diff --git a/.claude/commands/apple-container.md b/.claude/commands/apple-container.md
new file mode 100644
index 00000000000..ca6876ad530
--- /dev/null
+++ b/.claude/commands/apple-container.md
@@ -0,0 +1,46 @@
+---
+allowed-tools: Bash(container *), Bash(cargo *), Read, Grep, Glob
+---
+
+# Run Tests in Linux Container (Apple `container` CLI)
+
+Run RustPython tests inside a Linux container using Apple's `container` CLI.
+**NEVER use Docker, Podman, or any other container runtime.** Only use the `container` command.
+
+## Arguments
+- `$ARGUMENTS`: Test command to run (e.g., `test_io`, `test_codecs -v`, `test_io -v -m "test_errors"`)
+
+## Prerequisites
+
+The `container` CLI is installed via `brew install container`.
+The dev image `rustpython-dev` is already built.
+
+## Steps
+
+1. **Check if the container is already running**
+   ```shell
+   container list 2>/dev/null | grep rustpython-test
+   ```
+
+2. **Start the container if not running**
+   ```shell
+   container run -d --name rustpython-test -m 8G -c 4 \
+       --mount type=bind,source=/Users/al03219714/Projects/RustPython3,target=/workspace \
+       -w /workspace rustpython-dev sleep infinity
+   ```
+
+3. **Run the test inside the container**
+   ```shell
+   container exec rustpython-test sh -c "cargo run --release -- -m test $ARGUMENTS"
+   ```
+
+4. **Report results**
+   - Show test summary (pass/fail counts, expected failures, unexpected successes)
+   - Highlight any new failures compared to macOS results if available
+   - Do NOT stop or remove the container after testing (keep it for reuse)
+
+## Notes
+- The workspace is bind-mounted, so local code changes are immediately available
+- Use `container exec rustpython-test sh -c "..."` for any command inside the container
+- To rebuild after code changes, run: `container exec rustpython-test sh -c "cargo build --release"`
+- To stop the container when done: `container rm -f rustpython-test`
diff --git a/.claude/commands/investigate-test-failure.md b/.claude/commands/investigate-test-failure.md
new file mode 100644
index 00000000000..e9d6b2d2d2c
--- /dev/null
+++ b/.claude/commands/investigate-test-failure.md
@@ -0,0 +1,49 @@
+---
+allowed-tools: Bash(python3:*), Bash(cargo run:*), Read, Grep, Glob, Bash(git add:*), Bash(git commit:*), Bash(cargo fmt:*), Bash(git diff:*), Task
+---
+
+# Investigate Test Failure
+
+Investigate why a specific test is failing and determine if it can be fixed or needs an issue.
+
+## Arguments
+- `$ARGUMENTS`: Failed test identifier (e.g., `test_inspect.TestGetSourceBase.test_getsource_reload`)
+
+## Steps
+
+1. **Analyze failure cause**
+   - Read the test code
+   - Analyze failure message/traceback
+   - Check related RustPython code
+
+2. **Verify behavior in CPython**
+   - Run the test with `python3 -m unittest` to confirm expected behavior
+   - Document the expected output
+
+3. **Determine fix feasibility**
+   - **Simple fix** (import issues, small logic bugs): Fix code → Run `cargo fmt --all` → Pre-commit review → Commit
+   - **Complex fix** (major unimplemented features): Collect issue info and report to user
+
+   **Pre-commit review process**:
+   - Run `git diff` to see the changes
+   - Use Task tool with `general-purpose` subagent to review:
+     - Compare implementation against cpython/ source code
+     - Verify the fix aligns with CPython behavior
+     - Check for any missed edge cases
+   - Proceed to commit only after review passes
+
+4. **For complex issues - Collect issue information**
+   Following `.github/ISSUE_TEMPLATE/report-incompatibility.md` format:
+
+   - **Feature**: Description of missing/broken Python feature
+   - **Minimal reproduction code**: Smallest code that reproduces the issue
+   - **CPython behavior**: Result when running with python3
+   - **RustPython behavior**: Result when running with cargo run
+   - **Python Documentation link**: Link to relevant CPython docs
+
+   Report collected information to the user. Issue creation is done only upon user request.
+
+   Example issue creation command:
+   ```
+   gh issue create --template report-incompatibility.md --title "..." --body "..."
+   ```
diff --git a/.claude/commands/upgrade-pylib-next.md b/.claude/commands/upgrade-pylib-next.md
new file mode 100644
index 00000000000..712b79433b3
--- /dev/null
+++ b/.claude/commands/upgrade-pylib-next.md
@@ -0,0 +1,33 @@
+---
+allowed-tools: Skill(upgrade-pylib), Bash(gh pr list:*)
+---
+
+# Upgrade Next Python Library
+
+Find the next Python library module ready for upgrade and run `/upgrade-pylib` for it.
+
+## Current TODO Status
+
+!`cargo run --release -- scripts/update_lib todo 2>/dev/null`
+
+## Open Upgrade PRs
+
+!`gh pr list --search "Update in:title" --json number,title --template '{{range .}}#{{.number}} {{.title}}{{"\n"}}{{end}}'`
+
+## Instructions
+
+From the TODO list above, find modules matching these patterns (in priority order):
+
+1. `[ ] [no deps]` - Modules with no dependencies (can be upgraded immediately)
+2. `[ ] [0/n]` - Modules where all dependencies are already upgraded (e.g., `[0/3]`, `[0/5]`)
+
+These patterns indicate modules that are ready to upgrade without blocking dependencies.
+
+**Important**: Skip any modules that already have an open PR in the "Open Upgrade PRs" list above.
+
+**After identifying a suitable module**, run:
+```
+/upgrade-pylib <module_name>
+```
+
+If no modules match these criteria, inform the user that all eligible modules have dependencies that need to be upgraded first.
diff --git a/.claude/commands/upgrade-pylib.md b/.claude/commands/upgrade-pylib.md
index ba4cef525ab..d54305d2616 100644
--- a/.claude/commands/upgrade-pylib.md
+++ b/.claude/commands/upgrade-pylib.md
@@ -1,3 +1,7 @@
+---
+allowed-tools: Bash(git add:*), Bash(git commit:*), Bash(python3 scripts/update_lib quick:*), Bash(python3 scripts/update_lib auto-mark:*)
+---
+
 # Upgrade Python Library from CPython
 
 Upgrade a Python standard library module from CPython to RustPython.
@@ -23,24 +27,19 @@ This helps improve the tooling for future upgrades.
 
 ## 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 (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)
+1. **Run quick upgrade with update_lib**
+   - Run: `python3 scripts/update_lib quick $ARGUMENTS` (module name)
+   - Or: `python3 scripts/update_lib quick cpython/Lib/$ARGUMENTS.py` (library file path)
+   - Or: `python3 scripts/update_lib quick cpython/Lib/$ARGUMENTS/` (library directory path)
    - This will:
+     - Copy library files (delete existing `Lib/$ARGUMENTS.py` or `Lib/$ARGUMENTS/`, then copy from `cpython/Lib/`)
      - 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.
+     - Create a git commit with the changes
+   - **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 2 or added in step 3.
 
-4. **Review git diff and restore RUSTPYTHON-specific changes**
+2. **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
@@ -49,13 +48,46 @@ This helps improve the tooling for future upgrades.
    - **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:
+3. **Investigate test failures with subagent**
+   - First, get dependent tests using the deps command:
+     ```
+     cargo run --release -- scripts/update_lib deps $ARGUMENTS
+     ```
+   - Look for the line `- [ ] $ARGUMENTS: test_xxx test_yyy ...` to get the direct dependent tests
+   - Run those tests to collect failures:
+     ```
+     cargo run --release -- -m test test_xxx test_yyy ... 2>&1 | grep -E "^(FAIL|ERROR):"
+     ```
+   - For example, if deps output shows `- [ ] linecache: test_bdb test_inspect test_linecache test_traceback test_zipimport`, run:
+     ```
+     cargo run --release -- -m test test_bdb test_inspect test_linecache test_traceback test_zipimport 2>&1 | grep -E "^(FAIL|ERROR):"
+     ```
+   - For each failure, use the Task tool with `general-purpose` subagent to investigate:
+     - Subagent should follow the `/investigate-test-failure` skill workflow
+     - Pass the failed test identifier as the argument (e.g., `test_inspect.TestGetSourceBase.test_getsource_reload`)
+   - If subagent can fix the issue easily: fix and commit
+   - If complex issue: subagent collects issue info and reports back (issue creation on user request only)
+   - Using subagent prevents context pollution in the main conversation
+
+4. **Mark remaining test failures with auto-mark**
+   - Run: `python3 scripts/update_lib auto-mark Lib/test/test_$ARGUMENTS.py --mark-failure`
+   - Or for directory: `python3 scripts/update_lib auto-mark Lib/test/test_$ARGUMENTS/ --mark-failure`
+   - This will:
+     - Run tests and mark ALL failing tests with `@unittest.expectedFailure`
+     - Remove `@unittest.expectedFailure` from tests that now pass
+   - **Note**: The `--mark-failure` flag marks all failures including regressions. Review the changes before committing.
+
+5. **Handle panics manually**
+   - If any tests cause panics/crashes (not just assertion failures), they need `@unittest.skip` instead:
+     ```python
+     @unittest.skip("TODO: RUSTPYTHON; panics with 'index out of bounds'")
+     def test_crashes(self):
+         ...
+     ```
+   - auto-mark cannot detect panics automatically - check the test output for crash messages
+
+6. **Handle class-specific failures**
+   - If a test fails only in the C implementation (TestCFoo) but passes in the Python implementation (TestPyFoo), or vice versa, move the marker to the specific subclass:
      ```python
      # Base class - no marker here
      class TestFoo:
@@ -70,25 +102,21 @@ This helps improve the tooling for future upgrades.
          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):
-         ...
-     ```
+7. **Commit the test fixes**
+   - Run: `git add -u && git commit -m "Mark failing tests"`
+   - This creates a separate commit for the test markers added in steps 2-6
 
 ## Example Usage
 ```
+# Using module names (recommended)
 /upgrade-pylib inspect
 /upgrade-pylib json
 /upgrade-pylib asyncio
+
+# Using library paths (alternative)
+/upgrade-pylib cpython/Lib/inspect.py
+/upgrade-pylib cpython/Lib/json/
 ```
 
 ## Example: Restoring RUSTPYTHON changes
diff --git a/.claude/scripts/setup-env.sh b/.claude/scripts/setup-env.sh
new file mode 100755
index 00000000000..f5d28a3f14c
--- /dev/null
+++ b/.claude/scripts/setup-env.sh
@@ -0,0 +1,50 @@
+#!/bin/bash
+# Claude Code web session startup script
+# Sets up the development environment for RustPython
+
+set -e
+
+cd /home/user/RustPython
+
+echo "=== RustPython dev environment setup ==="
+
+# 1. Ensure python3 points to 3.13+ (needed for scripts/update_lib)
+#    /usr/local/bin takes precedence over /usr/bin in PATH,
+#    so we update the symlink there directly.
+CURRENT_PY=$(python3 --version 2>&1 | grep -oP '\d+\.\d+')
+if [ "$(printf '%s\n' "3.13" "$CURRENT_PY" | sort -V | head -1)" != "3.13" ]; then
+    echo "Upgrading python3 default to 3.13..."
+    # Find best available Python >= 3.13
+    TARGET=""
+    for ver in python3.14 python3.13; do
+        if command -v "$ver" &>/dev/null; then
+            TARGET=$(command -v "$ver")
+            break
+        fi
+    done
+    if [ -n "$TARGET" ]; then
+        # Override /usr/local/bin/python3 if it exists and is outdated
+        if [ -e /usr/local/bin/python3 ]; then
+            sudo ln -sf "$TARGET" /usr/local/bin/python3
+        fi
+        # Also set /usr/bin via update-alternatives
+        sudo update-alternatives --install /usr/bin/python3 python3 "$TARGET" 3 2>/dev/null || true
+        sudo update-alternatives --set python3 "$TARGET" 2>/dev/null || true
+        echo "python3 now: $(python3 --version)"
+    else
+        echo "WARNING: No Python 3.13+ found. scripts/update_lib may not work."
+    fi
+else
+    echo "python3 already >= 3.13: $(python3 --version)"
+fi
+
+# 2. Clone CPython source if not present (needed for scripts/update_lib)
+if [ ! -d "cpython" ]; then
+    echo "Cloning CPython v3.14.3 (shallow)..."
+    git clone --depth 1 --branch v3.14.3 https://github.com/python/cpython.git cpython
+    echo "CPython source ready."
+else
+    echo "CPython source already present."
+fi
+
+echo "=== Setup complete ==="
diff --git a/.claude/settings.json b/.claude/settings.json
new file mode 100644
index 00000000000..22f0a9a8a01
--- /dev/null
+++ b/.claude/settings.json
@@ -0,0 +1,15 @@
+{
+  "hooks": {
+    "SessionStart": [
+      {
+        "matcher": "",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "bash .claude/scripts/setup-env.sh"
+          }
+        ]
+      }
+    ]
+  }
+}
diff --git a/.cspell.dict/cpython.txt b/.cspell.dict/cpython.txt
index 7574d45c5f1..38e8656c3b2 100644
--- a/.cspell.dict/cpython.txt
+++ b/.cspell.dict/cpython.txt
@@ -10,7 +10,10 @@ badcert
 badsyntax
 baseinfo
 basetype
+binop
+bltin
 boolop
+BUFMAX
 BUILDSTDLIB
 bxor
 byteswap
@@ -25,18 +28,25 @@ carg
 cellarg
 cellvar
 cellvars
+ceval
 cfield
 CLASSDEREF
 classdict
 cmpop
 codedepth
 CODEUNIT
+CONIN
+CONOUT
+constevaluator
+consti
 CONVFUNC
 convparam
 copyslot
 cpucount
+datastack
 defaultdict
 denom
+deopt
 dictbytype
 DICTFLAG
 dictoffset
@@ -47,6 +57,8 @@ eofs
 evalloop
 excepthandler
 exceptiontable
+fastlocal
+fastlocals
 fblock
 fblocks
 fdescr
@@ -55,8 +67,11 @@ fielddesc
 fieldlist
 fileutils
 finalbody
+finalizers
+firsttraceable
 flowgraph
 formatfloat
+freelist
 freevar
 freevars
 fromlist
@@ -72,6 +87,7 @@ HASPOINTER
 HASSTRUCT
 HASUNION
 heaptype
+hexdigit
 HIGHRES
 IFUNC
 IMMUTABLETYPE
@@ -93,6 +109,7 @@ lineiterator
 linetable
 loadfast
 localsplus
+localspluskinds
 Lshift
 lsprof
 MAXBLOCKS
@@ -101,7 +118,9 @@ metavars
 miscompiles
 mult
 multibytecodec
+nameobj
 nameop
+ncells
 nconsts
 newargs
 newfree
@@ -110,6 +129,7 @@ newsemlockobject
 nfrees
 nkwargs
 nkwelts
+nlocalsplus
 Nondescriptor
 noninteger
 nops
@@ -135,11 +155,14 @@ prec
 preinitialized
 pybuilddir
 pycore
+pyinner
 pydecimal
 Pyfunc
+pylifecycle
 pymain
 pyrepl
 PYTHONTRACEMALLOC
+PYTHONUTF8
 pythonw
 PYTHREAD_NAME
 releasebuffer
@@ -147,16 +170,21 @@ repr
 resinfo
 Rshift
 SA_ONSTACK
+saveall
 scls
 setdict
 setfunc
+setprofileallthreads
 SETREF
 setresult
 setslice
+settraceallthreads
 SLOTDEFINED
+SMALLBUF
 SOABI
 SSLEOF
 stackdepth
+stackref
 staticbase
 stginfo
 storefast
@@ -167,10 +195,14 @@ subparams
 subscr
 sval
 swappedbytes
+sysdict
 templatelib
+testconsole
+threadstate
 ticketer
 tmptype
 tok_oldval
+tstate
 tvars
 typeobject
 typeparam
@@ -178,9 +210,11 @@ Typeparam
 typeparams
 typeslots
 unaryop
+uncollectable
 Unhandle
 unparse
 unparser
+untracking
 VARKEYWORDS
 varkwarg
 venvlauncher
@@ -190,8 +224,11 @@ venvwlauncher
 venvwlaunchert
 wbits
 weakreflist
+weakrefobject
 webpki
+winconsoleio
 withitem
 withs
+worklist
 xstat
 XXPRIME
diff --git a/.cspell.dict/python-more.txt b/.cspell.dict/python-more.txt
index 2dd31f8f579..2ce5d246d72 100644
--- a/.cspell.dict/python-more.txt
+++ b/.cspell.dict/python-more.txt
@@ -1,8 +1,10 @@
 abiflags
 abstractmethods
+addcompare
 aenter
 aexit
 aiter
+altzone
 anext
 anextawaitable
 annotationlib
@@ -24,6 +26,7 @@ breakpointhook
 cformat
 chunksize
 classcell
+classmethods
 closefd
 closesocket
 codepoint
@@ -32,6 +35,8 @@ codesize
 contextvar
 cpython
 cratio
+ctype
+ctypes
 dealloc
 debugbuild
 decompressor
@@ -74,6 +79,8 @@ fstring
 fstrings
 ftruncate
 genexpr
+genexpressions
+getargs
 getattro
 getcodesize
 getdefaultencoding
@@ -83,14 +90,17 @@ getformat
 getframe
 getframemodulename
 getnewargs
+getopt
 getpip
 getrandom
 getrecursionlimit
 getrefcount
 getsizeof
 getswitchinterval
+getweakref
 getweakrefcount
 getweakrefs
+getweakrefs
 getwindowsversion
 gmtoff
 groupdict
@@ -103,8 +113,12 @@ idxs
 impls
 indexgroup
 infj
+inittab
+Inittab
 instancecheck
 instanceof
+interpchannels
+interpqueues
 irepeat
 isabstractmethod
 isbytes
@@ -129,6 +143,7 @@ listcomp
 longrange
 lvalue
 mappingproxy
+markupbase
 maskpri
 maxdigits
 MAXGROUPS
@@ -144,6 +159,7 @@ mformat
 mro
 mros
 multiarch
+mymodule
 namereplace
 nanj
 nbytes
@@ -156,6 +172,7 @@ nlocals
 NOARGS
 nonbytes
 Nonprintable
+onceregistry
 origname
 ospath
 pendingcr
@@ -170,7 +187,10 @@ profilefunc
 pycache
 pycodecs
 pycs
+pydatetime
 pyexpat
+pyio
+pymain
 PYTHONAPI
 PYTHONBREAKPOINT
 PYTHONDEBUG
@@ -220,10 +240,13 @@ scproxy
 seennl
 setattro
 setcomp
+setprofileallthreads
 setrecursionlimit
 setswitchinterval
+settraceallthreads
 showwarnmsg
 signum
+sitebuiltins
 slotnames
 STACKLESS
 stacklevel
@@ -232,14 +255,17 @@ startpos
 subclassable
 subclasscheck
 subclasshook
+subclassing
 suboffset
 suboffsets
 SUBPATTERN
+subpatterns
 sumprod
 surrogateescape
 surrogatepass
 sysconf
 sysconfigdata
+sysdict
 sysvars
 teedata
 thisclass
@@ -266,35 +292,10 @@ warnopts
 weaklist
 weakproxy
 weakrefs
+weakrefset
 winver
 withdata
 xmlcharrefreplace
 xoptions
 xopts
 yieldfrom
-addcompare
-altzone
-classmethods
-ctype
-ctypes
-genexpressions
-getargs
-getopt
-getweakref
-getweakrefs
-inittab
-Inittab
-interpchannels
-interpqueues
-markupbase
-mymodule
-pydatetime
-pyio
-pymain
-setprofileallthreads
-settraceallthreads
-sitebuiltins
-subclassing
-subpatterns
-sysdict
-weakrefset
diff --git a/.cspell.dict/rust-more.txt b/.cspell.dict/rust-more.txt
index c3ebd61833a..c4457723c6c 100644
--- a/.cspell.dict/rust-more.txt
+++ b/.cspell.dict/rust-more.txt
@@ -5,7 +5,9 @@ biguint
 bindgen
 bitand
 bitflags
+bitflagset
 bitor
+bitvec
 bitxor
 bstr
 byteorder
@@ -58,6 +60,7 @@ powi
 prepended
 punct
 replacen
+retag
 rmatch
 rposition
 rsplitn
@@ -89,5 +92,3 @@ widestring
 winapi
 winresource
 winsock
-bitvec
-Bitvec
diff --git a/.cspell.dict/rustpython.txt b/.cspell.dict/rustpython.txt
new file mode 100644
index 00000000000..8cd08358019
--- /dev/null
+++ b/.cspell.dict/rustpython.txt
@@ -0,0 +1,32 @@
+cfgs
+miri
+py
+pyarg
+pyargs
+pyast
+pyattr
+pyclass
+pyclassmethod
+pyexception
+pyfunction
+pygetset
+pyimpl
+pylib
+pymath
+pymethod
+pymodule
+pyname
+pyobj
+pyobject
+pypayload
+pyref
+pyslot
+pystaticmethod
+pystone
+pystr
+pystruct
+pystructseq
+pytype
+rustix
+struc
+zelf
diff --git a/.cspell.json b/.cspell.json
index ebed8664e58..b7efb2e2311 100644
--- a/.cspell.json
+++ b/.cspell.json
@@ -9,6 +9,7 @@
     "@cspell/dict-win32/cspell-ext.json",
     "@cspell/dict-shell/cspell-ext.json",
   ],
+  "allowCompoundWords": true,
   // language - current active spelling language
   "language": "en",
   // dictionaries - list of the names of the dictionaries to use
@@ -16,6 +17,7 @@
     "cpython",  // Sometimes keeping same terms with cpython is easy
     "python-more",  // Python API terms not listed in python
     "rust-more",  // Rust API terms not listed in rust
+    "rustpython",  // RustPython derive macros and internal terms
     "en_US",
     "softwareTerms",
     "c",
@@ -38,6 +40,10 @@
     {
       "name": "rust-more",
       "path": "./.cspell.dict/rust-more.txt"
+    },
+    {
+      "name": "rustpython",
+      "path": "./.cspell.dict/rustpython.txt"
     }
   ],
   "ignorePaths": [
@@ -46,108 +52,42 @@
     "Lib/**"
   ],
   // words - list of words to be always considered correct
+  // (compound words like pyarg, baseclass, microbenchmark are handled by allowCompoundWords)
   "words": [
-    "RUSTPYTHONPATH",
-    // RustPython terms
     "aiterable",
     "alnum",
-    "baseclass",
-    "boxvec",
-    "Bytecode",
-    "cfgs",
-    "codegen",
     "coro",
     "dedentations",
     "dedents",
     "deduped",
-    "downcastable",
-    "downcasted",
-    "dumpable",
+    "deoptimize",
     "emscripten",
     "excs",
-    "finalizer",
-    "GetSet",
-    "groupref",
-    "internable",
     "interps",
     "jitted",
     "jitting",
+    "kwonly",
     "lossily",
-    "makeunicodedata",
-    "microbenchmark",
-    "microbenchmarks",
-    "miri",
-    "notrace",
+    "mcache",
     "oparg",
-    "openat",
-    "pyarg",
-    "pyargs",
-    "pyast",
-    "PyAttr",
+    "opargs",
     "pyc",
-    "PyClass",
-    "PyClassMethod",
-    "PyException",
-    "PyFunction",
-    "pygetset",
-    "pyimpl",
-    "pylib",
-    "pymath",
-    "pymember",
-    "PyMethod",
-    "PyModule",
-    "pyname",
-    "pyobj",
-    "PyObject",
-    "pypayload",
-    "PyProperty",
-    "pyref",
-    "PyResult",
-    "pyslot",
-    "PyStaticMethod",
-    "pystone",
-    "pystr",
-    "pystruct",
-    "pystructseq",
-    "pytrace",
-    "pytype",
-    "reducelib",
-    "richcompare",
-    "RustPython",
     "significand",
-    "struc",
-    "summands", // plural of summand
-    "sysmodule",
-    "tracebacks",
-    "typealiases",
-    "unhashable",
-    "uninit",
+    "summands",
     "unraisable",
-    "unresizable",
-    "varint",
     "wasi",
-    "zelf",
+    "weaked",
     // unix
     "posixshmem",
     "shm",
     "CLOEXEC",
-    "codeset",
     "endgrent",
     "gethrvtime",
     "getrusage",
-    "nanosleep",
     "sigaction",
-    "sighandler",
     "WRLCK",
     // win32
-    "birthtime",
-    "IFEXEC",
-    // "stat"
-    "FIRMLINK",
-    // CPython internal names
-    "sysdict",
-    "settraceallthreads",
-    "setprofileallthreads"
+    "IFEXEC"
   ],
   // flagWords - list of words to be always considered incorrect
   "flagWords": [
diff --git a/.gitattributes b/.gitattributes
index d1dd182a9b0..d076a34f977 100644
--- a/.gitattributes
+++ b/.gitattributes
@@ -4,5 +4,67 @@ Cargo.lock  linguist-generated
 vm/src/stdlib/ast/gen.rs    linguist-generated -merge
 Lib/*.py    text working-tree-encoding=UTF-8 eol=LF
 **/*.rs     text working-tree-encoding=UTF-8 eol=LF
-*.pck       binary
 crates/rustpython_doc_db/src/*.inc.rs   linguist-generated=true
+
+# Binary data types
+*.aif binary
+*.aifc binary
+*.aiff binary
+*.au binary
+*.bmp binary
+*.exe binary
+*.icns binary
+*.gif binary
+*.ico binary
+*.jpg binary
+*.pck binary
+*.pdf binary
+*.png binary
+*.psd binary
+*.tar binary
+*.wav binary
+*.whl binary
+*.zip binary
+
+# Text files that should not be subject to eol conversion
+[attr]noeol -text
+
+Lib/test/cjkencodings/*                    noeol
+Lib/test/tokenizedata/coding20731.py       noeol
+Lib/test/decimaltestdata/*.decTest         noeol
+Lib/test/test_email/data/*.txt             noeol
+Lib/test/xmltestdata/*                     noeol
+
+# Shell scripts should have LF even on Windows because of Cygwin
+Lib/venv/scripts/common/activate text eol=lf
+Lib/venv/scripts/posix/* text eol=lf
+
+# CRLF files
+[attr]dos text eol=crlf
+
+# Language aware diff headers
+# https://tekin.co.uk/2020/10/better-git-diff-output-for-ruby-python-elixir-and-more
+# https://gist.github.com/tekin/12500956bd56784728e490d8cef9cb81
+*.css   diff=css
+*.html  diff=html
+*.py    diff=python
+*.md    diff=markdown
+
+# Generated files
+# https://github.com/github/linguist/blob/master/docs/overrides.md
+#
+# To always hide generated files in local diffs, mark them as binary:
+# $ git config diff.generated.binary true
+#
+[attr]generated linguist-generated=true diff=generated
+
+Lib/_opcode_metadata.py                             generated
+Lib/keyword.py                                      generated
+Lib/idlelib/help.html                               generated
+Lib/test/certdata/*.pem                             generated
+Lib/test/certdata/*.0                               generated
+Lib/test/levenshtein_examples.json                  generated
+Lib/test/test_stable_abi_ctypes.py                  generated
+Lib/token.py                                        generated
+
+.github/workflows/*.lock.yml linguist-generated=true merge=ours
\ No newline at end of file
diff --git a/.github/actions/install-linux-deps/action.yml b/.github/actions/install-linux-deps/action.yml
new file mode 100644
index 00000000000..7900060fb29
--- /dev/null
+++ b/.github/actions/install-linux-deps/action.yml
@@ -0,0 +1,49 @@
+# This action installs a few dependencies necessary to build RustPython on Linux.
+# It can be configured depending on which libraries are needed:
+#
+# ```
+# - uses: ./.github/actions/install-linux-deps
+#   with:
+#     gcc-multilib: true
+#     musl-tools: false
+# ```
+#
+# See the `inputs` section for all options and their defaults. Note that you must checkout the
+# repository before you can use this action.
+#
+# This action will only install dependencies when the current operating system is Linux. It will do
+# nothing on any other OS (macOS, Windows).
+
+name: Install Linux dependencies
+description: Installs the dependencies necessary to build RustPython on Linux.
+inputs:
+  gcc-multilib:
+    description: Install gcc-multilib (gcc-multilib)
+    required: false
+    default: "false"
+  musl-tools:
+    description: Install musl-tools (musl-tools)
+    required: false
+    default: "false"
+  gcc-aarch64-linux-gnu:
+    description: Install gcc-aarch64-linux-gnu (gcc-aarch64-linux-gnu)
+    required: false
+    default: "false"
+  clang:
+    description: Install clang (clang)
+    required: false
+    default: "false"
+runs:
+  using: composite
+  steps:
+    - name: Install Linux dependencies
+      shell: bash
+      if: ${{ runner.os == 'Linux' }}
+      run: >
+        sudo apt-get update
+
+        sudo apt-get install --no-install-recommends
+        ${{ fromJSON(inputs.gcc-multilib) && 'gcc-multilib' || '' }}
+        ${{ fromJSON(inputs.musl-tools) && 'musl-tools' || '' }}
+        ${{ fromJSON(inputs.clang) && 'clang' || '' }}
+        ${{ fromJSON(inputs.gcc-aarch64-linux-gnu) && 'gcc-aarch64-linux-gnu linux-libc-dev-arm64-cross libc6-dev-arm64-cross' || '' }}
diff --git a/.github/actions/install-macos-deps/action.yml b/.github/actions/install-macos-deps/action.yml
new file mode 100644
index 00000000000..46abef197a4
--- /dev/null
+++ b/.github/actions/install-macos-deps/action.yml
@@ -0,0 +1,47 @@
+# This action installs a few dependencies necessary to build RustPython on macOS. By default it installs
+# autoconf, automake and libtool, but can be configured depending on which libraries are needed:
+#
+# ```
+# - uses: ./.github/actions/install-macos-deps
+#   with:
+#     openssl: true
+#     libtool: false
+# ```
+#
+# See the `inputs` section for all options and their defaults. Note that you must checkout the
+# repository before you can use this action.
+#
+# This action will only install dependencies when the current operating system is macOS. It will do
+# nothing on any other OS (Linux, Windows).
+
+name: Install macOS dependencies
+description: Installs the dependencies necessary to build RustPython on macOS.
+inputs:
+  autoconf:
+    description: Install autoconf (autoconf)
+    required: false
+    default: "true"
+  automake:
+    description: Install automake (automake)
+    required: false
+    default: "true"
+  libtool:
+    description: Install libtool (libtool)
+    required: false
+    default: "true"
+  openssl:
+    description: Install openssl (openssl@3)
+    required: false
+    default: "false"
+runs:
+  using: composite
+  steps:
+    - name: Install macOS dependencies
+      shell: bash
+      if: ${{ runner.os == 'macOS' }}
+      run: >
+        brew install
+        ${{ fromJSON(inputs.autoconf) && 'autoconf' || '' }}
+        ${{ fromJSON(inputs.automake) && 'automake' || '' }}
+        ${{ fromJSON(inputs.libtool) && 'libtool' || '' }}
+        ${{ fromJSON(inputs.openssl) && 'openssl@3' || '' }}
diff --git a/.github/aw/actions-lock.json b/.github/aw/actions-lock.json
new file mode 100644
index 00000000000..ad986cbd051
--- /dev/null
+++ b/.github/aw/actions-lock.json
@@ -0,0 +1,14 @@
+{
+  "entries": {
+    "actions/github-script@v8": {
+      "repo": "actions/github-script",
+      "version": "v8",
+      "sha": "ed597411d8f924073f98dfc5c65a23a2325f34cd"
+    },
+    "github/gh-aw/actions/setup@v0.43.22": {
+      "repo": "github/gh-aw/actions/setup",
+      "version": "v0.43.22",
+      "sha": "fe858c3e14589bf396594a0b106e634d9065823e"
+    }
+  }
+}
diff --git a/.github/dependabot.yml b/.github/dependabot.yml
index b3b7b446e4a..4995153001e 100644
--- a/.github/dependabot.yml
+++ b/.github/dependabot.yml
@@ -1,15 +1,167 @@
+# cspell:ignore manyhow tinyvec zeroize
 version: 2
 updates:
   - package-ecosystem: cargo
     directory: /
     schedule:
       interval: weekly
+    cooldown:
+      default-days: 7
+      semver-major-days: 30
+      semver-minor-days: 7
+      semver-patch-days: 3
+    groups:
+      criterion:
+        patterns:
+          - "criterion*"
+      crypto:
+        patterns:
+          - "digest"
+          - "md-5"
+          - "sha-1"
+          - "sha2"
+          - "sha3"
+          - "blake2"
+          - "hmac"
+          - "pbkdf2"
+      futures:
+        patterns:
+          - "futures*"
+      get-size2:
+        patterns:
+          - "get-size*2"
+      iana-time-zone:
+        patterns:
+          - "iana-time-zone*"
+      jiff:
+        patterns:
+          - "jiff*"
+      lexical:
+        patterns:
+          - "lexical*"
+      libffi:
+        patterns:
+          - "libffi*"
+      malachite:
+        patterns:
+          - "malachite*"
+      manyhow:
+        patterns:
+          - "manyhow*"
+      num:
+        patterns:
+          - "num-bigint"
+          - "num-complex"
+          - "num-integer"
+          - "num-iter"
+          - "num-rational"
+          - "num-traits"
+      num_enum:
+        patterns:
+          - "num_enum*"
+      openssl:
+        patterns:
+          - "openssl*"
+      parking_lot:
+        patterns:
+          - "parking_lot*"
+      phf:
+        patterns:
+          - "phf*"
+      plotters:
+        patterns:
+          - "plotters*"
+      portable-atomic:
+        patterns:
+          - "portable-atomic*"
+      pyo3:
+        patterns:
+          - "pyo3*"
+      quote-use:
+        patterns:
+          - "quote-use*"
+      random:
+        patterns:
+          - "getrandom"
+          - "mt19937"
+          - "rand*"
+      rayon:
+        patterns:
+          - "rayon*"
+      regex:
+        patterns:
+          - "regex*"
+      result-like:
+        patterns:
+          - "result-like*"
+      security-framework:
+        patterns:
+          - "security-framework*"
+      serde:
+        patterns:
+          - "serde"
+          - "serde_core"
+          - "serde_derive"
+      system-configuration:
+        patterns:
+          - "system-configuration*"
+      thiserror:
+        patterns:
+          - "thiserror*"
+      time:
+        patterns:
+          - "time*"
+      tinyvec:
+        patterns:
+          - "tinyvec*"
+      tls_codec:
+        patterns:
+          - "tls_codec*"
+      toml:
+        patterns:
+          - "toml*"
+      wasm-bindgen:
+        patterns:
+          - "wasm-bindgen*"
+      wasmtime:
+        patterns:
+          - "cranelift*"
+          - "wasmtime*"
+      webpki-root:
+        patterns:
+          - "webpki-root*"
+      windows:
+        patterns:
+          - "windows*"
+      zerocopy:
+        patterns:
+          - "zerocopy*"
+      zeroize:
+        patterns:
+          - "zeroize*"
     ignore:
       # TODO: Remove when we use ruff from crates.io
       # for some reason dependabot only updates the Cargo.lock file when dealing
       # with git dependencies. i.e. not updating the version in Cargo.toml
-      - dependency-name: "ruff_*" 
+      - dependency-name: "ruff_*"
   - package-ecosystem: github-actions
     directory: /
     schedule:
       interval: weekly
+    cooldown:
+      default-days: 7
+  - package-ecosystem: npm
+    directory: /
+    schedule:
+      interval: weekly
+    cooldown:
+      default-days: 7
+      semver-major-days: 30
+      semver-minor-days: 7
+      semver-patch-days: 3
+  - package-ecosystem: pre-commit
+    directory: /
+    schedule:
+      interval: weekly
+    cooldown:
+      default-days: 7
diff --git a/.github/workflows/ci.yaml b/.github/workflows/ci.yaml
index 74db871139c..04983981966 100644
--- a/.github/workflows/ci.yaml
+++ b/.github/workflows/ci.yaml
@@ -8,119 +8,66 @@ on:
 
 name: CI
 
+permissions:
+  contents: read
+
 # Cancel previous workflows if they are the same workflow on same ref (branch/tags)
 # with the same event (push/pull_request) even they are in progress.
 # This setting will help reduce the number of duplicated workflows.
 concurrency:
-  group: ${{ github.workflow }}-${{ github.ref }}-${{ github.event_name }}
+  group: ${{ github.workflow }}-${{ github.ref_name }}-${{ github.event.pull_request.number || github.sha }}
   cancel-in-progress: true
 
 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
+  CARGO_ARGS: --no-default-features --features stdlib,importlib,stdio,encodings,sqlite,ssl-rustls,host_env
+  CARGO_ARGS_NO_SSL: --no-default-features --features stdlib,importlib,stdio,encodings,sqlite,host_env
   # 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
-  # test_posixpath: OSError: (22, 'The filename, directory name, or volume label syntax is incorrect. (os error 123)')
-  # test_venv: couple of failing tests
-  WINDOWS_SKIPS: >-
-    test_asyncio
-    test_glob
-    test_rlcompleter
-    test_pathlib
-    test_posixpath
-    test_venv
-  # PLATFORM_INDEPENDENT_TESTS are tests that do not depend on the underlying OS. They are currently
-  # only run on Linux to speed up the CI.
-  PLATFORM_INDEPENDENT_TESTS: >-
-    test__colorize
-    test_array
-    test_asyncgen
-    test_binop
-    test_bisect
-    test_bool
-    test_bytes
-    test_call
-    test_class
-    test_cmath
-    test_collections
-    test_complex
-    test_contains
-    test_copy
-    test_dataclasses
-    test_decimal
-    test_decorators
-    test_defaultdict
-    test_deque
-    test_dict
-    test_dictcomps
-    test_dictviews
-    test_dis
-    test_enumerate
-    test_exception_variations
-    test_float
-    test_format
-    test_fractions
-    test_genericalias
-    test_genericclass
-    test_grammar
-    test_range
-    test_index
-    test_int
-    test_int_literal
-    test_isinstance
-    test_iter
-    test_iterlen
-    test_itertools
-    test_json
-    test_keyword
-    test_keywordonlyarg
-    test_list
-    test_long
-    test_longexp
-    test_math
-    test_operator
-    test_ordered_dict
-    test_pow
-    test_raise
-    test_richcmp
-    test_scope
-    test_set
-    test_slice
-    test_sort
-    test_string
-    test_string_literals
-    test_strtod
-    test_structseq
-    test_subclassinit
-    test_super
-    test_syntax
-    test_tuple
-    test_types
-    test_unary
-    test_unpack
-    test_weakref
-    test_yield_from
-  ENV_POLLUTING_TESTS_COMMON: >-
-  ENV_POLLUTING_TESTS_LINUX: >-
-    test.test_multiprocessing_fork.test_processes
-    test.test_multiprocessing_forkserver.test_processes
-    test.test_multiprocessing_spawn.test_processes
-  ENV_POLLUTING_TESTS_MACOS: >-
-    test.test_multiprocessing_forkserver.test_processes
-    test.test_multiprocessing_spawn.test_processes
-  ENV_POLLUTING_TESTS_WINDOWS: >-
-  # Python version targeted by the CI.
-  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
+  CARGO_INCREMENTAL: 0
+  CARGO_TERM_COLOR: always
 
 jobs:
+  determine_changes:
+    name: Determine changes
+    runs-on: ubuntu-latest
+    outputs:
+      # Flag that is raised when any rust code is changed.
+      rust_code: ${{ steps.check_rust_code.outputs.changed }}
+    steps:
+      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+        with:
+          fetch-depth: 0
+          persist-credentials: false
+
+      - name: Determine merge base
+        id: merge_base
+        run: |
+          sha=$(git merge-base HEAD "origin/${BASE_REF}")
+          echo "sha=${sha}" >> "$GITHUB_OUTPUT"
+        env:
+          BASE_REF: ${{ github.event.pull_request.base.ref || 'main' }}
+
+      - name: Check if there was any code related change
+        id: check_rust_code
+        run: |
+          if git diff --quiet "${MERGE_BASE}...HEAD" -- \
+            ':!Lib/**' \
+            ':!scripts/**' \
+            ':!extra_tests/**' \
+            ':.github/workflows/ci.yaml' \
+          ; then
+              echo "changed=false" >> "$GITHUB_OUTPUT"
+          else
+              echo "changed=true" >> "$GITHUB_OUTPUT"
+          fi
+        env:
+          MERGE_BASE: ${{ steps.merge_base.outputs.sha }}
+
   rust_tests:
     if: ${{ !contains(github.event.pull_request.labels.*.name, 'skip:ci') }}
     env:
@@ -133,29 +80,46 @@ jobs:
         os: [macos-latest, ubuntu-latest, windows-2025]
       fail-fast: false
     steps:
-      - uses: actions/checkout@v6.0.2
+      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+        with:
+          persist-credentials: false
+
       - uses: dtolnay/rust-toolchain@stable
         with:
           components: clippy
-      - uses: Swatinem/rust-cache@v2
 
-      - name: Set up the Mac environment
-        run: brew install autoconf automake libtool
-        if: runner.os == 'macOS'
+      - uses: Swatinem/rust-cache@c19371144df3bb44fab255c43d04cbc2ab54d1c4 # v2.9.1
+        with:
+          save-if: ${{ github.ref == 'refs/heads/main' }}
+
+      - name: Install macOS dependencies
+        uses: ./.github/actions/install-macos-deps
 
       - name: run clippy
         run: cargo clippy ${{ env.CARGO_ARGS }} --workspace --all-targets ${{ env.WORKSPACE_EXCLUDES }} -- -Dwarnings
 
       - name: run rust tests
         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 ${{ env.WORKSPACE_EXCLUDES }} --exclude rustpython-jit --verbose --features threading ${{ env.CARGO_ARGS }}
-        if: runner.os == 'macOS'
 
       - name: check compilation without threading
         run: cargo check ${{ env.CARGO_ARGS }}
 
+      - run: cargo doc --locked
+        if: runner.os == 'Linux'
+
+      - name: check compilation without host_env (sandbox mode)
+        run: |
+          cargo check -p rustpython-vm --no-default-features --features compiler
+          cargo check -p rustpython-stdlib --no-default-features --features compiler
+          cargo build --no-default-features --features stdlib,importlib,stdio,encodings,freeze-stdlib
+        if: runner.os == 'Linux'
+
+      - name: sandbox smoke test
+        run: |
+          target/debug/rustpython extra_tests/snippets/sandbox_smoke.py
+          target/debug/rustpython extra_tests/snippets/stdlib_re.py
+        if: runner.os == 'Linux'
+
       - name: Test openssl build
         run: cargo build --no-default-features --features ssl-openssl
         if: runner.os == 'Linux'
@@ -180,87 +144,81 @@ jobs:
           PYTHONPATH: scripts
         if: runner.os == 'Linux'
 
-      - name: prepare Intel MacOS build
-        uses: dtolnay/rust-toolchain@stable
-        with:
+  cargo_check:
+    name: cargo check
+    runs-on: ${{ matrix.os }}
+    needs:
+      - determine_changes
+    if: |
+      !contains(github.event.pull_request.labels.*.name, 'skip:ci') &&
+      needs.determine_changes.outputs.rust_code == 'true'
+    strategy:
+      matrix:
+        include: 
+        - os: ubuntu-latest
+          target: aarch64-linux-android
+        - os: ubuntu-latest
+          target: i686-unknown-linux-gnu
+          dependencies:
+            gcc-multilib: true
+        - os: ubuntu-latest
+          target: i686-unknown-linux-musl
+          dependencies:
+            musl-tools: true
+        - os: ubuntu-latest
+          target: wasm32-wasip2
+        - os: ubuntu-latest
+          target: x86_64-unknown-freebsd
+        - os: ubuntu-latest
+          target: aarch64-unknown-linux-gnu
+          dependencies:
+            gcc-aarch64-linux-gnu: true
+        - os: macos-latest
+          target: aarch64-apple-ios
+        - os: macos-latest
           target: x86_64-apple-darwin
-        if: runner.os == 'macOS'
-      - 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
+      fail-fast: false
+    steps:
+      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
         with:
-          target: aarch64-apple-ios
-        if: runner.os == 'macOS'
-      - name: Check compilation for iOS
-        run: cargo check --target aarch64-apple-ios ${{ env.CARGO_ARGS_NO_SSL }}
-        if: runner.os == 'macOS'
+          persist-credentials: false
 
-  exotic_targets:
-    if: ${{ !contains(github.event.pull_request.labels.*.name, 'skip:ci') }}
-    name: Ensure compilation on various targets
-    runs-on: ubuntu-latest
-    timeout-minutes: 30
-    steps:
-      - uses: actions/checkout@v6.0.2
-      - uses: dtolnay/rust-toolchain@stable
+      - name: Install dependencies
+        uses: ./.github/actions/install-linux-deps
+        # zizmor has an issue with dynamic `with`
+        # with: ${{ matrix.dependencies || fromJSON('{}') }}
         with:
-          target: i686-unknown-linux-gnu
+          gcc-multilib: ${{ matrix.dependencies.gcc-multilib || false }}
+          musl-tools: ${{ matrix.dependencies.musl-tools || false }}
+          gcc-aarch64-linux-gnu: ${{ matrix.dependencies.gcc-aarch64-linux-gnu || false }}
 
-      - name: Install gcc-multilib and musl-tools
-        run: sudo apt-get update && sudo apt-get install gcc-multilib musl-tools
-      - name: Check compilation for x86 32bit
-        run: cargo check --target i686-unknown-linux-gnu ${{ env.CARGO_ARGS_NO_SSL }}
+      - name: Restore cache
+        uses: actions/cache/restore@668228422ae6a00e4ad889ee87cd7109ec5666a7 # v5.0.4
+        if: ${{ github.ref != 'refs/heads/main' }} # Never restore on main
+        with:
+          path: |
+            ~/.cargo/bin/
+            ~/.cargo/registry/index/
+            ~/.cargo/registry/cache/
+            ~/.cargo/git/db/
+            target/
+          # key won't match, will rely on restore-keys
+          key: cargo-check-${{ runner.os }}-${{ matrix.target }}
+          restore-keys: |
+            cargo-check-${{ runner.os }}-${{ matrix.target }}-
 
       - uses: dtolnay/rust-toolchain@stable
         with:
-          target: aarch64-linux-android
+          target: ${{ matrix.target }}
 
       - name: Setup Android NDK
+        if: ${{ matrix.target == 'aarch64-linux-android' }}
         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:
-          target: aarch64-unknown-linux-gnu
-
-      - name: Install gcc-aarch64-linux-gnu
-        run: sudo apt install gcc-aarch64-linux-gnu
-      - name: Check compilation for aarch64 linux gnu
-        run: cargo check --target aarch64-unknown-linux-gnu ${{ env.CARGO_ARGS_NO_SSL }}
-
-      - uses: dtolnay/rust-toolchain@stable
-        with:
-          target: i686-unknown-linux-musl
-
-      - name: Check compilation for musl
-        run: cargo check --target i686-unknown-linux-musl ${{ env.CARGO_ARGS_NO_SSL }}
-
-      - uses: dtolnay/rust-toolchain@stable
-        with:
-          target: x86_64-unknown-freebsd
-
-      - name: Check compilation for freebsd
-        run: cargo check --target x86_64-unknown-freebsd ${{ env.CARGO_ARGS_NO_SSL }}
-
-      - uses: dtolnay/rust-toolchain@stable
-        with:
-          target: x86_64-unknown-freebsd
-
-      - name: Check compilation for freeBSD
-        run: cargo check --target x86_64-unknown-freebsd ${{ env.CARGO_ARGS_NO_SSL }}
-
       # - name: Prepare repository for redox compilation
       #   run: bash scripts/redox/uncomment-cargo.sh
       # - name: Check compilation for Redox
@@ -269,149 +227,139 @@ jobs:
       #     command: check
       #     args: --ignore-rust-version
 
+      - name: Check compilation
+        run: cargo check --target "${{ matrix.target }}" ${{ 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
+
+      - name: Save cache
+        if: ${{ github.ref == 'refs/heads/main' }} # only save on main
+        uses: actions/cache/save@668228422ae6a00e4ad889ee87cd7109ec5666a7 # v5.0.4
+        with:
+          path: |
+            ~/.cargo/bin/
+            ~/.cargo/registry/index/
+            ~/.cargo/registry/cache/
+            ~/.cargo/git/db/
+            target/
+          key: cargo-check-${{ runner.os }}-${{ matrix.target }}-${{ hashFiles('**/Cargo.toml') }}-${{ hashFiles('Cargo.lock') }}-${{ github.sha }}
+
   snippets_cpython:
     if: ${{ !contains(github.event.pull_request.labels.*.name, 'skip:ci') }}
     env:
       RUST_BACKTRACE: full
+      # Tests that can be flaky when running with multiple processes `-j 2`. We will use `-j 1` for these.
+      FLAKY_MP_TESTS: >-
+        test_class
+        test_concurrent_futures
+        test_eintr
+        test_multiprocessing_fork
+        test_multiprocessing_forkserver
+        test_multiprocessing_spawn
     name: Run snippets and cpython tests
     runs-on: ${{ matrix.os }}
     strategy:
       matrix:
-        os: [macos-latest, ubuntu-latest, windows-2025]
+        include:
+        - os: macos-latest
+          extra_test_args:
+            - '-u all'
+          env_polluting_tests: []
+          skips: []
+          timeout: 50
+        - os: ubuntu-latest
+          extra_test_args:
+            - '-u all'
+          env_polluting_tests: []
+          skips: []
+          timeout: 60
+        - os: windows-2025
+          extra_test_args: [] # TODO: Enable '-u all'
+          env_polluting_tests: []
+          skips:
+            - test_rlcompleter
+            - test_pathlib # panic by surrogate chars
+            - test_posixpath # OSError: (22, 'The filename, directory name, or volume label syntax is incorrect. (os error 123)')
+            - test_venv # couple of failing tests
+          timeout: 50
       fail-fast: false
     steps:
-      - uses: actions/checkout@v6.0.2
+      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+        with:
+          persist-credentials: false
+
       - uses: dtolnay/rust-toolchain@stable
-      - uses: Swatinem/rust-cache@v2
-      - uses: actions/setup-python@v6.2.0
+
+      - uses: Swatinem/rust-cache@c19371144df3bb44fab255c43d04cbc2ab54d1c4 # v2.9.1
         with:
-          python-version: ${{ env.PYTHON_VERSION }}
-      - name: Set up the Mac environment
-        run: brew install autoconf automake libtool openssl@3
-        if: runner.os == 'macOS'
-      - name: build rustpython
-        run: cargo build --release --verbose --features=threading ${{ env.CARGO_ARGS }}
-        if: runner.os == 'macOS'
-      - name: build rustpython
-        run: cargo build --release --verbose --features=threading ${{ env.CARGO_ARGS }},jit
-        if: runner.os != 'macOS'
-      - uses: actions/setup-python@v6.2.0
+          save-if: ${{ github.ref == 'refs/heads/main' }}
+
+      - uses: actions/setup-python@a309ff8b426b58ec0e2a45f0f869d46889d02405 # v6.2.0
+
+      - name: Install macOS dependencies
+        uses: ./.github/actions/install-macos-deps
         with:
-          python-version: ${{ env.PYTHON_VERSION }}
+          openssl: true
+
+      - name: build rustpython
+        run: cargo build --release --verbose --features=threading,jit ${{ env.CARGO_ARGS }}
+
       - name: run snippets
         run: python -m pip install -r requirements.txt && pytest -v
         working-directory: ./extra_tests
 
-      - 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: 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: 45
+      - name: Detect available cores
+        id: cores
+        shell: bash
+        run: |
+          cores=$(python -c 'print(__import__("os").process_cpu_count())')
+          echo "cores=${cores}" >> "$GITHUB_OUTPUT"
 
-      - if: runner.os == 'macOS'
-        name: run cpython platform-dependent tests (MacOS)
+      - name: Run CPython tests
+        run: |
+          target/release/rustpython -m test -j ${{ steps.cores.outputs.cores }} ${{ join(matrix.extra_test_args, ' ') }} --slowest --fail-env-changed --timeout 600 -v -x ${{ env.FLAKY_MP_TESTS }} ${{ join(matrix.skips, ' ') }}
+        timeout-minutes: ${{ matrix.timeout }}
         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: 45
 
-      - if: runner.os == 'Windows'
-        name: run cpython platform-dependent tests (windows partial - fixme)
+      - name: Run flaky MP CPython tests
+        run: |
+          target/release/rustpython -m test -j 1 ${{ join(matrix.extra_test_args, ' ') }} --slowest --fail-env-changed --timeout 600 -v ${{ env.FLAKY_MP_TESTS }}
+        timeout-minutes: ${{ matrix.timeout }}
         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)
+      - name: run cpython tests to check if env polluters have stopped polluting
         shell: bash
         run: |
-          for thing in ${{ env.ENV_POLLUTING_TESTS_COMMON }} ${{ env.ENV_POLLUTING_TESTS_LINUX }}; do
-            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 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
-        timeout-minutes: 15
+          IFS=' ' read -r -a target_array <<< "$TARGETS"
 
-      - 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 thing in "${target_array[@]}"; do
             for i in $(seq 1 10); do
               set +e
-              target/release/rustpython -m test -j 1 --slowest --fail-env-changed --timeout 600 -v ${thing}
+              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
+              if [ "${exit_code}" -eq 3 ]; then
                 echo "Test ${thing} polluted the environment on attempt ${i}."
                 break
               fi
             done
-            if [ ${exit_code} -ne 3 ]; then
+            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 remove ${thing} from matrix.env_polluting_tests 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
-        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
-            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 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
+              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
+        env:
+          TARGETS: ${{ join(matrix.env_polluting_tests, ' ') }}
         timeout-minutes: 15
 
       - if: runner.os != 'Windows'
@@ -420,70 +368,82 @@ jobs:
           mkdir site-packages
           target/release/rustpython --install-pip ensurepip --user
           target/release/rustpython -m pip install six
+
       - name: Check that ensurepip succeeds.
         run: |
           target/release/rustpython -m ensurepip
           target/release/rustpython -c "import pip"
+
       - if: runner.os != 'Windows'
         name: Check if pip inside venv is functional
         run: |
           target/release/rustpython -m venv testvenv
           testvenv/bin/rustpython -m pip install wheel
-      - if: runner.os != 'macOS'
-        name: Check whats_left is not broken
-        shell: bash
-        run: python -I scripts/whats_left.py --no-default-features --features "$(sed -e 's/--[^ ]*//g' <<< "${{ env.CARGO_ARGS }}" | tr -d '[:space:]'),threading,jit"
-      - if: runner.os == 'macOS' # TODO fix jit on macOS
-        name: Check whats_left is not broken (macOS)
+
+      - name: Check whats_left is not broken
         shell: bash
-        run: python -I scripts/whats_left.py --no-default-features --features "$(sed -e 's/--[^ ]*//g' <<< "${{ env.CARGO_ARGS }}" | tr -d '[:space:]'),threading" # no jit on macOS for now
+        run: python -I scripts/whats_left.py ${{ env.CARGO_ARGS }} --features jit
 
   lint:
-    name: Check Rust code with clippy
+    name: Lint
     runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      checks: write
+      pull-requests: write
+      security-events: write # for zizmor
     steps:
-      - uses: actions/checkout@v6.0.2
-      - uses: dtolnay/rust-toolchain@stable
+      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
         with:
-          components: clippy
+          persist-credentials: false
 
-      - name: run clippy on wasm
-        run: cargo clippy --manifest-path=crates/wasm/Cargo.toml -- -Dwarnings
+      - uses: actions/setup-python@a309ff8b426b58ec0e2a45f0f869d46889d02405 # v6.2.0
+
+      - uses: dtolnay/rust-toolchain@stable
+        with:
+          components: rustfmt
 
-      - name: Ensure docs generate no warnings
-        run: cargo doc --locked
+      - uses: cargo-bins/cargo-binstall@0b24824336e2b3800b0f89d9e08b2c08bfa3dcdd # v1.17.9
 
-      - name: Ensure Lib/_opcode_metadata is updated
+      - name: cargo shear
         run: |
-          python scripts/generate_opcode_metadata.py
-          if [ -n "$(git status --porcelain)" ]; then
-            exit 1
-          fi
+          cargo binstall --no-confirm cargo-shear
+          cargo shear
 
-      - name: Install ruff
-        uses: astral-sh/ruff-action@57714a7c8a2e59f32539362ba31877a1957dded1 # v3.5.1
-        with:
-          version: "0.14.11"
-          args: "--version"
+      - name: actionlint
+        uses: reviewdog/action-actionlint@0d952c597ef8459f634d7145b0b044a9699e5e43 # v1.71.0
 
-      - run: ruff check --diff
+      - name: zizmor
+        uses: zizmorcore/zizmor-action@71321a20a9ded102f6e9ce5718a2fcec2c4f70d8 # v0.5.2
 
-      - run: ruff format --check
+      - name: restore prek cache
+        if: ${{ github.ref != 'refs/heads/main' }} # never restore on main
+        uses: actions/cache/restore@668228422ae6a00e4ad889ee87cd7109ec5666a7 # v5.0.4
+        with:
+          key: prek-${{ hashFiles('.pre-commit-config.yaml') }}
+          path: ~/.cache/prek
 
-      - name: install prettier
-        run: yarn global add prettier && echo "$(yarn global bin)" >>$GITHUB_PATH
+      - name: prek
+        id: prek
+        uses: j178/prek-action@53276d8b0d10f8b6672aa85b4588c6921d0370cc # v2.0.1
+        with:
+          cache: false
+          show-verbose-logs: false
+        continue-on-error: true
 
-      - name: check wasm code with prettier
-        # prettier doesn't handle ignore files very well: https://github.com/prettier/prettier/issues/8506
-        run: cd wasm && git ls-files -z | xargs -0 prettier --check -u
-      # Keep cspell check as the last step. This is optional test.
-      - name: install extra dictionaries
-        run: npm install @cspell/dict-en_us @cspell/dict-cpp @cspell/dict-python @cspell/dict-rust @cspell/dict-win32 @cspell/dict-shell
-      - name: spell checker
-        uses: streetsidesoftware/cspell-action@v8
+      - name: save prek cache
+        if: ${{ github.ref == 'refs/heads/main' }} # only save on main
+        uses: actions/cache/save@668228422ae6a00e4ad889ee87cd7109ec5666a7 # v5.0.4
         with:
-          files: "**/*.rs"
-          incremental_files_only: true
+          key: prek-${{ hashFiles('.pre-commit-config.yaml') }}
+          path: ~/.cache/prek
+
+      - name: reviewdog
+        uses: reviewdog/action-suggester@aa38384ceb608d00f84b4690cacc83a5aba307ff # 1.24.0
+        with:
+          level: warning
+          fail_level: error
+          cleanup: false
 
   miri:
     if: ${{ !contains(github.event.pull_request.labels.*.name, 'skip:ci') }}
@@ -493,14 +453,18 @@ jobs:
     env:
       NIGHTLY_CHANNEL: nightly
     steps:
-      - uses: actions/checkout@v6.0.2
+      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+        with:
+          persist-credentials: false
 
       - uses: dtolnay/rust-toolchain@master
         with:
           toolchain: ${{ env.NIGHTLY_CHANNEL }}
           components: miri
 
-      - uses: Swatinem/rust-cache@v2
+      - uses: Swatinem/rust-cache@c19371144df3bb44fab255c43d04cbc2ab54d1c4 # v2.9.1
+        with:
+          save-if: ${{ github.ref == 'refs/heads/main' }}
 
       - name: Run tests under miri
         run: cargo +${{ env.NIGHTLY_CHANNEL }} miri test -p rustpython-vm -- miri_test
@@ -515,10 +479,21 @@ jobs:
     runs-on: ubuntu-latest
     timeout-minutes: 30
     steps:
-      - uses: actions/checkout@v6.0.2
+      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+        with:
+          persist-credentials: false
+
       - uses: dtolnay/rust-toolchain@stable
+        with:
+          components: clippy
+
+      - uses: Swatinem/rust-cache@c19371144df3bb44fab255c43d04cbc2ab54d1c4 # v2.9.1
+        with:
+          save-if: ${{ github.ref == 'refs/heads/main' }}
+
+      - name: cargo clippy
+        run: cargo clippy --manifest-path=crates/wasm/Cargo.toml -- -Dwarnings
 
-      - uses: Swatinem/rust-cache@v2
       - name: install wasm-pack
         run: curl https://rustwasm.github.io/wasm-pack/installer/init.sh -sSf | sh
       - name: install geckodriver
@@ -526,18 +501,19 @@ jobs:
           wget https://github.com/mozilla/geckodriver/releases/download/v0.36.0/geckodriver-v0.36.0-linux64.tar.gz
           mkdir geckodriver
           tar -xzf geckodriver-v0.36.0-linux64.tar.gz -C geckodriver
-      - uses: actions/setup-python@v6.2.0
-        with:
-          python-version: ${{ env.PYTHON_VERSION }}
+
+      - uses: actions/setup-python@a309ff8b426b58ec0e2a45f0f869d46889d02405 # v6.2.0
+
       - run: python -m pip install -r requirements.txt
         working-directory: ./wasm/tests
-      - uses: actions/setup-node@v6
+      - uses: actions/setup-node@53b83947a5a98c8d113130e565377fae1a50d02f # v6.3.0
         with:
           cache: "npm"
           cache-dependency-path: "wasm/demo/package-lock.json"
       - name: run test
         run: |
-          export PATH=$PATH:`pwd`/../../geckodriver
+          driver_path="$(pwd)/../../geckodriver"
+          export PATH="$PATH:${driver_path}"
           npm install
           npm run test
         env:
@@ -578,19 +554,29 @@ jobs:
     runs-on: ubuntu-latest
     timeout-minutes: 30
     steps:
-      - uses: actions/checkout@v6.0.2
+      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+        with:
+          persist-credentials: false
+
       - uses: dtolnay/rust-toolchain@stable
         with:
           target: wasm32-wasip1
 
-      - uses: Swatinem/rust-cache@v2
+      - uses: Swatinem/rust-cache@c19371144df3bb44fab255c43d04cbc2ab54d1c4 # v2.9.1
+        with:
+          save-if: ${{ github.ref == 'refs/heads/main' }}
+
       - name: Setup Wasmer
         uses: wasmerio/setup-wasmer@v3
+
       - name: Install clang
-        run: sudo apt-get update && sudo apt-get install clang -y
+        uses: ./.github/actions/install-linux-deps
+        with:
+          clang: true
+
       - name: build rustpython
         run: cargo build --release --target wasm32-wasip1 --features freeze-stdlib,stdlib --verbose
       - name: run snippets
-        run: wasmer run --dir `pwd` target/wasm32-wasip1/release/rustpython.wasm -- `pwd`/extra_tests/snippets/stdlib_random.py
+        run: wasmer run --dir "$(pwd)" target/wasm32-wasip1/release/rustpython.wasm -- "$(pwd)/extra_tests/snippets/stdlib_random.py"
       - name: run cpython unittest
-        run: wasmer run --dir `pwd` target/wasm32-wasip1/release/rustpython.wasm -- `pwd`/Lib/test/test_int.py
+        run: wasmer run --dir "$(pwd)" target/wasm32-wasip1/release/rustpython.wasm -- "$(pwd)/Lib/test/test_int.py"
diff --git a/.github/workflows/comment-commands.yml b/.github/workflows/comment-commands.yml
index 3f3402270ea..eb9e2f96d1a 100644
--- a/.github/workflows/comment-commands.yml
+++ b/.github/workflows/comment-commands.yml
@@ -18,4 +18,6 @@ jobs:
     steps:
       # Using REST API and not `gh issue edit`. https://github.com/cli/cli/issues/6235#issuecomment-1243487651
       - run: |
-          curl -H "Authorization: token ${{ github.token }}" -d '{"assignees": ["${{ github.event.comment.user.login }}"]}' https://api.github.com/repos/${{ github.repository }}/issues/${{ github.event.issue.number }}/assignees
+          curl -H "Authorization: token ${{ github.token }}" -d '{"assignees": ["${{ env.USER }}"]}' https://api.github.com/repos/${{ github.repository }}/issues/${{ github.event.issue.number }}/assignees
+        env:
+          USER:  ${{ github.event.comment.user.login }}
diff --git a/.github/workflows/cron-ci.yaml b/.github/workflows/cron-ci.yaml
index 0a546595a8c..2e648e12cb7 100644
--- a/.github/workflows/cron-ci.yaml
+++ b/.github/workflows/cron-ci.yaml
@@ -12,8 +12,7 @@ on:
 name: Periodic checks/tasks
 
 env:
-  CARGO_ARGS: --no-default-features --features stdlib,importlib,encodings,ssl-rustls,jit
-  PYTHON_VERSION: "3.14.2"
+  CARGO_ARGS: --no-default-features --features stdlib,importlib,stdio,encodings,ssl-rustls,jit,host_env
 
 jobs:
   # codecov collects code coverage data from the rust tests, python snippets and python test suite.
@@ -24,15 +23,18 @@ jobs:
     # Disable this scheduled job when running on a fork.
     if: ${{ github.repository == 'RustPython/RustPython' || github.event_name != 'schedule' }}
     steps:
-      - uses: actions/checkout@v6.0.2
+      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+        with:
+          persist-credentials: false
+
       - uses: dtolnay/rust-toolchain@stable
       - uses: taiki-e/install-action@cargo-llvm-cov
-      - uses: actions/setup-python@v6.2.0
-        with:
-          python-version: ${{ env.PYTHON_VERSION }}
+
+      - uses: actions/setup-python@a309ff8b426b58ec0e2a45f0f869d46889d02405 # v6.2.0
+
       - 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 --exclude rustpython-compiler-source --exclude rustpython-venvlauncher --verbose --no-default-features --features stdlib,importlib,encodings,ssl-rustls,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,stdio,encodings,ssl-rustls,jit,host_env
       - name: Run cargo-llvm-cov with Python snippets.
         run: python scripts/cargo-llvm-cov.py
         continue-on-error: true
@@ -45,7 +47,7 @@ jobs:
         if: ${{ github.event_name != 'pull_request' }}
         uses: codecov/codecov-action@v5
         with:
-          file: ./codecov.lcov
+          files: ./codecov.lcov
 
   testdata:
     name: Collect regression test data
@@ -53,7 +55,10 @@ jobs:
     # Disable this scheduled job when running on a fork.
     if: ${{ github.repository == 'RustPython/RustPython' || github.event_name != 'schedule' }}
     steps:
-      - uses: actions/checkout@v6.0.2
+      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+        with:
+          persist-credentials: true
+
       - uses: dtolnay/rust-toolchain@stable
       - name: build rustpython
         run: cargo build --release --verbose
@@ -85,11 +90,14 @@ jobs:
     # Disable this scheduled job when running on a fork.
     if: ${{ github.repository == 'RustPython/RustPython' || github.event_name != 'schedule' }}
     steps:
-      - uses: actions/checkout@v6.0.2
-      - uses: dtolnay/rust-toolchain@stable
-      - uses: actions/setup-python@v6.2.0
+      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
         with:
-          python-version: ${{ env.PYTHON_VERSION }}
+          persist-credentials: true
+
+      - uses: dtolnay/rust-toolchain@stable
+
+      - uses: actions/setup-python@a309ff8b426b58ec0e2a45f0f869d46889d02405 # v6.2.0
+
       - name: build rustpython
         run: cargo build --release --verbose
       - name: Collect what is left data
@@ -143,11 +151,14 @@ jobs:
     # Disable this scheduled job when running on a fork.
     if: ${{ github.repository == 'RustPython/RustPython' || github.event_name != 'schedule' }}
     steps:
-      - uses: actions/checkout@v6.0.2
-      - uses: dtolnay/rust-toolchain@stable
-      - uses: actions/setup-python@v6.2.0
+      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
         with:
-          python-version: ${{ env.PYTHON_VERSION }}
+          persist-credentials: true
+
+      - uses: dtolnay/rust-toolchain@stable
+
+      - uses: actions/setup-python@a309ff8b426b58ec0e2a45f0f869d46889d02405 # v6.2.0
+
       - run: cargo install cargo-criterion
       - name: build benchmarks
         run: cargo build --release --benches
@@ -158,12 +169,12 @@ jobs:
       - name: restructure generated files
         run: |
           cd ./target/criterion/reports
-          find -type d -name cpython | xargs rm -rf
-          find -type d -name rustpython | xargs rm -rf
-          find -mindepth 2 -maxdepth 2 -name violin.svg | xargs rm -rf
-          find -type f -not -name violin.svg | xargs rm -rf
-          for file in $(find -type f -name violin.svg); do mv $file $(echo $file | sed -E "s_\./([^/]+)/([^/]+)/violin\.svg_./\1/\2.svg_"); done
-          find -mindepth 2 -maxdepth 2 -type d | xargs rm -rf
+          find . -type d -name cpython -print0 | xargs -0 rm -rf
+          find . -type d -name rustpython -print0 | xargs -0 rm -rf
+          find . -mindepth 2 -maxdepth 2 -name violin.svg -print0 | xargs -0 rm -rf
+          find . -type f -not -name violin.svg -print0 | xargs -0 rm -rf
+          find . -type f -name violin.svg -exec sh -c 'for file; do mv "$file" "$(echo "$file" | sed -E "s_\./([^/]+)/([^/]+)/violin\.svg_./\1/\2.svg_")"; done' _ {} +
+          find . -mindepth 2 -maxdepth 2 -type d -print0 | xargs -0 rm -rf
           cd ..
           mv reports/* .
           rmdir reports
diff --git a/.github/workflows/lib-deps-check.yaml b/.github/workflows/lib-deps-check.yaml
index a4b7128d830..b009c427df7 100644
--- a/.github/workflows/lib-deps-check.yaml
+++ b/.github/workflows/lib-deps-check.yaml
@@ -4,10 +4,10 @@ on:
   pull_request_target:
     types: [opened, synchronize, reopened]
     paths:
-      - 'Lib/**'
+      - "Lib/**"
 
 concurrency:
-  group: lib-deps-${{ github.event.pull_request.number }}
+  group: ${{ github.workflow }}-${{ github.ref_name }}-${{ github.event.pull_request.number }}
   cancel-in-progress: true
 
 jobs:
@@ -18,11 +18,12 @@ jobs:
     timeout-minutes: 10
     steps:
       - name: Checkout base branch
-        uses: actions/checkout@v6.0.2
+        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
         with:
           # Use base branch for scripts (security: don't run PR code with elevated permissions)
           ref: ${{ github.event.pull_request.base.ref }}
           fetch-depth: 0
+          persist-credentials: false
 
       - name: Fetch PR head
         run: |
@@ -33,9 +34,20 @@ jobs:
           # Checkout only Lib/ directory from PR head for accurate comparison
           git checkout ${{ github.event.pull_request.head.sha }} -- Lib/
 
-      - name: Checkout CPython
+      - name: Get target CPython version
+        id: cpython-version
         run: |
-          git clone --depth 1 --branch v3.14.2 https://github.com/python/cpython.git cpython
+          version=$(cat .python-version)
+          echo "version=${version}" >> "$GITHUB_OUTPUT"
+
+      - name: Checkout CPython
+        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+        with:
+          repository: python/cpython
+          path: cpython
+          ref: "v${{ steps.cpython-version.outputs.version }}"
+          fetch-depth: 1
+          persist-credentials: false
 
       - name: Get changed Lib files
         id: changed-files
@@ -70,36 +82,26 @@ jobs:
 
       - name: Setup Python
         if: steps.changed-files.outputs.modules != ''
-        uses: actions/setup-python@v6.2.0
-        with:
-          python-version: "3.12"
+        uses: actions/setup-python@a309ff8b426b58ec0e2a45f0f869d46889d02405 # v6.2.0
 
       - name: Run deps check
         if: steps.changed-files.outputs.modules != ''
         id: deps-check
         run: |
           # Run deps for all modules at once
-          python scripts/update_lib deps ${{ steps.changed-files.outputs.modules }} --depth 2 > /tmp/deps_output.txt 2>&1 || true
-
-          # Read output for GitHub Actions
-          echo "deps_output<<EOF" >> $GITHUB_OUTPUT
-          cat /tmp/deps_output.txt >> $GITHUB_OUTPUT
-          echo "EOF" >> $GITHUB_OUTPUT
-
-          # Check if there's any meaningful output
-          if [ -s /tmp/deps_output.txt ]; then
-            echo "has_output=true" >> $GITHUB_OUTPUT
-          else
-            echo "has_output=false" >> $GITHUB_OUTPUT
-          fi
+          echo "deps_output<<EOF" >> "$GITHUB_OUTPUT"
+          output=$(python scripts/update_lib deps "${MODULES}"  --depth 2 2>&1 || true)
+          echo "$output" >> "$GITHUB_OUTPUT"
+          echo "EOF" >> "$GITHUB_OUTPUT"
+        env:
+          MODULES: ${{ steps.changed-files.outputs.modules }}
 
       - name: Post comment
-        if: steps.deps-check.outputs.has_output == 'true'
-        uses: marocchino/sticky-pull-request-comment@v2
+        if: steps.deps-check.outputs.deps_output != ''
+        uses: marocchino/sticky-pull-request-comment@v3
         with:
           header: lib-deps-check
           number: ${{ github.event.pull_request.number }}
-          recreate: true
           message: |
             ## 📦 Library Dependencies
 
@@ -113,7 +115,7 @@ jobs:
 
       - name: Remove comment if no Lib changes
         if: steps.changed-files.outputs.modules == ''
-        uses: marocchino/sticky-pull-request-comment@v2
+        uses: marocchino/sticky-pull-request-comment@v3
         with:
           header: lib-deps-check
           number: ${{ github.event.pull_request.number }}
diff --git a/.github/workflows/pr-auto-commit.yaml b/.github/workflows/pr-auto-commit.yaml
deleted file mode 100644
index f34dd724e4c..00000000000
--- a/.github/workflows/pr-auto-commit.yaml
+++ /dev/null
@@ -1,120 +0,0 @@
-name: Auto-format PR
-
-# This workflow triggers when a PR is opened/updated
-on:
-  pull_request_target:
-    types: [opened, synchronize, reopened]
-    branches:
-      - main
-      - release
-
-concurrency:
-  group: auto-format-${{ github.event.pull_request.number }}
-  cancel-in-progress: true
-
-jobs:
-  auto_format:
-    permissions:
-      contents: write
-      pull-requests: write
-    runs-on: ubuntu-latest
-    timeout-minutes: 60
-    steps:
-      - name: Checkout PR branch
-        uses: actions/checkout@v6.0.2
-        with:
-          ref: ${{ github.event.pull_request.head.sha }}
-          repository: ${{ github.event.pull_request.head.repo.full_name }}
-          token: ${{ secrets.AUTO_COMMIT_PAT }}
-          fetch-depth: 0
-
-      - name: Setup Rust
-        uses: dtolnay/rust-toolchain@stable
-        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
-        with:
-          version: "0.14.11"
-          args: "--version"
-
-      - 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: Run ruff check import sorting
-        run: |
-          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 [ "$(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: Push formatting changes
-        if: steps.check-changes.outputs.has_changes == 'true'
-        run: |
-          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
-        with:
-          number: ${{ github.event.pull_request.number }}
-          message: |
-            **Code has been automatically formatted**
-
-            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/.github/workflows/release.yml b/.github/workflows/release.yml
index 9a6d0ad9838..ae6c9da9b74 100644
--- a/.github/workflows/release.yml
+++ b/.github/workflows/release.yml
@@ -12,83 +12,83 @@ on:
         required: false
         default: true
 
-permissions:
-  contents: write
-
 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:
-    runs-on: ${{ matrix.platform.runner }}
+    runs-on: ${{ matrix.os }}
     # Disable this scheduled job when running on a fork.
     if: ${{ github.repository == 'RustPython/RustPython' || github.event_name != 'schedule' }}
     strategy:
       matrix:
-        platform:
-          - runner: ubuntu-latest
+        include:
+          - os: ubuntu-latest
             target: x86_64-unknown-linux-gnu
-#          - runner: ubuntu-latest
-#            target: i686-unknown-linux-gnu
-#          - runner: ubuntu-latest
-#            target: aarch64-unknown-linux-gnu
-#          - runner: ubuntu-latest
-#            target: armv7-unknown-linux-gnueabi
-#          - runner: ubuntu-latest
-#            target: s390x-unknown-linux-gnu
-#          - runner: ubuntu-latest
-#            target: powerpc64le-unknown-linux-gnu
-          - runner: macos-latest
+          - os: macos-latest
             target: aarch64-apple-darwin
-#          - runner: macos-latest
-#            target: x86_64-apple-darwin
-          - runner: windows-2025
+          - os: windows-2025
             target: x86_64-pc-windows-msvc
-#          - runner: windows-2025
-#            target: i686-pc-windows-msvc
-#          - runner: windows-2025
-#            target: aarch64-pc-windows-msvc
+          # - os: ubuntu-latest
+          #   target: i686-unknown-linux-gnu
+          # - os: ubuntu-latest
+          #   target: aarch64-unknown-linux-gnu
+          # - os: ubuntu-latest
+          #   target: armv7-unknown-linux-gnueabi
+          # - os: ubuntu-latest
+          #   target: s390x-unknown-linux-gnu
+          # - os: ubuntu-latest
+          #   target: powerpc64le-unknown-linux-gnu
+          # - os: macos-latest
+          #   target: x86_64-apple-darwin
+          # - os: windows-2025
+          #   target: i686-pc-windows-msvc
+          # - os: windows-2025
+          #   target: aarch64-pc-windows-msvc
       fail-fast: false
     steps:
-      - uses: actions/checkout@v6.0.2
+      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+        with:
+          persist-credentials: false
+
       - uses: dtolnay/rust-toolchain@stable
-      - uses: cargo-bins/cargo-binstall@main
+        with:
+          target: ${{ matrix.target }}
 
-      - name: Set up Environment
-        shell: bash
-        run: rustup target add ${{ matrix.platform.target }}
-      - name: Set up MacOS Environment
-        run: brew install autoconf automake libtool
-        if: runner.os == 'macOS'
+      - name: Install macOS dependencies
+        uses: ./.github/actions/install-macos-deps
+        with:
+          autoconf: true
+          automake: true
+          libtool: true
 
       - name: Build RustPython
-        run: cargo build --release --target=${{ matrix.platform.target }} --verbose --features=threading ${{ env.CARGO_ARGS }}
-        if: runner.os == 'macOS'
-      - name: Build RustPython
-        run: cargo build --release --target=${{ matrix.platform.target }} --verbose --features=threading ${{ env.CARGO_ARGS }},jit
-        if: runner.os != 'macOS'
+        run: cargo build --release --target=${{ matrix.target }} --verbose --no-default-features --features stdlib,stdio,importlib,encodings,sqlite,host_env,ssl-rustls,threading,jit
 
       - name: Rename Binary
-        run: cp target/${{ matrix.platform.target }}/release/rustpython target/rustpython-release-${{ runner.os }}-${{ matrix.platform.target }}
+        run: cp target/${{ matrix.target }}/release/rustpython target/rustpython-release-${{ runner.os }}-${{ matrix.target }}
         if: runner.os != 'Windows'
+
       - name: Rename Binary
-        run: cp target/${{ matrix.platform.target }}/release/rustpython.exe target/rustpython-release-${{ runner.os }}-${{ matrix.platform.target }}.exe
+        run: cp target/${{ matrix.target }}/release/rustpython.exe target/rustpython-release-${{ runner.os }}-${{ matrix.target }}.exe
         if: runner.os == 'Windows'
 
       - name: Upload Binary Artifacts
-        uses: actions/upload-artifact@v6.0.0
+        uses: actions/upload-artifact@bbbca2ddaa5d8feaa63e36b76fdaad77386f024f # v7.0.0
         with:
-          name: rustpython-release-${{ runner.os }}-${{ matrix.platform.target }}
-          path: target/rustpython-release-${{ runner.os }}-${{ matrix.platform.target }}*
+          name: rustpython-release-${{ runner.os }}-${{ matrix.target }}
+          path: target/rustpython-release-${{ runner.os }}-${{ matrix.target }}*
 
   build-wasm:
     runs-on: ubuntu-latest
     # Disable this scheduled job when running on a fork.
     if: ${{ github.repository == 'RustPython/RustPython' || github.event_name != 'schedule' }}
     steps:
-      - uses: actions/checkout@v6.0.2
+      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+        with:
+          persist-credentials: false
+
       - uses: dtolnay/rust-toolchain@stable
         with:
           targets: wasm32-wasip1
@@ -100,16 +100,22 @@ jobs:
         run: cp target/wasm32-wasip1/release/rustpython.wasm target/rustpython-release-wasm32-wasip1.wasm
 
       - name: Upload Binary Artifacts
-        uses: actions/upload-artifact@v6.0.0
+        uses: actions/upload-artifact@bbbca2ddaa5d8feaa63e36b76fdaad77386f024f # v7.0.0
         with:
           name: rustpython-release-wasm32-wasip1
           path: target/rustpython-release-wasm32-wasip1.wasm
 
       - name: install wasm-pack
         run: curl https://rustwasm.github.io/wasm-pack/installer/init.sh -sSf | sh
-      - uses: actions/setup-node@v6
-      - uses: mwilliamson/setup-wabt-action@v3
-        with: { wabt-version: "1.0.30" }
+
+      - uses: actions/setup-node@53b83947a5a98c8d113130e565377fae1a50d02f # v6.3.0
+        with:
+          package-manager-cache: false
+
+      - uses: mwilliamson/setup-wabt-action@febe2a12b7ccb999a6e5d953a8362a3b7ffcf148 # v3.2.0
+        with:
+          wabt-version: "1.0.30"
+
       - name: build demo
         run: |
           npm install
@@ -117,6 +123,7 @@ jobs:
         env:
           NODE_OPTIONS: "--openssl-legacy-provider"
         working-directory: ./wasm/demo
+
       - name: build notebook demo
         run: |
           npm install
@@ -125,8 +132,10 @@ jobs:
         env:
           NODE_OPTIONS: "--openssl-legacy-provider"
         working-directory: ./wasm/notebook
+
       - name: Deploy demo to Github Pages
-        uses: peaceiris/actions-gh-pages@v4
+        if: ${{ github.repository == 'RustPython/RustPython' }}
+        uses: peaceiris/actions-gh-pages@4f9cc6602d3f66b9c108549d475ec49e8ef4d45e # v4.0.0
         with:
           deploy_key: ${{ secrets.ACTIONS_DEMO_DEPLOY_KEY }}
           publish_dir: ./wasm/demo/dist
@@ -139,30 +148,28 @@ jobs:
     if: ${{ github.repository == 'RustPython/RustPython' || github.event_name != 'schedule' }}
     needs: [build, build-wasm]
     steps:
-      - uses: actions/checkout@v6.0.2
+      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+        with:
+          persist-credentials: false
 
       - name: Download Binary Artifacts
-        uses: actions/download-artifact@v7.0.0
+        uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c # v8.0.1
         with:
           path: bin
           pattern: rustpython-*
           merge-multiple: true
 
       - name: Create Lib Archive
-        run: |
-          zip -r bin/rustpython-lib.zip Lib/
+        run: zip -r bin/rustpython-lib.zip Lib/
 
       - name: List Binaries
         run: |
           ls -lah bin/
           file bin/*
+
       - name: Create Release
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-          tag: ${{ github.ref_name }}
-          run: ${{ github.run_number }}
         run: |
-          if [[ "${{ github.event.inputs.pre-release }}" == "false" ]]; then
+          if [[ "${PRE_RELEASE_INPUT}" == "false" ]]; then
             RELEASE_TYPE_NAME=Release
             PRERELEASE_ARG=
           else
@@ -179,3 +186,8 @@ jobs:
               --generate-notes \
               $PRERELEASE_ARG \
               bin/rustpython-release-*
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          tag: ${{ github.ref_name }}
+          run: ${{ github.run_number }}
+          PRE_RELEASE_INPUT: ${{ github.event.inputs.pre-release }}
diff --git a/.github/workflows/update-doc-db.yml b/.github/workflows/update-doc-db.yml
index 1fd3b930985..bcb766e0a35 100644
--- a/.github/workflows/update-doc-db.yml
+++ b/.github/workflows/update-doc-db.yml
@@ -1,7 +1,6 @@
 name: Update doc DB
 
-permissions:
-  contents: write
+permissions: {}
 
 on:
   workflow_dispatch:
@@ -9,11 +8,11 @@ on:
       python-version:
         description: Target python version to generate doc db for
         type: string
-        default: "3.14.2"
-      ref:
-        description: Branch to commit to (leave empty for current branch)
+        default: "3.14.3"
+      base-ref:
+        description: Base branch to create the update branch from
         type: string
-        default: ""
+        default: "main"
 
 defaults:
   run:
@@ -21,6 +20,8 @@ defaults:
 
 jobs:
   generate:
+    permissions:
+      contents: read
     runs-on: ${{ matrix.os }}
     strategy:
       matrix:
@@ -29,7 +30,7 @@ jobs:
           - windows-latest
           - macos-latest
     steps:
-      - uses: actions/checkout@0c366fd6a839edf440554fa01a7085ccba70ac98 # v6.0.1
+      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
         with:
           persist-credentials: false
           sparse-checkout: |
@@ -42,7 +43,7 @@ jobs:
       - name: Generate docs
         run: python crates/doc/generate.py
 
-      - uses: actions/upload-artifact@b7c566a772e6b6bfb58ed0dc250532a479d7789f # v6.0.0
+      - uses: actions/upload-artifact@bbbca2ddaa5d8feaa63e36b76fdaad77386f024f # v7.0.0
         with:
           name: doc-db-${{ inputs.python-version }}-${{ matrix.os }}
           path: "crates/doc/generated/*.json"
@@ -53,20 +54,30 @@ jobs:
   merge:
     runs-on: ubuntu-latest
     needs: generate
+    permissions:
+      contents: write
+      pull-requests: write
     steps:
-      - uses: actions/checkout@0c366fd6a839edf440554fa01a7085ccba70ac98 # v6.0.1
+      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
         with:
-          ref: ${{ inputs.ref || github.ref }}
-          token: ${{ secrets.AUTO_COMMIT_PAT }}
+          persist-credentials: true
+          ref: ${{ inputs.base-ref }}
+
+      - name: Create update branch
+        run: git switch -c "update-doc-${PYTHON_VERSION}"
+        env:
+          PYTHON_VERSION: ${{ inputs.python-version }}
 
       - name: Download generated doc DBs
-        uses: actions/download-artifact@37930b1c2abaa49bbe596cd826c3c89aef350131 # v7.0.0
+        uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c # v8.0.1
         with:
           pattern: "doc-db-${{ inputs.python-version }}-**"
           path: crates/doc/generated/
           merge-multiple: true
 
       - name: Transform JSON
+        env:
+          PYTHON_VERSION: ${{ inputs.python-version }}
         run: |
           # Merge all artifacts
           jq -s "add" --sort-keys crates/doc/generated/*.json > crates/doc/generated/merged.json
@@ -79,7 +90,7 @@ jobs:
           echo -n '' > $OUTPUT_FILE
 
           echo '// This file was auto-generated by `.github/workflows/update-doc-db.yml`.' >> $OUTPUT_FILE
-          echo "// CPython version: ${{ inputs.python-version }}" >> $OUTPUT_FILE
+          echo "// CPython version: ${PYTHON_VERSION}" >> $OUTPUT_FILE
           echo '// spell-checker: disable' >> $OUTPUT_FILE
 
           echo '' >> $OUTPUT_FILE
@@ -88,7 +99,7 @@ jobs:
           cat crates/doc/generated/raw_entries.txt >> $OUTPUT_FILE
           echo '};' >> $OUTPUT_FILE
 
-      - uses: actions/upload-artifact@b7c566a772e6b6bfb58ed0dc250532a479d7789f # v6.0.0
+      - uses: actions/upload-artifact@bbbca2ddaa5d8feaa63e36b76fdaad77386f024f # v7.0.0
         with:
           name: doc-db-${{ inputs.python-version }}
           path: "crates/doc/src/data.inc.rs"
@@ -96,13 +107,20 @@ jobs:
           retention-days: 7
           overwrite: true
 
-      - name: Commit and push (non-main branches only)
-        if: github.ref != 'refs/heads/main' && inputs.ref != 'main'
+      - name: Commit, push and create PR
+        env:
+          GH_TOKEN: ${{ github.token }}
+          PYTHON_VERSION: ${{ inputs.python-version }}
+          BASE_REF: ${{ inputs.base-ref }}
         run: |
           git config user.name "github-actions[bot]"
           git config user.email "github-actions[bot]@users.noreply.github.com"
           if [ -n "$(git status --porcelain)" ]; then
             git add crates/doc/src/data.inc.rs
-            git commit -m "Update doc DB for CPython ${{ inputs.python-version }}"
-            git push
+            git commit -m "Update doc DB for CPython ${PYTHON_VERSION}"
+            git push -u origin HEAD
+            gh pr create \
+              --base "${BASE_REF}" \
+              --title "Update doc DB for CPython ${PYTHON_VERSION}" \
+              --body "Auto-generated by update-doc-db workflow."
           fi
diff --git a/.github/workflows/update-libs-status.yaml b/.github/workflows/update-libs-status.yaml
new file mode 100644
index 00000000000..db32c7a3e94
--- /dev/null
+++ b/.github/workflows/update-libs-status.yaml
@@ -0,0 +1,96 @@
+name: Updated libs status
+
+on:
+  push:
+    branches:
+      - main
+    paths:
+      - "Lib/**"
+  workflow_dispatch:
+
+permissions:
+  contents: read
+  issues: write
+
+env:
+  ISSUE_ID: "6839"
+
+jobs:
+  update-issue:
+    runs-on: ubuntu-latest
+    if: ${{ github.repository == 'RustPython/RustPython' }}
+    steps:
+      - name: Clone RustPython
+        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+        with:
+          path: rustpython
+          persist-credentials: false
+          sparse-checkout: |-
+              Lib
+              scripts/update_lib
+              .python-version
+
+      - name: Get target CPython version
+        id: cpython-version
+        run: |
+          version=$(cat rustpython/.python-version)
+          echo "version=${version}" >> "$GITHUB_OUTPUT"
+
+      - name: Clone CPython
+        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+        with:
+          repository: python/cpython
+          path: cpython
+          ref: "v${{ steps.cpython-version.outputs.version }}"
+          persist-credentials: false
+          sparse-checkout: |
+            Lib
+
+      - name: Get current date
+        id: current_date
+        run: |
+          now=$(date -u +"%Y-%m-%d %H:%M:%S")
+          echo "date=$now" >> "$GITHUB_OUTPUT"
+
+      - name: Write body prefix
+        run: |
+          cat > body.txt <<EOF
+
+          <!-- 
+          THIS BODY IS AUTO-GENERATED. DO NOT EDIT MANUALLY!
+          -->
+
+          ## Summary
+
+          Check \`scripts/update_lib\` for tools. As a note, the current latest Python version is \`${{ steps.cpython-version.outputs.version }}\`.
+
+          Previous versions' issues as reference
+          - 3.13: #5529 
+
+          <!-- 
+          Quick guideline for Copilot:
+          # Clone \`github.com/python/cpython\` \`${{ steps.cpython-version.outputs.version }}\` tag under RustPython working dir with depth 1 option; never 3.14.0 or 3.14.1 or 3.14.2
+          # Pick a library or test to update. Probably user give one.
+          # Run \`python3 scripts/update_lib quick <name>\`
+          # A commit is automatically created. push the commit.
+          # Do not include keywords that automatically close an issue (e.g., Fix, Close, Resolve) next to an issue link or issue number.
+          -->
+
+          ## Details
+
+          ${{ steps.current_date.outputs.date }} (UTC)
+          \`\`\`shell
+          $ python3 scripts/update_lib todo --done
+          \`\`\`
+          EOF
+        
+      - name: Run todo
+        run: python3 rustpython/scripts/update_lib todo --cpython cpython --lib rustpython/Lib --done >> body.txt
+
+      - name: Update GH issue
+        run: gh issue edit ${{ env.ISSUE_ID }} --body-file ../body.txt
+        env:
+          GH_TOKEN: ${{ github.token }}
+        working-directory: rustpython
+        
+
diff --git a/.github/workflows/upgrade-pylib.lock.yml b/.github/workflows/upgrade-pylib.lock.yml
new file mode 100644
index 00000000000..1f4e42341e2
--- /dev/null
+++ b/.github/workflows/upgrade-pylib.lock.yml
@@ -0,0 +1,1093 @@
+#
+#    ___                   _   _      
+#   / _ \                 | | (_)     
+#  | |_| | __ _  ___ _ __ | |_ _  ___ 
+#  |  _  |/ _` |/ _ \ '_ \| __| |/ __|
+#  | | | | (_| |  __/ | | | |_| | (__ 
+#  \_| |_/\__, |\___|_| |_|\__|_|\___|
+#          __/ |
+#  _    _ |___/ 
+# | |  | |                / _| |
+# | |  | | ___ _ __ _  __| |_| | _____      ____
+# | |/\| |/ _ \ '__| |/ /|  _| |/ _ \ \ /\ / / ___|
+# \  /\  / (_) | | | | ( | | | | (_) \ V  V /\__ \
+#  \/  \/ \___/|_| |_|\_\|_| |_|\___/ \_/\_/ |___/
+#
+# This file was automatically generated by gh-aw (v0.43.22). DO NOT EDIT.
+#
+# To update this file, edit the corresponding .md file and run:
+#   gh aw compile
+# Not all edits will cause changes to this file.
+#
+# For more information: https://github.github.com/gh-aw/introduction/overview/
+#
+# Pick an out-of-sync Python library from the todo list and upgrade it
+# by running `scripts/update_lib quick`, then open a pull request.
+#
+# frontmatter-hash: 3129480d6628afe028911bb8b31b6bb3b5eb251e395f00ed0677922cd21727cb
+
+name: "Upgrade Python Library"
+"on":
+  workflow_dispatch:
+    inputs:
+      name:
+        description: Module name to upgrade (leave empty to auto-pick)
+        required: false
+        type: string
+
+permissions: {}
+
+concurrency:
+  group: "gh-aw-${{ github.workflow }}"
+
+run-name: "Upgrade Python Library"
+
+env:
+  ISSUE_ID: "6839"
+  PYTHON_VERSION: v3.14.3
+
+# Cache configuration from frontmatter was processed and added to the main job steps
+
+jobs:
+  activation:
+    runs-on: ubuntu-slim
+    permissions:
+      contents: read
+    outputs:
+      comment_id: ""
+      comment_repo: ""
+    steps:
+      - name: Setup Scripts
+        uses: github/gh-aw/actions/setup@48d8fdfddc8cad854ac0c70ceb573f09fb8f9c9b # v0.62.5
+        with:
+          destination: /opt/gh-aw/actions
+      - name: Check workflow file timestamps
+        uses: actions/github-script@ed597411d8f924073f98dfc5c65a23a2325f34cd # v8
+        env:
+          GH_AW_WORKFLOW_FILE: "upgrade-pylib.lock.yml"
+        with:
+          script: |
+            const { setupGlobals } = require('/opt/gh-aw/actions/setup_globals.cjs');
+            setupGlobals(core, github, context, exec, io);
+            const { main } = require('/opt/gh-aw/actions/check_workflow_timestamp_api.cjs');
+            await main();
+
+  agent:
+    needs: activation
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      issues: read
+      pull-requests: read
+    concurrency:
+      group: "gh-aw-copilot-${{ github.workflow }}"
+    env:
+      DEFAULT_BRANCH: ${{ github.event.repository.default_branch }}
+      GH_AW_ASSETS_ALLOWED_EXTS: ""
+      GH_AW_ASSETS_BRANCH: ""
+      GH_AW_ASSETS_MAX_SIZE_KB: 0
+      GH_AW_MCP_LOG_DIR: /tmp/gh-aw/mcp-logs/safeoutputs
+      GH_AW_SAFE_OUTPUTS: /opt/gh-aw/safeoutputs/outputs.jsonl
+      GH_AW_SAFE_OUTPUTS_CONFIG_PATH: /opt/gh-aw/safeoutputs/config.json
+      GH_AW_SAFE_OUTPUTS_TOOLS_PATH: /opt/gh-aw/safeoutputs/tools.json
+    outputs:
+      checkout_pr_success: ${{ steps.checkout-pr.outputs.checkout_pr_success || 'true' }}
+      has_patch: ${{ steps.collect_output.outputs.has_patch }}
+      model: ${{ steps.generate_aw_info.outputs.model }}
+      output: ${{ steps.collect_output.outputs.output }}
+      output_types: ${{ steps.collect_output.outputs.output_types }}
+      secret_verification_result: ${{ steps.validate-secret.outputs.verification_result }}
+    steps:
+      - name: Setup Scripts
+        uses: github/gh-aw/actions/setup@48d8fdfddc8cad854ac0c70ceb573f09fb8f9c9b # v0.62.5
+        with:
+          destination: /opt/gh-aw/actions
+      - name: Checkout repository
+        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+        with:
+          persist-credentials: false
+      - name: Setup Python
+        uses: actions/setup-python@a309ff8b426b58ec0e2a45f0f869d46889d02405 # v6.2.0
+        with:
+          python-version: '3.14'
+      - name: Create gh-aw temp directory
+        run: bash /opt/gh-aw/actions/create_gh_aw_tmp_dir.sh
+      # Cache configuration from frontmatter processed below
+      - name: Cache (cpython-lib-${{ env.PYTHON_VERSION }})
+        uses: actions/cache@668228422ae6a00e4ad889ee87cd7109ec5666a7 # v5.0.4
+        with:
+          key: cpython-lib-${{ env.PYTHON_VERSION }}
+          path: cpython
+          restore-keys: |
+            cpython-lib-
+      - name: Configure Git credentials
+        env:
+          REPO_NAME: ${{ github.repository }}
+          SERVER_URL: ${{ github.server_url }}
+        run: |
+          git config --global user.email "github-actions[bot]@users.noreply.github.com"
+          git config --global user.name "github-actions[bot]"
+          # Re-authenticate git with GitHub token
+          SERVER_URL_STRIPPED="${SERVER_URL#https://}"
+          git remote set-url origin "https://x-access-token:${{ github.token }}@${SERVER_URL_STRIPPED}/${REPO_NAME}.git"
+          echo "Git configured with standard GitHub Actions identity"
+      - name: Checkout PR branch
+        id: checkout-pr
+        if: |
+          github.event.pull_request
+        uses: actions/github-script@ed597411d8f924073f98dfc5c65a23a2325f34cd # v8
+        env:
+          GH_TOKEN: ${{ secrets.GH_AW_GITHUB_MCP_SERVER_TOKEN || secrets.GH_AW_GITHUB_TOKEN || secrets.GITHUB_TOKEN }}
+        with:
+          github-token: ${{ secrets.GH_AW_GITHUB_MCP_SERVER_TOKEN || secrets.GH_AW_GITHUB_TOKEN || secrets.GITHUB_TOKEN }}
+          script: |
+            const { setupGlobals } = require('/opt/gh-aw/actions/setup_globals.cjs');
+            setupGlobals(core, github, context, exec, io);
+            const { main } = require('/opt/gh-aw/actions/checkout_pr_branch.cjs');
+            await main();
+      - name: Generate agentic run info
+        id: generate_aw_info
+        uses: actions/github-script@ed597411d8f924073f98dfc5c65a23a2325f34cd # v8
+        with:
+          script: |
+            const fs = require('fs');
+            
+            const awInfo = {
+              engine_id: "copilot",
+              engine_name: "GitHub Copilot CLI",
+              model: process.env.GH_AW_MODEL_AGENT_COPILOT || "",
+              version: "",
+              agent_version: "0.0.409",
+              cli_version: "v0.43.22",
+              workflow_name: "Upgrade Python Library",
+              experimental: false,
+              supports_tools_allowlist: true,
+              supports_http_transport: true,
+              run_id: context.runId,
+              run_number: context.runNumber,
+              run_attempt: process.env.GITHUB_RUN_ATTEMPT,
+              repository: context.repo.owner + '/' + context.repo.repo,
+              ref: context.ref,
+              sha: context.sha,
+              actor: context.actor,
+              event_name: context.eventName,
+              staged: false,
+              allowed_domains: ["defaults","rust","python"],
+              firewall_enabled: true,
+              awf_version: "v0.16.4",
+              awmg_version: "",
+              steps: {
+                firewall: "squid"
+              },
+              created_at: new Date().toISOString()
+            };
+            
+            // Write to /tmp/gh-aw directory to avoid inclusion in PR
+            const tmpPath = '/tmp/gh-aw/aw_info.json';
+            fs.writeFileSync(tmpPath, JSON.stringify(awInfo, null, 2));
+            console.log('Generated aw_info.json at:', tmpPath);
+            console.log(JSON.stringify(awInfo, null, 2));
+            
+            // Set model as output for reuse in other steps/jobs
+            core.setOutput('model', awInfo.model);
+      - name: Validate COPILOT_GITHUB_TOKEN secret
+        id: validate-secret
+        run: /opt/gh-aw/actions/validate_multi_secret.sh COPILOT_GITHUB_TOKEN 'GitHub Copilot CLI' https://github.github.com/gh-aw/reference/engines/#github-copilot-default
+        env:
+          COPILOT_GITHUB_TOKEN: ${{ secrets.COPILOT_GITHUB_TOKEN }}
+      - name: Install GitHub Copilot CLI
+        run: /opt/gh-aw/actions/install_copilot_cli.sh 0.0.409
+      - name: Install awf binary
+        run: bash /opt/gh-aw/actions/install_awf_binary.sh v0.16.4
+      - name: Determine automatic lockdown mode for GitHub MCP server
+        id: determine-automatic-lockdown
+        uses: actions/github-script@ed597411d8f924073f98dfc5c65a23a2325f34cd # v8
+        env:
+          GH_AW_GITHUB_TOKEN: ${{ secrets.GH_AW_GITHUB_TOKEN }}
+          GH_AW_GITHUB_MCP_SERVER_TOKEN: ${{ secrets.GH_AW_GITHUB_MCP_SERVER_TOKEN }}
+        with:
+          script: |
+            const determineAutomaticLockdown = require('/opt/gh-aw/actions/determine_automatic_lockdown.cjs');
+            await determineAutomaticLockdown(github, context, core);
+      - name: Download container images
+        run: bash /opt/gh-aw/actions/download_docker_images.sh ghcr.io/github/gh-aw-firewall/agent:0.16.4 ghcr.io/github/gh-aw-firewall/squid:0.16.4 ghcr.io/github/gh-aw-mcpg:v0.1.4 ghcr.io/github/github-mcp-server:v0.30.3 node:lts-alpine
+      - name: Write Safe Outputs Config
+        run: |
+          mkdir -p /opt/gh-aw/safeoutputs
+          mkdir -p /tmp/gh-aw/safeoutputs
+          mkdir -p /tmp/gh-aw/mcp-logs/safeoutputs
+          cat > /opt/gh-aw/safeoutputs/config.json << 'GH_AW_SAFE_OUTPUTS_CONFIG_EOF'
+          {"create_pull_request":{"expires":30},"missing_data":{},"missing_tool":{},"noop":{"max":1}}
+          GH_AW_SAFE_OUTPUTS_CONFIG_EOF
+          cat > /opt/gh-aw/safeoutputs/tools.json << 'GH_AW_SAFE_OUTPUTS_TOOLS_EOF'
+          [
+            {
+              "description": "Create a new GitHub pull request to propose code changes. Use this after making file edits to submit them for review and merging. The PR will be created from the current branch with your committed changes. For code review comments on an existing PR, use create_pull_request_review_comment instead. CONSTRAINTS: Maximum 1 pull request(s) can be created. Title will be prefixed with \"Update \". Labels [pylib-sync] will be automatically added.",
+              "inputSchema": {
+                "additionalProperties": false,
+                "properties": {
+                  "body": {
+                    "description": "Detailed PR description in Markdown. Include what changes were made, why, testing notes, and any breaking changes. Do NOT repeat the title as a heading.",
+                    "type": "string"
+                  },
+                  "branch": {
+                    "description": "Source branch name containing the changes. If omitted, uses the current working branch.",
+                    "type": "string"
+                  },
+                  "labels": {
+                    "description": "Labels to categorize the PR (e.g., 'enhancement', 'bugfix'). Labels must exist in the repository.",
+                    "items": {
+                      "type": "string"
+                    },
+                    "type": "array"
+                  },
+                  "title": {
+                    "description": "Concise PR title describing the changes. Follow repository conventions (e.g., conventional commits). The title appears as the main heading.",
+                    "type": "string"
+                  }
+                },
+                "required": [
+                  "title",
+                  "body"
+                ],
+                "type": "object"
+              },
+              "name": "create_pull_request"
+            },
+            {
+              "description": "Report that a tool or capability needed to complete the task is not available, or share any information you deem important about missing functionality or limitations. Use this when you cannot accomplish what was requested because the required functionality is missing or access is restricted.",
+              "inputSchema": {
+                "additionalProperties": false,
+                "properties": {
+                  "alternatives": {
+                    "description": "Any workarounds, manual steps, or alternative approaches the user could take (max 256 characters).",
+                    "type": "string"
+                  },
+                  "reason": {
+                    "description": "Explanation of why this tool is needed or what information you want to share about the limitation (max 256 characters).",
+                    "type": "string"
+                  },
+                  "tool": {
+                    "description": "Optional: Name or description of the missing tool or capability (max 128 characters). Be specific about what functionality is needed.",
+                    "type": "string"
+                  }
+                },
+                "required": [
+                  "reason"
+                ],
+                "type": "object"
+              },
+              "name": "missing_tool"
+            },
+            {
+              "description": "Log a transparency message when no significant actions are needed. Use this to confirm workflow completion and provide visibility when analysis is complete but no changes or outputs are required (e.g., 'No issues found', 'All checks passed'). This ensures the workflow produces human-visible output even when no other actions are taken.",
+              "inputSchema": {
+                "additionalProperties": false,
+                "properties": {
+                  "message": {
+                    "description": "Status or completion message to log. Should explain what was analyzed and the outcome (e.g., 'Code review complete - no issues found', 'Analysis complete - all tests passing').",
+                    "type": "string"
+                  }
+                },
+                "required": [
+                  "message"
+                ],
+                "type": "object"
+              },
+              "name": "noop"
+            },
+            {
+              "description": "Report that data or information needed to complete the task is not available. Use this when you cannot accomplish what was requested because required data, context, or information is missing.",
+              "inputSchema": {
+                "additionalProperties": false,
+                "properties": {
+                  "alternatives": {
+                    "description": "Any workarounds, manual steps, or alternative approaches the user could take (max 256 characters).",
+                    "type": "string"
+                  },
+                  "context": {
+                    "description": "Additional context about the missing data or where it should come from (max 256 characters).",
+                    "type": "string"
+                  },
+                  "data_type": {
+                    "description": "Type or description of the missing data or information (max 128 characters). Be specific about what data is needed.",
+                    "type": "string"
+                  },
+                  "reason": {
+                    "description": "Explanation of why this data is needed to complete the task (max 256 characters).",
+                    "type": "string"
+                  }
+                },
+                "required": [],
+                "type": "object"
+              },
+              "name": "missing_data"
+            }
+          ]
+          GH_AW_SAFE_OUTPUTS_TOOLS_EOF
+          cat > /opt/gh-aw/safeoutputs/validation.json << 'GH_AW_SAFE_OUTPUTS_VALIDATION_EOF'
+          {
+            "create_pull_request": {
+              "defaultMax": 1,
+              "fields": {
+                "body": {
+                  "required": true,
+                  "type": "string",
+                  "sanitize": true,
+                  "maxLength": 65000
+                },
+                "branch": {
+                  "required": true,
+                  "type": "string",
+                  "sanitize": true,
+                  "maxLength": 256
+                },
+                "labels": {
+                  "type": "array",
+                  "itemType": "string",
+                  "itemSanitize": true,
+                  "itemMaxLength": 128
+                },
+                "title": {
+                  "required": true,
+                  "type": "string",
+                  "sanitize": true,
+                  "maxLength": 128
+                }
+              }
+            },
+            "missing_tool": {
+              "defaultMax": 20,
+              "fields": {
+                "alternatives": {
+                  "type": "string",
+                  "sanitize": true,
+                  "maxLength": 512
+                },
+                "reason": {
+                  "required": true,
+                  "type": "string",
+                  "sanitize": true,
+                  "maxLength": 256
+                },
+                "tool": {
+                  "type": "string",
+                  "sanitize": true,
+                  "maxLength": 128
+                }
+              }
+            },
+            "noop": {
+              "defaultMax": 1,
+              "fields": {
+                "message": {
+                  "required": true,
+                  "type": "string",
+                  "sanitize": true,
+                  "maxLength": 65000
+                }
+              }
+            }
+          }
+          GH_AW_SAFE_OUTPUTS_VALIDATION_EOF
+      - name: Generate Safe Outputs MCP Server Config
+        id: safe-outputs-config
+        run: |
+          # Generate a secure random API key (360 bits of entropy, 40+ chars)
+          # Mask immediately to prevent timing vulnerabilities
+          API_KEY=$(openssl rand -base64 45 | tr -d '/+=')
+          echo "::add-mask::${API_KEY}"
+          
+          PORT=3001
+          
+          # Set outputs for next steps
+          {
+            echo "safe_outputs_api_key=${API_KEY}"
+            echo "safe_outputs_port=${PORT}"
+          } >> "$GITHUB_OUTPUT"
+          
+          echo "Safe Outputs MCP server will run on port ${PORT}"
+          
+      - name: Start Safe Outputs MCP HTTP Server
+        id: safe-outputs-start
+        env:
+          DEBUG: '*'
+          GH_AW_SAFE_OUTPUTS_PORT: ${{ steps.safe-outputs-config.outputs.safe_outputs_port }}
+          GH_AW_SAFE_OUTPUTS_API_KEY: ${{ steps.safe-outputs-config.outputs.safe_outputs_api_key }}
+          GH_AW_SAFE_OUTPUTS_TOOLS_PATH: /opt/gh-aw/safeoutputs/tools.json
+          GH_AW_SAFE_OUTPUTS_CONFIG_PATH: /opt/gh-aw/safeoutputs/config.json
+          GH_AW_MCP_LOG_DIR: /tmp/gh-aw/mcp-logs/safeoutputs
+        run: |
+          # Environment variables are set above to prevent template injection
+          export DEBUG
+          export GH_AW_SAFE_OUTPUTS_PORT
+          export GH_AW_SAFE_OUTPUTS_API_KEY
+          export GH_AW_SAFE_OUTPUTS_TOOLS_PATH
+          export GH_AW_SAFE_OUTPUTS_CONFIG_PATH
+          export GH_AW_MCP_LOG_DIR
+          
+          bash /opt/gh-aw/actions/start_safe_outputs_server.sh
+          
+      - name: Start MCP gateway
+        id: start-mcp-gateway
+        env:
+          GH_AW_SAFE_OUTPUTS: ${{ env.GH_AW_SAFE_OUTPUTS }}
+          GH_AW_SAFE_OUTPUTS_API_KEY: ${{ steps.safe-outputs-start.outputs.api_key }}
+          GH_AW_SAFE_OUTPUTS_PORT: ${{ steps.safe-outputs-start.outputs.port }}
+          GITHUB_MCP_LOCKDOWN: ${{ steps.determine-automatic-lockdown.outputs.lockdown == 'true' && '1' || '0' }}
+          GITHUB_MCP_SERVER_TOKEN: ${{ secrets.GH_AW_GITHUB_MCP_SERVER_TOKEN || secrets.GH_AW_GITHUB_TOKEN || secrets.GITHUB_TOKEN }}
+        run: |
+          set -eo pipefail
+          mkdir -p /tmp/gh-aw/mcp-config
+          
+          # Export gateway environment variables for MCP config and gateway script
+          export MCP_GATEWAY_PORT="80"
+          export MCP_GATEWAY_DOMAIN="host.docker.internal"
+          MCP_GATEWAY_API_KEY=$(openssl rand -base64 45 | tr -d '/+=')
+          echo "::add-mask::${MCP_GATEWAY_API_KEY}"
+          export MCP_GATEWAY_API_KEY
+          export MCP_GATEWAY_PAYLOAD_DIR="/tmp/gh-aw/mcp-payloads"
+          mkdir -p "${MCP_GATEWAY_PAYLOAD_DIR}"
+          export DEBUG="*"
+          
+          export GH_AW_ENGINE="copilot"
+          export MCP_GATEWAY_DOCKER_COMMAND='docker run -i --rm --network host -v /var/run/docker.sock:/var/run/docker.sock -e MCP_GATEWAY_PORT -e MCP_GATEWAY_DOMAIN -e MCP_GATEWAY_API_KEY -e MCP_GATEWAY_PAYLOAD_DIR -e DEBUG -e MCP_GATEWAY_LOG_DIR -e GH_AW_MCP_LOG_DIR -e GH_AW_SAFE_OUTPUTS -e GH_AW_SAFE_OUTPUTS_CONFIG_PATH -e GH_AW_SAFE_OUTPUTS_TOOLS_PATH -e GH_AW_ASSETS_BRANCH -e GH_AW_ASSETS_MAX_SIZE_KB -e GH_AW_ASSETS_ALLOWED_EXTS -e DEFAULT_BRANCH -e GITHUB_MCP_SERVER_TOKEN -e GITHUB_MCP_LOCKDOWN -e GITHUB_REPOSITORY -e GITHUB_SERVER_URL -e GITHUB_SHA -e GITHUB_WORKSPACE -e GITHUB_TOKEN -e GITHUB_RUN_ID -e GITHUB_RUN_NUMBER -e GITHUB_RUN_ATTEMPT -e GITHUB_JOB -e GITHUB_ACTION -e GITHUB_EVENT_NAME -e GITHUB_EVENT_PATH -e GITHUB_ACTOR -e GITHUB_ACTOR_ID -e GITHUB_TRIGGERING_ACTOR -e GITHUB_WORKFLOW -e GITHUB_WORKFLOW_REF -e GITHUB_WORKFLOW_SHA -e GITHUB_REF -e GITHUB_REF_NAME -e GITHUB_REF_TYPE -e GITHUB_HEAD_REF -e GITHUB_BASE_REF -e GH_AW_SAFE_OUTPUTS_PORT -e GH_AW_SAFE_OUTPUTS_API_KEY -v /tmp/gh-aw/mcp-payloads:/tmp/gh-aw/mcp-payloads:rw -v /opt:/opt:ro -v /tmp:/tmp:rw -v '"${GITHUB_WORKSPACE}"':'"${GITHUB_WORKSPACE}"':rw ghcr.io/github/gh-aw-mcpg:v0.1.4'
+          
+          mkdir -p /home/runner/.copilot
+          cat << GH_AW_MCP_CONFIG_EOF | bash /opt/gh-aw/actions/start_mcp_gateway.sh
+          {
+            "mcpServers": {
+              "github": {
+                "type": "stdio",
+                "container": "ghcr.io/github/github-mcp-server:v0.30.3",
+                "env": {
+                  "GITHUB_LOCKDOWN_MODE": "$GITHUB_MCP_LOCKDOWN",
+                  "GITHUB_PERSONAL_ACCESS_TOKEN": "\${GITHUB_MCP_SERVER_TOKEN}",
+                  "GITHUB_READ_ONLY": "1",
+                  "GITHUB_TOOLSETS": "repos,issues,pull_requests"
+                }
+              },
+              "safeoutputs": {
+                "type": "http",
+                "url": "http://host.docker.internal:$GH_AW_SAFE_OUTPUTS_PORT",
+                "headers": {
+                  "Authorization": "\${GH_AW_SAFE_OUTPUTS_API_KEY}"
+                }
+              }
+            },
+            "gateway": {
+              "port": $MCP_GATEWAY_PORT,
+              "domain": "${MCP_GATEWAY_DOMAIN}",
+              "apiKey": "${MCP_GATEWAY_API_KEY}",
+              "payloadDir": "${MCP_GATEWAY_PAYLOAD_DIR}"
+            }
+          }
+          GH_AW_MCP_CONFIG_EOF
+      - name: Generate workflow overview
+        uses: actions/github-script@ed597411d8f924073f98dfc5c65a23a2325f34cd # v8
+        with:
+          script: |
+            const { generateWorkflowOverview } = require('/opt/gh-aw/actions/generate_workflow_overview.cjs');
+            await generateWorkflowOverview(core);
+      - name: Create prompt with built-in context
+        env:
+          GH_AW_PROMPT: /tmp/gh-aw/aw-prompts/prompt.txt
+          GH_AW_SAFE_OUTPUTS: ${{ env.GH_AW_SAFE_OUTPUTS }}
+          GH_AW_ENV_ISSUE_ID: ${{ env.ISSUE_ID }}
+          GH_AW_GITHUB_ACTOR: ${{ github.actor }}
+          GH_AW_GITHUB_EVENT_COMMENT_ID: ${{ github.event.comment.id }}
+          GH_AW_GITHUB_EVENT_DISCUSSION_NUMBER: ${{ github.event.discussion.number }}
+          GH_AW_GITHUB_EVENT_INPUTS_NAME: ${{ github.event.inputs.name }}
+          GH_AW_GITHUB_EVENT_ISSUE_NUMBER: ${{ github.event.issue.number }}
+          GH_AW_GITHUB_EVENT_PULL_REQUEST_NUMBER: ${{ github.event.pull_request.number }}
+          GH_AW_GITHUB_REPOSITORY: ${{ github.repository }}
+          GH_AW_GITHUB_RUN_ID: ${{ github.run_id }}
+          GH_AW_GITHUB_WORKSPACE: ${{ github.workspace }}
+        run: |
+          bash /opt/gh-aw/actions/create_prompt_first.sh
+          cat << 'GH_AW_PROMPT_EOF' > "$GH_AW_PROMPT"
+          <system>
+          GH_AW_PROMPT_EOF
+          cat "/opt/gh-aw/prompts/xpia.md" >> "$GH_AW_PROMPT"
+          cat "/opt/gh-aw/prompts/temp_folder_prompt.md" >> "$GH_AW_PROMPT"
+          cat "/opt/gh-aw/prompts/markdown.md" >> "$GH_AW_PROMPT"
+          cat << 'GH_AW_PROMPT_EOF' >> "$GH_AW_PROMPT"
+          <safe-outputs>
+          <description>GitHub API Access Instructions</description>
+          <important>
+          The gh CLI is NOT authenticated. Do NOT use gh commands for GitHub operations.
+          </important>
+          <instructions>
+          To create or modify GitHub resources (issues, discussions, pull requests, etc.), you MUST call the appropriate safe output tool. Simply writing content will NOT work - the workflow requires actual tool calls.
+          
+          Temporary IDs: Some safe output tools support a temporary ID field (usually named temporary_id) so you can reference newly-created items elsewhere in the SAME agent output (for example, using #aw_abc1 in a later body). 
+          
+          **IMPORTANT - temporary_id format rules:**
+          - If you DON'T need to reference the item later, OMIT the temporary_id field entirely (it will be auto-generated if needed)
+          - If you DO need cross-references/chaining, you MUST match this EXACT validation regex: /^aw_[A-Za-z0-9]{3,8}$/i
+          - Format: aw_ prefix followed by 3 to 8 alphanumeric characters (A-Z, a-z, 0-9, case-insensitive)
+          - Valid alphanumeric characters: ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789
+          - INVALID examples: aw_ab (too short), aw_123456789 (too long), aw_test-id (contains hyphen), aw_id_123 (contains underscore)
+          - VALID examples: aw_abc, aw_abc1, aw_Test123, aw_A1B2C3D4, aw_12345678
+          - To generate valid IDs: use 3-8 random alphanumeric characters or omit the field to let the system auto-generate
+          
+          Do NOT invent other aw_* formats — downstream steps will reject them with validation errors matching against /^aw_[A-Za-z0-9]{3,8}$/i.
+          
+          Discover available tools from the safeoutputs MCP server.
+          
+          **Critical**: Tool calls write structured data that downstream jobs process. Without tool calls, follow-up actions will be skipped.
+          
+          **Note**: If you made no other safe output tool calls during this workflow execution, call the "noop" tool to provide a status message indicating completion or that no actions were needed.
+          </instructions>
+          </safe-outputs>
+          <github-context>
+          The following GitHub context information is available for this workflow:
+          {{#if __GH_AW_GITHUB_ACTOR__ }}
+          - **actor**: __GH_AW_GITHUB_ACTOR__
+          {{/if}}
+          {{#if __GH_AW_GITHUB_REPOSITORY__ }}
+          - **repository**: __GH_AW_GITHUB_REPOSITORY__
+          {{/if}}
+          {{#if __GH_AW_GITHUB_WORKSPACE__ }}
+          - **workspace**: __GH_AW_GITHUB_WORKSPACE__
+          {{/if}}
+          {{#if __GH_AW_GITHUB_EVENT_ISSUE_NUMBER__ }}
+          - **issue-number**: #__GH_AW_GITHUB_EVENT_ISSUE_NUMBER__
+          {{/if}}
+          {{#if __GH_AW_GITHUB_EVENT_DISCUSSION_NUMBER__ }}
+          - **discussion-number**: #__GH_AW_GITHUB_EVENT_DISCUSSION_NUMBER__
+          {{/if}}
+          {{#if __GH_AW_GITHUB_EVENT_PULL_REQUEST_NUMBER__ }}
+          - **pull-request-number**: #__GH_AW_GITHUB_EVENT_PULL_REQUEST_NUMBER__
+          {{/if}}
+          {{#if __GH_AW_GITHUB_EVENT_COMMENT_ID__ }}
+          - **comment-id**: __GH_AW_GITHUB_EVENT_COMMENT_ID__
+          {{/if}}
+          {{#if __GH_AW_GITHUB_RUN_ID__ }}
+          - **workflow-run-id**: __GH_AW_GITHUB_RUN_ID__
+          {{/if}}
+          </github-context>
+          
+          GH_AW_PROMPT_EOF
+          cat << 'GH_AW_PROMPT_EOF' >> "$GH_AW_PROMPT"
+          </system>
+          GH_AW_PROMPT_EOF
+          cat << 'GH_AW_PROMPT_EOF' >> "$GH_AW_PROMPT"
+          {{#runtime-import .github/workflows/upgrade-pylib.md}}
+          GH_AW_PROMPT_EOF
+      - name: Substitute placeholders
+        uses: actions/github-script@ed597411d8f924073f98dfc5c65a23a2325f34cd # v8
+        env:
+          GH_AW_PROMPT: /tmp/gh-aw/aw-prompts/prompt.txt
+          GH_AW_ENV_ISSUE_ID: ${{ env.ISSUE_ID }}
+          GH_AW_GITHUB_ACTOR: ${{ github.actor }}
+          GH_AW_GITHUB_EVENT_COMMENT_ID: ${{ github.event.comment.id }}
+          GH_AW_GITHUB_EVENT_DISCUSSION_NUMBER: ${{ github.event.discussion.number }}
+          GH_AW_GITHUB_EVENT_INPUTS_NAME: ${{ github.event.inputs.name }}
+          GH_AW_GITHUB_EVENT_ISSUE_NUMBER: ${{ github.event.issue.number }}
+          GH_AW_GITHUB_EVENT_PULL_REQUEST_NUMBER: ${{ github.event.pull_request.number }}
+          GH_AW_GITHUB_REPOSITORY: ${{ github.repository }}
+          GH_AW_GITHUB_RUN_ID: ${{ github.run_id }}
+          GH_AW_GITHUB_WORKSPACE: ${{ github.workspace }}
+        with:
+          script: |
+            const substitutePlaceholders = require('/opt/gh-aw/actions/substitute_placeholders.cjs');
+            
+            // Call the substitution function
+            return await substitutePlaceholders({
+              file: process.env.GH_AW_PROMPT,
+              substitutions: {
+                GH_AW_ENV_ISSUE_ID: process.env.GH_AW_ENV_ISSUE_ID,
+                GH_AW_GITHUB_ACTOR: process.env.GH_AW_GITHUB_ACTOR,
+                GH_AW_GITHUB_EVENT_COMMENT_ID: process.env.GH_AW_GITHUB_EVENT_COMMENT_ID,
+                GH_AW_GITHUB_EVENT_DISCUSSION_NUMBER: process.env.GH_AW_GITHUB_EVENT_DISCUSSION_NUMBER,
+                GH_AW_GITHUB_EVENT_INPUTS_NAME: process.env.GH_AW_GITHUB_EVENT_INPUTS_NAME,
+                GH_AW_GITHUB_EVENT_ISSUE_NUMBER: process.env.GH_AW_GITHUB_EVENT_ISSUE_NUMBER,
+                GH_AW_GITHUB_EVENT_PULL_REQUEST_NUMBER: process.env.GH_AW_GITHUB_EVENT_PULL_REQUEST_NUMBER,
+                GH_AW_GITHUB_REPOSITORY: process.env.GH_AW_GITHUB_REPOSITORY,
+                GH_AW_GITHUB_RUN_ID: process.env.GH_AW_GITHUB_RUN_ID,
+                GH_AW_GITHUB_WORKSPACE: process.env.GH_AW_GITHUB_WORKSPACE
+              }
+            });
+      - name: Interpolate variables and render templates
+        uses: actions/github-script@ed597411d8f924073f98dfc5c65a23a2325f34cd # v8
+        env:
+          GH_AW_PROMPT: /tmp/gh-aw/aw-prompts/prompt.txt
+          GH_AW_ENV_ISSUE_ID: ${{ env.ISSUE_ID }}
+          GH_AW_GITHUB_EVENT_INPUTS_NAME: ${{ github.event.inputs.name }}
+        with:
+          script: |
+            const { setupGlobals } = require('/opt/gh-aw/actions/setup_globals.cjs');
+            setupGlobals(core, github, context, exec, io);
+            const { main } = require('/opt/gh-aw/actions/interpolate_prompt.cjs');
+            await main();
+      - name: Validate prompt placeholders
+        env:
+          GH_AW_PROMPT: /tmp/gh-aw/aw-prompts/prompt.txt
+        run: bash /opt/gh-aw/actions/validate_prompt_placeholders.sh
+      - name: Print prompt
+        env:
+          GH_AW_PROMPT: /tmp/gh-aw/aw-prompts/prompt.txt
+        run: bash /opt/gh-aw/actions/print_prompt_summary.sh
+      - name: Clean git credentials
+        run: bash /opt/gh-aw/actions/clean_git_credentials.sh
+      - name: Execute GitHub Copilot CLI
+        id: agentic_execution
+        # Copilot CLI tool arguments (sorted):
+        timeout-minutes: 45
+        run: |
+          set -o pipefail
+          sudo -E awf --env-all --container-workdir "${GITHUB_WORKSPACE}" --allow-domains '*.pythonhosted.org,anaconda.org,api.business.githubcopilot.com,api.enterprise.githubcopilot.com,api.github.com,api.githubcopilot.com,api.individual.githubcopilot.com,api.snapcraft.io,archive.ubuntu.com,azure.archive.ubuntu.com,binstar.org,bootstrap.pypa.io,conda.anaconda.org,conda.binstar.org,crates.io,crl.geotrust.com,crl.globalsign.com,crl.identrust.com,crl.sectigo.com,crl.thawte.com,crl.usertrust.com,crl.verisign.com,crl3.digicert.com,crl4.digicert.com,crls.ssl.com,files.pythonhosted.org,github.com,host.docker.internal,index.crates.io,json-schema.org,json.schemastore.org,keyserver.ubuntu.com,ocsp.digicert.com,ocsp.geotrust.com,ocsp.globalsign.com,ocsp.identrust.com,ocsp.sectigo.com,ocsp.ssl.com,ocsp.thawte.com,ocsp.usertrust.com,ocsp.verisign.com,packagecloud.io,packages.cloud.google.com,packages.microsoft.com,pip.pypa.io,ppa.launchpad.net,pypi.org,pypi.python.org,raw.githubusercontent.com,registry.npmjs.org,repo.anaconda.com,repo.continuum.io,s.symcb.com,s.symcd.com,security.ubuntu.com,sh.rustup.rs,static.crates.io,static.rust-lang.org,telemetry.enterprise.githubcopilot.com,ts-crl.ws.symantec.com,ts-ocsp.ws.symantec.com' --log-level info --proxy-logs-dir /tmp/gh-aw/sandbox/firewall/logs --enable-host-access --image-tag 0.16.4 --skip-pull \
+            -- '/usr/local/bin/copilot --add-dir /tmp/gh-aw/ --log-level all --log-dir /tmp/gh-aw/sandbox/agent/logs/ --add-dir "${GITHUB_WORKSPACE}" --disable-builtin-mcps --allow-all-tools --allow-all-paths --share /tmp/gh-aw/sandbox/agent/logs/conversation.md --prompt "$(cat /tmp/gh-aw/aw-prompts/prompt.txt)"${GH_AW_MODEL_AGENT_COPILOT:+ --model "$GH_AW_MODEL_AGENT_COPILOT"}' \
+            2>&1 | tee /tmp/gh-aw/agent-stdio.log
+        env:
+          COPILOT_AGENT_RUNNER_TYPE: STANDALONE
+          COPILOT_GITHUB_TOKEN: ${{ secrets.COPILOT_GITHUB_TOKEN }}
+          GH_AW_MCP_CONFIG: /home/runner/.copilot/mcp-config.json
+          GH_AW_MODEL_AGENT_COPILOT: ${{ vars.GH_AW_MODEL_AGENT_COPILOT || '' }}
+          GH_AW_PROMPT: /tmp/gh-aw/aw-prompts/prompt.txt
+          GH_AW_SAFE_OUTPUTS: ${{ env.GH_AW_SAFE_OUTPUTS }}
+          GITHUB_HEAD_REF: ${{ github.head_ref }}
+          GITHUB_REF_NAME: ${{ github.ref_name }}
+          GITHUB_STEP_SUMMARY: ${{ env.GITHUB_STEP_SUMMARY }}
+          GITHUB_WORKSPACE: ${{ github.workspace }}
+          XDG_CONFIG_HOME: /home/runner
+      - name: Configure Git credentials
+        env:
+          REPO_NAME: ${{ github.repository }}
+          SERVER_URL: ${{ github.server_url }}
+        run: |
+          git config --global user.email "github-actions[bot]@users.noreply.github.com"
+          git config --global user.name "github-actions[bot]"
+          # Re-authenticate git with GitHub token
+          SERVER_URL_STRIPPED="${SERVER_URL#https://}"
+          git remote set-url origin "https://x-access-token:${{ github.token }}@${SERVER_URL_STRIPPED}/${REPO_NAME}.git"
+          echo "Git configured with standard GitHub Actions identity"
+      - name: Copy Copilot session state files to logs
+        if: always()
+        continue-on-error: true
+        run: |
+          # Copy Copilot session state files to logs folder for artifact collection
+          # This ensures they are in /tmp/gh-aw/ where secret redaction can scan them
+          SESSION_STATE_DIR="$HOME/.copilot/session-state"
+          LOGS_DIR="/tmp/gh-aw/sandbox/agent/logs"
+          if [ -d "$SESSION_STATE_DIR" ]; then
+            echo "Copying Copilot session state files from $SESSION_STATE_DIR to $LOGS_DIR"
+            mkdir -p "$LOGS_DIR"
+            cp -v "$SESSION_STATE_DIR"/*.jsonl "$LOGS_DIR/" 2>/dev/null || true
+            echo "Session state files copied successfully"
+          else
+            echo "No session-state directory found at $SESSION_STATE_DIR"
+          fi
+      - name: Stop MCP gateway
+        if: always()
+        continue-on-error: true
+        env:
+          MCP_GATEWAY_PORT: ${{ steps.start-mcp-gateway.outputs.gateway-port }}
+          MCP_GATEWAY_API_KEY: ${{ steps.start-mcp-gateway.outputs.gateway-api-key }}
+          GATEWAY_PID: ${{ steps.start-mcp-gateway.outputs.gateway-pid }}
+        run: |
+          bash /opt/gh-aw/actions/stop_mcp_gateway.sh "$GATEWAY_PID"
+      - name: Redact secrets in logs
+        if: always()
+        uses: actions/github-script@ed597411d8f924073f98dfc5c65a23a2325f34cd # v8
+        with:
+          script: |
+            const { setupGlobals } = require('/opt/gh-aw/actions/setup_globals.cjs');
+            setupGlobals(core, github, context, exec, io);
+            const { main } = require('/opt/gh-aw/actions/redact_secrets.cjs');
+            await main();
+        env:
+          GH_AW_SECRET_NAMES: 'COPILOT_GITHUB_TOKEN,GH_AW_GITHUB_MCP_SERVER_TOKEN,GH_AW_GITHUB_TOKEN,GITHUB_TOKEN'
+          SECRET_COPILOT_GITHUB_TOKEN: ${{ secrets.COPILOT_GITHUB_TOKEN }}
+          SECRET_GH_AW_GITHUB_MCP_SERVER_TOKEN: ${{ secrets.GH_AW_GITHUB_MCP_SERVER_TOKEN }}
+          SECRET_GH_AW_GITHUB_TOKEN: ${{ secrets.GH_AW_GITHUB_TOKEN }}
+          SECRET_GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+      - name: Upload Safe Outputs
+        if: always()
+        uses: actions/upload-artifact@bbbca2ddaa5d8feaa63e36b76fdaad77386f024f # v7.0.0
+        with:
+          name: safe-output
+          path: ${{ env.GH_AW_SAFE_OUTPUTS }}
+          if-no-files-found: warn
+      - name: Ingest agent output
+        id: collect_output
+        uses: actions/github-script@ed597411d8f924073f98dfc5c65a23a2325f34cd # v8
+        env:
+          GH_AW_SAFE_OUTPUTS: ${{ env.GH_AW_SAFE_OUTPUTS }}
+          GH_AW_ALLOWED_DOMAINS: "*.pythonhosted.org,anaconda.org,api.business.githubcopilot.com,api.enterprise.githubcopilot.com,api.github.com,api.githubcopilot.com,api.individual.githubcopilot.com,api.snapcraft.io,archive.ubuntu.com,azure.archive.ubuntu.com,binstar.org,bootstrap.pypa.io,conda.anaconda.org,conda.binstar.org,crates.io,crl.geotrust.com,crl.globalsign.com,crl.identrust.com,crl.sectigo.com,crl.thawte.com,crl.usertrust.com,crl.verisign.com,crl3.digicert.com,crl4.digicert.com,crls.ssl.com,files.pythonhosted.org,github.com,host.docker.internal,index.crates.io,json-schema.org,json.schemastore.org,keyserver.ubuntu.com,ocsp.digicert.com,ocsp.geotrust.com,ocsp.globalsign.com,ocsp.identrust.com,ocsp.sectigo.com,ocsp.ssl.com,ocsp.thawte.com,ocsp.usertrust.com,ocsp.verisign.com,packagecloud.io,packages.cloud.google.com,packages.microsoft.com,pip.pypa.io,ppa.launchpad.net,pypi.org,pypi.python.org,raw.githubusercontent.com,registry.npmjs.org,repo.anaconda.com,repo.continuum.io,s.symcb.com,s.symcd.com,security.ubuntu.com,sh.rustup.rs,static.crates.io,static.rust-lang.org,telemetry.enterprise.githubcopilot.com,ts-crl.ws.symantec.com,ts-ocsp.ws.symantec.com"
+          GITHUB_SERVER_URL: ${{ github.server_url }}
+          GITHUB_API_URL: ${{ github.api_url }}
+        with:
+          script: |
+            const { setupGlobals } = require('/opt/gh-aw/actions/setup_globals.cjs');
+            setupGlobals(core, github, context, exec, io);
+            const { main } = require('/opt/gh-aw/actions/collect_ndjson_output.cjs');
+            await main();
+      - name: Upload sanitized agent output
+        if: always() && env.GH_AW_AGENT_OUTPUT
+        uses: actions/upload-artifact@bbbca2ddaa5d8feaa63e36b76fdaad77386f024f # v7.0.0
+        with:
+          name: agent-output
+          path: ${{ env.GH_AW_AGENT_OUTPUT }}
+          if-no-files-found: warn
+      - name: Upload engine output files
+        uses: actions/upload-artifact@bbbca2ddaa5d8feaa63e36b76fdaad77386f024f # v7.0.0
+        with:
+          name: agent_outputs
+          path: |
+            /tmp/gh-aw/sandbox/agent/logs/
+            /tmp/gh-aw/redacted-urls.log
+          if-no-files-found: ignore
+      - name: Parse agent logs for step summary
+        if: always()
+        uses: actions/github-script@ed597411d8f924073f98dfc5c65a23a2325f34cd # v8
+        env:
+          GH_AW_AGENT_OUTPUT: /tmp/gh-aw/sandbox/agent/logs/
+        with:
+          script: |
+            const { setupGlobals } = require('/opt/gh-aw/actions/setup_globals.cjs');
+            setupGlobals(core, github, context, exec, io);
+            const { main } = require('/opt/gh-aw/actions/parse_copilot_log.cjs');
+            await main();
+      - name: Parse MCP gateway logs for step summary
+        if: always()
+        uses: actions/github-script@ed597411d8f924073f98dfc5c65a23a2325f34cd # v8
+        with:
+          script: |
+            const { setupGlobals } = require('/opt/gh-aw/actions/setup_globals.cjs');
+            setupGlobals(core, github, context, exec, io);
+            const { main } = require('/opt/gh-aw/actions/parse_mcp_gateway_log.cjs');
+            await main();
+      - name: Print firewall logs
+        if: always()
+        continue-on-error: true
+        env:
+          AWF_LOGS_DIR: /tmp/gh-aw/sandbox/firewall/logs
+        run: |
+          # Fix permissions on firewall logs so they can be uploaded as artifacts
+          # AWF runs with sudo, creating files owned by root
+          sudo chmod -R a+r /tmp/gh-aw/sandbox/firewall/logs 2>/dev/null || true
+          awf logs summary | tee -a "$GITHUB_STEP_SUMMARY"
+      - name: Upload agent artifacts
+        if: always()
+        continue-on-error: true
+        uses: actions/upload-artifact@bbbca2ddaa5d8feaa63e36b76fdaad77386f024f # v7.0.0
+        with:
+          name: agent-artifacts
+          path: |
+            /tmp/gh-aw/aw-prompts/prompt.txt
+            /tmp/gh-aw/aw_info.json
+            /tmp/gh-aw/mcp-logs/
+            /tmp/gh-aw/sandbox/firewall/logs/
+            /tmp/gh-aw/agent-stdio.log
+            /tmp/gh-aw/agent/
+            /tmp/gh-aw/aw*.patch
+          if-no-files-found: ignore
+
+  conclusion:
+    needs:
+      - activation
+      - agent
+      - detection
+      - safe_outputs
+    if: (always()) && (needs.agent.result != 'skipped')
+    runs-on: ubuntu-slim
+    permissions:
+      contents: read
+      discussions: write
+      issues: write
+      pull-requests: write
+    outputs:
+      noop_message: ${{ steps.noop.outputs.noop_message }}
+      tools_reported: ${{ steps.missing_tool.outputs.tools_reported }}
+      total_count: ${{ steps.missing_tool.outputs.total_count }}
+    steps:
+      - name: Setup Scripts
+        uses: github/gh-aw/actions/setup@48d8fdfddc8cad854ac0c70ceb573f09fb8f9c9b # v0.62.5
+        with:
+          destination: /opt/gh-aw/actions
+      - name: Download agent output artifact
+        continue-on-error: true
+        uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c # v8.0.1
+        with:
+          name: agent-output
+          path: /tmp/gh-aw/safeoutputs/
+      - name: Setup agent output environment variable
+        run: |
+          mkdir -p /tmp/gh-aw/safeoutputs/
+          find "/tmp/gh-aw/safeoutputs/" -type f -print
+          echo "GH_AW_AGENT_OUTPUT=/tmp/gh-aw/safeoutputs/agent_output.json" >> "$GITHUB_ENV"
+      - name: Process No-Op Messages
+        id: noop
+        uses: actions/github-script@ed597411d8f924073f98dfc5c65a23a2325f34cd # v8
+        env:
+          GH_AW_AGENT_OUTPUT: ${{ env.GH_AW_AGENT_OUTPUT }}
+          GH_AW_NOOP_MAX: 1
+          GH_AW_WORKFLOW_NAME: "Upgrade Python Library"
+        with:
+          github-token: ${{ secrets.GH_AW_GITHUB_TOKEN || secrets.GITHUB_TOKEN }}
+          script: |
+            const { setupGlobals } = require('/opt/gh-aw/actions/setup_globals.cjs');
+            setupGlobals(core, github, context, exec, io);
+            const { main } = require('/opt/gh-aw/actions/noop.cjs');
+            await main();
+      - name: Record Missing Tool
+        id: missing_tool
+        uses: actions/github-script@ed597411d8f924073f98dfc5c65a23a2325f34cd # v8
+        env:
+          GH_AW_AGENT_OUTPUT: ${{ env.GH_AW_AGENT_OUTPUT }}
+          GH_AW_WORKFLOW_NAME: "Upgrade Python Library"
+        with:
+          github-token: ${{ secrets.GH_AW_GITHUB_TOKEN || secrets.GITHUB_TOKEN }}
+          script: |
+            const { setupGlobals } = require('/opt/gh-aw/actions/setup_globals.cjs');
+            setupGlobals(core, github, context, exec, io);
+            const { main } = require('/opt/gh-aw/actions/missing_tool.cjs');
+            await main();
+      - name: Handle Agent Failure
+        id: handle_agent_failure
+        uses: actions/github-script@ed597411d8f924073f98dfc5c65a23a2325f34cd # v8
+        env:
+          GH_AW_AGENT_OUTPUT: ${{ env.GH_AW_AGENT_OUTPUT }}
+          GH_AW_WORKFLOW_NAME: "Upgrade Python Library"
+          GH_AW_RUN_URL: ${{ github.server_url }}/${{ github.repository }}/actions/runs/${{ github.run_id }}
+          GH_AW_AGENT_CONCLUSION: ${{ needs.agent.result }}
+          GH_AW_WORKFLOW_ID: "upgrade-pylib"
+          GH_AW_SECRET_VERIFICATION_RESULT: ${{ needs.agent.outputs.secret_verification_result }}
+          GH_AW_CHECKOUT_PR_SUCCESS: ${{ needs.agent.outputs.checkout_pr_success }}
+        with:
+          github-token: ${{ secrets.GH_AW_GITHUB_TOKEN || secrets.GITHUB_TOKEN }}
+          script: |
+            const { setupGlobals } = require('/opt/gh-aw/actions/setup_globals.cjs');
+            setupGlobals(core, github, context, exec, io);
+            const { main } = require('/opt/gh-aw/actions/handle_agent_failure.cjs');
+            await main();
+      - name: Handle No-Op Message
+        id: handle_noop_message
+        uses: actions/github-script@ed597411d8f924073f98dfc5c65a23a2325f34cd # v8
+        env:
+          GH_AW_AGENT_OUTPUT: ${{ env.GH_AW_AGENT_OUTPUT }}
+          GH_AW_WORKFLOW_NAME: "Upgrade Python Library"
+          GH_AW_RUN_URL: ${{ github.server_url }}/${{ github.repository }}/actions/runs/${{ github.run_id }}
+          GH_AW_AGENT_CONCLUSION: ${{ needs.agent.result }}
+          GH_AW_NOOP_MESSAGE: ${{ steps.noop.outputs.noop_message }}
+          GH_AW_NOOP_REPORT_AS_ISSUE: "true"
+        with:
+          github-token: ${{ secrets.GH_AW_GITHUB_TOKEN || secrets.GITHUB_TOKEN }}
+          script: |
+            const { setupGlobals } = require('/opt/gh-aw/actions/setup_globals.cjs');
+            setupGlobals(core, github, context, exec, io);
+            const { main } = require('/opt/gh-aw/actions/handle_noop_message.cjs');
+            await main();
+      - name: Handle Create Pull Request Error
+        id: handle_create_pr_error
+        uses: actions/github-script@ed597411d8f924073f98dfc5c65a23a2325f34cd # v8
+        env:
+          GH_AW_AGENT_OUTPUT: ${{ env.GH_AW_AGENT_OUTPUT }}
+          GH_AW_WORKFLOW_NAME: "Upgrade Python Library"
+          GH_AW_RUN_URL: ${{ github.server_url }}/${{ github.repository }}/actions/runs/${{ github.run_id }}
+        with:
+          github-token: ${{ secrets.GH_AW_GITHUB_TOKEN || secrets.GITHUB_TOKEN }}
+          script: |
+            const { setupGlobals } = require('/opt/gh-aw/actions/setup_globals.cjs');
+            setupGlobals(core, github, context, exec, io);
+            const { main } = require('/opt/gh-aw/actions/handle_create_pr_error.cjs');
+            await main();
+      - name: Update reaction comment with completion status
+        id: conclusion
+        uses: actions/github-script@ed597411d8f924073f98dfc5c65a23a2325f34cd # v8
+        env:
+          GH_AW_AGENT_OUTPUT: ${{ env.GH_AW_AGENT_OUTPUT }}
+          GH_AW_COMMENT_ID: ${{ needs.activation.outputs.comment_id }}
+          GH_AW_COMMENT_REPO: ${{ needs.activation.outputs.comment_repo }}
+          GH_AW_RUN_URL: ${{ github.server_url }}/${{ github.repository }}/actions/runs/${{ github.run_id }}
+          GH_AW_WORKFLOW_NAME: "Upgrade Python Library"
+          GH_AW_AGENT_CONCLUSION: ${{ needs.agent.result }}
+          GH_AW_DETECTION_CONCLUSION: ${{ needs.detection.result }}
+        with:
+          github-token: ${{ secrets.GH_AW_GITHUB_TOKEN || secrets.GITHUB_TOKEN }}
+          script: |
+            const { setupGlobals } = require('/opt/gh-aw/actions/setup_globals.cjs');
+            setupGlobals(core, github, context, exec, io);
+            const { main } = require('/opt/gh-aw/actions/notify_comment_error.cjs');
+            await main();
+
+  detection:
+    needs: agent
+    if: needs.agent.outputs.output_types != '' || needs.agent.outputs.has_patch == 'true'
+    runs-on: ubuntu-latest
+    permissions: {}
+    concurrency:
+      group: "gh-aw-copilot-${{ github.workflow }}"
+    timeout-minutes: 10
+    outputs:
+      success: ${{ steps.parse_results.outputs.success }}
+    steps:
+      - name: Setup Scripts
+        uses: github/gh-aw/actions/setup@48d8fdfddc8cad854ac0c70ceb573f09fb8f9c9b # v0.62.5
+        with:
+          destination: /opt/gh-aw/actions
+      - name: Download agent artifacts
+        continue-on-error: true
+        uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c # v8.0.1
+        with:
+          name: agent-artifacts
+          path: /tmp/gh-aw/threat-detection/
+      - name: Download agent output artifact
+        continue-on-error: true
+        uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c # v8.0.1
+        with:
+          name: agent-output
+          path: /tmp/gh-aw/threat-detection/
+      - name: Echo agent output types
+        env:
+          AGENT_OUTPUT_TYPES: ${{ needs.agent.outputs.output_types }}
+        run: |
+          echo "Agent output-types: $AGENT_OUTPUT_TYPES"
+      - name: Setup threat detection
+        uses: actions/github-script@ed597411d8f924073f98dfc5c65a23a2325f34cd # v8
+        env:
+          WORKFLOW_NAME: "Upgrade Python Library"
+          WORKFLOW_DESCRIPTION: "Pick an out-of-sync Python library from the todo list and upgrade it\nby running `scripts/update_lib quick`, then open a pull request."
+          HAS_PATCH: ${{ needs.agent.outputs.has_patch }}
+        with:
+          script: |
+            const { setupGlobals } = require('/opt/gh-aw/actions/setup_globals.cjs');
+            setupGlobals(core, github, context, exec, io);
+            const { main } = require('/opt/gh-aw/actions/setup_threat_detection.cjs');
+            await main();
+      - name: Ensure threat-detection directory and log
+        run: |
+          mkdir -p /tmp/gh-aw/threat-detection
+          touch /tmp/gh-aw/threat-detection/detection.log
+      - name: Validate COPILOT_GITHUB_TOKEN secret
+        id: validate-secret
+        run: /opt/gh-aw/actions/validate_multi_secret.sh COPILOT_GITHUB_TOKEN 'GitHub Copilot CLI' https://github.github.com/gh-aw/reference/engines/#github-copilot-default
+        env:
+          COPILOT_GITHUB_TOKEN: ${{ secrets.COPILOT_GITHUB_TOKEN }}
+      - name: Install GitHub Copilot CLI
+        run: /opt/gh-aw/actions/install_copilot_cli.sh 0.0.409
+      - name: Execute GitHub Copilot CLI
+        id: agentic_execution
+        # Copilot CLI tool arguments (sorted):
+        # --allow-tool shell(cat)
+        # --allow-tool shell(grep)
+        # --allow-tool shell(head)
+        # --allow-tool shell(jq)
+        # --allow-tool shell(ls)
+        # --allow-tool shell(tail)
+        # --allow-tool shell(wc)
+        timeout-minutes: 20
+        run: |
+          set -o pipefail
+          COPILOT_CLI_INSTRUCTION="$(cat /tmp/gh-aw/aw-prompts/prompt.txt)"
+          mkdir -p /tmp/
+          mkdir -p /tmp/gh-aw/
+          mkdir -p /tmp/gh-aw/agent/
+          mkdir -p /tmp/gh-aw/sandbox/agent/logs/
+          copilot --add-dir /tmp/ --add-dir /tmp/gh-aw/ --add-dir /tmp/gh-aw/agent/ --log-level all --log-dir /tmp/gh-aw/sandbox/agent/logs/ --disable-builtin-mcps --allow-tool 'shell(cat)' --allow-tool 'shell(grep)' --allow-tool 'shell(head)' --allow-tool 'shell(jq)' --allow-tool 'shell(ls)' --allow-tool 'shell(tail)' --allow-tool 'shell(wc)' --share /tmp/gh-aw/sandbox/agent/logs/conversation.md --prompt "$COPILOT_CLI_INSTRUCTION"${GH_AW_MODEL_DETECTION_COPILOT:+ --model "$GH_AW_MODEL_DETECTION_COPILOT"} 2>&1 | tee /tmp/gh-aw/threat-detection/detection.log
+        env:
+          COPILOT_AGENT_RUNNER_TYPE: STANDALONE
+          COPILOT_GITHUB_TOKEN: ${{ secrets.COPILOT_GITHUB_TOKEN }}
+          GH_AW_MODEL_DETECTION_COPILOT: ${{ vars.GH_AW_MODEL_DETECTION_COPILOT || '' }}
+          GH_AW_PROMPT: /tmp/gh-aw/aw-prompts/prompt.txt
+          GITHUB_HEAD_REF: ${{ github.head_ref }}
+          GITHUB_REF_NAME: ${{ github.ref_name }}
+          GITHUB_STEP_SUMMARY: ${{ env.GITHUB_STEP_SUMMARY }}
+          GITHUB_WORKSPACE: ${{ github.workspace }}
+          XDG_CONFIG_HOME: /home/runner
+      - name: Parse threat detection results
+        id: parse_results
+        uses: actions/github-script@ed597411d8f924073f98dfc5c65a23a2325f34cd # v8
+        with:
+          script: |
+            const { setupGlobals } = require('/opt/gh-aw/actions/setup_globals.cjs');
+            setupGlobals(core, github, context, exec, io);
+            const { main } = require('/opt/gh-aw/actions/parse_threat_detection_results.cjs');
+            await main();
+      - name: Upload threat detection log
+        if: always()
+        uses: actions/upload-artifact@bbbca2ddaa5d8feaa63e36b76fdaad77386f024f # v7.0.0
+        with:
+          name: threat-detection.log
+          path: /tmp/gh-aw/threat-detection/detection.log
+          if-no-files-found: ignore
+
+  safe_outputs:
+    needs:
+      - activation
+      - agent
+      - detection
+    if: ((!cancelled()) && (needs.agent.result != 'skipped')) && (needs.detection.outputs.success == 'true')
+    runs-on: ubuntu-slim
+    permissions:
+      contents: write
+      issues: write
+      pull-requests: write
+    timeout-minutes: 15
+    env:
+      GH_AW_ENGINE_ID: "copilot"
+      GH_AW_WORKFLOW_ID: "upgrade-pylib"
+      GH_AW_WORKFLOW_NAME: "Upgrade Python Library"
+    outputs:
+      create_discussion_error_count: ${{ steps.process_safe_outputs.outputs.create_discussion_error_count }}
+      create_discussion_errors: ${{ steps.process_safe_outputs.outputs.create_discussion_errors }}
+      process_safe_outputs_processed_count: ${{ steps.process_safe_outputs.outputs.processed_count }}
+      process_safe_outputs_temporary_id_map: ${{ steps.process_safe_outputs.outputs.temporary_id_map }}
+    steps:
+      - name: Setup Scripts
+        uses: github/gh-aw/actions/setup@48d8fdfddc8cad854ac0c70ceb573f09fb8f9c9b # v0.62.5
+        with:
+          destination: /opt/gh-aw/actions
+      - name: Download agent output artifact
+        continue-on-error: true
+        uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c # v8.0.1
+        with:
+          name: agent-output
+          path: /tmp/gh-aw/safeoutputs/
+      - name: Setup agent output environment variable
+        run: |
+          mkdir -p /tmp/gh-aw/safeoutputs/
+          find "/tmp/gh-aw/safeoutputs/" -type f -print
+          echo "GH_AW_AGENT_OUTPUT=/tmp/gh-aw/safeoutputs/agent_output.json" >> "$GITHUB_ENV"
+      - name: Download patch artifact
+        continue-on-error: true
+        uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c # v8.0.1
+        with:
+          name: agent-artifacts
+          path: /tmp/gh-aw/
+      - name: Checkout repository
+        if: ((!cancelled()) && (needs.agent.result != 'skipped')) && (contains(needs.agent.outputs.output_types, 'create_pull_request'))
+        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+        with:
+          token: ${{ github.token }}
+          persist-credentials: false
+          fetch-depth: 1
+      - name: Configure Git credentials
+        if: ((!cancelled()) && (needs.agent.result != 'skipped')) && (contains(needs.agent.outputs.output_types, 'create_pull_request'))
+        env:
+          REPO_NAME: ${{ github.repository }}
+          SERVER_URL: ${{ github.server_url }}
+          GIT_TOKEN: ${{ github.token }}
+        run: |
+          git config --global user.email "github-actions[bot]@users.noreply.github.com"
+          git config --global user.name "github-actions[bot]"
+          # Re-authenticate git with GitHub token
+          SERVER_URL_STRIPPED="${SERVER_URL#https://}"
+          git remote set-url origin "https://x-access-token:${GIT_TOKEN}@${SERVER_URL_STRIPPED}/${REPO_NAME}.git"
+          echo "Git configured with standard GitHub Actions identity"
+      - name: Process Safe Outputs
+        id: process_safe_outputs
+        uses: actions/github-script@ed597411d8f924073f98dfc5c65a23a2325f34cd # v8
+        env:
+          GH_AW_AGENT_OUTPUT: ${{ env.GH_AW_AGENT_OUTPUT }}
+          GH_AW_SAFE_OUTPUTS_HANDLER_CONFIG: "{\"create_pull_request\":{\"base_branch\":\"${{ github.ref_name }}\",\"draft\":false,\"expires\":30,\"labels\":[\"pylib-sync\"],\"max\":1,\"max_patch_size\":1024,\"title_prefix\":\"Update \"},\"missing_data\":{},\"missing_tool\":{}}"
+        with:
+          github-token: ${{ secrets.GH_AW_GITHUB_TOKEN || secrets.GITHUB_TOKEN }}
+          script: |
+            const { setupGlobals } = require('/opt/gh-aw/actions/setup_globals.cjs');
+            setupGlobals(core, github, context, exec, io);
+            const { main } = require('/opt/gh-aw/actions/safe_output_handler_manager.cjs');
+            await main();
+
diff --git a/.github/workflows/upgrade-pylib.md b/.github/workflows/upgrade-pylib.md
new file mode 100644
index 00000000000..058fc067493
--- /dev/null
+++ b/.github/workflows/upgrade-pylib.md
@@ -0,0 +1,134 @@
+---
+description: |
+  Pick an out-of-sync Python library from the todo list and upgrade it
+  by running `scripts/update_lib quick`, then open a pull request.
+
+on:
+  workflow_dispatch:
+    inputs:
+      name:
+        description: "Module name to upgrade (leave empty to auto-pick)"
+        required: false
+        type: string
+
+timeout-minutes: 45
+
+permissions:
+  contents: read
+  issues: read
+  pull-requests: read
+
+network:
+  allowed:
+    - defaults
+    - rust
+    - python
+
+engine: copilot
+
+runtimes:
+  python:
+    version: "3.14"
+
+tools:
+  bash:
+    - ":*"
+  edit:
+  github:
+    toolsets: [repos, issues, pull_requests]
+    read-only: true
+
+safe-outputs:
+  create-pull-request:
+    title-prefix: "Update "
+    labels: [pylib-sync]
+    draft: false
+    expires: 30
+
+cache:
+  key: cpython-lib-${{ env.PYTHON_VERSION }}
+  path: cpython
+  restore-keys:
+    - cpython-lib-
+
+env:
+  PYTHON_VERSION: "v3.14.4"
+  ISSUE_ID: "6839"
+---
+
+# Upgrade Python Library
+
+You are an automated maintenance agent for RustPython, a Python 3 interpreter written in Rust. Your task is to upgrade one out-of-sync Python standard library module from CPython.
+
+## Step 1: Set up the environment
+
+The CPython source may already be cached. Check if the `cpython` directory exists and has the correct version:
+
+```bash
+if [ -d "cpython/Lib" ]; then
+    echo "CPython cache hit, skipping clone"
+else
+    git clone --depth 1 --branch "$PYTHON_VERSION" https://github.com/python/cpython.git cpython
+fi
+```
+
+## Step 2: Determine module name
+
+Run this script to determine the module name:
+
+```bash
+MODULE_NAME="${{ github.event.inputs.name }}"
+if [ -z "$MODULE_NAME" ]; then
+    echo "No module specified, running todo to find one..."
+    python3 scripts/update_lib todo
+    echo "Pick one module from the list above that is marked [ ], has no unmet deps, and has a small Δ number."
+    echo "Do NOT pick: opcode, datetime, random, hashlib, tokenize, pdb, _pyrepl, concurrent, asyncio, multiprocessing, ctypes, idlelib, tkinter, shutil, tarfile, email, unittest"
+else
+    echo "Module specified by user: $MODULE_NAME"
+fi
+```
+
+If the script printed "Module specified by user: ...", use that exact name. If it printed the todo list, pick one suitable module from it.
+
+## Step 3: Run the upgrade
+
+Run the quick upgrade command. This will copy the library from CPython, migrate test files preserving RustPython markers, auto-mark test failures, and create a git commit:
+
+```bash
+python3 scripts/update_lib quick <module_name>
+```
+
+This takes a while because it builds RustPython (`cargo build --release`) and runs tests to determine which ones pass or fail.
+
+If the command fails, report the error and stop. Do not try to fix Rust code or modify test files manually.
+
+## Step 4: Verify the result
+
+After the script succeeds, check what changed:
+
+```bash
+git log -1 --stat
+git diff HEAD~1 --stat
+```
+
+Make sure the commit was created with the correct message format: `Update <name> from <version>`.
+
+## Step 5: Create the pull request
+
+Create a pull request. Reference issue #${{ env.ISSUE_ID }} in the body but do **NOT** use keywords that auto-close issues (Fix, Close, Resolve).
+
+Use this format for the PR body:
+
+```
+## Summary
+
+Upgrade `<module_name>` from CPython $PYTHON_VERSION.
+
+Part of #$ISSUE_ID
+
+## Changes
+
+- Updated `Lib/<module_name>` from CPython
+- Migrated test files preserving RustPython markers
+- Auto-marked test failures with `@expectedFailure`
+```
diff --git a/.github/zizmor.yml b/.github/zizmor.yml
new file mode 100644
index 00000000000..f22f76b70d8
--- /dev/null
+++ b/.github/zizmor.yml
@@ -0,0 +1,14 @@
+rules:
+  unpinned-uses:
+    config:
+      policies:
+        # dtolnay/rust-toolchain is a trusted action that uses lightweight branch
+        # refs (@stable, @nightly, etc.) by design. Pinning to a hash would break
+        # the intended usage pattern.
+        # We can remove this once https://github.com/dtolnay/rust-toolchain/issues/180 is resolved
+        dtolnay/rust-toolchain: any
+  # dtolnay/rust-toolchain handles component installation, target addition, and
+  # override configuration beyond what a bare `rustup` invocation provides.
+  # See: https://github.com/zizmorcore/zizmor/issues/1817
+  superfluous-actions:
+    disable: true
diff --git a/.gitignore b/.gitignore
index 20d3d47d059..338a6437ca2 100644
--- a/.gitignore
+++ b/.gitignore
@@ -10,7 +10,6 @@ __pycache__/
 wasm-pack.log
 .idea/
 .envrc
-.python-version
 
 flame-graph.html
 flame.txt
@@ -22,8 +21,10 @@ flamescope.json
 extra_tests/snippets/resources
 extra_tests/not_impl.py
 
+Lib/_sysconfig_vars*.json
 Lib/site-packages/*
 !Lib/site-packages/README.txt
 Lib/test/data/*
 !Lib/test/data/README
 cpython/
+
diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml
new file mode 100644
index 00000000000..00a0a194b87
--- /dev/null
+++ b/.pre-commit-config.yaml
@@ -0,0 +1,71 @@
+# NOTE: Reason for not using `prek.toml` is dependabot supports `pre-commit` as an ecosystem
+# See: https://github.blog/changelog/2026-03-10-dependabot-now-supports-pre-commit-hooks/
+
+fail_fast: false
+repos:
+  - repo: https://github.com/pre-commit/pre-commit-hooks
+    rev: v6.0.0
+    hooks:
+      - id: check-merge-conflict
+        priority: 0
+
+  - repo: https://github.com/astral-sh/ruff-pre-commit
+    rev: v0.15.7
+    hooks:
+      - id: ruff-format
+        priority: 0
+
+      - id: ruff-check
+        args: [--select, I, --fix, --exit-non-zero-on-fix]
+        types_or: [python]
+        require_serial: true
+        priority: 1
+
+  - repo: local
+    hooks:
+      - id: redundant-test-patches
+        name: check redundant test patches
+        entry: scripts/check_redundant_patches.py
+        files: '^Lib/test/.*\.py$'
+        language: script
+        types: [python]
+        priority: 0
+
+  - repo: local
+    hooks:
+      - id: rustfmt
+        name: rustfmt
+        entry: rustfmt
+        language: system
+        types: [rust]
+        priority: 0
+
+      - id: generate-opcode-metadata
+        name: generate opcode metadata
+        entry: python scripts/generate_opcode_metadata.py
+        files: '^(crates/compiler-core/src/bytecode/instruction\.rs|scripts/generate_opcode_metadata\.py)$'
+        pass_filenames: false
+        language: system
+        require_serial: true
+        priority: 1 # so rustfmt runs first
+
+  - repo: https://github.com/streetsidesoftware/cspell-cli
+    rev: v9.7.0
+    hooks:
+      - id: cspell
+        types: [rust]
+        additional_dependencies:
+          - '@cspell/dict-en_us'
+          - '@cspell/dict-cpp'
+          - '@cspell/dict-python'
+          - '@cspell/dict-rust'
+          - '@cspell/dict-win32'
+          - '@cspell/dict-shell'
+        priority: 0
+
+  - repo: https://github.com/rbubley/mirrors-prettier
+    rev: v3.8.1
+    hooks:
+      - id: prettier
+        files: '^wasm/.*$'
+        priority: 0
diff --git a/.python-version b/.python-version
new file mode 100644
index 00000000000..0104088a93f
--- /dev/null
+++ b/.python-version
@@ -0,0 +1 @@
+3.14.4
diff --git a/AGENTS.md b/AGENTS.md
index fa14977953a..b407328cffb 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -93,7 +93,7 @@ rm -r target/debug/build/rustpython-* && find . | grep -E "\.pyc$" | xargs rm -r
 
 ```bash
 # Run Rust unit tests
-cargo test --workspace --exclude rustpython_wasm
+cargo test --workspace --exclude rustpython_wasm --exclude rustpython-venvlauncher
 
 # Run Python snippets tests (debug mode recommended for faster compilation)
 cargo run -- extra_tests/snippets/builtin_bytes.py
@@ -125,6 +125,36 @@ Run `./scripts/whats_left.py` to get a list of unimplemented methods, which is h
 - Follow Rust best practices for error handling and memory management
 - Use the macro system (`pyclass`, `pymodule`, `pyfunction`, etc.) when implementing Python functionality in Rust
 
+#### Comments
+
+- Do not delete or rewrite existing comments unless they are factually wrong or directly contradict the new code.
+- Do not add decorative section separators (e.g. `// -----------`, `// ===`, `/* *** */`). Use `///` doc-comments or short `//` comments only when they add value.
+
+#### Avoid Duplicate Code in Branches
+
+When branches differ only in a value but share common logic, extract the differing value first, then call the common logic once.
+
+**Bad:**
+```rust
+let result = if condition {
+    let msg = format!("message A: {x}");
+    some_function(msg, shared_arg)
+} else {
+    let msg = format!("message B");
+    some_function(msg, shared_arg)
+};
+```
+
+**Good:**
+```rust
+let msg = if condition {
+    format!("message A: {x}")
+} else {
+    format!("message B")
+};
+let result = some_function(msg, shared_arg);
+```
+
 ### Python Code
 
 - **IMPORTANT**: In most cases, Python code should not be edited. Bug fixes should be made through Rust code modifications only
@@ -197,6 +227,10 @@ cargo build --target wasm32-wasip1 --no-default-features --features freeze-stdli
 cargo run --features jit
 ```
 
+### Linux Build and Debug on macOS
+
+See the "Testing on Linux from macOS" section in [DEVELOPMENT.md](DEVELOPMENT.md#testing-on-linux-from-macos).
+
 ### Building venvlauncher (Windows)
 
 See DEVELOPMENT.md "CPython Version Upgrade Checklist" section.
diff --git a/Cargo.lock b/Cargo.lock
index c6462e235f3..20336689a32 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -79,9 +79,9 @@ checksum = "4b46cbb362ab8752921c97e041f5e366ee6297bd428a31275b9fcf1e380f7299"
 
 [[package]]
 name = "anstream"
-version = "0.6.21"
+version = "1.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "43d5b281e737544384e969a5ccad3f1cdd24b48086a0fc1b2a5262a26b8f4f4a"
+checksum = "824a212faf96e9acacdbd09febd34438f8f711fb84e09a8916013cd7815ca28d"
 dependencies = [
  "anstyle",
  "anstyle-parse",
@@ -100,9 +100,9 @@ checksum = "5192cca8006f1fd4f7237516f40fa183bb07f8fbdfedaa0036de5ea9b0b45e78"
 
 [[package]]
 name = "anstyle-parse"
-version = "0.2.7"
+version = "1.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4e7644824f0aa2c7b9384579234ef10eb7efb6a0deb83f9630a49594dd9c15c2"
+checksum = "52ce7f38b242319f7cabaa6813055467063ecdc9d355bbb4ce0c68908cd8130e"
 dependencies = [
  "utf8parse",
 ]
@@ -249,9 +249,9 @@ checksum = "c08606f8c3cbf4ce6ec8e28fb0014a2c086708fe954eaa885384a6165172e7e8"
 
 [[package]]
 name = "aws-lc-fips-sys"
-version = "0.13.11"
+version = "0.13.13"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "df6ea8e07e2df15b9f09f2ac5ee2977369b06d116f0c4eb5fa4ad443b73c7f53"
+checksum = "f8bce4948d2520386c6d92a6ea2d472300257702242e5a1d01d6add52bd2e7c1"
 dependencies = [
  "bindgen 0.72.1",
  "cc",
@@ -263,9 +263,9 @@ dependencies = [
 
 [[package]]
 name = "aws-lc-rs"
-version = "1.15.4"
+version = "1.16.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7b7b6141e96a8c160799cc2d5adecd5cbbe5054cb8c7c4af53da0f83bb7ad256"
+checksum = "a054912289d18629dc78375ba2c3726a3afe3ff71b4edba9dedfca0e3446d1fc"
 dependencies = [
  "aws-lc-fips-sys",
  "aws-lc-sys",
@@ -275,9 +275,9 @@ dependencies = [
 
 [[package]]
 name = "aws-lc-sys"
-version = "0.37.0"
+version = "0.39.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5c34dda4df7017c8db52132f0f8a2e0f8161649d15723ed63fc00c82d0f2081a"
+checksum = "1fa7e52a4c5c547c741610a2c6f123f3881e409b714cd27e6798ef020c514f0a"
 dependencies = [
  "cc",
  "cmake",
@@ -303,7 +303,7 @@ version = "0.71.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "5f58bf3d7db68cfbac37cfc485a8d711e87e064c3d0fe0435b92f7a407f9d6b3"
 dependencies = [
- "bitflags 2.10.0",
+ "bitflags 2.11.0",
  "cexpr",
  "clang-sys",
  "itertools 0.13.0",
@@ -323,7 +323,7 @@ version = "0.72.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "993776b509cfb49c750f11b8f07a46fa23e0a1386ffc01fb1e7d343efc387895"
 dependencies = [
- "bitflags 2.10.0",
+ "bitflags 2.11.0",
  "cexpr",
  "clang-sys",
  "itertools 0.13.0",
@@ -345,9 +345,21 @@ checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a"
 
 [[package]]
 name = "bitflags"
-version = "2.10.0"
+version = "2.11.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "812e12b5285cc515a9c72a5c1d3b6d46a19dac5acfef5265968c166106e31dd3"
+checksum = "843867be96c8daad0d758b57df9392b6d8d271134fce549de6ce169ff98a92af"
+
+[[package]]
+name = "bitflagset"
+version = "0.0.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "64b6ee310aa7af14142c8c9121775774ff601ae055ed98ba7fac96098bcde1b9"
+dependencies = [
+ "num-integer",
+ "num-traits",
+ "radium",
+ "ref-cast",
+]
 
 [[package]]
 name = "blake2"
@@ -389,9 +401,9 @@ dependencies = [
 
 [[package]]
 name = "bumpalo"
-version = "3.19.1"
+version = "3.20.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5dd9dc738b7a8311c7ade152424974d8115f2cdad61e8dab8dac9f2362298510"
+checksum = "5d20789868f4b01b2f2caec9f5c4e0213b41e3e5702a50157d699ae31ced2fcb"
 dependencies = [
  "allocator-api2",
 ]
@@ -404,9 +416,9 @@ checksum = "1fbdf580320f38b612e485521afda1ee26d10cc9884efaaa750d383e13e3c5f4"
 
 [[package]]
 name = "bytes"
-version = "1.11.0"
+version = "1.11.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b35204fbdc0b3f4446b89fc1ac2cf84a8a68971995d0bf2e925ec7cd960f9cb3"
+checksum = "1e748733b7cbc798e1434b6ac524f0c1ff2ab456fe201501e6497c8417a4fc33"
 
 [[package]]
 name = "bzip2"
@@ -491,9 +503,9 @@ checksum = "613afe47fcd5fac7ccf1db93babcb082c5994d996f20b8b159f2ad1658eb5724"
 
 [[package]]
 name = "chrono"
-version = "0.4.43"
+version = "0.4.44"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fac4744fb15ae8337dc853fee7fb3f4e48c0fbaa23d0afe49c447b4fab126118"
+checksum = "c673075a2e0e5f4a1dde27ce9dee1ea4558c7ffe648f576438a20ca1d2acc4b0"
 dependencies = [
  "iana-time-zone",
  "js-sys",
@@ -593,15 +605,6 @@ dependencies = [
  "cc",
 ]
 
-[[package]]
-name = "cobs"
-version = "0.3.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0fa961b519f0b462e3a3b4a34b64d119eeaca1d59af726fe450bbba07a9fc0a1"
-dependencies = [
- "thiserror 2.0.18",
-]
-
 [[package]]
 name = "collection_literals"
 version = "1.0.3"
@@ -709,9 +712,9 @@ dependencies = [
 
 [[package]]
 name = "cranelift"
-version = "0.128.1"
+version = "0.130.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d483a248b5d971d1ef6a814385502a38d8dde8fbf08b4ad08b78c53b8d66f923"
+checksum = "f13b593d4c3fe30bdf7e7bf4cbe78637849515822d305da6080c7ddda554d251"
 dependencies = [
  "cranelift-codegen",
  "cranelift-frontend",
@@ -720,46 +723,46 @@ dependencies = [
 
 [[package]]
 name = "cranelift-assembler-x64"
-version = "0.128.1"
+version = "0.130.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d32b9105ce689b3e79ae288f62e9c2d0de66e4869176a11829e5c696da0f018f"
+checksum = "4f248321c6a7d4de5dcf2939368e96a397ad3f53b6a076e38d0104d1da326d37"
 dependencies = [
  "cranelift-assembler-x64-meta",
 ]
 
 [[package]]
 name = "cranelift-assembler-x64-meta"
-version = "0.128.1"
+version = "0.130.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0e950e8dd96c1760f1c3a2b06d3d35584a3617239d034e73593ec096a1f3ea69"
+checksum = "ab6d78ff1f7d9bf8b7e1afbedbf78ba49e38e9da479d4c8a2db094e22f64e2bc"
 dependencies = [
  "cranelift-srcgen",
 ]
 
 [[package]]
 name = "cranelift-bforest"
-version = "0.128.1"
+version = "0.130.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d769576bc48246fccf7f07173739e5f7a7fb3270eb9ac363c0792cad8963c034"
+checksum = "6b6005ba640213a5b95382aeaf6b82bf028309581c8d7349778d66f27dc1180b"
 dependencies = [
  "cranelift-entity",
+ "wasmtime-internal-core",
 ]
 
 [[package]]
 name = "cranelift-bitset"
-version = "0.128.1"
+version = "0.130.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "94d37c4589e52def48bd745c3b28b523d66ade8b074644ed3a366144c225f212"
+checksum = "81fb5b134a12b559ff0c0f5af0fcd755ad380723b5016c4e0d36f74d39485340"
 dependencies = [
- "serde",
- "serde_derive",
+ "wasmtime-internal-core",
 ]
 
 [[package]]
 name = "cranelift-codegen"
-version = "0.128.1"
+version = "0.130.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c23b5ab93367eba82bddf49b63d841d8a0b8b39fb89d82829de6647b3a747108"
+checksum = "85837de8be7f17a4034a6b08816f05a3144345d2091937b39d415990daca28f4"
 dependencies = [
  "bumpalo",
  "cranelift-assembler-x64",
@@ -771,21 +774,22 @@ dependencies = [
  "cranelift-entity",
  "cranelift-isle",
  "gimli",
- "hashbrown 0.15.5",
+ "hashbrown 0.16.1",
+ "libm",
  "log",
  "regalloc2",
  "rustc-hash",
  "serde",
  "smallvec",
  "target-lexicon",
- "wasmtime-internal-math",
+ "wasmtime-internal-core",
 ]
 
 [[package]]
 name = "cranelift-codegen-meta"
-version = "0.128.1"
+version = "0.130.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6c6118d26dd046455d31374b9432947ea2ba445c21fd8724370edd072f51f3bd"
+checksum = "e433faa87d38e5b8ff469e44a26fea4f93e58abd7a7c10bad9810056139700c9"
 dependencies = [
  "cranelift-assembler-x64-meta",
  "cranelift-codegen-shared",
@@ -795,35 +799,34 @@ dependencies = [
 
 [[package]]
 name = "cranelift-codegen-shared"
-version = "0.128.1"
+version = "0.130.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a068c67f04f37de835fda87a10491e266eea9f9283d0887d8bd0a2c0726588a9"
+checksum = "5397ba61976e13944ca71230775db13ee1cb62849701ed35b753f4761ed0a9b7"
 
 [[package]]
 name = "cranelift-control"
-version = "0.128.1"
+version = "0.130.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "35ceb830549fcd7f05493a3b6d3d2bcfa4d43588b099e8c2393d2d140d6f7951"
+checksum = "cc81c88765580720eb30f4fc2c1bfdb75fcbf3094f87b3cd69cecca79d77a245"
 dependencies = [
  "arbitrary",
 ]
 
 [[package]]
 name = "cranelift-entity"
-version = "0.128.1"
+version = "0.130.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2b130f0edd119e7665f1875b8d686bd3fccefd9d74d10e9005cbcd76392e1831"
+checksum = "463feed5d46cf8763f3ba3045284cf706dd161496e20ec9c14afbb4ba09b9e66"
 dependencies = [
  "cranelift-bitset",
- "serde",
- "serde_derive",
+ "wasmtime-internal-core",
 ]
 
 [[package]]
 name = "cranelift-frontend"
-version = "0.128.1"
+version = "0.130.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "626a46aa207183bae011de3411a40951c494cea3fb2ef223d3118f75e13b23ca"
+checksum = "a4c5eca7696c1c04ab4c7ed8d18eadbb47d6cc9f14ec86fe0881bf1d7e97e261"
 dependencies = [
  "cranelift-codegen",
  "log",
@@ -833,15 +836,15 @@ dependencies = [
 
 [[package]]
 name = "cranelift-isle"
-version = "0.128.1"
+version = "0.130.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d09dab08a5129cf59919fdd4567e599ea955de62191a852982150ac42ce4ab21"
+checksum = "f1153844610cc9c6da8cf10ce205e45da1a585b7688ed558aa808bbe2e4e6d77"
 
 [[package]]
 name = "cranelift-jit"
-version = "0.128.1"
+version = "0.130.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "aaab95b37e712267c51ca968ed4fa83d1a79b9ff3bc86fb9469c764340f486e4"
+checksum = "41836de8321b303d3d4188e58cc09c30c7645337342acfcfb363732695cae098"
 dependencies = [
  "anyhow",
  "cranelift-codegen",
@@ -859,9 +862,9 @@ dependencies = [
 
 [[package]]
 name = "cranelift-module"
-version = "0.128.1"
+version = "0.130.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4d53f2d6b64ef9fb21da36698d45715639e0df50224883baa1e9bd04f96f0716"
+checksum = "b731f66cb1b69b60a74216e632968ebdbb95c488d26aa1448ec226ae0ffec33e"
 dependencies = [
  "anyhow",
  "cranelift-codegen",
@@ -870,9 +873,9 @@ dependencies = [
 
 [[package]]
 name = "cranelift-native"
-version = "0.128.1"
+version = "0.130.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "847b8eaef0f7095b401d3ce80587036495b94e7a051904df9e28d6cd14e69b94"
+checksum = "a97b583fe9a60f06b0464cee6be5a17f623fd91b217aaac99b51b339d19911af"
 dependencies = [
  "cranelift-codegen",
  "libc",
@@ -881,9 +884,9 @@ dependencies = [
 
 [[package]]
 name = "cranelift-srcgen"
-version = "0.128.1"
+version = "0.130.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "15a4849e90e778f2fcc9fd1b93bd074dbf6b8b6f420951f9617c4774fe71e7fc"
+checksum = "8594dc6bb4860fa8292f1814c76459dbfb933e1978d8222de6380efce45c7cee"
 
 [[package]]
 name = "crc32fast"
@@ -896,9 +899,9 @@ dependencies = [
 
 [[package]]
 name = "criterion"
-version = "0.8.1"
+version = "0.8.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4d883447757bb0ee46f233e9dc22eb84d93a9508c9b868687b274fc431d886bf"
+checksum = "950046b2aa2492f9a536f5f4f9a3de7b9e2476e575e05bd6c333371add4d98f3"
 dependencies = [
  "alloca",
  "anes",
@@ -921,9 +924,9 @@ dependencies = [
 
 [[package]]
 name = "criterion-plot"
-version = "0.8.1"
+version = "0.8.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ed943f81ea2faa8dcecbbfa50164acf95d555afec96a27871663b300e387b2e4"
+checksum = "d8d80a2f4f5b554395e47b5d8305bc3d27813bacb73493eb1001e8f76dae29ea"
 dependencies = [
  "cast",
  "itertools 0.13.0",
@@ -1116,18 +1119,6 @@ version = "1.15.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "48c757948c5ede0e46177b7add2e67155f70e33c07fea8284df6576da70b3719"
 
-[[package]]
-name = "embedded-io"
-version = "0.4.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ef1a6892d9eef45c8fa6b9e0086428a2cca8491aca8f787c534a3d6d0bcb3ced"
-
-[[package]]
-name = "embedded-io"
-version = "0.6.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "edd0f118536f44f5ccd48bcb8b111bdc3de888b58c74639dfb034a357d0f206d"
-
 [[package]]
 name = "encode_unicode"
 version = "1.0.0"
@@ -1142,25 +1133,19 @@ checksum = "c34f04666d835ff5d62e058c3995147c06f42fe86ff053337632bca83e42702d"
 
 [[package]]
 name = "env_filter"
-version = "0.1.4"
+version = "1.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1bf3c259d255ca70051b30e2e95b5446cdb8949ac4cd22c0d7fd634d89f568e2"
+checksum = "7a1c3cc8e57274ec99de65301228b537f1e4eedc1b8e0f9411c6caac8ae7308f"
 dependencies = [
  "log",
  "regex",
 ]
 
-[[package]]
-name = "env_home"
-version = "0.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c7f84e12ccf0a7ddc17a6c41c93326024c42920d7ee630d04950e6926645c0fe"
-
 [[package]]
 name = "env_logger"
-version = "0.11.8"
+version = "0.11.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "13c863f0904021b108aa8b2f55046443e6b1ebde8fd4a15c399893aae4fa069f"
+checksum = "0621c04f2196ac3f488dd583365b9c09be011a4ab8b9f37248ffcc8f6198b56a"
 dependencies = [
  "anstream",
  "anstyle",
@@ -1197,12 +1182,6 @@ version = "1.1.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "de853764b47027c2e862a995c34978ffa63c1501f2e15f987ba11bd4f9bba193"
 
-[[package]]
-name = "fallible-iterator"
-version = "0.3.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2acce4a10f12dc2fb14a218589d4f1f62ef011b2d0cc4b3cb1bba8e94da14649"
-
 [[package]]
 name = "fastrand"
 version = "2.3.0"
@@ -1270,20 +1249,19 @@ dependencies = [
 
 [[package]]
 name = "flate2"
-version = "1.1.8"
+version = "1.1.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b375d6465b98090a5f25b1c7703f3859783755aa9a80433b36e0379a3ec2f369"
+checksum = "843fba2746e448b37e26a819579957415c8cef339bf08564fe8b7ddbd959573c"
 dependencies = [
- "crc32fast",
  "miniz_oxide",
- "zlib-rs",
+ "zlib-rs 0.6.0",
 ]
 
 [[package]]
-name = "foldhash"
-version = "0.1.5"
+name = "fnv"
+version = "1.0.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d9c4f5dac5e15c24eb999c26181a6ca40b39fe946cbe4c263c7209467bc83af2"
+checksum = "3f9eec918d3f24069decb9af1554cad7c880e2da24a9afd88aca000531ab82c1"
 
 [[package]]
 name = "foldhash"
@@ -1417,11 +1395,12 @@ dependencies = [
 
 [[package]]
 name = "gimli"
-version = "0.32.3"
+version = "0.33.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e629b9b98ef3dd8afe6ca2bd0f89306cec16d43d907889945bc5d6687f2f13c7"
+checksum = "0bf7f043f89559805f8c7cacc432749b2fa0d0a0a9ee46ce47164ed5ba7f126c"
 dependencies = [
- "fallible-iterator",
+ "fnv",
+ "hashbrown 0.16.1",
  "indexmap",
  "stable_deref_trait",
 ]
@@ -1448,10 +1427,6 @@ name = "hashbrown"
 version = "0.15.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9229cfe53dfd69f0609a49f65461bd93001ea1ef889cd5529dd176593f5338a1"
-dependencies = [
- "foldhash 0.1.5",
- "serde",
-]
 
 [[package]]
 name = "hashbrown"
@@ -1459,7 +1434,7 @@ version = "0.16.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "841d1cc9bed7f9236f321df977030373f4a4163ae1a7dbfe1a51a2c1a51d9100"
 dependencies = [
- "foldhash 0.2.0",
+ "foldhash",
 ]
 
 [[package]]
@@ -1529,24 +1504,97 @@ dependencies = [
 ]
 
 [[package]]
-name = "indexmap"
-version = "2.13.0"
+name = "icu_collections"
+version = "2.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7714e70437a7dc3ac8eb7e6f8df75fd8eb422675fc7678aff7364301092b1017"
+checksum = "4c6b649701667bbe825c3b7e6388cb521c23d88644678e83c0c4d0a621a34b43"
 dependencies = [
- "equivalent",
- "hashbrown 0.16.1",
- "serde",
- "serde_core",
+ "displaydoc",
+ "potential_utf",
+ "yoke",
+ "zerofrom",
+ "zerovec",
 ]
 
 [[package]]
-name = "indoc"
-version = "2.0.7"
+name = "icu_locale_core"
+version = "2.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "79cf5c93f93228cf8efb3ba362535fb11199ac548a09ce117c9b1adc3030d706"
+checksum = "edba7861004dd3714265b4db54a3c390e880ab658fec5f7db895fae2046b5bb6"
 dependencies = [
- "rustversion",
+ "displaydoc",
+ "litemap",
+ "tinystr",
+ "writeable",
+ "zerovec",
+]
+
+[[package]]
+name = "icu_normalizer"
+version = "2.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5f6c8828b67bf8908d82127b2054ea1b4427ff0230ee9141c54251934ab1b599"
+dependencies = [
+ "icu_collections",
+ "icu_normalizer_data",
+ "icu_properties",
+ "icu_provider",
+ "smallvec",
+ "utf16_iter",
+ "utf8_iter",
+ "write16",
+ "zerovec",
+]
+
+[[package]]
+name = "icu_normalizer_data"
+version = "2.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7aedcccd01fc5fe81e6b489c15b247b8b0690feb23304303a9e560f37efc560a"
+
+[[package]]
+name = "icu_properties"
+version = "2.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "020bfc02fe870ec3a66d93e677ccca0562506e5872c650f893269e08615d74ec"
+dependencies = [
+ "icu_collections",
+ "icu_locale_core",
+ "icu_properties_data",
+ "icu_provider",
+ "zerotrie",
+ "zerovec",
+]
+
+[[package]]
+name = "icu_properties_data"
+version = "2.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "616c294cf8d725c6afcd8f55abc17c56464ef6211f9ed59cccffe534129c77af"
+
+[[package]]
+name = "icu_provider"
+version = "2.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "85962cf0ce02e1e0a629cc34e7ca3e373ce20dda4c4d7294bbd0bf1fdb59e614"
+dependencies = [
+ "displaydoc",
+ "icu_locale_core",
+ "writeable",
+ "yoke",
+ "zerofrom",
+ "zerotrie",
+ "zerovec",
+]
+
+[[package]]
+name = "indexmap"
+version = "2.13.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7714e70437a7dc3ac8eb7e6f8df75fd8eb422675fc7678aff7364301092b1017"
+dependencies = [
+ "equivalent",
+ "hashbrown 0.16.1",
 ]
 
 [[package]]
@@ -1561,9 +1609,9 @@ dependencies = [
 
 [[package]]
 name = "insta"
-version = "1.46.1"
+version = "1.46.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "248b42847813a1550dafd15296fd9748c651d0c32194559dbc05d804d54b21e8"
+checksum = "e82db8c87c7f1ccecb34ce0c24399b8a73081427f3c7c50a5d597925356115e4"
 dependencies = [
  "console",
  "once_cell",
@@ -1621,9 +1669,9 @@ checksum = "92ecc6618181def0457392ccd0ee51198e065e016d1d527a7ac1b6dc7c1f09d2"
 
 [[package]]
 name = "jiff"
-version = "0.2.18"
+version = "0.2.23"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e67e8da4c49d6d9909fe03361f9b620f58898859f5c7aded68351e85e71ecf50"
+checksum = "1a3546dc96b6d42c5f24902af9e2538e82e39ad350b0c766eb3fbf2d8f3d8359"
 dependencies = [
  "jiff-static",
  "log",
@@ -1634,9 +1682,9 @@ dependencies = [
 
 [[package]]
 name = "jiff-static"
-version = "0.2.18"
+version = "0.2.23"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e0c84ee7f197eca9a86c6fd6cb771e55eb991632f15f2bc3ca6ec838929e6e78"
+checksum = "2a8c8b344124222efd714b73bb41f8b5120b27a7cc1c75593a6ff768d9d05aa4"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -1687,9 +1735,9 @@ dependencies = [
 
 [[package]]
 name = "junction"
-version = "1.4.1"
+version = "1.4.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "642883fdc81cf2da15ee8183fa1d2c7da452414dd41541a0f3e1428069345447"
+checksum = "8cfc352a66ba903c23239ef51e809508b6fc2b0f90e3476ac7a9ff47e863ae95"
 dependencies = [
  "scopeguard",
  "windows-sys 0.61.2",
@@ -1697,9 +1745,9 @@ dependencies = [
 
 [[package]]
 name = "keccak"
-version = "0.1.5"
+version = "0.1.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ecc2af9a1119c51f12a14607e783cb977bde58bc069ff0c3da1095e635d70654"
+checksum = "cb26cec98cce3a3d96cbb7bced3c4b16e3d13f27ec56dbd62cbc8f39cfb9d653"
 dependencies = [
  "cpufeatures",
 ]
@@ -1743,9 +1791,9 @@ checksum = "2604dd126bb14f13fb5d1bd6a66155079cb9fa655b37f875b3a742c705dbed17"
 
 [[package]]
 name = "lexopt"
-version = "0.3.1"
+version = "0.3.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9fa0e2a1fcbe2f6be6c42e342259976206b383122fc152e872795338b5a3f3a7"
+checksum = "803ec87c9cfb29b9d2633f20cba1f488db3fd53f2158b1024cbefb47ba05d413"
 
 [[package]]
 name = "libbz2-rs-sys"
@@ -1755,9 +1803,9 @@ checksum = "2c4a545a15244c7d945065b5d392b2d2d7f21526fba56ce51467b06ed445e8f7"
 
 [[package]]
 name = "libc"
-version = "0.2.180"
+version = "0.2.183"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bcc35a38544a891a5f7c865aca548a982ccb3b8650a5b06d0fd33a10283c56fc"
+checksum = "b5b646652bf6661599e1da8901b3b9522896f01e736bad5f723fe7a3a27f899d"
 
 [[package]]
 name = "libffi"
@@ -1798,6 +1846,26 @@ dependencies = [
  "windows-link",
 ]
 
+[[package]]
+name = "liblzma"
+version = "0.4.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b6033b77c21d1f56deeae8014eb9fbe7bdf1765185a6c508b5ca82eeaed7f899"
+dependencies = [
+ "liblzma-sys",
+]
+
+[[package]]
+name = "liblzma-sys"
+version = "0.4.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9f2db66f3268487b5033077f266da6777d057949b8f93c8ad82e441df25e6186"
+dependencies = [
+ "cc",
+ "libc",
+ "pkg-config",
+]
+
 [[package]]
 name = "libm"
 version = "0.2.16"
@@ -1810,15 +1878,15 @@ version = "0.1.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "3d0b95e02c851351f877147b7deea7b1afb1df71b63aa5f8270716e0c5720616"
 dependencies = [
- "bitflags 2.10.0",
+ "bitflags 2.11.0",
  "libc",
 ]
 
 [[package]]
 name = "libsqlite3-sys"
-version = "0.36.0"
+version = "0.37.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "95b4103cffefa72eb8428cb6b47d6627161e51c2739fc5e3b734584157bc642a"
+checksum = "b1f111c8c41e7c61a49cd34e44c7619462967221a6443b0ec299e0ac30cfb9b1"
 dependencies = [
  "cc",
  "pkg-config",
@@ -1831,14 +1899,20 @@ version = "0.5.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c10501e7805cee23da17c7790e59df2870c0d4043ec6d03f67d31e2b53e77415"
 dependencies = [
- "zlib-rs",
+ "zlib-rs 0.5.5",
 ]
 
 [[package]]
 name = "linux-raw-sys"
-version = "0.11.0"
+version = "0.12.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "32a66949e030da00e8c7d4434b251670a91556f4144941d37452769c25d58a53"
+
+[[package]]
+name = "litemap"
+version = "0.8.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "df1d3c3b53da64cf5760482273a98e575c651a67eec7f77df96b5b642de8f039"
+checksum = "6373607a59f0be73a39b6fe456b8192fcc3585f602af20751600e974dd455e77"
 
 [[package]]
 name = "lock_api"
@@ -1857,24 +1931,13 @@ checksum = "5e5032e24019045c762d3c0f28f5b6b8bbf38563a65908389bf7978758920897"
 
 [[package]]
 name = "lz4_flex"
-version = "0.12.0"
+version = "0.13.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ab6473172471198271ff72e9379150e9dfd70d8e533e0752a27e515b48dd375e"
+checksum = "db9a0d582c2874f68138a16ce1867e0ffde6c0bb0a0df85e1f36d04146db488a"
 dependencies = [
  "twox-hash",
 ]
 
-[[package]]
-name = "lzma-sys"
-version = "0.1.20"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5fda04ab3764e6cde78b9974eec4f779acaba7c4e84b36eca3cf77c581b85d27"
-dependencies = [
- "cc",
- "libc",
- "pkg-config",
-]
-
 [[package]]
 name = "mac_address"
 version = "1.1.8"
@@ -1896,9 +1959,9 @@ dependencies = [
 
 [[package]]
 name = "malachite-base"
-version = "0.9.0"
+version = "0.9.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5eb2a098b227df48779e28ed4125dd3161b792a9254961377cea6f5c19e5b417"
+checksum = "a8b6f86fdbb1eb9955946be91775239dfcb0acdb1a51bb07d5fc9b8c854f5ccd"
 dependencies = [
  "hashbrown 0.16.1",
  "itertools 0.14.0",
@@ -1908,9 +1971,9 @@ dependencies = [
 
 [[package]]
 name = "malachite-bigint"
-version = "0.9.0"
+version = "0.9.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6eaf19f1b8ba023528050372eafd72ca11f80f70c9dc2af9bb22f888bf079013"
+checksum = "67fcd6e504ffc67db2b3c6d5e90e08054646e2b04f42115a5460bf1c1e37d3bc"
 dependencies = [
  "malachite-base",
  "malachite-nz",
@@ -1921,9 +1984,9 @@ dependencies = [
 
 [[package]]
 name = "malachite-nz"
-version = "0.9.0"
+version = "0.9.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ab7c0ddc4e2681459d70591baf30ca5abd31c25969e76d3605838bec794c8077"
+checksum = "0197a2f5cfee19d59178e282985c6ca79a9233e26a2adcf40acb693896aa09f6"
 dependencies = [
  "itertools 0.14.0",
  "libm",
@@ -1933,9 +1996,9 @@ dependencies = [
 
 [[package]]
 name = "malachite-q"
-version = "0.9.0"
+version = "0.9.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e13d19f04fc672f251d477c8d58c13c6c5550553dfba6a665c9ad3604466ac9a"
+checksum = "be2add95162aede090c48f0ee51bea7d328847ce3180aa44588111f846cc116b"
 dependencies = [
  "itertools 0.14.0",
  "malachite-base",
@@ -1971,12 +2034,6 @@ version = "1.0.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "3e2e65a1a2e43cfcb47a895c4c8b10d1f4a61097f9f254f183aee60cad9c651d"
 
-[[package]]
-name = "matches"
-version = "0.1.10"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2532096657941c2fea9c289d370a250971c689d4f143798ff67113ec042024a5"
-
 [[package]]
 name = "md-5"
 version = "0.10.6"
@@ -1989,15 +2046,15 @@ dependencies = [
 
 [[package]]
 name = "memchr"
-version = "2.7.6"
+version = "2.8.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f52b00d39961fc5b2736ea853c9cc86238e165017a493d1d5c8eac6bdc4cc273"
+checksum = "f8ca58f447f06ed17d5fc4043ce1b10dd205e060fb3ce5b979b8ed8e59ff3f79"
 
 [[package]]
 name = "memmap2"
-version = "0.9.9"
+version = "0.9.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "744133e4a0e0a658e1374cf3bf8e415c4052a15a111acd372764c55b4177d490"
+checksum = "714098028fe011992e1c3962653c96b2d578c4b4bce9036e15ff220319b1e0e3"
 dependencies = [
  "libc",
 ]
@@ -2051,7 +2108,7 @@ version = "0.29.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "71e2746dc3a24dd78b3cfcb7be93368c6de9963d30f43a6a73998a9cf4b17b46"
 dependencies = [
- "bitflags 2.10.0",
+ "bitflags 2.11.0",
  "cfg-if",
  "cfg_aliases",
  "libc",
@@ -2064,7 +2121,7 @@ version = "0.30.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "74523f3a35e05aba87a1d978330aef40f67b0304ac79c1c00b294c9830543db6"
 dependencies = [
- "bitflags 2.10.0",
+ "bitflags 2.11.0",
  "cfg-if",
  "cfg_aliases",
  "libc",
@@ -2136,9 +2193,9 @@ dependencies = [
 
 [[package]]
 name = "num_enum"
-version = "0.7.5"
+version = "0.7.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b1207a7e20ad57b847bbddc6776b968420d38292bbfe2089accff5e19e82454c"
+checksum = "5d0bca838442ec211fa11de3a8b0e0e8f3a4522575b5c4c06ed722e005036f26"
 dependencies = [
  "num_enum_derive",
  "rustversion",
@@ -2146,9 +2203,9 @@ dependencies = [
 
 [[package]]
 name = "num_enum_derive"
-version = "0.7.5"
+version = "0.7.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ff32365de1b6743cb203b710788263c44a03de03802daf96092f2da4fe6ba4d7"
+checksum = "680998035259dcfcafe653688bf2aa6d3e2dc05e98be6ab46afb089dc84f1df8"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -2193,11 +2250,11 @@ checksum = "d6790f58c7ff633d8771f42965289203411a5e5c68388703c06e14f24770b41e"
 
 [[package]]
 name = "openssl"
-version = "0.10.75"
+version = "0.10.76"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "08838db121398ad17ab8531ce9de97b244589089e290a384c900cb9ff7434328"
+checksum = "951c002c75e16ea2c65b8c7e4d3d51d5530d8dfa7d060b4776828c88cfb18ecf"
 dependencies = [
- "bitflags 2.10.0",
+ "bitflags 2.11.0",
  "cfg-if",
  "foreign-types",
  "libc",
@@ -2234,9 +2291,9 @@ dependencies = [
 
 [[package]]
 name = "openssl-sys"
-version = "0.9.111"
+version = "0.9.112"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "82cab2d520aa75e3c58898289429321eb788c3106963d0dc886ec7a5f4adc321"
+checksum = "57d55af3b3e226502be1526dfdba67ab0e9c96fc293004e79576b2b9edb0dbdb"
 dependencies = [
  "cc",
  "libc",
@@ -2283,8 +2340,7 @@ dependencies = [
 [[package]]
 name = "parking_lot_core"
 version = "0.9.12"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2621685985a2ebf1c516881c026032ac7deafcda1a2c9b7850dc81e3dfcb64c1"
+source = "git+https://github.com/youknowone/parking_lot?branch=rustpython#4392edbe879acc9c0dd94eda53d2205d3ab912c9"
 dependencies = [
  "cfg-if",
  "libc",
@@ -2508,15 +2564,12 @@ dependencies = [
 ]
 
 [[package]]
-name = "postcard"
-version = "1.1.3"
+name = "potential_utf"
+version = "0.1.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6764c3b5dd454e283a30e6dfe78e9b31096d9e32036b5d1eaac7a6119ccb9a24"
+checksum = "b73949432f5e2a09657003c25bca5e19a0e9c84f8058ca374f49e0ebe605af77"
 dependencies = [
- "cobs",
- "embedded-io 0.4.0",
- "embedded-io 0.6.1",
- "serde",
+ "zerovec",
 ]
 
 [[package]]
@@ -2566,9 +2619,9 @@ dependencies = [
 
 [[package]]
 name = "psm"
-version = "0.1.29"
+version = "0.1.30"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1fa96cb91275ed31d6da3e983447320c4eb219ac180fa1679a0889ff32861e2d"
+checksum = "3852766467df634d74f0b2d7819bf8dc483a0eb2e3b0f50f756f9cfe8b0d18d8"
 dependencies = [
  "ar_archive_writer",
  "cc",
@@ -2576,9 +2629,9 @@ dependencies = [
 
 [[package]]
 name = "pymath"
-version = "0.1.5"
+version = "0.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bbfb6723b732fc7f0b29a0ee7150c7f70f947bf467b8c3e82530b13589a78b4c"
+checksum = "bc10e50b7a1f2cc3887e983721cb51fc7574be0066c84bff3ef9e5c096e8d6d5"
 dependencies = [
  "libc",
  "libm",
@@ -2590,35 +2643,32 @@ dependencies = [
 
 [[package]]
 name = "pyo3"
-version = "0.27.2"
+version = "0.28.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ab53c047fcd1a1d2a8820fe84f05d6be69e9526be40cb03b73f86b6b03e6d87d"
+checksum = "91fd8e38a3b50ed1167fb981cd6fd60147e091784c427b8f7183a7ee32c31c12"
 dependencies = [
- "indoc",
  "libc",
- "memoffset",
  "once_cell",
  "portable-atomic",
  "pyo3-build-config",
  "pyo3-ffi",
  "pyo3-macros",
- "unindent",
 ]
 
 [[package]]
 name = "pyo3-build-config"
-version = "0.27.2"
+version = "0.28.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b455933107de8642b4487ed26d912c2d899dec6114884214a0b3bb3be9261ea6"
+checksum = "e368e7ddfdeb98c9bca7f8383be1648fd84ab466bf2bc015e94008db6d35611e"
 dependencies = [
  "target-lexicon",
 ]
 
 [[package]]
 name = "pyo3-ffi"
-version = "0.27.2"
+version = "0.28.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1c85c9cbfaddf651b1221594209aed57e9e5cff63c4d11d1feead529b872a089"
+checksum = "7f29e10af80b1f7ccaf7f69eace800a03ecd13e883acfacc1e5d0988605f651e"
 dependencies = [
  "libc",
  "pyo3-build-config",
@@ -2626,9 +2676,9 @@ dependencies = [
 
 [[package]]
 name = "pyo3-macros"
-version = "0.27.2"
+version = "0.28.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0a5b10c9bf9888125d917fb4d2ca2d25c8df94c7ab5a52e13313a07e050a3b02"
+checksum = "df6e520eff47c45997d2fc7dd8214b25dd1310918bbb2642156ef66a67f29813"
 dependencies = [
  "proc-macro2",
  "pyo3-macros-backend",
@@ -2638,9 +2688,9 @@ dependencies = [
 
 [[package]]
 name = "pyo3-macros-backend"
-version = "0.27.2"
+version = "0.28.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "03b51720d314836e53327f5871d4c0cfb4fb37cc2c4a11cc71907a86342c40f9"
+checksum = "c4cdc218d835738f81c2338f822078af45b4afdf8b2e33cbb5916f108b813acb"
 dependencies = [
  "heck",
  "proc-macro2",
@@ -2651,9 +2701,9 @@ dependencies = [
 
 [[package]]
 name = "quote"
-version = "1.0.44"
+version = "1.0.45"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "21b2ebcf727b7760c461f091f9f0f539b77b8e87f2fd88131e7f1b433b3cece4"
+checksum = "41f2619966050689382d2b44f664f4bc593e129785a36d6ee376ddf37259b924"
 dependencies = [
  "proc-macro2",
 ]
@@ -2796,7 +2846,7 @@ version = "0.5.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ed2bf2547551a7053d6fdfafda3f938979645c44812fbfcda098faae3f1a362d"
 dependencies = [
- "bitflags 2.10.0",
+ "bitflags 2.11.0",
 ]
 
 [[package]]
@@ -2810,11 +2860,31 @@ dependencies = [
  "thiserror 1.0.69",
 ]
 
+[[package]]
+name = "ref-cast"
+version = "1.0.25"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f354300ae66f76f1c85c5f84693f0ce81d747e2c3f21a45fef496d89c960bf7d"
+dependencies = [
+ "ref-cast-impl",
+]
+
+[[package]]
+name = "ref-cast-impl"
+version = "1.0.25"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b7186006dcb21920990093f30e3dea63b7d6e977bf1256be20c3563a5db070da"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
 [[package]]
 name = "regalloc2"
-version = "0.13.5"
+version = "0.15.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "08effbc1fa53aaebff69521a5c05640523fab037b34a4a2c109506bc938246fa"
+checksum = "952ddbfc6f9f64d006c3efd8c9851a6ba2f2b944ba94730db255d55006e0ffda"
 dependencies = [
  "allocator-api2",
  "bumpalo",
@@ -2900,72 +2970,6 @@ dependencies = [
  "windows-sys 0.52.0",
 ]
 
-[[package]]
-name = "ruff_python_ast"
-version = "0.0.0"
-source = "git+https://github.com/astral-sh/ruff.git?rev=8b2e7b36f246b990fe473a84eef25ff429e59ecf#8b2e7b36f246b990fe473a84eef25ff429e59ecf"
-dependencies = [
- "aho-corasick",
- "bitflags 2.10.0",
- "compact_str",
- "get-size2",
- "is-macro",
- "memchr",
- "ruff_python_trivia",
- "ruff_source_file",
- "ruff_text_size",
- "rustc-hash",
- "thiserror 2.0.18",
-]
-
-[[package]]
-name = "ruff_python_parser"
-version = "0.0.0"
-source = "git+https://github.com/astral-sh/ruff.git?rev=8b2e7b36f246b990fe473a84eef25ff429e59ecf#8b2e7b36f246b990fe473a84eef25ff429e59ecf"
-dependencies = [
- "bitflags 2.10.0",
- "bstr",
- "compact_str",
- "get-size2",
- "memchr",
- "ruff_python_ast",
- "ruff_python_trivia",
- "ruff_text_size",
- "rustc-hash",
- "static_assertions",
- "unicode-ident",
- "unicode-normalization",
- "unicode_names2 1.3.0",
-]
-
-[[package]]
-name = "ruff_python_trivia"
-version = "0.0.0"
-source = "git+https://github.com/astral-sh/ruff.git?rev=8b2e7b36f246b990fe473a84eef25ff429e59ecf#8b2e7b36f246b990fe473a84eef25ff429e59ecf"
-dependencies = [
- "itertools 0.14.0",
- "ruff_source_file",
- "ruff_text_size",
- "unicode-ident",
-]
-
-[[package]]
-name = "ruff_source_file"
-version = "0.0.0"
-source = "git+https://github.com/astral-sh/ruff.git?rev=8b2e7b36f246b990fe473a84eef25ff429e59ecf#8b2e7b36f246b990fe473a84eef25ff429e59ecf"
-dependencies = [
- "memchr",
- "ruff_text_size",
-]
-
-[[package]]
-name = "ruff_text_size"
-version = "0.0.0"
-source = "git+https://github.com/astral-sh/ruff.git?rev=8b2e7b36f246b990fe473a84eef25ff429e59ecf#8b2e7b36f246b990fe473a84eef25ff429e59ecf"
-dependencies = [
- "get-size2",
-]
-
 [[package]]
 name = "rustc-hash"
 version = "2.1.1"
@@ -2983,11 +2987,11 @@ dependencies = [
 
 [[package]]
 name = "rustix"
-version = "1.1.3"
+version = "1.1.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "146c9e247ccc180c1f61615433868c99f3de3ae256a30a43b49f67c2d9171f34"
+checksum = "b6fe4565b9518b83ef4f91bb47ce29620ca828bd32cb7e408f0062e9930ba190"
 dependencies = [
- "bitflags 2.10.0",
+ "bitflags 2.11.0",
  "errno",
  "libc",
  "linux-raw-sys",
@@ -2996,9 +3000,9 @@ dependencies = [
 
 [[package]]
 name = "rustls"
-version = "0.23.36"
+version = "0.23.37"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c665f33d38cea657d9614f766881e4d510e0eda4239891eea56b4cadcf01801b"
+checksum = "758025cb5fccfd3bc2fd74708fd4682be41d99e5dff73c377c0646c6012c73a4"
 dependencies = [
  "aws-lc-rs",
  "once_cell",
@@ -3067,9 +3071,9 @@ checksum = "f87165f0995f63a9fbeea62b64d10b4d9d8e78ec6d7d51fb2125fda7bb36788f"
 
 [[package]]
 name = "rustls-webpki"
-version = "0.103.9"
+version = "0.103.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d7df23109aa6c1567d1c575b9952556388da57401e4ace1d15f79eedad0d8f53"
+checksum = "df33b2b81ac578cabaf06b89b0631153a3f416b0a886e8a7a1707fb51abbd1ef"
 dependencies = [
  "aws-lc-rs",
  "ring",
@@ -3079,7 +3083,7 @@ dependencies = [
 
 [[package]]
 name = "rustpython"
-version = "0.4.0"
+version = "0.5.0"
 dependencies = [
  "cfg-if",
  "criterion",
@@ -3091,9 +3095,9 @@ dependencies = [
  "libc",
  "log",
  "pyo3",
- "ruff_python_parser",
  "rustpython-compiler",
  "rustpython-pylib",
+ "rustpython-ruff_python_parser",
  "rustpython-stdlib",
  "rustpython-vm",
  "rustyline",
@@ -3102,10 +3106,10 @@ dependencies = [
 
 [[package]]
 name = "rustpython-codegen"
-version = "0.4.0"
+version = "0.5.0"
 dependencies = [
  "ahash",
- "bitflags 2.10.0",
+ "bitflags 2.11.0",
  "indexmap",
  "insta",
  "itertools 0.14.0",
@@ -3114,11 +3118,11 @@ dependencies = [
  "memchr",
  "num-complex",
  "num-traits",
- "ruff_python_ast",
- "ruff_python_parser",
- "ruff_text_size",
  "rustpython-compiler-core",
  "rustpython-literal",
+ "rustpython-ruff_python_ast",
+ "rustpython-ruff_python_parser",
+ "rustpython-ruff_text_size",
  "rustpython-wtf8",
  "thiserror 2.0.18",
  "unicode_names2 2.0.0",
@@ -3126,10 +3130,10 @@ dependencies = [
 
 [[package]]
 name = "rustpython-common"
-version = "0.4.0"
+version = "0.5.0"
 dependencies = [
  "ascii",
- "bitflags 2.10.0",
+ "bitflags 2.11.0",
  "cfg-if",
  "getrandom 0.3.4",
  "itertools 0.14.0",
@@ -3141,7 +3145,6 @@ dependencies = [
  "nix 0.30.1",
  "num-complex",
  "num-traits",
- "once_cell",
  "parking_lot",
  "radium",
  "rustpython-literal",
@@ -3154,41 +3157,42 @@ dependencies = [
 
 [[package]]
 name = "rustpython-compiler"
-version = "0.4.0"
+version = "0.5.0"
 dependencies = [
- "ruff_python_ast",
- "ruff_python_parser",
- "ruff_source_file",
- "ruff_text_size",
  "rustpython-codegen",
  "rustpython-compiler-core",
+ "rustpython-ruff_python_ast",
+ "rustpython-ruff_python_parser",
+ "rustpython-ruff_source_file",
+ "rustpython-ruff_text_size",
  "thiserror 2.0.18",
 ]
 
 [[package]]
 name = "rustpython-compiler-core"
-version = "0.4.0"
+version = "0.5.0"
 dependencies = [
- "bitflags 2.10.0",
+ "bitflags 2.11.0",
+ "bitflagset",
  "itertools 0.14.0",
  "lz4_flex",
  "malachite-bigint",
  "num-complex",
- "ruff_source_file",
+ "rustpython-ruff_source_file",
  "rustpython-wtf8",
 ]
 
 [[package]]
 name = "rustpython-compiler-source"
-version = "0.5.0+deprecated"
+version = "0.4.1+deprecated"
 dependencies = [
- "ruff_source_file",
- "ruff_text_size",
+ "rustpython-ruff_source_file",
+ "rustpython-ruff_text_size",
 ]
 
 [[package]]
 name = "rustpython-derive"
-version = "0.4.0"
+version = "0.5.0"
 dependencies = [
  "rustpython-compiler",
  "rustpython-derive-impl",
@@ -3197,7 +3201,7 @@ dependencies = [
 
 [[package]]
 name = "rustpython-derive-impl"
-version = "0.4.0"
+version = "0.5.0"
 dependencies = [
  "itertools 0.14.0",
  "maplit",
@@ -3212,14 +3216,14 @@ dependencies = [
 
 [[package]]
 name = "rustpython-doc"
-version = "0.4.0"
+version = "0.5.0"
 dependencies = [
  "phf 0.13.1",
 ]
 
 [[package]]
 name = "rustpython-jit"
-version = "0.4.0"
+version = "0.5.0"
 dependencies = [
  "approx",
  "cranelift",
@@ -3235,31 +3239,102 @@ dependencies = [
 
 [[package]]
 name = "rustpython-literal"
-version = "0.4.0"
+version = "0.5.0"
 dependencies = [
  "hexf-parse",
+ "icu_properties",
  "is-macro",
  "lexical-parse-float",
  "num-traits",
  "rand 0.9.2",
  "rustpython-wtf8",
- "unic-ucd-category",
 ]
 
 [[package]]
 name = "rustpython-pylib"
-version = "0.4.0"
+version = "0.5.0"
 dependencies = [
  "glob",
  "rustpython-compiler-core",
  "rustpython-derive",
 ]
 
+[[package]]
+name = "rustpython-ruff_python_ast"
+version = "0.15.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f021ff72cabf5e2cd6d8ec8813d376a8445a228dc610ab56c27bd9054cda70d4"
+dependencies = [
+ "aho-corasick",
+ "bitflags 2.11.0",
+ "compact_str",
+ "get-size2",
+ "is-macro",
+ "memchr",
+ "rustc-hash",
+ "rustpython-ruff_python_trivia",
+ "rustpython-ruff_source_file",
+ "rustpython-ruff_text_size",
+ "thiserror 2.0.18",
+]
+
+[[package]]
+name = "rustpython-ruff_python_parser"
+version = "0.15.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "01e6ee78bd9671fb5766664b2695fe1f2a92a961f4d9101646c570d8acdb1e0b"
+dependencies = [
+ "bitflags 2.11.0",
+ "bstr",
+ "compact_str",
+ "get-size2",
+ "memchr",
+ "rustc-hash",
+ "rustpython-ruff_python_ast",
+ "rustpython-ruff_python_trivia",
+ "rustpython-ruff_text_size",
+ "static_assertions",
+ "unicode-ident",
+ "unicode-normalization",
+ "unicode_names2 1.3.0",
+]
+
+[[package]]
+name = "rustpython-ruff_python_trivia"
+version = "0.15.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "79e7cfd1056f3a02ff0d2d0e4474286ca963260782f878b7b81c1dd87432e682"
+dependencies = [
+ "itertools 0.14.0",
+ "rustpython-ruff_source_file",
+ "rustpython-ruff_text_size",
+ "unicode-ident",
+]
+
+[[package]]
+name = "rustpython-ruff_source_file"
+version = "0.15.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "948107aad62ddb12a11fc7bf68a49e52a0b0a3737d415a2505e54f5a9edac737"
+dependencies = [
+ "memchr",
+ "rustpython-ruff_text_size",
+]
+
+[[package]]
+name = "rustpython-ruff_text_size"
+version = "0.15.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8291ee0f5a779e54ccd4e0151a0c426f8b49a123f99b5b6545db17ccdd4277aa"
+dependencies = [
+ "get-size2",
+]
+
 [[package]]
 name = "rustpython-sre_engine"
-version = "0.4.0"
+version = "0.5.0"
 dependencies = [
- "bitflags 2.10.0",
+ "bitflags 2.11.0",
  "criterion",
  "num_enum",
  "optional",
@@ -3268,7 +3343,7 @@ dependencies = [
 
 [[package]]
 name = "rustpython-stdlib"
-version = "0.4.0"
+version = "0.5.0"
 dependencies = [
  "adler32",
  "ahash",
@@ -3279,6 +3354,7 @@ dependencies = [
  "bzip2",
  "cfg-if",
  "chrono",
+ "constant_time_eq",
  "crc32fast",
  "crossbeam-utils",
  "csv-core",
@@ -3291,12 +3367,16 @@ dependencies = [
  "foreign-types-shared",
  "gethostname",
  "hex",
+ "hmac",
+ "icu_normalizer",
+ "icu_properties",
  "indexmap",
  "itertools 0.14.0",
  "libc",
+ "liblzma",
+ "liblzma-sys",
  "libsqlite3-sys",
  "libz-rs-sys",
- "lzma-sys",
  "mac_address",
  "malachite-bigint",
  "md-5",
@@ -3305,7 +3385,6 @@ dependencies = [
  "mt19937",
  "nix 0.30.1",
  "num-complex",
- "num-integer",
  "num-traits",
  "num_enum",
  "oid-registry",
@@ -3315,6 +3394,7 @@ dependencies = [
  "page_size",
  "parking_lot",
  "paste",
+ "pbkdf2",
  "pem-rfc7468 1.0.0",
  "phf 0.13.1",
  "pkcs8",
@@ -3327,6 +3407,10 @@ dependencies = [
  "rustls-platform-verifier",
  "rustpython-common",
  "rustpython-derive",
+ "rustpython-ruff_python_ast",
+ "rustpython-ruff_python_parser",
+ "rustpython-ruff_source_file",
+ "rustpython-ruff_text_size",
  "rustpython-vm",
  "schannel",
  "sha-1",
@@ -3338,14 +3422,7 @@ dependencies = [
  "termios",
  "tk-sys",
  "ucd",
- "unic-char-property",
- "unic-normal",
  "unic-ucd-age",
- "unic-ucd-bidi",
- "unic-ucd-category",
- "unic-ucd-ident",
- "unicode-bidi-mirroring",
- "unicode-casing",
  "unicode_names2 2.0.0",
  "uuid",
  "webpki-roots",
@@ -3354,23 +3431,19 @@ dependencies = [
  "x509-cert",
  "x509-parser",
  "xml",
- "xz2",
 ]
 
 [[package]]
 name = "rustpython-venvlauncher"
-version = "0.4.0"
-dependencies = [
- "windows-sys 0.61.2",
-]
+version = "0.5.0"
 
 [[package]]
 name = "rustpython-vm"
-version = "0.4.0"
+version = "0.5.0"
 dependencies = [
  "ahash",
  "ascii",
- "bitflags 2.10.0",
+ "bitflags 2.11.0",
  "bstr",
  "caseless",
  "cfg-if",
@@ -3385,6 +3458,7 @@ dependencies = [
  "glob",
  "half",
  "hex",
+ "icu_properties",
  "indexmap",
  "is-macro",
  "itertools 0.14.0",
@@ -3401,15 +3475,11 @@ dependencies = [
  "num-traits",
  "num_cpus",
  "num_enum",
- "once_cell",
  "optional",
  "parking_lot",
  "paste",
  "psm",
  "result-like",
- "ruff_python_ast",
- "ruff_python_parser",
- "ruff_text_size",
  "rustix",
  "rustpython-codegen",
  "rustpython-common",
@@ -3418,6 +3488,9 @@ dependencies = [
  "rustpython-derive",
  "rustpython-jit",
  "rustpython-literal",
+ "rustpython-ruff_python_ast",
+ "rustpython-ruff_python_parser",
+ "rustpython-ruff_text_size",
  "rustpython-sre_engine",
  "rustyline",
  "scoped-tls",
@@ -3427,12 +3500,8 @@ dependencies = [
  "strum",
  "strum_macros",
  "thiserror 2.0.18",
- "thread_local",
  "timsort",
  "uname",
- "unic-ucd-bidi",
- "unic-ucd-category",
- "unic-ucd-ident",
  "unicode-casing",
  "wasm-bindgen",
  "which",
@@ -3442,7 +3511,7 @@ dependencies = [
 
 [[package]]
 name = "rustpython-wtf8"
-version = "0.4.0"
+version = "0.5.0"
 dependencies = [
  "ascii",
  "bstr",
@@ -3452,11 +3521,10 @@ dependencies = [
 
 [[package]]
 name = "rustpython_wasm"
-version = "0.4.0"
+version = "0.5.0"
 dependencies = [
  "console_error_panic_hook",
  "js-sys",
- "ruff_python_parser",
  "rustpython-common",
  "rustpython-pylib",
  "rustpython-stdlib",
@@ -3480,7 +3548,7 @@ version = "17.0.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e902948a25149d50edc1a8e0141aad50f54e22ba83ff988cf8f7c9ef07f50564"
 dependencies = [
- "bitflags 2.10.0",
+ "bitflags 2.11.0",
  "cfg-if",
  "clipboard-win",
  "fd-lock",
@@ -3504,9 +3572,9 @@ checksum = "a50f4cf475b65d88e057964e0e9bb1f0aa9bbb2036dc65c64596b42932536984"
 
 [[package]]
 name = "safe_arch"
-version = "0.9.3"
+version = "1.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "629516c85c29fe757770fa03f2074cf1eac43d44c02a3de9fc2ef7b0e207dfdd"
+checksum = "1f7caad094bd561859bcd467734a720c3c1f5d1f338995351fefe2190c45efed"
 dependencies = [
  "bytemuck",
 ]
@@ -3531,9 +3599,9 @@ dependencies = [
 
 [[package]]
 name = "schannel"
-version = "0.1.28"
+version = "0.1.29"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "891d81b926048e76efe18581bf793546b4c0eaf8448d72be8de2bbee5fd166e1"
+checksum = "91c1b7e4904c873ef0710c1f407dde2e6287de2bebc1bbbf7d430bb7cbffd939"
 dependencies = [
  "windows-sys 0.61.2",
 ]
@@ -3567,7 +3635,7 @@ version = "3.5.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b3297343eaf830f66ede390ea39da1d462b6b0c1b000f420d0a83f898bbbe6ef"
 dependencies = [
- "bitflags 2.10.0",
+ "bitflags 2.11.0",
  "core-foundation 0.10.1",
  "core-foundation-sys",
  "libc",
@@ -3640,9 +3708,9 @@ dependencies = [
 
 [[package]]
 name = "serde_spanned"
-version = "1.0.4"
+version = "1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f8bbf91e5a4d6315eee45e704372590b30e260ee83af6639d64557f51b067776"
+checksum = "876ac351060d4f882bb1032b6369eb0aef79ad9df1ea8bc404874d8cc3d0cd98"
 dependencies = [
  "serde_core",
 ]
@@ -3742,18 +3810,15 @@ name = "smallvec"
 version = "1.15.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "67b1b7a3b5fe4f1376887184045fcf45c69e92af734b7aaddc05fb777b6fbd03"
-dependencies = [
- "serde",
-]
 
 [[package]]
 name = "socket2"
-version = "0.6.2"
+version = "0.6.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "86f4aa3ad99f2088c990dfa82d367e19cb29268ed67c574d10d0a4bfe71f07e0"
+checksum = "3a766e1110788c36f4fa1c2b71b387a7815aa65f88ce0229841826633d93723e"
 dependencies = [
  "libc",
- "windows-sys 0.60.2",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
@@ -3780,15 +3845,15 @@ checksum = "a2eb9349b6444b326872e140eb1cf5e7c522154d69e7a0ffb0fb81c06b37543f"
 
 [[package]]
 name = "strum"
-version = "0.27.2"
+version = "0.28.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "af23d6f6c1a224baef9d3f61e287d2761385a5b88fdab4eb4c6f11aeb54c4bcf"
+checksum = "9628de9b8791db39ceda2b119bbe13134770b56c138ec1d3af810d045c04f9bd"
 
 [[package]]
 name = "strum_macros"
-version = "0.27.2"
+version = "0.28.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7695ce3845ea4b33927c055a39dc438a45b059f7c1b3d91d38d10355fb8cbca7"
+checksum = "ab85eea0270ee17587ed4156089e10b9e6880ee688791d45a905f5b1ca36f664"
 dependencies = [
  "heck",
  "proc-macro2",
@@ -3804,9 +3869,9 @@ checksum = "13c2bddecc57b384dee18652358fb23172facb8a2c51ccc10d74c157bdea3292"
 
 [[package]]
 name = "syn"
-version = "2.0.114"
+version = "2.0.117"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d4d107df263a3013ef9b1879b0df87d706ff80f65a86ea879bd9c31f9b307c2a"
+checksum = "e665b8803e7b1d2a727f4023456bbbbe74da67099c585258af0ad9c5013b9b99"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -3841,7 +3906,7 @@ version = "0.7.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a13f3d0daba03132c0aa9767f98351b3488edc2c100cda2d2ec2b04f3d8d3c8b"
 dependencies = [
- "bitflags 2.10.0",
+ "bitflags 2.11.0",
  "core-foundation 0.9.4",
  "system-configuration-sys",
 ]
@@ -3950,20 +4015,11 @@ dependencies = [
  "winapi",
 ]
 
-[[package]]
-name = "thread_local"
-version = "1.1.9"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f60246a4944f24f6e018aa17cdeffb7818b76356965d03b07d6a9886e8962185"
-dependencies = [
- "cfg-if",
-]
-
 [[package]]
 name = "time"
-version = "0.3.46"
+version = "0.3.47"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9da98b7d9b7dad93488a84b8248efc35352b0b2657397d4167e7ad67e5d535e5"
+checksum = "743bd48c283afc0388f9b8827b976905fb217ad9e647fae3a379a9283c4def2c"
 dependencies = [
  "deranged",
  "itoa",
@@ -3982,9 +4038,9 @@ checksum = "7694e1cfe791f8d31026952abf09c69ca6f6fa4e1a1229e18988f06a04a12dca"
 
 [[package]]
 name = "time-macros"
-version = "0.2.26"
+version = "0.2.27"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "78cc610bac2dcee56805c99642447d4c5dbde4d01f752ffea0199aee1f601dc4"
+checksum = "2e70e4c5a0e0a8a4823ad65dfe1a6930e4f4d756dcd9dd7939022b5e8c501215"
 dependencies = [
  "num-conv",
  "time-core",
@@ -3996,6 +4052,16 @@ version = "0.1.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "639ce8ef6d2ba56be0383a94dd13b92138d58de44c62618303bb798fa92bdc00"
 
+[[package]]
+name = "tinystr"
+version = "0.8.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "42d3e9c45c09de15d06dd8acf5f4e0e399e85927b7f00711024eb7ae10fa4869"
+dependencies = [
+ "displaydoc",
+ "zerovec",
+]
+
 [[package]]
 name = "tinytemplate"
 version = "1.2.1"
@@ -4053,9 +4119,9 @@ dependencies = [
 
 [[package]]
 name = "toml"
-version = "0.9.11+spec-1.1.0"
+version = "1.1.0+spec-1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f3afc9a848309fe1aaffaed6e1546a7a14de1f935dc9d89d32afd9a44bab7c46"
+checksum = "f8195ca05e4eb728f4ba94f3e3291661320af739c4e43779cbdfae82ab239fcc"
 dependencies = [
  "indexmap",
  "serde_core",
@@ -4068,27 +4134,27 @@ dependencies = [
 
 [[package]]
 name = "toml_datetime"
-version = "0.7.5+spec-1.1.0"
+version = "1.1.0+spec-1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "92e1cfed4a3038bc5a127e35a2d360f145e1f4b971b551a2ba5fd7aedf7e1347"
+checksum = "97251a7c317e03ad83774a8752a7e81fb6067740609f75ea2b585b569a59198f"
 dependencies = [
  "serde_core",
 ]
 
 [[package]]
 name = "toml_parser"
-version = "1.0.6+spec-1.1.0"
+version = "1.1.0+spec-1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a3198b4b0a8e11f09dd03e133c0280504d0801269e9afa46362ffde1cbeebf44"
+checksum = "2334f11ee363607eb04df9b8fc8a13ca1715a72ba8662a26ac285c98aabb4011"
 dependencies = [
  "winnow",
 ]
 
 [[package]]
 name = "toml_writer"
-version = "1.0.6+spec-1.1.0"
+version = "1.1.0+spec-1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ab16f14aed21ee8bfd8ec22513f7287cd4a91aa92e44edfe2c17ddd004e92607"
+checksum = "d282ade6016312faf3e41e57ebbba0c073e4056dab1232ab1cb624199648f8ed"
 
 [[package]]
 name = "twox-hash"
@@ -4138,15 +4204,6 @@ version = "0.9.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "80d7ff825a6a654ee85a63e80f92f054f904f21e7d12da4e22f9834a4aaa35bc"
 
-[[package]]
-name = "unic-normal"
-version = "0.9.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f09d64d33589a94628bc2aeb037f35c2e25f3f049c7348b5aa5580b48e6bba62"
-dependencies = [
- "unic-ucd-normal",
-]
-
 [[package]]
 name = "unic-ucd-age"
 version = "0.9.0"
@@ -4158,61 +4215,6 @@ dependencies = [
  "unic-ucd-version",
 ]
 
-[[package]]
-name = "unic-ucd-bidi"
-version = "0.9.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d1d568b51222484e1f8209ce48caa6b430bf352962b877d592c29ab31fb53d8c"
-dependencies = [
- "unic-char-property",
- "unic-char-range",
- "unic-ucd-version",
-]
-
-[[package]]
-name = "unic-ucd-category"
-version = "0.9.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1b8d4591f5fcfe1bd4453baaf803c40e1b1e69ff8455c47620440b46efef91c0"
-dependencies = [
- "matches",
- "unic-char-property",
- "unic-char-range",
- "unic-ucd-version",
-]
-
-[[package]]
-name = "unic-ucd-hangul"
-version = "0.9.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "eb1dc690e19010e1523edb9713224cba5ef55b54894fe33424439ec9a40c0054"
-dependencies = [
- "unic-ucd-version",
-]
-
-[[package]]
-name = "unic-ucd-ident"
-version = "0.9.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e230a37c0381caa9219d67cf063aa3a375ffed5bf541a452db16e744bdab6987"
-dependencies = [
- "unic-char-property",
- "unic-char-range",
- "unic-ucd-version",
-]
-
-[[package]]
-name = "unic-ucd-normal"
-version = "0.9.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "86aed873b8202d22b13859dda5fe7c001d271412c31d411fd9b827e030569410"
-dependencies = [
- "unic-char-property",
- "unic-char-range",
- "unic-ucd-hangul",
- "unic-ucd-version",
-]
-
 [[package]]
 name = "unic-ucd-version"
 version = "0.9.0"
@@ -4222,12 +4224,6 @@ dependencies = [
  "unic-common",
 ]
 
-[[package]]
-name = "unicode-bidi-mirroring"
-version = "0.4.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5dfa6e8c60bb66d49db113e0125ee8711b7647b5579dc7f5f19c42357ed039fe"
-
 [[package]]
 name = "unicode-casing"
 version = "0.1.1"
@@ -4303,12 +4299,6 @@ dependencies = [
  "rand 0.8.5",
 ]
 
-[[package]]
-name = "unindent"
-version = "0.2.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7264e107f553ccae879d21fbea1d6724ac785e8c3bfc762137959b5802826ef3"
-
 [[package]]
 name = "untrusted"
 version = "0.7.1"
@@ -4321,6 +4311,18 @@ version = "0.9.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8ecb6da28b8a351d773b68d5825ac39017e680750f980f3a1a85cd8dd28a47c1"
 
+[[package]]
+name = "utf16_iter"
+version = "1.0.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c8232dd3cdaed5356e0f716d285e4b40b932ac434100fe9b7e0e8e935b9e6246"
+
+[[package]]
+name = "utf8_iter"
+version = "1.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b6c140620e7ffbb22c2dee59cafe6084a59b5ffc27a8859a5f0d494b5d52b6be"
+
 [[package]]
 name = "utf8parse"
 version = "0.2.2"
@@ -4329,9 +4331,9 @@ checksum = "06abde3611657adf66d383f00b093d7faecc7fa57071cce2578660c9f1010821"
 
 [[package]]
 name = "uuid"
-version = "1.20.0"
+version = "1.22.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ee48d38b119b0cd71fe4141b30f5ba9c7c5d9f4e7a3a8b4a674e4b6ef789976f"
+checksum = "a68d3c8f01c0cfa54a75291d83601161799e4a89a39e0929f4b0354d88757a37"
 dependencies = [
  "atomic",
  "js-sys",
@@ -4435,59 +4437,27 @@ dependencies = [
 ]
 
 [[package]]
-name = "wasmparser"
-version = "0.243.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f6d8db401b0528ec316dfbe579e6ab4152d61739cfe076706d2009127970159d"
-dependencies = [
- "bitflags 2.10.0",
- "hashbrown 0.15.5",
- "indexmap",
- "serde",
-]
-
-[[package]]
-name = "wasmtime-environ"
-version = "41.0.1"
+name = "wasmtime-internal-core"
+version = "43.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "37b9af430b11ff3cd63fbef54cf38e26154089c179316b8a5e400b8ba2d0ebf1"
+checksum = "e671917bb6856ae360cb59d7aaf26f1cfd042c7b924319dd06fd380739fc0b2e"
 dependencies = [
- "anyhow",
- "cranelift-bitset",
- "cranelift-entity",
- "gimli",
- "indexmap",
- "log",
- "object",
- "postcard",
- "serde",
- "serde_derive",
- "smallvec",
- "target-lexicon",
- "wasmparser",
+ "hashbrown 0.16.1",
+ "libm",
 ]
 
 [[package]]
 name = "wasmtime-internal-jit-icache-coherence"
-version = "41.0.1"
+version = "43.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "85b46da671c07242b5f5eab491b12d6c25dd26929f1693c055fcca94489ef8f5"
+checksum = "9b3112806515fac8495883885eb8dbdde849988ae91fe6beb544c0d7c0f4c9aa"
 dependencies = [
  "cfg-if",
  "libc",
- "wasmtime-environ",
+ "wasmtime-internal-core",
  "windows-sys 0.61.2",
 ]
 
-[[package]]
-name = "wasmtime-internal-math"
-version = "41.0.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4d1f0763c6f6f78e410f964db9f53d9b84ab4cc336945e81f0b78717b0a9934e"
-dependencies = [
- "libm",
-]
-
 [[package]]
 name = "web-sys"
 version = "0.3.85"
@@ -4509,29 +4479,27 @@ dependencies = [
 
 [[package]]
 name = "webpki-roots"
-version = "1.0.5"
+version = "1.0.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "12bed680863276c63889429bfd6cab3b99943659923822de1c8a39c49e4d722c"
+checksum = "22cfaf3c063993ff62e73cb4311efde4db1efb31ab78a3e5c457939ad5cc0bed"
 dependencies = [
  "rustls-pki-types",
 ]
 
 [[package]]
 name = "which"
-version = "8.0.0"
+version = "8.0.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d3fabb953106c3c8eea8306e4393700d7657561cb43122571b172bbfb7c7ba1d"
+checksum = "81995fafaaaf6ae47a7d0cc83c67caf92aeb7e5331650ae6ff856f7c0c60c459"
 dependencies = [
- "env_home",
- "rustix",
- "winsafe",
+ "libc",
 ]
 
 [[package]]
 name = "wide"
-version = "0.8.3"
+version = "1.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "13ca908d26e4786149c48efcf6c0ea09ab0e06d1fe3c17dc1b4b0f1ca4a7e788"
+checksum = "ac11b009ebeae802ed758530b6496784ebfee7a87b9abfbcaf3bbe25b814eb25"
 dependencies = [
  "bytemuck",
  "safe_arch",
@@ -4866,32 +4834,38 @@ checksum = "d6bbff5f0aada427a1e5a6da5f1f98158182f26556f345ac9e04d36d0ebed650"
 
 [[package]]
 name = "winnow"
-version = "0.7.14"
+version = "1.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5a5364e9d77fcdeeaa6062ced926ee3381faa2ee02d3eb83a5c27a8825540829"
+checksum = "a90e88e4667264a994d34e6d1ab2d26d398dcdca8b7f52bec8668957517fc7d8"
 
 [[package]]
 name = "winresource"
-version = "0.1.30"
+version = "0.1.31"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e287ced0f21cd11f4035fe946fd3af145f068d1acb708afd248100f89ec7432d"
+checksum = "0986a8b1d586b7d3e4fe3d9ea39fb451ae22869dcea4aa109d287a374d866087"
 dependencies = [
  "toml",
  "version_check",
 ]
 
-[[package]]
-name = "winsafe"
-version = "0.0.19"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d135d17ab770252ad95e9a872d365cf3090e3be864a34ab46f48555993efc904"
-
 [[package]]
 name = "wit-bindgen"
 version = "0.51.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d7249219f66ced02969388cf2bb044a09756a083d0fab1e566056b04d9fbcaa5"
 
+[[package]]
+name = "write16"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d1890f4022759daae28ed4fe62859b1236caebfc61ede2f63ed4e695f3f6d936"
+
+[[package]]
+name = "writeable"
+version = "0.6.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9edde0db4769d2dc68579893f2306b26c6ecfbe0ef499b013d731b7b9247e0b9"
+
 [[package]]
 name = "x509-cert"
 version = "0.2.5"
@@ -4908,9 +4882,9 @@ dependencies = [
 
 [[package]]
 name = "x509-parser"
-version = "0.18.0"
+version = "0.18.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "eb3e137310115a65136898d2079f003ce33331a6c4b0d51f1531d1be082b6425"
+checksum = "d43b0f71ce057da06bc0851b23ee24f3f86190b07203dd8f567d0b706a185202"
 dependencies = [
  "asn1-rs",
  "data-encoding",
@@ -4930,12 +4904,26 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b8aa498d22c9bbaf482329839bc5620c46be275a19a812e9a22a2b07529a642a"
 
 [[package]]
-name = "xz2"
-version = "0.1.7"
+name = "yoke"
+version = "0.8.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "388c44dc09d76f1536602ead6d325eb532f5c122f17782bd57fb47baeeb767e2"
+checksum = "72d6e5c6afb84d73944e5cedb052c4680d5657337201555f9f2a16b7406d4954"
 dependencies = [
- "lzma-sys",
+ "stable_deref_trait",
+ "yoke-derive",
+ "zerofrom",
+]
+
+[[package]]
+name = "yoke-derive"
+version = "0.8.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b659052874eb698efe5b9e8cf382204678a0086ebf46982b79d6ca3182927e5d"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+ "synstructure",
 ]
 
 [[package]]
@@ -4958,6 +4946,27 @@ dependencies = [
  "syn",
 ]
 
+[[package]]
+name = "zerofrom"
+version = "0.1.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "50cc42e0333e05660c3587f3bf9d0478688e15d870fab3346451ce7f8c9fbea5"
+dependencies = [
+ "zerofrom-derive",
+]
+
+[[package]]
+name = "zerofrom-derive"
+version = "0.1.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d71e5d6e06ab090c67b5e44993ec16b72dcbaabc526db883a360057678b48502"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+ "synstructure",
+]
+
 [[package]]
 name = "zeroize"
 version = "1.8.2"
@@ -4978,12 +4987,51 @@ dependencies = [
  "syn",
 ]
 
+[[package]]
+name = "zerotrie"
+version = "0.2.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2a59c17a5562d507e4b54960e8569ebee33bee890c70aa3fe7b97e85a9fd7851"
+dependencies = [
+ "displaydoc",
+ "yoke",
+ "zerofrom",
+]
+
+[[package]]
+name = "zerovec"
+version = "0.11.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6c28719294829477f525be0186d13efa9a3c602f7ec202ca9e353d310fb9a002"
+dependencies = [
+ "yoke",
+ "zerofrom",
+ "zerovec-derive",
+]
+
+[[package]]
+name = "zerovec-derive"
+version = "0.11.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "eadce39539ca5cb3985590102671f2567e659fca9666581ad3411d59207951f3"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
 [[package]]
 name = "zlib-rs"
 version = "0.5.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "40990edd51aae2c2b6907af74ffb635029d5788228222c4bb811e9351c0caad3"
 
+[[package]]
+name = "zlib-rs"
+version = "0.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a7948af682ccbc3342b6e9420e8c51c1fe5d7bf7756002b4a3c6cabfe96a7e3c"
+
 [[package]]
 name = "zmij"
 version = "1.0.17"
diff --git a/Cargo.toml b/Cargo.toml
index 54d1fdda41f..7bd8b8f3374 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -10,7 +10,8 @@ repository.workspace = true
 license.workspace = true
 
 [features]
-default = ["threading", "stdlib", "stdio", "importlib", "ssl-rustls"]
+default = ["threading", "stdlib", "stdio", "importlib", "ssl-rustls", "host_env"]
+host_env = ["rustpython-vm/host_env", "rustpython-stdlib?/host_env"]
 importlib = ["rustpython-vm/importlib"]
 encodings = ["rustpython-vm/encodings"]
 stdio = ["rustpython-vm/stdio"]
@@ -33,8 +34,7 @@ winresource = "0.1"
 rustpython-compiler = { workspace = true }
 rustpython-pylib = { workspace = true, optional = true }
 rustpython-stdlib = { workspace = true, optional = true, features = ["compiler"] }
-rustpython-vm = { workspace = true, features = ["compiler"] }
-ruff_python_parser = { workspace = true }
+rustpython-vm = { workspace = true, features = ["compiler", "gc"] }
 
 cfg-if = { workspace = true }
 log = { workspace = true }
@@ -53,8 +53,9 @@ rustyline = { workspace = true }
 
 [dev-dependencies]
 criterion = { workspace = true }
-pyo3 = { version = "0.27", features = ["auto-initialize"] }
+pyo3 = { version = "0.28.2", features = ["auto-initialize"] }
 rustpython-stdlib = { workspace = true }
+ruff_python_parser = { workspace = true }
 
 [[bench]]
 name = "execution"
@@ -76,10 +77,21 @@ opt-level = 3
 # https://github.com/rust-lang/rust/issues/92869
 # lto = "thin"
 
-# Doesn't change often
+# Some crates don't change as much but benefit more from
+# more expensive optimization passes, so we selectively
+# decrease codegen-units in some cases.
 [profile.release.package.rustpython-doc]
 codegen-units = 1
 
+[profile.release.package.rustpython-literal]
+codegen-units = 1
+
+[profile.release.package.rustpython-common]
+codegen-units = 1
+
+[profile.release.package.rustpython-wtf8]
+codegen-units = 1
+
 [profile.bench]
 lto = "thin"
 codegen-units = 1
@@ -89,6 +101,7 @@ opt-level = 3
 lto = "thin"
 
 [patch.crates-io]
+parking_lot_core = { git = "https://github.com/youknowone/parking_lot", branch = "rustpython" }
 # REDOX START, Uncomment when you want to compile/check with redoxer
 # REDOX END
 
@@ -120,7 +133,7 @@ members = [
 exclude = ["pymath"]
 
 [workspace.package]
-version = "0.4.0"
+version = "0.5.0"
 authors = ["RustPython Team"]
 edition = "2024"
 rust-version = "1.93.0"
@@ -128,35 +141,43 @@ repository = "https://github.com/RustPython/RustPython"
 license = "MIT"
 
 [workspace.dependencies]
-rustpython-compiler-core = { path = "crates/compiler-core", version = "0.4.0" }
-rustpython-compiler = { path = "crates/compiler", version = "0.4.0" }
-rustpython-codegen = { path = "crates/codegen", version = "0.4.0" }
-rustpython-common = { path = "crates/common", version = "0.4.0" }
-rustpython-derive = { path = "crates/derive", version = "0.4.0" }
-rustpython-derive-impl = { path = "crates/derive-impl", version = "0.4.0" }
-rustpython-jit = { path = "crates/jit", version = "0.4.0" }
-rustpython-literal = { path = "crates/literal", version = "0.4.0" }
-rustpython-vm = { path = "crates/vm", default-features = false, version = "0.4.0" }
-rustpython-pylib = { path = "crates/pylib", version = "0.4.0" }
-rustpython-stdlib = { path = "crates/stdlib", default-features = false, version = "0.4.0" }
-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.14 is based on commit 8b2e7b36f246b990fe473a84eef25ff429e59ecf
+rustpython-compiler-core = { path = "crates/compiler-core", version = "0.5.0" }
+rustpython-compiler = { path = "crates/compiler", version = "0.5.0" }
+rustpython-codegen = { path = "crates/codegen", version = "0.5.0" }
+rustpython-common = { path = "crates/common", version = "0.5.0" }
+rustpython-derive = { path = "crates/derive", version = "0.5.0" }
+rustpython-derive-impl = { path = "crates/derive-impl", version = "0.5.0" }
+rustpython-jit = { path = "crates/jit", version = "0.5.0" }
+rustpython-literal = { path = "crates/literal", version = "0.5.0" }
+rustpython-vm = { path = "crates/vm", default-features = false, version = "0.5.0" }
+rustpython-pylib = { path = "crates/pylib", version = "0.5.0" }
+rustpython-stdlib = { path = "crates/stdlib", default-features = false, version = "0.5.0" }
+rustpython-sre_engine = { path = "crates/sre_engine", version = "0.5.0" }
+rustpython-wtf8 = { path = "crates/wtf8", version = "0.5.0" }
+rustpython-doc = { path = "crates/doc", version = "0.5.0" }
+
+# Use RustPython-packaged Ruff crates from the published fork while keeping
+# existing crate names in the codebase.
+ruff_python_parser = { package = "rustpython-ruff_python_parser", version = "0.15.8" }
+ruff_python_ast = { package = "rustpython-ruff_python_ast", version = "0.15.8" }
+ruff_text_size = { package = "rustpython-ruff_text_size", version = "0.15.8" }
+ruff_source_file = { package = "rustpython-ruff_source_file", version = "0.15.8" }
+# To update ruff crates, comment out the above lines and uncomment the following lines to pull directly from the Ruff repository at the specified commit hash.
+# Ruff tag 0.15.8 is based on commit c2a8815842f9dc5d24ec19385eae0f1a7188b0d9
 # 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 = "8b2e7b36f246b990fe473a84eef25ff429e59ecf" }
-ruff_python_ast = { git = "https://github.com/astral-sh/ruff.git", rev = "8b2e7b36f246b990fe473a84eef25ff429e59ecf" }
-ruff_text_size = { git = "https://github.com/astral-sh/ruff.git", rev = "8b2e7b36f246b990fe473a84eef25ff429e59ecf" }
-ruff_source_file = { git = "https://github.com/astral-sh/ruff.git", rev = "8b2e7b36f246b990fe473a84eef25ff429e59ecf" }
+# ruff_python_parser = { git = "https://github.com/astral-sh/ruff.git", rev = "c2a8815842f9dc5d24ec19385eae0f1a7188b0d9" }
+# ruff_python_ast = { git = "https://github.com/astral-sh/ruff.git", rev = "c2a8815842f9dc5d24ec19385eae0f1a7188b0d9" }
+# ruff_text_size = { git = "https://github.com/astral-sh/ruff.git", rev = "c2a8815842f9dc5d24ec19385eae0f1a7188b0d9" }
+# ruff_source_file = { git = "https://github.com/astral-sh/ruff.git", rev = "c2a8815842f9dc5d24ec19385eae0f1a7188b0d9" }
 
 phf = { version = "0.13.1", default-features = false, features = ["macros"]}
 ahash = "0.8.12"
 ascii = "1.1"
-bitflags = "2.9.4"
+bitflags = "2.11.0"
+bitflagset = "0.0.3"
 bstr = "1"
 cfg-if = "1.0"
-chrono = { version = "0.4.43", default-features = false, features = ["clock", "oldtime", "std"] }
+chrono = { version = "0.4.44", default-features = false, features = ["clock", "oldtime", "std"] }
 constant_time_eq = "0.4"
 criterion = { version = "0.8", features = ["html_reports"] }
 crossbeam-utils = "0.8.21"
@@ -168,50 +189,44 @@ indexmap = { version = "2.13.0", features = ["std"] }
 insta = "1.46"
 itertools = "0.14.0"
 is-macro = "0.3.7"
-junction = "1.4.1"
-libc = "0.2.180"
+junction = "1.4.2"
+libc = "0.2.183"
 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.9"
-malachite-q = "0.9"
-malachite-base = "0.9"
-memchr = "2.7.4"
+malachite-bigint = "0.9.1"
+malachite-q = "0.9.1"
+malachite-base = "0.9.1"
+memchr = "2.8.0"
 num-complex = "0.4.6"
 num-integer = "0.1.46"
 num-traits = "0.2"
 num_enum = { version = "0.7", default-features = false }
 optional = "0.5"
-once_cell = "1.20.3"
 parking_lot = "0.12.3"
 paste = "1.0.15"
 proc-macro2 = "1.0.105"
-pymath = { version = "0.1.5", features = ["mul_add", "malachite-bigint", "complex"] }
-quote = "1.0.44"
+pymath = { version = "0.2.0", features = ["mul_add", "malachite-bigint", "complex"] }
+quote = "1.0.45"
 radium = "1.1.1"
 rand = "0.9"
 rand_core = { version = "0.9", features = ["os_rng"] }
 rustix = { version = "1.1", features = ["event"] }
 rustyline = "17.0.1"
 serde = { package = "serde_core", version = "1.0.225", default-features = false, features = ["alloc"] }
-schannel = "0.1.28"
+schannel = "0.1.29"
 scoped-tls = "1"
 scopeguard = "1"
 static_assertions = "1.1"
-strum = "0.27"
-strum_macros = "0.27"
+strum = "0.28"
+strum_macros = "0.28"
 syn = "2"
 thiserror = "2.0"
-thread_local = "1.1.9"
+icu_properties = "2"
+icu_normalizer = "2"
 unicode-casing = "0.1.1"
-unic-char-property = "0.9.0"
-unic-normal = "0.9.0"
 unic-ucd-age = "0.9.0"
-unic-ucd-bidi = "0.9.0"
-unic-ucd-category = "0.9.0"
-unic-ucd-ident = "0.9.0"
 unicode_names2 = "2.0.0"
-unicode-bidi-mirroring = "0.4"
 widestring = "1.2.0"
 windows-sys = "0.61.2"
 wasm-bindgen = "0.2.106"
@@ -224,9 +239,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"
+alloc_instead_of_core = "warn"
+std_instead_of_alloc = "warn"
+std_instead_of_core = "warn"
 perf = "warn"
 style = "warn"
 complexity = "warn"
diff --git a/DEVELOPMENT.md b/DEVELOPMENT.md
index 24c149eebef..7573f0f2640 100644
--- a/DEVELOPMENT.md
+++ b/DEVELOPMENT.md
@@ -65,7 +65,7 @@ $ pytest -v
 Rust unit tests can be run with `cargo`:
 
 ```shell
-$ cargo test --workspace --exclude rustpython_wasm
+$ cargo test --workspace --exclude rustpython_wasm --exclude rustpython-venvlauncher
 ```
 
 Python unit tests can be run by compiling RustPython and running the test module:
diff --git a/Lib/_ast_unparse.py b/Lib/_ast_unparse.py
new file mode 100644
index 00000000000..1c8741b5a55
--- /dev/null
+++ b/Lib/_ast_unparse.py
@@ -0,0 +1,1161 @@
+# This module contains ``ast.unparse()``, defined here
+# to improve the import time for the ``ast`` module.
+import sys
+from _ast import *
+from ast import NodeVisitor
+from contextlib import contextmanager, nullcontext
+from enum import IntEnum, auto, _simple_enum
+
+# Large float and imaginary literals get turned into infinities in the AST.
+# We unparse those infinities to INFSTR.
+_INFSTR = "1e" + repr(sys.float_info.max_10_exp + 1)
+
+@_simple_enum(IntEnum)
+class _Precedence:
+    """Precedence table that originated from python grammar."""
+
+    NAMED_EXPR = auto()      # <target> := <expr1>
+    TUPLE = auto()           # <expr1>, <expr2>
+    YIELD = auto()           # 'yield', 'yield from'
+    TEST = auto()            # 'if'-'else', 'lambda'
+    OR = auto()              # 'or'
+    AND = auto()             # 'and'
+    NOT = auto()             # 'not'
+    CMP = auto()             # '<', '>', '==', '>=', '<=', '!=',
+                             # 'in', 'not in', 'is', 'is not'
+    EXPR = auto()
+    BOR = EXPR               # '|'
+    BXOR = auto()            # '^'
+    BAND = auto()            # '&'
+    SHIFT = auto()           # '<<', '>>'
+    ARITH = auto()           # '+', '-'
+    TERM = auto()            # '*', '@', '/', '%', '//'
+    FACTOR = auto()          # unary '+', '-', '~'
+    POWER = auto()           # '**'
+    AWAIT = auto()           # 'await'
+    ATOM = auto()
+
+    def next(self):
+        try:
+            return self.__class__(self + 1)
+        except ValueError:
+            return self
+
+
+_SINGLE_QUOTES = ("'", '"')
+_MULTI_QUOTES = ('"""', "'''")
+_ALL_QUOTES = (*_SINGLE_QUOTES, *_MULTI_QUOTES)
+
+class Unparser(NodeVisitor):
+    """Methods in this class recursively traverse an AST and
+    output source code for the abstract syntax; original formatting
+    is disregarded."""
+
+    def __init__(self):
+        self._source = []
+        self._precedences = {}
+        self._type_ignores = {}
+        self._indent = 0
+        self._in_try_star = False
+        self._in_interactive = False
+
+    def interleave(self, inter, f, seq):
+        """Call f on each item in seq, calling inter() in between."""
+        seq = iter(seq)
+        try:
+            f(next(seq))
+        except StopIteration:
+            pass
+        else:
+            for x in seq:
+                inter()
+                f(x)
+
+    def items_view(self, traverser, items):
+        """Traverse and separate the given *items* with a comma and append it to
+        the buffer. If *items* is a single item sequence, a trailing comma
+        will be added."""
+        if len(items) == 1:
+            traverser(items[0])
+            self.write(",")
+        else:
+            self.interleave(lambda: self.write(", "), traverser, items)
+
+    def maybe_newline(self):
+        """Adds a newline if it isn't the start of generated source"""
+        if self._source:
+            self.write("\n")
+
+    def maybe_semicolon(self):
+        """Adds a "; " delimiter if it isn't the start of generated source"""
+        if self._source:
+            self.write("; ")
+
+    def fill(self, text="", *, allow_semicolon=True):
+        """Indent a piece of text and append it, according to the current
+        indentation level, or only delineate with semicolon if applicable"""
+        if self._in_interactive and not self._indent and allow_semicolon:
+            self.maybe_semicolon()
+            self.write(text)
+        else:
+            self.maybe_newline()
+            self.write("    " * self._indent + text)
+
+    def write(self, *text):
+        """Add new source parts"""
+        self._source.extend(text)
+
+    @contextmanager
+    def buffered(self, buffer = None):
+        if buffer is None:
+            buffer = []
+
+        original_source = self._source
+        self._source = buffer
+        yield buffer
+        self._source = original_source
+
+    @contextmanager
+    def block(self, *, extra = None):
+        """A context manager for preparing the source for blocks. It adds
+        the character':', increases the indentation on enter and decreases
+        the indentation on exit. If *extra* is given, it will be directly
+        appended after the colon character.
+        """
+        self.write(":")
+        if extra:
+            self.write(extra)
+        self._indent += 1
+        yield
+        self._indent -= 1
+
+    @contextmanager
+    def delimit(self, start, end):
+        """A context manager for preparing the source for expressions. It adds
+        *start* to the buffer and enters, after exit it adds *end*."""
+
+        self.write(start)
+        yield
+        self.write(end)
+
+    def delimit_if(self, start, end, condition):
+        if condition:
+            return self.delimit(start, end)
+        else:
+            return nullcontext()
+
+    def require_parens(self, precedence, node):
+        """Shortcut to adding precedence related parens"""
+        return self.delimit_if("(", ")", self.get_precedence(node) > precedence)
+
+    def get_precedence(self, node):
+        return self._precedences.get(node, _Precedence.TEST)
+
+    def set_precedence(self, precedence, *nodes):
+        for node in nodes:
+            self._precedences[node] = precedence
+
+    def get_raw_docstring(self, node):
+        """If a docstring node is found in the body of the *node* parameter,
+        return that docstring node, None otherwise.
+
+        Logic mirrored from ``_PyAST_GetDocString``."""
+        if not isinstance(
+            node, (AsyncFunctionDef, FunctionDef, ClassDef, Module)
+        ) or len(node.body) < 1:
+            return None
+        node = node.body[0]
+        if not isinstance(node, Expr):
+            return None
+        node = node.value
+        if isinstance(node, Constant) and isinstance(node.value, str):
+            return node
+
+    def get_type_comment(self, node):
+        comment = self._type_ignores.get(node.lineno) or node.type_comment
+        if comment is not None:
+            return f" # type: {comment}"
+
+    def traverse(self, node):
+        if isinstance(node, list):
+            for item in node:
+                self.traverse(item)
+        else:
+            super().visit(node)
+
+    # Note: as visit() resets the output text, do NOT rely on
+    # NodeVisitor.generic_visit to handle any nodes (as it calls back in to
+    # the subclass visit() method, which resets self._source to an empty list)
+    def visit(self, node):
+        """Outputs a source code string that, if converted back to an ast
+        (using ast.parse) will generate an AST equivalent to *node*"""
+        self._source = []
+        self.traverse(node)
+        return "".join(self._source)
+
+    def _write_docstring_and_traverse_body(self, node):
+        if (docstring := self.get_raw_docstring(node)):
+            self._write_docstring(docstring)
+            self.traverse(node.body[1:])
+        else:
+            self.traverse(node.body)
+
+    def visit_Module(self, node):
+        self._type_ignores = {
+            ignore.lineno: f"ignore{ignore.tag}"
+            for ignore in node.type_ignores
+        }
+        try:
+            self._write_docstring_and_traverse_body(node)
+        finally:
+            self._type_ignores.clear()
+
+    def visit_Interactive(self, node):
+        self._in_interactive = True
+        try:
+            self._write_docstring_and_traverse_body(node)
+        finally:
+            self._in_interactive = False
+
+    def visit_FunctionType(self, node):
+        with self.delimit("(", ")"):
+            self.interleave(
+                lambda: self.write(", "), self.traverse, node.argtypes
+            )
+
+        self.write(" -> ")
+        self.traverse(node.returns)
+
+    def visit_Expr(self, node):
+        self.fill()
+        self.set_precedence(_Precedence.YIELD, node.value)
+        self.traverse(node.value)
+
+    def visit_NamedExpr(self, node):
+        with self.require_parens(_Precedence.NAMED_EXPR, node):
+            self.set_precedence(_Precedence.ATOM, node.target, node.value)
+            self.traverse(node.target)
+            self.write(" := ")
+            self.traverse(node.value)
+
+    def visit_Import(self, node):
+        self.fill("import ")
+        self.interleave(lambda: self.write(", "), self.traverse, node.names)
+
+    def visit_ImportFrom(self, node):
+        self.fill("from ")
+        self.write("." * (node.level or 0))
+        if node.module:
+            self.write(node.module)
+        self.write(" import ")
+        self.interleave(lambda: self.write(", "), self.traverse, node.names)
+
+    def visit_Assign(self, node):
+        self.fill()
+        for target in node.targets:
+            self.set_precedence(_Precedence.TUPLE, target)
+            self.traverse(target)
+            self.write(" = ")
+        self.traverse(node.value)
+        if type_comment := self.get_type_comment(node):
+            self.write(type_comment)
+
+    def visit_AugAssign(self, node):
+        self.fill()
+        self.traverse(node.target)
+        self.write(" " + self.binop[node.op.__class__.__name__] + "= ")
+        self.traverse(node.value)
+
+    def visit_AnnAssign(self, node):
+        self.fill()
+        with self.delimit_if("(", ")", not node.simple and isinstance(node.target, Name)):
+            self.traverse(node.target)
+        self.write(": ")
+        self.traverse(node.annotation)
+        if node.value:
+            self.write(" = ")
+            self.traverse(node.value)
+
+    def visit_Return(self, node):
+        self.fill("return")
+        if node.value:
+            self.write(" ")
+            self.traverse(node.value)
+
+    def visit_Pass(self, node):
+        self.fill("pass")
+
+    def visit_Break(self, node):
+        self.fill("break")
+
+    def visit_Continue(self, node):
+        self.fill("continue")
+
+    def visit_Delete(self, node):
+        self.fill("del ")
+        self.interleave(lambda: self.write(", "), self.traverse, node.targets)
+
+    def visit_Assert(self, node):
+        self.fill("assert ")
+        self.traverse(node.test)
+        if node.msg:
+            self.write(", ")
+            self.traverse(node.msg)
+
+    def visit_Global(self, node):
+        self.fill("global ")
+        self.interleave(lambda: self.write(", "), self.write, node.names)
+
+    def visit_Nonlocal(self, node):
+        self.fill("nonlocal ")
+        self.interleave(lambda: self.write(", "), self.write, node.names)
+
+    def visit_Await(self, node):
+        with self.require_parens(_Precedence.AWAIT, node):
+            self.write("await")
+            if node.value:
+                self.write(" ")
+                self.set_precedence(_Precedence.ATOM, node.value)
+                self.traverse(node.value)
+
+    def visit_Yield(self, node):
+        with self.require_parens(_Precedence.YIELD, node):
+            self.write("yield")
+            if node.value:
+                self.write(" ")
+                self.set_precedence(_Precedence.ATOM, node.value)
+                self.traverse(node.value)
+
+    def visit_YieldFrom(self, node):
+        with self.require_parens(_Precedence.YIELD, node):
+            self.write("yield from ")
+            if not node.value:
+                raise ValueError("Node can't be used without a value attribute.")
+            self.set_precedence(_Precedence.ATOM, node.value)
+            self.traverse(node.value)
+
+    def visit_Raise(self, node):
+        self.fill("raise")
+        if not node.exc:
+            if node.cause:
+                raise ValueError(f"Node can't use cause without an exception.")
+            return
+        self.write(" ")
+        self.traverse(node.exc)
+        if node.cause:
+            self.write(" from ")
+            self.traverse(node.cause)
+
+    def do_visit_try(self, node):
+        self.fill("try", allow_semicolon=False)
+        with self.block():
+            self.traverse(node.body)
+        for ex in node.handlers:
+            self.traverse(ex)
+        if node.orelse:
+            self.fill("else", allow_semicolon=False)
+            with self.block():
+                self.traverse(node.orelse)
+        if node.finalbody:
+            self.fill("finally", allow_semicolon=False)
+            with self.block():
+                self.traverse(node.finalbody)
+
+    def visit_Try(self, node):
+        prev_in_try_star = self._in_try_star
+        try:
+            self._in_try_star = False
+            self.do_visit_try(node)
+        finally:
+            self._in_try_star = prev_in_try_star
+
+    def visit_TryStar(self, node):
+        prev_in_try_star = self._in_try_star
+        try:
+            self._in_try_star = True
+            self.do_visit_try(node)
+        finally:
+            self._in_try_star = prev_in_try_star
+
+    def visit_ExceptHandler(self, node):
+        self.fill("except*" if self._in_try_star else "except", allow_semicolon=False)
+        if node.type:
+            self.write(" ")
+            self.traverse(node.type)
+        if node.name:
+            self.write(" as ")
+            self.write(node.name)
+        with self.block():
+            self.traverse(node.body)
+
+    def visit_ClassDef(self, node):
+        self.maybe_newline()
+        for deco in node.decorator_list:
+            self.fill("@", allow_semicolon=False)
+            self.traverse(deco)
+        self.fill("class " + node.name, allow_semicolon=False)
+        if hasattr(node, "type_params"):
+            self._type_params_helper(node.type_params)
+        with self.delimit_if("(", ")", condition = node.bases or node.keywords):
+            comma = False
+            for e in node.bases:
+                if comma:
+                    self.write(", ")
+                else:
+                    comma = True
+                self.traverse(e)
+            for e in node.keywords:
+                if comma:
+                    self.write(", ")
+                else:
+                    comma = True
+                self.traverse(e)
+
+        with self.block():
+            self._write_docstring_and_traverse_body(node)
+
+    def visit_FunctionDef(self, node):
+        self._function_helper(node, "def")
+
+    def visit_AsyncFunctionDef(self, node):
+        self._function_helper(node, "async def")
+
+    def _function_helper(self, node, fill_suffix):
+        self.maybe_newline()
+        for deco in node.decorator_list:
+            self.fill("@", allow_semicolon=False)
+            self.traverse(deco)
+        def_str = fill_suffix + " " + node.name
+        self.fill(def_str, allow_semicolon=False)
+        if hasattr(node, "type_params"):
+            self._type_params_helper(node.type_params)
+        with self.delimit("(", ")"):
+            self.traverse(node.args)
+        if node.returns:
+            self.write(" -> ")
+            self.traverse(node.returns)
+        with self.block(extra=self.get_type_comment(node)):
+            self._write_docstring_and_traverse_body(node)
+
+    def _type_params_helper(self, type_params):
+        if type_params is not None and len(type_params) > 0:
+            with self.delimit("[", "]"):
+                self.interleave(lambda: self.write(", "), self.traverse, type_params)
+
+    def visit_TypeVar(self, node):
+        self.write(node.name)
+        if node.bound:
+            self.write(": ")
+            self.traverse(node.bound)
+        if node.default_value:
+            self.write(" = ")
+            self.traverse(node.default_value)
+
+    def visit_TypeVarTuple(self, node):
+        self.write("*" + node.name)
+        if node.default_value:
+            self.write(" = ")
+            self.traverse(node.default_value)
+
+    def visit_ParamSpec(self, node):
+        self.write("**" + node.name)
+        if node.default_value:
+            self.write(" = ")
+            self.traverse(node.default_value)
+
+    def visit_TypeAlias(self, node):
+        self.fill("type ")
+        self.traverse(node.name)
+        self._type_params_helper(node.type_params)
+        self.write(" = ")
+        self.traverse(node.value)
+
+    def visit_For(self, node):
+        self._for_helper("for ", node)
+
+    def visit_AsyncFor(self, node):
+        self._for_helper("async for ", node)
+
+    def _for_helper(self, fill, node):
+        self.fill(fill, allow_semicolon=False)
+        self.set_precedence(_Precedence.TUPLE, node.target)
+        self.traverse(node.target)
+        self.write(" in ")
+        self.traverse(node.iter)
+        with self.block(extra=self.get_type_comment(node)):
+            self.traverse(node.body)
+        if node.orelse:
+            self.fill("else", allow_semicolon=False)
+            with self.block():
+                self.traverse(node.orelse)
+
+    def visit_If(self, node):
+        self.fill("if ", allow_semicolon=False)
+        self.traverse(node.test)
+        with self.block():
+            self.traverse(node.body)
+        # collapse nested ifs into equivalent elifs.
+        while node.orelse and len(node.orelse) == 1 and isinstance(node.orelse[0], If):
+            node = node.orelse[0]
+            self.fill("elif ", allow_semicolon=False)
+            self.traverse(node.test)
+            with self.block():
+                self.traverse(node.body)
+        # final else
+        if node.orelse:
+            self.fill("else", allow_semicolon=False)
+            with self.block():
+                self.traverse(node.orelse)
+
+    def visit_While(self, node):
+        self.fill("while ", allow_semicolon=False)
+        self.traverse(node.test)
+        with self.block():
+            self.traverse(node.body)
+        if node.orelse:
+            self.fill("else", allow_semicolon=False)
+            with self.block():
+                self.traverse(node.orelse)
+
+    def visit_With(self, node):
+        self.fill("with ", allow_semicolon=False)
+        self.interleave(lambda: self.write(", "), self.traverse, node.items)
+        with self.block(extra=self.get_type_comment(node)):
+            self.traverse(node.body)
+
+    def visit_AsyncWith(self, node):
+        self.fill("async with ", allow_semicolon=False)
+        self.interleave(lambda: self.write(", "), self.traverse, node.items)
+        with self.block(extra=self.get_type_comment(node)):
+            self.traverse(node.body)
+
+    def _str_literal_helper(
+        self, string, *, quote_types=_ALL_QUOTES, escape_special_whitespace=False
+    ):
+        """Helper for writing string literals, minimizing escapes.
+        Returns the tuple (string literal to write, possible quote types).
+        """
+        def escape_char(c):
+            # \n and \t are non-printable, but we only escape them if
+            # escape_special_whitespace is True
+            if not escape_special_whitespace and c in "\n\t":
+                return c
+            # Always escape backslashes and other non-printable characters
+            if c == "\\" or not c.isprintable():
+                return c.encode("unicode_escape").decode("ascii")
+            return c
+
+        escaped_string = "".join(map(escape_char, string))
+        possible_quotes = quote_types
+        if "\n" in escaped_string:
+            possible_quotes = [q for q in possible_quotes if q in _MULTI_QUOTES]
+        possible_quotes = [q for q in possible_quotes if q not in escaped_string]
+        if not possible_quotes:
+            # If there aren't any possible_quotes, fallback to using repr
+            # on the original string. Try to use a quote from quote_types,
+            # e.g., so that we use triple quotes for docstrings.
+            string = repr(string)
+            quote = next((q for q in quote_types if string[0] in q), string[0])
+            return string[1:-1], [quote]
+        if escaped_string:
+            # Sort so that we prefer '''"''' over """\""""
+            possible_quotes.sort(key=lambda q: q[0] == escaped_string[-1])
+            # If we're using triple quotes and we'd need to escape a final
+            # quote, escape it
+            if possible_quotes[0][0] == escaped_string[-1]:
+                assert len(possible_quotes[0]) == 3
+                escaped_string = escaped_string[:-1] + "\\" + escaped_string[-1]
+        return escaped_string, possible_quotes
+
+    def _write_str_avoiding_backslashes(self, string, *, quote_types=_ALL_QUOTES):
+        """Write string literal value with a best effort attempt to avoid backslashes."""
+        string, quote_types = self._str_literal_helper(string, quote_types=quote_types)
+        quote_type = quote_types[0]
+        self.write(f"{quote_type}{string}{quote_type}")
+
+    def _ftstring_helper(self, parts):
+        new_parts = []
+        quote_types = list(_ALL_QUOTES)
+        fallback_to_repr = False
+        for value, is_constant in parts:
+            if is_constant:
+                value, new_quote_types = self._str_literal_helper(
+                    value,
+                    quote_types=quote_types,
+                    escape_special_whitespace=True,
+                )
+                if set(new_quote_types).isdisjoint(quote_types):
+                    fallback_to_repr = True
+                    break
+                quote_types = new_quote_types
+            else:
+                if "\n" in value:
+                    quote_types = [q for q in quote_types if q in _MULTI_QUOTES]
+                    assert quote_types
+
+                new_quote_types = [q for q in quote_types if q not in value]
+                if new_quote_types:
+                    quote_types = new_quote_types
+            new_parts.append(value)
+
+        if fallback_to_repr:
+            # If we weren't able to find a quote type that works for all parts
+            # of the JoinedStr, fallback to using repr and triple single quotes.
+            quote_types = ["'''"]
+            new_parts.clear()
+            for value, is_constant in parts:
+                if is_constant:
+                    value = repr('"' + value)  # force repr to use single quotes
+                    expected_prefix = "'\""
+                    assert value.startswith(expected_prefix), repr(value)
+                    value = value[len(expected_prefix):-1]
+                new_parts.append(value)
+
+        value = "".join(new_parts)
+        quote_type = quote_types[0]
+        self.write(f"{quote_type}{value}{quote_type}")
+
+    def _write_ftstring(self, values, prefix):
+        self.write(prefix)
+        fstring_parts = []
+        for value in values:
+            with self.buffered() as buffer:
+                self._write_ftstring_inner(value)
+            fstring_parts.append(
+                ("".join(buffer), isinstance(value, Constant))
+            )
+        self._ftstring_helper(fstring_parts)
+
+    def visit_JoinedStr(self, node):
+        self._write_ftstring(node.values, "f")
+
+    def visit_TemplateStr(self, node):
+        self._write_ftstring(node.values, "t")
+
+    def _write_ftstring_inner(self, node, is_format_spec=False):
+        if isinstance(node, JoinedStr):
+            # for both the f-string itself, and format_spec
+            for value in node.values:
+                self._write_ftstring_inner(value, is_format_spec=is_format_spec)
+        elif isinstance(node, Constant) and isinstance(node.value, str):
+            value = node.value.replace("{", "{{").replace("}", "}}")
+
+            if is_format_spec:
+                value = value.replace("\\", "\\\\")
+                value = value.replace("'", "\\'")
+                value = value.replace('"', '\\"')
+                value = value.replace("\n", "\\n")
+            self.write(value)
+        elif isinstance(node, FormattedValue):
+            self.visit_FormattedValue(node)
+        elif isinstance(node, Interpolation):
+            self.visit_Interpolation(node)
+        else:
+            raise ValueError(f"Unexpected node inside JoinedStr, {node!r}")
+
+    def _unparse_interpolation_value(self, inner):
+        unparser = type(self)()
+        unparser.set_precedence(_Precedence.TEST.next(), inner)
+        return unparser.visit(inner)
+
+    def _write_interpolation(self, node, use_str_attr=False):
+        with self.delimit("{", "}"):
+            if use_str_attr:
+                expr = node.str
+            else:
+                expr = self._unparse_interpolation_value(node.value)
+            if expr.startswith("{"):
+                # Separate pair of opening brackets as "{ {"
+                self.write(" ")
+            self.write(expr)
+            if node.conversion != -1:
+                self.write(f"!{chr(node.conversion)}")
+            if node.format_spec:
+                self.write(":")
+                self._write_ftstring_inner(node.format_spec, is_format_spec=True)
+
+    def visit_FormattedValue(self, node):
+        self._write_interpolation(node)
+
+    def visit_Interpolation(self, node):
+        # If `str` is set to `None`, use the `value` to generate the source code.
+        self._write_interpolation(node, use_str_attr=node.str is not None)
+
+    def visit_Name(self, node):
+        self.write(node.id)
+
+    def _write_docstring(self, node):
+        self.fill(allow_semicolon=False)
+        if node.kind == "u":
+            self.write("u")
+        self._write_str_avoiding_backslashes(node.value, quote_types=_MULTI_QUOTES)
+
+    def _write_constant(self, value):
+        if isinstance(value, (float, complex)):
+            # Substitute overflowing decimal literal for AST infinities,
+            # and inf - inf for NaNs.
+            self.write(
+                repr(value)
+                .replace("inf", _INFSTR)
+                .replace("nan", f"({_INFSTR}-{_INFSTR})")
+            )
+        else:
+            self.write(repr(value))
+
+    def visit_Constant(self, node):
+        value = node.value
+        if isinstance(value, tuple):
+            with self.delimit("(", ")"):
+                self.items_view(self._write_constant, value)
+        elif value is ...:
+            self.write("...")
+        else:
+            if node.kind == "u":
+                self.write("u")
+            self._write_constant(node.value)
+
+    def visit_List(self, node):
+        with self.delimit("[", "]"):
+            self.interleave(lambda: self.write(", "), self.traverse, node.elts)
+
+    def visit_ListComp(self, node):
+        with self.delimit("[", "]"):
+            self.traverse(node.elt)
+            for gen in node.generators:
+                self.traverse(gen)
+
+    def visit_GeneratorExp(self, node):
+        with self.delimit("(", ")"):
+            self.traverse(node.elt)
+            for gen in node.generators:
+                self.traverse(gen)
+
+    def visit_SetComp(self, node):
+        with self.delimit("{", "}"):
+            self.traverse(node.elt)
+            for gen in node.generators:
+                self.traverse(gen)
+
+    def visit_DictComp(self, node):
+        with self.delimit("{", "}"):
+            self.traverse(node.key)
+            self.write(": ")
+            self.traverse(node.value)
+            for gen in node.generators:
+                self.traverse(gen)
+
+    def visit_comprehension(self, node):
+        if node.is_async:
+            self.write(" async for ")
+        else:
+            self.write(" for ")
+        self.set_precedence(_Precedence.TUPLE, node.target)
+        self.traverse(node.target)
+        self.write(" in ")
+        self.set_precedence(_Precedence.TEST.next(), node.iter, *node.ifs)
+        self.traverse(node.iter)
+        for if_clause in node.ifs:
+            self.write(" if ")
+            self.traverse(if_clause)
+
+    def visit_IfExp(self, node):
+        with self.require_parens(_Precedence.TEST, node):
+            self.set_precedence(_Precedence.TEST.next(), node.body, node.test)
+            self.traverse(node.body)
+            self.write(" if ")
+            self.traverse(node.test)
+            self.write(" else ")
+            self.set_precedence(_Precedence.TEST, node.orelse)
+            self.traverse(node.orelse)
+
+    def visit_Set(self, node):
+        if node.elts:
+            with self.delimit("{", "}"):
+                self.interleave(lambda: self.write(", "), self.traverse, node.elts)
+        else:
+            # `{}` would be interpreted as a dictionary literal, and
+            # `set` might be shadowed. Thus:
+            self.write('{*()}')
+
+    def visit_Dict(self, node):
+        def write_key_value_pair(k, v):
+            self.traverse(k)
+            self.write(": ")
+            self.traverse(v)
+
+        def write_item(item):
+            k, v = item
+            if k is None:
+                # for dictionary unpacking operator in dicts {**{'y': 2}}
+                # see PEP 448 for details
+                self.write("**")
+                self.set_precedence(_Precedence.EXPR, v)
+                self.traverse(v)
+            else:
+                write_key_value_pair(k, v)
+
+        with self.delimit("{", "}"):
+            self.interleave(
+                lambda: self.write(", "), write_item, zip(node.keys, node.values)
+            )
+
+    def visit_Tuple(self, node):
+        with self.delimit_if(
+            "(",
+            ")",
+            len(node.elts) == 0 or self.get_precedence(node) > _Precedence.TUPLE
+        ):
+            self.items_view(self.traverse, node.elts)
+
+    unop = {"Invert": "~", "Not": "not", "UAdd": "+", "USub": "-"}
+    unop_precedence = {
+        "not": _Precedence.NOT,
+        "~": _Precedence.FACTOR,
+        "+": _Precedence.FACTOR,
+        "-": _Precedence.FACTOR,
+    }
+
+    def visit_UnaryOp(self, node):
+        operator = self.unop[node.op.__class__.__name__]
+        operator_precedence = self.unop_precedence[operator]
+        with self.require_parens(operator_precedence, node):
+            self.write(operator)
+            # factor prefixes (+, -, ~) shouldn't be separated
+            # from the value they belong, (e.g: +1 instead of + 1)
+            if operator_precedence is not _Precedence.FACTOR:
+                self.write(" ")
+            self.set_precedence(operator_precedence, node.operand)
+            self.traverse(node.operand)
+
+    binop = {
+        "Add": "+",
+        "Sub": "-",
+        "Mult": "*",
+        "MatMult": "@",
+        "Div": "/",
+        "Mod": "%",
+        "LShift": "<<",
+        "RShift": ">>",
+        "BitOr": "|",
+        "BitXor": "^",
+        "BitAnd": "&",
+        "FloorDiv": "//",
+        "Pow": "**",
+    }
+
+    binop_precedence = {
+        "+": _Precedence.ARITH,
+        "-": _Precedence.ARITH,
+        "*": _Precedence.TERM,
+        "@": _Precedence.TERM,
+        "/": _Precedence.TERM,
+        "%": _Precedence.TERM,
+        "<<": _Precedence.SHIFT,
+        ">>": _Precedence.SHIFT,
+        "|": _Precedence.BOR,
+        "^": _Precedence.BXOR,
+        "&": _Precedence.BAND,
+        "//": _Precedence.TERM,
+        "**": _Precedence.POWER,
+    }
+
+    binop_rassoc = frozenset(("**",))
+    def visit_BinOp(self, node):
+        operator = self.binop[node.op.__class__.__name__]
+        operator_precedence = self.binop_precedence[operator]
+        with self.require_parens(operator_precedence, node):
+            if operator in self.binop_rassoc:
+                left_precedence = operator_precedence.next()
+                right_precedence = operator_precedence
+            else:
+                left_precedence = operator_precedence
+                right_precedence = operator_precedence.next()
+
+            self.set_precedence(left_precedence, node.left)
+            self.traverse(node.left)
+            self.write(f" {operator} ")
+            self.set_precedence(right_precedence, node.right)
+            self.traverse(node.right)
+
+    cmpops = {
+        "Eq": "==",
+        "NotEq": "!=",
+        "Lt": "<",
+        "LtE": "<=",
+        "Gt": ">",
+        "GtE": ">=",
+        "Is": "is",
+        "IsNot": "is not",
+        "In": "in",
+        "NotIn": "not in",
+    }
+
+    def visit_Compare(self, node):
+        with self.require_parens(_Precedence.CMP, node):
+            self.set_precedence(_Precedence.CMP.next(), node.left, *node.comparators)
+            self.traverse(node.left)
+            for o, e in zip(node.ops, node.comparators):
+                self.write(" " + self.cmpops[o.__class__.__name__] + " ")
+                self.traverse(e)
+
+    boolops = {"And": "and", "Or": "or"}
+    boolop_precedence = {"and": _Precedence.AND, "or": _Precedence.OR}
+
+    def visit_BoolOp(self, node):
+        operator = self.boolops[node.op.__class__.__name__]
+        operator_precedence = self.boolop_precedence[operator]
+
+        def increasing_level_traverse(node):
+            nonlocal operator_precedence
+            operator_precedence = operator_precedence.next()
+            self.set_precedence(operator_precedence, node)
+            self.traverse(node)
+
+        with self.require_parens(operator_precedence, node):
+            s = f" {operator} "
+            self.interleave(lambda: self.write(s), increasing_level_traverse, node.values)
+
+    def visit_Attribute(self, node):
+        self.set_precedence(_Precedence.ATOM, node.value)
+        self.traverse(node.value)
+        # Special case: 3.__abs__() is a syntax error, so if node.value
+        # is an integer literal then we need to either parenthesize
+        # it or add an extra space to get 3 .__abs__().
+        if isinstance(node.value, Constant) and isinstance(node.value.value, int):
+            self.write(" ")
+        self.write(".")
+        self.write(node.attr)
+
+    def visit_Call(self, node):
+        self.set_precedence(_Precedence.ATOM, node.func)
+        self.traverse(node.func)
+        with self.delimit("(", ")"):
+            comma = False
+            for e in node.args:
+                if comma:
+                    self.write(", ")
+                else:
+                    comma = True
+                self.traverse(e)
+            for e in node.keywords:
+                if comma:
+                    self.write(", ")
+                else:
+                    comma = True
+                self.traverse(e)
+
+    def visit_Subscript(self, node):
+        def is_non_empty_tuple(slice_value):
+            return (
+                isinstance(slice_value, Tuple)
+                and slice_value.elts
+            )
+
+        self.set_precedence(_Precedence.ATOM, node.value)
+        self.traverse(node.value)
+        with self.delimit("[", "]"):
+            if is_non_empty_tuple(node.slice):
+                # parentheses can be omitted if the tuple isn't empty
+                self.items_view(self.traverse, node.slice.elts)
+            else:
+                self.traverse(node.slice)
+
+    def visit_Starred(self, node):
+        self.write("*")
+        self.set_precedence(_Precedence.EXPR, node.value)
+        self.traverse(node.value)
+
+    def visit_Ellipsis(self, node):
+        self.write("...")
+
+    def visit_Slice(self, node):
+        if node.lower:
+            self.traverse(node.lower)
+        self.write(":")
+        if node.upper:
+            self.traverse(node.upper)
+        if node.step:
+            self.write(":")
+            self.traverse(node.step)
+
+    def visit_Match(self, node):
+        self.fill("match ", allow_semicolon=False)
+        self.traverse(node.subject)
+        with self.block():
+            for case in node.cases:
+                self.traverse(case)
+
+    def visit_arg(self, node):
+        self.write(node.arg)
+        if node.annotation:
+            self.write(": ")
+            self.traverse(node.annotation)
+
+    def visit_arguments(self, node):
+        first = True
+        # normal arguments
+        all_args = node.posonlyargs + node.args
+        defaults = [None] * (len(all_args) - len(node.defaults)) + node.defaults
+        for index, elements in enumerate(zip(all_args, defaults), 1):
+            a, d = elements
+            if first:
+                first = False
+            else:
+                self.write(", ")
+            self.traverse(a)
+            if d:
+                self.write("=")
+                self.traverse(d)
+            if index == len(node.posonlyargs):
+                self.write(", /")
+
+        # varargs, or bare '*' if no varargs but keyword-only arguments present
+        if node.vararg or node.kwonlyargs:
+            if first:
+                first = False
+            else:
+                self.write(", ")
+            self.write("*")
+            if node.vararg:
+                self.write(node.vararg.arg)
+                if node.vararg.annotation:
+                    self.write(": ")
+                    self.traverse(node.vararg.annotation)
+
+        # keyword-only arguments
+        if node.kwonlyargs:
+            for a, d in zip(node.kwonlyargs, node.kw_defaults):
+                self.write(", ")
+                self.traverse(a)
+                if d:
+                    self.write("=")
+                    self.traverse(d)
+
+        # kwargs
+        if node.kwarg:
+            if first:
+                first = False
+            else:
+                self.write(", ")
+            self.write("**" + node.kwarg.arg)
+            if node.kwarg.annotation:
+                self.write(": ")
+                self.traverse(node.kwarg.annotation)
+
+    def visit_keyword(self, node):
+        if node.arg is None:
+            self.write("**")
+        else:
+            self.write(node.arg)
+            self.write("=")
+        self.traverse(node.value)
+
+    def visit_Lambda(self, node):
+        with self.require_parens(_Precedence.TEST, node):
+            self.write("lambda")
+            with self.buffered() as buffer:
+                self.traverse(node.args)
+            if buffer:
+                self.write(" ", *buffer)
+            self.write(": ")
+            self.set_precedence(_Precedence.TEST, node.body)
+            self.traverse(node.body)
+
+    def visit_alias(self, node):
+        self.write(node.name)
+        if node.asname:
+            self.write(" as " + node.asname)
+
+    def visit_withitem(self, node):
+        self.traverse(node.context_expr)
+        if node.optional_vars:
+            self.write(" as ")
+            self.traverse(node.optional_vars)
+
+    def visit_match_case(self, node):
+        self.fill("case ", allow_semicolon=False)
+        self.traverse(node.pattern)
+        if node.guard:
+            self.write(" if ")
+            self.traverse(node.guard)
+        with self.block():
+            self.traverse(node.body)
+
+    def visit_MatchValue(self, node):
+        self.traverse(node.value)
+
+    def visit_MatchSingleton(self, node):
+        self._write_constant(node.value)
+
+    def visit_MatchSequence(self, node):
+        with self.delimit("[", "]"):
+            self.interleave(
+                lambda: self.write(", "), self.traverse, node.patterns
+            )
+
+    def visit_MatchStar(self, node):
+        name = node.name
+        if name is None:
+            name = "_"
+        self.write(f"*{name}")
+
+    def visit_MatchMapping(self, node):
+        def write_key_pattern_pair(pair):
+            k, p = pair
+            self.traverse(k)
+            self.write(": ")
+            self.traverse(p)
+
+        with self.delimit("{", "}"):
+            keys = node.keys
+            self.interleave(
+                lambda: self.write(", "),
+                write_key_pattern_pair,
+                zip(keys, node.patterns, strict=True),
+            )
+            rest = node.rest
+            if rest is not None:
+                if keys:
+                    self.write(", ")
+                self.write(f"**{rest}")
+
+    def visit_MatchClass(self, node):
+        self.set_precedence(_Precedence.ATOM, node.cls)
+        self.traverse(node.cls)
+        with self.delimit("(", ")"):
+            patterns = node.patterns
+            self.interleave(
+                lambda: self.write(", "), self.traverse, patterns
+            )
+            attrs = node.kwd_attrs
+            if attrs:
+                def write_attr_pattern(pair):
+                    attr, pattern = pair
+                    self.write(f"{attr}=")
+                    self.traverse(pattern)
+
+                if patterns:
+                    self.write(", ")
+                self.interleave(
+                    lambda: self.write(", "),
+                    write_attr_pattern,
+                    zip(attrs, node.kwd_patterns, strict=True),
+                )
+
+    def visit_MatchAs(self, node):
+        name = node.name
+        pattern = node.pattern
+        if name is None:
+            self.write("_")
+        elif pattern is None:
+            self.write(node.name)
+        else:
+            with self.require_parens(_Precedence.TEST, node):
+                self.set_precedence(_Precedence.BOR, node.pattern)
+                self.traverse(node.pattern)
+                self.write(f" as {node.name}")
+
+    def visit_MatchOr(self, node):
+        with self.require_parens(_Precedence.BOR, node):
+            self.set_precedence(_Precedence.BOR.next(), *node.patterns)
+            self.interleave(lambda: self.write(" | "), self.traverse, node.patterns)
diff --git a/Lib/_compat_pickle.py b/Lib/_compat_pickle.py
index 17b9010278f..60793c391ae 100644
--- a/Lib/_compat_pickle.py
+++ b/Lib/_compat_pickle.py
@@ -22,7 +22,6 @@
     'tkMessageBox': 'tkinter.messagebox',
     'ScrolledText': 'tkinter.scrolledtext',
     'Tkconstants': 'tkinter.constants',
-    'Tix': 'tkinter.tix',
     'ttk': 'tkinter.ttk',
     'Tkinter': 'tkinter',
     'markupbase': '_markupbase',
@@ -257,3 +256,4 @@
 
 for excname in PYTHON3_IMPORTERROR_EXCEPTIONS:
     REVERSE_NAME_MAPPING[('builtins', excname)] = ('exceptions', 'ImportError')
+del excname
diff --git a/Lib/_markupbase.py b/Lib/_markupbase.py
index 3ad7e279960..614f0cd16dd 100644
--- a/Lib/_markupbase.py
+++ b/Lib/_markupbase.py
@@ -13,7 +13,7 @@
 _markedsectionclose = re.compile(r']\s*]\s*>')
 
 # An analysis of the MS-Word extensions is available at
-# http://www.planetpublish.com/xmlarena/xap/Thursday/WordtoXML.pdf
+# http://web.archive.org/web/20060321153828/http://www.planetpublish.com/xmlarena/xap/Thursday/WordtoXML.pdf
 
 _msmarkedsectionclose = re.compile(r']\s*>')
 
diff --git a/Lib/_opcode_metadata.py b/Lib/_opcode_metadata.py
index bb55ee423cf..4da6e507736 100644
--- a/Lib/_opcode_metadata.py
+++ b/Lib/_opcode_metadata.py
@@ -1,16 +1,223 @@
 # This file is generated by scripts/generate_opcode_metadata.py
-# for RustPython bytecode format (CPython 3.13 compatible opcode numbers).
+# for RustPython bytecode format (CPython 3.14 compatible opcode numbers).
 # Do not edit!
 
-_specializations = {}
+_specializations = {
+    "RESUME": [
+        "RESUME_CHECK",
+    ],
+    "LOAD_CONST": [
+        "LOAD_CONST_MORTAL",
+        "LOAD_CONST_IMMORTAL",
+    ],
+    "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_SUBSCR_LIST_INT",
+        "BINARY_OP_SUBSCR_LIST_SLICE",
+        "BINARY_OP_SUBSCR_TUPLE_INT",
+        "BINARY_OP_SUBSCR_STR_INT",
+        "BINARY_OP_SUBSCR_DICT",
+        "BINARY_OP_SUBSCR_GETITEM",
+        "BINARY_OP_EXTEND",
+        "BINARY_OP_INPLACE_ADD_UNICODE",
+    ],
+    "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_CLASS_WITH_METACLASS_CHECK",
+        "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",
+    ],
+    "JUMP_BACKWARD": [
+        "JUMP_BACKWARD_NO_JIT",
+        "JUMP_BACKWARD_JIT",
+    ],
+    "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",
+    ],
+    "CALL_KW": [
+        "CALL_KW_BOUND_METHOD",
+        "CALL_KW_PY",
+        "CALL_KW_NON_PY",
+    ],
+}
 
-_specialized_opmap = {}
+_specialized_opmap = {
+    'BINARY_OP_ADD_FLOAT': 129,
+    'BINARY_OP_ADD_INT': 130,
+    'BINARY_OP_ADD_UNICODE': 131,
+    'BINARY_OP_EXTEND': 132,
+    'BINARY_OP_INPLACE_ADD_UNICODE': 3,
+    'BINARY_OP_MULTIPLY_FLOAT': 133,
+    'BINARY_OP_MULTIPLY_INT': 134,
+    'BINARY_OP_SUBSCR_DICT': 135,
+    'BINARY_OP_SUBSCR_GETITEM': 136,
+    'BINARY_OP_SUBSCR_LIST_INT': 137,
+    'BINARY_OP_SUBSCR_LIST_SLICE': 138,
+    'BINARY_OP_SUBSCR_STR_INT': 139,
+    'BINARY_OP_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,
+}
 
 opmap = {
     'CACHE': 0,
+    'RESERVED': 17,
+    'RESUME': 128,
+    'INSTRUMENTED_LINE': 254,
+    'ENTER_EXECUTOR': 255,
     'BINARY_SLICE': 1,
     'BUILD_TEMPLATE': 2,
-    'BINARY_OP_INPLACE_ADD_UNICODE': 3,
     'CALL_FUNCTION_EX': 4,
     'CHECK_EG_MATCH': 5,
     'CHECK_EXC_MATCH': 6,
@@ -24,7 +231,6 @@
     'GET_AITER': 14,
     'GET_ANEXT': 15,
     'GET_ITER': 16,
-    'RESERVED': 17,
     'GET_LEN': 18,
     'GET_YIELD_FROM_ITER': 19,
     'INTERPRETER_EXIT': 20,
@@ -128,90 +334,6 @@
     '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_OP_SUBSCR_DICT': 135,
-    'BINARY_OP_SUBSCR_GETITEM': 136,
-    'BINARY_OP_SUBSCR_LIST_INT': 137,
-    'BINARY_OP_SUBSCR_LIST_SLICE': 138,
-    'BINARY_OP_SUBSCR_STR_INT': 139,
-    'BINARY_OP_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,
     'INSTRUMENTED_END_FOR': 234,
     'INSTRUMENTED_POP_ITER': 235,
     'INSTRUMENTED_END_SEND': 236,
@@ -232,8 +354,6 @@
     'INSTRUMENTED_CALL_KW': 251,
     'INSTRUMENTED_CALL_FUNCTION_EX': 252,
     'INSTRUMENTED_JUMP_BACKWARD': 253,
-    'INSTRUMENTED_LINE': 254,
-    'ENTER_EXECUTOR': 255,
     'ANNOTATIONS_PLACEHOLDER': 256,
     'JUMP': 257,
     'JUMP_IF_FALSE': 258,
@@ -247,6 +367,5 @@
     'STORE_FAST_MAYBE_NULL': 266,
 }
 
-# CPython 3.13 compatible: opcodes < 44 have no argument
-HAVE_ARGUMENT = 44
-MIN_INSTRUMENTED_OPCODE = 236
+HAVE_ARGUMENT = 43
+MIN_INSTRUMENTED_OPCODE = 234
diff --git a/Lib/_pycodecs.py b/Lib/_pycodecs.py
index d0efa9ad6bb..98dec3c614d 100644
--- a/Lib/_pycodecs.py
+++ b/Lib/_pycodecs.py
@@ -22,10 +22,10 @@
 
    The builtin Unicode codecs use the following interface:
 
-     <encoding>_encode(Unicode_object[,errors='strict']) -> 
+     <encoding>_encode(Unicode_object[,errors='strict']) ->
          (string object, bytes consumed)
 
-     <encoding>_decode(char_buffer_obj[,errors='strict']) -> 
+     <encoding>_decode(char_buffer_obj[,errors='strict']) ->
         (Unicode object, bytes consumed)
 
    <encoding>_encode() interfaces also accept non-Unicode object as
@@ -44,47 +44,76 @@
 From PyPy v1.0.0
 
 """
-#from unicodecodec import *
-
-__all__ = ['register', 'lookup', 'lookup_error', 'register_error', 'encode', 'decode',
-           'latin_1_encode', 'mbcs_decode', 'readbuffer_encode', 'escape_encode',
-           'utf_8_decode', 'raw_unicode_escape_decode', 'utf_7_decode',
-           'unicode_escape_encode', 'latin_1_decode', 'utf_16_decode',
-           'unicode_escape_decode', 'ascii_decode', 'charmap_encode', 'charmap_build',
-           'unicode_internal_encode', 'unicode_internal_decode', 'utf_16_ex_decode',
-           'escape_decode', 'charmap_decode', 'utf_7_encode', 'mbcs_encode',
-           'ascii_encode', 'utf_16_encode', 'raw_unicode_escape_encode', 'utf_8_encode',
-           'utf_16_le_encode', 'utf_16_be_encode', 'utf_16_le_decode', 'utf_16_be_decode',]
+# from unicodecodec import *
+
+__all__ = [
+    "register",
+    "lookup",
+    "lookup_error",
+    "register_error",
+    "encode",
+    "decode",
+    "latin_1_encode",
+    "mbcs_decode",
+    "readbuffer_encode",
+    "escape_encode",
+    "utf_8_decode",
+    "raw_unicode_escape_decode",
+    "utf_7_decode",
+    "unicode_escape_encode",
+    "latin_1_decode",
+    "utf_16_decode",
+    "unicode_escape_decode",
+    "ascii_decode",
+    "charmap_encode",
+    "charmap_build",
+    "unicode_internal_encode",
+    "unicode_internal_decode",
+    "utf_16_ex_decode",
+    "escape_decode",
+    "charmap_decode",
+    "utf_7_encode",
+    "mbcs_encode",
+    "ascii_encode",
+    "utf_16_encode",
+    "raw_unicode_escape_encode",
+    "utf_8_encode",
+    "utf_16_le_encode",
+    "utf_16_be_encode",
+    "utf_16_le_decode",
+    "utf_16_be_decode",
+    "utf_32_ex_decode",
+]
 
 import sys
 import warnings
 from _codecs import *
 
 
-def latin_1_encode( obj, errors='strict'):
-    """None
-    """
+def latin_1_encode(obj, errors="strict"):
+    """None"""
     res = PyUnicode_EncodeLatin1(obj, len(obj), errors)
     res = bytes(res)
     return res, len(obj)
+
+
 # XXX MBCS codec might involve ctypes ?
 def mbcs_decode():
-    """None
-    """
+    """None"""
     pass
 
-def readbuffer_encode( obj, errors='strict'):
-    """None
-    """
+
+def readbuffer_encode(obj, errors="strict"):
+    """None"""
     if isinstance(obj, str):
         res = obj.encode()
     else:
         res = bytes(obj)
     return res, len(obj)
 
-def escape_encode( obj, errors='strict'):
-    """None
-    """
+
+def escape_encode(obj, errors="strict"):
+    """None"""
     if not isinstance(obj, bytes):
         raise TypeError("must be bytes")
     s = repr(obj).encode()
@@ -93,85 +122,88 @@ def escape_encode( obj, errors='strict'):
         v = v.replace(b"'", b"\\'").replace(b'\\"', b'"')
     return v, len(obj)
 
-def raw_unicode_escape_decode( data, errors='strict', final=False):
-    """None
-    """
-    res = PyUnicode_DecodeRawUnicodeEscape(data, len(data), errors, final)
-    res = ''.join(res)
-    return res, len(data)
 
-def utf_7_decode( data, errors='strict'):
-    """None
-    """
-    res = PyUnicode_DecodeUTF7(data, len(data), errors)
-    res = ''.join(res)
-    return res, len(data)
+def raw_unicode_escape_decode(data, errors="strict", final=True):
+    """None"""
+    res, consumed = PyUnicode_DecodeRawUnicodeEscape(data, len(data), errors, final)
+    res = "".join(res)
+    return res, consumed
 
-def unicode_escape_encode( obj, errors='strict'):
-    """None
-    """
+
+def utf_7_decode(data, errors="strict", final=False):
+    """None"""
+    res, consumed = PyUnicode_DecodeUTF7(data, len(data), errors, final)
+    res = "".join(res)
+    return res, consumed
+
+
+def unicode_escape_encode(obj, errors="strict"):
+    """None"""
     res = unicodeescape_string(obj, len(obj), 0)
-    res = b''.join(res)
+    res = b"".join(res)
     return res, len(obj)
 
-def latin_1_decode( data, errors='strict'):
-    """None
-    """
+
+def latin_1_decode(data, errors="strict"):
+    """None"""
     res = PyUnicode_DecodeLatin1(data, len(data), errors)
-    res = ''.join(res)
+    res = "".join(res)
     return res, len(data)
 
-def utf_16_decode( data, errors='strict', final=False):
-    """None
-    """
+
+def utf_16_decode(data, errors="strict", final=False):
+    """None"""
     consumed = len(data)
     if final:
         consumed = 0
-    res, consumed, byteorder = PyUnicode_DecodeUTF16Stateful(data, len(data), errors, 'native', final)
-    res = ''.join(res)
+    res, consumed, byteorder = PyUnicode_DecodeUTF16Stateful(
+        data, len(data), errors, "native", final
+    )
+    res = "".join(res)
     return res, consumed
 
-def unicode_escape_decode( data, errors='strict', final=False):
-    """None
-    """
-    res = PyUnicode_DecodeUnicodeEscape(data, len(data), errors, final)
-    res = ''.join(res)
-    return res, len(data)
 
+def unicode_escape_decode(data, errors="strict", final=True):
+    """None"""
+    res, consumed = PyUnicode_DecodeUnicodeEscape(data, len(data), errors, final)
+    res = "".join(res)
+    return res, consumed
 
-def ascii_decode( data, errors='strict'):
-    """None
-    """
+
+def ascii_decode(data, errors="strict"):
+    """None"""
     res = PyUnicode_DecodeASCII(data, len(data), errors)
-    res = ''.join(res)
+    res = "".join(res)
     return res, len(data)
 
-def charmap_encode(obj, errors='strict', mapping='latin-1'):
-    """None
-    """
+
+def charmap_encode(obj, errors="strict", mapping="latin-1"):
+    """None"""
 
     res = PyUnicode_EncodeCharmap(obj, len(obj), mapping, errors)
     res = bytes(res)
     return res, len(obj)
 
+
 def charmap_build(s):
     return {ord(c): i for i, c in enumerate(s)}
 
+
 if sys.maxunicode == 65535:
     unicode_bytes = 2
 else:
     unicode_bytes = 4
 
-def unicode_internal_encode( obj, errors='strict'):
-    """None
-    """
+
+def unicode_internal_encode(obj, errors="strict"):
+    """None"""
     if type(obj) == str:
         p = bytearray()
         t = [ord(x) for x in obj]
         for i in t:
             b = bytearray()
             for j in range(unicode_bytes):
-                b.append(i%256)
+                b.append(i % 256)
                 i >>= 8
             if sys.byteorder == "big":
                 b.reverse()
@@ -179,12 +211,12 @@ def unicode_internal_encode( obj, errors='strict'):
         res = bytes(p)
         return res, len(res)
     else:
-        res = "You can do better than this" # XXX make this right
+        res = "You can do better than this"  # XXX make this right
         return res, len(res)
 
-def unicode_internal_decode( unistr, errors='strict'):
-    """None
-    """
+
+def unicode_internal_decode(unistr, errors="strict"):
+    """None"""
     if type(unistr) == str:
         return unistr, len(unistr)
     else:
@@ -198,165 +230,418 @@ def unicode_internal_decode( unistr, errors='strict'):
             start = 0
             stop = unicode_bytes
             step = 1
-        while i < len(unistr)-unicode_bytes+1:
+        while i < len(unistr) - unicode_bytes + 1:
             t = 0
             h = 0
             for j in range(start, stop, step):
-                t += ord(unistr[i+j])<<(h*8)
+                t += ord(unistr[i + j]) << (h * 8)
                 h += 1
             i += unicode_bytes
             p += chr(t)
-        res = ''.join(p)
+        res = "".join(p)
         return res, len(res)
 
-def utf_16_ex_decode( data, errors='strict', byteorder=0, final=0):
-    """None
-    """
+
+def utf_16_ex_decode(data, errors="strict", byteorder=0, final=0):
+    """None"""
     if byteorder == 0:
-        bm = 'native'
+        bm = "native"
     elif byteorder == -1:
-        bm = 'little'
+        bm = "little"
     else:
-        bm = 'big'
+        bm = "big"
     consumed = len(data)
     if final:
         consumed = 0
-    res, consumed, byteorder = PyUnicode_DecodeUTF16Stateful(data, len(data), errors, bm, final)
-    res = ''.join(res)
+    res, consumed, byteorder = PyUnicode_DecodeUTF16Stateful(
+        data, len(data), errors, bm, final
+    )
+    res = "".join(res)
     return res, consumed, byteorder
 
-# XXX needs error messages when the input is invalid
-def escape_decode(data, errors='strict'):
-    """None
-    """
+
+def utf_32_ex_decode(data, errors="strict", byteorder=0, final=0):
+    """None"""
+    if byteorder == 0:
+        if len(data) < 4:
+            if final and len(data):
+                if sys.byteorder == "little":
+                    bm = "little"
+                else:
+                    bm = "big"
+                res, consumed, _ = PyUnicode_DecodeUTF32Stateful(
+                    data, len(data), errors, bm, final
+                )
+                return "".join(res), consumed, 0
+            return "", 0, 0
+        if data[0:4] == b"\xff\xfe\x00\x00":
+            res, consumed, _ = PyUnicode_DecodeUTF32Stateful(
+                data[4:], len(data) - 4, errors, "little", final
+            )
+            return "".join(res), consumed + 4, -1
+        if data[0:4] == b"\x00\x00\xfe\xff":
+            res, consumed, _ = PyUnicode_DecodeUTF32Stateful(
+                data[4:], len(data) - 4, errors, "big", final
+            )
+            return "".join(res), consumed + 4, 1
+        if sys.byteorder == "little":
+            bm = "little"
+        else:
+            bm = "big"
+        res, consumed, _ = PyUnicode_DecodeUTF32Stateful(
+            data, len(data), errors, bm, final
+        )
+        return "".join(res), consumed, 0
+
+    if byteorder == -1:
+        res, consumed, _ = PyUnicode_DecodeUTF32Stateful(
+            data, len(data), errors, "little", final
+        )
+        return "".join(res), consumed, -1
+
+    res, consumed, _ = PyUnicode_DecodeUTF32Stateful(
+        data, len(data), errors, "big", final
+    )
+    return "".join(res), consumed, 1
+
+
+def _is_hex_digit(b):
+    return (
+        0x30 <= b <= 0x39  # 0-9
+        or 0x41 <= b <= 0x46  # A-F
+        or 0x61 <= b <= 0x66
+    )  # a-f
+
+
+def escape_decode(data, errors="strict"):
+    if isinstance(data, str):
+        data = data.encode("latin-1")
     l = len(data)
     i = 0
     res = bytearray()
     while i < l:
-        
-        if data[i] == '\\':
+        if data[i] == 0x5C:  # '\\'
             i += 1
             if i >= l:
                 raise ValueError("Trailing \\ in string")
-            else:
-                if data[i] == '\\':
-                    res += b'\\'
-                elif data[i] == 'n':
-                    res += b'\n'
-                elif data[i] == 't':
-                    res += b'\t'
-                elif data[i] == 'r':
-                    res += b'\r'
-                elif data[i] == 'b':
-                    res += b'\b'
-                elif data[i] == '\'':
-                    res += b'\''
-                elif data[i] == '\"':
-                    res += b'\"'
-                elif data[i] == 'f':
-                    res += b'\f'
-                elif data[i] == 'a':
-                    res += b'\a'
-                elif data[i] == 'v':
-                    res += b'\v'
-                elif '0' <= data[i] <= '9':
-                    # emulate a strange wrap-around behavior of CPython:
-                    # \400 is the same as \000 because 0400 == 256
-                    octal = data[i:i+3]
-                    res.append(int(octal, 8) & 0xFF)
-                    i += 2
-                elif data[i] == 'x':
-                    hexa = data[i+1:i+3]
-                    res.append(int(hexa, 16))
+            ch = data[i]
+            if ch == 0x5C:
+                res.append(0x5C)  # \\
+            elif ch == 0x27:
+                res.append(0x27)  # \'
+            elif ch == 0x22:
+                res.append(0x22)  # \"
+            elif ch == 0x61:
+                res.append(0x07)  # \a
+            elif ch == 0x62:
+                res.append(0x08)  # \b
+            elif ch == 0x66:
+                res.append(0x0C)  # \f
+            elif ch == 0x6E:
+                res.append(0x0A)  # \n
+            elif ch == 0x72:
+                res.append(0x0D)  # \r
+            elif ch == 0x74:
+                res.append(0x09)  # \t
+            elif ch == 0x76:
+                res.append(0x0B)  # \v
+            elif ch == 0x0A:
+                pass  # \<newline> continuation
+            elif 0x30 <= ch <= 0x37:  # \0-\7 octal
+                val = ch - 0x30
+                if i + 1 < l and 0x30 <= data[i + 1] <= 0x37:
+                    i += 1
+                    val = (val << 3) | (data[i] - 0x30)
+                    if i + 1 < l and 0x30 <= data[i + 1] <= 0x37:
+                        i += 1
+                        val = (val << 3) | (data[i] - 0x30)
+                res.append(val & 0xFF)
+            elif ch == 0x78:  # \x hex
+                hex_count = 0
+                for j in range(1, 3):
+                    if i + j < l and _is_hex_digit(data[i + j]):
+                        hex_count += 1
+                    else:
+                        break
+                if hex_count < 2:
+                    if errors == "strict":
+                        raise ValueError("invalid \\x escape at position %d" % (i - 1))
+                    elif errors == "replace":
+                        res.append(0x3F)  # '?'
+                    i += hex_count
+                else:
+                    res.append(int(bytes(data[i + 1 : i + 3]), 16))
                     i += 2
+            else:
+                import warnings
+
+                warnings.warn(
+                    '"\\%c" is an invalid escape sequence' % ch
+                    if 0x20 <= ch < 0x7F
+                    else '"\\x%02x" is an invalid escape sequence' % ch,
+                    DeprecationWarning,
+                    stacklevel=2,
+                )
+                res.append(0x5C)
+                res.append(ch)
         else:
             res.append(data[i])
         i += 1
-    res = bytes(res)
-    return res, len(res)
+    return bytes(res), l
+
 
-def charmap_decode( data, errors='strict', mapping=None):
-    """None
-    """
+def charmap_decode(data, errors="strict", mapping=None):
+    """None"""
     res = PyUnicode_DecodeCharmap(data, len(data), mapping, errors)
-    res = ''.join(res)
+    res = "".join(res)
     return res, len(data)
 
 
-def utf_7_encode( obj, errors='strict'):
-    """None
-    """
+def utf_7_encode(obj, errors="strict"):
+    """None"""
     res = PyUnicode_EncodeUTF7(obj, len(obj), 0, 0, errors)
-    res = b''.join(res)
+    res = b"".join(res)
     return res, len(obj)
 
-def mbcs_encode( obj, errors='strict'):
-    """None
-    """
+
+def mbcs_encode(obj, errors="strict"):
+    """None"""
     pass
+
+
 ##    return (PyUnicode_EncodeMBCS(
-##                             (obj), 
+##                             (obj),
 ##                             len(obj),
 ##                             errors),
 ##                  len(obj))
-    
 
-def ascii_encode( obj, errors='strict'):
-    """None
-    """
+
+def ascii_encode(obj, errors="strict"):
+    """None"""
     res = PyUnicode_EncodeASCII(obj, len(obj), errors)
     res = bytes(res)
     return res, len(obj)
 
-def utf_16_encode( obj, errors='strict'):
-    """None
-    """
-    res = PyUnicode_EncodeUTF16(obj, len(obj), errors, 'native')
+
+def utf_16_encode(obj, errors="strict"):
+    """None"""
+    res = PyUnicode_EncodeUTF16(obj, len(obj), errors, "native")
     res = bytes(res)
     return res, len(obj)
 
-def raw_unicode_escape_encode( obj, errors='strict'):
-    """None
-    """
+
+def raw_unicode_escape_encode(obj, errors="strict"):
+    """None"""
     res = PyUnicode_EncodeRawUnicodeEscape(obj, len(obj))
     res = bytes(res)
     return res, len(obj)
 
-def utf_16_le_encode( obj, errors='strict'):
-    """None
-    """
-    res = PyUnicode_EncodeUTF16(obj, len(obj), errors, 'little')
+
+def utf_16_le_encode(obj, errors="strict"):
+    """None"""
+    res = PyUnicode_EncodeUTF16(obj, len(obj), errors, "little")
     res = bytes(res)
     return res, len(obj)
 
-def utf_16_be_encode( obj, errors='strict'):
-    """None
-    """
-    res = PyUnicode_EncodeUTF16(obj, len(obj), errors, 'big')
+
+def utf_16_be_encode(obj, errors="strict"):
+    """None"""
+    res = PyUnicode_EncodeUTF16(obj, len(obj), errors, "big")
     res = bytes(res)
     return res, len(obj)
 
-def utf_16_le_decode( data, errors='strict', byteorder=0, final = 0):
-    """None
-    """
-    consumed = len(data)
-    if final:
-        consumed = 0
-    res, consumed, byteorder = PyUnicode_DecodeUTF16Stateful(data, len(data), errors, 'little', final)
-    res = ''.join(res)
+
+def utf_16_le_decode(data, errors="strict", final=0):
+    res, consumed, byteorder = PyUnicode_DecodeUTF16Stateful(
+        data, len(data), errors, "little", final
+    )
+    res = "".join(res)
     return res, consumed
 
-def utf_16_be_decode( data, errors='strict', byteorder=0, final = 0):
-    """None
-    """
-    consumed = len(data)
-    if final:
-        consumed = 0
-    res, consumed, byteorder = PyUnicode_DecodeUTF16Stateful(data, len(data), errors, 'big', final)
-    res = ''.join(res)
+
+def utf_16_be_decode(data, errors="strict", final=0):
+    res, consumed, byteorder = PyUnicode_DecodeUTF16Stateful(
+        data, len(data), errors, "big", final
+    )
+    res = "".join(res)
     return res, consumed
 
 
+def STORECHAR32(ch, byteorder):
+    """Store a 32-bit character as 4 bytes in the specified byte order."""
+    b0 = ch & 0xFF
+    b1 = (ch >> 8) & 0xFF
+    b2 = (ch >> 16) & 0xFF
+    b3 = (ch >> 24) & 0xFF
+    if byteorder == "little":
+        return [b0, b1, b2, b3]
+    else:  # big-endian
+        return [b3, b2, b1, b0]
+
+
+def PyUnicode_EncodeUTF32(s, size, errors, byteorder="little"):
+    """Encode a Unicode string to UTF-32."""
+    p = []
+    bom = sys.byteorder
+
+    if byteorder == "native":
+        bom = sys.byteorder
+        # Add BOM for native encoding
+        p += STORECHAR32(0xFEFF, bom)
+
+    if byteorder == "little":
+        bom = "little"
+    elif byteorder == "big":
+        bom = "big"
+
+    pos = 0
+    while pos < len(s):
+        ch = ord(s[pos])
+        if 0xD800 <= ch <= 0xDFFF:
+            if errors == "surrogatepass":
+                p += STORECHAR32(ch, bom)
+                pos += 1
+            else:
+                res, pos = unicode_call_errorhandler(
+                    errors, "utf-32", "surrogates not allowed", s, pos, pos + 1, False
+                )
+                for c in res:
+                    p += STORECHAR32(ord(c), bom)
+        else:
+            p += STORECHAR32(ch, bom)
+            pos += 1
+
+    return p
+
+
+def utf_32_encode(obj, errors="strict"):
+    """UTF-32 encoding with BOM."""
+    encoded = PyUnicode_EncodeUTF32(obj, len(obj), errors, "native")
+    return bytes(encoded), len(obj)
+
+
+def utf_32_le_encode(obj, errors="strict"):
+    """UTF-32 little-endian encoding without BOM."""
+    encoded = PyUnicode_EncodeUTF32(obj, len(obj), errors, "little")
+    return bytes(encoded), len(obj)
+
+
+def utf_32_be_encode(obj, errors="strict"):
+    """UTF-32 big-endian encoding without BOM."""
+    res = PyUnicode_EncodeUTF32(obj, len(obj), errors, "big")
+    res = bytes(res)
+    return res, len(obj)
+
+
+def PyUnicode_DecodeUTF32Stateful(data, size, errors, byteorder="little", final=0):
+    """Decode UTF-32 encoded bytes to Unicode string."""
+    if size == 0:
+        return [], 0, 0
+
+    result = []
+    pos = 0
+    aligned_size = (size // 4) * 4
+
+    while pos + 3 < aligned_size:
+        if byteorder == "little":
+            ch = (
+                data[pos]
+                | (data[pos + 1] << 8)
+                | (data[pos + 2] << 16)
+                | (data[pos + 3] << 24)
+            )
+        else:  # big-endian
+            ch = (
+                (data[pos] << 24)
+                | (data[pos + 1] << 16)
+                | (data[pos + 2] << 8)
+                | data[pos + 3]
+            )
+
+        # Validate code point
+        if ch > 0x10FFFF:
+            if errors == "strict":
+                raise UnicodeDecodeError(
+                    "utf-32",
+                    bytes(data),
+                    pos,
+                    pos + 4,
+                    "codepoint not in range(0x110000)",
+                )
+            elif errors == "replace":
+                result.append("\ufffd")
+            # 'ignore' - skip this character
+            pos += 4
+        elif 0xD800 <= ch <= 0xDFFF:
+            if errors == "surrogatepass":
+                result.append(chr(ch))
+                pos += 4
+            else:
+                msg = "code point in surrogate code point range(0xd800, 0xe000)"
+                res, pos = unicode_call_errorhandler(
+                    errors, "utf-32", msg, data, pos, pos + 4, True
+                )
+                result.append(res)
+        else:
+            result.append(chr(ch))
+            pos += 4
+
+    # Handle trailing incomplete bytes
+    if pos < size:
+        if final:
+            res, pos = unicode_call_errorhandler(
+                errors, "utf-32", "truncated data", data, pos, size, True
+            )
+            if res:
+                result.append(res)
+
+    return result, pos, 0
+
+
+def utf_32_decode(data, errors="strict", final=0):
+    """UTF-32 decoding with BOM detection."""
+    if len(data) >= 4:
+        # Check for BOM
+        if data[0:4] == b"\xff\xfe\x00\x00":
+            # UTF-32 LE BOM
+            res, consumed, _ = PyUnicode_DecodeUTF32Stateful(
+                data[4:], len(data) - 4, errors, "little", final
+            )
+            res = "".join(res)
+            return res, consumed + 4
+        elif data[0:4] == b"\x00\x00\xfe\xff":
+            # UTF-32 BE BOM
+            res, consumed, _ = PyUnicode_DecodeUTF32Stateful(
+                data[4:], len(data) - 4, errors, "big", final
+            )
+            res = "".join(res)
+            return res, consumed + 4
+
+    # Default to little-endian if no BOM
+    byteorder = "little" if sys.byteorder == "little" else "big"
+    res, consumed, _ = PyUnicode_DecodeUTF32Stateful(
+        data, len(data), errors, byteorder, final
+    )
+    res = "".join(res)
+    return res, consumed
+
+
+def utf_32_le_decode(data, errors="strict", final=0):
+    """UTF-32 little-endian decoding without BOM."""
+    res, consumed, _ = PyUnicode_DecodeUTF32Stateful(
+        data, len(data), errors, "little", final
+    )
+    res = "".join(res)
+    return res, consumed
+
+
+def utf_32_be_decode(data, errors="strict", final=0):
+    """UTF-32 big-endian decoding without BOM."""
+    res, consumed, _ = PyUnicode_DecodeUTF32Stateful(
+        data, len(data), errors, "big", final
+    )
+    res = "".join(res)
+    return res, consumed
 
 
 #  ----------------------------------------------------------------------
@@ -364,9 +649,9 @@ def utf_16_be_decode( data, errors='strict', byteorder=0, final = 0):
 ##import sys
 ##""" Python implementation of CPythons builtin unicode codecs.
 ##
-##    Generally the functions in this module take a list of characters an returns 
+##    Generally the functions in this module take a list of characters an returns
 ##    a list of characters.
-##    
+##
 ##    For use in the PyPy project"""
 
 
@@ -376,283 +661,496 @@ def utf_16_be_decode( data, errors='strict', byteorder=0, final = 0):
 ##         1 - special
 ##         2 - whitespace (optional)
 ##         3 - RFC2152 Set O (optional)
-    
+
 utf7_special = [
-    1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 1, 1, 2, 1, 1,
-    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
-    2, 3, 3, 3, 3, 3, 3, 0, 0, 0, 3, 1, 0, 0, 0, 1,
-    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 3, 3, 3, 0,
-    3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 1, 3, 3, 3,
-    3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 3, 3, 1, 1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    2,
+    2,
+    1,
+    1,
+    2,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    2,
+    3,
+    3,
+    3,
+    3,
+    3,
+    3,
+    0,
+    0,
+    0,
+    3,
+    1,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    3,
+    3,
+    3,
+    3,
+    0,
+    3,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    3,
+    1,
+    3,
+    3,
+    3,
+    3,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    3,
+    3,
+    3,
+    1,
+    1,
 ]
-unicode_latin1 = [None]*256
+unicode_latin1 = [None] * 256
 
 
 def SPECIAL(c, encodeO, encodeWS):
     c = ord(c)
-    return (c>127 or utf7_special[c] == 1) or \
-            (encodeWS and (utf7_special[(c)] == 2)) or \
-            (encodeO and (utf7_special[(c)] == 3))
+    return (
+        (c > 127 or utf7_special[c] == 1)
+        or (encodeWS and (utf7_special[(c)] == 2))
+        or (encodeO and (utf7_special[(c)] == 3))
+    )
+
+
 def B64(n):
-    return bytes([b"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"[(n) & 0x3f]])
+    return bytes(
+        [
+            b"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"[
+                (n) & 0x3F
+            ]
+        ]
+    )
+
+
 def B64CHAR(c):
-    return (c.isalnum() or (c) == b'+' or (c) == b'/')
+    return c.isalnum() or (c) == b"+" or (c) == b"/"
+
+
 def UB64(c):
-    if (c) == b'+' :
-        return 62 
-    elif (c) == b'/':
-        return 63 
-    elif (c) >= b'a':
-        return ord(c) - 71 
-    elif (c) >= b'A':
-        return ord(c) - 65 
-    else: 
+    if (c) == b"+":
+        return 62
+    elif (c) == b"/":
+        return 63
+    elif (c) >= b"a":
+        return ord(c) - 71
+    elif (c) >= b"A":
+        return ord(c) - 65
+    else:
         return ord(c) + 4
 
-def ENCODE( ch, bits) :
+
+def ENCODE(ch, bits):
     out = []
-    while (bits >= 6):
-        out +=  B64(ch >> (bits-6))
-        bits -= 6 
+    while bits >= 6:
+        out += B64(ch >> (bits - 6))
+        bits -= 6
     return out, bits
 
-def PyUnicode_DecodeUTF7(s, size, errors):
 
-    starts = s
-    errmsg = ""
-    inShift = 0
-    bitsleft = 0
-    charsleft = 0
-    surrogate = 0
-    p = []
-    errorHandler = None
-    exc = None
+def _IS_BASE64(ch):
+    return (
+        (ord("A") <= ch <= ord("Z"))
+        or (ord("a") <= ch <= ord("z"))
+        or (ord("0") <= ch <= ord("9"))
+        or ch == ord("+")
+        or ch == ord("/")
+    )
 
-    if (size == 0):
-        return ''
+
+def _FROM_BASE64(ch):
+    if ch == ord("+"):
+        return 62
+    if ch == ord("/"):
+        return 63
+    if ch >= ord("a"):
+        return ch - 71
+    if ch >= ord("A"):
+        return ch - 65
+    if ch >= ord("0"):
+        return ch - ord("0") + 52
+    return -1
+
+
+def _DECODE_DIRECT(ch):
+    return ch <= 127 and ch != ord("+")
+
+
+def PyUnicode_DecodeUTF7(s, size, errors, final=False):
+    if size == 0:
+        return [], 0
+
+    p = []
+    inShift = False
+    base64bits = 0
+    base64buffer = 0
+    surrogate = 0
+    startinpos = 0
+    shiftOutStart = 0
     i = 0
+
     while i < size:
-        
-        ch = bytes([s[i]])
-        if (inShift):
-            if ((ch == b'-') or not B64CHAR(ch)):
-                inShift = 0
+        ch = s[i]
+        if inShift:
+            if _IS_BASE64(ch):
+                base64buffer = (base64buffer << 6) | _FROM_BASE64(ch)
+                base64bits += 6
                 i += 1
-                
-                while (bitsleft >= 16):
-                    outCh =  ((charsleft) >> (bitsleft-16)) & 0xffff
-                    bitsleft -= 16
-                    
-                    if (surrogate):
-                        ##            We have already generated an error for the high surrogate
-                        ##            so let's not bother seeing if the low surrogate is correct or not 
-                        surrogate = 0
-                    elif (0xDC00 <= (outCh) and (outCh) <= 0xDFFF):
-            ##             This is a surrogate pair. Unfortunately we can't represent 
-            ##               it in a 16-bit character 
-                        surrogate = 1
-                        msg = "code pairs are not supported"
-                        out, x = unicode_call_errorhandler(errors, 'utf-7', msg, s, i-1, i)
-                        p.append(out)
-                        bitsleft = 0
-                        break
+                if base64bits >= 16:
+                    outCh = (base64buffer >> (base64bits - 16)) & 0xFFFF
+                    base64bits -= 16
+                    base64buffer &= (1 << base64bits) - 1
+                    if surrogate:
+                        if 0xDC00 <= outCh <= 0xDFFF:
+                            ch2 = (
+                                0x10000
+                                + ((surrogate - 0xD800) << 10)
+                                + (outCh - 0xDC00)
+                            )
+                            p.append(chr(ch2))
+                            surrogate = 0
+                            continue
+                        else:
+                            p.append(chr(surrogate))
+                            surrogate = 0
+                    if 0xD800 <= outCh <= 0xDBFF:
+                        surrogate = outCh
                     else:
-                        p.append(chr(outCh ))
-                        #p += out
-                if (bitsleft >= 6):
-##                    /* The shift sequence has a partial character in it. If
-##                       bitsleft < 6 then we could just classify it as padding
-##                       but that is not the case here */
-                    msg = "partial character in shift sequence"
-                    out, x = unicode_call_errorhandler(errors, 'utf-7', msg, s, i-1, i)
-                    
-##                /* According to RFC2152 the remaining bits should be zero. We
-##                   choose to signal an error/insert a replacement character
-##                   here so indicate the potential of a misencoded character. */
-
-##                /* On x86, a << b == a << (b%32) so make sure that bitsleft != 0 */
-##                if (bitsleft and (charsleft << (sizeof(charsleft) * 8 - bitsleft))):
-##                    raise UnicodeDecodeError, "non-zero padding bits in shift sequence"
-                if (ch == b'-') :
-                    if ((i < size) and (s[i] == '-')) :
-                        p +=  '-'
-                        inShift = 1
-                    
-                elif SPECIAL(ch, 0, 0) :
-                    raise  UnicodeDecodeError("unexpected special character")
-                        
-                else:  
-                    p.append(chr(ord(ch)))
+                        p.append(chr(outCh))
             else:
-                charsleft = (charsleft << 6) | UB64(ch)
-                bitsleft += 6
-                i += 1
-##                /* p, charsleft, bitsleft, surrogate = */ DECODE(p, charsleft, bitsleft, surrogate);
-        elif ( ch == b'+' ):
+                inShift = False
+                if base64bits > 0:
+                    if base64bits >= 6:
+                        i += 1
+                        errmsg = "partial character in shift sequence"
+                        out, i = unicode_call_errorhandler(
+                            errors, "utf-7", errmsg, s, startinpos, i
+                        )
+                        p.append(out)
+                        continue
+                    else:
+                        if base64buffer != 0:
+                            i += 1
+                            errmsg = "non-zero padding bits in shift sequence"
+                            out, i = unicode_call_errorhandler(
+                                errors, "utf-7", errmsg, s, startinpos, i
+                            )
+                            p.append(out)
+                            continue
+                if surrogate and _DECODE_DIRECT(ch):
+                    p.append(chr(surrogate))
+                surrogate = 0
+                if ch == ord("-"):
+                    i += 1
+        elif ch == ord("+"):
             startinpos = i
             i += 1
-            if (i<size and s[i] == '-'):
+            if i < size and s[i] == ord("-"):
                 i += 1
-                p.append(b'+')
+                p.append("+")
+            elif i < size and not _IS_BASE64(s[i]):
+                i += 1
+                errmsg = "ill-formed sequence"
+                out, i = unicode_call_errorhandler(
+                    errors, "utf-7", errmsg, s, startinpos, i
+                )
+                p.append(out)
             else:
-                inShift = 1
-                bitsleft = 0
-                
-        elif (SPECIAL(ch, 0, 0)):
+                inShift = True
+                surrogate = 0
+                shiftOutStart = len(p)
+                base64bits = 0
+                base64buffer = 0
+        elif _DECODE_DIRECT(ch):
             i += 1
-            raise UnicodeDecodeError("unexpected special character")
+            p.append(chr(ch))
         else:
-            p.append(chr(ord(ch)))
+            startinpos = i
             i += 1
+            errmsg = "unexpected special character"
+            out, i = unicode_call_errorhandler(
+                errors, "utf-7", errmsg, s, startinpos, i
+            )
+            p.append(out)
+
+    if inShift and not final:
+        return p[:shiftOutStart], startinpos
+
+    if inShift and final:
+        if surrogate or base64bits >= 6 or (base64bits > 0 and base64buffer != 0):
+            errmsg = "unterminated shift sequence"
+            out, i = unicode_call_errorhandler(
+                errors, "utf-7", errmsg, s, startinpos, size
+            )
+            p.append(out)
+
+    return p, size
+
+
+def _ENCODE_DIRECT(ch, encodeSetO, encodeWhiteSpace):
+    c = ord(ch) if isinstance(ch, str) else ch
+    if c > 127:
+        return False
+    if utf7_special[c] == 0:
+        return True
+    if utf7_special[c] == 2:
+        return not encodeWhiteSpace
+    if utf7_special[c] == 3:
+        return not encodeSetO
+    return False
 
-    if (inShift) :
-        #XXX This aint right
-        endinpos = size
-        raise UnicodeDecodeError("unterminated shift sequence")
-        
-    return p
 
 def PyUnicode_EncodeUTF7(s, size, encodeSetO, encodeWhiteSpace, errors):
-
-#    /* It might be possible to tighten this worst case */
     inShift = False
-    i = 0
-    bitsleft = 0
-    charsleft = 0
+    base64bits = 0
+    base64buffer = 0
     out = []
-    for ch in s:
-        if (not inShift) :
-            if (ch == '+'):
-                out.append(b'+-')
-            elif (SPECIAL(ch, encodeSetO, encodeWhiteSpace)):
-                charsleft = ord(ch)
-                bitsleft = 16
-                out.append(b'+')
-                p, bitsleft = ENCODE( charsleft, bitsleft)
-                out.append(p)
-                inShift = bitsleft > 0
+
+    for i, ch in enumerate(s):
+        ch_ord = ord(ch)
+        if inShift:
+            if _ENCODE_DIRECT(ch, encodeSetO, encodeWhiteSpace):
+                # shifting out
+                if base64bits:
+                    out.append(B64(base64buffer << (6 - base64bits)))
+                    base64buffer = 0
+                    base64bits = 0
+                inShift = False
+                if B64CHAR(ch) or ch == "-":
+                    out.append(b"-")
+                out.append(bytes([ch_ord]))
             else:
-                out.append(bytes([ord(ch)]))
+                # encode character in base64
+                if ch_ord >= 0x10000:
+                    # split into surrogate pair
+                    hi = 0xD800 | ((ch_ord - 0x10000) >> 10)
+                    lo = 0xDC00 | ((ch_ord - 0x10000) & 0x3FF)
+                    base64bits += 16
+                    base64buffer = (base64buffer << 16) | hi
+                    while base64bits >= 6:
+                        out.append(B64(base64buffer >> (base64bits - 6)))
+                        base64bits -= 6
+                    base64buffer &= (1 << base64bits) - 1 if base64bits else 0
+                    ch_ord = lo
+
+                base64bits += 16
+                base64buffer = (base64buffer << 16) | ch_ord
+                while base64bits >= 6:
+                    out.append(B64(base64buffer >> (base64bits - 6)))
+                    base64bits -= 6
+                base64buffer &= (1 << base64bits) - 1 if base64bits else 0
         else:
-            if (not SPECIAL(ch, encodeSetO, encodeWhiteSpace)):
-                out.append(B64((charsleft) << (6-bitsleft)))
-                charsleft = 0
-                bitsleft = 0
-##                /* Characters not in the BASE64 set implicitly unshift the sequence
-##                   so no '-' is required, except if the character is itself a '-' */
-                if (B64CHAR(ch) or ch == '-'):
-                    out.append(b'-')
-                inShift = False
-                out.append(bytes([ord(ch)]))
+            if ch == "+":
+                out.append(b"+-")
+            elif _ENCODE_DIRECT(ch, encodeSetO, encodeWhiteSpace):
+                out.append(bytes([ch_ord]))
             else:
-                bitsleft += 16
-                charsleft = (((charsleft) << 16) | ord(ch))
-                p, bitsleft =  ENCODE(charsleft, bitsleft)
-                out.append(p)
-##                /* If the next character is special then we dont' need to terminate
-##                   the shift sequence. If the next character is not a BASE64 character
-##                   or '-' then the shift sequence will be terminated implicitly and we
-##                   don't have to insert a '-'. */
-
-                if (bitsleft == 0):
-                    if (i + 1 < size):
-                        ch2 = s[i+1]
-
-                        if (SPECIAL(ch2, encodeSetO, encodeWhiteSpace)):
-                            pass
-                        elif (B64CHAR(ch2) or ch2 == '-'):
-                            out.append(b'-')
-                            inShift = False
-                        else:
+                out.append(b"+")
+                inShift = True
+                # encode character in base64
+                if ch_ord >= 0x10000:
+                    hi = 0xD800 | ((ch_ord - 0x10000) >> 10)
+                    lo = 0xDC00 | ((ch_ord - 0x10000) & 0x3FF)
+                    base64bits += 16
+                    base64buffer = (base64buffer << 16) | hi
+                    while base64bits >= 6:
+                        out.append(B64(base64buffer >> (base64bits - 6)))
+                        base64bits -= 6
+                    base64buffer &= (1 << base64bits) - 1 if base64bits else 0
+                    ch_ord = lo
+
+                base64bits += 16
+                base64buffer = (base64buffer << 16) | ch_ord
+                while base64bits >= 6:
+                    out.append(B64(base64buffer >> (base64bits - 6)))
+                    base64bits -= 6
+                base64buffer &= (1 << base64bits) - 1 if base64bits else 0
+
+                if base64bits == 0:
+                    if i + 1 < size:
+                        ch2 = s[i + 1]
+                        if _ENCODE_DIRECT(ch2, encodeSetO, encodeWhiteSpace):
+                            if B64CHAR(ch2) or ch2 == "-":
+                                out.append(b"-")
                             inShift = False
                     else:
-                        out.append(b'-')
+                        out.append(b"-")
                         inShift = False
-        i += 1
-            
-    if (bitsleft):
-        out.append(B64(charsleft << (6-bitsleft) ) )
-        out.append(b'-')
+
+    if base64bits:
+        out.append(B64(base64buffer << (6 - base64bits)))
+    if inShift:
+        out.append(b"-")
 
     return out
 
-unicode_empty = ''
 
-def unicodeescape_string(s, size, quotes):
+unicode_empty = ""
 
+
+def unicodeescape_string(s, size, quotes):
     p = []
-    if (quotes) :
-        if (s.find('\'') != -1 and s.find('"') == -1):
+    if quotes:
+        if s.find("'") != -1 and s.find('"') == -1:
             p.append(b'"')
         else:
-            p.append(b'\'')
+            p.append(b"'")
     pos = 0
-    while (pos < size):
+    while pos < size:
         ch = s[pos]
-        #/* Escape quotes */
-        if (quotes and (ch == p[1] or ch == '\\')):
-            p.append(b'\\%c' % ord(ch))
+        # /* Escape quotes */
+        if quotes and (ch == p[1] or ch == "\\"):
+            p.append(b"\\%c" % ord(ch))
             pos += 1
             continue
 
-#ifdef Py_UNICODE_WIDE
-        #/* Map 21-bit characters to '\U00xxxxxx' */
-        elif (ord(ch) >= 0x10000):
-            p.append(b'\\U%08x' % ord(ch))
+        # ifdef Py_UNICODE_WIDE
+        # /* Map 21-bit characters to '\U00xxxxxx' */
+        elif ord(ch) >= 0x10000:
+            p.append(b"\\U%08x" % ord(ch))
             pos += 1
-            continue        
-#endif
-        #/* Map UTF-16 surrogate pairs to Unicode \UXXXXXXXX escapes */
-        elif (ord(ch) >= 0xD800 and ord(ch) < 0xDC00):
+            continue
+        # endif
+        # /* Map UTF-16 surrogate pairs to Unicode \UXXXXXXXX escapes */
+        elif ord(ch) >= 0xD800 and ord(ch) < 0xDC00:
             pos += 1
             ch2 = s[pos]
-            
-            if (ord(ch2) >= 0xDC00 and ord(ch2) <= 0xDFFF):
+
+            if ord(ch2) >= 0xDC00 and ord(ch2) <= 0xDFFF:
                 ucs = (((ord(ch) & 0x03FF) << 10) | (ord(ch2) & 0x03FF)) + 0x00010000
-                p.append(b'\\U%08x' % ucs)
+                p.append(b"\\U%08x" % ucs)
                 pos += 1
                 continue
-           
-            #/* Fall through: isolated surrogates are copied as-is */
+
+            # /* Fall through: isolated surrogates are copied as-is */
             pos -= 1
-            
-        #/* Map 16-bit characters to '\uxxxx' */
-        if (ord(ch) >= 256):
-            p.append(b'\\u%04x' % ord(ch))
-            
-        #/* Map special whitespace to '\t', \n', '\r' */
-        elif (ch == '\t'):
-            p.append(b'\\t')
-        
-        elif (ch == '\n'):
-            p.append(b'\\n')
-
-        elif (ch == '\r'):
-            p.append(b'\\r')
-
-        elif (ch == '\\'):
-            p.append(b'\\\\')
-
-        #/* Map non-printable US ASCII to '\xhh' */
-        elif (ch < ' ' or ch >= chr(0x7F)) :
-            p.append(b'\\x%02x' % ord(ch))
-        #/* Copy everything else as-is */
+
+        # /* Map 16-bit characters to '\uxxxx' */
+        if ord(ch) >= 256:
+            p.append(b"\\u%04x" % ord(ch))
+
+        # /* Map special whitespace to '\t', \n', '\r' */
+        elif ch == "\t":
+            p.append(b"\\t")
+
+        elif ch == "\n":
+            p.append(b"\\n")
+
+        elif ch == "\r":
+            p.append(b"\\r")
+
+        elif ch == "\\":
+            p.append(b"\\\\")
+
+        # /* Map non-printable US ASCII to '\xhh' */
+        elif ch < " " or ch >= chr(0x7F):
+            p.append(b"\\x%02x" % ord(ch))
+        # /* Copy everything else as-is */
         else:
             p.append(bytes([ord(ch)]))
         pos += 1
-    if (quotes):
+    if quotes:
         p.append(p[0])
     return p
 
-def PyUnicode_DecodeASCII(s, size, errors):
 
-#    /* ASCII is equivalent to the first 128 ordinals in Unicode. */
-    if (size == 1 and ord(s) < 128) :
+def PyUnicode_DecodeASCII(s, size, errors):
+    #    /* ASCII is equivalent to the first 128 ordinals in Unicode. */
+    if size == 1 and ord(s) < 128:
         return [chr(ord(s))]
-    if (size == 0):
-        return [''] #unicode('')
+    if size == 0:
+        return [""]  # unicode('')
     p = []
     pos = 0
     while pos < len(s):
@@ -661,54 +1159,50 @@ def PyUnicode_DecodeASCII(s, size, errors):
             p += chr(c)
             pos += 1
         else:
-            
             res = unicode_call_errorhandler(
-                    errors, "ascii", "ordinal not in range(128)",
-                    s,  pos, pos+1)
+                errors, "ascii", "ordinal not in range(128)", s, pos, pos + 1
+            )
             p += res[0]
             pos = res[1]
     return p
 
-def PyUnicode_EncodeASCII(p, size, errors):
 
+def PyUnicode_EncodeASCII(p, size, errors):
     return unicode_encode_ucs1(p, size, errors, 128)
 
-def PyUnicode_AsASCIIString(unistr):
 
+def PyUnicode_AsASCIIString(unistr):
     if not type(unistr) == str:
         raise TypeError
-    return PyUnicode_EncodeASCII(str(unistr),
-                                 len(str),
-                                None)
+    return PyUnicode_EncodeASCII(unistr, len(unistr), None)
 
-def PyUnicode_DecodeUTF16Stateful(s, size, errors, byteorder='native', final=True):
 
-    bo = 0       #/* assume native ordering by default */
+def PyUnicode_DecodeUTF16Stateful(s, size, errors, byteorder="native", final=True):
+    bo = 0  # /* assume native ordering by default */
     consumed = 0
     errmsg = ""
 
-    if sys.byteorder == 'little':
+    if sys.byteorder == "little":
         ihi = 1
         ilo = 0
     else:
         ihi = 0
         ilo = 1
-    
 
-    #/* Unpack UTF-16 encoded data */
+    # /* Unpack UTF-16 encoded data */
 
-##    /* Check for BOM marks (U+FEFF) in the input and adjust current
-##       byte order setting accordingly. In native mode, the leading BOM
-##       mark is skipped, in all other modes, it is copied to the output
-##       stream as-is (giving a ZWNBSP character). */
+    ##    /* Check for BOM marks (U+FEFF) in the input and adjust current
+    ##       byte order setting accordingly. In native mode, the leading BOM
+    ##       mark is skipped, in all other modes, it is copied to the output
+    ##       stream as-is (giving a ZWNBSP character). */
     q = 0
     p = []
-    if byteorder == 'native':
-        if (size >= 2):
+    if byteorder == "native":
+        if size >= 2:
             bom = (s[ihi] << 8) | s[ilo]
-#ifdef BYTEORDER_IS_LITTLE_ENDIAN
-            if sys.byteorder == 'little':
-                if (bom == 0xFEFF):
+            # ifdef BYTEORDER_IS_LITTLE_ENDIAN
+            if sys.byteorder == "little":
+                if bom == 0xFEFF:
                     q += 2
                     bo = -1
                 elif bom == 0xFFFE:
@@ -721,118 +1215,143 @@ def PyUnicode_DecodeUTF16Stateful(s, size, errors, byteorder='native', final=Tru
                 elif bom == 0xFFFE:
                     q += 2
                     bo = -1
-    elif byteorder == 'little':
+    elif byteorder == "little":
         bo = -1
     else:
         bo = 1
-        
-    if (size == 0):
-        return [''], 0, bo
-    
-    if (bo == -1):
-        #/* force LE */
+
+    if size == 0:
+        return [""], 0, bo
+
+    if bo == -1:
+        # /* force LE */
         ihi = 1
         ilo = 0
 
-    elif (bo == 1):
-        #/* force BE */
+    elif bo == 1:
+        # /* force BE */
         ihi = 0
         ilo = 1
 
-    while (q < len(s)):
-    
-        #/* remaining bytes at the end? (size should be even) */
-        if (len(s)-q<2):
+    while q < len(s):
+        # /* remaining bytes at the end? (size should be even) */
+        if len(s) - q < 2:
             if not final:
                 break
-            errmsg = "truncated data"
-            startinpos = q
-            endinpos = len(s)
-            unicode_call_errorhandler(errors, 'utf-16', errmsg, s, startinpos, endinpos, True)
-#           /* The remaining input chars are ignored if the callback
-##             chooses to skip the input */
-    
-        ch = (s[q+ihi] << 8) | s[q+ilo]
-        q += 2
-    
-        if (ch < 0xD800 or ch > 0xDFFF):
+            res, q = unicode_call_errorhandler(
+                errors, "utf-16", "truncated data", s, q, len(s), True
+            )
+            p.append(res)
+            break
+
+        ch = (s[q + ihi] << 8) | s[q + ilo]
+
+        if ch < 0xD800 or ch > 0xDFFF:
             p.append(chr(ch))
-            continue
-    
-        #/* UTF-16 code pair: */
-        if (q >= len(s)):
-            errmsg = "unexpected end of data"
-            startinpos = q-2
-            endinpos = len(s)
-            unicode_call_errorhandler(errors, 'utf-16', errmsg, s, startinpos, endinpos, True)
-
-        if (0xD800 <= ch and ch <= 0xDBFF):
-            ch2 = (s[q+ihi] << 8) | s[q+ilo]
             q += 2
-            if (0xDC00 <= ch2 and ch2 <= 0xDFFF):
-    #ifndef Py_UNICODE_WIDE
-                if sys.maxunicode < 65536:
-                    p += [chr(ch), chr(ch2)]
+            continue
+
+        # /* UTF-16 code pair: high surrogate */
+        if 0xD800 <= ch <= 0xDBFF:
+            if q + 4 <= len(s):
+                ch2 = (s[q + 2 + ihi] << 8) | s[q + 2 + ilo]
+                if 0xDC00 <= ch2 <= 0xDFFF:
+                    # Valid surrogate pair - always assemble
+                    p.append(chr((((ch & 0x3FF) << 10) | (ch2 & 0x3FF)) + 0x10000))
+                    q += 4
+                    continue
                 else:
-                    p.append(chr((((ch & 0x3FF)<<10) | (ch2 & 0x3FF)) + 0x10000))
-    #endif
+                    # High surrogate followed by non-low-surrogate
+                    if errors == "surrogatepass":
+                        p.append(chr(ch))
+                        q += 2
+                        continue
+                    res, q = unicode_call_errorhandler(
+                        errors, "utf-16", "illegal UTF-16 surrogate", s, q, q + 2, True
+                    )
+                    p.append(res)
+            else:
+                # High surrogate at end of data
+                if not final:
+                    break
+                if errors == "surrogatepass":
+                    p.append(chr(ch))
+                    q += 2
+                    continue
+                res, q = unicode_call_errorhandler(
+                    errors, "utf-16", "unexpected end of data", s, q, len(s), True
+                )
+                p.append(res)
+        else:
+            # Low surrogate without preceding high surrogate
+            if errors == "surrogatepass":
+                p.append(chr(ch))
+                q += 2
                 continue
+            res, q = unicode_call_errorhandler(
+                errors, "utf-16", "illegal encoding", s, q, q + 2, True
+            )
+            p.append(res)
 
-            else:
-                errmsg = "illegal UTF-16 surrogate"
-                startinpos = q-4
-                endinpos = startinpos+2
-                unicode_call_errorhandler(errors, 'utf-16', errmsg, s, startinpos, endinpos, True)
-           
-        errmsg = "illegal encoding"
-        startinpos = q-2
-        endinpos = startinpos+2
-        unicode_call_errorhandler(errors, 'utf-16', errmsg, s, startinpos, endinpos, True)
-        
     return p, q, bo
 
+
 # moved out of local scope, especially because it didn't
 # have any nested variables.
 
+
 def STORECHAR(CH, byteorder):
-    hi = (CH >> 8) & 0xff
-    lo = CH & 0xff
-    if byteorder == 'little':
+    hi = (CH >> 8) & 0xFF
+    lo = CH & 0xFF
+    if byteorder == "little":
         return [lo, hi]
     else:
         return [hi, lo]
 
-def PyUnicode_EncodeUTF16(s, size, errors, byteorder='little'):
 
-#    /* Offsets from p for storing byte pairs in the right order. */
+def PyUnicode_EncodeUTF16(s, size, errors, byteorder="little"):
+    #    /* Offsets from p for storing byte pairs in the right order. */
 
-        
     p = []
     bom = sys.byteorder
-    if (byteorder == 'native'):
-        
+    if byteorder == "native":
         bom = sys.byteorder
         p += STORECHAR(0xFEFF, bom)
-        
-    if (size == 0):
-        return ""
 
-    if (byteorder == 'little' ):
-        bom = 'little'
-    elif (byteorder == 'big'):
-        bom = 'big'
+    if byteorder == "little":
+        bom = "little"
+    elif byteorder == "big":
+        bom = "big"
 
-
-    for c in s:
-        ch = ord(c)
-        ch2 = 0
-        if (ch >= 0x10000) :
-            ch2 = 0xDC00 | ((ch-0x10000) & 0x3FF)
-            ch  = 0xD800 | ((ch-0x10000) >> 10)
-
-        p += STORECHAR(ch, bom)
-        if (ch2):
-            p += STORECHAR(ch2, bom)
+    pos = 0
+    while pos < len(s):
+        ch = ord(s[pos])
+        if 0xD800 <= ch <= 0xDFFF:
+            if errors == "surrogatepass":
+                p += STORECHAR(ch, bom)
+                pos += 1
+            else:
+                res, pos = unicode_call_errorhandler(
+                    errors, "utf-16", "surrogates not allowed", s, pos, pos + 1, False
+                )
+                for c in res:
+                    cp = ord(c)
+                    cp2 = 0
+                    if cp >= 0x10000:
+                        cp2 = 0xDC00 | ((cp - 0x10000) & 0x3FF)
+                        cp = 0xD800 | ((cp - 0x10000) >> 10)
+                    p += STORECHAR(cp, bom)
+                    if cp2:
+                        p += STORECHAR(cp2, bom)
+        else:
+            ch2 = 0
+            if ch >= 0x10000:
+                ch2 = 0xDC00 | ((ch - 0x10000) & 0x3FF)
+                ch = 0xD800 | ((ch - 0x10000) >> 10)
+            p += STORECHAR(ch, bom)
+            if ch2:
+                p += STORECHAR(ch2, bom)
+            pos += 1
 
     return p
 
@@ -840,119 +1359,149 @@ def PyUnicode_EncodeUTF16(s, size, errors, byteorder='little'):
 def PyUnicode_DecodeMBCS(s, size, errors):
     pass
 
+
 def PyUnicode_EncodeMBCS(p, size, errors):
     pass
 
-def unicode_call_errorhandler(errors,  encoding, 
-                reason, input, startinpos, endinpos, decode=True):
-    
+
+def unicode_call_errorhandler(
+    errors, encoding, reason, input, startinpos, endinpos, decode=True
+):
     errorHandler = lookup_error(errors)
     if decode:
-        exceptionObject = UnicodeDecodeError(encoding, input, startinpos, endinpos, reason)
+        exceptionObject = UnicodeDecodeError(
+            encoding, input, startinpos, endinpos, reason
+        )
     else:
-        exceptionObject = UnicodeEncodeError(encoding, input, startinpos, endinpos, reason)
+        exceptionObject = UnicodeEncodeError(
+            encoding, input, startinpos, endinpos, reason
+        )
     res = errorHandler(exceptionObject)
-    if isinstance(res, tuple) and isinstance(res[0], str) and isinstance(res[1], int):
+    if (
+        isinstance(res, tuple)
+        and isinstance(res[0], (str, bytes))
+        and isinstance(res[1], int)
+    ):
         newpos = res[1]
-        if (newpos < 0):
+        if newpos < 0:
             newpos = len(input) + newpos
         if newpos < 0 or newpos > len(input):
-            raise IndexError( "position %d from error handler out of bounds" % newpos)
+            raise IndexError("position %d from error handler out of bounds" % newpos)
         return res[0], newpos
     else:
-        raise TypeError("encoding error handler must return (unicode, int) tuple, not %s" % repr(res))
+        raise TypeError(
+            "encoding error handler must return (unicode, int) tuple, not %s"
+            % repr(res)
+        )
+
+
+# /* --- Latin-1 Codec ------------------------------------------------------ */
 
-#/* --- Latin-1 Codec ------------------------------------------------------ */
 
 def PyUnicode_DecodeLatin1(s, size, errors):
-    #/* Latin-1 is equivalent to the first 256 ordinals in Unicode. */
-##    if (size == 1):
-##        return [PyUnicode_FromUnicode(s, 1)]
+    # /* Latin-1 is equivalent to the first 256 ordinals in Unicode. */
+    ##    if (size == 1):
+    ##        return [PyUnicode_FromUnicode(s, 1)]
     pos = 0
     p = []
-    while (pos < size):
+    while pos < size:
         p += chr(s[pos])
         pos += 1
     return p
 
+
 def unicode_encode_ucs1(p, size, errors, limit):
-    
     if limit == 256:
         reason = "ordinal not in range(256)"
         encoding = "latin-1"
     else:
         reason = "ordinal not in range(128)"
         encoding = "ascii"
-    
-    if (size == 0):
+
+    if size == 0:
         return []
     res = bytearray()
     pos = 0
     while pos < len(p):
-    #for ch in p:
+        # for ch in p:
         ch = p[pos]
-        
+
         if ord(ch) < limit:
             res.append(ord(ch))
             pos += 1
         else:
-            #/* startpos for collecting unencodable chars */
-            collstart = pos 
-            collend = pos+1 
+            # /* startpos for collecting unencodable chars */
+            collstart = pos
+            collend = pos + 1
             while collend < len(p) and ord(p[collend]) >= limit:
                 collend += 1
-            x = unicode_call_errorhandler(errors, encoding, reason, p, collstart, collend, False)
-            res += x[0].encode()
+            x = unicode_call_errorhandler(
+                errors, encoding, reason, p, collstart, collend, False
+            )
+            replacement = x[0]
+            if isinstance(replacement, bytes):
+                res += replacement
+            else:
+                res += replacement.encode()
             pos = x[1]
-    
+
     return res
 
+
 def PyUnicode_EncodeLatin1(p, size, errors):
     res = unicode_encode_ucs1(p, size, errors, 256)
     return res
 
-hexdigits = [ord(hex(i)[-1]) for i in range(16)]+[ord(hex(i)[-1].upper()) for i in range(10, 16)]
+
+hexdigits = [ord(hex(i)[-1]) for i in range(16)] + [
+    ord(hex(i)[-1].upper()) for i in range(10, 16)
+]
+
 
 def hex_number_end(s, pos, digits):
     target_end = pos + digits
-    while pos < target_end and pos < len(s) and s[pos] in hexdigits: 
+    while pos < target_end and pos < len(s) and s[pos] in hexdigits:
         pos += 1
     return pos
 
+
 def hexescape(s, pos, digits, message, errors):
     ch = 0
     p = []
     number_end = hex_number_end(s, pos, digits)
     if number_end - pos != digits:
-        x = unicode_call_errorhandler(errors, "unicodeescape", message, s, pos-2, number_end)
+        x = unicode_call_errorhandler(
+            errors, "unicodeescape", message, s, pos - 2, number_end
+        )
         p.append(x[0])
         pos = x[1]
     else:
-        ch = int(s[pos:pos+digits], 16)
-        #/* when we get here, ch is a 32-bit unicode character */
+        ch = int(s[pos : pos + digits], 16)
+        # /* when we get here, ch is a 32-bit unicode character */
         if ch <= sys.maxunicode:
             p.append(chr(ch))
             pos += digits
 
-        elif (ch <= 0x10ffff):
+        elif ch <= 0x10FFFF:
             ch -= 0x10000
             p.append(chr(0xD800 + (ch >> 10)))
-            p.append(chr(0xDC00 +  (ch & 0x03FF)))
+            p.append(chr(0xDC00 + (ch & 0x03FF)))
             pos += digits
         else:
             message = "illegal Unicode character"
-            x = unicode_call_errorhandler(errors, "unicodeescape", message, s, pos-2,
-                    pos+digits)
+            x = unicode_call_errorhandler(
+                errors, "unicodeescape", message, s, pos - 2, pos + digits
+            )
             p.append(x[0])
             pos = x[1]
     res = p
     return res, pos
 
+
 def PyUnicode_DecodeUnicodeEscape(s, size, errors, final):
+    if size == 0:
+        return "", 0
 
-    if (size == 0):
-        return ''
-    
     if isinstance(s, str):
         s = s.encode()
 
@@ -960,131 +1509,168 @@ def PyUnicode_DecodeUnicodeEscape(s, size, errors, final):
 
     p = []
     pos = 0
-    while (pos < size): 
-##        /* Non-escape characters are interpreted as Unicode ordinals */
-        if (chr(s[pos]) != '\\') :
+    while pos < size:
+        ##        /* Non-escape characters are interpreted as Unicode ordinals */
+        if s[pos] != ord("\\"):
             p.append(chr(s[pos]))
             pos += 1
             continue
-##        /* \ - Escapes */
-        else:
-            pos += 1
-            if pos >= len(s):
-                errmessage = "\\ at end of string"
-                unicode_call_errorhandler(errors, "unicodeescape", errmessage, s, pos-1, size)
-            ch = chr(s[pos])
-            pos += 1
-    ##        /* \x escapes */
-            if   ch == '\n': pass
-            elif ch == '\\': p += '\\'
-            elif ch == '\'': p += '\''
-            elif ch == '\"': p += '\"' 
-            elif ch == 'b' : p += '\b' 
-            elif ch == 'f' : p += '\014' #/* FF */
-            elif ch == 't' : p += '\t' 
-            elif ch == 'n' : p += '\n'
-            elif ch == 'r' : p += '\r' 
-            elif ch == 'v' : p += '\013' #break; /* VT */
-            elif ch == 'a' : p += '\007' # break; /* BEL, not classic C */
-            elif '0' <= ch <= '7':
-                x = ord(ch) - ord('0')
-                if pos < size:
-                    ch = chr(s[pos])
-                    if '0' <= ch <= '7':
-                        pos += 1
-                        x = (x<<3) + ord(ch) - ord('0')
-                        if pos < size:
-                            ch = chr(s[pos])
-                            if '0' <= ch <= '7':
-                                pos += 1
-                                x = (x<<3) + ord(ch) - ord('0')
-                p.append(chr(x))
-    ##        /* hex escapes */
-    ##        /* \xXX */
-            elif ch == 'x':
+        ##        /* \ - Escapes */
+        escape_start = pos
+        pos += 1
+        if pos >= size:
+            if not final:
+                pos = escape_start
+                break
+            errmessage = "\\ at end of string"
+            unicode_call_errorhandler(
+                errors, "unicodeescape", errmessage, s, pos - 1, size
+            )
+            break
+        ch = chr(s[pos])
+        pos += 1
+        ##        /* \x escapes */
+        if ch == "\n":
+            pass
+        elif ch == "\\":
+            p += "\\"
+        elif ch == "'":
+            p += "'"
+        elif ch == '"':
+            p += '"'
+        elif ch == "b":
+            p += "\b"
+        elif ch == "f":
+            p += "\014"  # /* FF */
+        elif ch == "t":
+            p += "\t"
+        elif ch == "n":
+            p += "\n"
+        elif ch == "r":
+            p += "\r"
+        elif ch == "v":
+            p += "\013"  # break; /* VT */
+        elif ch == "a":
+            p += "\007"  # break; /* BEL, not classic C */
+        elif "0" <= ch <= "7":
+            x = ord(ch) - ord("0")
+            if pos < size:
+                ch = chr(s[pos])
+                if "0" <= ch <= "7":
+                    pos += 1
+                    x = (x << 3) + ord(ch) - ord("0")
+                    if pos < size:
+                        ch = chr(s[pos])
+                        if "0" <= ch <= "7":
+                            pos += 1
+                            x = (x << 3) + ord(ch) - ord("0")
+            p.append(chr(x))
+        ##        /* hex escapes */
+        ##        /* \xXX */
+        elif ch in ("x", "u", "U"):
+            if ch == "x":
                 digits = 2
                 message = "truncated \\xXX escape"
-                x = hexescape(s, pos, digits, message, errors)
-                p += x[0]
-                pos = x[1]
-    
-         #   /* \uXXXX */
-            elif ch == 'u':
+            elif ch == "u":
                 digits = 4
                 message = "truncated \\uXXXX escape"
+            else:
+                digits = 8
+                message = "truncated \\UXXXXXXXX escape"
+            number_end = hex_number_end(s, pos, digits)
+            if number_end - pos != digits:
+                if not final:
+                    pos = escape_start
+                    break
                 x = hexescape(s, pos, digits, message, errors)
                 p += x[0]
                 pos = x[1]
-    
-          #  /* \UXXXXXXXX */
-            elif ch == 'U':
-                digits = 8
-                message = "truncated \\UXXXXXXXX escape"
+            else:
                 x = hexescape(s, pos, digits, message, errors)
                 p += x[0]
                 pos = x[1]
-##        /* \N{name} */
-            elif ch == 'N':
-                message = "malformed \\N character escape"
-                # pos += 1
-                look = pos
-                try:
-                    import unicodedata
-                except ImportError:
-                    message = "\\N escapes not supported (can't load unicodedata module)"
-                    unicode_call_errorhandler(errors, "unicodeescape", message, s, pos-1, size)
-                if look < size and chr(s[look]) == '{':
-                    #/* look for the closing brace */
-                    while (look < size and chr(s[look]) != '}'):
-                        look += 1
-                    if (look > pos+1 and look < size and chr(s[look]) == '}'):
-                        #/* found a name.  look it up in the unicode database */
-                        message = "unknown Unicode character name"
-                        st = s[pos+1:look]
-                        try:
-                            chr_codec = unicodedata.lookup("%s" % st)
-                        except LookupError as e:
-                            x = unicode_call_errorhandler(errors, "unicodeescape", message, s, pos-1, look+1)
-                        else:
-                            x = chr_codec, look + 1 
-                        p.append(x[0])
-                        pos = x[1]
-                    else:        
-                        x = unicode_call_errorhandler(errors, "unicodeescape", message, s, pos-1, look+1)
-                else:        
-                    x = unicode_call_errorhandler(errors, "unicodeescape", message, s, pos-1, look+1)
+        ##        /* \N{name} */
+        elif ch == "N":
+            message = "malformed \\N character escape"
+            look = pos
+            try:
+                import unicodedata
+            except ImportError:
+                message = "\\N escapes not supported (can't load unicodedata module)"
+                unicode_call_errorhandler(
+                    errors, "unicodeescape", message, s, pos - 1, size
+                )
+                continue
+            if look < size and chr(s[look]) == "{":
+                # /* look for the closing brace */
+                while look < size and chr(s[look]) != "}":
+                    look += 1
+                if look > pos + 1 and look < size and chr(s[look]) == "}":
+                    # /* found a name.  look it up in the unicode database */
+                    message = "unknown Unicode character name"
+                    st = s[pos + 1 : look]
+                    try:
+                        chr_codec = unicodedata.lookup("%s" % st)
+                    except LookupError as e:
+                        x = unicode_call_errorhandler(
+                            errors, "unicodeescape", message, s, pos - 1, look + 1
+                        )
+                    else:
+                        x = chr_codec, look + 1
+                    p.append(x[0])
+                    pos = x[1]
+                else:
+                    if not final:
+                        pos = escape_start
+                        break
+                    x = unicode_call_errorhandler(
+                        errors, "unicodeescape", message, s, pos - 1, look + 1
+                    )
+                    p.append(x[0])
+                    pos = x[1]
             else:
-                if not found_invalid_escape:
-                    found_invalid_escape = True
-                    warnings.warn("invalid escape sequence '\\%c'" % ch, DeprecationWarning, 2)
-                p.append('\\')
-                p.append(ch)
-    return p
+                if not final:
+                    pos = escape_start
+                    break
+                x = unicode_call_errorhandler(
+                    errors, "unicodeescape", message, s, pos - 1, look + 1
+                )
+                p.append(x[0])
+                pos = x[1]
+        else:
+            if not found_invalid_escape:
+                found_invalid_escape = True
+                warnings.warn(
+                    "invalid escape sequence '\\%c'" % ch, DeprecationWarning, 2
+                )
+            p.append("\\")
+            p.append(ch)
+    return p, pos
+
 
 def PyUnicode_EncodeRawUnicodeEscape(s, size):
-    
-    if (size == 0):
-        return b''
+    if size == 0:
+        return b""
 
     p = bytearray()
     for ch in s:
-#       /* Map 32-bit characters to '\Uxxxxxxxx' */
-        if (ord(ch) >= 0x10000):
-            p += b'\\U%08x' % ord(ch)
-        elif (ord(ch) >= 256) :
-#       /* Map 16-bit characters to '\uxxxx' */
-            p += b'\\u%04x' % (ord(ch))
-#       /* Copy everything else as-is */
+        #       /* Map 32-bit characters to '\Uxxxxxxxx' */
+        if ord(ch) >= 0x10000:
+            p += b"\\U%08x" % ord(ch)
+        elif ord(ch) >= 256:
+            #       /* Map 16-bit characters to '\uxxxx' */
+            p += b"\\u%04x" % (ord(ch))
+        #       /* Copy everything else as-is */
         else:
             p.append(ord(ch))
-    
-    #p += '\0'
+
+    # p += '\0'
     return p
 
-def charmapencode_output(c, mapping):
 
+def charmapencode_output(c, mapping):
     rep = mapping[c]
-    if isinstance(rep, int) or isinstance(rep, int):
+    if isinstance(rep, int):
         if rep < 256:
             return [rep]
         else:
@@ -1098,144 +1684,156 @@ def charmapencode_output(c, mapping):
     else:
         raise TypeError("character mapping must return integer, None or str")
 
-def PyUnicode_EncodeCharmap(p, size, mapping='latin-1', errors='strict'):
 
-##    /* the following variable is used for caching string comparisons
-##     * -1=not initialized, 0=unknown, 1=strict, 2=replace,
-##     * 3=ignore, 4=xmlcharrefreplace */
+def PyUnicode_EncodeCharmap(p, size, mapping="latin-1", errors="strict"):
+    ##    /* the following variable is used for caching string comparisons
+    ##     * -1=not initialized, 0=unknown, 1=strict, 2=replace,
+    ##     * 3=ignore, 4=xmlcharrefreplace */
 
-#    /* Default to Latin-1 */
-    if mapping == 'latin-1':
+    #    /* Default to Latin-1 */
+    if mapping == "latin-1":
         return PyUnicode_EncodeLatin1(p, size, errors)
-    if (size == 0):
-        return b''
+    if size == 0:
+        return b""
     inpos = 0
     res = []
-    while (inpos<size):
-        #/* try to encode it */
+    while inpos < size:
+        # /* try to encode it */
         try:
             x = charmapencode_output(ord(p[inpos]), mapping)
             res += x
         except KeyError:
-            x = unicode_call_errorhandler(errors, "charmap",
-            "character maps to <undefined>", p, inpos, inpos+1, False)
-            try:
-                for y in x[0]:
-                    res += charmapencode_output(ord(y), mapping)
-            except KeyError:
-                raise UnicodeEncodeError("charmap", p, inpos, inpos+1,
-                                        "character maps to <undefined>")
+            x = unicode_call_errorhandler(
+                errors,
+                "charmap",
+                "character maps to <undefined>",
+                p,
+                inpos,
+                inpos + 1,
+                False,
+            )
+            replacement = x[0]
+            if isinstance(replacement, bytes):
+                res += list(replacement)
+            else:
+                try:
+                    for y in replacement:
+                        res += charmapencode_output(ord(y), mapping)
+                except KeyError:
+                    raise UnicodeEncodeError(
+                        "charmap", p, inpos, inpos + 1, "character maps to <undefined>"
+                    )
         inpos += 1
     return res
 
-def PyUnicode_DecodeCharmap(s, size, mapping, errors):
 
-##    /* Default to Latin-1 */
-    if (mapping == None):
+def PyUnicode_DecodeCharmap(s, size, mapping, errors):
+    ##    /* Default to Latin-1 */
+    if mapping == None:
         return PyUnicode_DecodeLatin1(s, size, errors)
 
-    if (size == 0):
-        return ''
+    if size == 0:
+        return ""
     p = []
     inpos = 0
-    while (inpos< len(s)):
-        
-        #/* Get mapping (char ordinal -> integer, Unicode char or None) */
+    while inpos < len(s):
+        # /* Get mapping (char ordinal -> integer, Unicode char or None) */
         ch = s[inpos]
         try:
             x = mapping[ch]
             if isinstance(x, int):
-                if x < 65536:
+                if x == 0xFFFE:
+                    raise KeyError
+                if 0 <= x <= 0x10FFFF:
                     p += chr(x)
                 else:
-                    raise TypeError("character mapping must be in range(65536)")
+                    raise TypeError(
+                        "character mapping must be in range(0x%x)" % (0x110000,)
+                    )
             elif isinstance(x, str):
+                if len(x) == 1 and x == "\ufffe":
+                    raise KeyError
                 p += x
-            elif not x:
+            elif x is None:
                 raise KeyError
             else:
                 raise TypeError
-        except KeyError:
-            x = unicode_call_errorhandler(errors, "charmap",
-                "character maps to <undefined>", s, inpos, inpos+1)
+        except (KeyError, IndexError):
+            x = unicode_call_errorhandler(
+                errors, "charmap", "character maps to <undefined>", s, inpos, inpos + 1
+            )
             p += x[0]
         inpos += 1
     return p
 
-def PyUnicode_DecodeRawUnicodeEscape(s, size, errors, final):
 
-    if (size == 0):
-        return ''
+def PyUnicode_DecodeRawUnicodeEscape(s, size, errors, final):
+    if size == 0:
+        return "", 0
 
     if isinstance(s, str):
         s = s.encode()
 
     pos = 0
     p = []
-    while (pos < len(s)):
-        ch = chr(s[pos])
-    #/* Non-escape characters are interpreted as Unicode ordinals */
-        if (ch != '\\'):
-            p.append(ch)
+    while pos < len(s):
+        # /* Non-escape characters are interpreted as Unicode ordinals */
+        if s[pos] != ord("\\"):
+            p.append(chr(s[pos]))
             pos += 1
-            continue        
+            continue
         startinpos = pos
-##      /* \u-escapes are only interpreted iff the number of leading
-##         backslashes is odd */
+        p_len_before = len(p)
+        ##      /* \u-escapes are only interpreted iff the number of leading
+        ##         backslashes is odd */
         bs = pos
         while pos < size:
-            if (s[pos] != ord('\\')):
+            if s[pos] != ord("\\"):
                 break
             p.append(chr(s[pos]))
             pos += 1
-    
-        if (pos >= size):
+
+        if pos >= size:
+            if not final:
+                del p[p_len_before:]
+                pos = startinpos
             break
-        if (((pos - bs) & 1) == 0 or
-            (s[pos] != ord('u') and s[pos] != ord('U'))) :
+        if ((pos - bs) & 1) == 0 or (s[pos] != ord("u") and s[pos] != ord("U")):
             p.append(chr(s[pos]))
             pos += 1
             continue
-        
+
         p.pop(-1)
-        if s[pos] == ord('u'):
-            count = 4 
-        else: 
-            count = 8
+        count = 4 if s[pos] == ord("u") else 8
         pos += 1
 
-        #/* \uXXXX with 4 hex digits, \Uxxxxxxxx with 8 */
+        # /* \uXXXX with 4 hex digits, \Uxxxxxxxx with 8 */
         number_end = hex_number_end(s, pos, count)
         if number_end - pos != count:
+            if not final:
+                del p[p_len_before:]
+                pos = startinpos
+                break
             res = unicode_call_errorhandler(
-                    errors, "rawunicodeescape", "truncated \\uXXXX",
-                    s, pos-2, number_end)
+                errors, "rawunicodeescape", "truncated \\uXXXX", s, pos - 2, number_end
+            )
             p.append(res[0])
             pos = res[1]
         else:
-            x = int(s[pos:pos+count], 16)
-    #ifndef Py_UNICODE_WIDE
-            if sys.maxunicode > 0xffff:
-                if (x > sys.maxunicode):
-                    res = unicode_call_errorhandler(
-                        errors, "rawunicodeescape", "\\Uxxxxxxxx out of range",
-                        s, pos-2, pos+count)
-                    pos = res[1]
-                    p.append(res[0])
-                else:
-                    p.append(chr(x))
-                    pos += count
+            x = int(s[pos : pos + count], 16)
+            if x > sys.maxunicode:
+                res = unicode_call_errorhandler(
+                    errors,
+                    "rawunicodeescape",
+                    "\\Uxxxxxxxx out of range",
+                    s,
+                    pos - 2,
+                    pos + count,
+                )
+                pos = res[1]
+                p.append(res[0])
             else:
-                if (x > 0x10000):
-                    res = unicode_call_errorhandler(
-                        errors, "rawunicodeescape", "\\Uxxxxxxxx out of range",
-                        s, pos-2, pos+count)
-                    pos = res[1]
-                    p.append(res[0])
-
-    #endif
-                else:
-                    p.append(chr(x))
-                    pos += count
+                p.append(chr(x))
+                pos += count
 
-    return p
+    return p, pos
diff --git a/Lib/_pydatetime.py b/Lib/_pydatetime.py
index 38e1f764f00..70251dbb653 100644
--- a/Lib/_pydatetime.py
+++ b/Lib/_pydatetime.py
@@ -1,12 +1,10 @@
-"""Concrete date/time and related types.
-
-See http://www.iana.org/time-zones/repository/tz-link.html for
-time zone and DST data sources.
-"""
+"""Pure Python implementation of the datetime module."""
 
 __all__ = ("date", "datetime", "time", "timedelta", "timezone", "tzinfo",
            "MINYEAR", "MAXYEAR", "UTC")
 
+__name__ = "datetime"
+
 
 import time as _time
 import math as _math
@@ -18,10 +16,10 @@ def _cmp(x, y):
 
 def _get_class_module(self):
     module_name = self.__class__.__module__
-    if module_name == '_pydatetime':
-        return 'datetime'
+    if module_name == 'datetime':
+        return 'datetime.'
     else:
-        return module_name
+        return ''
 
 MINYEAR = 1
 MAXYEAR = 9999
@@ -64,14 +62,14 @@ def _days_in_month(year, month):
 
 def _days_before_month(year, month):
     "year, month -> number of days in year preceding first day of month."
-    assert 1 <= month <= 12, 'month must be in 1..12'
+    assert 1 <= month <= 12, f"month must be in 1..12, not {month}"
     return _DAYS_BEFORE_MONTH[month] + (month > 2 and _is_leap(year))
 
 def _ymd2ord(year, month, day):
     "year, month, day -> ordinal, considering 01-Jan-0001 as day 1."
-    assert 1 <= month <= 12, 'month must be in 1..12'
+    assert 1 <= month <= 12, f"month must be in 1..12, not {month}"
     dim = _days_in_month(year, month)
-    assert 1 <= day <= dim, ('day must be in 1..%d' % dim)
+    assert 1 <= day <= dim, f"day must be in 1..{dim}, not {day}"
     return (_days_before_year(year) +
             _days_before_month(year, month) +
             day)
@@ -204,6 +202,17 @@ def _format_offset(off, sep=':'):
                 s += '.%06d' % ss.microseconds
     return s
 
+_normalize_century = None
+def _need_normalize_century():
+    global _normalize_century
+    if _normalize_century is None:
+        try:
+            _normalize_century = (
+                _time.strftime("%Y", (99, 1, 1, 0, 0, 0, 0, 1, 0)) != "0099")
+        except ValueError:
+            _normalize_century = True
+    return _normalize_century
+
 # Correctly substitute for %z and %Z escapes in strftime formats.
 def _wrap_strftime(object, format, timetuple):
     # Don't call utcoffset() or tzname() unless actually needed.
@@ -261,6 +270,20 @@ def _wrap_strftime(object, format, timetuple):
                                 # strftime is going to have at this: escape %
                                 Zreplace = s.replace('%', '%%')
                     newformat.append(Zreplace)
+                # Note that datetime(1000, 1, 1).strftime('%G') == '1000' so
+                # year 1000 for %G can go on the fast path.
+                elif ((ch in 'YG' or ch in 'FC') and
+                        object.year < 1000 and _need_normalize_century()):
+                    if ch == 'G':
+                        year = int(_time.strftime("%G", timetuple))
+                    else:
+                        year = object.year
+                    if ch == 'C':
+                        push('{:02}'.format(year // 100))
+                    else:
+                        push('{:04}'.format(year))
+                        if ch == 'F':
+                            push('-{:02}-{:02}'.format(*timetuple[1:3]))
                 else:
                     push('%')
                     push(ch)
@@ -399,7 +422,7 @@ def _parse_hh_mm_ss_ff(tstr):
 
     if pos < len_str:
         if tstr[pos] not in '.,':
-            raise ValueError("Invalid microsecond component")
+            raise ValueError("Invalid microsecond separator")
         else:
             pos += 1
             if not all(map(_is_ascii_digit, tstr[pos:])):
@@ -430,6 +453,17 @@ def _parse_isoformat_time(tstr):
 
     time_comps = _parse_hh_mm_ss_ff(timestr)
 
+    hour, minute, second, microsecond = time_comps
+    became_next_day = False
+    error_from_components = False
+    if (hour == 24):
+        if all(time_comp == 0 for time_comp in time_comps[1:]):
+            hour = 0
+            time_comps[0] = hour
+            became_next_day = True
+        else:
+            error_from_components = True
+
     tzi = None
     if tz_pos == len_str and tstr[-1] == 'Z':
         tzi = timezone.utc
@@ -445,7 +479,7 @@ def _parse_isoformat_time(tstr):
         # HH:MM:SS            len: 8
         # HH:MM:SS.f+         len: 10+
 
-        if len(tzstr) in (0, 1, 3):
+        if len(tzstr) in (0, 1, 3) or tstr[tz_pos-1] == 'Z':
             raise ValueError("Malformed time zone string")
 
         tz_comps = _parse_hh_mm_ss_ff(tzstr)
@@ -462,13 +496,13 @@ def _parse_isoformat_time(tstr):
 
     time_comps.append(tzi)
 
-    return time_comps
+    return time_comps, became_next_day, error_from_components
 
 # tuple[int, int, int] -> tuple[int, int, int] version of date.fromisocalendar
 def _isoweek_to_gregorian(year, week, day):
     # Year is bounded this way because 9999-12-31 is (9999, 52, 5)
     if not MINYEAR <= year <= MAXYEAR:
-        raise ValueError(f"Year is out of range: {year}")
+        raise ValueError(f"year must be in {MINYEAR}..{MAXYEAR}, not {year}")
 
     if not 0 < week < 53:
         out_of_range = True
@@ -501,7 +535,7 @@ def _isoweek_to_gregorian(year, week, day):
 def _check_tzname(name):
     if name is not None and not isinstance(name, str):
         raise TypeError("tzinfo.tzname() must return None or string, "
-                        "not '%s'" % type(name))
+                        f"not {type(name).__name__!r}")
 
 # name is the offset-producing method, "utcoffset" or "dst".
 # offset is what it returned.
@@ -514,24 +548,24 @@ def _check_utc_offset(name, offset):
     if offset is None:
         return
     if not isinstance(offset, timedelta):
-        raise TypeError("tzinfo.%s() must return None "
-                        "or timedelta, not '%s'" % (name, type(offset)))
+        raise TypeError(f"tzinfo.{name}() must return None "
+                        f"or timedelta, not {type(offset).__name__!r}")
     if not -timedelta(1) < offset < timedelta(1):
-        raise ValueError("%s()=%s, must be strictly between "
-                         "-timedelta(hours=24) and timedelta(hours=24)" %
-                         (name, offset))
+        raise ValueError("offset must be a timedelta "
+                         "strictly between -timedelta(hours=24) and "
+                         f"timedelta(hours=24), not {offset!r}")
 
 def _check_date_fields(year, month, day):
     year = _index(year)
     month = _index(month)
     day = _index(day)
     if not MINYEAR <= year <= MAXYEAR:
-        raise ValueError('year must be in %d..%d' % (MINYEAR, MAXYEAR), year)
+        raise ValueError(f"year must be in {MINYEAR}..{MAXYEAR}, not {year}")
     if not 1 <= month <= 12:
-        raise ValueError('month must be in 1..12', month)
+        raise ValueError(f"month must be in 1..12, not {month}")
     dim = _days_in_month(year, month)
     if not 1 <= day <= dim:
-        raise ValueError('day must be in 1..%d' % dim, day)
+        raise ValueError(f"day {day} must be in range 1..{dim} for month {month} in year {year}")
     return year, month, day
 
 def _check_time_fields(hour, minute, second, microsecond, fold):
@@ -540,20 +574,23 @@ def _check_time_fields(hour, minute, second, microsecond, fold):
     second = _index(second)
     microsecond = _index(microsecond)
     if not 0 <= hour <= 23:
-        raise ValueError('hour must be in 0..23', hour)
+        raise ValueError(f"hour must be in 0..23, not {hour}")
     if not 0 <= minute <= 59:
-        raise ValueError('minute must be in 0..59', minute)
+        raise ValueError(f"minute must be in 0..59, not {minute}")
     if not 0 <= second <= 59:
-        raise ValueError('second must be in 0..59', second)
+        raise ValueError(f"second must be in 0..59, not {second}")
     if not 0 <= microsecond <= 999999:
-        raise ValueError('microsecond must be in 0..999999', microsecond)
+        raise ValueError(f"microsecond must be in 0..999999, not {microsecond}")
     if fold not in (0, 1):
-        raise ValueError('fold must be either 0 or 1', fold)
+        raise ValueError(f"fold must be either 0 or 1, not {fold}")
     return hour, minute, second, microsecond, fold
 
 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")
+        raise TypeError(
+            "tzinfo argument must be None or of a tzinfo subclass, "
+            f"not {type(tz).__name__!r}"
+        )
 
 def _divide_and_round(a, b):
     """divide a by b and round result to the nearest integer
@@ -607,7 +644,19 @@ def __new__(cls, days=0, seconds=0, microseconds=0,
         # guide the C implementation; it's way more convoluted than speed-
         # ignoring auto-overflow-to-long idiomatic Python could be.
 
-        # XXX Check that all inputs are ints or floats.
+        for name, value in (
+            ("days", days),
+            ("seconds", seconds),
+            ("microseconds", microseconds),
+            ("milliseconds", milliseconds),
+            ("minutes", minutes),
+            ("hours", hours),
+            ("weeks", weeks)
+        ):
+            if not isinstance(value, (int, float)):
+                raise TypeError(
+                    f"unsupported type for timedelta {name} component: {type(value).__name__}"
+                )
 
         # Final values, all integer.
         # s and us fit in 32-bit signed ints; d isn't bounded.
@@ -708,9 +757,9 @@ def __repr__(self):
             args.append("microseconds=%d" % self._microseconds)
         if not args:
             args.append('0')
-        return "%s.%s(%s)" % (_get_class_module(self),
-                              self.__class__.__qualname__,
-                              ', '.join(args))
+        return "%s%s(%s)" % (_get_class_module(self),
+                             self.__class__.__qualname__,
+                             ', '.join(args))
 
     def __str__(self):
         mm, ss = divmod(self._seconds, 60)
@@ -907,6 +956,7 @@ class date:
     fromtimestamp()
     today()
     fromordinal()
+    strptime()
 
     Operators:
 
@@ -989,8 +1039,12 @@ def fromordinal(cls, n):
     @classmethod
     def fromisoformat(cls, date_string):
         """Construct a date from a string in ISO 8601 format."""
+
         if not isinstance(date_string, str):
-            raise TypeError('fromisoformat: argument must be str')
+            raise TypeError('Argument must be a str')
+
+        if not date_string.isascii():
+            raise ValueError('Argument must be an ASCII str')
 
         if len(date_string) not in (7, 8, 10):
             raise ValueError(f'Invalid isoformat string: {date_string!r}')
@@ -1007,6 +1061,12 @@ def fromisocalendar(cls, year, week, day):
         This is the inverse of the date.isocalendar() function"""
         return cls(*_isoweek_to_gregorian(year, week, day))
 
+    @classmethod
+    def strptime(cls, date_string, format):
+        """Parse a date string according to the given format (like time.strptime())."""
+        import _strptime
+        return _strptime._strptime_datetime_date(cls, date_string, format)
+
     # Conversions to string
 
     def __repr__(self):
@@ -1016,11 +1076,11 @@ def __repr__(self):
         >>> repr(d)
         'datetime.date(2010, 1, 1)'
         """
-        return "%s.%s(%d, %d, %d)" % (_get_class_module(self),
-                                      self.__class__.__qualname__,
-                                      self._year,
-                                      self._month,
-                                      self._day)
+        return "%s%s(%d, %d, %d)" % (_get_class_module(self),
+                                     self.__class__.__qualname__,
+                                     self._year,
+                                     self._month,
+                                     self._day)
     # XXX These shouldn't depend on time.localtime(), because that
     # clips the usable dates to [1970 .. 2038).  At least ctime() is
     # easily done without using strftime() -- that's better too because
@@ -1327,6 +1387,7 @@ class time:
     Constructors:
 
     __new__()
+    strptime()
 
     Operators:
 
@@ -1385,6 +1446,12 @@ def __new__(cls, hour=0, minute=0, second=0, microsecond=0, tzinfo=None, *, fold
         self._fold = fold
         return self
 
+    @classmethod
+    def strptime(cls, date_string, format):
+        """string, format -> new time parsed from a string (like time.strptime())."""
+        import _strptime
+        return _strptime._strptime_datetime_time(cls, date_string, format)
+
     # Read-only field accessors
     @property
     def hour(self):
@@ -1513,7 +1580,7 @@ def __repr__(self):
             s = ", %d" % self._second
         else:
             s = ""
-        s= "%s.%s(%d, %d%s)" % (_get_class_module(self),
+        s = "%s%s(%d, %d%s)" % (_get_class_module(self),
                                 self.__class__.__qualname__,
                                 self._hour, self._minute, s)
         if self._tzinfo is not None:
@@ -1555,7 +1622,7 @@ def fromisoformat(cls, time_string):
         time_string = time_string.removeprefix('T')
 
         try:
-            return cls(*_parse_isoformat_time(time_string))
+            return cls(*_parse_isoformat_time(time_string)[0])
         except Exception:
             raise ValueError(f'Invalid isoformat string: {time_string!r}')
 
@@ -1869,10 +1936,27 @@ def fromisoformat(cls, date_string):
 
         if tstr:
             try:
-                time_components = _parse_isoformat_time(tstr)
+                time_components, became_next_day, error_from_components = _parse_isoformat_time(tstr)
             except ValueError:
                 raise ValueError(
                     f'Invalid isoformat string: {date_string!r}') from None
+            else:
+                if error_from_components:
+                    raise ValueError("minute, second, and microsecond must be 0 when hour is 24")
+
+                if became_next_day:
+                    year, month, day = date_components
+                    # Only wrap day/month when it was previously valid
+                    if month <= 12 and day <= (days_in_month := _days_in_month(year, month)):
+                        # Calculate midnight of the next day
+                        day += 1
+                        if day > days_in_month:
+                            day = 1
+                            month += 1
+                            if month > 12:
+                                month = 1
+                                year += 1
+                        date_components = [year, month, day]
         else:
             time_components = [0, 0, 0, 0, None]
 
@@ -2072,9 +2156,9 @@ def __repr__(self):
             del L[-1]
         if L[-1] == 0:
             del L[-1]
-        s = "%s.%s(%s)" % (_get_class_module(self),
-                           self.__class__.__qualname__,
-                           ", ".join(map(str, L)))
+        s = "%s%s(%s)" % (_get_class_module(self),
+                          self.__class__.__qualname__,
+                          ", ".join(map(str, L)))
         if self._tzinfo is not None:
             assert s[-1:] == ")"
             s = s[:-1] + ", tzinfo=%r" % self._tzinfo + ")"
@@ -2091,7 +2175,7 @@ def __str__(self):
     def strptime(cls, date_string, format):
         'string, format -> new datetime parsed from a string (like time.strptime()).'
         import _strptime
-        return _strptime._strptime_datetime(cls, date_string, format)
+        return _strptime._strptime_datetime_datetime(cls, date_string, format)
 
     def utcoffset(self):
         """Return the timezone offset as timedelta positive east of UTC (negative west of
@@ -2331,7 +2415,7 @@ def __new__(cls, offset, name=_Omitted):
         if not cls._minoffset <= offset <= cls._maxoffset:
             raise ValueError("offset must be a timedelta "
                              "strictly between -timedelta(hours=24) and "
-                             "timedelta(hours=24).")
+                             f"timedelta(hours=24), not {offset!r}")
         return cls._create(offset, name)
 
     def __init_subclass__(cls):
@@ -2371,12 +2455,12 @@ def __repr__(self):
         if self is self.utc:
             return 'datetime.timezone.utc'
         if self._name is None:
-            return "%s.%s(%r)" % (_get_class_module(self),
-                                  self.__class__.__qualname__,
-                                  self._offset)
-        return "%s.%s(%r, %r)" % (_get_class_module(self),
-                                  self.__class__.__qualname__,
-                                  self._offset, self._name)
+            return "%s%s(%r)" % (_get_class_module(self),
+                                 self.__class__.__qualname__,
+                                 self._offset)
+        return "%s%s(%r, %r)" % (_get_class_module(self),
+                                 self.__class__.__qualname__,
+                                 self._offset, self._name)
 
     def __str__(self):
         return self.tzname(None)
diff --git a/Lib/_pydecimal.py b/Lib/_pydecimal.py
index ff80180a79e..97a629fe92c 100644
--- a/Lib/_pydecimal.py
+++ b/Lib/_pydecimal.py
@@ -38,10 +38,10 @@
     'ROUND_FLOOR', 'ROUND_UP', 'ROUND_HALF_DOWN', 'ROUND_05UP',
 
     # Functions for manipulating contexts
-    'setcontext', 'getcontext', 'localcontext',
+    'setcontext', 'getcontext', 'localcontext', 'IEEEContext',
 
     # Limits for the C version for compatibility
-    'MAX_PREC',  'MAX_EMAX', 'MIN_EMIN', 'MIN_ETINY',
+    'MAX_PREC',  'MAX_EMAX', 'MIN_EMIN', 'MIN_ETINY', 'IEEE_CONTEXT_MAX_BITS',
 
     # C version: compile time choice that enables the thread local context (deprecated, now always true)
     'HAVE_THREADS',
@@ -83,10 +83,12 @@
     MAX_PREC = 999999999999999999
     MAX_EMAX = 999999999999999999
     MIN_EMIN = -999999999999999999
+    IEEE_CONTEXT_MAX_BITS = 512
 else:
     MAX_PREC = 425000000
     MAX_EMAX = 425000000
     MIN_EMIN = -425000000
+    IEEE_CONTEXT_MAX_BITS = 256
 
 MIN_ETINY = MIN_EMIN - (MAX_PREC-1)
 
@@ -417,6 +419,27 @@ def sin(x):
     return ctx_manager
 
 
+def IEEEContext(bits, /):
+    """
+    Return a context object initialized to the proper values for one of the
+    IEEE interchange formats.  The argument must be a multiple of 32 and less
+    than IEEE_CONTEXT_MAX_BITS.
+    """
+    if bits <= 0 or bits > IEEE_CONTEXT_MAX_BITS or bits % 32:
+        raise ValueError("argument must be a multiple of 32, "
+                         f"with a maximum of {IEEE_CONTEXT_MAX_BITS}")
+
+    ctx = Context()
+    ctx.prec = 9 * (bits//32) - 2
+    ctx.Emax = 3 * (1 << (bits//16 + 3))
+    ctx.Emin = 1 - ctx.Emax
+    ctx.rounding = ROUND_HALF_EVEN
+    ctx.clamp = 1
+    ctx.traps = dict.fromkeys(_signals, False)
+
+    return ctx
+
+
 ##### Decimal class #######################################################
 
 # Do not subclass Decimal from numbers.Real and do not register it as such
@@ -582,6 +605,21 @@ def __new__(cls, value="0", context=None):
 
         raise TypeError("Cannot convert %r to Decimal" % value)
 
+    @classmethod
+    def from_number(cls, number):
+        """Converts a real number to a decimal number, exactly.
+
+        >>> Decimal.from_number(314)              # int
+        Decimal('314')
+        >>> Decimal.from_number(0.1)              # float
+        Decimal('0.1000000000000000055511151231257827021181583404541015625')
+        >>> Decimal.from_number(Decimal('3.14'))  # another decimal instance
+        Decimal('3.14')
+        """
+        if isinstance(number, (int, Decimal, float)):
+            return cls(number)
+        raise TypeError("Cannot convert %r to Decimal" % number)
+
     @classmethod
     def from_float(cls, f):
         """Converts a float to a decimal number, exactly.
@@ -2425,12 +2463,12 @@ def __pow__(self, other, modulo=None, context=None):
 
         return ans
 
-    def __rpow__(self, other, context=None):
+    def __rpow__(self, other, modulo=None, context=None):
         """Swaps self/other and returns __pow__."""
         other = _convert_other(other)
         if other is NotImplemented:
             return other
-        return other.__pow__(self, context=context)
+        return other.__pow__(self, modulo, context=context)
 
     def normalize(self, context=None):
         """Normalize- strip trailing 0s, change anything equal to 0 to 0e0"""
@@ -3302,7 +3340,10 @@ def _fill_logical(self, context, opa, opb):
         return opa, opb
 
     def logical_and(self, other, context=None):
-        """Applies an 'and' operation between self and other's digits."""
+        """Applies an 'and' operation between self and other's digits.
+
+        Both self and other must be logical numbers.
+        """
         if context is None:
             context = getcontext()
 
@@ -3319,14 +3360,20 @@ def logical_and(self, other, context=None):
         return _dec_from_triple(0, result.lstrip('0') or '0', 0)
 
     def logical_invert(self, context=None):
-        """Invert all its digits."""
+        """Invert all its digits.
+
+        The self must be logical number.
+        """
         if context is None:
             context = getcontext()
         return self.logical_xor(_dec_from_triple(0,'1'*context.prec,0),
                                 context)
 
     def logical_or(self, other, context=None):
-        """Applies an 'or' operation between self and other's digits."""
+        """Applies an 'or' operation between self and other's digits.
+
+        Both self and other must be logical numbers.
+        """
         if context is None:
             context = getcontext()
 
@@ -3343,7 +3390,10 @@ def logical_or(self, other, context=None):
         return _dec_from_triple(0, result.lstrip('0') or '0', 0)
 
     def logical_xor(self, other, context=None):
-        """Applies an 'xor' operation between self and other's digits."""
+        """Applies an 'xor' operation between self and other's digits.
+
+        Both self and other must be logical numbers.
+        """
         if context is None:
             context = getcontext()
 
@@ -6058,7 +6108,7 @@ def _convert_for_comparison(self, other, equality_op=False):
         (?P<diag>\d*)            # with (possibly empty) diagnostic info.
     )
 #    \s*
-    \Z
+    \z
 """, re.VERBOSE | re.IGNORECASE).match
 
 _all_zeros = re.compile('0*$').match
@@ -6082,11 +6132,15 @@ def _convert_for_comparison(self, other, equality_op=False):
 (?P<no_neg_0>z)?
 (?P<alt>\#)?
 (?P<zeropad>0)?
-(?P<minimumwidth>(?!0)\d+)?
-(?P<thousands_sep>,)?
-(?:\.(?P<precision>0|(?!0)\d+))?
+(?P<minimumwidth>\d+)?
+(?P<thousands_sep>[,_])?
+(?:\.
+    (?=[\d,_])  # lookahead for digit or separator
+    (?P<precision>\d+)?
+    (?P<frac_separators>[,_])?
+)?
 (?P<type>[eEfFgGn%])?
-\Z
+\z
 """, re.VERBOSE|re.DOTALL)
 
 del re
@@ -6177,6 +6231,9 @@ def _parse_format_specifier(format_spec, _localeconv=None):
         format_dict['grouping'] = [3, 0]
         format_dict['decimal_point'] = '.'
 
+    if format_dict['frac_separators'] is None:
+        format_dict['frac_separators'] = ''
+
     return format_dict
 
 def _format_align(sign, body, spec):
@@ -6296,6 +6353,11 @@ def _format_number(is_negative, intpart, fracpart, exp, spec):
 
     sign = _format_sign(is_negative, spec)
 
+    frac_sep = spec['frac_separators']
+    if fracpart and frac_sep:
+        fracpart = frac_sep.join(fracpart[pos:pos + 3]
+                                 for pos in range(0, len(fracpart), 3))
+
     if fracpart or spec['alt']:
         fracpart = spec['decimal_point'] + fracpart
 
diff --git a/Lib/_pyio.py b/Lib/_pyio.py
index 48c8f770f81..116ce4f37ec 100644
--- a/Lib/_pyio.py
+++ b/Lib/_pyio.py
@@ -16,15 +16,16 @@
     _setmode = None
 
 import io
-from io import (__all__, SEEK_SET, SEEK_CUR, SEEK_END)
+from io import (__all__, SEEK_SET, SEEK_CUR, SEEK_END, Reader, Writer)  # noqa: F401
 
 valid_seek_flags = {0, 1, 2}  # Hardwired values
 if hasattr(os, 'SEEK_HOLE') :
     valid_seek_flags.add(os.SEEK_HOLE)
     valid_seek_flags.add(os.SEEK_DATA)
 
-# open() uses st_blksize whenever we can
-DEFAULT_BUFFER_SIZE = 8 * 1024  # bytes
+# open() uses max(min(blocksize, 8 MiB), DEFAULT_BUFFER_SIZE)
+# when the device block size is available.
+DEFAULT_BUFFER_SIZE = 128 * 1024  # bytes
 
 # NOTE: Base classes defined here are registered with the "official" ABCs
 # defined in io.py. We don't use real inheritance though, because we don't want
@@ -123,10 +124,10 @@ def open(file, mode="r", buffering=-1, encoding=None, errors=None,
     the size of a fixed-size chunk buffer.  When no buffering argument is
     given, the default buffering policy works as follows:
 
-    * Binary files are buffered in fixed-size chunks; the size of the buffer
-      is chosen using a heuristic trying to determine the underlying device's
-      "block size" and falling back on `io.DEFAULT_BUFFER_SIZE`.
-      On many systems, the buffer will typically be 4096 or 8192 bytes long.
+   * Binary files are buffered in fixed-size chunks; the size of the buffer
+     is max(min(blocksize, 8 MiB), DEFAULT_BUFFER_SIZE)
+     when the device block size is available.
+     On most systems, the buffer will typically be 128 kilobytes long.
 
     * "Interactive" text files (files for which isatty() returns True)
       use line buffering.  Other text files use the policy described above
@@ -238,18 +239,11 @@ def open(file, mode="r", buffering=-1, encoding=None, errors=None,
     result = raw
     try:
         line_buffering = False
-        if buffering == 1 or buffering < 0 and raw.isatty():
+        if buffering == 1 or buffering < 0 and raw._isatty_open_only():
             buffering = -1
             line_buffering = True
         if buffering < 0:
-            buffering = DEFAULT_BUFFER_SIZE
-            try:
-                bs = os.fstat(raw.fileno()).st_blksize
-            except (OSError, AttributeError):
-                pass
-            else:
-                if bs > 1:
-                    buffering = bs
+            buffering = max(min(raw._blksize, 8192 * 1024), DEFAULT_BUFFER_SIZE)
         if buffering < 0:
             raise ValueError("invalid buffering size")
         if buffering == 0:
@@ -941,22 +935,22 @@ def read1(self, size=-1):
         return self.read(size)
 
     def write(self, b):
-        if self.closed:
-            raise ValueError("write to closed file")
         if isinstance(b, str):
             raise TypeError("can't write str to binary stream")
         with memoryview(b) as view:
+            if self.closed:
+                raise ValueError("write to closed file")
+
             n = view.nbytes  # Size of any bytes-like object
-        if n == 0:
-            return 0
-        pos = self._pos
-        if pos > len(self._buffer):
-            # Inserts null bytes between the current end of the file
-            # and the new write position.
-            padding = b'\x00' * (pos - len(self._buffer))
-            self._buffer += padding
-        self._buffer[pos:pos + n] = b
-        self._pos += n
+            if n == 0:
+                return 0
+
+            pos = self._pos
+            if pos > len(self._buffer):
+                # Pad buffer to pos with null bytes.
+                self._buffer.resize(pos)
+            self._buffer[pos:pos + n] = view
+            self._pos += n
         return n
 
     def seek(self, pos, whence=0):
@@ -1470,6 +1464,17 @@ def write(self, b):
         return BufferedWriter.write(self, b)
 
 
+def _new_buffersize(bytes_read):
+    # Parallels _io/fileio.c new_buffersize
+    if bytes_read > 65536:
+        addend = bytes_read >> 3
+    else:
+        addend = 256 + bytes_read
+    if addend < DEFAULT_BUFFER_SIZE:
+        addend = DEFAULT_BUFFER_SIZE
+    return bytes_read + addend
+
+
 class FileIO(RawIOBase):
     _fd = -1
     _created = False
@@ -1494,6 +1499,7 @@ def __init__(self, file, mode='r', closefd=True, opener=None):
         """
         if self._fd >= 0:
             # Have to close the existing file first.
+            self._stat_atopen = None
             try:
                 if self._closefd:
                     os.close(self._fd)
@@ -1573,18 +1579,15 @@ def __init__(self, file, mode='r', closefd=True, opener=None):
                     os.set_inheritable(fd, False)
 
             self._closefd = closefd
-            fdfstat = os.fstat(fd)
+            self._stat_atopen = os.fstat(fd)
             try:
-                if stat.S_ISDIR(fdfstat.st_mode):
+                if stat.S_ISDIR(self._stat_atopen.st_mode):
                     raise IsADirectoryError(errno.EISDIR,
                                             os.strerror(errno.EISDIR), file)
             except AttributeError:
                 # Ignore the AttributeError if stat.S_ISDIR or errno.EISDIR
                 # don't exist.
                 pass
-            self._blksize = getattr(fdfstat, 'st_blksize', 0)
-            if self._blksize <= 1:
-                self._blksize = DEFAULT_BUFFER_SIZE
 
             if _setmode:
                 # don't translate newlines (\r\n <=> \n)
@@ -1601,6 +1604,7 @@ def __init__(self, file, mode='r', closefd=True, opener=None):
                     if e.errno != errno.ESPIPE:
                         raise
         except:
+            self._stat_atopen = None
             if owned_fd is not None:
                 os.close(owned_fd)
             raise
@@ -1629,6 +1633,17 @@ def __repr__(self):
             return ('<%s name=%r mode=%r closefd=%r>' %
                     (class_name, name, self.mode, self._closefd))
 
+    @property
+    def _blksize(self):
+        if self._stat_atopen is None:
+            return DEFAULT_BUFFER_SIZE
+
+        blksize = getattr(self._stat_atopen, "st_blksize", 0)
+        # WASI sets blsize to 0
+        if not blksize:
+            return DEFAULT_BUFFER_SIZE
+        return blksize
+
     def _checkReadable(self):
         if not self._readable:
             raise UnsupportedOperation('File not open for reading')
@@ -1640,7 +1655,13 @@ def _checkWritable(self, msg=None):
     def read(self, size=None):
         """Read at most size bytes, returned as bytes.
 
-        Only makes one system call, so less data may be returned than requested
+        If size is less than 0, read all bytes in the file making
+        multiple read calls. See ``FileIO.readall``.
+
+        Attempts to make only one system call, retrying only per
+        PEP 475 (EINTR). This means less data may be returned than
+        requested.
+
         In non-blocking mode, returns None if no data is available.
         Return an empty bytes object at EOF.
         """
@@ -1656,45 +1677,57 @@ def read(self, size=None):
     def readall(self):
         """Read all data from the file, returned as bytes.
 
-        In non-blocking mode, returns as much as is immediately available,
-        or None if no data is available.  Return an empty bytes object at EOF.
+        Reads until either there is an error or read() returns size 0
+        (indicates EOF). If the file is already at EOF, returns an
+        empty bytes object.
+
+        In non-blocking mode, returns as much data as could be read
+        before EAGAIN. If no data is available (EAGAIN is returned
+        before bytes are read) returns None.
         """
         self._checkClosed()
         self._checkReadable()
-        bufsize = DEFAULT_BUFFER_SIZE
-        try:
-            pos = os.lseek(self._fd, 0, SEEK_CUR)
-            end = os.fstat(self._fd).st_size
-            if end >= pos:
-                bufsize = end - pos + 1
-        except OSError:
-            pass
+        if self._stat_atopen is None or self._stat_atopen.st_size <= 0:
+            bufsize = DEFAULT_BUFFER_SIZE
+        else:
+            # In order to detect end of file, need a read() of at least 1
+            # byte which returns size 0. Oversize the buffer by 1 byte so the
+            # I/O can be completed with two read() calls (one for all data, one
+            # for EOF) without needing to resize the buffer.
+            bufsize = self._stat_atopen.st_size + 1
 
-        result = bytearray()
-        while True:
-            if len(result) >= bufsize:
-                bufsize = len(result)
-                bufsize += max(bufsize, DEFAULT_BUFFER_SIZE)
-            n = bufsize - len(result)
-            try:
-                chunk = os.read(self._fd, n)
-            except BlockingIOError:
-                if result:
-                    break
+            if self._stat_atopen.st_size > 65536:
+                try:
+                    pos = os.lseek(self._fd, 0, SEEK_CUR)
+                    if self._stat_atopen.st_size >= pos:
+                        bufsize = self._stat_atopen.st_size - pos + 1
+                except OSError:
+                    pass
+
+        result = bytearray(bufsize)
+        bytes_read = 0
+        try:
+            while n := os.readinto(self._fd, memoryview(result)[bytes_read:]):
+                bytes_read += n
+                if bytes_read >= len(result):
+                    result.resize(_new_buffersize(bytes_read))
+        except BlockingIOError:
+            if not bytes_read:
                 return None
-            if not chunk: # reached the end of the file
-                break
-            result += chunk
 
+        assert len(result) - bytes_read >= 1, \
+            "os.readinto buffer size 0 will result in erroneous EOF / returns 0"
+        result.resize(bytes_read)
         return bytes(result)
 
-    def readinto(self, b):
+    def readinto(self, buffer):
         """Same as RawIOBase.readinto()."""
-        m = memoryview(b).cast('B')
-        data = self.read(len(m))
-        n = len(data)
-        m[:n] = data
-        return n
+        self._checkClosed()
+        self._checkReadable()
+        try:
+            return os.readinto(self._fd, buffer)
+        except BlockingIOError:
+            return None
 
     def write(self, b):
         """Write bytes b to file, return number written.
@@ -1744,6 +1777,7 @@ def truncate(self, size=None):
         if size is None:
             size = self.tell()
         os.ftruncate(self._fd, size)
+        self._stat_atopen = None
         return size
 
     def close(self):
@@ -1753,6 +1787,7 @@ def close(self):
         called more than once without error.
         """
         if not self.closed:
+            self._stat_atopen = None
             try:
                 if self._closefd and self._fd >= 0:
                     os.close(self._fd)
@@ -1791,6 +1826,21 @@ def isatty(self):
         self._checkClosed()
         return os.isatty(self._fd)
 
+    def _isatty_open_only(self):
+        """Checks whether the file is a TTY using an open-only optimization.
+
+        TTYs are always character devices. If the interpreter knows a file is
+        not a character device when it would call ``isatty``, can skip that
+        call. Inside ``open()``  there is a fresh stat result that contains that
+        information. Use the stat result to skip a system call. Outside of that
+        context TOCTOU issues (the fd could be arbitrarily modified by
+        surrounding code).
+        """
+        if (self._stat_atopen is not None
+            and not stat.S_ISCHR(self._stat_atopen.st_mode)):
+            return False
+        return os.isatty(self._fd)
+
     @property
     def closefd(self):
         """True if the file descriptor will be closed by close()."""
@@ -2015,8 +2065,7 @@ def __init__(self, buffer, encoding=None, errors=None, newline=None,
             raise ValueError("invalid encoding: %r" % encoding)
 
         if not codecs.lookup(encoding)._is_text_encoding:
-            msg = ("%r is not a text encoding; "
-                   "use codecs.open() to handle arbitrary codecs")
+            msg = "%r is not a text encoding"
             raise LookupError(msg % encoding)
 
         if errors is None:
@@ -2524,9 +2573,12 @@ def read(self, size=None):
                 size = size_index()
         decoder = self._decoder or self._get_decoder()
         if size < 0:
+            chunk = self.buffer.read()
+            if chunk is None:
+                raise BlockingIOError("Read returned None.")
             # Read everything.
             result = (self._get_decoded_chars() +
-                      decoder.decode(self.buffer.read(), final=True))
+                      decoder.decode(chunk, final=True))
             if self._snapshot is not None:
                 self._set_decoded_chars('')
                 self._snapshot = None
diff --git a/Lib/_pylong.py b/Lib/_pylong.py
index 4970eb3fa67..be1acd17ce3 100644
--- a/Lib/_pylong.py
+++ b/Lib/_pylong.py
@@ -45,10 +45,16 @@
 #
 # and `mycache[lo]` replaces `base**lo` in the inner function.
 #
-# While this does give minor speedups (a few percent at best), the primary
-# intent is to simplify the functions using this, by eliminating the need for
-# them to craft their own ad-hoc caching schemes.
-def compute_powers(w, base, more_than, show=False):
+# If an algorithm wants the powers of ceiling(w/2) instead of the floor,
+# pass keyword argument `need_hi=True`.
+#
+# While this does give minor speedups (a few percent at best), the
+# primary intent is to simplify the functions using this, by eliminating
+# the need for them to craft their own ad-hoc caching schemes.
+#
+# See code near end of file for a block of code that can be enabled to
+# run millions of tests.
+def compute_powers(w, base, more_than, *, need_hi=False, show=False):
     seen = set()
     need = set()
     ws = {w}
@@ -58,40 +64,70 @@ def compute_powers(w, base, more_than, show=False):
             continue
         seen.add(w)
         lo = w >> 1
-        # only _need_ lo here; some other path may, or may not, need hi
-        need.add(lo)
-        ws.add(lo)
-        if w & 1:
-            ws.add(lo + 1)
+        hi = w - lo
+        # only _need_ one here; the other may, or may not, be needed
+        which = hi if need_hi else lo
+        need.add(which)
+        ws.add(which)
+        if lo != hi:
+            ws.add(w - which)
+
+    # `need` is the set of exponents needed. To compute them all
+    # efficiently, possibly add other exponents to `extra`. The goal is
+    # to ensure that each exponent can be gotten from a smaller one via
+    # multiplying by the base, squaring it, or squaring and then
+    # multiplying by the base.
+    #
+    # If need_hi is False, this is already the case (w can always be
+    # gotten from w >> 1 via one of the squaring strategies). But we do
+    # the work anyway, just in case ;-)
+    #
+    # Note that speed is irrelevant. These loops are working on little
+    # ints (exponents) and go around O(log w) times. The total cost is
+    # insignificant compared to just one of the bigint multiplies.
+    cands = need.copy()
+    extra = set()
+    while cands:
+        w = max(cands)
+        cands.remove(w)
+        lo = w >> 1
+        if lo > more_than and w-1 not in cands and lo not in cands:
+            extra.add(lo)
+            cands.add(lo)
+    assert need_hi or not extra
 
     d = {}
-    if not need:
-        return d
-    it = iter(sorted(need))
-    first = next(it)
-    if show:
-        print("pow at", first)
-    d[first] = base ** first
-    for this in it:
-        if this - 1 in d:
+    for n in sorted(need | extra):
+        lo = n >> 1
+        hi = n - lo
+        if n-1 in d:
             if show:
-                print("* base at", this)
-            d[this] = d[this - 1] * base # cheap
-        else:
-            lo = this >> 1
-            hi = this - lo
-            assert lo in d
+                print("* base", end="")
+            result = d[n-1] * base # cheap!
+        elif lo in d:
+            # Multiplying a bigint by itself is about twice as fast
+            # in CPython provided it's the same object.
             if show:
-                print("square at", this)
-            # Multiplying a bigint by itself (same object!) is about twice
-            # as fast in CPython.
-            sq = d[lo] * d[lo]
+                print("square", end="")
+            result = d[lo] * d[lo] # same object
             if hi != lo:
-                assert hi == lo + 1
                 if show:
-                    print("    and * base")
-                sq *= base
-            d[this] = sq
+                    print(" * base", end="")
+                assert 2 * lo + 1 == n
+                result *= base
+        else: # rare
+            if show:
+                print("pow", end='')
+            result = base ** n
+        if show:
+            print(" at", n, "needed" if n in need else "extra")
+        d[n] = result
+
+    assert need <= d.keys()
+    if excess := d.keys() - need:
+        assert need_hi
+        for n in excess:
+            del d[n]
     return d
 
 _unbounded_dec_context = decimal.getcontext().copy()
@@ -211,6 +247,145 @@ def inner(a, b):
     return inner(0, len(s))
 
 
+# Asymptotically faster version, using the C decimal module. See
+# comments at the end of the file. This uses decimal arithmetic to
+# convert from base 10 to base 256. The latter is just a string of
+# bytes, which CPython can convert very efficiently to a Python int.
+
+# log of 10 to base 256 with best-possible 53-bit precision. Obtained
+# via:
+#    from mpmath import mp
+#    mp.prec = 1000
+#    print(float(mp.log(10, 256)).hex())
+_LOG_10_BASE_256 = float.fromhex('0x1.a934f0979a371p-2') # about 0.415
+
+# _spread is for internal testing. It maps a key to the number of times
+# that condition obtained in _dec_str_to_int_inner:
+#     key 0 - quotient guess was right
+#     key 1 - quotient had to be boosted by 1, one time
+#     key 999 - one adjustment wasn't enough, so fell back to divmod
+from collections import defaultdict
+_spread = defaultdict(int)
+del defaultdict
+
+def _dec_str_to_int_inner(s, *, GUARD=8):
+    # Yes, BYTELIM is "large". Large enough that CPython will usually
+    # use the Karatsuba _str_to_int_inner to convert the string. This
+    # allowed reducing the cutoff for calling _this_ function from 3.5M
+    # to 2M digits. We could almost certainly do even better by
+    # fine-tuning this and/or using a larger output base than 256.
+    BYTELIM = 100_000
+    D = decimal.Decimal
+    result = bytearray()
+    # See notes at end of file for discussion of GUARD.
+    assert GUARD > 0 # if 0, `decimal` can blow up - .prec 0 not allowed
+
+    def inner(n, w):
+        #assert n < D256 ** w # required, but too expensive to check
+        if w <= BYTELIM:
+            # XXX Stefan Pochmann discovered that, for 1024-bit ints,
+            # `int(Decimal)` took 2.5x longer than `int(str(Decimal))`.
+            # Worse, `int(Decimal) is still quadratic-time for much
+            # larger ints. So unless/until all that is repaired, the
+            # seemingly redundant `str(Decimal)` is crucial to speed.
+            result.extend(int(str(n)).to_bytes(w)) # big-endian default
+            return
+        w1 = w >> 1
+        w2 = w - w1
+        if 0:
+            # This is maximally clear, but "too slow". `decimal`
+            # division is asymptotically fast, but we have no way to
+            # tell it to reuse the high-precision reciprocal it computes
+            # for pow256[w2], so it has to recompute it over & over &
+            # over again :-(
+            hi, lo = divmod(n, pow256[w2][0])
+        else:
+            p256, recip = pow256[w2]
+            # The integer part will have a number of digits about equal
+            # to the difference between the log10s of `n` and `pow256`
+            # (which, since these are integers, is roughly approximated
+            # by `.adjusted()`). That's the working precision we need,
+            ctx.prec = max(n.adjusted() - p256.adjusted(), 0) + GUARD
+            hi = +n * +recip # unary `+` chops back to ctx.prec digits
+            ctx.prec = decimal.MAX_PREC
+            hi = hi.to_integral_value() # lose the fractional digits
+            lo = n - hi * p256
+            # Because we've been uniformly rounding down, `hi` is a
+            # lower bound on the correct quotient.
+            assert lo >= 0
+            # Adjust quotient up if needed. It usually isn't. In random
+            # testing on inputs through 5 billion digit strings, the
+            # test triggered once in about 200 thousand tries.
+            count = 0
+            if lo >= p256:
+                count = 1
+                lo -= p256
+                hi += 1
+                if lo >= p256:
+                    # Complete correction via an exact computation. I
+                    # believe it's not possible to get here provided
+                    # GUARD >= 3. It's tested by reducing GUARD below
+                    # that.
+                    count = 999
+                    hi2, lo = divmod(lo, p256)
+                    hi += hi2
+            _spread[count] += 1
+            # The assert should always succeed, but way too slow to keep
+            # enabled.
+            #assert hi, lo == divmod(n, pow256[w2][0])
+        inner(hi, w1)
+        del hi # at top levels, can free a lot of RAM "early"
+        inner(lo, w2)
+
+    # How many base 256 digits are needed?. Mathematically, exactly
+    # floor(log256(int(s))) + 1. There is no cheap way to compute this.
+    # But we can get an upper bound, and that's necessary for our error
+    # analysis to make sense. int(s) < 10**len(s), so the log needed is
+    # < log256(10**len(s)) = len(s) * log256(10). However, using
+    # finite-precision floating point for this, it's possible that the
+    # computed value is a little less than the true value. If the true
+    # value is at - or a little higher than - an integer, we can get an
+    # off-by-1 error too low. So we add 2 instead of 1 if chopping lost
+    # a fraction > 0.9.
+
+    # The "WASI" test platform can complain about `len(s)` if it's too
+    # large to fit in its idea of "an index-sized integer".
+    lenS = s.__len__()
+    log_ub = lenS * _LOG_10_BASE_256
+    log_ub_as_int = int(log_ub)
+    w = log_ub_as_int + 1 + (log_ub - log_ub_as_int > 0.9)
+    # And what if we've plain exhausted the limits of HW floats? We
+    # could compute the log to any desired precision using `decimal`,
+    # but it's not plausible that anyone will pass a string requiring
+    # trillions of bytes (unless they're just trying to "break things").
+    if w.bit_length() >= 46:
+        # "Only" had < 53 - 46 = 7 bits to spare in IEEE-754 double.
+        raise ValueError(f"cannot convert string of len {lenS} to int")
+    with decimal.localcontext(_unbounded_dec_context) as ctx:
+        D256 = D(256)
+        pow256 = compute_powers(w, D256, BYTELIM, need_hi=True)
+        rpow256 = compute_powers(w, 1 / D256, BYTELIM, need_hi=True)
+        # We're going to do inexact, chopped arithmetic, multiplying by
+        # an approximation to the reciprocal of 256**i. We chop to get a
+        # lower bound on the true integer quotient. Our approximation is
+        # a lower bound, the multiplication is chopped too, and
+        # to_integral_value() is also chopped.
+        ctx.traps[decimal.Inexact] = 0
+        ctx.rounding = decimal.ROUND_DOWN
+        for k, v in pow256.items():
+            # No need to save much more precision in the reciprocal than
+            # the power of 256 has, plus some guard digits to absorb
+            # most relevant rounding errors. This is highly significant:
+            # 1/2**i has the same number of significant decimal digits
+            # as 5**i, generally over twice the number in 2**i,
+            ctx.prec = v.adjusted() + GUARD + 1
+            # The unary "+" chops the reciprocal back to that precision.
+            pow256[k] = v, +rpow256[k]
+        del rpow256 # exact reciprocals no longer needed
+        ctx.prec = decimal.MAX_PREC
+        inner(D(s), w)
+    return int.from_bytes(result)
+
 def int_from_string(s):
     """Asymptotically fast version of PyLong_FromString(), conversion
     of a string of decimal digits into an 'int'."""
@@ -219,7 +394,10 @@ def int_from_string(s):
     # and underscores, and stripped leading whitespace.  The input can still
     # contain underscores and have trailing whitespace.
     s = s.rstrip().replace('_', '')
-    return _str_to_int_inner(s)
+    func = _str_to_int_inner
+    if len(s) >= 2_000_000 and _decimal is not None:
+        func = _dec_str_to_int_inner
+    return func(s)
 
 def str_to_int(s):
     """Asymptotically fast version of decimal string to 'int' conversion."""
@@ -352,7 +530,7 @@ def int_divmod(a, b):
     Its time complexity is O(n**1.58), where n = #bits(a) + #bits(b).
     """
     if b == 0:
-        raise ZeroDivisionError
+        raise ZeroDivisionError('division by zero')
     elif b < 0:
         q, r = int_divmod(-a, -b)
         return q, -r
@@ -361,3 +539,191 @@ def int_divmod(a, b):
         return ~q, b + ~r
     else:
         return _divmod_pos(a, b)
+
+
+# Notes on _dec_str_to_int_inner:
+#
+# Stefan Pochmann worked up a str->int function that used the decimal
+# module to, in effect, convert from base 10 to base 256. This is
+# "unnatural", in that it requires multiplying and dividing by large
+# powers of 2, which `decimal` isn't naturally suited to. But
+# `decimal`'s `*` and `/` are asymptotically superior to CPython's, so
+# at _some_ point it could be expected to win.
+#
+# Alas, the crossover point was too high to be of much real interest. I
+# (Tim) then worked on ways to replace its division with multiplication
+# by a cached reciprocal approximation instead, fixing up errors
+# afterwards. This reduced the crossover point significantly,
+#
+# I revisited the code, and found ways to improve and simplify it. The
+# crossover point is at about 3.4 million digits now.
+#
+# About .adjusted()
+# -----------------
+# Restrict to Decimal values x > 0. We don't use negative numbers in the
+# code, and I don't want to have to keep typing, e.g., "absolute value".
+#
+# For convenience, I'll use `x.a` to mean `x.adjusted()`. x.a doesn't
+# look at the digits of x, but instead returns an integer giving x's
+# order of magnitude. These are equivalent:
+#
+# - x.a is the power-of-10 exponent of x's most significant digit.
+# - x.a = the infinitely precise floor(log10(x))
+# - x can be written in this form, where f is a real with 1 <= f < 10:
+#    x = f * 10**x.a
+#
+# Observation; if x is an integer, len(str(x)) = x.a + 1.
+#
+# Lemma 1: (x * y).a = x.a + y.a, or one larger
+#
+# Proof: Write x = f * 10**x.a and y = g * 10**y.a, where f and g are in
+# [1, 10). Then x*y = f*g * 10**(x.a + y.a), where 1 <= f*g < 100. If
+# f*g < 10, (x*y).a is x.a+y.a. Else divide f*g by 10 to bring it back
+# into [1, 10], and add 1 to the exponent to compensate. Then (x*y).a is
+# x.a+y.a+1.
+#
+# Lemma 2: ceiling(log10(x/y)) <= x.a - y.a + 1
+#
+# Proof: Express x and y as in Lemma 1. Then x/y = f/g * 10**(x.a -
+# y.a), where 1/10 < f/g < 10. If 1 <= f/g, (x/y).a is x.a-y.a. Else
+# multiply f/g by 10 to bring it back into [1, 10], and subtract 1 from
+# the exponent to compensate. Then (x/y).a is x.a-y.a-1. So the largest
+# (x/y).a can be is x.a-y.a. Since that's the floor of log10(x/y). the
+# ceiling is at most 1 larger (with equality iff f/g = 1 exactly).
+#
+# GUARD digits
+# ------------
+# We only want the integer part of divisions, so don't need to build
+# the full multiplication tree. But using _just_ the number of
+# digits expected in the integer part ignores too much. What's left
+# out can have a very significant effect on the quotient. So we use
+# GUARD additional digits.
+#
+# The default 8 is more than enough so no more than 1 correction step
+# was ever needed for all inputs tried through 2.5 billion digits. In
+# fact, I believe 3 guard digits are always enough - but the proof is
+# very involved, so better safe than sorry.
+#
+# Short course:
+#
+# If prec is the decimal precision in effect, and we're rounding down,
+# the result of an operation is exactly equal to the infinitely precise
+# result times 1-e for some real e with 0 <= e < 10**(1-prec). In
+#
+#     ctx.prec = max(n.adjusted() - p256.adjusted(), 0) + GUARD
+#     hi = +n * +recip # unary `+` chops to ctx.prec digits
+#
+# we have 3 visible chopped operations, but there's also a 4th:
+# precomputing a truncated `recip` as part of setup.
+#
+# So the computed product is exactly equal to the true product times
+# (1-e1)*(1-e2)*(1-e3)*(1-e4); since the e's are all very small, an
+# excellent approximation to the second factor is 1-(e1+e2+e3+e4) (the
+# 2nd and higher order terms in the expanded product are too tiny to
+# matter). If they're all as large as possible, that's
+#
+# 1 - 4*10**(1-prec). This, BTW, is all bog-standard FP error analysis.
+#
+# That implies the computed product is within 1 of the true product
+# provided prec >= log10(true_product) + 1.602.
+#
+# Here are telegraphic details, rephrasing the initial condition in
+# equivalent ways, step by step:
+#
+# prod - prod * (1 - 4*10**(1-prec)) <= 1
+# prod - prod + prod * 4*10**(1-prec)) <= 1
+# prod * 4*10**(1-prec)) <= 1
+# 10**(log10(prod)) * 4*10**(1-prec)) <= 1
+# 4*10**(1-prec+log10(prod))) <= 1
+# 10**(1-prec+log10(prod))) <= 1/4
+# 1-prec+log10(prod) <= log10(1/4) = -0.602
+# -prec <= -1.602 - log10(prod)
+# prec >= log10(prod) + 1.602
+#
+# The true product is the same as the true ratio n/p256. By Lemma 2
+# above, n.a - p256.a + 1 is an upper bound on the ceiling of
+# log10(prod). Then 2 is the ceiling of 1.602. so n.a - p256.a + 3 is an
+# upper bound on the right hand side of the inequality. Any prec >= that
+# will work.
+#
+# But since this is just a sketch of a proof ;-), the code uses the
+# empirically tested 8 instead of 3. 5 digits more or less makes no
+# practical difference to speed - these ints are huge. And while
+# increasing GUARD above 3 may not be necessary, every increase cuts the
+# percentage of cases that need a correction at all.
+#
+# On Computing Reciprocals
+# ------------------------
+# In general, the exact reciprocals we compute have over twice as many
+# significant digits as needed. 1/256**i has the same number of
+# significant decimal digits as 5**i. It's a significant waste of RAM
+# to store all those unneeded digits.
+#
+# So we cut exact reciprocals back to the least precision that can
+# be needed so that the error analysis above is valid,
+#
+# [Note: turns out it's very significantly faster to do it this way than
+# to compute  1 / 256**i  directly to the desired precision, because the
+# power method doesn't require division. It's also faster than computing
+# (1/256)**i directly to the desired precision - no material division
+# there, but `compute_powers()` is much smarter about _how_ to compute
+# all the powers needed than repeated applications of `**` - that
+# function invokes `**` for at most the few smallest powers needed.]
+#
+# The hard part is that chopping back to a shorter width occurs
+# _outside_ of `inner`. We can't know then what `prec` `inner()` will
+# need. We have to pick, for each value of `w2`, the largest possible
+# value `prec` can become when `inner()` is working on `w2`.
+#
+# This is the `prec` inner() uses:
+#     max(n.a - p256.a, 0) + GUARD
+# and what setup uses (renaming its `v` to `p256` - same thing):
+#     p256.a + GUARD + 1
+#
+# We need that the second is always at least as large as the first,
+# which is the same as requiring
+#
+#     n.a - 2 * p256.a <= 1
+#
+# What's the largest n can be? n < 255**w = 256**(w2 + (w - w2)). The
+# worst case in this context is when w ix even. and then w = 2*w2, so
+# n < 256**(2*w2) = (256**w2)**2 = p256**2. By Lemma 1, then, n.a
+# is at most p256.a + p256.a + 1.
+#
+# So the most n.a - 2 * p256.a can be is
+# p256.a + p256.a + 1 - 2 * p256.a = 1. QED
+#
+# Note: an earlier version of the code split on floor(e/2) instead of on
+# the ceiling. The worst case then is odd `w`, and a more involved proof
+# was needed to show that adding 4 (instead of 1) may be necessary.
+# Basically because, in that case, n may be up to 256 times larger than
+# p256**2. Curiously enough, by splitting on the ceiling instead,
+# nothing in any proof here actually depends on the output base (256).
+
+# Enable for brute-force testing of compute_powers(). This takes about a
+# minute, because it tries millions of cases.
+if 0:
+    def consumer(w, limit, need_hi):
+        seen = set()
+        need = set()
+        def inner(w):
+            if w <= limit:
+                return
+            if w in seen:
+                return
+            seen.add(w)
+            lo = w >> 1
+            hi = w - lo
+            need.add(hi if need_hi else lo)
+            inner(lo)
+            inner(hi)
+        inner(w)
+        exp = compute_powers(w, 1, limit, need_hi=need_hi)
+        assert exp.keys() == need
+
+    from itertools import chain
+    for need_hi in (False, True):
+        for limit in (0, 1, 10, 100, 1_000, 10_000, 100_000):
+            for w in chain(range(1, 100_000),
+                           (10**i for i in range(5, 30))):
+                consumer(w, limit, need_hi)
diff --git a/Lib/_strptime.py b/Lib/_strptime.py
index a07eb5f9230..fc7e369c3d1 100644
--- a/Lib/_strptime.py
+++ b/Lib/_strptime.py
@@ -472,7 +472,7 @@ def repl(m):
         if day_of_month_in_format and not year_in_format:
             import warnings
             warnings.warn("""\
-Parsing dates involving a day of month without a year specified is ambiguious
+Parsing dates involving a day of month without a year specified is ambiguous
 and fails to parse leap day. The default behavior will change in Python 3.15
 to either always raise an exception or to use a different default year (TBD).
 To avoid trouble, add a specific year to the input & format.
@@ -783,18 +783,40 @@ def _strptime_time(data_string, format="%a %b %d %H:%M:%S %Y"):
     tt = _strptime(data_string, format)[0]
     return time.struct_time(tt[:time._STRUCT_TM_ITEMS])
 
-def _strptime_datetime(cls, data_string, format="%a %b %d %H:%M:%S %Y"):
-    """Return a class cls instance based on the input string and the
+def _strptime_datetime_date(cls, data_string, format="%a %b %d %Y"):
+    """Return a date instance based on the input string and the
+    format string."""
+    tt, _, _ = _strptime(data_string, format)
+    args = tt[:3]
+    return cls(*args)
+
+def _parse_tz(tzname, gmtoff, gmtoff_fraction):
+    tzdelta = datetime_timedelta(seconds=gmtoff, microseconds=gmtoff_fraction)
+    if tzname:
+        return datetime_timezone(tzdelta, tzname)
+    else:
+        return datetime_timezone(tzdelta)
+
+def _strptime_datetime_time(cls, data_string, format="%H:%M:%S"):
+    """Return a time instance based on the input string and the
     format string."""
     tt, fraction, gmtoff_fraction = _strptime(data_string, format)
     tzname, gmtoff = tt[-2:]
-    args = tt[:6] + (fraction,)
-    if gmtoff is not None:
-        tzdelta = datetime_timedelta(seconds=gmtoff, microseconds=gmtoff_fraction)
-        if tzname:
-            tz = datetime_timezone(tzdelta, tzname)
-        else:
-            tz = datetime_timezone(tzdelta)
-        args += (tz,)
+    args = tt[3:6] + (fraction,)
+    if gmtoff is None:
+        return cls(*args)
+    else:
+        tz = _parse_tz(tzname, gmtoff, gmtoff_fraction)
+        return cls(*args, tz)
 
-    return cls(*args)
+def _strptime_datetime_datetime(cls, data_string, format="%a %b %d %H:%M:%S %Y"):
+    """Return a datetime instance based on the input string and the
+    format string."""
+    tt, fraction, gmtoff_fraction = _strptime(data_string, format)
+    tzname, gmtoff = tt[-2:]
+    args = tt[:6] + (fraction,)
+    if gmtoff is None:
+        return cls(*args)
+    else:
+        tz = _parse_tz(tzname, gmtoff, gmtoff_fraction)
+        return cls(*args, tz)
diff --git a/Lib/_weakrefset.py b/Lib/_weakrefset.py
index 489eec714e0..d1c7fcaeec9 100644
--- a/Lib/_weakrefset.py
+++ b/Lib/_weakrefset.py
@@ -8,69 +8,29 @@
 __all__ = ['WeakSet']
 
 
-class _IterationGuard:
-    # This context manager registers itself in the current iterators of the
-    # weak container, such as to delay all removals until the context manager
-    # exits.
-    # This technique should be relatively thread-safe (since sets are).
-
-    def __init__(self, weakcontainer):
-        # Don't create cycles
-        self.weakcontainer = ref(weakcontainer)
-
-    def __enter__(self):
-        w = self.weakcontainer()
-        if w is not None:
-            w._iterating.add(self)
-        return self
-
-    def __exit__(self, e, t, b):
-        w = self.weakcontainer()
-        if w is not None:
-            s = w._iterating
-            s.remove(self)
-            if not s:
-                w._commit_removals()
-
-
 class WeakSet:
     def __init__(self, data=None):
         self.data = set()
+
         def _remove(item, selfref=ref(self)):
             self = selfref()
             if self is not None:
-                if self._iterating:
-                    self._pending_removals.append(item)
-                else:
-                    self.data.discard(item)
+                self.data.discard(item)
+
         self._remove = _remove
-        # A list of keys to be removed
-        self._pending_removals = []
-        self._iterating = set()
         if data is not None:
             self.update(data)
 
-    def _commit_removals(self):
-        pop = self._pending_removals.pop
-        discard = self.data.discard
-        while True:
-            try:
-                item = pop()
-            except IndexError:
-                return
-            discard(item)
-
     def __iter__(self):
-        with _IterationGuard(self):
-            for itemref in self.data:
-                item = itemref()
-                if item is not None:
-                    # Caveat: the iterator will keep a strong reference to
-                    # `item` until it is resumed or closed.
-                    yield item
+        for itemref in self.data.copy():
+            item = itemref()
+            if item is not None:
+                # Caveat: the iterator will keep a strong reference to
+                # `item` until it is resumed or closed.
+                yield item
 
     def __len__(self):
-        return len(self.data) - len(self._pending_removals)
+        return len(self.data)
 
     def __contains__(self, item):
         try:
@@ -83,21 +43,15 @@ def __reduce__(self):
         return self.__class__, (list(self),), self.__getstate__()
 
     def add(self, item):
-        if self._pending_removals:
-            self._commit_removals()
         self.data.add(ref(item, self._remove))
 
     def clear(self):
-        if self._pending_removals:
-            self._commit_removals()
         self.data.clear()
 
     def copy(self):
         return self.__class__(self)
 
     def pop(self):
-        if self._pending_removals:
-            self._commit_removals()
         while True:
             try:
                 itemref = self.data.pop()
@@ -108,18 +62,12 @@ def pop(self):
                 return item
 
     def remove(self, item):
-        if self._pending_removals:
-            self._commit_removals()
         self.data.remove(ref(item))
 
     def discard(self, item):
-        if self._pending_removals:
-            self._commit_removals()
         self.data.discard(ref(item))
 
     def update(self, other):
-        if self._pending_removals:
-            self._commit_removals()
         for element in other:
             self.add(element)
 
@@ -136,8 +84,6 @@ def difference(self, other):
     def difference_update(self, other):
         self.__isub__(other)
     def __isub__(self, other):
-        if self._pending_removals:
-            self._commit_removals()
         if self is other:
             self.data.clear()
         else:
@@ -151,8 +97,6 @@ def intersection(self, other):
     def intersection_update(self, other):
         self.__iand__(other)
     def __iand__(self, other):
-        if self._pending_removals:
-            self._commit_removals()
         self.data.intersection_update(ref(item) for item in other)
         return self
 
@@ -184,8 +128,6 @@ def symmetric_difference(self, other):
     def symmetric_difference_update(self, other):
         self.__ixor__(other)
     def __ixor__(self, other):
-        if self._pending_removals:
-            self._commit_removals()
         if self is other:
             self.data.clear()
         else:
diff --git a/Lib/annotationlib.py b/Lib/annotationlib.py
index a5788cdbfae..832d160de7f 100644
--- a/Lib/annotationlib.py
+++ b/Lib/annotationlib.py
@@ -279,7 +279,13 @@ def __eq__(self, other):
             # 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__
+            # Two separate cells are always considered unequal in forward refs.
+            and (
+                {name: id(cell) for name, cell in self.__cell__.items()}
+                == {name: id(cell) for name, cell in other.__cell__.items()}
+                if isinstance(self.__cell__, dict) and isinstance(other.__cell__, dict)
+                else self.__cell__ is other.__cell__
+            )
             and self.__owner__ == other.__owner__
             and (
                 (tuple(sorted(self.__extra_names__.items())) if self.__extra_names__ else None) ==
@@ -293,7 +299,10 @@ def __hash__(self):
             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__,
+            (  # cells are not hashable as well
+                tuple(sorted([(name, id(cell)) for name, cell in self.__cell__.items()]))
+                if isinstance(self.__cell__, dict) else id(self.__cell__),
+            ),
             self.__owner__,
             tuple(sorted(self.__extra_names__.items())) if self.__extra_names__ else None,
         ))
@@ -1096,7 +1105,7 @@ 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("*"):
+    if arg.lstrip().startswith("*"):
         return f"({arg},)[0]"  # E.g. (*Ts,)[0] or (*tuple[int, int],)[0]
     else:
         return arg
diff --git a/Lib/argparse.py b/Lib/argparse.py
index 88c1f5a7ef3..1d7d34f9924 100644
--- a/Lib/argparse.py
+++ b/Lib/argparse.py
@@ -337,27 +337,17 @@ def _format_usage(self, usage, actions, groups, prefix):
         elif usage is None:
             prog = '%(prog)s' % dict(prog=self._prog)
 
-            # split optionals from positionals
-            optionals = []
-            positionals = []
-            for action in actions:
-                if action.option_strings:
-                    optionals.append(action)
-                else:
-                    positionals.append(action)
-
+            parts, pos_start = self._get_actions_usage_parts(actions, groups)
             # build full usage string
-            format = self._format_actions_usage
-            action_usage = format(optionals + positionals, groups)
-            usage = ' '.join([s for s in [prog, action_usage] if s])
+            usage = ' '.join(filter(None, [prog, *parts]))
 
             # wrap the usage parts if it's too long
             text_width = self._width - self._current_indent
             if len(prefix) + len(self._decolor(usage)) > text_width:
 
                 # break usage into wrappable parts
-                opt_parts = self._get_actions_usage_parts(optionals, groups)
-                pos_parts = self._get_actions_usage_parts(positionals, groups)
+                opt_parts = parts[:pos_start]
+                pos_parts = parts[pos_start:]
 
                 # helper for wrapping lines
                 def get_lines(parts, indent, prefix=None):
@@ -414,110 +404,114 @@ def get_lines(parts, indent, prefix=None):
         # prefix with '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()
-        inserts = {}
-        for group in groups:
-            if not group._group_actions:
-                raise ValueError(f'empty group {group}')
+        """Get usage parts with split index for optionals/positionals.
 
-            if all(action.help is SUPPRESS for action in group._group_actions):
-                continue
-
-            try:
-                start = min(actions.index(item) for item in group._group_actions)
-            except ValueError:
-                continue
-            else:
-                end = start + len(group._group_actions)
-                if set(actions[start:end]) == set(group._group_actions):
-                    group_actions.update(group._group_actions)
-                    inserts[start, end] = group
+        Returns (parts, pos_start) where pos_start is the index in parts
+        where positionals begin.
+        This preserves mutually exclusive group formatting across the
+        optionals/positionals boundary (gh-75949).
+        """
+        actions = [action for action in actions if action.help is not SUPPRESS]
+        # group actions by mutually exclusive groups
+        action_groups = dict.fromkeys(actions)
+        for group in groups:
+            for action in group._group_actions:
+                if action in action_groups:
+                    action_groups[action] = group
+        # positional arguments keep their position
+        positionals = []
+        for action in actions:
+            if not action.option_strings:
+                group = action_groups.pop(action)
+                if group:
+                    group_actions = [
+                        action2 for action2 in group._group_actions
+                        if action2.option_strings and
+                           action_groups.pop(action2, None)
+                    ] + [action]
+                    positionals.append((group.required, group_actions))
+                else:
+                    positionals.append((None, [action]))
+        # the remaining optional arguments are sorted by the position of
+        # the first option in the group
+        optionals = []
+        for action in actions:
+            if action.option_strings and action in action_groups:
+                group = action_groups.pop(action)
+                if group:
+                    group_actions = [action] + [
+                        action2 for action2 in group._group_actions
+                        if action2.option_strings and
+                           action_groups.pop(action2, None)
+                    ]
+                    optionals.append((group.required, group_actions))
+                else:
+                    optionals.append((None, [action]))
 
         # collect all actions format strings
         parts = []
         t = self._theme
-        for action in actions:
-
-            # suppressed arguments are marked with None
-            if action.help is SUPPRESS:
-                part = None
-
-            # produce all arg strings
-            elif not action.option_strings:
-                default = self._get_default_metavar_for_positional(action)
-                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:
-                    if part[0] == '[' and part[-1] == ']':
-                        part = part[1:-1]
-
-            # 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
+        pos_start = None
+        for i, (required, group) in enumerate(optionals + positionals):
+            start = len(parts)
+            if i == len(optionals):
+                pos_start = start
+            in_group = len(group) > 1
+            for action in group:
+                # produce all arg strings
+                if not action.option_strings:
+                    default = self._get_default_metavar_for_positional(action)
+                    part = self._format_args(action, default)
+                    # if it's in a group, strip the outer []
+                    if in_group:
+                        if part[0] == '[' and part[-1] == ']':
+                            part = part[1:-1]
+                    part = t.summary_action + part + t.reset
+
+                # produce the first way to invoke the option in brackets
                 else:
-                    option_color = t.summary_short_option
+                    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 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 = (
-                        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:
-                    part = '[%s]' % part
-
-            # add the action string to the list
-            parts.append(part)
-
-        # group mutually exclusive actions
-        inserted_separators_indices = set()
-        for start, end in sorted(inserts, reverse=True):
-            group = inserts[start, end]
-            group_parts = [item for item in parts[start:end] if item is not None]
-            group_size = len(group_parts)
-            if group.required:
-                open, close = "()" if group_size > 1 else ("", "")
-            else:
-                open, close = "[]"
-            group_parts[0] = open + group_parts[0]
-            group_parts[-1] = group_parts[-1] + close
-            for i, part in enumerate(group_parts[:-1], start=start):
-                # insert a separator if not already done in a nested group
-                if i not in inserted_separators_indices:
-                    parts[i] = part + ' |'
-                    inserted_separators_indices.add(i)
-            parts[start + group_size - 1] = group_parts[-1]
-            for i in range(start + group_size, end):
-                parts[i] = None
-
-        # return the usage parts
-        return [item for item in parts if item is not None]
+                    # 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 = (
+                            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 or required or in_group):
+                        part = '[%s]' % part
+
+                # add the action string to the list
+                parts.append(part)
+
+            if in_group:
+                parts[start] = ('(' if required else '[') + parts[start]
+                for i in range(start, len(parts) - 1):
+                    parts[i] += ' |'
+                parts[-1] += ')' if required else ']'
+
+        if pos_start is None:
+            pos_start = len(parts)
+        return parts, pos_start
 
     def _format_text(self, text):
         if '%(prog)' in text:
@@ -745,11 +739,14 @@ def _get_help_string(self, action):
         if help is None:
             help = ''
 
-        if '%(default)' not in help:
-            if action.default is not SUPPRESS:
-                defaulting_nargs = [OPTIONAL, ZERO_OR_MORE]
-                if action.option_strings or action.nargs in defaulting_nargs:
-                    help += _(' (default: %(default)s)')
+        if (
+            '%(default)' not in help
+            and action.default is not SUPPRESS
+            and not action.required
+        ):
+            defaulting_nargs = (OPTIONAL, ZERO_OR_MORE)
+            if action.option_strings or action.nargs in defaulting_nargs:
+                help += _(' (default: %(default)s)')
         return help
 
 
@@ -1552,8 +1549,8 @@ def add_argument(self, *args, **kwargs):
                             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()
+        if hasattr(self, "_get_validation_formatter"):
+            formatter = self._get_validation_formatter()
             try:
                 formatter._format_args(action, None)
             except TypeError:
@@ -1741,8 +1738,8 @@ def _handle_conflict_resolve(self, action, conflicting_actions):
                 action.container._remove_action(action)
 
     def _check_help(self, action):
-        if action.help and hasattr(self, "_get_formatter"):
-            formatter = self._get_formatter()
+        if action.help and hasattr(self, "_get_validation_formatter"):
+            formatter = self._get_validation_formatter()
             try:
                 formatter._expand_help(action)
             except (ValueError, TypeError, KeyError) as exc:
@@ -1897,6 +1894,9 @@ def __init__(self,
         self.suggest_on_error = suggest_on_error
         self.color = color
 
+        # Cached formatter for validation (avoids repeated _set_color calls)
+        self._cached_formatter = None
+
         add_group = self.add_argument_group
         self._positionals = add_group(_('positional arguments'))
         self._optionals = add_group(_('options'))
@@ -2728,6 +2728,13 @@ def _get_formatter(self):
         formatter._set_color(self.color)
         return formatter
 
+    def _get_validation_formatter(self):
+        # Return cached formatter for read-only validation operations
+        # (_expand_help and _format_args). Avoids repeated slow _set_color calls.
+        if self._cached_formatter is None:
+            self._cached_formatter = self._get_formatter()
+        return self._cached_formatter
+
     # =====================
     # Help-printing methods
     # =====================
diff --git a/Lib/ast.py b/Lib/ast.py
index 37b20206b8a..2f11683ecf7 100644
--- a/Lib/ast.py
+++ b/Lib/ast.py
@@ -20,11 +20,7 @@
 :copyright: Copyright 2008 by Armin Ronacher.
 :license: Python License.
 """
-import sys
-import re
 from _ast import *
-from contextlib import contextmanager, nullcontext
-from enum import IntEnum, auto, _simple_enum
 
 
 def parse(source, filename='<unknown>', mode='exec', *,
@@ -319,12 +315,18 @@ def get_docstring(node, clean=True):
     return text
 
 
-_line_pattern = re.compile(r"(.*?(?:\r\n|\n|\r|$))")
+_line_pattern = None
 def _splitlines_no_ff(source, maxlines=None):
     """Split a string into lines ignoring form feed and other chars.
 
     This mimics how the Python parser splits source code.
     """
+    global _line_pattern
+    if _line_pattern is None:
+        # lazily computed to speedup import time of `ast`
+        import re
+        _line_pattern = re.compile(r"(.*?(?:\r\n|\n|\r|$))")
+
     lines = []
     for lineno, match in enumerate(_line_pattern.finditer(source), 1):
         if maxlines is not None and lineno > maxlines:
@@ -395,6 +397,88 @@ def walk(node):
         yield node
 
 
+def compare(
+    a,
+    b,
+    /,
+    *,
+    compare_attributes=False,
+):
+    """Recursively compares two ASTs.
+
+    compare_attributes affects whether AST attributes are considered
+    in the comparison. If compare_attributes is False (default), then
+    attributes are ignored. Otherwise they must all be equal. This
+    option is useful to check whether the ASTs are structurally equal but
+    might differ in whitespace or similar details.
+    """
+
+    sentinel = object()  # handle the possibility of a missing attribute/field
+
+    def _compare(a, b):
+        # Compare two fields on an AST object, which may themselves be
+        # AST objects, lists of AST objects, or primitive ASDL types
+        # like identifiers and constants.
+        if isinstance(a, AST):
+            return compare(
+                a,
+                b,
+                compare_attributes=compare_attributes,
+            )
+        elif isinstance(a, list):
+            # If a field is repeated, then both objects will represent
+            # the value as a list.
+            if len(a) != len(b):
+                return False
+            for a_item, b_item in zip(a, b):
+                if not _compare(a_item, b_item):
+                    return False
+            else:
+                return True
+        else:
+            return type(a) is type(b) and a == b
+
+    def _compare_fields(a, b):
+        if a._fields != b._fields:
+            return False
+        for field in a._fields:
+            a_field = getattr(a, field, sentinel)
+            b_field = getattr(b, field, sentinel)
+            if a_field is sentinel and b_field is sentinel:
+                # both nodes are missing a field at runtime
+                continue
+            if a_field is sentinel or b_field is sentinel:
+                # one of the node is missing a field
+                return False
+            if not _compare(a_field, b_field):
+                return False
+        else:
+            return True
+
+    def _compare_attributes(a, b):
+        if a._attributes != b._attributes:
+            return False
+        # Attributes are always ints.
+        for attr in a._attributes:
+            a_attr = getattr(a, attr, sentinel)
+            b_attr = getattr(b, attr, sentinel)
+            if a_attr is sentinel and b_attr is sentinel:
+                # both nodes are missing an attribute at runtime
+                continue
+            if a_attr != b_attr:
+                return False
+        else:
+            return True
+
+    if type(a) is not type(b):
+        return False
+    if not _compare_fields(a, b):
+        return False
+    if compare_attributes and not _compare_attributes(a, b):
+        return False
+    return True
+
+
 class NodeVisitor(object):
     """
     A node visitor base class that walks the abstract syntax tree and calls a
@@ -431,27 +515,6 @@ def generic_visit(self, node):
             elif isinstance(value, AST):
                 self.visit(value)
 
-    def visit_Constant(self, node):
-        value = node.value
-        type_name = _const_node_type_names.get(type(value))
-        if type_name is None:
-            for cls, name in _const_node_type_names.items():
-                if isinstance(value, cls):
-                    type_name = name
-                    break
-        if type_name is not None:
-            method = 'visit_' + type_name
-            try:
-                visitor = getattr(self, method)
-            except AttributeError:
-                pass
-            else:
-                import warnings
-                warnings.warn(f"{method} is deprecated; add visit_Constant",
-                              DeprecationWarning, 2)
-                return visitor(node)
-        return self.generic_visit(node)
-
 
 class NodeTransformer(NodeVisitor):
     """
@@ -511,151 +574,6 @@ def generic_visit(self, node):
                     setattr(node, field, new_node)
         return node
 
-
-_DEPRECATED_VALUE_ALIAS_MESSAGE = (
-    "{name} is deprecated and will be removed in Python {remove}; use value instead"
-)
-_DEPRECATED_CLASS_MESSAGE = (
-    "{name} is deprecated and will be removed in Python {remove}; "
-    "use ast.Constant instead"
-)
-
-
-# If the ast module is loaded more than once, only add deprecated methods once
-if not hasattr(Constant, 'n'):
-    # The following code is for backward compatibility.
-    # It will be removed in future.
-
-    def _n_getter(self):
-        """Deprecated. Use value instead."""
-        import warnings
-        warnings._deprecated(
-            "Attribute n", message=_DEPRECATED_VALUE_ALIAS_MESSAGE, remove=(3, 14)
-        )
-        return self.value
-
-    def _n_setter(self, value):
-        import warnings
-        warnings._deprecated(
-            "Attribute n", message=_DEPRECATED_VALUE_ALIAS_MESSAGE, remove=(3, 14)
-        )
-        self.value = value
-
-    def _s_getter(self):
-        """Deprecated. Use value instead."""
-        import warnings
-        warnings._deprecated(
-            "Attribute s", message=_DEPRECATED_VALUE_ALIAS_MESSAGE, remove=(3, 14)
-        )
-        return self.value
-
-    def _s_setter(self, value):
-        import warnings
-        warnings._deprecated(
-            "Attribute s", message=_DEPRECATED_VALUE_ALIAS_MESSAGE, remove=(3, 14)
-        )
-        self.value = value
-
-    Constant.n = property(_n_getter, _n_setter)
-    Constant.s = property(_s_getter, _s_setter)
-
-class _ABC(type):
-
-    def __init__(cls, *args):
-        cls.__doc__ = """Deprecated AST node class. Use ast.Constant instead"""
-
-    def __instancecheck__(cls, inst):
-        if cls in _const_types:
-            import warnings
-            warnings._deprecated(
-                f"ast.{cls.__qualname__}",
-                message=_DEPRECATED_CLASS_MESSAGE,
-                remove=(3, 14)
-            )
-        if not isinstance(inst, Constant):
-            return False
-        if cls in _const_types:
-            try:
-                value = inst.value
-            except AttributeError:
-                return False
-            else:
-                return (
-                    isinstance(value, _const_types[cls]) and
-                    not isinstance(value, _const_types_not.get(cls, ()))
-                )
-        return type.__instancecheck__(cls, inst)
-
-def _new(cls, *args, **kwargs):
-    for key in kwargs:
-        if key not in cls._fields:
-            # arbitrary keyword arguments are accepted
-            continue
-        pos = cls._fields.index(key)
-        if pos < len(args):
-            raise TypeError(f"{cls.__name__} got multiple values for argument {key!r}")
-    if cls in _const_types:
-        import warnings
-        warnings._deprecated(
-            f"ast.{cls.__qualname__}", message=_DEPRECATED_CLASS_MESSAGE, remove=(3, 14)
-        )
-        return Constant(*args, **kwargs)
-    return Constant.__new__(cls, *args, **kwargs)
-
-class Num(Constant, metaclass=_ABC):
-    _fields = ('n',)
-    __new__ = _new
-
-class Str(Constant, metaclass=_ABC):
-    _fields = ('s',)
-    __new__ = _new
-
-class Bytes(Constant, metaclass=_ABC):
-    _fields = ('s',)
-    __new__ = _new
-
-class NameConstant(Constant, metaclass=_ABC):
-    __new__ = _new
-
-class Ellipsis(Constant, metaclass=_ABC):
-    _fields = ()
-
-    def __new__(cls, *args, **kwargs):
-        if cls is _ast_Ellipsis:
-            import warnings
-            warnings._deprecated(
-                "ast.Ellipsis", message=_DEPRECATED_CLASS_MESSAGE, remove=(3, 14)
-            )
-            return Constant(..., *args, **kwargs)
-        return Constant.__new__(cls, *args, **kwargs)
-
-# Keep another reference to Ellipsis in the global namespace
-# so it can be referenced in Ellipsis.__new__
-# (The original "Ellipsis" name is removed from the global namespace later on)
-_ast_Ellipsis = Ellipsis
-
-_const_types = {
-    Num: (int, float, complex),
-    Str: (str,),
-    Bytes: (bytes,),
-    NameConstant: (type(None), bool),
-    Ellipsis: (type(...),),
-}
-_const_types_not = {
-    Num: (bool,),
-}
-
-_const_node_type_names = {
-    bool: 'NameConstant',  # should be before int
-    type(None): 'NameConstant',
-    int: 'Num',
-    float: 'Num',
-    complex: 'Num',
-    str: 'Str',
-    bytes: 'Bytes',
-    type(...): 'Ellipsis',
-}
-
 class slice(AST):
     """Deprecated AST node class."""
 
@@ -696,1147 +614,21 @@ class Param(expr_context):
     """Deprecated AST node class.  Unused in Python 3."""
 
 
-# Large float and imaginary literals get turned into infinities in the AST.
-# We unparse those infinities to INFSTR.
-_INFSTR = "1e" + repr(sys.float_info.max_10_exp + 1)
-
-@_simple_enum(IntEnum)
-class _Precedence:
-    """Precedence table that originated from python grammar."""
-
-    NAMED_EXPR = auto()      # <target> := <expr1>
-    TUPLE = auto()           # <expr1>, <expr2>
-    YIELD = auto()           # 'yield', 'yield from'
-    TEST = auto()            # 'if'-'else', 'lambda'
-    OR = auto()              # 'or'
-    AND = auto()             # 'and'
-    NOT = auto()             # 'not'
-    CMP = auto()             # '<', '>', '==', '>=', '<=', '!=',
-                             # 'in', 'not in', 'is', 'is not'
-    EXPR = auto()
-    BOR = EXPR               # '|'
-    BXOR = auto()            # '^'
-    BAND = auto()            # '&'
-    SHIFT = auto()           # '<<', '>>'
-    ARITH = auto()           # '+', '-'
-    TERM = auto()            # '*', '@', '/', '%', '//'
-    FACTOR = auto()          # unary '+', '-', '~'
-    POWER = auto()           # '**'
-    AWAIT = auto()           # 'await'
-    ATOM = auto()
-
-    def next(self):
-        try:
-            return self.__class__(self + 1)
-        except ValueError:
-            return self
-
-
-_SINGLE_QUOTES = ("'", '"')
-_MULTI_QUOTES = ('"""', "'''")
-_ALL_QUOTES = (*_SINGLE_QUOTES, *_MULTI_QUOTES)
-
-class _Unparser(NodeVisitor):
-    """Methods in this class recursively traverse an AST and
-    output source code for the abstract syntax; original formatting
-    is disregarded."""
-
-    def __init__(self):
-        self._source = []
-        self._precedences = {}
-        self._type_ignores = {}
-        self._indent = 0
-        self._in_try_star = False
-
-    def interleave(self, inter, f, seq):
-        """Call f on each item in seq, calling inter() in between."""
-        seq = iter(seq)
-        try:
-            f(next(seq))
-        except StopIteration:
-            pass
-        else:
-            for x in seq:
-                inter()
-                f(x)
-
-    def items_view(self, traverser, items):
-        """Traverse and separate the given *items* with a comma and append it to
-        the buffer. If *items* is a single item sequence, a trailing comma
-        will be added."""
-        if len(items) == 1:
-            traverser(items[0])
-            self.write(",")
-        else:
-            self.interleave(lambda: self.write(", "), traverser, items)
-
-    def maybe_newline(self):
-        """Adds a newline if it isn't the start of generated source"""
-        if self._source:
-            self.write("\n")
-
-    def fill(self, text=""):
-        """Indent a piece of text and append it, according to the current
-        indentation level"""
-        self.maybe_newline()
-        self.write("    " * self._indent + text)
-
-    def write(self, *text):
-        """Add new source parts"""
-        self._source.extend(text)
-
-    @contextmanager
-    def buffered(self, buffer = None):
-        if buffer is None:
-            buffer = []
-
-        original_source = self._source
-        self._source = buffer
-        yield buffer
-        self._source = original_source
-
-    @contextmanager
-    def block(self, *, extra = None):
-        """A context manager for preparing the source for blocks. It adds
-        the character':', increases the indentation on enter and decreases
-        the indentation on exit. If *extra* is given, it will be directly
-        appended after the colon character.
-        """
-        self.write(":")
-        if extra:
-            self.write(extra)
-        self._indent += 1
-        yield
-        self._indent -= 1
-
-    @contextmanager
-    def delimit(self, start, end):
-        """A context manager for preparing the source for expressions. It adds
-        *start* to the buffer and enters, after exit it adds *end*."""
-
-        self.write(start)
-        yield
-        self.write(end)
-
-    def delimit_if(self, start, end, condition):
-        if condition:
-            return self.delimit(start, end)
-        else:
-            return nullcontext()
-
-    def require_parens(self, precedence, node):
-        """Shortcut to adding precedence related parens"""
-        return self.delimit_if("(", ")", self.get_precedence(node) > precedence)
-
-    def get_precedence(self, node):
-        return self._precedences.get(node, _Precedence.TEST)
-
-    def set_precedence(self, precedence, *nodes):
-        for node in nodes:
-            self._precedences[node] = precedence
-
-    def get_raw_docstring(self, node):
-        """If a docstring node is found in the body of the *node* parameter,
-        return that docstring node, None otherwise.
-
-        Logic mirrored from ``_PyAST_GetDocString``."""
-        if not isinstance(
-            node, (AsyncFunctionDef, FunctionDef, ClassDef, Module)
-        ) or len(node.body) < 1:
-            return None
-        node = node.body[0]
-        if not isinstance(node, Expr):
-            return None
-        node = node.value
-        if isinstance(node, Constant) and isinstance(node.value, str):
-            return node
-
-    def get_type_comment(self, node):
-        comment = self._type_ignores.get(node.lineno) or node.type_comment
-        if comment is not None:
-            return f" # type: {comment}"
-
-    def traverse(self, node):
-        if isinstance(node, list):
-            for item in node:
-                self.traverse(item)
-        else:
-            super().visit(node)
-
-    # Note: as visit() resets the output text, do NOT rely on
-    # NodeVisitor.generic_visit to handle any nodes (as it calls back in to
-    # the subclass visit() method, which resets self._source to an empty list)
-    def visit(self, node):
-        """Outputs a source code string that, if converted back to an ast
-        (using ast.parse) will generate an AST equivalent to *node*"""
-        self._source = []
-        self.traverse(node)
-        return "".join(self._source)
-
-    def _write_docstring_and_traverse_body(self, node):
-        if (docstring := self.get_raw_docstring(node)):
-            self._write_docstring(docstring)
-            self.traverse(node.body[1:])
-        else:
-            self.traverse(node.body)
-
-    def visit_Module(self, node):
-        self._type_ignores = {
-            ignore.lineno: f"ignore{ignore.tag}"
-            for ignore in node.type_ignores
-        }
-        self._write_docstring_and_traverse_body(node)
-        self._type_ignores.clear()
-
-    def visit_FunctionType(self, node):
-        with self.delimit("(", ")"):
-            self.interleave(
-                lambda: self.write(", "), self.traverse, node.argtypes
-            )
-
-        self.write(" -> ")
-        self.traverse(node.returns)
-
-    def visit_Expr(self, node):
-        self.fill()
-        self.set_precedence(_Precedence.YIELD, node.value)
-        self.traverse(node.value)
-
-    def visit_NamedExpr(self, node):
-        with self.require_parens(_Precedence.NAMED_EXPR, node):
-            self.set_precedence(_Precedence.ATOM, node.target, node.value)
-            self.traverse(node.target)
-            self.write(" := ")
-            self.traverse(node.value)
-
-    def visit_Import(self, node):
-        self.fill("import ")
-        self.interleave(lambda: self.write(", "), self.traverse, node.names)
-
-    def visit_ImportFrom(self, node):
-        self.fill("from ")
-        self.write("." * (node.level or 0))
-        if node.module:
-            self.write(node.module)
-        self.write(" import ")
-        self.interleave(lambda: self.write(", "), self.traverse, node.names)
-
-    def visit_Assign(self, node):
-        self.fill()
-        for target in node.targets:
-            self.set_precedence(_Precedence.TUPLE, target)
-            self.traverse(target)
-            self.write(" = ")
-        self.traverse(node.value)
-        if type_comment := self.get_type_comment(node):
-            self.write(type_comment)
-
-    def visit_AugAssign(self, node):
-        self.fill()
-        self.traverse(node.target)
-        self.write(" " + self.binop[node.op.__class__.__name__] + "= ")
-        self.traverse(node.value)
-
-    def visit_AnnAssign(self, node):
-        self.fill()
-        with self.delimit_if("(", ")", not node.simple and isinstance(node.target, Name)):
-            self.traverse(node.target)
-        self.write(": ")
-        self.traverse(node.annotation)
-        if node.value:
-            self.write(" = ")
-            self.traverse(node.value)
-
-    def visit_Return(self, node):
-        self.fill("return")
-        if node.value:
-            self.write(" ")
-            self.traverse(node.value)
-
-    def visit_Pass(self, node):
-        self.fill("pass")
-
-    def visit_Break(self, node):
-        self.fill("break")
-
-    def visit_Continue(self, node):
-        self.fill("continue")
-
-    def visit_Delete(self, node):
-        self.fill("del ")
-        self.interleave(lambda: self.write(", "), self.traverse, node.targets)
-
-    def visit_Assert(self, node):
-        self.fill("assert ")
-        self.traverse(node.test)
-        if node.msg:
-            self.write(", ")
-            self.traverse(node.msg)
-
-    def visit_Global(self, node):
-        self.fill("global ")
-        self.interleave(lambda: self.write(", "), self.write, node.names)
-
-    def visit_Nonlocal(self, node):
-        self.fill("nonlocal ")
-        self.interleave(lambda: self.write(", "), self.write, node.names)
-
-    def visit_Await(self, node):
-        with self.require_parens(_Precedence.AWAIT, node):
-            self.write("await")
-            if node.value:
-                self.write(" ")
-                self.set_precedence(_Precedence.ATOM, node.value)
-                self.traverse(node.value)
-
-    def visit_Yield(self, node):
-        with self.require_parens(_Precedence.YIELD, node):
-            self.write("yield")
-            if node.value:
-                self.write(" ")
-                self.set_precedence(_Precedence.ATOM, node.value)
-                self.traverse(node.value)
-
-    def visit_YieldFrom(self, node):
-        with self.require_parens(_Precedence.YIELD, node):
-            self.write("yield from ")
-            if not node.value:
-                raise ValueError("Node can't be used without a value attribute.")
-            self.set_precedence(_Precedence.ATOM, node.value)
-            self.traverse(node.value)
-
-    def visit_Raise(self, node):
-        self.fill("raise")
-        if not node.exc:
-            if node.cause:
-                raise ValueError(f"Node can't use cause without an exception.")
-            return
-        self.write(" ")
-        self.traverse(node.exc)
-        if node.cause:
-            self.write(" from ")
-            self.traverse(node.cause)
-
-    def do_visit_try(self, node):
-        self.fill("try")
-        with self.block():
-            self.traverse(node.body)
-        for ex in node.handlers:
-            self.traverse(ex)
-        if node.orelse:
-            self.fill("else")
-            with self.block():
-                self.traverse(node.orelse)
-        if node.finalbody:
-            self.fill("finally")
-            with self.block():
-                self.traverse(node.finalbody)
-
-    def visit_Try(self, node):
-        prev_in_try_star = self._in_try_star
-        try:
-            self._in_try_star = False
-            self.do_visit_try(node)
-        finally:
-            self._in_try_star = prev_in_try_star
-
-    def visit_TryStar(self, node):
-        prev_in_try_star = self._in_try_star
-        try:
-            self._in_try_star = True
-            self.do_visit_try(node)
-        finally:
-            self._in_try_star = prev_in_try_star
-
-    def visit_ExceptHandler(self, node):
-        self.fill("except*" if self._in_try_star else "except")
-        if node.type:
-            self.write(" ")
-            self.traverse(node.type)
-        if node.name:
-            self.write(" as ")
-            self.write(node.name)
-        with self.block():
-            self.traverse(node.body)
-
-    def visit_ClassDef(self, node):
-        self.maybe_newline()
-        for deco in node.decorator_list:
-            self.fill("@")
-            self.traverse(deco)
-        self.fill("class " + node.name)
-        if hasattr(node, "type_params"):
-            self._type_params_helper(node.type_params)
-        with self.delimit_if("(", ")", condition = node.bases or node.keywords):
-            comma = False
-            for e in node.bases:
-                if comma:
-                    self.write(", ")
-                else:
-                    comma = True
-                self.traverse(e)
-            for e in node.keywords:
-                if comma:
-                    self.write(", ")
-                else:
-                    comma = True
-                self.traverse(e)
-
-        with self.block():
-            self._write_docstring_and_traverse_body(node)
-
-    def visit_FunctionDef(self, node):
-        self._function_helper(node, "def")
-
-    def visit_AsyncFunctionDef(self, node):
-        self._function_helper(node, "async def")
-
-    def _function_helper(self, node, fill_suffix):
-        self.maybe_newline()
-        for deco in node.decorator_list:
-            self.fill("@")
-            self.traverse(deco)
-        def_str = fill_suffix + " " + node.name
-        self.fill(def_str)
-        if hasattr(node, "type_params"):
-            self._type_params_helper(node.type_params)
-        with self.delimit("(", ")"):
-            self.traverse(node.args)
-        if node.returns:
-            self.write(" -> ")
-            self.traverse(node.returns)
-        with self.block(extra=self.get_type_comment(node)):
-            self._write_docstring_and_traverse_body(node)
-
-    def _type_params_helper(self, type_params):
-        if type_params is not None and len(type_params) > 0:
-            with self.delimit("[", "]"):
-                self.interleave(lambda: self.write(", "), self.traverse, type_params)
-
-    def visit_TypeVar(self, node):
-        self.write(node.name)
-        if node.bound:
-            self.write(": ")
-            self.traverse(node.bound)
-        if node.default_value:
-            self.write(" = ")
-            self.traverse(node.default_value)
-
-    def visit_TypeVarTuple(self, node):
-        self.write("*" + node.name)
-        if node.default_value:
-            self.write(" = ")
-            self.traverse(node.default_value)
-
-    def visit_ParamSpec(self, node):
-        self.write("**" + node.name)
-        if node.default_value:
-            self.write(" = ")
-            self.traverse(node.default_value)
-
-    def visit_TypeAlias(self, node):
-        self.fill("type ")
-        self.traverse(node.name)
-        self._type_params_helper(node.type_params)
-        self.write(" = ")
-        self.traverse(node.value)
-
-    def visit_For(self, node):
-        self._for_helper("for ", node)
-
-    def visit_AsyncFor(self, node):
-        self._for_helper("async for ", node)
-
-    def _for_helper(self, fill, node):
-        self.fill(fill)
-        self.set_precedence(_Precedence.TUPLE, node.target)
-        self.traverse(node.target)
-        self.write(" in ")
-        self.traverse(node.iter)
-        with self.block(extra=self.get_type_comment(node)):
-            self.traverse(node.body)
-        if node.orelse:
-            self.fill("else")
-            with self.block():
-                self.traverse(node.orelse)
-
-    def visit_If(self, node):
-        self.fill("if ")
-        self.traverse(node.test)
-        with self.block():
-            self.traverse(node.body)
-        # collapse nested ifs into equivalent elifs.
-        while node.orelse and len(node.orelse) == 1 and isinstance(node.orelse[0], If):
-            node = node.orelse[0]
-            self.fill("elif ")
-            self.traverse(node.test)
-            with self.block():
-                self.traverse(node.body)
-        # final else
-        if node.orelse:
-            self.fill("else")
-            with self.block():
-                self.traverse(node.orelse)
-
-    def visit_While(self, node):
-        self.fill("while ")
-        self.traverse(node.test)
-        with self.block():
-            self.traverse(node.body)
-        if node.orelse:
-            self.fill("else")
-            with self.block():
-                self.traverse(node.orelse)
-
-    def visit_With(self, node):
-        self.fill("with ")
-        self.interleave(lambda: self.write(", "), self.traverse, node.items)
-        with self.block(extra=self.get_type_comment(node)):
-            self.traverse(node.body)
-
-    def visit_AsyncWith(self, node):
-        self.fill("async with ")
-        self.interleave(lambda: self.write(", "), self.traverse, node.items)
-        with self.block(extra=self.get_type_comment(node)):
-            self.traverse(node.body)
-
-    def _str_literal_helper(
-        self, string, *, quote_types=_ALL_QUOTES, escape_special_whitespace=False
-    ):
-        """Helper for writing string literals, minimizing escapes.
-        Returns the tuple (string literal to write, possible quote types).
-        """
-        def escape_char(c):
-            # \n and \t are non-printable, but we only escape them if
-            # escape_special_whitespace is True
-            if not escape_special_whitespace and c in "\n\t":
-                return c
-            # Always escape backslashes and other non-printable characters
-            if c == "\\" or not c.isprintable():
-                return c.encode("unicode_escape").decode("ascii")
-            return c
-
-        escaped_string = "".join(map(escape_char, string))
-        possible_quotes = quote_types
-        if "\n" in escaped_string:
-            possible_quotes = [q for q in possible_quotes if q in _MULTI_QUOTES]
-        possible_quotes = [q for q in possible_quotes if q not in escaped_string]
-        if not possible_quotes:
-            # If there aren't any possible_quotes, fallback to using repr
-            # on the original string. Try to use a quote from quote_types,
-            # e.g., so that we use triple quotes for docstrings.
-            string = repr(string)
-            quote = next((q for q in quote_types if string[0] in q), string[0])
-            return string[1:-1], [quote]
-        if escaped_string:
-            # Sort so that we prefer '''"''' over """\""""
-            possible_quotes.sort(key=lambda q: q[0] == escaped_string[-1])
-            # If we're using triple quotes and we'd need to escape a final
-            # quote, escape it
-            if possible_quotes[0][0] == escaped_string[-1]:
-                assert len(possible_quotes[0]) == 3
-                escaped_string = escaped_string[:-1] + "\\" + escaped_string[-1]
-        return escaped_string, possible_quotes
-
-    def _write_str_avoiding_backslashes(self, string, *, quote_types=_ALL_QUOTES):
-        """Write string literal value with a best effort attempt to avoid backslashes."""
-        string, quote_types = self._str_literal_helper(string, quote_types=quote_types)
-        quote_type = quote_types[0]
-        self.write(f"{quote_type}{string}{quote_type}")
-
-    def visit_JoinedStr(self, node):
-        self.write("f")
-
-        fstring_parts = []
-        for value in node.values:
-            with self.buffered() as buffer:
-                self._write_fstring_inner(value)
-            fstring_parts.append(
-                ("".join(buffer), isinstance(value, Constant))
-            )
-
-        new_fstring_parts = []
-        quote_types = list(_ALL_QUOTES)
-        fallback_to_repr = False
-        for value, is_constant in fstring_parts:
-            if is_constant:
-                value, new_quote_types = self._str_literal_helper(
-                    value,
-                    quote_types=quote_types,
-                    escape_special_whitespace=True,
-                )
-                if set(new_quote_types).isdisjoint(quote_types):
-                    fallback_to_repr = True
-                    break
-                quote_types = new_quote_types
-            else:
-                if "\n" in value:
-                    quote_types = [q for q in quote_types if q in _MULTI_QUOTES]
-                    assert quote_types
-
-                new_quote_types = [q for q in quote_types if q not in value]
-                if new_quote_types:
-                    quote_types = new_quote_types
-            new_fstring_parts.append(value)
-
-        if fallback_to_repr:
-            # If we weren't able to find a quote type that works for all parts
-            # of the JoinedStr, fallback to using repr and triple single quotes.
-            quote_types = ["'''"]
-            new_fstring_parts.clear()
-            for value, is_constant in fstring_parts:
-                if is_constant:
-                    value = repr('"' + value)  # force repr to use single quotes
-                    expected_prefix = "'\""
-                    assert value.startswith(expected_prefix), repr(value)
-                    value = value[len(expected_prefix):-1]
-                new_fstring_parts.append(value)
-
-        value = "".join(new_fstring_parts)
-        quote_type = quote_types[0]
-        self.write(f"{quote_type}{value}{quote_type}")
-
-    def _write_fstring_inner(self, node, is_format_spec=False):
-        if isinstance(node, JoinedStr):
-            # for both the f-string itself, and format_spec
-            for value in node.values:
-                self._write_fstring_inner(value, is_format_spec=is_format_spec)
-        elif isinstance(node, Constant) and isinstance(node.value, str):
-            value = node.value.replace("{", "{{").replace("}", "}}")
-
-            if is_format_spec:
-                value = value.replace("\\", "\\\\")
-                value = value.replace("'", "\\'")
-                value = value.replace('"', '\\"')
-                value = value.replace("\n", "\\n")
-            self.write(value)
-        elif isinstance(node, FormattedValue):
-            self.visit_FormattedValue(node)
-        else:
-            raise ValueError(f"Unexpected node inside JoinedStr, {node!r}")
-
-    def visit_FormattedValue(self, node):
-        def unparse_inner(inner):
-            unparser = type(self)()
-            unparser.set_precedence(_Precedence.TEST.next(), inner)
-            return unparser.visit(inner)
-
-        with self.delimit("{", "}"):
-            expr = unparse_inner(node.value)
-            if expr.startswith("{"):
-                # Separate pair of opening brackets as "{ {"
-                self.write(" ")
-            self.write(expr)
-            if node.conversion != -1:
-                self.write(f"!{chr(node.conversion)}")
-            if node.format_spec:
-                self.write(":")
-                self._write_fstring_inner(node.format_spec, is_format_spec=True)
-
-    def visit_Name(self, node):
-        self.write(node.id)
-
-    def _write_docstring(self, node):
-        self.fill()
-        if node.kind == "u":
-            self.write("u")
-        self._write_str_avoiding_backslashes(node.value, quote_types=_MULTI_QUOTES)
-
-    def _write_constant(self, value):
-        if isinstance(value, (float, complex)):
-            # Substitute overflowing decimal literal for AST infinities,
-            # and inf - inf for NaNs.
-            self.write(
-                repr(value)
-                .replace("inf", _INFSTR)
-                .replace("nan", f"({_INFSTR}-{_INFSTR})")
-            )
-        else:
-            self.write(repr(value))
-
-    def visit_Constant(self, node):
-        value = node.value
-        if isinstance(value, tuple):
-            with self.delimit("(", ")"):
-                self.items_view(self._write_constant, value)
-        elif value is ...:
-            self.write("...")
-        else:
-            if node.kind == "u":
-                self.write("u")
-            self._write_constant(node.value)
-
-    def visit_List(self, node):
-        with self.delimit("[", "]"):
-            self.interleave(lambda: self.write(", "), self.traverse, node.elts)
-
-    def visit_ListComp(self, node):
-        with self.delimit("[", "]"):
-            self.traverse(node.elt)
-            for gen in node.generators:
-                self.traverse(gen)
-
-    def visit_GeneratorExp(self, node):
-        with self.delimit("(", ")"):
-            self.traverse(node.elt)
-            for gen in node.generators:
-                self.traverse(gen)
-
-    def visit_SetComp(self, node):
-        with self.delimit("{", "}"):
-            self.traverse(node.elt)
-            for gen in node.generators:
-                self.traverse(gen)
-
-    def visit_DictComp(self, node):
-        with self.delimit("{", "}"):
-            self.traverse(node.key)
-            self.write(": ")
-            self.traverse(node.value)
-            for gen in node.generators:
-                self.traverse(gen)
-
-    def visit_comprehension(self, node):
-        if node.is_async:
-            self.write(" async for ")
-        else:
-            self.write(" for ")
-        self.set_precedence(_Precedence.TUPLE, node.target)
-        self.traverse(node.target)
-        self.write(" in ")
-        self.set_precedence(_Precedence.TEST.next(), node.iter, *node.ifs)
-        self.traverse(node.iter)
-        for if_clause in node.ifs:
-            self.write(" if ")
-            self.traverse(if_clause)
-
-    def visit_IfExp(self, node):
-        with self.require_parens(_Precedence.TEST, node):
-            self.set_precedence(_Precedence.TEST.next(), node.body, node.test)
-            self.traverse(node.body)
-            self.write(" if ")
-            self.traverse(node.test)
-            self.write(" else ")
-            self.set_precedence(_Precedence.TEST, node.orelse)
-            self.traverse(node.orelse)
-
-    def visit_Set(self, node):
-        if node.elts:
-            with self.delimit("{", "}"):
-                self.interleave(lambda: self.write(", "), self.traverse, node.elts)
-        else:
-            # `{}` would be interpreted as a dictionary literal, and
-            # `set` might be shadowed. Thus:
-            self.write('{*()}')
-
-    def visit_Dict(self, node):
-        def write_key_value_pair(k, v):
-            self.traverse(k)
-            self.write(": ")
-            self.traverse(v)
-
-        def write_item(item):
-            k, v = item
-            if k is None:
-                # for dictionary unpacking operator in dicts {**{'y': 2}}
-                # see PEP 448 for details
-                self.write("**")
-                self.set_precedence(_Precedence.EXPR, v)
-                self.traverse(v)
-            else:
-                write_key_value_pair(k, v)
-
-        with self.delimit("{", "}"):
-            self.interleave(
-                lambda: self.write(", "), write_item, zip(node.keys, node.values)
-            )
-
-    def visit_Tuple(self, node):
-        with self.delimit_if(
-            "(",
-            ")",
-            len(node.elts) == 0 or self.get_precedence(node) > _Precedence.TUPLE
-        ):
-            self.items_view(self.traverse, node.elts)
-
-    unop = {"Invert": "~", "Not": "not", "UAdd": "+", "USub": "-"}
-    unop_precedence = {
-        "not": _Precedence.NOT,
-        "~": _Precedence.FACTOR,
-        "+": _Precedence.FACTOR,
-        "-": _Precedence.FACTOR,
-    }
-
-    def visit_UnaryOp(self, node):
-        operator = self.unop[node.op.__class__.__name__]
-        operator_precedence = self.unop_precedence[operator]
-        with self.require_parens(operator_precedence, node):
-            self.write(operator)
-            # factor prefixes (+, -, ~) shouldn't be separated
-            # from the value they belong, (e.g: +1 instead of + 1)
-            if operator_precedence is not _Precedence.FACTOR:
-                self.write(" ")
-            self.set_precedence(operator_precedence, node.operand)
-            self.traverse(node.operand)
-
-    binop = {
-        "Add": "+",
-        "Sub": "-",
-        "Mult": "*",
-        "MatMult": "@",
-        "Div": "/",
-        "Mod": "%",
-        "LShift": "<<",
-        "RShift": ">>",
-        "BitOr": "|",
-        "BitXor": "^",
-        "BitAnd": "&",
-        "FloorDiv": "//",
-        "Pow": "**",
-    }
-
-    binop_precedence = {
-        "+": _Precedence.ARITH,
-        "-": _Precedence.ARITH,
-        "*": _Precedence.TERM,
-        "@": _Precedence.TERM,
-        "/": _Precedence.TERM,
-        "%": _Precedence.TERM,
-        "<<": _Precedence.SHIFT,
-        ">>": _Precedence.SHIFT,
-        "|": _Precedence.BOR,
-        "^": _Precedence.BXOR,
-        "&": _Precedence.BAND,
-        "//": _Precedence.TERM,
-        "**": _Precedence.POWER,
-    }
-
-    binop_rassoc = frozenset(("**",))
-    def visit_BinOp(self, node):
-        operator = self.binop[node.op.__class__.__name__]
-        operator_precedence = self.binop_precedence[operator]
-        with self.require_parens(operator_precedence, node):
-            if operator in self.binop_rassoc:
-                left_precedence = operator_precedence.next()
-                right_precedence = operator_precedence
-            else:
-                left_precedence = operator_precedence
-                right_precedence = operator_precedence.next()
-
-            self.set_precedence(left_precedence, node.left)
-            self.traverse(node.left)
-            self.write(f" {operator} ")
-            self.set_precedence(right_precedence, node.right)
-            self.traverse(node.right)
-
-    cmpops = {
-        "Eq": "==",
-        "NotEq": "!=",
-        "Lt": "<",
-        "LtE": "<=",
-        "Gt": ">",
-        "GtE": ">=",
-        "Is": "is",
-        "IsNot": "is not",
-        "In": "in",
-        "NotIn": "not in",
-    }
-
-    def visit_Compare(self, node):
-        with self.require_parens(_Precedence.CMP, node):
-            self.set_precedence(_Precedence.CMP.next(), node.left, *node.comparators)
-            self.traverse(node.left)
-            for o, e in zip(node.ops, node.comparators):
-                self.write(" " + self.cmpops[o.__class__.__name__] + " ")
-                self.traverse(e)
-
-    boolops = {"And": "and", "Or": "or"}
-    boolop_precedence = {"and": _Precedence.AND, "or": _Precedence.OR}
-
-    def visit_BoolOp(self, node):
-        operator = self.boolops[node.op.__class__.__name__]
-        operator_precedence = self.boolop_precedence[operator]
-
-        def increasing_level_traverse(node):
-            nonlocal operator_precedence
-            operator_precedence = operator_precedence.next()
-            self.set_precedence(operator_precedence, node)
-            self.traverse(node)
-
-        with self.require_parens(operator_precedence, node):
-            s = f" {operator} "
-            self.interleave(lambda: self.write(s), increasing_level_traverse, node.values)
-
-    def visit_Attribute(self, node):
-        self.set_precedence(_Precedence.ATOM, node.value)
-        self.traverse(node.value)
-        # Special case: 3.__abs__() is a syntax error, so if node.value
-        # is an integer literal then we need to either parenthesize
-        # it or add an extra space to get 3 .__abs__().
-        if isinstance(node.value, Constant) and isinstance(node.value.value, int):
-            self.write(" ")
-        self.write(".")
-        self.write(node.attr)
-
-    def visit_Call(self, node):
-        self.set_precedence(_Precedence.ATOM, node.func)
-        self.traverse(node.func)
-        with self.delimit("(", ")"):
-            comma = False
-            for e in node.args:
-                if comma:
-                    self.write(", ")
-                else:
-                    comma = True
-                self.traverse(e)
-            for e in node.keywords:
-                if comma:
-                    self.write(", ")
-                else:
-                    comma = True
-                self.traverse(e)
-
-    def visit_Subscript(self, node):
-        def is_non_empty_tuple(slice_value):
-            return (
-                isinstance(slice_value, Tuple)
-                and slice_value.elts
-            )
-
-        self.set_precedence(_Precedence.ATOM, node.value)
-        self.traverse(node.value)
-        with self.delimit("[", "]"):
-            if is_non_empty_tuple(node.slice):
-                # parentheses can be omitted if the tuple isn't empty
-                self.items_view(self.traverse, node.slice.elts)
-            else:
-                self.traverse(node.slice)
-
-    def visit_Starred(self, node):
-        self.write("*")
-        self.set_precedence(_Precedence.EXPR, node.value)
-        self.traverse(node.value)
-
-    def visit_Ellipsis(self, node):
-        self.write("...")
-
-    def visit_Slice(self, node):
-        if node.lower:
-            self.traverse(node.lower)
-        self.write(":")
-        if node.upper:
-            self.traverse(node.upper)
-        if node.step:
-            self.write(":")
-            self.traverse(node.step)
-
-    def visit_Match(self, node):
-        self.fill("match ")
-        self.traverse(node.subject)
-        with self.block():
-            for case in node.cases:
-                self.traverse(case)
-
-    def visit_arg(self, node):
-        self.write(node.arg)
-        if node.annotation:
-            self.write(": ")
-            self.traverse(node.annotation)
-
-    def visit_arguments(self, node):
-        first = True
-        # normal arguments
-        all_args = node.posonlyargs + node.args
-        defaults = [None] * (len(all_args) - len(node.defaults)) + node.defaults
-        for index, elements in enumerate(zip(all_args, defaults), 1):
-            a, d = elements
-            if first:
-                first = False
-            else:
-                self.write(", ")
-            self.traverse(a)
-            if d:
-                self.write("=")
-                self.traverse(d)
-            if index == len(node.posonlyargs):
-                self.write(", /")
-
-        # varargs, or bare '*' if no varargs but keyword-only arguments present
-        if node.vararg or node.kwonlyargs:
-            if first:
-                first = False
-            else:
-                self.write(", ")
-            self.write("*")
-            if node.vararg:
-                self.write(node.vararg.arg)
-                if node.vararg.annotation:
-                    self.write(": ")
-                    self.traverse(node.vararg.annotation)
-
-        # keyword-only arguments
-        if node.kwonlyargs:
-            for a, d in zip(node.kwonlyargs, node.kw_defaults):
-                self.write(", ")
-                self.traverse(a)
-                if d:
-                    self.write("=")
-                    self.traverse(d)
-
-        # kwargs
-        if node.kwarg:
-            if first:
-                first = False
-            else:
-                self.write(", ")
-            self.write("**" + node.kwarg.arg)
-            if node.kwarg.annotation:
-                self.write(": ")
-                self.traverse(node.kwarg.annotation)
-
-    def visit_keyword(self, node):
-        if node.arg is None:
-            self.write("**")
-        else:
-            self.write(node.arg)
-            self.write("=")
-        self.traverse(node.value)
-
-    def visit_Lambda(self, node):
-        with self.require_parens(_Precedence.TEST, node):
-            self.write("lambda")
-            with self.buffered() as buffer:
-                self.traverse(node.args)
-            if buffer:
-                self.write(" ", *buffer)
-            self.write(": ")
-            self.set_precedence(_Precedence.TEST, node.body)
-            self.traverse(node.body)
-
-    def visit_alias(self, node):
-        self.write(node.name)
-        if node.asname:
-            self.write(" as " + node.asname)
-
-    def visit_withitem(self, node):
-        self.traverse(node.context_expr)
-        if node.optional_vars:
-            self.write(" as ")
-            self.traverse(node.optional_vars)
-
-    def visit_match_case(self, node):
-        self.fill("case ")
-        self.traverse(node.pattern)
-        if node.guard:
-            self.write(" if ")
-            self.traverse(node.guard)
-        with self.block():
-            self.traverse(node.body)
-
-    def visit_MatchValue(self, node):
-        self.traverse(node.value)
-
-    def visit_MatchSingleton(self, node):
-        self._write_constant(node.value)
-
-    def visit_MatchSequence(self, node):
-        with self.delimit("[", "]"):
-            self.interleave(
-                lambda: self.write(", "), self.traverse, node.patterns
-            )
-
-    def visit_MatchStar(self, node):
-        name = node.name
-        if name is None:
-            name = "_"
-        self.write(f"*{name}")
-
-    def visit_MatchMapping(self, node):
-        def write_key_pattern_pair(pair):
-            k, p = pair
-            self.traverse(k)
-            self.write(": ")
-            self.traverse(p)
-
-        with self.delimit("{", "}"):
-            keys = node.keys
-            self.interleave(
-                lambda: self.write(", "),
-                write_key_pattern_pair,
-                zip(keys, node.patterns, strict=True),
-            )
-            rest = node.rest
-            if rest is not None:
-                if keys:
-                    self.write(", ")
-                self.write(f"**{rest}")
-
-    def visit_MatchClass(self, node):
-        self.set_precedence(_Precedence.ATOM, node.cls)
-        self.traverse(node.cls)
-        with self.delimit("(", ")"):
-            patterns = node.patterns
-            self.interleave(
-                lambda: self.write(", "), self.traverse, patterns
-            )
-            attrs = node.kwd_attrs
-            if attrs:
-                def write_attr_pattern(pair):
-                    attr, pattern = pair
-                    self.write(f"{attr}=")
-                    self.traverse(pattern)
-
-                if patterns:
-                    self.write(", ")
-                self.interleave(
-                    lambda: self.write(", "),
-                    write_attr_pattern,
-                    zip(attrs, node.kwd_patterns, strict=True),
-                )
-
-    def visit_MatchAs(self, node):
-        name = node.name
-        pattern = node.pattern
-        if name is None:
-            self.write("_")
-        elif pattern is None:
-            self.write(node.name)
-        else:
-            with self.require_parens(_Precedence.TEST, node):
-                self.set_precedence(_Precedence.BOR, node.pattern)
-                self.traverse(node.pattern)
-                self.write(f" as {node.name}")
-
-    def visit_MatchOr(self, node):
-        with self.require_parens(_Precedence.BOR, node):
-            self.set_precedence(_Precedence.BOR.next(), *node.patterns)
-            self.interleave(lambda: self.write(" | "), self.traverse, node.patterns)
-
 def unparse(ast_obj):
-    unparser = _Unparser()
+    global _Unparser
+    try:
+        unparser = _Unparser()
+    except NameError:
+        from _ast_unparse import Unparser as _Unparser
+        unparser = _Unparser()
     return unparser.visit(ast_obj)
 
 
-_deprecated_globals = {
-    name: globals().pop(name)
-    for name in ('Num', 'Str', 'Bytes', 'NameConstant', 'Ellipsis')
-}
-
-def __getattr__(name):
-    if name in _deprecated_globals:
-        globals()[name] = value = _deprecated_globals[name]
-        import warnings
-        warnings._deprecated(
-            f"ast.{name}", message=_DEPRECATED_CLASS_MESSAGE, remove=(3, 14)
-        )
-        return value
-    raise AttributeError(f"module 'ast' has no attribute '{name}'")
-
-
-def main():
+def main(args=None):
     import argparse
+    import sys
 
-    parser = argparse.ArgumentParser(prog='python -m ast')
+    parser = argparse.ArgumentParser(color=True)
     parser.add_argument('infile', nargs='?', default='-',
                         help='the file to parse; defaults to stdin')
     parser.add_argument('-m', '--mode', default='exec',
@@ -1849,7 +641,16 @@ def main():
                              'column offsets')
     parser.add_argument('-i', '--indent', type=int, default=3,
                         help='indentation of nodes (number of spaces)')
-    args = parser.parse_args()
+    parser.add_argument('--feature-version',
+                        type=str, default=None, metavar='VERSION',
+                        help='Python version in the format 3.x '
+                             '(for example, 3.10)')
+    parser.add_argument('-O', '--optimize',
+                        type=int, default=-1, metavar='LEVEL',
+                        help='optimization level for parser (default -1)')
+    parser.add_argument('--show-empty', default=False, action='store_true',
+                        help='show empty lists and fields in dump output')
+    args = parser.parse_args(args)
 
     if args.infile == '-':
         name = '<stdin>'
@@ -1858,8 +659,22 @@ def main():
         name = args.infile
         with open(args.infile, 'rb') as infile:
             source = infile.read()
-    tree = parse(source, name, args.mode, type_comments=args.no_type_comments)
-    print(dump(tree, include_attributes=args.include_attributes, indent=args.indent))
+
+    # Process feature_version
+    feature_version = None
+    if args.feature_version:
+        try:
+            major, minor = map(int, args.feature_version.split('.', 1))
+        except ValueError:
+            parser.error('Invalid format for --feature-version; '
+                         'expected format 3.x (for example, 3.10)')
+
+        feature_version = (major, minor)
+
+    tree = parse(source, name, args.mode, type_comments=args.no_type_comments,
+                 feature_version=feature_version, optimize=args.optimize)
+    print(dump(tree, include_attributes=args.include_attributes,
+               indent=args.indent, show_empty=args.show_empty))
 
 if __name__ == '__main__':
     main()
diff --git a/Lib/asyncio/__init__.py b/Lib/asyncio/__init__.py
index 03165a425eb..32a5dbae03a 100644
--- a/Lib/asyncio/__init__.py
+++ b/Lib/asyncio/__init__.py
@@ -10,6 +10,7 @@
 from .events import *
 from .exceptions import *
 from .futures import *
+from .graph import *
 from .locks import *
 from .protocols import *
 from .runners import *
@@ -27,6 +28,7 @@
            events.__all__ +
            exceptions.__all__ +
            futures.__all__ +
+           graph.__all__ +
            locks.__all__ +
            protocols.__all__ +
            runners.__all__ +
@@ -45,3 +47,28 @@
 else:
     from .unix_events import *  # pragma: no cover
     __all__ += unix_events.__all__
+
+def __getattr__(name: str):
+    import warnings
+
+    match name:
+        case "AbstractEventLoopPolicy":
+            warnings._deprecated(f"asyncio.{name}", remove=(3, 16))
+            return events._AbstractEventLoopPolicy
+        case "DefaultEventLoopPolicy":
+            warnings._deprecated(f"asyncio.{name}", remove=(3, 16))
+            if sys.platform == 'win32':
+                return windows_events._DefaultEventLoopPolicy
+            return unix_events._DefaultEventLoopPolicy
+        case "WindowsSelectorEventLoopPolicy":
+            if sys.platform == 'win32':
+                warnings._deprecated(f"asyncio.{name}", remove=(3, 16))
+                return windows_events._WindowsSelectorEventLoopPolicy
+            # Else fall through to the AttributeError below.
+        case "WindowsProactorEventLoopPolicy":
+            if sys.platform == 'win32':
+                warnings._deprecated(f"asyncio.{name}", remove=(3, 16))
+                return windows_events._WindowsProactorEventLoopPolicy
+            # Else fall through to the AttributeError below.
+
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
diff --git a/Lib/asyncio/__main__.py b/Lib/asyncio/__main__.py
index 8e9af83cc8a..e07dd52a2a5 100644
--- a/Lib/asyncio/__main__.py
+++ b/Lib/asyncio/__main__.py
@@ -1,5 +1,7 @@
+import argparse
 import ast
 import asyncio
+import asyncio.tools
 import concurrent.futures
 import contextvars
 import inspect
@@ -10,7 +12,7 @@
 import types
 import warnings
 
-from _colorize import can_colorize, ANSIColors  # type: ignore[import-not-found]
+from _colorize import get_theme
 from _pyrepl.console import InteractiveColoredConsole
 
 from . import futures
@@ -102,8 +104,9 @@ def run(self):
                     exec(startup_code, console.locals)
 
             ps1 = getattr(sys, "ps1", ">>> ")
-            if can_colorize() and CAN_USE_PYREPL:
-                ps1 = f"{ANSIColors.BOLD_MAGENTA}{ps1}{ANSIColors.RESET}"
+            if CAN_USE_PYREPL:
+                theme = get_theme().syntax
+                ps1 = f"{theme.prompt}{ps1}{theme.reset}"
             console.write(f"{ps1}import asyncio\n")
 
             if CAN_USE_PYREPL:
@@ -141,6 +144,37 @@ def interrupt(self) -> None:
 
 
 if __name__ == '__main__':
+    parser = argparse.ArgumentParser(
+        prog="python3 -m asyncio",
+        description="Interactive asyncio shell and CLI tools",
+        color=True,
+    )
+    subparsers = parser.add_subparsers(help="sub-commands", dest="command")
+    ps = subparsers.add_parser(
+        "ps", help="Display a table of all pending tasks in a process"
+    )
+    ps.add_argument("pid", type=int, help="Process ID to inspect")
+    pstree = subparsers.add_parser(
+        "pstree", help="Display a tree of all pending tasks in a process"
+    )
+    pstree.add_argument("pid", type=int, help="Process ID to inspect")
+    args = parser.parse_args()
+    match args.command:
+        case "ps":
+            asyncio.tools.display_awaited_by_tasks_table(args.pid)
+            sys.exit(0)
+        case "pstree":
+            asyncio.tools.display_awaited_by_tasks_tree(args.pid)
+            sys.exit(0)
+        case None:
+            pass  # continue to the interactive shell
+        case _:
+            # shouldn't happen as an invalid command-line wouldn't parse
+            # but let's keep it for the next person adding a command
+            print(f"error: unhandled command {args.command}", file=sys.stderr)
+            parser.print_usage(file=sys.stderr)
+            sys.exit(1)
+
     sys.audit("cpython.run_stdin")
 
     if os.getenv('PYTHON_BASIC_REPL'):
diff --git a/Lib/asyncio/base_events.py b/Lib/asyncio/base_events.py
index 356fc3d7913..8cbb71f7085 100644
--- a/Lib/asyncio/base_events.py
+++ b/Lib/asyncio/base_events.py
@@ -458,24 +458,18 @@ 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, **kwargs):
-        """Schedule a coroutine object.
+    def create_task(self, coro, **kwargs):
+        """Schedule or begin executing a coroutine object.
 
         Return a task object.
         """
         self._check_closed()
         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]
+            return self._task_factory(self, coro, **kwargs)
 
+        task = tasks.Task(coro, loop=self, **kwargs)
+        if task._source_traceback:
+            del task._source_traceback[-1]
         try:
             return task
         finally:
@@ -841,7 +835,7 @@ def call_soon(self, callback, *args, context=None):
 
     def _check_callback(self, callback, method):
         if (coroutines.iscoroutine(callback) or
-                coroutines.iscoroutinefunction(callback)):
+                coroutines._iscoroutinefunction(callback)):
             raise TypeError(
                 f"coroutines cannot be used with {method}()")
         if not callable(callback):
@@ -878,7 +872,10 @@ def call_soon_threadsafe(self, callback, *args, context=None):
         self._check_closed()
         if self._debug:
             self._check_callback(callback, 'call_soon_threadsafe')
-        handle = self._call_soon(callback, args, context)
+        handle = events._ThreadSafeHandle(callback, args, self, context)
+        self._ready.append(handle)
+        if handle._source_traceback:
+            del handle._source_traceback[-1]
         if handle._source_traceback:
             del handle._source_traceback[-1]
         self._write_to_self()
@@ -1677,8 +1674,7 @@ async def connect_accepted_socket(
             raise ValueError(
                 'ssl_shutdown_timeout is only meaningful with ssl')
 
-        if sock is not None:
-            _check_ssl_socket(sock)
+        _check_ssl_socket(sock)
 
         transport, protocol = await self._create_connection_transport(
             sock, protocol_factory, ssl, '', server_side=True,
diff --git a/Lib/asyncio/coroutines.py b/Lib/asyncio/coroutines.py
index ab4f30eb51b..a51319cb72a 100644
--- a/Lib/asyncio/coroutines.py
+++ b/Lib/asyncio/coroutines.py
@@ -18,7 +18,16 @@ def _is_debug_mode():
 
 
 def iscoroutinefunction(func):
+    import warnings
     """Return True if func is a decorated coroutine function."""
+    warnings._deprecated("asyncio.iscoroutinefunction",
+                         f"{warnings._DEPRECATED_MSG}; "
+                         "use inspect.iscoroutinefunction() instead",
+                         remove=(3,16))
+    return _iscoroutinefunction(func)
+
+
+def _iscoroutinefunction(func):
     return (inspect.iscoroutinefunction(func) or
             getattr(func, '_is_coroutine', None) is _is_coroutine)
 
diff --git a/Lib/asyncio/events.py b/Lib/asyncio/events.py
index 0d1591e4604..a7fb55982ab 100644
--- a/Lib/asyncio/events.py
+++ b/Lib/asyncio/events.py
@@ -5,14 +5,18 @@
 # SPDX-FileCopyrightText: Copyright (c) 2015-2021 MagicStack Inc.  http://magic.io
 
 __all__ = (
-    'AbstractEventLoopPolicy',
-    'AbstractEventLoop', 'AbstractServer',
-    'Handle', 'TimerHandle',
-    'get_event_loop_policy', 'set_event_loop_policy',
-    'get_event_loop', 'set_event_loop', 'new_event_loop',
-    'get_child_watcher', 'set_child_watcher',
-    '_set_running_loop', 'get_running_loop',
-    '_get_running_loop',
+    "AbstractEventLoop",
+    "AbstractServer",
+    "Handle",
+    "TimerHandle",
+    "get_event_loop_policy",
+    "set_event_loop_policy",
+    "get_event_loop",
+    "set_event_loop",
+    "new_event_loop",
+    "_set_running_loop",
+    "get_running_loop",
+    "_get_running_loop",
 )
 
 import contextvars
@@ -22,6 +26,7 @@
 import subprocess
 import sys
 import threading
+import warnings
 
 from . import format_helpers
 
@@ -104,6 +109,34 @@ def _run(self):
             self._loop.call_exception_handler(context)
         self = None  # Needed to break cycles when an exception occurs.
 
+# _ThreadSafeHandle is used for callbacks scheduled with call_soon_threadsafe
+# and is thread safe unlike Handle which is not thread safe.
+class _ThreadSafeHandle(Handle):
+
+    __slots__ = ('_lock',)
+
+    def __init__(self, callback, args, loop, context=None):
+        super().__init__(callback, args, loop, context)
+        self._lock = threading.RLock()
+
+    def cancel(self):
+        with self._lock:
+            return super().cancel()
+
+    def cancelled(self):
+        with self._lock:
+            return super().cancelled()
+
+    def _run(self):
+        # The event loop checks for cancellation without holding the lock
+        # It is possible that the handle is cancelled after the check
+        # but before the callback is called so check it again after acquiring
+        # the lock and return without calling the callback if it is cancelled.
+        with self._lock:
+            if self._cancelled:
+                return
+            return super()._run()
+
 
 class TimerHandle(Handle):
     """Object returned by timed callback registration methods."""
@@ -629,7 +662,7 @@ def set_debug(self, enabled):
         raise NotImplementedError
 
 
-class AbstractEventLoopPolicy:
+class _AbstractEventLoopPolicy:
     """Abstract policy for accessing the event loop."""
 
     def get_event_loop(self):
@@ -652,18 +685,7 @@ def new_event_loop(self):
         the current context, set_event_loop must be called explicitly."""
         raise NotImplementedError
 
-    # Child processes handling (Unix only).
-
-    def get_child_watcher(self):
-        "Get the watcher for child processes."
-        raise NotImplementedError
-
-    def set_child_watcher(self, watcher):
-        """Set the watcher for child processes."""
-        raise NotImplementedError
-
-
-class BaseDefaultEventLoopPolicy(AbstractEventLoopPolicy):
+class _BaseDefaultEventLoopPolicy(_AbstractEventLoopPolicy):
     """Default policy implementation for accessing the event loop.
 
     In this policy, each thread has its own event loop.  However, we
@@ -680,7 +702,6 @@ class BaseDefaultEventLoopPolicy(AbstractEventLoopPolicy):
 
     class _Local(threading.local):
         _loop = None
-        _set_called = False
 
     def __init__(self):
         self._local = self._Local()
@@ -690,28 +711,6 @@ def get_event_loop(self):
 
         Returns an instance of EventLoop or raises an exception.
         """
-        if (self._local._loop is None and
-                not self._local._set_called and
-                threading.current_thread() is threading.main_thread()):
-            stacklevel = 2
-            try:
-                f = sys._getframe(1)
-            except AttributeError:
-                pass
-            else:
-                # Move up the call stack so that the warning is attached
-                # to the line outside asyncio itself.
-                while f:
-                    module = f.f_globals.get('__name__')
-                    if not (module == 'asyncio' or module.startswith('asyncio.')):
-                        break
-                    f = f.f_back
-                    stacklevel += 1
-            import warnings
-            warnings.warn('There is no current event loop',
-                          DeprecationWarning, stacklevel=stacklevel)
-            self.set_event_loop(self.new_event_loop())
-
         if self._local._loop is None:
             raise RuntimeError('There is no current event loop in thread %r.'
                                % threading.current_thread().name)
@@ -720,7 +719,6 @@ def get_event_loop(self):
 
     def set_event_loop(self, loop):
         """Set the event loop."""
-        self._local._set_called = True
         if loop is not None and not isinstance(loop, AbstractEventLoop):
             raise TypeError(f"loop must be an instance of AbstractEventLoop or None, not '{type(loop).__name__}'")
         self._local._loop = loop
@@ -790,34 +788,36 @@ def _init_event_loop_policy():
     global _event_loop_policy
     with _lock:
         if _event_loop_policy is None:  # pragma: no branch
-            from . import DefaultEventLoopPolicy
-            _event_loop_policy = DefaultEventLoopPolicy()
+            if sys.platform == 'win32':
+                from .windows_events import _DefaultEventLoopPolicy
+            else:
+                from .unix_events import _DefaultEventLoopPolicy
+            _event_loop_policy = _DefaultEventLoopPolicy()
 
 
-def get_event_loop_policy():
+def _get_event_loop_policy():
     """Get the current event loop policy."""
     if _event_loop_policy is None:
         _init_event_loop_policy()
     return _event_loop_policy
 
+def get_event_loop_policy():
+    warnings._deprecated('asyncio.get_event_loop_policy', remove=(3, 16))
+    return _get_event_loop_policy()
 
 def _set_event_loop_policy(policy):
     """Set the current event loop policy.
 
     If policy is None, the default policy is restored."""
     global _event_loop_policy
-    if policy is not None and not isinstance(policy, AbstractEventLoopPolicy):
+    if policy is not None and not isinstance(policy, _AbstractEventLoopPolicy):
         raise TypeError(f"policy must be an instance of AbstractEventLoopPolicy or None, not '{type(policy).__name__}'")
     _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."""
+    warnings._deprecated('asyncio.set_event_loop_policy', remove=(3,16))
     _set_event_loop_policy(policy)
 
-
 def get_event_loop():
     """Return an asyncio event loop.
 
@@ -831,28 +831,17 @@ def get_event_loop():
     current_loop = _get_running_loop()
     if current_loop is not None:
         return current_loop
-    return get_event_loop_policy().get_event_loop()
+    return _get_event_loop_policy().get_event_loop()
 
 
 def set_event_loop(loop):
     """Equivalent to calling get_event_loop_policy().set_event_loop(loop)."""
-    get_event_loop_policy().set_event_loop(loop)
+    _get_event_loop_policy().set_event_loop(loop)
 
 
 def new_event_loop():
     """Equivalent to calling get_event_loop_policy().new_event_loop()."""
-    return get_event_loop_policy().new_event_loop()
-
-
-def get_child_watcher():
-    """Equivalent to calling get_event_loop_policy().get_child_watcher()."""
-    return get_event_loop_policy().get_child_watcher()
-
-
-def set_child_watcher(watcher):
-    """Equivalent to calling
-    get_event_loop_policy().set_child_watcher(watcher)."""
-    return get_event_loop_policy().set_child_watcher(watcher)
+    return _get_event_loop_policy().new_event_loop()
 
 
 # Alias pure-Python implementations for testing purposes.
@@ -882,7 +871,7 @@ def set_child_watcher(watcher):
     def on_fork():
         # Reset the loop and wakeupfd in the forked child process.
         if _event_loop_policy is not None:
-            _event_loop_policy._local = BaseDefaultEventLoopPolicy._Local()
+            _event_loop_policy._local = _BaseDefaultEventLoopPolicy._Local()
         _set_running_loop(None)
         signal.set_wakeup_fd(-1)
 
diff --git a/Lib/asyncio/futures.py b/Lib/asyncio/futures.py
index 51932639097..d1df6707302 100644
--- a/Lib/asyncio/futures.py
+++ b/Lib/asyncio/futures.py
@@ -2,6 +2,7 @@
 
 __all__ = (
     'Future', 'wrap_future', 'isfuture',
+    'future_add_to_awaited_by', 'future_discard_from_awaited_by',
 )
 
 import concurrent.futures
@@ -43,7 +44,6 @@ class Future:
     - This class is not compatible with the wait() and as_completed()
       methods in the concurrent.futures package.
 
-    (In Python 3.4 or later we may be able to unify the implementations.)
     """
 
     # Class variables serving as defaults for instance variables.
@@ -61,12 +61,15 @@ class Future:
     #   the Future protocol (i.e. is intended to be duck-type compatible).
     #   The value must also be not-None, to enable a subclass to declare
     #   that it is not compatible by setting this to None.
-    # - It is set by __iter__() below so that Task._step() can tell
+    # - It is set by __iter__() below so that Task.__step() can tell
     #   the difference between
-    #   `await Future()` or`yield from Future()` (correct) vs.
+    #   `await Future()` or `yield from Future()` (correct) vs.
     #   `yield Future()` (incorrect).
     _asyncio_future_blocking = False
 
+    # Used by the capture_call_stack() API.
+    __asyncio_awaited_by = None
+
     __log_traceback = False
 
     def __init__(self, *, loop=None):
@@ -116,6 +119,12 @@ def _log_traceback(self, val):
             raise ValueError('_log_traceback can only be set to False')
         self.__log_traceback = False
 
+    @property
+    def _asyncio_awaited_by(self):
+        if self.__asyncio_awaited_by is None:
+            return None
+        return frozenset(self.__asyncio_awaited_by)
+
     def get_loop(self):
         """Return the event loop the Future is bound to."""
         loop = self._loop
@@ -416,6 +425,49 @@ def wrap_future(future, *, loop=None):
     return new_future
 
 
+def future_add_to_awaited_by(fut, waiter, /):
+    """Record that `fut` is awaited on by `waiter`."""
+    # For the sake of keeping the implementation minimal and assuming
+    # that most of asyncio users use the built-in Futures and Tasks
+    # (or their subclasses), we only support native Future objects
+    # and their subclasses.
+    #
+    # Longer version: tracking requires storing the caller-callee
+    # dependency somewhere. One obvious choice is to store that
+    # information right in the future itself in a dedicated attribute.
+    # This means that we'd have to require all duck-type compatible
+    # futures to implement a specific attribute used by asyncio for
+    # the book keeping. Another solution would be to store that in
+    # a global dictionary. The downside here is that that would create
+    # strong references and any scenario where the "add" call isn't
+    # followed by a "discard" call would lead to a memory leak.
+    # Using WeakDict would resolve that issue, but would complicate
+    # the C code (_asynciomodule.c). The bottom line here is that
+    # it's not clear that all this work would be worth the effort.
+    #
+    # Note that there's an accelerated version of this function
+    # shadowing this implementation later in this file.
+    if isinstance(fut, _PyFuture) and isinstance(waiter, _PyFuture):
+        if fut._Future__asyncio_awaited_by is None:
+            fut._Future__asyncio_awaited_by = set()
+        fut._Future__asyncio_awaited_by.add(waiter)
+
+
+def future_discard_from_awaited_by(fut, waiter, /):
+    """Record that `fut` is no longer awaited on by `waiter`."""
+    # See the comment in "future_add_to_awaited_by()" body for
+    # details on implementation.
+    #
+    # Note that there's an accelerated version of this function
+    # shadowing this implementation later in this file.
+    if isinstance(fut, _PyFuture) and isinstance(waiter, _PyFuture):
+        if fut._Future__asyncio_awaited_by is not None:
+            fut._Future__asyncio_awaited_by.discard(waiter)
+
+
+_py_future_add_to_awaited_by = future_add_to_awaited_by
+_py_future_discard_from_awaited_by = future_discard_from_awaited_by
+
 try:
     import _asyncio
 except ImportError:
@@ -423,3 +475,7 @@ def wrap_future(future, *, loop=None):
 else:
     # _CFuture is needed for tests.
     Future = _CFuture = _asyncio.Future
+    future_add_to_awaited_by = _asyncio.future_add_to_awaited_by
+    future_discard_from_awaited_by = _asyncio.future_discard_from_awaited_by
+    _c_future_add_to_awaited_by = future_add_to_awaited_by
+    _c_future_discard_from_awaited_by = future_discard_from_awaited_by
diff --git a/Lib/asyncio/graph.py b/Lib/asyncio/graph.py
new file mode 100644
index 00000000000..b5bfeb1630a
--- /dev/null
+++ b/Lib/asyncio/graph.py
@@ -0,0 +1,276 @@
+"""Introspection utils for tasks call graphs."""
+
+import dataclasses
+import io
+import sys
+import types
+
+from . import events
+from . import futures
+from . import tasks
+
+__all__ = (
+    'capture_call_graph',
+    'format_call_graph',
+    'print_call_graph',
+    'FrameCallGraphEntry',
+    'FutureCallGraph',
+)
+
+# Sadly, we can't re-use the traceback module's datastructures as those
+# are tailored for error reporting, whereas we need to represent an
+# async call graph.
+#
+# Going with pretty verbose names as we'd like to export them to the
+# top level asyncio namespace, and want to avoid future name clashes.
+
+
+@dataclasses.dataclass(frozen=True, slots=True)
+class FrameCallGraphEntry:
+    frame: types.FrameType
+
+
+@dataclasses.dataclass(frozen=True, slots=True)
+class FutureCallGraph:
+    future: futures.Future
+    call_stack: tuple["FrameCallGraphEntry", ...]
+    awaited_by: tuple["FutureCallGraph", ...]
+
+
+def _build_graph_for_future(
+    future: futures.Future,
+    *,
+    limit: int | None = None,
+) -> FutureCallGraph:
+    if not isinstance(future, futures.Future):
+        raise TypeError(
+            f"{future!r} object does not appear to be compatible "
+            f"with asyncio.Future"
+        )
+
+    coro = None
+    if get_coro := getattr(future, 'get_coro', None):
+        coro = get_coro() if limit != 0 else None
+
+    st: list[FrameCallGraphEntry] = []
+    awaited_by: list[FutureCallGraph] = []
+
+    while coro is not None:
+        if hasattr(coro, 'cr_await'):
+            # A native coroutine or duck-type compatible iterator
+            st.append(FrameCallGraphEntry(coro.cr_frame))
+            coro = coro.cr_await
+        elif hasattr(coro, 'ag_await'):
+            # A native async generator or duck-type compatible iterator
+            st.append(FrameCallGraphEntry(coro.cr_frame))
+            coro = coro.ag_await
+        else:
+            break
+
+    if future._asyncio_awaited_by:
+        for parent in future._asyncio_awaited_by:
+            awaited_by.append(_build_graph_for_future(parent, limit=limit))
+
+    if limit is not None:
+        if limit > 0:
+            st = st[:limit]
+        elif limit < 0:
+            st = st[limit:]
+    st.reverse()
+    return FutureCallGraph(future, tuple(st), tuple(awaited_by))
+
+
+def capture_call_graph(
+    future: futures.Future | None = None,
+    /,
+    *,
+    depth: int = 1,
+    limit: int | None = None,
+) -> FutureCallGraph | None:
+    """Capture the async call graph for the current task or the provided Future.
+
+    The graph is represented with three data structures:
+
+    * FutureCallGraph(future, call_stack, awaited_by)
+
+      Where 'future' is an instance of asyncio.Future or asyncio.Task.
+
+      'call_stack' is a tuple of FrameGraphEntry objects.
+
+      'awaited_by' is a tuple of FutureCallGraph objects.
+
+    * FrameCallGraphEntry(frame)
+
+      Where 'frame' is a frame object of a regular Python function
+      in the call stack.
+
+    Receives an optional 'future' argument. If not passed,
+    the current task will be used. If there's no current task, the function
+    returns None.
+
+    If "capture_call_graph()" is introspecting *the current task*, the
+    optional keyword-only 'depth' argument can be used to skip the specified
+    number of frames from top of the stack.
+
+    If the optional keyword-only 'limit' argument is provided, each call stack
+    in the resulting graph is truncated to include at most ``abs(limit)``
+    entries. If 'limit' is positive, the entries left are the closest to
+    the invocation point. If 'limit' is negative, the topmost entries are
+    left. If 'limit' is omitted or None, all entries are present.
+    If 'limit' is 0, the call stack is not captured at all, only
+    "awaited by" information is present.
+    """
+
+    loop = events._get_running_loop()
+
+    if future is not None:
+        # Check if we're in a context of a running event loop;
+        # if yes - check if the passed future is the currently
+        # running task or not.
+        if loop is None or future is not tasks.current_task(loop=loop):
+            return _build_graph_for_future(future, limit=limit)
+        # else: future is the current task, move on.
+    else:
+        if loop is None:
+            raise RuntimeError(
+                'capture_call_graph() is called outside of a running '
+                'event loop and no *future* to introspect was provided')
+        future = tasks.current_task(loop=loop)
+
+    if future is None:
+        # This isn't a generic call stack introspection utility. If we
+        # can't determine the current task and none was provided, we
+        # just return.
+        return None
+
+    if not isinstance(future, futures.Future):
+        raise TypeError(
+            f"{future!r} object does not appear to be compatible "
+            f"with asyncio.Future"
+        )
+
+    call_stack: list[FrameCallGraphEntry] = []
+
+    f = sys._getframe(depth) if limit != 0 else None
+    try:
+        while f is not None:
+            is_async = f.f_generator is not None
+            call_stack.append(FrameCallGraphEntry(f))
+
+            if is_async:
+                if f.f_back is not None and f.f_back.f_generator is None:
+                    # We've reached the bottom of the coroutine stack, which
+                    # must be the Task that runs it.
+                    break
+
+            f = f.f_back
+    finally:
+        del f
+
+    awaited_by = []
+    if future._asyncio_awaited_by:
+        for parent in future._asyncio_awaited_by:
+            awaited_by.append(_build_graph_for_future(parent, limit=limit))
+
+    if limit is not None:
+        limit *= -1
+        if limit > 0:
+            call_stack = call_stack[:limit]
+        elif limit < 0:
+            call_stack = call_stack[limit:]
+
+    return FutureCallGraph(future, tuple(call_stack), tuple(awaited_by))
+
+
+def format_call_graph(
+    future: futures.Future | None = None,
+    /,
+    *,
+    depth: int = 1,
+    limit: int | None = None,
+) -> str:
+    """Return the async call graph as a string for `future`.
+
+    If `future` is not provided, format the call graph for the current task.
+    """
+
+    def render_level(st: FutureCallGraph, buf: list[str], level: int) -> None:
+        def add_line(line: str) -> None:
+            buf.append(level * '    ' + line)
+
+        if isinstance(st.future, tasks.Task):
+            add_line(
+                f'* Task(name={st.future.get_name()!r}, id={id(st.future):#x})'
+            )
+        else:
+            add_line(
+                f'* Future(id={id(st.future):#x})'
+            )
+
+        if st.call_stack:
+            add_line(
+                f'  + Call stack:'
+            )
+            for ste in st.call_stack:
+                f = ste.frame
+
+                if f.f_generator is None:
+                    f = ste.frame
+                    add_line(
+                        f'  |   File {f.f_code.co_filename!r},'
+                        f' line {f.f_lineno}, in'
+                        f' {f.f_code.co_qualname}()'
+                    )
+                else:
+                    c = f.f_generator
+
+                    try:
+                        f = c.cr_frame
+                        code = c.cr_code
+                        tag = 'async'
+                    except AttributeError:
+                        try:
+                            f = c.ag_frame
+                            code = c.ag_code
+                            tag = 'async generator'
+                        except AttributeError:
+                            f = c.gi_frame
+                            code = c.gi_code
+                            tag = 'generator'
+
+                    add_line(
+                        f'  |   File {f.f_code.co_filename!r},'
+                        f' line {f.f_lineno}, in'
+                        f' {tag} {code.co_qualname}()'
+                    )
+
+        if st.awaited_by:
+            add_line(
+                f'  + Awaited by:'
+            )
+            for fut in st.awaited_by:
+                render_level(fut, buf, level + 1)
+
+    graph = capture_call_graph(future, depth=depth + 1, limit=limit)
+    if graph is None:
+        return ""
+
+    buf: list[str] = []
+    try:
+        render_level(graph, buf, 0)
+    finally:
+        # 'graph' has references to frames so we should
+        # make sure it's GC'ed as soon as we don't need it.
+        del graph
+    return '\n'.join(buf)
+
+def print_call_graph(
+    future: futures.Future | None = None,
+    /,
+    *,
+    file: io.Writer[str] | None = None,
+    depth: int = 1,
+    limit: int | None = None,
+) -> None:
+    """Print the async call graph for the current task or the provided Future."""
+    print(format_call_graph(future, depth=depth, limit=limit), file=file)
diff --git a/Lib/asyncio/locks.py b/Lib/asyncio/locks.py
index 3df4c693a91..fa3a94764b5 100644
--- a/Lib/asyncio/locks.py
+++ b/Lib/asyncio/locks.py
@@ -341,9 +341,9 @@ def _notify(self, n):
                 fut.set_result(False)
 
     def notify_all(self):
-        """Wake up all threads waiting on this condition. This method acts
-        like notify(), but wakes up all waiting threads instead of one. If the
-        calling thread has not acquired the lock when this method is called,
+        """Wake up all tasks waiting on this condition. This method acts
+        like notify(), but wakes up all waiting tasks instead of one. If the
+        calling task has not acquired the lock when this method is called,
         a RuntimeError is raised.
         """
         self.notify(len(self._waiters))
diff --git a/Lib/asyncio/runners.py b/Lib/asyncio/runners.py
index 102ae78021b..ba37e003a65 100644
--- a/Lib/asyncio/runners.py
+++ b/Lib/asyncio/runners.py
@@ -3,6 +3,7 @@
 import contextvars
 import enum
 import functools
+import inspect
 import threading
 import signal
 from . import coroutines
@@ -84,10 +85,7 @@ def get_loop(self):
         return self._loop
 
     def run(self, coro, *, context=None):
-        """Run a coroutine inside the embedded event loop."""
-        if not coroutines.iscoroutine(coro):
-            raise ValueError("a coroutine was expected, got {!r}".format(coro))
-
+        """Run code in the embedded event loop."""
         if events._get_running_loop() is not None:
             # fail fast with short traceback
             raise RuntimeError(
@@ -95,8 +93,19 @@ def run(self, coro, *, context=None):
 
         self._lazy_init()
 
+        if not coroutines.iscoroutine(coro):
+            if inspect.isawaitable(coro):
+                async def _wrap_awaitable(awaitable):
+                    return await awaitable
+
+                coro = _wrap_awaitable(coro)
+            else:
+                raise TypeError('An asyncio.Future, a coroutine or an '
+                                'awaitable is required')
+
         if context is None:
             context = self._context
+
         task = self._loop.create_task(coro, context=context)
 
         if (threading.current_thread() is threading.main_thread()
diff --git a/Lib/asyncio/selector_events.py b/Lib/asyncio/selector_events.py
index 8701467d413..ff7e16df3c6 100644
--- a/Lib/asyncio/selector_events.py
+++ b/Lib/asyncio/selector_events.py
@@ -173,16 +173,20 @@ def _accept_connection(
         # listening socket has triggered an EVENT_READ. There may be multiple
         # connections waiting for an .accept() so it is called in a loop.
         # See https://bugs.python.org/issue27906 for more details.
-        for _ in range(backlog):
+        for _ in range(backlog + 1):
             try:
                 conn, addr = sock.accept()
                 if self._debug:
                     logger.debug("%r got a new connection from %r: %r",
                                  server, addr, conn)
                 conn.setblocking(False)
-            except (BlockingIOError, InterruptedError, ConnectionAbortedError):
-                # Early exit because the socket accept buffer is empty.
-                return None
+            except ConnectionAbortedError:
+                # Discard connections that were aborted before accept().
+                continue
+            except (BlockingIOError, InterruptedError):
+                # Early exit because of a signal or
+                # the socket accept buffer is empty.
+                return
             except OSError as exc:
                 # There's nowhere to send the error, so just log it.
                 if exc.errno in (errno.EMFILE, errno.ENFILE,
diff --git a/Lib/asyncio/staggered.py b/Lib/asyncio/staggered.py
index 0afed64fdf9..2ad65d8648e 100644
--- a/Lib/asyncio/staggered.py
+++ b/Lib/asyncio/staggered.py
@@ -8,6 +8,7 @@
 from . import exceptions as exceptions_mod
 from . import locks
 from . import tasks
+from . import futures
 
 
 async def staggered_race(coro_fns, delay, *, loop=None):
@@ -63,6 +64,7 @@ async def staggered_race(coro_fns, delay, *, loop=None):
     """
     # TODO: when we have aiter() and anext(), allow async iterables in coro_fns.
     loop = loop or events.get_running_loop()
+    parent_task = tasks.current_task(loop)
     enum_coro_fns = enumerate(coro_fns)
     winner_result = None
     winner_index = None
@@ -73,6 +75,7 @@ async def staggered_race(coro_fns, delay, *, loop=None):
 
     def task_done(task):
         running_tasks.discard(task)
+        futures.future_discard_from_awaited_by(task, parent_task)
         if (
             on_completed_fut is not None
             and not on_completed_fut.done()
@@ -110,6 +113,7 @@ async def run_one_coro(ok_to_start, previous_failed) -> None:
         this_failed = locks.Event()
         next_ok_to_start = locks.Event()
         next_task = loop.create_task(run_one_coro(next_ok_to_start, this_failed))
+        futures.future_add_to_awaited_by(next_task, parent_task)
         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
@@ -148,6 +152,7 @@ async def run_one_coro(ok_to_start, previous_failed) -> None:
     try:
         ok_to_start = locks.Event()
         first_task = loop.create_task(run_one_coro(ok_to_start, None))
+        futures.future_add_to_awaited_by(first_task, parent_task)
         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.
@@ -171,4 +176,4 @@ async def run_one_coro(ok_to_start, previous_failed) -> None:
             raise propagate_cancellation_error
         return winner_result, winner_index, exceptions
     finally:
-        del exceptions, propagate_cancellation_error, unhandled_exceptions
+        del exceptions, propagate_cancellation_error, unhandled_exceptions, parent_task
diff --git a/Lib/asyncio/taskgroups.py b/Lib/asyncio/taskgroups.py
index 8fda6c8d55e..00e8f6d5d1a 100644
--- a/Lib/asyncio/taskgroups.py
+++ b/Lib/asyncio/taskgroups.py
@@ -6,6 +6,7 @@
 
 from . import events
 from . import exceptions
+from . import futures
 from . import tasks
 
 
@@ -178,7 +179,7 @@ async def _aexit(self, et, exc):
                 exc = None
 
 
-    def create_task(self, coro, *, name=None, context=None):
+    def create_task(self, coro, **kwargs):
         """Create a new task in this group and return it.
 
         Similar to `asyncio.create_task`.
@@ -192,10 +193,9 @@ def create_task(self, coro, *, name=None, context=None):
         if self._aborting:
             coro.close()
             raise RuntimeError(f"TaskGroup {self!r} is shutting down")
-        if context is None:
-            task = self._loop.create_task(coro, name=name)
-        else:
-            task = self._loop.create_task(coro, name=name, context=context)
+        task = self._loop.create_task(coro, **kwargs)
+
+        futures.future_add_to_awaited_by(task, self._parent_task)
 
         # Always schedule the done callback even if the task is
         # already done (e.g. if the coro was able to complete eagerly),
@@ -228,6 +228,8 @@ def _abort(self):
     def _on_task_done(self, task):
         self._tasks.discard(task)
 
+        futures.future_discard_from_awaited_by(task, self._parent_task)
+
         if self._on_completed_fut is not None and not self._tasks:
             if not self._on_completed_fut.done():
                 self._on_completed_fut.set_result(True)
diff --git a/Lib/asyncio/tasks.py b/Lib/asyncio/tasks.py
index dadcb5b5f36..fbd5c39a7c5 100644
--- a/Lib/asyncio/tasks.py
+++ b/Lib/asyncio/tasks.py
@@ -48,23 +48,8 @@ def all_tasks(loop=None):
     # capturing the set of eager tasks first, so if an eager task "graduates"
     # to a regular task in another thread, we don't risk missing it.
     eager_tasks = list(_eager_tasks)
-    # Looping over the WeakSet isn't safe as it can be updated from another
-    # thread, therefore we cast it to list prior to filtering. The list cast
-    # itself requires iteration, so we repeat it several times ignoring
-    # RuntimeErrors (which are not very likely to occur).
-    # See issues 34970 and 36607 for details.
-    scheduled_tasks = None
-    i = 0
-    while True:
-        try:
-            scheduled_tasks = list(_scheduled_tasks)
-        except RuntimeError:
-            i += 1
-            if i >= 1000:
-                raise
-        else:
-            break
-    return {t for t in itertools.chain(scheduled_tasks, eager_tasks)
+
+    return {t for t in itertools.chain(_scheduled_tasks, eager_tasks)
             if futures._get_loop(t) is loop and not t.done()}
 
 
@@ -125,7 +110,7 @@ def __init__(self, coro, *, loop=None, name=None, context=None,
             self.__eager_start()
         else:
             self._loop.call_soon(self.__step, context=self._context)
-            _register_task(self)
+            _py_register_task(self)
 
     def __del__(self):
         if self._state == futures._PENDING and self._log_destroy_pending:
@@ -260,39 +245,39 @@ def uncancel(self):
         return self._num_cancels_requested
 
     def __eager_start(self):
-        prev_task = _swap_current_task(self._loop, self)
+        prev_task = _py_swap_current_task(self._loop, self)
         try:
-            _register_eager_task(self)
+            _py_register_eager_task(self)
             try:
                 self._context.run(self.__step_run_and_handle_result, None)
             finally:
-                _unregister_eager_task(self)
+                _py_unregister_eager_task(self)
         finally:
             try:
-                curtask = _swap_current_task(self._loop, prev_task)
+                curtask = _py_swap_current_task(self._loop, prev_task)
                 assert curtask is self
             finally:
                 if self.done():
                     self._coro = None
                     self = None  # Needed to break cycles when an exception occurs.
                 else:
-                    _register_task(self)
+                    _py_register_task(self)
 
     def __step(self, exc=None):
         if self.done():
             raise exceptions.InvalidStateError(
-                f'_step(): already done: {self!r}, {exc!r}')
+                f'__step(): already done: {self!r}, {exc!r}')
         if self._must_cancel:
             if not isinstance(exc, exceptions.CancelledError):
                 exc = self._make_cancelled_error()
             self._must_cancel = False
         self._fut_waiter = None
 
-        _enter_task(self._loop, self)
+        _py_enter_task(self._loop, self)
         try:
             self.__step_run_and_handle_result(exc)
         finally:
-            _leave_task(self._loop, self)
+            _py_leave_task(self._loop, self)
             self = None  # Needed to break cycles when an exception occurs.
 
     def __step_run_and_handle_result(self, exc):
@@ -337,6 +322,7 @@ def __step_run_and_handle_result(self, exc):
                         self._loop.call_soon(
                             self.__step, new_exc, context=self._context)
                     else:
+                        futures.future_add_to_awaited_by(result, self)
                         result._asyncio_future_blocking = False
                         result.add_done_callback(
                             self.__wakeup, context=self._context)
@@ -371,6 +357,7 @@ def __step_run_and_handle_result(self, exc):
             self = None  # Needed to break cycles when an exception occurs.
 
     def __wakeup(self, future):
+        futures.future_discard_from_awaited_by(future, self)
         try:
             future.result()
         except BaseException as exc:
@@ -379,7 +366,7 @@ def __wakeup(self, future):
         else:
             # Don't pass the value of `future.result()` explicitly,
             # as `Future.__iter__` and `Future.__await__` don't need it.
-            # If we call `_step(value, None)` instead of `_step()`,
+            # If we call `__step(value, None)` instead of `__step()`,
             # Python eval loop would use `.send(value)` method call,
             # instead of `__next__()`, which is slower for futures
             # that return non-generator iterators from their `__iter__`.
@@ -399,19 +386,13 @@ def __wakeup(self, future):
     Task = _CTask = _asyncio.Task
 
 
-def create_task(coro, *, name=None, context=None):
+def create_task(coro, **kwargs):
     """Schedule the execution of a coroutine object in a spawn task.
 
     Return a Task object.
     """
     loop = events.get_running_loop()
-    if context is None:
-        # Use legacy API if context is not needed
-        task = loop.create_task(coro, name=name)
-    else:
-        task = loop.create_task(coro, name=name, context=context)
-
-    return task
+    return loop.create_task(coro, **kwargs)
 
 
 # wait() and as_completed() similar to those in PEP 3148.
@@ -517,6 +498,7 @@ async def _wait(fs, timeout, return_when, loop):
     if timeout is not None:
         timeout_handle = loop.call_later(timeout, _release_waiter, waiter)
     counter = len(fs)
+    cur_task = current_task()
 
     def _on_completion(f):
         nonlocal counter
@@ -529,9 +511,11 @@ def _on_completion(f):
                 timeout_handle.cancel()
             if not waiter.done():
                 waiter.set_result(None)
+        futures.future_discard_from_awaited_by(f, cur_task)
 
     for f in fs:
         f.add_done_callback(_on_completion)
+        futures.future_add_to_awaited_by(f, cur_task)
 
     try:
         await waiter
@@ -817,10 +801,19 @@ def gather(*coros_or_futures, return_exceptions=False):
         outer.set_result([])
         return outer
 
-    def _done_callback(fut):
+    loop = events._get_running_loop()
+    if loop is not None:
+        cur_task = current_task(loop)
+    else:
+        cur_task = None
+
+    def _done_callback(fut, cur_task=cur_task):
         nonlocal nfinished
         nfinished += 1
 
+        if cur_task is not None:
+            futures.future_discard_from_awaited_by(fut, cur_task)
+
         if outer is None or outer.done():
             if not fut.cancelled():
                 # Mark exception retrieved.
@@ -877,7 +870,6 @@ def _done_callback(fut):
     nfuts = 0
     nfinished = 0
     done_futs = []
-    loop = None
     outer = None  # bpo-46672
     for arg in coros_or_futures:
         if arg not in arg_to_fut:
@@ -890,12 +882,13 @@ def _done_callback(fut):
                 # can't control it, disable the "destroy pending task"
                 # warning.
                 fut._log_destroy_pending = False
-
             nfuts += 1
             arg_to_fut[arg] = fut
             if fut.done():
                 done_futs.append(fut)
             else:
+                if cur_task is not None:
+                    futures.future_add_to_awaited_by(fut, cur_task)
                 fut.add_done_callback(_done_callback)
 
         else:
@@ -915,6 +908,25 @@ def _done_callback(fut):
     return outer
 
 
+def _log_on_exception(fut):
+    if fut.cancelled():
+        return
+
+    exc = fut.exception()
+    if exc is None:
+        return
+
+    context = {
+        'message':
+        f'{exc.__class__.__name__} exception in shielded future',
+        'exception': exc,
+        'future': fut,
+    }
+    if fut._source_traceback:
+        context['source_traceback'] = fut._source_traceback
+    fut._loop.call_exception_handler(context)
+
+
 def shield(arg):
     """Wait for a future, shielding it from cancellation.
 
@@ -955,11 +967,16 @@ def shield(arg):
     loop = futures._get_loop(inner)
     outer = loop.create_future()
 
+    if loop is not None and (cur_task := current_task(loop)) is not None:
+        futures.future_add_to_awaited_by(inner, cur_task)
+    else:
+        cur_task = None
+
+    def _clear_awaited_by_callback(inner):
+        futures.future_discard_from_awaited_by(inner, cur_task)
+
     def _inner_done_callback(inner):
         if outer.cancelled():
-            if not inner.cancelled():
-                # Mark inner's result as retrieved.
-                inner.exception()
             return
 
         if inner.cancelled():
@@ -971,10 +988,16 @@ def _inner_done_callback(inner):
             else:
                 outer.set_result(inner.result())
 
-
     def _outer_done_callback(outer):
         if not inner.done():
             inner.remove_done_callback(_inner_done_callback)
+            # Keep only one callback to log on cancel
+            inner.remove_done_callback(_log_on_exception)
+            inner.add_done_callback(_log_on_exception)
+
+    if cur_task is not None:
+        inner.add_done_callback(_clear_awaited_by_callback)
+
 
     inner.add_done_callback(_inner_done_callback)
     outer.add_done_callback(_outer_done_callback)
@@ -1023,9 +1046,9 @@ def create_eager_task_factory(custom_task_constructor):
         used. E.g. `loop.set_task_factory(asyncio.eager_task_factory)`.
         """
 
-    def factory(loop, coro, *, name=None, context=None):
+    def factory(loop, coro, *, eager_start=True, **kwargs):
         return custom_task_constructor(
-            coro, loop=loop, name=name, context=context, eager_start=True)
+            coro, loop=loop, eager_start=eager_start, **kwargs)
 
     return factory
 
@@ -1097,14 +1120,13 @@ def _unregister_eager_task(task):
 _py_enter_task = _enter_task
 _py_leave_task = _leave_task
 _py_swap_current_task = _swap_current_task
-
+_py_all_tasks = all_tasks
 
 try:
     from _asyncio import (_register_task, _register_eager_task,
                           _unregister_task, _unregister_eager_task,
                           _enter_task, _leave_task, _swap_current_task,
-                          _scheduled_tasks, _eager_tasks, _current_tasks,
-                          current_task)
+                          current_task, all_tasks)
 except ImportError:
     pass
 else:
@@ -1116,3 +1138,4 @@ def _unregister_eager_task(task):
     _c_enter_task = _enter_task
     _c_leave_task = _leave_task
     _c_swap_current_task = _swap_current_task
+    _c_all_tasks = all_tasks
diff --git a/Lib/asyncio/timeouts.py b/Lib/asyncio/timeouts.py
index e6f5100691d..09342dc7c13 100644
--- a/Lib/asyncio/timeouts.py
+++ b/Lib/asyncio/timeouts.py
@@ -1,7 +1,6 @@
 import enum
 
 from types import TracebackType
-from typing import final, Optional, Type
 
 from . import events
 from . import exceptions
@@ -23,14 +22,13 @@ class _State(enum.Enum):
     EXITED = "finished"
 
 
-@final
 class Timeout:
     """Asynchronous context manager for cancelling overdue coroutines.
 
     Use `timeout()` or `timeout_at()` rather than instantiating this class directly.
     """
 
-    def __init__(self, when: Optional[float]) -> None:
+    def __init__(self, when: float | None) -> None:
         """Schedule a timeout that will trigger at a given loop time.
 
         - If `when` is `None`, the timeout will never trigger.
@@ -39,15 +37,15 @@ def __init__(self, when: Optional[float]) -> None:
         """
         self._state = _State.CREATED
 
-        self._timeout_handler: Optional[events.TimerHandle] = None
-        self._task: Optional[tasks.Task] = None
+        self._timeout_handler: events.TimerHandle | None = None
+        self._task: tasks.Task | None = None
         self._when = when
 
-    def when(self) -> Optional[float]:
+    def when(self) -> float | None:
         """Return the current deadline."""
         return self._when
 
-    def reschedule(self, when: Optional[float]) -> None:
+    def reschedule(self, when: float | None) -> None:
         """Reschedule the timeout."""
         if self._state is not _State.ENTERED:
             if self._state is _State.CREATED:
@@ -96,10 +94,10 @@ async def __aenter__(self) -> "Timeout":
 
     async def __aexit__(
         self,
-        exc_type: Optional[Type[BaseException]],
-        exc_val: Optional[BaseException],
-        exc_tb: Optional[TracebackType],
-    ) -> Optional[bool]:
+        exc_type: type[BaseException] | None,
+        exc_val: BaseException | None,
+        exc_tb: TracebackType | None,
+    ) -> bool | None:
         assert self._state in (_State.ENTERED, _State.EXPIRING)
 
         if self._timeout_handler is not None:
@@ -142,7 +140,7 @@ def _insert_timeout_error(exc_val: BaseException) -> None:
             exc_val = exc_val.__context__
 
 
-def timeout(delay: Optional[float]) -> Timeout:
+def timeout(delay: float | None) -> Timeout:
     """Timeout async context manager.
 
     Useful in cases when you want to apply timeout logic around block
@@ -162,7 +160,7 @@ def timeout(delay: Optional[float]) -> Timeout:
     return Timeout(loop.time() + delay if delay is not None else None)
 
 
-def timeout_at(when: Optional[float]) -> Timeout:
+def timeout_at(when: float | None) -> Timeout:
     """Schedule the timeout at absolute time.
 
     Like timeout() but argument gives absolute time in the same clock system
diff --git a/Lib/asyncio/tools.py b/Lib/asyncio/tools.py
new file mode 100644
index 00000000000..f39e11fdd51
--- /dev/null
+++ b/Lib/asyncio/tools.py
@@ -0,0 +1,276 @@
+"""Tools to analyze tasks running in asyncio programs."""
+
+from collections import defaultdict, namedtuple
+from itertools import count
+from enum import Enum
+import sys
+from _remote_debugging import RemoteUnwinder, FrameInfo
+
+class NodeType(Enum):
+    COROUTINE = 1
+    TASK = 2
+
+
+class CycleFoundException(Exception):
+    """Raised when there is a cycle when drawing the call tree."""
+    def __init__(
+            self,
+            cycles: list[list[int]],
+            id2name: dict[int, str],
+        ) -> None:
+        super().__init__(cycles, id2name)
+        self.cycles = cycles
+        self.id2name = id2name
+
+
+
+# ─── indexing helpers ───────────────────────────────────────────
+def _format_stack_entry(elem: str|FrameInfo) -> str:
+    if not isinstance(elem, str):
+        if elem.lineno == 0 and elem.filename == "":
+            return f"{elem.funcname}"
+        else:
+            return f"{elem.funcname} {elem.filename}:{elem.lineno}"
+    return elem
+
+
+def _index(result):
+    id2name, awaits, task_stacks = {}, [], {}
+    for awaited_info in result:
+        for task_info in awaited_info.awaited_by:
+            task_id = task_info.task_id
+            task_name = task_info.task_name
+            id2name[task_id] = task_name
+
+            # Store the internal coroutine stack for this task
+            if task_info.coroutine_stack:
+                for coro_info in task_info.coroutine_stack:
+                    call_stack = coro_info.call_stack
+                    internal_stack = [_format_stack_entry(frame) for frame in call_stack]
+                    task_stacks[task_id] = internal_stack
+
+            # Add the awaited_by relationships (external dependencies)
+            if task_info.awaited_by:
+                for coro_info in task_info.awaited_by:
+                    call_stack = coro_info.call_stack
+                    parent_task_id = coro_info.task_name
+                    stack = [_format_stack_entry(frame) for frame in call_stack]
+                    awaits.append((parent_task_id, stack, task_id))
+    return id2name, awaits, task_stacks
+
+
+def _build_tree(id2name, awaits, task_stacks):
+    id2label = {(NodeType.TASK, tid): name for tid, name in id2name.items()}
+    children = defaultdict(list)
+    cor_nodes = defaultdict(dict)  # Maps parent -> {frame_name: node_key}
+    next_cor_id = count(1)
+
+    def get_or_create_cor_node(parent, frame):
+        """Get existing coroutine node or create new one under parent"""
+        if frame in cor_nodes[parent]:
+            return cor_nodes[parent][frame]
+
+        node_key = (NodeType.COROUTINE, f"c{next(next_cor_id)}")
+        id2label[node_key] = frame
+        children[parent].append(node_key)
+        cor_nodes[parent][frame] = node_key
+        return node_key
+
+    # Build task dependency tree with coroutine frames
+    for parent_id, stack, child_id in awaits:
+        cur = (NodeType.TASK, parent_id)
+        for frame in reversed(stack):
+            cur = get_or_create_cor_node(cur, frame)
+
+        child_key = (NodeType.TASK, child_id)
+        if child_key not in children[cur]:
+            children[cur].append(child_key)
+
+    # Add coroutine stacks for leaf tasks
+    awaiting_tasks = {parent_id for parent_id, _, _ in awaits}
+    for task_id in id2name:
+        if task_id not in awaiting_tasks and task_id in task_stacks:
+            cur = (NodeType.TASK, task_id)
+            for frame in reversed(task_stacks[task_id]):
+                cur = get_or_create_cor_node(cur, frame)
+
+    return id2label, children
+
+
+def _roots(id2label, children):
+    all_children = {c for kids in children.values() for c in kids}
+    return [n for n in id2label if n not in all_children]
+
+# ─── detect cycles in the task-to-task graph ───────────────────────
+def _task_graph(awaits):
+    """Return {parent_task_id: {child_task_id, …}, …}."""
+    g = defaultdict(set)
+    for parent_id, _stack, child_id in awaits:
+        g[parent_id].add(child_id)
+    return g
+
+
+def _find_cycles(graph):
+    """
+    Depth-first search for back-edges.
+
+    Returns a list of cycles (each cycle is a list of task-ids) or an
+    empty list if the graph is acyclic.
+    """
+    WHITE, GREY, BLACK = 0, 1, 2
+    color = defaultdict(lambda: WHITE)
+    path, cycles = [], []
+
+    def dfs(v):
+        color[v] = GREY
+        path.append(v)
+        for w in graph.get(v, ()):
+            if color[w] == WHITE:
+                dfs(w)
+            elif color[w] == GREY:            # back-edge → cycle!
+                i = path.index(w)
+                cycles.append(path[i:] + [w])  # make a copy
+        color[v] = BLACK
+        path.pop()
+
+    for v in list(graph):
+        if color[v] == WHITE:
+            dfs(v)
+    return cycles
+
+
+# ─── PRINT TREE FUNCTION ───────────────────────────────────────
+def get_all_awaited_by(pid):
+    unwinder = RemoteUnwinder(pid)
+    return unwinder.get_all_awaited_by()
+
+
+def build_async_tree(result, task_emoji="(T)", cor_emoji=""):
+    """
+    Build a list of strings for pretty-print an async call tree.
+
+    The call tree is produced by `get_all_async_stacks()`, prefixing tasks
+    with `task_emoji` and coroutine frames with `cor_emoji`.
+    """
+    id2name, awaits, task_stacks = _index(result)
+    g = _task_graph(awaits)
+    cycles = _find_cycles(g)
+    if cycles:
+        raise CycleFoundException(cycles, id2name)
+    labels, children = _build_tree(id2name, awaits, task_stacks)
+
+    def pretty(node):
+        flag = task_emoji if node[0] == NodeType.TASK else cor_emoji
+        return f"{flag} {labels[node]}"
+
+    def render(node, prefix="", last=True, buf=None):
+        if buf is None:
+            buf = []
+        buf.append(f"{prefix}{'└── ' if last else '├── '}{pretty(node)}")
+        new_pref = prefix + ("    " if last else "│   ")
+        kids = children.get(node, [])
+        for i, kid in enumerate(kids):
+            render(kid, new_pref, i == len(kids) - 1, buf)
+        return buf
+
+    return [render(root) for root in _roots(labels, children)]
+
+
+def build_task_table(result):
+    id2name, _, _ = _index(result)
+    table = []
+
+    for awaited_info in result:
+        thread_id = awaited_info.thread_id
+        for task_info in awaited_info.awaited_by:
+            # Get task info
+            task_id = task_info.task_id
+            task_name = task_info.task_name
+
+            # Build coroutine stack string
+            frames = [frame for coro in task_info.coroutine_stack
+                     for frame in coro.call_stack]
+            coro_stack = " -> ".join(_format_stack_entry(x).split(" ")[0]
+                                   for x in frames)
+
+            # Handle tasks with no awaiters
+            if not task_info.awaited_by:
+                table.append([thread_id, hex(task_id), task_name, coro_stack,
+                            "", "", "0x0"])
+                continue
+
+            # Handle tasks with awaiters
+            for coro_info in task_info.awaited_by:
+                parent_id = coro_info.task_name
+                awaiter_frames = [_format_stack_entry(x).split(" ")[0]
+                                for x in coro_info.call_stack]
+                awaiter_chain = " -> ".join(awaiter_frames)
+                awaiter_name = id2name.get(parent_id, "Unknown")
+                parent_id_str = (hex(parent_id) if isinstance(parent_id, int)
+                               else str(parent_id))
+
+                table.append([thread_id, hex(task_id), task_name, coro_stack,
+                            awaiter_chain, awaiter_name, parent_id_str])
+
+    return table
+
+def _print_cycle_exception(exception: CycleFoundException):
+    print("ERROR: await-graph contains cycles - cannot print a tree!", file=sys.stderr)
+    print("", file=sys.stderr)
+    for c in exception.cycles:
+        inames = " → ".join(exception.id2name.get(tid, hex(tid)) for tid in c)
+        print(f"cycle: {inames}", file=sys.stderr)
+
+
+def exit_with_permission_help_text():
+    """
+    Prints a message pointing to platform-specific permission help text and exits the program.
+    This function is called when a PermissionError is encountered while trying
+    to attach to a process.
+    """
+    print(
+        "Error: The specified process cannot be attached to due to insufficient permissions.\n"
+        "See the Python documentation for details on required privileges and troubleshooting:\n"
+        "https://docs.python.org/3.14/howto/remote_debugging.html#permission-requirements\n"
+    )
+    sys.exit(1)
+
+
+def _get_awaited_by_tasks(pid: int) -> list:
+    try:
+        return get_all_awaited_by(pid)
+    except RuntimeError as e:
+        while e.__context__ is not None:
+            e = e.__context__
+        print(f"Error retrieving tasks: {e}")
+        sys.exit(1)
+    except PermissionError as e:
+        exit_with_permission_help_text()
+
+
+def display_awaited_by_tasks_table(pid: int) -> None:
+    """Build and print a table of all pending tasks under `pid`."""
+
+    tasks = _get_awaited_by_tasks(pid)
+    table = build_task_table(tasks)
+    # Print the table in a simple tabular format
+    print(
+        f"{'tid':<10} {'task id':<20} {'task name':<20} {'coroutine stack':<50} {'awaiter chain':<50} {'awaiter name':<15} {'awaiter id':<15}"
+    )
+    print("-" * 180)
+    for row in table:
+        print(f"{row[0]:<10} {row[1]:<20} {row[2]:<20} {row[3]:<50} {row[4]:<50} {row[5]:<15} {row[6]:<15}")
+
+
+def display_awaited_by_tasks_tree(pid: int) -> None:
+    """Build and print a tree of all pending tasks under `pid`."""
+
+    tasks = _get_awaited_by_tasks(pid)
+    try:
+        result = build_async_tree(tasks)
+    except CycleFoundException as e:
+        _print_cycle_exception(e)
+        sys.exit(1)
+
+    for tree in result:
+        print("\n".join(tree))
diff --git a/Lib/asyncio/unix_events.py b/Lib/asyncio/unix_events.py
index 41ccf1b78fb..1c1458127db 100644
--- a/Lib/asyncio/unix_events.py
+++ b/Lib/asyncio/unix_events.py
@@ -28,10 +28,6 @@
 
 __all__ = (
     'SelectorEventLoop',
-    'AbstractChildWatcher', 'SafeChildWatcher',
-    'FastChildWatcher', 'PidfdChildWatcher',
-    'MultiLoopChildWatcher', 'ThreadedChildWatcher',
-    'DefaultEventLoopPolicy',
     'EventLoop',
 )
 
@@ -65,6 +61,10 @@ def __init__(self, selector=None):
         super().__init__(selector)
         self._signal_handlers = {}
         self._unix_server_sockets = {}
+        if can_use_pidfd():
+            self._watcher = _PidfdChildWatcher()
+        else:
+            self._watcher = _ThreadedChildWatcher()
 
     def close(self):
         super().close()
@@ -94,7 +94,7 @@ def add_signal_handler(self, sig, callback, *args):
         Raise RuntimeError if there is a problem setting up the handler.
         """
         if (coroutines.iscoroutine(callback) or
-                coroutines.iscoroutinefunction(callback)):
+                coroutines._iscoroutinefunction(callback)):
             raise TypeError("coroutines cannot be used "
                             "with add_signal_handler()")
         self._check_signal(sig)
@@ -197,33 +197,22 @@ def _make_write_pipe_transport(self, pipe, protocol, waiter=None,
     async def _make_subprocess_transport(self, protocol, args, shell,
                                          stdin, stdout, stderr, bufsize,
                                          extra=None, **kwargs):
-        with warnings.catch_warnings():
-            warnings.simplefilter('ignore', DeprecationWarning)
-            watcher = events.get_child_watcher()
-
-        with watcher:
-            if not watcher.is_active():
-                # Check early.
-                # Raising exception before process creation
-                # prevents subprocess execution if the watcher
-                # is not ready to handle it.
-                raise RuntimeError("asyncio.get_child_watcher() is not activated, "
-                                "subprocess support is not installed.")
-            waiter = self.create_future()
-            transp = _UnixSubprocessTransport(self, protocol, args, shell,
-                                            stdin, stdout, stderr, bufsize,
-                                            waiter=waiter, extra=extra,
-                                            **kwargs)
-            watcher.add_child_handler(transp.get_pid(),
-                                    self._child_watcher_callback, transp)
-            try:
-                await waiter
-            except (SystemExit, KeyboardInterrupt):
-                raise
-            except BaseException:
-                transp.close()
-                await transp._wait()
-                raise
+        watcher = self._watcher
+        waiter = self.create_future()
+        transp = _UnixSubprocessTransport(self, protocol, args, shell,
+                                        stdin, stdout, stderr, bufsize,
+                                        waiter=waiter, extra=extra,
+                                        **kwargs)
+        watcher.add_child_handler(transp.get_pid(),
+                                self._child_watcher_callback, transp)
+        try:
+            await waiter
+        except (SystemExit, KeyboardInterrupt):
+            raise
+        except BaseException:
+            transp.close()
+            await transp._wait()
+            raise
 
         return transp
 
@@ -865,93 +854,7 @@ def _start(self, args, shell, stdin, stdout, stderr, bufsize, **kwargs):
                 stdin_w.close()
 
 
-class AbstractChildWatcher:
-    """Abstract base class for monitoring child processes.
-
-    Objects derived from this class monitor a collection of subprocesses and
-    report their termination or interruption by a signal.
-
-    New callbacks are registered with .add_child_handler(). Starting a new
-    process must be done within a 'with' block to allow the watcher to suspend
-    its activity until the new process if fully registered (this is needed to
-    prevent a race condition in some implementations).
-
-    Example:
-        with watcher:
-            proc = subprocess.Popen("sleep 1")
-            watcher.add_child_handler(proc.pid, callback)
-
-    Notes:
-        Implementations of this class must be thread-safe.
-
-        Since child watcher objects may catch the SIGCHLD signal and call
-        waitpid(-1), there should be only one active object per process.
-    """
-
-    def __init_subclass__(cls) -> None:
-        if cls.__module__ != __name__:
-            warnings._deprecated("AbstractChildWatcher",
-                             "{name!r} is deprecated as of Python 3.12 and will be "
-                             "removed in Python {remove}.",
-                              remove=(3, 14))
-
-    def add_child_handler(self, pid, callback, *args):
-        """Register a new child handler.
-
-        Arrange for callback(pid, returncode, *args) to be called when
-        process 'pid' terminates. Specifying another callback for the same
-        process replaces the previous handler.
-
-        Note: callback() must be thread-safe.
-        """
-        raise NotImplementedError()
-
-    def remove_child_handler(self, pid):
-        """Removes the handler for process 'pid'.
-
-        The function returns True if the handler was successfully removed,
-        False if there was nothing to remove."""
-
-        raise NotImplementedError()
-
-    def attach_loop(self, loop):
-        """Attach the watcher to an event loop.
-
-        If the watcher was previously attached to an event loop, then it is
-        first detached before attaching to the new loop.
-
-        Note: loop may be None.
-        """
-        raise NotImplementedError()
-
-    def close(self):
-        """Close the watcher.
-
-        This must be called to make sure that any underlying resource is freed.
-        """
-        raise NotImplementedError()
-
-    def is_active(self):
-        """Return ``True`` if the watcher is active and is used by the event loop.
-
-        Return True if the watcher is installed and ready to handle process exit
-        notifications.
-
-        """
-        raise NotImplementedError()
-
-    def __enter__(self):
-        """Enter the watcher's context and allow starting new processes
-
-        This function must return self"""
-        raise NotImplementedError()
-
-    def __exit__(self, a, b, c):
-        """Exit the watcher's context"""
-        raise NotImplementedError()
-
-
-class PidfdChildWatcher(AbstractChildWatcher):
+class _PidfdChildWatcher:
     """Child watcher implementation using Linux's pid file descriptors.
 
     This child watcher polls process file descriptors (pidfds) to await child
@@ -963,21 +866,6 @@ class PidfdChildWatcher(AbstractChildWatcher):
     recent (5.3+) kernels.
     """
 
-    def __enter__(self):
-        return self
-
-    def __exit__(self, exc_type, exc_value, exc_traceback):
-        pass
-
-    def is_active(self):
-        return True
-
-    def close(self):
-        pass
-
-    def attach_loop(self, loop):
-        pass
-
     def add_child_handler(self, pid, callback, *args):
         loop = events.get_running_loop()
         pidfd = os.pidfd_open(pid)
@@ -1002,386 +890,7 @@ def _do_wait(self, pid, pidfd, callback, args):
         os.close(pidfd)
         callback(pid, returncode, *args)
 
-    def remove_child_handler(self, pid):
-        # asyncio never calls remove_child_handler() !!!
-        # The method is no-op but is implemented because
-        # abstract base classes require it.
-        return True
-
-
-class BaseChildWatcher(AbstractChildWatcher):
-
-    def __init__(self):
-        self._loop = None
-        self._callbacks = {}
-
-    def close(self):
-        self.attach_loop(None)
-
-    def is_active(self):
-        return self._loop is not None and self._loop.is_running()
-
-    def _do_waitpid(self, expected_pid):
-        raise NotImplementedError()
-
-    def _do_waitpid_all(self):
-        raise NotImplementedError()
-
-    def attach_loop(self, loop):
-        assert loop is None or isinstance(loop, events.AbstractEventLoop)
-
-        if self._loop is not None and loop is None and self._callbacks:
-            warnings.warn(
-                'A loop is being detached '
-                'from a child watcher with pending handlers',
-                RuntimeWarning)
-
-        if self._loop is not None:
-            self._loop.remove_signal_handler(signal.SIGCHLD)
-
-        self._loop = loop
-        if loop is not None:
-            loop.add_signal_handler(signal.SIGCHLD, self._sig_chld)
-
-            # Prevent a race condition in case a child terminated
-            # during the switch.
-            self._do_waitpid_all()
-
-    def _sig_chld(self):
-        try:
-            self._do_waitpid_all()
-        except (SystemExit, KeyboardInterrupt):
-            raise
-        except BaseException as exc:
-            # self._loop should always be available here
-            # as '_sig_chld' is added as a signal handler
-            # in 'attach_loop'
-            self._loop.call_exception_handler({
-                'message': 'Unknown exception in SIGCHLD handler',
-                'exception': exc,
-            })
-
-
-class SafeChildWatcher(BaseChildWatcher):
-    """'Safe' child watcher implementation.
-
-    This implementation avoids disrupting other code spawning processes by
-    polling explicitly each process in the SIGCHLD handler instead of calling
-    os.waitpid(-1).
-
-    This is a safe solution but it has a significant overhead when handling a
-    big number of children (O(n) each time SIGCHLD is raised)
-    """
-
-    def __init__(self):
-        super().__init__()
-        warnings._deprecated("SafeChildWatcher",
-                             "{name!r} is deprecated as of Python 3.12 and will be "
-                             "removed in Python {remove}.",
-                              remove=(3, 14))
-
-    def close(self):
-        self._callbacks.clear()
-        super().close()
-
-    def __enter__(self):
-        return self
-
-    def __exit__(self, a, b, c):
-        pass
-
-    def add_child_handler(self, pid, callback, *args):
-        self._callbacks[pid] = (callback, args)
-
-        # Prevent a race condition in case the child is already terminated.
-        self._do_waitpid(pid)
-
-    def remove_child_handler(self, pid):
-        try:
-            del self._callbacks[pid]
-            return True
-        except KeyError:
-            return False
-
-    def _do_waitpid_all(self):
-
-        for pid in list(self._callbacks):
-            self._do_waitpid(pid)
-
-    def _do_waitpid(self, expected_pid):
-        assert expected_pid > 0
-
-        try:
-            pid, status = os.waitpid(expected_pid, os.WNOHANG)
-        except ChildProcessError:
-            # The child process is already reaped
-            # (may happen if waitpid() is called elsewhere).
-            pid = expected_pid
-            returncode = 255
-            logger.warning(
-                "Unknown child process pid %d, will report returncode 255",
-                pid)
-        else:
-            if pid == 0:
-                # The child process is still alive.
-                return
-
-            returncode = waitstatus_to_exitcode(status)
-            if self._loop.get_debug():
-                logger.debug('process %s exited with returncode %s',
-                             expected_pid, returncode)
-
-        try:
-            callback, args = self._callbacks.pop(pid)
-        except KeyError:  # pragma: no cover
-            # May happen if .remove_child_handler() is called
-            # after os.waitpid() returns.
-            if self._loop.get_debug():
-                logger.warning("Child watcher got an unexpected pid: %r",
-                               pid, exc_info=True)
-        else:
-            callback(pid, returncode, *args)
-
-
-class FastChildWatcher(BaseChildWatcher):
-    """'Fast' child watcher implementation.
-
-    This implementation reaps every terminated processes by calling
-    os.waitpid(-1) directly, possibly breaking other code spawning processes
-    and waiting for their termination.
-
-    There is no noticeable overhead when handling a big number of children
-    (O(1) each time a child terminates).
-    """
-    def __init__(self):
-        super().__init__()
-        self._lock = threading.Lock()
-        self._zombies = {}
-        self._forks = 0
-        warnings._deprecated("FastChildWatcher",
-                             "{name!r} is deprecated as of Python 3.12 and will be "
-                             "removed in Python {remove}.",
-                              remove=(3, 14))
-
-    def close(self):
-        self._callbacks.clear()
-        self._zombies.clear()
-        super().close()
-
-    def __enter__(self):
-        with self._lock:
-            self._forks += 1
-
-            return self
-
-    def __exit__(self, a, b, c):
-        with self._lock:
-            self._forks -= 1
-
-            if self._forks or not self._zombies:
-                return
-
-            collateral_victims = str(self._zombies)
-            self._zombies.clear()
-
-        logger.warning(
-            "Caught subprocesses termination from unknown pids: %s",
-            collateral_victims)
-
-    def add_child_handler(self, pid, callback, *args):
-        assert self._forks, "Must use the context manager"
-
-        with self._lock:
-            try:
-                returncode = self._zombies.pop(pid)
-            except KeyError:
-                # The child is running.
-                self._callbacks[pid] = callback, args
-                return
-
-        # The child is dead already. We can fire the callback.
-        callback(pid, returncode, *args)
-
-    def remove_child_handler(self, pid):
-        try:
-            del self._callbacks[pid]
-            return True
-        except KeyError:
-            return False
-
-    def _do_waitpid_all(self):
-        # Because of signal coalescing, we must keep calling waitpid() as
-        # long as we're able to reap a child.
-        while True:
-            try:
-                pid, status = os.waitpid(-1, os.WNOHANG)
-            except ChildProcessError:
-                # No more child processes exist.
-                return
-            else:
-                if pid == 0:
-                    # A child process is still alive.
-                    return
-
-                returncode = waitstatus_to_exitcode(status)
-
-            with self._lock:
-                try:
-                    callback, args = self._callbacks.pop(pid)
-                except KeyError:
-                    # unknown child
-                    if self._forks:
-                        # It may not be registered yet.
-                        self._zombies[pid] = returncode
-                        if self._loop.get_debug():
-                            logger.debug('unknown process %s exited '
-                                         'with returncode %s',
-                                         pid, returncode)
-                        continue
-                    callback = None
-                else:
-                    if self._loop.get_debug():
-                        logger.debug('process %s exited with returncode %s',
-                                     pid, returncode)
-
-            if callback is None:
-                logger.warning(
-                    "Caught subprocess termination from unknown pid: "
-                    "%d -> %d", pid, returncode)
-            else:
-                callback(pid, returncode, *args)
-
-
-class MultiLoopChildWatcher(AbstractChildWatcher):
-    """A watcher that doesn't require running loop in the main thread.
-
-    This implementation registers a SIGCHLD signal handler on
-    instantiation (which may conflict with other code that
-    install own handler for this signal).
-
-    The solution is safe but it has a significant overhead when
-    handling a big number of processes (*O(n)* each time a
-    SIGCHLD is received).
-    """
-
-    # Implementation note:
-    # The class keeps compatibility with AbstractChildWatcher ABC
-    # To achieve this it has empty attach_loop() method
-    # and doesn't accept explicit loop argument
-    # for add_child_handler()/remove_child_handler()
-    # but retrieves the current loop by get_running_loop()
-
-    def __init__(self):
-        self._callbacks = {}
-        self._saved_sighandler = None
-        warnings._deprecated("MultiLoopChildWatcher",
-                             "{name!r} is deprecated as of Python 3.12 and will be "
-                             "removed in Python {remove}.",
-                              remove=(3, 14))
-
-    def is_active(self):
-        return self._saved_sighandler is not None
-
-    def close(self):
-        self._callbacks.clear()
-        if self._saved_sighandler is None:
-            return
-
-        handler = signal.getsignal(signal.SIGCHLD)
-        if handler != self._sig_chld:
-            logger.warning("SIGCHLD handler was changed by outside code")
-        else:
-            signal.signal(signal.SIGCHLD, self._saved_sighandler)
-        self._saved_sighandler = None
-
-    def __enter__(self):
-        return self
-
-    def __exit__(self, exc_type, exc_val, exc_tb):
-        pass
-
-    def add_child_handler(self, pid, callback, *args):
-        loop = events.get_running_loop()
-        self._callbacks[pid] = (loop, callback, args)
-
-        # Prevent a race condition in case the child is already terminated.
-        self._do_waitpid(pid)
-
-    def remove_child_handler(self, pid):
-        try:
-            del self._callbacks[pid]
-            return True
-        except KeyError:
-            return False
-
-    def attach_loop(self, loop):
-        # Don't save the loop but initialize itself if called first time
-        # The reason to do it here is that attach_loop() is called from
-        # unix policy only for the main thread.
-        # Main thread is required for subscription on SIGCHLD signal
-        if self._saved_sighandler is not None:
-            return
-
-        self._saved_sighandler = signal.signal(signal.SIGCHLD, self._sig_chld)
-        if self._saved_sighandler is None:
-            logger.warning("Previous SIGCHLD handler was set by non-Python code, "
-                           "restore to default handler on watcher close.")
-            self._saved_sighandler = signal.SIG_DFL
-
-        # Set SA_RESTART to limit EINTR occurrences.
-        signal.siginterrupt(signal.SIGCHLD, False)
-
-    def _do_waitpid_all(self):
-        for pid in list(self._callbacks):
-            self._do_waitpid(pid)
-
-    def _do_waitpid(self, expected_pid):
-        assert expected_pid > 0
-
-        try:
-            pid, status = os.waitpid(expected_pid, os.WNOHANG)
-        except ChildProcessError:
-            # The child process is already reaped
-            # (may happen if waitpid() is called elsewhere).
-            pid = expected_pid
-            returncode = 255
-            logger.warning(
-                "Unknown child process pid %d, will report returncode 255",
-                pid)
-            debug_log = False
-        else:
-            if pid == 0:
-                # The child process is still alive.
-                return
-
-            returncode = waitstatus_to_exitcode(status)
-            debug_log = True
-        try:
-            loop, callback, args = self._callbacks.pop(pid)
-        except KeyError:  # pragma: no cover
-            # May happen if .remove_child_handler() is called
-            # after os.waitpid() returns.
-            logger.warning("Child watcher got an unexpected pid: %r",
-                           pid, exc_info=True)
-        else:
-            if loop.is_closed():
-                logger.warning("Loop %r that handles pid %r is closed", loop, pid)
-            else:
-                if debug_log and loop.get_debug():
-                    logger.debug('process %s exited with returncode %s',
-                                 expected_pid, returncode)
-                loop.call_soon_threadsafe(callback, pid, returncode, *args)
-
-    def _sig_chld(self, signum, frame):
-        try:
-            self._do_waitpid_all()
-        except (SystemExit, KeyboardInterrupt):
-            raise
-        except BaseException:
-            logger.warning('Unknown exception in SIGCHLD handler', exc_info=True)
-
-
-class ThreadedChildWatcher(AbstractChildWatcher):
+class _ThreadedChildWatcher:
     """Threaded child watcher implementation.
 
     The watcher uses a thread per process
@@ -1398,18 +907,6 @@ def __init__(self):
         self._pid_counter = itertools.count(0)
         self._threads = {}
 
-    def is_active(self):
-        return True
-
-    def close(self):
-        pass
-
-    def __enter__(self):
-        return self
-
-    def __exit__(self, exc_type, exc_val, exc_tb):
-        pass
-
     def __del__(self, _warn=warnings.warn):
         threads = [thread for thread in list(self._threads.values())
                    if thread.is_alive()]
@@ -1427,15 +924,6 @@ def add_child_handler(self, pid, callback, *args):
         self._threads[pid] = thread
         thread.start()
 
-    def remove_child_handler(self, pid):
-        # asyncio never calls remove_child_handler() !!!
-        # The method is no-op but is implemented because
-        # abstract base classes require it.
-        return True
-
-    def attach_loop(self, loop):
-        pass
-
     def _do_waitpid(self, loop, expected_pid, callback, args):
         assert expected_pid > 0
 
@@ -1474,63 +962,11 @@ def can_use_pidfd():
     return True
 
 
-class _UnixDefaultEventLoopPolicy(events.BaseDefaultEventLoopPolicy):
-    """UNIX event loop policy with a watcher for child processes."""
+class _UnixDefaultEventLoopPolicy(events._BaseDefaultEventLoopPolicy):
+    """UNIX event loop policy"""
     _loop_factory = _UnixSelectorEventLoop
 
-    def __init__(self):
-        super().__init__()
-        self._watcher = None
-
-    def _init_watcher(self):
-        with events._lock:
-            if self._watcher is None:  # pragma: no branch
-                if can_use_pidfd():
-                    self._watcher = PidfdChildWatcher()
-                else:
-                    self._watcher = ThreadedChildWatcher()
-
-    def set_event_loop(self, loop):
-        """Set the event loop.
-
-        As a side effect, if a child watcher was set before, then calling
-        .set_event_loop() from the main thread will call .attach_loop(loop) on
-        the child watcher.
-        """
-
-        super().set_event_loop(loop)
-
-        if (self._watcher is not None and
-                threading.current_thread() is threading.main_thread()):
-            self._watcher.attach_loop(loop)
-
-    def get_child_watcher(self):
-        """Get the watcher for child processes.
-
-        If not yet set, a ThreadedChildWatcher object is automatically created.
-        """
-        if self._watcher is None:
-            self._init_watcher()
-
-        warnings._deprecated("get_child_watcher",
-                            "{name!r} is deprecated as of Python 3.12 and will be "
-                            "removed in Python {remove}.", remove=(3, 14))
-        return self._watcher
-
-    def set_child_watcher(self, watcher):
-        """Set the watcher for child processes."""
-
-        assert watcher is None or isinstance(watcher, AbstractChildWatcher)
-
-        if self._watcher is not None:
-            self._watcher.close()
-
-        self._watcher = watcher
-        warnings._deprecated("set_child_watcher",
-                            "{name!r} is deprecated as of Python 3.12 and will be "
-                            "removed in Python {remove}.", remove=(3, 14))
-
 
 SelectorEventLoop = _UnixSelectorEventLoop
-DefaultEventLoopPolicy = _UnixDefaultEventLoopPolicy
+_DefaultEventLoopPolicy = _UnixDefaultEventLoopPolicy
 EventLoop = SelectorEventLoop
diff --git a/Lib/asyncio/windows_events.py b/Lib/asyncio/windows_events.py
index bf99bc271c7..5f75b17d8ca 100644
--- a/Lib/asyncio/windows_events.py
+++ b/Lib/asyncio/windows_events.py
@@ -29,8 +29,8 @@
 
 __all__ = (
     'SelectorEventLoop', 'ProactorEventLoop', 'IocpProactor',
-    'DefaultEventLoopPolicy', 'WindowsSelectorEventLoopPolicy',
-    'WindowsProactorEventLoopPolicy', 'EventLoop',
+    '_DefaultEventLoopPolicy', '_WindowsSelectorEventLoopPolicy',
+    '_WindowsProactorEventLoopPolicy', 'EventLoop',
 )
 
 
@@ -891,13 +891,13 @@ def callback(f):
 SelectorEventLoop = _WindowsSelectorEventLoop
 
 
-class WindowsSelectorEventLoopPolicy(events.BaseDefaultEventLoopPolicy):
+class _WindowsSelectorEventLoopPolicy(events._BaseDefaultEventLoopPolicy):
     _loop_factory = SelectorEventLoop
 
 
-class WindowsProactorEventLoopPolicy(events.BaseDefaultEventLoopPolicy):
+class _WindowsProactorEventLoopPolicy(events._BaseDefaultEventLoopPolicy):
     _loop_factory = ProactorEventLoop
 
 
-DefaultEventLoopPolicy = WindowsProactorEventLoopPolicy
+_DefaultEventLoopPolicy = _WindowsProactorEventLoopPolicy
 EventLoop = ProactorEventLoop
diff --git a/Lib/bdb.py b/Lib/bdb.py
index f256b56daaa..79da4bab9c9 100644
--- a/Lib/bdb.py
+++ b/Lib/bdb.py
@@ -2,7 +2,9 @@
 
 import fnmatch
 import sys
+import threading
 import os
+import weakref
 from contextlib import contextmanager
 from inspect import CO_GENERATOR, CO_COROUTINE, CO_ASYNC_GENERATOR
 
@@ -15,6 +17,166 @@ class BdbQuit(Exception):
     """Exception to give up completely."""
 
 
+E = sys.monitoring.events
+
+class _MonitoringTracer:
+    EVENT_CALLBACK_MAP = {
+        E.PY_START: 'call',
+        E.PY_RESUME: 'call',
+        E.PY_THROW: 'call',
+        E.LINE: 'line',
+        E.JUMP: 'jump',
+        E.PY_RETURN: 'return',
+        E.PY_YIELD: 'return',
+        E.PY_UNWIND: 'unwind',
+        E.RAISE: 'exception',
+        E.STOP_ITERATION: 'exception',
+        E.INSTRUCTION: 'opcode',
+    }
+
+    GLOBAL_EVENTS = E.PY_START | E.PY_RESUME | E.PY_THROW | E.PY_UNWIND | E.RAISE
+    LOCAL_EVENTS = E.LINE | E.JUMP | E.PY_RETURN | E.PY_YIELD | E.STOP_ITERATION
+
+    def __init__(self):
+        self._tool_id = sys.monitoring.DEBUGGER_ID
+        self._name = 'bdbtracer'
+        self._tracefunc = None
+        self._disable_current_event = False
+        self._tracing_thread = None
+        self._enabled = False
+
+    def start_trace(self, tracefunc):
+        self._tracefunc = tracefunc
+        self._tracing_thread = threading.current_thread()
+        curr_tool = sys.monitoring.get_tool(self._tool_id)
+        if curr_tool is None:
+            sys.monitoring.use_tool_id(self._tool_id, self._name)
+        elif curr_tool == self._name:
+            sys.monitoring.clear_tool_id(self._tool_id)
+        else:
+            raise ValueError('Another debugger is using the monitoring tool')
+        E = sys.monitoring.events
+        all_events = 0
+        for event, cb_name in self.EVENT_CALLBACK_MAP.items():
+            callback = self.callback_wrapper(getattr(self, f'{cb_name}_callback'), event)
+            sys.monitoring.register_callback(self._tool_id, event, callback)
+            if event != E.INSTRUCTION:
+                all_events |= event
+        self.update_local_events()
+        sys.monitoring.set_events(self._tool_id, self.GLOBAL_EVENTS)
+        self._enabled = True
+
+    def stop_trace(self):
+        self._enabled = False
+        self._tracing_thread = None
+        curr_tool = sys.monitoring.get_tool(self._tool_id)
+        if curr_tool != self._name:
+            return
+        sys.monitoring.clear_tool_id(self._tool_id)
+        sys.monitoring.free_tool_id(self._tool_id)
+
+    def disable_current_event(self):
+        self._disable_current_event = True
+
+    def restart_events(self):
+        if sys.monitoring.get_tool(self._tool_id) == self._name:
+            sys.monitoring.restart_events()
+
+    def callback_wrapper(self, func, event):
+        import functools
+
+        @functools.wraps(func)
+        def wrapper(*args):
+            if self._tracing_thread != threading.current_thread():
+                return
+            try:
+                frame = sys._getframe().f_back
+                ret = func(frame, *args)
+                if self._enabled and frame.f_trace:
+                    self.update_local_events()
+                if (
+                    self._disable_current_event
+                    and event not in (E.PY_THROW, E.PY_UNWIND, E.RAISE)
+                ):
+                    return sys.monitoring.DISABLE
+                else:
+                    return ret
+            except BaseException:
+                self.stop_trace()
+                sys._getframe().f_back.f_trace = None
+                raise
+            finally:
+                self._disable_current_event = False
+
+        return wrapper
+
+    def call_callback(self, frame, code, *args):
+        local_tracefunc = self._tracefunc(frame, 'call', None)
+        if local_tracefunc is not None:
+            frame.f_trace = local_tracefunc
+            if self._enabled:
+                sys.monitoring.set_local_events(self._tool_id, code, self.LOCAL_EVENTS)
+
+    def return_callback(self, frame, code, offset, retval):
+        if frame.f_trace:
+            frame.f_trace(frame, 'return', retval)
+
+    def unwind_callback(self, frame, code, *args):
+        if frame.f_trace:
+            frame.f_trace(frame, 'return', None)
+
+    def line_callback(self, frame, code, *args):
+        if frame.f_trace and frame.f_trace_lines:
+            frame.f_trace(frame, 'line', None)
+
+    def jump_callback(self, frame, code, inst_offset, dest_offset):
+        if dest_offset > inst_offset:
+            return sys.monitoring.DISABLE
+        inst_lineno = self._get_lineno(code, inst_offset)
+        dest_lineno = self._get_lineno(code, dest_offset)
+        if inst_lineno != dest_lineno:
+            return sys.monitoring.DISABLE
+        if frame.f_trace and frame.f_trace_lines:
+            frame.f_trace(frame, 'line', None)
+
+    def exception_callback(self, frame, code, offset, exc):
+        if frame.f_trace:
+            if exc.__traceback__ and hasattr(exc.__traceback__, 'tb_frame'):
+                tb = exc.__traceback__
+                while tb:
+                    if tb.tb_frame.f_locals.get('self') is self:
+                        return
+                    tb = tb.tb_next
+            frame.f_trace(frame, 'exception', (type(exc), exc, exc.__traceback__))
+
+    def opcode_callback(self, frame, code, offset):
+        if frame.f_trace and frame.f_trace_opcodes:
+            frame.f_trace(frame, 'opcode', None)
+
+    def update_local_events(self, frame=None):
+        if sys.monitoring.get_tool(self._tool_id) != self._name:
+            return
+        if frame is None:
+            frame = sys._getframe().f_back
+        while frame is not None:
+            if frame.f_trace is not None:
+                if frame.f_trace_opcodes:
+                    events = self.LOCAL_EVENTS | E.INSTRUCTION
+                else:
+                    events = self.LOCAL_EVENTS
+                sys.monitoring.set_local_events(self._tool_id, frame.f_code, events)
+            frame = frame.f_back
+
+    def _get_lineno(self, code, offset):
+        import dis
+        last_lineno = None
+        for start, lineno in dis.findlinestarts(code):
+            if offset < start:
+                return last_lineno
+            last_lineno = lineno
+        return last_lineno
+
+
 class Bdb:
     """Generic Python debugger base class.
 
@@ -29,7 +191,7 @@ class Bdb:
     is determined by the __name__ in the frame globals.
     """
 
-    def __init__(self, skip=None):
+    def __init__(self, skip=None, backend='settrace'):
         self.skip = set(skip) if skip else None
         self.breaks = {}
         self.fncache = {}
@@ -39,6 +201,14 @@ def __init__(self, skip=None):
         self.enterframe = None
         self.cmdframe = None
         self.cmdlineno = None
+        self.code_linenos = weakref.WeakKeyDictionary()
+        self.backend = backend
+        if backend == 'monitoring':
+            self.monitoring_tracer = _MonitoringTracer()
+        elif backend == 'settrace':
+            self.monitoring_tracer = None
+        else:
+            raise ValueError(f"Invalid backend '{backend}'")
 
         self._load_breaks()
 
@@ -59,6 +229,18 @@ def canonic(self, filename):
             self.fncache[filename] = canonic
         return canonic
 
+    def start_trace(self):
+        if self.monitoring_tracer:
+            self.monitoring_tracer.start_trace(self.trace_dispatch)
+        else:
+            sys.settrace(self.trace_dispatch)
+
+    def stop_trace(self):
+        if self.monitoring_tracer:
+            self.monitoring_tracer.stop_trace()
+        else:
+            sys.settrace(None)
+
     def reset(self):
         """Set values of attributes as ready to start debugging."""
         import linecache
@@ -133,7 +315,10 @@ def dispatch_line(self, frame):
             self.cmdframe == frame and self.cmdlineno == frame.f_lineno
         ):
             self.user_line(frame)
+            self.restart_events()
             if self.quitting: raise BdbQuit
+        elif not self.get_break(frame.f_code.co_filename, frame.f_lineno):
+            self.disable_current_event()
         return self.trace_dispatch
 
     def dispatch_call(self, frame, arg):
@@ -149,12 +334,18 @@ def dispatch_call(self, frame, arg):
             self.botframe = frame.f_back # (CT) Note that this may also be None!
             return self.trace_dispatch
         if not (self.stop_here(frame) or self.break_anywhere(frame)):
-            # No need to trace this function
+            # We already know there's no breakpoint in this function
+            # If it's a next/until/return command, we don't need any CALL event
+            # and we don't need to set the f_trace on any new frame.
+            # If it's a step command, it must either hit stop_here, or skip the
+            # whole module. Either way, we don't need the CALL event here.
+            self.disable_current_event()
             return # None
         # Ignore call events in generator except when stepping.
         if self.stopframe and frame.f_code.co_flags & GENERATOR_AND_COROUTINE_FLAGS:
             return self.trace_dispatch
         self.user_call(frame, arg)
+        self.restart_events()
         if self.quitting: raise BdbQuit
         return self.trace_dispatch
 
@@ -168,10 +359,14 @@ def dispatch_return(self, frame, arg):
         if self.stop_here(frame) or frame == self.returnframe:
             # Ignore return events in generator except when stepping.
             if self.stopframe and frame.f_code.co_flags & GENERATOR_AND_COROUTINE_FLAGS:
+                # It's possible to trigger a StopIteration exception in
+                # the caller so we must set the trace function in the caller
+                self._set_caller_tracefunc(frame)
                 return self.trace_dispatch
             try:
                 self.frame_returning = frame
                 self.user_return(frame, arg)
+                self.restart_events()
             finally:
                 self.frame_returning = None
             if self.quitting: raise BdbQuit
@@ -199,6 +394,7 @@ def dispatch_exception(self, frame, arg):
             if not (frame.f_code.co_flags & GENERATOR_AND_COROUTINE_FLAGS
                     and arg[0] is StopIteration and arg[2] is None):
                 self.user_exception(frame, arg)
+                self.restart_events()
                 if self.quitting: raise BdbQuit
         # Stop at the StopIteration or GeneratorExit exception when the user
         # has set stopframe in a generator by issuing a return command, or a
@@ -208,6 +404,7 @@ def dispatch_exception(self, frame, arg):
                 and self.stopframe.f_code.co_flags & GENERATOR_AND_COROUTINE_FLAGS
                 and arg[0] in (StopIteration, GeneratorExit)):
             self.user_exception(frame, arg)
+            self.restart_events()
             if self.quitting: raise BdbQuit
 
         return self.trace_dispatch
@@ -217,10 +414,14 @@ def dispatch_opcode(self, frame, arg):
         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.
+
+        Opcode event will always trigger the user callback. For now the only
+        opcode event is from an inline set_trace() and we want to stop there
+        unconditionally.
         """
-        if self.stop_here(frame) or self.break_here(frame):
-            self.user_opcode(frame)
-            if self.quitting: raise BdbQuit
+        self.user_opcode(frame)
+        self.restart_events()
+        if self.quitting: raise BdbQuit
         return self.trace_dispatch
 
     # Normally derived classes don't override the following
@@ -286,9 +487,25 @@ def do_clear(self, arg):
         raise NotImplementedError("subclass of bdb must implement do_clear()")
 
     def break_anywhere(self, frame):
-        """Return True if there is any breakpoint for frame's filename.
+        """Return True if there is any breakpoint in that frame
+        """
+        filename = self.canonic(frame.f_code.co_filename)
+        if filename not in self.breaks:
+            return False
+        for lineno in self.breaks[filename]:
+            if self._lineno_in_frame(lineno, frame):
+                return True
+        return False
+
+    def _lineno_in_frame(self, lineno, frame):
+        """Return True if the line number is in the frame's code object.
         """
-        return self.canonic(frame.f_code.co_filename) in self.breaks
+        code = frame.f_code
+        if lineno < code.co_firstlineno:
+            return False
+        if code not in self.code_linenos:
+            self.code_linenos[code] = set(lineno for _, _, lineno in code.co_lines())
+        return lineno in self.code_linenos[code]
 
     # Derived classes should override the user_* methods
     # to gain control.
@@ -322,6 +539,8 @@ def _set_trace_opcodes(self, trace_opcodes):
                 if frame is self.botframe:
                     break
                 frame = frame.f_back
+            if self.monitoring_tracer:
+                self.monitoring_tracer.update_local_events()
 
     def _set_stopinfo(self, stopframe, returnframe, stoplineno=0, opcode=False,
                       cmdframe=None, cmdlineno=None):
@@ -381,7 +600,7 @@ def set_next(self, frame):
     def set_return(self, frame):
         """Stop when returning from the given frame."""
         if frame.f_code.co_flags & GENERATOR_AND_COROUTINE_FLAGS:
-            self._set_stopinfo(frame, None, -1)
+            self._set_stopinfo(frame, frame, -1)
         else:
             self._set_stopinfo(frame.f_back, frame)
 
@@ -390,6 +609,7 @@ def set_trace(self, frame=None):
 
         If frame is not specified, debugging starts from caller's frame.
         """
+        self.stop_trace()
         if frame is None:
             frame = sys._getframe().f_back
         self.reset()
@@ -402,7 +622,8 @@ def set_trace(self, frame=None):
                 frame.f_trace_lines = True
                 frame = frame.f_back
             self.set_stepinstr()
-        sys.settrace(self.trace_dispatch)
+            self.enterframe = None
+        self.start_trace()
 
     def set_continue(self):
         """Stop only at breakpoints or when finished.
@@ -413,13 +634,15 @@ def set_continue(self):
         self._set_stopinfo(self.botframe, None, -1)
         if not self.breaks:
             # no breakpoints; run without debugger overhead
-            sys.settrace(None)
+            self.stop_trace()
             frame = sys._getframe().f_back
             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
+            if self.backend == 'monitoring':
+                self.monitoring_tracer.update_local_events()
             self.frame_trace_lines_opcodes = {}
 
     def set_quit(self):
@@ -430,7 +653,7 @@ def set_quit(self):
         self.stopframe = self.botframe
         self.returnframe = None
         self.quitting = True
-        sys.settrace(None)
+        self.stop_trace()
 
     # Derived classes and clients can call the following methods
     # to manipulate breakpoints.  These methods return an
@@ -658,6 +881,16 @@ def format_stack_entry(self, frame_lineno, lprefix=': '):
             s += f'{lprefix}Warning: lineno is None'
         return s
 
+    def disable_current_event(self):
+        """Disable the current event."""
+        if self.backend == 'monitoring':
+            self.monitoring_tracer.disable_current_event()
+
+    def restart_events(self):
+        """Restart all events."""
+        if self.backend == 'monitoring':
+            self.monitoring_tracer.restart_events()
+
     # The following methods can be called by clients to use
     # a debugger to debug a statement or an expression.
     # Both can be given as a string, or a code object.
@@ -675,14 +908,14 @@ def run(self, cmd, globals=None, locals=None):
         self.reset()
         if isinstance(cmd, str):
             cmd = compile(cmd, "<string>", "exec")
-        sys.settrace(self.trace_dispatch)
+        self.start_trace()
         try:
             exec(cmd, globals, locals)
         except BdbQuit:
             pass
         finally:
             self.quitting = True
-            sys.settrace(None)
+            self.stop_trace()
 
     def runeval(self, expr, globals=None, locals=None):
         """Debug an expression executed via the eval() function.
@@ -695,14 +928,14 @@ def runeval(self, expr, globals=None, locals=None):
         if locals is None:
             locals = globals
         self.reset()
-        sys.settrace(self.trace_dispatch)
+        self.start_trace()
         try:
             return eval(expr, globals, locals)
         except BdbQuit:
             pass
         finally:
             self.quitting = True
-            sys.settrace(None)
+            self.stop_trace()
 
     def runctx(self, cmd, globals, locals):
         """For backwards-compatibility.  Defers to run()."""
@@ -717,7 +950,7 @@ def runcall(self, func, /, *args, **kwds):
         Return the result of the function call.
         """
         self.reset()
-        sys.settrace(self.trace_dispatch)
+        self.start_trace()
         res = None
         try:
             res = func(*args, **kwds)
@@ -725,7 +958,7 @@ def runcall(self, func, /, *args, **kwds):
             pass
         finally:
             self.quitting = True
-            sys.settrace(None)
+            self.stop_trace()
         return res
 
 
diff --git a/Lib/code.py b/Lib/code.py
index 2777c311187..b134886dc26 100644
--- a/Lib/code.py
+++ b/Lib/code.py
@@ -13,7 +13,6 @@
 __all__ = ["InteractiveInterpreter", "InteractiveConsole", "interact",
            "compile_command"]
 
-
 class InteractiveInterpreter:
     """Base class for InteractiveConsole.
 
@@ -126,7 +125,7 @@ def showtraceback(self):
         """
         try:
             typ, value, tb = sys.exc_info()
-            self._showtraceback(typ, value, tb.tb_next, '')
+            self._showtraceback(typ, value, tb.tb_next, "")
         finally:
             typ = value = tb = None
 
@@ -140,7 +139,7 @@ def _showtraceback(self, typ, value, tb, source):
                 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)
+        sys.last_exc = sys.last_value = value
         if sys.excepthook is sys.__excepthook__:
             self._excepthook(typ, value, tb)
         else:
@@ -220,12 +219,17 @@ def interact(self, banner=None, exitmsg=None):
         """
         try:
             sys.ps1
+            delete_ps1_after = False
         except AttributeError:
             sys.ps1 = ">>> "
+            delete_ps1_after = True
         try:
-            sys.ps2
+            _ps2 = sys.ps2
+            delete_ps2_after = False
         except AttributeError:
             sys.ps2 = "... "
+            delete_ps2_after = True
+
         cprt = 'Type "help", "copyright", "credits" or "license" for more information.'
         if banner is None:
             self.write("Python %s on %s\n%s\n(%s)\n" %
@@ -288,6 +292,12 @@ def interact(self, banner=None, exitmsg=None):
             if _quit is not None:
                 builtins.quit = _quit
 
+            if delete_ps1_after:
+                del sys.ps1
+
+            if delete_ps2_after:
+                del sys.ps2
+
             if exitmsg is None:
                 self.write('now exiting %s...\n' % self.__class__.__name__)
             elif exitmsg != '':
@@ -366,7 +376,7 @@ def interact(banner=None, readfunc=None, local=None, exitmsg=None, local_exit=Fa
         console.raw_input = readfunc
     else:
         try:
-            import readline
+            import readline  # noqa: F401
         except ImportError:
             pass
     console.interact(banner, exitmsg)
@@ -375,9 +385,9 @@ def interact(banner=None, readfunc=None, local=None, exitmsg=None, local_exit=Fa
 if __name__ == "__main__":
     import argparse
 
-    parser = argparse.ArgumentParser()
+    parser = argparse.ArgumentParser(color=True)
     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/codecs.py b/Lib/codecs.py
index e4f4e1b5c02..e4a8010aba9 100644
--- a/Lib/codecs.py
+++ b/Lib/codecs.py
@@ -884,7 +884,6 @@ def __reduce_ex__(self, proto):
 ### Shortcuts
 
 def open(filename, mode='r', encoding=None, errors='strict', buffering=-1):
-
     """ Open an encoded file using the given mode and return
         a wrapped version providing transparent encoding/decoding.
 
@@ -912,8 +911,11 @@ def open(filename, mode='r', encoding=None, errors='strict', buffering=-1):
         .encoding which allows querying the used encoding. This
         attribute is only available if an encoding was specified as
         parameter.
-
     """
+    import warnings
+    warnings.warn("codecs.open() is deprecated. Use open() instead.",
+                  DeprecationWarning, stacklevel=2)
+
     if encoding is not None and \
        'b' not in mode:
         # Force opening of the file in binary mode
@@ -1109,24 +1111,15 @@ def make_encoding_map(decoding_map):
 
 ### error handlers
 
-try:
-    strict_errors = lookup_error("strict")
-    ignore_errors = lookup_error("ignore")
-    replace_errors = lookup_error("replace")
-    xmlcharrefreplace_errors = lookup_error("xmlcharrefreplace")
-    backslashreplace_errors = lookup_error("backslashreplace")
-    namereplace_errors = lookup_error("namereplace")
-except LookupError:
-    # In --disable-unicode builds, these error handler are missing
-    strict_errors = None
-    ignore_errors = None
-    replace_errors = None
-    xmlcharrefreplace_errors = None
-    backslashreplace_errors = None
-    namereplace_errors = None
+strict_errors = lookup_error("strict")
+ignore_errors = lookup_error("ignore")
+replace_errors = lookup_error("replace")
+xmlcharrefreplace_errors = lookup_error("xmlcharrefreplace")
+backslashreplace_errors = lookup_error("backslashreplace")
+namereplace_errors = lookup_error("namereplace")
 
 # Tell modulefinder that using codecs probably needs the encodings
 # package
 _false = 0
 if _false:
-    import encodings
+    import encodings  # noqa: F401
diff --git a/Lib/codeop.py b/Lib/codeop.py
index adf000ba29f..8cac00442d9 100644
--- a/Lib/codeop.py
+++ b/Lib/codeop.py
@@ -47,7 +47,7 @@
 PyCF_ONLY_AST = 0x400
 PyCF_ALLOW_INCOMPLETE_INPUT = 0x4000
 
-def _maybe_compile(compiler, source, filename, symbol):
+def _maybe_compile(compiler, source, filename, symbol, flags):
     # Check for source consisting of only blank lines and comments.
     for line in source.split("\n"):
         line = line.strip()
@@ -61,10 +61,10 @@ def _maybe_compile(compiler, source, filename, symbol):
     with warnings.catch_warnings():
         warnings.simplefilter("ignore", (SyntaxWarning, DeprecationWarning))
         try:
-            compiler(source, filename, symbol)
+            compiler(source, filename, symbol, flags=flags)
         except SyntaxError:  # Let other compile() errors propagate.
             try:
-                compiler(source + "\n", filename, symbol)
+                compiler(source + "\n", filename, symbol, flags=flags)
                 return None
             except _IncompleteInputError as e:
                 return None
@@ -74,14 +74,13 @@ def _maybe_compile(compiler, source, filename, symbol):
 
     return compiler(source, filename, symbol, incomplete_input=False)
 
-def _compile(source, filename, symbol, incomplete_input=True):
-    flags = 0
+def _compile(source, filename, symbol, incomplete_input=True, *, flags=0):
     if incomplete_input:
         flags |= PyCF_ALLOW_INCOMPLETE_INPUT
         flags |= PyCF_DONT_IMPLY_DEDENT
     return compile(source, filename, symbol, flags)
 
-def compile_command(source, filename="<input>", symbol="single"):
+def compile_command(source, filename="<input>", symbol="single", flags=0):
     r"""Compile a command and determine whether it is incomplete.
 
     Arguments:
@@ -100,7 +99,7 @@ def compile_command(source, filename="<input>", symbol="single"):
       syntax error (OverflowError and ValueError can be produced by
       malformed literals).
     """
-    return _maybe_compile(_compile, source, filename, symbol)
+    return _maybe_compile(_compile, source, filename, symbol, flags)
 
 class Compile:
     """Instances of this class behave much like the built-in compile
@@ -152,4 +151,4 @@ def __call__(self, source, filename="<input>", symbol="single"):
           syntax error (OverflowError and ValueError can be produced by
           malformed literals).
         """
-        return _maybe_compile(self.compiler, source, filename, symbol)
+        return _maybe_compile(self.compiler, source, filename, symbol, flags=self.compiler.flags)
diff --git a/Lib/collections/__init__.py b/Lib/collections/__init__.py
index db36248c4ff..3d3bbd7a39a 100644
--- a/Lib/collections/__init__.py
+++ b/Lib/collections/__init__.py
@@ -57,10 +57,7 @@
 try:
     from _collections import defaultdict
 except ImportError:
-    # FIXME: try to implement defaultdict in collections.rs rather than in Python
-    # I (coolreader18) couldn't figure out some class stuff with __new__ and
-    # __init__ and __missing__ and subclassing built-in types from Rust, so I went
-    # with this instead.
+    # TODO: RUSTPYTHON - implement defaultdict in Rust
     from ._defaultdict import defaultdict
 
 heapq = None  # Lazily imported
diff --git a/Lib/compileall.py b/Lib/compileall.py
index 47e2446356e..67fe370451e 100644
--- a/Lib/compileall.py
+++ b/Lib/compileall.py
@@ -317,7 +317,9 @@ def main():
     import argparse
 
     parser = argparse.ArgumentParser(
-        description='Utilities to support installing Python libraries.')
+        description='Utilities to support installing Python libraries.',
+        color=True,
+    )
     parser.add_argument('-l', action='store_const', const=0,
                         default=None, dest='maxlevels',
                         help="don't recurse into subdirectories")
diff --git a/Lib/configparser.py b/Lib/configparser.py
index 05b86acb919..d435a5c2fe0 100644
--- a/Lib/configparser.py
+++ b/Lib/configparser.py
@@ -154,14 +154,13 @@
 import os
 import re
 import sys
-import types
 
 __all__ = ("NoSectionError", "DuplicateOptionError", "DuplicateSectionError",
            "NoOptionError", "InterpolationError", "InterpolationDepthError",
            "InterpolationMissingOptionError", "InterpolationSyntaxError",
            "ParsingError", "MissingSectionHeaderError",
-           "MultilineContinuationError",
-           "ConfigParser", "RawConfigParser",
+           "MultilineContinuationError", "UnnamedSectionDisabledError",
+           "InvalidWriteError", "ConfigParser", "RawConfigParser",
            "Interpolation", "BasicInterpolation",  "ExtendedInterpolation",
            "SectionProxy", "ConverterMapping",
            "DEFAULTSECT", "MAX_INTERPOLATION_DEPTH", "UNNAMED_SECTION")
@@ -362,11 +361,27 @@ def __init__(self, filename, lineno, line):
         self.line = line
         self.args = (filename, lineno, line)
 
+
+class UnnamedSectionDisabledError(Error):
+    """Raised when an attempt to use UNNAMED_SECTION is made with the
+    feature disabled."""
+    def __init__(self):
+        Error.__init__(self, "Support for UNNAMED_SECTION is disabled.")
+
+
 class _UnnamedSection:
 
     def __repr__(self):
         return "<UNNAMED_SECTION>"
 
+class InvalidWriteError(Error):
+    """Raised when attempting to write data that the parser would read back differently.
+    ex: writing a key which begins with the section header pattern would read back as a
+    new section """
+
+    def __init__(self, msg=''):
+        Error.__init__(self, msg)
+
 
 UNNAMED_SECTION = _UnnamedSection()
 
@@ -556,35 +571,36 @@ def __init__(self):
 
 
 class _Line(str):
+    __slots__ = 'clean', 'has_comments'
 
     def __new__(cls, val, *args, **kwargs):
         return super().__new__(cls, val)
 
-    def __init__(self, val, prefixes):
-        self.prefixes = prefixes
-
-    @functools.cached_property
-    def clean(self):
-        return self._strip_full() and self._strip_inline()
+    def __init__(self, val, comments):
+        trimmed = val.strip()
+        self.clean = comments.strip(trimmed)
+        self.has_comments = trimmed != self.clean
 
-    @property
-    def has_comments(self):
-        return self.strip() != self.clean
 
-    def _strip_inline(self):
-        """
-        Search for the earliest prefix at the beginning of the line or following a space.
-        """
-        matcher = re.compile(
-            '|'.join(fr'(^|\s)({re.escape(prefix)})' for prefix in self.prefixes.inline)
-            # match nothing if no prefixes
-            or '(?!)'
+class _CommentSpec:
+    def __init__(self, full_prefixes, inline_prefixes):
+        full_patterns = (
+            # prefix at the beginning of a line
+            fr'^({re.escape(prefix)}).*'
+            for prefix in full_prefixes
         )
-        match = matcher.search(self)
-        return self[:match.start() if match else None].strip()
+        inline_patterns = (
+            # prefix at the beginning of the line or following a space
+            fr'(^|\s)({re.escape(prefix)}.*)'
+            for prefix in inline_prefixes
+        )
+        self.pattern = re.compile('|'.join(itertools.chain(full_patterns, inline_patterns)))
+
+    def strip(self, text):
+        return self.pattern.sub('', text).rstrip()
 
-    def _strip_full(self):
-        return '' if any(map(self.strip().startswith, self.prefixes.full)) else True
+    def wrap(self, text):
+        return _Line(text, self)
 
 
 class RawConfigParser(MutableMapping):
@@ -653,10 +669,7 @@ def __init__(self, defaults=None, dict_type=_default_dict,
             else:
                 self._optcre = re.compile(self._OPT_TMPL.format(delim=d),
                                           re.VERBOSE)
-        self._prefixes = types.SimpleNamespace(
-            full=tuple(comment_prefixes or ()),
-            inline=tuple(inline_comment_prefixes or ()),
-        )
+        self._comments = _CommentSpec(comment_prefixes or (), inline_comment_prefixes or ())
         self._strict = strict
         self._allow_no_value = allow_no_value
         self._empty_lines_in_values = empty_lines_in_values
@@ -694,6 +707,10 @@ def add_section(self, section):
         if section == self.default_section:
             raise ValueError('Invalid section name: %r' % section)
 
+        if section is UNNAMED_SECTION:
+            if not self._allow_unnamed_section:
+                raise UnnamedSectionDisabledError
+
         if section in self._sections:
             raise DuplicateSectionError(section)
         self._sections[section] = self._dict()
@@ -777,7 +794,8 @@ def read_dict(self, dictionary, source='<dict>'):
         """
         elements_added = set()
         for section, keys in dictionary.items():
-            section = str(section)
+            if section is not UNNAMED_SECTION:
+                section = str(section)
             try:
                 self.add_section(section)
             except (DuplicateSectionError, ValueError):
@@ -949,7 +967,7 @@ def write(self, fp, space_around_delimiters=True):
         if self._defaults:
             self._write_section(fp, self.default_section,
                                     self._defaults.items(), d)
-        if UNNAMED_SECTION in self._sections:
+        if UNNAMED_SECTION in self._sections and self._sections[UNNAMED_SECTION]:
             self._write_section(fp, UNNAMED_SECTION, self._sections[UNNAMED_SECTION].items(), d, unnamed=True)
 
         for section in self._sections:
@@ -959,10 +977,11 @@ def write(self, fp, space_around_delimiters=True):
                                 self._sections[section].items(), d)
 
     def _write_section(self, fp, section_name, section_items, delimiter, unnamed=False):
-        """Write a single section to the specified `fp'."""
+        """Write a single section to the specified 'fp'."""
         if not unnamed:
             fp.write("[{}]\n".format(section_name))
         for key, value in section_items:
+            self._validate_key_contents(key)
             value = self._interpolation.before_write(self, section_name, key,
                                                      value)
             if value is not None or not self._allow_no_value:
@@ -1047,7 +1066,6 @@ def _read(self, fp, fpname):
         in an otherwise empty line or may be entered in lines holding values or
         section names. Please note that comments get stripped off when reading configuration files.
         """
-
         try:
             ParsingError._raise_all(self._read_inner(fp, fpname))
         finally:
@@ -1056,8 +1074,7 @@ def _read(self, fp, fpname):
     def _read_inner(self, fp, fpname):
         st = _ReadState()
 
-        Line = functools.partial(_Line, prefixes=self._prefixes)
-        for st.lineno, line in enumerate(map(Line, fp), start=1):
+        for st.lineno, line in enumerate(map(self._comments.wrap, fp), start=1):
             if not line.clean:
                 if self._empty_lines_in_values:
                     # add empty line to the value, but only if there was no
@@ -1200,21 +1217,32 @@ def _convert_to_boolean(self, value):
             raise ValueError('Not a boolean: %s' % value)
         return self.BOOLEAN_STATES[value.lower()]
 
+    def _validate_key_contents(self, key):
+        """Raises an InvalidWriteError for any keys containing
+        delimiters or that begins with the section header pattern"""
+        if re.match(self.SECTCRE, key):
+            raise InvalidWriteError(
+                f"Cannot write key {key}; begins with section pattern")
+        for delim in self._delimiters:
+            if delim in key:
+                raise InvalidWriteError(
+                    f"Cannot write key {key}; contains delimiter {delim}")
+
     def _validate_value_types(self, *, section="", option="", value=""):
-        """Raises a TypeError for non-string values.
+        """Raises a TypeError for illegal non-string values.
 
-        The only legal non-string value if we allow valueless
-        options is None, so we need to check if the value is a
-        string if:
-        - we do not allow valueless options, or
-        - we allow valueless options but the value is not None
+        Legal non-string values are UNNAMED_SECTION and falsey values if
+        they are allowed.
 
         For compatibility reasons this method is not used in classic set()
         for RawConfigParsers. It is invoked in every case for mapping protocol
         access and in ConfigParser.set().
         """
-        if not isinstance(section, str):
-            raise TypeError("section names must be strings")
+        if section is UNNAMED_SECTION:
+            if not self._allow_unnamed_section:
+                raise UnnamedSectionDisabledError
+        elif not isinstance(section, str):
+            raise TypeError("section names must be strings or UNNAMED_SECTION")
         if not isinstance(option, str):
             raise TypeError("option keys must be strings")
         if not self._allow_no_value or value:
diff --git a/Lib/copy.py b/Lib/copy.py
index 2a4606246aa..c64fc076179 100644
--- a/Lib/copy.py
+++ b/Lib/copy.py
@@ -67,13 +67,15 @@ def copy(x):
 
     cls = type(x)
 
-    copier = _copy_dispatch.get(cls)
-    if copier:
-        return copier(x)
+    if cls in _copy_atomic_types:
+        return x
+    if cls in _copy_builtin_containers:
+        return cls.copy(x)
+
 
     if issubclass(cls, type):
         # treat it as a regular class:
-        return _copy_immutable(x)
+        return x
 
     copier = getattr(cls, "__copy__", None)
     if copier is not None:
@@ -98,23 +100,12 @@ def copy(x):
     return _reconstruct(x, None, *rv)
 
 
-_copy_dispatch = d = {}
-
-def _copy_immutable(x):
-    return x
-for t in (types.NoneType, int, float, bool, complex, str, tuple,
+_copy_atomic_types = {types.NoneType, int, float, bool, complex, str, tuple,
           bytes, frozenset, type, range, slice, property,
           types.BuiltinFunctionType, types.EllipsisType,
           types.NotImplementedType, types.FunctionType, types.CodeType,
-          weakref.ref):
-    d[t] = _copy_immutable
-
-d[list] = list.copy
-d[dict] = dict.copy
-d[set] = set.copy
-d[bytearray] = bytearray.copy
-
-del d, t
+          weakref.ref, super}
+_copy_builtin_containers = {list, dict, set, bytearray}
 
 def deepcopy(x, memo=None, _nil=[]):
     """Deep copy operation on arbitrary Python objects.
@@ -122,6 +113,11 @@ def deepcopy(x, memo=None, _nil=[]):
     See the module's __doc__ string for more info.
     """
 
+    cls = type(x)
+
+    if cls in _atomic_types:
+        return x
+
     d = id(x)
     if memo is None:
         memo = {}
@@ -130,14 +126,12 @@ def deepcopy(x, memo=None, _nil=[]):
         if y is not _nil:
             return y
 
-    cls = type(x)
-
     copier = _deepcopy_dispatch.get(cls)
     if copier is not None:
         y = copier(x, memo)
     else:
         if issubclass(cls, type):
-            y = _deepcopy_atomic(x, memo)
+            y = x # atomic copy
         else:
             copier = getattr(x, "__deepcopy__", None)
             if copier is not None:
@@ -168,26 +162,12 @@ def deepcopy(x, memo=None, _nil=[]):
         _keep_alive(x, memo) # Make sure x lives at least as long as d
     return y
 
+_atomic_types =  {types.NoneType, types.EllipsisType, types.NotImplementedType,
+          int, float, bool, complex, bytes, str, types.CodeType, type, range,
+          types.BuiltinFunctionType, types.FunctionType, weakref.ref, property}
+
 _deepcopy_dispatch = d = {}
 
-def _deepcopy_atomic(x, memo):
-    return x
-d[types.NoneType] = _deepcopy_atomic
-d[types.EllipsisType] = _deepcopy_atomic
-d[types.NotImplementedType] = _deepcopy_atomic
-d[int] = _deepcopy_atomic
-d[float] = _deepcopy_atomic
-d[bool] = _deepcopy_atomic
-d[complex] = _deepcopy_atomic
-d[bytes] = _deepcopy_atomic
-d[str] = _deepcopy_atomic
-d[types.CodeType] = _deepcopy_atomic
-d[type] = _deepcopy_atomic
-d[range] = _deepcopy_atomic
-d[types.BuiltinFunctionType] = _deepcopy_atomic
-d[types.FunctionType] = _deepcopy_atomic
-d[weakref.ref] = _deepcopy_atomic
-d[property] = _deepcopy_atomic
 
 def _deepcopy_list(x, memo, deepcopy=deepcopy):
     y = []
diff --git a/Lib/csv.py b/Lib/csv.py
index cd202659873..0a627ba7a51 100644
--- a/Lib/csv.py
+++ b/Lib/csv.py
@@ -63,7 +63,6 @@ class excel:
         written as two quotes
 """
 
-import re
 import types
 from _csv import Error, writer, reader, register_dialect, \
                  unregister_dialect, get_dialect, list_dialects, \
@@ -281,6 +280,7 @@ def _guess_quote_and_delimiter(self, data, delimiters):
         If there is no quotechar the delimiter can't be determined
         this way.
         """
+        import re
 
         matches = []
         for restr in (r'(?P<delim>[^\w\n"\'])(?P<space> ?)(?P<quote>["\']).*?(?P=quote)(?P=delim)', # ,".*?",
diff --git a/Lib/ctypes/__init__.py b/Lib/ctypes/__init__.py
index 80651dc64ce..04ec0270148 100644
--- a/Lib/ctypes/__init__.py
+++ b/Lib/ctypes/__init__.py
@@ -14,6 +14,7 @@
 from _ctypes import RTLD_LOCAL, RTLD_GLOBAL
 from _ctypes import ArgumentError
 from _ctypes import SIZEOF_TIME_T
+from _ctypes import CField
 
 from struct import calcsize as _calcsize
 
@@ -21,7 +22,7 @@
     raise Exception("Version number mismatch", __version__, _ctypes_version)
 
 if _os.name == "nt":
-    from _ctypes import FormatError
+    from _ctypes import COMError, CopyComPointer, FormatError
 
 DEFAULT_MODE = RTLD_LOCAL
 if _os.name == "posix" and _sys.platform == "darwin":
@@ -163,6 +164,7 @@ def __repr__(self):
             return super().__repr__()
         except ValueError:
             return "%s(<NULL>)" % type(self).__name__
+    __class_getitem__ = classmethod(_types.GenericAlias)
 _check_size(py_object, "P")
 
 class c_short(_SimpleCData):
@@ -207,6 +209,18 @@ class c_longdouble(_SimpleCData):
 if sizeof(c_longdouble) == sizeof(c_double):
     c_longdouble = c_double
 
+try:
+    class c_double_complex(_SimpleCData):
+        _type_ = "D"
+    _check_size(c_double_complex)
+    class c_float_complex(_SimpleCData):
+        _type_ = "F"
+    _check_size(c_float_complex)
+    class c_longdouble_complex(_SimpleCData):
+        _type_ = "G"
+except AttributeError:
+    pass
+
 if _calcsize("l") == _calcsize("q"):
     # if long and long long have the same size, make c_longlong an alias for c_long
     c_longlong = c_long
@@ -254,7 +268,72 @@ class c_void_p(_SimpleCData):
 class c_bool(_SimpleCData):
     _type_ = "?"
 
-from _ctypes import POINTER, pointer, _pointer_type_cache
+def POINTER(cls):
+    """Create and return a new ctypes pointer type.
+
+    Pointer types are cached and reused internally,
+    so calling this function repeatedly is cheap.
+    """
+    if cls is None:
+        return c_void_p
+    try:
+        return cls.__pointer_type__
+    except AttributeError:
+        pass
+    if isinstance(cls, str):
+        # handle old-style incomplete types (see test_ctypes.test_incomplete)
+        import warnings
+        warnings._deprecated("ctypes.POINTER with string", remove=(3, 19))
+        try:
+            return _pointer_type_cache_fallback[cls]
+        except KeyError:
+            result = type(f'LP_{cls}', (_Pointer,), {})
+            _pointer_type_cache_fallback[cls] = result
+            return result
+
+    # create pointer type and set __pointer_type__ for cls
+    return type(f'LP_{cls.__name__}', (_Pointer,), {'_type_': cls})
+
+def pointer(obj):
+    """Create a new pointer instance, pointing to 'obj'.
+
+    The returned object is of the type POINTER(type(obj)). Note that if you
+    just want to pass a pointer to an object to a foreign function call, you
+    should use byref(obj) which is much faster.
+    """
+    typ = POINTER(type(obj))
+    return typ(obj)
+
+class _PointerTypeCache:
+    def __setitem__(self, cls, pointer_type):
+        import warnings
+        warnings._deprecated("ctypes._pointer_type_cache", remove=(3, 19))
+        try:
+            cls.__pointer_type__ = pointer_type
+        except AttributeError:
+            _pointer_type_cache_fallback[cls] = pointer_type
+
+    def __getitem__(self, cls):
+        import warnings
+        warnings._deprecated("ctypes._pointer_type_cache", remove=(3, 19))
+        try:
+            return cls.__pointer_type__
+        except AttributeError:
+            return _pointer_type_cache_fallback[cls]
+
+    def get(self, cls, default=None):
+        import warnings
+        warnings._deprecated("ctypes._pointer_type_cache", remove=(3, 19))
+        try:
+            return cls.__pointer_type__
+        except AttributeError:
+            return _pointer_type_cache_fallback.get(cls, default)
+
+    def __contains__(self, cls):
+        return hasattr(cls, '__pointer_type__')
+
+_pointer_type_cache_fallback = {}
+_pointer_type_cache = _PointerTypeCache()
 
 class c_wchar_p(_SimpleCData):
     _type_ = "Z"
@@ -265,7 +344,7 @@ class c_wchar(_SimpleCData):
     _type_ = "u"
 
 def _reset_cache():
-    _pointer_type_cache.clear()
+    _pointer_type_cache_fallback.clear()
     _c_functype_cache.clear()
     if _os.name == "nt":
         _win_functype_cache.clear()
@@ -273,7 +352,6 @@ def _reset_cache():
     POINTER(c_wchar).from_param = c_wchar_p.from_param
     # _SimpleCData.c_char_p_from_param
     POINTER(c_char).from_param = c_char_p.from_param
-    _pointer_type_cache[None] = c_void_p
 
 def create_unicode_buffer(init, size=None):
     """create_unicode_buffer(aString) -> character array
@@ -307,13 +385,7 @@ def create_unicode_buffer(init, size=None):
 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:
-        raise RuntimeError("What's this???")
     pointer.set_type(cls)
-    _pointer_type_cache[cls] = pointer
-    del _pointer_type_cache[id(pointer)]
 
 def ARRAY(typ, len):
     return typ * len
@@ -520,6 +592,7 @@ def WinError(code=None, descr=None):
 # functions
 
 from _ctypes import _memmove_addr, _memset_addr, _string_at_addr, _cast_addr
+from _ctypes import _memoryview_at_addr
 
 ## void *memmove(void *, const void *, size_t);
 memmove = CFUNCTYPE(c_void_p, c_void_p, c_void_p, c_size_t)(_memmove_addr)
@@ -545,6 +618,14 @@ def string_at(ptr, size=-1):
     Return the byte string at void *ptr."""
     return _string_at(ptr, size)
 
+_memoryview_at = PYFUNCTYPE(
+    py_object, c_void_p, c_ssize_t, c_int)(_memoryview_at_addr)
+def memoryview_at(ptr, size, readonly=False):
+    """memoryview_at(ptr, size[, readonly]) -> memoryview
+
+    Return a memoryview representing the memory at void *ptr."""
+    return _memoryview_at(ptr, size, bool(readonly))
+
 try:
     from _ctypes import _wstring_at_addr
 except ImportError:
diff --git a/Lib/ctypes/_layout.py b/Lib/ctypes/_layout.py
new file mode 100644
index 00000000000..2048ccb6a1c
--- /dev/null
+++ b/Lib/ctypes/_layout.py
@@ -0,0 +1,330 @@
+"""Python implementation of computing the layout of a struct/union
+
+This code is internal and tightly coupled to the C part. The interface
+may change at any time.
+"""
+
+import sys
+import warnings
+
+from _ctypes import CField, buffer_info
+import ctypes
+
+def round_down(n, multiple):
+    assert n >= 0
+    assert multiple > 0
+    return (n // multiple) * multiple
+
+def round_up(n, multiple):
+    assert n >= 0
+    assert multiple > 0
+    return ((n + multiple - 1) // multiple) * multiple
+
+_INT_MAX = (1 << (ctypes.sizeof(ctypes.c_int) * 8) - 1) - 1
+
+
+class StructUnionLayout:
+    def __init__(self, fields, size, align, format_spec):
+        # sequence of CField objects
+        self.fields = fields
+
+        # total size of the aggregate (rounded up to alignment)
+        self.size = size
+
+        # total alignment requirement of the aggregate
+        self.align = align
+
+        # buffer format specification (as a string, UTF-8 but bes
+        # kept ASCII-only)
+        self.format_spec = format_spec
+
+
+def get_layout(cls, input_fields, is_struct, base):
+    """Return a StructUnionLayout for the given class.
+
+    Called by PyCStructUnionType_update_stginfo when _fields_ is assigned
+    to a class.
+    """
+    # Currently there are two modes, selectable using the '_layout_' attribute:
+    #
+    # 'gcc-sysv' mode places fields one after another, bit by bit.
+    #   But "each bit field must fit within a single object of its specified
+    #   type" (GCC manual, section 15.8 "Bit Field Packing"). When it doesn't,
+    #   we insert a few bits of padding to avoid that.
+    #
+    # 'ms' mode works similar except for bitfield packing.  Adjacent
+    #   bit-fields are packed into the same 1-, 2-, or 4-byte allocation unit
+    #   if the integral types are the same size and if the next bit-field fits
+    #   into the current allocation unit without crossing the boundary imposed
+    #   by the common alignment requirements of the bit-fields.
+    #
+    #   See https://gcc.gnu.org/onlinedocs/gcc/x86-Options.html#index-mms-bitfields
+    #   for details.
+
+    # We do not support zero length bitfields (we use bitsize != 0
+    # elsewhere to indicate a bitfield). Here, non-bitfields have bit_size
+    # set to size*8.
+
+    # For clarity, variables that count bits have `bit` in their names.
+
+    pack = getattr(cls, '_pack_', None)
+
+    layout = getattr(cls, '_layout_', None)
+    if layout is None:
+        if sys.platform == 'win32':
+            gcc_layout = False
+        elif pack:
+            if is_struct:
+                base_type_name = 'Structure'
+            else:
+                base_type_name = 'Union'
+            warnings._deprecated(
+                '_pack_ without _layout_',
+                f"Due to '_pack_', the '{cls.__name__}' {base_type_name} will "
+                + "use memory layout compatible with MSVC (Windows). "
+                + "If this is intended, set _layout_ to 'ms'. "
+                + "The implicit default is deprecated and slated to become "
+                + "an error in Python {remove}.",
+                remove=(3, 19),
+            )
+            gcc_layout = False
+        else:
+            gcc_layout = True
+    elif layout == 'ms':
+        gcc_layout = False
+    elif layout == 'gcc-sysv':
+        gcc_layout = True
+    else:
+        raise ValueError(f'unknown _layout_: {layout!r}')
+
+    align = getattr(cls, '_align_', 1)
+    if align < 0:
+        raise ValueError('_align_ must be a non-negative integer')
+    elif align == 0:
+        # Setting `_align_ = 0` amounts to using the default alignment
+        align = 1
+
+    if base:
+        align = max(ctypes.alignment(base), align)
+
+    swapped_bytes = hasattr(cls, '_swappedbytes_')
+    if swapped_bytes:
+        big_endian = sys.byteorder == 'little'
+    else:
+        big_endian = sys.byteorder == 'big'
+
+    if pack is not None:
+        try:
+            pack = int(pack)
+        except (TypeError, ValueError):
+            raise ValueError("_pack_ must be an integer")
+        if pack < 0:
+            raise ValueError("_pack_ must be a non-negative integer")
+        if pack > _INT_MAX:
+            raise ValueError("_pack_ too big")
+        if gcc_layout:
+            raise ValueError('_pack_ is not compatible with gcc-sysv layout')
+
+    result_fields = []
+
+    if is_struct:
+        format_spec_parts = ["T{"]
+    else:
+        format_spec_parts = ["B"]
+
+    last_field_bit_size = 0  # used in MS layout only
+
+    # `8 * next_byte_offset + next_bit_offset` points to where the
+    # next field would start.
+    next_bit_offset = 0
+    next_byte_offset = 0
+
+    # size if this was a struct (sum of field sizes, plus padding)
+    struct_size = 0
+    # max of field sizes; only meaningful for unions
+    union_size = 0
+
+    if base:
+        struct_size = ctypes.sizeof(base)
+        if gcc_layout:
+            next_bit_offset = struct_size * 8
+        else:
+            next_byte_offset = struct_size
+
+    last_size = struct_size
+    for i, field in enumerate(input_fields):
+        if not is_struct:
+            # Unions start fresh each time
+            last_field_bit_size = 0
+            next_bit_offset = 0
+            next_byte_offset = 0
+
+        # Unpack the field
+        field = tuple(field)
+        try:
+            name, ctype = field
+        except (ValueError, TypeError):
+            try:
+                name, ctype, bit_size = field
+            except (ValueError, TypeError) as exc:
+                raise ValueError(
+                    '_fields_ must be a sequence of (name, C type) pairs '
+                    + 'or (name, C type, bit size) triples') from exc
+            is_bitfield = True
+            if bit_size <= 0:
+                raise ValueError(
+                    f'number of bits invalid for bit field {name!r}')
+            type_size = ctypes.sizeof(ctype)
+            if bit_size > type_size * 8:
+                raise ValueError(
+                    f'number of bits invalid for bit field {name!r}')
+        else:
+            is_bitfield = False
+            type_size = ctypes.sizeof(ctype)
+            bit_size = type_size * 8
+
+        type_bit_size = type_size * 8
+        type_align = ctypes.alignment(ctype) or 1
+        type_bit_align = type_align * 8
+
+        if gcc_layout:
+            # We don't use next_byte_offset here
+            assert pack is None
+            assert next_byte_offset == 0
+
+            # Determine whether the bit field, if placed at the next
+            # free bit, fits within a single object of its specified type.
+            # That is: determine a "slot", sized & aligned for the
+            # specified type, which contains the bitfield's beginning:
+            slot_start_bit = round_down(next_bit_offset, type_bit_align)
+            slot_end_bit = slot_start_bit + type_bit_size
+            # And see if it also contains the bitfield's last bit:
+            field_end_bit = next_bit_offset + bit_size
+            if field_end_bit > slot_end_bit:
+                # It doesn't: add padding (bump up to the next
+                # alignment boundary)
+                next_bit_offset = round_up(next_bit_offset, type_bit_align)
+
+            offset = round_down(next_bit_offset, type_bit_align) // 8
+            if is_bitfield:
+                bit_offset = next_bit_offset - 8 * offset
+                assert bit_offset <= type_bit_size
+            else:
+                assert offset == next_bit_offset / 8
+
+            next_bit_offset += bit_size
+            struct_size = round_up(next_bit_offset, 8) // 8
+        else:
+            if pack:
+                type_align = min(pack, type_align)
+
+            # next_byte_offset points to end of current bitfield.
+            # next_bit_offset is generally non-positive,
+            # and 8 * next_byte_offset + next_bit_offset points just behind
+            # the end of the last field we placed.
+            if (
+                (0 < next_bit_offset + bit_size)
+                or (type_bit_size != last_field_bit_size)
+            ):
+                # Close the previous bitfield (if any)
+                # and start a new bitfield
+                next_byte_offset = round_up(next_byte_offset, type_align)
+
+                next_byte_offset += type_size
+
+                last_field_bit_size = type_bit_size
+                # Reminder: 8 * (next_byte_offset) + next_bit_offset
+                # points to where we would start a new field, namely
+                # just behind where we placed the last field plus an
+                # allowance for alignment.
+                next_bit_offset = -last_field_bit_size
+
+            assert type_bit_size == last_field_bit_size
+
+            offset = next_byte_offset - last_field_bit_size // 8
+            if is_bitfield:
+                assert 0 <= (last_field_bit_size + next_bit_offset)
+                bit_offset = last_field_bit_size + next_bit_offset
+            if type_bit_size:
+                assert (last_field_bit_size + next_bit_offset) < type_bit_size
+
+            next_bit_offset += bit_size
+            struct_size = next_byte_offset
+
+        if is_bitfield and big_endian:
+            # On big-endian architectures, bit fields are also laid out
+            # starting with the big end.
+            bit_offset = type_bit_size - bit_size - bit_offset
+
+        # Add the format spec parts
+        if is_struct:
+            padding = offset - last_size
+            format_spec_parts.append(padding_spec(padding))
+
+            fieldfmt, bf_ndim, bf_shape = buffer_info(ctype)
+
+            if bf_shape:
+                format_spec_parts.extend((
+                    "(",
+                    ','.join(str(n) for n in bf_shape),
+                    ")",
+                ))
+
+            if fieldfmt is None:
+                fieldfmt = "B"
+            if isinstance(name, bytes):
+                # a bytes name would be rejected later, but we check early
+                # to avoid a BytesWarning with `python -bb`
+                raise TypeError(
+                    f"field {name!r}: name must be a string, not bytes")
+            format_spec_parts.append(f"{fieldfmt}:{name}:")
+
+        result_fields.append(CField(
+            name=name,
+            type=ctype,
+            byte_size=type_size,
+            byte_offset=offset,
+            bit_size=bit_size if is_bitfield else None,
+            bit_offset=bit_offset if is_bitfield else None,
+            index=i,
+
+            # Do not use CField outside ctypes, yet.
+            # The constructor is internal API and may change without warning.
+            _internal_use=True,
+        ))
+        if is_bitfield and not gcc_layout:
+            assert type_bit_size > 0
+
+        align = max(align, type_align)
+        last_size = struct_size
+        if not is_struct:
+            union_size = max(struct_size, union_size)
+
+    if is_struct:
+        total_size = struct_size
+    else:
+        total_size = union_size
+
+    # Adjust the size according to the alignment requirements
+    aligned_size = round_up(total_size, align)
+
+    # Finish up the format spec
+    if is_struct:
+        padding = aligned_size - total_size
+        format_spec_parts.append(padding_spec(padding))
+        format_spec_parts.append("}")
+
+    return StructUnionLayout(
+        fields=result_fields,
+        size=aligned_size,
+        align=align,
+        format_spec="".join(format_spec_parts),
+    )
+
+
+def padding_spec(padding):
+    if padding <= 0:
+        return ""
+    if padding == 1:
+        return "x"
+    return f"{padding}x"
diff --git a/Lib/ctypes/util.py b/Lib/ctypes/util.py
index 117bf06cb01..378f12167c6 100644
--- a/Lib/ctypes/util.py
+++ b/Lib/ctypes/util.py
@@ -67,6 +67,65 @@ def find_library(name):
                 return fname
         return None
 
+    # Listing loaded DLLs on Windows relies on the following APIs:
+    # https://learn.microsoft.com/windows/win32/api/psapi/nf-psapi-enumprocessmodules
+    # https://learn.microsoft.com/windows/win32/api/libloaderapi/nf-libloaderapi-getmodulefilenamew
+    import ctypes
+    from ctypes import wintypes
+
+    _kernel32 = ctypes.WinDLL('kernel32', use_last_error=True)
+    _get_current_process = _kernel32["GetCurrentProcess"]
+    _get_current_process.restype = wintypes.HANDLE
+
+    _k32_get_module_file_name = _kernel32["GetModuleFileNameW"]
+    _k32_get_module_file_name.restype = wintypes.DWORD
+    _k32_get_module_file_name.argtypes = (
+        wintypes.HMODULE,
+        wintypes.LPWSTR,
+        wintypes.DWORD,
+    )
+
+    _psapi = ctypes.WinDLL('psapi', use_last_error=True)
+    _enum_process_modules = _psapi["EnumProcessModules"]
+    _enum_process_modules.restype = wintypes.BOOL
+    _enum_process_modules.argtypes = (
+        wintypes.HANDLE,
+        ctypes.POINTER(wintypes.HMODULE),
+        wintypes.DWORD,
+        wintypes.LPDWORD,
+    )
+
+    def _get_module_filename(module: wintypes.HMODULE):
+        name = (wintypes.WCHAR * 32767)() # UNICODE_STRING_MAX_CHARS
+        if _k32_get_module_file_name(module, name, len(name)):
+            return name.value
+        return None
+
+
+    def _get_module_handles():
+        process = _get_current_process()
+        space_needed = wintypes.DWORD()
+        n = 1024
+        while True:
+            modules = (wintypes.HMODULE * n)()
+            if not _enum_process_modules(process,
+                                         modules,
+                                         ctypes.sizeof(modules),
+                                         ctypes.byref(space_needed)):
+                err = ctypes.get_last_error()
+                msg = ctypes.FormatError(err).strip()
+                raise ctypes.WinError(err, f"EnumProcessModules failed: {msg}")
+            n = space_needed.value // ctypes.sizeof(wintypes.HMODULE)
+            if n <= len(modules):
+                return modules[:n]
+
+    def dllist():
+        """Return a list of loaded shared libraries in the current process."""
+        modules = _get_module_handles()
+        libraries = [name for h in modules
+                        if (name := _get_module_filename(h)) is not None]
+        return libraries
+
 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):
@@ -80,6 +139,22 @@ def find_library(name):
                 continue
         return None
 
+    # Listing loaded libraries on Apple systems relies on the following API:
+    # https://developer.apple.com/library/archive/documentation/System/Conceptual/ManPages_iPhoneOS/man3/dyld.3.html
+    import ctypes
+
+    _libc = ctypes.CDLL(find_library("c"))
+    _dyld_get_image_name = _libc["_dyld_get_image_name"]
+    _dyld_get_image_name.restype = ctypes.c_char_p
+
+    def dllist():
+        """Return a list of loaded shared libraries in the current process."""
+        num_images = _libc._dyld_image_count()
+        libraries = [os.fsdecode(name) for i in range(num_images)
+                        if (name := _dyld_get_image_name(i)) is not None]
+
+        return libraries
+
 elif sys.platform.startswith("aix"):
     # AIX has two styles of storing shared libraries
     # GNU auto_tools refer to these as svr4 and aix
@@ -98,6 +173,25 @@ def find_library(name):
         fname = f"{directory}/lib{name}.so"
         return fname if os.path.isfile(fname) else None
 
+elif sys.platform == "emscripten":
+    def _is_wasm(filename):
+        # Return True if the given file is an WASM module
+        wasm_header = b"\x00asm"
+        with open(filename, 'br') as thefile:
+            return thefile.read(4) == wasm_header
+
+    def find_library(name):
+        candidates = [f"lib{name}.so", f"lib{name}.wasm"]
+        paths = os.environ.get("LD_LIBRARY_PATH", "")
+        for libdir in paths.split(":"):
+            for name in candidates:
+                libfile = os.path.join(libdir, name)
+
+                if os.path.isfile(libfile) and _is_wasm(libfile):
+                    return libfile
+
+        return None
+
 elif os.name == "posix":
     # Andreas Degert's find functions, using gcc, /sbin/ldconfig, objdump
     import re, tempfile
@@ -341,6 +435,55 @@ def find_library(name):
             return _findSoname_ldconfig(name) or \
                    _get_soname(_findLib_gcc(name)) or _get_soname(_findLib_ld(name))
 
+
+# Listing loaded libraries on other systems will try to use
+# functions common to Linux and a few other Unix-like systems.
+# See the following for several platforms' documentation of the same API:
+# https://man7.org/linux/man-pages/man3/dl_iterate_phdr.3.html
+# https://man.freebsd.org/cgi/man.cgi?query=dl_iterate_phdr
+# https://man.openbsd.org/dl_iterate_phdr
+# https://docs.oracle.com/cd/E88353_01/html/E37843/dl-iterate-phdr-3c.html
+if (os.name == "posix" and
+    sys.platform not in {"darwin", "ios", "tvos", "watchos"}):
+    import ctypes
+    if hasattr((_libc := ctypes.CDLL(None)), "dl_iterate_phdr"):
+
+        class _dl_phdr_info(ctypes.Structure):
+            _fields_ = [
+                ("dlpi_addr", ctypes.c_void_p),
+                ("dlpi_name", ctypes.c_char_p),
+                ("dlpi_phdr", ctypes.c_void_p),
+                ("dlpi_phnum", ctypes.c_ushort),
+            ]
+
+        _dl_phdr_callback = ctypes.CFUNCTYPE(
+            ctypes.c_int,
+            ctypes.POINTER(_dl_phdr_info),
+            ctypes.c_size_t,
+            ctypes.POINTER(ctypes.py_object),
+        )
+
+        @_dl_phdr_callback
+        def _info_callback(info, _size, data):
+            libraries = data.contents.value
+            name = os.fsdecode(info.contents.dlpi_name)
+            libraries.append(name)
+            return 0
+
+        _dl_iterate_phdr = _libc["dl_iterate_phdr"]
+        _dl_iterate_phdr.argtypes = [
+            _dl_phdr_callback,
+            ctypes.POINTER(ctypes.py_object),
+        ]
+        _dl_iterate_phdr.restype = ctypes.c_int
+
+        def dllist():
+            """Return a list of loaded shared libraries in the current process."""
+            libraries = []
+            _dl_iterate_phdr(_info_callback,
+                             ctypes.byref(ctypes.py_object(libraries)))
+            return libraries
+
 ################################################################
 # test code
 
@@ -384,5 +527,12 @@ def test():
             print(cdll.LoadLibrary("libcrypt.so"))
             print(find_library("crypt"))
 
+    try:
+        dllist
+    except NameError:
+        print('dllist() not available')
+    else:
+        print(dllist())
+
 if __name__ == "__main__":
     test()
diff --git a/Lib/ctypes/wintypes.py b/Lib/ctypes/wintypes.py
index 9c4e721438a..4beba0d1951 100644
--- a/Lib/ctypes/wintypes.py
+++ b/Lib/ctypes/wintypes.py
@@ -63,10 +63,16 @@ def __repr__(self):
 HBITMAP = HANDLE
 HBRUSH = HANDLE
 HCOLORSPACE = HANDLE
+HCONV = HANDLE
+HCONVLIST = HANDLE
+HCURSOR = HANDLE
 HDC = HANDLE
+HDDEDATA = HANDLE
 HDESK = HANDLE
+HDROP = HANDLE
 HDWP = HANDLE
 HENHMETAFILE = HANDLE
+HFILE = INT
 HFONT = HANDLE
 HGDIOBJ = HANDLE
 HGLOBAL = HANDLE
@@ -82,9 +88,11 @@ def __repr__(self):
 HMONITOR = HANDLE
 HPALETTE = HANDLE
 HPEN = HANDLE
+HRESULT = LONG
 HRGN = HANDLE
 HRSRC = HANDLE
 HSTR = HANDLE
+HSZ = HANDLE
 HTASK = HANDLE
 HWINSTA = HANDLE
 HWND = HANDLE
diff --git a/Lib/dataclasses.py b/Lib/dataclasses.py
index 7883ce78e57..c8dbb247745 100644
--- a/Lib/dataclasses.py
+++ b/Lib/dataclasses.py
@@ -5,6 +5,7 @@
 import inspect
 import keyword
 import itertools
+import annotationlib
 import abc
 from reprlib import recursive_repr
 
@@ -243,6 +244,10 @@ def __repr__(self):
     property,
 })
 
+# Any marker is used in `make_dataclass` to mark unannotated fields as `Any`
+# without importing `typing` module.
+_ANY_MARKER = object()
+
 
 class InitVar:
     __slots__ = ('type', )
@@ -282,11 +287,12 @@ class Field:
                  'compare',
                  'metadata',
                  'kw_only',
+                 'doc',
                  '_field_type',  # Private: not to be used by user code.
                  )
 
     def __init__(self, default, default_factory, init, repr, hash, compare,
-                 metadata, kw_only):
+                 metadata, kw_only, doc):
         self.name = None
         self.type = None
         self.default = default
@@ -299,6 +305,7 @@ def __init__(self, default, default_factory, init, repr, hash, compare,
                          if metadata is None else
                          types.MappingProxyType(metadata))
         self.kw_only = kw_only
+        self.doc = doc
         self._field_type = None
 
     @recursive_repr()
@@ -314,6 +321,7 @@ def __repr__(self):
                 f'compare={self.compare!r},'
                 f'metadata={self.metadata!r},'
                 f'kw_only={self.kw_only!r},'
+                f'doc={self.doc!r},'
                 f'_field_type={self._field_type}'
                 ')')
 
@@ -381,7 +389,7 @@ def __repr__(self):
 # so that a type checker can be told (via overloads) that this is a
 # function whose type depends on its parameters.
 def field(*, default=MISSING, default_factory=MISSING, init=True, repr=True,
-          hash=None, compare=True, metadata=None, kw_only=MISSING):
+          hash=None, compare=True, metadata=None, kw_only=MISSING, doc=None):
     """Return an object to identify dataclass fields.
 
     default is the default value of the field.  default_factory is a
@@ -393,7 +401,7 @@ def field(*, default=MISSING, default_factory=MISSING, init=True, repr=True,
     comparison functions.  metadata, if specified, must be a mapping
     which is stored but not otherwise examined by dataclass.  If kw_only
     is true, the field will become a keyword-only parameter to
-    __init__().
+    __init__().  doc is an optional docstring for this field.
 
     It is an error to specify both default and default_factory.
     """
@@ -401,7 +409,7 @@ def field(*, default=MISSING, default_factory=MISSING, init=True, repr=True,
     if default is not MISSING and default_factory is not MISSING:
         raise ValueError('cannot specify both default and default_factory')
     return Field(default, default_factory, init, repr, hash, compare,
-                 metadata, kw_only)
+                 metadata, kw_only, doc)
 
 
 def _fields_in_init_order(fields):
@@ -433,9 +441,11 @@ def __init__(self, globals):
         self.locals = {}
         self.overwrite_errors = {}
         self.unconditional_adds = {}
+        self.method_annotations = {}
 
     def add_fn(self, name, args, body, *, locals=None, return_type=MISSING,
-               overwrite_error=False, unconditional_add=False, decorator=None):
+               overwrite_error=False, unconditional_add=False, decorator=None,
+               annotation_fields=None):
         if locals is not None:
             self.locals.update(locals)
 
@@ -456,16 +466,14 @@ def add_fn(self, name, args, body, *, locals=None, return_type=MISSING,
 
         self.names.append(name)
 
-        if return_type is not MISSING:
-            self.locals[f'__dataclass_{name}_return_type__'] = return_type
-            return_annotation = f'->__dataclass_{name}_return_type__'
-        else:
-            return_annotation = ''
+        if annotation_fields is not None:
+            self.method_annotations[name] = (annotation_fields, return_type)
+
         args = ','.join(args)
         body = '\n'.join(body)
 
         # Compute the text of the entire function, add it to the text we're generating.
-        self.src.append(f'{f' {decorator}\n' if decorator else ''} def {name}({args}){return_annotation}:\n{body}')
+        self.src.append(f'{f' {decorator}\n' if decorator else ''} def {name}({args}):\n{body}')
 
     def add_fns_to_class(self, cls):
         # The source to all of the functions we're generating.
@@ -501,6 +509,15 @@ def add_fns_to_class(self, cls):
         # Now that we've generated the functions, assign them into cls.
         for name, fn in zip(self.names, fns):
             fn.__qualname__ = f"{cls.__qualname__}.{fn.__name__}"
+
+            try:
+                annotation_fields, return_type = self.method_annotations[name]
+            except KeyError:
+                pass
+            else:
+                annotate_fn = _make_annotate_function(cls, name, annotation_fields, return_type)
+                fn.__annotate__ = annotate_fn
+
             if self.unconditional_adds.get(name, False):
                 setattr(cls, name, fn)
             else:
@@ -516,6 +533,49 @@ def add_fns_to_class(self, cls):
                     raise TypeError(error_msg)
 
 
+def _make_annotate_function(__class__, method_name, annotation_fields, return_type):
+    # Create an __annotate__ function for a dataclass
+    # Try to return annotations in the same format as they would be
+    # from a regular __init__ function
+
+    def __annotate__(format, /):
+        Format = annotationlib.Format
+        match format:
+            case Format.VALUE | Format.FORWARDREF | Format.STRING:
+                cls_annotations = {}
+                for base in reversed(__class__.__mro__):
+                    cls_annotations.update(
+                        annotationlib.get_annotations(base, format=format)
+                    )
+
+                new_annotations = {}
+                for k in annotation_fields:
+                    # gh-142214: The annotation may be missing in unusual dynamic cases.
+                    # If so, just skip it.
+                    try:
+                        new_annotations[k] = cls_annotations[k]
+                    except KeyError:
+                        pass
+
+                if return_type is not MISSING:
+                    if format == Format.STRING:
+                        new_annotations["return"] = annotationlib.type_repr(return_type)
+                    else:
+                        new_annotations["return"] = return_type
+
+                return new_annotations
+
+            case _:
+                raise NotImplementedError(format)
+
+    # This is a flag for _add_slots to know it needs to regenerate this method
+    # In order to remove references to the original class when it is replaced
+    __annotate__.__generated_by_dataclasses__ = True
+    __annotate__.__qualname__ = f"{__class__.__qualname__}.{method_name}.__annotate__"
+
+    return __annotate__
+
+
 def _field_assign(frozen, name, value, self_name):
     # If we're a frozen class, then assign to our fields in __init__
     # via object.__setattr__.  Otherwise, just use a simple
@@ -604,7 +664,7 @@ def _init_param(f):
     elif f.default_factory is not MISSING:
         # There's a factory function.  Set a marker.
         default = '=__dataclass_HAS_DEFAULT_FACTORY__'
-    return f'{f.name}:__dataclass_type_{f.name}__{default}'
+    return f'{f.name}{default}'
 
 
 def _init_fn(fields, std_fields, kw_only_fields, frozen, has_post_init,
@@ -627,11 +687,10 @@ def _init_fn(fields, std_fields, kw_only_fields, frozen, has_post_init,
                 raise TypeError(f'non-default argument {f.name!r} '
                                 f'follows default argument {seen_default.name!r}')
 
-    locals = {**{f'__dataclass_type_{f.name}__': f.type for f in fields},
-              **{'__dataclass_HAS_DEFAULT_FACTORY__': _HAS_DEFAULT_FACTORY,
-                 '__dataclass_builtins_object__': object,
-                 }
-              }
+    annotation_fields = [f.name for f in fields if f.init]
+
+    locals = {'__dataclass_HAS_DEFAULT_FACTORY__': _HAS_DEFAULT_FACTORY,
+              '__dataclass_builtins_object__': object}
 
     body_lines = []
     for f in fields:
@@ -655,14 +714,15 @@ def _init_fn(fields, std_fields, kw_only_fields, frozen, has_post_init,
     if kw_only_fields:
         # Add the keyword-only args.  Because the * can only be added if
         # there's at least one keyword-only arg, there needs to be a test here
-        # (instead of just concatenting the lists together).
+        # (instead of just concatenating the lists together).
         _init_params += ['*']
         _init_params += [_init_param(f) for f in kw_only_fields]
     func_builder.add_fn('__init__',
                         [self_name] + _init_params,
                         body_lines,
                         locals=locals,
-                        return_type=None)
+                        return_type=None,
+                        annotation_fields=annotation_fields)
 
 
 def _frozen_get_del_attr(cls, fields, func_builder):
@@ -689,11 +749,8 @@ def _frozen_get_del_attr(cls, fields, func_builder):
 
 
 def _is_classvar(a_type, typing):
-    # This test uses a typing internal class, but it's the best way to
-    # test if this is a ClassVar.
     return (a_type is typing.ClassVar
-            or (type(a_type) is typing._GenericAlias
-                and a_type.__origin__ is typing.ClassVar))
+            or (typing.get_origin(a_type) is typing.ClassVar))
 
 
 def _is_initvar(a_type, dataclasses):
@@ -981,7 +1038,8 @@ def _process_class(cls, init, repr, eq, order, unsafe_hash, frozen,
     # actual default value.  Pseudo-fields ClassVars and InitVars are
     # included, despite the fact that they're not real fields.  That's
     # dealt with later.
-    cls_annotations = inspect.get_annotations(cls)
+    cls_annotations = annotationlib.get_annotations(
+        cls, format=annotationlib.Format.FORWARDREF)
 
     # Now find fields in our class.  While doing so, validate some
     # things, and set the default values (as class attributes) where
@@ -1161,7 +1219,10 @@ def _process_class(cls, init, repr, eq, order, unsafe_hash, frozen,
         try:
             # In some cases fetching a signature is not possible.
             # But, we surely should not fail in this case.
-            text_sig = str(inspect.signature(cls)).replace(' -> None', '')
+            text_sig = str(inspect.signature(
+                cls,
+                annotation_format=annotationlib.Format.FORWARDREF,
+            )).replace(' -> None', '')
         except (TypeError, ValueError):
             text_sig = ''
         cls.__doc__ = (cls.__name__ + text_sig)
@@ -1175,7 +1236,7 @@ def _process_class(cls, init, repr, eq, order, unsafe_hash, frozen,
     if weakref_slot and not slots:
         raise TypeError('weakref_slot is True but slots is False')
     if slots:
-        cls = _add_slots(cls, frozen, weakref_slot)
+        cls = _add_slots(cls, frozen, weakref_slot, fields)
 
     abc.update_abstractmethods(cls)
 
@@ -1219,14 +1280,65 @@ def _get_slots(cls):
             raise TypeError(f"Slots of '{cls.__name__}' cannot be determined")
 
 
-def _add_slots(cls, is_frozen, weakref_slot):
-    # Need to create a new class, since we can't set __slots__
-    #  after a class has been created.
+def _update_func_cell_for__class__(f, oldcls, newcls):
+    # Returns True if we update a cell, else False.
+    if f is None:
+        # f will be None in the case of a property where not all of
+        # fget, fset, and fdel are used.  Nothing to do in that case.
+        return False
+    try:
+        idx = f.__code__.co_freevars.index("__class__")
+    except ValueError:
+        # This function doesn't reference __class__, so nothing to do.
+        return False
+    # Fix the cell to point to the new class, if it's already pointing
+    # at the old class.  I'm not convinced that the "is oldcls" test
+    # is needed, but other than performance can't hurt.
+    closure = f.__closure__[idx]
+    if closure.cell_contents is oldcls:
+        closure.cell_contents = newcls
+        return True
+    return False
+
+
+def _create_slots(defined_fields, inherited_slots, field_names, weakref_slot):
+    # The slots for our class.  Remove slots from our base classes.  Add
+    # '__weakref__' if weakref_slot was given, unless it is already present.
+    seen_docs = False
+    slots = {}
+    for slot in itertools.filterfalse(
+        inherited_slots.__contains__,
+        itertools.chain(
+            # gh-93521: '__weakref__' also needs to be filtered out if
+            # already present in inherited_slots
+            field_names, ('__weakref__',) if weakref_slot else ()
+        )
+    ):
+        doc = getattr(defined_fields.get(slot), 'doc', None)
+        if doc is not None:
+            seen_docs = True
+        slots[slot] = doc
+
+    # We only return dict if there's at least one doc member,
+    # otherwise we return tuple, which is the old default format.
+    if seen_docs:
+        return slots
+    return tuple(slots)
+
+
+def _add_slots(cls, is_frozen, weakref_slot, defined_fields):
+    # Need to create a new class, since we can't set __slots__ after a
+    # class has been created, and the @dataclass decorator is called
+    # after the class is created.
 
     # Make sure __slots__ isn't already set.
     if '__slots__' in cls.__dict__:
         raise TypeError(f'{cls.__name__} already specifies __slots__')
 
+    # gh-102069: Remove existing __weakref__ descriptor.
+    # gh-135228: Make sure the original class can be garbage collected.
+    sys._clear_type_descriptors(cls)
+
     # Create a new dict for our new class.
     cls_dict = dict(cls.__dict__)
     field_names = tuple(f.name for f in fields(cls))
@@ -1234,17 +1346,9 @@ def _add_slots(cls, is_frozen, weakref_slot):
     inherited_slots = set(
         itertools.chain.from_iterable(map(_get_slots, cls.__mro__[1:-1]))
     )
-    # The slots for our class.  Remove slots from our base classes.  Add
-    # '__weakref__' if weakref_slot was given, unless it is already present.
-    cls_dict["__slots__"] = tuple(
-        itertools.filterfalse(
-            inherited_slots.__contains__,
-            itertools.chain(
-                # gh-93521: '__weakref__' also needs to be filtered out if
-                # already present in inherited_slots
-                field_names, ('__weakref__',) if weakref_slot else ()
-            )
-        ),
+
+    cls_dict["__slots__"] = _create_slots(
+        defined_fields, inherited_slots, field_names, weakref_slot,
     )
 
     for field_name in field_names:
@@ -1252,26 +1356,59 @@ def _add_slots(cls, is_frozen, weakref_slot):
         #  available in _MARKER.
         cls_dict.pop(field_name, None)
 
-    # Remove __dict__ itself.
-    cls_dict.pop('__dict__', None)
-
-    # Clear existing `__weakref__` descriptor, it belongs to a previous type:
-    cls_dict.pop('__weakref__', None)  # gh-102069
-
     # And finally create the class.
     qualname = getattr(cls, '__qualname__', None)
-    cls = type(cls)(cls.__name__, cls.__bases__, cls_dict)
+    newcls = type(cls)(cls.__name__, cls.__bases__, cls_dict)
     if qualname is not None:
-        cls.__qualname__ = qualname
+        newcls.__qualname__ = qualname
 
     if is_frozen:
         # Need this for pickling frozen classes with slots.
         if '__getstate__' not in cls_dict:
-            cls.__getstate__ = _dataclass_getstate
+            newcls.__getstate__ = _dataclass_getstate
         if '__setstate__' not in cls_dict:
-            cls.__setstate__ = _dataclass_setstate
+            newcls.__setstate__ = _dataclass_setstate
+
+    # Fix up any closures which reference __class__.  This is used to
+    # fix zero argument super so that it points to the correct class
+    # (the newly created one, which we're returning) and not the
+    # original class.  We can break out of this loop as soon as we
+    # make an update, since all closures for a class will share a
+    # given cell.
+    for member in newcls.__dict__.values():
+        # If this is a wrapped function, unwrap it.
+        member = inspect.unwrap(member)
+
+        if isinstance(member, types.FunctionType):
+            if _update_func_cell_for__class__(member, cls, newcls):
+                break
+        elif isinstance(member, property):
+            if (_update_func_cell_for__class__(member.fget, cls, newcls)
+                or _update_func_cell_for__class__(member.fset, cls, newcls)
+                or _update_func_cell_for__class__(member.fdel, cls, newcls)):
+                break
+
+    # Get new annotations to remove references to the original class
+    # in forward references
+    newcls_ann = annotationlib.get_annotations(
+        newcls, format=annotationlib.Format.FORWARDREF)
+
+    # Fix references in dataclass Fields
+    for f in getattr(newcls, _FIELDS).values():
+        try:
+            ann = newcls_ann[f.name]
+        except KeyError:
+            pass
+        else:
+            f.type = ann
 
-    return cls
+    # Fix the class reference in the __annotate__ method
+    init = newcls.__init__
+    if init_annotate := getattr(init, "__annotate__", None):
+        if getattr(init_annotate, "__generated_by_dataclasses__", False):
+            _update_func_cell_for__class__(init_annotate, cls, newcls)
+
+    return newcls
 
 
 def dataclass(cls=None, /, *, init=True, repr=True, eq=True, order=False,
@@ -1490,7 +1627,7 @@ def _astuple_inner(obj, tuple_factory):
 def make_dataclass(cls_name, fields, *, bases=(), namespace=None, init=True,
                    repr=True, eq=True, order=False, unsafe_hash=False,
                    frozen=False, match_args=True, kw_only=False, slots=False,
-                   weakref_slot=False, module=None):
+                   weakref_slot=False, module=None, decorator=dataclass):
     """Return a new dynamically created dataclass.
 
     The dataclass name will be 'cls_name'.  'fields' is an iterable
@@ -1528,7 +1665,7 @@ class C(Base):
     for item in fields:
         if isinstance(item, str):
             name = item
-            tp = 'typing.Any'
+            tp = _ANY_MARKER
         elif len(item) == 2:
             name, tp, = item
         elif len(item) == 3:
@@ -1547,15 +1684,49 @@ class C(Base):
         seen.add(name)
         annotations[name] = tp
 
+    # We initially block the VALUE format, because inside dataclass() we'll
+    # call get_annotations(), which will try the VALUE format first. If we don't
+    # block, that means we'd always end up eagerly importing typing here, which
+    # is what we're trying to avoid.
+    value_blocked = True
+
+    def annotate_method(format):
+        def get_any():
+            match format:
+                case annotationlib.Format.STRING:
+                    return 'typing.Any'
+                case annotationlib.Format.FORWARDREF:
+                    typing = sys.modules.get("typing")
+                    if typing is None:
+                        return annotationlib.ForwardRef("Any", module="typing")
+                    else:
+                        return typing.Any
+                case annotationlib.Format.VALUE:
+                    if value_blocked:
+                        raise NotImplementedError
+                    from typing import Any
+                    return Any
+                case _:
+                    raise NotImplementedError
+        annos = {
+            ann: get_any() if t is _ANY_MARKER else t
+            for ann, t in annotations.items()
+        }
+        if format == annotationlib.Format.STRING:
+            return annotationlib.annotations_to_string(annos)
+        else:
+            return annos
+
     # Update 'ns' with the user-supplied namespace plus our calculated values.
     def exec_body_callback(ns):
         ns.update(namespace)
         ns.update(defaults)
-        ns['__annotations__'] = annotations
 
     # We use `types.new_class()` instead of simply `type()` to allow dynamic creation
     # of generic dataclasses.
     cls = types.new_class(cls_name, bases, {}, exec_body_callback)
+    # For now, set annotations including the _ANY_MARKER.
+    cls.__annotate__ = annotate_method
 
     # For pickling to work, the __module__ variable needs to be set to the frame
     # where the dataclass is created.
@@ -1570,11 +1741,14 @@ def exec_body_callback(ns):
     if module is not None:
         cls.__module__ = module
 
-    # Apply the normal decorator.
-    return dataclass(cls, init=init, repr=repr, eq=eq, order=order,
-                     unsafe_hash=unsafe_hash, frozen=frozen,
-                     match_args=match_args, kw_only=kw_only, slots=slots,
-                     weakref_slot=weakref_slot)
+    # Apply the normal provided decorator.
+    cls = decorator(cls, init=init, repr=repr, eq=eq, order=order,
+                    unsafe_hash=unsafe_hash, frozen=frozen,
+                    match_args=match_args, kw_only=kw_only, slots=slots,
+                    weakref_slot=weakref_slot)
+    # Now that the class is ready, allow the VALUE format.
+    value_blocked = False
+    return cls
 
 
 def replace(obj, /, **changes):
diff --git a/Lib/datetime.py b/Lib/datetime.py
index a33d2d724cb..14f30556584 100644
--- a/Lib/datetime.py
+++ b/Lib/datetime.py
@@ -1,9 +1,13 @@
+"""Specific date/time and related types.
+
+See https://data.iana.org/time-zones/tz-link.html for
+time zone and DST data sources.
+"""
+
 try:
     from _datetime import *
-    from _datetime import __doc__
 except ImportError:
     from _pydatetime import *
-    from _pydatetime import __doc__
 
 __all__ = ("date", "datetime", "time", "timedelta", "timezone", "tzinfo",
            "MINYEAR", "MAXYEAR", "UTC")
diff --git a/Lib/decimal.py b/Lib/decimal.py
index ee3147f5dde..530bdfb3895 100644
--- a/Lib/decimal.py
+++ b/Lib/decimal.py
@@ -100,8 +100,8 @@
 
 try:
     from _decimal import *
-    from _decimal import __version__
-    from _decimal import __libmpdec_version__
+    from _decimal import __version__  # noqa: F401
+    from _decimal import __libmpdec_version__  # noqa: F401
 except ImportError:
     import _pydecimal
     import sys
diff --git a/Lib/difflib.py b/Lib/difflib.py
index 33e7e6c165a..ac1ba4a6e4e 100644
--- a/Lib/difflib.py
+++ b/Lib/difflib.py
@@ -78,8 +78,8 @@ class SequenceMatcher:
     sequences.  As a rule of thumb, a .ratio() value over 0.6 means the
     sequences are close matches:
 
-    >>> print(round(s.ratio(), 3))
-    0.866
+    >>> print(round(s.ratio(), 2))
+    0.87
     >>>
 
     If you're only interested in where the sequences match,
@@ -908,87 +908,85 @@ def _fancy_replace(self, a, alo, ahi, b, blo, bhi):
         + abcdefGhijkl
         ?    ^  ^  ^
         """
-
-        # don't synch up unless the lines have a similarity score of at
-        # least cutoff; best_ratio tracks the best score seen so far
-        best_ratio, cutoff = 0.74, 0.75
+        # Don't synch up unless the lines have a similarity score above
+        # cutoff. Previously only the smallest pair was handled here,
+        # and if there are many pairs with the best ratio, recursion
+        # could grow very deep, and runtime cubic. See:
+        # https://github.com/python/cpython/issues/119105
+        #
+        # Later, more pathological cases prompted removing recursion
+        # entirely.
+        cutoff = 0.74999
         cruncher = SequenceMatcher(self.charjunk)
-        eqi, eqj = None, None   # 1st indices of equal lines (if any)
+        crqr = cruncher.real_quick_ratio
+        cqr = cruncher.quick_ratio
+        cr = cruncher.ratio
 
-        # search for the pair that matches best without being identical
-        # (identical lines must be junk lines, & we don't want to synch up
-        # on junk -- unless we have to)
+        WINDOW = 10
+        best_i = best_j = None
+        dump_i, dump_j = alo, blo # smallest indices not yet resolved
         for j in range(blo, bhi):
-            bj = b[j]
-            cruncher.set_seq2(bj)
-            for i in range(alo, ahi):
-                ai = a[i]
-                if ai == bj:
-                    if eqi is None:
-                        eqi, eqj = i, j
-                    continue
-                cruncher.set_seq1(ai)
-                # computing similarity is expensive, so use the quick
-                # upper bounds first -- have seen this speed up messy
-                # compares by a factor of 3.
-                # note that ratio() is only expensive to compute the first
-                # time it's called on a sequence pair; the expensive part
-                # of the computation is cached by cruncher
-                if cruncher.real_quick_ratio() > best_ratio and \
-                      cruncher.quick_ratio() > best_ratio and \
-                      cruncher.ratio() > best_ratio:
-                    best_ratio, best_i, best_j = cruncher.ratio(), i, j
-        if best_ratio < cutoff:
-            # no non-identical "pretty close" pair
-            if eqi is None:
-                # no identical pair either -- treat it as a straight replace
-                yield from self._plain_replace(a, alo, ahi, b, blo, bhi)
-                return
-            # no close pair, but an identical pair -- synch up on that
-            best_i, best_j, best_ratio = eqi, eqj, 1.0
-        else:
-            # there's a close pair, so forget the identical pair (if any)
-            eqi = None
-
-        # a[best_i] very similar to b[best_j]; eqi is None iff they're not
-        # identical
-
-        # pump out diffs from before the synch point
-        yield from self._fancy_helper(a, alo, best_i, b, blo, best_j)
-
-        # do intraline marking on the synch pair
-        aelt, belt = a[best_i], b[best_j]
-        if eqi is None:
-            # pump out a '-', '?', '+', '?' quad for the synched lines
-            atags = btags = ""
-            cruncher.set_seqs(aelt, belt)
-            for tag, ai1, ai2, bj1, bj2 in cruncher.get_opcodes():
-                la, lb = ai2 - ai1, bj2 - bj1
-                if tag == 'replace':
-                    atags += '^' * la
-                    btags += '^' * lb
-                elif tag == 'delete':
-                    atags += '-' * la
-                elif tag == 'insert':
-                    btags += '+' * lb
-                elif tag == 'equal':
-                    atags += ' ' * la
-                    btags += ' ' * lb
-                else:
-                    raise ValueError('unknown tag %r' % (tag,))
-            yield from self._qformat(aelt, belt, atags, btags)
-        else:
-            # the synch pair is identical
-            yield '  ' + aelt
+            cruncher.set_seq2(b[j])
+            # Search the corresponding i's within WINDOW for rhe highest
+            # ratio greater than `cutoff`.
+            aequiv = alo + (j - blo)
+            arange = range(max(aequiv - WINDOW, dump_i),
+                           min(aequiv + WINDOW + 1, ahi))
+            if not arange: # likely exit if `a` is shorter than `b`
+                break
+            best_ratio = cutoff
+            for i in arange:
+                cruncher.set_seq1(a[i])
+                # Ordering by cheapest to most expensive ratio is very
+                # valuable, most often getting out early.
+                if (crqr() > best_ratio
+                      and cqr() > best_ratio
+                      and cr() > best_ratio):
+                    best_i, best_j, best_ratio = i, j, cr()
+
+            if best_i is None:
+                # found nothing to synch on yet - move to next j
+                continue
 
-        # pump out diffs from after the synch point
-        yield from self._fancy_helper(a, best_i+1, ahi, b, best_j+1, bhi)
+            # pump out straight replace from before this synch pair
+            yield from self._fancy_helper(a, dump_i, best_i,
+                                          b, dump_j, best_j)
+            # do intraline marking on the synch pair
+            aelt, belt = a[best_i], b[best_j]
+            if aelt != belt:
+                # pump out a '-', '?', '+', '?' quad for the synched lines
+                atags = btags = ""
+                cruncher.set_seqs(aelt, belt)
+                for tag, ai1, ai2, bj1, bj2 in cruncher.get_opcodes():
+                    la, lb = ai2 - ai1, bj2 - bj1
+                    if tag == 'replace':
+                        atags += '^' * la
+                        btags += '^' * lb
+                    elif tag == 'delete':
+                        atags += '-' * la
+                    elif tag == 'insert':
+                        btags += '+' * lb
+                    elif tag == 'equal':
+                        atags += ' ' * la
+                        btags += ' ' * lb
+                    else:
+                        raise ValueError('unknown tag %r' % (tag,))
+                yield from self._qformat(aelt, belt, atags, btags)
+            else:
+                # the synch pair is identical
+                yield '  ' + aelt
+            dump_i, dump_j = best_i + 1, best_j + 1
+            best_i = best_j = None
+
+        # pump out straight replace from after the last synch pair
+        yield from self._fancy_helper(a, dump_i, ahi,
+                                      b, dump_j, bhi)
 
     def _fancy_helper(self, a, alo, ahi, b, blo, bhi):
         g = []
         if alo < ahi:
             if blo < bhi:
-                g = self._fancy_replace(a, alo, ahi, b, blo, bhi)
+                g = self._plain_replace(a, alo, ahi, b, blo, bhi)
             else:
                 g = self._dump('-', a, alo, ahi)
         elif blo < bhi:
@@ -1040,11 +1038,9 @@ def _qformat(self, aline, bline, atags, btags):
 # remaining is that perhaps it was really the case that " volatile"
 # was inserted after "private".  I can live with that <wink>.
 
-import re
-
-def IS_LINE_JUNK(line, pat=re.compile(r"\s*(?:#\s*)?$").match):
+def IS_LINE_JUNK(line, pat=None):
     r"""
-    Return True for ignorable line: iff `line` is blank or contains a single '#'.
+    Return True for ignorable line: if `line` is blank or contains a single '#'.
 
     Examples:
 
@@ -1056,6 +1052,11 @@ def IS_LINE_JUNK(line, pat=re.compile(r"\s*(?:#\s*)?$").match):
     False
     """
 
+    if pat is None:
+        # Default: match '#' or the empty string
+        return line.strip() in '#'
+   # Previous versions used the undocumented parameter 'pat' as a
+   # match function. Retain this behaviour for compatibility.
     return pat(line) is not None
 
 def IS_CHARACTER_JUNK(ch, ws=" \t"):
@@ -1266,6 +1267,12 @@ def _check_types(a, b, *args):
     if b and not isinstance(b[0], str):
         raise TypeError('lines to compare must be str, not %s (%r)' %
                         (type(b[0]).__name__, b[0]))
+    if isinstance(a, str):
+        raise TypeError('input must be a sequence of strings, not %s' %
+                        type(a).__name__)
+    if isinstance(b, str):
+        raise TypeError('input must be a sequence of strings, not %s' %
+                        type(b).__name__)
     for arg in args:
         if not isinstance(arg, str):
             raise TypeError('all arguments must be str, not: %r' % (arg,))
@@ -1628,13 +1635,22 @@ def _line_pair_iterator():
 </html>"""
 
 _styles = """
+        :root {color-scheme: light dark}
         table.diff {font-family: Menlo, Consolas, Monaco, Liberation Mono, Lucida Console, monospace; border:medium}
         .diff_header {background-color:#e0e0e0}
         td.diff_header {text-align:right}
         .diff_next {background-color:#c0c0c0}
-        .diff_add {background-color:#aaffaa}
+        .diff_add {background-color:palegreen}
         .diff_chg {background-color:#ffff77}
-        .diff_sub {background-color:#ffaaaa}"""
+        .diff_sub {background-color:#ffaaaa}
+
+        @media (prefers-color-scheme: dark) {
+            .diff_header {background-color:#666}
+            .diff_next {background-color:#393939}
+            .diff_add {background-color:darkgreen}
+            .diff_chg {background-color:#847415}
+            .diff_sub {background-color:darkred}
+        }"""
 
 _table_template = """
     <table class="diff" id="difflib_chg_%(prefix)s_top"
@@ -2014,7 +2030,6 @@ def make_table(self,fromlines,tolines,fromdesc='',todesc='',context=False,
                      replace('\1','</span>'). \
                      replace('\t','&nbsp;')
 
-del re
 
 def restore(delta, which):
     r"""
@@ -2047,10 +2062,3 @@ def restore(delta, which):
     for line in delta:
         if line[:2] in prefixes:
             yield line[2:]
-
-def _test():
-    import doctest, difflib
-    return doctest.testmod(difflib)
-
-if __name__ == "__main__":
-    _test()
diff --git a/Lib/doctest.py b/Lib/doctest.py
index ecac54ad5a5..a66888d8fc9 100644
--- a/Lib/doctest.py
+++ b/Lib/doctest.py
@@ -109,6 +109,8 @@ def _test():
 from _colorize import ANSIColors, can_colorize
 
 
+__unittest = True
+
 class TestResults(namedtuple('TestResults', 'failed attempted')):
     def __new__(cls, failed, attempted, *, skipped=0):
         results = super().__new__(cls, failed, attempted)
@@ -390,11 +392,11 @@ def __init__(self, out):
         # still use input() to get user input
         self.use_rawinput = 1
 
-    def set_trace(self, frame=None):
+    def set_trace(self, frame=None, *, commands=None):
         self.__debugger_used = True
         if frame is None:
             frame = sys._getframe().f_back
-        pdb.Pdb.set_trace(self, frame)
+        pdb.Pdb.set_trace(self, frame, commands=commands)
 
     def set_continue(self):
         # Calling set_continue unconditionally would break unit test
@@ -1230,7 +1232,7 @@ class DocTestRunner:
     `OutputChecker` to the constructor.
 
     The test runner's display output can be controlled in two ways.
-    First, an output function (`out) can be passed to
+    First, an output function (`out`) can be passed to
     `TestRunner.run`; this function will be called with strings that
     should be displayed.  It defaults to `sys.stdout.write`.  If
     capturing the output is not sufficient, then the display output
@@ -1398,11 +1400,11 @@ def __run(self, test, compileflags, out):
                 exec(compile(example.source, filename, "single",
                              compileflags, True), test.globs)
                 self.debugger.set_continue() # ==== Example Finished ====
-                exception = None
+                exc_info = None
             except KeyboardInterrupt:
                 raise
-            except:
-                exception = sys.exc_info()
+            except BaseException as exc:
+                exc_info = type(exc), exc, exc.__traceback__.tb_next
                 self.debugger.set_continue() # ==== Example Finished ====
 
             got = self._fakeout.getvalue()  # the actual output
@@ -1411,21 +1413,21 @@ def __run(self, test, compileflags, out):
 
             # If the example executed without raising any exceptions,
             # verify its output.
-            if exception is None:
+            if exc_info is None:
                 if check(example.want, got, self.optionflags):
                     outcome = SUCCESS
 
             # The example raised an exception:  check if it was expected.
             else:
-                formatted_ex = traceback.format_exception_only(*exception[:2])
-                if issubclass(exception[0], SyntaxError):
+                formatted_ex = traceback.format_exception_only(*exc_info[:2])
+                if issubclass(exc_info[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__}:",
+                        f"{exc_info[0].__qualname__}:",
+                        f"{exc_info[0].__module__}.{exc_info[0].__qualname__}:",
                     )
                     exc_msg_index = next(
                         index
@@ -1436,7 +1438,7 @@ def __run(self, test, compileflags, out):
 
                 exc_msg = "".join(formatted_ex)
                 if not quiet:
-                    got += _exception_traceback(exception)
+                    got += _exception_traceback(exc_info)
 
                 # If `example.exc_msg` is None, then we weren't expecting
                 # an exception.
@@ -1465,7 +1467,7 @@ def __run(self, test, compileflags, out):
             elif outcome is BOOM:
                 if not quiet:
                     self.report_unexpected_exception(out, test, example,
-                                                     exception)
+                                                     exc_info)
                 failures += 1
             else:
                 assert False, ("unknown outcome", outcome)
@@ -2327,7 +2329,7 @@ def runTest(self):
             sys.stdout = old
 
         if results.failed:
-            raise self.failureException(self.format_failure(new.getvalue()))
+            raise self.failureException(self.format_failure(new.getvalue().rstrip('\n')))
 
     def format_failure(self, err):
         test = self._dt_test
@@ -2737,7 +2739,7 @@ def testsource(module, name):
     return testsrc
 
 def debug_src(src, pm=False, globs=None):
-    """Debug a single doctest docstring, in argument `src`'"""
+    """Debug a single doctest docstring, in argument `src`"""
     testsrc = script_from_examples(src)
     debug_script(testsrc, pm, globs)
 
@@ -2873,7 +2875,7 @@ def get(self):
 def _test():
     import argparse
 
-    parser = argparse.ArgumentParser(description="doctest runner")
+    parser = argparse.ArgumentParser(description="doctest runner", color=True)
     parser.add_argument('-v', '--verbose', action='store_true', default=False,
                         help='print very verbose output for all tests')
     parser.add_argument('-o', '--option', action='append',
diff --git a/Lib/encodings/__init__.py b/Lib/encodings/__init__.py
index f9075b8f0d9..298177eb800 100644
--- a/Lib/encodings/__init__.py
+++ b/Lib/encodings/__init__.py
@@ -156,19 +156,22 @@ def search_function(encoding):
 codecs.register(search_function)
 
 if sys.platform == 'win32':
-    # bpo-671666, bpo-46668: If Python does not implement a codec for current
-    # Windows ANSI code page, use the "mbcs" codec instead:
-    # WideCharToMultiByte() and MultiByteToWideChar() functions with CP_ACP.
-    # Python does not support custom code pages.
-    def _alias_mbcs(encoding):
+    from ._win_cp_codecs import create_win32_code_page_codec
+
+    def win32_code_page_search_function(encoding):
+        encoding = encoding.lower()
+        if not encoding.startswith('cp'):
+            return None
         try:
-            import _winapi
-            ansi_code_page = "cp%s" % _winapi.GetACP()
-            if encoding == ansi_code_page:
-                import encodings.mbcs
-                return encodings.mbcs.getregentry()
-        except ImportError:
-            # Imports may fail while we are shutting down
-            pass
+            cp = int(encoding[2:])
+        except ValueError:
+            return None
+        # Test if the code page is supported
+        try:
+            codecs.code_page_encode(cp, 'x')
+        except (OverflowError, OSError):
+            return None
+
+        return create_win32_code_page_codec(cp)
 
-    codecs.register(_alias_mbcs)
+    codecs.register(win32_code_page_search_function)
diff --git a/Lib/encodings/_win_cp_codecs.py b/Lib/encodings/_win_cp_codecs.py
new file mode 100644
index 00000000000..4f8eb886794
--- /dev/null
+++ b/Lib/encodings/_win_cp_codecs.py
@@ -0,0 +1,36 @@
+import codecs
+
+def create_win32_code_page_codec(cp):
+    from codecs import code_page_encode, code_page_decode
+
+    def encode(input, errors='strict'):
+        return code_page_encode(cp, input, errors)
+
+    def decode(input, errors='strict'):
+        return code_page_decode(cp, input, errors, True)
+
+    class IncrementalEncoder(codecs.IncrementalEncoder):
+        def encode(self, input, final=False):
+            return code_page_encode(cp, input, self.errors)[0]
+
+    class IncrementalDecoder(codecs.BufferedIncrementalDecoder):
+        def _buffer_decode(self, input, errors, final):
+            return code_page_decode(cp, input, errors, final)
+
+    class StreamWriter(codecs.StreamWriter):
+        def encode(self, input, errors='strict'):
+            return code_page_encode(cp, input, errors)
+
+    class StreamReader(codecs.StreamReader):
+        def decode(self, input, errors, final):
+            return code_page_decode(cp, input, errors, final)
+
+    return codecs.CodecInfo(
+        name=f'cp{cp}',
+        encode=encode,
+        decode=decode,
+        incrementalencoder=IncrementalEncoder,
+        incrementaldecoder=IncrementalDecoder,
+        streamreader=StreamReader,
+        streamwriter=StreamWriter,
+    )
diff --git a/Lib/encodings/aliases.py b/Lib/encodings/aliases.py
index 6a5ca046b5e..4ecb6b6e297 100644
--- a/Lib/encodings/aliases.py
+++ b/Lib/encodings/aliases.py
@@ -204,6 +204,11 @@
     'csibm869'           : 'cp869',
     'ibm869'             : 'cp869',
 
+    # cp874 codec
+    '874'                : 'cp874',
+    'ms874'              : 'cp874',
+    'windows_874'        : 'cp874',
+
     # cp932 codec
     '932'                : 'cp932',
     'ms932'              : 'cp932',
@@ -241,6 +246,7 @@
     'ks_c_5601_1987'     : 'euc_kr',
     'ksx1001'            : 'euc_kr',
     'ks_x_1001'          : 'euc_kr',
+    'cseuckr'            : 'euc_kr',
 
     # gb18030 codec
     'gb18030_2000'       : 'gb18030',
@@ -399,6 +405,8 @@
     'iso_8859_8'         : 'iso8859_8',
     'iso_8859_8_1988'    : 'iso8859_8',
     'iso_ir_138'         : 'iso8859_8',
+    'iso_8859_8_i'       : 'iso8859_8',
+    'iso_8859_8_e'       : 'iso8859_8',
 
     # iso8859_9 codec
     'csisolatin5'        : 'iso8859_9',
diff --git a/Lib/enum.py b/Lib/enum.py
index 3adb208c7e6..b4551da1c17 100644
--- a/Lib/enum.py
+++ b/Lib/enum.py
@@ -1,6 +1,5 @@
 import sys
 import builtins as bltns
-from functools import partial
 from types import MappingProxyType, DynamicClassAttribute
 
 
@@ -38,7 +37,7 @@ def _is_descriptor(obj):
     """
     Returns True if obj is a descriptor, False otherwise.
     """
-    return not isinstance(obj, partial) and (
+    return (
             hasattr(obj, '__get__') or
             hasattr(obj, '__set__') or
             hasattr(obj, '__delete__')
@@ -130,7 +129,7 @@ def show_flag_values(value):
 def bin(num, max_bits=None):
     """
     Like built-in bin(), except negative values are represented in
-    twos-compliment, and the leading bit always indicates sign
+    twos-complement, and the leading bit always indicates sign
     (0=positive, 1=negative).
 
     >>> bin(10)
@@ -139,6 +138,7 @@ def bin(num, max_bits=None):
     '0b1 0101'
     """
 
+    num = num.__index__()
     ceiling = 2 ** (num).bit_length()
     if num >= 0:
         s = bltns.bin(num + ceiling).replace('1', '0', 1)
@@ -151,18 +151,6 @@ def bin(num, max_bits=None):
             digits = (sign[-1] * max_bits + digits)[-max_bits:]
     return "%s %s" % (sign, digits)
 
-def _dedent(text):
-    """
-    Like textwrap.dedent.  Rewritten because we cannot import textwrap.
-    """
-    lines = text.split('\n')
-    for i, ch in enumerate(lines[0]):
-        if ch != ' ':
-            break
-    for j, l in enumerate(lines):
-        lines[j] = l[i:]
-    return '\n'.join(lines)
-
 class _not_given:
     def __repr__(self):
         return('<not given>')
@@ -208,7 +196,7 @@ def __get__(self, instance, ownerclass=None):
             # use previous enum.property
             return self.fget(instance)
         elif self._attr_type == 'attr':
-            # look up previous attibute
+            # look up previous attribute
             return getattr(self._cls_type, self.name)
         elif self._attr_type == 'desc':
             # use previous descriptor
@@ -406,12 +394,6 @@ 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
         elif self._cls_name is not None and _is_internal_class(self._cls_name, value):
@@ -1103,6 +1085,21 @@ def _add_member_(cls, name, member):
         # now add to _member_map_ (even aliases)
         cls._member_map_[name] = member
 
+    @property
+    def __signature__(cls):
+        from inspect import Parameter, Signature
+        if cls._member_names_:
+            return Signature([Parameter('values', Parameter.VAR_POSITIONAL)])
+        else:
+            return Signature([Parameter('new_class_name', Parameter.POSITIONAL_ONLY),
+                              Parameter('names', Parameter.POSITIONAL_OR_KEYWORD),
+                              Parameter('module', Parameter.KEYWORD_ONLY, default=None),
+                              Parameter('qualname', Parameter.KEYWORD_ONLY, default=None),
+                              Parameter('type', Parameter.KEYWORD_ONLY, default=None),
+                              Parameter('start', Parameter.KEYWORD_ONLY, default=1),
+                              Parameter('boundary', Parameter.KEYWORD_ONLY, default=None)])
+
+
 EnumMeta = EnumType         # keep EnumMeta name for backwards compatibility
 
 
@@ -1146,13 +1143,6 @@ class Enum(metaclass=EnumType):
     attributes -- see the documentation for details.
     """
 
-    @classmethod
-    def __signature__(cls):
-        if cls._member_names_:
-            return '(*values)'
-        else:
-            return '(new_class_name, /, names, *, module=None, qualname=None, type=None, start=1, boundary=None)'
-
     def __new__(cls, value):
         # all enum instances are actually created during class construction
         # without calling this method; this method is called by the metaclass'
@@ -1214,9 +1204,6 @@ def __new__(cls, value):
             exc = None
             ve_exc = None
 
-    def __init__(self, *args, **kwds):
-        pass
-
     def _add_alias_(self, name):
         self.__class__._add_member_(name, self)
 
@@ -2041,8 +2028,7 @@ def _test_simple_enum(checked_enum, simple_enum):
         ...     RED = auto()
         ...     GREEN = auto()
         ...     BLUE = auto()
-        ... # TODO: RUSTPYTHON
-        >>> _test_simple_enum(CheckedColor, Color)  # doctest: +SKIP
+        >>> _test_simple_enum(CheckedColor, Color)
 
     If differences are found, a :exc:`TypeError` is raised.
     """
diff --git a/Lib/fnmatch.py b/Lib/fnmatch.py
index 73acb1fe8d4..10e1c936688 100644
--- a/Lib/fnmatch.py
+++ b/Lib/fnmatch.py
@@ -9,12 +9,15 @@
 The function translate(PATTERN) returns a regular expression
 corresponding to PATTERN.  (It does not compile it.)
 """
+
+import functools
+import itertools
 import os
 import posixpath
 import re
-import functools
 
-__all__ = ["filter", "fnmatch", "fnmatchcase", "translate"]
+__all__ = ["filter", "filterfalse", "fnmatch", "fnmatchcase", "translate"]
+
 
 def fnmatch(name, pat):
     """Test whether FILENAME matches PATTERN.
@@ -35,6 +38,7 @@ def fnmatch(name, pat):
     pat = os.path.normcase(pat)
     return fnmatchcase(name, pat)
 
+
 @functools.lru_cache(maxsize=32768, typed=True)
 def _compile_pattern(pat):
     if isinstance(pat, bytes):
@@ -45,6 +49,7 @@ def _compile_pattern(pat):
         res = translate(pat)
     return re.compile(res).match
 
+
 def filter(names, pat):
     """Construct a list from those elements of the iterable NAMES that match PAT."""
     result = []
@@ -61,6 +66,22 @@ def filter(names, pat):
                 result.append(name)
     return result
 
+
+def filterfalse(names, pat):
+    """Construct a list from those elements of the iterable NAMES that do not match PAT."""
+    pat = os.path.normcase(pat)
+    match = _compile_pattern(pat)
+    if os.path is posixpath:
+        # normcase on posix is NOP. Optimize it away from the loop.
+        return list(itertools.filterfalse(match, names))
+
+    result = []
+    for name in names:
+        if match(os.path.normcase(name)) is None:
+            result.append(name)
+    return result
+
+
 def fnmatchcase(name, pat):
     """Test whether FILENAME matches PATTERN, including case.
 
@@ -77,24 +98,32 @@ def translate(pat):
     There is no way to quote meta-characters.
     """
 
-    STAR = object()
-    parts = _translate(pat, STAR, '.')
-    return _join_translated_parts(parts, STAR)
+    parts, star_indices = _translate(pat, '*', '.')
+    return _join_translated_parts(parts, star_indices)
+
 
+_re_setops_sub = re.compile(r'([&~|])').sub
+_re_escape = functools.lru_cache(maxsize=512)(re.escape)
 
-def _translate(pat, STAR, QUESTION_MARK):
+
+def _translate(pat, star, question_mark):
     res = []
     add = res.append
+    star_indices = []
+
     i, n = 0, len(pat)
     while i < n:
         c = pat[i]
         i = i+1
         if c == '*':
+            # store the position of the wildcard
+            star_indices.append(len(res))
+            add(star)
             # compress consecutive `*` into one
-            if (not res) or res[-1] is not STAR:
-                add(STAR)
+            while i < n and pat[i] == '*':
+                i += 1
         elif c == '?':
-            add(QUESTION_MARK)
+            add(question_mark)
         elif c == '[':
             j = i
             if j < n and pat[j] == '!':
@@ -133,8 +162,6 @@ def _translate(pat, STAR, QUESTION_MARK):
                     # Hyphens that create ranges shouldn't be escaped.
                     stuff = '-'.join(s.replace('\\', r'\\').replace('-', r'\-')
                                      for s in chunks)
-                # Escape set operations (&&, ~~ and ||).
-                stuff = re.sub(r'([&~|])', r'\\\1', stuff)
                 i = j+1
                 if not stuff:
                     # Empty range: never match.
@@ -143,50 +170,40 @@ def _translate(pat, STAR, QUESTION_MARK):
                     # Negated empty range: match any character.
                     add('.')
                 else:
+                    # Escape set operations (&&, ~~ and ||).
+                    stuff = _re_setops_sub(r'\\\1', stuff)
                     if stuff[0] == '!':
                         stuff = '^' + stuff[1:]
                     elif stuff[0] in ('^', '['):
                         stuff = '\\' + stuff
                     add(f'[{stuff}]')
         else:
-            add(re.escape(c))
-    assert i == n
-    return res
-
-
-def _join_translated_parts(inp, STAR):
-    # Deal with STARs.
-    res = []
-    add = res.append
-    i, n = 0, len(inp)
-    # Fixed pieces at the start?
-    while i < n and inp[i] is not STAR:
-        add(inp[i])
-        i += 1
-    # Now deal with STAR fixed STAR fixed ...
-    # For an interior `STAR fixed` pairing, we want to do a minimal
-    # .*? match followed by `fixed`, with no possibility of backtracking.
-    # Atomic groups ("(?>...)") allow us to spell that directly.
-    # Note: people rely on the undocumented ability to join multiple
-    # translate() results together via "|" to build large regexps matching
-    # "one of many" shell patterns.
-    while i < n:
-        assert inp[i] is STAR
-        i += 1
-        if i == n:
-            add(".*")
-            break
-        assert inp[i] is not STAR
-        fixed = []
-        while i < n and inp[i] is not STAR:
-            fixed.append(inp[i])
-            i += 1
-        fixed = "".join(fixed)
-        if i == n:
-            add(".*")
-            add(fixed)
-        else:
-            add(f"(?>.*?{fixed})")
+            add(_re_escape(c))
     assert i == n
-    res = "".join(res)
-    return fr'(?s:{res})\Z'
+    return res, star_indices
+
+
+def _join_translated_parts(parts, star_indices):
+    if not star_indices:
+        return fr'(?s:{"".join(parts)})\z'
+    iter_star_indices = iter(star_indices)
+    j = next(iter_star_indices)
+    buffer = parts[:j]  # fixed pieces at the start
+    append, extend = buffer.append, buffer.extend
+    i = j + 1
+    for j in iter_star_indices:
+        # Now deal with STAR fixed STAR fixed ...
+        # For an interior `STAR fixed` pairing, we want to do a minimal
+        # .*? match followed by `fixed`, with no possibility of backtracking.
+        # Atomic groups ("(?>...)") allow us to spell that directly.
+        # Note: people rely on the undocumented ability to join multiple
+        # translate() results together via "|" to build large regexps matching
+        # "one of many" shell patterns.
+        append('(?>.*?')
+        extend(parts[i:j])
+        append(')')
+        i = j + 1
+    append('.*')
+    extend(parts[i:])
+    res = ''.join(buffer)
+    return fr'(?s:{res})\z'
diff --git a/Lib/fractions.py b/Lib/fractions.py
index 9d42e809875..a497ee19935 100644
--- a/Lib/fractions.py
+++ b/Lib/fractions.py
@@ -3,7 +3,6 @@
 
 """Fraction, infinite-precision, rational numbers."""
 
-from decimal import Decimal
 import functools
 import math
 import numbers
@@ -65,7 +64,7 @@ def _hash_algorithm(numerator, denominator):
        (?:\.(?P<decimal>\d*|\d+(_\d+)*))?  # an optional fractional part
        (?:E(?P<exp>[-+]?\d+(_\d+)*))?      # and optional exponent
     )
-    \s*\Z                                  # and optional whitespace to finish
+    \s*\z                                  # and optional whitespace to finish
 """, re.VERBOSE | re.IGNORECASE)
 
 
@@ -169,9 +168,13 @@ def _round_to_figures(n, d, figures):
     # A '0' that's *not* followed by another digit is parsed as a minimum width
     # rather than a zeropad flag.
     (?P<zeropad>0(?=[0-9]))?
-    (?P<minimumwidth>0|[1-9][0-9]*)?
+    (?P<minimumwidth>[0-9]+)?
     (?P<thousands_sep>[,_])?
-    (?:\.(?P<precision>0|[1-9][0-9]*))?
+    (?:\.
+        (?=[,_0-9])  # lookahead for digit or separator
+        (?P<precision>[0-9]+)?
+        (?P<frac_separators>[,_])?
+    )?
     (?P<presentation_type>[eEfFgG%])
 """, re.DOTALL | re.VERBOSE).fullmatch
 
@@ -244,7 +247,9 @@ def __new__(cls, numerator=0, denominator=None):
                 self._denominator = numerator.denominator
                 return self
 
-            elif isinstance(numerator, (float, Decimal)):
+            elif (isinstance(numerator, float) or
+                  (not isinstance(numerator, type) and
+                   hasattr(numerator, 'as_integer_ratio'))):
                 # Exact conversion
                 self._numerator, self._denominator = numerator.as_integer_ratio()
                 return self
@@ -278,8 +283,8 @@ def __new__(cls, numerator=0, denominator=None):
                     numerator = -numerator
 
             else:
-                raise TypeError("argument should be a string "
-                                "or a Rational instance")
+                raise TypeError("argument should be a string or a Rational "
+                                "instance or have the as_integer_ratio() method")
 
         elif type(numerator) is int is type(denominator):
             pass # *very* normal case
@@ -305,6 +310,28 @@ def __new__(cls, numerator=0, denominator=None):
         self._denominator = denominator
         return self
 
+    @classmethod
+    def from_number(cls, number):
+        """Converts a finite real number to a rational number, exactly.
+
+        Beware that Fraction.from_number(0.3) != Fraction(3, 10).
+
+        """
+        if type(number) is int:
+            return cls._from_coprime_ints(number, 1)
+
+        elif isinstance(number, numbers.Rational):
+            return cls._from_coprime_ints(number.numerator, number.denominator)
+
+        elif (isinstance(number, float) or
+              (not isinstance(number, type) and
+               hasattr(number, 'as_integer_ratio'))):
+            return cls._from_coprime_ints(*number.as_integer_ratio())
+
+        else:
+            raise TypeError("argument should be a Rational instance or "
+                            "have the as_integer_ratio() method")
+
     @classmethod
     def from_float(cls, f):
         """Converts a finite float to a rational number, exactly.
@@ -476,6 +503,7 @@ def _format_float_style(self, match):
         minimumwidth = int(match["minimumwidth"] or "0")
         thousands_sep = match["thousands_sep"]
         precision = int(match["precision"] or "6")
+        frac_sep = match["frac_separators"] or ""
         presentation_type = match["presentation_type"]
         trim_zeros = presentation_type in "gG" and not alternate_form
         trim_point = not alternate_form
@@ -532,6 +560,9 @@ def _format_float_style(self, match):
         if trim_zeros:
             frac_part = frac_part.rstrip("0")
         separator = "" if trim_point and not frac_part else "."
+        if frac_sep:
+            frac_part = frac_sep.join(frac_part[pos:pos + 3]
+                                      for pos in range(0, len(frac_part), 3))
         trailing = separator + frac_part + suffix
 
         # Do zero padding if required.
@@ -671,7 +702,7 @@ def forward(a, b):
             elif isinstance(b, float):
                 return fallback_operator(float(a), b)
             elif handle_complex and isinstance(b, complex):
-                return fallback_operator(complex(a), b)
+                return fallback_operator(float(a), b)
             else:
                 return NotImplemented
         forward.__name__ = '__' + fallback_operator.__name__ + '__'
@@ -684,7 +715,7 @@ def reverse(b, a):
             elif isinstance(a, numbers.Real):
                 return fallback_operator(float(a), float(b))
             elif handle_complex and isinstance(a, numbers.Complex):
-                return fallback_operator(complex(a), complex(b))
+                return fallback_operator(complex(a), float(b))
             else:
                 return NotImplemented
         reverse.__name__ = '__r' + fallback_operator.__name__ + '__'
@@ -851,7 +882,7 @@ def _mod(a, b):
 
     __mod__, __rmod__ = _operator_fallbacks(_mod, operator.mod, False)
 
-    def __pow__(a, b):
+    def __pow__(a, b, modulo=None):
         """a ** b
 
         If b is not an integer, the result will be a float or complex
@@ -859,6 +890,8 @@ def __pow__(a, b):
         result will be rational.
 
         """
+        if modulo is not None:
+            return NotImplemented
         if isinstance(b, numbers.Rational):
             if b.denominator == 1:
                 power = b.numerator
@@ -883,8 +916,10 @@ def __pow__(a, b):
         else:
             return NotImplemented
 
-    def __rpow__(b, a):
+    def __rpow__(b, a, modulo=None):
         """a ** b"""
+        if modulo is not None:
+            return NotImplemented
         if b._denominator == 1 and b._numerator >= 0:
             # If a is an int, keep it that way if possible.
             return a ** b._numerator
diff --git a/Lib/ftplib.py b/Lib/ftplib.py
index 10c5d1ea08a..50771e8c17c 100644
--- a/Lib/ftplib.py
+++ b/Lib/ftplib.py
@@ -343,7 +343,7 @@ def ntransfercmd(self, cmd, rest=None):
         connection and the expected size of the transfer.  The
         expected size may be None if it could not be determined.
 
-        Optional `rest' argument can be a string that is sent as the
+        Optional 'rest' argument can be a string that is sent as the
         argument to a REST command.  This is essentially a server
         marker used to tell the server to skip over any data up to the
         given marker.
diff --git a/Lib/getopt.py b/Lib/getopt.py
index 5419d77f5d7..25f3e2439b3 100644
--- a/Lib/getopt.py
+++ b/Lib/getopt.py
@@ -2,8 +2,8 @@
 
 This module helps scripts to parse the command line arguments in
 sys.argv.  It supports the same conventions as the Unix getopt()
-function (including the special meanings of arguments of the form `-'
-and `--').  Long options similar to those supported by GNU software
+function (including the special meanings of arguments of the form '-'
+and '--').  Long options similar to those supported by GNU software
 may be used as well via an optional third argument.  This module
 provides two functions and an exception:
 
@@ -24,21 +24,14 @@
 # TODO for gnu_getopt():
 #
 # - GNU getopt_long_only mechanism
-# - allow the caller to specify ordering
-# - RETURN_IN_ORDER option
-# - GNU extension with '-' as first character of option string
-# - optional arguments, specified by double colons
 # - an option string with a W followed by semicolon should
 #   treat "-W foo" as "--foo"
 
 __all__ = ["GetoptError","error","getopt","gnu_getopt"]
 
 import os
-try:
-    from gettext import gettext as _
-except ImportError:
-    # Bootstrapping Python: gettext's dependencies not built yet
-    def _(s): return s
+from gettext import gettext as _
+
 
 class GetoptError(Exception):
     opt = ''
@@ -61,12 +54,14 @@ def getopt(args, shortopts, longopts = []):
     running program.  Typically, this means "sys.argv[1:]".  shortopts
     is the string of option letters that the script wants to
     recognize, with options that require an argument followed by a
-    colon (i.e., the same format that Unix getopt() uses).  If
+    colon and options that accept an optional argument followed by
+    two colons (i.e., the same format that Unix getopt() uses).  If
     specified, longopts is a list of strings with the names of the
     long options which should be supported.  The leading '--'
     characters should not be included in the option name.  Options
     which require an argument should be followed by an equal sign
-    ('=').
+    ('=').  Options which accept an optional argument should be
+    followed by an equal sign and question mark ('=?').
 
     The return value consists of two elements: the first is a list of
     (option, value) pairs; the second is the list of program arguments
@@ -105,7 +100,7 @@ def gnu_getopt(args, shortopts, longopts = []):
     processing options as soon as a non-option argument is
     encountered.
 
-    If the first character of the option string is `+', or if the
+    If the first character of the option string is '+', or if the
     environment variable POSIXLY_CORRECT is set, then option
     processing stops as soon as a non-option argument is encountered.
 
@@ -118,8 +113,13 @@ def gnu_getopt(args, shortopts, longopts = []):
     else:
         longopts = list(longopts)
 
+    return_in_order = False
+    if shortopts.startswith('-'):
+        shortopts = shortopts[1:]
+        all_options_first = False
+        return_in_order = True
     # Allow options after non-option arguments?
-    if shortopts.startswith('+'):
+    elif shortopts.startswith('+'):
         shortopts = shortopts[1:]
         all_options_first = True
     elif os.environ.get("POSIXLY_CORRECT"):
@@ -133,8 +133,14 @@ def gnu_getopt(args, shortopts, longopts = []):
             break
 
         if args[0][:2] == '--':
+            if return_in_order and prog_args:
+                opts.append((None, prog_args))
+                prog_args = []
             opts, args = do_longs(opts, args[0][2:], longopts, args[1:])
         elif args[0][:1] == '-' and args[0] != '-':
+            if return_in_order and prog_args:
+                opts.append((None, prog_args))
+                prog_args = []
             opts, args = do_shorts(opts, args[0][1:], shortopts, args[1:])
         else:
             if all_options_first:
@@ -156,7 +162,7 @@ def do_longs(opts, opt, longopts, args):
 
     has_arg, opt = long_has_args(opt, longopts)
     if has_arg:
-        if optarg is None:
+        if optarg is None and has_arg != '?':
             if not args:
                 raise GetoptError(_('option --%s requires argument') % opt, opt)
             optarg, args = args[0], args[1:]
@@ -177,13 +183,19 @@ def long_has_args(opt, longopts):
         return False, opt
     elif opt + '=' in possibilities:
         return True, opt
-    # No exact match, so better be unique.
+    elif opt + '=?' in possibilities:
+        return '?', opt
+    # Possibilities must be unique to be accepted
     if len(possibilities) > 1:
-        # XXX since possibilities contains all valid continuations, might be
-        # nice to work them into the error msg
-        raise GetoptError(_('option --%s not a unique prefix') % opt, opt)
+        raise GetoptError(
+            _("option --%s not a unique prefix; possible options: %s")
+            % (opt, ", ".join(possibilities)),
+            opt,
+        )
     assert len(possibilities) == 1
     unique_match = possibilities[0]
+    if unique_match.endswith('=?'):
+        return '?', unique_match[:-2]
     has_arg = unique_match.endswith('=')
     if has_arg:
         unique_match = unique_match[:-1]
@@ -192,8 +204,9 @@ def long_has_args(opt, longopts):
 def do_shorts(opts, optstring, shortopts, args):
     while optstring != '':
         opt, optstring = optstring[0], optstring[1:]
-        if short_has_arg(opt, shortopts):
-            if optstring == '':
+        has_arg = short_has_arg(opt, shortopts)
+        if has_arg:
+            if optstring == '' and has_arg != '?':
                 if not args:
                     raise GetoptError(_('option -%s requires argument') % opt,
                                       opt)
@@ -207,7 +220,11 @@ def do_shorts(opts, optstring, shortopts, args):
 def short_has_arg(opt, shortopts):
     for i in range(len(shortopts)):
         if opt == shortopts[i] != ':':
-            return shortopts.startswith(':', i+1)
+            if not shortopts.startswith(':', i+1):
+                return False
+            if shortopts.startswith('::', i+1):
+                return '?'
+            return True
     raise GetoptError(_('option -%s not recognized') % opt, opt)
 
 if __name__ == '__main__':
diff --git a/Lib/getpass.py b/Lib/getpass.py
index bd0097ced94..3d9bb1f0d14 100644
--- a/Lib/getpass.py
+++ b/Lib/getpass.py
@@ -1,6 +1,7 @@
 """Utilities to get a password and/or the current user name.
 
-getpass(prompt[, stream]) - Prompt for a password, with echo turned off.
+getpass(prompt[, stream[, echo_char]]) - Prompt for a password, with echo
+turned off and optional keyboard feedback.
 getuser() - Get the user name from the environment or password database.
 
 GetPassWarning - This UserWarning is issued when getpass() cannot prevent
@@ -25,13 +26,15 @@
 class GetPassWarning(UserWarning): pass
 
 
-def unix_getpass(prompt='Password: ', stream=None):
+def unix_getpass(prompt='Password: ', stream=None, *, echo_char=None):
     """Prompt for a password, with echo turned off.
 
     Args:
       prompt: Written on stream to ask for the input.  Default: 'Password: '
       stream: A writable file object to display the prompt.  Defaults to
               the tty.  If no tty is available defaults to sys.stderr.
+      echo_char: A single ASCII character to mask input (e.g., '*').
+              If None, input is hidden.
     Returns:
       The seKr3t input.
     Raises:
@@ -40,6 +43,8 @@ def unix_getpass(prompt='Password: ', stream=None):
 
     Always restores terminal settings before returning.
     """
+    _check_echo_char(echo_char)
+
     passwd = None
     with contextlib.ExitStack() as stack:
         try:
@@ -68,12 +73,16 @@ def unix_getpass(prompt='Password: ', stream=None):
                 old = termios.tcgetattr(fd)     # a copy to save
                 new = old[:]
                 new[3] &= ~termios.ECHO  # 3 == 'lflags'
+                if echo_char:
+                    new[3] &= ~termios.ICANON
                 tcsetattr_flags = termios.TCSAFLUSH
                 if hasattr(termios, 'TCSASOFT'):
                     tcsetattr_flags |= termios.TCSASOFT
                 try:
                     termios.tcsetattr(fd, tcsetattr_flags, new)
-                    passwd = _raw_input(prompt, stream, input=input)
+                    passwd = _raw_input(prompt, stream, input=input,
+                                        echo_char=echo_char)
+
                 finally:
                     termios.tcsetattr(fd, tcsetattr_flags, old)
                     stream.flush()  # issue7208
@@ -93,10 +102,11 @@ def unix_getpass(prompt='Password: ', stream=None):
         return passwd
 
 
-def win_getpass(prompt='Password: ', stream=None):
+def win_getpass(prompt='Password: ', stream=None, *, echo_char=None):
     """Prompt for password with echo off, using Windows getwch()."""
     if sys.stdin is not sys.__stdin__:
         return fallback_getpass(prompt, stream)
+    _check_echo_char(echo_char)
 
     for c in prompt:
         msvcrt.putwch(c)
@@ -108,25 +118,48 @@ def win_getpass(prompt='Password: ', stream=None):
         if c == '\003':
             raise KeyboardInterrupt
         if c == '\b':
+            if echo_char and pw:
+                msvcrt.putwch('\b')
+                msvcrt.putwch(' ')
+                msvcrt.putwch('\b')
             pw = pw[:-1]
         else:
             pw = pw + c
+            if echo_char:
+                msvcrt.putwch(echo_char)
     msvcrt.putwch('\r')
     msvcrt.putwch('\n')
     return pw
 
 
-def fallback_getpass(prompt='Password: ', stream=None):
+def fallback_getpass(prompt='Password: ', stream=None, *, echo_char=None):
+    _check_echo_char(echo_char)
     import warnings
     warnings.warn("Can not control echo on the terminal.", GetPassWarning,
                   stacklevel=2)
     if not stream:
         stream = sys.stderr
     print("Warning: Password input may be echoed.", file=stream)
-    return _raw_input(prompt, stream)
+    return _raw_input(prompt, stream, echo_char=echo_char)
+
 
+def _check_echo_char(echo_char):
+    # Single-character ASCII excluding control characters
+    if echo_char is None:
+        return
+    if not isinstance(echo_char, str):
+        raise TypeError("'echo_char' must be a str or None, not "
+                        f"{type(echo_char).__name__}")
+    if not (
+        len(echo_char) == 1
+        and echo_char.isprintable()
+        and echo_char.isascii()
+    ):
+        raise ValueError("'echo_char' must be a single printable ASCII "
+                         f"character, got: {echo_char!r}")
 
-def _raw_input(prompt="", stream=None, input=None):
+
+def _raw_input(prompt="", stream=None, input=None, echo_char=None):
     # This doesn't save the string in the GNU readline history.
     if not stream:
         stream = sys.stderr
@@ -143,6 +176,8 @@ def _raw_input(prompt="", stream=None, input=None):
             stream.write(prompt)
         stream.flush()
     # NOTE: The Python C API calls flockfile() (and unlock) during readline.
+    if echo_char:
+        return _readline_with_echo_char(stream, input, echo_char)
     line = input.readline()
     if not line:
         raise EOFError
@@ -151,6 +186,35 @@ def _raw_input(prompt="", stream=None, input=None):
     return line
 
 
+def _readline_with_echo_char(stream, input, echo_char):
+    passwd = ""
+    eof_pressed = False
+    while True:
+        char = input.read(1)
+        if char == '\n' or char == '\r':
+            break
+        elif char == '\x03':
+            raise KeyboardInterrupt
+        elif char == '\x7f' or char == '\b':
+            if passwd:
+                stream.write("\b \b")
+                stream.flush()
+            passwd = passwd[:-1]
+        elif char == '\x04':
+            if eof_pressed:
+                break
+            else:
+                eof_pressed = True
+        elif char == '\x00':
+            continue
+        else:
+            passwd += char
+            stream.write(echo_char)
+            stream.flush()
+            eof_pressed = False
+    return passwd
+
+
 def getuser():
     """Get the username from the environment or password database.
 
diff --git a/Lib/gettext.py b/Lib/gettext.py
index 62cff81b7b3..6c11ab2b1eb 100644
--- a/Lib/gettext.py
+++ b/Lib/gettext.py
@@ -41,14 +41,10 @@
 #   to do binary searches and lazy initializations.  Or you might want to use
 #   the undocumented double-hash algorithm for .mo files with hash tables, but
 #   you'll need to study the GNU gettext code to do this.
-#
-# - Support Solaris .mo file formats.  Unfortunately, we've been unable to
-#   find this format documented anywhere.
 
 
 import operator
 import os
-import re
 import sys
 
 
@@ -70,22 +66,26 @@
 # https://www.gnu.org/software/gettext/manual/gettext.html#Plural-forms
 # http://git.savannah.gnu.org/cgit/gettext.git/tree/gettext-runtime/intl/plural.y
 
-_token_pattern = re.compile(r"""
-        (?P<WHITESPACES>[ \t]+)                    | # spaces and horizontal tabs
-        (?P<NUMBER>[0-9]+\b)                       | # decimal integer
-        (?P<NAME>n\b)                              | # only n is allowed
-        (?P<PARENTHESIS>[()])                      |
-        (?P<OPERATOR>[-*/%+?:]|[><!]=?|==|&&|\|\|) | # !, *, /, %, +, -, <, >,
-                                                     # <=, >=, ==, !=, &&, ||,
-                                                     # ? :
-                                                     # unary and bitwise ops
-                                                     # not allowed
-        (?P<INVALID>\w+|.)                           # invalid token
-    """, re.VERBOSE|re.DOTALL)
-
+_token_pattern = None
 
 def _tokenize(plural):
-    for mo in re.finditer(_token_pattern, plural):
+    global _token_pattern
+    if _token_pattern is None:
+        import re
+        _token_pattern = re.compile(r"""
+                (?P<WHITESPACES>[ \t]+)                    | # spaces and horizontal tabs
+                (?P<NUMBER>[0-9]+\b)                       | # decimal integer
+                (?P<NAME>n\b)                              | # only n is allowed
+                (?P<PARENTHESIS>[()])                      |
+                (?P<OPERATOR>[-*/%+?:]|[><!]=?|==|&&|\|\|) | # !, *, /, %, +, -, <, >,
+                                                             # <=, >=, ==, !=, &&, ||,
+                                                             # ? :
+                                                             # unary and bitwise ops
+                                                             # not allowed
+                (?P<INVALID>\w+|.)                           # invalid token
+            """, re.VERBOSE|re.DOTALL)
+
+    for mo in _token_pattern.finditer(plural):
         kind = mo.lastgroup
         if kind == 'WHITESPACES':
             continue
@@ -648,7 +648,7 @@ def npgettext(context, msgid1, msgid2, n):
 #    import gettext
 #    cat = gettext.Catalog(PACKAGE, localedir=LOCALEDIR)
 #    _ = cat.gettext
-#    print _('Hello World')
+#    print(_('Hello World'))
 
 # The resulting catalog object currently don't support access through a
 # dictionary API, which was supported (but apparently unused) in GNOME
diff --git a/Lib/glob.py b/Lib/glob.py
index c506e0e2157..f1a87c82fc5 100644
--- a/Lib/glob.py
+++ b/Lib/glob.py
@@ -22,6 +22,9 @@ def glob(pathname, *, root_dir=None, dir_fd=None, recursive=False,
     dot are special cases that are not matched by '*' and '?'
     patterns by default.
 
+    The order of the returned list is undefined. Sort it if you need a
+    particular order.
+
     If `include_hidden` is true, the patterns '*', '?', '**'  will match hidden
     directories.
 
@@ -40,6 +43,9 @@ def iglob(pathname, *, root_dir=None, dir_fd=None, recursive=False,
     dot are special cases that are not matched by '*' and '?'
     patterns.
 
+    The order of the returned paths is undefined. Sort them if you need a
+    particular order.
+
     If recursive is true, the pattern '**' will match any files and
     zero or more directories and subdirectories.
     """
@@ -312,24 +318,24 @@ def translate(pat, *, recursive=False, include_hidden=False, seps=None):
             if part:
                 if not include_hidden and part[0] in '*?':
                     results.append(r'(?!\.)')
-                results.extend(fnmatch._translate(part, f'{not_sep}*', not_sep))
+                results.extend(fnmatch._translate(part, f'{not_sep}*', not_sep)[0])
             if idx < last_part_idx:
                 results.append(any_sep)
     res = ''.join(results)
-    return fr'(?s:{res})\Z'
+    return fr'(?s:{res})\z'
 
 
 @functools.lru_cache(maxsize=512)
-def _compile_pattern(pat, sep, case_sensitive, recursive=True):
+def _compile_pattern(pat, seps, case_sensitive, recursive=True):
     """Compile given glob pattern to a re.Pattern object (observing case
     sensitivity)."""
     flags = re.NOFLAG if case_sensitive else re.IGNORECASE
-    regex = translate(pat, recursive=recursive, include_hidden=True, seps=sep)
+    regex = translate(pat, recursive=recursive, include_hidden=True, seps=seps)
     return re.compile(regex, flags=flags).match
 
 
-class _Globber:
-    """Class providing shell-style pattern matching and globbing.
+class _GlobberBase:
+    """Abstract class providing shell-style pattern matching and globbing.
     """
 
     def __init__(self, sep, case_sensitive, case_pedantic=False, recursive=False):
@@ -338,34 +344,31 @@ def __init__(self, sep, case_sensitive, case_pedantic=False, recursive=False):
         self.case_pedantic = case_pedantic
         self.recursive = recursive
 
-    # Low-level methods
-
-    lstat = operator.methodcaller('lstat')
-    add_slash = operator.methodcaller('joinpath', '')
+    # Abstract methods
 
     @staticmethod
-    def scandir(path):
-        """Emulates os.scandir(), which returns an object that can be used as
-        a context manager. This method is called by walk() and glob().
+    def lexists(path):
+        """Implements os.path.lexists().
         """
-        return contextlib.nullcontext(path.iterdir())
+        raise NotImplementedError
 
     @staticmethod
-    def concat_path(path, text):
-        """Appends text to the given path.
+    def scandir(path):
+        """Like os.scandir(), but generates (entry, name, path) tuples.
         """
-        return path.with_segments(path._raw_path + text)
+        raise NotImplementedError
 
     @staticmethod
-    def parse_entry(entry):
-        """Returns the path of an entry yielded from scandir().
+    def concat_path(path, text):
+        """Implements path concatenation.
         """
-        return entry
+        raise NotImplementedError
 
     # High-level methods
 
-    def compile(self, pat):
-        return _compile_pattern(pat, self.sep, self.case_sensitive, self.recursive)
+    def compile(self, pat, altsep=None):
+        seps = (self.sep, altsep) if altsep else self.sep
+        return _compile_pattern(pat, seps, self.case_sensitive, self.recursive)
 
     def selector(self, parts):
         """Returns a function that selects from a given path, walking and
@@ -387,10 +390,12 @@ def selector(self, parts):
     def special_selector(self, part, parts):
         """Returns a function that selects special children of the given path.
         """
+        if parts:
+            part += self.sep
         select_next = self.selector(parts)
 
         def select_special(path, exists=False):
-            path = self.concat_path(self.add_slash(path), part)
+            path = self.concat_path(path, part)
             return select_next(path, exists)
         return select_special
 
@@ -400,14 +405,16 @@ def literal_selector(self, part, parts):
 
         # Optimization: consume and join any subsequent literal parts here,
         # rather than leaving them for the next selector. This reduces the
-        # number of string concatenation operations and calls to add_slash().
+        # number of string concatenation operations.
         while parts and magic_check.search(parts[-1]) is None:
             part += self.sep + parts.pop()
+        if parts:
+            part += self.sep
 
         select_next = self.selector(parts)
 
         def select_literal(path, exists=False):
-            path = self.concat_path(self.add_slash(path), part)
+            path = self.concat_path(path, part)
             return select_next(path, exists=False)
         return select_literal
 
@@ -423,23 +430,19 @@ def wildcard_selector(self, part, parts):
 
         def select_wildcard(path, exists=False):
             try:
-                # We must close the scandir() object before proceeding to
-                # avoid exhausting file descriptors when globbing deep trees.
-                with self.scandir(path) as scandir_it:
-                    entries = list(scandir_it)
+                entries = self.scandir(path)
             except OSError:
                 pass
             else:
-                for entry in entries:
-                    if match is None or match(entry.name):
+                for entry, entry_name, entry_path in entries:
+                    if match is None or match(entry_name):
                         if dir_only:
                             try:
                                 if not entry.is_dir():
                                     continue
                             except OSError:
                                 continue
-                        entry_path = self.parse_entry(entry)
-                        if dir_only:
+                            entry_path = self.concat_path(entry_path, self.sep)
                             yield from select_next(entry_path, exists=True)
                         else:
                             yield entry_path
@@ -469,7 +472,6 @@ def recursive_selector(self, part, parts):
         select_next = self.selector(parts)
 
         def select_recursive(path, exists=False):
-            path = self.add_slash(path)
             match_pos = len(str(path))
             if match is None or match(str(path), match_pos):
                 yield from select_next(path, exists)
@@ -480,14 +482,11 @@ def select_recursive(path, exists=False):
         def select_recursive_step(stack, match_pos):
             path = stack.pop()
             try:
-                # We must close the scandir() object before proceeding to
-                # avoid exhausting file descriptors when globbing deep trees.
-                with self.scandir(path) as scandir_it:
-                    entries = list(scandir_it)
+                entries = self.scandir(path)
             except OSError:
                 pass
             else:
-                for entry in entries:
+                for entry, _entry_name, entry_path in entries:
                     is_dir = False
                     try:
                         if entry.is_dir(follow_symlinks=follow_symlinks):
@@ -496,8 +495,10 @@ def select_recursive_step(stack, match_pos):
                         pass
 
                     if is_dir or not dir_only:
-                        entry_path = self.parse_entry(entry)
-                        if match is None or match(str(entry_path), match_pos):
+                        entry_path_str = str(entry_path)
+                        if dir_only:
+                            entry_path = self.concat_path(entry_path, self.sep)
+                        if match is None or match(entry_path_str, match_pos):
                             if dir_only:
                                 yield from select_next(entry_path, exists=True)
                             else:
@@ -516,30 +517,37 @@ def select_exists(self, path, exists=False):
             # Optimization: this path is already known to exist, e.g. because
             # it was returned from os.scandir(), so we skip calling lstat().
             yield path
-        else:
-            try:
-                self.lstat(path)
-                yield path
-            except OSError:
-                pass
+        elif self.lexists(path):
+            yield path
 
 
-class _StringGlobber(_Globber):
-    lstat = staticmethod(os.lstat)
-    scandir = staticmethod(os.scandir)
-    parse_entry = operator.attrgetter('path')
+class _StringGlobber(_GlobberBase):
+    """Provides shell-style pattern matching and globbing for string paths.
+    """
+    lexists = staticmethod(os.path.lexists)
     concat_path = operator.add
 
-    if os.name == 'nt':
-        @staticmethod
-        def add_slash(pathname):
-            tail = os.path.splitroot(pathname)[2]
-            if not tail or tail[-1] in '\\/':
-                return pathname
-            return f'{pathname}\\'
-    else:
-        @staticmethod
-        def add_slash(pathname):
-            if not pathname or pathname[-1] == '/':
-                return pathname
-            return f'{pathname}/'
+    @staticmethod
+    def scandir(path):
+        # We must close the scandir() object before proceeding to
+        # avoid exhausting file descriptors when globbing deep trees.
+        with os.scandir(path) as scandir_it:
+            entries = list(scandir_it)
+        return ((entry, entry.name, entry.path) for entry in entries)
+
+
+class _PathGlobber(_GlobberBase):
+    """Provides shell-style pattern matching and globbing for pathlib paths.
+    """
+
+    @staticmethod
+    def lexists(path):
+        return path.info.exists(follow_symlinks=False)
+
+    @staticmethod
+    def scandir(path):
+        return ((child.info, child.name, child) for child in path.iterdir())
+
+    @staticmethod
+    def concat_path(path, text):
+        return path.with_segments(str(path) + text)
diff --git a/Lib/hashlib.py b/Lib/hashlib.py
index e5f81d754ac..0e9bd98aa1f 100644
--- a/Lib/hashlib.py
+++ b/Lib/hashlib.py
@@ -33,7 +33,7 @@
  - hexdigest():  Like digest() except the digest is returned as a string
                  of double length, containing only hexadecimal digits.
  - copy():       Return a copy (clone) of the hash object. This can be used to
-                 efficiently compute the digests of datas that share a common
+                 efficiently compute the digests of data that share a common
                  initial substring.
 
 For example, to obtain the digest of the byte string 'Nobody inspects the
@@ -65,7 +65,7 @@
 algorithms_available = set(__always_supported)
 
 __all__ = __always_supported + ('new', 'algorithms_guaranteed',
-                                'algorithms_available', 'pbkdf2_hmac', 'file_digest')
+                                'algorithms_available', 'file_digest')
 
 
 __builtin_constructor_cache = {}
@@ -92,13 +92,13 @@ def __get_builtin_constructor(name):
             import _md5
             cache['MD5'] = cache['md5'] = _md5.md5
         elif name in {'SHA256', 'sha256', 'SHA224', 'sha224'}:
-            import _sha256
-            cache['SHA224'] = cache['sha224'] = _sha256.sha224
-            cache['SHA256'] = cache['sha256'] = _sha256.sha256
+            import _sha2
+            cache['SHA224'] = cache['sha224'] = _sha2.sha224
+            cache['SHA256'] = cache['sha256'] = _sha2.sha256
         elif name in {'SHA512', 'sha512', 'SHA384', 'sha384'}:
-            import _sha512
-            cache['SHA384'] = cache['sha384'] = _sha512.sha384
-            cache['SHA512'] = cache['sha512'] = _sha512.sha512
+            import _sha2
+            cache['SHA384'] = cache['sha384'] = _sha2.sha384
+            cache['SHA512'] = cache['sha512'] = _sha2.sha512
         elif name in {'blake2b', 'blake2s'}:
             import _blake2
             cache['blake2b'] = _blake2.blake2b
@@ -141,38 +141,37 @@ def __get_openssl_constructor(name):
         return __get_builtin_constructor(name)
 
 
-def __py_new(name, data=b'', **kwargs):
+def __py_new(name, *args, **kwargs):
     """new(name, data=b'', **kwargs) - Return a new hashing object using the
     named algorithm; optionally initialized with data (which must be
     a bytes-like object).
     """
-    return __get_builtin_constructor(name)(data, **kwargs)
+    return __get_builtin_constructor(name)(*args, **kwargs)
 
 
-def __hash_new(name, data=b'', **kwargs):
+def __hash_new(name, *args, **kwargs):
     """new(name, data=b'') - Return a new hashing object using the named algorithm;
     optionally initialized with data (which must be a bytes-like object).
     """
     if name in __block_openssl_constructor:
         # Prefer our builtin blake2 implementation.
-        return __get_builtin_constructor(name)(data, **kwargs)
+        return __get_builtin_constructor(name)(*args, **kwargs)
     try:
-        return _hashlib.new(name, data, **kwargs)
+        return _hashlib.new(name, *args, **kwargs)
     except ValueError:
         # If the _hashlib module (OpenSSL) doesn't support the named
         # hash, try using our builtin implementations.
         # This allows for SHA224/256 and SHA384/512 support even though
         # the OpenSSL library prior to 0.9.8 doesn't provide them.
-        return __get_builtin_constructor(name)(data)
+        return __get_builtin_constructor(name)(*args, **kwargs)
 
 
 try:
     import _hashlib
     new = __hash_new
     __get_hash = __get_openssl_constructor
-    # TODO: RUSTPYTHON set in _hashlib instance PyFrozenSet algorithms_available
-    '''algorithms_available = algorithms_available.union(
-            _hashlib.openssl_md_meth_names)'''
+    algorithms_available = algorithms_available.union(
+            _hashlib.openssl_md_meth_names)
 except ImportError:
     _hashlib = None
     new = __py_new
@@ -181,76 +180,14 @@ def __hash_new(name, data=b'', **kwargs):
 try:
     # OpenSSL's PKCS5_PBKDF2_HMAC requires OpenSSL 1.0+ with HMAC and SHA
     from _hashlib import pbkdf2_hmac
+    __all__ += ('pbkdf2_hmac',)
 except ImportError:
-    from warnings import warn as _warn
-    _trans_5C = bytes((x ^ 0x5C) for x in range(256))
-    _trans_36 = bytes((x ^ 0x36) for x in range(256))
-
-    def pbkdf2_hmac(hash_name, password, salt, iterations, dklen=None):
-        """Password based key derivation function 2 (PKCS #5 v2.0)
-
-        This Python implementations based on the hmac module about as fast
-        as OpenSSL's PKCS5_PBKDF2_HMAC for short passwords and much faster
-        for long passwords.
-        """
-        _warn(
-            "Python implementation of pbkdf2_hmac() is deprecated.",
-            category=DeprecationWarning,
-            stacklevel=2
-        )
-        if not isinstance(hash_name, str):
-            raise TypeError(hash_name)
-
-        if not isinstance(password, (bytes, bytearray)):
-            password = bytes(memoryview(password))
-        if not isinstance(salt, (bytes, bytearray)):
-            salt = bytes(memoryview(salt))
-
-        # Fast inline HMAC implementation
-        inner = new(hash_name)
-        outer = new(hash_name)
-        blocksize = getattr(inner, 'block_size', 64)
-        if len(password) > blocksize:
-            password = new(hash_name, password).digest()
-        password = password + b'\x00' * (blocksize - len(password))
-        inner.update(password.translate(_trans_36))
-        outer.update(password.translate(_trans_5C))
-
-        def prf(msg, inner=inner, outer=outer):
-            # PBKDF2_HMAC uses the password as key. We can re-use the same
-            # digest objects and just update copies to skip initialization.
-            icpy = inner.copy()
-            ocpy = outer.copy()
-            icpy.update(msg)
-            ocpy.update(icpy.digest())
-            return ocpy.digest()
-
-        if iterations < 1:
-            raise ValueError(iterations)
-        if dklen is None:
-            dklen = outer.digest_size
-        if dklen < 1:
-            raise ValueError(dklen)
-
-        dkey = b''
-        loop = 1
-        from_bytes = int.from_bytes
-        while len(dkey) < dklen:
-            prev = prf(salt + loop.to_bytes(4))
-            # endianness doesn't matter here as long to / from use the same
-            rkey = from_bytes(prev)
-            for i in range(iterations - 1):
-                prev = prf(prev)
-                # rkey = rkey ^ prev
-                rkey ^= from_bytes(prev)
-            loop += 1
-            dkey += rkey.to_bytes(inner.digest_size)
-
-        return dkey[:dklen]
+    pass
+
 
 try:
     # OpenSSL's scrypt requires OpenSSL 1.1+
-    from _hashlib import scrypt
+    from _hashlib import scrypt  # noqa: F401
 except ImportError:
     pass
 
@@ -294,6 +231,8 @@ def file_digest(fileobj, digest, /, *, _bufsize=2**18):
     view = memoryview(buf)
     while True:
         size = fileobj.readinto(buf)
+        if size is None:
+            raise BlockingIOError("I/O operation would block.")
         if size == 0:
             break  # EOF
         digestobj.update(view[:size])
diff --git a/Lib/hmac.py b/Lib/hmac.py
index 8b4eb2fe741..2d6016cda11 100644
--- a/Lib/hmac.py
+++ b/Lib/hmac.py
@@ -3,7 +3,6 @@
 Implements the HMAC algorithm as described by RFC 2104.
 """
 
-import warnings as _warnings
 try:
     import _hashlib as _hashopenssl
 except ImportError:
@@ -14,7 +13,10 @@
     compare_digest = _hashopenssl.compare_digest
     _functype = type(_hashopenssl.openssl_sha256)  # builtin type
 
-import hashlib as _hashlib
+try:
+    import _hmac
+except ImportError:
+    _hmac = None
 
 trans_5C = bytes((x ^ 0x5C) for x in range(256))
 trans_36 = bytes((x ^ 0x36) for x in range(256))
@@ -24,11 +26,27 @@
 digest_size = None
 
 
+def _get_digest_constructor(digest_like):
+    if callable(digest_like):
+        return digest_like
+    if isinstance(digest_like, str):
+        def digest_wrapper(d=b''):
+            import hashlib
+            return hashlib.new(digest_like, d)
+    else:
+        def digest_wrapper(d=b''):
+            return digest_like.new(d)
+    return digest_wrapper
+
+
 class HMAC:
     """RFC 2104 HMAC class.  Also complies with RFC 4231.
 
     This supports the API for Cryptographic Hash Functions (PEP 247).
     """
+
+    # Note: self.blocksize is the default blocksize; self.block_size
+    # is effective block size as well as the public API attribute.
     blocksize = 64  # 512-bit HMAC; can be changed in subclasses.
 
     __slots__ = (
@@ -50,31 +68,47 @@ def __init__(self, key, msg=None, digestmod=''):
         """
 
         if not isinstance(key, (bytes, bytearray)):
-            raise TypeError("key: expected bytes or bytearray, but got %r" % type(key).__name__)
+            raise TypeError(f"key: expected bytes or bytearray, "
+                            f"but got {type(key).__name__!r}")
 
         if not digestmod:
             raise TypeError("Missing required argument 'digestmod'.")
 
+        self.__init(key, msg, digestmod)
+
+    def __init(self, key, msg, digestmod):
         if _hashopenssl and isinstance(digestmod, (str, _functype)):
             try:
-                self._init_hmac(key, msg, digestmod)
-            except _hashopenssl.UnsupportedDigestmodError:
-                self._init_old(key, msg, digestmod)
-        else:
-            self._init_old(key, msg, digestmod)
+                self._init_openssl_hmac(key, msg, digestmod)
+                return
+            except _hashopenssl.UnsupportedDigestmodError:  # pragma: no cover
+                pass
+        if _hmac and isinstance(digestmod, str):
+            try:
+                self._init_builtin_hmac(key, msg, digestmod)
+                return
+            except _hmac.UnknownHashError:  # pragma: no cover
+                pass
+        self._init_old(key, msg, digestmod)
 
-    def _init_hmac(self, key, msg, digestmod):
+    def _init_openssl_hmac(self, key, msg, digestmod):
         self._hmac = _hashopenssl.hmac_new(key, msg, digestmod=digestmod)
+        self._inner = self._outer = None  # because the slots are defined
+        self.digest_size = self._hmac.digest_size
+        self.block_size = self._hmac.block_size
+
+    _init_hmac = _init_openssl_hmac  # for backward compatibility (if any)
+
+    def _init_builtin_hmac(self, key, msg, digestmod):
+        self._hmac = _hmac.new(key, msg, digestmod=digestmod)
+        self._inner = self._outer = None  # because the slots are defined
         self.digest_size = self._hmac.digest_size
         self.block_size = self._hmac.block_size
 
     def _init_old(self, key, msg, digestmod):
-        if callable(digestmod):
-            digest_cons = digestmod
-        elif isinstance(digestmod, str):
-            digest_cons = lambda d=b'': _hashlib.new(digestmod, d)
-        else:
-            digest_cons = lambda d=b'': digestmod.new(d)
+        import warnings
+
+        digest_cons = _get_digest_constructor(digestmod)
 
         self._hmac = None
         self._outer = digest_cons()
@@ -84,21 +118,19 @@ def _init_old(self, key, msg, digestmod):
         if hasattr(self._inner, 'block_size'):
             blocksize = self._inner.block_size
             if blocksize < 16:
-                _warnings.warn('block_size of %d seems too small; using our '
-                               'default of %d.' % (blocksize, self.blocksize),
-                               RuntimeWarning, 2)
-                blocksize = self.blocksize
+                warnings.warn(f"block_size of {blocksize} seems too small; "
+                              f"using our default of {self.blocksize}.",
+                              RuntimeWarning, 2)
+                blocksize = self.blocksize  # pragma: no cover
         else:
-            _warnings.warn('No block_size attribute on given digest object; '
-                           'Assuming %d.' % (self.blocksize),
-                           RuntimeWarning, 2)
-            blocksize = self.blocksize
+            warnings.warn("No block_size attribute on given digest object; "
+                          f"Assuming {self.blocksize}.",
+                          RuntimeWarning, 2)
+            blocksize = self.blocksize  # pragma: no cover
 
         if len(key) > blocksize:
             key = digest_cons(key).digest()
 
-        # self.blocksize is the default blocksize. self.block_size is
-        # effective block size as well as the public API attribute.
         self.block_size = blocksize
 
         key = key.ljust(blocksize, b'\0')
@@ -127,6 +159,7 @@ def copy(self):
         # Call __new__ directly to avoid the expensive __init__.
         other = self.__class__.__new__(self.__class__)
         other.digest_size = self.digest_size
+        other.block_size = self.block_size
         if self._hmac:
             other._hmac = self._hmac.copy()
             other._inner = other._outer = None
@@ -164,6 +197,7 @@ def hexdigest(self):
         h = self._current()
         return h.hexdigest()
 
+
 def new(key, msg=None, digestmod=''):
     """Create a new hashing object and return it.
 
@@ -193,25 +227,41 @@ def digest(key, msg, digest):
             A hashlib constructor returning a new hash object. *OR*
             A module supporting PEP 247.
     """
-    if _hashopenssl is not None and isinstance(digest, (str, _functype)):
+    if _hashopenssl and isinstance(digest, (str, _functype)):
         try:
             return _hashopenssl.hmac_digest(key, msg, digest)
+        except OverflowError:
+            # OpenSSL's HMAC limits the size of the key to INT_MAX.
+            # Instead of falling back to HACL* implementation which
+            # may still not be supported due to a too large key, we
+            # directly switch to the pure Python fallback instead
+            # even if we could have used streaming HMAC for small keys
+            # but large messages.
+            return _compute_digest_fallback(key, msg, digest)
         except _hashopenssl.UnsupportedDigestmodError:
             pass
 
-    if callable(digest):
-        digest_cons = digest
-    elif isinstance(digest, str):
-        digest_cons = lambda d=b'': _hashlib.new(digest, d)
-    else:
-        digest_cons = lambda d=b'': digest.new(d)
+    if _hmac and isinstance(digest, str):
+        try:
+            return _hmac.compute_digest(key, msg, digest)
+        except (OverflowError, _hmac.UnknownHashError):
+            # HACL* HMAC limits the size of the key to UINT32_MAX
+            # so we fallback to the pure Python implementation even
+            # if streaming HMAC may have been used for small keys
+            # and large messages.
+            pass
+
+    return _compute_digest_fallback(key, msg, digest)
+
 
+def _compute_digest_fallback(key, msg, digest):
+    digest_cons = _get_digest_constructor(digest)
     inner = digest_cons()
     outer = digest_cons()
     blocksize = getattr(inner, 'block_size', 64)
     if len(key) > blocksize:
         key = digest_cons(key).digest()
-    key = key + b'\x00' * (blocksize - len(key))
+    key = key.ljust(blocksize, b'\0')
     inner.update(key.translate(trans_36))
     outer.update(key.translate(trans_5C))
     inner.update(msg)
diff --git a/Lib/http/__init__.py b/Lib/http/__init__.py
index 17a47b180e5..691b4a9a367 100644
--- a/Lib/http/__init__.py
+++ b/Lib/http/__init__.py
@@ -54,8 +54,9 @@ def is_server_error(self):
     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'
+    PROCESSING = 102, 'Processing', 'Server is processing the request'
+    EARLY_HINTS = (103, 'Early Hints',
+            'Headers sent to prepare for the response')
 
     # success
     OK = 200, 'OK', 'Request fulfilled, document follows'
@@ -67,9 +68,11 @@ def is_server_error(self):
     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'
+    MULTI_STATUS = (207, 'Multi-Status',
+        'Response contains multiple statuses in the body')
+    ALREADY_REPORTED = (208, 'Already Reported',
+        'Operation has already been reported')
+    IM_USED = 226, 'IM Used', 'Request completed using instance manipulations'
 
     # redirection
     MULTIPLE_CHOICES = (300, 'Multiple Choices',
@@ -128,15 +131,19 @@ def is_server_error(self):
     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.')
+        '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_CONTENT = (422, 'Unprocessable Content',
+        'Server is not able to process the contained instructions')
     UNPROCESSABLE_ENTITY = UNPROCESSABLE_CONTENT
-    LOCKED = 423, 'Locked'
-    FAILED_DEPENDENCY = 424, 'Failed Dependency'
-    TOO_EARLY = 425, 'Too Early'
-    UPGRADE_REQUIRED = 426, 'Upgrade Required'
+    LOCKED = 423, 'Locked', 'Resource of a method is locked'
+    FAILED_DEPENDENCY = (424, 'Failed Dependency',
+        'Dependent action of the request failed')
+    TOO_EARLY = (425, 'Too Early',
+        'Server refuses to process a request that might be replayed')
+    UPGRADE_REQUIRED = (426, 'Upgrade Required',
+        'Server refuses to perform the request using the current protocol')
     PRECONDITION_REQUIRED = (428, 'Precondition Required',
         'The origin server requires the request to be conditional')
     TOO_MANY_REQUESTS = (429, 'Too Many Requests',
@@ -164,10 +171,14 @@ def is_server_error(self):
         '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'
+    VARIANT_ALSO_NEGOTIATES = (506, 'Variant Also Negotiates',
+        'Server has an internal configuration error')
+    INSUFFICIENT_STORAGE = (507, 'Insufficient Storage',
+        'Server is not able to store the representation')
+    LOOP_DETECTED = (508, 'Loop Detected',
+        'Server encountered an infinite loop while processing a request')
+    NOT_EXTENDED = (510, 'Not Extended',
+        'Request does not meet the resource access policy')
     NETWORK_AUTHENTICATION_REQUIRED = (511,
         'Network Authentication Required',
         'The client needs to authenticate to gain network access')
diff --git a/Lib/http/client.py b/Lib/http/client.py
index dd5f4136e9e..77f8d26291d 100644
--- a/Lib/http/client.py
+++ b/Lib/http/client.py
@@ -1047,7 +1047,7 @@ def close(self):
                 response.close()
 
     def send(self, data):
-        """Send `data' to the server.
+        """Send 'data' to the server.
         ``data`` can be a string object, a bytes object, an array object, a
         file-like object that supports a .read() method, or an iterable object.
         """
@@ -1159,10 +1159,10 @@ def putrequest(self, method, url, skip_host=False,
                    skip_accept_encoding=False):
         """Send a request to the server.
 
-        `method' specifies an HTTP request method, e.g. 'GET'.
-        `url' specifies the object being requested, e.g. '/index.html'.
-        `skip_host' if True does not add automatically a 'Host:' header
-        `skip_accept_encoding' if True does not add automatically an
+        'method' specifies an HTTP request method, e.g. 'GET'.
+        'url' specifies the object being requested, e.g. '/index.html'.
+        'skip_host' if True does not add automatically a 'Host:' header
+        'skip_accept_encoding' if True does not add automatically an
            'Accept-Encoding:' header
         """
 
diff --git a/Lib/http/cookiejar.py b/Lib/http/cookiejar.py
index 9a2f0fb851c..68cf16c93cc 100644
--- a/Lib/http/cookiejar.py
+++ b/Lib/http/cookiejar.py
@@ -1987,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.  curl and lynx use 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
diff --git a/Lib/http/cookies.py b/Lib/http/cookies.py
index 57791c6ab08..e0e2cd4b696 100644
--- a/Lib/http/cookies.py
+++ b/Lib/http/cookies.py
@@ -87,9 +87,9 @@
 such trickeries do not confuse it.
 
    >>> C = cookies.SimpleCookie()
-   >>> C.load('keebler="E=everybody; L=\\"Loves\\"; fudge=\\012;";')
+   >>> C.load('keebler="E=everybody; L=\\"Loves\\"; fudge=;";')
    >>> print(C)
-   Set-Cookie: keebler="E=everybody; L=\"Loves\"; fudge=\012;"
+   Set-Cookie: keebler="E=everybody; L=\"Loves\"; fudge=;"
 
 Each element of the Cookie also supports all of the RFC 2109
 Cookie attributes.  Here's an example which sets the Path
@@ -170,6 +170,15 @@ class CookieError(Exception):
 })
 
 _is_legal_key = re.compile('[%s]+' % re.escape(_LegalChars)).fullmatch
+_control_character_re = re.compile(r'[\x00-\x1F\x7F]')
+
+
+def _has_control_character(*val):
+    """Detects control characters within a value.
+    Supports any type, as header values can be any type.
+    """
+    return any(_control_character_re.search(str(v)) for v in val)
+
 
 def _quote(str):
     r"""Quote a string for use in a cookie header.
@@ -264,17 +273,19 @@ class Morsel(dict):
         "httponly" : "HttpOnly",
         "version"  : "Version",
         "samesite" : "SameSite",
+        "partitioned": "Partitioned",
     }
 
-    _flags = {'secure', 'httponly'}
+    _reserved_defaults = dict.fromkeys(_reserved, "")
+
+    _flags = {'secure', 'httponly', 'partitioned'}
 
     def __init__(self):
         # Set defaults
         self._key = self._value = self._coded_value = None
 
         # Set default attributes
-        for key in self._reserved:
-            dict.__setitem__(self, key, "")
+        dict.update(self, self._reserved_defaults)
 
     @property
     def key(self):
@@ -292,12 +303,16 @@ def __setitem__(self, K, V):
         K = K.lower()
         if not K in self._reserved:
             raise CookieError("Invalid attribute %r" % (K,))
+        if _has_control_character(K, V):
+            raise CookieError(f"Control characters are not allowed in cookies {K!r} {V!r}")
         dict.__setitem__(self, K, V)
 
     def setdefault(self, key, val=None):
         key = key.lower()
         if key not in self._reserved:
             raise CookieError("Invalid attribute %r" % (key,))
+        if _has_control_character(key, val):
+            raise CookieError("Control characters are not allowed in cookies %r %r" % (key, val,))
         return dict.setdefault(self, key, val)
 
     def __eq__(self, morsel):
@@ -333,6 +348,9 @@ def set(self, key, val, coded_val):
             raise CookieError('Attempt to set a reserved key %r' % (key,))
         if not _is_legal_key(key):
             raise CookieError('Illegal key %r' % (key,))
+        if _has_control_character(key, val, coded_val):
+            raise CookieError(
+                "Control characters are not allowed in cookies %r %r %r" % (key, val, coded_val,))
 
         # It's a good key, so save it.
         self._key = key
@@ -486,7 +504,10 @@ def output(self, attrs=None, header="Set-Cookie:", sep="\015\012"):
         result = []
         items = sorted(self.items())
         for key, value in items:
-            result.append(value.output(attrs, header))
+            value_output = value.output(attrs, header)
+            if _has_control_character(value_output):
+                raise CookieError("Control characters are not allowed in cookies")
+            result.append(value_output)
         return sep.join(result)
 
     __str__ = output
diff --git a/Lib/http/server.py b/Lib/http/server.py
index 0ec479003a4..ac1f57c29f0 100644
--- a/Lib/http/server.py
+++ b/Lib/http/server.py
@@ -83,8 +83,10 @@
 __version__ = "0.6"
 
 __all__ = [
-    "HTTPServer", "ThreadingHTTPServer", "BaseHTTPRequestHandler",
-    "SimpleHTTPRequestHandler", "CGIHTTPRequestHandler",
+    "HTTPServer", "ThreadingHTTPServer",
+    "HTTPSServer", "ThreadingHTTPSServer",
+    "BaseHTTPRequestHandler", "SimpleHTTPRequestHandler",
+    "CGIHTTPRequestHandler",
 ]
 
 import copy
@@ -99,7 +101,7 @@
 import posixpath
 import select
 import shutil
-import socket # For gethostbyaddr()
+import socket
 import socketserver
 import sys
 import time
@@ -114,6 +116,11 @@
 <html lang="en">
     <head>
         <meta charset="utf-8">
+        <style type="text/css">
+            :root {
+                color-scheme: light dark;
+            }
+        </style>
         <title>Error response</title>
     </head>
     <body>
@@ -133,7 +140,8 @@
 
 class HTTPServer(socketserver.TCPServer):
 
-    allow_reuse_address = 1    # Seems to make sense in testing environment
+    allow_reuse_address = True    # Seems to make sense in testing environment
+    allow_reuse_port = False
 
     def server_bind(self):
         """Override server_bind to store the server name."""
@@ -147,6 +155,47 @@ class ThreadingHTTPServer(socketserver.ThreadingMixIn, HTTPServer):
     daemon_threads = True
 
 
+class HTTPSServer(HTTPServer):
+    def __init__(self, server_address, RequestHandlerClass,
+                 bind_and_activate=True, *, certfile, keyfile=None,
+                 password=None, alpn_protocols=None):
+        try:
+            import ssl
+        except ImportError:
+            raise RuntimeError("SSL module is missing; "
+                               "HTTPS support is unavailable")
+
+        self.ssl = ssl
+        self.certfile = certfile
+        self.keyfile = keyfile
+        self.password = password
+        # Support by default HTTP/1.1
+        self.alpn_protocols = (
+            ["http/1.1"] if alpn_protocols is None else alpn_protocols
+        )
+
+        super().__init__(server_address,
+                         RequestHandlerClass,
+                         bind_and_activate)
+
+    def server_activate(self):
+        """Wrap the socket in SSLSocket."""
+        super().server_activate()
+        context = self._create_context()
+        self.socket = context.wrap_socket(self.socket, server_side=True)
+
+    def _create_context(self):
+        """Create a secure SSL context."""
+        context = self.ssl.create_default_context(self.ssl.Purpose.CLIENT_AUTH)
+        context.load_cert_chain(self.certfile, self.keyfile, self.password)
+        context.set_alpn_protocols(self.alpn_protocols)
+        return context
+
+
+class ThreadingHTTPSServer(socketserver.ThreadingMixIn, HTTPSServer):
+    daemon_threads = True
+
+
 class BaseHTTPRequestHandler(socketserver.StreamRequestHandler):
 
     """HTTP request handler base class.
@@ -817,6 +866,7 @@ def list_directory(self, path):
         r.append('<html lang="en">')
         r.append('<head>')
         r.append(f'<meta charset="{enc}">')
+        r.append('<style type="text/css">\n:root {\ncolor-scheme: light dark;\n}\n</style>')
         r.append(f'<title>{title}</title>\n</head>')
         r.append(f'<body>\n<h1>{title}</h1>')
         r.append('<hr>\n<ul>')
@@ -1281,7 +1331,8 @@ def _get_best_family(*address):
 
 def test(HandlerClass=BaseHTTPRequestHandler,
          ServerClass=ThreadingHTTPServer,
-         protocol="HTTP/1.0", port=8000, bind=None):
+         protocol="HTTP/1.0", port=8000, bind=None,
+         tls_cert=None, tls_key=None, tls_password=None):
     """Test the HTTP request handler class.
 
     This runs an HTTP server on port 8000 (or the port argument).
@@ -1289,12 +1340,20 @@ def test(HandlerClass=BaseHTTPRequestHandler,
     """
     ServerClass.address_family, addr = _get_best_family(bind, port)
     HandlerClass.protocol_version = protocol
-    with ServerClass(addr, HandlerClass) as httpd:
+
+    if tls_cert:
+        server = ServerClass(addr, HandlerClass, certfile=tls_cert,
+                             keyfile=tls_key, password=tls_password)
+    else:
+        server = ServerClass(addr, HandlerClass)
+
+    with server as httpd:
         host, port = httpd.socket.getsockname()[:2]
         url_host = f'[{host}]' if ':' in host else host
+        protocol = 'HTTPS' if tls_cert else 'HTTP'
         print(
-            f"Serving HTTP on {host} port {port} "
-            f"(http://{url_host}:{port}/) ..."
+            f"Serving {protocol} on {host} port {port} "
+            f"({protocol.lower()}://{url_host}:{port}/) ..."
         )
         try:
             httpd.serve_forever()
@@ -1306,7 +1365,7 @@ def test(HandlerClass=BaseHTTPRequestHandler,
     import argparse
     import contextlib
 
-    parser = argparse.ArgumentParser()
+    parser = argparse.ArgumentParser(color=True)
     parser.add_argument('--cgi', action='store_true',
                         help='run as CGI server')
     parser.add_argument('-b', '--bind', metavar='ADDRESS',
@@ -1319,17 +1378,38 @@ def test(HandlerClass=BaseHTTPRequestHandler,
                         default='HTTP/1.0',
                         help='conform to this HTTP version '
                              '(default: %(default)s)')
+    parser.add_argument('--tls-cert', metavar='PATH',
+                        help='path to the TLS certificate chain file')
+    parser.add_argument('--tls-key', metavar='PATH',
+                        help='path to the TLS key file')
+    parser.add_argument('--tls-password-file', metavar='PATH',
+                        help='path to the password file for the TLS key')
     parser.add_argument('port', default=8000, type=int, nargs='?',
                         help='bind to this port '
                              '(default: %(default)s)')
     args = parser.parse_args()
+
+    if not args.tls_cert and args.tls_key:
+        parser.error("--tls-key requires --tls-cert to be set")
+
+    tls_key_password = None
+    if args.tls_password_file:
+        if not args.tls_cert:
+            parser.error("--tls-password-file requires --tls-cert to be set")
+
+        try:
+            with open(args.tls_password_file, "r", encoding="utf-8") as f:
+                tls_key_password = f.read().strip()
+        except OSError as e:
+            parser.error(f"Failed to read TLS password file: {e}")
+
     if args.cgi:
         handler_class = CGIHTTPRequestHandler
     else:
         handler_class = SimpleHTTPRequestHandler
 
     # ensure dual-stack is not disabled; ref #38907
-    class DualStackServer(ThreadingHTTPServer):
+    class DualStackServerMixin:
 
         def server_bind(self):
             # suppress exception when protocol is IPv4
@@ -1342,10 +1422,20 @@ def finish_request(self, request, client_address):
             self.RequestHandlerClass(request, client_address, self,
                                      directory=args.directory)
 
+    class HTTPDualStackServer(DualStackServerMixin, ThreadingHTTPServer):
+        pass
+    class HTTPSDualStackServer(DualStackServerMixin, ThreadingHTTPSServer):
+        pass
+
+    ServerClass = HTTPSDualStackServer if args.tls_cert else HTTPDualStackServer
+
     test(
         HandlerClass=handler_class,
-        ServerClass=DualStackServer,
+        ServerClass=ServerClass,
         port=args.port,
         bind=args.bind,
         protocol=args.protocol,
+        tls_cert=args.tls_cert,
+        tls_key=args.tls_key,
+        tls_password=tls_key_password,
     )
diff --git a/Lib/imaplib.py b/Lib/imaplib.py
new file mode 100644
index 00000000000..cbe129b3e7c
--- /dev/null
+++ b/Lib/imaplib.py
@@ -0,0 +1,1967 @@
+"""IMAP4 client.
+
+Based on RFC 2060.
+
+Public class:           IMAP4
+Public variable:        Debug
+Public functions:       Internaldate2tuple
+                        Int2AP
+                        ParseFlags
+                        Time2Internaldate
+"""
+
+# Author: Piers Lauder <piers@cs.su.oz.au> December 1997.
+#
+# Authentication code contributed by Donn Cave <donn@u.washington.edu> June 1998.
+# String method conversion by ESR, February 2001.
+# GET/SETACL contributed by Anthony Baxter <anthony@interlink.com.au> April 2001.
+# IMAP4_SSL contributed by Tino Lange <Tino.Lange@isg.de> March 2002.
+# GET/SETQUOTA contributed by Andreas Zeidler <az@kreativkombinat.de> June 2002.
+# PROXYAUTH contributed by Rick Holbert <holbert.13@osu.edu> November 2002.
+# GET/SETANNOTATION contributed by Tomas Lindroos <skitta@abo.fi> June 2005.
+# IDLE contributed by Forest <forestix@nom.one> August 2024.
+
+__version__ = "2.60"
+
+import binascii, errno, random, re, socket, subprocess, sys, time, calendar
+from datetime import datetime, timezone, timedelta
+from io import DEFAULT_BUFFER_SIZE
+
+try:
+    import ssl
+    HAVE_SSL = True
+except ImportError:
+    HAVE_SSL = False
+
+__all__ = ["IMAP4", "IMAP4_stream", "Internaldate2tuple",
+           "Int2AP", "ParseFlags", "Time2Internaldate"]
+
+#       Globals
+
+CRLF = b'\r\n'
+Debug = 0
+IMAP4_PORT = 143
+IMAP4_SSL_PORT = 993
+AllowedVersions = ('IMAP4REV1', 'IMAP4')        # Most recent first
+
+# Maximal line length when calling readline(). This is to prevent
+# reading arbitrary length lines. RFC 3501 and 2060 (IMAP 4rev1)
+# don't specify a line length. RFC 2683 suggests limiting client
+# command lines to 1000 octets and that servers should be prepared
+# to accept command lines up to 8000 octets, so we used to use 10K here.
+# In the modern world (eg: gmail) the response to, for example, a
+# search command can be quite large, so we now use 1M.
+_MAXLINE = 1000000
+
+
+#       Commands
+
+Commands = {
+        # name            valid states
+        'APPEND':       ('AUTH', 'SELECTED'),
+        'AUTHENTICATE': ('NONAUTH',),
+        'CAPABILITY':   ('NONAUTH', 'AUTH', 'SELECTED', 'LOGOUT'),
+        'CHECK':        ('SELECTED',),
+        'CLOSE':        ('SELECTED',),
+        'COPY':         ('SELECTED',),
+        'CREATE':       ('AUTH', 'SELECTED'),
+        'DELETE':       ('AUTH', 'SELECTED'),
+        'DELETEACL':    ('AUTH', 'SELECTED'),
+        'ENABLE':       ('AUTH', ),
+        'EXAMINE':      ('AUTH', 'SELECTED'),
+        'EXPUNGE':      ('SELECTED',),
+        'FETCH':        ('SELECTED',),
+        'GETACL':       ('AUTH', 'SELECTED'),
+        'GETANNOTATION':('AUTH', 'SELECTED'),
+        'GETQUOTA':     ('AUTH', 'SELECTED'),
+        'GETQUOTAROOT': ('AUTH', 'SELECTED'),
+        'IDLE':         ('AUTH', 'SELECTED'),
+        'MYRIGHTS':     ('AUTH', 'SELECTED'),
+        'LIST':         ('AUTH', 'SELECTED'),
+        'LOGIN':        ('NONAUTH',),
+        'LOGOUT':       ('NONAUTH', 'AUTH', 'SELECTED', 'LOGOUT'),
+        'LSUB':         ('AUTH', 'SELECTED'),
+        'MOVE':         ('SELECTED',),
+        'NAMESPACE':    ('AUTH', 'SELECTED'),
+        'NOOP':         ('NONAUTH', 'AUTH', 'SELECTED', 'LOGOUT'),
+        'PARTIAL':      ('SELECTED',),                                  # NB: obsolete
+        'PROXYAUTH':    ('AUTH',),
+        'RENAME':       ('AUTH', 'SELECTED'),
+        'SEARCH':       ('SELECTED',),
+        'SELECT':       ('AUTH', 'SELECTED'),
+        'SETACL':       ('AUTH', 'SELECTED'),
+        'SETANNOTATION':('AUTH', 'SELECTED'),
+        'SETQUOTA':     ('AUTH', 'SELECTED'),
+        'SORT':         ('SELECTED',),
+        'STARTTLS':     ('NONAUTH',),
+        'STATUS':       ('AUTH', 'SELECTED'),
+        'STORE':        ('SELECTED',),
+        'SUBSCRIBE':    ('AUTH', 'SELECTED'),
+        'THREAD':       ('SELECTED',),
+        'UID':          ('SELECTED',),
+        'UNSUBSCRIBE':  ('AUTH', 'SELECTED'),
+        'UNSELECT':     ('SELECTED',),
+        }
+
+#       Patterns to match server responses
+
+Continuation = re.compile(br'\+( (?P<data>.*))?')
+Flags = re.compile(br'.*FLAGS \((?P<flags>[^\)]*)\)')
+InternalDate = re.compile(br'.*INTERNALDATE "'
+        br'(?P<day>[ 0123][0-9])-(?P<mon>[A-Z][a-z][a-z])-(?P<year>[0-9][0-9][0-9][0-9])'
+        br' (?P<hour>[0-9][0-9]):(?P<min>[0-9][0-9]):(?P<sec>[0-9][0-9])'
+        br' (?P<zonen>[-+])(?P<zoneh>[0-9][0-9])(?P<zonem>[0-9][0-9])'
+        br'"')
+# Literal is no longer used; kept for backward compatibility.
+Literal = re.compile(br'.*{(?P<size>\d+)}$', re.ASCII)
+MapCRLF = re.compile(br'\r\n|\r|\n')
+# We no longer exclude the ']' character from the data portion of the response
+# code, even though it violates the RFC.  Popular IMAP servers such as Gmail
+# allow flags with ']', and there are programs (including imaplib!) that can
+# produce them.  The problem with this is if the 'text' portion of the response
+# includes a ']' we'll parse the response wrong (which is the point of the RFC
+# restriction).  However, that seems less likely to be a problem in practice
+# than being unable to correctly parse flags that include ']' chars, which
+# was reported as a real-world problem in issue #21815.
+Response_code = re.compile(br'\[(?P<type>[A-Z-]+)( (?P<data>.*))?\]')
+Untagged_response = re.compile(br'\* (?P<type>[A-Z-]+)( (?P<data>.*))?')
+# Untagged_status is no longer used; kept for backward compatibility
+Untagged_status = re.compile(
+    br'\* (?P<data>\d+) (?P<type>[A-Z-]+)( (?P<data2>.*))?', re.ASCII)
+# We compile these in _mode_xxx.
+_Literal = br'.*{(?P<size>\d+)}$'
+_Untagged_status = br'\* (?P<data>\d+) (?P<type>[A-Z-]+)( (?P<data2>.*))?'
+
+
+
+class IMAP4:
+
+    r"""IMAP4 client class.
+
+    Instantiate with: IMAP4([host[, port[, timeout=None]]])
+
+            host - host's name (default: localhost);
+            port - port number (default: standard IMAP4 port).
+            timeout - socket timeout (default: None)
+                      If timeout is not given or is None,
+                      the global default socket timeout is used
+
+    All IMAP4rev1 commands are supported by methods of the same
+    name (in lowercase).
+
+    All arguments to commands are converted to strings, except for
+    AUTHENTICATE, and the last argument to APPEND which is passed as
+    an IMAP4 literal.  If necessary (the string contains any
+    non-printing characters or white-space and isn't enclosed with
+    either parentheses or double quotes) each string is quoted.
+    However, the 'password' argument to the LOGIN command is always
+    quoted.  If you want to avoid having an argument string quoted
+    (eg: the 'flags' argument to STORE) then enclose the string in
+    parentheses (eg: "(\Deleted)").
+
+    Each command returns a tuple: (type, [data, ...]) where 'type'
+    is usually 'OK' or 'NO', and 'data' is either the text from the
+    tagged response, or untagged results from command. Each 'data'
+    is either a string, or a tuple. If a tuple, then the first part
+    is the header of the response, and the second part contains
+    the data (ie: 'literal' value).
+
+    Errors raise the exception class <instance>.error("<reason>").
+    IMAP4 server errors raise <instance>.abort("<reason>"),
+    which is a sub-class of 'error'. Mailbox status changes
+    from READ-WRITE to READ-ONLY raise the exception class
+    <instance>.readonly("<reason>"), which is a sub-class of 'abort'.
+
+    "error" exceptions imply a program error.
+    "abort" exceptions imply the connection should be reset, and
+            the command re-tried.
+    "readonly" exceptions imply the command should be re-tried.
+
+    Note: to use this module, you must read the RFCs pertaining to the
+    IMAP4 protocol, as the semantics of the arguments to each IMAP4
+    command are left to the invoker, not to mention the results. Also,
+    most IMAP servers implement a sub-set of the commands available here.
+    """
+
+    class error(Exception): pass    # Logical errors - debug required
+    class abort(error): pass        # Service errors - close and retry
+    class readonly(abort): pass     # Mailbox status changed to READ-ONLY
+    class _responsetimeout(TimeoutError): pass # No response during IDLE
+
+    def __init__(self, host='', port=IMAP4_PORT, timeout=None):
+        self.debug = Debug
+        self.state = 'LOGOUT'
+        self.literal = None             # A literal argument to a command
+        self.tagged_commands = {}       # Tagged commands awaiting response
+        self.untagged_responses = {}    # {typ: [data, ...], ...}
+        self.continuation_response = '' # Last continuation response
+        self._idle_responses = []       # Response queue for idle iteration
+        self._idle_capture = False      # Whether to queue responses for idle
+        self.is_readonly = False        # READ-ONLY desired state
+        self.tagnum = 0
+        self._tls_established = False
+        self._mode_ascii()
+        self._readbuf = []
+
+        # Open socket to server.
+
+        self.open(host, port, timeout)
+
+        try:
+            self._connect()
+        except Exception:
+            try:
+                self.shutdown()
+            except OSError:
+                pass
+            raise
+
+    def _mode_ascii(self):
+        self.utf8_enabled = False
+        self._encoding = 'ascii'
+        self.Literal = re.compile(_Literal, re.ASCII)
+        self.Untagged_status = re.compile(_Untagged_status, re.ASCII)
+
+
+    def _mode_utf8(self):
+        self.utf8_enabled = True
+        self._encoding = 'utf-8'
+        self.Literal = re.compile(_Literal)
+        self.Untagged_status = re.compile(_Untagged_status)
+
+
+    def _connect(self):
+        # Create unique tag for this session,
+        # and compile tagged response matcher.
+
+        self.tagpre = Int2AP(random.randint(4096, 65535))
+        self.tagre = re.compile(br'(?P<tag>'
+                        + self.tagpre
+                        + br'\d+) (?P<type>[A-Z]+) (?P<data>.*)', re.ASCII)
+
+        # Get server welcome message,
+        # request and store CAPABILITY response.
+
+        if __debug__:
+            self._cmd_log_len = 10
+            self._cmd_log_idx = 0
+            self._cmd_log = {}           # Last '_cmd_log_len' interactions
+            if self.debug >= 1:
+                self._mesg('imaplib version %s' % __version__)
+                self._mesg('new IMAP4 connection, tag=%s' % self.tagpre)
+
+        self.welcome = self._get_response()
+        if 'PREAUTH' in self.untagged_responses:
+            self.state = 'AUTH'
+        elif 'OK' in self.untagged_responses:
+            self.state = 'NONAUTH'
+        else:
+            raise self.error(self.welcome)
+
+        self._get_capabilities()
+        if __debug__:
+            if self.debug >= 3:
+                self._mesg('CAPABILITIES: %r' % (self.capabilities,))
+
+        for version in AllowedVersions:
+            if not version in self.capabilities:
+                continue
+            self.PROTOCOL_VERSION = version
+            return
+
+        raise self.error('server not IMAP4 compliant')
+
+
+    def __getattr__(self, attr):
+        #       Allow UPPERCASE variants of IMAP4 command methods.
+        if attr in Commands:
+            return getattr(self, attr.lower())
+        raise AttributeError("Unknown IMAP4 command: '%s'" % attr)
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, *args):
+        if self.state == "LOGOUT":
+            return
+
+        try:
+            self.logout()
+        except OSError:
+            pass
+
+
+    #       Overridable methods
+
+
+    def _create_socket(self, timeout):
+        # Default value of IMAP4.host is '', but socket.getaddrinfo()
+        # (which is used by socket.create_connection()) expects None
+        # as a default value for host.
+        if timeout is not None and not timeout:
+            raise ValueError('Non-blocking socket (timeout=0) is not supported')
+        host = None if not self.host else self.host
+        sys.audit("imaplib.open", self, self.host, self.port)
+        address = (host, self.port)
+        if timeout is not None:
+            return socket.create_connection(address, timeout)
+        return socket.create_connection(address)
+
+    def open(self, host='', port=IMAP4_PORT, timeout=None):
+        """Setup connection to remote server on "host:port"
+            (default: localhost:standard IMAP4 port).
+        This connection will be used by the routines:
+            read, readline, send, shutdown.
+        """
+        self.host = host
+        self.port = port
+        self.sock = self._create_socket(timeout)
+        self._file = self.sock.makefile('rb')
+
+
+    @property
+    def file(self):
+        # The old 'file' attribute is no longer used now that we do our own
+        # read() and readline() buffering, with which it conflicts.
+        # As an undocumented interface, it should never have been accessed by
+        # external code, and therefore does not warrant deprecation.
+        # Nevertheless, we provide this property for now, to avoid suddenly
+        # breaking any code in the wild that might have been using it in a
+        # harmless way.
+        import warnings
+        warnings.warn(
+            'IMAP4.file is unsupported, can cause errors, and may be removed.',
+            RuntimeWarning,
+            stacklevel=2)
+        return self._file
+
+
+    def read(self, size):
+        """Read 'size' bytes from remote."""
+        # We need buffered read() to continue working after socket timeouts,
+        # since we use them during IDLE. Unfortunately, the standard library's
+        # SocketIO implementation makes this impossible, by setting a permanent
+        # error condition instead of letting the caller decide how to handle a
+        # timeout. We therefore implement our own buffered read().
+        # https://github.com/python/cpython/issues/51571
+        #
+        # Reading in chunks instead of delegating to a single
+        # BufferedReader.read() call also means we avoid its preallocation
+        # of an unreasonably large memory block if a malicious server claims
+        # it will send a huge literal without actually sending one.
+        # https://github.com/python/cpython/issues/119511
+
+        parts = []
+
+        while size > 0:
+
+            if len(parts) < len(self._readbuf):
+                buf = self._readbuf[len(parts)]
+            else:
+                try:
+                    buf = self.sock.recv(DEFAULT_BUFFER_SIZE)
+                except ConnectionError:
+                    break
+                if not buf:
+                    break
+                self._readbuf.append(buf)
+
+            if len(buf) >= size:
+                parts.append(buf[:size])
+                self._readbuf = [buf[size:]] + self._readbuf[len(parts):]
+                break
+            parts.append(buf)
+            size -= len(buf)
+
+        return b''.join(parts)
+
+
+    def readline(self):
+        """Read line from remote."""
+        # The comment in read() explains why we implement our own readline().
+
+        LF = b'\n'
+        parts = []
+        length = 0
+
+        while length < _MAXLINE:
+
+            if len(parts) < len(self._readbuf):
+                buf = self._readbuf[len(parts)]
+            else:
+                try:
+                    buf = self.sock.recv(DEFAULT_BUFFER_SIZE)
+                except ConnectionError:
+                    break
+                if not buf:
+                    break
+                self._readbuf.append(buf)
+
+            pos = buf.find(LF)
+            if pos != -1:
+                pos += 1
+                parts.append(buf[:pos])
+                self._readbuf = [buf[pos:]] + self._readbuf[len(parts):]
+                break
+            parts.append(buf)
+            length += len(buf)
+
+        line = b''.join(parts)
+        if len(line) > _MAXLINE:
+            raise self.error("got more than %d bytes" % _MAXLINE)
+        return line
+
+
+    def send(self, data):
+        """Send data to remote."""
+        sys.audit("imaplib.send", self, data)
+        self.sock.sendall(data)
+
+
+    def shutdown(self):
+        """Close I/O established in "open"."""
+        self._file.close()
+        try:
+            self.sock.shutdown(socket.SHUT_RDWR)
+        except OSError as exc:
+            # The server might already have closed the connection.
+            # On Windows, this may result in WSAEINVAL (error 10022):
+            # An invalid operation was attempted.
+            if (exc.errno != errno.ENOTCONN
+               and getattr(exc, 'winerror', 0) != 10022):
+                raise
+        finally:
+            self.sock.close()
+
+
+    def socket(self):
+        """Return socket instance used to connect to IMAP4 server.
+
+        socket = <instance>.socket()
+        """
+        return self.sock
+
+
+
+    #       Utility methods
+
+
+    def recent(self):
+        """Return most recent 'RECENT' responses if any exist,
+        else prompt server for an update using the 'NOOP' command.
+
+        (typ, [data]) = <instance>.recent()
+
+        'data' is None if no new messages,
+        else list of RECENT responses, most recent last.
+        """
+        name = 'RECENT'
+        typ, dat = self._untagged_response('OK', [None], name)
+        if dat[-1]:
+            return typ, dat
+        typ, dat = self.noop()  # Prod server for response
+        return self._untagged_response(typ, dat, name)
+
+
+    def response(self, code):
+        """Return data for response 'code' if received, or None.
+
+        Old value for response 'code' is cleared.
+
+        (code, [data]) = <instance>.response(code)
+        """
+        return self._untagged_response(code, [None], code.upper())
+
+
+
+    #       IMAP4 commands
+
+
+    def append(self, mailbox, flags, date_time, message):
+        """Append message to named mailbox.
+
+        (typ, [data]) = <instance>.append(mailbox, flags, date_time, message)
+
+                All args except 'message' can be None.
+        """
+        name = 'APPEND'
+        if not mailbox:
+            mailbox = 'INBOX'
+        if flags:
+            if (flags[0],flags[-1]) != ('(',')'):
+                flags = '(%s)' % flags
+        else:
+            flags = None
+        if date_time:
+            date_time = Time2Internaldate(date_time)
+        else:
+            date_time = None
+        literal = MapCRLF.sub(CRLF, message)
+        self.literal = literal
+        return self._simple_command(name, mailbox, flags, date_time)
+
+
+    def authenticate(self, mechanism, authobject):
+        """Authenticate command - requires response processing.
+
+        'mechanism' specifies which authentication mechanism is to
+        be used - it must appear in <instance>.capabilities in the
+        form AUTH=<mechanism>.
+
+        'authobject' must be a callable object:
+
+                data = authobject(response)
+
+        It will be called to process server continuation responses; the
+        response argument it is passed will be a bytes.  It should return bytes
+        data that will be base64 encoded and sent to the server.  It should
+        return None if the client abort response '*' should be sent instead.
+        """
+        mech = mechanism.upper()
+        # XXX: shouldn't this code be removed, not commented out?
+        #cap = 'AUTH=%s' % mech
+        #if not cap in self.capabilities:       # Let the server decide!
+        #    raise self.error("Server doesn't allow %s authentication." % mech)
+        self.literal = _Authenticator(authobject).process
+        typ, dat = self._simple_command('AUTHENTICATE', mech)
+        if typ != 'OK':
+            raise self.error(dat[-1].decode('utf-8', 'replace'))
+        self.state = 'AUTH'
+        return typ, dat
+
+
+    def capability(self):
+        """(typ, [data]) = <instance>.capability()
+        Fetch capabilities list from server."""
+
+        name = 'CAPABILITY'
+        typ, dat = self._simple_command(name)
+        return self._untagged_response(typ, dat, name)
+
+
+    def check(self):
+        """Checkpoint mailbox on server.
+
+        (typ, [data]) = <instance>.check()
+        """
+        return self._simple_command('CHECK')
+
+
+    def close(self):
+        """Close currently selected mailbox.
+
+        Deleted messages are removed from writable mailbox.
+        This is the recommended command before 'LOGOUT'.
+
+        (typ, [data]) = <instance>.close()
+        """
+        try:
+            typ, dat = self._simple_command('CLOSE')
+        finally:
+            self.state = 'AUTH'
+        return typ, dat
+
+
+    def copy(self, message_set, new_mailbox):
+        """Copy 'message_set' messages onto end of 'new_mailbox'.
+
+        (typ, [data]) = <instance>.copy(message_set, new_mailbox)
+        """
+        return self._simple_command('COPY', message_set, new_mailbox)
+
+
+    def create(self, mailbox):
+        """Create new mailbox.
+
+        (typ, [data]) = <instance>.create(mailbox)
+        """
+        return self._simple_command('CREATE', mailbox)
+
+
+    def delete(self, mailbox):
+        """Delete old mailbox.
+
+        (typ, [data]) = <instance>.delete(mailbox)
+        """
+        return self._simple_command('DELETE', mailbox)
+
+    def deleteacl(self, mailbox, who):
+        """Delete the ACLs (remove any rights) set for who on mailbox.
+
+        (typ, [data]) = <instance>.deleteacl(mailbox, who)
+        """
+        return self._simple_command('DELETEACL', mailbox, who)
+
+    def enable(self, capability):
+        """Send an RFC5161 enable string to the server.
+
+        (typ, [data]) = <instance>.enable(capability)
+        """
+        if 'ENABLE' not in self.capabilities:
+            raise IMAP4.error("Server does not support ENABLE")
+        typ, data = self._simple_command('ENABLE', capability)
+        if typ == 'OK' and 'UTF8=ACCEPT' in capability.upper():
+            self._mode_utf8()
+        return typ, data
+
+    def expunge(self):
+        """Permanently remove deleted items from selected mailbox.
+
+        Generates 'EXPUNGE' response for each deleted message.
+
+        (typ, [data]) = <instance>.expunge()
+
+        'data' is list of 'EXPUNGE'd message numbers in order received.
+        """
+        name = 'EXPUNGE'
+        typ, dat = self._simple_command(name)
+        return self._untagged_response(typ, dat, name)
+
+
+    def fetch(self, message_set, message_parts):
+        """Fetch (parts of) messages.
+
+        (typ, [data, ...]) = <instance>.fetch(message_set, message_parts)
+
+        'message_parts' should be a string of selected parts
+        enclosed in parentheses, eg: "(UID BODY[TEXT])".
+
+        'data' are tuples of message part envelope and data.
+        """
+        name = 'FETCH'
+        typ, dat = self._simple_command(name, message_set, message_parts)
+        return self._untagged_response(typ, dat, name)
+
+
+    def getacl(self, mailbox):
+        """Get the ACLs for a mailbox.
+
+        (typ, [data]) = <instance>.getacl(mailbox)
+        """
+        typ, dat = self._simple_command('GETACL', mailbox)
+        return self._untagged_response(typ, dat, 'ACL')
+
+
+    def getannotation(self, mailbox, entry, attribute):
+        """(typ, [data]) = <instance>.getannotation(mailbox, entry, attribute)
+        Retrieve ANNOTATIONs."""
+
+        typ, dat = self._simple_command('GETANNOTATION', mailbox, entry, attribute)
+        return self._untagged_response(typ, dat, 'ANNOTATION')
+
+
+    def getquota(self, root):
+        """Get the quota root's resource usage and limits.
+
+        Part of the IMAP4 QUOTA extension defined in rfc2087.
+
+        (typ, [data]) = <instance>.getquota(root)
+        """
+        typ, dat = self._simple_command('GETQUOTA', root)
+        return self._untagged_response(typ, dat, 'QUOTA')
+
+
+    def getquotaroot(self, mailbox):
+        """Get the list of quota roots for the named mailbox.
+
+        (typ, [[QUOTAROOT responses...], [QUOTA responses]]) = <instance>.getquotaroot(mailbox)
+        """
+        typ, dat = self._simple_command('GETQUOTAROOT', mailbox)
+        typ, quota = self._untagged_response(typ, dat, 'QUOTA')
+        typ, quotaroot = self._untagged_response(typ, dat, 'QUOTAROOT')
+        return typ, [quotaroot, quota]
+
+
+    def idle(self, duration=None):
+        """Return an iterable IDLE context manager producing untagged responses.
+        If the argument is not None, limit iteration to 'duration' seconds.
+
+        with M.idle(duration=29 * 60) as idler:
+            for typ, data in idler:
+                print(typ, data)
+
+        Note: 'duration' requires a socket connection (not IMAP4_stream).
+        """
+        return Idler(self, duration)
+
+
+    def list(self, directory='""', pattern='*'):
+        """List mailbox names in directory matching pattern.
+
+        (typ, [data]) = <instance>.list(directory='""', pattern='*')
+
+        'data' is list of LIST responses.
+        """
+        name = 'LIST'
+        typ, dat = self._simple_command(name, directory, pattern)
+        return self._untagged_response(typ, dat, name)
+
+
+    def login(self, user, password):
+        """Identify client using plaintext password.
+
+        (typ, [data]) = <instance>.login(user, password)
+
+        NB: 'password' will be quoted.
+        """
+        typ, dat = self._simple_command('LOGIN', user, self._quote(password))
+        if typ != 'OK':
+            raise self.error(dat[-1])
+        self.state = 'AUTH'
+        return typ, dat
+
+
+    def login_cram_md5(self, user, password):
+        """ Force use of CRAM-MD5 authentication.
+
+        (typ, [data]) = <instance>.login_cram_md5(user, password)
+        """
+        self.user, self.password = user, password
+        return self.authenticate('CRAM-MD5', self._CRAM_MD5_AUTH)
+
+
+    def _CRAM_MD5_AUTH(self, challenge):
+        """ Authobject to use with CRAM-MD5 authentication. """
+        import hmac
+
+        if isinstance(self.password, str):
+            password = self.password.encode('utf-8')
+        else:
+            password = self.password
+
+        try:
+            authcode = hmac.HMAC(password, challenge, 'md5')
+        except ValueError:  # HMAC-MD5 is not available
+            raise self.error("CRAM-MD5 authentication is not supported")
+        return f"{self.user} {authcode.hexdigest()}"
+
+
+    def logout(self):
+        """Shutdown connection to server.
+
+        (typ, [data]) = <instance>.logout()
+
+        Returns server 'BYE' response.
+        """
+        self.state = 'LOGOUT'
+        typ, dat = self._simple_command('LOGOUT')
+        self.shutdown()
+        return typ, dat
+
+
+    def lsub(self, directory='""', pattern='*'):
+        """List 'subscribed' mailbox names in directory matching pattern.
+
+        (typ, [data, ...]) = <instance>.lsub(directory='""', pattern='*')
+
+        'data' are tuples of message part envelope and data.
+        """
+        name = 'LSUB'
+        typ, dat = self._simple_command(name, directory, pattern)
+        return self._untagged_response(typ, dat, name)
+
+    def myrights(self, mailbox):
+        """Show my ACLs for a mailbox (i.e. the rights that I have on mailbox).
+
+        (typ, [data]) = <instance>.myrights(mailbox)
+        """
+        typ,dat = self._simple_command('MYRIGHTS', mailbox)
+        return self._untagged_response(typ, dat, 'MYRIGHTS')
+
+    def namespace(self):
+        """ Returns IMAP namespaces ala rfc2342
+
+        (typ, [data, ...]) = <instance>.namespace()
+        """
+        name = 'NAMESPACE'
+        typ, dat = self._simple_command(name)
+        return self._untagged_response(typ, dat, name)
+
+
+    def noop(self):
+        """Send NOOP command.
+
+        (typ, [data]) = <instance>.noop()
+        """
+        if __debug__:
+            if self.debug >= 3:
+                self._dump_ur(self.untagged_responses)
+        return self._simple_command('NOOP')
+
+
+    def partial(self, message_num, message_part, start, length):
+        """Fetch truncated part of a message.
+
+        (typ, [data, ...]) = <instance>.partial(message_num, message_part, start, length)
+
+        'data' is tuple of message part envelope and data.
+        """
+        name = 'PARTIAL'
+        typ, dat = self._simple_command(name, message_num, message_part, start, length)
+        return self._untagged_response(typ, dat, 'FETCH')
+
+
+    def proxyauth(self, user):
+        """Assume authentication as "user".
+
+        Allows an authorised administrator to proxy into any user's
+        mailbox.
+
+        (typ, [data]) = <instance>.proxyauth(user)
+        """
+
+        name = 'PROXYAUTH'
+        return self._simple_command('PROXYAUTH', user)
+
+
+    def rename(self, oldmailbox, newmailbox):
+        """Rename old mailbox name to new.
+
+        (typ, [data]) = <instance>.rename(oldmailbox, newmailbox)
+        """
+        return self._simple_command('RENAME', oldmailbox, newmailbox)
+
+
+    def search(self, charset, *criteria):
+        """Search mailbox for matching messages.
+
+        (typ, [data]) = <instance>.search(charset, criterion, ...)
+
+        'data' is space separated list of matching message numbers.
+        If UTF8 is enabled, charset MUST be None.
+        """
+        name = 'SEARCH'
+        if charset:
+            if self.utf8_enabled:
+                raise IMAP4.error("Non-None charset not valid in UTF8 mode")
+            typ, dat = self._simple_command(name, 'CHARSET', charset, *criteria)
+        else:
+            typ, dat = self._simple_command(name, *criteria)
+        return self._untagged_response(typ, dat, name)
+
+
+    def select(self, mailbox='INBOX', readonly=False):
+        """Select a mailbox.
+
+        Flush all untagged responses.
+
+        (typ, [data]) = <instance>.select(mailbox='INBOX', readonly=False)
+
+        'data' is count of messages in mailbox ('EXISTS' response).
+
+        Mandated responses are ('FLAGS', 'EXISTS', 'RECENT', 'UIDVALIDITY'), so
+        other responses should be obtained via <instance>.response('FLAGS') etc.
+        """
+        self.untagged_responses = {}    # Flush old responses.
+        self.is_readonly = readonly
+        if readonly:
+            name = 'EXAMINE'
+        else:
+            name = 'SELECT'
+        typ, dat = self._simple_command(name, mailbox)
+        if typ != 'OK':
+            self.state = 'AUTH'     # Might have been 'SELECTED'
+            return typ, dat
+        self.state = 'SELECTED'
+        if 'READ-ONLY' in self.untagged_responses \
+                and not readonly:
+            if __debug__:
+                if self.debug >= 1:
+                    self._dump_ur(self.untagged_responses)
+            raise self.readonly('%s is not writable' % mailbox)
+        return typ, self.untagged_responses.get('EXISTS', [None])
+
+
+    def setacl(self, mailbox, who, what):
+        """Set a mailbox acl.
+
+        (typ, [data]) = <instance>.setacl(mailbox, who, what)
+        """
+        return self._simple_command('SETACL', mailbox, who, what)
+
+
+    def setannotation(self, *args):
+        """(typ, [data]) = <instance>.setannotation(mailbox[, entry, attribute]+)
+        Set ANNOTATIONs."""
+
+        typ, dat = self._simple_command('SETANNOTATION', *args)
+        return self._untagged_response(typ, dat, 'ANNOTATION')
+
+
+    def setquota(self, root, limits):
+        """Set the quota root's resource limits.
+
+        (typ, [data]) = <instance>.setquota(root, limits)
+        """
+        typ, dat = self._simple_command('SETQUOTA', root, limits)
+        return self._untagged_response(typ, dat, 'QUOTA')
+
+
+    def sort(self, sort_criteria, charset, *search_criteria):
+        """IMAP4rev1 extension SORT command.
+
+        (typ, [data]) = <instance>.sort(sort_criteria, charset, search_criteria, ...)
+        """
+        name = 'SORT'
+        #if not name in self.capabilities:      # Let the server decide!
+        #       raise self.error('unimplemented extension command: %s' % name)
+        if (sort_criteria[0],sort_criteria[-1]) != ('(',')'):
+            sort_criteria = '(%s)' % sort_criteria
+        typ, dat = self._simple_command(name, sort_criteria, charset, *search_criteria)
+        return self._untagged_response(typ, dat, name)
+
+
+    def starttls(self, ssl_context=None):
+        name = 'STARTTLS'
+        if not HAVE_SSL:
+            raise self.error('SSL support missing')
+        if self._tls_established:
+            raise self.abort('TLS session already established')
+        if name not in self.capabilities:
+            raise self.abort('TLS not supported by server')
+        # Generate a default SSL context if none was passed.
+        if ssl_context is None:
+            ssl_context = ssl._create_stdlib_context()
+        typ, dat = self._simple_command(name)
+        if typ == 'OK':
+            self.sock = ssl_context.wrap_socket(self.sock,
+                                                server_hostname=self.host)
+            self._file = self.sock.makefile('rb')
+            self._tls_established = True
+            self._get_capabilities()
+        else:
+            raise self.error("Couldn't establish TLS session")
+        return self._untagged_response(typ, dat, name)
+
+
+    def status(self, mailbox, names):
+        """Request named status conditions for mailbox.
+
+        (typ, [data]) = <instance>.status(mailbox, names)
+        """
+        name = 'STATUS'
+        #if self.PROTOCOL_VERSION == 'IMAP4':   # Let the server decide!
+        #    raise self.error('%s unimplemented in IMAP4 (obtain IMAP4rev1 server, or re-code)' % name)
+        typ, dat = self._simple_command(name, mailbox, names)
+        return self._untagged_response(typ, dat, name)
+
+
+    def store(self, message_set, command, flags):
+        """Alters flag dispositions for messages in mailbox.
+
+        (typ, [data]) = <instance>.store(message_set, command, flags)
+        """
+        if (flags[0],flags[-1]) != ('(',')'):
+            flags = '(%s)' % flags  # Avoid quoting the flags
+        typ, dat = self._simple_command('STORE', message_set, command, flags)
+        return self._untagged_response(typ, dat, 'FETCH')
+
+
+    def subscribe(self, mailbox):
+        """Subscribe to new mailbox.
+
+        (typ, [data]) = <instance>.subscribe(mailbox)
+        """
+        return self._simple_command('SUBSCRIBE', mailbox)
+
+
+    def thread(self, threading_algorithm, charset, *search_criteria):
+        """IMAPrev1 extension THREAD command.
+
+        (type, [data]) = <instance>.thread(threading_algorithm, charset, search_criteria, ...)
+        """
+        name = 'THREAD'
+        typ, dat = self._simple_command(name, threading_algorithm, charset, *search_criteria)
+        return self._untagged_response(typ, dat, name)
+
+
+    def uid(self, command, *args):
+        """Execute "command arg ..." with messages identified by UID,
+                rather than message number.
+
+        (typ, [data]) = <instance>.uid(command, arg1, arg2, ...)
+
+        Returns response appropriate to 'command'.
+        """
+        command = command.upper()
+        if not command in Commands:
+            raise self.error("Unknown IMAP4 UID command: %s" % command)
+        if self.state not in Commands[command]:
+            raise self.error("command %s illegal in state %s, "
+                             "only allowed in states %s" %
+                             (command, self.state,
+                              ', '.join(Commands[command])))
+        name = 'UID'
+        typ, dat = self._simple_command(name, command, *args)
+        if command in ('SEARCH', 'SORT', 'THREAD'):
+            name = command
+        else:
+            name = 'FETCH'
+        return self._untagged_response(typ, dat, name)
+
+
+    def unsubscribe(self, mailbox):
+        """Unsubscribe from old mailbox.
+
+        (typ, [data]) = <instance>.unsubscribe(mailbox)
+        """
+        return self._simple_command('UNSUBSCRIBE', mailbox)
+
+
+    def unselect(self):
+        """Free server's resources associated with the selected mailbox
+        and returns the server to the authenticated state.
+        This command performs the same actions as CLOSE, except
+        that no messages are permanently removed from the currently
+        selected mailbox.
+
+        (typ, [data]) = <instance>.unselect()
+        """
+        try:
+            typ, data = self._simple_command('UNSELECT')
+        finally:
+            self.state = 'AUTH'
+        return typ, data
+
+
+    def xatom(self, name, *args):
+        """Allow simple extension commands
+                notified by server in CAPABILITY response.
+
+        Assumes command is legal in current state.
+
+        (typ, [data]) = <instance>.xatom(name, arg, ...)
+
+        Returns response appropriate to extension command 'name'.
+        """
+        name = name.upper()
+        #if not name in self.capabilities:      # Let the server decide!
+        #    raise self.error('unknown extension command: %s' % name)
+        if not name in Commands:
+            Commands[name] = (self.state,)
+        return self._simple_command(name, *args)
+
+
+
+    #       Private methods
+
+
+    def _append_untagged(self, typ, dat):
+        if dat is None:
+            dat = b''
+
+        # During idle, queue untagged responses for delivery via iteration
+        if self._idle_capture:
+            # Responses containing literal strings are passed to us one data
+            # fragment at a time, while others arrive in a single call.
+            if (not self._idle_responses or
+                isinstance(self._idle_responses[-1][1][-1], bytes)):
+                # We are not continuing a fragmented response; start a new one
+                self._idle_responses.append((typ, [dat]))
+            else:
+                # We are continuing a fragmented response; append the fragment
+                response = self._idle_responses[-1]
+                assert response[0] == typ
+                response[1].append(dat)
+            if __debug__ and self.debug >= 5:
+                self._mesg(f'idle: queue untagged {typ} {dat!r}')
+            return
+
+        ur = self.untagged_responses
+        if __debug__:
+            if self.debug >= 5:
+                self._mesg('untagged_responses[%s] %s += ["%r"]' %
+                        (typ, len(ur.get(typ,'')), dat))
+        if typ in ur:
+            ur[typ].append(dat)
+        else:
+            ur[typ] = [dat]
+
+
+    def _check_bye(self):
+        bye = self.untagged_responses.get('BYE')
+        if bye:
+            raise self.abort(bye[-1].decode(self._encoding, 'replace'))
+
+
+    def _command(self, name, *args):
+
+        if self.state not in Commands[name]:
+            self.literal = None
+            raise self.error("command %s illegal in state %s, "
+                             "only allowed in states %s" %
+                             (name, self.state,
+                              ', '.join(Commands[name])))
+
+        for typ in ('OK', 'NO', 'BAD'):
+            if typ in self.untagged_responses:
+                del self.untagged_responses[typ]
+
+        if 'READ-ONLY' in self.untagged_responses \
+        and not self.is_readonly:
+            raise self.readonly('mailbox status changed to READ-ONLY')
+
+        tag = self._new_tag()
+        name = bytes(name, self._encoding)
+        data = tag + b' ' + name
+        for arg in args:
+            if arg is None: continue
+            if isinstance(arg, str):
+                arg = bytes(arg, self._encoding)
+            data = data + b' ' + arg
+
+        literal = self.literal
+        if literal is not None:
+            self.literal = None
+            if type(literal) is type(self._command):
+                literator = literal
+            else:
+                literator = None
+                if self.utf8_enabled:
+                    data = data + bytes(' UTF8 (~{%s}' % len(literal), self._encoding)
+                    literal = literal + b')'
+                else:
+                    data = data + bytes(' {%s}' % len(literal), self._encoding)
+
+        if __debug__:
+            if self.debug >= 4:
+                self._mesg('> %r' % data)
+            else:
+                self._log('> %r' % data)
+
+        try:
+            self.send(data + CRLF)
+        except OSError as val:
+            raise self.abort('socket error: %s' % val)
+
+        if literal is None:
+            return tag
+
+        while 1:
+            # Wait for continuation response
+
+            while self._get_response():
+                if self.tagged_commands[tag]:   # BAD/NO?
+                    return tag
+
+            # Send literal
+
+            if literator:
+                literal = literator(self.continuation_response)
+
+            if __debug__:
+                if self.debug >= 4:
+                    self._mesg('write literal size %s' % len(literal))
+
+            try:
+                self.send(literal)
+                self.send(CRLF)
+            except OSError as val:
+                raise self.abort('socket error: %s' % val)
+
+            if not literator:
+                break
+
+        return tag
+
+
+    def _command_complete(self, name, tag):
+        logout = (name == 'LOGOUT')
+        # BYE is expected after LOGOUT
+        if not logout:
+            self._check_bye()
+        try:
+            typ, data = self._get_tagged_response(tag, expect_bye=logout)
+        except self.abort as val:
+            raise self.abort('command: %s => %s' % (name, val))
+        except self.error as val:
+            raise self.error('command: %s => %s' % (name, val))
+        if not logout:
+            self._check_bye()
+        if typ == 'BAD':
+            raise self.error('%s command error: %s %s' % (name, typ, data))
+        return typ, data
+
+
+    def _get_capabilities(self):
+        typ, dat = self.capability()
+        if dat == [None]:
+            raise self.error('no CAPABILITY response from server')
+        dat = str(dat[-1], self._encoding)
+        dat = dat.upper()
+        self.capabilities = tuple(dat.split())
+
+
+    def _get_response(self, start_timeout=False):
+
+        # Read response and store.
+        #
+        # Returns None for continuation responses,
+        # otherwise first response line received.
+        #
+        # If start_timeout is given, temporarily uses it as a socket
+        # timeout while waiting for the start of a response, raising
+        # _responsetimeout if one doesn't arrive. (Used by Idler.)
+
+        if start_timeout is not False and self.sock:
+            assert start_timeout is None or start_timeout > 0
+            saved_timeout = self.sock.gettimeout()
+            self.sock.settimeout(start_timeout)
+            try:
+                resp = self._get_line()
+            except TimeoutError as err:
+                raise self._responsetimeout from err
+            finally:
+                self.sock.settimeout(saved_timeout)
+        else:
+            resp = self._get_line()
+
+        # Command completion response?
+
+        if self._match(self.tagre, resp):
+            tag = self.mo.group('tag')
+            if not tag in self.tagged_commands:
+                raise self.abort('unexpected tagged response: %r' % resp)
+
+            typ = self.mo.group('type')
+            typ = str(typ, self._encoding)
+            dat = self.mo.group('data')
+            self.tagged_commands[tag] = (typ, [dat])
+        else:
+            dat2 = None
+
+            # '*' (untagged) responses?
+
+            if not self._match(Untagged_response, resp):
+                if self._match(self.Untagged_status, resp):
+                    dat2 = self.mo.group('data2')
+
+            if self.mo is None:
+                # Only other possibility is '+' (continuation) response...
+
+                if self._match(Continuation, resp):
+                    self.continuation_response = self.mo.group('data')
+                    return None     # NB: indicates continuation
+
+                raise self.abort("unexpected response: %r" % resp)
+
+            typ = self.mo.group('type')
+            typ = str(typ, self._encoding)
+            dat = self.mo.group('data')
+            if dat is None: dat = b''        # Null untagged response
+            if dat2: dat = dat + b' ' + dat2
+
+            # Is there a literal to come?
+
+            while self._match(self.Literal, dat):
+
+                # Read literal direct from connection.
+
+                size = int(self.mo.group('size'))
+                if __debug__:
+                    if self.debug >= 4:
+                        self._mesg('read literal size %s' % size)
+                data = self.read(size)
+
+                # Store response with literal as tuple
+
+                self._append_untagged(typ, (dat, data))
+
+                # Read trailer - possibly containing another literal
+
+                dat = self._get_line()
+
+            self._append_untagged(typ, dat)
+
+        # Bracketed response information?
+
+        if typ in ('OK', 'NO', 'BAD') and self._match(Response_code, dat):
+            typ = self.mo.group('type')
+            typ = str(typ, self._encoding)
+            self._append_untagged(typ, self.mo.group('data'))
+
+        if __debug__:
+            if self.debug >= 1 and typ in ('NO', 'BAD', 'BYE'):
+                self._mesg('%s response: %r' % (typ, dat))
+
+        return resp
+
+
+    def _get_tagged_response(self, tag, expect_bye=False):
+
+        while 1:
+            result = self.tagged_commands[tag]
+            if result is not None:
+                del self.tagged_commands[tag]
+                return result
+
+            if expect_bye:
+                typ = 'BYE'
+                bye = self.untagged_responses.pop(typ, None)
+                if bye is not None:
+                    # Server replies to the "LOGOUT" command with "BYE"
+                    return (typ, bye)
+
+            # If we've seen a BYE at this point, the socket will be
+            # closed, so report the BYE now.
+            self._check_bye()
+
+            # Some have reported "unexpected response" exceptions.
+            # Note that ignoring them here causes loops.
+            # Instead, send me details of the unexpected response and
+            # I'll update the code in '_get_response()'.
+
+            try:
+                self._get_response()
+            except self.abort as val:
+                if __debug__:
+                    if self.debug >= 1:
+                        self.print_log()
+                raise
+
+
+    def _get_line(self):
+
+        line = self.readline()
+        if not line:
+            raise self.abort('socket error: EOF')
+
+        # Protocol mandates all lines terminated by CRLF
+        if not line.endswith(b'\r\n'):
+            raise self.abort('socket error: unterminated line: %r' % line)
+
+        line = line[:-2]
+        if __debug__:
+            if self.debug >= 4:
+                self._mesg('< %r' % line)
+            else:
+                self._log('< %r' % line)
+        return line
+
+
+    def _match(self, cre, s):
+
+        # Run compiled regular expression match method on 's'.
+        # Save result, return success.
+
+        self.mo = cre.match(s)
+        if __debug__:
+            if self.mo is not None and self.debug >= 5:
+                self._mesg("\tmatched %r => %r" % (cre.pattern, self.mo.groups()))
+        return self.mo is not None
+
+
+    def _new_tag(self):
+
+        tag = self.tagpre + bytes(str(self.tagnum), self._encoding)
+        self.tagnum = self.tagnum + 1
+        self.tagged_commands[tag] = None
+        return tag
+
+
+    def _quote(self, arg):
+
+        arg = arg.replace('\\', '\\\\')
+        arg = arg.replace('"', '\\"')
+
+        return '"' + arg + '"'
+
+
+    def _simple_command(self, name, *args):
+
+        return self._command_complete(name, self._command(name, *args))
+
+
+    def _untagged_response(self, typ, dat, name):
+        if typ == 'NO':
+            return typ, dat
+        if not name in self.untagged_responses:
+            return typ, [None]
+        data = self.untagged_responses.pop(name)
+        if __debug__:
+            if self.debug >= 5:
+                self._mesg('untagged_responses[%s] => %s' % (name, data))
+        return typ, data
+
+
+    if __debug__:
+
+        def _mesg(self, s, secs=None):
+            if secs is None:
+                secs = time.time()
+            tm = time.strftime('%M:%S', time.localtime(secs))
+            sys.stderr.write('  %s.%02d %s\n' % (tm, (secs*100)%100, s))
+            sys.stderr.flush()
+
+        def _dump_ur(self, untagged_resp_dict):
+            if not untagged_resp_dict:
+                return
+            items = (f'{key}: {value!r}'
+                    for key, value in untagged_resp_dict.items())
+            self._mesg('untagged responses dump:' + '\n\t\t'.join(items))
+
+        def _log(self, line):
+            # Keep log of last '_cmd_log_len' interactions for debugging.
+            self._cmd_log[self._cmd_log_idx] = (line, time.time())
+            self._cmd_log_idx += 1
+            if self._cmd_log_idx >= self._cmd_log_len:
+                self._cmd_log_idx = 0
+
+        def print_log(self):
+            self._mesg('last %d IMAP4 interactions:' % len(self._cmd_log))
+            i, n = self._cmd_log_idx, self._cmd_log_len
+            while n:
+                try:
+                    self._mesg(*self._cmd_log[i])
+                except:
+                    pass
+                i += 1
+                if i >= self._cmd_log_len:
+                    i = 0
+                n -= 1
+
+
+class Idler:
+    """Iterable IDLE context manager: start IDLE & produce untagged responses.
+
+    An object of this type is returned by the IMAP4.idle() method.
+
+    Note: The name and structure of this class are subject to change.
+    """
+
+    def __init__(self, imap, duration=None):
+        if 'IDLE' not in imap.capabilities:
+            raise imap.error("Server does not support IMAP4 IDLE")
+        if duration is not None and not imap.sock:
+            # IMAP4_stream pipes don't support timeouts
+            raise imap.error('duration requires a socket connection')
+        self._duration = duration
+        self._deadline = None
+        self._imap = imap
+        self._tag = None
+        self._saved_state = None
+
+    def __enter__(self):
+        imap = self._imap
+        assert not imap._idle_responses
+        assert not imap._idle_capture
+
+        if __debug__ and imap.debug >= 4:
+            imap._mesg(f'idle start duration={self._duration}')
+
+        # Start capturing untagged responses before sending IDLE,
+        # so we can deliver via iteration any that arrive while
+        # the IDLE command continuation request is still pending.
+        imap._idle_capture = True
+
+        try:
+            self._tag = imap._command('IDLE')
+            # As with any command, the server is allowed to send us unrelated,
+            # untagged responses before acting on IDLE.  These lines will be
+            # returned by _get_response().  When the server is ready, it will
+            # send an IDLE continuation request, indicated by _get_response()
+            # returning None.  We therefore process responses in a loop until
+            # this occurs.
+            while resp := imap._get_response():
+                if imap.tagged_commands[self._tag]:
+                    typ, data = imap.tagged_commands.pop(self._tag)
+                    if typ == 'NO':
+                        raise imap.error(f'idle denied: {data}')
+                    raise imap.abort(f'unexpected status response: {resp}')
+
+            if __debug__ and imap.debug >= 4:
+                prompt = imap.continuation_response
+                imap._mesg(f'idle continuation prompt: {prompt}')
+        except BaseException:
+            imap._idle_capture = False
+            raise
+
+        if self._duration is not None:
+            self._deadline = time.monotonic() + self._duration
+
+        self._saved_state = imap.state
+        imap.state = 'IDLING'
+
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        imap = self._imap
+
+        if __debug__ and imap.debug >= 4:
+            imap._mesg('idle done')
+        imap.state = self._saved_state
+
+        # Stop intercepting untagged responses before sending DONE,
+        # since we can no longer deliver them via iteration.
+        imap._idle_capture = False
+
+        # If we captured untagged responses while the IDLE command
+        # continuation request was still pending, but the user did not
+        # iterate over them before exiting IDLE, we must put them
+        # someplace where the user can retrieve them.  The only
+        # sensible place for this is the untagged_responses dict,
+        # despite its unfortunate inability to preserve the relative
+        # order of different response types.
+        if leftovers := len(imap._idle_responses):
+            if __debug__ and imap.debug >= 4:
+                imap._mesg(f'idle quit with {leftovers} leftover responses')
+            while imap._idle_responses:
+                typ, data = imap._idle_responses.pop(0)
+                # Append one fragment at a time, just as _get_response() does
+                for datum in data:
+                    imap._append_untagged(typ, datum)
+
+        try:
+            imap.send(b'DONE' + CRLF)
+            status, [msg] = imap._command_complete('IDLE', self._tag)
+            if __debug__ and imap.debug >= 4:
+                imap._mesg(f'idle status: {status} {msg!r}')
+        except OSError:
+            if not exc_type:
+                raise
+
+        return False  # Do not suppress context body exceptions
+
+    def __iter__(self):
+        return self
+
+    def _pop(self, timeout, default=('', None)):
+        # Get the next response, or a default value on timeout.
+        # The timeout arg can be an int or float, or None for no timeout.
+        # Timeouts require a socket connection (not IMAP4_stream).
+        # This method ignores self._duration.
+
+        # Historical Note:
+        # The timeout was originally implemented using select() after
+        # checking for the presence of already-buffered data.
+        # That allowed timeouts on pipe connetions like IMAP4_stream.
+        # However, it seemed possible that SSL data arriving without any
+        # IMAP data afterward could cause select() to indicate available
+        # application data when there was none, leading to a read() call
+        # that would block with no timeout. It was unclear under what
+        # conditions this would happen in practice. Our implementation was
+        # changed to use socket timeouts instead of select(), just to be
+        # safe.
+
+        imap = self._imap
+        if imap.state != 'IDLING':
+            raise imap.error('_pop() only works during IDLE')
+
+        if imap._idle_responses:
+            # Response is ready to return to the user
+            resp = imap._idle_responses.pop(0)
+            if __debug__ and imap.debug >= 4:
+                imap._mesg(f'idle _pop({timeout}) de-queued {resp[0]}')
+            return resp
+
+        if __debug__ and imap.debug >= 4:
+            imap._mesg(f'idle _pop({timeout}) reading')
+
+        if timeout is not None:
+            if timeout <= 0:
+                return default
+            timeout = float(timeout)  # Required by socket.settimeout()
+
+        try:
+            imap._get_response(timeout)  # Reads line, calls _append_untagged()
+        except IMAP4._responsetimeout:
+            if __debug__ and imap.debug >= 4:
+                imap._mesg(f'idle _pop({timeout}) done')
+            return default
+
+        resp = imap._idle_responses.pop(0)
+
+        if __debug__ and imap.debug >= 4:
+            imap._mesg(f'idle _pop({timeout}) read {resp[0]}')
+        return resp
+
+    def __next__(self):
+        imap = self._imap
+
+        if self._duration is None:
+            timeout = None
+        else:
+            timeout = self._deadline - time.monotonic()
+        typ, data = self._pop(timeout)
+
+        if not typ:
+            if __debug__ and imap.debug >= 4:
+                imap._mesg('idle iterator exhausted')
+            raise StopIteration
+
+        return typ, data
+
+    def burst(self, interval=0.1):
+        """Yield a burst of responses no more than 'interval' seconds apart.
+
+        with M.idle() as idler:
+            # get a response and any others following by < 0.1 seconds
+            batch = list(idler.burst())
+            print(f'processing {len(batch)} responses...')
+            print(batch)
+
+        Note: This generator requires a socket connection (not IMAP4_stream).
+        """
+        if not self._imap.sock:
+            raise self._imap.error('burst() requires a socket connection')
+
+        try:
+            yield next(self)
+        except StopIteration:
+            return
+
+        while response := self._pop(interval, None):
+            yield response
+
+
+if HAVE_SSL:
+
+    class IMAP4_SSL(IMAP4):
+
+        """IMAP4 client class over SSL connection
+
+        Instantiate with: IMAP4_SSL([host[, port[, ssl_context[, timeout=None]]]])
+
+                host - host's name (default: localhost);
+                port - port number (default: standard IMAP4 SSL port);
+                ssl_context - a SSLContext object that contains your certificate chain
+                              and private key (default: None)
+                timeout - socket timeout (default: None) If timeout is not given or is None,
+                          the global default socket timeout is used
+
+        for more documentation see the docstring of the parent class IMAP4.
+        """
+
+
+        def __init__(self, host='', port=IMAP4_SSL_PORT,
+                     *, ssl_context=None, timeout=None):
+            if ssl_context is None:
+                ssl_context = ssl._create_stdlib_context()
+            self.ssl_context = ssl_context
+            IMAP4.__init__(self, host, port, timeout)
+
+        def _create_socket(self, timeout):
+            sock = IMAP4._create_socket(self, timeout)
+            return self.ssl_context.wrap_socket(sock,
+                                                server_hostname=self.host)
+
+        def open(self, host='', port=IMAP4_SSL_PORT, timeout=None):
+            """Setup connection to remote server on "host:port".
+                (default: localhost:standard IMAP4 SSL port).
+            This connection will be used by the routines:
+                read, readline, send, shutdown.
+            """
+            IMAP4.open(self, host, port, timeout)
+
+    __all__.append("IMAP4_SSL")
+
+
+class IMAP4_stream(IMAP4):
+
+    """IMAP4 client class over a stream
+
+    Instantiate with: IMAP4_stream(command)
+
+            "command" - a string that can be passed to subprocess.Popen()
+
+    for more documentation see the docstring of the parent class IMAP4.
+    """
+
+
+    def __init__(self, command):
+        self.command = command
+        IMAP4.__init__(self)
+
+
+    def open(self, host=None, port=None, timeout=None):
+        """Setup a stream connection.
+        This connection will be used by the routines:
+            read, readline, send, shutdown.
+        """
+        self.host = None        # For compatibility with parent class
+        self.port = None
+        self.sock = None
+        self._file = None
+        self.process = subprocess.Popen(self.command,
+            bufsize=DEFAULT_BUFFER_SIZE,
+            stdin=subprocess.PIPE, stdout=subprocess.PIPE,
+            shell=True, close_fds=True)
+        self.writefile = self.process.stdin
+        self.readfile = self.process.stdout
+
+    def read(self, size):
+        """Read 'size' bytes from remote."""
+        return self.readfile.read(size)
+
+
+    def readline(self):
+        """Read line from remote."""
+        return self.readfile.readline()
+
+
+    def send(self, data):
+        """Send data to remote."""
+        self.writefile.write(data)
+        self.writefile.flush()
+
+
+    def shutdown(self):
+        """Close I/O established in "open"."""
+        self.readfile.close()
+        self.writefile.close()
+        self.process.wait()
+
+
+
+class _Authenticator:
+
+    """Private class to provide en/decoding
+            for base64-based authentication conversation.
+    """
+
+    def __init__(self, mechinst):
+        self.mech = mechinst    # Callable object to provide/process data
+
+    def process(self, data):
+        ret = self.mech(self.decode(data))
+        if ret is None:
+            return b'*'     # Abort conversation
+        return self.encode(ret)
+
+    def encode(self, inp):
+        #
+        #  Invoke binascii.b2a_base64 iteratively with
+        #  short even length buffers, strip the trailing
+        #  line feed from the result and append.  "Even"
+        #  means a number that factors to both 6 and 8,
+        #  so when it gets to the end of the 8-bit input
+        #  there's no partial 6-bit output.
+        #
+        oup = b''
+        if isinstance(inp, str):
+            inp = inp.encode('utf-8')
+        while inp:
+            if len(inp) > 48:
+                t = inp[:48]
+                inp = inp[48:]
+            else:
+                t = inp
+                inp = b''
+            e = binascii.b2a_base64(t)
+            if e:
+                oup = oup + e[:-1]
+        return oup
+
+    def decode(self, inp):
+        if not inp:
+            return b''
+        return binascii.a2b_base64(inp)
+
+Months = ' Jan Feb Mar Apr May Jun Jul Aug Sep Oct Nov Dec'.split(' ')
+Mon2num = {s.encode():n+1 for n, s in enumerate(Months[1:])}
+
+def Internaldate2tuple(resp):
+    """Parse an IMAP4 INTERNALDATE string.
+
+    Return corresponding local time.  The return value is a
+    time.struct_time tuple or None if the string has wrong format.
+    """
+
+    mo = InternalDate.match(resp)
+    if not mo:
+        return None
+
+    mon = Mon2num[mo.group('mon')]
+    zonen = mo.group('zonen')
+
+    day = int(mo.group('day'))
+    year = int(mo.group('year'))
+    hour = int(mo.group('hour'))
+    min = int(mo.group('min'))
+    sec = int(mo.group('sec'))
+    zoneh = int(mo.group('zoneh'))
+    zonem = int(mo.group('zonem'))
+
+    # INTERNALDATE timezone must be subtracted to get UT
+
+    zone = (zoneh*60 + zonem)*60
+    if zonen == b'-':
+        zone = -zone
+
+    tt = (year, mon, day, hour, min, sec, -1, -1, -1)
+    utc = calendar.timegm(tt) - zone
+
+    return time.localtime(utc)
+
+
+
+def Int2AP(num):
+
+    """Convert integer to A-P string representation."""
+
+    val = b''; AP = b'ABCDEFGHIJKLMNOP'
+    num = int(abs(num))
+    while num:
+        num, mod = divmod(num, 16)
+        val = AP[mod:mod+1] + val
+    return val
+
+
+
+def ParseFlags(resp):
+
+    """Convert IMAP4 flags response to python tuple."""
+
+    mo = Flags.match(resp)
+    if not mo:
+        return ()
+
+    return tuple(mo.group('flags').split())
+
+
+def Time2Internaldate(date_time):
+
+    """Convert date_time to IMAP4 INTERNALDATE representation.
+
+    Return string in form: '"DD-Mmm-YYYY HH:MM:SS +HHMM"'.  The
+    date_time argument can be a number (int or float) representing
+    seconds since epoch (as returned by time.time()), a 9-tuple
+    representing local time, an instance of time.struct_time (as
+    returned by time.localtime()), an aware datetime instance or a
+    double-quoted string.  In the last case, it is assumed to already
+    be in the correct format.
+    """
+    if isinstance(date_time, (int, float)):
+        dt = datetime.fromtimestamp(date_time,
+                                    timezone.utc).astimezone()
+    elif isinstance(date_time, tuple):
+        try:
+            gmtoff = date_time.tm_gmtoff
+        except AttributeError:
+            if time.daylight:
+                dst = date_time[8]
+                if dst == -1:
+                    dst = time.localtime(time.mktime(date_time))[8]
+                gmtoff = -(time.timezone, time.altzone)[dst]
+            else:
+                gmtoff = -time.timezone
+        delta = timedelta(seconds=gmtoff)
+        dt = datetime(*date_time[:6], tzinfo=timezone(delta))
+    elif isinstance(date_time, datetime):
+        if date_time.tzinfo is None:
+            raise ValueError("date_time must be aware")
+        dt = date_time
+    elif isinstance(date_time, str) and (date_time[0],date_time[-1]) == ('"','"'):
+        return date_time        # Assume in correct format
+    else:
+        raise ValueError("date_time not of a known type")
+    fmt = '"%d-{}-%Y %H:%M:%S %z"'.format(Months[dt.month])
+    return dt.strftime(fmt)
+
+
+
+if __name__ == '__main__':
+
+    # To test: invoke either as 'python imaplib.py [IMAP4_server_hostname]'
+    # or 'python imaplib.py -s "rsh IMAP4_server_hostname exec /etc/rimapd"'
+    # to test the IMAP4_stream class
+
+    import getopt, getpass
+
+    try:
+        optlist, args = getopt.getopt(sys.argv[1:], 'd:s:')
+    except getopt.error as val:
+        optlist, args = (), ()
+
+    stream_command = None
+    for opt,val in optlist:
+        if opt == '-d':
+            Debug = int(val)
+        elif opt == '-s':
+            stream_command = val
+            if not args: args = (stream_command,)
+
+    if not args: args = ('',)
+
+    host = args[0]
+
+    USER = getpass.getuser()
+    PASSWD = getpass.getpass("IMAP password for %s on %s: " % (USER, host or "localhost"))
+
+    test_mesg = 'From: %(user)s@localhost%(lf)sSubject: IMAP4 test%(lf)s%(lf)sdata...%(lf)s' % {'user':USER, 'lf':'\n'}
+    test_seq1 = (
+    ('login', (USER, PASSWD)),
+    ('create', ('/tmp/xxx 1',)),
+    ('rename', ('/tmp/xxx 1', '/tmp/yyy')),
+    ('CREATE', ('/tmp/yyz 2',)),
+    ('append', ('/tmp/yyz 2', None, None, test_mesg)),
+    ('list', ('/tmp', 'yy*')),
+    ('select', ('/tmp/yyz 2',)),
+    ('search', (None, 'SUBJECT', 'test')),
+    ('fetch', ('1', '(FLAGS INTERNALDATE RFC822)')),
+    ('store', ('1', 'FLAGS', r'(\Deleted)')),
+    ('namespace', ()),
+    ('expunge', ()),
+    ('recent', ()),
+    ('close', ()),
+    )
+
+    test_seq2 = (
+    ('select', ()),
+    ('response',('UIDVALIDITY',)),
+    ('uid', ('SEARCH', 'ALL')),
+    ('response', ('EXISTS',)),
+    ('append', (None, None, None, test_mesg)),
+    ('recent', ()),
+    ('logout', ()),
+    )
+
+    def run(cmd, args):
+        M._mesg('%s %s' % (cmd, args))
+        typ, dat = getattr(M, cmd)(*args)
+        M._mesg('%s => %s %s' % (cmd, typ, dat))
+        if typ == 'NO': raise dat[0]
+        return dat
+
+    try:
+        if stream_command:
+            M = IMAP4_stream(stream_command)
+        else:
+            M = IMAP4(host)
+        if M.state == 'AUTH':
+            test_seq1 = test_seq1[1:]   # Login not needed
+        M._mesg('PROTOCOL_VERSION = %s' % M.PROTOCOL_VERSION)
+        M._mesg('CAPABILITIES = %r' % (M.capabilities,))
+
+        for cmd,args in test_seq1:
+            run(cmd, args)
+
+        for ml in run('list', ('/tmp/', 'yy%')):
+            mo = re.match(r'.*"([^"]+)"$', ml)
+            if mo: path = mo.group(1)
+            else: path = ml.split()[-1]
+            run('delete', (path,))
+
+        for cmd,args in test_seq2:
+            dat = run(cmd, args)
+
+            if (cmd,args) != ('uid', ('SEARCH', 'ALL')):
+                continue
+
+            uid = dat[-1].split()
+            if not uid: continue
+            run('uid', ('FETCH', '%s' % uid[-1],
+                    '(FLAGS INTERNALDATE RFC822.SIZE RFC822.HEADER RFC822.TEXT)'))
+
+        print('\nAll tests OK.')
+
+    except:
+        print('\nTests failed.')
+
+        if not Debug:
+            print('''
+If you would like to see debugging output,
+try: %s -d5
+''' % sys.argv[0])
+
+        raise
diff --git a/Lib/importlib/_bootstrap.py b/Lib/importlib/_bootstrap.py
index 68d993cacae..499da1e04ef 100644
--- a/Lib/importlib/_bootstrap.py
+++ b/Lib/importlib/_bootstrap.py
@@ -382,6 +382,9 @@ def release(self):
                     self.waiters.pop()
                     self.wakeup.release()
 
+    def locked(self):
+        return bool(self.count)
+
     def __repr__(self):
         return f'_ModuleLock({self.name!r}) at {id(self)}'
 
@@ -490,8 +493,7 @@ def _call_with_frames_removed(f, *args, **kwds):
 
 def _verbose_message(message, *args, verbosity=1):
     """Print the message to stderr if -v/PYTHONVERBOSE is turned on."""
-    # XXX RUSTPYTHON: hasattr check because we might be bootstrapping and we wouldn't have stderr yet
-    if sys.flags.verbose >= verbosity and hasattr(sys, "stderr"):
+    if sys.flags.verbose >= verbosity:
         if not message.startswith(('#', 'import ')):
             message = '# ' + message
         print(message.format(*args), file=sys.stderr)
@@ -1242,10 +1244,12 @@ def _find_spec(name, path, target=None):
     """Find a module's spec."""
     meta_path = sys.meta_path
     if meta_path is None:
-        # PyImport_Cleanup() is running or has been called.
         raise ImportError("sys.meta_path is None, Python is likely "
                           "shutting down")
 
+    # gh-130094: Copy sys.meta_path so that we have a consistent view of the
+    # list while iterating over it.
+    meta_path = list(meta_path)
     if not meta_path:
         _warnings.warn('sys.meta_path is empty', ImportWarning)
 
@@ -1300,7 +1304,6 @@ def _sanity_check(name, package, level):
 
 
 _ERR_MSG_PREFIX = 'No module named '
-_ERR_MSG = _ERR_MSG_PREFIX + '{!r}'
 
 def _find_and_load_unlocked(name, import_):
     path = None
@@ -1310,8 +1313,9 @@ def _find_and_load_unlocked(name, import_):
         if parent not in sys.modules:
             _call_with_frames_removed(import_, parent)
         # Crazy side-effects!
-        if name in sys.modules:
-            return sys.modules[name]
+        module = sys.modules.get(name)
+        if module is not None:
+            return module
         parent_module = sys.modules[parent]
         try:
             path = parent_module.__path__
@@ -1319,6 +1323,12 @@ def _find_and_load_unlocked(name, import_):
             msg = f'{_ERR_MSG_PREFIX}{name!r}; {parent!r} is not a package'
             raise ModuleNotFoundError(msg, name=name) from None
         parent_spec = parent_module.__spec__
+        if getattr(parent_spec, '_initializing', False):
+            _call_with_frames_removed(import_, parent)
+        # Crazy side-effects (again)!
+        module = sys.modules.get(name)
+        if module is not None:
+            return module
         child = name.rpartition('.')[2]
     spec = _find_spec(name, path)
     if spec is None:
diff --git a/Lib/importlib/_bootstrap_external.py b/Lib/importlib/_bootstrap_external.py
index 89ce8c09c94..95ce14b2c39 100644
--- a/Lib/importlib/_bootstrap_external.py
+++ b/Lib/importlib/_bootstrap_external.py
@@ -221,277 +221,7 @@ def _write_atomic(path, data, mode=0o666):
 
 _code_type = type(_write_atomic.__code__)
 
-
-# Finder/loader utility code ###############################################
-
-# Magic word to reject .pyc files generated by other Python versions.
-# It should change for each incompatible change to the bytecode.
-#
-# The value of CR and LF is incorporated so if you ever read or write
-# a .pyc file in text mode the magic number will be wrong; also, the
-# Apple MPW compiler swaps their values, botching string constants.
-#
-# There were a variety of old schemes for setting the magic number.
-# The current working scheme is to increment the previous value by
-# 10.
-#
-# Starting with the adoption of PEP 3147 in Python 3.2, every bump in magic
-# number also includes a new "magic tag", i.e. a human readable string used
-# to represent the magic number in __pycache__ directories.  When you change
-# the magic number, you must also set a new unique magic tag.  Generally this
-# can be named after the Python major version of the magic number bump, but
-# it can really be anything, as long as it's different than anything else
-# that's come before.  The tags are included in the following table, starting
-# with Python 3.2a0.
-#
-# Known values:
-#  Python 1.5:   20121
-#  Python 1.5.1: 20121
-#     Python 1.5.2: 20121
-#     Python 1.6:   50428
-#     Python 2.0:   50823
-#     Python 2.0.1: 50823
-#     Python 2.1:   60202
-#     Python 2.1.1: 60202
-#     Python 2.1.2: 60202
-#     Python 2.2:   60717
-#     Python 2.3a0: 62011
-#     Python 2.3a0: 62021
-#     Python 2.3a0: 62011 (!)
-#     Python 2.4a0: 62041
-#     Python 2.4a3: 62051
-#     Python 2.4b1: 62061
-#     Python 2.5a0: 62071
-#     Python 2.5a0: 62081 (ast-branch)
-#     Python 2.5a0: 62091 (with)
-#     Python 2.5a0: 62092 (changed WITH_CLEANUP opcode)
-#     Python 2.5b3: 62101 (fix wrong code: for x, in ...)
-#     Python 2.5b3: 62111 (fix wrong code: x += yield)
-#     Python 2.5c1: 62121 (fix wrong lnotab with for loops and
-#                          storing constants that should have been removed)
-#     Python 2.5c2: 62131 (fix wrong code: for x, in ... in listcomp/genexp)
-#     Python 2.6a0: 62151 (peephole optimizations and STORE_MAP opcode)
-#     Python 2.6a1: 62161 (WITH_CLEANUP optimization)
-#     Python 2.7a0: 62171 (optimize list comprehensions/change LIST_APPEND)
-#     Python 2.7a0: 62181 (optimize conditional branches:
-#                          introduce POP_JUMP_IF_FALSE and POP_JUMP_IF_TRUE)
-#     Python 2.7a0  62191 (introduce SETUP_WITH)
-#     Python 2.7a0  62201 (introduce BUILD_SET)
-#     Python 2.7a0  62211 (introduce MAP_ADD and SET_ADD)
-#     Python 3000:   3000
-#                    3010 (removed UNARY_CONVERT)
-#                    3020 (added BUILD_SET)
-#                    3030 (added keyword-only parameters)
-#                    3040 (added signature annotations)
-#                    3050 (print becomes a function)
-#                    3060 (PEP 3115 metaclass syntax)
-#                    3061 (string literals become unicode)
-#                    3071 (PEP 3109 raise changes)
-#                    3081 (PEP 3137 make __file__ and __name__ unicode)
-#                    3091 (kill str8 interning)
-#                    3101 (merge from 2.6a0, see 62151)
-#                    3103 (__file__ points to source file)
-#     Python 3.0a4: 3111 (WITH_CLEANUP optimization).
-#     Python 3.0b1: 3131 (lexical exception stacking, including POP_EXCEPT
-                          #3021)
-#     Python 3.1a1: 3141 (optimize list, set and dict comprehensions:
-#                         change LIST_APPEND and SET_ADD, add MAP_ADD #2183)
-#     Python 3.1a1: 3151 (optimize conditional branches:
-#                         introduce POP_JUMP_IF_FALSE and POP_JUMP_IF_TRUE
-                          #4715)
-#     Python 3.2a1: 3160 (add SETUP_WITH #6101)
-#                   tag: cpython-32
-#     Python 3.2a2: 3170 (add DUP_TOP_TWO, remove DUP_TOPX and ROT_FOUR #9225)
-#                   tag: cpython-32
-#     Python 3.2a3  3180 (add DELETE_DEREF #4617)
-#     Python 3.3a1  3190 (__class__ super closure changed)
-#     Python 3.3a1  3200 (PEP 3155 __qualname__ added #13448)
-#     Python 3.3a1  3210 (added size modulo 2**32 to the pyc header #13645)
-#     Python 3.3a2  3220 (changed PEP 380 implementation #14230)
-#     Python 3.3a4  3230 (revert changes to implicit __class__ closure #14857)
-#     Python 3.4a1  3250 (evaluate positional default arguments before
-#                        keyword-only defaults #16967)
-#     Python 3.4a1  3260 (add LOAD_CLASSDEREF; allow locals of class to override
-#                        free vars #17853)
-#     Python 3.4a1  3270 (various tweaks to the __class__ closure #12370)
-#     Python 3.4a1  3280 (remove implicit class argument)
-#     Python 3.4a4  3290 (changes to __qualname__ computation #19301)
-#     Python 3.4a4  3300 (more changes to __qualname__ computation #19301)
-#     Python 3.4rc2 3310 (alter __qualname__ computation #20625)
-#     Python 3.5a1  3320 (PEP 465: Matrix multiplication operator #21176)
-#     Python 3.5b1  3330 (PEP 448: Additional Unpacking Generalizations #2292)
-#     Python 3.5b2  3340 (fix dictionary display evaluation order #11205)
-#     Python 3.5b3  3350 (add GET_YIELD_FROM_ITER opcode #24400)
-#     Python 3.5.2  3351 (fix BUILD_MAP_UNPACK_WITH_CALL opcode #27286)
-#     Python 3.6a0  3360 (add FORMAT_VALUE opcode #25483)
-#     Python 3.6a1  3361 (lineno delta of code.co_lnotab becomes signed #26107)
-#     Python 3.6a2  3370 (16 bit wordcode #26647)
-#     Python 3.6a2  3371 (add BUILD_CONST_KEY_MAP opcode #27140)
-#     Python 3.6a2  3372 (MAKE_FUNCTION simplification, remove MAKE_CLOSURE
-#                         #27095)
-#     Python 3.6b1  3373 (add BUILD_STRING opcode #27078)
-#     Python 3.6b1  3375 (add SETUP_ANNOTATIONS and STORE_ANNOTATION opcodes
-#                         #27985)
-#     Python 3.6b1  3376 (simplify CALL_FUNCTIONs & BUILD_MAP_UNPACK_WITH_CALL
-                          #27213)
-#     Python 3.6b1  3377 (set __class__ cell from type.__new__ #23722)
-#     Python 3.6b2  3378 (add BUILD_TUPLE_UNPACK_WITH_CALL #28257)
-#     Python 3.6rc1 3379 (more thorough __class__ validation #23722)
-#     Python 3.7a1  3390 (add LOAD_METHOD and CALL_METHOD opcodes #26110)
-#     Python 3.7a2  3391 (update GET_AITER #31709)
-#     Python 3.7a4  3392 (PEP 552: Deterministic pycs #31650)
-#     Python 3.7b1  3393 (remove STORE_ANNOTATION opcode #32550)
-#     Python 3.7b5  3394 (restored docstring as the first stmt in the body;
-#                         this might affected the first line number #32911)
-#     Python 3.8a1  3400 (move frame block handling to compiler #17611)
-#     Python 3.8a1  3401 (add END_ASYNC_FOR #33041)
-#     Python 3.8a1  3410 (PEP570 Python Positional-Only Parameters #36540)
-#     Python 3.8b2  3411 (Reverse evaluation order of key: value in dict
-#                         comprehensions #35224)
-#     Python 3.8b2  3412 (Swap the position of positional args and positional
-#                         only args in ast.arguments #37593)
-#     Python 3.8b4  3413 (Fix "break" and "continue" in "finally" #37830)
-#     Python 3.9a0  3420 (add LOAD_ASSERTION_ERROR #34880)
-#     Python 3.9a0  3421 (simplified bytecode for with blocks #32949)
-#     Python 3.9a0  3422 (remove BEGIN_FINALLY, END_FINALLY, CALL_FINALLY, POP_FINALLY bytecodes #33387)
-#     Python 3.9a2  3423 (add IS_OP, CONTAINS_OP and JUMP_IF_NOT_EXC_MATCH bytecodes #39156)
-#     Python 3.9a2  3424 (simplify bytecodes for *value unpacking)
-#     Python 3.9a2  3425 (simplify bytecodes for **value unpacking)
-#     Python 3.10a1 3430 (Make 'annotations' future by default)
-#     Python 3.10a1 3431 (New line number table format -- PEP 626)
-#     Python 3.10a2 3432 (Function annotation for MAKE_FUNCTION is changed from dict to tuple bpo-42202)
-#     Python 3.10a2 3433 (RERAISE restores f_lasti if oparg != 0)
-#     Python 3.10a6 3434 (PEP 634: Structural Pattern Matching)
-#     Python 3.10a7 3435 Use instruction offsets (as opposed to byte offsets).
-#     Python 3.10b1 3436 (Add GEN_START bytecode #43683)
-#     Python 3.10b1 3437 (Undo making 'annotations' future by default - We like to dance among core devs!)
-#     Python 3.10b1 3438 Safer line number table handling.
-#     Python 3.10b1 3439 (Add ROT_N)
-#     Python 3.11a1 3450 Use exception table for unwinding ("zero cost" exception handling)
-#     Python 3.11a1 3451 (Add CALL_METHOD_KW)
-#     Python 3.11a1 3452 (drop nlocals from marshaled code objects)
-#     Python 3.11a1 3453 (add co_fastlocalnames and co_fastlocalkinds)
-#     Python 3.11a1 3454 (compute cell offsets relative to locals bpo-43693)
-#     Python 3.11a1 3455 (add MAKE_CELL bpo-43693)
-#     Python 3.11a1 3456 (interleave cell args bpo-43693)
-#     Python 3.11a1 3457 (Change localsplus to a bytes object bpo-43693)
-#     Python 3.11a1 3458 (imported objects now don't use LOAD_METHOD/CALL_METHOD)
-#     Python 3.11a1 3459 (PEP 657: add end line numbers and column offsets for instructions)
-#     Python 3.11a1 3460 (Add co_qualname field to PyCodeObject bpo-44530)
-#     Python 3.11a1 3461 (JUMP_ABSOLUTE must jump backwards)
-#     Python 3.11a2 3462 (bpo-44511: remove COPY_DICT_WITHOUT_KEYS, change
-#                         MATCH_CLASS and MATCH_KEYS, and add COPY)
-#     Python 3.11a3 3463 (bpo-45711: JUMP_IF_NOT_EXC_MATCH no longer pops the
-#                         active exception)
-#     Python 3.11a3 3464 (bpo-45636: Merge numeric BINARY_*/INPLACE_* into
-#                         BINARY_OP)
-#     Python 3.11a3 3465 (Add COPY_FREE_VARS opcode)
-#     Python 3.11a4 3466 (bpo-45292: PEP-654 except*)
-#     Python 3.11a4 3467 (Change CALL_xxx opcodes)
-#     Python 3.11a4 3468 (Add SEND opcode)
-#     Python 3.11a4 3469 (bpo-45711: remove type, traceback from exc_info)
-#     Python 3.11a4 3470 (bpo-46221: PREP_RERAISE_STAR no longer pushes lasti)
-#     Python 3.11a4 3471 (bpo-46202: remove pop POP_EXCEPT_AND_RERAISE)
-#     Python 3.11a4 3472 (bpo-46009: replace GEN_START with POP_TOP)
-#     Python 3.11a4 3473 (Add POP_JUMP_IF_NOT_NONE/POP_JUMP_IF_NONE opcodes)
-#     Python 3.11a4 3474 (Add RESUME opcode)
-#     Python 3.11a5 3475 (Add RETURN_GENERATOR opcode)
-#     Python 3.11a5 3476 (Add ASYNC_GEN_WRAP opcode)
-#     Python 3.11a5 3477 (Replace DUP_TOP/DUP_TOP_TWO with COPY and
-#                         ROT_TWO/ROT_THREE/ROT_FOUR/ROT_N with SWAP)
-#     Python 3.11a5 3478 (New CALL opcodes)
-#     Python 3.11a5 3479 (Add PUSH_NULL opcode)
-#     Python 3.11a5 3480 (New CALL opcodes, second iteration)
-#     Python 3.11a5 3481 (Use inline cache for BINARY_OP)
-#     Python 3.11a5 3482 (Use inline caching for UNPACK_SEQUENCE and LOAD_GLOBAL)
-#     Python 3.11a5 3483 (Use inline caching for COMPARE_OP and BINARY_SUBSCR)
-#     Python 3.11a5 3484 (Use inline caching for LOAD_ATTR, LOAD_METHOD, and
-#                         STORE_ATTR)
-#     Python 3.11a5 3485 (Add an oparg to GET_AWAITABLE)
-#     Python 3.11a6 3486 (Use inline caching for PRECALL and CALL)
-#     Python 3.11a6 3487 (Remove the adaptive "oparg counter" mechanism)
-#     Python 3.11a6 3488 (LOAD_GLOBAL can push additional NULL)
-#     Python 3.11a6 3489 (Add JUMP_BACKWARD, remove JUMP_ABSOLUTE)
-#     Python 3.11a6 3490 (remove JUMP_IF_NOT_EXC_MATCH, add CHECK_EXC_MATCH)
-#     Python 3.11a6 3491 (remove JUMP_IF_NOT_EG_MATCH, add CHECK_EG_MATCH,
-#                         add JUMP_BACKWARD_NO_INTERRUPT, make JUMP_NO_INTERRUPT virtual)
-#     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)
-#     Python 3.12a1 3503 (Shrink LOAD_METHOD cache)
-#     Python 3.12a1 3504 (Merge LOAD_METHOD back into LOAD_ATTR)
-#     Python 3.12a1 3505 (Specialization/Cache for FOR_ITER)
-#     Python 3.12a1 3506 (Add BINARY_SLICE and STORE_SLICE instructions)
-#     Python 3.12a1 3507 (Set lineno of module's RESUME to 0)
-#     Python 3.12a1 3508 (Add CLEANUP_THROW)
-#     Python 3.12a1 3509 (Conditional jumps only jump forward)
-#     Python 3.12a2 3510 (FOR_ITER leaves iterator on the stack)
-#     Python 3.12a2 3511 (Add STOPITERATION_ERROR instruction)
-#     Python 3.12a2 3512 (Remove all unused consts from code objects)
-#     Python 3.12a4 3513 (Add CALL_INTRINSIC_1 instruction, removed STOPITERATION_ERROR, PRINT_EXPR, IMPORT_STAR)
-#     Python 3.12a4 3514 (Remove ASYNC_GEN_WRAP, LIST_TO_TUPLE, and UNARY_POSITIVE)
-#     Python 3.12a5 3515 (Embed jump mask in COMPARE_OP oparg)
-#     Python 3.12a5 3516 (Add COMPARE_AND_BRANCH instruction)
-#     Python 3.12a5 3517 (Change YIELD_VALUE oparg to exception block depth)
-#     Python 3.12a6 3518 (Add RETURN_CONST instruction)
-#     Python 3.12a6 3519 (Modify SEND instruction)
-#     Python 3.12a6 3520 (Remove PREP_RERAISE_STAR, add CALL_INTRINSIC_2)
-#     Python 3.12a7 3521 (Shrink the LOAD_GLOBAL caches)
-#     Python 3.12a7 3522 (Removed JUMP_IF_FALSE_OR_POP/JUMP_IF_TRUE_OR_POP)
-#     Python 3.12a7 3523 (Convert COMPARE_AND_BRANCH back to COMPARE_OP)
-#     Python 3.12a7 3524 (Shrink the BINARY_SUBSCR caches)
-#     Python 3.12b1 3525 (Shrink the CALL caches)
-#     Python 3.12b1 3526 (Add instrumentation support)
-#     Python 3.12b1 3527 (Add LOAD_SUPER_ATTR)
-#     Python 3.12b1 3528 (Add LOAD_SUPER_ATTR_METHOD specialization)
-#     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.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
-#     a week ago, I should put "Python 3.12a7" next to my new magic number.
-
-# MAGIC must change whenever the bytecode emitted by the compiler may no
-# longer be understood by older implementations of the eval loop (usually
-# due to the addition of new opcodes).
-#
-# Starting with Python 3.11, Python 3.n starts with magic number 2900+50n.
-#
-# Whenever MAGIC_NUMBER is changed, the ranges in the magic_values array
-# in PC/launcher.c must also be updated.
-
-MAGIC_NUMBER = (2996).to_bytes(2, 'little') + b'\r\n'
-
-_RAW_MAGIC_NUMBER = int.from_bytes(MAGIC_NUMBER, 'little')  # For import.c
+MAGIC_NUMBER = _imp.pyc_magic_number_token.to_bytes(4, 'little')
 
 _PYCACHE = '__pycache__'
 _OPT = 'opt-'
@@ -983,6 +713,12 @@ def _search_registry(cls, fullname):
 
     @classmethod
     def find_spec(cls, fullname, path=None, target=None):
+        _warnings.warn('importlib.machinery.WindowsRegistryFinder is '
+                       'deprecated; use site configuration instead. '
+                       'Future versions of Python may not enable this '
+                       'finder by default.',
+                       DeprecationWarning, stacklevel=2)
+
         filepath = cls._search_registry(fullname)
         if filepath is None:
             return None
@@ -1131,7 +867,7 @@ def get_code(self, fullname):
                                  _imp.check_hash_based_pycs == 'always')):
                                 source_bytes = self.get_data(source_path)
                                 source_hash = _imp.source_hash(
-                                    _RAW_MAGIC_NUMBER,
+                                    _imp.pyc_magic_number_token,
                                     source_bytes,
                                 )
                                 _validate_hash_pyc(data, source_hash, fullname,
@@ -1160,7 +896,7 @@ def get_code(self, fullname):
                 source_mtime is not None):
             if hash_based:
                 if source_hash is None:
-                    source_hash = _imp.source_hash(_RAW_MAGIC_NUMBER,
+                    source_hash = _imp.source_hash(_imp.pyc_magic_number_token,
                                                    source_bytes)
                 data = _code_to_hash_pyc(code_object, source_hash, check_source)
             else:
@@ -1505,7 +1241,7 @@ def _path_importer_cache(cls, path):
         if path == '':
             try:
                 path = _os.getcwd()
-            except FileNotFoundError:
+            except (FileNotFoundError, PermissionError):
                 # Don't cache the failure as the cwd can easily change to
                 # a valid directory later on.
                 return None
diff --git a/Lib/importlib/abc.py b/Lib/importlib/abc.py
index 37fef357fe2..1e47495f65f 100644
--- a/Lib/importlib/abc.py
+++ b/Lib/importlib/abc.py
@@ -13,9 +13,6 @@
     _frozen_importlib_external = _bootstrap_external
 from ._abc import Loader
 import abc
-import warnings
-
-from .resources import abc as _resources_abc
 
 
 __all__ = [
@@ -25,19 +22,6 @@
 ]
 
 
-def __getattr__(name):
-    """
-    For backwards compatibility, continue to make names
-    from _resources_abc available through this module. #93963
-    """
-    if name in _resources_abc.__all__:
-        obj = getattr(_resources_abc, name)
-        warnings._deprecated(f"{__name__}.{name}", remove=(3, 14))
-        globals()[name] = obj
-        return obj
-    raise AttributeError(f'module {__name__!r} has no attribute {name!r}')
-
-
 def _register(abstract_cls, *classes):
     for cls in classes:
         abstract_cls.register(cls)
@@ -80,10 +64,13 @@ def invalidate_caches(self):
 class ResourceLoader(Loader):
 
     """Abstract base class for loaders which can return data from their
-    back-end storage.
+    back-end storage to facilitate reading data to perform an import.
 
     This ABC represents one of the optional protocols specified by PEP 302.
 
+    For directly loading resources, use TraversableResources instead. This class
+    primarily exists for backwards compatibility with other ABCs in this module.
+
     """
 
     @abc.abstractmethod
@@ -215,6 +202,10 @@ class SourceLoader(_bootstrap_external.SourceLoader, ResourceLoader, ExecutionLo
 
     def path_mtime(self, path):
         """Return the (int) modification time for the path (str)."""
+        import warnings
+        warnings.warn('SourceLoader.path_mtime is deprecated in favour of '
+                      'SourceLoader.path_stats().',
+                      DeprecationWarning, stacklevel=2)
         if self.path_stats.__func__ is SourceLoader.path_stats:
             raise OSError
         return int(self.path_stats(path)['mtime'])
diff --git a/Lib/importlib/machinery.py b/Lib/importlib/machinery.py
index fbd30b159fb..63d726445c3 100644
--- a/Lib/importlib/machinery.py
+++ b/Lib/importlib/machinery.py
@@ -3,9 +3,11 @@
 from ._bootstrap import ModuleSpec
 from ._bootstrap import BuiltinImporter
 from ._bootstrap import FrozenImporter
-from ._bootstrap_external import (SOURCE_SUFFIXES, DEBUG_BYTECODE_SUFFIXES,
-                     OPTIMIZED_BYTECODE_SUFFIXES, BYTECODE_SUFFIXES,
-                     EXTENSION_SUFFIXES)
+from ._bootstrap_external import (
+    SOURCE_SUFFIXES, BYTECODE_SUFFIXES, EXTENSION_SUFFIXES,
+    DEBUG_BYTECODE_SUFFIXES as _DEBUG_BYTECODE_SUFFIXES,
+    OPTIMIZED_BYTECODE_SUFFIXES as _OPTIMIZED_BYTECODE_SUFFIXES
+)
 from ._bootstrap_external import WindowsRegistryFinder
 from ._bootstrap_external import PathFinder
 from ._bootstrap_external import FileFinder
@@ -19,3 +21,30 @@
 def all_suffixes():
     """Returns a list of all recognized module suffixes for this process"""
     return SOURCE_SUFFIXES + BYTECODE_SUFFIXES + EXTENSION_SUFFIXES
+
+
+__all__ = ['AppleFrameworkLoader', 'BYTECODE_SUFFIXES', 'BuiltinImporter',
+           'DEBUG_BYTECODE_SUFFIXES', 'EXTENSION_SUFFIXES',
+           'ExtensionFileLoader', 'FileFinder', 'FrozenImporter', 'ModuleSpec',
+           'NamespaceLoader', 'OPTIMIZED_BYTECODE_SUFFIXES', 'PathFinder',
+           'SOURCE_SUFFIXES', 'SourceFileLoader', 'SourcelessFileLoader',
+           'WindowsRegistryFinder', 'all_suffixes']
+
+
+def __getattr__(name):
+    import warnings
+
+    if name == 'DEBUG_BYTECODE_SUFFIXES':
+        warnings.warn('importlib.machinery.DEBUG_BYTECODE_SUFFIXES is '
+                      'deprecated; use importlib.machinery.BYTECODE_SUFFIXES '
+                      'instead.',
+                      DeprecationWarning, stacklevel=2)
+        return _DEBUG_BYTECODE_SUFFIXES
+    elif name == 'OPTIMIZED_BYTECODE_SUFFIXES':
+        warnings.warn('importlib.machinery.OPTIMIZED_BYTECODE_SUFFIXES is '
+                      'deprecated; use importlib.machinery.BYTECODE_SUFFIXES '
+                      'instead.',
+                      DeprecationWarning, stacklevel=2)
+        return _OPTIMIZED_BYTECODE_SUFFIXES
+
+    raise AttributeError(f'module {__name__!r} has no attribute {name!r}')
diff --git a/Lib/importlib/resources/_common.py b/Lib/importlib/resources/_common.py
index d9128266a2e..4e9014c45a0 100644
--- a/Lib/importlib/resources/_common.py
+++ b/Lib/importlib/resources/_common.py
@@ -77,12 +77,12 @@ def resolve(cand: Optional[Anchor]) -> types.ModuleType:
     return cast(types.ModuleType, cand)
 
 
-@resolve.register(str)  # TODO: RUSTPYTHON; manual type annotation
+@resolve.register
 def _(cand: str) -> types.ModuleType:
     return importlib.import_module(cand)
 
 
-@resolve.register(type(None))  # TODO: RUSTPYTHON; manual type annotation
+@resolve.register
 def _(cand: None) -> types.ModuleType:
     return resolve(_infer_caller().f_globals['__name__'])
 
@@ -183,7 +183,7 @@ def _(path):
 @contextlib.contextmanager
 def _temp_path(dir: tempfile.TemporaryDirectory):
     """
-    Wrap tempfile.TemporyDirectory to return a pathlib object.
+    Wrap tempfile.TemporaryDirectory to return a pathlib object.
     """
     with dir as result:
         yield pathlib.Path(result)
diff --git a/Lib/importlib/resources/_legacy.py b/Lib/importlib/resources/_legacy.py
deleted file mode 100644
index b1ea8105dad..00000000000
--- a/Lib/importlib/resources/_legacy.py
+++ /dev/null
@@ -1,120 +0,0 @@
-import functools
-import os
-import pathlib
-import types
-import warnings
-
-from typing import Union, Iterable, ContextManager, BinaryIO, TextIO, Any
-
-from . import _common
-
-Package = Union[types.ModuleType, str]
-Resource = str
-
-
-def deprecated(func):
-    @functools.wraps(func)
-    def wrapper(*args, **kwargs):
-        warnings.warn(
-            f"{func.__name__} is deprecated. Use files() instead. "
-            "Refer to https://importlib-resources.readthedocs.io"
-            "/en/latest/using.html#migrating-from-legacy for migration advice.",
-            DeprecationWarning,
-            stacklevel=2,
-        )
-        return func(*args, **kwargs)
-
-    return wrapper
-
-
-def normalize_path(path: Any) -> str:
-    """Normalize a path by ensuring it is a string.
-
-    If the resulting string contains path separators, an exception is raised.
-    """
-    str_path = str(path)
-    parent, file_name = os.path.split(str_path)
-    if parent:
-        raise ValueError(f'{path!r} must be only a file name')
-    return file_name
-
-
-@deprecated
-def open_binary(package: Package, resource: Resource) -> BinaryIO:
-    """Return a file-like object opened for binary reading of the resource."""
-    return (_common.files(package) / normalize_path(resource)).open('rb')
-
-
-@deprecated
-def read_binary(package: Package, resource: Resource) -> bytes:
-    """Return the binary contents of the resource."""
-    return (_common.files(package) / normalize_path(resource)).read_bytes()
-
-
-@deprecated
-def open_text(
-    package: Package,
-    resource: Resource,
-    encoding: str = 'utf-8',
-    errors: str = 'strict',
-) -> TextIO:
-    """Return a file-like object opened for text reading of the resource."""
-    return (_common.files(package) / normalize_path(resource)).open(
-        'r', encoding=encoding, errors=errors
-    )
-
-
-@deprecated
-def read_text(
-    package: Package,
-    resource: Resource,
-    encoding: str = 'utf-8',
-    errors: str = 'strict',
-) -> str:
-    """Return the decoded string of the resource.
-
-    The decoding-related arguments have the same semantics as those of
-    bytes.decode().
-    """
-    with open_text(package, resource, encoding, errors) as fp:
-        return fp.read()
-
-
-@deprecated
-def contents(package: Package) -> Iterable[str]:
-    """Return an iterable of entries in `package`.
-
-    Note that not all entries are resources.  Specifically, directories are
-    not considered resources.  Use `is_resource()` on each entry returned here
-    to check if it is a resource or not.
-    """
-    return [path.name for path in _common.files(package).iterdir()]
-
-
-@deprecated
-def is_resource(package: Package, name: str) -> bool:
-    """True if `name` is a resource inside `package`.
-
-    Directories are *not* resources.
-    """
-    resource = normalize_path(name)
-    return any(
-        traversable.name == resource and traversable.is_file()
-        for traversable in _common.files(package).iterdir()
-    )
-
-
-@deprecated
-def path(
-    package: Package,
-    resource: Resource,
-) -> ContextManager[pathlib.Path]:
-    """A context manager providing a file path object to the resource.
-
-    If the resource does not already exist on its own on the file system,
-    a temporary file will be created. If the file was created, the file
-    will be deleted upon exiting the context manager (no exception is
-    raised if the file was deleted prior to the context manager
-    exiting).
-    """
-    return _common.as_file(_common.files(package) / normalize_path(resource))
diff --git a/Lib/importlib/util.py b/Lib/importlib/util.py
index 284206b62f9..2b564e9b52e 100644
--- a/Lib/importlib/util.py
+++ b/Lib/importlib/util.py
@@ -5,7 +5,6 @@
 from ._bootstrap import spec_from_loader
 from ._bootstrap import _find_spec
 from ._bootstrap_external import MAGIC_NUMBER
-from ._bootstrap_external import _RAW_MAGIC_NUMBER
 from ._bootstrap_external import cache_from_source
 from ._bootstrap_external import decode_source
 from ._bootstrap_external import source_from_cache
@@ -18,7 +17,7 @@
 
 def source_hash(source_bytes):
     "Return the hash of *source_bytes* as used in hash-based pyc files."
-    return _imp.source_hash(_RAW_MAGIC_NUMBER, source_bytes)
+    return _imp.source_hash(_imp.pyc_magic_number_token, source_bytes)
 
 
 def resolve_name(name, package):
@@ -272,3 +271,9 @@ def exec_module(self, module):
         loader_state['is_loading'] = False
         module.__spec__.loader_state = loader_state
         module.__class__ = _LazyModule
+
+
+__all__ = ['LazyLoader', 'Loader', 'MAGIC_NUMBER',
+           'cache_from_source', 'decode_source', 'find_spec',
+           'module_from_spec', 'resolve_name', 'source_from_cache',
+           'source_hash', 'spec_from_file_location', 'spec_from_loader']
diff --git a/Lib/inspect.py b/Lib/inspect.py
index 385fbc686b6..3cee85f39a6 100644
--- a/Lib/inspect.py
+++ b/Lib/inspect.py
@@ -348,6 +348,7 @@ def isgenerator(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
+        gi_suspended    set to 1 when the generator is suspended at a yield point, 0 otherwise
         gi_yieldfrom    object being iterated by yield from or None
 
         __iter__()      defined to support iteration over container
diff --git a/Lib/io.py b/Lib/io.py
index f0e2fa15d5a..63ffadb1d38 100644
--- a/Lib/io.py
+++ b/Lib/io.py
@@ -46,21 +46,20 @@
            "BufferedReader", "BufferedWriter", "BufferedRWPair",
            "BufferedRandom", "TextIOBase", "TextIOWrapper",
            "UnsupportedOperation", "SEEK_SET", "SEEK_CUR", "SEEK_END",
-           "DEFAULT_BUFFER_SIZE", "text_encoding", "IncrementalNewlineDecoder"]
+           "DEFAULT_BUFFER_SIZE", "text_encoding", "IncrementalNewlineDecoder",
+           "Reader", "Writer"]
 
 
 import _io
 import abc
 
+from _collections_abc import _check_methods
 from _io import (DEFAULT_BUFFER_SIZE, BlockingIOError, UnsupportedOperation,
                  open, open_code, FileIO, BytesIO, StringIO, BufferedReader,
                  BufferedWriter, BufferedRWPair, BufferedRandom,
                  IncrementalNewlineDecoder, text_encoding, TextIOWrapper)
 
 
-# Pretend this exception was created here.
-UnsupportedOperation.__module__ = "io"
-
 # for seek()
 SEEK_SET = 0
 SEEK_CUR = 1
@@ -97,3 +96,55 @@ class TextIOBase(_io._TextIOBase, IOBase):
     pass
 else:
     RawIOBase.register(_WindowsConsoleIO)
+
+#
+# Static Typing Support
+#
+
+GenericAlias = type(list[int])
+
+
+class Reader(metaclass=abc.ABCMeta):
+    """Protocol for simple I/O reader instances.
+
+    This protocol only supports blocking I/O.
+    """
+
+    __slots__ = ()
+
+    @abc.abstractmethod
+    def read(self, size=..., /):
+        """Read data from the input stream and return it.
+
+        If *size* is specified, at most *size* items (bytes/characters) will be
+        read.
+        """
+
+    @classmethod
+    def __subclasshook__(cls, C):
+        if cls is Reader:
+            return _check_methods(C, "read")
+        return NotImplemented
+
+    __class_getitem__ = classmethod(GenericAlias)
+
+
+class Writer(metaclass=abc.ABCMeta):
+    """Protocol for simple I/O writer instances.
+
+    This protocol only supports blocking I/O.
+    """
+
+    __slots__ = ()
+
+    @abc.abstractmethod
+    def write(self, data, /):
+        """Write *data* to the output stream and return the number of items written."""
+
+    @classmethod
+    def __subclasshook__(cls, C):
+        if cls is Writer:
+            return _check_methods(C, "write")
+        return NotImplemented
+
+    __class_getitem__ = classmethod(GenericAlias)
diff --git a/Lib/linecache.py b/Lib/linecache.py
index 2b5a31b3e75..ef3b2d9136b 100644
--- a/Lib/linecache.py
+++ b/Lib/linecache.py
@@ -33,10 +33,9 @@ def getlines(filename, module_globals=None):
     """Get the lines for a Python source file from the cache.
     Update the cache if it doesn't contain an entry for this file already."""
 
-    if filename in cache:
-        entry = cache[filename]
-        if len(entry) != 1:
-            return cache[filename][2]
+    entry = cache.get(filename, None)
+    if entry is not None and len(entry) != 1:
+        return entry[2]
 
     try:
         return updatecache(filename, module_globals)
@@ -56,10 +55,9 @@ def _make_key(code):
 
 def _getlines_from_code(code):
     code_id = _make_key(code)
-    if code_id in _interactive_cache:
-        entry = _interactive_cache[code_id]
-        if len(entry) != 1:
-            return _interactive_cache[code_id][2]
+    entry = _interactive_cache.get(code_id, None)
+    if entry is not None and len(entry) != 1:
+        return entry[2]
     return []
 
 
@@ -84,12 +82,8 @@ def checkcache(filename=None):
         filenames = [filename]
 
     for filename in filenames:
-        try:
-            entry = cache[filename]
-        except KeyError:
-            continue
-
-        if len(entry) == 1:
+        entry = cache.get(filename, None)
+        if entry is None or len(entry) == 1:
             # lazy cache entry, leave it lazy.
             continue
         size, mtime, lines, fullname = entry
@@ -125,9 +119,7 @@ def updatecache(filename, module_globals=None):
         # These import can fail if the interpreter is shutting down
         return []
 
-    if filename in cache:
-        if len(cache[filename]) != 1:
-            cache.pop(filename, None)
+    entry = cache.pop(filename, None)
     if _source_unavailable(filename):
         return []
 
@@ -149,9 +141,12 @@ def updatecache(filename, module_globals=None):
 
         # Realise a lazy loader based lookup if there is one
         # otherwise try to lookup right now.
-        if lazycache(filename, module_globals):
+        lazy_entry = entry if entry is not None and len(entry) == 1 else None
+        if lazy_entry is None:
+            lazy_entry = _make_lazycache_entry(filename, module_globals)
+        if lazy_entry is not None:
             try:
-                data = cache[filename][0]()
+                data = lazy_entry[0]()
             except (ImportError, OSError):
                 pass
             else:
@@ -159,13 +154,14 @@ def updatecache(filename, module_globals=None):
                     # No luck, the PEP302 loader cannot find the source
                     # for this module.
                     return []
-                cache[filename] = (
+                entry = (
                     len(data),
                     None,
                     [line + '\n' for line in data.splitlines()],
                     fullname
                 )
-                return cache[filename][2]
+                cache[filename] = entry
+                return entry[2]
 
         # Try looking through the module search path, which is only useful
         # when handling a relative filename.
@@ -214,13 +210,20 @@ def lazycache(filename, module_globals):
         get_source method must be found, the filename must be a cacheable
         filename, and the filename must not be already cached.
     """
-    if filename in cache:
-        if len(cache[filename]) == 1:
-            return True
-        else:
-            return False
+    entry = cache.get(filename, None)
+    if entry is not None:
+        return len(entry) == 1
+
+    lazy_entry = _make_lazycache_entry(filename, module_globals)
+    if lazy_entry is not None:
+        cache[filename] = lazy_entry
+        return True
+    return False
+
+
+def _make_lazycache_entry(filename, module_globals):
     if not filename or (filename.startswith('<') and filename.endswith('>')):
-        return False
+        return None
     # Try for a __loader__, if available
     if module_globals and '__name__' in module_globals:
         spec = module_globals.get('__spec__')
@@ -233,9 +236,10 @@ def lazycache(filename, module_globals):
         if name and get_source:
             def get_lines(name=name, *args, **kwargs):
                 return get_source(name, *args, **kwargs)
-            cache[filename] = (get_lines,)
-            return True
-    return False
+            return (get_lines,)
+    return None
+
+
 
 def _register_code(code, string, name):
     entry = (len(string),
@@ -248,4 +252,5 @@ def _register_code(code, string, name):
         for const in code.co_consts:
             if isinstance(const, type(code)):
                 stack.append(const)
-        _interactive_cache[_make_key(code)] = entry
+        key = _make_key(code)
+        _interactive_cache[key] = entry
diff --git a/Lib/locale.py b/Lib/locale.py
index db6d0abb26b..dfedc6386cb 100644
--- a/Lib/locale.py
+++ b/Lib/locale.py
@@ -13,7 +13,6 @@
 import sys
 import encodings
 import encodings.aliases
-import re
 import _collections_abc
 from builtins import str as _builtin_str
 import functools
@@ -177,8 +176,7 @@ def _strip_padding(s, amount):
         amount -= 1
     return s[lpos:rpos+1]
 
-_percent_re = re.compile(r'%(?:\((?P<key>.*?)\))?'
-                         r'(?P<modifiers>[-#0-9 +*.hlL]*?)[eEfFgGdiouxXcrs%]')
+_percent_re = None
 
 def _format(percent, value, grouping=False, monetary=False, *additional):
     if additional:
@@ -217,6 +215,13 @@ def format_string(f, val, grouping=False, monetary=False):
     Grouping is applied if the third parameter is true.
     Conversion uses monetary thousands separator and grouping strings if
     forth parameter monetary is true."""
+    global _percent_re
+    if _percent_re is None:
+        import re
+
+        _percent_re = re.compile(r'%(?:\((?P<key>.*?)\))?(?P<modifiers'
+                                 r'>[-#0-9 +*.hlL]*?)[eEfFgGdiouxXcrs%]')
+
     percents = list(_percent_re.finditer(f))
     new_f = _percent_re.sub('%s', f)
 
diff --git a/Lib/mailbox.py b/Lib/mailbox.py
index b00d9e8634c..364af6bb010 100644
--- a/Lib/mailbox.py
+++ b/Lib/mailbox.py
@@ -2183,11 +2183,7 @@ def _unlock_file(f):
 
 def _create_carefully(path):
     """Create a file if it doesn't exist and open for reading and writing."""
-    fd = os.open(path, os.O_CREAT | os.O_EXCL | os.O_RDWR, 0o666)
-    try:
-        return open(path, 'rb+')
-    finally:
-        os.close(fd)
+    return open(path, 'xb+')
 
 def _create_temporary(path):
     """Create a temp file based on path and open for reading and writing."""
diff --git a/Lib/modulefinder.py b/Lib/modulefinder.py
new file mode 100644
index 00000000000..ac478ee7f51
--- /dev/null
+++ b/Lib/modulefinder.py
@@ -0,0 +1,671 @@
+"""Find modules used by a script, using introspection."""
+
+import dis
+import importlib._bootstrap_external
+import importlib.machinery
+import marshal
+import os
+import io
+import sys
+
+# Old imp constants:
+
+_SEARCH_ERROR = 0
+_PY_SOURCE = 1
+_PY_COMPILED = 2
+_C_EXTENSION = 3
+_PKG_DIRECTORY = 5
+_C_BUILTIN = 6
+_PY_FROZEN = 7
+
+# Modulefinder does a good job at simulating Python's, but it can not
+# handle __path__ modifications packages make at runtime.  Therefore there
+# is a mechanism whereby you can register extra paths in this map for a
+# package, and it will be honored.
+
+# Note this is a mapping is lists of paths.
+packagePathMap = {}
+
+# A Public interface
+def AddPackagePath(packagename, path):
+    packagePathMap.setdefault(packagename, []).append(path)
+
+replacePackageMap = {}
+
+# This ReplacePackage mechanism allows modulefinder to work around
+# situations in which a package injects itself under the name
+# of another package into sys.modules at runtime by calling
+# ReplacePackage("real_package_name", "faked_package_name")
+# before running ModuleFinder.
+
+def ReplacePackage(oldname, newname):
+    replacePackageMap[oldname] = newname
+
+
+def _find_module(name, path=None):
+    """An importlib reimplementation of imp.find_module (for our purposes)."""
+
+    # It's necessary to clear the caches for our Finder first, in case any
+    # modules are being added/deleted/modified at runtime. In particular,
+    # test_modulefinder.py changes file tree contents in a cache-breaking way:
+
+    importlib.machinery.PathFinder.invalidate_caches()
+
+    spec = importlib.machinery.PathFinder.find_spec(name, path)
+
+    if spec is None:
+        raise ImportError("No module named {name!r}".format(name=name), name=name)
+
+    # Some special cases:
+
+    if spec.loader is importlib.machinery.BuiltinImporter:
+        return None, None, ("", "", _C_BUILTIN)
+
+    if spec.loader is importlib.machinery.FrozenImporter:
+        return None, None, ("", "", _PY_FROZEN)
+
+    file_path = spec.origin
+
+    if spec.loader.is_package(name):
+        return None, os.path.dirname(file_path), ("", "", _PKG_DIRECTORY)
+
+    if isinstance(spec.loader, importlib.machinery.SourceFileLoader):
+        kind = _PY_SOURCE
+
+    elif isinstance(
+        spec.loader, (
+            importlib.machinery.ExtensionFileLoader,
+            importlib.machinery.AppleFrameworkLoader,
+        )
+    ):
+        kind = _C_EXTENSION
+
+    elif isinstance(spec.loader, importlib.machinery.SourcelessFileLoader):
+        kind = _PY_COMPILED
+
+    else:  # Should never happen.
+        return None, None, ("", "", _SEARCH_ERROR)
+
+    file = io.open_code(file_path)
+    suffix = os.path.splitext(file_path)[-1]
+
+    return file, file_path, (suffix, "rb", kind)
+
+
+class Module:
+
+    def __init__(self, name, file=None, path=None):
+        self.__name__ = name
+        self.__file__ = file
+        self.__path__ = path
+        self.__code__ = None
+        # The set of global names that are assigned to in the module.
+        # This includes those names imported through starimports of
+        # Python modules.
+        self.globalnames = {}
+        # The set of starimports this module did that could not be
+        # resolved, ie. a starimport from a non-Python module.
+        self.starimports = {}
+
+    def __repr__(self):
+        s = "Module(%r" % (self.__name__,)
+        if self.__file__ is not None:
+            s = s + ", %r" % (self.__file__,)
+        if self.__path__ is not None:
+            s = s + ", %r" % (self.__path__,)
+        s = s + ")"
+        return s
+
+class ModuleFinder:
+
+    def __init__(self, path=None, debug=0, excludes=None, replace_paths=None):
+        if path is None:
+            path = sys.path
+        self.path = path
+        self.modules = {}
+        self.badmodules = {}
+        self.debug = debug
+        self.indent = 0
+        self.excludes = excludes if excludes is not None else []
+        self.replace_paths = replace_paths if replace_paths is not None else []
+        self.processed_paths = []   # Used in debugging only
+
+    def msg(self, level, str, *args):
+        if level <= self.debug:
+            for i in range(self.indent):
+                print("   ", end=' ')
+            print(str, end=' ')
+            for arg in args:
+                print(repr(arg), end=' ')
+            print()
+
+    def msgin(self, *args):
+        level = args[0]
+        if level <= self.debug:
+            self.indent = self.indent + 1
+            self.msg(*args)
+
+    def msgout(self, *args):
+        level = args[0]
+        if level <= self.debug:
+            self.indent = self.indent - 1
+            self.msg(*args)
+
+    def run_script(self, pathname):
+        self.msg(2, "run_script", pathname)
+        with io.open_code(pathname) as fp:
+            stuff = ("", "rb", _PY_SOURCE)
+            self.load_module('__main__', fp, pathname, stuff)
+
+    def load_file(self, pathname):
+        dir, name = os.path.split(pathname)
+        name, ext = os.path.splitext(name)
+        with io.open_code(pathname) as fp:
+            stuff = (ext, "rb", _PY_SOURCE)
+            self.load_module(name, fp, pathname, stuff)
+
+    def import_hook(self, name, caller=None, fromlist=None, level=-1):
+        self.msg(3, "import_hook", name, caller, fromlist, level)
+        parent = self.determine_parent(caller, level=level)
+        q, tail = self.find_head_package(parent, name)
+        m = self.load_tail(q, tail)
+        if not fromlist:
+            return q
+        if m.__path__:
+            self.ensure_fromlist(m, fromlist)
+        return None
+
+    def determine_parent(self, caller, level=-1):
+        self.msgin(4, "determine_parent", caller, level)
+        if not caller or level == 0:
+            self.msgout(4, "determine_parent -> None")
+            return None
+        pname = caller.__name__
+        if level >= 1: # relative import
+            if caller.__path__:
+                level -= 1
+            if level == 0:
+                parent = self.modules[pname]
+                assert parent is caller
+                self.msgout(4, "determine_parent ->", parent)
+                return parent
+            if pname.count(".") < level:
+                raise ImportError("relative importpath too deep")
+            pname = ".".join(pname.split(".")[:-level])
+            parent = self.modules[pname]
+            self.msgout(4, "determine_parent ->", parent)
+            return parent
+        if caller.__path__:
+            parent = self.modules[pname]
+            assert caller is parent
+            self.msgout(4, "determine_parent ->", parent)
+            return parent
+        if '.' in pname:
+            i = pname.rfind('.')
+            pname = pname[:i]
+            parent = self.modules[pname]
+            assert parent.__name__ == pname
+            self.msgout(4, "determine_parent ->", parent)
+            return parent
+        self.msgout(4, "determine_parent -> None")
+        return None
+
+    def find_head_package(self, parent, name):
+        self.msgin(4, "find_head_package", parent, name)
+        if '.' in name:
+            i = name.find('.')
+            head = name[:i]
+            tail = name[i+1:]
+        else:
+            head = name
+            tail = ""
+        if parent:
+            qname = "%s.%s" % (parent.__name__, head)
+        else:
+            qname = head
+        q = self.import_module(head, qname, parent)
+        if q:
+            self.msgout(4, "find_head_package ->", (q, tail))
+            return q, tail
+        if parent:
+            qname = head
+            parent = None
+            q = self.import_module(head, qname, parent)
+            if q:
+                self.msgout(4, "find_head_package ->", (q, tail))
+                return q, tail
+        self.msgout(4, "raise ImportError: No module named", qname)
+        raise ImportError("No module named " + qname)
+
+    def load_tail(self, q, tail):
+        self.msgin(4, "load_tail", q, tail)
+        m = q
+        while tail:
+            i = tail.find('.')
+            if i < 0: i = len(tail)
+            head, tail = tail[:i], tail[i+1:]
+            mname = "%s.%s" % (m.__name__, head)
+            m = self.import_module(head, mname, m)
+            if not m:
+                self.msgout(4, "raise ImportError: No module named", mname)
+                raise ImportError("No module named " + mname)
+        self.msgout(4, "load_tail ->", m)
+        return m
+
+    def ensure_fromlist(self, m, fromlist, recursive=0):
+        self.msg(4, "ensure_fromlist", m, fromlist, recursive)
+        for sub in fromlist:
+            if sub == "*":
+                if not recursive:
+                    all = self.find_all_submodules(m)
+                    if all:
+                        self.ensure_fromlist(m, all, 1)
+            elif not hasattr(m, sub):
+                subname = "%s.%s" % (m.__name__, sub)
+                submod = self.import_module(sub, subname, m)
+                if not submod:
+                    raise ImportError("No module named " + subname)
+
+    def find_all_submodules(self, m):
+        if not m.__path__:
+            return
+        modules = {}
+        # 'suffixes' used to be a list hardcoded to [".py", ".pyc"].
+        # But we must also collect Python extension modules - although
+        # we cannot separate normal dlls from Python extensions.
+        suffixes = []
+        suffixes += importlib.machinery.EXTENSION_SUFFIXES[:]
+        suffixes += importlib.machinery.SOURCE_SUFFIXES[:]
+        suffixes += importlib.machinery.BYTECODE_SUFFIXES[:]
+        for dir in m.__path__:
+            try:
+                names = os.listdir(dir)
+            except OSError:
+                self.msg(2, "can't list directory", dir)
+                continue
+            for name in names:
+                mod = None
+                for suff in suffixes:
+                    n = len(suff)
+                    if name[-n:] == suff:
+                        mod = name[:-n]
+                        break
+                if mod and mod != "__init__":
+                    modules[mod] = mod
+        return modules.keys()
+
+    def import_module(self, partname, fqname, parent):
+        self.msgin(3, "import_module", partname, fqname, parent)
+        try:
+            m = self.modules[fqname]
+        except KeyError:
+            pass
+        else:
+            self.msgout(3, "import_module ->", m)
+            return m
+        if fqname in self.badmodules:
+            self.msgout(3, "import_module -> None")
+            return None
+        if parent and parent.__path__ is None:
+            self.msgout(3, "import_module -> None")
+            return None
+        try:
+            fp, pathname, stuff = self.find_module(partname,
+                                                   parent and parent.__path__, parent)
+        except ImportError:
+            self.msgout(3, "import_module ->", None)
+            return None
+
+        try:
+            m = self.load_module(fqname, fp, pathname, stuff)
+        finally:
+            if fp:
+                fp.close()
+        if parent:
+            setattr(parent, partname, m)
+        self.msgout(3, "import_module ->", m)
+        return m
+
+    def load_module(self, fqname, fp, pathname, file_info):
+        suffix, mode, type = file_info
+        self.msgin(2, "load_module", fqname, fp and "fp", pathname)
+        if type == _PKG_DIRECTORY:
+            m = self.load_package(fqname, pathname)
+            self.msgout(2, "load_module ->", m)
+            return m
+        if type == _PY_SOURCE:
+            co = compile(fp.read(), pathname, 'exec')
+        elif type == _PY_COMPILED:
+            try:
+                data = fp.read()
+                importlib._bootstrap_external._classify_pyc(data, fqname, {})
+            except ImportError as exc:
+                self.msgout(2, "raise ImportError: " + str(exc), pathname)
+                raise
+            co = marshal.loads(memoryview(data)[16:])
+        else:
+            co = None
+        m = self.add_module(fqname)
+        m.__file__ = pathname
+        if co:
+            if self.replace_paths:
+                co = self.replace_paths_in_code(co)
+            m.__code__ = co
+            self.scan_code(co, m)
+        self.msgout(2, "load_module ->", m)
+        return m
+
+    def _add_badmodule(self, name, caller):
+        if name not in self.badmodules:
+            self.badmodules[name] = {}
+        if caller:
+            self.badmodules[name][caller.__name__] = 1
+        else:
+            self.badmodules[name]["-"] = 1
+
+    def _safe_import_hook(self, name, caller, fromlist, level=-1):
+        # wrapper for self.import_hook() that won't raise ImportError
+        if name in self.badmodules:
+            self._add_badmodule(name, caller)
+            return
+        try:
+            self.import_hook(name, caller, level=level)
+        except ImportError as msg:
+            self.msg(2, "ImportError:", str(msg))
+            self._add_badmodule(name, caller)
+        except SyntaxError as msg:
+            self.msg(2, "SyntaxError:", str(msg))
+            self._add_badmodule(name, caller)
+        else:
+            if fromlist:
+                for sub in fromlist:
+                    fullname = name + "." + sub
+                    if fullname in self.badmodules:
+                        self._add_badmodule(fullname, caller)
+                        continue
+                    try:
+                        self.import_hook(name, caller, [sub], level=level)
+                    except ImportError as msg:
+                        self.msg(2, "ImportError:", str(msg))
+                        self._add_badmodule(fullname, caller)
+
+    def scan_opcodes(self, co):
+        # Scan the code, and yield 'interesting' opcode combinations
+        for name in dis._find_store_names(co):
+            yield "store", (name,)
+        for name, level, fromlist in dis._find_imports(co):
+            if level == 0:  # absolute import
+                yield "absolute_import", (fromlist, name)
+            else:  # relative import
+                yield "relative_import", (level, fromlist, name)
+
+    def scan_code(self, co, m):
+        code = co.co_code
+        scanner = self.scan_opcodes
+        for what, args in scanner(co):
+            if what == "store":
+                name, = args
+                m.globalnames[name] = 1
+            elif what == "absolute_import":
+                fromlist, name = args
+                have_star = 0
+                if fromlist is not None:
+                    if "*" in fromlist:
+                        have_star = 1
+                    fromlist = [f for f in fromlist if f != "*"]
+                self._safe_import_hook(name, m, fromlist, level=0)
+                if have_star:
+                    # We've encountered an "import *". If it is a Python module,
+                    # the code has already been parsed and we can suck out the
+                    # global names.
+                    mm = None
+                    if m.__path__:
+                        # At this point we don't know whether 'name' is a
+                        # submodule of 'm' or a global module. Let's just try
+                        # the full name first.
+                        mm = self.modules.get(m.__name__ + "." + name)
+                    if mm is None:
+                        mm = self.modules.get(name)
+                    if mm is not None:
+                        m.globalnames.update(mm.globalnames)
+                        m.starimports.update(mm.starimports)
+                        if mm.__code__ is None:
+                            m.starimports[name] = 1
+                    else:
+                        m.starimports[name] = 1
+            elif what == "relative_import":
+                level, fromlist, name = args
+                if name:
+                    self._safe_import_hook(name, m, fromlist, level=level)
+                else:
+                    parent = self.determine_parent(m, level=level)
+                    self._safe_import_hook(parent.__name__, None, fromlist, level=0)
+            else:
+                # We don't expect anything else from the generator.
+                raise RuntimeError(what)
+
+        for c in co.co_consts:
+            if isinstance(c, type(co)):
+                self.scan_code(c, m)
+
+    def load_package(self, fqname, pathname):
+        self.msgin(2, "load_package", fqname, pathname)
+        newname = replacePackageMap.get(fqname)
+        if newname:
+            fqname = newname
+        m = self.add_module(fqname)
+        m.__file__ = pathname
+        m.__path__ = [pathname]
+
+        # As per comment at top of file, simulate runtime __path__ additions.
+        m.__path__ = m.__path__ + packagePathMap.get(fqname, [])
+
+        fp, buf, stuff = self.find_module("__init__", m.__path__)
+        try:
+            self.load_module(fqname, fp, buf, stuff)
+            self.msgout(2, "load_package ->", m)
+            return m
+        finally:
+            if fp:
+                fp.close()
+
+    def add_module(self, fqname):
+        if fqname in self.modules:
+            return self.modules[fqname]
+        self.modules[fqname] = m = Module(fqname)
+        return m
+
+    def find_module(self, name, path, parent=None):
+        if parent is not None:
+            # assert path is not None
+            fullname = parent.__name__+'.'+name
+        else:
+            fullname = name
+        if fullname in self.excludes:
+            self.msgout(3, "find_module -> Excluded", fullname)
+            raise ImportError(name)
+
+        if path is None:
+            if name in sys.builtin_module_names:
+                return (None, None, ("", "", _C_BUILTIN))
+
+            path = self.path
+
+        return _find_module(name, path)
+
+    def report(self):
+        """Print a report to stdout, listing the found modules with their
+        paths, as well as modules that are missing, or seem to be missing.
+        """
+        print()
+        print("  %-25s %s" % ("Name", "File"))
+        print("  %-25s %s" % ("----", "----"))
+        # Print modules found
+        keys = sorted(self.modules.keys())
+        for key in keys:
+            m = self.modules[key]
+            if m.__path__:
+                print("P", end=' ')
+            else:
+                print("m", end=' ')
+            print("%-25s" % key, m.__file__ or "")
+
+        # Print missing modules
+        missing, maybe = self.any_missing_maybe()
+        if missing:
+            print()
+            print("Missing modules:")
+            for name in missing:
+                mods = sorted(self.badmodules[name].keys())
+                print("?", name, "imported from", ', '.join(mods))
+        # Print modules that may be missing, but then again, maybe not...
+        if maybe:
+            print()
+            print("Submodules that appear to be missing, but could also be", end=' ')
+            print("global names in the parent package:")
+            for name in maybe:
+                mods = sorted(self.badmodules[name].keys())
+                print("?", name, "imported from", ', '.join(mods))
+
+    def any_missing(self):
+        """Return a list of modules that appear to be missing. Use
+        any_missing_maybe() if you want to know which modules are
+        certain to be missing, and which *may* be missing.
+        """
+        missing, maybe = self.any_missing_maybe()
+        return missing + maybe
+
+    def any_missing_maybe(self):
+        """Return two lists, one with modules that are certainly missing
+        and one with modules that *may* be missing. The latter names could
+        either be submodules *or* just global names in the package.
+
+        The reason it can't always be determined is that it's impossible to
+        tell which names are imported when "from module import *" is done
+        with an extension module, short of actually importing it.
+        """
+        missing = []
+        maybe = []
+        for name in self.badmodules:
+            if name in self.excludes:
+                continue
+            i = name.rfind(".")
+            if i < 0:
+                missing.append(name)
+                continue
+            subname = name[i+1:]
+            pkgname = name[:i]
+            pkg = self.modules.get(pkgname)
+            if pkg is not None:
+                if pkgname in self.badmodules[name]:
+                    # The package tried to import this module itself and
+                    # failed. It's definitely missing.
+                    missing.append(name)
+                elif subname in pkg.globalnames:
+                    # It's a global in the package: definitely not missing.
+                    pass
+                elif pkg.starimports:
+                    # It could be missing, but the package did an "import *"
+                    # from a non-Python module, so we simply can't be sure.
+                    maybe.append(name)
+                else:
+                    # It's not a global in the package, the package didn't
+                    # do funny star imports, it's very likely to be missing.
+                    # The symbol could be inserted into the package from the
+                    # outside, but since that's not good style we simply list
+                    # it missing.
+                    missing.append(name)
+            else:
+                missing.append(name)
+        missing.sort()
+        maybe.sort()
+        return missing, maybe
+
+    def replace_paths_in_code(self, co):
+        new_filename = original_filename = os.path.normpath(co.co_filename)
+        for f, r in self.replace_paths:
+            if original_filename.startswith(f):
+                new_filename = r + original_filename[len(f):]
+                break
+
+        if self.debug and original_filename not in self.processed_paths:
+            if new_filename != original_filename:
+                self.msgout(2, "co_filename %r changed to %r" \
+                                    % (original_filename,new_filename,))
+            else:
+                self.msgout(2, "co_filename %r remains unchanged" \
+                                    % (original_filename,))
+            self.processed_paths.append(original_filename)
+
+        consts = list(co.co_consts)
+        for i in range(len(consts)):
+            if isinstance(consts[i], type(co)):
+                consts[i] = self.replace_paths_in_code(consts[i])
+
+        return co.replace(co_consts=tuple(consts), co_filename=new_filename)
+
+
+def test():
+    # Parse command line
+    import getopt
+    try:
+        opts, args = getopt.getopt(sys.argv[1:], "dmp:qx:")
+    except getopt.error as msg:
+        print(msg)
+        return
+
+    # Process options
+    debug = 1
+    domods = 0
+    addpath = []
+    exclude = []
+    for o, a in opts:
+        if o == '-d':
+            debug = debug + 1
+        if o == '-m':
+            domods = 1
+        if o == '-p':
+            addpath = addpath + a.split(os.pathsep)
+        if o == '-q':
+            debug = 0
+        if o == '-x':
+            exclude.append(a)
+
+    # Provide default arguments
+    if not args:
+        script = "hello.py"
+    else:
+        script = args[0]
+
+    # Set the path based on sys.path and the script directory
+    path = sys.path[:]
+    path[0] = os.path.dirname(script)
+    path = addpath + path
+    if debug > 1:
+        print("path:")
+        for item in path:
+            print("   ", repr(item))
+
+    # Create the module finder and turn its crank
+    mf = ModuleFinder(path, debug, exclude)
+    for arg in args[1:]:
+        if arg == '-m':
+            domods = 1
+            continue
+        if domods:
+            if arg[-2:] == '.*':
+                mf.import_hook(arg[:-2], None, ["*"])
+            else:
+                mf.import_hook(arg)
+        else:
+            mf.load_file(arg)
+    mf.run_script(script)
+    mf.report()
+    return mf  # for -i debugging
+
+
+if __name__ == '__main__':
+    try:
+        mf = test()
+    except KeyboardInterrupt:
+        print("\n[interrupted]")
diff --git a/Lib/multiprocessing/util.py b/Lib/multiprocessing/util.py
index b8bfea045df..4c8425064fe 100644
--- a/Lib/multiprocessing/util.py
+++ b/Lib/multiprocessing/util.py
@@ -517,15 +517,13 @@ def _flush_std_streams():
 
 def spawnv_passfds(path, args, passfds):
     import _posixsubprocess
-    import subprocess
     passfds = tuple(sorted(map(int, passfds)))
     errpipe_read, errpipe_write = os.pipe()
     try:
         return _posixsubprocess.fork_exec(
             args, [path], True, passfds, None, None,
             -1, -1, -1, -1, -1, -1, errpipe_read, errpipe_write,
-            False, False, -1, None, None, None, -1, None,
-            subprocess._USE_VFORK)
+            False, False, -1, None, None, None, -1, None)
     finally:
         os.close(errpipe_read)
         os.close(errpipe_write)
diff --git a/Lib/optparse.py b/Lib/optparse.py
index 1c450c6fcbe..38cf16d21ef 100644
--- a/Lib/optparse.py
+++ b/Lib/optparse.py
@@ -43,7 +43,7 @@
 
 __copyright__ = """
 Copyright (c) 2001-2006 Gregory P. Ward.  All rights reserved.
-Copyright (c) 2002-2006 Python Software Foundation.  All rights reserved.
+Copyright (c) 2002 Python Software Foundation.  All rights reserved.
 
 Redistribution and use in source and binary forms, with or without
 modification, are permitted provided that the following conditions are
@@ -74,7 +74,8 @@
 """
 
 import sys, os
-import textwrap
+from gettext import gettext as _, ngettext
+
 
 def _repr(self):
     return "<%s at 0x%x: %s>" % (self.__class__.__name__, id(self), self)
@@ -86,19 +87,6 @@ def _repr(self):
 #   Id: help.py 527 2006-07-23 15:21:30Z greg
 #   Id: errors.py 509 2006-04-20 00:58:24Z gward
 
-try:
-    from gettext import gettext, ngettext
-except ImportError:
-    def gettext(message):
-        return message
-
-    def ngettext(singular, plural, n):
-        if n == 1:
-            return singular
-        return plural
-
-_ = gettext
-
 
 class OptParseError (Exception):
     def __init__(self, msg):
@@ -263,6 +251,7 @@ def _format_text(self, text):
         Format a paragraph of free-form text for inclusion in the
         help output at the current indentation level.
         """
+        import textwrap
         text_width = max(self.width - self.current_indent, 11)
         indent = " "*self.current_indent
         return textwrap.fill(text,
@@ -319,6 +308,7 @@ def format_option(self, option):
             indent_first = 0
         result.append(opts)
         if option.help:
+            import textwrap
             help_text = self.expand_default(option)
             help_lines = textwrap.wrap(help_text, self.help_width)
             result.append("%*s%s\n" % (indent_first, "", help_lines[0]))
diff --git a/Lib/os.py b/Lib/os.py
index b4c9f84c36d..ac03b416390 100644
--- a/Lib/os.py
+++ b/Lib/os.py
@@ -10,7 +10,7 @@
   - os.extsep is the extension separator (always '.')
   - os.altsep is the alternate pathname separator (None or '/')
   - os.pathsep is the component separator used in $PATH etc
-  - os.linesep is the line separator in text files ('\r' or '\n' or '\r\n')
+  - os.linesep is the line separator in text files ('\n' or '\r\n')
   - os.defpath is the default search path for executables
   - os.devnull is the file path of the null device ('/dev/null', etc.)
 
@@ -64,6 +64,10 @@ def _get_exports_list(module):
         from posix import _have_functions
     except ImportError:
         pass
+    try:
+        from posix import _create_environ
+    except ImportError:
+        pass
 
     import posix
     __all__.extend(_get_exports_list(posix))
@@ -88,6 +92,10 @@ def _get_exports_list(module):
         from nt import _have_functions
     except ImportError:
         pass
+    try:
+        from nt import _create_environ
+    except ImportError:
+        pass
 
 else:
     raise ImportError('no os specific module found')
@@ -366,61 +374,45 @@ def walk(top, topdown=True, onerror=None, followlinks=False):
         # minor reason when (say) a thousand readable directories are still
         # left to visit.
         try:
-            scandir_it = scandir(top)
+            with scandir(top) as entries:
+                for entry in entries:
+                    try:
+                        if followlinks is _walk_symlinks_as_files:
+                            is_dir = entry.is_dir(follow_symlinks=False) and not entry.is_junction()
+                        else:
+                            is_dir = entry.is_dir()
+                    except OSError:
+                        # If is_dir() raises an OSError, consider the entry not to
+                        # be a directory, same behaviour as os.path.isdir().
+                        is_dir = False
+
+                    if is_dir:
+                        dirs.append(entry.name)
+                    else:
+                        nondirs.append(entry.name)
+
+                    if not topdown and is_dir:
+                        # Bottom-up: traverse into sub-directory, but exclude
+                        # symlinks to directories if followlinks is False
+                        if followlinks:
+                            walk_into = True
+                        else:
+                            try:
+                                is_symlink = entry.is_symlink()
+                            except OSError:
+                                # If is_symlink() raises an OSError, consider the
+                                # entry not to be a symbolic link, same behaviour
+                                # as os.path.islink().
+                                is_symlink = False
+                            walk_into = not is_symlink
+
+                        if walk_into:
+                            walk_dirs.append(entry.path)
         except OSError as error:
             if onerror is not None:
                 onerror(error)
             continue
 
-        cont = False
-        with scandir_it:
-            while True:
-                try:
-                    try:
-                        entry = next(scandir_it)
-                    except StopIteration:
-                        break
-                except OSError as error:
-                    if onerror is not None:
-                        onerror(error)
-                    cont = True
-                    break
-
-                try:
-                    if followlinks is _walk_symlinks_as_files:
-                        is_dir = entry.is_dir(follow_symlinks=False) and not entry.is_junction()
-                    else:
-                        is_dir = entry.is_dir()
-                except OSError:
-                    # If is_dir() raises an OSError, consider the entry not to
-                    # be a directory, same behaviour as os.path.isdir().
-                    is_dir = False
-
-                if is_dir:
-                    dirs.append(entry.name)
-                else:
-                    nondirs.append(entry.name)
-
-                if not topdown and is_dir:
-                    # Bottom-up: traverse into sub-directory, but exclude
-                    # symlinks to directories if followlinks is False
-                    if followlinks:
-                        walk_into = True
-                    else:
-                        try:
-                            is_symlink = entry.is_symlink()
-                        except OSError:
-                            # If is_symlink() raises an OSError, consider the
-                            # entry not to be a symbolic link, same behaviour
-                            # as os.path.islink().
-                            is_symlink = False
-                        walk_into = not is_symlink
-
-                    if walk_into:
-                        walk_dirs.append(entry.path)
-        if cont:
-            continue
-
         if topdown:
             # Yield before sub-directory traversal if going top down
             yield top, dirs, nondirs
@@ -774,7 +766,7 @@ def __ror__(self, other):
         new.update(self)
         return new
 
-def _createenviron():
+def _create_environ_mapping():
     if name == 'nt':
         # Where Env Var Names Must Be UPPERCASE
         def check_str(value):
@@ -804,9 +796,24 @@ def decode(value):
         encode, decode)
 
 # unicode environ
-environ = _createenviron()
-del _createenviron
+environ = _create_environ_mapping()
+del _create_environ_mapping
+
+
+if _exists("_create_environ"):
+    def reload_environ():
+        data = _create_environ()
+        if name == 'nt':
+            encodekey = environ.encodekey
+            data = {encodekey(key): value
+                    for key, value in data.items()}
+
+        # modify in-place to keep os.environb in sync
+        env_data = environ._data
+        env_data.clear()
+        env_data.update(data)
 
+    __all__.append("reload_environ")
 
 def getenv(key, default=None):
     """Get an environment variable, return None if it doesn't exist.
diff --git a/Lib/pathlib/__init__.py b/Lib/pathlib/__init__.py
index 4b3edf535a6..0d763d1f0dc 100644
--- a/Lib/pathlib/__init__.py
+++ b/Lib/pathlib/__init__.py
@@ -5,8 +5,1303 @@
 operating systems.
 """
 
-from ._abc import *
-from ._local import *
+import io
+import ntpath
+import operator
+import os
+import posixpath
+import sys
+from errno import *
+from glob import _StringGlobber, _no_recurse_symlinks
+from itertools import chain
+from stat import S_ISDIR, S_ISREG, S_ISSOCK, S_ISBLK, S_ISCHR, S_ISFIFO
+from _collections_abc import Sequence
 
-__all__ = (_abc.__all__ +
-           _local.__all__)
+try:
+    import pwd
+except ImportError:
+    pwd = None
+try:
+    import grp
+except ImportError:
+    grp = None
+
+from pathlib._os import (
+    PathInfo, DirEntryInfo,
+    ensure_different_files, ensure_distinct_paths,
+    copyfile2, copyfileobj, magic_open, copy_info,
+)
+
+
+__all__ = [
+    "UnsupportedOperation",
+    "PurePath", "PurePosixPath", "PureWindowsPath",
+    "Path", "PosixPath", "WindowsPath",
+    ]
+
+
+class UnsupportedOperation(NotImplementedError):
+    """An exception that is raised when an unsupported operation is attempted.
+    """
+    pass
+
+
+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:
+    """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 unjoined 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
+
+    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)
+        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)
+
+    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
+        return drv, root, [x for x in rel.split(sep) if x and x != '.']
+
+    @classmethod
+    def _parse_pattern(cls, pattern):
+        """Parse a glob pattern to a list of parts. This is much like
+        _parse_path, except:
+
+        - Rather than normalizing and returning the drive and root, we raise
+          NotImplementedError if either are present.
+        - If the path has no real parts, we raise ValueError.
+        - If the path ends in a slash, then a final empty part is added.
+        """
+        drv, root, rel = cls.parser.splitroot(pattern)
+        if root or drv:
+            raise NotImplementedError("Non-relative patterns are unsupported")
+        sep = cls.parser.sep
+        altsep = cls.parser.altsep
+        if altsep:
+            rel = rel.replace(altsep, sep)
+        parts = [x for x in rel.split(sep) if x and x != '.']
+        if not parts:
+            raise ValueError(f"Unacceptable pattern: {str(pattern)!r}")
+        elif rel.endswith(sep):
+            # GH-65238: preserve trailing slash in glob patterns.
+            parts.append('')
+        return parts
+
+    def as_posix(self):
+        """Return the string representation of the path with forward (/)
+        slashes."""
+        return str(self).replace(self.parser.sep, '/')
+
+    @property
+    def _raw_path(self):
+        paths = self._raw_paths
+        if len(paths) == 1:
+            return paths[0]
+        elif paths:
+            # Join path segments from the initializer.
+            return self.parser.join(*paths)
+        else:
+            return ''
+
+    @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 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('.'):
+            raise ValueError(f"Invalid suffix {suffix!r}")
+        else:
+            return self.with_name(stem + suffix)
+
+    @property
+    def stem(self):
+        """The final path component, minus its last suffix."""
+        name = self.name
+        i = name.rfind('.')
+        if i != -1:
+            stem = name[:i]
+            # Stem must contain at least one non-dot character.
+            if stem.lstrip('.'):
+                return stem
+        return name
+
+    @property
+    def suffix(self):
+        """
+        The final component's last suffix, if any.
+
+        This includes the leading period. For example: '.txt'
+        """
+        name = self.name.lstrip('.')
+        i = name.rfind('.')
+        if i != -1:
+            return name[i:]
+        return ''
+
+    @property
+    def suffixes(self):
+        """
+        A list of the final component's suffixes, if any.
+
+        These include the leading periods. For example: ['.tar', '.gz']
+        """
+        return ['.' + ext for ext in self.name.lstrip('.').split('.')[1:]]
+
+    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 hasattr(other, 'with_segments'):
+            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):
+        """Return True if the path is relative to another path or False.
+        """
+        if not hasattr(other, 'with_segments'):
+            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."""
+        import warnings
+        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._deprecated("pathlib.PurePath.is_reserved", msg, remove=(3, 15))
+        if self.parser is ntpath:
+            return self.parser.isreserved(self)
+        return False
+
+    def as_uri(self):
+        """Return the path as a URI."""
+        import warnings
+        msg = ("pathlib.PurePath.as_uri() is deprecated and scheduled "
+               "for removal in Python 3.19. Use pathlib.Path.as_uri().")
+        warnings._deprecated("pathlib.PurePath.as_uri", msg, remove=(3, 19))
+        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))
+
+    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 hasattr(pattern, 'with_segments'):
+            pattern = self.with_segments(pattern)
+        if case_sensitive is None:
+            case_sensitive = self.parser is posixpath
+
+        # 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(self) if self.parts else ''
+        pattern = str(pattern) if pattern.parts else ''
+        globber = _StringGlobber(self.parser.sep, case_sensitive, recursive=True)
+        return globber.compile(pattern)(path) is not None
+
+    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 hasattr(path_pattern, 'with_segments'):
+            path_pattern = self.with_segments(path_pattern)
+        if case_sensitive is None:
+            case_sensitive = self.parser is posixpath
+        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 = _StringGlobber(self.parser.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
+
+# 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(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__ = ('_info',)
+
+    def __new__(cls, *args, **kwargs):
+        if cls is Path:
+            cls = WindowsPath if os.name == 'nt' else PosixPath
+        return object.__new__(cls)
+
+    @property
+    def info(self):
+        """
+        A PathInfo object that exposes the file type and other file attributes
+        of this path.
+        """
+        try:
+            return self._info
+        except AttributeError:
+            self._info = PathInfo(self)
+            return self._info
+
+    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 os.lstat(self)
+
+    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.
+        """
+        if follow_symlinks:
+            return os.path.exists(self)
+        return os.path.lexists(self)
+
+    def is_dir(self, *, follow_symlinks=True):
+        """
+        Whether this path is a directory.
+        """
+        if follow_symlinks:
+            return os.path.isdir(self)
+        try:
+            return S_ISDIR(self.stat(follow_symlinks=follow_symlinks).st_mode)
+        except (OSError, ValueError):
+            return False
+
+    def is_file(self, *, follow_symlinks=True):
+        """
+        Whether this path is a regular file (also True for symlinks pointing
+        to regular files).
+        """
+        if follow_symlinks:
+            return os.path.isfile(self)
+        try:
+            return S_ISREG(self.stat(follow_symlinks=follow_symlinks).st_mode)
+        except (OSError, ValueError):
+            return False
+
+    def is_mount(self):
+        """
+        Check if this path is a mount point
+        """
+        return os.path.ismount(self)
+
+    def is_symlink(self):
+        """
+        Whether this path is a symbolic link.
+        """
+        return os.path.islink(self)
+
+    def is_junction(self):
+        """
+        Whether this path is a junction.
+        """
+        return os.path.isjunction(self)
+
+    def is_block_device(self):
+        """
+        Whether this path is a block device.
+        """
+        try:
+            return S_ISBLK(self.stat().st_mode)
+        except (OSError, ValueError):
+            return False
+
+    def is_char_device(self):
+        """
+        Whether this path is a character device.
+        """
+        try:
+            return S_ISCHR(self.stat().st_mode)
+        except (OSError, ValueError):
+            return False
+
+    def is_fifo(self):
+        """
+        Whether this path is a FIFO.
+        """
+        try:
+            return S_ISFIFO(self.stat().st_mode)
+        except (OSError, ValueError):
+            return False
+
+    def is_socket(self):
+        """
+        Whether this path is a socket.
+        """
+        try:
+            return S_ISSOCK(self.stat().st_mode)
+        except (OSError, ValueError):
+            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.
+        """
+        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', buffering=0) 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.
+        """
+        # Call io.text_encoding() here to ensure any warning is raised at an
+        # appropriate stack level.
+        encoding = io.text_encoding(encoding)
+        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.
+        """
+        # Call io.text_encoding() here to ensure any warning is raised at an
+        # appropriate stack level.
+        encoding = io.text_encoding(encoding)
+        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)
+
+    _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 _from_dir_entry(self, dir_entry, path_str):
+        path = self.with_segments(path_str)
+        path._str = path_str
+        path._info = DirEntryInfo(dir_entry)
+        return path
+
+    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:
+            entries = list(scandir_it)
+        if root_dir == '.':
+            return (self._from_dir_entry(e, e.name) for e in entries)
+        else:
+            return (self._from_dir_entry(e, e.path) for e in entries)
+
+    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 case_sensitive is None:
+            case_sensitive = self.parser is posixpath
+            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
+        parts = self._parse_pattern(pattern)
+        recursive = True if recurse_symlinks else _no_recurse_symlinks
+        globber = _StringGlobber(self.parser.sep, case_sensitive, case_pedantic, recursive)
+        select = globber.selector(parts[::-1])
+        root = str(self)
+        paths = select(self.parser.join(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)
+        pattern = self.parser.join('**', 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)
+
+    @classmethod
+    def cwd(cls):
+        """Return a new path pointing to the current working directory."""
+        cwd = os.getcwd()
+        path = cls(cwd)
+        path._str = cwd  # getcwd() returns a normalized path
+        return path
+
+    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
+    else:
+        def owner(self, *, follow_symlinks=True):
+            """
+            Return the login name of the file owner.
+            """
+            f = f"{type(self).__name__}.owner()"
+            raise UnsupportedOperation(f"{f} is unsupported on this system")
+
+    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
+    else:
+        def group(self, *, follow_symlinks=True):
+            """
+            Return the group name of the file gid.
+            """
+            f = f"{type(self).__name__}.group()"
+            raise UnsupportedOperation(f"{f} is unsupported on this system")
+
+    if hasattr(os, "readlink"):
+        def readlink(self):
+            """
+            Return the path to which the symbolic link points.
+            """
+            return self.with_segments(os.readlink(self))
+    else:
+        def readlink(self):
+            """
+            Return the path to which the symbolic link points.
+            """
+            f = f"{type(self).__name__}.readlink()"
+            raise UnsupportedOperation(f"{f} is unsupported on this system")
+
+    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 _delete(self):
+        """
+        Delete this file or directory (including all sub-directories).
+        """
+        if self.is_symlink() or self.is_junction():
+            self.unlink()
+        elif self.is_dir():
+            # Lazy import to improve module import time
+            import shutil
+            shutil.rmtree(self)
+        else:
+            self.unlink()
+
+    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)
+        if not hasattr(target, 'with_segments'):
+            target = self.with_segments(target)
+        return 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)
+        if not hasattr(target, 'with_segments'):
+            target = self.with_segments(target)
+        return target
+
+    def copy(self, target, **kwargs):
+        """
+        Recursively copy this file or directory tree to the given destination.
+        """
+        if not hasattr(target, 'with_segments'):
+            target = self.with_segments(target)
+        ensure_distinct_paths(self, target)
+        target._copy_from(self, **kwargs)
+        return target.joinpath()  # Empty join to ensure fresh metadata.
+
+    def copy_into(self, target_dir, **kwargs):
+        """
+        Copy this file or directory tree into the given existing directory.
+        """
+        name = self.name
+        if not name:
+            raise ValueError(f"{self!r} has an empty name")
+        elif hasattr(target_dir, 'with_segments'):
+            target = target_dir / name
+        else:
+            target = self.with_segments(target_dir, name)
+        return self.copy(target, **kwargs)
+
+    def _copy_from(self, source, follow_symlinks=True, preserve_metadata=False):
+        """
+        Recursively copy the given path to this path.
+        """
+        if not follow_symlinks and source.info.is_symlink():
+            self._copy_from_symlink(source, preserve_metadata)
+        elif source.info.is_dir():
+            children = source.iterdir()
+            os.mkdir(self)
+            for child in children:
+                self.joinpath(child.name)._copy_from(
+                    child, follow_symlinks, preserve_metadata)
+            if preserve_metadata:
+                copy_info(source.info, self)
+        else:
+            self._copy_from_file(source, preserve_metadata)
+
+    def _copy_from_file(self, source, preserve_metadata=False):
+        ensure_different_files(source, self)
+        with magic_open(source, 'rb') as source_f:
+            with open(self, 'wb') as target_f:
+                copyfileobj(source_f, target_f)
+        if preserve_metadata:
+            copy_info(source.info, self)
+
+    if copyfile2:
+        # Use fast OS routine for local file copying where available.
+        _copy_from_file_fallback = _copy_from_file
+        def _copy_from_file(self, source, preserve_metadata=False):
+            try:
+                source = os.fspath(source)
+            except TypeError:
+                pass
+            else:
+                copyfile2(source, str(self))
+                return
+            self._copy_from_file_fallback(source, preserve_metadata)
+
+    if os.name == 'nt':
+        # If a directory-symlink is copied *before* its target, then
+        # os.symlink() incorrectly creates a file-symlink on Windows. Avoid
+        # this by passing *target_is_dir* to os.symlink() on Windows.
+        def _copy_from_symlink(self, source, preserve_metadata=False):
+            os.symlink(str(source.readlink()), self, source.info.is_dir())
+            if preserve_metadata:
+                copy_info(source.info, self, follow_symlinks=False)
+    else:
+        def _copy_from_symlink(self, source, preserve_metadata=False):
+            os.symlink(str(source.readlink()), self)
+            if preserve_metadata:
+                copy_info(source.info, self, follow_symlinks=False)
+
+    def move(self, target):
+        """
+        Recursively move this file or directory tree to the given destination.
+        """
+        # Use os.replace() if the target is os.PathLike and on the same FS.
+        try:
+            target = self.with_segments(target)
+        except TypeError:
+            pass
+        else:
+            ensure_different_files(self, target)
+            try:
+                os.replace(self, target)
+            except OSError as err:
+                if err.errno != EXDEV:
+                    raise
+            else:
+                return target.joinpath()  # Empty join to ensure fresh metadata.
+        # Fall back to copy+delete.
+        target = self.copy(target, follow_symlinks=False, preserve_metadata=True)
+        self._delete()
+        return target
+
+    def move_into(self, target_dir):
+        """
+        Move this file or directory tree into the given existing directory.
+        """
+        name = self.name
+        if not name:
+            raise ValueError(f"{self!r} has an empty name")
+        elif hasattr(target_dir, 'with_segments'):
+            target = target_dir / name
+        else:
+            target = self.with_segments(target_dir, name)
+        return self.move(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)
+    else:
+        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.
+            """
+            f = f"{type(self).__name__}.symlink_to()"
+            raise UnsupportedOperation(f"{f} is unsupported on this system")
+
+    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)
+    else:
+        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.
+            """
+            f = f"{type(self).__name__}.hardlink_to()"
+            raise UnsupportedOperation(f"{f} is unsupported on this system")
+
+    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 home(cls):
+        """Return a new path pointing to expanduser('~').
+        """
+        homedir = os.path.expanduser("~")
+        if homedir == "~":
+            raise RuntimeError("Could not determine home directory.")
+        return cls(homedir)
+
+    def as_uri(self):
+        """Return the path as a URI."""
+        if not self.is_absolute():
+            raise ValueError("relative paths can't be expressed as file URIs")
+        from urllib.request import pathname2url
+        return pathname2url(str(self), add_scheme=True)
+
+    @classmethod
+    def from_uri(cls, uri):
+        """Return a new path from the given 'file' URI."""
+        from urllib.error import URLError
+        from urllib.request import url2pathname
+        try:
+            path = cls(url2pathname(uri, require_scheme=True))
+        except URLError as exc:
+            raise ValueError(exc.reason) from None
+        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/pathlib/_abc.py b/Lib/pathlib/_abc.py
deleted file mode 100644
index 4d24146aa53..00000000000
--- a/Lib/pathlib/_abc.py
+++ /dev/null
@@ -1,930 +0,0 @@
-"""
-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
index 0188e7c7722..58e137f2a92 100644
--- a/Lib/pathlib/_local.py
+++ b/Lib/pathlib/_local.py
@@ -1,861 +1,12 @@
-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
+"""
+This module exists so that pathlib objects pickled under Python 3.13 can be
+unpickled in 3.14+.
+"""
 
+from pathlib import *
 
 __all__ = [
+    "UnsupportedOperation",
     "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/pathlib/_os.py b/Lib/pathlib/_os.py
new file mode 100644
index 00000000000..039836941dd
--- /dev/null
+++ b/Lib/pathlib/_os.py
@@ -0,0 +1,530 @@
+"""
+Low-level OS functionality wrappers used by pathlib.
+"""
+
+from errno import *
+from io import TextIOWrapper, text_encoding
+from stat import S_ISDIR, S_ISREG, S_ISLNK, S_IMODE
+import os
+import sys
+try:
+    import fcntl
+except ImportError:
+    fcntl = None
+try:
+    import posix
+except ImportError:
+    posix = None
+try:
+    import _winapi
+except ImportError:
+    _winapi = None
+
+
+def _get_copy_blocksize(infd):
+    """Determine blocksize for fastcopying on Linux.
+    Hopefully the whole file will be copied in a single call.
+    The copying itself should be performed in a loop 'till EOF is
+    reached (0 return) so a blocksize smaller or bigger than the actual
+    file size should not make any difference, also in case the file
+    content changes while being copied.
+    """
+    try:
+        blocksize = max(os.fstat(infd).st_size, 2 ** 23)  # min 8 MiB
+    except OSError:
+        blocksize = 2 ** 27  # 128 MiB
+    # On 32-bit architectures truncate to 1 GiB to avoid OverflowError,
+    # see gh-82500.
+    if sys.maxsize < 2 ** 32:
+        blocksize = min(blocksize, 2 ** 30)
+    return blocksize
+
+
+if fcntl and hasattr(fcntl, 'FICLONE'):
+    def _ficlone(source_fd, target_fd):
+        """
+        Perform a lightweight copy of two files, where the data blocks are
+        copied only when modified. This is known as Copy on Write (CoW),
+        instantaneous copy or reflink.
+        """
+        fcntl.ioctl(target_fd, fcntl.FICLONE, source_fd)
+else:
+    _ficlone = None
+
+
+if posix and hasattr(posix, '_fcopyfile'):
+    def _fcopyfile(source_fd, target_fd):
+        """
+        Copy a regular file content using high-performance fcopyfile(3)
+        syscall (macOS).
+        """
+        posix._fcopyfile(source_fd, target_fd, posix._COPYFILE_DATA)
+else:
+    _fcopyfile = None
+
+
+if hasattr(os, 'copy_file_range'):
+    def _copy_file_range(source_fd, target_fd):
+        """
+        Copy data from one regular mmap-like fd to another by using a
+        high-performance copy_file_range(2) syscall that gives filesystems
+        an opportunity to implement the use of reflinks or server-side
+        copy.
+        This should work on Linux >= 4.5 only.
+        """
+        blocksize = _get_copy_blocksize(source_fd)
+        offset = 0
+        while True:
+            sent = os.copy_file_range(source_fd, target_fd, blocksize,
+                                      offset_dst=offset)
+            if sent == 0:
+                break  # EOF
+            offset += sent
+else:
+    _copy_file_range = None
+
+
+if hasattr(os, 'sendfile'):
+    def _sendfile(source_fd, target_fd):
+        """Copy data from one regular mmap-like fd to another by using
+        high-performance sendfile(2) syscall.
+        This should work on Linux >= 2.6.33 only.
+        """
+        blocksize = _get_copy_blocksize(source_fd)
+        offset = 0
+        while True:
+            sent = os.sendfile(target_fd, source_fd, offset, blocksize)
+            if sent == 0:
+                break  # EOF
+            offset += sent
+else:
+    _sendfile = None
+
+
+if _winapi and hasattr(_winapi, 'CopyFile2'):
+    def copyfile2(source, target):
+        """
+        Copy from one file to another using CopyFile2 (Windows only).
+        """
+        _winapi.CopyFile2(source, target, 0)
+else:
+    copyfile2 = None
+
+
+def copyfileobj(source_f, target_f):
+    """
+    Copy data from file-like object source_f to file-like object target_f.
+    """
+    try:
+        source_fd = source_f.fileno()
+        target_fd = target_f.fileno()
+    except Exception:
+        pass  # Fall through to generic code.
+    else:
+        try:
+            # Use OS copy-on-write where available.
+            if _ficlone:
+                try:
+                    _ficlone(source_fd, target_fd)
+                    return
+                except OSError as err:
+                    if err.errno not in (EBADF, EOPNOTSUPP, ETXTBSY, EXDEV):
+                        raise err
+
+            # Use OS copy where available.
+            if _fcopyfile:
+                try:
+                    _fcopyfile(source_fd, target_fd)
+                    return
+                except OSError as err:
+                    if err.errno not in (EINVAL, ENOTSUP):
+                        raise err
+            if _copy_file_range:
+                try:
+                    _copy_file_range(source_fd, target_fd)
+                    return
+                except OSError as err:
+                    if err.errno not in (ETXTBSY, EXDEV):
+                        raise err
+            if _sendfile:
+                try:
+                    _sendfile(source_fd, target_fd)
+                    return
+                except OSError as err:
+                    if err.errno != ENOTSOCK:
+                        raise err
+        except OSError as err:
+            # Produce more useful error messages.
+            err.filename = source_f.name
+            err.filename2 = target_f.name
+            raise err
+
+    # Last resort: copy with fileobj read() and write().
+    read_source = source_f.read
+    write_target = target_f.write
+    while buf := read_source(1024 * 1024):
+        write_target(buf)
+
+
+def magic_open(path, 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.
+    """
+    text = 'b' not in mode
+    if text:
+        # Call io.text_encoding() here to ensure any warning is raised at an
+        # appropriate stack level.
+        encoding = text_encoding(encoding)
+    try:
+        return open(path, mode, buffering, encoding, errors, newline)
+    except TypeError:
+        pass
+    cls = type(path)
+    mode = ''.join(sorted(c for c in mode if c not in 'bt'))
+    if text:
+        try:
+            attr = getattr(cls, f'__open_{mode}__')
+        except AttributeError:
+            pass
+        else:
+            return attr(path, buffering, encoding, errors, newline)
+    elif encoding is not None:
+        raise ValueError("binary mode doesn't take an encoding argument")
+    elif errors is not None:
+        raise ValueError("binary mode doesn't take an errors argument")
+    elif newline is not None:
+        raise ValueError("binary mode doesn't take a newline argument")
+
+    try:
+        attr = getattr(cls, f'__open_{mode}b__')
+    except AttributeError:
+        pass
+    else:
+        stream = attr(path, buffering)
+        if text:
+            stream = TextIOWrapper(stream, encoding, errors, newline)
+        return stream
+
+    raise TypeError(f"{cls.__name__} can't be opened with mode {mode!r}")
+
+
+def ensure_distinct_paths(source, target):
+    """
+    Raise OSError(EINVAL) if the other path is within this path.
+    """
+    # Note: there is no straightforward, foolproof algorithm to determine
+    # if one directory is within another (a particularly perverse example
+    # would be a single network share mounted in one location via NFS, and
+    # in another location via CIFS), so we simply checks whether the
+    # other path is lexically equal to, or within, this path.
+    if source == target:
+        err = OSError(EINVAL, "Source and target are the same path")
+    elif source in target.parents:
+        err = OSError(EINVAL, "Source path is a parent of target path")
+    else:
+        return
+    err.filename = str(source)
+    err.filename2 = str(target)
+    raise err
+
+
+def ensure_different_files(source, target):
+    """
+    Raise OSError(EINVAL) if both paths refer to the same file.
+    """
+    try:
+        source_file_id = source.info._file_id
+        target_file_id = target.info._file_id
+    except AttributeError:
+        if source != target:
+            return
+    else:
+        try:
+            if source_file_id() != target_file_id():
+                return
+        except (OSError, ValueError):
+            return
+    err = OSError(EINVAL, "Source and target are the same file")
+    err.filename = str(source)
+    err.filename2 = str(target)
+    raise err
+
+
+def copy_info(info, target, follow_symlinks=True):
+    """Copy metadata from the given PathInfo to the given local path."""
+    copy_times_ns = (
+        hasattr(info, '_access_time_ns') and
+        hasattr(info, '_mod_time_ns') and
+        (follow_symlinks or os.utime in os.supports_follow_symlinks))
+    if copy_times_ns:
+        t0 = info._access_time_ns(follow_symlinks=follow_symlinks)
+        t1 = info._mod_time_ns(follow_symlinks=follow_symlinks)
+        os.utime(target, ns=(t0, t1), follow_symlinks=follow_symlinks)
+
+    # We must copy extended attributes before the file is (potentially)
+    # chmod()'ed read-only, otherwise setxattr() will error with -EACCES.
+    copy_xattrs = (
+        hasattr(info, '_xattrs') and
+        hasattr(os, 'setxattr') and
+        (follow_symlinks or os.setxattr in os.supports_follow_symlinks))
+    if copy_xattrs:
+        xattrs = info._xattrs(follow_symlinks=follow_symlinks)
+        for attr, value in xattrs:
+            try:
+                os.setxattr(target, attr, value, follow_symlinks=follow_symlinks)
+            except OSError as e:
+                if e.errno not in (EPERM, ENOTSUP, ENODATA, EINVAL, EACCES):
+                    raise
+
+    copy_posix_permissions = (
+        hasattr(info, '_posix_permissions') and
+        (follow_symlinks or os.chmod in os.supports_follow_symlinks))
+    if copy_posix_permissions:
+        posix_permissions = info._posix_permissions(follow_symlinks=follow_symlinks)
+        try:
+            os.chmod(target, posix_permissions, follow_symlinks=follow_symlinks)
+        except NotImplementedError:
+            # if we got a NotImplementedError, it's because
+            #   * follow_symlinks=False,
+            #   * lchown() is unavailable, and
+            #   * either
+            #       * fchownat() is unavailable or
+            #       * fchownat() doesn't implement AT_SYMLINK_NOFOLLOW.
+            #         (it returned ENOSUP.)
+            # therefore we're out of options--we simply cannot chown the
+            # symlink.  give up, suppress the error.
+            # (which is what shutil always did in this circumstance.)
+            pass
+
+    copy_bsd_flags = (
+        hasattr(info, '_bsd_flags') and
+        hasattr(os, 'chflags') and
+        (follow_symlinks or os.chflags in os.supports_follow_symlinks))
+    if copy_bsd_flags:
+        bsd_flags = info._bsd_flags(follow_symlinks=follow_symlinks)
+        try:
+            os.chflags(target, bsd_flags, follow_symlinks=follow_symlinks)
+        except OSError as why:
+            if why.errno not in (EOPNOTSUPP, ENOTSUP):
+                raise
+
+
+class _PathInfoBase:
+    __slots__ = ('_path', '_stat_result', '_lstat_result')
+
+    def __init__(self, path):
+        self._path = str(path)
+
+    def __repr__(self):
+        path_type = "WindowsPath" if os.name == "nt" else "PosixPath"
+        return f"<{path_type}.info>"
+
+    def _stat(self, *, follow_symlinks=True, ignore_errors=False):
+        """Return the status as an os.stat_result, or None if stat() fails and
+        ignore_errors is true."""
+        if follow_symlinks:
+            try:
+                result = self._stat_result
+            except AttributeError:
+                pass
+            else:
+                if ignore_errors or result is not None:
+                    return result
+            try:
+                self._stat_result = os.stat(self._path)
+            except (OSError, ValueError):
+                self._stat_result = None
+                if not ignore_errors:
+                    raise
+            return self._stat_result
+        else:
+            try:
+                result = self._lstat_result
+            except AttributeError:
+                pass
+            else:
+                if ignore_errors or result is not None:
+                    return result
+            try:
+                self._lstat_result = os.lstat(self._path)
+            except (OSError, ValueError):
+                self._lstat_result = None
+                if not ignore_errors:
+                    raise
+            return self._lstat_result
+
+    def _posix_permissions(self, *, follow_symlinks=True):
+        """Return the POSIX file permissions."""
+        return S_IMODE(self._stat(follow_symlinks=follow_symlinks).st_mode)
+
+    def _file_id(self, *, follow_symlinks=True):
+        """Returns the identifier of the file."""
+        st = self._stat(follow_symlinks=follow_symlinks)
+        return st.st_dev, st.st_ino
+
+    def _access_time_ns(self, *, follow_symlinks=True):
+        """Return the access time in nanoseconds."""
+        return self._stat(follow_symlinks=follow_symlinks).st_atime_ns
+
+    def _mod_time_ns(self, *, follow_symlinks=True):
+        """Return the modify time in nanoseconds."""
+        return self._stat(follow_symlinks=follow_symlinks).st_mtime_ns
+
+    if hasattr(os.stat_result, 'st_flags'):
+        def _bsd_flags(self, *, follow_symlinks=True):
+            """Return the flags."""
+            return self._stat(follow_symlinks=follow_symlinks).st_flags
+
+    if hasattr(os, 'listxattr'):
+        def _xattrs(self, *, follow_symlinks=True):
+            """Return the xattrs as a list of (attr, value) pairs, or an empty
+            list if extended attributes aren't supported."""
+            try:
+                return [
+                    (attr, os.getxattr(self._path, attr, follow_symlinks=follow_symlinks))
+                    for attr in os.listxattr(self._path, follow_symlinks=follow_symlinks)]
+            except OSError as err:
+                if err.errno not in (EPERM, ENOTSUP, ENODATA, EINVAL, EACCES):
+                    raise
+                return []
+
+
+class _WindowsPathInfo(_PathInfoBase):
+    """Implementation of pathlib.types.PathInfo that provides status
+    information for Windows paths. Don't try to construct it yourself."""
+    __slots__ = ('_exists', '_is_dir', '_is_file', '_is_symlink')
+
+    def exists(self, *, follow_symlinks=True):
+        """Whether this path exists."""
+        if not follow_symlinks and self.is_symlink():
+            return True
+        try:
+            return self._exists
+        except AttributeError:
+            if os.path.exists(self._path):
+                self._exists = True
+                return True
+            else:
+                self._exists = self._is_dir = self._is_file = False
+                return False
+
+    def is_dir(self, *, follow_symlinks=True):
+        """Whether this path is a directory."""
+        if not follow_symlinks and self.is_symlink():
+            return False
+        try:
+            return self._is_dir
+        except AttributeError:
+            if os.path.isdir(self._path):
+                self._is_dir = self._exists = True
+                return True
+            else:
+                self._is_dir = False
+                return False
+
+    def is_file(self, *, follow_symlinks=True):
+        """Whether this path is a regular file."""
+        if not follow_symlinks and self.is_symlink():
+            return False
+        try:
+            return self._is_file
+        except AttributeError:
+            if os.path.isfile(self._path):
+                self._is_file = self._exists = True
+                return True
+            else:
+                self._is_file = False
+                return False
+
+    def is_symlink(self):
+        """Whether this path is a symbolic link."""
+        try:
+            return self._is_symlink
+        except AttributeError:
+            self._is_symlink = os.path.islink(self._path)
+            return self._is_symlink
+
+
+class _PosixPathInfo(_PathInfoBase):
+    """Implementation of pathlib.types.PathInfo that provides status
+    information for POSIX paths. Don't try to construct it yourself."""
+    __slots__ = ()
+
+    def exists(self, *, follow_symlinks=True):
+        """Whether this path exists."""
+        st = self._stat(follow_symlinks=follow_symlinks, ignore_errors=True)
+        if st is None:
+            return False
+        return True
+
+    def is_dir(self, *, follow_symlinks=True):
+        """Whether this path is a directory."""
+        st = self._stat(follow_symlinks=follow_symlinks, ignore_errors=True)
+        if st is None:
+            return False
+        return S_ISDIR(st.st_mode)
+
+    def is_file(self, *, follow_symlinks=True):
+        """Whether this path is a regular file."""
+        st = self._stat(follow_symlinks=follow_symlinks, ignore_errors=True)
+        if st is None:
+            return False
+        return S_ISREG(st.st_mode)
+
+    def is_symlink(self):
+        """Whether this path is a symbolic link."""
+        st = self._stat(follow_symlinks=False, ignore_errors=True)
+        if st is None:
+            return False
+        return S_ISLNK(st.st_mode)
+
+
+PathInfo = _WindowsPathInfo if os.name == 'nt' else _PosixPathInfo
+
+
+class DirEntryInfo(_PathInfoBase):
+    """Implementation of pathlib.types.PathInfo that provides status
+    information by querying a wrapped os.DirEntry object. Don't try to
+    construct it yourself."""
+    __slots__ = ('_entry',)
+
+    def __init__(self, entry):
+        super().__init__(entry.path)
+        self._entry = entry
+
+    def _stat(self, *, follow_symlinks=True, ignore_errors=False):
+        try:
+            return self._entry.stat(follow_symlinks=follow_symlinks)
+        except OSError:
+            if not ignore_errors:
+                raise
+            return None
+
+    def exists(self, *, follow_symlinks=True):
+        """Whether this path exists."""
+        if not follow_symlinks:
+            return True
+        return self._stat(ignore_errors=True) is not None
+
+    def is_dir(self, *, follow_symlinks=True):
+        """Whether this path is a directory."""
+        try:
+            return self._entry.is_dir(follow_symlinks=follow_symlinks)
+        except OSError:
+            return False
+
+    def is_file(self, *, follow_symlinks=True):
+        """Whether this path is a regular file."""
+        try:
+            return self._entry.is_file(follow_symlinks=follow_symlinks)
+        except OSError:
+            return False
+
+    def is_symlink(self):
+        """Whether this path is a symbolic link."""
+        try:
+            return self._entry.is_symlink()
+        except OSError:
+            return False
diff --git a/Lib/pathlib/types.py b/Lib/pathlib/types.py
new file mode 100644
index 00000000000..d8f5c34a1a7
--- /dev/null
+++ b/Lib/pathlib/types.py
@@ -0,0 +1,430 @@
+"""
+Protocols for supporting classes in pathlib.
+"""
+
+# This module also provides abstract base classes for rich path objects.
+# These ABCs are a *private* part of the Python standard library, but they're
+# made available as a PyPI package called "pathlib-abc". It's possible they'll
+# become an official part of the standard library in future.
+#
+# Three ABCs are provided -- _JoinablePath, _ReadablePath and _WritablePath
+
+
+from abc import ABC, abstractmethod
+from glob import _PathGlobber
+from io import text_encoding
+from pathlib._os import magic_open, ensure_distinct_paths, ensure_different_files, copyfileobj
+from pathlib import PurePath, Path
+from typing import Optional, Protocol, runtime_checkable
+
+
+def _explode_path(path, split):
+    """
+    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.
+    """
+    parent, name = split(path)
+    names = []
+    while path != parent:
+        names.append(name)
+        path = parent
+        parent, name = split(path)
+    return path, names
+
+
+@runtime_checkable
+class _PathParser(Protocol):
+    """Protocol 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 JoinablePath functionality. Each JoinablePath
+    subclass references its path parser via a 'parser' class attribute.
+    """
+
+    sep: str
+    altsep: Optional[str]
+    def split(self, path: str) -> tuple[str, str]: ...
+    def splitext(self, path: str) -> tuple[str, str]: ...
+    def normcase(self, path: str) -> str: ...
+
+
+@runtime_checkable
+class PathInfo(Protocol):
+    """Protocol for path info objects, which support querying the file type.
+    Methods may return cached results.
+    """
+    def exists(self, *, follow_symlinks: bool = True) -> bool: ...
+    def is_dir(self, *, follow_symlinks: bool = True) -> bool: ...
+    def is_file(self, *, follow_symlinks: bool = True) -> bool: ...
+    def is_symlink(self) -> bool: ...
+
+
+class _JoinablePath(ABC):
+    """Abstract base class for pure path objects.
+
+    This class *does not* provide several magic methods that are defined in
+    its implementation PurePath. They are: __init__, __fspath__, __bytes__,
+    __reduce__, __hash__, __eq__, __lt__, __le__, __gt__, __ge__.
+    """
+    __slots__ = ()
+
+    @property
+    @abstractmethod
+    def parser(self):
+        """Implementation of pathlib._types.Parser used for low-level path
+        parsing and manipulation.
+        """
+        raise NotImplementedError
+
+    @abstractmethod
+    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()`.
+        """
+        raise NotImplementedError
+
+    @abstractmethod
+    def __str__(self):
+        """Return the string representation of the path, suitable for
+        passing to system calls."""
+        raise NotImplementedError
+
+    @property
+    def anchor(self):
+        """The concatenation of the drive and root, or ''."""
+        return _explode_path(str(self), self.parser.split)[0]
+
+    @property
+    def name(self):
+        """The final path component, if any."""
+        return self.parser.split(str(self))[1]
+
+    @property
+    def suffix(self):
+        """
+        The final component's last suffix, if any.
+
+        This includes the leading period. For example: '.txt'
+        """
+        return self.parser.splitext(self.name)[1]
+
+    @property
+    def suffixes(self):
+        """
+        A list of the final component's suffixes, if any.
+
+        These include the leading periods. For example: ['.tar', '.gz']
+        """
+        split = self.parser.splitext
+        stem, suffix = split(self.name)
+        suffixes = []
+        while suffix:
+            suffixes.append(suffix)
+            stem, suffix = split(stem)
+        return suffixes[::-1]
+
+    @property
+    def stem(self):
+        """The final path component, minus its last suffix."""
+        return self.parser.splitext(self.name)[0]
+
+    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}")
+        path = str(self)
+        path = path.removesuffix(split(path)[1]) + name
+        return self.with_segments(path)
+
+    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('.'):
+            raise ValueError(f"Invalid suffix {suffix!r}")
+        else:
+            return self.with_name(stem + suffix)
+
+    @property
+    def parts(self):
+        """An object providing sequence-like access to the
+        components in the filesystem path."""
+        anchor, parts = _explode_path(str(self), self.parser.split)
+        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(str(self), *pathsegments)
+
+    def __truediv__(self, key):
+        try:
+            return self.with_segments(str(self), key)
+        except TypeError:
+            return NotImplemented
+
+    def __rtruediv__(self, key):
+        try:
+            return self.with_segments(key, str(self))
+        except TypeError:
+            return NotImplemented
+
+    @property
+    def parent(self):
+        """The logical parent of the path."""
+        path = str(self)
+        parent = self.parser.split(path)[0]
+        if path != parent:
+            return self.with_segments(parent)
+        return self
+
+    @property
+    def parents(self):
+        """A sequence of this path's logical parents."""
+        split = self.parser.split
+        path = str(self)
+        parent = split(path)[0]
+        parents = []
+        while path != parent:
+            parents.append(self.with_segments(parent))
+            path = parent
+            parent = split(path)[0]
+        return tuple(parents)
+
+    def full_match(self, pattern):
+        """
+        Return True if this path matches the given glob-style pattern. The
+        pattern is matched against the entire path.
+        """
+        case_sensitive = self.parser.normcase('Aa') == 'Aa'
+        globber = _PathGlobber(self.parser.sep, case_sensitive, recursive=True)
+        match = globber.compile(pattern, altsep=self.parser.altsep)
+        return match(str(self)) is not None
+
+
+class _ReadablePath(_JoinablePath):
+    """Abstract base class for readable path objects.
+
+    The Path class implements this ABC for local filesystem paths. Users may
+    create subclasses to implement readable virtual filesystem paths, such as
+    paths in archive files or on remote storage systems.
+    """
+    __slots__ = ()
+
+    @property
+    @abstractmethod
+    def info(self):
+        """
+        A PathInfo object that exposes the file type and other file attributes
+        of this path.
+        """
+        raise NotImplementedError
+
+    @abstractmethod
+    def __open_rb__(self, buffering=-1):
+        """
+        Open the file pointed to by this path for reading in binary mode and
+        return a file object, like open(mode='rb').
+        """
+        raise NotImplementedError
+
+    def read_bytes(self):
+        """
+        Open the file in bytes mode, read it, and close the file.
+        """
+        with magic_open(self, mode='rb', buffering=0) 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.
+        """
+        # Call io.text_encoding() here to ensure any warning is raised at an
+        # appropriate stack level.
+        encoding = text_encoding(encoding)
+        with magic_open(self, mode='r', encoding=encoding, errors=errors, newline=newline) as f:
+            return f.read()
+
+    @abstractmethod
+    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 NotImplementedError
+
+    def glob(self, pattern, *, recurse_symlinks=True):
+        """Iterate over this subtree and yield all existing files (of any
+        kind, including directories) matching the given relative pattern.
+        """
+        anchor, parts = _explode_path(pattern, self.parser.split)
+        if anchor:
+            raise NotImplementedError("Non-relative patterns are unsupported")
+        elif not parts:
+            raise ValueError(f"Unacceptable pattern: {pattern!r}")
+        elif not recurse_symlinks:
+            raise NotImplementedError("recurse_symlinks=False is unsupported")
+        case_sensitive = self.parser.normcase('Aa') == 'Aa'
+        globber = _PathGlobber(self.parser.sep, case_sensitive, recursive=True)
+        select = globber.selector(parts)
+        return select(self.joinpath(''))
+
+    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():
+                    if child.info.is_dir(follow_symlinks=follow_symlinks):
+                        if not top_down:
+                            paths.append(child)
+                        dirnames.append(child.name)
+                    else:
+                        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)]
+
+    @abstractmethod
+    def readlink(self):
+        """
+        Return the path to which the symbolic link points.
+        """
+        raise NotImplementedError
+
+    def copy(self, target, **kwargs):
+        """
+        Recursively copy this file or directory tree to the given destination.
+        """
+        ensure_distinct_paths(self, target)
+        target._copy_from(self, **kwargs)
+        return target.joinpath()  # Empty join to ensure fresh metadata.
+
+    def copy_into(self, target_dir, **kwargs):
+        """
+        Copy this file or directory tree into the given existing directory.
+        """
+        name = self.name
+        if not name:
+            raise ValueError(f"{self!r} has an empty name")
+        return self.copy(target_dir / name, **kwargs)
+
+
+class _WritablePath(_JoinablePath):
+    """Abstract base class for writable path objects.
+
+    The Path class implements this ABC for local filesystem paths. Users may
+    create subclasses to implement writable virtual filesystem paths, such as
+    paths in archive files or on remote storage systems.
+    """
+    __slots__ = ()
+
+    @abstractmethod
+    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 NotImplementedError
+
+    @abstractmethod
+    def mkdir(self):
+        """
+        Create a new directory at this given path.
+        """
+        raise NotImplementedError
+
+    @abstractmethod
+    def __open_wb__(self, buffering=-1):
+        """
+        Open the file pointed to by this path for writing in binary mode and
+        return a file object, like open(mode='wb').
+        """
+        raise NotImplementedError
+
+    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 magic_open(self, 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.
+        """
+        # Call io.text_encoding() here to ensure any warning is raised at an
+        # appropriate stack level.
+        encoding = text_encoding(encoding)
+        if not isinstance(data, str):
+            raise TypeError('data must be str, not %s' %
+                            data.__class__.__name__)
+        with magic_open(self, mode='w', encoding=encoding, errors=errors, newline=newline) as f:
+            return f.write(data)
+
+    def _copy_from(self, source, follow_symlinks=True):
+        """
+        Recursively copy the given path to this path.
+        """
+        stack = [(source, self)]
+        while stack:
+            src, dst = stack.pop()
+            if not follow_symlinks and src.info.is_symlink():
+                dst.symlink_to(str(src.readlink()), src.info.is_dir())
+            elif src.info.is_dir():
+                children = src.iterdir()
+                dst.mkdir()
+                for child in children:
+                    stack.append((child, dst.joinpath(child.name)))
+            else:
+                ensure_different_files(src, dst)
+                with magic_open(src, 'rb') as source_f:
+                    with magic_open(dst, 'wb') as target_f:
+                        copyfileobj(source_f, target_f)
+
+
+_JoinablePath.register(PurePath)
+_ReadablePath.register(Path)
+_WritablePath.register(Path)
diff --git a/Lib/pdb.py b/Lib/pdb.py
index bf503f1e73e..ec6cf06e58b 100755
--- a/Lib/pdb.py
+++ b/Lib/pdb.py
@@ -185,6 +185,15 @@ def __init__(self, completekey='tab', stdin=None, stdout=None, skip=None,
         self.commands_bnum = None # The breakpoint number for which we are
                                   # defining a list
 
+    def set_trace(self, frame=None, *, commands=None):
+        if frame is None:
+            frame = sys._getframe().f_back
+
+        if commands is not None:
+            self.rcLines.extend(commands)
+
+        super().set_trace(frame)
+
     def sigint_handler(self, signum, frame):
         if self.allow_kbdint:
             raise KeyboardInterrupt
diff --git a/Lib/pickle.py b/Lib/pickle.py
index 550f8675f2c..beaefae0479 100644
--- a/Lib/pickle.py
+++ b/Lib/pickle.py
@@ -26,12 +26,11 @@
 from types import FunctionType
 from copyreg import dispatch_table
 from copyreg import _extension_registry, _inverted_registry, _extension_cache
-from itertools import islice
+from itertools import batched
 from functools import partial
 import sys
 from sys import maxsize
 from struct import pack, unpack
-import re
 import io
 import codecs
 import _compat_pickle
@@ -51,7 +50,7 @@
 bytes_types = (bytes, bytearray)
 
 # These are purely informational; no code uses these.
-format_version = "4.0"                  # File format version we write
+format_version = "5.0"                  # File format version we write
 compatible_formats = ["1.0",            # Original protocol 0
                       "1.1",            # Protocol 0 with INST added
                       "1.2",            # Original protocol 1
@@ -68,7 +67,7 @@
 # The protocol we write by default.  May be less than HIGHEST_PROTOCOL.
 # Only bump this if the oldest still supported version of Python already
 # includes it.
-DEFAULT_PROTOCOL = 4
+DEFAULT_PROTOCOL = 5
 
 class PickleError(Exception):
     """A common base class for the other pickling exceptions."""
@@ -188,7 +187,7 @@ def __init__(self, value):
 NEXT_BUFFER      = b'\x97'  # push next out-of-band buffer
 READONLY_BUFFER  = b'\x98'  # make top of stack readonly
 
-__all__.extend([x for x in dir() if re.match("[A-Z][A-Z0-9_]+$", x)])
+__all__.extend(x for x in dir() if x.isupper() and not x.startswith('_'))
 
 
 class _Framer:
@@ -313,38 +312,46 @@ def load_frame(self, frame_size):
 
 # Tools used for pickling.
 
-def _getattribute(obj, name):
-    top = obj
-    for subpath in name.split('.'):
-        if subpath == '<locals>':
-            raise AttributeError("Can't get local attribute {!r} on {!r}"
-                                 .format(name, top))
-        try:
-            parent = obj
-            obj = getattr(obj, subpath)
-        except AttributeError:
-            raise AttributeError("Can't get attribute {!r} on {!r}"
-                                 .format(name, top)) from None
-    return obj, parent
+def _getattribute(obj, dotted_path):
+    for subpath in dotted_path:
+        obj = getattr(obj, subpath)
+    return obj
 
 def whichmodule(obj, name):
     """Find the module an object belong to."""
+    dotted_path = name.split('.')
     module_name = getattr(obj, '__module__', None)
-    if module_name is not None:
-        return module_name
-    # Protect the iteration by using a list copy of sys.modules against dynamic
-    # modules that trigger imports of other modules upon calls to getattr.
-    for module_name, module in sys.modules.copy().items():
-        if (module_name == '__main__'
-            or module_name == '__mp_main__'  # bpo-42406
-            or module is None):
-            continue
-        try:
-            if _getattribute(module, name)[0] is obj:
-                return module_name
-        except AttributeError:
-            pass
-    return '__main__'
+    if '<locals>' in dotted_path:
+        raise PicklingError(f"Can't pickle local object {obj!r}")
+    if module_name is None:
+        # Protect the iteration by using a list copy of sys.modules against dynamic
+        # modules that trigger imports of other modules upon calls to getattr.
+        for module_name, module in sys.modules.copy().items():
+            if (module_name == '__main__'
+                or module_name == '__mp_main__'  # bpo-42406
+                or module is None):
+                continue
+            try:
+                if _getattribute(module, dotted_path) is obj:
+                    return module_name
+            except AttributeError:
+                pass
+        module_name = '__main__'
+
+    try:
+        __import__(module_name, level=0)
+        module = sys.modules[module_name]
+    except (ImportError, ValueError, KeyError) as exc:
+        raise PicklingError(f"Can't pickle {obj!r}: {exc!s}")
+    try:
+        if _getattribute(module, dotted_path) is obj:
+            return module_name
+    except AttributeError:
+        raise PicklingError(f"Can't pickle {obj!r}: "
+                            f"it's not found as {module_name}.{name}")
+
+    raise PicklingError(
+        f"Can't pickle {obj!r}: it's not the same object as {module_name}.{name}")
 
 def encode_long(x):
     r"""Encode a long to a two's complement little-endian binary string.
@@ -396,6 +403,13 @@ def decode_long(data):
     """
     return int.from_bytes(data, byteorder='little', signed=True)
 
+def _T(obj):
+    cls = type(obj)
+    module = cls.__module__
+    if module in (None, 'builtins', '__main__'):
+        return cls.__qualname__
+    return f'{module}.{cls.__qualname__}'
+
 
 _NoValue = object()
 
@@ -409,7 +423,7 @@ def __init__(self, file, protocol=None, *, fix_imports=True,
 
         The optional *protocol* argument tells the pickler to use the
         given protocol; supported protocols are 0, 1, 2, 3, 4 and 5.
-        The default protocol is 4. It was introduced in Python 3.4, and
+        The default protocol is 5. It was introduced in Python 3.8, and
         is incompatible with previous versions.
 
         Specifying a negative protocol version selects the highest
@@ -579,26 +593,29 @@ def save(self, obj, save_persistent_id=True):
                     if reduce is not _NoValue:
                         rv = reduce()
                     else:
-                        raise PicklingError("Can't pickle %r object: %r" %
-                                            (t.__name__, obj))
+                        raise PicklingError(f"Can't pickle {_T(t)} object")
 
         # Check for string returned by reduce(), meaning "save as global"
         if isinstance(rv, str):
             self.save_global(obj, rv)
             return
 
-        # Assert that reduce() returned a tuple
-        if not isinstance(rv, tuple):
-            raise PicklingError("%s must return string or tuple" % reduce)
-
-        # Assert that it returned an appropriately sized tuple
-        l = len(rv)
-        if not (2 <= l <= 6):
-            raise PicklingError("Tuple returned by %s must have "
-                                "two to six elements" % reduce)
-
-        # Save the reduce() output and finally memoize the object
-        self.save_reduce(obj=obj, *rv)
+        try:
+            # Assert that reduce() returned a tuple
+            if not isinstance(rv, tuple):
+                raise PicklingError(f'__reduce__ must return a string or tuple, not {_T(rv)}')
+
+            # Assert that it returned an appropriately sized tuple
+            l = len(rv)
+            if not (2 <= l <= 6):
+                raise PicklingError("tuple returned by __reduce__ "
+                                    "must contain 2 through 6 elements")
+
+            # Save the reduce() output and finally memoize the object
+            self.save_reduce(obj=obj, *rv)
+        except BaseException as exc:
+            exc.add_note(f'when serializing {_T(obj)} object')
+            raise
 
     def persistent_id(self, obj):
         # This exists so a subclass can override it
@@ -620,10 +637,12 @@ def save_reduce(self, func, args, state=None, listitems=None,
                     dictitems=None, state_setter=None, *, obj=None):
         # This API is called by some subclasses
 
-        if not isinstance(args, tuple):
-            raise PicklingError("args from save_reduce() must be a tuple")
         if not callable(func):
-            raise PicklingError("func from save_reduce() must be callable")
+            raise PicklingError(f"first item of the tuple returned by __reduce__ "
+                                f"must be callable, not {_T(func)}")
+        if not isinstance(args, tuple):
+            raise PicklingError(f"second item of the tuple returned by __reduce__ "
+                                f"must be a tuple, not {_T(args)}")
 
         save = self.save
         write = self.write
@@ -632,19 +651,30 @@ def save_reduce(self, func, args, state=None, listitems=None,
         if self.proto >= 2 and func_name == "__newobj_ex__":
             cls, args, kwargs = args
             if not hasattr(cls, "__new__"):
-                raise PicklingError("args[0] from {} args has no __new__"
-                                    .format(func_name))
+                raise PicklingError("first argument to __newobj_ex__() has no __new__")
             if obj is not None and cls is not obj.__class__:
-                raise PicklingError("args[0] from {} args has the wrong class"
-                                    .format(func_name))
+                raise PicklingError(f"first argument to __newobj_ex__() "
+                                    f"must be {obj.__class__!r}, not {cls!r}")
             if self.proto >= 4:
-                save(cls)
-                save(args)
-                save(kwargs)
+                try:
+                    save(cls)
+                except BaseException as exc:
+                    exc.add_note(f'when serializing {_T(obj)} class')
+                    raise
+                try:
+                    save(args)
+                    save(kwargs)
+                except BaseException as exc:
+                    exc.add_note(f'when serializing {_T(obj)} __new__ arguments')
+                    raise
                 write(NEWOBJ_EX)
             else:
                 func = partial(cls.__new__, cls, *args, **kwargs)
-                save(func)
+                try:
+                    save(func)
+                except BaseException as exc:
+                    exc.add_note(f'when serializing {_T(obj)} reconstructor')
+                    raise
                 save(())
                 write(REDUCE)
         elif self.proto >= 2 and func_name == "__newobj__":
@@ -676,18 +706,33 @@ def save_reduce(self, func, args, state=None, listitems=None,
             # Python 2.2).
             cls = args[0]
             if not hasattr(cls, "__new__"):
-                raise PicklingError(
-                    "args[0] from __newobj__ args has no __new__")
+                raise PicklingError("first argument to __newobj__() has no __new__")
             if obj is not None and cls is not obj.__class__:
-                raise PicklingError(
-                    "args[0] from __newobj__ args has the wrong class")
+                raise PicklingError(f"first argument to __newobj__() "
+                                    f"must be {obj.__class__!r}, not {cls!r}")
             args = args[1:]
-            save(cls)
-            save(args)
+            try:
+                save(cls)
+            except BaseException as exc:
+                exc.add_note(f'when serializing {_T(obj)} class')
+                raise
+            try:
+                save(args)
+            except BaseException as exc:
+                exc.add_note(f'when serializing {_T(obj)} __new__ arguments')
+                raise
             write(NEWOBJ)
         else:
-            save(func)
-            save(args)
+            try:
+                save(func)
+            except BaseException as exc:
+                exc.add_note(f'when serializing {_T(obj)} reconstructor')
+                raise
+            try:
+                save(args)
+            except BaseException as exc:
+                exc.add_note(f'when serializing {_T(obj)} reconstructor arguments')
+                raise
             write(REDUCE)
 
         if obj is not None:
@@ -705,23 +750,35 @@ def save_reduce(self, func, args, state=None, listitems=None,
         # items and dict items (as (key, value) tuples), or None.
 
         if listitems is not None:
-            self._batch_appends(listitems)
+            self._batch_appends(listitems, obj)
 
         if dictitems is not None:
-            self._batch_setitems(dictitems)
+            self._batch_setitems(dictitems, obj)
 
         if state is not None:
             if state_setter is None:
-                save(state)
+                try:
+                    save(state)
+                except BaseException as exc:
+                    exc.add_note(f'when serializing {_T(obj)} state')
+                    raise
                 write(BUILD)
             else:
                 # If a state_setter is specified, call it instead of load_build
                 # to update obj's with its previous state.
                 # First, push state_setter and its tuple of expected arguments
                 # (obj, state) onto the stack.
-                save(state_setter)
+                try:
+                    save(state_setter)
+                except BaseException as exc:
+                    exc.add_note(f'when serializing {_T(obj)} state setter')
+                    raise
                 save(obj)  # simple BINGET opcode as obj is already memoized.
-                save(state)
+                try:
+                    save(state)
+                except BaseException as exc:
+                    exc.add_note(f'when serializing {_T(obj)} state')
+                    raise
                 write(TUPLE2)
                 # Trigger a state_setter(obj, state) function call.
                 write(REDUCE)
@@ -901,8 +958,12 @@ def save_tuple(self, obj):
         save = self.save
         memo = self.memo
         if n <= 3 and self.proto >= 2:
-            for element in obj:
-                save(element)
+            for i, element in enumerate(obj):
+                try:
+                    save(element)
+                except BaseException as exc:
+                    exc.add_note(f'when serializing {_T(obj)} item {i}')
+                    raise
             # Subtle.  Same as in the big comment below.
             if id(obj) in memo:
                 get = self.get(memo[id(obj)][0])
@@ -916,8 +977,12 @@ def save_tuple(self, obj):
         # has more than 3 elements.
         write = self.write
         write(MARK)
-        for element in obj:
-            save(element)
+        for i, element in enumerate(obj):
+            try:
+                save(element)
+            except BaseException as exc:
+                exc.add_note(f'when serializing {_T(obj)} item {i}')
+                raise
 
         if id(obj) in memo:
             # Subtle.  d was not in memo when we entered save_tuple(), so
@@ -947,38 +1012,47 @@ def save_list(self, obj):
             self.write(MARK + LIST)
 
         self.memoize(obj)
-        self._batch_appends(obj)
+        self._batch_appends(obj, obj)
 
     dispatch[list] = save_list
 
     _BATCHSIZE = 1000
 
-    def _batch_appends(self, items):
+    def _batch_appends(self, items, obj):
         # Helper to batch up APPENDS sequences
         save = self.save
         write = self.write
 
         if not self.bin:
-            for x in items:
-                save(x)
+            for i, x in enumerate(items):
+                try:
+                    save(x)
+                except BaseException as exc:
+                    exc.add_note(f'when serializing {_T(obj)} item {i}')
+                    raise
                 write(APPEND)
             return
 
-        it = iter(items)
-        while True:
-            tmp = list(islice(it, self._BATCHSIZE))
-            n = len(tmp)
-            if n > 1:
+        start = 0
+        for batch in batched(items, self._BATCHSIZE):
+            batch_len = len(batch)
+            if batch_len != 1:
                 write(MARK)
-                for x in tmp:
-                    save(x)
+                for i, x in enumerate(batch, start):
+                    try:
+                        save(x)
+                    except BaseException as exc:
+                        exc.add_note(f'when serializing {_T(obj)} item {i}')
+                        raise
                 write(APPENDS)
-            elif n:
-                save(tmp[0])
+            else:
+                try:
+                    save(batch[0])
+                except BaseException as exc:
+                    exc.add_note(f'when serializing {_T(obj)} item {start}')
+                    raise
                 write(APPEND)
-            # else tmp is empty, and we're done
-            if n < self._BATCHSIZE:
-                return
+            start += batch_len
 
     def save_dict(self, obj):
         if self.bin:
@@ -987,11 +1061,11 @@ def save_dict(self, obj):
             self.write(MARK + DICT)
 
         self.memoize(obj)
-        self._batch_setitems(obj.items())
+        self._batch_setitems(obj.items(), obj)
 
     dispatch[dict] = save_dict
 
-    def _batch_setitems(self, items):
+    def _batch_setitems(self, items, obj):
         # Helper to batch up SETITEMS sequences; proto >= 1 only
         save = self.save
         write = self.write
@@ -999,28 +1073,34 @@ def _batch_setitems(self, items):
         if not self.bin:
             for k, v in items:
                 save(k)
-                save(v)
+                try:
+                    save(v)
+                except BaseException as exc:
+                    exc.add_note(f'when serializing {_T(obj)} item {k!r}')
+                    raise
                 write(SETITEM)
             return
 
-        it = iter(items)
-        while True:
-            tmp = list(islice(it, self._BATCHSIZE))
-            n = len(tmp)
-            if n > 1:
+        for batch in batched(items, self._BATCHSIZE):
+            if len(batch) != 1:
                 write(MARK)
-                for k, v in tmp:
+                for k, v in batch:
                     save(k)
-                    save(v)
+                    try:
+                        save(v)
+                    except BaseException as exc:
+                        exc.add_note(f'when serializing {_T(obj)} item {k!r}')
+                        raise
                 write(SETITEMS)
-            elif n:
-                k, v = tmp[0]
+            else:
+                k, v = batch[0]
                 save(k)
-                save(v)
+                try:
+                    save(v)
+                except BaseException as exc:
+                    exc.add_note(f'when serializing {_T(obj)} item {k!r}')
+                    raise
                 write(SETITEM)
-            # else tmp is empty, and we're done
-            if n < self._BATCHSIZE:
-                return
 
     def save_set(self, obj):
         save = self.save
@@ -1033,17 +1113,15 @@ def save_set(self, obj):
         write(EMPTY_SET)
         self.memoize(obj)
 
-        it = iter(obj)
-        while True:
-            batch = list(islice(it, self._BATCHSIZE))
-            n = len(batch)
-            if n > 0:
-                write(MARK)
+        for batch in batched(obj, self._BATCHSIZE):
+            write(MARK)
+            try:
                 for item in batch:
                     save(item)
-                write(ADDITEMS)
-            if n < self._BATCHSIZE:
-                return
+            except BaseException as exc:
+                exc.add_note(f'when serializing {_T(obj)} element')
+                raise
+            write(ADDITEMS)
     dispatch[set] = save_set
 
     def save_frozenset(self, obj):
@@ -1055,8 +1133,12 @@ def save_frozenset(self, obj):
             return
 
         write(MARK)
-        for item in obj:
-            save(item)
+        try:
+            for item in obj:
+                save(item)
+        except BaseException as exc:
+            exc.add_note(f'when serializing {_T(obj)} element')
+            raise
 
         if id(obj) in self.memo:
             # If the object is already in the memo, this means it is
@@ -1075,24 +1157,10 @@ def save_global(self, obj, name=None):
 
         if name is None:
             name = getattr(obj, '__qualname__', None)
-        if name is None:
-            name = obj.__name__
+            if name is None:
+                name = obj.__name__
 
         module_name = whichmodule(obj, name)
-        try:
-            __import__(module_name, level=0)
-            module = sys.modules[module_name]
-            obj2, parent = _getattribute(module, name)
-        except (ImportError, KeyError, AttributeError):
-            raise PicklingError(
-                "Can't pickle %r: it's not found as %s.%s" %
-                (obj, module_name, name)) from None
-        else:
-            if obj2 is not obj:
-                raise PicklingError(
-                    "Can't pickle %r: it's not the same object as %s.%s" %
-                    (obj, module_name, name))
-
         if self.proto >= 2:
             code = _extension_registry.get((module_name, name), _NoValue)
             if code is not _NoValue:
@@ -1109,10 +1177,7 @@ def save_global(self, obj, name=None):
                 else:
                     write(EXT4 + pack("<i", code))
                 return
-        lastname = name.rpartition('.')[2]
-        if parent is module:
-            name = lastname
-        # Non-ASCII identifiers are supported only with protocols >= 3.
+
         if self.proto >= 4:
             self.save(module_name)
             self.save(name)
@@ -1144,8 +1209,7 @@ def save_global(self, obj, name=None):
     def _save_toplevel_by_name(self, module_name, name):
         if self.proto >= 3:
             # Non-ASCII identifiers are supported only with protocols >= 3.
-            self.write(GLOBAL + bytes(module_name, "utf-8") + b'\n' +
-                       bytes(name, "utf-8") + b'\n')
+            encoding = "utf-8"
         else:
             if self.fix_imports:
                 r_name_mapping = _compat_pickle.REVERSE_NAME_MAPPING
@@ -1154,13 +1218,19 @@ def _save_toplevel_by_name(self, module_name, name):
                     module_name, name = r_name_mapping[(module_name, name)]
                 elif module_name in r_import_mapping:
                     module_name = r_import_mapping[module_name]
-            try:
-                self.write(GLOBAL + bytes(module_name, "ascii") + b'\n' +
-                           bytes(name, "ascii") + b'\n')
-            except UnicodeEncodeError:
-                raise PicklingError(
-                    "can't pickle global identifier '%s.%s' using "
-                    "pickle protocol %i" % (module_name, name, self.proto)) from None
+            encoding = "ascii"
+        try:
+            self.write(GLOBAL + bytes(module_name, encoding) + b'\n')
+        except UnicodeEncodeError:
+            raise PicklingError(
+                f"can't pickle module identifier {module_name!r} using "
+                f"pickle protocol {self.proto}")
+        try:
+            self.write(bytes(name, encoding) + b'\n')
+        except UnicodeEncodeError:
+            raise PicklingError(
+                f"can't pickle global identifier {name!r} using "
+                f"pickle protocol {self.proto}")
 
     def save_type(self, obj):
         if obj is type(None):
@@ -1316,7 +1386,7 @@ def load_int(self):
         elif data == TRUE[1:]:
             val = True
         else:
-            val = int(data, 0)
+            val = int(data)
         self.append(val)
     dispatch[INT[0]] = load_int
 
@@ -1336,7 +1406,7 @@ def load_long(self):
         val = self.readline()[:-1]
         if val and val[-1] == b'L'[0]:
             val = val[:-1]
-        self.append(int(val, 0))
+        self.append(int(val))
     dispatch[LONG[0]] = load_long
 
     def load_long1(self):
@@ -1620,8 +1690,13 @@ def find_class(self, module, name):
             elif module in _compat_pickle.IMPORT_MAPPING:
                 module = _compat_pickle.IMPORT_MAPPING[module]
         __import__(module, level=0)
-        if self.proto >= 4:
-            return _getattribute(sys.modules[module], name)[0]
+        if self.proto >= 4 and '.' in name:
+            dotted_path = name.split('.')
+            try:
+                return _getattribute(sys.modules[module], dotted_path)
+            except AttributeError:
+                raise AttributeError(
+                    f"Can't resolve path {name!r} on module {module!r}")
         else:
             return getattr(sys.modules[module], name)
 
@@ -1831,36 +1906,26 @@ def _loads(s, /, *, fix_imports=True, encoding="ASCII", errors="strict",
     Pickler, Unpickler = _Pickler, _Unpickler
     dump, dumps, load, loads = _dump, _dumps, _load, _loads
 
-# Doctest
-def _test():
-    import doctest
-    return doctest.testmod()
 
-if __name__ == "__main__":
+def _main(args=None):
     import argparse
+    import pprint
     parser = argparse.ArgumentParser(
-        description='display contents of the pickle files')
+        description='display contents of the pickle files',
+        color=True,
+    )
     parser.add_argument(
         'pickle_file',
-        nargs='*', help='the pickle file')
-    parser.add_argument(
-        '-t', '--test', action='store_true',
-        help='run self-test suite')
-    parser.add_argument(
-        '-v', action='store_true',
-        help='run verbosely; only affects self-test run')
-    args = parser.parse_args()
-    if args.test:
-        _test()
-    else:
-        if not args.pickle_file:
-            parser.print_help()
+        nargs='+', help='the pickle file')
+    args = parser.parse_args(args)
+    for fn in args.pickle_file:
+        if fn == '-':
+            obj = load(sys.stdin.buffer)
         else:
-            import pprint
-            for fn in args.pickle_file:
-                if fn == '-':
-                    obj = load(sys.stdin.buffer)
-                else:
-                    with open(fn, 'rb') as f:
-                        obj = load(f)
-                pprint.pprint(obj)
+            with open(fn, 'rb') as f:
+                obj = load(f)
+        pprint.pprint(obj)
+
+
+if __name__ == "__main__":
+    _main()
diff --git a/Lib/pickletools.py b/Lib/pickletools.py
index 33a51492ea9..254b6c7fcc9 100644
--- a/Lib/pickletools.py
+++ b/Lib/pickletools.py
@@ -348,7 +348,7 @@ def read_stringnl(f, decode=True, stripquotes=True, *, encoding='latin-1'):
         for q in (b'"', b"'"):
             if data.startswith(q):
                 if not data.endswith(q):
-                    raise ValueError("strinq quote %r not found at both "
+                    raise ValueError("string quote %r not found at both "
                                      "ends of %r" % (q, data))
                 data = data[1:-1]
                 break
@@ -2429,8 +2429,6 @@ def dis(pickle, out=None, memo=None, indentlevel=4, annotate=0):
     + A memo entry isn't referenced before it's defined.
 
     + The markobject isn't stored in the memo.
-
-    + A memo entry isn't redefined.
     """
 
     # Most of the hair here is for sanity checks, but most of it is needed
@@ -2484,7 +2482,7 @@ def dis(pickle, out=None, memo=None, indentlevel=4, annotate=0):
                     assert opcode.name == "POP"
                     numtopop = 0
             else:
-                errormsg = markmsg = "no MARK exists on stack"
+                errormsg = "no MARK exists on stack"
 
         # Check for correct memo usage.
         if opcode.name in ("PUT", "BINPUT", "LONG_BINPUT", "MEMOIZE"):
@@ -2494,9 +2492,7 @@ def dis(pickle, out=None, memo=None, indentlevel=4, annotate=0):
             else:
                 assert arg is not None
                 memo_idx = arg
-            if memo_idx in memo:
-                errormsg = "memo key %r already defined" % arg
-            elif not stack:
+            if not stack:
                 errormsg = "stack is empty -- can't store into memo"
             elif stack[-1] is markobject:
                 errormsg = "can't store markobject in the memo"
@@ -2842,17 +2838,16 @@ def __init__(self, value):
             'disassembler_memo_test': _memo_test,
            }
 
-def _test():
-    import doctest
-    return doctest.testmod()
 
 if __name__ == "__main__":
     import argparse
     parser = argparse.ArgumentParser(
-        description='disassemble one or more pickle files')
+        description='disassemble one or more pickle files',
+        color=True,
+    )
     parser.add_argument(
         'pickle_file',
-        nargs='*', help='the pickle file')
+        nargs='+', help='the pickle file')
     parser.add_argument(
         '-o', '--output',
         help='the file where the output should be written')
@@ -2869,36 +2864,24 @@ def _test():
         '-p', '--preamble', default="==> {name} <==",
         help='if more than one pickle file is specified, print this before'
         ' each disassembly')
-    parser.add_argument(
-        '-t', '--test', action='store_true',
-        help='run self-test suite')
-    parser.add_argument(
-        '-v', action='store_true',
-        help='run verbosely; only affects self-test run')
     args = parser.parse_args()
-    if args.test:
-        _test()
+    annotate = 30 if args.annotate else 0
+    memo = {} if args.memo else None
+    if args.output is None:
+        output = sys.stdout
     else:
-        if not args.pickle_file:
-            parser.print_help()
-        else:
-            annotate = 30 if args.annotate else 0
-            memo = {} if args.memo else None
-            if args.output is None:
-                output = sys.stdout
+        output = open(args.output, 'w')
+    try:
+        for arg in args.pickle_file:
+            if len(args.pickle_file) > 1:
+                name = '<stdin>' if arg == '-' else arg
+                preamble = args.preamble.format(name=name)
+                output.write(preamble + '\n')
+            if arg == '-':
+                dis(sys.stdin.buffer, output, memo, args.indentlevel, annotate)
             else:
-                output = open(args.output, 'w')
-            try:
-                for arg in args.pickle_file:
-                    if len(args.pickle_file) > 1:
-                        name = '<stdin>' if arg == '-' else arg
-                        preamble = args.preamble.format(name=name)
-                        output.write(preamble + '\n')
-                    if arg == '-':
-                        dis(sys.stdin.buffer, output, memo, args.indentlevel, annotate)
-                    else:
-                        with open(arg, 'rb') as f:
-                            dis(f, output, memo, args.indentlevel, annotate)
-            finally:
-                if output is not sys.stdout:
-                    output.close()
+                with open(arg, 'rb') as f:
+                    dis(f, output, memo, args.indentlevel, annotate)
+    finally:
+        if output is not sys.stdout:
+            output.close()
diff --git a/Lib/pkgutil.py b/Lib/pkgutil.py
index dccbec52aa7..8772a66791a 100644
--- a/Lib/pkgutil.py
+++ b/Lib/pkgutil.py
@@ -8,11 +8,9 @@
 import os
 import os.path
 import sys
-from types import ModuleType
-import warnings
 
 __all__ = [
-    'get_importer', 'iter_importers', 'get_loader', 'find_loader',
+    'get_importer', 'iter_importers',
     'walk_packages', 'iter_modules', 'get_data',
     'read_code', 'extend_path',
     'ModuleInfo',
@@ -263,59 +261,6 @@ def iter_importers(fullname=""):
         yield get_importer(item)
 
 
-def get_loader(module_or_name):
-    """Get a "loader" object for module_or_name
-
-    Returns None if the module cannot be found or imported.
-    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:
-            return None
-    if isinstance(module_or_name, ModuleType):
-        module = module_or_name
-        loader = getattr(module, '__loader__', None)
-        if loader is not None:
-            return loader
-        if getattr(module, '__spec__', None) is None:
-            return None
-        fullname = module.__name__
-    else:
-        fullname = module_or_name
-    return find_loader(fullname)
-
-
-def find_loader(fullname):
-    """Find a "loader" object for fullname
-
-    This is a backwards compatibility wrapper around
-    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)
-    try:
-        spec = importlib.util.find_spec(fullname)
-    except (ImportError, AttributeError, TypeError, ValueError) as ex:
-        # This hack fixes an impedance mismatch between pkgutil and
-        # importlib, where the latter raises other errors for cases where
-        # pkgutil previously raised ImportError
-        msg = "Error while finding loader for {!r} ({}: {})"
-        raise ImportError(msg.format(fullname, type(ex), ex)) from ex
-    return spec.loader if spec is not None else None
-
-
 def extend_path(path, name):
     """Extend a package's path.
 
diff --git a/Lib/poplib.py b/Lib/poplib.py
new file mode 100644
index 00000000000..4469bff44b4
--- /dev/null
+++ b/Lib/poplib.py
@@ -0,0 +1,477 @@
+"""A POP3 client class.
+
+Based on the J. Myers POP3 draft, Jan. 96
+"""
+
+# Author: David Ascher <david_ascher@brown.edu>
+#         [heavily stealing from nntplib.py]
+# Updated: Piers Lauder <piers@cs.su.oz.au> [Jul '97]
+# String method conversion and test jig improvements by ESR, February 2001.
+# Added the POP3_SSL class. Methods loosely based on IMAP_SSL. Hector Urtubia <urtubia@mrbook.org> Aug 2003
+
+# Example (see the test function at the end of this file)
+
+# Imports
+
+import errno
+import re
+import socket
+import sys
+
+try:
+    import ssl
+    HAVE_SSL = True
+except ImportError:
+    HAVE_SSL = False
+
+__all__ = ["POP3","error_proto"]
+
+# Exception raised when an error or invalid response is received:
+
+class error_proto(Exception): pass
+
+# Standard Port
+POP3_PORT = 110
+
+# POP SSL PORT
+POP3_SSL_PORT = 995
+
+# Line terminators (we always output CRLF, but accept any of CRLF, LFCR, LF)
+CR = b'\r'
+LF = b'\n'
+CRLF = CR+LF
+
+# maximal line length when calling readline(). This is to prevent
+# reading arbitrary length lines. RFC 1939 limits POP3 line length to
+# 512 characters, including CRLF. We have selected 2048 just to be on
+# the safe side.
+_MAXLINE = 2048
+
+
+class POP3:
+
+    """This class supports both the minimal and optional command sets.
+    Arguments can be strings or integers (where appropriate)
+    (e.g.: retr(1) and retr('1') both work equally well.
+
+    Minimal Command Set:
+            USER name               user(name)
+            PASS string             pass_(string)
+            STAT                    stat()
+            LIST [msg]              list(msg = None)
+            RETR msg                retr(msg)
+            DELE msg                dele(msg)
+            NOOP                    noop()
+            RSET                    rset()
+            QUIT                    quit()
+
+    Optional Commands (some servers support these):
+            RPOP name               rpop(name)
+            APOP name digest        apop(name, digest)
+            TOP msg n               top(msg, n)
+            UIDL [msg]              uidl(msg = None)
+            CAPA                    capa()
+            STLS                    stls()
+            UTF8                    utf8()
+
+    Raises one exception: 'error_proto'.
+
+    Instantiate with:
+            POP3(hostname, port=110)
+
+    NB:     the POP protocol locks the mailbox from user
+            authorization until QUIT, so be sure to get in, suck
+            the messages, and quit, each time you access the
+            mailbox.
+
+            POP is a line-based protocol, which means large mail
+            messages consume lots of python cycles reading them
+            line-by-line.
+
+            If it's available on your mail server, use IMAP4
+            instead, it doesn't suffer from the two problems
+            above.
+    """
+
+    encoding = 'UTF-8'
+
+    def __init__(self, host, port=POP3_PORT,
+                 timeout=socket._GLOBAL_DEFAULT_TIMEOUT):
+        self.host = host
+        self.port = port
+        self._tls_established = False
+        sys.audit("poplib.connect", self, host, port)
+        self.sock = self._create_socket(timeout)
+        self.file = self.sock.makefile('rb')
+        self._debugging = 0
+        self.welcome = self._getresp()
+
+    def _create_socket(self, timeout):
+        if timeout is not None and not timeout:
+            raise ValueError('Non-blocking socket (timeout=0) is not supported')
+        return socket.create_connection((self.host, self.port), timeout)
+
+    def _putline(self, line):
+        if self._debugging > 1: print('*put*', repr(line))
+        sys.audit("poplib.putline", self, line)
+        self.sock.sendall(line + CRLF)
+
+
+    # Internal: send one command to the server (through _putline())
+
+    def _putcmd(self, line):
+        if self._debugging: print('*cmd*', repr(line))
+        line = bytes(line, self.encoding)
+        self._putline(line)
+
+
+    # Internal: return one line from the server, stripping CRLF.
+    # This is where all the CPU time of this module is consumed.
+    # Raise error_proto('-ERR EOF') if the connection is closed.
+
+    def _getline(self):
+        line = self.file.readline(_MAXLINE + 1)
+        if len(line) > _MAXLINE:
+            raise error_proto('line too long')
+
+        if self._debugging > 1: print('*get*', repr(line))
+        if not line: raise error_proto('-ERR EOF')
+        octets = len(line)
+        # server can send any combination of CR & LF
+        # however, 'readline()' returns lines ending in LF
+        # so only possibilities are ...LF, ...CRLF, CR...LF
+        if line[-2:] == CRLF:
+            return line[:-2], octets
+        if line[:1] == CR:
+            return line[1:-1], octets
+        return line[:-1], octets
+
+
+    # Internal: get a response from the server.
+    # Raise 'error_proto' if the response doesn't start with '+'.
+
+    def _getresp(self):
+        resp, o = self._getline()
+        if self._debugging > 1: print('*resp*', repr(resp))
+        if not resp.startswith(b'+'):
+            raise error_proto(resp)
+        return resp
+
+
+    # Internal: get a response plus following text from the server.
+
+    def _getlongresp(self):
+        resp = self._getresp()
+        list = []; octets = 0
+        line, o = self._getline()
+        while line != b'.':
+            if line.startswith(b'..'):
+                o = o-1
+                line = line[1:]
+            octets = octets + o
+            list.append(line)
+            line, o = self._getline()
+        return resp, list, octets
+
+
+    # Internal: send a command and get the response
+
+    def _shortcmd(self, line):
+        self._putcmd(line)
+        return self._getresp()
+
+
+    # Internal: send a command and get the response plus following text
+
+    def _longcmd(self, line):
+        self._putcmd(line)
+        return self._getlongresp()
+
+
+    # These can be useful:
+
+    def getwelcome(self):
+        return self.welcome
+
+
+    def set_debuglevel(self, level):
+        self._debugging = level
+
+
+    # Here are all the POP commands:
+
+    def user(self, user):
+        """Send user name, return response
+
+        (should indicate password required).
+        """
+        return self._shortcmd('USER %s' % user)
+
+
+    def pass_(self, pswd):
+        """Send password, return response
+
+        (response includes message count, mailbox size).
+
+        NB: mailbox is locked by server from here to 'quit()'
+        """
+        return self._shortcmd('PASS %s' % pswd)
+
+
+    def stat(self):
+        """Get mailbox status.
+
+        Result is tuple of 2 ints (message count, mailbox size)
+        """
+        retval = self._shortcmd('STAT')
+        rets = retval.split()
+        if self._debugging: print('*stat*', repr(rets))
+
+        # Check if the response has enough elements
+        # RFC 1939 requires at least 3 elements (+OK, message count, mailbox size)
+        # but allows additional data after the required fields
+        if len(rets) < 3:
+            raise error_proto("Invalid STAT response format")
+
+        try:
+            numMessages = int(rets[1])
+            sizeMessages = int(rets[2])
+        except ValueError:
+            raise error_proto("Invalid STAT response data: non-numeric values")
+
+        return (numMessages, sizeMessages)
+
+
+    def list(self, which=None):
+        """Request listing, return result.
+
+        Result without a message number argument is in form
+        ['response', ['mesg_num octets', ...], octets].
+
+        Result when a message number argument is given is a
+        single response: the "scan listing" for that message.
+        """
+        if which is not None:
+            return self._shortcmd('LIST %s' % which)
+        return self._longcmd('LIST')
+
+
+    def retr(self, which):
+        """Retrieve whole message number 'which'.
+
+        Result is in form ['response', ['line', ...], octets].
+        """
+        return self._longcmd('RETR %s' % which)
+
+
+    def dele(self, which):
+        """Delete message number 'which'.
+
+        Result is 'response'.
+        """
+        return self._shortcmd('DELE %s' % which)
+
+
+    def noop(self):
+        """Does nothing.
+
+        One supposes the response indicates the server is alive.
+        """
+        return self._shortcmd('NOOP')
+
+
+    def rset(self):
+        """Unmark all messages marked for deletion."""
+        return self._shortcmd('RSET')
+
+
+    def quit(self):
+        """Signoff: commit changes on server, unlock mailbox, close connection."""
+        resp = self._shortcmd('QUIT')
+        self.close()
+        return resp
+
+    def close(self):
+        """Close the connection without assuming anything about it."""
+        try:
+            file = self.file
+            self.file = None
+            if file is not None:
+                file.close()
+        finally:
+            sock = self.sock
+            self.sock = None
+            if sock is not None:
+                try:
+                    sock.shutdown(socket.SHUT_RDWR)
+                except OSError as exc:
+                    # The server might already have closed the connection.
+                    # On Windows, this may result in WSAEINVAL (error 10022):
+                    # An invalid operation was attempted.
+                    if (exc.errno != errno.ENOTCONN
+                       and getattr(exc, 'winerror', 0) != 10022):
+                        raise
+                finally:
+                    sock.close()
+
+    #__del__ = quit
+
+
+    # optional commands:
+
+    def rpop(self, user):
+        """Send RPOP command to access the mailbox with an alternate user."""
+        return self._shortcmd('RPOP %s' % user)
+
+
+    timestamp = re.compile(br'\+OK.[^<]*(<.*>)')
+
+    def apop(self, user, password):
+        """Authorisation
+
+        - only possible if server has supplied a timestamp in initial greeting.
+
+        Args:
+                user     - mailbox user;
+                password - mailbox password.
+
+        NB: mailbox is locked by server from here to 'quit()'
+        """
+        secret = bytes(password, self.encoding)
+        m = self.timestamp.match(self.welcome)
+        if not m:
+            raise error_proto('-ERR APOP not supported by server')
+        import hashlib
+        digest = m.group(1)+secret
+        digest = hashlib.md5(digest).hexdigest()
+        return self._shortcmd('APOP %s %s' % (user, digest))
+
+
+    def top(self, which, howmuch):
+        """Retrieve message header of message number 'which'
+        and first 'howmuch' lines of message body.
+
+        Result is in form ['response', ['line', ...], octets].
+        """
+        return self._longcmd('TOP %s %s' % (which, howmuch))
+
+
+    def uidl(self, which=None):
+        """Return message digest (unique id) list.
+
+        If 'which', result contains unique id for that message
+        in the form 'response mesgnum uid', otherwise result is
+        the list ['response', ['mesgnum uid', ...], octets]
+        """
+        if which is not None:
+            return self._shortcmd('UIDL %s' % which)
+        return self._longcmd('UIDL')
+
+
+    def utf8(self):
+        """Try to enter UTF-8 mode (see RFC 6856). Returns server response.
+        """
+        return self._shortcmd('UTF8')
+
+
+    def capa(self):
+        """Return server capabilities (RFC 2449) as a dictionary
+        >>> c=poplib.POP3('localhost')
+        >>> c.capa()
+        {'IMPLEMENTATION': ['Cyrus', 'POP3', 'server', 'v2.2.12'],
+         'TOP': [], 'LOGIN-DELAY': ['0'], 'AUTH-RESP-CODE': [],
+         'EXPIRE': ['NEVER'], 'USER': [], 'STLS': [], 'PIPELINING': [],
+         'UIDL': [], 'RESP-CODES': []}
+        >>>
+
+        Really, according to RFC 2449, the cyrus folks should avoid
+        having the implementation split into multiple arguments...
+        """
+        def _parsecap(line):
+            lst = line.decode('ascii').split()
+            return lst[0], lst[1:]
+
+        caps = {}
+        try:
+            resp = self._longcmd('CAPA')
+            rawcaps = resp[1]
+            for capline in rawcaps:
+                capnm, capargs = _parsecap(capline)
+                caps[capnm] = capargs
+        except error_proto:
+            raise error_proto('-ERR CAPA not supported by server')
+        return caps
+
+
+    def stls(self, context=None):
+        """Start a TLS session on the active connection as specified in RFC 2595.
+
+                context - a ssl.SSLContext
+        """
+        if not HAVE_SSL:
+            raise error_proto('-ERR TLS support missing')
+        if self._tls_established:
+            raise error_proto('-ERR TLS session already established')
+        caps = self.capa()
+        if not 'STLS' in caps:
+            raise error_proto('-ERR STLS not supported by server')
+        if context is None:
+            context = ssl._create_stdlib_context()
+        resp = self._shortcmd('STLS')
+        self.sock = context.wrap_socket(self.sock,
+                                        server_hostname=self.host)
+        self.file = self.sock.makefile('rb')
+        self._tls_established = True
+        return resp
+
+
+if HAVE_SSL:
+
+    class POP3_SSL(POP3):
+        """POP3 client class over SSL connection
+
+        Instantiate with: POP3_SSL(hostname, port=995, context=None)
+
+               hostname - the hostname of the pop3 over ssl server
+               port - port number
+               context - a ssl.SSLContext
+
+        See the methods of the parent class POP3 for more documentation.
+        """
+
+        def __init__(self, host, port=POP3_SSL_PORT,
+                     *, timeout=socket._GLOBAL_DEFAULT_TIMEOUT, context=None):
+            if context is None:
+                context = ssl._create_stdlib_context()
+            self.context = context
+            POP3.__init__(self, host, port, timeout)
+
+        def _create_socket(self, timeout):
+            sock = POP3._create_socket(self, timeout)
+            sock = self.context.wrap_socket(sock,
+                                            server_hostname=self.host)
+            return sock
+
+        def stls(self, context=None):
+            """The method unconditionally raises an exception since the
+            STLS command doesn't make any sense on an already established
+            SSL/TLS session.
+            """
+            raise error_proto('-ERR TLS session already established')
+
+    __all__.append("POP3_SSL")
+
+if __name__ == "__main__":
+    a = POP3(sys.argv[1])
+    print(a.getwelcome())
+    a.user(sys.argv[2])
+    a.pass_(sys.argv[3])
+    a.list()
+    (numMsgs, totalSize) = a.stat()
+    for i in range(1, numMsgs + 1):
+        (header, msg, octets) = a.retr(i)
+        print("Message %d:" % i)
+        for line in msg:
+            print('   ' + line)
+        print('-----------------------')
+    a.quit()
diff --git a/Lib/posixpath.py b/Lib/posixpath.py
index 80561ae7e52..ad86cc06c01 100644
--- a/Lib/posixpath.py
+++ b/Lib/posixpath.py
@@ -284,42 +284,41 @@ def expanduser(path):
 # This expands the forms $variable and ${variable} only.
 # Non-existent variables are left unchanged.
 
-_varprog = None
-_varprogb = None
+_varpattern = r'\$(\w+|\{[^}]*\}?)'
+_varsub = None
+_varsubb = None
 
 def expandvars(path):
     """Expand shell variables of form $var and ${var}.  Unknown variables
     are left unchanged."""
     path = os.fspath(path)
-    global _varprog, _varprogb
+    global _varsub, _varsubb
     if isinstance(path, bytes):
         if b'$' not in path:
             return path
-        if not _varprogb:
+        if not _varsubb:
             import re
-            _varprogb = re.compile(br'\$(\w+|\{[^}]*\})', re.ASCII)
-        search = _varprogb.search
+            _varsubb = re.compile(_varpattern.encode(), re.ASCII).sub
+        sub = _varsubb
         start = b'{'
         end = b'}'
         environ = getattr(os, 'environb', None)
     else:
         if '$' not in path:
             return path
-        if not _varprog:
+        if not _varsub:
             import re
-            _varprog = re.compile(r'\$(\w+|\{[^}]*\})', re.ASCII)
-        search = _varprog.search
+            _varsub = re.compile(_varpattern, re.ASCII).sub
+        sub = _varsub
         start = '{'
         end = '}'
         environ = os.environ
-    i = 0
-    while True:
-        m = search(path, i)
-        if not m:
-            break
-        i, j = m.span(0)
-        name = m.group(1)
-        if name.startswith(start) and name.endswith(end):
+
+    def repl(m):
+        name = m[1]
+        if name.startswith(start):
+            if not name.endswith(end):
+                return m[0]
             name = name[1:-1]
         try:
             if environ is None:
@@ -327,13 +326,11 @@ def expandvars(path):
             else:
                 value = environ[name]
         except KeyError:
-            i = j
+            return m[0]
         else:
-            tail = path[j:]
-            path = path[:i] + value
-            i = len(path)
-            path += tail
-    return path
+            return value
+
+    return sub(repl, path)
 
 
 # Normalize a path, e.g. A//B, A/./B and A/foo/../B all become A/B.
@@ -410,6 +407,8 @@ def realpath(filename, *, strict=False):
     else:
         ignored_error = OSError
 
+    lstat = os.lstat
+    readlink = os.readlink
     maxlinks = None
 
     # The stack of unresolved path parts. When popped, a special value of None
@@ -432,6 +431,10 @@ def realpath(filename, *, strict=False):
     # the same links.
     seen = {}
 
+    # Number of symlinks traversed. When the number of traversals is limited
+    # by *maxlinks*, this is used instead of *seen* to detect symlink loops.
+    link_count = 0
+
     while part_count:
         name = rest.pop()
         if name is None:
@@ -451,14 +454,22 @@ def realpath(filename, *, strict=False):
         else:
             newpath = path + sep + name
         try:
-            st_mode = os.lstat(newpath).st_mode
+            st_mode = lstat(newpath).st_mode
             if not stat.S_ISLNK(st_mode):
                 if strict and part_count and not stat.S_ISDIR(st_mode):
                     raise OSError(errno.ENOTDIR, os.strerror(errno.ENOTDIR),
                                   newpath)
                 path = newpath
                 continue
-            if newpath in seen:
+            elif maxlinks is not None:
+                link_count += 1
+                if link_count > maxlinks:
+                    if strict:
+                        raise OSError(errno.ELOOP, os.strerror(errno.ELOOP),
+                                      newpath)
+                    path = newpath
+                    continue
+            elif newpath in seen:
                 # Already seen this path
                 path = seen[newpath]
                 if path is not None:
@@ -466,11 +477,11 @@ def realpath(filename, *, strict=False):
                     continue
                 # The symlink is not resolved, so we must have a symlink loop.
                 if strict:
-                    # Raise OSError(errno.ELOOP)
-                    os.stat(newpath)
+                    raise OSError(errno.ELOOP, os.strerror(errno.ELOOP),
+                                  newpath)
                 path = newpath
                 continue
-            target = os.readlink(newpath)
+            target = readlink(newpath)
         except ignored_error:
             pass
         else:
diff --git a/Lib/pprint.py b/Lib/pprint.py
index 9314701db34..dc0953cec67 100644
--- a/Lib/pprint.py
+++ b/Lib/pprint.py
@@ -35,8 +35,6 @@
 """
 
 import collections as _collections
-import dataclasses as _dataclasses
-import re
 import sys as _sys
 import types as _types
 from io import StringIO as _StringIO
@@ -54,6 +52,7 @@ def pprint(object, stream=None, indent=1, width=80, depth=None, *,
         underscore_numbers=underscore_numbers)
     printer.pprint(object)
 
+
 def pformat(object, indent=1, width=80, depth=None, *,
             compact=False, sort_dicts=True, underscore_numbers=False):
     """Format a Python object into a pretty-printed representation."""
@@ -61,22 +60,27 @@ def pformat(object, indent=1, width=80, depth=None, *,
                          compact=compact, sort_dicts=sort_dicts,
                          underscore_numbers=underscore_numbers).pformat(object)
 
+
 def pp(object, *args, sort_dicts=False, **kwargs):
     """Pretty-print a Python object"""
     pprint(object, *args, sort_dicts=sort_dicts, **kwargs)
 
+
 def saferepr(object):
     """Version of repr() which can handle recursive data structures."""
     return PrettyPrinter()._safe_repr(object, {}, None, 0)[0]
 
+
 def isreadable(object):
     """Determine if saferepr(object) is readable by eval()."""
     return PrettyPrinter()._safe_repr(object, {}, None, 0)[1]
 
+
 def isrecursive(object):
     """Determine if object requires a recursive representation."""
     return PrettyPrinter()._safe_repr(object, {}, None, 0)[2]
 
+
 class _safe_key:
     """Helper function for key functions when sorting unorderable objects.
 
@@ -99,10 +103,12 @@ def __lt__(self, other):
             return ((str(type(self.obj)), id(self.obj)) < \
                     (str(type(other.obj)), id(other.obj)))
 
+
 def _safe_tuple(t):
     "Helper function for comparing 2-tuples"
     return _safe_key(t[0]), _safe_key(t[1])
 
+
 class PrettyPrinter:
     def __init__(self, indent=1, width=80, depth=None, stream=None, *,
                  compact=False, sort_dicts=True, underscore_numbers=False):
@@ -179,12 +185,15 @@ def _format(self, object, stream, indent, allowance, context, level):
         max_width = self._width - indent - allowance
         if len(rep) > max_width:
             p = self._dispatch.get(type(object).__repr__, None)
+            # Lazy import to improve module import time
+            from dataclasses import is_dataclass
+
             if p is not None:
                 context[objid] = 1
                 p(self, object, stream, indent, allowance, context, level + 1)
                 del context[objid]
                 return
-            elif (_dataclasses.is_dataclass(object) and
+            elif (is_dataclass(object) and
                   not isinstance(object, type) and
                   object.__dataclass_params__.repr and
                   # Check dataclass has generated repr method.
@@ -197,9 +206,12 @@ def _format(self, object, stream, indent, allowance, context, level):
         stream.write(rep)
 
     def _pprint_dataclass(self, object, stream, indent, allowance, context, level):
+        # Lazy import to improve module import time
+        from dataclasses import fields as dataclass_fields
+
         cls_name = object.__class__.__name__
         indent += len(cls_name) + 1
-        items = [(f.name, getattr(object, f.name)) for f in _dataclasses.fields(object) if f.repr]
+        items = [(f.name, getattr(object, f.name)) for f in dataclass_fields(object) if f.repr]
         stream.write(cls_name + '(')
         self._format_namespace_items(items, stream, indent, allowance, context, level)
         stream.write(')')
@@ -291,6 +303,9 @@ def _pprint_str(self, object, stream, indent, allowance, context, level):
             if len(rep) <= max_width1:
                 chunks.append(rep)
             else:
+                # Lazy import to improve module import time
+                import re
+
                 # A list of alternating (non-space, space) strings
                 parts = re.findall(r'\S*\s*', line)
                 assert parts
@@ -632,9 +647,11 @@ def _safe_repr(self, object, context, maxlevels, level):
         rep = repr(object)
         return rep, (rep and not rep.startswith('<')), False
 
+
 _builtin_scalars = frozenset({str, bytes, bytearray, float, complex,
                               bool, type(None)})
 
+
 def _recursion(object):
     return ("<Recursion on %s with id=%s>"
             % (type(object).__name__, id(object)))
diff --git a/Lib/py_compile.py b/Lib/py_compile.py
index 388614e51b1..43d8ec90ffb 100644
--- a/Lib/py_compile.py
+++ b/Lib/py_compile.py
@@ -177,7 +177,7 @@ def main():
     import argparse
 
     description = 'A simple command-line interface for py_compile module.'
-    parser = argparse.ArgumentParser(description=description)
+    parser = argparse.ArgumentParser(description=description, color=True)
     parser.add_argument(
         '-q', '--quiet',
         action='store_true',
diff --git a/Lib/pydoc.py b/Lib/pydoc.py
index b521a550472..1f8a6ef3d7c 100644
--- a/Lib/pydoc.py
+++ b/Lib/pydoc.py
@@ -1,4 +1,3 @@
-#!/usr/bin/env python3
 """Generate Python documentation in HTML or text for interactive use.
 
 At the Python interactive prompt, calling help(thing) on a Python object
@@ -16,12 +15,15 @@ class or function within a module or module in a package.  If the
 Run "pydoc -k <keyword>" to search for a keyword in the synopsis lines
 of all available modules.
 
+Run "pydoc -n <hostname>" to start an HTTP server with the given
+hostname (default: localhost) on the local machine.
+
 Run "pydoc -p <port>" to start an HTTP server on the given port on the
 local machine.  Port number 0 can be used to get an arbitrary unused port.
 
 Run "pydoc -b" to start an HTTP server on an arbitrary unused port and
-open a Web browser to interactively browse documentation.  The -p option
-can be used with the -b option to explicitly specify the server port.
+open a web browser to interactively browse documentation.  Combine with
+the -n and -p options to control the hostname and port used.
 
 Run "pydoc -w <name>" to write out the HTML documentation for a module
 to a file named "<name>.html".
@@ -51,6 +53,8 @@ class or function within a module or module in a package.  If the
 #     the current directory is changed with os.chdir(), an incorrect
 #     path will be displayed.
 
+import ast
+import __future__
 import builtins
 import importlib._bootstrap
 import importlib._bootstrap_external
@@ -63,14 +67,32 @@ class or function within a module or module in a package.  If the
 import platform
 import re
 import sys
+import sysconfig
+import textwrap
 import time
 import tokenize
 import urllib.parse
 import warnings
+from annotationlib import Format
 from collections import deque
 from reprlib import Repr
 from traceback import format_exception_only
 
+from _pyrepl.pager import (get_pager, pipe_pager,
+                           plain_pager, tempfile_pager, tty_pager)
+
+# Expose plain() as pydoc.plain()
+from _pyrepl.pager import plain  # noqa: F401
+
+
+# --------------------------------------------------------- old names
+
+getpager = get_pager
+pipepager = pipe_pager
+plainpager = plain_pager
+tempfilepager = tempfile_pager
+ttypager = tty_pager
+
 
 # --------------------------------------------------------- common routines
 
@@ -86,9 +108,100 @@ def pathdirs():
             normdirs.append(normdir)
     return dirs
 
+def _findclass(func):
+    cls = sys.modules.get(func.__module__)
+    if cls is None:
+        return None
+    for name in func.__qualname__.split('.')[:-1]:
+        cls = getattr(cls, name)
+    if not inspect.isclass(cls):
+        return None
+    return cls
+
+def _finddoc(obj):
+    if inspect.ismethod(obj):
+        name = obj.__func__.__name__
+        self = obj.__self__
+        if (inspect.isclass(self) and
+            getattr(getattr(self, name, None), '__func__') is obj.__func__):
+            # classmethod
+            cls = self
+        else:
+            cls = self.__class__
+    elif inspect.isfunction(obj):
+        name = obj.__name__
+        cls = _findclass(obj)
+        if cls is None or getattr(cls, name) is not obj:
+            return None
+    elif inspect.isbuiltin(obj):
+        name = obj.__name__
+        self = obj.__self__
+        if (inspect.isclass(self) and
+            self.__qualname__ + '.' + name == obj.__qualname__):
+            # classmethod
+            cls = self
+        else:
+            cls = self.__class__
+    # Should be tested before isdatadescriptor().
+    elif isinstance(obj, property):
+        name = obj.__name__
+        cls = _findclass(obj.fget)
+        if cls is None or getattr(cls, name) is not obj:
+            return None
+    elif inspect.ismethoddescriptor(obj) or inspect.isdatadescriptor(obj):
+        name = obj.__name__
+        cls = obj.__objclass__
+        if getattr(cls, name) is not obj:
+            return None
+        if inspect.ismemberdescriptor(obj):
+            slots = getattr(cls, '__slots__', None)
+            if isinstance(slots, dict) and name in slots:
+                return slots[name]
+    else:
+        return None
+    for base in cls.__mro__:
+        try:
+            doc = _getowndoc(getattr(base, name))
+        except AttributeError:
+            continue
+        if doc is not None:
+            return doc
+    return None
+
+def _getowndoc(obj):
+    """Get the documentation string for an object if it is not
+    inherited from its class."""
+    try:
+        doc = object.__getattribute__(obj, '__doc__')
+        if doc is None:
+            return None
+        if obj is not type:
+            typedoc = type(obj).__doc__
+            if isinstance(typedoc, str) and typedoc == doc:
+                return None
+        return doc
+    except AttributeError:
+        return None
+
+def _getdoc(object):
+    """Get the documentation string for an object.
+
+    All tabs are expanded to spaces.  To clean up docstrings that are
+    indented to line up with blocks of code, any whitespace than can be
+    uniformly removed from the second line onwards is removed."""
+    doc = _getowndoc(object)
+    if doc is None:
+        try:
+            doc = _finddoc(object)
+        except (AttributeError, TypeError):
+            return None
+    if not isinstance(doc, str):
+        return None
+    return inspect.cleandoc(doc)
+
 def getdoc(object):
     """Get the doc string or comments for an object."""
-    result = inspect.getdoc(object) or inspect.getcomments(object)
+    result = _getdoc(object) or inspect.getcomments(object)
     return result and re.sub('^ *\n', '', result.rstrip()) or ''
 
 def splitdoc(doc):
@@ -100,6 +213,27 @@ def splitdoc(doc):
         return lines[0], '\n'.join(lines[2:])
     return '', '\n'.join(lines)
 
+def _getargspec(object):
+    try:
+        signature = inspect.signature(object, annotation_format=Format.STRING)
+        if signature:
+            name = getattr(object, '__name__', '')
+            # <lambda> function are always single-line and should not be formatted
+            max_width = (80 - len(name)) if name != '<lambda>' else None
+            return signature.format(max_width=max_width, quote_annotation_strings=False)
+    except (ValueError, TypeError):
+        argspec = getattr(object, '__text_signature__', None)
+        if argspec:
+            if argspec[:2] == '($':
+                argspec = '(' + argspec[2:]
+            if getattr(object, '__self__', None) is not None:
+                # Strip the bound argument.
+                m = re.match(r'\(\w+(?:(?=\))|,\s*(?:/(?:(?=\))|,\s*))?)', argspec)
+                if m:
+                    argspec = '(' + argspec[m.end():]
+        return argspec
+    return None
+
 def classname(object, modname):
     """Get a class name and qualify it with a module name if necessary."""
     name = object.__name__
@@ -107,6 +241,19 @@ def classname(object, modname):
         name = object.__module__ + '.' + name
     return name
 
+def parentname(object, modname):
+    """Get a name of the enclosing class (qualified it with a module name
+    if necessary) or module."""
+    if '.' in object.__qualname__:
+        name = object.__qualname__.rpartition('.')[0]
+        if object.__module__ != modname and object.__module__ is not None:
+            return object.__module__ + '.' + name
+        else:
+            return name
+    else:
+        if object.__module__ != modname:
+            return object.__module__
+
 def isdata(object):
     """Check if an object is of a type that probably means it's data."""
     return not (inspect.ismodule(object) or inspect.isclass(object) or
@@ -134,12 +281,6 @@ def stripid(text):
     # The behaviour of %p is implementation-dependent in terms of case.
     return _re_stripid.sub(r'\1', text)
 
-def _is_some_method(obj):
-    return (inspect.isfunction(obj) or
-            inspect.ismethod(obj) or
-            inspect.isbuiltin(obj) or
-            inspect.ismethoddescriptor(obj))
-
 def _is_bound_method(fn):
     """
     Returns True if fn is a bound method, regardless of whether
@@ -155,7 +296,7 @@ def _is_bound_method(fn):
 
 def allmethods(cl):
     methods = {}
-    for key, value in inspect.getmembers(cl, _is_some_method):
+    for key, value in inspect.getmembers(cl, inspect.isroutine):
         methods[key] = 1
     for base in cl.__bases__:
         methods.update(allmethods(base)) # all your base are belong to us
@@ -180,6 +321,8 @@ def _split_list(s, predicate):
             no.append(x)
     return yes, no
 
+_future_feature_names = set(__future__.all_feature_names)
+
 def visiblename(name, all=None, obj=None):
     """Decide whether to show documentation on a variable."""
     # Certain special names are redundant or internal.
@@ -187,13 +330,19 @@ def visiblename(name, all=None, obj=None):
     if name in {'__author__', '__builtins__', '__cached__', '__credits__',
                 '__date__', '__doc__', '__file__', '__spec__',
                 '__loader__', '__module__', '__name__', '__package__',
-                '__path__', '__qualname__', '__slots__', '__version__'}:
+                '__path__', '__qualname__', '__slots__', '__version__',
+                '__static_attributes__', '__firstlineno__',
+                '__annotate_func__', '__annotations_cache__'}:
         return 0
     # Private names are hidden, but special names are displayed.
     if name.startswith('__') and name.endswith('__'): return 1
     # Namedtuples have public fields and methods with a single leading underscore
     if name.startswith('_') and hasattr(obj, '_fields'):
         return True
+    # Ignore __future__ imports.
+    if obj is not __future__ and name in _future_feature_names:
+        if isinstance(getattr(obj, name, None), __future__._Feature):
+            return False
     if all is not None:
         # only document that which the programmer exported in __all__
         return name in all
@@ -201,11 +350,15 @@ def visiblename(name, all=None, obj=None):
         return not name.startswith('_')
 
 def classify_class_attrs(object):
-    """Wrap inspect.classify_class_attrs, with fixup for data descriptors."""
+    """Wrap inspect.classify_class_attrs, with fixup for data descriptors and bound methods."""
     results = []
     for (name, kind, cls, value) in inspect.classify_class_attrs(object):
         if inspect.isdatadescriptor(value):
             kind = 'data descriptor'
+            if isinstance(value, property) and value.fset is None:
+                kind = 'readonly property'
+        elif kind == 'method' and _is_bound_method(value):
+            kind = 'static method'
         results.append((name, kind, cls, value))
     return results
 
@@ -225,6 +378,8 @@ def sort_attributes(attrs, object):
 
 def ispackage(path):
     """Guess whether a path refers to a package directory."""
+    warnings.warn('The pydoc.ispackage() function is deprecated',
+                  DeprecationWarning, stacklevel=2)
     if os.path.isdir(path):
         for ext in ('.py', '.pyc'):
             if os.path.isfile(os.path.join(path, '__init__' + ext)):
@@ -232,21 +387,29 @@ def ispackage(path):
     return False
 
 def source_synopsis(file):
-    line = file.readline()
-    while line[:1] == '#' or not line.strip():
-        line = file.readline()
-        if not line: break
-    line = line.strip()
-    if line[:4] == 'r"""': line = line[1:]
-    if line[:3] == '"""':
-        line = line[3:]
-        if line[-1:] == '\\': line = line[:-1]
-        while not line.strip():
-            line = file.readline()
-            if not line: break
-        result = line.split('"""')[0].strip()
-    else: result = None
-    return result
+    """Return the one-line summary of a file object, if present"""
+
+    string = ''
+    try:
+        tokens = tokenize.generate_tokens(file.readline)
+        for tok_type, tok_string, _, _, _ in tokens:
+            if tok_type == tokenize.STRING:
+                string += tok_string
+            elif tok_type == tokenize.NEWLINE:
+                with warnings.catch_warnings():
+                    # Ignore the "invalid escape sequence" warning.
+                    warnings.simplefilter("ignore", SyntaxWarning)
+                    docstring = ast.literal_eval(string)
+                if not isinstance(docstring, str):
+                    return None
+                return docstring.strip().split('\n')[0].strip()
+            elif tok_type == tokenize.OP and tok_string in ('(', ')'):
+                string += tok_string
+            elif tok_type not in (tokenize.COMMENT, tokenize.NL, tokenize.ENCODING):
+                return None
+    except (tokenize.TokenError, UnicodeDecodeError, SyntaxError):
+        return None
+    return None
 
 def synopsis(filename, cache={}):
     """Get the one-line summary out of a module file."""
@@ -290,8 +453,17 @@ def synopsis(filename, cache={}):
 class ErrorDuringImport(Exception):
     """Errors that occurred while trying to import something to document it."""
     def __init__(self, filename, exc_info):
+        if not isinstance(exc_info, tuple):
+            assert isinstance(exc_info, BaseException)
+            self.exc = type(exc_info)
+            self.value = exc_info
+            self.tb = exc_info.__traceback__
+        else:
+            warnings.warn("A tuple value for exc_info is deprecated, use an exception instance",
+                          DeprecationWarning)
+
+            self.exc, self.value, self.tb = exc_info
         self.filename = filename
-        self.exc, self.value, self.tb = exc_info
 
     def __str__(self):
         exc = self.exc.__name__
@@ -312,8 +484,8 @@ def importfile(path):
     spec = importlib.util.spec_from_file_location(name, path, loader=loader)
     try:
         return importlib._bootstrap._load(spec)
-    except:
-        raise ErrorDuringImport(path, sys.exc_info())
+    except BaseException as err:
+        raise ErrorDuringImport(path, err)
 
 def safeimport(path, forceload=0, cache={}):
     """Import a module; handle errors; return None if the module isn't found.
@@ -340,25 +512,21 @@ def safeimport(path, forceload=0, cache={}):
                     # Prevent garbage collection.
                     cache[key] = sys.modules[key]
                     del sys.modules[key]
-        module = __import__(path)
-    except:
+        module = importlib.import_module(path)
+    except BaseException as err:
         # Did the error occur before or after the module was found?
-        (exc, value, tb) = info = sys.exc_info()
         if path in sys.modules:
             # An error occurred while executing the imported module.
-            raise ErrorDuringImport(sys.modules[path].__file__, info)
-        elif exc is SyntaxError:
+            raise ErrorDuringImport(sys.modules[path].__file__, err)
+        elif type(err) is SyntaxError:
             # A SyntaxError occurred before we could execute the module.
-            raise ErrorDuringImport(value.filename, info)
-        elif issubclass(exc, ImportError) and value.name == path:
+            raise ErrorDuringImport(err.filename, err)
+        elif isinstance(err, ImportError) and err.name == path:
             # No such module in the path.
             return None
         else:
             # Some other error occurred during the importing process.
-            raise ErrorDuringImport(path, sys.exc_info())
-    for part in path.split('.')[1:]:
-        try: module = getattr(module, part)
-        except AttributeError: return None
+            raise ErrorDuringImport(path, err)
     return module
 
 # ---------------------------------------------------- formatter base class
@@ -376,15 +544,13 @@ def document(self, object, name=None, *args):
         # identifies something in a way that pydoc itself has issues handling;
         # think 'super' and how it is a descriptor (which raises the exception
         # by lacking a __name__ attribute) and an instance.
-        if inspect.isgetsetdescriptor(object): return self.docdata(*args)
-        if inspect.ismemberdescriptor(object): return self.docdata(*args)
         try:
             if inspect.ismodule(object): return self.docmodule(*args)
             if inspect.isclass(object): return self.docclass(*args)
             if inspect.isroutine(object): return self.docroutine(*args)
         except AttributeError:
             pass
-        if isinstance(object, property): return self.docproperty(*args)
+        if inspect.isdatadescriptor(object): return self.docdata(*args)
         return self.docother(*args)
 
     def fail(self, object, name=None, *args):
@@ -395,9 +561,7 @@ def fail(self, object, name=None, *args):
 
     docmodule = docclass = docroutine = docother = docproperty = docdata = fail
 
-    def getdocloc(self, object,
-                  basedir=os.path.join(sys.base_exec_prefix, "lib",
-                                       "python%d.%d" %  sys.version_info[:2])):
+    def getdocloc(self, object, basedir=sysconfig.get_path('stdlib')):
         """Return the location of module docs or None"""
 
         try:
@@ -409,16 +573,26 @@ def getdocloc(self, object,
 
         basedir = os.path.normcase(basedir)
         if (isinstance(object, type(os)) and
-            (object.__name__ in ('errno', 'exceptions', 'gc', 'imp',
+            (object.__name__ in ('errno', 'exceptions', 'gc',
                                  'marshal', 'posix', 'signal', 'sys',
                                  '_thread', 'zipimport') or
              (file.startswith(basedir) and
               not file.startswith(os.path.join(basedir, 'site-packages')))) and
-            object.__name__ not in ('xml.etree', 'test.pydoc_mod')):
-            if docloc.startswith(("http://", "https://")):
-                docloc = "%s/%s" % (docloc.rstrip("/"), object.__name__.lower())
+            object.__name__ not in ('xml.etree', 'test.test_pydoc.pydoc_mod')):
+
+            try:
+                from pydoc_data import module_docs
+            except ImportError:
+                module_docs = None
+
+            if module_docs and object.__name__ in module_docs.module_docs:
+                doc_name = module_docs.module_docs[object.__name__]
+                if docloc.startswith(("http://", "https://")):
+                    docloc = "{}/{}".format(docloc.rstrip("/"), doc_name)
+                else:
+                    docloc = os.path.join(docloc, doc_name)
             else:
-                docloc = os.path.join(docloc, object.__name__.lower() + ".html")
+                docloc = None
         else:
             docloc = None
         return docloc
@@ -454,7 +628,7 @@ def repr_string(self, x, level):
             # needed to make any special characters, so show a raw string.
             return 'r' + testrepr[0] + self.escape(test) + testrepr[0]
         return re.sub(r'((\\[\\abfnrtv\'"]|\\[0-9]..|\\x..|\\u....)+)',
-                      r'<font color="#c040c0">\1</font>',
+                      r'<span class="repr">\1</span>',
                       self.escape(testrepr))
 
     repr_str = repr_string
@@ -479,49 +653,48 @@ class HTMLDoc(Doc):
     def page(self, title, contents):
         """Format an HTML page."""
         return '''\
-<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
-<html><head><title>Python: %s</title>
-<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
-</head><body bgcolor="#f0f0f8">
+<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<title>Python: %s</title>
+</head><body>
 %s
 </body></html>''' % (title, contents)
 
-    def heading(self, title, fgcol, bgcol, extras=''):
+    def heading(self, title, extras=''):
         """Format a page heading."""
         return '''
-<table width="100%%" cellspacing=0 cellpadding=2 border=0 summary="heading">
-<tr bgcolor="%s">
-<td valign=bottom>&nbsp;<br>
-<font color="%s" face="helvetica, arial">&nbsp;<br>%s</font></td
-><td align=right valign=bottom
-><font color="%s" face="helvetica, arial">%s</font></td></tr></table>
-    ''' % (bgcol, fgcol, title, fgcol, extras or '&nbsp;')
-
-    def section(self, title, fgcol, bgcol, contents, width=6,
+<table class="heading">
+<tr class="heading-text decor">
+<td class="title">&nbsp;<br>%s</td>
+<td class="extra">%s</td></tr></table>
+    ''' % (title, extras or '&nbsp;')
+
+    def section(self, title, cls, contents, width=6,
                 prelude='', marginalia=None, gap='&nbsp;'):
         """Format a section with a heading."""
         if marginalia is None:
-            marginalia = '<tt>' + '&nbsp;' * width + '</tt>'
+            marginalia = '<span class="code">' + '&nbsp;' * width + '</span>'
         result = '''<p>
-<table width="100%%" cellspacing=0 cellpadding=2 border=0 summary="section">
-<tr bgcolor="%s">
-<td colspan=3 valign=bottom>&nbsp;<br>
-<font color="%s" face="helvetica, arial">%s</font></td></tr>
-    ''' % (bgcol, fgcol, title)
+<table class="section">
+<tr class="decor %s-decor heading-text">
+<td class="section-title" colspan=3>&nbsp;<br>%s</td></tr>
+    ''' % (cls, title)
         if prelude:
             result = result + '''
-<tr bgcolor="%s"><td rowspan=2>%s</td>
-<td colspan=2>%s</td></tr>
-<tr><td>%s</td>''' % (bgcol, marginalia, prelude, gap)
+<tr><td class="decor %s-decor" rowspan=2>%s</td>
+<td class="decor %s-decor" colspan=2>%s</td></tr>
+<tr><td>%s</td>''' % (cls, marginalia, cls, prelude, gap)
         else:
             result = result + '''
-<tr><td bgcolor="%s">%s</td><td>%s</td>''' % (bgcol, marginalia, gap)
+<tr><td class="decor %s-decor">%s</td><td>%s</td>''' % (cls, marginalia, gap)
 
-        return result + '\n<td width="100%%">%s</td></tr></table>' % contents
+        return result + '\n<td class="singlecolumn">%s</td></tr></table>' % contents
 
     def bigsection(self, title, *args):
         """Format a section with a big heading."""
-        title = '<big><strong>%s</strong></big>' % title
+        title = '<strong class="bigsection">%s</strong>' % title
         return self.section(title, *args)
 
     def preformat(self, text):
@@ -530,19 +703,19 @@ def preformat(self, text):
         return replace(text, '\n\n', '\n \n', '\n\n', '\n \n',
                              ' ', '&nbsp;', '\n', '<br>\n')
 
-    def multicolumn(self, list, format, cols=4):
+    def multicolumn(self, list, format):
         """Format a list of items into a multi-column list."""
         result = ''
-        rows = (len(list)+cols-1)//cols
-        for col in range(cols):
-            result = result + '<td width="%d%%" valign=top>' % (100//cols)
+        rows = (len(list) + 3) // 4
+        for col in range(4):
+            result = result + '<td class="multicolumn">'
             for i in range(rows*col, rows*col+rows):
                 if i < len(list):
                     result = result + format(list[i]) + '<br>\n'
             result = result + '</td>'
-        return '<table width="100%%" summary="list"><tr>%s</tr></table>' % result
+        return '<table><tr>%s</tr></table>' % result
 
-    def grey(self, text): return '<font color="#909090">%s</font>' % text
+    def grey(self, text): return '<span class="grey">%s</span>' % text
 
     def namelink(self, name, *dicts):
         """Make a link for an identifier, given name-to-URL mappings."""
@@ -559,6 +732,25 @@ def classlink(self, object, modname):
                 module.__name__, name, classname(object, modname))
         return classname(object, modname)
 
+    def parentlink(self, object, modname):
+        """Make a link for the enclosing class or module."""
+        link = None
+        name, module = object.__name__, sys.modules.get(object.__module__)
+        if hasattr(module, name) and getattr(module, name) is object:
+            if '.' in object.__qualname__:
+                name = object.__qualname__.rpartition('.')[0]
+                if object.__module__ != modname:
+                    link = '%s.html#%s' % (module.__name__, name)
+                else:
+                    link = '#%s' % name
+            else:
+                if object.__module__ != modname:
+                    link = '%s.html' % module.__name__
+        if link:
+            return '<a href="%s">%s</a>' % (link, parentname(object, modname))
+        else:
+            return parentname(object, modname)
+
     def modulelink(self, object):
         """Make a link for a module."""
         return '<a href="%s.html">%s</a>' % (object.__name__, object.__name__)
@@ -588,13 +780,11 @@ def markup(self, text, escape=None, funcs={}, classes={}, methods={}):
         escape = escape or self.escape
         results = []
         here = 0
-        pattern = re.compile(r'\b((http|ftp)://\S+[\w/]|'
+        pattern = re.compile(r'\b((http|https|ftp)://\S+[\w/]|'
                                 r'RFC[- ]?(\d+)|'
                                 r'PEP[- ]?(\d+)|'
                                 r'(self\.)?(\w+))')
-        while True:
-            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]))
 
@@ -603,10 +793,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 = 'http://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 selfdot:
                 # Create a link for methods like 'self.method(...)'
@@ -629,17 +819,17 @@ def formattree(self, tree, modname, parent=None):
         """Produce HTML for a class tree as given by inspect.getclasstree()."""
         result = ''
         for entry in tree:
-            if type(entry) is type(()):
+            if isinstance(entry, tuple):
                 c, bases = entry
-                result = result + '<dt><font face="helvetica, arial">'
+                result = result + '<dt class="heading-text">'
                 result = result + self.classlink(c, modname)
                 if bases and bases != (parent,):
                     parents = []
                     for base in bases:
                         parents.append(self.classlink(base, modname))
                     result = result + '(' + ', '.join(parents) + ')'
-                result = result + '\n</font></dt>'
-            elif type(entry) is type([]):
+                result = result + '\n</dt>'
+            elif isinstance(entry, list):
                 result = result + '<dd>\n%s</dd>\n' % self.formattree(
                     entry, modname, c)
         return '<dl>\n%s</dl>\n' % result
@@ -655,10 +845,10 @@ def docmodule(self, object, name=None, mod=None, *ignored):
         links = []
         for i in range(len(parts)-1):
             links.append(
-                '<a href="%s.html"><font color="#ffffff">%s</font></a>' %
+                '<a href="%s.html" class="white">%s</a>' %
                 ('.'.join(parts[:i+1]), parts[i]))
         linkedname = '.'.join(links + parts[-1:])
-        head = '<big><big><strong>%s</strong></big></big>' % linkedname
+        head = '<strong class="title">%s</strong>' % linkedname
         try:
             path = inspect.getabsfile(object)
             url = urllib.parse.quote(path)
@@ -680,9 +870,7 @@ def docmodule(self, object, name=None, mod=None, *ignored):
             docloc = '<br><a href="%(docloc)s">Module Reference</a>' % locals()
         else:
             docloc = ''
-        result = self.heading(
-            head, '#ffffff', '#7799ee',
-            '<a href=".">index</a><br>' + filelink + docloc)
+        result = self.heading(head, '<a href=".">index</a><br>' + filelink + docloc)
 
         modules = inspect.getmembers(object, inspect.ismodule)
 
@@ -704,9 +892,10 @@ def docmodule(self, object, name=None, mod=None, *ignored):
                             cdict[key] = cdict[base] = modname + '.html#' + key
         funcs, fdict = [], {}
         for key, value in inspect.getmembers(object, inspect.isroutine):
-            # if __all__ exists, believe it.  Otherwise use old heuristic.
-            if (all is not None or
-                inspect.isbuiltin(value) or inspect.getmodule(value) is object):
+            # if __all__ exists, believe it.  Otherwise use a heuristic.
+            if (all is not None
+                or inspect.isbuiltin(value)
+                or (inspect.getmodule(value) or object) is object):
                 if visiblename(key, all, object):
                     funcs.append((key, value))
                     fdict[key] = '#-' + key
@@ -717,7 +906,7 @@ def docmodule(self, object, name=None, mod=None, *ignored):
                 data.append((key, value))
 
         doc = self.markup(getdoc(object), self.preformat, fdict, cdict)
-        doc = doc and '<tt>%s</tt>' % doc
+        doc = doc and '<span class="code">%s</span>' % doc
         result = result + '<p>%s</p>\n' % doc
 
         if hasattr(object, '__path__'):
@@ -727,12 +916,12 @@ def docmodule(self, object, name=None, mod=None, *ignored):
             modpkgs.sort()
             contents = self.multicolumn(modpkgs, self.modpkglink)
             result = result + self.bigsection(
-                'Package Contents', '#ffffff', '#aa55cc', contents)
+                'Package Contents', 'pkg-content', contents)
         elif modules:
             contents = self.multicolumn(
                 modules, lambda t: self.modulelink(t[1]))
             result = result + self.bigsection(
-                'Modules', '#ffffff', '#aa55cc', contents)
+                'Modules', 'pkg-content', contents)
 
         if classes:
             classlist = [value for (key, value) in classes]
@@ -741,27 +930,25 @@ def docmodule(self, object, name=None, mod=None, *ignored):
             for key, value in classes:
                 contents.append(self.document(value, key, name, fdict, cdict))
             result = result + self.bigsection(
-                'Classes', '#ffffff', '#ee77aa', ' '.join(contents))
+                'Classes', 'index', ' '.join(contents))
         if funcs:
             contents = []
             for key, value in funcs:
                 contents.append(self.document(value, key, name, fdict, cdict))
             result = result + self.bigsection(
-                'Functions', '#ffffff', '#eeaa77', ' '.join(contents))
+                'Functions', 'functions', ' '.join(contents))
         if data:
             contents = []
             for key, value in data:
                 contents.append(self.document(value, key))
             result = result + self.bigsection(
-                'Data', '#ffffff', '#55aa55', '<br>\n'.join(contents))
+                'Data', 'data', '<br>\n'.join(contents))
         if hasattr(object, '__author__'):
             contents = self.markup(str(object.__author__), self.preformat)
-            result = result + self.bigsection(
-                'Author', '#ffffff', '#7799ee', contents)
+            result = result + self.bigsection('Author', 'author', contents)
         if hasattr(object, '__credits__'):
             contents = self.markup(str(object.__credits__), self.preformat)
-            result = result + self.bigsection(
-                'Credits', '#ffffff', '#7799ee', contents)
+            result = result + self.bigsection('Credits', 'credits', contents)
 
         return result
 
@@ -806,10 +993,10 @@ def spill(msg, attrs, predicate):
                     except Exception:
                         # Some descriptors may meet a failure in their __get__.
                         # (bug #1785)
-                        push(self._docdescriptor(name, value, mod))
+                        push(self.docdata(value, name, mod))
                     else:
                         push(self.document(value, name, mod,
-                                        funcs, classes, mdict, object))
+                                        funcs, classes, mdict, object, homecls))
                     push('\n')
             return attrs
 
@@ -819,7 +1006,7 @@ def spilldescriptors(msg, attrs, predicate):
                 hr.maybe()
                 push(msg)
                 for name, kind, homecls, value in ok:
-                    push(self._docdescriptor(name, value, mod))
+                    push(self.docdata(value, name, mod))
             return attrs
 
         def spilldata(msg, attrs, predicate):
@@ -829,16 +1016,13 @@ def spilldata(msg, attrs, predicate):
                 push(msg)
                 for name, kind, homecls, value in ok:
                     base = self.docother(getattr(object, name), name, mod)
-                    if callable(value) or inspect.isdatadescriptor(value):
-                        doc = getattr(value, "__doc__", None)
-                    else:
-                        doc = None
-                    if doc is None:
+                    doc = getdoc(value)
+                    if not doc:
                         push('<dl><dt>%s</dl>\n' % base)
                     else:
                         doc = self.markup(getdoc(value), self.preformat,
                                           funcs, classes, mdict)
-                        doc = '<dd><tt>%s</tt>' % doc
+                        doc = '<dd><span class="code">%s</span>' % doc
                         push('<dl><dt>%s%s</dl>\n' % (base, doc))
                     push('\n')
             return attrs
@@ -870,7 +1054,7 @@ def spilldata(msg, attrs, predicate):
                 thisclass = attrs[0][2]
             attrs, inherited = _split_list(attrs, lambda t: t[2] is thisclass)
 
-            if thisclass is builtins.object:
+            if object is not builtins.object and thisclass is builtins.object:
                 attrs = inherited
                 continue
             elif thisclass is object:
@@ -889,6 +1073,8 @@ def spilldata(msg, attrs, predicate):
                           lambda t: t[1] == 'class method')
             attrs = spill('Static methods %s' % tag, attrs,
                           lambda t: t[1] == 'static method')
+            attrs = spilldescriptors("Readonly properties %s" % tag, attrs,
+                                     lambda t: t[1] == 'readonly property')
             attrs = spilldescriptors('Data descriptors %s' % tag, attrs,
                                      lambda t: t[1] == 'data descriptor')
             attrs = spilldata('Data and other attributes %s' % tag, attrs,
@@ -909,100 +1095,129 @@ def spilldata(msg, attrs, predicate):
             for base in bases:
                 parents.append(self.classlink(base, object.__module__))
             title = title + '(%s)' % ', '.join(parents)
-        doc = self.markup(getdoc(object), self.preformat, funcs, classes, mdict)
-        doc = doc and '<tt>%s<br>&nbsp;</tt>' % doc
 
-        return self.section(title, '#000000', '#ffc8d8', contents, 3, doc)
+        decl = ''
+        argspec = _getargspec(object)
+        if argspec and argspec != '()':
+            decl = name + self.escape(argspec) + '\n\n'
+
+        doc = getdoc(object)
+        if decl:
+            doc = decl + (doc or '')
+        doc = self.markup(doc, self.preformat, funcs, classes, mdict)
+        doc = doc and '<span class="code">%s<br>&nbsp;</span>' % doc
+
+        return self.section(title, 'title', contents, 3, doc)
 
     def formatvalue(self, object):
         """Format an argument default value as text."""
         return self.grey('=' + self.repr(object))
 
     def docroutine(self, object, name=None, mod=None,
-                   funcs={}, classes={}, methods={}, cl=None):
+                   funcs={}, classes={}, methods={}, cl=None, homecls=None):
         """Produce HTML documentation for a function or method object."""
         realname = object.__name__
         name = name or realname
-        anchor = (cl and cl.__name__ or '') + '-' + name
+        if homecls is None:
+            homecls = cl
+        anchor = ('' if cl is None else cl.__name__) + '-' + name
         note = ''
-        skipdocs = 0
+        skipdocs = False
+        imfunc = None
         if _is_bound_method(object):
-            imclass = object.__self__.__class__
-            if cl:
-                if imclass is not cl:
-                    note = ' from ' + self.classlink(imclass, mod)
+            imself = object.__self__
+            if imself is cl:
+                imfunc = getattr(object, '__func__', None)
+            elif inspect.isclass(imself):
+                note = ' class method of %s' % self.classlink(imself, mod)
             else:
-                if object.__self__ is not None:
-                    note = ' method of %s instance' % self.classlink(
-                        object.__self__.__class__, mod)
-                else:
-                    note = ' unbound %s method' % self.classlink(imclass,mod)
+                note = ' method of %s instance' % self.classlink(
+                    imself.__class__, mod)
+        elif (inspect.ismethoddescriptor(object) or
+              inspect.ismethodwrapper(object)):
+            try:
+                objclass = object.__objclass__
+            except AttributeError:
+                pass
+            else:
+                if cl is None:
+                    note = ' unbound %s method' % self.classlink(objclass, mod)
+                elif objclass is not homecls:
+                    note = ' from ' + self.classlink(objclass, mod)
+        else:
+            imfunc = object
+        if inspect.isfunction(imfunc) and homecls is not None and (
+            imfunc.__module__ != homecls.__module__ or
+            imfunc.__qualname__ != homecls.__qualname__ + '.' + realname):
+            pname = self.parentlink(imfunc, mod)
+            if pname:
+                note = ' from %s' % pname
+
+        if (inspect.iscoroutinefunction(object) or
+                inspect.isasyncgenfunction(object)):
+            asyncqualifier = 'async '
+        else:
+            asyncqualifier = ''
 
         if name == realname:
             title = '<a name="%s"><strong>%s</strong></a>' % (anchor, realname)
         else:
-            if cl and inspect.getattr_static(cl, realname, []) is object:
+            if (cl is not None and
+                inspect.getattr_static(cl, realname, []) is object):
                 reallink = '<a href="#%s">%s</a>' % (
                     cl.__name__ + '-' + realname, realname)
-                skipdocs = 1
+                skipdocs = True
+                if note.startswith(' from '):
+                    note = ''
             else:
                 reallink = realname
             title = '<a name="%s"><strong>%s</strong></a> = %s' % (
                 anchor, name, reallink)
         argspec = None
         if inspect.isroutine(object):
-            try:
-                signature = inspect.signature(object)
-            except (ValueError, TypeError):
-                signature = None
-            if signature:
-                argspec = str(signature)
-                if realname == '<lambda>':
-                    title = '<strong>%s</strong> <em>lambda</em> ' % name
-                    # XXX lambda's won't usually have func_annotations['return']
-                    # since the syntax doesn't support but it is possible.
-                    # So removing parentheses isn't truly safe.
+            argspec = _getargspec(object)
+            if argspec and realname == '<lambda>':
+                title = '<strong>%s</strong> <em>lambda</em> ' % name
+                # XXX lambda's won't usually have func_annotations['return']
+                # since the syntax doesn't support but it is possible.
+                # So removing parentheses isn't truly safe.
+                if not object.__annotations__:
                     argspec = argspec[1:-1] # remove parentheses
         if not argspec:
             argspec = '(...)'
 
-        decl = title + self.escape(argspec) + (note and self.grey(
-               '<font face="helvetica, arial">%s</font>' % note))
+        decl = asyncqualifier + title + self.escape(argspec) + (note and
+               self.grey('<span class="heading-text">%s</span>' % note))
 
         if skipdocs:
             return '<dl><dt>%s</dt></dl>\n' % decl
         else:
             doc = self.markup(
                 getdoc(object), self.preformat, funcs, classes, methods)
-            doc = doc and '<dd><tt>%s</tt></dd>' % doc
+            doc = doc and '<dd><span class="code">%s</span></dd>' % doc
             return '<dl><dt>%s</dt>%s</dl>\n' % (decl, doc)
 
-    def _docdescriptor(self, name, value, mod):
+    def docdata(self, object, name=None, mod=None, cl=None, *ignored):
+        """Produce html documentation for a data descriptor."""
         results = []
         push = results.append
 
         if name:
             push('<dl><dt><strong>%s</strong></dt>\n' % name)
-        if value.__doc__ is not None:
-            doc = self.markup(getdoc(value), self.preformat)
-            push('<dd><tt>%s</tt></dd>\n' % doc)
+        doc = self.markup(getdoc(object), self.preformat)
+        if doc:
+            push('<dd><span class="code">%s</span></dd>\n' % doc)
         push('</dl>\n')
 
         return ''.join(results)
 
-    def docproperty(self, object, name=None, mod=None, cl=None):
-        """Produce html documentation for a property."""
-        return self._docdescriptor(name, object, mod)
+    docproperty = docdata
 
     def docother(self, object, name=None, mod=None, *ignored):
         """Produce HTML documentation for a data object."""
         lhs = name and '<strong>%s</strong> = ' % name or ''
         return lhs + self.repr(object)
 
-    def docdata(self, object, name=None, mod=None, cl=None):
-        """Produce html documentation for a data descriptor."""
-        return self._docdescriptor(name, object, mod)
-
     def index(self, dir, shadowed=None):
         """Generate an HTML index for a directory of modules."""
         modpkgs = []
@@ -1016,7 +1231,7 @@ def index(self, dir, shadowed=None):
 
         modpkgs.sort()
         contents = self.multicolumn(modpkgs, self.modpkglink)
-        return self.bigsection(dir, '#ffffff', '#ee77aa', contents)
+        return self.bigsection(dir, 'index', contents)
 
 # -------------------------------------------- text documentation generator
 
@@ -1067,8 +1282,7 @@ def bold(self, text):
     def indent(self, text, prefix='    '):
         """Indent text by prepending a given prefix to each line."""
         if not text: return ''
-        lines = [prefix + line for line in text.split('\n')]
-        if lines: lines[-1] = lines[-1].rstrip()
+        lines = [(prefix + line).rstrip() for line in text.split('\n')]
         return '\n'.join(lines)
 
     def section(self, title, contents):
@@ -1082,19 +1296,19 @@ def formattree(self, tree, modname, parent=None, prefix=''):
         """Render in text a class tree as returned by inspect.getclasstree()."""
         result = ''
         for entry in tree:
-            if type(entry) is type(()):
+            if isinstance(entry, tuple):
                 c, bases = entry
                 result = result + prefix + classname(c, modname)
                 if bases and bases != (parent,):
                     parents = (classname(c, modname) for c in bases)
                     result = result + '(%s)' % ', '.join(parents)
                 result = result + '\n'
-            elif type(entry) is type([]):
+            elif isinstance(entry, list):
                 result = result + self.formattree(
                     entry, modname, c, prefix + '    ')
         return result
 
-    def docmodule(self, object, name=None, mod=None):
+    def docmodule(self, object, name=None, mod=None, *ignored):
         """Produce text documentation for a given module object."""
         name = object.__name__ # ignore the passed-in name
         synop, desc = splitdoc(getdoc(object))
@@ -1123,9 +1337,10 @@ def docmodule(self, object, name=None, mod=None):
                     classes.append((key, value))
         funcs = []
         for key, value in inspect.getmembers(object, inspect.isroutine):
-            # if __all__ exists, believe it.  Otherwise use old heuristic.
-            if (all is not None or
-                inspect.isbuiltin(value) or inspect.getmodule(value) is object):
+            # if __all__ exists, believe it.  Otherwise use a heuristic.
+            if (all is not None
+                or inspect.isbuiltin(value)
+                or (inspect.getmodule(value) or object) is object):
                 if visiblename(key, all, object):
                     funcs.append((key, value))
         data = []
@@ -1212,10 +1427,17 @@ def makename(c, m=object.__module__):
             parents = map(makename, bases)
             title = title + '(%s)' % ', '.join(parents)
 
-        doc = getdoc(object)
-        contents = doc and [doc + '\n'] or []
+        contents = []
         push = contents.append
 
+        argspec = _getargspec(object)
+        if argspec and argspec != '()':
+            push(name + argspec + '\n')
+
+        doc = getdoc(object)
+        if doc:
+            push(doc + '\n')
+
         # List the mro, if non-trivial.
         mro = deque(inspect.getmro(object))
         if len(mro) > 2:
@@ -1224,6 +1446,25 @@ def makename(c, m=object.__module__):
                 push('    ' + makename(base))
             push('')
 
+        # List the built-in subclasses, if any:
+        subclasses = sorted(
+            (str(cls.__name__) for cls in type.__subclasses__(object)
+             if (not cls.__name__.startswith("_") and
+                 getattr(cls, '__module__', '') == "builtins")),
+            key=str.lower
+        )
+        no_of_subclasses = len(subclasses)
+        MAX_SUBCLASSES_TO_DISPLAY = 4
+        if subclasses:
+            push("Built-in subclasses:")
+            for subclassname in subclasses[:MAX_SUBCLASSES_TO_DISPLAY]:
+                push('    ' + subclassname)
+            if no_of_subclasses > MAX_SUBCLASSES_TO_DISPLAY:
+                push('    ... and ' +
+                     str(no_of_subclasses - MAX_SUBCLASSES_TO_DISPLAY) +
+                     ' other subclasses')
+            push('')
+
         # Cute little class to pump out a horizontal rule between sections.
         class HorizontalRule:
             def __init__(self):
@@ -1245,10 +1486,10 @@ def spill(msg, attrs, predicate):
                     except Exception:
                         # Some descriptors may meet a failure in their __get__.
                         # (bug #1785)
-                        push(self._docdescriptor(name, value, mod))
+                        push(self.docdata(value, name, mod))
                     else:
                         push(self.document(value,
-                                        name, mod, object))
+                                        name, mod, object, homecls))
             return attrs
 
         def spilldescriptors(msg, attrs, predicate):
@@ -1257,7 +1498,7 @@ def spilldescriptors(msg, attrs, predicate):
                 hr.maybe()
                 push(msg)
                 for name, kind, homecls, value in ok:
-                    push(self._docdescriptor(name, value, mod))
+                    push(self.docdata(value, name, mod))
             return attrs
 
         def spilldata(msg, attrs, predicate):
@@ -1266,10 +1507,7 @@ def spilldata(msg, attrs, predicate):
                 hr.maybe()
                 push(msg)
                 for name, kind, homecls, value in ok:
-                    if callable(value) or inspect.isdatadescriptor(value):
-                        doc = getdoc(value)
-                    else:
-                        doc = None
+                    doc = getdoc(value)
                     try:
                         obj = getattr(object, name)
                     except AttributeError:
@@ -1289,7 +1527,7 @@ def spilldata(msg, attrs, predicate):
                 thisclass = attrs[0][2]
             attrs, inherited = _split_list(attrs, lambda t: t[2] is thisclass)
 
-            if thisclass is builtins.object:
+            if object is not builtins.object and thisclass is builtins.object:
                 attrs = inherited
                 continue
             elif thisclass is object:
@@ -1307,6 +1545,8 @@ def spilldata(msg, attrs, predicate):
                           lambda t: t[1] == 'class method')
             attrs = spill("Static methods %s:\n" % tag, attrs,
                           lambda t: t[1] == 'static method')
+            attrs = spilldescriptors("Readonly properties %s:\n" % tag, attrs,
+                                     lambda t: t[1] == 'readonly property')
             attrs = spilldescriptors("Data descriptors %s:\n" % tag, attrs,
                                      lambda t: t[1] == 'data descriptor')
             attrs = spilldata("Data and other attributes %s:\n" % tag, attrs,
@@ -1324,48 +1564,73 @@ def formatvalue(self, object):
         """Format an argument default value as text."""
         return '=' + self.repr(object)
 
-    def docroutine(self, object, name=None, mod=None, cl=None):
+    def docroutine(self, object, name=None, mod=None, cl=None, homecls=None):
         """Produce text documentation for a function or method object."""
         realname = object.__name__
         name = name or realname
+        if homecls is None:
+            homecls = cl
         note = ''
-        skipdocs = 0
+        skipdocs = False
+        imfunc = None
         if _is_bound_method(object):
-            imclass = object.__self__.__class__
-            if cl:
-                if imclass is not cl:
-                    note = ' from ' + classname(imclass, mod)
+            imself = object.__self__
+            if imself is cl:
+                imfunc = getattr(object, '__func__', None)
+            elif inspect.isclass(imself):
+                note = ' class method of %s' % classname(imself, mod)
             else:
-                if object.__self__ is not None:
-                    note = ' method of %s instance' % classname(
-                        object.__self__.__class__, mod)
-                else:
-                    note = ' unbound %s method' % classname(imclass,mod)
+                note = ' method of %s instance' % classname(
+                    imself.__class__, mod)
+        elif (inspect.ismethoddescriptor(object) or
+              inspect.ismethodwrapper(object)):
+            try:
+                objclass = object.__objclass__
+            except AttributeError:
+                pass
+            else:
+                if cl is None:
+                    note = ' unbound %s method' % classname(objclass, mod)
+                elif objclass is not homecls:
+                    note = ' from ' + classname(objclass, mod)
+        else:
+            imfunc = object
+        if inspect.isfunction(imfunc) and homecls is not None and (
+            imfunc.__module__ != homecls.__module__ or
+            imfunc.__qualname__ != homecls.__qualname__ + '.' + realname):
+            pname = parentname(imfunc, mod)
+            if pname:
+                note = ' from %s' % pname
+
+        if (inspect.iscoroutinefunction(object) or
+                inspect.isasyncgenfunction(object)):
+            asyncqualifier = 'async '
+        else:
+            asyncqualifier = ''
 
         if name == realname:
             title = self.bold(realname)
         else:
-            if cl and inspect.getattr_static(cl, realname, []) is object:
-                skipdocs = 1
+            if (cl is not None and
+                inspect.getattr_static(cl, realname, []) is object):
+                skipdocs = True
+                if note.startswith(' from '):
+                    note = ''
             title = self.bold(name) + ' = ' + realname
         argspec = None
 
         if inspect.isroutine(object):
-            try:
-                signature = inspect.signature(object)
-            except (ValueError, TypeError):
-                signature = None
-            if signature:
-                argspec = str(signature)
-                if realname == '<lambda>':
-                    title = self.bold(name) + ' lambda '
-                    # XXX lambda's won't usually have func_annotations['return']
-                    # since the syntax doesn't support but it is possible.
-                    # So removing parentheses isn't truly safe.
-                    argspec = argspec[1:-1] # remove parentheses
+            argspec = _getargspec(object)
+            if argspec and realname == '<lambda>':
+                title = self.bold(name) + ' lambda '
+                # XXX lambda's won't usually have func_annotations['return']
+                # since the syntax doesn't support but it is possible.
+                # So removing parentheses isn't truly safe.
+                if not object.__annotations__:
+                    argspec = argspec[1:-1]
         if not argspec:
             argspec = '(...)'
-        decl = title + argspec + note
+        decl = asyncqualifier + title + argspec + note
 
         if skipdocs:
             return decl + '\n'
@@ -1373,28 +1638,24 @@ def docroutine(self, object, name=None, mod=None, cl=None):
             doc = getdoc(object) or ''
             return decl + '\n' + (doc and self.indent(doc).rstrip() + '\n')
 
-    def _docdescriptor(self, name, value, mod):
+    def docdata(self, object, name=None, mod=None, cl=None, *ignored):
+        """Produce text documentation for a data descriptor."""
         results = []
         push = results.append
 
         if name:
             push(self.bold(name))
             push('\n')
-        doc = getdoc(value) or ''
+        doc = getdoc(object) or ''
         if doc:
             push(self.indent(doc))
             push('\n')
         return ''.join(results)
 
-    def docproperty(self, object, name=None, mod=None, cl=None):
-        """Produce text documentation for a property."""
-        return self._docdescriptor(name, object, mod)
+    docproperty = docdata
 
-    def docdata(self, object, name=None, mod=None, cl=None):
-        """Produce text documentation for a data descriptor."""
-        return self._docdescriptor(name, object, mod)
-
-    def docother(self, object, name=None, mod=None, parent=None, maxlen=None, doc=None):
+    def docother(self, object, name=None, mod=None, parent=None, *ignored,
+                 maxlen=None, doc=None):
         """Produce text documentation for a data object."""
         repr = self.repr(object)
         if maxlen:
@@ -1402,8 +1663,10 @@ def docother(self, object, name=None, mod=None, parent=None, maxlen=None, doc=No
             chop = maxlen - len(line)
             if chop < 0: repr = repr[:chop] + '...'
         line = (name and self.bold(name) + ' = ' or '') + repr
-        if doc is not None:
-            line += '\n' + self.indent(str(doc))
+        if not doc:
+            doc = getdoc(object)
+        if doc:
+            line += '\n' + self.indent(str(doc)) + '\n'
         return line
 
 class _PlainTextDoc(TextDoc):
@@ -1413,136 +1676,11 @@ def bold(self, text):
 
 # --------------------------------------------------------- user interfaces
 
-def pager(text):
+def pager(text, title=''):
     """The first time this is called, determine what kind of pager to use."""
     global pager
-    pager = getpager()
-    pager(text)
-
-def getpager():
-    """Decide what method to use for paging through text."""
-    if not hasattr(sys.stdin, "isatty"):
-        return plainpager
-    if not hasattr(sys.stdout, "isatty"):
-        return plainpager
-    if not sys.stdin.isatty() or not sys.stdout.isatty():
-        return plainpager
-    use_pager = os.environ.get('MANPAGER') or os.environ.get('PAGER')
-    if use_pager:
-        if sys.platform == 'win32': # pipes completely broken in Windows
-            return lambda text: tempfilepager(plain(text), use_pager)
-        elif os.environ.get('TERM') in ('dumb', 'emacs'):
-            return lambda text: pipepager(plain(text), use_pager)
-        else:
-            return lambda text: pipepager(text, use_pager)
-    if os.environ.get('TERM') in ('dumb', 'emacs'):
-        return plainpager
-    if sys.platform == 'win32':
-        return lambda text: tempfilepager(plain(text), 'more <')
-    if hasattr(os, 'system') and os.system('(less) 2>/dev/null') == 0:
-        return lambda text: pipepager(text, 'less')
-
-    import tempfile
-    (fd, filename) = tempfile.mkstemp()
-    os.close(fd)
-    try:
-        if hasattr(os, 'system') and os.system('more "%s"' % filename) == 0:
-            return lambda text: pipepager(text, 'more')
-        else:
-            return ttypager
-    finally:
-        os.unlink(filename)
-
-def plain(text):
-    """Remove boldface formatting from text."""
-    return re.sub('.\b', '', text)
-
-def pipepager(text, cmd):
-    """Page through text by feeding it to another program."""
-    import subprocess
-    proc = subprocess.Popen(cmd, shell=True, stdin=subprocess.PIPE)
-    try:
-        with io.TextIOWrapper(proc.stdin, errors='backslashreplace') as pipe:
-            try:
-                pipe.write(text)
-            except KeyboardInterrupt:
-                # We've hereby abandoned whatever text hasn't been written,
-                # but the pager is still in control of the terminal.
-                pass
-    except OSError:
-        pass # Ignore broken pipes caused by quitting the pager program.
-    while True:
-        try:
-            proc.wait()
-            break
-        except KeyboardInterrupt:
-            # Ignore ctl-c like the pager itself does.  Otherwise the pager is
-            # left running and the terminal is in raw mode and unusable.
-            pass
-
-def tempfilepager(text, cmd):
-    """Page through text by invoking a program on a temporary file."""
-    import tempfile
-    filename = tempfile.mktemp()
-    with open(filename, 'w', errors='backslashreplace') as file:
-        file.write(text)
-    try:
-        os.system(cmd + ' "' + filename + '"')
-    finally:
-        os.unlink(filename)
-
-def _escape_stdout(text):
-    # Escape non-encodable characters to avoid encoding errors later
-    encoding = getattr(sys.stdout, 'encoding', None) or 'utf-8'
-    return text.encode(encoding, 'backslashreplace').decode(encoding)
-
-def ttypager(text):
-    """Page through text on a text terminal."""
-    lines = plain(_escape_stdout(text)).split('\n')
-    try:
-        import tty
-        fd = sys.stdin.fileno()
-        old = tty.tcgetattr(fd)
-        tty.setcbreak(fd)
-        getchar = lambda: sys.stdin.read(1)
-    except (ImportError, AttributeError, io.UnsupportedOperation):
-        tty = None
-        getchar = lambda: sys.stdin.readline()[:-1][:1]
-
-    try:
-        try:
-            h = int(os.environ.get('LINES', 0))
-        except ValueError:
-            h = 0
-        if h <= 1:
-            h = 25
-        r = inc = h - 1
-        sys.stdout.write('\n'.join(lines[:inc]) + '\n')
-        while lines[r:]:
-            sys.stdout.write('-- more --')
-            sys.stdout.flush()
-            c = getchar()
-
-            if c in ('q', 'Q'):
-                sys.stdout.write('\r          \r')
-                break
-            elif c in ('\r', '\n'):
-                sys.stdout.write('\r          \r' + lines[r] + '\n')
-                r = r + 1
-                continue
-            if c in ('b', 'B', '\x1b'):
-                r = r - inc - inc
-                if r < 0: r = 0
-            sys.stdout.write('\n' + '\n'.join(lines[r:r+inc]) + '\n')
-            r = r + inc
-
-    finally:
-        if tty:
-            tty.tcsetattr(fd, tty.TCSAFLUSH, old)
-
-def plainpager(text):
-    """Simply print unformatted text.  This is the ultimate fallback."""
-    sys.stdout.write(plain(_escape_stdout(text)))
+    pager = get_pager()
+    pager(text, title)
 
 def describe(thing):
     """Produce a short description of the given thing."""
@@ -1569,6 +1707,13 @@ def describe(thing):
         return 'function ' + thing.__name__
     if inspect.ismethod(thing):
         return 'method ' + thing.__name__
+    if inspect.ismethodwrapper(thing):
+        return 'method wrapper ' + thing.__name__
+    if inspect.ismethoddescriptor(thing):
+        try:
+            return 'method descriptor ' + thing.__name__
+        except AttributeError:
+            pass
     return type(thing).__name__
 
 def locate(path, forceload=0):
@@ -1626,36 +1771,49 @@ def render_doc(thing, title='Python Library Documentation: %s', forceload=0,
     if not (inspect.ismodule(object) or
               inspect.isclass(object) or
               inspect.isroutine(object) or
-              inspect.isgetsetdescriptor(object) or
-              inspect.ismemberdescriptor(object) or
-              isinstance(object, property)):
+              inspect.isdatadescriptor(object) or
+              _getdoc(object)):
         # If the passed object is a piece of data or an instance,
         # document its available methods instead of its value.
-        object = type(object)
-        desc += ' object'
+        if hasattr(object, '__origin__'):
+            object = object.__origin__
+        else:
+            object = type(object)
+            desc += ' object'
     return title % desc + '\n\n' + renderer.document(object, name)
 
 def doc(thing, title='Python Library Documentation: %s', forceload=0,
-        output=None):
+        output=None, is_cli=False):
     """Display text documentation, given an object or a path to an object."""
-    try:
-        if output is None:
-            pager(render_doc(thing, title, forceload))
-        else:
-            output.write(render_doc(thing, title, forceload, plaintext))
-    except (ImportError, ErrorDuringImport) as value:
-        print(value)
+    if output is None:
+        try:
+            if isinstance(thing, str):
+                what = thing
+            else:
+                what = getattr(thing, '__qualname__', None)
+                if not isinstance(what, str):
+                    what = getattr(thing, '__name__', None)
+                    if not isinstance(what, str):
+                        what = type(thing).__name__ + ' object'
+            pager(render_doc(thing, title, forceload), f'Help on {what!s}')
+        except ImportError as exc:
+            if is_cli:
+                raise
+            print(exc)
+    else:
+        try:
+            s = render_doc(thing, title, forceload, plaintext)
+        except ImportError as exc:
+            s = str(exc)
+        output.write(s)
 
 def writedoc(thing, forceload=0):
     """Write HTML documentation to a file in the current directory."""
-    try:
-        object, name = resolve(thing, forceload)
-        page = html.page(describe(object), html.document(object, name))
-        with open(name + '.html', 'w', encoding='utf-8') as file:
-            file.write(page)
-        print('wrote', name + '.html')
-    except (ImportError, ErrorDuringImport) as value:
-        print(value)
+    object, name = resolve(thing, forceload)
+    page = html.page(describe(object), html.document(object, name))
+    with open(name + '.html', 'w', encoding='utf-8') as file:
+        file.write(page)
+    print('wrote', name + '.html')
 
 def writedocs(dir, pkgpath='', done=None):
     """Write out HTML documentation for all modules in a directory tree."""
@@ -1664,6 +1822,37 @@ def writedocs(dir, pkgpath='', done=None):
         writedoc(modname)
     return
 
+
+def _introdoc():
+    import textwrap
+    ver = '%d.%d' % sys.version_info[:2]
+    if os.environ.get('PYTHON_BASIC_REPL'):
+        pyrepl_keys = ''
+    else:
+        # Additional help for keyboard shortcuts if enhanced REPL is used.
+        pyrepl_keys = '''
+        You can use the following keyboard shortcuts at the main interpreter prompt.
+        F1: enter interactive help, F2: enter history browsing mode, F3: enter paste
+        mode (press again to exit).
+        '''
+    return textwrap.dedent(f'''\
+        Welcome to Python {ver}'s help utility! If this is your first time using
+        Python, you should definitely check out the tutorial at
+        https://docs.python.org/{ver}/tutorial/.
+
+        Enter the name of any module, keyword, or topic to get help on writing
+        Python programs and using Python modules.  To get a list of available
+        modules, keywords, symbols, or topics, enter "modules", "keywords",
+        "symbols", or "topics".
+        {pyrepl_keys}
+        Each module also comes with a one-line summary of what it does; to list
+        the modules whose name or summary contain a given string such as "spam",
+        enter "modules spam".
+
+        To quit this help utility and return to the interpreter,
+        enter "q", "quit" or "exit".
+    ''')
+
 class Helper:
 
     # These dictionaries map a topic name to either an alias, or a tuple
@@ -1672,7 +1861,7 @@ class Helper:
     # in pydoc_data/topics.py.
     #
     # CAUTION: if you change one of these dictionaries, be sure to adapt the
-    #          list of needed labels in Doc/tools/pyspecific.py and
+    #          list of needed labels in Doc/tools/extensions/pyspecific.py and
     #          regenerate the pydoc_data/topics.py file by running
     #              make pydoc-topics
     #          in Doc/ and copying the output file into the Lib/ directory.
@@ -1684,6 +1873,8 @@ class Helper:
         'and': 'BOOLEAN',
         'as': 'with',
         'assert': ('assert', ''),
+        'async': ('async', ''),
+        'await': ('await', ''),
         'break': ('break', 'while for'),
         'class': ('class', 'CLASSES SPECIALMETHODS'),
         'continue': ('continue', 'while for'),
@@ -1735,6 +1926,7 @@ class Helper:
         ':': 'SLICINGS DICTIONARYLITERALS',
         '@': 'def class',
         '\\': 'STRINGS',
+        ':=': 'ASSIGNMENTEXPRESSIONS',
         '_': 'PRIVATENAMES',
         '__': 'PRIVATENAMES SPECIALMETHODS',
         '`': 'BACKQUOTES',
@@ -1749,6 +1941,7 @@ class Helper:
             if topic not in topics:
                 topics = topics + ' ' + topic
             symbols[symbol] = topics
+    del topic, symbols_, symbol, topics
 
     topics = {
         'TYPES': ('types', 'STRINGS UNICODE NUMBERS SEQUENCES MAPPINGS '
@@ -1827,6 +2020,7 @@ class Helper:
         'ASSERTION': 'assert',
         'ASSIGNMENT': ('assignment', 'AUGMENTEDASSIGNMENT'),
         'AUGMENTEDASSIGNMENT': ('augassign', 'NUMBERMETHODS'),
+        'ASSIGNMENTEXPRESSIONS': ('assignment-expressions', ''),
         'DELETION': 'del',
         'RETURNING': 'return',
         'IMPORTING': 'import',
@@ -1841,8 +2035,13 @@ def __init__(self, input=None, output=None):
         self._input = input
         self._output = output
 
-    input  = property(lambda self: self._input or sys.stdin)
-    output = property(lambda self: self._output or sys.stdout)
+    @property
+    def input(self):
+        return self._input or sys.stdin
+
+    @property
+    def output(self):
+        return self._output or sys.stdout
 
     def __repr__(self):
         if inspect.stack()[1][3] == '?':
@@ -1854,7 +2053,10 @@ def __repr__(self):
     _GoInteractive = object()
     def __call__(self, request=_GoInteractive):
         if request is not self._GoInteractive:
-            self.help(request)
+            try:
+                self.help(request)
+            except ImportError as err:
+                self.output.write(f'{err}\n')
         else:
             self.intro()
             self.interact()
@@ -1870,17 +2072,18 @@ def interact(self):
         while True:
             try:
                 request = self.getline('help> ')
-                if not request: break
             except (KeyboardInterrupt, EOFError):
                 break
             request = request.strip()
+            if not request:
+                continue  # back to the prompt
 
             # Make sure significant trailing quoting marks of literals don't
             # get deleted while cleaning input
             if (len(request) > 2 and request[0] == request[-1] in ("'", '"')
                     and request[0] not in request[1:-1]):
                 request = request[1:-1]
-            if request.lower() in ('q', 'quit'): break
+            if request.lower() in ('q', 'quit', 'exit'): break
             if request == 'help':
                 self.intro()
             else:
@@ -1895,8 +2098,8 @@ def getline(self, prompt):
             self.output.flush()
             return self.input.readline()
 
-    def help(self, request):
-        if type(request) is type(''):
+    def help(self, request, is_cli=False):
+        if isinstance(request, str):
             request = request.strip()
             if request == 'keywords': self.listkeywords()
             elif request == 'symbols': self.listsymbols()
@@ -1907,34 +2110,20 @@ def help(self, request):
             elif request in self.symbols: self.showsymbol(request)
             elif request in ['True', 'False', 'None']:
                 # special case these keywords since they are objects too
-                doc(eval(request), 'Help on %s:')
+                doc(eval(request), 'Help on %s:', output=self._output, is_cli=is_cli)
             elif request in self.keywords: self.showtopic(request)
             elif request in self.topics: self.showtopic(request)
-            elif request: doc(request, 'Help on %s:', output=self._output)
-            else: doc(str, 'Help on %s:', output=self._output)
+            elif request: doc(request, 'Help on %s:', output=self._output, is_cli=is_cli)
+            else: doc(str, 'Help on %s:', output=self._output, is_cli=is_cli)
         elif isinstance(request, Helper): self()
-        else: doc(request, 'Help on %s:', output=self._output)
+        else: doc(request, 'Help on %s:', output=self._output, is_cli=is_cli)
         self.output.write('\n')
 
     def intro(self):
-        self.output.write('''
-Welcome to Python {0}'s help utility!
-
-If this is your first time using Python, you should definitely check out
-the tutorial on the Internet at https://docs.python.org/{0}/tutorial/.
-
-Enter the name of any module, keyword, or topic to get help on writing
-Python programs and using Python modules.  To quit this help utility and
-return to the interpreter, just type "quit".
-
-To get a list of available modules, keywords, symbols, or topics, type
-"modules", "keywords", "symbols", or "topics".  Each module also comes
-with a one-line summary of what it does; to list the modules whose name
-or summary contain a given string such as "spam", type "modules spam".
-'''.format('%d.%d' % sys.version_info[:2]))
+        self.output.write(_introdoc())
 
     def list(self, items, columns=4, width=80):
-        items = list(sorted(items))
+        items = sorted(items)
         colw = width // columns
         rows = (len(items) + columns - 1) // columns
         for row in range(rows):
@@ -1966,7 +2155,7 @@ def listtopics(self):
 Here is a list of available topics.  Enter any topic name to get more help.
 
 ''')
-        self.list(self.topics.keys())
+        self.list(self.topics.keys(), columns=3)
 
     def showtopic(self, topic, more_xrefs=''):
         try:
@@ -1981,7 +2170,7 @@ def showtopic(self, topic, more_xrefs=''):
         if not target:
             self.output.write('no documentation found for %s\n' % repr(topic))
             return
-        if type(target) is type(''):
+        if isinstance(target, str):
             return self.showtopic(target, more_xrefs)
 
         label, xrefs = target
@@ -1998,7 +2187,11 @@ def showtopic(self, topic, more_xrefs=''):
             text = 'Related help topics: ' + ', '.join(xrefs.split()) + '\n'
             wrapped_text = textwrap.wrap(text, 72)
             doc += '\n%s\n' % '\n'.join(wrapped_text)
-        pager(doc)
+
+        if self._output is None:
+            pager(doc, f'Help on {topic!s}')
+        else:
+            self.output.write(doc)
 
     def _gettopic(self, topic, more_xrefs=''):
         """Return unbuffered tuple of (topic, xrefs).
@@ -2090,7 +2283,7 @@ def run(self, callback, key=None, completer=None, onerror=None):
                 callback(None, modname, '')
             else:
                 try:
-                    spec = pkgutil._get_spec(importer, modname)
+                    spec = importer.find_spec(modname)
                 except SyntaxError:
                     # raised by tests for bad coding cookies or BOM
                     continue
@@ -2135,13 +2328,13 @@ def onerror(modname):
         warnings.filterwarnings('ignore') # ignore problems during import
         ModuleScanner().run(callback, key, onerror=onerror)
 
-# --------------------------------------- enhanced Web browser interface
+# --------------------------------------- enhanced web browser interface
 
-def _start_server(urlhandler, port):
+def _start_server(urlhandler, hostname, port):
     """Start an HTTP server thread on a specific port.
 
     Start an HTML/text server thread, so HTML or text documents can be
-    browsed dynamically and interactively with a Web browser.  Example use:
+    browsed dynamically and interactively with a web browser.  Example use:
 
         >>> import time
         >>> import pydoc
@@ -2177,14 +2370,14 @@ def _start_server(urlhandler, port):
         Let the server do its thing. We just need to monitor its status.
         Use time.sleep so the loop doesn't hog the CPU.
 
-        >>> starttime = time.time()
+        >>> starttime = time.monotonic()
         >>> timeout = 1                    #seconds
 
         This is a short timeout for testing purposes.
 
         >>> while serverthread.serving:
         ...     time.sleep(.01)
-        ...     if serverthread.serving and time.time() - starttime > timeout:
+        ...     if serverthread.serving and time.monotonic() - starttime > timeout:
         ...          serverthread.stop()
         ...          break
 
@@ -2222,8 +2415,8 @@ def log_message(self, *args):
 
     class DocServer(http.server.HTTPServer):
 
-        def __init__(self, port, callback):
-            self.host = 'localhost'
+        def __init__(self, host, port, callback):
+            self.host = host
             self.address = (self.host, port)
             self.callback = callback
             self.base.__init__(self, self.address, self.handler)
@@ -2243,12 +2436,14 @@ def server_activate(self):
 
     class ServerThread(threading.Thread):
 
-        def __init__(self, urlhandler, port):
+        def __init__(self, urlhandler, host, port):
             self.urlhandler = urlhandler
+            self.host = host
             self.port = int(port)
             threading.Thread.__init__(self)
             self.serving = False
             self.error = None
+            self.docserver = None
 
         def run(self):
             """Start the server."""
@@ -2257,11 +2452,11 @@ def run(self):
                 DocServer.handler = DocHandler
                 DocHandler.MessageClass = email.message.Message
                 DocHandler.urlhandler = staticmethod(self.urlhandler)
-                docsvr = DocServer(self.port, self.ready)
+                docsvr = DocServer(self.host, self.port, self.ready)
                 self.docserver = docsvr
                 docsvr.serve_until_quit()
-            except Exception as e:
-                self.error = e
+            except Exception as err:
+                self.error = err
 
         def ready(self, server):
             self.serving = True
@@ -2279,11 +2474,11 @@ def stop(self):
             self.serving = False
             self.url = None
 
-    thread = ServerThread(urlhandler, port)
+    thread = ServerThread(urlhandler, hostname, port)
     thread.start()
-    # Wait until thread.serving is True to make sure we are
-    # really up before returning.
-    while not thread.error and not thread.serving:
+    # Wait until thread.serving is True and thread.docserver is set
+    # to make sure we are really up before returning.
+    while not thread.error and not (thread.serving and thread.docserver):
         time.sleep(.01)
     return thread
 
@@ -2306,15 +2501,14 @@ def page(self, title, contents):
                 '<link rel="stylesheet" type="text/css" href="%s">' %
                 css_path)
             return '''\
-<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
-<html><head><title>Pydoc: %s</title>
-<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
-%s</head><body bgcolor="#f0f0f8">%s<div style="clear:both;padding-top:.5em;">%s</div>
+<!DOCTYPE>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<title>Pydoc: %s</title>
+%s</head><body>%s<div style="clear:both;padding-top:.5em;">%s</div>
 </body></html>''' % (title, css_link, html_navbar(), contents)
 
-        def filelink(self, url, path):
-            return '<a href="getfile?key=%s">%s</a>' % (url, path)
-
 
     html = _HTMLDoc()
 
@@ -2352,22 +2546,21 @@ def bltinlink(name):
             return '<a href="%s.html">%s</a>' % (name, name)
 
         heading = html.heading(
-            '<big><big><strong>Index of Modules</strong></big></big>',
-            '#ffffff', '#7799ee')
+            '<strong class="title">Index of Modules</strong>'
+        )
         names = [name for name in sys.builtin_module_names
                  if name != '__main__']
         contents = html.multicolumn(names, bltinlink)
         contents = [heading, '<p>' + html.bigsection(
-            'Built-in Modules', '#ffffff', '#ee77aa', contents)]
+            'Built-in Modules', 'index', contents)]
 
         seen = {}
         for dir in sys.path:
             contents.append(html.index(dir, seen))
 
         contents.append(
-            '<p align=right><font color="#909090" face="helvetica,'
-            'arial"><strong>pydoc</strong> by Ka-Ping Yee'
-            '&lt;ping@lfw.org&gt;</font>')
+            '<p align=right class="heading-text grey"><strong>pydoc</strong> by Ka-Ping Yee'
+            '&lt;ping@lfw.org&gt;</p>')
         return 'Index of Modules', ''.join(contents)
 
     def html_search(key):
@@ -2392,27 +2585,14 @@ def bltinlink(name):
 
         results = []
         heading = html.heading(
-            '<big><big><strong>Search Results</strong></big></big>',
-            '#ffffff', '#7799ee')
+            '<strong class="title">Search Results</strong>',
+        )
         for name, desc in search_result:
             results.append(bltinlink(name) + desc)
         contents = heading + html.bigsection(
-            'key = %s' % key, '#ffffff', '#ee77aa', '<br>'.join(results))
+            'key = %s' % key, 'index', '<br>'.join(results))
         return 'Search Results', contents
 
-    def html_getfile(path):
-        """Get and display a source file listing safely."""
-        path = urllib.parse.unquote(path)
-        with tokenize.open(path) as fp:
-            lines = html.escape(fp.read())
-        body = '<pre>%s</pre>' % lines
-        heading = html.heading(
-            '<big><big><strong>File Listing</strong></big></big>',
-            '#ffffff', '#7799ee')
-        contents = heading + html.bigsection(
-            'File: %s' % path, '#ffffff', '#ee77aa', body)
-        return 'getfile %s' % path, contents
-
     def html_topics():
         """Index of topic texts available."""
 
@@ -2420,20 +2600,20 @@ def bltinlink(name):
             return '<a href="topic?key=%s">%s</a>' % (name, name)
 
         heading = html.heading(
-            '<big><big><strong>INDEX</strong></big></big>',
-            '#ffffff', '#7799ee')
+            '<strong class="title">INDEX</strong>',
+        )
         names = sorted(Helper.topics.keys())
 
         contents = html.multicolumn(names, bltinlink)
         contents = heading + html.bigsection(
-            'Topics', '#ffffff', '#ee77aa', contents)
+            'Topics', 'index', contents)
         return 'Topics', contents
 
     def html_keywords():
         """Index of keywords."""
         heading = html.heading(
-            '<big><big><strong>INDEX</strong></big></big>',
-            '#ffffff', '#7799ee')
+            '<strong class="title">INDEX</strong>',
+        )
         names = sorted(Helper.keywords.keys())
 
         def bltinlink(name):
@@ -2441,7 +2621,7 @@ def bltinlink(name):
 
         contents = html.multicolumn(names, bltinlink)
         contents = heading + html.bigsection(
-            'Keywords', '#ffffff', '#ee77aa', contents)
+            'Keywords', 'index', contents)
         return 'Keywords', contents
 
     def html_topicpage(topic):
@@ -2454,10 +2634,10 @@ def html_topicpage(topic):
         else:
             title = 'TOPIC'
         heading = html.heading(
-            '<big><big><strong>%s</strong></big></big>' % title,
-            '#ffffff', '#7799ee')
+            '<strong class="title">%s</strong>' % title,
+        )
         contents = '<pre>%s</pre>' % html.markup(contents)
-        contents = html.bigsection(topic , '#ffffff','#ee77aa', contents)
+        contents = html.bigsection(topic , 'index', contents)
         if xrefs:
             xrefs = sorted(xrefs.split())
 
@@ -2465,8 +2645,7 @@ def bltinlink(name):
                 return '<a href="topic?key=%s">%s</a>' % (name, name)
 
             xrefs = html.multicolumn(xrefs, bltinlink)
-            xrefs = html.section('Related help topics: ',
-                                 '#ffffff', '#ee77aa', xrefs)
+            xrefs = html.section('Related help topics: ', 'index', xrefs)
         return ('%s %s' % (title, topic),
                 ''.join((heading, contents, xrefs)))
 
@@ -2480,12 +2659,11 @@ def html_getobj(url):
 
     def html_error(url, exc):
         heading = html.heading(
-            '<big><big><strong>Error</strong></big></big>',
-            '#ffffff', '#7799ee')
+            '<strong class="title">Error</strong>',
+        )
         contents = '<br>'.join(html.escape(line) for line in
                                format_exception_only(type(exc), exc))
-        contents = heading + html.bigsection(url, '#ffffff', '#bb0000',
-                                             contents)
+        contents = heading + html.bigsection(url, 'error', contents)
         return "Error - %s" % url, contents
 
     def get_html_page(url):
@@ -2504,8 +2682,6 @@ def get_html_page(url):
                 op, _, url = url.partition('=')
                 if op == "search?key":
                     title, content = html_search(url)
-                elif op == "getfile?key":
-                    title, content = html_getfile(url)
                 elif op == "topic?key":
                     # try topics first, then objects.
                     try:
@@ -2543,14 +2719,14 @@ def get_html_page(url):
     raise TypeError('unknown content type %r for url %s' % (content_type, url))
 
 
-def browse(port=0, *, open_browser=True):
-    """Start the enhanced pydoc Web server and open a Web browser.
+def browse(port=0, *, open_browser=True, hostname='localhost'):
+    """Start the enhanced pydoc web server and open a web browser.
 
     Use port '0' to start the server on an arbitrary port.
     Set open_browser to False to suppress opening a browser.
     """
     import webbrowser
-    serverthread = _start_server(_url_handler, port)
+    serverthread = _start_server(_url_handler, hostname, port)
     if serverthread.error:
         print(serverthread.error)
         return
@@ -2583,25 +2759,58 @@ def browse(port=0, *, open_browser=True):
 def ispath(x):
     return isinstance(x, str) and x.find(os.sep) >= 0
 
+def _get_revised_path(given_path, argv0):
+    """Ensures current directory is on returned path, and argv0 directory is not
+
+    Exception: argv0 dir is left alone if it's also pydoc's directory.
+
+    Returns a new path entry list, or None if no adjustment is needed.
+    """
+    # Scripts may get the current directory in their path by default if they're
+    # run with the -m switch, or directly from the current directory.
+    # The interactive prompt also allows imports from the current directory.
+
+    # Accordingly, if the current directory is already present, don't make
+    # any changes to the given_path
+    if '' in given_path or os.curdir in given_path or os.getcwd() in given_path:
+        return None
+
+    # Otherwise, add the current directory to the given path, and remove the
+    # script directory (as long as the latter isn't also pydoc's directory.
+    stdlib_dir = os.path.dirname(__file__)
+    script_dir = os.path.dirname(argv0)
+    revised_path = given_path.copy()
+    if script_dir in given_path and not os.path.samefile(script_dir, stdlib_dir):
+        revised_path.remove(script_dir)
+    revised_path.insert(0, os.getcwd())
+    return revised_path
+
+
+# Note: the tests only cover _get_revised_path, not _adjust_cli_path itself
+def _adjust_cli_sys_path():
+    """Ensures current directory is on sys.path, and __main__ directory is not.
+
+    Exception: __main__ dir is left alone if it's also pydoc's directory.
+    """
+    revised_path = _get_revised_path(sys.path, sys.argv[0])
+    if revised_path is not None:
+        sys.path[:] = revised_path
+
+
 def cli():
     """Command-line interface (looks at sys.argv to decide what to do)."""
     import getopt
     class BadUsage(Exception): pass
 
-    # Scripts don't get the current directory in their path by default
-    # unless they are run with the '-m' switch
-    if '' not in sys.path:
-        scriptdir = os.path.dirname(sys.argv[0])
-        if scriptdir in sys.path:
-            sys.path.remove(scriptdir)
-        sys.path.insert(0, '.')
+    _adjust_cli_sys_path()
 
     try:
-        opts, args = getopt.getopt(sys.argv[1:], 'bk:p:w')
+        opts, args = getopt.getopt(sys.argv[1:], 'bk:n:p:w')
         writing = False
         start_server = False
         open_browser = False
-        port = None
+        port = 0
+        hostname = 'localhost'
         for opt, val in opts:
             if opt == '-b':
                 start_server = True
@@ -2614,18 +2823,19 @@ class BadUsage(Exception): pass
                 port = val
             if opt == '-w':
                 writing = True
+            if opt == '-n':
+                start_server = True
+                hostname = val
 
         if start_server:
-            if port is None:
-                port = 0
-            browse(port, open_browser=open_browser)
+            browse(port, hostname=hostname, open_browser=open_browser)
             return
 
         if not args: raise BadUsage
         for arg in args:
             if ispath(arg) and not os.path.exists(arg):
                 print('file %r does not exist' % arg)
-                break
+                sys.exit(1)
             try:
                 if ispath(arg) and os.path.isfile(arg):
                     arg = importfile(arg)
@@ -2635,9 +2845,10 @@ class BadUsage(Exception): pass
                     else:
                         writedoc(arg)
                 else:
-                    help.help(arg)
-            except ErrorDuringImport as value:
+                    help.help(arg, is_cli=True)
+            except (ImportError, ErrorDuringImport) as value:
                 print(value)
+                sys.exit(1)
 
     except (getopt.error, BadUsage):
         cmd = os.path.splitext(os.path.basename(sys.argv[0]))[0]
@@ -2654,14 +2865,17 @@ class BadUsage(Exception): pass
 {cmd} -k <keyword>
     Search for a keyword in the synopsis lines of all available modules.
 
+{cmd} -n <hostname>
+    Start an HTTP server with the given hostname (default: localhost).
+
 {cmd} -p <port>
     Start an HTTP server on the given port on the local machine.  Port
     number 0 can be used to get an arbitrary unused port.
 
 {cmd} -b
-    Start an HTTP server on an arbitrary unused port and open a Web browser
-    to interactively browse documentation.  The -p option can be used with
-    the -b option to explicitly specify the server port.
+    Start an HTTP server on an arbitrary unused port and open a web browser
+    to interactively browse documentation.  This option can be used in
+    combination with -n and/or -p.
 
 {cmd} -w <name> ...
     Write out the HTML documentation for a module to a file in the current
diff --git a/Lib/pydoc_data/module_docs.py b/Lib/pydoc_data/module_docs.py
new file mode 100644
index 00000000000..2a6ede3aa14
--- /dev/null
+++ b/Lib/pydoc_data/module_docs.py
@@ -0,0 +1,320 @@
+# Autogenerated by Sphinx on Tue Feb  3 17:32:13 2026
+# as part of the release process.
+
+module_docs = {
+    '__future__': '__future__#module-__future__',
+    '__main__': '__main__#module-__main__',
+    '_thread': '_thread#module-_thread',
+    '_tkinter': 'tkinter#module-_tkinter',
+    'abc': 'abc#module-abc',
+    'aifc': 'aifc#module-aifc',
+    'annotationlib': 'annotationlib#module-annotationlib',
+    'argparse': 'argparse#module-argparse',
+    'array': 'array#module-array',
+    'ast': 'ast#module-ast',
+    'asynchat': 'asynchat#module-asynchat',
+    'asyncio': 'asyncio#module-asyncio',
+    'asyncore': 'asyncore#module-asyncore',
+    'atexit': 'atexit#module-atexit',
+    'audioop': 'audioop#module-audioop',
+    'base64': 'base64#module-base64',
+    'bdb': 'bdb#module-bdb',
+    'binascii': 'binascii#module-binascii',
+    'bisect': 'bisect#module-bisect',
+    'builtins': 'builtins#module-builtins',
+    'bz2': 'bz2#module-bz2',
+    'cProfile': 'profile#module-cProfile',
+    'calendar': 'calendar#module-calendar',
+    'cgi': 'cgi#module-cgi',
+    'cgitb': 'cgitb#module-cgitb',
+    'chunk': 'chunk#module-chunk',
+    'cmath': 'cmath#module-cmath',
+    'cmd': 'cmd#module-cmd',
+    'code': 'code#module-code',
+    'codecs': 'codecs#module-codecs',
+    'codeop': 'codeop#module-codeop',
+    'collections': 'collections#module-collections',
+    'collections.abc': 'collections.abc#module-collections.abc',
+    'colorsys': 'colorsys#module-colorsys',
+    'compileall': 'compileall#module-compileall',
+    'compression': 'compression#module-compression',
+    'compression.zstd': 'compression.zstd#module-compression.zstd',
+    'concurrent.futures': 'concurrent.futures#module-concurrent.futures',
+    'concurrent.interpreters': 'concurrent.interpreters#module-concurrent.interpreters',
+    'configparser': 'configparser#module-configparser',
+    'contextlib': 'contextlib#module-contextlib',
+    'contextvars': 'contextvars#module-contextvars',
+    'copy': 'copy#module-copy',
+    'copyreg': 'copyreg#module-copyreg',
+    'crypt': 'crypt#module-crypt',
+    'csv': 'csv#module-csv',
+    'ctypes': 'ctypes#module-ctypes',
+    'curses': 'curses#module-curses',
+    'curses.ascii': 'curses.ascii#module-curses.ascii',
+    'curses.panel': 'curses.panel#module-curses.panel',
+    'curses.textpad': 'curses#module-curses.textpad',
+    'dataclasses': 'dataclasses#module-dataclasses',
+    'datetime': 'datetime#module-datetime',
+    'dbm': 'dbm#module-dbm',
+    'dbm.dumb': 'dbm#module-dbm.dumb',
+    'dbm.gnu': 'dbm#module-dbm.gnu',
+    'dbm.ndbm': 'dbm#module-dbm.ndbm',
+    'dbm.sqlite3': 'dbm#module-dbm.sqlite3',
+    'decimal': 'decimal#module-decimal',
+    'difflib': 'difflib#module-difflib',
+    'dis': 'dis#module-dis',
+    'distutils': 'distutils#module-distutils',
+    'doctest': 'doctest#module-doctest',
+    'email': 'email#module-email',
+    'email.charset': 'email.charset#module-email.charset',
+    'email.contentmanager': 'email.contentmanager#module-email.contentmanager',
+    'email.encoders': 'email.encoders#module-email.encoders',
+    'email.errors': 'email.errors#module-email.errors',
+    'email.generator': 'email.generator#module-email.generator',
+    'email.header': 'email.header#module-email.header',
+    'email.headerregistry': 'email.headerregistry#module-email.headerregistry',
+    'email.iterators': 'email.iterators#module-email.iterators',
+    'email.message': 'email.message#module-email.message',
+    'email.mime': 'email.mime#module-email.mime',
+    'email.mime.application': 'email.mime#module-email.mime.application',
+    'email.mime.audio': 'email.mime#module-email.mime.audio',
+    'email.mime.base': 'email.mime#module-email.mime.base',
+    'email.mime.image': 'email.mime#module-email.mime.image',
+    'email.mime.message': 'email.mime#module-email.mime.message',
+    'email.mime.multipart': 'email.mime#module-email.mime.multipart',
+    'email.mime.nonmultipart': 'email.mime#module-email.mime.nonmultipart',
+    'email.mime.text': 'email.mime#module-email.mime.text',
+    'email.parser': 'email.parser#module-email.parser',
+    'email.policy': 'email.policy#module-email.policy',
+    'email.utils': 'email.utils#module-email.utils',
+    'encodings': 'codecs#module-encodings',
+    'encodings.idna': 'codecs#module-encodings.idna',
+    'encodings.mbcs': 'codecs#module-encodings.mbcs',
+    'encodings.utf_8_sig': 'codecs#module-encodings.utf_8_sig',
+    'ensurepip': 'ensurepip#module-ensurepip',
+    'enum': 'enum#module-enum',
+    'errno': 'errno#module-errno',
+    'faulthandler': 'faulthandler#module-faulthandler',
+    'fcntl': 'fcntl#module-fcntl',
+    'filecmp': 'filecmp#module-filecmp',
+    'fileinput': 'fileinput#module-fileinput',
+    'fnmatch': 'fnmatch#module-fnmatch',
+    'fractions': 'fractions#module-fractions',
+    'ftplib': 'ftplib#module-ftplib',
+    'functools': 'functools#module-functools',
+    'gc': 'gc#module-gc',
+    'getopt': 'getopt#module-getopt',
+    'getpass': 'getpass#module-getpass',
+    'gettext': 'gettext#module-gettext',
+    'glob': 'glob#module-glob',
+    'graphlib': 'graphlib#module-graphlib',
+    'grp': 'grp#module-grp',
+    'gzip': 'gzip#module-gzip',
+    'hashlib': 'hashlib#module-hashlib',
+    'heapq': 'heapq#module-heapq',
+    'hmac': 'hmac#module-hmac',
+    'html': 'html#module-html',
+    'html.entities': 'html.entities#module-html.entities',
+    'html.parser': 'html.parser#module-html.parser',
+    'http': 'http#module-http',
+    'http.client': 'http.client#module-http.client',
+    'http.cookiejar': 'http.cookiejar#module-http.cookiejar',
+    'http.cookies': 'http.cookies#module-http.cookies',
+    'http.server': 'http.server#module-http.server',
+    'idlelib': 'idle#module-idlelib',
+    'imaplib': 'imaplib#module-imaplib',
+    'imghdr': 'imghdr#module-imghdr',
+    'imp': 'imp#module-imp',
+    'importlib': 'importlib#module-importlib',
+    'importlib.abc': 'importlib#module-importlib.abc',
+    'importlib.machinery': 'importlib#module-importlib.machinery',
+    'importlib.metadata': 'importlib.metadata#module-importlib.metadata',
+    'importlib.resources': 'importlib.resources#module-importlib.resources',
+    'importlib.resources.abc': 'importlib.resources.abc#module-importlib.resources.abc',
+    'importlib.util': 'importlib#module-importlib.util',
+    'inspect': 'inspect#module-inspect',
+    'io': 'io#module-io',
+    'ipaddress': 'ipaddress#module-ipaddress',
+    'itertools': 'itertools#module-itertools',
+    'json': 'json#module-json',
+    'json.tool': 'json#module-json.tool',
+    'keyword': 'keyword#module-keyword',
+    'linecache': 'linecache#module-linecache',
+    'locale': 'locale#module-locale',
+    'logging': 'logging#module-logging',
+    'logging.config': 'logging.config#module-logging.config',
+    'logging.handlers': 'logging.handlers#module-logging.handlers',
+    'lzma': 'lzma#module-lzma',
+    'mailbox': 'mailbox#module-mailbox',
+    'mailcap': 'mailcap#module-mailcap',
+    'marshal': 'marshal#module-marshal',
+    'math': 'math#module-math',
+    'mimetypes': 'mimetypes#module-mimetypes',
+    'mmap': 'mmap#module-mmap',
+    'modulefinder': 'modulefinder#module-modulefinder',
+    'msilib': 'msilib#module-msilib',
+    'msvcrt': 'msvcrt#module-msvcrt',
+    'multiprocessing': 'multiprocessing#module-multiprocessing',
+    'multiprocessing.connection': 'multiprocessing#module-multiprocessing.connection',
+    'multiprocessing.dummy': 'multiprocessing#module-multiprocessing.dummy',
+    'multiprocessing.managers': 'multiprocessing#module-multiprocessing.managers',
+    'multiprocessing.pool': 'multiprocessing#module-multiprocessing.pool',
+    'multiprocessing.shared_memory': 'multiprocessing.shared_memory#module-multiprocessing.shared_memory',
+    'multiprocessing.sharedctypes': 'multiprocessing#module-multiprocessing.sharedctypes',
+    'netrc': 'netrc#module-netrc',
+    'nis': 'nis#module-nis',
+    'nntplib': 'nntplib#module-nntplib',
+    'numbers': 'numbers#module-numbers',
+    'operator': 'operator#module-operator',
+    'optparse': 'optparse#module-optparse',
+    'os': 'os#module-os',
+    'os.path': 'os.path#module-os.path',
+    'ossaudiodev': 'ossaudiodev#module-ossaudiodev',
+    'pathlib': 'pathlib#module-pathlib',
+    'pathlib.types': 'pathlib#module-pathlib.types',
+    'pdb': 'pdb#module-pdb',
+    'pickle': 'pickle#module-pickle',
+    'pickletools': 'pickletools#module-pickletools',
+    'pipes': 'pipes#module-pipes',
+    'pkgutil': 'pkgutil#module-pkgutil',
+    'platform': 'platform#module-platform',
+    'plistlib': 'plistlib#module-plistlib',
+    'poplib': 'poplib#module-poplib',
+    'posix': 'posix#module-posix',
+    'pprint': 'pprint#module-pprint',
+    'profile': 'profile#module-profile',
+    'pstats': 'profile#module-pstats',
+    'pty': 'pty#module-pty',
+    'pwd': 'pwd#module-pwd',
+    'py_compile': 'py_compile#module-py_compile',
+    'pyclbr': 'pyclbr#module-pyclbr',
+    'pydoc': 'pydoc#module-pydoc',
+    'queue': 'queue#module-queue',
+    'quopri': 'quopri#module-quopri',
+    'random': 'random#module-random',
+    're': 're#module-re',
+    'readline': 'readline#module-readline',
+    'reprlib': 'reprlib#module-reprlib',
+    'resource': 'resource#module-resource',
+    'rlcompleter': 'rlcompleter#module-rlcompleter',
+    'runpy': 'runpy#module-runpy',
+    'sched': 'sched#module-sched',
+    'secrets': 'secrets#module-secrets',
+    'select': 'select#module-select',
+    'selectors': 'selectors#module-selectors',
+    'shelve': 'shelve#module-shelve',
+    'shlex': 'shlex#module-shlex',
+    'shutil': 'shutil#module-shutil',
+    'signal': 'signal#module-signal',
+    'site': 'site#module-site',
+    'sitecustomize': 'site#module-sitecustomize',
+    'smtpd': 'smtpd#module-smtpd',
+    'smtplib': 'smtplib#module-smtplib',
+    'sndhdr': 'sndhdr#module-sndhdr',
+    'socket': 'socket#module-socket',
+    'socketserver': 'socketserver#module-socketserver',
+    'spwd': 'spwd#module-spwd',
+    'sqlite3': 'sqlite3#module-sqlite3',
+    'ssl': 'ssl#module-ssl',
+    'stat': 'stat#module-stat',
+    'statistics': 'statistics#module-statistics',
+    'string': 'string#module-string',
+    'string.templatelib': 'string.templatelib#module-string.templatelib',
+    'stringprep': 'stringprep#module-stringprep',
+    'struct': 'struct#module-struct',
+    'subprocess': 'subprocess#module-subprocess',
+    'sunau': 'sunau#module-sunau',
+    'symtable': 'symtable#module-symtable',
+    'sys': 'sys#module-sys',
+    'sys.monitoring': 'sys.monitoring#module-sys.monitoring',
+    'sysconfig': 'sysconfig#module-sysconfig',
+    'syslog': 'syslog#module-syslog',
+    'tabnanny': 'tabnanny#module-tabnanny',
+    'tarfile': 'tarfile#module-tarfile',
+    'telnetlib': 'telnetlib#module-telnetlib',
+    'tempfile': 'tempfile#module-tempfile',
+    'termios': 'termios#module-termios',
+    'test': 'test#module-test',
+    'test.regrtest': 'test#module-test.regrtest',
+    'test.support': 'test#module-test.support',
+    'test.support.bytecode_helper': 'test#module-test.support.bytecode_helper',
+    'test.support.import_helper': 'test#module-test.support.import_helper',
+    'test.support.os_helper': 'test#module-test.support.os_helper',
+    'test.support.script_helper': 'test#module-test.support.script_helper',
+    'test.support.socket_helper': 'test#module-test.support.socket_helper',
+    'test.support.threading_helper': 'test#module-test.support.threading_helper',
+    'test.support.warnings_helper': 'test#module-test.support.warnings_helper',
+    'textwrap': 'textwrap#module-textwrap',
+    'threading': 'threading#module-threading',
+    'time': 'time#module-time',
+    'timeit': 'timeit#module-timeit',
+    'tkinter': 'tkinter#module-tkinter',
+    'tkinter.colorchooser': 'tkinter.colorchooser#module-tkinter.colorchooser',
+    'tkinter.commondialog': 'dialog#module-tkinter.commondialog',
+    'tkinter.dnd': 'tkinter.dnd#module-tkinter.dnd',
+    'tkinter.filedialog': 'dialog#module-tkinter.filedialog',
+    'tkinter.font': 'tkinter.font#module-tkinter.font',
+    'tkinter.messagebox': 'tkinter.messagebox#module-tkinter.messagebox',
+    'tkinter.scrolledtext': 'tkinter.scrolledtext#module-tkinter.scrolledtext',
+    'tkinter.simpledialog': 'dialog#module-tkinter.simpledialog',
+    'tkinter.ttk': 'tkinter.ttk#module-tkinter.ttk',
+    'token': 'token#module-token',
+    'tokenize': 'tokenize#module-tokenize',
+    'tomllib': 'tomllib#module-tomllib',
+    'trace': 'trace#module-trace',
+    'traceback': 'traceback#module-traceback',
+    'tracemalloc': 'tracemalloc#module-tracemalloc',
+    'tty': 'tty#module-tty',
+    'turtle': 'turtle#module-turtle',
+    'turtledemo': 'turtle#module-turtledemo',
+    'types': 'types#module-types',
+    'typing': 'typing#module-typing',
+    'unicodedata': 'unicodedata#module-unicodedata',
+    'unittest': 'unittest#module-unittest',
+    'unittest.mock': 'unittest.mock#module-unittest.mock',
+    'urllib': 'urllib#module-urllib',
+    'urllib.error': 'urllib.error#module-urllib.error',
+    'urllib.parse': 'urllib.parse#module-urllib.parse',
+    'urllib.request': 'urllib.request#module-urllib.request',
+    'urllib.response': 'urllib.request#module-urllib.response',
+    'urllib.robotparser': 'urllib.robotparser#module-urllib.robotparser',
+    'usercustomize': 'site#module-usercustomize',
+    'uu': 'uu#module-uu',
+    'uuid': 'uuid#module-uuid',
+    'venv': 'venv#module-venv',
+    'warnings': 'warnings#module-warnings',
+    'wave': 'wave#module-wave',
+    'weakref': 'weakref#module-weakref',
+    'webbrowser': 'webbrowser#module-webbrowser',
+    'winreg': 'winreg#module-winreg',
+    'winsound': 'winsound#module-winsound',
+    'wsgiref': 'wsgiref#module-wsgiref',
+    'wsgiref.handlers': 'wsgiref#module-wsgiref.handlers',
+    'wsgiref.headers': 'wsgiref#module-wsgiref.headers',
+    'wsgiref.simple_server': 'wsgiref#module-wsgiref.simple_server',
+    'wsgiref.types': 'wsgiref#module-wsgiref.types',
+    'wsgiref.util': 'wsgiref#module-wsgiref.util',
+    'wsgiref.validate': 'wsgiref#module-wsgiref.validate',
+    'xdrlib': 'xdrlib#module-xdrlib',
+    'xml': 'xml#module-xml',
+    'xml.dom': 'xml.dom#module-xml.dom',
+    'xml.dom.minidom': 'xml.dom.minidom#module-xml.dom.minidom',
+    'xml.dom.pulldom': 'xml.dom.pulldom#module-xml.dom.pulldom',
+    'xml.etree.ElementInclude': 'xml.etree.elementtree#module-xml.etree.ElementInclude',
+    'xml.etree.ElementTree': 'xml.etree.elementtree#module-xml.etree.ElementTree',
+    'xml.parsers.expat': 'pyexpat#module-xml.parsers.expat',
+    'xml.parsers.expat.errors': 'pyexpat#module-xml.parsers.expat.errors',
+    'xml.parsers.expat.model': 'pyexpat#module-xml.parsers.expat.model',
+    'xml.sax': 'xml.sax#module-xml.sax',
+    'xml.sax.handler': 'xml.sax.handler#module-xml.sax.handler',
+    'xml.sax.saxutils': 'xml.sax.utils#module-xml.sax.saxutils',
+    'xml.sax.xmlreader': 'xml.sax.reader#module-xml.sax.xmlreader',
+    'xmlrpc': 'xmlrpc#module-xmlrpc',
+    'xmlrpc.client': 'xmlrpc.client#module-xmlrpc.client',
+    'xmlrpc.server': 'xmlrpc.server#module-xmlrpc.server',
+    'zipapp': 'zipapp#module-zipapp',
+    'zipfile': 'zipfile#module-zipfile',
+    'zipimport': 'zipimport#module-zipimport',
+    'zlib': 'zlib#module-zlib',
+    'zoneinfo': 'zoneinfo#module-zoneinfo',
+}
diff --git a/Lib/pydoc_data/topics.py b/Lib/pydoc_data/topics.py
index 56317b8a724..4e31cf08bb5 100644
--- a/Lib/pydoc_data/topics.py
+++ b/Lib/pydoc_data/topics.py
@@ -1,4 +1,4 @@
-# Autogenerated by Sphinx on Fri Dec  5 18:49:09 2025
+# Autogenerated by Sphinx on Tue Feb  3 17:32:13 2026
 # as part of the release process.
 
 topics = {
@@ -2000,7 +2000,7 @@ class attributes; they are shared by instances.  Instance attributes
    ... except* BlockingIOError as e:
    ...     print(repr(e))
    ...
-   ExceptionGroup('', (BlockingIOError()))
+   ExceptionGroup('', (BlockingIOError(),))
 
 "break", "continue" and "return" cannot appear in an "except*" clause.
 
@@ -5796,7 +5796,9 @@ class of the instance or a *non-virtual base class* thereof. The
    |           | With no precision given, uses a precision of "6" digits    |
    |           | after the decimal point for "float", and shows all         |
    |           | coefficient digits for "Decimal".  If "p=0", the decimal   |
-   |           | point is omitted unless the "#" option is used.            |
+   |           | point is omitted unless the "#" option is used.  For       |
+   |           | "float", the exponent always contains at least two digits, |
+   |           | and is zero if the value is zero.                          |
    +-----------+------------------------------------------------------------+
    | "'E'"     | Scientific notation. Same as "'e'" except it uses an upper |
    |           | case ‘E’ as the separator character.                       |
@@ -9830,7 +9832,12 @@ class is used in a class pattern with positional arguments, each
    it is intended to remove all case distinctions in a string. For
    example, the German lowercase letter "'ß'" is equivalent to ""ss"".
    Since it is already lowercase, "lower()" would do nothing to "'ß'";
-   "casefold()" converts it to ""ss"".
+   "casefold()" converts it to ""ss"". For example:
+
+      >>> 'straße'.lower()
+      'straße'
+      >>> 'straße'.casefold()
+      'strasse'
 
    The casefolding algorithm is described in section 3.13 ‘Default
    Case Folding’ of the Unicode Standard.
@@ -10019,7 +10026,18 @@ class is used in a class pattern with positional arguments, each
 str.index(sub[, start[, end]])
 
    Like "find()", but raise "ValueError" when the substring is not
-   found.
+   found. For example:
+
+      >>> 'spam, spam, spam'.index('spam')
+      0
+      >>> 'spam, spam, spam'.index('eggs')
+      Traceback (most recent call last):
+        File "<python-input-0>", line 1, in <module>
+          'spam, spam, spam'.index('eggs')
+          ~~~~~~~~~~~~~~~~~~~~~~~~^^^^^^^^
+      ValueError: substring not found
+
+   See also "rindex()".
 
 str.isalnum()
 
@@ -10118,7 +10136,19 @@ class is used in a class pattern with positional arguments, each
    that have the Unicode numeric value property, e.g. U+2155, VULGAR
    FRACTION ONE FIFTH.  Formally, numeric characters are those with
    the property value Numeric_Type=Digit, Numeric_Type=Decimal or
-   Numeric_Type=Numeric.
+   Numeric_Type=Numeric. For example:
+
+      >>> '0123456789'.isnumeric()
+      True
+      >>> '٠١٢٣٤٥٦٧٨٩'.isnumeric()  # Arabic-indic digit zero to nine
+      True
+      >>> '⅕'.isnumeric()  # Vulgar fraction one fifth
+      True
+      >>> '²'.isdecimal(), '²'.isdigit(),  '²'.isnumeric()
+      (False, True, True)
+
+   See also "isdecimal()" and "isdigit()". Numeric characters are a
+   superset of decimal numbers.
 
 str.isprintable()
 
@@ -10136,6 +10166,13 @@ class is used in a class pattern with positional arguments, each
    plus the ASCII space 0x20. Nonprintable characters are those in
    group Separator or Other (Z or C), except the ASCII space.
 
+   For example:
+
+      >>> ''.isprintable(), ' '.isprintable()
+      (True, True)
+      >>> '\t'.isprintable(), '\n'.isprintable()
+      (False, False)
+
 str.isspace()
 
    Return "True" if there are only whitespace characters in the string
@@ -10201,10 +10238,24 @@ class is used in a class pattern with positional arguments, each
    space). The original string is returned if *width* is less than or
    equal to "len(s)".
 
+   For example:
+
+      >>> 'Python'.ljust(10)
+      'Python    '
+      >>> 'Python'.ljust(10, '.')
+      'Python....'
+      >>> 'Monty Python'.ljust(10, '.')
+      'Monty Python'
+
+   See also "rjust()".
+
 str.lower()
 
    Return a copy of the string with all the cased characters [4]
-   converted to lowercase.
+   converted to lowercase. For example:
+
+      >>> 'Lower Method Example'.lower()
+      'lower method example'
 
    The lowercasing algorithm used is described in section 3.13
    ‘Default Case Folding’ of the Unicode Standard.
@@ -10268,6 +10319,8 @@ class is used in a class pattern with positional arguments, each
 
    Added in version 3.9.
 
+   See also "removesuffix()" and "startswith()".
+
 str.removesuffix(suffix, /)
 
    If the string ends with the *suffix* string and that *suffix* is
@@ -10281,12 +10334,19 @@ class is used in a class pattern with positional arguments, each
 
    Added in version 3.9.
 
+   See also "removeprefix()" and "endswith()".
+
 str.replace(old, new, /, count=-1)
 
    Return a copy of the string with all occurrences of substring *old*
    replaced by *new*.  If *count* is given, only the first *count*
    occurrences are replaced. If *count* is not specified or "-1", then
-   all occurrences are replaced.
+   all occurrences are replaced. For example:
+
+      >>> 'spam, spam, spam'.replace('spam', 'eggs')
+      'eggs, eggs, eggs'
+      >>> 'spam, spam, spam'.replace('spam', 'eggs', 1)
+      'eggs, spam, spam'
 
    Changed in version 3.13: *count* is now supported as a keyword
    argument.
@@ -10296,12 +10356,30 @@ class is used in a class pattern with positional arguments, each
    Return the highest index in the string where substring *sub* is
    found, such that *sub* is contained within "s[start:end]".
    Optional arguments *start* and *end* are interpreted as in slice
-   notation.  Return "-1" on failure.
+   notation.  Return "-1" on failure. For example:
+
+      >>> 'spam, spam, spam'.rfind('sp')
+      12
+      >>> 'spam, spam, spam'.rfind('sp', 0, 10)
+      6
+
+   See also "find()" and "rindex()".
 
 str.rindex(sub[, start[, end]])
 
    Like "rfind()" but raises "ValueError" when the substring *sub* is
-   not found.
+   not found. For example:
+
+      >>> 'spam, spam, spam'.rindex('spam')
+      12
+      >>> 'spam, spam, spam'.rindex('eggs')
+      Traceback (most recent call last):
+        File "<stdin-0>", line 1, in <module>
+          'spam, spam, spam'.rindex('eggs')
+          ~~~~~~~~~~~~~~~~~~~~~~~~~^^^^^^^^
+      ValueError: substring not found
+
+   See also "index()" and "find()".
 
 str.rjust(width, fillchar=' ', /)
 
@@ -10318,6 +10396,17 @@ class is used in a class pattern with positional arguments, each
    found, return a 3-tuple containing two empty strings, followed by
    the string itself.
 
+   For example:
+
+      >>> 'Monty Python'.rpartition(' ')
+      ('Monty', ' ', 'Python')
+      >>> "Monty Python's Flying Circus".rpartition(' ')
+      ("Monty Python's Flying", ' ', 'Circus')
+      >>> 'Monty Python'.rpartition('-')
+      ('', '', 'Monty Python')
+
+   See also "partition()".
+
 str.rsplit(sep=None, maxsplit=-1)
 
    Return a list of the words in the string, using *sep* as the
@@ -11088,7 +11177,7 @@ class is used in a class pattern with positional arguments, each
 
 * In "fstring_replacement_field", if "f_debug_specifier" is present,
   all whitespace after the opening brace until the
-  "f_debug_specifier", as well as whitespace immediatelly following
+  "f_debug_specifier", as well as whitespace immediately following
   "f_debug_specifier", is retained as part of the expression.
 
   **CPython implementation detail:** The expression is not handled in
@@ -11211,8 +11300,11 @@ class is used in a class pattern with positional arguments, each
 
 By default, an object is considered true unless its class defines
 either a "__bool__()" method that returns "False" or a "__len__()"
-method that returns zero, when called with the object. [1]  Here are
-most of the built-in objects considered false:
+method that returns zero, when called with the object. [1] If one of
+the methods raises an exception when called, the exception is
+propagated and the object does not have a truth value (for example,
+"NotImplemented"). Here are most of the built-in objects considered
+false:
 
 * constants defined to be false: "None" and "False"
 
@@ -11393,7 +11485,7 @@ class is used in a class pattern with positional arguments, each
    ... except* BlockingIOError as e:
    ...     print(repr(e))
    ...
-   ExceptionGroup('', (BlockingIOError()))
+   ExceptionGroup('', (BlockingIOError(),))
 
 "break", "continue" and "return" cannot appear in an "except*" clause.
 
@@ -11777,6 +11869,10 @@ def foo():
 +----------------------------------------------------+----------------------------------------------------+
 | Attribute                                          | Meaning                                            |
 |====================================================|====================================================|
+| function.__builtins__                              | A reference to the "dictionary" that holds the     |
+|                                                    | function’s builtins namespace.  Added in version   |
+|                                                    | 3.10.                                              |
++----------------------------------------------------+----------------------------------------------------+
 | function.__globals__                               | A reference to the "dictionary" that holds the     |
 |                                                    | function’s global variables – the global namespace |
 |                                                    | of the module in which the function was defined.   |
@@ -12871,10 +12967,6 @@ class dict(iterable, /, **kwargs)
    the keyword argument replaces the value from the positional
    argument.
 
-   Providing keyword arguments as in the first example only works for
-   keys that are valid Python identifiers.  Otherwise, any valid keys
-   can be used.
-
    Dictionaries compare equal if and only if they have the same "(key,
    value)" pairs (regardless of ordering). Order comparisons (‘<’,
    ‘<=’, ‘>=’, ‘>’) raise "TypeError".  To illustrate dictionary
@@ -13387,10 +13479,17 @@ class dict(iterable, /, **kwargs)
    note that "-0" is still "0".
 
 4. The slice of *s* from *i* to *j* is defined as the sequence of
-   items with index *k* such that "i <= k < j".  If *i* or *j* is
-   greater than "len(s)", use "len(s)".  If *i* is omitted or "None",
-   use "0".  If *j* is omitted or "None", use "len(s)".  If *i* is
-   greater than or equal to *j*, the slice is empty.
+   items with index *k* such that "i <= k < j".
+
+   * If *i* is omitted or "None", use "0".
+
+   * If *j* is omitted or "None", use "len(s)".
+
+   * If *i* or *j* is less than "-len(s)", use "0".
+
+   * If *i* or *j* is greater than "len(s)", use "len(s)".
+
+   * If *i* is greater than or equal to *j*, the slice is empty.
 
 5. The slice of *s* from *i* to *j* with step *k* is defined as the
    sequence of items with index  "x = i + n*k" such that "0 <= n <
@@ -13655,6 +13754,76 @@ class list(iterable=(), /)
       empty for the duration, and raises "ValueError" if it can detect
       that the list has been mutated during a sort.
 
+Thread safety: Reading a single element from a "list" is *atomic*:
+
+   lst[i]   # list.__getitem__
+
+The following methods traverse the list and use *atomic* reads of each
+item to perform their function. That means that they may return
+results affected by concurrent modifications:
+
+   item in lst
+   lst.index(item)
+   lst.count(item)
+
+All of the above methods/operations are also lock-free. They do not
+block concurrent modifications. Other operations that hold a lock will
+not block these from observing intermediate states.All other
+operations from here on block using the per-object lock.Writing a
+single item via "lst[i] = x" is safe to call from multiple threads and
+will not corrupt the list.The following operations return new objects
+and appear *atomic* to other threads:
+
+   lst1 + lst2    # concatenates two lists into a new list
+   x * lst        # repeats lst x times into a new list
+   lst.copy()     # returns a shallow copy of the list
+
+Methods that only operate on a single elements with no shifting
+required are *atomic*:
+
+   lst.append(x)  # append to the end of the list, no shifting required
+   lst.pop()      # pop element from the end of the list, no shifting required
+
+The "clear()" method is also *atomic*. Other threads cannot observe
+elements being removed.The "sort()" method is not *atomic*. Other
+threads cannot observe intermediate states during sorting, but the
+list appears empty for the duration of the sort.The following
+operations may allow lock-free operations to observe intermediate
+states since they modify multiple elements in place:
+
+   lst.insert(idx, item)  # shifts elements
+   lst.pop(idx)           # idx not at the end of the list, shifts elements
+   lst *= x               # copies elements in place
+
+The "remove()" method may allow concurrent modifications since element
+comparison may execute arbitrary Python code (via
+"__eq__()")."extend()" is safe to call from multiple threads.
+However, its guarantees depend on the iterable passed to it. If it is
+a "list", a "tuple", a "set", a "frozenset", a "dict" or a dictionary
+view object (but not their subclasses), the "extend" operation is safe
+from concurrent modifications to the iterable. Otherwise, an iterator
+is created which can be concurrently modified by another thread.  The
+same applies to inplace concatenation of a list with other iterables
+when using "lst += iterable".Similarly, assigning to a list slice with
+"lst[i:j] = iterable" is safe to call from multiple threads, but
+"iterable" is only locked when it is also a "list" (but not its
+subclasses).Operations that involve multiple accesses, as well as
+iteration, are never atomic. For example:
+
+   # NOT atomic: read-modify-write
+   lst[i] = lst[i] + 1
+
+   # NOT atomic: check-then-act
+   if lst:
+       item = lst.pop()
+
+   # NOT thread-safe: iteration while modifying
+   for item in lst:
+       process(item)  # another thread may modify lst
+
+Consider external synchronization when sharing "list" instances across
+threads.  See Python support for free threading for more information.
+
 
 Tuples
 ======
diff --git a/Lib/queue.py b/Lib/queue.py
index 25beb46e30d..c0b35987654 100644
--- a/Lib/queue.py
+++ b/Lib/queue.py
@@ -80,9 +80,6 @@ def task_done(self):
         have been processed (meaning that a task_done() call was received
         for every item that had been put() into the queue).
 
-        shutdown(immediate=True) calls task_done() for each remaining item in
-        the queue.
-
         Raises a ValueError if called more times than there were items
         placed in the queue.
         '''
@@ -239,9 +236,11 @@ def shutdown(self, immediate=False):
         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', a task is marked as done for each item remaining in
-        the queue, which may unblock callers of join().
+        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.
         '''
         with self.mutex:
             self.is_shutdown = True
diff --git a/Lib/random.py b/Lib/random.py
index 36e3925811c..86d562f0b8a 100644
--- a/Lib/random.py
+++ b/Lib/random.py
@@ -50,39 +50,18 @@
 # Adrian Baddeley.  Adapted by Raymond Hettinger for use with
 # the Mersenne Twister  and os.urandom() core generators.
 
-from warnings import warn as _warn
 from math import log as _log, exp as _exp, pi as _pi, e as _e, ceil as _ceil
 from math import sqrt as _sqrt, acos as _acos, cos as _cos, sin as _sin
 from math import tau as TWOPI, floor as _floor, isfinite as _isfinite
 from math import lgamma as _lgamma, fabs as _fabs, log2 as _log2
-try:
-    from os import urandom as _urandom
-except ImportError:
-    # XXX RUSTPYTHON
-    # On wasm, _random.Random.random() does give a proper random value, but
-    # we don't have the os module
-    def _urandom(*args, **kwargs):
-        raise NotImplementedError("urandom")
-    _os = None
-from _collections_abc import Set as _Set, Sequence as _Sequence
+from os import urandom as _urandom
+from _collections_abc import Sequence as _Sequence
 from operator import index as _index
 from itertools import accumulate as _accumulate, repeat as _repeat
 from bisect import bisect as _bisect
-try:
-    import os as _os
-except ImportError:
-    # XXX RUSTPYTHON
-    # On wasm, we don't have the os module
-    _os = None
+import os as _os
 import _random
 
-try:
-    # hashlib is pretty heavy to load, try lean internal module first
-    from _sha2 import sha512 as _sha512
-except ImportError:
-    # fallback to official implementation
-    from hashlib import sha512 as _sha512
-
 __all__ = [
     "Random",
     "SystemRandom",
@@ -118,6 +97,7 @@ def _urandom(*args, **kwargs):
 BPF = 53        # Number of bits in a float
 RECIP_BPF = 2 ** -BPF
 _ONE = 1
+_sha512 = None
 
 
 class Random(_random.Random):
@@ -172,13 +152,23 @@ def seed(self, a=None, version=2):
             a = -2 if x == -1 else x
 
         elif version == 2 and isinstance(a, (str, bytes, bytearray)):
+            global _sha512
+            if _sha512 is None:
+                try:
+                    # hashlib is pretty heavy to load, try lean internal
+                    # module first
+                    from _sha2 import sha512 as _sha512
+                except ImportError:
+                    # fallback to official implementation
+                    from hashlib import sha512 as _sha512
+
             if isinstance(a, str):
                 a = a.encode()
             a = int.from_bytes(a + _sha512(a).digest())
 
         elif not isinstance(a, (type(None), int, float, str, bytes, bytearray)):
-            raise TypeError('The only supported seed types are: None,\n'
-                            'int, float, str, bytes, and bytearray.')
+            raise TypeError('The only supported seed types are:\n'
+                            'None, int, float, str, bytes, and bytearray.')
 
         super().seed(a)
         self.gauss_next = None
@@ -255,11 +245,10 @@ def __init_subclass__(cls, /, **kwargs):
     def _randbelow_with_getrandbits(self, n):
         "Return a random int in the range [0,n).  Defined for n > 0."
 
-        getrandbits = self.getrandbits
         k = n.bit_length()
-        r = getrandbits(k)  # 0 <= r < 2**k
+        r = self.getrandbits(k)  # 0 <= r < 2**k
         while r >= n:
-            r = getrandbits(k)
+            r = self.getrandbits(k)
         return r
 
     def _randbelow_without_getrandbits(self, n, maxsize=1<<BPF):
@@ -270,9 +259,10 @@ def _randbelow_without_getrandbits(self, n, maxsize=1<<BPF):
 
         random = self.random
         if n >= maxsize:
-            _warn("Underlying random() generator does not supply \n"
-                "enough bits to choose from a population range this large.\n"
-                "To remove the range limitation, add a getrandbits() method.")
+            from warnings import warn
+            warn("Underlying random() generator does not supply \n"
+                 "enough bits to choose from a population range this large.\n"
+                 "To remove the range limitation, add a getrandbits() method.")
             return _floor(random() * n)
         rem = maxsize % n
         limit = (maxsize - rem) / maxsize   # int(limit * maxsize) % n == 0
@@ -345,8 +335,11 @@ def randrange(self, start, stop=None, step=_ONE):
     def randint(self, a, b):
         """Return random integer in range [a, b], including both end points.
         """
-
-        return self.randrange(a, b+1)
+        a = _index(a)
+        b = _index(b)
+        if b < a:
+            raise ValueError(f"empty range in randint({a}, {b})")
+        return a + self._randbelow(b - a + 1)
 
 
     ## -------------------- sequence methods  -------------------
@@ -430,11 +423,11 @@ def sample(self, population, k, *, counts=None):
             cum_counts = list(_accumulate(counts))
             if len(cum_counts) != n:
                 raise ValueError('The number of counts does not match the population')
-            total = cum_counts.pop()
+            total = cum_counts.pop() if cum_counts else 0
             if not isinstance(total, int):
                 raise TypeError('Counts must be integers')
-            if total <= 0:
-                raise ValueError('Total of counts must be greater than zero')
+            if total < 0:
+                raise ValueError('Counts must be non-negative')
             selections = self.sample(range(total), k=k)
             bisect = _bisect
             return [population[bisect(cum_counts, s)] for s in selections]
@@ -801,12 +794,18 @@ def binomialvariate(self, n=1, p=0.5):
 
             sum(random() < p for i in range(n))
 
-        Returns an integer in the range:   0 <= X <= n
+        Returns an integer in the range:
+
+            0 <= X <= n
+
+        The integer is chosen with the probability:
+
+            P(X == k) = math.comb(n, k) * p ** k * (1 - p) ** (n - k)
 
         The mean (expected value) and variance of the random variable are:
 
             E[X] = n * p
-            Var[x] = n * p * (1 - p)
+            Var[X] = n * p * (1 - p)
 
         """
         # Error check inputs and handle edge cases
@@ -1005,5 +1004,75 @@ def _test(N=10_000):
     _os.register_at_fork(after_in_child=_inst.seed)
 
 
+# ------------------------------------------------------
+# -------------- command-line interface ----------------
+
+
+def _parse_args(arg_list: list[str] | None):
+    import argparse
+    parser = argparse.ArgumentParser(
+        formatter_class=argparse.RawTextHelpFormatter, color=True)
+    group = parser.add_mutually_exclusive_group()
+    group.add_argument(
+        "-c", "--choice", nargs="+",
+        help="print a random choice")
+    group.add_argument(
+        "-i", "--integer", type=int, metavar="N",
+        help="print a random integer between 1 and N inclusive")
+    group.add_argument(
+        "-f", "--float", type=float, metavar="N",
+        help="print a random floating-point number between 0 and N inclusive")
+    group.add_argument(
+        "--test", type=int, const=10_000, nargs="?",
+        help=argparse.SUPPRESS)
+    parser.add_argument("input", nargs="*",
+                        help="""\
+if no options given, output depends on the input
+    string or multiple: same as --choice
+    integer: same as --integer
+    float: same as --float""")
+    args = parser.parse_args(arg_list)
+    return args, parser.format_help()
+
+
+def main(arg_list: list[str] | None = None) -> int | str:
+    args, help_text = _parse_args(arg_list)
+
+    # Explicit arguments
+    if args.choice:
+        return choice(args.choice)
+
+    if args.integer is not None:
+        return randint(1, args.integer)
+
+    if args.float is not None:
+        return uniform(0, args.float)
+
+    if args.test:
+        _test(args.test)
+        return ""
+
+    # No explicit argument, select based on input
+    if len(args.input) == 1:
+        val = args.input[0]
+        try:
+            # Is it an integer?
+            val = int(val)
+            return randint(1, val)
+        except ValueError:
+            try:
+                # Is it a float?
+                val = float(val)
+                return uniform(0, val)
+            except ValueError:
+                # Split in case of space-separated string: "a b c"
+                return choice(val.split())
+
+    if len(args.input) >= 2:
+        return choice(args.input)
+
+    return help_text
+
+
 if __name__ == '__main__':
-    _test()
+    print(main())
diff --git a/Lib/shlex.py b/Lib/shlex.py
index f4821616b62..5959f52dd12 100644
--- a/Lib/shlex.py
+++ b/Lib/shlex.py
@@ -7,11 +7,7 @@
 # iterator interface by Gustavo Niemeyer, April 2003.
 # changes to tokenize more like Posix shells by Vinay Sajip, July 2016.
 
-import os
-import re
 import sys
-from collections import deque
-
 from io import StringIO
 
 __all__ = ["shlex", "split", "quote", "join"]
@@ -20,6 +16,8 @@ class shlex:
     "A lexical analyzer class for simple shell-like syntaxes."
     def __init__(self, instream=None, infile=None, posix=False,
                  punctuation_chars=False):
+        from collections import deque  # deferred import for performance
+
         if isinstance(instream, str):
             instream = StringIO(instream)
         if instream is not None:
@@ -278,6 +276,7 @@ def read_token(self):
 
     def sourcehook(self, newfile):
         "Hook called on a filename to be sourced."
+        import os.path
         if newfile[0] == '"':
             newfile = newfile[1:-1]
         # This implements cpp-like semantics for relative-path inclusion.
@@ -318,13 +317,20 @@ def join(split_command):
     return ' '.join(quote(arg) for arg in split_command)
 
 
-_find_unsafe = re.compile(r'[^\w@%+=:,./-]', re.ASCII).search
-
 def quote(s):
     """Return a shell-escaped version of the string *s*."""
     if not s:
         return "''"
-    if _find_unsafe(s) is None:
+
+    if not isinstance(s, str):
+        raise TypeError(f"expected string object, got {type(s).__name__!r}")
+
+    # Use bytes.translate() for performance
+    safe_chars = (b'%+,-./0123456789:=@'
+                  b'ABCDEFGHIJKLMNOPQRSTUVWXYZ_'
+                  b'abcdefghijklmnopqrstuvwxyz')
+    # No quoting is needed if `s` is an ASCII string consisting only of `safe_chars`
+    if s.isascii() and not s.encode().translate(None, delete=safe_chars):
         return s
 
     # use single quotes, and put single quotes into double quotes
diff --git a/Lib/shutil.py b/Lib/shutil.py
index 7df972012c7..8d8fe145567 100644
--- a/Lib/shutil.py
+++ b/Lib/shutil.py
@@ -32,6 +32,13 @@
 except ImportError:
     _LZMA_SUPPORTED = False
 
+try:
+    from compression import zstd
+    del zstd
+    _ZSTD_SUPPORTED = True
+except ImportError:
+    _ZSTD_SUPPORTED = False
+
 _WINDOWS = os.name == 'nt'
 posix = nt = None
 if os.name == 'posix':
@@ -44,11 +51,12 @@
 else:
     _winapi = None
 
-COPY_BUFSIZE = 1024 * 1024 if _WINDOWS else 64 * 1024
+COPY_BUFSIZE = 1024 * 1024 if _WINDOWS else 256 * 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", "android")))
+                    and sys.platform.startswith(("linux", "android", "sunos")))
+_USE_CP_COPY_FILE_RANGE = hasattr(os, "copy_file_range")
 _HAS_FCOPYFILE = posix and hasattr(posix, "_fcopyfile")  # macOS
 
 # CMD defaults in Windows 10
@@ -56,7 +64,7 @@
 
 __all__ = ["copyfileobj", "copyfile", "copymode", "copystat", "copy", "copy2",
            "copytree", "move", "rmtree", "Error", "SpecialFileError",
-           "ExecError", "make_archive", "get_archive_formats",
+           "make_archive", "get_archive_formats",
            "register_archive_format", "unregister_archive_format",
            "get_unpack_formats", "register_unpack_format",
            "unregister_unpack_format", "unpack_archive",
@@ -74,8 +82,6 @@ class SpecialFileError(OSError):
     """Raised when trying to do a kind of operation (e.g. copying) which is
     not supported on a special file (e.g. a named pipe)"""
 
-class ExecError(OSError):
-    """Raised when a command could not be executed"""
 
 class ReadError(OSError):
     """Raised when an archive cannot be read"""
@@ -109,10 +115,70 @@ def _fastcopy_fcopyfile(fsrc, fdst, flags):
         else:
             raise err from None
 
+def _determine_linux_fastcopy_blocksize(infd):
+    """Determine blocksize for fastcopying on Linux.
+
+    Hopefully the whole file will be copied in a single call.
+    The copying itself should be performed in a loop 'till EOF is
+    reached (0 return) so a blocksize smaller or bigger than the actual
+    file size should not make any difference, also in case the file
+    content changes while being copied.
+    """
+    try:
+        blocksize = max(os.fstat(infd).st_size, 2 ** 23)  # min 8 MiB
+    except OSError:
+        blocksize = 2 ** 27  # 128 MiB
+    # On 32-bit architectures truncate to 1 GiB to avoid OverflowError,
+    # see gh-82500.
+    if sys.maxsize < 2 ** 32:
+        blocksize = min(blocksize, 2 ** 30)
+    return blocksize
+
+def _fastcopy_copy_file_range(fsrc, fdst):
+    """Copy data from one regular mmap-like fd to another by using
+    a high-performance copy_file_range(2) syscall that gives filesystems
+    an opportunity to implement the use of reflinks or server-side copy.
+
+    This should work on Linux >= 4.5 only.
+    """
+    try:
+        infd = fsrc.fileno()
+        outfd = fdst.fileno()
+    except Exception as err:
+        raise _GiveupOnFastCopy(err)  # not a regular file
+
+    blocksize = _determine_linux_fastcopy_blocksize(infd)
+    offset = 0
+    while True:
+        try:
+            n_copied = os.copy_file_range(infd, outfd, blocksize, offset_dst=offset)
+        except OSError as err:
+            # ...in oder to have a more informative exception.
+            err.filename = fsrc.name
+            err.filename2 = fdst.name
+
+            if err.errno == errno.ENOSPC:  # filesystem is full
+                raise err from None
+
+            # Give up on first call and if no data was copied.
+            if offset == 0 and os.lseek(outfd, 0, os.SEEK_CUR) == 0:
+                raise _GiveupOnFastCopy(err)
+
+            raise err
+        else:
+            if n_copied == 0:
+                # If no bytes have been copied yet, copy_file_range
+                # might silently fail.
+                # https://lore.kernel.org/linux-fsdevel/20210126233840.GG4626@dread.disaster.area/T/#m05753578c7f7882f6e9ffe01f981bc223edef2b0
+                if offset == 0:
+                    raise _GiveupOnFastCopy()
+                break
+            offset += n_copied
+
 def _fastcopy_sendfile(fsrc, fdst):
     """Copy data from one regular mmap-like fd to another by using
     high-performance sendfile(2) syscall.
-    This should work on Linux >= 2.6.33 only.
+    This should work on Linux >= 2.6.33, Android and Solaris.
     """
     # Note: copyfileobj() is left alone in order to not introduce any
     # unexpected breakage. Possible risks by using zero-copy calls
@@ -130,26 +196,13 @@ def _fastcopy_sendfile(fsrc, fdst):
     except Exception as err:
         raise _GiveupOnFastCopy(err)  # not a regular file
 
-    # Hopefully the whole file will be copied in a single call.
-    # sendfile() is called in a loop 'till EOF is reached (0 return)
-    # so a bufsize smaller or bigger than the actual file size
-    # should not make any difference, also in case the file content
-    # changes while being copied.
-    try:
-        blocksize = max(os.fstat(infd).st_size, 2 ** 23)  # min 8MiB
-    except OSError:
-        blocksize = 2 ** 27  # 128MiB
-    # On 32-bit architectures truncate to 1GiB to avoid OverflowError,
-    # see bpo-38319.
-    if sys.maxsize < 2 ** 32:
-        blocksize = min(blocksize, 2 ** 30)
-
+    blocksize = _determine_linux_fastcopy_blocksize(infd)
     offset = 0
     while True:
         try:
             sent = os.sendfile(outfd, infd, offset, blocksize)
         except OSError as err:
-            # ...in oder to have a more informative exception.
+            # ...in order to have a more informative exception.
             err.filename = fsrc.name
             err.filename2 = fdst.name
 
@@ -267,13 +320,21 @@ def copyfile(src, dst, *, follow_symlinks=True):
                             return dst
                         except _GiveupOnFastCopy:
                             pass
-                    # Linux
-                    elif _USE_CP_SENDFILE:
-                        try:
-                            _fastcopy_sendfile(fsrc, fdst)
-                            return dst
-                        except _GiveupOnFastCopy:
-                            pass
+                    # Linux / Android / Solaris
+                    elif _USE_CP_SENDFILE or _USE_CP_COPY_FILE_RANGE:
+                        # reflink may be implicit in copy_file_range.
+                        if _USE_CP_COPY_FILE_RANGE:
+                            try:
+                                _fastcopy_copy_file_range(fsrc, fdst)
+                                return dst
+                            except _GiveupOnFastCopy:
+                                pass
+                        if _USE_CP_SENDFILE:
+                            try:
+                                _fastcopy_sendfile(fsrc, fdst)
+                                return dst
+                            except _GiveupOnFastCopy:
+                                pass
                     # Windows, see:
                     # https://github.com/python/cpython/pull/7160#discussion_r195405230
                     elif _WINDOWS and file_size > 0:
@@ -605,7 +666,22 @@ def _rmtree_islink(st):
         return stat.S_ISLNK(st.st_mode)
 
 # version vulnerable to race conditions
-def _rmtree_unsafe(path, onexc):
+def _rmtree_unsafe(path, dir_fd, onexc):
+    if dir_fd is not None:
+        raise NotImplementedError("dir_fd unavailable on this platform")
+    try:
+        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:
+        onexc(os.path.islink, path, err)
+        # can't continue even if onexc hook returns
+        return
     def onerror(err):
         if not isinstance(err, FileNotFoundError):
             onexc(os.scandir, err.filename, err)
@@ -635,7 +711,26 @@ def onerror(err):
         onexc(os.rmdir, path, err)
 
 # Version using fd-based APIs to protect against races
-def _rmtree_safe_fd(stack, onexc):
+def _rmtree_safe_fd(path, dir_fd, onexc):
+    # While the unsafe rmtree works fine on bytes, the fd based does not.
+    if isinstance(path, bytes):
+        path = os.fsdecode(path)
+    stack = [(os.lstat, dir_fd, path, None)]
+    try:
+        while stack:
+            _rmtree_safe_fd_step(stack, onexc)
+    finally:
+        # 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:
+                onexc(os.close, path, err)
+
+def _rmtree_safe_fd_step(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
@@ -710,6 +805,7 @@ def _rmtree_safe_fd(stack, onexc):
                      os.supports_dir_fd and
                      os.scandir in os.supports_fd and
                      os.stat in os.supports_follow_symlinks)
+_rmtree_impl = _rmtree_safe_fd if _use_fd_functions else _rmtree_unsafe
 
 def rmtree(path, ignore_errors=False, onerror=None, *, onexc=None, dir_fd=None):
     """Recursively delete a directory tree.
@@ -753,41 +849,7 @@ def onexc(*args):
                     exc_info = type(exc), exc, exc.__traceback__
                 return onerror(func, path, exc_info)
 
-    if _use_fd_functions:
-        # While the unsafe rmtree works fine on bytes, the fd based does not.
-        if isinstance(path, bytes):
-            path = os.fsdecode(path)
-        stack = [(os.lstat, dir_fd, path, None)]
-        try:
-            while stack:
-                _rmtree_safe_fd(stack, onexc)
-        finally:
-            # 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:
-                    onexc(os.close, path, err)
-    else:
-        if dir_fd is not None:
-            raise NotImplementedError("dir_fd unavailable on this platform")
-        try:
-            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:
-            onexc(os.path.islink, path, err)
-            # can't continue even if onexc hook returns
-            return
-        return _rmtree_unsafe(path, onexc)
+    _rmtree_impl(path, dir_fd, onexc)
 
 # Allow introspection of whether or not the hardening against symlink
 # attacks is supported on the current platform
@@ -932,14 +994,14 @@ def _make_tarball(base_name, base_dir, compress="gzip", verbose=0, dry_run=0,
     """Create a (possibly compressed) tar file from all the files under
     'base_dir'.
 
-    'compress' must be "gzip" (the default), "bzip2", "xz", or None.
+    'compress' must be "gzip" (the default), "bzip2", "xz", "zst", or None.
 
     '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_name' +  ".tar", possibly plus
-    the appropriate compression extension (".gz", ".bz2", or ".xz").
+    the appropriate compression extension (".gz", ".bz2", ".xz", or ".zst").
 
     Returns the output filename.
     """
@@ -951,6 +1013,8 @@ def _make_tarball(base_name, base_dir, compress="gzip", verbose=0, dry_run=0,
         tar_compression = 'bz2'
     elif _LZMA_SUPPORTED and compress == 'xz':
         tar_compression = 'xz'
+    elif _ZSTD_SUPPORTED and compress == 'zst':
+        tar_compression = 'zst'
     else:
         raise ValueError("bad value for 'compress', or compression format not "
                          "supported : {0}".format(compress))
@@ -1079,6 +1143,10 @@ def _make_zipfile(base_name, base_dir, verbose=0, dry_run=0,
     _ARCHIVE_FORMATS['xztar'] = (_make_tarball, [('compress', 'xz')],
                                 "xz'ed tar-file")
 
+if _ZSTD_SUPPORTED:
+    _ARCHIVE_FORMATS['zstdtar'] = (_make_tarball, [('compress', 'zst')],
+                                  "zstd'ed tar-file")
+
 def get_archive_formats():
     """Returns a list of supported formats for archiving and unarchiving.
 
@@ -1119,7 +1187,7 @@ def make_archive(base_name, format, root_dir=None, base_dir=None, verbose=0,
 
     '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", or "xztar".  Or any other registered format.
+    "bztar", "xztar", or "zstdtar".  Or any other registered format.
 
     'root_dir' is a directory that will be the root directory of the
     archive; ie. we typically chdir into 'root_dir' before creating the
@@ -1269,7 +1337,7 @@ def _unpack_zipfile(filename, extract_dir):
         zip.close()
 
 def _unpack_tarfile(filename, extract_dir, *, filter=None):
-    """Unpack tar/tar.gz/tar.bz2/tar.xz `filename` to `extract_dir`
+    """Unpack tar/tar.gz/tar.bz2/tar.xz/tar.zst `filename` to `extract_dir`
     """
     import tarfile  # late import for breaking circular dependency
     try:
@@ -1304,6 +1372,10 @@ def _unpack_tarfile(filename, extract_dir, *, filter=None):
     _UNPACK_FORMATS['xztar'] = (['.tar.xz', '.txz'], _unpack_tarfile, [],
                                 "xz'ed tar-file")
 
+if _ZSTD_SUPPORTED:
+    _UNPACK_FORMATS['zstdtar'] = (['.tar.zst', '.tzst'], _unpack_tarfile, [],
+                                  "zstd'ed tar-file")
+
 def _find_unpack_format(filename):
     for name, info in _UNPACK_FORMATS.items():
         for extension in info[0]:
@@ -1320,7 +1392,7 @@ def unpack_archive(filename, extract_dir=None, format=None, *, filter=None):
     is unpacked. If not provided, the current working directory is used.
 
     `format` is the archive format: one of "zip", "tar", "gztar", "bztar",
-    or "xztar".  Or any other registered format.  If not provided,
+    "xztar", or "zstdtar".  Or any other registered format.  If not provided,
     unpack_archive will use the filename extension and see if an unpacker
     was registered for that extension.
 
@@ -1581,3 +1653,15 @@ def which(cmd, mode=os.F_OK | os.X_OK, path=None):
                 if _access_check(name, mode):
                     return name
     return None
+
+def __getattr__(name):
+    if name == "ExecError":
+        import warnings
+        warnings._deprecated(
+            "shutil.ExecError",
+            f"{warnings._DEPRECATED_MSG}; it "
+            "isn't raised by any shutil function.",
+            remove=(3, 16)
+        )
+        return RuntimeError
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
diff --git a/Lib/smtplib.py b/Lib/smtplib.py
old mode 100755
new mode 100644
index 9b81bcfbc41..72093f7f8b0
--- a/Lib/smtplib.py
+++ b/Lib/smtplib.py
@@ -1,5 +1,3 @@
-#! /usr/bin/env python3
-
 '''SMTP/ESMTP client class.
 
 This should follow RFC 821 (SMTP), RFC 1869 (ESMTP), RFC 2554 (SMTP
@@ -105,7 +103,7 @@ class SMTPSenderRefused(SMTPResponseException):
     """Sender address refused.
 
     In addition to the attributes set by on all SMTPResponseException
-    exceptions, this sets `sender' to the string that the SMTP refused.
+    exceptions, this sets 'sender' to the string that the SMTP refused.
     """
 
     def __init__(self, code, msg, sender):
@@ -182,8 +180,7 @@ def _fix_eols(data):
 
 try:
     hmac.digest(b'', b'', 'md5')
-# except ValueError:
-except (ValueError, AttributeError): # TODO: RUSTPYTHON
+except ValueError:
     _have_cram_md5_support = False
 else:
     _have_cram_md5_support = True
@@ -325,7 +322,7 @@ def _get_socket(self, host, port, timeout):
     def connect(self, host='localhost', port=0, source_address=None):
         """Connect to a host on a given port.
 
-        If the hostname ends with a colon (`:') followed by a number, and
+        If the hostname ends with a colon (':') followed by a number, and
         there is no port specified, that suffix will be stripped off and the
         number interpreted as the port number to use.
 
@@ -356,7 +353,7 @@ def connect(self, host='localhost', port=0, source_address=None):
         return (code, msg)
 
     def send(self, s):
-        """Send `s' to the server."""
+        """Send 's' to the server."""
         if self.debuglevel > 0:
             self._print_debug('send:', repr(s))
         if self.sock:
diff --git a/Lib/socket.py b/Lib/socket.py
index 35d87eff34d..727b0e75f03 100644
--- a/Lib/socket.py
+++ b/Lib/socket.py
@@ -52,7 +52,9 @@
 import _socket
 from _socket import *
 
-import os, sys, io, selectors
+import io
+import os
+import sys
 from enum import IntEnum, IntFlag
 
 try:
@@ -110,102 +112,103 @@ def _intenum_converter(value, enum_klass):
 
 # WSA error codes
 if sys.platform.lower().startswith("win"):
-    errorTab = {}
-    errorTab[6] = "Specified event object handle is invalid."
-    errorTab[8] = "Insufficient memory available."
-    errorTab[87] = "One or more parameters are invalid."
-    errorTab[995] = "Overlapped operation aborted."
-    errorTab[996] = "Overlapped I/O event object not in signaled state."
-    errorTab[997] = "Overlapped operation will complete later."
-    errorTab[10004] = "The operation was interrupted."
-    errorTab[10009] = "A bad file handle was passed."
-    errorTab[10013] = "Permission denied."
-    errorTab[10014] = "A fault occurred on the network??"  # WSAEFAULT
-    errorTab[10022] = "An invalid operation was attempted."
-    errorTab[10024] = "Too many open files."
-    errorTab[10035] = "The socket operation would block."
-    errorTab[10036] = "A blocking operation is already in progress."
-    errorTab[10037] = "Operation already in progress."
-    errorTab[10038] = "Socket operation on nonsocket."
-    errorTab[10039] = "Destination address required."
-    errorTab[10040] = "Message too long."
-    errorTab[10041] = "Protocol wrong type for socket."
-    errorTab[10042] = "Bad protocol option."
-    errorTab[10043] = "Protocol not supported."
-    errorTab[10044] = "Socket type not supported."
-    errorTab[10045] = "Operation not supported."
-    errorTab[10046] = "Protocol family not supported."
-    errorTab[10047] = "Address family not supported by protocol family."
-    errorTab[10048] = "The network address is in use."
-    errorTab[10049] = "Cannot assign requested address."
-    errorTab[10050] = "Network is down."
-    errorTab[10051] = "Network is unreachable."
-    errorTab[10052] = "Network dropped connection on reset."
-    errorTab[10053] = "Software caused connection abort."
-    errorTab[10054] = "The connection has been reset."
-    errorTab[10055] = "No buffer space available."
-    errorTab[10056] = "Socket is already connected."
-    errorTab[10057] = "Socket is not connected."
-    errorTab[10058] = "The network has been shut down."
-    errorTab[10059] = "Too many references."
-    errorTab[10060] = "The operation timed out."
-    errorTab[10061] = "Connection refused."
-    errorTab[10062] = "Cannot translate name."
-    errorTab[10063] = "The name is too long."
-    errorTab[10064] = "The host is down."
-    errorTab[10065] = "The host is unreachable."
-    errorTab[10066] = "Directory not empty."
-    errorTab[10067] = "Too many processes."
-    errorTab[10068] = "User quota exceeded."
-    errorTab[10069] = "Disk quota exceeded."
-    errorTab[10070] = "Stale file handle reference."
-    errorTab[10071] = "Item is remote."
-    errorTab[10091] = "Network subsystem is unavailable."
-    errorTab[10092] = "Winsock.dll version out of range."
-    errorTab[10093] = "Successful WSAStartup not yet performed."
-    errorTab[10101] = "Graceful shutdown in progress."
-    errorTab[10102] = "No more results from WSALookupServiceNext."
-    errorTab[10103] = "Call has been canceled."
-    errorTab[10104] = "Procedure call table is invalid."
-    errorTab[10105] = "Service provider is invalid."
-    errorTab[10106] = "Service provider failed to initialize."
-    errorTab[10107] = "System call failure."
-    errorTab[10108] = "Service not found."
-    errorTab[10109] = "Class type not found."
-    errorTab[10110] = "No more results from WSALookupServiceNext."
-    errorTab[10111] = "Call was canceled."
-    errorTab[10112] = "Database query was refused."
-    errorTab[11001] = "Host not found."
-    errorTab[11002] = "Nonauthoritative host not found."
-    errorTab[11003] = "This is a nonrecoverable error."
-    errorTab[11004] = "Valid name, no data record requested type."
-    errorTab[11005] = "QoS receivers."
-    errorTab[11006] = "QoS senders."
-    errorTab[11007] = "No QoS senders."
-    errorTab[11008] = "QoS no receivers."
-    errorTab[11009] = "QoS request confirmed."
-    errorTab[11010] = "QoS admission error."
-    errorTab[11011] = "QoS policy failure."
-    errorTab[11012] = "QoS bad style."
-    errorTab[11013] = "QoS bad object."
-    errorTab[11014] = "QoS traffic control error."
-    errorTab[11015] = "QoS generic error."
-    errorTab[11016] = "QoS service type error."
-    errorTab[11017] = "QoS flowspec error."
-    errorTab[11018] = "Invalid QoS provider buffer."
-    errorTab[11019] = "Invalid QoS filter style."
-    errorTab[11020] = "Invalid QoS filter style."
-    errorTab[11021] = "Incorrect QoS filter count."
-    errorTab[11022] = "Invalid QoS object length."
-    errorTab[11023] = "Incorrect QoS flow count."
-    errorTab[11024] = "Unrecognized QoS object."
-    errorTab[11025] = "Invalid QoS policy object."
-    errorTab[11026] = "Invalid QoS flow descriptor."
-    errorTab[11027] = "Invalid QoS provider-specific flowspec."
-    errorTab[11028] = "Invalid QoS provider-specific filterspec."
-    errorTab[11029] = "Invalid QoS shape discard mode object."
-    errorTab[11030] = "Invalid QoS shaping rate object."
-    errorTab[11031] = "Reserved policy QoS element type."
+    errorTab = {
+        6: "Specified event object handle is invalid.",
+        8: "Insufficient memory available.",
+        87: "One or more parameters are invalid.",
+        995: "Overlapped operation aborted.",
+        996: "Overlapped I/O event object not in signaled state.",
+        997: "Overlapped operation will complete later.",
+        10004: "The operation was interrupted.",
+        10009: "A bad file handle was passed.",
+        10013: "Permission denied.",
+        10014: "A fault occurred on the network??",
+        10022: "An invalid operation was attempted.",
+        10024: "Too many open files.",
+        10035: "The socket operation would block.",
+        10036: "A blocking operation is already in progress.",
+        10037: "Operation already in progress.",
+        10038: "Socket operation on nonsocket.",
+        10039: "Destination address required.",
+        10040: "Message too long.",
+        10041: "Protocol wrong type for socket.",
+        10042: "Bad protocol option.",
+        10043: "Protocol not supported.",
+        10044: "Socket type not supported.",
+        10045: "Operation not supported.",
+        10046: "Protocol family not supported.",
+        10047: "Address family not supported by protocol family.",
+        10048: "The network address is in use.",
+        10049: "Cannot assign requested address.",
+        10050: "Network is down.",
+        10051: "Network is unreachable.",
+        10052: "Network dropped connection on reset.",
+        10053: "Software caused connection abort.",
+        10054: "The connection has been reset.",
+        10055: "No buffer space available.",
+        10056: "Socket is already connected.",
+        10057: "Socket is not connected.",
+        10058: "The network has been shut down.",
+        10059: "Too many references.",
+        10060: "The operation timed out.",
+        10061: "Connection refused.",
+        10062: "Cannot translate name.",
+        10063: "The name is too long.",
+        10064: "The host is down.",
+        10065: "The host is unreachable.",
+        10066: "Directory not empty.",
+        10067: "Too many processes.",
+        10068: "User quota exceeded.",
+        10069: "Disk quota exceeded.",
+        10070: "Stale file handle reference.",
+        10071: "Item is remote.",
+        10091: "Network subsystem is unavailable.",
+        10092: "Winsock.dll version out of range.",
+        10093: "Successful WSAStartup not yet performed.",
+        10101: "Graceful shutdown in progress.",
+        10102: "No more results from WSALookupServiceNext.",
+        10103: "Call has been canceled.",
+        10104: "Procedure call table is invalid.",
+        10105: "Service provider is invalid.",
+        10106: "Service provider failed to initialize.",
+        10107: "System call failure.",
+        10108: "Service not found.",
+        10109: "Class type not found.",
+        10110: "No more results from WSALookupServiceNext.",
+        10111: "Call was canceled.",
+        10112: "Database query was refused.",
+        11001: "Host not found.",
+        11002: "Nonauthoritative host not found.",
+        11003: "This is a nonrecoverable error.",
+        11004: "Valid name, no data record requested type.",
+        11005: "QoS receivers.",
+        11006: "QoS senders.",
+        11007: "No QoS senders.",
+        11008: "QoS no receivers.",
+        11009: "QoS request confirmed.",
+        11010: "QoS admission error.",
+        11011: "QoS policy failure.",
+        11012: "QoS bad style.",
+        11013: "QoS bad object.",
+        11014: "QoS traffic control error.",
+        11015: "QoS generic error.",
+        11016: "QoS service type error.",
+        11017: "QoS flowspec error.",
+        11018: "Invalid QoS provider buffer.",
+        11019: "Invalid QoS filter style.",
+        11020: "Invalid QoS filter style.",
+        11021: "Incorrect QoS filter count.",
+        11022: "Invalid QoS object length.",
+        11023: "Incorrect QoS flow count.",
+        11024: "Unrecognized QoS object.",
+        11025: "Invalid QoS policy object.",
+        11026: "Invalid QoS flow descriptor.",
+        11027: "Invalid QoS provider-specific flowspec.",
+        11028: "Invalid QoS provider-specific filterspec.",
+        11029: "Invalid QoS shape discard mode object.",
+        11030: "Invalid QoS shaping rate object.",
+        11031: "Reserved policy QoS element type."
+    }
     __all__.append("errorTab")
 
 
@@ -348,6 +351,9 @@ def makefile(self, mode="r", buffering=None, *,
     if hasattr(os, 'sendfile'):
 
         def _sendfile_use_sendfile(self, file, offset=0, count=None):
+            # Lazy import to improve module import time
+            import selectors
+
             self._check_sendfile_params(file, offset, count)
             sockno = self.fileno()
             try:
@@ -549,20 +555,18 @@ def fromfd(fd, family, type, proto=0):
     return socket(family, type, proto, nfd)
 
 if hasattr(_socket.socket, "sendmsg"):
-    import array
-
     def send_fds(sock, buffers, fds, flags=0, address=None):
         """ send_fds(sock, buffers, fds[, flags[, address]]) -> integer
 
         Send the list of file descriptors fds over an AF_UNIX socket.
         """
+        import array
+
         return sock.sendmsg(buffers, [(_socket.SOL_SOCKET,
             _socket.SCM_RIGHTS, array.array("i", fds))])
     __all__.append("send_fds")
 
 if hasattr(_socket.socket, "recvmsg"):
-    import array
-
     def recv_fds(sock, bufsize, maxfds, flags=0):
         """ recv_fds(sock, bufsize, maxfds[, flags]) -> (data, list of file
         descriptors, msg_flags, address)
@@ -570,6 +574,8 @@ def recv_fds(sock, bufsize, maxfds, flags=0):
         Receive up to maxfds file descriptors returning the message
         data and a list containing the descriptors.
         """
+        import array
+
         # Array of ints
         fds = array.array("i")
         msg, ancdata, flags, addr = sock.recvmsg(bufsize,
diff --git a/Lib/ssl.py b/Lib/ssl.py
index c8703b046cf..8889aff92fa 100644
--- a/Lib/ssl.py
+++ b/Lib/ssl.py
@@ -116,7 +116,7 @@
 
 from _ssl import (
     HAS_SNI, HAS_ECDH, HAS_NPN, HAS_ALPN, HAS_SSLv2, HAS_SSLv3, HAS_TLSv1,
-    HAS_TLSv1_1, HAS_TLSv1_2, HAS_TLSv1_3, HAS_PSK
+    HAS_TLSv1_1, HAS_TLSv1_2, HAS_TLSv1_3, HAS_PSK, HAS_PHA
 )
 from _ssl import _DEFAULT_CIPHERS, _OPENSSL_API_VERSION
 
@@ -186,7 +186,7 @@ class _TLSContentType:
 class _TLSAlertType:
     """Alert types for TLSContentType.ALERT messages
 
-    See RFC 8466, section B.2
+    See RFC 8446, section B.2
     """
     CLOSE_NOTIFY = 0
     UNEXPECTED_MESSAGE = 10
diff --git a/Lib/stat.py b/Lib/stat.py
index 1b4ed1ebc94..81f694329bf 100644
--- a/Lib/stat.py
+++ b/Lib/stat.py
@@ -166,9 +166,14 @@ def filemode(mode):
     perm = []
     for index, table in enumerate(_filemode_table):
         for bit, char in table:
-            if mode & bit == bit:
-                perm.append(char)
-                break
+            if index == 0:
+                if S_IFMT(mode) == bit:
+                    perm.append(char)
+                    break
+            else:
+                if mode & bit == bit:
+                    perm.append(char)
+                    break
         else:
             if index == 0:
                 # Unknown filetype
diff --git a/Lib/statistics.py b/Lib/statistics.py
index ad4a94219cf..26cf925529e 100644
--- a/Lib/statistics.py
+++ b/Lib/statistics.py
@@ -138,7 +138,7 @@
 from decimal import Decimal
 from itertools import count, groupby, repeat
 from bisect import bisect_left, bisect_right
-from math import hypot, sqrt, fabs, exp, erf, tau, log, fsum, sumprod
+from math import hypot, sqrt, fabs, exp, erfc, tau, log, fsum, sumprod
 from math import isfinite, isinf, pi, cos, sin, tan, cosh, asin, atan, acos
 from functools import reduce
 from operator import itemgetter
@@ -147,447 +147,149 @@
 _SQRT2 = sqrt(2.0)
 _random = random
 
-# === Exceptions ===
+## Exceptions ##############################################################
 
 class StatisticsError(ValueError):
     pass
 
 
-# === Private utilities ===
+## Measures of central tendency (averages) #################################
 
-def _sum(data):
-    """_sum(data) -> (type, sum, count)
-
-    Return a high-precision sum of the given numeric data as a fraction,
-    together with the type to be converted to and the count of items.
-
-    Examples
-    --------
-
-    >>> _sum([3, 2.25, 4.5, -0.5, 0.25])
-    (<class 'float'>, Fraction(19, 2), 5)
-
-    Some sources of round-off error will be avoided:
-
-    # Built-in sum returns zero.
-    >>> _sum([1e50, 1, -1e50] * 1000)
-    (<class 'float'>, Fraction(1000, 1), 3000)
+def mean(data):
+    """Return the sample arithmetic mean of data.
 
-    Fractions and Decimals are also supported:
+    >>> mean([1, 2, 3, 4, 4])
+    2.8
 
     >>> from fractions import Fraction as F
-    >>> _sum([F(2, 3), F(7, 5), F(1, 4), F(5, 6)])
-    (<class 'fractions.Fraction'>, Fraction(63, 20), 4)
+    >>> mean([F(3, 7), F(1, 21), F(5, 3), F(1, 3)])
+    Fraction(13, 21)
 
     >>> from decimal import Decimal as D
-    >>> data = [D("0.1375"), D("0.2108"), D("0.3061"), D("0.0419")]
-    >>> _sum(data)
-    (<class 'decimal.Decimal'>, Fraction(6963, 10000), 4)
+    >>> mean([D("0.5"), D("0.75"), D("0.625"), D("0.375")])
+    Decimal('0.5625')
+
+    If ``data`` is empty, StatisticsError will be raised.
 
-    Mixed types are currently treated as an error, except that int is
-    allowed.
     """
-    count = 0
-    types = set()
-    types_add = types.add
-    partials = {}
-    partials_get = partials.get
-    for typ, values in groupby(data, type):
-        types_add(typ)
-        for n, d in map(_exact_ratio, values):
-            count += 1
-            partials[d] = partials_get(d, 0) + n
-    if None in partials:
-        # The sum will be a NAN or INF. We can ignore all the finite
-        # partials, and just look at this special one.
-        total = partials[None]
-        assert not _isfinite(total)
-    else:
-        # Sum all the partial sums using builtin sum.
-        total = sum(Fraction(n, d) for d, n in partials.items())
-    T = reduce(_coerce, types, int)  # or raise TypeError
-    return (T, total, count)
+    T, total, n = _sum(data)
+    if n < 1:
+        raise StatisticsError('mean requires at least one data point')
+    return _convert(total / n, T)
 
 
-def _ss(data, c=None):
-    """Return the exact mean and sum of square deviations of sequence data.
+def fmean(data, weights=None):
+    """Convert data to floats and compute the arithmetic mean.
 
-    Calculations are done in a single pass, allowing the input to be an iterator.
+    This runs faster than the mean() function and it always returns a float.
+    If the input dataset is empty, it raises a StatisticsError.
 
-    If given *c* is used the mean; otherwise, it is calculated from the data.
-    Use the *c* argument with care, as it can lead to garbage results.
+    >>> fmean([3.5, 4.0, 5.25])
+    4.25
 
     """
-    if c is not None:
-        T, ssd, count = _sum((d := x - c) * d for x in data)
-        return (T, ssd, c, count)
-    count = 0
-    types = set()
-    types_add = types.add
-    sx_partials = defaultdict(int)
-    sxx_partials = defaultdict(int)
-    for typ, values in groupby(data, type):
-        types_add(typ)
-        for n, d in map(_exact_ratio, values):
-            count += 1
-            sx_partials[d] += n
-            sxx_partials[d] += n * n
-    if not count:
-        ssd = c = Fraction(0)
-    elif None in sx_partials:
-        # The sum will be a NAN or INF. We can ignore all the finite
-        # partials, and just look at this special one.
-        ssd = c = sx_partials[None]
-        assert not _isfinite(ssd)
-    else:
-        sx = sum(Fraction(n, d) for d, n in sx_partials.items())
-        sxx = sum(Fraction(n, d*d) for d, n in sxx_partials.items())
-        # This formula has poor numeric properties for floats,
-        # but with fractions it is exact.
-        ssd = (count * sxx - sx * sx) / count
-        c = sx / count
-    T = reduce(_coerce, types, int)  # or raise TypeError
-    return (T, ssd, c, count)
+    if weights is None:
 
+        try:
+            n = len(data)
+        except TypeError:
+            # Handle iterators that do not define __len__().
+            counter = count()
+            total = fsum(map(itemgetter(0), zip(data, counter)))
+            n = next(counter)
+        else:
+            total = fsum(data)
 
-def _isfinite(x):
-    try:
-        return x.is_finite()  # Likely a Decimal.
-    except AttributeError:
-        return math.isfinite(x)  # Coerces to float first.
+        if not n:
+            raise StatisticsError('fmean requires at least one data point')
 
+        return total / n
 
-def _coerce(T, S):
-    """Coerce types T and S to a common type, or raise TypeError.
+    if not isinstance(weights, (list, tuple)):
+        weights = list(weights)
 
-    Coercion rules are currently an implementation detail. See the CoerceTest
-    test class in test_statistics for details.
-    """
-    # See http://bugs.python.org/issue24068.
-    assert T is not bool, "initial type T is bool"
-    # If the types are the same, no need to coerce anything. Put this
-    # first, so that the usual case (no coercion needed) happens as soon
-    # as possible.
-    if T is S:  return T
-    # Mixed int & other coerce to the other type.
-    if S is int or S is bool:  return T
-    if T is int:  return S
-    # If one is a (strict) subclass of the other, coerce to the subclass.
-    if issubclass(S, T):  return S
-    if issubclass(T, S):  return T
-    # Ints coerce to the other type.
-    if issubclass(T, int):  return S
-    if issubclass(S, int):  return T
-    # Mixed fraction & float coerces to float (or float subclass).
-    if issubclass(T, Fraction) and issubclass(S, float):
-        return S
-    if issubclass(T, float) and issubclass(S, Fraction):
-        return T
-    # Any other combination is disallowed.
-    msg = "don't know how to coerce %s and %s"
-    raise TypeError(msg % (T.__name__, S.__name__))
+    try:
+        num = sumprod(data, weights)
+    except ValueError:
+        raise StatisticsError('data and weights must be the same length')
 
+    den = fsum(weights)
 
-def _exact_ratio(x):
-    """Return Real number x to exact (numerator, denominator) pair.
+    if not den:
+        raise StatisticsError('sum of weights must be non-zero')
 
-    >>> _exact_ratio(0.25)
-    (1, 4)
+    return num / den
 
-    x is expected to be an int, Fraction, Decimal or float.
-    """
 
-    # XXX We should revisit whether using fractions to accumulate exact
-    # ratios is the right way to go.
+def geometric_mean(data):
+    """Convert data to floats and compute the geometric mean.
 
-    # The integer ratios for binary floats can have numerators or
-    # denominators with over 300 decimal digits.  The problem is more
-    # acute with decimal floats where the default decimal context
-    # supports a huge range of exponents from Emin=-999999 to
-    # Emax=999999.  When expanded with as_integer_ratio(), numbers like
-    # Decimal('3.14E+5000') and Decimal('3.14E-5000') have large
-    # numerators or denominators that will slow computation.
+    Raises a StatisticsError if the input dataset is empty
+    or if it contains a negative value.
 
-    # When the integer ratios are accumulated as fractions, the size
-    # grows to cover the full range from the smallest magnitude to the
-    # largest.  For example, Fraction(3.14E+300) + Fraction(3.14E-300),
-    # has a 616 digit numerator.  Likewise,
-    # Fraction(Decimal('3.14E+5000')) + Fraction(Decimal('3.14E-5000'))
-    # has 10,003 digit numerator.
+    Returns zero if the product of inputs is zero.
 
-    # This doesn't seem to have been problem in practice, but it is a
-    # potential pitfall.
+    No special efforts are made to achieve exact results.
+    (However, this may change in the future.)
 
-    try:
-        return x.as_integer_ratio()
-    except AttributeError:
-        pass
-    except (OverflowError, ValueError):
-        # float NAN or INF.
-        assert not _isfinite(x)
-        return (x, None)
-    try:
-        # x may be an Integral ABC.
-        return (x.numerator, x.denominator)
-    except AttributeError:
-        msg = f"can't convert type '{type(x).__name__}' to numerator/denominator"
-        raise TypeError(msg)
+    >>> round(geometric_mean([54, 24, 36]), 9)
+    36.0
 
+    """
+    n = 0
+    found_zero = False
 
-def _convert(value, T):
-    """Convert value to given numeric type T."""
-    if type(value) is T:
-        # This covers the cases where T is Fraction, or where value is
-        # a NAN or INF (Decimal or float).
-        return value
-    if issubclass(T, int) and value.denominator != 1:
-        T = float
-    try:
-        # FIXME: what do we do if this overflows?
-        return T(value)
-    except TypeError:
-        if issubclass(T, Decimal):
-            return T(value.numerator) / T(value.denominator)
-        else:
-            raise
+    def count_positive(iterable):
+        nonlocal n, found_zero
+        for n, x in enumerate(iterable, start=1):
+            if x > 0.0 or math.isnan(x):
+                yield x
+            elif x == 0.0:
+                found_zero = True
+            else:
+                raise StatisticsError('No negative inputs allowed', x)
 
+    total = fsum(map(log, count_positive(data)))
 
-def _fail_neg(values, errmsg='negative value'):
-    """Iterate over values, failing if any are less than zero."""
-    for x in values:
-        if x < 0:
-            raise StatisticsError(errmsg)
-        yield x
+    if not n:
+        raise StatisticsError('Must have a non-empty dataset')
+    if math.isnan(total):
+        return math.nan
+    if found_zero:
+        return math.nan if total == math.inf else 0.0
 
+    return exp(total / n)
 
-def _rank(data, /, *, key=None, reverse=False, ties='average', start=1) -> list[float]:
-    """Rank order a dataset. The lowest value has rank 1.
 
-    Ties are averaged so that equal values receive the same rank:
+def harmonic_mean(data, weights=None):
+    """Return the harmonic mean of data.
 
-        >>> data = [31, 56, 31, 25, 75, 18]
-        >>> _rank(data)
-        [3.5, 5.0, 3.5, 2.0, 6.0, 1.0]
+    The harmonic mean is the reciprocal of the arithmetic mean of the
+    reciprocals of the data.  It can be used for averaging ratios or
+    rates, for example speeds.
 
-    The operation is idempotent:
+    Suppose a car travels 40 km/hr for 5 km and then speeds-up to
+    60 km/hr for another 5 km. What is the average speed?
 
-        >>> _rank([3.5, 5.0, 3.5, 2.0, 6.0, 1.0])
-        [3.5, 5.0, 3.5, 2.0, 6.0, 1.0]
+        >>> harmonic_mean([40, 60])
+        48.0
 
-    It is possible to rank the data in reverse order so that the
-    highest value has rank 1.  Also, a key-function can extract
-    the field to be ranked:
+    Suppose a car travels 40 km/hr for 5 km, and when traffic clears,
+    speeds-up to 60 km/hr for the remaining 30 km of the journey. What
+    is the average speed?
 
-        >>> goals = [('eagles', 45), ('bears', 48), ('lions', 44)]
-        >>> _rank(goals, key=itemgetter(1), reverse=True)
-        [2.0, 1.0, 3.0]
+        >>> harmonic_mean([40, 60], weights=[5, 30])
+        56.0
 
-    Ranks are conventionally numbered starting from one; however,
-    setting *start* to zero allows the ranks to be used as array indices:
+    If ``data`` is empty, or any element is less than zero,
+    ``harmonic_mean`` will raise ``StatisticsError``.
 
-        >>> prize = ['Gold', 'Silver', 'Bronze', 'Certificate']
-        >>> scores = [8.1, 7.3, 9.4, 8.3]
-        >>> [prize[int(i)] for i in _rank(scores, start=0, reverse=True)]
-        ['Bronze', 'Certificate', 'Gold', 'Silver']
-
-    """
-    # If this function becomes public at some point, more thought
-    # needs to be given to the signature.  A list of ints is
-    # plausible when ties is "min" or "max".  When ties is "average",
-    # either list[float] or list[Fraction] is plausible.
-
-    # Default handling of ties matches scipy.stats.mstats.spearmanr.
-    if ties != 'average':
-        raise ValueError(f'Unknown tie resolution method: {ties!r}')
-    if key is not None:
-        data = map(key, data)
-    val_pos = sorted(zip(data, count()), reverse=reverse)
-    i = start - 1
-    result = [0] * len(val_pos)
-    for _, g in groupby(val_pos, key=itemgetter(0)):
-        group = list(g)
-        size = len(group)
-        rank = i + (size + 1) / 2
-        for value, orig_pos in group:
-            result[orig_pos] = rank
-        i += size
-    return result
-
-
-def _integer_sqrt_of_frac_rto(n: int, m: int) -> int:
-    """Square root of n/m, rounded to the nearest integer using round-to-odd."""
-    # Reference: https://www.lri.fr/~melquion/doc/05-imacs17_1-expose.pdf
-    a = math.isqrt(n // m)
-    return a | (a*a*m != n)
-
-
-# For 53 bit precision floats, the bit width used in
-# _float_sqrt_of_frac() is 109.
-_sqrt_bit_width: int = 2 * sys.float_info.mant_dig + 3
-
-
-def _float_sqrt_of_frac(n: int, m: int) -> float:
-    """Square root of n/m as a float, correctly rounded."""
-    # See principle and proof sketch at: https://bugs.python.org/msg407078
-    q = (n.bit_length() - m.bit_length() - _sqrt_bit_width) // 2
-    if q >= 0:
-        numerator = _integer_sqrt_of_frac_rto(n, m << 2 * q) << q
-        denominator = 1
-    else:
-        numerator = _integer_sqrt_of_frac_rto(n << -2 * q, m)
-        denominator = 1 << -q
-    return numerator / denominator   # Convert to float
-
-
-def _decimal_sqrt_of_frac(n: int, m: int) -> Decimal:
-    """Square root of n/m as a Decimal, correctly rounded."""
-    # Premise:  For decimal, computing (n/m).sqrt() can be off
-    #           by 1 ulp from the correctly rounded result.
-    # Method:   Check the result, moving up or down a step if needed.
-    if n <= 0:
-        if not n:
-            return Decimal('0.0')
-        n, m = -n, -m
-
-    root = (Decimal(n) / Decimal(m)).sqrt()
-    nr, dr = root.as_integer_ratio()
-
-    plus = root.next_plus()
-    np, dp = plus.as_integer_ratio()
-    # test: n / m > ((root + plus) / 2) ** 2
-    if 4 * n * (dr*dp)**2 > m * (dr*np + dp*nr)**2:
-        return plus
-
-    minus = root.next_minus()
-    nm, dm = minus.as_integer_ratio()
-    # test: n / m < ((root + minus) / 2) ** 2
-    if 4 * n * (dr*dm)**2 < m * (dr*nm + dm*nr)**2:
-        return minus
-
-    return root
-
-
-# === Measures of central tendency (averages) ===
-
-def mean(data):
-    """Return the sample arithmetic mean of data.
-
-    >>> mean([1, 2, 3, 4, 4])
-    2.8
-
-    >>> from fractions import Fraction as F
-    >>> mean([F(3, 7), F(1, 21), F(5, 3), F(1, 3)])
-    Fraction(13, 21)
-
-    >>> from decimal import Decimal as D
-    >>> mean([D("0.5"), D("0.75"), D("0.625"), D("0.375")])
-    Decimal('0.5625')
-
-    If ``data`` is empty, StatisticsError will be raised.
-    """
-    T, total, n = _sum(data)
-    if n < 1:
-        raise StatisticsError('mean requires at least one data point')
-    return _convert(total / n, T)
-
-
-def fmean(data, weights=None):
-    """Convert data to floats and compute the arithmetic mean.
-
-    This runs faster than the mean() function and it always returns a float.
-    If the input dataset is empty, it raises a StatisticsError.
-
-    >>> fmean([3.5, 4.0, 5.25])
-    4.25
-    """
-    if weights is None:
-        try:
-            n = len(data)
-        except TypeError:
-            # Handle iterators that do not define __len__().
-            n = 0
-            def count(iterable):
-                nonlocal n
-                for n, x in enumerate(iterable, start=1):
-                    yield x
-            data = count(data)
-        total = fsum(data)
-        if not n:
-            raise StatisticsError('fmean requires at least one data point')
-        return total / n
-    if not isinstance(weights, (list, tuple)):
-        weights = list(weights)
-    try:
-        num = sumprod(data, weights)
-    except ValueError:
-        raise StatisticsError('data and weights must be the same length')
-    den = fsum(weights)
-    if not den:
-        raise StatisticsError('sum of weights must be non-zero')
-    return num / den
-
-
-def geometric_mean(data):
-    """Convert data to floats and compute the geometric mean.
-
-    Raises a StatisticsError if the input dataset is empty
-    or if it contains a negative value.
-
-    Returns zero if the product of inputs is zero.
-
-    No special efforts are made to achieve exact results.
-    (However, this may change in the future.)
-
-    >>> round(geometric_mean([54, 24, 36]), 9)
-    36.0
-    """
-    n = 0
-    found_zero = False
-    def count_positive(iterable):
-        nonlocal n, found_zero
-        for n, x in enumerate(iterable, start=1):
-            if x > 0.0 or math.isnan(x):
-                yield x
-            elif x == 0.0:
-                found_zero = True
-            else:
-                raise StatisticsError('No negative inputs allowed', x)
-    total = fsum(map(log, count_positive(data)))
-    if not n:
-        raise StatisticsError('Must have a non-empty dataset')
-    if math.isnan(total):
-        return math.nan
-    if found_zero:
-        return math.nan if total == math.inf else 0.0
-    return exp(total / n)
-
-
-def harmonic_mean(data, weights=None):
-    """Return the harmonic mean of data.
-
-    The harmonic mean is the reciprocal of the arithmetic mean of the
-    reciprocals of the data.  It can be used for averaging ratios or
-    rates, for example speeds.
-
-    Suppose a car travels 40 km/hr for 5 km and then speeds-up to
-    60 km/hr for another 5 km. What is the average speed?
-
-        >>> harmonic_mean([40, 60])
-        48.0
-
-    Suppose a car travels 40 km/hr for 5 km, and when traffic clears,
-    speeds-up to 60 km/hr for the remaining 30 km of the journey. What
-    is the average speed?
-
-        >>> harmonic_mean([40, 60], weights=[5, 30])
-        56.0
-
-    If ``data`` is empty, or any element is less than zero,
-    ``harmonic_mean`` will raise ``StatisticsError``.
     """
     if iter(data) is data:
         data = list(data)
+
     errmsg = 'harmonic mean does not support negative values'
+
     n = len(data)
     if n < 1:
         raise StatisticsError('harmonic_mean requires at least one data point')
@@ -599,6 +301,7 @@ def harmonic_mean(data, weights=None):
             return x
         else:
             raise TypeError('unsupported type')
+
     if weights is None:
         weights = repeat(1, n)
         sum_weights = n
@@ -608,16 +311,19 @@ def harmonic_mean(data, weights=None):
         if len(weights) != n:
             raise StatisticsError('Number of weights does not match data size')
         _, sum_weights, _ = _sum(w for w in _fail_neg(weights, errmsg))
+
     try:
         data = _fail_neg(data, errmsg)
         T, total, count = _sum(w / x if w else 0 for w, x in zip(weights, data))
     except ZeroDivisionError:
         return 0
+
     if total <= 0:
         raise StatisticsError('Weighted sum must be positive')
+
     return _convert(sum_weights / total, T)
 
-# FIXME: investigate ways to calculate medians without sorting? Quickselect?
+
 def median(data):
     """Return the median (middle value) of numeric data.
 
@@ -654,6 +360,9 @@ def median_low(data):
     3
 
     """
+    # Potentially the sorting step could be replaced with a quickselect.
+    # However, it would require an excellent implementation to beat our
+    # highly optimized builtin sort.
     data = sorted(data)
     n = len(data)
     if n == 0:
@@ -797,6 +506,7 @@ def multimode(data):
     ['b', 'd', 'f']
     >>> multimode('')
     []
+
     """
     counts = Counter(iter(data))
     if not counts:
@@ -805,347 +515,48 @@ def multimode(data):
     return [value for value, count in counts.items() if count == maxcount]
 
 
-def kde(data, h, kernel='normal', *, cumulative=False):
-    """Kernel Density Estimation:  Create a continuous probability density
-    function or cumulative distribution function from discrete samples.
+## Measures of spread ######################################################
 
-    The basic idea is to smooth the data using a kernel function
-    to help draw inferences about a population from a sample.
+def variance(data, xbar=None):
+    """Return the sample variance of data.
 
-    The degree of smoothing is controlled by the scaling parameter h
-    which is called the bandwidth.  Smaller values emphasize local
-    features while larger values give smoother results.
+    data should be an iterable of Real-valued numbers, with at least two
+    values. The optional argument xbar, if given, should be the mean of
+    the data. If it is missing or None, the mean is automatically calculated.
 
-    The kernel determines the relative weights of the sample data
-    points.  Generally, the choice of kernel shape does not matter
-    as much as the more influential bandwidth smoothing parameter.
+    Use this function when your data is a sample from a population. To
+    calculate the variance from the entire population, see ``pvariance``.
 
-    Kernels that give some weight to every sample point:
+    Examples:
 
-       normal (gauss)
-       logistic
-       sigmoid
+    >>> data = [2.75, 1.75, 1.25, 0.25, 0.5, 1.25, 3.5]
+    >>> variance(data)
+    1.3720238095238095
 
-    Kernels that only give weight to sample points within
-    the bandwidth:
+    If you have already calculated the mean of your data, you can pass it as
+    the optional second argument ``xbar`` to avoid recalculating it:
 
-       rectangular (uniform)
-       triangular
-       parabolic (epanechnikov)
-       quartic (biweight)
-       triweight
-       cosine
+    >>> m = mean(data)
+    >>> variance(data, m)
+    1.3720238095238095
 
-    If *cumulative* is true, will return a cumulative distribution function.
+    This function does not check that ``xbar`` is actually the mean of
+    ``data``. Giving arbitrary values for ``xbar`` may lead to invalid or
+    impossible results.
 
-    A StatisticsError will be raised if the data sequence is empty.
+    Decimals and Fractions are supported:
 
-    Example
-    -------
+    >>> from decimal import Decimal as D
+    >>> variance([D("27.5"), D("30.25"), D("30.25"), D("34.5"), D("41.75")])
+    Decimal('31.01875')
 
-    Given a sample of six data points, construct a continuous
-    function that estimates the underlying probability density:
+    >>> from fractions import Fraction as F
+    >>> variance([F(1, 6), F(1, 2), F(5, 3)])
+    Fraction(67, 108)
 
-        >>> sample = [-2.1, -1.3, -0.4, 1.9, 5.1, 6.2]
-        >>> f_hat = kde(sample, h=1.5)
-
-    Compute the area under the curve:
-
-        >>> area = sum(f_hat(x) for x in range(-20, 20))
-        >>> round(area, 4)
-        1.0
-
-    Plot the estimated probability density function at
-    evenly spaced points from -6 to 10:
-
-        >>> for x in range(-6, 11):
-        ...     density = f_hat(x)
-        ...     plot = ' ' * int(density * 400) + 'x'
-        ...     print(f'{x:2}: {density:.3f} {plot}')
-        ...
-        -6: 0.002 x
-        -5: 0.009    x
-        -4: 0.031             x
-        -3: 0.070                             x
-        -2: 0.111                                             x
-        -1: 0.125                                                   x
-         0: 0.110                                            x
-         1: 0.086                                   x
-         2: 0.068                            x
-         3: 0.059                        x
-         4: 0.066                           x
-         5: 0.082                                 x
-         6: 0.082                                 x
-         7: 0.058                        x
-         8: 0.028            x
-         9: 0.009    x
-        10: 0.002 x
-
-    Estimate P(4.5 < X <= 7.5), the probability that a new sample value
-    will be between 4.5 and 7.5:
-
-        >>> cdf = kde(sample, h=1.5, cumulative=True)
-        >>> round(cdf(7.5) - cdf(4.5), 2)
-        0.22
-
-    References
-    ----------
-
-    Kernel density estimation and its application:
-    https://www.itm-conferences.org/articles/itmconf/pdf/2018/08/itmconf_sam2018_00037.pdf
-
-    Kernel functions in common use:
-    https://en.wikipedia.org/wiki/Kernel_(statistics)#kernel_functions_in_common_use
-
-    Interactive graphical demonstration and exploration:
-    https://demonstrations.wolfram.com/KernelDensityEstimation/
-
-    Kernel estimation of cumulative distribution function of a random variable with bounded support
-    https://www.econstor.eu/bitstream/10419/207829/1/10.21307_stattrans-2016-037.pdf
-
-    """
-
-    n = len(data)
-    if not n:
-        raise StatisticsError('Empty data sequence')
-
-    if not isinstance(data[0], (int, float)):
-        raise TypeError('Data sequence must contain ints or floats')
-
-    if h <= 0.0:
-        raise StatisticsError(f'Bandwidth h must be positive, not {h=!r}')
-
-    match kernel:
-
-        case 'normal' | 'gauss':
-            sqrt2pi = sqrt(2 * pi)
-            sqrt2 = sqrt(2)
-            K = lambda t: exp(-1/2 * t * t) / sqrt2pi
-            W = lambda t: 1/2 * (1.0 + erf(t / sqrt2))
-            support = None
-
-        case 'logistic':
-            # 1.0 / (exp(t) + 2.0 + exp(-t))
-            K = lambda t: 1/2 / (1.0 + cosh(t))
-            W = lambda t: 1.0 - 1.0 / (exp(t) + 1.0)
-            support = None
-
-        case 'sigmoid':
-            # (2/pi) / (exp(t) + exp(-t))
-            c1 = 1 / pi
-            c2 = 2 / pi
-            K = lambda t: c1 / cosh(t)
-            W = lambda t: c2 * atan(exp(t))
-            support = None
-
-        case 'rectangular' | 'uniform':
-            K = lambda t: 1/2
-            W = lambda t: 1/2 * t + 1/2
-            support = 1.0
-
-        case 'triangular':
-            K = lambda t: 1.0 - abs(t)
-            W = lambda t: t*t * (1/2 if t < 0.0 else -1/2) + t + 1/2
-            support = 1.0
-
-        case 'parabolic' | 'epanechnikov':
-            K = lambda t: 3/4 * (1.0 - t * t)
-            W = lambda t: -1/4 * t**3 + 3/4 * t + 1/2
-            support = 1.0
-
-        case 'quartic' | 'biweight':
-            K = lambda t: 15/16 * (1.0 - t * t) ** 2
-            W = lambda t: 3/16 * t**5 - 5/8 * t**3 + 15/16 * t + 1/2
-            support = 1.0
-
-        case 'triweight':
-            K = lambda t: 35/32 * (1.0 - t * t) ** 3
-            W = lambda t: 35/32 * (-1/7*t**7 + 3/5*t**5 - t**3 + t) + 1/2
-            support = 1.0
-
-        case 'cosine':
-            c1 = pi / 4
-            c2 = pi / 2
-            K = lambda t: c1 * cos(c2 * t)
-            W = lambda t: 1/2 * sin(c2 * t) + 1/2
-            support = 1.0
-
-        case _:
-            raise StatisticsError(f'Unknown kernel name: {kernel!r}')
-
-    if support is None:
-
-        def pdf(x):
-            n = len(data)
-            return sum(K((x - x_i) / h) for x_i in data) / (n * h)
-
-        def cdf(x):
-            n = len(data)
-            return sum(W((x - x_i) / h) for x_i in data) / n
-
-    else:
-
-        sample = sorted(data)
-        bandwidth = h * support
-
-        def pdf(x):
-            nonlocal n, sample
-            if len(data) != n:
-                sample = sorted(data)
-                n = len(data)
-            i = bisect_left(sample, x - bandwidth)
-            j = bisect_right(sample, x + bandwidth)
-            supported = sample[i : j]
-            return sum(K((x - x_i) / h) for x_i in supported) / (n * h)
-
-        def cdf(x):
-            nonlocal n, sample
-            if len(data) != n:
-                sample = sorted(data)
-                n = len(data)
-            i = bisect_left(sample, x - bandwidth)
-            j = bisect_right(sample, x + bandwidth)
-            supported = sample[i : j]
-            return sum((W((x - x_i) / h) for x_i in supported), i) / n
-
-    if cumulative:
-        cdf.__doc__ = f'CDF estimate with {h=!r} and {kernel=!r}'
-        return cdf
-
-    else:
-        pdf.__doc__ = f'PDF estimate with {h=!r} and {kernel=!r}'
-        return pdf
-
-
-# Notes on methods for computing quantiles
-# ----------------------------------------
-#
-# There is no one perfect way to compute quantiles.  Here we offer
-# two methods that serve common needs.  Most other packages
-# surveyed offered at least one or both of these two, making them
-# "standard" in the sense of "widely-adopted and reproducible".
-# They are also easy to explain, easy to compute manually, and have
-# straight-forward interpretations that aren't surprising.
-
-# The default method is known as "R6", "PERCENTILE.EXC", or "expected
-# value of rank order statistics". The alternative method is known as
-# "R7", "PERCENTILE.INC", or "mode of rank order statistics".
-
-# For sample data where there is a positive probability for values
-# beyond the range of the data, the R6 exclusive method is a
-# reasonable choice.  Consider a random sample of nine values from a
-# population with a uniform distribution from 0.0 to 1.0.  The
-# distribution of the third ranked sample point is described by
-# betavariate(alpha=3, beta=7) which has mode=0.250, median=0.286, and
-# mean=0.300.  Only the latter (which corresponds with R6) gives the
-# desired cut point with 30% of the population falling below that
-# value, making it comparable to a result from an inv_cdf() function.
-# The R6 exclusive method is also idempotent.
-
-# For describing population data where the end points are known to
-# be included in the data, the R7 inclusive method is a reasonable
-# choice.  Instead of the mean, it uses the mode of the beta
-# distribution for the interior points.  Per Hyndman & Fan, "One nice
-# property is that the vertices of Q7(p) divide the range into n - 1
-# intervals, and exactly 100p% of the intervals lie to the left of
-# Q7(p) and 100(1 - p)% of the intervals lie to the right of Q7(p)."
-
-# If needed, other methods could be added.  However, for now, the
-# position is that fewer options make for easier choices and that
-# external packages can be used for anything more advanced.
-
-def quantiles(data, *, n=4, method='exclusive'):
-    """Divide *data* into *n* continuous intervals with equal probability.
-
-    Returns a list of (n - 1) cut points separating the intervals.
-
-    Set *n* to 4 for quartiles (the default).  Set *n* to 10 for deciles.
-    Set *n* to 100 for percentiles which gives the 99 cuts points that
-    separate *data* in to 100 equal sized groups.
-
-    The *data* can be any iterable containing sample.
-    The cut points are linearly interpolated between data points.
-
-    If *method* is set to *inclusive*, *data* is treated as population
-    data.  The minimum value is treated as the 0th percentile and the
-    maximum value is treated as the 100th percentile.
     """
-    if n < 1:
-        raise StatisticsError('n must be at least 1')
-    data = sorted(data)
-    ld = len(data)
-    if ld < 2:
-        if ld == 1:
-            return data * (n - 1)
-        raise StatisticsError('must have at least one data point')
-
-    if method == 'inclusive':
-        m = ld - 1
-        result = []
-        for i in range(1, n):
-            j, delta = divmod(i * m, n)
-            interpolated = (data[j] * (n - delta) + data[j + 1] * delta) / n
-            result.append(interpolated)
-        return result
-
-    if method == 'exclusive':
-        m = ld + 1
-        result = []
-        for i in range(1, n):
-            j = i * m // n                               # rescale i to m/n
-            j = 1 if j < 1 else ld-1 if j > ld-1 else j  # clamp to 1 .. ld-1
-            delta = i*m - j*n                            # exact integer math
-            interpolated = (data[j - 1] * (n - delta) + data[j] * delta) / n
-            result.append(interpolated)
-        return result
-
-    raise ValueError(f'Unknown method: {method!r}')
-
-
-# === Measures of spread ===
-
-# See http://mathworld.wolfram.com/Variance.html
-#     http://mathworld.wolfram.com/SampleVariance.html
+    # http://mathworld.wolfram.com/SampleVariance.html
 
-
-def variance(data, xbar=None):
-    """Return the sample variance of data.
-
-    data should be an iterable of Real-valued numbers, with at least two
-    values. The optional argument xbar, if given, should be the mean of
-    the data. If it is missing or None, the mean is automatically calculated.
-
-    Use this function when your data is a sample from a population. To
-    calculate the variance from the entire population, see ``pvariance``.
-
-    Examples:
-
-    >>> data = [2.75, 1.75, 1.25, 0.25, 0.5, 1.25, 3.5]
-    >>> variance(data)
-    1.3720238095238095
-
-    If you have already calculated the mean of your data, you can pass it as
-    the optional second argument ``xbar`` to avoid recalculating it:
-
-    >>> m = mean(data)
-    >>> variance(data, m)
-    1.3720238095238095
-
-    This function does not check that ``xbar`` is actually the mean of
-    ``data``. Giving arbitrary values for ``xbar`` may lead to invalid or
-    impossible results.
-
-    Decimals and Fractions are supported:
-
-    >>> from decimal import Decimal as D
-    >>> variance([D("27.5"), D("30.25"), D("30.25"), D("34.5"), D("41.75")])
-    Decimal('31.01875')
-
-    >>> from fractions import Fraction as F
-    >>> variance([F(1, 6), F(1, 2), F(5, 3)])
-    Fraction(67, 108)
-
-    """
     T, ss, c, n = _ss(data, xbar)
     if n < 2:
         raise StatisticsError('variance requires at least two data points')
@@ -1187,6 +598,8 @@ def pvariance(data, mu=None):
     Fraction(13, 72)
 
     """
+    # http://mathworld.wolfram.com/Variance.html
+
     T, ss, c, n = _ss(data, mu)
     if n < 1:
         raise StatisticsError('pvariance requires at least one data point')
@@ -1206,9 +619,14 @@ def stdev(data, xbar=None):
     if n < 2:
         raise StatisticsError('stdev requires at least two data points')
     mss = ss / (n - 1)
+    try:
+        mss_numerator = mss.numerator
+        mss_denominator = mss.denominator
+    except AttributeError:
+        raise ValueError('inf or nan encountered in data')
     if issubclass(T, Decimal):
-        return _decimal_sqrt_of_frac(mss.numerator, mss.denominator)
-    return _float_sqrt_of_frac(mss.numerator, mss.denominator)
+        return _decimal_sqrt_of_frac(mss_numerator, mss_denominator)
+    return _float_sqrt_of_frac(mss_numerator, mss_denominator)
 
 
 def pstdev(data, mu=None):
@@ -1224,51 +642,17 @@ def pstdev(data, mu=None):
     if n < 1:
         raise StatisticsError('pstdev requires at least one data point')
     mss = ss / n
+    try:
+        mss_numerator = mss.numerator
+        mss_denominator = mss.denominator
+    except AttributeError:
+        raise ValueError('inf or nan encountered in data')
     if issubclass(T, Decimal):
-        return _decimal_sqrt_of_frac(mss.numerator, mss.denominator)
-    return _float_sqrt_of_frac(mss.numerator, mss.denominator)
+        return _decimal_sqrt_of_frac(mss_numerator, mss_denominator)
+    return _float_sqrt_of_frac(mss_numerator, mss_denominator)
 
 
-def _mean_stdev(data):
-    """In one pass, compute the mean and sample standard deviation as floats."""
-    T, ss, xbar, n = _ss(data)
-    if n < 2:
-        raise StatisticsError('stdev requires at least two data points')
-    mss = ss / (n - 1)
-    try:
-        return float(xbar), _float_sqrt_of_frac(mss.numerator, mss.denominator)
-    except AttributeError:
-        # Handle Nans and Infs gracefully
-        return float(xbar), float(xbar) / float(ss)
-
-def _sqrtprod(x: float, y: float) -> float:
-    "Return sqrt(x * y) computed with improved accuracy and without overflow/underflow."
-    h = sqrt(x * y)
-    if not isfinite(h):
-        if isinf(h) and not isinf(x) and not isinf(y):
-            # Finite inputs overflowed, so scale down, and recompute.
-            scale = 2.0 ** -512  # sqrt(1 / sys.float_info.max)
-            return _sqrtprod(scale * x, scale * y) / scale
-        return h
-    if not h:
-        if x and y:
-            # Non-zero inputs underflowed, so scale up, and recompute.
-            # Scale:  1 / sqrt(sys.float_info.min * sys.float_info.epsilon)
-            scale = 2.0 ** 537
-            return _sqrtprod(scale * x, scale * y) / scale
-        return h
-    # Improve accuracy with a differential correction.
-    # https://www.wolframalpha.com/input/?i=Maclaurin+series+sqrt%28h**2+%2B+x%29+at+x%3D0
-    d = sumprod((x, h), (y, -h))
-    return h + d / (2.0 * h)
-
-
-# === Statistics for relations between two inputs ===
-
-# See https://en.wikipedia.org/wiki/Covariance
-#     https://en.wikipedia.org/wiki/Pearson_correlation_coefficient
-#     https://en.wikipedia.org/wiki/Simple_linear_regression
-
+## Statistics for relations between two inputs #############################
 
 def covariance(x, y, /):
     """Covariance
@@ -1287,6 +671,7 @@ def covariance(x, y, /):
     -7.5
 
     """
+    # https://en.wikipedia.org/wiki/Covariance
     n = len(x)
     if len(y) != n:
         raise StatisticsError('covariance requires that both inputs have same number of data points')
@@ -1320,7 +705,10 @@ def correlation(x, y, /, *, method='linear'):
     Spearman's rank correlation coefficient is appropriate for ordinal
     data or for continuous data that doesn't meet the linear proportion
     requirement for Pearson's correlation coefficient.
+
     """
+    # https://en.wikipedia.org/wiki/Pearson_correlation_coefficient
+    # https://en.wikipedia.org/wiki/Spearman%27s_rank_correlation_coefficient
     n = len(x)
     if len(y) != n:
         raise StatisticsError('correlation requires that both inputs have same number of data points')
@@ -1328,18 +716,22 @@ def correlation(x, y, /, *, method='linear'):
         raise StatisticsError('correlation requires at least two data points')
     if method not in {'linear', 'ranked'}:
         raise ValueError(f'Unknown method: {method!r}')
+
     if method == 'ranked':
         start = (n - 1) / -2            # Center rankings around zero
         x = _rank(x, start=start)
         y = _rank(y, start=start)
+
     else:
         xbar = fsum(x) / n
         ybar = fsum(y) / n
         x = [xi - xbar for xi in x]
         y = [yi - ybar for yi in y]
+
     sxy = sumprod(x, y)
     sxx = sumprod(x, x)
     syy = sumprod(y, y)
+
     try:
         return sxy / _sqrtprod(sxx, syy)
     except ZeroDivisionError:
@@ -1387,381 +779,317 @@ def linear_regression(x, y, /, *, proportional=False):
     LinearRegression(slope=2.90475..., intercept=0.0)
 
     """
+    # https://en.wikipedia.org/wiki/Simple_linear_regression
     n = len(x)
     if len(y) != n:
         raise StatisticsError('linear regression requires that both inputs have same number of data points')
     if n < 2:
         raise StatisticsError('linear regression requires at least two data points')
+
     if not proportional:
         xbar = fsum(x) / n
         ybar = fsum(y) / n
         x = [xi - xbar for xi in x]  # List because used three times below
         y = (yi - ybar for yi in y)  # Generator because only used once below
+
     sxy = sumprod(x, y) + 0.0        # Add zero to coerce result to a float
     sxx = sumprod(x, x)
+
     try:
         slope = sxy / sxx   # equivalent to:  covariance(x, y) / variance(x)
     except ZeroDivisionError:
         raise StatisticsError('x is constant')
+
     intercept = 0.0 if proportional else ybar - slope * xbar
     return LinearRegression(slope=slope, intercept=intercept)
 
 
-## Normal Distribution #####################################################
-
+## Kernel Density Estimation ###############################################
+
+_kernel_specs = {}
+
+def register(*kernels):
+    "Load the kernel's pdf, cdf, invcdf, and support into _kernel_specs."
+    def deco(builder):
+        spec = dict(zip(('pdf', 'cdf', 'invcdf', 'support'), builder()))
+        for kernel in kernels:
+            _kernel_specs[kernel] = spec
+        return builder
+    return deco
+
+@register('normal', 'gauss')
+def normal_kernel():
+    sqrt2pi = sqrt(2 * pi)
+    neg_sqrt2 = -sqrt(2)
+    pdf = lambda t: exp(-1/2 * t * t) / sqrt2pi
+    cdf = lambda t: 1/2 * erfc(t / neg_sqrt2)
+    invcdf = lambda t: _normal_dist_inv_cdf(t, 0.0, 1.0)
+    support = None
+    return pdf, cdf, invcdf, support
+
+@register('logistic')
+def logistic_kernel():
+    # 1.0 / (exp(t) + 2.0 + exp(-t))
+    pdf = lambda t: 1/2 / (1.0 + cosh(t))
+    cdf = lambda t: 1.0 - 1.0 / (exp(t) + 1.0)
+    invcdf = lambda p: log(p / (1.0 - p))
+    support = None
+    return pdf, cdf, invcdf, support
+
+@register('sigmoid')
+def sigmoid_kernel():
+    # (2/pi) / (exp(t) + exp(-t))
+    c1 = 1 / pi
+    c2 = 2 / pi
+    c3 = pi / 2
+    pdf = lambda t: c1 / cosh(t)
+    cdf = lambda t: c2 * atan(exp(t))
+    invcdf = lambda p: log(tan(p * c3))
+    support = None
+    return pdf, cdf, invcdf, support
+
+@register('rectangular', 'uniform')
+def rectangular_kernel():
+    pdf = lambda t: 1/2
+    cdf = lambda t: 1/2 * t + 1/2
+    invcdf = lambda p: 2.0 * p - 1.0
+    support = 1.0
+    return pdf, cdf, invcdf, support
+
+@register('triangular')
+def triangular_kernel():
+    pdf = lambda t: 1.0 - abs(t)
+    cdf = lambda t: t*t * (1/2 if t < 0.0 else -1/2) + t + 1/2
+    invcdf = lambda p: sqrt(2.0*p) - 1.0 if p < 1/2 else 1.0 - sqrt(2.0 - 2.0*p)
+    support = 1.0
+    return pdf, cdf, invcdf, support
+
+@register('parabolic', 'epanechnikov')
+def parabolic_kernel():
+    pdf = lambda t: 3/4 * (1.0 - t * t)
+    cdf = lambda t: sumprod((-1/4, 3/4, 1/2), (t**3, t, 1.0))
+    invcdf = lambda p: 2.0 * cos((acos(2.0*p - 1.0) + pi) / 3.0)
+    support = 1.0
+    return pdf, cdf, invcdf, support
 
-def _normal_dist_inv_cdf(p, mu, sigma):
-    # There is no closed-form solution to the inverse CDF for the normal
-    # distribution, so we use a rational approximation instead:
-    # Wichura, M.J. (1988). "Algorithm AS241: The Percentage Points of the
-    # Normal Distribution".  Applied Statistics. Blackwell Publishing. 37
-    # (3): 477–484. doi:10.2307/2347330. JSTOR 2347330.
-    q = p - 0.5
-    if fabs(q) <= 0.425:
-        r = 0.180625 - q * q
-        # Hash sum: 55.88319_28806_14901_4439
-        num = (((((((2.50908_09287_30122_6727e+3 * r +
-                     3.34305_75583_58812_8105e+4) * r +
-                     6.72657_70927_00870_0853e+4) * r +
-                     4.59219_53931_54987_1457e+4) * r +
-                     1.37316_93765_50946_1125e+4) * r +
-                     1.97159_09503_06551_4427e+3) * r +
-                     1.33141_66789_17843_7745e+2) * r +
-                     3.38713_28727_96366_6080e+0) * q
-        den = (((((((5.22649_52788_52854_5610e+3 * r +
-                     2.87290_85735_72194_2674e+4) * r +
-                     3.93078_95800_09271_0610e+4) * r +
-                     2.12137_94301_58659_5867e+4) * r +
-                     5.39419_60214_24751_1077e+3) * r +
-                     6.87187_00749_20579_0830e+2) * r +
-                     4.23133_30701_60091_1252e+1) * r +
-                     1.0)
-        x = num / den
-        return mu + (x * sigma)
-    r = p if q <= 0.0 else 1.0 - p
-    r = sqrt(-log(r))
-    if r <= 5.0:
-        r = r - 1.6
-        # Hash sum: 49.33206_50330_16102_89036
-        num = (((((((7.74545_01427_83414_07640e-4 * r +
-                     2.27238_44989_26918_45833e-2) * r +
-                     2.41780_72517_74506_11770e-1) * r +
-                     1.27045_82524_52368_38258e+0) * r +
-                     3.64784_83247_63204_60504e+0) * r +
-                     5.76949_72214_60691_40550e+0) * r +
-                     4.63033_78461_56545_29590e+0) * r +
-                     1.42343_71107_49683_57734e+0)
-        den = (((((((1.05075_00716_44416_84324e-9 * r +
-                     5.47593_80849_95344_94600e-4) * r +
-                     1.51986_66563_61645_71966e-2) * r +
-                     1.48103_97642_74800_74590e-1) * r +
-                     6.89767_33498_51000_04550e-1) * r +
-                     1.67638_48301_83803_84940e+0) * r +
-                     2.05319_16266_37758_82187e+0) * r +
-                     1.0)
-    else:
-        r = r - 5.0
-        # Hash sum: 47.52583_31754_92896_71629
-        num = (((((((2.01033_43992_92288_13265e-7 * r +
-                     2.71155_55687_43487_57815e-5) * r +
-                     1.24266_09473_88078_43860e-3) * r +
-                     2.65321_89526_57612_30930e-2) * r +
-                     2.96560_57182_85048_91230e-1) * r +
-                     1.78482_65399_17291_33580e+0) * r +
-                     5.46378_49111_64114_36990e+0) * r +
-                     6.65790_46435_01103_77720e+0)
-        den = (((((((2.04426_31033_89939_78564e-15 * r +
-                     1.42151_17583_16445_88870e-7) * r +
-                     1.84631_83175_10054_68180e-5) * r +
-                     7.86869_13114_56132_59100e-4) * r +
-                     1.48753_61290_85061_48525e-2) * r +
-                     1.36929_88092_27358_05310e-1) * r +
-                     5.99832_20655_58879_37690e-1) * r +
-                     1.0)
-    x = num / den
-    if q < 0.0:
-        x = -x
-    return mu + (x * sigma)
+def _newton_raphson(f_inv_estimate, f, f_prime, tolerance=1e-12):
+    def f_inv(y):
+        "Return x such that f(x) ≈ y within the specified tolerance."
+        x = f_inv_estimate(y)
+        while abs(diff := f(x) - y) > tolerance:
+            x -= diff / f_prime(x)
+        return x
+    return f_inv
 
+def _quartic_invcdf_estimate(p):
+    # A handrolled piecewise approximation. There is no magic here.
+    sign, p = (1.0, p) if p <= 1/2 else (-1.0, 1.0 - p)
+    if p < 0.0106:
+        return ((2.0 * p) ** 0.3838 - 1.0) * sign
+    x = (2.0 * p) ** 0.4258865685331 - 1.0
+    if p < 0.499:
+        x += 0.026818732 * sin(7.101753784 * p + 2.73230839482953)
+    return x * sign
 
-# If available, use C implementation
-try:
-    from _statistics import _normal_dist_inv_cdf
-except ImportError:
-    pass
+@register('quartic', 'biweight')
+def quartic_kernel():
+    pdf = lambda t: 15/16 * (1.0 - t * t) ** 2
+    cdf = lambda t: sumprod((3/16, -5/8, 15/16, 1/2),
+                            (t**5, t**3, t, 1.0))
+    invcdf = _newton_raphson(_quartic_invcdf_estimate, f=cdf, f_prime=pdf)
+    support = 1.0
+    return pdf, cdf, invcdf, support
 
+def _triweight_invcdf_estimate(p):
+    # A handrolled piecewise approximation. There is no magic here.
+    sign, p = (1.0, p) if p <= 1/2 else (-1.0, 1.0 - p)
+    x = (2.0 * p) ** 0.3400218741872791 - 1.0
+    if 0.00001 < p < 0.499:
+        x -= 0.033 * sin(1.07 * tau * (p - 0.035))
+    return x * sign
 
-class NormalDist:
-    "Normal distribution of a random variable"
-    # https://en.wikipedia.org/wiki/Normal_distribution
-    # https://en.wikipedia.org/wiki/Variance#Properties
+@register('triweight')
+def triweight_kernel():
+    pdf = lambda t: 35/32 * (1.0 - t * t) ** 3
+    cdf = lambda t: sumprod((-5/32, 21/32, -35/32, 35/32, 1/2),
+                            (t**7, t**5, t**3, t, 1.0))
+    invcdf = _newton_raphson(_triweight_invcdf_estimate, f=cdf, f_prime=pdf)
+    support = 1.0
+    return pdf, cdf, invcdf, support
+
+@register('cosine')
+def cosine_kernel():
+    c1 = pi / 4
+    c2 = pi / 2
+    pdf = lambda t: c1 * cos(c2 * t)
+    cdf = lambda t: 1/2 * sin(c2 * t) + 1/2
+    invcdf = lambda p: 2.0 * asin(2.0 * p - 1.0) / pi
+    support = 1.0
+    return pdf, cdf, invcdf, support
+
+del register, normal_kernel, logistic_kernel, sigmoid_kernel
+del rectangular_kernel, triangular_kernel, parabolic_kernel
+del quartic_kernel, triweight_kernel, cosine_kernel
 
-    __slots__ = {
-        '_mu': 'Arithmetic mean of a normal distribution',
-        '_sigma': 'Standard deviation of a normal distribution',
-    }
 
-    def __init__(self, mu=0.0, sigma=1.0):
-        "NormalDist where mu is the mean and sigma is the standard deviation."
-        if sigma < 0.0:
-            raise StatisticsError('sigma must be non-negative')
-        self._mu = float(mu)
-        self._sigma = float(sigma)
+def kde(data, h, kernel='normal', *, cumulative=False):
+    """Kernel Density Estimation:  Create a continuous probability density
+    function or cumulative distribution function from discrete samples.
 
-    @classmethod
-    def from_samples(cls, data):
-        "Make a normal distribution instance from sample data."
-        return cls(*_mean_stdev(data))
+    The basic idea is to smooth the data using a kernel function
+    to help draw inferences about a population from a sample.
 
-    def samples(self, n, *, seed=None):
-        "Generate *n* samples for a given mean and standard deviation."
-        rnd = random.random if seed is None else random.Random(seed).random
-        inv_cdf = _normal_dist_inv_cdf
-        mu = self._mu
-        sigma = self._sigma
-        return [inv_cdf(rnd(), mu, sigma) for _ in repeat(None, n)]
+    The degree of smoothing is controlled by the scaling parameter h
+    which is called the bandwidth.  Smaller values emphasize local
+    features while larger values give smoother results.
 
-    def pdf(self, x):
-        "Probability density function.  P(x <= X < x+dx) / dx"
-        variance = self._sigma * self._sigma
-        if not variance:
-            raise StatisticsError('pdf() not defined when sigma is zero')
-        diff = x - self._mu
-        return exp(diff * diff / (-2.0 * variance)) / sqrt(tau * variance)
+    The kernel determines the relative weights of the sample data
+    points.  Generally, the choice of kernel shape does not matter
+    as much as the more influential bandwidth smoothing parameter.
 
-    def cdf(self, x):
-        "Cumulative distribution function.  P(X <= x)"
-        if not self._sigma:
-            raise StatisticsError('cdf() not defined when sigma is zero')
-        return 0.5 * (1.0 + erf((x - self._mu) / (self._sigma * _SQRT2)))
+    Kernels that give some weight to every sample point:
 
-    def inv_cdf(self, p):
-        """Inverse cumulative distribution function.  x : P(X <= x) = p
+       normal (gauss)
+       logistic
+       sigmoid
 
-        Finds the value of the random variable such that the probability of
-        the variable being less than or equal to that value equals the given
-        probability.
+    Kernels that only give weight to sample points within
+    the bandwidth:
 
-        This function is also called the percent point function or quantile
-        function.
-        """
-        if p <= 0.0 or p >= 1.0:
-            raise StatisticsError('p must be in the range 0.0 < p < 1.0')
-        return _normal_dist_inv_cdf(p, self._mu, self._sigma)
+       rectangular (uniform)
+       triangular
+       parabolic (epanechnikov)
+       quartic (biweight)
+       triweight
+       cosine
 
-    def quantiles(self, n=4):
-        """Divide into *n* continuous intervals with equal probability.
+    If *cumulative* is true, will return a cumulative distribution function.
 
-        Returns a list of (n - 1) cut points separating the intervals.
+    A StatisticsError will be raised if the data sequence is empty.
 
-        Set *n* to 4 for quartiles (the default).  Set *n* to 10 for deciles.
-        Set *n* to 100 for percentiles which gives the 99 cuts points that
-        separate the normal distribution in to 100 equal sized groups.
-        """
-        return [self.inv_cdf(i / n) for i in range(1, n)]
+    Example
+    -------
 
-    def overlap(self, other):
-        """Compute the overlapping coefficient (OVL) between two normal distributions.
+    Given a sample of six data points, construct a continuous
+    function that estimates the underlying probability density:
 
-        Measures the agreement between two normal probability distributions.
-        Returns a value between 0.0 and 1.0 giving the overlapping area in
-        the two underlying probability density functions.
+        >>> sample = [-2.1, -1.3, -0.4, 1.9, 5.1, 6.2]
+        >>> f_hat = kde(sample, h=1.5)
 
-            >>> N1 = NormalDist(2.4, 1.6)
-            >>> N2 = NormalDist(3.2, 2.0)
-            >>> N1.overlap(N2)
-            0.8035050657330205
-        """
-        # See: "The overlapping coefficient as a measure of agreement between
-        # probability distributions and point estimation of the overlap of two
-        # normal densities" -- Henry F. Inman and Edwin L. Bradley Jr
-        # http://dx.doi.org/10.1080/03610928908830127
-        if not isinstance(other, NormalDist):
-            raise TypeError('Expected another NormalDist instance')
-        X, Y = self, other
-        if (Y._sigma, Y._mu) < (X._sigma, X._mu):  # sort to assure commutativity
-            X, Y = Y, X
-        X_var, Y_var = X.variance, Y.variance
-        if not X_var or not Y_var:
-            raise StatisticsError('overlap() not defined when sigma is zero')
-        dv = Y_var - X_var
-        dm = fabs(Y._mu - X._mu)
-        if not dv:
-            return 1.0 - erf(dm / (2.0 * X._sigma * _SQRT2))
-        a = X._mu * Y_var - Y._mu * X_var
-        b = X._sigma * Y._sigma * sqrt(dm * dm + dv * log(Y_var / X_var))
-        x1 = (a + b) / dv
-        x2 = (a - b) / dv
-        return 1.0 - (fabs(Y.cdf(x1) - X.cdf(x1)) + fabs(Y.cdf(x2) - X.cdf(x2)))
+    Compute the area under the curve:
 
-    def zscore(self, x):
-        """Compute the Standard Score.  (x - mean) / stdev
+        >>> area = sum(f_hat(x) for x in range(-20, 20))
+        >>> round(area, 4)
+        1.0
 
-        Describes *x* in terms of the number of standard deviations
-        above or below the mean of the normal distribution.
-        """
-        # https://www.statisticshowto.com/probability-and-statistics/z-score/
-        if not self._sigma:
-            raise StatisticsError('zscore() not defined when sigma is zero')
-        return (x - self._mu) / self._sigma
+    Plot the estimated probability density function at
+    evenly spaced points from -6 to 10:
 
-    @property
-    def mean(self):
-        "Arithmetic mean of the normal distribution."
-        return self._mu
-
-    @property
-    def median(self):
-        "Return the median of the normal distribution"
-        return self._mu
-
-    @property
-    def mode(self):
-        """Return the mode of the normal distribution
-
-        The mode is the value x where which the probability density
-        function (pdf) takes its maximum value.
-        """
-        return self._mu
-
-    @property
-    def stdev(self):
-        "Standard deviation of the normal distribution."
-        return self._sigma
-
-    @property
-    def variance(self):
-        "Square of the standard deviation."
-        return self._sigma * self._sigma
-
-    def __add__(x1, x2):
-        """Add a constant or another NormalDist instance.
-
-        If *other* is a constant, translate mu by the constant,
-        leaving sigma unchanged.
-
-        If *other* is a NormalDist, add both the means and the variances.
-        Mathematically, this works only if the two distributions are
-        independent or if they are jointly normally distributed.
-        """
-        if isinstance(x2, NormalDist):
-            return NormalDist(x1._mu + x2._mu, hypot(x1._sigma, x2._sigma))
-        return NormalDist(x1._mu + x2, x1._sigma)
-
-    def __sub__(x1, x2):
-        """Subtract a constant or another NormalDist instance.
-
-        If *other* is a constant, translate by the constant mu,
-        leaving sigma unchanged.
+        >>> for x in range(-6, 11):
+        ...     density = f_hat(x)
+        ...     plot = ' ' * int(density * 400) + 'x'
+        ...     print(f'{x:2}: {density:.3f} {plot}')
+        ...
+        -6: 0.002 x
+        -5: 0.009    x
+        -4: 0.031             x
+        -3: 0.070                             x
+        -2: 0.111                                             x
+        -1: 0.125                                                   x
+         0: 0.110                                            x
+         1: 0.086                                   x
+         2: 0.068                            x
+         3: 0.059                        x
+         4: 0.066                           x
+         5: 0.082                                 x
+         6: 0.082                                 x
+         7: 0.058                        x
+         8: 0.028            x
+         9: 0.009    x
+        10: 0.002 x
 
-        If *other* is a NormalDist, subtract the means and add the variances.
-        Mathematically, this works only if the two distributions are
-        independent or if they are jointly normally distributed.
-        """
-        if isinstance(x2, NormalDist):
-            return NormalDist(x1._mu - x2._mu, hypot(x1._sigma, x2._sigma))
-        return NormalDist(x1._mu - x2, x1._sigma)
+    Estimate P(4.5 < X <= 7.5), the probability that a new sample value
+    will be between 4.5 and 7.5:
 
-    def __mul__(x1, x2):
-        """Multiply both mu and sigma by a constant.
+        >>> cdf = kde(sample, h=1.5, cumulative=True)
+        >>> round(cdf(7.5) - cdf(4.5), 2)
+        0.22
 
-        Used for rescaling, perhaps to change measurement units.
-        Sigma is scaled with the absolute value of the constant.
-        """
-        return NormalDist(x1._mu * x2, x1._sigma * fabs(x2))
+    References
+    ----------
 
-    def __truediv__(x1, x2):
-        """Divide both mu and sigma by a constant.
+    Kernel density estimation and its application:
+    https://www.itm-conferences.org/articles/itmconf/pdf/2018/08/itmconf_sam2018_00037.pdf
 
-        Used for rescaling, perhaps to change measurement units.
-        Sigma is scaled with the absolute value of the constant.
-        """
-        return NormalDist(x1._mu / x2, x1._sigma / fabs(x2))
+    Kernel functions in common use:
+    https://en.wikipedia.org/wiki/Kernel_(statistics)#kernel_functions_in_common_use
 
-    def __pos__(x1):
-        "Return a copy of the instance."
-        return NormalDist(x1._mu, x1._sigma)
+    Interactive graphical demonstration and exploration:
+    https://demonstrations.wolfram.com/KernelDensityEstimation/
 
-    def __neg__(x1):
-        "Negates mu while keeping sigma the same."
-        return NormalDist(-x1._mu, x1._sigma)
+    Kernel estimation of cumulative distribution function of a random variable with bounded support
+    https://www.econstor.eu/bitstream/10419/207829/1/10.21307_stattrans-2016-037.pdf
 
-    __radd__ = __add__
+    """
 
-    def __rsub__(x1, x2):
-        "Subtract a NormalDist from a constant or another NormalDist."
-        return -(x1 - x2)
+    n = len(data)
+    if not n:
+        raise StatisticsError('Empty data sequence')
 
-    __rmul__ = __mul__
+    if not isinstance(data[0], (int, float)):
+        raise TypeError('Data sequence must contain ints or floats')
 
-    def __eq__(x1, x2):
-        "Two NormalDist objects are equal if their mu and sigma are both equal."
-        if not isinstance(x2, NormalDist):
-            return NotImplemented
-        return x1._mu == x2._mu and x1._sigma == x2._sigma
+    if h <= 0.0:
+        raise StatisticsError(f'Bandwidth h must be positive, not {h=!r}')
 
-    def __hash__(self):
-        "NormalDist objects hash equal if their mu and sigma are both equal."
-        return hash((self._mu, self._sigma))
+    kernel_spec = _kernel_specs.get(kernel)
+    if kernel_spec is None:
+        raise StatisticsError(f'Unknown kernel name: {kernel!r}')
+    K = kernel_spec['pdf']
+    W = kernel_spec['cdf']
+    support = kernel_spec['support']
 
-    def __repr__(self):
-        return f'{type(self).__name__}(mu={self._mu!r}, sigma={self._sigma!r})'
+    if support is None:
 
-    def __getstate__(self):
-        return self._mu, self._sigma
+        def pdf(x):
+            return sum(K((x - x_i) / h) for x_i in data) / (len(data) * h)
 
-    def __setstate__(self, state):
-        self._mu, self._sigma = state
+        def cdf(x):
+            return sum(W((x - x_i) / h) for x_i in data) / len(data)
 
+    else:
 
-## kde_random() ##############################################################
+        sample = sorted(data)
+        bandwidth = h * support
 
-def _newton_raphson(f_inv_estimate, f, f_prime, tolerance=1e-12):
-    def f_inv(y):
-        "Return x such that f(x) ≈ y within the specified tolerance."
-        x = f_inv_estimate(y)
-        while abs(diff := f(x) - y) > tolerance:
-            x -= diff / f_prime(x)
-        return x
-    return f_inv
+        def pdf(x):
+            nonlocal n, sample
+            if len(data) != n:
+                sample = sorted(data)
+                n = len(data)
+            i = bisect_left(sample, x - bandwidth)
+            j = bisect_right(sample, x + bandwidth)
+            supported = sample[i : j]
+            return sum(K((x - x_i) / h) for x_i in supported) / (n * h)
 
-def _quartic_invcdf_estimate(p):
-    sign, p = (1.0, p) if p <= 1/2 else (-1.0, 1.0 - p)
-    x = (2.0 * p) ** 0.4258865685331 - 1.0
-    if p >= 0.004 < 0.499:
-        x += 0.026818732 * sin(7.101753784 * p + 2.73230839482953)
-    return x * sign
+        def cdf(x):
+            nonlocal n, sample
+            if len(data) != n:
+                sample = sorted(data)
+                n = len(data)
+            i = bisect_left(sample, x - bandwidth)
+            j = bisect_right(sample, x + bandwidth)
+            supported = sample[i : j]
+            return sum((W((x - x_i) / h) for x_i in supported), i) / n
 
-_quartic_invcdf = _newton_raphson(
-    f_inv_estimate = _quartic_invcdf_estimate,
-    f = lambda t: 3/16 * t**5 - 5/8 * t**3 + 15/16 * t + 1/2,
-    f_prime = lambda t: 15/16 * (1.0 - t * t) ** 2)
+    if cumulative:
+        cdf.__doc__ = f'CDF estimate with {h=!r} and {kernel=!r}'
+        return cdf
 
-def _triweight_invcdf_estimate(p):
-    sign, p = (1.0, p) if p <= 1/2 else (-1.0, 1.0 - p)
-    x = (2.0 * p) ** 0.3400218741872791 - 1.0
-    return x * sign
+    else:
+        pdf.__doc__ = f'PDF estimate with {h=!r} and {kernel=!r}'
+        return pdf
 
-_triweight_invcdf = _newton_raphson(
-    f_inv_estimate = _triweight_invcdf_estimate,
-    f = lambda t: 35/32 * (-1/7*t**7 + 3/5*t**5 - t**3 + t) + 1/2,
-    f_prime = lambda t: 35/32 * (1.0 - t * t) ** 3)
-
-_kernel_invcdfs = {
-    'normal': NormalDist().inv_cdf,
-    'logistic': lambda p: log(p / (1 - p)),
-    'sigmoid': lambda p: log(tan(p * pi/2)),
-    'rectangular': lambda p: 2*p - 1,
-    'parabolic': lambda p: 2 * cos((acos(2*p-1) + pi) / 3),
-    'quartic': _quartic_invcdf,
-    'triweight': _triweight_invcdf,
-    'triangular': lambda p: sqrt(2*p) - 1 if p < 1/2 else 1 - sqrt(2 - 2*p),
-    'cosine': lambda p: 2 * asin(2*p - 1) / pi,
-}
-_kernel_invcdfs['gauss'] = _kernel_invcdfs['normal']
-_kernel_invcdfs['uniform'] = _kernel_invcdfs['rectangular']
-_kernel_invcdfs['epanechnikov'] = _kernel_invcdfs['parabolic']
-_kernel_invcdfs['biweight'] = _kernel_invcdfs['quartic']
 
 def kde_random(data, h, kernel='normal', *, seed=None):
     """Return a function that makes a random selection from the estimated
@@ -1791,17 +1119,761 @@ def kde_random(data, h, kernel='normal', *, seed=None):
     if h <= 0.0:
         raise StatisticsError(f'Bandwidth h must be positive, not {h=!r}')
 
-    kernel_invcdf = _kernel_invcdfs.get(kernel)
-    if kernel_invcdf is None:
+    kernel_spec = _kernel_specs.get(kernel)
+    if kernel_spec is None:
         raise StatisticsError(f'Unknown kernel name: {kernel!r}')
+    invcdf = kernel_spec['invcdf']
 
     prng = _random.Random(seed)
     random = prng.random
     choice = prng.choice
 
     def rand():
-        return choice(data) + h * kernel_invcdf(random())
+        return choice(data) + h * invcdf(random())
 
     rand.__doc__ = f'Random KDE selection with {h=!r} and {kernel=!r}'
 
     return rand
+
+
+## Quantiles ###############################################################
+
+# There is no one perfect way to compute quantiles.  Here we offer
+# two methods that serve common needs.  Most other packages
+# surveyed offered at least one or both of these two, making them
+# "standard" in the sense of "widely-adopted and reproducible".
+# They are also easy to explain, easy to compute manually, and have
+# straight-forward interpretations that aren't surprising.
+
+# The default method is known as "R6", "PERCENTILE.EXC", or "expected
+# value of rank order statistics". The alternative method is known as
+# "R7", "PERCENTILE.INC", or "mode of rank order statistics".
+
+# For sample data where there is a positive probability for values
+# beyond the range of the data, the R6 exclusive method is a
+# reasonable choice.  Consider a random sample of nine values from a
+# population with a uniform distribution from 0.0 to 1.0.  The
+# distribution of the third ranked sample point is described by
+# betavariate(alpha=3, beta=7) which has mode=0.250, median=0.286, and
+# mean=0.300.  Only the latter (which corresponds with R6) gives the
+# desired cut point with 30% of the population falling below that
+# value, making it comparable to a result from an inv_cdf() function.
+# The R6 exclusive method is also idempotent.
+
+# For describing population data where the end points are known to
+# be included in the data, the R7 inclusive method is a reasonable
+# choice.  Instead of the mean, it uses the mode of the beta
+# distribution for the interior points.  Per Hyndman & Fan, "One nice
+# property is that the vertices of Q7(p) divide the range into n - 1
+# intervals, and exactly 100p% of the intervals lie to the left of
+# Q7(p) and 100(1 - p)% of the intervals lie to the right of Q7(p)."
+
+# If needed, other methods could be added.  However, for now, the
+# position is that fewer options make for easier choices and that
+# external packages can be used for anything more advanced.
+
+def quantiles(data, *, n=4, method='exclusive'):
+    """Divide *data* into *n* continuous intervals with equal probability.
+
+    Returns a list of (n - 1) cut points separating the intervals.
+
+    Set *n* to 4 for quartiles (the default).  Set *n* to 10 for deciles.
+    Set *n* to 100 for percentiles which gives the 99 cuts points that
+    separate *data* in to 100 equal sized groups.
+
+    The *data* can be any iterable containing sample.
+    The cut points are linearly interpolated between data points.
+
+    If *method* is set to *inclusive*, *data* is treated as population
+    data.  The minimum value is treated as the 0th percentile and the
+    maximum value is treated as the 100th percentile.
+
+    """
+    if n < 1:
+        raise StatisticsError('n must be at least 1')
+
+    data = sorted(data)
+
+    ld = len(data)
+    if ld < 2:
+        if ld == 1:
+            return data * (n - 1)
+        raise StatisticsError('must have at least one data point')
+
+    if method == 'inclusive':
+        m = ld - 1
+        result = []
+        for i in range(1, n):
+            j, delta = divmod(i * m, n)
+            interpolated = (data[j] * (n - delta) + data[j + 1] * delta) / n
+            result.append(interpolated)
+        return result
+
+    if method == 'exclusive':
+        m = ld + 1
+        result = []
+        for i in range(1, n):
+            j = i * m // n                               # rescale i to m/n
+            j = 1 if j < 1 else ld-1 if j > ld-1 else j  # clamp to 1 .. ld-1
+            delta = i*m - j*n                            # exact integer math
+            interpolated = (data[j - 1] * (n - delta) + data[j] * delta) / n
+            result.append(interpolated)
+        return result
+
+    raise ValueError(f'Unknown method: {method!r}')
+
+
+## Normal Distribution #####################################################
+
+class NormalDist:
+    "Normal distribution of a random variable"
+    # https://en.wikipedia.org/wiki/Normal_distribution
+    # https://en.wikipedia.org/wiki/Variance#Properties
+
+    __slots__ = {
+        '_mu': 'Arithmetic mean of a normal distribution',
+        '_sigma': 'Standard deviation of a normal distribution',
+    }
+
+    def __init__(self, mu=0.0, sigma=1.0):
+        "NormalDist where mu is the mean and sigma is the standard deviation."
+        if sigma < 0.0:
+            raise StatisticsError('sigma must be non-negative')
+        self._mu = float(mu)
+        self._sigma = float(sigma)
+
+    @classmethod
+    def from_samples(cls, data):
+        "Make a normal distribution instance from sample data."
+        return cls(*_mean_stdev(data))
+
+    def samples(self, n, *, seed=None):
+        "Generate *n* samples for a given mean and standard deviation."
+        rnd = random.random if seed is None else random.Random(seed).random
+        inv_cdf = _normal_dist_inv_cdf
+        mu = self._mu
+        sigma = self._sigma
+        return [inv_cdf(rnd(), mu, sigma) for _ in repeat(None, n)]
+
+    def pdf(self, x):
+        "Probability density function.  P(x <= X < x+dx) / dx"
+        variance = self._sigma * self._sigma
+        if not variance:
+            raise StatisticsError('pdf() not defined when sigma is zero')
+        diff = x - self._mu
+        return exp(diff * diff / (-2.0 * variance)) / sqrt(tau * variance)
+
+    def cdf(self, x):
+        "Cumulative distribution function.  P(X <= x)"
+        if not self._sigma:
+            raise StatisticsError('cdf() not defined when sigma is zero')
+        return 0.5 * erfc((self._mu - x) / (self._sigma * _SQRT2))
+
+    def inv_cdf(self, p):
+        """Inverse cumulative distribution function.  x : P(X <= x) = p
+
+        Finds the value of the random variable such that the probability of
+        the variable being less than or equal to that value equals the given
+        probability.
+
+        This function is also called the percent point function or quantile
+        function.
+        """
+        if p <= 0.0 or p >= 1.0:
+            raise StatisticsError('p must be in the range 0.0 < p < 1.0')
+        return _normal_dist_inv_cdf(p, self._mu, self._sigma)
+
+    def quantiles(self, n=4):
+        """Divide into *n* continuous intervals with equal probability.
+
+        Returns a list of (n - 1) cut points separating the intervals.
+
+        Set *n* to 4 for quartiles (the default).  Set *n* to 10 for deciles.
+        Set *n* to 100 for percentiles which gives the 99 cuts points that
+        separate the normal distribution in to 100 equal sized groups.
+        """
+        return [self.inv_cdf(i / n) for i in range(1, n)]
+
+    def overlap(self, other):
+        """Compute the overlapping coefficient (OVL) between two normal distributions.
+
+        Measures the agreement between two normal probability distributions.
+        Returns a value between 0.0 and 1.0 giving the overlapping area in
+        the two underlying probability density functions.
+
+            >>> N1 = NormalDist(2.4, 1.6)
+            >>> N2 = NormalDist(3.2, 2.0)
+            >>> N1.overlap(N2)
+            0.8035050657330205
+        """
+        # See: "The overlapping coefficient as a measure of agreement between
+        # probability distributions and point estimation of the overlap of two
+        # normal densities" -- Henry F. Inman and Edwin L. Bradley Jr
+        # http://dx.doi.org/10.1080/03610928908830127
+        if not isinstance(other, NormalDist):
+            raise TypeError('Expected another NormalDist instance')
+        X, Y = self, other
+        if (Y._sigma, Y._mu) < (X._sigma, X._mu):  # sort to assure commutativity
+            X, Y = Y, X
+        X_var, Y_var = X.variance, Y.variance
+        if not X_var or not Y_var:
+            raise StatisticsError('overlap() not defined when sigma is zero')
+        dv = Y_var - X_var
+        dm = fabs(Y._mu - X._mu)
+        if not dv:
+            return erfc(dm / (2.0 * X._sigma * _SQRT2))
+        a = X._mu * Y_var - Y._mu * X_var
+        b = X._sigma * Y._sigma * sqrt(dm * dm + dv * log(Y_var / X_var))
+        x1 = (a + b) / dv
+        x2 = (a - b) / dv
+        return 1.0 - (fabs(Y.cdf(x1) - X.cdf(x1)) + fabs(Y.cdf(x2) - X.cdf(x2)))
+
+    def zscore(self, x):
+        """Compute the Standard Score.  (x - mean) / stdev
+
+        Describes *x* in terms of the number of standard deviations
+        above or below the mean of the normal distribution.
+        """
+        # https://www.statisticshowto.com/probability-and-statistics/z-score/
+        if not self._sigma:
+            raise StatisticsError('zscore() not defined when sigma is zero')
+        return (x - self._mu) / self._sigma
+
+    @property
+    def mean(self):
+        "Arithmetic mean of the normal distribution."
+        return self._mu
+
+    @property
+    def median(self):
+        "Return the median of the normal distribution"
+        return self._mu
+
+    @property
+    def mode(self):
+        """Return the mode of the normal distribution
+
+        The mode is the value x where which the probability density
+        function (pdf) takes its maximum value.
+        """
+        return self._mu
+
+    @property
+    def stdev(self):
+        "Standard deviation of the normal distribution."
+        return self._sigma
+
+    @property
+    def variance(self):
+        "Square of the standard deviation."
+        return self._sigma * self._sigma
+
+    def __add__(x1, x2):
+        """Add a constant or another NormalDist instance.
+
+        If *other* is a constant, translate mu by the constant,
+        leaving sigma unchanged.
+
+        If *other* is a NormalDist, add both the means and the variances.
+        Mathematically, this works only if the two distributions are
+        independent or if they are jointly normally distributed.
+        """
+        if isinstance(x2, NormalDist):
+            return NormalDist(x1._mu + x2._mu, hypot(x1._sigma, x2._sigma))
+        return NormalDist(x1._mu + x2, x1._sigma)
+
+    def __sub__(x1, x2):
+        """Subtract a constant or another NormalDist instance.
+
+        If *other* is a constant, translate by the constant mu,
+        leaving sigma unchanged.
+
+        If *other* is a NormalDist, subtract the means and add the variances.
+        Mathematically, this works only if the two distributions are
+        independent or if they are jointly normally distributed.
+        """
+        if isinstance(x2, NormalDist):
+            return NormalDist(x1._mu - x2._mu, hypot(x1._sigma, x2._sigma))
+        return NormalDist(x1._mu - x2, x1._sigma)
+
+    def __mul__(x1, x2):
+        """Multiply both mu and sigma by a constant.
+
+        Used for rescaling, perhaps to change measurement units.
+        Sigma is scaled with the absolute value of the constant.
+        """
+        return NormalDist(x1._mu * x2, x1._sigma * fabs(x2))
+
+    def __truediv__(x1, x2):
+        """Divide both mu and sigma by a constant.
+
+        Used for rescaling, perhaps to change measurement units.
+        Sigma is scaled with the absolute value of the constant.
+        """
+        return NormalDist(x1._mu / x2, x1._sigma / fabs(x2))
+
+    def __pos__(x1):
+        "Return a copy of the instance."
+        return NormalDist(x1._mu, x1._sigma)
+
+    def __neg__(x1):
+        "Negates mu while keeping sigma the same."
+        return NormalDist(-x1._mu, x1._sigma)
+
+    __radd__ = __add__
+
+    def __rsub__(x1, x2):
+        "Subtract a NormalDist from a constant or another NormalDist."
+        return -(x1 - x2)
+
+    __rmul__ = __mul__
+
+    def __eq__(x1, x2):
+        "Two NormalDist objects are equal if their mu and sigma are both equal."
+        if not isinstance(x2, NormalDist):
+            return NotImplemented
+        return x1._mu == x2._mu and x1._sigma == x2._sigma
+
+    def __hash__(self):
+        "NormalDist objects hash equal if their mu and sigma are both equal."
+        return hash((self._mu, self._sigma))
+
+    def __repr__(self):
+        return f'{type(self).__name__}(mu={self._mu!r}, sigma={self._sigma!r})'
+
+    def __getstate__(self):
+        return self._mu, self._sigma
+
+    def __setstate__(self, state):
+        self._mu, self._sigma = state
+
+
+## Private utilities #######################################################
+
+def _sum(data):
+    """_sum(data) -> (type, sum, count)
+
+    Return a high-precision sum of the given numeric data as a fraction,
+    together with the type to be converted to and the count of items.
+
+    Examples
+    --------
+
+    >>> _sum([3, 2.25, 4.5, -0.5, 0.25])
+    (<class 'float'>, Fraction(19, 2), 5)
+
+    Some sources of round-off error will be avoided:
+
+    # Built-in sum returns zero.
+    >>> _sum([1e50, 1, -1e50] * 1000)
+    (<class 'float'>, Fraction(1000, 1), 3000)
+
+    Fractions and Decimals are also supported:
+
+    >>> from fractions import Fraction as F
+    >>> _sum([F(2, 3), F(7, 5), F(1, 4), F(5, 6)])
+    (<class 'fractions.Fraction'>, Fraction(63, 20), 4)
+
+    >>> from decimal import Decimal as D
+    >>> data = [D("0.1375"), D("0.2108"), D("0.3061"), D("0.0419")]
+    >>> _sum(data)
+    (<class 'decimal.Decimal'>, Fraction(6963, 10000), 4)
+
+    Mixed types are currently treated as an error, except that int is
+    allowed.
+
+    """
+    count = 0
+    types = set()
+    types_add = types.add
+    partials = {}
+    partials_get = partials.get
+
+    for typ, values in groupby(data, type):
+        types_add(typ)
+        for n, d in map(_exact_ratio, values):
+            count += 1
+            partials[d] = partials_get(d, 0) + n
+
+    if None in partials:
+        # The sum will be a NAN or INF. We can ignore all the finite
+        # partials, and just look at this special one.
+        total = partials[None]
+        assert not _isfinite(total)
+    else:
+        # Sum all the partial sums using builtin sum.
+        total = sum(Fraction(n, d) for d, n in partials.items())
+
+    T = reduce(_coerce, types, int)  # or raise TypeError
+    return (T, total, count)
+
+
+def _ss(data, c=None):
+    """Return the exact mean and sum of square deviations of sequence data.
+
+    Calculations are done in a single pass, allowing the input to be an iterator.
+
+    If given *c* is used the mean; otherwise, it is calculated from the data.
+    Use the *c* argument with care, as it can lead to garbage results.
+
+    """
+    if c is not None:
+        T, ssd, count = _sum((d := x - c) * d for x in data)
+        return (T, ssd, c, count)
+
+    count = 0
+    types = set()
+    types_add = types.add
+    sx_partials = defaultdict(int)
+    sxx_partials = defaultdict(int)
+
+    for typ, values in groupby(data, type):
+        types_add(typ)
+        for n, d in map(_exact_ratio, values):
+            count += 1
+            sx_partials[d] += n
+            sxx_partials[d] += n * n
+
+    if not count:
+        ssd = c = Fraction(0)
+
+    elif None in sx_partials:
+        # The sum will be a NAN or INF. We can ignore all the finite
+        # partials, and just look at this special one.
+        ssd = c = sx_partials[None]
+        assert not _isfinite(ssd)
+
+    else:
+        sx = sum(Fraction(n, d) for d, n in sx_partials.items())
+        sxx = sum(Fraction(n, d*d) for d, n in sxx_partials.items())
+        # This formula has poor numeric properties for floats,
+        # but with fractions it is exact.
+        ssd = (count * sxx - sx * sx) / count
+        c = sx / count
+
+    T = reduce(_coerce, types, int)  # or raise TypeError
+    return (T, ssd, c, count)
+
+
+def _isfinite(x):
+    try:
+        return x.is_finite()  # Likely a Decimal.
+    except AttributeError:
+        return math.isfinite(x)  # Coerces to float first.
+
+
+def _coerce(T, S):
+    """Coerce types T and S to a common type, or raise TypeError.
+
+    Coercion rules are currently an implementation detail. See the CoerceTest
+    test class in test_statistics for details.
+
+    """
+    # See http://bugs.python.org/issue24068.
+    assert T is not bool, "initial type T is bool"
+    # If the types are the same, no need to coerce anything. Put this
+    # first, so that the usual case (no coercion needed) happens as soon
+    # as possible.
+    if T is S:  return T
+    # Mixed int & other coerce to the other type.
+    if S is int or S is bool:  return T
+    if T is int:  return S
+    # If one is a (strict) subclass of the other, coerce to the subclass.
+    if issubclass(S, T):  return S
+    if issubclass(T, S):  return T
+    # Ints coerce to the other type.
+    if issubclass(T, int):  return S
+    if issubclass(S, int):  return T
+    # Mixed fraction & float coerces to float (or float subclass).
+    if issubclass(T, Fraction) and issubclass(S, float):
+        return S
+    if issubclass(T, float) and issubclass(S, Fraction):
+        return T
+    # Any other combination is disallowed.
+    msg = "don't know how to coerce %s and %s"
+    raise TypeError(msg % (T.__name__, S.__name__))
+
+
+def _exact_ratio(x):
+    """Return Real number x to exact (numerator, denominator) pair.
+
+    >>> _exact_ratio(0.25)
+    (1, 4)
+
+    x is expected to be an int, Fraction, Decimal or float.
+
+    """
+    try:
+        return x.as_integer_ratio()
+    except AttributeError:
+        pass
+    except (OverflowError, ValueError):
+        # float NAN or INF.
+        assert not _isfinite(x)
+        return (x, None)
+
+    try:
+        # x may be an Integral ABC.
+        return (x.numerator, x.denominator)
+    except AttributeError:
+        msg = f"can't convert type '{type(x).__name__}' to numerator/denominator"
+        raise TypeError(msg)
+
+
+def _convert(value, T):
+    """Convert value to given numeric type T."""
+    if type(value) is T:
+        # This covers the cases where T is Fraction, or where value is
+        # a NAN or INF (Decimal or float).
+        return value
+
+    if issubclass(T, int) and value.denominator != 1:
+        T = float
+
+    try:
+        # FIXME: what do we do if this overflows?
+        return T(value)
+    except TypeError:
+        if issubclass(T, Decimal):
+            return T(value.numerator) / T(value.denominator)
+        else:
+            raise
+
+
+def _fail_neg(values, errmsg='negative value'):
+    """Iterate over values, failing if any are less than zero."""
+    for x in values:
+        if x < 0:
+            raise StatisticsError(errmsg)
+        yield x
+
+
+def _rank(data, /, *, key=None, reverse=False, ties='average', start=1) -> list[float]:
+    """Rank order a dataset. The lowest value has rank 1.
+
+    Ties are averaged so that equal values receive the same rank:
+
+        >>> data = [31, 56, 31, 25, 75, 18]
+        >>> _rank(data)
+        [3.5, 5.0, 3.5, 2.0, 6.0, 1.0]
+
+    The operation is idempotent:
+
+        >>> _rank([3.5, 5.0, 3.5, 2.0, 6.0, 1.0])
+        [3.5, 5.0, 3.5, 2.0, 6.0, 1.0]
+
+    It is possible to rank the data in reverse order so that the
+    highest value has rank 1.  Also, a key-function can extract
+    the field to be ranked:
+
+        >>> goals = [('eagles', 45), ('bears', 48), ('lions', 44)]
+        >>> _rank(goals, key=itemgetter(1), reverse=True)
+        [2.0, 1.0, 3.0]
+
+    Ranks are conventionally numbered starting from one; however,
+    setting *start* to zero allows the ranks to be used as array indices:
+
+        >>> prize = ['Gold', 'Silver', 'Bronze', 'Certificate']
+        >>> scores = [8.1, 7.3, 9.4, 8.3]
+        >>> [prize[int(i)] for i in _rank(scores, start=0, reverse=True)]
+        ['Bronze', 'Certificate', 'Gold', 'Silver']
+
+    """
+    # If this function becomes public at some point, more thought
+    # needs to be given to the signature.  A list of ints is
+    # plausible when ties is "min" or "max".  When ties is "average",
+    # either list[float] or list[Fraction] is plausible.
+
+    # Default handling of ties matches scipy.stats.mstats.spearmanr.
+    if ties != 'average':
+        raise ValueError(f'Unknown tie resolution method: {ties!r}')
+    if key is not None:
+        data = map(key, data)
+    val_pos = sorted(zip(data, count()), reverse=reverse)
+    i = start - 1
+    result = [0] * len(val_pos)
+    for _, g in groupby(val_pos, key=itemgetter(0)):
+        group = list(g)
+        size = len(group)
+        rank = i + (size + 1) / 2
+        for value, orig_pos in group:
+            result[orig_pos] = rank
+        i += size
+    return result
+
+
+def _integer_sqrt_of_frac_rto(n: int, m: int) -> int:
+    """Square root of n/m, rounded to the nearest integer using round-to-odd."""
+    # Reference: https://www.lri.fr/~melquion/doc/05-imacs17_1-expose.pdf
+    a = math.isqrt(n // m)
+    return a | (a*a*m != n)
+
+
+# For 53 bit precision floats, the bit width used in
+# _float_sqrt_of_frac() is 109.
+_sqrt_bit_width: int = 2 * sys.float_info.mant_dig + 3
+
+
+def _float_sqrt_of_frac(n: int, m: int) -> float:
+    """Square root of n/m as a float, correctly rounded."""
+    # See principle and proof sketch at: https://bugs.python.org/msg407078
+    q = (n.bit_length() - m.bit_length() - _sqrt_bit_width) // 2
+    if q >= 0:
+        numerator = _integer_sqrt_of_frac_rto(n, m << 2 * q) << q
+        denominator = 1
+    else:
+        numerator = _integer_sqrt_of_frac_rto(n << -2 * q, m)
+        denominator = 1 << -q
+    return numerator / denominator   # Convert to float
+
+
+def _decimal_sqrt_of_frac(n: int, m: int) -> Decimal:
+    """Square root of n/m as a Decimal, correctly rounded."""
+    # Premise:  For decimal, computing (n/m).sqrt() can be off
+    #           by 1 ulp from the correctly rounded result.
+    # Method:   Check the result, moving up or down a step if needed.
+    if n <= 0:
+        if not n:
+            return Decimal('0.0')
+        n, m = -n, -m
+
+    root = (Decimal(n) / Decimal(m)).sqrt()
+    nr, dr = root.as_integer_ratio()
+
+    plus = root.next_plus()
+    np, dp = plus.as_integer_ratio()
+    # test: n / m > ((root + plus) / 2) ** 2
+    if 4 * n * (dr*dp)**2 > m * (dr*np + dp*nr)**2:
+        return plus
+
+    minus = root.next_minus()
+    nm, dm = minus.as_integer_ratio()
+    # test: n / m < ((root + minus) / 2) ** 2
+    if 4 * n * (dr*dm)**2 < m * (dr*nm + dm*nr)**2:
+        return minus
+
+    return root
+
+
+def _mean_stdev(data):
+    """In one pass, compute the mean and sample standard deviation as floats."""
+    T, ss, xbar, n = _ss(data)
+    if n < 2:
+        raise StatisticsError('stdev requires at least two data points')
+    mss = ss / (n - 1)
+    try:
+        return float(xbar), _float_sqrt_of_frac(mss.numerator, mss.denominator)
+    except AttributeError:
+        # Handle Nans and Infs gracefully
+        return float(xbar), float(xbar) / float(ss)
+
+
+def _sqrtprod(x: float, y: float) -> float:
+    "Return sqrt(x * y) computed with improved accuracy and without overflow/underflow."
+
+    h = sqrt(x * y)
+
+    if not isfinite(h):
+        if isinf(h) and not isinf(x) and not isinf(y):
+            # Finite inputs overflowed, so scale down, and recompute.
+            scale = 2.0 ** -512  # sqrt(1 / sys.float_info.max)
+            return _sqrtprod(scale * x, scale * y) / scale
+        return h
+
+    if not h:
+        if x and y:
+            # Non-zero inputs underflowed, so scale up, and recompute.
+            # Scale:  1 / sqrt(sys.float_info.min * sys.float_info.epsilon)
+            scale = 2.0 ** 537
+            return _sqrtprod(scale * x, scale * y) / scale
+        return h
+
+    # Improve accuracy with a differential correction.
+    # https://www.wolframalpha.com/input/?i=Maclaurin+series+sqrt%28h**2+%2B+x%29+at+x%3D0
+    d = sumprod((x, h), (y, -h))
+    return h + d / (2.0 * h)
+
+
+def _normal_dist_inv_cdf(p, mu, sigma):
+    # There is no closed-form solution to the inverse CDF for the normal
+    # distribution, so we use a rational approximation instead:
+    # Wichura, M.J. (1988). "Algorithm AS241: The Percentage Points of the
+    # Normal Distribution".  Applied Statistics. Blackwell Publishing. 37
+    # (3): 477–484. doi:10.2307/2347330. JSTOR 2347330.
+    q = p - 0.5
+
+    if fabs(q) <= 0.425:
+        r = 0.180625 - q * q
+        # Hash sum: 55.88319_28806_14901_4439
+        num = (((((((2.50908_09287_30122_6727e+3 * r +
+                     3.34305_75583_58812_8105e+4) * r +
+                     6.72657_70927_00870_0853e+4) * r +
+                     4.59219_53931_54987_1457e+4) * r +
+                     1.37316_93765_50946_1125e+4) * r +
+                     1.97159_09503_06551_4427e+3) * r +
+                     1.33141_66789_17843_7745e+2) * r +
+                     3.38713_28727_96366_6080e+0) * q
+        den = (((((((5.22649_52788_52854_5610e+3 * r +
+                     2.87290_85735_72194_2674e+4) * r +
+                     3.93078_95800_09271_0610e+4) * r +
+                     2.12137_94301_58659_5867e+4) * r +
+                     5.39419_60214_24751_1077e+3) * r +
+                     6.87187_00749_20579_0830e+2) * r +
+                     4.23133_30701_60091_1252e+1) * r +
+                     1.0)
+        x = num / den
+        return mu + (x * sigma)
+
+    r = p if q <= 0.0 else 1.0 - p
+    r = sqrt(-log(r))
+    if r <= 5.0:
+        r = r - 1.6
+        # Hash sum: 49.33206_50330_16102_89036
+        num = (((((((7.74545_01427_83414_07640e-4 * r +
+                     2.27238_44989_26918_45833e-2) * r +
+                     2.41780_72517_74506_11770e-1) * r +
+                     1.27045_82524_52368_38258e+0) * r +
+                     3.64784_83247_63204_60504e+0) * r +
+                     5.76949_72214_60691_40550e+0) * r +
+                     4.63033_78461_56545_29590e+0) * r +
+                     1.42343_71107_49683_57734e+0)
+        den = (((((((1.05075_00716_44416_84324e-9 * r +
+                     5.47593_80849_95344_94600e-4) * r +
+                     1.51986_66563_61645_71966e-2) * r +
+                     1.48103_97642_74800_74590e-1) * r +
+                     6.89767_33498_51000_04550e-1) * r +
+                     1.67638_48301_83803_84940e+0) * r +
+                     2.05319_16266_37758_82187e+0) * r +
+                     1.0)
+    else:
+        r = r - 5.0
+        # Hash sum: 47.52583_31754_92896_71629
+        num = (((((((2.01033_43992_92288_13265e-7 * r +
+                     2.71155_55687_43487_57815e-5) * r +
+                     1.24266_09473_88078_43860e-3) * r +
+                     2.65321_89526_57612_30930e-2) * r +
+                     2.96560_57182_85048_91230e-1) * r +
+                     1.78482_65399_17291_33580e+0) * r +
+                     5.46378_49111_64114_36990e+0) * r +
+                     6.65790_46435_01103_77720e+0)
+        den = (((((((2.04426_31033_89939_78564e-15 * r +
+                     1.42151_17583_16445_88870e-7) * r +
+                     1.84631_83175_10054_68180e-5) * r +
+                     7.86869_13114_56132_59100e-4) * r +
+                     1.48753_61290_85061_48525e-2) * r +
+                     1.36929_88092_27358_05310e-1) * r +
+                     5.99832_20655_58879_37690e-1) * r +
+                     1.0)
+
+    x = num / den
+    if q < 0.0:
+        x = -x
+
+    return mu + (x * sigma)
+
+
+# If available, use C implementation
+try:
+    from _statistics import _normal_dist_inv_cdf
+except ImportError:
+    pass
diff --git a/Lib/subprocess.py b/Lib/subprocess.py
index 885f0092b53..578d7b95d05 100644
--- a/Lib/subprocess.py
+++ b/Lib/subprocess.py
@@ -79,7 +79,7 @@
 
 if _mswindows:
     import _winapi
-    from _winapi import (CREATE_NEW_CONSOLE, CREATE_NEW_PROCESS_GROUP,
+    from _winapi import (CREATE_NEW_CONSOLE, CREATE_NEW_PROCESS_GROUP,  # noqa: F401
                          STD_INPUT_HANDLE, STD_OUTPUT_HANDLE,
                          STD_ERROR_HANDLE, SW_HIDE,
                          STARTF_USESTDHANDLES, STARTF_USESHOWWINDOW,
@@ -752,7 +752,6 @@ def _use_posix_spawn():
 # These are primarily fail-safe knobs for negatives. A True value does not
 # 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')
 
 
@@ -1125,10 +1124,9 @@ def __exit__(self, exc_type, value, traceback):
                     except TimeoutExpired:
                         pass
                 self._sigint_wait_secs = 0  # Note that this has been done.
-                return  # resume the KeyboardInterrupt
-
-            # Wait for the process to terminate, to avoid zombies.
-            self.wait()
+            else:
+                # Wait for the process to terminate, to avoid zombies.
+                self.wait()
 
     def __del__(self, _maxsize=sys.maxsize, _warn=warnings.warn):
         if not self._child_created:
@@ -1927,7 +1925,7 @@ def _execute_child(self, args, executable, preexec_fn, close_fds,
                             errpipe_read, errpipe_write,
                             restore_signals, start_new_session,
                             process_group, gid, gids, uid, umask,
-                            preexec_fn, _USE_VFORK)
+                            preexec_fn)
                     self._child_created = True
                 finally:
                     # be sure the FD is closed no matter what
@@ -2143,7 +2141,7 @@ def _communicate(self, input, endtime, orig_timeout):
 
                 while selector.get_map():
                     timeout = self._remaining_time(endtime)
-                    if timeout is not None and timeout < 0:
+                    if timeout is not None and timeout <= 0:
                         self._check_timeout(endtime, orig_timeout,
                                             stdout, stderr,
                                             skip_check_and_raise=True)
diff --git a/Lib/symtable.py b/Lib/symtable.py
index 672ec0ce1ff..7a30e1ac4ca 100644
--- a/Lib/symtable.py
+++ b/Lib/symtable.py
@@ -1,9 +1,16 @@
 """Interface to the compiler's internal symbol tables"""
 
 import _symtable
-from _symtable import (USE, DEF_GLOBAL, DEF_NONLOCAL, DEF_LOCAL, DEF_PARAM,
-     DEF_IMPORT, DEF_BOUND, DEF_ANNOT, SCOPE_OFF, SCOPE_MASK, FREE,
-     LOCAL, GLOBAL_IMPLICIT, GLOBAL_EXPLICIT, CELL)
+from _symtable import (
+    USE,
+    DEF_GLOBAL,  # noqa: F401
+    DEF_NONLOCAL, DEF_LOCAL,
+    DEF_PARAM, DEF_TYPE_PARAM, DEF_FREE_CLASS,
+    DEF_IMPORT, DEF_BOUND, DEF_ANNOT,
+    DEF_COMP_ITER, DEF_COMP_CELL,
+    SCOPE_OFF, SCOPE_MASK,
+    FREE, LOCAL, GLOBAL_IMPLICIT, GLOBAL_EXPLICIT, CELL
+)
 
 import weakref
 from enum import StrEnum
@@ -165,6 +172,10 @@ def get_children(self):
                 for st in self._table.children]
 
 
+def _get_scope(flags):  # like _PyST_GetScope()
+    return (flags >> SCOPE_OFF) & SCOPE_MASK
+
+
 class Function(SymbolTable):
 
     # Default values for instance variables
@@ -190,7 +201,7 @@ def get_locals(self):
         """
         if self.__locals is None:
             locs = (LOCAL, CELL)
-            test = lambda x: ((x >> SCOPE_OFF) & SCOPE_MASK) in locs
+            test = lambda x: _get_scope(x) in locs
             self.__locals = self.__idents_matching(test)
         return self.__locals
 
@@ -199,7 +210,7 @@ def get_globals(self):
         """
         if self.__globals is None:
             glob = (GLOBAL_IMPLICIT, GLOBAL_EXPLICIT)
-            test = lambda x:((x >> SCOPE_OFF) & SCOPE_MASK) in glob
+            test = lambda x: _get_scope(x) in glob
             self.__globals = self.__idents_matching(test)
         return self.__globals
 
@@ -214,7 +225,7 @@ def get_frees(self):
         """Return a tuple of free variables in the function.
         """
         if self.__frees is None:
-            is_free = lambda x:((x >> SCOPE_OFF) & SCOPE_MASK) == FREE
+            is_free = lambda x: _get_scope(x) == FREE
             self.__frees = self.__idents_matching(is_free)
         return self.__frees
 
@@ -226,6 +237,12 @@ class Class(SymbolTable):
     def get_methods(self):
         """Return a tuple of methods declared in the class.
         """
+        import warnings
+        typename = f'{self.__class__.__module__}.{self.__class__.__name__}'
+        warnings.warn(f'{typename}.get_methods() is deprecated '
+                      f'and will be removed in Python 3.16.',
+                      DeprecationWarning, stacklevel=2)
+
         if self.__methods is None:
             d = {}
 
@@ -268,7 +285,7 @@ class Symbol:
     def __init__(self, name, flags, namespaces=None, *, module_scope=False):
         self.__name = name
         self.__flags = flags
-        self.__scope = (flags >> SCOPE_OFF) & SCOPE_MASK # like PyST_GetScope()
+        self.__scope = _get_scope(flags)
         self.__namespaces = namespaces or ()
         self.__module_scope = module_scope
 
@@ -293,13 +310,18 @@ def is_referenced(self):
         """Return *True* if the symbol is used in
         its block.
         """
-        return bool(self.__flags & _symtable.USE)
+        return bool(self.__flags & USE)
 
     def is_parameter(self):
         """Return *True* if the symbol is a parameter.
         """
         return bool(self.__flags & DEF_PARAM)
 
+    def is_type_parameter(self):
+        """Return *True* if the symbol is a type parameter.
+        """
+        return bool(self.__flags & DEF_TYPE_PARAM)
+
     def is_global(self):
         """Return *True* if the symbol is global.
         """
@@ -332,6 +354,11 @@ def is_free(self):
         """
         return bool(self.__scope == FREE)
 
+    def is_free_class(self):
+        """Return *True* if a class-scoped symbol is free from
+        the perspective of a method."""
+        return bool(self.__flags & DEF_FREE_CLASS)
+
     def is_imported(self):
         """Return *True* if the symbol is created from
         an import statement.
@@ -342,6 +369,16 @@ def is_assigned(self):
         """Return *True* if a symbol is assigned to."""
         return bool(self.__flags & DEF_LOCAL)
 
+    def is_comp_iter(self):
+        """Return *True* if the symbol is a comprehension iteration variable.
+        """
+        return bool(self.__flags & DEF_COMP_ITER)
+
+    def is_comp_cell(self):
+        """Return *True* if the symbol is a cell in an inlined comprehension.
+        """
+        return bool(self.__flags & DEF_COMP_CELL)
+
     def is_namespace(self):
         """Returns *True* if name binding introduces new namespace.
 
diff --git a/Lib/sysconfig/__init__.py b/Lib/sysconfig/__init__.py
index 8365236f61c..ae83243fa3e 100644
--- a/Lib/sysconfig/__init__.py
+++ b/Lib/sysconfig/__init__.py
@@ -116,8 +116,10 @@ def _getuserbase():
     if env_base:
         return env_base
 
-    # Emscripten, iOS, tvOS, VxWorks, WASI, and watchOS have no home directories
-    if sys.platform in {"emscripten", "ios", "tvos", "vxworks", "wasi", "watchos"}:
+    # Emscripten, iOS, tvOS, VxWorks, WASI, and watchOS have no home directories.
+    # Use _PYTHON_HOST_PLATFORM to get the correct platform when cross-compiling.
+    system_name = os.environ.get('_PYTHON_HOST_PLATFORM', sys.platform).split('-')[0]
+    if system_name in {"emscripten", "ios", "tvos", "vxworks", "wasi", "watchos"}:
         return None
 
     def joinuser(*args):
@@ -323,17 +325,37 @@ def get_default_scheme():
 
 def get_makefile_filename():
     """Return the path of the Makefile."""
+
+    # GH-127429: When cross-compiling, use the Makefile from the target, instead of the host Python.
+    if cross_base := os.environ.get('_PYTHON_PROJECT_BASE'):
+        return os.path.join(cross_base, 'Makefile')
+
     if _PYTHON_BUILD:
         return os.path.join(_PROJECT_BASE, "Makefile")
+
     if hasattr(sys, 'abiflags'):
         config_dir_name = f'config-{_PY_VERSION_SHORT}{sys.abiflags}'
     else:
         config_dir_name = 'config'
+
     if hasattr(sys.implementation, '_multiarch'):
         config_dir_name += f'-{sys.implementation._multiarch}'
+
     return os.path.join(get_path('stdlib'), config_dir_name, 'Makefile')
 
 
+def _import_from_directory(path, name):
+    if name not in sys.modules:
+        import importlib.machinery
+        import importlib.util
+
+        spec = importlib.machinery.PathFinder.find_spec(name, [path])
+        module = importlib.util.module_from_spec(spec)
+        spec.loader.exec_module(module)
+        sys.modules[name] = module
+    return sys.modules[name]
+
+
 def _get_sysconfigdata_name():
     multiarch = getattr(sys.implementation, '_multiarch', '')
     return os.environ.get(
@@ -341,26 +363,34 @@ def _get_sysconfigdata_name():
         f'_sysconfigdata_{sys.abiflags}_{sys.platform}_{multiarch}',
     )
 
+
+def _get_sysconfigdata():
+    import importlib
+
+    name = _get_sysconfigdata_name()
+    path = os.environ.get('_PYTHON_SYSCONFIGDATA_PATH')
+    module = _import_from_directory(path, name) if path else importlib.import_module(name)
+
+    return module.build_time_vars
+
+
+def _installation_is_relocated():
+    """Is the Python installation running from a different prefix than what was targetted when building?"""
+    if os.name != 'posix':
+        raise NotImplementedError('sysconfig._installation_is_relocated() is currently only supported on POSIX')
+
+    data = _get_sysconfigdata()
+    return (
+        data['prefix'] != getattr(sys, 'base_prefix', '')
+        or data['exec_prefix'] != getattr(sys, 'base_exec_prefix', '')
+    )
+
+
 def _init_posix(vars):
     """Initialize the module as appropriate for POSIX systems."""
-    # _sysconfigdata is generated at build time, see _generate_posix_vars()
-    name = _get_sysconfigdata_name()
+    # GH-126920: Make sure we don't overwrite any of the keys already set
+    vars.update(_get_sysconfigdata() | vars)
 
-    # For cross builds, the path to the target's sysconfigdata must be specified
-    # so it can be imported. It cannot be in PYTHONPATH, as foreign modules in
-    # sys.path can cause crashes when loaded by the host interpreter.
-    # Rely on truthiness as a valueless env variable is still an empty string.
-    # See OS X note in _generate_posix_vars re _sysconfigdata.
-    if (path := os.environ.get('_PYTHON_SYSCONFIGDATA_PATH')):
-        from importlib.machinery import FileFinder, SourceFileLoader, SOURCE_SUFFIXES
-        from importlib.util import module_from_spec
-        spec = FileFinder(path, (SourceFileLoader, SOURCE_SUFFIXES)).find_spec(name)
-        _temp = module_from_spec(spec)
-        spec.loader.exec_module(_temp)
-    else:
-        _temp = __import__(name, globals(), locals(), ['build_time_vars'], 0)
-    build_time_vars = _temp.build_time_vars
-    vars.update(build_time_vars)
 
 def _init_non_posix(vars):
     """Initialize the module as appropriate for NT"""
@@ -371,9 +401,20 @@ def _init_non_posix(vars):
     vars['BINLIBDEST'] = get_path('platstdlib')
     vars['INCLUDEPY'] = get_path('include')
 
-    # Add EXT_SUFFIX, SOABI, and Py_GIL_DISABLED
+    # Add EXT_SUFFIX, SOABI, Py_DEBUG, and Py_GIL_DISABLED
     vars.update(_sysconfig.config_vars())
 
+    # NOTE: ABIFLAGS is only an emulated value. It is not present during build
+    #       on Windows. sys.abiflags is absent on Windows and vars['abiflags']
+    #       is already widely used to calculate paths, so it should remain an
+    #       empty string.
+    vars['ABIFLAGS'] = ''.join(
+        (
+            't' if vars['Py_GIL_DISABLED'] else '',
+            '_d' if vars['Py_DEBUG'] else '',
+        ),
+    )
+
     vars['LIBDIR'] = _safe_realpath(os.path.join(get_config_var('installed_base'), 'libs'))
     if hasattr(sys, 'dllhandle'):
         dllhandle = _winapi.GetModuleFileName(sys.dllhandle)
@@ -427,7 +468,7 @@ def get_config_h_filename():
     """Return the path of pyconfig.h."""
     if _PYTHON_BUILD:
         if os.name == "nt":
-            inc_dir = os.path.dirname(sys._base_executable)
+            inc_dir = os.path.join(_PROJECT_BASE, 'PC')
         else:
             inc_dir = _PROJECT_BASE
     else:
@@ -468,29 +509,44 @@ def get_path(name, scheme=get_default_scheme(), vars=None, expand=True):
 def _init_config_vars():
     global _CONFIG_VARS
     _CONFIG_VARS = {}
+
+    prefix = os.path.normpath(sys.prefix)
+    exec_prefix = os.path.normpath(sys.exec_prefix)
+    base_prefix = _BASE_PREFIX
+    base_exec_prefix = _BASE_EXEC_PREFIX
+
+    try:
+        abiflags = sys.abiflags
+    except AttributeError:
+        abiflags = ''
+
+    if os.name == 'posix':
+        _init_posix(_CONFIG_VARS)
+        # If we are cross-compiling, load the prefixes from the Makefile instead.
+        if '_PYTHON_PROJECT_BASE' in os.environ:
+            prefix = _CONFIG_VARS['host_prefix']
+            exec_prefix = _CONFIG_VARS['host_exec_prefix']
+            base_prefix = _CONFIG_VARS['host_prefix']
+            base_exec_prefix = _CONFIG_VARS['host_exec_prefix']
+            abiflags = _CONFIG_VARS['ABIFLAGS']
+
     # Normalized versions of prefix and exec_prefix are handy to have;
     # in fact, these are the standard versions used most places in the
     # Distutils.
-    _PREFIX = os.path.normpath(sys.prefix)
-    _EXEC_PREFIX = os.path.normpath(sys.exec_prefix)
-    _CONFIG_VARS['prefix'] = _PREFIX  # FIXME: This gets overwriten by _init_posix.
-    _CONFIG_VARS['exec_prefix'] = _EXEC_PREFIX  # FIXME: This gets overwriten by _init_posix.
+    _CONFIG_VARS['prefix'] = prefix
+    _CONFIG_VARS['exec_prefix'] = exec_prefix
     _CONFIG_VARS['py_version'] = _PY_VERSION
     _CONFIG_VARS['py_version_short'] = _PY_VERSION_SHORT
     _CONFIG_VARS['py_version_nodot'] = _PY_VERSION_SHORT_NO_DOT
-    _CONFIG_VARS['installed_base'] = _BASE_PREFIX
-    _CONFIG_VARS['base'] = _PREFIX
-    _CONFIG_VARS['installed_platbase'] = _BASE_EXEC_PREFIX
-    _CONFIG_VARS['platbase'] = _EXEC_PREFIX
+    _CONFIG_VARS['installed_base'] = base_prefix
+    _CONFIG_VARS['base'] = prefix
+    _CONFIG_VARS['installed_platbase'] = base_exec_prefix
+    _CONFIG_VARS['platbase'] = exec_prefix
     _CONFIG_VARS['projectbase'] = _PROJECT_BASE
     _CONFIG_VARS['platlibdir'] = sys.platlibdir
     _CONFIG_VARS['implementation'] = _get_implementation()
     _CONFIG_VARS['implementation_lower'] = _get_implementation().lower()
-    try:
-        _CONFIG_VARS['abiflags'] = sys.abiflags
-    except AttributeError:
-        # sys.abiflags may not be defined on all platforms.
-        _CONFIG_VARS['abiflags'] = ''
+    _CONFIG_VARS['abiflags'] = abiflags
     try:
         _CONFIG_VARS['py_version_nodot_plat'] = sys.winver.replace('.', '')
     except AttributeError:
@@ -499,8 +555,6 @@ def _init_config_vars():
     if os.name == 'nt':
         _init_non_posix(_CONFIG_VARS)
         _CONFIG_VARS['VPATH'] = sys._vpath
-    if os.name == 'posix':
-        _init_posix(_CONFIG_VARS)
     if _HAS_USER_BASE:
         # Setting 'userbase' is done below the call to the
         # init function to enable using 'get_config_var' in
@@ -550,7 +604,16 @@ def get_config_vars(*args):
     global _CONFIG_VARS_INITIALIZED
 
     # Avoid claiming the lock once initialization is complete.
-    if not _CONFIG_VARS_INITIALIZED:
+    if _CONFIG_VARS_INITIALIZED:
+        # GH-126789: If sys.prefix or sys.exec_prefix were updated, invalidate the cache.
+        prefix = os.path.normpath(sys.prefix)
+        exec_prefix = os.path.normpath(sys.exec_prefix)
+        if _CONFIG_VARS['prefix'] != prefix or _CONFIG_VARS['exec_prefix'] != exec_prefix:
+            with _CONFIG_VARS_LOCK:
+                _CONFIG_VARS_INITIALIZED = False
+                _init_config_vars()
+    else:
+        # Initialize the config_vars cache.
         with _CONFIG_VARS_LOCK:
             # Test again with the lock held to avoid races. Note that
             # we test _CONFIG_VARS here, not _CONFIG_VARS_INITIALIZED,
@@ -558,15 +621,6 @@ def get_config_vars(*args):
             # don't re-enter init_config_vars().
             if _CONFIG_VARS is None:
                 _init_config_vars()
-    else:
-        # If the site module initialization happened after _CONFIG_VARS was
-        # initialized, a virtual environment might have been activated, resulting in
-        # variables like sys.prefix changing their value, so we need to re-init the
-        # config vars (see GH-126789).
-        if _CONFIG_VARS['base'] != os.path.normpath(sys.prefix):
-            with _CONFIG_VARS_LOCK:
-                _CONFIG_VARS_INITIALIZED = False
-                _init_config_vars()
 
     if args:
         vals = []
@@ -627,34 +681,34 @@ def get_platform():
 
     # Set for cross builds explicitly
     if "_PYTHON_HOST_PLATFORM" in os.environ:
-        return os.environ["_PYTHON_HOST_PLATFORM"]
-
-    # Try to distinguish various flavours of Unix
-    osname, host, release, version, machine = os.uname()
-
-    # Convert the OS name to lowercase, remove '/' characters, and translate
-    # spaces (for "Power Macintosh")
-    osname = osname.lower().replace('/', '')
-    machine = machine.replace(' ', '_')
-    machine = machine.replace('/', '-')
-
-    if osname[:5] == "linux":
-        if sys.platform == "android":
-            osname = "android"
-            release = get_config_var("ANDROID_API_LEVEL")
-
-            # Wheel tags use the ABI names from Android's own tools.
-            machine = {
-                "x86_64": "x86_64",
-                "i686": "x86",
-                "aarch64": "arm64_v8a",
-                "armv7l": "armeabi_v7a",
-            }[machine]
-        else:
-            # At least on Linux/Intel, 'machine' is the processor --
-            # i386, etc.
-            # XXX what about Alpha, SPARC, etc?
-            return  f"{osname}-{machine}"
+        osname, _, machine = os.environ["_PYTHON_HOST_PLATFORM"].partition('-')
+        release = None
+    else:
+        # Try to distinguish various flavours of Unix
+        osname, host, release, version, machine = os.uname()
+
+        # Convert the OS name to lowercase, remove '/' characters, and translate
+        # spaces (for "Power Macintosh")
+        osname = osname.lower().replace('/', '')
+        machine = machine.replace(' ', '_')
+        machine = machine.replace('/', '-')
+
+    if osname == "android" or sys.platform == "android":
+        osname = "android"
+        release = get_config_var("ANDROID_API_LEVEL")
+
+        # Wheel tags use the ABI names from Android's own tools.
+        machine = {
+            "x86_64": "x86_64",
+            "i686": "x86",
+            "aarch64": "arm64_v8a",
+            "armv7l": "armeabi_v7a",
+        }[machine]
+    elif osname == "linux":
+        # At least on Linux/Intel, 'machine' is the processor --
+        # i386, etc.
+        # XXX what about Alpha, SPARC, etc?
+        return  f"{osname}-{machine}"
     elif osname[:5] == "sunos":
         if release[0] >= "5":           # SunOS 5 == Solaris 2
             osname = "solaris"
@@ -686,7 +740,7 @@ def get_platform():
                                                 get_config_vars(),
                                                 osname, release, machine)
 
-    return f"{osname}-{release}-{machine}"
+    return '-'.join(map(str, filter(None, (osname, release, machine))))
 
 
 def get_python_version():
@@ -705,6 +759,15 @@ def expand_makefile_vars(s, vars):
     variable expansions; if 'vars' is the output of 'parse_makefile()',
     you're fine.  Returns a variable-expanded version of 's'.
     """
+
+    import warnings
+    warnings.warn(
+        'sysconfig.expand_makefile_vars is deprecated and will be removed in '
+        'Python 3.16. Use sysconfig.get_paths(vars=...) instead.',
+        DeprecationWarning,
+        stacklevel=2,
+    )
+
     import re
 
     _findvar1_rx = r"\$\(([A-Za-z][A-Za-z0-9_]*)\)"
diff --git a/Lib/sysconfig/__main__.py b/Lib/sysconfig/__main__.py
index d7257b9d2d0..bc2197cfe79 100644
--- a/Lib/sysconfig/__main__.py
+++ b/Lib/sysconfig/__main__.py
@@ -1,10 +1,13 @@
+import json
 import os
 import sys
+import types
 from sysconfig import (
     _ALWAYS_STR,
     _PYTHON_BUILD,
     _get_sysconfigdata_name,
     get_config_h_filename,
+    get_config_var,
     get_config_vars,
     get_default_scheme,
     get_makefile_filename,
@@ -157,6 +160,19 @@ def _print_config_dict(d, stream):
     print ("}", file=stream)
 
 
+def _get_pybuilddir():
+    pybuilddir = f'build/lib.{get_platform()}-{get_python_version()}'
+    if get_config_var('Py_DEBUG') == '1':
+        pybuilddir += '-pydebug'
+    return pybuilddir
+
+
+def _get_json_data_name():
+    name = _get_sysconfigdata_name()
+    assert name.startswith('_sysconfigdata')
+    return name.replace('_sysconfigdata', '_sysconfig_vars') + '.json'
+
+
 def _generate_posix_vars():
     """Generate the Python module containing build-time variables."""
     vars = {}
@@ -185,6 +201,8 @@ def _generate_posix_vars():
     if _PYTHON_BUILD:
         vars['BLDSHARED'] = vars['LDSHARED']
 
+    name = _get_sysconfigdata_name()
+
     # There's a chicken-and-egg situation on OS X with regards to the
     # _sysconfigdata module after the changes introduced by #15298:
     # get_config_vars() is called by get_platform() as part of the
@@ -196,16 +214,13 @@ def _generate_posix_vars():
     # _sysconfigdata module manually and populate it with the build vars.
     # This is more than sufficient for ensuring the subsequent call to
     # get_platform() succeeds.
-    name = _get_sysconfigdata_name()
-    if 'darwin' in sys.platform:
-        import types
-        module = types.ModuleType(name)
-        module.build_time_vars = vars
-        sys.modules[name] = module
+    # GH-127178: Since we started generating a .json file, we also need this to
+    #            be able to run sysconfig.get_config_vars().
+    module = types.ModuleType(name)
+    module.build_time_vars = vars
+    sys.modules[name] = module
 
-    pybuilddir = f'build/lib.{get_platform()}-{get_python_version()}'
-    if hasattr(sys, "gettotalrefcount"):
-        pybuilddir += '-pydebug'
+    pybuilddir = _get_pybuilddir()
     os.makedirs(pybuilddir, exist_ok=True)
     destfile = os.path.join(pybuilddir, name + '.py')
 
@@ -215,6 +230,19 @@ def _generate_posix_vars():
         f.write('build_time_vars = ')
         _print_config_dict(vars, stream=f)
 
+    print(f'Written {destfile}')
+
+    install_vars = get_config_vars()
+    # Fix config vars to match the values after install (of the default environment)
+    install_vars['projectbase'] = install_vars['BINDIR']
+    install_vars['srcdir'] = install_vars['LIBPL']
+    # Write a JSON file with the output of sysconfig.get_config_vars
+    jsonfile = os.path.join(pybuilddir, _get_json_data_name())
+    with open(jsonfile, 'w') as f:
+        json.dump(install_vars, f, indent=2)
+
+    print(f'Written {jsonfile}')
+
     # Create file used for sys.path fixup -- see Modules/getpath.c
     with open('pybuilddir.txt', 'w', encoding='utf8') as f:
         f.write(pybuilddir)
diff --git a/Lib/tabnanny.py b/Lib/tabnanny.py
old mode 100755
new mode 100644
index d06c4c221e9..c0097351b26
--- a/Lib/tabnanny.py
+++ b/Lib/tabnanny.py
@@ -1,5 +1,3 @@
-#! /usr/bin/env python3
-
 """The Tab Nanny despises ambiguous indentation.  She knows no mercy.
 
 tabnanny -- Detection of ambiguous indentation
diff --git a/Lib/tarfile.py b/Lib/tarfile.py
old mode 100755
new mode 100644
index 04fda115971..c7e9f7d681a
--- a/Lib/tarfile.py
+++ b/Lib/tarfile.py
@@ -1,4 +1,3 @@
-#!/usr/bin/env python3
 #-------------------------------------------------------------------
 # tarfile.py
 #-------------------------------------------------------------------
@@ -46,7 +45,6 @@
 import struct
 import copy
 import re
-import warnings
 
 try:
     import pwd
@@ -69,7 +67,7 @@
            "DEFAULT_FORMAT", "open","fully_trusted_filter", "data_filter",
            "tar_filter", "FilterError", "AbsoluteLinkError",
            "OutsideDestinationError", "SpecialFileError", "AbsolutePathError",
-           "LinkOutsideDestinationError"]
+           "LinkOutsideDestinationError", "LinkFallbackError"]
 
 
 #---------------------------------------------------------
@@ -341,7 +339,7 @@ class _Stream:
     """
 
     def __init__(self, name, mode, comptype, fileobj, bufsize,
-                 compresslevel):
+                 compresslevel, preset):
         """Construct a _Stream object.
         """
         self._extfileobj = True
@@ -355,7 +353,7 @@ def __init__(self, name, mode, comptype, fileobj, bufsize,
             fileobj = _StreamProxy(fileobj)
             comptype = fileobj.getcomptype()
 
-        self.name     = name or ""
+        self.name     = os.fspath(name) if name is not None else ""
         self.mode     = mode
         self.comptype = comptype
         self.fileobj  = fileobj
@@ -395,17 +393,23 @@ def __init__(self, name, mode, comptype, fileobj, bufsize,
                     import lzma
                 except ImportError:
                     raise CompressionError("lzma module is not available") from None
-
-                # XXX: RUSTPYTHON; xz is not supported yet
-                raise CompressionError("lzma module is not available") from None
-
                 if mode == "r":
                     self.dbuf = b""
                     self.cmp = lzma.LZMADecompressor()
                     self.exception = lzma.LZMAError
                 else:
-                    self.cmp = lzma.LZMACompressor()
-
+                    self.cmp = lzma.LZMACompressor(preset=preset)
+            elif comptype == "zst":
+                try:
+                    from compression import zstd
+                except ImportError:
+                    raise CompressionError("compression.zstd module is not available") from None
+                if mode == "r":
+                    self.dbuf = b""
+                    self.cmp = zstd.ZstdDecompressor()
+                    self.exception = zstd.ZstdError
+                else:
+                    self.cmp = zstd.ZstdCompressor()
             elif comptype != "tar":
                 raise CompressionError("unknown compression type %r" % comptype)
 
@@ -597,6 +601,8 @@ def getcomptype(self):
             return "bz2"
         elif self.buf.startswith((b"\x5d\x00\x00\x80", b"\xfd7zXZ")):
             return "xz"
+        elif self.buf.startswith(b"\x28\xb5\x2f\xfd"):
+            return "zst"
         else:
             return "tar"
 
@@ -641,6 +647,10 @@ def __init__(self, fileobj, offset, size, name, blockinfo=None):
     def flush(self):
         pass
 
+    @property
+    def mode(self):
+        return 'rb'
+
     def readable(self):
         return True
 
@@ -756,10 +766,22 @@ def __init__(self, tarinfo, path):
         super().__init__(f'{tarinfo.name!r} would link to {path!r}, '
                          + 'which is outside the destination')
 
+class LinkFallbackError(FilterError):
+    def __init__(self, tarinfo, path):
+        self.tarinfo = tarinfo
+        self._path = path
+        super().__init__(f'link {tarinfo.name!r} would be extracted as a '
+                         + f'copy of {path!r}, which was rejected')
+
+# Errors caused by filters -- both "fatal" and "non-fatal" -- that
+# we consider to be issues with the argument, rather than a bug in the
+# filter function
+_FILTER_ERRORS = (FilterError, OSError, ExtractError)
+
 def _get_filtered_attrs(member, dest_path, for_data=True):
     new_attrs = {}
     name = member.name
-    dest_path = os.path.realpath(dest_path)
+    dest_path = os.path.realpath(dest_path, strict=os.path.ALLOW_MISSING)
     # Strip leading / (tar's directory separator) from filenames.
     # Include os.sep (target OS directory separator) as well.
     if name.startswith(('/', os.sep)):
@@ -769,7 +791,8 @@ def _get_filtered_attrs(member, dest_path, for_data=True):
         # For example, 'C:/foo' on Windows.
         raise AbsolutePathError(member)
     # Ensure we stay in the destination
-    target_path = os.path.realpath(os.path.join(dest_path, name))
+    target_path = os.path.realpath(os.path.join(dest_path, name),
+                                   strict=os.path.ALLOW_MISSING)
     if os.path.commonpath([target_path, dest_path]) != dest_path:
         raise OutsideDestinationError(member, target_path)
     # Limit permissions (no high bits, and go-w)
@@ -807,6 +830,9 @@ def _get_filtered_attrs(member, dest_path, for_data=True):
         if member.islnk() or member.issym():
             if os.path.isabs(member.linkname):
                 raise AbsoluteLinkError(member)
+            normalized = os.path.normpath(member.linkname)
+            if normalized != member.linkname:
+                new_attrs['linkname'] = normalized
             if member.issym():
                 target_path = os.path.join(dest_path,
                                            os.path.dirname(name),
@@ -814,7 +840,8 @@ def _get_filtered_attrs(member, dest_path, for_data=True):
             else:
                 target_path = os.path.join(dest_path,
                                            member.linkname)
-            target_path = os.path.realpath(target_path)
+            target_path = os.path.realpath(target_path,
+                                           strict=os.path.ALLOW_MISSING)
             if os.path.commonpath([target_path, dest_path]) != dest_path:
                 raise LinkOutsideDestinationError(member, target_path)
     return new_attrs
@@ -847,6 +874,9 @@ def data_filter(member, dest_path):
 # Sentinel for replace() defaults, meaning "don't change the attribute"
 _KEEP = object()
 
+# Header length is digits followed by a space.
+_header_length_prefix_re = re.compile(br"([0-9]{1,20}) ")
+
 class TarInfo(object):
     """Informational class which holds the details about an
        archive member given by a tar header block.
@@ -877,7 +907,7 @@ class TarInfo(object):
         pax_headers = ('A dictionary containing key-value pairs of an '
                        'associated pax extended header.'),
         sparse = 'Sparse member information.',
-        tarfile = None,
+        _tarfile = None,
         _sparse_structs = None,
         _link_target = None,
         )
@@ -906,6 +936,24 @@ def __init__(self, name=""):
         self.sparse = None      # sparse member information
         self.pax_headers = {}   # pax header information
 
+    @property
+    def tarfile(self):
+        import warnings
+        warnings.warn(
+            'The undocumented "tarfile" attribute of TarInfo objects '
+            + 'is deprecated and will be removed in Python 3.16',
+            DeprecationWarning, stacklevel=2)
+        return self._tarfile
+
+    @tarfile.setter
+    def tarfile(self, tarfile):
+        import warnings
+        warnings.warn(
+            'The undocumented "tarfile" attribute of TarInfo objects '
+            + 'is deprecated and will be removed in Python 3.16',
+            DeprecationWarning, stacklevel=2)
+        self._tarfile = tarfile
+
     @property
     def path(self):
         'In pax headers, "name" is called "path".'
@@ -1200,7 +1248,7 @@ def _create_pax_generic_header(cls, pax_headers, type, encoding):
         for keyword, value in pax_headers.items():
             keyword = keyword.encode("utf-8")
             if binary:
-                # Try to restore the original byte representation of `value'.
+                # Try to restore the original byte representation of 'value'.
                 # Needless to say, that the encoding must match the string.
                 value = value.encode(encoding, "surrogateescape")
             else:
@@ -1416,37 +1464,59 @@ def _proc_pax(self, tarfile):
         else:
             pax_headers = tarfile.pax_headers.copy()
 
-        # Check if the pax header contains a hdrcharset field. This tells us
-        # the encoding of the path, linkpath, uname and gname fields. Normally,
-        # these fields are UTF-8 encoded but since POSIX.1-2008 tar
-        # implementations are allowed to store them as raw binary strings if
-        # the translation to UTF-8 fails.
-        match = re.search(br"\d+ hdrcharset=([^\n]+)\n", buf)
-        if match is not None:
-            pax_headers["hdrcharset"] = match.group(1).decode("utf-8")
-
-        # For the time being, we don't care about anything other than "BINARY".
-        # The only other value that is currently allowed by the standard is
-        # "ISO-IR 10646 2000 UTF-8" in other words UTF-8.
-        hdrcharset = pax_headers.get("hdrcharset")
-        if hdrcharset == "BINARY":
-            encoding = tarfile.encoding
-        else:
-            encoding = "utf-8"
-
         # Parse pax header information. A record looks like that:
         # "%d %s=%s\n" % (length, keyword, value). length is the size
         # of the complete record including the length field itself and
-        # the newline. keyword and value are both UTF-8 encoded strings.
-        regex = re.compile(br"(\d+) ([^=]+)=")
+        # the newline.
         pos = 0
-        while match := regex.match(buf, pos):
-            length, keyword = match.groups()
-            length = int(length)
-            if length == 0:
+        encoding = None
+        raw_headers = []
+        while len(buf) > pos and buf[pos] != 0x00:
+            if not (match := _header_length_prefix_re.match(buf, pos)):
                 raise InvalidHeaderError("invalid header")
-            value = buf[match.end(2) + 1:match.start(1) + length - 1]
+            try:
+                length = int(match.group(1))
+            except ValueError:
+                raise InvalidHeaderError("invalid header")
+            # Headers must be at least 5 bytes, shortest being '5 x=\n'.
+            # Value is allowed to be empty.
+            if length < 5:
+                raise InvalidHeaderError("invalid header")
+            if pos + length > len(buf):
+                raise InvalidHeaderError("invalid header")
+
+            header_value_end_offset = match.start(1) + length - 1  # Last byte of the header
+            keyword_and_value = buf[match.end(1) + 1:header_value_end_offset]
+            raw_keyword, equals, raw_value = keyword_and_value.partition(b"=")
 
+            # Check the framing of the header. The last character must be '\n' (0x0A)
+            if not raw_keyword or equals != b"=" or buf[header_value_end_offset] != 0x0A:
+                raise InvalidHeaderError("invalid header")
+            raw_headers.append((length, raw_keyword, raw_value))
+
+            # Check if the pax header contains a hdrcharset field. This tells us
+            # the encoding of the path, linkpath, uname and gname fields. Normally,
+            # these fields are UTF-8 encoded but since POSIX.1-2008 tar
+            # implementations are allowed to store them as raw binary strings if
+            # the translation to UTF-8 fails. For the time being, we don't care about
+            # anything other than "BINARY". The only other value that is currently
+            # allowed by the standard is "ISO-IR 10646 2000 UTF-8" in other words UTF-8.
+            # Note that we only follow the initial 'hdrcharset' setting to preserve
+            # the initial behavior of the 'tarfile' module.
+            if raw_keyword == b"hdrcharset" and encoding is None:
+                if raw_value == b"BINARY":
+                    encoding = tarfile.encoding
+                else:  # This branch ensures only the first 'hdrcharset' header is used.
+                    encoding = "utf-8"
+
+            pos += length
+
+        # If no explicit hdrcharset is set, we use UTF-8 as a default.
+        if encoding is None:
+            encoding = "utf-8"
+
+        # After parsing the raw headers we can decode them to text.
+        for length, raw_keyword, raw_value in raw_headers:
             # Normally, we could just use "utf-8" as the encoding and "strict"
             # as the error handler, but we better not take the risk. For
             # example, GNU tar <= 1.23 is known to store filenames it cannot
@@ -1454,17 +1524,16 @@ def _proc_pax(self, tarfile):
             # hdrcharset=BINARY header).
             # We first try the strict standard encoding, and if that fails we
             # fall back on the user's encoding and error handler.
-            keyword = self._decode_pax_field(keyword, "utf-8", "utf-8",
+            keyword = self._decode_pax_field(raw_keyword, "utf-8", "utf-8",
                     tarfile.errors)
             if keyword in PAX_NAME_FIELDS:
-                value = self._decode_pax_field(value, encoding, tarfile.encoding,
+                value = self._decode_pax_field(raw_value, encoding, tarfile.encoding,
                         tarfile.errors)
             else:
-                value = self._decode_pax_field(value, "utf-8", "utf-8",
+                value = self._decode_pax_field(raw_value, "utf-8", "utf-8",
                         tarfile.errors)
 
             pax_headers[keyword] = value
-            pos += length
 
         # Fetch the next header.
         try:
@@ -1479,7 +1548,7 @@ def _proc_pax(self, tarfile):
 
         elif "GNU.sparse.size" in pax_headers:
             # GNU extended sparse format version 0.0.
-            self._proc_gnusparse_00(next, pax_headers, buf)
+            self._proc_gnusparse_00(next, raw_headers)
 
         elif pax_headers.get("GNU.sparse.major") == "1" and pax_headers.get("GNU.sparse.minor") == "0":
             # GNU extended sparse format version 1.0.
@@ -1501,15 +1570,24 @@ def _proc_pax(self, tarfile):
 
         return next
 
-    def _proc_gnusparse_00(self, next, pax_headers, buf):
+    def _proc_gnusparse_00(self, next, raw_headers):
         """Process a GNU tar extended sparse header, version 0.0.
         """
         offsets = []
-        for match in re.finditer(br"\d+ GNU.sparse.offset=(\d+)\n", buf):
-            offsets.append(int(match.group(1)))
         numbytes = []
-        for match in re.finditer(br"\d+ GNU.sparse.numbytes=(\d+)\n", buf):
-            numbytes.append(int(match.group(1)))
+        for _, keyword, value in raw_headers:
+            if keyword == b"GNU.sparse.offset":
+                try:
+                    offsets.append(int(value.decode()))
+                except ValueError:
+                    raise InvalidHeaderError("invalid header")
+
+            elif keyword == b"GNU.sparse.numbytes":
+                try:
+                    numbytes.append(int(value.decode()))
+                except ValueError:
+                    raise InvalidHeaderError("invalid header")
+
         next.sparse = list(zip(offsets, numbytes))
 
     def _proc_gnusparse_01(self, next, pax_headers):
@@ -1569,6 +1647,9 @@ def _block(self, count):
         """Round up a byte count by BLOCKSIZE and return it,
            e.g. _block(834) => 1024.
         """
+        # Only non-negative offsets are allowed
+        if count < 0:
+            raise InvalidHeaderError("invalid offset")
         blocks, remainder = divmod(count, BLOCKSIZE)
         if remainder:
             blocks += 1
@@ -1645,14 +1726,14 @@ class TarFile(object):
     def __init__(self, name=None, mode="r", fileobj=None, format=None,
             tarinfo=None, dereference=None, ignore_zeros=None, encoding=None,
             errors="surrogateescape", pax_headers=None, debug=None,
-            errorlevel=None, copybufsize=None):
-        """Open an (uncompressed) tar archive `name'. `mode' is either 'r' to
+            errorlevel=None, copybufsize=None, stream=False):
+        """Open an (uncompressed) tar archive 'name'. 'mode' is either 'r' to
            read from an existing archive, 'a' to append data to an existing
-           file or 'w' to create a new file overwriting an existing one. `mode'
+           file or 'w' to create a new file overwriting an existing one. 'mode'
            defaults to 'r'.
-           If `fileobj' is given, it is used for reading or writing data. If it
-           can be determined, `mode' is overridden by `fileobj's mode.
-           `fileobj' is not closed, when TarFile is closed.
+           If 'fileobj' is given, it is used for reading or writing data. If it
+           can be determined, 'mode' is overridden by 'fileobj's mode.
+           'fileobj' is not closed, when TarFile is closed.
         """
         modes = {"r": "rb", "a": "r+b", "w": "wb", "x": "xb"}
         if mode not in modes:
@@ -1677,6 +1758,8 @@ def __init__(self, name=None, mode="r", fileobj=None, format=None,
         self.name = os.path.abspath(name) if name else None
         self.fileobj = fileobj
 
+        self.stream = stream
+
         # Init attributes.
         if format is not None:
             self.format = format
@@ -1709,6 +1792,8 @@ def __init__(self, name=None, mode="r", fileobj=None, format=None,
                                 # current position in the archive file
         self.inodes = {}        # dictionary caching the inodes of
                                 # archive members already added
+        self._unames = {}       # Cached mappings of uid -> uname
+        self._gnames = {}       # Cached mappings of gid -> gname
 
         try:
             if self.mode == "r":
@@ -1764,11 +1849,13 @@ def open(cls, name=None, mode="r", fileobj=None, bufsize=RECORDSIZE, **kwargs):
            'r:gz'       open for reading with gzip compression
            'r:bz2'      open for reading with bzip2 compression
            'r:xz'       open for reading with lzma compression
+           'r:zst'      open for reading with zstd compression
            'a' or 'a:'  open for appending, creating the file if necessary
            'w' or 'w:'  open for writing without compression
            'w:gz'       open for writing with gzip compression
            'w:bz2'      open for writing with bzip2 compression
            'w:xz'       open for writing with lzma compression
+           'w:zst'      open for writing with zstd compression
 
            'x' or 'x:'  create a tarfile exclusively without compression, raise
                         an exception if the file is already created
@@ -1778,16 +1865,20 @@ def open(cls, name=None, mode="r", fileobj=None, bufsize=RECORDSIZE, **kwargs):
                         if the file is already created
            'x:xz'       create an lzma compressed tarfile, raise an exception
                         if the file is already created
+           'x:zst'      create a zstd compressed tarfile, raise an exception
+                        if the file is already created
 
            'r|*'        open a stream of tar blocks with transparent compression
            'r|'         open an uncompressed stream of tar blocks for reading
            'r|gz'       open a gzip compressed stream of tar blocks
            'r|bz2'      open a bzip2 compressed stream of tar blocks
            'r|xz'       open an lzma compressed stream of tar blocks
+           'r|zst'      open a zstd compressed stream of tar blocks
            'w|'         open an uncompressed stream for writing
            'w|gz'       open a gzip compressed stream for writing
            'w|bz2'      open a bzip2 compressed stream for writing
            'w|xz'       open an lzma compressed stream for writing
+           'w|zst'      open a zstd compressed stream for writing
         """
 
         if not name and not fileobj:
@@ -1832,10 +1923,17 @@ def not_compressed(comptype):
 
             if filemode not in ("r", "w"):
                 raise ValueError("mode must be 'r' or 'w'")
+            if "compresslevel" in kwargs and comptype not in ("gz", "bz2"):
+                raise ValueError(
+                    "compresslevel is only valid for w|gz and w|bz2 modes"
+                )
+            if "preset" in kwargs and comptype not in ("xz",):
+                raise ValueError("preset is only valid for w|xz mode")
 
             compresslevel = kwargs.pop("compresslevel", 9)
+            preset = kwargs.pop("preset", None)
             stream = _Stream(name, filemode, comptype, fileobj, bufsize,
-                             compresslevel)
+                             compresslevel, preset)
             try:
                 t = cls(name, filemode, stream, **kwargs)
             except:
@@ -1931,9 +2029,6 @@ def xzopen(cls, name, mode="r", fileobj=None, preset=None, **kwargs):
         except ImportError:
             raise CompressionError("lzma module is not available") from None
 
-        # XXX: RUSTPYTHON; xz is not supported yet
-        raise CompressionError("lzma module is not available") from None
-
         fileobj = LZMAFile(fileobj or name, mode, preset=preset)
 
         try:
@@ -1949,12 +2044,48 @@ def xzopen(cls, name, mode="r", fileobj=None, preset=None, **kwargs):
         t._extfileobj = False
         return t
 
+    @classmethod
+    def zstopen(cls, name, mode="r", fileobj=None, level=None, options=None,
+                zstd_dict=None, **kwargs):
+        """Open zstd compressed tar archive name for reading or writing.
+           Appending is not allowed.
+        """
+        if mode not in ("r", "w", "x"):
+            raise ValueError("mode must be 'r', 'w' or 'x'")
+
+        try:
+            from compression.zstd import ZstdFile, ZstdError
+        except ImportError:
+            raise CompressionError("compression.zstd module is not available") from None
+
+        fileobj = ZstdFile(
+            fileobj or name,
+            mode,
+            level=level,
+            options=options,
+            zstd_dict=zstd_dict
+        )
+
+        try:
+            t = cls.taropen(name, mode, fileobj, **kwargs)
+        except (ZstdError, EOFError) as e:
+            fileobj.close()
+            if mode == 'r':
+                raise ReadError("not a zstd file") from e
+            raise
+        except Exception:
+            fileobj.close()
+            raise
+        t._extfileobj = False
+        return t
+
     # All *open() methods are registered here.
     OPEN_METH = {
         "tar": "taropen",   # uncompressed tar
         "gz":  "gzopen",    # gzip compressed tar
         "bz2": "bz2open",   # bzip2 compressed tar
-        "xz":  "xzopen"     # lzma compressed tar
+        "xz":  "xzopen",    # lzma compressed tar
+        "zst": "zstopen",   # zstd compressed tar
     }
 
     #--------------------------------------------------------------------------
@@ -1982,7 +2113,7 @@ def close(self):
                 self.fileobj.close()
 
     def getmember(self, name):
-        """Return a TarInfo object for member `name'. If `name' can not be
+        """Return a TarInfo object for member 'name'. If 'name' can not be
            found in the archive, KeyError is raised. If a member occurs more
            than once in the archive, its last occurrence is assumed to be the
            most up-to-date version.
@@ -2010,9 +2141,9 @@ def getnames(self):
 
     def gettarinfo(self, name=None, arcname=None, fileobj=None):
         """Create a TarInfo object from the result of os.stat or equivalent
-           on an existing file. The file is either named by `name', or
-           specified as a file object `fileobj' with a file descriptor. If
-           given, `arcname' specifies an alternative name for the file in the
+           on an existing file. The file is either named by 'name', or
+           specified as a file object 'fileobj' with a file descriptor. If
+           given, 'arcname' specifies an alternative name for the file in the
            archive, otherwise, the name is taken from the 'name' attribute of
            'fileobj', or the 'name' argument. The name should be a text
            string.
@@ -2036,7 +2167,7 @@ def gettarinfo(self, name=None, arcname=None, fileobj=None):
         # Now, fill the TarInfo object with
         # information specific for the file.
         tarinfo = self.tarinfo()
-        tarinfo.tarfile = self  # Not needed
+        tarinfo._tarfile = self  # To be removed in 3.16.
 
         # Use os.stat or os.lstat, depending on if symlinks shall be resolved.
         if fileobj is None:
@@ -2090,16 +2221,23 @@ def gettarinfo(self, name=None, arcname=None, fileobj=None):
         tarinfo.mtime = statres.st_mtime
         tarinfo.type = type
         tarinfo.linkname = linkname
+
+        # Calls to pwd.getpwuid() and grp.getgrgid() tend to be expensive. To
+        # speed things up, cache the resolved usernames and group names.
         if pwd:
-            try:
-                tarinfo.uname = pwd.getpwuid(tarinfo.uid)[0]
-            except KeyError:
-                pass
+            if tarinfo.uid not in self._unames:
+                try:
+                    self._unames[tarinfo.uid] = pwd.getpwuid(tarinfo.uid)[0]
+                except KeyError:
+                    self._unames[tarinfo.uid] = ''
+            tarinfo.uname = self._unames[tarinfo.uid]
         if grp:
-            try:
-                tarinfo.gname = grp.getgrgid(tarinfo.gid)[0]
-            except KeyError:
-                pass
+            if tarinfo.gid not in self._gnames:
+                try:
+                    self._gnames[tarinfo.gid] = grp.getgrgid(tarinfo.gid)[0]
+                except KeyError:
+                    self._gnames[tarinfo.gid] = ''
+            tarinfo.gname = self._gnames[tarinfo.gid]
 
         if type in (CHRTYPE, BLKTYPE):
             if hasattr(os, "major") and hasattr(os, "minor"):
@@ -2108,11 +2246,15 @@ def gettarinfo(self, name=None, arcname=None, fileobj=None):
         return tarinfo
 
     def list(self, verbose=True, *, members=None):
-        """Print a table of contents to sys.stdout. If `verbose' is False, only
-           the names of the members are printed. If it is True, an `ls -l'-like
-           output is produced. `members' is optional and must be a subset of the
+        """Print a table of contents to sys.stdout. If 'verbose' is False, only
+           the names of the members are printed. If it is True, an 'ls -l'-like
+           output is produced. 'members' is optional and must be a subset of the
            list returned by getmembers().
         """
+        # Convert tarinfo type to stat type.
+        type2mode = {REGTYPE: stat.S_IFREG, SYMTYPE: stat.S_IFLNK,
+                     FIFOTYPE: stat.S_IFIFO, CHRTYPE: stat.S_IFCHR,
+                     DIRTYPE: stat.S_IFDIR, BLKTYPE: stat.S_IFBLK}
         self._check()
 
         if members is None:
@@ -2122,7 +2264,8 @@ def list(self, verbose=True, *, members=None):
                 if tarinfo.mode is None:
                     _safe_print("??????????")
                 else:
-                    _safe_print(stat.filemode(tarinfo.mode))
+                    modetype = type2mode.get(tarinfo.type, 0)
+                    _safe_print(stat.filemode(modetype | tarinfo.mode))
                 _safe_print("%s/%s" % (tarinfo.uname or tarinfo.uid,
                                        tarinfo.gname or tarinfo.gid))
                 if tarinfo.ischr() or tarinfo.isblk():
@@ -2146,11 +2289,11 @@ def list(self, verbose=True, *, members=None):
             print()
 
     def add(self, name, arcname=None, recursive=True, *, filter=None):
-        """Add the file `name' to the archive. `name' may be any type of file
-           (directory, fifo, symbolic link, etc.). If given, `arcname'
+        """Add the file 'name' to the archive. 'name' may be any type of file
+           (directory, fifo, symbolic link, etc.). If given, 'arcname'
            specifies an alternative name for the file in the archive.
            Directories are added recursively by default. This can be avoided by
-           setting `recursive' to False. `filter' is a function
+           setting 'recursive' to False. 'filter' is a function
            that expects a TarInfo object argument and returns the changed
            TarInfo object, if it returns None the TarInfo object will be
            excluded from the archive.
@@ -2197,13 +2340,16 @@ def add(self, name, arcname=None, recursive=True, *, filter=None):
             self.addfile(tarinfo)
 
     def addfile(self, tarinfo, fileobj=None):
-        """Add the TarInfo object `tarinfo' to the archive. If `fileobj' is
-           given, it should be a binary file, and tarinfo.size bytes are read
-           from it and added to the archive. You can create TarInfo objects
-           directly, or by using gettarinfo().
+        """Add the TarInfo object 'tarinfo' to the archive. If 'tarinfo' represents
+           a non zero-size regular file, the 'fileobj' argument should be a binary file,
+           and tarinfo.size bytes are read from it and added to the archive.
+           You can create TarInfo objects directly, or by using gettarinfo().
         """
         self._check("awx")
 
+        if fileobj is None and tarinfo.isreg() and tarinfo.size != 0:
+            raise ValueError("fileobj not provided for non zero-size regular file")
+
         tarinfo = copy.copy(tarinfo)
 
         buf = tarinfo.tobuf(self.format, self.encoding, self.errors)
@@ -2225,12 +2371,7 @@ def _get_filter_function(self, filter):
         if filter is None:
             filter = self.extraction_filter
             if filter is None:
-                warnings.warn(
-                    'Python 3.14 will, by default, filter extracted tar '
-                    + 'archives and reject files or modify their metadata. '
-                    + 'Use the filter argument to control this behavior.',
-                    DeprecationWarning)
-                return fully_trusted_filter
+                return data_filter
             if isinstance(filter, str):
                 raise TypeError(
                     'String names are not supported for '
@@ -2248,12 +2389,12 @@ def extractall(self, path=".", members=None, *, numeric_owner=False,
                    filter=None):
         """Extract all members from the archive to the current working
            directory and set owner, modification time and permissions on
-           directories afterwards. `path' specifies a different directory
-           to extract to. `members' is optional and must be a subset of the
-           list returned by getmembers(). If `numeric_owner` is True, only
+           directories afterwards. 'path' specifies a different directory
+           to extract to. 'members' is optional and must be a subset of the
+           list returned by getmembers(). If 'numeric_owner' is True, only
            the numbers for user/group names are used and not the names.
 
-           The `filter` function will be called on each member just
+           The 'filter' function will be called on each member just
            before extraction.
            It can return a changed TarInfo or None to skip the member.
            String names of common filters are accepted.
@@ -2265,81 +2406,124 @@ def extractall(self, path=".", members=None, *, numeric_owner=False,
             members = self
 
         for member in members:
-            tarinfo = self._get_extract_tarinfo(member, filter_function, path)
+            tarinfo, unfiltered = self._get_extract_tarinfo(
+                member, filter_function, path)
             if tarinfo is None:
                 continue
             if tarinfo.isdir():
                 # For directories, delay setting attributes until later,
                 # since permissions can interfere with extraction and
                 # extracting contents can reset mtime.
-                directories.append(tarinfo)
+                directories.append(unfiltered)
             self._extract_one(tarinfo, path, set_attrs=not tarinfo.isdir(),
-                              numeric_owner=numeric_owner)
+                              numeric_owner=numeric_owner,
+                              filter_function=filter_function)
 
         # Reverse sort directories.
         directories.sort(key=lambda a: a.name, reverse=True)
 
+
         # Set correct owner, mtime and filemode on directories.
-        for tarinfo in directories:
-            dirpath = os.path.join(path, tarinfo.name)
+        for unfiltered in directories:
             try:
+                # Need to re-apply any filter, to take the *current* filesystem
+                # state into account.
+                try:
+                    tarinfo = filter_function(unfiltered, path)
+                except _FILTER_ERRORS as exc:
+                    self._log_no_directory_fixup(unfiltered, repr(exc))
+                    continue
+                if tarinfo is None:
+                    self._log_no_directory_fixup(unfiltered,
+                                                 'excluded by filter')
+                    continue
+                dirpath = os.path.join(path, tarinfo.name)
+                try:
+                    lstat = os.lstat(dirpath)
+                except FileNotFoundError:
+                    self._log_no_directory_fixup(tarinfo, 'missing')
+                    continue
+                if not stat.S_ISDIR(lstat.st_mode):
+                    # This is no longer a directory; presumably a later
+                    # member overwrote the entry.
+                    self._log_no_directory_fixup(tarinfo, 'not a directory')
+                    continue
                 self.chown(tarinfo, dirpath, numeric_owner=numeric_owner)
                 self.utime(tarinfo, dirpath)
                 self.chmod(tarinfo, dirpath)
             except ExtractError as e:
                 self._handle_nonfatal_error(e)
 
+    def _log_no_directory_fixup(self, member, reason):
+        self._dbg(2, "tarfile: Not fixing up directory %r (%s)" %
+                  (member.name, reason))
+
     def extract(self, member, path="", set_attrs=True, *, numeric_owner=False,
                 filter=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 TarInfo object. You can
-           specify a different directory using `path'. File attributes (owner,
-           mtime, mode) are set unless `set_attrs' is False. If `numeric_owner`
+           as possible. 'member' may be a filename or a TarInfo object. You can
+           specify a different directory using 'path'. File attributes (owner,
+           mtime, mode) are set unless 'set_attrs' is False. If 'numeric_owner'
            is True, only the numbers for user/group names are used and not
            the names.
 
-           The `filter` function will be called before extraction.
+           The 'filter' function will be called before extraction.
            It can return a changed TarInfo or None to skip the member.
            String names of common filters are accepted.
         """
         filter_function = self._get_filter_function(filter)
-        tarinfo = self._get_extract_tarinfo(member, filter_function, path)
+        tarinfo, unfiltered = self._get_extract_tarinfo(
+            member, filter_function, path)
         if tarinfo is not None:
             self._extract_one(tarinfo, path, set_attrs, numeric_owner)
 
     def _get_extract_tarinfo(self, member, filter_function, path):
-        """Get filtered TarInfo (or None) from member, which might be a str"""
+        """Get (filtered, unfiltered) TarInfos from *member*
+
+        *member* might be a string.
+
+        Return (None, None) if not found.
+        """
+
         if isinstance(member, str):
-            tarinfo = self.getmember(member)
+            unfiltered = self.getmember(member)
         else:
-            tarinfo = member
+            unfiltered = member
 
-        unfiltered = tarinfo
+        filtered = None
         try:
-            tarinfo = filter_function(tarinfo, path)
-        except (OSError, FilterError) as e:
+            filtered = filter_function(unfiltered, path)
+        except (OSError, UnicodeEncodeError, FilterError) as e:
             self._handle_fatal_error(e)
         except ExtractError as e:
             self._handle_nonfatal_error(e)
-        if tarinfo is None:
+        if filtered is None:
             self._dbg(2, "tarfile: Excluded %r" % unfiltered.name)
-            return None
+            return None, None
+
         # Prepare the link target for makelink().
-        if tarinfo.islnk():
-            tarinfo = copy.copy(tarinfo)
-            tarinfo._link_target = os.path.join(path, tarinfo.linkname)
-        return tarinfo
+        if filtered.islnk():
+            filtered = copy.copy(filtered)
+            filtered._link_target = os.path.join(path, filtered.linkname)
+        return filtered, unfiltered
 
-    def _extract_one(self, tarinfo, path, set_attrs, numeric_owner):
-        """Extract from filtered tarinfo to disk"""
+    def _extract_one(self, tarinfo, path, set_attrs, numeric_owner,
+                     filter_function=None):
+        """Extract from filtered tarinfo to disk.
+
+           filter_function is only used when extracting a *different*
+           member (e.g. as fallback to creating a symlink)
+        """
         self._check("r")
 
         try:
             self._extract_member(tarinfo, os.path.join(path, tarinfo.name),
                                  set_attrs=set_attrs,
-                                 numeric_owner=numeric_owner)
-        except OSError as e:
+                                 numeric_owner=numeric_owner,
+                                 filter_function=filter_function,
+                                 extraction_root=path)
+        except (OSError, UnicodeEncodeError) as e:
             self._handle_fatal_error(e)
         except ExtractError as e:
             self._handle_nonfatal_error(e)
@@ -2364,10 +2548,10 @@ def _handle_fatal_error(self, e):
             self._dbg(1, "tarfile: %s %s" % (type(e).__name__, e))
 
     def extractfile(self, member):
-        """Extract a member from the archive as a file object. `member' may be
-           a filename or a TarInfo object. If `member' is a regular file or
+        """Extract a member from the archive as a file object. 'member' may be
+           a filename or a TarInfo object. If 'member' is a regular file or
            a link, an io.BufferedReader object is returned. For all other
-           existing members, None is returned. If `member' does not appear
+           existing members, None is returned. If 'member' does not appear
            in the archive, KeyError is raised.
         """
         self._check("r")
@@ -2396,9 +2580,13 @@ def extractfile(self, member):
             return None
 
     def _extract_member(self, tarinfo, targetpath, set_attrs=True,
-                        numeric_owner=False):
-        """Extract the TarInfo object tarinfo to a physical
+                        numeric_owner=False, *, filter_function=None,
+                        extraction_root=None):
+        """Extract the filtered TarInfo object tarinfo to a physical
            file called targetpath.
+
+           filter_function is only used when extracting a *different*
+           member (e.g. as fallback to creating a symlink)
         """
         # Fetch the TarInfo object for the given name
         # and build the destination pathname, replacing
@@ -2411,7 +2599,7 @@ def _extract_member(self, tarinfo, targetpath, set_attrs=True,
         if upperdirs and not os.path.exists(upperdirs):
             # Create directories that are not part of the archive with
             # default permissions.
-            os.makedirs(upperdirs)
+            os.makedirs(upperdirs, exist_ok=True)
 
         if tarinfo.islnk() or tarinfo.issym():
             self._dbg(1, "%s -> %s" % (tarinfo.name, tarinfo.linkname))
@@ -2427,7 +2615,10 @@ def _extract_member(self, tarinfo, targetpath, set_attrs=True,
         elif tarinfo.ischr() or tarinfo.isblk():
             self.makedev(tarinfo, targetpath)
         elif tarinfo.islnk() or tarinfo.issym():
-            self.makelink(tarinfo, targetpath)
+            self.makelink_with_filter(
+                tarinfo, targetpath,
+                filter_function=filter_function,
+                extraction_root=extraction_root)
         elif tarinfo.type not in SUPPORTED_TYPES:
             self.makeunknown(tarinfo, targetpath)
         else:
@@ -2510,10 +2701,18 @@ def makedev(self, tarinfo, targetpath):
                  os.makedev(tarinfo.devmajor, tarinfo.devminor))
 
     def makelink(self, tarinfo, targetpath):
+        return self.makelink_with_filter(tarinfo, targetpath, None, None)
+
+    def makelink_with_filter(self, tarinfo, targetpath,
+                             filter_function, extraction_root):
         """Make a (symbolic) link called targetpath. If it cannot be created
           (platform limitation), we try to make a copy of the referenced file
           instead of a link.
+
+          filter_function is only used when extracting a *different*
+          member (e.g. as fallback to creating a link).
         """
+        keyerror_to_extracterror = False
         try:
             # For systems that support symbolic and hard links.
             if tarinfo.issym():
@@ -2521,18 +2720,41 @@ def makelink(self, tarinfo, targetpath):
                     # Avoid FileExistsError on following os.symlink.
                     os.unlink(targetpath)
                 os.symlink(tarinfo.linkname, targetpath)
+                return
             else:
                 if os.path.exists(tarinfo._link_target):
+                    if os.path.lexists(targetpath):
+                        # Avoid FileExistsError on following os.link.
+                        os.unlink(targetpath)
                     os.link(tarinfo._link_target, targetpath)
-                else:
-                    self._extract_member(self._find_link_target(tarinfo),
-                                         targetpath)
+                    return
         except symlink_exception:
+            keyerror_to_extracterror = True
+
+        try:
+            unfiltered = self._find_link_target(tarinfo)
+        except KeyError:
+            if keyerror_to_extracterror:
+                raise ExtractError(
+                    "unable to resolve link inside archive") from None
+            else:
+                raise
+
+        if filter_function is None:
+            filtered = unfiltered
+        else:
+            if extraction_root is None:
+                raise ExtractError(
+                    "makelink_with_filter: if filter_function is not None, "
+                    + "extraction_root must also not be None")
             try:
-                self._extract_member(self._find_link_target(tarinfo),
-                                     targetpath)
-            except KeyError:
-                raise ExtractError("unable to resolve link inside archive") from None
+                filtered = filter_function(unfiltered, extraction_root)
+            except _FILTER_ERRORS as cause:
+                raise LinkFallbackError(tarinfo, unfiltered.name) from cause
+        if filtered is not None:
+            self._extract_member(filtered, targetpath,
+                                 filter_function=filter_function,
+                                 extraction_root=extraction_root)
 
     def chown(self, tarinfo, targetpath, numeric_owner):
         """Set owner of targetpath according to tarinfo. If numeric_owner
@@ -2564,7 +2786,8 @@ def chown(self, tarinfo, targetpath, numeric_owner):
                     os.lchown(targetpath, u, g)
                 else:
                     os.chown(targetpath, u, g)
-            except OSError as e:
+            except (OSError, OverflowError) as e:
+                # OverflowError can be raised if an ID doesn't fit in 'id_t'
                 raise ExtractError("could not change owner") from e
 
     def chmod(self, tarinfo, targetpath):
@@ -2647,7 +2870,9 @@ def next(self):
             break
 
         if tarinfo is not None:
-            self.members.append(tarinfo)
+            # if streaming the file we do not want to cache the tarinfo
+            if not self.stream:
+                self.members.append(tarinfo)
         else:
             self._loaded = True
 
@@ -2698,11 +2923,12 @@ def _getmember(self, name, tarinfo=None, normalize=False):
 
     def _load(self):
         """Read through the entire archive file and look for readable
-           members.
+           members. This should not run if the file is set to stream.
         """
-        while self.next() is not None:
-            pass
-        self._loaded = True
+        if not self.stream:
+            while self.next() is not None:
+                pass
+            self._loaded = True
 
     def _check(self, mode=None):
         """Check if TarFile is still open, and if the operation's mode
@@ -2812,7 +3038,7 @@ def main():
     import argparse
 
     description = 'A simple command-line interface for tarfile module.'
-    parser = argparse.ArgumentParser(description=description)
+    parser = argparse.ArgumentParser(description=description, color=True)
     parser.add_argument('-v', '--verbose', action='store_true', default=False,
                         help='Verbose output')
     parser.add_argument('--filter', metavar='<filtername>',
@@ -2892,6 +3118,9 @@ def main():
             '.tbz': 'bz2',
             '.tbz2': 'bz2',
             '.tb2': 'bz2',
+            # zstd
+            '.zst': 'zst',
+            '.tzst': 'zst',
         }
         tar_mode = 'w:' + compressions[ext] if ext in compressions else 'w'
         tar_files = args.create
diff --git a/Lib/tempfile.py b/Lib/tempfile.py
index 8036e93cd6d..5e3ccab5f48 100644
--- a/Lib/tempfile.py
+++ b/Lib/tempfile.py
@@ -438,11 +438,19 @@ class _TemporaryFileCloser:
     cleanup_called = False
     close_called = False
 
-    def __init__(self, file, name, delete=True, delete_on_close=True):
+    def __init__(
+        self,
+        file,
+        name,
+        delete=True,
+        delete_on_close=True,
+        warn_message="Implicitly cleaning up unknown file",
+    ):
         self.file = file
         self.name = name
         self.delete = delete
         self.delete_on_close = delete_on_close
+        self.warn_message = warn_message
 
     def cleanup(self, windows=(_os.name == 'nt'), unlink=_os.unlink):
         if not self.cleanup_called:
@@ -470,7 +478,10 @@ def close(self):
                     self.cleanup()
 
     def __del__(self):
+        close_called = self.close_called
         self.cleanup()
+        if not close_called:
+            _warnings.warn(self.warn_message, ResourceWarning)
 
 
 class _TemporaryFileWrapper:
@@ -484,8 +495,17 @@ class _TemporaryFileWrapper:
     def __init__(self, file, name, delete=True, delete_on_close=True):
         self.file = file
         self.name = name
-        self._closer = _TemporaryFileCloser(file, name, delete,
-                                            delete_on_close)
+        self._closer = _TemporaryFileCloser(
+            file,
+            name,
+            delete,
+            delete_on_close,
+            warn_message=f"Implicitly cleaning up {self!r}",
+        )
+
+    def __repr__(self):
+        file = self.__dict__['file']
+        return f"<{type(self).__name__} {file=}>"
 
     def __getattr__(self, name):
         # Attribute lookups are delegated to the underlying file
diff --git a/Lib/test/_code_definitions.py b/Lib/test/_code_definitions.py
new file mode 100644
index 00000000000..70c44da2ec6
--- /dev/null
+++ b/Lib/test/_code_definitions.py
@@ -0,0 +1,323 @@
+
+def simple_script():
+    assert True
+
+
+def complex_script():
+    obj = 'a string'
+    pickle = __import__('pickle')
+    def spam_minimal():
+        pass
+    spam_minimal()
+    data = pickle.dumps(obj)
+    res = pickle.loads(data)
+    assert res == obj, (res, obj)
+
+
+def script_with_globals():
+    obj1, obj2 = spam(42)
+    assert obj1 == 42
+    assert obj2 is None
+
+
+def script_with_explicit_empty_return():
+    return None
+
+
+def script_with_return():
+    return True
+
+
+def spam_minimal():
+    # no arg defaults or kwarg defaults
+    # no annotations
+    # no local vars
+    # no free vars
+    # no globals
+    # no builtins
+    # no attr access (names)
+    # no code
+    return
+
+
+def spam_with_builtins():
+    x = 42
+    values = (42,)
+    checks = tuple(callable(v) for v in values)
+    res = callable(values), tuple(values), list(values), checks
+    print(res)
+
+
+def spam_with_globals_and_builtins():
+    func1 = spam
+    func2 = spam_minimal
+    funcs = (func1, func2)
+    checks = tuple(callable(f) for f in funcs)
+    res = callable(funcs), tuple(funcs), list(funcs), checks
+    print(res)
+
+
+def spam_with_global_and_attr_same_name():
+    try:
+        spam_minimal.spam_minimal
+    except AttributeError:
+        pass
+
+
+def spam_full_args(a, b, /, c, d, *args, e, f, **kwargs):
+    return (a, b, c, d, e, f, args, kwargs)
+
+
+def spam_full_args_with_defaults(a=-1, b=-2, /, c=-3, d=-4, *args,
+                                 e=-5, f=-6, **kwargs):
+    return (a, b, c, d, e, f, args, kwargs)
+
+
+def spam_args_attrs_and_builtins(a, b, /, c, d, *args, e, f, **kwargs):
+    if args.__len__() > 2:
+        return None
+    return a, b, c, d, e, f, args, kwargs
+
+
+def spam_returns_arg(x):
+    return x
+
+
+def spam_raises():
+    raise Exception('spam!')
+
+
+def spam_with_inner_not_closure():
+    def eggs():
+        pass
+    eggs()
+
+
+def spam_with_inner_closure():
+    x = 42
+    def eggs():
+        print(x)
+    eggs()
+
+
+def spam_annotated(a: int, b: str, c: object) -> tuple:
+    return a, b, c
+
+
+def spam_full(a, b, /, c, d:int=1, *args, e, f:object=None, **kwargs) -> tuple:
+    # arg defaults, kwarg defaults
+    # annotations
+    # all kinds of local vars, except cells
+    # no free vars
+    # some globals
+    # some builtins
+    # some attr access (names)
+    x = args
+    y = kwargs
+    z = (a, b, c, d)
+    kwargs['e'] = e
+    kwargs['f'] = f
+    extras = list((x, y, z, spam, spam.__name__))
+    return tuple(a, b, c, d, e, f, args, kwargs), extras
+
+
+def spam(x):
+    return x, None
+
+
+def spam_N(x):
+    def eggs_nested(y):
+        return None, y
+    return eggs_nested, x
+
+
+def spam_C(x):
+    a = 1
+    def eggs_closure(y):
+        return None, y, a, x
+    return eggs_closure, a, x
+
+
+def spam_NN(x):
+    def eggs_nested_N(y):
+        def ham_nested(z):
+            return None, z
+        return ham_nested, y
+    return eggs_nested_N, x
+
+
+def spam_NC(x):
+    a = 1
+    def eggs_nested_C(y):
+        def ham_closure(z):
+            return None, z, y, a, x
+        return ham_closure, y
+    return eggs_nested_C, a, x
+
+
+def spam_CN(x):
+    a = 1
+    def eggs_closure_N(y):
+        def ham_C_nested(z):
+            return None, z
+        return ham_C_nested, y, a, x
+    return eggs_closure_N, a, x
+
+
+def spam_CC(x):
+    a = 1
+    def eggs_closure_C(y):
+        b = 2
+        def ham_C_closure(z):
+            return None, z, b, y, a, x
+        return ham_C_closure, b, y, a, x
+    return eggs_closure_C, a, x
+
+
+eggs_nested, *_ = spam_N(1)
+eggs_closure, *_ = spam_C(1)
+eggs_nested_N, *_ = spam_NN(1)
+eggs_nested_C, *_ = spam_NC(1)
+eggs_closure_N, *_ = spam_CN(1)
+eggs_closure_C, *_ = spam_CC(1)
+
+ham_nested, *_ = eggs_nested_N(2)
+ham_closure, *_ = eggs_nested_C(2)
+ham_C_nested, *_ = eggs_closure_N(2)
+ham_C_closure, *_ = eggs_closure_C(2)
+
+
+TOP_FUNCTIONS = [
+    # shallow
+    simple_script,
+    complex_script,
+    script_with_globals,
+    script_with_explicit_empty_return,
+    script_with_return,
+    spam_minimal,
+    spam_with_builtins,
+    spam_with_globals_and_builtins,
+    spam_with_global_and_attr_same_name,
+    spam_full_args,
+    spam_full_args_with_defaults,
+    spam_args_attrs_and_builtins,
+    spam_returns_arg,
+    spam_raises,
+    spam_with_inner_not_closure,
+    spam_with_inner_closure,
+    spam_annotated,
+    spam_full,
+    spam,
+    # outer func
+    spam_N,
+    spam_C,
+    spam_NN,
+    spam_NC,
+    spam_CN,
+    spam_CC,
+]
+NESTED_FUNCTIONS = [
+    # inner func
+    eggs_nested,
+    eggs_closure,
+    eggs_nested_N,
+    eggs_nested_C,
+    eggs_closure_N,
+    eggs_closure_C,
+    # inner inner func
+    ham_nested,
+    ham_closure,
+    ham_C_nested,
+    ham_C_closure,
+]
+FUNCTIONS = [
+    *TOP_FUNCTIONS,
+    *NESTED_FUNCTIONS,
+]
+
+STATELESS_FUNCTIONS = [
+    simple_script,
+    complex_script,
+    script_with_explicit_empty_return,
+    script_with_return,
+    spam,
+    spam_minimal,
+    spam_with_builtins,
+    spam_full_args,
+    spam_args_attrs_and_builtins,
+    spam_returns_arg,
+    spam_raises,
+    spam_annotated,
+    spam_with_inner_not_closure,
+    spam_with_inner_closure,
+    spam_N,
+    spam_C,
+    spam_NN,
+    spam_NC,
+    spam_CN,
+    spam_CC,
+    eggs_nested,
+    eggs_nested_N,
+    ham_nested,
+    ham_C_nested
+]
+STATELESS_CODE = [
+    *STATELESS_FUNCTIONS,
+    script_with_globals,
+    spam_full_args_with_defaults,
+    spam_with_globals_and_builtins,
+    spam_with_global_and_attr_same_name,
+    spam_full,
+]
+
+PURE_SCRIPT_FUNCTIONS = [
+    simple_script,
+    complex_script,
+    script_with_explicit_empty_return,
+    spam_minimal,
+    spam_with_builtins,
+    spam_raises,
+    spam_with_inner_not_closure,
+    spam_with_inner_closure,
+]
+SCRIPT_FUNCTIONS = [
+    *PURE_SCRIPT_FUNCTIONS,
+    script_with_globals,
+    spam_with_globals_and_builtins,
+    spam_with_global_and_attr_same_name,
+]
+
+
+# generators
+
+def gen_spam_1(*args):
+     for arg in args:
+         yield arg
+
+
+def gen_spam_2(*args):
+    yield from args
+
+
+async def async_spam():
+    pass
+coro_spam = async_spam()
+coro_spam.close()
+
+
+async def asyncgen_spam(*args):
+    for arg in args:
+        yield arg
+asynccoro_spam = asyncgen_spam(1, 2, 3)
+
+
+FUNCTION_LIKE = [
+    gen_spam_1,
+    gen_spam_2,
+    async_spam,
+    asyncgen_spam,
+]
+FUNCTION_LIKE_APPLIED = [
+    coro_spam,  # actually FunctionType?
+    asynccoro_spam,  # actually FunctionType?
+]
diff --git a/Lib/test/_test_atexit.py b/Lib/test/_test_atexit.py
index 55d28083349..2e961d6a485 100644
--- a/Lib/test/_test_atexit.py
+++ b/Lib/test/_test_atexit.py
@@ -19,7 +19,9 @@ def assert_raises_unraisable(self, exc_type, func, *args):
             atexit.register(func, *args)
             atexit._run_exitfuncs()
 
-            self.assertEqual(cm.unraisable.object, func)
+            self.assertIsNone(cm.unraisable.object)
+            self.assertEqual(cm.unraisable.err_msg,
+                    f'Exception ignored in atexit callback {func!r}')
             self.assertEqual(cm.unraisable.exc_type, exc_type)
             self.assertEqual(type(cm.unraisable.exc_value), exc_type)
 
@@ -125,12 +127,61 @@ def func():
         try:
             with support.catch_unraisable_exception() as cm:
                 atexit._run_exitfuncs()
-                self.assertEqual(cm.unraisable.object, func)
+                self.assertIsNone(cm.unraisable.object)
+                self.assertEqual(cm.unraisable.err_msg,
+                        f'Exception ignored in atexit callback {func!r}')
                 self.assertEqual(cm.unraisable.exc_type, ZeroDivisionError)
                 self.assertEqual(type(cm.unraisable.exc_value), ZeroDivisionError)
         finally:
             atexit.unregister(func)
 
+    def test_eq_unregister_clear(self):
+        # Issue #112127: callback's __eq__ may call unregister or _clear
+        class Evil:
+            def __eq__(self, other):
+                action(other)
+                return NotImplemented
+
+        for action in atexit.unregister, lambda o: atexit._clear():
+            with self.subTest(action=action):
+                atexit.register(lambda: None)
+                atexit.unregister(Evil())
+                atexit._clear()
+
+    def test_eq_unregister(self):
+        # Issue #112127: callback's __eq__ may call unregister
+        def f1():
+            log.append(1)
+        def f2():
+            log.append(2)
+        def f3():
+            log.append(3)
+
+        class Pred:
+            def __eq__(self, other):
+                nonlocal cnt
+                cnt += 1
+                if cnt == when:
+                    atexit.unregister(what)
+                if other is f2:
+                    return True
+                return False
+
+        for what, expected in (
+                (f1, [3]),
+                (f2, [3, 1]),
+                (f3, [1]),
+            ):
+            for when in range(1, 4):
+                with self.subTest(what=what.__name__, when=when):
+                    cnt = 0
+                    log = []
+                    for f in (f1, f2, f3):
+                        atexit.register(f)
+                    atexit.unregister(Pred())
+                    atexit._run_exitfuncs()
+                    self.assertEqual(log, expected)
+
 
 if __name__ == "__main__":
     unittest.main()
diff --git a/Lib/test/_test_eintr.py b/Lib/test/_test_eintr.py
index c8f04e9625c..b462f67b9c9 100644
--- a/Lib/test/_test_eintr.py
+++ b/Lib/test/_test_eintr.py
@@ -91,7 +91,7 @@ class OSEINTRTest(EINTRBaseTest):
     """ EINTR tests for the os module. """
 
     def new_sleep_process(self):
-        code = 'import time; time.sleep(%r)' % self.sleep_time
+        code = f'import time; time.sleep({self.sleep_time!r})'
         return self.subprocess(code)
 
     def _test_wait_multiple(self, wait_func):
@@ -123,36 +123,46 @@ def test_waitpid(self):
     def test_wait4(self):
         self._test_wait_single(lambda pid: os.wait4(pid, 0))
 
-    def test_read(self):
+    def _interrupted_reads(self):
+        """Make a fd which will force block on read of expected bytes."""
         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"]
+        data = [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,
+            f'data = {data!r}',
+            f'sleep_time = {self.sleep_time!r}',
             '',
-            'for data in datas:',
+            'for item in data:',
             '    # let the parent block on read()',
             '    time.sleep(sleep_time)',
-            '    os.write(wr, data)',
+            '    os.write(wr, item)',
         ))
 
         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)))
+            for datum in data:
+                yield rd, datum
             self.assertEqual(proc.wait(), 0)
 
-    @unittest.expectedFailure  # TODO: RUSTPYTHON InterruptedError: [Errno 4] Interrupted system call
+    def test_read(self):
+        for fd, expected in self._interrupted_reads():
+            self.assertEqual(expected, os.read(fd, len(expected)))
+
+    def test_readinto(self):
+        for fd, expected in self._interrupted_reads():
+            buffer = bytearray(len(expected))
+            self.assertEqual(os.readinto(fd, buffer), len(expected))
+            self.assertEqual(buffer, expected)
+
     def test_write(self):
         rd, wr = os.pipe()
         self.addCleanup(os.close, wr)
@@ -165,8 +175,8 @@ def test_write(self):
             'import io, os, sys, time',
             '',
             'rd = int(sys.argv[1])',
-            'sleep_time = %r' % self.sleep_time,
-            'data = b"x" * %s' % support.PIPE_MAX_SIZE,
+            f'sleep_time = {self.sleep_time!r}',
+            f'data = b"x" * {support.PIPE_MAX_SIZE}',
             'data_len = len(data)',
             '',
             '# let the parent block on write()',
@@ -179,8 +189,8 @@ def test_write(self):
             '',
             'value = read_data.getvalue()',
             'if value != data:',
-            '    raise Exception("read error: %s vs %s bytes"',
-            '                    % (len(value), data_len))',
+            '    raise Exception(f"read error: {len(value)}'
+                                  ' vs {data_len} bytes")',
         ))
 
         proc = self.subprocess(code, str(rd), pass_fds=[rd])
@@ -203,33 +213,33 @@ def _test_recv(self, recv_func):
         # wr closed explicitly by parent
 
         # single-byte payload guard us against partial recv
-        datas = [b"x", b"y", b"z"]
+        data = [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,
+            f'family = {int(wr.family)}',
+            f'sock_type = {int(wr.type)}',
+            f'data = {data!r}',
+            f'sleep_time = {self.sleep_time!r}',
             '',
             'wr = socket.fromfd(fd, family, sock_type)',
             'os.close(fd)',
             '',
             'with wr:',
-            '    for data in datas:',
+            '    for item in data:',
             '        # let the parent block on recv()',
             '        time.sleep(sleep_time)',
-            '        wr.sendall(data)',
+            '        wr.sendall(item)',
         ))
 
         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)))
+            for item in data:
+                self.assertEqual(item, recv_func(rd, len(item)))
             self.assertEqual(proc.wait(), 0)
 
     def test_recv(self):
@@ -251,10 +261,10 @@ def _test_send(self, send_func):
             '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),
+            f'family = {int(rd.family)}',
+            f'sock_type = {int(rd.type)}',
+            f'sleep_time = {self.sleep_time!r}',
+            f'data = b"xyz" * {support.SOCK_MAX_SIZE // 3}',
             'data_len = len(data)',
             '',
             'rd = socket.fromfd(fd, family, sock_type)',
@@ -270,8 +280,8 @@ def _test_send(self, send_func):
             '        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))',
+            '    raise Exception(f"recv error: {len(received_data)}'
+                                  ' vs {data_len} bytes")',
         ))
 
         fd = rd.fileno()
@@ -303,9 +313,9 @@ def test_accept(self):
         code = '\n'.join((
             'import socket, time',
             '',
-            'host = %r' % socket_helper.HOST,
-            'port = %s' % port,
-            'sleep_time = %r' % self.sleep_time,
+            f'host = {socket_helper.HOST!r}',
+            f'port = {port}',
+            f'sleep_time = {self.sleep_time!r}',
             '',
             '# let parent block on accept()',
             'time.sleep(sleep_time)',
@@ -333,15 +343,15 @@ def _test_open(self, do_open_close_reader, do_open_close_writer):
         os_helper.unlink(filename)
         try:
             os.mkfifo(filename)
-        except PermissionError as e:
-            self.skipTest('os.mkfifo(): %s' % e)
+        except PermissionError as exc:
+            self.skipTest(f'os.mkfifo(): {exc!r}')
         self.addCleanup(os_helper.unlink, filename)
 
         code = '\n'.join((
             'import os, time',
             '',
-            'path = %a' % filename,
-            'sleep_time = %r' % self.sleep_time,
+            f'path = {filename!a}',
+            f'sleep_time = {self.sleep_time!r}',
             '',
             '# let the parent block',
             'time.sleep(sleep_time)',
@@ -381,7 +391,6 @@ 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)
@@ -400,21 +409,20 @@ class SignalEINTRTest(EINTRBaseTest):
 
     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,
+            f'pid = {os.getpid()}',
+            f'signum = {int(signum)}',
+            f'sleep_time = {self.sleep_time!r}',
             'time.sleep(sleep_time)',
             'os.kill(pid, signum)',
         ))
 
-        old_mask = signal.pthread_sigmask(signal.SIG_BLOCK, [signum])
+        signal.pthread_sigmask(signal.SIG_BLOCK, [signum])
         self.addCleanup(signal.pthread_sigmask, signal.SIG_UNBLOCK, [signum])
 
         proc = self.subprocess(code)
@@ -452,7 +460,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.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')
@@ -534,14 +542,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.expectedFailure  # TODO: RUSTPYTHON; InterruptedError: [Errno 4] Interrupted system call
     @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
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; InterruptedError: [Errno 4] Interrupted system call
     def test_flock(self):
         self._lock(fcntl.flock, "flock")
 
diff --git a/Lib/test/_test_gc_fast_cycles.py b/Lib/test/_test_gc_fast_cycles.py
new file mode 100644
index 00000000000..4e2c7d72a02
--- /dev/null
+++ b/Lib/test/_test_gc_fast_cycles.py
@@ -0,0 +1,48 @@
+# Run by test_gc.
+from test import support
+import _testinternalcapi
+import gc
+import unittest
+
+class IncrementalGCTests(unittest.TestCase):
+
+    # Use small increments to emulate longer running process in a shorter time
+    @support.gc_threshold(200, 10)
+    def test_incremental_gc_handles_fast_cycle_creation(self):
+
+        class LinkedList:
+
+            #Use slots to reduce number of implicit objects
+            __slots__ = "next", "prev", "surprise"
+
+            def __init__(self, next=None, prev=None):
+                self.next = next
+                if next is not None:
+                    next.prev = self
+                self.prev = prev
+                if prev is not None:
+                    prev.next = self
+
+        def make_ll(depth):
+            head = LinkedList()
+            for i in range(depth):
+                head = LinkedList(head, head.prev)
+            return head
+
+        head = make_ll(1000)
+
+        assert(gc.isenabled())
+        olds = []
+        initial_heap_size = _testinternalcapi.get_tracked_heap_size()
+        for i in range(20_000):
+            newhead = make_ll(20)
+            newhead.surprise = head
+            olds.append(newhead)
+            if len(olds) == 20:
+                new_objects = _testinternalcapi.get_tracked_heap_size() - initial_heap_size
+                self.assertLess(new_objects, 27_000, f"Heap growing. Reached limit after {i} iterations")
+                del olds[:]
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/Lib/test/_test_multiprocessing.py b/Lib/test/_test_multiprocessing.py
index 0855e384f24..a009cb8cadd 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 timeout")
+    @unittest.skip("TODO: RUSTPYTHON; flaky timeout - thread start latency")
     def test_repr_rlock(self):
         if self.TYPE != 'processes':
             self.skipTest('test not appropriate for {}'.format(self.TYPE))
@@ -4057,8 +4057,6 @@ 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).
@@ -4417,7 +4415,6 @@ 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
@@ -4816,8 +4813,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
+    # TODO: RUSTPYTHON; SIGSEGV due to dict thread-safety issue under aggressive GC
+    @unittest.skip("TODO: RUSTPYTHON")
     @support.requires_resource('cpu')
     def test_thread_safety(self):
         # bpo-24484: _run_finalizers() should be thread-safe
@@ -5445,8 +5442,6 @@ 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
@@ -6592,7 +6587,8 @@ def tearDownClass(cls):
         # cycles. Trigger a garbage collection to break these cycles.
         test.support.gc_collect()
 
-        processes = set(multiprocessing.process._dangling) - set(cls.dangling[0])
+        # TODO: RUSTPYTHON: Filter out stopped processes since gc.collect() is a no-op
+        processes = {p for p in multiprocessing.process._dangling if p.is_alive()} - {p for p in cls.dangling[0] if p.is_alive()}
         if processes:
             test.support.environment_altered = True
             support.print_warning(f'Dangling processes: {processes}')
@@ -6789,7 +6785,8 @@ def tearDownModule():
 
         multiprocessing.set_start_method(old_start_method[0], force=True)
         # pause a bit so we don't get warning about dangling threads/processes
-        processes = set(multiprocessing.process._dangling) - set(dangling[0])
+        # TODO: RUSTPYTHON: Filter out stopped processes since gc.collect() is a no-op
+        processes = {p for p in multiprocessing.process._dangling if p.is_alive()} - {p for p in dangling[0] if p.is_alive()}
         if processes:
             need_sleep = True
             test.support.environment_altered = True
diff --git a/Lib/test/audiodata/pluck-alaw.aifc b/Lib/test/audiodata/pluck-alaw.aifc
deleted file mode 100644
index 3b7fbd2af75..00000000000
Binary files a/Lib/test/audiodata/pluck-alaw.aifc and /dev/null differ
diff --git a/Lib/test/audiodata/pluck-pcm16.aiff b/Lib/test/audiodata/pluck-pcm16.aiff
deleted file mode 100644
index 6c8c40d1409..00000000000
Binary files a/Lib/test/audiodata/pluck-pcm16.aiff and /dev/null differ
diff --git a/Lib/test/audiodata/pluck-pcm16.au b/Lib/test/audiodata/pluck-pcm16.au
deleted file mode 100644
index 398f07f0719..00000000000
Binary files a/Lib/test/audiodata/pluck-pcm16.au and /dev/null differ
diff --git a/Lib/test/audiodata/pluck-pcm24.aiff b/Lib/test/audiodata/pluck-pcm24.aiff
deleted file mode 100644
index 8eba145a44d..00000000000
Binary files a/Lib/test/audiodata/pluck-pcm24.aiff and /dev/null differ
diff --git a/Lib/test/audiodata/pluck-pcm24.au b/Lib/test/audiodata/pluck-pcm24.au
deleted file mode 100644
index 0bb230418a3..00000000000
Binary files a/Lib/test/audiodata/pluck-pcm24.au and /dev/null differ
diff --git a/Lib/test/audiodata/pluck-pcm32.aiff b/Lib/test/audiodata/pluck-pcm32.aiff
deleted file mode 100644
index 46ac0373f6a..00000000000
Binary files a/Lib/test/audiodata/pluck-pcm32.aiff and /dev/null differ
diff --git a/Lib/test/audiodata/pluck-pcm32.au b/Lib/test/audiodata/pluck-pcm32.au
deleted file mode 100644
index 92ee5965e40..00000000000
Binary files a/Lib/test/audiodata/pluck-pcm32.au and /dev/null differ
diff --git a/Lib/test/audiodata/pluck-pcm8.aiff b/Lib/test/audiodata/pluck-pcm8.aiff
deleted file mode 100644
index 5de4f3b2d87..00000000000
Binary files a/Lib/test/audiodata/pluck-pcm8.aiff and /dev/null differ
diff --git a/Lib/test/audiodata/pluck-pcm8.au b/Lib/test/audiodata/pluck-pcm8.au
deleted file mode 100644
index b7172c8f234..00000000000
Binary files a/Lib/test/audiodata/pluck-pcm8.au and /dev/null differ
diff --git a/Lib/test/audiodata/pluck-ulaw.aifc b/Lib/test/audiodata/pluck-ulaw.aifc
deleted file mode 100644
index 3085cf097fb..00000000000
Binary files a/Lib/test/audiodata/pluck-ulaw.aifc and /dev/null differ
diff --git a/Lib/test/audiodata/pluck-ulaw.au b/Lib/test/audiodata/pluck-ulaw.au
deleted file mode 100644
index 11103535c6b..00000000000
Binary files a/Lib/test/audiodata/pluck-ulaw.au and /dev/null differ
diff --git a/Lib/test/certdata/allsans.pem b/Lib/test/certdata/allsans.pem
index 02f2c2e6346..f6a63b9219d 100644
--- a/Lib/test/certdata/allsans.pem
+++ b/Lib/test/certdata/allsans.pem
@@ -1,42 +1,42 @@
 -----BEGIN PRIVATE KEY-----
-MIIG/QIBADANBgkqhkiG9w0BAQEFAASCBucwggbjAgEAAoIBgQCczEVv5D2UDtn6
-DMmZ/uCWCLyL+K5xTZp/5j3cyISoaTuU1Ku3kD97eLgpHj4Fgk5ZJi21zsQqepCj
-jAhBk6tj6RYUcnMbb8MuxUkQMEDW+5LfSyp+HCaetlHosWdhEDqX4kpJ5ajBwNRt
-07mxQExtC4kcno0ut9rG5XzLN29XpCpRHlFFrntOgQAEoiz9/fc8qaTgb37RgGYP
-Qsxh7PcRDRe4ZGx1l06Irr8Y+2W50zWCfkwCS3DaLDOKIjSOfPHNqmfcfsTpzrj8
-330cdPklrMIuiBv+iGklCjkPZJiEhxvY2k6ERM4HAxxuPCivrH5MCeMNYvBVUcLr
-GROm7JRXRllI/XubwwoAaAb+y+dZtCZ9AnzHIb+nyKiJxWAjzjR+QPL6jHrVWBVA
-WTc83YP5FvxUXMfY3sVv9tNSCV3cpYOW5+iXcQzLuczXnOLRYk7p9wkb0/hk9KuK
-4BMA90eBhvFMCFgHJ1/xJg2nFmBHPo/xbcwPG/ma5T/McA8mAlECAwEAAQKCAYAB
-m29nxPNjod5Wm4xydWQYbZj/J0qkcyru/i1qpqyDbGa1sRNcg5A/A/8BPuPcWxhR
-/hvwVeD5XX2/i2cnQuv6D3DQP1cSNCxQPanwzknP2k7IVqUmG0RDErPWuoDIhCnR
-ljp0NPQsnj0fLhEkcbgG0xwx7KceUDigGsiTbatIvvBHGhQzrmTpqlVVdtMWvGRt
-HQEJYuMuIw6IwALHyy3CITv5wh/Bec5OhNoFF8iUZceR4ZkGWf8bYWIa25xlzH6K
-4rhOOh1G2ObHHTjhZq4mGXTHY1MEkAxXKWlR3DJc0Lh5E1UETSI6WBHWRb08iwQ5
-AkLOPyMpt08xHFWbJqywvlxenpri+gjY3xbXqGNhyDYWHZqlQmJVnzxoUOuuHi2R
-dO86IckUc4Thjbm7a6AilL9t8juNZvyeQUVgtVi25uPkm/cK6r5vo8y4UOUU41EN
-NOathlF69gh93il4t6zJW9jPV2WENv1H/vhKUWKW6cabX3vy4rANwy3q4V//GDEC
-gcEAuniGCHaEdSjV2sUHyt/yrCLbU6+eLTfNk6AQyXJk6Wrvj6g3gx90ewEq5i/C
-ukmSKDslr9pupq8Z/UNfYHZfJfpwEsYvIZ8DdFSd62/h66DhIoEn1v3Lwt+aexgX
-yGJHF0BG9JA2CU5Z5NGjlnQYqQBobO9uZMq62l15Ig1MAMHGL0ZYVvOqGZD7XvtC
-4UnclK5kjp51Vd5rydEQxyi5qkyLl9Q6T0FQXOphGIOd8ifYeUGe7YC72cFPevdx
-wDXZAoHBANdDVvCMrjmzdrS6td39/2nHTeerFPbsOe2LIQYzqjeEe6GWqd2NL9NZ
-bk3/cAuVgbWtdvSQQhhmSqOC7JZic4hbZb3lK6v/sr4F/Zu0CfAu80swWFMeS7vq
-eQeYzN4w4dKpJArvU3ll7N9AlZhdlYkbPf0WdeOIjZawdAOxNtNe0O+j+5MsXR59
-qkULatumhcKUnqxFCiVHzy21CVJtRzrtu6oGoSdFbmG82eSJ1rPXiuuDnCyzjyMW
-iClYRM4NOQKBwERnO/vUxihYT4LOLlqcpl/A9aYQUT0TMGWMHTxYq2343WJceeiu
-3ELXHc6NDKjbnjMF54BH57lbmHQQh+dR5PuAkCZC7z0tIM5G0Bty0nRmcs/+gwfZ
-2Cpnbjrjjq3iZ2O/H4hNcpUdWdqXkKP7eKReUvBLMLrmp369NVdpe0z3yGTFMFjN
-T8PLLHsePt14A+PCyX6L4E0cp3vEJpx4cwtmwvpyTuWN9xXuoKmmdoVDWqS4jr1f
-MQnjYO2h4ed5mQKBwGVttWli4DUP+r7tuwP+ynptDqg6VIaEiEcFZ2okre+63QYm
-l6NtAzvyx6a41XKf355bPdG+p2YXzNN+vTue6BE3/5iagxloQjCHYhgbnRMvDDRB
-c1y2ybihoqWRufZ30fARAoqkehCZliMbq2E/t1YDIBJAowuzLAP04LVcqxitdIV2
-HvQZ00aqr7AY0SDuNdiZbqp9XWpzi4td4iaUlxuNKP/UX9rBPGGROpoU2LWkujB+
-svfdI3TFCSNyE/mDAQKBwQCP++WZKxExrSFRk3W+TcHKHZb2pusfoPWE7WH6EnDW
-dkTZpa3PZaf0xgeglmNBv4Paxw2eMPsIhyNv62XY/6GbY6VJWRyx/s+NsazeP4ji
-xUOufnwTePjYw6x0pcl6BknZrHn8LCJU741h0yTum8cDdNfRKdc0AMy0gVXk4ZTG
-2cAtbEcWb3J+a5kYf6mp5yx3BNwtewkGZhc2VuQ9mQNbMmOOS/pHQQTRWcxsQwyt
-GPAhMKawjrL1KFmu7vIqDSw=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 -----END PRIVATE KEY-----
 Certificate:
     Data:
@@ -47,38 +47,38 @@ Certificate:
         Issuer: C=XY, O=Python Software Foundation CA, CN=our-ca-server
         Validity
             Not Before: Aug 29 14:23:16 2018 GMT
-            Not After : Oct 28 14:23:16 2037 GMT
+            Not After : Oct 28 14:23:16 2525 GMT
         Subject: C=XY, L=Castle Anthrax, O=Python Software Foundation, CN=allsans
         Subject Public Key Info:
             Public Key Algorithm: rsaEncryption
                 Public-Key: (3072 bit)
                 Modulus:
-                    00:9c:cc:45:6f:e4:3d:94:0e:d9:fa:0c:c9:99:fe:
-                    e0:96:08:bc:8b:f8:ae:71:4d:9a:7f:e6:3d:dc:c8:
-                    84:a8:69:3b:94:d4:ab:b7:90:3f:7b:78:b8:29:1e:
-                    3e:05:82:4e:59:26:2d:b5:ce:c4:2a:7a:90:a3:8c:
-                    08:41:93:ab:63:e9:16:14:72:73:1b:6f:c3:2e:c5:
-                    49:10:30:40:d6:fb:92:df:4b:2a:7e:1c:26:9e:b6:
-                    51:e8:b1:67:61:10:3a:97:e2:4a:49:e5:a8:c1:c0:
-                    d4:6d:d3:b9:b1:40:4c:6d:0b:89:1c:9e:8d:2e:b7:
-                    da:c6:e5:7c:cb:37:6f:57:a4:2a:51:1e:51:45:ae:
-                    7b:4e:81:00:04:a2:2c:fd:fd:f7:3c:a9:a4:e0:6f:
-                    7e:d1:80:66:0f:42:cc:61:ec:f7:11:0d:17:b8:64:
-                    6c:75:97:4e:88:ae:bf:18:fb:65:b9:d3:35:82:7e:
-                    4c:02:4b:70:da:2c:33:8a:22:34:8e:7c:f1:cd:aa:
-                    67:dc:7e:c4:e9:ce:b8:fc:df:7d:1c:74:f9:25:ac:
-                    c2:2e:88:1b:fe:88:69:25:0a:39:0f:64:98:84:87:
-                    1b:d8:da:4e:84:44:ce:07:03:1c:6e:3c:28:af:ac:
-                    7e:4c:09:e3:0d:62:f0:55:51:c2:eb:19:13:a6:ec:
-                    94:57:46:59:48:fd:7b:9b:c3:0a:00:68:06:fe:cb:
-                    e7:59:b4:26:7d:02:7c:c7:21:bf:a7:c8:a8:89:c5:
-                    60:23:ce:34:7e:40:f2:fa:8c:7a:d5:58:15:40:59:
-                    37:3c:dd:83:f9:16:fc:54:5c:c7:d8:de:c5:6f:f6:
-                    d3:52:09:5d:dc:a5:83:96:e7:e8:97:71:0c:cb:b9:
-                    cc:d7:9c:e2:d1:62:4e:e9:f7:09:1b:d3:f8:64:f4:
-                    ab:8a:e0:13:00:f7:47:81:86:f1:4c:08:58:07:27:
-                    5f:f1:26:0d:a7:16:60:47:3e:8f:f1:6d:cc:0f:1b:
-                    f9:9a:e5:3f:cc:70:0f:26:02:51
+                    00:98:11:8f:a5:23:04:bf:c3:e8:00:53:93:df:c5:
+                    27:8b:e2:a3:05:e5:3b:45:92:b8:9f:2f:4a:10:68:
+                    28:d6:15:bf:23:79:7d:91:6f:5b:4a:68:e6:f2:ad:
+                    89:93:51:15:56:6c:c9:08:d4:b2:4e:41:66:2d:1a:
+                    50:0d:a3:69:af:7f:85:43:d7:06:59:ff:1f:d3:9b:
+                    29:71:7b:70:3b:8a:d4:93:66:06:6e:19:72:c7:b4:
+                    53:fd:c2:4e:f2:4b:8e:81:95:57:0d:ab:76:68:3a:
+                    2e:e4:93:c3:71:4e:25:2a:82:c9:8b:83:73:63:f8:
+                    87:e4:f0:e2:3b:73:50:5c:3f:6a:5a:d7:06:4e:fe:
+                    5d:cf:4d:6a:ad:15:22:ec:14:4b:ce:2b:93:7a:64:
+                    fa:88:2c:05:22:e6:f1:24:3a:21:5e:7f:15:47:1e:
+                    f0:f8:37:72:16:48:58:12:c2:20:e2:f4:a8:67:b5:
+                    d4:70:6b:e6:b1:b1:9c:63:ab:fa:3b:d0:58:d0:3b:
+                    9a:b9:42:ec:a6:f5:a0:ea:aa:8e:3b:3c:cc:a4:11:
+                    bd:60:75:30:50:2b:59:8f:96:23:0a:b0:b8:b9:cf:
+                    27:08:ff:2a:66:d4:f1:1c:1f:9d:fe:f7:f1:7e:53:
+                    60:75:6e:6b:c0:ff:d3:c1:c7:c4:fb:85:4c:9c:94:
+                    16:d0:1c:29:9d:71:72:18:0a:01:6b:e4:06:c6:4b:
+                    78:c5:79:53:e2:17:b8:42:3e:3d:64:fe:37:29:6b:
+                    25:d9:02:d5:a6:a8:94:e5:91:72:86:6c:ce:bc:02:
+                    03:3f:0c:73:b4:7c:60:98:19:15:30:da:f8:55:dd:
+                    92:11:0a:6d:01:ab:07:e8:ad:e1:61:fb:6a:0c:c9:
+                    98:c3:8e:fa:3f:b9:98:d9:35:ac:dd:a5:cc:2f:3b:
+                    2d:1c:94:59:0e:47:05:48:d3:34:c8:8b:15:d8:49:
+                    5e:31:37:50:57:f3:6d:49:0a:e8:58:b9:ba:e8:f3:
+                    d9:be:31:28:f1:3b:5e:2a:82:cd
                 Exponent: 65537 (0x10001)
         X509v3 extensions:
             X509v3 Subject Alternative Name: 
@@ -90,9 +90,9 @@ Certificate:
             X509v3 Basic Constraints: critical
                 CA:FALSE
             X509v3 Subject Key Identifier: 
-                31:5E:C0:5E:2F:47:FF:8B:92:F9:EE:3D:B1:87:D0:53:75:3B:B1:48
+                73:0D:4E:1F:4A:EC:F2:53:0F:53:FC:85:6F:CF:82:CD:A3:E8:11:8D
             X509v3 Authority Key Identifier: 
-                keyid:F3:EC:94:8E:F2:8E:30:C4:8E:68:C2:BF:8E:6A:19:C0:C1:9F:76:65
+                keyid:C0:0A:2B:28:43:DE:5F:C9:7D:47:E5:47:9B:36:F2:65:8C:67:3B:E2
                 DirName:/C=XY/O=Python Software Foundation CA/CN=our-ca-server
                 serial:CB:2D:80:99:5A:69:52:5B
             Authority Information Access: 
@@ -103,65 +103,65 @@ Certificate:
                   URI:http://testca.pythontest.net/testca/revocation.crl
     Signature Algorithm: sha256WithRSAEncryption
     Signature Value:
-        72:42:a6:fc:ee:3c:21:47:05:33:e8:8c:6b:27:07:4a:ed:e2:
-        81:47:96:79:43:ff:0f:ef:5a:06:aa:4c:01:70:5b:21:c4:b7:
-        5d:17:29:c8:10:02:c3:08:7b:8c:86:56:9e:e9:7c:6e:a8:b6:
-        26:13:9e:1e:1f:93:66:85:67:63:9e:08:fb:55:39:56:82:f5:
-        be:0c:38:1e:eb:c4:54:b2:a7:7b:18:55:bb:00:87:43:50:50:
-        bb:e1:29:10:cf:3d:c9:07:c7:d2:5d:b6:45:68:1f:d6:de:00:
-        96:3e:29:73:f6:22:70:21:a2:ba:68:28:94:ec:37:bc:a7:00:
-        70:58:4e:d1:48:ae:ef:8d:11:a4:6e:10:2f:92:83:07:e2:76:
-        ac:bf:4f:bb:d6:9f:47:9e:a4:02:03:16:f8:a8:0a:3d:67:17:
-        31:44:0e:68:d0:d3:24:d5:e7:bf:67:30:8f:88:97:92:0a:1e:
-        d7:74:df:7e:7b:4c:c6:d9:c3:84:92:2b:a0:89:11:08:4c:dd:
-        32:49:df:36:23:d4:63:56:e4:f1:68:5a:6f:a0:c3:3c:e2:36:
-        ee:f3:46:60:78:4d:76:a5:5a:4a:61:c6:f8:ae:18:68:c2:8d:
-        0e:2f:76:50:bb:be:b9:56:f1:04:5c:ac:ad:d7:d6:a4:1e:45:
-        45:52:f4:10:a2:0f:9b:e3:d9:73:17:b6:52:42:a6:5b:c9:e9:
-        8d:60:74:68:d0:1f:7a:ce:01:8e:9e:55:cb:cf:64:c1:cc:9a:
-        72:aa:b4:5f:b5:55:13:41:10:51:a0:2c:a5:5b:43:12:ca:cc:
-        b7:c4:ac:f2:6f:72:fd:0d:50:6a:d6:81:c1:91:93:21:fe:de:
-        9a:be:e5:3c:2a:98:95:a1:42:f8:f2:5c:75:c6:f1:fd:11:b1:
-        22:26:33:5b:43:63:21:06:61:d2:cd:04:f3:30:c6:a8:3f:17:
-        d3:05:a3:87:45:2e:52:1e:51:88:e3:59:4c:78:51:b0:7b:b4:
-        58:d9:27:22:6e:8c
+        a5:3d:12:87:b9:3b:3e:9c:1c:59:fb:d5:38:22:49:61:f3:c3:
+        11:53:4b:4e:63:af:f2:3d:ef:24:67:45:bc:74:5c:4a:65:c5:
+        b4:bb:fe:84:b8:b6:ca:7d:fc:aa:ff:80:ae:67:1f:cb:c3:cd:
+        8f:f9:75:8c:f9:d3:3f:db:f6:81:d8:06:42:c3:5d:a9:1e:a3:
+        81:7d:57:ac:97:d9:bd:c8:ce:1e:ec:74:d7:94:d5:df:b1:ad:
+        ce:84:14:5c:8c:45:a4:a8:eb:67:ab:16:57:61:15:86:ae:11:
+        1e:b5:10:42:de:84:76:88:9b:37:12:aa:a6:77:42:75:b4:c0:
+        04:b3:75:45:e0:d7:aa:34:e3:07:c5:ed:f8:4e:f0:39:99:1f:
+        5b:d8:4e:0c:ad:64:6d:09:07:3f:e3:e1:9f:1b:65:07:96:59:
+        9a:b5:f1:4d:c3:ec:f7:32:a1:05:94:d1:0b:18:54:3c:67:cf:
+        38:f5:2b:ec:cb:bd:79:be:f7:1b:b7:71:3f:c6:44:80:7f:00:
+        dc:3d:a0:07:c0:b5:1c:fb:52:f6:a0:f8:92:c6:c6:73:07:c5:
+        ca:0b:04:7c:55:51:e3:ba:93:32:17:bd:61:ae:cf:13:e4:5e:
+        03:b2:51:11:c7:68:f5:08:b6:0e:57:49:11:3c:e3:f4:0e:e1:
+        96:20:44:28:31:94:11:44:50:cf:17:70:8d:9c:14:c5:ed:94:
+        4d:ba:94:9b:db:8b:9f:55:a1:5e:0a:90:bb:a0:0e:0d:3b:a0:
+        dd:4d:47:d1:cf:d0:47:6b:ff:6f:af:e4:83:40:73:e6:3a:59:
+        40:bd:4f:3a:21:22:63:27:5d:02:26:67:89:1d:2f:19:c5:77:
+        e6:b5:67:4a:dd:b5:0e:de:46:34:57:c7:03:84:5d:cd:34:08:
+        8f:47:c9:4d:7f:04:c0:4f:ff:68:52:bb:ae:84:0e:54:ce:5c:
+        27:71:0f:a2:3f:9f:7a:49:a8:fa:0a:45:cf:96:42:a7:65:23:
+        b9:3e:40:eb:46:7b
 -----BEGIN CERTIFICATE-----
-MIIHDTCCBXWgAwIBAgIJAMstgJlaaVJfMA0GCSqGSIb3DQEBCwUAME0xCzAJBgNV
+MIIHDzCCBXegAwIBAgIJAMstgJlaaVJfMA0GCSqGSIb3DQEBCwUAME0xCzAJBgNV
 BAYTAlhZMSYwJAYDVQQKDB1QeXRob24gU29mdHdhcmUgRm91bmRhdGlvbiBDQTEW
-MBQGA1UEAwwNb3VyLWNhLXNlcnZlcjAeFw0xODA4MjkxNDIzMTZaFw0zNzEwMjgx
-NDIzMTZaMF0xCzAJBgNVBAYTAlhZMRcwFQYDVQQHDA5DYXN0bGUgQW50aHJheDEj
-MCEGA1UECgwaUHl0aG9uIFNvZnR3YXJlIEZvdW5kYXRpb24xEDAOBgNVBAMMB2Fs
-bHNhbnMwggGiMA0GCSqGSIb3DQEBAQUAA4IBjwAwggGKAoIBgQCczEVv5D2UDtn6
-DMmZ/uCWCLyL+K5xTZp/5j3cyISoaTuU1Ku3kD97eLgpHj4Fgk5ZJi21zsQqepCj
-jAhBk6tj6RYUcnMbb8MuxUkQMEDW+5LfSyp+HCaetlHosWdhEDqX4kpJ5ajBwNRt
-07mxQExtC4kcno0ut9rG5XzLN29XpCpRHlFFrntOgQAEoiz9/fc8qaTgb37RgGYP
-Qsxh7PcRDRe4ZGx1l06Irr8Y+2W50zWCfkwCS3DaLDOKIjSOfPHNqmfcfsTpzrj8
-330cdPklrMIuiBv+iGklCjkPZJiEhxvY2k6ERM4HAxxuPCivrH5MCeMNYvBVUcLr
-GROm7JRXRllI/XubwwoAaAb+y+dZtCZ9AnzHIb+nyKiJxWAjzjR+QPL6jHrVWBVA
-WTc83YP5FvxUXMfY3sVv9tNSCV3cpYOW5+iXcQzLuczXnOLRYk7p9wkb0/hk9KuK
-4BMA90eBhvFMCFgHJ1/xJg2nFmBHPo/xbcwPG/ma5T/McA8mAlECAwEAAaOCAt4w
-ggLaMIIBMAYDVR0RBIIBJzCCASOCB2FsbHNhbnOgHgYDKgMEoBcMFXNvbWUgb3Ro
-ZXIgaWRlbnRpZmllcqA1BgYrBgEFAgKgKzApoBAbDktFUkJFUk9TLlJFQUxNoRUw
-E6ADAgEBoQwwChsIdXNlcm5hbWWBEHVzZXJAZXhhbXBsZS5vcmeCD3d3dy5leGFt
-cGxlLm9yZ6RnMGUxCzAJBgNVBAYTAlhZMRcwFQYDVQQHDA5DYXN0bGUgQW50aHJh
-eDEjMCEGA1UECgwaUHl0aG9uIFNvZnR3YXJlIEZvdW5kYXRpb24xGDAWBgNVBAMM
-D2Rpcm5hbWUgZXhhbXBsZYYXaHR0cHM6Ly93d3cucHl0aG9uLm9yZy+HBH8AAAGH
-EAAAAAAAAAAAAAAAAAAAAAGIBCoDBAUwDgYDVR0PAQH/BAQDAgWgMB0GA1UdJQQW
-MBQGCCsGAQUFBwMBBggrBgEFBQcDAjAMBgNVHRMBAf8EAjAAMB0GA1UdDgQWBBQx
-XsBeL0f/i5L57j2xh9BTdTuxSDB9BgNVHSMEdjB0gBTz7JSO8o4wxI5owr+OahnA
-wZ92ZaFRpE8wTTELMAkGA1UEBhMCWFkxJjAkBgNVBAoMHVB5dGhvbiBTb2Z0d2Fy
-ZSBGb3VuZGF0aW9uIENBMRYwFAYDVQQDDA1vdXItY2Etc2VydmVyggkAyy2AmVpp
-UlswgYMGCCsGAQUFBwEBBHcwdTA8BggrBgEFBQcwAoYwaHR0cDovL3Rlc3RjYS5w
-eXRob250ZXN0Lm5ldC90ZXN0Y2EvcHljYWNlcnQuY2VyMDUGCCsGAQUFBzABhilo
-dHRwOi8vdGVzdGNhLnB5dGhvbnRlc3QubmV0L3Rlc3RjYS9vY3NwLzBDBgNVHR8E
-PDA6MDigNqA0hjJodHRwOi8vdGVzdGNhLnB5dGhvbnRlc3QubmV0L3Rlc3RjYS9y
-ZXZvY2F0aW9uLmNybDANBgkqhkiG9w0BAQsFAAOCAYEAckKm/O48IUcFM+iMaycH
-Su3igUeWeUP/D+9aBqpMAXBbIcS3XRcpyBACwwh7jIZWnul8bqi2JhOeHh+TZoVn
-Y54I+1U5VoL1vgw4HuvEVLKnexhVuwCHQ1BQu+EpEM89yQfH0l22RWgf1t4Alj4p
-c/YicCGiumgolOw3vKcAcFhO0Uiu740RpG4QL5KDB+J2rL9Pu9afR56kAgMW+KgK
-PWcXMUQOaNDTJNXnv2cwj4iXkgoe13TffntMxtnDhJIroIkRCEzdMknfNiPUY1bk
-8Whab6DDPOI27vNGYHhNdqVaSmHG+K4YaMKNDi92ULu+uVbxBFysrdfWpB5FRVL0
-EKIPm+PZcxe2UkKmW8npjWB0aNAfes4Bjp5Vy89kwcyacqq0X7VVE0EQUaAspVtD
-EsrMt8Ss8m9y/Q1QataBwZGTIf7emr7lPCqYlaFC+PJcdcbx/RGxIiYzW0NjIQZh
-0s0E8zDGqD8X0wWjh0UuUh5RiONZTHhRsHu0WNknIm6M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 -----END CERTIFICATE-----
diff --git a/Lib/test/certdata/capath/b1930218.0 b/Lib/test/certdata/capath/b1930218.0
index aa9dbbe294f..6d773ee5b32 100644
--- a/Lib/test/certdata/capath/b1930218.0
+++ b/Lib/test/certdata/capath/b1930218.0
@@ -1,27 +1,27 @@
 -----BEGIN CERTIFICATE-----
-MIIEgDCCAuigAwIBAgIJAMstgJlaaVJbMA0GCSqGSIb3DQEBCwUAME0xCzAJBgNV
+MIIEgjCCAuqgAwIBAgIJAMstgJlaaVJbMA0GCSqGSIb3DQEBCwUAME0xCzAJBgNV
 BAYTAlhZMSYwJAYDVQQKDB1QeXRob24gU29mdHdhcmUgRm91bmRhdGlvbiBDQTEW
-MBQGA1UEAwwNb3VyLWNhLXNlcnZlcjAeFw0xODA4MjkxNDIzMTZaFw0zNzEwMjgx
-NDIzMTZaME0xCzAJBgNVBAYTAlhZMSYwJAYDVQQKDB1QeXRob24gU29mdHdhcmUg
-Rm91bmRhdGlvbiBDQTEWMBQGA1UEAwwNb3VyLWNhLXNlcnZlcjCCAaIwDQYJKoZI
-hvcNAQEBBQADggGPADCCAYoCggGBANCgm7G5O3nuMS+4URwBde0JWUysyL9qCvh6
-CPAl4yV7avjE2KqgYAclsM9zcQVSaL8Gk64QYZa8s2mBGn0Z/CCGj5poG+3N4mxh
-Z8dOVepDBiEb6bm+hF/C2uuJiOBCpkVJKtC5a4yTyUQ7yvw8lH/dcMWt2Es73B74
-VUu1J4b437CDz/cWN78TFzTUyVXtaxbJf60gTvAe2Ru/jbrNypbvHmnLUWZhSA3o
-eaNZYdQQjeANOwuFttWFEt2lB8VL+iP6VDn3lwvJREceVnc8PBMBC2131hS6RPRT
-NVbZPbk+NV/bM5pPWrk4RMkySf5m9h8al6rKTEr2uF5Af/sLHfhbodz4wC7QbUn1
-0kbUkFf+koE0ri04u6gXDOHlP+L3JgVUUPVksxxuRP9vqbQDlukOwojYclKQmcZB
-D0aQWbg+b9Linh02gpXTWIoS8+LYDSBRI/CQLZo+fSaGsqfX+ShgA+N3x4gEyf6J
-d3AQT8Ogijv0q0J74xSS2K4W1qHefQIDAQABo2MwYTAdBgNVHQ4EFgQU8+yUjvKO
-MMSOaMK/jmoZwMGfdmUwHwYDVR0jBBgwFoAU8+yUjvKOMMSOaMK/jmoZwMGfdmUw
-DwYDVR0TAQH/BAUwAwEB/zAOBgNVHQ8BAf8EBAMCAYYwDQYJKoZIhvcNAQELBQAD
-ggGBAIsAVHKzjevzrzSf1mDq3oQ/jASPGaa+AmfEY8V040c3WYOUBvFFGegHL9ZO
-S0+oPccHByeS9H5zT4syGZRGeiXE2cQnsBFjOmCLheFzTzQ7a6Q0jEmOzc9PsmUn
-QRmw/IAxePJzapt9cTRQ/Hio2gW0nFs6mXprXe870+k7MwESZc9eB9gZr9VT6vAQ
-rMS2Jjw0LnTuZN0dNnWJRACwDf0vswHMGosCzWzogILKv4LXAJ3YNhXSBzf8bHMd
-2qgc6CCOMnr+bScW5Fhs6z7w/iRSKXG4lntTS0UgVUBehhvsyUaRku6sk2WRLpS2
-tqzoozSJpBoSDU1EpVLti5HuL6avpJUl+c7HW6cA05PKtDxdTfexPMxttEW+gu0Y
-kMiG0XVRUARM6E/S1lCqdede/6F7Jxkca0ksbE1rY8w7cwDzmSbQgofTqTactD25
-SGiokvAnjgzNFXZChIDJP6N+tN3X+Kx2umCXPFofTt5x7gk5EN0x1WhXXRrlQroO
-aOZF0w==
+MBQGA1UEAwwNb3VyLWNhLXNlcnZlcjAgFw0xODA4MjkxNDIzMTZaGA8yNTI1MTAy
+ODE0MjMxNlowTTELMAkGA1UEBhMCWFkxJjAkBgNVBAoMHVB5dGhvbiBTb2Z0d2Fy
+ZSBGb3VuZGF0aW9uIENBMRYwFAYDVQQDDA1vdXItY2Etc2VydmVyMIIBojANBgkq
+hkiG9w0BAQEFAAOCAY8AMIIBigKCAYEA5rri5MHCDBw+Yti5XFcuUriDxYg65pp6
+9WQWM+s3bi9782gDRWVHXXEQWcorGwBsgRRh9IZZP+r9eDcWnUPxxPZpjMUpBoie
+JiIErATYhzRIOetr8guSqsNuY1FRa8Kt/1zIL7IbnCCKQD6iL2rqyNk3Q1zc7ZLi
+2UDSYZ9xivXtObqoXj61IWMQ2G+04hEBCxDou/ti70hVvPXSnKtorpUlGfKXfRrc
+ZuqIXobky8tpTV6wo/tsMeQoYF6Q8dQuEFDhhfANXL3dRSQIGT4ck2aPK9pTfQQc
+DkLEaF6mzakY7afNatDRhrqQ/7dM3sdDJG3HHGucgefhG1clkKkOyVbz9mteLbQu
+QFCbQmPS1pkcONzPKyyncvHHXmM0dkj0PogTnoYWUy90+4cBjSKkaDPuE2x6BhRU
+VhdXV5g00AtmCeOICfilFRwQc9CIUJleGGU7/zEnG17GqkH9LS8Yp8Dyq8citQtp
+0nPRu9AcPfqkNWLNM4bHoCMPuWrV0m2NAgMBAAGjYzBhMB0GA1UdDgQWBBTACiso
+Q95fyX1H5UebNvJljGc74jAfBgNVHSMEGDAWgBTACisoQ95fyX1H5UebNvJljGc7
+4jAPBgNVHRMBAf8EBTADAQH/MA4GA1UdDwEB/wQEAwIBhjANBgkqhkiG9w0BAQsF
+AAOCAYEAvONWIgPkXLln/5S8dZwAhbDVnMTDKWZei7KppjCGcRpr8gDFgqtfUAQq
+++24TLkAG0lXkhHNorzLD6i0YfgUyqDsQBe6VaHEvKayWu/0IBB3R9CgxVi5bLUQ
+e4VKQ6P7LAG5dxewvqDurq5NZ4ZIiVeGeOo87fBBNY1xaFX58umsMtTGou/sVObE
+jiz9vapgVmUzleoQxnQE6ypumxH2YQCq/ezyC7FLEc2T69+Yrky0BwRK5e//Ulh1
+9T6kceFKclypj9SqiPBqcbTDAF+ZbteRr2yYDWTCJMeeBRFoXiRi4y5F7KM08qOd
+TeUyGC90/BHxNlBPoEApaFxDTCNsXXLE7FJ269yyvB+mxAZmm1zHzMry0SVP3qUf
+jeQMSbbPhUChuR/GxxkVB2M0k9BXoFpw7K9KHHIXHXSjbDFFCzN6obhG28cOZExv
+t5kEgkMf4FnWmSEnKAlArvzEI6qgDAgFKpIc2yOe0dVjrjkToxKIWkM8Sm4y8ISf
++QkMkee4
 -----END CERTIFICATE-----
diff --git a/Lib/test/certdata/capath/ceff1710.0 b/Lib/test/certdata/capath/ceff1710.0
index aa9dbbe294f..6d773ee5b32 100644
--- a/Lib/test/certdata/capath/ceff1710.0
+++ b/Lib/test/certdata/capath/ceff1710.0
@@ -1,27 +1,27 @@
 -----BEGIN CERTIFICATE-----
-MIIEgDCCAuigAwIBAgIJAMstgJlaaVJbMA0GCSqGSIb3DQEBCwUAME0xCzAJBgNV
+MIIEgjCCAuqgAwIBAgIJAMstgJlaaVJbMA0GCSqGSIb3DQEBCwUAME0xCzAJBgNV
 BAYTAlhZMSYwJAYDVQQKDB1QeXRob24gU29mdHdhcmUgRm91bmRhdGlvbiBDQTEW
-MBQGA1UEAwwNb3VyLWNhLXNlcnZlcjAeFw0xODA4MjkxNDIzMTZaFw0zNzEwMjgx
-NDIzMTZaME0xCzAJBgNVBAYTAlhZMSYwJAYDVQQKDB1QeXRob24gU29mdHdhcmUg
-Rm91bmRhdGlvbiBDQTEWMBQGA1UEAwwNb3VyLWNhLXNlcnZlcjCCAaIwDQYJKoZI
-hvcNAQEBBQADggGPADCCAYoCggGBANCgm7G5O3nuMS+4URwBde0JWUysyL9qCvh6
-CPAl4yV7avjE2KqgYAclsM9zcQVSaL8Gk64QYZa8s2mBGn0Z/CCGj5poG+3N4mxh
-Z8dOVepDBiEb6bm+hF/C2uuJiOBCpkVJKtC5a4yTyUQ7yvw8lH/dcMWt2Es73B74
-VUu1J4b437CDz/cWN78TFzTUyVXtaxbJf60gTvAe2Ru/jbrNypbvHmnLUWZhSA3o
-eaNZYdQQjeANOwuFttWFEt2lB8VL+iP6VDn3lwvJREceVnc8PBMBC2131hS6RPRT
-NVbZPbk+NV/bM5pPWrk4RMkySf5m9h8al6rKTEr2uF5Af/sLHfhbodz4wC7QbUn1
-0kbUkFf+koE0ri04u6gXDOHlP+L3JgVUUPVksxxuRP9vqbQDlukOwojYclKQmcZB
-D0aQWbg+b9Linh02gpXTWIoS8+LYDSBRI/CQLZo+fSaGsqfX+ShgA+N3x4gEyf6J
-d3AQT8Ogijv0q0J74xSS2K4W1qHefQIDAQABo2MwYTAdBgNVHQ4EFgQU8+yUjvKO
-MMSOaMK/jmoZwMGfdmUwHwYDVR0jBBgwFoAU8+yUjvKOMMSOaMK/jmoZwMGfdmUw
-DwYDVR0TAQH/BAUwAwEB/zAOBgNVHQ8BAf8EBAMCAYYwDQYJKoZIhvcNAQELBQAD
-ggGBAIsAVHKzjevzrzSf1mDq3oQ/jASPGaa+AmfEY8V040c3WYOUBvFFGegHL9ZO
-S0+oPccHByeS9H5zT4syGZRGeiXE2cQnsBFjOmCLheFzTzQ7a6Q0jEmOzc9PsmUn
-QRmw/IAxePJzapt9cTRQ/Hio2gW0nFs6mXprXe870+k7MwESZc9eB9gZr9VT6vAQ
-rMS2Jjw0LnTuZN0dNnWJRACwDf0vswHMGosCzWzogILKv4LXAJ3YNhXSBzf8bHMd
-2qgc6CCOMnr+bScW5Fhs6z7w/iRSKXG4lntTS0UgVUBehhvsyUaRku6sk2WRLpS2
-tqzoozSJpBoSDU1EpVLti5HuL6avpJUl+c7HW6cA05PKtDxdTfexPMxttEW+gu0Y
-kMiG0XVRUARM6E/S1lCqdede/6F7Jxkca0ksbE1rY8w7cwDzmSbQgofTqTactD25
-SGiokvAnjgzNFXZChIDJP6N+tN3X+Kx2umCXPFofTt5x7gk5EN0x1WhXXRrlQroO
-aOZF0w==
+MBQGA1UEAwwNb3VyLWNhLXNlcnZlcjAgFw0xODA4MjkxNDIzMTZaGA8yNTI1MTAy
+ODE0MjMxNlowTTELMAkGA1UEBhMCWFkxJjAkBgNVBAoMHVB5dGhvbiBTb2Z0d2Fy
+ZSBGb3VuZGF0aW9uIENBMRYwFAYDVQQDDA1vdXItY2Etc2VydmVyMIIBojANBgkq
+hkiG9w0BAQEFAAOCAY8AMIIBigKCAYEA5rri5MHCDBw+Yti5XFcuUriDxYg65pp6
+9WQWM+s3bi9782gDRWVHXXEQWcorGwBsgRRh9IZZP+r9eDcWnUPxxPZpjMUpBoie
+JiIErATYhzRIOetr8guSqsNuY1FRa8Kt/1zIL7IbnCCKQD6iL2rqyNk3Q1zc7ZLi
+2UDSYZ9xivXtObqoXj61IWMQ2G+04hEBCxDou/ti70hVvPXSnKtorpUlGfKXfRrc
+ZuqIXobky8tpTV6wo/tsMeQoYF6Q8dQuEFDhhfANXL3dRSQIGT4ck2aPK9pTfQQc
+DkLEaF6mzakY7afNatDRhrqQ/7dM3sdDJG3HHGucgefhG1clkKkOyVbz9mteLbQu
+QFCbQmPS1pkcONzPKyyncvHHXmM0dkj0PogTnoYWUy90+4cBjSKkaDPuE2x6BhRU
+VhdXV5g00AtmCeOICfilFRwQc9CIUJleGGU7/zEnG17GqkH9LS8Yp8Dyq8citQtp
+0nPRu9AcPfqkNWLNM4bHoCMPuWrV0m2NAgMBAAGjYzBhMB0GA1UdDgQWBBTACiso
+Q95fyX1H5UebNvJljGc74jAfBgNVHSMEGDAWgBTACisoQ95fyX1H5UebNvJljGc7
+4jAPBgNVHRMBAf8EBTADAQH/MA4GA1UdDwEB/wQEAwIBhjANBgkqhkiG9w0BAQsF
+AAOCAYEAvONWIgPkXLln/5S8dZwAhbDVnMTDKWZei7KppjCGcRpr8gDFgqtfUAQq
+++24TLkAG0lXkhHNorzLD6i0YfgUyqDsQBe6VaHEvKayWu/0IBB3R9CgxVi5bLUQ
+e4VKQ6P7LAG5dxewvqDurq5NZ4ZIiVeGeOo87fBBNY1xaFX58umsMtTGou/sVObE
+jiz9vapgVmUzleoQxnQE6ypumxH2YQCq/ezyC7FLEc2T69+Yrky0BwRK5e//Ulh1
+9T6kceFKclypj9SqiPBqcbTDAF+ZbteRr2yYDWTCJMeeBRFoXiRi4y5F7KM08qOd
+TeUyGC90/BHxNlBPoEApaFxDTCNsXXLE7FJ269yyvB+mxAZmm1zHzMry0SVP3qUf
+jeQMSbbPhUChuR/GxxkVB2M0k9BXoFpw7K9KHHIXHXSjbDFFCzN6obhG28cOZExv
+t5kEgkMf4FnWmSEnKAlArvzEI6qgDAgFKpIc2yOe0dVjrjkToxKIWkM8Sm4y8ISf
++QkMkee4
 -----END CERTIFICATE-----
diff --git a/Lib/test/certdata/cert3.pem b/Lib/test/certdata/cert3.pem
index 4ab0f5ff133..a11dc614657 100644
--- a/Lib/test/certdata/cert3.pem
+++ b/Lib/test/certdata/cert3.pem
@@ -1,34 +1,34 @@
 -----BEGIN CERTIFICATE-----
-MIIF8TCCBFmgAwIBAgIJAMstgJlaaVJcMA0GCSqGSIb3DQEBCwUAME0xCzAJBgNV
+MIIF8zCCBFugAwIBAgIJAMstgJlaaVJcMA0GCSqGSIb3DQEBCwUAME0xCzAJBgNV
 BAYTAlhZMSYwJAYDVQQKDB1QeXRob24gU29mdHdhcmUgRm91bmRhdGlvbiBDQTEW
-MBQGA1UEAwwNb3VyLWNhLXNlcnZlcjAeFw0xODA4MjkxNDIzMTZaFw0zNzEwMjgx
-NDIzMTZaMF8xCzAJBgNVBAYTAlhZMRcwFQYDVQQHDA5DYXN0bGUgQW50aHJheDEj
-MCEGA1UECgwaUHl0aG9uIFNvZnR3YXJlIEZvdW5kYXRpb24xEjAQBgNVBAMMCWxv
-Y2FsaG9zdDCCAaIwDQYJKoZIhvcNAQEBBQADggGPADCCAYoCggGBAKAqKHEL7aDt
-3swl8hQF8VaK4zDGDRaF3E/IZTMwCN7FsQ4ejSiOe3E90f0phHCIpEpv2OebNenY
-IpOGoFgkh62r/cthmnhu8Mn+FUIv17iOq7WX7B30OSqEpnr1voLX93XYkAq8LlMh
-P79vsSCVhTwow3HZY7krEgl5WlfryOfj1i1TODSFPRCJePh66BsOTUvV/33GC+Qd
-pVZVDGLowU1Ycmr/FdRvwT+F39Dehp03UFcxaX0/joPhH5gYpBB1kWTAQmxuqKMW
-9ZZs6hrPtMXF/yfSrrXrzTdpct9paKR8RcufOcS8qju/ISK+1P/LXg2b5KJHedLo
-TTIO3yCZ4d1odyuZBP7JDrI05gMJx95gz6sG685Qc+52MzLSTwr/Qg+MOjQoBy0o
-8fRRVvIMEwoN0ZDb4uFEUuwZceUP1vTk/GGpNQt7ct4ropn6K4Zta3BUtovlLjZa
-IIBhc1KETUqjRDvC6ACKmlcJ/5pY/dbH1lOux+IMFsh+djmaV90b3QIDAQABo4IB
-wDCCAbwwFAYDVR0RBA0wC4IJbG9jYWxob3N0MA4GA1UdDwEB/wQEAwIFoDAdBgNV
-HSUEFjAUBggrBgEFBQcDAQYIKwYBBQUHAwIwDAYDVR0TAQH/BAIwADAdBgNVHQ4E
-FgQUP7HpT6C+MGY+ChjID0caTzRqD0IwfQYDVR0jBHYwdIAU8+yUjvKOMMSOaMK/
-jmoZwMGfdmWhUaRPME0xCzAJBgNVBAYTAlhZMSYwJAYDVQQKDB1QeXRob24gU29m
-dHdhcmUgRm91bmRhdGlvbiBDQTEWMBQGA1UEAwwNb3VyLWNhLXNlcnZlcoIJAMst
-gJlaaVJbMIGDBggrBgEFBQcBAQR3MHUwPAYIKwYBBQUHMAKGMGh0dHA6Ly90ZXN0
-Y2EucHl0aG9udGVzdC5uZXQvdGVzdGNhL3B5Y2FjZXJ0LmNlcjA1BggrBgEFBQcw
-AYYpaHR0cDovL3Rlc3RjYS5weXRob250ZXN0Lm5ldC90ZXN0Y2Evb2NzcC8wQwYD
-VR0fBDwwOjA4oDagNIYyaHR0cDovL3Rlc3RjYS5weXRob250ZXN0Lm5ldC90ZXN0
-Y2EvcmV2b2NhdGlvbi5jcmwwDQYJKoZIhvcNAQELBQADggGBAMo0usXQzycxMtYN
-JzC42xfftzmnu7E7hsQx/fur22MazJCruU6rNEkMXow+cKOnay+nmiV7AVoYlkh2
-+DZ4dPq8fWh/5cqmnXvccr2jJVEXaOjp1wKGLH0WfLXcRLIK4/fJM6NRNoO81HDN
-hJGfBrot0gUKZcPZVQmouAlpu5OGwrfCkHR8v/BdvA5jE4zr+g/x+uUScE0M64wu
-okJCAAQP/PkfQZxjePBmk7KPLuiTHFDLLX+2uldvUmLXOQsJgqumU03MBT4Z8NTA
-zqmtEM65ceSP8lo8Zbrcy+AEkCulFaZ92tyjtbe8oN4wTmTLFw06oFLSZzuiOgDV
-OaphdVKf/pvA6KBpr6izox0KQFIE5z3AAJZfKzMGDDD20xhy7jjQZNMAhjfsT+k4
-SeYB/6KafNxq08uoulj7w4Z4R/EGpkXnU96ZHYHmvGN0RnxwI1cpYHCazG8AjsK/
-anN9brBi5twTGrn+D8LRBqF5Yn+2MKkD0EdXJdtIENHP+32sPQ==
+MBQGA1UEAwwNb3VyLWNhLXNlcnZlcjAgFw0xODA4MjkxNDIzMTZaGA8yNTI1MTAy
+ODE0MjMxNlowXzELMAkGA1UEBhMCWFkxFzAVBgNVBAcMDkNhc3RsZSBBbnRocmF4
+MSMwIQYDVQQKDBpQeXRob24gU29mdHdhcmUgRm91bmRhdGlvbjESMBAGA1UEAwwJ
+bG9jYWxob3N0MIIBojANBgkqhkiG9w0BAQEFAAOCAY8AMIIBigKCAYEA7jZwqmFq
+ILsyiAdz8DrKEcyPMIDXccd0YiCUiLRSEpQIAeF5GMzwaYuZxUfBgqquyFEEPomM
+HWWt8h+l9dSHZawseIA3UBUhTnoJxuNaKr+xsARBb6usZaMKaGhsPuf/P7CV/1VO
+OKy/f34jFU23oTITEv8+Z00mEgAle7EV58FuE+pdjne+xczwY52hRQza+RiKIg+J
+jUid+bdObZYhnM9CMhOUxkepCBBTSB+bYXh6CSeCQuLi8licHiacQ8ddJ41kcCjf
+7V5vBZx0DzEQFJdsDNO0GRCNcn81K9NP6BtnaT5z8jYfuqdpXfCUtINvz3dqUC/D
+rZjNnA3DeRPqghFtVFSCef/2nfKVHKEMMkSAUTiW2pKr+hXFU3YE6IKKuVbvk+k1
+RS0iEr1b6bFdDLU/x/f/U7Qp6jsJYhPLPJG9zY0E/Hu9lRzXeN21TxOA3kPl5WzK
+Cs1fhjpkh0n80jmQfZEnEphneWA/O/N02y/P+zZ9REUHVqmosRiN+vgRAgMBAAGj
+ggHAMIIBvDAUBgNVHREEDTALgglsb2NhbGhvc3QwDgYDVR0PAQH/BAQDAgWgMB0G
+A1UdJQQWMBQGCCsGAQUFBwMBBggrBgEFBQcDAjAMBgNVHRMBAf8EAjAAMB0GA1Ud
+DgQWBBQWIsmqINT0ju2cprsj9fIpRO3yHjB9BgNVHSMEdjB0gBTACisoQ95fyX1H
+5UebNvJljGc74qFRpE8wTTELMAkGA1UEBhMCWFkxJjAkBgNVBAoMHVB5dGhvbiBT
+b2Z0d2FyZSBGb3VuZGF0aW9uIENBMRYwFAYDVQQDDA1vdXItY2Etc2VydmVyggkA
+yy2AmVppUlswgYMGCCsGAQUFBwEBBHcwdTA8BggrBgEFBQcwAoYwaHR0cDovL3Rl
+c3RjYS5weXRob250ZXN0Lm5ldC90ZXN0Y2EvcHljYWNlcnQuY2VyMDUGCCsGAQUF
+BzABhilodHRwOi8vdGVzdGNhLnB5dGhvbnRlc3QubmV0L3Rlc3RjYS9vY3NwLzBD
+BgNVHR8EPDA6MDigNqA0hjJodHRwOi8vdGVzdGNhLnB5dGhvbnRlc3QubmV0L3Rl
+c3RjYS9yZXZvY2F0aW9uLmNybDANBgkqhkiG9w0BAQsFAAOCAYEAQ4IfGLTLerdO
+rMNlLrdXOvB4s7IgPr17JPfnF8xiwLhj8C4wDFS+yZR8VNRABm6SnXIsRPXjwUo/
+JuQhyrrvT6NQVu6JXNxbmLwM6dsWmPBMP2W52eAuvYOexxv3T4dfdf9nXQr/zvoL
+8dWLWCMrkie4Ff9mwvlo4u1koErgQousNWpnZPXLqQA3IFbdOgJu2A+0Xf+Sow1l
+/C6rTje8ftZbHFV4oG6pLlUxz2HwG0z+/mB1dujZofUU8EMzTVIFvjP/2jGUvQ3l
+Taju0fOSNMI2kTc6bewg37Oeol3Q8KHi/7eFzgnjyEpqk6Su7MFnQveOL2TK13Zy
+vz/vZP8Q3aI+LfWqAs8x8G2Ta1ZMsIiVVNzUrNzBiCeL2ZxOZpP43V50QSaa7+jI
+RlzV9PzNzGfHM2IucJvROd40/a2duUhh54lTYmLwQGxoL+HaQGEqUK/JQW2YFq/L
+YwPsBJngOZhgrqpqV5slcwMWv3jI1y/r/GR/x3iMNBVbZkCYhuYK
 -----END CERTIFICATE-----
diff --git a/Lib/test/certdata/idnsans.pem b/Lib/test/certdata/idnsans.pem
index 07a42422af1..ebd7250cb4e 100644
--- a/Lib/test/certdata/idnsans.pem
+++ b/Lib/test/certdata/idnsans.pem
@@ -1,42 +1,42 @@
 -----BEGIN PRIVATE KEY-----
-MIIG/AIBADANBgkqhkiG9w0BAQEFAASCBuYwggbiAgEAAoIBgQCp6zt40WB3K7yj
-BGugnRuqI3ApftThZWDIpvW0cVmN0nqQxsO6CCnS4dS7SYhGFiIqWjNVc2WG0gv7
-nC5DFguqbndNZk9/SjX8EOxKz4ANjd61WnTkDO5Tbiiyd+TuEBxhmbEF69bF9dtd
-1Sgo8jmM7j+aa6ClYh/49bx+blJDF76EGSrmB1q+obMeZURhPXNBeoiqKR83x5Hc
-LTJYMocvb6m8uABwuSka13Gb3QGu06p5ldK6TDK38HsoOy6MFO5F1PrkakG/eBHO
-jcBOGPfNmTwWOqvwlcQWykr4QspWS+yTzdkgZ+mxar/yQuq7wuYSNaEfGH5yoYtV
-WIgKwwZRDPqpSQuVe+J+MWLPQ6RTM+rXIHVzHtPk1f8DrgN+hSepJy/sVBBEQCzj
-nyB+scn76ETWch3iyVoMj3oVOGs0b4XTDMmUw/DmEt5TDah7TqE3G+fpBIbgMSjx
-MzUQZl27izmM9nQCJRAosNoNwXqlM754K9WcY6gT8kkcj1CfTmMCAwEAAQKCAYAz
-9ZdHkDsf5fN2pAznXfOOOOz8+2hMjmwkn42GAp1gdWr+Z5GFiyaC8oTTSp6N1AnZ
-iqCk8jcrHYMFi1JIOG8TzFjWBcGsinxsmp4vGDmvq2Ddcw5IiD2+rHJsdKZAOBP9
-snpD9cTE3zQYAu0XbE617krrxRqoSBO/1SExRjoIgzPCgFGyarBQl/DGjC/3Tku2
-y6oL4qxFqdTMD9QTzUuycUJlz5xu2+gaaaQ3hcMUe2xnZq28Qz3FKpf2ivZmZqWf
-4+AIe0lRosmFoLAFjIyyuGCkWZ2t9KDIZV0OOS4+DvVOC/Um9r4VojeikripCGKY
-2FzkkuQP3jz6pJ1UxCDg7YXZdR2IbcS18F1OYmLViU8oLDR6T01s0Npmp39dDazf
-A4U+WyV3o1ydiSpwAiN8pJadmr5BHrCSmawV8ztW5yholufrO+FR5ze2+QG99txm
-6l7lUI8Nz01lYG6D10MjaQ9INk2WSjBPVNbfsTl73/hR76/319ctfOINRMHilJ0C
-gcEAvFgTdc5Qf9E7xEZE5UtpSTPvZ24DxQ7hmGW3pTs6+Nw4ccknnW0lLkWvY4Sf
-gXl4TyTTUhe6PAN3UHzbjN2vdsTmAVUlnkNH40ymF8FgRGFNDuvuCZvf5ZWNddSl
-6Vu/e5TFPDAqS8rGnl23DgXhlT+3Y0/mrftWoigdOxgximLAsmmqp/tANGi9jqE1
-3L0BN+xKqMMKSXkMtuzJHuini8MaWQgQcW/4czh4ArdesMzuVrstOD8947XHreY9
-pesVAoHBAOb0y/AFEdR+mhk/cfqjTzsNU2sS9yHlzMVgecF8BA26xcfAwg4d47VS
-+LK8fV6KC4hHk4uQWjQzCG2PYXBbFT52xeJ3EC8DwWxJP09b4HV/1mWxXl5htjnr
-dfyTmXKvEe5ZBpKGWc8i7s7jBi7R5EpgIfc586iNRyjYAk60dyG0iP13SurRvXBg
-ID25VR4wABl3HQ3Hhv61dqC9FPrdHZQJdysfUqNrAFniWsSR2eyG5i4S1uHa3G+i
-MzBTOuBRlwKBwBNXUBhG6YlWqTaMqMKLLfKwfKM4bvargost1uAG5xVrN/inWYQX
-EzxfN5WWpvKa0Ln/5BuICD3ldTk0uS8MDNq7eYslfUl1S0qSMnQ6DXK4MzuXCsi9
-0w42f2JcRfVi0JUWP/LgV1eVKTRWF1g/Tl0PP/vY1q2DI/BfAjFxWJUHcxZfN4Es
-kflP0Dd3YpqaZieiAkC2VrYY0i9uvXCJH7uAe5Is+9NKVk8uu1Q8FGM/iDIr4obm
-J6rcnfbDsAz7yQKBwGtIbW9qO3UU9ioiQaTmtYg90XEclzXk1HEfNo+9NvjVuMfo
-b3w1QDBbgXEtg6MlxuOgNBaRkIVM625ROzcA6GZir9tZ6Wede/z8LW+Ew0hxgLsu
-YCLBiu9uxBj2y0HttwubySTJSfChToNGC/o1v7EY5M492kSCk/qSFMhQpkI+5Z+w
-CVn44eHQlUl2zOY/79vka9eZxsiMrLVP/+3kRrgciYG7hByrOLeIIRfMlIl9xHDE
-iZLSorEsjFC3aNMIswKBwFELC2fvlziW9rECQcGXnvc1DPmZcxm1ATFZ93FpKleF
-TjLIWSdst0PmO8CSIuEZ2ZXPoK9CMJyQG+kt3k7IgZ1xKXg9y6ThwbznurXp1jaW
-NjEnYtFMBK9Ur3oaAsrG2XwZ2PMvnI/Yp8tciGvjJlzSM8gHJ9BL8Yf+3gIJi/0D
-KtaF9ha9J/SDDZdEiLIQ4LvSqYmlUgsCgiUvY3SVwCh8xDfBWD1hKw9vUiZu5cnJ
-81hAHFgeD4f+C8fLols/sA==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 -----END PRIVATE KEY-----
 Certificate:
     Data:
@@ -47,38 +47,38 @@ Certificate:
         Issuer: C=XY, O=Python Software Foundation CA, CN=our-ca-server
         Validity
             Not Before: Aug 29 14:23:16 2018 GMT
-            Not After : Oct 28 14:23:16 2037 GMT
+            Not After : Oct 28 14:23:16 2525 GMT
         Subject: C=XY, L=Castle Anthrax, O=Python Software Foundation, CN=idnsans
         Subject Public Key Info:
             Public Key Algorithm: rsaEncryption
                 Public-Key: (3072 bit)
                 Modulus:
-                    00:a9:eb:3b:78:d1:60:77:2b:bc:a3:04:6b:a0:9d:
-                    1b:aa:23:70:29:7e:d4:e1:65:60:c8:a6:f5:b4:71:
-                    59:8d:d2:7a:90:c6:c3:ba:08:29:d2:e1:d4:bb:49:
-                    88:46:16:22:2a:5a:33:55:73:65:86:d2:0b:fb:9c:
-                    2e:43:16:0b:aa:6e:77:4d:66:4f:7f:4a:35:fc:10:
-                    ec:4a:cf:80:0d:8d:de:b5:5a:74:e4:0c:ee:53:6e:
-                    28:b2:77:e4:ee:10:1c:61:99:b1:05:eb:d6:c5:f5:
-                    db:5d:d5:28:28:f2:39:8c:ee:3f:9a:6b:a0:a5:62:
-                    1f:f8:f5:bc:7e:6e:52:43:17:be:84:19:2a:e6:07:
-                    5a:be:a1:b3:1e:65:44:61:3d:73:41:7a:88:aa:29:
-                    1f:37:c7:91:dc:2d:32:58:32:87:2f:6f:a9:bc:b8:
-                    00:70:b9:29:1a:d7:71:9b:dd:01:ae:d3:aa:79:95:
-                    d2:ba:4c:32:b7:f0:7b:28:3b:2e:8c:14:ee:45:d4:
-                    fa:e4:6a:41:bf:78:11:ce:8d:c0:4e:18:f7:cd:99:
-                    3c:16:3a:ab:f0:95:c4:16:ca:4a:f8:42:ca:56:4b:
-                    ec:93:cd:d9:20:67:e9:b1:6a:bf:f2:42:ea:bb:c2:
-                    e6:12:35:a1:1f:18:7e:72:a1:8b:55:58:88:0a:c3:
-                    06:51:0c:fa:a9:49:0b:95:7b:e2:7e:31:62:cf:43:
-                    a4:53:33:ea:d7:20:75:73:1e:d3:e4:d5:ff:03:ae:
-                    03:7e:85:27:a9:27:2f:ec:54:10:44:40:2c:e3:9f:
-                    20:7e:b1:c9:fb:e8:44:d6:72:1d:e2:c9:5a:0c:8f:
-                    7a:15:38:6b:34:6f:85:d3:0c:c9:94:c3:f0:e6:12:
-                    de:53:0d:a8:7b:4e:a1:37:1b:e7:e9:04:86:e0:31:
-                    28:f1:33:35:10:66:5d:bb:8b:39:8c:f6:74:02:25:
-                    10:28:b0:da:0d:c1:7a:a5:33:be:78:2b:d5:9c:63:
-                    a8:13:f2:49:1c:8f:50:9f:4e:63
+                    00:de:18:6c:ac:a8:da:ac:cf:ae:3e:c6:c3:7e:09:
+                    46:43:7c:28:0f:3e:1c:d4:2b:49:43:52:59:04:92:
+                    9d:19:78:57:90:9b:7f:a9:a3:66:3c:da:0b:c9:21:
+                    56:a5:3b:90:a1:89:78:cf:c5:28:09:c2:8b:68:48:
+                    77:b8:41:9f:1f:58:09:64:5f:57:75:f4:0f:31:8e:
+                    37:ad:c7:52:b7:76:a6:6c:b6:a7:b7:98:f3:fb:1d:
+                    0b:df:26:54:64:98:0b:55:84:56:94:8f:5f:92:53:
+                    1f:4a:b3:81:c1:e0:b9:36:86:a2:94:a2:ad:d3:95:
+                    13:29:79:27:c9:4d:76:87:4e:15:4f:ec:a6:4f:58:
+                    1c:df:33:ba:5d:a4:66:27:ce:70:69:c6:07:f2:98:
+                    da:e9:4d:c5:cd:0a:37:91:ea:55:25:8f:f4:c4:c4:
+                    78:98:2e:3e:04:d1:a3:83:47:f4:94:cf:4b:41:35:
+                    d0:90:45:c4:43:c3:e3:b2:44:47:ba:46:4d:f6:2a:
+                    b9:77:e0:fa:f5:74:d2:9e:11:1d:2d:ba:58:4c:db:
+                    04:45:b2:ac:34:6b:cb:cd:b3:5d:c8:df:40:47:e1:
+                    a5:c0:af:96:c6:80:b0:85:da:d5:db:3f:72:a8:7a:
+                    84:7f:1a:44:12:59:5d:78:2a:b8:53:c6:12:83:dd:
+                    01:09:f2:01:e3:a0:76:0a:af:82:1d:70:56:1c:4d:
+                    a9:1b:23:d1:37:4c:7b:10:8d:04:d4:30:9f:d7:ca:
+                    0c:da:ec:e3:ab:ea:93:4f:29:8d:74:b5:87:e9:ed:
+                    68:72:c9:8e:dc:07:f0:bf:ac:79:d4:63:47:f9:f0:
+                    86:65:45:d3:18:81:c2:c2:52:5e:f0:cd:4c:52:54:
+                    43:32:af:d0:2b:cb:c5:d9:66:5c:6e:3b:ad:bd:93:
+                    6b:9d:00:81:b0:22:2d:93:56:af:94:2b:49:0d:3d:
+                    9c:86:89:c1:87:31:e1:21:a0:d7:37:60:33:01:ff:
+                    36:1e:a8:ca:f8:2a:bc:88:fa:69
                 Exponent: 65537 (0x10001)
         X509v3 extensions:
             X509v3 Subject Alternative Name: 
@@ -90,9 +90,9 @@ Certificate:
             X509v3 Basic Constraints: critical
                 CA:FALSE
             X509v3 Subject Key Identifier: 
-                5B:93:42:58:B0:B4:18:CC:41:4C:15:EB:42:33:66:77:4C:71:2F:42
+                C8:06:99:B7:E8:8F:EC:4F:3D:5C:89:6A:06:F5:77:2E:B0:E0:6A:9E
             X509v3 Authority Key Identifier: 
-                keyid:F3:EC:94:8E:F2:8E:30:C4:8E:68:C2:BF:8E:6A:19:C0:C1:9F:76:65
+                keyid:C0:0A:2B:28:43:DE:5F:C9:7D:47:E5:47:9B:36:F2:65:8C:67:3B:E2
                 DirName:/C=XY/O=Python Software Foundation CA/CN=our-ca-server
                 serial:CB:2D:80:99:5A:69:52:5B
             Authority Information Access: 
@@ -103,64 +103,64 @@ Certificate:
                   URI:http://testca.pythontest.net/testca/revocation.crl
     Signature Algorithm: sha256WithRSAEncryption
     Signature Value:
-        5f:d8:9b:dc:22:55:80:47:e1:9b:04:3e:46:53:9b:e5:a7:4a:
-        8f:eb:53:01:39:d5:04:f6:cf:dc:48:84:8a:a9:c3:a5:35:22:
-        2f:ab:74:77:ec:a6:fd:b1:e6:e6:74:82:38:54:0b:27:36:e6:
-        ec:3d:fe:92:1a:b2:7a:35:0d:a3:e5:7c:ff:e5:5b:1a:28:4b:
-        29:1f:99:1b:3e:11:e9:e2:e0:d7:da:06:4f:e3:7b:8c:ad:30:
-        f4:39:24:e8:ad:2a:0e:71:74:ab:ed:62:e9:9f:85:7e:6a:b0:
-        bb:53:b4:d7:6b:b8:da:54:15:5c:9a:41:cf:61:f1:ab:67:d6:
-        27:5c:0c:a3:d7:41:e7:27:3e:58:89:d6:1f:3f:2a:52:cc:13:
-        0b:4b:e6:d6:ba:a0:c7:fd:e3:17:a4:b8:da:cc:cb:88:70:21:
-        3b:70:df:09:40:6c:e7:02:81:08:80:b0:36:77:fb:44:c5:cf:
-        bf:19:54:7c:d1:4e:1f:a2:44:9e:d8:56:0e:bf:4b:0b:e0:84:
-        6f:bc:f6:c6:7f:35:7a:17:ca:83:b3:82:c6:4e:d3:f3:d8:30:
-        05:fd:6d:3c:8a:ab:63:55:6f:c5:18:ba:66:fe:e2:35:04:2b:
-        ae:76:34:f0:56:18:e8:54:db:83:b2:1b:93:0a:25:81:81:f0:
-        25:ca:0a:95:be:8e:2f:05:3f:6c:e7:de:d1:7c:b8:a3:71:7c:
-        6f:8a:05:c3:69:eb:6f:e6:76:8c:11:e1:59:0b:12:53:07:42:
-        84:e8:89:ee:ab:7d:28:81:48:e8:79:d5:cf:a2:05:a4:fd:72:
-        2c:7d:b4:1c:08:90:4e:0d:10:05:d1:9a:c0:69:4c:0a:14:39:
-        17:fb:4d:5b:f6:42:bb:46:27:23:0f:5e:57:5b:b8:ae:9b:a3:
-        0e:23:59:41:63:41:a4:f1:69:df:b3:a3:5c:10:d5:63:30:74:
-        a8:3c:0c:8e:1c:6b:10:e1:13:27:02:26:9b:fd:88:93:7e:91:
-        9c:f9:c2:07:27:a4
+        40:d1:6d:8e:a2:0b:91:4b:a8:c4:08:d0:f3:f9:8b:d0:a3:0b:
+        dc:00:22:8c:f1:2e:2b:e5:e6:b4:6e:ce:9d:cf:59:32:66:6c:
+        bb:0e:3b:1d:9c:05:d2:eb:a6:29:f8:74:4f:dc:83:3b:32:5a:
+        2c:67:86:61:25:bc:bd:19:eb:20:c6:30:69:0e:4c:b2:e3:18:
+        ca:9e:fe:40:bc:1c:ad:8b:03:f5:04:be:90:ce:27:27:2f:83:
+        14:57:8d:4f:a0:db:46:ce:e0:7d:e2:cf:7d:ea:0c:fd:8d:00:
+        27:0a:db:0d:5f:e7:1e:52:25:1f:64:b9:30:5f:07:1a:10:a3:
+        69:35:0e:dc:f8:23:f7:34:07:ce:c8:92:94:39:4d:d5:c3:ab:
+        33:aa:f9:67:be:66:18:ac:67:14:5f:93:5f:68:48:04:ed:1e:
+        c9:74:28:b2:47:34:49:11:e4:7b:38:32:e5:dc:40:13:b4:69:
+        75:39:43:db:7c:4a:f0:2b:94:cd:01:ba:4d:9b:9e:68:b3:ee:
+        03:9e:7f:9c:0c:cf:9c:5c:cb:d4:33:d5:f0:e3:21:54:9a:13:
+        6f:eb:1a:0f:f3:8b:e8:ef:eb:34:ba:09:77:39:2a:8a:4b:e1:
+        7e:9f:b5:05:be:95:b6:92:5d:4c:35:47:38:64:38:5e:27:b8:
+        f9:34:94:2f:57:16:b0:f5:6a:21:3f:09:34:b9:dd:f8:d1:47:
+        2c:c7:5e:7f:63:49:f4:5b:f4:d9:ea:66:fc:aa:64:27:f0:72:
+        d7:94:6f:86:0f:e7:3b:b3:d4:d9:30:67:b8:a2:c3:f7:4d:07:
+        44:b3:70:67:dd:b1:21:ac:7c:2a:04:7b:2c:1d:df:0b:82:a9:
+        fb:df:88:72:47:1c:f5:5d:a3:f7:52:22:2d:ea:f4:2a:45:4f:
+        9b:9d:63:95:59:f3:79:05:2b:f1:5b:3b:62:71:69:90:30:d7:
+        7a:b2:c8:ec:68:e5:94:bb:97:00:d0:95:a7:fd:04:6c:f7:8b:
+        28:c1:96:9b:6a:94
 -----BEGIN CERTIFICATE-----
-MIIGvTCCBSWgAwIBAgIJAMstgJlaaVJgMA0GCSqGSIb3DQEBCwUAME0xCzAJBgNV
+MIIGvzCCBSegAwIBAgIJAMstgJlaaVJgMA0GCSqGSIb3DQEBCwUAME0xCzAJBgNV
 BAYTAlhZMSYwJAYDVQQKDB1QeXRob24gU29mdHdhcmUgRm91bmRhdGlvbiBDQTEW
-MBQGA1UEAwwNb3VyLWNhLXNlcnZlcjAeFw0xODA4MjkxNDIzMTZaFw0zNzEwMjgx
-NDIzMTZaMF0xCzAJBgNVBAYTAlhZMRcwFQYDVQQHDA5DYXN0bGUgQW50aHJheDEj
-MCEGA1UECgwaUHl0aG9uIFNvZnR3YXJlIEZvdW5kYXRpb24xEDAOBgNVBAMMB2lk
-bnNhbnMwggGiMA0GCSqGSIb3DQEBAQUAA4IBjwAwggGKAoIBgQCp6zt40WB3K7yj
-BGugnRuqI3ApftThZWDIpvW0cVmN0nqQxsO6CCnS4dS7SYhGFiIqWjNVc2WG0gv7
-nC5DFguqbndNZk9/SjX8EOxKz4ANjd61WnTkDO5Tbiiyd+TuEBxhmbEF69bF9dtd
-1Sgo8jmM7j+aa6ClYh/49bx+blJDF76EGSrmB1q+obMeZURhPXNBeoiqKR83x5Hc
-LTJYMocvb6m8uABwuSka13Gb3QGu06p5ldK6TDK38HsoOy6MFO5F1PrkakG/eBHO
-jcBOGPfNmTwWOqvwlcQWykr4QspWS+yTzdkgZ+mxar/yQuq7wuYSNaEfGH5yoYtV
-WIgKwwZRDPqpSQuVe+J+MWLPQ6RTM+rXIHVzHtPk1f8DrgN+hSepJy/sVBBEQCzj
-nyB+scn76ETWch3iyVoMj3oVOGs0b4XTDMmUw/DmEt5TDah7TqE3G+fpBIbgMSjx
-MzUQZl27izmM9nQCJRAosNoNwXqlM754K9WcY6gT8kkcj1CfTmMCAwEAAaOCAo4w
-ggKKMIHhBgNVHREEgdkwgdaCB2lkbnNhbnOCH3huLS1rbmlnLTVxYS5pZG4ucHl0
-aG9udGVzdC5uZXSCLnhuLS1rbmlnc2dzc2NoZW4tbGNiMHcuaWRuYTIwMDMucHl0
-aG9udGVzdC5uZXSCLnhuLS1rbmlnc2djaGVuLWI0YTNkdW4uaWRuYTIwMDgucHl0
-aG9udGVzdC5uZXSCJHhuLS1ueGFzbXE2Yi5pZG5hMjAwMy5weXRob250ZXN0Lm5l
-dIIkeG4tLW54YXNtbTFjLmlkbmEyMDA4LnB5dGhvbnRlc3QubmV0MA4GA1UdDwEB
-/wQEAwIFoDAdBgNVHSUEFjAUBggrBgEFBQcDAQYIKwYBBQUHAwIwDAYDVR0TAQH/
-BAIwADAdBgNVHQ4EFgQUW5NCWLC0GMxBTBXrQjNmd0xxL0IwfQYDVR0jBHYwdIAU
-8+yUjvKOMMSOaMK/jmoZwMGfdmWhUaRPME0xCzAJBgNVBAYTAlhZMSYwJAYDVQQK
-DB1QeXRob24gU29mdHdhcmUgRm91bmRhdGlvbiBDQTEWMBQGA1UEAwwNb3VyLWNh
-LXNlcnZlcoIJAMstgJlaaVJbMIGDBggrBgEFBQcBAQR3MHUwPAYIKwYBBQUHMAKG
-MGh0dHA6Ly90ZXN0Y2EucHl0aG9udGVzdC5uZXQvdGVzdGNhL3B5Y2FjZXJ0LmNl
-cjA1BggrBgEFBQcwAYYpaHR0cDovL3Rlc3RjYS5weXRob250ZXN0Lm5ldC90ZXN0
-Y2Evb2NzcC8wQwYDVR0fBDwwOjA4oDagNIYyaHR0cDovL3Rlc3RjYS5weXRob250
-ZXN0Lm5ldC90ZXN0Y2EvcmV2b2NhdGlvbi5jcmwwDQYJKoZIhvcNAQELBQADggGB
-AF/Ym9wiVYBH4ZsEPkZTm+WnSo/rUwE51QT2z9xIhIqpw6U1Ii+rdHfspv2x5uZ0
-gjhUCyc25uw9/pIasno1DaPlfP/lWxooSykfmRs+Eeni4NfaBk/je4ytMPQ5JOit
-Kg5xdKvtYumfhX5qsLtTtNdruNpUFVyaQc9h8atn1idcDKPXQecnPliJ1h8/KlLM
-EwtL5ta6oMf94xekuNrMy4hwITtw3wlAbOcCgQiAsDZ3+0TFz78ZVHzRTh+iRJ7Y
-Vg6/SwvghG+89sZ/NXoXyoOzgsZO0/PYMAX9bTyKq2NVb8UYumb+4jUEK652NPBW
-GOhU24OyG5MKJYGB8CXKCpW+ji8FP2zn3tF8uKNxfG+KBcNp62/mdowR4VkLElMH
-QoToie6rfSiBSOh51c+iBaT9cix9tBwIkE4NEAXRmsBpTAoUORf7TVv2QrtGJyMP
-XldbuK6bow4jWUFjQaTxad+zo1wQ1WMwdKg8DI4caxDhEycCJpv9iJN+kZz5wgcn
-pA==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 -----END CERTIFICATE-----
diff --git a/Lib/test/certdata/keycert.passwd.pem b/Lib/test/certdata/keycert.passwd.pem
index 187021b8eeb..1739a3525fe 100644
--- a/Lib/test/certdata/keycert.passwd.pem
+++ b/Lib/test/certdata/keycert.passwd.pem
@@ -1,69 +1,69 @@
 -----BEGIN ENCRYPTED PRIVATE KEY-----
-MIIHbTBXBgkqhkiG9w0BBQ0wSjApBgkqhkiG9w0BBQwwHAQIc17oH9riZswCAggA
-MAwGCCqGSIb3DQIJBQAwHQYJYIZIAWUDBAEqBBDwi0Mkj59S0hplpnDSNHwPBIIH
-EFGdZuO4Cwzg0bspLhE1UpBN5cBq1rKbf4PyVtCczIqJt3KjO3H5I4KdQd9zihkN
-A1qzMiqVZOnQZw1eWFXMdyWuCgvNe1S/PRLWY3iZfnuZ9gZXQvyMEHy4JU7pe2Ib
-GNm9mzadzJtGv0YZ05Kkza20zRlOxC/cgaNUV6TPeTSwW9CR2bylxw0lTFKBph+o
-uFGcAzhqQuw9vsURYJf1f1iE7bQsnWU2kKmb9cx6kaUXiGJpkUMUraBL/rShoHa0
-eet6saiFnK3XGMCIK0mhS9s92CIQV5H9oQQPo/7s6MOoUHjC/gFoWBXoIDOcN9aR
-ngybosCLtofY2m14WcHXvu4NJnfnKStx73K3dy3ZLr2iyjnsqGD1OhqGEWOVG/ho
-QiZEhZ+9sOnqWI2OuMhMoQJNvrLj7AY4QbdkahdjNvLjDAQSuMI2uSUDFDNfkQdy
-hqF/iiEM28PmSHCapgCpzR4+VfEfXBoyBCqs973asa9qhrorfnBVxXnvsqmKNLGH
-dymtEPei9scpoftE5T9TPqQj46446bXk23Xpg8QIFa8InQC2Y+yZqqlqvzCAbN6S
-Qcq1DcTSAMnbmBXVu9hPmJYIYOlBMHL8JGbsGrkVOhLiiIou4w3G+DyAvIwPj6j9
-BHLqa7HgUnUEC+zL4azVHOSMqmDsOiF3w9fkBWNSkOyNoZpe+gBjbxq7sp+GjAJv
-1CemRC3LSoNzLcjRG2IEGs1jlEHSSfijvwlE4lEy3JVc+QK8BOkKXXDVhY1SQHcS
-pniEnj95RFVmAujdFDBoUgySyxK/y6Ju/tHPpSTG9VMNbJTKTdBWAVWWHVJzBFhR
-0Ug62VrBK7fmfUdH1b37aIxqsPND2De6WLm0RX+7r3XPDJ7hm+baKCchI5CvnG19
-ky8InhMbU4qV+9LceMETmNKKDkhKl4Zx/Y3nab7DG9s/RZfrTdCHojc9Va/t0Ykp
-qlVrvdj/893CdI78SW3VjWBJGWfKMyT16hBMY3TPz6ulbFXk6Pul/KcLLWslghS+
-GKZjyBe96UwfH4C7WjuIB+zo+De3Wr8xOCdJR5zwEutBMM+L/Wul8B6wIEGS71kB
-TN/CAoeIgHLQFbcw4YE80dllTnSEsqF+ahVTTcCt3iLUaOgeTUxteMbXY9+nekSX
-x8aUcvkMhbU9omdEowFr5/HIMKXo4UXat4fIGgh2pG8v8fA46hZXkhWUh/PhbnQw
-StXzn4fA13erqVI679kHMmOIQebv4oqdcwkImrH5fEsACNjQbkYZF5fD4z+1GHkA
-e2eGqejVT+OV14I8qfx9oqs2f8aqijH8fYLU0TymE7p53DYZy4WvDwk22I4rMzoQ
-sGkOZwfKUYpdBI2t6tEf1ROBjoNG0E2Onq+5iooibN08rKXKAQMWsK+2vNHNHwBW
-49vRheQNnRqSuLY+b7QAjA0KuRWo9YptCbnXyF/Aw64jMfAGjggDLoaZfALGZk3n
-P+ZoL9xc7rYRpIca44BeYI6AhHFcWWIOX7Sm69FvmyHlfsgTAXVgY1lQPuGy68Au
-PHSkgUyydDtkrfb2W2gJuqD/+h+9X2z+o/+nETYPCZm3sH5xvTY/DTcTx9kTpXxx
-YQBaFTt12eVX7wZVr5K3u9M371rg+SeXC2SzL4T6APHD52cxbA1jgM0JFh3KJTuk
-fADxIzM1NdzYQ45J6i2w+/Fh4VPnXZ0oiUSwE094XTBlvhI6zHgar2Q0Qx1P51vB
-odd9XzyDLULuIzei0DYjTIg0KhE+wAGq1I5qtiMhmy5TdCKKNA9WGb1Pq38zpyjU
-wGmztzSzCEjfLyhChaUObVRRxEfD5ioxKer/fczOhKQe8FXmGy5u/04tVmmEyNOO
-JkkDtZy+UbKuJ257QnY72wPjgtHNy+S4Iv7zHUbNJNhxk+xBlRcmRNWCEM20LBSO
-Tj4S9gyan+gH2+WFxy8FaENUhM+vHFEeJcjQIBFBeWICmSmdkh/r0YK1UVJ9NLfR
-l0HiKm3lKg+kNCexTAPLMt2rGZ4PAKVnhVaxtuHMYYDpl2GYmyH73B9BfcPdA/Zx
-GUBmd9hwcLz9SuUg+fjHcogZRRRlcZlKhw3zUCsqHSCQXZCQm7mBlG/5C/7cM7wQ
-IRtsNospLStOg51gv21ClQ+uWx30XEcwmnIfVoLl1vMaguuf1u5u3dWBD/UgmqiP
-1Ym8jv0BF/AS+u/CtUpwe7ZWxFT0vbyi10xxIF7O07fwFa+5dME3ycZwcyiE95K1
-ftcHlGOIhuVBMSNZXC4I9LM+7IWy+hanUcK+v5RvwBDSJV3fnAOdfrka1L/HyEEb
-x/FYKEiU/TAjXDw2NtZ2itpADTSG5KbdJSwPr01Ak7aE+QYe7TIKJhBDZXGQlqq8
-1wv77zyv7V5Xq2cxSEKgSqzB9fhYZCASe8+HWlV2T+Sd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 -----END ENCRYPTED PRIVATE KEY-----
 -----BEGIN CERTIFICATE-----
-MIIEgzCCAuugAwIBAgIUU+FIM/dUbCklbdDwNPd2xemDAEwwDQYJKoZIhvcNAQEL
+MIIEhTCCAu2gAwIBAgIUTxhwRX6zBQc3+l3imDklEbqcDpIwDQYJKoZIhvcNAQEL
 BQAwXzELMAkGA1UEBhMCWFkxFzAVBgNVBAcMDkNhc3RsZSBBbnRocmF4MSMwIQYD
 VQQKDBpQeXRob24gU29mdHdhcmUgRm91bmRhdGlvbjESMBAGA1UEAwwJbG9jYWxo
-b3N0MB4XDTIzMTEyNTA0MjEzNloXDTQzMDEyNDA0MjEzNlowXzELMAkGA1UEBhMC
-WFkxFzAVBgNVBAcMDkNhc3RsZSBBbnRocmF4MSMwIQYDVQQKDBpQeXRob24gU29m
-dHdhcmUgRm91bmRhdGlvbjESMBAGA1UEAwwJbG9jYWxob3N0MIIBojANBgkqhkiG
-9w0BAQEFAAOCAY8AMIIBigKCAYEAzXTIl1su11AGu6sDPsoxqcRGyAX0yjxIcswF
-vj+eW/fBs2GcBby95VEOKpJPKRYYB7fAEAjAKK59zFdsDX/ynxPZLqyLQocBkFVq
-tclhCRZu//KZND+uQuHSx3PjGkSvK/nrGjg5T0bkM4SFeb0YdLb+0aDTKGozUC82
-oBAilNcrFz1VXpEF0qUe9QeKQhyd0MaW5T1oSn+U3RAj2MXm3TGExyZeaicpIM5O
-HFlnwUxsYSDZo0jUj342MbPOZh8szZDWi042jdtSA3i8uMSplEf4O8ZPmX0JCtrz
-fVjRVdaKXIjrhMNWB8K44q6AeyhqJcVHtOmPYoHDm0qIjcrurt0LZaGhmCuKimNd
-njcPxW0VQmDIS/mO5+s24SK+Mpznm5q/clXEwyD8FbrtrzV5cHCE8eNkxjuQjkmi
-wW9uadK1s54tDwRWMl6DRWRyxoF0an885UQWmbsgEB5aRmEx2L0JeD0/q6Iw1Nta
-As8DG4AaWuYMrgZXz7XvyiMq3IxVAgMBAAGjNzA1MBQGA1UdEQQNMAuCCWxvY2Fs
-aG9zdDAdBgNVHQ4EFgQUl2wd7iWE1JTZUVq2yFBKGm9N36owDQYJKoZIhvcNAQEL
-BQADggGBAF0f5x6QXFbgdyLOyeAPD/1DDxNjM68fJSmNM/6vxHJeDFzK0Pja+iJo
-xv54YiS9F2tiKPpejk4ujvLQgvrYrTQvliIE+7fUT0dV74wZKPdLphftT9uEo1dH
-TeIld+549fqcfZCJfVPE2Ka4vfyMGij9hVfY5FoZL1Xpnq/ZGYyWZNAPbkG292p8
-KrfLZm/0fFYAhq8tG/6DX7+2btxeX4MP/49tzskcYWgOjlkknyhJ76aMG9BJ1D7F
-/TIEh5ihNwRTmyt023RBz/xWiN4xBLyIlpQ6d5ECKmFNFr0qnEui6UovfCHUF6lZ
-qcAQ5VFQQ2CayNlVmQ+UGmWIqANlacYWBt7Q6VqpGg24zTMec1/Pqd6X07ScSfrm
-MAtywrWrU7p1aEkN5lBa4n/XKZHGYMjor/YcMdF5yjdSrZr274YYO1pafmTFwRwH
-5o16c8WPc0aPvTFbkGIFT5ddxYstw+QwsBtLKE2lJ4Qfmxt0Ew/0L7xkbK1BaCOo
-EGD2IF7VDQ==
+b3N0MCAXDTI0MTAwODExNTExMloYDzI0MDgwMTI5MTE1MTEyWjBfMQswCQYDVQQG
+EwJYWTEXMBUGA1UEBwwOQ2FzdGxlIEFudGhyYXgxIzAhBgNVBAoMGlB5dGhvbiBT
+b2Z0d2FyZSBGb3VuZGF0aW9uMRIwEAYDVQQDDAlsb2NhbGhvc3QwggGiMA0GCSqG
+SIb3DQEBAQUAA4IBjwAwggGKAoIBgQDwcIAYm12nmQTGB3caFn7alDe3LSliEfNC
+2ZTR+5sh1eucQPbzgFM5SR4soKGElwI68Eg7g1kwqu3zmrI/FAiQI/RrUHyBZiEt
+nFBPM44vY02XjUlJ9nBtgP7QjpRz6ZP0z1DrrojpYLVwg9cR0khTqD5cg2jvTB05
+yL9lQNk295/rMuueC9FaAQ+Y5la0ub7Lbe8gkYPotYliGx5qqCQmsXeTsxCpvQD7
+u0vBF9/nxlwywwzKGXabcN9YQhSECCC4c+eYjqoRgvAaF48xEnokxenzBIqZ82BR
+kFo+zfNR+VhJRctNiZ6Ppa1Ise1H3LjZMDfY1S89QOLYsFXUp8L7ZMVE27Bej+Sq
+4wEJ3soK/k1kr0YauqJ0lCEKkUPD9OeNHmczeakjj11tgtctsYbwgDSUYGA3w+DC
+KD1aSfeuR3Hj89cSsVRrRrPFFih46Tr2PpTNoK6MtPH3RPJKV+Db8E1V2mXmNE0M
+Lg6ramSHsD9iZXTLhG2JO+/876k3N3kCAwEAAaM3MDUwFAYDVR0RBA0wC4IJbG9j
+YWxob3N0MB0GA1UdDgQWBBR459BlAel5MqCtG0DrvVtMZlQfuTANBgkqhkiG9w0B
+AQsFAAOCAYEAaTFWjK/LFzOo+0TWqTTj4WC4N3I8JFrHnlqFJlpchYTW2z92SU1G
+iEzFjWzuDNjp5KM9BqlmGtzXZvy6MItGkYsjPRdPVU0rbCmyTho6y77kTyiEG12V
+UAJ1in3FOQfDwLPcp7wQRgCQq3iZlv7pwXp2Lm5fzu8kZPnxmTVdiKQun9Ps7uKq
+BoM0fM2K14MxVO4Wc0SERnaPszE7xAhkIcs+NRT/gHYdTBlPhao83S3LOOdtCqCP
+pNUOEaShlwI5bVsDPUXNX/eS0MYFNlsYTb5rCxK8jf3W3KNjKTOzN94pHiQOhpkg
+xMPPi3m03/9oKTVXBtHI2A+u3ukheKE6sBXCLdv/GEs9zYI49zmpQxNWz5EOumWL
+k+W/vPv7cD6LeHxxp+nCbEJi1gZtYb3gMY1sLkMNxcOu0QHTqHfme+k7VKWm8anO
+3ogGdGtPuPAD/qjMwg3ChSDLl5Ur/E9UPlD4yM/7KtUD7mLv+jbddA62EiA9MxVB
+t+yt7pOwOA66
 -----END CERTIFICATE-----
diff --git a/Lib/test/certdata/keycert.pem b/Lib/test/certdata/keycert.pem
index a30d15ca4d6..43ad52c2af5 100644
--- a/Lib/test/certdata/keycert.pem
+++ b/Lib/test/certdata/keycert.pem
@@ -1,67 +1,67 @@
 -----BEGIN PRIVATE KEY-----
-MIIG/QIBADANBgkqhkiG9w0BAQEFAASCBucwggbjAgEAAoIBgQDNdMiXWy7XUAa7
-qwM+yjGpxEbIBfTKPEhyzAW+P55b98GzYZwFvL3lUQ4qkk8pFhgHt8AQCMAorn3M
-V2wNf/KfE9kurItChwGQVWq1yWEJFm7/8pk0P65C4dLHc+MaRK8r+esaODlPRuQz
-hIV5vRh0tv7RoNMoajNQLzagECKU1ysXPVVekQXSpR71B4pCHJ3QxpblPWhKf5Td
-ECPYxebdMYTHJl5qJykgzk4cWWfBTGxhINmjSNSPfjYxs85mHyzNkNaLTjaN21ID
-eLy4xKmUR/g7xk+ZfQkK2vN9WNFV1opciOuEw1YHwrjiroB7KGolxUe06Y9igcOb
-SoiNyu6u3QtloaGYK4qKY12eNw/FbRVCYMhL+Y7n6zbhIr4ynOebmr9yVcTDIPwV
-uu2vNXlwcITx42TGO5COSaLBb25p0rWzni0PBFYyXoNFZHLGgXRqfzzlRBaZuyAQ
-HlpGYTHYvQl4PT+rojDU21oCzwMbgBpa5gyuBlfPte/KIyrcjFUCAwEAAQKCAYAO
-M1r0+TCy4Z1hhceu5JdLql0RELZTbxi71IW2GVwW87gv75hy3hGLAs/1mdC+YIBP
-MkBka1JqzWq0/7rgcP5CSAMsInFqqv2s7fZ286ERGXuZFbnInnkrNsQUlJo3E9W+
-tqKtGIM/i0EVHX0DRdJlqMtSjmjh43tB+M1wAUV+n6OjEtJue5wZK+AIpBmGicdP
-qZY+6IBnm8tcfzPXFRCoq7ZHdIu0jxnc4l2MQJK3DdL04KoiStOkSl8xDsI+lTtq
-D3qa41LE0TY8X2jJ/w6KK3cUeK7F4DQYs+kfCKWMVPpn0/5u6TbC1F7gLvkrseph
-7cIgrruNNs9iKacnR1w3U72R+hNxHsNfo4RGHFa192p/Mfc+kiBd5RNR/M9oHdeq
-U6T/+KM+QyF5dDOyonY0QjwfAcEx+ZsV72nj8AerjM907I6dgHo/9YZ2S1Dt/xuG
-ntD+76GDzmrOvXmmpF0DsTn+Wql7AC4uzaOjv6PVziqz03pR61RpjPDemyJEWMkC
-gcEA7BkGGX3enBENs3X6BYFoeXfGO/hV7/aNpA6ykLzw657dqwy2b6bWLiIaqZdZ
-u0oiY6+SpOtavkZBFTq4bTVD58FHL0n73Yvvaft507kijpYBrxyDOfTJOETv+dVG
-XiY8AUSAE6GjPi0ebuYIVUxoDnMeWDuRJNvTck4byn1hJ1aVlEhwXNxt/nAjq48s
-5QDuR6Z9F8lqEACRYCHSMQYFm35c7c1pPsHJnElX8a7eZ9lT7HGPXHaf/ypMkOzo
-dvJNAoHBAN7GhDomff/kSgQLyzmqKqQowTZlyihnReapygwr8YpNcqKDqq6VlnfH
-Jl1+qtSMSVI0csmccwJWkz1WtSjDsvY+oMdv4gUK3028vQAMQZo+Sh7OElFPFET3
-UmL+Nh73ACPgpiommsdLZQPcIqpWNT5NzO+Jm5xa+U9ToVZgQ7xjrqee5NUiMutr
-r7UWAz7vDWu3x7bzYRRdUJxU18NogGbFGWJ1KM0c67GUXu2E7wBQdjVdS78UWs+4
-XBxKQkG2KQKBwQCtO+M82x122BB8iGkulvhogBjlMd8klnzxTpN5HhmMWWH+uvI1
-1G29Jer4WwRNJyU6jb4E4mgPyw7AG/jssLOlniy0Jw32TlIaKpoGXwZbJvgPW9Vx
-tgnbDsIiR3o9ZMKMj42GWgike4ikCIc+xzRmvdMbHIHwUJfCfEtp9TtPGPnh9pDz
-og3XLsMNg52GXnt3+VI6HOCE41XH+qj2rZt5r2tSVXEOyjQ7R5mOzSeFfXJVwDFX
-v/a/zHKnuB0OAdUCgcBLrxPTEaqy2eMPdtZHM/mipbnmejRw/4zu7XYYJoG7483z
-SlodT/K7pKvzDYqKBVMPm4P33K/x9mm1aBTJ0ZqmL+a9etRFtEjjByEKuB89gLX7
-uzTb7MrNF10lBopqgK3KgpLRNSZWWNXrtskMJ5eVICdkpdJ5Dyst+RKR3siEYzU9
-+yxxAFpeQsqB8gWORva/RsOR8yNjIMS3J9fZqlIdGA8ktPr0nEOyo96QQR5VdACE
-5rpKI2cqtM6OSegynOkCgcAnr2Xzjef6tdcrxrQrq0DjEFTMoCAxQRa6tuF/NYHV
-AK70Y4hBNX84Bvym4hmfbMUEuOCJU+QHQf/iDQrHXPhtX3X2/t8M+AlIzmwLKf2o
-VwCYnZ8SqiwSaWVg+GANWLh0JuKn/ZYyR8urR79dAXFfp0UK+N39vIxNoBisBf+F
-G8mca7zx3UtK2eOW8WgGHz+Y20VZy0m/nkNekd1ZTXoSGhL+iN4XsTRn1YQIn69R
-kNdcwhtZZ3dpChUdf+w/LIc=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 -----END PRIVATE KEY-----
 -----BEGIN CERTIFICATE-----
-MIIEgzCCAuugAwIBAgIUU+FIM/dUbCklbdDwNPd2xemDAEwwDQYJKoZIhvcNAQEL
+MIIEhTCCAu2gAwIBAgIUTxhwRX6zBQc3+l3imDklEbqcDpIwDQYJKoZIhvcNAQEL
 BQAwXzELMAkGA1UEBhMCWFkxFzAVBgNVBAcMDkNhc3RsZSBBbnRocmF4MSMwIQYD
 VQQKDBpQeXRob24gU29mdHdhcmUgRm91bmRhdGlvbjESMBAGA1UEAwwJbG9jYWxo
-b3N0MB4XDTIzMTEyNTA0MjEzNloXDTQzMDEyNDA0MjEzNlowXzELMAkGA1UEBhMC
-WFkxFzAVBgNVBAcMDkNhc3RsZSBBbnRocmF4MSMwIQYDVQQKDBpQeXRob24gU29m
-dHdhcmUgRm91bmRhdGlvbjESMBAGA1UEAwwJbG9jYWxob3N0MIIBojANBgkqhkiG
-9w0BAQEFAAOCAY8AMIIBigKCAYEAzXTIl1su11AGu6sDPsoxqcRGyAX0yjxIcswF
-vj+eW/fBs2GcBby95VEOKpJPKRYYB7fAEAjAKK59zFdsDX/ynxPZLqyLQocBkFVq
-tclhCRZu//KZND+uQuHSx3PjGkSvK/nrGjg5T0bkM4SFeb0YdLb+0aDTKGozUC82
-oBAilNcrFz1VXpEF0qUe9QeKQhyd0MaW5T1oSn+U3RAj2MXm3TGExyZeaicpIM5O
-HFlnwUxsYSDZo0jUj342MbPOZh8szZDWi042jdtSA3i8uMSplEf4O8ZPmX0JCtrz
-fVjRVdaKXIjrhMNWB8K44q6AeyhqJcVHtOmPYoHDm0qIjcrurt0LZaGhmCuKimNd
-njcPxW0VQmDIS/mO5+s24SK+Mpznm5q/clXEwyD8FbrtrzV5cHCE8eNkxjuQjkmi
-wW9uadK1s54tDwRWMl6DRWRyxoF0an885UQWmbsgEB5aRmEx2L0JeD0/q6Iw1Nta
-As8DG4AaWuYMrgZXz7XvyiMq3IxVAgMBAAGjNzA1MBQGA1UdEQQNMAuCCWxvY2Fs
-aG9zdDAdBgNVHQ4EFgQUl2wd7iWE1JTZUVq2yFBKGm9N36owDQYJKoZIhvcNAQEL
-BQADggGBAF0f5x6QXFbgdyLOyeAPD/1DDxNjM68fJSmNM/6vxHJeDFzK0Pja+iJo
-xv54YiS9F2tiKPpejk4ujvLQgvrYrTQvliIE+7fUT0dV74wZKPdLphftT9uEo1dH
-TeIld+549fqcfZCJfVPE2Ka4vfyMGij9hVfY5FoZL1Xpnq/ZGYyWZNAPbkG292p8
-KrfLZm/0fFYAhq8tG/6DX7+2btxeX4MP/49tzskcYWgOjlkknyhJ76aMG9BJ1D7F
-/TIEh5ihNwRTmyt023RBz/xWiN4xBLyIlpQ6d5ECKmFNFr0qnEui6UovfCHUF6lZ
-qcAQ5VFQQ2CayNlVmQ+UGmWIqANlacYWBt7Q6VqpGg24zTMec1/Pqd6X07ScSfrm
-MAtywrWrU7p1aEkN5lBa4n/XKZHGYMjor/YcMdF5yjdSrZr274YYO1pafmTFwRwH
-5o16c8WPc0aPvTFbkGIFT5ddxYstw+QwsBtLKE2lJ4Qfmxt0Ew/0L7xkbK1BaCOo
-EGD2IF7VDQ==
+b3N0MCAXDTI0MTAwODExNTExMloYDzI0MDgwMTI5MTE1MTEyWjBfMQswCQYDVQQG
+EwJYWTEXMBUGA1UEBwwOQ2FzdGxlIEFudGhyYXgxIzAhBgNVBAoMGlB5dGhvbiBT
+b2Z0d2FyZSBGb3VuZGF0aW9uMRIwEAYDVQQDDAlsb2NhbGhvc3QwggGiMA0GCSqG
+SIb3DQEBAQUAA4IBjwAwggGKAoIBgQDwcIAYm12nmQTGB3caFn7alDe3LSliEfNC
+2ZTR+5sh1eucQPbzgFM5SR4soKGElwI68Eg7g1kwqu3zmrI/FAiQI/RrUHyBZiEt
+nFBPM44vY02XjUlJ9nBtgP7QjpRz6ZP0z1DrrojpYLVwg9cR0khTqD5cg2jvTB05
+yL9lQNk295/rMuueC9FaAQ+Y5la0ub7Lbe8gkYPotYliGx5qqCQmsXeTsxCpvQD7
+u0vBF9/nxlwywwzKGXabcN9YQhSECCC4c+eYjqoRgvAaF48xEnokxenzBIqZ82BR
+kFo+zfNR+VhJRctNiZ6Ppa1Ise1H3LjZMDfY1S89QOLYsFXUp8L7ZMVE27Bej+Sq
+4wEJ3soK/k1kr0YauqJ0lCEKkUPD9OeNHmczeakjj11tgtctsYbwgDSUYGA3w+DC
+KD1aSfeuR3Hj89cSsVRrRrPFFih46Tr2PpTNoK6MtPH3RPJKV+Db8E1V2mXmNE0M
+Lg6ramSHsD9iZXTLhG2JO+/876k3N3kCAwEAAaM3MDUwFAYDVR0RBA0wC4IJbG9j
+YWxob3N0MB0GA1UdDgQWBBR459BlAel5MqCtG0DrvVtMZlQfuTANBgkqhkiG9w0B
+AQsFAAOCAYEAaTFWjK/LFzOo+0TWqTTj4WC4N3I8JFrHnlqFJlpchYTW2z92SU1G
+iEzFjWzuDNjp5KM9BqlmGtzXZvy6MItGkYsjPRdPVU0rbCmyTho6y77kTyiEG12V
+UAJ1in3FOQfDwLPcp7wQRgCQq3iZlv7pwXp2Lm5fzu8kZPnxmTVdiKQun9Ps7uKq
+BoM0fM2K14MxVO4Wc0SERnaPszE7xAhkIcs+NRT/gHYdTBlPhao83S3LOOdtCqCP
+pNUOEaShlwI5bVsDPUXNX/eS0MYFNlsYTb5rCxK8jf3W3KNjKTOzN94pHiQOhpkg
+xMPPi3m03/9oKTVXBtHI2A+u3ukheKE6sBXCLdv/GEs9zYI49zmpQxNWz5EOumWL
+k+W/vPv7cD6LeHxxp+nCbEJi1gZtYb3gMY1sLkMNxcOu0QHTqHfme+k7VKWm8anO
+3ogGdGtPuPAD/qjMwg3ChSDLl5Ur/E9UPlD4yM/7KtUD7mLv+jbddA62EiA9MxVB
+t+yt7pOwOA66
 -----END CERTIFICATE-----
diff --git a/Lib/test/certdata/keycert.pem.reference b/Lib/test/certdata/keycert.pem.reference
new file mode 100644
index 00000000000..5528b98fff9
--- /dev/null
+++ b/Lib/test/certdata/keycert.pem.reference
@@ -0,0 +1,13 @@
+{'issuer': ((('countryName', 'XY'),),
+            (('localityName', 'Castle Anthrax'),),
+            (('organizationName', 'Python Software Foundation'),),
+            (('commonName', 'localhost'),)),
+ 'notAfter': 'Jan 29 11:51:12 2408 GMT',
+ 'notBefore': 'Oct  8 11:51:12 2024 GMT',
+ 'serialNumber': '4F1870457EB3050737FA5DE298392511BA9C0E92',
+ 'subject': ((('countryName', 'XY'),),
+             (('localityName', 'Castle Anthrax'),),
+             (('organizationName', 'Python Software Foundation'),),
+             (('commonName', 'localhost'),)),
+ 'subjectAltName': (('DNS', 'localhost'),),
+ 'version': 3}
diff --git a/Lib/test/certdata/keycert2.pem b/Lib/test/certdata/keycert2.pem
index c7c4aa74583..63e2181ed83 100644
--- a/Lib/test/certdata/keycert2.pem
+++ b/Lib/test/certdata/keycert2.pem
@@ -1,67 +1,67 @@
 -----BEGIN PRIVATE KEY-----
-MIIG/gIBADANBgkqhkiG9w0BAQEFAASCBugwggbkAgEAAoIBgQCyAUXjczgUEn7m
-mOwDMi/++wDRxqJAJ2f7F9ADxTuOm+EtdpfYr4mBn8Uz9e3I+ZheG5y3QZ1ddBYA
-9YTfcUL0on8UXLOOBVZCetxsQXoSAuDMPV0IXeEgtZZDXe7STqKSQeYk7Cz+VtHe
-lZ8j7oOOcx5sJgpbaD+OGJnPoAdB8l8nQfxqAG45sW4P6gfLKoJLviKctDe5pvgi
-JC8tvytg/IhESKeefLZ4ix2dNjj2GNUaL+khU6UEuM1kJHcPVjPoYc+y8fop/qhQ
-0ithBhO2OvJ+YmOFdCE67SyCwU3p8zJpN+XkwbHttgmNg4OSs7H6V7E52/CsTNTA
-SthBHXtxqaM+vjbGARrz2Fpc/n+LwRt7MGIR0gVtntTgnP0HoeHskhAIeDtaPrZ6
-zHdl3aDwgAecVebTEBT5YPboz+X1lWdOrRD2JW3bqXSRIN3E4qz5IMuNx3VvhpSR
-eFZzR6QIbxQqzO/Vp93Ivy8hPZ6WMgfSYWs7CGtu4NP79PJfdMsCAwEAAQKCAYAc
-e3yp2NlbyNvaXRTCrCim5ZXrexuiJUwLjvNfbxNJDeM5iZThfLEFd0GwP0U1l86M
-HGH2pr6d4gHVVHPW5wIeL9Qit3SZoHv9djhH8DAuqpw6wgTdXlw0BipNjD23FBMK
-URYYyVuntM+vDITi1Hrjc8Ml7e5RUvx8aa5O3R3cLQKRvwq7EWeRvrTMQhfOJ/ai
-VQGnzmRuRevFVsHf0YuI4M+TEYcUooL2BdiOu8rggfezUYA9r2sjtshSok0UvKeb
-79pNzWmg9EWVeFk+A0HQpyLq+3EVyB5UZ3CZRkT0XhEm1B7mpKrtcGMjaumNAam7
-jkhidGdhT/PV9BB1TttcqwTf+JH9P9sSpY9ZTA1LkkeWe9Rwqpxjjssqxxl6Xnds
-+wUfuovVvHuBinsO+5PLE5UQByn21WcIBNnPCAMvALy/68T7z8+ATJ+I2CqBXuM2
-z5663hNrvdCu93PpK4j/k/1l3NTrthaorbnPhkmNYHQkBicpAfFQywrv6enD+30C
-gcEA7Vlw76og4oxI7SSD6gTfo85OqTLp2CUZhNNxzYiUOOssRnGHBKsGZ8p0OhLN
-vk9/SgbeHL5jsmnyd8ZuYWmsOQHRWgg1zO3S25iuq+VAo4cL/7IynoJ0RP5xP0Pw
-QD+xJLZQp0XuLUtXnlc6dM5Hg7tOTthOP9UxA1i57lzpYfkRnKmSeWi+4IDJymOt
-WoWnEK7Yr7qSg6aScLWRyIvAPVmKF9LToSFaTq0eOD0GIwAQxqNbIwN3U0UJ5Ruc
-KRBVAoHBAL/+DNGqnEzhhWS6zqZp2eH90YR+b3R4yOK4PROm2AVA3h1GhIAiWX68
-PvKYZK9dZ9EdAswlFf9PVQYIXUraR3az0UiIywnNMri+kO1ZxwofGvljrOfRRLg0
-B46wuHi6dVgTWzjTl503G9+FpAYNHv184xsr1tne0pf2TKEnN7oyQciCV8qtr8vV
-HrL46uaD0w1fcXIXbO3F/7ErLsvsgLzKfxR5BeQo6Fq0GmzD+lCmzVNirtfl2CZj
-2ukROXUQnwKBwQDR1CqFlm/wGHk4PPnp31ke5XqhFoOpNFM1HAEV5VK0ZyQDOsZU
-mCXXiCHsXUdKodk0RpIB80cMKaHTxbc7o0JAO50q7OszOmUZAggZq1jTuMYgzRb3
-DvlfLVpMxfEVu7kNbagr2STRIjRZpV/md569lM+L4Kp8wCrOfJgTZExm8txhFYCK
-mNF2hCThKfHNfy7NDuY9pMF2ZcI8pig1lWbkVc5BdX7miifeOinnKfvM4XfzQ+OE
-NsI8+WHgC+KoYukCgcBwrOpdCmHchOZCbZfl9m1Wwh16QrGqi1BqLnI53EsfGijA
-yaftgzs+s7/FpEZC3PCWuw3vPTyhr69YcQQ/b8dNFM8YYJ+4SuMfpUds5Kl5eTPd
-dO/+xMQtzus4hOJeiB9h50o8GYH7VGJZVhcjLgQoBGlMgvf+uVSitnvWgCumbORK
-hqR7YF+xoov3wToquubcDE2KBdF54h/jnFJEf7I2GilmnHgmpRNoWBbCCmoXdy09
-aMbwEgY+0Y+iBOfRmkUCgcEAoHJLw7VnZQGQQL4l3lnoGU9o06RPkNbpda9G/Ptz
-v+K7DXmHiLFVDszvZaPVreohuc0tKdrT0cZpZ21h0GQD4B6JX66R/y6CCAr0QpdA
-pFZO9sc5ky6RJ4xZCoCsNJzORNUb36cagEzBWExb7Jz2v6gNa044K5bs3CVv5h15
-rJtTxZNn/gcnIk+gt//67WUnKLS4PR5PVCCqYhSbhFwx/OvVTJmflIBUinAclf2Q
-M4mhHOfwBicqYzzEYbOE9Vk9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 -----END PRIVATE KEY-----
 -----BEGIN CERTIFICATE-----
-MIIEjDCCAvSgAwIBAgIUQ2S3jJ5nve5k5956sgsrWY3vw9MwDQYJKoZIhvcNAQEL
+MIIEjjCCAvagAwIBAgIUCP/QP57z62jCsjf6l0ft/yzDxOkwDQYJKoZIhvcNAQEL
 BQAwYjELMAkGA1UEBhMCWFkxFzAVBgNVBAcMDkNhc3RsZSBBbnRocmF4MSMwIQYD
 VQQKDBpQeXRob24gU29mdHdhcmUgRm91bmRhdGlvbjEVMBMGA1UEAwwMZmFrZWhv
-c3RuYW1lMB4XDTIzMTEyNTA0MjEzN1oXDTQzMDEyNDA0MjEzN1owYjELMAkGA1UE
-BhMCWFkxFzAVBgNVBAcMDkNhc3RsZSBBbnRocmF4MSMwIQYDVQQKDBpQeXRob24g
-U29mdHdhcmUgRm91bmRhdGlvbjEVMBMGA1UEAwwMZmFrZWhvc3RuYW1lMIIBojAN
-BgkqhkiG9w0BAQEFAAOCAY8AMIIBigKCAYEAsgFF43M4FBJ+5pjsAzIv/vsA0cai
-QCdn+xfQA8U7jpvhLXaX2K+JgZ/FM/XtyPmYXhuct0GdXXQWAPWE33FC9KJ/FFyz
-jgVWQnrcbEF6EgLgzD1dCF3hILWWQ13u0k6ikkHmJOws/lbR3pWfI+6DjnMebCYK
-W2g/jhiZz6AHQfJfJ0H8agBuObFuD+oHyyqCS74inLQ3uab4IiQvLb8rYPyIREin
-nny2eIsdnTY49hjVGi/pIVOlBLjNZCR3D1Yz6GHPsvH6Kf6oUNIrYQYTtjryfmJj
-hXQhOu0sgsFN6fMyaTfl5MGx7bYJjYODkrOx+lexOdvwrEzUwErYQR17camjPr42
-xgEa89haXP5/i8EbezBiEdIFbZ7U4Jz9B6Hh7JIQCHg7Wj62esx3Zd2g8IAHnFXm
-0xAU+WD26M/l9ZVnTq0Q9iVt26l0kSDdxOKs+SDLjcd1b4aUkXhWc0ekCG8UKszv
-1afdyL8vIT2eljIH0mFrOwhrbuDT+/TyX3TLAgMBAAGjOjA4MBcGA1UdEQQQMA6C
-DGZha2Vob3N0bmFtZTAdBgNVHQ4EFgQU5wVOIuQD/Jxmam/97g91+igosWQwDQYJ
-KoZIhvcNAQELBQADggGBAFv5gW5x4ET5NXEw6vILlOtwxwplEbU/x6eUVR/AXtEz
-jtq9zIk2svX/JIzSLRQnjJmb/nCDCeNcFMkkgIiB64I3yMJT9n50fO4EhSGEaITZ
-vYAw0/U6QXw+B1VS1ijNA44X2zvC+aw1q9W+0SKtvnu7l16TQ654ey0Qh9hOF1HS
-AZQ46593T9gaZMeexz4CShoBZ80oFOJezfNhyT3FK6tzXNbkVoJDhlLvr/ep81GG
-mABUGtKQYYMhuSSp0TDvf7jnXxtQcZI5lQOxZp0fnWUcK4gMVJqFVicwY8NiOhAG
-6TlvXYP4COLAvGmqBB+xUhekIS0jVzaMyek+hKK0sT/OE+W/fR5V9YT5QlHFJCf5
-IUIfDCpBZrBpsOTwsUm8eL0krLiBjYf0HgH5oFBc7aF4w1kuUJjlsJ68bzO9mLEF
-HXDaOWbe00+7BMMDnyuEyLN8KaAGiN8x0NQRX+nTAjCdPs6E0NftcXtznWBID6tA
-j5m7qjsoGurj6TlDsBJb1A==
+c3RuYW1lMCAXDTI0MTAwODExNTExMloYDzI0MDgwMTI5MTE1MTEyWjBiMQswCQYD
+VQQGEwJYWTEXMBUGA1UEBwwOQ2FzdGxlIEFudGhyYXgxIzAhBgNVBAoMGlB5dGhv
+biBTb2Z0d2FyZSBGb3VuZGF0aW9uMRUwEwYDVQQDDAxmYWtlaG9zdG5hbWUwggGi
+MA0GCSqGSIb3DQEBAQUAA4IBjwAwggGKAoIBgQCtFmmyQ+HjjeBXUE61fTenp2C9
+cvHzZSTFvKNeKZ2ZVZzH1HFnMBlTXGlXybSi2PhfxNYo5JrNGW4vZADh/eIFOONv
+PebQBONi4B1188Mb1RHgyIMtl/gOLF+L9DkStFb2eJ3fFInjNh5byhhpcOH1AmPC
+siLeCAO3qc9qeChmJ4hAy1xmx74yQkOGzu0hKZ9d5QNNemCpPKThJ+X8+PCY+FRO
+bAdKJ56er2BjkdaUB/Mp6BBLokYs917VdnH6TiicqfrUsjh36XpOG35/bW9jsQRp
+beGkMIW6vn9GEYT79d4+FWdl9SxTfcSy7tn35/SvtIYDByWLc4IJizTuFV91pGms
+XSav4YVF1hLC5cy8iEfKrdAl1kzamHfHKuY+P+sbwSQHPn5Z5xyUVr+odU0t7+YE
+xBKLG8zHkQ+h2bwEeFy6H9uYQZFhBLOHrkkWSPYLKjzch6DyNkTp+5cGWLOkcs8X
+t0mjG2gzUlgwIYWHkq7wE9jxz3/tJ3MGf2CNDxsCAwEAAaM6MDgwFwYDVR0RBBAw
+DoIMZmFrZWhvc3RuYW1lMB0GA1UdDgQWBBSAf/Z+TUHMOcr020NGG4geSnlNhTAN
+BgkqhkiG9w0BAQsFAAOCAYEAIia0ULQmC510p78HZbiOb2BV8q+0AY0l6Cn/FRIL
+Voqy7uB5oEYdDisla8epmBTU35+JmfrRHbP6IuSqKdcGj8VqsjZljhntSrB7rw4O
+IqjbnxnfEuREjY2w+WGLvvdtVGXCBgfRmIItORFKpoOvLzLIi1lXeDq8QL97K4nM
+tPsZpzILCBCoXmhh0MweCCNe1HSD8q6EbSDjVoxraBl0YK/l1ID08Fi5fwdddRX7
+txfx5NtoWWbsLZY0GdBtQmRCifs7P9lyhjUd87bJGd8WCBE4IzLwJiHEyNPI4WHe
+8jmvKD/zO7mKxT9/jF7IBqwTHgQQ1uaRGytiXjRlfPu4Ez8ASR6rP7Hlua7h0Ba7
+OcDPcgM8rzN4zcfsvZ+8Cd84HXFjHhV6ZdRPbBWFWd8TlDufrWNuY4SyOtkyfE5E
+lWcoRnkBGBaooZNcd72ZwZVO0gAS31bgs8ju+k02GIDLkuZSRNPeFsRQbcMu1Mhc
+cFteFsqniLhzpkWJVQQgeGlV
 -----END CERTIFICATE-----
diff --git a/Lib/test/certdata/keycert3.pem b/Lib/test/certdata/keycert3.pem
index 20d9bd14e96..097dc9f8e88 100644
--- a/Lib/test/certdata/keycert3.pem
+++ b/Lib/test/certdata/keycert3.pem
@@ -1,42 +1,42 @@
 -----BEGIN PRIVATE KEY-----
-MIIG/gIBADANBgkqhkiG9w0BAQEFAASCBugwggbkAgEAAoIBgQCgKihxC+2g7d7M
-JfIUBfFWiuMwxg0WhdxPyGUzMAjexbEOHo0ojntxPdH9KYRwiKRKb9jnmzXp2CKT
-hqBYJIetq/3LYZp4bvDJ/hVCL9e4jqu1l+wd9DkqhKZ69b6C1/d12JAKvC5TIT+/
-b7EglYU8KMNx2WO5KxIJeVpX68jn49YtUzg0hT0QiXj4eugbDk1L1f99xgvkHaVW
-VQxi6MFNWHJq/xXUb8E/hd/Q3oadN1BXMWl9P46D4R+YGKQQdZFkwEJsbqijFvWW
-bOoaz7TFxf8n0q616803aXLfaWikfEXLnznEvKo7vyEivtT/y14Nm+SiR3nS6E0y
-Dt8gmeHdaHcrmQT+yQ6yNOYDCcfeYM+rBuvOUHPudjMy0k8K/0IPjDo0KActKPH0
-UVbyDBMKDdGQ2+LhRFLsGXHlD9b05PxhqTULe3LeK6KZ+iuGbWtwVLaL5S42WiCA
-YXNShE1Ko0Q7wugAippXCf+aWP3Wx9ZTrsfiDBbIfnY5mlfdG90CAwEAAQKCAYAA
-ogoE4FoxD5+YyPGa+KcKg4QAVlgI5cCIJC+aMy9lyfw4JRDDv0RnnynsSTS3ySJ1
-FNoTmD5vTSZd1ONfVc2fdxWKrzkQDsgu1C07VLsShKXTEuWg/K0ZKOsLg1scY0Qc
-GB4BnNrGA1SgKg3WJiEfqr2S/pvxSGVK2krsHAdwOytGhJStSHWEUjbDLKEsMjNG
-AHOBCL5VSXS00aM55NeWuanCGH36l/J4kMvgpHB9wJE1twFGuHCUvtgEHtzPH9fQ
-plmI0QDREm6UE6Qh01lxmwx3Xc5ASBURmxs+bxpk94BPRpj8/eF2HPiJalrkJksj
-Xk3QQ7k23v6XnmHKV3QqpjUgJTdbuMoTrVMu14cIH6FtXfwVhtthPnCI8rk5Lh8N
-cqLC7HT+NE1JyygzuMToOHMmSJTQ8L6BTIaRCZjvGTPYaZfFgeMHvvhAJtP5zAcc
-xQzyCyNBU8RdPGT8tJTyDUIRs20poqe7dKrPEIocKJX7tvNSI2QxkQ96Adxo1gEC
-gcEAvI8m6QCDGgDWI8yTH9EvZQwq+tF8I+WMC+jbPuDwKg5ZKC7VjRO//9JzPY+c
-TxmLnQu64OkECHbu7pswDBbtnPMbodF9inYEY5RkfufEjEMJGEdkoBJWnNx78EkV
-bcffWik0wXwdt6jd1CAnjmS9qaPz0T1NV8m5rQQn5JUYXlC9eB2kOojZYLbZBl3g
-xUSRbIqHC7h8HuyAU26EPiprHsIxrOpbxABFOdvo2optr50U7X10Eqb4mRQ4z22W
-ojJdAoHBANlzJjjEgGVB9W50pJqkTw8wXiTUG8AmhqrVvqEttLPcWpK6QwRkRC+i
-5N1iUObf/kOlun2gNfHF6gM68Ja9wb2eGvE5sApq9hPpyYF0LS3g8BbJ9GOs6NU9
-BfM1CkPrDCdc4kzlUpDibvc6Fc9raCqvrZRlKEukqQS8dumVdb74IaPsP6q8sZMz
-jibOk0eUrbx2c5vEnd0W8zMeNCuCwO1oXbfenPp/GLX9ZRlolWS/3cQoZYOSQc9J
-lFQYkxL3gQKBwQCy3Pwk9AZoqTh4dvtsqArUSImQqRygFIQXXAh1ifxneHrcYijS
-jVSIwEHuuIamhe3oyBK6fG8F9IPLtUwLe8hkJDwm8Misiiy5pS77LrFD9+btr/Nk
-4GBmpcOveDQqkflt1j6j9y9dY4MhUGsVaLx86fhDmGoAh2tpEtMgwsl91gsUoNGD
-cQL6+he+MVkg510nX/Sgipy63M8R1Xj+W1CHueBTTXBE6ZjBPLiSbdOETXZnnaR4
-eQjCdOs64JKOQ0UCgcBZ4kFAYel48aTT/Z801QphCus/afX2nXY5E5Vy5oO1fTZr
-RFcDb7bHwhu8bzFl3d0qdUz7NMhXoimzIB/nD5UQHlSgtenQxJnnbVIAEtfCCSL1
-KJG+yfCMhGb7O0d8/6HMe5aHlptkjFS2GOp/DLTIQEoN9yqK6gt7i7PTphY/1C2D
-ptpCZzE32a2+2NEEW67dIlFzZ/ihNSVeUfPasHezKtricECPQw4h3BZ4RETMmoq+
-1LvxgPl3B8EqaeYRhwECgcEAjjp/0hu/ukQhiNeR5a9p1ECBFP8qFh6Cpo0Az/DT
-1kX0qU8tnT3cYYhwbVGwLxn2HVRdLrbjMj/t88W/LM2IaQ162m7TvvBMxNmr058y
-sW/LADp5YWWsY70EJ8AfaTmdQriqKsNiLLpNdgcm1bkwHJ1CNlvEpDs1OOI3cCGi
-BEuUmeKxpRhwCaZeaR5tREmbD70My+BMDTDLfrXoKqzl4JrRua4jFTpHeZaFdkkh
-gDq3K6+KpVREQFEhyOtIB2kk
+MIIG/gIBADANBgkqhkiG9w0BAQEFAASCBugwggbkAgEAAoIBgQDuNnCqYWoguzKI
+B3PwOsoRzI8wgNdxx3RiIJSItFISlAgB4XkYzPBpi5nFR8GCqq7IUQQ+iYwdZa3y
+H6X11IdlrCx4gDdQFSFOegnG41oqv7GwBEFvq6xlowpoaGw+5/8/sJX/VU44rL9/
+fiMVTbehMhMS/z5nTSYSACV7sRXnwW4T6l2Od77FzPBjnaFFDNr5GIoiD4mNSJ35
+t05tliGcz0IyE5TGR6kIEFNIH5theHoJJ4JC4uLyWJweJpxDx10njWRwKN/tXm8F
+nHQPMRAUl2wM07QZEI1yfzUr00/oG2dpPnPyNh+6p2ld8JS0g2/Pd2pQL8OtmM2c
+DcN5E+qCEW1UVIJ5//ad8pUcoQwyRIBROJbakqv6FcVTdgTogoq5Vu+T6TVFLSIS
+vVvpsV0MtT/H9/9TtCnqOwliE8s8kb3NjQT8e72VHNd43bVPE4DeQ+XlbMoKzV+G
+OmSHSfzSOZB9kScSmGd5YD8783TbL8/7Nn1ERQdWqaixGI36+BECAwEAAQKCAYBV
+Ubhevg9V89ZwdELpSxUu9NZgZ/VCck7UCplIsVUoBE8t5UULRfPhybdkuoOrulhp
+tOLRR1ChAtcffohhmSJ5nwY6jqnBDCBmzD0OOEYGQ6xvv8Z0KcfQi2nh5WzHxy5b
+8HJ5BmPC1tSr5FDKg5B+ssG0Lyl5tF8rWVQTjmSrIlO73Fhv+6GflPyQoVeutKEF
+UO3Ar1H0AYtbcnUruPcHBBDQgMTrk6UOF1LM5U0wxwbmmnkEXeEtLeGUxv13JUMe
+QTrSw0P+hn5uiDMwY5lI212ayorbwyNuzU0hGW7j98qa/S9MVSeRwv4bsbtBqwtT
+ZVGL2TogjeJ+8+qDlv5tf3crD1pV0yu7uVUeIGrJZJdiiMM6N7/x3cIJtrLDaF1w
+9kUqdQGWDWwRV3w0FaeXDVlUTJ3VFTZIinLo1Vmd3AXLn97eVy+68DWD6ELlMkfF
+ro3bQbQu59DGswDF9+mMauhgvljnxY/wUnkyp8LGZt8w/RU/op8LcvPKFjQfX6UC
+gcEA/RClguU/JTWQSF4Vjy5+DmrzSCXabrO7986lkOwPXEaXLsF2pGOU+sbxffXZ
+PCQ4zU6aNYBMtNWLrVqBrPnI78XZQbmSG7zUDxWwmr1ttuSHGthdaZUVTOsFsnpE
+R+1lj20G2T2ankzv0ICFz7BWyaYwyzDrABwuP189b3juuX6xGLlCO25/AnK+iTXQ
+WF4ZURZiwDg4WpxvPsE2FFglN09TtDDCeQw/zv7Jh6jWtHZfivfv/wR8ILu72gde
+LdinAoHBAPD5slojp2St6iWTaxcYYBc+4x+Rv7oyxeAyM/00iIAnf19oaAw3jki1
+yz6zeNnhaZuwa6ruvhJAESPc+pXkmoPpQ1yIRjKZc3jPVoaxYuSPgUEbHV6BQbjD
+clIoGkC6ISsjanMq8Z3pK7e2bxY4mxGRQIFSFnTeK8m8nzq5dYisVtxxJFnV2fDG
+NWDMdDYBh52vpkPjnm5OoOuilkEH2ygtZlT6bKAbnhi/FVjYCHk46inaYx8PakMu
+LnvZI0OIhwKBwBGzYGBPeKM5o+Xr7sYdEmQfxvR88VJc8ADdS2dfm5NwvJJgpdPJ
+w1nnIG0XDSLPxclWfiLP3o2ngiWV9wwKTKu4wwF94WJfStXjRn8MUOhCA9E04RPJ
+gbvnlHZvZudBC6GElr4LOQ1phDypQLLOOsPQBAmyWj2fuvxjxQBPDSOcYPbBvog5
+qliZfgpK4U/NBShO0IlxZT+xQXa6PPYfVDsSKWCpKHEfEjeASshaXuowfW5S+U51
+GdmQSAtwCH5ccQKBwQCOLgW5gYfms2aPvSdWfR9VF9nSaqCBMCvoWDasky5mzucs
+V+HsM2tUI09EM4h+pa02GyWruSmUgxCZ5GxFvJgedKc2FYG1oSysf0lCN69tw+4z
+h9gQRpuMdGUjbF3xCuE/HqpUQWZGEamlv5JTvhpghx9ULibp1Zxob05Ty9E5TtYB
+QxB7oN3yXkBoWLnIk6Z8t4KWU9rKosH3xfp5bDU2w3K5ePhWj3T8jOH/hZeaTqZ7
+A0uwq9u6v6jVkgxocEkCgcEAhyMPyiMqqq55qD6JlPY4zf4mWQJS4MnmWexH/5N1
+a6uogerwZnIjuH0/wNc2qzQSOwVJRqjlxRZbEkWST0JK/meXZ+e0nqaROWICutO6
+ciIf2wVjTzn1f85DHwPhUf3P2zIfpVFh+XuvSb32J+pzNwK40gMhirYMDSbsm/RQ
+JrJHQwEX9BvI6IP5kaMOMlSwiG3Soo3MxeJWmozkz09+cs7BwMFsUKOdqruJHSaw
+/Q06DQ9u9UyjmLyKv3IkN/cK
 -----END PRIVATE KEY-----
 Certificate:
     Data:
@@ -47,38 +47,38 @@ Certificate:
         Issuer: C=XY, O=Python Software Foundation CA, CN=our-ca-server
         Validity
             Not Before: Aug 29 14:23:16 2018 GMT
-            Not After : Oct 28 14:23:16 2037 GMT
+            Not After : Oct 28 14:23:16 2525 GMT
         Subject: C=XY, L=Castle Anthrax, O=Python Software Foundation, CN=localhost
         Subject Public Key Info:
             Public Key Algorithm: rsaEncryption
                 Public-Key: (3072 bit)
                 Modulus:
-                    00:a0:2a:28:71:0b:ed:a0:ed:de:cc:25:f2:14:05:
-                    f1:56:8a:e3:30:c6:0d:16:85:dc:4f:c8:65:33:30:
-                    08:de:c5:b1:0e:1e:8d:28:8e:7b:71:3d:d1:fd:29:
-                    84:70:88:a4:4a:6f:d8:e7:9b:35:e9:d8:22:93:86:
-                    a0:58:24:87:ad:ab:fd:cb:61:9a:78:6e:f0:c9:fe:
-                    15:42:2f:d7:b8:8e:ab:b5:97:ec:1d:f4:39:2a:84:
-                    a6:7a:f5:be:82:d7:f7:75:d8:90:0a:bc:2e:53:21:
-                    3f:bf:6f:b1:20:95:85:3c:28:c3:71:d9:63:b9:2b:
-                    12:09:79:5a:57:eb:c8:e7:e3:d6:2d:53:38:34:85:
-                    3d:10:89:78:f8:7a:e8:1b:0e:4d:4b:d5:ff:7d:c6:
-                    0b:e4:1d:a5:56:55:0c:62:e8:c1:4d:58:72:6a:ff:
-                    15:d4:6f:c1:3f:85:df:d0:de:86:9d:37:50:57:31:
-                    69:7d:3f:8e:83:e1:1f:98:18:a4:10:75:91:64:c0:
-                    42:6c:6e:a8:a3:16:f5:96:6c:ea:1a:cf:b4:c5:c5:
-                    ff:27:d2:ae:b5:eb:cd:37:69:72:df:69:68:a4:7c:
-                    45:cb:9f:39:c4:bc:aa:3b:bf:21:22:be:d4:ff:cb:
-                    5e:0d:9b:e4:a2:47:79:d2:e8:4d:32:0e:df:20:99:
-                    e1:dd:68:77:2b:99:04:fe:c9:0e:b2:34:e6:03:09:
-                    c7:de:60:cf:ab:06:eb:ce:50:73:ee:76:33:32:d2:
-                    4f:0a:ff:42:0f:8c:3a:34:28:07:2d:28:f1:f4:51:
-                    56:f2:0c:13:0a:0d:d1:90:db:e2:e1:44:52:ec:19:
-                    71:e5:0f:d6:f4:e4:fc:61:a9:35:0b:7b:72:de:2b:
-                    a2:99:fa:2b:86:6d:6b:70:54:b6:8b:e5:2e:36:5a:
-                    20:80:61:73:52:84:4d:4a:a3:44:3b:c2:e8:00:8a:
-                    9a:57:09:ff:9a:58:fd:d6:c7:d6:53:ae:c7:e2:0c:
-                    16:c8:7e:76:39:9a:57:dd:1b:dd
+                    00:ee:36:70:aa:61:6a:20:bb:32:88:07:73:f0:3a:
+                    ca:11:cc:8f:30:80:d7:71:c7:74:62:20:94:88:b4:
+                    52:12:94:08:01:e1:79:18:cc:f0:69:8b:99:c5:47:
+                    c1:82:aa:ae:c8:51:04:3e:89:8c:1d:65:ad:f2:1f:
+                    a5:f5:d4:87:65:ac:2c:78:80:37:50:15:21:4e:7a:
+                    09:c6:e3:5a:2a:bf:b1:b0:04:41:6f:ab:ac:65:a3:
+                    0a:68:68:6c:3e:e7:ff:3f:b0:95:ff:55:4e:38:ac:
+                    bf:7f:7e:23:15:4d:b7:a1:32:13:12:ff:3e:67:4d:
+                    26:12:00:25:7b:b1:15:e7:c1:6e:13:ea:5d:8e:77:
+                    be:c5:cc:f0:63:9d:a1:45:0c:da:f9:18:8a:22:0f:
+                    89:8d:48:9d:f9:b7:4e:6d:96:21:9c:cf:42:32:13:
+                    94:c6:47:a9:08:10:53:48:1f:9b:61:78:7a:09:27:
+                    82:42:e2:e2:f2:58:9c:1e:26:9c:43:c7:5d:27:8d:
+                    64:70:28:df:ed:5e:6f:05:9c:74:0f:31:10:14:97:
+                    6c:0c:d3:b4:19:10:8d:72:7f:35:2b:d3:4f:e8:1b:
+                    67:69:3e:73:f2:36:1f:ba:a7:69:5d:f0:94:b4:83:
+                    6f:cf:77:6a:50:2f:c3:ad:98:cd:9c:0d:c3:79:13:
+                    ea:82:11:6d:54:54:82:79:ff:f6:9d:f2:95:1c:a1:
+                    0c:32:44:80:51:38:96:da:92:ab:fa:15:c5:53:76:
+                    04:e8:82:8a:b9:56:ef:93:e9:35:45:2d:22:12:bd:
+                    5b:e9:b1:5d:0c:b5:3f:c7:f7:ff:53:b4:29:ea:3b:
+                    09:62:13:cb:3c:91:bd:cd:8d:04:fc:7b:bd:95:1c:
+                    d7:78:dd:b5:4f:13:80:de:43:e5:e5:6c:ca:0a:cd:
+                    5f:86:3a:64:87:49:fc:d2:39:90:7d:91:27:12:98:
+                    67:79:60:3f:3b:f3:74:db:2f:cf:fb:36:7d:44:45:
+                    07:56:a9:a8:b1:18:8d:fa:f8:11
                 Exponent: 65537 (0x10001)
         X509v3 extensions:
             X509v3 Subject Alternative Name: 
@@ -90,9 +90,9 @@ Certificate:
             X509v3 Basic Constraints: critical
                 CA:FALSE
             X509v3 Subject Key Identifier: 
-                3F:B1:E9:4F:A0:BE:30:66:3E:0A:18:C8:0F:47:1A:4F:34:6A:0F:42
+                16:22:C9:AA:20:D4:F4:8E:ED:9C:A6:BB:23:F5:F2:29:44:ED:F2:1E
             X509v3 Authority Key Identifier: 
-                keyid:F3:EC:94:8E:F2:8E:30:C4:8E:68:C2:BF:8E:6A:19:C0:C1:9F:76:65
+                keyid:C0:0A:2B:28:43:DE:5F:C9:7D:47:E5:47:9B:36:F2:65:8C:67:3B:E2
                 DirName:/C=XY/O=Python Software Foundation CA/CN=our-ca-server
                 serial:CB:2D:80:99:5A:69:52:5B
             Authority Information Access: 
@@ -103,59 +103,59 @@ Certificate:
                   URI:http://testca.pythontest.net/testca/revocation.crl
     Signature Algorithm: sha256WithRSAEncryption
     Signature Value:
-        ca:34:ba:c5:d0:cf:27:31:32:d6:0d:27:30:b8:db:17:df:b7:
-        39:a7:bb:b1:3b:86:c4:31:fd:fb:ab:db:63:1a:cc:90:ab:b9:
-        4e:ab:34:49:0c:5e:8c:3e:70:a3:a7:6b:2f:a7:9a:25:7b:01:
-        5a:18:96:48:76:f8:36:78:74:fa:bc:7d:68:7f:e5:ca:a6:9d:
-        7b:dc:72:bd:a3:25:51:17:68:e8:e9:d7:02:86:2c:7d:16:7c:
-        b5:dc:44:b2:0a:e3:f7:c9:33:a3:51:36:83:bc:d4:70:cd:84:
-        91:9f:06:ba:2d:d2:05:0a:65:c3:d9:55:09:a8:b8:09:69:bb:
-        93:86:c2:b7:c2:90:74:7c:bf:f0:5d:bc:0e:63:13:8c:eb:fa:
-        0f:f1:fa:e5:12:70:4d:0c:eb:8c:2e:a2:42:42:00:04:0f:fc:
-        f9:1f:41:9c:63:78:f0:66:93:b2:8f:2e:e8:93:1c:50:cb:2d:
-        7f:b6:ba:57:6f:52:62:d7:39:0b:09:82:ab:a6:53:4d:cc:05:
-        3e:19:f0:d4:c0:ce:a9:ad:10:ce:b9:71:e4:8f:f2:5a:3c:65:
-        ba:dc:cb:e0:04:90:2b:a5:15:a6:7d:da:dc:a3:b5:b7:bc:a0:
-        de:30:4e:64:cb:17:0d:3a:a0:52:d2:67:3b:a2:3a:00:d5:39:
-        aa:61:75:52:9f:fe:9b:c0:e8:a0:69:af:a8:b3:a3:1d:0a:40:
-        52:04:e7:3d:c0:00:96:5f:2b:33:06:0c:30:f6:d3:18:72:ee:
-        38:d0:64:d3:00:86:37:ec:4f:e9:38:49:e6:01:ff:a2:9a:7c:
-        dc:6a:d3:cb:a8:ba:58:fb:c3:86:78:47:f1:06:a6:45:e7:53:
-        de:99:1d:81:e6:bc:63:74:46:7c:70:23:57:29:60:70:9a:cc:
-        6f:00:8e:c2:bf:6a:73:7d:6e:b0:62:e6:dc:13:1a:b9:fe:0f:
-        c2:d1:06:a1:79:62:7f:b6:30:a9:03:d0:47:57:25:db:48:10:
-        d1:cf:fb:7d:ac:3d
+        43:82:1f:18:b4:cb:7a:b7:4e:ac:c3:65:2e:b7:57:3a:f0:78:
+        b3:b2:20:3e:bd:7b:24:f7:e7:17:cc:62:c0:b8:63:f0:2e:30:
+        0c:54:be:c9:94:7c:54:d4:40:06:6e:92:9d:72:2c:44:f5:e3:
+        c1:4a:3f:26:e4:21:ca:ba:ef:4f:a3:50:56:ee:89:5c:dc:5b:
+        98:bc:0c:e9:db:16:98:f0:4c:3f:65:b9:d9:e0:2e:bd:83:9e:
+        c7:1b:f7:4f:87:5f:75:ff:67:5d:0a:ff:ce:fa:0b:f1:d5:8b:
+        58:23:2b:92:27:b8:15:ff:66:c2:f9:68:e2:ed:64:a0:4a:e0:
+        42:8b:ac:35:6a:67:64:f5:cb:a9:00:37:20:56:dd:3a:02:6e:
+        d8:0f:b4:5d:ff:92:a3:0d:65:fc:2e:ab:4e:37:bc:7e:d6:5b:
+        1c:55:78:a0:6e:a9:2e:55:31:cf:61:f0:1b:4c:fe:fe:60:75:
+        76:e8:d9:a1:f5:14:f0:43:33:4d:52:05:be:33:ff:da:31:94:
+        bd:0d:e5:4d:a8:ee:d1:f3:92:34:c2:36:91:37:3a:6d:ec:20:
+        df:b3:9e:a2:5d:d0:f0:a1:e2:ff:b7:85:ce:09:e3:c8:4a:6a:
+        93:a4:ae:ec:c1:67:42:f7:8e:2f:64:ca:d7:76:72:bf:3f:ef:
+        64:ff:10:dd:a2:3e:2d:f5:aa:02:cf:31:f0:6d:93:6b:56:4c:
+        b0:88:95:54:dc:d4:ac:dc:c1:88:27:8b:d9:9c:4e:66:93:f8:
+        dd:5e:74:41:26:9a:ef:e8:c8:46:5c:d5:f4:fc:cd:cc:67:c7:
+        33:62:2e:70:9b:d1:39:de:34:fd:ad:9d:b9:48:61:e7:89:53:
+        62:62:f0:40:6c:68:2f:e1:da:40:61:2a:50:af:c9:41:6d:98:
+        16:af:cb:63:03:ec:04:99:e0:39:98:60:ae:aa:6a:57:9b:25:
+        73:03:16:bf:78:c8:d7:2f:eb:fc:64:7f:c7:78:8c:34:15:5b:
+        66:40:98:86:e6:0a
 -----BEGIN CERTIFICATE-----
-MIIF8TCCBFmgAwIBAgIJAMstgJlaaVJcMA0GCSqGSIb3DQEBCwUAME0xCzAJBgNV
+MIIF8zCCBFugAwIBAgIJAMstgJlaaVJcMA0GCSqGSIb3DQEBCwUAME0xCzAJBgNV
 BAYTAlhZMSYwJAYDVQQKDB1QeXRob24gU29mdHdhcmUgRm91bmRhdGlvbiBDQTEW
-MBQGA1UEAwwNb3VyLWNhLXNlcnZlcjAeFw0xODA4MjkxNDIzMTZaFw0zNzEwMjgx
-NDIzMTZaMF8xCzAJBgNVBAYTAlhZMRcwFQYDVQQHDA5DYXN0bGUgQW50aHJheDEj
-MCEGA1UECgwaUHl0aG9uIFNvZnR3YXJlIEZvdW5kYXRpb24xEjAQBgNVBAMMCWxv
-Y2FsaG9zdDCCAaIwDQYJKoZIhvcNAQEBBQADggGPADCCAYoCggGBAKAqKHEL7aDt
-3swl8hQF8VaK4zDGDRaF3E/IZTMwCN7FsQ4ejSiOe3E90f0phHCIpEpv2OebNenY
-IpOGoFgkh62r/cthmnhu8Mn+FUIv17iOq7WX7B30OSqEpnr1voLX93XYkAq8LlMh
-P79vsSCVhTwow3HZY7krEgl5WlfryOfj1i1TODSFPRCJePh66BsOTUvV/33GC+Qd
-pVZVDGLowU1Ycmr/FdRvwT+F39Dehp03UFcxaX0/joPhH5gYpBB1kWTAQmxuqKMW
-9ZZs6hrPtMXF/yfSrrXrzTdpct9paKR8RcufOcS8qju/ISK+1P/LXg2b5KJHedLo
-TTIO3yCZ4d1odyuZBP7JDrI05gMJx95gz6sG685Qc+52MzLSTwr/Qg+MOjQoBy0o
-8fRRVvIMEwoN0ZDb4uFEUuwZceUP1vTk/GGpNQt7ct4ropn6K4Zta3BUtovlLjZa
-IIBhc1KETUqjRDvC6ACKmlcJ/5pY/dbH1lOux+IMFsh+djmaV90b3QIDAQABo4IB
-wDCCAbwwFAYDVR0RBA0wC4IJbG9jYWxob3N0MA4GA1UdDwEB/wQEAwIFoDAdBgNV
-HSUEFjAUBggrBgEFBQcDAQYIKwYBBQUHAwIwDAYDVR0TAQH/BAIwADAdBgNVHQ4E
-FgQUP7HpT6C+MGY+ChjID0caTzRqD0IwfQYDVR0jBHYwdIAU8+yUjvKOMMSOaMK/
-jmoZwMGfdmWhUaRPME0xCzAJBgNVBAYTAlhZMSYwJAYDVQQKDB1QeXRob24gU29m
-dHdhcmUgRm91bmRhdGlvbiBDQTEWMBQGA1UEAwwNb3VyLWNhLXNlcnZlcoIJAMst
-gJlaaVJbMIGDBggrBgEFBQcBAQR3MHUwPAYIKwYBBQUHMAKGMGh0dHA6Ly90ZXN0
-Y2EucHl0aG9udGVzdC5uZXQvdGVzdGNhL3B5Y2FjZXJ0LmNlcjA1BggrBgEFBQcw
-AYYpaHR0cDovL3Rlc3RjYS5weXRob250ZXN0Lm5ldC90ZXN0Y2Evb2NzcC8wQwYD
-VR0fBDwwOjA4oDagNIYyaHR0cDovL3Rlc3RjYS5weXRob250ZXN0Lm5ldC90ZXN0
-Y2EvcmV2b2NhdGlvbi5jcmwwDQYJKoZIhvcNAQELBQADggGBAMo0usXQzycxMtYN
-JzC42xfftzmnu7E7hsQx/fur22MazJCruU6rNEkMXow+cKOnay+nmiV7AVoYlkh2
-+DZ4dPq8fWh/5cqmnXvccr2jJVEXaOjp1wKGLH0WfLXcRLIK4/fJM6NRNoO81HDN
-hJGfBrot0gUKZcPZVQmouAlpu5OGwrfCkHR8v/BdvA5jE4zr+g/x+uUScE0M64wu
-okJCAAQP/PkfQZxjePBmk7KPLuiTHFDLLX+2uldvUmLXOQsJgqumU03MBT4Z8NTA
-zqmtEM65ceSP8lo8Zbrcy+AEkCulFaZ92tyjtbe8oN4wTmTLFw06oFLSZzuiOgDV
-OaphdVKf/pvA6KBpr6izox0KQFIE5z3AAJZfKzMGDDD20xhy7jjQZNMAhjfsT+k4
-SeYB/6KafNxq08uoulj7w4Z4R/EGpkXnU96ZHYHmvGN0RnxwI1cpYHCazG8AjsK/
-anN9brBi5twTGrn+D8LRBqF5Yn+2MKkD0EdXJdtIENHP+32sPQ==
+MBQGA1UEAwwNb3VyLWNhLXNlcnZlcjAgFw0xODA4MjkxNDIzMTZaGA8yNTI1MTAy
+ODE0MjMxNlowXzELMAkGA1UEBhMCWFkxFzAVBgNVBAcMDkNhc3RsZSBBbnRocmF4
+MSMwIQYDVQQKDBpQeXRob24gU29mdHdhcmUgRm91bmRhdGlvbjESMBAGA1UEAwwJ
+bG9jYWxob3N0MIIBojANBgkqhkiG9w0BAQEFAAOCAY8AMIIBigKCAYEA7jZwqmFq
+ILsyiAdz8DrKEcyPMIDXccd0YiCUiLRSEpQIAeF5GMzwaYuZxUfBgqquyFEEPomM
+HWWt8h+l9dSHZawseIA3UBUhTnoJxuNaKr+xsARBb6usZaMKaGhsPuf/P7CV/1VO
+OKy/f34jFU23oTITEv8+Z00mEgAle7EV58FuE+pdjne+xczwY52hRQza+RiKIg+J
+jUid+bdObZYhnM9CMhOUxkepCBBTSB+bYXh6CSeCQuLi8licHiacQ8ddJ41kcCjf
+7V5vBZx0DzEQFJdsDNO0GRCNcn81K9NP6BtnaT5z8jYfuqdpXfCUtINvz3dqUC/D
+rZjNnA3DeRPqghFtVFSCef/2nfKVHKEMMkSAUTiW2pKr+hXFU3YE6IKKuVbvk+k1
+RS0iEr1b6bFdDLU/x/f/U7Qp6jsJYhPLPJG9zY0E/Hu9lRzXeN21TxOA3kPl5WzK
+Cs1fhjpkh0n80jmQfZEnEphneWA/O/N02y/P+zZ9REUHVqmosRiN+vgRAgMBAAGj
+ggHAMIIBvDAUBgNVHREEDTALgglsb2NhbGhvc3QwDgYDVR0PAQH/BAQDAgWgMB0G
+A1UdJQQWMBQGCCsGAQUFBwMBBggrBgEFBQcDAjAMBgNVHRMBAf8EAjAAMB0GA1Ud
+DgQWBBQWIsmqINT0ju2cprsj9fIpRO3yHjB9BgNVHSMEdjB0gBTACisoQ95fyX1H
+5UebNvJljGc74qFRpE8wTTELMAkGA1UEBhMCWFkxJjAkBgNVBAoMHVB5dGhvbiBT
+b2Z0d2FyZSBGb3VuZGF0aW9uIENBMRYwFAYDVQQDDA1vdXItY2Etc2VydmVyggkA
+yy2AmVppUlswgYMGCCsGAQUFBwEBBHcwdTA8BggrBgEFBQcwAoYwaHR0cDovL3Rl
+c3RjYS5weXRob250ZXN0Lm5ldC90ZXN0Y2EvcHljYWNlcnQuY2VyMDUGCCsGAQUF
+BzABhilodHRwOi8vdGVzdGNhLnB5dGhvbnRlc3QubmV0L3Rlc3RjYS9vY3NwLzBD
+BgNVHR8EPDA6MDigNqA0hjJodHRwOi8vdGVzdGNhLnB5dGhvbnRlc3QubmV0L3Rl
+c3RjYS9yZXZvY2F0aW9uLmNybDANBgkqhkiG9w0BAQsFAAOCAYEAQ4IfGLTLerdO
+rMNlLrdXOvB4s7IgPr17JPfnF8xiwLhj8C4wDFS+yZR8VNRABm6SnXIsRPXjwUo/
+JuQhyrrvT6NQVu6JXNxbmLwM6dsWmPBMP2W52eAuvYOexxv3T4dfdf9nXQr/zvoL
+8dWLWCMrkie4Ff9mwvlo4u1koErgQousNWpnZPXLqQA3IFbdOgJu2A+0Xf+Sow1l
+/C6rTje8ftZbHFV4oG6pLlUxz2HwG0z+/mB1dujZofUU8EMzTVIFvjP/2jGUvQ3l
+Taju0fOSNMI2kTc6bewg37Oeol3Q8KHi/7eFzgnjyEpqk6Su7MFnQveOL2TK13Zy
+vz/vZP8Q3aI+LfWqAs8x8G2Ta1ZMsIiVVNzUrNzBiCeL2ZxOZpP43V50QSaa7+jI
+RlzV9PzNzGfHM2IucJvROd40/a2duUhh54lTYmLwQGxoL+HaQGEqUK/JQW2YFq/L
+YwPsBJngOZhgrqpqV5slcwMWv3jI1y/r/GR/x3iMNBVbZkCYhuYK
 -----END CERTIFICATE-----
diff --git a/Lib/test/certdata/keycert3.pem.reference b/Lib/test/certdata/keycert3.pem.reference
new file mode 100644
index 00000000000..84d2ca29953
--- /dev/null
+++ b/Lib/test/certdata/keycert3.pem.reference
@@ -0,0 +1,15 @@
+{'OCSP': ('http://testca.pythontest.net/testca/ocsp/',),
+ 'caIssuers': ('http://testca.pythontest.net/testca/pycacert.cer',),
+ 'crlDistributionPoints': ('http://testca.pythontest.net/testca/revocation.crl',),
+ 'issuer': ((('countryName', 'XY'),),
+            (('organizationName', 'Python Software Foundation CA'),),
+            (('commonName', 'our-ca-server'),)),
+ 'notAfter': 'Oct 28 14:23:16 2525 GMT',
+ 'notBefore': 'Aug 29 14:23:16 2018 GMT',
+ 'serialNumber': 'CB2D80995A69525C',
+ 'subject': ((('countryName', 'XY'),),
+             (('localityName', 'Castle Anthrax'),),
+             (('organizationName', 'Python Software Foundation'),),
+             (('commonName', 'localhost'),)),
+ 'subjectAltName': (('DNS', 'localhost'),),
+ 'version': 3}
diff --git a/Lib/test/certdata/keycert4.pem b/Lib/test/certdata/keycert4.pem
index ff4dceac790..fcaa3a1656d 100644
--- a/Lib/test/certdata/keycert4.pem
+++ b/Lib/test/certdata/keycert4.pem
@@ -1,42 +1,42 @@
 -----BEGIN PRIVATE KEY-----
-MIIG/QIBADANBgkqhkiG9w0BAQEFAASCBucwggbjAgEAAoIBgQDGKA1zZDjeNPh2
-J9WHVXXMUf8h5N4/bHCM3CbIaZ1dShkCgfmFWmOtruEihgbfRYaSWZAwCmVAQGjm
-gvUfgOIgsFfM8yO+zDByPhza7XvWPZfEe7mNRFe5ZlYntbeM/vuWCM4VzwDq/mqF
-TFxNRmwInqE7hx0WnfCoQWe9N41hJyl1K0OjADb+SjlpJ0/UJ63hsB+dowGjaaBv
-J8HduQcRqNg8s6FcyJJ8Mjss1uRMFK2j9QrmgbA61XuIPCxzc3J57mW8FN2KsR8D
-2HOhe9nsTGlxp+O5Cudf/RBWB443xcoyduwRXOFTdEAU45MS4tKGP2hzezuxMFQn
-LKARXVW4/gFxZk7kU8TweZUS6LAYPfYJnlfteb6z37LAbtoDvzKUKBEDf/nmoa7C
-uKxSPC5HIKhLbjU/6kuPglSVEfJPJWu2bZJDAkFL85Ot3gPs10EX2lMUy0Jt3tf+
-TaQjEvFZhpKN8KAdYj3eVgOfzIBbQyjotHJjFe9Jkq4q7RoI+ncCAwEAAQKCAYAH
-tRsdRh1Z7JmHOasy+tPDsvhVuWLHMaYlScvAYhJh/W65YSKd56+zFKINlX3fYcp5
-Fz67Yy+uWahXVE2QgFou3KX0u+9ucRiLFXfYheWL3xSMXJgRee0LI/T7tRe7uAHu
-CnoURqKCulIqzLOO1efx1eKasXmVuhEtmjhVpcmDGv8SChSKTIjzgOjqT7QGE9Xq
-eSRhq7mulpq9zWq+/369yG+0SvPs60vTxNovDIaBn/RHSW5FjeDss5QnmYMh/ukN
-dggoKllQlkTzHSxHmKrIJuryZC+bsqvEPUFXN0NMUYcZRvt1lwdjzq/A+w4gDDZG
-7QqAzYMYQZMw9PJeHqu4mxfUX5hJWuAwG5I2eV3kBRheoFw7MxP0tw40fPlFU+Zh
-pRXbKwhMAlIHi0D8NyMn3hkVPyToWVVY3vHRknBB/52RqRq3MjqEFaAZfp0nFkiF
-ytv3Dd5aeBb1vraOIREyhxIxE/qY8CtZC+6JI8CpufLmFXB412WPwl0OrVpWYfEC
-gcEA486zOI46xRDgDw0jqTpOFHzh+3VZ8UoPoiqCjKzJGnrh2EeLvTsXX/GZOj0m
-5zl6RHEGFjm5vKCh2C72Vj/m+AFVy7V9iJRzTYzP8So/3paaqo7ZaROTa6uStxdD
-VPnY1uIgVQz9w5coN4dmr+RLBpFvvWaHp1wuC08YIWxcC9HSTQpbi1EP5eo08fOk
-8reNkDEHxihDGHr1xW0z0qJqK1IVyLP7wDkmapudMZjkjqJSGJwwefV4qyGMTV2b
-suW1AoHBAN6t9n6LBH553MF5iUrNJYxXh/SCom4Zft9aD6W4bZV/xL4XPpKBB4HX
-aWdeI0iYZU9U+CZ88tBoQCt+JMrJ9cz03ENOvA/MBMREwbZ2hKmQgnoDZsV0vNry
-6UsxeQmeNpGQFUz9foVJQVRdQCceN2YEABdehV1HZoSBbuGZkzqGJXrWwaf/ZhpB
-dPYGUGOsczoD2/QLuWy2M7f7v0Ews6Heww3zipWzvdxKE0IpyVs30ZwVi8CRQiWU
-bEcleXP6+wKBwAi3xEwJxV39Q1XQHuk+/fXywYMp/oMpXmfKUKypgBivUy0/r61S
-MZbOXBrKdE6s+GzeFmmLU/xP+WGYinzKfUBIbMwa6e7sH218UgjcoQ0Xnlugk9ld
-kmqwajDvhvgdh5rRlIMsuBlgE33shJV+mxBpSGlrHw3cjTaJlFbTGsKpCO9B0jcG
-pyEZUWVg+ZMASz6VYcLHj6nEKtufTjhlVsLJpWPE34F/rmSuB9n6C+UZeSLP91rz
-dea2pfPf/TFfcQKBwF4DSj9Qx/vxzS7t9fXbuM+QoPitMpCTOQppRpPr0nA8uj6b
-J7LIwPejj3+xsenTVWpx8DanqAgvC3CRWE05iQoYEupj0mhE9Xo7oSE81nOUbFHB
-H+GbkKRLzA0P/Q7/egBouWWA3Kq/K9LHb+9UBYWPiM5U/K9OFs04rCyZHxylSCud
-gbNA08Wf/xZjwgri4t8KhBF75bQtFJbHtY57Vkuv9d/tA4SCl1Tq/UiAxd86KMfi
-HNeXPDsLd89t1eIOgwKBwQDJkqwZXkhwkhoNuHRdzPO/1f5FyKpQxFs+x+OBulzG
-zuwVKIawsLlUR4TBtF7PChOSZSH50VZaBI5kVti79kEtfNjfAzg4kleHrY8jQ/eq
-HludZ3nmiPqqlbH4MH8NWczPEjee6z4ODROsAe31pz3S8YQK7KVoEuSf0+usJ894
-FtzS5wl6POAXTo2QeSNg9zTbb6JjVYcq6KCTnflDm4YEvFKI+ARqAXQHxm05wEOe
-DbKC6hxxQbDaNOvXEAda8wU=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 -----END PRIVATE KEY-----
 Certificate:
     Data:
@@ -47,38 +47,38 @@ Certificate:
         Issuer: C=XY, O=Python Software Foundation CA, CN=our-ca-server
         Validity
             Not Before: Aug 29 14:23:16 2018 GMT
-            Not After : Oct 28 14:23:16 2037 GMT
+            Not After : Oct 28 14:23:16 2525 GMT
         Subject: C=XY, L=Castle Anthrax, O=Python Software Foundation, CN=fakehostname
         Subject Public Key Info:
             Public Key Algorithm: rsaEncryption
                 Public-Key: (3072 bit)
                 Modulus:
-                    00:c6:28:0d:73:64:38:de:34:f8:76:27:d5:87:55:
-                    75:cc:51:ff:21:e4:de:3f:6c:70:8c:dc:26:c8:69:
-                    9d:5d:4a:19:02:81:f9:85:5a:63:ad:ae:e1:22:86:
-                    06:df:45:86:92:59:90:30:0a:65:40:40:68:e6:82:
-                    f5:1f:80:e2:20:b0:57:cc:f3:23:be:cc:30:72:3e:
-                    1c:da:ed:7b:d6:3d:97:c4:7b:b9:8d:44:57:b9:66:
-                    56:27:b5:b7:8c:fe:fb:96:08:ce:15:cf:00:ea:fe:
-                    6a:85:4c:5c:4d:46:6c:08:9e:a1:3b:87:1d:16:9d:
-                    f0:a8:41:67:bd:37:8d:61:27:29:75:2b:43:a3:00:
-                    36:fe:4a:39:69:27:4f:d4:27:ad:e1:b0:1f:9d:a3:
-                    01:a3:69:a0:6f:27:c1:dd:b9:07:11:a8:d8:3c:b3:
-                    a1:5c:c8:92:7c:32:3b:2c:d6:e4:4c:14:ad:a3:f5:
-                    0a:e6:81:b0:3a:d5:7b:88:3c:2c:73:73:72:79:ee:
-                    65:bc:14:dd:8a:b1:1f:03:d8:73:a1:7b:d9:ec:4c:
-                    69:71:a7:e3:b9:0a:e7:5f:fd:10:56:07:8e:37:c5:
-                    ca:32:76:ec:11:5c:e1:53:74:40:14:e3:93:12:e2:
-                    d2:86:3f:68:73:7b:3b:b1:30:54:27:2c:a0:11:5d:
-                    55:b8:fe:01:71:66:4e:e4:53:c4:f0:79:95:12:e8:
-                    b0:18:3d:f6:09:9e:57:ed:79:be:b3:df:b2:c0:6e:
-                    da:03:bf:32:94:28:11:03:7f:f9:e6:a1:ae:c2:b8:
-                    ac:52:3c:2e:47:20:a8:4b:6e:35:3f:ea:4b:8f:82:
-                    54:95:11:f2:4f:25:6b:b6:6d:92:43:02:41:4b:f3:
-                    93:ad:de:03:ec:d7:41:17:da:53:14:cb:42:6d:de:
-                    d7:fe:4d:a4:23:12:f1:59:86:92:8d:f0:a0:1d:62:
-                    3d:de:56:03:9f:cc:80:5b:43:28:e8:b4:72:63:15:
-                    ef:49:92:ae:2a:ed:1a:08:fa:77
+                    00:bf:b8:22:3f:e1:e5:52:08:8a:f1:ff:f1:9c:08:
+                    2c:5e:40:fd:7a:32:d7:f4:c0:0b:88:34:14:7d:b9:
+                    3c:92:17:cb:04:56:84:ba:ac:d0:70:2d:eb:9d:65:
+                    76:87:99:ca:77:8c:ce:cd:d9:ef:46:8c:8f:1d:75:
+                    07:1c:3c:0a:4a:07:08:c0:c6:17:53:e1:77:ae:51:
+                    37:a9:e1:5a:da:29:68:cb:4d:60:ef:00:11:df:09:
+                    51:41:d6:d5:f7:1e:eb:04:59:a4:bc:9f:fa:47:f8:
+                    de:0b:51:f9:f1:4b:71:e7:16:a1:82:e6:26:f6:0d:
+                    28:05:4c:29:cb:41:28:fc:da:25:20:00:27:5f:f3:
+                    b8:99:4e:89:ec:fa:44:6f:a9:8b:1d:c2:9b:20:05:
+                    49:ce:fb:0f:a8:73:9a:3b:36:3d:5b:24:99:53:44:
+                    4b:18:ea:44:06:63:de:1a:b3:8a:42:92:6a:a1:a0:
+                    14:c2:ef:f9:5e:f7:01:46:99:78:a9:45:88:b7:a5:
+                    f4:93:3a:a0:10:25:fa:96:d5:59:50:e0:16:dc:de:
+                    53:79:2f:e3:8d:4e:61:57:3a:04:c9:e6:a8:5a:4b:
+                    c7:20:96:76:04:94:92:35:41:04:da:83:25:90:30:
+                    7b:81:0c:83:29:af:72:2f:ff:9a:94:53:37:48:33:
+                    3a:0c:ae:95:fa:89:e9:f7:19:a9:ff:8f:28:e3:ce:
+                    f3:fd:e6:32:6f:1a:e8:d0:b9:dc:3f:9b:25:ca:f1:
+                    53:94:4e:15:6d:b2:d4:43:14:0d:dc:22:85:78:52:
+                    a3:0e:0f:3f:30:ea:a6:14:d0:63:d8:14:1a:bf:ff:
+                    55:1d:a4:3a:e4:fd:f0:4f:05:ed:cc:2c:94:f6:fa:
+                    c0:7f:91:3c:f0:c7:16:2c:2a:a7:1d:8c:f1:b6:06:
+                    dd:d8:da:79:3b:84:2c:c4:d0:ab:ae:7a:a0:90:3e:
+                    4f:f7:7e:89:98:d5:30:f2:4e:55:8e:ae:20:12:e3:
+                    41:18:b9:ee:51:87:1f:6a:af:c9
                 Exponent: 65537 (0x10001)
         X509v3 extensions:
             X509v3 Subject Alternative Name: 
@@ -90,9 +90,9 @@ Certificate:
             X509v3 Basic Constraints: critical
                 CA:FALSE
             X509v3 Subject Key Identifier: 
-                1C:70:14:B0:20:DD:08:76:A4:3B:56:59:FA:5F:34:F8:36:66:E8:56
+                E4:3D:4C:DB:96:85:CC:90:ED:0F:58:1E:8D:4D:7D:34:6C:4E:11:10
             X509v3 Authority Key Identifier: 
-                keyid:F3:EC:94:8E:F2:8E:30:C4:8E:68:C2:BF:8E:6A:19:C0:C1:9F:76:65
+                keyid:C0:0A:2B:28:43:DE:5F:C9:7D:47:E5:47:9B:36:F2:65:8C:67:3B:E2
                 DirName:/C=XY/O=Python Software Foundation CA/CN=our-ca-server
                 serial:CB:2D:80:99:5A:69:52:5B
             Authority Information Access: 
@@ -103,59 +103,59 @@ Certificate:
                   URI:http://testca.pythontest.net/testca/revocation.crl
     Signature Algorithm: sha256WithRSAEncryption
     Signature Value:
-        75:14:e5:68:45:8d:ed:6c:f1:27:1e:0e:f3:35:ae:0e:60:c1:
-        65:36:62:b8:07:78:e1:b9:8d:7a:50:70:af:06:c9:d4:ee:50:
-        ef:d2:76:b2:a2:b6:cb:dc:a6:18:b5:3d:d2:f7:eb:0e:ec:b7:
-        95:cd:2e:b1:36:6f:a8:9f:b8:4d:ff:ce:8a:c4:8e:62:37:32:
-        80:3e:05:4a:4d:39:87:69:09:00:e8:40:64:d2:9d:f9:1f:9f:
-        ab:67:1f:f9:c6:84:ba:7e:17:6c:8b:8d:08:ee:fb:8a:d7:cd:
-        06:25:72:9f:4e:1a:c2:71:e1:1b:cf:a2:d7:1c:05:12:95:d6:
-        49:4b:e9:95:95:89:cf:68:18:46:a3:ea:0d:9d:8e:ca:1c:28:
-        55:49:6b:c0:4b:58:f5:42:b9:0a:ec:0e:6e:21:a4:ff:60:c0:
-        1b:6e:40:72:d0:a5:c5:b5:db:4e:87:67:3a:31:70:cb:32:84:
-        70:a9:e2:ff:e0:f2:db:cd:03:b4:85:45:d3:07:cc:0f:c7:49:
-        d8:c2:17:eb:73:f7:4a:c0:d9:8c:59:ef:c0:0a:ce:13:0b:84:
-        c9:aa:0d:11:14:b4:e5:74:aa:ec:18:de:5f:26:18:98:4a:76:
-        f0:7f:cd:e6:c4:b5:58:03:03:f5:10:01:5d:8f:63:88:ba:65:
-        d7:b4:7f:5a:1a:51:0e:ed:e5:68:fa:18:03:72:15:a1:ec:27:
-        1f:ea:ac:24:46:18:6e:f1:97:db:4a:f4:d6:a1:91:a0:8c:b0:
-        2f:be:87:3b:44:b0:8d:2a:89:85:5f:f2:d9:e3:2e:66:b2:88:
-        98:04:2c:96:32:38:99:19:a9:83:fd:94:0c:dd:63:d4:1b:60:
-        9d:43:98:35:ac:b4:23:38:de:7f:85:52:57:a0:37:df:a5:cf:
-        be:54:2c:3c:50:27:2b:d4:54:a9:9d:a3:d4:a5:b3:c0:ea:3d:
-        0e:e2:70:6b:fb:cb:a5:56:05:ec:64:72:f0:1a:db:64:01:cb:
-        5d:27:c4:a1:c4:63
+        63:e9:cd:0f:ec:dd:27:a0:fc:76:16:a1:f2:5f:d3:07:9a:3f:
+        97:f4:11:e8:20:e9:3c:dd:16:4f:20:62:71:73:a9:46:3e:85:
+        6e:44:be:9d:08:4b:eb:80:08:d5:1b:93:5f:4a:0f:df:b7:1b:
+        38:e2:2b:5c:68:48:ea:0a:58:5c:36:6c:79:a4:1e:b5:7e:ef:
+        cb:8d:5d:bd:7d:4a:e6:4e:dd:0b:87:10:ff:01:0e:9b:8b:bd:
+        de:1c:9a:25:fb:a2:e1:52:7b:8a:aa:08:37:b2:87:f7:45:9d:
+        0b:ab:11:6b:0c:7f:db:ed:de:cc:1e:86:f0:be:30:25:6b:4b:
+        ff:f5:f2:99:ed:b0:b1:68:c1:44:0b:79:7b:81:95:b5:36:37:
+        12:c4:99:9e:85:e8:2f:2d:cc:cd:d8:c6:f2:20:ec:6a:06:fd:
+        b8:fc:ff:02:11:95:4d:38:0d:42:8b:b2:43:eb:c2:b9:a4:e0:
+        33:f1:da:25:2f:11:cf:57:b9:25:e5:ab:92:f2:b2:b5:11:2f:
+        bd:31:f7:55:eb:96:94:78:5a:ad:9c:8f:56:ec:34:a0:73:9c:
+        01:c2:76:24:e0:f8:b3:c9:23:b9:ea:ab:c3:0a:d3:f8:53:44:
+        c7:12:37:76:44:d7:ee:25:93:f4:1c:1d:7c:fe:06:2c:fa:c5:
+        bb:c6:90:a4:57:fd:09:2e:da:af:f3:ac:e6:6d:7f:03:a1:26:
+        36:9a:51:7d:8d:28:a7:5d:5d:37:57:cc:6a:11:2a:98:1d:57:
+        71:32:6e:98:7c:12:28:ef:5c:2f:26:29:d4:56:0a:b1:23:d9:
+        9d:35:20:1a:ec:cc:51:53:6e:ef:1c:e7:bc:3c:21:e7:64:31:
+        b1:4c:f3:55:b5:c4:93:17:d8:72:5a:05:2e:4a:e5:33:07:0e:
+        7d:cf:22:73:0b:67:9f:b4:82:60:cd:71:f8:76:0c:c4:dc:98:
+        ee:49:f9:03:7f:0d:d8:c6:76:79:3c:28:ed:77:77:d3:7e:d5:
+        aa:1e:6e:2e:df:a5
 -----BEGIN CERTIFICATE-----
-MIIF9zCCBF+gAwIBAgIJAMstgJlaaVJdMA0GCSqGSIb3DQEBCwUAME0xCzAJBgNV
+MIIF+TCCBGGgAwIBAgIJAMstgJlaaVJdMA0GCSqGSIb3DQEBCwUAME0xCzAJBgNV
 BAYTAlhZMSYwJAYDVQQKDB1QeXRob24gU29mdHdhcmUgRm91bmRhdGlvbiBDQTEW
-MBQGA1UEAwwNb3VyLWNhLXNlcnZlcjAeFw0xODA4MjkxNDIzMTZaFw0zNzEwMjgx
-NDIzMTZaMGIxCzAJBgNVBAYTAlhZMRcwFQYDVQQHDA5DYXN0bGUgQW50aHJheDEj
-MCEGA1UECgwaUHl0aG9uIFNvZnR3YXJlIEZvdW5kYXRpb24xFTATBgNVBAMMDGZh
-a2Vob3N0bmFtZTCCAaIwDQYJKoZIhvcNAQEBBQADggGPADCCAYoCggGBAMYoDXNk
-ON40+HYn1YdVdcxR/yHk3j9scIzcJshpnV1KGQKB+YVaY62u4SKGBt9FhpJZkDAK
-ZUBAaOaC9R+A4iCwV8zzI77MMHI+HNrte9Y9l8R7uY1EV7lmVie1t4z++5YIzhXP
-AOr+aoVMXE1GbAieoTuHHRad8KhBZ703jWEnKXUrQ6MANv5KOWknT9QnreGwH52j
-AaNpoG8nwd25BxGo2DyzoVzIknwyOyzW5EwUraP1CuaBsDrVe4g8LHNzcnnuZbwU
-3YqxHwPYc6F72exMaXGn47kK51/9EFYHjjfFyjJ27BFc4VN0QBTjkxLi0oY/aHN7
-O7EwVCcsoBFdVbj+AXFmTuRTxPB5lRLosBg99gmeV+15vrPfssBu2gO/MpQoEQN/
-+eahrsK4rFI8LkcgqEtuNT/qS4+CVJUR8k8la7ZtkkMCQUvzk63eA+zXQRfaUxTL
-Qm3e1/5NpCMS8VmGko3woB1iPd5WA5/MgFtDKOi0cmMV70mSrirtGgj6dwIDAQAB
-o4IBwzCCAb8wFwYDVR0RBBAwDoIMZmFrZWhvc3RuYW1lMA4GA1UdDwEB/wQEAwIF
-oDAdBgNVHSUEFjAUBggrBgEFBQcDAQYIKwYBBQUHAwIwDAYDVR0TAQH/BAIwADAd
-BgNVHQ4EFgQUHHAUsCDdCHakO1ZZ+l80+DZm6FYwfQYDVR0jBHYwdIAU8+yUjvKO
-MMSOaMK/jmoZwMGfdmWhUaRPME0xCzAJBgNVBAYTAlhZMSYwJAYDVQQKDB1QeXRo
-b24gU29mdHdhcmUgRm91bmRhdGlvbiBDQTEWMBQGA1UEAwwNb3VyLWNhLXNlcnZl
-coIJAMstgJlaaVJbMIGDBggrBgEFBQcBAQR3MHUwPAYIKwYBBQUHMAKGMGh0dHA6
-Ly90ZXN0Y2EucHl0aG9udGVzdC5uZXQvdGVzdGNhL3B5Y2FjZXJ0LmNlcjA1Bggr
-BgEFBQcwAYYpaHR0cDovL3Rlc3RjYS5weXRob250ZXN0Lm5ldC90ZXN0Y2Evb2Nz
-cC8wQwYDVR0fBDwwOjA4oDagNIYyaHR0cDovL3Rlc3RjYS5weXRob250ZXN0Lm5l
-dC90ZXN0Y2EvcmV2b2NhdGlvbi5jcmwwDQYJKoZIhvcNAQELBQADggGBAHUU5WhF
-je1s8SceDvM1rg5gwWU2YrgHeOG5jXpQcK8GydTuUO/SdrKitsvcphi1PdL36w7s
-t5XNLrE2b6ifuE3/zorEjmI3MoA+BUpNOYdpCQDoQGTSnfkfn6tnH/nGhLp+F2yL
-jQju+4rXzQYlcp9OGsJx4RvPotccBRKV1klL6ZWVic9oGEaj6g2djsocKFVJa8BL
-WPVCuQrsDm4hpP9gwBtuQHLQpcW1206HZzoxcMsyhHCp4v/g8tvNA7SFRdMHzA/H
-SdjCF+tz90rA2YxZ78AKzhMLhMmqDREUtOV0quwY3l8mGJhKdvB/zebEtVgDA/UQ
-AV2PY4i6Zde0f1oaUQ7t5Wj6GANyFaHsJx/qrCRGGG7xl9tK9NahkaCMsC++hztE
-sI0qiYVf8tnjLmayiJgELJYyOJkZqYP9lAzdY9QbYJ1DmDWstCM43n+FUlegN9+l
-z75ULDxQJyvUVKmdo9Sls8DqPQ7icGv7y6VWBexkcvAa22QBy10nxKHEYw==
+MBQGA1UEAwwNb3VyLWNhLXNlcnZlcjAgFw0xODA4MjkxNDIzMTZaGA8yNTI1MTAy
+ODE0MjMxNlowYjELMAkGA1UEBhMCWFkxFzAVBgNVBAcMDkNhc3RsZSBBbnRocmF4
+MSMwIQYDVQQKDBpQeXRob24gU29mdHdhcmUgRm91bmRhdGlvbjEVMBMGA1UEAwwM
+ZmFrZWhvc3RuYW1lMIIBojANBgkqhkiG9w0BAQEFAAOCAY8AMIIBigKCAYEAv7gi
+P+HlUgiK8f/xnAgsXkD9ejLX9MALiDQUfbk8khfLBFaEuqzQcC3rnWV2h5nKd4zO
+zdnvRoyPHXUHHDwKSgcIwMYXU+F3rlE3qeFa2iloy01g7wAR3wlRQdbV9x7rBFmk
+vJ/6R/jeC1H58Utx5xahguYm9g0oBUwpy0Eo/NolIAAnX/O4mU6J7PpEb6mLHcKb
+IAVJzvsPqHOaOzY9WySZU0RLGOpEBmPeGrOKQpJqoaAUwu/5XvcBRpl4qUWIt6X0
+kzqgECX6ltVZUOAW3N5TeS/jjU5hVzoEyeaoWkvHIJZ2BJSSNUEE2oMlkDB7gQyD
+Ka9yL/+alFM3SDM6DK6V+onp9xmp/48o487z/eYybxro0LncP5slyvFTlE4VbbLU
+QxQN3CKFeFKjDg8/MOqmFNBj2BQav/9VHaQ65P3wTwXtzCyU9vrAf5E88McWLCqn
+HYzxtgbd2Np5O4QsxNCrrnqgkD5P936JmNUw8k5Vjq4gEuNBGLnuUYcfaq/JAgMB
+AAGjggHDMIIBvzAXBgNVHREEEDAOggxmYWtlaG9zdG5hbWUwDgYDVR0PAQH/BAQD
+AgWgMB0GA1UdJQQWMBQGCCsGAQUFBwMBBggrBgEFBQcDAjAMBgNVHRMBAf8EAjAA
+MB0GA1UdDgQWBBTkPUzbloXMkO0PWB6NTX00bE4REDB9BgNVHSMEdjB0gBTACiso
+Q95fyX1H5UebNvJljGc74qFRpE8wTTELMAkGA1UEBhMCWFkxJjAkBgNVBAoMHVB5
+dGhvbiBTb2Z0d2FyZSBGb3VuZGF0aW9uIENBMRYwFAYDVQQDDA1vdXItY2Etc2Vy
+dmVyggkAyy2AmVppUlswgYMGCCsGAQUFBwEBBHcwdTA8BggrBgEFBQcwAoYwaHR0
+cDovL3Rlc3RjYS5weXRob250ZXN0Lm5ldC90ZXN0Y2EvcHljYWNlcnQuY2VyMDUG
+CCsGAQUFBzABhilodHRwOi8vdGVzdGNhLnB5dGhvbnRlc3QubmV0L3Rlc3RjYS9v
+Y3NwLzBDBgNVHR8EPDA6MDigNqA0hjJodHRwOi8vdGVzdGNhLnB5dGhvbnRlc3Qu
+bmV0L3Rlc3RjYS9yZXZvY2F0aW9uLmNybDANBgkqhkiG9w0BAQsFAAOCAYEAY+nN
+D+zdJ6D8dhah8l/TB5o/l/QR6CDpPN0WTyBicXOpRj6FbkS+nQhL64AI1RuTX0oP
+37cbOOIrXGhI6gpYXDZseaQetX7vy41dvX1K5k7dC4cQ/wEOm4u93hyaJfui4VJ7
+iqoIN7KH90WdC6sRawx/2+3ezB6G8L4wJWtL//Xyme2wsWjBRAt5e4GVtTY3EsSZ
+noXoLy3MzdjG8iDsagb9uPz/AhGVTTgNQouyQ+vCuaTgM/HaJS8Rz1e5JeWrkvKy
+tREvvTH3VeuWlHharZyPVuw0oHOcAcJ2JOD4s8kjueqrwwrT+FNExxI3dkTX7iWT
+9BwdfP4GLPrFu8aQpFf9CS7ar/Os5m1/A6EmNppRfY0op11dN1fMahEqmB1XcTJu
+mHwSKO9cLyYp1FYKsSPZnTUgGuzMUVNu7xznvDwh52QxsUzzVbXEkxfYcloFLkrl
+MwcOfc8icwtnn7SCYM1x+HYMxNyY7kn5A38N2MZ2eTwo7Xd3037Vqh5uLt+l
 -----END CERTIFICATE-----
diff --git a/Lib/test/certdata/keycertecc.pem b/Lib/test/certdata/keycertecc.pem
index bd109921898..d503d49dc85 100644
--- a/Lib/test/certdata/keycertecc.pem
+++ b/Lib/test/certdata/keycertecc.pem
@@ -1,8 +1,8 @@
 -----BEGIN PRIVATE KEY-----
-MIG2AgEAMBAGByqGSM49AgEGBSuBBAAiBIGeMIGbAgEBBDDRUbCeT3hMph4Y/ahL
-1sy9Qfy4DYotuAP06UetzG6syv+EoQ02kX3xvazqwiJDrEyhZANiAAQef97STEPn
-4Nk6C153VEx24MNkJUcmLe771u6lr3Q8Em3J/YPaA1i9Ys7KZA3WvoKBPoWaaikn
-4yLQbd/6YE6AAjMuaThlR1/cqH5QnmS3DXHUjmxnLjWy/dZl0CJG1qo=
+MIG2AgEAMBAGByqGSM49AgEGBSuBBAAiBIGeMIGbAgEBBDBuhPMBtySJ8hFhn5hU
+1yvdDujmB8ajjXNlkQ9GhGdghQIAfKmP9vWtSY+1+BRjpAahZANiAAQKLvQoetPb
+S5tbgExB5vSDUtgc7hK1j6AN++En6AkW8KkK+O/31jkItqBoSQz8ts+VCU5cloTf
+H6i5AS9zUkHr4DEyn+XxfiutzcNQPdQIBmygWAsUpa1XlZf8ExMFf/A=
 -----END PRIVATE KEY-----
 Certificate:
     Data:
@@ -13,19 +13,19 @@ Certificate:
         Issuer: C=XY, O=Python Software Foundation CA, CN=our-ca-server
         Validity
             Not Before: Aug 29 14:23:16 2018 GMT
-            Not After : Oct 28 14:23:16 2037 GMT
+            Not After : Oct 28 14:23:16 2525 GMT
         Subject: C=XY, L=Castle Anthrax, O=Python Software Foundation, CN=localhost-ecc
         Subject Public Key Info:
             Public Key Algorithm: id-ecPublicKey
                 Public-Key: (384 bit)
                 pub:
-                    04:1e:7f:de:d2:4c:43:e7:e0:d9:3a:0b:5e:77:54:
-                    4c:76:e0:c3:64:25:47:26:2d:ee:fb:d6:ee:a5:af:
-                    74:3c:12:6d:c9:fd:83:da:03:58:bd:62:ce:ca:64:
-                    0d:d6:be:82:81:3e:85:9a:6a:29:27:e3:22:d0:6d:
-                    df:fa:60:4e:80:02:33:2e:69:38:65:47:5f:dc:a8:
-                    7e:50:9e:64:b7:0d:71:d4:8e:6c:67:2e:35:b2:fd:
-                    d6:65:d0:22:46:d6:aa
+                    04:0a:2e:f4:28:7a:d3:db:4b:9b:5b:80:4c:41:e6:
+                    f4:83:52:d8:1c:ee:12:b5:8f:a0:0d:fb:e1:27:e8:
+                    09:16:f0:a9:0a:f8:ef:f7:d6:39:08:b6:a0:68:49:
+                    0c:fc:b6:cf:95:09:4e:5c:96:84:df:1f:a8:b9:01:
+                    2f:73:52:41:eb:e0:31:32:9f:e5:f1:7e:2b:ad:cd:
+                    c3:50:3d:d4:08:06:6c:a0:58:0b:14:a5:ad:57:95:
+                    97:fc:13:13:05:7f:f0
                 ASN1 OID: secp384r1
                 NIST CURVE: P-384
         X509v3 extensions:
@@ -38,9 +38,9 @@ Certificate:
             X509v3 Basic Constraints: critical
                 CA:FALSE
             X509v3 Subject Key Identifier: 
-                45:ED:32:14:6D:51:A2:3B:B0:80:55:E0:A6:9B:74:4C:A5:56:88:B1
+                F3:39:E5:90:3F:58:6F:55:9D:91:D4:86:B8:1B:14:35:09:AC:06:97
             X509v3 Authority Key Identifier: 
-                keyid:F3:EC:94:8E:F2:8E:30:C4:8E:68:C2:BF:8E:6A:19:C0:C1:9F:76:65
+                keyid:C0:0A:2B:28:43:DE:5F:C9:7D:47:E5:47:9B:36:F2:65:8C:67:3B:E2
                 DirName:/C=XY/O=Python Software Foundation CA/CN=our-ca-server
                 serial:CB:2D:80:99:5A:69:52:5B
             Authority Information Access: 
@@ -51,53 +51,53 @@ Certificate:
                   URI:http://testca.pythontest.net/testca/revocation.crl
     Signature Algorithm: sha256WithRSAEncryption
     Signature Value:
-        07:e4:91:0b:d3:ed:4b:52:7f:50:68:c7:8d:80:48:9f:b7:4a:
-        13:66:bf:9d:4c:2d:18:19:68:a0:da:3b:12:85:05:16:fa:8d:
-        9c:58:c6:81:b3:96:ba:11:62:65:d3:76:f1:1c:ab:95:e4:d8:
-        2a:e0:1f:7b:c5:20:2e:7c:8f:de:87:7a:2b:52:54:ca:d1:41:
-        b0:5e:20:72:df:44:00:4a:69:1a:ef:10:63:52:13:ed:49:02:
-        ee:dc:9d:f3:c8:ba:c4:01:81:5a:a9:1c:15:12:b6:21:de:44:
-        a5:fd:7e:f9:22:d1:3e:ee:22:dd:31:55:32:4e:41:68:27:c5:
-        95:1b:7e:6b:18:74:f9:22:d6:b7:b9:31:72:51:a0:5a:2c:ff:
-        62:76:e9:a0:55:8d:78:33:52:4a:58:b2:f4:4b:0c:43:82:2f:
-        a9:84:68:05:dd:11:47:70:24:fe:5c:92:fd:17:21:63:bb:fa:
-        93:fa:54:54:05:72:48:ed:81:48:ab:95:fc:6d:a8:62:96:f9:
-        3b:e2:71:18:05:3e:76:bb:df:95:17:7b:81:4b:1f:7f:e1:67:
-        76:c4:07:cb:65:a7:f2:cf:e6:b4:fb:75:7c:ee:df:a1:f5:34:
-        20:2b:48:fd:2e:49:ff:f3:a6:3b:00:49:6c:88:79:ed:9c:16:
-        2a:04:72:e2:93:e4:7e:3f:2a:dd:30:47:9a:99:84:2a:b9:c4:
-        40:31:a6:68:f3:20:d1:75:f1:1e:c8:18:64:5b:f8:4c:ce:9a:
-        3c:57:2c:e3:63:64:29:0a:c2:b6:8e:20:01:55:9f:fe:10:ba:
-        12:42:38:0a:9b:53:01:a5:b4:08:76:ec:e8:a6:fc:69:2c:f7:
-        7f:5e:0f:44:07:55:e1:7c:2e:58:e5:d6:fc:6f:c2:4d:83:65:
-        bd:f3:32:e3:14:48:22:8d:80:18:ea:44:f8:24:79:ff:ff:c6:
-        04:c2:e9:90:34:40:d6:59:3f:59:1e:4a:9a:58:60:ce:ab:f9:
-        76:0e:ef:f7:05:17
+        b8:d9:bf:b8:88:0a:01:2b:aa:64:32:e8:97:e1:0f:ee:34:40:
+        ef:71:fc:e5:f4:a2:3b:26:00:e2:19:3b:3e:cb:8e:2b:51:4c:
+        30:ff:ab:44:9d:28:8d:d2:9c:32:e3:6b:96:73:1c:9d:55:76:
+        b2:bf:af:b8:51:ed:fd:04:e7:0d:fa:8c:2a:68:01:cb:92:90:
+        7d:d1:31:d8:6c:f4:b8:4b:ea:62:59:1e:31:4e:f7:17:ae:3f:
+        f0:b6:ff:f8:6e:64:e3:6e:e9:19:4f:d0:1e:84:1e:df:56:49:
+        ae:90:a9:e0:7b:70:e6:97:7f:08:f2:03:49:82:7d:58:8e:a5:
+        a0:88:59:f3:a1:ab:b7:dd:6b:9a:2b:79:64:9c:d3:07:7c:ec:
+        a3:8d:56:77:28:10:c9:42:a5:fa:81:8e:35:ad:f7:28:da:58:
+        cc:a0:61:fa:0d:75:fd:26:ab:07:88:c5:64:21:f1:98:1c:e3:
+        13:51:38:a7:59:a5:59:88:b9:10:4d:c1:79:70:3f:36:9e:08:
+        75:53:7f:77:a3:3d:5d:16:b7:3b:a2:f6:eb:41:9b:56:16:80:
+        34:96:57:f0:3a:3d:91:43:17:51:2b:64:2c:d7:e2:25:45:85:
+        f3:5f:73:f8:7d:aa:a3:6d:61:e8:ba:c5:90:5e:16:50:bc:79:
+        b9:4e:df:66:db:ae:95:80:15:da:4e:bf:8f:4e:9d:e3:7d:b0:
+        ab:8b:72:93:3c:56:1b:92:d3:67:07:d5:5a:ad:98:16:69:ea:
+        46:fe:e0:d0:f4:ae:95:d3:b5:80:7d:f2:64:4d:14:c0:97:d2:
+        f3:91:bb:e6:43:d0:7e:39:14:0b:95:ab:c1:56:fd:26:79:f8:
+        8c:69:eb:bc:74:0e:ea:cd:94:62:7e:30:58:01:7f:84:ee:9d:
+        58:9c:fc:8f:75:1e:d9:86:cb:f4:fd:4c:af:b2:f7:69:ea:58:
+        cb:7c:93:ce:3d:86:f0:46:01:df:86:02:a1:6c:0f:fb:13:84:
+        d6:75:23:f9:17:21
 -----BEGIN CERTIFICATE-----
-MIIEyzCCAzOgAwIBAgIJAMstgJlaaVJeMA0GCSqGSIb3DQEBCwUAME0xCzAJBgNV
+MIIEzTCCAzWgAwIBAgIJAMstgJlaaVJeMA0GCSqGSIb3DQEBCwUAME0xCzAJBgNV
 BAYTAlhZMSYwJAYDVQQKDB1QeXRob24gU29mdHdhcmUgRm91bmRhdGlvbiBDQTEW
-MBQGA1UEAwwNb3VyLWNhLXNlcnZlcjAeFw0xODA4MjkxNDIzMTZaFw0zNzEwMjgx
-NDIzMTZaMGMxCzAJBgNVBAYTAlhZMRcwFQYDVQQHDA5DYXN0bGUgQW50aHJheDEj
-MCEGA1UECgwaUHl0aG9uIFNvZnR3YXJlIEZvdW5kYXRpb24xFjAUBgNVBAMMDWxv
-Y2FsaG9zdC1lY2MwdjAQBgcqhkjOPQIBBgUrgQQAIgNiAAQef97STEPn4Nk6C153
-VEx24MNkJUcmLe771u6lr3Q8Em3J/YPaA1i9Ys7KZA3WvoKBPoWaaikn4yLQbd/6
-YE6AAjMuaThlR1/cqH5QnmS3DXHUjmxnLjWy/dZl0CJG1qqjggHEMIIBwDAYBgNV
-HREEETAPgg1sb2NhbGhvc3QtZWNjMA4GA1UdDwEB/wQEAwIFoDAdBgNVHSUEFjAU
-BggrBgEFBQcDAQYIKwYBBQUHAwIwDAYDVR0TAQH/BAIwADAdBgNVHQ4EFgQURe0y
-FG1RojuwgFXgppt0TKVWiLEwfQYDVR0jBHYwdIAU8+yUjvKOMMSOaMK/jmoZwMGf
-dmWhUaRPME0xCzAJBgNVBAYTAlhZMSYwJAYDVQQKDB1QeXRob24gU29mdHdhcmUg
-Rm91bmRhdGlvbiBDQTEWMBQGA1UEAwwNb3VyLWNhLXNlcnZlcoIJAMstgJlaaVJb
-MIGDBggrBgEFBQcBAQR3MHUwPAYIKwYBBQUHMAKGMGh0dHA6Ly90ZXN0Y2EucHl0
-aG9udGVzdC5uZXQvdGVzdGNhL3B5Y2FjZXJ0LmNlcjA1BggrBgEFBQcwAYYpaHR0
-cDovL3Rlc3RjYS5weXRob250ZXN0Lm5ldC90ZXN0Y2Evb2NzcC8wQwYDVR0fBDww
-OjA4oDagNIYyaHR0cDovL3Rlc3RjYS5weXRob250ZXN0Lm5ldC90ZXN0Y2EvcmV2
-b2NhdGlvbi5jcmwwDQYJKoZIhvcNAQELBQADggGBAAfkkQvT7UtSf1Box42ASJ+3
-ShNmv51MLRgZaKDaOxKFBRb6jZxYxoGzlroRYmXTdvEcq5Xk2CrgH3vFIC58j96H
-eitSVMrRQbBeIHLfRABKaRrvEGNSE+1JAu7cnfPIusQBgVqpHBUStiHeRKX9fvki
-0T7uIt0xVTJOQWgnxZUbfmsYdPki1re5MXJRoFos/2J26aBVjXgzUkpYsvRLDEOC
-L6mEaAXdEUdwJP5ckv0XIWO7+pP6VFQFckjtgUirlfxtqGKW+TvicRgFPna735UX
-e4FLH3/hZ3bEB8tlp/LP5rT7dXzu36H1NCArSP0uSf/zpjsASWyIee2cFioEcuKT
-5H4/Kt0wR5qZhCq5xEAxpmjzINF18R7IGGRb+EzOmjxXLONjZCkKwraOIAFVn/4Q
-uhJCOAqbUwGltAh27Oim/Gks939eD0QHVeF8Lljl1vxvwk2DZb3zMuMUSCKNgBjq
-RPgkef//xgTC6ZA0QNZZP1keSppYYM6r+XYO7/cFFw==
+MBQGA1UEAwwNb3VyLWNhLXNlcnZlcjAgFw0xODA4MjkxNDIzMTZaGA8yNTI1MTAy
+ODE0MjMxNlowYzELMAkGA1UEBhMCWFkxFzAVBgNVBAcMDkNhc3RsZSBBbnRocmF4
+MSMwIQYDVQQKDBpQeXRob24gU29mdHdhcmUgRm91bmRhdGlvbjEWMBQGA1UEAwwN
+bG9jYWxob3N0LWVjYzB2MBAGByqGSM49AgEGBSuBBAAiA2IABAou9Ch609tLm1uA
+TEHm9INS2BzuErWPoA374SfoCRbwqQr47/fWOQi2oGhJDPy2z5UJTlyWhN8fqLkB
+L3NSQevgMTKf5fF+K63Nw1A91AgGbKBYCxSlrVeVl/wTEwV/8KOCAcQwggHAMBgG
+A1UdEQQRMA+CDWxvY2FsaG9zdC1lY2MwDgYDVR0PAQH/BAQDAgWgMB0GA1UdJQQW
+MBQGCCsGAQUFBwMBBggrBgEFBQcDAjAMBgNVHRMBAf8EAjAAMB0GA1UdDgQWBBTz
+OeWQP1hvVZ2R1Ia4GxQ1CawGlzB9BgNVHSMEdjB0gBTACisoQ95fyX1H5UebNvJl
+jGc74qFRpE8wTTELMAkGA1UEBhMCWFkxJjAkBgNVBAoMHVB5dGhvbiBTb2Z0d2Fy
+ZSBGb3VuZGF0aW9uIENBMRYwFAYDVQQDDA1vdXItY2Etc2VydmVyggkAyy2AmVpp
+UlswgYMGCCsGAQUFBwEBBHcwdTA8BggrBgEFBQcwAoYwaHR0cDovL3Rlc3RjYS5w
+eXRob250ZXN0Lm5ldC90ZXN0Y2EvcHljYWNlcnQuY2VyMDUGCCsGAQUFBzABhilo
+dHRwOi8vdGVzdGNhLnB5dGhvbnRlc3QubmV0L3Rlc3RjYS9vY3NwLzBDBgNVHR8E
+PDA6MDigNqA0hjJodHRwOi8vdGVzdGNhLnB5dGhvbnRlc3QubmV0L3Rlc3RjYS9y
+ZXZvY2F0aW9uLmNybDANBgkqhkiG9w0BAQsFAAOCAYEAuNm/uIgKASuqZDLol+EP
+7jRA73H85fSiOyYA4hk7PsuOK1FMMP+rRJ0ojdKcMuNrlnMcnVV2sr+vuFHt/QTn
+DfqMKmgBy5KQfdEx2Gz0uEvqYlkeMU73F64/8Lb/+G5k427pGU/QHoQe31ZJrpCp
+4Htw5pd/CPIDSYJ9WI6loIhZ86Grt91rmit5ZJzTB3zso41WdygQyUKl+oGONa33
+KNpYzKBh+g11/SarB4jFZCHxmBzjE1E4p1mlWYi5EE3BeXA/Np4IdVN/d6M9XRa3
+O6L260GbVhaANJZX8Do9kUMXUStkLNfiJUWF819z+H2qo21h6LrFkF4WULx5uU7f
+ZtuulYAV2k6/j06d432wq4tykzxWG5LTZwfVWq2YFmnqRv7g0PSuldO1gH3yZE0U
+wJfS85G75kPQfjkUC5WrwVb9Jnn4jGnrvHQO6s2UYn4wWAF/hO6dWJz8j3Ue2YbL
+9P1Mr7L3aepYy3yTzj2G8EYB34YCoWwP+xOE1nUj+Rch
 -----END CERTIFICATE-----
diff --git a/Lib/test/certdata/make_ssl_certs.py b/Lib/test/certdata/make_ssl_certs.py
index ed2037c1fdf..18e61449638 100644
--- a/Lib/test/certdata/make_ssl_certs.py
+++ b/Lib/test/certdata/make_ssl_certs.py
@@ -1,6 +1,7 @@
 """Make the custom certificate and private key files used by test_ssl
 and friends."""
 
+import argparse
 import os
 import pprint
 import shutil
@@ -8,7 +9,8 @@
 from subprocess import *
 
 startdate = "20180829142316Z"
-enddate = "20371028142316Z"
+enddate_default = "25251028142316Z"
+days_default = "140000"
 
 req_template = """
     [ default ]
@@ -79,8 +81,8 @@
     default_startdate = {startdate}
     enddate = {enddate}
     default_enddate = {enddate}
-    default_days = 7000
-    default_crl_days = 7000
+    default_days = {days}
+    default_crl_days = {days}
     certificate = pycacert.pem
     private_key = pycakey.pem
     serial    = $dir/serial
@@ -117,7 +119,7 @@
 here = os.path.abspath(os.path.dirname(__file__))
 
 
-def make_cert_key(hostname, sign=False, extra_san='',
+def make_cert_key(cmdlineargs, hostname, sign=False, extra_san='',
                   ext='req_x509_extensions_full', key='rsa:3072'):
     print("creating cert for " + hostname)
     tempnames = []
@@ -130,13 +132,13 @@ def make_cert_key(hostname, sign=False, extra_san='',
             hostname=hostname,
             extra_san=extra_san,
             startdate=startdate,
-            enddate=enddate
+            enddate=cmdlineargs.enddate,
+            days=cmdlineargs.days
         )
         with open(req_file, 'w') as f:
             f.write(req)
-        args = ['req', '-new', '-nodes', '-days', '7000',
+        args = ['req', '-new', '-nodes', '-days', cmdlineargs.days,
                 '-newkey', key, '-keyout', key_file,
-                '-extensions', ext,
                 '-config', req_file]
         if sign:
             with tempfile.NamedTemporaryFile(delete=False) as f:
@@ -145,7 +147,7 @@ def make_cert_key(hostname, sign=False, extra_san='',
             args += ['-out', reqfile ]
 
         else:
-            args += ['-x509', '-out', cert_file ]
+            args += ['-extensions', ext, '-x509', '-out', cert_file ]
         check_call(['openssl'] + args)
 
         if sign:
@@ -175,7 +177,7 @@ def make_cert_key(hostname, sign=False, extra_san='',
 def unmake_ca():
     shutil.rmtree(TMP_CADIR)
 
-def make_ca():
+def make_ca(cmdlineargs):
     os.mkdir(TMP_CADIR)
     with open(os.path.join('cadir','index.txt'),'a+') as f:
         pass # empty file
@@ -192,7 +194,8 @@ def make_ca():
             hostname='our-ca-server',
             extra_san='',
             startdate=startdate,
-            enddate=enddate
+            enddate=cmdlineargs.enddate,
+            days=cmdlineargs.days
         )
         t.write(req)
         t.flush()
@@ -219,14 +222,22 @@ def make_ca():
     shutil.copy('capath/ceff1710.0', 'capath/b1930218.0')
 
 
-def print_cert(path):
+def write_cert_reference(path):
     import _ssl
-    pprint.pprint(_ssl._test_decode_cert(path))
+    refdata = pprint.pformat(_ssl._test_decode_cert(path))
+    print(refdata)
+    with open(path + '.reference', 'w') as f:
+        print(refdata, file=f)
 
 
 if __name__ == '__main__':
+    parser = argparse.ArgumentParser(description='Make the custom certificate and private key files used by test_ssl and friends.')
+    parser.add_argument('--days', default=days_default)
+    parser.add_argument('--enddate', default=enddate_default)
+    cmdlineargs = parser.parse_args()
+
     os.chdir(here)
-    cert, key = make_cert_key('localhost', ext='req_x509_extensions_simple')
+    cert, key = make_cert_key(cmdlineargs, 'localhost', ext='req_x509_extensions_simple')
     with open('ssl_cert.pem', 'w') as f:
         f.write(cert)
     with open('ssl_key.pem', 'w') as f:
@@ -243,26 +254,26 @@ def print_cert(path):
         f.write(cert)
 
     # For certificate matching tests
-    make_ca()
-    cert, key = make_cert_key('fakehostname', ext='req_x509_extensions_simple')
+    make_ca(cmdlineargs)
+    cert, key = make_cert_key(cmdlineargs, 'fakehostname', ext='req_x509_extensions_simple')
     with open('keycert2.pem', 'w') as f:
         f.write(key)
         f.write(cert)
 
-    cert, key = make_cert_key('localhost', sign=True)
+    cert, key = make_cert_key(cmdlineargs, 'localhost', sign=True)
     with open('keycert3.pem', 'w') as f:
         f.write(key)
         f.write(cert)
 
     check_call(['openssl', 'x509', '-outform', 'pem', '-in', 'keycert3.pem', '-out', 'cert3.pem'])
 
-    cert, key = make_cert_key('fakehostname', sign=True)
+    cert, key = make_cert_key(cmdlineargs, 'fakehostname', sign=True)
     with open('keycert4.pem', 'w') as f:
         f.write(key)
         f.write(cert)
 
     cert, key = make_cert_key(
-        'localhost-ecc', sign=True, key='param:secp384r1.pem'
+        cmdlineargs, 'localhost-ecc', sign=True, key='param:secp384r1.pem'
     )
     with open('keycertecc.pem', 'w') as f:
         f.write(key)
@@ -282,7 +293,7 @@ def print_cert(path):
         'RID.1 = 1.2.3.4.5',
     ]
 
-    cert, key = make_cert_key('allsans', sign=True, extra_san='\n'.join(extra_san))
+    cert, key = make_cert_key(cmdlineargs, 'allsans', sign=True, extra_san='\n'.join(extra_san))
     with open('allsans.pem', 'w') as f:
         f.write(key)
         f.write(cert)
@@ -299,17 +310,17 @@ def print_cert(path):
     ]
 
     # IDN SANS, signed
-    cert, key = make_cert_key('idnsans', sign=True, extra_san='\n'.join(extra_san))
+    cert, key = make_cert_key(cmdlineargs, 'idnsans', sign=True, extra_san='\n'.join(extra_san))
     with open('idnsans.pem', 'w') as f:
         f.write(key)
         f.write(cert)
 
-    cert, key = make_cert_key('nosan', sign=True, ext='req_x509_extensions_nosan')
+    cert, key = make_cert_key(cmdlineargs, 'nosan', sign=True, ext='req_x509_extensions_nosan')
     with open('nosan.pem', 'w') as f:
         f.write(key)
         f.write(cert)
 
     unmake_ca()
-    print("update Lib/test/test_ssl.py and Lib/test/test_asyncio/utils.py")
-    print_cert('keycert.pem')
-    print_cert('keycert3.pem')
+    print("Writing out reference data for Lib/test/test_ssl.py and Lib/test/test_asyncio/utils.py")
+    write_cert_reference('keycert.pem')
+    write_cert_reference('keycert3.pem')
diff --git a/Lib/test/certdata/nosan.pem b/Lib/test/certdata/nosan.pem
index c6ff8ea31bf..c397342fa86 100644
--- a/Lib/test/certdata/nosan.pem
+++ b/Lib/test/certdata/nosan.pem
@@ -1,131 +1,137 @@
 -----BEGIN PRIVATE KEY-----
-MIIG/gIBADANBgkqhkiG9w0BAQEFAASCBugwggbkAgEAAoIBgQC99xEYPTwFN/ji
-i0lm11ckEGhcxciSsIgTgior54CLgQy7JXllTYmAWFTTg2zNBvDMexGI0h+xtZ4q
-1Renghgt33N3Y6CT3v/L7JkE1abQbFveKW/ydlxH0+jLlsENSWjySwC80+f9L3bX
-TcD8T4Fu9Uty2Rg1a/Eyekng5RmfkmLNgxfnX5R5nWhh0Aia7h3Ax2zCALfxqZIm
-fxwavEgHsW/yZi+T+eoJwe0i7a6LaUoLqsPV9ZhagziNDaappPHH42NW39WlRhx1
-UjtiRm2Jihnzxcfs+90zLXSp5pxo/cE9Ia4d8ieq3Rxd/XgjlF6FXXFJjwfL36Dw
-ehy8m3PKKAuO+fyMgPPPMQb7oaRy/MBG0NayRreTwyKILS2zafIW/iKpgICbxrWJ
-r/H1b3S6PBKYUE2uQs0/ZPnRjjh0VeNnue7JcRoNbe27I2d56KUBsVEPdokjU59v
-NYi6Se+ViZXtUbM1u/I0kvDMprAiobwtJFYgcE86N1lFJjHSwDMCAwEAAQKCAYBb
-lvnJBA0iPwBiyeFUElNTcg2/XST9hNu2/DU1AeM6X7gxqznCnAXFudD8Qgt9NvF2
-xYeIvjbFydk+sYs8Gj9qLqhPUdukMAqI2cRVTmWla/lHPhdZgbOwdf1x23es3k4Z
-NAxg/pKFwhK8cCKyA+tWAjKkZwODDk42ljt0kUEvbLbye1hVGAJQOJKRRmo/uLrj
-rcNELnCBtc5ffT2hrlHUU7qz1ozt/brXhYa+JnbXhKZMxcKyMD2KtmXXrFNEy99o
-jXbrpDCos82bzQfPDo8IpCbVbEd2J00aFmrNjQWhZuXX5dXflrujW4J0nzeHrZ78
-rNAz2/YuZ543BTB3XbogeFuLC5RqBgAMmw2WJ96Oa/UG8nZNvEw54N5r6dhfXj6A
-VlJFLVwlfBQdAdaM3P4uZ6WECrH3EerQa27qyUdRrcDaGPLt7wG9FmMivnW1KQsy
-5ow/gM0CsxFj2xNoGw1S5jtclbgSy8HNJaBsNk4XMQ+ORABZdG1MTTE+GMSjD/EC
-gcEA+6JYiZEo+QrvItIZYB6Go4suu/F8df1pEjJlxwp2GmObitRhtV6r9g9IySFv
-5SL7ZxARr4aQxvM7fNp57p9ssmkBtY0ofMjJAxhvs4T37bAcGK/2xCegNSmbqh24
-FAWpRDMgE5PjtuWC5jTvSOYFeUxwI/cu0HxWdxJl2dPUSL1nI2jP+ok3pZobEQk9
-E2+MlHpKmU+s/lAkuQiP+AW9a4M+ZJNWxocJjmtwj4OjJXPm7GddA/5x622DxFe6
-4K2vAoHBAMFC0An25bwGoFrCV/96s45K4qZcZcJ660+aK3xXaq6/8KfiusJnWds2
-nc0B6jYjKs8A7yTAGXke6fmyVsoLosZiXsbpW2m16g8jL79Tc85O9oDNmDIGk1uT
-tRLZc2BvmHmy/dNrdbT/EHC3FKNWQVqWc2sHhPeB6F3hIEXDSUO/GB0njMZNXrPJ
-547RlhN0xCLb3vTzzGHwNmwfI81YjV/XI4vpJjq1YceN8Xyd1r5ZOFfU8woIACO3
-I4dvBQ1avQKBwQCLDs9wzohfAFzg2Exvos7y6AKemDgYmD8NcE5wbWaQ9MTLNsz8
-RuIu64lkpRbKAMf/z5CGeI3fdCFGwRGq/e06tu7b3rMmKmtzS3jHM08zyiPsvKlZ
-AzD00BaXLy8/2VUOPFaYmxy3QSRShaRKm9sgik5agcocKuo5iTBB7V8eB5VMqyps
-IJJg8MXOZ1WaPQXqM56wFKjcLXvtyT6OaNWh6Xh8ajQFKDDuxI8CsFNjaiaONBzi
-DSX1XaL4ySab7T8CgcEAsI+7xP6+EDP1mDVpc8zD8kHUI6zSgwUNqiHtjKHIo3JU
-CO2JNkZ5v158eGlBcshaOdheozKlkxR9KlSWGezbf2crs4pKq585AS9iVeeGK3vU
-lQRAAaQkSEv/6AKl9/q8UKMIZnkMhploibGZt0f8WSiOtb+e6QjUI8CjXVj2vF//
-RdN2N01EMflKBh7Qf2H0NuytGxkJJojxD4K7kMVQE7lXjmEpPgWsGUZC01jYcfrN
-EOFKUWXRys9sNDVnZjX5AoHAFRyOC1BlmVEtcOsgzum4+JEDWvRnO1hP1tm68eTZ
-ijB/XppDtVESpq3+1+gx2YOmzlUNEhKlcn6eHPWEJwdVxJ87Gdh03rIV/ZQUKe46
-3+j6l/5coN4WfCBloy4b+Tcj+ZTL4sKaLm33RoD2UEWS5mmItfZuoEFQB958h3JD
-1Ka1tgsLnuYGjcrg+ALvbM5nQlefzPqPJh0C8UV3Ny/4Gd02YgHw7Yoe4m6OUqQv
-hctFUL/gjIGg9PVqTWzVVKaI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 -----END PRIVATE KEY-----
 Certificate:
     Data:
-        Version: 1 (0x0)
+        Version: 3 (0x2)
         Serial Number:
             cb:2d:80:99:5a:69:52:61
         Signature Algorithm: sha256WithRSAEncryption
         Issuer: C=XY, O=Python Software Foundation CA, CN=our-ca-server
         Validity
             Not Before: Aug 29 14:23:16 2018 GMT
-            Not After : Oct 28 14:23:16 2037 GMT
+            Not After : Oct 28 14:23:16 2525 GMT
         Subject: C=XY, L=Castle Anthrax, O=Python Software Foundation, CN=nosan
         Subject Public Key Info:
             Public Key Algorithm: rsaEncryption
                 Public-Key: (3072 bit)
                 Modulus:
-                    00:bd:f7:11:18:3d:3c:05:37:f8:e2:8b:49:66:d7:
-                    57:24:10:68:5c:c5:c8:92:b0:88:13:82:2a:2b:e7:
-                    80:8b:81:0c:bb:25:79:65:4d:89:80:58:54:d3:83:
-                    6c:cd:06:f0:cc:7b:11:88:d2:1f:b1:b5:9e:2a:d5:
-                    17:a7:82:18:2d:df:73:77:63:a0:93:de:ff:cb:ec:
-                    99:04:d5:a6:d0:6c:5b:de:29:6f:f2:76:5c:47:d3:
-                    e8:cb:96:c1:0d:49:68:f2:4b:00:bc:d3:e7:fd:2f:
-                    76:d7:4d:c0:fc:4f:81:6e:f5:4b:72:d9:18:35:6b:
-                    f1:32:7a:49:e0:e5:19:9f:92:62:cd:83:17:e7:5f:
-                    94:79:9d:68:61:d0:08:9a:ee:1d:c0:c7:6c:c2:00:
-                    b7:f1:a9:92:26:7f:1c:1a:bc:48:07:b1:6f:f2:66:
-                    2f:93:f9:ea:09:c1:ed:22:ed:ae:8b:69:4a:0b:aa:
-                    c3:d5:f5:98:5a:83:38:8d:0d:a6:a9:a4:f1:c7:e3:
-                    63:56:df:d5:a5:46:1c:75:52:3b:62:46:6d:89:8a:
-                    19:f3:c5:c7:ec:fb:dd:33:2d:74:a9:e6:9c:68:fd:
-                    c1:3d:21:ae:1d:f2:27:aa:dd:1c:5d:fd:78:23:94:
-                    5e:85:5d:71:49:8f:07:cb:df:a0:f0:7a:1c:bc:9b:
-                    73:ca:28:0b:8e:f9:fc:8c:80:f3:cf:31:06:fb:a1:
-                    a4:72:fc:c0:46:d0:d6:b2:46:b7:93:c3:22:88:2d:
-                    2d:b3:69:f2:16:fe:22:a9:80:80:9b:c6:b5:89:af:
-                    f1:f5:6f:74:ba:3c:12:98:50:4d:ae:42:cd:3f:64:
-                    f9:d1:8e:38:74:55:e3:67:b9:ee:c9:71:1a:0d:6d:
-                    ed:bb:23:67:79:e8:a5:01:b1:51:0f:76:89:23:53:
-                    9f:6f:35:88:ba:49:ef:95:89:95:ed:51:b3:35:bb:
-                    f2:34:92:f0:cc:a6:b0:22:a1:bc:2d:24:56:20:70:
-                    4f:3a:37:59:45:26:31:d2:c0:33
+                    00:c3:e5:00:c7:04:14:ea:1b:98:3f:39:6e:a4:55:
+                    be:a8:4c:72:cc:e2:ae:b0:5f:8d:98:a1:f3:c6:06:
+                    35:85:94:87:8c:5f:bf:00:d4:fc:d1:be:02:8b:a3:
+                    d4:57:6c:13:9b:fd:0f:3d:ad:bb:6c:2f:d7:5d:f8:
+                    57:14:68:d3:fb:18:d2:e7:5f:e3:29:78:e9:cc:38:
+                    be:8c:ec:bc:e2:84:58:b4:3b:24:66:bc:2c:ad:58:
+                    85:0c:62:41:fc:96:a1:ee:c9:dc:1d:51:13:ac:6e:
+                    a1:a4:da:be:d2:6d:ef:17:cc:36:df:f5:d3:67:09:
+                    86:67:a0:e2:4c:88:6b:e9:d3:c0:f9:14:51:89:2f:
+                    e2:bb:37:dc:42:10:70:a9:1c:9e:66:17:2c:b0:ce:
+                    e9:e8:47:7b:ac:12:05:7e:d1:bf:27:b7:6f:3b:45:
+                    c2:e8:04:d6:8e:44:22:ed:e8:bd:45:4a:c4:9b:ea:
+                    0d:cd:4b:f0:14:34:d0:db:d5:52:e8:6b:de:87:14:
+                    b2:f7:ac:10:aa:4a:dd:f2:48:21:ad:cf:79:67:70:
+                    41:b9:1d:70:51:34:45:a8:91:ae:12:2a:a1:c3:38:
+                    ff:33:0d:96:71:b6:63:70:5a:9e:90:b4:76:85:8f:
+                    8a:d8:fd:79:cc:1a:27:a4:26:02:06:72:bc:de:07:
+                    c8:c0:83:01:82:f6:ed:b7:62:8e:7f:21:7e:4e:86:
+                    04:88:6e:a8:f4:9a:d6:15:47:06:70:25:bb:33:5d:
+                    54:27:ec:13:5b:43:33:45:36:09:e9:24:fa:49:c4:
+                    0e:31:0d:1a:f8:d7:92:2c:01:01:e6:ee:e8:2d:dc:
+                    6d:1a:5f:63:db:6d:76:31:3a:91:7f:51:df:b7:25:
+                    0b:b9:bd:81:9b:70:c5:31:a8:e3:da:1e:2d:c2:f1:
+                    05:13:ad:cb:c8:44:19:b8:5b:62:f6:7d:dd:f1:00:
+                    da:42:e9:16:9f:45:55:e3:7d:e1:85:7e:4d:29:c8:
+                    0a:e5:bc:8c:98:08:6b:f1:01:e5
                 Exponent: 65537 (0x10001)
+        X509v3 extensions:
+            X509v3 Subject Key Identifier: 
+                27:04:5B:37:51:0D:92:FD:2C:60:61:FE:4F:9C:66:20:41:2C:08:45
+            X509v3 Authority Key Identifier: 
+                C0:0A:2B:28:43:DE:5F:C9:7D:47:E5:47:9B:36:F2:65:8C:67:3B:E2
     Signature Algorithm: sha256WithRSAEncryption
     Signature Value:
-        7e:dd:64:64:92:6c:b9:41:ce:f3:e3:f8:e6:9f:c8:5b:32:39:
-        8c:03:5b:5e:7e:b3:23:ca:6c:d1:99:2f:53:af:9d:3c:84:cd:
-        c6:ce:0a:ee:94:de:ff:a7:06:81:7e:e2:38:a5:05:39:58:22:
-        dc:13:83:53:e7:f8:16:cb:93:dc:cf:4b:e6:1b:9f:9e:71:ef:
-        ee:ba:ea:b6:68:5c:32:22:7e:54:4f:46:a6:0b:11:8f:ef:05:
-        6e:d3:0b:d0:a8:be:95:23:a2:e4:e7:a8:a2:a4:7d:98:52:86:
-        a4:15:fb:74:7a:9a:89:23:43:20:26:3a:56:9e:a3:6e:54:02:
-        76:4e:25:9c:a1:8c:03:99:e5:eb:a6:61:b4:9c:2a:b1:ed:eb:
-        94:f9:14:aa:a4:c3:f0:f7:7a:03:a3:b1:f8:c0:83:79:ab:8a:
-        93:7f:0a:95:08:50:ff:55:19:ac:28:a2:c8:9f:a6:77:72:a3:
-        da:37:a9:ff:f3:57:70:c8:65:d9:55:14:84:b4:b3:78:86:82:
-        da:84:2c:48:19:51:ec:9d:20:b1:4d:18:fb:82:9f:7b:a7:80:
-        22:69:25:83:4d:bf:ac:31:64:f5:39:11:f1:ed:53:fb:67:ab:
-        91:86:c5:4d:87:e8:6b:fe:9a:84:fe:6a:92:6b:62:c1:ae:d2:
-        f0:cb:06:6e:f3:50:f4:8d:6d:fa:7d:6a:1c:64:c3:98:91:da:
-        c9:8c:a9:79:e5:48:4c:a2:de:42:28:e8:0e:9f:52:6a:a4:e0:
-        c7:ac:11:9c:ba:5d:d6:84:93:56:28:f1:6d:83:aa:62:b2:b7:
-        56:c6:64:d9:96:4e:97:ab:4e:8f:ba:f6:ab:b9:17:52:98:32:
-        7f:b5:12:fa:39:d7:34:2a:f3:ed:40:90:6f:66:7b:b6:c1:9d:
-        b9:53:d0:e3:e9:69:8c:cf:7a:fd:08:0a:62:47:d4:ce:72:f7:
-        6f:80:b4:1d:18:7a:ba:a2:a9:45:49:ef:9c:0b:99:89:03:ab:
-        5f:7a:9d:c5:77:b7
+        a0:b7:48:56:c6:b3:92:26:3f:d8:92:3c:ed:72:b5:89:ea:fd:
+        c9:66:da:ba:6a:8e:0d:04:ea:b2:fd:1f:e4:29:da:1e:c7:8f:
+        5a:f0:88:74:dd:b3:f0:5e:a7:c4:77:13:cf:a8:19:fb:f2:2d:
+        ee:47:b4:0c:7c:5b:d3:dc:2f:2a:5c:bf:43:22:1c:91:d8:03:
+        7d:44:90:c0:2d:fe:9e:7c:8b:ef:39:4e:b3:87:99:c8:eb:c2:
+        b7:cf:86:65:05:52:8c:15:b9:6a:8d:cd:e3:2a:29:d1:f5:87:
+        42:11:c3:2e:42:ec:ed:26:55:8d:f3:ad:66:f4:79:72:f7:9e:
+        ed:bc:0c:5a:a7:74:ab:dc:57:e8:5c:99:b6:32:8f:7e:58:6e:
+        70:48:ea:5d:a7:fa:b1:fc:c0:e9:50:3a:a4:53:21:e7:8b:77:
+        54:2d:bb:64:1e:fc:88:86:90:c1:03:90:17:bb:3c:cf:ce:e8:
+        48:32:c2:07:e5:8e:4f:93:a9:1a:e2:f5:93:a8:01:9f:30:26:
+        1e:ed:b5:62:e9:25:c5:b0:32:e1:fc:bd:d6:48:b4:70:a9:e2:
+        cd:f6:a9:42:cb:bb:24:39:b9:34:fc:b9:cb:09:01:f0:5e:7e:
+        ef:b5:59:d6:88:31:a9:4c:be:7d:5b:de:4d:ec:84:1b:a1:1b:
+        d8:7d:83:cb:f1:04:c9:f1:f3:a4:08:05:3c:b5:96:13:1d:37:
+        8a:23:83:22:86:72:17:13:5e:e8:89:06:58:cd:89:42:71:12:
+        e5:47:fc:f7:6e:96:28:8f:19:b9:d7:86:5b:c5:62:14:e1:5b:
+        06:e7:e0:66:7e:fc:b7:9e:a9:99:14:e5:0a:d6:df:8f:b5:a2:
+        1a:74:54:30:f6:f4:bf:1b:43:1d:be:4f:38:92:55:10:7b:d8:
+        4f:e0:33:0f:40:2e:58:ec:9c:78:1b:43:17:b3:cb:0b:f5:34:
+        e2:7e:11:a1:90:b6:3c:79:6a:0b:91:ce:0b:8d:d5:60:e4:6d:
+        c8:2a:3d:40:6d:17
 -----BEGIN CERTIFICATE-----
-MIIEJDCCAowCCQDLLYCZWmlSYTANBgkqhkiG9w0BAQsFADBNMQswCQYDVQQGEwJY
-WTEmMCQGA1UECgwdUHl0aG9uIFNvZnR3YXJlIEZvdW5kYXRpb24gQ0ExFjAUBgNV
-BAMMDW91ci1jYS1zZXJ2ZXIwHhcNMTgwODI5MTQyMzE2WhcNMzcxMDI4MTQyMzE2
-WjBbMQswCQYDVQQGEwJYWTEXMBUGA1UEBwwOQ2FzdGxlIEFudGhyYXgxIzAhBgNV
-BAoMGlB5dGhvbiBTb2Z0d2FyZSBGb3VuZGF0aW9uMQ4wDAYDVQQDDAVub3NhbjCC
-AaIwDQYJKoZIhvcNAQEBBQADggGPADCCAYoCggGBAL33ERg9PAU3+OKLSWbXVyQQ
-aFzFyJKwiBOCKivngIuBDLsleWVNiYBYVNODbM0G8Mx7EYjSH7G1nirVF6eCGC3f
-c3djoJPe/8vsmQTVptBsW94pb/J2XEfT6MuWwQ1JaPJLALzT5/0vdtdNwPxPgW71
-S3LZGDVr8TJ6SeDlGZ+SYs2DF+dflHmdaGHQCJruHcDHbMIAt/GpkiZ/HBq8SAex
-b/JmL5P56gnB7SLtrotpSguqw9X1mFqDOI0Npqmk8cfjY1bf1aVGHHVSO2JGbYmK
-GfPFx+z73TMtdKnmnGj9wT0hrh3yJ6rdHF39eCOUXoVdcUmPB8vfoPB6HLybc8oo
-C475/IyA888xBvuhpHL8wEbQ1rJGt5PDIogtLbNp8hb+IqmAgJvGtYmv8fVvdLo8
-EphQTa5CzT9k+dGOOHRV42e57slxGg1t7bsjZ3nopQGxUQ92iSNTn281iLpJ75WJ
-le1RszW78jSS8MymsCKhvC0kViBwTzo3WUUmMdLAMwIDAQABMA0GCSqGSIb3DQEB
-CwUAA4IBgQB+3WRkkmy5Qc7z4/jmn8hbMjmMA1tefrMjymzRmS9Tr508hM3Gzgru
-lN7/pwaBfuI4pQU5WCLcE4NT5/gWy5Pcz0vmG5+ece/uuuq2aFwyIn5UT0amCxGP
-7wVu0wvQqL6VI6Lk56iipH2YUoakFft0epqJI0MgJjpWnqNuVAJ2TiWcoYwDmeXr
-pmG0nCqx7euU+RSqpMPw93oDo7H4wIN5q4qTfwqVCFD/VRmsKKLIn6Z3cqPaN6n/
-81dwyGXZVRSEtLN4hoLahCxIGVHsnSCxTRj7gp97p4AiaSWDTb+sMWT1ORHx7VP7
-Z6uRhsVNh+hr/pqE/mqSa2LBrtLwywZu81D0jW36fWocZMOYkdrJjKl55UhMot5C
-KOgOn1JqpODHrBGcul3WhJNWKPFtg6pisrdWxmTZlk6Xq06PuvaruRdSmDJ/tRL6
-Odc0KvPtQJBvZnu2wZ25U9Dj6WmMz3r9CApiR9TOcvdvgLQdGHq6oqlFSe+cC5mJ
-A6tfep3Fd7c=
+MIIEbzCCAtegAwIBAgIJAMstgJlaaVJhMA0GCSqGSIb3DQEBCwUAME0xCzAJBgNV
+BAYTAlhZMSYwJAYDVQQKDB1QeXRob24gU29mdHdhcmUgRm91bmRhdGlvbiBDQTEW
+MBQGA1UEAwwNb3VyLWNhLXNlcnZlcjAgFw0xODA4MjkxNDIzMTZaGA8yNTI1MTAy
+ODE0MjMxNlowWzELMAkGA1UEBhMCWFkxFzAVBgNVBAcMDkNhc3RsZSBBbnRocmF4
+MSMwIQYDVQQKDBpQeXRob24gU29mdHdhcmUgRm91bmRhdGlvbjEOMAwGA1UEAwwF
+bm9zYW4wggGiMA0GCSqGSIb3DQEBAQUAA4IBjwAwggGKAoIBgQDD5QDHBBTqG5g/
+OW6kVb6oTHLM4q6wX42YofPGBjWFlIeMX78A1PzRvgKLo9RXbBOb/Q89rbtsL9dd
++FcUaNP7GNLnX+MpeOnMOL6M7LzihFi0OyRmvCytWIUMYkH8lqHuydwdUROsbqGk
+2r7Sbe8XzDbf9dNnCYZnoOJMiGvp08D5FFGJL+K7N9xCEHCpHJ5mFyywzunoR3us
+EgV+0b8nt287RcLoBNaORCLt6L1FSsSb6g3NS/AUNNDb1VLoa96HFLL3rBCqSt3y
+SCGtz3lncEG5HXBRNEWoka4SKqHDOP8zDZZxtmNwWp6QtHaFj4rY/XnMGiekJgIG
+crzeB8jAgwGC9u23Yo5/IX5OhgSIbqj0mtYVRwZwJbszXVQn7BNbQzNFNgnpJPpJ
+xA4xDRr415IsAQHm7ugt3G0aX2PbbXYxOpF/Ud+3JQu5vYGbcMUxqOPaHi3C8QUT
+rcvIRBm4W2L2fd3xANpC6RafRVXjfeGFfk0pyArlvIyYCGvxAeUCAwEAAaNCMEAw
+HQYDVR0OBBYEFCcEWzdRDZL9LGBh/k+cZiBBLAhFMB8GA1UdIwQYMBaAFMAKKyhD
+3l/JfUflR5s28mWMZzviMA0GCSqGSIb3DQEBCwUAA4IBgQCgt0hWxrOSJj/Ykjzt
+crWJ6v3JZtq6ao4NBOqy/R/kKdoex49a8Ih03bPwXqfEdxPPqBn78i3uR7QMfFvT
+3C8qXL9DIhyR2AN9RJDALf6efIvvOU6zh5nI68K3z4ZlBVKMFblqjc3jKinR9YdC
+EcMuQuztJlWN861m9Hly957tvAxap3Sr3FfoXJm2Mo9+WG5wSOpdp/qx/MDpUDqk
+UyHni3dULbtkHvyIhpDBA5AXuzzPzuhIMsIH5Y5Pk6ka4vWTqAGfMCYe7bVi6SXF
+sDLh/L3WSLRwqeLN9qlCy7skObk0/LnLCQHwXn7vtVnWiDGpTL59W95N7IQboRvY
+fYPL8QTJ8fOkCAU8tZYTHTeKI4MihnIXE17oiQZYzYlCcRLlR/z3bpYojxm514Zb
+xWIU4VsG5+Bmfvy3nqmZFOUK1t+PtaIadFQw9vS/G0Mdvk84klUQe9hP4DMPQC5Y
+7Jx4G0MXs8sL9TTifhGhkLY8eWoLkc4LjdVg5G3IKj1AbRc=
 -----END CERTIFICATE-----
diff --git a/Lib/test/certdata/pycacert.pem b/Lib/test/certdata/pycacert.pem
index 0a48bf7d235..c2c8b1ecdcf 100644
--- a/Lib/test/certdata/pycacert.pem
+++ b/Lib/test/certdata/pycacert.pem
@@ -7,96 +7,96 @@ Certificate:
         Issuer: C=XY, O=Python Software Foundation CA, CN=our-ca-server
         Validity
             Not Before: Aug 29 14:23:16 2018 GMT
-            Not After : Oct 28 14:23:16 2037 GMT
+            Not After : Oct 28 14:23:16 2525 GMT
         Subject: C=XY, O=Python Software Foundation CA, CN=our-ca-server
         Subject Public Key Info:
             Public Key Algorithm: rsaEncryption
                 Public-Key: (3072 bit)
                 Modulus:
-                    00:d0:a0:9b:b1:b9:3b:79:ee:31:2f:b8:51:1c:01:
-                    75:ed:09:59:4c:ac:c8:bf:6a:0a:f8:7a:08:f0:25:
-                    e3:25:7b:6a:f8:c4:d8:aa:a0:60:07:25:b0:cf:73:
-                    71:05:52:68:bf:06:93:ae:10:61:96:bc:b3:69:81:
-                    1a:7d:19:fc:20:86:8f:9a:68:1b:ed:cd:e2:6c:61:
-                    67:c7:4e:55:ea:43:06:21:1b:e9:b9:be:84:5f:c2:
-                    da:eb:89:88:e0:42:a6:45:49:2a:d0:b9:6b:8c:93:
-                    c9:44:3b:ca:fc:3c:94:7f:dd:70:c5:ad:d8:4b:3b:
-                    dc:1e:f8:55:4b:b5:27:86:f8:df:b0:83:cf:f7:16:
-                    37:bf:13:17:34:d4:c9:55:ed:6b:16:c9:7f:ad:20:
-                    4e:f0:1e:d9:1b:bf:8d:ba:cd:ca:96:ef:1e:69:cb:
-                    51:66:61:48:0d:e8:79:a3:59:61:d4:10:8d:e0:0d:
-                    3b:0b:85:b6:d5:85:12:dd:a5:07:c5:4b:fa:23:fa:
-                    54:39:f7:97:0b:c9:44:47:1e:56:77:3c:3c:13:01:
-                    0b:6d:77:d6:14:ba:44:f4:53:35:56:d9:3d:b9:3e:
-                    35:5f:db:33:9a:4f:5a:b9:38:44:c9:32:49:fe:66:
-                    f6:1f:1a:97:aa:ca:4c:4a:f6:b8:5e:40:7f:fb:0b:
-                    1d:f8:5b:a1:dc:f8:c0:2e:d0:6d:49:f5:d2:46:d4:
-                    90:57:fe:92:81:34:ae:2d:38:bb:a8:17:0c:e1:e5:
-                    3f:e2:f7:26:05:54:50:f5:64:b3:1c:6e:44:ff:6f:
-                    a9:b4:03:96:e9:0e:c2:88:d8:72:52:90:99:c6:41:
-                    0f:46:90:59:b8:3e:6f:d2:e2:9e:1d:36:82:95:d3:
-                    58:8a:12:f3:e2:d8:0d:20:51:23:f0:90:2d:9a:3e:
-                    7d:26:86:b2:a7:d7:f9:28:60:03:e3:77:c7:88:04:
-                    c9:fe:89:77:70:10:4f:c3:a0:8a:3b:f4:ab:42:7b:
-                    e3:14:92:d8:ae:16:d6:a1:de:7d
+                    00:e6:ba:e2:e4:c1:c2:0c:1c:3e:62:d8:b9:5c:57:
+                    2e:52:b8:83:c5:88:3a:e6:9a:7a:f5:64:16:33:eb:
+                    37:6e:2f:7b:f3:68:03:45:65:47:5d:71:10:59:ca:
+                    2b:1b:00:6c:81:14:61:f4:86:59:3f:ea:fd:78:37:
+                    16:9d:43:f1:c4:f6:69:8c:c5:29:06:88:9e:26:22:
+                    04:ac:04:d8:87:34:48:39:eb:6b:f2:0b:92:aa:c3:
+                    6e:63:51:51:6b:c2:ad:ff:5c:c8:2f:b2:1b:9c:20:
+                    8a:40:3e:a2:2f:6a:ea:c8:d9:37:43:5c:dc:ed:92:
+                    e2:d9:40:d2:61:9f:71:8a:f5:ed:39:ba:a8:5e:3e:
+                    b5:21:63:10:d8:6f:b4:e2:11:01:0b:10:e8:bb:fb:
+                    62:ef:48:55:bc:f5:d2:9c:ab:68:ae:95:25:19:f2:
+                    97:7d:1a:dc:66:ea:88:5e:86:e4:cb:cb:69:4d:5e:
+                    b0:a3:fb:6c:31:e4:28:60:5e:90:f1:d4:2e:10:50:
+                    e1:85:f0:0d:5c:bd:dd:45:24:08:19:3e:1c:93:66:
+                    8f:2b:da:53:7d:04:1c:0e:42:c4:68:5e:a6:cd:a9:
+                    18:ed:a7:cd:6a:d0:d1:86:ba:90:ff:b7:4c:de:c7:
+                    43:24:6d:c7:1c:6b:9c:81:e7:e1:1b:57:25:90:a9:
+                    0e:c9:56:f3:f6:6b:5e:2d:b4:2e:40:50:9b:42:63:
+                    d2:d6:99:1c:38:dc:cf:2b:2c:a7:72:f1:c7:5e:63:
+                    34:76:48:f4:3e:88:13:9e:86:16:53:2f:74:fb:87:
+                    01:8d:22:a4:68:33:ee:13:6c:7a:06:14:54:56:17:
+                    57:57:98:34:d0:0b:66:09:e3:88:09:f8:a5:15:1c:
+                    10:73:d0:88:50:99:5e:18:65:3b:ff:31:27:1b:5e:
+                    c6:aa:41:fd:2d:2f:18:a7:c0:f2:ab:c7:22:b5:0b:
+                    69:d2:73:d1:bb:d0:1c:3d:fa:a4:35:62:cd:33:86:
+                    c7:a0:23:0f:b9:6a:d5:d2:6d:8d
                 Exponent: 65537 (0x10001)
         X509v3 extensions:
             X509v3 Subject Key Identifier: 
-                F3:EC:94:8E:F2:8E:30:C4:8E:68:C2:BF:8E:6A:19:C0:C1:9F:76:65
+                C0:0A:2B:28:43:DE:5F:C9:7D:47:E5:47:9B:36:F2:65:8C:67:3B:E2
             X509v3 Authority Key Identifier: 
-                F3:EC:94:8E:F2:8E:30:C4:8E:68:C2:BF:8E:6A:19:C0:C1:9F:76:65
+                C0:0A:2B:28:43:DE:5F:C9:7D:47:E5:47:9B:36:F2:65:8C:67:3B:E2
             X509v3 Basic Constraints: critical
                 CA:TRUE
             X509v3 Key Usage: critical
                 Digital Signature, Certificate Sign, CRL Sign
     Signature Algorithm: sha256WithRSAEncryption
     Signature Value:
-        8b:00:54:72:b3:8d:eb:f3:af:34:9f:d6:60:ea:de:84:3f:8c:
-        04:8f:19:a6:be:02:67:c4:63:c5:74:e3:47:37:59:83:94:06:
-        f1:45:19:e8:07:2f:d6:4e:4b:4f:a8:3d:c7:07:07:27:92:f4:
-        7e:73:4f:8b:32:19:94:46:7a:25:c4:d9:c4:27:b0:11:63:3a:
-        60:8b:85:e1:73:4f:34:3b:6b:a4:34:8c:49:8e:cd:cf:4f:b2:
-        65:27:41:19:b0:fc:80:31:78:f2:73:6a:9b:7d:71:34:50:fc:
-        78:a8:da:05:b4:9c:5b:3a:99:7a:6b:5d:ef:3b:d3:e9:3b:33:
-        01:12:65:cf:5e:07:d8:19:af:d5:53:ea:f0:10:ac:c4:b6:26:
-        3c:34:2e:74:ee:64:dd:1d:36:75:89:44:00:b0:0d:fd:2f:b3:
-        01:cc:1a:8b:02:cd:6c:e8:80:82:ca:bf:82:d7:00:9d:d8:36:
-        15:d2:07:37:fc:6c:73:1d:da:a8:1c:e8:20:8e:32:7a:fe:6d:
-        27:16:e4:58:6c:eb:3e:f0:fe:24:52:29:71:b8:96:7b:53:4b:
-        45:20:55:40:5e:86:1b:ec:c9:46:91:92:ee:ac:93:65:91:2e:
-        94:b6:b6:ac:e8:a3:34:89:a4:1a:12:0d:4d:44:a5:52:ed:8b:
-        91:ee:2f:a6:af:a4:95:25:f9:ce:c7:5b:a7:00:d3:93:ca:b4:
-        3c:5d:4d:f7:b1:3c:cc:6d:b4:45:be:82:ed:18:90:c8:86:d1:
-        75:51:50:04:4c:e8:4f:d2:d6:50:aa:75:e7:5e:ff:a1:7b:27:
-        19:1c:6b:49:2c:6c:4d:6b:63:cc:3b:73:00:f3:99:26:d0:82:
-        87:d3:a9:36:9c:b4:3d:b9:48:68:a8:92:f0:27:8e:0c:cd:15:
-        76:42:84:80:c9:3f:a3:7e:b4:dd:d7:f8:ac:76:ba:60:97:3c:
-        5a:1f:4e:de:71:ee:09:39:10:dd:31:d5:68:57:5d:1a:e5:42:
-        ba:0e:68:e6:45:d3
+        bc:e3:56:22:03:e4:5c:b9:67:ff:94:bc:75:9c:00:85:b0:d5:
+        9c:c4:c3:29:66:5e:8b:b2:a9:a6:30:86:71:1a:6b:f2:00:c5:
+        82:ab:5f:50:04:2a:fb:ed:b8:4c:b9:00:1b:49:57:92:11:cd:
+        a2:bc:cb:0f:a8:b4:61:f8:14:ca:a0:ec:40:17:ba:55:a1:c4:
+        bc:a6:b2:5a:ef:f4:20:10:77:47:d0:a0:c5:58:b9:6c:b5:10:
+        7b:85:4a:43:a3:fb:2c:01:b9:77:17:b0:be:a0:ee:ae:ae:4d:
+        67:86:48:89:57:86:78:ea:3c:ed:f0:41:35:8d:71:68:55:f9:
+        f2:e9:ac:32:d4:c6:a2:ef:ec:54:e6:c4:8e:2c:fd:bd:aa:60:
+        56:65:33:95:ea:10:c6:74:04:eb:2a:6e:9b:11:f6:61:00:aa:
+        fd:ec:f2:0b:b1:4b:11:cd:93:eb:df:98:ae:4c:b4:07:04:4a:
+        e5:ef:ff:52:58:75:f5:3e:a4:71:e1:4a:72:5c:a9:8f:d4:aa:
+        88:f0:6a:71:b4:c3:00:5f:99:6e:d7:91:af:6c:98:0d:64:c2:
+        24:c7:9e:05:11:68:5e:24:62:e3:2e:45:ec:a3:34:f2:a3:9d:
+        4d:e5:32:18:2f:74:fc:11:f1:36:50:4f:a0:40:29:68:5c:43:
+        4c:23:6c:5d:72:c4:ec:52:76:eb:dc:b2:bc:1f:a6:c4:06:66:
+        9b:5c:c7:cc:ca:f2:d1:25:4f:de:a5:1f:8d:e4:0c:49:b6:cf:
+        85:40:a1:b9:1f:c6:c7:19:15:07:63:34:93:d0:57:a0:5a:70:
+        ec:af:4a:1c:72:17:1d:74:a3:6c:31:45:0b:33:7a:a1:b8:46:
+        db:c7:0e:64:4c:6f:b7:99:04:82:43:1f:e0:59:d6:99:21:27:
+        28:09:40:ae:fc:c4:23:aa:a0:0c:08:05:2a:92:1c:db:23:9e:
+        d1:d5:63:ae:39:13:a3:12:88:5a:43:3c:4a:6e:32:f0:84:9f:
+        f9:09:0c:91:e7:b8
 -----BEGIN CERTIFICATE-----
-MIIEgDCCAuigAwIBAgIJAMstgJlaaVJbMA0GCSqGSIb3DQEBCwUAME0xCzAJBgNV
+MIIEgjCCAuqgAwIBAgIJAMstgJlaaVJbMA0GCSqGSIb3DQEBCwUAME0xCzAJBgNV
 BAYTAlhZMSYwJAYDVQQKDB1QeXRob24gU29mdHdhcmUgRm91bmRhdGlvbiBDQTEW
-MBQGA1UEAwwNb3VyLWNhLXNlcnZlcjAeFw0xODA4MjkxNDIzMTZaFw0zNzEwMjgx
-NDIzMTZaME0xCzAJBgNVBAYTAlhZMSYwJAYDVQQKDB1QeXRob24gU29mdHdhcmUg
-Rm91bmRhdGlvbiBDQTEWMBQGA1UEAwwNb3VyLWNhLXNlcnZlcjCCAaIwDQYJKoZI
-hvcNAQEBBQADggGPADCCAYoCggGBANCgm7G5O3nuMS+4URwBde0JWUysyL9qCvh6
-CPAl4yV7avjE2KqgYAclsM9zcQVSaL8Gk64QYZa8s2mBGn0Z/CCGj5poG+3N4mxh
-Z8dOVepDBiEb6bm+hF/C2uuJiOBCpkVJKtC5a4yTyUQ7yvw8lH/dcMWt2Es73B74
-VUu1J4b437CDz/cWN78TFzTUyVXtaxbJf60gTvAe2Ru/jbrNypbvHmnLUWZhSA3o
-eaNZYdQQjeANOwuFttWFEt2lB8VL+iP6VDn3lwvJREceVnc8PBMBC2131hS6RPRT
-NVbZPbk+NV/bM5pPWrk4RMkySf5m9h8al6rKTEr2uF5Af/sLHfhbodz4wC7QbUn1
-0kbUkFf+koE0ri04u6gXDOHlP+L3JgVUUPVksxxuRP9vqbQDlukOwojYclKQmcZB
-D0aQWbg+b9Linh02gpXTWIoS8+LYDSBRI/CQLZo+fSaGsqfX+ShgA+N3x4gEyf6J
-d3AQT8Ogijv0q0J74xSS2K4W1qHefQIDAQABo2MwYTAdBgNVHQ4EFgQU8+yUjvKO
-MMSOaMK/jmoZwMGfdmUwHwYDVR0jBBgwFoAU8+yUjvKOMMSOaMK/jmoZwMGfdmUw
-DwYDVR0TAQH/BAUwAwEB/zAOBgNVHQ8BAf8EBAMCAYYwDQYJKoZIhvcNAQELBQAD
-ggGBAIsAVHKzjevzrzSf1mDq3oQ/jASPGaa+AmfEY8V040c3WYOUBvFFGegHL9ZO
-S0+oPccHByeS9H5zT4syGZRGeiXE2cQnsBFjOmCLheFzTzQ7a6Q0jEmOzc9PsmUn
-QRmw/IAxePJzapt9cTRQ/Hio2gW0nFs6mXprXe870+k7MwESZc9eB9gZr9VT6vAQ
-rMS2Jjw0LnTuZN0dNnWJRACwDf0vswHMGosCzWzogILKv4LXAJ3YNhXSBzf8bHMd
-2qgc6CCOMnr+bScW5Fhs6z7w/iRSKXG4lntTS0UgVUBehhvsyUaRku6sk2WRLpS2
-tqzoozSJpBoSDU1EpVLti5HuL6avpJUl+c7HW6cA05PKtDxdTfexPMxttEW+gu0Y
-kMiG0XVRUARM6E/S1lCqdede/6F7Jxkca0ksbE1rY8w7cwDzmSbQgofTqTactD25
-SGiokvAnjgzNFXZChIDJP6N+tN3X+Kx2umCXPFofTt5x7gk5EN0x1WhXXRrlQroO
-aOZF0w==
+MBQGA1UEAwwNb3VyLWNhLXNlcnZlcjAgFw0xODA4MjkxNDIzMTZaGA8yNTI1MTAy
+ODE0MjMxNlowTTELMAkGA1UEBhMCWFkxJjAkBgNVBAoMHVB5dGhvbiBTb2Z0d2Fy
+ZSBGb3VuZGF0aW9uIENBMRYwFAYDVQQDDA1vdXItY2Etc2VydmVyMIIBojANBgkq
+hkiG9w0BAQEFAAOCAY8AMIIBigKCAYEA5rri5MHCDBw+Yti5XFcuUriDxYg65pp6
+9WQWM+s3bi9782gDRWVHXXEQWcorGwBsgRRh9IZZP+r9eDcWnUPxxPZpjMUpBoie
+JiIErATYhzRIOetr8guSqsNuY1FRa8Kt/1zIL7IbnCCKQD6iL2rqyNk3Q1zc7ZLi
+2UDSYZ9xivXtObqoXj61IWMQ2G+04hEBCxDou/ti70hVvPXSnKtorpUlGfKXfRrc
+ZuqIXobky8tpTV6wo/tsMeQoYF6Q8dQuEFDhhfANXL3dRSQIGT4ck2aPK9pTfQQc
+DkLEaF6mzakY7afNatDRhrqQ/7dM3sdDJG3HHGucgefhG1clkKkOyVbz9mteLbQu
+QFCbQmPS1pkcONzPKyyncvHHXmM0dkj0PogTnoYWUy90+4cBjSKkaDPuE2x6BhRU
+VhdXV5g00AtmCeOICfilFRwQc9CIUJleGGU7/zEnG17GqkH9LS8Yp8Dyq8citQtp
+0nPRu9AcPfqkNWLNM4bHoCMPuWrV0m2NAgMBAAGjYzBhMB0GA1UdDgQWBBTACiso
+Q95fyX1H5UebNvJljGc74jAfBgNVHSMEGDAWgBTACisoQ95fyX1H5UebNvJljGc7
+4jAPBgNVHRMBAf8EBTADAQH/MA4GA1UdDwEB/wQEAwIBhjANBgkqhkiG9w0BAQsF
+AAOCAYEAvONWIgPkXLln/5S8dZwAhbDVnMTDKWZei7KppjCGcRpr8gDFgqtfUAQq
+++24TLkAG0lXkhHNorzLD6i0YfgUyqDsQBe6VaHEvKayWu/0IBB3R9CgxVi5bLUQ
+e4VKQ6P7LAG5dxewvqDurq5NZ4ZIiVeGeOo87fBBNY1xaFX58umsMtTGou/sVObE
+jiz9vapgVmUzleoQxnQE6ypumxH2YQCq/ezyC7FLEc2T69+Yrky0BwRK5e//Ulh1
+9T6kceFKclypj9SqiPBqcbTDAF+ZbteRr2yYDWTCJMeeBRFoXiRi4y5F7KM08qOd
+TeUyGC90/BHxNlBPoEApaFxDTCNsXXLE7FJ269yyvB+mxAZmm1zHzMry0SVP3qUf
+jeQMSbbPhUChuR/GxxkVB2M0k9BXoFpw7K9KHHIXHXSjbDFFCzN6obhG28cOZExv
+t5kEgkMf4FnWmSEnKAlArvzEI6qgDAgFKpIc2yOe0dVjrjkToxKIWkM8Sm4y8ISf
++QkMkee4
 -----END CERTIFICATE-----
diff --git a/Lib/test/certdata/pycakey.pem b/Lib/test/certdata/pycakey.pem
index a6bf7356f4f..0248f985545 100644
--- a/Lib/test/certdata/pycakey.pem
+++ b/Lib/test/certdata/pycakey.pem
@@ -1,40 +1,40 @@
 -----BEGIN PRIVATE KEY-----
-MIIG/gIBADANBgkqhkiG9w0BAQEFAASCBugwggbkAgEAAoIBgQDQoJuxuTt57jEv
-uFEcAXXtCVlMrMi/agr4egjwJeMle2r4xNiqoGAHJbDPc3EFUmi/BpOuEGGWvLNp
-gRp9Gfwgho+aaBvtzeJsYWfHTlXqQwYhG+m5voRfwtrriYjgQqZFSSrQuWuMk8lE
-O8r8PJR/3XDFrdhLO9we+FVLtSeG+N+wg8/3Fje/Exc01MlV7WsWyX+tIE7wHtkb
-v426zcqW7x5py1FmYUgN6HmjWWHUEI3gDTsLhbbVhRLdpQfFS/oj+lQ595cLyURH
-HlZ3PDwTAQttd9YUukT0UzVW2T25PjVf2zOaT1q5OETJMkn+ZvYfGpeqykxK9rhe
-QH/7Cx34W6Hc+MAu0G1J9dJG1JBX/pKBNK4tOLuoFwzh5T/i9yYFVFD1ZLMcbkT/
-b6m0A5bpDsKI2HJSkJnGQQ9GkFm4Pm/S4p4dNoKV01iKEvPi2A0gUSPwkC2aPn0m
-hrKn1/koYAPjd8eIBMn+iXdwEE/DoIo79KtCe+MUktiuFtah3n0CAwEAAQKCAYAD
-iUK0/k2ZRqXJHXKBKy8rWjYMHCj3lvMM/M3g+tYWS7i88w00cIJ1geM006FDSf8i
-LxjatvFd2OCg9ay+w8LSbvrJJGGbeXAQjo1v7ePRPttAPWphQ8RCS+8NAKhJcNJu
-UzapZ13WJKfL2HLw1+VbziORXjMlLKRnAVDkzHMZO70C5MEQ0EIX+C6zrmBOl2HH
-du6LPy8crSaDQg8YxFCI7WWnvRKp+Gp8aIfYnR+7ifT1qr5o9sEUw8GAReyooJ3a
-yJ9uBUbcelO8fNjEABf9xjx+jOmOVsQfig2KuBEi0qXlQSpilZfUdYJhtNke9ADu
-Hui6MBn04D4RIzeKXV+OLjiLwqkJyNlPuxJ2EGpIHNMcx3gpjXIApAwc47BQwLKJ
-VhMWMXS0EWhCLtEzf5UrbMNX+Io3J7noEUu6jxmJV1BKhrnlYeoo4JryN0DUpkSb
-rOAOJLOkpfj7+gvqmWI4MT6SQXSr6BK+3m4J5bVSq4pej9uG5NR3Utghi5hF7DEC
-gcEA3cYNPYPFSTj9YAR3GUZvwUPVL3ZEFcwjrIeg87JhuZOH/hSQ33SgeEoAtaqL
-cLbimj7YzUYx3FOUCp/7yK/bAF1dhAbFab1yZE46Qv2Vi4e+/KEBBftqxyJl5KyV
-vc/HE1dXZGZIO1X5Z5MX8nO3rz/YayiozYVmMibrbHxgTEDC4BrbWtPJQNkflWEb
-FXNjkm0s2+J3kFANpL94NUKMGtArxQV3hWydGN8wS3Fn7LDnHDoM5mOt/naeKRES
-fwwpAoHBAPDTKsKs2LEe4YFzO1EClycDelppjxh5pHSnzTWSq40aKx533SG4aLyI
-DmghzoA3OmY0xpAy1WpT9FeiDNbYpiFCH3qBkArQR2QCu+WGUQ9tDoeN0C2Dje4e
-Yix49BjcGSWzSNvh+tU9PzRc/9eVBMAQuaCm3yNEL+Z7hFTzkrCWK23+jP/OzIIC
-XhnKdOveIYVAjlVgv8CoWIy3xhwXyqPAcstcPmlv9sDAYn37Ot7rGIS7e0WyQxvg
-gxnOxFzKNQKBwQDOPOn/NNV5HKh0bHKdbKVs4zoT4zW515etUIvbVR4QSCSFonZ/
-d6PreVZjmvAFp+3fZ2aSrx6bOJZJszGhFfjhw/G9X9aiWO1SXnVL6yrxERIJOWkM
-ORy5h0GegOjYFauaTvUUhxHRLEi9i0sPy5EcRpFqReuFBPNe3Fa/EoMzJl6TriYj
-tyRHTCNU9XMMZbxJZYH8EgUCjY/Cj9SoIvTL0p+Bn23hBHqrsJLm9dWhhXnHBC0O
-68/Y/lJi+l9rCtECgcEAt6PfTJovl0j8HxF23vyBtK9TQtSR2NERlh9LPZn9lViq
-Hs66YndT7sg1bDSzWlRDBSMjc1xAH5erkJOzBLYqYNwiUvGvnH9coSfwjkMRVxkL
-ZlS+taZGuZiTtmP5h2d3CaegXIQDGU5d/xkXwxYQjEF0u8vkBel+OVxg+cLPTjcF
-IRhl/r98dXtGtJYM+LvnhcxHfVWMg2YcOBn/SPbfgGVFZEuQECjf2fYaZQUJzGkr
-xjOM+gXIZN6cOjbQyA0tAoHADgR5/bMbcf6Jk0w56c/khFZz/pusne5cjXw5a6qq
-fClAqnqjGBpkRxs7HoCR3aje0Pd0pCS93a6Wiqneo4x4HDrpo+pWR2KGAAF4MeO3
-3K94hncmiLAiZo8iqULLKCqJW2EGB2b7QzGpY7jCPiI1g80KuYPesf4ZohSfrr1w
-DoqGoNrcIVdVmUgX47lLqIiWarbbDRY0Am9j58dovmNINYr5wCYGbeh2RuUmHr4u
-E2bb0CdekSHf05HPiF9QpK1z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 -----END PRIVATE KEY-----
diff --git a/Lib/test/certdata/revocation.crl b/Lib/test/certdata/revocation.crl
index 431a831c4f1..a10586d1f79 100644
--- a/Lib/test/certdata/revocation.crl
+++ b/Lib/test/certdata/revocation.crl
@@ -1,14 +1,14 @@
 -----BEGIN X509 CRL-----
-MIICJjCBjwIBATANBgkqhkiG9w0BAQsFADBNMQswCQYDVQQGEwJYWTEmMCQGA1UE
+MIICKDCBkQIBATANBgkqhkiG9w0BAQsFADBNMQswCQYDVQQGEwJYWTEmMCQGA1UE
 CgwdUHl0aG9uIFNvZnR3YXJlIEZvdW5kYXRpb24gQ0ExFjAUBgNVBAMMDW91ci1j
-YS1zZXJ2ZXIXDTIzMTEyNTA0MjEzNloXDTQzMDEyNDA0MjEzNlqgDjAMMAoGA1Ud
-FAQDAgEAMA0GCSqGSIb3DQEBCwUAA4IBgQDMZ4XLQlzUrqBbszEq9I/nXK3jN8/p
-VZ2aScU2le0ySJqIthe0yXEYuoFu+I4ZULyNkCA79baStIl8/Lt48DOHfBVv8SVx
-ZqF7/fdUZBCLJV1kuhuSSknbtNmja5NI4/lcRRXrodRWDMcOmqlKbAC6RMQz/gMG
-vpewGPX1oj5AQnqqd9spKtHbeqeDiyyWYr9ZZFO/433lP7GdsoriTPggYJJMWJvs
-819buE0iGwWf+rTLB51VyGluhcz2pqimej6Ra2cdnYh5IztZlDFR99HywzWhVz/A
-2fwUA91GR7zATerweXVKNd59mcgF4PZWiXmQMwcE0qQOMqMmAqYPLim1mretZsAs
-t1X+nDM0Ak3sKumIjteQF7I6VpSsG4NCtq23G8KpNHnBZVOt0U065lQEvx0ZmB94
-1z7SzjfSZMVXYxBjSXljwuoc1keGpNT5xCmHyrOIxaHsmizzwNESW4dGVLu7/JfK
-w40uGbwH09w4Cfbwuo7w6sRWDWPnlW2mkoc=
+YS1zZXJ2ZXIXDTI0MTAwODExNTExMloYDzI0MDgwMTI5MTE1MTEyWqAOMAwwCgYD
+VR0UBAMCAQAwDQYJKoZIhvcNAQELBQADggGBAKN4S2g4wCeU1fO5TSckAwxgdzdh
+pY28f4musnQt7l37MzB2gmJVDSCZfQyrUnfSEST15WEY7CZVyTlbsu6gYKK53Yej
+j3ORBfGUgzaz62Hs8di7SrHDzWUlNCFa47YFWDmtj96KTX1AItnpkCCE58Wfpivp
+Hu+YINFpi/2vI2nvP/xcfvgT3dXek9kyz+2jHmadxcn2VerSBZZ9fiZk/k4NzgoI
+JdiSswtN1c5GelHQfftwRXbWqsp6TvgHC5MagDuHh5Bj7/DftI7nCy0IT5GnP8lS
+ZqmXUMpa8zbtSNSTIk0XepmypNW8HHMQbfJp0y7yOQ4pPyXICrjYTg7wKpODRcm3
+BRN89vvNfCszMU41glVfQG+2Po5uAMTl1hX8WYSj0+Xxrdg+wgJead4S5Sq3CgMT
+bKsH2Dqh43L8BTxuxzLQyduK0gKSl8vlN7a9Bzm3IXYlyk+kKSyo4jP8XK79pj1k
+1JglMFM9jpoMF2VmNjiROtVEl2tbDGwlvpjWYQ==
 -----END X509 CRL-----
diff --git a/Lib/test/certdata/ssl_cert.pem b/Lib/test/certdata/ssl_cert.pem
index 427948252b7..6db52404942 100644
--- a/Lib/test/certdata/ssl_cert.pem
+++ b/Lib/test/certdata/ssl_cert.pem
@@ -1,27 +1,27 @@
 -----BEGIN CERTIFICATE-----
-MIIEgzCCAuugAwIBAgIUU+FIM/dUbCklbdDwNPd2xemDAEwwDQYJKoZIhvcNAQEL
+MIIEhTCCAu2gAwIBAgIUTxhwRX6zBQc3+l3imDklEbqcDpIwDQYJKoZIhvcNAQEL
 BQAwXzELMAkGA1UEBhMCWFkxFzAVBgNVBAcMDkNhc3RsZSBBbnRocmF4MSMwIQYD
 VQQKDBpQeXRob24gU29mdHdhcmUgRm91bmRhdGlvbjESMBAGA1UEAwwJbG9jYWxo
-b3N0MB4XDTIzMTEyNTA0MjEzNloXDTQzMDEyNDA0MjEzNlowXzELMAkGA1UEBhMC
-WFkxFzAVBgNVBAcMDkNhc3RsZSBBbnRocmF4MSMwIQYDVQQKDBpQeXRob24gU29m
-dHdhcmUgRm91bmRhdGlvbjESMBAGA1UEAwwJbG9jYWxob3N0MIIBojANBgkqhkiG
-9w0BAQEFAAOCAY8AMIIBigKCAYEAzXTIl1su11AGu6sDPsoxqcRGyAX0yjxIcswF
-vj+eW/fBs2GcBby95VEOKpJPKRYYB7fAEAjAKK59zFdsDX/ynxPZLqyLQocBkFVq
-tclhCRZu//KZND+uQuHSx3PjGkSvK/nrGjg5T0bkM4SFeb0YdLb+0aDTKGozUC82
-oBAilNcrFz1VXpEF0qUe9QeKQhyd0MaW5T1oSn+U3RAj2MXm3TGExyZeaicpIM5O
-HFlnwUxsYSDZo0jUj342MbPOZh8szZDWi042jdtSA3i8uMSplEf4O8ZPmX0JCtrz
-fVjRVdaKXIjrhMNWB8K44q6AeyhqJcVHtOmPYoHDm0qIjcrurt0LZaGhmCuKimNd
-njcPxW0VQmDIS/mO5+s24SK+Mpznm5q/clXEwyD8FbrtrzV5cHCE8eNkxjuQjkmi
-wW9uadK1s54tDwRWMl6DRWRyxoF0an885UQWmbsgEB5aRmEx2L0JeD0/q6Iw1Nta
-As8DG4AaWuYMrgZXz7XvyiMq3IxVAgMBAAGjNzA1MBQGA1UdEQQNMAuCCWxvY2Fs
-aG9zdDAdBgNVHQ4EFgQUl2wd7iWE1JTZUVq2yFBKGm9N36owDQYJKoZIhvcNAQEL
-BQADggGBAF0f5x6QXFbgdyLOyeAPD/1DDxNjM68fJSmNM/6vxHJeDFzK0Pja+iJo
-xv54YiS9F2tiKPpejk4ujvLQgvrYrTQvliIE+7fUT0dV74wZKPdLphftT9uEo1dH
-TeIld+549fqcfZCJfVPE2Ka4vfyMGij9hVfY5FoZL1Xpnq/ZGYyWZNAPbkG292p8
-KrfLZm/0fFYAhq8tG/6DX7+2btxeX4MP/49tzskcYWgOjlkknyhJ76aMG9BJ1D7F
-/TIEh5ihNwRTmyt023RBz/xWiN4xBLyIlpQ6d5ECKmFNFr0qnEui6UovfCHUF6lZ
-qcAQ5VFQQ2CayNlVmQ+UGmWIqANlacYWBt7Q6VqpGg24zTMec1/Pqd6X07ScSfrm
-MAtywrWrU7p1aEkN5lBa4n/XKZHGYMjor/YcMdF5yjdSrZr274YYO1pafmTFwRwH
-5o16c8WPc0aPvTFbkGIFT5ddxYstw+QwsBtLKE2lJ4Qfmxt0Ew/0L7xkbK1BaCOo
-EGD2IF7VDQ==
+b3N0MCAXDTI0MTAwODExNTExMloYDzI0MDgwMTI5MTE1MTEyWjBfMQswCQYDVQQG
+EwJYWTEXMBUGA1UEBwwOQ2FzdGxlIEFudGhyYXgxIzAhBgNVBAoMGlB5dGhvbiBT
+b2Z0d2FyZSBGb3VuZGF0aW9uMRIwEAYDVQQDDAlsb2NhbGhvc3QwggGiMA0GCSqG
+SIb3DQEBAQUAA4IBjwAwggGKAoIBgQDwcIAYm12nmQTGB3caFn7alDe3LSliEfNC
+2ZTR+5sh1eucQPbzgFM5SR4soKGElwI68Eg7g1kwqu3zmrI/FAiQI/RrUHyBZiEt
+nFBPM44vY02XjUlJ9nBtgP7QjpRz6ZP0z1DrrojpYLVwg9cR0khTqD5cg2jvTB05
+yL9lQNk295/rMuueC9FaAQ+Y5la0ub7Lbe8gkYPotYliGx5qqCQmsXeTsxCpvQD7
+u0vBF9/nxlwywwzKGXabcN9YQhSECCC4c+eYjqoRgvAaF48xEnokxenzBIqZ82BR
+kFo+zfNR+VhJRctNiZ6Ppa1Ise1H3LjZMDfY1S89QOLYsFXUp8L7ZMVE27Bej+Sq
+4wEJ3soK/k1kr0YauqJ0lCEKkUPD9OeNHmczeakjj11tgtctsYbwgDSUYGA3w+DC
+KD1aSfeuR3Hj89cSsVRrRrPFFih46Tr2PpTNoK6MtPH3RPJKV+Db8E1V2mXmNE0M
+Lg6ramSHsD9iZXTLhG2JO+/876k3N3kCAwEAAaM3MDUwFAYDVR0RBA0wC4IJbG9j
+YWxob3N0MB0GA1UdDgQWBBR459BlAel5MqCtG0DrvVtMZlQfuTANBgkqhkiG9w0B
+AQsFAAOCAYEAaTFWjK/LFzOo+0TWqTTj4WC4N3I8JFrHnlqFJlpchYTW2z92SU1G
+iEzFjWzuDNjp5KM9BqlmGtzXZvy6MItGkYsjPRdPVU0rbCmyTho6y77kTyiEG12V
+UAJ1in3FOQfDwLPcp7wQRgCQq3iZlv7pwXp2Lm5fzu8kZPnxmTVdiKQun9Ps7uKq
+BoM0fM2K14MxVO4Wc0SERnaPszE7xAhkIcs+NRT/gHYdTBlPhao83S3LOOdtCqCP
+pNUOEaShlwI5bVsDPUXNX/eS0MYFNlsYTb5rCxK8jf3W3KNjKTOzN94pHiQOhpkg
+xMPPi3m03/9oKTVXBtHI2A+u3ukheKE6sBXCLdv/GEs9zYI49zmpQxNWz5EOumWL
+k+W/vPv7cD6LeHxxp+nCbEJi1gZtYb3gMY1sLkMNxcOu0QHTqHfme+k7VKWm8anO
+3ogGdGtPuPAD/qjMwg3ChSDLl5Ur/E9UPlD4yM/7KtUD7mLv+jbddA62EiA9MxVB
+t+yt7pOwOA66
 -----END CERTIFICATE-----
diff --git a/Lib/test/certdata/ssl_key.passwd.pem b/Lib/test/certdata/ssl_key.passwd.pem
index 6ab7d57d003..e60a66c2798 100644
--- a/Lib/test/certdata/ssl_key.passwd.pem
+++ b/Lib/test/certdata/ssl_key.passwd.pem
@@ -1,42 +1,42 @@
 -----BEGIN ENCRYPTED PRIVATE KEY-----
-MIIHbTBXBgkqhkiG9w0BBQ0wSjApBgkqhkiG9w0BBQwwHAQIsc9l0YPybNICAggA
-MAwGCCqGSIb3DQIJBQAwHQYJYIZIAWUDBAEqBBDxb9ekR9MERvIff73hFLc6BIIH
-ENhkFePApZj7ZqpjBltINRnaZhu8sEfG1/y3ejDBOa5Sq3C/UPykPfJh0IXsraAB
-STZO22UQEDpJzDnf1aLCo2cJpdz4Mr+Uj8OUdPiX83OlhC36gMrkgSYUdhSFQEas
-MLiBnXU6Z5Mv1Lxe7TJrnMyA4A8JYXXu5XVTErJrC0YT6iCPQh7eAoEtml9a/tJM
-OPg6kn58zmzVDp8LAau4Th1yhdD/cUQM09wg2i5JHLeC9akD+CkNlujVoAirLMTh
-xoMXTy2dkv/lIwI9QVx6WE/VKIngBAPIi3Q+YCIm0PaTgWj5U10C8j4t7kW2AEZK
-z82+vDOpLRGLo/ItNCO9F/a9e4PK4xxwFCOfR80tQNhs5gjKnbDz5IQv2p+pUfUX
-u+AIO0rBb3M9Yya1MC2pc5VLAeQ3UF6YPrNyNjoDsQOytY3YtRVyxiKW72QzeUcX
-Vpc3U6u8ZyHhkxK6bMv3dkPHGW1MOBd9/U5z+9lhHOfCGFStIQ9M8N48ZCWEGyty
-oZT3UApxgqiBAi1h14ZyagA2mjsMNtTmmkSa3v26WUfrwnjm7LD1/0Vm+ptBOFH2
-CkP/aAvr8Ie+ehWobXGpqwB6rlOAwdpPrePtEZiZtdt58anmCquRgE5GIYtVz30f
-flRABM8waJ196RDGkNAmDA3p/sqHy4vbsIOMl8faZ3QxvGVZlPbUEwPhiTIetA5Q
-95fT/uIcuBLfpbaN23j/Av3LiJAeABSmGZ+dA+NXC5UMvuX8COyBU0YF2V6ofpIu
-gP3UC7Tn4yV3Pbes81LEDCskaN6qVRil47l0G+dNcEHVkrGKcSaRCN+joBSCbuin
-Rol34ir9azh8DqHRKdVlLlzTmDQcOwmi0Vx0ASgBXx4UI3IfK45gLJVoz6dkUz+3
-GIPrnh5cw2DvIgIApwmuCQUXPbWZwUW0zuyzhtny9W6S72GUE/P5oUCV+kGYBsup
-FNiAyR9+n/xUuzB5HqIosj4rX+M4il4Ovt+KaCO6/COi+YjAO/9EnSttu8OTxsXl
-wvgblsT7Y1d+iUfmIVNGtbc5NX46ktrbGiqgPX7oR7YDy5/+FQlnPS1YL0ThUiAC
-2RbItu6b0uUyfu2jfWaGqy+SiRZ81rLwKPU3vJSEPfooVcJTG49EE006ZC4TvRzu
-fNkId+P+BxvhEpUM4+VKzfzViEPuzR1u/DuwLAavS7nr5qb+zaUq+Fte5vDQmjjC
-fflT8hS0BGpYEGndeZT4k+mZunHgs3NVUQ4/HW0nflf1j6qAn4+yIB79dH9d/ubt
-RyBG29K+rN0TI/kH9BQZfsAcbnmhpT/ud0mJfeHZ0Lknn6mdJ/k4LXN0T1IlLKz3
-cSleOWY3zjKaOsbuju1o5IiVIr+AF/w+M4nzzDX6DDVpBPAt9iUnDGqjh6mJ3QWQ
-CyCJDLNP0X8rZ8va2KOPorIBhmfDwJKEtIoXkb2hqWURTE0chC444QqiMsMXsX6+
-mOmiWGkdBFnEpGITISFTGERCjEfqOgTMweCANpquiLymJXgDURL603N2WexSgwnu
-Gy1Ws1cA+1cT65ZLqjSqayZ6WdQvsKBBAnGW5LbwBhoCkX0vahs5nZiw0KnskP60
-wNMnyxaS1SuDJ65n+vuLUl7WeysRyz10RWliYZFiUE7jIXfWeYGonAo4eyCEeV/f
-HInxxpswsg/na8BGBPMsx2SfBIiIvSIT4VNxHrL3sIfDrnb2HH/ut/oSLBgSKzY5
-DdkPz309kMM5dqnHANAgRrtVhqzLQE3kNGZ9mO/X1FAyXx8eB7NSeB6ysD8CAHvm
-lkyfsGTzVsnuWWpeHqplds0wx5+XouVtFRI5J3RGa39mbpM1hMyIbS0O24CBKW6K
-7n2UunbABwepL1hSa4e01OPdz4Zx/oayOevTtlfVqh68cEEc6ePdzf7z69pjot7B
-eqlNaqa1POOmkuygL+fiP1BAR3rGEoQKXqb+6JjzLM9CnhCQHHPR2UdqukkEYwsa
-bh9CU8AlfAJ19KFDria4JZXtl8LLMLLqWIO8fmQx7VqkEkEkl8jecO8YMaZTzFEb
-bW7QtIZ1qHWH0UIHH3Qlav72NJTKvGIbtp1JNrLdsHcYNcojLZkEeA83UPaiTB2R
-udltVUd016cktRVzLOKrust8kzPq3iSjpoIXFyFqIYHvWxGHgc7qD5gVBlazqSsV
-qudDv+0PCBjLWLjS6HkFI8BfyXd3ME2wvSmTzSSgSh4nVJNNrZ/RVTtQ5MLVcdh0
-sJ3qsq2Pokf61XXjsTiQorX+cgI9zF6zETXHvnLf9FL+G/VSlcLUsQ0wC584qwQt
-OSASYTbM79xgmjRmolZOptcYXGktfi2C4iq6V6zpFJuNMVgzZ+SbaQw9bvzUo2jG
-VMwrTuQQ+fsAyn66WZvtkSGAdp58+3PNq31ZjafJXBzN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 -----END ENCRYPTED PRIVATE KEY-----
diff --git a/Lib/test/certdata/ssl_key.pem b/Lib/test/certdata/ssl_key.pem
index ee927210511..1ad9e5e2b83 100644
--- a/Lib/test/certdata/ssl_key.pem
+++ b/Lib/test/certdata/ssl_key.pem
@@ -1,40 +1,40 @@
 -----BEGIN PRIVATE KEY-----
-MIIG/QIBADANBgkqhkiG9w0BAQEFAASCBucwggbjAgEAAoIBgQDNdMiXWy7XUAa7
-qwM+yjGpxEbIBfTKPEhyzAW+P55b98GzYZwFvL3lUQ4qkk8pFhgHt8AQCMAorn3M
-V2wNf/KfE9kurItChwGQVWq1yWEJFm7/8pk0P65C4dLHc+MaRK8r+esaODlPRuQz
-hIV5vRh0tv7RoNMoajNQLzagECKU1ysXPVVekQXSpR71B4pCHJ3QxpblPWhKf5Td
-ECPYxebdMYTHJl5qJykgzk4cWWfBTGxhINmjSNSPfjYxs85mHyzNkNaLTjaN21ID
-eLy4xKmUR/g7xk+ZfQkK2vN9WNFV1opciOuEw1YHwrjiroB7KGolxUe06Y9igcOb
-SoiNyu6u3QtloaGYK4qKY12eNw/FbRVCYMhL+Y7n6zbhIr4ynOebmr9yVcTDIPwV
-uu2vNXlwcITx42TGO5COSaLBb25p0rWzni0PBFYyXoNFZHLGgXRqfzzlRBaZuyAQ
-HlpGYTHYvQl4PT+rojDU21oCzwMbgBpa5gyuBlfPte/KIyrcjFUCAwEAAQKCAYAO
-M1r0+TCy4Z1hhceu5JdLql0RELZTbxi71IW2GVwW87gv75hy3hGLAs/1mdC+YIBP
-MkBka1JqzWq0/7rgcP5CSAMsInFqqv2s7fZ286ERGXuZFbnInnkrNsQUlJo3E9W+
-tqKtGIM/i0EVHX0DRdJlqMtSjmjh43tB+M1wAUV+n6OjEtJue5wZK+AIpBmGicdP
-qZY+6IBnm8tcfzPXFRCoq7ZHdIu0jxnc4l2MQJK3DdL04KoiStOkSl8xDsI+lTtq
-D3qa41LE0TY8X2jJ/w6KK3cUeK7F4DQYs+kfCKWMVPpn0/5u6TbC1F7gLvkrseph
-7cIgrruNNs9iKacnR1w3U72R+hNxHsNfo4RGHFa192p/Mfc+kiBd5RNR/M9oHdeq
-U6T/+KM+QyF5dDOyonY0QjwfAcEx+ZsV72nj8AerjM907I6dgHo/9YZ2S1Dt/xuG
-ntD+76GDzmrOvXmmpF0DsTn+Wql7AC4uzaOjv6PVziqz03pR61RpjPDemyJEWMkC
-gcEA7BkGGX3enBENs3X6BYFoeXfGO/hV7/aNpA6ykLzw657dqwy2b6bWLiIaqZdZ
-u0oiY6+SpOtavkZBFTq4bTVD58FHL0n73Yvvaft507kijpYBrxyDOfTJOETv+dVG
-XiY8AUSAE6GjPi0ebuYIVUxoDnMeWDuRJNvTck4byn1hJ1aVlEhwXNxt/nAjq48s
-5QDuR6Z9F8lqEACRYCHSMQYFm35c7c1pPsHJnElX8a7eZ9lT7HGPXHaf/ypMkOzo
-dvJNAoHBAN7GhDomff/kSgQLyzmqKqQowTZlyihnReapygwr8YpNcqKDqq6VlnfH
-Jl1+qtSMSVI0csmccwJWkz1WtSjDsvY+oMdv4gUK3028vQAMQZo+Sh7OElFPFET3
-UmL+Nh73ACPgpiommsdLZQPcIqpWNT5NzO+Jm5xa+U9ToVZgQ7xjrqee5NUiMutr
-r7UWAz7vDWu3x7bzYRRdUJxU18NogGbFGWJ1KM0c67GUXu2E7wBQdjVdS78UWs+4
-XBxKQkG2KQKBwQCtO+M82x122BB8iGkulvhogBjlMd8klnzxTpN5HhmMWWH+uvI1
-1G29Jer4WwRNJyU6jb4E4mgPyw7AG/jssLOlniy0Jw32TlIaKpoGXwZbJvgPW9Vx
-tgnbDsIiR3o9ZMKMj42GWgike4ikCIc+xzRmvdMbHIHwUJfCfEtp9TtPGPnh9pDz
-og3XLsMNg52GXnt3+VI6HOCE41XH+qj2rZt5r2tSVXEOyjQ7R5mOzSeFfXJVwDFX
-v/a/zHKnuB0OAdUCgcBLrxPTEaqy2eMPdtZHM/mipbnmejRw/4zu7XYYJoG7483z
-SlodT/K7pKvzDYqKBVMPm4P33K/x9mm1aBTJ0ZqmL+a9etRFtEjjByEKuB89gLX7
-uzTb7MrNF10lBopqgK3KgpLRNSZWWNXrtskMJ5eVICdkpdJ5Dyst+RKR3siEYzU9
-+yxxAFpeQsqB8gWORva/RsOR8yNjIMS3J9fZqlIdGA8ktPr0nEOyo96QQR5VdACE
-5rpKI2cqtM6OSegynOkCgcAnr2Xzjef6tdcrxrQrq0DjEFTMoCAxQRa6tuF/NYHV
-AK70Y4hBNX84Bvym4hmfbMUEuOCJU+QHQf/iDQrHXPhtX3X2/t8M+AlIzmwLKf2o
-VwCYnZ8SqiwSaWVg+GANWLh0JuKn/ZYyR8urR79dAXFfp0UK+N39vIxNoBisBf+F
-G8mca7zx3UtK2eOW8WgGHz+Y20VZy0m/nkNekd1ZTXoSGhL+iN4XsTRn1YQIn69R
-kNdcwhtZZ3dpChUdf+w/LIc=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 -----END PRIVATE KEY-----
diff --git a/Lib/test/cjkencodings/big5-utf8.txt b/Lib/test/cjkencodings/big5-utf8.txt
new file mode 100644
index 00000000000..a0a534a964d
--- /dev/null
+++ b/Lib/test/cjkencodings/big5-utf8.txt
@@ -0,0 +1,9 @@
+如何在 Python 中使用既有的 C library?
+　在資訊科技快速發展的今天, 開發及測試軟體的速度是不容忽視的
+課題. 為加快開發及測試的速度, 我們便常希望能利用一些已開發好的
+library, 並有一個 fast prototyping 的 programming language 可
+供使用. 目前有許許多多的 library 是以 C 寫成, 而 Python 是一個
+fast prototyping 的 programming language. 故我們希望能將既有的
+C library 拿到 Python 的環境中測試及整合. 其中最主要也是我們所
+要討論的問題就是:
+
diff --git a/Lib/test/cjkencodings/big5.txt b/Lib/test/cjkencodings/big5.txt
new file mode 100644
index 00000000000..f4424959e91
--- /dev/null
+++ b/Lib/test/cjkencodings/big5.txt
@@ -0,0 +1,9 @@
+�p��b Python ���ϥάJ���� C library?
+�@�b��T��ާֳt�o�i������, �}�o�δ��ճn�骺�t�׬O���e������
+���D. ���[�ֶ}�o�δ��ժ��t��, �ڭ̫K�`�Ʊ��Q�Τ@�Ǥw�}�o�n��
+library, ��@�� fast prototyping �� programming language �i
+�Ѩϥ�. �ثe���\�\�h�h�� library �O�H C �g��, �� Python �O�@��
+fast prototyping �� programming language. �G�ڭ̧Ʊ��N�J����
+C library ���� Python �����Ҥ����դξ�X. �䤤�̥D�n�]�O�ڭ̩�
+�n�Q�ת����D�N�O:
+
diff --git a/Lib/test/cjkencodings/big5hkscs-utf8.txt b/Lib/test/cjkencodings/big5hkscs-utf8.txt
new file mode 100644
index 00000000000..f744ce9ae08
--- /dev/null
+++ b/Lib/test/cjkencodings/big5hkscs-utf8.txt
@@ -0,0 +1,2 @@
+𠄌Ě鵮罓洆
+ÊÊ̄ê êê̄
diff --git a/Lib/test/cjkencodings/big5hkscs.txt b/Lib/test/cjkencodings/big5hkscs.txt
new file mode 100644
index 00000000000..81c42b3503d
--- /dev/null
+++ b/Lib/test/cjkencodings/big5hkscs.txt
@@ -0,0 +1,2 @@
+�E�\�s�ڍ�
+�f�b�� ����
diff --git a/Lib/test/cjkencodings/cp949-utf8.txt b/Lib/test/cjkencodings/cp949-utf8.txt
new file mode 100644
index 00000000000..5655e385176
--- /dev/null
+++ b/Lib/test/cjkencodings/cp949-utf8.txt
@@ -0,0 +1,9 @@
+똠방각하 펲시콜라
+
+㉯㉯납!! 因九月패믤릔궈 ⓡⓖ훀¿¿¿ 긍뒙 ⓔ뎨 ㉯. .
+亞영ⓔ능횹 . . . . 서울뤄 뎐학乙 家훀 ! ! !ㅠ.ㅠ
+흐흐흐 ㄱㄱㄱ☆ㅠ_ㅠ 어릨 탸콰긐 뎌응 칑九들乙 ㉯드긐
+설릌 家훀 . . . . 굴애쉌 ⓔ궈 ⓡ릘㉱긐 因仁川女中까즼
+와쒀훀 ! ! 亞영ⓔ 家능궈 ☆上관 없능궈능 亞능뒈훀 글애듴
+ⓡ려듀九 싀풔숴훀 어릨 因仁川女中싁⑨들앜!! ㉯㉯납♡ ⌒⌒*
+
diff --git a/Lib/test/cjkencodings/cp949.txt b/Lib/test/cjkencodings/cp949.txt
new file mode 100644
index 00000000000..16549aa5e49
--- /dev/null
+++ b/Lib/test/cjkencodings/cp949.txt
@@ -0,0 +1,9 @@
+�c�氢�� �����ݶ�
+
+������!! �������В�p�� �ި��R������ ���� �ѵ� ��. .
+䬿��Ѵ��� . . . . ����� ������ ʫ�R ! ! !��.��
+������ �������٤�_�� � ����O ���� �h������ ����O
+���j ʫ�R . . . . ���֚f �ѱ� �ސt�ƒO ����������
+�;��R ! ! 䬿��� ʫ�ɱ� ��߾�� ���ɱŴ� 䬴ɵ��R �۾֊�
+�޷����� ��Ǵ���R � ����������Ĩ���!! �������� �ҡ�*
+
diff --git a/Lib/test/cjkencodings/euc_jisx0213-utf8.txt b/Lib/test/cjkencodings/euc_jisx0213-utf8.txt
new file mode 100644
index 00000000000..9a56a2e18bd
--- /dev/null
+++ b/Lib/test/cjkencodings/euc_jisx0213-utf8.txt
@@ -0,0 +1,8 @@
+Python の開発は、1990 年ごろから開始されています。
+開発者の Guido van Rossum は教育用のプログラミング言語「ABC」の開発に参加していましたが、ABC は実用上の目的にはあまり適していませんでした。
+このため、Guido はより実用的なプログラミング言語の開発を開始し、英国 BBS 放送のコメディ番組「モンティ パイソン」のファンである Guido はこの言語を「Python」と名づけました。
+このような背景から生まれた Python の言語設計は、「シンプル」で「習得が容易」という目標に重点が置かれています。
+多くのスクリプト系言語ではユーザの目先の利便性を優先して色々な機能を言語要素として取り入れる場合が多いのですが、Python ではそういった小細工が追加されることはあまりありません。
+言語自体の機能は最小限に押さえ、必要な機能は拡張モジュールとして追加する、というのが Python のポリシーです。
+
+ノか゚ ト゚ トキ喝塀 𡚴𪎌 麀齁𩛰
diff --git a/Lib/test/cjkencodings/euc_jisx0213.txt b/Lib/test/cjkencodings/euc_jisx0213.txt
new file mode 100644
index 00000000000..51e9268ca98
--- /dev/null
+++ b/Lib/test/cjkencodings/euc_jisx0213.txt
@@ -0,0 +1,8 @@
+Python �γ�ȯ�ϡ�1990 ǯ�������鳫�Ϥ���Ƥ��ޤ���
+��ȯ�Ԥ� Guido van Rossum �϶����ѤΥץ�����ߥ󥰸����ABC�פγ�ȯ�˻��ä��Ƥ��ޤ�������ABC �ϼ��Ѿ����Ū�ˤϤ��ޤ�Ŭ���Ƥ��ޤ���Ǥ�����
+���Τ��ᡢGuido �Ϥ�����Ū�ʥץ�����ߥ󥰸���γ�ȯ�򳫻Ϥ����ѹ� BBS �����Υ���ǥ����ȡ֥��ƥ� �ѥ�����פΥե���Ǥ��� Guido �Ϥ��θ�����Python�פ�̾�Ť��ޤ�����
+���Τ褦���طʤ������ޤ줿 Python �θ����߷פϡ��֥���ץ�פǡֽ������ưספȤ�����ɸ�˽������֤���Ƥ��ޤ���
+¿���Υ�����ץȷϸ���Ǥϥ桼�����������������ͥ�褷�ƿ����ʵ�ǽ��������ǤȤ��Ƽ��������礬¿���ΤǤ�����Python �ǤϤ������ä����ٹ����ɲä���뤳�ȤϤ��ޤꤢ��ޤ���
+���켫�Τε�ǽ�ϺǾ��¤˲�������ɬ�פʵ�ǽ�ϳ�ĥ�⥸�塼��Ȥ����ɲä��롢�Ȥ����Τ� Python �Υݥꥷ���Ǥ���
+
+�Τ� �� �ȥ����� ���� ��ԏ����
diff --git a/Lib/test/cjkencodings/euc_jp-utf8.txt b/Lib/test/cjkencodings/euc_jp-utf8.txt
new file mode 100644
index 00000000000..7763250ebbe
--- /dev/null
+++ b/Lib/test/cjkencodings/euc_jp-utf8.txt
@@ -0,0 +1,7 @@
+Python の開発は、1990 年ごろから開始されています。
+開発者の Guido van Rossum は教育用のプログラミング言語「ABC」の開発に参加していましたが、ABC は実用上の目的にはあまり適していませんでした。
+このため、Guido はより実用的なプログラミング言語の開発を開始し、英国 BBS 放送のコメディ番組「モンティ パイソン」のファンである Guido はこの言語を「Python」と名づけました。
+このような背景から生まれた Python の言語設計は、「シンプル」で「習得が容易」という目標に重点が置かれています。
+多くのスクリプト系言語ではユーザの目先の利便性を優先して色々な機能を言語要素として取り入れる場合が多いのですが、Python ではそういった小細工が追加されることはあまりありません。
+言語自体の機能は最小限に押さえ、必要な機能は拡張モジュールとして追加する、というのが Python のポリシーです。
+
diff --git a/Lib/test/cjkencodings/euc_jp.txt b/Lib/test/cjkencodings/euc_jp.txt
new file mode 100644
index 00000000000..9da6b5d83da
--- /dev/null
+++ b/Lib/test/cjkencodings/euc_jp.txt
@@ -0,0 +1,7 @@
+Python �γ�ȯ�ϡ�1990 ǯ�������鳫�Ϥ���Ƥ��ޤ���
+��ȯ�Ԥ� Guido van Rossum �϶����ѤΥץ�����ߥ󥰸����ABC�פγ�ȯ�˻��ä��Ƥ��ޤ�������ABC �ϼ��Ѿ����Ū�ˤϤ��ޤ�Ŭ���Ƥ��ޤ���Ǥ�����
+���Τ��ᡢGuido �Ϥ�����Ū�ʥץ�����ߥ󥰸���γ�ȯ�򳫻Ϥ����ѹ� BBS �����Υ���ǥ����ȡ֥��ƥ� �ѥ�����פΥե���Ǥ��� Guido �Ϥ��θ�����Python�פ�̾�Ť��ޤ�����
+���Τ褦���طʤ������ޤ줿 Python �θ����߷פϡ��֥���ץ�פǡֽ������ưספȤ�����ɸ�˽������֤���Ƥ��ޤ���
+¿���Υ�����ץȷϸ���Ǥϥ桼�����������������ͥ�褷�ƿ����ʵ�ǽ��������ǤȤ��Ƽ��������礬¿���ΤǤ�����Python �ǤϤ������ä����ٹ����ɲä���뤳�ȤϤ��ޤꤢ��ޤ���
+���켫�Τε�ǽ�ϺǾ��¤˲�������ɬ�פʵ�ǽ�ϳ�ĥ�⥸�塼��Ȥ����ɲä��롢�Ȥ����Τ� Python �Υݥꥷ���Ǥ���
+
diff --git a/Lib/test/cjkencodings/euc_kr-utf8.txt b/Lib/test/cjkencodings/euc_kr-utf8.txt
new file mode 100644
index 00000000000..16c37412b6a
--- /dev/null
+++ b/Lib/test/cjkencodings/euc_kr-utf8.txt
@@ -0,0 +1,7 @@
+◎ 파이썬(Python)은 배우기 쉽고, 강력한 프로그래밍 언어입니다. 파이썬은
+효율적인 고수준 데이터 구조와 간단하지만 효율적인 객체지향프로그래밍을
+지원합니다. 파이썬의 우아(優雅)한 문법과 동적 타이핑, 그리고 인터프리팅
+환경은 파이썬을 스크립팅과 여러 분야에서와 대부분의 플랫폼에서의 빠른
+애플리케이션 개발을 할 수 있는 이상적인 언어로 만들어줍니다.
+
+☆첫가끝: 날아라 쓔쓔쓩~ 닁큼! 뜽금없이 전홥니다. 뷁. 그런거 읎다.
diff --git a/Lib/test/cjkencodings/euc_kr.txt b/Lib/test/cjkencodings/euc_kr.txt
new file mode 100644
index 00000000000..f68dd350289
--- /dev/null
+++ b/Lib/test/cjkencodings/euc_kr.txt
@@ -0,0 +1,7 @@
+�� ���̽�(Python)�� ���� ����, ������ ���α׷��� ����Դϴ�. ���̽���
+ȿ������ ������ ������ ������ ���������� ȿ������ ��ü�������α׷�����
+�����մϴ�. ���̽��� ���(���)�� ������ ���� Ÿ����, �׸��� ����������
+ȯ���� ���̽��� ��ũ���ð� ���� �о߿����� ��κ��� �÷��������� ����
+���ø����̼� ������ �� �� �ִ� �̻����� ���� ������ݴϴ�.
+
+��ù����: ���ƶ� �Ԥ��ФԤԤ��ФԾ�~ �Ԥ��Ҥ�ŭ! �Ԥ��Ѥ��ݾ��� ���Ԥ��Ȥ��ϴ�. �Ԥ��Τ�. �׷��� �Ԥ��Ѥ���.
diff --git a/Lib/test/cjkencodings/gb18030-utf8.txt b/Lib/test/cjkencodings/gb18030-utf8.txt
new file mode 100644
index 00000000000..2060d2593eb
--- /dev/null
+++ b/Lib/test/cjkencodings/gb18030-utf8.txt
@@ -0,0 +1,15 @@
+Python（派森）语言是一种功能强大而完善的通用型计算机程序设计语言，
+已经具有十多年的发展历史，成熟且稳定。这种语言具有非常简捷而清晰
+的语法特点，适合完成各种高层任务，几乎可以在所有的操作系统中
+运行。这种语言简单而强大，适合各种人士学习使用。目前，基于这
+种语言的相关技术正在飞速的发展，用户数量急剧扩大，相关的资源非常多。
+如何在 Python 中使用既有的 C library?
+　在資訊科技快速發展的今天, 開發及測試軟體的速度是不容忽視的
+課題. 為加快開發及測試的速度, 我們便常希望能利用一些已開發好的
+library, 並有一個 fast prototyping 的 programming language 可
+供使用. 目前有許許多多的 library 是以 C 寫成, 而 Python 是一個
+fast prototyping 的 programming language. 故我們希望能將既有的
+C library 拿到 Python 的環境中測試及整合. 其中最主要也是我們所
+要討論的問題就是:
+파이썬은 강력한 기능을 지닌 범용 컴퓨터 프로그래밍 언어다.
+
diff --git a/Lib/test/cjkencodings/gb18030.txt b/Lib/test/cjkencodings/gb18030.txt
new file mode 100644
index 00000000000..5d1f6dca232
--- /dev/null
+++ b/Lib/test/cjkencodings/gb18030.txt
@@ -0,0 +1,15 @@
+Python����ɭ��������һ�ֹ���ǿ������Ƶ�ͨ���ͼ��������������ԣ�
+�Ѿ�����ʮ����ķ�չ��ʷ���������ȶ����������Ծ��зdz���ݶ�����
+���﷨�ص㣬�ʺ���ɸ��ָ߲����񣬼������������еIJ���ϵͳ��
+���С��������Լ򵥶�ǿ���ʺϸ�����ʿѧϰʹ�á�Ŀǰ��������
+�����Ե���ؼ������ڷ��ٵķ�չ���û���������������ص���Դ�dz��ࡣ
+����� Python ��ʹ�ü��е� C library?
+�����YӍ�Ƽ����ٰlչ�Ľ���, �_�l���yԇܛ�w���ٶ��Dz��ݺ�ҕ��
+�n�}. ��ӿ��_�l���yԇ���ٶ�, �҂��㳣ϣ��������һЩ���_�l�õ�
+library, �K��һ�� fast prototyping �� programming language ��
+��ʹ��. Ŀǰ���S�S���� library ���� C ����, �� Python ��һ��
+fast prototyping �� programming language. ���҂�ϣ���܌����е�
+C library �õ� Python �ĭh���Мyԇ������. ��������ҪҲ���҂���
+ҪӑՓ�Ć��}����:
+�5�1�3�3�2�1�3�1 �7�6�0�4�6�3 �8�5�8�6�3�5 �3�1�9�5 �0�9�3�0 �4�3�5�7�5�5 �5�5�0�9�8�9�9�3�0�4 �2�9�2�5�9�9.
+
diff --git a/Lib/test/cjkencodings/gb2312-utf8.txt b/Lib/test/cjkencodings/gb2312-utf8.txt
new file mode 100644
index 00000000000..efb7d8f95cd
--- /dev/null
+++ b/Lib/test/cjkencodings/gb2312-utf8.txt
@@ -0,0 +1,6 @@
+Python（派森）语言是一种功能强大而完善的通用型计算机程序设计语言，
+已经具有十多年的发展历史，成熟且稳定。这种语言具有非常简捷而清晰
+的语法特点，适合完成各种高层任务，几乎可以在所有的操作系统中
+运行。这种语言简单而强大，适合各种人士学习使用。目前，基于这
+种语言的相关技术正在飞速的发展，用户数量急剧扩大，相关的资源非常多。
+
diff --git a/Lib/test/cjkencodings/gb2312.txt b/Lib/test/cjkencodings/gb2312.txt
new file mode 100644
index 00000000000..1536ac10b9e
--- /dev/null
+++ b/Lib/test/cjkencodings/gb2312.txt
@@ -0,0 +1,6 @@
+Python����ɭ��������һ�ֹ���ǿ������Ƶ�ͨ���ͼ��������������ԣ�
+�Ѿ�����ʮ����ķ�չ��ʷ���������ȶ����������Ծ��зdz���ݶ�����
+���﷨�ص㣬�ʺ���ɸ��ָ߲����񣬼������������еIJ���ϵͳ��
+���С��������Լ򵥶�ǿ���ʺϸ�����ʿѧϰʹ�á�Ŀǰ��������
+�����Ե���ؼ������ڷ��ٵķ�չ���û���������������ص���Դ�dz��ࡣ
+
diff --git a/Lib/test/cjkencodings/gbk-utf8.txt b/Lib/test/cjkencodings/gbk-utf8.txt
new file mode 100644
index 00000000000..75bbd31ec5a
--- /dev/null
+++ b/Lib/test/cjkencodings/gbk-utf8.txt
@@ -0,0 +1,14 @@
+Python（派森）语言是一种功能强大而完善的通用型计算机程序设计语言，
+已经具有十多年的发展历史，成熟且稳定。这种语言具有非常简捷而清晰
+的语法特点，适合完成各种高层任务，几乎可以在所有的操作系统中
+运行。这种语言简单而强大，适合各种人士学习使用。目前，基于这
+种语言的相关技术正在飞速的发展，用户数量急剧扩大，相关的资源非常多。
+如何在 Python 中使用既有的 C library?
+　在資訊科技快速發展的今天, 開發及測試軟體的速度是不容忽視的
+課題. 為加快開發及測試的速度, 我們便常希望能利用一些已開發好的
+library, 並有一個 fast prototyping 的 programming language 可
+供使用. 目前有許許多多的 library 是以 C 寫成, 而 Python 是一個
+fast prototyping 的 programming language. 故我們希望能將既有的
+C library 拿到 Python 的環境中測試及整合. 其中最主要也是我們所
+要討論的問題就是:
+
diff --git a/Lib/test/cjkencodings/gbk.txt b/Lib/test/cjkencodings/gbk.txt
new file mode 100644
index 00000000000..8788f8a2dc4
--- /dev/null
+++ b/Lib/test/cjkencodings/gbk.txt
@@ -0,0 +1,14 @@
+Python����ɭ��������һ�ֹ���ǿ������Ƶ�ͨ���ͼ��������������ԣ�
+�Ѿ�����ʮ����ķ�չ��ʷ���������ȶ����������Ծ��зdz���ݶ�����
+���﷨�ص㣬�ʺ���ɸ��ָ߲����񣬼������������еIJ���ϵͳ��
+���С��������Լ򵥶�ǿ���ʺϸ�����ʿѧϰʹ�á�Ŀǰ��������
+�����Ե���ؼ������ڷ��ٵķ�չ���û���������������ص���Դ�dz��ࡣ
+����� Python ��ʹ�ü��е� C library?
+�����YӍ�Ƽ����ٰlչ�Ľ���, �_�l���yԇܛ�w���ٶ��Dz��ݺ�ҕ��
+�n�}. ��ӿ��_�l���yԇ���ٶ�, �҂��㳣ϣ��������һЩ���_�l�õ�
+library, �K��һ�� fast prototyping �� programming language ��
+��ʹ��. Ŀǰ���S�S���� library ���� C ����, �� Python ��һ��
+fast prototyping �� programming language. ���҂�ϣ���܌����е�
+C library �õ� Python �ĭh���Мyԇ������. ��������ҪҲ���҂���
+ҪӑՓ�Ć��}����:
+
diff --git a/Lib/test/cjkencodings/hz-utf8.txt b/Lib/test/cjkencodings/hz-utf8.txt
new file mode 100644
index 00000000000..7c11735c1f1
--- /dev/null
+++ b/Lib/test/cjkencodings/hz-utf8.txt
@@ -0,0 +1,2 @@
+This sentence is in ASCII.
+The next sentence is in GB.己所不欲，勿施於人。Bye.
diff --git a/Lib/test/cjkencodings/hz.txt b/Lib/test/cjkencodings/hz.txt
new file mode 100644
index 00000000000..f882d463447
--- /dev/null
+++ b/Lib/test/cjkencodings/hz.txt
@@ -0,0 +1,2 @@
+This sentence is in ASCII.
+The next sentence is in GB.~{<:Ky2;S{#,NpJ)l6HK!#~}Bye.
diff --git a/Lib/test/cjkencodings/iso2022_jp-utf8.txt b/Lib/test/cjkencodings/iso2022_jp-utf8.txt
new file mode 100644
index 00000000000..7763250ebbe
--- /dev/null
+++ b/Lib/test/cjkencodings/iso2022_jp-utf8.txt
@@ -0,0 +1,7 @@
+Python の開発は、1990 年ごろから開始されています。
+開発者の Guido van Rossum は教育用のプログラミング言語「ABC」の開発に参加していましたが、ABC は実用上の目的にはあまり適していませんでした。
+このため、Guido はより実用的なプログラミング言語の開発を開始し、英国 BBS 放送のコメディ番組「モンティ パイソン」のファンである Guido はこの言語を「Python」と名づけました。
+このような背景から生まれた Python の言語設計は、「シンプル」で「習得が容易」という目標に重点が置かれています。
+多くのスクリプト系言語ではユーザの目先の利便性を優先して色々な機能を言語要素として取り入れる場合が多いのですが、Python ではそういった小細工が追加されることはあまりありません。
+言語自体の機能は最小限に押さえ、必要な機能は拡張モジュールとして追加する、というのが Python のポリシーです。
+
diff --git a/Lib/test/cjkencodings/iso2022_jp.txt b/Lib/test/cjkencodings/iso2022_jp.txt
new file mode 100644
index 00000000000..fc398d64ad2
--- /dev/null
+++ b/Lib/test/cjkencodings/iso2022_jp.txt
@@ -0,0 +1,7 @@
+Python $B$N3+H/$O!"(B1990 $BG/$4$m$+$i3+;O$5$l$F$$$^$9!#(B
+$B3+H/<T$N(B Guido van Rossum $B$O650iMQ$N%W%m%0%i%_%s%08@8l!V(BABC$B!W$N3+H/$K;22C$7$F$$$^$7$?$,!"(BABC $B$O<BMQ>e$NL\E*$K$O$"$^$jE,$7$F$$$^$;$s$G$7$?!#(B
+$B$3$N$?$a!"(BGuido $B$O$h$j<BMQE*$J%W%m%0%i%_%s%08@8l$N3+H/$r3+;O$7!"1Q9q(B BBS $BJ|Aw$N%3%a%G%#HVAH!V%b%s%F%#(B $B%Q%$%=%s!W$N%U%!%s$G$"$k(B Guido $B$O$3$N8@8l$r!V(BPython$B!W$HL>$E$1$^$7$?!#(B
+$B$3$N$h$&$JGX7J$+$i@8$^$l$?(B Python $B$N8@8l@_7W$O!"!V%7%s%W%k!W$G!V=,F@$,MF0W!W$H$$$&L\I8$K=EE@$,CV$+$l$F$$$^$9!#(B
+$BB?$/$N%9%/%j%W%H7O8@8l$G$O%f!<%6$NL\@h$NMxJX@-$rM%@h$7$F?'!9$J5!G=$r8@8lMWAG$H$7$F<h$jF~$l$k>l9g$,B?$$$N$G$9$,!"(BPython $B$G$O$=$&$$$C$?>.:Y9)$,DI2C$5$l$k$3$H$O$"$^$j$"$j$^$;$s!#(B
+$B8@8l<+BN$N5!G=$O:G>.8B$K2!$5$(!"I,MW$J5!G=$O3HD%%b%8%e!<%k$H$7$FDI2C$9$k!"$H$$$&$N$,(B Python $B$N%]%j%7!<$G$9!#(B
+
diff --git a/Lib/test/cjkencodings/iso2022_kr-utf8.txt b/Lib/test/cjkencodings/iso2022_kr-utf8.txt
new file mode 100644
index 00000000000..d5c9d6eeeb2
--- /dev/null
+++ b/Lib/test/cjkencodings/iso2022_kr-utf8.txt
@@ -0,0 +1,7 @@
+◎ 파이썬(Python)은 배우기 쉽고, 강력한 프로그래밍 언어입니다. 파이썬은
+효율적인 고수준 데이터 구조와 간단하지만 효율적인 객체지향프로그래밍을
+지원합니다. 파이썬의 우아(優雅)한 문법과 동적 타이핑, 그리고 인터프리팅
+환경은 파이썬을 스크립팅과 여러 분야에서와 대부분의 플랫폼에서의 빠른
+애플리케이션 개발을 할 수 있는 이상적인 언어로 만들어줍니다.
+
+☆첫가끝: 날아라 쓩~ 큼! 금없이 전니다. 그런거 다.
diff --git a/Lib/test/cjkencodings/iso2022_kr.txt b/Lib/test/cjkencodings/iso2022_kr.txt
new file mode 100644
index 00000000000..2cece21c5dd
--- /dev/null
+++ b/Lib/test/cjkencodings/iso2022_kr.txt
@@ -0,0 +1,7 @@
+$)C!] FD@L=c(Python)@: 9h?l1b =10m, 0-7BGQ GA7N1W7!9V >p>n@T4O4Y. FD@L=c@:
+H?@2@{@N 0m<vAX 5%@LEM 18A6?M 0#4\GOAv88 H?@2@{@N 04C<AvGbGA7N1W7!9V@;
+Av?xGU4O4Y. FD@L=c@G ?l>F(iPd:)GQ 9.9}0z 5?@{ E8@LGN, 1W8.0m @NEMGA8.FC
+H/0f@: FD@L=c@; =:E)83FC0z ?)7/ :P>_?!<-?M 4k:N:P@G GC7'F{?!<-@G :|8%
+>VGC8.DI@L<G 039_@; GR <v @V4B @L;s@{@N >p>n7N 885i>nA]4O4Y.
+
+!YC90!3!: 3/>F6s >1~ E-! 1]>x@L @|4O4Y. 1W710E 4Y.
diff --git a/Lib/test/cjkencodings/johab-utf8.txt b/Lib/test/cjkencodings/johab-utf8.txt
new file mode 100644
index 00000000000..5655e385176
--- /dev/null
+++ b/Lib/test/cjkencodings/johab-utf8.txt
@@ -0,0 +1,9 @@
+똠방각하 펲시콜라
+
+㉯㉯납!! 因九月패믤릔궈 ⓡⓖ훀¿¿¿ 긍뒙 ⓔ뎨 ㉯. .
+亞영ⓔ능횹 . . . . 서울뤄 뎐학乙 家훀 ! ! !ㅠ.ㅠ
+흐흐흐 ㄱㄱㄱ☆ㅠ_ㅠ 어릨 탸콰긐 뎌응 칑九들乙 ㉯드긐
+설릌 家훀 . . . . 굴애쉌 ⓔ궈 ⓡ릘㉱긐 因仁川女中까즼
+와쒀훀 ! ! 亞영ⓔ 家능궈 ☆上관 없능궈능 亞능뒈훀 글애듴
+ⓡ려듀九 싀풔숴훀 어릨 因仁川女中싁⑨들앜!! ㉯㉯납♡ ⌒⌒*
+
diff --git a/Lib/test/cjkencodings/johab.txt b/Lib/test/cjkencodings/johab.txt
new file mode 100644
index 00000000000..067781b785a
--- /dev/null
+++ b/Lib/test/cjkencodings/johab.txt
@@ -0,0 +1,9 @@
+���w�b�a �\��ũ�a
+
+�����s!! �g��Ú������ �����zٯٯٯ �w�� �ѕ� ��. .
+�<�w�ѓw�s . . . . �ᶉ�� �e�b�� �;�z ! ! !�A.�A
+�a�a�a �A�A�A�i�A_�A �៚ ȡ���z �a�w ×✗i�� ���a�z
+��z �;�z . . . . ������ �ъ� �ޟ��‹z �g�b�I����a��
+�����z ! ! �<�w�� �;�w�� �i꾉� ���w���w �<�w���z �i���z
+�ޝa�A� ��Ρ���z �៚ �g�b�I���鯂��i�z!! �����sٽ �b�b*
+
diff --git a/Lib/test/cjkencodings/shift_jis-utf8.txt b/Lib/test/cjkencodings/shift_jis-utf8.txt
new file mode 100644
index 00000000000..7763250ebbe
--- /dev/null
+++ b/Lib/test/cjkencodings/shift_jis-utf8.txt
@@ -0,0 +1,7 @@
+Python の開発は、1990 年ごろから開始されています。
+開発者の Guido van Rossum は教育用のプログラミング言語「ABC」の開発に参加していましたが、ABC は実用上の目的にはあまり適していませんでした。
+このため、Guido はより実用的なプログラミング言語の開発を開始し、英国 BBS 放送のコメディ番組「モンティ パイソン」のファンである Guido はこの言語を「Python」と名づけました。
+このような背景から生まれた Python の言語設計は、「シンプル」で「習得が容易」という目標に重点が置かれています。
+多くのスクリプト系言語ではユーザの目先の利便性を優先して色々な機能を言語要素として取り入れる場合が多いのですが、Python ではそういった小細工が追加されることはあまりありません。
+言語自体の機能は最小限に押さえ、必要な機能は拡張モジュールとして追加する、というのが Python のポリシーです。
+
diff --git a/Lib/test/cjkencodings/shift_jis.txt b/Lib/test/cjkencodings/shift_jis.txt
new file mode 100644
index 00000000000..10b760d8678
--- /dev/null
+++ b/Lib/test/cjkencodings/shift_jis.txt
@@ -0,0 +1,7 @@
+Python �̊J���́A1990 �N���납��J�n����Ă��܂��B
+�J���҂� Guido van Rossum �͋���p�̃v���O���~���O����uABC�v�̊J���ɎQ�����Ă��܂������AABC �͎��p��̖ړI�ɂ͂��܂�K���Ă��܂���ł����B
+���̂��߁AGuido �͂����p�I�ȃv���O���~���O����̊J�����J�n���A�p�� BBS �����̃R���f�B�ԑg�u�����e�B �p�C�\���v�̃t�@���ł��� Guido �͂��̌�����uPython�v�Ɩ��Â��܂����B
+���̂悤�Ȕw�i���琶�܂ꂽ Python �̌���݌v�́A�u�V���v���v�Łu�K�����e�Ձv�Ƃ����ڕW�ɏd�_���u����Ă��܂��B
+�����̃X�N���v�g�n����ł̓��[�U�̖ڐ�̗��֐���D�悵�ĐF�X�ȋ@�\������v�f�Ƃ��Ď������ꍇ�������̂ł����APython �ł͂������������׍H���lj�����邱�Ƃ͂��܂肠��܂���B
+���ꎩ�̂̋@�\�͍ŏ����ɉ������A�K�v�ȋ@�\�͊g�����W���[���Ƃ��Ēlj�����A�Ƃ����̂� Python �̃|���V�[�ł��B
+
diff --git a/Lib/test/cjkencodings/shift_jisx0213-utf8.txt b/Lib/test/cjkencodings/shift_jisx0213-utf8.txt
new file mode 100644
index 00000000000..9a56a2e18bd
--- /dev/null
+++ b/Lib/test/cjkencodings/shift_jisx0213-utf8.txt
@@ -0,0 +1,8 @@
+Python の開発は、1990 年ごろから開始されています。
+開発者の Guido van Rossum は教育用のプログラミング言語「ABC」の開発に参加していましたが、ABC は実用上の目的にはあまり適していませんでした。
+このため、Guido はより実用的なプログラミング言語の開発を開始し、英国 BBS 放送のコメディ番組「モンティ パイソン」のファンである Guido はこの言語を「Python」と名づけました。
+このような背景から生まれた Python の言語設計は、「シンプル」で「習得が容易」という目標に重点が置かれています。
+多くのスクリプト系言語ではユーザの目先の利便性を優先して色々な機能を言語要素として取り入れる場合が多いのですが、Python ではそういった小細工が追加されることはあまりありません。
+言語自体の機能は最小限に押さえ、必要な機能は拡張モジュールとして追加する、というのが Python のポリシーです。
+
+ノか゚ ト゚ トキ喝塀 𡚴𪎌 麀齁𩛰
diff --git a/Lib/test/cjkencodings/shift_jisx0213.txt b/Lib/test/cjkencodings/shift_jisx0213.txt
new file mode 100644
index 00000000000..08c9ef46301
--- /dev/null
+++ b/Lib/test/cjkencodings/shift_jisx0213.txt
@@ -0,0 +1,8 @@
+Python �̊J���́A1990 �N���납��J�n����Ă��܂��B
+�J���҂� Guido van Rossum �͋���p�̃v���O���~���O����uABC�v�̊J���ɎQ�����Ă��܂������AABC �͎��p��̖ړI�ɂ͂��܂�K���Ă��܂���ł����B
+���̂��߁AGuido �͂����p�I�ȃv���O���~���O����̊J�����J�n���A�p�� BBS �����̃R���f�B�ԑg�u�����e�B �p�C�\���v�̃t�@���ł��� Guido �͂��̌�����uPython�v�Ɩ��Â��܂����B
+���̂悤�Ȕw�i���琶�܂ꂽ Python �̌���݌v�́A�u�V���v���v�Łu�K�����e�Ձv�Ƃ����ڕW�ɏd�_���u����Ă��܂��B
+�����̃X�N���v�g�n����ł̓��[�U�̖ڐ�̗��֐���D�悵�ĐF�X�ȋ@�\������v�f�Ƃ��Ď������ꍇ�������̂ł����APython �ł͂������������׍H���lj�����邱�Ƃ͂��܂肠��܂���B
+���ꎩ�̂̋@�\�͍ŏ����ɉ������A�K�v�ȋ@�\�͊g�����W���[���Ƃ��Ēlj�����A�Ƃ����̂� Python �̃|���V�[�ł��B
+
+�m�� �� �g�L�K�y ���� ������
diff --git a/Lib/test/datetimetester.py b/Lib/test/datetimetester.py
index 1bb74c6d969..004f4214574 100644
--- a/Lib/test/datetimetester.py
+++ b/Lib/test/datetimetester.py
@@ -1,11 +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
-"""
+"""Test the datetime module."""
 import bisect
+import contextlib
 import copy
 import decimal
 import io
@@ -26,7 +21,7 @@
 
 from test import support
 from test.support import is_resource_enabled, ALWAYS_EQ, LARGEST, SMALLEST
-from test.support import script_helper, warnings_helper
+from test.support import os_helper, script_helper, warnings_helper
 
 import datetime as datetime_module
 from datetime import MINYEAR, MAXYEAR
@@ -188,7 +183,7 @@ class NotEnough(tzinfo):
             def __init__(self, offset, name):
                 self.__offset = offset
                 self.__name = name
-        self.assertTrue(issubclass(NotEnough, tzinfo))
+        self.assertIsSubclass(NotEnough, tzinfo)
         ne = NotEnough(3, "NotByALongShot")
         self.assertIsInstance(ne, tzinfo)
 
@@ -237,7 +232,7 @@ def test_pickling_subclass(self):
                 self.assertIs(type(derived), otype)
                 self.assertEqual(derived.utcoffset(None), offset)
                 self.assertEqual(derived.tzname(None), oname)
-                self.assertFalse(hasattr(derived, 'spam'))
+                self.assertNotHasAttr(derived, 'spam')
 
     def test_issue23600(self):
         DSTDIFF = DSTOFFSET = timedelta(hours=1)
@@ -510,12 +505,16 @@ def test_harmful_mixed_comparison(self):
 #############################################################################
 # timedelta tests
 
+class SubclassTimeDelta(timedelta):
+    sub_var = 1
+
 class TestTimeDelta(HarmlessMixedComparison, unittest.TestCase):
 
     theclass = timedelta
 
     def test_constructor(self):
         eq = self.assertEqual
+        ra = self.assertRaises
         td = timedelta
 
         # Check keyword args to constructor
@@ -539,6 +538,15 @@ def test_constructor(self):
         eq(td(seconds=0.001), td(milliseconds=1))
         eq(td(milliseconds=0.001), td(microseconds=1))
 
+        # Check type of args to constructor
+        ra(TypeError, lambda: td(weeks='1'))
+        ra(TypeError, lambda: td(days='1'))
+        ra(TypeError, lambda: td(hours='1'))
+        ra(TypeError, lambda: td(minutes='1'))
+        ra(TypeError, lambda: td(seconds='1'))
+        ra(TypeError, lambda: td(milliseconds='1'))
+        ra(TypeError, lambda: td(microseconds='1'))
+
     def test_computations(self):
         eq = self.assertEqual
         td = timedelta
@@ -787,6 +795,15 @@ def test_repr(self):
         self.assertEqual(repr(self.theclass(seconds=1, microseconds=100)),
                          "%s(seconds=1, microseconds=100)" % name)
 
+    def test_repr_subclass(self):
+        """Subclasses should have bare names in the repr (gh-107773)."""
+        td = SubclassTimeDelta(days=1)
+        self.assertEqual(repr(td), "SubclassTimeDelta(days=1)")
+        td = SubclassTimeDelta(seconds=30)
+        self.assertEqual(repr(td), "SubclassTimeDelta(seconds=30)")
+        td = SubclassTimeDelta(weeks=2)
+        self.assertEqual(repr(td), "SubclassTimeDelta(days=14)")
+
     def test_roundtrip(self):
         for td in (timedelta(days=999999999, hours=23, minutes=59,
                              seconds=59, microseconds=999999),
@@ -796,7 +813,7 @@ def test_roundtrip(self):
 
             # Verify td -> string -> td identity.
             s = repr(td)
-            self.assertTrue(s.startswith('datetime.'))
+            self.assertStartsWith(s, 'datetime.')
             s = s[9:]
             td2 = eval(s)
             self.assertEqual(td, td2)
@@ -1115,6 +1132,85 @@ def test_delta_non_days_ignored(self):
         dt2 = dt - delta
         self.assertEqual(dt2, dt - days)
 
+    def test_strptime(self):
+        inputs = [
+            # Basic valid cases
+            (date(1998, 2, 3), '1998-02-03', '%Y-%m-%d'),
+            (date(2004, 12, 2), '2004-12-02', '%Y-%m-%d'),
+
+            # Edge cases: Leap year
+            (date(2020, 2, 29), '2020-02-29', '%Y-%m-%d'),  # Valid leap year date
+
+            # bpo-34482: Handle surrogate pairs
+            (date(2004, 12, 2), '2004-12\ud80002', '%Y-%m\ud800%d'),
+            (date(2004, 12, 2), '2004\ud80012-02', '%Y\ud800%m-%d'),
+
+            # Month/day variations
+            (date(2004, 2, 1), '2004-02', '%Y-%m'),  # No day provided
+            (date(2004, 2, 1), '02-2004', '%m-%Y'),  # Month and year swapped
+
+            # Different day-month-year formats
+            (date(2004, 12, 2), '02/12/2004', '%d/%m/%Y'),  # Day/Month/Year
+            (date(2004, 12, 2), '12/02/2004', '%m/%d/%Y'),  # Month/Day/Year
+
+            # Different separators
+            (date(2023, 9, 24), '24.09.2023', '%d.%m.%Y'),  # Dots as separators
+            (date(2023, 9, 24), '24-09-2023', '%d-%m-%Y'),  # Dashes
+            (date(2023, 9, 24), '2023/09/24', '%Y/%m/%d'),  # Slashes
+
+            # Handling years with fewer digits
+            (date(127, 2, 3), '0127-02-03', '%Y-%m-%d'),
+            (date(99, 2, 3), '0099-02-03', '%Y-%m-%d'),
+            (date(5, 2, 3), '0005-02-03', '%Y-%m-%d'),
+
+            # Variations on ISO 8601 format
+            (date(2023, 9, 25), '2023-W39-1', '%G-W%V-%u'),  # ISO week date (Week 39, Monday)
+            (date(2023, 9, 25), '2023-268', '%Y-%j'),  # Year and day of the year (Julian)
+        ]
+        for expected, string, format in inputs:
+            with self.subTest(string=string, format=format):
+                got = date.strptime(string, format)
+                self.assertEqual(expected, got)
+                self.assertIs(type(got), date)
+
+    def test_strptime_single_digit(self):
+        # bpo-34903: Check that single digit dates are allowed.
+        strptime = date.strptime
+        with self.assertRaises(ValueError):
+            # %y does require two digits.
+            newdate = strptime('01/02/3', '%d/%m/%y')
+
+        d1 = date(2003, 2, 1)
+        d2 = date(2003, 1, 2)
+        d3 = date(2003, 1, 25)
+        inputs = [
+            ('%d', '1/02/03',  '%d/%m/%y', d1),
+            ('%m', '01/2/03',  '%d/%m/%y', d1),
+            ('%j', '2/03',     '%j/%y',    d2),
+            ('%w', '6/04/03',  '%w/%U/%y', d1),
+            # %u requires a single digit.
+            ('%W', '6/4/2003', '%u/%W/%Y', d1),
+            ('%V', '6/4/2003', '%u/%V/%G', d3),
+        ]
+        for reason, string, format, target in inputs:
+            reason = 'test single digit ' + reason
+            with self.subTest(reason=reason,
+                              string=string,
+                              format=format,
+                              target=target):
+                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.
+            date.strptime('02-29', '%m-%d')
+        with self._assertNotWarns(DeprecationWarning):
+            date.strptime('20-03-14', '%y-%m-%d')
+            date.strptime('02-29,2024', '%m-%d,%Y')
+
 class SubclassDate(date):
     sub_var = 1
 
@@ -1135,7 +1231,7 @@ def test_roundtrip(self):
                    self.theclass.today()):
             # Verify dt -> string -> date identity.
             s = repr(dt)
-            self.assertTrue(s.startswith('datetime.'))
+            self.assertStartsWith(s, 'datetime.')
             s = s[9:]
             dt2 = eval(s)
             self.assertEqual(dt, dt2)
@@ -1144,6 +1240,15 @@ def test_roundtrip(self):
             dt2 = self.theclass(dt.year, dt.month, dt.day)
             self.assertEqual(dt, dt2)
 
+    def test_repr_subclass(self):
+        """Subclasses should have bare names in the repr (gh-107773)."""
+        td = SubclassDate(1, 2, 3)
+        self.assertEqual(repr(td), "SubclassDate(1, 2, 3)")
+        td = SubclassDate(2014, 1, 1)
+        self.assertEqual(repr(td), "SubclassDate(2014, 1, 1)")
+        td = SubclassDate(2010, 10, day=10)
+        self.assertEqual(repr(td), "SubclassDate(2010, 10, 10)")
+
     def test_ordinal_conversions(self):
         # Check some fixed values.
         for y, m, d, n in [(1, 1, 1, 1),      # calendar origin
@@ -1519,7 +1624,6 @@ def test_strftime(self):
         # bpo-41260: The parameter was named "fmt" in the pure python impl.
         t.strftime(format="%f")
 
-    @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
@@ -1620,7 +1724,6 @@ def test_pickling(self):
             self.assertEqual(orig, derived)
         self.assertEqual(orig.__reduce__(), orig.__reduce_ex__(2))
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_compat_unpickle(self):
         tests = [
             b"cdatetime\ndate\n(S'\\x07\\xdf\\x0b\\x1b'\ntR.",
@@ -1704,19 +1807,42 @@ def test_bool(self):
         self.assertTrue(self.theclass.min)
         self.assertTrue(self.theclass.max)
 
+    def check_strftime_y2k(self, specifier):
+        # Test that years less than 1000 are 0-padded; note that the beginning
+        # of an ISO 8601 year may fall in an ISO week of the year before, and
+        # therefore needs an offset of -1 when formatting with '%G'.
+        dataset = (
+            (1, 0),
+            (49, -1),
+            (70, 0),
+            (99, 0),
+            (100, -1),
+            (999, 0),
+            (1000, 0),
+            (1970, 0),
+        )
+        for year, g_offset in dataset:
+            with self.subTest(year=year, specifier=specifier):
+                d = self.theclass(year, 1, 1)
+                if specifier == 'G':
+                    year += g_offset
+                if specifier == 'C':
+                    expected = f"{year // 100:02d}"
+                else:
+                    expected = f"{year:04d}"
+                    if specifier == 'F':
+                        expected += f"-01-01"
+                self.assertEqual(d.strftime(f"%{specifier}"), expected)
+
     def test_strftime_y2k(self):
-        for y in (1, 49, 70, 99, 100, 999, 1000, 1970):
-            d = self.theclass(y, 1, 1)
-            # Issue 13305:  For years < 1000, the value is not always
-            # padded to 4 digits across platforms.  The C standard
-            # assumes year >= 1900, so it does not specify the number
-            # of digits.
-            if d.strftime("%Y") != '%04d' % y:
-                # Year 42 returns '42', not padded
-                self.assertEqual(d.strftime("%Y"), '%d' % y)
-                # '0042' is obtained anyway
-                if support.has_strftime_extensions:
-                    self.assertEqual(d.strftime("%4Y"), '%04d' % y)
+        self.check_strftime_y2k('Y')
+        self.check_strftime_y2k('G')
+
+    def test_strftime_y2k_c99(self):
+        # CPython requires C11; specifiers new in C99 must work.
+        # (Other implementations may want to disable this test.)
+        self.check_strftime_y2k('F')
+        self.check_strftime_y2k('C')
 
     def test_replace(self):
         cls = self.theclass
@@ -1867,6 +1993,26 @@ def test_backdoor_resistance(self):
             # blow up because other fields are insane.
             self.theclass(base[:2] + bytes([ord_byte]) + base[3:])
 
+    def test_valuerror_messages(self):
+        pattern = re.compile(
+            r"(year|month|day) must be in \d+\.\.\d+, not \d+"
+        )
+        test_cases = [
+            (2009, 13, 1),      # Month out of range
+            (2009, 0, 1),       # Month out of range
+            (10000, 12, 31),    # Year out of range
+            (0, 12, 31),        # Year out of range
+        ]
+        for case in test_cases:
+            with self.subTest(case):
+                with self.assertRaisesRegex(ValueError, pattern):
+                    self.theclass(*case)
+
+        # days out of range have their own error message, see issue 70647
+        with self.assertRaises(ValueError) as msg:
+            self.theclass(2009, 1, 32)
+        self.assertIn(f"day 32 must be in range 1..31 for month 1 in year 2009", str(msg.exception))
+
     def test_fromisoformat(self):
         # Test that isoformat() is reversible
         base_dates = [
@@ -1950,6 +2096,7 @@ def test_fromisoformat_fails(self):
             '10000-W25-1',      # Invalid year
             '2020-W25-0',       # Invalid day-of-week
             '2020-W25-8',       # Invalid day-of-week
+            '٢025-03-09'        # Unicode characters
             '2009\ud80002\ud80028',     # Separators are surrogate codepoints
         ]
 
@@ -2077,7 +2224,7 @@ def test_roundtrip(self):
                    self.theclass.now()):
             # Verify dt -> string -> datetime identity.
             s = repr(dt)
-            self.assertTrue(s.startswith('datetime.'))
+            self.assertStartsWith(s, 'datetime.')
             s = s[9:]
             dt2 = eval(s)
             self.assertEqual(dt, dt2)
@@ -2407,7 +2554,6 @@ def test_pickling_subclass_datetime(self):
             self.assertEqual(orig, derived)
             self.assertTrue(isinstance(derived, SubclassDatetime))
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_compat_unpickle(self):
         tests = [
             b'cdatetime\ndatetime\n('
@@ -2727,7 +2873,8 @@ def test_utcnow(self):
     def test_strptime(self):
         string = '2004-12-01 13:02:47.197'
         format = '%Y-%m-%d %H:%M:%S.%f'
-        expected = _strptime._strptime_datetime(self.theclass, string, format)
+        expected = _strptime._strptime_datetime_datetime(self.theclass, string,
+                                                         format)
         got = self.theclass.strptime(string, format)
         self.assertEqual(expected, got)
         self.assertIs(type(expected), self.theclass)
@@ -2741,8 +2888,8 @@ def test_strptime(self):
         ]
         for string, format in inputs:
             with self.subTest(string=string, format=format):
-                expected = _strptime._strptime_datetime(self.theclass, string,
-                                                        format)
+                expected = _strptime._strptime_datetime_datetime(self.theclass,
+                                                                 string, format)
                 got = self.theclass.strptime(string, format)
                 self.assertEqual(expected, got)
 
@@ -2864,8 +3011,7 @@ def test_more_strftime(self):
             self.assertEqual(t.strftime("%z"), "-0200" + z)
             self.assertEqual(t.strftime("%:z"), "-02:00:" + z)
 
-    @unittest.skip('TODO: RUSTPYTHON')
-    # UnicodeEncodeError: 'utf-8' codec can't encode character '\ud83d' in position 0: surrogates not allowed
+    @unittest.skip("TODO: RUSTPYTHON")
     def test_strftime_special(self):
         t = self.theclass(2004, 12, 31, 6, 22, 33, 47)
         s1 = t.strftime('%c')
@@ -3119,6 +3265,28 @@ class DateTimeSubclass(self.theclass):
                 self.assertEqual(res.year, 2013)
                 self.assertEqual(res.fold, fold)
 
+    def test_valuerror_messages(self):
+        pattern = re.compile(
+            r"(year|month|day|hour|minute|second) must "
+            r"be in \d+\.\.\d+, not \d+"
+        )
+        test_cases = [
+            (2009, 4, 1, 12, 30, 90),   # Second out of range
+            (2009, 4, 1, 12, 90, 45),   # Minute out of range
+            (2009, 4, 1, 25, 30, 45),   # Hour out of range
+            (2009, 13, 1, 24, 0, 0),    # Month out of range
+            (9999, 12, 31, 24, 0, 0),   # Year out of range
+        ]
+        for case in test_cases:
+            with self.subTest(case):
+                with self.assertRaisesRegex(ValueError, pattern):
+                    self.theclass(*case)
+
+        # days out of range have their own error message, see issue 70647
+        with self.assertRaises(ValueError) as msg:
+            self.theclass(2009, 4, 32, 24, 0, 0)
+        self.assertIn(f"day 32 must be in range 1..30 for month 4 in year 2009", str(msg.exception))
+
     def test_fromisoformat_datetime(self):
         # Test that isoformat() is reversible
         base_dates = [
@@ -3360,6 +3528,9 @@ def test_fromisoformat_datetime_examples(self):
             ('2025-01-02T03:04:05,678+00:00:10',
              self.theclass(2025, 1, 2, 3, 4, 5, 678000,
                            tzinfo=timezone(timedelta(seconds=10)))),
+            ('2025-01-02T24:00:00', self.theclass(2025, 1, 3, 0, 0, 0)),
+            ('2025-01-31T24:00:00', self.theclass(2025, 2, 1, 0, 0, 0)),
+            ('2025-12-31T24:00:00', self.theclass(2026, 1, 1, 0, 0, 0))
         ]
 
         for input_str, expected in examples:
@@ -3382,7 +3553,7 @@ def test_fromisoformat_fails_datetime(self):
             '2009-04-19T03:15:4500:00',     # Bad time zone separator
             '2009-04-19T03:15:45.123456+24:30',    # Invalid time zone offset
             '2009-04-19T03:15:45.123456-24:30',    # Invalid negative offset
-            '2009-04-10ᛇᛇᛇᛇᛇ12:15',         # Too many unicode separators
+            '2009-04-10ᛇᛇᛇᛇᛇ12:15',         # Unicode chars
             '2009-04\ud80010T12:15',        # Surrogate char in date
             '2009-04-10T12\ud80015',        # Surrogate char in time
             '2009-04-19T1',                 # Incomplete hours
@@ -3391,11 +3562,19 @@ def test_fromisoformat_fails_datetime(self):
             '2009-04-19T12:',               # Ends with time separator
             '2009-04-19T12:30:',            # Ends with time separator
             '2009-04-19T12:30:45.',         # Ends with time separator
-            '2009-04-19T12:30:45.123456+',  # Ends with timzone separator
-            '2009-04-19T12:30:45.123456-',  # Ends with timzone separator
+            '2009-04-19T12:30:45.123456+',  # Ends with timezone separator
+            '2009-04-19T12:30:45.123456-',  # Ends with timezone separator
             '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-19T24:00:00.000001',  # Has non-zero microseconds on 24:00
+            '2009-04-19T24:00:01.000000',  # Has non-zero seconds on 24:00
+            '2009-04-19T24:01:00.000000',  # Has non-zero minutes on 24:00
+            '2009-04-32T24:00:00.000000',  # Day is invalid before wrapping due to 24:00
+            '2009-13-01T24:00:00.000000',  # Month is invalid before wrapping due to 24:00
+            '9999-12-31T24:00:00.000000',  # Year is invalid after wrapping due to 24:00
+            '2009-04-19T12:30Z12:00',      # Extra time zone info after Z
+            '2009-04-19T12:30:45:334034',  # Invalid microsecond separator
             '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)
@@ -3406,6 +3585,29 @@ def test_fromisoformat_fails_datetime(self):
                 with self.assertRaises(ValueError):
                     self.theclass.fromisoformat(bad_str)
 
+    def test_fromisoformat_fails_datetime_valueerror(self):
+        pattern = re.compile(
+            r"(year|month|day|hour|minute|second) must "
+            r"be in \d+\.\.\d+, not \d+"
+        )
+        bad_strs = [
+            "2009-04-01T12:30:90",          # Second out of range
+            "2009-04-01T12:90:45",          # Minute out of range
+            "2009-04-01T25:30:45",          # Hour out of range
+            "2009-13-01T24:00:00",          # Month out of range
+            "9999-12-31T24:00:00",          # Year out of range
+        ]
+
+        for bad_str in bad_strs:
+            with self.subTest(bad_str=bad_str):
+                with self.assertRaisesRegex(ValueError, pattern):
+                    self.theclass.fromisoformat(bad_str)
+
+        # days out of range have their own error message, see issue 70647
+        with self.assertRaises(ValueError) as msg:
+            self.theclass.fromisoformat("2009-04-32T24:00:00")
+        self.assertIn(f"day 32 must be in range 1..30 for month 4 in year 2009", str(msg.exception))
+
     def test_fromisoformat_fails_surrogate(self):
         # Test that when fromisoformat() fails with a surrogate character as
         # the separator, the error message contains the original string
@@ -3432,6 +3634,15 @@ class DateTimeSubclass(self.theclass):
         self.assertEqual(dt, dt_rt)
         self.assertIsInstance(dt_rt, DateTimeSubclass)
 
+    def test_repr_subclass(self):
+        """Subclasses should have bare names in the repr (gh-107773)."""
+        td = SubclassDatetime(2014, 1, 1)
+        self.assertEqual(repr(td), "SubclassDatetime(2014, 1, 1, 0, 0)")
+        td = SubclassDatetime(2010, 10, day=10)
+        self.assertEqual(repr(td), "SubclassDatetime(2010, 10, 10, 0, 0)")
+        td = SubclassDatetime(2010, 10, 2, second=3)
+        self.assertEqual(repr(td), "SubclassDatetime(2010, 10, 2, 0, 0, 3)")
+
 
 class TestSubclassDateTime(TestDateTime):
     theclass = SubclassDatetime
@@ -3468,7 +3679,7 @@ def test_roundtrip(self):
 
         # Verify t -> string -> time identity.
         s = repr(t)
-        self.assertTrue(s.startswith('datetime.'))
+        self.assertStartsWith(s, 'datetime.')
         s = s[9:]
         t2 = eval(s)
         self.assertEqual(t, t2)
@@ -3668,8 +3879,7 @@ 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
+    @unittest.skip("TODO: RUSTPYTHON")
     def test_strftime_special(self):
         t = self.theclass(1, 2, 3, 4)
         s1 = t.strftime('%I%p%Z')
@@ -3744,6 +3954,19 @@ def test_repr(self):
         self.assertEqual(repr(self.theclass(23, 15, 0, 0)),
                          "%s(23, 15)" % name)
 
+    def test_repr_subclass(self):
+        """Subclasses should have bare names in the repr (gh-107773)."""
+        td = SubclassTime(hour=1)
+        self.assertEqual(repr(td), "SubclassTime(1, 0)")
+        td = SubclassTime(hour=2, minute=30)
+        self.assertEqual(repr(td), "SubclassTime(2, 30)")
+        td = SubclassTime(hour=2, minute=30, second=11)
+        self.assertEqual(repr(td), "SubclassTime(2, 30, 11)")
+        td = SubclassTime(minute=30, second=11, fold=0)
+        self.assertEqual(repr(td), "SubclassTime(0, 30, 11)")
+        td = SubclassTime(minute=30, second=11, fold=1)
+        self.assertEqual(repr(td), "SubclassTime(0, 30, 11, fold=1)")
+
     def test_resolution_info(self):
         self.assertIsInstance(self.theclass.min, self.theclass)
         self.assertIsInstance(self.theclass.max, self.theclass)
@@ -3768,7 +3991,6 @@ def test_pickling_subclass_time(self):
             self.assertEqual(orig, derived)
             self.assertTrue(isinstance(derived, SubclassTime))
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_compat_unpickle(self):
         tests = [
             (b"cdatetime\ntime\n(S'\\x14;\\x10\\x00\\x10\\x00'\ntR.",
@@ -3791,6 +4013,78 @@ def test_compat_unpickle(self):
                     derived = loads(data, encoding='latin1')
                     self.assertEqual(derived, expected)
 
+    def test_strptime(self):
+        # bpo-34482: Check that surrogates are handled properly.
+        inputs = [
+            (self.theclass(13, 2, 47, 197000), '13:02:47.197', '%H:%M:%S.%f'),
+            (self.theclass(13, 2, 47, 197000), '13:02\ud80047.197', '%H:%M\ud800%S.%f'),
+            (self.theclass(13, 2, 47, 197000), '13\ud80002:47.197', '%H\ud800%M:%S.%f'),
+        ]
+        for expected, string, format in inputs:
+            with self.subTest(string=string, format=format):
+                got = self.theclass.strptime(string, format)
+                self.assertEqual(expected, got)
+                self.assertIs(type(got), self.theclass)
+
+    def test_strptime_tz(self):
+        strptime = self.theclass.strptime
+        self.assertEqual(strptime("+0002", "%z").utcoffset(), 2 * MINUTE)
+        self.assertEqual(strptime("-0002", "%z").utcoffset(), -2 * MINUTE)
+        self.assertEqual(
+            strptime("-00:02:01.000003", "%z").utcoffset(),
+            -timedelta(minutes=2, seconds=1, microseconds=3)
+        )
+        # Only local timezone and UTC are supported
+        for tzseconds, tzname in ((0, 'UTC'), (0, 'GMT'),
+                                 (-_time.timezone, _time.tzname[0])):
+            if tzseconds < 0:
+                sign = '-'
+                seconds = -tzseconds
+            else:
+                sign ='+'
+                seconds = tzseconds
+            hours, minutes = divmod(seconds//60, 60)
+            tstr = "{}{:02d}{:02d} {}".format(sign, hours, minutes, tzname)
+            with self.subTest(tstr=tstr):
+                t = strptime(tstr, "%z %Z")
+                self.assertEqual(t.utcoffset(), timedelta(seconds=tzseconds))
+                self.assertEqual(t.tzname(), tzname)
+                self.assertIs(type(t), self.theclass)
+
+        # Can produce inconsistent time
+        tstr, fmt = "+1234 UTC", "%z %Z"
+        t = strptime(tstr, fmt)
+        self.assertEqual(t.utcoffset(), 12 * HOUR + 34 * MINUTE)
+        self.assertEqual(t.tzname(), 'UTC')
+        # yet will roundtrip
+        self.assertEqual(t.strftime(fmt), tstr)
+
+        # Produce naive time if no %z is provided
+        self.assertEqual(strptime("UTC", "%Z").tzinfo, None)
+
+    def test_strptime_errors(self):
+        for tzstr in ("-2400", "-000", "z"):
+            with self.assertRaises(ValueError):
+                self.theclass.strptime(tzstr, "%z")
+
+    def test_strptime_single_digit(self):
+        # bpo-34903: Check that single digit times are allowed.
+        t = self.theclass(4, 5, 6)
+        inputs = [
+            ('%H', '4:05:06',   '%H:%M:%S',   t),
+            ('%M', '04:5:06',   '%H:%M:%S',   t),
+            ('%S', '04:05:6',   '%H:%M:%S',   t),
+            ('%I', '4am:05:06', '%I%p:%M:%S', t),
+        ]
+        for reason, string, format, target in inputs:
+            reason = 'test single digit ' + reason
+            with self.subTest(reason=reason,
+                              string=string,
+                              format=format,
+                              target=target):
+                newdate = self.theclass.strptime(string, format)
+                self.assertEqual(newdate, target, msg=reason)
+
     def test_bool(self):
         # time is always True.
         cls = self.theclass
@@ -4066,8 +4360,7 @@ 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
+    @unittest.skip("TODO: RUSTPYTHON")
     def test_zones(self):
         est = FixedOffset(-300, "EST", 1)
         utc = FixedOffset(0, "UTC", -2)
@@ -4186,7 +4479,6 @@ def test_pickling(self):
             self.assertEqual(derived.tzname(), 'cookie')
         self.assertEqual(orig.__reduce__(), orig.__reduce_ex__(2))
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_compat_unpickle(self):
         tests = [
             b"cdatetime\ntime\n(S'\\x05\\x06\\x07\\x01\\xe2@'\n"
@@ -4316,6 +4608,21 @@ def utcoffset(self, t):
         t2 = t2.replace(tzinfo=Varies())
         self.assertTrue(t1 < t2)  # t1's offset counter still going up
 
+    def test_valuerror_messages(self):
+        pattern = re.compile(
+            r"(hour|minute|second|microsecond) must be in \d+\.\.\d+, not \d+"
+        )
+        test_cases = [
+            (12, 30, 90, 9999991),  # Microsecond out of range
+            (12, 30, 90, 000000),   # Second out of range
+            (25, 30, 45, 000000),   # Hour out of range
+            (12, 90, 45, 000000),   # Minute out of range
+        ]
+        for case in test_cases:
+            with self.subTest(case):
+                with self.assertRaisesRegex(ValueError, pattern):
+                    self.theclass(*case)
+
     def test_fromisoformat(self):
         time_examples = [
             (0, 0, 0, 0),
@@ -4365,7 +4672,7 @@ def test_fromisoformat_timezone(self):
 
             with self.subTest(tstr=tstr):
                 t_rt = self.theclass.fromisoformat(tstr)
-                assert t == t_rt, t_rt
+                assert t == t_rt
 
     def test_fromisoformat_timespecs(self):
         time_bases = [
@@ -4424,6 +4731,7 @@ def test_fromisoformat_time_examples(self):
             ('00:00:00.000', self.theclass(0, 0)),
             ('000000.000000', self.theclass(0, 0)),
             ('00:00:00.000000', self.theclass(0, 0)),
+            ('00:00:00,100000', self.theclass(0, 0, 0, 100000)),
             ('1200', self.theclass(12, 0)),
             ('12:00', self.theclass(12, 0)),
             ('120000', self.theclass(12, 0)),
@@ -4489,6 +4797,10 @@ 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.5',                     # Decimal mark at end of hour
+            '12:30,5',                  # Decimal mark at end of minute
+            '12:30:45.123456Z12:00',    # Extra time zone info after Z
+            '12:30:45:334034',          # Invalid microsecond separator
             '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)
@@ -4652,7 +4964,6 @@ def test_pickling(self):
             self.assertEqual(derived.tzname(), 'cookie')
         self.assertEqual(orig.__reduce__(), orig.__reduce_ex__(2))
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_compat_unpickle(self):
         tests = [
             b'cdatetime\ndatetime\n'
@@ -5829,21 +6140,21 @@ def test_vilnius_1941_fromutc(self):
 
         gdt = datetime(1941, 6, 23, 20, 59, 59, tzinfo=timezone.utc)
         ldt = gdt.astimezone(Vilnius)
-        self.assertEqual(ldt.strftime("%c %Z%z"),
+        self.assertEqual(ldt.strftime("%a %b %d %H:%M:%S %Y %Z%z"),
                          'Mon Jun 23 23:59:59 1941 MSK+0300')
         self.assertEqual(ldt.fold, 0)
         self.assertFalse(ldt.dst())
 
         gdt = datetime(1941, 6, 23, 21, tzinfo=timezone.utc)
         ldt = gdt.astimezone(Vilnius)
-        self.assertEqual(ldt.strftime("%c %Z%z"),
+        self.assertEqual(ldt.strftime("%a %b %d %H:%M:%S %Y %Z%z"),
                          'Mon Jun 23 23:00:00 1941 CEST+0200')
         self.assertEqual(ldt.fold, 1)
         self.assertTrue(ldt.dst())
 
         gdt = datetime(1941, 6, 23, 22, tzinfo=timezone.utc)
         ldt = gdt.astimezone(Vilnius)
-        self.assertEqual(ldt.strftime("%c %Z%z"),
+        self.assertEqual(ldt.strftime("%a %b %d %H:%M:%S %Y %Z%z"),
                          'Tue Jun 24 00:00:00 1941 CEST+0200')
         self.assertEqual(ldt.fold, 0)
         self.assertTrue(ldt.dst())
@@ -5853,22 +6164,22 @@ def test_vilnius_1941_toutc(self):
 
         ldt = datetime(1941, 6, 23, 22, 59, 59, tzinfo=Vilnius)
         gdt = ldt.astimezone(timezone.utc)
-        self.assertEqual(gdt.strftime("%c %Z"),
+        self.assertEqual(gdt.strftime("%a %b %d %H:%M:%S %Y %Z"),
                          'Mon Jun 23 19:59:59 1941 UTC')
 
         ldt = datetime(1941, 6, 23, 23, 59, 59, tzinfo=Vilnius)
         gdt = ldt.astimezone(timezone.utc)
-        self.assertEqual(gdt.strftime("%c %Z"),
+        self.assertEqual(gdt.strftime("%a %b %d %H:%M:%S %Y %Z"),
                          'Mon Jun 23 20:59:59 1941 UTC')
 
         ldt = datetime(1941, 6, 23, 23, 59, 59, tzinfo=Vilnius, fold=1)
         gdt = ldt.astimezone(timezone.utc)
-        self.assertEqual(gdt.strftime("%c %Z"),
+        self.assertEqual(gdt.strftime("%a %b %d %H:%M:%S %Y %Z"),
                          'Mon Jun 23 21:59:59 1941 UTC')
 
         ldt = datetime(1941, 6, 24, 0, tzinfo=Vilnius)
         gdt = ldt.astimezone(timezone.utc)
-        self.assertEqual(gdt.strftime("%c %Z"),
+        self.assertEqual(gdt.strftime("%a %b %d %H:%M:%S %Y %Z"),
                          'Mon Jun 23 22:00:00 1941 UTC')
 
     def test_constructors(self):
@@ -6394,6 +6705,17 @@ def test_gaps(self):
                 ldt = tz.fromutc(udt.replace(tzinfo=tz))
                 self.assertEqual(ldt.fold, 0)
 
+    @classmethod
+    @contextlib.contextmanager
+    def _change_tz(cls, new_tzinfo):
+        try:
+            with os_helper.EnvironmentVarGuard() as env:
+                env["TZ"] = new_tzinfo
+                _time.tzset()
+                yield
+        finally:
+            _time.tzset()
+
     @unittest.skipUnless(
         hasattr(_time, "tzset"), "time module has no attribute tzset"
     )
@@ -6408,10 +6730,7 @@ def test_system_transitions(self):
                 self.zonename.startswith('right/')):
             self.skipTest("Skipping %s" % self.zonename)
         tz = self.tz
-        TZ = os.environ.get('TZ')
-        os.environ['TZ'] = self.zonename
-        try:
-            _time.tzset()
+        with self._change_tz(self.zonename):
             for udt, shift in tz.transitions():
                 if udt.year >= 2037:
                     # System support for times around the end of 32-bit time_t
@@ -6419,7 +6738,7 @@ def test_system_transitions(self):
                     break
                 s0 = (udt - datetime(1970, 1, 1)) // SEC
                 ss = shift // SEC   # shift seconds
-                for x in [-40 * 3600, -20*3600, -1, 0,
+                for x in [-40 * 3600, -20 * 3600, -1, 0,
                           ss - 1, ss + 20 * 3600, ss + 40 * 3600]:
                     s = s0 + x
                     sdt = datetime.fromtimestamp(s)
@@ -6438,12 +6757,6 @@ def test_system_transitions(self):
                     utc0 = dt.astimezone(timezone.utc)
                     utc1 = dt.replace(fold=1).astimezone(timezone.utc)
                     self.assertEqual(utc0, utc1 + timedelta(0, ss))
-        finally:
-            if TZ is None:
-                del os.environ['TZ']
-            else:
-                os.environ['TZ'] = TZ
-            _time.tzset()
 
 
 class ZoneInfoCompleteTest(unittest.TestSuite):
@@ -6939,9 +7252,6 @@ def pickle_fake_date(datetime_) -> Type[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("""
@@ -6974,6 +7284,34 @@ def test_update_type_cache(self):
             """)
         script_helper.assert_python_ok('-c', script)
 
+    def test_concurrent_initialization_subinterpreter(self):
+        # gh-136421: Concurrent initialization of _datetime across multiple
+        # interpreters wasn't thread-safe due to its static types.
+
+        # Run in a subprocess to ensure we get a clean version of _datetime
+        script = """if True:
+        from concurrent.futures import InterpreterPoolExecutor
+
+        def func():
+            import _datetime
+            print('a', end='')
+
+        with InterpreterPoolExecutor() as executor:
+            for _ in range(8):
+                executor.submit(func)
+        """
+        rc, out, err = script_helper.assert_python_ok("-c", script)
+        self.assertEqual(rc, 0)
+        self.assertEqual(out, b"a" * 8)
+        self.assertEqual(err, b"")
+
+        # Now test against concurrent reinitialization
+        script = "import _datetime\n" + script
+        rc, out, err = script_helper.assert_python_ok("-c", script)
+        self.assertEqual(rc, 0)
+        self.assertEqual(out, b"a" * 8)
+        self.assertEqual(err, b"")
+
 
 def load_tests(loader, standard_tests, pattern):
     standard_tests.addTest(ZoneInfoCompleteTest())
diff --git a/Lib/test/dis_module.py b/Lib/test/dis_module.py
new file mode 100644
index 00000000000..afbf600fdee
--- /dev/null
+++ b/Lib/test/dis_module.py
@@ -0,0 +1,5 @@
+
+# A simple module for testing the dis module.
+
+def f(): pass
+def g(): pass
diff --git a/Lib/test/libregrtest/save_env.py b/Lib/test/libregrtest/save_env.py
index 0ec12d7c475..eeb1f17d702 100644
--- a/Lib/test/libregrtest/save_env.py
+++ b/Lib/test/libregrtest/save_env.py
@@ -240,7 +240,9 @@ def get_multiprocessing_process__dangling(self):
         # Unjoined process objects can survive after process exits
         multiprocessing_process._cleanup()
         # This copies the weakrefs without making any strong reference
-        return multiprocessing_process._dangling.copy()
+        # TODO: RUSTPYTHON - filter out dead processes since gc doesn't clean WeakSet. Revert this line when we have a GC
+        # return multiprocessing_process._dangling.copy()
+        return {p for p in multiprocessing_process._dangling if p.is_alive()}
     def restore_multiprocessing_process__dangling(self, saved):
         multiprocessing_process = self.get_module('multiprocessing.process')
         multiprocessing_process._dangling.clear()
diff --git a/Lib/test/list_tests.py b/Lib/test/list_tests.py
index 65dfa41b26e..e76f79c274e 100644
--- a/Lib/test/list_tests.py
+++ b/Lib/test/list_tests.py
@@ -6,7 +6,8 @@
 from functools import cmp_to_key
 
 from test import seq_tests
-from test.support import ALWAYS_EQ, NEVER_EQ, get_c_recursion_limit
+from test.support import ALWAYS_EQ, NEVER_EQ
+from test.support import skip_emscripten_stack_overflow, skip_wasi_stack_overflow
 
 
 class CommonTest(seq_tests.CommonTest):
@@ -59,9 +60,11 @@ def test_repr(self):
         self.assertEqual(str(a2), "[0, 1, 2, [...], 3]")
         self.assertEqual(repr(a2), "[0, 1, 2, [...], 3]")
 
+    @skip_wasi_stack_overflow()
+    @skip_emscripten_stack_overflow()
     def test_repr_deep(self):
         a = self.type2test([])
-        for i in range(get_c_recursion_limit() + 1):
+        for i in range(200_000):
             a = self.type2test([a])
         self.assertRaises(RecursionError, repr, a)
 
diff --git a/Lib/test/lock_tests.py b/Lib/test/lock_tests.py
index 4031bfaeb64..8c7a4f76563 100644
--- a/Lib/test/lock_tests.py
+++ b/Lib/test/lock_tests.py
@@ -162,7 +162,7 @@ def f():
         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()
@@ -210,7 +210,7 @@ def with_lock(err=None):
         with Bunch(f, 1):
             pass
 
-    @unittest.skip('TODO: RUSTPYTHON; sometimes hangs')
+    @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.
@@ -334,6 +334,26 @@ class RLockTests(BaseLockTests):
     """
     Tests for recursive locks.
     """
+    def test_repr_count(self):
+        # see gh-134322: check that count values are correct:
+        # when a rlock is just created,
+        # in a second thread when rlock is acquired in the main thread.
+        lock = self.locktype()
+        self.assertIn("count=0", repr(lock))
+        self.assertIn("<unlocked", repr(lock))
+        lock.acquire()
+        lock.acquire()
+        self.assertIn("count=2", repr(lock))
+        self.assertIn("<locked", repr(lock))
+
+        result = []
+        def call_repr():
+            result.append(repr(lock))
+        with Bunch(call_repr, 1):
+            pass
+        self.assertIn("count=2", result[0])
+        self.assertIn("<locked", result[0])
+
     def test_reacquire(self):
         lock = self.locktype()
         lock.acquire()
@@ -355,6 +375,36 @@ def test_release_unacquired(self):
         lock.release()
         self.assertRaises(RuntimeError, lock.release)
 
+    def test_locked(self):
+        lock = self.locktype()
+        self.assertFalse(lock.locked())
+        lock.acquire()
+        self.assertTrue(lock.locked())
+        lock.acquire()
+        self.assertTrue(lock.locked())
+        lock.release()
+        self.assertTrue(lock.locked())
+        lock.release()
+        self.assertFalse(lock.locked())
+
+    def test_locked_with_2threads(self):
+        # see gh-134323: check that a rlock which
+        # is acquired in a different thread,
+        # is still locked in the main thread.
+        result = []
+        rlock = self.locktype()
+        self.assertFalse(rlock.locked())
+        def acquire():
+            result.append(rlock.locked())
+            rlock.acquire()
+            result.append(rlock.locked())
+
+        with Bunch(acquire, 1):
+            pass
+        self.assertTrue(rlock.locked())
+        self.assertFalse(result[0])
+        self.assertTrue(result[1])
+
     def test_release_save_unacquired(self):
         # Cannot _release_save an unacquired lock
         lock = self.locktype()
diff --git a/Lib/test/mapping_tests.py b/Lib/test/mapping_tests.py
index 53f29f60538..20306e1526d 100644
--- a/Lib/test/mapping_tests.py
+++ b/Lib/test/mapping_tests.py
@@ -1,7 +1,7 @@
 # tests common to dict and UserDict
 import unittest
 import collections
-import sys
+from test import support
 
 
 class BasicTestMappingProtocol(unittest.TestCase):
@@ -70,8 +70,8 @@ def test_read(self):
         if not d: self.fail("Full mapping must compare to True")
         # keys(), items(), iterkeys() ...
         def check_iterandlist(iter, lst, ref):
-            self.assertTrue(hasattr(iter, '__next__'))
-            self.assertTrue(hasattr(iter, '__iter__'))
+            self.assertHasAttr(iter, '__next__')
+            self.assertHasAttr(iter, '__iter__')
             x = list(iter)
             self.assertTrue(set(x)==set(lst)==set(ref))
         check_iterandlist(iter(d.keys()), list(d.keys()),
@@ -448,7 +448,7 @@ def __new__(cls):
         class Exc(Exception): pass
 
         class baddict1(self.type2test):
-            def __init__(self):
+            def __init__(self, *args, **kwargs):
                 raise Exc()
 
         self.assertRaises(Exc, baddict1.fromkeys, [1])
@@ -595,12 +595,14 @@ def test_mutatingiteration(self):
         d = self._empty_mapping()
         d[1] = 1
         try:
+            count = 0
             for i in d:
                 d[i+1] = 1
+                if count >= 1:
+                    self.fail("changing dict size during iteration doesn't raise Error")
+                count += 1
         except RuntimeError:
             pass
-        else:
-            self.fail("changing dict size during iteration doesn't raise Error")
 
     def test_repr(self):
         d = self._empty_mapping()
@@ -620,9 +622,12 @@ def __repr__(self):
         d = self._full_mapping({1: BadRepr()})
         self.assertRaises(Exc, repr, d)
 
+    @support.skip_wasi_stack_overflow()
+    @support.skip_emscripten_stack_overflow()
+    @support.skip_if_sanitizer("requires deep stack", ub=True)
     def test_repr_deep(self):
         d = self._empty_mapping()
-        for i in range(sys.getrecursionlimit() + 100):
+        for i in range(support.exceeds_recursion_limit()):
             d0 = d
             d = self._empty_mapping()
             d[1] = d0
diff --git a/Lib/test/multibytecodec_support.py b/Lib/test/multibytecodec_support.py
new file mode 100644
index 00000000000..6b4c57d0b4b
--- /dev/null
+++ b/Lib/test/multibytecodec_support.py
@@ -0,0 +1,400 @@
+#
+# multibytecodec_support.py
+#   Common Unittest Routines for CJK codecs
+#
+
+import codecs
+import os
+import re
+import sys
+import unittest
+from http.client import HTTPException
+from test import support
+from io import BytesIO
+
+class TestBase:
+    encoding        = ''   # codec name
+    codec           = None # codec tuple (with 4 elements)
+    tstring         = None # must set. 2 strings to test StreamReader
+
+    codectests      = None # must set. codec test tuple
+    roundtriptest   = 1    # set if roundtrip is possible with unicode
+    has_iso10646    = 0    # set if this encoding contains whole iso10646 map
+    xmlcharnametest = None # string to test xmlcharrefreplace
+    unmappedunicode = '\udeee' # a unicode code point that is not mapped.
+
+    def setUp(self):
+        if self.codec is None:
+            self.codec = codecs.lookup(self.encoding)
+        self.encode = self.codec.encode
+        self.decode = self.codec.decode
+        self.reader = self.codec.streamreader
+        self.writer = self.codec.streamwriter
+        self.incrementalencoder = self.codec.incrementalencoder
+        self.incrementaldecoder = self.codec.incrementaldecoder
+
+    def test_chunkcoding(self):
+        tstring_lines = []
+        for b in self.tstring:
+            lines = b.split(b"\n")
+            last = lines.pop()
+            assert last == b""
+            lines = [line + b"\n" for line in lines]
+            tstring_lines.append(lines)
+        for native, utf8 in zip(*tstring_lines):
+            u = self.decode(native)[0]
+            self.assertEqual(u, utf8.decode('utf-8'))
+            if self.roundtriptest:
+                self.assertEqual(native, self.encode(u)[0])
+
+    def test_errorhandle(self):
+        for source, scheme, expected in self.codectests:
+            if isinstance(source, bytes):
+                func = self.decode
+            else:
+                func = self.encode
+            if expected:
+                result = func(source, scheme)[0]
+                if func is self.decode:
+                    self.assertTrue(type(result) is str, type(result))
+                    self.assertEqual(result, expected,
+                                     '%a.decode(%r, %r)=%a != %a'
+                                     % (source, self.encoding, scheme, result,
+                                        expected))
+                else:
+                    self.assertTrue(type(result) is bytes, type(result))
+                    self.assertEqual(result, expected,
+                                     '%a.encode(%r, %r)=%a != %a'
+                                     % (source, self.encoding, scheme, result,
+                                        expected))
+            else:
+                self.assertRaises(UnicodeError, func, source, scheme)
+
+    def test_xmlcharrefreplace(self):
+        if self.has_iso10646:
+            self.skipTest('encoding contains full ISO 10646 map')
+
+        s = "\u0b13\u0b23\u0b60 nd eggs"
+        self.assertEqual(
+            self.encode(s, "xmlcharrefreplace")[0],
+            b"&#2835;&#2851;&#2912; nd eggs"
+        )
+
+    def test_customreplace_encode(self):
+        if self.has_iso10646:
+            self.skipTest('encoding contains full ISO 10646 map')
+
+        from html.entities import codepoint2name
+
+        def xmlcharnamereplace(exc):
+            if not isinstance(exc, UnicodeEncodeError):
+                raise TypeError("don't know how to handle %r" % exc)
+            l = []
+            for c in exc.object[exc.start:exc.end]:
+                if ord(c) in codepoint2name:
+                    l.append("&%s;" % codepoint2name[ord(c)])
+                else:
+                    l.append("&#%d;" % ord(c))
+            return ("".join(l), exc.end)
+
+        codecs.register_error("test.xmlcharnamereplace", xmlcharnamereplace)
+
+        if self.xmlcharnametest:
+            sin, sout = self.xmlcharnametest
+        else:
+            sin = "\xab\u211c\xbb = \u2329\u1234\u232a"
+            sout = b"&laquo;&real;&raquo; = &lang;&#4660;&rang;"
+        self.assertEqual(self.encode(sin,
+                                    "test.xmlcharnamereplace")[0], sout)
+
+    def test_callback_returns_bytes(self):
+        def myreplace(exc):
+            return (b"1234", exc.end)
+        codecs.register_error("test.cjktest", myreplace)
+        enc = self.encode("abc" + self.unmappedunicode + "def", "test.cjktest")[0]
+        self.assertEqual(enc, b"abc1234def")
+
+    def test_callback_wrong_objects(self):
+        def myreplace(exc):
+            return (ret, exc.end)
+        codecs.register_error("test.cjktest", myreplace)
+
+        for ret in ([1, 2, 3], [], None, object()):
+            self.assertRaises(TypeError, self.encode, self.unmappedunicode,
+                              'test.cjktest')
+
+    def test_callback_long_index(self):
+        def myreplace(exc):
+            return ('x', int(exc.end))
+        codecs.register_error("test.cjktest", myreplace)
+        self.assertEqual(self.encode('abcd' + self.unmappedunicode + 'efgh',
+                                     'test.cjktest'), (b'abcdxefgh', 9))
+
+        def myreplace(exc):
+            return ('x', sys.maxsize + 1)
+        codecs.register_error("test.cjktest", myreplace)
+        self.assertRaises(IndexError, self.encode, self.unmappedunicode,
+                          'test.cjktest')
+
+    def test_callback_None_index(self):
+        def myreplace(exc):
+            return ('x', None)
+        codecs.register_error("test.cjktest", myreplace)
+        self.assertRaises(TypeError, self.encode, self.unmappedunicode,
+                          'test.cjktest')
+
+    def test_callback_backward_index(self):
+        def myreplace(exc):
+            if myreplace.limit > 0:
+                myreplace.limit -= 1
+                return ('REPLACED', 0)
+            else:
+                return ('TERMINAL', exc.end)
+        myreplace.limit = 3
+        codecs.register_error("test.cjktest", myreplace)
+        self.assertEqual(self.encode('abcd' + self.unmappedunicode + 'efgh',
+                                     'test.cjktest'),
+                (b'abcdREPLACEDabcdREPLACEDabcdREPLACEDabcdTERMINALefgh', 9))
+
+    def test_callback_forward_index(self):
+        def myreplace(exc):
+            return ('REPLACED', exc.end + 2)
+        codecs.register_error("test.cjktest", myreplace)
+        self.assertEqual(self.encode('abcd' + self.unmappedunicode + 'efgh',
+                                     'test.cjktest'), (b'abcdREPLACEDgh', 9))
+
+    def test_callback_index_outofbound(self):
+        def myreplace(exc):
+            return ('TERM', 100)
+        codecs.register_error("test.cjktest", myreplace)
+        self.assertRaises(IndexError, self.encode, self.unmappedunicode,
+                          'test.cjktest')
+
+    def test_incrementalencoder(self):
+        UTF8Reader = codecs.getreader('utf-8')
+        for sizehint in [None] + list(range(1, 33)) + \
+                        [64, 128, 256, 512, 1024]:
+            istream = UTF8Reader(BytesIO(self.tstring[1]))
+            ostream = BytesIO()
+            encoder = self.incrementalencoder()
+            while 1:
+                if sizehint is not None:
+                    data = istream.read(sizehint)
+                else:
+                    data = istream.read()
+
+                if not data:
+                    break
+                e = encoder.encode(data)
+                ostream.write(e)
+
+            self.assertEqual(ostream.getvalue(), self.tstring[0])
+
+    def test_incrementaldecoder(self):
+        UTF8Writer = codecs.getwriter('utf-8')
+        for sizehint in [None, -1] + list(range(1, 33)) + \
+                        [64, 128, 256, 512, 1024]:
+            istream = BytesIO(self.tstring[0])
+            ostream = UTF8Writer(BytesIO())
+            decoder = self.incrementaldecoder()
+            while 1:
+                data = istream.read(sizehint)
+                if not data:
+                    break
+                else:
+                    u = decoder.decode(data)
+                    ostream.write(u)
+
+            self.assertEqual(ostream.getvalue(), self.tstring[1])
+
+    def test_incrementalencoder_error_callback(self):
+        inv = self.unmappedunicode
+
+        e = self.incrementalencoder()
+        self.assertRaises(UnicodeEncodeError, e.encode, inv, True)
+
+        e.errors = 'ignore'
+        self.assertEqual(e.encode(inv, True), b'')
+
+        e.reset()
+        def tempreplace(exc):
+            return ('called', exc.end)
+        codecs.register_error('test.incremental_error_callback', tempreplace)
+        e.errors = 'test.incremental_error_callback'
+        self.assertEqual(e.encode(inv, True), b'called')
+
+        # again
+        e.errors = 'ignore'
+        self.assertEqual(e.encode(inv, True), b'')
+
+    def test_streamreader(self):
+        UTF8Writer = codecs.getwriter('utf-8')
+        for name in ["read", "readline", "readlines"]:
+            for sizehint in [None, -1] + list(range(1, 33)) + \
+                            [64, 128, 256, 512, 1024]:
+                istream = self.reader(BytesIO(self.tstring[0]))
+                ostream = UTF8Writer(BytesIO())
+                func = getattr(istream, name)
+                while 1:
+                    data = func(sizehint)
+                    if not data:
+                        break
+                    if name == "readlines":
+                        ostream.writelines(data)
+                    else:
+                        ostream.write(data)
+
+                self.assertEqual(ostream.getvalue(), self.tstring[1])
+
+    def test_streamwriter(self):
+        readfuncs = ('read', 'readline', 'readlines')
+        UTF8Reader = codecs.getreader('utf-8')
+        for name in readfuncs:
+            for sizehint in [None] + list(range(1, 33)) + \
+                            [64, 128, 256, 512, 1024]:
+                istream = UTF8Reader(BytesIO(self.tstring[1]))
+                ostream = self.writer(BytesIO())
+                func = getattr(istream, name)
+                while 1:
+                    if sizehint is not None:
+                        data = func(sizehint)
+                    else:
+                        data = func()
+
+                    if not data:
+                        break
+                    if name == "readlines":
+                        ostream.writelines(data)
+                    else:
+                        ostream.write(data)
+
+                self.assertEqual(ostream.getvalue(), self.tstring[0])
+
+    def test_streamwriter_reset_no_pending(self):
+        # Issue #23247: Calling reset() on a fresh StreamWriter instance
+        # (without pending data) must not crash
+        stream = BytesIO()
+        writer = self.writer(stream)
+        writer.reset()
+
+    def test_incrementalencoder_del_segfault(self):
+        e = self.incrementalencoder()
+        with self.assertRaises(AttributeError):
+            del e.errors
+
+    def test_null_terminator(self):
+        # see gh-101828
+        text = "フルーツ"
+        try:
+            text.encode(self.encoding)
+        except UnicodeEncodeError:
+            text = "Python is cool"
+        encode_w_null = (text + "\0").encode(self.encoding)
+        encode_plus_null = text.encode(self.encoding) + "\0".encode(self.encoding)
+        self.assertTrue(encode_w_null.endswith(b'\x00'))
+        self.assertEqual(encode_w_null, encode_plus_null)
+
+        encode_w_null_2 = (text + "\0" + text + "\0").encode(self.encoding)
+        encode_plus_null_2 = encode_plus_null + encode_plus_null
+        self.assertEqual(encode_w_null_2.count(b'\x00'), 2)
+        self.assertEqual(encode_w_null_2, encode_plus_null_2)
+
+
+class TestBase_Mapping(unittest.TestCase):
+    pass_enctest = []
+    pass_dectest = []
+    supmaps = []
+    codectests = []
+
+    def setUp(self):
+        try:
+            self.open_mapping_file().close() # test it to report the error early
+        except (OSError, HTTPException):
+            self.skipTest("Could not retrieve "+self.mapfileurl)
+
+    def open_mapping_file(self):
+        return support.open_urlresource(self.mapfileurl, encoding="utf-8")
+
+    def test_mapping_file(self):
+        if self.mapfileurl.endswith('.xml'):
+            self._test_mapping_file_ucm()
+        else:
+            self._test_mapping_file_plain()
+
+    def _test_mapping_file_plain(self):
+        def unichrs(s):
+            return ''.join(chr(int(x, 16)) for x in s.split('+'))
+
+        urt_wa = {}
+
+        with self.open_mapping_file() as f:
+            for line in f:
+                if not line:
+                    break
+                data = line.split('#')[0].split()
+                if len(data) != 2:
+                    continue
+
+                if data[0][:2] != '0x':
+                    self.fail(f"Invalid line: {line!r}")
+                csetch = bytes.fromhex(data[0][2:])
+                if len(csetch) == 1 and 0x80 <= csetch[0]:
+                    continue
+
+                unich = unichrs(data[1])
+                if ord(unich) == 0xfffd or unich in urt_wa:
+                    continue
+                urt_wa[unich] = csetch
+
+                self._testpoint(csetch, unich)
+
+    def _test_mapping_file_ucm(self):
+        with self.open_mapping_file() as f:
+            ucmdata = f.read()
+        uc = re.findall('<a u="([A-F0-9]{4})" b="([0-9A-F ]+)"/>', ucmdata)
+        for uni, coded in uc:
+            unich = chr(int(uni, 16))
+            codech = bytes.fromhex(coded)
+            self._testpoint(codech, unich)
+
+    def test_mapping_supplemental(self):
+        for mapping in self.supmaps:
+            self._testpoint(*mapping)
+
+    def _testpoint(self, csetch, unich):
+        if (csetch, unich) not in self.pass_enctest:
+            self.assertEqual(unich.encode(self.encoding), csetch)
+        if (csetch, unich) not in self.pass_dectest:
+            self.assertEqual(str(csetch, self.encoding), unich)
+
+    def test_errorhandle(self):
+        for source, scheme, expected in self.codectests:
+            if isinstance(source, bytes):
+                func = source.decode
+            else:
+                func = source.encode
+            if expected:
+                if isinstance(source, bytes):
+                    result = func(self.encoding, scheme)
+                    self.assertTrue(type(result) is str, type(result))
+                    self.assertEqual(result, expected,
+                                     '%a.decode(%r, %r)=%a != %a'
+                                     % (source, self.encoding, scheme, result,
+                                        expected))
+                else:
+                    result = func(self.encoding, scheme)
+                    self.assertTrue(type(result) is bytes, type(result))
+                    self.assertEqual(result, expected,
+                                     '%a.encode(%r, %r)=%a != %a'
+                                     % (source, self.encoding, scheme, result,
+                                        expected))
+            else:
+                self.assertRaises(UnicodeError, func, self.encoding, scheme)
+
+def load_teststring(name):
+    dir = os.path.join(os.path.dirname(__file__), 'cjkencodings')
+    with open(os.path.join(dir, name + '.txt'), 'rb') as f:
+        encoded = f.read()
+    with open(os.path.join(dir, name + '-utf8.txt'), 'rb') as f:
+        utf8 = f.read()
+    return encoded, utf8
diff --git a/Lib/test/pickletester.py b/Lib/test/pickletester.py
index c0d4c8f43b9..9a3a26a8400 100644
--- a/Lib/test/pickletester.py
+++ b/Lib/test/pickletester.py
@@ -1012,6 +1012,26 @@ def test_constants(self):
         self.assertIs(self.loads(b'I01\n.'), True)
         self.assertIs(self.loads(b'I00\n.'), False)
 
+    def test_zero_padded_integers(self):
+        self.assertEqual(self.loads(b'I010\n.'), 10)
+        self.assertEqual(self.loads(b'I-010\n.'), -10)
+        self.assertEqual(self.loads(b'I0010\n.'), 10)
+        self.assertEqual(self.loads(b'I-0010\n.'), -10)
+        self.assertEqual(self.loads(b'L010\n.'), 10)
+        self.assertEqual(self.loads(b'L-010\n.'), -10)
+        self.assertEqual(self.loads(b'L0010\n.'), 10)
+        self.assertEqual(self.loads(b'L-0010\n.'), -10)
+        self.assertEqual(self.loads(b'L010L\n.'), 10)
+        self.assertEqual(self.loads(b'L-010L\n.'), -10)
+
+    def test_nondecimal_integers(self):
+        self.assertRaises(ValueError, self.loads, b'I0b10\n.')
+        self.assertRaises(ValueError, self.loads, b'I0o10\n.')
+        self.assertRaises(ValueError, self.loads, b'I0x10\n.')
+        self.assertRaises(ValueError, self.loads, b'L0b10L\n.')
+        self.assertRaises(ValueError, self.loads, b'L0o10L\n.')
+        self.assertRaises(ValueError, self.loads, b'L0x10L\n.')
+
     def test_empty_bytestring(self):
         # issue 11286
         empty = self.loads(b'\x80\x03U\x00q\x00.', encoding='koi8-r')
@@ -1234,24 +1254,37 @@ def test_find_class(self):
         self.assertIs(unpickler.find_class('os.path', 'join'), os.path.join)
 
         self.assertIs(unpickler4.find_class('builtins', 'str.upper'), str.upper)
-        with self.assertRaises(AttributeError):
+        with self.assertRaisesRegex(AttributeError,
+                r"module 'builtins' has no attribute 'str\.upper'"):
             unpickler.find_class('builtins', 'str.upper')
 
-        with self.assertRaises(AttributeError):
+        with self.assertRaisesRegex(AttributeError,
+                "module 'math' has no attribute 'spam'"):
             unpickler.find_class('math', 'spam')
-        with self.assertRaises(AttributeError):
+        with self.assertRaisesRegex(AttributeError,
+                "module 'math' has no attribute 'spam'"):
             unpickler4.find_class('math', 'spam')
-        with self.assertRaises(AttributeError):
+        with self.assertRaisesRegex(AttributeError,
+                r"module 'math' has no attribute 'log\.spam'"):
             unpickler.find_class('math', 'log.spam')
-        with self.assertRaises(AttributeError):
+        with self.assertRaisesRegex(AttributeError,
+                r"Can't resolve path 'log\.spam' on module 'math'") as cm:
             unpickler4.find_class('math', 'log.spam')
-        with self.assertRaises(AttributeError):
+        self.assertEqual(str(cm.exception.__context__),
+            "'builtin_function_or_method' object has no attribute 'spam'")
+        with self.assertRaisesRegex(AttributeError,
+                r"module 'math' has no attribute 'log\.<locals>\.spam'"):
             unpickler.find_class('math', 'log.<locals>.spam')
-        with self.assertRaises(AttributeError):
+        with self.assertRaisesRegex(AttributeError,
+                r"Can't resolve path 'log\.<locals>\.spam' on module 'math'") as cm:
             unpickler4.find_class('math', 'log.<locals>.spam')
-        with self.assertRaises(AttributeError):
+        self.assertEqual(str(cm.exception.__context__),
+            "'builtin_function_or_method' object has no attribute '<locals>'")
+        with self.assertRaisesRegex(AttributeError,
+                "module 'math' has no attribute ''"):
             unpickler.find_class('math', '')
-        with self.assertRaises(AttributeError):
+        with self.assertRaisesRegex(AttributeError,
+                "module 'math' has no attribute ''"):
             unpickler4.find_class('math', '')
         self.assertRaises(ModuleNotFoundError, unpickler.find_class, 'spam', 'log')
         self.assertRaises(ValueError, unpickler.find_class, '', 'log')
@@ -1637,48 +1670,77 @@ def test_bad_reduce_result(self):
         obj = REX([print, ()])
         for proto in protocols:
             with self.subTest(proto=proto):
-                with self.assertRaises(pickle.PicklingError):
+                with self.assertRaises(pickle.PicklingError) as cm:
                     self.dumps(obj, proto)
+                self.assertEqual(str(cm.exception),
+                    '__reduce__ must return a string or tuple, not list')
+                self.assertEqual(cm.exception.__notes__, [
+                    'when serializing test.pickletester.REX object'])
 
         obj = REX((print,))
         for proto in protocols:
             with self.subTest(proto=proto):
-                with self.assertRaises(pickle.PicklingError):
+                with self.assertRaises(pickle.PicklingError) as cm:
                     self.dumps(obj, proto)
+                self.assertEqual(str(cm.exception),
+                    'tuple returned by __reduce__ must contain 2 through 6 elements')
+                self.assertEqual(cm.exception.__notes__, [
+                    'when serializing test.pickletester.REX object'])
 
         obj = REX((print, (), None, None, None, None, None))
         for proto in protocols:
             with self.subTest(proto=proto):
-                with self.assertRaises(pickle.PicklingError):
+                with self.assertRaises(pickle.PicklingError) as cm:
                     self.dumps(obj, proto)
+                self.assertEqual(str(cm.exception),
+                    'tuple returned by __reduce__ must contain 2 through 6 elements')
+                self.assertEqual(cm.exception.__notes__, [
+                    'when serializing test.pickletester.REX object'])
 
     def test_bad_reconstructor(self):
         obj = REX((42, ()))
         for proto in protocols:
             with self.subTest(proto=proto):
-                with self.assertRaises(pickle.PicklingError):
+                with self.assertRaises(pickle.PicklingError) as cm:
                     self.dumps(obj, proto)
+                self.assertEqual(str(cm.exception),
+                    'first item of the tuple returned by __reduce__ '
+                    'must be callable, not int')
+                self.assertEqual(cm.exception.__notes__, [
+                    'when serializing test.pickletester.REX object'])
 
     def test_unpickleable_reconstructor(self):
         obj = REX((UnpickleableCallable(), ()))
         for proto in protocols:
             with self.subTest(proto=proto):
-                with self.assertRaises(CustomError):
+                with self.assertRaises(CustomError) as cm:
                     self.dumps(obj, proto)
+                self.assertEqual(cm.exception.__notes__, [
+                    'when serializing test.pickletester.REX reconstructor',
+                    'when serializing test.pickletester.REX object'])
 
     def test_bad_reconstructor_args(self):
         obj = REX((print, []))
         for proto in protocols:
             with self.subTest(proto=proto):
-                with self.assertRaises(pickle.PicklingError):
+                with self.assertRaises(pickle.PicklingError) as cm:
                     self.dumps(obj, proto)
+                self.assertEqual(str(cm.exception),
+                    'second item of the tuple returned by __reduce__ '
+                    'must be a tuple, not list')
+                self.assertEqual(cm.exception.__notes__, [
+                    'when serializing test.pickletester.REX object'])
 
     def test_unpickleable_reconstructor_args(self):
         obj = REX((print, (1, 2, UNPICKLEABLE)))
         for proto in protocols:
             with self.subTest(proto=proto):
-                with self.assertRaises(CustomError):
+                with self.assertRaises(CustomError) as cm:
                     self.dumps(obj, proto)
+                self.assertEqual(cm.exception.__notes__, [
+                    'when serializing tuple item 2',
+                    'when serializing test.pickletester.REX reconstructor arguments',
+                    'when serializing test.pickletester.REX object'])
 
     def test_bad_newobj_args(self):
         obj = REX((copyreg.__newobj__, ()))
@@ -1686,74 +1748,154 @@ def test_bad_newobj_args(self):
             with self.subTest(proto=proto):
                 with self.assertRaises((IndexError, pickle.PicklingError)) as cm:
                     self.dumps(obj, proto)
+                self.assertIn(str(cm.exception), {
+                    'tuple index out of range',
+                    '__newobj__ expected at least 1 argument, got 0'})
+                self.assertEqual(cm.exception.__notes__, [
+                    'when serializing test.pickletester.REX object'])
 
         obj = REX((copyreg.__newobj__, [REX]))
         for proto in protocols[2:]:
             with self.subTest(proto=proto):
-                with self.assertRaises((IndexError, pickle.PicklingError)):
+                with self.assertRaises(pickle.PicklingError) as cm:
                     self.dumps(obj, proto)
+                self.assertEqual(str(cm.exception),
+                    'second item of the tuple returned by __reduce__ '
+                    'must be a tuple, not list')
+                self.assertEqual(cm.exception.__notes__, [
+                    'when serializing test.pickletester.REX object'])
 
     def test_bad_newobj_class(self):
         obj = REX((copyreg.__newobj__, (NoNew(),)))
         for proto in protocols[2:]:
             with self.subTest(proto=proto):
-                with self.assertRaises(pickle.PicklingError):
+                with self.assertRaises(pickle.PicklingError) as cm:
                     self.dumps(obj, proto)
+                self.assertIn(str(cm.exception), {
+                    'first argument to __newobj__() has no __new__',
+                    f'first argument to __newobj__() must be a class, not {__name__}.NoNew'})
+                self.assertEqual(cm.exception.__notes__, [
+                    'when serializing test.pickletester.REX object'])
 
     def test_wrong_newobj_class(self):
         obj = REX((copyreg.__newobj__, (str,)))
         for proto in protocols[2:]:
             with self.subTest(proto=proto):
-                with self.assertRaises(pickle.PicklingError):
+                with self.assertRaises(pickle.PicklingError) as cm:
                     self.dumps(obj, proto)
+                self.assertEqual(str(cm.exception),
+                    f'first argument to __newobj__() must be {REX!r}, not {str!r}')
+                self.assertEqual(cm.exception.__notes__, [
+                    'when serializing test.pickletester.REX object'])
 
     def test_unpickleable_newobj_class(self):
         class LocalREX(REX): pass
         obj = LocalREX((copyreg.__newobj__, (LocalREX,)))
         for proto in protocols:
             with self.subTest(proto=proto):
-                with self.assertRaises((pickle.PicklingError, AttributeError)):
+                with self.assertRaises(pickle.PicklingError) as cm:
                     self.dumps(obj, proto)
+            if proto >= 2:
+                self.assertEqual(cm.exception.__notes__, [
+                    f'when serializing {LocalREX.__module__}.{LocalREX.__qualname__} class',
+                    f'when serializing {LocalREX.__module__}.{LocalREX.__qualname__} object'])
+            else:
+                self.assertEqual(cm.exception.__notes__, [
+                    'when serializing tuple item 0',
+                    f'when serializing {LocalREX.__module__}.{LocalREX.__qualname__} reconstructor arguments',
+                    f'when serializing {LocalREX.__module__}.{LocalREX.__qualname__} object'])
 
     def test_unpickleable_newobj_args(self):
         obj = REX((copyreg.__newobj__, (REX, 1, 2, UNPICKLEABLE)))
         for proto in protocols:
             with self.subTest(proto=proto):
-                with self.assertRaises(CustomError):
+                with self.assertRaises(CustomError) as cm:
                     self.dumps(obj, proto)
+                if proto >= 2:
+                    self.assertEqual(cm.exception.__notes__, [
+                        'when serializing tuple item 2',
+                        'when serializing test.pickletester.REX __new__ arguments',
+                        'when serializing test.pickletester.REX object'])
+                else:
+                    self.assertEqual(cm.exception.__notes__, [
+                        'when serializing tuple item 3',
+                        'when serializing test.pickletester.REX reconstructor arguments',
+                        'when serializing test.pickletester.REX object'])
 
     def test_bad_newobj_ex_args(self):
         obj = REX((copyreg.__newobj_ex__, ()))
         for proto in protocols[2:]:
             with self.subTest(proto=proto):
-                with self.assertRaises((ValueError, pickle.PicklingError)):
+                with self.assertRaises((ValueError, pickle.PicklingError)) as cm:
                     self.dumps(obj, proto)
+                self.assertIn(str(cm.exception), {
+                    'not enough values to unpack (expected 3, got 0)',
+                    '__newobj_ex__ expected 3 arguments, got 0'})
+                self.assertEqual(cm.exception.__notes__, [
+                    'when serializing test.pickletester.REX object'])
 
         obj = REX((copyreg.__newobj_ex__, 42))
         for proto in protocols[2:]:
             with self.subTest(proto=proto):
-                with self.assertRaises(pickle.PicklingError):
+                with self.assertRaises(pickle.PicklingError) as cm:
                     self.dumps(obj, proto)
+                self.assertEqual(str(cm.exception),
+                    'second item of the tuple returned by __reduce__ '
+                    'must be a tuple, not int')
+                self.assertEqual(cm.exception.__notes__, [
+                    'when serializing test.pickletester.REX object'])
 
         obj = REX((copyreg.__newobj_ex__, (REX, 42, {})))
-        is_py = self.pickler is pickle._Pickler
-        for proto in protocols[2:4] if is_py else protocols[2:]:
-            with self.subTest(proto=proto):
-                with self.assertRaises((TypeError, pickle.PicklingError)):
-                    self.dumps(obj, proto)
+        if self.pickler is pickle._Pickler:
+            for proto in protocols[2:4]:
+                with self.subTest(proto=proto):
+                    with self.assertRaises(TypeError) as cm:
+                        self.dumps(obj, proto)
+                    self.assertEqual(str(cm.exception),
+                        'Value after * must be an iterable, not int')
+                    self.assertEqual(cm.exception.__notes__, [
+                        'when serializing test.pickletester.REX object'])
+        else:
+            for proto in protocols[2:]:
+                with self.subTest(proto=proto):
+                    with self.assertRaises(pickle.PicklingError) as cm:
+                        self.dumps(obj, proto)
+                    self.assertEqual(str(cm.exception),
+                        'second argument to __newobj_ex__() must be a tuple, not int')
+                    self.assertEqual(cm.exception.__notes__, [
+                        'when serializing test.pickletester.REX object'])
 
         obj = REX((copyreg.__newobj_ex__, (REX, (), [])))
-        for proto in protocols[2:4] if is_py else protocols[2:]:
-            with self.subTest(proto=proto):
-                with self.assertRaises((TypeError, pickle.PicklingError)):
-                    self.dumps(obj, proto)
+        if self.pickler is pickle._Pickler:
+            for proto in protocols[2:4]:
+                with self.subTest(proto=proto):
+                    with self.assertRaises(TypeError) as cm:
+                        self.dumps(obj, proto)
+                    self.assertEqual(str(cm.exception),
+                        'functools.partial() argument after ** must be a mapping, not list')
+                    self.assertEqual(cm.exception.__notes__, [
+                        'when serializing test.pickletester.REX object'])
+        else:
+            for proto in protocols[2:]:
+                with self.subTest(proto=proto):
+                    with self.assertRaises(pickle.PicklingError) as cm:
+                        self.dumps(obj, proto)
+                    self.assertEqual(str(cm.exception),
+                        'third argument to __newobj_ex__() must be a dict, not list')
+                    self.assertEqual(cm.exception.__notes__, [
+                        'when serializing test.pickletester.REX object'])
 
     def test_bad_newobj_ex__class(self):
         obj = REX((copyreg.__newobj_ex__, (NoNew(), (), {})))
         for proto in protocols[2:]:
             with self.subTest(proto=proto):
-                with self.assertRaises(pickle.PicklingError):
+                with self.assertRaises(pickle.PicklingError) as cm:
                     self.dumps(obj, proto)
+                self.assertIn(str(cm.exception), {
+                    'first argument to __newobj_ex__() has no __new__',
+                    f'first argument to __newobj_ex__() must be a class, not {__name__}.NoNew'})
+                self.assertEqual(cm.exception.__notes__, [
+                    'when serializing test.pickletester.REX object'])
 
     def test_wrong_newobj_ex_class(self):
         if self.pickler is not pickle._Pickler:
@@ -1761,37 +1903,99 @@ def test_wrong_newobj_ex_class(self):
         obj = REX((copyreg.__newobj_ex__, (str, (), {})))
         for proto in protocols[2:]:
             with self.subTest(proto=proto):
-                with self.assertRaises(pickle.PicklingError):
+                with self.assertRaises(pickle.PicklingError) as cm:
                     self.dumps(obj, proto)
+                self.assertEqual(str(cm.exception),
+                    f'first argument to __newobj_ex__() must be {REX}, not {str}')
+                self.assertEqual(cm.exception.__notes__, [
+                    'when serializing test.pickletester.REX object'])
 
     def test_unpickleable_newobj_ex_class(self):
         class LocalREX(REX): pass
         obj = LocalREX((copyreg.__newobj_ex__, (LocalREX, (), {})))
         for proto in protocols:
             with self.subTest(proto=proto):
-                with self.assertRaises((pickle.PicklingError, AttributeError)):
+                with self.assertRaises(pickle.PicklingError) as cm:
                     self.dumps(obj, proto)
+                if proto >= 4:
+                    self.assertEqual(cm.exception.__notes__, [
+                        f'when serializing {LocalREX.__module__}.{LocalREX.__qualname__} class',
+                        f'when serializing {LocalREX.__module__}.{LocalREX.__qualname__} object'])
+                elif proto >= 2:
+                    self.assertEqual(cm.exception.__notes__, [
+                        'when serializing tuple item 0',
+                        'when serializing tuple item 1',
+                        'when serializing functools.partial state',
+                        'when serializing functools.partial object',
+                        f'when serializing {LocalREX.__module__}.{LocalREX.__qualname__} reconstructor',
+                        f'when serializing {LocalREX.__module__}.{LocalREX.__qualname__} object'])
+                else:
+                    self.assertEqual(cm.exception.__notes__, [
+                        'when serializing tuple item 0',
+                        f'when serializing {LocalREX.__module__}.{LocalREX.__qualname__} reconstructor arguments',
+                        f'when serializing {LocalREX.__module__}.{LocalREX.__qualname__} object'])
 
     def test_unpickleable_newobj_ex_args(self):
         obj = REX((copyreg.__newobj_ex__, (REX, (1, 2, UNPICKLEABLE), {})))
         for proto in protocols:
             with self.subTest(proto=proto):
-                with self.assertRaises(CustomError):
+                with self.assertRaises(CustomError) as cm:
                     self.dumps(obj, proto)
+                if proto >= 4:
+                    self.assertEqual(cm.exception.__notes__, [
+                        'when serializing tuple item 2',
+                        'when serializing test.pickletester.REX __new__ arguments',
+                        'when serializing test.pickletester.REX object'])
+                elif proto >= 2:
+                    self.assertEqual(cm.exception.__notes__, [
+                        'when serializing tuple item 3',
+                        'when serializing tuple item 1',
+                        'when serializing functools.partial state',
+                        'when serializing functools.partial object',
+                        'when serializing test.pickletester.REX reconstructor',
+                        'when serializing test.pickletester.REX object'])
+                else:
+                    self.assertEqual(cm.exception.__notes__, [
+                        'when serializing tuple item 2',
+                        'when serializing tuple item 1',
+                        'when serializing test.pickletester.REX reconstructor arguments',
+                        'when serializing test.pickletester.REX object'])
 
     def test_unpickleable_newobj_ex_kwargs(self):
         obj = REX((copyreg.__newobj_ex__, (REX, (), {'a': UNPICKLEABLE})))
         for proto in protocols:
             with self.subTest(proto=proto):
-                with self.assertRaises(CustomError):
+                with self.assertRaises(CustomError) as cm:
                     self.dumps(obj, proto)
+                if proto >= 4:
+                    self.assertEqual(cm.exception.__notes__, [
+                        "when serializing dict item 'a'",
+                        'when serializing test.pickletester.REX __new__ arguments',
+                        'when serializing test.pickletester.REX object'])
+                elif proto >= 2:
+                    self.assertEqual(cm.exception.__notes__, [
+                        "when serializing dict item 'a'",
+                        'when serializing tuple item 2',
+                        'when serializing functools.partial state',
+                        'when serializing functools.partial object',
+                        'when serializing test.pickletester.REX reconstructor',
+                        'when serializing test.pickletester.REX object'])
+                else:
+                    self.assertEqual(cm.exception.__notes__, [
+                        "when serializing dict item 'a'",
+                        'when serializing tuple item 2',
+                        'when serializing test.pickletester.REX reconstructor arguments',
+                        'when serializing test.pickletester.REX object'])
 
     def test_unpickleable_state(self):
         obj = REX_state(UNPICKLEABLE)
         for proto in protocols:
             with self.subTest(proto=proto):
-                with self.assertRaises(CustomError):
+                with self.assertRaises(CustomError) as cm:
                     self.dumps(obj, proto)
+                self.assertEqual(cm.exception.__notes__, [
+                    'when serializing test.pickletester.REX_state state',
+                    'when serializing test.pickletester.REX_state object'])
 
     def test_bad_state_setter(self):
         if self.pickler is pickle._Pickler:
@@ -1799,22 +2003,33 @@ def test_bad_state_setter(self):
         obj = REX((print, (), 'state', None, None, 42))
         for proto in protocols:
             with self.subTest(proto=proto):
-                with self.assertRaises(pickle.PicklingError):
+                with self.assertRaises(pickle.PicklingError) as cm:
                     self.dumps(obj, proto)
+                self.assertEqual(str(cm.exception),
+                    'sixth item of the tuple returned by __reduce__ '
+                    'must be callable, not int')
+                self.assertEqual(cm.exception.__notes__, [
+                    'when serializing test.pickletester.REX object'])
 
     def test_unpickleable_state_setter(self):
         obj = REX((print, (), 'state', None, None, UnpickleableCallable()))
         for proto in protocols:
             with self.subTest(proto=proto):
-                with self.assertRaises(CustomError):
+                with self.assertRaises(CustomError) as cm:
                     self.dumps(obj, proto)
+                self.assertEqual(cm.exception.__notes__, [
+                    'when serializing test.pickletester.REX state setter',
+                    'when serializing test.pickletester.REX object'])
 
     def test_unpickleable_state_with_state_setter(self):
         obj = REX((print, (), UNPICKLEABLE, None, None, print))
         for proto in protocols:
             with self.subTest(proto=proto):
-                with self.assertRaises(CustomError):
+                with self.assertRaises(CustomError) as cm:
                     self.dumps(obj, proto)
+                self.assertEqual(cm.exception.__notes__, [
+                    'when serializing test.pickletester.REX state',
+                    'when serializing test.pickletester.REX object'])
 
     def test_bad_object_list_items(self):
         # Issue4176: crash when 4th and 5th items of __reduce__()
@@ -1822,23 +2037,37 @@ def test_bad_object_list_items(self):
         obj = REX((list, (), None, 42))
         for proto in protocols:
             with self.subTest(proto=proto):
-                with self.assertRaises((TypeError, pickle.PicklingError)):
+                with self.assertRaises((TypeError, pickle.PicklingError)) as cm:
                     self.dumps(obj, proto)
+                self.assertIn(str(cm.exception), {
+                    "'int' object is not iterable",
+                    'fourth item of the tuple returned by __reduce__ '
+                    'must be an iterator, not int'})
+                self.assertEqual(cm.exception.__notes__, [
+                    'when serializing test.pickletester.REX object'])
 
         if self.pickler is not pickle._Pickler:
             # Python implementation is less strict and also accepts iterables.
             obj = REX((list, (), None, []))
             for proto in protocols:
                 with self.subTest(proto=proto):
-                    with self.assertRaises((TypeError, pickle.PicklingError)):
+                    with self.assertRaises(pickle.PicklingError):
                         self.dumps(obj, proto)
+                    self.assertEqual(str(cm.exception),
+                        'fourth item of the tuple returned by __reduce__ '
+                        'must be an iterator, not int')
+                    self.assertEqual(cm.exception.__notes__, [
+                        'when serializing test.pickletester.REX object'])
 
     def test_unpickleable_object_list_items(self):
         obj = REX_six([1, 2, UNPICKLEABLE])
         for proto in protocols:
             with self.subTest(proto=proto):
-                with self.assertRaises(CustomError):
+                with self.assertRaises(CustomError) as cm:
                     self.dumps(obj, proto)
+                self.assertEqual(cm.exception.__notes__, [
+                    'when serializing test.pickletester.REX_six item 2',
+                    'when serializing test.pickletester.REX_six object'])
 
     def test_bad_object_dict_items(self):
         # Issue4176: crash when 4th and 5th items of __reduce__()
@@ -1846,82 +2075,135 @@ def test_bad_object_dict_items(self):
         obj = REX((dict, (), None, None, 42))
         for proto in protocols:
             with self.subTest(proto=proto):
-                with self.assertRaises((TypeError, pickle.PicklingError)):
+                with self.assertRaises((TypeError, pickle.PicklingError)) as cm:
                     self.dumps(obj, proto)
+                self.assertIn(str(cm.exception), {
+                    "'int' object is not iterable",
+                    'fifth item of the tuple returned by __reduce__ '
+                    'must be an iterator, not int'})
+                self.assertEqual(cm.exception.__notes__, [
+                    'when serializing test.pickletester.REX object'])
 
         for proto in protocols:
             obj = REX((dict, (), None, None, iter([('a',)])))
             with self.subTest(proto=proto):
-                with self.assertRaises((ValueError, TypeError)):
+                with self.assertRaises((ValueError, TypeError)) as cm:
                     self.dumps(obj, proto)
+                self.assertIn(str(cm.exception), {
+                    'not enough values to unpack (expected 2, got 1)',
+                    'dict items iterator must return 2-tuples'})
+                self.assertEqual(cm.exception.__notes__, [
+                    'when serializing test.pickletester.REX object'])
 
         if self.pickler is not pickle._Pickler:
             # Python implementation is less strict and also accepts iterables.
             obj = REX((dict, (), None, None, []))
             for proto in protocols:
                 with self.subTest(proto=proto):
-                    with self.assertRaises((TypeError, pickle.PicklingError)):
+                    with self.assertRaises(pickle.PicklingError):
                         self.dumps(obj, proto)
+                    self.assertEqual(str(cm.exception),
+                        'dict items iterator must return 2-tuples')
+                    self.assertEqual(cm.exception.__notes__, [
+                        'when serializing test.pickletester.REX object'])
 
     def test_unpickleable_object_dict_items(self):
         obj = REX_seven({'a': UNPICKLEABLE})
         for proto in protocols:
             with self.subTest(proto=proto):
-                with self.assertRaises(CustomError):
+                with self.assertRaises(CustomError) as cm:
                     self.dumps(obj, proto)
+                self.assertEqual(cm.exception.__notes__, [
+                    "when serializing test.pickletester.REX_seven item 'a'",
+                    'when serializing test.pickletester.REX_seven object'])
 
     def test_unpickleable_list_items(self):
         obj = [1, [2, 3, UNPICKLEABLE]]
         for proto in protocols:
             with self.subTest(proto=proto):
-                with self.assertRaises(CustomError):
+                with self.assertRaises(CustomError) as cm:
                     self.dumps(obj, proto)
+                self.assertEqual(cm.exception.__notes__, [
+                    'when serializing list item 2',
+                    'when serializing list item 1'])
         for n in [0, 1, 1000, 1005]:
             obj = [*range(n), UNPICKLEABLE]
             for proto in protocols:
                 with self.subTest(proto=proto):
-                    with self.assertRaises(CustomError):
+                    with self.assertRaises(CustomError) as cm:
                         self.dumps(obj, proto)
+                    self.assertEqual(cm.exception.__notes__, [
+                        f'when serializing list item {n}'])
 
     def test_unpickleable_tuple_items(self):
         obj = (1, (2, 3, UNPICKLEABLE))
         for proto in protocols:
             with self.subTest(proto=proto):
-                with self.assertRaises(CustomError):
+                with self.assertRaises(CustomError) as cm:
                     self.dumps(obj, proto)
+                self.assertEqual(cm.exception.__notes__, [
+                    'when serializing tuple item 2',
+                    'when serializing tuple item 1'])
         obj = (*range(10), UNPICKLEABLE)
         for proto in protocols:
             with self.subTest(proto=proto):
-                with self.assertRaises(CustomError):
+                with self.assertRaises(CustomError) as cm:
                     self.dumps(obj, proto)
+                self.assertEqual(cm.exception.__notes__, [
+                    'when serializing tuple item 10'])
 
     def test_unpickleable_dict_items(self):
         obj = {'a': {'b': UNPICKLEABLE}}
         for proto in protocols:
             with self.subTest(proto=proto):
-                with self.assertRaises(CustomError):
+                with self.assertRaises(CustomError) as cm:
                     self.dumps(obj, proto)
+                self.assertEqual(cm.exception.__notes__, [
+                    "when serializing dict item 'b'",
+                    "when serializing dict item 'a'"])
         for n in [0, 1, 1000, 1005]:
             obj = dict.fromkeys(range(n))
             obj['a'] = UNPICKLEABLE
             for proto in protocols:
                 with self.subTest(proto=proto, n=n):
-                    with self.assertRaises(CustomError):
+                    with self.assertRaises(CustomError) as cm:
                         self.dumps(obj, proto)
+                    self.assertEqual(cm.exception.__notes__, [
+                        "when serializing dict item 'a'"])
 
     def test_unpickleable_set_items(self):
         obj = {UNPICKLEABLE}
         for proto in protocols:
             with self.subTest(proto=proto):
-                with self.assertRaises(CustomError):
+                with self.assertRaises(CustomError) as cm:
                     self.dumps(obj, proto)
+                if proto >= 4:
+                    self.assertEqual(cm.exception.__notes__, [
+                        'when serializing set element'])
+                else:
+                    self.assertEqual(cm.exception.__notes__, [
+                        'when serializing list item 0',
+                        'when serializing tuple item 0',
+                        'when serializing set reconstructor arguments'])
 
     def test_unpickleable_frozenset_items(self):
         obj = frozenset({frozenset({UNPICKLEABLE})})
         for proto in protocols:
             with self.subTest(proto=proto):
-                with self.assertRaises(CustomError):
+                with self.assertRaises(CustomError) as cm:
                     self.dumps(obj, proto)
+                if proto >= 4:
+                    self.assertEqual(cm.exception.__notes__, [
+                        'when serializing frozenset element',
+                        'when serializing frozenset element'])
+                else:
+                    self.assertEqual(cm.exception.__notes__, [
+                        'when serializing list item 0',
+                        'when serializing tuple item 0',
+                        'when serializing frozenset reconstructor arguments',
+                        'when serializing list item 0',
+                        'when serializing tuple item 0',
+                        'when serializing frozenset reconstructor arguments'])
 
     def test_global_lookup_error(self):
         # Global name does not exist
@@ -1929,26 +2211,42 @@ def test_global_lookup_error(self):
         obj.__module__ = __name__
         for proto in protocols:
             with self.subTest(proto=proto):
-                with self.assertRaises(pickle.PicklingError):
+                with self.assertRaises(pickle.PicklingError) as cm:
                     self.dumps(obj, proto)
+                self.assertEqual(str(cm.exception),
+                    f"Can't pickle {obj!r}: it's not found as {__name__}.spam")
+                self.assertEqual(str(cm.exception.__context__),
+                    f"module '{__name__}' has no attribute 'spam'")
 
         obj.__module__ = 'nonexisting'
         for proto in protocols:
             with self.subTest(proto=proto):
-                with self.assertRaises(pickle.PicklingError):
+                with self.assertRaises(pickle.PicklingError) as cm:
                     self.dumps(obj, proto)
+                self.assertEqual(str(cm.exception),
+                    f"Can't pickle {obj!r}: No module named 'nonexisting'")
+                self.assertEqual(str(cm.exception.__context__),
+                    "No module named 'nonexisting'")
 
         obj.__module__ = ''
         for proto in protocols:
             with self.subTest(proto=proto):
-                with self.assertRaises((ValueError, pickle.PicklingError)):
+                with self.assertRaises(pickle.PicklingError) as cm:
                     self.dumps(obj, proto)
+                self.assertEqual(str(cm.exception),
+                    f"Can't pickle {obj!r}: Empty module name")
+                self.assertEqual(str(cm.exception.__context__),
+                    "Empty module name")
 
         obj.__module__ = None
         for proto in protocols:
             with self.subTest(proto=proto):
-                with self.assertRaises(pickle.PicklingError):
+                with self.assertRaises(pickle.PicklingError) as cm:
                     self.dumps(obj, proto)
+                self.assertEqual(str(cm.exception),
+                    f"Can't pickle {obj!r}: it's not found as __main__.spam")
+                self.assertEqual(str(cm.exception.__context__),
+                    "module '__main__' has no attribute 'spam'")
 
     def test_nonencodable_global_name_error(self):
         for proto in protocols[:4]:
@@ -1957,8 +2255,11 @@ def test_nonencodable_global_name_error(self):
                 obj = REX(name)
                 obj.__module__ = __name__
                 with support.swap_item(globals(), name, obj):
-                    with self.assertRaises((UnicodeEncodeError, pickle.PicklingError)):
+                    with self.assertRaises(pickle.PicklingError) as cm:
                         self.dumps(obj, proto)
+                    self.assertEqual(str(cm.exception),
+                        f"can't pickle global identifier {name!r} using pickle protocol {proto}")
+                    self.assertIsInstance(cm.exception.__context__, UnicodeEncodeError)
 
     def test_nonencodable_module_name_error(self):
         for proto in protocols[:4]:
@@ -1968,8 +2269,11 @@ def test_nonencodable_module_name_error(self):
                 obj.__module__ = name
                 mod = types.SimpleNamespace(test=obj)
                 with support.swap_item(sys.modules, name, mod):
-                    with self.assertRaises((UnicodeEncodeError, pickle.PicklingError)):
+                    with self.assertRaises(pickle.PicklingError) as cm:
                         self.dumps(obj, proto)
+                    self.assertEqual(str(cm.exception),
+                        f"can't pickle module identifier {name!r} using pickle protocol {proto}")
+                    self.assertIsInstance(cm.exception.__context__, UnicodeEncodeError)
 
     def test_nested_lookup_error(self):
         # Nested name does not exist
@@ -1981,14 +2285,24 @@ class A:
         obj.__module__ = __name__
         for proto in protocols:
             with self.subTest(proto=proto):
-                with self.assertRaises(pickle.PicklingError):
+                with self.assertRaises(pickle.PicklingError) as cm:
                     self.dumps(obj, proto)
+                self.assertEqual(str(cm.exception),
+                    f"Can't pickle {obj!r}: "
+                    f"it's not found as {__name__}.TestGlobal.A.B.C")
+                self.assertEqual(str(cm.exception.__context__),
+                    "type object 'A' has no attribute 'B'")
 
         obj.__module__ = None
         for proto in protocols:
             with self.subTest(proto=proto):
-                with self.assertRaises(pickle.PicklingError):
+                with self.assertRaises(pickle.PicklingError) as cm:
                     self.dumps(obj, proto)
+                self.assertEqual(str(cm.exception),
+                    f"Can't pickle {obj!r}: "
+                    f"it's not found as __main__.TestGlobal.A.B.C")
+                self.assertEqual(str(cm.exception.__context__),
+                    "module '__main__' has no attribute 'TestGlobal'")
 
     def test_wrong_object_lookup_error(self):
         # Name is bound to different object
@@ -1999,14 +2313,23 @@ class TestGlobal:
         obj.__module__ = __name__
         for proto in protocols:
             with self.subTest(proto=proto):
-                with self.assertRaises(pickle.PicklingError):
+                with self.assertRaises(pickle.PicklingError) as cm:
                     self.dumps(obj, proto)
+                self.assertEqual(str(cm.exception),
+                    f"Can't pickle {obj!r}: "
+                    f"it's not the same object as {__name__}.TestGlobal")
+                self.assertIsNone(cm.exception.__context__)
 
         obj.__module__ = None
         for proto in protocols:
             with self.subTest(proto=proto):
-                with self.assertRaises(pickle.PicklingError):
+                with self.assertRaises(pickle.PicklingError) as cm:
                     self.dumps(obj, proto)
+                self.assertEqual(str(cm.exception),
+                    f"Can't pickle {obj!r}: "
+                    f"it's not found as __main__.TestGlobal")
+                self.assertEqual(str(cm.exception.__context__),
+                    "module '__main__' has no attribute 'TestGlobal'")
 
     def test_local_lookup_error(self):
         # Test that whichmodule() errors out cleanly when looking up
@@ -2016,21 +2339,27 @@ def f():
         # Since the function is local, lookup will fail
         for proto in protocols:
             with self.subTest(proto=proto):
-                with self.assertRaises((AttributeError, pickle.PicklingError)):
+                with self.assertRaises(pickle.PicklingError) as cm:
                     self.dumps(f, proto)
+                self.assertEqual(str(cm.exception),
+                    f"Can't pickle local object {f!r}")
         # Same without a __module__ attribute (exercises a different path
         # in _pickle.c).
         del f.__module__
         for proto in protocols:
             with self.subTest(proto=proto):
-                with self.assertRaises((AttributeError, pickle.PicklingError)):
+                with self.assertRaises(pickle.PicklingError) as cm:
                     self.dumps(f, proto)
+                self.assertEqual(str(cm.exception),
+                    f"Can't pickle local object {f!r}")
         # Yet a different path.
         f.__name__ = f.__qualname__
         for proto in protocols:
             with self.subTest(proto=proto):
-                with self.assertRaises((AttributeError, pickle.PicklingError)):
+                with self.assertRaises(pickle.PicklingError) as cm:
                     self.dumps(f, proto)
+                self.assertEqual(str(cm.exception),
+                    f"Can't pickle local object {f!r}")
 
     def test_reduce_ex_None(self):
         c = REX_None()
@@ -2744,7 +3073,7 @@ def test_proto(self):
             pickled = self.dumps(None, proto)
             if proto >= 2:
                 proto_header = pickle.PROTO + bytes([proto])
-                self.assertTrue(pickled.startswith(proto_header))
+                self.assertStartsWith(pickled, proto_header)
             else:
                 self.assertEqual(count_opcode(pickle.PROTO, pickled), 0)
 
@@ -4640,8 +4969,11 @@ class MyClass:
                 # NotImplemented
                 self.assertIs(math_log, math.log)
 
-                with self.assertRaises(pickle.PicklingError):
+                with self.assertRaises(pickle.PicklingError) as cm:
                     p.dump(g)
+                self.assertRegex(str(cm.exception),
+                    r'(__reduce__|<bound method .*reducer_override.*>)'
+                    r' must return (a )?string or tuple')
 
                 with self.assertRaisesRegex(
                         ValueError, 'The reducer just failed'):
@@ -4680,7 +5012,7 @@ def test_default_dispatch_table(self):
         p = self.pickler_class(f, 0)
         with self.assertRaises(AttributeError):
             p.dispatch_table
-        self.assertFalse(hasattr(p, 'dispatch_table'))
+        self.assertNotHasAttr(p, 'dispatch_table')
 
     def test_class_dispatch_table(self):
         # A dispatch_table attribute can be specified class-wide
diff --git a/Lib/test/profilee.py b/Lib/test/profilee.py
new file mode 100644
index 00000000000..b6a090a2e34
--- /dev/null
+++ b/Lib/test/profilee.py
@@ -0,0 +1,115 @@
+"""
+Input for test_profile.py and test_cprofile.py.
+
+IMPORTANT: This stuff is touchy. If you modify anything above the
+test class you'll have to regenerate the stats by running the two
+test files.
+
+*ALL* NUMBERS in the expected output are relevant.  If you change
+the formatting of pstats, please don't just regenerate the expected
+output without checking very carefully that not a single number has
+changed.
+"""
+
+import sys
+
+# In order to have reproducible time, we simulate a timer in the global
+# variable 'TICKS', which represents simulated time in milliseconds.
+# (We can't use a helper function increment the timer since it would be
+# included in the profile and would appear to consume all the time.)
+TICKS = 42000
+
+def timer():
+    return TICKS
+
+def testfunc():
+    # 1 call
+    # 1000 ticks total: 270 ticks local, 730 ticks in subfunctions
+    global TICKS
+    TICKS += 99
+    helper()                            # 300
+    helper()                            # 300
+    TICKS += 171
+    factorial(14)                       # 130
+
+def factorial(n):
+    # 23 calls total
+    # 170 ticks total, 150 ticks local
+    # 3 primitive calls, 130, 20 and 20 ticks total
+    # including 116, 17, 17 ticks local
+    global TICKS
+    if n > 0:
+        TICKS += n
+        return mul(n, factorial(n-1))
+    else:
+        TICKS += 11
+        return 1
+
+def mul(a, b):
+    # 20 calls
+    # 1 tick, local
+    global TICKS
+    TICKS += 1
+    return a * b
+
+def helper():
+    # 2 calls
+    # 300 ticks total: 20 ticks local, 260 ticks in subfunctions
+    global TICKS
+    TICKS += 1
+    helper1()                           # 30
+    TICKS += 2
+    helper1()                           # 30
+    TICKS += 6
+    helper2()                           # 50
+    TICKS += 3
+    helper2()                           # 50
+    TICKS += 2
+    helper2()                           # 50
+    TICKS += 5
+    helper2_indirect()                  # 70
+    TICKS += 1
+
+def helper1():
+    # 4 calls
+    # 30 ticks total: 29 ticks local, 1 tick in subfunctions
+    global TICKS
+    TICKS += 10
+    hasattr(C(), "foo")                 # 1
+    TICKS += 19
+    lst = []
+    lst.append(42)                      # 0
+    sys.exception()                     # 0
+
+def helper2_indirect():
+    helper2()                           # 50
+    factorial(3)                        # 20
+
+def helper2():
+    # 8 calls
+    # 50 ticks local: 39 ticks local, 11 ticks in subfunctions
+    global TICKS
+    TICKS += 11
+    hasattr(C(), "bar")                 # 1
+    TICKS += 13
+    subhelper()                         # 10
+    TICKS += 15
+
+def subhelper():
+    # 8 calls
+    # 10 ticks total: 8 ticks local, 2 ticks in subfunctions
+    global TICKS
+    TICKS += 2
+    for i in range(2):                  # 0
+        try:
+            C().foo                     # 1 x 2
+        except AttributeError:
+            TICKS += 3                  # 3 x 2
+
+class C:
+    def __getattr__(self, name):
+        # 28 calls
+        # 1 tick, local
+        global TICKS
+        TICKS += 1
+        raise AttributeError
diff --git a/Lib/test/seq_tests.py b/Lib/test/seq_tests.py
index 54eb5e65ac2..c7497d09f64 100644
--- a/Lib/test/seq_tests.py
+++ b/Lib/test/seq_tests.py
@@ -426,8 +426,7 @@ def test_pickle(self):
             self.assertEqual(lst2, lst)
             self.assertNotEqual(id(lst2), id(lst))
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
-    @support.suppress_immortalization()
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_free_after_iterating(self):
         support.check_free_after_iterating(self, iter, self.type2test)
         support.check_free_after_iterating(self, reversed, self.type2test)
diff --git a/Lib/test/ssl_servers.py b/Lib/test/ssl_servers.py
index c45411f49d8..15b071e04dd 100644
--- a/Lib/test/ssl_servers.py
+++ b/Lib/test/ssl_servers.py
@@ -14,7 +14,7 @@
 here = os.path.dirname(__file__)
 
 HOST = socket_helper.HOST
-CERTFILE = os.path.join(here, 'certdata/keycert.pem')
+CERTFILE = os.path.join(here, 'certdata', 'keycert.pem')
 
 # This one's based on HTTPServer, which is based on socketserver
 
diff --git a/Lib/test/support/__init__.py b/Lib/test/support/__init__.py
index cc5a48738fd..6b3f2c447e8 100644
--- a/Lib/test/support/__init__.py
+++ b/Lib/test/support/__init__.py
@@ -3,11 +3,12 @@
 if __name__ != 'test.support':
     raise ImportError('support must be imported from the test package')
 
-import _opcode
+import annotationlib
 import contextlib
 import functools
 import inspect
 import logging
+import _opcode
 import os
 import re
 import stat
@@ -19,7 +20,6 @@
 import unittest
 import warnings
 
-import annotationlib
 
 __all__ = [
     # globals
@@ -30,7 +30,8 @@
     "record_original_stdout", "get_original_stdout", "captured_stdout",
     "captured_stdin", "captured_stderr", "captured_output",
     # unittest
-    "is_resource_enabled", "requires", "requires_freebsd_version",
+    "is_resource_enabled", "get_resource_value", "requires", "requires_resource",
+    "requires_freebsd_version",
     "requires_gil_enabled", "requires_linux_version", "requires_mac_ver",
     "check_syntax_error",
     "requires_gzip", "requires_bz2", "requires_lzma", "requires_zstd",
@@ -43,6 +44,7 @@
     "check__all__", "skip_if_buggy_ucrt_strfptime",
     "check_disallow_instantiation", "check_sanitizer", "skip_if_sanitizer",
     "requires_limited_api", "requires_specialization", "thread_unsafe",
+    "skip_if_unlimited_stack_size",
     # sys
     "MS_WINDOWS", "is_jython", "is_android", "is_emscripten", "is_wasi",
     "is_apple_mobile", "check_impl_detail", "unix_shell", "setswitchinterval",
@@ -184,7 +186,7 @@ def get_attribute(obj, name):
         return attribute
 
 verbose = 1              # Flag set to 0 by regrtest.py
-use_resources = None     # Flag set to [] by regrtest.py
+use_resources = None     # Flag set to {} by regrtest.py
 max_memuse = 0           # Disable bigmem tests (they will still be run with
                          # small sizes, to make sure they work.)
 real_max_memuse = 0
@@ -299,6 +301,16 @@ def is_resource_enabled(resource):
     """
     return use_resources is None or resource in use_resources
 
+def get_resource_value(resource):
+    """Test whether a resource is enabled.
+
+    Known resources are set by regrtest.py.  If not running under regrtest.py,
+    all resources are assumed enabled unless use_resources has been set.
+    """
+    if use_resources is None:
+        return None
+    return use_resources.get(resource)
+
 def requires(resource, msg=None):
     """Raise ResourceDenied if the specified resource is not available."""
     if not is_resource_enabled(resource):
@@ -562,52 +574,6 @@ 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.
-
-    Use this helper in code where SkipTest must be eagerly handled.
-    """
-    if not suppress:
-        return True
-    try:
-        import _testinternalcapi
-    except ImportError:
-        return False
-    return True
-
-
-@contextlib.contextmanager
-def suppress_immortalization(suppress=True):
-    """Suppress immortalization of deferred objects.
-
-    If _testinternalcapi is not available, the decorated test or class
-    is skipped. Use can_use_suppress_immortalization() outside test cases
-    to check if this decorator can be used.
-    """
-    if not suppress:
-        yield  # no-op
-        return
-
-    from .import_helper import import_module
-
-    _testinternalcapi = import_module("_testinternalcapi")
-    _testinternalcapi.suppress_immortalization(True)
-    try:
-        yield
-    finally:
-        _testinternalcapi.suppress_immortalization(False)
-
-
-def skip_if_suppress_immortalization():
-    try:
-        import _testinternalcapi
-    except ImportError:
-        return
-    return unittest.skipUnless(_testinternalcapi.get_immortalize_deferred(),
-                                "requires immortalization of deferred objects")
-
-
 MS_WINDOWS = (sys.platform == 'win32')
 
 # Is not actually used in tests, but is kept for compatibility.
@@ -783,9 +749,7 @@ def check_syntax_error(testcase, statement, errtext='', *, lineno=None, offset=N
 
 
 def open_urlresource(url, *args, **kw):
-    import urllib.parse
-    import urllib.request
-
+    import urllib.request, urllib.parse
     from .os_helper import unlink
     try:
         import gzip
@@ -919,13 +883,6 @@ def disable_gc():
 
 @contextlib.contextmanager
 def gc_threshold(*args):
-    # TODO: RUSTPYTHON; GC is not supported yet
-    try:
-        yield
-    finally:
-        pass
-    return
-
     import gc
     old_threshold = gc.get_threshold()
     gc.set_threshold(*args)
@@ -1410,7 +1367,6 @@ def refcount_test(test):
 def requires_limited_api(test):
     try:
         import _testcapi  # noqa: F401
-
         import _testlimitedcapi  # noqa: F401
     except ImportError:
         return unittest.skip('needs _testcapi and _testlimitedcapi modules')(test)
@@ -1666,8 +1622,8 @@ def __init__(self, link=None):
 
     if sys.platform == "win32":
         def _platform_specific(self):
-            import _winapi
             import glob
+            import _winapi
 
             if os.path.lexists(self.real) and not os.path.exists(self.real):
                 # App symlink appears to not exist, but we want the
@@ -1739,6 +1695,25 @@ def skip_if_pgo_task(test):
     return test if ok else unittest.skip(msg)(test)
 
 
+def skip_if_unlimited_stack_size(test):
+    """Skip decorator for tests not run when an unlimited stack size is configured.
+
+    Tests using support.infinite_recursion([...]) may otherwise run into
+    an infinite loop, running until the memory on the system is filled and
+    crashing due to OOM.
+
+    See https://github.com/python/cpython/issues/143460.
+    """
+    if is_emscripten or is_wasi or os.name == "nt":
+        return test
+
+    import resource
+    curlim, maxlim = resource.getrlimit(resource.RLIMIT_STACK)
+    unlimited_stack_size_cond = curlim == maxlim and curlim in (-1, 0xFFFF_FFFF_FFFF_FFFF)
+    reason = "Not run due to unlimited stack size"
+    return unittest.skipIf(unlimited_stack_size_cond, reason)(test)
+
+
 def detect_api_mismatch(ref_api, other_api, *, ignore=()):
     """Returns the set of items in ref_api not in other_api, except for a
     defined list of items to be ignored in this check.
@@ -2063,10 +2038,9 @@ def missing_compiler_executable(cmd_names=[]):
     missing.
 
     """
-    import shutil
-
-    from setuptools import errors
     from setuptools._distutils import ccompiler, sysconfig
+    from setuptools import errors
+    import shutil
 
     compiler = ccompiler.new_compiler()
     sysconfig.customize_compiler(compiler)
@@ -2556,7 +2530,6 @@ 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):
@@ -2763,15 +2736,6 @@ 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
-        return _testcapi.Py_C_RECURSION_LIMIT
-    except ImportError:
-        raise unittest.SkipTest('requires _testcapi')
-
-
 def exceeds_recursion_limit():
     """For recursion tests, easily exceeds default recursion limit."""
     return 150_000
@@ -2988,7 +2952,6 @@ def is_slot_wrapper(name, value):
 @contextlib.contextmanager
 def force_color(color: bool):
     import _colorize
-
     from .os_helper import EnvironmentVarGuard
 
     with (
@@ -3267,3 +3230,10 @@ def linked_to_musl():
         return _linked_to_musl
     _linked_to_musl = tuple(map(int, version.split('.')))
     return _linked_to_musl
+
+
+def control_characters_c0() -> list[str]:
+    """Returns a list of C0 control characters as strings.
+    C0 control characters defined as the byte range 0x00-0x1F, and 0x7F.
+    """
+    return [chr(c) for c in range(0x00, 0x20)] + ["\x7F"]
diff --git a/Lib/test/support/import_helper.py b/Lib/test/support/import_helper.py
index 2d80b663dd5..4c7eac0b7eb 100644
--- a/Lib/test/support/import_helper.py
+++ b/Lib/test/support/import_helper.py
@@ -1,5 +1,5 @@
-import _imp
 import contextlib
+import _imp
 import importlib
 import importlib.machinery
 import importlib.util
@@ -10,7 +10,7 @@
 import unittest
 import warnings
 
-from .os_helper import temp_dir, unlink
+from .os_helper import unlink, temp_dir
 
 
 @contextlib.contextmanager
diff --git a/Lib/test/support/rustpython.py b/Lib/test/support/rustpython.py
new file mode 100644
index 00000000000..8ed7bc24dcf
--- /dev/null
+++ b/Lib/test/support/rustpython.py
@@ -0,0 +1,24 @@
+"""
+RustPython specific helpers.
+"""
+
+import doctest
+
+
+# copied from https://github.com/RustPython/RustPython/pull/6919
+EXPECTED_FAILURE = doctest.register_optionflag("EXPECTED_FAILURE")
+
+
+class DocTestChecker(doctest.OutputChecker):
+    """
+    Custom output checker that lets us add: `+EXPECTED_FAILURE` for doctest tests.
+
+    We want to be able to mark failing doctest test the same way we do with normal
+    unit test, without this class we would have to skip the doctest for the CI to pass.
+    """
+
+    def check_output(self, want, got, optionflags):
+        res = super().check_output(want, got, optionflags)
+        if optionflags & EXPECTED_FAILURE:
+            res = not res
+        return res
diff --git a/Lib/test/test___all__.py b/Lib/test/test___all__.py
index 7b5356ea02a..8ded9f99248 100644
--- a/Lib/test/test___all__.py
+++ b/Lib/test/test___all__.py
@@ -3,7 +3,6 @@
 from test.support import warnings_helper
 import os
 import sys
-import types
 
 
 if support.check_sanitizer(address=True, memory=True):
@@ -38,6 +37,7 @@ def check_all(self, modname):
             (".* (module|package)", DeprecationWarning),
             (".* (module|package)", PendingDeprecationWarning),
             ("", ResourceWarning),
+            ("", SyntaxWarning),
             quiet=True):
             try:
                 exec("import %s" % modname, names)
@@ -53,6 +53,7 @@ def check_all(self, modname):
             with warnings_helper.check_warnings(
                 ("", DeprecationWarning),
                 ("", ResourceWarning),
+                ("", SyntaxWarning),
                 quiet=True):
                 try:
                     exec("from %s import *" % modname, names)
@@ -71,6 +72,8 @@ def check_all(self, modname):
                 all_set = set(all_list)
                 self.assertCountEqual(all_set, all_list, "in module {}".format(modname))
                 self.assertEqual(keys, all_set, "in module {}".format(modname))
+                # Verify __dir__ is non-empty and doesn't produce an error
+                self.assertTrue(dir(sys.modules[modname]))
 
     def walk_modules(self, basedir, modpath):
         for fn in sorted(os.listdir(basedir)):
@@ -94,8 +97,6 @@ def walk_modules(self, basedir, modpath):
                 continue
             yield path, modpath + modname
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_all(self):
         # List of denied modules and packages
         denylist = set([
@@ -106,7 +107,7 @@ def test_all(self):
         # In case _socket fails to build, make this test fail more gracefully
         # than an AttributeError somewhere deep in concurrent.futures, email
         # or unittest.
-        import _socket
+        import _socket  # noqa: F401
 
         ignored = []
         failed_imports = []
diff --git a/Lib/test/test__locale.py b/Lib/test/test__locale.py
new file mode 100644
index 00000000000..11b2c9545a1
--- /dev/null
+++ b/Lib/test/test__locale.py
@@ -0,0 +1,300 @@
+from _locale import (setlocale, LC_ALL, LC_CTYPE, LC_NUMERIC, LC_TIME, localeconv, Error)
+try:
+    from _locale import (RADIXCHAR, THOUSEP, nl_langinfo)
+except ImportError:
+    nl_langinfo = None
+
+import locale
+import sys
+import unittest
+from platform import uname
+
+from test import support
+
+if uname().system == "Darwin":
+    maj, min, mic = [int(part) for part in uname().release.split(".")]
+    if (maj, min, mic) < (8, 0, 0):
+        raise unittest.SkipTest("locale support broken for OS X < 10.4")
+
+candidate_locales = ['es_UY', 'fr_FR', 'fi_FI', 'es_CO', 'pt_PT', 'it_IT',
+    'et_EE', 'es_PY', 'no_NO', 'nl_NL', 'lv_LV', 'el_GR', 'be_BY', 'fr_BE',
+    'ro_RO', 'ru_UA', 'ru_RU', 'es_VE', 'ca_ES', 'se_NO', 'es_EC', 'id_ID',
+    'ka_GE', 'es_CL', 'wa_BE', 'hu_HU', 'lt_LT', 'sl_SI', 'hr_HR', 'es_AR',
+    'es_ES', 'oc_FR', 'gl_ES', 'bg_BG', 'is_IS', 'mk_MK', 'de_AT', 'pt_BR',
+    'da_DK', 'nn_NO', 'cs_CZ', 'de_LU', 'es_BO', 'sq_AL', 'sk_SK', 'fr_CH',
+    'de_DE', 'sr_YU', 'br_FR', 'nl_BE', 'sv_FI', 'pl_PL', 'fr_CA', 'fo_FO',
+    'bs_BA', 'fr_LU', 'kl_GL', 'fa_IR', 'de_BE', 'sv_SE', 'it_CH', 'uk_UA',
+    'eu_ES', 'vi_VN', 'af_ZA', 'nb_NO', 'en_DK', 'tg_TJ', 'ps_AF', 'en_US',
+    'fr_FR.ISO8859-1', 'fr_FR.UTF-8', 'fr_FR.ISO8859-15@euro',
+    'ru_RU.KOI8-R', 'ko_KR.eucKR',
+    'ja_JP.UTF-8', 'lzh_TW.UTF-8', 'my_MM.UTF-8', 'or_IN.UTF-8', 'shn_MM.UTF-8',
+    'ar_AE.UTF-8', 'bn_IN.UTF-8', 'mr_IN.UTF-8', 'th_TH.TIS620',
+]
+
+def setUpModule():
+    global candidate_locales
+    # Issue #13441: Skip some locales (e.g. cs_CZ and hu_HU) on Solaris to
+    # workaround a mbstowcs() bug. For example, on Solaris, the hu_HU locale uses
+    # the locale encoding ISO-8859-2, the thousands separator is b'\xA0' and it is
+    # decoded as U+30000020 (an invalid character) by mbstowcs().
+    if sys.platform == 'sunos5':
+        old_locale = locale.setlocale(locale.LC_ALL)
+        try:
+            locales = []
+            for loc in candidate_locales:
+                try:
+                    locale.setlocale(locale.LC_ALL, loc)
+                except Error:
+                    continue
+                encoding = locale.getencoding()
+                try:
+                    localeconv()
+                except Exception as err:
+                    print("WARNING: Skip locale %s (encoding %s): [%s] %s"
+                        % (loc, encoding, type(err), err))
+                else:
+                    locales.append(loc)
+            candidate_locales = locales
+        finally:
+            locale.setlocale(locale.LC_ALL, old_locale)
+
+    # Workaround for MSVC6(debug) crash bug
+    if "MSC v.1200" in sys.version:
+        def accept(loc):
+            a = loc.split(".")
+            return not(len(a) == 2 and len(a[-1]) >= 9)
+        candidate_locales = [loc for loc in candidate_locales if accept(loc)]
+
+# List known locale values to test against when available.
+# Dict formatted as ``<locale> : (<decimal_point>, <thousands_sep>)``.  If a
+# value is not known, use '' .
+known_numerics = {
+    'en_US': ('.', ','),
+    'de_DE' : (',', '.'),
+    # The French thousands separator may be a breaking or non-breaking space
+    # depending on the platform, so do not test it
+    'fr_FR' : (',', ''),
+    'ps_AF': ('\u066b', '\u066c'),
+}
+
+known_alt_digits = {
+    'C': (0, {}),
+    'en_US': (0, {}),
+    'fa_IR': (100, {0: '\u06f0\u06f0', 10: '\u06f1\u06f0', 99: '\u06f9\u06f9'}),
+    'ja_JP': (100, {1: '\u4e00', 10: '\u5341', 99: '\u4e5d\u5341\u4e5d'}),
+    'lzh_TW': (32, {0: '\u3007', 10: '\u5341', 31: '\u5345\u4e00'}),
+    'my_MM': (100, {0: '\u1040\u1040', 10: '\u1041\u1040', 99: '\u1049\u1049'}),
+    'or_IN': (100, {0: '\u0b66', 10: '\u0b67\u0b66', 99: '\u0b6f\u0b6f'}),
+    'shn_MM': (100, {0: '\u1090\u1090', 10: '\u1091\u1090', 99: '\u1099\u1099'}),
+    'ar_AE': (100, {0: '\u0660', 10: '\u0661\u0660', 99: '\u0669\u0669'}),
+    'bn_IN': (100, {0: '\u09e6', 10: '\u09e7\u09e6', 99: '\u09ef\u09ef'}),
+}
+
+known_era = {
+    'C': (0, ''),
+    'en_US': (0, ''),
+    'ja_JP': (11, '+:1:2019/05/01:2019/12/31:令和:%EC元年'),
+    'zh_TW': (3, '+:1:1912/01/01:1912/12/31:民國:%EC元年'),
+    'th_TW': (1, '+:1:-543/01/01:+*:พ.ศ.:%EC %Ey'),
+}
+
+if sys.platform == 'win32':
+    # ps_AF doesn't work on Windows: see bpo-38324 (msg361830)
+    del known_numerics['ps_AF']
+
+if sys.platform == 'sunos5':
+    # On Solaris, Japanese ERAs start with the year 1927,
+    # and thus there's less of them.
+    known_era['ja_JP'] = (5, '+:1:2019/05/01:2019/12/31:令和:%EC元年')
+
+class _LocaleTests(unittest.TestCase):
+
+    def setUp(self):
+        self.oldlocale = setlocale(LC_ALL)
+
+    def tearDown(self):
+        setlocale(LC_ALL, self.oldlocale)
+
+    # Want to know what value was calculated, what it was compared against,
+    # what function was used for the calculation, what type of data was used,
+    # the locale that was supposedly set, and the actual locale that is set.
+    lc_numeric_err_msg = "%s != %s (%s for %s; set to %s, using %s)"
+
+    def numeric_tester(self, calc_type, calc_value, data_type, used_locale):
+        """Compare calculation against known value, if available"""
+        try:
+            set_locale = setlocale(LC_NUMERIC)
+        except Error:
+            set_locale = "<not able to determine>"
+        known_value = known_numerics.get(used_locale,
+                                    ('', ''))[data_type == 'thousands_sep']
+        if known_value and calc_value:
+            self.assertEqual(calc_value, known_value,
+                                self.lc_numeric_err_msg % (
+                                    calc_value, known_value,
+                                    calc_type, data_type, set_locale,
+                                    used_locale))
+            return True
+
+    @unittest.skipUnless(nl_langinfo, "nl_langinfo is not available")
+    @unittest.skipIf(support.linked_to_musl(), "musl libc issue, bpo-46390")
+    def test_lc_numeric_nl_langinfo(self):
+        # Test nl_langinfo against known values
+        tested = False
+        oldloc = setlocale(LC_CTYPE)
+        for loc in candidate_locales:
+            try:
+                setlocale(LC_NUMERIC, loc)
+            except Error:
+                continue
+            for li, lc in ((RADIXCHAR, "decimal_point"),
+                            (THOUSEP, "thousands_sep")):
+                if self.numeric_tester('nl_langinfo', nl_langinfo(li), lc, loc):
+                    tested = True
+            self.assertEqual(setlocale(LC_CTYPE), oldloc)
+        if not tested:
+            self.skipTest('no suitable locales')
+
+    @unittest.skipIf(support.linked_to_musl(), "musl libc issue, bpo-46390")
+    def test_lc_numeric_localeconv(self):
+        # Test localeconv against known values
+        tested = False
+        oldloc = setlocale(LC_CTYPE)
+        for loc in candidate_locales:
+            try:
+                setlocale(LC_NUMERIC, loc)
+            except Error:
+                continue
+            formatting = localeconv()
+            for lc in ("decimal_point",
+                        "thousands_sep"):
+                if self.numeric_tester('localeconv', formatting[lc], lc, loc):
+                    tested = True
+            self.assertEqual(setlocale(LC_CTYPE), oldloc)
+        if not tested:
+            self.skipTest('no suitable locales')
+
+    @unittest.skipUnless(nl_langinfo, "nl_langinfo is not available")
+    def test_lc_numeric_basic(self):
+        # Test nl_langinfo against localeconv
+        tested = False
+        oldloc = setlocale(LC_CTYPE)
+        for loc in candidate_locales:
+            try:
+                setlocale(LC_NUMERIC, loc)
+            except Error:
+                continue
+            for li, lc in ((RADIXCHAR, "decimal_point"),
+                            (THOUSEP, "thousands_sep")):
+                nl_radixchar = nl_langinfo(li)
+                li_radixchar = localeconv()[lc]
+                try:
+                    set_locale = setlocale(LC_NUMERIC)
+                except Error:
+                    set_locale = "<not able to determine>"
+                self.assertEqual(nl_radixchar, li_radixchar,
+                                "%s (nl_langinfo) != %s (localeconv) "
+                                "(set to %s, using %s)" % (
+                                                nl_radixchar, li_radixchar,
+                                                loc, set_locale))
+                tested = True
+            self.assertEqual(setlocale(LC_CTYPE), oldloc)
+        if not tested:
+            self.skipTest('no suitable locales')
+
+    @unittest.skipUnless(nl_langinfo, "nl_langinfo is not available")
+    @unittest.skipUnless(hasattr(locale, 'ALT_DIGITS'), "requires locale.ALT_DIGITS")
+    @unittest.skipIf(support.linked_to_musl(), "musl libc issue, bpo-46390")
+    def test_alt_digits_nl_langinfo(self):
+        # Test nl_langinfo(ALT_DIGITS)
+        tested = False
+        for loc in candidate_locales:
+            with self.subTest(locale=loc):
+                try:
+                    setlocale(LC_TIME, loc)
+                except Error:
+                    self.skipTest(f'no locale {loc!r}')
+                    continue
+
+                with self.subTest(locale=loc):
+                    alt_digits = nl_langinfo(locale.ALT_DIGITS)
+                    self.assertIsInstance(alt_digits, str)
+                    alt_digits = alt_digits.split(';') if alt_digits else []
+                    if alt_digits:
+                        self.assertGreaterEqual(len(alt_digits), 10, alt_digits)
+                    loc1 = loc.split('.', 1)[0]
+                    if loc1 in known_alt_digits:
+                        count, samples = known_alt_digits[loc1]
+                        if count and not alt_digits:
+                            self.skipTest(f'ALT_DIGITS is not set for locale {loc!r} on this platform')
+                        self.assertEqual(len(alt_digits), count, alt_digits)
+                        for i in samples:
+                            self.assertEqual(alt_digits[i], samples[i])
+                    tested = True
+        if not tested:
+            self.skipTest('no suitable locales')
+
+    @unittest.skipUnless(nl_langinfo, "nl_langinfo is not available")
+    @unittest.skipUnless(hasattr(locale, 'ERA'), "requires locale.ERA")
+    @unittest.skipIf(support.linked_to_musl(), "musl libc issue, bpo-46390")
+    def test_era_nl_langinfo(self):
+        # Test nl_langinfo(ERA)
+        tested = False
+        for loc in candidate_locales:
+            with self.subTest(locale=loc):
+                try:
+                    setlocale(LC_TIME, loc)
+                except Error:
+                    self.skipTest(f'no locale {loc!r}')
+                    continue
+
+                with self.subTest(locale=loc):
+                    era = nl_langinfo(locale.ERA)
+                    self.assertIsInstance(era, str)
+                    if era:
+                        self.assertEqual(era.count(':'), (era.count(';') + 1) * 5, era)
+
+                    loc1 = loc.split('.', 1)[0]
+                    if loc1 in known_era:
+                        count, sample = known_era[loc1]
+                        if count:
+                            if not era:
+                                self.skipTest(f'ERA is not set for locale {loc!r} on this platform')
+                            self.assertGreaterEqual(era.count(';') + 1, count)
+                            self.assertIn(sample, era)
+                        else:
+                            self.assertEqual(era, '')
+                    tested = True
+        if not tested:
+            self.skipTest('no suitable locales')
+
+    def test_float_parsing(self):
+        # Bug #1391872: Test whether float parsing is okay on European
+        # locales.
+        tested = False
+        oldloc = setlocale(LC_CTYPE)
+        for loc in candidate_locales:
+            try:
+                setlocale(LC_NUMERIC, loc)
+            except Error:
+                continue
+
+            # Ignore buggy locale databases. (Mac OS 10.4 and some other BSDs)
+            if loc == 'eu_ES' and localeconv()['decimal_point'] == "' ":
+                continue
+
+            self.assertEqual(int(eval('3.14') * 100), 314,
+                                "using eval('3.14') failed for %s" % loc)
+            self.assertEqual(int(float('3.14') * 100), 314,
+                                "using float('3.14') failed for %s" % loc)
+            if localeconv()['decimal_point'] != '.':
+                self.assertRaises(ValueError, float,
+                                  localeconv()['decimal_point'].join(['1', '23']))
+            tested = True
+            self.assertEqual(setlocale(LC_CTYPE), oldloc)
+        if not tested:
+            self.skipTest('no suitable locales')
+
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/Lib/test/test__opcode.py b/Lib/test/test__opcode.py
index 43d475baa5d..c253bc2be02 100644
--- a/Lib/test/test__opcode.py
+++ b/Lib/test/test__opcode.py
@@ -38,7 +38,6 @@ 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; KeyError: 'BINARY_OP_ADD_INT'
     def test_opmaps(self):
         def check_roundtrip(name, map):
             return self.assertEqual(opcode.opname[map[name]], name)
@@ -116,7 +115,6 @@ def test_stack_effect_jump(self):
 
 
 class SpecializationStatsTests(unittest.TestCase):
-    @unittest.expectedFailure  # TODO: RUSTPYTHON; AssertionError: 'load_attr' not found in []
     def test_specialization_stats(self):
         stat_names = ["success", "failure", "hit", "deferred", "miss", "deopt"]
         specialized_opcodes = [
diff --git a/Lib/test/test__osx_support.py b/Lib/test/test__osx_support.py
index 4a14cb35213..0813c4804c1 100644
--- a/Lib/test/test__osx_support.py
+++ b/Lib/test/test__osx_support.py
@@ -20,12 +20,13 @@ def setUp(self):
         self.prog_name = 'bogus_program_xxxx'
         self.temp_path_dir = os.path.abspath(os.getcwd())
         self.env = self.enterContext(os_helper.EnvironmentVarGuard())
-        for cv in ('CFLAGS', 'LDFLAGS', 'CPPFLAGS',
-                            'BASECFLAGS', 'BLDSHARED', 'LDSHARED', 'CC',
-                            'CXX', 'PY_CFLAGS', 'PY_LDFLAGS', 'PY_CPPFLAGS',
-                            'PY_CORE_CFLAGS', 'PY_CORE_LDFLAGS'):
-            if cv in self.env:
-                self.env.unset(cv)
+
+        self.env.unset(
+            'CFLAGS', 'LDFLAGS', 'CPPFLAGS',
+            'BASECFLAGS', 'BLDSHARED', 'LDSHARED', 'CC',
+            'CXX', 'PY_CFLAGS', 'PY_LDFLAGS', 'PY_CPPFLAGS',
+            'PY_CORE_CFLAGS', 'PY_CORE_LDFLAGS'
+        )
 
     def add_expected_saved_initial_values(self, config_vars, expected_vars):
         # Ensure that the initial values for all modified config vars
@@ -65,8 +66,8 @@ def test__find_build_tool(self):
                             'cc not found - check xcode-select')
 
     def test__get_system_version(self):
-        self.assertTrue(platform.mac_ver()[0].startswith(
-                                    _osx_support._get_system_version()))
+        self.assertStartsWith(platform.mac_ver()[0],
+                              _osx_support._get_system_version())
 
     def test__remove_original_values(self):
         config_vars = {
diff --git a/Lib/test/test_abc.py b/Lib/test/test_abc.py
index 92bd955855b..e29fc5a2394 100644
--- a/Lib/test/test_abc.py
+++ b/Lib/test/test_abc.py
@@ -20,7 +20,7 @@ def test_abstractproperty_basics(self):
             def foo(self): pass
             self.assertTrue(foo.__isabstractmethod__)
             def bar(self): pass
-            self.assertFalse(hasattr(bar, "__isabstractmethod__"))
+            self.assertNotHasAttr(bar, "__isabstractmethod__")
 
             class C(metaclass=abc_ABCMeta):
                 @abc.abstractproperty
@@ -89,7 +89,7 @@ def test_abstractmethod_basics(self):
             def foo(self): pass
             self.assertTrue(foo.__isabstractmethod__)
             def bar(self): pass
-            self.assertFalse(hasattr(bar, "__isabstractmethod__"))
+            self.assertNotHasAttr(bar, "__isabstractmethod__")
 
         def test_abstractproperty_basics(self):
             @property
@@ -168,8 +168,7 @@ def method_two(self):
             msg = r"class C without an implementation for abstract methods 'method_one', 'method_two'"
             self.assertRaisesRegex(TypeError, msg, C)
 
-        # TODO: RUSTPYTHON; AssertionError: False is not true
-        @unittest.expectedFailure
+        @unittest.expectedFailure  # TODO: RUSTPYTHON; AssertionError: False is not true
         def test_abstractmethod_integration(self):
             for abstractthing in [abc.abstractmethod, abc.abstractproperty,
                                   abc.abstractclassmethod,
@@ -278,21 +277,21 @@ class A(metaclass=abc_ABCMeta):
             class B(object):
                 pass
             b = B()
-            self.assertFalse(issubclass(B, A))
-            self.assertFalse(issubclass(B, (A,)))
+            self.assertNotIsSubclass(B, A)
+            self.assertNotIsSubclass(B, (A,))
             self.assertNotIsInstance(b, A)
             self.assertNotIsInstance(b, (A,))
             B1 = A.register(B)
-            self.assertTrue(issubclass(B, A))
-            self.assertTrue(issubclass(B, (A,)))
+            self.assertIsSubclass(B, A)
+            self.assertIsSubclass(B, (A,))
             self.assertIsInstance(b, A)
             self.assertIsInstance(b, (A,))
             self.assertIs(B1, B)
             class C(B):
                 pass
             c = C()
-            self.assertTrue(issubclass(C, A))
-            self.assertTrue(issubclass(C, (A,)))
+            self.assertIsSubclass(C, A)
+            self.assertIsSubclass(C, (A,))
             self.assertIsInstance(c, A)
             self.assertIsInstance(c, (A,))
 
@@ -303,16 +302,16 @@ class A(metaclass=abc_ABCMeta):
             class B(object):
                 pass
             b = B()
-            self.assertTrue(issubclass(B, A))
-            self.assertTrue(issubclass(B, (A,)))
+            self.assertIsSubclass(B, A)
+            self.assertIsSubclass(B, (A,))
             self.assertIsInstance(b, A)
             self.assertIsInstance(b, (A,))
             @A.register
             class C(B):
                 pass
             c = C()
-            self.assertTrue(issubclass(C, A))
-            self.assertTrue(issubclass(C, (A,)))
+            self.assertIsSubclass(C, A)
+            self.assertIsSubclass(C, (A,))
             self.assertIsInstance(c, A)
             self.assertIsInstance(c, (A,))
             self.assertIs(C, A.register(C))
@@ -323,14 +322,14 @@ class A(metaclass=abc_ABCMeta):
             class B:
                 pass
             b = B()
-            self.assertFalse(isinstance(b, A))
-            self.assertFalse(isinstance(b, (A,)))
+            self.assertNotIsInstance(b, A)
+            self.assertNotIsInstance(b, (A,))
             token_old = abc_get_cache_token()
             A.register(B)
             token_new = abc_get_cache_token()
             self.assertGreater(token_new, token_old)
-            self.assertTrue(isinstance(b, A))
-            self.assertTrue(isinstance(b, (A,)))
+            self.assertIsInstance(b, A)
+            self.assertIsInstance(b, (A,))
 
         def test_registration_builtins(self):
             class A(metaclass=abc_ABCMeta):
@@ -338,18 +337,18 @@ class A(metaclass=abc_ABCMeta):
             A.register(int)
             self.assertIsInstance(42, A)
             self.assertIsInstance(42, (A,))
-            self.assertTrue(issubclass(int, A))
-            self.assertTrue(issubclass(int, (A,)))
+            self.assertIsSubclass(int, A)
+            self.assertIsSubclass(int, (A,))
             class B(A):
                 pass
             B.register(str)
             class C(str): pass
             self.assertIsInstance("", A)
             self.assertIsInstance("", (A,))
-            self.assertTrue(issubclass(str, A))
-            self.assertTrue(issubclass(str, (A,)))
-            self.assertTrue(issubclass(C, A))
-            self.assertTrue(issubclass(C, (A,)))
+            self.assertIsSubclass(str, A)
+            self.assertIsSubclass(str, (A,))
+            self.assertIsSubclass(C, A)
+            self.assertIsSubclass(C, (A,))
 
         def test_registration_edge_cases(self):
             class A(metaclass=abc_ABCMeta):
@@ -377,39 +376,39 @@ class A(metaclass=abc_ABCMeta):
         def test_registration_transitiveness(self):
             class A(metaclass=abc_ABCMeta):
                 pass
-            self.assertTrue(issubclass(A, A))
-            self.assertTrue(issubclass(A, (A,)))
+            self.assertIsSubclass(A, A)
+            self.assertIsSubclass(A, (A,))
             class B(metaclass=abc_ABCMeta):
                 pass
-            self.assertFalse(issubclass(A, B))
-            self.assertFalse(issubclass(A, (B,)))
-            self.assertFalse(issubclass(B, A))
-            self.assertFalse(issubclass(B, (A,)))
+            self.assertNotIsSubclass(A, B)
+            self.assertNotIsSubclass(A, (B,))
+            self.assertNotIsSubclass(B, A)
+            self.assertNotIsSubclass(B, (A,))
             class C(metaclass=abc_ABCMeta):
                 pass
             A.register(B)
             class B1(B):
                 pass
-            self.assertTrue(issubclass(B1, A))
-            self.assertTrue(issubclass(B1, (A,)))
+            self.assertIsSubclass(B1, A)
+            self.assertIsSubclass(B1, (A,))
             class C1(C):
                 pass
             B1.register(C1)
-            self.assertFalse(issubclass(C, B))
-            self.assertFalse(issubclass(C, (B,)))
-            self.assertFalse(issubclass(C, B1))
-            self.assertFalse(issubclass(C, (B1,)))
-            self.assertTrue(issubclass(C1, A))
-            self.assertTrue(issubclass(C1, (A,)))
-            self.assertTrue(issubclass(C1, B))
-            self.assertTrue(issubclass(C1, (B,)))
-            self.assertTrue(issubclass(C1, B1))
-            self.assertTrue(issubclass(C1, (B1,)))
+            self.assertNotIsSubclass(C, B)
+            self.assertNotIsSubclass(C, (B,))
+            self.assertNotIsSubclass(C, B1)
+            self.assertNotIsSubclass(C, (B1,))
+            self.assertIsSubclass(C1, A)
+            self.assertIsSubclass(C1, (A,))
+            self.assertIsSubclass(C1, B)
+            self.assertIsSubclass(C1, (B,))
+            self.assertIsSubclass(C1, B1)
+            self.assertIsSubclass(C1, (B1,))
             C1.register(int)
             class MyInt(int):
                 pass
-            self.assertTrue(issubclass(MyInt, A))
-            self.assertTrue(issubclass(MyInt, (A,)))
+            self.assertIsSubclass(MyInt, A)
+            self.assertIsSubclass(MyInt, (A,))
             self.assertIsInstance(42, A)
             self.assertIsInstance(42, (A,))
 
@@ -469,16 +468,16 @@ def __subclasshook__(cls, C):
                     if cls is A:
                         return 'foo' in C.__dict__
                     return NotImplemented
-            self.assertFalse(issubclass(A, A))
-            self.assertFalse(issubclass(A, (A,)))
+            self.assertNotIsSubclass(A, A)
+            self.assertNotIsSubclass(A, (A,))
             class B:
                 foo = 42
-            self.assertTrue(issubclass(B, A))
-            self.assertTrue(issubclass(B, (A,)))
+            self.assertIsSubclass(B, A)
+            self.assertIsSubclass(B, (A,))
             class C:
                 spam = 42
-            self.assertFalse(issubclass(C, A))
-            self.assertFalse(issubclass(C, (A,)))
+            self.assertNotIsSubclass(C, A)
+            self.assertNotIsSubclass(C, (A,))
 
         def test_all_new_methods_are_called(self):
             class A(metaclass=abc_ABCMeta):
@@ -495,7 +494,7 @@ class C(A, B):
             self.assertEqual(B.counter, 1)
 
         def test_ABC_has___slots__(self):
-            self.assertTrue(hasattr(abc.ABC, '__slots__'))
+            self.assertHasAttr(abc.ABC, '__slots__')
 
         def test_tricky_new_works(self):
             def with_metaclass(meta, *bases):
@@ -517,13 +516,14 @@ def foo(self):
 
             del A.foo
             self.assertEqual(A.__abstractmethods__, {'foo'})
-            self.assertFalse(hasattr(A, 'foo'))
+            self.assertNotHasAttr(A, 'foo')
 
             abc.update_abstractmethods(A)
 
             self.assertEqual(A.__abstractmethods__, set())
             A()
 
+
         def test_update_new_abstractmethods(self):
             class A(metaclass=abc_ABCMeta):
                 @abc.abstractmethod
@@ -589,7 +589,7 @@ def updated_foo(self):
             A.foo = updated_foo
             abc.update_abstractmethods(A)
             A()
-            self.assertFalse(hasattr(A, '__abstractmethods__'))
+            self.assertNotHasAttr(A, '__abstractmethods__')
 
         def test_update_del_implementation(self):
             class A(metaclass=abc_ABCMeta):
@@ -685,10 +685,16 @@ class B(A, metaclass=abc_ABCMeta, name="test"):
 
     return TestLegacyAPI, TestABC, TestABCWithInitSubclass
 
-TestLegacyAPI_Py, TestABC_Py, TestABCWithInitSubclass_Py = test_factory(abc.ABCMeta,
-                                                                        abc.get_cache_token)
-TestLegacyAPI_C, TestABC_C, TestABCWithInitSubclass_C = test_factory(_py_abc.ABCMeta,
-                                                                     _py_abc.get_cache_token)
+TestLegacyAPI_Py, TestABC_Py, TestABCWithInitSubclass_Py = test_factory(_py_abc.ABCMeta,
+                                                                        _py_abc.get_cache_token)
+TestLegacyAPI_C, TestABC_C, TestABCWithInitSubclass_C = test_factory(abc.ABCMeta,
+                                                                     abc.get_cache_token)
+
+# gh-130095: The _py_abc tests are not thread-safe when run with
+# `--parallel-threads`
+TestLegacyAPI_Py.__unittest_thread_unsafe__ = True
+TestABC_Py.__unittest_thread_unsafe__ = True
+TestABCWithInitSubclass_Py.__unittest_thread_unsafe__ = True
 
 if __name__ == "__main__":
     unittest.main()
diff --git a/Lib/test/test_abstract_numbers.py b/Lib/test/test_abstract_numbers.py
index 72232b670cd..cf071d2c933 100644
--- a/Lib/test/test_abstract_numbers.py
+++ b/Lib/test/test_abstract_numbers.py
@@ -24,11 +24,11 @@ def not_implemented(*args, **kwargs):
 
 class TestNumbers(unittest.TestCase):
     def test_int(self):
-        self.assertTrue(issubclass(int, Integral))
-        self.assertTrue(issubclass(int, Rational))
-        self.assertTrue(issubclass(int, Real))
-        self.assertTrue(issubclass(int, Complex))
-        self.assertTrue(issubclass(int, Number))
+        self.assertIsSubclass(int, Integral)
+        self.assertIsSubclass(int, Rational)
+        self.assertIsSubclass(int, Real)
+        self.assertIsSubclass(int, Complex)
+        self.assertIsSubclass(int, Number)
 
         self.assertEqual(7, int(7).real)
         self.assertEqual(0, int(7).imag)
@@ -38,11 +38,11 @@ def test_int(self):
         self.assertEqual(1, int(7).denominator)
 
     def test_float(self):
-        self.assertFalse(issubclass(float, Integral))
-        self.assertFalse(issubclass(float, Rational))
-        self.assertTrue(issubclass(float, Real))
-        self.assertTrue(issubclass(float, Complex))
-        self.assertTrue(issubclass(float, Number))
+        self.assertNotIsSubclass(float, Integral)
+        self.assertNotIsSubclass(float, Rational)
+        self.assertIsSubclass(float, Real)
+        self.assertIsSubclass(float, Complex)
+        self.assertIsSubclass(float, Number)
 
         self.assertEqual(7.3, float(7.3).real)
         self.assertEqual(0, float(7.3).imag)
@@ -50,11 +50,11 @@ def test_float(self):
         self.assertEqual(-7.3, float(-7.3).conjugate())
 
     def test_complex(self):
-        self.assertFalse(issubclass(complex, Integral))
-        self.assertFalse(issubclass(complex, Rational))
-        self.assertFalse(issubclass(complex, Real))
-        self.assertTrue(issubclass(complex, Complex))
-        self.assertTrue(issubclass(complex, Number))
+        self.assertNotIsSubclass(complex, Integral)
+        self.assertNotIsSubclass(complex, Rational)
+        self.assertNotIsSubclass(complex, Real)
+        self.assertIsSubclass(complex, Complex)
+        self.assertIsSubclass(complex, Number)
 
         c1, c2 = complex(3, 2), complex(4,1)
         # XXX: This is not ideal, but see the comment in math_trunc().
diff --git a/Lib/test/test_annotationlib.py b/Lib/test/test_annotationlib.py
new file mode 100644
index 00000000000..e89d6c0b161
--- /dev/null
+++ b/Lib/test/test_annotationlib.py
@@ -0,0 +1,2252 @@
+"""Tests for the annotations module."""
+
+import textwrap
+import annotationlib
+import builtins
+import collections
+import functools
+import itertools
+import pickle
+from string.templatelib import Template, Interpolation
+import types
+import typing
+import sys
+import unittest
+from annotationlib import (
+    Format,
+    ForwardRef,
+    get_annotations,
+    annotations_to_string,
+    type_repr,
+)
+from typing import Unpack, get_type_hints, List, Union
+
+from test import support
+from test.support import import_helper
+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
+
+
+def times_three(fn):
+    @functools.wraps(fn)
+    def wrapper(a, b):
+        return fn(a * 3, b * 3)
+
+    return wrapper
+
+
+class MyClass:
+    def __repr__(self):
+        return "my repr"
+
+
+class TestFormat(unittest.TestCase):
+    def test_enum(self):
+        self.assertEqual(Format.VALUE.value, 1)
+        self.assertEqual(Format.VALUE, 1)
+
+        self.assertEqual(Format.VALUE_WITH_FAKE_GLOBALS.value, 2)
+        self.assertEqual(Format.VALUE_WITH_FAKE_GLOBALS, 2)
+
+        self.assertEqual(Format.FORWARDREF.value, 3)
+        self.assertEqual(Format.FORWARDREF, 3)
+
+        self.assertEqual(Format.STRING.value, 4)
+        self.assertEqual(Format.STRING, 4)
+
+
+class TestForwardRefFormat(unittest.TestCase):
+    def test_closure(self):
+        def inner(arg: x):
+            pass
+
+        anno = get_annotations(inner, format=Format.FORWARDREF)
+        fwdref = anno["arg"]
+        self.assertIsInstance(fwdref, ForwardRef)
+        self.assertEqual(fwdref.__forward_arg__, "x")
+        with self.assertRaises(NameError):
+            fwdref.evaluate()
+
+        x = 1
+        self.assertEqual(fwdref.evaluate(), x)
+
+        anno = get_annotations(inner, format=Format.FORWARDREF)
+        self.assertEqual(anno["arg"], x)
+
+    def test_multiple_closure(self):
+        def inner(arg: x[y]):
+            pass
+
+        fwdref = get_annotations(inner, format=Format.FORWARDREF)["arg"]
+        self.assertIsInstance(fwdref, ForwardRef)
+        self.assertEqual(fwdref.__forward_arg__, "x[y]")
+        with self.assertRaises(NameError):
+            fwdref.evaluate()
+
+        y = str
+        fwdref = get_annotations(inner, format=Format.FORWARDREF)["arg"]
+        self.assertIsInstance(fwdref, ForwardRef)
+        extra_name, extra_val = next(iter(fwdref.__extra_names__.items()))
+        self.assertEqual(fwdref.__forward_arg__.replace(extra_name, extra_val.__name__), "x[str]")
+        with self.assertRaises(NameError):
+            fwdref.evaluate()
+
+        x = list
+        self.assertEqual(fwdref.evaluate(), x[y])
+
+        fwdref = get_annotations(inner, format=Format.FORWARDREF)["arg"]
+        self.assertEqual(fwdref, x[y])
+
+    def test_function(self):
+        def f(x: int, y: doesntexist):
+            pass
+
+        anno = get_annotations(f, format=Format.FORWARDREF)
+        self.assertIs(anno["x"], int)
+        fwdref = anno["y"]
+        self.assertIsInstance(fwdref, ForwardRef)
+        self.assertEqual(fwdref.__forward_arg__, "doesntexist")
+        with self.assertRaises(NameError):
+            fwdref.evaluate()
+        self.assertEqual(fwdref.evaluate(globals={"doesntexist": 1}), 1)
+
+    def test_nonexistent_attribute(self):
+        def f(
+            x: some.module,
+            y: some[module],
+            z: some(module),
+            alpha: some | obj,
+            beta: +some,
+            gamma: some < obj,
+            delta: some | {obj: module},
+            epsilon: some | {obj},
+            zeta: some | [obj, module],
+            eta: some | (),
+        ):
+            pass
+
+        anno = get_annotations(f, format=Format.FORWARDREF)
+        x_anno = anno["x"]
+        self.assertIsInstance(x_anno, ForwardRef)
+        self.assertEqual(x_anno, support.EqualToForwardRef("some.module", owner=f))
+
+        y_anno = anno["y"]
+        self.assertIsInstance(y_anno, ForwardRef)
+        self.assertEqual(y_anno, support.EqualToForwardRef("some[module]", owner=f))
+
+        z_anno = anno["z"]
+        self.assertIsInstance(z_anno, ForwardRef)
+        self.assertEqual(z_anno, support.EqualToForwardRef("some(module)", owner=f))
+
+        alpha_anno = anno["alpha"]
+        self.assertIsInstance(alpha_anno, ForwardRef)
+        self.assertEqual(alpha_anno, support.EqualToForwardRef("some | obj", owner=f))
+
+        beta_anno = anno["beta"]
+        self.assertIsInstance(beta_anno, ForwardRef)
+        self.assertEqual(beta_anno, support.EqualToForwardRef("+some", owner=f))
+
+        gamma_anno = anno["gamma"]
+        self.assertIsInstance(gamma_anno, ForwardRef)
+        self.assertEqual(gamma_anno, support.EqualToForwardRef("some < obj", owner=f))
+
+        delta_anno = anno["delta"]
+        self.assertIsInstance(delta_anno, ForwardRef)
+        self.assertEqual(delta_anno, support.EqualToForwardRef("some | {obj: module}", owner=f))
+
+        epsilon_anno = anno["epsilon"]
+        self.assertIsInstance(epsilon_anno, ForwardRef)
+        self.assertEqual(epsilon_anno, support.EqualToForwardRef("some | {obj}", owner=f))
+
+        zeta_anno = anno["zeta"]
+        self.assertIsInstance(zeta_anno, ForwardRef)
+        self.assertEqual(zeta_anno, support.EqualToForwardRef("some | [obj, module]", owner=f))
+
+        eta_anno = anno["eta"]
+        self.assertIsInstance(eta_anno, ForwardRef)
+        self.assertEqual(eta_anno, support.EqualToForwardRef("some | ()", owner=f))
+
+    def test_partially_nonexistent(self):
+        # These annotations start with a non-existent variable and then use
+        # global types with defined values. This partially evaluates by putting
+        # those globals into `fwdref.__extra_names__`.
+        def f(
+            x: obj | int,
+            y: container[int:obj, int],
+            z: dict_val | {str: int},
+            alpha: set_val | {str, int},
+            beta: obj | bool | int,
+            gamma: obj | call_func(int, kwd=bool),
+        ):
+            pass
+
+        def func(*args, **kwargs):
+            return Union[*args, *(kwargs.values())]
+
+        anno = get_annotations(f, format=Format.FORWARDREF)
+        globals_ = {
+            "obj": str, "container": list, "dict_val": {1: 2}, "set_val": {1, 2},
+            "call_func": func
+        }
+
+        x_anno = anno["x"]
+        self.assertIsInstance(x_anno, ForwardRef)
+        self.assertEqual(x_anno.evaluate(globals=globals_), str | int)
+
+        y_anno = anno["y"]
+        self.assertIsInstance(y_anno, ForwardRef)
+        self.assertEqual(y_anno.evaluate(globals=globals_), list[int:str, int])
+
+        z_anno = anno["z"]
+        self.assertIsInstance(z_anno, ForwardRef)
+        self.assertEqual(z_anno.evaluate(globals=globals_), {1: 2} | {str: int})
+
+        alpha_anno = anno["alpha"]
+        self.assertIsInstance(alpha_anno, ForwardRef)
+        self.assertEqual(alpha_anno.evaluate(globals=globals_), {1, 2} | {str, int})
+
+        beta_anno = anno["beta"]
+        self.assertIsInstance(beta_anno, ForwardRef)
+        self.assertEqual(beta_anno.evaluate(globals=globals_), str | bool | int)
+
+        gamma_anno = anno["gamma"]
+        self.assertIsInstance(gamma_anno, ForwardRef)
+        self.assertEqual(gamma_anno.evaluate(globals=globals_), str | func(int, kwd=bool))
+
+    def test_partially_nonexistent_union(self):
+        # Test unions with '|' syntax equal unions with typing.Union[] with some forwardrefs
+        class UnionForwardrefs:
+            pipe: str | undefined
+            union: Union[str, undefined]
+
+        annos = get_annotations(UnionForwardrefs, format=Format.FORWARDREF)
+
+        pipe = annos["pipe"]
+        self.assertIsInstance(pipe, ForwardRef)
+        self.assertEqual(
+            pipe.evaluate(globals={"undefined": int}),
+            str | int,
+        )
+        union = annos["union"]
+        self.assertIsInstance(union, Union)
+        arg1, arg2 = typing.get_args(union)
+        self.assertIs(arg1, str)
+        self.assertEqual(
+            arg2, support.EqualToForwardRef("undefined", is_class=True, owner=UnionForwardrefs)
+        )
+
+
+class TestStringFormat(unittest.TestCase):
+    def test_closure(self):
+        x = 0
+
+        def inner(arg: x):
+            pass
+
+        anno = get_annotations(inner, format=Format.STRING)
+        self.assertEqual(anno, {"arg": "x"})
+
+    def test_closure_undefined(self):
+        if False:
+            x = 0
+
+        def inner(arg: x):
+            pass
+
+        anno = get_annotations(inner, format=Format.STRING)
+        self.assertEqual(anno, {"arg": "x"})
+
+    def test_function(self):
+        def f(x: int, y: doesntexist):
+            pass
+
+        anno = get_annotations(f, format=Format.STRING)
+        self.assertEqual(anno, {"x": "int", "y": "doesntexist"})
+
+    def test_expressions(self):
+        def f(
+            add: a + b,
+            sub: a - b,
+            mul: a * b,
+            matmul: a @ b,
+            truediv: a / b,
+            mod: a % b,
+            lshift: a << b,
+            rshift: a >> b,
+            or_: a | b,
+            xor: a ^ b,
+            and_: a & b,
+            floordiv: a // b,
+            pow_: a**b,
+            lt: a < b,
+            le: a <= b,
+            eq: a == b,
+            ne: a != b,
+            gt: a > b,
+            ge: a >= b,
+            invert: ~a,
+            neg: -a,
+            pos: +a,
+            getitem: a[b],
+            getattr: a.b,
+            call: a(b, *c, d=e),  # **kwargs are not supported
+            *args: *a,
+        ):
+            pass
+
+        anno = get_annotations(f, format=Format.STRING)
+        self.assertEqual(
+            anno,
+            {
+                "add": "a + b",
+                "sub": "a - b",
+                "mul": "a * b",
+                "matmul": "a @ b",
+                "truediv": "a / b",
+                "mod": "a % b",
+                "lshift": "a << b",
+                "rshift": "a >> b",
+                "or_": "a | b",
+                "xor": "a ^ b",
+                "and_": "a & b",
+                "floordiv": "a // b",
+                "pow_": "a ** b",
+                "lt": "a < b",
+                "le": "a <= b",
+                "eq": "a == b",
+                "ne": "a != b",
+                "gt": "a > b",
+                "ge": "a >= b",
+                "invert": "~a",
+                "neg": "-a",
+                "pos": "+a",
+                "getitem": "a[b]",
+                "getattr": "a.b",
+                "call": "a(b, *c, d=e)",
+                "args": "*a",
+            },
+        )
+
+    def test_reverse_ops(self):
+        def f(
+            radd: 1 + a,
+            rsub: 1 - a,
+            rmul: 1 * a,
+            rmatmul: 1 @ a,
+            rtruediv: 1 / a,
+            rmod: 1 % a,
+            rlshift: 1 << a,
+            rrshift: 1 >> a,
+            ror: 1 | a,
+            rxor: 1 ^ a,
+            rand: 1 & a,
+            rfloordiv: 1 // a,
+            rpow: 1**a,
+        ):
+            pass
+
+        anno = get_annotations(f, format=Format.STRING)
+        self.assertEqual(
+            anno,
+            {
+                "radd": "1 + a",
+                "rsub": "1 - a",
+                "rmul": "1 * a",
+                "rmatmul": "1 @ a",
+                "rtruediv": "1 / a",
+                "rmod": "1 % a",
+                "rlshift": "1 << a",
+                "rrshift": "1 >> a",
+                "ror": "1 | a",
+                "rxor": "1 ^ a",
+                "rand": "1 & a",
+                "rfloordiv": "1 // a",
+                "rpow": "1 ** a",
+            },
+        )
+
+    def test_template_str(self):
+        def f(
+            x: t"{a}",
+            y: list[t"{a}"],
+            z: t"{a:b} {c!r} {d!s:t}",
+            a: t"a{b}c{d}e{f}g",
+            b: t"{a:{1}}",
+            c: t"{a | b * c}",
+            gh138558: t"{ 0}",
+        ): pass
+
+        annos = get_annotations(f, format=Format.STRING)
+        self.assertEqual(annos, {
+            "x": "t'{a}'",
+            "y": "list[t'{a}']",
+            "z": "t'{a:b} {c!r} {d!s:t}'",
+            "a": "t'a{b}c{d}e{f}g'",
+            # interpolations in the format spec are eagerly evaluated so we can't recover the source
+            "b": "t'{a:1}'",
+            "c": "t'{a | b * c}'",
+            "gh138558": "t'{ 0}'",
+        })
+
+        def g(
+            x: t"{a}",
+        ): ...
+
+        annos = get_annotations(g, format=Format.FORWARDREF)
+        templ = annos["x"]
+        # Template and Interpolation don't have __eq__ so we have to compare manually
+        self.assertIsInstance(templ, Template)
+        self.assertEqual(templ.strings, ("", ""))
+        self.assertEqual(len(templ.interpolations), 1)
+        interp = templ.interpolations[0]
+        self.assertEqual(interp.value, support.EqualToForwardRef("a", owner=g))
+        self.assertEqual(interp.expression, "a")
+        self.assertIsNone(interp.conversion)
+        self.assertEqual(interp.format_spec, "")
+
+    def test_getitem(self):
+        def f(x: undef1[str, undef2]):
+            pass
+        anno = get_annotations(f, format=Format.STRING)
+        self.assertEqual(anno, {"x": "undef1[str, undef2]"})
+
+        anno = get_annotations(f, format=Format.FORWARDREF)
+        fwdref = anno["x"]
+        self.assertIsInstance(fwdref, ForwardRef)
+        self.assertEqual(
+            fwdref.evaluate(globals={"undef1": dict, "undef2": float}), dict[str, float]
+        )
+
+    def test_slice(self):
+        def f(x: a[b:c]):
+            pass
+        anno = get_annotations(f, format=Format.STRING)
+        self.assertEqual(anno, {"x": "a[b:c]"})
+
+        def f(x: a[b:c, d:e]):
+            pass
+        anno = get_annotations(f, format=Format.STRING)
+        self.assertEqual(anno, {"x": "a[b:c, d:e]"})
+
+        obj = slice(1, 1, 1)
+        def f(x: obj):
+            pass
+        anno = get_annotations(f, format=Format.STRING)
+        self.assertEqual(anno, {"x": "obj"})
+
+    def test_literals(self):
+        def f(
+            a: 1,
+            b: 1.0,
+            c: "hello",
+            d: b"hello",
+            e: True,
+            f: None,
+            g: ...,
+            h: 1j,
+        ):
+            pass
+
+        anno = get_annotations(f, format=Format.STRING)
+        self.assertEqual(
+            anno,
+            {
+                "a": "1",
+                "b": "1.0",
+                "c": 'hello',
+                "d": "b'hello'",
+                "e": "True",
+                "f": "None",
+                "g": "...",
+                "h": "1j",
+            },
+        )
+
+    def test_displays(self):
+        # Simple case first
+        def f(x: a[[int, str], float]):
+            pass
+        anno = get_annotations(f, format=Format.STRING)
+        self.assertEqual(anno, {"x": "a[[int, str], float]"})
+
+        def g(
+            w: a[[int, str], float],
+            x: a[{int}, 3],
+            y: a[{int: str}, 4],
+            z: a[(int, str), 5],
+        ):
+            pass
+        anno = get_annotations(g, format=Format.STRING)
+        self.assertEqual(
+            anno,
+            {
+                "w": "a[[int, str], float]",
+                "x": "a[{int}, 3]",
+                "y": "a[{int: str}, 4]",
+                "z": "a[(int, str), 5]",
+            },
+        )
+
+    def test_nested_expressions(self):
+        def f(
+            nested: list[Annotated[set[int], "set of ints", 4j]],
+            set: {a + b},  # single element because order is not guaranteed
+            dict: {a + b: c + d, "key": e + g},
+            list: [a, b, c],
+            tuple: (a, b, c),
+            slice: (a[b:c], a[b:c:d], a[:c], a[b:], a[:], a[::d], a[b::d]),
+            extended_slice: a[:, :, c:d],
+            unpack1: [*a],
+            unpack2: [*a, b, c],
+        ):
+            pass
+
+        anno = get_annotations(f, format=Format.STRING)
+        self.assertEqual(
+            anno,
+            {
+                "nested": "list[Annotated[set[int], 'set of ints', 4j]]",
+                "set": "{a + b}",
+                "dict": "{a + b: c + d, 'key': e + g}",
+                "list": "[a, b, c]",
+                "tuple": "(a, b, c)",
+                "slice": "(a[b:c], a[b:c:d], a[:c], a[b:], a[:], a[::d], a[b::d])",
+                "extended_slice": "a[:, :, c:d]",
+                "unpack1": "[*a]",
+                "unpack2": "[*a, b, c]",
+            },
+        )
+
+    def test_unsupported_operations(self):
+        format_msg = "Cannot stringify annotation containing string formatting"
+
+        def f(fstring: f"{a}"):
+            pass
+
+        with self.assertRaisesRegex(TypeError, format_msg):
+            get_annotations(f, format=Format.STRING)
+
+        def f(fstring_format: f"{a:02d}"):
+            pass
+
+        with self.assertRaisesRegex(TypeError, format_msg):
+            get_annotations(f, format=Format.STRING)
+
+    def test_shenanigans(self):
+        # In cases like this we can't reconstruct the source; test that we do something
+        # halfway reasonable.
+        def f(x: x | (1).__class__, y: (1).__class__):
+            pass
+
+        self.assertEqual(
+            get_annotations(f, format=Format.STRING),
+            {"x": "x | <class 'int'>", "y": "<class 'int'>"},
+        )
+
+
+class TestGetAnnotations(unittest.TestCase):
+    def test_builtin_type(self):
+        self.assertEqual(get_annotations(int), {})
+        self.assertEqual(get_annotations(object), {})
+
+    def test_custom_metaclass(self):
+        class Meta(type):
+            pass
+
+        class C(metaclass=Meta):
+            x: int
+
+        self.assertEqual(get_annotations(C), {"x": int})
+
+    def test_missing_dunder_dict(self):
+        class NoDict(type):
+            @property
+            def __dict__(cls):
+                raise AttributeError
+
+            b: str
+
+        class C1(metaclass=NoDict):
+            a: int
+
+        self.assertEqual(get_annotations(C1), {"a": int})
+        self.assertEqual(
+            get_annotations(C1, format=Format.FORWARDREF),
+            {"a": int},
+        )
+        self.assertEqual(
+            get_annotations(C1, format=Format.STRING),
+            {"a": "int"},
+        )
+        self.assertEqual(get_annotations(NoDict), {"b": str})
+        self.assertEqual(
+            get_annotations(NoDict, format=Format.FORWARDREF),
+            {"b": str},
+        )
+        self.assertEqual(
+            get_annotations(NoDict, format=Format.STRING),
+            {"b": "str"},
+        )
+
+    def test_format(self):
+        def f1(a: int):
+            pass
+
+        def f2(a: undefined):
+            pass
+
+        self.assertEqual(
+            get_annotations(f1, format=Format.VALUE),
+            {"a": int},
+        )
+        self.assertEqual(get_annotations(f1, format=1), {"a": int})
+
+        fwd = support.EqualToForwardRef("undefined", owner=f2)
+        self.assertEqual(
+            get_annotations(f2, format=Format.FORWARDREF),
+            {"a": fwd},
+        )
+        self.assertEqual(get_annotations(f2, format=3), {"a": fwd})
+
+        self.assertEqual(
+            get_annotations(f1, format=Format.STRING),
+            {"a": "int"},
+        )
+        self.assertEqual(get_annotations(f1, format=4), {"a": "int"})
+
+        with self.assertRaises(ValueError):
+            get_annotations(f1, format=42)
+
+        with self.assertRaisesRegex(
+            ValueError,
+            r"The VALUE_WITH_FAKE_GLOBALS format is for internal use only",
+        ):
+            get_annotations(f1, format=Format.VALUE_WITH_FAKE_GLOBALS)
+
+        with self.assertRaisesRegex(
+            ValueError,
+            r"The VALUE_WITH_FAKE_GLOBALS format is for internal use only",
+        ):
+            get_annotations(f1, format=2)
+
+    def test_custom_object_with_annotations(self):
+        class C:
+            def __init__(self):
+                self.__annotations__ = {"x": int, "y": str}
+
+        self.assertEqual(get_annotations(C()), {"x": int, "y": str})
+
+    def test_custom_format_eval_str(self):
+        def foo():
+            pass
+
+        with self.assertRaises(ValueError):
+            get_annotations(foo, format=Format.FORWARDREF, eval_str=True)
+            get_annotations(foo, format=Format.STRING, eval_str=True)
+
+    def test_stock_annotations(self):
+        def foo(a: int, b: str):
+            pass
+
+        for format in (Format.VALUE, Format.FORWARDREF):
+            with self.subTest(format=format):
+                self.assertEqual(
+                    get_annotations(foo, format=format),
+                    {"a": int, "b": str},
+                )
+        self.assertEqual(
+            get_annotations(foo, format=Format.STRING),
+            {"a": "int", "b": "str"},
+        )
+
+        foo.__annotations__ = {"a": "foo", "b": "str"}
+        for format in Format:
+            if format == Format.VALUE_WITH_FAKE_GLOBALS:
+                continue
+            with self.subTest(format=format):
+                self.assertEqual(
+                    get_annotations(foo, format=format),
+                    {"a": "foo", "b": "str"},
+                )
+
+        self.assertEqual(
+            get_annotations(foo, eval_str=True, locals=locals()),
+            {"a": foo, "b": str},
+        )
+        self.assertEqual(
+            get_annotations(foo, eval_str=True, globals=locals()),
+            {"a": foo, "b": str},
+        )
+
+    def test_stock_annotations_in_module(self):
+        isa = inspect_stock_annotations
+
+        for kwargs in [
+            {},
+            {"eval_str": False},
+            {"format": Format.VALUE},
+            {"format": Format.FORWARDREF},
+            {"format": Format.VALUE, "eval_str": False},
+            {"format": Format.FORWARDREF, "eval_str": False},
+        ]:
+            with self.subTest(**kwargs):
+                self.assertEqual(get_annotations(isa, **kwargs), {"a": int, "b": str})
+                self.assertEqual(
+                    get_annotations(isa.MyClass, **kwargs),
+                    {"a": int, "b": str},
+                )
+                self.assertEqual(
+                    get_annotations(isa.function, **kwargs),
+                    {"a": int, "b": str, "return": isa.MyClass},
+                )
+                self.assertEqual(
+                    get_annotations(isa.function2, **kwargs),
+                    {"a": int, "b": "str", "c": isa.MyClass, "return": isa.MyClass},
+                )
+                self.assertEqual(
+                    get_annotations(isa.function3, **kwargs),
+                    {"a": "int", "b": "str", "c": "MyClass"},
+                )
+                self.assertEqual(
+                    get_annotations(annotationlib, **kwargs), {}
+                )  # annotations module has no annotations
+                self.assertEqual(get_annotations(isa.UnannotatedClass, **kwargs), {})
+                self.assertEqual(
+                    get_annotations(isa.unannotated_function, **kwargs),
+                    {},
+                )
+
+        for kwargs in [
+            {"eval_str": True},
+            {"format": Format.VALUE, "eval_str": True},
+        ]:
+            with self.subTest(**kwargs):
+                self.assertEqual(get_annotations(isa, **kwargs), {"a": int, "b": str})
+                self.assertEqual(
+                    get_annotations(isa.MyClass, **kwargs),
+                    {"a": int, "b": str},
+                )
+                self.assertEqual(
+                    get_annotations(isa.function, **kwargs),
+                    {"a": int, "b": str, "return": isa.MyClass},
+                )
+                self.assertEqual(
+                    get_annotations(isa.function2, **kwargs),
+                    {"a": int, "b": str, "c": isa.MyClass, "return": isa.MyClass},
+                )
+                self.assertEqual(
+                    get_annotations(isa.function3, **kwargs),
+                    {"a": int, "b": str, "c": isa.MyClass},
+                )
+                self.assertEqual(get_annotations(annotationlib, **kwargs), {})
+                self.assertEqual(get_annotations(isa.UnannotatedClass, **kwargs), {})
+                self.assertEqual(
+                    get_annotations(isa.unannotated_function, **kwargs),
+                    {},
+                )
+
+        self.assertEqual(
+            get_annotations(isa, format=Format.STRING),
+            {"a": "int", "b": "str"},
+        )
+        self.assertEqual(
+            get_annotations(isa.MyClass, format=Format.STRING),
+            {"a": "int", "b": "str"},
+        )
+        self.assertEqual(
+            get_annotations(isa.function, format=Format.STRING),
+            {"a": "int", "b": "str", "return": "MyClass"},
+        )
+        self.assertEqual(
+            get_annotations(isa.function2, format=Format.STRING),
+            {"a": "int", "b": "str", "c": "MyClass", "return": "MyClass"},
+        )
+        self.assertEqual(
+            get_annotations(isa.function3, format=Format.STRING),
+            {"a": "int", "b": "str", "c": "MyClass"},
+        )
+        self.assertEqual(
+            get_annotations(annotationlib, format=Format.STRING),
+            {},
+        )
+        self.assertEqual(
+            get_annotations(isa.UnannotatedClass, format=Format.STRING),
+            {},
+        )
+        self.assertEqual(
+            get_annotations(isa.unannotated_function, format=Format.STRING),
+            {},
+        )
+
+    def test_stock_annotations_on_wrapper(self):
+        isa = inspect_stock_annotations
+
+        wrapped = times_three(isa.function)
+        self.assertEqual(wrapped(1, "x"), isa.MyClass(3, "xxx"))
+        self.assertIsNot(wrapped.__globals__, isa.function.__globals__)
+        self.assertEqual(
+            get_annotations(wrapped),
+            {"a": int, "b": str, "return": isa.MyClass},
+        )
+        self.assertEqual(
+            get_annotations(wrapped, format=Format.FORWARDREF),
+            {"a": int, "b": str, "return": isa.MyClass},
+        )
+        self.assertEqual(
+            get_annotations(wrapped, format=Format.STRING),
+            {"a": "int", "b": "str", "return": "MyClass"},
+        )
+        self.assertEqual(
+            get_annotations(wrapped, eval_str=True),
+            {"a": int, "b": str, "return": isa.MyClass},
+        )
+        self.assertEqual(
+            get_annotations(wrapped, eval_str=False),
+            {"a": int, "b": str, "return": isa.MyClass},
+        )
+
+    def test_stringized_annotations_in_module(self):
+        isa = inspect_stringized_annotations
+        for kwargs in [
+            {},
+            {"eval_str": False},
+            {"format": Format.VALUE},
+            {"format": Format.FORWARDREF},
+            {"format": Format.STRING},
+            {"format": Format.VALUE, "eval_str": False},
+            {"format": Format.FORWARDREF, "eval_str": False},
+            {"format": Format.STRING, "eval_str": False},
+        ]:
+            with self.subTest(**kwargs):
+                self.assertEqual(
+                    get_annotations(isa, **kwargs),
+                    {"a": "int", "b": "str"},
+                )
+                self.assertEqual(
+                    get_annotations(isa.MyClass, **kwargs),
+                    {"a": "int", "b": "str"},
+                )
+                self.assertEqual(
+                    get_annotations(isa.function, **kwargs),
+                    {"a": "int", "b": "str", "return": "MyClass"},
+                )
+                self.assertEqual(
+                    get_annotations(isa.function2, **kwargs),
+                    {"a": "int", "b": "'str'", "c": "MyClass", "return": "MyClass"},
+                )
+                self.assertEqual(
+                    get_annotations(isa.function3, **kwargs),
+                    {"a": "'int'", "b": "'str'", "c": "'MyClass'"},
+                )
+                self.assertEqual(get_annotations(isa.UnannotatedClass, **kwargs), {})
+                self.assertEqual(
+                    get_annotations(isa.unannotated_function, **kwargs),
+                    {},
+                )
+
+        for kwargs in [
+            {"eval_str": True},
+            {"eval_str": True, "globals": isa.__dict__, "locals": {}},
+            {"eval_str": True, "globals": {}, "locals": isa.__dict__},
+            {"format": Format.VALUE, "eval_str": True},
+        ]:
+            with self.subTest(**kwargs):
+                self.assertEqual(get_annotations(isa, **kwargs), {"a": int, "b": str})
+                self.assertEqual(
+                    get_annotations(isa.MyClass, **kwargs),
+                    {"a": int, "b": str},
+                )
+                self.assertEqual(
+                    get_annotations(isa.function, **kwargs),
+                    {"a": int, "b": str, "return": isa.MyClass},
+                )
+                self.assertEqual(
+                    get_annotations(isa.function2, **kwargs),
+                    {"a": int, "b": "str", "c": isa.MyClass, "return": isa.MyClass},
+                )
+                self.assertEqual(
+                    get_annotations(isa.function3, **kwargs),
+                    {"a": "int", "b": "str", "c": "MyClass"},
+                )
+                self.assertEqual(get_annotations(isa.UnannotatedClass, **kwargs), {})
+                self.assertEqual(
+                    get_annotations(isa.unannotated_function, **kwargs),
+                    {},
+                )
+
+    def test_stringized_annotations_in_empty_module(self):
+        isa2 = inspect_stringized_annotations_2
+        self.assertEqual(get_annotations(isa2), {})
+        self.assertEqual(get_annotations(isa2, eval_str=True), {})
+        self.assertEqual(get_annotations(isa2, eval_str=False), {})
+
+    def test_stringized_annotations_with_star_unpack(self):
+        def f(*args: "*tuple[int, ...]"): ...
+        self.assertEqual(get_annotations(f, eval_str=True),
+                         {'args': (*tuple[int, ...],)[0]})
+        def f(*args: " *tuple[int, ...]"): ...
+        self.assertEqual(get_annotations(f, eval_str=True),
+                         {'args': (*tuple[int, ...],)[0]})
+
+
+    def test_stringized_annotations_on_wrapper(self):
+        isa = inspect_stringized_annotations
+        wrapped = times_three(isa.function)
+        self.assertEqual(wrapped(1, "x"), isa.MyClass(3, "xxx"))
+        self.assertIsNot(wrapped.__globals__, isa.function.__globals__)
+        self.assertEqual(
+            get_annotations(wrapped),
+            {"a": "int", "b": "str", "return": "MyClass"},
+        )
+        self.assertEqual(
+            get_annotations(wrapped, eval_str=True),
+            {"a": int, "b": str, "return": isa.MyClass},
+        )
+        self.assertEqual(
+            get_annotations(wrapped, eval_str=False),
+            {"a": "int", "b": "str", "return": "MyClass"},
+        )
+
+    def test_stringized_annotations_on_partial_wrapper(self):
+        isa = inspect_stringized_annotations
+
+        def times_three_str(fn: typing.Callable[[str], isa.MyClass]):
+            @functools.wraps(fn)
+            def wrapper(b: "str") -> "MyClass":
+                return fn(b * 3)
+
+            return wrapper
+
+        wrapped = times_three_str(functools.partial(isa.function, 1))
+        self.assertEqual(wrapped("x"), isa.MyClass(1, "xxx"))
+        self.assertIsNot(wrapped.__globals__, isa.function.__globals__)
+        self.assertEqual(
+            get_annotations(wrapped, eval_str=True),
+            {"b": str, "return": isa.MyClass},
+        )
+        self.assertEqual(
+            get_annotations(wrapped, eval_str=False),
+            {"b": "str", "return": "MyClass"},
+        )
+
+        # If functools is not loaded, names will be evaluated in the current
+        # module instead of being unwrapped to the original.
+        functools_mod = sys.modules["functools"]
+        del sys.modules["functools"]
+
+        self.assertEqual(
+            get_annotations(wrapped, eval_str=True),
+            {"b": str, "return": MyClass},
+        )
+        self.assertEqual(
+            get_annotations(wrapped, eval_str=False),
+            {"b": "str", "return": "MyClass"},
+        )
+
+        sys.modules["functools"] = functools_mod
+
+    def test_stringized_annotations_on_class(self):
+        isa = inspect_stringized_annotations
+        # test that local namespace lookups work
+        self.assertEqual(
+            get_annotations(isa.MyClassWithLocalAnnotations),
+            {"x": "mytype"},
+        )
+        self.assertEqual(
+            get_annotations(isa.MyClassWithLocalAnnotations, eval_str=True),
+            {"x": int},
+        )
+
+    def test_stringized_annotations_on_custom_object(self):
+        class HasAnnotations:
+            @property
+            def __annotations__(self):
+                return {"x": "int"}
+
+        ha = HasAnnotations()
+        self.assertEqual(get_annotations(ha), {"x": "int"})
+        self.assertEqual(get_annotations(ha, eval_str=True), {"x": int})
+
+    def test_stringized_annotation_permutations(self):
+        def define_class(name, has_future, has_annos, base_text, extra_names=None):
+            lines = []
+            if has_future:
+                lines.append("from __future__ import annotations")
+            lines.append(f"class {name}({base_text}):")
+            if has_annos:
+                lines.append(f"    {name}_attr: int")
+            else:
+                lines.append("    pass")
+            code = "\n".join(lines)
+            ns = support.run_code(code, extra_names=extra_names)
+            return ns[name]
+
+        def check_annotations(cls, has_future, has_annos):
+            if has_annos:
+                if has_future:
+                    anno = "int"
+                else:
+                    anno = int
+                self.assertEqual(get_annotations(cls), {f"{cls.__name__}_attr": anno})
+            else:
+                self.assertEqual(get_annotations(cls), {})
+
+        for meta_future, base_future, child_future, meta_has_annos, base_has_annos, child_has_annos in itertools.product(
+            (False, True),
+            (False, True),
+            (False, True),
+            (False, True),
+            (False, True),
+            (False, True),
+        ):
+            with self.subTest(
+                meta_future=meta_future,
+                base_future=base_future,
+                child_future=child_future,
+                meta_has_annos=meta_has_annos,
+                base_has_annos=base_has_annos,
+                child_has_annos=child_has_annos,
+            ):
+                meta = define_class(
+                    "Meta",
+                    has_future=meta_future,
+                    has_annos=meta_has_annos,
+                    base_text="type",
+                )
+                base = define_class(
+                    "Base",
+                    has_future=base_future,
+                    has_annos=base_has_annos,
+                    base_text="metaclass=Meta",
+                    extra_names={"Meta": meta},
+                )
+                child = define_class(
+                    "Child",
+                    has_future=child_future,
+                    has_annos=child_has_annos,
+                    base_text="Base",
+                    extra_names={"Base": base},
+                )
+                check_annotations(meta, meta_future, meta_has_annos)
+                check_annotations(base, base_future, base_has_annos)
+                check_annotations(child, child_future, child_has_annos)
+
+    def test_modify_annotations(self):
+        def f(x: int):
+            pass
+
+        self.assertEqual(get_annotations(f), {"x": int})
+        self.assertEqual(
+            get_annotations(f, format=Format.FORWARDREF),
+            {"x": int},
+        )
+
+        f.__annotations__["x"] = str
+        # The modification is reflected in VALUE (the default)
+        self.assertEqual(get_annotations(f), {"x": str})
+        # ... and also in FORWARDREF, which tries __annotations__ if available
+        self.assertEqual(
+            get_annotations(f, format=Format.FORWARDREF),
+            {"x": str},
+        )
+        # ... but not in STRING which always uses __annotate__
+        self.assertEqual(
+            get_annotations(f, format=Format.STRING),
+            {"x": "int"},
+        )
+
+    def test_non_dict_annotations(self):
+        class WeirdAnnotations:
+            @property
+            def __annotations__(self):
+                return "not a dict"
+
+        wa = WeirdAnnotations()
+        for format in Format:
+            if format == Format.VALUE_WITH_FAKE_GLOBALS:
+                continue
+            with (
+                self.subTest(format=format),
+                self.assertRaisesRegex(
+                    ValueError, r".*__annotations__ is neither a dict nor None"
+                ),
+            ):
+                get_annotations(wa, format=format)
+
+    def test_annotations_on_custom_object(self):
+        class HasAnnotations:
+            @property
+            def __annotations__(self):
+                return {"x": int}
+
+        ha = HasAnnotations()
+        self.assertEqual(get_annotations(ha, format=Format.VALUE), {"x": int})
+        self.assertEqual(get_annotations(ha, format=Format.FORWARDREF), {"x": int})
+
+        self.assertEqual(get_annotations(ha, format=Format.STRING), {"x": "int"})
+
+    def test_raising_annotations_on_custom_object(self):
+        class HasRaisingAnnotations:
+            @property
+            def __annotations__(self):
+                return {"x": undefined}
+
+        hra = HasRaisingAnnotations()
+
+        with self.assertRaises(NameError):
+            get_annotations(hra, format=Format.VALUE)
+
+        with self.assertRaises(NameError):
+            get_annotations(hra, format=Format.FORWARDREF)
+
+        undefined = float
+        self.assertEqual(get_annotations(hra, format=Format.VALUE), {"x": float})
+
+    def test_forwardref_prefers_annotations(self):
+        class HasBoth:
+            @property
+            def __annotations__(self):
+                return {"x": int}
+
+            @property
+            def __annotate__(self):
+                return lambda format: {"x": str}
+
+        hb = HasBoth()
+        self.assertEqual(get_annotations(hb, format=Format.VALUE), {"x": int})
+        self.assertEqual(get_annotations(hb, format=Format.FORWARDREF), {"x": int})
+        self.assertEqual(get_annotations(hb, format=Format.STRING), {"x": str})
+
+    def test_only_annotate(self):
+        def f(x: int):
+            pass
+
+        class OnlyAnnotate:
+            @property
+            def __annotate__(self):
+                return f.__annotate__
+
+        oa = OnlyAnnotate()
+        self.assertEqual(get_annotations(oa, format=Format.VALUE), {"x": int})
+        self.assertEqual(get_annotations(oa, format=Format.FORWARDREF), {"x": int})
+        self.assertEqual(
+            get_annotations(oa, format=Format.STRING),
+            {"x": "int"},
+        )
+
+    def test_non_dict_annotate(self):
+        class WeirdAnnotate:
+            def __annotate__(self, *args, **kwargs):
+                return "not a dict"
+
+        wa = WeirdAnnotate()
+        for format in Format:
+            if format == Format.VALUE_WITH_FAKE_GLOBALS:
+                continue
+            with (
+                self.subTest(format=format),
+                self.assertRaisesRegex(
+                    ValueError, r".*__annotate__ returned a non-dict"
+                ),
+            ):
+                get_annotations(wa, format=format)
+
+    def test_no_annotations(self):
+        class CustomClass:
+            pass
+
+        class MyCallable:
+            def __call__(self):
+                pass
+
+        for format in Format:
+            if format == Format.VALUE_WITH_FAKE_GLOBALS:
+                continue
+            for obj in (None, 1, object(), CustomClass()):
+                with self.subTest(format=format, obj=obj):
+                    with self.assertRaises(TypeError):
+                        get_annotations(obj, format=format)
+
+            # Callables and types with no annotations return an empty dict
+            for obj in (int, len, MyCallable()):
+                with self.subTest(format=format, obj=obj):
+                    self.assertEqual(get_annotations(obj, format=format), {})
+
+    def test_pep695_generic_class_with_future_annotations(self):
+        ann_module695 = inspect_stringized_annotations_pep695
+        A_annotations = 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 = 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 = 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 = 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(
+                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 = 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(
+                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(
+            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__),
+        )
+
+    def test_partial_evaluation(self):
+        def f(
+            x: builtins.undef,
+            y: list[int],
+            z: 1 + int,
+            a: builtins.int,
+            b: [builtins.undef, builtins.int],
+        ):
+            pass
+
+        self.assertEqual(
+            get_annotations(f, format=Format.FORWARDREF),
+            {
+                "x": support.EqualToForwardRef("builtins.undef", owner=f),
+                "y": list[int],
+                "z": support.EqualToForwardRef("1 + int", owner=f),
+                "a": int,
+                "b": [
+                    support.EqualToForwardRef("builtins.undef", owner=f),
+                    # We can't resolve this because we have to evaluate the whole annotation
+                    support.EqualToForwardRef("builtins.int", owner=f),
+                ],
+            },
+        )
+
+        self.assertEqual(
+            get_annotations(f, format=Format.STRING),
+            {
+                "x": "builtins.undef",
+                "y": "list[int]",
+                "z": "1 + int",
+                "a": "builtins.int",
+                "b": "[builtins.undef, builtins.int]",
+            },
+        )
+
+    def test_partial_evaluation_error(self):
+        def f(x: range[1]):
+            pass
+        with self.assertRaisesRegex(
+            TypeError, "type 'range' is not subscriptable"
+        ):
+            f.__annotations__
+
+        self.assertEqual(
+            get_annotations(f, format=Format.FORWARDREF),
+            {
+                "x": support.EqualToForwardRef("range[1]", owner=f),
+            },
+        )
+
+    def test_partial_evaluation_cell(self):
+        obj = object()
+
+        class RaisesAttributeError:
+            attriberr: obj.missing
+
+        anno = get_annotations(RaisesAttributeError, format=Format.FORWARDREF)
+        self.assertEqual(
+            anno,
+            {
+                "attriberr": support.EqualToForwardRef(
+                    "obj.missing", is_class=True, owner=RaisesAttributeError
+                )
+            },
+        )
+
+    def test_nonlocal_in_annotation_scope(self):
+        class Demo:
+            nonlocal sequence_b
+            x: sequence_b
+            y: sequence_b[int]
+
+        fwdrefs = get_annotations(Demo, format=Format.FORWARDREF)
+
+        self.assertIsInstance(fwdrefs["x"], ForwardRef)
+        self.assertIsInstance(fwdrefs["y"], ForwardRef)
+
+        sequence_b = list
+        self.assertIs(fwdrefs["x"].evaluate(), list)
+        self.assertEqual(fwdrefs["y"].evaluate(), list[int])
+
+    def test_raises_error_from_value(self):
+        # test that if VALUE is the only supported format, but raises an error
+        # that error is propagated from get_annotations
+        class DemoException(Exception): ...
+
+        def annotate(format, /):
+            if format == Format.VALUE:
+                raise DemoException()
+            else:
+                raise NotImplementedError(format)
+
+        def f(): ...
+
+        f.__annotate__ = annotate
+
+        for fmt in [Format.VALUE, Format.FORWARDREF, Format.STRING]:
+            with self.assertRaises(DemoException):
+                get_annotations(f, format=fmt)
+
+
+class TestCallEvaluateFunction(unittest.TestCase):
+    def test_evaluation(self):
+        def evaluate(format, exc=NotImplementedError):
+            if format > 2:
+                raise exc
+            return undefined
+
+        with self.assertRaises(NameError):
+            annotationlib.call_evaluate_function(evaluate, Format.VALUE)
+        self.assertEqual(
+            annotationlib.call_evaluate_function(evaluate, Format.FORWARDREF),
+            support.EqualToForwardRef("undefined"),
+        )
+        self.assertEqual(
+            annotationlib.call_evaluate_function(evaluate, Format.STRING),
+            "undefined",
+        )
+
+    def test_fake_global_evaluation(self):
+        # This will raise an AttributeError
+        def evaluate_union(format, exc=NotImplementedError):
+            if format == Format.VALUE_WITH_FAKE_GLOBALS:
+                # Return a ForwardRef
+                return builtins.undefined | list[int]
+            raise exc
+
+        self.assertEqual(
+            annotationlib.call_evaluate_function(evaluate_union, Format.FORWARDREF),
+            support.EqualToForwardRef("builtins.undefined | list[int]"),
+        )
+
+        # This will raise an AttributeError
+        def evaluate_intermediate(format, exc=NotImplementedError):
+            if format == Format.VALUE_WITH_FAKE_GLOBALS:
+                intermediate = builtins.undefined
+                # Return a literal
+                return intermediate is None
+            raise exc
+
+        self.assertIs(
+            annotationlib.call_evaluate_function(evaluate_intermediate, Format.FORWARDREF),
+            False,
+        )
+
+
+class TestCallAnnotateFunction(unittest.TestCase):
+    # Tests for user defined annotate functions.
+
+    # Format and NotImplementedError are provided as arguments so they exist in
+    # the fake globals namespace.
+    # This avoids non-matching conditions passing by being converted to stringifiers.
+    # See: https://github.com/python/cpython/issues/138764
+
+    def test_user_annotate_value(self):
+        def annotate(format, /):
+            if format == Format.VALUE:
+                return {"x": str}
+            else:
+                raise NotImplementedError(format)
+
+        annotations = annotationlib.call_annotate_function(
+            annotate,
+            Format.VALUE,
+        )
+
+        self.assertEqual(annotations, {"x": str})
+
+    def test_user_annotate_forwardref_supported(self):
+        # If Format.FORWARDREF is supported prefer it over Format.VALUE
+        def annotate(format, /, __Format=Format, __NotImplementedError=NotImplementedError):
+            if format == __Format.VALUE:
+                return {'x': str}
+            elif format == __Format.VALUE_WITH_FAKE_GLOBALS:
+                return {'x': int}
+            elif format == __Format.FORWARDREF:
+                return {'x': float}
+            else:
+                raise __NotImplementedError(format)
+
+        annotations = annotationlib.call_annotate_function(
+            annotate,
+            Format.FORWARDREF
+        )
+
+        self.assertEqual(annotations, {"x": float})
+
+    def test_user_annotate_forwardref_fakeglobals(self):
+        # If Format.FORWARDREF is not supported, use Format.VALUE_WITH_FAKE_GLOBALS
+        # before falling back to Format.VALUE
+        def annotate(format, /, __Format=Format, __NotImplementedError=NotImplementedError):
+            if format == __Format.VALUE:
+                return {'x': str}
+            elif format == __Format.VALUE_WITH_FAKE_GLOBALS:
+                return {'x': int}
+            else:
+                raise __NotImplementedError(format)
+
+        annotations = annotationlib.call_annotate_function(
+            annotate,
+            Format.FORWARDREF
+        )
+
+        self.assertEqual(annotations, {"x": int})
+
+    def test_user_annotate_forwardref_value_fallback(self):
+        # If Format.FORWARDREF and Format.VALUE_WITH_FAKE_GLOBALS are not supported
+        # use Format.VALUE
+        def annotate(format, /, __Format=Format, __NotImplementedError=NotImplementedError):
+            if format == __Format.VALUE:
+                return {"x": str}
+            else:
+                raise __NotImplementedError(format)
+
+        annotations = annotationlib.call_annotate_function(
+            annotate,
+            Format.FORWARDREF,
+        )
+
+        self.assertEqual(annotations, {"x": str})
+
+    def test_user_annotate_string_supported(self):
+        # If Format.STRING is supported prefer it over Format.VALUE
+        def annotate(format, /, __Format=Format, __NotImplementedError=NotImplementedError):
+            if format == __Format.VALUE:
+                return {'x': str}
+            elif format == __Format.VALUE_WITH_FAKE_GLOBALS:
+                return {'x': int}
+            elif format == __Format.STRING:
+                return {'x': "float"}
+            else:
+                raise __NotImplementedError(format)
+
+        annotations = annotationlib.call_annotate_function(
+            annotate,
+            Format.STRING,
+        )
+
+        self.assertEqual(annotations, {"x": "float"})
+
+    def test_user_annotate_string_fakeglobals(self):
+        # If Format.STRING is not supported but Format.VALUE_WITH_FAKE_GLOBALS is
+        # prefer that over Format.VALUE
+        def annotate(format, /, __Format=Format, __NotImplementedError=NotImplementedError):
+            if format == __Format.VALUE:
+                return {'x': str}
+            elif format == __Format.VALUE_WITH_FAKE_GLOBALS:
+                return {'x': int}
+            else:
+                raise __NotImplementedError(format)
+
+        annotations = annotationlib.call_annotate_function(
+            annotate,
+            Format.STRING,
+        )
+
+        self.assertEqual(annotations, {"x": "int"})
+
+    def test_user_annotate_string_value_fallback(self):
+        # If Format.STRING and Format.VALUE_WITH_FAKE_GLOBALS are not
+        # supported fall back to Format.VALUE and convert to strings
+        def annotate(format, /, __Format=Format, __NotImplementedError=NotImplementedError):
+            if format == __Format.VALUE:
+                return {"x": str}
+            else:
+                raise __NotImplementedError(format)
+
+        annotations = annotationlib.call_annotate_function(
+            annotate,
+            Format.STRING,
+        )
+
+        self.assertEqual(annotations, {"x": "str"})
+
+    def test_condition_not_stringified(self):
+        # Make sure the first condition isn't evaluated as True by being converted
+        # to a _Stringifier
+        def annotate(format, /):
+            if format == Format.FORWARDREF:
+                return {"x": str}
+            else:
+                raise NotImplementedError(format)
+
+        with self.assertRaises(NotImplementedError):
+            annotationlib.call_annotate_function(annotate, Format.STRING)
+
+    def test_unsupported_formats(self):
+        def annotate(format, /):
+            if format == Format.FORWARDREF:
+                return {"x": str}
+            else:
+                raise NotImplementedError(format)
+
+        with self.assertRaises(ValueError):
+            annotationlib.call_annotate_function(annotate, Format.VALUE_WITH_FAKE_GLOBALS)
+
+        with self.assertRaises(RuntimeError):
+            annotationlib.call_annotate_function(annotate, Format.VALUE)
+
+        with self.assertRaises(ValueError):
+            # Some non-Format value
+            annotationlib.call_annotate_function(annotate, 7)
+
+    def test_error_from_value_raised(self):
+        # Test that the error from format.VALUE is raised
+        # if all formats fail
+
+        class DemoException(Exception): ...
+
+        def annotate(format, /):
+            if format == Format.VALUE:
+                raise DemoException()
+            else:
+                raise NotImplementedError(format)
+
+        for fmt in [Format.VALUE, Format.FORWARDREF, Format.STRING]:
+            with self.assertRaises(DemoException):
+                annotationlib.call_annotate_function(annotate, format=fmt)
+
+
+class MetaclassTests(unittest.TestCase):
+    def test_annotated_meta(self):
+        class Meta(type):
+            a: int
+
+        class X(metaclass=Meta):
+            pass
+
+        class Y(metaclass=Meta):
+            b: float
+
+        self.assertEqual(get_annotations(Meta), {"a": int})
+        self.assertEqual(Meta.__annotate__(Format.VALUE), {"a": int})
+
+        self.assertEqual(get_annotations(X), {})
+        self.assertIs(X.__annotate__, None)
+
+        self.assertEqual(get_annotations(Y), {"b": float})
+        self.assertEqual(Y.__annotate__(Format.VALUE), {"b": float})
+
+    def test_unannotated_meta(self):
+        class Meta(type):
+            pass
+
+        class X(metaclass=Meta):
+            a: str
+
+        class Y(X):
+            pass
+
+        self.assertEqual(get_annotations(Meta), {})
+        self.assertIs(Meta.__annotate__, None)
+
+        self.assertEqual(get_annotations(Y), {})
+        self.assertIs(Y.__annotate__, None)
+
+        self.assertEqual(get_annotations(X), {"a": str})
+        self.assertEqual(X.__annotate__(Format.VALUE), {"a": str})
+
+    def test_ordering(self):
+        # Based on a sample by David Ellis
+        # https://discuss.python.org/t/pep-749-implementing-pep-649/54974/38
+
+        def make_classes():
+            class Meta(type):
+                a: int
+                expected_annotations = {"a": int}
+
+            class A(type, metaclass=Meta):
+                b: float
+                expected_annotations = {"b": float}
+
+            class B(metaclass=A):
+                c: str
+                expected_annotations = {"c": str}
+
+            class C(B):
+                expected_annotations = {}
+
+            class D(metaclass=Meta):
+                expected_annotations = {}
+
+            return Meta, A, B, C, D
+
+        classes = make_classes()
+        class_count = len(classes)
+        for order in itertools.permutations(range(class_count), class_count):
+            names = ", ".join(classes[i].__name__ for i in order)
+            with self.subTest(names=names):
+                classes = make_classes()  # Regenerate classes
+                for i in order:
+                    get_annotations(classes[i])
+                for c in classes:
+                    with self.subTest(c=c):
+                        self.assertEqual(get_annotations(c), c.expected_annotations)
+                        annotate_func = getattr(c, "__annotate__", None)
+                        if c.expected_annotations:
+                            self.assertEqual(
+                                annotate_func(Format.VALUE), c.expected_annotations
+                            )
+                        else:
+                            self.assertIs(annotate_func, None)
+
+
+class TestGetAnnotateFromClassNamespace(unittest.TestCase):
+    def test_with_metaclass(self):
+        class Meta(type):
+            def __new__(mcls, name, bases, ns):
+                annotate = annotationlib.get_annotate_from_class_namespace(ns)
+                expected = ns["expected_annotate"]
+                with self.subTest(name=name):
+                    if expected:
+                        self.assertIsNotNone(annotate)
+                    else:
+                        self.assertIsNone(annotate)
+                return super().__new__(mcls, name, bases, ns)
+
+        class HasAnnotations(metaclass=Meta):
+            expected_annotate = True
+            a: int
+
+        class NoAnnotations(metaclass=Meta):
+            expected_annotate = False
+
+        class CustomAnnotate(metaclass=Meta):
+            expected_annotate = True
+            def __annotate__(format):
+                return {}
+
+        code = """
+            from __future__ import annotations
+
+            class HasFutureAnnotations(metaclass=Meta):
+                expected_annotate = False
+                a: int
+        """
+        exec(textwrap.dedent(code), {"Meta": Meta})
+
+
+class TestTypeRepr(unittest.TestCase):
+    def test_type_repr(self):
+        class Nested:
+            pass
+
+        def nested():
+            pass
+
+        self.assertEqual(type_repr(int), "int")
+        self.assertEqual(type_repr(MyClass), f"{__name__}.MyClass")
+        self.assertEqual(
+            type_repr(Nested), f"{__name__}.TestTypeRepr.test_type_repr.<locals>.Nested"
+        )
+        self.assertEqual(
+            type_repr(nested), f"{__name__}.TestTypeRepr.test_type_repr.<locals>.nested"
+        )
+        self.assertEqual(type_repr(len), "len")
+        self.assertEqual(type_repr(type_repr), "annotationlib.type_repr")
+        self.assertEqual(type_repr(times_three), f"{__name__}.times_three")
+        self.assertEqual(type_repr(...), "...")
+        self.assertEqual(type_repr(None), "None")
+        self.assertEqual(type_repr(1), "1")
+        self.assertEqual(type_repr("1"), "'1'")
+        self.assertEqual(type_repr(Format.VALUE), repr(Format.VALUE))
+        self.assertEqual(type_repr(MyClass()), "my repr")
+        # gh138558 tests
+        self.assertEqual(type_repr(t'''{ 0
+            & 1
+            | 2
+        }'''), 't"""{ 0\n            & 1\n            | 2}"""')
+        self.assertEqual(
+            type_repr(Template("hi", Interpolation(42, "42"))), "t'hi{42}'"
+        )
+        self.assertEqual(
+            type_repr(Template("hi", Interpolation(42))),
+            "Template('hi', Interpolation(42, '', None, ''))",
+        )
+        self.assertEqual(
+            type_repr(Template("hi", Interpolation(42, "   "))),
+            "Template('hi', Interpolation(42, '   ', None, ''))",
+        )
+        # gh138558: perhaps in the future, we can improve this behavior:
+        self.assertEqual(type_repr(Template(Interpolation(42, "99"))), "t'{99}'")
+
+
+class TestAnnotationsToString(unittest.TestCase):
+    def test_annotations_to_string(self):
+        self.assertEqual(annotations_to_string({}), {})
+        self.assertEqual(annotations_to_string({"x": int}), {"x": "int"})
+        self.assertEqual(annotations_to_string({"x": "int"}), {"x": "int"})
+        self.assertEqual(
+            annotations_to_string({"x": int, "y": str}), {"x": "int", "y": "str"}
+        )
+
+
+class A:
+    pass
+
+TypeParamsAlias1 = int
+
+class TypeParamsSample[TypeParamsAlias1, TypeParamsAlias2]:
+    TypeParamsAlias2 = str
+
+
+class TestForwardRefClass(unittest.TestCase):
+    def test_forwardref_instance_type_error(self):
+        fr = ForwardRef("int")
+        with self.assertRaises(TypeError):
+            isinstance(42, fr)
+
+    def test_forwardref_subclass_type_error(self):
+        fr = ForwardRef("int")
+        with self.assertRaises(TypeError):
+            issubclass(int, fr)
+
+    def test_forwardref_only_str_arg(self):
+        with self.assertRaises(TypeError):
+            ForwardRef(1)  # only `str` type is allowed
+
+    def test_forward_equality(self):
+        fr = ForwardRef("int")
+        self.assertEqual(fr, ForwardRef("int"))
+        self.assertNotEqual(List["int"], List[int])
+        self.assertNotEqual(fr, ForwardRef("int", module=__name__))
+        frm = ForwardRef("int", module=__name__)
+        self.assertEqual(frm, ForwardRef("int", module=__name__))
+        self.assertNotEqual(frm, ForwardRef("int", module="__other_name__"))
+
+    def test_forward_equality_get_type_hints(self):
+        c1 = ForwardRef("C")
+        c1_gth = ForwardRef("C")
+        c2 = ForwardRef("C")
+        c2_gth = ForwardRef("C")
+
+        class C:
+            pass
+
+        def foo(a: c1_gth, b: c2_gth):
+            pass
+
+        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 = ForwardRef("int")
+        c1_gth = ForwardRef("int")
+        c2 = ForwardRef("int")
+        c2_gth = ForwardRef("int")
+
+        def foo(a: c1_gth, b: c2_gth):
+            pass
+
+        get_type_hints(foo, globals(), locals())
+
+        self.assertEqual(hash(c1), hash(c2))
+        self.assertEqual(hash(c1_gth), hash(c2_gth))
+        self.assertEqual(hash(c1), hash(c1_gth))
+
+        c3 = ForwardRef("int", module=__name__)
+        c4 = ForwardRef("int", module="__other_name__")
+
+        self.assertNotEqual(hash(c3), hash(c1))
+        self.assertNotEqual(hash(c3), hash(c1_gth))
+        self.assertNotEqual(hash(c3), hash(c4))
+        self.assertEqual(hash(c3), hash(ForwardRef("int", module=__name__)))
+
+    def test_forward_equality_and_hash_with_cells(self):
+        """Regression test for GH-143831."""
+        class A:
+            def one(_) -> C1:
+                """One cell."""
+
+            one_f = ForwardRef("C1", owner=one)
+            one_f_ga1 = get_annotations(one, format=Format.FORWARDREF)["return"]
+            one_f_ga2 = get_annotations(one, format=Format.FORWARDREF)["return"]
+            self.assertIsInstance(one_f_ga1.__cell__, types.CellType)
+            self.assertIs(one_f_ga1.__cell__, one_f_ga2.__cell__)
+
+            def two(_) -> C1 | C2:
+                """Two cells."""
+
+            two_f_ga1 = get_annotations(two, format=Format.FORWARDREF)["return"]
+            two_f_ga2 = get_annotations(two, format=Format.FORWARDREF)["return"]
+            self.assertIsNot(two_f_ga1.__cell__, two_f_ga2.__cell__)
+            self.assertIsInstance(two_f_ga1.__cell__, dict)
+            self.assertIsInstance(two_f_ga2.__cell__, dict)
+
+        type C1 = None
+        type C2 = None
+
+        self.assertNotEqual(A.one_f, A.one_f_ga1)
+        self.assertNotEqual(hash(A.one_f), hash(A.one_f_ga1))
+
+        self.assertEqual(A.one_f_ga1, A.one_f_ga2)
+        self.assertEqual(hash(A.one_f_ga1), hash(A.one_f_ga2))
+
+        self.assertEqual(A.two_f_ga1, A.two_f_ga2)
+        self.assertEqual(hash(A.two_f_ga1), hash(A.two_f_ga2))
+
+    def test_forward_equality_namespace(self):
+        def namespace1():
+            a = ForwardRef("A")
+
+            def fun(x: a):
+                pass
+
+            get_type_hints(fun, globals(), locals())
+            return a
+
+        def namespace2():
+            a = ForwardRef("A")
+
+            class A:
+                pass
+
+            def fun(x: a):
+                pass
+
+            get_type_hints(fun, globals(), locals())
+            return a
+
+        self.assertEqual(namespace1(), namespace1())
+        self.assertEqual(namespace1(), namespace2())
+
+    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')]",
+        )
+        self.assertEqual(
+            repr(List[ForwardRef("int", module="mod", is_class=True)]),
+            "typing.List[ForwardRef('int', module='mod', is_class=True)]",
+        )
+        self.assertEqual(
+            repr(List[ForwardRef("int", owner="class")]),
+            "typing.List[ForwardRef('int', owner='class')]",
+        )
+
+    def test_forward_recursion_actually(self):
+        def namespace1():
+            a = ForwardRef("A")
+            A = a
+
+            def fun(x: a):
+                pass
+
+            ret = get_type_hints(fun, globals(), locals())
+            return a
+
+        def namespace2():
+            a = ForwardRef("A")
+            A = a
+
+            def fun(x: a):
+                pass
+
+            ret = get_type_hints(fun, globals(), locals())
+            return a
+
+        r1 = namespace1()
+        r2 = namespace2()
+        self.assertIsNot(r1, r2)
+        self.assertEqual(r1, r2)
+
+    def test_syntax_error(self):
+
+        with self.assertRaises(SyntaxError):
+            typing.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_or(self):
+        X = ForwardRef("X")
+        # __or__/__ror__ itself
+        self.assertEqual(X | "x", Union[X, "x"])
+        self.assertEqual("x" | X, Union["x", X])
+
+    def test_multiple_ways_to_create(self):
+        X1 = Union["X"]
+        self.assertIsInstance(X1, ForwardRef)
+        X2 = ForwardRef("X")
+        self.assertIsInstance(X2, ForwardRef)
+        self.assertEqual(X1, X2)
+
+    def test_special_attrs(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 = ForwardRef("set[Any]")
+        self.assertNotHasAttr(fr, "__name__")
+        self.assertNotHasAttr(fr, "__qualname__")
+        self.assertEqual(fr.__module__, "annotationlib")
+        # Forward refs are currently unpicklable once they contain a code object.
+        fr.__forward_code__  # fill the cache
+        for proto in range(pickle.HIGHEST_PROTOCOL + 1):
+            with self.assertRaises(TypeError):
+                pickle.dumps(fr, proto)
+
+    def test_evaluate_string_format(self):
+        fr = ForwardRef("set[Any]")
+        self.assertEqual(fr.evaluate(format=Format.STRING), "set[Any]")
+
+    def test_evaluate_forwardref_format(self):
+        fr = ForwardRef("undef")
+        evaluated = fr.evaluate(format=Format.FORWARDREF)
+        self.assertIs(fr, evaluated)
+
+        fr = ForwardRef("set[undefined]")
+        evaluated = fr.evaluate(format=Format.FORWARDREF)
+        self.assertEqual(
+            evaluated,
+            set[support.EqualToForwardRef("undefined")],
+        )
+
+        fr = ForwardRef("a + b")
+        self.assertEqual(
+            fr.evaluate(format=Format.FORWARDREF),
+            support.EqualToForwardRef("a + b"),
+        )
+        self.assertEqual(
+            fr.evaluate(format=Format.FORWARDREF, locals={"a": 1, "b": 2}),
+            3,
+        )
+
+        fr = ForwardRef('"a" + 1')
+        self.assertEqual(
+            fr.evaluate(format=Format.FORWARDREF),
+            support.EqualToForwardRef('"a" + 1'),
+        )
+
+    def test_evaluate_notimplemented_format(self):
+        class C:
+            x: alias
+
+        fwdref = get_annotations(C, format=Format.FORWARDREF)["x"]
+
+        with self.assertRaises(NotImplementedError):
+            fwdref.evaluate(format=Format.VALUE_WITH_FAKE_GLOBALS)
+
+        with self.assertRaises(NotImplementedError):
+            # Some other unsupported value
+            fwdref.evaluate(format=7)
+
+    def test_evaluate_with_type_params(self):
+        class Gen[T]:
+            alias = int
+
+        with self.assertRaises(NameError):
+            ForwardRef("T").evaluate()
+        with self.assertRaises(NameError):
+            ForwardRef("T").evaluate(type_params=())
+        with self.assertRaises(NameError):
+            ForwardRef("T").evaluate(owner=int)
+
+        (T,) = Gen.__type_params__
+        self.assertIs(ForwardRef("T").evaluate(type_params=Gen.__type_params__), T)
+        self.assertIs(ForwardRef("T").evaluate(owner=Gen), T)
+
+        with self.assertRaises(NameError):
+            ForwardRef("alias").evaluate(type_params=Gen.__type_params__)
+        self.assertIs(ForwardRef("alias").evaluate(owner=Gen), int)
+        # If you pass custom locals, we don't look at the owner's locals
+        with self.assertRaises(NameError):
+            ForwardRef("alias").evaluate(owner=Gen, locals={})
+        # But if the name exists in the locals, it works
+        self.assertIs(
+            ForwardRef("alias").evaluate(owner=Gen, locals={"alias": str}), str
+        )
+
+    def test_evaluate_with_type_params_and_scope_conflict(self):
+        for is_class in (False, True):
+            with self.subTest(is_class=is_class):
+                fwdref1 = ForwardRef("TypeParamsAlias1", owner=TypeParamsSample, is_class=is_class)
+                fwdref2 = ForwardRef("TypeParamsAlias2", owner=TypeParamsSample, is_class=is_class)
+
+                self.assertIs(
+                    fwdref1.evaluate(),
+                    TypeParamsSample.__type_params__[0],
+                )
+                self.assertIs(
+                    fwdref2.evaluate(),
+                    TypeParamsSample.TypeParamsAlias2,
+                )
+
+    def test_fwdref_with_module(self):
+        self.assertIs(ForwardRef("Format", module="annotationlib").evaluate(), Format)
+        self.assertIs(
+            ForwardRef("Counter", module="collections").evaluate(), collections.Counter
+        )
+        self.assertEqual(
+            ForwardRef("Counter[int]", module="collections").evaluate(),
+            collections.Counter[int],
+        )
+
+        with self.assertRaises(NameError):
+            # If globals are passed explicitly, we don't look at the module dict
+            ForwardRef("Format", module="annotationlib").evaluate(globals={})
+
+    def test_fwdref_to_builtin(self):
+        self.assertIs(ForwardRef("int").evaluate(), int)
+        self.assertIs(ForwardRef("int", module="collections").evaluate(), int)
+        self.assertIs(ForwardRef("int", owner=str).evaluate(), int)
+
+        # builtins are still searched with explicit globals
+        self.assertIs(ForwardRef("int").evaluate(globals={}), int)
+
+        # explicit values in globals have precedence
+        obj = object()
+        self.assertIs(ForwardRef("int").evaluate(globals={"int": obj}), obj)
+
+    def test_fwdref_value_is_not_cached(self):
+        fr = ForwardRef("hello")
+        with self.assertRaises(NameError):
+            fr.evaluate()
+        self.assertIs(fr.evaluate(globals={"hello": str}), str)
+        with self.assertRaises(NameError):
+            fr.evaluate()
+
+    def test_fwdref_with_owner(self):
+        self.assertEqual(
+            ForwardRef("Counter[int]", owner=collections).evaluate(),
+            collections.Counter[int],
+        )
+
+    def test_name_lookup_without_eval(self):
+        # test the codepath where we look up simple names directly in the
+        # namespaces without going through eval()
+        self.assertIs(ForwardRef("int").evaluate(), int)
+        self.assertIs(ForwardRef("int").evaluate(locals={"int": str}), str)
+        self.assertIs(
+            ForwardRef("int").evaluate(locals={"int": float}, globals={"int": str}),
+            float,
+        )
+        self.assertIs(ForwardRef("int").evaluate(globals={"int": str}), str)
+        with support.swap_attr(builtins, "int", dict):
+            self.assertIs(ForwardRef("int").evaluate(), dict)
+
+        with self.assertRaises(NameError, msg="name 'doesntexist' is not defined") as exc:
+            ForwardRef("doesntexist").evaluate()
+
+        self.assertEqual(exc.exception.name, "doesntexist")
+
+    def test_evaluate_undefined_generic(self):
+        # Test the codepath where have to eval() with undefined variables.
+        class C:
+            x: alias[int, undef]
+
+        generic = get_annotations(C, format=Format.FORWARDREF)["x"].evaluate(
+            format=Format.FORWARDREF,
+            globals={"alias": dict}
+        )
+        self.assertNotIsInstance(generic, ForwardRef)
+        self.assertIs(generic.__origin__, dict)
+        self.assertEqual(len(generic.__args__), 2)
+        self.assertIs(generic.__args__[0], int)
+        self.assertIsInstance(generic.__args__[1], ForwardRef)
+
+        generic = get_annotations(C, format=Format.FORWARDREF)["x"].evaluate(
+            format=Format.FORWARDREF,
+            globals={"alias": Union},
+            locals={"alias": dict}
+        )
+        self.assertNotIsInstance(generic, ForwardRef)
+        self.assertIs(generic.__origin__, dict)
+        self.assertEqual(len(generic.__args__), 2)
+        self.assertIs(generic.__args__[0], int)
+        self.assertIsInstance(generic.__args__[1], ForwardRef)
+
+    def test_fwdref_invalid_syntax(self):
+        fr = ForwardRef("if")
+        with self.assertRaises(SyntaxError):
+            fr.evaluate()
+        fr = ForwardRef("1+")
+        with self.assertRaises(SyntaxError):
+            fr.evaluate()
+
+    def test_re_evaluate_generics(self):
+        global global_alias
+
+        # If we've already run this test before,
+        # ensure the variable is still undefined
+        if "global_alias" in globals():
+            del global_alias
+
+        class C:
+            x: global_alias[int]
+
+        # Evaluate the ForwardRef once
+        evaluated = get_annotations(C, format=Format.FORWARDREF)["x"].evaluate(
+            format=Format.FORWARDREF
+        )
+
+        # Now define the global and ensure that the ForwardRef evaluates
+        global_alias = list
+        self.assertEqual(evaluated.evaluate(), list[int])
+
+    def test_fwdref_evaluate_argument_mutation(self):
+        class C[T]:
+            nonlocal alias
+            x: alias[T]
+
+        # Mutable arguments
+        globals_ = globals()
+        globals_copy = globals_.copy()
+        locals_ = locals()
+        locals_copy = locals_.copy()
+
+        # Evaluate the ForwardRef, ensuring we use __cell__ and type params
+        get_annotations(C, format=Format.FORWARDREF)["x"].evaluate(
+            globals=globals_,
+            locals=locals_,
+            type_params=C.__type_params__,
+            format=Format.FORWARDREF,
+        )
+
+        # Check if the passed in mutable arguments equal the originals
+        self.assertEqual(globals_, globals_copy)
+        self.assertEqual(locals_, locals_copy)
+
+        alias = list
+
+    def test_fwdref_final_class(self):
+        with self.assertRaises(TypeError):
+            class C(ForwardRef):
+                pass
+
+
+class TestAnnotationLib(unittest.TestCase):
+    def test__all__(self):
+        support.check__all__(self, annotationlib)
+
+    @support.cpython_only
+    def test_lazy_imports(self):
+        import_helper.ensure_lazy_imports(
+            "annotationlib",
+            {
+                "typing",
+                "warnings",
+            },
+        )
diff --git a/Lib/test/test_argparse.py b/Lib/test/test_argparse.py
index 9b8179ef969..f48fb765bb3 100644
--- a/Lib/test/test_argparse.py
+++ b/Lib/test/test_argparse.py
@@ -3307,12 +3307,11 @@ def test_help_subparser_all_mutually_exclusive_group_members_suppressed(self):
               '''
         self.assertEqual(cmd_foo.format_help(), textwrap.dedent(expected))
 
-    def test_empty_group(self):
+    def test_usage_empty_group(self):
         # See issue 26952
-        parser = argparse.ArgumentParser()
+        parser = ErrorRaisingArgumentParser(prog='PROG')
         group = parser.add_mutually_exclusive_group()
-        with self.assertRaises(ValueError):
-            parser.parse_args(['-h'])
+        self.assertEqual(parser.format_usage(), 'usage: PROG [-h]\n')
 
     def test_nested_mutex_groups(self):
         parser = argparse.ArgumentParser(prog='PROG')
@@ -3580,25 +3579,29 @@ def get_parser(self, required):
         group.add_argument('-b', action='store_true', help='b help')
         parser.add_argument('-y', action='store_true', help='y help')
         group.add_argument('-c', action='store_true', help='c help')
+        parser.add_argument('-z', action='store_true', help='z help')
         return parser
 
     failures = ['-a -b', '-b -c', '-a -c', '-a -b -c']
     successes = [
-        ('-a', NS(a=True, b=False, c=False, x=False, y=False)),
-        ('-b', NS(a=False, b=True, c=False, x=False, y=False)),
-        ('-c', NS(a=False, b=False, c=True, x=False, y=False)),
-        ('-a -x', NS(a=True, b=False, c=False, x=True, y=False)),
-        ('-y -b', NS(a=False, b=True, c=False, x=False, y=True)),
-        ('-x -y -c', NS(a=False, b=False, c=True, x=True, y=True)),
+        ('-a', NS(a=True, b=False, c=False, x=False, y=False, z=False)),
+        ('-b', NS(a=False, b=True, c=False, x=False, y=False, z=False)),
+        ('-c', NS(a=False, b=False, c=True, x=False, y=False, z=False)),
+        ('-a -x', NS(a=True, b=False, c=False, x=True, y=False, z=False)),
+        ('-y -b', NS(a=False, b=True, c=False, x=False, y=True, z=False)),
+        ('-x -y -c', NS(a=False, b=False, c=True, x=True, y=True, z=False)),
     ]
     successes_when_not_required = [
-        ('', NS(a=False, b=False, c=False, x=False, y=False)),
-        ('-x', NS(a=False, b=False, c=False, x=True, y=False)),
-        ('-y', NS(a=False, b=False, c=False, x=False, y=True)),
+        ('', NS(a=False, b=False, c=False, x=False, y=False, z=False)),
+        ('-x', NS(a=False, b=False, c=False, x=True, y=False, z=False)),
+        ('-y', NS(a=False, b=False, c=False, x=False, y=True, z=False)),
     ]
 
-    usage_when_required = usage_when_not_required = '''\
-        usage: PROG [-h] [-x] [-a] [-b] [-y] [-c]
+    usage_when_not_required = '''\
+        usage: PROG [-h] [-x] [-a | -b | -c] [-y] [-z]
+        '''
+    usage_when_required = '''\
+        usage: PROG [-h] [-x] (-a | -b | -c) [-y] [-z]
         '''
     help = '''\
 
@@ -3609,6 +3612,7 @@ def get_parser(self, required):
           -b          b help
           -y          y help
           -c          c help
+          -z          z help
         '''
 
 
@@ -3662,23 +3666,27 @@ def get_parser(self, required):
         group.add_argument('a', nargs='?', help='a help')
         group.add_argument('-b', action='store_true', help='b help')
         group.add_argument('-c', action='store_true', help='c help')
+        parser.add_argument('-z', action='store_true', help='z help')
         return parser
 
     failures = ['X A -b', '-b -c', '-c X A']
     successes = [
-        ('X A', NS(a='A', b=False, c=False, x='X', y=False)),
-        ('X -b', NS(a=None, b=True, c=False, x='X', y=False)),
-        ('X -c', NS(a=None, b=False, c=True, x='X', y=False)),
-        ('X A -y', NS(a='A', b=False, c=False, x='X', y=True)),
-        ('X -y -b', NS(a=None, b=True, c=False, x='X', y=True)),
+        ('X A', NS(a='A', b=False, c=False, x='X', y=False, z=False)),
+        ('X -b', NS(a=None, b=True, c=False, x='X', y=False, z=False)),
+        ('X -c', NS(a=None, b=False, c=True, x='X', y=False, z=False)),
+        ('X A -y', NS(a='A', b=False, c=False, x='X', y=True, z=False)),
+        ('X -y -b', NS(a=None, b=True, c=False, x='X', y=True, z=False)),
     ]
     successes_when_not_required = [
-        ('X', NS(a=None, b=False, c=False, x='X', y=False)),
-        ('X -y', NS(a=None, b=False, c=False, x='X', y=True)),
+        ('X', NS(a=None, b=False, c=False, x='X', y=False, z=False)),
+        ('X -y', NS(a=None, b=False, c=False, x='X', y=True, z=False)),
     ]
 
-    usage_when_required = usage_when_not_required = '''\
-        usage: PROG [-h] [-y] [-b] [-c] x [a]
+    usage_when_not_required = '''\
+        usage: PROG [-h] [-y] [-z] x [-b | -c | a]
+        '''
+    usage_when_required = '''\
+        usage: PROG [-h] [-y] [-z] x (-b | -c | a)
         '''
     help = '''\
 
@@ -3691,6 +3699,7 @@ def get_parser(self, required):
           -y          y help
           -b          b help
           -c          c help
+          -z          z help
         '''
 
 
@@ -4885,6 +4894,25 @@ def test_long_mutex_groups_wrap(self):
         ''')
         self.assertEqual(parser.format_usage(), usage)
 
+    def test_mutex_groups_with_mixed_optionals_positionals_wrap(self):
+        # https://github.com/python/cpython/issues/75949
+        # Mutually exclusive groups containing both optionals and positionals
+        # should preserve pipe separators when the usage line wraps.
+        parser = argparse.ArgumentParser(prog='PROG')
+        g = parser.add_mutually_exclusive_group()
+        g.add_argument('-v', '--verbose', action='store_true')
+        g.add_argument('-q', '--quiet', action='store_true')
+        g.add_argument('-x', '--extra-long-option-name', nargs='?')
+        g.add_argument('-y', '--yet-another-long-option', nargs='?')
+        g.add_argument('positional', nargs='?')
+
+        usage = textwrap.dedent('''\
+        usage: PROG [-h]
+                    [-v | -q | -x [EXTRA_LONG_OPTION_NAME] |
+                    -y [YET_ANOTHER_LONG_OPTION] | positional]
+        ''')
+        self.assertEqual(parser.format_usage(), usage)
+
 
 class TestHelpVariableExpansion(HelpTestCase):
     """Test that variables are expanded properly in help messages"""
@@ -5300,6 +5328,7 @@ class TestHelpArgumentDefaults(HelpTestCase):
     argument_signatures = [
         Sig('--foo', help='foo help - oh and by the way, %(default)s'),
         Sig('--bar', action='store_true', help='bar help'),
+        Sig('--required', required=True, help='some help'),
         Sig('--taz', action=argparse.BooleanOptionalAction,
             help='Whether to taz it', default=True),
         Sig('--corge', action=argparse.BooleanOptionalAction,
@@ -5313,8 +5342,8 @@ class TestHelpArgumentDefaults(HelpTestCase):
          [Sig('--baz', type=int, default=42, help='baz help')]),
     ]
     usage = '''\
-        usage: PROG [-h] [--foo FOO] [--bar] [--taz | --no-taz] [--corge | --no-corge]
-                    [--quux QUUX] [--baz BAZ]
+        usage: PROG [-h] [--foo FOO] [--bar] --required REQUIRED [--taz | --no-taz]
+                    [--corge | --no-corge] [--quux QUUX] [--baz BAZ]
                     spam [badger]
         '''
     help = usage + '''\
@@ -5329,6 +5358,7 @@ class TestHelpArgumentDefaults(HelpTestCase):
           -h, --help           show this help message and exit
           --foo FOO            foo help - oh and by the way, None
           --bar                bar help (default: False)
+          --required REQUIRED  some help
           --taz, --no-taz      Whether to taz it (default: True)
           --corge, --no-corge  Whether to corge it
           --quux QUUX          Set the quux (default: 42)
@@ -7256,7 +7286,28 @@ def test_argparse_color(self):
             ),
         )
 
-    def test_argparse_color_usage(self):
+    def test_argparse_color_mutually_exclusive_group_usage(self):
+        parser = argparse.ArgumentParser(color=True, prog="PROG")
+        group = parser.add_mutually_exclusive_group()
+        group.add_argument('--foo', action='store_true', help='FOO')
+        group.add_argument('--spam', help='SPAM')
+        group.add_argument('badger', nargs='*', help='BADGER')
+
+        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
+        reset = self.theme.reset
+
+        self.assertEqual(parser.format_usage(),
+            f"{heading}usage: {reset}{prog}PROG{reset} [{short}-h{reset}] "
+            f"[{long}--foo{reset} | "
+            f"{long}--spam {label}SPAM{reset} | "
+            f"{pos}badger ...{reset}]\n")
+
+    def test_argparse_color_custom_usage(self):
         # Arrange
         parser = argparse.ArgumentParser(
             add_help=False,
diff --git a/Lib/test/test_array.py b/Lib/test/test_array.py
index 0c20e27cfda..db09e50e8f4 100644
--- a/Lib/test/test_array.py
+++ b/Lib/test/test_array.py
@@ -8,16 +8,20 @@
 from test.support import import_helper
 from test.support import os_helper
 from test.support import _2G
+from test.support import subTests
 import weakref
 import pickle
 import operator
 import struct
 import sys
+import warnings
 
 import array
 from array import _array_reconstructor as array_reconstructor
 
-sizeof_wchar = array.array('u').itemsize
+with warnings.catch_warnings():
+    warnings.simplefilter('ignore', DeprecationWarning)
+    sizeof_wchar = array.array('u').itemsize
 
 
 class ArraySubclass(array.array):
@@ -27,7 +31,7 @@ class ArraySubclassWithKwargs(array.array):
     def __init__(self, typecode, newarg=None):
         array.array.__init__(self)
 
-typecodes = 'ubBhHiIlLfdqQ'
+typecodes = 'uwbBhHiIlLfdqQ'
 
 class MiscTest(unittest.TestCase):
 
@@ -93,8 +97,17 @@ def test_empty(self):
 UTF32_LE = 20
 UTF32_BE = 21
 
+
 class ArrayReconstructorTest(unittest.TestCase):
 
+    def setUp(self):
+        self.enterContext(warnings.catch_warnings())
+        warnings.filterwarnings(
+            "ignore",
+            message="The 'u' type code is deprecated and "
+                    "will be removed in Python 3.16",
+            category=DeprecationWarning)
+
     def test_error(self):
         self.assertRaises(TypeError, array_reconstructor,
                           "", "b", 0, b"")
@@ -176,23 +189,23 @@ def test_numbers(self):
                 self.assertEqual(a, b,
                     msg="{0!r} != {1!r}; testcase={2!r}".format(a, b, testcase))
 
-    # TODO: RUSTPYTHON - requires UTF-32 encoding support in codecs and proper array reconstructor implementation
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; Add support for 'w'
     def test_unicode(self):
         teststr = "Bonne Journ\xe9e \U0002030a\U00020347"
         testcases = (
             (UTF16_LE, "UTF-16-LE"),
             (UTF16_BE, "UTF-16-BE"),
-            (UTF32_LE, "UTF-32-LE"), # TODO: RUSTPYTHON
-            (UTF32_BE, "UTF-32-BE")  # TODO: RUSTPYTHON
+            (UTF32_LE, "UTF-32-LE"),
+            (UTF32_BE, "UTF-32-BE")
         )
         for testcase in testcases:
             mformat_code, encoding = testcase
-            a = array.array('u', teststr)
-            b = array_reconstructor(
-                array.array, 'u', mformat_code, teststr.encode(encoding))
-            self.assertEqual(a, b,
-                msg="{0!r} != {1!r}; testcase={2!r}".format(a, b, testcase))
+            for c in 'uw':
+                a = array.array(c, teststr)
+                b = array_reconstructor(
+                    array.array, c, mformat_code, teststr.encode(encoding))
+                self.assertEqual(a, b,
+                    msg="{0!r} != {1!r}; testcase={2!r}".format(a, b, testcase))
 
 
 class BaseTest:
@@ -204,6 +217,14 @@ class BaseTest:
     # outside: An entry that is not in example
     # minitemsize: the minimum guaranteed itemsize
 
+    def setUp(self):
+        self.enterContext(warnings.catch_warnings())
+        warnings.filterwarnings(
+            "ignore",
+            message="The 'u' type code is deprecated and "
+                    "will be removed in Python 3.16",
+            category=DeprecationWarning)
+
     def assertEntryEqual(self, entry1, entry2):
         self.assertEqual(entry1, entry2)
 
@@ -236,7 +257,7 @@ def test_buffer_info(self):
         self.assertEqual(bi[1], len(a))
 
     def test_byteswap(self):
-        if self.typecode == 'u':
+        if self.typecode in ('u', 'w'):
             example = '\U00100100'
         else:
             example = self.example
@@ -357,8 +378,6 @@ def test_reverse_iterator(self):
         self.assertEqual(list(a), list(self.example))
         self.assertEqual(list(reversed(a)), list(iter(a))[::-1])
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_reverse_iterator_picking(self):
         orig = array.array(self.typecode, self.example)
         data = list(orig)
@@ -997,6 +1016,29 @@ def test_pop(self):
             array.array(self.typecode, self.example[3:]+self.example[:-1])
         )
 
+    def test_clear(self):
+        a = array.array(self.typecode, self.example)
+        with self.assertRaises(TypeError):
+            a.clear(42)
+        a.clear()
+        self.assertEqual(len(a), 0)
+        self.assertEqual(a.typecode, self.typecode)
+
+        a = array.array(self.typecode)
+        a.clear()
+        self.assertEqual(len(a), 0)
+        self.assertEqual(a.typecode, self.typecode)
+
+        a = array.array(self.typecode, self.example)
+        a.clear()
+        a.append(self.example[2])
+        a.append(self.example[3])
+        self.assertEqual(a, array.array(self.typecode, self.example[2:4]))
+
+        with memoryview(a):
+            with self.assertRaises(BufferError):
+                a.clear()
+
     def test_reverse(self):
         a = array.array(self.typecode, self.example)
         self.assertRaises(TypeError, a.reverse, 42)
@@ -1083,7 +1125,7 @@ def test_buffer(self):
         self.assertEqual(m.tobytes(), expected)
         self.assertRaises(BufferError, a.frombytes, a.tobytes())
         self.assertEqual(m.tobytes(), expected)
-        if self.typecode == 'u':
+        if self.typecode in ('u', 'w'):
             self.assertRaises(BufferError, a.fromunicode, a.tounicode())
             self.assertEqual(m.tobytes(), expected)
         self.assertRaises(BufferError, operator.imul, a, 2)
@@ -1138,17 +1180,19 @@ def test_sizeof_without_buffer(self):
         basesize = support.calcvobjsize('Pn2Pi')
         support.check_sizeof(self, a, basesize)
 
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; Add support for 'w'
     def test_initialize_with_unicode(self):
-        if self.typecode != 'u':
+        if self.typecode not in ('u', 'w'):
             with self.assertRaises(TypeError) as cm:
                 a = array.array(self.typecode, 'foo')
             self.assertIn("cannot use a str", str(cm.exception))
             with self.assertRaises(TypeError) as cm:
-                a = array.array(self.typecode, array.array('u', 'foo'))
+                a = array.array(self.typecode, array.array('w', 'foo'))
             self.assertIn("cannot use a unicode array", str(cm.exception))
         else:
             a = array.array(self.typecode, "foo")
             a = array.array(self.typecode, array.array('u', 'foo'))
+            a = array.array(self.typecode, array.array('w', 'foo'))
 
     @support.cpython_only
     def test_obsolete_write_lock(self):
@@ -1156,8 +1200,7 @@ def test_obsolete_write_lock(self):
         a = array.array('B', b"")
         self.assertRaises(BufferError, _testcapi.getbuffer_with_null_view, a)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_free_after_iterating(self):
         support.check_free_after_iterating(self, iter, array.array,
                                            (self.typecode,))
@@ -1177,40 +1220,255 @@ class UnicodeTest(StringTest, unittest.TestCase):
     smallerexample = '\x01\u263a\x00\ufefe'
     biggerexample = '\x01\u263a\x01\ufeff'
     outside = str('\x33')
-    minitemsize = 2
+    minitemsize = sizeof_wchar
 
     def test_unicode(self):
         self.assertRaises(TypeError, array.array, 'b', 'foo')
 
-        a = array.array('u', '\xa0\xc2\u1234')
+        a = array.array(self.typecode, '\xa0\xc2\u1234')
         a.fromunicode(' ')
         a.fromunicode('')
         a.fromunicode('')
         a.fromunicode('\x11abc\xff\u1234')
         s = a.tounicode()
         self.assertEqual(s, '\xa0\xc2\u1234 \x11abc\xff\u1234')
-        self.assertEqual(a.itemsize, sizeof_wchar)
+        self.assertEqual(a.itemsize, self.minitemsize)
 
         s = '\x00="\'a\\b\x80\xff\u0000\u0001\u1234'
-        a = array.array('u', s)
+        a = array.array(self.typecode, s)
         self.assertEqual(
             repr(a),
-            "array('u', '\\x00=\"\\'a\\\\b\\x80\xff\\x00\\x01\u1234')")
+            f"array('{self.typecode}', '\\x00=\"\\'a\\\\b\\x80\xff\\x00\\x01\u1234')")
 
         self.assertRaises(TypeError, a.fromunicode)
 
     def test_issue17223(self):
-        # this used to crash
-        if sizeof_wchar == 4:
-            # U+FFFFFFFF is an invalid code point in Unicode 6.0
-            invalid_str = b'\xff\xff\xff\xff'
-        else:
+        if self.typecode == 'u' and sizeof_wchar == 2:
             # PyUnicode_FromUnicode() cannot fail with 16-bit wchar_t
             self.skipTest("specific to 32-bit wchar_t")
-        a = array.array('u', invalid_str)
+
+        # this used to crash
+        # U+FFFFFFFF is an invalid code point in Unicode 6.0
+        invalid_str = b'\xff\xff\xff\xff'
+
+        a = array.array(self.typecode, invalid_str)
         self.assertRaises(ValueError, a.tounicode)
         self.assertRaises(ValueError, str, a)
 
+    def test_typecode_u_deprecation(self):
+        with self.assertWarns(DeprecationWarning):
+            array.array("u")
+
+    def test_empty_string_mem_leak_gh140474(self):
+        with warnings.catch_warnings():
+            warnings.simplefilter('ignore', DeprecationWarning)
+            for _ in range(1000):
+                a = array.array('u', '')
+                self.assertEqual(len(a), 0)
+                self.assertEqual(a.typecode, 'u')
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; Add support for 'w'
+    def test_add(self):
+        return super().test_add()
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; Add support for 'w'
+    def test_extend(self):
+        return super().test_extend()
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; Add support for 'w'
+    def test_iadd(self):
+        return super().test_iadd()
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; Add support for 'w'
+    def test_setiadd(self):
+        return super().test_setiadd()
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; Add support for 'w'
+    def test_setslice(self):
+        return super().test_setslice()
+
+
+class UCS4Test(UnicodeTest):
+    typecode = 'w'
+    minitemsize = 4
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; Add support for 'w'
+    def test_buffer(self):
+        return super().test_buffer()
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; Add support for 'w'
+    def test_buffer_info(self):
+        return super().test_buffer_info()
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; Add support for 'w'
+    def test_byteswap(self):
+        return super().test_byteswap()
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; Add support for 'w'
+    def test_clear(self):
+        return super().test_clear()
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; Add support for 'w'
+    def test_cmp(self):
+        return super().test_cmp()
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; Add support for 'w'
+    def test_constructor(self):
+        return super().test_constructor()
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; Add support for 'w'
+    def test_constructor_with_iterable_argument(self):
+        return super().test_constructor_with_iterable_argument()
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; Add support for 'w'
+    def test_copy(self):
+        return super().test_copy()
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; Add support for 'w'
+    def test_count(self):
+        return super().test_count()
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; Add support for 'w'
+    def test_coveritertraverse(self):
+        return super().test_coveritertraverse()
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; Add support for 'w'
+    def test_deepcopy(self):
+        return super().test_deepcopy()
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; Add support for 'w'
+    def test_delitem(self):
+        return super().test_delitem()
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; Add support for 'w'
+    def test_exhausted_iterator(self):
+        return super().test_exhausted_iterator()
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; Add support for 'w'
+    def test_exhausted_reverse_iterator(self):
+        return super().test_exhausted_reverse_iterator()
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; Add support for 'w'
+    def test_extended_getslice(self):
+        return super().test_extended_getslice()
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; Add support for 'w'
+    def test_extended_set_del_slice(self):
+        return super().test_extended_set_del_slice()
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; Add support for 'w'
+    def test_filewrite(self):
+        return super().test_filewrite()
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; Add support for 'w'
+    def test_fromarray(self):
+        return super().test_fromarray()
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; Add support for 'w'
+    def test_fromfile_ioerror(self):
+        return super().test_fromfile_ioerror()
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; Add support for 'w'
+    def test_getitem(self):
+        return super().test_getitem()
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; Add support for 'w'
+    def test_getslice(self):
+        return super().test_getslice()
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; Add support for 'w'
+    def test_imul(self):
+        return super().test_imul()
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; Add support for 'w'
+    def test_index(self):
+        return super().test_index()
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; Add support for 'w'
+    def test_insert(self):
+        return super().test_insert()
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; Add support for 'w'
+    def test_issue17223(self):
+        return super().test_issue17223()
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; Add support for 'w'
+    def test_iterator_pickle(self):
+        return super().test_iterator_pickle()
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; Add support for 'w'
+    def test_len(self):
+        return super().test_len()
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; Add support for 'w'
+    def test_mul(self):
+        return super().test_mul()
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; Add support for 'w'
+    def test_pickle(self):
+        return super().test_pickle()
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; Add support for 'w'
+    def test_pickle_for_empty_array(self):
+        return super().test_pickle_for_empty_array()
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; Add support for 'w'
+    def test_pop(self):
+        return super().test_pop()
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; Add support for 'w'
+    def test_reduce_ex(self):
+        return super().test_reduce_ex()
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; Add support for 'w'
+    def test_remove(self):
+        return super().test_remove()
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; Add support for 'w'
+    def test_repr(self):
+        return super().test_repr()
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; Add support for 'w'
+    def test_reverse(self):
+        return super().test_reverse()
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; Add support for 'w'
+    def test_reverse_iterator(self):
+        return super().test_reverse_iterator()
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; Add support for 'w'
+    def test_reverse_iterator_picking(self):
+        return super().test_reverse_iterator_picking()
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; Add support for 'w'
+    def test_setitem(self):
+        return super().test_setitem()
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; Add support for 'w'
+    def test_str(self):
+        return super().test_str()
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; Add support for 'w'
+    def test_tofrombytes(self):
+        return super().test_tofrombytes()
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; Add support for 'w'
+    def test_tofromfile(self):
+        return super().test_tofromfile()
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; Add support for 'w'
+    def test_tofromlist(self):
+        return super().test_tofromlist()
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; Add support for 'w'
+    def test_unicode(self):
+        return super().test_unicode()
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; Add support for 'w'
+    def test_weakref(self):
+        return super().test_weakref()
+
+
 class NumberTest(BaseTest):
 
     def test_extslice(self):
@@ -1442,8 +1700,8 @@ def test_byteswap(self):
             if a.itemsize==1:
                 self.assertEqual(a, b)
             else:
-                # On alphas treating the byte swapped bit patters as
-                # floats/doubles results in floating point exceptions
+                # On alphas treating the byte swapped bit patterns as
+                # floats/doubles results in floating-point exceptions
                 # => compare the 8bit string values instead
                 self.assertNotEqual(a.tobytes(), b.tobytes())
             b.byteswap()
@@ -1615,5 +1873,55 @@ def test_tolist(self, size):
         self.assertEqual(ls[:8], list(example[:8]))
         self.assertEqual(ls[-8:], list(example[-8:]))
 
+    def test_gh_128961(self):
+        a = array.array('i')
+        it = iter(a)
+        list(it)
+        it.__setstate__(0)
+        self.assertRaises(StopIteration, next, it)
+
+    # Tests for NULL pointer dereference in array.__setitem__
+    # when the index conversion mutates the array.
+    # See: https://github.com/python/cpython/issues/142555.
+
+    @unittest.skip("TODO: RUSTPYTHON; Hangs")
+    @subTests("dtype", ["b", "B", "h", "H", "i", "l", "q", "I", "L", "Q"])
+    def test_setitem_use_after_clear_with_int_data(self, dtype):
+        victim = array.array(dtype, list(range(64)))
+
+        class Index:
+            def __index__(self):
+                victim.clear()
+                return 0
+
+        self.assertRaises(IndexError, victim.__setitem__, 1, Index())
+        self.assertEqual(len(victim), 0)
+
+    @unittest.skip("TODO: RUSTPYTHON; Hangs")
+    def test_setitem_use_after_shrink_with_int_data(self):
+        victim = array.array('b', [1, 2, 3])
+
+        class Index:
+            def __index__(self):
+                victim.pop()
+                victim.pop()
+                return 0
+
+        self.assertRaises(IndexError, victim.__setitem__, 1, Index())
+
+    @unittest.skip("TODO: RUSTPYTHON; Hangs")
+    @subTests("dtype", ["f", "d"])
+    def test_setitem_use_after_clear_with_float_data(self, dtype):
+        victim = array.array(dtype, [1.0, 2.0, 3.0])
+
+        class Float:
+            def __float__(self):
+                victim.clear()
+                return 0.0
+
+        self.assertRaises(IndexError, victim.__setitem__, 1, Float())
+        self.assertEqual(len(victim), 0)
+
+
 if __name__ == "__main__":
     unittest.main()
diff --git a/Lib/test/test_ast/data/ast_repr.txt b/Lib/test/test_ast/data/ast_repr.txt
new file mode 100644
index 00000000000..1c1985519cd
--- /dev/null
+++ b/Lib/test/test_ast/data/ast_repr.txt
@@ -0,0 +1,214 @@
+Module(body=[Expr(value=Constant(value='module docstring', kind=None))], type_ignores=[])
+Module(body=[FunctionDef(name='f', args=arguments(posonlyargs=[], args=[], vararg=None, kwonlyargs=[], kw_defaults=[], kwarg=None, defaults=[]), body=[Pass()], decorator_list=[], returns=None, type_comment=None, type_params=[])], type_ignores=[])
+Module(body=[FunctionDef(name='f', args=arguments(posonlyargs=[], args=[], vararg=None, kwonlyargs=[], kw_defaults=[], kwarg=None, defaults=[]), body=[Expr(value=Constant(...))], decorator_list=[], returns=None, type_comment=None, type_params=[])], type_ignores=[])
+Module(body=[FunctionDef(name='f', args=arguments(posonlyargs=[], args=[arg(...)], vararg=None, kwonlyargs=[], kw_defaults=[], kwarg=None, defaults=[]), body=[Pass()], decorator_list=[], returns=None, type_comment=None, type_params=[])], type_ignores=[])
+Module(body=[FunctionDef(name='f', args=arguments(posonlyargs=[], args=[arg(...)], vararg=None, kwonlyargs=[], kw_defaults=[], kwarg=None, defaults=[Constant(...)]), body=[Pass()], decorator_list=[], returns=None, type_comment=None, type_params=[])], type_ignores=[])
+Module(body=[FunctionDef(name='f', args=arguments(posonlyargs=[], args=[], vararg=arg(...), kwonlyargs=[], kw_defaults=[], kwarg=None, defaults=[]), body=[Pass()], decorator_list=[], returns=None, type_comment=None, type_params=[])], type_ignores=[])
+Module(body=[FunctionDef(name='f', args=arguments(posonlyargs=[], args=[], vararg=arg(...), kwonlyargs=[], kw_defaults=[], kwarg=None, defaults=[]), body=[Pass()], decorator_list=[], returns=None, type_comment=None, type_params=[])], type_ignores=[])
+Module(body=[FunctionDef(name='f', args=arguments(posonlyargs=[], args=[], vararg=arg(...), kwonlyargs=[], kw_defaults=[], kwarg=None, defaults=[]), body=[Pass()], decorator_list=[], returns=None, type_comment=None, type_params=[])], type_ignores=[])
+Module(body=[FunctionDef(name='f', args=arguments(posonlyargs=[], args=[], vararg=arg(...), kwonlyargs=[], kw_defaults=[], kwarg=None, defaults=[]), body=[Pass()], decorator_list=[], returns=None, type_comment=None, type_params=[])], type_ignores=[])
+Module(body=[FunctionDef(name='f', args=arguments(posonlyargs=[], args=[], vararg=None, kwonlyargs=[], kw_defaults=[], kwarg=arg(...), defaults=[]), body=[Pass()], decorator_list=[], returns=None, type_comment=None, type_params=[])], type_ignores=[])
+Module(body=[FunctionDef(name='f', args=arguments(posonlyargs=[], args=[arg(...), ..., arg(...)], vararg=arg(...), kwonlyargs=[arg(...)], kw_defaults=[Constant(...)], kwarg=arg(...), defaults=[Constant(...), ..., Dict(...)]), body=[Expr(value=Constant(...))], decorator_list=[], returns=None, type_comment=None, type_params=[])], type_ignores=[])
+Module(body=[FunctionDef(name='f', args=arguments(posonlyargs=[], args=[], vararg=None, kwonlyargs=[], kw_defaults=[], kwarg=None, defaults=[]), body=[Pass()], decorator_list=[], returns=Subscript(value=Name(...), slice=Tuple(...), ctx=Load(...)), type_comment=None, type_params=[])], type_ignores=[])
+Module(body=[FunctionDef(name='f', args=arguments(posonlyargs=[], args=[], vararg=None, kwonlyargs=[], kw_defaults=[], kwarg=None, defaults=[]), body=[Pass()], decorator_list=[], returns=Subscript(value=Name(...), slice=Tuple(...), ctx=Load(...)), type_comment=None, type_params=[])], type_ignores=[])
+Module(body=[FunctionDef(name='f', args=arguments(posonlyargs=[], args=[], vararg=None, kwonlyargs=[], kw_defaults=[], kwarg=None, defaults=[]), body=[Pass()], decorator_list=[], returns=Subscript(value=Name(...), slice=Tuple(...), ctx=Load(...)), type_comment=None, type_params=[])], type_ignores=[])
+Module(body=[ClassDef(name='C', bases=[], keywords=[], body=[Pass()], decorator_list=[], type_params=[])], type_ignores=[])
+Module(body=[ClassDef(name='C', bases=[], keywords=[], body=[Expr(value=Constant(...))], decorator_list=[], type_params=[])], type_ignores=[])
+Module(body=[ClassDef(name='C', bases=[Name(id='object', ctx=Load(...))], keywords=[], body=[Pass()], decorator_list=[], type_params=[])], type_ignores=[])
+Module(body=[ClassDef(name='C', bases=[Name(id='A', ctx=Load(...)), Name(id='B', ctx=Load(...))], keywords=[], body=[Pass()], decorator_list=[], type_params=[])], type_ignores=[])
+Module(body=[FunctionDef(name='f', args=arguments(posonlyargs=[], args=[], vararg=None, kwonlyargs=[], kw_defaults=[], kwarg=None, defaults=[]), body=[Return(value=Constant(...))], decorator_list=[], returns=None, type_comment=None, type_params=[])], type_ignores=[])
+Module(body=[FunctionDef(name='f', args=arguments(posonlyargs=[], args=[], vararg=None, kwonlyargs=[], kw_defaults=[], kwarg=None, defaults=[]), body=[Return(value=None)], decorator_list=[], returns=None, type_comment=None, type_params=[])], type_ignores=[])
+Module(body=[Delete(targets=[Name(id='v', ctx=Del(...))])], type_ignores=[])
+Module(body=[Assign(targets=[Name(id='v', ctx=Store(...))], value=Constant(value=1, kind=None), type_comment=None)], type_ignores=[])
+Module(body=[Assign(targets=[Tuple(elts=[Name(...), Name(...)], ctx=Store(...))], value=Name(id='c', ctx=Load(...)), type_comment=None)], type_ignores=[])
+Module(body=[Assign(targets=[Tuple(elts=[Name(...), Name(...)], ctx=Store(...))], value=Name(id='c', ctx=Load(...)), type_comment=None)], type_ignores=[])
+Module(body=[Assign(targets=[List(elts=[Name(...), Name(...)], ctx=Store(...))], value=Name(id='c', ctx=Load(...)), type_comment=None)], type_ignores=[])
+Module(body=[Assign(targets=[Subscript(value=Name(...), slice=Name(...), ctx=Store(...))], value=Name(id='c', ctx=Load(...)), type_comment=None)], type_ignores=[])
+Module(body=[AnnAssign(target=Name(id='x', ctx=Store(...)), annotation=Subscript(value=Name(...), slice=Tuple(...), ctx=Load(...)), value=None, simple=1)], type_ignores=[])
+Module(body=[AnnAssign(target=Name(id='x', ctx=Store(...)), annotation=Subscript(value=Name(...), slice=Tuple(...), ctx=Load(...)), value=None, simple=1)], type_ignores=[])
+Module(body=[AnnAssign(target=Name(id='x', ctx=Store(...)), annotation=Subscript(value=Name(...), slice=Tuple(...), ctx=Load(...)), value=None, simple=1)], type_ignores=[])
+Module(body=[AugAssign(target=Name(id='v', ctx=Store(...)), op=Add(), value=Constant(value=1, kind=None))], type_ignores=[])
+Module(body=[AugAssign(target=Name(id='v', ctx=Store(...)), op=Sub(), value=Constant(value=1, kind=None))], type_ignores=[])
+Module(body=[AugAssign(target=Name(id='v', ctx=Store(...)), op=Mult(), value=Constant(value=1, kind=None))], type_ignores=[])
+Module(body=[AugAssign(target=Name(id='v', ctx=Store(...)), op=MatMult(), value=Constant(value=1, kind=None))], type_ignores=[])
+Module(body=[AugAssign(target=Name(id='v', ctx=Store(...)), op=Div(), value=Constant(value=1, kind=None))], type_ignores=[])
+Module(body=[AugAssign(target=Name(id='v', ctx=Store(...)), op=Mod(), value=Constant(value=1, kind=None))], type_ignores=[])
+Module(body=[AugAssign(target=Name(id='v', ctx=Store(...)), op=Pow(), value=Constant(value=1, kind=None))], type_ignores=[])
+Module(body=[AugAssign(target=Name(id='v', ctx=Store(...)), op=LShift(), value=Constant(value=1, kind=None))], type_ignores=[])
+Module(body=[AugAssign(target=Name(id='v', ctx=Store(...)), op=RShift(), value=Constant(value=1, kind=None))], type_ignores=[])
+Module(body=[AugAssign(target=Name(id='v', ctx=Store(...)), op=BitOr(), value=Constant(value=1, kind=None))], type_ignores=[])
+Module(body=[AugAssign(target=Name(id='v', ctx=Store(...)), op=BitXor(), value=Constant(value=1, kind=None))], type_ignores=[])
+Module(body=[AugAssign(target=Name(id='v', ctx=Store(...)), op=BitAnd(), value=Constant(value=1, kind=None))], type_ignores=[])
+Module(body=[AugAssign(target=Name(id='v', ctx=Store(...)), op=FloorDiv(), value=Constant(value=1, kind=None))], type_ignores=[])
+Module(body=[For(target=Name(id='v', ctx=Store(...)), iter=Name(id='v', ctx=Load(...)), body=[Pass()], orelse=[], type_comment=None)], type_ignores=[])
+Module(body=[For(target=Name(id='v', ctx=Store(...)), iter=Name(id='v', ctx=Load(...)), body=[Pass()], orelse=[Pass()], type_comment=None)], type_ignores=[])
+Module(body=[While(test=Name(id='v', ctx=Load(...)), body=[Pass()], orelse=[])], type_ignores=[])
+Module(body=[While(test=Name(id='v', ctx=Load(...)), body=[Pass()], orelse=[Pass()])], type_ignores=[])
+Module(body=[If(test=Name(id='v', ctx=Load(...)), body=[Pass()], orelse=[])], type_ignores=[])
+Module(body=[If(test=Name(id='a', ctx=Load(...)), body=[Pass()], orelse=[If(test=Name(...), body=[Pass(...)], orelse=[])])], type_ignores=[])
+Module(body=[If(test=Name(id='a', ctx=Load(...)), body=[Pass()], orelse=[Pass()])], type_ignores=[])
+Module(body=[If(test=Name(id='a', ctx=Load(...)), body=[Pass()], orelse=[If(test=Name(...), body=[Pass(...)], orelse=[Pass(...)])])], type_ignores=[])
+Module(body=[If(test=Name(id='a', ctx=Load(...)), body=[Pass()], orelse=[If(test=Name(...), body=[Pass(...)], orelse=[If(...)])])], type_ignores=[])
+Module(body=[With(items=[withitem(context_expr=Name(...), optional_vars=None)], body=[Pass()], type_comment=None)], type_ignores=[])
+Module(body=[With(items=[withitem(context_expr=Name(...), optional_vars=None), withitem(context_expr=Name(...), optional_vars=None)], body=[Pass()], type_comment=None)], type_ignores=[])
+Module(body=[With(items=[withitem(context_expr=Name(...), optional_vars=Name(...))], body=[Pass()], type_comment=None)], type_ignores=[])
+Module(body=[With(items=[withitem(context_expr=Name(...), optional_vars=Name(...)), withitem(context_expr=Name(...), optional_vars=Name(...))], body=[Pass()], type_comment=None)], type_ignores=[])
+Module(body=[With(items=[withitem(context_expr=Name(...), optional_vars=Name(...))], body=[Pass()], type_comment=None)], type_ignores=[])
+Module(body=[With(items=[withitem(context_expr=Name(...), optional_vars=None), withitem(context_expr=Name(...), optional_vars=None)], body=[Pass()], type_comment=None)], type_ignores=[])
+Module(body=[Raise(exc=None, cause=None)], type_ignores=[])
+Module(body=[Raise(exc=Call(func=Name(...), args=[Constant(...)], keywords=[]), cause=None)], type_ignores=[])
+Module(body=[Raise(exc=Name(id='Exception', ctx=Load(...)), cause=None)], type_ignores=[])
+Module(body=[Raise(exc=Call(func=Name(...), args=[Constant(...)], keywords=[]), cause=Constant(value=None, kind=None))], type_ignores=[])
+Module(body=[Try(body=[Pass()], handlers=[ExceptHandler(type=Name(...), name=None, body=[Pass(...)])], orelse=[], finalbody=[])], type_ignores=[])
+Module(body=[Try(body=[Pass()], handlers=[ExceptHandler(type=Name(...), name='exc', body=[Pass(...)])], orelse=[], finalbody=[])], type_ignores=[])
+Module(body=[Try(body=[Pass()], handlers=[], orelse=[], finalbody=[Pass()])], type_ignores=[])
+Module(body=[TryStar(body=[Pass()], handlers=[ExceptHandler(type=Name(...), name=None, body=[Pass(...)])], orelse=[], finalbody=[])], type_ignores=[])
+Module(body=[TryStar(body=[Pass()], handlers=[ExceptHandler(type=Name(...), name='exc', body=[Pass(...)])], orelse=[], finalbody=[])], type_ignores=[])
+Module(body=[Try(body=[Pass()], handlers=[ExceptHandler(type=Name(...), name=None, body=[Pass(...)])], orelse=[Pass()], finalbody=[Pass()])], type_ignores=[])
+Module(body=[Try(body=[Pass()], handlers=[ExceptHandler(type=Name(...), name='exc', body=[Pass(...)])], orelse=[Pass()], finalbody=[Pass()])], type_ignores=[])
+Module(body=[TryStar(body=[Pass()], handlers=[ExceptHandler(type=Name(...), name='exc', body=[Pass(...)])], orelse=[Pass()], finalbody=[Pass()])], type_ignores=[])
+Module(body=[Assert(test=Name(id='v', ctx=Load(...)), msg=None)], type_ignores=[])
+Module(body=[Assert(test=Name(id='v', ctx=Load(...)), msg=Constant(value='message', kind=None))], type_ignores=[])
+Module(body=[Import(names=[alias(name='sys', asname=None)])], type_ignores=[])
+Module(body=[Import(names=[alias(name='foo', asname='bar')])], type_ignores=[])
+Module(body=[ImportFrom(module='sys', names=[alias(name='x', asname='y')], level=0)], type_ignores=[])
+Module(body=[ImportFrom(module='sys', names=[alias(name='v', asname=None)], level=0)], type_ignores=[])
+Module(body=[Global(names=['v'])], type_ignores=[])
+Module(body=[Expr(value=Constant(value=1, kind=None))], type_ignores=[])
+Module(body=[Pass()], type_ignores=[])
+Module(body=[For(target=Name(id='v', ctx=Store(...)), iter=Name(id='v', ctx=Load(...)), body=[Break()], orelse=[], type_comment=None)], type_ignores=[])
+Module(body=[For(target=Name(id='v', ctx=Store(...)), iter=Name(id='v', ctx=Load(...)), body=[Continue()], orelse=[], type_comment=None)], type_ignores=[])
+Module(body=[For(target=Tuple(elts=[Name(...), Name(...)], ctx=Store(...)), iter=Name(id='c', ctx=Load(...)), body=[Pass()], orelse=[], type_comment=None)], type_ignores=[])
+Module(body=[For(target=Tuple(elts=[Name(...), Name(...)], ctx=Store(...)), iter=Name(id='c', ctx=Load(...)), body=[Pass()], orelse=[], type_comment=None)], type_ignores=[])
+Module(body=[For(target=List(elts=[Name(...), Name(...)], ctx=Store(...)), iter=Name(id='c', ctx=Load(...)), body=[Pass()], orelse=[], type_comment=None)], type_ignores=[])
+Module(body=[Expr(value=GeneratorExp(elt=Tuple(...), generators=[comprehension(...)]))], type_ignores=[])
+Module(body=[Expr(value=DictComp(key=Name(...), value=Name(...), generators=[comprehension(...), comprehension(...)]))], type_ignores=[])
+Module(body=[Expr(value=DictComp(key=Name(...), value=Name(...), generators=[comprehension(...)]))], type_ignores=[])
+Module(body=[Expr(value=SetComp(elt=Name(...), generators=[comprehension(...)]))], type_ignores=[])
+Module(body=[Expr(value=SetComp(elt=Name(...), generators=[comprehension(...)]))], type_ignores=[])
+Module(body=[AsyncFunctionDef(name='f', args=arguments(posonlyargs=[], args=[], vararg=None, kwonlyargs=[], kw_defaults=[], kwarg=None, defaults=[]), body=[Expr(value=Constant(...)), Expr(value=Await(...))], decorator_list=[], returns=None, type_comment=None, type_params=[])], type_ignores=[])
+Module(body=[AsyncFunctionDef(name='f', args=arguments(posonlyargs=[], args=[], vararg=None, kwonlyargs=[], kw_defaults=[], kwarg=None, defaults=[]), body=[AsyncFor(target=Name(...), iter=Name(...), body=[Expr(...)], orelse=[Expr(...)], type_comment=None)], decorator_list=[], returns=None, type_comment=None, type_params=[])], type_ignores=[])
+Module(body=[AsyncFunctionDef(name='f', args=arguments(posonlyargs=[], args=[], vararg=None, kwonlyargs=[], kw_defaults=[], kwarg=None, defaults=[]), body=[AsyncWith(items=[withitem(...)], body=[Expr(...)], type_comment=None)], decorator_list=[], returns=None, type_comment=None, type_params=[])], type_ignores=[])
+Module(body=[Expr(value=Dict(keys=[None, Constant(...)], values=[Dict(...), Constant(...)]))], type_ignores=[])
+Module(body=[Expr(value=Set(elts=[Starred(...), Constant(...)]))], type_ignores=[])
+Module(body=[FunctionDef(name='f', args=arguments(posonlyargs=[], args=[], vararg=None, kwonlyargs=[], kw_defaults=[], kwarg=None, defaults=[]), body=[Expr(value=Yield(...))], decorator_list=[], returns=None, type_comment=None, type_params=[])], type_ignores=[])
+Module(body=[FunctionDef(name='f', args=arguments(posonlyargs=[], args=[], vararg=None, kwonlyargs=[], kw_defaults=[], kwarg=None, defaults=[]), body=[Expr(value=YieldFrom(...))], decorator_list=[], returns=None, type_comment=None, type_params=[])], type_ignores=[])
+Module(body=[AsyncFunctionDef(name='f', args=arguments(posonlyargs=[], args=[], vararg=None, kwonlyargs=[], kw_defaults=[], kwarg=None, defaults=[]), body=[Expr(value=ListComp(...))], decorator_list=[], returns=None, type_comment=None, type_params=[])], type_ignores=[])
+Module(body=[FunctionDef(name='f', args=arguments(posonlyargs=[], args=[], vararg=None, kwonlyargs=[], kw_defaults=[], kwarg=None, defaults=[]), body=[Pass()], decorator_list=[Name(id='deco1', ctx=Load(...)), ..., Call(func=Name(...), args=[Constant(...)], keywords=[])], returns=None, type_comment=None, type_params=[])], type_ignores=[])
+Module(body=[AsyncFunctionDef(name='f', args=arguments(posonlyargs=[], args=[], vararg=None, kwonlyargs=[], kw_defaults=[], kwarg=None, defaults=[]), body=[Pass()], decorator_list=[Name(id='deco1', ctx=Load(...)), ..., Call(func=Name(...), args=[Constant(...)], keywords=[])], returns=None, type_comment=None, type_params=[])], type_ignores=[])
+Module(body=[ClassDef(name='C', bases=[], keywords=[], body=[Pass()], decorator_list=[Name(id='deco1', ctx=Load(...)), ..., Call(func=Name(...), args=[Constant(...)], keywords=[])], type_params=[])], type_ignores=[])
+Module(body=[FunctionDef(name='f', args=arguments(posonlyargs=[], args=[], vararg=None, kwonlyargs=[], kw_defaults=[], kwarg=None, defaults=[]), body=[Pass()], decorator_list=[Call(func=Name(...), args=[GeneratorExp(...)], keywords=[])], returns=None, type_comment=None, type_params=[])], type_ignores=[])
+Module(body=[FunctionDef(name='f', args=arguments(posonlyargs=[], args=[], vararg=None, kwonlyargs=[], kw_defaults=[], kwarg=None, defaults=[]), body=[Pass()], decorator_list=[Attribute(value=Attribute(...), attr='c', ctx=Load(...))], returns=None, type_comment=None, type_params=[])], type_ignores=[])
+Module(body=[Expr(value=NamedExpr(target=Name(...), value=Constant(...)))], type_ignores=[])
+Module(body=[If(test=NamedExpr(target=Name(...), value=Call(...)), body=[Pass()], orelse=[])], type_ignores=[])
+Module(body=[While(test=NamedExpr(target=Name(...), value=Call(...)), body=[Pass()], orelse=[])], type_ignores=[])
+Module(body=[FunctionDef(name='f', args=arguments(posonlyargs=[arg(...)], args=[], vararg=None, kwonlyargs=[], kw_defaults=[], kwarg=None, defaults=[]), body=[Pass()], decorator_list=[], returns=None, type_comment=None, type_params=[])], type_ignores=[])
+Module(body=[FunctionDef(name='f', args=arguments(posonlyargs=[arg(...)], args=[arg(...), ..., arg(...)], vararg=None, kwonlyargs=[], kw_defaults=[], kwarg=None, defaults=[]), body=[Pass()], decorator_list=[], returns=None, type_comment=None, type_params=[])], type_ignores=[])
+Module(body=[FunctionDef(name='f', args=arguments(posonlyargs=[arg(...)], args=[arg(...)], vararg=None, kwonlyargs=[arg(...), arg(...)], kw_defaults=[None, None], kwarg=None, defaults=[]), body=[Pass()], decorator_list=[], returns=None, type_comment=None, type_params=[])], type_ignores=[])
+Module(body=[FunctionDef(name='f', args=arguments(posonlyargs=[arg(...)], args=[arg(...)], vararg=None, kwonlyargs=[arg(...), arg(...)], kw_defaults=[None, None], kwarg=arg(...), defaults=[]), body=[Pass()], decorator_list=[], returns=None, type_comment=None, type_params=[])], type_ignores=[])
+Module(body=[FunctionDef(name='f', args=arguments(posonlyargs=[arg(...)], args=[], vararg=None, kwonlyargs=[], kw_defaults=[], kwarg=None, defaults=[Constant(...)]), body=[Pass()], decorator_list=[], returns=None, type_comment=None, type_params=[])], type_ignores=[])
+Module(body=[FunctionDef(name='f', args=arguments(posonlyargs=[arg(...)], args=[arg(...), arg(...)], vararg=None, kwonlyargs=[], kw_defaults=[], kwarg=None, defaults=[Constant(...), ..., Constant(...)]), body=[Pass()], decorator_list=[], returns=None, type_comment=None, type_params=[])], type_ignores=[])
+Module(body=[FunctionDef(name='f', args=arguments(posonlyargs=[arg(...)], args=[arg(...)], vararg=None, kwonlyargs=[arg(...)], kw_defaults=[Constant(...)], kwarg=None, defaults=[Constant(...), Constant(...)]), body=[Pass()], decorator_list=[], returns=None, type_comment=None, type_params=[])], type_ignores=[])
+Module(body=[FunctionDef(name='f', args=arguments(posonlyargs=[arg(...)], args=[arg(...)], vararg=None, kwonlyargs=[arg(...)], kw_defaults=[None], kwarg=None, defaults=[Constant(...), Constant(...)]), body=[Pass()], decorator_list=[], returns=None, type_comment=None, type_params=[])], type_ignores=[])
+Module(body=[FunctionDef(name='f', args=arguments(posonlyargs=[arg(...)], args=[arg(...)], vararg=None, kwonlyargs=[arg(...)], kw_defaults=[Constant(...)], kwarg=arg(...), defaults=[Constant(...), Constant(...)]), body=[Pass()], decorator_list=[], returns=None, type_comment=None, type_params=[])], type_ignores=[])
+Module(body=[FunctionDef(name='f', args=arguments(posonlyargs=[arg(...)], args=[arg(...)], vararg=None, kwonlyargs=[arg(...)], kw_defaults=[None], kwarg=arg(...), defaults=[Constant(...), Constant(...)]), body=[Pass()], decorator_list=[], returns=None, type_comment=None, type_params=[])], type_ignores=[])
+Module(body=[TypeAlias(name=Name(id='X', ctx=Store(...)), type_params=[], value=Name(id='int', ctx=Load(...)))], type_ignores=[])
+Module(body=[TypeAlias(name=Name(id='X', ctx=Store(...)), type_params=[TypeVar(name='T', bound=None, default_value=None)], value=Name(id='int', ctx=Load(...)))], type_ignores=[])
+Module(body=[TypeAlias(name=Name(id='X', ctx=Store(...)), type_params=[TypeVar(name='T', bound=None, default_value=None), ..., ParamSpec(name='P', default_value=None)], value=Tuple(elts=[Name(...), ..., Name(...)], ctx=Load(...)))], type_ignores=[])
+Module(body=[TypeAlias(name=Name(id='X', ctx=Store(...)), type_params=[TypeVar(name='T', bound=Name(...), default_value=None), ..., ParamSpec(name='P', default_value=None)], value=Tuple(elts=[Name(...), ..., Name(...)], ctx=Load(...)))], type_ignores=[])
+Module(body=[TypeAlias(name=Name(id='X', ctx=Store(...)), type_params=[TypeVar(name='T', bound=Tuple(...), default_value=None), ..., ParamSpec(name='P', default_value=None)], value=Tuple(elts=[Name(...), ..., Name(...)], ctx=Load(...)))], type_ignores=[])
+Module(body=[TypeAlias(name=Name(id='X', ctx=Store(...)), type_params=[TypeVar(name='T', bound=Name(...), default_value=Constant(...)), ..., ParamSpec(name='P', default_value=Constant(...))], value=Tuple(elts=[Name(...), ..., Name(...)], ctx=Load(...)))], type_ignores=[])
+Module(body=[ClassDef(name='X', bases=[], keywords=[], body=[Pass()], decorator_list=[], type_params=[TypeVar(name='T', bound=None, default_value=None)])], type_ignores=[])
+Module(body=[ClassDef(name='X', bases=[], keywords=[], body=[Pass()], decorator_list=[], type_params=[TypeVar(name='T', bound=None, default_value=None), ..., ParamSpec(name='P', default_value=None)])], type_ignores=[])
+Module(body=[ClassDef(name='X', bases=[], keywords=[], body=[Pass()], decorator_list=[], type_params=[TypeVar(name='T', bound=Name(...), default_value=None), ..., ParamSpec(name='P', default_value=None)])], type_ignores=[])
+Module(body=[ClassDef(name='X', bases=[], keywords=[], body=[Pass()], decorator_list=[], type_params=[TypeVar(name='T', bound=Tuple(...), default_value=None), ..., ParamSpec(name='P', default_value=None)])], type_ignores=[])
+Module(body=[ClassDef(name='X', bases=[], keywords=[], body=[Pass()], decorator_list=[], type_params=[TypeVar(name='T', bound=Name(...), default_value=Constant(...)), ..., ParamSpec(name='P', default_value=Constant(...))])], type_ignores=[])
+Module(body=[FunctionDef(name='f', args=arguments(posonlyargs=[], args=[], vararg=None, kwonlyargs=[], kw_defaults=[], kwarg=None, defaults=[]), body=[Pass()], decorator_list=[], returns=None, type_comment=None, type_params=[TypeVar(name='T', bound=None, default_value=None)])], type_ignores=[])
+Module(body=[FunctionDef(name='f', args=arguments(posonlyargs=[], args=[], vararg=None, kwonlyargs=[], kw_defaults=[], kwarg=None, defaults=[]), body=[Pass()], decorator_list=[], returns=None, type_comment=None, type_params=[TypeVar(name='T', bound=None, default_value=None), ..., ParamSpec(name='P', default_value=None)])], type_ignores=[])
+Module(body=[FunctionDef(name='f', args=arguments(posonlyargs=[], args=[], vararg=None, kwonlyargs=[], kw_defaults=[], kwarg=None, defaults=[]), body=[Pass()], decorator_list=[], returns=None, type_comment=None, type_params=[TypeVar(name='T', bound=Name(...), default_value=None), ..., ParamSpec(name='P', default_value=None)])], type_ignores=[])
+Module(body=[FunctionDef(name='f', args=arguments(posonlyargs=[], args=[], vararg=None, kwonlyargs=[], kw_defaults=[], kwarg=None, defaults=[]), body=[Pass()], decorator_list=[], returns=None, type_comment=None, type_params=[TypeVar(name='T', bound=Tuple(...), default_value=None), ..., ParamSpec(name='P', default_value=None)])], type_ignores=[])
+Module(body=[FunctionDef(name='f', args=arguments(posonlyargs=[], args=[], vararg=None, kwonlyargs=[], kw_defaults=[], kwarg=None, defaults=[]), body=[Pass()], decorator_list=[], returns=None, type_comment=None, type_params=[TypeVar(name='T', bound=Name(...), default_value=Constant(...)), ..., ParamSpec(name='P', default_value=Constant(...))])], type_ignores=[])
+Module(body=[Match(subject=Name(id='x', ctx=Load(...)), cases=[match_case(pattern=MatchValue(...), guard=None, body=[Pass(...)])])], type_ignores=[])
+Module(body=[Match(subject=Name(id='x', ctx=Load(...)), cases=[match_case(pattern=MatchValue(...), guard=None, body=[Pass(...)]), match_case(pattern=MatchAs(...), guard=None, body=[Pass(...)])])], type_ignores=[])
+Module(body=[Expr(value=Constant(value=None, kind=None))], type_ignores=[])
+Module(body=[Expr(value=Constant(value=True, kind=None))], type_ignores=[])
+Module(body=[Expr(value=Constant(value=False, kind=None))], type_ignores=[])
+Module(body=[Expr(value=BoolOp(op=And(...), values=[Name(...), Name(...)]))], type_ignores=[])
+Module(body=[Expr(value=BoolOp(op=Or(...), values=[Name(...), Name(...)]))], type_ignores=[])
+Module(body=[Expr(value=BinOp(left=Name(...), op=Add(...), right=Name(...)))], type_ignores=[])
+Module(body=[Expr(value=BinOp(left=Name(...), op=Sub(...), right=Name(...)))], type_ignores=[])
+Module(body=[Expr(value=BinOp(left=Name(...), op=Mult(...), right=Name(...)))], type_ignores=[])
+Module(body=[Expr(value=BinOp(left=Name(...), op=Div(...), right=Name(...)))], type_ignores=[])
+Module(body=[Expr(value=BinOp(left=Name(...), op=MatMult(...), right=Name(...)))], type_ignores=[])
+Module(body=[Expr(value=BinOp(left=Name(...), op=FloorDiv(...), right=Name(...)))], type_ignores=[])
+Module(body=[Expr(value=BinOp(left=Name(...), op=Pow(...), right=Name(...)))], type_ignores=[])
+Module(body=[Expr(value=BinOp(left=Name(...), op=Mod(...), right=Name(...)))], type_ignores=[])
+Module(body=[Expr(value=BinOp(left=Name(...), op=RShift(...), right=Name(...)))], type_ignores=[])
+Module(body=[Expr(value=BinOp(left=Name(...), op=LShift(...), right=Name(...)))], type_ignores=[])
+Module(body=[Expr(value=BinOp(left=Name(...), op=BitXor(...), right=Name(...)))], type_ignores=[])
+Module(body=[Expr(value=BinOp(left=Name(...), op=BitOr(...), right=Name(...)))], type_ignores=[])
+Module(body=[Expr(value=BinOp(left=Name(...), op=BitAnd(...), right=Name(...)))], type_ignores=[])
+Module(body=[Expr(value=UnaryOp(op=Not(...), operand=Name(...)))], type_ignores=[])
+Module(body=[Expr(value=UnaryOp(op=UAdd(...), operand=Name(...)))], type_ignores=[])
+Module(body=[Expr(value=UnaryOp(op=USub(...), operand=Name(...)))], type_ignores=[])
+Module(body=[Expr(value=UnaryOp(op=Invert(...), operand=Name(...)))], type_ignores=[])
+Module(body=[Expr(value=Lambda(args=arguments(...), body=Constant(...)))], type_ignores=[])
+Module(body=[Expr(value=Dict(keys=[Constant(...)], values=[Constant(...)]))], type_ignores=[])
+Module(body=[Expr(value=Dict(keys=[], values=[]))], type_ignores=[])
+Module(body=[Expr(value=Set(elts=[Constant(...)]))], type_ignores=[])
+Module(body=[Expr(value=Dict(keys=[Constant(...)], values=[Constant(...)]))], type_ignores=[])
+Module(body=[Expr(value=List(elts=[Constant(...), Constant(...)], ctx=Load(...)))], type_ignores=[])
+Module(body=[Expr(value=Tuple(elts=[Constant(...)], ctx=Load(...)))], type_ignores=[])
+Module(body=[Expr(value=Set(elts=[Constant(...), Constant(...)]))], type_ignores=[])
+Module(body=[Expr(value=ListComp(elt=Name(...), generators=[comprehension(...)]))], type_ignores=[])
+Module(body=[Expr(value=GeneratorExp(elt=Name(...), generators=[comprehension(...)]))], type_ignores=[])
+Module(body=[Expr(value=SetComp(elt=Name(...), generators=[comprehension(...)]))], type_ignores=[])
+Module(body=[Expr(value=DictComp(key=Name(...), value=Name(...), generators=[comprehension(...)]))], type_ignores=[])
+Module(body=[Expr(value=ListComp(elt=Tuple(...), generators=[comprehension(...)]))], type_ignores=[])
+Module(body=[Expr(value=ListComp(elt=Tuple(...), generators=[comprehension(...)]))], type_ignores=[])
+Module(body=[Expr(value=ListComp(elt=Tuple(...), generators=[comprehension(...)]))], type_ignores=[])
+Module(body=[Expr(value=SetComp(elt=Tuple(...), generators=[comprehension(...)]))], type_ignores=[])
+Module(body=[Expr(value=SetComp(elt=Tuple(...), generators=[comprehension(...)]))], type_ignores=[])
+Module(body=[Expr(value=SetComp(elt=Tuple(...), generators=[comprehension(...)]))], type_ignores=[])
+Module(body=[Expr(value=GeneratorExp(elt=Tuple(...), generators=[comprehension(...)]))], type_ignores=[])
+Module(body=[Expr(value=GeneratorExp(elt=Tuple(...), generators=[comprehension(...)]))], type_ignores=[])
+Module(body=[Expr(value=GeneratorExp(elt=Tuple(...), generators=[comprehension(...)]))], type_ignores=[])
+Module(body=[Expr(value=Compare(left=Constant(...), ops=[Lt(...), Lt(...)], comparators=[Constant(...), Constant(...)]))], type_ignores=[])
+Module(body=[Expr(value=Compare(left=Name(...), ops=[Eq(...)], comparators=[Name(...)]))], type_ignores=[])
+Module(body=[Expr(value=Compare(left=Name(...), ops=[LtE(...)], comparators=[Name(...)]))], type_ignores=[])
+Module(body=[Expr(value=Compare(left=Name(...), ops=[GtE(...)], comparators=[Name(...)]))], type_ignores=[])
+Module(body=[Expr(value=Compare(left=Name(...), ops=[NotEq(...)], comparators=[Name(...)]))], type_ignores=[])
+Module(body=[Expr(value=Compare(left=Name(...), ops=[Is(...)], comparators=[Name(...)]))], type_ignores=[])
+Module(body=[Expr(value=Compare(left=Name(...), ops=[IsNot(...)], comparators=[Name(...)]))], type_ignores=[])
+Module(body=[Expr(value=Compare(left=Name(...), ops=[In(...)], comparators=[Name(...)]))], type_ignores=[])
+Module(body=[Expr(value=Compare(left=Name(...), ops=[NotIn(...)], comparators=[Name(...)]))], type_ignores=[])
+Module(body=[Expr(value=Call(func=Name(...), args=[], keywords=[]))], type_ignores=[])
+Module(body=[Expr(value=Call(func=Name(...), args=[Constant(...), ..., Starred(...)], keywords=[keyword(...), keyword(...)]))], type_ignores=[])
+Module(body=[Expr(value=Call(func=Name(...), args=[Starred(...)], keywords=[]))], type_ignores=[])
+Module(body=[Expr(value=Call(func=Name(...), args=[GeneratorExp(...)], keywords=[]))], type_ignores=[])
+Module(body=[Expr(value=Constant(value=10, kind=None))], type_ignores=[])
+Module(body=[Expr(value=Constant(value=1j, kind=None))], type_ignores=[])
+Module(body=[Expr(value=Constant(value='string', kind=None))], type_ignores=[])
+Module(body=[Expr(value=Attribute(value=Name(...), attr='b', ctx=Load(...)))], type_ignores=[])
+Module(body=[Expr(value=Subscript(value=Name(...), slice=Slice(...), ctx=Load(...)))], type_ignores=[])
+Module(body=[Expr(value=Name(id='v', ctx=Load(...)))], type_ignores=[])
+Module(body=[Expr(value=List(elts=[Constant(...), ..., Constant(...)], ctx=Load(...)))], type_ignores=[])
+Module(body=[Expr(value=List(elts=[], ctx=Load(...)))], type_ignores=[])
+Module(body=[Expr(value=Tuple(elts=[Constant(...), ..., Constant(...)], ctx=Load(...)))], type_ignores=[])
+Module(body=[Expr(value=Tuple(elts=[Constant(...), ..., Constant(...)], ctx=Load(...)))], type_ignores=[])
+Module(body=[Expr(value=Tuple(elts=[], ctx=Load(...)))], type_ignores=[])
+Module(body=[Expr(value=Call(func=Attribute(...), args=[Subscript(...)], keywords=[]))], type_ignores=[])
+Module(body=[Expr(value=Subscript(value=List(...), slice=Slice(...), ctx=Load(...)))], type_ignores=[])
+Module(body=[Expr(value=Subscript(value=List(...), slice=Slice(...), ctx=Load(...)))], type_ignores=[])
+Module(body=[Expr(value=Subscript(value=List(...), slice=Slice(...), ctx=Load(...)))], type_ignores=[])
+Module(body=[Expr(value=Subscript(value=List(...), slice=Slice(...), ctx=Load(...)))], type_ignores=[])
+Module(body=[Expr(value=IfExp(test=Name(...), body=Call(...), orelse=Call(...)))], type_ignores=[])
+Module(body=[Expr(value=JoinedStr(values=[FormattedValue(...)]))], type_ignores=[])
+Module(body=[Expr(value=JoinedStr(values=[FormattedValue(...)]))], type_ignores=[])
+Module(body=[Expr(value=JoinedStr(values=[FormattedValue(...)]))], type_ignores=[])
+Module(body=[Expr(value=JoinedStr(values=[Constant(...), ..., Constant(...)]))], type_ignores=[])
+Module(body=[Expr(value=TemplateStr(values=[Interpolation(...)]))], type_ignores=[])
+Module(body=[Expr(value=TemplateStr(values=[Interpolation(...)]))], type_ignores=[])
+Module(body=[Expr(value=TemplateStr(values=[Interpolation(...)]))], type_ignores=[])
+Module(body=[Expr(value=TemplateStr(values=[Interpolation(...)]))], type_ignores=[])
+Module(body=[Expr(value=TemplateStr(values=[Constant(...), ..., Constant(...)]))], type_ignores=[])
\ No newline at end of file
diff --git a/Lib/test/test_ast/snippets.py b/Lib/test/test_ast/snippets.py
index 28d32b2941f..b76f98901d2 100644
--- a/Lib/test/test_ast/snippets.py
+++ b/Lib/test/test_ast/snippets.py
@@ -364,6 +364,12 @@
   "f'{a:.2f}'",
   "f'{a!r}'",
   "f'foo({a})'",
+  # TemplateStr and Interpolation
+  "t'{a}'",
+  "t'{a:.2f}'",
+  "t'{a!r}'",
+  "t'{a!r:.2f}'",
+  "t'foo({a})'",
 ]
 
 
@@ -597,5 +603,10 @@ def main():
 ('Expression', ('JoinedStr', (1, 0, 1, 10), [('FormattedValue', (1, 2, 1, 9), ('Name', (1, 3, 1, 4), 'a', ('Load',)), -1, ('JoinedStr', (1, 4, 1, 8), [('Constant', (1, 5, 1, 8), '.2f', None)]))])),
 ('Expression', ('JoinedStr', (1, 0, 1, 8), [('FormattedValue', (1, 2, 1, 7), ('Name', (1, 3, 1, 4), 'a', ('Load',)), 114, None)])),
 ('Expression', ('JoinedStr', (1, 0, 1, 11), [('Constant', (1, 2, 1, 6), 'foo(', None), ('FormattedValue', (1, 6, 1, 9), ('Name', (1, 7, 1, 8), 'a', ('Load',)), -1, None), ('Constant', (1, 9, 1, 10), ')', None)])),
+('Expression', ('TemplateStr', (1, 0, 1, 6), [('Interpolation', (1, 2, 1, 5), ('Name', (1, 3, 1, 4), 'a', ('Load',)), 'a', -1, None)])),
+('Expression', ('TemplateStr', (1, 0, 1, 10), [('Interpolation', (1, 2, 1, 9), ('Name', (1, 3, 1, 4), 'a', ('Load',)), 'a', -1, ('JoinedStr', (1, 4, 1, 8), [('Constant', (1, 5, 1, 8), '.2f', None)]))])),
+('Expression', ('TemplateStr', (1, 0, 1, 8), [('Interpolation', (1, 2, 1, 7), ('Name', (1, 3, 1, 4), 'a', ('Load',)), 'a', 114, None)])),
+('Expression', ('TemplateStr', (1, 0, 1, 12), [('Interpolation', (1, 2, 1, 11), ('Name', (1, 3, 1, 4), 'a', ('Load',)), 'a', 114, ('JoinedStr', (1, 6, 1, 10), [('Constant', (1, 7, 1, 10), '.2f', None)]))])),
+('Expression', ('TemplateStr', (1, 0, 1, 11), [('Constant', (1, 2, 1, 6), 'foo(', None), ('Interpolation', (1, 6, 1, 9), ('Name', (1, 7, 1, 8), 'a', ('Load',)), 'a', -1, None), ('Constant', (1, 9, 1, 10), ')', None)])),
 ]
 main()
diff --git a/Lib/test/test_ast/test_ast.py b/Lib/test/test_ast/test_ast.py
index 5309939777f..e2e619c5a23 100644
--- a/Lib/test/test_ast/test_ast.py
+++ b/Lib/test/test_ast/test_ast.py
@@ -1,34 +1,59 @@
+import _ast_unparse
 import ast
 import builtins
+import contextlib
 import copy
 import dis
 import enum
+import itertools
 import os
 import re
 import sys
+import tempfile
 import textwrap
 import types
 import unittest
-import warnings
 import weakref
-from functools import partial
+from io import StringIO
+from pathlib import Path
 from textwrap import dedent
-
 try:
     import _testinternalcapi
 except ImportError:
     _testinternalcapi = None
 
 from test import support
-from test.support.import_helper import import_fresh_module
-from test.support import os_helper, script_helper
+from test.support import os_helper
+from test.support import skip_emscripten_stack_overflow, skip_wasi_stack_overflow, skip_if_unlimited_stack_size
 from test.support.ast_helper import ASTTestMixin
+from test.support.import_helper import ensure_lazy_imports
 from test.test_ast.utils import to_tuple
 from test.test_ast.snippets import (
     eval_tests, eval_results, exec_tests, exec_results, single_tests, single_results
 )
 
 
+STDLIB = os.path.dirname(ast.__file__)
+STDLIB_FILES = [fn for fn in os.listdir(STDLIB) if fn.endswith(".py")]
+STDLIB_FILES.extend(["test/test_grammar.py", "test/test_unpack_ex.py"])
+
+AST_REPR_DATA_FILE = Path(__file__).parent / "data" / "ast_repr.txt"
+
+def ast_repr_get_test_cases() -> list[str]:
+    return exec_tests + eval_tests
+
+
+def ast_repr_update_snapshots() -> None:
+    data = [repr(ast.parse(test)) for test in ast_repr_get_test_cases()]
+    AST_REPR_DATA_FILE.write_text("\n".join(data))
+
+
+class LazyImportTest(unittest.TestCase):
+    @support.cpython_only
+    def test_lazy_import(self):
+        ensure_lazy_imports("ast", {"contextlib", "enum", "inspect", "re", "collections", "argparse"})
+
+
 class AST_Tests(unittest.TestCase):
     maxDiff = None
 
@@ -37,7 +62,7 @@ def _is_ast_node(self, name, node):
             return False
         if "ast" not in node.__module__:
             return False
-        return name != "AST" and name[0].isupper()
+        return name != 'AST' and name[0].isupper()
 
     def _assertTrueorder(self, ast_node, parent_pos):
         if not isinstance(ast_node, ast.AST) or ast_node._fields is None:
@@ -50,7 +75,7 @@ def _assertTrueorder(self, ast_node, parent_pos):
             value = getattr(ast_node, name)
             if isinstance(value, list):
                 first_pos = parent_pos
-                if value and name == "decorator_list":
+                if value and name == 'decorator_list':
                     first_pos = (value[0].lineno, value[0].col_offset)
                 for child in value:
                     self._assertTrueorder(child, first_pos)
@@ -72,7 +97,6 @@ def test_AST_objects(self):
             # "ast.AST constructor takes 0 positional arguments"
             ast.AST(2)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_AST_fields_NULL_check(self):
         # See: https://github.com/python/cpython/issues/126105
         old_value = ast.AST._fields
@@ -90,11 +114,10 @@ def cleanup():
         with self.assertRaisesRegex(AttributeError, msg):
             ast.AST()
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AssertionError: <test.test_ast.test_ast.AST_Tests.test_AST_garbage_collection.<locals>.X object at 0x7e85c3a80> is not None
     def test_AST_garbage_collection(self):
         class X:
             pass
-
         a = ast.AST()
         a.x = X()
         a.x.a = a
@@ -103,13 +126,10 @@ class X:
         support.gc_collect()
         self.assertIsNone(ref())
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_snippets(self):
-        for input, output, kind in (
-            (exec_tests, exec_results, "exec"),
-            (single_tests, single_results, "single"),
-            (eval_tests, eval_results, "eval"),
-        ):
+        for input, output, kind in ((exec_tests, exec_results, "exec"),
+                                    (single_tests, single_results, "single"),
+                                    (eval_tests, eval_results, "eval")):
             for i, o in zip(input, output):
                 with self.subTest(action="parsing", input=i):
                     ast_tree = compile(i, "?", kind, ast.PyCF_ONLY_AST)
@@ -118,18 +138,23 @@ def test_snippets(self):
                 with self.subTest(action="compiling", input=i, kind=kind):
                     compile(ast_tree, "?", kind)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_ast_validation(self):
         # compile() is the only function that calls PyAST_Validate
         snippets_to_validate = exec_tests + single_tests + eval_tests
         for snippet in snippets_to_validate:
             tree = ast.parse(snippet)
-            compile(tree, "<string>", "exec")
+            compile(tree, '<string>', 'exec')
+
+    def test_parse_invalid_ast(self):
+        # see gh-130139
+        for optval in (-1, 0, 1, 2):
+            self.assertRaises(TypeError, ast.parse, ast.Constant(42),
+                              optimize=optval)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON; ValueError: compile() unrecognized flags
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; ValueError: compile() unrecognized flags
     def test_optimization_levels__debug__(self):
-        cases = [(-1, "__debug__"), (0, "__debug__"), (1, False), (2, False)]
-        for optval, expected in cases:
+        cases = [(-1, '__debug__'), (0, '__debug__'), (1, False), (2, False)]
+        for (optval, expected) in cases:
             with self.subTest(optval=optval, expected=expected):
                 res1 = ast.parse("__debug__", optimize=optval)
                 res2 = ast.parse(ast.parse("__debug__"), optimize=optval)
@@ -142,33 +167,10 @@ def test_optimization_levels__debug__(self):
                         self.assertIsInstance(res.body[0].value, ast.Name)
                         self.assertEqual(res.body[0].value.id, expected)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON; ValueError: compile() unrecognized flags
-    def test_optimization_levels_const_folding(self):
-        folded = ("Expr", (1, 0, 1, 5), ("Constant", (1, 0, 1, 5), 3, None))
-        not_folded = (
-            "Expr",
-            (1, 0, 1, 5),
-            (
-                "BinOp",
-                (1, 0, 1, 5),
-                ("Constant", (1, 0, 1, 1), 1, None),
-                ("Add",),
-                ("Constant", (1, 4, 1, 5), 2, None),
-            ),
-        )
-
-        cases = [(-1, not_folded), (0, not_folded), (1, folded), (2, folded)]
-        for optval, expected in cases:
-            with self.subTest(optval=optval):
-                tree1 = ast.parse("1 + 2", optimize=optval)
-                tree2 = ast.parse(ast.parse("1 + 2"), optimize=optval)
-                for tree in [tree1, tree2]:
-                    res = to_tuple(tree.body[0])
-                    self.assertEqual(res, expected)
-
-    @unittest.expectedFailure # TODO: RUSTPYTHON; ValueError not raised
     def test_invalid_position_information(self):
-        invalid_linenos = [(10, 1), (-10, -11), (10, -11), (-5, -2), (-5, 1)]
+        invalid_linenos = [
+            (10, 1), (-10, -11), (10, -11), (-5, -2), (-5, 1)
+        ]
 
         for lineno, end_lineno in invalid_linenos:
             with self.subTest(f"Check invalid linenos {lineno}:{end_lineno}"):
@@ -177,36 +179,25 @@ def test_invalid_position_information(self):
                 tree.body[0].lineno = lineno
                 tree.body[0].end_lineno = end_lineno
                 with self.assertRaises(ValueError):
-                    compile(tree, "<string>", "exec")
+                    compile(tree, '<string>', 'exec')
 
-        invalid_col_offsets = [(10, 1), (-10, -11), (10, -11), (-5, -2), (-5, 1)]
+        invalid_col_offsets = [
+            (10, 1), (-10, -11), (10, -11), (-5, -2), (-5, 1)
+        ]
         for col_offset, end_col_offset in invalid_col_offsets:
-            with self.subTest(
-                f"Check invalid col_offset {col_offset}:{end_col_offset}"
-            ):
+            with self.subTest(f"Check invalid col_offset {col_offset}:{end_col_offset}"):
                 snippet = "a = 1"
                 tree = ast.parse(snippet)
                 tree.body[0].col_offset = col_offset
                 tree.body[0].end_col_offset = end_col_offset
                 with self.assertRaises(ValueError):
-                    compile(tree, "<string>", "exec")
+                    compile(tree, '<string>', 'exec')
 
     def test_compilation_of_ast_nodes_with_default_end_position_values(self):
-        tree = ast.Module(
-            body=[
-                ast.Import(
-                    names=[ast.alias(name="builtins", lineno=1, col_offset=0)],
-                    lineno=1,
-                    col_offset=0,
-                ),
-                ast.Import(
-                    names=[ast.alias(name="traceback", lineno=0, col_offset=0)],
-                    lineno=0,
-                    col_offset=1,
-                ),
-            ],
-            type_ignores=[],
-        )
+        tree = ast.Module(body=[
+            ast.Import(names=[ast.alias(name='builtins', lineno=1, col_offset=0)], lineno=1, col_offset=0),
+            ast.Import(names=[ast.alias(name='traceback', lineno=0, col_offset=0)], lineno=0, col_offset=1)
+        ], type_ignores=[])
 
         # Check that compilation doesn't crash. Note: this may crash explicitly only on debug mode.
         compile(tree, "<string>", "exec")
@@ -231,6 +222,131 @@ def test_negative_locations_for_compile(self):
                 # This also must not crash:
                 ast.parse(tree, optimize=2)
 
+    def test_docstring_optimization_single_node(self):
+        # https://github.com/python/cpython/issues/137308
+        class_example1 = textwrap.dedent('''
+            class A:
+                """Docstring"""
+        ''')
+        class_example2 = textwrap.dedent('''
+            class A:
+                """
+                Docstring"""
+        ''')
+        def_example1 = textwrap.dedent('''
+            def some():
+                """Docstring"""
+        ''')
+        def_example2 = textwrap.dedent('''
+            def some():
+                """Docstring
+                                       """
+        ''')
+        async_def_example1 = textwrap.dedent('''
+            async def some():
+                """Docstring"""
+        ''')
+        async_def_example2 = textwrap.dedent('''
+            async def some():
+                """
+                Docstring
+            """
+        ''')
+        for code in [
+            class_example1,
+            class_example2,
+            def_example1,
+            def_example2,
+            async_def_example1,
+            async_def_example2,
+        ]:
+            for opt_level in [0, 1, 2]:
+                with self.subTest(code=code, opt_level=opt_level):
+                    mod = ast.parse(code, optimize=opt_level)
+                    self.assertEqual(len(mod.body[0].body), 1)
+                    if opt_level == 2:
+                        pass_stmt = mod.body[0].body[0]
+                        self.assertIsInstance(pass_stmt, ast.Pass)
+                        self.assertEqual(
+                            vars(pass_stmt),
+                            {
+                                'lineno': 3,
+                                'col_offset': 4,
+                                'end_lineno': 3,
+                                'end_col_offset': 8,
+                            },
+                        )
+                    else:
+                        self.assertIsInstance(mod.body[0].body[0], ast.Expr)
+                        self.assertIsInstance(
+                            mod.body[0].body[0].value,
+                            ast.Constant,
+                        )
+
+                    compile(code, "a", "exec")
+                    compile(code, "a", "exec", optimize=opt_level)
+                    compile(mod, "a", "exec")
+                    compile(mod, "a", "exec", optimize=opt_level)
+
+    def test_docstring_optimization_multiple_nodes(self):
+        # https://github.com/python/cpython/issues/137308
+        class_example = textwrap.dedent(
+            """
+            class A:
+                '''
+                Docstring
+                '''
+                x = 1
+            """
+        )
+
+        def_example = textwrap.dedent(
+            """
+            def some():
+                '''
+                Docstring
+
+            '''
+                x = 1
+            """
+        )
+
+        async_def_example = textwrap.dedent(
+            """
+            async def some():
+
+                '''Docstring
+
+            '''
+                x = 1
+            """
+        )
+
+        for code in [
+            class_example,
+            def_example,
+            async_def_example,
+        ]:
+            for opt_level in [0, 1, 2]:
+                with self.subTest(code=code, opt_level=opt_level):
+                    mod = ast.parse(code, optimize=opt_level)
+                    if opt_level == 2:
+                        self.assertNotIsInstance(
+                            mod.body[0].body[0],
+                            (ast.Pass, ast.Expr),
+                        )
+                    else:
+                        self.assertIsInstance(mod.body[0].body[0], ast.Expr)
+                        self.assertIsInstance(
+                            mod.body[0].body[0].value,
+                            ast.Constant,
+                        )
+
+                    compile(code, "a", "exec")
+                    compile(code, "a", "exec", optimize=opt_level)
+                    compile(mod, "a", "exec")
+                    compile(mod, "a", "exec", optimize=opt_level)
+
     def test_slice(self):
         slc = ast.parse("x[::]").body[0].value.slice
         self.assertIsNone(slc.upper)
@@ -251,7 +367,7 @@ def test_alias(self):
         im = ast.parse("from bar import y").body[0]
         self.assertEqual(len(im.names), 1)
         alias = im.names[0]
-        self.assertEqual(alias.name, "y")
+        self.assertEqual(alias.name, 'y')
         self.assertIsNone(alias.asname)
         self.assertEqual(alias.lineno, 1)
         self.assertEqual(alias.end_lineno, 1)
@@ -260,7 +376,7 @@ def test_alias(self):
 
         im = ast.parse("from bar import *").body[0]
         alias = im.names[0]
-        self.assertEqual(alias.name, "*")
+        self.assertEqual(alias.name, '*')
         self.assertIsNone(alias.asname)
         self.assertEqual(alias.lineno, 1)
         self.assertEqual(alias.end_lineno, 1)
@@ -286,45 +402,17 @@ def test_alias(self):
         self.assertEqual(alias.end_col_offset, 17)
 
     def test_base_classes(self):
-        self.assertTrue(issubclass(ast.For, ast.stmt))
-        self.assertTrue(issubclass(ast.Name, ast.expr))
-        self.assertTrue(issubclass(ast.stmt, ast.AST))
-        self.assertTrue(issubclass(ast.expr, ast.AST))
-        self.assertTrue(issubclass(ast.comprehension, ast.AST))
-        self.assertTrue(issubclass(ast.Gt, ast.AST))
-
-    def test_import_deprecated(self):
-        ast = import_fresh_module("ast")
-        depr_regex = (
-            r"ast\.{} is deprecated and will be removed in Python 3.14; "
-            r"use ast\.Constant instead"
-        )
-        for name in "Num", "Str", "Bytes", "NameConstant", "Ellipsis":
-            with self.assertWarnsRegex(DeprecationWarning, depr_regex.format(name)):
-                getattr(ast, name)
-
-    def test_field_attr_existence_deprecated(self):
-        with warnings.catch_warnings():
-            warnings.filterwarnings("ignore", "", DeprecationWarning)
-            from ast import Num, Str, Bytes, NameConstant, Ellipsis
+        self.assertIsSubclass(ast.For, ast.stmt)
+        self.assertIsSubclass(ast.Name, ast.expr)
+        self.assertIsSubclass(ast.stmt, ast.AST)
+        self.assertIsSubclass(ast.expr, ast.AST)
+        self.assertIsSubclass(ast.comprehension, ast.AST)
+        self.assertIsSubclass(ast.Gt, ast.AST)
 
-        for name in ("Num", "Str", "Bytes", "NameConstant", "Ellipsis"):
-            item = getattr(ast, name)
-            if self._is_ast_node(name, item):
-                with self.subTest(item):
-                    with self.assertWarns(DeprecationWarning):
-                        x = item()
-                if isinstance(x, ast.AST):
-                    self.assertIs(type(x._fields), tuple)
-
-    @unittest.expectedFailure # TODO: RUSTPYTHON; type object 'Module' has no attribute '__annotations__'
     def test_field_attr_existence(self):
         for name, item in ast.__dict__.items():
-            # These emit DeprecationWarnings
-            if name in {"Num", "Str", "Bytes", "NameConstant", "Ellipsis"}:
-                continue
             # constructor has a different signature
-            if name == "Index":
+            if name == 'Index':
                 continue
             if self._is_ast_node(name, item):
                 x = self._construct_ast_class(item)
@@ -335,42 +423,28 @@ def _construct_ast_class(self, cls):
         kwargs = {}
         for name, typ in cls.__annotations__.items():
             if typ is str:
-                kwargs[name] = "capybara"
+                kwargs[name] = 'capybara'
             elif typ is int:
                 kwargs[name] = 42
             elif typ is object:
-                kwargs[name] = b"capybara"
+                kwargs[name] = b'capybara'
             elif isinstance(typ, type) and issubclass(typ, ast.AST):
                 kwargs[name] = self._construct_ast_class(typ)
         return cls(**kwargs)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_arguments(self):
         x = ast.arguments()
-        self.assertEqual(
-            x._fields,
-            (
-                "posonlyargs",
-                "args",
-                "vararg",
-                "kwonlyargs",
-                "kw_defaults",
-                "kwarg",
-                "defaults",
-            ),
-        )
-        self.assertEqual(
-            x.__annotations__,
-            {
-                "posonlyargs": list[ast.arg],
-                "args": list[ast.arg],
-                "vararg": ast.arg | None,
-                "kwonlyargs": list[ast.arg],
-                "kw_defaults": list[ast.expr],
-                "kwarg": ast.arg | None,
-                "defaults": list[ast.expr],
-            },
-        )
+        self.assertEqual(x._fields, ('posonlyargs', 'args', 'vararg', 'kwonlyargs',
+                                     'kw_defaults', 'kwarg', 'defaults'))
+        self.assertEqual(ast.arguments.__annotations__, {
+            'posonlyargs': list[ast.arg],
+            'args': list[ast.arg],
+            'vararg': ast.arg | None,
+            'kwonlyargs': list[ast.arg],
+            'kw_defaults': list[ast.expr],
+            'kwarg': ast.arg | None,
+            'defaults': list[ast.expr],
+        })
 
         self.assertEqual(x.args, [])
         self.assertIsNone(x.vararg)
@@ -379,117 +453,16 @@ def test_arguments(self):
         self.assertEqual(x.args, 2)
         self.assertEqual(x.vararg, 3)
 
-    def test_field_attr_writable_deprecated(self):
-        with warnings.catch_warnings():
-            warnings.filterwarnings("ignore", "", DeprecationWarning)
-            x = ast.Num()
-        # We can assign to _fields
-        x._fields = 666
-        self.assertEqual(x._fields, 666)
-
     def test_field_attr_writable(self):
         x = ast.Constant(1)
         # We can assign to _fields
         x._fields = 666
         self.assertEqual(x._fields, 666)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
-    def test_classattrs_deprecated(self):
-        with warnings.catch_warnings():
-            warnings.filterwarnings("ignore", "", DeprecationWarning)
-            from ast import Num, Str, Bytes, NameConstant, Ellipsis
-
-        with warnings.catch_warnings(record=True) as wlog:
-            warnings.filterwarnings("always", "", DeprecationWarning)
-            x = ast.Num()
-            self.assertEqual(x._fields, ("value", "kind"))
-
-            with self.assertRaises(AttributeError):
-                x.value
-
-            with self.assertRaises(AttributeError):
-                x.n
-
-            x = ast.Num(42)
-            self.assertEqual(x.value, 42)
-            self.assertEqual(x.n, 42)
-
-            with self.assertRaises(AttributeError):
-                x.lineno
-
-            with self.assertRaises(AttributeError):
-                x.foobar
-
-            x = ast.Num(lineno=2)
-            self.assertEqual(x.lineno, 2)
-
-            x = ast.Num(42, lineno=0)
-            self.assertEqual(x.lineno, 0)
-            self.assertEqual(x._fields, ("value", "kind"))
-            self.assertEqual(x.value, 42)
-            self.assertEqual(x.n, 42)
-
-            self.assertRaises(TypeError, ast.Num, 1, None, 2)
-            self.assertRaises(TypeError, ast.Num, 1, None, 2, lineno=0)
-
-            # Arbitrary keyword arguments are supported
-            self.assertEqual(ast.Num(1, foo="bar").foo, "bar")
-
-            with self.assertRaisesRegex(
-                TypeError, "Num got multiple values for argument 'n'"
-            ):
-                ast.Num(1, n=2)
-
-            self.assertEqual(ast.Num(42).n, 42)
-            self.assertEqual(ast.Num(4.25).n, 4.25)
-            self.assertEqual(ast.Num(4.25j).n, 4.25j)
-            self.assertEqual(ast.Str("42").s, "42")
-            self.assertEqual(ast.Bytes(b"42").s, b"42")
-            self.assertIs(ast.NameConstant(True).value, True)
-            self.assertIs(ast.NameConstant(False).value, False)
-            self.assertIs(ast.NameConstant(None).value, None)
-
-        self.assertEqual(
-            [str(w.message) for w in wlog],
-            [
-                "ast.Num is deprecated and will be removed in Python 3.14; use ast.Constant instead",
-                "Constant.__init__ missing 1 required positional argument: 'value'. This will become "
-                "an error in Python 3.15.",
-                "Attribute n is deprecated and will be removed in Python 3.14; use value instead",
-                "ast.Num is deprecated and will be removed in Python 3.14; use ast.Constant instead",
-                "Attribute n is deprecated and will be removed in Python 3.14; use value instead",
-                "ast.Num is deprecated and will be removed in Python 3.14; use ast.Constant instead",
-                "Constant.__init__ missing 1 required positional argument: 'value'. This will become "
-                "an error in Python 3.15.",
-                "ast.Num is deprecated and will be removed in Python 3.14; use ast.Constant instead",
-                "Attribute n is deprecated and will be removed in Python 3.14; use value instead",
-                "ast.Num is deprecated and will be removed in Python 3.14; use ast.Constant instead",
-                "ast.Num is deprecated and will be removed in Python 3.14; use ast.Constant instead",
-                "ast.Num is deprecated and will be removed in Python 3.14; use ast.Constant instead",
-                "Constant.__init__ got an unexpected keyword argument 'foo'. Support for "
-                "arbitrary keyword arguments is deprecated and will be removed in Python "
-                "3.15.",
-                "ast.Num is deprecated and will be removed in Python 3.14; use ast.Constant instead",
-                "Attribute n is deprecated and will be removed in Python 3.14; use value instead",
-                "ast.Num is deprecated and will be removed in Python 3.14; use ast.Constant instead",
-                "Attribute n is deprecated and will be removed in Python 3.14; use value instead",
-                "ast.Num is deprecated and will be removed in Python 3.14; use ast.Constant instead",
-                "Attribute n is deprecated and will be removed in Python 3.14; use value instead",
-                "ast.Str is deprecated and will be removed in Python 3.14; use ast.Constant instead",
-                "Attribute s is deprecated and will be removed in Python 3.14; use value instead",
-                "ast.Bytes is deprecated and will be removed in Python 3.14; use ast.Constant instead",
-                "Attribute s is deprecated and will be removed in Python 3.14; use value instead",
-                "ast.NameConstant is deprecated and will be removed in Python 3.14; use ast.Constant instead",
-                "ast.NameConstant is deprecated and will be removed in Python 3.14; use ast.Constant instead",
-                "ast.NameConstant is deprecated and will be removed in Python 3.14; use ast.Constant instead",
-            ],
-        )
-
-    @unittest.expectedFailure # TODO: RUSTPYTHON; DeprecationWarning not triggered
     def test_classattrs(self):
         with self.assertWarns(DeprecationWarning):
             x = ast.Constant()
-        self.assertEqual(x._fields, ("value", "kind"))
+        self.assertEqual(x._fields, ('value', 'kind'))
 
         with self.assertRaises(AttributeError):
             x.value
@@ -508,7 +481,7 @@ def test_classattrs(self):
 
         x = ast.Constant(42, lineno=0)
         self.assertEqual(x.lineno, 0)
-        self.assertEqual(x._fields, ("value", "kind"))
+        self.assertEqual(x._fields, ('value', 'kind'))
         self.assertEqual(x.value, 42)
 
         self.assertRaises(TypeError, ast.Constant, 1, None, 2)
@@ -516,234 +489,32 @@ def test_classattrs(self):
 
         # Arbitrary keyword arguments are supported (but deprecated)
         with self.assertWarns(DeprecationWarning):
-            self.assertEqual(ast.Constant(1, foo="bar").foo, "bar")
+            self.assertEqual(ast.Constant(1, foo='bar').foo, 'bar')
 
-        with self.assertRaisesRegex(
-            TypeError, "Constant got multiple values for argument 'value'"
-        ):
+        with self.assertRaisesRegex(TypeError, "Constant got multiple values for argument 'value'"):
             ast.Constant(1, value=2)
 
         self.assertEqual(ast.Constant(42).value, 42)
         self.assertEqual(ast.Constant(4.25).value, 4.25)
         self.assertEqual(ast.Constant(4.25j).value, 4.25j)
-        self.assertEqual(ast.Constant("42").value, "42")
-        self.assertEqual(ast.Constant(b"42").value, b"42")
+        self.assertEqual(ast.Constant('42').value, '42')
+        self.assertEqual(ast.Constant(b'42').value, b'42')
         self.assertIs(ast.Constant(True).value, True)
         self.assertIs(ast.Constant(False).value, False)
         self.assertIs(ast.Constant(None).value, None)
         self.assertIs(ast.Constant(...).value, ...)
 
-    def test_realtype(self):
-        with warnings.catch_warnings():
-            warnings.filterwarnings("ignore", "", DeprecationWarning)
-            from ast import Num, Str, Bytes, NameConstant, Ellipsis
-
-        with warnings.catch_warnings(record=True) as wlog:
-            warnings.filterwarnings("always", "", DeprecationWarning)
-            self.assertIs(type(ast.Num(42)), ast.Constant)
-            self.assertIs(type(ast.Num(4.25)), ast.Constant)
-            self.assertIs(type(ast.Num(4.25j)), ast.Constant)
-            self.assertIs(type(ast.Str("42")), ast.Constant)
-            self.assertIs(type(ast.Bytes(b"42")), ast.Constant)
-            self.assertIs(type(ast.NameConstant(True)), ast.Constant)
-            self.assertIs(type(ast.NameConstant(False)), ast.Constant)
-            self.assertIs(type(ast.NameConstant(None)), ast.Constant)
-            self.assertIs(type(ast.Ellipsis()), ast.Constant)
-
-        self.assertEqual(
-            [str(w.message) for w in wlog],
-            [
-                "ast.Num is deprecated and will be removed in Python 3.14; use ast.Constant instead",
-                "ast.Num is deprecated and will be removed in Python 3.14; use ast.Constant instead",
-                "ast.Num is deprecated and will be removed in Python 3.14; use ast.Constant instead",
-                "ast.Str is deprecated and will be removed in Python 3.14; use ast.Constant instead",
-                "ast.Bytes is deprecated and will be removed in Python 3.14; use ast.Constant instead",
-                "ast.NameConstant is deprecated and will be removed in Python 3.14; use ast.Constant instead",
-                "ast.NameConstant is deprecated and will be removed in Python 3.14; use ast.Constant instead",
-                "ast.NameConstant is deprecated and will be removed in Python 3.14; use ast.Constant instead",
-                "ast.Ellipsis is deprecated and will be removed in Python 3.14; use ast.Constant instead",
-            ],
-        )
-
-    def test_isinstance(self):
-        from ast import Constant
-
-        with warnings.catch_warnings():
-            warnings.filterwarnings("ignore", "", DeprecationWarning)
-            from ast import Num, Str, Bytes, NameConstant, Ellipsis
-
-        cls_depr_msg = (
-            "ast.{} is deprecated and will be removed in Python 3.14; "
-            "use ast.Constant instead"
-        )
-
-        assertNumDeprecated = partial(
-            self.assertWarnsRegex, DeprecationWarning, cls_depr_msg.format("Num")
-        )
-        assertStrDeprecated = partial(
-            self.assertWarnsRegex, DeprecationWarning, cls_depr_msg.format("Str")
-        )
-        assertBytesDeprecated = partial(
-            self.assertWarnsRegex, DeprecationWarning, cls_depr_msg.format("Bytes")
-        )
-        assertNameConstantDeprecated = partial(
-            self.assertWarnsRegex,
-            DeprecationWarning,
-            cls_depr_msg.format("NameConstant"),
-        )
-        assertEllipsisDeprecated = partial(
-            self.assertWarnsRegex, DeprecationWarning, cls_depr_msg.format("Ellipsis")
-        )
-
-        for arg in 42, 4.2, 4.2j:
-            with self.subTest(arg=arg):
-                with assertNumDeprecated():
-                    n = Num(arg)
-                with assertNumDeprecated():
-                    self.assertIsInstance(n, Num)
-
-        with assertStrDeprecated():
-            s = Str("42")
-        with assertStrDeprecated():
-            self.assertIsInstance(s, Str)
-
-        with assertBytesDeprecated():
-            b = Bytes(b"42")
-        with assertBytesDeprecated():
-            self.assertIsInstance(b, Bytes)
-
-        for arg in True, False, None:
-            with self.subTest(arg=arg):
-                with assertNameConstantDeprecated():
-                    n = NameConstant(arg)
-                with assertNameConstantDeprecated():
-                    self.assertIsInstance(n, NameConstant)
-
-        with assertEllipsisDeprecated():
-            e = Ellipsis()
-        with assertEllipsisDeprecated():
-            self.assertIsInstance(e, Ellipsis)
-
-        for arg in 42, 4.2, 4.2j:
-            with self.subTest(arg=arg):
-                with assertNumDeprecated():
-                    self.assertIsInstance(Constant(arg), Num)
-
-        with assertStrDeprecated():
-            self.assertIsInstance(Constant("42"), Str)
-
-        with assertBytesDeprecated():
-            self.assertIsInstance(Constant(b"42"), Bytes)
-
-        for arg in True, False, None:
-            with self.subTest(arg=arg):
-                with assertNameConstantDeprecated():
-                    self.assertIsInstance(Constant(arg), NameConstant)
-
-        with assertEllipsisDeprecated():
-            self.assertIsInstance(Constant(...), Ellipsis)
-
-        with assertStrDeprecated():
-            s = Str("42")
-        assertNumDeprecated(self.assertNotIsInstance, s, Num)
-        assertBytesDeprecated(self.assertNotIsInstance, s, Bytes)
-
-        with assertNumDeprecated():
-            n = Num(42)
-        assertStrDeprecated(self.assertNotIsInstance, n, Str)
-        assertNameConstantDeprecated(self.assertNotIsInstance, n, NameConstant)
-        assertEllipsisDeprecated(self.assertNotIsInstance, n, Ellipsis)
-
-        with assertNameConstantDeprecated():
-            n = NameConstant(True)
-        with assertNumDeprecated():
-            self.assertNotIsInstance(n, Num)
-
-        with assertNameConstantDeprecated():
-            n = NameConstant(False)
-        with assertNumDeprecated():
-            self.assertNotIsInstance(n, Num)
-
-        for arg in "42", True, False:
-            with self.subTest(arg=arg):
-                with assertNumDeprecated():
-                    self.assertNotIsInstance(Constant(arg), Num)
-
-        assertStrDeprecated(self.assertNotIsInstance, Constant(42), Str)
-        assertBytesDeprecated(self.assertNotIsInstance, Constant("42"), Bytes)
-        assertNameConstantDeprecated(
-            self.assertNotIsInstance, Constant(42), NameConstant
-        )
-        assertEllipsisDeprecated(self.assertNotIsInstance, Constant(42), Ellipsis)
-        assertNumDeprecated(self.assertNotIsInstance, Constant(None), Num)
-        assertStrDeprecated(self.assertNotIsInstance, Constant(None), Str)
-        assertBytesDeprecated(self.assertNotIsInstance, Constant(None), Bytes)
-        assertNameConstantDeprecated(
-            self.assertNotIsInstance, Constant(1), NameConstant
-        )
-        assertEllipsisDeprecated(self.assertNotIsInstance, Constant(None), Ellipsis)
-
-        class S(str):
-            pass
-
-        with assertStrDeprecated():
-            self.assertIsInstance(Constant(S("42")), Str)
-        with assertNumDeprecated():
-            self.assertNotIsInstance(Constant(S("42")), Num)
-
-    @unittest.expectedFailure # TODO: RUSTPYTHON; will be removed in Python 3.14
-    def test_constant_subclasses_deprecated(self):
-        with warnings.catch_warnings():
-            warnings.filterwarnings("ignore", "", DeprecationWarning)
-            from ast import Num
-
-        with warnings.catch_warnings(record=True) as wlog:
-            warnings.filterwarnings("always", "", DeprecationWarning)
-
-            class N(ast.Num):
-                def __init__(self, *args, **kwargs):
-                    super().__init__(*args, **kwargs)
-                    self.z = "spam"
-
-            class N2(ast.Num):
-                pass
-
-            n = N(42)
-            self.assertEqual(n.n, 42)
-            self.assertEqual(n.z, "spam")
-            self.assertIs(type(n), N)
-            self.assertIsInstance(n, N)
-            self.assertIsInstance(n, ast.Num)
-            self.assertNotIsInstance(n, N2)
-            self.assertNotIsInstance(ast.Num(42), N)
-            n = N(n=42)
-            self.assertEqual(n.n, 42)
-            self.assertIs(type(n), N)
-
-        self.assertEqual(
-            [str(w.message) for w in wlog],
-            [
-                "Attribute n is deprecated and will be removed in Python 3.14; use value instead",
-                "Attribute n is deprecated and will be removed in Python 3.14; use value instead",
-                "ast.Num is deprecated and will be removed in Python 3.14; use ast.Constant instead",
-                "ast.Num is deprecated and will be removed in Python 3.14; use ast.Constant instead",
-                "Attribute n is deprecated and will be removed in Python 3.14; use value instead",
-                "Attribute n is deprecated and will be removed in Python 3.14; use value instead",
-            ],
-        )
-
     def test_constant_subclasses(self):
         class N(ast.Constant):
             def __init__(self, *args, **kwargs):
                 super().__init__(*args, **kwargs)
-                self.z = "spam"
-
+                self.z = 'spam'
         class N2(ast.Constant):
             pass
 
         n = N(42)
         self.assertEqual(n.value, 42)
-        self.assertEqual(n.z, "spam")
+        self.assertEqual(n.z, 'spam')
         self.assertEqual(type(n), N)
         self.assertTrue(isinstance(n, N))
         self.assertTrue(isinstance(n, ast.Constant))
@@ -758,12 +529,11 @@ def test_module(self):
         x = ast.Module(body, [])
         self.assertEqual(x.body, body)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON; DeprecationWarning not triggered
     def test_nodeclasses(self):
         # Zero arguments constructor explicitly allowed (but deprecated)
         with self.assertWarns(DeprecationWarning):
             x = ast.BinOp()
-        self.assertEqual(x._fields, ("left", "op", "right"))
+        self.assertEqual(x._fields, ('left', 'op', 'right'))
 
         # Random attribute allowed too
         x.foobarbaz = 5
@@ -810,15 +580,14 @@ def test_no_fields(self):
         x = ast.Sub()
         self.assertEqual(x._fields, ())
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_invalid_sum(self):
         pos = dict(lineno=2, col_offset=3)
         m = ast.Module([ast.Expr(ast.expr(**pos), **pos)], [])
         with self.assertRaises(TypeError) as cm:
             compile(m, "<test>", "exec")
-        self.assertIn("but got <ast.expr", str(cm.exception))
+        self.assertIn("but got expr()", str(cm.exception))
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; ValueError: expected str for name
     def test_invalid_identifier(self):
         m = ast.Module([ast.Expr(ast.Name(42, ast.Load()))], [])
         ast.fix_missing_locations(m)
@@ -830,10 +599,12 @@ def test_invalid_constant(self):
         for invalid_constant in int, (1, 2, int), frozenset((1, 2, int)):
             e = ast.Expression(body=ast.Constant(invalid_constant))
             ast.fix_missing_locations(e)
-            with self.assertRaisesRegex(TypeError, "invalid type in Constant: type"):
+            with self.assertRaisesRegex(
+                TypeError, "invalid type in Constant: type"
+            ):
                 compile(e, "<test>", "eval")
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; TypeError: expected some sort of expr, but got None
     def test_empty_yield_from(self):
         # Issue 16546: yield from value is not optional.
         empty_yield_from = ast.parse("def f():\n yield from g()")
@@ -847,15 +618,13 @@ def test_issue31592(self):
         # There shouldn't be an assertion failure in case of a bad
         # unicodedata.normalize().
         import unicodedata
-
         def bad_normalize(*args):
             return None
-
-        with support.swap_attr(unicodedata, "normalize", bad_normalize):
-            self.assertRaises(TypeError, ast.parse, "\u03d5")
+        with support.swap_attr(unicodedata, 'normalize', bad_normalize):
+            self.assertRaises(TypeError, ast.parse, '\u03D5')
 
     def test_issue18374_binop_col_offset(self):
-        tree = ast.parse("4+5+6+7")
+        tree = ast.parse('4+5+6+7')
         parent_binop = tree.body[0].value
         child_binop = parent_binop.left
         grandchild_binop = child_binop.left
@@ -866,7 +635,7 @@ def test_issue18374_binop_col_offset(self):
         self.assertEqual(grandchild_binop.col_offset, 0)
         self.assertEqual(grandchild_binop.end_col_offset, 3)
 
-        tree = ast.parse("4+5-\\\n 6-7")
+        tree = ast.parse('4+5-\\\n 6-7')
         parent_binop = tree.body[0].value
         child_binop = parent_binop.left
         grandchild_binop = child_binop.left
@@ -886,62 +655,264 @@ def test_issue18374_binop_col_offset(self):
         self.assertEqual(grandchild_binop.end_lineno, 1)
 
     def test_issue39579_dotted_name_end_col_offset(self):
-        tree = ast.parse("@a.b.c\ndef f(): pass")
+        tree = ast.parse('@a.b.c\ndef f(): pass')
         attr_b = tree.body[0].decorator_list[0].value
         self.assertEqual(attr_b.end_col_offset, 4)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_ast_asdl_signature(self):
-        self.assertEqual(
-            ast.withitem.__doc__, "withitem(expr context_expr, expr? optional_vars)"
-        )
+        self.assertEqual(ast.withitem.__doc__, "withitem(expr context_expr, expr? optional_vars)")
         self.assertEqual(ast.GtE.__doc__, "GtE")
         self.assertEqual(ast.Name.__doc__, "Name(identifier id, expr_context ctx)")
-        self.assertEqual(
-            ast.cmpop.__doc__,
-            "cmpop = Eq | NotEq | Lt | LtE | Gt | GtE | Is | IsNot | In | NotIn",
-        )
+        self.assertEqual(ast.cmpop.__doc__, "cmpop = Eq | NotEq | Lt | LtE | Gt | GtE | Is | IsNot | In | NotIn")
         expressions = [f"     | {node.__doc__}" for node in ast.expr.__subclasses__()]
         expressions[0] = f"expr = {ast.expr.__subclasses__()[0].__doc__}"
         self.assertCountEqual(ast.expr.__doc__.split("\n"), expressions)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON; SyntaxError not raised
+    def test_compare_basics(self):
+        self.assertTrue(ast.compare(ast.parse("x = 10"), ast.parse("x = 10")))
+        self.assertFalse(ast.compare(ast.parse("x = 10"), ast.parse("")))
+        self.assertFalse(ast.compare(ast.parse("x = 10"), ast.parse("x")))
+        self.assertFalse(
+            ast.compare(ast.parse("x = 10;y = 20"), ast.parse("class C:pass"))
+        )
+
+    def test_compare_modified_ast(self):
+        # The ast API is a bit underspecified. The objects are mutable,
+        # and even _fields and _attributes are mutable. The compare() does
+        # some simple things to accommodate mutability.
+        a = ast.parse("m * x + b", mode="eval")
+        b = ast.parse("m * x + b", mode="eval")
+        self.assertTrue(ast.compare(a, b))
+
+        a._fields = a._fields + ("spam",)
+        a.spam = "Spam"
+        self.assertNotEqual(a._fields, b._fields)
+        self.assertFalse(ast.compare(a, b))
+        self.assertFalse(ast.compare(b, a))
+
+        b._fields = a._fields
+        b.spam = a.spam
+        self.assertTrue(ast.compare(a, b))
+        self.assertTrue(ast.compare(b, a))
+
+        b._attributes = b._attributes + ("eggs",)
+        b.eggs = "eggs"
+        self.assertNotEqual(a._attributes, b._attributes)
+        self.assertFalse(ast.compare(a, b, compare_attributes=True))
+        self.assertFalse(ast.compare(b, a, compare_attributes=True))
+
+        a._attributes = b._attributes
+        a.eggs = b.eggs
+        self.assertTrue(ast.compare(a, b, compare_attributes=True))
+        self.assertTrue(ast.compare(b, a, compare_attributes=True))
+
+    def test_compare_literals(self):
+        constants = (
+            -20,
+            20,
+            20.0,
+            1,
+            1.0,
+            True,
+            0,
+            False,
+            frozenset(),
+            tuple(),
+            "ABCD",
+            "abcd",
+            "中文字",
+            1e1000,
+            -1e1000,
+        )
+        for next_index, constant in enumerate(constants[:-1], 1):
+            next_constant = constants[next_index]
+            with self.subTest(literal=constant, next_literal=next_constant):
+                self.assertTrue(
+                    ast.compare(ast.Constant(constant), ast.Constant(constant))
+                )
+                self.assertFalse(
+                    ast.compare(
+                        ast.Constant(constant), ast.Constant(next_constant)
+                    )
+                )
+
+        same_looking_literal_cases = [
+            {1, 1.0, True, 1 + 0j},
+            {0, 0.0, False, 0 + 0j},
+        ]
+        for same_looking_literals in same_looking_literal_cases:
+            for literal in same_looking_literals:
+                for same_looking_literal in same_looking_literals - {literal}:
+                    self.assertFalse(
+                        ast.compare(
+                            ast.Constant(literal),
+                            ast.Constant(same_looking_literal),
+                        )
+                    )
+
+    def test_compare_fieldless(self):
+        self.assertTrue(ast.compare(ast.Add(), ast.Add()))
+        self.assertFalse(ast.compare(ast.Sub(), ast.Add()))
+
+        # test that missing runtime fields is handled in ast.compare()
+        a1, a2 = ast.Name('a'), ast.Name('a')
+        self.assertTrue(ast.compare(a1, a2))
+        self.assertTrue(ast.compare(a1, a2))
+        del a1.id
+        self.assertFalse(ast.compare(a1, a2))
+        del a2.id
+        self.assertTrue(ast.compare(a1, a2))
+
+    def test_compare_modes(self):
+        for mode, sources in (
+            ("exec", exec_tests),
+            ("eval", eval_tests),
+            ("single", single_tests),
+        ):
+            for source in sources:
+                a = ast.parse(source, mode=mode)
+                b = ast.parse(source, mode=mode)
+                self.assertTrue(
+                    ast.compare(a, b), f"{ast.dump(a)} != {ast.dump(b)}"
+                )
+
+    def test_compare_attributes_option(self):
+        def parse(a, b):
+            return ast.parse(a), ast.parse(b)
+
+        a, b = parse("2 + 2", "2+2")
+        self.assertTrue(ast.compare(a, b))
+        self.assertTrue(ast.compare(a, b, compare_attributes=False))
+        self.assertFalse(ast.compare(a, b, compare_attributes=True))
+
+    def test_compare_attributes_option_missing_attribute(self):
+        # test that missing runtime attributes is handled in ast.compare()
+        a1, a2 = ast.Name('a', lineno=1), ast.Name('a', lineno=1)
+        self.assertTrue(ast.compare(a1, a2))
+        self.assertTrue(ast.compare(a1, a2, compare_attributes=True))
+        del a1.lineno
+        self.assertFalse(ast.compare(a1, a2, compare_attributes=True))
+        del a2.lineno
+        self.assertTrue(ast.compare(a1, a2, compare_attributes=True))
+
     def test_positional_only_feature_version(self):
-        ast.parse("def foo(x, /): ...", feature_version=(3, 8))
-        ast.parse("def bar(x=1, /): ...", feature_version=(3, 8))
+        ast.parse('def foo(x, /): ...', feature_version=(3, 8))
+        ast.parse('def bar(x=1, /): ...', feature_version=(3, 8))
         with self.assertRaises(SyntaxError):
-            ast.parse("def foo(x, /): ...", feature_version=(3, 7))
+            ast.parse('def foo(x, /): ...', feature_version=(3, 7))
         with self.assertRaises(SyntaxError):
-            ast.parse("def bar(x=1, /): ...", feature_version=(3, 7))
+            ast.parse('def bar(x=1, /): ...', feature_version=(3, 7))
 
-        ast.parse("lambda x, /: ...", feature_version=(3, 8))
-        ast.parse("lambda x=1, /: ...", feature_version=(3, 8))
+        ast.parse('lambda x, /: ...', feature_version=(3, 8))
+        ast.parse('lambda x=1, /: ...', feature_version=(3, 8))
         with self.assertRaises(SyntaxError):
-            ast.parse("lambda x, /: ...", feature_version=(3, 7))
+            ast.parse('lambda x, /: ...', feature_version=(3, 7))
         with self.assertRaises(SyntaxError):
-            ast.parse("lambda x=1, /: ...", feature_version=(3, 7))
+            ast.parse('lambda x=1, /: ...', feature_version=(3, 7))
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON; SyntaxError not raised
     def test_assignment_expression_feature_version(self):
-        ast.parse("(x := 0)", feature_version=(3, 8))
+        ast.parse('(x := 0)', feature_version=(3, 8))
+        with self.assertRaises(SyntaxError):
+            ast.parse('(x := 0)', feature_version=(3, 7))
+
+    def test_pep750_tstring(self):
+        code = 't""'
+        ast.parse(code, feature_version=(3, 14))
+        with self.assertRaises(SyntaxError):
+            ast.parse(code, feature_version=(3, 13))
+
+    def test_pep758_except_without_parens(self):
+        code = textwrap.dedent("""
+            try:
+                ...
+            except ValueError, TypeError:
+                ...
+        """)
+        ast.parse(code, feature_version=(3, 14))
         with self.assertRaises(SyntaxError):
-            ast.parse("(x := 0)", feature_version=(3, 7))
+            ast.parse(code, feature_version=(3, 13))
+
+    def test_pep758_except_with_single_expr(self):
+        single_expr = textwrap.dedent("""
+            try:
+                ...
+            except{0} TypeError:
+                ...
+        """)
+
+        single_expr_with_as = textwrap.dedent("""
+            try:
+                ...
+            except{0} TypeError as exc:
+                ...
+        """)
+
+        single_tuple_expr = textwrap.dedent("""
+            try:
+                ...
+            except{0} (TypeError,):
+                ...
+        """)
+
+        single_tuple_expr_with_as = textwrap.dedent("""
+            try:
+                ...
+            except{0} (TypeError,) as exc:
+                ...
+        """)
+
+        single_parens_expr = textwrap.dedent("""
+            try:
+                ...
+            except{0} (TypeError):
+                ...
+        """)
+
+        single_parens_expr_with_as = textwrap.dedent("""
+            try:
+                ...
+            except{0} (TypeError) as exc:
+                ...
+        """)
+
+        for code in [
+            single_expr,
+            single_expr_with_as,
+            single_tuple_expr,
+            single_tuple_expr_with_as,
+            single_parens_expr,
+            single_parens_expr_with_as,
+        ]:
+            for star in [True, False]:
+                code = code.format('*' if star else '')
+                with self.subTest(code=code, star=star):
+                    ast.parse(code, feature_version=(3, 14))
+                    ast.parse(code, feature_version=(3, 13))
+
+    def test_pep758_except_star_without_parens(self):
+        code = textwrap.dedent("""
+            try:
+                ...
+            except* ValueError, TypeError:
+                ...
+        """)
+        ast.parse(code, feature_version=(3, 14))
+        with self.assertRaises(SyntaxError):
+            ast.parse(code, feature_version=(3, 13))
 
     def test_conditional_context_managers_parse_with_low_feature_version(self):
         # regression test for gh-115881
-        ast.parse("with (x() if y else z()): ...", feature_version=(3, 8))
+        ast.parse('with (x() if y else z()): ...', feature_version=(3, 8))
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON; SyntaxError not raised
     def test_exception_groups_feature_version(self):
-        code = dedent("""
+        code = dedent('''
         try: ...
         except* Exception: ...
-        """)
+        ''')
         ast.parse(code)
         with self.assertRaises(SyntaxError):
             ast.parse(code, feature_version=(3, 10))
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON; SyntaxError not raised
     def test_type_params_feature_version(self):
         samples = [
             "type X = int",
@@ -954,7 +925,7 @@ def test_type_params_feature_version(self):
                 with self.assertRaises(SyntaxError):
                     ast.parse(sample, feature_version=(3, 11))
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON; SyntaxError not raised
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; SyntaxError not raised
     def test_type_params_default_feature_version(self):
         samples = [
             "type X[*Ts=int] = int",
@@ -969,21 +940,18 @@ def test_type_params_default_feature_version(self):
 
     def test_invalid_major_feature_version(self):
         with self.assertRaises(ValueError):
-            ast.parse("pass", feature_version=(2, 7))
+            ast.parse('pass', feature_version=(2, 7))
         with self.assertRaises(ValueError):
-            ast.parse("pass", feature_version=(4, 0))
+            ast.parse('pass', feature_version=(4, 0))
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON; ValueError not raised
     def test_constant_as_name(self):
         for constant in "True", "False", "None":
             expr = ast.Expression(ast.Name(constant, ast.Load()))
             ast.fix_missing_locations(expr)
-            with self.assertRaisesRegex(
-                ValueError, f"identifier field can't represent '{constant}' constant"
-            ):
+            with self.assertRaisesRegex(ValueError, f"identifier field can't represent '{constant}' constant"):
                 compile(expr, "<test>", "eval")
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON; ValueError not raised
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; ValueError not raised
     def test_constant_as_unicode_name(self):
         constants = [
             ("True", b"Tru\xe1\xb5\x89"),
@@ -998,41 +966,41 @@ def test_constant_as_unicode_name(self):
     def test_precedence_enum(self):
         class _Precedence(enum.IntEnum):
             """Precedence table that originated from python grammar."""
-
-            NAMED_EXPR = enum.auto()  # <target> := <expr1>
-            TUPLE = enum.auto()  # <expr1>, <expr2>
-            YIELD = enum.auto()  # 'yield', 'yield from'
-            TEST = enum.auto()  # 'if'-'else', 'lambda'
-            OR = enum.auto()  # 'or'
-            AND = enum.auto()  # 'and'
-            NOT = enum.auto()  # 'not'
-            CMP = enum.auto()  # '<', '>', '==', '>=', '<=', '!=',
-            # 'in', 'not in', 'is', 'is not'
+            NAMED_EXPR = enum.auto()      # <target> := <expr1>
+            TUPLE = enum.auto()           # <expr1>, <expr2>
+            YIELD = enum.auto()           # 'yield', 'yield from'
+            TEST = enum.auto()            # 'if'-'else', 'lambda'
+            OR = enum.auto()              # 'or'
+            AND = enum.auto()             # 'and'
+            NOT = enum.auto()             # 'not'
+            CMP = enum.auto()             # '<', '>', '==', '>=', '<=', '!=',
+                                          # 'in', 'not in', 'is', 'is not'
             EXPR = enum.auto()
-            BOR = EXPR  # '|'
-            BXOR = enum.auto()  # '^'
-            BAND = enum.auto()  # '&'
-            SHIFT = enum.auto()  # '<<', '>>'
-            ARITH = enum.auto()  # '+', '-'
-            TERM = enum.auto()  # '*', '@', '/', '%', '//'
-            FACTOR = enum.auto()  # unary '+', '-', '~'
-            POWER = enum.auto()  # '**'
-            AWAIT = enum.auto()  # 'await'
+            BOR = EXPR                    # '|'
+            BXOR = enum.auto()            # '^'
+            BAND = enum.auto()            # '&'
+            SHIFT = enum.auto()           # '<<', '>>'
+            ARITH = enum.auto()           # '+', '-'
+            TERM = enum.auto()            # '*', '@', '/', '%', '//'
+            FACTOR = enum.auto()          # unary '+', '-', '~'
+            POWER = enum.auto()           # '**'
+            AWAIT = enum.auto()           # 'await'
             ATOM = enum.auto()
-
             def next(self):
                 try:
                     return self.__class__(self + 1)
                 except ValueError:
                     return self
-
-        enum._test_simple_enum(_Precedence, ast._Precedence)
+        enum._test_simple_enum(_Precedence, _ast_unparse._Precedence)
 
     @support.cpython_only
+    @skip_if_unlimited_stack_size
+    @skip_wasi_stack_overflow()
+    @skip_emscripten_stack_overflow()
     def test_ast_recursion_limit(self):
-        fail_depth = support.exceeds_recursion_limit()
-        crash_depth = 100_000
-        success_depth = int(support.get_c_recursion_limit() * 0.8)
+        # Android test devices have less memory.
+        crash_depth = 100_000 if sys.platform == "android" else 500_000
+        success_depth = 200
         if _testinternalcapi is not None:
             remaining = _testinternalcapi.get_c_recursion_remaining()
             success_depth = min(success_depth, remaining)
@@ -1040,12 +1008,13 @@ def test_ast_recursion_limit(self):
         def check_limit(prefix, repeated):
             expect_ok = prefix + repeated * success_depth
             ast.parse(expect_ok)
-            for depth in (fail_depth, crash_depth):
-                broken = prefix + repeated * depth
-                details = "Compiling ({!r} + {!r} * {})".format(prefix, repeated, depth)
-                with self.assertRaises(RecursionError, msg=details):
-                    with support.infinite_recursion():
-                        ast.parse(broken)
+
+            broken = prefix + repeated * crash_depth
+            details = "Compiling ({!r} + {!r} * {})".format(
+                        prefix, repeated, crash_depth)
+            with self.assertRaises(RecursionError, msg=details):
+                with support.infinite_recursion():
+                    ast.parse(broken)
 
         check_limit("a", "()")
         check_limit("a", ".b")
@@ -1053,9 +1022,8 @@ def check_limit(prefix, repeated):
         check_limit("a", "*a")
 
     def test_null_bytes(self):
-        with self.assertRaises(
-            SyntaxError, msg="source code string cannot contain null bytes"
-        ):
+        with self.assertRaises(SyntaxError,
+            msg="source code string cannot contain null bytes"):
             ast.parse("a\0b")
 
     def assert_none_check(self, node: type[ast.AST], attr: str, source: str) -> None:
@@ -1071,7 +1039,7 @@ def assert_none_check(self, node: type[ast.AST], attr: str, source: str) -> None
             with self.assertRaisesRegex(ValueError, f"^{e}$"):
                 compile(tree, "<test>", "exec")
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON; TypeError: expected some sort of expr, but got None
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; TypeError: expected some sort of expr, but got None
     def test_none_checks(self) -> None:
         tests = [
             (ast.alias, "name", "import spam as SPAM"),
@@ -1085,11 +1053,63 @@ def test_none_checks(self) -> None:
         for node, attr, source in tests:
             self.assert_none_check(node, attr, source)
 
+    def test_repr(self) -> None:
+        snapshots = AST_REPR_DATA_FILE.read_text().split("\n")
+        for test, snapshot in zip(ast_repr_get_test_cases(), snapshots, strict=True):
+            with self.subTest(test_input=test):
+                self.assertEqual(repr(ast.parse(test)), snapshot)
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AssertionError: ValueError not raised
+    def test_repr_large_input_crash(self):
+        # gh-125010: Fix use-after-free in ast repr()
+        source = "0x0" + "e" * 10_000
+        with self.assertRaisesRegex(ValueError,
+                                    r"Exceeds the limit \(\d+ digits\)"):
+            repr(ast.Constant(value=eval(source)))
+
+    def test_tstring(self):
+        # Test AST structure for simple t-string
+        tree = ast.parse('t"Hello"')
+        self.assertIsInstance(tree.body[0].value, ast.TemplateStr)
+        self.assertIsInstance(tree.body[0].value.values[0], ast.Constant)
+
+        # Test AST for t-string with interpolation
+        tree = ast.parse('t"Hello {name}"')
+        self.assertIsInstance(tree.body[0].value, ast.TemplateStr)
+        self.assertIsInstance(tree.body[0].value.values[0], ast.Constant)
+        self.assertIsInstance(tree.body[0].value.values[1], ast.Interpolation)
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; ValueError: compile() unrecognized flags
+    def test_optimization_levels_const_folding(self):
+        return super().test_optimization_levels_const_folding()
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; will be removed in Python 3.14
+    def test_constant_subclasses_deprecated(self):
+        return super().test_constant_subclasses_deprecated()
+
 
 class CopyTests(unittest.TestCase):
     """Test copying and pickling AST nodes."""
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @staticmethod
+    def iter_ast_classes():
+        """Iterate over the (native) subclasses of ast.AST recursively.
+
+        This excludes the special class ast.Index since its constructor
+        returns an integer.
+        """
+        def do(cls):
+            if cls.__module__ != 'ast':
+                return
+            if cls is ast.Index:
+                return
+
+            yield cls
+            for sub in cls.__subclasses__():
+                yield from do(sub)
+
+        yield from do(ast.AST)
+
     def test_pickling(self):
         import pickle
 
@@ -1100,6 +1120,7 @@ def test_pickling(self):
                     ast2 = pickle.loads(pickle.dumps(tree, protocol))
                     self.assertEqual(to_tuple(ast2), to_tuple(tree))
 
+    @skip_if_unlimited_stack_size
     def test_copy_with_parents(self):
         # gh-120108
         code = """
@@ -1154,66 +1175,317 @@ def test_copy_with_parents(self):
 
         for node in ast.walk(tree2):
             for child in ast.iter_child_nodes(node):
-                if hasattr(child, "parent") and not isinstance(
-                    child,
-                    (
-                        ast.expr_context,
-                        ast.boolop,
-                        ast.unaryop,
-                        ast.cmpop,
-                        ast.operator,
-                    ),
-                ):
+                if hasattr(child, "parent") and not isinstance(child, (
+                    ast.expr_context, ast.boolop, ast.unaryop, ast.cmpop, ast.operator,
+                )):
                     self.assertEqual(to_tuple(child.parent), to_tuple(node))
 
+    def test_replace_interface(self):
+        for klass in self.iter_ast_classes():
+            with self.subTest(klass=klass):
+                self.assertHasAttr(klass, '__replace__')
+
+            fields = set(klass._fields)
+            with self.subTest(klass=klass, fields=fields):
+                node = klass(**dict.fromkeys(fields))
+                # forbid positional arguments in replace()
+                self.assertRaises(TypeError, copy.replace, node, 1)
+                self.assertRaises(TypeError, node.__replace__, 1)
+
+    def test_replace_native(self):
+        for klass in self.iter_ast_classes():
+            fields = set(klass._fields)
+            attributes = set(klass._attributes)
+
+            with self.subTest(klass=klass, fields=fields, attributes=attributes):
+                # use of object() to ensure that '==' and 'is'
+                # behave similarly in ast.compare(node, repl)
+                old_fields = {field: object() for field in fields}
+                old_attrs = {attr: object() for attr in attributes}
+
+                # check shallow copy
+                node = klass(**old_fields)
+                repl = copy.replace(node)
+                self.assertTrue(ast.compare(node, repl, compare_attributes=True))
+                # check when passing using attributes (they may be optional!)
+                node = klass(**old_fields, **old_attrs)
+                repl = copy.replace(node)
+                self.assertTrue(ast.compare(node, repl, compare_attributes=True))
+
+                for field in fields:
+                    # check when we sometimes have attributes and sometimes not
+                    for init_attrs in [{}, old_attrs]:
+                        node = klass(**old_fields, **init_attrs)
+                        # only change a single field (do not change attributes)
+                        new_value = object()
+                        repl = copy.replace(node, **{field: new_value})
+                        for f in fields:
+                            old_value = old_fields[f]
+                            # assert that there is no side-effect
+                            self.assertIs(getattr(node, f), old_value)
+                            # check the changes
+                            if f != field:
+                                self.assertIs(getattr(repl, f), old_value)
+                            else:
+                                self.assertIs(getattr(repl, f), new_value)
+                        self.assertFalse(ast.compare(node, repl, compare_attributes=True))
+
+                for attribute in attributes:
+                    node = klass(**old_fields, **old_attrs)
+                    # only change a single attribute (do not change fields)
+                    new_attr = object()
+                    repl = copy.replace(node, **{attribute: new_attr})
+                    for a in attributes:
+                        old_attr = old_attrs[a]
+                        # assert that there is no side-effect
+                        self.assertIs(getattr(node, a), old_attr)
+                        # check the changes
+                        if a != attribute:
+                            self.assertIs(getattr(repl, a), old_attr)
+                        else:
+                            self.assertIs(getattr(repl, a), new_attr)
+                    self.assertFalse(ast.compare(node, repl, compare_attributes=True))
+
+    def test_replace_accept_known_class_fields(self):
+        nid, ctx = object(), object()
+
+        node = ast.Name(id=nid, ctx=ctx)
+        self.assertIs(node.id, nid)
+        self.assertIs(node.ctx, ctx)
+
+        new_nid = object()
+        repl = copy.replace(node, id=new_nid)
+        # assert that there is no side-effect
+        self.assertIs(node.id, nid)
+        self.assertIs(node.ctx, ctx)
+        # check the changes
+        self.assertIs(repl.id, new_nid)
+        self.assertIs(repl.ctx, node.ctx)  # no changes
+
+    def test_replace_accept_known_class_attributes(self):
+        node = ast.parse('x').body[0].value
+        self.assertEqual(node.id, 'x')
+        self.assertEqual(node.lineno, 1)
+
+        # constructor allows any type so replace() should do the same
+        lineno = object()
+        repl = copy.replace(node, lineno=lineno)
+        # assert that there is no side-effect
+        self.assertEqual(node.lineno, 1)
+        # check the changes
+        self.assertEqual(repl.id, node.id)
+        self.assertEqual(repl.ctx, node.ctx)
+        self.assertEqual(repl.lineno, lineno)
+
+        _, _, state = node.__reduce__()
+        self.assertEqual(state['id'], 'x')
+        self.assertEqual(state['ctx'], node.ctx)
+        self.assertEqual(state['lineno'], 1)
+
+        _, _, state = repl.__reduce__()
+        self.assertEqual(state['id'], 'x')
+        self.assertEqual(state['ctx'], node.ctx)
+        self.assertEqual(state['lineno'], lineno)
+
+    def test_replace_accept_known_custom_class_fields(self):
+        class MyNode(ast.AST):
+            _fields = ('name', 'data')
+            __annotations__ = {'name': str, 'data': object}
+            __match_args__ = ('name', 'data')
+
+        name, data = 'name', object()
+
+        node = MyNode(name, data)
+        self.assertIs(node.name, name)
+        self.assertIs(node.data, data)
+        # check shallow copy
+        repl = copy.replace(node)
+        # assert that there is no side-effect
+        self.assertIs(node.name, name)
+        self.assertIs(node.data, data)
+        # check the shallow copy
+        self.assertIs(repl.name, name)
+        self.assertIs(repl.data, data)
+
+        node = MyNode(name, data)
+        repl_data = object()
+        # replace custom but known field
+        repl = copy.replace(node, data=repl_data)
+        # assert that there is no side-effect
+        self.assertIs(node.name, name)
+        self.assertIs(node.data, data)
+        # check the changes
+        self.assertIs(repl.name, node.name)
+        self.assertIs(repl.data, repl_data)
+
+    def test_replace_accept_known_custom_class_attributes(self):
+        class MyNode(ast.AST):
+            x = 0
+            y = 1
+            _attributes = ('x', 'y')
+
+        node = MyNode()
+        self.assertEqual(node.x, 0)
+        self.assertEqual(node.y, 1)
+
+        y = object()
+        repl = copy.replace(node, y=y)
+        # assert that there is no side-effect
+        self.assertEqual(node.x, 0)
+        self.assertEqual(node.y, 1)
+        # check the changes
+        self.assertEqual(repl.x, 0)
+        self.assertEqual(repl.y, y)
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AssertionError: 'x' is not 'x'
+    def test_replace_ignore_known_custom_instance_fields(self):
+        node = ast.parse('x').body[0].value
+        node.extra = extra = object()  # add instance 'extra' field
+        context = node.ctx
+
+        # assert initial values
+        self.assertIs(node.id, 'x')
+        self.assertIs(node.ctx, context)
+        self.assertIs(node.extra, extra)
+        # shallow copy, but drops extra fields
+        repl = copy.replace(node)
+        # assert that there is no side-effect
+        self.assertIs(node.id, 'x')
+        self.assertIs(node.ctx, context)
+        self.assertIs(node.extra, extra)
+        # verify that the 'extra' field is not kept
+        self.assertIs(repl.id, 'x')
+        self.assertIs(repl.ctx, context)
+        self.assertRaises(AttributeError, getattr, repl, 'extra')
+
+        # change known native field
+        repl = copy.replace(node, id='y')
+        # assert that there is no side-effect
+        self.assertIs(node.id, 'x')
+        self.assertIs(node.ctx, context)
+        self.assertIs(node.extra, extra)
+        # verify that the 'extra' field is not kept
+        self.assertIs(repl.id, 'y')
+        self.assertIs(repl.ctx, context)
+        self.assertRaises(AttributeError, getattr, repl, 'extra')
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AssertionError: "Name\.__replace__\ missing\ 1\ keyword\ argument:\ 'id'\." does not match "replace() does not support Name objects"
+    def test_replace_reject_missing_field(self):
+        # case: warn if deleted field is not replaced
+        node = ast.parse('x').body[0].value
+        context = node.ctx
+        del node.id
+
+        self.assertRaises(AttributeError, getattr, node, 'id')
+        self.assertIs(node.ctx, context)
+        msg = "Name.__replace__ missing 1 keyword argument: 'id'."
+        with self.assertRaisesRegex(TypeError, re.escape(msg)):
+            copy.replace(node)
+        # assert that there is no side-effect
+        self.assertRaises(AttributeError, getattr, node, 'id')
+        self.assertIs(node.ctx, context)
+
+        # case: do not raise if deleted field is replaced
+        node = ast.parse('x').body[0].value
+        context = node.ctx
+        del node.id
+
+        self.assertRaises(AttributeError, getattr, node, 'id')
+        self.assertIs(node.ctx, context)
+        repl = copy.replace(node, id='y')
+        # assert that there is no side-effect
+        self.assertRaises(AttributeError, getattr, node, 'id')
+        self.assertIs(node.ctx, context)
+        self.assertIs(repl.id, 'y')
+        self.assertIs(repl.ctx, context)
+
+    def test_replace_accept_missing_field_with_default(self):
+        node = ast.FunctionDef(name="foo", args=ast.arguments())
+        self.assertIs(node.returns, None)
+        self.assertEqual(node.decorator_list, [])
+        node2 = copy.replace(node, name="bar")
+        self.assertEqual(node2.name, "bar")
+        self.assertIs(node2.returns, None)
+        self.assertEqual(node2.decorator_list, [])
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AssertionError: "Name\.__replace__\ got\ an\ unexpected\ keyword\ argument\ 'extra'\." does not match "replace() does not support Name objects"
+    def test_replace_reject_known_custom_instance_fields_commits(self):
+        node = ast.parse('x').body[0].value
+        node.extra = extra = object()  # add instance 'extra' field
+        context = node.ctx
+
+        # explicit rejection of known instance fields
+        self.assertHasAttr(node, 'extra')
+        msg = "Name.__replace__ got an unexpected keyword argument 'extra'."
+        with self.assertRaisesRegex(TypeError, re.escape(msg)):
+            copy.replace(node, extra=1)
+        # assert that there is no side-effect
+        self.assertIs(node.id, 'x')
+        self.assertIs(node.ctx, context)
+        self.assertIs(node.extra, extra)
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AssertionError: "Name\.__replace__\ got\ an\ unexpected\ keyword\ argument\ 'unknown'\." does not match "replace() does not support Name objects"
+    def test_replace_reject_unknown_instance_fields(self):
+        node = ast.parse('x').body[0].value
+        context = node.ctx
+
+        # explicit rejection of unknown extra fields
+        self.assertRaises(AttributeError, getattr, node, 'unknown')
+        msg = "Name.__replace__ got an unexpected keyword argument 'unknown'."
+        with self.assertRaisesRegex(TypeError, re.escape(msg)):
+            copy.replace(node, unknown=1)
+        # assert that there is no side-effect
+        self.assertIs(node.id, 'x')
+        self.assertIs(node.ctx, context)
+        self.assertRaises(AttributeError, getattr, node, 'unknown')
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; Wrong error message
+    def test_replace_non_str_kwarg(self):
+        node = ast.Name(id="x")
+        errmsg = "got an unexpected keyword argument <object object"
+        with self.assertRaisesRegex(TypeError, errmsg):
+            node.__replace__(**{object(): "y"})
+
 
 class ASTHelpers_Test(unittest.TestCase):
     maxDiff = None
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_parse(self):
-        a = ast.parse("foo(1 + 1)")
-        b = compile("foo(1 + 1)", "<unknown>", "exec", ast.PyCF_ONLY_AST)
+        a = ast.parse('foo(1 + 1)')
+        b = compile('foo(1 + 1)', '<unknown>', 'exec', ast.PyCF_ONLY_AST)
         self.assertEqual(ast.dump(a), ast.dump(b))
 
     def test_parse_in_error(self):
         try:
-            1 / 0
+            1/0
         except Exception:
             with self.assertRaises(SyntaxError) as e:
                 ast.literal_eval(r"'\U'")
             self.assertIsNotNone(e.exception.__context__)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_dump(self):
         node = ast.parse('spam(eggs, "and cheese")')
-        self.assertEqual(
-            ast.dump(node),
+        self.assertEqual(ast.dump(node),
             "Module(body=[Expr(value=Call(func=Name(id='spam', ctx=Load()), "
-            "args=[Name(id='eggs', ctx=Load()), Constant(value='and cheese')]))])",
+            "args=[Name(id='eggs', ctx=Load()), Constant(value='and cheese')]))])"
         )
-        self.assertEqual(
-            ast.dump(node, annotate_fields=False),
+        self.assertEqual(ast.dump(node, annotate_fields=False),
             "Module([Expr(Call(Name('spam', Load()), [Name('eggs', Load()), "
-            "Constant('and cheese')]))])",
+            "Constant('and cheese')]))])"
         )
-        self.assertEqual(
-            ast.dump(node, include_attributes=True),
+        self.assertEqual(ast.dump(node, include_attributes=True),
             "Module(body=[Expr(value=Call(func=Name(id='spam', ctx=Load(), "
             "lineno=1, col_offset=0, end_lineno=1, end_col_offset=4), "
             "args=[Name(id='eggs', ctx=Load(), lineno=1, col_offset=5, "
             "end_lineno=1, end_col_offset=9), Constant(value='and cheese', "
             "lineno=1, col_offset=11, end_lineno=1, end_col_offset=23)], "
             "lineno=1, col_offset=0, end_lineno=1, end_col_offset=24), "
-            "lineno=1, col_offset=0, end_lineno=1, end_col_offset=24)])",
+            "lineno=1, col_offset=0, end_lineno=1, end_col_offset=24)])"
         )
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_dump_indent(self):
         node = ast.parse('spam(eggs, "and cheese")')
-        self.assertEqual(
-            ast.dump(node, indent=3),
-            """\
+        self.assertEqual(ast.dump(node, indent=3), """\
 Module(
    body=[
       Expr(
@@ -1221,11 +1493,8 @@ def test_dump_indent(self):
             func=Name(id='spam', ctx=Load()),
             args=[
                Name(id='eggs', ctx=Load()),
-               Constant(value='and cheese')]))])""",
-        )
-        self.assertEqual(
-            ast.dump(node, annotate_fields=False, indent="\t"),
-            """\
+               Constant(value='and cheese')]))])""")
+        self.assertEqual(ast.dump(node, annotate_fields=False, indent='\t'), """\
 Module(
 \t[
 \t\tExpr(
@@ -1233,11 +1502,8 @@ def test_dump_indent(self):
 \t\t\t\tName('spam', Load()),
 \t\t\t\t[
 \t\t\t\t\tName('eggs', Load()),
-\t\t\t\t\tConstant('and cheese')]))])""",
-        )
-        self.assertEqual(
-            ast.dump(node, include_attributes=True, indent=3),
-            """\
+\t\t\t\t\tConstant('and cheese')]))])""")
+        self.assertEqual(ast.dump(node, include_attributes=True, indent=3), """\
 Module(
    body=[
       Expr(
@@ -1270,78 +1536,72 @@ def test_dump_indent(self):
          lineno=1,
          col_offset=0,
          end_lineno=1,
-         end_col_offset=24)])""",
-        )
+         end_col_offset=24)])""")
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_dump_incomplete(self):
         node = ast.Raise(lineno=3, col_offset=4)
-        self.assertEqual(ast.dump(node), "Raise()")
-        self.assertEqual(
-            ast.dump(node, include_attributes=True), "Raise(lineno=3, col_offset=4)"
+        self.assertEqual(ast.dump(node),
+            "Raise()"
+        )
+        self.assertEqual(ast.dump(node, include_attributes=True),
+            "Raise(lineno=3, col_offset=4)"
+        )
+        node = ast.Raise(exc=ast.Name(id='e', ctx=ast.Load()), lineno=3, col_offset=4)
+        self.assertEqual(ast.dump(node),
+            "Raise(exc=Name(id='e', ctx=Load()))"
         )
-        node = ast.Raise(exc=ast.Name(id="e", ctx=ast.Load()), lineno=3, col_offset=4)
-        self.assertEqual(ast.dump(node), "Raise(exc=Name(id='e', ctx=Load()))")
-        self.assertEqual(
-            ast.dump(node, annotate_fields=False), "Raise(Name('e', Load()))"
+        self.assertEqual(ast.dump(node, annotate_fields=False),
+            "Raise(Name('e', Load()))"
         )
-        self.assertEqual(
-            ast.dump(node, include_attributes=True),
-            "Raise(exc=Name(id='e', ctx=Load()), lineno=3, col_offset=4)",
+        self.assertEqual(ast.dump(node, include_attributes=True),
+            "Raise(exc=Name(id='e', ctx=Load()), lineno=3, col_offset=4)"
         )
-        self.assertEqual(
-            ast.dump(node, annotate_fields=False, include_attributes=True),
-            "Raise(Name('e', Load()), lineno=3, col_offset=4)",
+        self.assertEqual(ast.dump(node, annotate_fields=False, include_attributes=True),
+            "Raise(Name('e', Load()), lineno=3, col_offset=4)"
         )
-        node = ast.Raise(cause=ast.Name(id="e", ctx=ast.Load()))
-        self.assertEqual(ast.dump(node), "Raise(cause=Name(id='e', ctx=Load()))")
-        self.assertEqual(
-            ast.dump(node, annotate_fields=False), "Raise(cause=Name('e', Load()))"
+        node = ast.Raise(cause=ast.Name(id='e', ctx=ast.Load()))
+        self.assertEqual(ast.dump(node),
+            "Raise(cause=Name(id='e', ctx=Load()))"
+        )
+        self.assertEqual(ast.dump(node, annotate_fields=False),
+            "Raise(cause=Name('e', Load()))"
         )
         # Arguments:
         node = ast.arguments(args=[ast.arg("x")])
-        self.assertEqual(
-            ast.dump(node, annotate_fields=False),
+        self.assertEqual(ast.dump(node, annotate_fields=False),
             "arguments([], [arg('x')])",
         )
         node = ast.arguments(posonlyargs=[ast.arg("x")])
-        self.assertEqual(
-            ast.dump(node, annotate_fields=False),
+        self.assertEqual(ast.dump(node, annotate_fields=False),
             "arguments([arg('x')])",
         )
-        node = ast.arguments(posonlyargs=[ast.arg("x")], kwonlyargs=[ast.arg("y")])
-        self.assertEqual(
-            ast.dump(node, annotate_fields=False),
+        node = ast.arguments(posonlyargs=[ast.arg("x")], kwonlyargs=[ast.arg('y')])
+        self.assertEqual(ast.dump(node, annotate_fields=False),
             "arguments([arg('x')], kwonlyargs=[arg('y')])",
         )
-        node = ast.arguments(args=[ast.arg("x")], kwonlyargs=[ast.arg("y")])
-        self.assertEqual(
-            ast.dump(node, annotate_fields=False),
+        node = ast.arguments(args=[ast.arg("x")], kwonlyargs=[ast.arg('y')])
+        self.assertEqual(ast.dump(node, annotate_fields=False),
             "arguments([], [arg('x')], kwonlyargs=[arg('y')])",
         )
         node = ast.arguments()
-        self.assertEqual(
-            ast.dump(node, annotate_fields=False),
+        self.assertEqual(ast.dump(node, annotate_fields=False),
             "arguments()",
         )
         # Classes:
         node = ast.ClassDef(
-            "T",
+            'T',
             [],
-            [ast.keyword("a", ast.Constant(None))],
+            [ast.keyword('a', ast.Constant(None))],
             [],
-            [ast.Name("dataclass", ctx=ast.Load())],
+            [ast.Name('dataclass', ctx=ast.Load())],
         )
-        self.assertEqual(
-            ast.dump(node),
+        self.assertEqual(ast.dump(node),
             "ClassDef(name='T', keywords=[keyword(arg='a', value=Constant(value=None))], decorator_list=[Name(id='dataclass', ctx=Load())])",
         )
-        self.assertEqual(
-            ast.dump(node, annotate_fields=False),
+        self.assertEqual(ast.dump(node, annotate_fields=False),
             "ClassDef('T', [], [keyword('a', Constant(None))], [], [Name('dataclass', Load())])",
         )
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_dump_show_empty(self):
         def check_node(node, empty, full, **kwargs):
             with self.subTest(show_empty=False):
@@ -1366,7 +1626,7 @@ def check_text(code, empty, full, **kwargs):
 
         check_node(
             # Corner case: there are no real `Name` instances with `id=''`:
-            ast.Name(id="", ctx=ast.Load()),
+            ast.Name(id='', ctx=ast.Load()),
             empty="Name(id='', ctx=Load())",
             full="Name(id='', ctx=Load())",
         )
@@ -1396,11 +1656,23 @@ def check_text(code, empty, full, **kwargs):
         )
 
         check_node(
-            ast.Constant(value=""),
+            ast.Constant(value=''),
             empty="Constant(value='')",
             full="Constant(value='')",
         )
 
+        check_node(
+            ast.Interpolation(value=ast.Constant(42), str=None, conversion=-1),
+            empty="Interpolation(value=Constant(value=42), str=None, conversion=-1)",
+            full="Interpolation(value=Constant(value=42), str=None, conversion=-1)",
+        )
+
+        check_node(
+            ast.Interpolation(value=ast.Constant(42), str=[], conversion=-1),
+            empty="Interpolation(value=Constant(value=42), str=[], conversion=-1)",
+            full="Interpolation(value=Constant(value=42), str=[], conversion=-1)",
+        )
+
         check_text(
             "def a(b: int = 0, *, c): ...",
             empty="Module(body=[FunctionDef(name='a', args=arguments(args=[arg(arg='b', annotation=Name(id='int', ctx=Load()))], kwonlyargs=[arg(arg='c')], kw_defaults=[None], defaults=[Constant(value=0)]), body=[Expr(value=Constant(value=Ellipsis))])])",
@@ -1432,37 +1704,31 @@ def check_text(code, empty, full, **kwargs):
             full="Module(body=[Import(names=[alias(name='_ast', asname='ast')]), ImportFrom(module='module', names=[alias(name='sub')], level=0)], type_ignores=[])",
         )
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; ?                                              ^^^^^^^^^                                                                                  ^^^^^^^^^
     def test_copy_location(self):
-        src = ast.parse("1 + 1", mode="eval")
+        src = ast.parse('1 + 1', mode='eval')
         src.body.right = ast.copy_location(ast.Constant(2), src.body.right)
-        self.assertEqual(
-            ast.dump(src, include_attributes=True),
-            "Expression(body=BinOp(left=Constant(value=1, lineno=1, col_offset=0, "
-            "end_lineno=1, end_col_offset=1), op=Add(), right=Constant(value=2, "
-            "lineno=1, col_offset=4, end_lineno=1, end_col_offset=5), lineno=1, "
-            "col_offset=0, end_lineno=1, end_col_offset=5))",
-        )
-        func = ast.Name("spam", ast.Load())
-        src = ast.Call(
-            col_offset=1, lineno=1, end_lineno=1, end_col_offset=1, func=func
-        )
+        self.assertEqual(ast.dump(src, include_attributes=True),
+            'Expression(body=BinOp(left=Constant(value=1, lineno=1, col_offset=0, '
+            'end_lineno=1, end_col_offset=1), op=Add(), right=Constant(value=2, '
+            'lineno=1, col_offset=4, end_lineno=1, end_col_offset=5), lineno=1, '
+            'col_offset=0, end_lineno=1, end_col_offset=5))'
+        )
+        func = ast.Name('spam', ast.Load())
+        src = ast.Call(col_offset=1, lineno=1, end_lineno=1, end_col_offset=1, func=func)
         new = ast.copy_location(src, ast.Call(col_offset=None, lineno=None, func=func))
         self.assertIsNone(new.end_lineno)
         self.assertIsNone(new.end_col_offset)
         self.assertEqual(new.lineno, 1)
         self.assertEqual(new.col_offset, 1)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_fix_missing_locations(self):
         src = ast.parse('write("spam")')
-        src.body.append(
-            ast.Expr(ast.Call(ast.Name("spam", ast.Load()), [ast.Constant("eggs")], []))
-        )
+        src.body.append(ast.Expr(ast.Call(ast.Name('spam', ast.Load()),
+                                          [ast.Constant('eggs')], [])))
         self.assertEqual(src, ast.fix_missing_locations(src))
         self.maxDiff = None
-        self.assertEqual(
-            ast.dump(src, include_attributes=True),
+        self.assertEqual(ast.dump(src, include_attributes=True),
             "Module(body=[Expr(value=Call(func=Name(id='write', ctx=Load(), "
             "lineno=1, col_offset=0, end_lineno=1, end_col_offset=5), "
             "args=[Constant(value='spam', lineno=1, col_offset=6, end_lineno=1, "
@@ -1472,29 +1738,27 @@ def test_fix_missing_locations(self):
             "lineno=1, col_offset=0, end_lineno=1, end_col_offset=0), "
             "args=[Constant(value='eggs', lineno=1, col_offset=0, end_lineno=1, "
             "end_col_offset=0)], lineno=1, col_offset=0, end_lineno=1, "
-            "end_col_offset=0), lineno=1, col_offset=0, end_lineno=1, end_col_offset=0)])",
+            "end_col_offset=0), lineno=1, col_offset=0, end_lineno=1, end_col_offset=0)])"
         )
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; ?                                              ^^^^^^^^^                                                                                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
     def test_increment_lineno(self):
-        src = ast.parse("1 + 1", mode="eval")
+        src = ast.parse('1 + 1', mode='eval')
         self.assertEqual(ast.increment_lineno(src, n=3), src)
-        self.assertEqual(
-            ast.dump(src, include_attributes=True),
-            "Expression(body=BinOp(left=Constant(value=1, lineno=4, col_offset=0, "
-            "end_lineno=4, end_col_offset=1), op=Add(), right=Constant(value=1, "
-            "lineno=4, col_offset=4, end_lineno=4, end_col_offset=5), lineno=4, "
-            "col_offset=0, end_lineno=4, end_col_offset=5))",
+        self.assertEqual(ast.dump(src, include_attributes=True),
+            'Expression(body=BinOp(left=Constant(value=1, lineno=4, col_offset=0, '
+            'end_lineno=4, end_col_offset=1), op=Add(), right=Constant(value=1, '
+            'lineno=4, col_offset=4, end_lineno=4, end_col_offset=5), lineno=4, '
+            'col_offset=0, end_lineno=4, end_col_offset=5))'
         )
         # issue10869: do not increment lineno of root twice
-        src = ast.parse("1 + 1", mode="eval")
+        src = ast.parse('1 + 1', mode='eval')
         self.assertEqual(ast.increment_lineno(src.body, n=3), src.body)
-        self.assertEqual(
-            ast.dump(src, include_attributes=True),
-            "Expression(body=BinOp(left=Constant(value=1, lineno=4, col_offset=0, "
-            "end_lineno=4, end_col_offset=1), op=Add(), right=Constant(value=1, "
-            "lineno=4, col_offset=4, end_lineno=4, end_col_offset=5), lineno=4, "
-            "col_offset=0, end_lineno=4, end_col_offset=5))",
+        self.assertEqual(ast.dump(src, include_attributes=True),
+            'Expression(body=BinOp(left=Constant(value=1, lineno=4, col_offset=0, '
+            'end_lineno=4, end_col_offset=1), op=Add(), right=Constant(value=1, '
+            'lineno=4, col_offset=4, end_lineno=4, end_col_offset=5), lineno=4, '
+            'col_offset=0, end_lineno=4, end_col_offset=5))'
         )
         src = ast.Call(
             func=ast.Name("test", ast.Load()), args=[], keywords=[], lineno=1
@@ -1502,85 +1766,82 @@ def test_increment_lineno(self):
         self.assertEqual(ast.increment_lineno(src).lineno, 2)
         self.assertIsNone(ast.increment_lineno(src).end_lineno)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON; IndexError: index out of range
     def test_increment_lineno_on_module(self):
-        src = ast.parse(
-            dedent("""\
+        src = ast.parse(dedent("""\
         a = 1
         b = 2 # type: ignore
         c = 3
         d = 4 # type: ignore@tag
-        """),
-            type_comments=True,
-        )
+        """), type_comments=True)
         ast.increment_lineno(src, n=5)
         self.assertEqual(src.type_ignores[0].lineno, 7)
         self.assertEqual(src.type_ignores[1].lineno, 9)
-        self.assertEqual(src.type_ignores[1].tag, "@tag")
+        self.assertEqual(src.type_ignores[1].tag, '@tag')
 
     def test_iter_fields(self):
-        node = ast.parse("foo()", mode="eval")
+        node = ast.parse('foo()', mode='eval')
         d = dict(ast.iter_fields(node.body))
-        self.assertEqual(d.pop("func").id, "foo")
-        self.assertEqual(d, {"keywords": [], "args": []})
+        self.assertEqual(d.pop('func').id, 'foo')
+        self.assertEqual(d, {'keywords': [], 'args': []})
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_iter_child_nodes(self):
-        node = ast.parse("spam(23, 42, eggs='leek')", mode="eval")
+        node = ast.parse("spam(23, 42, eggs='leek')", mode='eval')
         self.assertEqual(len(list(ast.iter_child_nodes(node.body))), 4)
         iterator = ast.iter_child_nodes(node.body)
-        self.assertEqual(next(iterator).id, "spam")
+        self.assertEqual(next(iterator).id, 'spam')
         self.assertEqual(next(iterator).value, 23)
         self.assertEqual(next(iterator).value, 42)
-        self.assertEqual(
-            ast.dump(next(iterator)),
-            "keyword(arg='eggs', value=Constant(value='leek'))",
+        self.assertEqual(ast.dump(next(iterator)),
+            "keyword(arg='eggs', value=Constant(value='leek'))"
         )
 
     def test_get_docstring(self):
         node = ast.parse('"""line one\n  line two"""')
-        self.assertEqual(ast.get_docstring(node), "line one\nline two")
+        self.assertEqual(ast.get_docstring(node),
+                         'line one\nline two')
 
         node = ast.parse('class foo:\n  """line one\n  line two"""')
-        self.assertEqual(ast.get_docstring(node.body[0]), "line one\nline two")
+        self.assertEqual(ast.get_docstring(node.body[0]),
+                         'line one\nline two')
 
         node = ast.parse('def foo():\n  """line one\n  line two"""')
-        self.assertEqual(ast.get_docstring(node.body[0]), "line one\nline two")
+        self.assertEqual(ast.get_docstring(node.body[0]),
+                         'line one\nline two')
 
         node = ast.parse('async def foo():\n  """spam\n  ham"""')
-        self.assertEqual(ast.get_docstring(node.body[0]), "spam\nham")
+        self.assertEqual(ast.get_docstring(node.body[0]), 'spam\nham')
 
         node = ast.parse('async def foo():\n  """spam\n  ham"""')
-        self.assertEqual(ast.get_docstring(node.body[0], clean=False), "spam\n  ham")
+        self.assertEqual(ast.get_docstring(node.body[0], clean=False), 'spam\n  ham')
 
-        node = ast.parse("x")
+        node = ast.parse('x')
         self.assertRaises(TypeError, ast.get_docstring, node.body[0])
 
     def test_get_docstring_none(self):
-        self.assertIsNone(ast.get_docstring(ast.parse("")))
+        self.assertIsNone(ast.get_docstring(ast.parse('')))
         node = ast.parse('x = "not docstring"')
         self.assertIsNone(ast.get_docstring(node))
-        node = ast.parse("def foo():\n  pass")
+        node = ast.parse('def foo():\n  pass')
         self.assertIsNone(ast.get_docstring(node))
 
-        node = ast.parse("class foo:\n  pass")
+        node = ast.parse('class foo:\n  pass')
         self.assertIsNone(ast.get_docstring(node.body[0]))
         node = ast.parse('class foo:\n  x = "not docstring"')
         self.assertIsNone(ast.get_docstring(node.body[0]))
-        node = ast.parse("class foo:\n  def bar(self): pass")
+        node = ast.parse('class foo:\n  def bar(self): pass')
         self.assertIsNone(ast.get_docstring(node.body[0]))
 
-        node = ast.parse("def foo():\n  pass")
+        node = ast.parse('def foo():\n  pass')
         self.assertIsNone(ast.get_docstring(node.body[0]))
         node = ast.parse('def foo():\n  x = "not docstring"')
         self.assertIsNone(ast.get_docstring(node.body[0]))
 
-        node = ast.parse("async def foo():\n  pass")
+        node = ast.parse('async def foo():\n  pass')
         self.assertIsNone(ast.get_docstring(node.body[0]))
         node = ast.parse('async def foo():\n  x = "not docstring"')
         self.assertIsNone(ast.get_docstring(node.body[0]))
 
-        node = ast.parse("async def foo():\n  42")
+        node = ast.parse('async def foo():\n  42')
         self.assertIsNone(ast.get_docstring(node.body[0]))
 
     def test_multi_line_docstring_col_offset_and_lineno_issue16806(self):
@@ -1603,83 +1864,79 @@ def test_multi_line_docstring_col_offset_and_lineno_issue16806(self):
         self.assertEqual(node.body[2].lineno, 13)
 
     def test_elif_stmt_start_position(self):
-        node = ast.parse("if a:\n    pass\nelif b:\n    pass\n")
+        node = ast.parse('if a:\n    pass\nelif b:\n    pass\n')
         elif_stmt = node.body[0].orelse[0]
         self.assertEqual(elif_stmt.lineno, 3)
         self.assertEqual(elif_stmt.col_offset, 0)
 
     def test_elif_stmt_start_position_with_else(self):
-        node = ast.parse("if a:\n    pass\nelif b:\n    pass\nelse:\n    pass\n")
+        node = ast.parse('if a:\n    pass\nelif b:\n    pass\nelse:\n    pass\n')
         elif_stmt = node.body[0].orelse[0]
         self.assertEqual(elif_stmt.lineno, 3)
         self.assertEqual(elif_stmt.col_offset, 0)
 
     def test_starred_expr_end_position_within_call(self):
-        node = ast.parse("f(*[0, 1])")
+        node = ast.parse('f(*[0, 1])')
         starred_expr = node.body[0].value.args[0]
         self.assertEqual(starred_expr.end_lineno, 1)
         self.assertEqual(starred_expr.end_col_offset, 9)
 
     def test_literal_eval(self):
-        self.assertEqual(ast.literal_eval("[1, 2, 3]"), [1, 2, 3])
+        self.assertEqual(ast.literal_eval('[1, 2, 3]'), [1, 2, 3])
         self.assertEqual(ast.literal_eval('{"foo": 42}'), {"foo": 42})
-        self.assertEqual(ast.literal_eval("(True, False, None)"), (True, False, None))
-        self.assertEqual(ast.literal_eval("{1, 2, 3}"), {1, 2, 3})
+        self.assertEqual(ast.literal_eval('(True, False, None)'), (True, False, None))
+        self.assertEqual(ast.literal_eval('{1, 2, 3}'), {1, 2, 3})
         self.assertEqual(ast.literal_eval('b"hi"'), b"hi")
-        self.assertEqual(ast.literal_eval("set()"), set())
-        self.assertRaises(ValueError, ast.literal_eval, "foo()")
-        self.assertEqual(ast.literal_eval("6"), 6)
-        self.assertEqual(ast.literal_eval("+6"), 6)
-        self.assertEqual(ast.literal_eval("-6"), -6)
-        self.assertEqual(ast.literal_eval("3.25"), 3.25)
-        self.assertEqual(ast.literal_eval("+3.25"), 3.25)
-        self.assertEqual(ast.literal_eval("-3.25"), -3.25)
-        self.assertEqual(repr(ast.literal_eval("-0.0")), "-0.0")
-        self.assertRaises(ValueError, ast.literal_eval, "++6")
-        self.assertRaises(ValueError, ast.literal_eval, "+True")
-        self.assertRaises(ValueError, ast.literal_eval, "2+3")
-
-    @unittest.expectedFailure # TODO: RUSTPYTHON; SyntaxError not raised
+        self.assertEqual(ast.literal_eval('set()'), set())
+        self.assertRaises(ValueError, ast.literal_eval, 'foo()')
+        self.assertEqual(ast.literal_eval('6'), 6)
+        self.assertEqual(ast.literal_eval('+6'), 6)
+        self.assertEqual(ast.literal_eval('-6'), -6)
+        self.assertEqual(ast.literal_eval('3.25'), 3.25)
+        self.assertEqual(ast.literal_eval('+3.25'), 3.25)
+        self.assertEqual(ast.literal_eval('-3.25'), -3.25)
+        self.assertEqual(repr(ast.literal_eval('-0.0')), '-0.0')
+        self.assertRaises(ValueError, ast.literal_eval, '++6')
+        self.assertRaises(ValueError, ast.literal_eval, '+True')
+        self.assertRaises(ValueError, ast.literal_eval, '2+3')
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; SyntaxError not raised
     def test_literal_eval_str_int_limit(self):
         with support.adjust_int_max_str_digits(4000):
-            ast.literal_eval("3" * 4000)  # no error
+            ast.literal_eval('3'*4000)  # no error
             with self.assertRaises(SyntaxError) as err_ctx:
-                ast.literal_eval("3" * 4001)
-            self.assertIn("Exceeds the limit ", str(err_ctx.exception))
-            self.assertIn(" Consider hexadecimal ", str(err_ctx.exception))
+                ast.literal_eval('3'*4001)
+            self.assertIn('Exceeds the limit ', str(err_ctx.exception))
+            self.assertIn(' Consider hexadecimal ', str(err_ctx.exception))
 
     def test_literal_eval_complex(self):
         # Issue #4907
-        self.assertEqual(ast.literal_eval("6j"), 6j)
-        self.assertEqual(ast.literal_eval("-6j"), -6j)
-        self.assertEqual(ast.literal_eval("6.75j"), 6.75j)
-        self.assertEqual(ast.literal_eval("-6.75j"), -6.75j)
-        self.assertEqual(ast.literal_eval("3+6j"), 3 + 6j)
-        self.assertEqual(ast.literal_eval("-3+6j"), -3 + 6j)
-        self.assertEqual(ast.literal_eval("3-6j"), 3 - 6j)
-        self.assertEqual(ast.literal_eval("-3-6j"), -3 - 6j)
-        self.assertEqual(ast.literal_eval("3.25+6.75j"), 3.25 + 6.75j)
-        self.assertEqual(ast.literal_eval("-3.25+6.75j"), -3.25 + 6.75j)
-        self.assertEqual(ast.literal_eval("3.25-6.75j"), 3.25 - 6.75j)
-        self.assertEqual(ast.literal_eval("-3.25-6.75j"), -3.25 - 6.75j)
-        self.assertEqual(ast.literal_eval("(3+6j)"), 3 + 6j)
-        self.assertRaises(ValueError, ast.literal_eval, "-6j+3")
-        self.assertRaises(ValueError, ast.literal_eval, "-6j+3j")
-        self.assertRaises(ValueError, ast.literal_eval, "3+-6j")
-        self.assertRaises(ValueError, ast.literal_eval, "3+(0+6j)")
-        self.assertRaises(ValueError, ast.literal_eval, "-(3+6j)")
+        self.assertEqual(ast.literal_eval('6j'), 6j)
+        self.assertEqual(ast.literal_eval('-6j'), -6j)
+        self.assertEqual(ast.literal_eval('6.75j'), 6.75j)
+        self.assertEqual(ast.literal_eval('-6.75j'), -6.75j)
+        self.assertEqual(ast.literal_eval('3+6j'), 3+6j)
+        self.assertEqual(ast.literal_eval('-3+6j'), -3+6j)
+        self.assertEqual(ast.literal_eval('3-6j'), 3-6j)
+        self.assertEqual(ast.literal_eval('-3-6j'), -3-6j)
+        self.assertEqual(ast.literal_eval('3.25+6.75j'), 3.25+6.75j)
+        self.assertEqual(ast.literal_eval('-3.25+6.75j'), -3.25+6.75j)
+        self.assertEqual(ast.literal_eval('3.25-6.75j'), 3.25-6.75j)
+        self.assertEqual(ast.literal_eval('-3.25-6.75j'), -3.25-6.75j)
+        self.assertEqual(ast.literal_eval('(3+6j)'), 3+6j)
+        self.assertRaises(ValueError, ast.literal_eval, '-6j+3')
+        self.assertRaises(ValueError, ast.literal_eval, '-6j+3j')
+        self.assertRaises(ValueError, ast.literal_eval, '3+-6j')
+        self.assertRaises(ValueError, ast.literal_eval, '3+(0+6j)')
+        self.assertRaises(ValueError, ast.literal_eval, '-(3+6j)')
 
     def test_literal_eval_malformed_dict_nodes(self):
-        malformed = ast.Dict(
-            keys=[ast.Constant(1), ast.Constant(2)], values=[ast.Constant(3)]
-        )
+        malformed = ast.Dict(keys=[ast.Constant(1), ast.Constant(2)], values=[ast.Constant(3)])
         self.assertRaises(ValueError, ast.literal_eval, malformed)
-        malformed = ast.Dict(
-            keys=[ast.Constant(1)], values=[ast.Constant(2), ast.Constant(3)]
-        )
+        malformed = ast.Dict(keys=[ast.Constant(1)], values=[ast.Constant(2), ast.Constant(3)])
         self.assertRaises(ValueError, ast.literal_eval, malformed)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; SyntaxError: expected an expression
     def test_literal_eval_trailing_ws(self):
         self.assertEqual(ast.literal_eval("    -1"), -1)
         self.assertEqual(ast.literal_eval("\t\t-1"), -1)
@@ -1687,58 +1944,52 @@ def test_literal_eval_trailing_ws(self):
         self.assertRaises(IndentationError, ast.literal_eval, "\n -1")
 
     def test_literal_eval_malformed_lineno(self):
-        msg = r"malformed node or string on line 3:"
+        msg = r'malformed node or string on line 3:'
         with self.assertRaisesRegex(ValueError, msg):
             ast.literal_eval("{'a': 1,\n'b':2,\n'c':++3,\n'd':4}")
 
-        node = ast.UnaryOp(ast.UAdd(), ast.UnaryOp(ast.UAdd(), ast.Constant(6)))
-        self.assertIsNone(getattr(node, "lineno", None))
-        msg = r"malformed node or string:"
+        node = ast.UnaryOp(
+            ast.UAdd(), ast.UnaryOp(ast.UAdd(), ast.Constant(6)))
+        self.assertIsNone(getattr(node, 'lineno', None))
+        msg = r'malformed node or string:'
         with self.assertRaisesRegex(ValueError, msg):
             ast.literal_eval(node)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AssertionError: "unexpected indent" does not match "expected an expression (<unknown>, line 2)"
     def test_literal_eval_syntax_errors(self):
         with self.assertRaisesRegex(SyntaxError, "unexpected indent"):
-            ast.literal_eval(r"""
+            ast.literal_eval(r'''
                 \
                 (\
-            \ """)
+            \ ''')
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; TypeError: required field "lineno" missing from alias
     def test_bad_integer(self):
         # issue13436: Bad error message with invalid numeric values
-        body = [
-            ast.ImportFrom(
-                module="time",
-                names=[ast.alias(name="sleep")],
-                level=None,
-                lineno=None,
-                col_offset=None,
-            )
-        ]
+        body = [ast.ImportFrom(module='time',
+                               names=[ast.alias(name='sleep')],
+                               level=None,
+                               lineno=None, col_offset=None)]
         mod = ast.Module(body, [])
         with self.assertRaises(ValueError) as cm:
-            compile(mod, "test", "exec")
+            compile(mod, 'test', 'exec')
         self.assertIn("invalid integer value: None", str(cm.exception))
 
     def test_level_as_none(self):
-        body = [
-            ast.ImportFrom(
-                module="time",
-                names=[ast.alias(name="sleep", lineno=0, col_offset=0)],
-                level=None,
-                lineno=0,
-                col_offset=0,
-            )
-        ]
+        body = [ast.ImportFrom(module='time',
+                               names=[ast.alias(name='sleep',
+                                                lineno=0, col_offset=0)],
+                               level=None,
+                               lineno=0, col_offset=0)]
         mod = ast.Module(body, [])
-        code = compile(mod, "test", "exec")
+        code = compile(mod, 'test', 'exec')
         ns = {}
         exec(code, ns)
-        self.assertIn("sleep", ns)
+        self.assertIn('sleep', ns)
 
-    @unittest.skip('TODO: RUSTPYTHON; crash')
+    @unittest.skip("TODO: RUSTPYTHON; crash")
+    @skip_if_unlimited_stack_size
+    @skip_emscripten_stack_overflow()
     def test_recursion_direct(self):
         e = ast.UnaryOp(op=ast.Not(), lineno=0, col_offset=0, operand=ast.Constant(1))
         e.operand = e
@@ -1746,7 +1997,9 @@ def test_recursion_direct(self):
             with support.infinite_recursion():
                 compile(ast.Expression(e), "<test>", "eval")
 
-    @unittest.skip('TODO: RUSTPYTHON; crash')
+    @unittest.skip("TODO: RUSTPYTHON; crash")
+    @skip_if_unlimited_stack_size
+    @skip_emscripten_stack_overflow()
     def test_recursion_indirect(self):
         e = ast.UnaryOp(op=ast.Not(), lineno=0, col_offset=0, operand=ast.Constant(1))
         f = ast.UnaryOp(op=ast.Not(), lineno=0, col_offset=0, operand=ast.Constant(1))
@@ -1758,6 +2011,7 @@ def test_recursion_indirect(self):
 
 
 class ASTValidatorTests(unittest.TestCase):
+
     def mod(self, mod, msg=None, mode="exec", *, exc=ValueError):
         mod.lineno = mod.col_offset = 0
         ast.fix_missing_locations(mod)
@@ -1776,7 +2030,6 @@ def stmt(self, stmt, msg=None):
         mod = ast.Module([stmt], [])
         self.mod(mod, msg)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON; ValueError not raised
     def test_module(self):
         m = ast.Interactive([ast.Expr(ast.Name("x", ast.Store()))])
         self.mod(m, "must have Load context", "single")
@@ -1784,15 +2037,9 @@ def test_module(self):
         self.mod(m, "must have Load context", "eval")
 
     def _check_arguments(self, fac, check):
-        def arguments(
-            args=None,
-            posonlyargs=None,
-            vararg=None,
-            kwonlyargs=None,
-            kwarg=None,
-            defaults=None,
-            kw_defaults=None,
-        ):
+        def arguments(args=None, posonlyargs=None, vararg=None,
+                      kwonlyargs=None, kwarg=None,
+                      defaults=None, kw_defaults=None):
             if args is None:
                 args = []
             if posonlyargs is None:
@@ -1803,69 +2050,50 @@ def arguments(
                 defaults = []
             if kw_defaults is None:
                 kw_defaults = []
-            args = ast.arguments(
-                args, posonlyargs, vararg, kwonlyargs, kw_defaults, kwarg, defaults
-            )
+            args = ast.arguments(args, posonlyargs, vararg, kwonlyargs,
+                                 kw_defaults, kwarg, defaults)
             return fac(args)
-
         args = [ast.arg("x", ast.Name("x", ast.Store()))]
         check(arguments(args=args), "must have Load context")
         check(arguments(posonlyargs=args), "must have Load context")
         check(arguments(kwonlyargs=args), "must have Load context")
-        check(
-            arguments(defaults=[ast.Constant(3)]), "more positional defaults than args"
-        )
-        check(
-            arguments(kw_defaults=[ast.Constant(4)]),
-            "length of kwonlyargs is not the same as kw_defaults",
-        )
+        check(arguments(defaults=[ast.Constant(3)]),
+                       "more positional defaults than args")
+        check(arguments(kw_defaults=[ast.Constant(4)]),
+                       "length of kwonlyargs is not the same as kw_defaults")
         args = [ast.arg("x", ast.Name("x", ast.Load()))]
-        check(
-            arguments(args=args, defaults=[ast.Name("x", ast.Store())]),
-            "must have Load context",
-        )
-        args = [
-            ast.arg("a", ast.Name("x", ast.Load())),
-            ast.arg("b", ast.Name("y", ast.Load())),
-        ]
-        check(
-            arguments(kwonlyargs=args, kw_defaults=[None, ast.Name("x", ast.Store())]),
-            "must have Load context",
-        )
-
-    @unittest.expectedFailure # TODO: RUSTPYTHON; ValueError not raised
+        check(arguments(args=args, defaults=[ast.Name("x", ast.Store())]),
+                       "must have Load context")
+        args = [ast.arg("a", ast.Name("x", ast.Load())),
+                ast.arg("b", ast.Name("y", ast.Load()))]
+        check(arguments(kwonlyargs=args,
+                          kw_defaults=[None, ast.Name("x", ast.Store())]),
+                          "must have Load context")
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; ValueError not raised
     def test_funcdef(self):
         a = ast.arguments([], [], None, [], [], None, [])
         f = ast.FunctionDef("x", a, [], [], None, None, [])
         self.stmt(f, "empty body on FunctionDef")
-        f = ast.FunctionDef(
-            "x", a, [ast.Pass()], [ast.Name("x", ast.Store())], None, None, []
-        )
+        f = ast.FunctionDef("x", a, [ast.Pass()], [ast.Name("x", ast.Store())], None, None, [])
         self.stmt(f, "must have Load context")
-        f = ast.FunctionDef(
-            "x", a, [ast.Pass()], [], ast.Name("x", ast.Store()), None, []
-        )
+        f = ast.FunctionDef("x", a, [ast.Pass()], [],
+                            ast.Name("x", ast.Store()), None, [])
         self.stmt(f, "must have Load context")
         f = ast.FunctionDef("x", ast.arguments(), [ast.Pass()])
         self.stmt(f)
-
         def fac(args):
             return ast.FunctionDef("x", args, [ast.Pass()], [], None, None, [])
-
         self._check_arguments(fac, self.stmt)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON; TypeError: class pattern defines no positional sub-patterns (__match_args__ missing)
     def test_funcdef_pattern_matching(self):
         # gh-104799: New fields on FunctionDef should be added at the end
         def matcher(node):
             match node:
-                case ast.FunctionDef(
-                    "foo",
-                    ast.arguments(args=[ast.arg("bar")]),
-                    [ast.Pass()],
-                    [ast.Name("capybara", ast.Load())],
-                    ast.Name("pacarana", ast.Load()),
-                ):
+                case ast.FunctionDef("foo", ast.arguments(args=[ast.arg("bar")]),
+                                     [ast.Pass()],
+                                     [ast.Name("capybara", ast.Load())],
+                                     ast.Name("pacarana", ast.Load())):
                     return True
                 case _:
                     return False
@@ -1880,11 +2108,9 @@ def foo(bar) -> pacarana:
         self.assertIsInstance(funcdef, ast.FunctionDef)
         self.assertTrue(matcher(funcdef))
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON; ValueError not raised
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; ValueError not raised
     def test_classdef(self):
-        def cls(
-            bases=None, keywords=None, body=None, decorator_list=None, type_params=None
-        ):
+        def cls(bases=None, keywords=None, body=None, decorator_list=None, type_params=None):
             if bases is None:
                 bases = []
             if keywords is None:
@@ -1895,94 +2121,73 @@ def cls(
                 decorator_list = []
             if type_params is None:
                 type_params = []
-            return ast.ClassDef(
-                "myclass", bases, keywords, body, decorator_list, type_params
-            )
-
-        self.stmt(cls(bases=[ast.Name("x", ast.Store())]), "must have Load context")
-        self.stmt(
-            cls(keywords=[ast.keyword("x", ast.Name("x", ast.Store()))]),
-            "must have Load context",
-        )
+            return ast.ClassDef("myclass", bases, keywords,
+                                body, decorator_list, type_params)
+        self.stmt(cls(bases=[ast.Name("x", ast.Store())]),
+                  "must have Load context")
+        self.stmt(cls(keywords=[ast.keyword("x", ast.Name("x", ast.Store()))]),
+                  "must have Load context")
         self.stmt(cls(body=[]), "empty body on ClassDef")
         self.stmt(cls(body=[None]), "None disallowed")
-        self.stmt(
-            cls(decorator_list=[ast.Name("x", ast.Store())]), "must have Load context"
-        )
+        self.stmt(cls(decorator_list=[ast.Name("x", ast.Store())]),
+                  "must have Load context")
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON; ValueError not raised
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; ValueError not raised
     def test_delete(self):
         self.stmt(ast.Delete([]), "empty targets on Delete")
         self.stmt(ast.Delete([None]), "None disallowed")
-        self.stmt(ast.Delete([ast.Name("x", ast.Load())]), "must have Del context")
+        self.stmt(ast.Delete([ast.Name("x", ast.Load())]),
+                  "must have Del context")
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON; ValueError not raised
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; ValueError not raised
     def test_assign(self):
         self.stmt(ast.Assign([], ast.Constant(3)), "empty targets on Assign")
         self.stmt(ast.Assign([None], ast.Constant(3)), "None disallowed")
-        self.stmt(
-            ast.Assign([ast.Name("x", ast.Load())], ast.Constant(3)),
-            "must have Store context",
-        )
-        self.stmt(
-            ast.Assign([ast.Name("x", ast.Store())], ast.Name("y", ast.Store())),
-            "must have Load context",
-        )
+        self.stmt(ast.Assign([ast.Name("x", ast.Load())], ast.Constant(3)),
+                  "must have Store context")
+        self.stmt(ast.Assign([ast.Name("x", ast.Store())],
+                                ast.Name("y", ast.Store())),
+                  "must have Load context")
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON; ValueError not raised
     def test_augassign(self):
-        aug = ast.AugAssign(
-            ast.Name("x", ast.Load()), ast.Add(), ast.Name("y", ast.Load())
-        )
+        aug = ast.AugAssign(ast.Name("x", ast.Load()), ast.Add(),
+                            ast.Name("y", ast.Load()))
         self.stmt(aug, "must have Store context")
-        aug = ast.AugAssign(
-            ast.Name("x", ast.Store()), ast.Add(), ast.Name("y", ast.Store())
-        )
+        aug = ast.AugAssign(ast.Name("x", ast.Store()), ast.Add(),
+                            ast.Name("y", ast.Store()))
         self.stmt(aug, "must have Load context")
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON; ValueError not raised
     def test_for(self):
         x = ast.Name("x", ast.Store())
         y = ast.Name("y", ast.Load())
         p = ast.Pass()
         self.stmt(ast.For(x, y, [], []), "empty body on For")
-        self.stmt(
-            ast.For(ast.Name("x", ast.Load()), y, [p], []), "must have Store context"
-        )
-        self.stmt(
-            ast.For(x, ast.Name("y", ast.Store()), [p], []), "must have Load context"
-        )
+        self.stmt(ast.For(ast.Name("x", ast.Load()), y, [p], []),
+                  "must have Store context")
+        self.stmt(ast.For(x, ast.Name("y", ast.Store()), [p], []),
+                  "must have Load context")
         e = ast.Expr(ast.Name("x", ast.Store()))
         self.stmt(ast.For(x, y, [e], []), "must have Load context")
         self.stmt(ast.For(x, y, [p], [e]), "must have Load context")
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON; ValueError not raised
     def test_while(self):
         self.stmt(ast.While(ast.Constant(3), [], []), "empty body on While")
-        self.stmt(
-            ast.While(ast.Name("x", ast.Store()), [ast.Pass()], []),
-            "must have Load context",
-        )
-        self.stmt(
-            ast.While(
-                ast.Constant(3), [ast.Pass()], [ast.Expr(ast.Name("x", ast.Store()))]
-            ),
-            "must have Load context",
-        )
+        self.stmt(ast.While(ast.Name("x", ast.Store()), [ast.Pass()], []),
+                  "must have Load context")
+        self.stmt(ast.While(ast.Constant(3), [ast.Pass()],
+                             [ast.Expr(ast.Name("x", ast.Store()))]),
+                             "must have Load context")
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON; ValueError not raised
     def test_if(self):
         self.stmt(ast.If(ast.Constant(3), [], []), "empty body on If")
         i = ast.If(ast.Name("x", ast.Store()), [ast.Pass()], [])
         self.stmt(i, "must have Load context")
         i = ast.If(ast.Constant(3), [ast.Expr(ast.Name("x", ast.Store()))], [])
         self.stmt(i, "must have Load context")
-        i = ast.If(
-            ast.Constant(3), [ast.Pass()], [ast.Expr(ast.Name("x", ast.Store()))]
-        )
+        i = ast.If(ast.Constant(3), [ast.Pass()],
+                   [ast.Expr(ast.Name("x", ast.Store()))])
         self.stmt(i, "must have Load context")
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_with(self):
         p = ast.Pass()
         self.stmt(ast.With([], [p]), "empty items on With")
@@ -1993,7 +2198,6 @@ def test_with(self):
         i = ast.withitem(ast.Constant(3), ast.Name("x", ast.Load()))
         self.stmt(ast.With([i], [p]), "must have Store context")
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON; ValueError not raised
     def test_raise(self):
         r = ast.Raise(None, ast.Constant(3))
         self.stmt(r, "Raise with cause but no exception")
@@ -2002,7 +2206,6 @@ def test_raise(self):
         r = ast.Raise(ast.Constant(4), ast.Name("x", ast.Store()))
         self.stmt(r, "must have Load context")
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON; ValueError not raised
     def test_try(self):
         p = ast.Pass()
         t = ast.Try([], [], [], [p])
@@ -2023,7 +2226,6 @@ def test_try(self):
         t = ast.Try([p], e, [p], [ast.Expr(ast.Name("x", ast.Store()))])
         self.stmt(t, "must have Load context")
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_try_star(self):
         p = ast.Pass()
         t = ast.TryStar([], [], [], [p])
@@ -2044,38 +2246,32 @@ def test_try_star(self):
         t = ast.TryStar([p], e, [p], [ast.Expr(ast.Name("x", ast.Store()))])
         self.stmt(t, "must have Load context")
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON; ValueError not raised
     def test_assert(self):
-        self.stmt(
-            ast.Assert(ast.Name("x", ast.Store()), None), "must have Load context"
-        )
-        assrt = ast.Assert(ast.Name("x", ast.Load()), ast.Name("y", ast.Store()))
+        self.stmt(ast.Assert(ast.Name("x", ast.Store()), None),
+                  "must have Load context")
+        assrt = ast.Assert(ast.Name("x", ast.Load()),
+                           ast.Name("y", ast.Store()))
         self.stmt(assrt, "must have Load context")
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON; ValueError not raised
     def test_import(self):
         self.stmt(ast.Import([]), "empty names on Import")
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_importfrom(self):
         imp = ast.ImportFrom(None, [ast.alias("x", None)], -42)
         self.stmt(imp, "Negative ImportFrom level")
         self.stmt(ast.ImportFrom(None, [], 0), "empty names on ImportFrom")
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON; ValueError not raised
     def test_global(self):
         self.stmt(ast.Global([]), "empty names on Global")
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON; ValueError not raised
     def test_nonlocal(self):
         self.stmt(ast.Nonlocal([]), "empty names on Nonlocal")
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON; ValueError not raised
     def test_expr(self):
         e = ast.Expr(ast.Name("x", ast.Store()))
         self.stmt(e, "must have Load context")
 
-    @unittest.skip('TODO: RUSTPYTHON; called `Option::unwrap()` on a `None` value')
+    @unittest.skip("TODO: RUSTPYTHON; called `Option::unwrap()` on a `None` value")
     def test_boolop(self):
         b = ast.BoolOp(ast.And(), [])
         self.expr(b, "less than 2 values")
@@ -2086,36 +2282,33 @@ def test_boolop(self):
         b = ast.BoolOp(ast.And(), [ast.Constant(4), ast.Name("x", ast.Store())])
         self.expr(b, "must have Load context")
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON; ValueError not raised
     def test_unaryop(self):
         u = ast.UnaryOp(ast.Not(), ast.Name("x", ast.Store()))
         self.expr(u, "must have Load context")
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON; ValueError not raised
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; ValueError not raised
     def test_lambda(self):
         a = ast.arguments([], [], None, [], [], None, [])
-        self.expr(ast.Lambda(a, ast.Name("x", ast.Store())), "must have Load context")
-
+        self.expr(ast.Lambda(a, ast.Name("x", ast.Store())),
+                  "must have Load context")
         def fac(args):
             return ast.Lambda(args, ast.Name("x", ast.Load()))
-
         self._check_arguments(fac, self.expr)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON; ValueError not raised
     def test_ifexp(self):
         l = ast.Name("x", ast.Load())
         s = ast.Name("y", ast.Store())
         for args in (s, l, l), (l, s, l), (l, l, s):
             self.expr(ast.IfExp(*args), "must have Load context")
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON; ValueError not raised
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; ValueError not raised
     def test_dict(self):
         d = ast.Dict([], [ast.Name("x", ast.Load())])
         self.expr(d, "same number of keys as values")
         d = ast.Dict([ast.Name("x", ast.Load())], [None])
         self.expr(d, "None disallowed")
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; TypeError: expected some sort of expr, but got None
     def test_set(self):
         self.expr(ast.Set([None]), "None disallowed")
         s = ast.Set([ast.Name("x", ast.Store())])
@@ -2123,13 +2316,11 @@ def test_set(self):
 
     def _check_comprehension(self, fac):
         self.expr(fac([]), "comprehension with no generators")
-        g = ast.comprehension(
-            ast.Name("x", ast.Load()), ast.Name("x", ast.Load()), [], 0
-        )
+        g = ast.comprehension(ast.Name("x", ast.Load()),
+                              ast.Name("x", ast.Load()), [], 0)
         self.expr(fac([g]), "must have Store context")
-        g = ast.comprehension(
-            ast.Name("x", ast.Store()), ast.Name("x", ast.Store()), [], 0
-        )
+        g = ast.comprehension(ast.Name("x", ast.Store()),
+                              ast.Name("x", ast.Store()), [], 0)
         self.expr(fac([g]), "must have Load context")
         x = ast.Name("x", ast.Store())
         y = ast.Name("y", ast.Load())
@@ -2139,46 +2330,42 @@ def _check_comprehension(self, fac):
         self.expr(fac([g]), "must have Load context")
 
     def _simple_comp(self, fac):
-        g = ast.comprehension(
-            ast.Name("x", ast.Store()), ast.Name("x", ast.Load()), [], 0
-        )
-        self.expr(fac(ast.Name("x", ast.Store()), [g]), "must have Load context")
-
+        g = ast.comprehension(ast.Name("x", ast.Store()),
+                              ast.Name("x", ast.Load()), [], 0)
+        self.expr(fac(ast.Name("x", ast.Store()), [g]),
+                  "must have Load context")
         def wrap(gens):
             return fac(ast.Name("x", ast.Store()), gens)
-
         self._check_comprehension(wrap)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON; ValueError not raised
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; ValueError not raised
     def test_listcomp(self):
         self._simple_comp(ast.ListComp)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON; ValueError not raised
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; ValueError not raised
     def test_setcomp(self):
         self._simple_comp(ast.SetComp)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON; ValueError not raised
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; ValueError not raised
     def test_generatorexp(self):
         self._simple_comp(ast.GeneratorExp)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON; ValueError not raised
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; ValueError not raised
     def test_dictcomp(self):
-        g = ast.comprehension(
-            ast.Name("y", ast.Store()), ast.Name("p", ast.Load()), [], 0
-        )
-        c = ast.DictComp(ast.Name("x", ast.Store()), ast.Name("y", ast.Load()), [g])
+        g = ast.comprehension(ast.Name("y", ast.Store()),
+                              ast.Name("p", ast.Load()), [], 0)
+        c = ast.DictComp(ast.Name("x", ast.Store()),
+                         ast.Name("y", ast.Load()), [g])
         self.expr(c, "must have Load context")
-        c = ast.DictComp(ast.Name("x", ast.Load()), ast.Name("y", ast.Store()), [g])
+        c = ast.DictComp(ast.Name("x", ast.Load()),
+                         ast.Name("y", ast.Store()), [g])
         self.expr(c, "must have Load context")
-
         def factory(comps):
             k = ast.Name("x", ast.Load())
             v = ast.Name("y", ast.Load())
             return ast.DictComp(k, v, comps)
-
         self._check_comprehension(factory)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_yield(self):
         self.expr(ast.Yield(ast.Name("x", ast.Store())), "must have Load")
         self.expr(ast.YieldFrom(ast.Name("x", ast.Store())), "must have Load")
@@ -2195,7 +2382,7 @@ def test_compare(self):
         comp = ast.Compare(left, [ast.In()], [ast.Constant("blah")])
         self.expr(comp)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON; ValueError not raised
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; ValueError not raised
     def test_call(self):
         func = ast.Name("x", ast.Load())
         args = [ast.Name("y", ast.Load())]
@@ -2208,202 +2395,204 @@ def test_call(self):
         call = ast.Call(func, args, bad_keywords)
         self.expr(call, "must have Load context")
 
-    def test_num(self):
-        with warnings.catch_warnings(record=True) as wlog:
-            warnings.filterwarnings("ignore", "", DeprecationWarning)
-            from ast import Num
-
-        with warnings.catch_warnings(record=True) as wlog:
-            warnings.filterwarnings("always", "", DeprecationWarning)
-
-            class subint(int):
-                pass
-
-            class subfloat(float):
-                pass
-
-            class subcomplex(complex):
-                pass
-
-            for obj in "0", "hello":
-                self.expr(ast.Num(obj))
-            for obj in subint(), subfloat(), subcomplex():
-                self.expr(ast.Num(obj), "invalid type", exc=TypeError)
-
-        self.assertEqual(
-            [str(w.message) for w in wlog],
-            [
-                "ast.Num is deprecated and will be removed in Python 3.14; use ast.Constant instead",
-                "ast.Num is deprecated and will be removed in Python 3.14; use ast.Constant instead",
-                "ast.Num is deprecated and will be removed in Python 3.14; use ast.Constant instead",
-                "ast.Num is deprecated and will be removed in Python 3.14; use ast.Constant instead",
-                "ast.Num is deprecated and will be removed in Python 3.14; use ast.Constant instead",
-            ],
-        )
-
-    @unittest.expectedFailure # TODO: RUSTPYTHON; ValueError not raised
     def test_attribute(self):
         attr = ast.Attribute(ast.Name("x", ast.Store()), "y", ast.Load())
         self.expr(attr, "must have Load context")
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON; ValueError not raised
     def test_subscript(self):
-        sub = ast.Subscript(ast.Name("x", ast.Store()), ast.Constant(3), ast.Load())
+        sub = ast.Subscript(ast.Name("x", ast.Store()), ast.Constant(3),
+                            ast.Load())
         self.expr(sub, "must have Load context")
         x = ast.Name("x", ast.Load())
-        sub = ast.Subscript(x, ast.Name("y", ast.Store()), ast.Load())
+        sub = ast.Subscript(x, ast.Name("y", ast.Store()),
+                            ast.Load())
         self.expr(sub, "must have Load context")
         s = ast.Name("x", ast.Store())
         for args in (s, None, None), (None, s, None), (None, None, s):
             sl = ast.Slice(*args)
-            self.expr(ast.Subscript(x, sl, ast.Load()), "must have Load context")
+            self.expr(ast.Subscript(x, sl, ast.Load()),
+                      "must have Load context")
         sl = ast.Tuple([], ast.Load())
         self.expr(ast.Subscript(x, sl, ast.Load()))
         sl = ast.Tuple([s], ast.Load())
         self.expr(ast.Subscript(x, sl, ast.Load()), "must have Load context")
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON; ValueError not raised
     def test_starred(self):
-        left = ast.List(
-            [ast.Starred(ast.Name("x", ast.Load()), ast.Store())], ast.Store()
-        )
+        left = ast.List([ast.Starred(ast.Name("x", ast.Load()), ast.Store())],
+                        ast.Store())
         assign = ast.Assign([left], ast.Constant(4))
         self.stmt(assign, "must have Store context")
 
     def _sequence(self, fac):
         self.expr(fac([None], ast.Load()), "None disallowed")
-        self.expr(
-            fac([ast.Name("x", ast.Store())], ast.Load()), "must have Load context"
-        )
+        self.expr(fac([ast.Name("x", ast.Store())], ast.Load()),
+                  "must have Load context")
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; TypeError: expected some sort of expr, but got None
     def test_list(self):
         self._sequence(ast.List)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; TypeError: expected some sort of expr, but got None
     def test_tuple(self):
         self._sequence(ast.Tuple)
 
-    def test_nameconstant(self):
-        with warnings.catch_warnings(record=True) as wlog:
-            warnings.filterwarnings("ignore", "", DeprecationWarning)
-            from ast import NameConstant
-
-        with warnings.catch_warnings(record=True) as wlog:
-            warnings.filterwarnings("always", "", DeprecationWarning)
-            self.expr(ast.NameConstant(4))
-
-        self.assertEqual(
-            [str(w.message) for w in wlog],
-            [
-                "ast.NameConstant is deprecated and will be removed in Python 3.14; use ast.Constant instead",
-            ],
-        )
-
-    @unittest.expectedFailure # TODO: RUSTPYTHON
-    @support.requires_resource("cpu")
+    @support.requires_resource('cpu')
     def test_stdlib_validates(self):
-        stdlib = os.path.dirname(ast.__file__)
-        tests = [fn for fn in os.listdir(stdlib) if fn.endswith(".py")]
-        tests.extend(["test/test_grammar.py", "test/test_unpack_ex.py"])
-        for module in tests:
+        for module in STDLIB_FILES:
             with self.subTest(module):
-                fn = os.path.join(stdlib, module)
+                fn = os.path.join(STDLIB, module)
                 with open(fn, "r", encoding="utf-8") as fp:
                     source = fp.read()
                 mod = ast.parse(source, fn)
                 compile(mod, fn, "exec")
+                mod2 = ast.parse(source, fn)
+                self.assertTrue(ast.compare(mod, mod2))
 
     constant_1 = ast.Constant(1)
     pattern_1 = ast.MatchValue(constant_1)
 
-    constant_x = ast.Constant("x")
+    constant_x = ast.Constant('x')
     pattern_x = ast.MatchValue(constant_x)
 
     constant_true = ast.Constant(True)
     pattern_true = ast.MatchSingleton(True)
 
-    name_carter = ast.Name("carter", ast.Load())
+    name_carter = ast.Name('carter', ast.Load())
 
     _MATCH_PATTERNS = [
         ast.MatchValue(
             ast.Attribute(
-                ast.Attribute(ast.Name("x", ast.Store()), "y", ast.Load()),
-                "z",
-                ast.Load(),
+                ast.Attribute(
+                    ast.Name('x', ast.Store()),
+                    'y', ast.Load()
+                ),
+                'z', ast.Load()
             )
         ),
         ast.MatchValue(
             ast.Attribute(
-                ast.Attribute(ast.Name("x", ast.Load()), "y", ast.Store()),
-                "z",
-                ast.Load(),
+                ast.Attribute(
+                    ast.Name('x', ast.Load()),
+                    'y', ast.Store()
+                ),
+                'z', ast.Load()
             )
         ),
-        ast.MatchValue(ast.Constant(...)),
-        ast.MatchValue(ast.Constant(True)),
-        ast.MatchValue(ast.Constant((1, 2, 3))),
-        ast.MatchSingleton("string"),
-        ast.MatchSequence([ast.MatchSingleton("string")]),
-        ast.MatchSequence([ast.MatchSequence([ast.MatchSingleton("string")])]),
-        ast.MatchMapping([constant_1, constant_true], [pattern_x]),
+        ast.MatchValue(
+            ast.Constant(...)
+        ),
+        ast.MatchValue(
+            ast.Constant(True)
+        ),
+        ast.MatchValue(
+            ast.Constant((1,2,3))
+        ),
+        ast.MatchSingleton('string'),
+        ast.MatchSequence([
+          ast.MatchSingleton('string')
+        ]),
+        ast.MatchSequence(
+            [
+                ast.MatchSequence(
+                    [
+                        ast.MatchSingleton('string')
+                    ]
+                )
+            ]
+        ),
         ast.MatchMapping(
-            [constant_true, constant_1], [pattern_x, pattern_1], rest="True"
+            [constant_1, constant_true],
+            [pattern_x]
+        ),
+        ast.MatchMapping(
+            [constant_true, constant_1],
+            [pattern_x, pattern_1],
+            rest='True'
         ),
         ast.MatchMapping(
-            [constant_true, ast.Starred(ast.Name("lol", ast.Load()), ast.Load())],
+            [constant_true, ast.Starred(ast.Name('lol', ast.Load()), ast.Load())],
             [pattern_x, pattern_1],
-            rest="legit",
+            rest='legit'
         ),
         ast.MatchClass(
-            ast.Attribute(ast.Attribute(constant_x, "y", ast.Load()), "z", ast.Load()),
-            patterns=[],
-            kwd_attrs=[],
-            kwd_patterns=[],
+            ast.Attribute(
+                ast.Attribute(
+                    constant_x,
+                    'y', ast.Load()),
+                'z', ast.Load()),
+            patterns=[], kwd_attrs=[], kwd_patterns=[]
         ),
         ast.MatchClass(
-            name_carter, patterns=[], kwd_attrs=["True"], kwd_patterns=[pattern_1]
+            name_carter,
+            patterns=[],
+            kwd_attrs=['True'],
+            kwd_patterns=[pattern_1]
         ),
         ast.MatchClass(
-            name_carter, patterns=[], kwd_attrs=[], kwd_patterns=[pattern_1]
+            name_carter,
+            patterns=[],
+            kwd_attrs=[],
+            kwd_patterns=[pattern_1]
         ),
         ast.MatchClass(
             name_carter,
-            patterns=[ast.MatchSingleton("string")],
+            patterns=[ast.MatchSingleton('string')],
             kwd_attrs=[],
-            kwd_patterns=[],
+            kwd_patterns=[]
         ),
         ast.MatchClass(
-            name_carter, patterns=[ast.MatchStar()], kwd_attrs=[], kwd_patterns=[]
+            name_carter,
+            patterns=[ast.MatchStar()],
+            kwd_attrs=[],
+            kwd_patterns=[]
         ),
         ast.MatchClass(
-            name_carter, patterns=[], kwd_attrs=[], kwd_patterns=[ast.MatchStar()]
+            name_carter,
+            patterns=[],
+            kwd_attrs=[],
+            kwd_patterns=[ast.MatchStar()]
         ),
         ast.MatchClass(
             constant_true,  # invalid name
             patterns=[],
-            kwd_attrs=["True"],
-            kwd_patterns=[pattern_1],
+            kwd_attrs=['True'],
+            kwd_patterns=[pattern_1]
+        ),
+        ast.MatchSequence(
+            [
+                ast.MatchStar("True")
+            ]
+        ),
+        ast.MatchAs(
+            name='False'
+        ),
+        ast.MatchOr(
+            []
+        ),
+        ast.MatchOr(
+            [pattern_1]
+        ),
+        ast.MatchOr(
+            [pattern_1, pattern_x, ast.MatchSingleton('xxx')]
         ),
-        ast.MatchSequence([ast.MatchStar("True")]),
-        ast.MatchAs(name="False"),
-        ast.MatchOr([]),
-        ast.MatchOr([pattern_1]),
-        ast.MatchOr([pattern_1, pattern_x, ast.MatchSingleton("xxx")]),
         ast.MatchAs(name="_"),
         ast.MatchStar(name="x"),
         ast.MatchSequence([ast.MatchStar("_")]),
         ast.MatchMapping([], [], rest="_"),
     ]
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_match_validation_pattern(self):
-        name_x = ast.Name("x", ast.Load())
+        name_x = ast.Name('x', ast.Load())
         for pattern in self._MATCH_PATTERNS:
             with self.subTest(ast.dump(pattern, indent=4)):
                 node = ast.Match(
                     subject=name_x,
-                    cases=[ast.match_case(pattern=pattern, body=[ast.Pass()])],
+                    cases = [
+                        ast.match_case(
+                            pattern=pattern,
+                            body = [ast.Pass()]
+                        )
+                    ]
                 )
                 node = ast.fix_missing_locations(node)
                 module = ast.Module([node], [])
@@ -2426,44 +2615,35 @@ def compile_constant(self, value):
 
         ns = {}
         exec(code, ns)
-        return ns["x"]
+        return ns['x']
 
     def test_validation(self):
         with self.assertRaises(TypeError) as cm:
             self.compile_constant([1, 2, 3])
-        self.assertEqual(str(cm.exception), "got an invalid type in Constant: list")
+        self.assertEqual(str(cm.exception),
+                         "got an invalid type in Constant: list")
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON; b'' is not b''
     def test_singletons(self):
-        for const in (None, False, True, Ellipsis, b"", frozenset()):
+        for const in (None, False, True, Ellipsis, b''):
             with self.subTest(const=const):
                 value = self.compile_constant(const)
                 self.assertIs(value, const)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_values(self):
         nested_tuple = (1,)
         nested_frozenset = frozenset({1})
         for level in range(3):
             nested_tuple = (nested_tuple, 2)
             nested_frozenset = frozenset({nested_frozenset, 2})
-        values = (
-            123,
-            123.0,
-            123j,
-            "unicode",
-            b"bytes",
-            tuple("tuple"),
-            frozenset("frozenset"),
-            nested_tuple,
-            nested_frozenset,
-        )
+        values = (123, 123.0, 123j,
+                  "unicode", b'bytes',
+                  tuple("tuple"), frozenset("frozenset"),
+                  nested_tuple, nested_frozenset)
         for value in values:
             with self.subTest(value=value):
                 result = self.compile_constant(value)
                 self.assertEqual(result, value)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON; SyntaxError: cannot assign to literal
     def test_assign_to_constant(self):
         tree = ast.parse("x = 1")
 
@@ -2474,35 +2654,42 @@ def test_assign_to_constant(self):
 
         with self.assertRaises(ValueError) as cm:
             compile(tree, "string", "exec")
-        self.assertEqual(
-            str(cm.exception),
-            "expression which can't be assigned " "to in Store context",
-        )
+        self.assertEqual(str(cm.exception),
+                         "expression which can't be assigned "
+                         "to in Store context")
 
     def test_get_docstring(self):
         tree = ast.parse("'docstring'\nx = 1")
-        self.assertEqual(ast.get_docstring(tree), "docstring")
+        self.assertEqual(ast.get_docstring(tree), 'docstring')
 
     def get_load_const(self, tree):
         # Compile to bytecode, disassemble and get parameter of LOAD_CONST
         # instructions
-        co = compile(tree, "<string>", "exec")
+        co = compile(tree, '<string>', 'exec')
         consts = []
         for instr in dis.get_instructions(co):
-            if instr.opname == "LOAD_CONST" or instr.opname == "RETURN_CONST":
+            if instr.opcode in dis.hasconst:
                 consts.append(instr.argval)
         return consts
 
     @support.cpython_only
     def test_load_const(self):
-        consts = [None, True, False, 124, 2.0, 3j, "unicode", b"bytes", (1, 2, 3)]
-
-        code = "\n".join(["x={!r}".format(const) for const in consts])
-        code += "\nx = ..."
+        consts = [None,
+                  True, False,
+                  1000,
+                  2.0,
+                  3j,
+                  "unicode",
+                  b'bytes',
+                  (1, 2, 3)]
+
+        code = '\n'.join(['x={!r}'.format(const) for const in consts])
+        code += '\nx = ...'
         consts.extend((Ellipsis, None))
 
         tree = ast.parse(code)
-        self.assertEqual(self.get_load_const(tree), consts)
+        self.assertEqual(self.get_load_const(tree),
+                         consts)
 
         # Replace expression nodes with constants
         for assign, const in zip(tree.body, consts):
@@ -2511,7 +2698,8 @@ def test_load_const(self):
             ast.copy_location(new_node, assign.value)
             assign.value = new_node
 
-        self.assertEqual(self.get_load_const(tree), consts)
+        self.assertEqual(self.get_load_const(tree),
+                         consts)
 
     def test_literal_eval(self):
         tree = ast.parse("1 + 2")
@@ -2525,22 +2713,22 @@ def test_literal_eval(self):
         ast.copy_location(new_right, binop.right)
         binop.right = new_right
 
-        self.assertEqual(ast.literal_eval(binop), 10 + 20j)
+        self.assertEqual(ast.literal_eval(binop), 10+20j)
 
     def test_string_kind(self):
-        c = ast.parse('"x"', mode="eval").body
+        c = ast.parse('"x"', mode='eval').body
         self.assertEqual(c.value, "x")
         self.assertEqual(c.kind, None)
 
-        c = ast.parse('u"x"', mode="eval").body
+        c = ast.parse('u"x"', mode='eval').body
         self.assertEqual(c.value, "x")
         self.assertEqual(c.kind, "u")
 
-        c = ast.parse('r"x"', mode="eval").body
+        c = ast.parse('r"x"', mode='eval').body
         self.assertEqual(c.value, "x")
         self.assertEqual(c.kind, None)
 
-        c = ast.parse('b"x"', mode="eval").body
+        c = ast.parse('b"x"', mode='eval').body
         self.assertEqual(c.value, b"x")
         self.assertEqual(c.kind, None)
 
@@ -2551,7 +2739,6 @@ class EndPositionTests(unittest.TestCase):
     Testing end positions of nodes requires a bit of extra care
     because of how LL parsers work.
     """
-
     def _check_end_pos(self, ast_node, end_lineno, end_col_offset):
         self.assertEqual(ast_node.end_lineno, end_lineno)
         self.assertEqual(ast_node.end_col_offset, end_col_offset)
@@ -2565,55 +2752,55 @@ def _parse_value(self, s):
         return ast.parse(s).body[0].value
 
     def test_lambda(self):
-        s = "lambda x, *y: None"
+        s = 'lambda x, *y: None'
         lam = self._parse_value(s)
-        self._check_content(s, lam.body, "None")
-        self._check_content(s, lam.args.args[0], "x")
-        self._check_content(s, lam.args.vararg, "y")
+        self._check_content(s, lam.body, 'None')
+        self._check_content(s, lam.args.args[0], 'x')
+        self._check_content(s, lam.args.vararg, 'y')
 
     def test_func_def(self):
-        s = dedent("""
+        s = dedent('''
             def func(x: int,
                      *args: str,
                      z: float = 0,
                      **kwargs: Any) -> bool:
                 return True
-            """).strip()
+            ''').strip()
         fdef = ast.parse(s).body[0]
         self._check_end_pos(fdef, 5, 15)
-        self._check_content(s, fdef.body[0], "return True")
-        self._check_content(s, fdef.args.args[0], "x: int")
-        self._check_content(s, fdef.args.args[0].annotation, "int")
-        self._check_content(s, fdef.args.kwarg, "kwargs: Any")
-        self._check_content(s, fdef.args.kwarg.annotation, "Any")
+        self._check_content(s, fdef.body[0], 'return True')
+        self._check_content(s, fdef.args.args[0], 'x: int')
+        self._check_content(s, fdef.args.args[0].annotation, 'int')
+        self._check_content(s, fdef.args.kwarg, 'kwargs: Any')
+        self._check_content(s, fdef.args.kwarg.annotation, 'Any')
 
     def test_call(self):
-        s = "func(x, y=2, **kw)"
+        s = 'func(x, y=2, **kw)'
         call = self._parse_value(s)
-        self._check_content(s, call.func, "func")
-        self._check_content(s, call.keywords[0].value, "2")
-        self._check_content(s, call.keywords[1].value, "kw")
+        self._check_content(s, call.func, 'func')
+        self._check_content(s, call.keywords[0].value, '2')
+        self._check_content(s, call.keywords[1].value, 'kw')
 
     def test_call_noargs(self):
-        s = "x[0]()"
+        s = 'x[0]()'
         call = self._parse_value(s)
-        self._check_content(s, call.func, "x[0]")
+        self._check_content(s, call.func, 'x[0]')
         self._check_end_pos(call, 1, 6)
 
     def test_class_def(self):
-        s = dedent("""
+        s = dedent('''
             class C(A, B):
                 x: int = 0
-        """).strip()
+        ''').strip()
         cdef = ast.parse(s).body[0]
         self._check_end_pos(cdef, 2, 14)
-        self._check_content(s, cdef.bases[1], "B")
-        self._check_content(s, cdef.body[0], "x: int = 0")
+        self._check_content(s, cdef.bases[1], 'B')
+        self._check_content(s, cdef.body[0], 'x: int = 0')
 
     def test_class_kw(self):
-        s = "class S(metaclass=abc.ABCMeta): pass"
+        s = 'class S(metaclass=abc.ABCMeta): pass'
         cdef = ast.parse(s).body[0]
-        self._check_content(s, cdef.keywords[0].value, "abc.ABCMeta")
+        self._check_content(s, cdef.keywords[0].value, 'abc.ABCMeta')
 
     def test_multi_line_str(self):
         s = dedent('''
@@ -2626,10 +2813,10 @@ def test_multi_line_str(self):
         self._check_end_pos(assign.value, 3, 40)
 
     def test_continued_str(self):
-        s = dedent("""
+        s = dedent('''
             x = "first part" \\
             "second part"
-        """).strip()
+        ''').strip()
         assign = ast.parse(s).body[0]
         self._check_end_pos(assign, 2, 13)
         self._check_end_pos(assign.value, 2, 13)
@@ -2637,7 +2824,7 @@ def test_continued_str(self):
     def test_suites(self):
         # We intentionally put these into the same string to check
         # that empty lines are not part of the suite.
-        s = dedent("""
+        s = dedent('''
             while True:
                 pass
 
@@ -2657,7 +2844,7 @@ def test_suites(self):
                 pass
 
             pass
-        """).strip()
+        ''').strip()
         mod = ast.parse(s)
         while_loop = mod.body[0]
         if_stmt = mod.body[1]
@@ -2671,18 +2858,18 @@ def test_suites(self):
         self._check_end_pos(try_stmt, 17, 8)
         self._check_end_pos(pass_stmt, 19, 4)
 
-        self._check_content(s, while_loop.test, "True")
-        self._check_content(s, if_stmt.body[0], "x = None")
-        self._check_content(s, if_stmt.orelse[0].test, "other()")
-        self._check_content(s, for_loop.target, "x, y")
-        self._check_content(s, try_stmt.body[0], "raise RuntimeError")
-        self._check_content(s, try_stmt.handlers[0].type, "TypeError")
+        self._check_content(s, while_loop.test, 'True')
+        self._check_content(s, if_stmt.body[0], 'x = None')
+        self._check_content(s, if_stmt.orelse[0].test, 'other()')
+        self._check_content(s, for_loop.target, 'x, y')
+        self._check_content(s, try_stmt.body[0], 'raise RuntimeError')
+        self._check_content(s, try_stmt.handlers[0].type, 'TypeError')
 
     def test_fstring(self):
         s = 'x = f"abc {x + y} abc"'
         fstr = self._parse_value(s)
         binop = fstr.values[1].value
-        self._check_content(s, binop, "x + y")
+        self._check_content(s, binop, 'x + y')
 
     def test_fstring_multi_line(self):
         s = dedent('''
@@ -2697,198 +2884,200 @@ def test_fstring_multi_line(self):
         fstr = self._parse_value(s)
         binop = fstr.values[1].value
         self._check_end_pos(binop, 5, 7)
-        self._check_content(s, binop.left, "arg_one")
-        self._check_content(s, binop.right, "arg_two")
+        self._check_content(s, binop.left, 'arg_one')
+        self._check_content(s, binop.right, 'arg_two')
 
     def test_import_from_multi_line(self):
-        s = dedent("""
+        s = dedent('''
             from x.y.z import (
                 a, b, c as c
             )
-        """).strip()
+        ''').strip()
         imp = ast.parse(s).body[0]
         self._check_end_pos(imp, 3, 1)
         self._check_end_pos(imp.names[2], 2, 16)
 
     def test_slices(self):
-        s1 = "f()[1, 2] [0]"
-        s2 = "x[ a.b: c.d]"
-        sm = dedent("""
+        s1 = 'f()[1, 2] [0]'
+        s2 = 'x[ a.b: c.d]'
+        sm = dedent('''
             x[ a.b: f () ,
                g () : c.d
               ]
-        """).strip()
+        ''').strip()
         i1, i2, im = map(self._parse_value, (s1, s2, sm))
-        self._check_content(s1, i1.value, "f()[1, 2]")
-        self._check_content(s1, i1.value.slice, "1, 2")
-        self._check_content(s2, i2.slice.lower, "a.b")
-        self._check_content(s2, i2.slice.upper, "c.d")
-        self._check_content(sm, im.slice.elts[0].upper, "f ()")
-        self._check_content(sm, im.slice.elts[1].lower, "g ()")
+        self._check_content(s1, i1.value, 'f()[1, 2]')
+        self._check_content(s1, i1.value.slice, '1, 2')
+        self._check_content(s2, i2.slice.lower, 'a.b')
+        self._check_content(s2, i2.slice.upper, 'c.d')
+        self._check_content(sm, im.slice.elts[0].upper, 'f ()')
+        self._check_content(sm, im.slice.elts[1].lower, 'g ()')
         self._check_end_pos(im, 3, 3)
 
     def test_binop(self):
-        s = dedent("""
+        s = dedent('''
             (1 * 2 + (3 ) +
                  4
             )
-        """).strip()
+        ''').strip()
         binop = self._parse_value(s)
         self._check_end_pos(binop, 2, 6)
-        self._check_content(s, binop.right, "4")
-        self._check_content(s, binop.left, "1 * 2 + (3 )")
-        self._check_content(s, binop.left.right, "3")
+        self._check_content(s, binop.right, '4')
+        self._check_content(s, binop.left, '1 * 2 + (3 )')
+        self._check_content(s, binop.left.right, '3')
 
     def test_boolop(self):
-        s = dedent("""
+        s = dedent('''
             if (one_condition and
                     (other_condition or yet_another_one)):
                 pass
-        """).strip()
+        ''').strip()
         bop = ast.parse(s).body[0].test
         self._check_end_pos(bop, 2, 44)
-        self._check_content(s, bop.values[1], "other_condition or yet_another_one")
+        self._check_content(s, bop.values[1],
+                            'other_condition or yet_another_one')
 
     def test_tuples(self):
-        s1 = "x = () ;"
-        s2 = "x = 1 , ;"
-        s3 = "x = (1 , 2 ) ;"
-        sm = dedent("""
+        s1 = 'x = () ;'
+        s2 = 'x = 1 , ;'
+        s3 = 'x = (1 , 2 ) ;'
+        sm = dedent('''
             x = (
                 a, b,
             )
-        """).strip()
+        ''').strip()
         t1, t2, t3, tm = map(self._parse_value, (s1, s2, s3, sm))
-        self._check_content(s1, t1, "()")
-        self._check_content(s2, t2, "1 ,")
-        self._check_content(s3, t3, "(1 , 2 )")
+        self._check_content(s1, t1, '()')
+        self._check_content(s2, t2, '1 ,')
+        self._check_content(s3, t3, '(1 , 2 )')
         self._check_end_pos(tm, 3, 1)
 
     def test_attribute_spaces(self):
-        s = "func(x. y .z)"
+        s = 'func(x. y .z)'
         call = self._parse_value(s)
         self._check_content(s, call, s)
-        self._check_content(s, call.args[0], "x. y .z")
+        self._check_content(s, call.args[0], 'x. y .z')
 
     def test_redundant_parenthesis(self):
-        s = "( ( ( a + b ) ) )"
+        s = '( ( ( a + b ) ) )'
         v = ast.parse(s).body[0].value
-        self.assertEqual(type(v).__name__, "BinOp")
-        self._check_content(s, v, "a + b")
-        s2 = "await " + s
+        self.assertEqual(type(v).__name__, 'BinOp')
+        self._check_content(s, v, 'a + b')
+        s2 = 'await ' + s
         v = ast.parse(s2).body[0].value.value
-        self.assertEqual(type(v).__name__, "BinOp")
-        self._check_content(s2, v, "a + b")
+        self.assertEqual(type(v).__name__, 'BinOp')
+        self._check_content(s2, v, 'a + b')
 
     def test_trailers_with_redundant_parenthesis(self):
         tests = (
-            ("( ( ( a ) ) ) ( )", "Call"),
-            ("( ( ( a ) ) ) ( b )", "Call"),
-            ("( ( ( a ) ) ) [ b ]", "Subscript"),
-            ("( ( ( a ) ) ) . b", "Attribute"),
+            ('( ( ( a ) ) ) ( )', 'Call'),
+            ('( ( ( a ) ) ) ( b )', 'Call'),
+            ('( ( ( a ) ) ) [ b ]', 'Subscript'),
+            ('( ( ( a ) ) ) . b', 'Attribute'),
         )
         for s, t in tests:
             with self.subTest(s):
                 v = ast.parse(s).body[0].value
                 self.assertEqual(type(v).__name__, t)
                 self._check_content(s, v, s)
-                s2 = "await " + s
+                s2 = 'await ' + s
                 v = ast.parse(s2).body[0].value.value
                 self.assertEqual(type(v).__name__, t)
                 self._check_content(s2, v, s)
 
     def test_displays(self):
-        s1 = "[{}, {1, }, {1, 2,} ]"
-        s2 = "{a: b, f (): g () ,}"
+        s1 = '[{}, {1, }, {1, 2,} ]'
+        s2 = '{a: b, f (): g () ,}'
         c1 = self._parse_value(s1)
         c2 = self._parse_value(s2)
-        self._check_content(s1, c1.elts[0], "{}")
-        self._check_content(s1, c1.elts[1], "{1, }")
-        self._check_content(s1, c1.elts[2], "{1, 2,}")
-        self._check_content(s2, c2.keys[1], "f ()")
-        self._check_content(s2, c2.values[1], "g ()")
+        self._check_content(s1, c1.elts[0], '{}')
+        self._check_content(s1, c1.elts[1], '{1, }')
+        self._check_content(s1, c1.elts[2], '{1, 2,}')
+        self._check_content(s2, c2.keys[1], 'f ()')
+        self._check_content(s2, c2.values[1], 'g ()')
 
     def test_comprehensions(self):
-        s = dedent("""
+        s = dedent('''
             x = [{x for x, y in stuff
                   if cond.x} for stuff in things]
-        """).strip()
+        ''').strip()
         cmp = self._parse_value(s)
         self._check_end_pos(cmp, 2, 37)
-        self._check_content(s, cmp.generators[0].iter, "things")
-        self._check_content(s, cmp.elt.generators[0].iter, "stuff")
-        self._check_content(s, cmp.elt.generators[0].ifs[0], "cond.x")
-        self._check_content(s, cmp.elt.generators[0].target, "x, y")
+        self._check_content(s, cmp.generators[0].iter, 'things')
+        self._check_content(s, cmp.elt.generators[0].iter, 'stuff')
+        self._check_content(s, cmp.elt.generators[0].ifs[0], 'cond.x')
+        self._check_content(s, cmp.elt.generators[0].target, 'x, y')
 
     def test_yield_await(self):
-        s = dedent("""
+        s = dedent('''
             async def f():
                 yield x
                 await y
-        """).strip()
+        ''').strip()
         fdef = ast.parse(s).body[0]
-        self._check_content(s, fdef.body[0].value, "yield x")
-        self._check_content(s, fdef.body[1].value, "await y")
+        self._check_content(s, fdef.body[0].value, 'yield x')
+        self._check_content(s, fdef.body[1].value, 'await y')
 
     def test_source_segment_multi(self):
-        s_orig = dedent("""
+        s_orig = dedent('''
             x = (
                 a, b,
             ) + ()
-        """).strip()
-        s_tuple = dedent("""
+        ''').strip()
+        s_tuple = dedent('''
             (
                 a, b,
             )
-        """).strip()
+        ''').strip()
         binop = self._parse_value(s_orig)
         self.assertEqual(ast.get_source_segment(s_orig, binop.left), s_tuple)
 
     def test_source_segment_padded(self):
-        s_orig = dedent("""
+        s_orig = dedent('''
             class C:
                 def fun(self) -> None:
                     "ЖЖЖЖЖ"
-        """).strip()
-        s_method = "    def fun(self) -> None:\n" '        "ЖЖЖЖЖ"'
+        ''').strip()
+        s_method = '    def fun(self) -> None:\n' \
+                   '        "ЖЖЖЖЖ"'
         cdef = ast.parse(s_orig).body[0]
-        self.assertEqual(
-            ast.get_source_segment(s_orig, cdef.body[0], padded=True), s_method
-        )
+        self.assertEqual(ast.get_source_segment(s_orig, cdef.body[0], padded=True),
+                         s_method)
 
     def test_source_segment_endings(self):
-        s = "v = 1\r\nw = 1\nx = 1\n\ry = 1\rz = 1\r\n"
+        s = 'v = 1\r\nw = 1\nx = 1\n\ry = 1\rz = 1\r\n'
         v, w, x, y, z = ast.parse(s).body
-        self._check_content(s, v, "v = 1")
-        self._check_content(s, w, "w = 1")
-        self._check_content(s, x, "x = 1")
-        self._check_content(s, y, "y = 1")
-        self._check_content(s, z, "z = 1")
+        self._check_content(s, v, 'v = 1')
+        self._check_content(s, w, 'w = 1')
+        self._check_content(s, x, 'x = 1')
+        self._check_content(s, y, 'y = 1')
+        self._check_content(s, z, 'z = 1')
 
     def test_source_segment_tabs(self):
-        s = dedent("""
+        s = dedent('''
             class C:
               \t\f  def fun(self) -> None:
               \t\f      pass
-        """).strip()
-        s_method = "  \t\f  def fun(self) -> None:\n" "  \t\f      pass"
+        ''').strip()
+        s_method = '  \t\f  def fun(self) -> None:\n' \
+                   '  \t\f      pass'
 
         cdef = ast.parse(s).body[0]
         self.assertEqual(ast.get_source_segment(s, cdef.body[0], padded=True), s_method)
 
     def test_source_segment_newlines(self):
-        s = "def f():\n  pass\ndef g():\r  pass\r\ndef h():\r\n  pass\r\n"
+        s = 'def f():\n  pass\ndef g():\r  pass\r\ndef h():\r\n  pass\r\n'
         f, g, h = ast.parse(s).body
-        self._check_content(s, f, "def f():\n  pass")
-        self._check_content(s, g, "def g():\r  pass")
-        self._check_content(s, h, "def h():\r\n  pass")
+        self._check_content(s, f, 'def f():\n  pass')
+        self._check_content(s, g, 'def g():\r  pass')
+        self._check_content(s, h, 'def h():\r\n  pass')
 
-        s = "def f():\n  a = 1\r  b = 2\r\n  c = 3\n"
+        s = 'def f():\n  a = 1\r  b = 2\r\n  c = 3\n'
         f = ast.parse(s).body[0]
         self._check_content(s, f, s.rstrip())
 
     def test_source_segment_missing_info(self):
-        s = "v = 1\r\nw = 1\nx = 1\n\ry = 1\r\n"
+        s = 'v = 1\r\nw = 1\nx = 1\n\ry = 1\r\n'
         v, w, x, y = ast.parse(s).body
         del v.lineno
         del w.end_lineno
@@ -2900,102 +3089,27 @@ def test_source_segment_missing_info(self):
         self.assertIsNone(ast.get_source_segment(s, y))
 
 
-class BaseNodeVisitorCases:
-    # Both `NodeVisitor` and `NodeTranformer` must raise these warnings:
-    def test_old_constant_nodes(self):
-        class Visitor(self.visitor_class):
-            def visit_Num(self, node):
-                log.append((node.lineno, "Num", node.n))
-
-            def visit_Str(self, node):
-                log.append((node.lineno, "Str", node.s))
-
-            def visit_Bytes(self, node):
-                log.append((node.lineno, "Bytes", node.s))
-
-            def visit_NameConstant(self, node):
-                log.append((node.lineno, "NameConstant", node.value))
-
-            def visit_Ellipsis(self, node):
-                log.append((node.lineno, "Ellipsis", ...))
-
-        mod = ast.parse(
-            dedent("""\
-            i = 42
-            f = 4.25
-            c = 4.25j
-            s = 'string'
-            b = b'bytes'
-            t = True
-            n = None
-            e = ...
-            """)
-        )
-        visitor = Visitor()
-        log = []
-        with warnings.catch_warnings(record=True) as wlog:
-            warnings.filterwarnings("always", "", DeprecationWarning)
-            visitor.visit(mod)
-        self.assertEqual(
-            log,
-            [
-                (1, "Num", 42),
-                (2, "Num", 4.25),
-                (3, "Num", 4.25j),
-                (4, "Str", "string"),
-                (5, "Bytes", b"bytes"),
-                (6, "NameConstant", True),
-                (7, "NameConstant", None),
-                (8, "Ellipsis", ...),
-            ],
-        )
-        self.assertEqual(
-            [str(w.message) for w in wlog],
-            [
-                "visit_Num is deprecated; add visit_Constant",
-                "Attribute n is deprecated and will be removed in Python 3.14; use value instead",
-                "visit_Num is deprecated; add visit_Constant",
-                "Attribute n is deprecated and will be removed in Python 3.14; use value instead",
-                "visit_Num is deprecated; add visit_Constant",
-                "Attribute n is deprecated and will be removed in Python 3.14; use value instead",
-                "visit_Str is deprecated; add visit_Constant",
-                "Attribute s is deprecated and will be removed in Python 3.14; use value instead",
-                "visit_Bytes is deprecated; add visit_Constant",
-                "Attribute s is deprecated and will be removed in Python 3.14; use value instead",
-                "visit_NameConstant is deprecated; add visit_Constant",
-                "visit_NameConstant is deprecated; add visit_Constant",
-                "visit_Ellipsis is deprecated; add visit_Constant",
-            ],
-        )
-
-
-class NodeVisitorTests(BaseNodeVisitorCases, unittest.TestCase):
-    visitor_class = ast.NodeVisitor
-
-
-class NodeTransformerTests(ASTTestMixin, BaseNodeVisitorCases, unittest.TestCase):
-    visitor_class = ast.NodeTransformer
-
-    def assertASTTransformation(self, tranformer_class, initial_code, expected_code):
+class NodeTransformerTests(ASTTestMixin, unittest.TestCase):
+    def assertASTTransformation(self, transformer_class,
+                                initial_code, expected_code):
         initial_ast = ast.parse(dedent(initial_code))
         expected_ast = ast.parse(dedent(expected_code))
 
-        tranformer = tranformer_class()
-        result_ast = ast.fix_missing_locations(tranformer.visit(initial_ast))
+        transformer = transformer_class()
+        result_ast = ast.fix_missing_locations(transformer.visit(initial_ast))
 
         self.assertASTEqual(result_ast, expected_ast)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON; <class 'object'> is not <class 'NoneType'>
     def test_node_remove_single(self):
-        code = "def func(arg) -> SomeType: ..."
-        expected = "def func(arg): ..."
+        code = 'def func(arg) -> SomeType: ...'
+        expected = 'def func(arg): ...'
 
         # Since `FunctionDef.returns` is defined as a single value, we test
         # the `if isinstance(old_value, AST):` branch here.
         class SomeTypeRemover(ast.NodeTransformer):
             def visit_Name(self, node: ast.Name):
                 self.generic_visit(node)
-                if node.id == "SomeType":
+                if node.id == 'SomeType':
                     return None
                 return node
 
@@ -3034,11 +3148,11 @@ class DSL(Base, kw1=True, kw2=True, kw3=False): ...
         class ExtendKeywords(ast.NodeTransformer):
             def visit_keyword(self, node: ast.keyword):
                 self.generic_visit(node)
-                if node.arg == "kw1":
+                if node.arg == 'kw1':
                     return [
                         node,
-                        ast.keyword("kw2", ast.Constant(True)),
-                        ast.keyword("kw3", ast.Constant(False)),
+                        ast.keyword('kw2', ast.Constant(True)),
+                        ast.keyword('kw3', ast.Constant(False)),
                     ]
                 return node
 
@@ -3057,8 +3171,8 @@ def func(arg):
         class PrintToLog(ast.NodeTransformer):
             def visit_Call(self, node: ast.Call):
                 self.generic_visit(node)
-                if isinstance(node.func, ast.Name) and node.func.id == "print":
-                    node.func.id = "log"
+                if isinstance(node.func, ast.Name) and node.func.id == 'print':
+                    node.func.id = 'log'
                 return node
 
         self.assertASTTransformation(PrintToLog, code, expected)
@@ -3076,15 +3190,15 @@ def func(arg):
         class PrintToLog(ast.NodeTransformer):
             def visit_Call(self, node: ast.Call):
                 self.generic_visit(node)
-                if isinstance(node.func, ast.Name) and node.func.id == "print":
+                if isinstance(node.func, ast.Name) and node.func.id == 'print':
                     return ast.Call(
                         func=ast.Attribute(
-                            ast.Name("logger", ctx=ast.Load()),
-                            attr="log",
+                            ast.Name('logger', ctx=ast.Load()),
+                            attr='log',
                             ctx=ast.Load(),
                         ),
                         args=node.args,
-                        keywords=[ast.keyword("debug", ast.Constant(True))],
+                        keywords=[ast.keyword('debug', ast.Constant(True))],
                     )
                 return node
 
@@ -3094,23 +3208,19 @@ def visit_Call(self, node: ast.Call):
 class ASTConstructorTests(unittest.TestCase):
     """Test the autogenerated constructors for AST nodes."""
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_FunctionDef(self):
         args = ast.arguments()
         self.assertEqual(args.args, [])
         self.assertEqual(args.posonlyargs, [])
-        with self.assertWarnsRegex(
-            DeprecationWarning,
-            r"FunctionDef\.__init__ missing 1 required positional argument: 'name'",
-        ):
+        with self.assertWarnsRegex(DeprecationWarning,
+                                   r"FunctionDef\.__init__ missing 1 required positional argument: 'name'"):
             node = ast.FunctionDef(args=args)
-        self.assertFalse(hasattr(node, "name"))
+        self.assertNotHasAttr(node, "name")
         self.assertEqual(node.decorator_list, [])
-        node = ast.FunctionDef(name="foo", args=args)
-        self.assertEqual(node.name, "foo")
+        node = ast.FunctionDef(name='foo', args=args)
+        self.assertEqual(node.name, 'foo')
         self.assertEqual(node.decorator_list, [])
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_expr_context(self):
         name = ast.Name("x")
         self.assertEqual(name.id, "x")
@@ -3124,10 +3234,8 @@ def test_expr_context(self):
         self.assertEqual(name3.id, "x")
         self.assertIsInstance(name3.ctx, ast.Del)
 
-        with self.assertWarnsRegex(
-            DeprecationWarning,
-            r"Name\.__init__ missing 1 required positional argument: 'id'",
-        ):
+        with self.assertWarnsRegex(DeprecationWarning,
+                                   r"Name\.__init__ missing 1 required positional argument: 'id'"):
             name3 = ast.Name()
 
     def test_custom_subclass_with_no_fields(self):
@@ -3140,7 +3248,7 @@ class NoInit(ast.AST):
 
     def test_fields_but_no_field_types(self):
         class Fields(ast.AST):
-            _fields = ("a",)
+            _fields = ('a',)
 
         obj = Fields()
         with self.assertRaises(AttributeError):
@@ -3150,8 +3258,8 @@ class Fields(ast.AST):
 
     def test_fields_and_types(self):
         class FieldsAndTypes(ast.AST):
-            _fields = ("a",)
-            _field_types = {"a": int | None}
+            _fields = ('a',)
+            _field_types = {'a': int | None}
             a: int | None = None
 
         obj = FieldsAndTypes()
@@ -3159,7 +3267,6 @@ class FieldsAndTypes(ast.AST):
         obj = FieldsAndTypes(a=1)
         self.assertEqual(obj.a, 1)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON; DeprecationWarning not triggered
     def test_custom_attributes(self):
         class MyAttrs(ast.AST):
             _attributes = ("a", "b")
@@ -3168,39 +3275,35 @@ class MyAttrs(ast.AST):
         self.assertEqual(obj.a, 1)
         self.assertEqual(obj.b, 2)
 
-        with self.assertWarnsRegex(
-            DeprecationWarning,
-            r"MyAttrs.__init__ got an unexpected keyword argument 'c'.",
-        ):
+        with self.assertWarnsRegex(DeprecationWarning,
+                                   r"MyAttrs.__init__ got an unexpected keyword argument 'c'."):
             obj = MyAttrs(c=3)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON; DeprecationWarning not triggered
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; DeprecationWarning not triggered
     def test_fields_and_types_no_default(self):
         class FieldsAndTypesNoDefault(ast.AST):
-            _fields = ("a",)
-            _field_types = {"a": int}
+            _fields = ('a',)
+            _field_types = {'a': int}
 
-        with self.assertWarnsRegex(
-            DeprecationWarning,
-            r"FieldsAndTypesNoDefault\.__init__ missing 1 required positional argument: 'a'\.",
-        ):
+        with self.assertWarnsRegex(DeprecationWarning,
+                                   r"FieldsAndTypesNoDefault\.__init__ missing 1 required positional argument: 'a'\."):
             obj = FieldsAndTypesNoDefault()
         with self.assertRaises(AttributeError):
             obj.a
         obj = FieldsAndTypesNoDefault(a=1)
         self.assertEqual(obj.a, 1)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON; DeprecationWarning not triggered
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; DeprecationWarning not triggered
     def test_incomplete_field_types(self):
         class MoreFieldsThanTypes(ast.AST):
-            _fields = ("a", "b")
-            _field_types = {"a": int | None}
+            _fields = ('a', 'b')
+            _field_types = {'a': int | None}
             a: int | None = None
             b: int | None = None
 
         with self.assertWarnsRegex(
             DeprecationWarning,
-            r"Field 'b' is missing from MoreFieldsThanTypes\._field_types",
+            r"Field 'b' is missing from MoreFieldsThanTypes\._field_types"
         ):
             obj = MoreFieldsThanTypes()
         self.assertIs(obj.a, None)
@@ -3210,11 +3313,20 @@ class MoreFieldsThanTypes(ast.AST):
         self.assertEqual(obj.a, 1)
         self.assertEqual(obj.b, 2)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; TypeError: Expected type 'str' but 'bytes' found.
+    def test_malformed_fields_with_bytes(self):
+        class BadFields(ast.AST):
+            _fields = (b'\xff'*64,)
+            _field_types = {'a': int}
+
+        # This should not crash
+        with self.assertWarnsRegex(DeprecationWarning, r"Field b'\\xff\\xff.*' .*"):
+            obj = BadFields()
+
     def test_complete_field_types(self):
         class _AllFieldTypes(ast.AST):
-            _fields = ("a", "b")
-            _field_types = {"a": int | None, "b": list[str]}
+            _fields = ('a', 'b')
+            _field_types = {'a': int | None, 'b': list[str]}
             # This must be set explicitly
             a: int | None = None
             # This will add an implicit empty list default
@@ -3224,6 +3336,28 @@ class _AllFieldTypes(ast.AST):
         self.assertIs(obj.a, None)
         self.assertEqual(obj.b, [])
 
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    def test_non_str_kwarg(self):
+        warn_msg = "got an unexpected keyword argument <object object"
+        with (
+            self.assertRaises(TypeError),
+            self.assertWarnsRegex(DeprecationWarning, warn_msg),
+        ):
+            ast.Name(**{object(): 'y'})
+
+        class FakeStr:
+            def __init__(self, value):
+                self.value = value
+
+            def __hash__(self):
+                return hash(self.value)
+
+            def __eq__(self, other):
+                return isinstance(other, str) and self.value == other
+
+        with self.assertRaisesRegex(TypeError, "got multiple values for argument"):
+            ast.Name("x", **{FakeStr('id'): 'y'})
+
 
 @support.cpython_only
 class ModuleStateTests(unittest.TestCase):
@@ -3231,9 +3365,9 @@ class ModuleStateTests(unittest.TestCase):
 
     def check_ast_module(self):
         # Check that the _ast module still works as expected
-        code = "x + 1"
-        filename = "<string>"
-        mode = "eval"
+        code = 'x + 1'
+        filename = '<string>'
+        mode = 'eval'
 
         # Create _ast.AST subclasses instances
         ast_tree = compile(code, filename, mode, flags=ast.PyCF_ONLY_AST)
@@ -3244,11 +3378,11 @@ def check_ast_module(self):
 
     def test_reload_module(self):
         # bpo-41194: Importing the _ast module twice must not crash.
-        with support.swap_item(sys.modules, "_ast", None):
-            del sys.modules["_ast"]
+        with support.swap_item(sys.modules, '_ast', None):
+            del sys.modules['_ast']
             import _ast as ast1
 
-            del sys.modules["_ast"]
+            del sys.modules['_ast']
             import _ast as ast2
 
             self.check_ast_module()
@@ -3269,23 +3403,22 @@ def my_import(name, *args, **kw):
             sys.modules[name] = lazy_mod
             return lazy_mod
 
-        with support.swap_item(sys.modules, "_ast", None):
-            del sys.modules["_ast"]
+        with support.swap_item(sys.modules, '_ast', None):
+            del sys.modules['_ast']
 
-            with support.swap_attr(builtins, "__import__", my_import):
+            with support.swap_attr(builtins, '__import__', my_import):
                 # Test that compile() does not import the _ast module
                 self.check_ast_module()
-                self.assertNotIn("_ast", sys.modules)
+                self.assertNotIn('_ast', sys.modules)
 
                 # Sanity check of the test itself
                 import _ast
-
                 self.assertIs(_ast, lazy_mod)
 
     def test_subinterpreter(self):
         # bpo-41631: Importing and using the _ast module in a subinterpreter
         # must not crash.
-        code = dedent("""
+        code = dedent('''
             import _ast
             import ast
             import gc
@@ -3303,54 +3436,272 @@ def test_subinterpreter(self):
             del ast, _ast
             del sys.modules['ast'], sys.modules['_ast']
             gc.collect()
-        """)
+        ''')
         res = support.run_in_subinterp(code)
         self.assertEqual(res, 0)
 
 
-class ASTMainTests(unittest.TestCase):
-    # Tests `ast.main()` function.
+class CommandLineTests(unittest.TestCase):
+    def setUp(self):
+        self.filename = tempfile.mktemp()
+        self.addCleanup(os_helper.unlink, self.filename)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
-    def test_cli_file_input(self):
-        code = "print(1, 2, 3)"
-        expected = ast.dump(ast.parse(code), indent=3)
+    @staticmethod
+    def text_normalize(string):
+        return textwrap.dedent(string).strip()
 
-        with os_helper.temp_dir() as tmp_dir:
-            filename = os.path.join(tmp_dir, "test_module.py")
-            with open(filename, "w", encoding="utf-8") as f:
-                f.write(code)
-            res, _ = script_helper.run_python_until_end("-m", "ast", filename)
+    def set_source(self, content):
+        Path(self.filename).write_text(self.text_normalize(content))
 
-        self.assertEqual(res.err, b"")
-        self.assertEqual(expected.splitlines(), res.out.decode("utf8").splitlines())
-        self.assertEqual(res.rc, 0)
+    def invoke_ast(self, *flags):
+        stderr = StringIO()
+        stdout = StringIO()
+        with (
+            contextlib.redirect_stdout(stdout),
+            contextlib.redirect_stderr(stderr),
+        ):
+            ast.main(args=[*flags, self.filename])
+        self.assertEqual(stderr.getvalue(), '')
+        return stdout.getvalue().strip()
+
+    def check_output(self, source, expect, *flags):
+        self.set_source(source)
+        res = self.invoke_ast(*flags)
+        expect = self.text_normalize(expect)
+        self.assertEqual(res, expect)
+
+    @support.requires_resource('cpu')
+    def test_invocation(self):
+        # test various combinations of parameters
+        base_flags = (
+            ('-m=exec', '--mode=exec'),
+            ('--no-type-comments', '--no-type-comments'),
+            ('-a', '--include-attributes'),
+            ('-i=4', '--indent=4'),
+            ('--feature-version=3.13', '--feature-version=3.13'),
+            ('-O=-1', '--optimize=-1'),
+            ('--show-empty', '--show-empty'),
+        )
+        self.set_source('''
+            print(1, 2, 3)
+            def f(x: int) -> int:
+                x -= 1
+                return x
+        ''')
+
+        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(flags=args):
+                        self.invoke_ast(*args)
+
+    @support.force_not_colorized
+    def test_help_message(self):
+        for flag in ('-h', '--help', '--unknown'):
+            with self.subTest(flag=flag):
+                output = StringIO()
+                with self.assertRaises(SystemExit):
+                    with contextlib.redirect_stderr(output):
+                        ast.main(args=flag)
+                self.assertStartsWith(output.getvalue(), 'usage: ')
+
+    def test_exec_mode_flag(self):
+        # test 'python -m ast -m/--mode exec'
+        source = 'x: bool = 1 # type: ignore[assignment]'
+        expect = '''
+            Module(
+               body=[
+                  AnnAssign(
+                     target=Name(id='x', ctx=Store()),
+                     annotation=Name(id='bool', ctx=Load()),
+                     value=Constant(value=1),
+                     simple=1)],
+               type_ignores=[
+                  TypeIgnore(lineno=1, tag='[assignment]')])
+        '''
+        for flag in ('-m=exec', '--mode=exec'):
+            with self.subTest(flag=flag):
+                self.check_output(source, expect, flag)
+
+    def test_single_mode_flag(self):
+        # test 'python -m ast -m/--mode single'
+        source = 'pass'
+        expect = '''
+            Interactive(
+               body=[
+                  Pass()])
+        '''
+        for flag in ('-m=single', '--mode=single'):
+            with self.subTest(flag=flag):
+                self.check_output(source, expect, flag)
+
+    def test_eval_mode_flag(self):
+        # test 'python -m ast -m/--mode eval'
+        source = 'print(1, 2, 3)'
+        expect = '''
+            Expression(
+               body=Call(
+                  func=Name(id='print', ctx=Load()),
+                  args=[
+                     Constant(value=1),
+                     Constant(value=2),
+                     Constant(value=3)]))
+        '''
+        for flag in ('-m=eval', '--mode=eval'):
+            with self.subTest(flag=flag):
+                self.check_output(source, expect, flag)
+
+    def test_func_type_mode_flag(self):
+        # test 'python -m ast -m/--mode func_type'
+        source = '(int, str) -> list[int]'
+        expect = '''
+            FunctionType(
+               argtypes=[
+                  Name(id='int', ctx=Load()),
+                  Name(id='str', ctx=Load())],
+               returns=Subscript(
+                  value=Name(id='list', ctx=Load()),
+                  slice=Name(id='int', ctx=Load()),
+                  ctx=Load()))
+        '''
+        for flag in ('-m=func_type', '--mode=func_type'):
+            with self.subTest(flag=flag):
+                self.check_output(source, expect, flag)
+
+    def test_no_type_comments_flag(self):
+        # test 'python -m ast --no-type-comments'
+        source = 'x: bool = 1 # type: ignore[assignment]'
+        expect = '''
+            Module(
+               body=[
+                  AnnAssign(
+                     target=Name(id='x', ctx=Store()),
+                     annotation=Name(id='bool', ctx=Load()),
+                     value=Constant(value=1),
+                     simple=1)])
+        '''
+        self.check_output(source, expect, '--no-type-comments')
+
+    def test_include_attributes_flag(self):
+        # test 'python -m ast -a/--include-attributes'
+        source = 'pass'
+        expect = '''
+            Module(
+               body=[
+                  Pass(
+                     lineno=1,
+                     col_offset=0,
+                     end_lineno=1,
+                     end_col_offset=4)])
+        '''
+        for flag in ('-a', '--include-attributes'):
+            with self.subTest(flag=flag):
+                self.check_output(source, expect, flag)
+
+    def test_indent_flag(self):
+        # test 'python -m ast -i/--indent 0'
+        source = 'pass'
+        expect = '''
+            Module(
+            body=[
+            Pass()])
+        '''
+        for flag in ('-i=0', '--indent=0'):
+            with self.subTest(flag=flag):
+                self.check_output(source, expect, flag)
+
+    def test_feature_version_flag(self):
+        # test 'python -m ast --feature-version 3.9/3.10'
+        source = '''
+            match x:
+                case 1:
+                    pass
+        '''
+        expect = '''
+            Module(
+               body=[
+                  Match(
+                     subject=Name(id='x', ctx=Load()),
+                     cases=[
+                        match_case(
+                           pattern=MatchValue(
+                              value=Constant(value=1)),
+                           body=[
+                              Pass()])])])
+        '''
+        self.check_output(source, expect, '--feature-version=3.10')
+        with self.assertRaises(SyntaxError):
+            self.invoke_ast('--feature-version=3.9')
+
+    def test_no_optimize_flag(self):
+        # test 'python -m ast -O/--optimize -1/0'
+        source = '''
+            match a:
+                case 1+2j:
+                    pass
+        '''
+        expect = '''
+            Module(
+               body=[
+                  Match(
+                     subject=Name(id='a', ctx=Load()),
+                     cases=[
+                        match_case(
+                           pattern=MatchValue(
+                              value=BinOp(
+                                 left=Constant(value=1),
+                                 op=Add(),
+                                 right=Constant(value=2j))),
+                           body=[
+                              Pass()])])])
+        '''
+        for flag in ('-O=-1', '--optimize=-1', '-O=0', '--optimize=0'):
+            with self.subTest(flag=flag):
+                self.check_output(source, expect, flag)
+
+    def test_optimize_flag(self):
+        # test 'python -m ast -O/--optimize 1/2'
+        source = '''
+            match a:
+                case 1+2j:
+                    pass
+        '''
+        expect = '''
+            Module(
+               body=[
+                  Match(
+                     subject=Name(id='a', ctx=Load()),
+                     cases=[
+                        match_case(
+                           pattern=MatchValue(
+                              value=Constant(value=(1+2j))),
+                           body=[
+                              Pass()])])])
+        '''
+        for flag in ('-O=1', '--optimize=1', '-O=2', '--optimize=2'):
+            with self.subTest(flag=flag):
+                self.check_output(source, expect, flag)
+
+    def test_show_empty_flag(self):
+        # test 'python -m ast --show-empty'
+        source = 'print(1, 2, 3)'
+        expect = '''
+            Module(
+               body=[
+                  Expr(
+                     value=Call(
+                        func=Name(id='print', ctx=Load()),
+                        args=[
+                           Constant(value=1),
+                           Constant(value=2),
+                           Constant(value=3)],
+                        keywords=[]))],
+               type_ignores=[])
+        '''
+        self.check_output(source, expect, '--show-empty')
 
-def compare(left, right):
-    return ast.dump(left) == ast.dump(right)
 
 class ASTOptimizationTests(unittest.TestCase):
-    binop = {
-        "+": ast.Add(),
-        "-": ast.Sub(),
-        "*": ast.Mult(),
-        "/": ast.Div(),
-        "%": ast.Mod(),
-        "<<": ast.LShift(),
-        ">>": ast.RShift(),
-        "|": ast.BitOr(),
-        "^": ast.BitXor(),
-        "&": ast.BitAnd(),
-        "//": ast.FloorDiv(),
-        "**": ast.Pow(),
-    }
-
-    unaryop = {
-        "~": ast.Invert(),
-        "+": ast.UAdd(),
-        "-": ast.USub(),
-    }
-
     def wrap_expr(self, expr):
         return ast.Module(body=[ast.Expr(value=expr)])
 
@@ -3358,112 +3709,31 @@ def wrap_statement(self, statement):
         return ast.Module(body=[statement])
 
     def assert_ast(self, code, non_optimized_target, optimized_target):
-
         non_optimized_tree = ast.parse(code, optimize=-1)
         optimized_tree = ast.parse(code, optimize=1)
 
         # Is a non-optimized tree equal to a non-optimized target?
         self.assertTrue(
-            compare(non_optimized_tree, non_optimized_target),
+            ast.compare(non_optimized_tree, non_optimized_target),
             f"{ast.dump(non_optimized_target)} must equal "
             f"{ast.dump(non_optimized_tree)}",
         )
 
         # Is a optimized tree equal to a non-optimized target?
         self.assertFalse(
-            compare(optimized_tree, non_optimized_target),
+            ast.compare(optimized_tree, non_optimized_target),
             f"{ast.dump(non_optimized_target)} must not equal "
             f"{ast.dump(non_optimized_tree)}"
         )
 
         # Is a optimized tree is equal to an optimized target?
         self.assertTrue(
-            compare(optimized_tree,  optimized_target),
+            ast.compare(optimized_tree,  optimized_target),
             f"{ast.dump(optimized_target)} must equal "
             f"{ast.dump(optimized_tree)}",
         )
 
-    def create_binop(self, operand, left=ast.Constant(1), right=ast.Constant(1)):
-            return ast.BinOp(left=left, op=self.binop[operand], right=right)
-
-    @unittest.expectedFailure # TODO: RUSTPYTHON; ValueError: compile() unrecognized flags
-    def test_folding_binop(self):
-        code = "1 %s 1"
-        operators = self.binop.keys()
-
-        for op in operators:
-            result_code = code % op
-            non_optimized_target = self.wrap_expr(self.create_binop(op))
-            optimized_target = self.wrap_expr(ast.Constant(value=eval(result_code)))
-
-            with self.subTest(
-                result_code=result_code,
-                non_optimized_target=non_optimized_target,
-                optimized_target=optimized_target
-            ):
-                self.assert_ast(result_code, non_optimized_target, optimized_target)
-
-        # Multiplication of constant tuples must be folded
-        code = "(1,) * 3"
-        non_optimized_target = self.wrap_expr(self.create_binop("*", ast.Tuple(elts=[ast.Constant(value=1)]), ast.Constant(value=3)))
-        optimized_target = self.wrap_expr(ast.Constant(eval(code)))
-
-        self.assert_ast(code, non_optimized_target, optimized_target)
-
-    @unittest.expectedFailure # TODO: RUSTPYTHON; ValueError: compile() unrecognized flags
-    def test_folding_unaryop(self):
-        code = "%s1"
-        operators = self.unaryop.keys()
-
-        def create_unaryop(operand):
-            return ast.UnaryOp(op=self.unaryop[operand], operand=ast.Constant(1))
-
-        for op in operators:
-            result_code = code % op
-            non_optimized_target = self.wrap_expr(create_unaryop(op))
-            optimized_target = self.wrap_expr(ast.Constant(eval(result_code)))
-
-            with self.subTest(
-                result_code=result_code,
-                non_optimized_target=non_optimized_target,
-                optimized_target=optimized_target
-            ):
-                self.assert_ast(result_code, non_optimized_target, optimized_target)
-
-    @unittest.expectedFailure # TODO: RUSTPYTHON; ValueError: compile() unrecognized flags
-    def test_folding_not(self):
-        code = "not (1 %s (1,))"
-        operators = {
-            "in": ast.In(),
-            "is": ast.Is(),
-        }
-        opt_operators = {
-            "is": ast.IsNot(),
-            "in": ast.NotIn(),
-        }
-
-        def create_notop(operand):
-            return ast.UnaryOp(op=ast.Not(), operand=ast.Compare(
-                left=ast.Constant(value=1),
-                ops=[operators[operand]],
-                comparators=[ast.Tuple(elts=[ast.Constant(value=1)])]
-            ))
-
-        for op in operators.keys():
-            result_code = code % op
-            non_optimized_target = self.wrap_expr(create_notop(op))
-            optimized_target = self.wrap_expr(
-                ast.Compare(left=ast.Constant(1), ops=[opt_operators[op]], comparators=[ast.Constant(value=(1,))])
-            )
-
-            with self.subTest(
-                result_code=result_code,
-                non_optimized_target=non_optimized_target,
-                optimized_target=optimized_target
-            ):
-                self.assert_ast(result_code, non_optimized_target, optimized_target)
-
-    @unittest.expectedFailure # TODO: RUSTPYTHON; ValueError: compile() unrecognized flags
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; ValueError: compile() unrecognized flags
     def test_folding_format(self):
         code = "'%s' % (a,)"
 
@@ -3483,158 +3753,122 @@ def test_folding_format(self):
 
         self.assert_ast(code, non_optimized_target, optimized_target)
 
+    def test_folding_match_case_allowed_expressions(self):
+        def get_match_case_values(node):
+            result = []
+            if isinstance(node, ast.Constant):
+                result.append(node.value)
+            elif isinstance(node, ast.MatchValue):
+                result.extend(get_match_case_values(node.value))
+            elif isinstance(node, ast.MatchMapping):
+                for key in node.keys:
+                    result.extend(get_match_case_values(key))
+            elif isinstance(node, ast.MatchSequence):
+                for pat in node.patterns:
+                    result.extend(get_match_case_values(pat))
+            else:
+                self.fail(f"Unexpected node {node}")
+            return result
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON; ValueError: compile() unrecognized flags
-    def test_folding_tuple(self):
-        code = "(1,)"
+        tests = [
+            ("-0", [0]),
+            ("-0.1", [-0.1]),
+            ("-0j", [complex(0, 0)]),
+            ("-0.1j", [complex(0, -0.1)]),
+            ("1 + 2j", [complex(1, 2)]),
+            ("1 - 2j", [complex(1, -2)]),
+            ("1.1 + 2.1j", [complex(1.1, 2.1)]),
+            ("1.1 - 2.1j", [complex(1.1, -2.1)]),
+            ("-0 + 1j", [complex(0, 1)]),
+            ("-0 - 1j", [complex(0, -1)]),
+            ("-0.1 + 1.1j", [complex(-0.1, 1.1)]),
+            ("-0.1 - 1.1j", [complex(-0.1, -1.1)]),
+            ("{-0: 0}", [0]),
+            ("{-0.1: 0}", [-0.1]),
+            ("{-0j: 0}", [complex(0, 0)]),
+            ("{-0.1j: 0}", [complex(0, -0.1)]),
+            ("{1 + 2j: 0}", [complex(1, 2)]),
+            ("{1 - 2j: 0}", [complex(1, -2)]),
+            ("{1.1 + 2.1j: 0}", [complex(1.1, 2.1)]),
+            ("{1.1 - 2.1j: 0}", [complex(1.1, -2.1)]),
+            ("{-0 + 1j: 0}", [complex(0, 1)]),
+            ("{-0 - 1j: 0}", [complex(0, -1)]),
+            ("{-0.1 + 1.1j: 0}", [complex(-0.1, 1.1)]),
+            ("{-0.1 - 1.1j: 0}", [complex(-0.1, -1.1)]),
+            ("{-0: 0, 0 + 1j: 0, 0.1 + 1j: 0}", [0, complex(0, 1), complex(0.1, 1)]),
+            ("[-0, -0.1, -0j, -0.1j]", [0, -0.1, complex(0, 0), complex(0, -0.1)]),
+            ("[[[[-0, -0.1, -0j, -0.1j]]]]", [0, -0.1, complex(0, 0), complex(0, -0.1)]),
+            ("[[-0, -0.1], -0j, -0.1j]", [0, -0.1, complex(0, 0), complex(0, -0.1)]),
+            ("[[-0, -0.1], [-0j, -0.1j]]", [0, -0.1, complex(0, 0), complex(0, -0.1)]),
+            ("(-0, -0.1, -0j, -0.1j)", [0, -0.1, complex(0, 0), complex(0, -0.1)]),
+            ("((((-0, -0.1, -0j, -0.1j))))", [0, -0.1, complex(0, 0), complex(0, -0.1)]),
+            ("((-0, -0.1), -0j, -0.1j)", [0, -0.1, complex(0, 0), complex(0, -0.1)]),
+            ("((-0, -0.1), (-0j, -0.1j))", [0, -0.1, complex(0, 0), complex(0, -0.1)]),
+        ]
+        for match_expr, constants in tests:
+            with self.subTest(match_expr):
+                src = f"match 0:\n\t case {match_expr}: pass"
+                tree = ast.parse(src, optimize=1)
+                match_stmt = tree.body[0]
+                case = match_stmt.cases[0]
+                values = get_match_case_values(case.pattern)
+                self.assertListEqual(constants, values)
+
+    def test_match_case_not_folded_in_unoptimized_ast(self):
+        src = textwrap.dedent("""
+            match a:
+                case 1+2j:
+                    pass
+            """)
 
-        non_optimized_target = self.wrap_expr(ast.Tuple(elts=[ast.Constant(1)]))
-        optimized_target = self.wrap_expr(ast.Constant(value=(1,)))
+        unfolded = "MatchValue(value=BinOp(left=Constant(value=1), op=Add(), right=Constant(value=2j))"
+        folded = "MatchValue(value=Constant(value=(1+2j)))"
+        for optval in (0, 1, 2):
+            self.assertIn(folded if optval else unfolded, ast.dump(ast.parse(src, optimize=optval)))
 
-        self.assert_ast(code, non_optimized_target, optimized_target)
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; ValueError: compile() unrecognized flags
+    def test_folding_binop(self):
+        return super().test_folding_binop()
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON; ValueError: compile() unrecognized flags
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; ValueError: compile() unrecognized flags
     def test_folding_comparator(self):
-        code = "1 %s %s1%s"
-        operators = [("in", ast.In()), ("not in", ast.NotIn())]
-        braces = [
-            ("[", "]", ast.List, (1,)),
-            ("{", "}", ast.Set, frozenset({1})),
-        ]
-        for left, right, non_optimized_comparator, optimized_comparator in braces:
-            for op, node in operators:
-                non_optimized_target = self.wrap_expr(ast.Compare(
-                    left=ast.Constant(1), ops=[node],
-                    comparators=[non_optimized_comparator(elts=[ast.Constant(1)])]
-                ))
-                optimized_target = self.wrap_expr(ast.Compare(
-                    left=ast.Constant(1), ops=[node],
-                    comparators=[ast.Constant(value=optimized_comparator)]
-                ))
-                self.assert_ast(code % (op, left, right), non_optimized_target, optimized_target)
-
-    @unittest.expectedFailure # TODO: RUSTPYTHON; ValueError: compile() unrecognized flags
-    def test_folding_iter(self):
-        code = "for _ in %s1%s: pass"
-        braces = [
-            ("[", "]", ast.List, (1,)),
-            ("{", "}", ast.Set, frozenset({1})),
-        ]
-
-        for left, right, ast_cls, optimized_iter in braces:
-            non_optimized_target = self.wrap_statement(ast.For(
-                target=ast.Name(id="_", ctx=ast.Store()),
-                iter=ast_cls(elts=[ast.Constant(1)]),
-                body=[ast.Pass()]
-            ))
-            optimized_target = self.wrap_statement(ast.For(
-                target=ast.Name(id="_", ctx=ast.Store()),
-                iter=ast.Constant(value=optimized_iter),
-                body=[ast.Pass()]
-            ))
-
-            self.assert_ast(code % (left, right), non_optimized_target, optimized_target)
-
-    @unittest.expectedFailure # TODO: RUSTPYTHON; ValueError: compile() unrecognized flags
-    def test_folding_subscript(self):
-        code = "(1,)[0]"
-
-        non_optimized_target = self.wrap_expr(
-            ast.Subscript(value=ast.Tuple(elts=[ast.Constant(value=1)]), slice=ast.Constant(value=0))
-        )
-        optimized_target = self.wrap_expr(ast.Constant(value=1))
+        return super().test_folding_comparator()
 
-        self.assert_ast(code, non_optimized_target, optimized_target)
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; ValueError: compile() unrecognized flags
+    def test_folding_iter(self):
+        return super().test_folding_iter()
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON; ValueError: compile() unrecognized flags
-    def test_folding_type_param_in_function_def(self):
-        code = "def foo[%s = 1 + 1](): pass"
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; ValueError: compile() unrecognized flags
+    def test_folding_not(self):
+        return super().test_folding_not()
 
-        unoptimized_binop = self.create_binop("+")
-        unoptimized_type_params = [
-            ("T", "T", ast.TypeVar),
-            ("**P", "P", ast.ParamSpec),
-            ("*Ts", "Ts", ast.TypeVarTuple),
-        ]
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; ValueError: compile() unrecognized flags
+    def test_folding_subscript(self):
+        return super().test_folding_subscript()
 
-        for type, name, type_param in unoptimized_type_params:
-            result_code = code % type
-            optimized_target = self.wrap_statement(
-                ast.FunctionDef(
-                    name='foo',
-                    args=ast.arguments(),
-                    body=[ast.Pass()],
-                    type_params=[type_param(name=name, default_value=ast.Constant(2))]
-                )
-            )
-            non_optimized_target = self.wrap_statement(
-                ast.FunctionDef(
-                    name='foo',
-                    args=ast.arguments(),
-                    body=[ast.Pass()],
-                    type_params=[type_param(name=name, default_value=unoptimized_binop)]
-                )
-            )
-            self.assert_ast(result_code, non_optimized_target, optimized_target)
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; ValueError: compile() unrecognized flags
+    def test_folding_tuple(self):
+        return super().test_folding_tuple()
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON; ValueError: compile() unrecognized flags
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; ValueError: compile() unrecognized flags
     def test_folding_type_param_in_class_def(self):
-        code = "class foo[%s = 1 + 1]: pass"
-
-        unoptimized_binop = self.create_binop("+")
-        unoptimized_type_params = [
-            ("T", "T", ast.TypeVar),
-            ("**P", "P", ast.ParamSpec),
-            ("*Ts", "Ts", ast.TypeVarTuple),
-        ]
+        return super().test_folding_type_param_in_class_def()
 
-        for type, name, type_param in unoptimized_type_params:
-            result_code = code % type
-            optimized_target = self.wrap_statement(
-                ast.ClassDef(
-                    name='foo',
-                    body=[ast.Pass()],
-                    type_params=[type_param(name=name, default_value=ast.Constant(2))]
-                )
-            )
-            non_optimized_target = self.wrap_statement(
-                ast.ClassDef(
-                    name='foo',
-                    body=[ast.Pass()],
-                    type_params=[type_param(name=name, default_value=unoptimized_binop)]
-                )
-            )
-            self.assert_ast(result_code, non_optimized_target, optimized_target)
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; ValueError: compile() unrecognized flags
+    def test_folding_type_param_in_function_def(self):
+        return super().test_folding_type_param_in_function_def()
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON; ValueError: compile() unrecognized flags
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; ValueError: compile() unrecognized flags
     def test_folding_type_param_in_type_alias(self):
-        code = "type foo[%s = 1 + 1] = 1"
-
-        unoptimized_binop = self.create_binop("+")
-        unoptimized_type_params = [
-            ("T", "T", ast.TypeVar),
-            ("**P", "P", ast.ParamSpec),
-            ("*Ts", "Ts", ast.TypeVarTuple),
-        ]
+        return super().test_folding_type_param_in_type_alias()
 
-        for type, name, type_param in unoptimized_type_params:
-            result_code = code % type
-            optimized_target = self.wrap_statement(
-                ast.TypeAlias(
-                    name=ast.Name(id='foo', ctx=ast.Store()),
-                    type_params=[type_param(name=name, default_value=ast.Constant(2))],
-                    value=ast.Constant(value=1),
-                )
-            )
-            non_optimized_target = self.wrap_statement(
-                ast.TypeAlias(
-                    name=ast.Name(id='foo', ctx=ast.Store()),
-                    type_params=[type_param(name=name, default_value=unoptimized_binop)],
-                    value=ast.Constant(value=1),
-                )
-            )
-            self.assert_ast(result_code, non_optimized_target, optimized_target)
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; ValueError: compile() unrecognized flags
+    def test_folding_unaryop(self):
+        return super().test_folding_unaryop()
 
 
-if __name__ == "__main__":
+if __name__ == '__main__':
+    if len(sys.argv) > 1 and sys.argv[1] == '--snapshot-update':
+        ast_repr_update_snapshots()
+        sys.exit(0)
     unittest.main()
diff --git a/Lib/test/test_ast/utils.py b/Lib/test/test_ast/utils.py
index 145e89ee94e..e7054f3f710 100644
--- a/Lib/test/test_ast/utils.py
+++ b/Lib/test/test_ast/utils.py
@@ -1,5 +1,5 @@
 def to_tuple(t):
-    if t is None or isinstance(t, (str, int, complex, float, bytes)) or t is Ellipsis:
+    if t is None or isinstance(t, (str, int, complex, float, bytes, tuple)) or t is Ellipsis:
         return t
     elif isinstance(t, list):
         return [to_tuple(e) for e in t]
diff --git a/Lib/test/test_asyncgen.py b/Lib/test/test_asyncgen.py
index 45d220e3e02..181476e0989 100644
--- a/Lib/test/test_asyncgen.py
+++ b/Lib/test/test_asyncgen.py
@@ -4,10 +4,12 @@
 import contextlib
 
 from test.support.import_helper import import_module
-from test.support import gc_collect
+from test.support import gc_collect, requires_working_socket
 asyncio = import_module("asyncio")
 
 
+requires_working_socket(module=True)
+
 _no_default = object()
 
 
@@ -375,6 +377,178 @@ async def async_gen_wrapper():
 
         self.compare_generators(sync_gen_wrapper(), async_gen_wrapper())
 
+    def test_async_gen_exception_12(self):
+        async def gen():
+            with self.assertWarnsRegex(RuntimeWarning,
+                    f"coroutine method 'asend' of '{gen.__qualname__}' "
+                    f"was never awaited"):
+                await anext(me)
+            yield 123
+
+        me = gen()
+        ai = me.__aiter__()
+        an = ai.__anext__()
+
+        with self.assertRaisesRegex(RuntimeError,
+                r'anext\(\): asynchronous generator is already running'):
+            an.__next__()
+
+        with self.assertRaisesRegex(RuntimeError,
+                r"cannot reuse already awaited __anext__\(\)/asend\(\)"):
+            an.send(None)
+
+    def test_async_gen_asend_throw_concurrent_with_send(self):
+        import types
+
+        @types.coroutine
+        def _async_yield(v):
+            return (yield v)
+
+        class MyExc(Exception):
+            pass
+
+        async def agenfn():
+            while True:
+                try:
+                    await _async_yield(None)
+                except MyExc:
+                    pass
+            return
+            yield
+
+
+        agen = agenfn()
+        gen = agen.asend(None)
+        gen.send(None)
+        gen2 = agen.asend(None)
+
+        with self.assertRaisesRegex(RuntimeError,
+                r'anext\(\): asynchronous generator is already running'):
+            gen2.throw(MyExc)
+
+        with self.assertRaisesRegex(RuntimeError,
+                r"cannot reuse already awaited __anext__\(\)/asend\(\)"):
+            gen2.send(None)
+
+    def test_async_gen_athrow_throw_concurrent_with_send(self):
+        import types
+
+        @types.coroutine
+        def _async_yield(v):
+            return (yield v)
+
+        class MyExc(Exception):
+            pass
+
+        async def agenfn():
+            while True:
+                try:
+                    await _async_yield(None)
+                except MyExc:
+                    pass
+            return
+            yield
+
+
+        agen = agenfn()
+        gen = agen.asend(None)
+        gen.send(None)
+        gen2 = agen.athrow(MyExc)
+
+        with self.assertRaisesRegex(RuntimeError,
+                r'athrow\(\): asynchronous generator is already running'):
+            gen2.throw(MyExc)
+
+        with self.assertRaisesRegex(RuntimeError,
+                r"cannot reuse already awaited aclose\(\)/athrow\(\)"):
+            gen2.send(None)
+
+    def test_async_gen_asend_throw_concurrent_with_throw(self):
+        import types
+
+        @types.coroutine
+        def _async_yield(v):
+            return (yield v)
+
+        class MyExc(Exception):
+            pass
+
+        async def agenfn():
+            try:
+                yield
+            except MyExc:
+                pass
+            while True:
+                try:
+                    await _async_yield(None)
+                except MyExc:
+                    pass
+
+
+        agen = agenfn()
+        with self.assertRaises(StopIteration):
+            agen.asend(None).send(None)
+
+        gen = agen.athrow(MyExc)
+        gen.throw(MyExc)
+        gen2 = agen.asend(MyExc)
+
+        with self.assertRaisesRegex(RuntimeError,
+                r'anext\(\): asynchronous generator is already running'):
+            gen2.throw(MyExc)
+
+        with self.assertRaisesRegex(RuntimeError,
+                r"cannot reuse already awaited __anext__\(\)/asend\(\)"):
+            gen2.send(None)
+
+    def test_async_gen_athrow_throw_concurrent_with_throw(self):
+        import types
+
+        @types.coroutine
+        def _async_yield(v):
+            return (yield v)
+
+        class MyExc(Exception):
+            pass
+
+        async def agenfn():
+            try:
+                yield
+            except MyExc:
+                pass
+            while True:
+                try:
+                    await _async_yield(None)
+                except MyExc:
+                    pass
+
+        agen = agenfn()
+        with self.assertRaises(StopIteration):
+            agen.asend(None).send(None)
+
+        gen = agen.athrow(MyExc)
+        gen.throw(MyExc)
+        gen2 = agen.athrow(None)
+
+        with self.assertRaisesRegex(RuntimeError,
+                r'athrow\(\): asynchronous generator is already running'):
+            gen2.throw(MyExc)
+
+        with self.assertRaisesRegex(RuntimeError,
+                r"cannot reuse already awaited aclose\(\)/athrow\(\)"):
+            gen2.send(None)
+
+    def test_async_gen_3_arg_deprecation_warning(self):
+        async def gen():
+            yield 123
+
+        with self.assertWarns(DeprecationWarning):
+            x = gen().athrow(GeneratorExit, GeneratorExit(), None)
+        with self.assertRaises(GeneratorExit):
+            x.send(None)
+            del x
+            gc_collect()
+
     def test_async_gen_api_01(self):
         async def gen():
             yield 123
@@ -393,8 +567,57 @@ async def gen():
         self.assertIsInstance(g.ag_frame, types.FrameType)
         self.assertFalse(g.ag_running)
         self.assertIsInstance(g.ag_code, types.CodeType)
+        aclose = g.aclose()
+        self.assertTrue(inspect.isawaitable(aclose))
+        aclose.close()
+
+    def test_async_gen_asend_close_runtime_error(self):
+        import types
+
+        @types.coroutine
+        def _async_yield(v):
+            return (yield v)
 
-        self.assertTrue(inspect.isawaitable(g.aclose()))
+        async def agenfn():
+            try:
+                await _async_yield(None)
+            except GeneratorExit:
+                await _async_yield(None)
+            return
+            yield
+
+        agen = agenfn()
+        gen = agen.asend(None)
+        gen.send(None)
+        with self.assertRaisesRegex(RuntimeError, "coroutine ignored GeneratorExit"):
+            gen.close()
+
+    def test_async_gen_athrow_close_runtime_error(self):
+        import types
+
+        @types.coroutine
+        def _async_yield(v):
+            return (yield v)
+
+        class MyExc(Exception):
+            pass
+
+        async def agenfn():
+            try:
+                yield
+            except MyExc:
+                try:
+                    await _async_yield(None)
+                except GeneratorExit:
+                    await _async_yield(None)
+
+        agen = agenfn()
+        with self.assertRaises(StopIteration):
+            agen.asend(None).send(None)
+        gen = agen.athrow(MyExc)
+        gen.send(None)
+        with self.assertRaisesRegex(RuntimeError, "coroutine ignored GeneratorExit"):
+            gen.close()
 
 
 class AsyncGenAsyncioTest(unittest.TestCase):
@@ -406,7 +629,7 @@ def setUp(self):
     def tearDown(self):
         self.loop.close()
         self.loop = None
-        asyncio.set_event_loop_policy(None)
+        asyncio.events._set_event_loop_policy(None)
 
     def check_async_iterator_anext(self, ait_class):
         with self.subTest(anext="pure-Python"):
@@ -648,7 +871,7 @@ def test1(anext):
             agen = agenfn()
             with contextlib.closing(anext(agen, "default").__await__()) as g:
                 self.assertEqual(g.send(None), 1)
-                self.assertEqual(g.throw(MyError, MyError(), None), 2)
+                self.assertEqual(g.throw(MyError()), 2)
                 try:
                     g.send(None)
                 except StopIteration as e:
@@ -661,9 +884,9 @@ def test2(anext):
             agen = agenfn()
             with contextlib.closing(anext(agen, "default").__await__()) as g:
                 self.assertEqual(g.send(None), 1)
-                self.assertEqual(g.throw(MyError, MyError(), None), 2)
+                self.assertEqual(g.throw(MyError()), 2)
                 with self.assertRaises(MyError):
-                    g.throw(MyError, MyError(), None)
+                    g.throw(MyError())
 
         def test3(anext):
             agen = agenfn()
@@ -690,9 +913,9 @@ async def agenfn():
             agen = agenfn()
             with contextlib.closing(anext(agen, "default").__await__()) as g:
                 self.assertEqual(g.send(None), 10)
-                self.assertEqual(g.throw(MyError, MyError(), None), 20)
+                self.assertEqual(g.throw(MyError()), 20)
                 with self.assertRaisesRegex(MyError, 'val'):
-                    g.throw(MyError, MyError('val'), None)
+                    g.throw(MyError('val'))
 
         def test5(anext):
             @types.coroutine
@@ -711,7 +934,7 @@ async def agenfn():
             with contextlib.closing(anext(agen, "default").__await__()) as g:
                 self.assertEqual(g.send(None), 10)
                 with self.assertRaisesRegex(StopIteration, 'default'):
-                    g.throw(MyError, MyError(), None)
+                    g.throw(MyError())
 
         def test6(anext):
             @types.coroutine
@@ -726,7 +949,7 @@ async def agenfn():
             agen = agenfn()
             with contextlib.closing(anext(agen, "default").__await__()) as g:
                 with self.assertRaises(MyError):
-                    g.throw(MyError, MyError(), None)
+                    g.throw(MyError())
 
         def run_test(test):
             with self.subTest('pure-Python anext()'):
@@ -929,6 +1152,43 @@ async def run():
 
         self.loop.run_until_complete(run())
 
+    def test_async_gen_asyncio_anext_tuple_no_exceptions(self):
+        # StopAsyncIteration exceptions should be cleared.
+        # See: https://github.com/python/cpython/issues/128078.
+
+        async def foo():
+            if False:
+                yield (1, 2)
+
+        async def run():
+            it = foo().__aiter__()
+            with self.assertRaises(StopAsyncIteration):
+                await it.__anext__()
+            res = await anext(it, ('a', 'b'))
+            self.assertTupleEqual(res, ('a', 'b'))
+
+        self.loop.run_until_complete(run())
+
+    def test_sync_anext_raises_exception(self):
+        # See: https://github.com/python/cpython/issues/131670
+        msg = 'custom'
+        for exc_type in [
+            StopAsyncIteration,
+            StopIteration,
+            ValueError,
+            Exception,
+        ]:
+            exc = exc_type(msg)
+            with self.subTest(exc=exc):
+                class A:
+                    def __anext__(self):
+                        raise exc
+
+                with self.assertRaisesRegex(exc_type, msg):
+                    anext(A())
+                with self.assertRaisesRegex(exc_type, msg):
+                    anext(A(), 1)
+
     def test_async_gen_asyncio_anext_stopiteration(self):
         async def foo():
             try:
@@ -1035,8 +1295,7 @@ async def gen():
                 while True:
                     yield 1
             finally:
-                await asyncio.sleep(0.01)
-                await asyncio.sleep(0.01)
+                await asyncio.sleep(0)
                 DONE = 1
 
         async def run():
@@ -1046,7 +1305,10 @@ async def run():
             del g
             gc_collect()  # For PyPy or other GCs.
 
-            await asyncio.sleep(0.1)
+            # Starts running the aclose task
+            await asyncio.sleep(0)
+            # For asyncio.sleep(0) in finally block
+            await asyncio.sleep(0)
 
         self.loop.run_until_complete(run())
         self.assertEqual(DONE, 1)
@@ -1539,6 +1801,8 @@ async def main():
         self.assertIsInstance(message['exception'], ZeroDivisionError)
         self.assertIn('unhandled exception during asyncio.run() shutdown',
                       message['message'])
+        del message, messages
+        gc_collect()
 
     def test_async_gen_expression_01(self):
         async def arange(n):
@@ -1556,21 +1820,35 @@ async def run():
         res = self.loop.run_until_complete(run())
         self.assertEqual(res, [i * 2 for i in range(10)])
 
-    # TODO: RUSTPYTHON: async for gen expression compilation
-    # def test_async_gen_expression_02(self):
-    #     async def wrap(n):
-    #         await asyncio.sleep(0.01)
-    #         return n
+    def test_async_gen_expression_02(self):
+        async def wrap(n):
+            await asyncio.sleep(0.01)
+            return n
 
-    #     def make_arange(n):
-    #         # This syntax is legal starting with Python 3.7
-    #         return (i * 2 for i in range(n) if await wrap(i))
+        def make_arange(n):
+            # This syntax is legal starting with Python 3.7
+            return (i * 2 for i in range(n) if await wrap(i))
 
-    #     async def run():
-    #         return [i async for i in make_arange(10)]
+        async def run():
+            return [i async for i in make_arange(10)]
+
+        res = self.loop.run_until_complete(run())
+        self.assertEqual(res, [i * 2 for i in range(1, 10)])
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AttributeError: __aiter__
+    def test_async_gen_expression_incorrect(self):
+        async def ag():
+            yield 42
 
-    #     res = self.loop.run_until_complete(run())
-    #     self.assertEqual(res, [i * 2 for i in range(1, 10)])
+        async def run(arg):
+            (x async for x in arg)
+
+        err_msg_async = "'async for' requires an object with " \
+            "__aiter__ method, got .*"
+
+        self.loop.run_until_complete(run(ag()))
+        with self.assertRaisesRegex(TypeError, err_msg_async):
+            self.loop.run_until_complete(run(None))
 
     def test_asyncgen_nonstarted_hooks_are_cancellable(self):
         # See https://bugs.python.org/issue38013
@@ -1593,6 +1871,7 @@ async def main():
         asyncio.run(main())
 
         self.assertEqual([], messages)
+        gc_collect()
 
     def test_async_gen_await_same_anext_coro_twice(self):
         async def async_iterate():
@@ -1630,6 +1909,62 @@ async def run():
 
         self.loop.run_until_complete(run())
 
+    def test_async_gen_throw_same_aclose_coro_twice(self):
+        async def async_iterate():
+            yield 1
+            yield 2
+
+        it = async_iterate()
+        nxt = it.aclose()
+        with self.assertRaises(StopIteration):
+            nxt.throw(GeneratorExit)
+
+        with self.assertRaisesRegex(
+            RuntimeError,
+            r"cannot reuse already awaited aclose\(\)/athrow\(\)"
+        ):
+            nxt.throw(GeneratorExit)
+
+    def test_async_gen_throw_custom_same_aclose_coro_twice(self):
+        async def async_iterate():
+            yield 1
+            yield 2
+
+        it = async_iterate()
+
+        class MyException(Exception):
+            pass
+
+        nxt = it.aclose()
+        with self.assertRaises(MyException):
+            nxt.throw(MyException)
+
+        with self.assertRaisesRegex(
+            RuntimeError,
+            r"cannot reuse already awaited aclose\(\)/athrow\(\)"
+        ):
+            nxt.throw(MyException)
+
+    def test_async_gen_throw_custom_same_athrow_coro_twice(self):
+        async def async_iterate():
+            yield 1
+            yield 2
+
+        it = async_iterate()
+
+        class MyException(Exception):
+            pass
+
+        nxt = it.athrow(MyException)
+        with self.assertRaises(MyException):
+            nxt.throw(MyException)
+
+        with self.assertRaisesRegex(
+            RuntimeError,
+            r"cannot reuse already awaited aclose\(\)/athrow\(\)"
+        ):
+            nxt.throw(MyException)
+
     def test_async_gen_aclose_twice_with_different_coros(self):
         # Regression test for https://bugs.python.org/issue39606
         async def async_iterate():
@@ -1672,5 +2007,109 @@ async def run():
         self.loop.run_until_complete(run())
 
 
+class TestUnawaitedWarnings(unittest.TestCase):
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AssertionError: RuntimeWarning not triggered
+    def test_asend(self):
+        async def gen():
+            yield 1
+
+        # gh-113753: asend objects allocated from a free-list should warn.
+        # Ensure there is a finalized 'asend' object ready to be reused.
+        try:
+            g = gen()
+            g.asend(None).send(None)
+        except StopIteration:
+            pass
+
+        msg = f"coroutine method 'asend' of '{gen.__qualname__}' was never awaited"
+        with self.assertWarnsRegex(RuntimeWarning, msg):
+            g = gen()
+            g.asend(None)
+            gc_collect()
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AssertionError: RuntimeWarning not triggered
+    def test_athrow(self):
+        async def gen():
+            yield 1
+
+        msg = f"coroutine method 'athrow' of '{gen.__qualname__}' was never awaited"
+        with self.assertWarnsRegex(RuntimeWarning, msg):
+            g = gen()
+            g.athrow(RuntimeError)
+            gc_collect()
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AssertionError: RuntimeWarning not triggered
+    def test_aclose(self):
+        async def gen():
+            yield 1
+
+        msg = f"coroutine method 'aclose' of '{gen.__qualname__}' was never awaited"
+        with self.assertWarnsRegex(RuntimeWarning, msg):
+            g = gen()
+            g.aclose()
+            gc_collect()
+
+    def test_aclose_throw(self):
+        async def gen():
+            return
+            yield
+
+        class MyException(Exception):
+            pass
+
+        g = gen()
+        with self.assertRaises(MyException):
+            g.aclose().throw(MyException)
+
+        del g
+        gc_collect()  # does not warn unawaited
+
+    def test_asend_send_already_running(self):
+        @types.coroutine
+        def _async_yield(v):
+            return (yield v)
+
+        async def agenfn():
+            while True:
+                await _async_yield(1)
+            return
+            yield
+
+        agen = agenfn()
+        gen = agen.asend(None)
+        gen.send(None)
+        gen2 = agen.asend(None)
+
+        with self.assertRaisesRegex(RuntimeError,
+                r'anext\(\): asynchronous generator is already running'):
+            gen2.send(None)
+
+        del gen2
+        gc_collect()  # does not warn unawaited
+
+
+    def test_athrow_send_already_running(self):
+        @types.coroutine
+        def _async_yield(v):
+            return (yield v)
+
+        async def agenfn():
+            while True:
+                await _async_yield(1)
+            return
+            yield
+
+        agen = agenfn()
+        gen = agen.asend(None)
+        gen.send(None)
+        gen2 = agen.athrow(Exception)
+
+        with self.assertRaisesRegex(RuntimeError,
+                r'athrow\(\): asynchronous generator is already running'):
+            gen2.send(None)
+
+        del gen2
+        gc_collect()  # does not warn unawaited
+
 if __name__ == "__main__":
     unittest.main()
diff --git a/Lib/test/test_asyncio/functional.py b/Lib/test/test_asyncio/functional.py
index d19c7a612cc..96dc9ab4401 100644
--- a/Lib/test/test_asyncio/functional.py
+++ b/Lib/test/test_asyncio/functional.py
@@ -217,16 +217,15 @@ def stop(self):
                     pass
         finally:
             super().stop()
-
-    def run(self):
-        try:
-            with self._sock:
-                self._sock.setblocking(False)
-                self._run()
-        finally:
+            self._sock.close()
             self._s1.close()
             self._s2.close()
 
+
+    def run(self):
+        self._sock.setblocking(False)
+        self._run()
+
     def _run(self):
         while self._active:
             if self._clients >= self._max_clients:
diff --git a/Lib/test/test_asyncio/test_base_events.py b/Lib/test/test_asyncio/test_base_events.py
index 870be745098..92895bbb420 100644
--- a/Lib/test/test_asyncio/test_base_events.py
+++ b/Lib/test/test_asyncio/test_base_events.py
@@ -29,7 +29,7 @@ class CustomError(Exception):
 
 
 def tearDownModule():
-    asyncio.set_event_loop_policy(None)
+    asyncio.events._set_event_loop_policy(None)
 
 
 def mock_socket_module():
@@ -1019,8 +1019,7 @@ async def iter_one():
         asyncio.create_task(iter_one())
         return status
 
-    # TODO: RUSTPYTHON - GC doesn't finalize async generators
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; - GC doesn't finalize async generators
     def test_asyncgen_finalization_by_gc(self):
         # Async generators should be finalized when garbage collected.
         self.loop._process_events = mock.Mock()
@@ -1036,8 +1035,7 @@ def test_asyncgen_finalization_by_gc(self):
             test_utils.run_briefly(self.loop)
             self.assertTrue(status['finalized'])
 
-    # TODO: RUSTPYTHON - GC doesn't finalize async generators
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; - GC doesn't finalize async generators
     def test_asyncgen_finalization_by_gc_in_other_thread(self):
         # Python issue 34769: If garbage collector runs in another
         # thread, async generators will not finalize in debug
@@ -1413,7 +1411,7 @@ def getaddrinfo_task(*args, **kwds):
         with self.assertRaises(OSError) as cm:
             self.loop.run_until_complete(coro)
 
-        self.assertTrue(str(cm.exception).startswith('Multiple exceptions: '))
+        self.assertStartsWith(str(cm.exception), 'Multiple exceptions: ')
         self.assertTrue(m_socket.socket.return_value.close.called)
 
         coro = self.loop.create_connection(
diff --git a/Lib/test/test_asyncio/test_buffered_proto.py b/Lib/test/test_asyncio/test_buffered_proto.py
index f24e363ebfc..6d3edcc36f5 100644
--- a/Lib/test/test_asyncio/test_buffered_proto.py
+++ b/Lib/test/test_asyncio/test_buffered_proto.py
@@ -5,7 +5,7 @@
 
 
 def tearDownModule():
-    asyncio.set_event_loop_policy(None)
+    asyncio.events._set_event_loop_policy(None)
 
 
 class ReceiveStuffProto(asyncio.BufferedProtocol):
diff --git a/Lib/test/test_asyncio/test_context.py b/Lib/test/test_asyncio/test_context.py
index 6b80721873d..f85f39839cb 100644
--- a/Lib/test/test_asyncio/test_context.py
+++ b/Lib/test/test_asyncio/test_context.py
@@ -4,7 +4,7 @@
 
 
 def tearDownModule():
-    asyncio.set_event_loop_policy(None)
+    asyncio.events._set_event_loop_policy(None)
 
 
 @unittest.skipUnless(decimal.HAVE_CONTEXTVAR, "decimal is built with a thread-local context")
diff --git a/Lib/test/test_asyncio/test_eager_task_factory.py b/Lib/test/test_asyncio/test_eager_task_factory.py
index 179a6e44b59..0561b54a3f1 100644
--- a/Lib/test/test_asyncio/test_eager_task_factory.py
+++ b/Lib/test/test_asyncio/test_eager_task_factory.py
@@ -13,7 +13,7 @@
 
 
 def tearDownModule():
-    asyncio.set_event_loop_policy(None)
+    asyncio.events._set_event_loop_policy(None)
 
 
 class EagerTaskFactoryLoopTests:
@@ -263,19 +263,62 @@ async def run():
 
         self.run_coro(run())
 
+    def test_eager_start_false(self):
+        name = None
+
+        async def asyncfn():
+            nonlocal name
+            name = asyncio.current_task().get_name()
+
+        async def main():
+            t = asyncio.get_running_loop().create_task(
+                asyncfn(), eager_start=False, name="example"
+            )
+            self.assertFalse(t.done())
+            self.assertIsNone(name)
+            await t
+            self.assertEqual(name, "example")
+
+        self.run_coro(main())
+
 
 class PyEagerTaskFactoryLoopTests(EagerTaskFactoryLoopTests, test_utils.TestCase):
     Task = tasks._PyTask
 
+    def setUp(self):
+        self._all_tasks = asyncio.all_tasks
+        self._current_task = asyncio.current_task
+        asyncio.current_task = asyncio.tasks.current_task = asyncio.tasks._py_current_task
+        asyncio.all_tasks = asyncio.tasks.all_tasks = asyncio.tasks._py_all_tasks
+        return super().setUp()
+
+    def tearDown(self):
+        asyncio.current_task = asyncio.tasks.current_task = self._current_task
+        asyncio.all_tasks = asyncio.tasks.all_tasks = self._all_tasks
+        return super().tearDown()
+
+
 
 @unittest.skipUnless(hasattr(tasks, '_CTask'),
                      'requires the C _asyncio module')
 class CEagerTaskFactoryLoopTests(EagerTaskFactoryLoopTests, test_utils.TestCase):
     Task = getattr(tasks, '_CTask', None)
 
+    def setUp(self):
+        self._current_task = asyncio.current_task
+        self._all_tasks = asyncio.all_tasks
+        asyncio.current_task = asyncio.tasks.current_task = asyncio.tasks._c_current_task
+        asyncio.all_tasks = asyncio.tasks.all_tasks = asyncio.tasks._c_all_tasks
+        return super().setUp()
+
+    def tearDown(self):
+        asyncio.current_task = asyncio.tasks.current_task = self._current_task
+        asyncio.all_tasks = asyncio.tasks.all_tasks = self._all_tasks
+        return super().tearDown()
+
     def test_issue105987(self):
         code = """if 1:
-        from _asyncio import _swap_current_task
+        from _asyncio import _swap_current_task, _set_running_loop
 
         class DummyTask:
             pass
@@ -284,6 +327,7 @@ class DummyLoop:
             pass
 
         l = DummyLoop()
+        _set_running_loop(l)
         _swap_current_task(l, DummyTask())
         t = _swap_current_task(l, None)
         """
@@ -400,31 +444,102 @@ class BaseEagerTaskFactoryTests(BaseTaskCountingTests):
 
 
 class NonEagerTests(BaseNonEagerTaskFactoryTests, test_utils.TestCase):
-    Task = asyncio.Task
+    Task = asyncio.tasks._CTask
 
+    def setUp(self):
+        self._current_task = asyncio.current_task
+        asyncio.current_task = asyncio.tasks.current_task = asyncio.tasks._c_current_task
+        return super().setUp()
+
+    def tearDown(self):
+        asyncio.current_task = asyncio.tasks.current_task = self._current_task
+        return super().tearDown()
 
 class EagerTests(BaseEagerTaskFactoryTests, test_utils.TestCase):
-    Task = asyncio.Task
+    Task = asyncio.tasks._CTask
+
+    def setUp(self):
+        self._current_task = asyncio.current_task
+        asyncio.current_task = asyncio.tasks.current_task = asyncio.tasks._c_current_task
+        return super().setUp()
+
+    def tearDown(self):
+        asyncio.current_task = asyncio.tasks.current_task = self._current_task
+        return super().tearDown()
 
 
 class NonEagerPyTaskTests(BaseNonEagerTaskFactoryTests, test_utils.TestCase):
     Task = tasks._PyTask
 
+    def setUp(self):
+        self._current_task = asyncio.current_task
+        asyncio.current_task = asyncio.tasks.current_task = asyncio.tasks._py_current_task
+        return super().setUp()
+
+    def tearDown(self):
+        asyncio.current_task = asyncio.tasks.current_task = self._current_task
+        return super().tearDown()
+
 
 class EagerPyTaskTests(BaseEagerTaskFactoryTests, test_utils.TestCase):
     Task = tasks._PyTask
 
+    def setUp(self):
+        self._current_task = asyncio.current_task
+        asyncio.current_task = asyncio.tasks.current_task = asyncio.tasks._py_current_task
+        return super().setUp()
+
+    def tearDown(self):
+        asyncio.current_task = asyncio.tasks.current_task = self._current_task
+        return super().tearDown()
 
 @unittest.skipUnless(hasattr(tasks, '_CTask'),
                      'requires the C _asyncio module')
 class NonEagerCTaskTests(BaseNonEagerTaskFactoryTests, test_utils.TestCase):
     Task = getattr(tasks, '_CTask', None)
 
+    def setUp(self):
+        self._current_task = asyncio.current_task
+        asyncio.current_task = asyncio.tasks.current_task = asyncio.tasks._c_current_task
+        return super().setUp()
+
+    def tearDown(self):
+        asyncio.current_task = asyncio.tasks.current_task = self._current_task
+        return super().tearDown()
+
 
 @unittest.skipUnless(hasattr(tasks, '_CTask'),
                      'requires the C _asyncio module')
 class EagerCTaskTests(BaseEagerTaskFactoryTests, test_utils.TestCase):
     Task = getattr(tasks, '_CTask', None)
 
+    def setUp(self):
+        self._current_task = asyncio.current_task
+        asyncio.current_task = asyncio.tasks.current_task = asyncio.tasks._c_current_task
+        return super().setUp()
+
+    def tearDown(self):
+        asyncio.current_task = asyncio.tasks.current_task = self._current_task
+        return super().tearDown()
+
+
+class DefaultTaskFactoryEagerStart(test_utils.TestCase):
+    def test_eager_start_true_with_default_factory(self):
+        name = None
+
+        async def asyncfn():
+            nonlocal name
+            name = asyncio.current_task().get_name()
+
+        async def main():
+            t = asyncio.get_running_loop().create_task(
+                asyncfn(), eager_start=True, name="example"
+            )
+            self.assertTrue(t.done())
+            self.assertEqual(name, "example")
+            await t
+
+        asyncio.run(main(), loop_factory=asyncio.EventLoop)
+
 if __name__ == '__main__':
     unittest.main()
diff --git a/Lib/test/test_asyncio/test_events.py b/Lib/test/test_asyncio/test_events.py
index 2cbb96da696..b60c7452f3f 100644
--- a/Lib/test/test_asyncio/test_events.py
+++ b/Lib/test/test_asyncio/test_events.py
@@ -23,7 +23,6 @@
 import unittest
 from unittest import mock
 import weakref
-import warnings
 if sys.platform not in ('win32', 'vxworks'):
     import tty
 
@@ -38,9 +37,8 @@
 from test.support import threading_helper
 from test.support import ALWAYS_EQ, LARGEST, SMALLEST
 
-
 def tearDownModule():
-    asyncio.set_event_loop_policy(None)
+    asyncio.events._set_event_loop_policy(None)
 
 
 def broken_unix_getsockname():
@@ -275,8 +273,7 @@ def tearDown(self):
         support.gc_collect()
         super().tearDown()
 
-    # TODO: RUSTPYTHON - RuntimeWarning for unawaited coroutine not triggered
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; - RuntimeWarning for unawaited coroutine not triggered
     def test_run_until_complete_nesting(self):
         async def coro1():
             await asyncio.sleep(0)
@@ -356,6 +353,124 @@ def run_in_thread():
         t.join()
         self.assertEqual(results, ['hello', 'world'])
 
+    def test_call_soon_threadsafe_handle_block_check_cancelled(self):
+        results = []
+
+        callback_started = threading.Event()
+        callback_finished = threading.Event()
+        def callback(arg):
+            callback_started.set()
+            results.append(arg)
+            time.sleep(1)
+            callback_finished.set()
+
+        def run_in_thread():
+            handle = self.loop.call_soon_threadsafe(callback, 'hello')
+            self.assertIsInstance(handle, events._ThreadSafeHandle)
+            callback_started.wait()
+            # callback started so it should block checking for cancellation
+            # until it finishes
+            self.assertFalse(handle.cancelled())
+            self.assertTrue(callback_finished.is_set())
+            self.loop.call_soon_threadsafe(self.loop.stop)
+
+        t = threading.Thread(target=run_in_thread)
+        t.start()
+
+        self.loop.run_forever()
+        t.join()
+        self.assertEqual(results, ['hello'])
+
+    def test_call_soon_threadsafe_handle_block_cancellation(self):
+        results = []
+
+        callback_started = threading.Event()
+        callback_finished = threading.Event()
+        def callback(arg):
+            callback_started.set()
+            results.append(arg)
+            time.sleep(1)
+            callback_finished.set()
+
+        def run_in_thread():
+            handle = self.loop.call_soon_threadsafe(callback, 'hello')
+            self.assertIsInstance(handle, events._ThreadSafeHandle)
+            callback_started.wait()
+            # callback started so it cannot be cancelled from other thread until
+            # it finishes
+            handle.cancel()
+            self.assertTrue(callback_finished.is_set())
+            self.loop.call_soon_threadsafe(self.loop.stop)
+
+        t = threading.Thread(target=run_in_thread)
+        t.start()
+
+        self.loop.run_forever()
+        t.join()
+        self.assertEqual(results, ['hello'])
+
+    def test_call_soon_threadsafe_handle_cancel_same_thread(self):
+        results = []
+        callback_started = threading.Event()
+        callback_finished = threading.Event()
+
+        fut = concurrent.futures.Future()
+        def callback(arg):
+            callback_started.set()
+            handle = fut.result()
+            handle.cancel()
+            results.append(arg)
+            callback_finished.set()
+            self.loop.stop()
+
+        def run_in_thread():
+            handle = self.loop.call_soon_threadsafe(callback, 'hello')
+            fut.set_result(handle)
+            self.assertIsInstance(handle, events._ThreadSafeHandle)
+            callback_started.wait()
+            # callback cancels itself from same thread so it has no effect
+            # it runs to completion
+            self.assertTrue(handle.cancelled())
+            self.assertTrue(callback_finished.is_set())
+            self.loop.call_soon_threadsafe(self.loop.stop)
+
+        t = threading.Thread(target=run_in_thread)
+        t.start()
+
+        self.loop.run_forever()
+        t.join()
+        self.assertEqual(results, ['hello'])
+
+    def test_call_soon_threadsafe_handle_cancel_other_thread(self):
+        results = []
+        ev = threading.Event()
+
+        callback_finished = threading.Event()
+        def callback(arg):
+            results.append(arg)
+            callback_finished.set()
+            self.loop.stop()
+
+        def run_in_thread():
+            handle = self.loop.call_soon_threadsafe(callback, 'hello')
+            # handle can be cancelled from other thread if not started yet
+            self.assertIsInstance(handle, events._ThreadSafeHandle)
+            handle.cancel()
+            self.assertTrue(handle.cancelled())
+            self.assertFalse(callback_finished.is_set())
+            ev.set()
+            self.loop.call_soon_threadsafe(self.loop.stop)
+
+        # block the main loop until the callback is added and cancelled in the
+        # other thread
+        self.loop.call_soon(ev.wait)
+        t = threading.Thread(target=run_in_thread)
+        t.start()
+        self.loop.run_forever()
+        t.join()
+        self.assertEqual(results, [])
+        self.assertFalse(callback_finished.is_set())
+
     def test_call_soon_threadsafe_same_thread(self):
         results = []
 
@@ -445,8 +560,7 @@ def writer(data):
         r.close()
         self.assertEqual(read, data)
 
-    # TODO: RUSTPYTHON - signal handler implementation differs
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; - signal handler implementation differs
     @unittest.skipUnless(hasattr(signal, 'SIGKILL'), 'No SIGKILL')
     def test_add_signal_handler(self):
         caught = 0
@@ -1174,8 +1288,7 @@ def test_create_unix_server_ssl_verified(self):
         server.close()
         self.loop.run_until_complete(proto.done)
 
-    # TODO: RUSTPYTHON - SSL peer certificate format differs
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; - SSL peer certificate format differs
     @unittest.skipIf(ssl is None, 'No ssl module')
     def test_create_server_ssl_verified(self):
         proto = MyProto(loop=self.loop)
@@ -2073,7 +2186,7 @@ def test_subprocess_stderr(self):
 
         transp.close()
         self.assertEqual(b'OUT:test', proto.data[1])
-        self.assertTrue(proto.data[2].startswith(b'ERR:test'), proto.data[2])
+        self.assertStartsWith(proto.data[2], b'ERR:test')
         self.assertEqual(0, proto.returncode)
 
     @support.requires_subprocess()
@@ -2095,8 +2208,7 @@ def test_subprocess_stderr_redirect_to_stdout(self):
 
         stdin.write(b'test')
         self.loop.run_until_complete(proto.completed)
-        self.assertTrue(proto.data[1].startswith(b'OUT:testERR:test'),
-                        proto.data[1])
+        self.assertStartsWith(proto.data[1], b'OUT:testERR:test')
         self.assertEqual(b'', proto.data[2])
 
         transp.close()
@@ -2216,24 +2328,8 @@ def test_remove_fds_after_closing(self):
 else:
     import selectors
 
-    class UnixEventLoopTestsMixin(EventLoopTestsMixin):
-        def setUp(self):
-            super().setUp()
-            with warnings.catch_warnings():
-                warnings.simplefilter('ignore', DeprecationWarning)
-                watcher = asyncio.SafeChildWatcher()
-                watcher.attach_loop(self.loop)
-                asyncio.set_child_watcher(watcher)
-
-        def tearDown(self):
-            with warnings.catch_warnings():
-                warnings.simplefilter('ignore', DeprecationWarning)
-                asyncio.set_child_watcher(None)
-            super().tearDown()
-
-
     if hasattr(selectors, 'KqueueSelector'):
-        class KqueueEventLoopTests(UnixEventLoopTestsMixin,
+        class KqueueEventLoopTests(EventLoopTestsMixin,
                                    SubprocessTestsMixin,
                                    test_utils.TestCase):
 
@@ -2258,7 +2354,7 @@ def test_write_pty(self):
                 super().test_write_pty()
 
     if hasattr(selectors, 'EpollSelector'):
-        class EPollEventLoopTests(UnixEventLoopTestsMixin,
+        class EPollEventLoopTests(EventLoopTestsMixin,
                                   SubprocessTestsMixin,
                                   test_utils.TestCase):
 
@@ -2266,7 +2362,7 @@ def create_event_loop(self):
                 return asyncio.SelectorEventLoop(selectors.EpollSelector())
 
     if hasattr(selectors, 'PollSelector'):
-        class PollEventLoopTests(UnixEventLoopTestsMixin,
+        class PollEventLoopTests(EventLoopTestsMixin,
                                  SubprocessTestsMixin,
                                  test_utils.TestCase):
 
@@ -2274,7 +2370,7 @@ def create_event_loop(self):
                 return asyncio.SelectorEventLoop(selectors.PollSelector())
 
     # Should always exist.
-    class SelectEventLoopTests(UnixEventLoopTestsMixin,
+    class SelectEventLoopTests(EventLoopTestsMixin,
                                SubprocessTestsMixin,
                                test_utils.TestCase):
 
@@ -2420,7 +2516,7 @@ def test_handle_repr_debug(self):
         self.assertRegex(repr(h), regex)
 
     def test_handle_source_traceback(self):
-        loop = asyncio.get_event_loop_policy().new_event_loop()
+        loop = asyncio.new_event_loop()
         loop.set_debug(True)
         self.set_event_loop(loop)
 
@@ -2559,33 +2655,46 @@ def callback(*args):
 
         h1 = asyncio.TimerHandle(when, callback, (), self.loop)
         h2 = asyncio.TimerHandle(when, callback, (), self.loop)
-        # TODO: Use assertLess etc.
-        self.assertFalse(h1 < h2)
-        self.assertFalse(h2 < h1)
-        self.assertTrue(h1 <= h2)
-        self.assertTrue(h2 <= h1)
-        self.assertFalse(h1 > h2)
-        self.assertFalse(h2 > h1)
-        self.assertTrue(h1 >= h2)
-        self.assertTrue(h2 >= h1)
-        self.assertTrue(h1 == h2)
-        self.assertFalse(h1 != h2)
+        with self.assertRaises(AssertionError):
+            self.assertLess(h1, h2)
+        with self.assertRaises(AssertionError):
+            self.assertLess(h2, h1)
+        with self.assertRaises(AssertionError):
+            self.assertGreater(h1, h2)
+        with self.assertRaises(AssertionError):
+            self.assertGreater(h2, h1)
+        with self.assertRaises(AssertionError):
+            self.assertNotEqual(h1, h2)
+
+        self.assertLessEqual(h1, h2)
+        self.assertLessEqual(h2, h1)
+        self.assertGreaterEqual(h1, h2)
+        self.assertGreaterEqual(h2, h1)
+        self.assertEqual(h1, h2)
 
         h2.cancel()
-        self.assertFalse(h1 == h2)
+        with self.assertRaises(AssertionError):
+            self.assertEqual(h1, h2)
+        self.assertNotEqual(h1, h2)
 
         h1 = asyncio.TimerHandle(when, callback, (), self.loop)
         h2 = asyncio.TimerHandle(when + 10.0, callback, (), self.loop)
-        self.assertTrue(h1 < h2)
-        self.assertFalse(h2 < h1)
-        self.assertTrue(h1 <= h2)
-        self.assertFalse(h2 <= h1)
-        self.assertFalse(h1 > h2)
-        self.assertTrue(h2 > h1)
-        self.assertFalse(h1 >= h2)
-        self.assertTrue(h2 >= h1)
-        self.assertFalse(h1 == h2)
-        self.assertTrue(h1 != h2)
+        with self.assertRaises(AssertionError):
+            self.assertLess(h2, h1)
+        with self.assertRaises(AssertionError):
+            self.assertLessEqual(h2, h1)
+        with self.assertRaises(AssertionError):
+            self.assertGreater(h1, h2)
+        with self.assertRaises(AssertionError):
+            self.assertGreaterEqual(h1, h2)
+        with self.assertRaises(AssertionError):
+            self.assertEqual(h1, h2)
+
+        self.assertLess(h1, h2)
+        self.assertGreater(h2, h1)
+        self.assertLessEqual(h1, h2)
+        self.assertGreaterEqual(h2, h1)
+        self.assertNotEqual(h1, h2)
 
         h3 = asyncio.Handle(callback, (), self.loop)
         self.assertIs(NotImplemented, h1.__eq__(h3))
@@ -2599,19 +2708,25 @@ def callback(*args):
             h1 <= ()
         with self.assertRaises(TypeError):
             h1 >= ()
-        self.assertFalse(h1 == ())
-        self.assertTrue(h1 != ())
-
-        self.assertTrue(h1 == ALWAYS_EQ)
-        self.assertFalse(h1 != ALWAYS_EQ)
-        self.assertTrue(h1 < LARGEST)
-        self.assertFalse(h1 > LARGEST)
-        self.assertTrue(h1 <= LARGEST)
-        self.assertFalse(h1 >= LARGEST)
-        self.assertFalse(h1 < SMALLEST)
-        self.assertTrue(h1 > SMALLEST)
-        self.assertFalse(h1 <= SMALLEST)
-        self.assertTrue(h1 >= SMALLEST)
+        with self.assertRaises(AssertionError):
+            self.assertEqual(h1, ())
+        with self.assertRaises(AssertionError):
+            self.assertNotEqual(h1, ALWAYS_EQ)
+        with self.assertRaises(AssertionError):
+            self.assertGreater(h1, LARGEST)
+        with self.assertRaises(AssertionError):
+            self.assertGreaterEqual(h1, LARGEST)
+        with self.assertRaises(AssertionError):
+            self.assertLess(h1, SMALLEST)
+        with self.assertRaises(AssertionError):
+            self.assertLessEqual(h1, SMALLEST)
+
+        self.assertNotEqual(h1, ())
+        self.assertEqual(h1, ALWAYS_EQ)
+        self.assertLess(h1, LARGEST)
+        self.assertLessEqual(h1, LARGEST)
+        self.assertGreaterEqual(h1, SMALLEST)
+        self.assertGreater(h1, SMALLEST)
 
 
 class AbstractEventLoopTests(unittest.TestCase):
@@ -2718,58 +2833,54 @@ async def inner():
 
 class PolicyTests(unittest.TestCase):
 
+    def test_abstract_event_loop_policy_deprecation(self):
+        with self.assertWarnsRegex(
+                DeprecationWarning, "'asyncio.AbstractEventLoopPolicy' is deprecated"):
+            policy = asyncio.AbstractEventLoopPolicy()
+            self.assertIsInstance(policy, asyncio.AbstractEventLoopPolicy)
+
+    def test_default_event_loop_policy_deprecation(self):
+        with self.assertWarnsRegex(
+                DeprecationWarning, "'asyncio.DefaultEventLoopPolicy' is deprecated"):
+            policy = asyncio.DefaultEventLoopPolicy()
+            self.assertIsInstance(policy, asyncio.DefaultEventLoopPolicy)
+
     def test_event_loop_policy(self):
-        policy = asyncio.AbstractEventLoopPolicy()
+        policy = asyncio.events._AbstractEventLoopPolicy()
         self.assertRaises(NotImplementedError, policy.get_event_loop)
         self.assertRaises(NotImplementedError, policy.set_event_loop, object())
         self.assertRaises(NotImplementedError, policy.new_event_loop)
-        self.assertRaises(NotImplementedError, policy.get_child_watcher)
-        self.assertRaises(NotImplementedError, policy.set_child_watcher,
-                          object())
 
     def test_get_event_loop(self):
-        policy = asyncio.DefaultEventLoopPolicy()
+        policy = test_utils.DefaultEventLoopPolicy()
         self.assertIsNone(policy._local._loop)
-        with self.assertWarns(DeprecationWarning) as cm:
-            loop = policy.get_event_loop()
-        self.assertEqual(cm.filename, __file__)
-        self.assertIsInstance(loop, asyncio.AbstractEventLoop)
 
-        self.assertIs(policy._local._loop, loop)
-        self.assertIs(loop, policy.get_event_loop())
-        loop.close()
+        with self.assertRaises(RuntimeError):
+            loop = policy.get_event_loop()
+        self.assertIsNone(policy._local._loop)
 
-    def test_get_event_loop_calls_set_event_loop(self):
-        policy = asyncio.DefaultEventLoopPolicy()
+    def test_get_event_loop_does_not_call_set_event_loop(self):
+        policy = test_utils.DefaultEventLoopPolicy()
 
         with mock.patch.object(
                 policy, "set_event_loop",
                 wraps=policy.set_event_loop) as m_set_event_loop:
 
-            with self.assertWarns(DeprecationWarning) as cm:
+            with self.assertRaises(RuntimeError):
                 loop = policy.get_event_loop()
-            self.addCleanup(loop.close)
-            self.assertEqual(cm.filename, __file__)
 
-            # policy._local._loop must be set through .set_event_loop()
-            # (the unix DefaultEventLoopPolicy needs this call to attach
-            # the child watcher correctly)
-            m_set_event_loop.assert_called_with(loop)
-
-        loop.close()
+            m_set_event_loop.assert_not_called()
 
     def test_get_event_loop_after_set_none(self):
-        policy = asyncio.DefaultEventLoopPolicy()
+        policy = test_utils.DefaultEventLoopPolicy()
         policy.set_event_loop(None)
         self.assertRaises(RuntimeError, policy.get_event_loop)
 
-    # TODO: RUSTPYTHON - mock.patch doesn't work correctly with threading.current_thread
-    @unittest.expectedFailure
     @mock.patch('asyncio.events.threading.current_thread')
     def test_get_event_loop_thread(self, m_current_thread):
 
         def f():
-            policy = asyncio.DefaultEventLoopPolicy()
+            policy = test_utils.DefaultEventLoopPolicy()
             self.assertRaises(RuntimeError, policy.get_event_loop)
 
         th = threading.Thread(target=f)
@@ -2777,14 +2888,14 @@ def f():
         th.join()
 
     def test_new_event_loop(self):
-        policy = asyncio.DefaultEventLoopPolicy()
+        policy = test_utils.DefaultEventLoopPolicy()
 
         loop = policy.new_event_loop()
         self.assertIsInstance(loop, asyncio.AbstractEventLoop)
         loop.close()
 
     def test_set_event_loop(self):
-        policy = asyncio.DefaultEventLoopPolicy()
+        policy = test_utils.DefaultEventLoopPolicy()
         old_loop = policy.new_event_loop()
         policy.set_event_loop(old_loop)
 
@@ -2798,20 +2909,31 @@ def test_set_event_loop(self):
         old_loop.close()
 
     def test_get_event_loop_policy(self):
-        policy = asyncio.get_event_loop_policy()
-        self.assertIsInstance(policy, asyncio.AbstractEventLoopPolicy)
-        self.assertIs(policy, asyncio.get_event_loop_policy())
+        with self.assertWarnsRegex(
+                DeprecationWarning, "'asyncio.get_event_loop_policy' is deprecated"):
+            policy = asyncio.get_event_loop_policy()
+            self.assertIsInstance(policy, asyncio.events._AbstractEventLoopPolicy)
+            self.assertIs(policy, asyncio.get_event_loop_policy())
 
     def test_set_event_loop_policy(self):
-        self.assertRaises(
-            TypeError, asyncio.set_event_loop_policy, object())
+        with self.assertWarnsRegex(
+                DeprecationWarning, "'asyncio.set_event_loop_policy' is deprecated"):
+            self.assertRaises(
+                TypeError, asyncio.set_event_loop_policy, object())
+
+        with self.assertWarnsRegex(
+                DeprecationWarning, "'asyncio.get_event_loop_policy' is deprecated"):
+            old_policy = asyncio.get_event_loop_policy()
 
-        old_policy = asyncio.get_event_loop_policy()
+        policy = test_utils.DefaultEventLoopPolicy()
+        with self.assertWarnsRegex(
+                DeprecationWarning, "'asyncio.set_event_loop_policy' is deprecated"):
+            asyncio.set_event_loop_policy(policy)
 
-        policy = asyncio.DefaultEventLoopPolicy()
-        asyncio.set_event_loop_policy(policy)
-        self.assertIs(policy, asyncio.get_event_loop_policy())
-        self.assertIsNot(policy, old_policy)
+        with self.assertWarnsRegex(
+                DeprecationWarning, "'asyncio.get_event_loop_policy' is deprecated"):
+            self.assertIs(policy, asyncio.get_event_loop_policy())
+            self.assertIsNot(policy, old_policy)
 
 
 class GetEventLoopTestsMixin:
@@ -2821,11 +2943,16 @@ class GetEventLoopTestsMixin:
     get_running_loop_impl = None
     get_event_loop_impl = None
 
+    Task = None
+    Future = None
+
     def setUp(self):
         self._get_running_loop_saved = events._get_running_loop
         self._set_running_loop_saved = events._set_running_loop
         self.get_running_loop_saved = events.get_running_loop
         self.get_event_loop_saved = events.get_event_loop
+        self._Task_saved = asyncio.Task
+        self._Future_saved = asyncio.Future
 
         events._get_running_loop = type(self)._get_running_loop_impl
         events._set_running_loop = type(self)._set_running_loop_impl
@@ -2837,25 +2964,15 @@ def setUp(self):
         asyncio.get_running_loop = type(self).get_running_loop_impl
         asyncio.get_event_loop = type(self).get_event_loop_impl
 
+        asyncio.Task = asyncio.tasks.Task = type(self).Task
+        asyncio.Future = asyncio.futures.Future = type(self).Future
         super().setUp()
 
         self.loop = asyncio.new_event_loop()
         asyncio.set_event_loop(self.loop)
 
-        if sys.platform != 'win32':
-            with warnings.catch_warnings():
-                warnings.simplefilter('ignore', DeprecationWarning)
-                watcher = asyncio.SafeChildWatcher()
-                watcher.attach_loop(self.loop)
-                asyncio.set_child_watcher(watcher)
-
     def tearDown(self):
         try:
-            if sys.platform != 'win32':
-                with warnings.catch_warnings():
-                    warnings.simplefilter('ignore', DeprecationWarning)
-                    asyncio.set_child_watcher(None)
-
             super().tearDown()
         finally:
             self.loop.close()
@@ -2871,8 +2988,10 @@ def tearDown(self):
             asyncio.get_running_loop = self.get_running_loop_saved
             asyncio.get_event_loop = self.get_event_loop_saved
 
-    if sys.platform != 'win32':
+            asyncio.Task = asyncio.tasks.Task = self._Task_saved
+            asyncio.Future = asyncio.futures.Future = self._Future_saved
 
+    if sys.platform != 'win32':
         def test_get_event_loop_new_process(self):
             # bpo-32126: The multiprocessing module used by
             # ProcessPoolExecutor is not functional when the
@@ -2918,13 +3037,13 @@ def test_get_event_loop_returns_running_loop(self):
         class TestError(Exception):
             pass
 
-        class Policy(asyncio.DefaultEventLoopPolicy):
+        class Policy(test_utils.DefaultEventLoopPolicy):
             def get_event_loop(self):
                 raise TestError
 
-        old_policy = asyncio.get_event_loop_policy()
+        old_policy = asyncio.events._get_event_loop_policy()
         try:
-            asyncio.set_event_loop_policy(Policy())
+            asyncio.events._set_event_loop_policy(Policy())
             loop = asyncio.new_event_loop()
 
             with self.assertRaises(TestError):
@@ -2952,7 +3071,7 @@ async def func():
                 asyncio.get_event_loop()
 
         finally:
-            asyncio.set_event_loop_policy(old_policy)
+            asyncio.events._set_event_loop_policy(old_policy)
             if loop is not None:
                 loop.close()
 
@@ -2962,23 +3081,18 @@ async def func():
         self.assertIs(asyncio._get_running_loop(), None)
 
     def test_get_event_loop_returns_running_loop2(self):
-        old_policy = asyncio.get_event_loop_policy()
+        old_policy = asyncio.events._get_event_loop_policy()
         try:
-            asyncio.set_event_loop_policy(asyncio.DefaultEventLoopPolicy())
+            asyncio.events._set_event_loop_policy(test_utils.DefaultEventLoopPolicy())
             loop = asyncio.new_event_loop()
             self.addCleanup(loop.close)
 
-            with self.assertWarns(DeprecationWarning) as cm:
-                loop2 = asyncio.get_event_loop()
-            self.addCleanup(loop2.close)
-            self.assertEqual(cm.filename, __file__)
-            asyncio.set_event_loop(None)
             with self.assertRaisesRegex(RuntimeError, 'no current'):
                 asyncio.get_event_loop()
 
-            with self.assertRaisesRegex(RuntimeError, 'no running'):
-                asyncio.get_running_loop()
-            self.assertIs(asyncio._get_running_loop(), None)
+            asyncio.set_event_loop(None)
+            with self.assertRaisesRegex(RuntimeError, 'no current'):
+                asyncio.get_event_loop()
 
             async def func():
                 self.assertIs(asyncio.get_event_loop(), loop)
@@ -2995,7 +3109,7 @@ async def func():
                 asyncio.get_event_loop()
 
         finally:
-            asyncio.set_event_loop_policy(old_policy)
+            asyncio.events._set_event_loop_policy(old_policy)
             if loop is not None:
                 loop.close()
 
@@ -3012,6 +3126,8 @@ class TestPyGetEventLoop(GetEventLoopTestsMixin, unittest.TestCase):
     get_running_loop_impl = events._py_get_running_loop
     get_event_loop_impl = events._py_get_event_loop
 
+    Task = asyncio.tasks._PyTask
+    Future = asyncio.futures._PyFuture
 
 try:
     import _asyncio  # NoQA
@@ -3026,6 +3142,8 @@ class TestCGetEventLoop(GetEventLoopTestsMixin, unittest.TestCase):
         get_running_loop_impl = events._c_get_running_loop
         get_event_loop_impl = events._c_get_event_loop
 
+        Task = asyncio.tasks._CTask
+        Future = asyncio.futures._CFuture
 
 class TestServer(unittest.TestCase):
 
diff --git a/Lib/test/test_asyncio/test_free_threading.py b/Lib/test/test_asyncio/test_free_threading.py
new file mode 100644
index 00000000000..c8de0d24499
--- /dev/null
+++ b/Lib/test/test_asyncio/test_free_threading.py
@@ -0,0 +1,235 @@
+import asyncio
+import threading
+import unittest
+from threading import Thread
+from unittest import TestCase
+import weakref
+from test import support
+from test.support import threading_helper
+
+threading_helper.requires_working_threading(module=True)
+
+
+class MyException(Exception):
+    pass
+
+
+def tearDownModule():
+    asyncio.events._set_event_loop_policy(None)
+
+
+class TestFreeThreading:
+    def test_all_tasks_race(self) -> None:
+        async def main():
+            loop = asyncio.get_running_loop()
+            future = loop.create_future()
+
+            async def coro():
+                await future
+
+            tasks = set()
+
+            async with asyncio.TaskGroup() as tg:
+                for _ in range(100):
+                    tasks.add(tg.create_task(coro()))
+
+                all_tasks = asyncio.all_tasks(loop)
+                self.assertEqual(len(all_tasks), 101)
+
+                for task in all_tasks:
+                    self.assertEqual(task.get_loop(), loop)
+                    self.assertFalse(task.done())
+
+                current = asyncio.current_task()
+                self.assertEqual(current.get_loop(), loop)
+                self.assertSetEqual(all_tasks, tasks | {current})
+                future.set_result(None)
+
+        def runner():
+            with asyncio.Runner() as runner:
+                loop = runner.get_loop()
+                loop.set_task_factory(self.factory)
+                runner.run(main())
+
+        threads = []
+
+        for _ in range(10):
+            thread = Thread(target=runner)
+            threads.append(thread)
+
+        with threading_helper.start_threads(threads):
+            pass
+
+    def test_all_tasks_different_thread(self) -> None:
+        loop = None
+        started = threading.Event()
+        done = threading.Event() # used for main task not finishing early
+        async def coro():
+            await asyncio.Future()
+
+        lock = threading.Lock()
+        tasks = set()
+
+        async def main():
+            nonlocal tasks, loop
+            loop = asyncio.get_running_loop()
+            started.set()
+            for i in range(1000):
+                with lock:
+                    asyncio.create_task(coro())
+                    tasks = asyncio.all_tasks(loop)
+            done.wait()
+
+        runner = threading.Thread(target=lambda: asyncio.run(main()))
+
+        def check():
+            started.wait()
+            with lock:
+                self.assertSetEqual(tasks & asyncio.all_tasks(loop), tasks)
+
+        threads = [threading.Thread(target=check) for _ in range(10)]
+        runner.start()
+
+        with threading_helper.start_threads(threads):
+            pass
+
+        done.set()
+        runner.join()
+
+    def test_task_different_thread_finalized(self) -> None:
+        task = None
+        async def func():
+            nonlocal task
+            task = asyncio.current_task()
+        def runner():
+            with asyncio.Runner() as runner:
+                loop = runner.get_loop()
+                loop.set_task_factory(self.factory)
+                runner.run(func())
+        thread = Thread(target=runner)
+        thread.start()
+        thread.join()
+        wr = weakref.ref(task)
+        del thread
+        del task
+        # task finalization in different thread shouldn't crash
+        support.gc_collect()
+        self.assertIsNone(wr())
+
+    def test_run_coroutine_threadsafe(self) -> None:
+        results = []
+
+        def in_thread(loop: asyncio.AbstractEventLoop):
+            coro = asyncio.sleep(0.1, result=42)
+            fut = asyncio.run_coroutine_threadsafe(coro, loop)
+            result = fut.result()
+            self.assertEqual(result, 42)
+            results.append(result)
+
+        async def main():
+            loop = asyncio.get_running_loop()
+            async with asyncio.TaskGroup() as tg:
+                for _ in range(10):
+                    tg.create_task(asyncio.to_thread(in_thread, loop))
+            self.assertEqual(results, [42] * 10)
+
+        with asyncio.Runner() as r:
+            loop = r.get_loop()
+            loop.set_task_factory(self.factory)
+            r.run(main())
+
+    def test_run_coroutine_threadsafe_exception(self) -> None:
+        async def coro():
+            await asyncio.sleep(0)
+            raise MyException("test")
+
+        def in_thread(loop: asyncio.AbstractEventLoop):
+            fut = asyncio.run_coroutine_threadsafe(coro(), loop)
+            return fut.result()
+
+        async def main():
+            loop = asyncio.get_running_loop()
+            tasks = []
+            for _ in range(10):
+                task = loop.create_task(asyncio.to_thread(in_thread, loop))
+                tasks.append(task)
+            results = await asyncio.gather(*tasks, return_exceptions=True)
+
+            self.assertEqual(len(results), 10)
+            for result in results:
+                self.assertIsInstance(result, MyException)
+                self.assertEqual(str(result), "test")
+
+        with asyncio.Runner() as r:
+            loop = r.get_loop()
+            loop.set_task_factory(self.factory)
+            r.run(main())
+
+
+class TestPyFreeThreading(TestFreeThreading, TestCase):
+
+    def setUp(self):
+        self._old_current_task = asyncio.current_task
+        asyncio.current_task = asyncio.tasks.current_task = asyncio.tasks._py_current_task
+        self._old_all_tasks = asyncio.all_tasks
+        asyncio.all_tasks = asyncio.tasks.all_tasks = asyncio.tasks._py_all_tasks
+        self._old_Task = asyncio.Task
+        asyncio.Task = asyncio.tasks.Task = asyncio.tasks._PyTask
+        self._old_Future = asyncio.Future
+        asyncio.Future = asyncio.futures.Future = asyncio.futures._PyFuture
+        return super().setUp()
+
+    def tearDown(self):
+        asyncio.current_task = asyncio.tasks.current_task = self._old_current_task
+        asyncio.all_tasks = asyncio.tasks.all_tasks = self._old_all_tasks
+        asyncio.Task = asyncio.tasks.Task = self._old_Task
+        asyncio.Future = asyncio.tasks.Future = self._old_Future
+        return super().tearDown()
+
+    def factory(self, loop, coro, **kwargs):
+        return asyncio.tasks._PyTask(coro, loop=loop, **kwargs)
+
+    @unittest.skip("TODO: RUSTPYTHON; hangs - Python _current_tasks dict not thread-safe")
+    def test_all_tasks_race(self):
+        return super().test_all_tasks_race()
+
+
+@unittest.skipUnless(hasattr(asyncio.tasks, "_c_all_tasks"), "requires _asyncio")
+class TestCFreeThreading(TestFreeThreading, TestCase):
+
+    def setUp(self):
+        self._old_current_task = asyncio.current_task
+        asyncio.current_task = asyncio.tasks.current_task = asyncio.tasks._c_current_task
+        self._old_all_tasks = asyncio.all_tasks
+        asyncio.all_tasks = asyncio.tasks.all_tasks = asyncio.tasks._c_all_tasks
+        self._old_Task = asyncio.Task
+        asyncio.Task = asyncio.tasks.Task = asyncio.tasks._CTask
+        self._old_Future = asyncio.Future
+        asyncio.Future = asyncio.futures.Future = asyncio.futures._CFuture
+        return super().setUp()
+
+    def tearDown(self):
+        asyncio.current_task = asyncio.tasks.current_task = self._old_current_task
+        asyncio.all_tasks = asyncio.tasks.all_tasks = self._old_all_tasks
+        asyncio.Task = asyncio.tasks.Task = self._old_Task
+        asyncio.Future = asyncio.futures.Future = self._old_Future
+        return super().tearDown()
+
+
+    def factory(self, loop, coro, **kwargs):
+        return asyncio.tasks._CTask(coro, loop=loop, **kwargs)
+
+
+class TestEagerPyFreeThreading(TestPyFreeThreading):
+    def factory(self, loop, coro, eager_start=True, **kwargs):
+        return asyncio.tasks._PyTask(coro, loop=loop, **kwargs, eager_start=eager_start)
+
+    @unittest.skip("TODO: RUSTPYTHON; hangs - Python _current_tasks dict not thread-safe")
+    def test_all_tasks_race(self):
+        return super().test_all_tasks_race()
+
+
+@unittest.skipUnless(hasattr(asyncio.tasks, "_c_all_tasks"), "requires _asyncio")
+class TestEagerCFreeThreading(TestCFreeThreading, TestCase):
+    def factory(self, loop, coro, eager_start=True, **kwargs):
+        return asyncio.tasks._CTask(coro, loop=loop, **kwargs, eager_start=eager_start)
diff --git a/Lib/test/test_asyncio/test_futures.py b/Lib/test/test_asyncio/test_futures.py
index 571fbace020..54bf824fef7 100644
--- a/Lib/test/test_asyncio/test_futures.py
+++ b/Lib/test/test_asyncio/test_futures.py
@@ -17,7 +17,7 @@
 
 
 def tearDownModule():
-    asyncio.set_event_loop_policy(None)
+    asyncio.events._set_event_loop_policy(None)
 
 
 def _fakefunc(f):
@@ -242,7 +242,7 @@ def test_uninitialized(self):
 
     def test_future_cancel_message_getter(self):
         f = self._new_future(loop=self.loop)
-        self.assertTrue(hasattr(f, '_cancel_message'))
+        self.assertHasAttr(f, '_cancel_message')
         self.assertEqual(f._cancel_message, None)
 
         f.cancel('my message')
@@ -678,8 +678,6 @@ def __del__(self):
             fut = self._new_future(loop=self.loop)
             fut.set_result(Evil())
 
-    # TODO: RUSTPYTHON - gc.get_referrers not implemented
-    @unittest.expectedFailure
     def test_future_cancelled_result_refcycles(self):
         f = self._new_future(loop=self.loop)
         f.cancel()
@@ -691,8 +689,6 @@ def test_future_cancelled_result_refcycles(self):
         self.assertIsNotNone(exc)
         self.assertListEqual(gc.get_referrers(exc), [])
 
-    # TODO: RUSTPYTHON - gc.get_referrers not implemented
-    @unittest.expectedFailure
     def test_future_cancelled_exception_refcycles(self):
         f = self._new_future(loop=self.loop)
         f.cancel()
@@ -720,16 +716,6 @@ def test_future_del_segfault(self):
         with self.assertRaises(AttributeError):
             del fut._log_traceback
 
-    # TODO: RUSTPYTHON - gc.get_referents not implemented
-    @unittest.expectedFailure
-    def test_future_iter_get_referents_segfault(self):
-        # See https://github.com/python/cpython/issues/122695
-        import _asyncio
-        it = iter(self._new_future(loop=self.loop))
-        del it
-        evil = gc.get_referents(_asyncio)
-        gc.collect()
-
     def test_callbacks_copy(self):
         # See https://github.com/python/cpython/issues/125789
         # In C implementation, the `_callbacks` attribute
@@ -748,6 +734,10 @@ def test_callbacks_copy(self):
         fut.remove_done_callback(f2)
         self.assertIsNone(fut._callbacks)
 
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; - gc.get_referents not implemented
+    def test_future_iter_get_referents_segfault(self):
+        return super().test_future_iter_get_referents_segfault()
+
 
 @unittest.skipUnless(hasattr(futures, '_CFuture'),
                      'requires the C _asyncio module')
diff --git a/Lib/test/test_asyncio/test_futures2.py b/Lib/test/test_asyncio/test_futures2.py
index b7cfffb76bd..c7c0ebdac1b 100644
--- a/Lib/test/test_asyncio/test_futures2.py
+++ b/Lib/test/test_asyncio/test_futures2.py
@@ -7,7 +7,7 @@
 
 
 def tearDownModule():
-    asyncio.set_event_loop_policy(None)
+    asyncio.events._set_event_loop_policy(None)
 
 
 class FutureTests:
diff --git a/Lib/test/test_asyncio/test_graph.py b/Lib/test/test_asyncio/test_graph.py
new file mode 100644
index 00000000000..2f22fbccba4
--- /dev/null
+++ b/Lib/test/test_asyncio/test_graph.py
@@ -0,0 +1,445 @@
+import asyncio
+import io
+import unittest
+
+
+# To prevent a warning "test altered the execution environment"
+def tearDownModule():
+    asyncio.events._set_event_loop_policy(None)
+
+
+def capture_test_stack(*, fut=None, depth=1):
+
+    def walk(s):
+        ret = [
+            (f"T<{n}>" if '-' not in (n := s.future.get_name()) else 'T<anon>')
+                if isinstance(s.future, asyncio.Task) else 'F'
+        ]
+
+        ret.append(
+            [
+                (
+                    f"s {entry.frame.f_code.co_name}"
+                        if entry.frame.f_generator is None else
+                        (
+                            f"a {entry.frame.f_generator.cr_code.co_name}"
+                            if hasattr(entry.frame.f_generator, 'cr_code') else
+                            f"ag {entry.frame.f_generator.ag_code.co_name}"
+                        )
+                ) for entry in s.call_stack
+            ]
+        )
+
+        ret.append(
+            sorted([
+                walk(ab) for ab in s.awaited_by
+            ], key=lambda entry: entry[0])
+        )
+
+        return ret
+
+    buf = io.StringIO()
+    asyncio.print_call_graph(fut, file=buf, depth=depth+1)
+
+    stack = asyncio.capture_call_graph(fut, depth=depth)
+    return walk(stack), buf.getvalue()
+
+
+class CallStackTestBase:
+
+    async def test_stack_tgroup(self):
+
+        stack_for_c5 = None
+
+        def c5():
+            nonlocal stack_for_c5
+            stack_for_c5 = capture_test_stack(depth=2)
+
+        async def c4():
+            await asyncio.sleep(0)
+            c5()
+
+        async def c3():
+            await c4()
+
+        async def c2():
+            await c3()
+
+        async def c1(task):
+            await task
+
+        async def main():
+            async with asyncio.TaskGroup() as tg:
+                task = tg.create_task(c2(), name="c2_root")
+                tg.create_task(c1(task), name="sub_main_1")
+                tg.create_task(c1(task), name="sub_main_2")
+
+        await main()
+
+        self.assertEqual(stack_for_c5[0], [
+            # task name
+            'T<c2_root>',
+            # call stack
+            ['s c5', 'a c4', 'a c3', 'a c2'],
+            # awaited by
+            [
+                ['T<anon>',
+                     ['a _aexit', 'a __aexit__', 'a main', 'a test_stack_tgroup'], []
+                ],
+                ['T<sub_main_1>',
+                    ['a c1'],
+                    [
+                        ['T<anon>',
+                            ['a _aexit', 'a __aexit__', 'a main', 'a test_stack_tgroup'], []
+                        ]
+                    ]
+                ],
+                ['T<sub_main_2>',
+                    ['a c1'],
+                    [
+                        ['T<anon>',
+                            ['a _aexit', 'a __aexit__', 'a main', 'a test_stack_tgroup'], []
+                        ]
+                    ]
+                ]
+            ]
+        ])
+
+        self.assertIn(
+            ' async CallStackTestBase.test_stack_tgroup()',
+            stack_for_c5[1])
+
+
+    async def test_stack_async_gen(self):
+
+        stack_for_gen_nested_call = None
+
+        async def gen_nested_call():
+            nonlocal stack_for_gen_nested_call
+            stack_for_gen_nested_call = capture_test_stack()
+
+        async def gen():
+            for num in range(2):
+                yield num
+                if num == 1:
+                    await gen_nested_call()
+
+        async def main():
+            async for el in gen():
+                pass
+
+        await main()
+
+        self.assertEqual(stack_for_gen_nested_call[0], [
+            'T<anon>',
+            [
+                's capture_test_stack',
+                'a gen_nested_call',
+                'ag gen',
+                'a main',
+                'a test_stack_async_gen'
+            ],
+            []
+        ])
+
+        self.assertIn(
+            'async generator CallStackTestBase.test_stack_async_gen.<locals>.gen()',
+            stack_for_gen_nested_call[1])
+
+    async def test_stack_gather(self):
+
+        stack_for_deep = None
+
+        async def deep():
+            await asyncio.sleep(0)
+            nonlocal stack_for_deep
+            stack_for_deep = capture_test_stack()
+
+        async def c1():
+            await asyncio.sleep(0)
+            await deep()
+
+        async def c2():
+            await asyncio.sleep(0)
+
+        async def main():
+            await asyncio.gather(c1(), c2())
+
+        await main()
+
+        self.assertEqual(stack_for_deep[0], [
+            'T<anon>',
+            ['s capture_test_stack', 'a deep', 'a c1'],
+            [
+                ['T<anon>', ['a main', 'a test_stack_gather'], []]
+            ]
+        ])
+
+    async def test_stack_shield(self):
+
+        stack_for_shield = None
+
+        async def deep():
+            await asyncio.sleep(0)
+            nonlocal stack_for_shield
+            stack_for_shield = capture_test_stack()
+
+        async def c1():
+            await asyncio.sleep(0)
+            await deep()
+
+        async def main():
+            await asyncio.shield(c1())
+
+        await main()
+
+        self.assertEqual(stack_for_shield[0], [
+            'T<anon>',
+            ['s capture_test_stack', 'a deep', 'a c1'],
+            [
+                ['T<anon>', ['a main', 'a test_stack_shield'], []]
+            ]
+        ])
+
+    async def test_stack_timeout(self):
+
+        stack_for_inner = None
+
+        async def inner():
+            await asyncio.sleep(0)
+            nonlocal stack_for_inner
+            stack_for_inner = capture_test_stack()
+
+        async def c1():
+            async with asyncio.timeout(1):
+                await asyncio.sleep(0)
+                await inner()
+
+        async def main():
+            await asyncio.shield(c1())
+
+        await main()
+
+        self.assertEqual(stack_for_inner[0], [
+            'T<anon>',
+            ['s capture_test_stack', 'a inner', 'a c1'],
+            [
+                ['T<anon>', ['a main', 'a test_stack_timeout'], []]
+            ]
+        ])
+
+    async def test_stack_wait(self):
+
+        stack_for_inner = None
+
+        async def inner():
+            await asyncio.sleep(0)
+            nonlocal stack_for_inner
+            stack_for_inner = capture_test_stack()
+
+        async def c1():
+            async with asyncio.timeout(1):
+                await asyncio.sleep(0)
+                await inner()
+
+        async def c2():
+            for i in range(3):
+                await asyncio.sleep(0)
+
+        async def main(t1, t2):
+            while True:
+                _, pending = await asyncio.wait([t1, t2])
+                if not pending:
+                    break
+
+        t1 = asyncio.create_task(c1())
+        t2 = asyncio.create_task(c2())
+        try:
+            await main(t1, t2)
+        finally:
+            await t1
+            await t2
+
+        self.assertEqual(stack_for_inner[0], [
+            'T<anon>',
+            ['s capture_test_stack', 'a inner', 'a c1'],
+            [
+                ['T<anon>',
+                    ['a _wait', 'a wait', 'a main', 'a test_stack_wait'],
+                    []
+                ]
+            ]
+        ])
+
+    async def test_stack_task(self):
+
+        stack_for_inner = None
+
+        async def inner():
+            await asyncio.sleep(0)
+            nonlocal stack_for_inner
+            stack_for_inner = capture_test_stack()
+
+        async def c1():
+            await inner()
+
+        async def c2():
+            await asyncio.create_task(c1(), name='there there')
+
+        async def main():
+            await c2()
+
+        await main()
+
+        self.assertEqual(stack_for_inner[0], [
+            'T<there there>',
+            ['s capture_test_stack', 'a inner', 'a c1'],
+            [['T<anon>', ['a c2', 'a main', 'a test_stack_task'], []]]
+        ])
+
+    async def test_stack_future(self):
+
+        stack_for_fut = None
+
+        async def a2(fut):
+            await fut
+
+        async def a1(fut):
+            await a2(fut)
+
+        async def b1(fut):
+            await fut
+
+        async def main():
+            nonlocal stack_for_fut
+
+            fut = asyncio.Future()
+            async with asyncio.TaskGroup() as g:
+                g.create_task(a1(fut), name="task A")
+                g.create_task(b1(fut), name='task B')
+
+                for _ in range(5):
+                    # Do a few iterations to ensure that both a1 and b1
+                    # await on the future
+                    await asyncio.sleep(0)
+
+                stack_for_fut = capture_test_stack(fut=fut)
+                fut.set_result(None)
+
+        await main()
+
+        self.assertEqual(stack_for_fut[0],
+            ['F',
+            [],
+            [
+                ['T<task A>',
+                    ['a a2', 'a a1'],
+                    [['T<anon>', ['a test_stack_future'], []]]
+                ],
+                ['T<task B>',
+                    ['a b1'],
+                    [['T<anon>', ['a test_stack_future'], []]]
+                ],
+            ]]
+        )
+
+        self.assertTrue(stack_for_fut[1].startswith('* Future(id='))
+
+
+@unittest.skipIf(
+    not hasattr(asyncio.futures, "_c_future_add_to_awaited_by"),
+    "C-accelerated asyncio call graph backend missing",
+)
+class TestCallStackC(CallStackTestBase, unittest.IsolatedAsyncioTestCase):
+    def setUp(self):
+        futures = asyncio.futures
+        tasks = asyncio.tasks
+
+        self._Future = asyncio.Future
+        asyncio.Future = futures.Future = futures._CFuture
+
+        self._Task = asyncio.Task
+        asyncio.Task = tasks.Task = tasks._CTask
+
+        self._future_add_to_awaited_by = asyncio.future_add_to_awaited_by
+        futures.future_add_to_awaited_by = futures._c_future_add_to_awaited_by
+        asyncio.future_add_to_awaited_by = futures.future_add_to_awaited_by
+
+        self._future_discard_from_awaited_by = asyncio.future_discard_from_awaited_by
+        futures.future_discard_from_awaited_by = futures._c_future_discard_from_awaited_by
+        asyncio.future_discard_from_awaited_by = futures.future_discard_from_awaited_by
+
+        self._current_task = asyncio.current_task
+        asyncio.current_task = asyncio.tasks.current_task = tasks._c_current_task
+
+    def tearDown(self):
+        futures = asyncio.futures
+        tasks = asyncio.tasks
+
+        futures.future_discard_from_awaited_by = self._future_discard_from_awaited_by
+        asyncio.future_discard_from_awaited_by = self._future_discard_from_awaited_by
+        del self._future_discard_from_awaited_by
+
+        futures.future_add_to_awaited_by = self._future_add_to_awaited_by
+        asyncio.future_add_to_awaited_by = self._future_add_to_awaited_by
+        del self._future_add_to_awaited_by
+
+        asyncio.Task = self._Task
+        tasks.Task = self._Task
+        del self._Task
+
+        asyncio.Future = self._Future
+        futures.Future = self._Future
+        del self._Future
+
+        asyncio.current_task = asyncio.tasks.current_task = self._current_task
+
+
+@unittest.skipIf(
+    not hasattr(asyncio.futures, "_py_future_add_to_awaited_by"),
+    "Pure Python asyncio call graph backend missing",
+)
+class TestCallStackPy(CallStackTestBase, unittest.IsolatedAsyncioTestCase):
+    def setUp(self):
+        futures = asyncio.futures
+        tasks = asyncio.tasks
+
+        self._Future = asyncio.Future
+        asyncio.Future = futures.Future = futures._PyFuture
+
+        self._Task = asyncio.Task
+        asyncio.Task = tasks.Task = tasks._PyTask
+
+        self._future_add_to_awaited_by = asyncio.future_add_to_awaited_by
+        futures.future_add_to_awaited_by = futures._py_future_add_to_awaited_by
+        asyncio.future_add_to_awaited_by = futures.future_add_to_awaited_by
+
+        self._future_discard_from_awaited_by = asyncio.future_discard_from_awaited_by
+        futures.future_discard_from_awaited_by = futures._py_future_discard_from_awaited_by
+        asyncio.future_discard_from_awaited_by = futures.future_discard_from_awaited_by
+
+        self._current_task = asyncio.current_task
+        asyncio.current_task = asyncio.tasks.current_task = tasks._py_current_task
+
+
+    def tearDown(self):
+        futures = asyncio.futures
+        tasks = asyncio.tasks
+
+        futures.future_discard_from_awaited_by = self._future_discard_from_awaited_by
+        asyncio.future_discard_from_awaited_by = self._future_discard_from_awaited_by
+        del self._future_discard_from_awaited_by
+
+        futures.future_add_to_awaited_by = self._future_add_to_awaited_by
+        asyncio.future_add_to_awaited_by = self._future_add_to_awaited_by
+        del self._future_add_to_awaited_by
+
+        asyncio.Task = self._Task
+        tasks.Task = self._Task
+        del self._Task
+
+        asyncio.Future = self._Future
+        futures.Future = self._Future
+        del self._Future
+
+        asyncio.current_task = asyncio.tasks.current_task = self._current_task
diff --git a/Lib/test/test_asyncio/test_locks.py b/Lib/test/test_asyncio/test_locks.py
index a0884bffe6b..e025d2990a3 100644
--- a/Lib/test/test_asyncio/test_locks.py
+++ b/Lib/test/test_asyncio/test_locks.py
@@ -14,24 +14,24 @@
     r'(, value:\d)?'
     r'(, waiters:\d+)?'
     r'(, waiters:\d+\/\d+)?' # barrier
-    r')\]>\Z'
+    r')\]>\z'
 )
 RGX_REPR = re.compile(STR_RGX_REPR)
 
 
 def tearDownModule():
-    asyncio.set_event_loop_policy(None)
+    asyncio.events._set_event_loop_policy(None)
 
 
 class LockTests(unittest.IsolatedAsyncioTestCase):
 
     async def test_repr(self):
         lock = asyncio.Lock()
-        self.assertTrue(repr(lock).endswith('[unlocked]>'))
+        self.assertEndsWith(repr(lock), '[unlocked]>')
         self.assertTrue(RGX_REPR.match(repr(lock)))
 
         await lock.acquire()
-        self.assertTrue(repr(lock).endswith('[locked]>'))
+        self.assertEndsWith(repr(lock), '[locked]>')
         self.assertTrue(RGX_REPR.match(repr(lock)))
 
     async def test_lock(self):
@@ -39,7 +39,7 @@ async def test_lock(self):
 
         with self.assertRaisesRegex(
             TypeError,
-            "object Lock can't be used in 'await' expression"
+            "'Lock' object can't be awaited"
         ):
             await lock
 
@@ -77,7 +77,7 @@ async def test_lock_by_with_statement(self):
             self.assertFalse(lock.locked())
             with self.assertRaisesRegex(
                 TypeError,
-                r"object \w+ can't be used in 'await' expression"
+                r"'\w+' object can't be awaited"
             ):
                 with await lock:
                     pass
@@ -286,12 +286,12 @@ class EventTests(unittest.IsolatedAsyncioTestCase):
 
     def test_repr(self):
         ev = asyncio.Event()
-        self.assertTrue(repr(ev).endswith('[unset]>'))
+        self.assertEndsWith(repr(ev), '[unset]>')
         match = RGX_REPR.match(repr(ev))
         self.assertEqual(match.group('extras'), 'unset')
 
         ev.set()
-        self.assertTrue(repr(ev).endswith('[set]>'))
+        self.assertEndsWith(repr(ev), '[set]>')
         self.assertTrue(RGX_REPR.match(repr(ev)))
 
         ev._waiters.append(mock.Mock())
@@ -916,11 +916,11 @@ def test_initial_value_zero(self):
 
     async def test_repr(self):
         sem = asyncio.Semaphore()
-        self.assertTrue(repr(sem).endswith('[unlocked, value:1]>'))
+        self.assertEndsWith(repr(sem), '[unlocked, value:1]>')
         self.assertTrue(RGX_REPR.match(repr(sem)))
 
         await sem.acquire()
-        self.assertTrue(repr(sem).endswith('[locked]>'))
+        self.assertEndsWith(repr(sem), '[locked]>')
         self.assertTrue('waiters' not in repr(sem))
         self.assertTrue(RGX_REPR.match(repr(sem)))
 
@@ -941,7 +941,7 @@ async def test_semaphore(self):
 
         with self.assertRaisesRegex(
             TypeError,
-            "object Semaphore can't be used in 'await' expression",
+            "'Semaphore' object can't be awaited",
         ):
             await sem
 
@@ -1194,14 +1194,14 @@ async def c3(result):
         self.assertEqual([2, 3], result)
 
     async def test_acquire_fifo_order_4(self):
-        # Test that a successfule `acquire()` will wake up multiple Tasks
+        # Test that a successful `acquire()` will wake up multiple Tasks
         # that were waiting in the Semaphore queue due to FIFO rules.
         sem = asyncio.Semaphore(0)
         result = []
         count = 0
 
         async def c1(result):
-            # First task immediatlly waits for semaphore.  It will be awoken by c2.
+            # First task immediately waits for semaphore.  It will be awoken by c2.
             self.assertEqual(sem._value, 0)
             await sem.acquire()
             # We should have woken up all waiting tasks now.
@@ -1270,7 +1270,7 @@ async def test_barrier(self):
         self.assertIn("filling", repr(barrier))
         with self.assertRaisesRegex(
             TypeError,
-            "object Barrier can't be used in 'await' expression",
+            "'Barrier' object can't be awaited",
         ):
             await barrier
 
@@ -1475,13 +1475,13 @@ async def coro():
             # first time waiting
             await barrier.wait()
 
-            # after wainting once for all tasks
+            # after waiting once for all tasks
             if rewait_n > 0:
                 rewait_n -= 1
                 # wait again only for rewait tasks
                 await barrier.wait()
             else:
-                # wait for end of draining state`
+                # wait for end of draining state
                 await barrier_nowaiting.wait()
                 # wait for other waiting tasks
                 await barrier.wait()
@@ -1780,7 +1780,7 @@ async def coro():
         self.assertEqual(barrier.n_waiting, 0)
 
     async def test_abort_barrier_when_exception_then_resetting(self):
-        # test from threading.Barrier: see `lock_tests.test_abort_and_reset``
+        # test from threading.Barrier: see `lock_tests.test_abort_and_reset`
         barrier1 = asyncio.Barrier(self.N)
         barrier2 = asyncio.Barrier(self.N)
         results1 = []
diff --git a/Lib/test/test_asyncio/test_pep492.py b/Lib/test/test_asyncio/test_pep492.py
index dc25a46985e..a0c8434c945 100644
--- a/Lib/test/test_asyncio/test_pep492.py
+++ b/Lib/test/test_asyncio/test_pep492.py
@@ -11,7 +11,7 @@
 
 
 def tearDownModule():
-    asyncio.set_event_loop_policy(None)
+    asyncio.events._set_event_loop_policy(None)
 
 
 # Test that asyncio.iscoroutine() uses collections.abc.Coroutine
@@ -77,7 +77,7 @@ async def test(lock):
             self.assertFalse(lock.locked())
             with self.assertRaisesRegex(
                 TypeError,
-                "can't be used in 'await' expression"
+                "can't be awaited"
             ):
                 with await lock:
                     pass
@@ -124,10 +124,10 @@ def foo(): yield
 
         self.assertFalse(asyncio.iscoroutine(foo()))
 
-
     def test_iscoroutinefunction(self):
         async def foo(): pass
-        self.assertTrue(asyncio.iscoroutinefunction(foo))
+        with self.assertWarns(DeprecationWarning):
+            self.assertTrue(asyncio.iscoroutinefunction(foo))
 
     def test_async_def_coroutines(self):
         async def bar():
diff --git a/Lib/test/test_asyncio/test_proactor_events.py b/Lib/test/test_asyncio/test_proactor_events.py
index 40cb5213c63..edfad5e11db 100644
--- a/Lib/test/test_asyncio/test_proactor_events.py
+++ b/Lib/test/test_asyncio/test_proactor_events.py
@@ -18,7 +18,7 @@
 
 
 def tearDownModule():
-    asyncio.set_event_loop_policy(None)
+    asyncio.events._set_event_loop_policy(None)
 
 
 def close_transport(transport):
diff --git a/Lib/test/test_asyncio/test_protocols.py b/Lib/test/test_asyncio/test_protocols.py
index 0f232631867..29d3bd22705 100644
--- a/Lib/test/test_asyncio/test_protocols.py
+++ b/Lib/test/test_asyncio/test_protocols.py
@@ -7,7 +7,7 @@
 def tearDownModule():
     # not needed for the test file but added for uniformness with all other
     # asyncio test files for the sake of unified cleanup
-    asyncio.set_event_loop_policy(None)
+    asyncio.events._set_event_loop_policy(None)
 
 
 class ProtocolsAbsTests(unittest.TestCase):
@@ -19,7 +19,7 @@ def test_base_protocol(self):
         self.assertIsNone(p.connection_lost(f))
         self.assertIsNone(p.pause_writing())
         self.assertIsNone(p.resume_writing())
-        self.assertFalse(hasattr(p, '__dict__'))
+        self.assertNotHasAttr(p, '__dict__')
 
     def test_protocol(self):
         f = mock.Mock()
@@ -30,7 +30,7 @@ def test_protocol(self):
         self.assertIsNone(p.eof_received())
         self.assertIsNone(p.pause_writing())
         self.assertIsNone(p.resume_writing())
-        self.assertFalse(hasattr(p, '__dict__'))
+        self.assertNotHasAttr(p, '__dict__')
 
     def test_buffered_protocol(self):
         f = mock.Mock()
@@ -41,7 +41,7 @@ def test_buffered_protocol(self):
         self.assertIsNone(p.buffer_updated(150))
         self.assertIsNone(p.pause_writing())
         self.assertIsNone(p.resume_writing())
-        self.assertFalse(hasattr(p, '__dict__'))
+        self.assertNotHasAttr(p, '__dict__')
 
     def test_datagram_protocol(self):
         f = mock.Mock()
@@ -50,7 +50,7 @@ def test_datagram_protocol(self):
         self.assertIsNone(dp.connection_lost(f))
         self.assertIsNone(dp.error_received(f))
         self.assertIsNone(dp.datagram_received(f, f))
-        self.assertFalse(hasattr(dp, '__dict__'))
+        self.assertNotHasAttr(dp, '__dict__')
 
     def test_subprocess_protocol(self):
         f = mock.Mock()
@@ -60,7 +60,7 @@ def test_subprocess_protocol(self):
         self.assertIsNone(sp.pipe_data_received(1, f))
         self.assertIsNone(sp.pipe_connection_lost(1, f))
         self.assertIsNone(sp.process_exited())
-        self.assertFalse(hasattr(sp, '__dict__'))
+        self.assertNotHasAttr(sp, '__dict__')
 
 
 if __name__ == '__main__':
diff --git a/Lib/test/test_asyncio/test_queues.py b/Lib/test/test_asyncio/test_queues.py
index 5019e9a2935..54bbe79f81f 100644
--- a/Lib/test/test_asyncio/test_queues.py
+++ b/Lib/test/test_asyncio/test_queues.py
@@ -6,7 +6,7 @@
 
 
 def tearDownModule():
-    asyncio.set_event_loop_policy(None)
+    asyncio.events._set_event_loop_policy(None)
 
 
 class QueueBasicTests(unittest.IsolatedAsyncioTestCase):
@@ -18,7 +18,7 @@ async def _test_repr_or_str(self, fn, expect_id):
         appear in fn(Queue()).
         """
         q = asyncio.Queue()
-        self.assertTrue(fn(q).startswith('<Queue'), fn(q))
+        self.assertStartsWith(fn(q), '<Queue')
         id_is_present = hex(id(q)) in fn(q)
         self.assertEqual(expect_id, id_is_present)
 
diff --git a/Lib/test/test_asyncio/test_runners.py b/Lib/test/test_asyncio/test_runners.py
index e86026b3250..de489c2dc43 100644
--- a/Lib/test/test_asyncio/test_runners.py
+++ b/Lib/test/test_asyncio/test_runners.py
@@ -12,14 +12,14 @@
 
 
 def tearDownModule():
-    asyncio.set_event_loop_policy(None)
+    asyncio.events._set_event_loop_policy(None)
 
 
 def interrupt_self():
     _thread.interrupt_main()
 
 
-class TestPolicy(asyncio.AbstractEventLoopPolicy):
+class TestPolicy(asyncio.events._AbstractEventLoopPolicy):
 
     def __init__(self, loop_factory):
         self.loop_factory = loop_factory
@@ -61,15 +61,15 @@ def setUp(self):
         super().setUp()
 
         policy = TestPolicy(self.new_loop)
-        asyncio.set_event_loop_policy(policy)
+        asyncio.events._set_event_loop_policy(policy)
 
     def tearDown(self):
-        policy = asyncio.get_event_loop_policy()
+        policy = asyncio.events._get_event_loop_policy()
         if policy.loop is not None:
             self.assertTrue(policy.loop.is_closed())
             self.assertTrue(policy.loop.shutdown_ag_run)
 
-        asyncio.set_event_loop_policy(None)
+        asyncio.events._set_event_loop_policy(None)
         super().tearDown()
 
 
@@ -93,8 +93,8 @@ async def main():
     def test_asyncio_run_only_coro(self):
         for o in {1, lambda: None}:
             with self.subTest(obj=o), \
-                    self.assertRaisesRegex(ValueError,
-                                           'a coroutine was expected'):
+                    self.assertRaisesRegex(TypeError,
+                                           'an awaitable is required'):
                 asyncio.run(o)
 
     def test_asyncio_run_debug(self):
@@ -208,7 +208,7 @@ async def main():
             await asyncio.sleep(0)
             return 42
 
-        policy = asyncio.get_event_loop_policy()
+        policy = asyncio.events._get_event_loop_policy()
         policy.set_event_loop = mock.Mock()
         asyncio.run(main())
         self.assertTrue(policy.set_event_loop.called)
@@ -259,7 +259,7 @@ def new_event_loop():
             loop.set_task_factory(Task)
             return loop
 
-        asyncio.set_event_loop_policy(TestPolicy(new_event_loop))
+        asyncio.events._set_event_loop_policy(TestPolicy(new_event_loop))
         with self.assertRaises(asyncio.CancelledError):
             asyncio.run(main())
 
@@ -319,19 +319,28 @@ async def f():
     def test_run_non_coro(self):
         with asyncio.Runner() as runner:
             with self.assertRaisesRegex(
-                ValueError,
-                "a coroutine was expected"
+                TypeError,
+                "an awaitable is required"
             ):
                 runner.run(123)
 
     def test_run_future(self):
         with asyncio.Runner() as runner:
-            with self.assertRaisesRegex(
-                ValueError,
-                "a coroutine was expected"
-            ):
-                fut = runner.get_loop().create_future()
-                runner.run(fut)
+            fut = runner.get_loop().create_future()
+            fut.set_result('done')
+            self.assertEqual('done', runner.run(fut))
+
+    def test_run_awaitable(self):
+        class MyAwaitable:
+            def __await__(self):
+                return self.run().__await__()
+
+            @staticmethod
+            async def run():
+                return 'done'
+
+        with asyncio.Runner() as runner:
+            self.assertEqual('done', runner.run(MyAwaitable()))
 
     def test_explicit_close(self):
         runner = asyncio.Runner()
@@ -393,8 +402,7 @@ async def get_context():
 
             self.assertEqual(2, runner.run(get_context()).get(cvar))
 
-    # TODO: RUSTPYTHON - RuntimeWarning for unawaited coroutine not triggered
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; - RuntimeWarning for unawaited coroutine not triggered
     def test_recursive_run(self):
         async def g():
             pass
@@ -488,7 +496,7 @@ def test_set_event_loop_called_once(self):
         async def coro():
             pass
 
-        policy = asyncio.get_event_loop_policy()
+        policy = asyncio.events._get_event_loop_policy()
         policy.set_event_loop = mock.Mock()
         runner = asyncio.Runner()
         runner.run(coro())
diff --git a/Lib/test/test_asyncio/test_selector_events.py b/Lib/test/test_asyncio/test_selector_events.py
index bfb347e4a8c..4bb5d4fb816 100644
--- a/Lib/test/test_asyncio/test_selector_events.py
+++ b/Lib/test/test_asyncio/test_selector_events.py
@@ -24,7 +24,7 @@
 
 
 def tearDownModule():
-    asyncio.set_event_loop_policy(None)
+    asyncio.events._set_event_loop_policy(None)
 
 
 class TestBaseSelectorEventLoop(BaseSelectorEventLoop):
@@ -347,6 +347,18 @@ def test_process_events_write_cancelled(self):
               selectors.EVENT_WRITE)])
         self.loop._remove_writer.assert_called_with(1)
 
+    def test_accept_connection_zero_one(self):
+        for backlog in [0, 1]:
+            sock = mock.Mock()
+            sock.accept.return_value = (mock.Mock(), mock.Mock())
+            with self.subTest(backlog):
+                mock_obj = mock.patch.object
+                with mock_obj(self.loop, '_accept_connection2') as accept2_mock:
+                    self.loop._accept_connection(
+                        mock.Mock(), sock, backlog=backlog)
+                self.loop.run_until_complete(asyncio.sleep(0))
+                self.assertEqual(sock.accept.call_count, backlog + 1)
+
     def test_accept_connection_multiple(self):
         sock = mock.Mock()
         sock.accept.return_value = (mock.Mock(), mock.Mock())
@@ -362,8 +374,33 @@ def test_accept_connection_multiple(self):
             self.loop._accept_connection(
                 mock.Mock(), sock, backlog=backlog)
         self.loop.run_until_complete(asyncio.sleep(0))
-        self.assertEqual(sock.accept.call_count, backlog)
+        self.assertEqual(sock.accept.call_count, backlog + 1)
+
+    def test_accept_connection_skip_connectionabortederror(self):
+        sock = mock.Mock()
 
+        def mock_sock_accept():
+            # mock accept(2) returning -ECONNABORTED every-other
+            # time that it's called. This applies most to OpenBSD
+            # whose sockets generate this errno more reproducibly than
+            # Linux and other OS.
+            if sock.accept.call_count % 2 == 0:
+                raise ConnectionAbortedError
+            return (mock.Mock(), mock.Mock())
+
+        sock.accept.side_effect = mock_sock_accept
+        backlog = 100
+        # test that _accept_connection's loop calls sock.accept
+        # all 100 times, continuing past ConnectionAbortedError
+        # instead of unnecessarily returning early
+        mock_obj = mock.patch.object
+        with mock_obj(self.loop, '_accept_connection2') as accept2_mock:
+            self.loop._accept_connection(
+                mock.Mock(), sock, backlog=backlog)
+        # as in test_accept_connection_multiple avoid task pending
+        # warnings by using asyncio.sleep(0)
+        self.loop.run_until_complete(asyncio.sleep(0))
+        self.assertEqual(sock.accept.call_count, backlog + 1)
 
 class SelectorTransportTests(test_utils.TestCase):
 
@@ -1077,7 +1114,7 @@ def _resume_writing():
         self.assertFalse(self.protocol.connection_lost.called)
 
         self.loop.writers[7]._run()
-        # during this ^ run, the _resume_writing mock above was called and added more data
+        # during this ^ run, the _resume_writing mock above was called and added more data
 
         self.assertEqual(transport.get_write_buffer_size(), 2)
         self.loop.writers[7]._run()
diff --git a/Lib/test/test_asyncio/test_sendfile.py b/Lib/test/test_asyncio/test_sendfile.py
index 2509d4382cd..dcd963b3355 100644
--- a/Lib/test/test_asyncio/test_sendfile.py
+++ b/Lib/test/test_asyncio/test_sendfile.py
@@ -22,7 +22,7 @@
 
 
 def tearDownModule():
-    asyncio.set_event_loop_policy(None)
+    asyncio.events._set_event_loop_policy(None)
 
 
 class MySendfileProto(asyncio.Protocol):
diff --git a/Lib/test/test_asyncio/test_server.py b/Lib/test/test_asyncio/test_server.py
index 60a40cc8349..5bd0f7e2af4 100644
--- a/Lib/test/test_asyncio/test_server.py
+++ b/Lib/test/test_asyncio/test_server.py
@@ -11,7 +11,7 @@
 
 
 def tearDownModule():
-    asyncio.set_event_loop_policy(None)
+    asyncio.events._set_event_loop_policy(None)
 
 
 class BaseStartServer(func_tests.FunctionalTestCaseMixin):
diff --git a/Lib/test/test_asyncio/test_sock_lowlevel.py b/Lib/test/test_asyncio/test_sock_lowlevel.py
index acef24a703b..df4ec794897 100644
--- a/Lib/test/test_asyncio/test_sock_lowlevel.py
+++ b/Lib/test/test_asyncio/test_sock_lowlevel.py
@@ -15,7 +15,7 @@
 
 
 def tearDownModule():
-    asyncio.set_event_loop_policy(None)
+    asyncio.events._set_event_loop_policy(None)
 
 
 class MyProto(asyncio.Protocol):
@@ -110,7 +110,7 @@ def _basetest_sock_client_ops(self, httpd, sock):
         self.loop.run_until_complete(
             self.loop.sock_recv(sock, 1024))
         sock.close()
-        self.assertTrue(data.startswith(b'HTTP/1.0 200 OK'))
+        self.assertStartsWith(data, b'HTTP/1.0 200 OK')
 
     def _basetest_sock_recv_into(self, httpd, sock):
         # same as _basetest_sock_client_ops, but using sock_recv_into
@@ -127,7 +127,7 @@ def _basetest_sock_recv_into(self, httpd, sock):
             self.loop.run_until_complete(
                 self.loop.sock_recv_into(sock, buf[nbytes:]))
         sock.close()
-        self.assertTrue(data.startswith(b'HTTP/1.0 200 OK'))
+        self.assertStartsWith(data, b'HTTP/1.0 200 OK')
 
     def test_sock_client_ops(self):
         with test_utils.run_test_server() as httpd:
@@ -150,7 +150,7 @@ async def _basetest_sock_recv_racing(self, httpd, sock):
         # consume data
         await self.loop.sock_recv(sock, 1024)
 
-        self.assertTrue(data.startswith(b'HTTP/1.0 200 OK'))
+        self.assertStartsWith(data, b'HTTP/1.0 200 OK')
 
     async def _basetest_sock_recv_into_racing(self, httpd, sock):
         sock.setblocking(False)
@@ -168,7 +168,7 @@ async def _basetest_sock_recv_into_racing(self, httpd, sock):
             nbytes = await self.loop.sock_recv_into(sock, buf[:1024])
             # consume data
             await self.loop.sock_recv_into(sock, buf[nbytes:])
-            self.assertTrue(data.startswith(b'HTTP/1.0 200 OK'))
+            self.assertStartsWith(data, b'HTTP/1.0 200 OK')
 
         await task
 
@@ -217,7 +217,7 @@ async def recv_all():
             sock.shutdown(socket.SHUT_WR)
             data = await task
             # ProactorEventLoop could deliver hello, so endswith is necessary
-            self.assertTrue(data.endswith(b'world'))
+            self.assertEndsWith(data, b'world')
 
     # After the first connect attempt before the listener is ready,
     # the socket needs time to "recover" to make the next connect call.
@@ -298,7 +298,7 @@ async def _basetest_huge_content(self, address):
         data = await self.loop.sock_recv(sock, DATA_SIZE)
         # HTTP headers size is less than MTU,
         # they are sent by the first packet always
-        self.assertTrue(data.startswith(b'HTTP/1.0 200 OK'))
+        self.assertStartsWith(data, b'HTTP/1.0 200 OK')
         while data.find(b'\r\n\r\n') == -1:
             data += await self.loop.sock_recv(sock, DATA_SIZE)
         # Strip headers
@@ -351,7 +351,7 @@ async def _basetest_huge_content_recvinto(self, address):
         data = bytes(buf[:nbytes])
         # HTTP headers size is less than MTU,
         # they are sent by the first packet always
-        self.assertTrue(data.startswith(b'HTTP/1.0 200 OK'))
+        self.assertStartsWith(data, b'HTTP/1.0 200 OK')
         while data.find(b'\r\n\r\n') == -1:
             nbytes = await self.loop.sock_recv_into(sock, buf)
             data = bytes(buf[:nbytes])
diff --git a/Lib/test/test_asyncio/test_ssl.py b/Lib/test/test_asyncio/test_ssl.py
index 858ba964be3..ab4a2316f9c 100644
--- a/Lib/test/test_asyncio/test_ssl.py
+++ b/Lib/test/test_asyncio/test_ssl.py
@@ -30,7 +30,7 @@
 
 
 def tearDownModule():
-    asyncio.set_event_loop_policy(None)
+    asyncio.events._set_event_loop_policy(None)
 
 
 class MyBaseProto(asyncio.Protocol):
@@ -741,8 +741,7 @@ async def client(addr):
                 asyncio.wait_for(client(srv.addr),
                                  timeout=support.SHORT_TIMEOUT))
 
-    # TODO: RUSTPYTHON - gc.collect() doesn't release SSLContext properly
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; - gc.collect() doesn't release SSLContext properly
     def test_create_connection_memory_leak(self):
         HELLO_MSG = b'1' * self.PAYLOAD_SIZE
 
@@ -1624,8 +1623,7 @@ async def test():
             else:
                 self.fail('Unexpected ResourceWarning: {}'.format(cm.warning))
 
-    # TODO: RUSTPYTHON - gc.collect() doesn't release SSLContext properly
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; - gc.collect() doesn't release SSLContext properly
     def test_handshake_timeout_handler_leak(self):
         s = socket.socket(socket.AF_INET)
         s.bind(('127.0.0.1', 0))
@@ -1651,8 +1649,6 @@ async def test(ctx):
         # SSLProtocol should be DECREF to 0
         self.assertIsNone(ctx())
 
-    # TODO: RUSTPYTHON - gc.collect() doesn't release SSLContext properly
-    @unittest.expectedFailure
     def test_shutdown_timeout_handler_leak(self):
         loop = self.loop
 
@@ -1857,16 +1853,14 @@ def stop(self):
                     pass
         finally:
             super().stop()
-
-    def run(self):
-        try:
-            with self._sock:
-                self._sock.setblocking(False)
-                self._run()
-        finally:
+            self._sock.close()
             self._s1.close()
             self._s2.close()
 
+    def run(self):
+        self._sock.setblocking(False)
+        self._run()
+
     def _run(self):
         while self._active:
             if self._clients >= self._max_clients:
diff --git a/Lib/test/test_asyncio/test_sslproto.py b/Lib/test/test_asyncio/test_sslproto.py
index ed9e0b344ec..7ab6e1511d7 100644
--- a/Lib/test/test_asyncio/test_sslproto.py
+++ b/Lib/test/test_asyncio/test_sslproto.py
@@ -21,7 +21,7 @@
 
 
 def tearDownModule():
-    asyncio.set_event_loop_policy(None)
+    asyncio.events._set_event_loop_policy(None)
 
 
 @unittest.skipIf(ssl is None, 'No ssl module')
@@ -282,8 +282,7 @@ def buffer_updated(self, nsize):
             with self.assertRaisesRegex(RuntimeError, 'empty buffer'):
                 protocols._feed_data_to_buffered_proto(proto, b'12345')
 
-    # TODO: RUSTPYTHON - gc.collect() doesn't release SSLContext properly
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; - gc.collect() doesn't release SSLContext properly
     def test_start_tls_client_reg_proto_1(self):
         HELLO_MSG = b'1' * self.PAYLOAD_SIZE
 
@@ -350,8 +349,7 @@ async def client(addr):
         support.gc_collect()
         self.assertIsNone(client_context())
 
-    # TODO: RUSTPYTHON - gc.collect() doesn't release SSLContext properly
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; - gc.collect() doesn't release SSLContext properly
     def test_create_connection_memory_leak(self):
         HELLO_MSG = b'1' * self.PAYLOAD_SIZE
 
@@ -670,8 +668,7 @@ async def main():
 
         self.loop.run_until_complete(main())
 
-    # TODO: RUSTPYTHON - gc.collect() doesn't release SSLContext properly
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; - gc.collect() doesn't release SSLContext properly
     def test_handshake_timeout(self):
         # bpo-29970: Check that a connection is aborted if handshake is not
         # completed in timeout period, instead of remaining open indefinitely
diff --git a/Lib/test/test_asyncio/test_staggered.py b/Lib/test/test_asyncio/test_staggered.py
index 40455a3804e..32e4817b70d 100644
--- a/Lib/test/test_asyncio/test_staggered.py
+++ b/Lib/test/test_asyncio/test_staggered.py
@@ -8,7 +8,7 @@
 
 
 def tearDownModule():
-    asyncio.set_event_loop_policy(None)
+    asyncio.events._set_event_loop_policy(None)
 
 
 class StaggeredTests(unittest.IsolatedAsyncioTestCase):
diff --git a/Lib/test/test_asyncio/test_streams.py b/Lib/test/test_asyncio/test_streams.py
index dcf8bc79a2f..5f0fc6a7a9d 100644
--- a/Lib/test/test_asyncio/test_streams.py
+++ b/Lib/test/test_asyncio/test_streams.py
@@ -1,15 +1,12 @@
 """Tests for streams.py."""
 
 import gc
-import os
 import queue
 import pickle
 import socket
-import sys
 import threading
 import unittest
 from unittest import mock
-import warnings
 try:
     import ssl
 except ImportError:
@@ -17,11 +14,11 @@
 
 import asyncio
 from test.test_asyncio import utils as test_utils
-from test.support import requires_subprocess, socket_helper
+from test.support import socket_helper
 
 
 def tearDownModule():
-    asyncio.set_event_loop_policy(None)
+    asyncio.events._set_event_loop_policy(None)
 
 
 class StreamTests(test_utils.TestCase):
@@ -50,7 +47,7 @@ def _basetest_open_connection(self, open_connection_fut):
         self.assertEqual(data, b'HTTP/1.0 200 OK\r\n')
         f = reader.read()
         data = self.loop.run_until_complete(f)
-        self.assertTrue(data.endswith(b'\r\n\r\nTest message'))
+        self.assertEndsWith(data, b'\r\n\r\nTest message')
         writer.close()
         self.assertEqual(messages, [])
 
@@ -75,7 +72,7 @@ def _basetest_open_connection_no_loop_ssl(self, open_connection_fut):
         writer.write(b'GET / HTTP/1.0\r\n\r\n')
         f = reader.read()
         data = self.loop.run_until_complete(f)
-        self.assertTrue(data.endswith(b'\r\n\r\nTest message'))
+        self.assertEndsWith(data, b'\r\n\r\nTest message')
 
         writer.close()
         self.assertEqual(messages, [])
@@ -822,52 +819,6 @@ async def client(addr):
         self.assertEqual(msg1, b"hello world 1!\n")
         self.assertEqual(msg2, b"hello world 2!\n")
 
-    @unittest.skipIf(sys.platform == 'win32', "Don't have pipes")
-    @requires_subprocess()
-    def test_read_all_from_pipe_reader(self):
-        # See asyncio issue 168.  This test is derived from the example
-        # subprocess_attach_read_pipe.py, but we configure the
-        # StreamReader's limit so that twice it is less than the size
-        # of the data writer.  Also we must explicitly attach a child
-        # watcher to the event loop.
-
-        code = """\
-import os, sys
-fd = int(sys.argv[1])
-os.write(fd, b'data')
-os.close(fd)
-"""
-        rfd, wfd = os.pipe()
-        args = [sys.executable, '-c', code, str(wfd)]
-
-        pipe = open(rfd, 'rb', 0)
-        reader = asyncio.StreamReader(loop=self.loop, limit=1)
-        protocol = asyncio.StreamReaderProtocol(reader, loop=self.loop)
-        transport, _ = self.loop.run_until_complete(
-            self.loop.connect_read_pipe(lambda: protocol, pipe))
-        with warnings.catch_warnings():
-            warnings.simplefilter('ignore', DeprecationWarning)
-            watcher = asyncio.SafeChildWatcher()
-        watcher.attach_loop(self.loop)
-        try:
-            with warnings.catch_warnings():
-                warnings.simplefilter('ignore', DeprecationWarning)
-                asyncio.set_child_watcher(watcher)
-            create = asyncio.create_subprocess_exec(
-                *args,
-                pass_fds={wfd},
-            )
-            proc = self.loop.run_until_complete(create)
-            self.loop.run_until_complete(proc.wait())
-        finally:
-            with warnings.catch_warnings():
-                warnings.simplefilter('ignore', DeprecationWarning)
-                asyncio.set_child_watcher(None)
-
-        os.close(wfd)
-        data = self.loop.run_until_complete(reader.read(-1))
-        self.assertEqual(data, b'data')
-
     def test_streamreader_constructor_without_loop(self):
         with self.assertRaisesRegex(RuntimeError, 'no current event loop'):
             asyncio.StreamReader()
@@ -1048,7 +999,7 @@ def test_wait_closed_on_close(self):
             self.assertEqual(data, b'HTTP/1.0 200 OK\r\n')
             f = rd.read()
             data = self.loop.run_until_complete(f)
-            self.assertTrue(data.endswith(b'\r\n\r\nTest message'))
+            self.assertEndsWith(data, b'\r\n\r\nTest message')
             self.assertFalse(wr.is_closing())
             wr.close()
             self.assertTrue(wr.is_closing())
@@ -1074,7 +1025,7 @@ async def inner(httpd):
             data = await rd.readline()
             self.assertEqual(data, b'HTTP/1.0 200 OK\r\n')
             data = await rd.read()
-            self.assertTrue(data.endswith(b'\r\n\r\nTest message'))
+            self.assertEndsWith(data, b'\r\n\r\nTest message')
             wr.close()
             await wr.wait_closed()
 
@@ -1094,7 +1045,7 @@ async def inner(httpd):
             data = await rd.readline()
             self.assertEqual(data, b'HTTP/1.0 200 OK\r\n')
             data = await rd.read()
-            self.assertTrue(data.endswith(b'\r\n\r\nTest message'))
+            self.assertEndsWith(data, b'\r\n\r\nTest message')
             wr.close()
             with self.assertRaises(ConnectionResetError):
                 wr.write(b'data')
@@ -1135,12 +1086,12 @@ async def inner(httpd):
             data = await rd.readline()
             self.assertEqual(data, b'HTTP/1.0 200 OK\r\n')
             data = await rd.read()
-            self.assertTrue(data.endswith(b'\r\n\r\nTest message'))
+            self.assertEndsWith(data, b'\r\n\r\nTest message')
             with self.assertWarns(ResourceWarning) as cm:
                 del wr
                 gc.collect()
                 self.assertEqual(len(cm.warnings), 1)
-                self.assertTrue(str(cm.warnings[0].message).startswith("unclosed <StreamWriter"))
+                self.assertStartsWith(str(cm.warnings[0].message), "unclosed <StreamWriter")
 
         messages = []
         self.loop.set_exception_handler(lambda loop, ctx: messages.append(ctx))
@@ -1158,7 +1109,7 @@ async def inner(httpd):
             data = await rd.readline()
             self.assertEqual(data, b'HTTP/1.0 200 OK\r\n')
             data = await rd.read()
-            self.assertTrue(data.endswith(b'\r\n\r\nTest message'))
+            self.assertEndsWith(data, b'\r\n\r\nTest message')
 
             # Make "loop is closed" occur first before "del wr" for this test.
             self.loop.stop()
@@ -1190,7 +1141,7 @@ async def inner(rd, wr):
                 del wr
                 gc.collect()
                 self.assertEqual(len(cm.warnings), 1)
-                self.assertTrue(str(cm.warnings[0].message).startswith("unclosed <StreamWriter"))
+                self.assertStartsWith(str(cm.warnings[0].message), "unclosed <StreamWriter")
 
         async def outer():
             srv = await asyncio.start_server(inner, socket_helper.HOSTv4, 0)
@@ -1246,7 +1197,7 @@ async def handle_echo(reader, writer):
         messages = self._basetest_unhandled_exceptions(handle_echo)
         self.assertEqual(messages, [])
 
-    @unittest.skip("RUSTPYTHON: gc.get_referrers not implemented")
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; NotImplementedError
     def test_open_connection_happy_eyeball_refcycles(self):
         port = socket_helper.find_unused_port()
         async def main():
@@ -1261,9 +1212,9 @@ async def main():
                 # can't use assertRaises because that clears frames
                 exc = excs.exceptions[0]
             self.assertIsNotNone(exc)
-            self.assertListEqual(gc.get_referrers(exc), [])
-
-        asyncio.run(main())
+            self.assertListEqual(gc.get_referrers(exc), [main_coro])
+        main_coro = main()
+        asyncio.run(main_coro)
 
 
 if __name__ == '__main__':
diff --git a/Lib/test/test_asyncio/test_subprocess.py b/Lib/test/test_asyncio/test_subprocess.py
index a290f14d86e..bf301740741 100644
--- a/Lib/test/test_asyncio/test_subprocess.py
+++ b/Lib/test/test_asyncio/test_subprocess.py
@@ -37,7 +37,7 @@
 
 
 def tearDownModule():
-    asyncio.set_event_loop_policy(None)
+    asyncio.events._set_event_loop_policy(None)
 
 
 class TestSubprocessTransport(base_subprocess.BaseSubprocessTransport):
@@ -631,15 +631,6 @@ async def kill_running():
         # the transport was not notified yet
         self.assertFalse(killed)
 
-        # Unlike SafeChildWatcher, FastChildWatcher does not pop the
-        # callbacks if waitpid() is called elsewhere. Let's clear them
-        # manually to avoid a warning when the watcher is detached.
-        if (sys.platform != 'win32' and
-                isinstance(self, SubprocessFastWatcherTests)):
-            with warnings.catch_warnings():
-                warnings.simplefilter('ignore', DeprecationWarning)
-                asyncio.get_child_watcher()._callbacks.clear()
-
     async def _test_popen_error(self, stdin):
         if sys.platform == 'win32':
             target = 'asyncio.windows_utils.Popen'
@@ -792,7 +783,7 @@ async def main() -> None:
 
     def test_subprocess_protocol_events(self):
         # gh-108973: Test that all subprocess protocol methods are called.
-        # The protocol methods are not called in a determistic order.
+        # The protocol methods are not called in a deterministic order.
         # The order depends on the event loop and the operating system.
         events = []
         fds = [1, 2]
@@ -931,55 +922,31 @@ async def main():
     # Unix
     class SubprocessWatcherMixin(SubprocessMixin):
 
-        Watcher = None
-
         def setUp(self):
             super().setUp()
-            policy = asyncio.get_event_loop_policy()
-            self.loop = policy.new_event_loop()
+            self.loop = asyncio.new_event_loop()
             self.set_event_loop(self.loop)
 
-            watcher = self._get_watcher()
-            watcher.attach_loop(self.loop)
-            with warnings.catch_warnings():
-                warnings.simplefilter('ignore', DeprecationWarning)
-                policy.set_child_watcher(watcher)
+        def test_watcher_implementation(self):
+            loop = self.loop
+            watcher = loop._watcher
+            if unix_events.can_use_pidfd():
+                self.assertIsInstance(watcher, unix_events._PidfdChildWatcher)
+            else:
+                self.assertIsInstance(watcher, unix_events._ThreadedChildWatcher)
 
-        def tearDown(self):
-            super().tearDown()
-            policy = asyncio.get_event_loop_policy()
-            with warnings.catch_warnings():
-                warnings.simplefilter('ignore', DeprecationWarning)
-                watcher = policy.get_child_watcher()
-                policy.set_child_watcher(None)
-            watcher.attach_loop(None)
-            watcher.close()
 
     class SubprocessThreadedWatcherTests(SubprocessWatcherMixin,
                                          test_utils.TestCase):
+        def setUp(self):
+            self._original_can_use_pidfd = unix_events.can_use_pidfd
+            # Force the use of the threaded child watcher
+            unix_events.can_use_pidfd = mock.Mock(return_value=False)
+            super().setUp()
 
-        def _get_watcher(self):
-            return unix_events.ThreadedChildWatcher()
-
-    class SubprocessSafeWatcherTests(SubprocessWatcherMixin,
-                                     test_utils.TestCase):
-
-        def _get_watcher(self):
-            with self.assertWarns(DeprecationWarning):
-                return unix_events.SafeChildWatcher()
-
-    class MultiLoopChildWatcherTests(test_utils.TestCase):
-
-        def test_warns(self):
-            with self.assertWarns(DeprecationWarning):
-                unix_events.MultiLoopChildWatcher()
-
-    class SubprocessFastWatcherTests(SubprocessWatcherMixin,
-                                     test_utils.TestCase):
-
-        def _get_watcher(self):
-            with self.assertWarns(DeprecationWarning):
-                return unix_events.FastChildWatcher()
+        def tearDown(self):
+            unix_events.can_use_pidfd = self._original_can_use_pidfd
+            return super().tearDown()
 
     @unittest.skipUnless(
         unix_events.can_use_pidfd(),
@@ -988,70 +955,8 @@ def _get_watcher(self):
     class SubprocessPidfdWatcherTests(SubprocessWatcherMixin,
                                       test_utils.TestCase):
 
-        def _get_watcher(self):
-            return unix_events.PidfdChildWatcher()
+        pass
 
-
-    class GenericWatcherTests(test_utils.TestCase):
-
-        def test_create_subprocess_fails_with_inactive_watcher(self):
-            watcher = mock.create_autospec(asyncio.AbstractChildWatcher)
-            watcher.is_active.return_value = False
-
-            async def execute():
-                asyncio.set_child_watcher(watcher)
-
-                with self.assertRaises(RuntimeError):
-                    await subprocess.create_subprocess_exec(
-                        os_helper.FakePath(sys.executable), '-c', 'pass')
-
-                watcher.add_child_handler.assert_not_called()
-
-            with asyncio.Runner(loop_factory=asyncio.new_event_loop) as runner:
-                with warnings.catch_warnings():
-                    warnings.simplefilter('ignore', DeprecationWarning)
-                    self.assertIsNone(runner.run(execute()))
-            self.assertListEqual(watcher.mock_calls, [
-                mock.call.__enter__(),
-                mock.call.is_active(),
-                mock.call.__exit__(RuntimeError, mock.ANY, mock.ANY),
-            ], watcher.mock_calls)
-
-
-        @unittest.skipUnless(
-            unix_events.can_use_pidfd(),
-            "operating system does not support pidfds",
-        )
-        def test_create_subprocess_with_pidfd(self):
-            async def in_thread():
-                proc = await asyncio.create_subprocess_exec(
-                    *PROGRAM_CAT,
-                    stdin=subprocess.PIPE,
-                    stdout=subprocess.PIPE,
-                )
-                stdout, stderr = await proc.communicate(b"some data")
-                return proc.returncode, stdout
-
-            async def main():
-                # asyncio.Runner did not call asyncio.set_event_loop()
-                with warnings.catch_warnings():
-                    warnings.simplefilter('error', DeprecationWarning)
-                    # get_event_loop() raises DeprecationWarning if
-                    # set_event_loop() was never called and RuntimeError if
-                    # it was called at least once.
-                    with self.assertRaises((RuntimeError, DeprecationWarning)):
-                        asyncio.get_event_loop_policy().get_event_loop()
-                return await asyncio.to_thread(asyncio.run, in_thread())
-            with self.assertWarns(DeprecationWarning):
-                asyncio.set_child_watcher(asyncio.PidfdChildWatcher())
-            try:
-                with asyncio.Runner(loop_factory=asyncio.new_event_loop) as runner:
-                    returncode, stdout = runner.run(main())
-                self.assertEqual(returncode, 0)
-                self.assertEqual(stdout, b'some data')
-            finally:
-                with self.assertWarns(DeprecationWarning):
-                    asyncio.set_child_watcher(None)
 else:
     # Windows
     class SubprocessProactorTests(SubprocessMixin, test_utils.TestCase):
diff --git a/Lib/test/test_asyncio/test_taskgroups.py b/Lib/test/test_asyncio/test_taskgroups.py
index 5910d616610..d4b2554dda9 100644
--- a/Lib/test/test_asyncio/test_taskgroups.py
+++ b/Lib/test/test_asyncio/test_taskgroups.py
@@ -15,7 +15,7 @@
 
 # To prevent a warning "test altered the execution environment"
 def tearDownModule():
-    asyncio.set_event_loop_policy(None)
+    asyncio.events._set_event_loop_policy(None)
 
 
 class MyExc(Exception):
@@ -30,6 +30,15 @@ def get_error_types(eg):
     return {type(exc) for exc in eg.exceptions}
 
 
+def no_other_refs():
+    # due to gh-124392 coroutines now refer to their locals
+    coro = asyncio.current_task().get_coro()
+    frame = sys._getframe(1)
+    while coro.cr_frame != frame:
+        coro = coro.cr_await
+    return [coro]
+
+
 def set_gc_state(enabled):
     was_enabled = gc.isenabled()
     if enabled:
@@ -918,7 +927,6 @@ async def outer():
 
         await outer()
 
-    @unittest.skip("RUSTPYTHON: gc.get_referrers not implemented")
     async def test_exception_refcycles_direct(self):
         """Test that TaskGroup doesn't keep a reference to the raised ExceptionGroup"""
         tg = asyncio.TaskGroup()
@@ -934,10 +942,9 @@ class _Done(Exception):
             exc = e
 
         self.assertIsNotNone(exc)
-        self.assertListEqual(gc.get_referrers(exc), [])
+        self.assertListEqual(gc.get_referrers(exc), no_other_refs())
 
 
-    @unittest.skip("RUSTPYTHON: gc.get_referrers not implemented")
     async def test_exception_refcycles_errors(self):
         """Test that TaskGroup deletes self._errors, and __aexit__ args"""
         tg = asyncio.TaskGroup()
@@ -953,10 +960,9 @@ class _Done(Exception):
             exc = excs.exceptions[0]
 
         self.assertIsInstance(exc, _Done)
-        self.assertListEqual(gc.get_referrers(exc), [])
+        self.assertListEqual(gc.get_referrers(exc), no_other_refs())
 
 
-    @unittest.skip("RUSTPYTHON: gc.get_referrers not implemented")
     async def test_exception_refcycles_parent_task(self):
         """Test that TaskGroup deletes self._parent_task"""
         tg = asyncio.TaskGroup()
@@ -976,10 +982,9 @@ async def coro_fn():
             exc = excs.exceptions[0].exceptions[0]
 
         self.assertIsInstance(exc, _Done)
-        self.assertListEqual(gc.get_referrers(exc), [])
+        self.assertListEqual(gc.get_referrers(exc), no_other_refs())
 
 
-    @unittest.skip("RUSTPYTHON: gc.get_referrers not implemented")
     async def test_exception_refcycles_parent_task_wr(self):
         """Test that TaskGroup deletes self._parent_task and create_task() deletes task"""
         tg = asyncio.TaskGroup()
@@ -1001,9 +1006,8 @@ async def coro_fn():
 
         self.assertIsNone(task_wr())
         self.assertIsInstance(exc, _Done)
-        self.assertListEqual(gc.get_referrers(exc), [])
+        self.assertListEqual(gc.get_referrers(exc), no_other_refs())
 
-    @unittest.skip("RUSTPYTHON: gc.get_referrers not implemented")
     async def test_exception_refcycles_propagate_cancellation_error(self):
         """Test that TaskGroup deletes propagate_cancellation_error"""
         tg = asyncio.TaskGroup()
@@ -1017,9 +1021,8 @@ async def test_exception_refcycles_propagate_cancellation_error(self):
             exc = e.__cause__
 
         self.assertIsInstance(exc, asyncio.CancelledError)
-        self.assertListEqual(gc.get_referrers(exc), [])
+        self.assertListEqual(gc.get_referrers(exc), no_other_refs())
 
-    @unittest.skip("RUSTPYTHON: gc.get_referrers not implemented")
     async def test_exception_refcycles_base_error(self):
         """Test that TaskGroup deletes self._base_error"""
         class MyKeyboardInterrupt(KeyboardInterrupt):
@@ -1035,7 +1038,19 @@ class MyKeyboardInterrupt(KeyboardInterrupt):
             exc = e
 
         self.assertIsNotNone(exc)
-        self.assertListEqual(gc.get_referrers(exc), [])
+        self.assertListEqual(gc.get_referrers(exc), no_other_refs())
+
+    async def test_name(self):
+        name = None
+
+        async def asyncfn():
+            nonlocal name
+            name = asyncio.current_task().get_name()
+
+        async with asyncio.TaskGroup() as tg:
+            tg.create_task(asyncfn(), name="example name")
+
+        self.assertEqual(name, "example name")
 
 
     async def test_cancels_task_if_created_during_creation(self):
@@ -1091,6 +1106,30 @@ async def throw_error():
 class TestTaskGroup(BaseTestTaskGroup, unittest.IsolatedAsyncioTestCase):
     loop_factory = asyncio.EventLoop
 
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; Test that TaskGroup deletes propagate_cancellation_error
+    async def test_exception_refcycles_propagate_cancellation_error(self):
+        return await super().test_exception_refcycles_propagate_cancellation_error()
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; Test that TaskGroup deletes self._base_error
+    async def test_exception_refcycles_base_error(self):
+        return await super().test_exception_refcycles_base_error()
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; Test that TaskGroup deletes self._errors, and __aexit__ args
+    async def test_exception_refcycles_errors(self):
+        return await super().test_exception_refcycles_errors()
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; Test that TaskGroup deletes self._parent_task
+    async def test_exception_refcycles_parent_task(self):
+        return await super().test_exception_refcycles_parent_task()
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; Test that TaskGroup deletes self._parent_task and create_task() deletes task
+    async def test_exception_refcycles_parent_task_wr(self):
+        return await super().test_exception_refcycles_parent_task_wr()
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; Test that TaskGroup doesn't keep a reference to the raised ExceptionGroup
+    async def test_exception_refcycles_direct(self):
+        return await super().test_exception_refcycles_direct()
+
 class TestEagerTaskTaskGroup(BaseTestTaskGroup, unittest.IsolatedAsyncioTestCase):
     @staticmethod
     def loop_factory():
@@ -1098,6 +1137,30 @@ def loop_factory():
         loop.set_task_factory(asyncio.eager_task_factory)
         return loop
 
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; Test that TaskGroup deletes propagate_cancellation_error
+    async def test_exception_refcycles_propagate_cancellation_error(self):
+        return await super().test_exception_refcycles_propagate_cancellation_error()
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; Test that TaskGroup deletes self._base_error
+    async def test_exception_refcycles_base_error(self):
+        return await super().test_exception_refcycles_base_error()
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; Test that TaskGroup deletes self._errors, and __aexit__ args
+    async def test_exception_refcycles_errors(self):
+        return await super().test_exception_refcycles_errors()
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; Test that TaskGroup deletes self._parent_task
+    async def test_exception_refcycles_parent_task(self):
+        return await super().test_exception_refcycles_parent_task()
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; Test that TaskGroup deletes self._parent_task and create_task() deletes task
+    async def test_exception_refcycles_parent_task_wr(self):
+        return await super().test_exception_refcycles_parent_task_wr()
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; Test that TaskGroup doesn't keep a reference to the raised ExceptionGroup
+    async def test_exception_refcycles_direct(self):
+        return await super().test_exception_refcycles_direct()
+
 
 if __name__ == "__main__":
     unittest.main()
diff --git a/Lib/test/test_asyncio/test_tasks.py b/Lib/test/test_asyncio/test_tasks.py
index 7a830230a7d..8a291f1cb7e 100644
--- a/Lib/test/test_asyncio/test_tasks.py
+++ b/Lib/test/test_asyncio/test_tasks.py
@@ -20,10 +20,11 @@
 from test.test_asyncio import utils as test_utils
 from test import support
 from test.support.script_helper import assert_python_ok
+from test.support.warnings_helper import ignore_warnings
 
 
 def tearDownModule():
-    asyncio.set_event_loop_policy(None)
+    asyncio.events._set_event_loop_policy(None)
 
 
 async def coroutine_function():
@@ -86,9 +87,10 @@ class BaseTaskTests:
 
     Task = None
     Future = None
+    all_tasks = None
 
-    def new_task(self, loop, coro, name='TestTask', context=None):
-        return self.__class__.Task(coro, loop=loop, name=name, context=context)
+    def new_task(self, loop, coro, name='TestTask', context=None, eager_start=None):
+        return self.__class__.Task(coro, loop=loop, name=name, context=context, eager_start=eager_start)
 
     def new_future(self, loop):
         return self.__class__.Future(loop=loop)
@@ -108,7 +110,7 @@ def test_task_cancel_message_getter(self):
         async def coro():
             pass
         t = self.new_task(self.loop, coro())
-        self.assertTrue(hasattr(t, '_cancel_message'))
+        self.assertHasAttr(t, '_cancel_message')
         self.assertEqual(t._cancel_message, None)
 
         t.cancel('my message')
@@ -544,7 +546,7 @@ async def task():
             try:
                 await asyncio.sleep(10)
             except asyncio.CancelledError:
-                asyncio.current_task().uncancel()
+                self.current_task().uncancel()
                 await asyncio.sleep(10)
 
         try:
@@ -596,7 +598,7 @@ def test_uncancel_structured_blocks(self):
         loop = asyncio.new_event_loop()
 
         async def make_request_with_timeout(*, sleep: float, timeout: float):
-            task = asyncio.current_task()
+            task = self.current_task()
             loop = task.get_loop()
 
             timed_out = False
@@ -1938,6 +1940,7 @@ async def notmutch():
         self.assertFalse(task.cancelled())
         self.assertIs(task.exception(), base_exc)
 
+    @ignore_warnings(category=DeprecationWarning)
     def test_iscoroutinefunction(self):
         def fn():
             pass
@@ -1955,6 +1958,7 @@ async def fn2():
         self.assertFalse(asyncio.iscoroutinefunction(mock.Mock()))
         self.assertTrue(asyncio.iscoroutinefunction(mock.AsyncMock()))
 
+    @ignore_warnings(category=DeprecationWarning)
     def test_coroutine_non_gen_function(self):
         async def func():
             return 'test'
@@ -1983,41 +1987,41 @@ async def coro():
         self.assertIsNone(t2.result())
 
     def test_current_task(self):
-        self.assertIsNone(asyncio.current_task(loop=self.loop))
+        self.assertIsNone(self.current_task(loop=self.loop))
 
         async def coro(loop):
-            self.assertIs(asyncio.current_task(), task)
+            self.assertIs(self.current_task(), task)
 
-            self.assertIs(asyncio.current_task(None), task)
-            self.assertIs(asyncio.current_task(), task)
+            self.assertIs(self.current_task(None), task)
+            self.assertIs(self.current_task(), task)
 
         task = self.new_task(self.loop, coro(self.loop))
         self.loop.run_until_complete(task)
-        self.assertIsNone(asyncio.current_task(loop=self.loop))
+        self.assertIsNone(self.current_task(loop=self.loop))
 
     def test_current_task_with_interleaving_tasks(self):
-        self.assertIsNone(asyncio.current_task(loop=self.loop))
+        self.assertIsNone(self.current_task(loop=self.loop))
 
         fut1 = self.new_future(self.loop)
         fut2 = self.new_future(self.loop)
 
         async def coro1(loop):
-            self.assertTrue(asyncio.current_task() is task1)
+            self.assertTrue(self.current_task() is task1)
             await fut1
-            self.assertTrue(asyncio.current_task() is task1)
+            self.assertTrue(self.current_task() is task1)
             fut2.set_result(True)
 
         async def coro2(loop):
-            self.assertTrue(asyncio.current_task() is task2)
+            self.assertTrue(self.current_task() is task2)
             fut1.set_result(True)
             await fut2
-            self.assertTrue(asyncio.current_task() is task2)
+            self.assertTrue(self.current_task() is task2)
 
         task1 = self.new_task(self.loop, coro1(self.loop))
         task2 = self.new_task(self.loop, coro2(self.loop))
 
         self.loop.run_until_complete(asyncio.wait((task1, task2)))
-        self.assertIsNone(asyncio.current_task(loop=self.loop))
+        self.assertIsNone(self.current_task(loop=self.loop))
 
     # Some thorough tests for cancellation propagation through
     # coroutines, tasks and wait().
@@ -2112,6 +2116,46 @@ def test_shield_cancel_outer(self):
         self.assertTrue(outer.cancelled())
         self.assertEqual(0, 0 if outer._callbacks is None else len(outer._callbacks))
 
+    def test_shield_cancel_outer_result(self):
+        mock_handler = mock.Mock()
+        self.loop.set_exception_handler(mock_handler)
+        inner = self.new_future(self.loop)
+        outer = asyncio.shield(inner)
+        test_utils.run_briefly(self.loop)
+        outer.cancel()
+        test_utils.run_briefly(self.loop)
+        inner.set_result(1)
+        test_utils.run_briefly(self.loop)
+        mock_handler.assert_not_called()
+
+    def test_shield_cancel_outer_exception(self):
+        mock_handler = mock.Mock()
+        self.loop.set_exception_handler(mock_handler)
+        inner = self.new_future(self.loop)
+        outer = asyncio.shield(inner)
+        test_utils.run_briefly(self.loop)
+        outer.cancel()
+        test_utils.run_briefly(self.loop)
+        inner.set_exception(Exception('foo'))
+        test_utils.run_briefly(self.loop)
+        mock_handler.assert_called_once()
+
+    def test_shield_duplicate_log_once(self):
+        mock_handler = mock.Mock()
+        self.loop.set_exception_handler(mock_handler)
+        inner = self.new_future(self.loop)
+        outer = asyncio.shield(inner)
+        test_utils.run_briefly(self.loop)
+        outer.cancel()
+        test_utils.run_briefly(self.loop)
+        outer = asyncio.shield(inner)
+        test_utils.run_briefly(self.loop)
+        outer.cancel()
+        test_utils.run_briefly(self.loop)
+        inner.set_exception(Exception('foo'))
+        test_utils.run_briefly(self.loop)
+        mock_handler.assert_called_once()
+
     def test_shield_shortcut(self):
         fut = self.new_future(self.loop)
         fut.set_result(42)
@@ -2249,9 +2293,7 @@ def test_wait_invalid_args(self):
         self.assertRaises(ValueError, self.loop.run_until_complete,
             asyncio.wait([]))
 
-    @unittest.skip("RUSTPYTHON: requires cyclic garbage collection")
     def test_log_destroyed_pending_task(self):
-        Task = self.__class__.Task
 
         async def kill_me(loop):
             future = self.new_future(loop)
@@ -2266,14 +2308,12 @@ async def kill_me(loop):
 
         # schedule the task
         coro = kill_me(self.loop)
-        task = asyncio.ensure_future(coro, loop=self.loop)
-
-        self.assertEqual(asyncio.all_tasks(loop=self.loop), {task})
+        task = self.new_task(self.loop, coro)
 
-        asyncio.set_event_loop(None)
+        self.assertEqual(self.all_tasks(loop=self.loop), {task})
 
         # execute the task so it waits for future
-        self.loop._run_once()
+        self.loop.run_until_complete(asyncio.sleep(0))
         self.assertEqual(len(self.loop._ready), 0)
 
         coro = None
@@ -2283,14 +2323,36 @@ async def kill_me(loop):
         # no more reference to kill_me() task: the task is destroyed by the GC
         support.gc_collect()
 
-        self.assertEqual(asyncio.all_tasks(loop=self.loop), set())
-
         mock_handler.assert_called_with(self.loop, {
             'message': 'Task was destroyed but it is pending!',
             'task': mock.ANY,
             'source_traceback': source_traceback,
         })
         mock_handler.reset_mock()
+        # task got resurrected by the exception handler
+        support.gc_collect()
+
+        self.assertEqual(self.all_tasks(loop=self.loop), set())
+
+    def test_task_not_crash_without_finalization(self):
+        Task = self.__class__.Task
+
+        class Subclass(Task):
+            def __del__(self):
+                pass
+
+        async def corofn():
+            await asyncio.sleep(0.01)
+
+        coro = corofn()
+        task = Subclass(coro, loop = self.loop)
+        task._log_destroy_pending = False
+
+        del task
+
+        support.gc_collect()
+
+        coro.close()
 
     @mock.patch('asyncio.base_events.logger')
     def test_tb_logger_not_called_after_cancel(self, m_log):
@@ -2432,7 +2494,7 @@ async def coro():
         message = m_log.error.call_args[0][0]
         self.assertIn('Task was destroyed but it is pending', message)
 
-        self.assertEqual(asyncio.all_tasks(self.loop), set())
+        self.assertEqual(self.all_tasks(self.loop), set())
 
     def test_create_task_with_noncoroutine(self):
         with self.assertRaisesRegex(TypeError,
@@ -2664,6 +2726,35 @@ async def main():
 
         self.assertEqual([None, 1, 2], ret)
 
+    def test_eager_start_true(self):
+        name = None
+
+        async def asyncfn():
+            nonlocal name
+            name = self.current_task().get_name()
+
+        async def main():
+            t = self.new_task(coro=asyncfn(), loop=asyncio.get_running_loop(), eager_start=True, name="example")
+            self.assertTrue(t.done())
+            self.assertEqual(name, "example")
+            await t
+
+    def test_eager_start_false(self):
+        name = None
+
+        async def asyncfn():
+            nonlocal name
+            name = self.current_task().get_name()
+
+        async def main():
+            t = self.new_task(coro=asyncfn(), loop=asyncio.get_running_loop(), eager_start=False, name="example")
+            self.assertFalse(t.done())
+            self.assertIsNone(name)
+            await t
+            self.assertEqual(name, "example")
+
+        asyncio.run(main(), loop_factory=asyncio.EventLoop)
+
     def test_get_coro(self):
         loop = asyncio.new_event_loop()
         coro = coroutine_function()
@@ -2697,12 +2788,12 @@ def __str__(self):
         coro = coroutine_function()
         with contextlib.closing(asyncio.EventLoop()) as loop:
             task = asyncio.Task.__new__(asyncio.Task)
-
             for _ in range(5):
                 with self.assertRaisesRegex(RuntimeError, 'break'):
                     task.__init__(coro, loop=loop, context=obj, name=Break())
 
             coro.close()
+            task._log_destroy_pending = False
             del task
 
             self.assertEqual(sys.getrefcount(obj), initial_refcount)
@@ -2827,6 +2918,8 @@ class CTask_CFuture_Tests(BaseTaskTests, SetMethodsTest,
 
     Task = getattr(tasks, '_CTask', None)
     Future = getattr(futures, '_CFuture', None)
+    all_tasks = getattr(tasks, '_c_all_tasks', None)
+    current_task = staticmethod(getattr(tasks, '_c_current_task', None))
 
     @support.refcount_test
     def test_refleaks_in_task___init__(self):
@@ -2849,6 +2942,11 @@ async def coro():
         with self.assertRaises(AttributeError):
             del task._log_destroy_pending
 
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; Actual: not called.
+    def test_log_destroyed_pending_task(self):
+        return super().test_log_destroyed_pending_task()
+
+
 
 @unittest.skipUnless(hasattr(futures, '_CFuture') and
                      hasattr(tasks, '_CTask'),
@@ -2858,6 +2956,12 @@ class CTask_CFuture_SubclassTests(BaseTaskTests, test_utils.TestCase):
 
     Task = getattr(tasks, '_CTask', None)
     Future = getattr(futures, '_CFuture', None)
+    all_tasks = getattr(tasks, '_c_all_tasks', None)
+    current_task = staticmethod(getattr(tasks, '_c_current_task', None))
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; Actual: not called.
+    def test_log_destroyed_pending_task(self):
+        return super().test_log_destroyed_pending_task()
 
 
 @unittest.skipUnless(hasattr(tasks, '_CTask'),
@@ -2867,6 +2971,12 @@ class CTaskSubclass_PyFuture_Tests(BaseTaskTests, test_utils.TestCase):
 
     Task = getattr(tasks, '_CTask', None)
     Future = futures._PyFuture
+    all_tasks = getattr(tasks, '_c_all_tasks', None)
+    current_task = staticmethod(getattr(tasks, '_c_current_task', None))
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; Actual: not called.
+    def test_log_destroyed_pending_task(self):
+        return super().test_log_destroyed_pending_task()
 
 
 @unittest.skipUnless(hasattr(futures, '_CFuture'),
@@ -2876,6 +2986,12 @@ class PyTask_CFutureSubclass_Tests(BaseTaskTests, test_utils.TestCase):
 
     Future = getattr(futures, '_CFuture', None)
     Task = tasks._PyTask
+    all_tasks = staticmethod(tasks._py_all_tasks)
+    current_task = staticmethod(tasks._py_current_task)
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; Actual: not called.
+    def test_log_destroyed_pending_task(self):
+        return super().test_log_destroyed_pending_task()
 
 
 @unittest.skipUnless(hasattr(tasks, '_CTask'),
@@ -2884,6 +3000,13 @@ class CTask_PyFuture_Tests(BaseTaskTests, test_utils.TestCase):
 
     Task = getattr(tasks, '_CTask', None)
     Future = futures._PyFuture
+    all_tasks = getattr(tasks, '_c_all_tasks', None)
+    current_task = staticmethod(getattr(tasks, '_c_current_task', None))
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; Actual: not called.
+    def test_log_destroyed_pending_task(self):
+        return super().test_log_destroyed_pending_task()
+
 
 
 @unittest.skipUnless(hasattr(futures, '_CFuture'),
@@ -2892,6 +3015,12 @@ class PyTask_CFuture_Tests(BaseTaskTests, test_utils.TestCase):
 
     Task = tasks._PyTask
     Future = getattr(futures, '_CFuture', None)
+    all_tasks = staticmethod(tasks._py_all_tasks)
+    current_task = staticmethod(tasks._py_current_task)
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; Actual: not called.
+    def test_log_destroyed_pending_task(self):
+        return super().test_log_destroyed_pending_task()
 
 
 class PyTask_PyFuture_Tests(BaseTaskTests, SetMethodsTest,
@@ -2899,13 +3028,24 @@ class PyTask_PyFuture_Tests(BaseTaskTests, SetMethodsTest,
 
     Task = tasks._PyTask
     Future = futures._PyFuture
+    all_tasks = staticmethod(tasks._py_all_tasks)
+    current_task = staticmethod(tasks._py_current_task)
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; Actual: not called.
+    def test_log_destroyed_pending_task(self):
+        return super().test_log_destroyed_pending_task()
 
 
 @add_subclass_tests
 class PyTask_PyFuture_SubclassTests(BaseTaskTests, test_utils.TestCase):
     Task = tasks._PyTask
     Future = futures._PyFuture
+    all_tasks = staticmethod(tasks._py_all_tasks)
+    current_task = staticmethod(tasks._py_current_task)
 
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; Actual: not called.
+    def test_log_destroyed_pending_task(self):
+        return super().test_log_destroyed_pending_task()
 
 @unittest.skipUnless(hasattr(tasks, '_CTask'),
                      'requires the C _asyncio module')
@@ -2938,6 +3078,7 @@ class BaseTaskIntrospectionTests:
     _unregister_task = None
     _enter_task = None
     _leave_task = None
+    all_tasks = None
 
     def test__register_task_1(self):
         class TaskLike:
@@ -2951,9 +3092,9 @@ def done(self):
         task = TaskLike()
         loop = mock.Mock()
 
-        self.assertEqual(asyncio.all_tasks(loop), set())
+        self.assertEqual(self.all_tasks(loop), set())
         self._register_task(task)
-        self.assertEqual(asyncio.all_tasks(loop), {task})
+        self.assertEqual(self.all_tasks(loop), {task})
         self._unregister_task(task)
 
     def test__register_task_2(self):
@@ -2967,9 +3108,9 @@ def done(self):
         task = TaskLike()
         loop = mock.Mock()
 
-        self.assertEqual(asyncio.all_tasks(loop), set())
+        self.assertEqual(self.all_tasks(loop), set())
         self._register_task(task)
-        self.assertEqual(asyncio.all_tasks(loop), {task})
+        self.assertEqual(self.all_tasks(loop), {task})
         self._unregister_task(task)
 
     def test__register_task_3(self):
@@ -2983,52 +3124,68 @@ def done(self):
         task = TaskLike()
         loop = mock.Mock()
 
-        self.assertEqual(asyncio.all_tasks(loop), set())
+        self.assertEqual(self.all_tasks(loop), set())
         self._register_task(task)
-        self.assertEqual(asyncio.all_tasks(loop), set())
+        self.assertEqual(self.all_tasks(loop), set())
         self._unregister_task(task)
 
     def test__enter_task(self):
         task = mock.Mock()
         loop = mock.Mock()
-        self.assertIsNone(asyncio.current_task(loop))
+        # _enter_task is called by Task.__step while the loop
+        # is running, so set the loop as the running loop
+        # for a more realistic test.
+        asyncio._set_running_loop(loop)
+        self.assertIsNone(self.current_task(loop))
         self._enter_task(loop, task)
-        self.assertIs(asyncio.current_task(loop), task)
+        self.assertIs(self.current_task(loop), task)
         self._leave_task(loop, task)
+        asyncio._set_running_loop(None)
 
     def test__enter_task_failure(self):
         task1 = mock.Mock()
         task2 = mock.Mock()
         loop = mock.Mock()
+        asyncio._set_running_loop(loop)
         self._enter_task(loop, task1)
         with self.assertRaises(RuntimeError):
             self._enter_task(loop, task2)
-        self.assertIs(asyncio.current_task(loop), task1)
+        self.assertIs(self.current_task(loop), task1)
         self._leave_task(loop, task1)
+        asyncio._set_running_loop(None)
 
     def test__leave_task(self):
         task = mock.Mock()
         loop = mock.Mock()
+        asyncio._set_running_loop(loop)
         self._enter_task(loop, task)
         self._leave_task(loop, task)
-        self.assertIsNone(asyncio.current_task(loop))
+        self.assertIsNone(self.current_task(loop))
+        asyncio._set_running_loop(None)
 
     def test__leave_task_failure1(self):
         task1 = mock.Mock()
         task2 = mock.Mock()
         loop = mock.Mock()
+        # _leave_task is called by Task.__step while the loop
+        # is running, so set the loop as the running loop
+        # for a more realistic test.
+        asyncio._set_running_loop(loop)
         self._enter_task(loop, task1)
         with self.assertRaises(RuntimeError):
             self._leave_task(loop, task2)
-        self.assertIs(asyncio.current_task(loop), task1)
+        self.assertIs(self.current_task(loop), task1)
         self._leave_task(loop, task1)
+        asyncio._set_running_loop(None)
 
     def test__leave_task_failure2(self):
         task = mock.Mock()
         loop = mock.Mock()
+        asyncio._set_running_loop(loop)
         with self.assertRaises(RuntimeError):
             self._leave_task(loop, task)
-        self.assertIsNone(asyncio.current_task(loop))
+        self.assertIsNone(self.current_task(loop))
+        asyncio._set_running_loop(None)
 
     def test__unregister_task(self):
         task = mock.Mock()
@@ -3036,13 +3193,13 @@ def test__unregister_task(self):
         task.get_loop = lambda: loop
         self._register_task(task)
         self._unregister_task(task)
-        self.assertEqual(asyncio.all_tasks(loop), set())
+        self.assertEqual(self.all_tasks(loop), set())
 
     def test__unregister_task_not_registered(self):
         task = mock.Mock()
         loop = mock.Mock()
         self._unregister_task(task)
-        self.assertEqual(asyncio.all_tasks(loop), set())
+        self.assertEqual(self.all_tasks(loop), set())
 
 
 class PyIntrospectionTests(test_utils.TestCase, BaseTaskIntrospectionTests):
@@ -3050,6 +3207,8 @@ class PyIntrospectionTests(test_utils.TestCase, BaseTaskIntrospectionTests):
     _unregister_task = staticmethod(tasks._py_unregister_task)
     _enter_task = staticmethod(tasks._py_enter_task)
     _leave_task = staticmethod(tasks._py_leave_task)
+    all_tasks = staticmethod(tasks._py_all_tasks)
+    current_task = staticmethod(tasks._py_current_task)
 
 
 @unittest.skipUnless(hasattr(tasks, '_c_register_task'),
@@ -3060,6 +3219,8 @@ class CIntrospectionTests(test_utils.TestCase, BaseTaskIntrospectionTests):
         _unregister_task = staticmethod(tasks._c_unregister_task)
         _enter_task = staticmethod(tasks._c_enter_task)
         _leave_task = staticmethod(tasks._c_leave_task)
+        all_tasks = staticmethod(tasks._c_all_tasks)
+        current_task = staticmethod(tasks._c_current_task)
     else:
         _register_task = _unregister_task = _enter_task = _leave_task = None
 
@@ -3117,7 +3278,7 @@ def new_task(self, coro):
 class GenericTaskTests(test_utils.TestCase):
 
     def test_future_subclass(self):
-        self.assertTrue(issubclass(asyncio.Task, asyncio.Future))
+        self.assertIsSubclass(asyncio.Task, asyncio.Future)
 
     @support.cpython_only
     def test_asyncio_module_compiled(self):
@@ -3126,14 +3287,14 @@ def test_asyncio_module_compiled(self):
         # fail on systems where C modules were successfully compiled
         # (hence the test for _functools etc), but _asyncio somehow didn't.
         try:
-            import _functools
-            import _json
-            import _pickle
+            import _functools  # noqa: F401
+            import _json       # noqa: F401
+            import _pickle     # noqa: F401
         except ImportError:
             self.skipTest('C modules are not available')
         else:
             try:
-                import _asyncio
+                import _asyncio  # noqa: F401
             except ImportError:
                 self.fail('_asyncio module is missing')
 
diff --git a/Lib/test/test_asyncio/test_threads.py b/Lib/test/test_asyncio/test_threads.py
index 774380270a7..8ad5f9b2c9e 100644
--- a/Lib/test/test_asyncio/test_threads.py
+++ b/Lib/test/test_asyncio/test_threads.py
@@ -8,7 +8,7 @@
 
 
 def tearDownModule():
-    asyncio.set_event_loop_policy(None)
+    asyncio.events._set_event_loop_policy(None)
 
 
 class ToThreadTests(unittest.IsolatedAsyncioTestCase):
diff --git a/Lib/test/test_asyncio/test_timeouts.py b/Lib/test/test_asyncio/test_timeouts.py
index 1f7f9ee696a..f60722c48b7 100644
--- a/Lib/test/test_asyncio/test_timeouts.py
+++ b/Lib/test/test_asyncio/test_timeouts.py
@@ -9,7 +9,7 @@
 
 
 def tearDownModule():
-    asyncio.set_event_loop_policy(None)
+    asyncio.events._set_event_loop_policy(None)
 
 class TimeoutTests(unittest.IsolatedAsyncioTestCase):
 
@@ -220,7 +220,7 @@ async def test_nested_timeouts_loop_busy(self):
                         # Pretend the loop is busy for a while.
                         time.sleep(0.1)
                         await asyncio.sleep(1)
-                # TimeoutError was cought by (2)
+                # TimeoutError was caught by (2)
                 await asyncio.sleep(10) # This sleep should be interrupted by (1)
         t1 = loop.time()
         self.assertTrue(t0 <= t1 <= t0 + 1)
diff --git a/Lib/test/test_asyncio/test_tools.py b/Lib/test/test_asyncio/test_tools.py
new file mode 100644
index 00000000000..34e94830204
--- /dev/null
+++ b/Lib/test/test_asyncio/test_tools.py
@@ -0,0 +1,1706 @@
+import unittest
+
+from asyncio import tools
+
+from collections import namedtuple
+
+FrameInfo = namedtuple('FrameInfo', ['funcname', 'filename', 'lineno'])
+CoroInfo = namedtuple('CoroInfo', ['call_stack', 'task_name'])
+TaskInfo = namedtuple('TaskInfo', ['task_id', 'task_name', 'coroutine_stack', 'awaited_by'])
+AwaitedInfo = namedtuple('AwaitedInfo', ['thread_id', 'awaited_by'])
+
+
+# mock output of get_all_awaited_by function.
+TEST_INPUTS_TREE = [
+    [
+        # test case containing a task called timer being awaited in two
+        # different subtasks part of a TaskGroup (root1 and root2) which call
+        # awaiter functions.
+        (
+            AwaitedInfo(
+                thread_id=1,
+                awaited_by=[
+                    TaskInfo(
+                        task_id=2,
+                        task_name="Task-1",
+                        coroutine_stack=[],
+                        awaited_by=[]
+                    ),
+                    TaskInfo(
+                        task_id=3,
+                        task_name="timer",
+                        coroutine_stack=[],
+                        awaited_by=[
+                            CoroInfo(
+                                call_stack=[
+                                    FrameInfo("awaiter3", "/path/to/app.py", 130),
+                                    FrameInfo("awaiter2", "/path/to/app.py", 120),
+                                    FrameInfo("awaiter", "/path/to/app.py", 110)
+                                ],
+                                task_name=4
+                            ),
+                            CoroInfo(
+                                call_stack=[
+                                    FrameInfo("awaiterB3", "/path/to/app.py", 190),
+                                    FrameInfo("awaiterB2", "/path/to/app.py", 180),
+                                    FrameInfo("awaiterB", "/path/to/app.py", 170)
+                                ],
+                                task_name=5
+                            ),
+                            CoroInfo(
+                                call_stack=[
+                                    FrameInfo("awaiterB3", "/path/to/app.py", 190),
+                                    FrameInfo("awaiterB2", "/path/to/app.py", 180),
+                                    FrameInfo("awaiterB", "/path/to/app.py", 170)
+                                ],
+                                task_name=6
+                            ),
+                            CoroInfo(
+                                call_stack=[
+                                    FrameInfo("awaiter3", "/path/to/app.py", 130),
+                                    FrameInfo("awaiter2", "/path/to/app.py", 120),
+                                    FrameInfo("awaiter", "/path/to/app.py", 110)
+                                ],
+                                task_name=7
+                            )
+                        ]
+                    ),
+                    TaskInfo(
+                        task_id=8,
+                        task_name="root1",
+                        coroutine_stack=[],
+                        awaited_by=[
+                            CoroInfo(
+                                call_stack=[
+                                    FrameInfo("_aexit", "", 0),
+                                    FrameInfo("__aexit__", "", 0),
+                                    FrameInfo("main", "", 0)
+                                ],
+                                task_name=2
+                            )
+                        ]
+                    ),
+                    TaskInfo(
+                        task_id=9,
+                        task_name="root2",
+                        coroutine_stack=[],
+                        awaited_by=[
+                            CoroInfo(
+                                call_stack=[
+                                    FrameInfo("_aexit", "", 0),
+                                    FrameInfo("__aexit__", "", 0),
+                                    FrameInfo("main", "", 0)
+                                ],
+                                task_name=2
+                            )
+                        ]
+                    ),
+                    TaskInfo(
+                        task_id=4,
+                        task_name="child1_1",
+                        coroutine_stack=[],
+                        awaited_by=[
+                            CoroInfo(
+                                call_stack=[
+                                    FrameInfo("_aexit", "", 0),
+                                    FrameInfo("__aexit__", "", 0),
+                                    FrameInfo("blocho_caller", "", 0),
+                                    FrameInfo("bloch", "", 0)
+                                ],
+                                task_name=8
+                            )
+                        ]
+                    ),
+                    TaskInfo(
+                        task_id=6,
+                        task_name="child2_1",
+                        coroutine_stack=[],
+                        awaited_by=[
+                            CoroInfo(
+                                call_stack=[
+                                    FrameInfo("_aexit", "", 0),
+                                    FrameInfo("__aexit__", "", 0),
+                                    FrameInfo("blocho_caller", "", 0),
+                                    FrameInfo("bloch", "", 0)
+                                ],
+                                task_name=8
+                            )
+                        ]
+                    ),
+                    TaskInfo(
+                        task_id=7,
+                        task_name="child1_2",
+                        coroutine_stack=[],
+                        awaited_by=[
+                            CoroInfo(
+                                call_stack=[
+                                    FrameInfo("_aexit", "", 0),
+                                    FrameInfo("__aexit__", "", 0),
+                                    FrameInfo("blocho_caller", "", 0),
+                                    FrameInfo("bloch", "", 0)
+                                ],
+                                task_name=9
+                            )
+                        ]
+                    ),
+                    TaskInfo(
+                        task_id=5,
+                        task_name="child2_2",
+                        coroutine_stack=[],
+                        awaited_by=[
+                            CoroInfo(
+                                call_stack=[
+                                    FrameInfo("_aexit", "", 0),
+                                    FrameInfo("__aexit__", "", 0),
+                                    FrameInfo("blocho_caller", "", 0),
+                                    FrameInfo("bloch", "", 0)
+                                ],
+                                task_name=9
+                            )
+                        ]
+                    )
+                ]
+            ),
+            AwaitedInfo(thread_id=0, awaited_by=[])
+        ),
+        (
+            [
+                [
+                    "└── (T) Task-1",
+                    "    └──  main",
+                    "        └──  __aexit__",
+                    "            └──  _aexit",
+                    "                ├── (T) root1",
+                    "                │   └──  bloch",
+                    "                │       └──  blocho_caller",
+                    "                │           └──  __aexit__",
+                    "                │               └──  _aexit",
+                    "                │                   ├── (T) child1_1",
+                    "                │                   │   └──  awaiter /path/to/app.py:110",
+                    "                │                   │       └──  awaiter2 /path/to/app.py:120",
+                    "                │                   │           └──  awaiter3 /path/to/app.py:130",
+                    "                │                   │               └── (T) timer",
+                    "                │                   └── (T) child2_1",
+                    "                │                       └──  awaiterB /path/to/app.py:170",
+                    "                │                           └──  awaiterB2 /path/to/app.py:180",
+                    "                │                               └──  awaiterB3 /path/to/app.py:190",
+                    "                │                                   └── (T) timer",
+                    "                └── (T) root2",
+                    "                    └──  bloch",
+                    "                        └──  blocho_caller",
+                    "                            └──  __aexit__",
+                    "                                └──  _aexit",
+                    "                                    ├── (T) child1_2",
+                    "                                    │   └──  awaiter /path/to/app.py:110",
+                    "                                    │       └──  awaiter2 /path/to/app.py:120",
+                    "                                    │           └──  awaiter3 /path/to/app.py:130",
+                    "                                    │               └── (T) timer",
+                    "                                    └── (T) child2_2",
+                    "                                        └──  awaiterB /path/to/app.py:170",
+                    "                                            └──  awaiterB2 /path/to/app.py:180",
+                    "                                                └──  awaiterB3 /path/to/app.py:190",
+                    "                                                    └── (T) timer",
+                ]
+            ]
+        ),
+    ],
+    [
+        # test case containing two roots
+        (
+            AwaitedInfo(
+                thread_id=9,
+                awaited_by=[
+                    TaskInfo(
+                        task_id=5,
+                        task_name="Task-5",
+                        coroutine_stack=[],
+                        awaited_by=[]
+                    ),
+                    TaskInfo(
+                        task_id=6,
+                        task_name="Task-6",
+                        coroutine_stack=[],
+                        awaited_by=[
+                            CoroInfo(
+                                call_stack=[FrameInfo("main2", "", 0)],
+                                task_name=5
+                            )
+                        ]
+                    ),
+                    TaskInfo(
+                        task_id=7,
+                        task_name="Task-7",
+                        coroutine_stack=[],
+                        awaited_by=[
+                            CoroInfo(
+                                call_stack=[FrameInfo("main2", "", 0)],
+                                task_name=5
+                            )
+                        ]
+                    ),
+                    TaskInfo(
+                        task_id=8,
+                        task_name="Task-8",
+                        coroutine_stack=[],
+                        awaited_by=[
+                            CoroInfo(
+                                call_stack=[FrameInfo("main2", "", 0)],
+                                task_name=5
+                            )
+                        ]
+                    )
+                ]
+            ),
+            AwaitedInfo(
+                thread_id=10,
+                awaited_by=[
+                    TaskInfo(
+                        task_id=1,
+                        task_name="Task-1",
+                        coroutine_stack=[],
+                        awaited_by=[]
+                    ),
+                    TaskInfo(
+                        task_id=2,
+                        task_name="Task-2",
+                        coroutine_stack=[],
+                        awaited_by=[
+                            CoroInfo(
+                                call_stack=[FrameInfo("main", "", 0)],
+                                task_name=1
+                            )
+                        ]
+                    ),
+                    TaskInfo(
+                        task_id=3,
+                        task_name="Task-3",
+                        coroutine_stack=[],
+                        awaited_by=[
+                            CoroInfo(
+                                call_stack=[FrameInfo("main", "", 0)],
+                                task_name=1
+                            )
+                        ]
+                    ),
+                    TaskInfo(
+                        task_id=4,
+                        task_name="Task-4",
+                        coroutine_stack=[],
+                        awaited_by=[
+                            CoroInfo(
+                                call_stack=[FrameInfo("main", "", 0)],
+                                task_name=1
+                            )
+                        ]
+                    )
+                ]
+            ),
+            AwaitedInfo(thread_id=11, awaited_by=[]),
+            AwaitedInfo(thread_id=0, awaited_by=[])
+        ),
+        (
+            [
+                [
+                    "└── (T) Task-5",
+                    "    └──  main2",
+                    "        ├── (T) Task-6",
+                    "        ├── (T) Task-7",
+                    "        └── (T) Task-8",
+                ],
+                [
+                    "└── (T) Task-1",
+                    "    └──  main",
+                    "        ├── (T) Task-2",
+                    "        ├── (T) Task-3",
+                    "        └── (T) Task-4",
+                ],
+            ]
+        ),
+    ],
+    [
+        # test case containing two roots, one of them without subtasks
+        (
+            [
+                AwaitedInfo(
+                    thread_id=1,
+                    awaited_by=[
+                        TaskInfo(
+                            task_id=2,
+                            task_name="Task-5",
+                            coroutine_stack=[],
+                            awaited_by=[]
+                        )
+                    ]
+                ),
+                AwaitedInfo(
+                    thread_id=3,
+                    awaited_by=[
+                        TaskInfo(
+                            task_id=4,
+                            task_name="Task-1",
+                            coroutine_stack=[],
+                            awaited_by=[]
+                        ),
+                        TaskInfo(
+                            task_id=5,
+                            task_name="Task-2",
+                            coroutine_stack=[],
+                            awaited_by=[
+                                CoroInfo(
+                                    call_stack=[FrameInfo("main", "", 0)],
+                                    task_name=4
+                                )
+                            ]
+                        ),
+                        TaskInfo(
+                            task_id=6,
+                            task_name="Task-3",
+                            coroutine_stack=[],
+                            awaited_by=[
+                                CoroInfo(
+                                    call_stack=[FrameInfo("main", "", 0)],
+                                    task_name=4
+                                )
+                            ]
+                        ),
+                        TaskInfo(
+                            task_id=7,
+                            task_name="Task-4",
+                            coroutine_stack=[],
+                            awaited_by=[
+                                CoroInfo(
+                                    call_stack=[FrameInfo("main", "", 0)],
+                                    task_name=4
+                                )
+                            ]
+                        )
+                    ]
+                ),
+                AwaitedInfo(thread_id=8, awaited_by=[]),
+                AwaitedInfo(thread_id=0, awaited_by=[])
+            ]
+        ),
+        (
+            [
+                ["└── (T) Task-5"],
+                [
+                    "└── (T) Task-1",
+                    "    └──  main",
+                    "        ├── (T) Task-2",
+                    "        ├── (T) Task-3",
+                    "        └── (T) Task-4",
+                ],
+            ]
+        ),
+    ],
+]
+
+TEST_INPUTS_CYCLES_TREE = [
+    [
+        # this test case contains a cycle: two tasks awaiting each other.
+        (
+            [
+                AwaitedInfo(
+                    thread_id=1,
+                    awaited_by=[
+                        TaskInfo(
+                            task_id=2,
+                            task_name="Task-1",
+                            coroutine_stack=[],
+                            awaited_by=[]
+                        ),
+                        TaskInfo(
+                            task_id=3,
+                            task_name="a",
+                            coroutine_stack=[],
+                            awaited_by=[
+                                CoroInfo(
+                                    call_stack=[FrameInfo("awaiter2", "", 0)],
+                                    task_name=4
+                                ),
+                                CoroInfo(
+                                    call_stack=[FrameInfo("main", "", 0)],
+                                    task_name=2
+                                )
+                            ]
+                        ),
+                        TaskInfo(
+                            task_id=4,
+                            task_name="b",
+                            coroutine_stack=[],
+                            awaited_by=[
+                                CoroInfo(
+                                    call_stack=[FrameInfo("awaiter", "", 0)],
+                                    task_name=3
+                                )
+                            ]
+                        )
+                    ]
+                ),
+                AwaitedInfo(thread_id=0, awaited_by=[])
+            ]
+        ),
+        ([[4, 3, 4]]),
+    ],
+    [
+        # this test case contains two cycles
+        (
+            [
+                AwaitedInfo(
+                    thread_id=1,
+                    awaited_by=[
+                        TaskInfo(
+                            task_id=2,
+                            task_name="Task-1",
+                            coroutine_stack=[],
+                            awaited_by=[]
+                        ),
+                        TaskInfo(
+                            task_id=3,
+                            task_name="A",
+                            coroutine_stack=[],
+                            awaited_by=[
+                                CoroInfo(
+                                    call_stack=[
+                                        FrameInfo("nested", "", 0),
+                                        FrameInfo("nested", "", 0),
+                                        FrameInfo("task_b", "", 0)
+                                    ],
+                                    task_name=4
+                                )
+                            ]
+                        ),
+                        TaskInfo(
+                            task_id=4,
+                            task_name="B",
+                            coroutine_stack=[],
+                            awaited_by=[
+                                CoroInfo(
+                                    call_stack=[
+                                        FrameInfo("nested", "", 0),
+                                        FrameInfo("nested", "", 0),
+                                        FrameInfo("task_c", "", 0)
+                                    ],
+                                    task_name=5
+                                ),
+                                CoroInfo(
+                                    call_stack=[
+                                        FrameInfo("nested", "", 0),
+                                        FrameInfo("nested", "", 0),
+                                        FrameInfo("task_a", "", 0)
+                                    ],
+                                    task_name=3
+                                )
+                            ]
+                        ),
+                        TaskInfo(
+                            task_id=5,
+                            task_name="C",
+                            coroutine_stack=[],
+                            awaited_by=[
+                                CoroInfo(
+                                    call_stack=[
+                                        FrameInfo("nested", "", 0),
+                                        FrameInfo("nested", "", 0)
+                                    ],
+                                    task_name=6
+                                )
+                            ]
+                        ),
+                        TaskInfo(
+                            task_id=6,
+                            task_name="Task-2",
+                            coroutine_stack=[],
+                            awaited_by=[
+                                CoroInfo(
+                                    call_stack=[
+                                        FrameInfo("nested", "", 0),
+                                        FrameInfo("nested", "", 0),
+                                        FrameInfo("task_b", "", 0)
+                                    ],
+                                    task_name=4
+                                )
+                            ]
+                        )
+                    ]
+                ),
+                AwaitedInfo(thread_id=0, awaited_by=[])
+            ]
+        ),
+        ([[4, 3, 4], [4, 6, 5, 4]]),
+    ],
+]
+
+TEST_INPUTS_TABLE = [
+    [
+        # test case containing a task called timer being awaited in two
+        # different subtasks part of a TaskGroup (root1 and root2) which call
+        # awaiter functions.
+        (
+            AwaitedInfo(
+                thread_id=1,
+                awaited_by=[
+                    TaskInfo(
+                        task_id=2,
+                        task_name="Task-1",
+                        coroutine_stack=[],
+                        awaited_by=[]
+                    ),
+                    TaskInfo(
+                        task_id=3,
+                        task_name="timer",
+                        coroutine_stack=[],
+                        awaited_by=[
+                            CoroInfo(
+                                call_stack=[
+                                    FrameInfo("awaiter3", "", 0),
+                                    FrameInfo("awaiter2", "", 0),
+                                    FrameInfo("awaiter", "", 0)
+                                ],
+                                task_name=4
+                            ),
+                            CoroInfo(
+                                call_stack=[
+                                    FrameInfo("awaiter1_3", "", 0),
+                                    FrameInfo("awaiter1_2", "", 0),
+                                    FrameInfo("awaiter1", "", 0)
+                                ],
+                                task_name=5
+                            ),
+                            CoroInfo(
+                                call_stack=[
+                                    FrameInfo("awaiter1_3", "", 0),
+                                    FrameInfo("awaiter1_2", "", 0),
+                                    FrameInfo("awaiter1", "", 0)
+                                ],
+                                task_name=6
+                            ),
+                            CoroInfo(
+                                call_stack=[
+                                    FrameInfo("awaiter3", "", 0),
+                                    FrameInfo("awaiter2", "", 0),
+                                    FrameInfo("awaiter", "", 0)
+                                ],
+                                task_name=7
+                            )
+                        ]
+                    ),
+                    TaskInfo(
+                        task_id=8,
+                        task_name="root1",
+                        coroutine_stack=[],
+                        awaited_by=[
+                            CoroInfo(
+                                call_stack=[
+                                    FrameInfo("_aexit", "", 0),
+                                    FrameInfo("__aexit__", "", 0),
+                                    FrameInfo("main", "", 0)
+                                ],
+                                task_name=2
+                            )
+                        ]
+                    ),
+                    TaskInfo(
+                        task_id=9,
+                        task_name="root2",
+                        coroutine_stack=[],
+                        awaited_by=[
+                            CoroInfo(
+                                call_stack=[
+                                    FrameInfo("_aexit", "", 0),
+                                    FrameInfo("__aexit__", "", 0),
+                                    FrameInfo("main", "", 0)
+                                ],
+                                task_name=2
+                            )
+                        ]
+                    ),
+                    TaskInfo(
+                        task_id=4,
+                        task_name="child1_1",
+                        coroutine_stack=[],
+                        awaited_by=[
+                            CoroInfo(
+                                call_stack=[
+                                    FrameInfo("_aexit", "", 0),
+                                    FrameInfo("__aexit__", "", 0),
+                                    FrameInfo("blocho_caller", "", 0),
+                                    FrameInfo("bloch", "", 0)
+                                ],
+                                task_name=8
+                            )
+                        ]
+                    ),
+                    TaskInfo(
+                        task_id=6,
+                        task_name="child2_1",
+                        coroutine_stack=[],
+                        awaited_by=[
+                            CoroInfo(
+                                call_stack=[
+                                    FrameInfo("_aexit", "", 0),
+                                    FrameInfo("__aexit__", "", 0),
+                                    FrameInfo("blocho_caller", "", 0),
+                                    FrameInfo("bloch", "", 0)
+                                ],
+                                task_name=8
+                            )
+                        ]
+                    ),
+                    TaskInfo(
+                        task_id=7,
+                        task_name="child1_2",
+                        coroutine_stack=[],
+                        awaited_by=[
+                            CoroInfo(
+                                call_stack=[
+                                    FrameInfo("_aexit", "", 0),
+                                    FrameInfo("__aexit__", "", 0),
+                                    FrameInfo("blocho_caller", "", 0),
+                                    FrameInfo("bloch", "", 0)
+                                ],
+                                task_name=9
+                            )
+                        ]
+                    ),
+                    TaskInfo(
+                        task_id=5,
+                        task_name="child2_2",
+                        coroutine_stack=[],
+                        awaited_by=[
+                            CoroInfo(
+                                call_stack=[
+                                    FrameInfo("_aexit", "", 0),
+                                    FrameInfo("__aexit__", "", 0),
+                                    FrameInfo("blocho_caller", "", 0),
+                                    FrameInfo("bloch", "", 0)
+                                ],
+                                task_name=9
+                            )
+                        ]
+                    )
+                ]
+            ),
+            AwaitedInfo(thread_id=0, awaited_by=[])
+        ),
+        (
+            [
+                [1, "0x2", "Task-1", "", "", "", "0x0"],
+                [
+                    1,
+                    "0x3",
+                    "timer",
+                    "",
+                    "awaiter3 -> awaiter2 -> awaiter",
+                    "child1_1",
+                    "0x4",
+                ],
+                [
+                    1,
+                    "0x3",
+                    "timer",
+                    "",
+                    "awaiter1_3 -> awaiter1_2 -> awaiter1",
+                    "child2_2",
+                    "0x5",
+                ],
+                [
+                    1,
+                    "0x3",
+                    "timer",
+                    "",
+                    "awaiter1_3 -> awaiter1_2 -> awaiter1",
+                    "child2_1",
+                    "0x6",
+                ],
+                [
+                    1,
+                    "0x3",
+                    "timer",
+                    "",
+                    "awaiter3 -> awaiter2 -> awaiter",
+                    "child1_2",
+                    "0x7",
+                ],
+                [
+                    1,
+                    "0x8",
+                    "root1",
+                    "",
+                    "_aexit -> __aexit__ -> main",
+                    "Task-1",
+                    "0x2",
+                ],
+                [
+                    1,
+                    "0x9",
+                    "root2",
+                    "",
+                    "_aexit -> __aexit__ -> main",
+                    "Task-1",
+                    "0x2",
+                ],
+                [
+                    1,
+                    "0x4",
+                    "child1_1",
+                    "",
+                    "_aexit -> __aexit__ -> blocho_caller -> bloch",
+                    "root1",
+                    "0x8",
+                ],
+                [
+                    1,
+                    "0x6",
+                    "child2_1",
+                    "",
+                    "_aexit -> __aexit__ -> blocho_caller -> bloch",
+                    "root1",
+                    "0x8",
+                ],
+                [
+                    1,
+                    "0x7",
+                    "child1_2",
+                    "",
+                    "_aexit -> __aexit__ -> blocho_caller -> bloch",
+                    "root2",
+                    "0x9",
+                ],
+                [
+                    1,
+                    "0x5",
+                    "child2_2",
+                    "",
+                    "_aexit -> __aexit__ -> blocho_caller -> bloch",
+                    "root2",
+                    "0x9",
+                ],
+            ]
+        ),
+    ],
+    [
+        # test case containing two roots
+        (
+            AwaitedInfo(
+                thread_id=9,
+                awaited_by=[
+                    TaskInfo(
+                        task_id=5,
+                        task_name="Task-5",
+                        coroutine_stack=[],
+                        awaited_by=[]
+                    ),
+                    TaskInfo(
+                        task_id=6,
+                        task_name="Task-6",
+                        coroutine_stack=[],
+                        awaited_by=[
+                            CoroInfo(
+                                call_stack=[FrameInfo("main2", "", 0)],
+                                task_name=5
+                            )
+                        ]
+                    ),
+                    TaskInfo(
+                        task_id=7,
+                        task_name="Task-7",
+                        coroutine_stack=[],
+                        awaited_by=[
+                            CoroInfo(
+                                call_stack=[FrameInfo("main2", "", 0)],
+                                task_name=5
+                            )
+                        ]
+                    ),
+                    TaskInfo(
+                        task_id=8,
+                        task_name="Task-8",
+                        coroutine_stack=[],
+                        awaited_by=[
+                            CoroInfo(
+                                call_stack=[FrameInfo("main2", "", 0)],
+                                task_name=5
+                            )
+                        ]
+                    )
+                ]
+            ),
+            AwaitedInfo(
+                thread_id=10,
+                awaited_by=[
+                    TaskInfo(
+                        task_id=1,
+                        task_name="Task-1",
+                        coroutine_stack=[],
+                        awaited_by=[]
+                    ),
+                    TaskInfo(
+                        task_id=2,
+                        task_name="Task-2",
+                        coroutine_stack=[],
+                        awaited_by=[
+                            CoroInfo(
+                                call_stack=[FrameInfo("main", "", 0)],
+                                task_name=1
+                            )
+                        ]
+                    ),
+                    TaskInfo(
+                        task_id=3,
+                        task_name="Task-3",
+                        coroutine_stack=[],
+                        awaited_by=[
+                            CoroInfo(
+                                call_stack=[FrameInfo("main", "", 0)],
+                                task_name=1
+                            )
+                        ]
+                    ),
+                    TaskInfo(
+                        task_id=4,
+                        task_name="Task-4",
+                        coroutine_stack=[],
+                        awaited_by=[
+                            CoroInfo(
+                                call_stack=[FrameInfo("main", "", 0)],
+                                task_name=1
+                            )
+                        ]
+                    )
+                ]
+            ),
+            AwaitedInfo(thread_id=11, awaited_by=[]),
+            AwaitedInfo(thread_id=0, awaited_by=[])
+        ),
+        (
+            [
+                [9, "0x5", "Task-5", "", "", "", "0x0"],
+                [9, "0x6", "Task-6", "", "main2", "Task-5", "0x5"],
+                [9, "0x7", "Task-7", "", "main2", "Task-5", "0x5"],
+                [9, "0x8", "Task-8", "", "main2", "Task-5", "0x5"],
+                [10, "0x1", "Task-1", "", "", "", "0x0"],
+                [10, "0x2", "Task-2", "", "main", "Task-1", "0x1"],
+                [10, "0x3", "Task-3", "", "main", "Task-1", "0x1"],
+                [10, "0x4", "Task-4", "", "main", "Task-1", "0x1"],
+            ]
+        ),
+    ],
+    [
+        # test case containing two roots, one of them without subtasks
+        (
+            [
+                AwaitedInfo(
+                    thread_id=1,
+                    awaited_by=[
+                        TaskInfo(
+                            task_id=2,
+                            task_name="Task-5",
+                            coroutine_stack=[],
+                            awaited_by=[]
+                        )
+                    ]
+                ),
+                AwaitedInfo(
+                    thread_id=3,
+                    awaited_by=[
+                        TaskInfo(
+                            task_id=4,
+                            task_name="Task-1",
+                            coroutine_stack=[],
+                            awaited_by=[]
+                        ),
+                        TaskInfo(
+                            task_id=5,
+                            task_name="Task-2",
+                            coroutine_stack=[],
+                            awaited_by=[
+                                CoroInfo(
+                                    call_stack=[FrameInfo("main", "", 0)],
+                                    task_name=4
+                                )
+                            ]
+                        ),
+                        TaskInfo(
+                            task_id=6,
+                            task_name="Task-3",
+                            coroutine_stack=[],
+                            awaited_by=[
+                                CoroInfo(
+                                    call_stack=[FrameInfo("main", "", 0)],
+                                    task_name=4
+                                )
+                            ]
+                        ),
+                        TaskInfo(
+                            task_id=7,
+                            task_name="Task-4",
+                            coroutine_stack=[],
+                            awaited_by=[
+                                CoroInfo(
+                                    call_stack=[FrameInfo("main", "", 0)],
+                                    task_name=4
+                                )
+                            ]
+                        )
+                    ]
+                ),
+                AwaitedInfo(thread_id=8, awaited_by=[]),
+                AwaitedInfo(thread_id=0, awaited_by=[])
+            ]
+        ),
+        (
+            [
+                [1, "0x2", "Task-5", "", "", "", "0x0"],
+                [3, "0x4", "Task-1", "", "", "", "0x0"],
+                [3, "0x5", "Task-2", "", "main", "Task-1", "0x4"],
+                [3, "0x6", "Task-3", "", "main", "Task-1", "0x4"],
+                [3, "0x7", "Task-4", "", "main", "Task-1", "0x4"],
+            ]
+        ),
+    ],
+    # CASES WITH CYCLES
+    [
+        # this test case contains a cycle: two tasks awaiting each other.
+        (
+            [
+                AwaitedInfo(
+                    thread_id=1,
+                    awaited_by=[
+                        TaskInfo(
+                            task_id=2,
+                            task_name="Task-1",
+                            coroutine_stack=[],
+                            awaited_by=[]
+                        ),
+                        TaskInfo(
+                            task_id=3,
+                            task_name="a",
+                            coroutine_stack=[],
+                            awaited_by=[
+                                CoroInfo(
+                                    call_stack=[FrameInfo("awaiter2", "", 0)],
+                                    task_name=4
+                                ),
+                                CoroInfo(
+                                    call_stack=[FrameInfo("main", "", 0)],
+                                    task_name=2
+                                )
+                            ]
+                        ),
+                        TaskInfo(
+                            task_id=4,
+                            task_name="b",
+                            coroutine_stack=[],
+                            awaited_by=[
+                                CoroInfo(
+                                    call_stack=[FrameInfo("awaiter", "", 0)],
+                                    task_name=3
+                                )
+                            ]
+                        )
+                    ]
+                ),
+                AwaitedInfo(thread_id=0, awaited_by=[])
+            ]
+        ),
+        (
+            [
+                [1, "0x2", "Task-1", "", "", "", "0x0"],
+                [1, "0x3", "a", "", "awaiter2", "b", "0x4"],
+                [1, "0x3", "a", "", "main", "Task-1", "0x2"],
+                [1, "0x4", "b", "", "awaiter", "a", "0x3"],
+            ]
+        ),
+    ],
+    [
+        # this test case contains two cycles
+        (
+            [
+                AwaitedInfo(
+                    thread_id=1,
+                    awaited_by=[
+                        TaskInfo(
+                            task_id=2,
+                            task_name="Task-1",
+                            coroutine_stack=[],
+                            awaited_by=[]
+                        ),
+                        TaskInfo(
+                            task_id=3,
+                            task_name="A",
+                            coroutine_stack=[],
+                            awaited_by=[
+                                CoroInfo(
+                                    call_stack=[
+                                        FrameInfo("nested", "", 0),
+                                        FrameInfo("nested", "", 0),
+                                        FrameInfo("task_b", "", 0)
+                                    ],
+                                    task_name=4
+                                )
+                            ]
+                        ),
+                        TaskInfo(
+                            task_id=4,
+                            task_name="B",
+                            coroutine_stack=[],
+                            awaited_by=[
+                                CoroInfo(
+                                    call_stack=[
+                                        FrameInfo("nested", "", 0),
+                                        FrameInfo("nested", "", 0),
+                                        FrameInfo("task_c", "", 0)
+                                    ],
+                                    task_name=5
+                                ),
+                                CoroInfo(
+                                    call_stack=[
+                                        FrameInfo("nested", "", 0),
+                                        FrameInfo("nested", "", 0),
+                                        FrameInfo("task_a", "", 0)
+                                    ],
+                                    task_name=3
+                                )
+                            ]
+                        ),
+                        TaskInfo(
+                            task_id=5,
+                            task_name="C",
+                            coroutine_stack=[],
+                            awaited_by=[
+                                CoroInfo(
+                                    call_stack=[
+                                        FrameInfo("nested", "", 0),
+                                        FrameInfo("nested", "", 0)
+                                    ],
+                                    task_name=6
+                                )
+                            ]
+                        ),
+                        TaskInfo(
+                            task_id=6,
+                            task_name="Task-2",
+                            coroutine_stack=[],
+                            awaited_by=[
+                                CoroInfo(
+                                    call_stack=[
+                                        FrameInfo("nested", "", 0),
+                                        FrameInfo("nested", "", 0),
+                                        FrameInfo("task_b", "", 0)
+                                    ],
+                                    task_name=4
+                                )
+                            ]
+                        )
+                    ]
+                ),
+                AwaitedInfo(thread_id=0, awaited_by=[])
+            ]
+        ),
+        (
+            [
+                [1, "0x2", "Task-1", "", "", "", "0x0"],
+                [
+                    1,
+                    "0x3",
+                    "A",
+                    "",
+                    "nested -> nested -> task_b",
+                    "B",
+                    "0x4",
+                ],
+                [
+                    1,
+                    "0x4",
+                    "B",
+                    "",
+                    "nested -> nested -> task_c",
+                    "C",
+                    "0x5",
+                ],
+                [
+                    1,
+                    "0x4",
+                    "B",
+                    "",
+                    "nested -> nested -> task_a",
+                    "A",
+                    "0x3",
+                ],
+                [
+                    1,
+                    "0x5",
+                    "C",
+                    "",
+                    "nested -> nested",
+                    "Task-2",
+                    "0x6",
+                ],
+                [
+                    1,
+                    "0x6",
+                    "Task-2",
+                    "",
+                    "nested -> nested -> task_b",
+                    "B",
+                    "0x4",
+                ],
+            ]
+        ),
+    ],
+]
+
+
+class TestAsyncioToolsTree(unittest.TestCase):
+    def test_asyncio_utils(self):
+        for input_, tree in TEST_INPUTS_TREE:
+            with self.subTest(input_):
+                result = tools.build_async_tree(input_)
+                self.assertEqual(result, tree)
+
+    def test_asyncio_utils_cycles(self):
+        for input_, cycles in TEST_INPUTS_CYCLES_TREE:
+            with self.subTest(input_):
+                try:
+                    tools.build_async_tree(input_)
+                except tools.CycleFoundException as e:
+                    self.assertEqual(e.cycles, cycles)
+
+
+class TestAsyncioToolsTable(unittest.TestCase):
+    def test_asyncio_utils(self):
+        for input_, table in TEST_INPUTS_TABLE:
+            with self.subTest(input_):
+                result = tools.build_task_table(input_)
+                self.assertEqual(result, table)
+
+
+class TestAsyncioToolsBasic(unittest.TestCase):
+    def test_empty_input_tree(self):
+        """Test build_async_tree with empty input."""
+        result = []
+        expected_output = []
+        self.assertEqual(tools.build_async_tree(result), expected_output)
+
+    def test_empty_input_table(self):
+        """Test build_task_table with empty input."""
+        result = []
+        expected_output = []
+        self.assertEqual(tools.build_task_table(result), expected_output)
+
+    def test_only_independent_tasks_tree(self):
+        input_ = [
+            AwaitedInfo(
+                thread_id=1,
+                awaited_by=[
+                    TaskInfo(
+                        task_id=10,
+                        task_name="taskA",
+                        coroutine_stack=[],
+                        awaited_by=[]
+                    ),
+                    TaskInfo(
+                        task_id=11,
+                        task_name="taskB",
+                        coroutine_stack=[],
+                        awaited_by=[]
+                    )
+                ]
+            )
+        ]
+        expected = [["└── (T) taskA"], ["└── (T) taskB"]]
+        result = tools.build_async_tree(input_)
+        self.assertEqual(sorted(result), sorted(expected))
+
+    def test_only_independent_tasks_table(self):
+        input_ = [
+            AwaitedInfo(
+                thread_id=1,
+                awaited_by=[
+                    TaskInfo(
+                        task_id=10,
+                        task_name="taskA",
+                        coroutine_stack=[],
+                        awaited_by=[]
+                    ),
+                    TaskInfo(
+                        task_id=11,
+                        task_name="taskB",
+                        coroutine_stack=[],
+                        awaited_by=[]
+                    )
+                ]
+            )
+        ]
+        self.assertEqual(
+            tools.build_task_table(input_),
+            [[1, '0xa', 'taskA', '', '', '', '0x0'], [1, '0xb', 'taskB', '', '', '', '0x0']]
+        )
+
+    def test_single_task_tree(self):
+        """Test build_async_tree with a single task and no awaits."""
+        result = [
+            AwaitedInfo(
+                thread_id=1,
+                awaited_by=[
+                    TaskInfo(
+                        task_id=2,
+                        task_name="Task-1",
+                        coroutine_stack=[],
+                        awaited_by=[]
+                    )
+                ]
+            )
+        ]
+        expected_output = [
+            [
+                "└── (T) Task-1",
+            ]
+        ]
+        self.assertEqual(tools.build_async_tree(result), expected_output)
+
+    def test_single_task_table(self):
+        """Test build_task_table with a single task and no awaits."""
+        result = [
+            AwaitedInfo(
+                thread_id=1,
+                awaited_by=[
+                    TaskInfo(
+                        task_id=2,
+                        task_name="Task-1",
+                        coroutine_stack=[],
+                        awaited_by=[]
+                    )
+                ]
+            )
+        ]
+        expected_output = [[1, '0x2', 'Task-1', '', '', '', '0x0']]
+        self.assertEqual(tools.build_task_table(result), expected_output)
+
+    def test_cycle_detection(self):
+        """Test build_async_tree raises CycleFoundException for cyclic input."""
+        result = [
+            AwaitedInfo(
+                thread_id=1,
+                awaited_by=[
+                    TaskInfo(
+                        task_id=2,
+                        task_name="Task-1",
+                        coroutine_stack=[],
+                        awaited_by=[
+                            CoroInfo(
+                                call_stack=[FrameInfo("main", "", 0)],
+                                task_name=3
+                            )
+                        ]
+                    ),
+                    TaskInfo(
+                        task_id=3,
+                        task_name="Task-2",
+                        coroutine_stack=[],
+                        awaited_by=[
+                            CoroInfo(
+                                call_stack=[FrameInfo("main", "", 0)],
+                                task_name=2
+                            )
+                        ]
+                    )
+                ]
+            )
+        ]
+        with self.assertRaises(tools.CycleFoundException) as context:
+            tools.build_async_tree(result)
+        self.assertEqual(context.exception.cycles, [[3, 2, 3]])
+
+    def test_complex_tree(self):
+        """Test build_async_tree with a more complex tree structure."""
+        result = [
+            AwaitedInfo(
+                thread_id=1,
+                awaited_by=[
+                    TaskInfo(
+                        task_id=2,
+                        task_name="Task-1",
+                        coroutine_stack=[],
+                        awaited_by=[]
+                    ),
+                    TaskInfo(
+                        task_id=3,
+                        task_name="Task-2",
+                        coroutine_stack=[],
+                        awaited_by=[
+                            CoroInfo(
+                                call_stack=[FrameInfo("main", "", 0)],
+                                task_name=2
+                            )
+                        ]
+                    ),
+                    TaskInfo(
+                        task_id=4,
+                        task_name="Task-3",
+                        coroutine_stack=[],
+                        awaited_by=[
+                            CoroInfo(
+                                call_stack=[FrameInfo("main", "", 0)],
+                                task_name=3
+                            )
+                        ]
+                    )
+                ]
+            )
+        ]
+        expected_output = [
+            [
+                "└── (T) Task-1",
+                "    └──  main",
+                "        └── (T) Task-2",
+                "            └──  main",
+                "                └── (T) Task-3",
+            ]
+        ]
+        self.assertEqual(tools.build_async_tree(result), expected_output)
+
+    def test_complex_table(self):
+        """Test build_task_table with a more complex tree structure."""
+        result = [
+            AwaitedInfo(
+                thread_id=1,
+                awaited_by=[
+                    TaskInfo(
+                        task_id=2,
+                        task_name="Task-1",
+                        coroutine_stack=[],
+                        awaited_by=[]
+                    ),
+                    TaskInfo(
+                        task_id=3,
+                        task_name="Task-2",
+                        coroutine_stack=[],
+                        awaited_by=[
+                            CoroInfo(
+                                call_stack=[FrameInfo("main", "", 0)],
+                                task_name=2
+                            )
+                        ]
+                    ),
+                    TaskInfo(
+                        task_id=4,
+                        task_name="Task-3",
+                        coroutine_stack=[],
+                        awaited_by=[
+                            CoroInfo(
+                                call_stack=[FrameInfo("main", "", 0)],
+                                task_name=3
+                            )
+                        ]
+                    )
+                ]
+            )
+        ]
+        expected_output = [
+            [1, '0x2', 'Task-1', '', '', '', '0x0'],
+            [1, '0x3', 'Task-2', '', 'main', 'Task-1', '0x2'],
+            [1, '0x4', 'Task-3', '', 'main', 'Task-2', '0x3']
+        ]
+        self.assertEqual(tools.build_task_table(result), expected_output)
+
+    def test_deep_coroutine_chain(self):
+        input_ = [
+            AwaitedInfo(
+                thread_id=1,
+                awaited_by=[
+                    TaskInfo(
+                        task_id=10,
+                        task_name="leaf",
+                        coroutine_stack=[],
+                        awaited_by=[
+                            CoroInfo(
+                                call_stack=[
+                                    FrameInfo("c1", "", 0),
+                                    FrameInfo("c2", "", 0),
+                                    FrameInfo("c3", "", 0),
+                                    FrameInfo("c4", "", 0),
+                                    FrameInfo("c5", "", 0)
+                                ],
+                                task_name=11
+                            )
+                        ]
+                    ),
+                    TaskInfo(
+                        task_id=11,
+                        task_name="root",
+                        coroutine_stack=[],
+                        awaited_by=[]
+                    )
+                ]
+            )
+        ]
+        expected = [
+            [
+                "└── (T) root",
+                "    └──  c5",
+                "        └──  c4",
+                "            └──  c3",
+                "                └──  c2",
+                "                    └──  c1",
+                "                        └── (T) leaf",
+            ]
+        ]
+        result = tools.build_async_tree(input_)
+        self.assertEqual(result, expected)
+
+    def test_multiple_cycles_same_node(self):
+        input_ = [
+            AwaitedInfo(
+                thread_id=1,
+                awaited_by=[
+                    TaskInfo(
+                        task_id=1,
+                        task_name="Task-A",
+                        coroutine_stack=[],
+                        awaited_by=[
+                            CoroInfo(
+                                call_stack=[FrameInfo("call1", "", 0)],
+                                task_name=2
+                            )
+                        ]
+                    ),
+                    TaskInfo(
+                        task_id=2,
+                        task_name="Task-B",
+                        coroutine_stack=[],
+                        awaited_by=[
+                            CoroInfo(
+                                call_stack=[FrameInfo("call2", "", 0)],
+                                task_name=3
+                            )
+                        ]
+                    ),
+                    TaskInfo(
+                        task_id=3,
+                        task_name="Task-C",
+                        coroutine_stack=[],
+                        awaited_by=[
+                            CoroInfo(
+                                call_stack=[FrameInfo("call3", "", 0)],
+                                task_name=1
+                            ),
+                            CoroInfo(
+                                call_stack=[FrameInfo("call4", "", 0)],
+                                task_name=2
+                            )
+                        ]
+                    )
+                ]
+            )
+        ]
+        with self.assertRaises(tools.CycleFoundException) as ctx:
+            tools.build_async_tree(input_)
+        cycles = ctx.exception.cycles
+        self.assertTrue(any(set(c) == {1, 2, 3} for c in cycles))
+
+    def test_table_output_format(self):
+        input_ = [
+            AwaitedInfo(
+                thread_id=1,
+                awaited_by=[
+                    TaskInfo(
+                        task_id=1,
+                        task_name="Task-A",
+                        coroutine_stack=[],
+                        awaited_by=[
+                            CoroInfo(
+                                call_stack=[FrameInfo("foo", "", 0)],
+                                task_name=2
+                            )
+                        ]
+                    ),
+                    TaskInfo(
+                        task_id=2,
+                        task_name="Task-B",
+                        coroutine_stack=[],
+                        awaited_by=[]
+                    )
+                ]
+            )
+        ]
+        table = tools.build_task_table(input_)
+        for row in table:
+            self.assertEqual(len(row), 7)
+            self.assertIsInstance(row[0], int)  # thread ID
+            self.assertTrue(
+                isinstance(row[1], str) and row[1].startswith("0x")
+            )  # hex task ID
+            self.assertIsInstance(row[2], str)  # task name
+            self.assertIsInstance(row[3], str)  # coroutine stack
+            self.assertIsInstance(row[4], str)  # coroutine chain
+            self.assertIsInstance(row[5], str)  # awaiter name
+            self.assertTrue(
+                isinstance(row[6], str) and row[6].startswith("0x")
+            )  # hex awaiter ID
+
+
+class TestAsyncioToolsEdgeCases(unittest.TestCase):
+
+    def test_task_awaits_self(self):
+        """A task directly awaits itself - should raise a cycle."""
+        input_ = [
+            AwaitedInfo(
+                thread_id=1,
+                awaited_by=[
+                    TaskInfo(
+                        task_id=1,
+                        task_name="Self-Awaiter",
+                        coroutine_stack=[],
+                        awaited_by=[
+                            CoroInfo(
+                                call_stack=[FrameInfo("loopback", "", 0)],
+                                task_name=1
+                            )
+                        ]
+                    )
+                ]
+            )
+        ]
+        with self.assertRaises(tools.CycleFoundException) as ctx:
+            tools.build_async_tree(input_)
+        self.assertIn([1, 1], ctx.exception.cycles)
+
+    def test_task_with_missing_awaiter_id(self):
+        """Awaiter ID not in task list - should not crash, just show 'Unknown'."""
+        input_ = [
+            AwaitedInfo(
+                thread_id=1,
+                awaited_by=[
+                    TaskInfo(
+                        task_id=1,
+                        task_name="Task-A",
+                        coroutine_stack=[],
+                        awaited_by=[
+                            CoroInfo(
+                                call_stack=[FrameInfo("coro", "", 0)],
+                                task_name=999
+                            )
+                        ]
+                    )
+                ]
+            )
+        ]
+        table = tools.build_task_table(input_)
+        self.assertEqual(len(table), 1)
+        self.assertEqual(table[0][5], "Unknown")
+
+    def test_duplicate_coroutine_frames(self):
+        """Same coroutine frame repeated under a parent - should deduplicate."""
+        input_ = [
+            AwaitedInfo(
+                thread_id=1,
+                awaited_by=[
+                    TaskInfo(
+                        task_id=1,
+                        task_name="Task-1",
+                        coroutine_stack=[],
+                        awaited_by=[
+                            CoroInfo(
+                                call_stack=[FrameInfo("frameA", "", 0)],
+                                task_name=2
+                            ),
+                            CoroInfo(
+                                call_stack=[FrameInfo("frameA", "", 0)],
+                                task_name=3
+                            )
+                        ]
+                    ),
+                    TaskInfo(
+                        task_id=2,
+                        task_name="Task-2",
+                        coroutine_stack=[],
+                        awaited_by=[]
+                    ),
+                    TaskInfo(
+                        task_id=3,
+                        task_name="Task-3",
+                        coroutine_stack=[],
+                        awaited_by=[]
+                    )
+                ]
+            )
+        ]
+        tree = tools.build_async_tree(input_)
+        # Both children should be under the same coroutine node
+        flat = "\n".join(tree[0])
+        self.assertIn("frameA", flat)
+        self.assertIn("Task-2", flat)
+        self.assertIn("Task-1", flat)
+
+        flat = "\n".join(tree[1])
+        self.assertIn("frameA", flat)
+        self.assertIn("Task-3", flat)
+        self.assertIn("Task-1", flat)
+
+    def test_task_with_no_name(self):
+        """Task with no name in id2name - should still render with fallback."""
+        input_ = [
+            AwaitedInfo(
+                thread_id=1,
+                awaited_by=[
+                    TaskInfo(
+                        task_id=1,
+                        task_name="root",
+                        coroutine_stack=[],
+                        awaited_by=[
+                            CoroInfo(
+                                call_stack=[FrameInfo("f1", "", 0)],
+                                task_name=2
+                            )
+                        ]
+                    ),
+                    TaskInfo(
+                        task_id=2,
+                        task_name=None,
+                        coroutine_stack=[],
+                        awaited_by=[]
+                    )
+                ]
+            )
+        ]
+        # If name is None, fallback to string should not crash
+        tree = tools.build_async_tree(input_)
+        self.assertIn("(T) None", "\n".join(tree[0]))
+
+    def test_tree_rendering_with_custom_emojis(self):
+        """Pass custom emojis to the tree renderer."""
+        input_ = [
+            AwaitedInfo(
+                thread_id=1,
+                awaited_by=[
+                    TaskInfo(
+                        task_id=1,
+                        task_name="MainTask",
+                        coroutine_stack=[],
+                        awaited_by=[
+                            CoroInfo(
+                                call_stack=[
+                                    FrameInfo("f1", "", 0),
+                                    FrameInfo("f2", "", 0)
+                                ],
+                                task_name=2
+                            )
+                        ]
+                    ),
+                    TaskInfo(
+                        task_id=2,
+                        task_name="SubTask",
+                        coroutine_stack=[],
+                        awaited_by=[]
+                    )
+                ]
+            )
+        ]
+        tree = tools.build_async_tree(input_, task_emoji="🧵", cor_emoji="🔁")
+        flat = "\n".join(tree[0])
+        self.assertIn("🧵 MainTask", flat)
+        self.assertIn("🔁 f1", flat)
+        self.assertIn("🔁 f2", flat)
+        self.assertIn("🧵 SubTask", flat)
diff --git a/Lib/test/test_asyncio/test_transports.py b/Lib/test/test_asyncio/test_transports.py
index bbdb218efaa..dbb572e2e15 100644
--- a/Lib/test/test_asyncio/test_transports.py
+++ b/Lib/test/test_asyncio/test_transports.py
@@ -10,7 +10,7 @@
 def tearDownModule():
     # not needed for the test file but added for uniformness with all other
     # asyncio test files for the sake of unified cleanup
-    asyncio.set_event_loop_policy(None)
+    asyncio.events._set_event_loop_policy(None)
 
 
 class TransportTests(unittest.TestCase):
diff --git a/Lib/test/test_asyncio/test_unix_events.py b/Lib/test/test_asyncio/test_unix_events.py
index 0e5488da272..520f5c733c3 100644
--- a/Lib/test/test_asyncio/test_unix_events.py
+++ b/Lib/test/test_asyncio/test_unix_events.py
@@ -10,11 +10,9 @@
 import socket
 import stat
 import sys
-import threading
 import time
 import unittest
 from unittest import mock
-import warnings
 
 from test import support
 from test.support import os_helper
@@ -27,13 +25,12 @@
 
 
 import asyncio
-from asyncio import log
 from asyncio import unix_events
 from test.test_asyncio import utils as test_utils
 
 
 def tearDownModule():
-    asyncio.set_event_loop_policy(None)
+    asyncio.events._set_event_loop_policy(None)
 
 
 MOCK_ANY = mock.ANY
@@ -1112,697 +1109,6 @@ def test_write_eof_pending(self):
         self.assertFalse(self.protocol.connection_lost.called)
 
 
-class AbstractChildWatcherTests(unittest.TestCase):
-
-    def test_warns_on_subclassing(self):
-        with self.assertWarns(DeprecationWarning):
-            class MyWatcher(asyncio.AbstractChildWatcher):
-                pass
-
-    def test_not_implemented(self):
-        f = mock.Mock()
-        watcher = asyncio.AbstractChildWatcher()
-        self.assertRaises(
-            NotImplementedError, watcher.add_child_handler, f, f)
-        self.assertRaises(
-            NotImplementedError, watcher.remove_child_handler, f)
-        self.assertRaises(
-            NotImplementedError, watcher.attach_loop, f)
-        self.assertRaises(
-            NotImplementedError, watcher.close)
-        self.assertRaises(
-            NotImplementedError, watcher.is_active)
-        self.assertRaises(
-            NotImplementedError, watcher.__enter__)
-        self.assertRaises(
-            NotImplementedError, watcher.__exit__, f, f, f)
-
-
-class BaseChildWatcherTests(unittest.TestCase):
-
-    def test_not_implemented(self):
-        f = mock.Mock()
-        watcher = unix_events.BaseChildWatcher()
-        self.assertRaises(
-            NotImplementedError, watcher._do_waitpid, f)
-
-
-class ChildWatcherTestsMixin:
-
-    ignore_warnings = mock.patch.object(log.logger, "warning")
-
-    def setUp(self):
-        super().setUp()
-        self.loop = self.new_test_loop()
-        self.running = False
-        self.zombies = {}
-
-        with mock.patch.object(
-                self.loop, "add_signal_handler") as self.m_add_signal_handler:
-            self.watcher = self.create_watcher()
-            self.watcher.attach_loop(self.loop)
-
-    def waitpid(self, pid, flags):
-        if isinstance(self.watcher, asyncio.SafeChildWatcher) or pid != -1:
-            self.assertGreater(pid, 0)
-        try:
-            if pid < 0:
-                return self.zombies.popitem()
-            else:
-                return pid, self.zombies.pop(pid)
-        except KeyError:
-            pass
-        if self.running:
-            return 0, 0
-        else:
-            raise ChildProcessError()
-
-    def add_zombie(self, pid, status):
-        self.zombies[pid] = status
-
-    def waitstatus_to_exitcode(self, status):
-        if status > 32768:
-            return status - 32768
-        elif 32700 < status < 32768:
-            return status - 32768
-        else:
-            return status
-
-    def test_create_watcher(self):
-        self.m_add_signal_handler.assert_called_once_with(
-            signal.SIGCHLD, self.watcher._sig_chld)
-
-    def waitpid_mocks(func):
-        def wrapped_func(self):
-            def patch(target, wrapper):
-                return mock.patch(target, wraps=wrapper,
-                                  new_callable=mock.Mock)
-
-            with patch('asyncio.unix_events.waitstatus_to_exitcode', self.waitstatus_to_exitcode), \
-                 patch('os.waitpid', self.waitpid) as m_waitpid:
-                func(self, m_waitpid)
-        return wrapped_func
-
-    @waitpid_mocks
-    def test_sigchld(self, m_waitpid):
-        # register a child
-        callback = mock.Mock()
-
-        with self.watcher:
-            self.running = True
-            self.watcher.add_child_handler(42, callback, 9, 10, 14)
-
-        self.assertFalse(callback.called)
-
-        # child is running
-        self.watcher._sig_chld()
-
-        self.assertFalse(callback.called)
-
-        # child terminates (returncode 12)
-        self.running = False
-        self.add_zombie(42, EXITCODE(12))
-        self.watcher._sig_chld()
-
-        callback.assert_called_once_with(42, 12, 9, 10, 14)
-
-        callback.reset_mock()
-
-        # ensure that the child is effectively reaped
-        self.add_zombie(42, EXITCODE(13))
-        with self.ignore_warnings:
-            self.watcher._sig_chld()
-
-        self.assertFalse(callback.called)
-
-        # sigchld called again
-        self.zombies.clear()
-        self.watcher._sig_chld()
-
-        self.assertFalse(callback.called)
-
-    @waitpid_mocks
-    def test_sigchld_two_children(self, m_waitpid):
-        callback1 = mock.Mock()
-        callback2 = mock.Mock()
-
-        # register child 1
-        with self.watcher:
-            self.running = True
-            self.watcher.add_child_handler(43, callback1, 7, 8)
-
-        self.assertFalse(callback1.called)
-        self.assertFalse(callback2.called)
-
-        # register child 2
-        with self.watcher:
-            self.watcher.add_child_handler(44, callback2, 147, 18)
-
-        self.assertFalse(callback1.called)
-        self.assertFalse(callback2.called)
-
-        # children are running
-        self.watcher._sig_chld()
-
-        self.assertFalse(callback1.called)
-        self.assertFalse(callback2.called)
-
-        # child 1 terminates (signal 3)
-        self.add_zombie(43, SIGNAL(3))
-        self.watcher._sig_chld()
-
-        callback1.assert_called_once_with(43, -3, 7, 8)
-        self.assertFalse(callback2.called)
-
-        callback1.reset_mock()
-
-        # child 2 still running
-        self.watcher._sig_chld()
-
-        self.assertFalse(callback1.called)
-        self.assertFalse(callback2.called)
-
-        # child 2 terminates (code 108)
-        self.add_zombie(44, EXITCODE(108))
-        self.running = False
-        self.watcher._sig_chld()
-
-        callback2.assert_called_once_with(44, 108, 147, 18)
-        self.assertFalse(callback1.called)
-
-        callback2.reset_mock()
-
-        # ensure that the children are effectively reaped
-        self.add_zombie(43, EXITCODE(14))
-        self.add_zombie(44, EXITCODE(15))
-        with self.ignore_warnings:
-            self.watcher._sig_chld()
-
-        self.assertFalse(callback1.called)
-        self.assertFalse(callback2.called)
-
-        # sigchld called again
-        self.zombies.clear()
-        self.watcher._sig_chld()
-
-        self.assertFalse(callback1.called)
-        self.assertFalse(callback2.called)
-
-    @waitpid_mocks
-    def test_sigchld_two_children_terminating_together(self, m_waitpid):
-        callback1 = mock.Mock()
-        callback2 = mock.Mock()
-
-        # register child 1
-        with self.watcher:
-            self.running = True
-            self.watcher.add_child_handler(45, callback1, 17, 8)
-
-        self.assertFalse(callback1.called)
-        self.assertFalse(callback2.called)
-
-        # register child 2
-        with self.watcher:
-            self.watcher.add_child_handler(46, callback2, 1147, 18)
-
-        self.assertFalse(callback1.called)
-        self.assertFalse(callback2.called)
-
-        # children are running
-        self.watcher._sig_chld()
-
-        self.assertFalse(callback1.called)
-        self.assertFalse(callback2.called)
-
-        # child 1 terminates (code 78)
-        # child 2 terminates (signal 5)
-        self.add_zombie(45, EXITCODE(78))
-        self.add_zombie(46, SIGNAL(5))
-        self.running = False
-        self.watcher._sig_chld()
-
-        callback1.assert_called_once_with(45, 78, 17, 8)
-        callback2.assert_called_once_with(46, -5, 1147, 18)
-
-        callback1.reset_mock()
-        callback2.reset_mock()
-
-        # ensure that the children are effectively reaped
-        self.add_zombie(45, EXITCODE(14))
-        self.add_zombie(46, EXITCODE(15))
-        with self.ignore_warnings:
-            self.watcher._sig_chld()
-
-        self.assertFalse(callback1.called)
-        self.assertFalse(callback2.called)
-
-    @waitpid_mocks
-    def test_sigchld_race_condition(self, m_waitpid):
-        # register a child
-        callback = mock.Mock()
-
-        with self.watcher:
-            # child terminates before being registered
-            self.add_zombie(50, EXITCODE(4))
-            self.watcher._sig_chld()
-
-            self.watcher.add_child_handler(50, callback, 1, 12)
-
-        callback.assert_called_once_with(50, 4, 1, 12)
-        callback.reset_mock()
-
-        # ensure that the child is effectively reaped
-        self.add_zombie(50, SIGNAL(1))
-        with self.ignore_warnings:
-            self.watcher._sig_chld()
-
-        self.assertFalse(callback.called)
-
-    @waitpid_mocks
-    def test_sigchld_replace_handler(self, m_waitpid):
-        callback1 = mock.Mock()
-        callback2 = mock.Mock()
-
-        # register a child
-        with self.watcher:
-            self.running = True
-            self.watcher.add_child_handler(51, callback1, 19)
-
-        self.assertFalse(callback1.called)
-        self.assertFalse(callback2.called)
-
-        # register the same child again
-        with self.watcher:
-            self.watcher.add_child_handler(51, callback2, 21)
-
-        self.assertFalse(callback1.called)
-        self.assertFalse(callback2.called)
-
-        # child terminates (signal 8)
-        self.running = False
-        self.add_zombie(51, SIGNAL(8))
-        self.watcher._sig_chld()
-
-        callback2.assert_called_once_with(51, -8, 21)
-        self.assertFalse(callback1.called)
-
-        callback2.reset_mock()
-
-        # ensure that the child is effectively reaped
-        self.add_zombie(51, EXITCODE(13))
-        with self.ignore_warnings:
-            self.watcher._sig_chld()
-
-        self.assertFalse(callback1.called)
-        self.assertFalse(callback2.called)
-
-    @waitpid_mocks
-    def test_sigchld_remove_handler(self, m_waitpid):
-        callback = mock.Mock()
-
-        # register a child
-        with self.watcher:
-            self.running = True
-            self.watcher.add_child_handler(52, callback, 1984)
-
-        self.assertFalse(callback.called)
-
-        # unregister the child
-        self.watcher.remove_child_handler(52)
-
-        self.assertFalse(callback.called)
-
-        # child terminates (code 99)
-        self.running = False
-        self.add_zombie(52, EXITCODE(99))
-        with self.ignore_warnings:
-            self.watcher._sig_chld()
-
-        self.assertFalse(callback.called)
-
-    @waitpid_mocks
-    def test_sigchld_unknown_status(self, m_waitpid):
-        callback = mock.Mock()
-
-        # register a child
-        with self.watcher:
-            self.running = True
-            self.watcher.add_child_handler(53, callback, -19)
-
-        self.assertFalse(callback.called)
-
-        # terminate with unknown status
-        self.zombies[53] = 1178
-        self.running = False
-        self.watcher._sig_chld()
-
-        callback.assert_called_once_with(53, 1178, -19)
-
-        callback.reset_mock()
-
-        # ensure that the child is effectively reaped
-        self.add_zombie(53, EXITCODE(101))
-        with self.ignore_warnings:
-            self.watcher._sig_chld()
-
-        self.assertFalse(callback.called)
-
-    @waitpid_mocks
-    def test_remove_child_handler(self, m_waitpid):
-        callback1 = mock.Mock()
-        callback2 = mock.Mock()
-        callback3 = mock.Mock()
-
-        # register children
-        with self.watcher:
-            self.running = True
-            self.watcher.add_child_handler(54, callback1, 1)
-            self.watcher.add_child_handler(55, callback2, 2)
-            self.watcher.add_child_handler(56, callback3, 3)
-
-        # remove child handler 1
-        self.assertTrue(self.watcher.remove_child_handler(54))
-
-        # remove child handler 2 multiple times
-        self.assertTrue(self.watcher.remove_child_handler(55))
-        self.assertFalse(self.watcher.remove_child_handler(55))
-        self.assertFalse(self.watcher.remove_child_handler(55))
-
-        # all children terminate
-        self.add_zombie(54, EXITCODE(0))
-        self.add_zombie(55, EXITCODE(1))
-        self.add_zombie(56, EXITCODE(2))
-        self.running = False
-        with self.ignore_warnings:
-            self.watcher._sig_chld()
-
-        self.assertFalse(callback1.called)
-        self.assertFalse(callback2.called)
-        callback3.assert_called_once_with(56, 2, 3)
-
-    @waitpid_mocks
-    def test_sigchld_unhandled_exception(self, m_waitpid):
-        callback = mock.Mock()
-
-        # register a child
-        with self.watcher:
-            self.running = True
-            self.watcher.add_child_handler(57, callback)
-
-        # raise an exception
-        m_waitpid.side_effect = ValueError
-
-        with mock.patch.object(log.logger,
-                               'error') as m_error:
-
-            self.assertEqual(self.watcher._sig_chld(), None)
-            self.assertTrue(m_error.called)
-
-    @waitpid_mocks
-    def test_sigchld_child_reaped_elsewhere(self, m_waitpid):
-        # register a child
-        callback = mock.Mock()
-
-        with self.watcher:
-            self.running = True
-            self.watcher.add_child_handler(58, callback)
-
-        self.assertFalse(callback.called)
-
-        # child terminates
-        self.running = False
-        self.add_zombie(58, EXITCODE(4))
-
-        # waitpid is called elsewhere
-        os.waitpid(58, os.WNOHANG)
-
-        m_waitpid.reset_mock()
-
-        # sigchld
-        with self.ignore_warnings:
-            self.watcher._sig_chld()
-
-        if isinstance(self.watcher, asyncio.FastChildWatcher):
-            # here the FastChildWatcher enters a deadlock
-            # (there is no way to prevent it)
-            self.assertFalse(callback.called)
-        else:
-            callback.assert_called_once_with(58, 255)
-
-    @waitpid_mocks
-    def test_sigchld_unknown_pid_during_registration(self, m_waitpid):
-        # register two children
-        callback1 = mock.Mock()
-        callback2 = mock.Mock()
-
-        with self.ignore_warnings, self.watcher:
-            self.running = True
-            # child 1 terminates
-            self.add_zombie(591, EXITCODE(7))
-            # an unknown child terminates
-            self.add_zombie(593, EXITCODE(17))
-
-            self.watcher._sig_chld()
-
-            self.watcher.add_child_handler(591, callback1)
-            self.watcher.add_child_handler(592, callback2)
-
-        callback1.assert_called_once_with(591, 7)
-        self.assertFalse(callback2.called)
-
-    @waitpid_mocks
-    def test_set_loop(self, m_waitpid):
-        # register a child
-        callback = mock.Mock()
-
-        with self.watcher:
-            self.running = True
-            self.watcher.add_child_handler(60, callback)
-
-        # attach a new loop
-        old_loop = self.loop
-        self.loop = self.new_test_loop()
-        patch = mock.patch.object
-
-        with patch(old_loop, "remove_signal_handler") as m_old_remove, \
-             patch(self.loop, "add_signal_handler") as m_new_add:
-
-            self.watcher.attach_loop(self.loop)
-
-            m_old_remove.assert_called_once_with(
-                signal.SIGCHLD)
-            m_new_add.assert_called_once_with(
-                signal.SIGCHLD, self.watcher._sig_chld)
-
-        # child terminates
-        self.running = False
-        self.add_zombie(60, EXITCODE(9))
-        self.watcher._sig_chld()
-
-        callback.assert_called_once_with(60, 9)
-
-    @waitpid_mocks
-    def test_set_loop_race_condition(self, m_waitpid):
-        # register 3 children
-        callback1 = mock.Mock()
-        callback2 = mock.Mock()
-        callback3 = mock.Mock()
-
-        with self.watcher:
-            self.running = True
-            self.watcher.add_child_handler(61, callback1)
-            self.watcher.add_child_handler(62, callback2)
-            self.watcher.add_child_handler(622, callback3)
-
-        # detach the loop
-        old_loop = self.loop
-        self.loop = None
-
-        with mock.patch.object(
-                old_loop, "remove_signal_handler") as m_remove_signal_handler:
-
-            with self.assertWarnsRegex(
-                    RuntimeWarning, 'A loop is being detached'):
-                self.watcher.attach_loop(None)
-
-            m_remove_signal_handler.assert_called_once_with(
-                signal.SIGCHLD)
-
-        # child 1 & 2 terminate
-        self.add_zombie(61, EXITCODE(11))
-        self.add_zombie(62, SIGNAL(5))
-
-        # SIGCHLD was not caught
-        self.assertFalse(callback1.called)
-        self.assertFalse(callback2.called)
-        self.assertFalse(callback3.called)
-
-        # attach a new loop
-        self.loop = self.new_test_loop()
-
-        with mock.patch.object(
-                self.loop, "add_signal_handler") as m_add_signal_handler:
-
-            self.watcher.attach_loop(self.loop)
-
-            m_add_signal_handler.assert_called_once_with(
-                signal.SIGCHLD, self.watcher._sig_chld)
-            callback1.assert_called_once_with(61, 11)  # race condition!
-            callback2.assert_called_once_with(62, -5)  # race condition!
-            self.assertFalse(callback3.called)
-
-        callback1.reset_mock()
-        callback2.reset_mock()
-
-        # child 3 terminates
-        self.running = False
-        self.add_zombie(622, EXITCODE(19))
-        self.watcher._sig_chld()
-
-        self.assertFalse(callback1.called)
-        self.assertFalse(callback2.called)
-        callback3.assert_called_once_with(622, 19)
-
-    @waitpid_mocks
-    def test_close(self, m_waitpid):
-        # register two children
-        callback1 = mock.Mock()
-
-        with self.watcher:
-            self.running = True
-            # child 1 terminates
-            self.add_zombie(63, EXITCODE(9))
-            # other child terminates
-            self.add_zombie(65, EXITCODE(18))
-            self.watcher._sig_chld()
-
-            self.watcher.add_child_handler(63, callback1)
-            self.watcher.add_child_handler(64, callback1)
-
-            self.assertEqual(len(self.watcher._callbacks), 1)
-            if isinstance(self.watcher, asyncio.FastChildWatcher):
-                self.assertEqual(len(self.watcher._zombies), 1)
-
-            with mock.patch.object(
-                    self.loop,
-                    "remove_signal_handler") as m_remove_signal_handler:
-
-                self.watcher.close()
-
-                m_remove_signal_handler.assert_called_once_with(
-                    signal.SIGCHLD)
-                self.assertFalse(self.watcher._callbacks)
-                if isinstance(self.watcher, asyncio.FastChildWatcher):
-                    self.assertFalse(self.watcher._zombies)
-
-
-class SafeChildWatcherTests (ChildWatcherTestsMixin, test_utils.TestCase):
-    def create_watcher(self):
-        with warnings.catch_warnings():
-            warnings.simplefilter("ignore", DeprecationWarning)
-            return asyncio.SafeChildWatcher()
-
-
-class FastChildWatcherTests (ChildWatcherTestsMixin, test_utils.TestCase):
-    def create_watcher(self):
-        with warnings.catch_warnings():
-            warnings.simplefilter("ignore", DeprecationWarning)
-            return asyncio.FastChildWatcher()
-
-
-class PolicyTests(unittest.TestCase):
-
-    def create_policy(self):
-        return asyncio.DefaultEventLoopPolicy()
-
-    @mock.patch('asyncio.unix_events.can_use_pidfd')
-    def test_get_default_child_watcher(self, m_can_use_pidfd):
-        m_can_use_pidfd.return_value = False
-        policy = self.create_policy()
-        self.assertIsNone(policy._watcher)
-        with self.assertWarns(DeprecationWarning):
-            watcher = policy.get_child_watcher()
-        self.assertIsInstance(watcher, asyncio.ThreadedChildWatcher)
-
-        self.assertIs(policy._watcher, watcher)
-        with self.assertWarns(DeprecationWarning):
-            self.assertIs(watcher, policy.get_child_watcher())
-
-        m_can_use_pidfd.return_value = True
-        policy = self.create_policy()
-        self.assertIsNone(policy._watcher)
-        with self.assertWarns(DeprecationWarning):
-            watcher = policy.get_child_watcher()
-        self.assertIsInstance(watcher, asyncio.PidfdChildWatcher)
-
-        self.assertIs(policy._watcher, watcher)
-        with self.assertWarns(DeprecationWarning):
-            self.assertIs(watcher, policy.get_child_watcher())
-
-    def test_get_child_watcher_after_set(self):
-        policy = self.create_policy()
-        with warnings.catch_warnings():
-            warnings.simplefilter("ignore", DeprecationWarning)
-            watcher = asyncio.FastChildWatcher()
-            policy.set_child_watcher(watcher)
-
-        self.assertIs(policy._watcher, watcher)
-        with self.assertWarns(DeprecationWarning):
-            self.assertIs(watcher, policy.get_child_watcher())
-
-    def test_get_child_watcher_thread(self):
-
-        def f():
-            policy.set_event_loop(policy.new_event_loop())
-
-            self.assertIsInstance(policy.get_event_loop(),
-                                  asyncio.AbstractEventLoop)
-            with warnings.catch_warnings():
-                warnings.simplefilter("ignore", DeprecationWarning)
-                watcher = policy.get_child_watcher()
-
-            self.assertIsInstance(watcher, asyncio.SafeChildWatcher)
-            self.assertIsNone(watcher._loop)
-
-            policy.get_event_loop().close()
-
-        policy = self.create_policy()
-        with warnings.catch_warnings():
-            warnings.simplefilter("ignore", DeprecationWarning)
-            policy.set_child_watcher(asyncio.SafeChildWatcher())
-
-        th = threading.Thread(target=f)
-        th.start()
-        th.join()
-
-    def test_child_watcher_replace_mainloop_existing(self):
-        policy = self.create_policy()
-        loop = policy.new_event_loop()
-        policy.set_event_loop(loop)
-
-        # Explicitly setup SafeChildWatcher,
-        # default ThreadedChildWatcher has no _loop property
-        with warnings.catch_warnings():
-            warnings.simplefilter("ignore", DeprecationWarning)
-            watcher = asyncio.SafeChildWatcher()
-            policy.set_child_watcher(watcher)
-        watcher.attach_loop(loop)
-
-        self.assertIs(watcher._loop, loop)
-
-        new_loop = policy.new_event_loop()
-        policy.set_event_loop(new_loop)
-
-        self.assertIs(watcher._loop, new_loop)
-
-        policy.set_event_loop(None)
-
-        self.assertIs(watcher._loop, None)
-
-        loop.close()
-        new_loop.close()
-
-
 class TestFunctional(unittest.TestCase):
 
     def setUp(self):
@@ -1874,11 +1180,46 @@ async def runner():
 
 
 @support.requires_fork()
-class TestFork(unittest.IsolatedAsyncioTestCase):
+class TestFork(unittest.TestCase):
+
+    def test_fork_not_share_current_task(self):
+        loop = object()
+        task = object()
+        asyncio._set_running_loop(loop)
+        self.addCleanup(asyncio._set_running_loop, None)
+        asyncio.tasks._enter_task(loop, task)
+        self.addCleanup(asyncio.tasks._leave_task, loop, task)
+        self.assertIs(asyncio.current_task(), task)
+        r, w = os.pipe()
+        self.addCleanup(os.close, r)
+        self.addCleanup(os.close, w)
+        pid = os.fork()
+        if pid == 0:
+            # child
+            try:
+                asyncio._set_running_loop(loop)
+                current_task = asyncio.current_task()
+                if current_task is None:
+                    os.write(w, b'NO TASK')
+                else:
+                    os.write(w, b'TASK:' + str(id(current_task)).encode())
+            except BaseException as e:
+                os.write(w, b'ERROR:' + ascii(e).encode())
+            finally:
+                asyncio._set_running_loop(None)
+                os._exit(0)
+        else:
+            # parent
+            result = os.read(r, 100)
+            self.assertEqual(result, b'NO TASK')
+            wait_process(pid, exitcode=0)
 
-    async def test_fork_not_share_event_loop(self):
+    def test_fork_not_share_event_loop(self):
         # The forked process should not share the event loop with the parent
-        loop = asyncio.get_running_loop()
+        loop = object()
+        asyncio._set_running_loop(loop)
+        self.assertIs(asyncio.get_running_loop(), loop)
+        self.addCleanup(asyncio._set_running_loop, None)
         r, w = os.pipe()
         self.addCleanup(os.close, r)
         self.addCleanup(os.close, w)
@@ -1886,8 +1227,7 @@ async def test_fork_not_share_event_loop(self):
         if pid == 0:
             # child
             try:
-                with self.assertWarns(DeprecationWarning):
-                    loop = asyncio.get_event_loop_policy().get_event_loop()
+                loop = asyncio.get_event_loop()
                 os.write(w, b'LOOP:' + str(id(loop)).encode())
             except RuntimeError:
                 os.write(w, b'NO LOOP')
@@ -1898,8 +1238,7 @@ async def test_fork_not_share_event_loop(self):
         else:
             # parent
             result = os.read(r, 100)
-            self.assertEqual(result[:5], b'LOOP:', result)
-            self.assertNotEqual(int(result[5:]), id(loop))
+            self.assertEqual(result, b'NO LOOP')
             wait_process(pid, exitcode=0)
 
     @hashlib_helper.requires_hashdigest('md5')
diff --git a/Lib/test/test_asyncio/test_waitfor.py b/Lib/test/test_asyncio/test_waitfor.py
index 11a8eeeab37..dedc6bf69d7 100644
--- a/Lib/test/test_asyncio/test_waitfor.py
+++ b/Lib/test/test_asyncio/test_waitfor.py
@@ -5,7 +5,7 @@
 
 
 def tearDownModule():
-    asyncio.set_event_loop_policy(None)
+    asyncio.events._set_event_loop_policy(None)
 
 
 # The following value can be used as a very small timeout:
diff --git a/Lib/test/test_asyncio/test_windows_events.py b/Lib/test/test_asyncio/test_windows_events.py
index 0c128c599ba..0af3368627a 100644
--- a/Lib/test/test_asyncio/test_windows_events.py
+++ b/Lib/test/test_asyncio/test_windows_events.py
@@ -19,7 +19,7 @@
 
 
 def tearDownModule():
-    asyncio.set_event_loop_policy(None)
+    asyncio.events._set_event_loop_policy(None)
 
 
 class UpperProto(asyncio.Protocol):
@@ -328,17 +328,18 @@ class WinPolicyTests(WindowsEventsTestCase):
 
     def test_selector_win_policy(self):
         async def main():
-            self.assertIsInstance(
-                asyncio.get_running_loop(),
-                asyncio.SelectorEventLoop)
+            self.assertIsInstance(asyncio.get_running_loop(), asyncio.SelectorEventLoop)
 
-        old_policy = asyncio.get_event_loop_policy()
+        old_policy = asyncio.events._get_event_loop_policy()
         try:
-            asyncio.set_event_loop_policy(
-                asyncio.WindowsSelectorEventLoopPolicy())
+            with self.assertWarnsRegex(
+                DeprecationWarning,
+                "'asyncio.WindowsSelectorEventLoopPolicy' is deprecated",
+            ):
+                asyncio.events._set_event_loop_policy(asyncio.WindowsSelectorEventLoopPolicy())
             asyncio.run(main())
         finally:
-            asyncio.set_event_loop_policy(old_policy)
+            asyncio.events._set_event_loop_policy(old_policy)
 
     def test_proactor_win_policy(self):
         async def main():
@@ -346,13 +347,16 @@ async def main():
                 asyncio.get_running_loop(),
                 asyncio.ProactorEventLoop)
 
-        old_policy = asyncio.get_event_loop_policy()
+        old_policy = asyncio.events._get_event_loop_policy()
         try:
-            asyncio.set_event_loop_policy(
-                asyncio.WindowsProactorEventLoopPolicy())
+            with self.assertWarnsRegex(
+                DeprecationWarning,
+                "'asyncio.WindowsProactorEventLoopPolicy' is deprecated",
+            ):
+                asyncio.events._set_event_loop_policy(asyncio.WindowsProactorEventLoopPolicy())
             asyncio.run(main())
         finally:
-            asyncio.set_event_loop_policy(old_policy)
+            asyncio.events._set_event_loop_policy(old_policy)
 
 
 if __name__ == '__main__':
diff --git a/Lib/test/test_asyncio/test_windows_utils.py b/Lib/test/test_asyncio/test_windows_utils.py
index eafa5be3829..97f078ff911 100644
--- a/Lib/test/test_asyncio/test_windows_utils.py
+++ b/Lib/test/test_asyncio/test_windows_utils.py
@@ -16,7 +16,7 @@
 
 
 def tearDownModule():
-    asyncio.set_event_loop_policy(None)
+    asyncio.events._set_event_loop_policy(None)
 
 
 class PipeTests(unittest.TestCase):
@@ -121,8 +121,8 @@ def test_popen(self):
         self.assertGreater(len(out), 0)
         self.assertGreater(len(err), 0)
         # allow for partial reads...
-        self.assertTrue(msg.upper().rstrip().startswith(out))
-        self.assertTrue(b"stderr".startswith(err))
+        self.assertStartsWith(msg.upper().rstrip(), out)
+        self.assertStartsWith(b"stderr", err)
 
         # The context manager calls wait() and closes resources
         with p:
diff --git a/Lib/test/test_asyncio/utils.py b/Lib/test/test_asyncio/utils.py
index d9a2939be13..a480e16e81b 100644
--- a/Lib/test/test_asyncio/utils.py
+++ b/Lib/test/test_asyncio/utils.py
@@ -14,7 +14,7 @@
 import threading
 import unittest
 import weakref
-import warnings
+from ast import literal_eval
 from unittest import mock
 
 from http.server import HTTPServer
@@ -55,24 +55,8 @@ def data_file(*filename):
 ONLYKEY = data_file('certdata', 'ssl_key.pem')
 SIGNED_CERTFILE = data_file('certdata', 'keycert3.pem')
 SIGNING_CA = data_file('certdata', 'pycacert.pem')
-PEERCERT = {
-    'OCSP': ('http://testca.pythontest.net/testca/ocsp/',),
-    'caIssuers': ('http://testca.pythontest.net/testca/pycacert.cer',),
-    'crlDistributionPoints': ('http://testca.pythontest.net/testca/revocation.crl',),
-    'issuer': ((('countryName', 'XY'),),
-            (('organizationName', 'Python Software Foundation CA'),),
-            (('commonName', 'our-ca-server'),)),
-    'notAfter': 'Oct 28 14:23:16 2037 GMT',
-    'notBefore': 'Aug 29 14:23:16 2018 GMT',
-    'serialNumber': 'CB2D80995A69525C',
-    'subject': ((('countryName', 'XY'),),
-             (('localityName', 'Castle Anthrax'),),
-             (('organizationName', 'Python Software Foundation'),),
-             (('commonName', 'localhost'),)),
-    'subjectAltName': (('DNS', 'localhost'),),
-    'version': 3
-}
-
+with open(data_file('certdata', 'keycert3.pem.reference')) as file:
+    PEERCERT = literal_eval(file.read())
 
 def simple_server_sslcontext():
     server_context = ssl.SSLContext(ssl.PROTOCOL_TLS_SERVER)
@@ -551,25 +535,6 @@ def close_loop(loop):
                 loop._default_executor.shutdown(wait=True)
         loop.close()
 
-        policy = support.maybe_get_event_loop_policy()
-        if policy is not None:
-            try:
-                with warnings.catch_warnings():
-                    warnings.simplefilter('ignore', DeprecationWarning)
-                    watcher = policy.get_child_watcher()
-            except NotImplementedError:
-                # watcher is not implemented by EventLoopPolicy, e.g. Windows
-                pass
-            else:
-                if isinstance(watcher, asyncio.ThreadedChildWatcher):
-                    # Wait for subprocess to finish, but not forever
-                    for thread in list(watcher._threads.values()):
-                        thread.join(timeout=support.SHORT_TIMEOUT)
-                        if thread.is_alive():
-                            raise RuntimeError(f"thread {thread} still alive: "
-                                               "subprocess still running")
-
-
     def set_event_loop(self, loop, *, cleanup=True):
         if loop is None:
             raise AssertionError('loop is None')
@@ -636,3 +601,9 @@ def func():
     await asyncio.sleep(0)
     if exc is not None:
         raise exc
+
+
+if sys.platform == 'win32':
+    DefaultEventLoopPolicy = asyncio.windows_events._DefaultEventLoopPolicy
+else:
+    DefaultEventLoopPolicy = asyncio.unix_events._DefaultEventLoopPolicy
diff --git a/Lib/test/test_atexit.py b/Lib/test/test_atexit.py
index 913b7556be8..6f57ee06879 100644
--- a/Lib/test/test_atexit.py
+++ b/Lib/test/test_atexit.py
@@ -1,10 +1,12 @@
 import atexit
 import os
+import subprocess
 import textwrap
 import unittest
+from test.support import os_helper
 from test import support
-from test.support import script_helper
-
+from test.support import SuppressCrashReport, script_helper
+from test.support import threading_helper
 
 class GeneralTest(unittest.TestCase):
     def test_general(self):
@@ -46,6 +48,40 @@ def test_atexit_instances(self):
         self.assertEqual(res.out.decode().splitlines(), ["atexit2", "atexit1"])
         self.assertFalse(res.err)
 
+    @unittest.skip("TODO: RUSTPYTHON; Flakey on CI")
+    @threading_helper.requires_working_threading()
+    @support.requires_resource("cpu")
+    @unittest.skipUnless(support.Py_GIL_DISABLED, "only meaningful without the GIL")
+    def test_atexit_thread_safety(self):
+        # GH-126907: atexit was not thread safe on the free-threaded build
+        source = """
+        from threading import Thread
+
+        def dummy():
+            pass
+
+
+        def thready():
+            for _ in range(100):
+                atexit.register(dummy)
+                atexit._clear()
+                atexit.register(dummy)
+                atexit.unregister(dummy)
+                atexit._run_exitfuncs()
+
+
+        threads = [Thread(target=thready) for _ in range(10)]
+        for thread in threads:
+            thread.start()
+
+        for thread in threads:
+            thread.join()
+        """
+
+        # atexit._clear() has some evil side effects, and we don't
+        # want them to affect the rest of the tests.
+        script_helper.assert_python_ok("-c", textwrap.dedent(source))
+
 
 @support.cpython_only
 class SubinterpreterTest(unittest.TestCase):
@@ -100,6 +136,37 @@ def callback():
         self.assertEqual(os.read(r, len(expected)), expected)
         os.close(r)
 
+    # Python built with Py_TRACE_REFS fail with a fatal error in
+    # _PyRefchain_Trace() on memory allocation error.
+    @unittest.skipIf(support.Py_TRACE_REFS, 'cannot test Py_TRACE_REFS build')
+    def test_atexit_with_low_memory(self):
+        # gh-140080: Test that setting low memory after registering an atexit
+        # callback doesn't cause an infinite loop during finalization.
+        code = textwrap.dedent("""
+            import atexit
+            import _testcapi
+
+            def callback():
+                print("hello")
+
+            atexit.register(callback)
+            # Simulate low memory condition
+            _testcapi.set_nomemory(0)
+        """)
+
+        with os_helper.temp_dir() as temp_dir:
+            script = script_helper.make_script(temp_dir, 'test_atexit_script', code)
+            with SuppressCrashReport():
+                with script_helper.spawn_python(script,
+                                                stderr=subprocess.PIPE) as proc:
+                    proc.wait()
+                    stdout = proc.stdout.read()
+                    stderr = proc.stderr.read()
+
+        self.assertIn(proc.returncode, (0, 1))
+        self.assertNotIn(b"hello", stdout)
+        self.assertIn(b"MemoryError", stderr)
+
 
 if __name__ == "__main__":
     unittest.main()
diff --git a/Lib/test/test_baseexception.py b/Lib/test/test_baseexception.py
index 63bf538aa53..5870dc7f9da 100644
--- a/Lib/test/test_baseexception.py
+++ b/Lib/test/test_baseexception.py
@@ -10,13 +10,11 @@ class ExceptionClassTests(unittest.TestCase):
     inheritance hierarchy)"""
 
     def test_builtins_new_style(self):
-        self.assertTrue(issubclass(Exception, object))
+        self.assertIsSubclass(Exception, object)
 
     def verify_instance_interface(self, ins):
         for attr in ("args", "__str__", "__repr__"):
-            self.assertTrue(hasattr(ins, attr),
-                    "%s missing %s attribute" %
-                        (ins.__class__.__name__, attr))
+            self.assertHasAttr(ins, attr)
 
     def test_inheritance(self):
         # Make sure the inheritance hierarchy matches the documentation
@@ -65,7 +63,7 @@ def test_inheritance(self):
                 elif last_depth > depth:
                     while superclasses[-1][0] >= depth:
                         superclasses.pop()
-                self.assertTrue(issubclass(exc, superclasses[-1][1]),
+                self.assertIsSubclass(exc, superclasses[-1][1],
                 "%s is not a subclass of %s" % (exc.__name__,
                     superclasses[-1][1].__name__))
                 try:  # Some exceptions require arguments; just skip them
diff --git a/Lib/test/test_bdb.py b/Lib/test/test_bdb.py
index c41fb763a16..f15dae13eb3 100644
--- a/Lib/test/test_bdb.py
+++ b/Lib/test/test_bdb.py
@@ -590,7 +590,6 @@ def fail(self, msg=None):
 class StateTestCase(BaseTestCase):
     """Test the step, next, return, until and quit 'set_' methods."""
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON; Error in atexit._run_exitfuncs
     def test_step(self):
         self.expect_set = [
             ('line', 2, 'tfunc_main'),  ('step', ),
@@ -601,7 +600,6 @@ def test_step(self):
         with TracerRun(self) as tracer:
             tracer.runcall(tfunc_main)
 
-    @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,7 +614,6 @@ def test_step_next_on_last_statement(self):
                 with TracerRun(self) as tracer:
                     tracer.runcall(tfunc_main)
 
-    @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', ),
@@ -626,7 +623,6 @@ def test_stepinstr(self):
         with TracerRun(self) as tracer:
             tracer.runcall(tfunc_main)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON; Error in atexit._run_exitfuncs
     def test_next(self):
         self.expect_set = [
             ('line', 2, 'tfunc_main'),   ('step', ),
@@ -638,7 +634,6 @@ def test_next(self):
         with TracerRun(self) as tracer:
             tracer.runcall(tfunc_main)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON; Error in atexit._run_exitfuncs
     def test_next_over_import(self):
         code = """
             def main():
@@ -653,7 +648,6 @@ def main():
             with TracerRun(self) as tracer:
                 tracer.runcall(tfunc_import)
 
-    @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.
@@ -666,7 +660,6 @@ def test_next_on_plain_statement(self):
         with TracerRun(self) as tracer:
             tracer.runcall(tfunc_main)
 
-    @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.
@@ -680,7 +673,6 @@ def test_next_in_caller_frame(self):
         with TracerRun(self) as tracer:
             tracer.runcall(tfunc_main)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON; Error in atexit._run_exitfuncs
     def test_return(self):
         self.expect_set = [
             ('line', 2, 'tfunc_main'),    ('step', ),
@@ -693,7 +685,6 @@ def test_return(self):
         with TracerRun(self) as tracer:
             tracer.runcall(tfunc_main)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON; Error in atexit._run_exitfuncs
     def test_return_in_caller_frame(self):
         self.expect_set = [
             ('line', 2, 'tfunc_main'),   ('step', ),
@@ -705,7 +696,6 @@ def test_return_in_caller_frame(self):
         with TracerRun(self) as tracer:
             tracer.runcall(tfunc_main)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON; Error in atexit._run_exitfuncs
     def test_until(self):
         self.expect_set = [
             ('line', 2, 'tfunc_main'),  ('step', ),
@@ -717,7 +707,6 @@ def test_until(self):
         with TracerRun(self) as tracer:
             tracer.runcall(tfunc_main)
 
-    @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'),
@@ -728,7 +717,6 @@ def test_until_with_too_large_count(self):
         with TracerRun(self) as tracer:
             tracer.runcall(tfunc_main)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON; Error in atexit._run_exitfuncs
     def test_until_in_caller_frame(self):
         self.expect_set = [
             ('line', 2, 'tfunc_main'),  ('step', ),
@@ -740,7 +728,6 @@ def test_until_in_caller_frame(self):
         with TracerRun(self) as tracer:
             tracer.runcall(tfunc_main)
 
-    @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
@@ -774,7 +761,6 @@ def test_skip_with_no_name_module(self):
         bdb = Bdb(skip=['anything*'])
         self.assertIs(bdb.is_skipped_module(None), False)
 
-    @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 = [
@@ -783,7 +769,6 @@ def test_down(self):
         with TracerRun(self) as tracer:
             self.assertRaises(BdbError, tracer.runcall, tfunc_main)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON; Error in atexit._run_exitfuncs
     def test_up(self):
         self.expect_set = [
             ('line', 2, 'tfunc_main'),  ('step', ),
@@ -797,7 +782,6 @@ def test_up(self):
 class BreakpointTestCase(BaseTestCase):
     """Test the breakpoint set method."""
 
-    @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))
@@ -805,7 +789,6 @@ def test_bp_on_non_existent_module(self):
         with TracerRun(self) as tracer:
             self.assertRaises(BdbError, tracer.runcall, tfunc_import)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON; Error in atexit._run_exitfuncs
     def test_bp_after_last_statement(self):
         code = """
             def main():
@@ -819,7 +802,6 @@ def main():
             with TracerRun(self) as tracer:
                 self.assertRaises(BdbError, tracer.runcall, tfunc_import)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON; Error in atexit._run_exitfuncs
     def test_temporary_bp(self):
         code = """
             def func():
@@ -843,7 +825,6 @@ def main():
             with TracerRun(self) as tracer:
                 tracer.runcall(tfunc_import)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON; Error in atexit._run_exitfuncs
     def test_disabled_temporary_bp(self):
         code = """
             def func():
@@ -872,7 +853,6 @@ def main():
             with TracerRun(self) as tracer:
                 tracer.runcall(tfunc_import)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON; Error in atexit._run_exitfuncs
     def test_bp_condition(self):
         code = """
             def func(a):
@@ -893,7 +873,6 @@ def main():
             with TracerRun(self) as tracer:
                 tracer.runcall(tfunc_import)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON; Error in atexit._run_exitfuncs
     def test_bp_exception_on_condition_evaluation(self):
         code = """
             def func(a):
@@ -913,7 +892,6 @@ def main():
             with TracerRun(self) as tracer:
                 tracer.runcall(tfunc_import)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON; Error in atexit._run_exitfuncs
     def test_bp_ignore_count(self):
         code = """
             def func():
@@ -935,7 +913,6 @@ def main():
             with TracerRun(self) as tracer:
                 tracer.runcall(tfunc_import)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON; Error in atexit._run_exitfuncs
     def test_ignore_count_on_disabled_bp(self):
         code = """
             def func():
@@ -963,7 +940,6 @@ def main():
             with TracerRun(self) as tracer:
                 tracer.runcall(tfunc_import)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON; Error in atexit._run_exitfuncs
     def test_clear_two_bp_on_same_line(self):
         code = """
             def func():
@@ -989,7 +965,6 @@ def main():
             with TracerRun(self) as tracer:
                 tracer.runcall(tfunc_import)
 
-    @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))
@@ -1043,7 +1018,6 @@ def test_load_bps_from_previous_Bdb_instance(self):
 class RunTestCase(BaseTestCase):
     """Test run, runeval and set_trace."""
 
-    @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 = """
@@ -1056,7 +1030,6 @@ def test_run_step(self):
         with TracerRun(self) as tracer:
             tracer.run(compile(textwrap.dedent(code), '<string>', 'exec'))
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON; Error in atexit._run_exitfuncs
     def test_runeval_step(self):
         # Test bdb 'runeval'.
         code = """
@@ -1073,13 +1046,13 @@ def main():
                 ('return', 1, '<module>'), ('quit', ),
             ]
             import test_module_for_bdb
+            ns = {'test_module_for_bdb': test_module_for_bdb}
             with TracerRun(self) as tracer:
-                tracer.runeval('test_module_for_bdb.main()', globals(), locals())
+                tracer.runeval('test_module_for_bdb.main()', ns, ns)
 
 class IssuesTestCase(BaseTestCase):
     """Test fixed bdb issues."""
 
-    @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
@@ -1110,7 +1083,6 @@ def func():
             with TracerRun(self) as tracer:
                 tracer.runcall(tfunc_import)
 
-    @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
@@ -1152,7 +1124,6 @@ def main():
                     with TracerRun(self) as tracer:
                         tracer.runcall(tfunc_import)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON; Error in atexit._run_exitfuncs
     def test_next_command_in_generator_for_loop(self):
         # Issue #16596.
         code = """
@@ -1184,7 +1155,6 @@ def main():
             with TracerRun(self) as tracer:
                 tracer.runcall(tfunc_import)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON; Error in atexit._run_exitfuncs
     def test_next_command_in_generator_with_subiterator(self):
         # Issue #16596.
         code = """
@@ -1216,7 +1186,6 @@ def main():
             with TracerRun(self) as tracer:
                 tracer.runcall(tfunc_import)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON; Error in atexit._run_exitfuncs
     def test_return_command_in_generator_with_subiterator(self):
         # Issue #16596.
         code = """
@@ -1248,7 +1217,6 @@ def main():
             with TracerRun(self) as tracer:
                 tracer.runcall(tfunc_import)
 
-    @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_bigmem.py b/Lib/test/test_bigmem.py
index aaa9972bc45..8f528812e35 100644
--- a/Lib/test/test_bigmem.py
+++ b/Lib/test/test_bigmem.py
@@ -638,8 +638,6 @@ def test_encode_utf7(self, size):
         except MemoryError:
             pass # acceptable on 32-bit
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     @bigmemtest(size=_4G // 4 + 5, memuse=ascii_char_size + ucs4_char_size + 4)
     def test_encode_utf32(self, size):
         try:
diff --git a/Lib/test/test_binascii.py b/Lib/test/test_binascii.py
index cf11ffce7f1..fa027710489 100644
--- a/Lib/test/test_binascii.py
+++ b/Lib/test/test_binascii.py
@@ -38,13 +38,13 @@ def assertConversion(self, original, converted, restored, **kwargs):
 
     def test_exceptions(self):
         # Check module exceptions
-        self.assertTrue(issubclass(binascii.Error, Exception))
-        self.assertTrue(issubclass(binascii.Incomplete, Exception))
+        self.assertIsSubclass(binascii.Error, Exception)
+        self.assertIsSubclass(binascii.Incomplete, Exception)
 
     def test_functions(self):
         # Check presence of all functions
         for name in all_functions:
-            self.assertTrue(hasattr(getattr(binascii, name), '__call__'))
+            self.assertHasAttr(getattr(binascii, name), '__call__')
             self.assertRaises(TypeError, getattr(binascii, name))
 
     def test_returned_value(self):
@@ -117,7 +117,7 @@ def addnoise(line):
         # empty strings. TBD: shouldn't it raise an exception instead ?
         self.assertEqual(binascii.a2b_base64(self.type2test(fillers)), b'')
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_base64_strict_mode(self):
         # Test base64 with strict mode on
         def _assertRegexTemplate(assert_regex: str, data: bytes, non_strict_mode_expected_result: bytes):
diff --git a/Lib/test/test_binop.py b/Lib/test/test_binop.py
index 299af09c498..b224c3d4e60 100644
--- a/Lib/test/test_binop.py
+++ b/Lib/test/test_binop.py
@@ -383,7 +383,7 @@ def test_comparison_orders(self):
         self.assertEqual(op_sequence(le, B, C), ['C.__ge__', 'B.__le__'])
         self.assertEqual(op_sequence(le, C, B), ['C.__le__', 'B.__ge__'])
 
-        self.assertTrue(issubclass(V, B))
+        self.assertIsSubclass(V, B)
         self.assertEqual(op_sequence(eq, B, V), ['B.__eq__', 'V.__eq__'])
         self.assertEqual(op_sequence(le, B, V), ['B.__le__', 'V.__ge__'])
 
diff --git a/Lib/test/test_bool.py b/Lib/test/test_bool.py
index 34ecb45f161..dcdf7bdce03 100644
--- a/Lib/test/test_bool.py
+++ b/Lib/test/test_bool.py
@@ -383,6 +383,10 @@ def __len__(self):
             __bool__ = None
         self.assertRaises(TypeError, bool, B())
 
+        class C:
+            __len__ = None
+        self.assertRaises(TypeError, bool, C())
+
     def test_real_and_imag(self):
         self.assertEqual(True.real, 1)
         self.assertEqual(True.imag, 0)
diff --git a/Lib/test/test_buffer.py b/Lib/test/test_buffer.py
index 468c6ea9def..bc09329e6de 100644
--- a/Lib/test/test_buffer.py
+++ b/Lib/test/test_buffer.py
@@ -17,12 +17,14 @@
 import unittest
 from test import support
 from test.support import os_helper
+import inspect
 from itertools import permutations, product
 from random import randrange, sample, choice
 import warnings
 import sys, array, io, os
 from decimal import Decimal
 from fractions import Fraction
+from test.support import warnings_helper
 
 try:
     from _testbuffer import *
@@ -64,7 +66,7 @@
     '?':0, 'c':0, 'b':0, 'B':0,
     'h':0, 'H':0, 'i':0, 'I':0,
     'l':0, 'L':0, 'n':0, 'N':0,
-    'f':0, 'd':0, 'P':0
+    'e':0, 'f':0, 'd':0, 'P':0
 }
 
 # NumPy does not have 'n' or 'N':
@@ -89,7 +91,8 @@
     'i':(-(1<<31), 1<<31), 'I':(0, 1<<32),
     'l':(-(1<<31), 1<<31), 'L':(0, 1<<32),
     'q':(-(1<<63), 1<<63), 'Q':(0, 1<<64),
-    'f':(-(1<<63), 1<<63), 'd':(-(1<<1023), 1<<1023)
+    'e':(-65519, 65520),   'f':(-(1<<63), 1<<63),
+    'd':(-(1<<1023), 1<<1023)
 }
 
 def native_type_range(fmt):
@@ -98,6 +101,8 @@ def native_type_range(fmt):
         lh = (0, 256)
     elif fmt == '?':
         lh = (0, 2)
+    elif fmt == 'e':
+        lh = (-65519, 65520)
     elif fmt == 'f':
         lh = (-(1<<63), 1<<63)
     elif fmt == 'd':
@@ -125,7 +130,10 @@ def native_type_range(fmt):
     for fmt in fmtdict['@']:
         fmtdict['@'][fmt] = native_type_range(fmt)
 
+# Format codes supported by the memoryview object
 MEMORYVIEW = NATIVE.copy()
+
+# Format codes supported by array.array
 ARRAY = NATIVE.copy()
 for k in NATIVE:
     if not k in "bBhHiIlLfd":
@@ -160,11 +168,11 @@ def randrange_fmt(mode, char, obj):
     if char == 'c':
         x = bytes([x])
         if obj == 'numpy' and x == b'\x00':
-            # http://projects.scipy.org/numpy/ticket/1925
+            # https://github.com/numpy/numpy/issues/2518
             x = b'\x01'
     if char == '?':
         x = bool(x)
-    if char == 'f' or char == 'd':
+    if char in 'efd':
         x = struct.pack(char, x)
         x = struct.unpack(char, x)[0]
     return x
@@ -959,8 +967,10 @@ def check_memoryview(m, expected_readonly=readonly):
                     self.assertEqual(m.strides, tuple(strides))
                 self.assertEqual(m.suboffsets, tuple(suboffsets))
 
-                n = 1 if ndim == 0 else len(lst)
-                self.assertEqual(len(m), n)
+                if ndim == 0:
+                    self.assertRaises(TypeError, len, m)
+                else:
+                    self.assertEqual(len(m), len(lst))
 
                 rep = result.tolist() if fmt else result.tobytes()
                 self.assertEqual(rep, lst)
@@ -1019,6 +1029,7 @@ def match(req, flag):
                     ndim=ndim, shape=shape, strides=strides,
                     lst=lst, sliced=sliced)
 
+    @support.requires_resource('cpu')
     def test_ndarray_getbuf(self):
         requests = (
             # distinct flags
@@ -1907,7 +1918,7 @@ def test_ndarray_random(self):
                 if numpy_array:
                     shape = t[3]
                     if 0 in shape:
-                        continue # http://projects.scipy.org/numpy/ticket/1910
+                        continue # https://github.com/numpy/numpy/issues/2503
                     z = numpy_array_from_structure(items, fmt, t)
                     self.verify(x, obj=None,
                                 itemsize=z.itemsize, fmt=fmt, readonly=False,
@@ -1939,7 +1950,7 @@ def test_ndarray_random_invalid(self):
                     except Exception as e:
                         numpy_err = e.__class__
 
-                    if 0: # http://projects.scipy.org/numpy/ticket/1910
+                    if 0: # https://github.com/numpy/numpy/issues/2503
                         self.assertTrue(numpy_err)
 
     def test_ndarray_random_slice_assign(self):
@@ -1985,7 +1996,7 @@ def test_ndarray_random_slice_assign(self):
 
                 if numpy_array:
                     if 0 in lshape or 0 in rshape:
-                        continue # http://projects.scipy.org/numpy/ticket/1910
+                        continue # https://github.com/numpy/numpy/issues/2503
 
                     zl = numpy_array_from_structure(litems, fmt, tl)
                     zr = numpy_array_from_structure(ritems, fmt, tr)
@@ -2246,7 +2257,7 @@ def test_py_buffer_to_contiguous(self):
         ###
         ###    Fortran output:
         ###    ---------------
-        ###       >>> fortran_buf = nd.tostring(order='F')
+        ###       >>> fortran_buf = nd.tobytes(order='F')
         ###       >>> fortran_buf
         ###       b'\x00\x04\x08\x01\x05\t\x02\x06\n\x03\x07\x0b'
         ###
@@ -2289,7 +2300,7 @@ def test_py_buffer_to_contiguous(self):
                 self.assertEqual(memoryview(y), memoryview(nd))
 
                 if numpy_array:
-                    self.assertEqual(b, na.tostring(order='C'))
+                    self.assertEqual(b, na.tobytes(order='C'))
 
             # 'F' request
             if f == 0: # 'C' to 'F'
@@ -2312,7 +2323,7 @@ def test_py_buffer_to_contiguous(self):
                 self.assertEqual(memoryview(y), memoryview(nd))
 
                 if numpy_array:
-                    self.assertEqual(b, na.tostring(order='F'))
+                    self.assertEqual(b, na.tobytes(order='F'))
 
             # 'A' request
             if f == ND_FORTRAN:
@@ -2336,7 +2347,7 @@ def test_py_buffer_to_contiguous(self):
                 self.assertEqual(memoryview(y), memoryview(nd))
 
                 if numpy_array:
-                    self.assertEqual(b, na.tostring(order='A'))
+                    self.assertEqual(b, na.tobytes(order='A'))
 
         # multi-dimensional, non-contiguous input
         nd = ndarray(list(range(12)), shape=[3, 4], flags=ND_WRITABLE|ND_PIL)
@@ -2750,6 +2761,7 @@ def iter_roundtrip(ex, m, items, fmt):
             m = memoryview(ex)
             iter_roundtrip(ex, m, items, fmt)
 
+    @support.requires_resource('cpu')
     def test_memoryview_cast_1D_ND(self):
         # Cast between C-contiguous buffers. At least one buffer must
         # be 1D, at least one format must be 'c', 'b' or 'B'.
@@ -2867,11 +2879,11 @@ def test_memoryview_tolist(self):
     def test_memoryview_repr(self):
         m = memoryview(bytearray(9))
         r = m.__repr__()
-        self.assertTrue(r.startswith("<memory"))
+        self.assertStartsWith(r, "<memory")
 
         m.release()
         r = m.__repr__()
-        self.assertTrue(r.startswith("<released"))
+        self.assertStartsWith(r, "<released")
 
     def test_memoryview_sequence(self):
 
@@ -3208,12 +3220,6 @@ def test_memoryview_compare_special_cases(self):
         nd[0] = (-1, float('nan'))
         self.assertNotEqual(memoryview(nd), nd)
 
-        # Depends on issue #15625: the struct module does not understand 'u'.
-        a = array.array('u', 'xyz')
-        v = memoryview(a)
-        self.assertNotEqual(a, v)
-        self.assertNotEqual(v, a)
-
         # Some ctypes format strings are unknown to the struct module.
         if ctypes:
             # format: "T{>l:x:>l:y:}"
@@ -3227,6 +3233,15 @@ class BEPoint(ctypes.BigEndianStructure):
             self.assertNotEqual(point, a)
             self.assertRaises(NotImplementedError, a.tolist)
 
+    @warnings_helper.ignore_warnings(category=DeprecationWarning)  # gh-80480 array('u')
+    def test_memoryview_compare_special_cases_deprecated_u_type_code(self):
+
+        # Depends on issue #15625: the struct module does not understand 'u'.
+        a = array.array('u', 'xyz')
+        v = memoryview(a)
+        self.assertNotEqual(a, v)
+        self.assertNotEqual(v, a)
+
     def test_memoryview_compare_ndim_zero(self):
 
         nd1 = ndarray(1729, shape=[], format='@L')
@@ -3895,6 +3910,8 @@ def test_memoryview_check_released(self):
         self.assertRaises(ValueError, memoryview, m)
         # memoryview.cast()
         self.assertRaises(ValueError, m.cast, 'c')
+        # memoryview.__iter__()
+        self.assertRaises(ValueError, m.__iter__)
         # getbuffer()
         self.assertRaises(ValueError, ndarray, m)
         # memoryview.tolist()
@@ -4422,6 +4439,14 @@ def test_issue_7385(self):
         x = ndarray([1,2,3], shape=[3], flags=ND_GETBUF_FAIL)
         self.assertRaises(BufferError, memoryview, x)
 
+    def test_bytearray_release_buffer_read_flag(self):
+        # See https://github.com/python/cpython/issues/126980
+        obj = bytearray(b'abc')
+        with self.assertRaises(SystemError):
+            obj.__buffer__(inspect.BufferFlags.READ)
+        with self.assertRaises(SystemError):
+            obj.__buffer__(inspect.BufferFlags.WRITE)
+
     @support.cpython_only
     def test_pybuffer_size_from_format(self):
         # basic tests
@@ -4429,6 +4454,383 @@ def test_pybuffer_size_from_format(self):
             self.assertEqual(_testcapi.PyBuffer_SizeFromFormat(format),
                              struct.calcsize(format))
 
+    @support.cpython_only
+    def test_flags_overflow(self):
+        # gh-126594: Check for integer overlow on large flags
+        try:
+            from _testcapi import INT_MIN, INT_MAX
+        except ImportError:
+            INT_MIN = -(2 ** 31)
+            INT_MAX = 2 ** 31 - 1
+
+        obj = b'abc'
+        for flags in (INT_MIN - 1, INT_MAX + 1):
+            with self.subTest(flags=flags):
+                with self.assertRaises(OverflowError):
+                    obj.__buffer__(flags)
+
+
+class TestPythonBufferProtocol(unittest.TestCase):
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    def test_basic(self):
+        class MyBuffer:
+            def __buffer__(self, flags):
+                return memoryview(b"hello")
+
+        mv = memoryview(MyBuffer())
+        self.assertEqual(mv.tobytes(), b"hello")
+        self.assertEqual(bytes(MyBuffer()), b"hello")
+
+    def test_bad_buffer_method(self):
+        class MustReturnMV:
+            def __buffer__(self, flags):
+                return 42
+
+        self.assertRaises(TypeError, memoryview, MustReturnMV())
+
+        class NoBytesEither:
+            def __buffer__(self, flags):
+                return b"hello"
+
+        self.assertRaises(TypeError, memoryview, NoBytesEither())
+
+        class WrongArity:
+            def __buffer__(self):
+                return memoryview(b"hello")
+
+        self.assertRaises(TypeError, memoryview, WrongArity())
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    def test_release_buffer(self):
+        class WhatToRelease:
+            def __init__(self):
+                self.held = False
+                self.ba = bytearray(b"hello")
+
+            def __buffer__(self, flags):
+                if self.held:
+                    raise TypeError("already held")
+                self.held = True
+                return memoryview(self.ba)
+
+            def __release_buffer__(self, buffer):
+                self.held = False
+
+        wr = WhatToRelease()
+        self.assertFalse(wr.held)
+        with memoryview(wr) as mv:
+            self.assertTrue(wr.held)
+            self.assertEqual(mv.tobytes(), b"hello")
+        self.assertFalse(wr.held)
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    def test_same_buffer_returned(self):
+        class WhatToRelease:
+            def __init__(self):
+                self.held = False
+                self.ba = bytearray(b"hello")
+                self.created_mv = None
+
+            def __buffer__(self, flags):
+                if self.held:
+                    raise TypeError("already held")
+                self.held = True
+                self.created_mv = memoryview(self.ba)
+                return self.created_mv
+
+            def __release_buffer__(self, buffer):
+                assert buffer is self.created_mv
+                self.held = False
+
+        wr = WhatToRelease()
+        self.assertFalse(wr.held)
+        with memoryview(wr) as mv:
+            self.assertTrue(wr.held)
+            self.assertEqual(mv.tobytes(), b"hello")
+        self.assertFalse(wr.held)
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    def test_buffer_flags(self):
+        class PossiblyMutable:
+            def __init__(self, data, mutable) -> None:
+                self._data = bytearray(data)
+                self._mutable = mutable
+
+            def __buffer__(self, flags):
+                if flags & inspect.BufferFlags.WRITABLE:
+                    if not self._mutable:
+                        raise RuntimeError("not mutable")
+                    return memoryview(self._data)
+                else:
+                    return memoryview(bytes(self._data))
+
+        mutable = PossiblyMutable(b"hello", True)
+        immutable = PossiblyMutable(b"hello", False)
+        with memoryview._from_flags(mutable, inspect.BufferFlags.WRITABLE) as mv:
+            self.assertEqual(mv.tobytes(), b"hello")
+            mv[0] = ord(b'x')
+            self.assertEqual(mv.tobytes(), b"xello")
+        with memoryview._from_flags(mutable, inspect.BufferFlags.SIMPLE) as mv:
+            self.assertEqual(mv.tobytes(), b"xello")
+            with self.assertRaises(TypeError):
+                mv[0] = ord(b'h')
+            self.assertEqual(mv.tobytes(), b"xello")
+        with memoryview._from_flags(immutable, inspect.BufferFlags.SIMPLE) as mv:
+            self.assertEqual(mv.tobytes(), b"hello")
+            with self.assertRaises(TypeError):
+                mv[0] = ord(b'x')
+            self.assertEqual(mv.tobytes(), b"hello")
+
+        with self.assertRaises(RuntimeError):
+            memoryview._from_flags(immutable, inspect.BufferFlags.WRITABLE)
+        with memoryview(immutable) as mv:
+            self.assertEqual(mv.tobytes(), b"hello")
+            with self.assertRaises(TypeError):
+                mv[0] = ord(b'x')
+            self.assertEqual(mv.tobytes(), b"hello")
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    def test_call_builtins(self):
+        ba = bytearray(b"hello")
+        mv = ba.__buffer__(0)
+        self.assertEqual(mv.tobytes(), b"hello")
+        ba.__release_buffer__(mv)
+        with self.assertRaises(OverflowError):
+            ba.__buffer__(sys.maxsize + 1)
+
+    @unittest.skipIf(_testcapi is None, "requires _testcapi")
+    def test_c_buffer(self):
+        buf = _testcapi.testBuf()
+        self.assertEqual(buf.references, 0)
+        mv = buf.__buffer__(0)
+        self.assertIsInstance(mv, memoryview)
+        self.assertEqual(mv.tobytes(), b"test")
+        self.assertEqual(buf.references, 1)
+        buf.__release_buffer__(mv)
+        self.assertEqual(buf.references, 0)
+        with self.assertRaises(ValueError):
+            mv.tobytes()
+        # Calling it again doesn't cause issues
+        with self.assertRaises(ValueError):
+            buf.__release_buffer__(mv)
+        self.assertEqual(buf.references, 0)
+
+    @unittest.skipIf(_testcapi is None, "requires _testcapi")
+    def test_c_buffer_invalid_flags(self):
+        buf = _testcapi.testBuf()
+        self.assertRaises(SystemError, buf.__buffer__, PyBUF_READ)
+        self.assertRaises(SystemError, buf.__buffer__, PyBUF_WRITE)
+
+    @unittest.skipIf(_testcapi is None, "requires _testcapi")
+    def test_c_fill_buffer_invalid_flags(self):
+        # PyBuffer_FillInfo
+        source = b"abc"
+        self.assertRaises(SystemError, _testcapi.buffer_fill_info,
+                          source, 0, PyBUF_READ)
+        self.assertRaises(SystemError, _testcapi.buffer_fill_info,
+                          source, 0, PyBUF_WRITE)
+
+    @unittest.skipIf(_testcapi is None, "requires _testcapi")
+    def test_c_fill_buffer_readonly_and_writable(self):
+        source = b"abc"
+        with _testcapi.buffer_fill_info(source, 1, PyBUF_SIMPLE) as m:
+            self.assertEqual(bytes(m), b"abc")
+            self.assertTrue(m.readonly)
+        with _testcapi.buffer_fill_info(source, 0, PyBUF_WRITABLE) as m:
+            self.assertEqual(bytes(m), b"abc")
+            self.assertFalse(m.readonly)
+        self.assertRaises(BufferError, _testcapi.buffer_fill_info,
+                          source, 1, PyBUF_WRITABLE)
+
+    def test_inheritance(self):
+        class A(bytearray):
+            def __buffer__(self, flags):
+                return super().__buffer__(flags)
+
+        a = A(b"hello")
+        mv = memoryview(a)
+        self.assertEqual(mv.tobytes(), b"hello")
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    def test_inheritance_releasebuffer(self):
+        rb_call_count = 0
+        class B(bytearray):
+            def __buffer__(self, flags):
+                return super().__buffer__(flags)
+            def __release_buffer__(self, view):
+                nonlocal rb_call_count
+                rb_call_count += 1
+                super().__release_buffer__(view)
+
+        b = B(b"hello")
+        with memoryview(b) as mv:
+            self.assertEqual(mv.tobytes(), b"hello")
+            self.assertEqual(rb_call_count, 0)
+        self.assertEqual(rb_call_count, 1)
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    def test_inherit_but_return_something_else(self):
+        class A(bytearray):
+            def __buffer__(self, flags):
+                return memoryview(b"hello")
+
+        a = A(b"hello")
+        with memoryview(a) as mv:
+            self.assertEqual(mv.tobytes(), b"hello")
+
+        rb_call_count = 0
+        rb_raised = False
+        class B(bytearray):
+            def __buffer__(self, flags):
+                return memoryview(b"hello")
+            def __release_buffer__(self, view):
+                nonlocal rb_call_count
+                rb_call_count += 1
+                try:
+                    super().__release_buffer__(view)
+                except ValueError:
+                    nonlocal rb_raised
+                    rb_raised = True
+
+        b = B(b"hello")
+        with memoryview(b) as mv:
+            self.assertEqual(mv.tobytes(), b"hello")
+            self.assertEqual(rb_call_count, 0)
+        self.assertEqual(rb_call_count, 1)
+        self.assertIs(rb_raised, True)
+
+    def test_override_only_release(self):
+        class C(bytearray):
+            def __release_buffer__(self, buffer):
+                super().__release_buffer__(buffer)
+
+        c = C(b"hello")
+        with memoryview(c) as mv:
+            self.assertEqual(mv.tobytes(), b"hello")
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    def test_release_saves_reference(self):
+        smuggled_buffer = None
+
+        class C(bytearray):
+            def __release_buffer__(s, buffer: memoryview):
+                with self.assertRaises(ValueError):
+                    memoryview(buffer)
+                with self.assertRaises(ValueError):
+                    buffer.cast("b")
+                with self.assertRaises(ValueError):
+                    buffer.toreadonly()
+                with self.assertRaises(ValueError):
+                    buffer[:1]
+                with self.assertRaises(ValueError):
+                    buffer.__buffer__(0)
+                nonlocal smuggled_buffer
+                smuggled_buffer = buffer
+                self.assertEqual(buffer.tobytes(), b"hello")
+                super().__release_buffer__(buffer)
+
+        c = C(b"hello")
+        with memoryview(c) as mv:
+            self.assertEqual(mv.tobytes(), b"hello")
+        c.clear()
+        with self.assertRaises(ValueError):
+            smuggled_buffer.tobytes()
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    def test_release_saves_reference_no_subclassing(self):
+        ba = bytearray(b"hello")
+
+        class C:
+            def __buffer__(self, flags):
+                return memoryview(ba)
+
+            def __release_buffer__(self, buffer):
+                self.buffer = buffer
+
+        c = C()
+        with memoryview(c) as mv:
+            self.assertEqual(mv.tobytes(), b"hello")
+        self.assertEqual(c.buffer.tobytes(), b"hello")
+
+        with self.assertRaises(BufferError):
+            ba.clear()
+        c.buffer.release()
+        ba.clear()
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    def test_multiple_inheritance_buffer_last(self):
+        class A:
+            def __buffer__(self, flags):
+                return memoryview(b"hello A")
+
+        class B(A, bytearray):
+            def __buffer__(self, flags):
+                return super().__buffer__(flags)
+
+        b = B(b"hello")
+        with memoryview(b) as mv:
+            self.assertEqual(mv.tobytes(), b"hello A")
+
+        class Releaser:
+            def __release_buffer__(self, buffer):
+                self.buffer = buffer
+
+        class C(Releaser, bytearray):
+            def __buffer__(self, flags):
+                return super().__buffer__(flags)
+
+        c = C(b"hello C")
+        with memoryview(c) as mv:
+            self.assertEqual(mv.tobytes(), b"hello C")
+        c.clear()
+        with self.assertRaises(ValueError):
+            c.buffer.tobytes()
+
+    def test_multiple_inheritance_buffer_last_raising(self):
+        class A:
+            def __buffer__(self, flags):
+                raise RuntimeError("should not be called")
+
+            def __release_buffer__(self, buffer):
+                raise RuntimeError("should not be called")
+
+        class B(bytearray, A):
+            def __buffer__(self, flags):
+                return super().__buffer__(flags)
+
+        b = B(b"hello")
+        with memoryview(b) as mv:
+            self.assertEqual(mv.tobytes(), b"hello")
+
+        class Releaser:
+            buffer = None
+            def __release_buffer__(self, buffer):
+                self.buffer = buffer
+
+        class C(bytearray, Releaser):
+            def __buffer__(self, flags):
+                return super().__buffer__(flags)
+
+        c = C(b"hello")
+        with memoryview(c) as mv:
+            self.assertEqual(mv.tobytes(), b"hello")
+        c.clear()
+        self.assertIs(c.buffer, None)
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    def test_release_buffer_with_exception_set(self):
+        class A:
+            def __buffer__(self, flags):
+                return memoryview(bytes(8))
+            def __release_buffer__(self, view):
+                pass
+
+        b = bytearray(8)
+        with memoryview(b):
+            # now b.extend will raise an exception due to exports
+            with self.assertRaises(BufferError):
+                b.extend(A())
+
 
 if __name__ == "__main__":
     unittest.main()
diff --git a/Lib/test/test_bufio.py b/Lib/test/test_bufio.py
index 989d8cd349b..cb9cb4d0bc7 100644
--- a/Lib/test/test_bufio.py
+++ b/Lib/test/test_bufio.py
@@ -28,7 +28,7 @@ def try_one(self, s):
             f.write(b"\n")
             f.write(s)
             f.close()
-            f = open(os_helper.TESTFN, "rb")
+            f = self.open(os_helper.TESTFN, "rb")
             line = f.readline()
             self.assertEqual(line, s + b"\n")
             line = f.readline()
@@ -65,9 +65,6 @@ def test_nullpat(self):
 class CBufferSizeTest(BufferSizeTest, unittest.TestCase):
     open = io.open
 
-# TODO: RUSTPYTHON
-import sys
-@unittest.skipIf(sys.platform == "win32", "TODO: RUSTPYTHON, can't cleanup temporary file on Windows")
 class PyBufferSizeTest(BufferSizeTest, unittest.TestCase):
     open = staticmethod(pyio.open)
 
diff --git a/Lib/test/test_builtin.py b/Lib/test/test_builtin.py
index cbba54a3bf9..cf0268c2ce5 100644
--- a/Lib/test/test_builtin.py
+++ b/Lib/test/test_builtin.py
@@ -1,14 +1,15 @@
 # Python test set -- built-in functions
 
 import ast
-import asyncio
 import builtins
 import collections
+import contextlib
 import decimal
 import fractions
 import gc
 import io
 import locale
+import math
 import os
 import pickle
 import platform
@@ -17,6 +18,7 @@
 import sys
 import traceback
 import types
+import typing
 import unittest
 import warnings
 from contextlib import ExitStack
@@ -27,10 +29,14 @@
 from types import AsyncGeneratorType, FunctionType, CellType
 from operator import neg
 from test import support
-from test.support import (swap_attr, maybe_get_event_loop_policy)
+from test.support import cpython_only, swap_attr
+from test.support import async_yield, run_yielding_async_fn
+from test.support.import_helper import import_module
 from test.support.os_helper import (EnvironmentVarGuard, TESTFN, unlink)
 from test.support.script_helper import assert_python_ok
+from test.support.testcase import ComplexesAreIdenticalMixin
 from test.support.warnings_helper import check_warnings
+from test.support import requires_IEEE_754
 from unittest.mock import MagicMock, patch
 try:
     import pty, signal
@@ -38,6 +44,14 @@
     pty = signal = None
 
 
+# Detect evidence of double-rounding: sum() does not always
+# get improved accuracy on machines that suffer from double rounding.
+x, y = 1e16, 2.9999 # use temporary values to defeat peephole optimizer
+HAVE_DOUBLE_ROUNDING = (x + y == 1e16 + 4)
+
+# used as proof of globals being used
+A_GLOBAL_VALUE = 123
+
 class Squares:
 
     def __init__(self, max):
@@ -134,7 +148,10 @@ def filter_char(arg):
 def map_char(arg):
     return chr(ord(arg)+1)
 
-class BuiltinTest(unittest.TestCase):
+def pack(*args):
+    return args
+
+class BuiltinTest(ComplexesAreIdenticalMixin, unittest.TestCase):
     # Helper to check picklability
     def check_iter_pickle(self, it, seq, proto):
         itorg = it
@@ -208,6 +225,8 @@ def test_all(self):
         self.assertEqual(all(x > 42 for x in S), True)
         S = [50, 40, 60]
         self.assertEqual(all(x > 42 for x in S), False)
+        S = [50, 40, 60, TestFailingBool()]
+        self.assertEqual(all(x > 42 for x in S), False)
 
     def test_any(self):
         self.assertEqual(any([None, None, None]), False)
@@ -221,9 +240,59 @@ def test_any(self):
         self.assertEqual(any([1, TestFailingBool()]), True) # Short-circuit
         S = [40, 60, 30]
         self.assertEqual(any(x > 42 for x in S), True)
+        S = [40, 60, 30, TestFailingBool()]
+        self.assertEqual(any(x > 42 for x in S), True)
         S = [10, 20, 30]
         self.assertEqual(any(x > 42 for x in S), False)
 
+    def test_all_any_tuple_optimization(self):
+        def f_all():
+            return all(x-2 for x in [1,2,3])
+
+        def f_any():
+            return any(x-1 for x in [1,2,3])
+
+        def f_tuple():
+            return tuple(2*x for x in [1,2,3])
+
+        funcs = [f_all, f_any, f_tuple]
+
+        for f in funcs:
+            # check that generator code object is not duplicated
+            code_objs = [c for c in f.__code__.co_consts if isinstance(c, type(f.__code__))]
+            self.assertEqual(len(code_objs), 1)
+
+
+        # check the overriding the builtins works
+
+        global all, any, tuple
+        saved = all, any, tuple
+        try:
+            all = lambda x : "all"
+            any = lambda x : "any"
+            tuple = lambda x : "tuple"
+
+            overridden_outputs = [f() for f in funcs]
+        finally:
+            all, any, tuple = saved
+
+        self.assertEqual(overridden_outputs, ['all', 'any', 'tuple'])
+
+        # Now repeat, overriding the builtins module as well
+        saved = all, any, tuple
+        try:
+            builtins.all = all = lambda x : "all"
+            builtins.any = any = lambda x : "any"
+            builtins.tuple = tuple = lambda x : "tuple"
+
+            overridden_outputs = [f() for f in funcs]
+        finally:
+            all, any, tuple = saved
+            builtins.all, builtins.any, builtins.tuple = saved
+
+        self.assertEqual(overridden_outputs, ['all', 'any', 'tuple'])
+
+
     def test_ascii(self):
         self.assertEqual(ascii(''), '\'\'')
         self.assertEqual(ascii(0), '0')
@@ -299,14 +368,13 @@ class C3(C2): pass
         self.assertTrue(callable(c3))
 
     def test_chr(self):
+        self.assertEqual(chr(0), '\0')
         self.assertEqual(chr(32), ' ')
         self.assertEqual(chr(65), 'A')
         self.assertEqual(chr(97), 'a')
         self.assertEqual(chr(0xff), '\xff')
-        self.assertRaises(ValueError, chr, 1<<24)
-        self.assertEqual(chr(sys.maxunicode),
-                         str('\\U0010ffff'.encode("ascii"), 'unicode-escape'))
         self.assertRaises(TypeError, chr)
+        self.assertRaises(TypeError, chr, 65.0)
         self.assertEqual(chr(0x0000FFFF), "\U0000FFFF")
         self.assertEqual(chr(0x00010000), "\U00010000")
         self.assertEqual(chr(0x00010001), "\U00010001")
@@ -318,10 +386,14 @@ def test_chr(self):
         self.assertEqual(chr(0x0010FFFF), "\U0010FFFF")
         self.assertRaises(ValueError, chr, -1)
         self.assertRaises(ValueError, chr, 0x00110000)
-        self.assertRaises((OverflowError, ValueError), chr, 2**32)
+        self.assertRaises(ValueError, chr, 1<<24)
+        self.assertRaises(ValueError, chr, 2**32-1)
+        self.assertRaises(ValueError, chr, -2**32)
+        self.assertRaises(ValueError, chr, 2**1000)
+        self.assertRaises(ValueError, chr, -2**1000)
 
     def test_cmp(self):
-        self.assertTrue(not hasattr(builtins, "cmp"))
+        self.assertNotHasAttr(builtins, "cmp")
 
     def test_compile(self):
         compile('print(1)\n', '', 'exec')
@@ -360,19 +432,18 @@ def f(): """doc"""
                   (1, False, 'doc', False, False),
                   (2, False, None, False, False)]
         for optval, *expected in values:
+            with self.subTest(optval=optval):
             # test both direct compilation and compilation via AST
-            codeobjs = []
-            codeobjs.append(compile(codestr, "<test>", "exec", optimize=optval))
-            tree = ast.parse(codestr)
-            codeobjs.append(compile(tree, "<test>", "exec", optimize=optval))
-            for code in codeobjs:
-                ns = {}
-                exec(code, ns)
-                rv = ns['f']()
-                self.assertEqual(rv, tuple(expected))
-
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+                codeobjs = []
+                codeobjs.append(compile(codestr, "<test>", "exec", optimize=optval))
+                tree = ast.parse(codestr, optimize=optval)
+                codeobjs.append(compile(tree, "<test>", "exec", optimize=optval))
+                for code in codeobjs:
+                    ns = {}
+                    exec(code, ns)
+                    rv = ns['f']()
+                    self.assertEqual(rv, tuple(expected))
+
     def test_compile_top_level_await_no_coro(self):
         """Make sure top level non-await codes get the correct coroutine flags"""
         modes = ('single', 'exec')
@@ -394,14 +465,9 @@ def test_compile_top_level_await_no_coro(self):
                                 msg=f"source={source} mode={mode}")
 
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    @unittest.skipIf(
-        support.is_emscripten or support.is_wasi,
-        "socket.accept is broken"
-    )
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_compile_top_level_await(self):
-        """Test whether code some top level await can be compiled.
+        """Test whether code with top level await can be compiled.
 
         Make sure it compiles only with the PyCF_ALLOW_TOP_LEVEL_AWAIT flag
         set, and make sure the generated code object has the CO_COROUTINE flag
@@ -414,12 +480,25 @@ async def arange(n):
             for i in range(n):
                 yield i
 
+        class Lock:
+            async def __aenter__(self):
+                return self
+
+            async def __aexit__(self, *exc_info):
+                pass
+
+        async def sleep(delay, result=None):
+            assert delay == 0
+            await async_yield(None)
+            return result
+
         modes = ('single', 'exec')
+        optimizations = (-1, 0, 1, 2)
         code_samples = [
-            '''a = await asyncio.sleep(0, result=1)''',
+            '''a = await sleep(0, result=1)''',
             '''async for i in arange(1):
                    a = 1''',
-            '''async with asyncio.Lock() as l:
+            '''async with Lock() as l:
                    a = 1''',
             '''a = [x async for x in arange(2)][1]''',
             '''a = 1 in {x async for x in arange(2)}''',
@@ -427,45 +506,63 @@ async def arange(n):
             '''a = [x async for x in arange(2) async for x in arange(2)][1]''',
             '''a = [x async for x in (x async for x in arange(5))][1]''',
             '''a, = [1 for x in {x async for x in arange(1)}]''',
-            '''a = [await asyncio.sleep(0, x) async for x in arange(2)][1]'''
+            '''a = [await sleep(0, x) async for x in arange(2)][1]''',
+            # gh-121637: Make sure we correctly handle the case where the
+            # async code is optimized away
+            '''assert not await sleep(0); a = 1''',
+            '''assert [x async for x in arange(1)]; a = 1''',
+            '''assert {x async for x in arange(1)}; a = 1''',
+            '''assert {x: x async for x in arange(1)}; a = 1''',
+            '''
+            if (a := 1) and __debug__:
+                async with Lock() as l:
+                    pass
+            ''',
+            '''
+            if (a := 1) and __debug__:
+                async for x in arange(2):
+                    pass
+            ''',
         ]
-        policy = maybe_get_event_loop_policy()
-        try:
-            for mode, code_sample in product(modes, code_samples):
+        for mode, code_sample, optimize in product(modes, code_samples, optimizations):
+            with self.subTest(mode=mode, code_sample=code_sample, optimize=optimize):
                 source = dedent(code_sample)
                 with self.assertRaises(
                         SyntaxError, msg=f"source={source} mode={mode}"):
-                    compile(source, '?', mode)
+                    compile(source, '?', mode, optimize=optimize)
 
                 co = compile(source,
-                             '?',
-                             mode,
-                             flags=ast.PyCF_ALLOW_TOP_LEVEL_AWAIT)
+                            '?',
+                            mode,
+                            flags=ast.PyCF_ALLOW_TOP_LEVEL_AWAIT,
+                            optimize=optimize)
 
                 self.assertEqual(co.co_flags & CO_COROUTINE, CO_COROUTINE,
-                                 msg=f"source={source} mode={mode}")
+                                msg=f"source={source} mode={mode}")
 
                 # test we can create and  advance a function type
-                globals_ = {'asyncio': asyncio, 'a': 0, 'arange': arange}
-                async_f = FunctionType(co, globals_)
-                asyncio.run(async_f())
+                globals_ = {'Lock': Lock, 'a': 0, 'arange': arange, 'sleep': sleep}
+                run_yielding_async_fn(FunctionType(co, globals_))
                 self.assertEqual(globals_['a'], 1)
 
                 # test we can await-eval,
-                globals_ = {'asyncio': asyncio, 'a': 0, 'arange': arange}
-                asyncio.run(eval(co, globals_))
+                globals_ = {'Lock': Lock, 'a': 0, 'arange': arange, 'sleep': sleep}
+                run_yielding_async_fn(lambda: eval(co, globals_))
                 self.assertEqual(globals_['a'], 1)
-        finally:
-            asyncio.set_event_loop_policy(policy)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_compile_top_level_await_invalid_cases(self):
          # helper function just to check we can run top=level async-for
         async def arange(n):
             for i in range(n):
                 yield i
 
+        class Lock:
+            async def __aenter__(self):
+                return self
+
+            async def __aexit__(self, *exc_info):
+                pass
+
         modes = ('single', 'exec')
         code_samples = [
             '''def f():  await arange(10)\n''',
@@ -476,30 +573,23 @@ async def arange(n):
                        a = 1
             ''',
             '''def f():
-                   async with asyncio.Lock() as l:
+                   async with Lock() as l:
                        a = 1
             '''
         ]
-        policy = maybe_get_event_loop_policy()
-        try:
-            for mode, code_sample in product(modes, code_samples):
-                source = dedent(code_sample)
-                with self.assertRaises(
-                        SyntaxError, msg=f"source={source} mode={mode}"):
-                    compile(source, '?', mode)
-
-                with self.assertRaises(
-                        SyntaxError, msg=f"source={source} mode={mode}"):
-                    co = compile(source,
-                             '?',
-                             mode,
-                             flags=ast.PyCF_ALLOW_TOP_LEVEL_AWAIT)
-        finally:
-            asyncio.set_event_loop_policy(policy)
+        for mode, code_sample in product(modes, code_samples):
+            source = dedent(code_sample)
+            with self.assertRaises(
+                    SyntaxError, msg=f"source={source} mode={mode}"):
+                compile(source, '?', mode)
 
+            with self.assertRaises(
+                    SyntaxError, msg=f"source={source} mode={mode}"):
+                co = compile(source,
+                         '?',
+                         mode,
+                         flags=ast.PyCF_ALLOW_TOP_LEVEL_AWAIT)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_compile_async_generator(self):
         """
         With the PyCF_ALLOW_TOP_LEVEL_AWAIT flag added in 3.8, we want to
@@ -509,13 +599,35 @@ def test_compile_async_generator(self):
         code = dedent("""async def ticker():
                 for i in range(10):
                     yield i
-                    await asyncio.sleep(0)""")
+                    await sleep(0)""")
 
         co = compile(code, '?', 'exec', flags=ast.PyCF_ALLOW_TOP_LEVEL_AWAIT)
         glob = {}
         exec(co, glob)
         self.assertEqual(type(glob['ticker']()), AsyncGeneratorType)
 
+    @unittest.expectedFailure # TODO: RUSTPYTHON; AssertionError: <_ast.Name object at 0xb40000731e3d1360> is not an instance of <class '_ast.Constant'>
+    def test_compile_ast(self):
+        args = ("a*__debug__", "f.py", "exec")
+        raw = compile(*args, flags = ast.PyCF_ONLY_AST).body[0]
+        opt1 = compile(*args, flags = ast.PyCF_OPTIMIZED_AST).body[0]
+        opt2 = compile(ast.parse(args[0]), *args[1:], flags = ast.PyCF_OPTIMIZED_AST).body[0]
+
+        for tree in (raw, opt1, opt2):
+            self.assertIsInstance(tree.value, ast.BinOp)
+            self.assertIsInstance(tree.value.op, ast.Mult)
+            self.assertIsInstance(tree.value.left, ast.Name)
+            self.assertEqual(tree.value.left.id, 'a')
+
+        raw_right = raw.value.right
+        self.assertIsInstance(raw_right, ast.Name)
+        self.assertEqual(raw_right.id, "__debug__")
+
+        for opt in [opt1, opt2]:
+            opt_right = opt.value.right
+            self.assertIsInstance(opt_right, ast.Constant)
+            self.assertEqual(opt_right.value, __debug__)
+
     def test_delattr(self):
         sys.spam = 1
         delattr(sys, 'spam')
@@ -524,8 +636,7 @@ def test_delattr(self):
         msg = r"^attribute name must be string, not 'int'$"
         self.assertRaisesRegex(TypeError, msg, delattr, sys, 1)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AssertionError: '__repr__' unexpectedly found in ['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__firstlineno__', '__format__', '__ge__', '__getattribute__', '__getstate__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__slots__', '__str__', '__subclasshook__', 'bar']
     def test_dir(self):
         # dir(wrong number of arguments)
         self.assertRaises(TypeError, dir, 42, 42)
@@ -587,6 +698,14 @@ def __dir__(self):
         self.assertIsInstance(res, list)
         self.assertTrue(res == ["a", "b", "c"])
 
+        # dir(obj__dir__iterable)
+        class Foo(object):
+            def __dir__(self):
+                return {"b", "c", "a"}
+        res = dir(Foo())
+        self.assertIsInstance(res, list)
+        self.assertEqual(sorted(res), ["a", "b", "c"])
+
         # dir(obj__dir__not_sequence)
         class Foo(object):
             def __dir__(self):
@@ -625,6 +744,16 @@ def test_divmod(self):
             self.assertAlmostEqual(result[1], exp_result[1])
 
         self.assertRaises(TypeError, divmod)
+        self.assertRaisesRegex(
+            ZeroDivisionError,
+            "division by zero",
+            divmod, 1, 0,
+        )
+        self.assertRaisesRegex(
+            ZeroDivisionError,
+            "division by zero",
+            divmod, 0.0, 0,
+        )
 
     def test_eval(self):
         self.assertEqual(eval('1+1'), 2)
@@ -649,6 +778,11 @@ def __getitem__(self, key):
                 raise ValueError
         self.assertRaises(ValueError, eval, "foo", {}, X())
 
+    def test_eval_kwargs(self):
+        data = {"A_GLOBAL_VALUE": 456}
+        self.assertEqual(eval("globals()['A_GLOBAL_VALUE']", globals=data), 456)
+        self.assertEqual(eval("globals()['A_GLOBAL_VALUE']", locals=data), 123)
+
     def test_general_eval(self):
         # Tests that general mappings can be used for the locals argument
 
@@ -742,8 +876,19 @@ def test_exec(self):
             del l['__builtins__']
         self.assertEqual((g, l), ({'a': 1}, {'b': 2}))
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    def test_exec_kwargs(self):
+        g = {}
+        exec('global z\nz = 1', globals=g)
+        if '__builtins__' in g:
+            del g['__builtins__']
+        self.assertEqual(g, {'z': 1})
+
+        # if we only set locals, the global assignment will not
+        # reach this locals dictionary
+        g = {}
+        exec('global z\nz = 1', locals=g)
+        self.assertEqual(g, {})
+
     def test_exec_globals(self):
         code = compile("print('Hello World!')", "", "exec")
         # no builtin function
@@ -753,8 +898,6 @@ def test_exec_globals(self):
         self.assertRaises(TypeError,
                           exec, code, {'__builtins__': 123})
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_exec_globals_frozen(self):
         class frozendict_error(Exception):
             pass
@@ -787,8 +930,6 @@ def __setitem__(self, key, value):
         self.assertRaises(frozendict_error,
                           exec, code, namespace)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_exec_globals_error_on_get(self):
         # custom `globals` or `builtins` can raise errors on item access
         class setonlyerror(Exception):
@@ -808,8 +949,6 @@ def __getitem__(self, key):
         self.assertRaises(setonlyerror, exec, code,
                           {'__builtins__': setonlydict({'superglobal': 1})})
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_exec_globals_dict_subclass(self):
         class customdict(dict):  # this one should not do anything fancy
             pass
@@ -821,6 +960,34 @@ class customdict(dict):  # this one should not do anything fancy
         self.assertRaisesRegex(NameError, "name 'superglobal' is not defined",
                                exec, code, {'__builtins__': customdict()})
 
+    def test_eval_builtins_mapping(self):
+        code = compile("superglobal", "test", "eval")
+        # works correctly
+        ns = {'__builtins__': types.MappingProxyType({'superglobal': 1})}
+        self.assertEqual(eval(code, ns), 1)
+        # custom builtins mapping is missing key
+        ns = {'__builtins__': types.MappingProxyType({})}
+        self.assertRaisesRegex(NameError, "name 'superglobal' is not defined",
+                               eval, code, ns)
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON; wrong error message
+    def test_exec_builtins_mapping_import(self):
+        code = compile("import foo.bar", "test", "exec")
+        ns = {'__builtins__': types.MappingProxyType({})}
+        self.assertRaisesRegex(ImportError, "__import__ not found", exec, code, ns)
+        ns = {'__builtins__': types.MappingProxyType({'__import__': lambda *args: args})}
+        exec(code, ns)
+        self.assertEqual(ns['foo'], ('foo.bar', ns, ns, None, 0))
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON; AssertionError: AttributeError not raised by eval
+    def test_eval_builtins_mapping_reduce(self):
+        # list_iterator.__reduce__() calls _PyEval_GetBuiltin("iter")
+        code = compile("x.__reduce__()", "test", "eval")
+        ns = {'__builtins__': types.MappingProxyType({}), 'x': iter([1, 2])}
+        self.assertRaisesRegex(AttributeError, "iter", eval, code, ns)
+        ns = {'__builtins__': types.MappingProxyType({'iter': iter}), 'x': iter([1, 2])}
+        self.assertEqual(eval(code, ns), (iter, ([1, 2],), 0))
+
     def test_exec_redirected(self):
         savestdout = sys.stdout
         sys.stdout = None # Whatever that cannot flush()
@@ -832,8 +999,7 @@ def test_exec_redirected(self):
         finally:
             sys.stdout = savestdout
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; TypeError: Unexpected keyword argument closure
     def test_exec_closure(self):
         def function_without_closures():
             return 3 * 5
@@ -901,8 +1067,24 @@ def four_freevars():
             three_freevars.__code__,
             three_freevars.__globals__,
             closure=my_closure)
+        my_closure = tuple(my_closure)
+
+        # should fail: anything passed to closure= isn't allowed
+        # when the source is a string
+        self.assertRaises(TypeError,
+            exec,
+            "pass",
+            closure=int)
+
+        # should fail: correct closure= argument isn't allowed
+        # when the source is a string
+        self.assertRaises(TypeError,
+            exec,
+            "pass",
+            closure=my_closure)
 
         # should fail: closure tuple with one non-cell-var
+        my_closure = list(my_closure)
         my_closure[0] = int
         my_closure = tuple(my_closure)
         self.assertRaises(TypeError,
@@ -943,6 +1125,20 @@ def test_filter_pickle(self):
             f2 = filter(filter_char, "abcdeabcde")
             self.check_iter_pickle(f1, list(f2), proto)
 
+    @unittest.skip("TODO: RUSTPYTHON; Segfault")
+    @support.skip_wasi_stack_overflow()
+    @support.skip_emscripten_stack_overflow()
+    @support.requires_resource('cpu')
+    def test_filter_dealloc(self):
+        # Tests recursive deallocation of nested filter objects using the
+        # thrashcan mechanism. See gh-102356 for more details.
+        max_iters = 1000000
+        i = filter(bool, range(max_iters))
+        for _ in range(max_iters):
+            i = filter(bool, i)
+        del i
+        gc.collect()
+
     def test_getattr(self):
         self.assertTrue(getattr(sys, 'stdout') is sys.stdout)
         self.assertRaises(TypeError, getattr)
@@ -994,6 +1190,16 @@ def __hash__(self):
                 return self
         self.assertEqual(hash(Z(42)), hash(42))
 
+    def test_invalid_hash_typeerror(self):
+        # GH-140406: The returned object from __hash__() would leak if it
+        # wasn't an integer.
+        class A:
+            def __hash__(self):
+                return 1.0
+
+        with self.assertRaises(TypeError):
+            hash(A())
+
     def test_hex(self):
         self.assertEqual(hex(16), '0x10')
         self.assertEqual(hex(-16), '-0x10')
@@ -1155,6 +1361,124 @@ def test_map_pickle(self):
             m2 = map(map_char, "Is this the real life?")
             self.check_iter_pickle(m1, list(m2), proto)
 
+    # strict map tests based on strict zip tests
+
+    def test_map_pickle_strict(self):
+        a = (1, 2, 3)
+        b = (4, 5, 6)
+        t = [(1, 4), (2, 5), (3, 6)]
+        for proto in range(pickle.HIGHEST_PROTOCOL + 1):
+            m1 = map(pack, a, b, strict=True)
+            self.check_iter_pickle(m1, t, proto)
+
+    def test_map_pickle_strict_fail(self):
+        a = (1, 2, 3)
+        b = (4, 5, 6, 7)
+        t = [(1, 4), (2, 5), (3, 6)]
+        for proto in range(pickle.HIGHEST_PROTOCOL + 1):
+            m1 = map(pack, a, b, strict=True)
+            m2 = pickle.loads(pickle.dumps(m1, proto))
+            self.assertEqual(self.iter_error(m1, ValueError), t)
+            self.assertEqual(self.iter_error(m2, ValueError), t)
+
+    def test_map_strict(self):
+        self.assertEqual(tuple(map(pack, (1, 2, 3), 'abc', strict=True)),
+                         ((1, 'a'), (2, 'b'), (3, 'c')))
+        self.assertRaises(ValueError, tuple,
+                          map(pack, (1, 2, 3, 4), 'abc', strict=True))
+        self.assertRaises(ValueError, tuple,
+                          map(pack, (1, 2), 'abc', strict=True))
+        self.assertRaises(ValueError, tuple,
+                          map(pack, (1, 2), (1, 2), 'abc', strict=True))
+
+        # gh-140517: Testing refleaks with mortal objects.
+        t1 = (None, object())
+        t2 = (object(), object())
+        t3 = (object(),)
+
+        self.assertRaises(ValueError, tuple,
+                          map(pack, t1, 'a', strict=True))
+        self.assertRaises(ValueError, tuple,
+                          map(pack, t1, t2, 'a', strict=True))
+        self.assertRaises(ValueError, tuple,
+                          map(pack, t1, t2, t3, strict=True))
+        self.assertRaises(ValueError, tuple,
+                          map(pack, 'a', t1, strict=True))
+        self.assertRaises(ValueError, tuple,
+                          map(pack, 'a', t2, t3, strict=True))
+
+    def test_map_strict_iterators(self):
+        x = iter(range(5))
+        y = [0]
+        z = iter(range(5))
+        self.assertRaises(ValueError, list,
+                          (map(pack, x, y, z, strict=True)))
+        self.assertEqual(next(x), 2)
+        self.assertEqual(next(z), 1)
+
+    def test_map_strict_error_handling(self):
+
+        class Error(Exception):
+            pass
+
+        class Iter:
+            def __init__(self, size):
+                self.size = size
+            def __iter__(self):
+                return self
+            def __next__(self):
+                self.size -= 1
+                if self.size < 0:
+                    raise Error
+                return self.size
+
+        l1 = self.iter_error(map(pack, "AB", Iter(1), strict=True), Error)
+        self.assertEqual(l1, [("A", 0)])
+        l2 = self.iter_error(map(pack, "AB", Iter(2), "A", strict=True), ValueError)
+        self.assertEqual(l2, [("A", 1, "A")])
+        l3 = self.iter_error(map(pack, "AB", Iter(2), "ABC", strict=True), Error)
+        self.assertEqual(l3, [("A", 1, "A"), ("B", 0, "B")])
+        l4 = self.iter_error(map(pack, "AB", Iter(3), strict=True), ValueError)
+        self.assertEqual(l4, [("A", 2), ("B", 1)])
+        l5 = self.iter_error(map(pack, Iter(1), "AB", strict=True), Error)
+        self.assertEqual(l5, [(0, "A")])
+        l6 = self.iter_error(map(pack, Iter(2), "A", strict=True), ValueError)
+        self.assertEqual(l6, [(1, "A")])
+        l7 = self.iter_error(map(pack, Iter(2), "ABC", strict=True), Error)
+        self.assertEqual(l7, [(1, "A"), (0, "B")])
+        l8 = self.iter_error(map(pack, Iter(3), "AB", strict=True), ValueError)
+        self.assertEqual(l8, [(2, "A"), (1, "B")])
+
+    def test_map_strict_error_handling_stopiteration(self):
+
+        class Iter:
+            def __init__(self, size):
+                self.size = size
+            def __iter__(self):
+                return self
+            def __next__(self):
+                self.size -= 1
+                if self.size < 0:
+                    raise StopIteration
+                return self.size
+
+        l1 = self.iter_error(map(pack, "AB", Iter(1), strict=True), ValueError)
+        self.assertEqual(l1, [("A", 0)])
+        l2 = self.iter_error(map(pack, "AB", Iter(2), "A", strict=True), ValueError)
+        self.assertEqual(l2, [("A", 1, "A")])
+        l3 = self.iter_error(map(pack, "AB", Iter(2), "ABC", strict=True), ValueError)
+        self.assertEqual(l3, [("A", 1, "A"), ("B", 0, "B")])
+        l4 = self.iter_error(map(pack, "AB", Iter(3), strict=True), ValueError)
+        self.assertEqual(l4, [("A", 2), ("B", 1)])
+        l5 = self.iter_error(map(pack, Iter(1), "AB", strict=True), ValueError)
+        self.assertEqual(l5, [(0, "A")])
+        l6 = self.iter_error(map(pack, Iter(2), "A", strict=True), ValueError)
+        self.assertEqual(l6, [(1, "A")])
+        l7 = self.iter_error(map(pack, Iter(2), "ABC", strict=True), ValueError)
+        self.assertEqual(l7, [(1, "A"), (0, "B")])
+        l8 = self.iter_error(map(pack, Iter(3), "AB", strict=True), ValueError)
+        self.assertEqual(l8, [(2, "A"), (1, "B")])
+
     def test_max(self):
         self.assertEqual(max('123123'), '3')
         self.assertEqual(max(1, 2, 3), 3)
@@ -1172,7 +1496,11 @@ def test_max(self):
             max()
 
         self.assertRaises(TypeError, max, 42)
-        self.assertRaises(ValueError, max, ())
+        with self.assertRaisesRegex(
+            ValueError,
+            r'max\(\) iterable argument is empty'
+        ):
+            max(())
         class BadSeq:
             def __getitem__(self, index):
                 raise ValueError
@@ -1231,7 +1559,11 @@ def test_min(self):
             min()
 
         self.assertRaises(TypeError, min, 42)
-        self.assertRaises(ValueError, min, ())
+        with self.assertRaisesRegex(
+            ValueError,
+            r'min\(\) iterable argument is empty'
+        ):
+            min(())
         class BadSeq:
             def __getitem__(self, index):
                 raise ValueError
@@ -1332,18 +1664,13 @@ def test_open(self):
         self.assertRaises(ValueError, open, 'a\x00b')
         self.assertRaises(ValueError, open, b'a\x00b')
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     @unittest.skipIf(sys.flags.utf8_mode, "utf-8 mode is enabled")
     def test_open_default_encoding(self):
-        old_environ = dict(os.environ)
-        try:
+        with EnvironmentVarGuard() as env:
             # try to get a user preferred encoding different than the current
             # locale encoding to check that open() uses the current locale
             # encoding and not the user preferred encoding
-            for key in ('LC_ALL', 'LANG', 'LC_CTYPE'):
-                if key in os.environ:
-                    del os.environ[key]
+            env.unset('LC_ALL', 'LANG', 'LC_CTYPE')
 
             self.write_testfile()
             current_locale_encoding = locale.getencoding()
@@ -1352,9 +1679,6 @@ def test_open_default_encoding(self):
                 fp = open(TESTFN, 'w')
             with fp:
                 self.assertEqual(fp.encoding, current_locale_encoding)
-        finally:
-            os.environ.clear()
-            os.environ.update(old_environ)
 
     @support.requires_subprocess()
     def test_open_non_inheritable(self):
@@ -1486,6 +1810,29 @@ def test_input(self):
             sys.stdout = savestdout
             fp.close()
 
+    def test_input_gh130163(self):
+        class X(io.StringIO):
+            def __getattribute__(self, name):
+                nonlocal patch
+                if patch:
+                    patch = False
+                    sys.stdout = X()
+                    sys.stderr = X()
+                    sys.stdin = X('input\n')
+                    support.gc_collect()
+                return io.StringIO.__getattribute__(self, name)
+
+        with (support.swap_attr(sys, 'stdout', None),
+              support.swap_attr(sys, 'stderr', None),
+              support.swap_attr(sys, 'stdin', None)):
+            patch = False
+            # the only references:
+            sys.stdout = X()
+            sys.stderr = X()
+            sys.stdin = X('input\n')
+            patch = True
+            input()  # should not crash
+
     # test_int(): see test_int.py for tests of built-in function int().
 
     def test_repr(self):
@@ -1501,6 +1848,11 @@ def test_repr(self):
         a[0] = a
         self.assertEqual(repr(a), '{0: {...}}')
 
+    def test_repr_blocked(self):
+        class C:
+            __repr__ = None
+        self.assertRaises(TypeError, repr, C())
+
     def test_round(self):
         self.assertEqual(round(0.0), 0.0)
         self.assertEqual(type(round(0.0)), int)
@@ -1607,14 +1959,17 @@ def test_bug_27936(self):
 
     def test_setattr(self):
         setattr(sys, 'spam', 1)
-        self.assertEqual(sys.spam, 1)
+        try:
+            self.assertEqual(sys.spam, 1)
+        finally:
+            del sys.spam
         self.assertRaises(TypeError, setattr)
         self.assertRaises(TypeError, setattr, sys)
         self.assertRaises(TypeError, setattr, sys, 'spam')
         msg = r"^attribute name must be string, not 'int'$"
         self.assertRaisesRegex(TypeError, msg, setattr, sys, 1, 'spam')
 
-    # test_str(): see test_unicode.py and test_bytes.py for str() tests.
+    # test_str(): see test_str.py and test_bytes.py for str() tests.
 
     def test_sum(self):
         self.assertEqual(sum([]), 0)
@@ -1644,6 +1999,8 @@ def test_sum(self):
         self.assertEqual(repr(sum([-0.0])), '0.0')
         self.assertEqual(repr(sum([-0.0], -0.0)), '-0.0')
         self.assertEqual(repr(sum([], -0.0)), '-0.0')
+        self.assertTrue(math.isinf(sum([float("inf"), float("inf")])))
+        self.assertTrue(math.isinf(sum([1e308, 1e308])))
 
         self.assertRaises(TypeError, sum)
         self.assertRaises(TypeError, sum, 42)
@@ -1658,6 +2015,8 @@ def test_sum(self):
         self.assertRaises(TypeError, sum, [], '')
         self.assertRaises(TypeError, sum, [], b'')
         self.assertRaises(TypeError, sum, [], bytearray())
+        self.assertRaises(OverflowError, sum, [1.0, 10**1000])
+        self.assertRaises(OverflowError, sum, [1j, 10**1000])
 
         class BadSeq:
             def __getitem__(self, index):
@@ -1668,6 +2027,37 @@ def __getitem__(self, index):
         sum(([x] for x in range(10)), empty)
         self.assertEqual(empty, [])
 
+        xs = [complex(random.random() - .5, random.random() - .5)
+              for _ in range(10000)]
+        self.assertEqual(sum(xs), complex(sum(z.real for z in xs),
+                                          sum(z.imag for z in xs)))
+
+        # test that sum() of complex and real numbers doesn't
+        # smash sign of imaginary 0
+        self.assertComplexesAreIdentical(sum([complex(1, -0.0), 1]),
+                                         complex(2, -0.0))
+        self.assertComplexesAreIdentical(sum([1, complex(1, -0.0)]),
+                                         complex(2, -0.0))
+        self.assertComplexesAreIdentical(sum([complex(1, -0.0), 1.0]),
+                                         complex(2, -0.0))
+        self.assertComplexesAreIdentical(sum([1.0, complex(1, -0.0)]),
+                                         complex(2, -0.0))
+
+    @requires_IEEE_754
+    @unittest.skipIf(HAVE_DOUBLE_ROUNDING,
+                         "sum accuracy not guaranteed on machines with double rounding")
+    @support.cpython_only    # Other implementations may choose a different algorithm
+    def test_sum_accuracy(self):
+        self.assertEqual(sum([0.1] * 10), 1.0)
+        self.assertEqual(sum([1.0, 10E100, 1.0, -10E100]), 2.0)
+        self.assertEqual(sum([1.0, 10E100, 1.0, -10E100, 2j]), 2+2j)
+        self.assertEqual(sum([2+1j, 10E100j, 1j, -10E100j]), 2+2j)
+        self.assertEqual(sum([1j, 1, 10E100j, 1j, 1.0, -10E100j]), 2+2j)
+        self.assertEqual(sum([2j, 1., 10E100, 1., -10E100]), 2+2j)
+        self.assertEqual(sum([1.0, 10**100, 1.0, -10**100]), 2.0)
+        self.assertEqual(sum([2j, 1.0, 10**100, 1.0, -10**100]), 2+2j)
+        self.assertEqual(sum([0.1j]*10 + [fractions.Fraction(1, 10)]), 0.1+1j)
+
     def test_type(self):
         self.assertEqual(type(''),  type('123'))
         self.assertNotEqual(type(''), type(()))
@@ -1947,7 +2337,7 @@ def __format__(self, format_spec):
         # tests for object.__format__ really belong elsewhere, but
         #  there's no good place to put them
         x = object().__format__('')
-        self.assertTrue(x.startswith('<object object at'))
+        self.assertStartsWith(x, '<object object at')
 
         # first argument to object.__format__ must be string
         self.assertRaises(TypeError, object().__format__, 3)
@@ -2003,6 +2393,24 @@ def test_bytearray_extend_error(self):
         bad_iter = map(int, "X")
         self.assertRaises(ValueError, array.extend, bad_iter)
 
+    @unittest.skip("TODO: RUSTPYTHON; Hangs")
+    def test_bytearray_join_with_misbehaving_iterator(self):
+        # Issue #112625
+        array = bytearray(b',')
+        def iterator():
+            array.clear()
+            yield b'A'
+            yield b'B'
+        self.assertRaises(BufferError, array.join, iterator())
+
+    def test_bytearray_join_with_custom_iterator(self):
+        # Issue #112625
+        array = bytearray(b',')
+        def iterator():
+            yield b'A'
+            yield b'B'
+        self.assertEqual(bytearray(b'A,B'), array.join(iterator()))
+
     def test_construct_singletons(self):
         for const in None, Ellipsis, NotImplemented:
             tp = type(const)
@@ -2023,6 +2431,24 @@ def test_bool_notimplemented(self):
         with self.assertRaisesRegex(TypeError, msg):
             not NotImplemented
 
+    def test_singleton_attribute_access(self):
+        for singleton in (NotImplemented, Ellipsis):
+            with self.subTest(singleton):
+                self.assertIs(type(singleton), singleton.__class__)
+                self.assertIs(type(singleton).__class__, type)
+
+                # Missing instance attributes:
+                with self.assertRaises(AttributeError):
+                    singleton.prop = 1
+                with self.assertRaises(AttributeError):
+                    singleton.prop
+
+                # Missing class attributes:
+                with self.assertRaises(TypeError):
+                    type(singleton).prop = 1
+                with self.assertRaises(AttributeError):
+                    type(singleton).prop
+
 
 class TestBreakpoint(unittest.TestCase):
     def setUp(self):
@@ -2128,6 +2554,11 @@ def test_envar_ignored_when_hook_is_set(self):
             breakpoint()
             mock.assert_not_called()
 
+    def test_runtime_error_when_hook_is_lost(self):
+        del sys.breakpointhook
+        with self.assertRaises(RuntimeError):
+            breakpoint()
+
 
 @unittest.skipUnless(pty, "the pty and signal modules must be available")
 class PtyTests(unittest.TestCase):
@@ -2161,8 +2592,6 @@ def _run_child(self, child, terminal_input):
         if pid == 0:
             # Child
             try:
-                # Make sure we don't get stuck if there's a problem
-                signal.alarm(2)
                 os.close(r)
                 with open(w, "w") as wpipe:
                     child(wpipe)
@@ -2212,7 +2641,10 @@ def _run_child(self, child, terminal_input):
 
         return lines
 
-    def check_input_tty(self, prompt, terminal_input, stdio_encoding=None):
+    def check_input_tty(self, prompt, terminal_input, stdio_encoding=None, *,
+                        expected=None,
+                        stdin_errors='surrogateescape',
+                        stdout_errors='replace'):
         if not sys.stdin.isatty() or not sys.stdout.isatty():
             self.skipTest("stdin and stdout must be ttys")
         def child(wpipe):
@@ -2220,56 +2652,83 @@ def child(wpipe):
             if stdio_encoding:
                 sys.stdin = io.TextIOWrapper(sys.stdin.detach(),
                                              encoding=stdio_encoding,
-                                             errors='surrogateescape')
+                                             errors=stdin_errors)
                 sys.stdout = io.TextIOWrapper(sys.stdout.detach(),
                                               encoding=stdio_encoding,
-                                              errors='replace')
+                                              errors=stdout_errors)
             print("tty =", sys.stdin.isatty() and sys.stdout.isatty(), file=wpipe)
-            print(ascii(input(prompt)), file=wpipe)
-        lines = self.run_child(child, terminal_input + b"\r\n")
+            try:
+                print(ascii(input(prompt)), file=wpipe)
+            except BaseException as e:
+                print(ascii(f'{e.__class__.__name__}: {e!s}'), file=wpipe)
+        with self.detach_readline():
+            lines = self.run_child(child, terminal_input + b"\r\n")
         # Check we did exercise the GNU readline path
         self.assertIn(lines[0], {'tty = True', 'tty = False'})
         if lines[0] != 'tty = True':
             self.skipTest("standard IO in should have been a tty")
         input_result = eval(lines[1])   # ascii() -> eval() roundtrip
-        if stdio_encoding:
-            expected = terminal_input.decode(stdio_encoding, 'surrogateescape')
-        else:
-            expected = terminal_input.decode(sys.stdin.encoding)  # what else?
+        if expected is None:
+            if stdio_encoding:
+                expected = terminal_input.decode(stdio_encoding, 'surrogateescape')
+            else:
+                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).
-        self.check_input_tty("prompt", b"quux")
-
-    def skip_if_readline(self):
+    @contextlib.contextmanager
+    def detach_readline(self):
         # bpo-13886: When the readline module is loaded, PyOS_Readline() uses
         # the readline implementation. In some cases, the Python readline
         # callback rlhandler() is called by readline with a string without
-        # non-ASCII characters. Skip tests on non-ASCII characters if the
-        # readline module is loaded, since test_builtin is not intented to test
+        # non-ASCII characters.
+        # Unlink readline temporarily from PyOS_Readline() for those tests,
+        # since test_builtin is not intended to test
         # the readline module, but the builtins module.
-        if 'readline' in sys.modules:
-            self.skipTest("the readline module is loaded")
+        if "readline" in sys.modules:
+            c = import_module("ctypes")
+            fp_api = "PyOS_ReadlineFunctionPointer"
+            prev_value = c.c_void_p.in_dll(c.pythonapi, fp_api).value
+            c.c_void_p.in_dll(c.pythonapi, fp_api).value = None
+            try:
+                yield
+            finally:
+                c.c_void_p.in_dll(c.pythonapi, fp_api).value = prev_value
+        else:
+            yield
+
+    def test_input_tty(self):
+        # Test input() functionality when wired to a tty
+        self.check_input_tty("prompt", b"quux")
 
-    @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
+    @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")
+        self.check_input_tty("prompté", b"quux\xc3\xa9", "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
+    @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.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_tty_null_in_prompt(self):
+        self.check_input_tty("prompt\0", b"",
+                expected='ValueError: input: prompt string cannot contain '
+                         'null characters')
+
+    def test_input_tty_nonencodable_prompt(self):
+        self.check_input_tty("prompté", b"quux", "ascii", stdout_errors='strict',
+                expected="UnicodeEncodeError: 'ascii' codec can't encode "
+                         "character '\\xe9' in position 6: ordinal not in "
+                         "range(128)")
+
+    def test_input_tty_nondecodable_input(self):
+        self.check_input_tty("prompt", b"quux\xe9", "ascii", stdin_errors='strict',
+                expected="UnicodeDecodeError: 'ascii' codec can't decode "
+                         "byte 0xe9 in position 4: ordinal not in "
+                         "range(128)")
+
+    @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()
         # fails, do not use the original stdout file descriptor
@@ -2330,8 +2789,6 @@ def test_baddecorator(self):
 
 class ShutdownTest(unittest.TestCase):
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_cleanup(self):
         # Issue #19255: builtins are still available at shutdown
         code = """if 1:
@@ -2364,6 +2821,35 @@ def __del__(self):
         self.assertEqual(["before", "after"], out.decode().splitlines())
 
 
+@cpython_only
+class ImmortalTests(unittest.TestCase):
+
+    if sys.maxsize < (1 << 32):
+        IMMORTAL_REFCOUNT_MINIMUM = 1 << 30
+    else:
+        IMMORTAL_REFCOUNT_MINIMUM = 1 << 31
+
+    IMMORTALS = (None, True, False, Ellipsis, NotImplemented, *range(-5, 257))
+
+    def assert_immortal(self, immortal):
+        with self.subTest(immortal):
+            self.assertGreater(sys.getrefcount(immortal), self.IMMORTAL_REFCOUNT_MINIMUM)
+
+    def test_immortals(self):
+        for immortal in self.IMMORTALS:
+            self.assert_immortal(immortal)
+
+    def test_list_repeat_respect_immortality(self):
+        refs = list(self.IMMORTALS) * 42
+        for immortal in self.IMMORTALS:
+            self.assert_immortal(immortal)
+
+    def test_tuple_repeat_respect_immortality(self):
+        refs = tuple(self.IMMORTALS) * 42
+        for immortal in self.IMMORTALS:
+            self.assert_immortal(immortal)
+
+
 class TestType(unittest.TestCase):
     def test_new_type(self):
         A = type('A', (), {})
@@ -2372,6 +2858,7 @@ def test_new_type(self):
         self.assertEqual(A.__module__, __name__)
         self.assertEqual(A.__bases__, (object,))
         self.assertIs(A.__base__, object)
+        self.assertNotIn('__firstlineno__', A.__dict__)
         x = A()
         self.assertIs(type(x), A)
         self.assertIs(x.__class__, A)
@@ -2450,6 +2937,29 @@ def test_type_qualname(self):
             A.__qualname__ = b'B'
         self.assertEqual(A.__qualname__, 'D.E')
 
+    def test_type_firstlineno(self):
+        A = type('A', (), {'__firstlineno__': 42})
+        self.assertEqual(A.__name__, 'A')
+        self.assertEqual(A.__module__, __name__)
+        self.assertEqual(A.__dict__['__firstlineno__'], 42)
+        A.__module__ = 'testmodule'
+        self.assertEqual(A.__module__, 'testmodule')
+        self.assertNotIn('__firstlineno__', A.__dict__)
+        A.__firstlineno__ = 43
+        self.assertEqual(A.__dict__['__firstlineno__'], 43)
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; TypeError: Expected type 'tuple' but 'str' found.
+    def test_type_typeparams(self):
+        class A[T]:
+            pass
+        T, = A.__type_params__
+        self.assertIsInstance(T, typing.TypeVar)
+        A.__type_params__ = "whatever"
+        self.assertEqual(A.__type_params__, "whatever")
+        with self.assertRaises(TypeError):
+            del A.__type_params__
+        self.assertEqual(A.__type_params__, "whatever")
+
     def test_type_doc(self):
         for doc in 'x', '\xc4', '\U0001f40d', 'x\x00y', b'x', 42, None:
             A = type('A', (), {'__doc__': doc})
@@ -2521,7 +3031,8 @@ def test_namespace_order(self):
 
 def load_tests(loader, tests, pattern):
     from doctest import DocTestSuite
-    tests.addTest(DocTestSuite(builtins))
+    if sys.float_repr_style == 'short':
+        tests.addTest(DocTestSuite(builtins))
     return tests
 
 if __name__ == "__main__":
diff --git a/Lib/test/test_bz2.py b/Lib/test/test_bz2.py
index 26b5e79d337..148d8f98c79 100644
--- a/Lib/test/test_bz2.py
+++ b/Lib/test/test_bz2.py
@@ -730,7 +730,7 @@ def testOpenBytesFilename(self):
             self.assertEqual(f.read(), self.DATA)
             self.assertEqual(f.name, str_filename)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AssertionError: <FakePath 'Z:\\TEMP\\tmphoipjcen'> != 'Z:\\TEMP\\tmphoipjcen'
     def testOpenPathLikeFilename(self):
         filename = FakePath(self.filename)
         with BZ2File(filename, "wb") as f:
@@ -1189,7 +1189,6 @@ def test_encoding_error_handler(self):
                 as f:
             self.assertEqual(f.read(), "foobar")
 
-    @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_c_locale_coercion.py b/Lib/test/test_c_locale_coercion.py
index 818dc16b834..71f934756e2 100644
--- a/Lib/test/test_c_locale_coercion.py
+++ b/Lib/test/test_c_locale_coercion.py
@@ -243,8 +243,6 @@ def setUpClass(cls):
         if not AVAILABLE_TARGETS:
             raise unittest.SkipTest("No C-with-UTF-8 locale available")
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_external_target_locale_configuration(self):
 
         # Explicitly setting a target locale should give the same behaviour as
diff --git a/Lib/test/test_class.py b/Lib/test/test_class.py
index a70a8078977..7420f289b16 100644
--- a/Lib/test/test_class.py
+++ b/Lib/test/test_class.py
@@ -1,6 +1,7 @@
 "Test the functionality of Python classes implementing operators."
 
 import unittest
+from test import support
 from test.support import cpython_only, import_helper, script_helper
 
 testmeths = [
@@ -134,6 +135,7 @@ def __%s__(self, *args):
 AllTests = type("AllTests", (object,), d)
 del d, statictests, method, method_template
 
+@support.thread_unsafe("callLst is shared between threads")
 class ClassTests(unittest.TestCase):
     def setUp(self):
         callLst[:] = []
@@ -554,7 +556,9 @@ class Custom:
         self.assertFalse(hasattr(o, "__call__"))
         self.assertFalse(hasattr(c, "__call__"))
 
-    @unittest.skip("TODO: RUSTPYTHON, segmentation fault")
+    @unittest.skip("TODO: RUSTPYTHON; segmentation fault")
+    @support.skip_emscripten_stack_overflow()
+    @support.skip_wasi_stack_overflow()
     def testSFBug532646(self):
         # Test for SF bug 532646
 
@@ -570,8 +574,7 @@ class A:
         else:
             self.fail("Failed to raise RecursionError")
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def testForExceptionsRaisedInInstanceGetattr2(self):
         # Tests for exceptions raised in instance_getattr2().
 
@@ -688,8 +691,7 @@ class A:
         with self.assertRaisesRegex(AttributeError, error_msg):
             del A.x
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def testObjectAttributeAccessErrorMessages(self):
         class A:
             pass
@@ -739,8 +741,6 @@ def __setattr__(self, name, value) -> None:
         with self.assertRaisesRegex(AttributeError, error_msg):
             del B().z
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def testConstructorErrorMessages(self):
         # bpo-31506: Improves the error message logic for object_new & object_init
 
@@ -845,12 +845,28 @@ def __init__(self, obj):
             Type(i)
         self.assertEqual(calls, 100)
 
-try:
-    from _testinternalcapi import has_inline_values
-except ImportError:
-    has_inline_values = None
+    def test_specialization_class_call_doesnt_crash(self):
+        # gh-123185
+
+        class Foo:
+            def __init__(self, arg):
+                pass
+
+        for _ in range(8):
+            try:
+                Foo()
+            except:
+                pass
+
+
+# from _testinternalcapi import has_inline_values # XXX: RUSTPYTHON
+
+Py_TPFLAGS_INLINE_VALUES = (1 << 2)
+Py_TPFLAGS_MANAGED_DICT = (1 << 4)
+
+class NoManagedDict:
+    __slots__ = ('a',)
 
-Py_TPFLAGS_MANAGED_DICT = (1 << 2)
 
 class Plain:
     pass
@@ -865,38 +881,55 @@ def __init__(self):
         self.d = 4
 
 
+class VarSizedSubclass(tuple):
+    pass
+
+
 class TestInlineValues(unittest.TestCase):
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    def test_flags(self):
-        self.assertEqual(Plain.__flags__ & Py_TPFLAGS_MANAGED_DICT, Py_TPFLAGS_MANAGED_DICT)
-        self.assertEqual(WithAttrs.__flags__ & Py_TPFLAGS_MANAGED_DICT, Py_TPFLAGS_MANAGED_DICT)
+    @unittest.expectedFailure # TODO: RUSTPYTHON; NameError: name 'has_inline_values' is not defined.
+    def test_no_flags_for_slots_class(self):
+        flags = NoManagedDict.__flags__
+        self.assertEqual(flags & Py_TPFLAGS_MANAGED_DICT, 0)
+        self.assertEqual(flags & Py_TPFLAGS_INLINE_VALUES, 0)
+        self.assertFalse(has_inline_values(NoManagedDict()))
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON; AssertionError: 0 != 4
+    def test_both_flags_for_regular_class(self):
+        for cls in (Plain, WithAttrs):
+            with self.subTest(cls=cls.__name__):
+                flags = cls.__flags__
+                self.assertEqual(flags & Py_TPFLAGS_MANAGED_DICT, Py_TPFLAGS_MANAGED_DICT)
+                self.assertEqual(flags & Py_TPFLAGS_INLINE_VALUES, Py_TPFLAGS_INLINE_VALUES)
+                self.assertTrue(has_inline_values(cls()))
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON; AssertionError: 0 != 4
+    def test_managed_dict_only_for_varsized_subclass(self):
+        flags = VarSizedSubclass.__flags__
+        self.assertEqual(flags & Py_TPFLAGS_MANAGED_DICT, Py_TPFLAGS_MANAGED_DICT)
+        self.assertEqual(flags & Py_TPFLAGS_INLINE_VALUES, 0)
+        self.assertFalse(has_inline_values(VarSizedSubclass()))
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_has_inline_values(self):
         c = Plain()
         self.assertTrue(has_inline_values(c))
         del c.__dict__
         self.assertFalse(has_inline_values(c))
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_instances(self):
         self.assertTrue(has_inline_values(Plain()))
         self.assertTrue(has_inline_values(WithAttrs()))
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_inspect_dict(self):
         for cls in (Plain, WithAttrs):
             c = cls()
             c.__dict__
             self.assertTrue(has_inline_values(c))
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_update_dict(self):
         d = { "e": 5, "f": 6 }
         for cls in (Plain, WithAttrs):
@@ -913,8 +946,7 @@ def check_100(self, obj):
         for i in range(100):
             self.assertEqual(getattr(obj, f"a{i}"), i)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_many_attributes(self):
         class C: pass
         c = C()
@@ -925,8 +957,7 @@ class C: pass
         c = C()
         self.assertTrue(has_inline_values(c))
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_many_attributes_with_dict(self):
         class C: pass
         c = C()
@@ -947,8 +978,7 @@ def __init__(self):
         obj.foo = None # Aborted here
         self.assertEqual(obj.__dict__, {"foo":None})
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_store_attr_deleted_dict(self):
         class Foo:
             pass
@@ -958,8 +988,7 @@ class Foo:
         f.a = 3
         self.assertEqual(f.a, 3)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_rematerialize_object_dict(self):
         # gh-121860: rematerializing an object's managed dictionary after it
         # had been deleted caused a crash.
@@ -978,7 +1007,7 @@ class Bar: pass
         self.assertIsInstance(f, Bar)
         self.assertEqual(f.__dict__, {})
 
-    @unittest.skip("TODO: RUSTPYTHON, unexpectedly long runtime")
+    @unittest.skip("TODO: RUSTPYTHON; unexpectedly long runtime")
     def test_store_attr_type_cache(self):
         """Verifies that the type cache doesn't provide a value which  is
         inconsistent from the dict."""
@@ -1029,5 +1058,6 @@ def __init__(self):
         self.assertFalse(out, msg=out.decode('utf-8'))
         self.assertFalse(err, msg=err.decode('utf-8'))
 
+
 if __name__ == '__main__':
     unittest.main()
diff --git a/Lib/test/test_cmd_line.py b/Lib/test/test_cmd_line.py
index eb455ebaed7..8aa6dad2735 100644
--- a/Lib/test/test_cmd_line.py
+++ b/Lib/test/test_cmd_line.py
@@ -475,8 +475,6 @@ def test_unmached_quote(self):
         self.assertRegex(err.decode('ascii', 'ignore'), 'SyntaxError')
         self.assertEqual(b'', out)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_stdout_flush_at_shutdown(self):
         # Issue #5319: if stdout.flush() fails at shutdown, an error should
         # be printed out.
diff --git a/Lib/test/test_cmd_line_script.py b/Lib/test/test_cmd_line_script.py
index d2b3a7d3e40..f977b97bcd3 100644
--- a/Lib/test/test_cmd_line_script.py
+++ b/Lib/test/test_cmd_line_script.py
@@ -548,8 +548,6 @@ def test_dash_m_main_traceback(self):
             self.assertIn(b'Exception in __main__ module', err)
             self.assertIn(b'Traceback', err)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_pep_409_verbiage(self):
         # Make sure PEP 409 syntax properly suppresses
         # the context of an exception
@@ -620,7 +618,6 @@ def test_syntaxerror_unindented_caret_position(self):
             # Confirm that the caret is located under the '=' sign
             self.assertIn("\n    ^^^^^\n", text)
 
-    @unittest.expectedFailureIfWindows("TODO: RUSTPYTHON")
     def test_syntaxerror_indented_caret_position(self):
         script = textwrap.dedent("""\
             if True:
diff --git a/Lib/test/test_code.py b/Lib/test/test_code.py
index f2ef233a59a..b4b15e29f26 100644
--- a/Lib/test/test_code.py
+++ b/Lib/test/test_code.py
@@ -6,8 +6,7 @@
 ...     return g
 ...
 
-# TODO: RUSTPYTHON
->>> # dump(f.__code__)
+>>> dump(f.__code__)
 name: f
 argcount: 1
 posonlyargcount: 0
@@ -18,10 +17,9 @@
 freevars: ()
 nlocals: 2
 flags: 3
-consts: ('None', '<code object g>')
+consts: ('<code object g>',)
 
-# TODO: RUSTPYTHON
->>> # dump(f(4).__code__)
+>>> dump(f(4).__code__)
 name: g
 argcount: 1
 posonlyargcount: 0
@@ -41,8 +39,7 @@
 ...     return c
 ...
 
-# TODO: RUSTPYTHON
->>> # dump(h.__code__)
+>>> dump(h.__code__)
 name: h
 argcount: 2
 posonlyargcount: 0
@@ -60,8 +57,7 @@
 ...     print(obj.attr2)
 ...     print(obj.attr3)
 
-# TODO: RUSTPYTHON
->>> # dump(attrs.__code__)
+>>> dump(attrs.__code__)
 name: attrs
 argcount: 1
 posonlyargcount: 0
@@ -80,8 +76,7 @@
 ...     53
 ...     0x53
 
-# TODO: RUSTPYTHON
->>> # dump(optimize_away.__code__)
+>>> dump(optimize_away.__code__)
 name: optimize_away
 argcount: 0
 posonlyargcount: 0
@@ -91,15 +86,14 @@
 cellvars: ()
 freevars: ()
 nlocals: 0
-flags: 3
+flags: 67108867
 consts: ("'doc string'", 'None')
 
 >>> def keywordonly_args(a,b,*,k1):
 ...     return a,b,k1
 ...
 
-# TODO: RUSTPYTHON
->>> # dump(keywordonly_args.__code__)
+>>> dump(keywordonly_args.__code__)
 name: keywordonly_args
 argcount: 2
 posonlyargcount: 0
@@ -116,8 +110,7 @@
 ...     return a,b,c
 ...
 
-# TODO: RUSTPYTHON
->>> # dump(posonly_args.__code__)
+>>> dump(posonly_args.__code__)
 name: posonly_args
 argcount: 3
 posonlyargcount: 2
@@ -130,8 +123,78 @@
 flags: 3
 consts: ('None',)
 
+>>> def has_docstring(x: str):
+...     'This is a one-line doc string'
+...     x += x
+...     x += "hello world"
+...     # co_flags should be 0x4000003 = 67108867
+...     return x
+
+>>> dump(has_docstring.__code__)
+name: has_docstring
+argcount: 1
+posonlyargcount: 0
+kwonlyargcount: 0
+names: ()
+varnames: ('x',)
+cellvars: ()
+freevars: ()
+nlocals: 1
+flags: 67108867
+consts: ("'This is a one-line doc string'", "'hello world'")
+
+>>> async def async_func_docstring(x: str, y: str):
+...     "This is a docstring from async function"
+...     import asyncio
+...     await asyncio.sleep(1)
+...     # co_flags should be 0x4000083 = 67108995
+...     return x + y
+
+>>> dump(async_func_docstring.__code__)
+name: async_func_docstring
+argcount: 2
+posonlyargcount: 0
+kwonlyargcount: 0
+names: ('asyncio', 'sleep')
+varnames: ('x', 'y', 'asyncio')
+cellvars: ()
+freevars: ()
+nlocals: 3
+flags: 67108995
+consts: ("'This is a docstring from async function'", 'None')
+
+>>> def no_docstring(x, y, z):
+...     return x + "hello" + y + z + "world"
+
+>>> dump(no_docstring.__code__)
+name: no_docstring
+argcount: 3
+posonlyargcount: 0
+kwonlyargcount: 0
+names: ()
+varnames: ('x', 'y', 'z')
+cellvars: ()
+freevars: ()
+nlocals: 3
+flags: 3
+consts: ("'hello'", "'world'")
+
+>>> class class_with_docstring:
+...     '''This is a docstring for class'''
+...     '''This line is not docstring'''
+...     pass
+
+>>> print(class_with_docstring.__doc__)
+This is a docstring for class
+
+>>> class class_without_docstring:
+...     pass
+
+>>> print(class_without_docstring.__doc__)
+None
 """
 
+import copy
 import inspect
 import sys
 import threading
@@ -147,10 +210,21 @@
     ctypes = None
 from test.support import (cpython_only,
                           check_impl_detail, requires_debug_ranges,
-                          gc_collect)
+                          gc_collect, Py_GIL_DISABLED, late_deletion)
 from test.support.script_helper import assert_python_ok
-from test.support import threading_helper
+from test.support import threading_helper, import_helper
+from test.support.bytecode_helper import instructions_with_positions
 from opcode import opmap, opname
+try:
+    from _testcapi import code_offset_to_line
+except ModuleNotFoundError:
+    code_offset_to_line = None
+try:
+    import _testinternalcapi
+except ModuleNotFoundError:
+    _testinternalcapi = None
+import test._code_definitions as defs
+
 COPY_FREE_VARS = opmap['COPY_FREE_VARS']
 
 
@@ -176,11 +250,12 @@ def dump(co):
 def external_getitem(self, i):
     return f"Foreign getitem: {super().__getitem__(i)}"
 
+
 class CodeTest(unittest.TestCase):
 
     @cpython_only
     def test_newempty(self):
-        import _testcapi
+        _testcapi = import_helper.import_module("_testcapi")
         co = _testcapi.code_newempty("filename", "funcname", 15)
         self.assertEqual(co.co_filename, "filename")
         self.assertEqual(co.co_name, "funcname")
@@ -259,10 +334,11 @@ def func():
             return x
         code = func.__code__
 
-        # different co_name, co_varnames, co_consts
+        # Different co_name, co_varnames, co_consts.
+        # Must have the same number of constants and
+        # variables or we get crashes.
         def func2():
             y = 2
-            z = 3
             return y
         code2 = func2.__code__
 
@@ -271,7 +347,7 @@ def func2():
             ("co_posonlyargcount", 0),
             ("co_kwonlyargcount", 0),
             ("co_nlocals", 1),
-            ("co_stacksize", 0),
+            ("co_stacksize", 1),
             ("co_flags", code.co_flags | inspect.CO_COROUTINE),
             ("co_firstlineno", 100),
             ("co_code", code2.co_code),
@@ -287,11 +363,17 @@ def func2():
             with self.subTest(attr=attr, value=value):
                 new_code = code.replace(**{attr: value})
                 self.assertEqual(getattr(new_code, attr), value)
+                new_code = copy.replace(code, **{attr: value})
+                self.assertEqual(getattr(new_code, attr), value)
 
         new_code = code.replace(co_varnames=code2.co_varnames,
                                 co_nlocals=code2.co_nlocals)
         self.assertEqual(new_code.co_varnames, code2.co_varnames)
         self.assertEqual(new_code.co_nlocals, code2.co_nlocals)
+        new_code = copy.replace(code, co_varnames=code2.co_varnames,
+                                co_nlocals=code2.co_nlocals)
+        self.assertEqual(new_code.co_varnames, code2.co_varnames)
+        self.assertEqual(new_code.co_nlocals, code2.co_nlocals)
 
     def test_nlocals_mismatch(self):
         def func():
@@ -330,8 +412,6 @@ def func():
         with self.assertRaises(ValueError):
             co.replace(co_nlocals=co.co_nlocals + 1)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_shrinking_localsplus(self):
         # Check that PyCode_NewWithPosOnlyArgs resizes both
         # localsplusnames and localspluskinds, if an argument is a cell.
@@ -347,7 +427,7 @@ def func():
         new_code = code = func.__code__.replace(co_linetable=b'')
         self.assertEqual(list(new_code.co_lines()), [])
 
-    # TODO: RUSTPYTHON
+    # TODO: RUSTPYTHON; co_lnotab intentionally not implemented (deprecated since 3.12)
     @unittest.expectedFailure
     def test_co_lnotab_is_deprecated(self):  # TODO: remove in 3.14
         def func():
@@ -356,20 +436,75 @@ def func():
         with self.assertWarns(DeprecationWarning):
             func.__code__.co_lnotab
 
-    # TODO: RUSTPYTHON
+    @unittest.skipIf(_testinternalcapi is None, '_testinternalcapi is missing')
+    def test_returns_only_none(self):
+        value = True
+
+        def spam1():
+            pass
+        def spam2():
+            return
+        def spam3():
+            return None
+        def spam4():
+            if not value:
+                return
+            ...
+        def spam5():
+            if not value:
+                return None
+            ...
+        lambda1 = (lambda: None)
+        for func in [
+            spam1,
+            spam2,
+            spam3,
+            spam4,
+            spam5,
+            lambda1,
+        ]:
+            with self.subTest(func):
+                res = _testinternalcapi.code_returns_only_none(func.__code__)
+                self.assertTrue(res)
+
+        def spam6():
+            return True
+        def spam7():
+            return value
+        def spam8():
+            if value:
+                return None
+            return True
+        def spam9():
+            if value:
+                return True
+            return None
+        lambda2 = (lambda: True)
+        for func in [
+            spam6,
+            spam7,
+            spam8,
+            spam9,
+            lambda2,
+        ]:
+            with self.subTest(func):
+                res = _testinternalcapi.code_returns_only_none(func.__code__)
+                self.assertFalse(res)
+
+    # TODO: RUSTPYTHON; replace() rejects invalid bytecodes for safety
     @unittest.expectedFailure
     def test_invalid_bytecode(self):
         def foo():
             pass
 
-        # assert that opcode 229 is invalid
-        self.assertEqual(opname[229], '<229>')
+        # assert that opcode 127 is invalid
+        self.assertEqual(opname[127], '<127>')
 
-        # change first opcode to 0xeb (=229)
+        # change first opcode to 0x7f (=127)
         foo.__code__ = foo.__code__.replace(
-            co_code=b'\xe5' + foo.__code__.co_code[1:])
+            co_code=b'\x7f' + foo.__code__.co_code[1:])
 
-        msg = "unknown opcode 229"
+        msg = "unknown opcode 127"
         with self.assertRaisesRegex(SystemError, msg):
             foo()
 
@@ -392,10 +527,8 @@ def test_co_positions_artificial_instructions(self):
         code = traceback.tb_frame.f_code
 
         artificial_instructions = []
-        for instr, positions in zip(
-            dis.get_instructions(code, show_caches=True),
-            code.co_positions(),
-            strict=True
+        for instr, positions in instructions_with_positions(
+            dis.get_instructions(code), code.co_positions()
         ):
             # If any of the positions is None, then all have to
             # be None as well for the case above. There are still
@@ -456,7 +589,7 @@ def f():
 
     # co_positions behavior when info is missing.
 
-    # @requires_debug_ranges()
+    @requires_debug_ranges()
     def test_co_positions_empty_linetable(self):
         def func():
             x = 1
@@ -513,6 +646,533 @@ def test_code_hash_uses_bytecode(self):
         self.assertNotEqual(c, c1)
         self.assertNotEqual(hash(c), hash(c1))
 
+    @cpython_only
+    def test_code_equal_with_instrumentation(self):
+        """ GH-109052
+
+        Make sure the instrumentation doesn't affect the code equality
+        The validity of this test relies on the fact that "x is x" and
+        "x in x" have only one different instruction and the instructions
+        have the same argument.
+
+        """
+        code1 = compile("x is x", "example.py", "eval")
+        code2 = compile("x in x", "example.py", "eval")
+        sys._getframe().f_trace_opcodes = True
+        sys.settrace(lambda *args: None)
+        exec(code1, {'x': []})
+        exec(code2, {'x': []})
+        self.assertNotEqual(code1, code2)
+        sys.settrace(None)
+
+    @unittest.skipIf(_testinternalcapi is None, "missing _testinternalcapi")
+    def test_local_kinds(self):
+        CO_FAST_ARG_POS = 0x02
+        CO_FAST_ARG_KW = 0x04
+        CO_FAST_ARG_VAR = 0x08
+        CO_FAST_HIDDEN = 0x10
+        CO_FAST_LOCAL = 0x20
+        CO_FAST_CELL = 0x40
+        CO_FAST_FREE = 0x80
+
+        POSONLY = CO_FAST_LOCAL | CO_FAST_ARG_POS
+        POSORKW = CO_FAST_LOCAL | CO_FAST_ARG_POS | CO_FAST_ARG_KW
+        KWONLY = CO_FAST_LOCAL | CO_FAST_ARG_KW
+        VARARGS = CO_FAST_LOCAL | CO_FAST_ARG_VAR | CO_FAST_ARG_POS
+        VARKWARGS = CO_FAST_LOCAL | CO_FAST_ARG_VAR | CO_FAST_ARG_KW
+
+        funcs = {
+            defs.simple_script: {},
+            defs.complex_script: {
+                'obj': CO_FAST_LOCAL,
+                'pickle': CO_FAST_LOCAL,
+                'spam_minimal': CO_FAST_LOCAL,
+                'data': CO_FAST_LOCAL,
+                'res': CO_FAST_LOCAL,
+            },
+            defs.script_with_globals: {
+                'obj1': CO_FAST_LOCAL,
+                'obj2': CO_FAST_LOCAL,
+            },
+            defs.script_with_explicit_empty_return: {},
+            defs.script_with_return: {},
+            defs.spam_minimal: {},
+            defs.spam_with_builtins: {
+                'x': CO_FAST_LOCAL,
+                'values': CO_FAST_LOCAL,
+                'checks': CO_FAST_LOCAL,
+                'res': CO_FAST_LOCAL,
+            },
+            defs.spam_with_globals_and_builtins: {
+                'func1': CO_FAST_LOCAL,
+                'func2': CO_FAST_LOCAL,
+                'funcs': CO_FAST_LOCAL,
+                'checks': CO_FAST_LOCAL,
+                'res': CO_FAST_LOCAL,
+            },
+            defs.spam_with_global_and_attr_same_name: {},
+            defs.spam_full_args: {
+                'a': POSONLY,
+                'b': POSONLY,
+                'c': POSORKW,
+                'd': POSORKW,
+                'e': KWONLY,
+                'f': KWONLY,
+                'args': VARARGS,
+                'kwargs': VARKWARGS,
+            },
+            defs.spam_full_args_with_defaults: {
+                'a': POSONLY,
+                'b': POSONLY,
+                'c': POSORKW,
+                'd': POSORKW,
+                'e': KWONLY,
+                'f': KWONLY,
+                'args': VARARGS,
+                'kwargs': VARKWARGS,
+            },
+            defs.spam_args_attrs_and_builtins: {
+                'a': POSONLY,
+                'b': POSONLY,
+                'c': POSORKW,
+                'd': POSORKW,
+                'e': KWONLY,
+                'f': KWONLY,
+                'args': VARARGS,
+                'kwargs': VARKWARGS,
+            },
+            defs.spam_returns_arg: {
+                'x': POSORKW,
+            },
+            defs.spam_raises: {},
+            defs.spam_with_inner_not_closure: {
+                'eggs': CO_FAST_LOCAL,
+            },
+            defs.spam_with_inner_closure: {
+                'x': CO_FAST_CELL,
+                'eggs': CO_FAST_LOCAL,
+            },
+            defs.spam_annotated: {
+                'a': POSORKW,
+                'b': POSORKW,
+                'c': POSORKW,
+            },
+            defs.spam_full: {
+                'a': POSONLY,
+                'b': POSONLY,
+                'c': POSORKW,
+                'd': POSORKW,
+                'e': KWONLY,
+                'f': KWONLY,
+                'args': VARARGS,
+                'kwargs': VARKWARGS,
+                'x': CO_FAST_LOCAL,
+                'y': CO_FAST_LOCAL,
+                'z': CO_FAST_LOCAL,
+                'extras': CO_FAST_LOCAL,
+            },
+            defs.spam: {
+                'x': POSORKW,
+            },
+            defs.spam_N: {
+                'x': POSORKW,
+                'eggs_nested': CO_FAST_LOCAL,
+            },
+            defs.spam_C: {
+                'x': POSORKW | CO_FAST_CELL,
+                'a': CO_FAST_CELL,
+                'eggs_closure': CO_FAST_LOCAL,
+            },
+            defs.spam_NN: {
+                'x': POSORKW,
+                'eggs_nested_N': CO_FAST_LOCAL,
+            },
+            defs.spam_NC: {
+                'x': POSORKW | CO_FAST_CELL,
+                'a': CO_FAST_CELL,
+                'eggs_nested_C': CO_FAST_LOCAL,
+            },
+            defs.spam_CN: {
+                'x': POSORKW | CO_FAST_CELL,
+                'a': CO_FAST_CELL,
+                'eggs_closure_N': CO_FAST_LOCAL,
+            },
+            defs.spam_CC: {
+                'x': POSORKW | CO_FAST_CELL,
+                'a': CO_FAST_CELL,
+                'eggs_closure_C': CO_FAST_LOCAL,
+            },
+            defs.eggs_nested: {
+                'y': POSORKW,
+            },
+            defs.eggs_closure: {
+                'y': POSORKW,
+                'x': CO_FAST_FREE,
+                'a': CO_FAST_FREE,
+            },
+            defs.eggs_nested_N: {
+                'y': POSORKW,
+                'ham_nested': CO_FAST_LOCAL,
+            },
+            defs.eggs_nested_C: {
+                'y': POSORKW | CO_FAST_CELL,
+                'x': CO_FAST_FREE,
+                'a': CO_FAST_FREE,
+                'ham_closure': CO_FAST_LOCAL,
+            },
+            defs.eggs_closure_N: {
+                'y': POSORKW,
+                'x': CO_FAST_FREE,
+                'a': CO_FAST_FREE,
+                'ham_C_nested': CO_FAST_LOCAL,
+            },
+            defs.eggs_closure_C: {
+                'y': POSORKW | CO_FAST_CELL,
+                'b': CO_FAST_CELL,
+                'x': CO_FAST_FREE,
+                'a': CO_FAST_FREE,
+                'ham_C_closure': CO_FAST_LOCAL,
+            },
+            defs.ham_nested: {
+                'z': POSORKW,
+            },
+            defs.ham_closure: {
+                'z': POSORKW,
+                'y': CO_FAST_FREE,
+                'x': CO_FAST_FREE,
+                'a': CO_FAST_FREE,
+            },
+            defs.ham_C_nested: {
+                'z': POSORKW,
+            },
+            defs.ham_C_closure: {
+                'z': POSORKW,
+                'y': CO_FAST_FREE,
+                'b': CO_FAST_FREE,
+                'x': CO_FAST_FREE,
+                'a': CO_FAST_FREE,
+            },
+        }
+        assert len(funcs) == len(defs.FUNCTIONS)
+        for func in defs.FUNCTIONS:
+            with self.subTest(func):
+                expected = funcs[func]
+                kinds = _testinternalcapi.get_co_localskinds(func.__code__)
+                self.assertEqual(kinds, expected)
+
+    @unittest.skipIf(_testinternalcapi is None, "missing _testinternalcapi")
+    def test_var_counts(self):
+        self.maxDiff = None
+        def new_var_counts(*,
+                           posonly=0,
+                           posorkw=0,
+                           kwonly=0,
+                           varargs=0,
+                           varkwargs=0,
+                           purelocals=0,
+                           argcells=0,
+                           othercells=0,
+                           freevars=0,
+                           globalvars=0,
+                           attrs=0,
+                           unknown=0,
+                           ):
+            nargvars = posonly + posorkw + kwonly + varargs + varkwargs
+            nlocals = nargvars + purelocals + othercells
+            if isinstance(globalvars, int):
+                globalvars = {
+                    'total': globalvars,
+                    'numglobal': 0,
+                    'numbuiltin': 0,
+                    'numunknown': globalvars,
+                }
+            else:
+                g_numunknown = 0
+                if isinstance(globalvars, dict):
+                    numglobal = globalvars['numglobal']
+                    numbuiltin = globalvars['numbuiltin']
+                    size = 2
+                    if 'numunknown' in globalvars:
+                        g_numunknown = globalvars['numunknown']
+                        size += 1
+                    assert len(globalvars) == size, globalvars
+                else:
+                    assert not isinstance(globalvars, str), repr(globalvars)
+                    try:
+                        numglobal, numbuiltin = globalvars
+                    except ValueError:
+                        numglobal, numbuiltin, g_numunknown = globalvars
+                globalvars = {
+                    'total': numglobal + numbuiltin + g_numunknown,
+                    'numglobal': numglobal,
+                    'numbuiltin': numbuiltin,
+                    'numunknown': g_numunknown,
+                }
+            unbound = globalvars['total'] + attrs + unknown
+            return {
+                'total': nlocals + freevars + unbound,
+                'locals': {
+                    'total': nlocals,
+                    'args': {
+                        'total': nargvars,
+                        'numposonly': posonly,
+                        'numposorkw': posorkw,
+                        'numkwonly': kwonly,
+                        'varargs': varargs,
+                        'varkwargs': varkwargs,
+                    },
+                    'numpure': purelocals,
+                    'cells': {
+                        'total': argcells + othercells,
+                        'numargs': argcells,
+                        'numothers': othercells,
+                    },
+                    'hidden': {
+                        'total': 0,
+                        'numpure': 0,
+                        'numcells': 0,
+                    },
+                },
+                'numfree': freevars,
+                'unbound': {
+                    'total': unbound,
+                    'globals': globalvars,
+                    'numattrs': attrs,
+                    'numunknown': unknown,
+                },
+            }
+
+        funcs = {
+            defs.simple_script: new_var_counts(),
+            defs.complex_script: new_var_counts(
+                purelocals=5,
+                globalvars=1,
+                attrs=2,
+            ),
+            defs.script_with_globals: new_var_counts(
+                purelocals=2,
+                globalvars=1,
+            ),
+            defs.script_with_explicit_empty_return: new_var_counts(),
+            defs.script_with_return: new_var_counts(),
+            defs.spam_minimal: new_var_counts(),
+            defs.spam_minimal: new_var_counts(),
+            defs.spam_with_builtins: new_var_counts(
+                purelocals=4,
+                globalvars=4,
+            ),
+            defs.spam_with_globals_and_builtins: new_var_counts(
+                purelocals=5,
+                globalvars=6,
+            ),
+            defs.spam_with_global_and_attr_same_name: new_var_counts(
+                globalvars=2,
+                attrs=1,
+            ),
+            defs.spam_full_args: new_var_counts(
+                posonly=2,
+                posorkw=2,
+                kwonly=2,
+                varargs=1,
+                varkwargs=1,
+            ),
+            defs.spam_full_args_with_defaults: new_var_counts(
+                posonly=2,
+                posorkw=2,
+                kwonly=2,
+                varargs=1,
+                varkwargs=1,
+            ),
+            defs.spam_args_attrs_and_builtins: new_var_counts(
+                posonly=2,
+                posorkw=2,
+                kwonly=2,
+                varargs=1,
+                varkwargs=1,
+                attrs=1,
+            ),
+            defs.spam_returns_arg: new_var_counts(
+                posorkw=1,
+            ),
+            defs.spam_raises: new_var_counts(
+                globalvars=1,
+            ),
+            defs.spam_with_inner_not_closure: new_var_counts(
+                purelocals=1,
+            ),
+            defs.spam_with_inner_closure: new_var_counts(
+                othercells=1,
+                purelocals=1,
+            ),
+            defs.spam_annotated: new_var_counts(
+                posorkw=3,
+            ),
+            defs.spam_full: new_var_counts(
+                posonly=2,
+                posorkw=2,
+                kwonly=2,
+                varargs=1,
+                varkwargs=1,
+                purelocals=4,
+                globalvars=3,
+                attrs=1,
+            ),
+            defs.spam: new_var_counts(
+                posorkw=1,
+            ),
+            defs.spam_N: new_var_counts(
+                posorkw=1,
+                purelocals=1,
+            ),
+            defs.spam_C: new_var_counts(
+                posorkw=1,
+                purelocals=1,
+                argcells=1,
+                othercells=1,
+            ),
+            defs.spam_NN: new_var_counts(
+                posorkw=1,
+                purelocals=1,
+            ),
+            defs.spam_NC: new_var_counts(
+                posorkw=1,
+                purelocals=1,
+                argcells=1,
+                othercells=1,
+            ),
+            defs.spam_CN: new_var_counts(
+                posorkw=1,
+                purelocals=1,
+                argcells=1,
+                othercells=1,
+            ),
+            defs.spam_CC: new_var_counts(
+                posorkw=1,
+                purelocals=1,
+                argcells=1,
+                othercells=1,
+            ),
+            defs.eggs_nested: new_var_counts(
+                posorkw=1,
+            ),
+            defs.eggs_closure: new_var_counts(
+                posorkw=1,
+                freevars=2,
+            ),
+            defs.eggs_nested_N: new_var_counts(
+                posorkw=1,
+                purelocals=1,
+            ),
+            defs.eggs_nested_C: new_var_counts(
+                posorkw=1,
+                purelocals=1,
+                argcells=1,
+                freevars=2,
+            ),
+            defs.eggs_closure_N: new_var_counts(
+                posorkw=1,
+                purelocals=1,
+                freevars=2,
+            ),
+            defs.eggs_closure_C: new_var_counts(
+                posorkw=1,
+                purelocals=1,
+                argcells=1,
+                othercells=1,
+                freevars=2,
+            ),
+            defs.ham_nested: new_var_counts(
+                posorkw=1,
+            ),
+            defs.ham_closure: new_var_counts(
+                posorkw=1,
+                freevars=3,
+            ),
+            defs.ham_C_nested: new_var_counts(
+                posorkw=1,
+            ),
+            defs.ham_C_closure: new_var_counts(
+                posorkw=1,
+                freevars=4,
+            ),
+        }
+        assert len(funcs) == len(defs.FUNCTIONS), (len(funcs), len(defs.FUNCTIONS))
+        for func in defs.FUNCTIONS:
+            with self.subTest(func):
+                expected = funcs[func]
+                counts = _testinternalcapi.get_code_var_counts(func.__code__)
+                self.assertEqual(counts, expected)
+
+        func = defs.spam_with_globals_and_builtins
+        with self.subTest(f'{func} code'):
+            expected = new_var_counts(
+                purelocals=5,
+                globalvars=6,
+            )
+            counts = _testinternalcapi.get_code_var_counts(func.__code__)
+            self.assertEqual(counts, expected)
+
+        with self.subTest(f'{func} with own globals and builtins'):
+            expected = new_var_counts(
+                purelocals=5,
+                globalvars=(2, 4),
+            )
+            counts = _testinternalcapi.get_code_var_counts(func)
+            self.assertEqual(counts, expected)
+
+        with self.subTest(f'{func} without globals'):
+            expected = new_var_counts(
+                purelocals=5,
+                globalvars=(0, 4, 2),
+            )
+            counts = _testinternalcapi.get_code_var_counts(func, globalsns={})
+            self.assertEqual(counts, expected)
+
+        with self.subTest(f'{func} without both'):
+            expected = new_var_counts(
+                purelocals=5,
+                globalvars=6,
+            )
+            counts = _testinternalcapi.get_code_var_counts(func, globalsns={},
+                  builtinsns={})
+            self.assertEqual(counts, expected)
+
+        with self.subTest(f'{func} without builtins'):
+            expected = new_var_counts(
+                purelocals=5,
+                globalvars=(2, 0, 4),
+            )
+            counts = _testinternalcapi.get_code_var_counts(func, builtinsns={})
+            self.assertEqual(counts, expected)
+
+    @unittest.skipIf(_testinternalcapi is None, "missing _testinternalcapi")
+    def test_stateless(self):
+        self.maxDiff = None
+
+        STATELESS_FUNCTIONS = [
+            *defs.STATELESS_FUNCTIONS,
+            # stateless with defaults
+            defs.spam_full_args_with_defaults,
+        ]
+
+        for func in defs.STATELESS_CODE:
+            with self.subTest((func, '(code)')):
+                _testinternalcapi.verify_stateless_code(func.__code__)
+        for func in STATELESS_FUNCTIONS:
+            with self.subTest((func, '(func)')):
+                _testinternalcapi.verify_stateless_code(func)
+
+        for func in defs.FUNCTIONS:
+            if func not in defs.STATELESS_CODE:
+                with self.subTest((func, '(code)')):
+                    with self.assertRaises(Exception):
+                        _testinternalcapi.verify_stateless_code(func.__code__)
+
+            if func not in STATELESS_FUNCTIONS:
+                with self.subTest((func, '(func)')):
+                    with self.assertRaises(Exception):
+                        _testinternalcapi.verify_stateless_code(func)
+
 
 def isinterned(s):
     return s is sys.intern(('_' + s + '_')[1:-1])
@@ -559,11 +1219,47 @@ def f(a='str_value'):
         self.assertIsInterned(f())
 
     @cpython_only
+    @unittest.skipIf(Py_GIL_DISABLED, "free-threaded build interns all string constants")
     def test_interned_string_with_null(self):
         co = compile(r'res = "str\0value!"', '?', 'exec')
         v = self.find_const(co.co_consts, 'str\0value!')
         self.assertIsNotInterned(v)
 
+    @cpython_only
+    @unittest.skipUnless(Py_GIL_DISABLED, "does not intern all constants")
+    def test_interned_constants(self):
+        # compile separately to avoid compile time de-duping
+
+        globals = {}
+        exec(textwrap.dedent("""
+            def func1():
+                return (0.0, (1, 2, "hello"))
+        """), globals)
+
+        exec(textwrap.dedent("""
+            def func2():
+                return (0.0, (1, 2, "hello"))
+        """), globals)
+
+        self.assertTrue(globals["func1"]() is globals["func2"]())
+
+    @cpython_only
+    def test_unusual_constants(self):
+        # gh-130851: Code objects constructed with constants that are not
+        # types generated by the bytecode compiler should not crash the
+        # interpreter.
+        class Unhashable:
+            def __hash__(self):
+                raise TypeError("unhashable type")
+
+        class MyInt(int):
+            pass
+
+        code = compile("a = 1", "<string>", "exec")
+        code = code.replace(co_consts=(1, Unhashable(), MyInt(1), MyInt(1)))
+        self.assertIsInstance(code.co_consts[1], Unhashable)
+        self.assertEqual(code.co_consts[2], code.co_consts[3])
+
 
 class CodeWeakRefTest(unittest.TestCase):
 
@@ -750,7 +1446,7 @@ def f():
             co_code=bytes(
                 [
                     dis.opmap["RESUME"], 0,
-                    dis.opmap["LOAD_ASSERTION_ERROR"], 0,
+                    dis.opmap["LOAD_COMMON_CONSTANT"], 0,
                     dis.opmap["RAISE_VARARGS"], 1,
                 ]
             ),
@@ -769,6 +1465,81 @@ def f():
             3 * [(42, 42, None, None)],
         )
 
+    @cpython_only
+    def test_docstring_under_o2(self):
+        code = textwrap.dedent('''
+            def has_docstring(x, y):
+                """This is a first-line doc string"""
+                """This is a second-line doc string"""
+                a = x + y
+                b = x - y
+                return a, b
+
+
+            def no_docstring(x):
+                def g(y):
+                    return x + y
+                return g
+
+
+            async def async_func():
+                """asynf function doc string"""
+                pass
+
+
+            for func in [has_docstring, no_docstring(4), async_func]:
+                assert(func.__doc__ is None)
+            ''')
+
+        rc, out, err = assert_python_ok('-OO', '-c', code)
+
+    @unittest.skipUnless(code_offset_to_line, '_testcapi required')
+    def test_co_branches(self):
+
+        def get_line_branches(func):
+            code = func.__code__
+            base = code.co_firstlineno
+            return [
+                (
+                    code_offset_to_line(code, src) - base,
+                    code_offset_to_line(code, left) - base,
+                    code_offset_to_line(code, right) - base
+                ) for (src, left, right) in
+                code.co_branches()
+            ]
+
+        def simple(x):
+            if x:
+                A
+            else:
+                B
+
+        self.assertEqual(
+            get_line_branches(simple),
+            [(1,2,4)])
+
+        def with_extended_args(x):
+            if x:
+                A.x; A.x; A.x; A.x; A.x; A.x;
+                A.x; A.x; A.x; A.x; A.x; A.x;
+                A.x; A.x; A.x; A.x; A.x; A.x;
+                A.x; A.x; A.x; A.x; A.x; A.x;
+                A.x; A.x; A.x; A.x; A.x; A.x;
+            else:
+                B
+
+        self.assertEqual(
+            get_line_branches(with_extended_args),
+            [(1,2,8)])
+
+        async def afunc():
+            async for letter in async_iter1:
+                2
+            3
+
+        self.assertEqual(
+            get_line_branches(afunc),
+            [(1,1,3)])
 
 if check_impl_detail(cpython=True) and ctypes is not None:
     py = ctypes.pythonapi
@@ -794,6 +1565,11 @@ def myfree(ptr):
 
     FREE_FUNC = freefunc(myfree)
     FREE_INDEX = RequestCodeExtraIndex(FREE_FUNC)
+    # Make sure myfree sticks around at least as long as the interpreter,
+    # since we (currently) can't unregister the function and leaving a
+    # dangling pointer will cause a crash on deallocation of code objects if
+    # something else uses co_extras, like test_capi.test_misc.
+    late_deletion(myfree)
 
     class CoExtra(unittest.TestCase):
         def get_func(self):
@@ -824,6 +1600,7 @@ def test_free_called(self):
 
             SetExtra(f.__code__, FREE_INDEX, ctypes.c_voidp(100))
             del f
+            gc_collect()  # For free-threaded build
             self.assertEqual(LAST_FREED, 100)
 
         def test_get_set(self):
@@ -854,13 +1631,19 @@ def __init__(self, f, test):
                     self.test = test
                 def run(self):
                     del self.f
-                    self.test.assertEqual(LAST_FREED, 500)
+                    gc_collect()
+                    # gh-117683: In the free-threaded build, the code object's
+                    # destructor may still be running concurrently in the main
+                    # thread.
+                    if not Py_GIL_DISABLED:
+                        self.test.assertEqual(LAST_FREED, 500)
 
             SetExtra(f.__code__, FREE_INDEX, ctypes.c_voidp(500))
             tt = ThreadTest(f, self)
             del f
             tt.start()
             tt.join()
+            gc_collect()  # For free-threaded build
             self.assertEqual(LAST_FREED, 500)
 
 
diff --git a/Lib/test/test_code_module.py b/Lib/test/test_code_module.py
index 4d5463e6db3..39d85d46274 100644
--- a/Lib/test/test_code_module.py
+++ b/Lib/test/test_code_module.py
@@ -39,19 +39,47 @@ def setUp(self):
         self.mock_sys()
 
     def test_ps1(self):
-        self.infunc.side_effect = EOFError('Finished')
+        self.infunc.side_effect = [
+            "import code",
+            "code.sys.ps1",
+            EOFError('Finished')
+        ]
         self.console.interact()
-        self.assertEqual(self.sysmod.ps1, '>>> ')
+        output = ''.join(''.join(call[1]) for call in self.stdout.method_calls)
+        self.assertIn('>>> ', output)
+        self.assertNotHasAttr(self.sysmod, 'ps1')
+
+        self.infunc.side_effect = [
+            "import code",
+            "code.sys.ps1",
+            EOFError('Finished')
+        ]
         self.sysmod.ps1 = 'custom1> '
         self.console.interact()
+        output = ''.join(''.join(call[1]) for call in self.stdout.method_calls)
+        self.assertIn('custom1> ', output)
         self.assertEqual(self.sysmod.ps1, 'custom1> ')
 
     def test_ps2(self):
-        self.infunc.side_effect = EOFError('Finished')
+        self.infunc.side_effect = [
+            "import code",
+            "code.sys.ps2",
+            EOFError('Finished')
+        ]
         self.console.interact()
-        self.assertEqual(self.sysmod.ps2, '... ')
+        output = ''.join(''.join(call[1]) for call in self.stdout.method_calls)
+        self.assertIn('... ', output)
+        self.assertNotHasAttr(self.sysmod, 'ps2')
+
+        self.infunc.side_effect = [
+            "import code",
+            "code.sys.ps2",
+            EOFError('Finished')
+        ]
         self.sysmod.ps2 = 'custom2> '
         self.console.interact()
+        output = ''.join(''.join(call[1]) for call in self.stdout.method_calls)
+        self.assertIn('custom2> ', output)
         self.assertEqual(self.sysmod.ps2, 'custom2> ')
 
     def test_console_stderr(self):
@@ -63,9 +91,6 @@ def test_console_stderr(self):
         else:
             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():",
                                    "    x = ?",
@@ -86,9 +111,7 @@ def test_syntax_error(self):
         self.assertIsNone(self.sysmod.last_value.__traceback__)
         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
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; -  'IndentationError: unexpected indentation']
     def test_indentation_error(self):
         self.infunc.side_effect = ["  1", EOFError('Finished')]
         self.console.interact()
@@ -105,16 +128,14 @@ def test_indentation_error(self):
         self.assertIsNone(self.sysmod.last_value.__traceback__)
         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
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AssertionError: 'UnicodeDecodeError: invalid utf-8 sequence of 1 bytes from index 1\n\nnow exiti [truncated]... doesn't start with 'UnicodeEncodeError: '
     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.assertStartsWith(output, 'UnicodeEncodeError: ')
         self.assertIs(self.sysmod.last_type, UnicodeEncodeError)
         self.assertIs(type(self.sysmod.last_value), UnicodeEncodeError)
         self.assertIsNone(self.sysmod.last_traceback)
@@ -144,9 +165,6 @@ def test_sysexcepthook(self):
             '  File "<console>", line 2, in f\n',
             '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():",
                                    "    x = ?",
@@ -170,9 +188,7 @@ def test_sysexcepthook_syntax_error(self):
             '        ^\n',
             '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
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; +  'IndentationError: unexpected indent\n']
     def test_sysexcepthook_indentation_error(self):
         self.infunc.side_effect = ["  1", EOFError('Finished')]
         hook = mock.Mock()
@@ -267,7 +283,6 @@ def test_exit_msg(self):
         self.assertEqual(err_msg, ['write', (expected,), {}])
 
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_cause_tb(self):
         self.infunc.side_effect = ["raise ValueError('') from AttributeError",
                                     EOFError('Finished')]
diff --git a/Lib/test/test_codeccallbacks.py b/Lib/test/test_codeccallbacks.py
index 9ca02cea351..763146c94fc 100644
--- a/Lib/test/test_codeccallbacks.py
+++ b/Lib/test/test_codeccallbacks.py
@@ -281,8 +281,6 @@ def handler2(exc):
             b"g[<252><223>]"
         )
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_longstrings(self):
         # test long strings to check for memory overflow problems
         errors = [ "strict", "ignore", "replace", "xmlcharrefreplace",
@@ -684,8 +682,6 @@ def test_badandgoodsurrogateescapeexceptions(self):
             ("\udc80", 2)
         )
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_badandgoodsurrogatepassexceptions(self):
         surrogatepass_errors = codecs.lookup_error('surrogatepass')
         # "surrogatepass" complains about a non-exception passed in
diff --git a/Lib/test/test_codecencodings_cn.py b/Lib/test/test_codecencodings_cn.py
new file mode 100644
index 00000000000..af32f624d81
--- /dev/null
+++ b/Lib/test/test_codecencodings_cn.py
@@ -0,0 +1,100 @@
+#
+# test_codecencodings_cn.py
+#   Codec encoding tests for PRC encodings.
+#
+
+from test import multibytecodec_support
+import unittest
+
+@unittest.skip("TODO: RUSTPYTHON; unknown encoding: gb2312")
+class Test_GB2312(multibytecodec_support.TestBase, unittest.TestCase):
+    encoding = 'gb2312'
+    tstring = multibytecodec_support.load_teststring('gb2312')
+    codectests = (
+        # invalid bytes
+        (b"abc\x81\x81\xc1\xc4", "strict",  None),
+        (b"abc\xc8", "strict",  None),
+        (b"abc\x81\x81\xc1\xc4", "replace", "abc\ufffd\ufffd\u804a"),
+        (b"abc\x81\x81\xc1\xc4\xc8", "replace", "abc\ufffd\ufffd\u804a\ufffd"),
+        (b"abc\x81\x81\xc1\xc4", "ignore",  "abc\u804a"),
+        (b"\xc1\x64", "strict", None),
+    )
+
+@unittest.skip("TODO: RUSTPYTHON; unknown encoding: gbk")
+class Test_GBK(multibytecodec_support.TestBase, unittest.TestCase):
+    encoding = 'gbk'
+    tstring = multibytecodec_support.load_teststring('gbk')
+    codectests = (
+        # invalid bytes
+        (b"abc\x80\x80\xc1\xc4", "strict",  None),
+        (b"abc\xc8", "strict",  None),
+        (b"abc\x80\x80\xc1\xc4", "replace", "abc\ufffd\ufffd\u804a"),
+        (b"abc\x80\x80\xc1\xc4\xc8", "replace", "abc\ufffd\ufffd\u804a\ufffd"),
+        (b"abc\x80\x80\xc1\xc4", "ignore",  "abc\u804a"),
+        (b"\x83\x34\x83\x31", "strict", None),
+        ("\u30fb", "strict", None),
+    )
+
+@unittest.skip("TODO: RUSTPYTHON; unknown encoding: gb18030")
+class Test_GB18030(multibytecodec_support.TestBase, unittest.TestCase):
+    encoding = 'gb18030'
+    tstring = multibytecodec_support.load_teststring('gb18030')
+    codectests = (
+        # invalid bytes
+        (b"abc\x80\x80\xc1\xc4", "strict",  None),
+        (b"abc\xc8", "strict",  None),
+        (b"abc\x80\x80\xc1\xc4", "replace", "abc\ufffd\ufffd\u804a"),
+        (b"abc\x80\x80\xc1\xc4\xc8", "replace", "abc\ufffd\ufffd\u804a\ufffd"),
+        (b"abc\x80\x80\xc1\xc4", "ignore",  "abc\u804a"),
+        (b"abc\x84\x39\x84\x39\xc1\xc4", "replace", "abc\ufffd9\ufffd9\u804a"),
+        ("\u30fb", "strict", b"\x819\xa79"),
+        (b"abc\x84\x32\x80\x80def", "replace", 'abc\ufffd2\ufffd\ufffddef'),
+        (b"abc\x81\x30\x81\x30def", "strict", 'abc\x80def'),
+        (b"abc\x86\x30\x81\x30def", "replace", 'abc\ufffd0\ufffd0def'),
+        # issue29990
+        (b"\xff\x30\x81\x30", "strict", None),
+        (b"\x81\x30\xff\x30", "strict", None),
+        (b"abc\x81\x39\xff\x39\xc1\xc4", "replace", "abc\ufffd\x39\ufffd\x39\u804a"),
+        (b"abc\xab\x36\xff\x30def", "replace", 'abc\ufffd\x36\ufffd\x30def'),
+        (b"abc\xbf\x38\xff\x32\xc1\xc4", "ignore",  "abc\x38\x32\u804a"),
+    )
+    has_iso10646 = True
+
+@unittest.skip("TODO: RUSTPYTHON; unknown encoding: hz")
+class Test_HZ(multibytecodec_support.TestBase, unittest.TestCase):
+    encoding = 'hz'
+    tstring = multibytecodec_support.load_teststring('hz')
+    codectests = (
+        # test '~\n' (3 lines)
+        (b'This sentence is in ASCII.\n'
+         b'The next sentence is in GB.~{<:Ky2;S{#,~}~\n'
+         b'~{NpJ)l6HK!#~}Bye.\n',
+         'strict',
+         'This sentence is in ASCII.\n'
+         'The next sentence is in GB.'
+         '\u5df1\u6240\u4e0d\u6b32\uff0c\u52ff\u65bd\u65bc\u4eba\u3002'
+         'Bye.\n'),
+        # test '~\n' (4 lines)
+        (b'This sentence is in ASCII.\n'
+         b'The next sentence is in GB.~\n'
+         b'~{<:Ky2;S{#,NpJ)l6HK!#~}~\n'
+         b'Bye.\n',
+         'strict',
+         'This sentence is in ASCII.\n'
+         'The next sentence is in GB.'
+         '\u5df1\u6240\u4e0d\u6b32\uff0c\u52ff\u65bd\u65bc\u4eba\u3002'
+         'Bye.\n'),
+        # invalid bytes
+        (b'ab~cd', 'replace', 'ab\uFFFDcd'),
+        (b'ab\xffcd', 'replace', 'ab\uFFFDcd'),
+        (b'ab~{\x81\x81\x41\x44~}cd', 'replace', 'ab\uFFFD\uFFFD\u804Acd'),
+        (b'ab~{\x41\x44~}cd', 'replace', 'ab\u804Acd'),
+        (b"ab~{\x79\x79\x41\x44~}cd", "replace", "ab\ufffd\ufffd\u804acd"),
+        # issue 30003
+        ('ab~cd', 'strict',  b'ab~~cd'),  # escape ~
+        (b'~{Dc~~:C~}', 'strict', None),  # ~~ only in ASCII mode
+        (b'~{Dc~\n:C~}', 'strict', None), # ~\n only in ASCII mode
+    )
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/Lib/test/test_codecencodings_hk.py b/Lib/test/test_codecencodings_hk.py
new file mode 100644
index 00000000000..b64d19bca91
--- /dev/null
+++ b/Lib/test/test_codecencodings_hk.py
@@ -0,0 +1,23 @@
+#
+# test_codecencodings_hk.py
+#   Codec encoding tests for HongKong encodings.
+#
+
+from test import multibytecodec_support
+import unittest
+
+@unittest.skip("TODO: RUSTPYTHON; unknown encoding: big5hkscs")
+class Test_Big5HKSCS(multibytecodec_support.TestBase, unittest.TestCase):
+    encoding = 'big5hkscs'
+    tstring = multibytecodec_support.load_teststring('big5hkscs')
+    codectests = (
+        # invalid bytes
+        (b"abc\x80\x80\xc1\xc4", "strict",  None),
+        (b"abc\xc8", "strict",  None),
+        (b"abc\x80\x80\xc1\xc4", "replace", "abc\ufffd\ufffd\u8b10"),
+        (b"abc\x80\x80\xc1\xc4\xc8", "replace", "abc\ufffd\ufffd\u8b10\ufffd"),
+        (b"abc\x80\x80\xc1\xc4", "ignore",  "abc\u8b10"),
+    )
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/Lib/test/test_codecencodings_iso2022.py b/Lib/test/test_codecencodings_iso2022.py
new file mode 100644
index 00000000000..fe97aa6977e
--- /dev/null
+++ b/Lib/test/test_codecencodings_iso2022.py
@@ -0,0 +1,92 @@
+# Codec encoding tests for ISO 2022 encodings.
+
+from test import multibytecodec_support
+import unittest
+
+COMMON_CODEC_TESTS = (
+        # invalid bytes
+        (b'ab\xFFcd', 'replace', 'ab\uFFFDcd'),
+        (b'ab\x1Bdef', 'replace', 'ab\x1Bdef'),
+        (b'ab\x1B$def', 'replace', 'ab\uFFFD'),
+    )
+
+@unittest.skip("TODO: RUSTPYTHON; unknown encoding: iso2022_jp")
+class Test_ISO2022_JP(multibytecodec_support.TestBase, unittest.TestCase):
+    encoding = 'iso2022_jp'
+    tstring = multibytecodec_support.load_teststring('iso2022_jp')
+    codectests = COMMON_CODEC_TESTS + (
+        (b'ab\x1BNdef', 'replace', 'ab\x1BNdef'),
+    )
+
+@unittest.skip("TODO: RUSTPYTHON; unknown encoding: iso2022_jp_2")
+class Test_ISO2022_JP2(multibytecodec_support.TestBase, unittest.TestCase):
+    encoding = 'iso2022_jp_2'
+    tstring = multibytecodec_support.load_teststring('iso2022_jp')
+    codectests = COMMON_CODEC_TESTS + (
+        (b'ab\x1BNdef', 'replace', 'abdef'),
+    )
+
+@unittest.skip("TODO: RUSTPYTHON; unknown encoding: iso2022_jp_3")
+class Test_ISO2022_JP3(multibytecodec_support.TestBase, unittest.TestCase):
+    encoding = 'iso2022_jp_3'
+    tstring = multibytecodec_support.load_teststring('iso2022_jp')
+    codectests = COMMON_CODEC_TESTS + (
+        (b'ab\x1BNdef', 'replace', 'ab\x1BNdef'),
+        (b'\x1B$(O\x2E\x23\x1B(B', 'strict', '\u3402'      ),
+        (b'\x1B$(O\x2E\x22\x1B(B', 'strict', '\U0002000B'  ),
+        (b'\x1B$(O\x24\x77\x1B(B', 'strict', '\u304B\u309A'),
+        (b'\x1B$(P\x21\x22\x1B(B', 'strict', '\u4E02'      ),
+        (b'\x1B$(P\x7E\x76\x1B(B', 'strict', '\U0002A6B2'  ),
+        ('\u3402',       'strict', b'\x1B$(O\x2E\x23\x1B(B'),
+        ('\U0002000B',   'strict', b'\x1B$(O\x2E\x22\x1B(B'),
+        ('\u304B\u309A', 'strict', b'\x1B$(O\x24\x77\x1B(B'),
+        ('\u4E02',       'strict', b'\x1B$(P\x21\x22\x1B(B'),
+        ('\U0002A6B2',   'strict', b'\x1B$(P\x7E\x76\x1B(B'),
+        (b'ab\x1B$(O\x2E\x21\x1B(Bdef', 'replace', 'ab\uFFFDdef'),
+        ('ab\u4FF1def', 'replace', b'ab?def'),
+    )
+    xmlcharnametest = (
+        '\xAB\u211C\xBB = \u2329\u1234\u232A',
+        b'\x1B$(O\x29\x28\x1B(B&real;\x1B$(O\x29\x32\x1B(B = &lang;&#4660;&rang;'
+    )
+
+@unittest.skip("TODO: RUSTPYTHON; unknown encoding: iso2022_jp_2004")
+class Test_ISO2022_JP2004(multibytecodec_support.TestBase, unittest.TestCase):
+    encoding = 'iso2022_jp_2004'
+    tstring = multibytecodec_support.load_teststring('iso2022_jp')
+    codectests = COMMON_CODEC_TESTS + (
+        (b'ab\x1BNdef', 'replace', 'ab\x1BNdef'),
+        (b'\x1B$(Q\x2E\x23\x1B(B', 'strict', '\u3402'      ),
+        (b'\x1B$(Q\x2E\x22\x1B(B', 'strict', '\U0002000B'  ),
+        (b'\x1B$(Q\x24\x77\x1B(B', 'strict', '\u304B\u309A'),
+        (b'\x1B$(P\x21\x22\x1B(B', 'strict', '\u4E02'      ),
+        (b'\x1B$(P\x7E\x76\x1B(B', 'strict', '\U0002A6B2'  ),
+        ('\u3402',       'strict', b'\x1B$(Q\x2E\x23\x1B(B'),
+        ('\U0002000B',   'strict', b'\x1B$(Q\x2E\x22\x1B(B'),
+        ('\u304B\u309A', 'strict', b'\x1B$(Q\x24\x77\x1B(B'),
+        ('\u4E02',       'strict', b'\x1B$(P\x21\x22\x1B(B'),
+        ('\U0002A6B2',   'strict', b'\x1B$(P\x7E\x76\x1B(B'),
+        (b'ab\x1B$(Q\x2E\x21\x1B(Bdef', 'replace', 'ab\u4FF1def'),
+        ('ab\u4FF1def', 'replace', b'ab\x1B$(Q\x2E\x21\x1B(Bdef'),
+    )
+    xmlcharnametest = (
+        '\xAB\u211C\xBB = \u2329\u1234\u232A',
+        b'\x1B$(Q\x29\x28\x1B(B&real;\x1B$(Q\x29\x32\x1B(B = &lang;&#4660;&rang;'
+    )
+
+@unittest.skip("TODO: RUSTPYTHON; unknown encoding: iso2022_kr")
+class Test_ISO2022_KR(multibytecodec_support.TestBase, unittest.TestCase):
+    encoding = 'iso2022_kr'
+    tstring = multibytecodec_support.load_teststring('iso2022_kr')
+    codectests = COMMON_CODEC_TESTS + (
+        (b'ab\x1BNdef', 'replace', 'ab\x1BNdef'),
+    )
+
+    # iso2022_kr.txt cannot be used to test "chunk coding": the escape
+    # sequence is only written on the first line
+    @unittest.skip('iso2022_kr.txt cannot be used to test "chunk coding"')
+    def test_chunkcoding(self):
+        pass
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/Lib/test/test_codecencodings_jp.py b/Lib/test/test_codecencodings_jp.py
new file mode 100644
index 00000000000..f78ae229f84
--- /dev/null
+++ b/Lib/test/test_codecencodings_jp.py
@@ -0,0 +1,133 @@
+#
+# test_codecencodings_jp.py
+#   Codec encoding tests for Japanese encodings.
+#
+
+from test import multibytecodec_support
+import unittest
+
+@unittest.skip("TODO: RUSTPYTHON; unknown encoding: cp932")
+class Test_CP932(multibytecodec_support.TestBase, unittest.TestCase):
+    encoding = 'cp932'
+    tstring = multibytecodec_support.load_teststring('shift_jis')
+    codectests = (
+        # invalid bytes
+        (b"abc\x81\x00\x81\x00\x82\x84", "strict",  None),
+        (b"abc\xf8", "strict",  None),
+        (b"abc\x81\x00\x82\x84", "replace", "abc\ufffd\x00\uff44"),
+        (b"abc\x81\x00\x82\x84\x88", "replace", "abc\ufffd\x00\uff44\ufffd"),
+        (b"abc\x81\x00\x82\x84", "ignore",  "abc\x00\uff44"),
+        (b"ab\xEBxy", "replace", "ab\uFFFDxy"),
+        (b"ab\xF0\x39xy", "replace", "ab\uFFFD9xy"),
+        (b"ab\xEA\xF0xy", "replace", 'ab\ufffd\ue038y'),
+        # sjis vs cp932
+        (b"\\\x7e", "replace", "\\\x7e"),
+        (b"\x81\x5f\x81\x61\x81\x7c", "replace", "\uff3c\u2225\uff0d"),
+    )
+
+euc_commontests = (
+    # invalid bytes
+    (b"abc\x80\x80\xc1\xc4", "strict",  None),
+    (b"abc\x80\x80\xc1\xc4", "replace", "abc\ufffd\ufffd\u7956"),
+    (b"abc\x80\x80\xc1\xc4\xc8", "replace", "abc\ufffd\ufffd\u7956\ufffd"),
+    (b"abc\x80\x80\xc1\xc4", "ignore",  "abc\u7956"),
+    (b"abc\xc8", "strict",  None),
+    (b"abc\x8f\x83\x83", "replace", "abc\ufffd\ufffd\ufffd"),
+    (b"\x82\xFCxy", "replace", "\ufffd\ufffdxy"),
+    (b"\xc1\x64", "strict", None),
+    (b"\xa1\xc0", "strict", "\uff3c"),
+    (b"\xa1\xc0\\", "strict", "\uff3c\\"),
+    (b"\x8eXY", "replace", "\ufffdXY"),
+)
+
+@unittest.skip("TODO: RUSTPYTHON; unknown encoding: euc_jis_2004")
+class Test_EUC_JIS_2004(multibytecodec_support.TestBase,
+                        unittest.TestCase):
+    encoding = 'euc_jis_2004'
+    tstring = multibytecodec_support.load_teststring('euc_jisx0213')
+    codectests = euc_commontests
+    xmlcharnametest = (
+        "\xab\u211c\xbb = \u2329\u1234\u232a",
+        b"\xa9\xa8&real;\xa9\xb2 = &lang;&#4660;&rang;"
+    )
+
+@unittest.skip("TODO: RUSTPYTHON; unknown encoding: euc_jisx0213")
+class Test_EUC_JISX0213(multibytecodec_support.TestBase,
+                        unittest.TestCase):
+    encoding = 'euc_jisx0213'
+    tstring = multibytecodec_support.load_teststring('euc_jisx0213')
+    codectests = euc_commontests
+    xmlcharnametest = (
+        "\xab\u211c\xbb = \u2329\u1234\u232a",
+        b"\xa9\xa8&real;\xa9\xb2 = &lang;&#4660;&rang;"
+    )
+
+@unittest.skip("TODO: RUSTPYTHON; unknown encoding: euc_jp")
+class Test_EUC_JP_COMPAT(multibytecodec_support.TestBase,
+                         unittest.TestCase):
+    encoding = 'euc_jp'
+    tstring = multibytecodec_support.load_teststring('euc_jp')
+    codectests = euc_commontests + (
+        ("\xa5", "strict", b"\x5c"),
+        ("\u203e", "strict", b"\x7e"),
+    )
+
+shiftjis_commonenctests = (
+    (b"abc\x80\x80\x82\x84", "strict",  None),
+    (b"abc\xf8", "strict",  None),
+    (b"abc\x80\x80\x82\x84def", "ignore",  "abc\uff44def"),
+)
+
+@unittest.skip("TODO: RUSTPYTHON; unknown encoding: shift_jis")
+class Test_SJIS_COMPAT(multibytecodec_support.TestBase, unittest.TestCase):
+    encoding = 'shift_jis'
+    tstring = multibytecodec_support.load_teststring('shift_jis')
+    codectests = shiftjis_commonenctests + (
+        (b"abc\x80\x80\x82\x84", "replace", "abc\ufffd\ufffd\uff44"),
+        (b"abc\x80\x80\x82\x84\x88", "replace", "abc\ufffd\ufffd\uff44\ufffd"),
+
+        (b"\\\x7e", "strict", "\\\x7e"),
+        (b"\x81\x5f\x81\x61\x81\x7c", "strict", "\uff3c\u2016\u2212"),
+        (b"abc\x81\x39", "replace",  "abc\ufffd9"),
+        (b"abc\xEA\xFC", "replace",  "abc\ufffd\ufffd"),
+        (b"abc\xFF\x58", "replace",  "abc\ufffdX"),
+    )
+
+@unittest.skip("TODO: RUSTPYTHON; unknown encoding: shift_jis_2004")
+class Test_SJIS_2004(multibytecodec_support.TestBase, unittest.TestCase):
+    encoding = 'shift_jis_2004'
+    tstring = multibytecodec_support.load_teststring('shift_jis')
+    codectests = shiftjis_commonenctests + (
+        (b"\\\x7e", "strict", "\xa5\u203e"),
+        (b"\x81\x5f\x81\x61\x81\x7c", "strict", "\\\u2016\u2212"),
+        (b"abc\xEA\xFC", "strict",  "abc\u64bf"),
+        (b"\x81\x39xy", "replace",  "\ufffd9xy"),
+        (b"\xFF\x58xy", "replace",  "\ufffdXxy"),
+        (b"\x80\x80\x82\x84xy", "replace", "\ufffd\ufffd\uff44xy"),
+        (b"\x80\x80\x82\x84\x88xy", "replace", "\ufffd\ufffd\uff44\u5864y"),
+        (b"\xFC\xFBxy", "replace", '\ufffd\u95b4y'),
+    )
+    xmlcharnametest = (
+        "\xab\u211c\xbb = \u2329\u1234\u232a",
+        b"\x85G&real;\x85Q = &lang;&#4660;&rang;"
+    )
+
+@unittest.skip("TODO: RUSTPYTHON; unknown encoding: shift_jisx0213")
+class Test_SJISX0213(multibytecodec_support.TestBase, unittest.TestCase):
+    encoding = 'shift_jisx0213'
+    tstring = multibytecodec_support.load_teststring('shift_jisx0213')
+    codectests = shiftjis_commonenctests + (
+        (b"abc\x80\x80\x82\x84", "replace", "abc\ufffd\ufffd\uff44"),
+        (b"abc\x80\x80\x82\x84\x88", "replace", "abc\ufffd\ufffd\uff44\ufffd"),
+
+        # sjis vs cp932
+        (b"\\\x7e", "replace", "\xa5\u203e"),
+        (b"\x81\x5f\x81\x61\x81\x7c", "replace", "\x5c\u2016\u2212"),
+    )
+    xmlcharnametest = (
+        "\xab\u211c\xbb = \u2329\u1234\u232a",
+        b"\x85G&real;\x85Q = &lang;&#4660;&rang;"
+    )
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/Lib/test/test_codecencodings_kr.py b/Lib/test/test_codecencodings_kr.py
new file mode 100644
index 00000000000..aee124007ae
--- /dev/null
+++ b/Lib/test/test_codecencodings_kr.py
@@ -0,0 +1,72 @@
+#
+# test_codecencodings_kr.py
+#   Codec encoding tests for ROK encodings.
+#
+
+from test import multibytecodec_support
+import unittest
+
+@unittest.skip("TODO: RUSTPYTHON; unknown encoding: cp949")
+class Test_CP949(multibytecodec_support.TestBase, unittest.TestCase):
+    encoding = 'cp949'
+    tstring = multibytecodec_support.load_teststring('cp949')
+    codectests = (
+        # invalid bytes
+        (b"abc\x80\x80\xc1\xc4", "strict",  None),
+        (b"abc\xc8", "strict",  None),
+        (b"abc\x80\x80\xc1\xc4", "replace", "abc\ufffd\ufffd\uc894"),
+        (b"abc\x80\x80\xc1\xc4\xc8", "replace", "abc\ufffd\ufffd\uc894\ufffd"),
+        (b"abc\x80\x80\xc1\xc4", "ignore",  "abc\uc894"),
+    )
+
+@unittest.skip("TODO: RUSTPYTHON; unknown encoding: euc_kr")
+class Test_EUCKR(multibytecodec_support.TestBase, unittest.TestCase):
+    encoding = 'euc_kr'
+    tstring = multibytecodec_support.load_teststring('euc_kr')
+    codectests = (
+        # invalid bytes
+        (b"abc\x80\x80\xc1\xc4", "strict",  None),
+        (b"abc\xc8", "strict",  None),
+        (b"abc\x80\x80\xc1\xc4", "replace", 'abc\ufffd\ufffd\uc894'),
+        (b"abc\x80\x80\xc1\xc4\xc8", "replace", "abc\ufffd\ufffd\uc894\ufffd"),
+        (b"abc\x80\x80\xc1\xc4", "ignore",  "abc\uc894"),
+
+        # composed make-up sequence errors
+        (b"\xa4\xd4", "strict", None),
+        (b"\xa4\xd4\xa4", "strict", None),
+        (b"\xa4\xd4\xa4\xb6", "strict", None),
+        (b"\xa4\xd4\xa4\xb6\xa4", "strict", None),
+        (b"\xa4\xd4\xa4\xb6\xa4\xd0", "strict", None),
+        (b"\xa4\xd4\xa4\xb6\xa4\xd0\xa4", "strict", None),
+        (b"\xa4\xd4\xa4\xb6\xa4\xd0\xa4\xd4", "strict", "\uc4d4"),
+        (b"\xa4\xd4\xa4\xb6\xa4\xd0\xa4\xd4x", "strict", "\uc4d4x"),
+        (b"a\xa4\xd4\xa4\xb6\xa4", "replace", 'a\ufffd'),
+        (b"\xa4\xd4\xa3\xb6\xa4\xd0\xa4\xd4", "strict", None),
+        (b"\xa4\xd4\xa4\xb6\xa3\xd0\xa4\xd4", "strict", None),
+        (b"\xa4\xd4\xa4\xb6\xa4\xd0\xa3\xd4", "strict", None),
+        (b"\xa4\xd4\xa4\xff\xa4\xd0\xa4\xd4", "replace", '\ufffd\u6e21\ufffd\u3160\ufffd'),
+        (b"\xa4\xd4\xa4\xb6\xa4\xff\xa4\xd4", "replace", '\ufffd\u6e21\ub544\ufffd\ufffd'),
+        (b"\xa4\xd4\xa4\xb6\xa4\xd0\xa4\xff", "replace", '\ufffd\u6e21\ub544\u572d\ufffd'),
+        (b"\xa4\xd4\xff\xa4\xd4\xa4\xb6\xa4\xd0\xa4\xd4", "replace", '\ufffd\ufffd\ufffd\uc4d4'),
+        (b"\xc1\xc4", "strict", "\uc894"),
+    )
+
+@unittest.skip("TODO: RUSTPYTHON; unknown encoding: johab")
+class Test_JOHAB(multibytecodec_support.TestBase, unittest.TestCase):
+    encoding = 'johab'
+    tstring = multibytecodec_support.load_teststring('johab')
+    codectests = (
+        # invalid bytes
+        (b"abc\x80\x80\xc1\xc4", "strict",  None),
+        (b"abc\xc8", "strict",  None),
+        (b"abc\x80\x80\xc1\xc4", "replace", "abc\ufffd\ufffd\ucd27"),
+        (b"abc\x80\x80\xc1\xc4\xc8", "replace", "abc\ufffd\ufffd\ucd27\ufffd"),
+        (b"abc\x80\x80\xc1\xc4", "ignore",  "abc\ucd27"),
+        (b"\xD8abc", "replace",  "\uFFFDabc"),
+        (b"\xD8\xFFabc", "replace",  "\uFFFD\uFFFDabc"),
+        (b"\x84bxy", "replace",  "\uFFFDbxy"),
+        (b"\x8CBxy", "replace",  "\uFFFDBxy"),
+    )
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/Lib/test/test_codecencodings_tw.py b/Lib/test/test_codecencodings_tw.py
new file mode 100644
index 00000000000..ca56b23234e
--- /dev/null
+++ b/Lib/test/test_codecencodings_tw.py
@@ -0,0 +1,23 @@
+#
+# test_codecencodings_tw.py
+#   Codec encoding tests for ROC encodings.
+#
+
+from test import multibytecodec_support
+import unittest
+
+@unittest.skip("TODO: RUSTPYTHON; unknown encoding: big5")
+class Test_Big5(multibytecodec_support.TestBase, unittest.TestCase):
+    encoding = 'big5'
+    tstring = multibytecodec_support.load_teststring('big5')
+    codectests = (
+        # invalid bytes
+        (b"abc\x80\x80\xc1\xc4", "strict",  None),
+        (b"abc\xc8", "strict",  None),
+        (b"abc\x80\x80\xc1\xc4", "replace", "abc\ufffd\ufffd\u8b10"),
+        (b"abc\x80\x80\xc1\xc4\xc8", "replace", "abc\ufffd\ufffd\u8b10\ufffd"),
+        (b"abc\x80\x80\xc1\xc4", "ignore",  "abc\u8b10"),
+    )
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/Lib/test/test_codecmaps_cn.py b/Lib/test/test_codecmaps_cn.py
new file mode 100644
index 00000000000..de254c6f767
--- /dev/null
+++ b/Lib/test/test_codecmaps_cn.py
@@ -0,0 +1,38 @@
+#
+# test_codecmaps_cn.py
+#   Codec mapping tests for PRC encodings
+#
+
+from test import multibytecodec_support
+import unittest
+
+class TestGB2312Map(multibytecodec_support.TestBase_Mapping,
+                   unittest.TestCase):
+    encoding = 'gb2312'
+    mapfileurl = 'http://www.pythontest.net/unicode/EUC-CN.TXT'
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; LookupError: unknown encoding: gb2312
+    def test_mapping_file(self):
+        return super().test_mapping_file()
+
+class TestGBKMap(multibytecodec_support.TestBase_Mapping,
+                   unittest.TestCase):
+    encoding = 'gbk'
+    mapfileurl = 'http://www.pythontest.net/unicode/CP936.TXT'
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; LookupError: unknown encoding: gbk
+    def test_mapping_file(self):
+        return super().test_mapping_file()
+
+class TestGB18030Map(multibytecodec_support.TestBase_Mapping,
+                     unittest.TestCase):
+    encoding = 'gb18030'
+    mapfileurl = 'http://www.pythontest.net/unicode/gb-18030-2000.xml'
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; LookupError: unknown encoding: gb18030
+    def test_mapping_file(self):
+        return super().test_mapping_file()
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/Lib/test/test_codecmaps_hk.py b/Lib/test/test_codecmaps_hk.py
new file mode 100644
index 00000000000..f02cf486f76
--- /dev/null
+++ b/Lib/test/test_codecmaps_hk.py
@@ -0,0 +1,19 @@
+#
+# test_codecmaps_hk.py
+#   Codec mapping tests for HongKong encodings
+#
+
+from test import multibytecodec_support
+import unittest
+
+class TestBig5HKSCSMap(multibytecodec_support.TestBase_Mapping,
+                       unittest.TestCase):
+    encoding = 'big5hkscs'
+    mapfileurl = 'http://www.pythontest.net/unicode/BIG5HKSCS-2004.TXT'
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; LookupError: unknown encoding: big5hkscs
+    def test_mapping_file(self):
+        return super().test_mapping_file()
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/Lib/test/test_codecmaps_jp.py b/Lib/test/test_codecmaps_jp.py
new file mode 100644
index 00000000000..f2d52f99526
--- /dev/null
+++ b/Lib/test/test_codecmaps_jp.py
@@ -0,0 +1,84 @@
+#
+# test_codecmaps_jp.py
+#   Codec mapping tests for Japanese encodings
+#
+
+from test import multibytecodec_support
+import unittest
+
+class TestCP932Map(multibytecodec_support.TestBase_Mapping,
+                   unittest.TestCase):
+    encoding = 'cp932'
+    mapfileurl = 'http://www.pythontest.net/unicode/CP932.TXT'
+    supmaps = [
+        (b'\x80', '\u0080'),
+        (b'\xa0', '\uf8f0'),
+        (b'\xfd', '\uf8f1'),
+        (b'\xfe', '\uf8f2'),
+        (b'\xff', '\uf8f3'),
+    ]
+    for i in range(0xa1, 0xe0):
+        supmaps.append((bytes([i]), chr(i+0xfec0)))
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; LookupError: unknown encoding: cp932
+    def test_mapping_file(self):
+        return super().test_mapping_file()
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; LookupError: unknown encoding: cp932
+    def test_mapping_supplemental(self):
+        return super().test_mapping_supplemental()
+
+
+class TestEUCJPCOMPATMap(multibytecodec_support.TestBase_Mapping,
+                         unittest.TestCase):
+    encoding = 'euc_jp'
+    mapfilename = 'EUC-JP.TXT'
+    mapfileurl = 'http://www.pythontest.net/unicode/EUC-JP.TXT'
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; LookupError: unknown encoding: euc_jp
+    def test_mapping_file(self):
+        return super().test_mapping_file()
+
+
+class TestSJISCOMPATMap(multibytecodec_support.TestBase_Mapping,
+                        unittest.TestCase):
+    encoding = 'shift_jis'
+    mapfilename = 'SHIFTJIS.TXT'
+    mapfileurl = 'http://www.pythontest.net/unicode/SHIFTJIS.TXT'
+    pass_enctest = [
+        (b'\x81_', '\\'),
+    ]
+    pass_dectest = [
+        (b'\\', '\xa5'),
+        (b'~', '\u203e'),
+        (b'\x81_', '\\'),
+    ]
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; LookupError: unknown encoding: shift_jis
+    def test_mapping_file(self):
+        return super().test_mapping_file()
+
+class TestEUCJISX0213Map(multibytecodec_support.TestBase_Mapping,
+                         unittest.TestCase):
+    encoding = 'euc_jisx0213'
+    mapfilename = 'EUC-JISX0213.TXT'
+    mapfileurl = 'http://www.pythontest.net/unicode/EUC-JISX0213.TXT'
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; LookupError: unknown encoding: euc_jisx0213
+    def test_mapping_file(self):
+        return super().test_mapping_file()
+
+
+class TestSJISX0213Map(multibytecodec_support.TestBase_Mapping,
+                       unittest.TestCase):
+    encoding = 'shift_jisx0213'
+    mapfilename = 'SHIFT_JISX0213.TXT'
+    mapfileurl = 'http://www.pythontest.net/unicode/SHIFT_JISX0213.TXT'
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; LookupError: unknown encoding: shift_jisx0213
+    def test_mapping_file(self):
+        return super().test_mapping_file()
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/Lib/test/test_codecmaps_kr.py b/Lib/test/test_codecmaps_kr.py
new file mode 100644
index 00000000000..b8376d36615
--- /dev/null
+++ b/Lib/test/test_codecmaps_kr.py
@@ -0,0 +1,49 @@
+#
+# test_codecmaps_kr.py
+#   Codec mapping tests for ROK encodings
+#
+
+from test import multibytecodec_support
+import unittest
+
+class TestCP949Map(multibytecodec_support.TestBase_Mapping,
+                   unittest.TestCase):
+    encoding = 'cp949'
+    mapfileurl = 'http://www.pythontest.net/unicode/CP949.TXT'
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; LookupError: unknown encoding: cp949
+    def test_mapping_file(self):
+        return super().test_mapping_file()
+
+
+class TestEUCKRMap(multibytecodec_support.TestBase_Mapping,
+                   unittest.TestCase):
+    encoding = 'euc_kr'
+    mapfileurl = 'http://www.pythontest.net/unicode/EUC-KR.TXT'
+
+    # A4D4 HANGUL FILLER indicates the begin of 8-bytes make-up sequence.
+    pass_enctest = [(b'\xa4\xd4', '\u3164')]
+    pass_dectest = [(b'\xa4\xd4', '\u3164')]
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; LookupError: unknown encoding: euc_kr
+    def test_mapping_file(self):
+        return super().test_mapping_file()
+
+
+class TestJOHABMap(multibytecodec_support.TestBase_Mapping,
+                   unittest.TestCase):
+    encoding = 'johab'
+    mapfileurl = 'http://www.pythontest.net/unicode/JOHAB.TXT'
+    # KS X 1001 standard assigned 0x5c as WON SIGN.
+    # But the early 90s is the only era that used johab widely,
+    # most software implements it as REVERSE SOLIDUS.
+    # So, we ignore the standard here.
+    pass_enctest = [(b'\\', '\u20a9')]
+    pass_dectest = [(b'\\', '\u20a9')]
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; LookupError: unknown encoding: johab
+    def test_mapping_file(self):
+        return super().test_mapping_file()
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/Lib/test/test_codecmaps_tw.py b/Lib/test/test_codecmaps_tw.py
new file mode 100644
index 00000000000..4a1359ce7be
--- /dev/null
+++ b/Lib/test/test_codecmaps_tw.py
@@ -0,0 +1,39 @@
+#
+# test_codecmaps_tw.py
+#   Codec mapping tests for ROC encodings
+#
+
+from test import multibytecodec_support
+import unittest
+
+class TestBIG5Map(multibytecodec_support.TestBase_Mapping,
+                  unittest.TestCase):
+    encoding = 'big5'
+    mapfileurl = 'http://www.pythontest.net/unicode/BIG5.TXT'
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; LookupError: unknown encoding: big5
+    def test_mapping_file(self):
+        return super().test_mapping_file()
+
+class TestCP950Map(multibytecodec_support.TestBase_Mapping,
+                   unittest.TestCase):
+    encoding = 'cp950'
+    mapfileurl = 'http://www.pythontest.net/unicode/CP950.TXT'
+    pass_enctest = [
+        (b'\xa2\xcc', '\u5341'),
+        (b'\xa2\xce', '\u5345'),
+    ]
+    codectests = (
+        (b"\xFFxy", "replace",  "\ufffdxy"),
+    )
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; LookupError: unknown encoding: cp950
+    def test_errorhandle(self):
+        return super().test_errorhandle()
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; LookupError: unknown encoding: cp950
+    def test_mapping_file(self):
+        return super().test_mapping_file()
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/Lib/test/test_codecs.py b/Lib/test/test_codecs.py
index 736022599ed..fefd062eacb 100644
--- a/Lib/test/test_codecs.py
+++ b/Lib/test/test_codecs.py
@@ -1,12 +1,15 @@
 import codecs
 import contextlib
 import copy
+import importlib
 import io
 import pickle
+import os
 import sys
 import unittest
 import encodings
 from unittest import mock
+import warnings
 
 from test import support
 from test.support import os_helper
@@ -20,13 +23,12 @@
 except ImportError:
     _testinternalcapi = None
 
-try:
-    import ctypes
-except ImportError:
-    ctypes = None
-    SIZEOF_WCHAR_T = -1
-else:
-    SIZEOF_WCHAR_T = ctypes.sizeof(ctypes.c_wchar)
+
+def codecs_open_no_warn(*args, **kwargs):
+    """Call codecs.open(*args, **kwargs) ignoring DeprecationWarning."""
+    with warnings.catch_warnings():
+        warnings.simplefilter("ignore")
+        return codecs.open(*args, **kwargs)
 
 def coding_checker(self, coder):
     def check(input, expect):
@@ -35,13 +37,13 @@ def check(input, expect):
 
 # On small versions of Windows like Windows IoT or Windows Nano Server not all codepages are present
 def is_code_page_present(cp):
-    from ctypes import POINTER, WINFUNCTYPE, WinDLL
+    from ctypes import POINTER, WINFUNCTYPE, WinDLL, Structure
     from ctypes.wintypes import BOOL, BYTE, WCHAR, UINT, DWORD
 
     MAX_LEADBYTES = 12  # 5 ranges, 2 bytes ea., 0 term.
     MAX_DEFAULTCHAR = 2 # single or double byte
     MAX_PATH = 260
-    class CPINFOEXW(ctypes.Structure):
+    class CPINFOEXW(Structure):
         _fields_ = [("MaxCharSize", UINT),
                     ("DefaultChar", BYTE*MAX_DEFAULTCHAR),
                     ("LeadByte", BYTE*MAX_LEADBYTES),
@@ -388,7 +390,6 @@ def test_bug1098990_b(self):
 
     ill_formed_sequence_replace = "\ufffd"
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_lone_surrogates(self):
         self.assertRaises(UnicodeEncodeError, "\ud800".encode, self.encoding)
         self.assertEqual("[\uDC80]".encode(self.encoding, "backslashreplace"),
@@ -464,7 +465,6 @@ class UTF32Test(ReadTest, unittest.TestCase):
               b'\x00\x00\x00s\x00\x00\x00p\x00\x00\x00a\x00\x00\x00m'
               b'\x00\x00\x00s\x00\x00\x00p\x00\x00\x00a\x00\x00\x00m')
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_only_one_bom(self):
         _,_,reader,writer = codecs.lookup(self.encoding)
         # encode some stream
@@ -480,7 +480,6 @@ def test_only_one_bom(self):
         f = reader(s)
         self.assertEqual(f.read(), "spamspam")
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_badbom(self):
         s = io.BytesIO(4*b"\xff")
         f = codecs.getreader(self.encoding)(s)
@@ -490,7 +489,6 @@ def test_badbom(self):
         f = codecs.getreader(self.encoding)(s)
         self.assertRaises(UnicodeDecodeError, f.read)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_partial(self):
         self.check_partial(
             "\x00\xff\u0100\uffff\U00010000",
@@ -522,26 +520,22 @@ def test_partial(self):
             ]
         )
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_handlers(self):
         self.assertEqual(('\ufffd', 1),
                          codecs.utf_32_decode(b'\x01', 'replace', True))
         self.assertEqual(('', 1),
                          codecs.utf_32_decode(b'\x01', 'ignore', True))
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_errors(self):
         self.assertRaises(UnicodeDecodeError, codecs.utf_32_decode,
                           b"\xff", "strict", True)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_decoder_state(self):
         self.check_state_handling_decode(self.encoding,
                                          "spamspam", self.spamle)
         self.check_state_handling_decode(self.encoding,
                                          "spamspam", self.spambe)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_issue8941(self):
         # Issue #8941: insufficient result allocation when decoding into
         # surrogate pairs on UCS-2 builds.
@@ -552,40 +546,11 @@ def test_issue8941(self):
         self.assertEqual('\U00010000' * 1024,
                          codecs.utf_32_decode(encoded_be)[0])
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
-    def test_bug1098990_a(self):
-        return super().test_bug1098990_a()
-
-    @unittest.expectedFailure # TODO: RUSTPYTHON
-    def test_bug1098990_b(self):
-        return super().test_bug1098990_b()
-
-    @unittest.expectedFailure # TODO: RUSTPYTHON
-    def test_bug1175396(self):
-        return super().test_bug1175396()
-
-    @unittest.expectedFailure # TODO: RUSTPYTHON
-    def test_incremental_surrogatepass(self):
-        return super().test_incremental_surrogatepass()
-
-    @unittest.expectedFailure # TODO: RUSTPYTHON
-    def test_mixed_readline_and_read(self):
-        return super().test_mixed_readline_and_read()
-
-    @unittest.expectedFailure # TODO: RUSTPYTHON
-    def test_readline(self):
-        return super().test_readline()
-
-    @unittest.expectedFailure # TODO: RUSTPYTHON
-    def test_readlinequeue(self):
-        return super().test_readlinequeue()
-
 
 class UTF32LETest(ReadTest, unittest.TestCase):
     encoding = "utf-32-le"
     ill_formed_sequence = b"\x80\xdc\x00\x00"
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_partial(self):
         self.check_partial(
             "\x00\xff\u0100\uffff\U00010000",
@@ -613,16 +578,13 @@ def test_partial(self):
             ]
         )
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_simple(self):
         self.assertEqual("\U00010203".encode(self.encoding), b"\x03\x02\x01\x00")
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_errors(self):
         self.assertRaises(UnicodeDecodeError, codecs.utf_32_le_decode,
                           b"\xff", "strict", True)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_issue8941(self):
         # Issue #8941: insufficient result allocation when decoding into
         # surrogate pairs on UCS-2 builds.
@@ -630,40 +592,11 @@ def test_issue8941(self):
         self.assertEqual('\U00010000' * 1024,
                          codecs.utf_32_le_decode(encoded)[0])
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
-    def test_bug1098990_a(self):
-        return super().test_bug1098990_a()
-
-    @unittest.expectedFailure # TODO: RUSTPYTHON
-    def test_bug1098990_b(self):
-        return super().test_bug1098990_b()
-
-    @unittest.expectedFailure # TODO: RUSTPYTHON
-    def test_bug1175396(self):
-        return super().test_bug1175396()
-
-    @unittest.expectedFailure # TODO: RUSTPYTHON
-    def test_incremental_surrogatepass(self):
-        return super().test_incremental_surrogatepass()
-
-    @unittest.expectedFailure # TODO: RUSTPYTHON
-    def test_mixed_readline_and_read(self):
-        return super().test_mixed_readline_and_read()
-
-    @unittest.expectedFailure # TODO: RUSTPYTHON
-    def test_readline(self):
-        return super().test_readline()
-
-    @unittest.expectedFailure # TODO: RUSTPYTHON
-    def test_readlinequeue(self):
-        return super().test_readlinequeue()
-
 
 class UTF32BETest(ReadTest, unittest.TestCase):
     encoding = "utf-32-be"
     ill_formed_sequence = b"\x00\x00\xdc\x80"
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_partial(self):
         self.check_partial(
             "\x00\xff\u0100\uffff\U00010000",
@@ -691,16 +624,13 @@ def test_partial(self):
             ]
         )
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_simple(self):
         self.assertEqual("\U00010203".encode(self.encoding), b"\x00\x01\x02\x03")
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_errors(self):
         self.assertRaises(UnicodeDecodeError, codecs.utf_32_be_decode,
                           b"\xff", "strict", True)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_issue8941(self):
         # Issue #8941: insufficient result allocation when decoding into
         # surrogate pairs on UCS-2 builds.
@@ -708,34 +638,6 @@ def test_issue8941(self):
         self.assertEqual('\U00010000' * 1024,
                          codecs.utf_32_be_decode(encoded)[0])
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
-    def test_bug1098990_a(self):
-        return super().test_bug1098990_a()
-
-    @unittest.expectedFailure # TODO: RUSTPYTHON
-    def test_bug1098990_b(self):
-        return super().test_bug1098990_b()
-
-    @unittest.expectedFailure # TODO: RUSTPYTHON
-    def test_bug1175396(self):
-        return super().test_bug1175396()
-
-    @unittest.expectedFailure # TODO: RUSTPYTHON
-    def test_incremental_surrogatepass(self):
-        return super().test_incremental_surrogatepass()
-
-    @unittest.expectedFailure # TODO: RUSTPYTHON
-    def test_mixed_readline_and_read(self):
-        return super().test_mixed_readline_and_read()
-
-    @unittest.expectedFailure # TODO: RUSTPYTHON
-    def test_readline(self):
-        return super().test_readline()
-
-    @unittest.expectedFailure # TODO: RUSTPYTHON
-    def test_readlinequeue(self):
-        return super().test_readlinequeue()
-
 
 class UTF16Test(ReadTest, unittest.TestCase):
     encoding = "utf-16"
@@ -771,7 +673,6 @@ def test_badbom(self):
         f = codecs.getreader(self.encoding)(s)
         self.assertRaises(UnicodeDecodeError, f.read)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_partial(self):
         self.check_partial(
             "\x00\xff\u0100\uffff\U00010000",
@@ -793,7 +694,6 @@ def test_partial(self):
             ]
         )
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_handlers(self):
         self.assertEqual(('\ufffd', 1),
                          codecs.utf_16_decode(b'\x01', 'replace', True))
@@ -821,32 +721,27 @@ def test_bug691291(self):
         self.addCleanup(os_helper.unlink, os_helper.TESTFN)
         with open(os_helper.TESTFN, 'wb') as fp:
             fp.write(s)
-        with codecs.open(os_helper.TESTFN, 'r',
+        with codecs_open_no_warn(os_helper.TESTFN, 'r',
                          encoding=self.encoding) as reader:
             self.assertEqual(reader.read(), s1)
 
     def test_invalid_modes(self):
         for mode in ('U', 'rU', 'r+U'):
             with self.assertRaises(ValueError) as cm:
-                codecs.open(os_helper.TESTFN, mode, encoding=self.encoding)
+                codecs_open_no_warn(os_helper.TESTFN, mode, encoding=self.encoding)
             self.assertIn('invalid mode', str(cm.exception))
 
         for mode in ('rt', 'wt', 'at', 'r+t'):
             with self.assertRaises(ValueError) as cm:
-                codecs.open(os_helper.TESTFN, mode, encoding=self.encoding)
+                codecs_open_no_warn(os_helper.TESTFN, mode, encoding=self.encoding)
             self.assertIn("can't have text and binary mode at once",
                           str(cm.exception))
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
-    def test_incremental_surrogatepass(self):
-        return super().test_incremental_surrogatepass()
-
 
 class UTF16LETest(ReadTest, unittest.TestCase):
     encoding = "utf-16-le"
     ill_formed_sequence = b"\x80\xdc"
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_partial(self):
         self.check_partial(
             "\x00\xff\u0100\uffff\U00010000",
@@ -866,7 +761,6 @@ def test_partial(self):
             ]
         )
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_errors(self):
         tests = [
             (b'\xff', '\ufffd'),
@@ -888,15 +782,10 @@ def test_nonbmp(self):
         self.assertEqual(b'\x00\xd8\x03\xde'.decode(self.encoding),
                          "\U00010203")
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
-    def test_incremental_surrogatepass(self):
-        return super().test_incremental_surrogatepass()
-
 class UTF16BETest(ReadTest, unittest.TestCase):
     encoding = "utf-16-be"
     ill_formed_sequence = b"\xdc\x80"
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_partial(self):
         self.check_partial(
             "\x00\xff\u0100\uffff\U00010000",
@@ -916,7 +805,6 @@ def test_partial(self):
             ]
         )
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_errors(self):
         tests = [
             (b'\xff', '\ufffd'),
@@ -938,10 +826,6 @@ def test_nonbmp(self):
         self.assertEqual(b'\xd8\x00\xde\x03'.decode(self.encoding),
                          "\U00010203")
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
-    def test_incremental_surrogatepass(self):
-        return super().test_incremental_surrogatepass()
-
 class UTF8Test(ReadTest, unittest.TestCase):
     encoding = "utf-8"
     ill_formed_sequence = b"\xed\xb2\x80"
@@ -987,7 +871,6 @@ def test_decode_error(self):
                 self.assertEqual(data.decode(self.encoding, error_handler),
                                  expected)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_lone_surrogates(self):
         super().test_lone_surrogates()
         # not sure if this is making sense for
@@ -1040,7 +923,6 @@ def test_incremental_errors(self):
 class UTF7Test(ReadTest, unittest.TestCase):
     encoding = "utf-7"
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_ascii(self):
         # Set D (directly encoded characters)
         set_d = ('ABCDEFGHIJKLMNOPQRSTUVWXYZ'
@@ -1067,7 +949,6 @@ def test_ascii(self):
                          b'+AAAAAQACAAMABAAFAAYABwAIAAsADAAOAA8AEAARABIAEwAU'
                          b'ABUAFgAXABgAGQAaABsAHAAdAB4AHwBcAH4Afw-')
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_partial(self):
         self.check_partial(
             'a+-b\x00c\x80d\u0100e\U00010000f',
@@ -1107,7 +988,6 @@ def test_partial(self):
             ]
         )
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_errors(self):
         tests = [
             (b'\xffb', '\ufffdb'),
@@ -1138,7 +1018,6 @@ def test_errors(self):
                                 raw, 'strict', True)
                 self.assertEqual(raw.decode('utf-7', 'replace'), expected)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_nonbmp(self):
         self.assertEqual('\U000104A0'.encode(self.encoding), b'+2AHcoA-')
         self.assertEqual('\ud801\udca0'.encode(self.encoding), b'+2AHcoA-')
@@ -1154,7 +1033,6 @@ def test_nonbmp(self):
         self.assertEqual(b'+IKwgrNgB3KA'.decode(self.encoding),
                          '\u20ac\u20ac\U000104A0')
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_lone_surrogates(self):
         tests = [
             (b'a+2AE-b', 'a\ud801b'),
@@ -1175,18 +1053,6 @@ def test_lone_surrogates(self):
             with self.subTest(raw=raw):
                 self.assertEqual(raw.decode('utf-7', 'replace'), expected)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
-    def test_bug1175396(self):
-        return super().test_bug1175396()
-
-    @unittest.expectedFailure # TODO: RUSTPYTHON
-    def test_incremental_surrogatepass(self):
-        return super().test_incremental_surrogatepass()
-
-    @unittest.expectedFailure # TODO: RUSTPYTHON
-    def test_readline(self):
-        return super().test_readline()
-
 
 class UTF16ExTest(unittest.TestCase):
 
@@ -1310,7 +1176,6 @@ def test_raw(self):
             if b != b'\\':
                 self.assertEqual(decode(b + b'0'), (b + b'0', 2))
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_escape(self):
         decode = codecs.escape_decode
         check = coding_checker(self, decode)
@@ -1334,7 +1199,7 @@ def test_escape(self):
         check(br"[\x41]", b"[A]")
         check(br"[\x410]", b"[A0]")
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON; DeprecationWarning not triggered
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; DeprecationWarning not triggered
     def test_warnings(self):
         decode = codecs.escape_decode
         check = coding_checker(self, decode)
@@ -1342,32 +1207,31 @@ def test_warnings(self):
             b = bytes([i])
             if b not in b'abfnrtvx':
                 with self.assertWarnsRegex(DeprecationWarning,
-                        r"invalid escape sequence '\\%c'" % i):
+                        r'"\\%c" is an invalid escape sequence' % i):
                     check(b"\\" + b, b"\\" + b)
             with self.assertWarnsRegex(DeprecationWarning,
-                    r"invalid escape sequence '\\%c'" % (i-32)):
+                    r'"\\%c" is an invalid escape sequence' % (i-32)):
                 check(b"\\" + b.upper(), b"\\" + b.upper())
         with self.assertWarnsRegex(DeprecationWarning,
-                r"invalid escape sequence '\\8'"):
+                r'"\\8" is an invalid escape sequence'):
             check(br"\8", b"\\8")
         with self.assertWarns(DeprecationWarning):
             check(br"\9", b"\\9")
         with self.assertWarnsRegex(DeprecationWarning,
-                r"invalid escape sequence '\\\xfa'") as cm:
+                r'"\\\xfa" is an invalid escape sequence') as cm:
             check(b"\\\xfa", b"\\\xfa")
         for i in range(0o400, 0o1000):
             with self.assertWarnsRegex(DeprecationWarning,
-                    r"invalid octal escape sequence '\\%o'" % i):
+                    r'"\\%o" is an invalid octal escape sequence' % i):
                 check(rb'\%o' % i, bytes([i & 0o377]))
 
         with self.assertWarnsRegex(DeprecationWarning,
-                r"invalid escape sequence '\\z'"):
+                r'"\\z" is an invalid escape sequence'):
             self.assertEqual(decode(br'\x\z', 'ignore'), (b'\\z', 4))
         with self.assertWarnsRegex(DeprecationWarning,
-                r"invalid octal escape sequence '\\501'"):
+                r'"\\501" is an invalid octal escape sequence'):
             self.assertEqual(decode(br'\x\501', 'ignore'), (b'A', 6))
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON; ValueError: not raised by escape_decode
     def test_errors(self):
         decode = codecs.escape_decode
         self.assertRaises(ValueError, decode, br"\x")
@@ -1999,9 +1863,9 @@ def test_all(self):
     def test_open(self):
         self.addCleanup(os_helper.unlink, os_helper.TESTFN)
         for mode in ('w', 'r', 'r+', 'w+', 'a', 'a+'):
-            with self.subTest(mode), \
-                    codecs.open(os_helper.TESTFN, mode, 'ascii') as file:
-                self.assertIsInstance(file, codecs.StreamReaderWriter)
+            with self.subTest(mode), self.assertWarns(DeprecationWarning):
+                with codecs.open(os_helper.TESTFN, mode, 'ascii') as file:
+                    self.assertIsInstance(file, codecs.StreamReaderWriter)
 
     def test_undefined(self):
         self.assertRaises(UnicodeError, codecs.encode, 'abc', 'undefined')
@@ -2018,7 +1882,7 @@ def test_file_closes_if_lookup_error_raised(self):
         mock_open = mock.mock_open()
         with mock.patch('builtins.open', mock_open) as file:
             with self.assertRaises(LookupError):
-                codecs.open(os_helper.TESTFN, 'wt', 'invalid-encoding')
+                codecs_open_no_warn(os_helper.TESTFN, 'wt', 'invalid-encoding')
 
             file().close.assert_called()
 
@@ -2291,7 +2155,7 @@ def test_basic(self):
 
 
 class BasicUnicodeTest(unittest.TestCase, MixInCheckStateHandling):
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; LookupError: unknown encoding: big5
     def test_basics(self):
         s = "abc123"  # all codecs should be able to encode these
         for encoding in all_unicode_encodings:
@@ -2411,7 +2275,7 @@ def test_basics_capi(self):
                         self.assertEqual(decodedresult, s,
                                          "encoding=%r" % encoding)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; LookupError: unknown encoding: big5
     def test_seek(self):
         # all codecs should be able to encode these
         s = "%s\n%s\n" % (100*"abc123", 100*"def456")
@@ -2427,7 +2291,7 @@ def test_seek(self):
                 data = reader.read()
                 self.assertEqual(s, data)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; LookupError: unknown encoding: big5
     def test_bad_decode_args(self):
         for encoding in all_unicode_encodings:
             decoder = codecs.getdecoder(encoding)
@@ -2435,7 +2299,7 @@ def test_bad_decode_args(self):
             if encoding not in ("idna", "punycode"):
                 self.assertRaises(TypeError, decoder, 42)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; LookupError: unknown encoding: big5
     def test_bad_encode_args(self):
         for encoding in all_unicode_encodings:
             encoder = codecs.getencoder(encoding)
@@ -2447,7 +2311,7 @@ def test_encoding_map_type_initialized(self):
         table_type = type(cp1140.encoding_table)
         self.assertEqual(table_type, table_type)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; LookupError: unknown encoding: big5
     def test_decoder_state(self):
         # Check that getstate() and setstate() handle the state properly
         u = "abc123"
@@ -2458,7 +2322,6 @@ def test_decoder_state(self):
 
 
 class CharmapTest(unittest.TestCase):
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_decode_with_string_map(self):
         self.assertEqual(
             codecs.charmap_decode(b"\x00\x01\x02", "strict", "abc"),
@@ -2514,7 +2377,6 @@ def test_decode_with_string_map(self):
             ("", len(allbytes))
         )
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_decode_with_int2str_map(self):
         self.assertEqual(
             codecs.charmap_decode(b"\x00\x01\x02", "strict",
@@ -2631,7 +2493,6 @@ def test_decode_with_int2str_map(self):
             b"\x00\x01\x02", "strict", {0: "A", 1: 'Bb', 2: 999999999}
         )
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_decode_with_int2int_map(self):
         a = ord('a')
         b = ord('b')
@@ -2724,7 +2585,7 @@ def test_streamreaderwriter(self):
 
 
 class TypesTest(unittest.TestCase):
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AttributeError: module 'codecs' has no attribute 'utf_32_ex_decode'. Did you mean: 'utf_16_ex_decode'?
     def test_decode_unicode(self):
         # Most decoders don't accept unicode input
         decoders = [
@@ -2826,7 +2687,7 @@ def test_escape_decode(self):
         check(br"\u20ac", "\u20ac")
         check(br"\U0001d120", "\U0001d120")
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON; DeprecationWarning not triggered
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; DeprecationWarning not triggered
     def test_decode_warnings(self):
         decode = codecs.unicode_escape_decode
         check = coding_checker(self, decode)
@@ -2834,30 +2695,30 @@ def test_decode_warnings(self):
             b = bytes([i])
             if b not in b'abfnrtuvx':
                 with self.assertWarnsRegex(DeprecationWarning,
-                        r"invalid escape sequence '\\%c'" % i):
+                        r'"\\%c" is an invalid escape sequence' % i):
                     check(b"\\" + b, "\\" + chr(i))
             if b.upper() not in b'UN':
                 with self.assertWarnsRegex(DeprecationWarning,
-                        r"invalid escape sequence '\\%c'" % (i-32)):
+                        r'"\\%c" is an invalid escape sequence' % (i-32)):
                     check(b"\\" + b.upper(), "\\" + chr(i-32))
         with self.assertWarnsRegex(DeprecationWarning,
-                r"invalid escape sequence '\\8'"):
+                r'"\\8" is an invalid escape sequence'):
             check(br"\8", "\\8")
         with self.assertWarns(DeprecationWarning):
             check(br"\9", "\\9")
         with self.assertWarnsRegex(DeprecationWarning,
-                r"invalid escape sequence '\\\xfa'") as cm:
+                r'"\\\xfa" is an invalid escape sequence') as cm:
             check(b"\\\xfa", "\\\xfa")
         for i in range(0o400, 0o1000):
             with self.assertWarnsRegex(DeprecationWarning,
-                    r"invalid octal escape sequence '\\%o'" % i):
+                    r'"\\%o" is an invalid octal escape sequence' % i):
                 check(rb'\%o' % i, chr(i))
 
         with self.assertWarnsRegex(DeprecationWarning,
-                r"invalid escape sequence '\\z'"):
+                r'"\\z" is an invalid escape sequence'):
             self.assertEqual(decode(br'\x\z', 'ignore'), ('\\z', 4))
         with self.assertWarnsRegex(DeprecationWarning,
-                r"invalid octal escape sequence '\\501'"):
+                r'"\\501" is an invalid octal escape sequence'):
             self.assertEqual(decode(br'\x\501', 'ignore'), ('\u0141', 6))
 
     def test_decode_errors(self):
@@ -2876,7 +2737,6 @@ def test_decode_errors(self):
         self.assertEqual(decode(br"\U00110000", "ignore"), ("", 10))
         self.assertEqual(decode(br"\U00110000", "replace"), ("\ufffd", 10))
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON; AssertionError: '\x00\t\n\r\\' != '\x00\t\n\r'
     def test_partial(self):
         self.check_partial(
             "\x00\t\n\r\\\xff\uffff\U00010000",
@@ -2916,14 +2776,10 @@ def test_partial(self):
             ]
         )
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; IndexError: index out of range
     def test_incremental_surrogatepass(self):
         return super().test_incremental_surrogatepass()
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
-    def test_readline(self):
-        return super().test_readline()
-
 class RawUnicodeEscapeTest(ReadTest, unittest.TestCase):
     encoding = "raw-unicode-escape"
 
@@ -2977,7 +2833,6 @@ def test_decode_errors(self):
         self.assertEqual(decode(br"\U00110000", "ignore"), ("", 10))
         self.assertEqual(decode(br"\U00110000", "replace"), ("\ufffd", 10))
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_partial(self):
         self.check_partial(
             "\x00\t\n\r\\\xff\uffff\U00010000",
@@ -3007,14 +2862,6 @@ def test_partial(self):
             ]
         )
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
-    def test_incremental_surrogatepass(self):
-        return super().test_incremental_surrogatepass()
-
-    @unittest.expectedFailure # TODO: RUSTPYTHON
-    def test_readline(self):
-        return super().test_readline()
-
 
 class EscapeEncodeTest(unittest.TestCase):
 
@@ -3057,7 +2904,6 @@ def test_ascii(self):
         self.assertEqual("foo\udc80bar".encode("ascii", "surrogateescape"),
                          b"foo\x80bar")
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_charmap(self):
         # bad byte: \xa5 is unmapped in iso-8859-3
         self.assertEqual(b"foo\xa5bar".decode("iso-8859-3", "surrogateescape"),
@@ -3072,7 +2918,6 @@ def test_latin1(self):
 
 
 class BomTest(unittest.TestCase):
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_seek0(self):
         data = "1234567890"
         tests = ("utf-16",
@@ -3084,7 +2929,7 @@ def test_seek0(self):
         self.addCleanup(os_helper.unlink, os_helper.TESTFN)
         for encoding in tests:
             # Check if the BOM is written only once
-            with codecs.open(os_helper.TESTFN, 'w+', encoding=encoding) as f:
+            with codecs_open_no_warn(os_helper.TESTFN, 'w+', encoding=encoding) as f:
                 f.write(data)
                 f.write(data)
                 f.seek(0)
@@ -3093,7 +2938,7 @@ def test_seek0(self):
                 self.assertEqual(f.read(), data * 2)
 
             # Check that the BOM is written after a seek(0)
-            with codecs.open(os_helper.TESTFN, 'w+', encoding=encoding) as f:
+            with codecs_open_no_warn(os_helper.TESTFN, 'w+', encoding=encoding) as f:
                 f.write(data[0])
                 self.assertNotEqual(f.tell(), 0)
                 f.seek(0)
@@ -3102,7 +2947,7 @@ def test_seek0(self):
                 self.assertEqual(f.read(), data)
 
             # (StreamWriter) Check that the BOM is written after a seek(0)
-            with codecs.open(os_helper.TESTFN, 'w+', encoding=encoding) as f:
+            with codecs_open_no_warn(os_helper.TESTFN, 'w+', encoding=encoding) as f:
                 f.writer.write(data[0])
                 self.assertNotEqual(f.writer.tell(), 0)
                 f.writer.seek(0)
@@ -3112,7 +2957,7 @@ def test_seek0(self):
 
             # Check that the BOM is not written after a seek() at a position
             # different than the start
-            with codecs.open(os_helper.TESTFN, 'w+', encoding=encoding) as f:
+            with codecs_open_no_warn(os_helper.TESTFN, 'w+', encoding=encoding) as f:
                 f.write(data)
                 f.seek(f.tell())
                 f.write(data)
@@ -3121,7 +2966,7 @@ def test_seek0(self):
 
             # (StreamWriter) Check that the BOM is not written after a seek()
             # at a position different than the start
-            with codecs.open(os_helper.TESTFN, 'w+', encoding=encoding) as f:
+            with codecs_open_no_warn(os_helper.TESTFN, 'w+', encoding=encoding) as f:
                 f.writer.write(data)
                 f.writer.seek(f.writer.tell())
                 f.writer.write(data)
@@ -3152,7 +2997,7 @@ def test_seek0(self):
     bytes_transform_encodings.append("zlib_codec")
     transform_aliases["zlib_codec"] = ["zip", "zlib"]
 try:
-    import bz2
+    import bz2  # noqa: F401
 except ImportError:
     pass
 else:
@@ -3251,7 +3096,6 @@ def test_binary_to_text_denylists_text_transforms(self):
                     bad_input.decode("rot_13")
                 self.assertIsNone(failure.exception.__cause__)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     @unittest.skipUnless(zlib, "Requires zlib support")
     def test_custom_zlib_error_is_noted(self):
         # Check zlib codec gives a good error for malformed input
@@ -3260,7 +3104,6 @@ def test_custom_zlib_error_is_noted(self):
             codecs.decode(b"hello", "zlib_codec")
         self.assertEqual(msg, failure.exception.__notes__[0])
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON; - AttributeError: 'Error' object has no attribute '__notes__'
     def test_custom_hex_error_is_noted(self):
         # Check hex codec gives a good error for malformed input
         import binascii
@@ -3278,6 +3121,13 @@ def test_aliases(self):
                     info = codecs.lookup(alias)
                     self.assertEqual(info.name, expected_name)
 
+    def test_alias_modules_exist(self):
+        encodings_dir = os.path.dirname(encodings.__file__)
+        for value in encodings.aliases.aliases.values():
+            codec_mod = f"encodings.{value}"
+            self.assertIsNotNone(importlib.util.find_spec(codec_mod),
+                                 f"Codec module not found: {codec_mod}")
+
     def test_quopri_stateless(self):
         # Should encode with quotetabs=True
         encoded = codecs.encode(b"space tab\teol \n", "quopri-codec")
@@ -3341,7 +3191,6 @@ def raise_obj(self, *args, **kwds):
         # Helper to dynamically change the object raised by a test codec
         raise self.obj_to_raise
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def check_note(self, obj_to_raise, msg, exc_type=RuntimeError):
         self.obj_to_raise = obj_to_raise
         self.set_codec(self.raise_obj, self.raise_obj)
@@ -3354,55 +3203,46 @@ def check_note(self, obj_to_raise, msg, exc_type=RuntimeError):
         with self.assertNoted("decoding", exc_type, msg):
             codecs.decode(b"bytes input", self.codec_name)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_raise_by_type(self):
         self.check_note(RuntimeError, "")
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_raise_by_value(self):
         msg = "This should be noted"
         self.check_note(RuntimeError(msg), msg)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_raise_grandchild_subclass_exact_size(self):
         msg = "This should be noted"
         class MyRuntimeError(RuntimeError):
             __slots__ = ()
         self.check_note(MyRuntimeError(msg), msg, MyRuntimeError)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_raise_subclass_with_weakref_support(self):
         msg = "This should be noted"
         class MyRuntimeError(RuntimeError):
             pass
         self.check_note(MyRuntimeError(msg), msg, MyRuntimeError)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_init_override(self):
         class CustomInit(RuntimeError):
             def __init__(self):
                 pass
         self.check_note(CustomInit, "")
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_new_override(self):
         class CustomNew(RuntimeError):
             def __new__(cls):
                 return super().__new__(cls)
         self.check_note(CustomNew, "")
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_instance_attribute(self):
         msg = "This should be noted"
         exc = RuntimeError(msg)
         exc.attr = 1
         self.check_note(exc, "^{}$".format(msg))
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_non_str_arg(self):
         self.check_note(RuntimeError(1), "1")
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_multiple_args(self):
         msg_re = r"^\('a', 'b', 'c'\)$"
         self.check_note(RuntimeError('a', 'b', 'c'), msg_re)
@@ -3419,7 +3259,6 @@ def test_codec_lookup_failure(self):
         with self.assertRaisesRegex(LookupError, msg):
             codecs.decode(b"bytes input", self.codec_name)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON;
     def test_unflagged_non_text_codec_handling(self):
         # The stdlib non-text codecs are now marked so they're
         # pre-emptively skipped by the text model related methods
@@ -3455,14 +3294,12 @@ def decode_to_bytes(*args, **kwds):
 class CodePageTest(unittest.TestCase):
     CP_UTF8 = 65001
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_invalid_code_page(self):
         self.assertRaises(ValueError, codecs.code_page_encode, -1, 'a')
         self.assertRaises(ValueError, codecs.code_page_decode, -1, b'a')
         self.assertRaises(OSError, codecs.code_page_encode, 123, 'a')
         self.assertRaises(OSError, codecs.code_page_decode, 123, b'a')
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_code_page_name(self):
         self.assertRaisesRegex(UnicodeEncodeError, 'cp932',
             codecs.code_page_encode, 932, '\xff')
@@ -3472,7 +3309,11 @@ def test_code_page_name(self):
             codecs.code_page_decode, self.CP_UTF8, b'\xff', 'strict', True)
 
     def check_decode(self, cp, tests):
-        for raw, errors, expected in tests:
+        for raw, errors, expected, *rest in tests:
+            if rest:
+                altexpected, = rest
+            else:
+                altexpected = expected
             if expected is not None:
                 try:
                     decoded = codecs.code_page_decode(cp, raw, errors, True)
@@ -3489,8 +3330,21 @@ def check_decode(self, cp, tests):
                 self.assertRaises(UnicodeDecodeError,
                     codecs.code_page_decode, cp, raw, errors, True)
 
+            if altexpected is not None:
+                decoded = raw.decode(f'cp{cp}', errors)
+                self.assertEqual(decoded, altexpected,
+                    '%a.decode("cp%s", %r)=%a != %a'
+                    % (raw, cp, errors, decoded, altexpected))
+            else:
+                self.assertRaises(UnicodeDecodeError,
+                    raw.decode, f'cp{cp}', errors)
+
     def check_encode(self, cp, tests):
-        for text, errors, expected in tests:
+        for text, errors, expected, *rest in tests:
+            if rest:
+                altexpected, = rest
+            else:
+                altexpected = expected
             if expected is not None:
                 try:
                     encoded = codecs.code_page_encode(cp, text, errors)
@@ -3501,19 +3355,27 @@ def check_encode(self, cp, tests):
                     '%a.encode("cp%s", %r)=%a != %a'
                     % (text, cp, errors, encoded[0], expected))
                 self.assertEqual(encoded[1], len(text))
+
+                encoded = text.encode(f'cp{cp}', errors)
+                self.assertEqual(encoded, altexpected,
+                    '%a.encode("cp%s", %r)=%a != %a'
+                    % (text, cp, errors, encoded, altexpected))
             else:
                 self.assertRaises(UnicodeEncodeError,
                     codecs.code_page_encode, cp, text, errors)
+                self.assertRaises(UnicodeEncodeError,
+                    text.encode, f'cp{cp}', errors)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_cp932(self):
         self.check_encode(932, (
             ('abc', 'strict', b'abc'),
             ('\uff44\u9a3e', 'strict', b'\x82\x84\xe9\x80'),
+            ('\uf8f3', 'strict', b'\xff'),
             # test error handlers
             ('\xff', 'strict', None),
             ('[\xff]', 'ignore', b'[]'),
-            ('[\xff]', 'replace', b'[y]'),
+            ('[\xff]', 'replace', b'[y]', b'[?]'),
             ('[\u20ac]', 'replace', b'[?]'),
             ('[\xff]', 'backslashreplace', b'[\\xff]'),
             ('[\xff]', 'namereplace',
@@ -3527,19 +3389,18 @@ def test_cp932(self):
             (b'abc', 'strict', 'abc'),
             (b'\x82\x84\xe9\x80', 'strict', '\uff44\u9a3e'),
             # invalid bytes
-            (b'[\xff]', 'strict', None),
-            (b'[\xff]', 'ignore', '[]'),
-            (b'[\xff]', 'replace', '[\ufffd]'),
-            (b'[\xff]', 'backslashreplace', '[\\xff]'),
-            (b'[\xff]', 'surrogateescape', '[\udcff]'),
-            (b'[\xff]', 'surrogatepass', None),
+            (b'[\xff]', 'strict', None, '[\uf8f3]'),
+            (b'[\xff]', 'ignore', '[]', '[\uf8f3]'),
+            (b'[\xff]', 'replace', '[\ufffd]', '[\uf8f3]'),
+            (b'[\xff]', 'backslashreplace', '[\\xff]', '[\uf8f3]'),
+            (b'[\xff]', 'surrogateescape', '[\udcff]', '[\uf8f3]'),
+            (b'[\xff]', 'surrogatepass', None, '[\uf8f3]'),
             (b'\x81\x00abc', 'strict', None),
             (b'\x81\x00abc', 'ignore', '\x00abc'),
             (b'\x81\x00abc', 'replace', '\ufffd\x00abc'),
             (b'\x81\x00abc', 'backslashreplace', '\\x81\x00abc'),
         ))
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_cp1252(self):
         self.check_encode(1252, (
             ('abc', 'strict', b'abc'),
@@ -3548,7 +3409,7 @@ def test_cp1252(self):
             # test error handlers
             ('\u0141', 'strict', None),
             ('\u0141', 'ignore', b''),
-            ('\u0141', 'replace', b'L'),
+            ('\u0141', 'replace', b'L', b'?'),
             ('\udc98', 'surrogateescape', b'\x98'),
             ('\udc98', 'surrogatepass', None),
         ))
@@ -3558,7 +3419,60 @@ def test_cp1252(self):
             (b'\xff', 'strict', '\xff'),
         ))
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    def test_cp708(self):
+        self.check_encode(708, (
+            ('abc2%', 'strict', b'abc2%'),
+            ('\u060c\u0621\u064a', 'strict',  b'\xac\xc1\xea'),
+            ('\u2562\xe7\xa0', 'strict',  b'\x86\x87\xff'),
+            ('\x9a\x9f', 'strict', b'\x9a\x9f'),
+            ('\u256b', 'strict', b'\xc0'),
+            # test error handlers
+            ('[\u0662]', 'strict',  None),
+            ('[\u0662]', 'ignore',  b'[]'),
+            ('[\u0662]', 'replace',  b'[?]'),
+            ('\udca0', 'surrogateescape', b'\xa0'),
+            ('\udca0', 'surrogatepass', None),
+        ))
+        self.check_decode(708, (
+            (b'abc2%', 'strict', 'abc2%'),
+            (b'\xac\xc1\xea', 'strict', '\u060c\u0621\u064a'),
+            (b'\x86\x87\xff', 'strict', '\u2562\xe7\xa0'),
+            (b'\x9a\x9f', 'strict', '\x9a\x9f'),
+            (b'\xc0', 'strict', '\u256b'),
+            # test error handlers
+            (b'\xa0', 'strict', None),
+            (b'[\xa0]', 'ignore', '[]'),
+            (b'[\xa0]', 'replace', '[\ufffd]'),
+            (b'[\xa0]', 'backslashreplace', '[\\xa0]'),
+            (b'[\xa0]', 'surrogateescape', '[\udca0]'),
+            (b'[\xa0]', 'surrogatepass', None),
+        ))
+
+    def test_cp20106(self):
+        self.check_encode(20106, (
+            ('abc', 'strict', b'abc'),
+            ('\xa7\xc4\xdf', 'strict',  b'@[~'),
+            # test error handlers
+            ('@', 'strict', None),
+            ('@', 'ignore', b''),
+            ('@', 'replace', b'?'),
+            ('\udcbf', 'surrogateescape', b'\xbf'),
+            ('\udcbf', 'surrogatepass', None),
+        ))
+        self.check_decode(20106, (
+            (b'abc', 'strict', 'abc'),
+            (b'@[~', 'strict', '\xa7\xc4\xdf'),
+            (b'\xe1\xfe', 'strict', 'a\xdf'),
+            # test error handlers
+            (b'(\xbf)', 'strict', None),
+            (b'(\xbf)', 'ignore', '()'),
+            (b'(\xbf)', 'replace', '(\ufffd)'),
+            (b'(\xbf)', 'backslashreplace', '(\\xbf)'),
+            (b'(\xbf)', 'surrogateescape', '(\udcbf)'),
+            (b'(\xbf)', 'surrogatepass', None),
+        ))
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; # TODO: RUSTPYTHON
     def test_cp_utf7(self):
         cp = 65000
         self.check_encode(cp, (
@@ -3579,7 +3493,6 @@ def test_cp_utf7(self):
             (b'[\xff]', 'strict', '[\xff]'),
         ))
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_multibyte_encoding(self):
         self.check_decode(932, (
             (b'\x84\xe9\x80', 'ignore', '\u9a3e'),
@@ -3594,7 +3507,6 @@ def test_multibyte_encoding(self):
             ('[\U0010ffff\uDC80]', 'replace', b'[\xf4\x8f\xbf\xbf?]'),
         ))
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_code_page_decode_flags(self):
         # Issue #36312: For some code pages (e.g. UTF-7) flags for
         # MultiByteToWideChar() must be set to 0.
@@ -3614,7 +3526,6 @@ def test_code_page_decode_flags(self):
         self.assertEqual(codecs.code_page_decode(42, b'abc'),
                          ('\uf061\uf062\uf063', 3))
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_incremental(self):
         decoded = codecs.code_page_decode(932, b'\x82', 'strict', False)
         self.assertEqual(decoded, ('', 0))
@@ -3634,17 +3545,15 @@ def test_incremental(self):
                                           False)
         self.assertEqual(decoded, ('abc', 3))
 
-    def test_mbcs_alias(self):
-        # Check that looking up our 'default' codepage will return
-        # mbcs when we don't have a more specific one available
-        code_page = 99_999
-        name = f'cp{code_page}'
-        with mock.patch('_winapi.GetACP', return_value=code_page):
-            try:
-                codec = codecs.lookup(name)
-                self.assertEqual(codec.name, 'mbcs')
-            finally:
-                codecs.unregister(name)
+    def test_mbcs_code_page(self):
+        # Check that codec for the current Windows (ANSII) code page is
+        # always available.
+        try:
+            from _winapi import GetACP
+        except ImportError:
+            self.skipTest('requires _winapi.GetACP')
+        cp = GetACP()
+        codecs.lookup(f'cp{cp}')
 
     @support.bigmemtest(size=2**31, memuse=7, dry_run=False)
     def test_large_input(self, size):
@@ -3908,7 +3817,7 @@ def check_decode_strings(self, errors):
                     with self.assertRaises(RuntimeError) as cm:
                         self.decode(encoded, errors)
                     errmsg = str(cm.exception)
-                    self.assertTrue(errmsg.startswith("decode error: "), errmsg)
+                    self.assertStartsWith(errmsg, "decode error: ")
                 else:
                     decoded = self.decode(encoded, errors)
                     self.assertEqual(decoded, expected)
@@ -3977,7 +3886,6 @@ def test_rot13_func(self):
 
 class CodecNameNormalizationTest(unittest.TestCase):
     """Test codec name normalization"""
-    @unittest.expectedFailure # TODO: RUSTPYTHON; AssertionError: Tuples differ: (1, 2, 3, 4) != (None, None, None, None)
     def test_codecs_lookup(self):
         FOUND = (1, 2, 3, 4)
         NOT_FOUND = (None, None, None, None)
diff --git a/Lib/test/test_codeop.py b/Lib/test/test_codeop.py
index c62e3748e6a..12976122241 100644
--- a/Lib/test/test_codeop.py
+++ b/Lib/test/test_codeop.py
@@ -30,8 +30,6 @@ def assertInvalid(self, str, symbol='single', is_syntax=1):
         except OverflowError:
             self.assertTrue(not is_syntax)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_valid(self):
         av = self.assertValid
 
@@ -94,8 +92,7 @@ def test_valid(self):
         av("def f():\n pass\n#foo\n")
         av("@a.b.c\ndef f():\n pass\n")
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AssertionError: <code object <module> at 0xc99532080 file "<input>", line 1> != None
     def test_incomplete(self):
         ai = self.assertIncomplete
 
@@ -282,13 +279,12 @@ def test_filename(self):
         self.assertNotEqual(compile_command("a = 1\n", "abc").co_filename,
                             compile("a = 1\n", "def", 'single').co_filename)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AssertionError: 0 != 2
     def test_warning(self):
         # Test that the warning is only returned once.
         with warnings_helper.check_warnings(
                 ('"is" with \'str\' literal', SyntaxWarning),
-                ("invalid escape sequence", SyntaxWarning),
+                ('"\\\\e" is an invalid escape sequence', SyntaxWarning),
                 ) as w:
             compile_command(r"'\e' is 0")
             self.assertEqual(len(w.warnings), 2)
@@ -309,8 +305,7 @@ def test_incomplete_warning(self):
             self.assertIncomplete("'\\e' + (")
         self.assertEqual(w, [])
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AssertionError: 0 != 1
     def test_invalid_warning(self):
         with warnings.catch_warnings(record=True) as w:
             warnings.simplefilter('always')
@@ -325,8 +320,6 @@ def assertSyntaxErrorMatches(self, code, message):
             with self.assertRaisesRegex(SyntaxError, message):
                 compile_command(code, symbol='exec')
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_syntax_errors(self):
         self.assertSyntaxErrorMatches(
             dedent("""\
diff --git a/Lib/test/test_collections.py b/Lib/test/test_collections.py
index b68305dd7aa..7a57ba722e8 100644
--- a/Lib/test/test_collections.py
+++ b/Lib/test/test_collections.py
@@ -262,7 +262,6 @@ def __contains__(self, key):
         d = c.new_child(b=20, c=30)
         self.assertEqual(d.maps, [{'b': 20, 'c': 30}, {'a': 1, 'b': 2}])
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_union_operators(self):
         cm1 = ChainMap(dict(a=1, b=2), dict(c=3, d=4))
         cm2 = ChainMap(dict(a=10, e=5), dict(b=20, d=4))
@@ -1957,7 +1956,7 @@ class X(ByteString): pass
             # No metaclass conflict
             class Z(ByteString, Awaitable): pass
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON; Need to implement __buffer__ and __release_buffer__ (https://docs.python.org/3.13/reference/datamodel.html#emulating-buffer-types)
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; Need to implement __buffer__ and __release_buffer__ (https://docs.python.org/3.13/reference/datamodel.html#emulating-buffer-types)
     def test_Buffer(self):
         for sample in [bytes, bytearray, memoryview]:
             self.assertIsInstance(sample(b"x"), Buffer)
@@ -2029,7 +2028,7 @@ def insert(self, index, value):
         self.assertEqual(len(mss), len(mss2))
         self.assertEqual(list(mss), list(mss2))
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AssertionError: TypeError not raised
     def test_illegal_patma_flags(self):
         with self.assertRaises(TypeError):
             class Both(Collection):
@@ -2121,6 +2120,19 @@ def test_basics(self):
         self.assertEqual(c.setdefault('e', 5), 5)
         self.assertEqual(c['e'], 5)
 
+    def test_update_reentrant_add_clears_counter(self):
+        c = Counter()
+        key = object()
+
+        class Evil(int):
+            def __add__(self, other):
+                c.clear()
+                return NotImplemented
+
+        c[key] = Evil()
+        c.update([key])
+        self.assertEqual(c[key], 1)
+
     def test_init(self):
         self.assertEqual(list(Counter(self=42).items()), [('self', 42)])
         self.assertEqual(list(Counter(iterable=42).items()), [('iterable', 42)])
diff --git a/Lib/test/test_compile.py b/Lib/test/test_compile.py
index 337366b4014..0495c58329c 100644
--- a/Lib/test/test_compile.py
+++ b/Lib/test/test_compile.py
@@ -1,5 +1,9 @@
+import contextlib
 import dis
+import io
+import itertools
 import math
+import opcode
 import os
 import unittest
 import sys
@@ -8,11 +12,18 @@
 import tempfile
 import types
 import textwrap
+import warnings
+try:
+    import _testinternalcapi
+except ImportError:
+    _testinternalcapi = None
+
 from test import support
-from test.support import script_helper, requires_debug_ranges
+from test.support import (script_helper, requires_debug_ranges, run_code,
+                          requires_specialization)
+from test.support.bytecode_helper import instructions_with_positions
 from test.support.os_helper import FakePath
 
-
 class TestSpecifics(unittest.TestCase):
 
     def compile_single(self, source):
@@ -108,29 +119,30 @@ def __getitem__(self, key):
         exec('z = a', g, d)
         self.assertEqual(d['z'], 12)
 
+    @unittest.skipIf(support.is_wasi, "exhausts limited stack on WASI")
+    @support.skip_emscripten_stack_overflow()
     def test_extended_arg(self):
-        # default: 1000 * 2.5 = 2500 repetitions
-        repeat = int(sys.getrecursionlimit() * 2.5)
+        repeat = 100
         longexpr = 'x = x or ' + '-x' * repeat
         g = {}
-        code = '''
-def f(x):
-    %s
-    %s
-    %s
-    %s
-    %s
-    %s
-    %s
-    %s
-    %s
-    %s
-    # the expressions above have no effect, x == argument
-    while x:
-        x -= 1
-        # EXTENDED_ARG/JUMP_ABSOLUTE here
-    return x
-''' % ((longexpr,)*10)
+        code = textwrap.dedent('''
+            def f(x):
+                %s
+                %s
+                %s
+                %s
+                %s
+                %s
+                %s
+                %s
+                %s
+                %s
+                # the expressions above have no effect, x == argument
+                while x:
+                    x -= 1
+                    # EXTENDED_ARG/JUMP_ABSOLUTE here
+                return x
+            ''' % ((longexpr,)*10))
         exec(code, g)
         self.assertEqual(g['f'](5), 0)
 
@@ -146,10 +158,11 @@ def test_float_literals(self):
 
     def test_indentation(self):
         # testing compile() of indented block w/o trailing newline"
-        s = """
-if 1:
-    if 2:
-        pass"""
+        s = textwrap.dedent("""
+            if 1:
+                if 2:
+                    pass
+            """)
         compile(s, "<string>", "exec")
 
     # This test is probably specific to CPython and may not generalize
@@ -160,9 +173,8 @@ def test_leading_newlines(self):
         s256 = "".join(["\n"] * 256 + ["spam"])
         co = compile(s256, 'fn', 'exec')
         self.assertEqual(co.co_firstlineno, 1)
-        lines = list(co.co_lines())
-        self.assertEqual(lines[0][2], 0)
-        self.assertEqual(lines[1][2], 257)
+        lines = [line for _, _, line in co.co_lines()]
+        self.assertEqual(lines, [0, 257])
 
     def test_literals_with_leading_zeroes(self):
         for arg in ["077787", "0xj", "0x.", "0e",  "090000000000000",
@@ -197,8 +209,7 @@ def test_literals_with_leading_zeroes(self):
         self.assertEqual(eval("0o777"), 511)
         self.assertEqual(eval("-0o0000010"), -8)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AssertionError: SyntaxError not raised
     def test_int_literals_too_long(self):
         n = 3000
         source = f"a = 1\nb = 2\nc = {'3'*n}\nd = 4"
@@ -272,8 +283,7 @@ def test_none_assignment(self):
             self.assertRaises(SyntaxError, compile, stmt, 'tmp', 'single')
             self.assertRaises(SyntaxError, compile, stmt, 'tmp', 'exec')
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AssertionError: SyntaxError not raised by compile
     def test_import(self):
         succeed = [
             'import sys',
@@ -334,8 +344,11 @@ def test_lambda_doc(self):
         l = lambda: "foo"
         self.assertIsNone(l.__doc__)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    def test_lambda_consts(self):
+        l = lambda: "this is the only const"
+        self.assertEqual(l.__code__.co_consts, ("this is the only const",))
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AssertionError: SyntaxError not raised by compile
     def test_encoding(self):
         code = b'# -*- coding: badencoding -*-\npass\n'
         self.assertRaises(SyntaxError, compile, code, 'tmp', 'exec')
@@ -440,16 +453,134 @@ class A:
             def f():
                 __mangled = 1
                 __not_mangled__ = 2
-                import __mangled_mod
-                import __package__.module
+                import __mangled_mod       # noqa: F401
+                import __package__.module  # noqa: F401
 
         self.assertIn("_A__mangled", A.f.__code__.co_varnames)
         self.assertIn("__not_mangled__", A.f.__code__.co_varnames)
         self.assertIn("_A__mangled_mod", A.f.__code__.co_varnames)
         self.assertIn("__package__", A.f.__code__.co_varnames)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    def test_condition_expression_with_dead_blocks_compiles(self):
+        # See gh-113054
+        compile('if (5 if 5 else T): 0', '<eval>', 'exec')
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    def test_condition_expression_with_redundant_comparisons_compiles(self):
+        # See gh-113054, gh-114083
+        exprs = [
+            'if 9<9<9and 9or 9:9',
+            'if 9<9<9and 9or 9or 9:9',
+            'if 9<9<9and 9or 9or 9or 9:9',
+            'if 9<9<9and 9or 9or 9or 9or 9:9',
+        ]
+        for expr in exprs:
+            with self.subTest(expr=expr):
+                with self.assertWarns(SyntaxWarning):
+                    compile(expr, '<eval>', 'exec')
+
+    def test_dead_code_with_except_handler_compiles(self):
+        compile(textwrap.dedent("""
+                if None:
+                    with CM:
+                        x = 1
+                else:
+                    x = 2
+               """), '<eval>', 'exec')
+
+    def test_try_except_in_while_with_chained_condition_compiles(self):
+        # see gh-124871
+        compile(textwrap.dedent("""
+            name_1, name_2, name_3 = 1, 2, 3
+            while name_3 <= name_2 > name_1:
+                try:
+                    raise
+                except:
+                    pass
+                finally:
+                    pass
+            """), '<eval>', 'exec')
+
+    def test_compile_invalid_namedexpr(self):
+        # gh-109351
+        m = ast.Module(
+            body=[
+                ast.Expr(
+                    value=ast.ListComp(
+                        elt=ast.NamedExpr(
+                            target=ast.Constant(value=1),
+                            value=ast.Constant(value=3),
+                        ),
+                        generators=[
+                            ast.comprehension(
+                                target=ast.Name(id="x", ctx=ast.Store()),
+                                iter=ast.Name(id="y", ctx=ast.Load()),
+                                ifs=[],
+                                is_async=0,
+                            )
+                        ],
+                    )
+                )
+            ],
+            type_ignores=[],
+        )
+
+        with self.assertRaisesRegex(TypeError, "NamedExpr target must be a Name"):
+            compile(ast.fix_missing_locations(m), "<file>", "exec")
+
+    def test_compile_redundant_jumps_and_nops_after_moving_cold_blocks(self):
+        # See gh-120367
+        code=textwrap.dedent("""
+            try:
+                pass
+            except:
+                pass
+            else:
+                match name_2:
+                    case b'':
+                        pass
+            finally:
+                something
+            """)
+
+        tree = ast.parse(code)
+
+        # make all instruction locations the same to create redundancies
+        for node in ast.walk(tree):
+            if hasattr(node,"lineno"):
+                 del node.lineno
+                 del node.end_lineno
+                 del node.col_offset
+                 del node.end_col_offset
+
+        compile(ast.fix_missing_locations(tree), "<file>", "exec")
+
+    def test_compile_redundant_jump_after_convert_pseudo_ops(self):
+        # See gh-120367
+        code=textwrap.dedent("""
+            if name_2:
+                pass
+            else:
+                try:
+                    pass
+                except:
+                    pass
+            ~name_5
+            """)
+
+        tree = ast.parse(code)
+
+        # make all instruction locations the same to create redundancies
+        for node in ast.walk(tree):
+            if hasattr(node,"lineno"):
+                 del node.lineno
+                 del node.end_lineno
+                 del node.col_offset
+                 del node.end_col_offset
+
+        compile(ast.fix_missing_locations(tree), "<file>", "exec")
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AssertionError: <code object <module> at 0xb77555080 file "<assign>1", line 1> != <code object <module> at 0xb77554f00 file "<assign>3", line 1>
     def test_compile_ast(self):
         fname = __file__
         if fname.lower().endswith('pyc'):
@@ -478,13 +609,33 @@ def test_compile_ast(self):
         self.assertRaises(TypeError, compile, co1, '<ast>', 'eval')
 
         # raise exception when node type is no start node
-        self.assertRaises(TypeError, compile, _ast.If(), '<ast>', 'exec')
+        self.assertRaises(TypeError, compile, _ast.If(test=_ast.Name(id='x', ctx=_ast.Load())), '<ast>', 'exec')
 
         # raise exception when node has invalid children
         ast = _ast.Module()
-        ast.body = [_ast.BoolOp()]
+        ast.body = [_ast.BoolOp(op=_ast.Or())]
         self.assertRaises(TypeError, compile, ast, '<ast>', 'exec')
 
+    def test_compile_invalid_typealias(self):
+        # gh-109341
+        m = ast.Module(
+            body=[
+                ast.TypeAlias(
+                    name=ast.Subscript(
+                        value=ast.Name(id="foo", ctx=ast.Load()),
+                        slice=ast.Constant(value="x"),
+                        ctx=ast.Store(),
+                    ),
+                    type_params=[],
+                    value=ast.Name(id="Callable", ctx=ast.Load()),
+                )
+            ],
+            type_ignores=[],
+        )
+
+        with self.assertRaisesRegex(TypeError, "TypeAlias with non-Name name"):
+            compile(ast.fix_missing_locations(m), "<file>", "exec")
+
     def test_dict_evaluation_order(self):
         i = 0
 
@@ -496,18 +647,32 @@ def f():
         d = {f(): f(), f(): f()}
         self.assertEqual(d, {1: 2, 3: 4})
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AssertionError: TypeError not raised
     def test_compile_filename(self):
         for filename in 'file.py', b'file.py':
             code = compile('pass', filename, 'exec')
             self.assertEqual(code.co_filename, 'file.py')
         for filename in bytearray(b'file.py'), memoryview(b'file.py'):
-            with self.assertWarns(DeprecationWarning):
-                code = compile('pass', filename, 'exec')
-            self.assertEqual(code.co_filename, 'file.py')
+            with self.assertRaises(TypeError):
+                compile('pass', filename, 'exec')
         self.assertRaises(TypeError, compile, 'pass', list(b'file.py'), 'exec')
 
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; TypeError: Expected type bool, not EvilBool
+    def test_compile_filename_refleak(self):
+        # Regression tests for reference leak in PyUnicode_FSDecoder.
+        # See https://github.com/python/cpython/issues/139748.
+        mortal_str = 'this is a mortal string'
+        # check error path when 'mode' AC conversion failed
+        self.assertRaises(TypeError, compile, b'', mortal_str, mode=1234)
+        # check error path when 'optimize' AC conversion failed
+        self.assertRaises(OverflowError, compile, b'', mortal_str,
+                          'exec', optimize=1 << 1000)
+        # check error path when 'dont_inherit' AC conversion failed
+        class EvilBool:
+            def __bool__(self): raise ValueError
+        self.assertRaises(ValueError, compile, b'', mortal_str,
+                          'exec', dont_inherit=EvilBool())
+
     @support.cpython_only
     def test_same_filename_used(self):
         s = """def f(): pass\ndef g(): pass"""
@@ -533,8 +698,7 @@ def test_single_statement(self):
         self.compile_single("class T:\n   pass")
         self.compile_single("c = '''\na=1\nb=2\nc=3\n'''")
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AssertionError: SyntaxError not raised by compile_single
     def test_bad_single_statement(self):
         self.assertInvalidSingle('1\n2')
         self.assertInvalidSingle('def f(): pass')
@@ -546,8 +710,7 @@ def test_bad_single_statement(self):
         self.assertInvalidSingle('x = 5 # comment\nx = 6\n')
         self.assertInvalidSingle("c = '''\nd=1\n'''\na = 1\n\nb = 2\n")
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AssertionError: b'source code cannot contain null bytes' not found in b'OSError: stream did not contain valid UTF-8\n'
     def test_particularly_evil_undecodable(self):
         # Issue 24022
         src = b'0000\x00\n00000000000\n\x00\n\x9e\n'
@@ -556,10 +719,9 @@ def test_particularly_evil_undecodable(self):
             with open(fn, "wb") as fp:
                 fp.write(src)
             res = script_helper.run_python_until_end(fn)[0]
-        self.assertIn(b"Non-UTF-8", res.err)
+        self.assertIn(b"source code cannot contain null bytes", res.err)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AssertionError: b'source code cannot contain null bytes' not found in b'OSError: stream did not contain valid UTF-8\n'
     def test_yet_more_evil_still_undecodable(self):
         # Issue #25388
         src = b"#\x00\n#\xfd\n"
@@ -568,30 +730,25 @@ def test_yet_more_evil_still_undecodable(self):
             with open(fn, "wb") as fp:
                 fp.write(src)
             res = script_helper.run_python_until_end(fn)[0]
-        self.assertIn(b"Non-UTF-8", res.err)
+        self.assertIn(b"source code cannot contain null bytes", res.err)
 
     @support.cpython_only
+    @unittest.skipIf(support.is_wasi, "exhausts limited stack on WASI")
+    @support.skip_emscripten_stack_overflow()
     def test_compiler_recursion_limit(self):
-        # Expected limit is sys.getrecursionlimit() * the scaling factor
-        # in symtable.c (currently 3)
-        # We expect to fail *at* that limit, because we use up some of
-        # the stack depth limit in the test suite code
-        # So we check the expected limit and 75% of that
-        # XXX (ncoghlan): duplicating the scaling factor here is a little
-        # ugly. Perhaps it should be exposed somewhere...
-        fail_depth = sys.getrecursionlimit() * 3
-        crash_depth = sys.getrecursionlimit() * 300
-        success_depth = int(fail_depth * 0.75)
+        # Compiler frames are small
+        limit = 100
+        # Android test devices have less memory.
+        crash_depth = limit * (1000 if sys.platform == "android" else 5000)
+        success_depth = limit
 
         def check_limit(prefix, repeated, mode="single"):
             expect_ok = prefix + repeated * success_depth
             compile(expect_ok, '<test>', mode)
-            for depth in (fail_depth, crash_depth):
-                broken = prefix + repeated * depth
-                details = "Compiling ({!r} + {!r} * {})".format(
-                            prefix, repeated, depth)
-                with self.assertRaises(RecursionError, msg=details):
-                    compile(broken, '<test>', mode)
+            broken = prefix + repeated * crash_depth
+            details = f"Compiling ({prefix!r} + {repeated!r} * {crash_depth})"
+            with self.assertRaises(RecursionError, msg=details):
+                compile(broken, '<test>', mode)
 
         check_limit("a", "()")
         check_limit("a", ".b")
@@ -601,14 +758,13 @@ def check_limit(prefix, repeated, mode="single"):
         # check_limit("a", " if a else a")
         # check_limit("if a: pass", "\nelif a: pass", mode="exec")
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AssertionError: "cannot contain null" does not match "invalid syntax (<dummy>, line 1)"
     def test_null_terminated(self):
         # The source code is null-terminated internally, but bytes-like
         # objects are accepted, which could be not terminated.
-        with self.assertRaisesRegex(ValueError, "cannot contain null"):
+        with self.assertRaisesRegex(SyntaxError, "cannot contain null"):
             compile("123\x00", "<dummy>", "eval")
-        with self.assertRaisesRegex(ValueError, "cannot contain null"):
+        with self.assertRaisesRegex(SyntaxError, "cannot contain null"):
             compile(memoryview(b"123\x00"), "<dummy>", "eval")
         code = compile(memoryview(b"123\x00")[1:-1], "<dummy>", "eval")
         self.assertEqual(eval(code), 23)
@@ -649,7 +805,6 @@ def check_same_constant(const):
             self.assertEqual(repr(f1()), repr(const))
 
         check_same_constant(None)
-        check_same_constant(0)
         check_same_constant(0.0)
         check_same_constant(b'abc')
         check_same_constant('abc')
@@ -664,7 +819,7 @@ def check_same_constant(const):
         # Merge constants in tuple or frozenset
         f1, f2 = lambda: "not a name", lambda: ("not a name",)
         f3 = lambda x: x in {("not a name",)}
-        self.assertIs(f1.__code__.co_consts[1],
+        self.assertIs(f1.__code__.co_consts[0],
                       f2.__code__.co_consts[1][0])
         self.assertIs(next(iter(f3.__code__.co_consts[1])),
                       f2.__code__.co_consts[1])
@@ -686,16 +841,62 @@ def test_merge_code_attrs(self):
 
         self.assertIs(f1.__code__.co_linetable, f2.__code__.co_linetable)
 
+    @support.cpython_only
+    def test_remove_unused_consts(self):
+        def f():
+            "docstring"
+            if True:
+                return "used"
+            else:
+                return "unused"
+
+        self.assertEqual(f.__code__.co_consts,
+                         (f.__doc__, "used"))
+
+    @support.cpython_only
+    def test_remove_unused_consts_no_docstring(self):
+        # the first item (None for no docstring in this case) is
+        # always retained.
+        def f():
+            if True:
+                return "used"
+            else:
+                return "unused"
+
+        self.assertEqual(f.__code__.co_consts,
+                         (True, "used"))
+
+    @support.cpython_only
+    def test_remove_unused_consts_extended_args(self):
+        N = 1000
+        code = ["def f():\n"]
+        code.append("\ts = ''\n")
+        code.append("\tfor i in range(1):\n")
+        for i in range(N):
+            code.append(f"\t\tif True: s += 't{i}'\n")
+            code.append(f"\t\tif False: s += 'f{i}'\n")
+        code.append("\treturn s\n")
+
+        code = "".join(code)
+        g = {}
+        eval(compile(code, "file.py", "exec"), g)
+        exec(code, g)
+        f = g['f']
+        expected = tuple([''] + [f't{i}' for i in range(N)])
+        self.assertEqual(f.__code__.co_consts, expected)
+        expected = "".join(expected[1:])
+        self.assertEqual(expected, f())
+
     # Stripping unused constants is not a strict requirement for the
     # Python semantics, it's a more an implementation detail.
     @support.cpython_only
-    def test_strip_unused_consts(self):
+    def test_strip_unused_None(self):
         # Python 3.10rc1 appended None to co_consts when None is not used
         # at all. See bpo-45056.
         def f1():
             "docstring"
             return 42
-        self.assertEqual(f1.__code__.co_consts, ("docstring", 42))
+        self.assertEqual(f1.__code__.co_consts, (f1.__doc__,))
 
     # This is a regression test for a CPython specific peephole optimizer
     # implementation bug present in a few releases.  It's assertion verifies
@@ -715,8 +916,90 @@ def unused_code_at_end():
             'RETURN_VALUE',
             list(dis.get_instructions(unused_code_at_end))[-1].opname)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @support.cpython_only
+    def test_docstring(self):
+        src = textwrap.dedent("""
+            def with_docstring():
+                "docstring"
+
+            def two_strings():
+                "docstring"
+                "not docstring"
+
+            def with_fstring():
+                f"not docstring"
+
+            def with_const_expression():
+                "also" + " not docstring"
+
+            def multiple_const_strings():
+                "not docstring " * 3
+            """)
+
+        for opt in [0, 1, 2]:
+            with self.subTest(opt=opt):
+                code = compile(src, "<test>", "exec", optimize=opt)
+                ns = {}
+                exec(code, ns)
+
+                if opt < 2:
+                    self.assertEqual(ns['with_docstring'].__doc__, "docstring")
+                    self.assertEqual(ns['two_strings'].__doc__, "docstring")
+                else:
+                    self.assertIsNone(ns['with_docstring'].__doc__)
+                    self.assertIsNone(ns['two_strings'].__doc__)
+                self.assertIsNone(ns['with_fstring'].__doc__)
+                self.assertIsNone(ns['with_const_expression'].__doc__)
+                self.assertIsNone(ns['multiple_const_strings'].__doc__)
+
+    @support.cpython_only
+    def test_docstring_interactive_mode(self):
+        srcs = [
+            """def with_docstring():
+                "docstring"
+            """,
+            """class with_docstring:
+                "docstring"
+            """,
+        ]
+
+        for opt in [0, 1, 2]:
+            for src in srcs:
+                with self.subTest(opt=opt, src=src):
+                    code = compile(textwrap.dedent(src), "<test>", "single", optimize=opt)
+                    ns = {}
+                    exec(code, ns)
+                    if opt < 2:
+                        self.assertEqual(ns['with_docstring'].__doc__, "docstring")
+                    else:
+                        self.assertIsNone(ns['with_docstring'].__doc__)
+
+    @support.cpython_only
+    def test_docstring_omitted(self):
+        # See gh-115347
+        src = textwrap.dedent("""
+            def f():
+                "docstring1"
+                def h():
+                    "docstring2"
+                    return 42
+
+                class C:
+                    "docstring3"
+                    pass
+
+                return h
+        """)
+        for opt in [-1, 0, 1, 2]:
+            for mode in ["exec", "single"]:
+                with self.subTest(opt=opt, mode=mode):
+                    code = compile(src, "<test>", mode, optimize=opt)
+                    output = io.StringIO()
+                    with contextlib.redirect_stdout(output):
+                        dis.dis(code)
+                    self.assertNotIn('NOP', output.getvalue())
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AssertionError: unable to find constant -0.0 in (0.0,)
     def test_dont_merge_constants(self):
         # Issue #25843: compile() must not merge constants which are equal
         # but have a different type.
@@ -733,7 +1016,6 @@ def check_different_constants(const1, const2):
             self.assertEqual(repr(f1()), repr(const1))
             self.assertEqual(repr(f2()), repr(const2))
 
-        check_different_constants(0, 0.0)
         check_different_constants(+0.0, -0.0)
         check_different_constants((0,), (0.0,))
         check_different_constants('a', b'a')
@@ -761,10 +1043,13 @@ def test_path_like_objects(self):
         # An implicit test for PyUnicode_FSDecoder().
         compile("42", FakePath("test_compile_pathlike"), "single")
 
+    # bpo-31113: Stack overflow when compile a long sequence of
+    # complex statements.
+    @support.requires_resource('cpu')
     def test_stack_overflow(self):
-        # bpo-31113: Stack overflow when compile a long sequence of
-        # complex statements.
-        compile("if a: b\n" * 200000, "<dummy>", "exec")
+        # Android test devices have less memory.
+        size = 100_000 if sys.platform == "android" else 200_000
+        compile("if a: b\n" * size, "<dummy>", "exec")
 
     # Multiple users rely on the fact that CPython does not generate
     # bytecode for dead code blocks. See bpo-37500 for more context.
@@ -796,12 +1081,10 @@ def unused_block_while_else():
         for func in funcs:
             opcodes = list(dis.get_instructions(func))
             self.assertLessEqual(len(opcodes), 4)
-            self.assertEqual('LOAD_CONST', opcodes[-2].opname)
-            self.assertEqual(None, opcodes[-2].argval)
             self.assertEqual('RETURN_VALUE', opcodes[-1].opname)
+            self.assertEqual(None, opcodes[-1].argval)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AssertionError: 3 != 8
     def test_false_while_loop(self):
         def break_in_while():
             while False:
@@ -817,12 +1100,10 @@ def continue_in_while():
         for func in funcs:
             opcodes = list(dis.get_instructions(func))
             self.assertEqual(3, len(opcodes))
-            self.assertEqual('LOAD_CONST', opcodes[1].opname)
+            self.assertEqual('RETURN_VALUE', opcodes[-1].opname)
             self.assertEqual(None, opcodes[1].argval)
-            self.assertEqual('RETURN_VALUE', opcodes[2].opname)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_consts_in_conditionals(self):
         def and_true(x):
             return True and x
@@ -846,8 +1127,6 @@ def or_false(x):
                 self.assertIn('LOAD_', opcodes[-2].opname)
                 self.assertEqual('RETURN_VALUE', opcodes[-1].opname)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_imported_load_method(self):
         sources = [
             """\
@@ -880,7 +1159,33 @@ def foo(x):
                 instructions = [opcode.opname for opcode in opcodes]
                 self.assertNotIn('LOAD_METHOD', instructions)
                 self.assertIn('LOAD_ATTR', instructions)
-                self.assertIn('PRECALL', instructions)
+                self.assertIn('CALL', instructions)
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AssertionError: 'LOAD_SMALL_INT' not found in ['RESUME', 'LOAD_CONST', 'RETURN_VALUE']
+    def test_folding_type_param(self):
+        get_code_fn_cls = lambda x: x.co_consts[0].co_consts[2]
+        get_code_type_alias = lambda x: x.co_consts[0].co_consts[3]
+        snippets = [
+            ("def foo[T = 40 + 5](): pass", get_code_fn_cls),
+            ("def foo[**P = 40 + 5](): pass", get_code_fn_cls),
+            ("def foo[*Ts = 40 + 5](): pass", get_code_fn_cls),
+            ("class foo[T = 40 + 5]: pass", get_code_fn_cls),
+            ("class foo[**P = 40 + 5]: pass", get_code_fn_cls),
+            ("class foo[*Ts = 40 + 5]: pass", get_code_fn_cls),
+            ("type foo[T = 40 + 5] = 1", get_code_type_alias),
+            ("type foo[**P = 40 + 5] = 1", get_code_type_alias),
+            ("type foo[*Ts = 40 + 5] = 1", get_code_type_alias),
+        ]
+        for snippet, get_code in snippets:
+            c = compile(snippet, "<dummy>", "exec")
+            code = get_code(c)
+            opcodes = list(dis.get_instructions(code))
+            instructions = [opcode.opname for opcode in opcodes]
+            args = [opcode.oparg for opcode in opcodes]
+            self.assertNotIn(40, args)
+            self.assertNotIn(5, args)
+            self.assertIn('LOAD_SMALL_INT', instructions)
+            self.assertIn(45, args)
 
     def test_lineno_procedure_call(self):
         def call():
@@ -890,8 +1195,7 @@ def call():
         line1 = call.__code__.co_firstlineno + 1
         assert line1 not in [line for (_, _, line) in call.__code__.co_lines()]
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_lineno_after_implicit_return(self):
         TRUE = True
         # Don't use constant True or False, as compiler will remove test
@@ -935,10 +1239,12 @@ def no_code2():
 
         for func in (no_code1, no_code2):
             with self.subTest(func=func):
+                if func is no_code1 and no_code1.__doc__ is None:
+                    continue
                 code = func.__code__
-                lines = list(code.co_lines())
-                start, end, line = lines[0]
+                [(start, end, line)] = code.co_lines()
                 self.assertEqual(start, 0)
+                self.assertEqual(end, len(code.co_code))
                 self.assertEqual(line, code.co_firstlineno)
 
     def get_code_lines(self, code):
@@ -950,8 +1256,7 @@ def get_code_lines(self, code):
                 last_line = line
         return res
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_lineno_attribute(self):
         def load_attr():
             return (
@@ -996,8 +1301,7 @@ def aug_store_attr():
                 code_lines = self.get_code_lines(func.__code__)
                 self.assertEqual(lines, code_lines)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; + [0]
     def test_line_number_genexp(self):
 
         def return_genexp():
@@ -1006,14 +1310,12 @@ def return_genexp():
                     x
                     in
                     y)
-        genexp_lines = [0, 2, 0]
+        genexp_lines = [0, 4, 2, 0, 4]
 
-        genexp_code = return_genexp.__code__.co_consts[1]
+        genexp_code = return_genexp.__code__.co_consts[0]
         code_lines = self.get_code_lines(genexp_code)
         self.assertEqual(genexp_lines, code_lines)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_line_number_implicit_return_after_async_for(self):
 
         async def test(aseq):
@@ -1024,6 +1326,73 @@ async def test(aseq):
         code_lines = self.get_code_lines(test.__code__)
         self.assertEqual(expected_lines, code_lines)
 
+    def check_line_numbers(self, code, opnames=None):
+        # Check that all instructions whose op matches opnames
+        # have a line number. opnames can be a single name, or
+        # a sequence of names. If it is None, match all ops.
+
+        if isinstance(opnames, str):
+            opnames = (opnames, )
+        for inst in dis.Bytecode(code):
+            if opnames and inst.opname in opnames:
+                self.assertIsNotNone(inst.positions.lineno)
+
+    def test_line_number_synthetic_jump_multiple_predecessors(self):
+        def f():
+            for x in it:
+                try:
+                    if C1:
+                        yield 2
+                except OSError:
+                    pass
+
+        self.check_line_numbers(f.__code__, 'JUMP_BACKWARD')
+
+    def test_line_number_synthetic_jump_multiple_predecessors_nested(self):
+        def f():
+            for x in it:
+                try:
+                    X = 3
+                except OSError:
+                    try:
+                        if C3:
+                            X = 4
+                    except OSError:
+                        pass
+            return 42
+
+        self.check_line_numbers(f.__code__, 'JUMP_BACKWARD')
+
+    def test_line_number_synthetic_jump_multiple_predecessors_more_nested(self):
+        def f():
+            for x in it:
+                try:
+                    X = 3
+                except OSError:
+                    try:
+                        if C3:
+                            if C4:
+                                X = 4
+                    except OSError:
+                        try:
+                            if C3:
+                                if C4:
+                                    X = 5
+                        except OSError:
+                            pass
+            return 42
+
+        self.check_line_numbers(f.__code__, 'JUMP_BACKWARD')
+
+    def test_lineno_of_backward_jump_conditional_in_loop(self):
+        # Issue gh-107901
+        def f():
+            for i in x:
+                if y:
+                    pass
+
+        self.check_line_numbers(f.__code__, 'JUMP_BACKWARD')
+
     def test_big_dict_literal(self):
         # The compiler has a flushing point in "compiler_dict" that calls compiles
         # a portion of the dictionary literal when the loop that iterates over the items
@@ -1073,14 +1442,109 @@ def while_not_chained(a, b, c):
         for instr in dis.Bytecode(while_not_chained):
             self.assertNotEqual(instr.opname, "EXTENDED_ARG")
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @support.cpython_only
+    def test_uses_slice_instructions(self):
+
+        def check_op_count(func, op, expected):
+            actual = 0
+            for instr in dis.Bytecode(func):
+                if instr.opname == op:
+                    actual += 1
+            self.assertEqual(actual, expected)
+
+        def check_consts(func, typ, expected):
+            expected = set([repr(x) for x in expected])
+            all_consts = set()
+            consts = func.__code__.co_consts
+            for instr in dis.Bytecode(func):
+                if instr.opname == "LOAD_CONST" and isinstance(consts[instr.oparg], typ):
+                    all_consts.add(repr(consts[instr.oparg]))
+            self.assertEqual(all_consts, expected)
+
+        def load():
+            return x[a:b] + x [a:] + x[:b] + x[:]
+
+        check_op_count(load, "BINARY_SLICE", 3)
+        check_op_count(load, "BUILD_SLICE", 0)
+        check_consts(load, slice, [slice(None, None, None)])
+        check_op_count(load, "BINARY_OP", 4)
+
+        def store():
+            x[a:b] = y
+            x [a:] = y
+            x[:b] = y
+            x[:] = y
+
+        check_op_count(store, "STORE_SLICE", 3)
+        check_op_count(store, "BUILD_SLICE", 0)
+        check_op_count(store, "STORE_SUBSCR", 1)
+        check_consts(store, slice, [slice(None, None, None)])
+
+        def long_slice():
+            return x[a:b:c]
+
+        check_op_count(long_slice, "BUILD_SLICE", 1)
+        check_op_count(long_slice, "BINARY_SLICE", 0)
+        check_consts(long_slice, slice, [])
+        check_op_count(long_slice, "BINARY_OP", 1)
+
+        def aug():
+            x[a:b] += y
+
+        check_op_count(aug, "BINARY_SLICE", 1)
+        check_op_count(aug, "STORE_SLICE", 1)
+        check_op_count(aug, "BUILD_SLICE", 0)
+        check_op_count(aug, "BINARY_OP", 1)
+        check_op_count(aug, "STORE_SUBSCR", 0)
+        check_consts(aug, slice, [])
+
+        def aug_const():
+            x[1:2] += y
+
+        check_op_count(aug_const, "BINARY_SLICE", 0)
+        check_op_count(aug_const, "STORE_SLICE", 0)
+        check_op_count(aug_const, "BINARY_OP", 2)
+        check_op_count(aug_const, "STORE_SUBSCR", 1)
+        check_consts(aug_const, slice, [slice(1, 2)])
+
+        def compound_const_slice():
+            x[1:2:3, 4:5:6] = y
+
+        check_op_count(compound_const_slice, "BINARY_SLICE", 0)
+        check_op_count(compound_const_slice, "BUILD_SLICE", 0)
+        check_op_count(compound_const_slice, "STORE_SLICE", 0)
+        check_op_count(compound_const_slice, "STORE_SUBSCR", 1)
+        check_consts(compound_const_slice, slice, [])
+        check_consts(compound_const_slice, tuple, [(slice(1, 2, 3), slice(4, 5, 6))])
+
+        def mutable_slice():
+            x[[]:] = y
+
+        check_consts(mutable_slice, slice, {})
+
+        def different_but_equal():
+            x[:0] = y
+            x[:0.0] = y
+            x[:False] = y
+            x[:None] = y
+
+        check_consts(
+            different_but_equal,
+            slice,
+            [
+                slice(None, 0, None),
+                slice(None, 0.0, None),
+                slice(None, False, None),
+                slice(None, None, None)
+            ]
+        )
+
     def test_compare_positions(self):
-        for opname, op in [
-            ("COMPARE_OP", "<"),
-            ("COMPARE_OP", "<="),
-            ("COMPARE_OP", ">"),
-            ("COMPARE_OP", ">="),
+        for opname_prefix, op in [
+            ("COMPARE_", "<"),
+            ("COMPARE_", "<="),
+            ("COMPARE_", ">"),
+            ("COMPARE_", ">="),
             ("CONTAINS_OP", "in"),
             ("CONTAINS_OP", "not in"),
             ("IS_OP", "is"),
@@ -1095,11 +1559,313 @@ def test_compare_positions(self):
                 actual_positions = [
                     instruction.positions
                     for instruction in dis.get_instructions(code)
-                    if instruction.opname == opname
+                    if instruction.opname.startswith(opname_prefix)
                 ]
                 with self.subTest(source):
                     self.assertEqual(actual_positions, expected_positions)
 
+    def test_if_expression_expression_empty_block(self):
+        # See regression in gh-99708
+        exprs = [
+            "assert (False if 1 else True)",
+            "def f():\n\tif not (False if 1 else True): raise AssertionError",
+            "def f():\n\tif not (False if 1 else True): return 12",
+        ]
+        for expr in exprs:
+            with self.subTest(expr=expr):
+                compile(expr, "<single>", "exec")
+
+    def test_multi_line_lambda_as_argument(self):
+        # See gh-101928
+        code = textwrap.dedent("""
+            def foo(param, lambda_exp):
+                pass
+
+            foo(param=0,
+                lambda_exp=lambda:
+                1)
+        """)
+        compile(code, "<test>", "exec")
+
+    def test_apply_static_swaps(self):
+        def f(x, y):
+            a, a = x, y
+            return a
+        self.assertEqual(f("x", "y"), "y")
+
+    def test_apply_static_swaps_2(self):
+        def f(x, y, z):
+            a, b, a = x, y, z
+            return a
+        self.assertEqual(f("x", "y", "z"), "z")
+
+    def test_apply_static_swaps_3(self):
+        def f(x, y, z):
+            a, a, b = x, y, z
+            return a
+        self.assertEqual(f("x", "y", "z"), "y")
+
+    def test_variable_dependent(self):
+        # gh-104635: Since the value of b is dependent on the value of a
+        # the first STORE_FAST for a should not be skipped. (e.g POP_TOP).
+        # This test case is added to prevent potential regression from aggressive optimization.
+        def f():
+            a = 42; b = a + 54; a = 54
+            return a, b
+        self.assertEqual(f(), (54, 96))
+
+    def test_duplicated_small_exit_block(self):
+        # See gh-109627
+        def f():
+            while element and something:
+                try:
+                    return something
+                except:
+                    pass
+
+    def test_cold_block_moved_to_end(self):
+        # See gh-109719
+        def f():
+            while name:
+                try:
+                    break
+                except:
+                    pass
+            else:
+                1 if 1 else 1
+
+    def test_remove_empty_basic_block_with_jump_target_label(self):
+        # See gh-109823
+        def f(x):
+            while x:
+                0 if 1 else 0
+
+    def test_remove_redundant_nop_edge_case(self):
+        # See gh-109889
+        def f():
+            a if (1 if b else c) else d
+
+    def test_global_declaration_in_except_used_in_else(self):
+        # See gh-111123
+        code = textwrap.dedent("""\
+            def f():
+                try:
+                    pass
+                %s Exception:
+                    global a
+                else:
+                    print(a)
+        """)
+
+        g, l = {'a': 5}, {}
+        for kw in ("except", "except*"):
+            exec(code % kw, g, l);
+
+    def test_regression_gh_120225(self):
+        async def name_4():
+            match b'':
+                case True:
+                    pass
+                case name_5 if f'e':
+                    {name_3: name_4 async for name_2 in name_5}
+                case []:
+                    pass
+            [[]]
+
+    def test_globals_dict_subclass(self):
+        # gh-132386
+        class WeirdDict(dict):
+            pass
+
+        ns = {}
+        exec('def foo(): return a', WeirdDict(), ns)
+
+        self.assertRaises(NameError, ns['foo'])
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; + [3, 5, 3, 5]
+    def test_compile_warnings(self):
+        # Each invocation of compile() emits compiler warnings, even if they
+        # have the same message and line number.
+        source = textwrap.dedent(r"""
+            # tokenizer
+            1or 0  # line 3
+            # code generator
+            1 is 1  # line 5
+        """)
+        with warnings.catch_warnings(record=True) as caught:
+            warnings.simplefilter("default")
+            for i in range(2):
+                # Even if compile() is at the same line.
+                compile(source, '<stdin>', 'exec')
+
+        self.assertEqual([wm.lineno for wm in caught], [3, 5] * 2)
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; + [5, 9]
+    def test_compile_warning_in_finally(self):
+        # Ensure that warnings inside finally blocks are
+        # only emitted once despite the block being
+        # compiled twice (for normal execution and for
+        # exception handling).
+        source = textwrap.dedent("""
+            try:
+                pass
+            finally:
+                1 is 1  # line 5
+                try:
+                    pass
+                finally: # nested
+                    1 is 1  # line 9
+        """)
+
+        with warnings.catch_warnings(record=True) as caught:
+            warnings.simplefilter("always")
+            compile(source, '<stdin>', 'exec')
+
+        self.assertEqual(sorted(wm.lineno for wm in caught), [5, 9])
+        for wm in caught:
+            self.assertEqual(wm.category, SyntaxWarning)
+            self.assertIn("\"is\" with 'int' literal", str(wm.message))
+
+        # Other code path is used for "try" with "except*".
+        source = textwrap.dedent("""
+            try:
+                pass
+            except *Exception:
+                pass
+            finally:
+                1 is 1  # line 7
+                try:
+                    pass
+                except *Exception:
+                    pass
+                finally: # nested
+                    1 is 1  # line 13
+        """)
+
+        with warnings.catch_warnings(record=True) as caught:
+            warnings.simplefilter("always")
+            compile(source, '<stdin>', 'exec')
+
+        self.assertEqual(sorted(wm.lineno for wm in caught), [7, 13])
+        for wm in caught:
+            self.assertEqual(wm.category, SyntaxWarning)
+            self.assertIn("\"is\" with 'int' literal", str(wm.message))
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    @support.subTests('src', [
+        textwrap.dedent("""
+            def f():
+                try:
+                    pass
+                finally:
+                    return 42
+            """),
+        textwrap.dedent("""
+            for x in y:
+                try:
+                    pass
+                finally:
+                    break
+            """),
+        textwrap.dedent("""
+            for x in y:
+                try:
+                    pass
+                finally:
+                    continue
+            """),
+    ])
+    def test_pep_765_warnings(self, src):
+        with self.assertWarnsRegex(SyntaxWarning, 'finally'):
+            compile(src, '<string>', 'exec')
+        with warnings.catch_warnings():
+            warnings.simplefilter("error")
+            tree = ast.parse(src)
+        with self.assertWarnsRegex(SyntaxWarning, 'finally'):
+            compile(tree, '<string>', 'exec')
+
+    @support.subTests('src', [
+        textwrap.dedent("""
+            try:
+                pass
+            finally:
+                def f():
+                    return 42
+            """),
+        textwrap.dedent("""
+            try:
+                pass
+            finally:
+                for x in y:
+                    break
+            """),
+        textwrap.dedent("""
+            try:
+                pass
+            finally:
+                for x in y:
+                    continue
+            """),
+    ])
+    def test_pep_765_no_warnings(self, src):
+        with warnings.catch_warnings():
+            warnings.simplefilter("error")
+            compile(src, '<string>', 'exec')
+
+
+class TestBooleanExpression(unittest.TestCase):
+    class Value:
+        def __init__(self):
+            self.called = 0
+
+        def __bool__(self):
+            self.called += 1
+            return self.value
+
+    class Yes(Value):
+        value = True
+
+    class No(Value):
+        value = False
+
+    def test_short_circuit_and(self):
+        v = [self.Yes(), self.No(), self.Yes()]
+        res = v[0] and v[1] and v[0]
+        self.assertIs(res, v[1])
+        self.assertEqual([e.called for e in v], [1, 1, 0])
+
+    def test_short_circuit_or(self):
+        v = [self.No(), self.Yes(), self.No()]
+        res = v[0] or v[1] or v[0]
+        self.assertIs(res, v[1])
+        self.assertEqual([e.called for e in v], [1, 1, 0])
+
+    def test_compound(self):
+        # See gh-124285
+        v = [self.No(), self.Yes(), self.Yes(), self.Yes()]
+        res = v[0] and v[1] or v[2] or v[3]
+        self.assertIs(res, v[2])
+        self.assertEqual([e.called for e in v], [1, 0, 1, 0])
+
+        v = [self.No(), self.No(), self.Yes(), self.Yes(), self.No()]
+        res = v[0] or v[1] and v[2] or v[3] or v[4]
+        self.assertIs(res, v[3])
+        self.assertEqual([e.called for e in v], [1, 1, 0, 1, 0])
+
+    def test_exception(self):
+        # See gh-137288
+        class Foo:
+            def __bool__(self):
+                raise NotImplementedError()
+
+        a = Foo()
+        b = Foo()
+
+        with self.assertRaises(NotImplementedError):
+            bool(a)
+
+        with self.assertRaises(NotImplementedError):
+            c = a or b
 
 @requires_debug_ranges()
 class TestSourcePositions(unittest.TestCase):
@@ -1118,7 +1884,7 @@ def check_positions_against_ast(self, snippet):
         class SourceOffsetVisitor(ast.NodeVisitor):
             def generic_visit(self, node):
                 super().generic_visit(node)
-                if not isinstance(node, ast.expr) and not isinstance(node, ast.stmt):
+                if not isinstance(node, (ast.expr, ast.stmt, ast.pattern)):
                     return
                 lines.add(node.lineno)
                 end_lines.add(node.end_lineno)
@@ -1147,8 +1913,8 @@ def generic_visit(self, node):
     def assertOpcodeSourcePositionIs(self, code, opcode,
             line, end_line, column, end_column, occurrence=1):
 
-        for instr, position in zip(
-            dis.Bytecode(code, show_caches=True), code.co_positions(), strict=True
+        for instr, position in instructions_with_positions(
+            dis.Bytecode(code), code.co_positions()
         ):
             if instr.opname == opcode:
                 occurrence -= 1
@@ -1186,15 +1952,303 @@ def test_compiles_to_extended_op_arg(self):
             column=2, end_column=9, occurrence=2)
 
     def test_multiline_expression(self):
-        snippet = """\
-f(
-    1, 2, 3, 4
-)
-"""
+        snippet = textwrap.dedent("""\
+            f(
+                1, 2, 3, 4
+            )
+            """)
         compiled_code, _ = self.check_positions_against_ast(snippet)
         self.assertOpcodeSourcePositionIs(compiled_code, 'CALL',
             line=1, end_line=3, column=0, end_column=1)
 
+    @requires_specialization
+    def test_multiline_boolean_expression(self):
+        snippet = textwrap.dedent("""\
+            if (a or
+                (b and not c) or
+                not (
+                    d > 0)):
+                x = 42
+            """)
+        compiled_code, _ = self.check_positions_against_ast(snippet)
+        # jump if a is true:
+        self.assertOpcodeSourcePositionIs(compiled_code, 'POP_JUMP_IF_TRUE',
+            line=1, end_line=1, column=4, end_column=5, occurrence=1)
+        # jump if b is false:
+        self.assertOpcodeSourcePositionIs(compiled_code, 'POP_JUMP_IF_FALSE',
+            line=2, end_line=2, column=5, end_column=6, occurrence=1)
+        # jump if c is false:
+        self.assertOpcodeSourcePositionIs(compiled_code, 'POP_JUMP_IF_FALSE',
+            line=2, end_line=2, column=15, end_column=16, occurrence=2)
+        # compare d and 0
+        self.assertOpcodeSourcePositionIs(compiled_code, 'COMPARE_OP',
+            line=4, end_line=4, column=8, end_column=13, occurrence=1)
+        # jump if comparison it True
+        self.assertOpcodeSourcePositionIs(compiled_code, 'POP_JUMP_IF_TRUE',
+            line=4, end_line=4, column=8, end_column=13, occurrence=2)
+
+    @unittest.skipIf(sys.flags.optimize, "Assertions are disabled in optimized mode")
+    def test_multiline_assert(self):
+        snippet = textwrap.dedent("""\
+            assert (a > 0 and
+                    bb > 0 and
+                    ccc == 1000000), "error msg"
+            """)
+        compiled_code, _ = self.check_positions_against_ast(snippet)
+        self.assertOpcodeSourcePositionIs(compiled_code, 'LOAD_COMMON_CONSTANT',
+            line=1, end_line=3, column=0, end_column=36, occurrence=1)
+        #  The "error msg":
+        self.assertOpcodeSourcePositionIs(compiled_code, 'LOAD_CONST',
+            line=3, end_line=3, column=25, end_column=36, occurrence=2)
+        self.assertOpcodeSourcePositionIs(compiled_code, 'CALL',
+            line=1, end_line=3, column=0, end_column=36, occurrence=1)
+        self.assertOpcodeSourcePositionIs(compiled_code, 'RAISE_VARARGS',
+            line=1, end_line=3, column=8, end_column=22, occurrence=1)
+
+    def test_multiline_generator_expression(self):
+        snippet = textwrap.dedent("""\
+            ((x,
+                2*x)
+                for x
+                in [1,2,3] if (x > 0
+                               and x < 100
+                               and x != 50))
+            """)
+        compiled_code, _ = self.check_positions_against_ast(snippet)
+        compiled_code = compiled_code.co_consts[0]
+        self.assertIsInstance(compiled_code, types.CodeType)
+        self.assertOpcodeSourcePositionIs(compiled_code, 'YIELD_VALUE',
+            line=1, end_line=2, column=1, end_column=8, occurrence=1)
+        self.assertOpcodeSourcePositionIs(compiled_code, 'JUMP_BACKWARD',
+            line=1, end_line=2, column=1, end_column=8, occurrence=1)
+        self.assertOpcodeSourcePositionIs(compiled_code, 'RETURN_VALUE',
+            line=4, end_line=4, column=7, end_column=14, occurrence=1)
+
+    def test_multiline_async_generator_expression(self):
+        snippet = textwrap.dedent("""\
+            ((x,
+                2*x)
+                async for x
+                in [1,2,3] if (x > 0
+                               and x < 100
+                               and x != 50))
+            """)
+        compiled_code, _ = self.check_positions_against_ast(snippet)
+        compiled_code = compiled_code.co_consts[0]
+        self.assertIsInstance(compiled_code, types.CodeType)
+        self.assertOpcodeSourcePositionIs(compiled_code, 'YIELD_VALUE',
+            line=1, end_line=2, column=1, end_column=8, occurrence=2)
+        self.assertOpcodeSourcePositionIs(compiled_code, 'RETURN_VALUE',
+            line=1, end_line=6, column=0, end_column=32, occurrence=1)
+
+    def test_multiline_list_comprehension(self):
+        snippet = textwrap.dedent("""\
+            [(x,
+                2*x)
+                for x
+                in [1,2,3] if (x > 0
+                               and x < 100
+                               and x != 50)]
+            """)
+        compiled_code, _ = self.check_positions_against_ast(snippet)
+        self.assertIsInstance(compiled_code, types.CodeType)
+        self.assertOpcodeSourcePositionIs(compiled_code, 'LIST_APPEND',
+            line=1, end_line=2, column=1, end_column=8, occurrence=1)
+        self.assertOpcodeSourcePositionIs(compiled_code, 'JUMP_BACKWARD',
+            line=1, end_line=2, column=1, end_column=8, occurrence=1)
+
+    def test_multiline_async_list_comprehension(self):
+        snippet = textwrap.dedent("""\
+            async def f():
+                [(x,
+                    2*x)
+                    async for x
+                    in [1,2,3] if (x > 0
+                                   and x < 100
+                                   and x != 50)]
+            """)
+        compiled_code, _ = self.check_positions_against_ast(snippet)
+        g = {}
+        eval(compiled_code, g)
+        compiled_code = g['f'].__code__
+        self.assertIsInstance(compiled_code, types.CodeType)
+        self.assertOpcodeSourcePositionIs(compiled_code, 'LIST_APPEND',
+            line=2, end_line=3, column=5, end_column=12, occurrence=1)
+        self.assertOpcodeSourcePositionIs(compiled_code, 'JUMP_BACKWARD',
+            line=2, end_line=3, column=5, end_column=12, occurrence=1)
+        self.assertOpcodeSourcePositionIs(compiled_code, 'RETURN_VALUE',
+            line=2, end_line=7, column=4, end_column=36, occurrence=1)
+
+    def test_multiline_set_comprehension(self):
+        snippet = textwrap.dedent("""\
+            {(x,
+                2*x)
+                for x
+                in [1,2,3] if (x > 0
+                               and x < 100
+                               and x != 50)}
+            """)
+        compiled_code, _ = self.check_positions_against_ast(snippet)
+        self.assertIsInstance(compiled_code, types.CodeType)
+        self.assertOpcodeSourcePositionIs(compiled_code, 'SET_ADD',
+            line=1, end_line=2, column=1, end_column=8, occurrence=1)
+        self.assertOpcodeSourcePositionIs(compiled_code, 'JUMP_BACKWARD',
+            line=1, end_line=2, column=1, end_column=8, occurrence=1)
+
+    def test_multiline_async_set_comprehension(self):
+        snippet = textwrap.dedent("""\
+            async def f():
+                {(x,
+                    2*x)
+                    async for x
+                    in [1,2,3] if (x > 0
+                                   and x < 100
+                                   and x != 50)}
+            """)
+        compiled_code, _ = self.check_positions_against_ast(snippet)
+        g = {}
+        eval(compiled_code, g)
+        compiled_code = g['f'].__code__
+        self.assertIsInstance(compiled_code, types.CodeType)
+        self.assertOpcodeSourcePositionIs(compiled_code, 'SET_ADD',
+            line=2, end_line=3, column=5, end_column=12, occurrence=1)
+        self.assertOpcodeSourcePositionIs(compiled_code, 'JUMP_BACKWARD',
+            line=2, end_line=3, column=5, end_column=12, occurrence=1)
+        self.assertOpcodeSourcePositionIs(compiled_code, 'RETURN_VALUE',
+            line=2, end_line=7, column=4, end_column=36, occurrence=1)
+
+    def test_multiline_dict_comprehension(self):
+        snippet = textwrap.dedent("""\
+            {x:
+                2*x
+                for x
+                in [1,2,3] if (x > 0
+                               and x < 100
+                               and x != 50)}
+            """)
+        compiled_code, _ = self.check_positions_against_ast(snippet)
+        self.assertIsInstance(compiled_code, types.CodeType)
+        self.assertOpcodeSourcePositionIs(compiled_code, 'MAP_ADD',
+            line=1, end_line=2, column=1, end_column=7, occurrence=1)
+        self.assertOpcodeSourcePositionIs(compiled_code, 'JUMP_BACKWARD',
+            line=1, end_line=2, column=1, end_column=7, occurrence=1)
+
+    def test_multiline_async_dict_comprehension(self):
+        snippet = textwrap.dedent("""\
+            async def f():
+                {x:
+                    2*x
+                    async for x
+                    in [1,2,3] if (x > 0
+                                   and x < 100
+                                   and x != 50)}
+            """)
+        compiled_code, _ = self.check_positions_against_ast(snippet)
+        g = {}
+        eval(compiled_code, g)
+        compiled_code = g['f'].__code__
+        self.assertIsInstance(compiled_code, types.CodeType)
+        self.assertOpcodeSourcePositionIs(compiled_code, 'MAP_ADD',
+            line=2, end_line=3, column=5, end_column=11, occurrence=1)
+        self.assertOpcodeSourcePositionIs(compiled_code, 'JUMP_BACKWARD',
+            line=2, end_line=3, column=5, end_column=11, occurrence=1)
+        self.assertOpcodeSourcePositionIs(compiled_code, 'RETURN_VALUE',
+            line=2, end_line=7, column=4, end_column=36, occurrence=1)
+
+    def test_matchcase_sequence(self):
+        snippet = textwrap.dedent("""\
+            match x:
+                case a, b:
+                    pass
+            """)
+        compiled_code, _ = self.check_positions_against_ast(snippet)
+        self.assertOpcodeSourcePositionIs(compiled_code, 'MATCH_SEQUENCE',
+            line=2, end_line=2, column=9, end_column=13, occurrence=1)
+        self.assertOpcodeSourcePositionIs(compiled_code, 'UNPACK_SEQUENCE',
+            line=2, end_line=2, column=9, end_column=13, occurrence=1)
+        self.assertOpcodeSourcePositionIs(compiled_code, 'STORE_NAME',
+            line=2, end_line=2, column=9, end_column=13, occurrence=1)
+        self.assertOpcodeSourcePositionIs(compiled_code, 'STORE_NAME',
+            line=2, end_line=2, column=9, end_column=13, occurrence=2)
+
+    def test_matchcase_sequence_wildcard(self):
+        snippet = textwrap.dedent("""\
+            match x:
+                case a, *b, c:
+                    pass
+            """)
+        compiled_code, _ = self.check_positions_against_ast(snippet)
+        self.assertOpcodeSourcePositionIs(compiled_code, 'MATCH_SEQUENCE',
+            line=2, end_line=2, column=9, end_column=17, occurrence=1)
+        self.assertOpcodeSourcePositionIs(compiled_code, 'UNPACK_EX',
+            line=2, end_line=2, column=9, end_column=17, occurrence=1)
+        self.assertOpcodeSourcePositionIs(compiled_code, 'STORE_NAME',
+            line=2, end_line=2, column=9, end_column=17, occurrence=1)
+        self.assertOpcodeSourcePositionIs(compiled_code, 'STORE_NAME',
+            line=2, end_line=2, column=9, end_column=17, occurrence=2)
+        self.assertOpcodeSourcePositionIs(compiled_code, 'STORE_NAME',
+            line=2, end_line=2, column=9, end_column=17, occurrence=3)
+
+    def test_matchcase_mapping(self):
+        snippet = textwrap.dedent("""\
+            match x:
+                case {"a" : a, "b": b}:
+                    pass
+            """)
+        compiled_code, _ = self.check_positions_against_ast(snippet)
+        self.assertOpcodeSourcePositionIs(compiled_code, 'MATCH_MAPPING',
+            line=2, end_line=2, column=9, end_column=26, occurrence=1)
+        self.assertOpcodeSourcePositionIs(compiled_code, 'MATCH_KEYS',
+            line=2, end_line=2, column=9, end_column=26, occurrence=1)
+        self.assertOpcodeSourcePositionIs(compiled_code, 'STORE_NAME',
+            line=2, end_line=2, column=9, end_column=26, occurrence=1)
+        self.assertOpcodeSourcePositionIs(compiled_code, 'STORE_NAME',
+            line=2, end_line=2, column=9, end_column=26, occurrence=2)
+
+    def test_matchcase_mapping_wildcard(self):
+        snippet = textwrap.dedent("""\
+            match x:
+                case {"a" : a, "b": b, **c}:
+                    pass
+            """)
+        compiled_code, _ = self.check_positions_against_ast(snippet)
+        self.assertOpcodeSourcePositionIs(compiled_code, 'MATCH_MAPPING',
+            line=2, end_line=2, column=9, end_column=31, occurrence=1)
+        self.assertOpcodeSourcePositionIs(compiled_code, 'MATCH_KEYS',
+            line=2, end_line=2, column=9, end_column=31, occurrence=1)
+        self.assertOpcodeSourcePositionIs(compiled_code, 'STORE_NAME',
+            line=2, end_line=2, column=9, end_column=31, occurrence=1)
+        self.assertOpcodeSourcePositionIs(compiled_code, 'STORE_NAME',
+            line=2, end_line=2, column=9, end_column=31, occurrence=2)
+
+    def test_matchcase_class(self):
+        snippet = textwrap.dedent("""\
+            match x:
+                case C(a, b):
+                    pass
+            """)
+        compiled_code, _ = self.check_positions_against_ast(snippet)
+        self.assertOpcodeSourcePositionIs(compiled_code, 'MATCH_CLASS',
+            line=2, end_line=2, column=9, end_column=16, occurrence=1)
+        self.assertOpcodeSourcePositionIs(compiled_code, 'UNPACK_SEQUENCE',
+            line=2, end_line=2, column=9, end_column=16, occurrence=1)
+        self.assertOpcodeSourcePositionIs(compiled_code, 'STORE_NAME',
+            line=2, end_line=2, column=9, end_column=16, occurrence=1)
+        self.assertOpcodeSourcePositionIs(compiled_code, 'STORE_NAME',
+            line=2, end_line=2, column=9, end_column=16, occurrence=2)
+
+    def test_matchcase_or(self):
+        snippet = textwrap.dedent("""\
+            match x:
+                case C(1) | C(2):
+                    pass
+            """)
+        compiled_code, _ = self.check_positions_against_ast(snippet)
+        self.assertOpcodeSourcePositionIs(compiled_code, 'MATCH_CLASS',
+            line=2, end_line=2, column=9, end_column=13, occurrence=1)
+        self.assertOpcodeSourcePositionIs(compiled_code, 'MATCH_CLASS',
+            line=2, end_line=2, column=16, end_column=20, occurrence=2)
+
     def test_very_long_line_end_offset(self):
         # Make sure we get the correct column offset for offsets
         # too large to store in a byte.
@@ -1209,16 +2263,16 @@ def test_complex_single_line_expression(self):
         snippet = "a - b @ (c * x['key'] + 23)"
 
         compiled_code, _ = self.check_positions_against_ast(snippet)
-        self.assertOpcodeSourcePositionIs(compiled_code, 'BINARY_SUBSCR',
+        self.assertOpcodeSourcePositionIs(compiled_code, 'BINARY_OP',
             line=1, end_line=1, column=13, end_column=21)
         self.assertOpcodeSourcePositionIs(compiled_code, 'BINARY_OP',
-            line=1, end_line=1, column=9, end_column=21, occurrence=1)
+            line=1, end_line=1, column=9, end_column=21, occurrence=2)
         self.assertOpcodeSourcePositionIs(compiled_code, 'BINARY_OP',
-            line=1, end_line=1, column=9, end_column=26, occurrence=2)
+            line=1, end_line=1, column=9, end_column=26, occurrence=3)
         self.assertOpcodeSourcePositionIs(compiled_code, 'BINARY_OP',
-            line=1, end_line=1, column=4, end_column=27, occurrence=3)
+            line=1, end_line=1, column=4, end_column=27, occurrence=4)
         self.assertOpcodeSourcePositionIs(compiled_code, 'BINARY_OP',
-            line=1, end_line=1, column=0, end_column=27, occurrence=4)
+            line=1, end_line=1, column=0, end_column=27, occurrence=5)
 
     def test_multiline_assert_rewritten_as_method_call(self):
         # GH-94694: Don't crash if pytest rewrites a multiline assert as a
@@ -1268,7 +2322,9 @@ def f():
             with self.subTest(body):
                 namespace = {}
                 source = textwrap.dedent(source_template.format(body))
-                exec(source, namespace)
+                with warnings.catch_warnings():
+                    warnings.simplefilter('ignore', SyntaxWarning)
+                    exec(source, namespace)
                 code = namespace["f"].__code__
                 self.assertOpcodeSourcePositionIs(
                     code,
@@ -1314,7 +2370,7 @@ def test_method_call(self):
         source = "(\n lhs  \n   .    \n     rhs      \n       )()"
         code = compile(source, "<test>", "exec")
         self.assertOpcodeSourcePositionIs(
-            code, "LOAD_METHOD", line=4, end_line=4, column=5, end_column=8
+            code, "LOAD_ATTR", line=4, end_line=4, column=5, end_column=8
         )
         self.assertOpcodeSourcePositionIs(
             code, "CALL", line=4, end_line=5, column=5, end_column=10
@@ -1345,9 +2401,6 @@ def test_column_offset_deduplication(self):
         for source in [
             "lambda: a",
             "(a for b in c)",
-            "[a for b in c]",
-            "{a for b in c}",
-            "{a: b for c in d}",
         ]:
             with self.subTest(source):
                 code = compile(f"{source}, {source}", "<test>", "eval")
@@ -1360,6 +2413,138 @@ def test_column_offset_deduplication(self):
                     list(code.co_consts[1].co_positions()),
                 )
 
+    def test_load_super_attr(self):
+        source = "class C:\n  def __init__(self):\n    super().__init__()"
+        for const in compile(source, "<test>", "exec").co_consts[0].co_consts:
+            if isinstance(const, types.CodeType):
+                code = const
+                break
+        self.assertOpcodeSourcePositionIs(
+            code, "LOAD_GLOBAL", line=3, end_line=3, column=4, end_column=9
+        )
+
+    def test_lambda_return_position(self):
+        snippets = [
+            "f = lambda: x",
+            "f = lambda: 42",
+            "f = lambda: 1 + 2",
+            "f = lambda: a + b",
+        ]
+        for snippet in snippets:
+            with self.subTest(snippet=snippet):
+                lamb = run_code(snippet)["f"]
+                positions = lamb.__code__.co_positions()
+                # assert that all positions are within the lambda
+                for i, pos in enumerate(positions):
+                    with self.subTest(i=i, pos=pos):
+                        start_line, end_line, start_col, end_col = pos
+                        if i == 0 and start_col == end_col == 0:
+                            # ignore the RESUME in the beginning
+                            continue
+                        self.assertEqual(start_line, 1)
+                        self.assertEqual(end_line, 1)
+                        code_start = snippet.find(":") + 2
+                        code_end = len(snippet)
+                        self.assertGreaterEqual(start_col, code_start)
+                        self.assertLessEqual(end_col, code_end)
+                        self.assertGreaterEqual(end_col, start_col)
+                        self.assertLessEqual(end_col, code_end)
+
+    def test_return_in_with_positions(self):
+        # See gh-98442
+        def f():
+            with xyz:
+                1
+                2
+                3
+                4
+                return R
+
+        # All instructions should have locations on a single line
+        for instr in dis.get_instructions(f):
+            start_line, end_line, _, _ = instr.positions
+            self.assertEqual(start_line, end_line)
+
+        # Expect four `LOAD_CONST None` instructions:
+        # three for the no-exception __exit__ call, and one for the return.
+        # They should all have the locations of the context manager ('xyz').
+
+        load_none = [instr for instr in dis.get_instructions(f) if
+                     instr.opname == 'LOAD_CONST' and instr.argval is None]
+        return_value = [instr for instr in dis.get_instructions(f) if
+                        instr.opname == 'RETURN_VALUE']
+
+        self.assertEqual(len(load_none), 4)
+        self.assertEqual(len(return_value), 2)
+        for instr in load_none + return_value:
+            start_line, end_line, start_col, end_col = instr.positions
+            self.assertEqual(start_line, f.__code__.co_firstlineno + 1)
+            self.assertEqual(end_line, f.__code__.co_firstlineno + 1)
+            self.assertEqual(start_col, 17)
+            self.assertEqual(end_col, 20)
+
+
+class TestStaticAttributes(unittest.TestCase):
+
+    def test_basic(self):
+        class C:
+            def f(self):
+                self.a = self.b = 42
+                # read fields are not included
+                self.f()
+                self.arr[3]
+
+        self.assertIsInstance(C.__static_attributes__, tuple)
+        self.assertEqual(sorted(C.__static_attributes__), ['a', 'b'])
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AttributeError: type object 'C' has no attribute '__static_attributes__'
+    def test_nested_function(self):
+        class C:
+            def f(self):
+                self.x = 1
+                self.y = 2
+                self.x = 3   # check deduplication
+
+            def g(self, obj):
+                self.y = 4
+                self.z = 5
+
+                def h(self, a):
+                    self.u = 6
+                    self.v = 7
+
+                obj.self = 8
+
+        self.assertEqual(sorted(C.__static_attributes__), ['u', 'v', 'x', 'y', 'z'])
+
+    def test_nested_class(self):
+        class C:
+            def f(self):
+                self.x = 42
+                self.y = 42
+
+            class D:
+                def g(self):
+                    self.y = 42
+                    self.z = 42
+
+        self.assertEqual(sorted(C.__static_attributes__), ['x', 'y'])
+        self.assertEqual(sorted(C.D.__static_attributes__), ['y', 'z'])
+
+    def test_subclass(self):
+        class C:
+            def f(self):
+                self.x = 42
+                self.y = 42
+
+        class D(C):
+            def g(self):
+                self.y = 42
+                self.z = 42
+
+        self.assertEqual(sorted(C.__static_attributes__), ['x', 'y'])
+        self.assertEqual(sorted(D.__static_attributes__), ['y', 'z'])
+
 
 class TestExpressionStackSize(unittest.TestCase):
     # These tests check that the computed stack size for a code object
@@ -1393,28 +2578,22 @@ def test_if_else(self):
     def test_binop(self):
         self.check_stack_size("x + " * self.N + "x")
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AssertionError: 101 not less than or equal to 6
     def test_list(self):
         self.check_stack_size("[" + "x, " * self.N + "x]")
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AssertionError: 101 not less than or equal to 6
     def test_tuple(self):
         self.check_stack_size("(" + "x, " * self.N + "x)")
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AssertionError: 101 not less than or equal to 6
     def test_set(self):
         self.check_stack_size("{" + "x, " * self.N + "x}")
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_dict(self):
         self.check_stack_size("{" + "x:x, " * self.N + "x:x}")
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AssertionError: 102 not less than or equal to 6
     def test_func_args(self):
         self.check_stack_size("f(" + "x, " * self.N + ")")
 
@@ -1422,8 +2601,7 @@ def test_func_kwargs(self):
         kwargs = (f'a{i}=x' for i in range(self.N))
         self.check_stack_size("f(" +  ", ".join(kwargs) + ")")
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AssertionError: 102 not less than or equal to 6
     def test_meth_args(self):
         self.check_stack_size("o.m(" + "x, " * self.N + ")")
 
@@ -1460,7 +2638,9 @@ def compile_snippet(i):
             script = """def func():\n""" + i * snippet
             if async_:
                 script = "async " + script
-            code = compile(script, "<script>", "exec")
+            with warnings.catch_warnings():
+                warnings.simplefilter('ignore', SyntaxWarning)
+                code = compile(script, "<script>", "exec")
             exec(code, ns, ns)
             return ns['func'].__code__
 
@@ -1773,6 +2953,67 @@ def test_return_inside_async_with_block(self):
             """
         self.check_stack_size(snippet, async_=True)
 
+@support.cpython_only
+@unittest.skipIf(_testinternalcapi is None, 'need _testinternalcapi module')
+class TestInstructionSequence(unittest.TestCase):
+    def compare_instructions(self, seq, expected):
+        self.assertEqual([(opcode.opname[i[0]],) + i[1:] for i in seq.get_instructions()],
+                         expected)
+
+    def test_basics(self):
+        seq = _testinternalcapi.new_instruction_sequence()
+
+        def add_op(seq, opname, oparg, bl, bc=0, el=0, ec=0):
+            seq.addop(opcode.opmap[opname], oparg, bl, bc, el, el)
+
+        add_op(seq, 'LOAD_CONST', 1, 1)
+        add_op(seq, 'JUMP', lbl1 := seq.new_label(), 2)
+        add_op(seq, 'LOAD_CONST', 1, 3)
+        add_op(seq, 'JUMP', lbl2 := seq.new_label(), 4)
+        seq.use_label(lbl1)
+        add_op(seq, 'LOAD_CONST', 2, 4)
+        seq.use_label(lbl2)
+        add_op(seq, 'RETURN_VALUE', 0, 3)
+
+        expected = [('LOAD_CONST', 1, 1),
+                    ('JUMP', 4, 2),
+                    ('LOAD_CONST', 1, 3),
+                    ('JUMP', 5, 4),
+                    ('LOAD_CONST', 2, 4),
+                    ('RETURN_VALUE', None, 3),
+                   ]
+
+        self.compare_instructions(seq, [ex + (0,0,0) for ex in expected])
+
+    def test_nested(self):
+        seq = _testinternalcapi.new_instruction_sequence()
+        seq.addop(opcode.opmap['LOAD_CONST'], 1, 1, 0, 0, 0)
+        nested = _testinternalcapi.new_instruction_sequence()
+        nested.addop(opcode.opmap['LOAD_CONST'], 2, 2, 0, 0, 0)
+
+        self.compare_instructions(seq, [('LOAD_CONST', 1, 1, 0, 0, 0)])
+        self.compare_instructions(nested, [('LOAD_CONST', 2, 2, 0, 0, 0)])
+
+        seq.add_nested(nested)
+        self.compare_instructions(seq, [('LOAD_CONST', 1, 1, 0, 0, 0)])
+        self.compare_instructions(seq.get_nested()[0], [('LOAD_CONST', 2, 2, 0, 0, 0)])
+
+    def test_static_attributes_are_sorted(self):
+        code = (
+            'class T:\n'
+            '    def __init__(self):\n'
+            '        self.{V1} = 10\n'
+            '        self.{V2} = 10\n'
+            '    def foo(self):\n'
+            '        self.{V3} = 10\n'
+        )
+        attributes = ("a", "b", "c")
+        for perm in itertools.permutations(attributes):
+            var_names = {f'V{i + 1}': name for i, name in enumerate(perm)}
+            ns = run_code(code.format(**var_names))
+            t = ns['T']
+            self.assertEqual(t.__static_attributes__, attributes)
+
 
 if __name__ == "__main__":
     unittest.main()
diff --git a/Lib/test/test_compileall.py b/Lib/test/test_compileall.py
index 9fa3dbc47e5..bb178d487e5 100644
--- a/Lib/test/test_compileall.py
+++ b/Lib/test/test_compileall.py
@@ -18,7 +18,7 @@
     # compileall relies on ProcessPoolExecutor if ProcessPoolExecutor exists
     # and it can function.
     from multiprocessing.util import _cleanup_tests as multiprocessing_cleanup_tests
-    from concurrent.futures import ProcessPoolExecutor
+    from concurrent.futures import ProcessPoolExecutor  # noqa: F401
     from concurrent.futures.process import _check_system_limits
     _check_system_limits()
     _have_multiprocessing = True
@@ -316,7 +316,7 @@ def _test_ddir_only(self, *, ddir, parallel=True):
 
         self.assertTrue(mods)
         for mod in mods:
-            self.assertTrue(mod.startswith(self.directory), mod)
+            self.assertStartsWith(mod, self.directory)
             modcode = importlib.util.cache_from_source(mod)
             modpath = mod[len(self.directory+os.sep):]
             _, _, err = script_helper.assert_python_failure(modcode)
@@ -576,8 +576,7 @@ def assertNotCompiled(self, fn):
         path = importlib.util.cache_from_source(fn)
         self.assertFalse(os.path.exists(path))
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_no_args_compiles_path(self):
         # Note that -l is implied for the no args case.
         bazfn = script_helper.make_script(self.directory, 'baz', '')
@@ -587,8 +586,7 @@ def test_no_args_compiles_path(self):
             self.assertNotCompiled(self.initfn)
             self.assertNotCompiled(self.barfn)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     @without_source_date_epoch  # timestamp invalidation test
     @support.requires_resource('cpu')
     def test_no_args_respects_force_flag(self):
@@ -722,7 +720,6 @@ def test_recursion_limit(self):
         self.assertCompiled(spamfn)
         self.assertCompiled(eggfn)
 
-    @unittest.skipIf(sys.platform == 'win32', 'TODO: RUSTPYTHON hangs')
     @os_helper.skip_unless_symlink
     def test_symlink_loop(self):
         # Currently, compileall ignores symlinks to directories.
diff --git a/Lib/test/test_complex.py b/Lib/test/test_complex.py
index 86d075de8ce..4adfa0a60ad 100644
--- a/Lib/test/test_complex.py
+++ b/Lib/test/test_complex.py
@@ -39,6 +39,16 @@ def __float__(self):
 class ComplexSubclass(complex):
     pass
 
+class OtherComplexSubclass(complex):
+    pass
+
+class MyInt:
+    def __init__(self, value):
+        self.value = value
+
+    def __int__(self):
+        return self.value
+
 class WithComplex:
     def __init__(self, value):
         self.value = value
@@ -93,6 +103,7 @@ def check_div(self, x, y):
             q = z.__truediv__(y)
             self.assertClose(q, x)
 
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AssertionError: floats nan and inf are not identical
     def test_truediv(self):
         simple_real = [float(i) for i in range(-5, 6)]
         simple_complex = [complex(x, y) for x in simple_real for y in simple_real]
@@ -118,6 +129,72 @@ def test_truediv(self):
             z = complex(0, 0) / complex(denom_real, denom_imag)
             self.assertTrue(isnan(z.real))
             self.assertTrue(isnan(z.imag))
+            z = float(0) / complex(denom_real, denom_imag)
+            self.assertTrue(isnan(z.real))
+            self.assertTrue(isnan(z.imag))
+
+        self.assertComplexesAreIdentical(complex(INF, NAN) / 2,
+                                         complex(INF, NAN))
+
+        self.assertComplexesAreIdentical(complex(INF, 1)/(0.0+1j),
+                                         complex(NAN, -INF))
+
+        # test recover of infs if numerator has infs and denominator is finite
+        self.assertComplexesAreIdentical(complex(INF, -INF)/(1+0j),
+                                         complex(INF, -INF))
+        self.assertComplexesAreIdentical(complex(INF, INF)/(0.0+1j),
+                                         complex(INF, -INF))
+        self.assertComplexesAreIdentical(complex(NAN, INF)/complex(2**1000, 2**-1000),
+                                         complex(INF, INF))
+        self.assertComplexesAreIdentical(complex(INF, NAN)/complex(2**1000, 2**-1000),
+                                         complex(INF, -INF))
+
+        # test recover of zeros if denominator is infinite
+        self.assertComplexesAreIdentical((1+1j)/complex(INF, INF), (0.0+0j))
+        self.assertComplexesAreIdentical((1+1j)/complex(INF, -INF), (0.0+0j))
+        self.assertComplexesAreIdentical((1+1j)/complex(-INF, INF),
+                                         complex(0.0, -0.0))
+        self.assertComplexesAreIdentical((1+1j)/complex(-INF, -INF),
+                                         complex(-0.0, 0))
+        self.assertComplexesAreIdentical((INF+1j)/complex(INF, INF),
+                                         complex(NAN, NAN))
+        self.assertComplexesAreIdentical(complex(1, INF)/complex(INF, INF),
+                                         complex(NAN, NAN))
+        self.assertComplexesAreIdentical(complex(INF, 1)/complex(1, INF),
+                                         complex(NAN, NAN))
+
+        # mixed types
+        self.assertEqual((1+1j)/float(2), 0.5+0.5j)
+        self.assertEqual(float(1)/(1+2j), 0.2-0.4j)
+        self.assertEqual(float(1)/(-1+2j), -0.2-0.4j)
+        self.assertEqual(float(1)/(1-2j), 0.2+0.4j)
+        self.assertEqual(float(1)/(2+1j), 0.4-0.2j)
+        self.assertEqual(float(1)/(-2+1j), -0.4-0.2j)
+        self.assertEqual(float(1)/(2-1j), 0.4+0.2j)
+
+        self.assertComplexesAreIdentical(INF/(1+0j),
+                                         complex(INF, NAN))
+        self.assertComplexesAreIdentical(INF/(0.0+1j),
+                                         complex(NAN, -INF))
+        self.assertComplexesAreIdentical(INF/complex(2**1000, 2**-1000),
+                                         complex(INF, NAN))
+        self.assertComplexesAreIdentical(INF/complex(NAN, NAN),
+                                         complex(NAN, NAN))
+
+        self.assertComplexesAreIdentical(float(1)/complex(INF, INF), (0.0-0j))
+        self.assertComplexesAreIdentical(float(1)/complex(INF, -INF), (0.0+0j))
+        self.assertComplexesAreIdentical(float(1)/complex(-INF, INF),
+                                         complex(-0.0, -0.0))
+        self.assertComplexesAreIdentical(float(1)/complex(-INF, -INF),
+                                         complex(-0.0, 0))
+        self.assertComplexesAreIdentical(float(1)/complex(INF, NAN),
+                                         complex(0.0, -0.0))
+        self.assertComplexesAreIdentical(float(1)/complex(-INF, NAN),
+                                         complex(-0.0, -0.0))
+        self.assertComplexesAreIdentical(float(1)/complex(NAN, INF),
+                                         complex(0.0, -0.0))
+        self.assertComplexesAreIdentical(float(INF)/complex(NAN, INF),
+                                         complex(NAN, NAN))
 
     def test_truediv_zero_division(self):
         for a, b in ZERO_DIVISION:
@@ -169,8 +246,7 @@ def test_richcompare(self):
         self.assertIs(operator.ne(1+1j, 2+2j), True)
         self.assertIs(operator.eq(1+1j, 2.0), False)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AssertionError: True is not False
     def test_richcompare_boundaries(self):
         def check(n, deltas, is_equal, imag = 0.0):
             for delta in deltas:
@@ -191,6 +267,10 @@ def check(n, deltas, is_equal, imag = 0.0):
     def test_add(self):
         self.assertEqual(1j + int(+1), complex(+1, 1))
         self.assertEqual(1j + int(-1), complex(-1, 1))
+        self.assertComplexesAreIdentical(complex(-0.0, -0.0) + (-0.0),
+                                         complex(-0.0, -0.0))
+        self.assertComplexesAreIdentical((-0.0) + complex(-0.0, -0.0),
+                                         complex(-0.0, -0.0))
         self.assertRaises(OverflowError, operator.add, 1j, 10**1000)
         self.assertRaises(TypeError, operator.add, 1j, None)
         self.assertRaises(TypeError, operator.add, None, 1j)
@@ -198,17 +278,48 @@ def test_add(self):
     def test_sub(self):
         self.assertEqual(1j - int(+1), complex(-1, 1))
         self.assertEqual(1j - int(-1), complex(1, 1))
+        self.assertComplexesAreIdentical(complex(-0.0, -0.0) - 0.0,
+                                         complex(-0.0, -0.0))
+        self.assertComplexesAreIdentical(-0.0 - complex(0.0, 0.0),
+                                         complex(-0.0, -0.0))
+        self.assertComplexesAreIdentical(complex(1, 2) - complex(2, 1),
+                                         complex(-1, 1))
+        self.assertComplexesAreIdentical(complex(2, 1) - complex(1, 2),
+                                         complex(1, -1))
         self.assertRaises(OverflowError, operator.sub, 1j, 10**1000)
         self.assertRaises(TypeError, operator.sub, 1j, None)
         self.assertRaises(TypeError, operator.sub, None, 1j)
 
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_mul(self):
         self.assertEqual(1j * int(20), complex(0, 20))
         self.assertEqual(1j * int(-1), complex(0, -1))
+        for c, r in [(2, complex(INF, 2)), (INF, complex(INF, INF)),
+                     (0, complex(NAN, 0)), (-0.0, complex(NAN, -0.0)),
+                     (NAN, complex(NAN, NAN))]:
+            with self.subTest(c=c, r=r):
+                self.assertComplexesAreIdentical(complex(INF, 1) * c, r)
+                self.assertComplexesAreIdentical(c * complex(INF, 1), r)
         self.assertRaises(OverflowError, operator.mul, 1j, 10**1000)
         self.assertRaises(TypeError, operator.mul, 1j, None)
         self.assertRaises(TypeError, operator.mul, None, 1j)
 
+        for z, w, r in [(1e300+1j, complex(INF, INF), complex(NAN, INF)),
+                        (1e300+1j, complex(NAN, INF), complex(-INF, INF)),
+                        (1e300+1j, complex(INF, NAN), complex(INF, INF)),
+                        (complex(INF, 1), complex(NAN, INF), complex(NAN, INF)),
+                        (complex(INF, 1), complex(INF, NAN), complex(INF, NAN)),
+                        (complex(NAN, 1), complex(1, INF), complex(-INF, NAN)),
+                        (complex(1, NAN), complex(1, INF), complex(NAN, INF)),
+                        (complex(1e200, NAN), complex(1e200, NAN), complex(INF, NAN)),
+                        (complex(1e200, NAN), complex(NAN, 1e200), complex(NAN, INF)),
+                        (complex(NAN, 1e200), complex(1e200, NAN), complex(NAN, INF)),
+                        (complex(NAN, 1e200), complex(NAN, 1e200), complex(-INF, NAN)),
+                        (complex(NAN, NAN), complex(NAN, NAN), complex(NAN, NAN))]:
+            with self.subTest(z=z, w=w, r=r):
+                self.assertComplexesAreIdentical(z * w, r)
+                self.assertComplexesAreIdentical(w * z, r)
+
     def test_mod(self):
         # % is no longer supported on complex numbers
         with self.assertRaises(TypeError):
@@ -250,6 +361,7 @@ def test_pow(self):
         self.assertAlmostEqual(pow(1j, 200), 1)
         self.assertRaises(ValueError, pow, 1+1j, 1+1j, 1+1j)
         self.assertRaises(OverflowError, pow, 1e200+1j, 1e200+1j)
+        self.assertRaises(OverflowError, pow, 1e200+1j, 5)
         self.assertRaises(TypeError, pow, 1j, None)
         self.assertRaises(TypeError, pow, None, 1j)
         self.assertAlmostEqual(pow(1j, 0.5), 0.7071067811865476+0.7071067811865475j)
@@ -347,8 +459,7 @@ def test_boolcontext(self):
     def test_conjugate(self):
         self.assertClose(complex(5.3, 9.8).conjugate(), 5.3-9.8j)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AssertionError: DeprecationWarning not triggered
     def test_constructor(self):
         def check(z, x, y):
             self.assertIs(type(z), complex)
@@ -371,25 +482,53 @@ def check(z, x, y):
         check(complex(1.0, 10.0), 1.0, 10.0)
         check(complex(4.25, 0.5), 4.25, 0.5)
 
-        check(complex(4.25+0j, 0), 4.25, 0.0)
-        check(complex(ComplexSubclass(4.25+0j), 0), 4.25, 0.0)
-        check(complex(WithComplex(4.25+0j), 0), 4.25, 0.0)
-        check(complex(4.25j, 0), 0.0, 4.25)
-        check(complex(0j, 4.25), 0.0, 4.25)
-        check(complex(0, 4.25+0j), 0.0, 4.25)
-        check(complex(0, ComplexSubclass(4.25+0j)), 0.0, 4.25)
+        with self.assertWarnsRegex(DeprecationWarning,
+                "argument 'real' must be a real number, not complex"):
+            check(complex(4.25+0j, 0), 4.25, 0.0)
+        with self.assertWarnsRegex(DeprecationWarning,
+                "argument 'real' must be a real number, not .*ComplexSubclass"):
+            check(complex(ComplexSubclass(4.25+0j), 0), 4.25, 0.0)
+        with self.assertWarnsRegex(DeprecationWarning,
+                "argument 'real' must be a real number, not .*WithComplex"):
+            check(complex(WithComplex(4.25+0j), 0), 4.25, 0.0)
+        with self.assertWarnsRegex(DeprecationWarning,
+                "argument 'real' must be a real number, not complex"):
+            check(complex(4.25j, 0), 0.0, 4.25)
+        with self.assertWarnsRegex(DeprecationWarning,
+                "argument 'real' must be a real number, not complex"):
+            check(complex(0j, 4.25), 0.0, 4.25)
+        with self.assertWarnsRegex(DeprecationWarning,
+                "argument 'imag' must be a real number, not complex"):
+            check(complex(0, 4.25+0j), 0.0, 4.25)
+        with self.assertWarnsRegex(DeprecationWarning,
+                "argument 'imag' must be a real number, not .*ComplexSubclass"):
+            check(complex(0, ComplexSubclass(4.25+0j)), 0.0, 4.25)
         with self.assertRaisesRegex(TypeError,
-                "second argument must be a number, not 'WithComplex'"):
+                "argument 'imag' must be a real number, not .*WithComplex"):
             complex(0, WithComplex(4.25+0j))
-        check(complex(0.0, 4.25j), -4.25, 0.0)
-        check(complex(4.25+0j, 0j), 4.25, 0.0)
-        check(complex(4.25j, 0j), 0.0, 4.25)
-        check(complex(0j, 4.25+0j), 0.0, 4.25)
-        check(complex(0j, 4.25j), -4.25, 0.0)
+        with self.assertWarnsRegex(DeprecationWarning,
+                "argument 'imag' must be a real number, not complex"):
+            check(complex(0.0, 4.25j), -4.25, 0.0)
+        with self.assertWarnsRegex(DeprecationWarning,
+                "argument 'real' must be a real number, not complex"):
+            check(complex(4.25+0j, 0j), 4.25, 0.0)
+        with self.assertWarnsRegex(DeprecationWarning,
+                "argument 'real' must be a real number, not complex"):
+            check(complex(4.25j, 0j), 0.0, 4.25)
+        with self.assertWarnsRegex(DeprecationWarning,
+                "argument 'real' must be a real number, not complex"):
+            check(complex(0j, 4.25+0j), 0.0, 4.25)
+        with self.assertWarnsRegex(DeprecationWarning,
+                "argument 'real' must be a real number, not complex"):
+            check(complex(0j, 4.25j), -4.25, 0.0)
 
         check(complex(real=4.25), 4.25, 0.0)
-        check(complex(real=4.25+0j), 4.25, 0.0)
-        check(complex(real=4.25+1.5j), 4.25, 1.5)
+        with self.assertWarnsRegex(DeprecationWarning,
+                "argument 'real' must be a real number, not complex"):
+            check(complex(real=4.25+0j), 4.25, 0.0)
+        with self.assertWarnsRegex(DeprecationWarning,
+                "argument 'real' must be a real number, not complex"):
+            check(complex(real=4.25+1.5j), 4.25, 1.5)
         check(complex(imag=1.5), 0.0, 1.5)
         check(complex(real=4.25, imag=1.5), 4.25, 1.5)
         check(complex(4.25, imag=1.5), 4.25, 1.5)
@@ -409,22 +548,22 @@ def check(z, x, y):
         del c, c2
 
         self.assertRaisesRegex(TypeError,
-            "first argument must be a string or a number, not 'dict'",
+            "argument must be a string or a number, not dict",
             complex, {})
         self.assertRaisesRegex(TypeError,
-            "first argument must be a string or a number, not 'NoneType'",
+            "argument must be a string or a number, not NoneType",
             complex, None)
         self.assertRaisesRegex(TypeError,
-            "first argument must be a string or a number, not 'dict'",
+            "argument 'real' must be a real number, not dict",
             complex, {1:2}, 0)
         self.assertRaisesRegex(TypeError,
-            "can't take second arg if first is a string",
+            "argument 'real' must be a real number, not str",
             complex, '1', 0)
         self.assertRaisesRegex(TypeError,
-            "second argument must be a number, not 'dict'",
+            "argument 'imag' must be a real number, not dict",
             complex, 0, {1:2})
         self.assertRaisesRegex(TypeError,
-                "second arg can't be a string",
+            "argument 'imag' must be a real number, not str",
             complex, 0, '1')
 
         self.assertRaises(TypeError, complex, WithComplex(1.5))
@@ -605,6 +744,35 @@ def test_underscores(self):
             if not any(ch in lit for ch in 'xXoObB'):
                 self.assertRaises(ValueError, complex, lit)
 
+    def test_from_number(self, cls=complex):
+        def eq(actual, expected):
+            self.assertEqual(actual, expected)
+            self.assertIs(type(actual), cls)
+
+        eq(cls.from_number(3.14), 3.14+0j)
+        eq(cls.from_number(3.14j), 3.14j)
+        eq(cls.from_number(314), 314.0+0j)
+        eq(cls.from_number(OtherComplexSubclass(3.14, 2.72)), 3.14+2.72j)
+        eq(cls.from_number(WithComplex(3.14+2.72j)), 3.14+2.72j)
+        eq(cls.from_number(WithFloat(3.14)), 3.14+0j)
+        eq(cls.from_number(WithIndex(314)), 314.0+0j)
+
+        cNAN = complex(NAN, NAN)
+        x = cls.from_number(cNAN)
+        self.assertTrue(x != x)
+        self.assertIs(type(x), cls)
+        if cls is complex:
+            self.assertIs(cls.from_number(cNAN), cNAN)
+
+        self.assertRaises(TypeError, cls.from_number, '3.14')
+        self.assertRaises(TypeError, cls.from_number, b'3.14')
+        self.assertRaises(TypeError, cls.from_number, MyInt(314))
+        self.assertRaises(TypeError, cls.from_number, {})
+        self.assertRaises(TypeError, cls.from_number)
+
+    def test_from_number_subclass(self):
+        self.test_from_number(ComplexSubclass)
+
     def test_hash(self):
         for x in range(-30, 30):
             self.assertEqual(hash(x), hash(complex(x, 0)))
diff --git a/Lib/test/test_concurrent_futures/test_process_pool.py b/Lib/test/test_concurrent_futures/test_process_pool.py
index 46dbdedd435..5d4e9677f5c 100644
--- a/Lib/test/test_concurrent_futures/test_process_pool.py
+++ b/Lib/test/test_concurrent_futures/test_process_pool.py
@@ -85,7 +85,6 @@ 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
diff --git a/Lib/test/test_concurrent_futures/test_wait.py b/Lib/test/test_concurrent_futures/test_wait.py
index 7a7857671a4..6749a690f6c 100644
--- a/Lib/test/test_concurrent_futures/test_wait.py
+++ b/Lib/test/test_concurrent_futures/test_wait.py
@@ -200,20 +200,5 @@ 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()
diff --git a/Lib/test/test_configparser.py b/Lib/test/test_configparser.py
index d95b504f826..1bfb53ccbb1 100644
--- a/Lib/test/test_configparser.py
+++ b/Lib/test/test_configparser.py
@@ -526,7 +526,6 @@ def test_default_case_sensitivity(self):
             cf.get(self.default_section, "Foo"), "Bar",
             "could not locate option, expecting case-insensitive defaults")
 
-    @unittest.skipIf(os.name == "nt", "TODO: RUSTPYTHON, universal newlines")
     def test_parse_errors(self):
         cf = self.newconfig()
         self.parse_error(cf, configparser.ParsingError,
@@ -762,7 +761,6 @@ def test_read_returns_file_list(self):
         parsed_files = cf.read([], encoding="utf-8")
         self.assertEqual(parsed_files, [])
 
-    # 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')
@@ -988,12 +986,12 @@ def test_add_section_default(self):
 
     def test_defaults_keyword(self):
         """bpo-23835 fix for ConfigParser"""
-        cf = self.newconfig(defaults={1: 2.4})
-        self.assertEqual(cf[self.default_section]['1'], '2.4')
-        self.assertAlmostEqual(cf[self.default_section].getfloat('1'), 2.4)
-        cf = self.newconfig(defaults={"A": 5.2})
-        self.assertEqual(cf[self.default_section]['a'], '5.2')
-        self.assertAlmostEqual(cf[self.default_section].getfloat('a'), 5.2)
+        cf = self.newconfig(defaults={1: 2.5})
+        self.assertEqual(cf[self.default_section]['1'], '2.5')
+        self.assertAlmostEqual(cf[self.default_section].getfloat('1'), 2.5)
+        cf = self.newconfig(defaults={"A": 5.25})
+        self.assertEqual(cf[self.default_section]['a'], '5.25')
+        self.assertAlmostEqual(cf[self.default_section].getfloat('a'), 5.25)
 
 
 class ConfigParserTestCaseNoInterpolation(BasicTestCase, unittest.TestCase):
@@ -2204,6 +2202,40 @@ def test_no_section(self):
         self.assertEqual('1', cfg2[configparser.UNNAMED_SECTION]['a'])
         self.assertEqual('2', cfg2[configparser.UNNAMED_SECTION]['b'])
 
+    def test_empty_unnamed_section(self):
+        cfg = configparser.ConfigParser(allow_unnamed_section=True)
+        cfg.add_section(configparser.UNNAMED_SECTION)
+        cfg.add_section('section')
+        output = io.StringIO()
+        cfg.write(output)
+        self.assertEqual(output.getvalue(), '[section]\n\n')
+
+    def test_add_section(self):
+        cfg = configparser.ConfigParser(allow_unnamed_section=True)
+        cfg.add_section(configparser.UNNAMED_SECTION)
+        cfg.set(configparser.UNNAMED_SECTION, 'a', '1')
+        self.assertEqual('1', cfg[configparser.UNNAMED_SECTION]['a'])
+        output = io.StringIO()
+        cfg.write(output)
+        self.assertEqual(output.getvalue(), 'a = 1\n\n')
+
+        cfg = configparser.ConfigParser(allow_unnamed_section=True)
+        cfg[configparser.UNNAMED_SECTION] = {'a': '1'}
+        self.assertEqual('1', cfg[configparser.UNNAMED_SECTION]['a'])
+        output = io.StringIO()
+        cfg.write(output)
+        self.assertEqual(output.getvalue(), 'a = 1\n\n')
+
+    def test_disabled_error(self):
+        with self.assertRaises(configparser.MissingSectionHeaderError):
+            configparser.ConfigParser().read_string("a = 1")
+
+        with self.assertRaises(configparser.UnnamedSectionDisabledError):
+            configparser.ConfigParser().add_section(configparser.UNNAMED_SECTION)
+
+        with self.assertRaises(configparser.UnnamedSectionDisabledError):
+            configparser.ConfigParser()[configparser.UNNAMED_SECTION] = {'a': '1'}
+
     def test_multiple_configs(self):
         cfg = configparser.ConfigParser(allow_unnamed_section=True)
         cfg.read_string('a = 1')
@@ -2214,6 +2246,30 @@ def test_multiple_configs(self):
         self.assertEqual('2', cfg[configparser.UNNAMED_SECTION]['b'])
 
 
+class InvalidInputTestCase(unittest.TestCase):
+    """Tests for issue #65697, where configparser will write configs
+    it parses back differently. Ex: keys containing delimiters or
+    matching the section pattern"""
+
+    def test_delimiter_in_key(self):
+        cfg = configparser.ConfigParser(delimiters=('='))
+        cfg.add_section('section1')
+        cfg.set('section1', 'a=b', 'c')
+        output = io.StringIO()
+        with self.assertRaises(configparser.InvalidWriteError):
+            cfg.write(output)
+        output.close()
+
+    def test_section_bracket_in_key(self):
+        cfg = configparser.ConfigParser()
+        cfg.add_section('section1')
+        cfg.set('section1', '[this parses back as a section]', 'foo')
+        output = io.StringIO()
+        with self.assertRaises(configparser.InvalidWriteError):
+            cfg.write(output)
+        output.close()
+
+
 class MiscTestCase(unittest.TestCase):
     def test__all__(self):
         support.check__all__(self, configparser, not_exported={"Error"})
diff --git a/Lib/test/test_contains.py b/Lib/test/test_contains.py
index 471d04a76ca..7339f16ace2 100644
--- a/Lib/test/test_contains.py
+++ b/Lib/test/test_contains.py
@@ -16,6 +16,7 @@ def __getitem__(self, n):
         return [self.el][n]
 
 class TestContains(unittest.TestCase):
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; Wrong error message
     def test_common_tests(self):
         a = base_set(1)
         b = myset(1)
@@ -24,8 +25,11 @@ def test_common_tests(self):
         self.assertNotIn(0, b)
         self.assertIn(1, c)
         self.assertNotIn(0, c)
-        self.assertRaises(TypeError, lambda: 1 in a)
-        self.assertRaises(TypeError, lambda: 1 not in a)
+        msg = "argument of type 'base_set' is not a container or iterable"
+        with self.assertRaisesRegex(TypeError, msg):
+            1 in a
+        with self.assertRaisesRegex(TypeError, msg):
+            1 not in a
 
         # test char in string
         self.assertIn('c', 'abc')
diff --git a/Lib/test/test_contextlib.py b/Lib/test/test_contextlib.py
index 420cc2510a8..d7145cd6fb2 100644
--- a/Lib/test/test_contextlib.py
+++ b/Lib/test/test_contextlib.py
@@ -99,8 +99,6 @@ def woohoo():
                 raise ZeroDivisionError()
         self.assertEqual(state, [1, 42, 999])
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_contextmanager_traceback(self):
         @contextmanager
         def f():
@@ -924,8 +922,6 @@ def __exit__(self, *exc_details):
         self.assertIsInstance(inner_exc, ValueError)
         self.assertIsInstance(inner_exc.__context__, ZeroDivisionError)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_exit_exception_chaining(self):
         # Ensure exception chaining matches the reference behaviour
         def raise_exc(exc):
@@ -957,8 +953,6 @@ def suppress_exc(*exc_details):
         self.assertIsInstance(inner_exc, ValueError)
         self.assertIsInstance(inner_exc.__context__, ZeroDivisionError)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_exit_exception_explicit_none_context(self):
         # Ensure ExitStack chaining matches actual nested `with` statements
         # regarding explicit __context__ = None.
@@ -1053,8 +1047,6 @@ def gets_the_context_right(exc):
             self.assertIsNone(
                        exc.__context__.__context__.__context__.__context__)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_exit_exception_with_existing_context(self):
         # Addresses a lack of test coverage discovered after checking in a
         # fix for issue 20317 that still contained debugging code.
diff --git a/Lib/test/test_contextlib_async.py b/Lib/test/test_contextlib_async.py
index a224bc68329..95d0bd7f92b 100644
--- a/Lib/test/test_contextlib_async.py
+++ b/Lib/test/test_contextlib_async.py
@@ -252,7 +252,6 @@ async def woohoo():
             raise ZeroDivisionError(999)
         self.assertEqual(state, [1, 42, 999])
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     async def test_contextmanager_except_stopiter(self):
         @asynccontextmanager
         async def woohoo():
@@ -650,7 +649,6 @@ async def __aenter__(self):
                 await stack.enter_async_context(LacksExit())
             self.assertFalse(stack._exit_callbacks)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     async def test_async_exit_exception_chaining(self):
         # Ensure exception chaining matches the reference behaviour
         async def raise_exc(exc):
@@ -682,7 +680,6 @@ async def suppress_exc(*exc_details):
         self.assertIsInstance(inner_exc, ValueError)
         self.assertIsInstance(inner_exc.__context__, ZeroDivisionError)
 
-    @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.
diff --git a/Lib/test/test_copy.py b/Lib/test/test_copy.py
index 3dec64cc9a2..cfef24727e8 100644
--- a/Lib/test/test_copy.py
+++ b/Lib/test/test_copy.py
@@ -19,7 +19,7 @@ class TestCopy(unittest.TestCase):
 
     def test_exceptions(self):
         self.assertIs(copy.Error, copy.error)
-        self.assertTrue(issubclass(copy.Error, Exception))
+        self.assertIsSubclass(copy.Error, Exception)
 
     # The copy() method
 
@@ -371,6 +371,8 @@ def test_deepcopy_list(self):
         self.assertIsNot(x, y)
         self.assertIsNot(x[0], y[0])
 
+    @support.skip_emscripten_stack_overflow()
+    @support.skip_wasi_stack_overflow()
     def test_deepcopy_reflexive_list(self):
         x = []
         x.append(x)
@@ -398,6 +400,8 @@ def test_deepcopy_tuple_of_immutables(self):
         y = copy.deepcopy(x)
         self.assertIs(x, y)
 
+    @support.skip_emscripten_stack_overflow()
+    @support.skip_wasi_stack_overflow()
     def test_deepcopy_reflexive_tuple(self):
         x = ([],)
         x[0].append(x)
@@ -415,6 +419,8 @@ def test_deepcopy_dict(self):
         self.assertIsNot(x, y)
         self.assertIsNot(x["foo"], y["foo"])
 
+    @support.skip_emscripten_stack_overflow()
+    @support.skip_wasi_stack_overflow()
     def test_deepcopy_reflexive_dict(self):
         x = {}
         x['foo'] = x
@@ -666,7 +672,7 @@ def __eq__(self, other):
     def test_reduce_5tuple(self):
         class C(dict):
             def __reduce__(self):
-                return (C, (), self.__dict__, None, self.items())
+                return (C, (), self.__dict__, None, iter(self.items()))
             def __eq__(self, other):
                 return (dict(self) == dict(other) and
                         self.__dict__ == other.__dict__)
diff --git a/Lib/test/test_coroutines.py b/Lib/test/test_coroutines.py
new file mode 100644
index 00000000000..604153354c1
--- /dev/null
+++ b/Lib/test/test_coroutines.py
@@ -0,0 +1,2547 @@
+import contextlib
+import copy
+import inspect
+import pickle
+import sys
+import types
+import traceback
+import unittest
+import warnings
+from test import support
+from test.support import import_helper
+from test.support import warnings_helper
+from test.support.script_helper import assert_python_ok
+try:
+    import _testcapi
+except ImportError:
+    _testcapi = None
+
+
+class AsyncYieldFrom:
+    def __init__(self, obj):
+        self.obj = obj
+
+    def __await__(self):
+        yield from self.obj
+
+
+class AsyncYield:
+    def __init__(self, value):
+        self.value = value
+
+    def __await__(self):
+        yield self.value
+
+
+async def asynciter(iterable):
+    """Convert an iterable to an asynchronous iterator."""
+    for x in iterable:
+        yield x
+
+
+def run_async(coro):
+    assert coro.__class__ in {types.GeneratorType, types.CoroutineType}
+
+    buffer = []
+    result = None
+    while True:
+        try:
+            buffer.append(coro.send(None))
+        except StopIteration as ex:
+            result = ex.args[0] if ex.args else None
+            break
+    return buffer, result
+
+
+def run_async__await__(coro):
+    assert coro.__class__ is types.CoroutineType
+    aw = coro.__await__()
+    buffer = []
+    result = None
+    i = 0
+    while True:
+        try:
+            if i % 2:
+                buffer.append(next(aw))
+            else:
+                buffer.append(aw.send(None))
+            i += 1
+        except StopIteration as ex:
+            result = ex.args[0] if ex.args else None
+            break
+    return buffer, result
+
+
+@contextlib.contextmanager
+def silence_coro_gc():
+    with warnings.catch_warnings():
+        warnings.simplefilter("ignore")
+        yield
+        support.gc_collect()
+
+
+class AsyncBadSyntaxTest(unittest.TestCase):
+
+    def test_badsyntax_1(self):
+        samples = [
+            """def foo():
+                await something()
+            """,
+
+            """await something()""",
+
+            """async def foo():
+                yield from []
+            """,
+
+            """async def foo():
+                await await fut
+            """,
+
+            """async def foo(a=await something()):
+                pass
+            """,
+
+            """async def foo(a:await something()):
+                pass
+            """,
+
+            """async def foo():
+                def bar():
+                 [i async for i in els]
+            """,
+
+            """async def foo():
+                def bar():
+                 [await i for i in els]
+            """,
+
+            """async def foo():
+                def bar():
+                 [i for i in els
+                    async for b in els]
+            """,
+
+            """async def foo():
+                def bar():
+                 [i for i in els
+                    for c in b
+                    async for b in els]
+            """,
+
+            """async def foo():
+                def bar():
+                 [i for i in els
+                    async for b in els
+                    for c in b]
+            """,
+
+            """async def foo():
+                def bar():
+                 [[async for i in b] for b in els]
+            """,
+
+            """async def foo():
+                def bar():
+                 [i for i in els
+                    for b in await els]
+            """,
+
+            """async def foo():
+                def bar():
+                 [i for i in els
+                    for b in els
+                        if await b]
+            """,
+
+            """async def foo():
+                def bar():
+                 [i for i in await els]
+            """,
+
+            """async def foo():
+                def bar():
+                 [i for i in els if await i]
+            """,
+
+            """def bar():
+                 [i async for i in els]
+            """,
+
+            """def bar():
+                 {i: i async for i in els}
+            """,
+
+            """def bar():
+                 {i async for i in els}
+            """,
+
+            """def bar():
+                 [await i for i in els]
+            """,
+
+            """def bar():
+                 [i for i in els
+                    async for b in els]
+            """,
+
+            """def bar():
+                 [i for i in els
+                    for c in b
+                    async for b in els]
+            """,
+
+            """def bar():
+                 [i for i in els
+                    async for b in els
+                    for c in b]
+            """,
+
+            """def bar():
+                 [i for i in els
+                    for b in await els]
+            """,
+
+            """def bar():
+                 [i for i in els
+                    for b in els
+                        if await b]
+            """,
+
+            """def bar():
+                 [i for i in await els]
+            """,
+
+            """def bar():
+                 [i for i in els if await i]
+            """,
+
+            """def bar():
+                 [[i async for i in a] for a in elts]
+            """,
+
+            """[[i async for i in a] for a in elts]
+            """,
+
+            """async def foo():
+                await
+            """,
+
+            """async def foo():
+                   def bar(): pass
+                   await = 1
+            """,
+
+            """async def foo():
+
+                   def bar(): pass
+                   await = 1
+            """,
+
+            """async def foo():
+                   def bar(): pass
+                   if 1:
+                       await = 1
+            """,
+
+            """def foo():
+                   async def bar(): pass
+                   if 1:
+                       await a
+            """,
+
+            """def foo():
+                   async def bar(): pass
+                   await a
+            """,
+
+            """def foo():
+                   def baz(): pass
+                   async def bar(): pass
+                   await a
+            """,
+
+            """def foo():
+                   def baz(): pass
+                   # 456
+                   async def bar(): pass
+                   # 123
+                   await a
+            """,
+
+            """async def foo():
+                   def baz(): pass
+                   # 456
+                   async def bar(): pass
+                   # 123
+                   await = 2
+            """,
+
+            """def foo():
+
+                   def baz(): pass
+
+                   async def bar(): pass
+
+                   await a
+            """,
+
+            """async def foo():
+
+                   def baz(): pass
+
+                   async def bar(): pass
+
+                   await = 2
+            """,
+
+            """async def foo():
+                   def async(): pass
+            """,
+
+            """async def foo():
+                   def await(): pass
+            """,
+
+            """async def foo():
+                   def bar():
+                       await
+            """,
+
+            """async def foo():
+                   return lambda async: await
+            """,
+
+            """async def foo():
+                   return lambda a: await
+            """,
+
+            """await a()""",
+
+            """async def foo(a=await b):
+                   pass
+            """,
+
+            """async def foo(a:await b):
+                   pass
+            """,
+
+            """def baz():
+                   async def foo(a=await b):
+                       pass
+            """,
+
+            """async def foo(async):
+                   pass
+            """,
+
+            """async def foo():
+                   def bar():
+                        def baz():
+                            async = 1
+            """,
+
+            """async def foo():
+                   def bar():
+                        def baz():
+                            pass
+                        async = 1
+            """,
+
+            """def foo():
+                   async def bar():
+
+                        async def baz():
+                            pass
+
+                        def baz():
+                            42
+
+                        async = 1
+            """,
+
+            """async def foo():
+                   def bar():
+                        def baz():
+                            pass\nawait foo()
+            """,
+
+            """def foo():
+                   def bar():
+                        async def baz():
+                            pass\nawait foo()
+            """,
+
+            """async def foo(await):
+                   pass
+            """,
+
+            """def foo():
+
+                   async def bar(): pass
+
+                   await a
+            """,
+
+            """def foo():
+                   async def bar():
+                        pass\nawait a
+            """,
+            """def foo():
+                   async for i in arange(2):
+                       pass
+            """,
+            """def foo():
+                   async with resource:
+                       pass
+            """,
+            """async with resource:
+                   pass
+            """,
+            """async for i in arange(2):
+                   pass
+            """,
+            ]
+
+        for code in samples:
+            with self.subTest(code=code), self.assertRaises(SyntaxError):
+                compile(code, "<test>", "exec")
+
+    def test_badsyntax_2(self):
+        samples = [
+            """def foo():
+                await = 1
+            """,
+
+            """class Bar:
+                def async(): pass
+            """,
+
+            """class Bar:
+                async = 1
+            """,
+
+            """class async:
+                pass
+            """,
+
+            """class await:
+                pass
+            """,
+
+            """import math as await""",
+
+            """def async():
+                pass""",
+
+            """def foo(*, await=1):
+                pass"""
+
+            """async = 1""",
+
+            """print(await=1)"""
+        ]
+
+        for code in samples:
+            with self.subTest(code=code), self.assertRaises(SyntaxError):
+                compile(code, "<test>", "exec")
+
+    def test_badsyntax_3(self):
+        with self.assertRaises(SyntaxError):
+            compile("async = 1", "<test>", "exec")
+
+    def test_badsyntax_4(self):
+        samples = [
+            '''def foo(await):
+                async def foo(): pass
+                async def foo():
+                    pass
+                return await + 1
+            ''',
+
+            '''def foo(await):
+                async def foo(): pass
+                async def foo(): pass
+                return await + 1
+            ''',
+
+            '''def foo(await):
+
+                async def foo(): pass
+
+                async def foo(): pass
+
+                return await + 1
+            ''',
+
+            '''def foo(await):
+                """spam"""
+                async def foo(): \
+                    pass
+                # 123
+                async def foo(): pass
+                # 456
+                return await + 1
+            ''',
+
+            '''def foo(await):
+                def foo(): pass
+                def foo(): pass
+                async def bar(): return await_
+                await_ = await
+                try:
+                    bar().send(None)
+                except StopIteration as ex:
+                    return ex.args[0] + 1
+            '''
+        ]
+
+        for code in samples:
+            with self.subTest(code=code), self.assertRaises(SyntaxError):
+                compile(code, "<test>", "exec")
+
+
+class TokenizerRegrTest(unittest.TestCase):
+
+    def test_oneline_defs(self):
+        buf = []
+        for i in range(500):
+            buf.append('def i{i}(): return {i}'.format(i=i))
+        buf = '\n'.join(buf)
+
+        # Test that 500 consequent, one-line defs is OK
+        ns = {}
+        exec(buf, ns, ns)
+        self.assertEqual(ns['i499'](), 499)
+
+        # Test that 500 consequent, one-line defs *and*
+        # one 'async def' following them is OK
+        buf += '\nasync def foo():\n    return'
+        ns = {}
+        exec(buf, ns, ns)
+        self.assertEqual(ns['i499'](), 499)
+        self.assertTrue(inspect.iscoroutinefunction(ns['foo']))
+
+
+class CoroutineTest(unittest.TestCase):
+
+    def test_gen_1(self):
+        def gen(): yield
+        self.assertNotHasAttr(gen, '__await__')
+
+    def test_func_1(self):
+        async def foo():
+            return 10
+
+        f = foo()
+        self.assertIsInstance(f, types.CoroutineType)
+        self.assertTrue(bool(foo.__code__.co_flags & inspect.CO_COROUTINE))
+        self.assertFalse(bool(foo.__code__.co_flags & inspect.CO_GENERATOR))
+        self.assertTrue(bool(f.cr_code.co_flags & inspect.CO_COROUTINE))
+        self.assertFalse(bool(f.cr_code.co_flags & inspect.CO_GENERATOR))
+        self.assertEqual(run_async(f), ([], 10))
+
+        self.assertEqual(run_async__await__(foo()), ([], 10))
+
+        def bar(): pass
+        self.assertFalse(bool(bar.__code__.co_flags & inspect.CO_COROUTINE))
+
+    def test_func_2(self):
+        async def foo():
+            raise StopIteration
+
+        with self.assertRaisesRegex(
+                RuntimeError, "coroutine raised StopIteration"):
+
+            run_async(foo())
+
+    def test_func_3(self):
+        async def foo():
+            raise StopIteration
+
+        coro = foo()
+        self.assertRegex(repr(coro), '^<coroutine object.* at 0x.*>$')
+        coro.close()
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; RuntimeError: coroutine raised StopIteration
+    def test_func_4(self):
+        async def foo():
+            raise StopIteration
+        coro = foo()
+
+        check = lambda: self.assertRaisesRegex(
+            TypeError, "'coroutine' object is not iterable")
+
+        with check():
+            list(coro)
+
+        with check():
+            tuple(coro)
+
+        with check():
+            sum(coro)
+
+        with check():
+            iter(coro)
+
+        with check():
+            for i in coro:
+                pass
+
+        with check():
+            [i for i in coro]
+
+        coro.close()
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AssertionError: TypeError not raised
+    def test_func_5(self):
+        @types.coroutine
+        def bar():
+            yield 1
+
+        async def foo():
+            await bar()
+
+        check = lambda: self.assertRaisesRegex(
+            TypeError, "'coroutine' object is not iterable")
+
+        coro = foo()
+        with check():
+            for el in coro:
+                pass
+        coro.close()
+
+        # the following should pass without an error
+        for el in bar():
+            self.assertEqual(el, 1)
+        self.assertEqual([el for el in bar()], [1])
+        self.assertEqual(tuple(bar()), (1,))
+        self.assertEqual(next(iter(bar())), 1)
+
+    def test_func_6(self):
+        @types.coroutine
+        def bar():
+            yield 1
+            yield 2
+
+        async def foo():
+            await bar()
+
+        f = foo()
+        self.assertEqual(f.send(None), 1)
+        self.assertEqual(f.send(None), 2)
+        with self.assertRaises(StopIteration):
+            f.send(None)
+
+    def test_func_7(self):
+        async def bar():
+            return 10
+        coro = bar()
+
+        def foo():
+            yield from coro
+
+        with self.assertRaisesRegex(
+                TypeError,
+                "cannot 'yield from' a coroutine object in "
+                "a non-coroutine generator"):
+            list(foo())
+
+        coro.close()
+
+    def test_func_8(self):
+        @types.coroutine
+        def bar():
+            return (yield from coro)
+
+        async def foo():
+            return 'spam'
+
+        coro = foo()
+        self.assertEqual(run_async(bar()), ([], 'spam'))
+        coro.close()
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AssertionError: RuntimeWarning not triggered
+    def test_func_9(self):
+        async def foo():
+            pass
+
+        with self.assertWarnsRegex(
+                RuntimeWarning,
+                r"coroutine '.*test_func_9.*foo' was never awaited"):
+
+            foo()
+            support.gc_collect()
+
+        with self.assertWarnsRegex(
+                RuntimeWarning,
+                r"coroutine '.*test_func_9.*foo' was never awaited"):
+
+            with self.assertRaises(TypeError):
+                # See bpo-32703.
+                for _ in foo():
+                    pass
+
+            support.gc_collect()
+
+    def test_func_10(self):
+        N = 0
+
+        @types.coroutine
+        def gen():
+            nonlocal N
+            try:
+                a = yield
+                yield (a ** 2)
+            except ZeroDivisionError:
+                N += 100
+                raise
+            finally:
+                N += 1
+
+        async def foo():
+            await gen()
+
+        coro = foo()
+        aw = coro.__await__()
+        self.assertIs(aw, iter(aw))
+        next(aw)
+        self.assertEqual(aw.send(10), 100)
+
+        self.assertEqual(N, 0)
+        aw.close()
+        self.assertEqual(N, 1)
+
+        coro = foo()
+        aw = coro.__await__()
+        next(aw)
+        with self.assertRaises(ZeroDivisionError):
+            aw.throw(ZeroDivisionError())
+        self.assertEqual(N, 102)
+
+        coro = foo()
+        aw = coro.__await__()
+        next(aw)
+        with self.assertRaises(ZeroDivisionError):
+            with self.assertWarns(DeprecationWarning):
+                aw.throw(ZeroDivisionError, ZeroDivisionError(), None)
+
+    def test_func_11(self):
+        async def func(): pass
+        coro = func()
+        # Test that PyCoro_Type and _PyCoroWrapper_Type types were properly
+        # initialized
+        self.assertIn('__await__', dir(coro))
+        self.assertIn('__iter__', dir(coro.__await__()))
+        self.assertIn('coroutine_wrapper', repr(coro.__await__()))
+        coro.close() # avoid RuntimeWarning
+
+    def test_func_12(self):
+        async def g():
+            me.send(None)
+            await foo
+        me = g()
+        with self.assertRaisesRegex(ValueError,
+                                    "coroutine already executing"):
+            me.send(None)
+
+    def test_func_13(self):
+        async def g():
+            pass
+
+        coro = g()
+        with self.assertRaisesRegex(
+                TypeError,
+                "can't send non-None value to a just-started coroutine"):
+            coro.send('spam')
+
+        coro.close()
+
+    def test_func_14(self):
+        @types.coroutine
+        def gen():
+            yield
+        async def coro():
+            try:
+                await gen()
+            except GeneratorExit:
+                await gen()
+        c = coro()
+        c.send(None)
+        with self.assertRaisesRegex(RuntimeError,
+                                    "coroutine ignored GeneratorExit"):
+            c.close()
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; StopIteration
+    def test_func_15(self):
+        # See http://bugs.python.org/issue25887 for details
+
+        async def spammer():
+            return 'spam'
+        async def reader(coro):
+            return await coro
+
+        spammer_coro = spammer()
+
+        with self.assertRaisesRegex(StopIteration, 'spam'):
+            reader(spammer_coro).send(None)
+
+        with self.assertRaisesRegex(RuntimeError,
+                                    'cannot reuse already awaited coroutine'):
+            reader(spammer_coro).send(None)
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; StopIteration
+    def test_func_16(self):
+        # See http://bugs.python.org/issue25887 for details
+
+        @types.coroutine
+        def nop():
+            yield
+        async def send():
+            await nop()
+            return 'spam'
+        async def read(coro):
+            await nop()
+            return await coro
+
+        spammer = send()
+
+        reader = read(spammer)
+        reader.send(None)
+        reader.send(None)
+        with self.assertRaisesRegex(Exception, 'ham'):
+            reader.throw(Exception('ham'))
+
+        reader = read(spammer)
+        reader.send(None)
+        with self.assertRaisesRegex(RuntimeError,
+                                    'cannot reuse already awaited coroutine'):
+            reader.send(None)
+
+        with self.assertRaisesRegex(RuntimeError,
+                                    'cannot reuse already awaited coroutine'):
+            reader.throw(Exception('wat'))
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; StopIteration
+    def test_func_17(self):
+        # See http://bugs.python.org/issue25887 for details
+
+        async def coroutine():
+            return 'spam'
+
+        coro = coroutine()
+        with self.assertRaisesRegex(StopIteration, 'spam'):
+            coro.send(None)
+
+        with self.assertRaisesRegex(RuntimeError,
+                                    'cannot reuse already awaited coroutine'):
+            coro.send(None)
+
+        with self.assertRaisesRegex(RuntimeError,
+                                    'cannot reuse already awaited coroutine'):
+            coro.throw(Exception('wat'))
+
+        # Closing a coroutine shouldn't raise any exception even if it's
+        # already closed/exhausted (similar to generators)
+        coro.close()
+        coro.close()
+
+    def test_func_18(self):
+        # See http://bugs.python.org/issue25887 for details
+
+        async def coroutine():
+            return 'spam'
+
+        coro = coroutine()
+        await_iter = coro.__await__()
+        it = iter(await_iter)
+
+        with self.assertRaisesRegex(StopIteration, 'spam'):
+            it.send(None)
+
+        with self.assertRaisesRegex(RuntimeError,
+                                    'cannot reuse already awaited coroutine'):
+            it.send(None)
+
+        with self.assertRaisesRegex(RuntimeError,
+                                    'cannot reuse already awaited coroutine'):
+            # Although the iterator protocol requires iterators to
+            # raise another StopIteration here, we don't want to do
+            # that.  In this particular case, the iterator will raise
+            # a RuntimeError, so that 'yield from' and 'await'
+            # expressions will trigger the error, instead of silently
+            # ignoring the call.
+            next(it)
+
+        with self.assertRaisesRegex(RuntimeError,
+                                    'cannot reuse already awaited coroutine'):
+            it.throw(Exception('wat'))
+
+        with self.assertRaisesRegex(RuntimeError,
+                                    'cannot reuse already awaited coroutine'):
+            it.throw(Exception('wat'))
+
+        # Closing a coroutine shouldn't raise any exception even if it's
+        # already closed/exhausted (similar to generators)
+        it.close()
+        it.close()
+
+    def test_func_19(self):
+        CHK = 0
+
+        @types.coroutine
+        def foo():
+            nonlocal CHK
+            yield
+            try:
+                yield
+            except GeneratorExit:
+                CHK += 1
+
+        async def coroutine():
+            await foo()
+
+        coro = coroutine()
+
+        coro.send(None)
+        coro.send(None)
+
+        self.assertEqual(CHK, 0)
+        coro.close()
+        self.assertEqual(CHK, 1)
+
+        for _ in range(3):
+            # Closing a coroutine shouldn't raise any exception even if it's
+            # already closed/exhausted (similar to generators)
+            coro.close()
+            self.assertEqual(CHK, 1)
+
+    def test_coro_wrapper_send_tuple(self):
+        async def foo():
+            return (10,)
+
+        result = run_async__await__(foo())
+        self.assertEqual(result, ([], (10,)))
+
+    def test_coro_wrapper_send_stop_iterator(self):
+        async def foo():
+            return StopIteration(10)
+
+        result = run_async__await__(foo())
+        self.assertIsInstance(result[1], StopIteration)
+        self.assertEqual(result[1].value, 10)
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AttributeError: 'coroutine' object has no attribute 'cr_suspended'
+    def test_cr_await(self):
+        @types.coroutine
+        def a():
+            self.assertEqual(inspect.getcoroutinestate(coro_b), inspect.CORO_RUNNING)
+            self.assertIsNone(coro_b.cr_await)
+            yield
+            self.assertEqual(inspect.getcoroutinestate(coro_b), inspect.CORO_RUNNING)
+            self.assertIsNone(coro_b.cr_await)
+
+        async def c():
+            await a()
+
+        async def b():
+            self.assertIsNone(coro_b.cr_await)
+            await c()
+            self.assertIsNone(coro_b.cr_await)
+
+        coro_b = b()
+        self.assertEqual(inspect.getcoroutinestate(coro_b), inspect.CORO_CREATED)
+        self.assertIsNone(coro_b.cr_await)
+
+        coro_b.send(None)
+        self.assertEqual(inspect.getcoroutinestate(coro_b), inspect.CORO_SUSPENDED)
+        self.assertEqual(coro_b.cr_await.cr_await.gi_code.co_name, 'a')
+
+        with self.assertRaises(StopIteration):
+            coro_b.send(None)  # complete coroutine
+        self.assertEqual(inspect.getcoroutinestate(coro_b), inspect.CORO_CLOSED)
+        self.assertIsNone(coro_b.cr_await)
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; TypeError: 'NoneType' object is not iterable
+    def test_corotype_1(self):
+        ct = types.CoroutineType
+        if not support.MISSING_C_DOCSTRINGS:
+            self.assertIn('into coroutine', ct.send.__doc__)
+            self.assertIn('inside coroutine', ct.close.__doc__)
+            self.assertIn('in coroutine', ct.throw.__doc__)
+            self.assertIn('of the coroutine', ct.__dict__['__name__'].__doc__)
+            self.assertIn('of the coroutine', ct.__dict__['__qualname__'].__doc__)
+        self.assertEqual(ct.__name__, 'coroutine')
+
+        async def f(): pass
+        c = f()
+        self.assertIn('coroutine object', repr(c))
+        c.close()
+
+    def test_await_1(self):
+
+        async def foo():
+            await 1
+        with self.assertRaisesRegex(TypeError, "'int' object can.t be awaited"):
+            run_async(foo())
+
+    def test_await_2(self):
+        async def foo():
+            await []
+        with self.assertRaisesRegex(TypeError, "'list' object can.t be awaited"):
+            run_async(foo())
+
+    def test_await_3(self):
+        async def foo():
+            await AsyncYieldFrom([1, 2, 3])
+
+        self.assertEqual(run_async(foo()), ([1, 2, 3], None))
+        self.assertEqual(run_async__await__(foo()), ([1, 2, 3], None))
+
+    def test_await_4(self):
+        async def bar():
+            return 42
+
+        async def foo():
+            return await bar()
+
+        self.assertEqual(run_async(foo()), ([], 42))
+
+    def test_await_5(self):
+        class Awaitable:
+            def __await__(self):
+                return
+
+        async def foo():
+            return (await Awaitable())
+
+        with self.assertRaisesRegex(
+            TypeError, "__await__.*returned non-iterator of type"):
+
+            run_async(foo())
+
+    def test_await_6(self):
+        class Awaitable:
+            def __await__(self):
+                return iter([52])
+
+        async def foo():
+            return (await Awaitable())
+
+        self.assertEqual(run_async(foo()), ([52], None))
+
+    def test_await_7(self):
+        class Awaitable:
+            def __await__(self):
+                yield 42
+                return 100
+
+        async def foo():
+            return (await Awaitable())
+
+        self.assertEqual(run_async(foo()), ([42], 100))
+
+    def test_await_8(self):
+        class Awaitable:
+            pass
+
+        async def foo(): return await Awaitable()
+
+        with self.assertRaisesRegex(
+            TypeError, "'Awaitable' object can't be awaited"):
+
+            run_async(foo())
+
+    def test_await_9(self):
+        def wrap():
+            return bar
+
+        async def bar():
+            return 42
+
+        async def foo():
+            db = {'b':  lambda: wrap}
+
+            class DB:
+                b = wrap
+
+            return (await bar() + await wrap()() + await db['b']()()() +
+                    await bar() * 1000 + await DB.b()())
+
+        async def foo2():
+            return -await bar()
+
+        self.assertEqual(run_async(foo()), ([], 42168))
+        self.assertEqual(run_async(foo2()), ([], -42))
+
+    def test_await_10(self):
+        async def baz():
+            return 42
+
+        async def bar():
+            return baz()
+
+        async def foo():
+            return await (await bar())
+
+        self.assertEqual(run_async(foo()), ([], 42))
+
+    def test_await_11(self):
+        def ident(val):
+            return val
+
+        async def bar():
+            return 'spam'
+
+        async def foo():
+            return ident(val=await bar())
+
+        async def foo2():
+            return await bar(), 'ham'
+
+        self.assertEqual(run_async(foo2()), ([], ('spam', 'ham')))
+
+    def test_await_12(self):
+        async def coro():
+            return 'spam'
+        c = coro()
+
+        class Awaitable:
+            def __await__(self):
+                return c
+
+        async def foo():
+            return await Awaitable()
+
+        with self.assertRaisesRegex(
+                TypeError, r"__await__\(\) returned a coroutine"):
+            run_async(foo())
+
+        c.close()
+
+    def test_await_13(self):
+        class Awaitable:
+            def __await__(self):
+                return self
+
+        async def foo():
+            return await Awaitable()
+
+        with self.assertRaisesRegex(
+            TypeError, "__await__.*returned non-iterator of type"):
+
+            run_async(foo())
+
+    def test_await_14(self):
+        class Wrapper:
+            # Forces the interpreter to use CoroutineType.__await__
+            def __init__(self, coro):
+                assert coro.__class__ is types.CoroutineType
+                self.coro = coro
+            def __await__(self):
+                return self.coro.__await__()
+
+        class FutureLike:
+            def __await__(self):
+                return (yield)
+
+        class Marker(Exception):
+            pass
+
+        async def coro1():
+            try:
+                return await FutureLike()
+            except ZeroDivisionError:
+                raise Marker
+        async def coro2():
+            return await Wrapper(coro1())
+
+        c = coro2()
+        c.send(None)
+        with self.assertRaisesRegex(StopIteration, 'spam'):
+            c.send('spam')
+
+        c = coro2()
+        c.send(None)
+        with self.assertRaises(Marker):
+            c.throw(ZeroDivisionError)
+
+    def test_await_15(self):
+        @types.coroutine
+        def nop():
+            yield
+
+        async def coroutine():
+            await nop()
+
+        async def waiter(coro):
+            await coro
+
+        coro = coroutine()
+        coro.send(None)
+
+        with self.assertRaisesRegex(RuntimeError,
+                                    "coroutine is being awaited already"):
+            waiter(coro).send(None)
+
+    def test_await_16(self):
+        # See https://bugs.python.org/issue29600 for details.
+
+        async def f():
+            return ValueError()
+
+        async def g():
+            try:
+                raise KeyError
+            except KeyError:
+                return await f()
+
+        _, result = run_async(g())
+        self.assertIsNone(result.__context__)
+
+    def test_await_17(self):
+        # See https://github.com/python/cpython/issues/131666 for details.
+        class A:
+            async def __anext__(self):
+                raise StopAsyncIteration
+            def __aiter__(self):
+                return self
+
+        with contextlib.closing(anext(A(), "a").__await__()) as anext_awaitable:
+            self.assertRaises(TypeError, anext_awaitable.close, 1)
+
+    def test_with_1(self):
+        class Manager:
+            def __init__(self, name):
+                self.name = name
+
+            async def __aenter__(self):
+                await AsyncYieldFrom(['enter-1-' + self.name,
+                                      'enter-2-' + self.name])
+                return self
+
+            async def __aexit__(self, *args):
+                await AsyncYieldFrom(['exit-1-' + self.name,
+                                      'exit-2-' + self.name])
+
+                if self.name == 'B':
+                    return True
+
+
+        async def foo():
+            async with Manager("A") as a, Manager("B") as b:
+                await AsyncYieldFrom([('managers', a.name, b.name)])
+                1/0
+
+        f = foo()
+        result, _ = run_async(f)
+
+        self.assertEqual(
+            result, ['enter-1-A', 'enter-2-A', 'enter-1-B', 'enter-2-B',
+                     ('managers', 'A', 'B'),
+                     'exit-1-B', 'exit-2-B', 'exit-1-A', 'exit-2-A']
+        )
+
+        async def foo():
+            async with Manager("A") as a, Manager("C") as c:
+                await AsyncYieldFrom([('managers', a.name, c.name)])
+                1/0
+
+        with self.assertRaises(ZeroDivisionError):
+            run_async(foo())
+
+    def test_with_2(self):
+        class CM:
+            def __aenter__(self):
+                pass
+
+        body_executed = None
+        async def foo():
+            nonlocal body_executed
+            body_executed = False
+            async with CM():
+                body_executed = True
+
+        with self.assertRaisesRegex(TypeError, 'asynchronous context manager.*__aexit__'):
+            run_async(foo())
+        self.assertIs(body_executed, False)
+
+    def test_with_3(self):
+        class CM:
+            def __aexit__(self):
+                pass
+
+        body_executed = None
+        async def foo():
+            nonlocal body_executed
+            body_executed = False
+            async with CM():
+                body_executed = True
+
+        with self.assertRaisesRegex(TypeError, 'asynchronous context manager'):
+            run_async(foo())
+        self.assertIs(body_executed, False)
+
+    def test_with_4(self):
+        class CM:
+            pass
+
+        body_executed = None
+        async def foo():
+            nonlocal body_executed
+            body_executed = False
+            async with CM():
+                body_executed = True
+
+        with self.assertRaisesRegex(TypeError, 'asynchronous context manager'):
+            run_async(foo())
+        self.assertIs(body_executed, False)
+
+    def test_with_5(self):
+        # While this test doesn't make a lot of sense,
+        # it's a regression test for an early bug with opcodes
+        # generation
+
+        class CM:
+            async def __aenter__(self):
+                return self
+
+            async def __aexit__(self, *exc):
+                pass
+
+        async def func():
+            async with CM():
+                self.assertEqual((1, ), 1)
+
+        with self.assertRaises(AssertionError):
+            run_async(func())
+
+    def test_with_6(self):
+        class CM:
+            def __aenter__(self):
+                return 123
+
+            def __aexit__(self, *e):
+                return 456
+
+        async def foo():
+            async with CM():
+                pass
+
+        with self.assertRaisesRegex(
+                TypeError,
+                "'async with' received an object from __aenter__ "
+                "that does not implement __await__: int"):
+            # it's important that __aexit__ wasn't called
+            run_async(foo())
+
+    def test_with_7(self):
+        class CM:
+            async def __aenter__(self):
+                return self
+
+            def __aexit__(self, *e):
+                return 444
+
+        # Exit with exception
+        async def foo():
+            async with CM():
+                1/0
+
+        try:
+            run_async(foo())
+        except TypeError as exc:
+            self.assertRegex(
+                exc.args[0],
+                "'async with' received an object from __aexit__ "
+                "that does not implement __await__: int")
+            self.assertTrue(exc.__context__ is not None)
+            self.assertTrue(isinstance(exc.__context__, ZeroDivisionError))
+        else:
+            self.fail('invalid asynchronous context manager did not fail')
+
+
+    def test_with_8(self):
+        CNT = 0
+
+        class CM:
+            async def __aenter__(self):
+                return self
+
+            def __aexit__(self, *e):
+                return 456
+
+        # Normal exit
+        async def foo():
+            nonlocal CNT
+            async with CM():
+                CNT += 1
+        with self.assertRaisesRegex(
+                TypeError,
+                "'async with' received an object from __aexit__ "
+                "that does not implement __await__: int"):
+            run_async(foo())
+        self.assertEqual(CNT, 1)
+
+        # Exit with 'break'
+        async def foo():
+            nonlocal CNT
+            for i in range(2):
+                async with CM():
+                    CNT += 1
+                    break
+        with self.assertRaisesRegex(
+                TypeError,
+                "'async with' received an object from __aexit__ "
+                "that does not implement __await__: int"):
+            run_async(foo())
+        self.assertEqual(CNT, 2)
+
+        # Exit with 'continue'
+        async def foo():
+            nonlocal CNT
+            for i in range(2):
+                async with CM():
+                    CNT += 1
+                    continue
+        with self.assertRaisesRegex(
+                TypeError,
+                "'async with' received an object from __aexit__ "
+                "that does not implement __await__: int"):
+            run_async(foo())
+        self.assertEqual(CNT, 3)
+
+        # Exit with 'return'
+        async def foo():
+            nonlocal CNT
+            async with CM():
+                CNT += 1
+                return
+        with self.assertRaisesRegex(
+                TypeError,
+                "'async with' received an object from __aexit__ "
+                "that does not implement __await__: int"):
+            run_async(foo())
+        self.assertEqual(CNT, 4)
+
+
+    def test_with_9(self):
+        CNT = 0
+
+        class CM:
+            async def __aenter__(self):
+                return self
+
+            async def __aexit__(self, *e):
+                1/0
+
+        async def foo():
+            nonlocal CNT
+            async with CM():
+                CNT += 1
+
+        with self.assertRaises(ZeroDivisionError):
+            run_async(foo())
+
+        self.assertEqual(CNT, 1)
+
+    def test_with_10(self):
+        CNT = 0
+
+        class CM:
+            async def __aenter__(self):
+                return self
+
+            async def __aexit__(self, *e):
+                1/0
+
+        async def foo():
+            nonlocal CNT
+            async with CM():
+                async with CM():
+                    raise RuntimeError
+
+        try:
+            run_async(foo())
+        except ZeroDivisionError as exc:
+            self.assertTrue(exc.__context__ is not None)
+            self.assertTrue(isinstance(exc.__context__, ZeroDivisionError))
+            self.assertTrue(isinstance(exc.__context__.__context__,
+                                       RuntimeError))
+        else:
+            self.fail('exception from __aexit__ did not propagate')
+
+    def test_with_11(self):
+        CNT = 0
+
+        class CM:
+            async def __aenter__(self):
+                raise NotImplementedError
+
+            async def __aexit__(self, *e):
+                1/0
+
+        async def foo():
+            nonlocal CNT
+            async with CM():
+                raise RuntimeError
+
+        try:
+            run_async(foo())
+        except NotImplementedError as exc:
+            self.assertTrue(exc.__context__ is None)
+        else:
+            self.fail('exception from __aenter__ did not propagate')
+
+    def test_with_12(self):
+        CNT = 0
+
+        class CM:
+            async def __aenter__(self):
+                return self
+
+            async def __aexit__(self, *e):
+                return True
+
+        async def foo():
+            nonlocal CNT
+            async with CM() as cm:
+                self.assertIs(cm.__class__, CM)
+                raise RuntimeError
+
+        run_async(foo())
+
+    def test_with_13(self):
+        CNT = 0
+
+        class CM:
+            async def __aenter__(self):
+                1/0
+
+            async def __aexit__(self, *e):
+                return True
+
+        async def foo():
+            nonlocal CNT
+            CNT += 1
+            async with CM():
+                CNT += 1000
+            CNT += 10000
+
+        with self.assertRaises(ZeroDivisionError):
+            run_async(foo())
+        self.assertEqual(CNT, 1)
+
+    def test_for_1(self):
+        aiter_calls = 0
+
+        class AsyncIter:
+            def __init__(self):
+                self.i = 0
+
+            def __aiter__(self):
+                nonlocal aiter_calls
+                aiter_calls += 1
+                return self
+
+            async def __anext__(self):
+                self.i += 1
+
+                if not (self.i % 10):
+                    await AsyncYield(self.i * 10)
+
+                if self.i > 100:
+                    raise StopAsyncIteration
+
+                return self.i, self.i
+
+
+        buffer = []
+        async def test1():
+            async for i1, i2 in AsyncIter():
+                buffer.append(i1 + i2)
+
+        yielded, _ = run_async(test1())
+        # Make sure that __aiter__ was called only once
+        self.assertEqual(aiter_calls, 1)
+        self.assertEqual(yielded, [i * 100 for i in range(1, 11)])
+        self.assertEqual(buffer, [i*2 for i in range(1, 101)])
+
+
+        buffer = []
+        async def test2():
+            nonlocal buffer
+            async for i in AsyncIter():
+                buffer.append(i[0])
+                if i[0] == 20:
+                    break
+            else:
+                buffer.append('what?')
+            buffer.append('end')
+
+        yielded, _ = run_async(test2())
+        # Make sure that __aiter__ was called only once
+        self.assertEqual(aiter_calls, 2)
+        self.assertEqual(yielded, [100, 200])
+        self.assertEqual(buffer, [i for i in range(1, 21)] + ['end'])
+
+
+        buffer = []
+        async def test3():
+            nonlocal buffer
+            async for i in AsyncIter():
+                if i[0] > 20:
+                    continue
+                buffer.append(i[0])
+            else:
+                buffer.append('what?')
+            buffer.append('end')
+
+        yielded, _ = run_async(test3())
+        # Make sure that __aiter__ was called only once
+        self.assertEqual(aiter_calls, 3)
+        self.assertEqual(yielded, [i * 100 for i in range(1, 11)])
+        self.assertEqual(buffer, [i for i in range(1, 21)] +
+                                 ['what?', 'end'])
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AttributeError: __aiter__
+    def test_for_2(self):
+        tup = (1, 2, 3)
+        refs_before = sys.getrefcount(tup)
+
+        async def foo():
+            async for i in tup:
+                print('never going to happen')
+
+        with self.assertRaisesRegex(
+                TypeError, "async for' requires an object.*__aiter__.*tuple"):
+
+            run_async(foo())
+
+        self.assertEqual(sys.getrefcount(tup), refs_before)
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AssertionError: "that does not implement __anext__" does not match "'async for' requires an iterator with __anext__ method, got I"
+    def test_for_3(self):
+        class I:
+            def __aiter__(self):
+                return self
+
+        aiter = I()
+        refs_before = sys.getrefcount(aiter)
+
+        async def foo():
+            async for i in aiter:
+                print('never going to happen')
+
+        with self.assertRaisesRegex(
+                TypeError,
+                r"that does not implement __anext__"):
+
+            run_async(foo())
+
+        self.assertEqual(sys.getrefcount(aiter), refs_before)
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AssertionError: "async for' received an invalid object.*__anext__.*tuple" does not match "'tuple' object is not an iterator"
+    def test_for_4(self):
+        class I:
+            def __aiter__(self):
+                return self
+
+            def __anext__(self):
+                return ()
+
+        aiter = I()
+        refs_before = sys.getrefcount(aiter)
+
+        async def foo():
+            async for i in aiter:
+                print('never going to happen')
+
+        with self.assertRaisesRegex(
+                TypeError,
+                "async for' received an invalid object.*__anext__.*tuple"):
+
+            run_async(foo())
+
+        self.assertEqual(sys.getrefcount(aiter), refs_before)
+
+    def test_for_6(self):
+        I = 0
+
+        class Manager:
+            async def __aenter__(self):
+                nonlocal I
+                I += 10000
+
+            async def __aexit__(self, *args):
+                nonlocal I
+                I += 100000
+
+        class Iterable:
+            def __init__(self):
+                self.i = 0
+
+            def __aiter__(self):
+                return self
+
+            async def __anext__(self):
+                if self.i > 10:
+                    raise StopAsyncIteration
+                self.i += 1
+                return self.i
+
+        ##############
+
+        manager = Manager()
+        iterable = Iterable()
+        mrefs_before = sys.getrefcount(manager)
+        irefs_before = sys.getrefcount(iterable)
+
+        async def main():
+            nonlocal I
+
+            async with manager:
+                async for i in iterable:
+                    I += 1
+            I += 1000
+
+        with warnings.catch_warnings():
+            warnings.simplefilter("error")
+            # Test that __aiter__ that returns an asynchronous iterator
+            # directly does not throw any warnings.
+            run_async(main())
+        self.assertEqual(I, 111011)
+
+        self.assertEqual(sys.getrefcount(manager), mrefs_before)
+        self.assertEqual(sys.getrefcount(iterable), irefs_before)
+
+        ##############
+
+        async def main():
+            nonlocal I
+
+            async with Manager():
+                async for i in Iterable():
+                    I += 1
+            I += 1000
+
+            async with Manager():
+                async for i in Iterable():
+                    I += 1
+            I += 1000
+
+        run_async(main())
+        self.assertEqual(I, 333033)
+
+        ##############
+
+        async def main():
+            nonlocal I
+
+            async with Manager():
+                I += 100
+                async for i in Iterable():
+                    I += 1
+                else:
+                    I += 10000000
+            I += 1000
+
+            async with Manager():
+                I += 100
+                async for i in Iterable():
+                    I += 1
+                else:
+                    I += 10000000
+            I += 1000
+
+        run_async(main())
+        self.assertEqual(I, 20555255)
+
+    def test_for_7(self):
+        CNT = 0
+        class AI:
+            def __aiter__(self):
+                1/0
+        async def foo():
+            nonlocal CNT
+            async for i in AI():
+                CNT += 1
+            CNT += 10
+        with self.assertRaises(ZeroDivisionError):
+            run_async(foo())
+        self.assertEqual(CNT, 0)
+
+    def test_for_8(self):
+        CNT = 0
+        class AI:
+            def __aiter__(self):
+                1/0
+        async def foo():
+            nonlocal CNT
+            async for i in AI():
+                CNT += 1
+            CNT += 10
+        with self.assertRaises(ZeroDivisionError):
+            with warnings.catch_warnings():
+                warnings.simplefilter("error")
+                # Test that if __aiter__ raises an exception it propagates
+                # without any kind of warning.
+                run_async(foo())
+        self.assertEqual(CNT, 0)
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AssertionError: "an invalid object from __anext__" does not match "'F' object is not an iterator"
+    def test_for_11(self):
+        class F:
+            def __aiter__(self):
+                return self
+            def __anext__(self):
+                return self
+            def __await__(self):
+                1 / 0
+
+        async def main():
+            async for _ in F():
+                pass
+
+        with self.assertRaisesRegex(TypeError,
+                                    'an invalid object from __anext__') as c:
+            main().send(None)
+
+        err = c.exception
+        self.assertIsInstance(err.__cause__, ZeroDivisionError)
+
+    def test_for_tuple(self):
+        class Done(Exception): pass
+
+        class AIter(tuple):
+            i = 0
+            def __aiter__(self):
+                return self
+            async def __anext__(self):
+                if self.i >= len(self):
+                    raise StopAsyncIteration
+                self.i += 1
+                return self[self.i - 1]
+
+        result = []
+        async def foo():
+            async for i in AIter([42]):
+                result.append(i)
+            raise Done
+
+        with self.assertRaises(Done):
+            foo().send(None)
+        self.assertEqual(result, [42])
+
+    def test_for_stop_iteration(self):
+        class Done(Exception): pass
+
+        class AIter(StopIteration):
+            i = 0
+            def __aiter__(self):
+                return self
+            async def __anext__(self):
+                if self.i:
+                    raise StopAsyncIteration
+                self.i += 1
+                return self.value
+
+        result = []
+        async def foo():
+            async for i in AIter(42):
+                result.append(i)
+            raise Done
+
+        with self.assertRaises(Done):
+            foo().send(None)
+        self.assertEqual(result, [42])
+
+    def test_comp_1(self):
+        async def f(i):
+            return i
+
+        async def run_list():
+            return [await c for c in [f(1), f(41)]]
+
+        async def run_set():
+            return {await c for c in [f(1), f(41)]}
+
+        async def run_dict1():
+            return {await c: 'a' for c in [f(1), f(41)]}
+
+        async def run_dict2():
+            return {i: await c for i, c in enumerate([f(1), f(41)])}
+
+        self.assertEqual(run_async(run_list()), ([], [1, 41]))
+        self.assertEqual(run_async(run_set()), ([], {1, 41}))
+        self.assertEqual(run_async(run_dict1()), ([], {1: 'a', 41: 'a'}))
+        self.assertEqual(run_async(run_dict2()), ([], {0: 1, 1: 41}))
+
+    def test_comp_2(self):
+        async def f(i):
+            return i
+
+        async def run_list():
+            return [s for c in [f(''), f('abc'), f(''), f(['de', 'fg'])]
+                    for s in await c]
+
+        self.assertEqual(
+            run_async(run_list()),
+            ([], ['a', 'b', 'c', 'de', 'fg']))
+
+        async def run_set():
+            return {d
+                    for c in [f([f([10, 30]),
+                                 f([20])])]
+                    for s in await c
+                    for d in await s}
+
+        self.assertEqual(
+            run_async(run_set()),
+            ([], {10, 20, 30}))
+
+        async def run_set2():
+            return {await s
+                    for c in [f([f(10), f(20)])]
+                    for s in await c}
+
+        self.assertEqual(
+            run_async(run_set2()),
+            ([], {10, 20}))
+
+    def test_comp_3(self):
+        async def f(it):
+            for i in it:
+                yield i
+
+        async def run_list():
+            return [i + 1 async for i in f([10, 20])]
+        self.assertEqual(
+            run_async(run_list()),
+            ([], [11, 21]))
+
+        async def run_set():
+            return {i + 1 async for i in f([10, 20])}
+        self.assertEqual(
+            run_async(run_set()),
+            ([], {11, 21}))
+
+        async def run_dict():
+            return {i + 1: i + 2 async for i in f([10, 20])}
+        self.assertEqual(
+            run_async(run_dict()),
+            ([], {11: 12, 21: 22}))
+
+        async def run_gen():
+            gen = (i + 1 async for i in f([10, 20]))
+            return [g + 100 async for g in gen]
+        self.assertEqual(
+            run_async(run_gen()),
+            ([], [111, 121]))
+
+    def test_comp_4(self):
+        async def f(it):
+            for i in it:
+                yield i
+
+        async def run_list():
+            return [i + 1 async for i in f([10, 20]) if i > 10]
+        self.assertEqual(
+            run_async(run_list()),
+            ([], [21]))
+
+        async def run_set():
+            return {i + 1 async for i in f([10, 20]) if i > 10}
+        self.assertEqual(
+            run_async(run_set()),
+            ([], {21}))
+
+        async def run_dict():
+            return {i + 1: i + 2 async for i in f([10, 20]) if i > 10}
+        self.assertEqual(
+            run_async(run_dict()),
+            ([], {21: 22}))
+
+        async def run_gen():
+            gen = (i + 1 async for i in f([10, 20]) if i > 10)
+            return [g + 100 async for g in gen]
+        self.assertEqual(
+            run_async(run_gen()),
+            ([], [121]))
+
+    def test_comp_4_2(self):
+        async def f(it):
+            for i in it:
+                yield i
+
+        async def run_list():
+            return [i + 10 async for i in f(range(5)) if 0 < i < 4]
+        self.assertEqual(
+            run_async(run_list()),
+            ([], [11, 12, 13]))
+
+        async def run_set():
+            return {i + 10 async for i in f(range(5)) if 0 < i < 4}
+        self.assertEqual(
+            run_async(run_set()),
+            ([], {11, 12, 13}))
+
+        async def run_dict():
+            return {i + 10: i + 100 async for i in f(range(5)) if 0 < i < 4}
+        self.assertEqual(
+            run_async(run_dict()),
+            ([], {11: 101, 12: 102, 13: 103}))
+
+        async def run_gen():
+            gen = (i + 10 async for i in f(range(5)) if 0 < i < 4)
+            return [g + 100 async for g in gen]
+        self.assertEqual(
+            run_async(run_gen()),
+            ([], [111, 112, 113]))
+
+    def test_comp_5(self):
+        async def f(it):
+            for i in it:
+                yield i
+
+        async def run_list():
+            return [i + 1 for pair in ([10, 20], [30, 40]) if pair[0] > 10
+                    async for i in f(pair) if i > 30]
+        self.assertEqual(
+            run_async(run_list()),
+            ([], [41]))
+
+    def test_comp_6(self):
+        async def f(it):
+            for i in it:
+                yield i
+
+        async def run_list():
+            return [i + 1 async for seq in f([(10, 20), (30,)])
+                    for i in seq]
+
+        self.assertEqual(
+            run_async(run_list()),
+            ([], [11, 21, 31]))
+
+    def test_comp_7(self):
+        async def f():
+            yield 1
+            yield 2
+            raise Exception('aaa')
+
+        async def run_list():
+            return [i async for i in f()]
+
+        with self.assertRaisesRegex(Exception, 'aaa'):
+            run_async(run_list())
+
+    def test_comp_8(self):
+        async def f():
+            return [i for i in [1, 2, 3]]
+
+        self.assertEqual(
+            run_async(f()),
+            ([], [1, 2, 3]))
+
+    def test_comp_9(self):
+        async def gen():
+            yield 1
+            yield 2
+        async def f():
+            l = [i async for i in gen()]
+            return [i for i in l]
+
+        self.assertEqual(
+            run_async(f()),
+            ([], [1, 2]))
+
+    def test_comp_10(self):
+        async def f():
+            xx = {i for i in [1, 2, 3]}
+            return {x: x for x in xx}
+
+        self.assertEqual(
+            run_async(f()),
+            ([], {1: 1, 2: 2, 3: 3}))
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AttributeError: __aiter__
+    def test_nested_comp(self):
+        async def run_list_inside_list():
+            return [[i + j async for i in asynciter([1, 2])] for j in [10, 20]]
+        self.assertEqual(
+            run_async(run_list_inside_list()),
+            ([], [[11, 12], [21, 22]]))
+
+        async def run_set_inside_list():
+            return [{i + j async for i in asynciter([1, 2])} for j in [10, 20]]
+        self.assertEqual(
+            run_async(run_set_inside_list()),
+            ([], [{11, 12}, {21, 22}]))
+
+        async def run_list_inside_set():
+            return {sum([i async for i in asynciter(range(j))]) for j in [3, 5]}
+        self.assertEqual(
+            run_async(run_list_inside_set()),
+            ([], {3, 10}))
+
+        async def run_dict_inside_dict():
+            return {j: {i: i + j async for i in asynciter([1, 2])} for j in [10, 20]}
+        self.assertEqual(
+            run_async(run_dict_inside_dict()),
+            ([], {10: {1: 11, 2: 12}, 20: {1: 21, 2: 22}}))
+
+        async def run_list_inside_gen():
+            gen = ([i + j async for i in asynciter([1, 2])] for j in [10, 20])
+            return [x async for x in gen]
+        self.assertEqual(
+            run_async(run_list_inside_gen()),
+            ([], [[11, 12], [21, 22]]))
+
+        async def run_gen_inside_list():
+            gens = [(i async for i in asynciter(range(j))) for j in [3, 5]]
+            return [x for g in gens async for x in g]
+        self.assertEqual(
+            run_async(run_gen_inside_list()),
+            ([], [0, 1, 2, 0, 1, 2, 3, 4]))
+
+        async def run_gen_inside_gen():
+            gens = ((i async for i in asynciter(range(j))) for j in [3, 5])
+            return [x for g in gens async for x in g]
+        self.assertEqual(
+            run_async(run_gen_inside_gen()),
+            ([], [0, 1, 2, 0, 1, 2, 3, 4]))
+
+        async def run_list_inside_list_inside_list():
+            return [[[i + j + k async for i in asynciter([1, 2])]
+                     for j in [10, 20]]
+                    for k in [100, 200]]
+        self.assertEqual(
+            run_async(run_list_inside_list_inside_list()),
+            ([], [[[111, 112], [121, 122]], [[211, 212], [221, 222]]]))
+
+    def test_copy(self):
+        async def func(): pass
+        coro = func()
+        with self.assertRaises(TypeError):
+            copy.copy(coro)
+
+        aw = coro.__await__()
+        try:
+            with self.assertRaises(TypeError):
+                copy.copy(aw)
+        finally:
+            aw.close()
+
+    def test_pickle(self):
+        async def func(): pass
+        coro = func()
+        for proto in range(pickle.HIGHEST_PROTOCOL + 1):
+            with self.assertRaises((TypeError, pickle.PicklingError)):
+                pickle.dumps(coro, proto)
+
+        aw = coro.__await__()
+        try:
+            for proto in range(pickle.HIGHEST_PROTOCOL + 1):
+                with self.assertRaises((TypeError, pickle.PicklingError)):
+                    pickle.dumps(aw, proto)
+        finally:
+            aw.close()
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AttributeError: 'NoneType' object has no attribute 'err_msg'
+    def test_fatal_coro_warning(self):
+        # Issue 27811
+        async def func(): pass
+        with warnings.catch_warnings(), \
+             support.catch_unraisable_exception() as cm:
+            warnings.filterwarnings("error")
+            coro = func()
+            # only store repr() to avoid keeping the coroutine alive
+            coro_repr = repr(coro)
+            coro = None
+            support.gc_collect()
+
+            self.assertEqual(cm.unraisable.err_msg,
+                             f"Exception ignored while finalizing "
+                             f"coroutine {coro_repr}")
+            self.assertIn("was never awaited", str(cm.unraisable.exc_value))
+
+    def test_for_assign_raising_stop_async_iteration(self):
+        class BadTarget:
+            def __setitem__(self, key, value):
+                raise StopAsyncIteration(42)
+        tgt = BadTarget()
+        async def source():
+            yield 10
+
+        async def run_for():
+            with self.assertRaises(StopAsyncIteration) as cm:
+                async for tgt[0] in source():
+                    pass
+            self.assertEqual(cm.exception.args, (42,))
+            return 'end'
+        self.assertEqual(run_async(run_for()), ([], 'end'))
+
+        async def run_list():
+            with self.assertRaises(StopAsyncIteration) as cm:
+                return [0 async for tgt[0] in source()]
+            self.assertEqual(cm.exception.args, (42,))
+            return 'end'
+        self.assertEqual(run_async(run_list()), ([], 'end'))
+
+        async def run_gen():
+            gen = (0 async for tgt[0] in source())
+            a = gen.asend(None)
+            with self.assertRaises(RuntimeError) as cm:
+                await a
+            self.assertIsInstance(cm.exception.__cause__, StopAsyncIteration)
+            self.assertEqual(cm.exception.__cause__.args, (42,))
+            return 'end'
+        self.assertEqual(run_async(run_gen()), ([], 'end'))
+
+    def test_for_assign_raising_stop_async_iteration_2(self):
+        class BadIterable:
+            def __iter__(self):
+                raise StopAsyncIteration(42)
+        async def badpairs():
+            yield BadIterable()
+
+        async def run_for():
+            with self.assertRaises(StopAsyncIteration) as cm:
+                async for i, j in badpairs():
+                    pass
+            self.assertEqual(cm.exception.args, (42,))
+            return 'end'
+        self.assertEqual(run_async(run_for()), ([], 'end'))
+
+        async def run_list():
+            with self.assertRaises(StopAsyncIteration) as cm:
+                return [0 async for i, j in badpairs()]
+            self.assertEqual(cm.exception.args, (42,))
+            return 'end'
+        self.assertEqual(run_async(run_list()), ([], 'end'))
+
+        async def run_gen():
+            gen = (0 async for i, j in badpairs())
+            a = gen.asend(None)
+            with self.assertRaises(RuntimeError) as cm:
+                await a
+            self.assertIsInstance(cm.exception.__cause__, StopAsyncIteration)
+            self.assertEqual(cm.exception.__cause__.args, (42,))
+            return 'end'
+        self.assertEqual(run_async(run_gen()), ([], 'end'))
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; This would crash the interpreter in 3.11a2
+    def test_bpo_45813_1(self):
+        'This would crash the interpreter in 3.11a2'
+        async def f():
+            pass
+        with self.assertWarns(RuntimeWarning):
+            frame = f().cr_frame
+        frame.clear()
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; This would crash the interpreter in 3.11a2
+    def test_bpo_45813_2(self):
+        'This would crash the interpreter in 3.11a2'
+        async def f():
+            pass
+        gen = f()
+        with self.assertWarns(RuntimeWarning):
+            gen.cr_frame.clear()
+        gen.close()
+
+    def test_cr_frame_after_close(self):
+        async def f():
+            pass
+        gen = f()
+        self.assertIsNotNone(gen.cr_frame)
+        gen.close()
+        self.assertIsNone(gen.cr_frame)
+
+    def test_stack_in_coroutine_throw(self):
+        # Regression test for https://github.com/python/cpython/issues/93592
+        async def a():
+            return await b()
+
+        async def b():
+            return await c()
+
+        @types.coroutine
+        def c():
+            try:
+                # traceback.print_stack()
+                yield len(traceback.extract_stack())
+            except ZeroDivisionError:
+                # traceback.print_stack()
+                yield len(traceback.extract_stack())
+
+        coro = a()
+        len_send = coro.send(None)
+        len_throw = coro.throw(ZeroDivisionError)
+        # before fixing, visible stack from throw would be shorter than from send.
+        self.assertEqual(len_send, len_throw)
+
+    def test_call_aiter_once_in_comprehension(self):
+
+        class AsyncIterator:
+
+            def __init__(self):
+                self.val = 0
+
+            async def __anext__(self):
+                if self.val == 2:
+                    raise StopAsyncIteration
+                self.val += 1
+                return self.val
+
+            # No __aiter__ method
+
+        class C:
+
+            def __aiter__(self):
+                return AsyncIterator()
+
+        async def run_listcomp():
+            return [i async for i in C()]
+
+        async def run_asyncgen():
+            ag = (i async for i in C())
+            return [i async for i in ag]
+
+        self.assertEqual(run_async(run_listcomp()), ([], [1, 2]))
+        self.assertEqual(run_async(run_asyncgen()), ([], [1, 2]))
+
+
+@unittest.skipIf(
+    support.is_emscripten or support.is_wasi,
+    "asyncio does not work under Emscripten/WASI yet."
+)
+class CoroAsyncIOCompatTest(unittest.TestCase):
+
+    def test_asyncio_1(self):
+        # asyncio cannot be imported when Python is compiled without thread
+        # support
+        asyncio = import_helper.import_module('asyncio')
+
+        class MyException(Exception):
+            pass
+
+        buffer = []
+
+        class CM:
+            async def __aenter__(self):
+                buffer.append(1)
+                await asyncio.sleep(0.01)
+                buffer.append(2)
+                return self
+
+            async def __aexit__(self, exc_type, exc_val, exc_tb):
+                await asyncio.sleep(0.01)
+                buffer.append(exc_type.__name__)
+
+        async def f():
+            async with CM():
+                await asyncio.sleep(0.01)
+                raise MyException
+            buffer.append('unreachable')
+
+        loop = asyncio.new_event_loop()
+        asyncio.set_event_loop(loop)
+        try:
+            loop.run_until_complete(f())
+        except MyException:
+            pass
+        finally:
+            loop.close()
+            asyncio.events._set_event_loop_policy(None)
+
+        self.assertEqual(buffer, [1, 2, 'MyException'])
+
+
+class OriginTrackingTest(unittest.TestCase):
+    def here(self):
+        info = inspect.getframeinfo(inspect.currentframe().f_back)
+        return (info.filename, info.lineno)
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AssertionError: None != (('/home/fanninpm/Documents/GitHub/RustPy[74 chars]g'),)
+    def test_origin_tracking(self):
+        orig_depth = sys.get_coroutine_origin_tracking_depth()
+        try:
+            async def corofn():
+                pass
+
+            sys.set_coroutine_origin_tracking_depth(0)
+            self.assertEqual(sys.get_coroutine_origin_tracking_depth(), 0)
+
+            with contextlib.closing(corofn()) as coro:
+                self.assertIsNone(coro.cr_origin)
+
+            sys.set_coroutine_origin_tracking_depth(1)
+            self.assertEqual(sys.get_coroutine_origin_tracking_depth(), 1)
+
+            fname, lineno = self.here()
+            with contextlib.closing(corofn()) as coro:
+                self.assertEqual(coro.cr_origin,
+                                 ((fname, lineno + 1, "test_origin_tracking"),))
+
+            sys.set_coroutine_origin_tracking_depth(2)
+            self.assertEqual(sys.get_coroutine_origin_tracking_depth(), 2)
+
+            def nested():
+                return (self.here(), corofn())
+            fname, lineno = self.here()
+            ((nested_fname, nested_lineno), coro) = nested()
+            with contextlib.closing(coro):
+                self.assertEqual(coro.cr_origin,
+                                 ((nested_fname, nested_lineno, "nested"),
+                                  (fname, lineno + 1, "test_origin_tracking")))
+
+            # Check we handle running out of frames correctly
+            sys.set_coroutine_origin_tracking_depth(1000)
+            with contextlib.closing(corofn()) as coro:
+                self.assertTrue(2 < len(coro.cr_origin) < 1000)
+
+            # We can't set depth negative
+            with self.assertRaises(ValueError):
+                sys.set_coroutine_origin_tracking_depth(-1)
+            # And trying leaves it unchanged
+            self.assertEqual(sys.get_coroutine_origin_tracking_depth(), 1000)
+
+        finally:
+            sys.set_coroutine_origin_tracking_depth(orig_depth)
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AssertionError: RuntimeWarning not triggered
+    def test_origin_tracking_warning(self):
+        async def corofn():
+            pass
+
+        a1_filename, a1_lineno = self.here()
+        def a1():
+            return corofn()  # comment in a1
+        a1_lineno += 2
+
+        a2_filename, a2_lineno = self.here()
+        def a2():
+            return a1()  # comment in a2
+        a2_lineno += 2
+
+        def check(depth, msg):
+            sys.set_coroutine_origin_tracking_depth(depth)
+            with self.assertWarns(RuntimeWarning) as cm:
+                a2()
+                support.gc_collect()
+            self.assertEqual(msg, str(cm.warning))
+
+        orig_depth = sys.get_coroutine_origin_tracking_depth()
+        try:
+            check(0, f"coroutine '{corofn.__qualname__}' was never awaited")
+            check(1, "".join([
+                f"coroutine '{corofn.__qualname__}' was never awaited\n",
+                "Coroutine created at (most recent call last)\n",
+                f'  File "{a1_filename}", line {a1_lineno}, in a1\n',
+                "    return corofn()  # comment in a1",
+            ]))
+            check(2, "".join([
+                f"coroutine '{corofn.__qualname__}' was never awaited\n",
+                "Coroutine created at (most recent call last)\n",
+                f'  File "{a2_filename}", line {a2_lineno}, in a2\n',
+                "    return a1()  # comment in a2\n",
+                f'  File "{a1_filename}", line {a1_lineno}, in a1\n',
+                "    return corofn()  # comment in a1",
+            ]))
+
+        finally:
+            sys.set_coroutine_origin_tracking_depth(orig_depth)
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AttributeError: 'NoneType' object has no attribute 'err_msg'
+    def test_unawaited_warning_when_module_broken(self):
+        # Make sure we don't blow up too bad if
+        # warnings._warn_unawaited_coroutine is broken somehow (e.g. because
+        # of shutdown problems)
+        async def corofn():
+            pass
+
+        orig_wuc = warnings._warn_unawaited_coroutine
+        try:
+            warnings._warn_unawaited_coroutine = lambda coro: 1/0
+            with support.catch_unraisable_exception() as cm, \
+                 warnings_helper.check_warnings(
+                         (r'coroutine .* was never awaited',
+                          RuntimeWarning)):
+                # only store repr() to avoid keeping the coroutine alive
+                coro = corofn()
+                coro_repr = repr(coro)
+
+                # clear reference to the coroutine without awaiting for it
+                del coro
+                support.gc_collect()
+
+                self.assertEqual(cm.unraisable.err_msg,
+                                 f"Exception ignored while finalizing "
+                                 f"coroutine {coro_repr}")
+                self.assertEqual(cm.unraisable.exc_type, ZeroDivisionError)
+
+            del warnings._warn_unawaited_coroutine
+            with warnings_helper.check_warnings(
+                    (r'coroutine .* was never awaited', RuntimeWarning)):
+                corofn()
+                support.gc_collect()
+
+        finally:
+            warnings._warn_unawaited_coroutine = orig_wuc
+
+
+class UnawaitedWarningDuringShutdownTest(unittest.TestCase):
+    # https://bugs.python.org/issue32591#msg310726
+    def test_unawaited_warning_during_shutdown(self):
+        code = ("import asyncio\n"
+                "async def f(): pass\n"
+                "async def t(): asyncio.gather(f())\n"
+                "asyncio.run(t())\n")
+        assert_python_ok("-c", code)
+
+        code = ("import sys\n"
+                "async def f(): pass\n"
+                "sys.coro = f()\n")
+        assert_python_ok("-c", code)
+
+        code = ("import sys\n"
+                "async def f(): pass\n"
+                "sys.corocycle = [f()]\n"
+                "sys.corocycle.append(sys.corocycle)\n")
+        assert_python_ok("-c", code)
+
+
+@support.cpython_only
+@unittest.skipIf(_testcapi is None, "requires _testcapi")
+class CAPITest(unittest.TestCase):
+
+    def test_tp_await_1(self):
+        from _testcapi import awaitType as at
+
+        async def foo():
+            future = at(iter([1]))
+            return (await future)
+
+        self.assertEqual(foo().send(None), 1)
+
+    def test_tp_await_2(self):
+        # Test tp_await to __await__ mapping
+        from _testcapi import awaitType as at
+        future = at(iter([1]))
+        self.assertEqual(next(future.__await__()), 1)
+
+    def test_tp_await_3(self):
+        from _testcapi import awaitType as at
+
+        async def foo():
+            future = at(1)
+            return (await future)
+
+        with self.assertRaisesRegex(
+                TypeError, "__await__.*returned non-iterator of type 'int'"):
+            self.assertEqual(foo().send(None), 1)
+
+
+if __name__=="__main__":
+    unittest.main()
diff --git a/Lib/test/test_csv.py b/Lib/test/test_csv.py
index bf9b1875573..8af2f0b337c 100644
--- a/Lib/test/test_csv.py
+++ b/Lib/test/test_csv.py
@@ -1,4 +1,4 @@
-# Copyright (C) 2001,2002 Python Software Foundation
+# Copyright (C) 2001 Python Software Foundation
 # csv package unit tests
 
 import copy
@@ -10,7 +10,8 @@
 import gc
 import pickle
 from test import support
-from test.support import import_helper, check_disallow_instantiation
+from test.support import cpython_only, import_helper, check_disallow_instantiation
+from test.support.import_helper import ensure_lazy_imports
 from itertools import permutations
 from textwrap import dedent
 from collections import OrderedDict
@@ -86,12 +87,12 @@ def _test_arg_valid(self, ctor, arg):
         self.assertRaises(ValueError, ctor, arg,
                           quotechar='\x85', lineterminator='\x85')
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_reader_arg_valid(self):
         self._test_arg_valid(csv.reader, [])
         self.assertRaises(OSError, csv.reader, BadIterable())
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_writer_arg_valid(self):
         self._test_arg_valid(csv.writer, StringIO())
         class BadWriter:
@@ -212,7 +213,7 @@ def test_write_bigfield(self):
         self._write_test([bigstring,bigstring], '%s,%s' % \
                          (bigstring, bigstring))
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_write_quoting(self):
         self._write_test(['a',1,'p,q'], 'a,1,"p,q"')
         self._write_error_test(csv.Error, ['a',1,'p,q'],
@@ -230,7 +231,7 @@ def test_write_quoting(self):
         self._write_test(['a','',None,1], '"a","",,"1"',
                          quoting = csv.QUOTE_NOTNULL)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_write_escape(self):
         self._write_test(['a',1,'p,q'], 'a,1,"p,q"',
                          escapechar='\\')
@@ -262,7 +263,7 @@ def test_write_escape(self):
         self._write_test(['C\\', '6', '7', 'X"'], 'C\\\\,6,7,"X"""',
                          escapechar='\\', quoting=csv.QUOTE_MINIMAL)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_write_lineterminator(self):
         for lineterminator in '\r\n', '\n', '\r', '!@#', '\0':
             with self.subTest(lineterminator=lineterminator):
@@ -276,7 +277,7 @@ def test_write_lineterminator(self):
                                      f'1,2{lineterminator}'
                                      f'"\r","\n"{lineterminator}')
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_write_iterable(self):
         self._write_test(iter(['a', 1, 'p,q']), 'a,1,"p,q"')
         self._write_test(iter(['a', 1, None]), 'a,1,')
@@ -319,7 +320,7 @@ def test_writerows_with_none(self):
             self.assertEqual(fileobj.read(), 'a\r\n""\r\n')
 
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_write_empty_fields(self):
         self._write_test((), '')
         self._write_test([''], '""')
@@ -333,7 +334,7 @@ def test_write_empty_fields(self):
         self._write_test(['', ''], ',')
         self._write_test([None, None], ',')
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_write_empty_fields_space_delimiter(self):
         self._write_test([''], '""', delimiter=' ', skipinitialspace=False)
         self._write_test([''], '""', delimiter=' ', skipinitialspace=True)
@@ -374,7 +375,7 @@ def _read_test(self, input, expect, **kwargs):
         result = list(reader)
         self.assertEqual(result, expect)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_read_oddinputs(self):
         self._read_test([], [])
         self._read_test([''], [[]])
@@ -385,7 +386,7 @@ def test_read_oddinputs(self):
         self.assertRaises(csv.Error, self._read_test,
                           [b'abc'], None)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_read_eol(self):
         self._read_test(['a,b', 'c,d'], [['a','b'], ['c','d']])
         self._read_test(['a,b\n', 'c,d\n'], [['a','b'], ['c','d']])
@@ -400,7 +401,7 @@ def test_read_eol(self):
         with self.assertRaisesRegex(csv.Error, errmsg):
             next(csv.reader(['a,b\r\nc,d']))
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_read_eof(self):
         self._read_test(['a,"'], [['a', '']])
         self._read_test(['"a'], [['a']])
@@ -410,7 +411,7 @@ def test_read_eof(self):
         self.assertRaises(csv.Error, self._read_test,
                           ['^'], [], escapechar='^', strict=True)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_read_nul(self):
         self._read_test(['\0'], [['\0']])
         self._read_test(['a,\0b,c'], [['a', '\0b', 'c']])
@@ -423,7 +424,7 @@ def test_read_delimiter(self):
         self._read_test(['a;b;c'], [['a', 'b', 'c']], delimiter=';')
         self._read_test(['a\0b\0c'], [['a', 'b', 'c']], delimiter='\0')
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_read_escape(self):
         self._read_test(['a,\\b,c'], [['a', 'b', 'c']], escapechar='\\')
         self._read_test(['a,b\\,c'], [['a', 'b,c']], escapechar='\\')
@@ -436,7 +437,7 @@ def test_read_escape(self):
         self._read_test(['a,\\b,c'], [['a', '\\b', 'c']], escapechar=None)
         self._read_test(['a,\\b,c'], [['a', '\\b', 'c']])
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_read_quoting(self):
         self._read_test(['1,",3,",5'], [['1', ',3,', '5']])
         self._read_test(['1,",3,",5'], [['1', '"', '3', '"', '5']],
@@ -473,7 +474,7 @@ def test_read_quoting(self):
         self._read_test(['1\\.5,\\.5,"\\.5"'], [[1.5, 0.5, ".5"]],
                         quoting=csv.QUOTE_STRINGS, escapechar='\\')
 
-    @unittest.skip('TODO: RUSTPYTHON; slice index starts at 1 but ends at 0')
+    @unittest.skip("TODO: RUSTPYTHON; slice index starts at 1 but ends at 0")
     def test_read_skipinitialspace(self):
         self._read_test(['no space, space,  spaces,\ttab'],
                         [['no space', 'space', 'spaces', '\ttab']],
@@ -488,7 +489,7 @@ def test_read_skipinitialspace(self):
                         [[None, None, None]],
                         skipinitialspace=True, quoting=csv.QUOTE_STRINGS)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_read_space_delimiter(self):
         self._read_test(['a   b', '  a  ', '  ', ''],
                         [['a', '', '', 'b'], ['', '', 'a', '', ''], ['', '', ''], []],
@@ -528,7 +529,7 @@ def test_read_linenum(self):
         self.assertRaises(StopIteration, next, r)
         self.assertEqual(r.line_num, 3)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_roundtrip_quoteed_newlines(self):
         rows = [
             ['\na', 'b\nc', 'd\n'],
@@ -547,7 +548,7 @@ def test_roundtrip_quoteed_newlines(self):
                     for i, row in enumerate(csv.reader(fileobj)):
                         self.assertEqual(row, rows[i])
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_roundtrip_escaped_unquoted_newlines(self):
         rows = [
             ['\na', 'b\nc', 'd\n'],
@@ -662,7 +663,7 @@ def compare_dialect_123(self, expected, *writeargs, **kwwriteargs):
             fileobj.seek(0)
             self.assertEqual(fileobj.read(), expected)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_dialect_apply(self):
         class testA(csv.excel):
             delimiter = "\t"
@@ -784,7 +785,7 @@ def test_quoted_quote(self):
                                  '"I see," said the blind man',
                                  'as he picked up his hammer and saw']])
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_quoted_nl(self):
         input = '''\
 1,2,3,"""I see,""
@@ -825,18 +826,18 @@ class EscapedExcel(csv.excel):
 class TestEscapedExcel(TestCsvBase):
     dialect = EscapedExcel()
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_escape_fieldsep(self):
         self.writerAssertEqual([['abc,def']], 'abc\\,def\r\n')
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_read_escape_fieldsep(self):
         self.readerAssertEqual('abc\\,def\r\n', [['abc,def']])
 
 class TestDialectUnix(TestCsvBase):
     dialect = 'unix'
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_simple_writer(self):
         self.writerAssertEqual([[1, 'abc def', 'abc']], '"1","abc def","abc"\n')
 
@@ -853,7 +854,7 @@ class TestQuotedEscapedExcel(TestCsvBase):
     def test_write_escape_fieldsep(self):
         self.writerAssertEqual([['abc,def']], '"abc,def"\r\n')
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_read_escape_fieldsep(self):
         self.readerAssertEqual('"abc\\,def"\r\n', [['abc,def']])
 
@@ -941,6 +942,14 @@ def test_dict_reader_fieldnames_accepts_list(self):
         reader = csv.DictReader(f, fieldnames)
         self.assertEqual(reader.fieldnames, fieldnames)
 
+    def test_dict_reader_set_fieldnames(self):
+        fieldnames = ["a", "b", "c"]
+        f = StringIO()
+        reader = csv.DictReader(f)
+        self.assertIsNone(reader.fieldnames)
+        reader.fieldnames = fieldnames
+        self.assertEqual(reader.fieldnames, fieldnames)
+
     def test_dict_writer_fieldnames_rejects_iter(self):
         fieldnames = ["a", "b", "c"]
         f = StringIO()
@@ -956,6 +965,7 @@ def test_dict_writer_fieldnames_accepts_list(self):
     def test_dict_reader_fieldnames_is_optional(self):
         f = StringIO()
         reader = csv.DictReader(f, fieldnames=None)
+        self.assertIsNone(reader.fieldnames)
 
     def test_read_dict_fields(self):
         with TemporaryFile("w+", encoding="utf-8") as fileobj:
@@ -1050,7 +1060,7 @@ def test_read_multi(self):
                                          "s1": 'abc',
                                          "s2": 'def'})
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_read_with_blanks(self):
         reader = csv.DictReader(["1,2,abc,4,5,6\r\n","\r\n",
                                  "1,2,abc,4,5,6\r\n"],
@@ -1102,7 +1112,7 @@ def test_float_write(self):
             fileobj.seek(0)
             self.assertEqual(fileobj.read(), expected)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_char_write(self):
         import array, string
         a = array.array('w', string.ascii_letters)
@@ -1147,19 +1157,22 @@ class mydialect(csv.Dialect):
         with self.assertRaises(csv.Error) as cm:
             mydialect()
         self.assertEqual(str(cm.exception),
-                         '"quotechar" must be a 1-character string')
+                         '"quotechar" must be a unicode character or None, '
+                         'not a string of length 0')
 
         mydialect.quotechar = "''"
         with self.assertRaises(csv.Error) as cm:
             mydialect()
         self.assertEqual(str(cm.exception),
-                         '"quotechar" must be a 1-character string')
+                         '"quotechar" must be a unicode character or None, '
+                         'not a string of length 2')
 
         mydialect.quotechar = 4
         with self.assertRaises(csv.Error) as cm:
             mydialect()
         self.assertEqual(str(cm.exception),
-                         '"quotechar" must be string or None, not int')
+                         '"quotechar" must be a unicode character or None, '
+                         'not int')
 
     def test_delimiter(self):
         class mydialect(csv.Dialect):
@@ -1176,31 +1189,32 @@ class mydialect(csv.Dialect):
         with self.assertRaises(csv.Error) as cm:
             mydialect()
         self.assertEqual(str(cm.exception),
-                         '"delimiter" must be a 1-character string')
+                         '"delimiter" must be a unicode character, '
+                         'not a string of length 3')
 
         mydialect.delimiter = ""
         with self.assertRaises(csv.Error) as cm:
             mydialect()
         self.assertEqual(str(cm.exception),
-                         '"delimiter" must be a 1-character string')
+                         '"delimiter" must be a unicode character, not a string of length 0')
 
         mydialect.delimiter = b","
         with self.assertRaises(csv.Error) as cm:
             mydialect()
         self.assertEqual(str(cm.exception),
-                         '"delimiter" must be string, not bytes')
+                         '"delimiter" must be a unicode character, not bytes')
 
         mydialect.delimiter = 4
         with self.assertRaises(csv.Error) as cm:
             mydialect()
         self.assertEqual(str(cm.exception),
-                         '"delimiter" must be string, not int')
+                         '"delimiter" must be a unicode character, not int')
 
         mydialect.delimiter = None
         with self.assertRaises(csv.Error) as cm:
             mydialect()
         self.assertEqual(str(cm.exception),
-                         '"delimiter" must be string, not NoneType')
+                         '"delimiter" must be a unicode character, not NoneType')
 
     def test_escapechar(self):
         class mydialect(csv.Dialect):
@@ -1214,20 +1228,32 @@ class mydialect(csv.Dialect):
         self.assertEqual(d.escapechar, "\\")
 
         mydialect.escapechar = ""
-        with self.assertRaisesRegex(csv.Error, '"escapechar" must be a 1-character string'):
+        with self.assertRaises(csv.Error) as cm:
             mydialect()
+        self.assertEqual(str(cm.exception),
+                         '"escapechar" must be a unicode character or None, '
+                         'not a string of length 0')
 
         mydialect.escapechar = "**"
-        with self.assertRaisesRegex(csv.Error, '"escapechar" must be a 1-character string'):
+        with self.assertRaises(csv.Error) as cm:
             mydialect()
+        self.assertEqual(str(cm.exception),
+                         '"escapechar" must be a unicode character or None, '
+                         'not a string of length 2')
 
         mydialect.escapechar = b"*"
-        with self.assertRaisesRegex(csv.Error, '"escapechar" must be string or None, not bytes'):
+        with self.assertRaises(csv.Error) as cm:
             mydialect()
+        self.assertEqual(str(cm.exception),
+                         '"escapechar" must be a unicode character or None, '
+                         'not bytes')
 
         mydialect.escapechar = 4
-        with self.assertRaisesRegex(csv.Error, '"escapechar" must be string or None, not int'):
+        with self.assertRaises(csv.Error) as cm:
             mydialect()
+        self.assertEqual(str(cm.exception),
+                         '"escapechar" must be a unicode character or None, '
+                         'not int')
 
     def test_lineterminator(self):
         class mydialect(csv.Dialect):
@@ -1248,9 +1274,15 @@ class mydialect(csv.Dialect):
         with self.assertRaises(csv.Error) as cm:
             mydialect()
         self.assertEqual(str(cm.exception),
-                         '"lineterminator" must be a string')
+                         '"lineterminator" must be a string, not int')
+
+        mydialect.lineterminator = None
+        with self.assertRaises(csv.Error) as cm:
+            mydialect()
+        self.assertEqual(str(cm.exception),
+                         '"lineterminator" must be a string, not NoneType')
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_invalid_chars(self):
         def create_invalid(field_name, value, **kwargs):
             class mydialect(csv.Dialect):
@@ -1357,6 +1389,19 @@ class TestSniffer(unittest.TestCase):
 ghi\0jkl
 """
 
+    sample15 = "\n\n\n"
+    sample16 = "abc\ndef\nghi"
+
+    sample17 = ["letter,offset"]
+    sample17.extend(f"{chr(ord('a') + i)},{i}" for i in range(20))
+    sample17.append("v,twenty_one")  # 'u' was skipped
+    sample17 = '\n'.join(sample17)
+
+    sample18 = ["letter,offset"]
+    sample18.extend(f"{chr(ord('a') + i)},{i}" for i in range(21))
+    sample18.append("v,twenty_one")  # 'u' was not skipped
+    sample18 = '\n'.join(sample18)
+
     def test_issue43625(self):
         sniffer = csv.Sniffer()
         self.assertTrue(sniffer.has_header(self.sample12))
@@ -1378,6 +1423,11 @@ def test_has_header_regex_special_delimiter(self):
         self.assertIs(sniffer.has_header(self.sample8), False)
         self.assertIs(sniffer.has_header(self.header2 + self.sample8), True)
 
+    def test_has_header_checks_20_rows(self):
+        sniffer = csv.Sniffer()
+        self.assertFalse(sniffer.has_header(self.sample17))
+        self.assertTrue(sniffer.has_header(self.sample18))
+
     def test_guess_quote_and_delimiter(self):
         sniffer = csv.Sniffer()
         for header in (";'123;4';", "'123;4';", ";'123;4'", "'123;4'"):
@@ -1427,6 +1477,10 @@ def test_delimiters(self):
         self.assertEqual(dialect.quotechar, "'")
         dialect = sniffer.sniff(self.sample14)
         self.assertEqual(dialect.delimiter, '\0')
+        self.assertRaisesRegex(csv.Error, "Could not determine delimiter",
+                               sniffer.sniff, self.sample15)
+        self.assertRaisesRegex(csv.Error, "Could not determine delimiter",
+                               sniffer.sniff, self.sample16)
 
     def test_doublequote(self):
         sniffer = csv.Sniffer()
@@ -1592,6 +1646,10 @@ class MiscTestCase(unittest.TestCase):
     def test__all__(self):
         support.check__all__(self, csv, ('csv', '_csv'))
 
+    @cpython_only
+    def test_lazy_import(self):
+        ensure_lazy_imports("csv", {"re"})
+
     def test_subclassable(self):
         # issue 44089
         class Foo(csv.Error): ...
diff --git a/Lib/test/test_ctypes/_support.py b/Lib/test/test_ctypes/_support.py
index e4c2b33825a..946d654a19a 100644
--- a/Lib/test/test_ctypes/_support.py
+++ b/Lib/test/test_ctypes/_support.py
@@ -2,15 +2,13 @@
 
 import ctypes
 from _ctypes import Structure, Union, _Pointer, Array, _SimpleCData, CFuncPtr
+import sys
+from test import support
 
 
 _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)
@@ -22,3 +20,132 @@ class _X(Structure):
 # type flags
 Py_TPFLAGS_DISALLOW_INSTANTIATION = 1 << 7
 Py_TPFLAGS_IMMUTABLETYPE = 1 << 8
+
+
+def is_underaligned(ctype):
+    """Return true when type's alignment is less than its size.
+
+    A famous example is 64-bit int on 32-bit x86.
+    """
+    return ctypes.alignment(ctype) < ctypes.sizeof(ctype)
+
+
+class StructCheckMixin:
+    def check_struct(self, structure):
+        """Assert that a structure is well-formed"""
+        self._check_struct_or_union(structure, is_struct=True)
+
+    def check_union(self, union):
+        """Assert that a union is well-formed"""
+        self._check_struct_or_union(union, is_struct=False)
+
+    def check_struct_or_union(self, cls):
+        if issubclass(cls, Structure):
+            self._check_struct_or_union(cls, is_struct=True)
+        elif issubclass(cls, Union):
+            self._check_struct_or_union(cls, is_struct=False)
+        else:
+            raise TypeError(cls)
+
+    def _check_struct_or_union(self, cls, is_struct):
+
+        # Check that fields are not overlapping (for structs),
+        # and that their metadata is consistent.
+
+        used_bits = 0
+
+        is_little_endian = (
+            hasattr(cls, '_swappedbytes_') ^ (sys.byteorder == 'little'))
+
+        anon_names = getattr(cls, '_anonymous_', ())
+        cls_size = ctypes.sizeof(cls)
+        for name, requested_type, *rest_of_tuple in cls._fields_:
+            field = getattr(cls, name)
+            with self.subTest(name=name, field=field):
+                is_bitfield = len(rest_of_tuple) > 0
+
+                # name
+                self.assertEqual(field.name, name)
+
+                # type
+                self.assertEqual(field.type, requested_type)
+
+                # offset === byte_offset
+                self.assertEqual(field.byte_offset, field.offset)
+                if not is_struct:
+                    self.assertEqual(field.byte_offset, 0)
+
+                # byte_size
+                self.assertEqual(field.byte_size, ctypes.sizeof(field.type))
+                self.assertGreaterEqual(field.byte_size, 0)
+
+                # Check that the field is inside the struct.
+                # See gh-130410 for why this is skipped for bitfields of
+                # underaligned types. Later in this function (see `bit_end`)
+                # we assert that the value *bits* are inside the struct.
+                if not (field.is_bitfield and is_underaligned(field.type)):
+                    self.assertLessEqual(field.byte_offset + field.byte_size,
+                                         cls_size)
+
+                # size
+                self.assertGreaterEqual(field.size, 0)
+                if is_bitfield:
+                    # size has backwards-compatible bit-packed info
+                    expected_size = (field.bit_size << 16) + field.bit_offset
+                    self.assertEqual(field.size, expected_size)
+                else:
+                    # size == byte_size
+                    self.assertEqual(field.size, field.byte_size)
+
+                # is_bitfield (bool)
+                self.assertIs(field.is_bitfield, is_bitfield)
+
+                # bit_offset
+                if is_bitfield:
+                    self.assertGreaterEqual(field.bit_offset, 0)
+                    self.assertLessEqual(field.bit_offset + field.bit_size,
+                                         field.byte_size * 8)
+                else:
+                    self.assertEqual(field.bit_offset, 0)
+                if not is_struct:
+                    if is_little_endian:
+                        self.assertEqual(field.bit_offset, 0)
+                    else:
+                        self.assertEqual(field.bit_offset,
+                                         field.byte_size * 8 - field.bit_size)
+
+                # bit_size
+                if is_bitfield:
+                    self.assertGreaterEqual(field.bit_size, 0)
+                    self.assertLessEqual(field.bit_size, field.byte_size * 8)
+                    [requested_bit_size] = rest_of_tuple
+                    self.assertEqual(field.bit_size, requested_bit_size)
+                else:
+                    self.assertEqual(field.bit_size, field.byte_size * 8)
+
+                # is_anonymous (bool)
+                self.assertIs(field.is_anonymous, name in anon_names)
+
+                # In a struct, field should not overlap.
+                # (Test skipped if the structs is enormous.)
+                if is_struct and cls_size < 10_000:
+                    # Get a mask indicating where the field is within the struct
+                    if is_little_endian:
+                        tp_shift = field.byte_offset * 8
+                    else:
+                        tp_shift = (cls_size
+                                    - field.byte_offset
+                                    - field.byte_size) * 8
+                    mask = (1 << field.bit_size) - 1
+                    mask <<= (tp_shift + field.bit_offset)
+                    assert mask.bit_count() == field.bit_size
+                    # Check that these bits aren't shared with previous fields
+                    self.assertEqual(used_bits & mask, 0)
+                    # Mark the bits for future checks
+                    used_bits |= mask
+
+                # field is inside cls
+                bit_end = (field.byte_offset * 8
+                           + field.bit_offset
+                           + field.bit_size)
+                self.assertLessEqual(bit_end, cls_size * 8)
diff --git a/Lib/test/test_ctypes/test_aligned_structures.py b/Lib/test/test_ctypes/test_aligned_structures.py
index 8e8ac429900..50b4d729b9d 100644
--- a/Lib/test/test_ctypes/test_aligned_structures.py
+++ b/Lib/test/test_ctypes/test_aligned_structures.py
@@ -1,13 +1,13 @@
 from ctypes import (
     c_char, c_uint32, c_uint16, c_ubyte, c_byte, alignment, sizeof,
     BigEndianStructure, LittleEndianStructure,
-    BigEndianUnion, LittleEndianUnion, Structure
+    BigEndianUnion, LittleEndianUnion, Structure,
 )
 import struct
 import unittest
+from ._support import StructCheckMixin
 
-
-class TestAlignedStructures(unittest.TestCase):
+class TestAlignedStructures(unittest.TestCase, StructCheckMixin):
     def test_aligned_string(self):
         for base, e in (
             (LittleEndianStructure, "<"),
@@ -19,12 +19,14 @@ class Aligned(base):
                 _fields_ = [
                     ('value', c_char * 12)
                 ]
+            self.check_struct(Aligned)
 
             class Main(base):
                 _fields_ = [
                     ('first', c_uint32),
                     ('string', Aligned),
                 ]
+            self.check_struct(Main)
 
             main = Main.from_buffer(data)
             self.assertEqual(main.first, 7)
@@ -46,12 +48,14 @@ class SomeBools(base):
                     ("bool1", c_ubyte),
                     ("bool2", c_ubyte),
                 ]
+            self.check_struct(SomeBools)
             class Main(base):
                 _fields_ = [
                     ("x", c_ubyte),
                     ("y", SomeBools),
                     ("z", c_ubyte),
                 ]
+            self.check_struct(Main)
 
             main = Main.from_buffer(data)
             self.assertEqual(alignment(SomeBools), 4)
@@ -65,6 +69,41 @@ class Main(base):
             self.assertEqual(Main.z.offset, 8)
             self.assertEqual(main.z, 7)
 
+    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)
+
     def test_oversized_structure(self):
         data = bytearray(b"\0" * 8)
         for base in (LittleEndianStructure, BigEndianStructure):
@@ -75,11 +114,13 @@ class SomeBoolsTooBig(base):
                     ("bool2", c_ubyte),
                     ("bool3", c_ubyte),
                 ]
+            self.check_struct(SomeBoolsTooBig)
             class Main(base):
                 _fields_ = [
                     ("y", SomeBoolsTooBig),
                     ("z", c_uint32),
                 ]
+            self.check_struct(Main)
             with self.assertRaises(ValueError) as ctx:
                 Main.from_buffer(data)
                 self.assertEqual(
@@ -98,18 +139,21 @@ class UnalignedSub(base):
                 _fields_ = [
                     ("x", c_uint32),
                 ]
+            self.check_struct(UnalignedSub)
 
             class AlignedStruct(UnalignedSub):
                 _align_ = 8
                 _fields_ = [
                     ("y", c_uint32),
                 ]
+            self.check_struct(AlignedStruct)
 
             class Main(base):
                 _fields_ = [
                     ("a", c_uint32),
                     ("b", AlignedStruct)
                 ]
+            self.check_struct(Main)
 
             main = Main.from_buffer(data)
             self.assertEqual(alignment(main.b), 8)
@@ -134,12 +178,14 @@ class AlignedUnion(ubase):
                     ("a", c_uint32),
                     ("b", c_ubyte * 7),
                 ]
+            self.check_union(AlignedUnion)
 
             class Main(sbase):
                 _fields_ = [
                     ("first", c_uint32),
                     ("union", AlignedUnion),
                 ]
+            self.check_struct(Main)
 
             main = Main.from_buffer(data)
             self.assertEqual(main.first, 1)
@@ -162,18 +208,21 @@ class Sub(sbase):
                     ("x", c_uint32),
                     ("y", c_uint32),
                 ]
+            self.check_struct(Sub)
 
             class MainUnion(ubase):
                 _fields_ = [
                     ("a", c_uint32),
                     ("b", Sub),
                 ]
+            self.check_union(MainUnion)
 
             class Main(sbase):
                 _fields_ = [
                     ("first", c_uint32),
                     ("union", MainUnion),
                 ]
+            self.check_struct(Main)
 
             main = Main.from_buffer(data)
             self.assertEqual(Main.first.size, 4)
@@ -198,17 +247,20 @@ class SubUnion(ubase):
                     ("unsigned", c_ubyte),
                     ("signed", c_byte),
                 ]
+            self.check_union(SubUnion)
 
             class MainUnion(SubUnion):
                 _fields_ = [
                     ("num", c_uint32)
                 ]
+            self.check_union(SubUnion)
 
             class Main(sbase):
                 _fields_ = [
                     ("first", c_uint16),
                     ("union", MainUnion),
                 ]
+            self.check_struct(Main)
 
             main = Main.from_buffer(data)
             self.assertEqual(main.union.num, 0xD60102D7)
@@ -232,11 +284,13 @@ class SubUnion(ubase):
                     ("unsigned", c_ubyte),
                     ("signed", c_byte),
                 ]
+            self.check_union(SubUnion)
 
             class Main(SubUnion):
                 _fields_ = [
                     ("num", c_uint32)
                 ]
+            self.check_struct(Main)
 
             main = Main.from_buffer(data)
             self.assertEqual(alignment(main), 8)
@@ -258,14 +312,17 @@ class Inner(sbase):
                     ("x", c_uint16),
                     ("y", c_uint16),
                 ]
+            self.check_struct(Inner)
 
             class Main(sbase):
                 _pack_ = 1
+                _layout_ = "ms"
                 _fields_ = [
                     ("a", c_ubyte),
                     ("b", Inner),
                     ("c", c_ubyte),
                 ]
+            self.check_struct(Main)
 
             main = Main.from_buffer(data)
             self.assertEqual(sizeof(main), 10)
@@ -281,41 +338,6 @@ class Main(sbase):
             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
index b36397b510f..2e16e708635 100644
--- a/Lib/test/test_ctypes/test_anon.py
+++ b/Lib/test/test_ctypes/test_anon.py
@@ -1,20 +1,23 @@
 import unittest
 import test.support
 from ctypes import c_int, Union, Structure, sizeof
+from ._support import StructCheckMixin
 
 
-class AnonTest(unittest.TestCase):
+class AnonTest(unittest.TestCase, StructCheckMixin):
 
     def test_anon(self):
         class ANON(Union):
             _fields_ = [("a", c_int),
                         ("b", c_int)]
+        self.check_union(ANON)
 
         class Y(Structure):
             _fields_ = [("x", c_int),
                         ("_", ANON),
                         ("y", c_int)]
             _anonymous_ = ["_"]
+        self.check_struct(Y)
 
         self.assertEqual(Y.a.offset, sizeof(c_int))
         self.assertEqual(Y.b.offset, sizeof(c_int))
@@ -52,17 +55,20 @@ class Name(Structure):
     def test_nested(self):
         class ANON_S(Structure):
             _fields_ = [("a", c_int)]
+        self.check_struct(ANON_S)
 
         class ANON_U(Union):
             _fields_ = [("_", ANON_S),
                         ("b", c_int)]
             _anonymous_ = ["_"]
+        self.check_union(ANON_U)
 
         class Y(Structure):
             _fields_ = [("x", c_int),
                         ("_", ANON_U),
                         ("y", c_int)]
             _anonymous_ = ["_"]
+        self.check_struct(Y)
 
         self.assertEqual(Y.x.offset, 0)
         self.assertEqual(Y.a.offset, sizeof(c_int))
diff --git a/Lib/test/test_ctypes/test_arrays.py b/Lib/test/test_ctypes/test_arrays.py
index c80fdff5de6..7f1f6cf5840 100644
--- a/Lib/test/test_ctypes/test_arrays.py
+++ b/Lib/test/test_ctypes/test_arrays.py
@@ -5,7 +5,7 @@
                     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 test.support import bigmemtest, _2G, threading_helper, Py_GIL_DISABLED
 from ._support import (_CData, PyCArrayType, Py_TPFLAGS_DISALLOW_INSTANTIATION,
                        Py_TPFLAGS_IMMUTABLETYPE)
 
@@ -267,6 +267,26 @@ def test_bpo36504_signed_int_overflow(self):
     def test_large_array(self, size):
         c_char * size
 
+    @threading_helper.requires_working_threading()
+    @unittest.skipUnless(Py_GIL_DISABLED, "only meaningful if the GIL is disabled")
+    def test_thread_safety(self):
+        from threading import Thread
+
+        buffer = (ctypes.c_char_p * 10)()
+
+        def run():
+            for i in range(100):
+                buffer.value = b"hello"
+                buffer[0] = b"j"
+
+        with threading_helper.catch_threading_exception() as cm:
+            threads = (Thread(target=run) for _ in range(25))
+            with threading_helper.start_threads(threads):
+                pass
+
+            if cm.exc_value:
+                raise cm.exc_value
+
 
 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
index c5e1840b0eb..2da1acfcf29 100644
--- a/Lib/test/test_ctypes/test_as_parameter.py
+++ b/Lib/test/test_ctypes/test_as_parameter.py
@@ -5,7 +5,7 @@
                     c_short, c_int, c_long, c_longlong,
                     c_byte, c_wchar, c_float, c_double,
                     ArgumentError)
-from test.support import import_helper
+from test.support import import_helper, skip_if_sanitizer
 _ctypes_test = import_helper.import_module("_ctypes_test")
 
 
@@ -192,6 +192,7 @@ class S8I(Structure):
         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))
 
+    @skip_if_sanitizer('requires deep stack', thread=True)
     def test_recursive_as_param(self):
         class A:
             pass
diff --git a/Lib/test/test_ctypes/test_bitfields.py b/Lib/test/test_ctypes/test_bitfields.py
index 0332544b582..518f838219e 100644
--- a/Lib/test/test_ctypes/test_bitfields.py
+++ b/Lib/test/test_ctypes/test_bitfields.py
@@ -1,72 +1,137 @@
 import os
+import sys
 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)
+                    c_uint8, c_uint16, c_uint32, c_uint64,
+                    c_short, c_ushort, c_int, c_uint, c_long, c_ulong,
+                    c_longlong, c_ulonglong,
+                    Union)
 from test import support
 from test.support import import_helper
+from ._support import StructCheckMixin
 _ctypes_test = import_helper.import_module("_ctypes_test")
 
 
+TEST_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),
+)
+
+
 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)]
+    _fields_ = TEST_FIELDS
 
 func = CDLL(_ctypes_test.__file__).unpack_bitfields
 func.argtypes = POINTER(BITS), c_char
 
 
+class BITS_msvc(Structure):
+    _layout_ = "ms"
+    _fields_ = TEST_FIELDS
+
+
+class BITS_gcc(Structure):
+    _layout_ = "gcc-sysv"
+    _fields_ = TEST_FIELDS
+
+
+try:
+    func_msvc = CDLL(_ctypes_test.__file__).unpack_bitfields_msvc
+except AttributeError as err:
+    # The MSVC struct must be available on Windows; it's optional elsewhere
+    if support.MS_WINDOWS:
+        raise err
+    func_msvc = None
+else:
+    func_msvc.argtypes = POINTER(BITS_msvc), 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')))
+                with self.subTest(i=i, name=name):
+                    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"
+        # See Modules/_ctypes/_ctypes_test.c for where the magic 999 comes from.
         if func(byref(b), name.encode('ascii')) == 999:
+            # unpack_bitfields and unpack_bitfields_msvc in
+            # Modules/_ctypes/_ctypes_test.c return 999 to indicate
+            # an invalid name. 'M' is only valid, if signed short bitfields
+            # are supported by the C compiler.
             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')))
+                with self.subTest(i=i, name=name):
+                    b = BITS()
+                    setattr(b, name, i)
+                    self.assertEqual(
+                        getattr(b, name),
+                        func(byref(b), (name.encode('ascii'))))
+
+    @unittest.skipUnless(func_msvc, "need MSVC or __attribute__((ms_struct))")
+    def test_shorts_msvc_mode(self):
+        b = BITS_msvc()
+        name = "M"
+        # See Modules/_ctypes/_ctypes_test.c for where the magic 999 comes from.
+        if func_msvc(byref(b), name.encode('ascii')) == 999:
+            # unpack_bitfields and unpack_bitfields_msvc in
+            # Modules/_ctypes/_ctypes_test.c return 999 to indicate
+            # an invalid name. 'M' is only valid, if signed short bitfields
+            # are supported by the C compiler.
+            self.skipTest("Compiler does not support signed short bitfields")
+        for i in range(256):
+            for name in "MNOPQRS":
+                with self.subTest(i=i, name=name):
+                    b = BITS_msvc()
+                    setattr(b, name, i)
+                    self.assertEqual(
+                        getattr(b, name),
+                        func_msvc(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):
+class BitFieldTest(unittest.TestCase, StructCheckMixin):
+
+    def test_generic_checks(self):
+        self.check_struct(BITS)
+        self.check_struct(BITS_msvc)
+        self.check_struct(BITS_gcc)
 
     def test_longlong(self):
         class X(Structure):
             _fields_ = [("a", c_longlong, 1),
                         ("b", c_longlong, 62),
                         ("c", c_longlong, 1)]
+        self.check_struct(X)
 
         self.assertEqual(sizeof(X), sizeof(c_longlong))
         x = X()
@@ -78,6 +143,7 @@ class X(Structure):
             _fields_ = [("a", c_ulonglong, 1),
                         ("b", c_ulonglong, 62),
                         ("c", c_ulonglong, 1)]
+        self.check_struct(X)
 
         self.assertEqual(sizeof(X), sizeof(c_longlong))
         x = X()
@@ -87,39 +153,49 @@ class X(Structure):
 
     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))
+            with self.subTest(c_typ):
+                if sizeof(c_typ) != alignment(c_typ):
+                     self.skipTest('assumes size=alignment')
+                class X(Structure):
+                    _fields_ = [("dummy", c_typ),
+                                ("a", c_typ, 3),
+                                ("b", c_typ, 3),
+                                ("c", c_typ, 1)]
+                self.check_struct(X)
+                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))
+            with self.subTest(c_typ):
+                if sizeof(c_typ) != alignment(c_typ):
+                     self.skipTest('assumes size=alignment')
+                class X(Structure):
+                    _fields_ = [("a", c_typ, 3),
+                                ("b", c_typ, 3),
+                                ("c", c_typ, 1)]
+                self.check_struct(X)
+                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})
+        for layout in "ms", "gcc-sysv":
+            with self.subTest(layout=layout):
+                return self.get_except(type(Structure), "X", (),
+                                       {"_fields_": fields, "layout": layout})
 
     def test_nonint_types(self):
         # bit fields are not allowed on non-integer types.
@@ -136,8 +212,16 @@ def test_nonint_types(self):
         result = self.fail_fields(("a", c_char, 1))
         self.assertEqual(result, (TypeError, 'bit fields not allowed for type c_char'))
 
-        class Dummy(Structure):
+        class Empty(Structure):
             _fields_ = []
+        self.check_struct(Empty)
+
+        result = self.fail_fields(("a", Empty, 1))
+        self.assertEqual(result, (ValueError, "number of bits invalid for bit field 'a'"))
+
+        class Dummy(Structure):
+            _fields_ = [("x", c_int)]
+        self.check_struct(Dummy)
 
         result = self.fail_fields(("a", Dummy, 1))
         self.assertEqual(result, (TypeError, 'bit fields not allowed for type Dummy'))
@@ -149,28 +233,37 @@ def test_c_wchar(self):
 
     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'))
+            with self.subTest(c_typ):
+                if sizeof(c_typ) != alignment(c_typ):
+                     self.skipTest('assumes size=alignment')
+                result = self.fail_fields(("a", c_typ, -1))
+                self.assertEqual(result, (ValueError,
+                    "number of bits invalid for bit field 'a'"))
+
+                result = self.fail_fields(("a", c_typ, 0))
+                self.assertEqual(result, (ValueError,
+                    "number of bits invalid for bit field 'a'"))
+
+                class X(Structure):
+                    _fields_ = [("a", c_typ, 1)]
+                self.check_struct(X)
+                self.assertEqual(sizeof(X), sizeof(c_typ))
+
+                class X(Structure):
+                    _fields_ = [("a", c_typ, sizeof(c_typ)*8)]
+                self.check_struct(X)
+                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 'a'"))
 
     def test_multi_bitfields_size(self):
         class X(Structure):
             _fields_ = [("a", c_short, 1),
                         ("b", c_short, 14),
                         ("c", c_short, 1)]
+        self.check_struct(X)
         self.assertEqual(sizeof(X), sizeof(c_short))
 
         class X(Structure):
@@ -178,6 +271,7 @@ class X(Structure):
                         ("a1", c_short),
                         ("b", c_short, 14),
                         ("c", c_short, 1)]
+        self.check_struct(X)
         self.assertEqual(sizeof(X), sizeof(c_short)*3)
         self.assertEqual(X.a.offset, 0)
         self.assertEqual(X.a1.offset, sizeof(c_short))
@@ -188,6 +282,7 @@ class X(Structure):
             _fields_ = [("a", c_short, 3),
                         ("b", c_short, 14),
                         ("c", c_short, 14)]
+        self.check_struct(X)
         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)
@@ -203,6 +298,7 @@ def test_mixed_1(self):
         class X(Structure):
             _fields_ = [("a", c_byte, 4),
                         ("b", c_int, 4)]
+        self.check_struct(X)
         if os.name == "nt":
             self.assertEqual(sizeof(X), sizeof(c_int)*2)
         else:
@@ -212,12 +308,14 @@ def test_mixed_2(self):
         class X(Structure):
             _fields_ = [("a", c_byte, 4),
                         ("b", c_int, 32)]
+        self.check_struct(X)
         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.check_struct(X)
         self.assertEqual(sizeof(X), sizeof(c_byte))
 
     def test_mixed_4(self):
@@ -228,6 +326,7 @@ class X(Structure):
                         ("d", c_short, 4),
                         ("e", c_short, 4),
                         ("f", c_int, 24)]
+        self.check_struct(X)
         # 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).
@@ -236,6 +335,177 @@ class X(Structure):
         else:
             self.assertEqual(sizeof(X), sizeof(c_int) * 2)
 
+    def test_mixed_5(self):
+        class X(Structure):
+            _fields_ = [
+                ('A', c_uint, 1),
+                ('B', c_ushort, 16)]
+        self.check_struct(X)
+        a = X()
+        a.A = 0
+        a.B = 1
+        self.assertEqual(1, a.B)
+
+    def test_mixed_6(self):
+        class X(Structure):
+            _fields_ = [
+                ('A', c_ulonglong, 1),
+                ('B', c_uint, 32)]
+        self.check_struct(X)
+        a = X()
+        a.A = 0
+        a.B = 1
+        self.assertEqual(1, a.B)
+
+    @unittest.skipIf(sizeof(c_uint64) != alignment(c_uint64),
+                     'assumes size=alignment')
+    def test_mixed_7(self):
+        class X(Structure):
+            _fields_ = [
+                ("A", c_uint32),
+                ('B', c_uint32, 20),
+                ('C', c_uint64, 24)]
+        self.check_struct(X)
+        self.assertEqual(16, sizeof(X))
+
+    def test_mixed_8(self):
+        class Foo(Structure):
+            _fields_ = [
+                ("A", c_uint32),
+                ("B", c_uint32, 32),
+                ("C", c_ulonglong, 1),
+                ]
+        self.check_struct(Foo)
+
+        class Bar(Structure):
+            _fields_ = [
+                ("A", c_uint32),
+                ("B", c_uint32),
+                ("C", c_ulonglong, 1),
+                ]
+        self.check_struct(Bar)
+        self.assertEqual(sizeof(Foo), sizeof(Bar))
+
+    def test_mixed_9(self):
+        class X(Structure):
+            _fields_ = [
+                ("A", c_uint8),
+                ("B", c_uint32, 1),
+                ]
+        self.check_struct(X)
+        if sys.platform == 'win32':
+            self.assertEqual(8, sizeof(X))
+        else:
+            self.assertEqual(4, sizeof(X))
+
+    @unittest.skipIf(sizeof(c_uint64) != alignment(c_uint64),
+                     'assumes size=alignment')
+    def test_mixed_10(self):
+        class X(Structure):
+            _fields_ = [
+                ("A", c_uint32, 1),
+                ("B", c_uint64, 1),
+                ]
+        self.check_struct(X)
+        if sys.platform == 'win32':
+            self.assertEqual(8, alignment(X))
+            self.assertEqual(16, sizeof(X))
+        else:
+            self.assertEqual(8, alignment(X))
+            self.assertEqual(8, sizeof(X))
+
+    def test_gh_95496(self):
+        for field_width in range(1, 33):
+            class TestStruct(Structure):
+                _fields_ = [
+                    ("Field1", c_uint32, field_width),
+                    ("Field2", c_uint8, 8)
+                ]
+            self.check_struct(TestStruct)
+
+            cmd = TestStruct()
+            cmd.Field2 = 1
+            self.assertEqual(1, cmd.Field2)
+
+    def test_gh_84039(self):
+        class Bad(Structure):
+            _pack_ = 1
+            _layout_ = "ms"
+            _fields_ = [
+                ("a0", c_uint8, 1),
+                ("a1", c_uint8, 1),
+                ("a2", c_uint8, 1),
+                ("a3", c_uint8, 1),
+                ("a4", c_uint8, 1),
+                ("a5", c_uint8, 1),
+                ("a6", c_uint8, 1),
+                ("a7", c_uint8, 1),
+                ("b0", c_uint16, 4),
+                ("b1", c_uint16, 12),
+            ]
+
+        class GoodA(Structure):
+            _pack_ = 1
+            _layout_ = "ms"
+            _fields_ = [
+                ("a0", c_uint8, 1),
+                ("a1", c_uint8, 1),
+                ("a2", c_uint8, 1),
+                ("a3", c_uint8, 1),
+                ("a4", c_uint8, 1),
+                ("a5", c_uint8, 1),
+                ("a6", c_uint8, 1),
+                ("a7", c_uint8, 1),
+            ]
+
+
+        class Good(Structure):
+            _pack_ = 1
+            _layout_ = "ms"
+            _fields_ = [
+                ("a", GoodA),
+                ("b0", c_uint16, 4),
+                ("b1", c_uint16, 12),
+            ]
+        self.check_struct(Bad)
+        self.check_struct(GoodA)
+        self.check_struct(Good)
+
+        self.assertEqual(3, sizeof(Bad))
+        self.assertEqual(3, sizeof(Good))
+
+    def test_gh_73939(self):
+        class MyStructure(Structure):
+            _pack_      = 1
+            _layout_ = "ms"
+            _fields_    = [
+                            ("P",       c_uint16),
+                            ("L",       c_uint16, 9),
+                            ("Pro",     c_uint16, 1),
+                            ("G",       c_uint16, 1),
+                            ("IB",      c_uint16, 1),
+                            ("IR",      c_uint16, 1),
+                            ("R",       c_uint16, 3),
+                            ("T",       c_uint32, 10),
+                            ("C",       c_uint32, 20),
+                            ("R2",      c_uint32, 2)
+                        ]
+        self.check_struct(MyStructure)
+        self.assertEqual(8, sizeof(MyStructure))
+
+    def test_gh_86098(self):
+        class X(Structure):
+            _fields_ = [
+                ("a", c_uint8, 8),
+                ("b", c_uint8, 8),
+                ("c", c_uint32, 16)
+            ]
+        self.check_struct(X)
+        if sys.platform == 'win32':
+            self.assertEqual(8, sizeof(X))
+        else:
+            self.assertEqual(4, sizeof(X))
+
     def test_anon_bitfields(self):
         # anonymous bit-fields gave a strange error message
         class X(Structure):
@@ -245,9 +515,13 @@ class Y(Structure):
             _anonymous_ = ["_"]
             _fields_ = [("_", X)]
 
+        self.check_struct(X)
+        self.check_struct(Y)
+
     def test_uint32(self):
         class X(Structure):
             _fields_ = [("a", c_uint32, 32)]
+        self.check_struct(X)
         x = X()
         x.a = 10
         self.assertEqual(x.a, 10)
@@ -257,6 +531,7 @@ class X(Structure):
     def test_uint64(self):
         class X(Structure):
             _fields_ = [("a", c_uint64, 64)]
+        self.check_struct(X)
         x = X()
         x.a = 10
         self.assertEqual(x.a, 10)
@@ -269,6 +544,7 @@ class Little(LittleEndianStructure):
             _fields_ = [("a", c_uint32, 24),
                         ("b", c_uint32, 4),
                         ("c", c_uint32, 4)]
+        self.check_struct(Little)
         b = bytearray(4)
         x = Little.from_buffer(b)
         x.a = 0xabcdef
@@ -282,6 +558,7 @@ class Big(BigEndianStructure):
             _fields_ = [("a", c_uint32, 24),
                         ("b", c_uint32, 4),
                         ("c", c_uint32, 4)]
+        self.check_struct(Big)
         b = bytearray(4)
         x = Big.from_buffer(b)
         x.a = 0xabcdef
@@ -289,6 +566,22 @@ class Big(BigEndianStructure):
         x.c = 2
         self.assertEqual(b, b'\xab\xcd\xef\x12')
 
+    def test_union_bitfield(self):
+        class BitfieldUnion(Union):
+            _fields_ = [("a", c_uint32, 1),
+                        ("b", c_uint32, 2),
+                        ("c", c_uint32, 3)]
+        self.check_union(BitfieldUnion)
+        self.assertEqual(sizeof(BitfieldUnion), 4)
+        b = bytearray(4)
+        x = BitfieldUnion.from_buffer(b)
+        x.a = 1
+        self.assertEqual(int.from_bytes(b).bit_count(), 1)
+        x.b = 3
+        self.assertEqual(int.from_bytes(b).bit_count(), 2)
+        x.c = 7
+        self.assertEqual(int.from_bytes(b).bit_count(), 3)
+
 
 if __name__ == "__main__":
     unittest.main()
diff --git a/Lib/test/test_ctypes/test_bytes.py b/Lib/test/test_ctypes/test_bytes.py
index fa11e1bbd49..0e7f81b9482 100644
--- a/Lib/test/test_ctypes/test_bytes.py
+++ b/Lib/test/test_ctypes/test_bytes.py
@@ -3,9 +3,10 @@
 import unittest
 from _ctypes import _SimpleCData
 from ctypes import Structure, c_char, c_char_p, c_wchar, c_wchar_p
+from ._support import StructCheckMixin
 
 
-class BytesTest(unittest.TestCase):
+class BytesTest(unittest.TestCase, StructCheckMixin):
     def test_c_char(self):
         x = c_char(b"x")
         self.assertRaises(TypeError, c_char, "x")
@@ -40,6 +41,7 @@ def test_c_wchar_p(self):
     def test_struct(self):
         class X(Structure):
             _fields_ = [("a", c_char * 3)]
+        self.check_struct(X)
 
         x = X(b"abc")
         self.assertRaises(TypeError, X, "abc")
@@ -49,6 +51,7 @@ class X(Structure):
     def test_struct_W(self):
         class X(Structure):
             _fields_ = [("a", c_wchar * 3)]
+        self.check_struct(X)
 
         x = X("abc")
         self.assertRaises(TypeError, X, b"abc")
diff --git a/Lib/test/test_ctypes/test_byteswap.py b/Lib/test/test_ctypes/test_byteswap.py
index 78eff0392c4..ea5951603f9 100644
--- a/Lib/test/test_ctypes/test_byteswap.py
+++ b/Lib/test/test_ctypes/test_byteswap.py
@@ -11,6 +11,7 @@
                     c_short, c_ushort, c_int, c_uint,
                     c_long, c_ulong, c_longlong, c_ulonglong,
                     c_uint32, c_float, c_double)
+from ._support import StructCheckMixin
 
 
 def bin(s):
@@ -24,15 +25,17 @@ def bin(s):
 #
 # For Structures and Unions, these types are created on demand.
 
-class Test(unittest.TestCase):
+class Test(unittest.TestCase, StructCheckMixin):
     def test_slots(self):
         class BigPoint(BigEndianStructure):
             __slots__ = ()
             _fields_ = [("x", c_int), ("y", c_int)]
+        self.check_struct(BigPoint)
 
         class LowPoint(LittleEndianStructure):
             __slots__ = ()
             _fields_ = [("x", c_int), ("y", c_int)]
+        self.check_struct(LowPoint)
 
         big = BigPoint()
         little = LowPoint()
@@ -200,6 +203,7 @@ def test_struct_fields_unsupported_byte_order(self):
             with self.assertRaises(TypeError):
                 class T(BigEndianStructure if sys.byteorder == "little" else LittleEndianStructure):
                     _fields_ = fields + [("x", typ)]
+                self.check_struct(T)
 
 
     def test_struct_struct(self):
@@ -219,14 +223,15 @@ def test_struct_struct(self):
                 class NestedStructure(nested):
                     _fields_ = [("x", c_uint32),
                                 ("y", c_uint32)]
+                self.check_struct(NestedStructure)
 
                 class TestStructure(parent):
                     _fields_ = [("point", NestedStructure)]
+                self.check_struct(TestStructure)
 
                 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)
 
@@ -248,6 +253,7 @@ class S(base):
                         ("h", c_short),
                         ("i", c_int),
                         ("d", c_double)]
+        self.check_struct(S)
 
         s1 = S(0x12, 0x1234, 0x12345678, 3.14)
         s2 = struct.pack(fmt, 0x12, 0x1234, 0x12345678, 3.14)
@@ -263,6 +269,7 @@ def test_unaligned_nonnative_struct_fields(self):
 
         class S(base):
             _pack_ = 1
+            _layout_ = "ms"
             _fields_ = [("b", c_byte),
                         ("h", c_short),
 
@@ -271,6 +278,7 @@ class S(base):
 
                         ("_2", c_byte),
                         ("d", c_double)]
+        self.check_struct(S)
 
         s1 = S()
         s1.b = 0x12
@@ -289,6 +297,7 @@ def test_unaligned_native_struct_fields(self):
 
         class S(Structure):
             _pack_ = 1
+            _layout_ = "ms"
             _fields_ = [("b", c_byte),
 
                         ("h", c_short),
@@ -298,6 +307,7 @@ class S(Structure):
 
                         ("_2", c_byte),
                         ("d", c_double)]
+        self.check_struct(S)
 
         s1 = S()
         s1.b = 0x12
@@ -334,6 +344,7 @@ def test_union_fields_unsupported_byte_order(self):
             with self.assertRaises(TypeError):
                 class T(BigEndianUnion if sys.byteorder == "little" else LittleEndianUnion):
                     _fields_ = fields + [("x", typ)]
+                self.check_union(T)
 
     def test_union_struct(self):
         # nested structures in unions with different byteorders
@@ -352,14 +363,15 @@ def test_union_struct(self):
                 class NestedStructure(nested):
                     _fields_ = [("x", c_uint32),
                                 ("y", c_uint32)]
+                self.check_struct(NestedStructure)
 
                 class TestUnion(parent):
                     _fields_ = [("point", NestedStructure)]
+                self.check_union(TestUnion)
 
                 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)
 
@@ -374,12 +386,15 @@ def test_build_struct_union_opposite_system_byteorder(self):
 
         class S1(_Structure):
             _fields_ = [("a", c_byte), ("b", c_byte)]
+        self.check_struct(S1)
 
         class U1(_Union):
             _fields_ = [("s1", S1), ("ab", c_short)]
+        self.check_union(U1)
 
         class S2(_Structure):
             _fields_ = [("u1", U1), ("c", c_byte)]
+        self.check_struct(S2)
 
 
 if __name__ == "__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
index eb77d6d7782..fd261acf497 100644
--- a/Lib/test/test_ctypes/test_c_simple_type_meta.py
+++ b/Lib/test/test_ctypes/test_c_simple_type_meta.py
@@ -1,15 +1,15 @@
 import unittest
+from test.support import MS_WINDOWS
 import ctypes
-from ctypes import POINTER, c_void_p
+from ctypes import POINTER, Structure, c_void_p
 
-from ._support import PyCSimpleType
+from ._support import PyCSimpleType, PyCPointerType, PyCStructType
 
 
-class PyCSimpleTypeAsMetaclassTest(unittest.TestCase):
-    def tearDown(self):
-        # to not leak references, we must clean _pointer_type_cache
-        ctypes._reset_cache()
+def set_non_ctypes_pointer_type(cls, pointer_type):
+    cls.__pointer_type__ = pointer_type
 
+class PyCSimpleTypeAsMetaclassTest(unittest.TestCase):
     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.
@@ -35,7 +35,7 @@ def __new__(cls, name, bases, namespace):
                 else:
                     ptr_bases = (self, POINTER(bases[0]))
                 p = p_meta(f"POINTER({self.__name__})", ptr_bases, {})
-                ctypes._pointer_type_cache[self] = p
+                set_non_ctypes_pointer_type(self, p)
                 return self
 
         class p_meta(PyCSimpleType, ct_meta):
@@ -44,19 +44,35 @@ class p_meta(PyCSimpleType, ct_meta):
         class PtrBase(c_void_p, metaclass=p_meta):
             pass
 
+        ptr_base_pointer = POINTER(PtrBase)
+
         class CtBase(object, metaclass=ct_meta):
             pass
 
+        ct_base_pointer = POINTER(CtBase)
+
         class Sub(CtBase):
             pass
 
+        sub_pointer = POINTER(Sub)
+
         class Sub2(Sub):
             pass
 
+        sub2_pointer = POINTER(Sub2)
+
+        self.assertIsNot(ptr_base_pointer, ct_base_pointer)
+        self.assertIsNot(ct_base_pointer, sub_pointer)
+        self.assertIsNot(sub_pointer, sub2_pointer)
+
         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)))
+        self.assertIsSubclass(POINTER(Sub2), Sub2)
+        self.assertIsSubclass(POINTER(Sub2), POINTER(Sub))
+        self.assertIsSubclass(POINTER(Sub), POINTER(CtBase))
+
+        self.assertIs(POINTER(Sub2), sub2_pointer)
+        self.assertIs(POINTER(Sub), sub_pointer)
+        self.assertIs(POINTER(CtBase), ct_base_pointer)
 
     def test_creating_pointer_in_dunder_new_2(self):
         # A simpler variant of the above, used in `CoClass` of the `comtypes`
@@ -68,7 +84,7 @@ def __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
+                set_non_ctypes_pointer_type(self, p)
                 return self
 
         class p_meta(PyCSimpleType, ct_meta):
@@ -77,14 +93,26 @@ class p_meta(PyCSimpleType, ct_meta):
         class Core(object):
             pass
 
+        with self.assertRaisesRegex(TypeError, "must have storage info"):
+            POINTER(Core)
+
         class CtBase(Core, metaclass=ct_meta):
             pass
 
+        ct_base_pointer = POINTER(CtBase)
+
         class Sub(CtBase):
             pass
 
+        sub_pointer = POINTER(Sub)
+
+        self.assertIsNot(ct_base_pointer, sub_pointer)
+
         self.assertIsInstance(POINTER(Sub), p_meta)
-        self.assertTrue(issubclass(POINTER(Sub), Sub))
+        self.assertIsSubclass(POINTER(Sub), Sub)
+
+        self.assertIs(POINTER(Sub), sub_pointer)
+        self.assertIs(POINTER(CtBase), ct_base_pointer)
 
     def test_creating_pointer_in_dunder_init_1(self):
         class ct_meta(type):
@@ -102,7 +130,7 @@ def __init__(self, name, bases, namespace):
                 else:
                     ptr_bases = (self, POINTER(bases[0]))
                 p = p_meta(f"POINTER({self.__name__})", ptr_bases, {})
-                ctypes._pointer_type_cache[self] = p
+                set_non_ctypes_pointer_type(self, p)
 
         class p_meta(PyCSimpleType, ct_meta):
             pass
@@ -110,19 +138,36 @@ class p_meta(PyCSimpleType, ct_meta):
         class PtrBase(c_void_p, metaclass=p_meta):
             pass
 
+        ptr_base_pointer = POINTER(PtrBase)
+
         class CtBase(object, metaclass=ct_meta):
             pass
 
+        ct_base_pointer = POINTER(CtBase)
+
         class Sub(CtBase):
             pass
 
+        sub_pointer = POINTER(Sub)
+
         class Sub2(Sub):
             pass
 
+        sub2_pointer = POINTER(Sub2)
+
+        self.assertIsNot(ptr_base_pointer, ct_base_pointer)
+        self.assertIsNot(ct_base_pointer, sub_pointer)
+        self.assertIsNot(sub_pointer, sub2_pointer)
+
         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)))
+        self.assertIsSubclass(POINTER(Sub2), Sub2)
+        self.assertIsSubclass(POINTER(Sub2), POINTER(Sub))
+        self.assertIsSubclass(POINTER(Sub), POINTER(CtBase))
+
+        self.assertIs(POINTER(PtrBase), ptr_base_pointer)
+        self.assertIs(POINTER(CtBase), ct_base_pointer)
+        self.assertIs(POINTER(Sub), sub_pointer)
+        self.assertIs(POINTER(Sub2), sub2_pointer)
 
     def test_creating_pointer_in_dunder_init_2(self):
         class ct_meta(type):
@@ -134,7 +179,7 @@ def __init__(self, name, bases, namespace):
                 if isinstance(self, p_meta):
                     return
                 p = p_meta(f"POINTER({self.__name__})", (self, c_void_p), {})
-                ctypes._pointer_type_cache[self] = p
+                set_non_ctypes_pointer_type(self, p)
 
         class p_meta(PyCSimpleType, ct_meta):
             pass
@@ -145,8 +190,195 @@ class Core(object):
         class CtBase(Core, metaclass=ct_meta):
             pass
 
+        ct_base_pointer = POINTER(CtBase)
+
         class Sub(CtBase):
             pass
 
+        sub_pointer = POINTER(Sub)
+
+        self.assertIsNot(ct_base_pointer, sub_pointer)
+
         self.assertIsInstance(POINTER(Sub), p_meta)
-        self.assertTrue(issubclass(POINTER(Sub), Sub))
+        self.assertIsSubclass(POINTER(Sub), Sub)
+
+        self.assertIs(POINTER(CtBase), ct_base_pointer)
+        self.assertIs(POINTER(Sub), sub_pointer)
+
+    def test_bad_type_message(self):
+        """Verify the error message that lists all available type codes"""
+        # (The string is generated at runtime, so this checks the underlying
+        # set of types as well as correct construction of the string.)
+        with self.assertRaises(AttributeError) as cm:
+            class F(metaclass=PyCSimpleType):
+                _type_ = "\0"
+        message = str(cm.exception)
+        expected_type_chars = list('cbBhHiIlLdDFGfuzZqQPXOv?g')
+        if not hasattr(ctypes, 'c_float_complex'):
+            expected_type_chars.remove('F')
+            expected_type_chars.remove('D')
+            expected_type_chars.remove('G')
+        if not MS_WINDOWS:
+            expected_type_chars.remove('X')
+        self.assertIn("'" + ''.join(expected_type_chars) + "'", message)
+
+    def test_creating_pointer_in_dunder_init_3(self):
+        """Check if interfcase subclasses properly creates according internal
+        pointer types. But not the same as external pointer types.
+        """
+
+        class StructureMeta(PyCStructType):
+            def __new__(cls, name, bases, dct, /, create_pointer_type=True):
+                assert len(bases) == 1, bases
+                return super().__new__(cls, name, bases, dct)
+
+            def __init__(self, name, bases, dct, /, create_pointer_type=True):
+
+                super().__init__(name, bases, dct)
+                if create_pointer_type:
+                    p_bases = (POINTER(bases[0]),)
+                    ns = {'_type_': self}
+                    internal_pointer_type = PointerMeta(f"p{name}", p_bases, ns)
+                    assert isinstance(internal_pointer_type, PyCPointerType)
+                    assert self.__pointer_type__ is internal_pointer_type
+
+        class PointerMeta(PyCPointerType):
+            def __new__(cls, name, bases, dct):
+                target = dct.get('_type_', None)
+                if target is None:
+
+                    # Create corresponding interface type and then set it as target
+                    target = StructureMeta(
+                        f"_{name}_",
+                        (bases[0]._type_,),
+                        {},
+                        create_pointer_type=False
+                    )
+                    dct['_type_'] = target
+
+                pointer_type = super().__new__(cls, name, bases, dct)
+                assert not hasattr(target, '__pointer_type__')
+
+                return pointer_type
+
+            def __init__(self, name, bases, dct, /, create_pointer_type=True):
+                target = dct.get('_type_', None)
+                assert not hasattr(target, '__pointer_type__')
+                super().__init__(name, bases, dct)
+                assert target.__pointer_type__ is self
+
+
+        class Interface(Structure, metaclass=StructureMeta, create_pointer_type=False):
+            pass
+
+        class pInterface(POINTER(c_void_p), metaclass=PointerMeta):
+            _type_ = Interface
+
+        class IUnknown(Interface):
+            pass
+
+        class pIUnknown(pInterface):
+            pass
+
+        self.assertTrue(issubclass(POINTER(IUnknown), pInterface))
+
+        self.assertIs(POINTER(Interface), pInterface)
+        self.assertIsNot(POINTER(IUnknown), pIUnknown)
+
+    def test_creating_pointer_in_dunder_init_4(self):
+        """Check if interfcase subclasses properly creates according internal
+        pointer types, the same as external pointer types.
+        """
+        class StructureMeta(PyCStructType):
+            def __new__(cls, name, bases, dct, /, create_pointer_type=True):
+                assert len(bases) == 1, bases
+
+                return super().__new__(cls, name, bases, dct)
+
+            def __init__(self, name, bases, dct, /, create_pointer_type=True):
+
+                super().__init__(name, bases, dct)
+                if create_pointer_type:
+                    p_bases = (POINTER(bases[0]),)
+                    ns = {'_type_': self}
+                    internal_pointer_type = PointerMeta(f"p{name}", p_bases, ns)
+                    assert isinstance(internal_pointer_type, PyCPointerType)
+                    assert self.__pointer_type__ is internal_pointer_type
+
+        class PointerMeta(PyCPointerType):
+            def __new__(cls, name, bases, dct):
+                target = dct.get('_type_', None)
+                assert target is not None
+                pointer_type = getattr(target, '__pointer_type__', None)
+
+                if pointer_type is None:
+                    pointer_type = super().__new__(cls, name, bases, dct)
+
+                return pointer_type
+
+            def __init__(self, name, bases, dct, /, create_pointer_type=True):
+                target = dct.get('_type_', None)
+                if not hasattr(target, '__pointer_type__'):
+                    # target.__pointer_type__ was created by super().__new__
+                    super().__init__(name, bases, dct)
+
+                assert target.__pointer_type__ is self
+
+
+        class Interface(Structure, metaclass=StructureMeta, create_pointer_type=False):
+            pass
+
+        class pInterface(POINTER(c_void_p), metaclass=PointerMeta):
+            _type_ = Interface
+
+        class IUnknown(Interface):
+            pass
+
+        class pIUnknown(pInterface):
+            _type_ = IUnknown
+
+        self.assertTrue(issubclass(POINTER(IUnknown), pInterface))
+
+        self.assertIs(POINTER(Interface), pInterface)
+        self.assertIs(POINTER(IUnknown), pIUnknown)
+
+    def test_custom_pointer_cache_for_ctypes_type1(self):
+        # Check if PyCPointerType.__init__() caches a pointer type
+        # customized in the metatype's __new__().
+        class PointerMeta(PyCPointerType):
+            def __new__(cls, name, bases, namespace):
+                namespace["_type_"] = C
+                return super().__new__(cls, name, bases, namespace)
+
+            def __init__(self, name, bases, namespace):
+                assert not hasattr(C, '__pointer_type__')
+                super().__init__(name, bases, namespace)
+                assert C.__pointer_type__ is self
+
+        class C(c_void_p):  # ctypes type
+            pass
+
+        class P(ctypes._Pointer, metaclass=PointerMeta):
+            pass
+
+        self.assertIs(P._type_, C)
+        self.assertIs(P, POINTER(C))
+
+    def test_custom_pointer_cache_for_ctypes_type2(self):
+        # Check if PyCPointerType.__init__() caches a pointer type
+        # customized in the metatype's __init__().
+        class PointerMeta(PyCPointerType):
+            def __init__(self, name, bases, namespace):
+                self._type_ = namespace["_type_"] = C
+                assert not hasattr(C, '__pointer_type__')
+                super().__init__(name, bases, namespace)
+                assert C.__pointer_type__ is self
+
+        class C(c_void_p):  # ctypes type
+            pass
+
+        class P(ctypes._Pointer, metaclass=PointerMeta):
+            pass
+
+        self.assertIs(P._type_, C)
+        self.assertIs(P, POINTER(C))
diff --git a/Lib/test/test_ctypes/test_callbacks.py b/Lib/test/test_ctypes/test_callbacks.py
index 8f483dfe1db..6c7c2e52707 100644
--- a/Lib/test/test_ctypes/test_callbacks.py
+++ b/Lib/test/test_ctypes/test_callbacks.py
@@ -324,7 +324,7 @@ def func():
 
             self.assertIsInstance(cm.unraisable.exc_value, TypeError)
             self.assertEqual(cm.unraisable.err_msg,
-                             f"Exception ignored on converting result "
+                             f"Exception ignored while converting result "
                              f"of ctypes callback function {func!r}")
             self.assertIsNone(cm.unraisable.object)
 
diff --git a/Lib/test/test_ctypes/test_cast.py b/Lib/test/test_ctypes/test_cast.py
index db6bdc75eff..604f44f03d6 100644
--- a/Lib/test/test_ctypes/test_cast.py
+++ b/Lib/test/test_ctypes/test_cast.py
@@ -32,8 +32,6 @@ 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_cfuncs.py b/Lib/test/test_ctypes/test_cfuncs.py
index 48330c4b0a7..937be8eaa95 100644
--- a/Lib/test/test_ctypes/test_cfuncs.py
+++ b/Lib/test/test_ctypes/test_cfuncs.py
@@ -5,7 +5,8 @@
                     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
+from test import support
+from test.support import import_helper, threading_helper
 _ctypes_test = import_helper.import_module("_ctypes_test")
 
 
@@ -13,9 +14,10 @@ class CFunctions(unittest.TestCase):
     _dll = CDLL(_ctypes_test.__file__)
 
     def S(self):
-        return c_longlong.in_dll(self._dll, "last_tf_arg_s").value
+        return _ctypes_test.get_last_tf_arg_s()
+
     def U(self):
-        return c_ulonglong.in_dll(self._dll, "last_tf_arg_u").value
+        return _ctypes_test.get_last_tf_arg_u()
 
     def test_byte(self):
         self._dll.tf_b.restype = c_byte
@@ -191,6 +193,23 @@ def test_void(self):
         self.assertEqual(self._dll.tv_i(-42), None)
         self.assertEqual(self.S(), -42)
 
+    @threading_helper.requires_working_threading()
+    @support.requires_resource("cpu")
+    @unittest.skipUnless(support.Py_GIL_DISABLED, "only meaningful on free-threading")
+    def test_thread_safety(self):
+        from threading import Thread
+
+        def concurrent():
+            for _ in range(100):
+                self._dll.tf_b.restype = c_byte
+                self._dll.tf_b.argtypes = (c_byte,)
+
+        with threading_helper.catch_threading_exception() as exc:
+            with threading_helper.start_threads((Thread(target=concurrent) for _ in range(10))):
+                pass
+
+            self.assertIsNone(exc.exc_value)
+
 
 # The following repeats the above tests with stdcall functions (where
 # they are available)
diff --git a/Lib/test/test_ctypes/test_dlerror.py b/Lib/test/test_ctypes/test_dlerror.py
index cd87bad3825..ea2d97d9000 100644
--- a/Lib/test/test_ctypes/test_dlerror.py
+++ b/Lib/test/test_ctypes/test_dlerror.py
@@ -32,6 +32,7 @@
 
 @unittest.skipUnless(sys.platform.startswith('linux'),
                      'test requires GNU IFUNC support')
+@unittest.skipIf(test.support.linked_to_musl(), "Requires glibc")
 class TestNullDlsym(unittest.TestCase):
     """GH-126554: Ensure that we catch NULL dlsym return values
 
@@ -54,7 +55,8 @@ class TestNullDlsym(unittest.TestCase):
     this 'dlsym returned NULL -> throw Error' rule.
     """
 
-    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     def test_null_dlsym(self):
         import subprocess
         import tempfile
@@ -121,7 +123,7 @@ def test_null_dlsym(self):
             # Assert that the IFUNC was called
             self.assertEqual(os.read(pipe_r, 2), b'OK')
 
-
+@test.support.thread_unsafe('setlocale is not thread-safe')
 @unittest.skipUnless(os.name != 'nt', 'test requires dlerror() calls')
 class TestLocalization(unittest.TestCase):
 
diff --git a/Lib/test/test_ctypes/test_dllist.py b/Lib/test/test_ctypes/test_dllist.py
new file mode 100644
index 00000000000..0e7c65127f6
--- /dev/null
+++ b/Lib/test/test_ctypes/test_dllist.py
@@ -0,0 +1,63 @@
+import os
+import sys
+import unittest
+from ctypes import CDLL
+import ctypes.util
+from test.support import import_helper
+
+
+WINDOWS = os.name == "nt"
+APPLE = sys.platform in {"darwin", "ios", "tvos", "watchos"}
+
+if WINDOWS:
+    KNOWN_LIBRARIES = ["KERNEL32.DLL"]
+elif APPLE:
+    KNOWN_LIBRARIES = ["libSystem.B.dylib"]
+else:
+    # trickier than it seems, because libc may not be present
+    # on musl systems, and sometimes goes by different names.
+    # However, ctypes itself loads libffi
+    KNOWN_LIBRARIES = ["libc.so", "libffi.so"]
+
+
+@unittest.skipUnless(
+    hasattr(ctypes.util, "dllist"),
+    "ctypes.util.dllist is not available on this platform",
+)
+class ListSharedLibraries(unittest.TestCase):
+
+    # TODO: RUSTPYTHON
+    @unittest.skipIf(not APPLE, "TODO: RUSTPYTHON")
+    def test_lists_system(self):
+        dlls = ctypes.util.dllist()
+
+        self.assertGreater(len(dlls), 0, f"loaded={dlls}")
+        self.assertTrue(
+            any(lib in dll for dll in dlls for lib in KNOWN_LIBRARIES), f"loaded={dlls}"
+        )
+
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_lists_updates(self):
+        dlls = ctypes.util.dllist()
+
+        # this test relies on being able to import a library which is
+        # not already loaded.
+        # If it is (e.g. by a previous test in the same process), we skip
+        if any("_ctypes_test" in dll for dll in dlls):
+            self.skipTest("Test library is already loaded")
+
+        _ctypes_test = import_helper.import_module("_ctypes_test")
+        test_module = CDLL(_ctypes_test.__file__)
+        dlls2 = ctypes.util.dllist()
+        self.assertIsNotNone(dlls2)
+
+        dlls1 = set(dlls)
+        dlls2 = set(dlls2)
+
+        self.assertGreater(dlls2, dlls1, f"newly loaded libraries: {dlls2 - dlls1}")
+        self.assertTrue(any("_ctypes_test" in dll for dll in dlls2), f"loaded={dlls2}")
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/Lib/test/test_ctypes/test_find.py b/Lib/test/test_ctypes/test_find.py
index 85b28617d2d..8bc84c3d2ef 100644
--- a/Lib/test/test_ctypes/test_find.py
+++ b/Lib/test/test_ctypes/test_find.py
@@ -5,7 +5,7 @@
 import unittest.mock
 from ctypes import CDLL, RTLD_GLOBAL
 from ctypes.util import find_library
-from test.support import os_helper
+from test.support import os_helper, thread_unsafe
 
 
 # On some systems, loading the OpenGL libraries needs the RTLD_GLOBAL mode.
@@ -78,6 +78,7 @@ def test_shell_injection(self):
 @unittest.skipUnless(sys.platform.startswith('linux'),
                      'Test only valid for Linux')
 class FindLibraryLinux(unittest.TestCase):
+    @thread_unsafe('uses setenv')
     def test_find_on_libpath(self):
         import subprocess
         import tempfile
@@ -152,5 +153,73 @@ def test_find(self):
                 self.assertIsNone(find_library(name))
 
 
+@unittest.skipUnless(test.support.is_emscripten,
+                     'Test only valid for Emscripten')
+class FindLibraryEmscripten(unittest.TestCase):
+    @classmethod
+    def setUpClass(cls):
+        import tempfile
+
+        # A very simple wasm module
+        # In WAT format: (module)
+        cls.wasm_module = b'\x00asm\x01\x00\x00\x00\x00\x08\x04name\x02\x01\x00'
+
+        cls.non_wasm_content = b'This is not a WASM file'
+
+        cls.temp_dir = tempfile.mkdtemp()
+        cls.libdummy_so_path = os.path.join(cls.temp_dir, 'libdummy.so')
+        with open(cls.libdummy_so_path, 'wb') as f:
+            f.write(cls.wasm_module)
+
+        cls.libother_wasm_path = os.path.join(cls.temp_dir, 'libother.wasm')
+        with open(cls.libother_wasm_path, 'wb') as f:
+            f.write(cls.wasm_module)
+
+        cls.libnowasm_so_path = os.path.join(cls.temp_dir, 'libnowasm.so')
+        with open(cls.libnowasm_so_path, 'wb') as f:
+            f.write(cls.non_wasm_content)
+
+    @classmethod
+    def tearDownClass(cls):
+        import shutil
+        shutil.rmtree(cls.temp_dir)
+
+    def test_find_wasm_file_with_so_extension(self):
+        with os_helper.EnvironmentVarGuard() as env:
+            env.set('LD_LIBRARY_PATH', self.temp_dir)
+            result = find_library('dummy')
+            self.assertEqual(result, self.libdummy_so_path)
+    def test_find_wasm_file_with_wasm_extension(self):
+        with os_helper.EnvironmentVarGuard() as env:
+            env.set('LD_LIBRARY_PATH', self.temp_dir)
+            result = find_library('other')
+            self.assertEqual(result, self.libother_wasm_path)
+
+    def test_ignore_non_wasm_file(self):
+        with os_helper.EnvironmentVarGuard() as env:
+            env.set('LD_LIBRARY_PATH', self.temp_dir)
+            result = find_library('nowasm')
+            self.assertIsNone(result)
+
+    def test_find_nothing_without_ld_library_path(self):
+        with os_helper.EnvironmentVarGuard() as env:
+            if 'LD_LIBRARY_PATH' in env:
+                del env['LD_LIBRARY_PATH']
+            result = find_library('dummy')
+            self.assertIsNone(result)
+            result = find_library('other')
+            self.assertIsNone(result)
+
+    def test_find_nothing_with_wrong_ld_library_path(self):
+        import tempfile
+        with tempfile.TemporaryDirectory() as empty_dir:
+            with os_helper.EnvironmentVarGuard() as env:
+                env.set('LD_LIBRARY_PATH', empty_dir)
+                result = find_library('dummy')
+                self.assertIsNone(result)
+                result = find_library('other')
+                self.assertIsNone(result)
+
+
 if __name__ == "__main__":
     unittest.main()
diff --git a/Lib/test/test_ctypes/test_funcptr.py b/Lib/test/test_ctypes/test_funcptr.py
index 8362fb16d94..be641da30ea 100644
--- a/Lib/test/test_ctypes/test_funcptr.py
+++ b/Lib/test/test_ctypes/test_funcptr.py
@@ -5,7 +5,7 @@
 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)
+                       Py_TPFLAGS_IMMUTABLETYPE, StructCheckMixin)
 
 
 try:
@@ -17,7 +17,7 @@
 lib = CDLL(_ctypes_test.__file__)
 
 
-class CFuncPtrTestCase(unittest.TestCase):
+class CFuncPtrTestCase(unittest.TestCase, StructCheckMixin):
     def test_inheritance_hierarchy(self):
         self.assertEqual(_CFuncPtr.mro(), [_CFuncPtr, _CData, object])
 
@@ -88,6 +88,7 @@ class WNDCLASS(Structure):
                         ("hCursor", HCURSOR),
                         ("lpszMenuName", LPCTSTR),
                         ("lpszClassName", LPCTSTR)]
+        self.check_struct(WNDCLASS)
 
         wndclass = WNDCLASS()
         wndclass.lpfnWndProc = WNDPROC(wndproc)
diff --git a/Lib/test/test_ctypes/test_functions.py b/Lib/test/test_ctypes/test_functions.py
index 63e393f7b7c..3454b83d43e 100644
--- a/Lib/test/test_ctypes/test_functions.py
+++ b/Lib/test/test_ctypes/test_functions.py
@@ -2,7 +2,7 @@
 import sys
 import unittest
 from ctypes import (CDLL, Structure, Array, CFUNCTYPE,
-                    byref, POINTER, pointer, ArgumentError,
+                    byref, POINTER, pointer, ArgumentError, sizeof,
                     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)
@@ -72,7 +72,8 @@ def callback(*args):
 
         self.assertEqual(str(cm.exception),
                          "argument 1: TypeError: one character bytes, "
-                         "bytearray or integer expected")
+                         "bytearray, or an integer in range(256) expected, "
+                         "not bytes of length 3")
 
     def test_wchar_parm(self):
         f = dll._testfunc_i_bhilfd
@@ -84,14 +85,27 @@ def test_wchar_parm(self):
         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")
+                         "argument 2: TypeError: a unicode character expected, "
+                         "not instance of int")
 
         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")
+                         "argument 2: TypeError: a unicode character expected, "
+                         "not a string of length 3")
+
+        with self.assertRaises(ArgumentError) as cm:
+            f(1, "", 3, 4, 5.0, 6.0)
+        self.assertEqual(str(cm.exception),
+                         "argument 2: TypeError: a unicode character expected, "
+                         "not a string of length 0")
+
+        if sizeof(c_wchar) < 4:
+            with self.assertRaises(ArgumentError) as cm:
+                f(1, "\U0001f40d", 3, 4, 5.0, 6.0)
+            self.assertEqual(str(cm.exception),
+                             "argument 2: TypeError: the string '\\U0001f40d' "
+                             "cannot be converted to a single wchar_t character")
 
     def test_c_char_p_parm(self):
         """Test the error message when converting an incompatible type to c_char_p."""
diff --git a/Lib/test/test_ctypes/test_generated_structs.py b/Lib/test/test_ctypes/test_generated_structs.py
new file mode 100644
index 00000000000..aa448fad5bb
--- /dev/null
+++ b/Lib/test/test_ctypes/test_generated_structs.py
@@ -0,0 +1,761 @@
+"""Test CTypes structs, unions, bitfields against C equivalents.
+
+The types here are auto-converted to C source at
+`Modules/_ctypes/_ctypes_test_generated.c.h`, which is compiled into
+_ctypes_test.
+
+Run this module to regenerate the files:
+
+./python Lib/test/test_ctypes/test_generated_structs.py > Modules/_ctypes/_ctypes_test_generated.c.h
+"""
+
+import unittest
+from test.support import import_helper, verbose
+import re
+from dataclasses import dataclass
+from functools import cached_property
+import sys
+
+import ctypes
+from ctypes import Structure, Union
+from ctypes import sizeof, alignment, pointer, string_at
+_ctypes_test = import_helper.import_module("_ctypes_test")
+
+from test.test_ctypes._support import StructCheckMixin
+
+# A 64-bit number where each nibble (hex digit) is different and
+# has 2-3 bits set.
+TEST_PATTERN = 0xae7596db
+
+# ctypes erases the difference between `c_int` and e.g.`c_int16`.
+# To keep it, we'll use custom subclasses with the C name stashed in `_c_name`:
+class c_bool(ctypes.c_bool):
+    _c_name = '_Bool'
+
+# To do it for all the other types, use some metaprogramming:
+for c_name, ctypes_name in {
+    'signed char': 'c_byte',
+    'short': 'c_short',
+    'int': 'c_int',
+    'long': 'c_long',
+    'long long': 'c_longlong',
+    'unsigned char': 'c_ubyte',
+    'unsigned short': 'c_ushort',
+    'unsigned int': 'c_uint',
+    'unsigned long': 'c_ulong',
+    'unsigned long long': 'c_ulonglong',
+    **{f'{u}int{n}_t': f'c_{u}int{n}'
+       for u in ('', 'u')
+       for n in (8, 16, 32, 64)}
+}.items():
+    ctype = getattr(ctypes, ctypes_name)
+    newtype = type(ctypes_name, (ctype,), {'_c_name': c_name})
+    globals()[ctypes_name] = newtype
+
+
+# Register structs and unions to test
+
+TESTCASES = {}
+def register(name=None, set_name=False):
+    def decorator(cls, name=name):
+        if name is None:
+            name = cls.__name__
+        assert name.isascii()  # will be used in _PyUnicode_EqualToASCIIString
+        assert name.isidentifier()  # will be used as a C identifier
+        assert name not in TESTCASES
+        TESTCASES[name] = cls
+        if set_name:
+            cls.__name__ = name
+        return cls
+    return decorator
+
+@register()
+class SingleInt(Structure):
+    _fields_ = [('a', c_int)]
+
+@register()
+class SingleInt_Union(Union):
+    _fields_ = [('a', c_int)]
+
+
+@register()
+class SingleU32(Structure):
+    _fields_ = [('a', c_uint32)]
+
+
+@register()
+class SimpleStruct(Structure):
+    _fields_ = [('x', c_int32), ('y', c_int8), ('z', c_uint16)]
+
+
+@register()
+class SimpleUnion(Union):
+    _fields_ = [('x', c_int32), ('y', c_int8), ('z', c_uint16)]
+
+
+@register()
+class ManyTypes(Structure):
+    _fields_ = [
+        ('i8', c_int8), ('u8', c_uint8),
+        ('i16', c_int16), ('u16', c_uint16),
+        ('i32', c_int32), ('u32', c_uint32),
+        ('i64', c_int64), ('u64', c_uint64),
+    ]
+
+
+@register()
+class ManyTypesU(Union):
+    _fields_ = [
+        ('i8', c_int8), ('u8', c_uint8),
+        ('i16', c_int16), ('u16', c_uint16),
+        ('i32', c_int32), ('u32', c_uint32),
+        ('i64', c_int64), ('u64', c_uint64),
+    ]
+
+
+@register()
+class Nested(Structure):
+    _fields_ = [
+        ('a', SimpleStruct), ('b', SimpleUnion), ('anon', SimpleStruct),
+    ]
+    _anonymous_ = ['anon']
+
+
+@register()
+class Packed1(Structure):
+    _fields_ = [('a', c_int8), ('b', c_int64)]
+    _pack_ = 1
+    _layout_ = 'ms'
+
+
+@register()
+class Packed2(Structure):
+    _fields_ = [('a', c_int8), ('b', c_int64)]
+    _pack_ = 2
+    _layout_ = 'ms'
+
+
+@register()
+class Packed3(Structure):
+    _fields_ = [('a', c_int8), ('b', c_int64)]
+    _pack_ = 4
+    _layout_ = 'ms'
+
+
+@register()
+class Packed4(Structure):
+    def _maybe_skip():
+        # `_pack_` enables MSVC-style packing, but keeps platform-specific
+        # alignments.
+        # The C code we generate for GCC/clang currently uses
+        # `__attribute__((ms_struct))`, which activates MSVC layout *and*
+        # alignments, that is, sizeof(basic type) == alignment(basic type).
+        # On a Pentium, int64 is 32-bit aligned, so the two won't match.
+        # The expected behavior is instead tested in
+        # StructureTestCase.test_packed, over in test_structures.py.
+        if sizeof(c_int64) != alignment(c_int64):
+            raise unittest.SkipTest('cannot test on this platform')
+
+    _fields_ = [('a', c_int8), ('b', c_int64)]
+    _pack_ = 8
+    _layout_ = 'ms'
+
+@register()
+class X86_32EdgeCase(Structure):
+    # On a Pentium, long long (int64) is 32-bit aligned,
+    # so these are packed tightly.
+    _fields_ = [('a', c_int32), ('b', c_int64), ('c', c_int32)]
+
+@register()
+class MSBitFieldExample(Structure):
+    # From https://learn.microsoft.com/en-us/cpp/c-language/c-bit-fields
+    _fields_ = [
+        ('a', c_uint, 4),
+        ('b', c_uint, 5),
+        ('c', c_uint, 7)]
+
+@register()
+class MSStraddlingExample(Structure):
+    # From https://learn.microsoft.com/en-us/cpp/c-language/c-bit-fields
+    _fields_ = [
+        ('first', c_uint, 9),
+        ('second', c_uint, 7),
+        ('may_straddle', c_uint, 30),
+        ('last', c_uint, 18)]
+
+@register()
+class IntBits(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)]
+
+@register()
+class Bits(Structure):
+    _fields_ = [*IntBits._fields_,
+
+                ("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)]
+
+@register()
+class IntBits_MSVC(Structure):
+    _layout_ = "ms"
+    _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)]
+
+@register()
+class Bits_MSVC(Structure):
+    _layout_ = "ms"
+    _fields_ = [*IntBits_MSVC._fields_,
+
+                ("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)]
+
+# Skipped for now -- we don't always match the alignment
+#@register()
+class IntBits_Union(Union):
+    _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)]
+
+# Skipped for now -- we don't always match the alignment
+#@register()
+class BitsUnion(Union):
+    _fields_ = [*IntBits_Union._fields_,
+
+                ("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)]
+
+@register()
+class I64Bits(Structure):
+    _fields_ = [("a", c_int64, 1),
+                ("b", c_int64, 62),
+                ("c", c_int64, 1)]
+
+@register()
+class U64Bits(Structure):
+    _fields_ = [("a", c_uint64, 1),
+                ("b", c_uint64, 62),
+                ("c", c_uint64, 1)]
+
+for n in 8, 16, 32, 64:
+    for signedness in '', 'u':
+        ctype = globals()[f'c_{signedness}int{n}']
+
+        @register(f'Struct331_{signedness}{n}', set_name=True)
+        class _cls(Structure):
+            _fields_ = [("a", ctype, 3),
+                        ("b", ctype, 3),
+                        ("c", ctype, 1)]
+
+        @register(f'Struct1x1_{signedness}{n}', set_name=True)
+        class _cls(Structure):
+            _fields_ = [("a", ctype, 1),
+                        ("b", ctype, n-2),
+                        ("c", ctype, 1)]
+
+        @register(f'Struct1nx1_{signedness}{n}', set_name=True)
+        class _cls(Structure):
+            _fields_ = [("a", ctype, 1),
+                        ("full", ctype),
+                        ("b", ctype, n-2),
+                        ("c", ctype, 1)]
+
+        @register(f'Struct3xx_{signedness}{n}', set_name=True)
+        class _cls(Structure):
+            _fields_ = [("a", ctype, 3),
+                        ("b", ctype, n-2),
+                        ("c", ctype, n-2)]
+
+@register()
+class Mixed1(Structure):
+    _fields_ = [("a", c_byte, 4),
+                ("b", c_int, 4)]
+
+@register()
+class Mixed2(Structure):
+    _fields_ = [("a", c_byte, 4),
+                ("b", c_int32, 32)]
+
+@register()
+class Mixed3(Structure):
+    _fields_ = [("a", c_byte, 4),
+                ("b", c_ubyte, 4)]
+
+@register()
+class Mixed4(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)]
+
+@register()
+class Mixed5(Structure):
+    _fields_ = [('A', c_uint, 1),
+                ('B', c_ushort, 16)]
+
+@register()
+class Mixed6(Structure):
+    _fields_ = [('A', c_ulonglong, 1),
+                ('B', c_uint, 32)]
+
+@register()
+class Mixed7(Structure):
+    _fields_ = [("A", c_uint32),
+                ('B', c_uint32, 20),
+                ('C', c_uint64, 24)]
+
+@register()
+class Mixed8_a(Structure):
+    _fields_ = [("A", c_uint32),
+                ("B", c_uint32, 32),
+                ("C", c_ulonglong, 1)]
+
+@register()
+class Mixed8_b(Structure):
+    _fields_ = [("A", c_uint32),
+                ("B", c_uint32),
+                ("C", c_ulonglong, 1)]
+
+@register()
+class Mixed9(Structure):
+    _fields_ = [("A", c_uint8),
+                ("B", c_uint32, 1)]
+
+@register()
+class Mixed10(Structure):
+    _fields_ = [("A", c_uint32, 1),
+                ("B", c_uint64, 1)]
+
+@register()
+class Example_gh_95496(Structure):
+    _fields_ = [("A", c_uint32, 1),
+                ("B", c_uint64, 1)]
+
+@register()
+class Example_gh_84039_bad(Structure):
+    _pack_ = 1
+    _layout_ = 'ms'
+    _fields_ = [("a0", c_uint8, 1),
+                ("a1", c_uint8, 1),
+                ("a2", c_uint8, 1),
+                ("a3", c_uint8, 1),
+                ("a4", c_uint8, 1),
+                ("a5", c_uint8, 1),
+                ("a6", c_uint8, 1),
+                ("a7", c_uint8, 1),
+                ("b0", c_uint16, 4),
+                ("b1", c_uint16, 12)]
+
+@register()
+class Example_gh_84039_good_a(Structure):
+    _pack_ = 1
+    _layout_ = 'ms'
+    _fields_ = [("a0", c_uint8, 1),
+                ("a1", c_uint8, 1),
+                ("a2", c_uint8, 1),
+                ("a3", c_uint8, 1),
+                ("a4", c_uint8, 1),
+                ("a5", c_uint8, 1),
+                ("a6", c_uint8, 1),
+                ("a7", c_uint8, 1)]
+
+@register()
+class Example_gh_84039_good(Structure):
+    _pack_ = 1
+    _layout_ = 'ms'
+    _fields_ = [("a", Example_gh_84039_good_a),
+                ("b0", c_uint16, 4),
+                ("b1", c_uint16, 12)]
+
+@register()
+class Example_gh_73939(Structure):
+    _pack_ = 1
+    _layout_ = 'ms'
+    _fields_ = [("P", c_uint16),
+                ("L", c_uint16, 9),
+                ("Pro", c_uint16, 1),
+                ("G", c_uint16, 1),
+                ("IB", c_uint16, 1),
+                ("IR", c_uint16, 1),
+                ("R", c_uint16, 3),
+                ("T", c_uint32, 10),
+                ("C", c_uint32, 20),
+                ("R2", c_uint32, 2)]
+
+@register()
+class Example_gh_86098(Structure):
+    _fields_ = [("a", c_uint8, 8),
+                ("b", c_uint8, 8),
+                ("c", c_uint32, 16)]
+
+@register()
+class Example_gh_86098_pack(Structure):
+    _pack_ = 1
+    _layout_ = 'ms'
+    _fields_ = [("a", c_uint8, 8),
+                ("b", c_uint8, 8),
+                ("c", c_uint32, 16)]
+
+@register()
+class AnonBitfields(Structure):
+    class X(Structure):
+        _fields_ = [("a", c_byte, 4),
+                    ("b", c_ubyte, 4)]
+    _anonymous_ = ["_"]
+    _fields_ = [("_", X), ('y', c_byte)]
+
+
+class GeneratedTest(unittest.TestCase, StructCheckMixin):
+    def test_generated_data(self):
+        """Check that a ctypes struct/union matches its C equivalent.
+
+        This compares with data from get_generated_test_data(), a list of:
+        - name (str)
+        - size (int)
+        - alignment (int)
+        - for each field, three snapshots of memory, as bytes:
+            - memory after the field is set to -1
+            - memory after the field is set to 1
+            - memory after the field is set to 0
+
+        or:
+        - None
+        - reason to skip the test (str)
+
+        This does depend on the C compiler keeping padding bits unchanged.
+        Common compilers seem to do so.
+        """
+        for name, cls in TESTCASES.items():
+            with self.subTest(name=name):
+                self.check_struct_or_union(cls)
+                if _maybe_skip := getattr(cls, '_maybe_skip', None):
+                    _maybe_skip()
+                expected = iter(_ctypes_test.get_generated_test_data(name))
+                expected_name = next(expected)
+                if expected_name is None:
+                    self.skipTest(next(expected))
+                self.assertEqual(name, expected_name)
+                self.assertEqual(sizeof(cls), next(expected))
+                with self.subTest('alignment'):
+                    self.assertEqual(alignment(cls), next(expected))
+                obj = cls()
+                ptr = pointer(obj)
+                for field in iterfields(cls):
+                    for value in -1, 1, TEST_PATTERN, 0:
+                        with self.subTest(field=field.full_name, value=value):
+                            field.set_to(obj, value)
+                            py_mem = string_at(ptr, sizeof(obj))
+                            c_mem = next(expected)
+                            if py_mem != c_mem:
+                                # Generate a helpful failure message
+                                lines, requires = dump_ctype(cls)
+                                m = "\n".join([str(field), 'in:', *lines])
+                                self.assertEqual(py_mem.hex(), c_mem.hex(), m)
+
+                            descriptor = field.descriptor
+                            field_mem = py_mem[
+                                field.byte_offset
+                                : field.byte_offset + descriptor.byte_size]
+                            field_int = int.from_bytes(field_mem, sys.byteorder)
+                            mask = (1 << descriptor.bit_size) - 1
+                            self.assertEqual(
+                                (field_int >> descriptor.bit_offset) & mask,
+                                value & mask)
+
+
+
+# The rest of this file is generating C code from a ctypes type.
+# This is only meant for (and tested with) the known inputs in this file!
+
+def c_str_repr(string):
+    """Return a string as a C literal"""
+    return '"' + re.sub('([\"\'\\\\\n])', r'\\\1', string) + '"'
+
+def dump_simple_ctype(tp, variable_name='', semi=''):
+    """Get C type name or declaration of a scalar type
+
+    variable_name: if given, declare the given variable
+    semi: a semicolon, and/or bitfield specification to tack on to the end
+    """
+    length = getattr(tp, '_length_', None)
+    if length is not None:
+        return f'{dump_simple_ctype(tp._type_, variable_name)}[{length}]{semi}'
+    assert not issubclass(tp, (Structure, Union))
+    return f'{tp._c_name}{maybe_space(variable_name)}{semi}'
+
+
+def dump_ctype(tp, struct_or_union_tag='', variable_name='', semi=''):
+    """Get C type name or declaration of a ctype
+
+    struct_or_union_tag: name of the struct or union
+    variable_name: if given, declare the given variable
+    semi: a semicolon, and/or bitfield specification to tack on to the end
+    """
+    requires = set()
+    if issubclass(tp, (Structure, Union)):
+        attributes = []
+        pushes = []
+        pops = []
+        pack = getattr(tp, '_pack_', None)
+        if pack is not None:
+            pushes.append(f'#pragma pack(push, {pack})')
+            pops.append(f'#pragma pack(pop)')
+        layout = getattr(tp, '_layout_', None)
+        if layout == 'ms':
+            # The 'ms_struct' attribute only works on x86 and PowerPC
+            requires.add(
+                'defined(MS_WIN32) || ('
+                    '(defined(__x86_64__) || defined(__i386__) || defined(__ppc64__)) && ('
+                    'defined(__GNUC__) || defined(__clang__)))'
+                )
+            attributes.append('ms_struct')
+        if attributes:
+            a = f' GCC_ATTR({", ".join(attributes)})'
+        else:
+            a = ''
+        lines = [f'{struct_or_union(tp)}{a}{maybe_space(struct_or_union_tag)} ' +'{']
+        for fielddesc in tp._fields_:
+            f_name, f_tp, f_bits = unpack_field_desc(*fielddesc)
+            if f_name in getattr(tp, '_anonymous_', ()):
+                f_name = ''
+            if f_bits is None:
+                subsemi = ';'
+            else:
+                if f_tp not in (c_int, c_uint):
+                    # XLC can reportedly only handle int & unsigned int
+                    # bitfields (the only types required by C spec)
+                    requires.add('!defined(__xlc__)')
+                subsemi = f' :{f_bits};'
+            sub_lines, sub_requires = dump_ctype(
+                f_tp, variable_name=f_name, semi=subsemi)
+            requires.update(sub_requires)
+            for line in sub_lines:
+                lines.append('    ' + line)
+        lines.append(f'}}{maybe_space(variable_name)}{semi}')
+        return [*pushes, *lines, *reversed(pops)], requires
+    else:
+        return [dump_simple_ctype(tp, variable_name, semi)], requires
+
+def struct_or_union(cls):
+    if issubclass(cls, Structure):
+         return 'struct'
+    if issubclass(cls, Union):
+        return 'union'
+    raise TypeError(cls)
+
+def maybe_space(string):
+    if string:
+        return ' ' + string
+    return string
+
+def unpack_field_desc(f_name, f_tp, f_bits=None):
+    """Unpack a _fields_ entry into a (name, type, bits) triple"""
+    return f_name, f_tp, f_bits
+
+@dataclass
+class FieldInfo:
+    """Information about a (possibly nested) struct/union field"""
+    name: str
+    tp: type
+    bits: int | None  # number if this is a bit field
+    parent_type: type
+    parent: 'FieldInfo' #| None
+    descriptor: object
+    byte_offset: int
+
+    @cached_property
+    def attr_path(self):
+        """Attribute names to get at the value of this field"""
+        if self.name in getattr(self.parent_type, '_anonymous_', ()):
+            selfpath = ()
+        else:
+            selfpath = (self.name,)
+        if self.parent:
+            return (*self.parent.attr_path, *selfpath)
+        else:
+            return selfpath
+
+    @cached_property
+    def full_name(self):
+        """Attribute names to get at the value of this field"""
+        return '.'.join(self.attr_path)
+
+    def set_to(self, obj, new):
+        """Set the field on a given Structure/Union instance"""
+        for attr_name in self.attr_path[:-1]:
+            obj = getattr(obj, attr_name)
+        setattr(obj, self.attr_path[-1], new)
+
+    @cached_property
+    def root(self):
+        if self.parent is None:
+            return self
+        else:
+            return self.parent
+
+    def __repr__(self):
+        qname = f'{self.root.parent_type.__name__}.{self.full_name}'
+        try:
+            desc = self.descriptor
+        except AttributeError:
+            desc = '???'
+        return f'<{type(self).__name__} for {qname}: {desc}>'
+
+def iterfields(tp, parent=None):
+    """Get *leaf* fields of a structure or union, as FieldInfo"""
+    try:
+        fields = tp._fields_
+    except AttributeError:
+        yield parent
+    else:
+        for fielddesc in fields:
+            f_name, f_tp, f_bits = unpack_field_desc(*fielddesc)
+            descriptor = getattr(tp, f_name)
+            byte_offset = descriptor.byte_offset
+            if parent:
+                byte_offset += parent.byte_offset
+            sub = FieldInfo(f_name, f_tp, f_bits, tp, parent, descriptor, byte_offset)
+            yield from iterfields(f_tp, sub)
+
+
+if __name__ == '__main__':
+    # Dump C source to stdout
+    def output(string):
+        print(re.compile(r'^ +$', re.MULTILINE).sub('', string).lstrip('\n'))
+    output("/* Generated by Lib/test/test_ctypes/test_generated_structs.py */")
+    output(f"#define TEST_PATTERN {TEST_PATTERN}")
+    output("""
+        // Append VALUE to the result.
+        #define APPEND(ITEM) {                          \\
+            PyObject *item = ITEM;                      \\
+            if (!item) {                                \\
+                Py_DECREF(result);                      \\
+                return NULL;                            \\
+            }                                           \\
+            int rv = PyList_Append(result, item);       \\
+            Py_DECREF(item);                            \\
+            if (rv < 0) {                               \\
+                Py_DECREF(result);                      \\
+                return NULL;                            \\
+            }                                           \\
+        }
+
+        // Set TARGET, and append a snapshot of `value`'s
+        // memory to the result.
+        #define SET_AND_APPEND(TYPE, TARGET, VAL) {     \\
+            TYPE v = VAL;                               \\
+            TARGET = v;                                 \\
+            APPEND(PyBytes_FromStringAndSize(           \\
+                (char*)&value, sizeof(value)));         \\
+        }
+
+        // Set a field to test values; append a snapshot of the memory
+        // after each of the operations.
+        #define TEST_FIELD(TYPE, TARGET) {                    \\
+            SET_AND_APPEND(TYPE, TARGET, -1)                  \\
+            SET_AND_APPEND(TYPE, TARGET, 1)                   \\
+            SET_AND_APPEND(TYPE, TARGET, (TYPE)TEST_PATTERN)  \\
+            SET_AND_APPEND(TYPE, TARGET, 0)                   \\
+        }
+
+        #if defined(__GNUC__) || defined(__clang__)
+        #define GCC_ATTR(X) __attribute__((X))
+        #else
+        #define GCC_ATTR(X) /* */
+        #endif
+
+        static PyObject *
+        get_generated_test_data(PyObject *self, PyObject *name)
+        {
+            if (!PyUnicode_Check(name)) {
+                PyErr_SetString(PyExc_TypeError, "need a string");
+                return NULL;
+            }
+            PyObject *result = PyList_New(0);
+            if (!result) {
+                return NULL;
+            }
+    """)
+    for name, cls in TESTCASES.items():
+        output("""
+            if (PyUnicode_CompareWithASCIIString(name, %s) == 0) {
+            """ % c_str_repr(name))
+        lines, requires = dump_ctype(cls, struct_or_union_tag=name, semi=';')
+        if requires:
+            output(f"""
+            #if {" && ".join(f'({r})' for r in sorted(requires))}
+            """)
+        for line in lines:
+            output('                ' + line)
+        typename = f'{struct_or_union(cls)} {name}'
+        output(f"""
+                {typename} value;
+                memset(&value, 0, sizeof(value));
+                APPEND(PyUnicode_FromString({c_str_repr(name)}));
+                APPEND(PyLong_FromLong(sizeof({typename})));
+                APPEND(PyLong_FromLong(_Alignof({typename})));
+        """.rstrip())
+        for field in iterfields(cls):
+            f_tp = dump_simple_ctype(field.tp)
+            output(f"""\
+                TEST_FIELD({f_tp}, value.{field.full_name});
+            """.rstrip())
+        if requires:
+            output(f"""
+            #else
+                APPEND(Py_NewRef(Py_None));
+                APPEND(PyUnicode_FromString("skipped on this compiler"));
+            #endif
+            """)
+        output("""
+                return result;
+            }
+        """)
+
+    output("""
+            Py_DECREF(result);
+            PyErr_Format(PyExc_ValueError, "unknown testcase %R", name);
+            return NULL;
+        }
+
+        #undef GCC_ATTR
+        #undef TEST_FIELD
+        #undef SET_AND_APPEND
+        #undef APPEND
+    """)
diff --git a/Lib/test/test_ctypes/test_incomplete.py b/Lib/test/test_ctypes/test_incomplete.py
index 9f859793d88..fefdfe9102e 100644
--- a/Lib/test/test_ctypes/test_incomplete.py
+++ b/Lib/test/test_ctypes/test_incomplete.py
@@ -3,15 +3,20 @@
 import warnings
 from ctypes import Structure, POINTER, pointer, c_char_p
 
+# String-based "incomplete pointers" were implemented in ctypes 0.6.3 (2003, when
+# ctypes was an external project). They made obsolete by the current
+# incomplete *types* (setting `_fields_` late) in 0.9.5 (2005).
+# ctypes was added to Python 2.5 (2006), without any mention in docs.
 
-# The incomplete pointer example from the tutorial
+# This tests incomplete pointer example from the old tutorial
+# (https://svn.python.org/projects/ctypes/tags/release_0_6_3/ctypes/docs/tutorial.stx)
 class TestSetPointerType(unittest.TestCase):
     def tearDown(self):
-        # to not leak references, we must clean _pointer_type_cache
-        ctypes._reset_cache()
+        ctypes._pointer_type_cache_fallback.clear()
 
     def test_incomplete_example(self):
-        lpcell = POINTER("cell")
+        with self.assertWarns(DeprecationWarning):
+            lpcell = POINTER("cell")
         class cell(Structure):
             _fields_ = [("name", c_char_p),
                         ("next", lpcell)]
@@ -20,6 +25,8 @@ class cell(Structure):
             warnings.simplefilter('ignore', DeprecationWarning)
             ctypes.SetPointerType(lpcell, cell)
 
+        self.assertIs(POINTER(cell), lpcell)
+
         c1 = cell()
         c1.name = b"foo"
         c2 = cell()
@@ -37,7 +44,8 @@ class cell(Structure):
         self.assertEqual(result, [b"foo", b"bar"] * 4)
 
     def test_deprecation(self):
-        lpcell = POINTER("cell")
+        with self.assertWarns(DeprecationWarning):
+            lpcell = POINTER("cell")
         class cell(Structure):
             _fields_ = [("name", c_char_p),
                         ("next", lpcell)]
@@ -45,6 +53,7 @@ class cell(Structure):
         with self.assertWarns(DeprecationWarning):
             ctypes.SetPointerType(lpcell, cell)
 
+        self.assertIs(POINTER(cell), lpcell)
 
 if __name__ == '__main__':
     unittest.main()
diff --git a/Lib/test/test_ctypes/test_internals.py b/Lib/test/test_ctypes/test_internals.py
index 292633aaa4b..778da6573da 100644
--- a/Lib/test/test_ctypes/test_internals.py
+++ b/Lib/test/test_ctypes/test_internals.py
@@ -27,8 +27,6 @@ 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)
@@ -64,8 +62,6 @@ 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 5aa5b86fa45..5602460d5ff 100644
--- a/Lib/test/test_ctypes/test_keeprefs.py
+++ b/Lib/test/test_ctypes/test_keeprefs.py
@@ -1,6 +1,5 @@
 import unittest
-from ctypes import (Structure, POINTER, pointer,  _pointer_type_cache,
-                    c_char_p, c_int)
+from ctypes import (Structure, POINTER, pointer, c_char_p, c_int)
 
 
 class SimpleTestCase(unittest.TestCase):
@@ -12,8 +11,6 @@ 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)
@@ -35,8 +32,6 @@ 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),
@@ -119,10 +114,6 @@ class RECT(Structure):
         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
index 7716100b08f..df7dbc0ae26 100644
--- a/Lib/test/test_ctypes/test_libc.py
+++ b/Lib/test/test_ctypes/test_libc.py
@@ -1,3 +1,4 @@
+import ctypes
 import math
 import unittest
 from ctypes import (CDLL, CFUNCTYPE, POINTER, create_string_buffer, sizeof,
@@ -21,6 +22,31 @@ def test_sqrt(self):
         self.assertEqual(lib.my_sqrt(4.0), 2.0)
         self.assertEqual(lib.my_sqrt(2.0), math.sqrt(2.0))
 
+    @unittest.skipUnless(hasattr(ctypes, "c_double_complex"),
+                         "requires C11 complex type and libffi >= 3.3.0")
+    def test_csqrt(self):
+        lib.my_csqrt.argtypes = ctypes.c_double_complex,
+        lib.my_csqrt.restype = ctypes.c_double_complex
+        self.assertEqual(lib.my_csqrt(4), 2+0j)
+        self.assertAlmostEqual(lib.my_csqrt(-1+0.01j),
+                               0.004999937502734214+1.0000124996093955j)
+        self.assertAlmostEqual(lib.my_csqrt(-1-0.01j),
+                               0.004999937502734214-1.0000124996093955j)
+
+        lib.my_csqrtf.argtypes = ctypes.c_float_complex,
+        lib.my_csqrtf.restype = ctypes.c_float_complex
+        self.assertAlmostEqual(lib.my_csqrtf(-1+0.01j),
+                               0.004999937502734214+1.0000124996093955j)
+        self.assertAlmostEqual(lib.my_csqrtf(-1-0.01j),
+                               0.004999937502734214-1.0000124996093955j)
+
+        lib.my_csqrtl.argtypes = ctypes.c_longdouble_complex,
+        lib.my_csqrtl.restype = ctypes.c_longdouble_complex
+        self.assertAlmostEqual(lib.my_csqrtl(-1+0.01j),
+                               0.004999937502734214+1.0000124996093955j)
+        self.assertAlmostEqual(lib.my_csqrtl(-1-0.01j),
+                               0.004999937502734214-1.0000124996093955j)
+
     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
diff --git a/Lib/test/test_ctypes/test_loading.py b/Lib/test/test_ctypes/test_loading.py
index a4d54f676a6..3b8332fbb30 100644
--- a/Lib/test/test_ctypes/test_loading.py
+++ b/Lib/test/test_ctypes/test_loading.py
@@ -141,7 +141,7 @@ def test_1703286_B(self):
                          'test specific to Windows')
     def test_load_hasattr(self):
         # bpo-34816: shouldn't raise OSError
-        self.assertFalse(hasattr(ctypes.windll, 'test'))
+        self.assertNotHasAttr(ctypes.windll, 'test')
 
     @unittest.skipUnless(os.name == "nt",
                          'test specific to Windows')
diff --git a/Lib/test/test_ctypes/test_memfunctions.py b/Lib/test/test_ctypes/test_memfunctions.py
index 112b27ba48e..e3cb5db775e 100644
--- a/Lib/test/test_ctypes/test_memfunctions.py
+++ b/Lib/test/test_ctypes/test_memfunctions.py
@@ -5,7 +5,9 @@
                     create_string_buffer, string_at,
                     create_unicode_buffer, wstring_at,
                     memmove, memset,
-                    c_char_p, c_byte, c_ubyte, c_wchar)
+                    memoryview_at, c_void_p,
+                    c_char_p, c_byte, c_ubyte, c_wchar,
+                    addressof, byref)
 
 
 class MemFunctionsTest(unittest.TestCase):
@@ -58,9 +60,6 @@ def test_cast(self):
     @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")
@@ -77,6 +76,62 @@ def test_wstring_at(self):
         self.assertEqual(wstring_at(a, 16), "Hello, World\0\0\0\0")
         self.assertEqual(wstring_at(a, 0), "")
 
+    def test_memoryview_at(self):
+        b = (c_byte * 10)()
+
+        size = len(b)
+        for foreign_ptr in (
+            b,
+            cast(b, c_void_p),
+            byref(b),
+            addressof(b),
+        ):
+            with self.subTest(foreign_ptr=type(foreign_ptr).__name__):
+                b[:] = b"initialval"
+                v = memoryview_at(foreign_ptr, size)
+                self.assertIsInstance(v, memoryview)
+                self.assertEqual(bytes(v), b"initialval")
+
+                # test that writes to source buffer get reflected in memoryview
+                b[:] = b"0123456789"
+                self.assertEqual(bytes(v), b"0123456789")
+
+                # test that writes to memoryview get reflected in source buffer
+                v[:] = b"9876543210"
+                self.assertEqual(bytes(b), b"9876543210")
+
+                with self.assertRaises(ValueError):
+                    memoryview_at(foreign_ptr, -1)
+
+                with self.assertRaises(ValueError):
+                    memoryview_at(foreign_ptr, sys.maxsize + 1)
+
+                v0 = memoryview_at(foreign_ptr, 0)
+                self.assertEqual(bytes(v0), b'')
+
+    def test_memoryview_at_readonly(self):
+        b = (c_byte * 10)()
+
+        size = len(b)
+        for foreign_ptr in (
+            b,
+            cast(b, c_void_p),
+            byref(b),
+            addressof(b),
+        ):
+            with self.subTest(foreign_ptr=type(foreign_ptr).__name__):
+                b[:] = b"initialval"
+                v = memoryview_at(foreign_ptr, size, readonly=True)
+                self.assertIsInstance(v, memoryview)
+                self.assertEqual(bytes(v), b"initialval")
+
+                # test that writes to source buffer get reflected in memoryview
+                b[:] = b"0123456789"
+                self.assertEqual(bytes(v), b"0123456789")
+
+                # test that writes to the memoryview are blocked
+                with self.assertRaises(TypeError):
+                    v[:] = b"9876543210"
 
 if __name__ == "__main__":
     unittest.main()
diff --git a/Lib/test/test_ctypes/test_numbers.py b/Lib/test/test_ctypes/test_numbers.py
index 29108a28ec1..c57c58eb002 100644
--- a/Lib/test/test_ctypes/test_numbers.py
+++ b/Lib/test/test_ctypes/test_numbers.py
@@ -1,12 +1,15 @@
 import array
+import ctypes
 import struct
 import sys
 import unittest
+from itertools import combinations
 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)
+from test.support.testcase import ComplexesAreIdenticalMixin
 
 
 def valid_ranges(*types):
@@ -38,8 +41,28 @@ def valid_ranges(*types):
 signed_ranges = valid_ranges(*signed_types)
 bool_values = [True, False, 0, 1, -1, 5000, 'test', [], [1]]
 
+class IntLike:
+    def __int__(self):
+        return 2
 
-class NumberTestCase(unittest.TestCase):
+class IndexLike:
+    def __index__(self):
+        return 2
+
+class FloatLike:
+    def __float__(self):
+        return 2.0
+
+class ComplexLike:
+    def __complex__(self):
+        return 1+1j
+
+
+INF = float("inf")
+NAN = float("nan")
+
+
+class NumberTestCase(unittest.TestCase, ComplexesAreIdenticalMixin):
 
     def test_default_init(self):
         # default values are set to zero
@@ -86,9 +109,6 @@ def test_byref(self):
     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)
@@ -96,18 +116,34 @@ def __float__(self):
             self.assertEqual(t(2).value, 2.0)
             self.assertEqual(t(f).value, 2.0)
 
+    @unittest.skipUnless(hasattr(ctypes, "c_double_complex"),
+                         "requires C11 complex type")
+    def test_complex(self):
+        for t in [ctypes.c_double_complex, ctypes.c_float_complex,
+                  ctypes.c_longdouble_complex]:
+            self.assertEqual(t(1).value, 1+0j)
+            self.assertEqual(t(1.0).value, 1+0j)
+            self.assertEqual(t(1+0.125j).value, 1+0.125j)
+            self.assertEqual(t(IndexLike()).value, 2+0j)
+            self.assertEqual(t(FloatLike()).value, 2+0j)
+            self.assertEqual(t(ComplexLike()).value, 1+1j)
+
+    @unittest.skipUnless(hasattr(ctypes, "c_double_complex"),
+                         "requires C11 complex type")
+    def test_complex_round_trip(self):
+        # Ensure complexes transformed exactly.  The CMPLX macro should
+        # preserve special components (like inf/nan or signed zero).
+        values = [complex(*_) for _ in combinations([1, -1, 0.0, -0.0, 2,
+                                                     -3, INF, -INF, NAN], 2)]
+        for z in values:
+            for t in [ctypes.c_double_complex, ctypes.c_float_complex,
+                      ctypes.c_longdouble_complex]:
+                with self.subTest(z=z, type=t):
+                    self.assertComplexesAreIdentical(z, t(z).value)
+
     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
diff --git a/Lib/test/test_ctypes/test_objects.py b/Lib/test/test_ctypes/test_objects.py
index 8db1cd873fd..fb01421b955 100644
--- a/Lib/test/test_ctypes/test_objects.py
+++ b/Lib/test/test_ctypes/test_objects.py
@@ -58,8 +58,7 @@
 
 
 def load_tests(loader, tests, pattern):
-    # TODO: RUSTPYTHON - doctest disabled due to null terminator in _objects
-    # tests.addTest(doctest.DocTestSuite())
+    tests.addTest(doctest.DocTestSuite())
     return tests
 
 
diff --git a/Lib/test/test_ctypes/test_parameters.py b/Lib/test/test_ctypes/test_parameters.py
index 1a6ddb91a7d..46f8ff93efa 100644
--- a/Lib/test/test_ctypes/test_parameters.py
+++ b/Lib/test/test_ctypes/test_parameters.py
@@ -4,7 +4,7 @@
 from ctypes import (CDLL, PyDLL, ArgumentError,
                     Structure, Array, Union,
                     _Pointer, _SimpleCData, _CFuncPtr,
-                    POINTER, pointer, byref,
+                    POINTER, pointer, byref, sizeof,
                     c_void_p, c_char_p, c_wchar_p, py_object,
                     c_bool,
                     c_char, c_wchar,
@@ -88,19 +88,33 @@ 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")
+                         "one character bytes, bytearray, or an integer "
+                         "in range(256) expected, not bytes of length 3")
 
     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")
+                         "a unicode character expected, not a string of length 3")
 
+        with self.assertRaises(TypeError) as cm:
+            c_wchar.from_param("")
+        self.assertEqual(str(cm.exception),
+                         "a unicode character expected, not a string of length 0")
 
         with self.assertRaises(TypeError) as cm:
             c_wchar.from_param(123)
         self.assertEqual(str(cm.exception),
-                         "unicode string expected instead of int instance")
+                         "a unicode character expected, not instance of int")
+
+        if sizeof(c_wchar) < 4:
+            with self.assertRaises(TypeError) as cm:
+                c_wchar.from_param('\U0001f40d')
+            self.assertEqual(str(cm.exception),
+                             "the string '\\U0001f40d' cannot be converted to "
+                             "a single wchar_t character")
+
+
 
     def test_int_pointers(self):
         LPINT = POINTER(c_int)
diff --git a/Lib/test/test_ctypes/test_pep3118.py b/Lib/test/test_ctypes/test_pep3118.py
index 06b2ccecade..11a0744f5a8 100644
--- a/Lib/test/test_ctypes/test_pep3118.py
+++ b/Lib/test/test_ctypes/test_pep3118.py
@@ -81,6 +81,7 @@ class Point(Structure):
 
 class PackedPoint(Structure):
     _pack_ = 2
+    _layout_ = 'ms'
     _fields_ = [("x", c_long), ("y", c_long)]
 
 class PointMidPad(Structure):
@@ -88,6 +89,7 @@ class PointMidPad(Structure):
 
 class PackedPointMidPad(Structure):
     _pack_ = 2
+    _layout_ = 'ms'
     _fields_ = [("x", c_byte), ("y", c_uint64)]
 
 class PointEndPad(Structure):
@@ -95,6 +97,7 @@ class PointEndPad(Structure):
 
 class PackedPointEndPad(Structure):
     _pack_ = 2
+    _layout_ = 'ms'
     _fields_ = [("x", c_uint64), ("y", c_byte)]
 
 class Point2(Structure):
diff --git a/Lib/test/test_ctypes/test_pickling.py b/Lib/test/test_ctypes/test_pickling.py
index 9d433fc69de..8f8c09f1fb6 100644
--- a/Lib/test/test_ctypes/test_pickling.py
+++ b/Lib/test/test_ctypes/test_pickling.py
@@ -3,7 +3,7 @@
 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
+from test.support import import_helper, thread_unsafe
 _ctypes_test = import_helper.import_module("_ctypes_test")
 
 
@@ -21,7 +21,6 @@ def __init__(self, *args, **kw):
 class Y(X):
     _fields_ = [("str", c_char_p)]
 
-
 class PickleTest:
     def dumps(self, item):
         return pickle.dumps(item, self.proto)
@@ -39,6 +38,7 @@ def test_simple(self):
             self.assertEqual(memoryview(src).tobytes(),
                                  memoryview(dst).tobytes())
 
+    @thread_unsafe('not thread safe')
     def test_struct(self):
         X.init_called = 0
 
diff --git a/Lib/test/test_ctypes/test_pointers.py b/Lib/test/test_ctypes/test_pointers.py
index ed4541335df..771cc8fbe0e 100644
--- a/Lib/test/test_ctypes/test_pointers.py
+++ b/Lib/test/test_ctypes/test_pointers.py
@@ -1,15 +1,18 @@
 import array
 import ctypes
+import gc
 import sys
 import unittest
 from ctypes import (CDLL, CFUNCTYPE, Structure,
-                    POINTER, pointer, _Pointer, _pointer_type_cache,
+                    POINTER, pointer, _Pointer,
                     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 ctypes import _pointer_type_cache, _pointer_type_cache_fallback
 from test.support import import_helper
+from weakref import WeakSet
 _ctypes_test = import_helper.import_module("_ctypes_test")
 from ._support import (_CData, PyCPointerType, Py_TPFLAGS_DISALLOW_INSTANTIATION,
                        Py_TPFLAGS_IMMUTABLETYPE)
@@ -22,6 +25,9 @@
 
 
 class PointersTestCase(unittest.TestCase):
+    def tearDown(self):
+        _pointer_type_cache_fallback.clear()
+
     def test_inheritance_hierarchy(self):
         self.assertEqual(_Pointer.mro(), [_Pointer, _CData, object])
 
@@ -127,6 +133,14 @@ def test_from_address(self):
         addr = a.buffer_info()[0]
         p = POINTER(POINTER(c_int))
 
+    def test_pointer_from_pointer(self):
+        p1 = POINTER(c_int)
+        p2 = POINTER(p1)
+
+        self.assertIsNot(p1, p2)
+        self.assertIs(p1.__pointer_type__, p2)
+        self.assertIs(p2._type_, p1)
+
     def test_other(self):
         class Table(Structure):
             _fields_ = [("a", c_int),
@@ -141,8 +155,6 @@ class Table(Structure):
 
         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
@@ -175,6 +187,7 @@ def test_bug_1467852(self):
         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:
@@ -193,6 +206,30 @@ def test_c_void_p(self):
         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_read_null_pointer(self):
+        null_ptr = POINTER(c_int)()
+        with self.assertRaisesRegex(ValueError, "NULL pointer access"):
+            null_ptr[0]
+
+    def test_write_null_pointer(self):
+        null_ptr = POINTER(c_int)()
+        with self.assertRaisesRegex(ValueError, "NULL pointer access"):
+            null_ptr[0] = 1
+
+    def test_set_pointer_to_null_and_read(self):
+        class Bar(Structure):
+            _fields_ = [("values", POINTER(c_int))]
+
+        bar = Bar()
+        bar.values = (c_int * 3)(1, 2, 3)
+
+        values = [bar.values[0], bar.values[1], bar.values[2]]
+        self.assertEqual(values, [1, 2, 3])
+
+        bar.values = None
+        with self.assertRaisesRegex(ValueError, "NULL pointer access"):
+            bar.values[0]
+
     def test_pointers_bool(self):
         # NULL pointers have a boolean False value, non-NULL pointers True.
         self.assertEqual(bool(POINTER(c_int)()), False)
@@ -210,20 +247,230 @@ 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)
+        with self.assertWarns(DeprecationWarning):
+            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_pointer_types_equal(self):
+        t1 = POINTER(c_int)
+        t2 = POINTER(c_int)
+
+        self.assertIs(t1, t2)
+
+        p1 = t1(c_int(1))
+        p2 = pointer(c_int(1))
+
+        self.assertIsInstance(p1, t1)
+        self.assertIsInstance(p2, t1)
+
+        self.assertIs(type(p1), t1)
+        self.assertIs(type(p2), t1)
+
+    def test_incomplete_pointer_types_still_equal(self):
+        with self.assertWarns(DeprecationWarning):
+            t1 = POINTER("LP_C")
+        with self.assertWarns(DeprecationWarning):
+            t2 = POINTER("LP_C")
+
+        self.assertIs(t1, t2)
+
+    def test_incomplete_pointer_types_cannot_instantiate(self):
+        with self.assertWarns(DeprecationWarning):
+            t1 = POINTER("LP_C")
+        with self.assertRaisesRegex(TypeError, "has no _type_"):
+            t1()
+
+    def test_pointer_set_type_twice(self):
+        t1 = POINTER(c_int)
+        self.assertIs(c_int.__pointer_type__, t1)
+        self.assertIs(t1._type_, c_int)
+
+        t1.set_type(c_int)
+        self.assertIs(c_int.__pointer_type__, t1)
+        self.assertIs(t1._type_, c_int)
+
+    def test_pointer_set_wrong_type(self):
+        int_ptr = POINTER(c_int)
+        float_ptr = POINTER(c_float)
+        try:
+            class C(c_int):
+                pass
+
+            t1 = POINTER(c_int)
+            t2 = POINTER(c_float)
+            t1.set_type(c_float)
+            self.assertEqual(t1(c_float(1.5))[0], 1.5)
+            self.assertIs(t1._type_, c_float)
+            self.assertIs(c_int.__pointer_type__, t1)
+            self.assertIs(c_float.__pointer_type__, float_ptr)
+
+            t1.set_type(C)
+            self.assertEqual(t1(C(123))[0].value, 123)
+            self.assertIs(c_int.__pointer_type__, t1)
+            self.assertIs(c_float.__pointer_type__, float_ptr)
+        finally:
+            POINTER(c_int).set_type(c_int)
+        self.assertIs(POINTER(c_int), int_ptr)
+        self.assertIs(POINTER(c_int)._type_, c_int)
+        self.assertIs(c_int.__pointer_type__, int_ptr)
+
+    def test_pointer_not_ctypes_type(self):
+        with self.assertRaisesRegex(TypeError, "must have storage info"):
+            POINTER(int)
+
+        with self.assertRaisesRegex(TypeError, "must have storage info"):
+            pointer(int)
+
+        with self.assertRaisesRegex(TypeError, "must have storage info"):
+            pointer(int(1))
+
+    def test_pointer_set_python_type(self):
+        p1 = POINTER(c_int)
+        with self.assertRaisesRegex(TypeError, "must have storage info"):
+            p1.set_type(int)
+
+    def test_pointer_type_attribute_is_none(self):
+        class Cls(Structure):
+            _fields_ = (
+                ('a', c_int),
+                ('b', c_float),
+            )
+
+        with self.assertRaisesRegex(AttributeError, ".Cls'> has no attribute '__pointer_type__'"):
+            Cls.__pointer_type__
+
+        p = POINTER(Cls)
+        self.assertIs(Cls.__pointer_type__, p)
+
+    def test_arbitrary_pointer_type_attribute(self):
+        class Cls(Structure):
+            _fields_ = (
+                ('a', c_int),
+                ('b', c_float),
+            )
+
+        garbage = 'garbage'
+
+        P = POINTER(Cls)
+        self.assertIs(Cls.__pointer_type__, P)
+        Cls.__pointer_type__ = garbage
+        self.assertIs(Cls.__pointer_type__, garbage)
+        self.assertIs(POINTER(Cls), garbage)
+        self.assertIs(P._type_, Cls)
+
+        instance = Cls(1, 2.0)
+        pointer = P(instance)
+        self.assertEqual(pointer[0].a, 1)
+        self.assertEqual(pointer[0].b, 2)
+
+        del Cls.__pointer_type__
+
+        NewP = POINTER(Cls)
+        self.assertIsNot(NewP, P)
+        self.assertIs(Cls.__pointer_type__, NewP)
+        self.assertIs(P._type_, Cls)
+
+    def test_pointer_types_factory(self):
+        """Shouldn't leak"""
+        def factory():
+            class Cls(Structure):
+                _fields_ = (
+                    ('a', c_int),
+                    ('b', c_float),
+                )
+
+            return Cls
+
+        ws_typ = WeakSet()
+        ws_ptr = WeakSet()
+        for _ in range(10):
+            typ = factory()
+            ptr = POINTER(typ)
+
+            ws_typ.add(typ)
+            ws_ptr.add(ptr)
+
+        typ = None
+        ptr = None
+
+        gc.collect()
+
+        self.assertEqual(len(ws_typ), 0, ws_typ)
+        self.assertEqual(len(ws_ptr), 0, ws_ptr)
+
+    def test_pointer_proto_missing_argtypes_error(self):
+        class BadType(ctypes._Pointer):
+            # _type_ is intentionally missing
+            pass
+
+        func = ctypes.pythonapi.Py_GetVersion
+        func.argtypes = (BadType,)
+
+        with self.assertRaises(ctypes.ArgumentError):
+            func(object())
+
+class PointerTypeCacheTestCase(unittest.TestCase):
+    # dummy tests to check warnings and base behavior
+    def tearDown(self):
+        _pointer_type_cache_fallback.clear()
+
+    def test_deprecated_cache_with_not_ctypes_type(self):
+        class C:
+            pass
+
+        with self.assertWarns(DeprecationWarning):
+            P = POINTER("C")
+
+        with self.assertWarns(DeprecationWarning):
+            self.assertIs(_pointer_type_cache["C"], P)
+
+        with self.assertWarns(DeprecationWarning):
+            _pointer_type_cache[C] = P
+        self.assertIs(C.__pointer_type__, P)
+        with self.assertWarns(DeprecationWarning):
+            self.assertIs(_pointer_type_cache[C], P)
+
+    def test_deprecated_cache_with_ints(self):
+        with self.assertWarns(DeprecationWarning):
+            _pointer_type_cache[123] = 456
+
+        with self.assertWarns(DeprecationWarning):
+            self.assertEqual(_pointer_type_cache[123], 456)
+
+    def test_deprecated_cache_with_ctypes_type(self):
+        class C(Structure):
+            _fields_ = [("a", c_int),
+                        ("b", c_int),
+                        ("c", c_int)]
+
+        P1 = POINTER(C)
+        with self.assertWarns(DeprecationWarning):
+            P2 = POINTER("C")
+
+        with self.assertWarns(DeprecationWarning):
+            _pointer_type_cache[C] = P2
+
+        self.assertIs(C.__pointer_type__, P2)
+        self.assertIsNot(C.__pointer_type__, P1)
+
+        with self.assertWarns(DeprecationWarning):
+            self.assertIs(_pointer_type_cache[C], P2)
+
+        with self.assertWarns(DeprecationWarning):
+            self.assertIs(_pointer_type_cache.get(C), P2)
+
+    def test_get_not_registered(self):
+        with self.assertWarns(DeprecationWarning):
+            self.assertIsNone(_pointer_type_cache.get(str))
+
+        with self.assertWarns(DeprecationWarning):
+            self.assertIsNone(_pointer_type_cache.get(str, None))
+
     def test_repeated_set_type(self):
         # Regression test for gh-133290
         class C(Structure):
diff --git a/Lib/test/test_ctypes/test_python_api.py b/Lib/test/test_ctypes/test_python_api.py
index 2e68b35f8af..a1ee8a0de1e 100644
--- a/Lib/test/test_ctypes/test_python_api.py
+++ b/Lib/test/test_ctypes/test_python_api.py
@@ -7,7 +7,7 @@
 
 
 class PythonAPITestCase(unittest.TestCase):
-    # TODO: RUSTPYTHON
+    # TODO: RUSTPYTHON - requires pythonapi (Python C API)
     @unittest.expectedFailure
     def test_PyBytes_FromStringAndSize(self):
         PyBytes_FromStringAndSize = pythonapi.PyBytes_FromStringAndSize
@@ -59,7 +59,7 @@ def test_PyObj_FromPtr(self):
         del pyobj
         self.assertEqual(sys.getrefcount(s), ref)
 
-    # TODO: RUSTPYTHON
+    # TODO: RUSTPYTHON - requires pythonapi (Python C API)
     @unittest.expectedFailure
     def test_PyOS_snprintf(self):
         PyOS_snprintf = pythonapi.PyOS_snprintf
diff --git a/Lib/test/test_ctypes/test_random_things.py b/Lib/test/test_ctypes/test_random_things.py
index 3908eca0926..73ff57d925e 100644
--- a/Lib/test/test_ctypes/test_random_things.py
+++ b/Lib/test/test_ctypes/test_random_things.py
@@ -51,7 +51,7 @@ def expect_unraisable(self, exc_type, exc_msg=None):
             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"Exception ignored while calling ctypes "
                              f"callback function {callback_func!r}")
             self.assertIsNone(cm.unraisable.object)
 
@@ -70,8 +70,6 @@ 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_refcounts.py b/Lib/test/test_ctypes/test_refcounts.py
index 9e87cfc661e..1815649ceb5 100644
--- a/Lib/test/test_ctypes/test_refcounts.py
+++ b/Lib/test/test_ctypes/test_refcounts.py
@@ -3,7 +3,7 @@
 import sys
 import unittest
 from test import support
-from test.support import import_helper
+from test.support import import_helper, thread_unsafe
 from test.support import script_helper
 _ctypes_test = import_helper.import_module("_ctypes_test")
 
@@ -13,7 +13,7 @@
 
 dll = ctypes.CDLL(_ctypes_test.__file__)
 
-
+@thread_unsafe('not thread safe')
 class RefcountTestCase(unittest.TestCase):
     @support.refcount_test
     def test_1(self):
@@ -24,36 +24,35 @@ def test_1(self):
         def callback(value):
             return value
 
-        self.assertEqual(sys.getrefcount(callback), 2)
+        orig_refcount = sys.getrefcount(callback)
         cb = MyCallback(callback)
 
-        self.assertGreater(sys.getrefcount(callback), 2)
+        self.assertGreater(sys.getrefcount(callback), orig_refcount)
         result = f(-10, cb)
         self.assertEqual(result, -18)
         cb = None
 
         gc.collect()
 
-        self.assertEqual(sys.getrefcount(callback), 2)
+        self.assertEqual(sys.getrefcount(callback), orig_refcount)
 
     @support.refcount_test
     def test_refcount(self):
         def func(*args):
             pass
-        # this is the standard refcount for func
-        self.assertEqual(sys.getrefcount(func), 2)
+        orig_refcount = sys.getrefcount(func)
 
         # the CFuncPtr instance holds at least one refcount on func:
         f = OtherCallback(func)
-        self.assertGreater(sys.getrefcount(func), 2)
+        self.assertGreater(sys.getrefcount(func), orig_refcount)
 
         # and may release it again
         del f
-        self.assertGreaterEqual(sys.getrefcount(func), 2)
+        self.assertGreaterEqual(sys.getrefcount(func), orig_refcount)
 
         # but now it must be gone
         gc.collect()
-        self.assertEqual(sys.getrefcount(func), 2)
+        self.assertEqual(sys.getrefcount(func), orig_refcount)
 
         class X(ctypes.Structure):
             _fields_ = [("a", OtherCallback)]
@@ -61,29 +60,29 @@ class X(ctypes.Structure):
         x.a = OtherCallback(func)
 
         # the CFuncPtr instance holds at least one refcount on func:
-        self.assertGreater(sys.getrefcount(func), 2)
+        self.assertGreater(sys.getrefcount(func), orig_refcount)
 
         # and may release it again
         del x
-        self.assertGreaterEqual(sys.getrefcount(func), 2)
+        self.assertGreaterEqual(sys.getrefcount(func), orig_refcount)
 
         # and now it must be gone again
         gc.collect()
-        self.assertEqual(sys.getrefcount(func), 2)
+        self.assertEqual(sys.getrefcount(func), orig_refcount)
 
         f = OtherCallback(func)
 
         # the CFuncPtr instance holds at least one refcount on func:
-        self.assertGreater(sys.getrefcount(func), 2)
+        self.assertGreater(sys.getrefcount(func), orig_refcount)
 
         # create a cycle
         f.cycle = f
 
         del f
         gc.collect()
-        self.assertEqual(sys.getrefcount(func), 2)
-
+        self.assertEqual(sys.getrefcount(func), orig_refcount)
 
+@thread_unsafe('not thread safe')
 class AnotherLeak(unittest.TestCase):
     def test_callback(self):
         proto = ctypes.CFUNCTYPE(ctypes.c_int, ctypes.c_int, ctypes.c_int)
diff --git a/Lib/test/test_ctypes/test_repr.py b/Lib/test/test_ctypes/test_repr.py
index e7587984a92..8c85e6cbe70 100644
--- a/Lib/test/test_ctypes/test_repr.py
+++ b/Lib/test/test_ctypes/test_repr.py
@@ -22,12 +22,12 @@ 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])
+            self.assertStartsWith(repr(base(42)), base.__name__)
+            self.assertStartsWith(repr(typ(42)), "<X object at")
 
     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])
+        self.assertStartsWith(repr(X(b'x')), "<X object at")
 
 
 if __name__ == "__main__":
diff --git a/Lib/test/test_ctypes/test_stringptr.py b/Lib/test/test_ctypes/test_stringptr.py
index bb6045b250f..a6a2dec68df 100644
--- a/Lib/test/test_ctypes/test_stringptr.py
+++ b/Lib/test/test_ctypes/test_stringptr.py
@@ -20,9 +20,9 @@ class X(Structure):
         # NULL pointer access
         self.assertRaises(ValueError, getattr, x.str, "contents")
         b = create_string_buffer(b"Hello, World")
-        self.assertEqual(sys.getrefcount(b), 2)
+        orig_refcount = sys.getrefcount(b)
         x.str = b
-        self.assertEqual(sys.getrefcount(b), 3)
+        self.assertEqual(sys.getrefcount(b), orig_refcount + 1)
 
         # POINTER(c_char) and Python string is NOT compatible
         # POINTER(c_char) and create_string_buffer() is compatible
diff --git a/Lib/test/test_ctypes/test_struct_fields.py b/Lib/test/test_ctypes/test_struct_fields.py
index fd9509757a3..dc26e26d8a9 100644
--- a/Lib/test/test_ctypes/test_struct_fields.py
+++ b/Lib/test/test_ctypes/test_struct_fields.py
@@ -1,11 +1,12 @@
 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)
+from ctypes import Structure, Union, sizeof, c_byte, c_char, c_int, CField
+from ._support import Py_TPFLAGS_IMMUTABLETYPE, StructCheckMixin
 
 
-class StructFieldsTestCase(unittest.TestCase):
+NOTHING = object()
+
+class FieldsTestBase(StructCheckMixin):
     # Structure/Union classes must get 'finalized' sooner or
     # later, when one of these things happen:
     #
@@ -15,42 +16,47 @@ class StructFieldsTestCase(unittest.TestCase):
     # 4. The type is subclassed
     #
     # When they are finalized, assigning _fields_ is no longer allowed.
+
+    def assert_final_fields(self, cls, expected=NOTHING):
+        self.assertRaises(AttributeError, setattr, cls, "_fields_", [])
+        self.assertEqual(getattr(cls, "_fields_", NOTHING), expected)
+
     def test_1_A(self):
-        class X(Structure):
+        class X(self.cls):
             pass
         self.assertEqual(sizeof(X), 0) # not finalized
         X._fields_ = [] # finalized
-        self.assertRaises(AttributeError, setattr, X, "_fields_", [])
+        self.assert_final_fields(X, expected=[])
 
     def test_1_B(self):
-        class X(Structure):
+        class X(self.cls):
             _fields_ = [] # finalized
-        self.assertRaises(AttributeError, setattr, X, "_fields_", [])
+        self.assert_final_fields(X, expected=[])
 
     def test_2(self):
-        class X(Structure):
+        class X(self.cls):
             pass
         X()
-        self.assertRaises(AttributeError, setattr, X, "_fields_", [])
+        self.assert_final_fields(X)
 
     def test_3(self):
-        class X(Structure):
+        class X(self.cls):
             pass
-        class Y(Structure):
+        class Y(self.cls):
             _fields_ = [("x", X)] # finalizes X
-        self.assertRaises(AttributeError, setattr, X, "_fields_", [])
+        self.assert_final_fields(X)
 
     def test_4(self):
-        class X(Structure):
+        class X(self.cls):
             pass
         class Y(X):
             pass
-        self.assertRaises(AttributeError, setattr, X, "_fields_", [])
+        self.assert_final_fields(X)
         Y._fields_ = []
-        self.assertRaises(AttributeError, setattr, X, "_fields_", [])
+        self.assert_final_fields(X)
 
     def test_5(self):
-        class X(Structure):
+        class X(self.cls):
             _fields_ = (("char", c_char * 5),)
 
         x = X(b'#' * 5)
@@ -60,15 +66,8 @@ class X(Structure):
     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):
+        class BrokenStructure(self.cls):
             def __init_subclass__(cls, **kwargs):
                 cls._fields_ = []  # This line will fail, `stginfo` is not ready
 
@@ -76,19 +75,44 @@ def __init_subclass__(cls, **kwargs):
                                     'ctypes state is not initialized'):
             class Subclass(BrokenStructure): ...
 
+    def test_invalid_byte_size_raises_gh132470(self):
+        with self.assertRaisesRegex(ValueError, r"does not match type size"):
+            CField(
+                name="a",
+                type=c_byte,
+                byte_size=2,  # Wrong size: c_byte is only 1 byte
+                byte_offset=2,
+                index=1,
+                _internal_use=True
+            )
+
     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.
 
+        max_field_size = sys.maxsize
+
         class X(Structure):
             _fields_ = [('char', c_char),]
-        max_field_size = sys.maxsize
+        self.check_struct(X)
 
         class Y(Structure):
             _fields_ = [('largeField', X * max_field_size)]
+        self.check_struct(Y)
+
         class Z(Structure):
             _fields_ = [('largeField', c_char * max_field_size)]
+        self.check_struct(Z)
+
+        # The *bit* size overflows Py_ssize_t.
+        self.assertEqual(Y.largeField.bit_size, max_field_size * 8)
+        self.assertEqual(Z.largeField.bit_size, max_field_size * 8)
+
+        self.assertEqual(Y.largeField.byte_size, max_field_size)
+        self.assertEqual(Z.largeField.byte_size, max_field_size)
+        self.assertEqual(sizeof(Y), max_field_size)
+        self.assertEqual(sizeof(Z), max_field_size)
 
         with self.assertRaises(OverflowError):
             class TooBig(Structure):
@@ -97,29 +121,56 @@ class TooBig(Structure):
             class TooBig(Structure):
                 _fields_ = [('largeField', c_char * (max_field_size + 1))]
 
+        # Also test around edge case for the bit_size calculation
+        for size in (max_field_size // 8 - 1,
+                     max_field_size // 8,
+                     max_field_size // 8 + 1):
+            class S(Structure):
+                _fields_ = [('largeField', c_char * size),]
+            self.check_struct(S)
+            self.assertEqual(S.largeField.bit_size, size * 8)
+
+    def test_bitfield_overflow_error_message(self):
+        with self.assertRaisesRegex(
+            ValueError,
+            r"bit field 'x' overflows its type \(2 \+ 7 > 8\)",
+        ):
+            CField(
+                name="x",
+                type=c_byte,
+                byte_size=1,
+                byte_offset=0,
+                index=0,
+                _internal_use=True,
+                bit_size=7,
+                bit_offset=2,
+            )
+
     # __set__ and __get__ should raise a TypeError in case their self
     # argument is not a ctype instance.
     def test___set__(self):
-        class MyCStruct(Structure):
+        class MyCStruct(self.cls):
             _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):
+        class MyCStruct(self.cls):
             _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)
+class StructFieldsTestCase(unittest.TestCase, FieldsTestBase):
+    cls = Structure
+
+    def test_cfield_type_flags(self):
+        self.assertTrue(CField.__flags__ & Py_TPFLAGS_IMMUTABLETYPE)
+
+    def test_cfield_inheritance_hierarchy(self):
+        self.assertEqual(CField.mro(), [CField, object])
+
+class UnionFieldsTestCase(unittest.TestCase, FieldsTestBase):
+    cls = Union
 
 
 if __name__ == "__main__":
diff --git a/Lib/test/test_ctypes/test_structunion.py b/Lib/test/test_ctypes/test_structunion.py
new file mode 100644
index 00000000000..5b21d48d99c
--- /dev/null
+++ b/Lib/test/test_ctypes/test_structunion.py
@@ -0,0 +1,477 @@
+"""Common tests for ctypes.Structure and ctypes.Union"""
+
+import unittest
+import sys
+from ctypes import (Structure, Union, POINTER, 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_int8, c_int16, c_int32)
+from ._support import (_CData, PyCStructType, UnionType,
+                       Py_TPFLAGS_DISALLOW_INSTANTIATION,
+                       Py_TPFLAGS_IMMUTABLETYPE)
+from struct import calcsize
+import contextlib
+from test.support import MS_WINDOWS
+
+
+class StructUnionTestBase:
+    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_subclass(self):
+        class X(self.cls):
+            _fields_ = [("a", c_int)]
+
+        class Y(X):
+            _fields_ = [("b", c_int)]
+
+        class Z(X):
+            pass
+
+        self.assertEqual(sizeof(X), sizeof(c_int))
+        self.check_sizeof(Y,
+                          struct_size=sizeof(c_int)*2,
+                          union_size=sizeof(c_int))
+        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(self.cls):
+            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.check_sizeof(Y,
+                          struct_size=sizeof(c_int)*2,
+                          union_size=sizeof(c_int))
+        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_inheritance_hierarchy(self):
+        self.assertEqual(self.cls.mro(), [self.cls, _CData, object])
+        self.assertEqual(type(self.metacls), type)
+
+    def test_type_flags(self):
+        for cls in self.cls, self.metacls:
+            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
+        NewClass = self.metacls.__new__(self.metacls, 'NewClass',
+                                        (self.cls,), {})
+        for cls in self.cls, NewClass:
+            with self.subTest(cls=cls):
+                with self.assertRaisesRegex(TypeError, "abstract class"):
+                    obj = cls()
+
+        # Cannot call the metaclass __init__ more than once
+        class T(self.cls):
+            _fields_ = [("x", c_char),
+                        ("y", c_char)]
+        with self.assertRaisesRegex(SystemError, "already initialized"):
+            self.metacls.__init__(T, 'ptr', (), {})
+
+    def test_alignment(self):
+        class X(self.cls):
+            _fields_ = [("x", c_char * 3)]
+        self.assertEqual(alignment(X), calcsize("s"))
+        self.assertEqual(sizeof(X), calcsize("3s"))
+
+        class Y(self.cls):
+            _fields_ = [("x", c_char * 3),
+                        ("y", c_int)]
+        self.assertEqual(alignment(Y), alignment(c_int))
+        self.check_sizeof(Y,
+                          struct_size=calcsize("3s i"),
+                          union_size=max(calcsize("3s"), calcsize("i")))
+
+        class SI(self.cls):
+            _fields_ = [("a", X),
+                        ("b", Y)]
+        self.assertEqual(alignment(SI), max(alignment(Y), alignment(X)))
+        self.check_sizeof(SI,
+                          struct_size=calcsize("3s0i 3si 0i"),
+                          union_size=max(calcsize("3s"), calcsize("i")))
+
+        class IS(self.cls):
+            _fields_ = [("b", Y),
+                        ("a", X)]
+
+        self.assertEqual(alignment(SI), max(alignment(X), alignment(Y)))
+        self.check_sizeof(IS,
+                          struct_size=calcsize("3si 3s 0i"),
+                          union_size=max(calcsize("3s"), calcsize("i")))
+
+        class XX(self.cls):
+            _fields_ = [("a", X),
+                        ("b", X)]
+        self.assertEqual(alignment(XX), alignment(X))
+        self.check_sizeof(XX,
+                          struct_size=calcsize("3s 3s 0s"),
+                          union_size=calcsize("3s"))
+
+    def test_empty(self):
+        # I had problems with these
+        #
+        # Although these are pathological cases: Empty Structures!
+        class X(self.cls):
+            _fields_ = []
+
+        # Is this really the correct alignment, or should it be 0?
+        self.assertTrue(alignment(X) == 1)
+        self.assertTrue(sizeof(X) == 0)
+
+        class XX(self.cls):
+            _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(self.cls):
+            _fields_ = [("x", c_int),
+                        ("y", c_char)]
+
+        self.assertEqual(X.x.offset, 0)
+        self.assertEqual(X.x.size, sizeof(c_int))
+
+        if self.cls == Structure:
+            self.assertEqual(X.y.offset, sizeof(c_int))
+        else:
+            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_field_descriptor_attributes(self):
+        """Test information provided by the descriptors"""
+        class Inner(Structure):
+            _fields_ = [
+                ("a", c_int16),
+                ("b", c_int8, 1),
+                ("c", c_int8, 2),
+            ]
+        class X(self.cls):
+            _fields_ = [
+                ("x", c_int32),
+                ("y", c_int16, 1),
+                ("_", Inner),
+            ]
+            _anonymous_ = ["_"]
+
+        field_names = "xy_abc"
+
+        # name
+
+        for name in field_names:
+            with self.subTest(name=name):
+                self.assertEqual(getattr(X, name).name, name)
+
+        # type
+
+        expected_types = dict(
+            x=c_int32,
+            y=c_int16,
+            _=Inner,
+            a=c_int16,
+            b=c_int8,
+            c=c_int8,
+        )
+        assert set(expected_types) == set(field_names)
+        for name, tp in expected_types.items():
+            with self.subTest(name=name):
+                self.assertEqual(getattr(X, name).type, tp)
+                self.assertEqual(getattr(X, name).byte_size, sizeof(tp))
+
+        # offset, byte_offset
+
+        expected_offsets = dict(
+            x=(0, 0),
+            y=(0, 4),
+            _=(0, 6),
+            a=(0, 6),
+            b=(2, 8),
+            c=(2, 8),
+        )
+        assert set(expected_offsets) == set(field_names)
+        for name, (union_offset, struct_offset) in expected_offsets.items():
+            with self.subTest(name=name):
+                self.assertEqual(getattr(X, name).offset,
+                                 getattr(X, name).byte_offset)
+                if self.cls == Structure:
+                    self.assertEqual(getattr(X, name).offset, struct_offset)
+                else:
+                    self.assertEqual(getattr(X, name).offset, union_offset)
+
+        # is_bitfield, bit_size, bit_offset
+        # size
+
+        little_endian = (sys.byteorder == 'little')
+        expected_bitfield_info = dict(
+            # (bit_size, bit_offset)
+            b=(1, 0 if little_endian else 7),
+            c=(2, 1 if little_endian else 5),
+            y=(1, 0 if little_endian else 15),
+        )
+        for name in field_names:
+            with self.subTest(name=name):
+                if info := expected_bitfield_info.get(name):
+                    self.assertEqual(getattr(X, name).is_bitfield, True)
+                    expected_bit_size, expected_bit_offset = info
+                    self.assertEqual(getattr(X, name).bit_size,
+                                     expected_bit_size)
+                    self.assertEqual(getattr(X, name).bit_offset,
+                                     expected_bit_offset)
+                    self.assertEqual(getattr(X, name).size,
+                                     (expected_bit_size << 16)
+                                     | expected_bit_offset)
+                else:
+                    self.assertEqual(getattr(X, name).is_bitfield, False)
+                    type_size = sizeof(expected_types[name])
+                    self.assertEqual(getattr(X, name).bit_size, type_size * 8)
+                    self.assertEqual(getattr(X, name).bit_offset, 0)
+                    self.assertEqual(getattr(X, name).size, type_size)
+
+        # is_anonymous
+
+        for name in field_names:
+            with self.subTest(name=name):
+                self.assertEqual(getattr(X, name).is_anonymous, (name == '_'))
+
+
+    def test_invalid_field_types(self):
+        class POINT(self.cls):
+            pass
+        self.assertRaises(TypeError, setattr, POINT, "_fields_", [("x", 1), ("y", 2)])
+
+    def test_invalid_name(self):
+        # field name must be string
+        for name in b"x", 3, None:
+            with self.subTest(name=name):
+                with self.assertRaises(TypeError):
+                    class S(self.cls):
+                        _fields_ = [(name, c_int)]
+
+    def test_str_name(self):
+        class WeirdString(str):
+            def __str__(self):
+                return "unwanted value"
+        class S(self.cls):
+            _fields_ = [(WeirdString("f"), c_int)]
+        self.assertEqual(S.f.name, "f")
+
+    def test_intarray_fields(self):
+        class SomeInts(self.cls):
+            _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_huge_field_name(self):
+        # issue12881: segfault with large structure field names
+        def create_class(length):
+            class S(self.cls):
+                _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 test_abstract_class(self):
+        class X(self.cls):
+            _abstract_ = "something"
+        with self.assertRaisesRegex(TypeError, r"^abstract class$"):
+            X()
+
+    def test_methods(self):
+        self.assertIn("in_dll", dir(type(self.cls)))
+        self.assertIn("from_address", dir(type(self.cls)))
+        self.assertIn("in_dll", dir(type(self.cls)))
+
+    def test_pack_layout_switch(self):
+        # Setting _pack_ implicitly sets default layout to MSVC;
+        # this is deprecated on non-Windows platforms.
+        if MS_WINDOWS:
+            warn_context = contextlib.nullcontext()
+        else:
+            warn_context = self.assertWarns(DeprecationWarning)
+        with warn_context:
+            class X(self.cls):
+                _pack_ = 1
+                # _layout_ missing
+                _fields_ = [('a', c_int8, 1), ('b', c_int16, 2)]
+
+        # Check MSVC layout (bitfields of different types aren't combined)
+        self.check_sizeof(X, struct_size=3, union_size=2)
+
+
+class StructureTestCase(unittest.TestCase, StructUnionTestBase):
+    cls = Structure
+    metacls = PyCStructType
+
+    def test_metaclass_name(self):
+        self.assertEqual(self.metacls.__name__, "PyCStructType")
+
+    def check_sizeof(self, cls, *, struct_size, union_size):
+        self.assertEqual(sizeof(cls), struct_size)
+
+    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))
+
+
+class UnionTestCase(unittest.TestCase, StructUnionTestBase):
+    cls = Union
+    metacls = UnionType
+
+    def test_metaclass_name(self):
+        self.assertEqual(self.metacls.__name__, "UnionType")
+
+    def check_sizeof(self, cls, *, struct_size, union_size):
+        self.assertEqual(sizeof(cls), union_size)
+
+    def test_simple_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))
+
+
+class PointerMemberTestBase:
+    def test(self):
+        # a Structure/Union with a POINTER field
+        class S(self.cls):
+            _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])
+
+        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])
+
+class PointerMemberTestCase_Struct(unittest.TestCase, PointerMemberTestBase):
+    cls = Structure
+
+    def test_none_to_pointer_fields(self):
+        class S(self.cls):
+            _fields_ = [("x", c_int),
+                        ("p", POINTER(c_int))]
+
+        s = S()
+        s.x = 12345678
+        s.p = None
+        self.assertEqual(s.x, 12345678)
+
+class PointerMemberTestCase_Union(unittest.TestCase, PointerMemberTestBase):
+    cls = Union
+
+    def test_none_to_pointer_fields(self):
+        class S(self.cls):
+            _fields_ = [("x", c_int),
+                        ("p", POINTER(c_int))]
+
+        s = S()
+        s.x = 12345678
+        s.p = None
+        self.assertFalse(s.p)  # NULL pointers are falsy
+
+
+class TestRecursiveBase:
+    def test_contains_itself(self):
+        class Recursive(self.cls):
+            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(self.cls):
+            pass
+        class Second(self.cls):
+            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")
+
+class TestRecursiveStructure(unittest.TestCase, TestRecursiveBase):
+    cls = Structure
+
+class TestRecursiveUnion(unittest.TestCase, TestRecursiveBase):
+    cls = Union
diff --git a/Lib/test/test_ctypes/test_structures.py b/Lib/test/test_ctypes/test_structures.py
index 7650c80273f..92d4851d739 100644
--- a/Lib/test/test_ctypes/test_structures.py
+++ b/Lib/test/test_ctypes/test_structures.py
@@ -1,214 +1,32 @@
+"""Tests for ctypes.Structure
+
+Features common with Union should go in test_structunion.py instead.
+"""
+
 from platform import architecture as _architecture
 import struct
 import sys
 import unittest
-from ctypes import (CDLL, Array, Structure, Union, POINTER, sizeof, byref, alignment,
+from ctypes import (CDLL, Structure, Union, POINTER, sizeof, byref,
                     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)
+                    c_uint8, c_uint16, c_uint32, c_int, c_uint,
+                    c_long, c_ulong, c_longlong, 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
+from ._support import StructCheckMixin
 _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...
 
+class StructureTestCase(unittest.TestCase, StructCheckMixin):
     def test_packed(self):
         class X(Structure):
             _fields_ = [("a", c_byte),
                         ("b", c_longlong)]
             _pack_ = 1
+            _layout_ = 'ms'
+        self.check_struct(X)
 
         self.assertEqual(sizeof(X), 9)
         self.assertEqual(X.b.offset, 1)
@@ -217,6 +35,8 @@ class X(Structure):
             _fields_ = [("a", c_byte),
                         ("b", c_longlong)]
             _pack_ = 2
+            _layout_ = 'ms'
+        self.check_struct(X)
         self.assertEqual(sizeof(X), 10)
         self.assertEqual(X.b.offset, 2)
 
@@ -227,6 +47,8 @@ class X(Structure):
             _fields_ = [("a", c_byte),
                         ("b", c_longlong)]
             _pack_ = 4
+            _layout_ = 'ms'
+        self.check_struct(X)
         self.assertEqual(sizeof(X), min(4, longlong_align) + longlong_size)
         self.assertEqual(X.b.offset, min(4, longlong_align))
 
@@ -234,26 +56,33 @@ class X(Structure):
             _fields_ = [("a", c_byte),
                         ("b", c_longlong)]
             _pack_ = 8
+            _layout_ = 'ms'
+        self.check_struct(X)
 
         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)
+        with self.assertRaises(ValueError):
+            class X(Structure):
+                _fields_ = [("a", "b"), ("b", "q")]
+                _pack_ = -1
+                _layout_ = "ms"
 
     @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)
+        with self.assertRaises(ValueError):
+            class X(Structure):
+                _fields_ = [("a", c_byte)]
+                _pack_ = _testcapi.INT_MAX + 1
+                _layout_ = "ms"
+
+        with self.assertRaises(ValueError):
+            class X(Structure):
+                _fields_ = [("a", c_byte)]
+                _pack_ = _testcapi.UINT_MAX + 2
+                _layout_ = "ms"
 
     def test_initializers(self):
         class Person(Structure):
@@ -274,6 +103,7 @@ class Person(Structure):
     def test_conflicting_initializers(self):
         class POINT(Structure):
             _fields_ = [("phi", c_float), ("rho", c_float)]
+        self.check_struct(POINT)
         # conflicting positional and keyword args
         self.assertRaisesRegex(TypeError, "phi", POINT, 2, 3, phi=4)
         self.assertRaisesRegex(TypeError, "rho", POINT, 2, 3, rho=4)
@@ -284,52 +114,25 @@ class POINT(Structure):
     def test_keyword_initializers(self):
         class POINT(Structure):
             _fields_ = [("x", c_int), ("y", c_int)]
+        self.check_struct(POINT)
         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)]
+        self.check_struct(Phone)
 
         class Person(Structure):
             _fields_ = [("name", c_char * 12),
                         ("phone", Phone),
                         ("age", c_int)]
+        self.check_struct(Person)
 
         p = Person(b"Someone", (b"1234", b"5678"), 5)
 
@@ -342,6 +145,7 @@ def test_structures_with_wchar(self):
         class PersonW(Structure):
             _fields_ = [("name", c_wchar * 12),
                         ("age", c_int)]
+        self.check_struct(PersonW)
 
         p = PersonW("Someone \xe9")
         self.assertEqual(p.name, "Someone \xe9")
@@ -357,11 +161,13 @@ def test_init_errors(self):
         class Phone(Structure):
             _fields_ = [("areacode", c_char*6),
                         ("number", c_char*12)]
+        self.check_struct(Phone)
 
         class Person(Structure):
             _fields_ = [("name", c_char * 12),
                         ("phone", Phone),
                         ("age", c_int)]
+        self.check_struct(Person)
 
         cls, msg = self.get_except(Person, b"Someone", (1, 2))
         self.assertEqual(cls, RuntimeError)
@@ -374,47 +180,29 @@ class Person(Structure):
         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)]
+        self.check_struct(W)
+
         class X(W):
             _fields_ = [("c", c_int)]
+        self.check_struct(X)
+
         class Y(X):
             pass
+        self.check_struct(Y)
+
         class Z(Y):
             _fields_ = [("d", c_int), ("e", c_int), ("f", c_int)]
+        self.check_struct(Z)
 
         z = Z(1, 2, 3, 4, 5, 6)
         self.assertEqual((z.a, z.b, z.c, z.d, z.e, z.f),
@@ -433,6 +221,7 @@ class Test(Structure):
                 ('second', c_ulong),
                 ('third', c_ulong),
             ]
+        self.check_struct(Test)
 
         s = Test()
         s.first = 0xdeadbeef
@@ -462,6 +251,7 @@ class Test(Structure):
             ]
             def __del__(self):
                 finalizer_calls.append("called")
+        self.check_struct(Test)
 
         s = Test(1, 2, 3)
         # Test the StructUnionType_paramfunc() code path which copies the
@@ -491,6 +281,7 @@ class X(Structure):
                 ('first', c_uint),
                 ('second', c_uint)
             ]
+        self.check_struct(X)
 
         s = X()
         s.first = 0xdeadbeef
@@ -502,11 +293,15 @@ class X(Structure):
         func(s)
         self.assertEqual(s.first, 0xdeadbeef)
         self.assertEqual(s.second, 0xcafebabe)
-        got = X.in_dll(dll, "last_tfrsuv_arg")
+        dll.get_last_tfrsuv_arg.argtypes = ()
+        dll.get_last_tfrsuv_arg.restype = X
+        got = dll.get_last_tfrsuv_arg()
         self.assertEqual(s.first, got.first)
         self.assertEqual(s.second, got.second)
 
     def _test_issue18060(self, Vector):
+        # Regression tests for gh-62260
+
         # The call to atan2() should succeed if the
         # class fields were correctly cloned in the
         # subclasses. Otherwise, it will segfault.
@@ -577,36 +372,43 @@ class Test2(Structure):
             _fields_ = [
                 ('data', c_ubyte * 16),
             ]
+        self.check_struct(Test2)
 
         class Test3AParent(Structure):
             _fields_ = [
                 ('data', c_float * 2),
             ]
+        self.check_struct(Test3AParent)
 
         class Test3A(Test3AParent):
             _fields_ = [
                 ('more_data', c_float * 2),
             ]
+        self.check_struct(Test3A)
 
         class Test3B(Structure):
             _fields_ = [
                 ('data', c_double * 2),
             ]
+        self.check_struct(Test3B)
 
         class Test3C(Structure):
             _fields_ = [
                 ("data", c_double * 4)
             ]
+        self.check_struct(Test3C)
 
         class Test3D(Structure):
             _fields_ = [
                 ("data", c_double * 8)
             ]
+        self.check_struct(Test3D)
 
         class Test3E(Structure):
             _fields_ = [
                 ("data", c_double * 9)
             ]
+        self.check_struct(Test3E)
 
 
         # Tests for struct Test2
@@ -698,12 +500,15 @@ class Test3E(Structure):
                 self.assertEqual(result.data[i], float(i+1))
 
     def test_38368(self):
+        # Regression test for gh-82549
         class U(Union):
             _fields_ = [
                 ('f1', c_uint8 * 16),
                 ('f2', c_uint16 * 8),
                 ('f3', c_uint32 * 4),
             ]
+        self.check_union(U)
+
         u = U()
         u.f3[0] = 0x01234567
         u.f3[1] = 0x89ABCDEF
@@ -719,9 +524,9 @@ class U(Union):
             self.assertEqual(f2, [0x4567, 0x0123, 0xcdef, 0x89ab,
                                   0x3210, 0x7654, 0xba98, 0xfedc])
 
-    @unittest.skipIf(True, 'Test disabled for now - see bpo-16575/bpo-16576')
+    @unittest.skipIf(True, 'Test disabled for now - see gh-60779/gh-60780')
     def test_union_by_value(self):
-        # See bpo-16575
+        # See gh-60779
 
         # These should mirror the structures in Modules/_ctypes/_ctypes_test.c
 
@@ -730,18 +535,21 @@ class Nested1(Structure):
                 ('an_int', c_int),
                 ('another_int', c_int),
             ]
+        self.check_struct(Nested1)
 
         class Test4(Union):
             _fields_ = [
                 ('a_long', c_long),
                 ('a_struct', Nested1),
             ]
+        self.check_struct(Test4)
 
         class Nested2(Structure):
             _fields_ = [
                 ('an_int', c_int),
                 ('a_union', Test4),
             ]
+        self.check_struct(Nested2)
 
         class Test5(Structure):
             _fields_ = [
@@ -749,6 +557,7 @@ class Test5(Structure):
                 ('nested', Nested2),
                 ('another_int', c_int),
             ]
+        self.check_struct(Test5)
 
         test4 = Test4()
         dll = CDLL(_ctypes_test.__file__)
@@ -800,9 +609,9 @@ class Test5(Structure):
         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')
+    @unittest.skipIf(True, 'Test disabled for now - see gh-60779/gh-60780')
     def test_bitfield_by_value(self):
-        # See bpo-16576
+        # See gh-60780
 
         # These should mirror the structures in Modules/_ctypes/_ctypes_test.c
 
@@ -813,6 +622,7 @@ class Test6(Structure):
                 ('C', c_int, 3),
                 ('D', c_int, 2),
             ]
+        self.check_struct(Test6)
 
         test6 = Test6()
         # As these are signed int fields, all are logically -1 due to sign
@@ -848,6 +658,8 @@ class Test7(Structure):
                 ('C', c_uint, 3),
                 ('D', c_uint, 2),
             ]
+        self.check_struct(Test7)
+
         test7 = Test7()
         test7.A = 1
         test7.B = 3
@@ -871,6 +683,7 @@ class Test8(Union):
                 ('C', c_int, 3),
                 ('D', c_int, 2),
             ]
+        self.check_union(Test8)
 
         test8 = Test8()
         with self.assertRaises(TypeError) as ctx:
@@ -881,75 +694,29 @@ class Test8(Union):
         self.assertEqual(ctx.exception.args[0], 'item 1 in _argtypes_ passes '
                          'a union by value, which is unsupported.')
 
+    def test_do_not_share_pointer_type_cache_via_stginfo_clone(self):
+        # This test case calls PyCStgInfo_clone()
+        # for the Mid and Vector class definitions
+        # and checks that pointer_type cache not shared
+        # between subclasses.
+        class Base(Structure):
+            _fields_ = [('y', c_double),
+                        ('x', c_double)]
+        base_ptr = POINTER(Base)
 
-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):
+        class Mid(Base):
             pass
+        Mid._fields_ = []
+        mid_ptr = POINTER(Mid)
 
-        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):
+        class Vector(Mid):
             pass
 
-        First._fields_ = [("second", Second)]
+        vector_ptr = POINTER(Vector)
 
-        try:
-            Second._fields_ = [("first", First)]
-        except AttributeError as details:
-            self.assertIn("_fields_ is final", str(details))
-        else:
-            self.fail("AttributeError not raised")
+        self.assertIsNot(base_ptr, mid_ptr)
+        self.assertIsNot(base_ptr, vector_ptr)
+        self.assertIsNot(mid_ptr, vector_ptr)
 
 
 if __name__ == '__main__':
diff --git a/Lib/test/test_ctypes/test_unaligned_structures.py b/Lib/test/test_ctypes/test_unaligned_structures.py
index 58a00597ef5..b5fb4c0df77 100644
--- a/Lib/test/test_ctypes/test_unaligned_structures.py
+++ b/Lib/test/test_ctypes/test_unaligned_structures.py
@@ -19,10 +19,12 @@
             c_ushort, c_uint, c_ulong, c_ulonglong]:
     class X(Structure):
         _pack_ = 1
+        _layout_ = 'ms'
         _fields_ = [("pad", c_byte),
                     ("value", typ)]
     class Y(SwappedStructure):
         _pack_ = 1
+        _layout_ = 'ms'
         _fields_ = [("pad", c_byte),
                     ("value", typ)]
     structures.append(X)
diff --git a/Lib/test/test_ctypes/test_values.py b/Lib/test/test_ctypes/test_values.py
index e0d200e2101..18554e193be 100644
--- a/Lib/test/test_ctypes/test_values.py
+++ b/Lib/test/test_ctypes/test_values.py
@@ -7,9 +7,8 @@
 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
+from test.support import import_helper, thread_unsafe
 
 
 class ValuesTestCase(unittest.TestCase):
@@ -18,6 +17,7 @@ def setUp(self):
         _ctypes_test = import_helper.import_module("_ctypes_test")
         self.ctdll = CDLL(_ctypes_test.__file__)
 
+    @thread_unsafe("static global variables aren't thread-safe")
     def test_an_integer(self):
         # This test checks and changes an integer stored inside the
         # _ctypes_test dll/shared lib.
@@ -39,7 +39,7 @@ def test_undefined(self):
 class PythonValuesTestCase(unittest.TestCase):
     """This test only works when python itself is a dll/shared library"""
 
-    # TODO: RUSTPYTHON
+    # TODO: RUSTPYTHON - requires pythonapi (Python C API)
     @unittest.expectedFailure
     def test_optimizeflag(self):
         # This test accesses the Py_OptimizeFlag integer, which is
@@ -48,8 +48,9 @@ def test_optimizeflag(self):
         opt = c_int.in_dll(pythonapi, "Py_OptimizeFlag").value
         self.assertEqual(opt, sys.flags.optimize)
 
-    # TODO: RUSTPYTHON
+    # TODO: RUSTPYTHON - requires pythonapi (Python C API)
     @unittest.expectedFailure
+    @thread_unsafe('overrides frozen modules')
     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
@@ -100,8 +101,6 @@ class struct_frozen(Structure):
                          "_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")
diff --git a/Lib/test/test_ctypes/test_win32.py b/Lib/test/test_ctypes/test_win32.py
index 4de4f0379cf..bb2fc0ca222 100644
--- a/Lib/test/test_ctypes/test_win32.py
+++ b/Lib/test/test_ctypes/test_win32.py
@@ -5,7 +5,6 @@
 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
@@ -14,11 +13,11 @@
 
 @unittest.skipUnless(sys.platform == "win32", 'Windows-specific test')
 class FunctionCallTestCase(unittest.TestCase):
+    # TODO: RUSTPYTHON: SEH not implemented, crashes with STATUS_ACCESS_VIOLATION
+    @unittest.skip("TODO: RUSTPYTHON")
     @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"
@@ -67,15 +66,16 @@ def test_PARAM(self):
                              sizeof(c_void_p))
 
     def test_COMError(self):
-        from _ctypes import COMError
+        from ctypes import COMError
         if support.HAVE_DOCSTRINGS:
             self.assertEqual(COMError.__doc__,
                              "Raised when a COM method call failed.")
 
-        ex = COMError(-1, "text", ("details",))
+        ex = COMError(-1, "text", ("descr", "source", "helpfile", 0, "progid"))
         self.assertEqual(ex.hresult, -1)
         self.assertEqual(ex.text, "text")
-        self.assertEqual(ex.details, ("details",))
+        self.assertEqual(ex.details,
+                         ("descr", "source", "helpfile", 0, "progid"))
 
         self.assertEqual(COMError.mro(),
                          [COMError, Exception, BaseException, object])
@@ -146,8 +146,8 @@ class RECT(Structure):
             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]
+        self.assertIs(PointInRect.argtypes[0], ReturnRect.argtypes[2])
+        self.assertIs(PointInRect.argtypes[0], ReturnRect.argtypes[5])
 
 
 if __name__ == '__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
index b12e09333bd..01db602149b 100644
--- a/Lib/test/test_ctypes/test_win32_com_foreign_func.py
+++ b/Lib/test/test_ctypes/test_win32_com_foreign_func.py
@@ -9,8 +9,7 @@
     raise unittest.SkipTest("Windows-specific test")
 
 
-from _ctypes import COMError, CopyComPointer
-from ctypes import HRESULT
+from ctypes import COMError, CopyComPointer, HRESULT
 
 
 COINIT_APARTMENTTHREADED = 0x2
@@ -158,8 +157,7 @@ class IPersist(IUnknown):
 
         self.assertEqual(0, ppst.Release())
 
-    # TODO: RUSTPYTHON - COM iid parameter handling not implemented
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; - COM iid parameter handling not implemented
     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_dataclasses/__init__.py b/Lib/test/test_dataclasses/__init__.py
index 4db73a64e73..dfe6b89f1ed 100644
--- a/Lib/test/test_dataclasses/__init__.py
+++ b/Lib/test/test_dataclasses/__init__.py
@@ -5,6 +5,7 @@
 from dataclasses import *
 
 import abc
+import annotationlib
 import io
 import pickle
 import inspect
@@ -12,18 +13,21 @@
 import types
 import weakref
 import traceback
+import sys
+import textwrap
 import unittest
 from unittest.mock import Mock
 from typing import ClassVar, Any, List, Union, Tuple, Dict, Generic, TypeVar, Optional, Protocol, DefaultDict
 from typing import get_type_hints
 from collections import deque, OrderedDict, namedtuple, defaultdict
 from copy import deepcopy
-from functools import total_ordering
+from functools import total_ordering, wraps
 
 import typing       # Needed for the string "typing.ClassVar[int]" to work as an annotation.
 import dataclasses  # Needed for the string "dataclasses.InitVar[int]" to work as an annotation.
 
 from test import support
+from test.support import import_helper
 
 # Just any custom exception we can catch.
 class CustomError(Exception): pass
@@ -61,7 +65,7 @@ class C:
                 x: int = field(default=1, default_factory=int)
 
     def test_field_repr(self):
-        int_field = field(default=1, init=True, repr=False)
+        int_field = field(default=1, init=True, repr=False, doc='Docstring')
         int_field.name = "id"
         repr_output = repr(int_field)
         expected_output = "Field(name='id',type=None," \
@@ -69,6 +73,7 @@ def test_field_repr(self):
                            "init=True,repr=False,hash=None," \
                            "compare=True,metadata=mappingproxy({})," \
                            f"kw_only={MISSING!r}," \
+                           "doc='Docstring'," \
                            "_field_type=None)"
 
         self.assertEqual(repr_output, expected_output)
@@ -115,7 +120,7 @@ class Some: pass
         for param in inspect.signature(dataclass).parameters:
             if param == 'cls':
                 continue
-            self.assertTrue(hasattr(Some.__dataclass_params__, param), msg=param)
+            self.assertHasAttr(Some.__dataclass_params__, param)
 
     def test_named_init_params(self):
         @dataclass
@@ -666,7 +671,7 @@ class C:
 
         self.assertEqual(the_fields[0].name, 'x')
         self.assertEqual(the_fields[0].type, int)
-        self.assertFalse(hasattr(C, 'x'))
+        self.assertNotHasAttr(C, 'x')
         self.assertTrue (the_fields[0].init)
         self.assertTrue (the_fields[0].repr)
         self.assertEqual(the_fields[1].name, 'y')
@@ -676,7 +681,7 @@ class C:
         self.assertTrue (the_fields[1].repr)
         self.assertEqual(the_fields[2].name, 'z')
         self.assertEqual(the_fields[2].type, str)
-        self.assertFalse(hasattr(C, 'z'))
+        self.assertNotHasAttr(C, 'z')
         self.assertTrue (the_fields[2].init)
         self.assertFalse(the_fields[2].repr)
 
@@ -727,8 +732,8 @@ class C:
             z: object = default
             t: int = field(default=100)
 
-        self.assertFalse(hasattr(C, 'x'))
-        self.assertFalse(hasattr(C, 'y'))
+        self.assertNotHasAttr(C, 'x')
+        self.assertNotHasAttr(C, 'y')
         self.assertIs   (C.z, default)
         self.assertEqual(C.t, 100)
 
@@ -922,6 +927,20 @@ class C:
 
         validate_class(C)
 
+    def test_incomplete_annotations(self):
+        # gh-142214
+        @dataclass
+        class C:
+            "doc"  # needed because otherwise we fetch the annotations at the wrong time
+            x: int
+
+        C.__annotate__ = lambda _: {}
+
+        self.assertEqual(
+            annotationlib.get_annotations(C.__init__),
+            {"return": None}
+        )
+
     def test_missing_default(self):
         # Test that MISSING works the same as a default not being
         #  specified.
@@ -1776,8 +1795,7 @@ class C:
         self.assertIsNot(d['f'], t)
         self.assertEqual(d['f'].my_a(), 6)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_helper_asdict_defaultdict(self):
         # Ensure asdict() does not throw exceptions when a
         # defaultdict is a member of a dataclass
@@ -1920,8 +1938,7 @@ class C:
         t = astuple(c, tuple_factory=list)
         self.assertEqual(t, ['outer', T(1, ['inner', T(11, 12, 13)], 2)])
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_helper_astuple_defaultdict(self):
         # Ensure astuple() does not throw exceptions when a
         # defaultdict is a member of a dataclass
@@ -2311,13 +2328,12 @@ 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:
             x: Union[int, type(None)] = None
 
-        self.assertDocStrEqual(C.__doc__, "C(x:Optional[int]=None)")
+        self.assertDocStrEqual(C.__doc__, "C(x:int|None=None)")
 
     def test_docstring_list_field(self):
         @dataclass
@@ -2347,6 +2363,31 @@ class C:
 
         self.assertDocStrEqual(C.__doc__, "C(x:collections.deque=<factory>)")
 
+    def test_docstring_undefined_name(self):
+        @dataclass
+        class C:
+            x: undef
+
+        self.assertDocStrEqual(C.__doc__, "C(x:undef)")
+
+    def test_docstring_with_unsolvable_forward_ref_in_init(self):
+        # See: https://github.com/python/cpython/issues/128184
+        ns = {}
+        exec(
+            textwrap.dedent(
+                """
+                from dataclasses import dataclass
+
+                @dataclass
+                class C:
+                    def __init__(self, x: X, num: int) -> None: ...
+                """,
+            ),
+            ns,
+        )
+
+        self.assertDocStrEqual(ns['C'].__doc__, "C(x:X,num:int)")
+
     def test_docstring_with_no_signature(self):
         # See https://github.com/python/cpython/issues/103449
         class Meta(type):
@@ -2446,6 +2487,149 @@ def __init__(self, a):
         self.assertEqual(D(5).a, 10)
 
 
+class TestInitAnnotate(unittest.TestCase):
+    # Tests for the generated __annotate__ function for __init__
+    # See: https://github.com/python/cpython/issues/137530
+
+    def test_annotate_function(self):
+        # No forward references
+        @dataclass
+        class A:
+            a: int
+
+        value_annos = annotationlib.get_annotations(A.__init__, format=annotationlib.Format.VALUE)
+        forwardref_annos = annotationlib.get_annotations(A.__init__, format=annotationlib.Format.FORWARDREF)
+        string_annos = annotationlib.get_annotations(A.__init__, format=annotationlib.Format.STRING)
+
+        self.assertEqual(value_annos, {'a': int, 'return': None})
+        self.assertEqual(forwardref_annos, {'a': int, 'return': None})
+        self.assertEqual(string_annos, {'a': 'int', 'return': 'None'})
+
+        self.assertTrue(getattr(A.__init__.__annotate__, "__generated_by_dataclasses__"))
+
+    def test_annotate_function_forwardref(self):
+        # With forward references
+        @dataclass
+        class B:
+            b: undefined
+
+        # VALUE annotations should raise while unresolvable
+        with self.assertRaises(NameError):
+            _ = annotationlib.get_annotations(B.__init__, format=annotationlib.Format.VALUE)
+
+        forwardref_annos = annotationlib.get_annotations(B.__init__, format=annotationlib.Format.FORWARDREF)
+        string_annos = annotationlib.get_annotations(B.__init__, format=annotationlib.Format.STRING)
+
+        self.assertEqual(forwardref_annos, {'b': support.EqualToForwardRef('undefined', owner=B, is_class=True), 'return': None})
+        self.assertEqual(string_annos, {'b': 'undefined', 'return': 'None'})
+
+        # Now VALUE and FORWARDREF should resolve, STRING should be unchanged
+        undefined = int
+
+        value_annos = annotationlib.get_annotations(B.__init__, format=annotationlib.Format.VALUE)
+        forwardref_annos = annotationlib.get_annotations(B.__init__, format=annotationlib.Format.FORWARDREF)
+        string_annos = annotationlib.get_annotations(B.__init__, format=annotationlib.Format.STRING)
+
+        self.assertEqual(value_annos, {'b': int, 'return': None})
+        self.assertEqual(forwardref_annos, {'b': int, 'return': None})
+        self.assertEqual(string_annos, {'b': 'undefined', 'return': 'None'})
+
+    def test_annotate_function_init_false(self):
+        # Check `init=False` attributes don't get into the annotations of the __init__ function
+        @dataclass
+        class C:
+            c: str = field(init=False)
+
+        self.assertEqual(annotationlib.get_annotations(C.__init__), {'return': None})
+
+    def test_annotate_function_contains_forwardref(self):
+        # Check string annotations on objects containing a ForwardRef
+        @dataclass
+        class D:
+            d: list[undefined]
+
+        with self.assertRaises(NameError):
+            annotationlib.get_annotations(D.__init__)
+
+        self.assertEqual(
+            annotationlib.get_annotations(D.__init__, format=annotationlib.Format.FORWARDREF),
+            {"d": list[support.EqualToForwardRef("undefined", is_class=True, owner=D)], "return": None}
+        )
+
+        self.assertEqual(
+            annotationlib.get_annotations(D.__init__, format=annotationlib.Format.STRING),
+            {"d": "list[undefined]", "return": "None"}
+        )
+
+        # Now test when it is defined
+        undefined = str
+
+        # VALUE should now resolve
+        self.assertEqual(
+            annotationlib.get_annotations(D.__init__),
+            {"d": list[str], "return": None}
+        )
+
+        self.assertEqual(
+            annotationlib.get_annotations(D.__init__, format=annotationlib.Format.FORWARDREF),
+            {"d": list[str], "return": None}
+        )
+
+        self.assertEqual(
+            annotationlib.get_annotations(D.__init__, format=annotationlib.Format.STRING),
+            {"d": "list[undefined]", "return": "None"}
+        )
+
+    def test_annotate_function_not_replaced(self):
+        # Check that __annotate__ is not replaced on non-generated __init__ functions
+        @dataclass(slots=True)
+        class E:
+            x: str
+            def __init__(self, x: int) -> None:
+                self.x = x
+
+        self.assertEqual(
+            annotationlib.get_annotations(E.__init__), {"x": int, "return": None}
+        )
+
+        self.assertFalse(hasattr(E.__init__.__annotate__, "__generated_by_dataclasses__"))
+
+    def test_slots_true_init_false(self):
+        # Test that slots=True and init=False work together and
+        #  that __annotate__ is not added to __init__.
+
+        @dataclass(slots=True, init=False)
+        class F:
+            x: int
+
+        f = F()
+        f.x = 10
+        self.assertEqual(f.x, 10)
+
+        self.assertFalse(hasattr(F.__init__, "__annotate__"))
+
+    def test_init_false_forwardref(self):
+        # Test forward references in fields not required for __init__ annotations.
+
+        # At the moment this raises a NameError for VALUE annotations even though the
+        # undefined annotation is not required for the __init__ annotations.
+        # Ideally this will be fixed but currently there is no good way to resolve this
+
+        @dataclass
+        class F:
+            not_in_init: list[undefined] = field(init=False, default=None)
+            in_init: int
+
+        annos = annotationlib.get_annotations(F.__init__, format=annotationlib.Format.FORWARDREF)
+        self.assertEqual(
+            annos,
+            {"in_init": int, "return": None},
+        )
+
+        with self.assertRaises(NameError):
+            annos = annotationlib.get_annotations(F.__init__)  # NameError on not_in_init
+
+
 class TestRepr(unittest.TestCase):
     def test_repr(self):
         @dataclass
@@ -2887,10 +3071,10 @@ class C:
             pass
 
         c = C()
-        self.assertFalse(hasattr(c, 'i'))
+        self.assertNotHasAttr(c, 'i')
         with self.assertRaises(FrozenInstanceError):
             c.i = 5
-        self.assertFalse(hasattr(c, 'i'))
+        self.assertNotHasAttr(c, 'i')
         with self.assertRaises(FrozenInstanceError):
             del c.i
 
@@ -3119,7 +3303,7 @@ class S(D):
             del s.y
         self.assertEqual(s.y, 10)
         del s.cached
-        self.assertFalse(hasattr(s, 'cached'))
+        self.assertNotHasAttr(s, 'cached')
         with self.assertRaises(AttributeError) as cm:
             del s.cached
         self.assertNotIsInstance(cm.exception, FrozenInstanceError)
@@ -3133,12 +3317,12 @@ class S(D):
             pass
 
         s = S()
-        self.assertFalse(hasattr(s, 'x'))
+        self.assertNotHasAttr(s, 'x')
         s.x = 5
         self.assertEqual(s.x, 5)
 
         del s.x
-        self.assertFalse(hasattr(s, 'x'))
+        self.assertNotHasAttr(s, 'x')
         with self.assertRaises(AttributeError) as cm:
             del s.x
         self.assertNotIsInstance(cm.exception, FrozenInstanceError)
@@ -3309,7 +3493,7 @@ class Base(Root4):
             j: str
             h: str
 
-        self.assertEqual(Base.__slots__, ('y', ))
+        self.assertEqual(Base.__slots__, ('y',))
 
         @dataclass(slots=True)
         class Derived(Base):
@@ -3319,7 +3503,7 @@ class Derived(Base):
             k: str
             h: str
 
-        self.assertEqual(Derived.__slots__, ('z', ))
+        self.assertEqual(Derived.__slots__, ('z',))
 
         @dataclass
         class AnotherDerived(Base):
@@ -3327,6 +3511,24 @@ class AnotherDerived(Base):
 
         self.assertNotIn('__slots__', AnotherDerived.__dict__)
 
+    def test_slots_with_docs(self):
+        class Root:
+            __slots__ = {'x': 'x'}
+
+        @dataclass(slots=True)
+        class Base(Root):
+            y1: int = field(doc='y1')
+            y2: int
+
+        self.assertEqual(Base.__slots__, {'y1': 'y1', 'y2': None})
+
+        @dataclass(slots=True)
+        class Child(Base):
+            z1: int = field(doc='z1')
+            z2: int
+
+        self.assertEqual(Child.__slots__, {'z1': 'z1', 'z2': None})
+
     def test_cant_inherit_from_iterator_slots(self):
 
         class Root:
@@ -3350,8 +3552,8 @@ class A:
         B = dataclass(A, slots=True)
         self.assertIsNot(A, B)
 
-        self.assertFalse(hasattr(A, "__slots__"))
-        self.assertTrue(hasattr(B, "__slots__"))
+        self.assertNotHasAttr(A, "__slots__")
+        self.assertHasAttr(B, "__slots__")
 
     # Can't be local to test_frozen_pickle.
     @dataclass(frozen=True, slots=True)
@@ -3470,8 +3672,6 @@ class A:
         self.assertEqual(obj.a, 'a')
         self.assertEqual(obj.b, 'b')
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_slots_no_weakref(self):
         @dataclass(slots=True)
         class A:
@@ -3486,8 +3686,6 @@ class A:
         with self.assertRaises(AttributeError):
             a.__weakref__
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_slots_weakref(self):
         @dataclass(slots=True, weakref_slot=True)
         class A:
@@ -3548,8 +3746,6 @@ def test_weakref_slot_make_dataclass(self):
                                     "weakref_slot is True but slots is False"):
             B = make_dataclass('B', [('a', int),], weakref_slot=True)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_weakref_slot_subclass_weakref_slot(self):
         @dataclass(slots=True, weakref_slot=True)
         class Base:
@@ -3568,8 +3764,6 @@ class A(Base):
         a_ref = weakref.ref(a)
         self.assertIs(a.__weakref__, a_ref)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_weakref_slot_subclass_no_weakref_slot(self):
         @dataclass(slots=True, weakref_slot=True)
         class Base:
@@ -3587,8 +3781,6 @@ class A(Base):
         a_ref = weakref.ref(a)
         self.assertIs(a.__weakref__, a_ref)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_weakref_slot_normal_base_weakref_slot(self):
         class Base:
             __slots__ = ('__weakref__',)
@@ -3633,8 +3825,6 @@ class B[T2]:
         self.assertTrue(B.__weakref__)
         B()
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_dataclass_derived_generic_from_base(self):
         T = typing.TypeVar('T')
 
@@ -3726,7 +3916,6 @@ class A(WithDictSlot): ...
     @support.cpython_only
     def test_dataclass_slot_dict_ctype(self):
         # https://github.com/python/cpython/issues/123935
-        from test.support import import_helper
         # Skips test if `_testcapi` is not present:
         _testcapi = import_helper.import_module('_testcapi')
 
@@ -3774,6 +3963,50 @@ class WithCorrectSuper(CorrectSuper):
         # that we create internally.
         self.assertEqual(CorrectSuper.args, ["default", "default"])
 
+    @unittest.skip("TODO: RUSTPYTHON; Crash - static type name must be already interned but async_generator_wrapped_value is not")
+    def test_original_class_is_gced(self):
+        # gh-135228: Make sure when we replace the class with slots=True, the original class
+        # gets garbage collected.
+        def make_simple():
+            @dataclass(slots=True)
+            class SlotsTest:
+                pass
+
+            return SlotsTest
+
+        def make_with_annotations():
+            @dataclass(slots=True)
+            class SlotsTest:
+                x: int
+
+            return SlotsTest
+
+        def make_with_annotations_and_method():
+            @dataclass(slots=True)
+            class SlotsTest:
+                x: int
+
+                def method(self) -> int:
+                    return self.x
+
+            return SlotsTest
+
+        def make_with_forwardref():
+            @dataclass(slots=True)
+            class SlotsTest:
+                x: undefined
+                y: list[undefined]
+
+            return SlotsTest
+
+        for make in (make_simple, make_with_annotations, make_with_annotations_and_method, make_with_forwardref):
+            with self.subTest(make=make):
+                C = make()
+                support.gc_collect()
+                candidates = [cls for cls in object.__subclasses__() if cls.__name__ == 'SlotsTest'
+                              and cls.__firstlineno__ == make.__code__.co_firstlineno + 1]
+                self.assertEqual(candidates, [C])
+
 
 class TestDescriptors(unittest.TestCase):
     def test_set_name(self):
@@ -4218,16 +4451,56 @@ def test_no_types(self):
         C = make_dataclass('Point', ['x', 'y', 'z'])
         c = C(1, 2, 3)
         self.assertEqual(vars(c), {'x': 1, 'y': 2, 'z': 3})
-        self.assertEqual(C.__annotations__, {'x': 'typing.Any',
-                                             'y': 'typing.Any',
-                                             'z': 'typing.Any'})
+        self.assertEqual(C.__annotations__, {'x': typing.Any,
+                                             'y': typing.Any,
+                                             'z': typing.Any})
 
         C = make_dataclass('Point', ['x', ('y', int), 'z'])
         c = C(1, 2, 3)
         self.assertEqual(vars(c), {'x': 1, 'y': 2, 'z': 3})
-        self.assertEqual(C.__annotations__, {'x': 'typing.Any',
+        self.assertEqual(C.__annotations__, {'x': typing.Any,
                                              'y': int,
-                                             'z': 'typing.Any'})
+                                             'z': typing.Any})
+
+    def test_no_types_get_annotations(self):
+        C = make_dataclass('C', ['x', ('y', int), 'z'])
+
+        self.assertEqual(
+            annotationlib.get_annotations(C, format=annotationlib.Format.VALUE),
+            {'x': typing.Any, 'y': int, 'z': typing.Any},
+        )
+        self.assertEqual(
+            annotationlib.get_annotations(
+                C, format=annotationlib.Format.FORWARDREF),
+            {'x': typing.Any, 'y': int, 'z': typing.Any},
+        )
+        self.assertEqual(
+            annotationlib.get_annotations(
+                C, format=annotationlib.Format.STRING),
+            {'x': 'typing.Any', 'y': 'int', 'z': 'typing.Any'},
+        )
+
+    def test_no_types_no_typing_import(self):
+        with import_helper.CleanImport('typing'):
+            self.assertNotIn('typing', sys.modules)
+            C = make_dataclass('C', ['x', ('y', int)])
+
+            self.assertNotIn('typing', sys.modules)
+            self.assertEqual(
+                C.__annotate__(annotationlib.Format.FORWARDREF),
+                {
+                    'x': annotationlib.ForwardRef('Any', module='typing'),
+                    'y': int,
+                },
+            )
+            self.assertNotIn('typing', sys.modules)
+
+            for field in fields(C):
+                if field.name == "x":
+                    self.assertEqual(field.type, annotationlib.ForwardRef('Any', module='typing'))
+                else:
+                    self.assertEqual(field.name, "y")
+                    self.assertIs(field.type, int)
 
     def test_module_attr(self):
         self.assertEqual(ByMakeDataClass.__module__, __name__)
@@ -4314,6 +4587,23 @@ def test_funny_class_names_names(self):
                 C = make_dataclass(classname, ['a', 'b'])
                 self.assertEqual(C.__name__, classname)
 
+    def test_dataclass_decorator_default(self):
+        C = make_dataclass('C', [('x', int)], decorator=dataclass)
+        c = C(10)
+        self.assertEqual(c.x, 10)
+
+    def test_dataclass_custom_decorator(self):
+        def custom_dataclass(cls, *args, **kwargs):
+            dc = dataclass(cls, *args, **kwargs)
+            dc.__custom__ = True
+            return dc
+
+        C = make_dataclass('C', [('x', int)], decorator=custom_dataclass)
+        c = C(10)
+        self.assertEqual(c.x, 10)
+        self.assertEqual(c.__custom__, True)
+
+
 class TestReplace(unittest.TestCase):
     def test(self):
         @dataclass(frozen=True)
@@ -4562,8 +4852,7 @@ class Date(Ordered):
         self.assertFalse(inspect.isabstract(Date))
         self.assertGreater(Date(2020,12,25), Date(2020,8,31))
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_maintain_abc(self):
         class A(abc.ABC):
             @abc.abstractmethod
@@ -4919,6 +5208,140 @@ def test_make_dataclass(self):
         self.assertTrue(fields(B)[0].kw_only)
         self.assertFalse(fields(B)[1].kw_only)
 
+    def test_deferred_annotations(self):
+        @dataclass
+        class A:
+            x: undefined
+            y: ClassVar[undefined]
+
+        fs = fields(A)
+        self.assertEqual(len(fs), 1)
+        self.assertEqual(fs[0].name, 'x')
+
+
+class TestZeroArgumentSuperWithSlots(unittest.TestCase):
+    def test_zero_argument_super(self):
+        @dataclass(slots=True)
+        class A:
+            def foo(self):
+                super()
+
+        A().foo()
+
+    def test_dunder_class_with_old_property(self):
+        @dataclass(slots=True)
+        class A:
+            def _get_foo(slf):
+                self.assertIs(__class__, type(slf))
+                self.assertIs(__class__, slf.__class__)
+                return __class__
+
+            def _set_foo(slf, value):
+                self.assertIs(__class__, type(slf))
+                self.assertIs(__class__, slf.__class__)
+
+            def _del_foo(slf):
+                self.assertIs(__class__, type(slf))
+                self.assertIs(__class__, slf.__class__)
+
+            foo = property(_get_foo, _set_foo, _del_foo)
+
+        a = A()
+        self.assertIs(a.foo, A)
+        a.foo = 4
+        del a.foo
+
+    def test_dunder_class_with_new_property(self):
+        @dataclass(slots=True)
+        class A:
+            @property
+            def foo(slf):
+                return slf.__class__
+
+            @foo.setter
+            def foo(slf, value):
+                self.assertIs(__class__, type(slf))
+
+            @foo.deleter
+            def foo(slf):
+                self.assertIs(__class__, type(slf))
+
+        a = A()
+        self.assertIs(a.foo, A)
+        a.foo = 4
+        del a.foo
+
+    # Test the parts of a property individually.
+    def test_slots_dunder_class_property_getter(self):
+        @dataclass(slots=True)
+        class A:
+            @property
+            def foo(slf):
+                return __class__
+
+        a = A()
+        self.assertIs(a.foo, A)
+
+    def test_slots_dunder_class_property_setter(self):
+        @dataclass(slots=True)
+        class A:
+            foo = property()
+            @foo.setter
+            def foo(slf, val):
+                self.assertIs(__class__, type(slf))
+
+        a = A()
+        a.foo = 4
+
+    def test_slots_dunder_class_property_deleter(self):
+        @dataclass(slots=True)
+        class A:
+            foo = property()
+            @foo.deleter
+            def foo(slf):
+                self.assertIs(__class__, type(slf))
+
+        a = A()
+        del a.foo
+
+    def test_wrapped(self):
+        def mydecorator(f):
+            @wraps(f)
+            def wrapper(*args, **kwargs):
+                return f(*args, **kwargs)
+            return wrapper
+
+        @dataclass(slots=True)
+        class A:
+            @mydecorator
+            def foo(self):
+                super()
+
+        A().foo()
+
+    def test_remembered_class(self):
+        # Apply the dataclass decorator manually (not when the class
+        # is created), so that we can keep a reference to the
+        # undecorated class.
+        class A:
+            def cls(self):
+                return __class__
+
+        self.assertIs(A().cls(), A)
+
+        B = dataclass(slots=True)(A)
+        self.assertIs(B().cls(), B)
+
+        # This is undesirable behavior, but is a function of how
+        # modifying __class__ in the closure works.  I'm not sure this
+        # should be tested or not: I don't really want to guarantee
+        # this behavior, but I don't want to lose the point that this
+        # is how it works.
+
+        # The underlying class is "broken" by changing its __class__
+        # in A.foo() to B.  This normally isn't a problem, because no
+        # one will be keeping a reference to the underlying class A.
+        self.assertIs(A().cls(), B)
 
 if __name__ == '__main__':
-    unittest.main()
\ No newline at end of file
+    unittest.main()
diff --git a/Lib/test/test_dbm.py b/Lib/test/test_dbm.py
index 6785aa273ac..e68eca29564 100644
--- a/Lib/test/test_dbm.py
+++ b/Lib/test/test_dbm.py
@@ -1,5 +1,6 @@
 """Test script for the dbm.open function based on testdumbdbm.py"""
 
+import sys
 import unittest
 import dbm
 import os
@@ -252,10 +253,13 @@ def setUp(self):
     assert mod.__name__.startswith('dbm.')
     suffix = mod.__name__[4:]
     testname = f'TestCase_{suffix}'
-    globals()[testname] = type(testname,
-                               (AnyDBMTestCase, unittest.TestCase),
-                               {'module': mod})
-
+    cls = type(testname,
+               (AnyDBMTestCase, unittest.TestCase),
+               {'module': mod})
+    # TODO: RUSTPYTHON; sqlite3 file locking prevents cleanup on Windows
+    if suffix == 'sqlite3' and sys.platform == 'win32':
+        cls = unittest.skip("TODO: RUSTPYTHON; sqlite3 file locking on Windows")(cls)
+    globals()[testname] = cls
 
 if __name__ == "__main__":
     unittest.main()
diff --git a/Lib/test/test_decimal.py b/Lib/test/test_decimal.py
index 01b0c06196c..3017c3337c7 100644
--- a/Lib/test/test_decimal.py
+++ b/Lib/test/test_decimal.py
@@ -45,6 +45,7 @@
 import random
 import inspect
 import threading
+import contextvars
 
 
 if sys.platform == 'darwin':
@@ -753,7 +754,7 @@ def test_explicit_context_create_decimal(self):
         for v in [-2**63-1, -2**63, -2**31-1, -2**31, 0,
                    2**31-1, 2**31, 2**63-1, 2**63]:
             d = nc.create_decimal(v)
-            self.assertTrue(isinstance(d, Decimal))
+            self.assertIsInstance(d, Decimal)
             self.assertEqual(int(d), v)
 
         nc.prec = 3
@@ -813,6 +814,29 @@ def test_explicit_context_create_from_float(self):
             x = random.expovariate(0.01) * (random.random() * 2.0 - 1.0)
             self.assertEqual(x, float(nc.create_decimal(x))) # roundtrip
 
+    def test_from_number(self, cls=None):
+        Decimal = self.decimal.Decimal
+        if cls is None:
+            cls = Decimal
+
+        def check(arg, expected):
+            d = cls.from_number(arg)
+            self.assertIs(type(d), cls)
+            self.assertEqual(d, expected)
+
+        check(314, Decimal(314))
+        check(3.14, Decimal.from_float(3.14))
+        check(Decimal('3.14'), Decimal('3.14'))
+        self.assertRaises(TypeError, cls.from_number, 3+4j)
+        self.assertRaises(TypeError, cls.from_number, '314')
+        self.assertRaises(TypeError, cls.from_number, (0, (3, 1, 4), 0))
+        self.assertRaises(TypeError, cls.from_number, object())
+
+    def test_from_number_subclass(self, cls=None):
+        class DecimalSubclass(self.decimal.Decimal):
+            pass
+        self.test_from_number(DecimalSubclass)
+
     def test_unicode_digits(self):
         Decimal = self.decimal.Decimal
 
@@ -830,9 +854,8 @@ class CExplicitConstructionTest(ExplicitConstructionTest, unittest.TestCase):
 class PyExplicitConstructionTest(ExplicitConstructionTest, unittest.TestCase):
     decimal = P
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    def test_unicode_digits(self): # TODO(RUSTPYTHON): Remove this test when it pass
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    def test_unicode_digits(self):
         return super().test_unicode_digits()
 
 class ImplicitConstructionTest:
@@ -963,6 +986,7 @@ def test_formatting(self):
             ('.0f', '0e-2', '0'),
             ('.0f', '3.14159265', '3'),
             ('.1f', '3.14159265', '3.1'),
+            ('.01f', '3.14159265', '3.1'), # leading zero in precision
             ('.4f', '3.14159265', '3.1416'),
             ('.6f', '3.14159265', '3.141593'),
             ('.7f', '3.14159265', '3.1415926'), # round-half-even!
@@ -1048,6 +1072,7 @@ def test_formatting(self):
             ('8,', '123456', ' 123,456'),
             ('08,', '123456', '0,123,456'), # special case: extra 0 needed
             ('+08,', '123456', '+123,456'), # but not if there's a sign
+            ('008,', '123456', '0,123,456'), # leading zero in width
             (' 08,', '123456', ' 123,456'),
             ('08,', '-123456', '-123,456'),
             ('+09,', '123456', '+0,123,456'),
@@ -1064,6 +1089,20 @@ def test_formatting(self):
             (',%', '123.456789', '12,345.6789%'),
             (',e', '123456', '1.23456e+5'),
             (',E', '123456', '1.23456E+5'),
+            # ... with '_' instead
+            ('_', '1234567', '1_234_567'),
+            ('07_', '1234.56', '1_234.56'),
+            ('_', '1.23456789', '1.23456789'),
+            ('_%', '123.456789', '12_345.6789%'),
+            # and now for something completely different...
+            ('.,', '1.23456789', '1.234,567,89'),
+            ('._', '1.23456789', '1.234_567_89'),
+            ('.6_f', '12345.23456789', '12345.234_568'),
+            (',._%', '123.456789', '12,345.678_9%'),
+            (',._e', '123456', '1.234_56e+5'),
+            (',.4_e', '123456', '1.234_6e+5'),
+            (',.3_e', '123456', '1.235e+5'),
+            (',._E', '123456', '1.234_56E+5'),
 
             # negative zero: default behavior
             ('.1f', '-0', '-0.0'),
@@ -1137,6 +1176,10 @@ def test_formatting(self):
         # bytes format argument
         self.assertRaises(TypeError, Decimal(1).__format__, b'-020')
 
+        # precision or fractional part separator should follow after dot
+        self.assertRaises(ValueError, format, Decimal(1), '.f')
+        self.assertRaises(ValueError, format, Decimal(1), '._6f')
+
     def test_negative_zero_format_directed_rounding(self):
         with self.decimal.localcontext() as ctx:
             ctx.rounding = ROUND_CEILING
@@ -1708,8 +1751,13 @@ def test_threading(self):
         self.finish1 = threading.Event()
         self.finish2 = threading.Event()
 
-        th1 = threading.Thread(target=thfunc1, args=(self,))
-        th2 = threading.Thread(target=thfunc2, args=(self,))
+        # This test wants to start threads with an empty context, no matter
+        # the setting of sys.flags.thread_inherit_context.  We pass the
+        # 'context' argument explicitly with an empty context instance.
+        th1 = threading.Thread(target=thfunc1, args=(self,),
+                               context=contextvars.Context())
+        th2 = threading.Thread(target=thfunc2, args=(self,),
+                               context=contextvars.Context())
 
         th1.start()
         th2.start()
@@ -2573,8 +2621,8 @@ class PythonAPItests:
     def test_abc(self):
         Decimal = self.decimal.Decimal
 
-        self.assertTrue(issubclass(Decimal, numbers.Number))
-        self.assertFalse(issubclass(Decimal, numbers.Real))
+        self.assertIsSubclass(Decimal, numbers.Number)
+        self.assertNotIsSubclass(Decimal, numbers.Real)
         self.assertIsInstance(Decimal(0), numbers.Number)
         self.assertNotIsInstance(Decimal(0), numbers.Real)
 
@@ -2673,7 +2721,7 @@ class MyDecimal(Decimal):
             def __init__(self, _):
                 self.x = 'y'
 
-        self.assertTrue(issubclass(MyDecimal, Decimal))
+        self.assertIsSubclass(MyDecimal, Decimal)
 
         r = MyDecimal.from_float(0.1)
         self.assertEqual(type(r), MyDecimal)
@@ -2891,31 +2939,31 @@ def test_exception_hierarchy(self):
         Rounded = decimal.Rounded
         Clamped = decimal.Clamped
 
-        self.assertTrue(issubclass(DecimalException, ArithmeticError))
-
-        self.assertTrue(issubclass(InvalidOperation, DecimalException))
-        self.assertTrue(issubclass(FloatOperation, DecimalException))
-        self.assertTrue(issubclass(FloatOperation, TypeError))
-        self.assertTrue(issubclass(DivisionByZero, DecimalException))
-        self.assertTrue(issubclass(DivisionByZero, ZeroDivisionError))
-        self.assertTrue(issubclass(Overflow, Rounded))
-        self.assertTrue(issubclass(Overflow, Inexact))
-        self.assertTrue(issubclass(Overflow, DecimalException))
-        self.assertTrue(issubclass(Underflow, Inexact))
-        self.assertTrue(issubclass(Underflow, Rounded))
-        self.assertTrue(issubclass(Underflow, Subnormal))
-        self.assertTrue(issubclass(Underflow, DecimalException))
-
-        self.assertTrue(issubclass(Subnormal, DecimalException))
-        self.assertTrue(issubclass(Inexact, DecimalException))
-        self.assertTrue(issubclass(Rounded, DecimalException))
-        self.assertTrue(issubclass(Clamped, DecimalException))
-
-        self.assertTrue(issubclass(decimal.ConversionSyntax, InvalidOperation))
-        self.assertTrue(issubclass(decimal.DivisionImpossible, InvalidOperation))
-        self.assertTrue(issubclass(decimal.DivisionUndefined, InvalidOperation))
-        self.assertTrue(issubclass(decimal.DivisionUndefined, ZeroDivisionError))
-        self.assertTrue(issubclass(decimal.InvalidContext, InvalidOperation))
+        self.assertIsSubclass(DecimalException, ArithmeticError)
+
+        self.assertIsSubclass(InvalidOperation, DecimalException)
+        self.assertIsSubclass(FloatOperation, DecimalException)
+        self.assertIsSubclass(FloatOperation, TypeError)
+        self.assertIsSubclass(DivisionByZero, DecimalException)
+        self.assertIsSubclass(DivisionByZero, ZeroDivisionError)
+        self.assertIsSubclass(Overflow, Rounded)
+        self.assertIsSubclass(Overflow, Inexact)
+        self.assertIsSubclass(Overflow, DecimalException)
+        self.assertIsSubclass(Underflow, Inexact)
+        self.assertIsSubclass(Underflow, Rounded)
+        self.assertIsSubclass(Underflow, Subnormal)
+        self.assertIsSubclass(Underflow, DecimalException)
+
+        self.assertIsSubclass(Subnormal, DecimalException)
+        self.assertIsSubclass(Inexact, DecimalException)
+        self.assertIsSubclass(Rounded, DecimalException)
+        self.assertIsSubclass(Clamped, DecimalException)
+
+        self.assertIsSubclass(decimal.ConversionSyntax, InvalidOperation)
+        self.assertIsSubclass(decimal.DivisionImpossible, InvalidOperation)
+        self.assertIsSubclass(decimal.DivisionUndefined, InvalidOperation)
+        self.assertIsSubclass(decimal.DivisionUndefined, ZeroDivisionError)
+        self.assertIsSubclass(decimal.InvalidContext, InvalidOperation)
 
 @requires_cdecimal
 class CPythonAPItests(PythonAPItests, unittest.TestCase):
@@ -2923,7 +2971,6 @@ class CPythonAPItests(PythonAPItests, unittest.TestCase):
 class PyPythonAPItests(PythonAPItests, unittest.TestCase):
     decimal = P
 
-
 class ContextAPItests:
 
     def test_none_args(self):
@@ -4371,6 +4418,51 @@ class CContextSubclassing(ContextSubclassing, unittest.TestCase):
 class PyContextSubclassing(ContextSubclassing, unittest.TestCase):
     decimal = P
 
+class IEEEContexts:
+
+    def test_ieee_context(self):
+        # issue 8786: Add support for IEEE 754 contexts to decimal module.
+        IEEEContext = self.decimal.IEEEContext
+
+        def assert_rest(self, context):
+            self.assertEqual(context.clamp, 1)
+            assert_signals(self, context, 'traps', [])
+            assert_signals(self, context, 'flags', [])
+
+        c = IEEEContext(32)
+        self.assertEqual(c.prec, 7)
+        self.assertEqual(c.Emax, 96)
+        self.assertEqual(c.Emin, -95)
+        assert_rest(self, c)
+
+        c = IEEEContext(64)
+        self.assertEqual(c.prec, 16)
+        self.assertEqual(c.Emax, 384)
+        self.assertEqual(c.Emin, -383)
+        assert_rest(self, c)
+
+        c = IEEEContext(128)
+        self.assertEqual(c.prec, 34)
+        self.assertEqual(c.Emax, 6144)
+        self.assertEqual(c.Emin, -6143)
+        assert_rest(self, c)
+
+        # Invalid values
+        self.assertRaises(ValueError, IEEEContext, -1)
+        self.assertRaises(ValueError, IEEEContext, 123)
+        self.assertRaises(ValueError, IEEEContext, 1024)
+
+    def test_constants(self):
+        # IEEEContext
+        IEEE_CONTEXT_MAX_BITS = self.decimal.IEEE_CONTEXT_MAX_BITS
+        self.assertIn(IEEE_CONTEXT_MAX_BITS, {256, 512})
+
+@requires_cdecimal
+class CIEEEContexts(IEEEContexts, unittest.TestCase):
+    decimal = C
+class PyIEEEContexts(IEEEContexts, unittest.TestCase):
+    decimal = P
+
 @skip_if_extra_functionality
 @requires_cdecimal
 class CheckAttributes(unittest.TestCase):
@@ -4382,6 +4474,7 @@ def test_module_attributes(self):
         self.assertEqual(C.MAX_EMAX, P.MAX_EMAX)
         self.assertEqual(C.MIN_EMIN, P.MIN_EMIN)
         self.assertEqual(C.MIN_ETINY, P.MIN_ETINY)
+        self.assertEqual(C.IEEE_CONTEXT_MAX_BITS, P.IEEE_CONTEXT_MAX_BITS)
 
         self.assertTrue(C.HAVE_THREADS is True or C.HAVE_THREADS is False)
         self.assertTrue(P.HAVE_THREADS is True or P.HAVE_THREADS is False)
@@ -4465,12 +4558,10 @@ def test_implicit_context(self):
             self.assertIs(Decimal("NaN").fma(7, 1).is_nan(), True)
             # three arg power
             self.assertEqual(pow(Decimal(10), 2, 7), 2)
+            self.assertEqual(pow(10, Decimal(2), 7), 2)
             if self.decimal == C:
-                self.assertEqual(pow(10, Decimal(2), 7), 2)
                 self.assertEqual(pow(10, 2, Decimal(7)), 2)
             else:
-                # XXX: Three-arg power doesn't use __rpow__.
-                self.assertRaises(TypeError, pow, 10, Decimal(2), 7)
                 # XXX: There is no special method to dispatch on the
                 # third arg of three-arg power.
                 self.assertRaises(TypeError, pow, 10, 2, Decimal(7))
@@ -4684,10 +4775,6 @@ def tearDown(self):
         sys.set_int_max_str_digits(self._previous_int_limit)
         super().tearDown()
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    def test_implicit_context(self): # TODO(RUSTPYTHON): Remove this test when it pass
-        return super().test_implicit_context()
 
 class PyFunctionality(unittest.TestCase):
     """Extra functionality in decimal.py"""
@@ -4872,42 +4959,6 @@ def test_py__round(self):
 class CFunctionality(unittest.TestCase):
     """Extra functionality in _decimal"""
 
-    @requires_extra_functionality
-    def test_c_ieee_context(self):
-        # issue 8786: Add support for IEEE 754 contexts to decimal module.
-        IEEEContext = C.IEEEContext
-        DECIMAL32 = C.DECIMAL32
-        DECIMAL64 = C.DECIMAL64
-        DECIMAL128 = C.DECIMAL128
-
-        def assert_rest(self, context):
-            self.assertEqual(context.clamp, 1)
-            assert_signals(self, context, 'traps', [])
-            assert_signals(self, context, 'flags', [])
-
-        c = IEEEContext(DECIMAL32)
-        self.assertEqual(c.prec, 7)
-        self.assertEqual(c.Emax, 96)
-        self.assertEqual(c.Emin, -95)
-        assert_rest(self, c)
-
-        c = IEEEContext(DECIMAL64)
-        self.assertEqual(c.prec, 16)
-        self.assertEqual(c.Emax, 384)
-        self.assertEqual(c.Emin, -383)
-        assert_rest(self, c)
-
-        c = IEEEContext(DECIMAL128)
-        self.assertEqual(c.prec, 34)
-        self.assertEqual(c.Emax, 6144)
-        self.assertEqual(c.Emin, -6143)
-        assert_rest(self, c)
-
-        # Invalid values
-        self.assertRaises(OverflowError, IEEEContext, 2**63)
-        self.assertRaises(ValueError, IEEEContext, -1)
-        self.assertRaises(ValueError, IEEEContext, 1024)
-
     @requires_extra_functionality
     def test_c_context(self):
         Context = C.Context
@@ -4928,12 +4979,6 @@ def test_constants(self):
             C.DecSubnormal, C.DecUnderflow
         )
 
-        # IEEEContext
-        self.assertEqual(C.DECIMAL32, 32)
-        self.assertEqual(C.DECIMAL64, 64)
-        self.assertEqual(C.DECIMAL128, 128)
-        self.assertEqual(C.IEEE_CONTEXT_MAX_BITS, 512)
-
         # Conditions
         for i, v in enumerate(cond):
             self.assertEqual(v, 1<<i)
diff --git a/Lib/test/test_decorators.py b/Lib/test/test_decorators.py
index 4da2c13a608..3a4fc959f6f 100644
--- a/Lib/test/test_decorators.py
+++ b/Lib/test/test_decorators.py
@@ -291,7 +291,6 @@ def bar(): return 42
         self.assertEqual(bar(), 42)
         self.assertEqual(actions, expected_actions)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_bound_function_inside_classmethod(self):
         class A:
             def foo(self, cls):
diff --git a/Lib/test/test_defaultdict.py b/Lib/test/test_defaultdict.py
index bdbe9b81e8f..f10603fb4c4 100644
--- a/Lib/test/test_defaultdict.py
+++ b/Lib/test/test_defaultdict.py
@@ -186,5 +186,24 @@ def test_union(self):
         with self.assertRaises(TypeError):
             i |= None
 
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AssertionError: 1 != 2
+    def test_factory_conflict_with_set_value(self):
+        key = "conflict_test"
+        count = 0
+
+        def default_factory():
+            nonlocal count
+            count += 1
+            local_count = count
+            if count == 1:
+                test_dict[key]
+            return local_count
+
+        test_dict = defaultdict(default_factory)
+
+        self.assertEqual(count, 0)
+        self.assertEqual(test_dict[key], 2)
+        self.assertEqual(count, 2)
+
 if __name__ == "__main__":
     unittest.main()
diff --git a/Lib/test/test_deque.py b/Lib/test/test_deque.py
index 9f00e12edd1..f798ab4b6d1 100644
--- a/Lib/test/test_deque.py
+++ b/Lib/test/test_deque.py
@@ -726,8 +726,7 @@ def test_gc_doesnt_blowup(self):
             d.append(1)
             gc.collect()
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AssertionError: False is not true : Cycle was not collected
     def test_container_iterator(self):
         # Bug #3680: tp_traverse was not implemented for deque iterator objects
         class C(object):
@@ -818,8 +817,7 @@ def test_basics(self):
         d.clear()
         self.assertEqual(len(d), 0)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AttributeError: 'Deque' object has no attribute 'x'
     def test_copy_pickle(self):
         for cls in Deque, DequeWithSlots:
             for d in cls('abc'), cls('abcde', maxlen=4):
@@ -842,10 +840,9 @@ def test_copy_pickle(self):
                     self.assertEqual(list(d), list(e))
                     self.assertEqual(e.x, d.x)
                     self.assertEqual(e.z, d.z)
-                    self.assertFalse(hasattr(e, 'y'))
+                    self.assertNotHasAttr(e, 'y')
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AttributeError: 'Deque' object has no attribute 'x'
     def test_pickle_recursive(self):
         for proto in range(pickle.HIGHEST_PROTOCOL + 1):
             for d in Deque('abc'), Deque('abc', 3):
diff --git a/Lib/test/test_descr.py b/Lib/test/test_descr.py
index 2ad302690c0..ab2290c96b8 100644
--- a/Lib/test/test_descr.py
+++ b/Lib/test/test_descr.py
@@ -7,6 +7,7 @@
 import random
 import string
 import sys
+import textwrap
 import types
 import unittest
 import warnings
@@ -15,7 +16,7 @@
 from copy import deepcopy
 from contextlib import redirect_stdout
 from test import support
-from test.support.testcase import ExtraAssertions
+from test.support.script_helper import assert_python_ok
 
 try:
     import _testcapi
@@ -404,11 +405,11 @@ def test_wrap_lenfunc_bad_cast(self):
         self.assertEqual(range(sys.maxsize).__len__(), sys.maxsize)
 
 
-class ClassPropertiesAndMethods(unittest.TestCase, ExtraAssertions):
+class ClassPropertiesAndMethods(unittest.TestCase):
 
     def test_python_dicts(self):
         # Testing Python subclass of dict...
-        self.assertTrue(issubclass(dict, dict))
+        self.assertIsSubclass(dict, dict)
         self.assertIsInstance({}, dict)
         d = dict()
         self.assertEqual(d, {})
@@ -432,7 +433,7 @@ def setstate(self, state):
                 self.state = state
             def getstate(self):
                 return self.state
-        self.assertTrue(issubclass(C, dict))
+        self.assertIsSubclass(C, dict)
         a1 = C(12)
         self.assertEqual(a1.state, 12)
         a2 = C(foo=1, bar=2)
@@ -1047,15 +1048,15 @@ class SubType(types.ModuleType):
 
         m = types.ModuleType("m")
         self.assertTrue(m.__class__ is types.ModuleType)
-        self.assertFalse(hasattr(m, "a"))
+        self.assertNotHasAttr(m, "a")
 
         m.__class__ = SubType
         self.assertTrue(m.__class__ is SubType)
-        self.assertTrue(hasattr(m, "a"))
+        self.assertHasAttr(m, "a")
 
         m.__class__ = types.ModuleType
         self.assertTrue(m.__class__ is types.ModuleType)
-        self.assertFalse(hasattr(m, "a"))
+        self.assertNotHasAttr(m, "a")
 
         # Make sure that builtin immutable objects don't support __class__
         # assignment, because the object instances may be interned.
@@ -1102,7 +1103,8 @@ class MyFrozenSet(frozenset):
         with self.assertRaises(TypeError):
             frozenset().__class__ = MyFrozenSet
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    @support.thread_unsafe
     def test_slots(self):
         # Testing __slots__...
         class C0(object):
@@ -1319,7 +1321,6 @@ class X(object):
         with self.assertRaisesRegex(AttributeError, "'X' object has no attribute 'a'"):
             X().a
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_slots_special(self):
         # Testing __dict__ and __weakref__ in __slots__...
         class D(object):
@@ -1358,7 +1359,7 @@ class C2(D, W):
         a.foo = 42
         self.assertEqual(a.__dict__, {"foo": 42})
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_slots_special2(self):
         # Testing __qualname__ and __classcell__ in __slots__
         class Meta(type):
@@ -1543,6 +1544,7 @@ class B(A1, A2):
         else:
             self.fail("finding the most derived metaclass should have failed")
 
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_classmethods(self):
         # Testing class methods...
         class C(object):
@@ -1588,8 +1590,7 @@ def f(cls, arg):
             self.fail("classmethod shouldn't accept keyword args")
 
         cm = classmethod(f)
-        cm_dict = {'__annotations__': {},
-                   '__doc__': (
+        cm_dict = {'__doc__': (
                        "f docstring"
                        if support.HAVE_PY_DOCSTRINGS
                        else None
@@ -1605,6 +1606,56 @@ def f(cls, arg):
         del cm.x
         self.assertNotHasAttr(cm, "x")
 
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    def test_classmethod_staticmethod_annotations(self):
+        for deco in (classmethod, staticmethod):
+            @deco
+            def unannotated(cls): pass
+            @deco
+            def annotated(cls) -> int: pass
+
+            for method in (annotated, unannotated):
+                with self.subTest(deco=deco, method=method):
+                    with self.assertRaises(AttributeError):
+                        del unannotated.__annotations__
+
+                    original_annotations = dict(method.__wrapped__.__annotations__)
+                    self.assertNotIn('__annotations__', method.__dict__)
+                    self.assertEqual(method.__annotations__, original_annotations)
+                    self.assertIn('__annotations__', method.__dict__)
+
+                    new_annotations = {"a": "b"}
+                    method.__annotations__ = new_annotations
+                    self.assertEqual(method.__annotations__, new_annotations)
+                    self.assertEqual(method.__wrapped__.__annotations__, original_annotations)
+
+                    del method.__annotations__
+                    self.assertEqual(method.__annotations__, original_annotations)
+
+                    original_annotate = method.__wrapped__.__annotate__
+                    self.assertNotIn('__annotate__', method.__dict__)
+                    self.assertIs(method.__annotate__, original_annotate)
+                    self.assertIn('__annotate__', method.__dict__)
+
+                    new_annotate = lambda: {"annotations": 1}
+                    method.__annotate__ = new_annotate
+                    self.assertIs(method.__annotate__, new_annotate)
+                    self.assertIs(method.__wrapped__.__annotate__, original_annotate)
+
+                    del method.__annotate__
+                    self.assertIs(method.__annotate__, original_annotate)
+
+    def test_staticmethod_annotations_without_dict_access(self):
+        # gh-125017: this used to crash
+        class Spam:
+            def __new__(cls, x, y):
+                pass
+
+        self.assertEqual(Spam.__new__.__annotations__, {})
+        obj = Spam.__dict__['__new__']
+        self.assertIsInstance(obj, staticmethod)
+        self.assertEqual(obj.__annotations__, {})
+
     @support.refcount_test
     def test_refleaks_in_classmethod___init__(self):
         gettotalrefcount = support.get_attribute(sys, 'gettotalrefcount')
@@ -1733,7 +1784,7 @@ class D(C):
         class E: # *not* subclassing from C
             foo = C.foo
         self.assertEqual(E().foo.__func__, C.foo) # i.e., unbound
-        self.assertTrue(repr(C.foo.__get__(C())).startswith("<bound method "))
+        self.assertStartsWith(repr(C.foo.__get__(C())), "<bound method ")
 
     def test_compattr(self):
         # Testing computed attributes...
@@ -1787,6 +1838,8 @@ class D(C):
         self.assertEqual(b.foo, 3)
         self.assertEqual(b.__class__, D)
 
+    # TODO: RUSTPYTHON; The `expectedFailure` here is from CPython, so this test must fail
+    # @unittest.expectedFailure
     def test_bad_new(self):
         self.assertRaises(TypeError, object.__new__)
         self.assertRaises(TypeError, object.__new__, '')
@@ -1799,7 +1852,6 @@ class C(list):
             __new__ = object.__new__
         self.assertRaises(TypeError, C)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_object_new(self):
         class A(object):
             pass
@@ -1859,7 +1911,7 @@ def __init__(self, foo):
         self.assertEqual(b.foo, 3)
         self.assertEqual(b.__class__, B)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_altmro(self):
         # Testing mro() and overriding it...
         class A(object):
@@ -2013,7 +2065,7 @@ class D(C):
         class E(object):
             foo = C.foo
         self.assertEqual(E().foo.__func__, C.foo) # i.e., unbound
-        self.assertTrue(repr(C.foo.__get__(C(1))).startswith("<bound method "))
+        self.assertStartsWith(repr(C.foo.__get__(C(1))), "<bound method ")
 
     @support.impl_detail("testing error message from implementation")
     def test_methods_in_c(self):
@@ -2038,7 +2090,7 @@ def test_methods_in_c(self):
             set_add.__get__(0)
         self.assertEqual(cm.exception.args[0], expected_errmsg)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_special_method_lookup(self):
         # The lookup of special methods bypasses __getattr__ and
         # __getattribute__, but they still can be descriptors.
@@ -2241,7 +2293,6 @@ def __contains__(self, value):
             self.assertIn(i, p10)
         self.assertNotIn(10, p10)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_weakrefs(self):
         # Testing weak references...
         import weakref
@@ -2273,7 +2324,7 @@ class Weak(object):
         self.assertEqual(r(), None)
         del r
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_properties(self):
         # Testing property...
         class C(object):
@@ -2601,7 +2652,7 @@ def __getclass(self):
 
         dir(C()) # This used to segfault
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_supers(self):
         # Testing super...
 
@@ -2714,7 +2765,7 @@ def test(klass):
         with self.assertRaises(TypeError):
             super(Base, kw=1)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_basic_inheritance(self):
         # Testing inheritance from basic types...
 
@@ -3047,7 +3098,7 @@ class sublist(list):
         ##         pass
         ##     os_helper.unlink(os_helper.TESTFN)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_keywords(self):
         # Testing keyword args to basic type constructors ...
         with self.assertRaisesRegex(TypeError, 'keyword argument'):
@@ -3194,8 +3245,6 @@ class classic:
             class C(base):
                 def __init__(self, value):
                     self.value = int(value)
-                def __cmp__(self_, other):
-                    self.fail("shouldn't call __cmp__")
                 def __eq__(self, other):
                     if isinstance(other, C):
                         return self.value == other.value
@@ -3250,7 +3299,7 @@ def __ge__(self, other):
                                          eval("x %s y" % op),
                                          "x=%d, y=%d" % (x, y))
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_descrdoc(self):
         # Testing descriptor doc strings...
         from _io import FileIO
@@ -3274,7 +3323,7 @@ class NewClass:
         self.assertEqual(NewClass.__doc__, 'object=None; type=NewClass')
         self.assertEqual(NewClass().__doc__, 'object=NewClass instance; type=NewClass')
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_set_class(self):
         # Testing __class__ assignment...
         class C(object): pass
@@ -3364,7 +3413,7 @@ def __del__(self):
         l = [A() for x in range(100)]
         del l
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_set_dict(self):
         # Testing __dict__ assignment...
         class C(object): pass
@@ -3480,6 +3529,10 @@ def __rpow__(self, other, mod=None):
         self.assertEqual(repr(2 ** I(3)), "I(8)")
         self.assertEqual(repr(I(2) ** 3), "I(8)")
         self.assertEqual(repr(pow(I(2), I(3), I(5))), "I(3)")
+        self.assertEqual(repr(pow(I(2), I(3), 5)), "I(3)")
+        self.assertEqual(repr(pow(I(2), 3, 5)), "I(3)")
+        self.assertEqual(repr(pow(2, I(3), 5)), "I(3)")
+        self.assertEqual(repr(pow(2, 3, I(5))), "3")
         class S(str):
             def __eq__(self, other):
                 return self.lower() == other.lower()
@@ -3623,7 +3676,9 @@ def f(a): return a
                            encoding='latin1', errors='replace')
         self.assertEqual(ba, b'abc\xbd?')
 
-    @unittest.skip('TODO: RUSTPYTHON; rustpython segmentation fault')
+    @unittest.skip("TODO: RUSTPYTHON; rustpython segmentation fault")
+    @support.skip_wasi_stack_overflow()
+    @support.skip_emscripten_stack_overflow()
     def test_recursive_call(self):
         # Testing recursive __call__() by setting to instance of class...
         class A(object):
@@ -3742,7 +3797,7 @@ def test_uninitialized_modules(self):
         m.foo = 1
         self.assertEqual(m.__dict__, {"foo": 1})
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_funny_new(self):
         # Testing __new__ returning something unexpected...
         class C(object):
@@ -3904,7 +3959,9 @@ def __del__(self):
         # it as a leak.
         del C.__del__
 
-    @unittest.skip('TODO: RUSTPYTHON; rustpython segmentation fault')
+    @unittest.skip("TODO: RUSTPYTHON; rustpython segmentation fault")
+    @support.skip_emscripten_stack_overflow()
+    @support.skip_wasi_stack_overflow()
     def test_slots_trash(self):
         # Testing slot trash...
         # Deallocating deeply nested slotted trash caused stack overflows
@@ -3917,7 +3974,6 @@ def __init__(self, x):
             o = trash(o)
         del o
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_slots_multiple_inheritance(self):
         # SF bug 575229, multiple inheritance w/ slots dumps core
         class A(object):
@@ -3997,6 +4053,21 @@ def test_ipow_exception_text(self):
             y = x ** 2
         self.assertIn('unsupported operand type(s) for **', str(cm.exception))
 
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    def test_pow_wrapper_error_messages(self):
+        self.assertRaisesRegex(TypeError,
+                               'expected 1 or 2 arguments, got 0',
+                               int().__pow__)
+        self.assertRaisesRegex(TypeError,
+                               'expected 1 or 2 arguments, got 3',
+                               int().__pow__, 1, 2, 3)
+        self.assertRaisesRegex(TypeError,
+                               'expected 1 or 2 arguments, got 0',
+                               int().__rpow__)
+        self.assertRaisesRegex(TypeError,
+                               'expected 1 or 2 arguments, got 3',
+                               int().__rpow__, 1, 2, 3)
+
     def test_mutable_bases(self):
         # Testing mutable bases...
 
@@ -4062,7 +4133,7 @@ class E(D):
         else:
             self.fail("shouldn't be able to create inheritance cycles")
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_builtin_bases(self):
         # Make sure all the builtin types can have their base queried without
         # segfaulting. See issue #5787.
@@ -4107,7 +4178,7 @@ class D(C):
         else:
             self.fail("best_base calculation found wanting")
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_unsubclassable_types(self):
         with self.assertRaises(TypeError):
             class X(type(None)):
@@ -4140,7 +4211,7 @@ class X(object):
         with self.assertRaises(TypeError):
             X.__bases__ = type(None), O
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_mutable_bases_with_failing_mro(self):
         # Testing mutable bases with failing mro...
         class WorkOnce(type):
@@ -4247,7 +4318,6 @@ class C:
         C.__name__ = Nasty("abc")
         C.__name__ = "normal"
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_subclass_right_op(self):
         # Testing correct dispatch of subclass overloading __r<op>__...
 
@@ -4382,7 +4452,7 @@ class D(C):
         self.assertIsInstance(a, C)  # Baseline
         self.assertIsInstance(pa, C) # Test
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_proxy_super(self):
         # Testing super() for a proxy object...
         class Proxy(object):
@@ -4406,7 +4476,7 @@ def f(self):
         p = Proxy(obj)
         self.assertEqual(C.__dict__["f"](p), "B.f->C.f")
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_carloverre(self):
         # Testing prohibition of Carlo Verre's hack...
         try:
@@ -4439,7 +4509,7 @@ class C(B, A):
         except TypeError:
             self.fail("setattr through direct base types should be legal")
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_carloverre_multi_inherit_invalid(self):
         class A(type):
             def __setattr__(cls, key, value):
@@ -4478,7 +4548,9 @@ class Oops(object):
         o.whatever = Provoker(o)
         del o
 
-    @unittest.skip('TODO: RUSTPYTHON; rustpython segmentation fault')
+    @unittest.skip("TODO: RUSTPYTHON; rustpython segmentation fault")
+    @support.skip_wasi_stack_overflow()
+    @support.skip_emscripten_stack_overflow()
     @support.requires_resource('cpu')
     def test_wrapper_segfault(self):
         # SF 927248: deeply nested wrappers could cause stack overflow
@@ -4553,7 +4625,7 @@ def assertNotOrderable(self, a, b):
         with self.assertRaises(TypeError):
             a >= b
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_method_wrapper(self):
         # Testing method-wrapper objects...
         # <type 'method-wrapper'> did not support any reflection before 2.5
@@ -4766,7 +4838,7 @@ class X(object):
         with self.assertRaises(AttributeError):
             del X.__abstractmethods__
 
-    @unittest.skip('TODO: RUSTPYTHON; crash. "dict has non-string keys: [PyObject PyInt { value: 1 }]"')
+    @unittest.skip("TODO: RUSTPYTHON; crash. \"dict has non-string keys: [PyObject PyInt { value: 1 }]\"")
     def test_gh55664(self):
         # gh-55664: issue a warning when the
         # __dict__ of a class contains non-string keys
@@ -4824,6 +4896,8 @@ class Thing:
                 # CALL_METHOD_DESCRIPTOR_O
                 deque.append(thing, thing)
 
+    @support.skip_emscripten_stack_overflow()
+    @support.skip_wasi_stack_overflow()
     def test_repr_as_str(self):
         # Issue #11603: crash or infinite loop when rebinding __str__ as
         # __repr__.
@@ -4855,7 +4929,7 @@ class A(int):
         with self.assertRaises(TypeError):
             a + a
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_slot_shadows_class_variable(self):
         with self.assertRaises(ValueError) as cm:
             class X:
@@ -4864,7 +4938,7 @@ class X:
         m = str(cm.exception)
         self.assertEqual("'foo' in __slots__ conflicts with class variable", m)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_set_doc(self):
         class X:
             "elephant"
@@ -4880,7 +4954,7 @@ class X:
         self.assertIn("cannot delete '__doc__' attribute of immutable type 'X'", str(cm.exception))
         self.assertEqual(X.__doc__, "banana")
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_qualname(self):
         descriptors = [str.lower, complex.real, float.real, int.__add__]
         types = ['method', 'member', 'getset', 'wrapper']
@@ -4913,7 +4987,6 @@ class Inside:
         self.assertEqual(Y.__qualname__, 'Y')
         self.assertEqual(Y.Inside.__qualname__, 'Y.Inside')
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_qualname_dict(self):
         ns = {'__qualname__': 'some.name'}
         tp = type('Foo', (), ns)
@@ -4924,7 +4997,7 @@ def test_qualname_dict(self):
         ns = {'__qualname__': 1}
         self.assertRaises(TypeError, type, 'Foo', (), ns)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_cycle_through_dict(self):
         # See bug #1469629
         class X(dict):
@@ -5039,7 +5112,6 @@ def __new__(cls):
                 cls.lst = [2**i for i in range(10000)]
         X.descr
 
-    @support.suppress_immortalization()
     def test_remove_subclass(self):
         # bpo-46417: when the last subclass of a type is deleted,
         # remove_subclass() clears the internal dictionary of subclasses:
@@ -5057,7 +5129,6 @@ class Child(Parent):
         gc.collect()
         self.assertEqual(Parent.__subclasses__(), [])
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_instance_method_get_behavior(self):
         # test case for gh-113157
 
@@ -5107,7 +5178,6 @@ def meth(self):
                 pass
         self.C = C
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     @unittest.skipIf(hasattr(sys, 'gettrace') and sys.gettrace(),
                         'trace function introduces __local__')
     def test_iter_keys(self):
@@ -5121,7 +5191,6 @@ def test_iter_keys(self):
                                 '__static_attributes__', '__weakref__',
                                 'meth'])
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON; AssertionError: 5 != 7
     @unittest.skipIf(hasattr(sys, 'gettrace') and sys.gettrace(),
                         'trace function introduces __local__')
     def test_iter_values(self):
@@ -5131,7 +5200,6 @@ def test_iter_values(self):
         values = list(it)
         self.assertEqual(len(values), 7)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     @unittest.skipIf(hasattr(sys, 'gettrace') and sys.gettrace(),
                         'trace function introduces __local__')
     def test_iter_items(self):
@@ -5161,8 +5229,8 @@ def test_repr(self):
         # We can't blindly compare with the repr of another dict as ordering
         # of keys and values is arbitrary and may differ.
         r = repr(self.C.__dict__)
-        self.assertTrue(r.startswith('mappingproxy('), r)
-        self.assertTrue(r.endswith(')'), r)
+        self.assertStartsWith(r, 'mappingproxy(')
+        self.assertEndsWith(r, ')')
         for k, v in self.C.__dict__.items():
             self.assertIn('{!r}: {!r}'.format(k, v), r)
 
@@ -5198,6 +5266,7 @@ def test_type_lookup_mro_reference(self):
         # Issue #14199: _PyType_Lookup() has to keep a strong reference to
         # the type MRO because it may be modified during the lookup, if
         # __bases__ is set during the lookup for example.
+        code = textwrap.dedent("""
         class MyKey(object):
             def __hash__(self):
                 return hash('mykey')
@@ -5213,17 +5282,29 @@ class Base2(object):
             mykey = 'from Base2'
             mykey2 = 'from Base2'
 
-        with self.assertWarnsRegex(RuntimeWarning, 'X'):
-            X = type('X', (Base,), {MyKey(): 5})
+        X = type('X', (Base,), {MyKey(): 5})
+
+        bases_before = ",".join([c.__name__ for c in X.__bases__])
+        print(f"before={bases_before}")
+
+        # mykey is initially read from Base, however, the lookup will be perfomed
+        # again if specialization fails. The second lookup will use the new
+        # mro set by __eq__.
+        print(X.mykey)
 
-        # Note that the access below uses getattr() rather than normally
-        # accessing the attribute.  That is done to avoid the bytecode
-        # specializer activating on repeated runs of the test.
+        bases_after = ",".join([c.__name__ for c in X.__bases__])
+        print(f"after={bases_after}")
 
-        # mykey is read from Base
-        self.assertEqual(getattr(X, 'mykey'), 'from Base')
-        # mykey2 is read from Base2 because MyKey.__eq__ has set __bases__
-        self.assertEqual(getattr(X, 'mykey2'), 'from Base2')
+        # mykey2 is read from Base2 because MyKey.__eq__ has set __bases_
+        print(f"mykey2={X.mykey2}")
+        """)
+        _, out, err = assert_python_ok("-c", code)
+        err = err.decode()
+        self.assertRegex(err, "RuntimeWarning: .*X")
+        out = out.decode()
+        self.assertRegex(out, "before=Base")
+        self.assertRegex(out, "after=Base2")
+        self.assertRegex(out, "mykey2=from Base2")
 
 
 class PicklingTests(unittest.TestCase):
@@ -5446,6 +5527,7 @@ def __repr__(self):
                                      {pickle.dumps, pickle._dumps},
                                      {pickle.loads, pickle._loads}))
 
+    @support.thread_unsafe
     def test_pickle_slots(self):
         # Tests pickling of classes with __slots__.
 
@@ -5513,6 +5595,7 @@ class E(C):
                 y = pickle_copier.copy(x)
                 self._assert_is_copy(x, y)
 
+    @support.thread_unsafe
     def test_reduce_copying(self):
         # Tests pickling and copying new-style classes and objects.
         global C1
@@ -5637,7 +5720,7 @@ def __repr__(self):
                     objcopy2 = deepcopy(objcopy)
                     self._assert_is_copy(obj, objcopy2)
 
-    @unittest.skip('TODO: RUSTPYTHON')
+    @unittest.skip("TODO: RUSTPYTHON")
     def test_issue24097(self):
         # Slot name is freed inside __getattr__ and is later used.
         class S(str):  # Not interned
@@ -5778,7 +5861,7 @@ class B(A):
         class C(B):
             pass
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_reent_set_bases_tp_base_cycle(self):
         """
         type_set_bases must check for an inheritance cycle not only through
@@ -5815,7 +5898,7 @@ class B2(A):
         with self.assertRaises(TypeError):
             B1.__bases__ += ()
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_tp_subclasses_cycle_in_update_slots(self):
         """
         type_set_bases must check for reentrancy upon finishing its job
@@ -5852,7 +5935,7 @@ class C(A):
         self.assertEqual(B1.__bases__, (C,))
         self.assertEqual(C.__subclasses__(), [B1])
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_tp_subclasses_cycle_error_return_path(self):
         """
         The same as test_tp_subclasses_cycle_in_update_slots, but tests
@@ -5921,7 +6004,7 @@ def mro(cls):
         class A(metaclass=M):
             pass
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_disappearing_custom_mro(self):
         """
         gh-92112: A custom mro() returning a result conflicting with
diff --git a/Lib/test/test_descrtut.py b/Lib/test/test_descrtut.py
index 4c128f770e2..15c3a6ebeed 100644
--- a/Lib/test/test_descrtut.py
+++ b/Lib/test/test_descrtut.py
@@ -8,7 +8,7 @@
 # of much interest anymore), and a few were fiddled to make the output
 # deterministic.
 
-from test.support import sortdict
+from test.support import sortdict  # noqa: F401
 import doctest
 import unittest
 
@@ -34,22 +34,21 @@ def merge(self, other):
             if key not in self:
                 self[key] = other[key]
 
-
 test_1 = """
 
 Here's the new type at work:
 
     >>> print(defaultdict)              # show our type
-    <class 'test.test_descrtut.defaultdict'>
+    <class '%(modname)s.defaultdict'>
     >>> print(type(defaultdict))        # its metatype
     <class 'type'>
     >>> a = defaultdict(default=0.0)    # create an instance
     >>> print(a)                        # show the instance
     {}
     >>> print(type(a))                  # show its type
-    <class 'test.test_descrtut.defaultdict'>
+    <class '%(modname)s.defaultdict'>
     >>> print(a.__class__)              # show its class
-    <class 'test.test_descrtut.defaultdict'>
+    <class '%(modname)s.defaultdict'>
     >>> print(type(a) is a.__class__)   # its type is its class
     True
     >>> a[1] = 3.25                     # modify the instance
@@ -100,7 +99,7 @@ def merge(self, other):
     >>> print(sortdict(a.__dict__))
     {'default': -1000, 'x1': 100, 'x2': 200}
     >>>
-"""
+""" % {'modname': __name__}
 
 class defaultdict2(dict):
     __slots__ = ['default']
@@ -137,10 +136,10 @@ def merge(self, other):
     >>> a.default = -1
     >>> a[1]
     -1
-    >>> a.x1 = 1
+    >>> a.x1 = 1 # TODO: RUSTPYTHON; # doctest: +EXPECTED_FAILURE
     Traceback (most recent call last):
       File "<stdin>", line 1, in ?
-    AttributeError: 'defaultdict2' object has no attribute 'x1'
+    AttributeError: 'defaultdict2' object has no attribute 'x1' and no __dict__ for setting new attributes
     >>>
 
 """
@@ -265,19 +264,19 @@ def merge(self, other):
     ...         print("classmethod", cls, y)
 
     >>> C.foo(1)
-    classmethod <class 'test.test_descrtut.C'> 1
+    classmethod <class '%(modname)s.C'> 1
     >>> c = C()
     >>> c.foo(1)
-    classmethod <class 'test.test_descrtut.C'> 1
+    classmethod <class '%(modname)s.C'> 1
 
     >>> class D(C):
     ...     pass
 
     >>> D.foo(1)
-    classmethod <class 'test.test_descrtut.D'> 1
+    classmethod <class '%(modname)s.D'> 1
     >>> d = D()
     >>> d.foo(1)
-    classmethod <class 'test.test_descrtut.D'> 1
+    classmethod <class '%(modname)s.D'> 1
 
 This prints "classmethod __main__.D 1" both times; in other words, the
 class passed as the first argument of foo() is the class involved in the
@@ -293,18 +292,18 @@ class passed as the first argument of foo() is the class involved in the
 
     >>> E.foo(1)
     E.foo() called
-    classmethod <class 'test.test_descrtut.C'> 1
+    classmethod <class '%(modname)s.C'> 1
     >>> e = E()
     >>> e.foo(1)
     E.foo() called
-    classmethod <class 'test.test_descrtut.C'> 1
+    classmethod <class '%(modname)s.C'> 1
 
 In this example, the call to C.foo() from E.foo() will see class C as its
 first argument, not class E. This is to be expected, since the call
 specifies the class C. But it stresses the difference between these class
 methods and methods defined in metaclasses (where an upcall to a metamethod
 would pass the target class as an explicit first argument).
-"""
+""" % {'modname': __name__}
 
 test_5 = """
 
@@ -465,18 +464,18 @@ def m(self):
 called A.foo()
 """
 
-# TODO: RUSTPYTHON
-__test__ = {# "tut1": test_1,
-            # "tut2": test_2,
-            # "tut3": test_3,
-            # "tut4": test_4,
+__test__ = {"tut1": test_1,
+            "tut2": test_2,
+            "tut3": test_3,
+            "tut4": test_4,
             "tut5": test_5,
             "tut6": test_6,
             "tut7": test_7,
             "tut8": test_8}
 
 def load_tests(loader, tests, pattern):
-    tests.addTest(doctest.DocTestSuite())
+    from test.support.rustpython import DocTestChecker  # TODO: RUSTPYTHON
+    tests.addTest(doctest.DocTestSuite(checker=DocTestChecker()))  # TODO: RUSTPYTHON
     return tests
 
 
diff --git a/Lib/test/test_dict.py b/Lib/test/test_dict.py
index 9598a7ab962..85d15830dcd 100644
--- a/Lib/test/test_dict.py
+++ b/Lib/test/test_dict.py
@@ -3,12 +3,22 @@
 import gc
 import pickle
 import random
+import re
 import string
 import sys
 import unittest
 import weakref
 from test import support
-from test.support import import_helper, get_c_recursion_limit
+from test.support import import_helper
+
+
+class CustomHash:
+    def __init__(self, hash):
+        self.hash = hash
+    def __hash__(self):
+        return self.hash
+    def __repr__(self):
+        return f'<CustomHash {self.hash} at {id(self):#x}>'
 
 
 class DictTest(unittest.TestCase):
@@ -265,6 +275,64 @@ def __next__(self):
 
         self.assertRaises(ValueError, {}.update, [(1, 2, 3)])
 
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    def test_update_type_error(self):
+        with self.assertRaises(TypeError) as cm:
+            {}.update([object() for _ in range(3)])
+
+        self.assertEqual(str(cm.exception), "object is not iterable")
+        self.assertEqual(
+            cm.exception.__notes__,
+            ['Cannot convert dictionary update sequence element #0 to a sequence'],
+        )
+
+        def badgen():
+            yield "key"
+            raise TypeError("oops")
+            yield "value"
+
+        with self.assertRaises(TypeError) as cm:
+            dict([badgen() for _ in range(3)])
+
+        self.assertEqual(str(cm.exception), "oops")
+        self.assertEqual(
+            cm.exception.__notes__,
+            ['Cannot convert dictionary update sequence element #0 to a sequence'],
+        )
+
+    def test_update_shared_keys(self):
+        class MyClass: pass
+
+        # Subclass str to enable us to create an object during the
+        # dict.update() call.
+        class MyStr(str):
+            def __hash__(self):
+                return super().__hash__()
+
+            def __eq__(self, other):
+                # Create an object that shares the same PyDictKeysObject as
+                # obj.__dict__.
+                obj2 = MyClass()
+                obj2.a = "a"
+                obj2.b = "b"
+                obj2.c = "c"
+                return super().__eq__(other)
+
+        obj = MyClass()
+        obj.a = "a"
+        obj.b = "b"
+
+        x = {}
+        x[MyStr("a")] = MyStr("a")
+
+        # gh-132617: this previously raised "dict mutated during update" error
+        x.update(obj.__dict__)
+
+        self.assertEqual(x, {
+            MyStr("a"): "a",
+            "b": "b",
+        })
+
     def test_fromkeys(self):
         self.assertEqual(dict.fromkeys('abc'), {'a':None, 'b':None, 'c':None})
         d = {}
@@ -369,8 +437,6 @@ def test_copy_fuzz(self):
                 self.assertNotEqual(d, d2)
                 self.assertEqual(len(d2), len(d) + 1)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_copy_maintains_tracking(self):
         class A:
             pass
@@ -613,9 +679,12 @@ def __repr__(self):
         d = {1: BadRepr()}
         self.assertRaises(Exc, repr, d)
 
+    @unittest.skip("TODO: RUSTPYTHON; segfault")
+    @support.skip_wasi_stack_overflow()
+    @support.skip_emscripten_stack_overflow()
     def test_repr_deep(self):
         d = {}
-        for i in range(get_c_recursion_limit() + 1):
+        for i in range(support.exceeds_recursion_limit()):
             d = {1: d}
         self.assertRaises(RecursionError, repr, d)
 
@@ -761,8 +830,8 @@ def test_dictview_mixed_set_operations(self):
 
     def test_missing(self):
         # Make sure dict doesn't have a __missing__ method
-        self.assertFalse(hasattr(dict, "__missing__"))
-        self.assertFalse(hasattr({}, "__missing__"))
+        self.assertNotHasAttr(dict, "__missing__")
+        self.assertNotHasAttr({}, "__missing__")
         # Test several cases:
         # (D) subclass defines __missing__ method returning a value
         # (E) subclass defines __missing__ method raising RuntimeError
@@ -883,8 +952,7 @@ def test_empty_presized_dict_in_freelist(self):
                  'f': None, 'g': None, 'h': None}
         d = {}
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_container_iterator(self):
         # Bug #3680: tp_traverse was not implemented for dictiter and
         # dictview objects.
@@ -901,127 +969,6 @@ class C(object):
             gc.collect()
             self.assertIs(ref(), None, "Cycle was not collected")
 
-    def _not_tracked(self, t):
-        # Nested containers can take several collections to untrack
-        gc.collect()
-        gc.collect()
-        self.assertFalse(gc.is_tracked(t), t)
-
-    def _tracked(self, t):
-        self.assertTrue(gc.is_tracked(t), t)
-        gc.collect()
-        gc.collect()
-        self.assertTrue(gc.is_tracked(t), t)
-
-    def test_string_keys_can_track_values(self):
-        # Test that this doesn't leak.
-        for i in range(10):
-            d = {}
-            for j in range(10):
-                d[str(j)] = j
-            d["foo"] = d
-
-    @support.cpython_only
-    def test_track_literals(self):
-        # Test GC-optimization of dict literals
-        x, y, z, w = 1.5, "a", (1, None), []
-
-        self._not_tracked({})
-        self._not_tracked({x:(), y:x, z:1})
-        self._not_tracked({1: "a", "b": 2})
-        self._not_tracked({1: 2, (None, True, False, ()): int})
-        self._not_tracked({1: object()})
-
-        # Dicts with mutable elements are always tracked, even if those
-        # elements are not tracked right now.
-        self._tracked({1: []})
-        self._tracked({1: ([],)})
-        self._tracked({1: {}})
-        self._tracked({1: set()})
-
-    @support.cpython_only
-    def test_track_dynamic(self):
-        # Test GC-optimization of dynamically-created dicts
-        class MyObject(object):
-            pass
-        x, y, z, w, o = 1.5, "a", (1, object()), [], MyObject()
-
-        d = dict()
-        self._not_tracked(d)
-        d[1] = "a"
-        self._not_tracked(d)
-        d[y] = 2
-        self._not_tracked(d)
-        d[z] = 3
-        self._not_tracked(d)
-        self._not_tracked(d.copy())
-        d[4] = w
-        self._tracked(d)
-        self._tracked(d.copy())
-        d[4] = None
-        self._not_tracked(d)
-        self._not_tracked(d.copy())
-
-        # dd isn't tracked right now, but it may mutate and therefore d
-        # which contains it must be tracked.
-        d = dict()
-        dd = dict()
-        d[1] = dd
-        self._not_tracked(dd)
-        self._tracked(d)
-        dd[1] = d
-        self._tracked(dd)
-
-        d = dict.fromkeys([x, y, z])
-        self._not_tracked(d)
-        dd = dict()
-        dd.update(d)
-        self._not_tracked(dd)
-        d = dict.fromkeys([x, y, z, o])
-        self._tracked(d)
-        dd = dict()
-        dd.update(d)
-        self._tracked(dd)
-
-        d = dict(x=x, y=y, z=z)
-        self._not_tracked(d)
-        d = dict(x=x, y=y, z=z, w=w)
-        self._tracked(d)
-        d = dict()
-        d.update(x=x, y=y, z=z)
-        self._not_tracked(d)
-        d.update(w=w)
-        self._tracked(d)
-
-        d = dict([(x, y), (z, 1)])
-        self._not_tracked(d)
-        d = dict([(x, y), (z, w)])
-        self._tracked(d)
-        d = dict()
-        d.update([(x, y), (z, 1)])
-        self._not_tracked(d)
-        d.update([(x, y), (z, w)])
-        self._tracked(d)
-
-    @support.cpython_only
-    def test_track_subtypes(self):
-        # Dict subtypes are always tracked
-        class MyDict(dict):
-            pass
-        self._tracked(MyDict())
-
-    @support.cpython_only
-    def test_track_lazy_instance_dicts(self):
-        class C:
-            pass
-        o = C()
-        d = o.__dict__
-        self._not_tracked(d)
-        o.untracked = 42
-        self._not_tracked(d)
-        o.tracked = []
-        self._tracked(d)
-
     def make_shared_key_dict(self, n):
         class C:
             pass
@@ -1312,16 +1259,14 @@ def __eq__(self, o):
         d = {X(): 0, 1: 1}
         self.assertRaises(RuntimeError, d.update, other)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_free_after_iterating(self):
         support.check_free_after_iterating(self, iter, dict)
         support.check_free_after_iterating(self, lambda d: iter(d.keys()), dict)
         support.check_free_after_iterating(self, lambda d: iter(d.values()), dict)
         support.check_free_after_iterating(self, lambda d: iter(d.items()), dict)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_equal_operator_modifying_operand(self):
         # test fix for seg fault reported in bpo-27945 part 3.
         class X():
@@ -1629,6 +1574,118 @@ def make_pairs():
                 self.assertEqual(d.get(key3_3), 44)
                 self.assertGreaterEqual(eq_count, 1)
 
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    def test_unhashable_key(self):
+        d = {'a': 1}
+        key = [1, 2, 3]
+
+        def check_unhashable_key():
+            msg = "cannot use 'list' as a dict key (unhashable type: 'list')"
+            return self.assertRaisesRegex(TypeError, re.escape(msg))
+
+        with check_unhashable_key():
+            key in d
+        with check_unhashable_key():
+            d[key]
+        with check_unhashable_key():
+            d[key] = 2
+        with check_unhashable_key():
+            d.setdefault(key, 2)
+        with check_unhashable_key():
+            d.pop(key)
+        with check_unhashable_key():
+            d.get(key)
+
+        # Only TypeError exception is overriden,
+        # other exceptions are left unchanged.
+        class HashError:
+            def __hash__(self):
+                raise KeyError('error')
+
+        key2 = HashError()
+        with self.assertRaises(KeyError):
+            key2 in d
+        with self.assertRaises(KeyError):
+            d[key2]
+        with self.assertRaises(KeyError):
+            d[key2] = 2
+        with self.assertRaises(KeyError):
+            d.setdefault(key2, 2)
+        with self.assertRaises(KeyError):
+            d.pop(key2)
+        with self.assertRaises(KeyError):
+            d.get(key2)
+
+    def test_clear_at_lookup(self):
+        # gh-140551 dict crash if clear is called at lookup stage
+        class X:
+            def __hash__(self):
+                return 1
+            def __eq__(self, other):
+                nonlocal d
+                d.clear()
+
+        d = {}
+        for _ in range(10):
+            d[X()] = None
+
+        self.assertEqual(len(d), 1)
+
+        d = {}
+        for _ in range(10):
+            d.setdefault(X(), None)
+
+        self.assertEqual(len(d), 1)
+
+    def test_split_table_update_with_str_subclass(self):
+        # gh-142218: inserting into a split table dictionary with a non str
+        # key that matches an existing key.
+        class MyStr(str): pass
+        class MyClass: pass
+        obj = MyClass()
+        obj.attr = 1
+        obj.__dict__[MyStr('attr')] = 2
+        self.assertEqual(obj.attr, 2)
+
+    def test_split_table_insert_with_str_subclass(self):
+        # gh-143189: inserting into split table dictionary with a non str
+        # key that matches an existing key in the shared table but not in
+        # the dict yet.
+
+        class MyStr(str): pass
+        class MyClass: pass
+
+        obj = MyClass()
+        obj.attr1 = 1
+
+        obj2 = MyClass()
+        d = obj2.__dict__
+        d[MyStr("attr1")] = 2
+        self.assertIsInstance(list(d)[0], MyStr)
+
+    def test_hash_collision_remove_add(self):
+        self.maxDiff = None
+        # There should be enough space, so all elements with unique hash
+        # will be placed in corresponding cells without collision.
+        n = 64
+        items = [(CustomHash(h), h) for h in range(n)]
+        # Keys with hash collision.
+        a = CustomHash(n)
+        b = CustomHash(n)
+        items += [(a, 'a'), (b, 'b')]
+        d = dict(items)
+        self.assertEqual(len(d), len(items), d)
+        del d[a]
+        # "a" has been replaced with a dummy.
+        del items[n]
+        self.assertEqual(len(d), len(items), d)
+        self.assertEqual(d, dict(items))
+        d[b] = 'c'
+        # "b" should not replace the dummy.
+        items[n] = (b, 'c')
+        self.assertEqual(len(d), len(items), d)
+        self.assertEqual(d, dict(items))
+
 
 class CAPITest(unittest.TestCase):
 
diff --git a/Lib/test/test_dictcomps.py b/Lib/test/test_dictcomps.py
index 233faa90c72..fc7ebb0f5a6 100644
--- a/Lib/test/test_dictcomps.py
+++ b/Lib/test/test_dictcomps.py
@@ -1,5 +1,8 @@
+import traceback
 import unittest
 
+from test.support import BrokenIter
+
 # For scope testing.
 g = "Global variable"
 
@@ -72,8 +75,7 @@ def test_local_visibility(self):
         self.assertEqual(actual, expected)
         self.assertEqual(v, "Local variable")
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_illegal_assignment(self):
         with self.assertRaisesRegex(SyntaxError, "cannot assign"):
             compile("{x: y for y, x in ((1, 2), (3, 4))} = 5", "<test>",
@@ -129,6 +131,41 @@ def test_star_expression(self):
         self.assertEqual({i: i*i for i in [*range(4)]}, expected)
         self.assertEqual({i: i*i for i in (*range(4),)}, expected)
 
+    def test_exception_locations(self):
+        # The location of an exception raised from __init__ or
+        # __next__ should should be the iterator expression
+        def init_raises():
+            try:
+                {x:x for x in BrokenIter(init_raises=True)}
+            except Exception as e:
+                return e
+
+        def next_raises():
+            try:
+                {x:x for x in BrokenIter(next_raises=True)}
+            except Exception as e:
+                return e
+
+        def iter_raises():
+            try:
+                {x:x for x in BrokenIter(iter_raises=True)}
+            except Exception as e:
+                return e
+
+        for func, expected in [(init_raises, "BrokenIter(init_raises=True)"),
+                               (next_raises, "BrokenIter(next_raises=True)"),
+                               (iter_raises, "BrokenIter(iter_raises=True)"),
+                              ]:
+            with self.subTest(func):
+                exc = func()
+                f = traceback.extract_tb(exc.__traceback__)[0]
+                indent = 16
+                co = func.__code__
+                self.assertEqual(f.lineno, co.co_firstlineno + 2)
+                self.assertEqual(f.end_lineno, co.co_firstlineno + 2)
+                self.assertEqual(f.line[f.colno - indent : f.end_colno - indent],
+                                 expected)
+
 
 if __name__ == "__main__":
     unittest.main()
diff --git a/Lib/test/test_dictviews.py b/Lib/test/test_dictviews.py
index 667cccd6cd7..2809417ffa1 100644
--- a/Lib/test/test_dictviews.py
+++ b/Lib/test/test_dictviews.py
@@ -2,7 +2,7 @@
 import copy
 import pickle
 import unittest
-from test.support import get_c_recursion_limit
+from test.support import skip_emscripten_stack_overflow, skip_wasi_stack_overflow, exceeds_recursion_limit
 
 class DictSetTest(unittest.TestCase):
 
@@ -277,11 +277,12 @@ def test_recursive_repr(self):
         # Again.
         self.assertIsInstance(r, str)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.skip("TODO: RUSTPYTHON; segfault")
+    @skip_wasi_stack_overflow()
+    @skip_emscripten_stack_overflow()
     def test_deeply_nested_repr(self):
         d = {}
-        for i in range(get_c_recursion_limit()//2 + 100):
+        for i in range(exceeds_recursion_limit()):
             d = {42: d.values()}
         self.assertRaises(RecursionError, repr, d)
 
@@ -291,8 +292,7 @@ def test_copy(self):
         self.assertRaises(TypeError, copy.copy, d.values())
         self.assertRaises(TypeError, copy.copy, d.items())
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_compare_error(self):
         class Exc(Exception):
             pass
diff --git a/Lib/test/test_difflib.py b/Lib/test/test_difflib.py
index 943d7a659b1..36be5c99c3f 100644
--- a/Lib/test/test_difflib.py
+++ b/Lib/test/test_difflib.py
@@ -282,6 +282,26 @@ def test_make_file_usascii_charset_with_nonascii_input(self):
         self.assertIn('content="text/html; charset=us-ascii"', output)
         self.assertIn('&#305;mpl&#305;c&#305;t', output)
 
+class TestDiffer(unittest.TestCase):
+    def test_close_matches_aligned(self):
+        # Of the 4 closely matching pairs, we want 1 to match with 3,
+        # and 2 with 4, to align with a "top to bottom" mental model.
+        a = ["cat\n", "dog\n", "close match 1\n", "close match 2\n"]
+        b = ["close match 3\n", "close match 4\n", "kitten\n", "puppy\n"]
+        m = difflib.Differ().compare(a, b)
+        self.assertEqual(list(m),
+                           ['- cat\n',
+                            '- dog\n',
+                            '- close match 1\n',
+                            '?             ^\n',
+                            '+ close match 3\n',
+                            '?             ^\n',
+                            '- close match 2\n',
+                            '?             ^\n',
+                            '+ close match 4\n',
+                            '?             ^\n',
+                            '+ kitten\n',
+                            '+ puppy\n'])
 
     def test_one_insert(self):
         m = difflib.Differ().compare('b' * 2, 'a' + 'b' * 2)
@@ -294,7 +314,7 @@ def test_one_delete(self):
 
 class TestOutputFormat(unittest.TestCase):
     def test_tab_delimiter(self):
-        args = ['one', 'two', 'Original', 'Current',
+        args = [['one'], ['two'], 'Original', 'Current',
             '2005-01-26 23:30:50', '2010-04-02 10:20:52']
         ud = difflib.unified_diff(*args, lineterm='')
         self.assertEqual(list(ud)[0:2], [
@@ -306,7 +326,7 @@ def test_tab_delimiter(self):
                            "--- Current\t2010-04-02 10:20:52"])
 
     def test_no_trailing_tab_on_empty_filedate(self):
-        args = ['one', 'two', 'Original', 'Current']
+        args = [['one'], ['two'], 'Original', 'Current']
         ud = difflib.unified_diff(*args, lineterm='')
         self.assertEqual(list(ud)[0:2], ["--- Original", "+++ Current"])
 
@@ -446,6 +466,28 @@ def assertDiff(expect, actual):
                                     lineterm=b'')
         assertDiff(expect, actual)
 
+
+class TestInputTypes(unittest.TestCase):
+    def _assert_type_error(self, msg, generator, *args):
+        with self.assertRaises(TypeError) as ctx:
+            list(generator(*args))
+        self.assertEqual(msg, str(ctx.exception))
+
+    def test_input_type_checks(self):
+        unified = difflib.unified_diff
+        context = difflib.context_diff
+
+        expect = "input must be a sequence of strings, not str"
+        self._assert_type_error(expect, unified, 'a', ['b'])
+        self._assert_type_error(expect, context, 'a', ['b'])
+
+        self._assert_type_error(expect, unified, ['a'], 'b')
+        self._assert_type_error(expect, context, ['a'], 'b')
+
+        expect = "lines to compare must be str, not NoneType (None)"
+        self._assert_type_error(expect, unified, ['a'], [None])
+        self._assert_type_error(expect, context, ['a'], [None])
+
     def test_mixed_types_content(self):
         # type of input content must be consistent: all str or all bytes
         a = [b'hello']
@@ -494,10 +536,6 @@ def test_mixed_types_dates(self):
         b = ['bar\n']
         list(difflib.unified_diff(a, b, 'a', 'b', datea, dateb))
 
-    def _assert_type_error(self, msg, generator, *args):
-        with self.assertRaises(TypeError) as ctx:
-            list(generator(*args))
-        self.assertEqual(msg, str(ctx.exception))
 
 class TestJunkAPIs(unittest.TestCase):
     def test_is_line_junk_true(self):
diff --git a/Lib/test/test_difflib_expect.html b/Lib/test/test_difflib_expect.html
index 12091206a28..9f33a9e9c9c 100644
--- a/Lib/test/test_difflib_expect.html
+++ b/Lib/test/test_difflib_expect.html
@@ -9,13 +9,22 @@
           content="text/html; charset=utf-8" />
     <title></title>
     <style type="text/css">
+        :root {color-scheme: light dark}
         table.diff {font-family: Menlo, Consolas, Monaco, Liberation Mono, Lucida Console, monospace; border:medium}
         .diff_header {background-color:#e0e0e0}
         td.diff_header {text-align:right}
         .diff_next {background-color:#c0c0c0}
-        .diff_add {background-color:#aaffaa}
+        .diff_add {background-color:palegreen}
         .diff_chg {background-color:#ffff77}
         .diff_sub {background-color:#ffaaaa}
+
+        @media (prefers-color-scheme: dark) {
+            .diff_header {background-color:#666}
+            .diff_next {background-color:#393939}
+            .diff_add {background-color:darkgreen}
+            .diff_chg {background-color:#847415}
+            .diff_sub {background-color:darkred}
+        }
     </style>
 </head>
 
diff --git a/Lib/test/test_dis.py b/Lib/test/test_dis.py
index ec851f939c9..15455a0fce8 100644
--- a/Lib/test/test_dis.py
+++ b/Lib/test/test_dis.py
@@ -1005,7 +1005,6 @@ 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',
                             'LOAD_FAST_BORROW_LOAD_FAST_BORROW',
@@ -1131,12 +1130,10 @@ 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)
@@ -1147,7 +1144,6 @@ 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 = {}
@@ -1180,7 +1176,6 @@ def test_disassemble_str(self):
         self.do_disassembly_test(fn_with_annotate_str, dis_fn_with_annotate_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)
 
@@ -2119,7 +2114,6 @@ def test_oparg_alias(self):
                                   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:
@@ -2422,7 +2416,6 @@ def test__find_imports(self):
                 self.assertEqual(len(res), 1)
                 self.assertEqual(res[0], expected)
 
-    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test__find_store_names(self):
         cases = [
             ("x+y", ()),
@@ -2589,7 +2582,6 @@ def f():
             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()'
diff --git a/Lib/test/test_doctest/test_doctest.py b/Lib/test/test_doctest/test_doctest.py
index 48d5ff6f73f..4a42abf44e5 100644
--- a/Lib/test/test_doctest/test_doctest.py
+++ b/Lib/test/test_doctest/test_doctest.py
@@ -4,7 +4,6 @@
 
 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
@@ -16,7 +15,6 @@
 import tempfile
 import types
 import contextlib
-import _colorize
 
 
 def doctest_skip_if(condition):
@@ -471,7 +469,7 @@ def basics(): r"""
     >>> tests = finder.find(sample_func)
 
     >>> print(tests)  # doctest: +ELLIPSIS
-    [<DocTest sample_func from test_doctest.py:38 (1 example)>]
+    [<DocTest sample_func from test_doctest.py:36 (1 example)>]
 
 The exact name depends on how test_doctest was invoked, so allow for
 leading path components.
@@ -733,47 +731,44 @@ def basics(): r"""
     [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.
-# """
+    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)
+    >>> 750 < len(tests) < 800 # approximate number of objects with docstrings  # TODO: RUSTPYTHON # doctest: +EXPECTED_FAILURE
+    True
+    >>> real_tests = [t for t in tests if len(t.examples) > 0]
+    >>> len(real_tests) # objects that actually have doctests  # TODO: RUSTPYTHON # doctest: +EXPECTED_FAILURE
+    14
+    >>> for t in real_tests:  # TODO: RUSTPYTHON # doctest: +EXPECTED_FAILURE
+    ...     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):
@@ -900,6 +895,7 @@ def basics(): r"""
 DocTestRunner is used to run DocTest test cases, and to accumulate
 statistics.  Here's a simple DocTest case we can use:
 
+    >>> import _colorize
     >>> save_colorize = _colorize.COLORIZE
     >>> _colorize.COLORIZE = False
 
@@ -1034,6 +1030,7 @@ def exceptions(): r"""
 lines between the first line and the type/value may be omitted or
 replaced with any other string:
 
+    >>> import _colorize
     >>> save_colorize = _colorize.COLORIZE
     >>> _colorize.COLORIZE = False
 
@@ -1042,7 +1039,7 @@ def exceptions(): r"""
     ...     >>> x = 12
     ...     >>> print(x//0)
     ...     Traceback (most recent call last):
-    ...     ZeroDivisionError: integer division or modulo by zero
+    ...     ZeroDivisionError: division by zero
     ...     '''
     >>> test = doctest.DocTestFinder().find(f)[0]
     >>> doctest.DocTestRunner(verbose=False).run(test)
@@ -1059,7 +1056,7 @@ def exceptions(): r"""
     ...     >>> print('pre-exception output', x//0)
     ...     pre-exception output
     ...     Traceback (most recent call last):
-    ...     ZeroDivisionError: integer division or modulo by zero
+    ...     ZeroDivisionError: division by zero
     ...     '''
     >>> test = doctest.DocTestFinder().find(f)[0]
     >>> doctest.DocTestRunner(verbose=False).run(test)
@@ -1070,7 +1067,7 @@ def exceptions(): r"""
         print('pre-exception output', x//0)
     Exception raised:
         ...
-        ZeroDivisionError: integer division or modulo by zero
+        ZeroDivisionError: division by zero
     TestResults(failed=1, attempted=2)
 
 Exception messages may contain newlines:
@@ -1265,7 +1262,7 @@ def exceptions(): r"""
     Exception raised:
         Traceback (most recent call last):
         ...
-        ZeroDivisionError: integer division or modulo by zero
+        ZeroDivisionError: division by zero
     TestResults(failed=1, attempted=1)
 
     >>> _colorize.COLORIZE = save_colorize
@@ -1310,6 +1307,7 @@ def optionflags(): r"""
 The DONT_ACCEPT_TRUE_FOR_1 flag disables matches between True/False
 and 1/0:
 
+    >>> import _colorize
     >>> save_colorize = _colorize.COLORIZE
     >>> _colorize.COLORIZE = False
 
@@ -1743,6 +1741,7 @@ def option_directives(): r"""
 single example.  To turn an option on for an example, follow that
 example with a comment of the form ``# doctest: +OPTION``:
 
+    >>> import _colorize
     >>> save_colorize = _colorize.COLORIZE
     >>> _colorize.COLORIZE = False
 
@@ -1997,851 +1996,752 @@ def test_testsource(): r"""
     <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_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:
+
+    >>> from test.support.pty_helper import FakeInput
+    >>> 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
+
+"""
+
+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.
+
+          >>> import _colorize
+          >>> 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:
+
+          >>> from test.support.pty_helper import FakeInput
+          >>> 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[11]>(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)  # TODO: RUSTPYTHON # doctest: +EXPECTED_FAILURE
+          ... 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
+          """
+
+    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)
+        >>> from test.support.pty_helper import FakeInput
+        >>> 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)
+    """
+
+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.
+    """
+
+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
+         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 "<doctest test.test_doctest.sample_doctest_errors[1]>", line 1, in <module>
+                 1/0
+                 ~^~
+             ZeroDivisionError: division by zero
+         <BLANKLINE>
+         >>> print(result.failures[1][1]) # doctest: +ELLIPSIS
+         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 "<doctest test.test_doctest.sample_doctest_errors.__test__.bad[1]>", line 1, in <module>
+                 1/0
+                 ~^~
+             ZeroDivisionError: division by zero
+         <BLANKLINE>
+         >>> print(result.failures[2][1]) # doctest: +ELLIPSIS
+         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 "<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 "<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 "<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>
+         >>> print(result.failures[3][1]) # doctest: +ELLIPSIS
+         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:
+               File "<doctest test.test_doctest.sample_doctest_errors.syntax_error[0]>", line 1
+                 2+*3
+                   ^
+             SyntaxError: invalid syntax
+         <BLANKLINE>
+    """
+
+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>
+
+       '/' 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>
+    """
+
+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
+        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 "<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 "<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:
+              File "<doctest test_doctest_errors.txt[4]>", line 1
+                2+*3
+                  ^
+            SyntaxError: invalid syntax
+        <BLANKLINE>
+    """
 
 def test_trailing_space_in_test():
     """
@@ -2913,7 +2813,8 @@ def test_unittest_reportflags():
       >>> result
       <unittest.result.TestResult run=1 errors=0 failures=1>
       >>> print(result.failures[0][1]) # doctest: +ELLIPSIS
-      Traceback ...
+      AssertionError: Failed doctest test for test_doctest.txt
+      ...
       Failed example:
           favorite_color
       ...
@@ -2932,14 +2833,14 @@ def test_unittest_reportflags():
       >>> result
       <unittest.result.TestResult run=1 errors=0 failures=1>
       >>> print(result.failures[0][1]) # doctest: +ELLIPSIS
-      Traceback ...
+      AssertionError: Failed doctest test for test_doctest.txt
+      ...
       Failed example:
           favorite_color
       Exception raised:
           ...
           NameError: name 'favorite_color' is not defined
       <BLANKLINE>
-      <BLANKLINE>
 
     We get only the first failure.
 
@@ -2959,7 +2860,8 @@ def test_unittest_reportflags():
     the trailing whitespace using `\x20` in the diff below.
 
       >>> print(result.failures[0][1]) # doctest: +ELLIPSIS
-      Traceback ...
+      AssertionError: Failed doctest test for test_doctest.txt
+      ...
       Failed example:
           favorite_color
       ...
@@ -2974,7 +2876,6 @@ def test_unittest_reportflags():
           +\x20
             b
       <BLANKLINE>
-      <BLANKLINE>
 
 
     Test runners can restore the formatting flags after they run:
@@ -2991,6 +2892,7 @@ def test_testfile(): r"""
 
 We don't want color or `-v` in sys.argv for these tests.
 
+    >>> import _colorize
     >>> save_colorize = _colorize.COLORIZE
     >>> _colorize.COLORIZE = False
 
@@ -3163,74 +3065,56 @@ def test_testfile(): r"""
     >>> _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)
-# """
+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 "<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 "<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:
+          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):
 
@@ -3276,82 +3160,80 @@ def test_hook(pathdir):
     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_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
@@ -3364,142 +3246,109 @@ def test_testmod(): r"""
     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)
-# """
+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 "<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 "<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 "<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 "<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 "<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:
+          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")
@@ -3508,278 +3357,269 @@ def test_testmod(): r"""
     # 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...
-
-# """
+if supports_unicode:
+    def test_unicode(): """
+Check doctest with a non-ascii filename:
+
+    >>> import _colorize
+    >>> 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 "<doctest foo-bär@baz[0]>", line 1, in <module>
+            raise Exception('clé')
+        Exception: clé
+    TestResults(failed=1, attempted=1)
+
+    >>> _colorize.COLORIZE = save_colorize
+    """
+
+
+@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"""
@@ -3841,6 +3681,7 @@ def test_run_doctestsuite_multiple_times():
 
 def test_exception_with_note(note):
     """
+    >>> import _colorize
     >>> save_colorize = _colorize.COLORIZE
     >>> _colorize.COLORIZE = False
 
@@ -3975,6 +3816,7 @@ def test_syntax_error_subclass_from_stdlib():
 
 def test_syntax_error_with_incorrect_expected_note():
     """
+    >>> import _colorize
     >>> save_colorize = _colorize.COLORIZE
     >>> _colorize.COLORIZE = False
 
@@ -4013,7 +3855,8 @@ def test_syntax_error_with_incorrect_expected_note():
 
 def load_tests(loader, tests, pattern):
     tests.addTest(doctest.DocTestSuite(doctest))
-    tests.addTest(doctest.DocTestSuite())
+    from test.support.rustpython import DocTestChecker  # TODO: RUSTPYTHON
+    tests.addTest(doctest.DocTestSuite(checker=DocTestChecker()))  # TODO: RUSTPYTHON
     return tests
 
 
diff --git a/Lib/test/test_docxmlrpc.py b/Lib/test/test_docxmlrpc.py
index 999533a72a1..2ad422079b7 100644
--- a/Lib/test/test_docxmlrpc.py
+++ b/Lib/test/test_docxmlrpc.py
@@ -88,8 +88,6 @@ def tearDown(self):
         self.thread.join()
         self.serv.server_close()
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_valid_get_response(self):
         self.client.request("GET", "/")
         response = self.client.getresponse()
@@ -119,7 +117,6 @@ def test_invalid_get_response(self):
 
         response.read()
 
-    @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
@@ -134,8 +131,6 @@ def test_lambda(self):
                        b'&lt;lambda&gt;</strong></a>(x, y)</dt></dl>'),
                       response.read())
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     @make_request_and_skipIf(sys.flags.optimize >= 2,
                      "Docstrings are omitted with -O2 and above")
     def test_autolinking(self):
@@ -160,7 +155,6 @@ 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")
     def test_system_methods(self):
@@ -190,7 +184,6 @@ 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.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 +193,6 @@ def test_autolink_dotted_methods(self):
         self.assertIn(b"""Try&nbsp;self.<strong>add</strong>,&nbsp;too.""",
                       response.read())
 
-    @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 +206,6 @@ def test_annotations(self):
              b'method_annotation</strong></a>(x: bytes)</dt></dl>'),
             response.read())
 
-    @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_dynamic.py b/Lib/test/test_dynamic.py
index 9fd2d867107..948a2029f1e 100644
--- a/Lib/test/test_dynamic.py
+++ b/Lib/test/test_dynamic.py
@@ -4,7 +4,7 @@
 import sys
 import unittest
 
-from test.support import swap_item, swap_attr, is_wasi, Py_DEBUG
+from test.support import swap_item, swap_attr, skip_wasi_stack_overflow
 
 
 class RebindBuiltinsTests(unittest.TestCase):
@@ -134,8 +134,9 @@ def test_eval_gives_lambda_custom_globals(self):
 
         self.assertEqual(foo(), 7)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
-    @unittest.skipIf(is_wasi and Py_DEBUG, "requires too much stack")
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    @skip_wasi_stack_overflow()
     def test_load_global_specialization_failure_keeps_oparg(self):
         # https://github.com/python/cpython/issues/91625
         class MyGlobals(dict):
diff --git a/Lib/test/test_dynamicclassattribute.py b/Lib/test/test_dynamicclassattribute.py
index 9f694d9eb46..b19be33c72f 100644
--- a/Lib/test/test_dynamicclassattribute.py
+++ b/Lib/test/test_dynamicclassattribute.py
@@ -104,8 +104,8 @@ def test_property_decorator_baseclass(self):
         self.assertEqual(base.spam, 10)
         self.assertEqual(base._spam, 10)
         delattr(base, "spam")
-        self.assertTrue(not hasattr(base, "spam"))
-        self.assertTrue(not hasattr(base, "_spam"))
+        self.assertNotHasAttr(base, "spam")
+        self.assertNotHasAttr(base, "_spam")
         base.spam = 20
         self.assertEqual(base.spam, 20)
         self.assertEqual(base._spam, 20)
diff --git a/Lib/test/test_enum.py b/Lib/test/test_enum.py
index 9f09098ebad..75e2353ea16 100644
--- a/Lib/test/test_enum.py
+++ b/Lib/test/test_enum.py
@@ -11,7 +11,6 @@
 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
@@ -20,7 +19,8 @@
 from pickle import dumps, loads, PicklingError, HIGHEST_PROTOCOL
 from test import support
 from test.support import ALWAYS_EQ, REPO_ROOT
-from test.support import threading_helper
+from test.support import threading_helper, cpython_only
+from test.support.import_helper import ensure_lazy_imports
 from datetime import timedelta
 
 python_version = sys.version_info[:2]
@@ -434,9 +434,9 @@ class Season(self.enum_type):
             def spam(cls):
                 pass
         #
-        self.assertTrue(hasattr(Season, 'spam'))
+        self.assertHasAttr(Season, 'spam')
         del Season.spam
-        self.assertFalse(hasattr(Season, 'spam'))
+        self.assertNotHasAttr(Season, 'spam')
         #
         with self.assertRaises(AttributeError):
             del Season.SPRING
@@ -445,8 +445,6 @@ def spam(cls):
         with self.assertRaises(AttributeError):
             del Season.SPRING.name
 
-    @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(
                 TypeError,
@@ -659,9 +657,6 @@ def __repr__(self):
         self.assertEqual(str(Generic.item), 'item.test')
 
     def test_overridden_str(self):
-        # TODO: RUSTPYTHON, format(NS.first) does not use __str__
-        if self.__class__ in (TestIntFlagFunction, TestIntFlagClass, TestIntEnumFunction, TestIntEnumClass, TestMinimalFloatFunction, TestMinimalFloatClass):
-            self.skipTest("format(NS.first) does not use __str__")
         NS = self.NewStrEnum
         self.assertEqual(str(NS.first), NS.first.name.upper())
         self.assertEqual(format(NS.first), NS.first.name.upper())
@@ -1544,22 +1539,6 @@ 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
@@ -1769,7 +1748,7 @@ class ThreePart(Enum):
         self.assertIs(ThreePart((3, 3.0, 'three')), ThreePart.THREE)
         self.assertIs(ThreePart(3, 3.0, 'three'), ThreePart.THREE)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON; AssertionError: <test.test_enum.IntStooges object at 0x55c70c38a240> is not <IntStooges.MOE: 3>
+    @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)
@@ -1923,8 +1902,6 @@ def test_wrong_inheritance_order(self):
             class Wrong(Enum, str):
                 NotHere = 'error before this point'
 
-    @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):
             def __init__(self, r, g, b):
@@ -2612,8 +2589,6 @@ class Test(Base2):
         self.assertEqual(Test.flash.flash, 'flashy dynamic')
         self.assertEqual(Test.flash.value, 1)
 
-    @unittest.expectedFailure # 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):
@@ -2678,12 +2653,12 @@ def __new__(cls, value, period):
             OneDay = day_1
             OneWeek = week_1
             OneMonth = month_1
-        self.assertFalse(hasattr(Period, '_ignore_'))
-        self.assertFalse(hasattr(Period, 'Period'))
-        self.assertFalse(hasattr(Period, 'i'))
-        self.assertTrue(isinstance(Period.day_1, timedelta))
-        self.assertTrue(Period.month_1 is Period.day_30)
-        self.assertTrue(Period.week_4 is Period.day_28)
+        self.assertNotHasAttr(Period, '_ignore_')
+        self.assertNotHasAttr(Period, 'Period')
+        self.assertNotHasAttr(Period, 'i')
+        self.assertIsInstance(Period.day_1, timedelta)
+        self.assertIs(Period.month_1, Period.day_30)
+        self.assertIs(Period.week_4, Period.day_28)
 
     def test_nonhash_value(self):
         class AutoNumberInAList(Enum):
@@ -2903,7 +2878,7 @@ class ReformedColor(StrMixin, IntEnum, SomeEnum, AnotherEnum):
         self.assertEqual(str(ReformedColor.BLUE), 'blue')
         self.assertEqual(ReformedColor.RED.behavior(), 'booyah')
         self.assertEqual(ConfusedColor.RED.social(), "what's up?")
-        self.assertTrue(issubclass(ReformedColor, int))
+        self.assertIsSubclass(ReformedColor, int)
 
     def test_multiple_inherited_mixin(self):
         @unique
@@ -2999,8 +2974,6 @@ def test_empty_globals(self):
         local_ls = {}
         exec(code, global_ns, local_ls)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
-    # RuntimeError: Error calling __set_name__ on '_proto_member' instance one in 'FirstFailedStrEnum'
     def test_strenum(self):
         class GoodStrEnum(StrEnum):
             one = '1'
@@ -3063,7 +3036,7 @@ class ThirdFailedStrEnum(StrEnum):
                 one = '1'
                 two = b'2', 'ascii', 9
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON; fails on encoding testing : TypeError: Expected type 'str' but 'builtin_function_or_method' found
+    @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
@@ -3125,8 +3098,6 @@ class ThirdFailedStrEnum(CustomStrEnum):
                 one = '1'
                 two = b'2', 'ascii', 9
 
-    @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__"):
             class Combined(str, Enum):
@@ -3413,8 +3384,6 @@ def __new__(cls, c):
         self.assertEqual(FlagFromChar.a, 158456325028528675187087900672)
         self.assertEqual(FlagFromChar.a|1, 158456325028528675187087900673)
 
-    @unittest.expectedFailure # 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):
@@ -4003,7 +3972,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):
@@ -4162,7 +4131,6 @@ def test_global_enum_str(self):
         self.assertEqual(str(NoName.ONE & NoName.TWO), 'NoName(0)')
         self.assertEqual(str(NoName(0)), 'NoName(0)')
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON; format(NewPerm.R) does not use __str__
     def test_format(self):
         Perm = self.Perm
         self.assertEqual(format(Perm.R, ''), '4')
@@ -4525,7 +4493,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):
@@ -5074,7 +5042,6 @@ class Color(Enum):
         MAGENTA = 2
         YELLOW = 3
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_pydoc(self):
         # indirectly test __objclass__
         if StrEnum.__doc__ is None:
@@ -5186,7 +5153,6 @@ 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(
@@ -5327,6 +5293,10 @@ class MiscTestCase(unittest.TestCase):
     def test__all__(self):
         support.check__all__(self, enum, not_exported={'bin', 'show_flag_values'})
 
+    @cpython_only
+    def test_lazy_import(self):
+        ensure_lazy_imports("enum", {"functools", "warnings", "inspect", "re"})
+
     def test_doc_1(self):
         class Single(Enum):
             ONE = 1
diff --git a/Lib/test/test_errno.py b/Lib/test/test_errno.py
index 5c437e9ccea..e7f185c6b1a 100644
--- a/Lib/test/test_errno.py
+++ b/Lib/test/test_errno.py
@@ -12,14 +12,12 @@ class ErrnoAttributeTests(unittest.TestCase):
     def test_for_improper_attributes(self):
         # No unexpected attributes should be on the module.
         for error_code in std_c_errors:
-            self.assertTrue(hasattr(errno, error_code),
-                            "errno is missing %s" % error_code)
+            self.assertHasAttr(errno, error_code)
 
     def test_using_errorcode(self):
         # Every key value in errno.errorcode should be on the module.
         for value in errno.errorcode.values():
-            self.assertTrue(hasattr(errno, value),
-                            'no %s attr in errno' % value)
+            self.assertHasAttr(errno, value)
 
 
 class ErrorcodeTests(unittest.TestCase):
diff --git a/Lib/test/test_except_star.py b/Lib/test/test_except_star.py
index 3e0f8caa9b2..807e7c5a5d6 100644
--- a/Lib/test/test_except_star.py
+++ b/Lib/test/test_except_star.py
@@ -84,7 +84,8 @@ def test_break_in_except_star(self):
                     if i == 2:
                         break
                 finally:
-                    return 0
+                    pass
+                return 0
             """)
 
 
@@ -117,7 +118,8 @@ def test_continue_in_except_star_block_invalid(self):
                     if i == 2:
                         continue
                 finally:
-                    return 0
+                    pass
+                return 0
             """)
 
     def test_return_in_except_star_block_invalid(self):
@@ -889,8 +891,7 @@ def test_raise_handle_all_raise_two_unnamed(self):
 
 
 class TestExceptStarExceptionGroupSubclass(ExceptStarTest):
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_except_star_EG_subclass(self):
         class EG(ExceptionGroup):
             def __new__(cls, message, excs, code):
@@ -1217,4 +1218,4 @@ def test_reraise_unhashable_eg(self):
 
 
 if __name__ == '__main__':
-    unittest.main()
\ No newline at end of file
+    unittest.main()
diff --git a/Lib/test/test_exception_group.py b/Lib/test/test_exception_group.py
index 2b48530a309..507bbc2ecbc 100644
--- a/Lib/test/test_exception_group.py
+++ b/Lib/test/test_exception_group.py
@@ -1,16 +1,14 @@
 import collections.abc
 import types
 import unittest
-from test.support import get_c_recursion_limit
+from test.support import skip_emscripten_stack_overflow, skip_wasi_stack_overflow, exceeds_recursion_limit
 
 class TestExceptionGroupTypeHierarchy(unittest.TestCase):
     def test_exception_group_types(self):
-        self.assertTrue(issubclass(ExceptionGroup, Exception))
-        self.assertTrue(issubclass(ExceptionGroup, BaseExceptionGroup))
-        self.assertTrue(issubclass(BaseExceptionGroup, BaseException))
+        self.assertIsSubclass(ExceptionGroup, Exception)
+        self.assertIsSubclass(ExceptionGroup, BaseExceptionGroup)
+        self.assertIsSubclass(BaseExceptionGroup, BaseException)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_exception_is_not_generic_type(self):
         with self.assertRaisesRegex(TypeError, 'Exception'):
             Exception[OSError]
@@ -22,8 +20,7 @@ def test_exception_group_is_generic_type(self):
 
 
 class BadConstructorArgs(unittest.TestCase):
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_bad_EG_construction__too_many_args(self):
         MSG = r'BaseExceptionGroup.__new__\(\) takes exactly 2 arguments'
         with self.assertRaisesRegex(TypeError, MSG):
@@ -464,15 +461,21 @@ def test_basics_split_by_predicate__match(self):
 class DeepRecursionInSplitAndSubgroup(unittest.TestCase):
     def make_deep_eg(self):
         e = TypeError(1)
-        for i in range(get_c_recursion_limit() + 1):
+        for i in range(exceeds_recursion_limit()):
             e = ExceptionGroup('eg', [e])
         return e
 
+    @unittest.skip("TODO: RUSTPYTHON; Segfault")
+    @skip_emscripten_stack_overflow()
+    @skip_wasi_stack_overflow()
     def test_deep_split(self):
         e = self.make_deep_eg()
         with self.assertRaises(RecursionError):
             e.split(TypeError)
 
+    @unittest.skip("TODO: RUSTPYTHON; Segfault")
+    @skip_emscripten_stack_overflow()
+    @skip_wasi_stack_overflow()
     def test_deep_subgroup(self):
         e = self.make_deep_eg()
         with self.assertRaises(RecursionError):
@@ -814,8 +817,8 @@ def test_split_does_not_copy_non_sequence_notes(self):
         eg = ExceptionGroup("eg", [ValueError(1), TypeError(2)])
         eg.__notes__ = 123
         match, rest = eg.split(TypeError)
-        self.assertFalse(hasattr(match, '__notes__'))
-        self.assertFalse(hasattr(rest, '__notes__'))
+        self.assertNotHasAttr(match, '__notes__')
+        self.assertNotHasAttr(rest, '__notes__')
 
     def test_drive_invalid_return_value(self):
         class MyEg(ExceptionGroup):
diff --git a/Lib/test/test_exception_hierarchy.py b/Lib/test/test_exception_hierarchy.py
index e8c1c7fd1e7..3472019ea13 100644
--- a/Lib/test/test_exception_hierarchy.py
+++ b/Lib/test/test_exception_hierarchy.py
@@ -146,8 +146,7 @@ def test_errno_translation(self):
         self.assertEqual(e.strerror, "File already exists")
         self.assertEqual(e.filename, "foo.txt")
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_blockingioerror(self):
         args = ("a", "b", "c", "d", "e")
         for n in range(6):
@@ -182,8 +181,7 @@ def test_init_kwdargs(self):
         self.assertEqual(e.bar, "baz")
         self.assertEqual(e.args, ("some message",))
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_new_overridden(self):
         e = SubOSErrorWithNew("some message", "baz")
         self.assertEqual(e.baz, "baz")
diff --git a/Lib/test/test_exception_variations.py b/Lib/test/test_exception_variations.py
index e103eaf8466..a83a41d2975 100644
--- a/Lib/test/test_exception_variations.py
+++ b/Lib/test/test_exception_variations.py
@@ -294,8 +294,6 @@ def test_nested_exception_in_finally_with_exception(self):
         self.assertTrue(hit_except)
 
 
-# TODO: RUSTPYTHON
-'''
 class ExceptStarTestCases(unittest.TestCase):
     def test_try_except_else_finally(self):
         hit_except = False
@@ -571,7 +569,7 @@ def test_nested_else_mixed2(self):
         self.assertFalse(hit_else)
         self.assertTrue(hit_finally)
         self.assertTrue(hit_except)
-'''
+
 
 if __name__ == '__main__':
     unittest.main()
diff --git a/Lib/test/test_exceptions.py b/Lib/test/test_exceptions.py
index 0c273935cb4..10010ffa9b8 100644
--- a/Lib/test/test_exceptions.py
+++ b/Lib/test/test_exceptions.py
@@ -60,7 +60,7 @@ def raise_catch(self, exc, excname):
             self.assertEqual(buf1, buf2)
             self.assertEqual(exc.__name__, excname)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def testRaising(self):
         self.raise_catch(AttributeError, "AttributeError")
         self.assertRaises(AttributeError, getattr, sys, "undefined_attribute")
@@ -145,7 +145,7 @@ def testRaising(self):
 
         self.raise_catch(StopAsyncIteration, "StopAsyncIteration")
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def testSyntaxErrorMessage(self):
         # make sure the right exception message is raised for each of
         # these code fragments
@@ -170,7 +170,7 @@ def ckmsg(src, msg):
         ckmsg("continue\n", "'continue' not properly in loop")
         ckmsg("f'{6 0}'", "invalid syntax. Perhaps you forgot a comma?")
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def testSyntaxErrorMissingParens(self):
         def ckmsg(src, msg, exception=SyntaxError):
             try:
@@ -227,14 +227,16 @@ def check(self, src, lineno, offset, end_lineno=None, end_offset=None, encoding=
                 if not isinstance(src, str):
                     src = src.decode(encoding, 'replace')
                 line = src.split('\n')[lineno-1]
+                if lineno == 1:
+                    line = line.removeprefix('\ufeff')
                 self.assertIn(line, cm.exception.text)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_error_offset_continuation_characters(self):
         check = self.check
         check('"\\\n"(1 for c in I,\\\n\\', 2, 2)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def testSyntaxErrorOffset(self):
         check = self.check
         check('def fact(x):\n\treturn x!\n', 2, 10)
@@ -244,7 +246,9 @@ def testSyntaxErrorOffset(self):
         check('Python = "\u1e54\xfd\u0163\u0125\xf2\xf1" +', 1, 20)
         check(b'# -*- coding: cp1251 -*-\nPython = "\xcf\xb3\xf2\xee\xed" +',
               2, 19, encoding='cp1251')
-        check(b'Python = "\xcf\xb3\xf2\xee\xed" +', 1, 10)
+        check(b'Python = "\xcf\xb3\xf2\xee\xed" +', 1, 12)
+        check(b'\n\n\nPython = "\xcf\xb3\xf2\xee\xed" +', 4, 12)
+        check(b'\xef\xbb\xbfPython = "\xcf\xb3\xf2\xee\xed" +', 1, 12)
         check('x = "a', 1, 5)
         check('lambda x: x = 2', 1, 1)
         check('f{a + b + c}', 1, 2)
@@ -292,7 +296,7 @@ def baz():
         check("pass\npass\npass\n(1+)\npass\npass\npass", 4, 4)
         check("(1+)", 1, 4)
         check("[interesting\nfoo()\n", 1, 1)
-        check(b"\xef\xbb\xbf#coding: utf8\nprint('\xe6\x88\x91')\n", 0, -1)
+        check(b"\xef\xbb\xbf#coding: utf8\nprint('\xe6\x88\x91')\n", 1, 0)
         check("""f'''
             {
             (123_a)
@@ -362,7 +366,7 @@ def test_capi1():
             except TypeError as err:
                 co = err.__traceback__.tb_frame.f_code
                 self.assertEqual(co.co_name, "test_capi1")
-                self.assertTrue(co.co_filename.endswith('test_exceptions.py'))
+                self.assertEndsWith(co.co_filename, 'test_exceptions.py')
             else:
                 self.fail("Expected exception")
 
@@ -374,7 +378,7 @@ def test_capi2():
                 tb = err.__traceback__.tb_next
                 co = tb.tb_frame.f_code
                 self.assertEqual(co.co_name, "__init__")
-                self.assertTrue(co.co_filename.endswith('test_exceptions.py'))
+                self.assertEndsWith(co.co_filename, 'test_exceptions.py')
                 co2 = tb.tb_frame.f_back.f_code
                 self.assertEqual(co2.co_name, "test_capi2")
             else:
@@ -428,9 +432,9 @@ def test_WindowsError(self):
             self.assertEqual(w.filename, None)
             self.assertEqual(w.filename2, None)
 
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     @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')
@@ -439,7 +443,7 @@ def test_windows_message(self):
         with self.assertRaisesRegex(OSError, 'Windows Error 0x%x' % code):
             ctypes.pythonapi.PyErr_SetFromWindowsErr(code)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def testAttributes(self):
         # test that exception attributes are happy
 
@@ -605,7 +609,7 @@ def test_invalid_setstate(self):
     def test_notes(self):
         for e in [BaseException(1), Exception(2), ValueError(3)]:
             with self.subTest(e=e):
-                self.assertFalse(hasattr(e, '__notes__'))
+                self.assertNotHasAttr(e, '__notes__')
                 e.add_note("My Note")
                 self.assertEqual(e.__notes__, ["My Note"])
 
@@ -617,7 +621,7 @@ def test_notes(self):
                 self.assertEqual(e.__notes__, ["My Note", "Your Note"])
 
                 del e.__notes__
-                self.assertFalse(hasattr(e, '__notes__'))
+                self.assertNotHasAttr(e, '__notes__')
 
                 e.add_note("Our Note")
                 self.assertEqual(e.__notes__, ["Our Note"])
@@ -658,7 +662,7 @@ def testInvalidTraceback(self):
         else:
             self.fail("No exception raised")
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_invalid_setattr(self):
         TE = TypeError
         exc = Exception()
@@ -671,7 +675,7 @@ def test_invalid_setattr(self):
         msg = "exception context must be None or derive from BaseException"
         self.assertRaisesRegex(TE, msg, setattr, exc, '__context__', 1)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_invalid_delattr(self):
         TE = TypeError
         try:
@@ -743,7 +747,6 @@ def __init__(self, fancy_arg):
         x = DerivedException(fancy_arg=42)
         self.assertEqual(x.fancy_arg, 42)
 
-    @unittest.skipIf(sys.platform == 'win32', 'TODO: RUSTPYTHON; Windows')
     @no_tracing
     def testInfiniteRecursion(self):
         def f():
@@ -1304,7 +1307,7 @@ def test_context_of_exception_in_else_and_finally(self):
         self.assertIs(exc, oe)
         self.assertIs(exc.__context__, ve)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_unicode_change_attributes(self):
         # See issue 7309. This was a crasher.
 
@@ -1348,7 +1351,7 @@ def test_unicode_errors_no_object(self):
         for klass in klasses:
             self.assertEqual(str(klass.__new__(klass)), "")
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON; OverflowError: Python int too large to convert to Rust usize
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; OverflowError: Python int too large to convert to Rust usize
     def test_unicode_error_str_does_not_crash(self):
         # Test that str(UnicodeError(...)) does not crash.
         # See https://github.com/python/cpython/issues/123378.
@@ -1372,7 +1375,45 @@ def test_unicode_error_str_does_not_crash(self):
                 exc = UnicodeDecodeError('utf-8', encoded, start, end, '')
                 self.assertIsInstance(str(exc), str)
 
-    @unittest.skipIf(sys.platform == 'win32', 'TODO: RUSTPYTHON; Windows')
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    def test_unicode_error_evil_str_set_none_object(self):
+        def side_effect(exc):
+            exc.object = None
+        self.do_test_unicode_error_mutate(side_effect)
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    def test_unicode_error_evil_str_del_self_object(self):
+        def side_effect(exc):
+            del exc.object
+        self.do_test_unicode_error_mutate(side_effect)
+
+    def do_test_unicode_error_mutate(self, side_effect):
+        # Test that str(UnicodeError(...)) does not crash when
+        # side-effects mutate the underlying 'object' attribute.
+        # See https://github.com/python/cpython/issues/128974.
+
+        class Evil(str):
+            def __str__(self):
+                side_effect(exc)
+                return self
+
+        for reason, encoding in [
+            ("reason", Evil("utf-8")),
+            (Evil("reason"), "utf-8"),
+            (Evil("reason"), Evil("utf-8")),
+        ]:
+            with self.subTest(encoding=encoding, reason=reason):
+                with self.subTest(UnicodeEncodeError):
+                    exc = UnicodeEncodeError(encoding, "x", 0, 1, reason)
+                    self.assertRaises(TypeError, str, exc)
+                with self.subTest(UnicodeDecodeError):
+                    exc = UnicodeDecodeError(encoding, b"x", 0, 1, reason)
+                    self.assertRaises(TypeError, str, exc)
+
+        with self.subTest(UnicodeTranslateError):
+            exc = UnicodeTranslateError("x", 0, 1, Evil("reason"))
+            self.assertRaises(TypeError, str, exc)
+
     @no_tracing
     def test_badisinstance(self):
         # Bug #2542: if issubclass(e, MyException) raises an exception,
@@ -1404,7 +1445,8 @@ def g():
         self.assertIsInstance(exc, RecursionError, type(exc))
         self.assertIn("maximum recursion depth exceeded", str(exc))
 
-
+    @support.skip_wasi_stack_overflow()
+    @support.skip_emscripten_stack_overflow()
     @cpython_only
     @support.requires_resource('cpu')
     def test_trashcan_recursion(self):
@@ -1420,6 +1462,7 @@ def foo():
         foo()
         support.gc_collect()
 
+    @support.skip_emscripten_stack_overflow()
     @cpython_only
     def test_recursion_normalizing_exception(self):
         import_module("_testinternalcapi")
@@ -1492,11 +1535,12 @@ def test_recursion_normalizing_infinite_exception(self):
         """
         rc, out, err = script_helper.assert_python_failure("-c", code)
         self.assertEqual(rc, 1)
-        expected = b'RecursionError: maximum recursion depth exceeded'
+        expected = b'RecursionError'
         self.assertTrue(expected in err, msg=f"{expected!r} not found in {err[:3_000]!r}... (truncated)")
         self.assertIn(b'Done.', out)
 
 
+    @support.skip_emscripten_stack_overflow()
     def test_recursion_in_except_handler(self):
 
         def set_relative_recursion_limit(n):
@@ -1602,7 +1646,7 @@ def test_exception_with_doc(self):
         # test basic usage of PyErr_NewException
         error1 = _testcapi.make_exception_with_doc("_testcapi.error1")
         self.assertIs(type(error1), type)
-        self.assertTrue(issubclass(error1, Exception))
+        self.assertIsSubclass(error1, Exception)
         self.assertIsNone(error1.__doc__)
 
         # test with given docstring
@@ -1612,21 +1656,21 @@ def test_exception_with_doc(self):
         # test with explicit base (without docstring)
         error3 = _testcapi.make_exception_with_doc("_testcapi.error3",
                                                    base=error2)
-        self.assertTrue(issubclass(error3, error2))
+        self.assertIsSubclass(error3, error2)
 
         # test with explicit base tuple
         class C(object):
             pass
         error4 = _testcapi.make_exception_with_doc("_testcapi.error4", doc4,
                                                    (error3, C))
-        self.assertTrue(issubclass(error4, error3))
-        self.assertTrue(issubclass(error4, C))
+        self.assertIsSubclass(error4, error3)
+        self.assertIsSubclass(error4, C)
         self.assertEqual(error4.__doc__, doc4)
 
         # test with explicit dictionary
         error5 = _testcapi.make_exception_with_doc("_testcapi.error5", "",
                                                    error4, {'a': 1})
-        self.assertTrue(issubclass(error5, error4))
+        self.assertIsSubclass(error5, error4)
         self.assertEqual(error5.a, 1)
         self.assertEqual(error5.__doc__, "")
 
@@ -1654,7 +1698,6 @@ def inner():
         gc_collect()  # For PyPy or other GCs.
         self.assertEqual(wr(), None)
 
-    @unittest.skipIf(sys.platform == 'win32', 'TODO: RUSTPYTHON; Windows')
     @no_tracing
     def test_recursion_error_cleanup(self):
         # Same test as above, but with "recursion exceeded" errors
@@ -1676,13 +1719,13 @@ def inner():
         gc_collect()  # For PyPy or other GCs.
         self.assertEqual(wr(), None)
 
-    @unittest.skipIf(sys.platform == 'win32', 'TODO: RUSTPYTHON; error specific to cpython')
     def test_errno_ENOTDIR(self):
         # Issue #12802: "not a directory" errors are ENOTDIR even on Windows
         with self.assertRaises(OSError) as cm:
             os.listdir(__file__)
         self.assertEqual(cm.exception.errno, errno.ENOTDIR, cm.exception)
 
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AssertionError: None != 'Exception ignored while calling dealloca[83 chars]200>'
     def test_unraisable(self):
         # Issue #22836: PyErr_WriteUnraisable() should give sensible reports
         class BrokenDel:
@@ -1693,13 +1736,15 @@ def __del__(self):
 
         obj = BrokenDel()
         with support.catch_unraisable_exception() as cm:
+            obj_repr = repr(type(obj).__del__)
             del obj
 
             gc_collect()  # For PyPy or other GCs.
-            self.assertEqual(cm.unraisable.object, BrokenDel.__del__)
+            self.assertEqual(cm.unraisable.err_msg,
+                             f"Exception ignored while calling "
+                             f"deallocator {obj_repr}")
             self.assertIsNotNone(cm.unraisable.exc_traceback)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_unhandled(self):
         # Check for sensible reporting of unhandled exceptions
         for exc_type in (ValueError, BrokenStrException):
@@ -1719,7 +1764,7 @@ def test_unhandled(self):
                     self.assertIn("<exception str() failed>", report)
                 else:
                     self.assertIn("test message", report)
-                self.assertTrue(report.endswith("\n"))
+                self.assertEndsWith(report, "\n")
 
     @cpython_only
     # Python built with Py_TRACE_REFS fail with a fatal error in
@@ -1859,6 +1904,30 @@ def test_memory_error_in_subinterp(self):
         rc, _, err = script_helper.assert_python_ok("-c", code)
         self.assertIn(b'MemoryError', err)
 
+    def test_keyerror_context(self):
+        # Make sure that _PyErr_SetKeyError() chains exceptions
+        try:
+            err1 = None
+            err2 = None
+            try:
+                d = {}
+                try:
+                    raise ValueError("bug")
+                except Exception as exc:
+                    err1 = exc
+                    d[1]
+            except Exception as exc:
+                err2 = exc
+
+            self.assertIsInstance(err1, ValueError)
+            self.assertIsInstance(err2, KeyError)
+            self.assertEqual(err2.__context__, err1)
+        finally:
+            # Break any potential reference cycle
+            exc1 = None
+            exc2 = None
+
+
     @cpython_only
     # Python built with Py_TRACE_REFS fail with a fatal error in
     # _PyRefchain_Trace() on memory allocation error.
@@ -1872,7 +1941,7 @@ def test_exec_set_nomemory_hang(self):
         # PyLong_FromLong() from returning cached integers, which
         # don't require a memory allocation. Prepend some dummy code
         # to artificially increase the instruction index.
-        warmup_code = "a = list(range(0, 1))\n" * 20
+        warmup_code = "a = list(range(0, 1))\n" * 60
         user_input = warmup_code + dedent("""
             try:
                 import _testcapi
@@ -1987,7 +2056,7 @@ def blech(self):
 
 class ImportErrorTests(unittest.TestCase):
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_attributes(self):
         # Setting 'name' and 'path' should not be a problem.
         exc = ImportError('test')
@@ -2077,7 +2146,7 @@ class AssertionErrorTests(unittest.TestCase):
     def tearDown(self):
         unlink(TESTFN)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     @force_not_colorized
     def test_assertion_error_location(self):
         cases = [
@@ -2176,7 +2245,7 @@ def test_assertion_error_location(self):
                 result = run_script(source)
                 self.assertEqual(result[-3:], expected)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     @force_not_colorized
     def test_multiline_not_highlighted(self):
         cases = [
@@ -2213,7 +2282,6 @@ def test_multiline_not_highlighted(self):
 class SyntaxErrorTests(unittest.TestCase):
     maxDiff = None
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     @force_not_colorized
     def test_range_of_offsets(self):
         cases = [
@@ -2305,6 +2373,7 @@ def test_range_of_offsets(self):
                     self.assertIn(expected, err.getvalue())
                     the_exception = exc
 
+    @force_not_colorized
     def test_subclass(self):
         class MySyntaxError(SyntaxError):
             pass
@@ -2320,7 +2389,7 @@ class MySyntaxError(SyntaxError):
      ^^^^^
 """, err.getvalue())
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_encodings(self):
         self.addCleanup(unlink, TESTFN)
         source = (
@@ -2329,7 +2398,7 @@ def test_encodings(self):
         )
         err = run_script(source.encode('cp437'))
         self.assertEqual(err[-3], '    "¢¢¢¢¢¢" + f(4, x for x in range(1))')
-        self.assertEqual(err[-2], '                          ^^^^^^^^^^^^^^^^^^^')
+        self.assertEqual(err[-2], '                            ^^^')
 
         # Check backwards tokenizer errors
         source = '# -*- coding: ascii -*-\n\n(\n'
@@ -2337,14 +2406,14 @@ def test_encodings(self):
         self.assertEqual(err[-3], '    (')
         self.assertEqual(err[-2], '    ^')
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_non_utf8(self):
         # Check non utf-8 characters
         self.addCleanup(unlink, TESTFN)
         err = run_script(b"\x89")
         self.assertIn("SyntaxError: Non-UTF-8 code starting with '\\x89' in file", err[-1])
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_string_source(self):
         def try_compile(source):
             with self.assertRaises(SyntaxError) as cm:
@@ -2387,7 +2456,7 @@ def try_compile(source):
         self.assertEqual(exc.offset, 1)
         self.assertEqual(exc.end_offset, 12)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_file_source(self):
         self.addCleanup(unlink, TESTFN)
         err = run_script('return "ä"')
@@ -2450,12 +2519,11 @@ def test_attributes_old_constructor(self):
         self.assertEqual(error, the_exception.text)
         self.assertEqual("bad bad", the_exception.msg)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_incorrect_constructor(self):
         args = ("bad.py", 1, 2)
         self.assertRaises(TypeError, SyntaxError, "bad bad", args)
 
-        args = ("bad.py", 1, 2, 4, 5, 6, 7)
+        args = ("bad.py", 1, 2, 4, 5, 6, 7, 8)
         self.assertRaises(TypeError, SyntaxError, "bad bad", args)
 
         args = ("bad.py", 1, 2, "abcdefg", 1)
@@ -2512,7 +2580,7 @@ def in_except():
                 pass
         self.lineno_after_raise(in_except, 4)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_lineno_after_other_except(self):
         def other_except():
             try:
@@ -2530,7 +2598,7 @@ def in_named_except():
                 pass
         self.lineno_after_raise(in_named_except, 4)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_lineno_in_try(self):
         def in_try():
             try:
@@ -2569,7 +2637,7 @@ def after_with():
                 pass
         self.lineno_after_raise(after_with, 2)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_missing_lineno_shows_as_none(self):
         def f():
             1/0
diff --git a/Lib/test/test_extcall.py b/Lib/test/test_extcall.py
new file mode 100644
index 00000000000..483d5ad5f2b
--- /dev/null
+++ b/Lib/test/test_extcall.py
@@ -0,0 +1,561 @@
+
+"""Doctest for method/function calls.
+
+We're going the use these types for extra testing
+
+    >>> from collections import UserList
+    >>> from collections import UserDict
+
+We're defining four helper functions
+
+    >>> from test import support
+    >>> def e(a,b):
+    ...     print(a, b)
+
+    >>> def f(*a, **k):
+    ...     print(a, support.sortdict(k))
+
+    >>> def g(x, *y, **z):
+    ...     print(x, y, support.sortdict(z))
+
+    >>> def h(j=1, a=2, h=3):
+    ...     print(j, a, h)
+
+Argument list examples
+
+    >>> f()
+    () {}
+    >>> f(1)
+    (1,) {}
+    >>> f(1, 2)
+    (1, 2) {}
+    >>> f(1, 2, 3)
+    (1, 2, 3) {}
+    >>> f(1, 2, 3, *(4, 5))
+    (1, 2, 3, 4, 5) {}
+    >>> f(1, 2, 3, *[4, 5])
+    (1, 2, 3, 4, 5) {}
+    >>> f(*[1, 2, 3], 4, 5)
+    (1, 2, 3, 4, 5) {}
+    >>> f(1, 2, 3, *UserList([4, 5]))
+    (1, 2, 3, 4, 5) {}
+    >>> f(1, 2, 3, *[4, 5], *[6, 7])
+    (1, 2, 3, 4, 5, 6, 7) {}
+    >>> f(1, *[2, 3], 4, *[5, 6], 7)
+    (1, 2, 3, 4, 5, 6, 7) {}
+    >>> f(*UserList([1, 2]), *UserList([3, 4]), 5, *UserList([6, 7]))
+    (1, 2, 3, 4, 5, 6, 7) {}
+
+Here we add keyword arguments
+
+    >>> f(1, 2, 3, **{'a':4, 'b':5})
+    (1, 2, 3) {'a': 4, 'b': 5}
+    >>> f(1, 2, **{'a': -1, 'b': 5}, **{'a': 4, 'c': 6})
+    Traceback (most recent call last):
+        ...
+    TypeError: test.test_extcall.f() got multiple values for keyword argument 'a'
+    >>> f(1, 2, **{'a': -1, 'b': 5}, a=4, c=6)
+    Traceback (most recent call last):
+        ...
+    TypeError: test.test_extcall.f() got multiple values for keyword argument 'a'
+    >>> f(1, 2, a=3, **{'a': 4}, **{'a': 5})
+    Traceback (most recent call last):
+        ...
+    TypeError: test.test_extcall.f() got multiple values for keyword argument 'a'
+    >>> f(1, 2, 3, *[4, 5], **{'a':6, 'b':7})
+    (1, 2, 3, 4, 5) {'a': 6, 'b': 7}
+    >>> f(1, 2, 3, x=4, y=5, *(6, 7), **{'a':8, 'b': 9})
+    (1, 2, 3, 6, 7) {'a': 8, 'b': 9, 'x': 4, 'y': 5}
+    >>> f(1, 2, 3, *[4, 5], **{'c': 8}, **{'a':6, 'b':7})
+    (1, 2, 3, 4, 5) {'a': 6, 'b': 7, 'c': 8}
+    >>> f(1, 2, 3, *(4, 5), x=6, y=7, **{'a':8, 'b': 9})
+    (1, 2, 3, 4, 5) {'a': 8, 'b': 9, 'x': 6, 'y': 7}
+
+    >>> f(1, 2, 3, **UserDict(a=4, b=5))
+    (1, 2, 3) {'a': 4, 'b': 5}
+    >>> f(1, 2, 3, *(4, 5), **UserDict(a=6, b=7))
+    (1, 2, 3, 4, 5) {'a': 6, 'b': 7}
+    >>> f(1, 2, 3, x=4, y=5, *(6, 7), **UserDict(a=8, b=9))
+    (1, 2, 3, 6, 7) {'a': 8, 'b': 9, 'x': 4, 'y': 5}
+    >>> f(1, 2, 3, *(4, 5), x=6, y=7, **UserDict(a=8, b=9))
+    (1, 2, 3, 4, 5) {'a': 8, 'b': 9, 'x': 6, 'y': 7}
+
+Mix keyword arguments and dict unpacking
+
+    >>> d1 = {'a':1}
+
+    >>> d2 = {'c':3}
+
+    >>> f(b=2, **d1, **d2)
+    () {'a': 1, 'b': 2, 'c': 3}
+
+    >>> f(**d1, b=2, **d2)
+    () {'a': 1, 'b': 2, 'c': 3}
+
+    >>> f(**d1, **d2, b=2)
+    () {'a': 1, 'b': 2, 'c': 3}
+
+    >>> f(**d1, b=2, **d2, d=4)
+    () {'a': 1, 'b': 2, 'c': 3, 'd': 4}
+
+Examples with invalid arguments (TypeErrors). We're also testing the function
+names in the exception messages.
+
+Verify clearing of SF bug #733667
+
+    >>> e(c=4)
+    Traceback (most recent call last):
+      ...
+    TypeError: e() got an unexpected keyword argument 'c'
+
+    >>> g()
+    Traceback (most recent call last):
+      ...
+    TypeError: g() missing 1 required positional argument: 'x'
+
+    >>> g(*())
+    Traceback (most recent call last):
+      ...
+    TypeError: g() missing 1 required positional argument: 'x'
+
+    >>> g(*(), **{})
+    Traceback (most recent call last):
+      ...
+    TypeError: g() missing 1 required positional argument: 'x'
+
+    >>> g(1)
+    1 () {}
+    >>> g(1, 2)
+    1 (2,) {}
+    >>> g(1, 2, 3)
+    1 (2, 3) {}
+    >>> g(1, 2, 3, *(4, 5))
+    1 (2, 3, 4, 5) {}
+
+    >>> class Nothing: pass
+    ...
+    >>> g(*Nothing())
+    Traceback (most recent call last):
+      ...
+    TypeError: test.test_extcall.g() argument after * must be an iterable, not Nothing
+
+    >>> class Nothing:
+    ...     def __len__(self): return 5
+    ...
+
+    >>> g(*Nothing())
+    Traceback (most recent call last):
+      ...
+    TypeError: test.test_extcall.g() argument after * must be an iterable, not Nothing
+
+    >>> class Nothing():
+    ...     def __len__(self): return 5
+    ...     def __getitem__(self, i):
+    ...         if i<3: return i
+    ...         else: raise IndexError(i)
+    ...
+
+    >>> g(*Nothing())
+    0 (1, 2) {}
+
+    >>> class Nothing:
+    ...     def __init__(self): self.c = 0
+    ...     def __iter__(self): return self
+    ...     def __next__(self):
+    ...         if self.c == 4:
+    ...             raise StopIteration
+    ...         c = self.c
+    ...         self.c += 1
+    ...         return c
+    ...
+
+    >>> g(*Nothing())
+    0 (1, 2, 3) {}
+
+Check for issue #4806: Does a TypeError in a generator get propagated with the
+right error message? (Also check with other iterables.)
+
+    >>> def broken(): raise TypeError("myerror")
+    ...
+
+    >>> g(*(broken() for i in range(1)))
+    Traceback (most recent call last):
+      ...
+    TypeError: myerror
+    >>> g(*range(1), *(broken() for i in range(1)))
+    Traceback (most recent call last):
+      ...
+    TypeError: myerror
+
+    >>> class BrokenIterable1:
+    ...     def __iter__(self):
+    ...         raise TypeError('myerror')
+    ...
+    >>> g(*BrokenIterable1())
+    Traceback (most recent call last):
+      ...
+    TypeError: myerror
+    >>> g(*range(1), *BrokenIterable1())
+    Traceback (most recent call last):
+      ...
+    TypeError: myerror
+
+    >>> class BrokenIterable2:
+    ...     def __iter__(self):
+    ...         yield 0
+    ...         raise TypeError('myerror')
+    ...
+    >>> g(*BrokenIterable2())
+    Traceback (most recent call last):
+      ...
+    TypeError: myerror
+    >>> g(*range(1), *BrokenIterable2())
+    Traceback (most recent call last):
+      ...
+    TypeError: myerror
+
+    >>> class BrokenSequence:
+    ...     def __getitem__(self, idx):
+    ...         raise TypeError('myerror')
+    ...
+    >>> g(*BrokenSequence())
+    Traceback (most recent call last):
+      ...
+    TypeError: myerror
+    >>> g(*range(1), *BrokenSequence())
+    Traceback (most recent call last):
+      ...
+    TypeError: myerror
+
+Make sure that the function doesn't stomp the dictionary
+
+    >>> d = {'a': 1, 'b': 2, 'c': 3}
+    >>> d2 = d.copy()
+    >>> g(1, d=4, **d)
+    1 () {'a': 1, 'b': 2, 'c': 3, 'd': 4}
+    >>> d == d2
+    True
+
+What about willful misconduct?
+
+    >>> def saboteur(**kw):
+    ...     kw['x'] = 'm'
+    ...     return kw
+
+    >>> d = {}
+    >>> kw = saboteur(a=1, **d)
+    >>> d
+    {}
+
+
+    >>> g(1, 2, 3, **{'x': 4, 'y': 5})
+    Traceback (most recent call last):
+      ...
+    TypeError: g() got multiple values for argument 'x'
+
+    >>> f(**{1:2})
+    Traceback (most recent call last):
+      ...
+    TypeError: keywords must be strings
+
+    >>> h(**{'e': 2})
+    Traceback (most recent call last):
+      ...
+    TypeError: h() got an unexpected keyword argument 'e'
+
+    >>> h(*h)
+    Traceback (most recent call last):
+      ...
+    TypeError: test.test_extcall.h() argument after * must be an iterable, not function
+
+    >>> h(1, *h)
+    Traceback (most recent call last):
+      ...
+    TypeError: Value after * must be an iterable, not function
+
+    >>> h(*[1], *h)
+    Traceback (most recent call last):
+      ...
+    TypeError: Value after * must be an iterable, not function
+
+    >>> dir(*h)
+    Traceback (most recent call last):
+      ...
+    TypeError: dir() argument after * must be an iterable, not function
+
+    >>> nothing = None
+    >>> nothing(*h)
+    Traceback (most recent call last):
+      ...
+    TypeError: None argument after * must be an iterable, \
+not function
+
+    >>> h(**h)
+    Traceback (most recent call last):
+      ...
+    TypeError: test.test_extcall.h() argument after ** must be a mapping, not function
+
+    >>> h(**[])
+    Traceback (most recent call last):
+      ...
+    TypeError: test.test_extcall.h() argument after ** must be a mapping, not list
+
+    >>> h(a=1, **h)
+    Traceback (most recent call last):
+      ...
+    TypeError: test.test_extcall.h() argument after ** must be a mapping, not function
+
+    >>> h(a=1, **[])
+    Traceback (most recent call last):
+      ...
+    TypeError: test.test_extcall.h() argument after ** must be a mapping, not list
+
+    >>> h(**{'a': 1}, **h)
+    Traceback (most recent call last):
+      ...
+    TypeError: test.test_extcall.h() argument after ** must be a mapping, not function
+
+    >>> h(**{'a': 1}, **[])
+    Traceback (most recent call last):
+      ...
+    TypeError: test.test_extcall.h() argument after ** must be a mapping, not list
+
+    >>> dir(**h)
+    Traceback (most recent call last):
+      ...
+    TypeError: dir() argument after ** must be a mapping, not function
+
+    >>> nothing(**h)
+    Traceback (most recent call last):
+      ...
+    TypeError: None argument after ** must be a mapping, \
+not function
+
+    >>> dir(b=1, **{'b': 1})
+    Traceback (most recent call last):
+      ...
+    TypeError: dir() got multiple values for keyword argument 'b'
+
+Test a kwargs mapping with duplicated keys.
+
+    >>> from collections.abc import Mapping
+    >>> class MultiDict(Mapping):
+    ...     def __init__(self, items):
+    ...         self._items = items
+    ...
+    ...     def __iter__(self):
+    ...         return (k for k, v in self._items)
+    ...
+    ...     def __getitem__(self, key):
+    ...         for k, v in self._items:
+    ...             if k == key:
+    ...                 return v
+    ...         raise KeyError(key)
+    ...
+    ...     def __len__(self):
+    ...         return len(self._items)
+    ...
+    ...     def keys(self):
+    ...         return [k for k, v in self._items]
+    ...
+    ...     def values(self):
+    ...         return [v for k, v in self._items]
+    ...
+    ...     def items(self):
+    ...         return [(k, v) for k, v in self._items]
+    ...
+    >>> g(**MultiDict([('x', 1), ('y', 2)]))
+    1 () {'y': 2}
+
+    >>> g(**MultiDict([('x', 1), ('x', 2)]))
+    Traceback (most recent call last):
+      ...
+    TypeError: test.test_extcall.g() got multiple values for keyword argument 'x'
+
+    >>> g(a=3, **MultiDict([('x', 1), ('x', 2)]))
+    Traceback (most recent call last):
+      ...
+    TypeError: test.test_extcall.g() got multiple values for keyword argument 'x'
+
+    >>> g(**MultiDict([('a', 3)]), **MultiDict([('x', 1), ('x', 2)]))
+    Traceback (most recent call last):
+      ...
+    TypeError: test.test_extcall.g() got multiple values for keyword argument 'x'
+
+Call with dict subtype:
+
+    >>> class MyDict(dict):
+    ...     pass
+
+    >>> def s1(**kwargs):
+    ...     return kwargs
+    >>> def s2(*args, **kwargs):
+    ...     return (args, kwargs)
+    >>> def s3(*, n, **kwargs):
+    ...     return (n, kwargs)
+
+    >>> md = MyDict({'a': 1, 'b': 2})
+    >>> assert s1(**md) == {'a': 1, 'b': 2}
+    >>> assert s2(*(1, 2), **md) == ((1, 2), {'a': 1, 'b': 2})
+    >>> assert s3(**MyDict({'n': 1, 'b': 2})) == (1, {'b': 2})
+    >>> s3(**md)
+    Traceback (most recent call last):
+      ...
+    TypeError: s3() missing 1 required keyword-only argument: 'n'
+
+Another helper function
+
+    >>> def f2(*a, **b):
+    ...     return a, b
+
+
+    >>> d = {}
+    >>> for i in range(512):
+    ...     key = 'k%d' % i
+    ...     d[key] = i
+    >>> a, b = f2(1, *(2,3), **d)
+    >>> len(a), len(b), b == d
+    (3, 512, True)
+
+    >>> class Foo:
+    ...     def method(self, arg1, arg2):
+    ...         return arg1+arg2
+
+    >>> x = Foo()
+    >>> Foo.method(*(x, 1, 2))
+    3
+    >>> Foo.method(x, *(1, 2))
+    3
+    >>> Foo.method(*(1, 2, 3))
+    5
+    >>> Foo.method(1, *[2, 3])
+    5
+
+A PyCFunction that takes only positional parameters should allow an
+empty keyword dictionary to pass without a complaint, but raise a
+TypeError if te dictionary is not empty
+
+    >>> try:
+    ...     silence = id(1, *{})
+    ...     True
+    ... except:
+    ...     False
+    True
+
+    >>> id(1, **{'foo': 1}) # TODO: RUSTPYTHON # doctest:+EXPECTED_FAILURE
+    Traceback (most recent call last):
+      ...
+    TypeError: id() takes no keyword arguments
+
+A corner case of keyword dictionary items being deleted during
+the function call setup. See <http://bugs.python.org/issue2016>.
+
+    >>> class Name(str):
+    ...     def __eq__(self, other):
+    ...         try:
+    ...              del x[self]
+    ...         except KeyError:
+    ...              pass
+    ...         return str.__eq__(self, other)
+    ...     def __hash__(self):
+    ...         return str.__hash__(self)
+
+    >>> x = {Name("a"):1, Name("b"):2}
+    >>> def f(a, b):
+    ...     print(a,b)
+    >>> f(**x)
+    1 2
+
+Too many arguments:
+
+    >>> def f(): pass
+    >>> f(1)
+    Traceback (most recent call last):
+      ...
+    TypeError: f() takes 0 positional arguments but 1 was given
+    >>> def f(a): pass
+    >>> f(1, 2)
+    Traceback (most recent call last):
+      ...
+    TypeError: f() takes 1 positional argument but 2 were given
+    >>> def f(a, b=1): pass
+    >>> f(1, 2, 3)
+    Traceback (most recent call last):
+      ...
+    TypeError: f() takes from 1 to 2 positional arguments but 3 were given
+    >>> def f(*, kw): pass
+    >>> f(1, kw=3)
+    Traceback (most recent call last):
+      ...
+    TypeError: f() takes 0 positional arguments but 1 positional argument (and 1 keyword-only argument) were given
+    >>> def f(*, kw, b): pass
+    >>> f(1, 2, 3, b=3, kw=3)
+    Traceback (most recent call last):
+      ...
+    TypeError: f() takes 0 positional arguments but 3 positional arguments (and 2 keyword-only arguments) were given
+    >>> def f(a, b=2, *, kw): pass
+    >>> f(2, 3, 4, kw=4)
+    Traceback (most recent call last):
+      ...
+    TypeError: f() takes from 1 to 2 positional arguments but 3 positional arguments (and 1 keyword-only argument) were given
+
+Too few and missing arguments:
+
+    >>> def f(a): pass
+    >>> f()
+    Traceback (most recent call last):
+      ...
+    TypeError: f() missing 1 required positional argument: 'a'
+    >>> def f(a, b): pass
+    >>> f()
+    Traceback (most recent call last):
+      ...
+    TypeError: f() missing 2 required positional arguments: 'a' and 'b'
+    >>> def f(a, b, c): pass
+    >>> f()
+    Traceback (most recent call last):
+      ...
+    TypeError: f() missing 3 required positional arguments: 'a', 'b', and 'c'
+    >>> def f(a, b, c, d, e): pass
+    >>> f()
+    Traceback (most recent call last):
+      ...
+    TypeError: f() missing 5 required positional arguments: 'a', 'b', 'c', 'd', and 'e'
+    >>> def f(a, b=4, c=5, d=5): pass
+    >>> f(c=12, b=9)
+    Traceback (most recent call last):
+      ...
+    TypeError: f() missing 1 required positional argument: 'a'
+
+Same with keyword only args:
+
+    >>> def f(*, w): pass
+    >>> f()
+    Traceback (most recent call last):
+      ...
+    TypeError: f() missing 1 required keyword-only argument: 'w'
+    >>> def f(*, a, b, c, d, e): pass
+    >>> f()
+    Traceback (most recent call last):
+      ...
+    TypeError: f() missing 5 required keyword-only arguments: 'a', 'b', 'c', 'd', and 'e'
+
+"""
+
+import doctest
+import unittest
+
+EXPECTED_FAILURE = doctest.register_optionflag('EXPECTED_FAILURE') # TODO: RUSTPYTHON
+class CustomOutputChecker(doctest.OutputChecker): # TODO: RUSTPYTHON
+    def check_output(self, want, got, optionflags): # TODO: RUSTPYTHON
+        if optionflags & EXPECTED_FAILURE: # TODO: RUSTPYTHON
+            return not super().check_output(want, got, optionflags) # TODO: RUSTPYTHON
+        return super().check_output(want, got, optionflags) # TODO: RUSTPYTHON
+
+def load_tests(loader, tests, pattern):
+    tests.addTest(doctest.DocTestSuite(checker=CustomOutputChecker())) # TODO: RUSTPYTHON
+    return tests
+
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/Lib/test/test_faulthandler.py b/Lib/test/test_faulthandler.py
index 5596e5b1669..f498085c691 100644
--- a/Lib/test/test_faulthandler.py
+++ b/Lib/test/test_faulthandler.py
@@ -22,6 +22,16 @@
 
 TIMEOUT = 0.5
 
+STACK_HEADER_STR = r'Stack (most recent call first):'
+
+# Regular expressions
+STACK_HEADER = re.escape(STACK_HEADER_STR)
+THREAD_NAME = r'( \[.*\])?'
+THREAD_ID = fr'Thread 0x[0-9a-f]+{THREAD_NAME}'
+THREAD_HEADER = fr'{THREAD_ID} \(most recent call first\):'
+CURRENT_THREAD_ID = fr'Current thread 0x[0-9a-f]+{THREAD_NAME}'
+CURRENT_THREAD_HEADER = fr'{CURRENT_THREAD_ID} \(most recent call first\):'
+
 
 def expected_traceback(lineno1, lineno2, header, min_count=1):
     regex = header
@@ -45,6 +55,13 @@ def temporary_filename():
     finally:
         os_helper.unlink(filename)
 
+
+ADDRESS_EXPR = "0x[0-9a-f]+"
+C_STACK_REGEX = [
+    r"Current thread's C stack trace \(most recent call first\):",
+    fr'(  Binary file ".+"(, at .*(\+|-){ADDRESS_EXPR})? \[{ADDRESS_EXPR}\])|(<.+>)'
+]
+
 class FaultHandlerTests(unittest.TestCase):
 
     def get_output(self, code, filename=None, fd=None):
@@ -93,6 +110,7 @@ def check_error(self, code, lineno, fatal_error, *,
                     fd=None, know_current_thread=True,
                     py_fatal_error=False,
                     garbage_collecting=False,
+                    c_stack=True,
                     function='<module>'):
         """
         Check that the fault handler for fatal errors is enabled and check the
@@ -100,21 +118,32 @@ def check_error(self, code, lineno, fatal_error, *,
 
         Raise an error if the output doesn't match the expected format.
         """
-        if all_threads:
+        all_threads_disabled = (
+            all_threads
+            and (not sys._is_gil_enabled())
+        )
+        if all_threads and not all_threads_disabled:
             if know_current_thread:
-                header = 'Current thread 0x[0-9a-f]+'
+                header = CURRENT_THREAD_HEADER
             else:
-                header = 'Thread 0x[0-9a-f]+'
+                header = THREAD_HEADER
         else:
-            header = 'Stack'
+            header = STACK_HEADER
         regex = [f'^{fatal_error}']
         if py_fatal_error:
             regex.append("Python runtime state: initialized")
         regex.append('')
-        regex.append(fr'{header} \(most recent call first\):')
-        if garbage_collecting:
-            regex.append('  Garbage-collecting')
-        regex.append(fr'  File "<string>", line {lineno} in {function}')
+        if all_threads_disabled and not py_fatal_error:
+            regex.append("<Cannot show all threads while the GIL is disabled>")
+        regex.append(fr'{header}')
+        if support.Py_GIL_DISABLED and py_fatal_error and not know_current_thread:
+            regex.append("  <tstate is freed>")
+        else:
+            if garbage_collecting and not all_threads_disabled:
+                regex.append('  Garbage-collecting')
+            regex.append(fr'  File "<string>", line {lineno} in {function}')
+        if c_stack:
+            regex.extend(C_STACK_REGEX)
         regex = '\n'.join(regex)
 
         if other_regex:
@@ -137,8 +166,6 @@ def check_windows_exception(self, code, line_number, name_regex, **kw):
         fatal_error = 'Windows fatal exception: %s' % name_regex
         self.check_error(code, line_number, fatal_error, **kw)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     @unittest.skipIf(sys.platform.startswith('aix'),
                      "the first page of memory is a mapped read-only on AIX")
     def test_read_null(self):
@@ -162,8 +189,6 @@ def test_read_null(self):
                 3,
                 'access violation')
 
-    # TODO: RUSTPYTHON, AssertionError: Regex didn't match
-    @unittest.expectedFailure
     @skip_segfault_on_android
     def test_sigsegv(self):
         self.check_fatal_error("""
@@ -174,8 +199,6 @@ def test_sigsegv(self):
             3,
             'Segmentation fault')
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     @skip_segfault_on_android
     def test_gc(self):
         # bpo-44466: Detect if the GC is running
@@ -212,8 +235,7 @@ def __del__(self):
             function='__del__',
             garbage_collecting=True)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AssertionError: 0 == 0
     def test_fatal_error_c_thread(self):
         self.check_fatal_error("""
             import faulthandler
@@ -226,8 +248,7 @@ def test_fatal_error_c_thread(self):
             func='faulthandler_fatal_error_thread',
             py_fatal_error=True)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @support.skip_if_sanitizer("TSAN itercepts SIGABRT", thread=True)
     def test_sigabrt(self):
         self.check_fatal_error("""
             import faulthandler
@@ -237,10 +258,9 @@ def test_sigabrt(self):
             3,
             'Aborted')
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     @unittest.skipIf(sys.platform == 'win32',
                      "SIGFPE cannot be caught on Windows")
+    @support.skip_if_sanitizer("TSAN itercepts SIGFPE", thread=True)
     def test_sigfpe(self):
         self.check_fatal_error("""
             import faulthandler
@@ -252,6 +272,7 @@ def test_sigfpe(self):
 
     @unittest.skipIf(_testcapi is None, 'need _testcapi')
     @unittest.skipUnless(hasattr(signal, 'SIGBUS'), 'need signal.SIGBUS')
+    @support.skip_if_sanitizer("TSAN itercepts SIGBUS", thread=True)
     @skip_segfault_on_android
     def test_sigbus(self):
         self.check_fatal_error("""
@@ -266,6 +287,7 @@ def test_sigbus(self):
 
     @unittest.skipIf(_testcapi is None, 'need _testcapi')
     @unittest.skipUnless(hasattr(signal, 'SIGILL'), 'need signal.SIGILL')
+    @support.skip_if_sanitizer("TSAN itercepts SIGILL", thread=True)
     @skip_segfault_on_android
     def test_sigill(self):
         self.check_fatal_error("""
@@ -291,13 +313,9 @@ def check_fatal_error_func(self, release_gil):
                 func='_testcapi_fatal_error_impl',
                 py_fatal_error=True)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_fatal_error(self):
         self.check_fatal_error_func(False)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_fatal_error_without_gil(self):
         self.check_fatal_error_func(True)
 
@@ -316,8 +334,6 @@ def test_stack_overflow(self):
             '(?:Segmentation fault|Bus error)',
             other_regex='unable to raise a stack overflow')
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     @skip_segfault_on_android
     def test_gil_released(self):
         self.check_fatal_error("""
@@ -328,8 +344,6 @@ def test_gil_released(self):
             3,
             'Segmentation fault')
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     @skip_segfault_on_android
     def test_enable_file(self):
         with temporary_filename() as filename:
@@ -343,8 +357,6 @@ def test_enable_file(self):
                 'Segmentation fault',
                 filename=filename)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     @unittest.skipIf(sys.platform == "win32",
                      "subprocess doesn't support pass_fds on Windows")
     @skip_segfault_on_android
@@ -361,8 +373,6 @@ def test_enable_fd(self):
                 'Segmentation fault',
                 fd=fd)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     @skip_segfault_on_android
     def test_enable_single_thread(self):
         self.check_fatal_error("""
@@ -389,8 +399,7 @@ def test_disable(self):
                      "%r is present in %r" % (not_expected, stderr))
         self.assertNotEqual(exitcode, 0)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AssertionError: Cannot find 'Extension modules:' in 'Fatal Python error: Segmentation fault\n\nCurrent thread 0x0000000000004284 (most recent call first):\n  File "<string>", line 6 in <module>'
     @skip_segfault_on_android
     def test_dump_ext_modules(self):
         code = """
@@ -511,7 +520,7 @@ def funcA():
         else:
             lineno = 14
         expected = [
-            'Stack (most recent call first):',
+            f'{STACK_HEADER_STR}',
             '  File "<string>", line %s in funcB' % lineno,
             '  File "<string>", line 17 in funcA',
             '  File "<string>", line 19 in <module>'
@@ -523,14 +532,10 @@ def funcA():
     def test_dump_traceback(self):
         self.check_dump_traceback()
 
-    # TODO: RUSTPYTHON - binary file write needs different handling
-    @unittest.expectedFailure
     def test_dump_traceback_file(self):
         with temporary_filename() as filename:
             self.check_dump_traceback(filename=filename)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     @unittest.skipIf(sys.platform == "win32",
                      "subprocess doesn't support pass_fds on Windows")
     def test_dump_traceback_fd(self):
@@ -553,7 +558,7 @@ def {func_name}():
             func_name=func_name,
         )
         expected = [
-            'Stack (most recent call first):',
+            f'{STACK_HEADER_STR}',
             '  File "<string>", line 4 in %s' % truncated,
             '  File "<string>", line 6 in <module>'
         ]
@@ -607,28 +612,24 @@ def run(self):
             lineno = 10
         # When the traceback is dumped, the waiter thread may be in the
         # `self.running.set()` call or in `self.stop.wait()`.
-        regex = r"""
-            ^Thread 0x[0-9a-f]+ \(most recent call first\):
+        regex = fr"""
+            ^{THREAD_HEADER}
             (?:  File ".*threading.py", line [0-9]+ in [_a-z]+
             ){{1,3}}  File "<string>", line (?:22|23) in run
               File ".*threading.py", line [0-9]+ in _bootstrap_inner
               File ".*threading.py", line [0-9]+ in _bootstrap
 
-            Current thread 0x[0-9a-f]+ \(most recent call first\):
+            {CURRENT_THREAD_HEADER}
               File "<string>", line {lineno} in dump
               File "<string>", line 28 in <module>$
             """
-        regex = dedent(regex.format(lineno=lineno)).strip()
+        regex = dedent(regex).strip()
         self.assertRegex(output, regex)
         self.assertEqual(exitcode, 0)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_dump_traceback_threads(self):
         self.check_dump_traceback_threads(None)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_dump_traceback_threads_file(self):
         with temporary_filename() as filename:
             self.check_dump_traceback_threads(filename)
@@ -688,44 +689,33 @@ def func(timeout, repeat, cancel, file, loops):
             count = loops
             if repeat:
                 count *= 2
-            header = r'Timeout \(%s\)!\nThread 0x[0-9a-f]+ \(most recent call first\):\n' % timeout_str
+            header = (fr'Timeout \({timeout_str}\)!\n'
+                      fr'{THREAD_HEADER}\n')
             regex = expected_traceback(17, 26, header, min_count=count)
             self.assertRegex(trace, regex)
         else:
             self.assertEqual(trace, '')
         self.assertEqual(exitcode, 0)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_dump_traceback_later(self):
         self.check_dump_traceback_later()
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_dump_traceback_later_repeat(self):
         self.check_dump_traceback_later(repeat=True)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_dump_traceback_later_cancel(self):
         self.check_dump_traceback_later(cancel=True)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_dump_traceback_later_file(self):
         with temporary_filename() as filename:
             self.check_dump_traceback_later(filename=filename)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     @unittest.skipIf(sys.platform == "win32",
                      "subprocess doesn't support pass_fds on Windows")
     def test_dump_traceback_later_fd(self):
         with tempfile.TemporaryFile('wb+') as fp:
             self.check_dump_traceback_later(fd=fp.fileno())
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     @support.requires_resource('walltime')
     def test_dump_traceback_later_twice(self):
         self.check_dump_traceback_later(loops=2)
@@ -801,9 +791,9 @@ def handler(signum, frame):
         trace = '\n'.join(trace)
         if not unregister:
             if all_threads:
-                regex = r'Current thread 0x[0-9a-f]+ \(most recent call first\):\n'
+                regex = fr'{CURRENT_THREAD_HEADER}\n'
             else:
-                regex = r'Stack \(most recent call first\):\n'
+                regex = fr'{STACK_HEADER}\n'
             regex = expected_traceback(14, 32, regex)
             self.assertRegex(trace, regex)
         else:
@@ -813,37 +803,26 @@ def handler(signum, frame):
         else:
             self.assertEqual(exitcode, 0)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_register(self):
         self.check_register()
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_unregister(self):
         self.check_register(unregister=True)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_register_file(self):
         with temporary_filename() as filename:
             self.check_register(filename=filename)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     @unittest.skipIf(sys.platform == "win32",
                      "subprocess doesn't support pass_fds on Windows")
     def test_register_fd(self):
         with tempfile.TemporaryFile('wb+') as fp:
             self.check_register(fd=fp.fileno())
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_register_threads(self):
         self.check_register(all_threads=True)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @support.skip_if_sanitizer("gh-129825: hangs under TSAN", thread=True)
     def test_register_chain(self):
         self.check_register(chain=True)
 
@@ -871,8 +850,6 @@ def test_stderr_None(self):
             with self.check_stderr_none():
                 faulthandler.register(signal.SIGUSR1)
 
-    # TODO: RUSTPYTHON, AttributeError: module 'msvcrt' has no attribute 'GetErrorMode'
-    @unittest.expectedFailure
     @unittest.skipUnless(MS_WINDOWS, 'specific to Windows')
     def test_raise_exception(self):
         for exc, name in (
@@ -985,5 +962,37 @@ def run(self):
         _, exitcode = self.get_output(code)
         self.assertEqual(exitcode, 0)
 
+    def check_c_stack(self, output):
+        starting_line = output.pop(0)
+        self.assertRegex(starting_line, C_STACK_REGEX[0])
+        self.assertGreater(len(output), 0)
+
+        for line in output:
+            with self.subTest(line=line):
+                if line != '':  # Ignore trailing or leading newlines
+                    self.assertRegex(line, C_STACK_REGEX[1])
+
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AssertionError: 1 != 0
+    def test_dump_c_stack(self):
+        code = dedent("""
+        import faulthandler
+        faulthandler.dump_c_stack()
+        """)
+        output, exitcode = self.get_output(code)
+        self.assertEqual(exitcode, 0)
+        self.check_c_stack(output)
+
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AttributeError: module 'faulthandler' has no attribute 'dump_c_stack'
+    def test_dump_c_stack_file(self):
+        import tempfile
+
+        with tempfile.TemporaryFile("w+") as tmp:
+            faulthandler.dump_c_stack(file=tmp)
+            tmp.flush()  # Just in case
+            tmp.seek(0)
+            self.check_c_stack(tmp.read().split("\n"))
+
 if __name__ == "__main__":
     unittest.main()
diff --git a/Lib/test/test_file.py b/Lib/test/test_file.py
index 36aea52a5a9..029c903e01a 100644
--- a/Lib/test/test_file.py
+++ b/Lib/test/test_file.py
@@ -126,7 +126,7 @@ def testMethods(self):
         # it must also return None if an exception was given
         try:
             1/0
-        except:
+        except ZeroDivisionError:
             self.assertEqual(self.f.__exit__(*sys.exc_info()), None)
 
     def testReadWhenWriting(self):
@@ -216,6 +216,16 @@ def testSetBufferSize(self):
         with self.assertWarnsRegex(RuntimeWarning, 'line buffering'):
             self._checkBufferSize(1)
 
+    def testDefaultBufferSize(self):
+        with self.open(TESTFN, 'wb') as f:
+            blksize = f.raw._blksize
+            f.write(b"\0" * 5_000_000)
+
+        with self.open(TESTFN, 'rb') as f:
+            data = f.read1()
+            expected_size = max(min(blksize, 8192 * 1024), io.DEFAULT_BUFFER_SIZE)
+            self.assertEqual(len(data), expected_size)
+
     def testTruncateOnWindows(self):
         # SF bug <https://bugs.python.org/issue801631>
         # "file.truncate fault on windows"
@@ -344,7 +354,6 @@ def testIteration(self):
 class COtherFileTests(OtherFileTests, unittest.TestCase):
     open = io.open
 
-
 class PyOtherFileTests(OtherFileTests, unittest.TestCase):
     open = staticmethod(pyio.open)
 
diff --git a/Lib/test/test_fileinput.py b/Lib/test/test_fileinput.py
index 1a6ef3cd275..b340ef7ed16 100644
--- a/Lib/test/test_fileinput.py
+++ b/Lib/test/test_fileinput.py
@@ -980,8 +980,6 @@ def check(errors, expected_lines):
         check('replace', ['\ufffdabc'])
         check('backslashreplace', ['\\x80abc'])
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_modes(self):
         with open(TESTFN, 'wb') as f:
             # UTF-7 is a convenient, seldom used encoding
diff --git a/Lib/test/test_fileio.py b/Lib/test/test_fileio.py
index fdb36ed997d..4f195cf045c 100644
--- a/Lib/test/test_fileio.py
+++ b/Lib/test/test_fileio.py
@@ -10,8 +10,8 @@
 from functools import wraps
 
 from test.support import (
-    cpython_only, swap_attr, gc_collect, is_emscripten, is_wasi,
-    infinite_recursion,
+    cpython_only, swap_attr, gc_collect, is_wasi,
+    infinite_recursion, strace_helper
 )
 from test.support.os_helper import (
     TESTFN, TESTFN_ASCII, TESTFN_UNICODE, make_bad_fd,
@@ -24,6 +24,9 @@
 import _pyio # Python implementation of io
 
 
+_strace_flags=["--trace=%file,%desc"]
+
+
 class AutoFileTests:
     # file tests for which a test file is automatically set up
 
@@ -359,6 +362,144 @@ def testErrnoOnClosedReadinto(self, f):
         a = array('b', b'x'*10)
         f.readinto(a)
 
+    @unittest.skip("TODO: RUSTPYTHON; extra ioctl(TCGETS) syscall for isatty check")
+    @strace_helper.requires_strace()
+    def test_syscalls_read(self):
+        """Check set of system calls during common I/O patterns
+
+        It's expected as bits of the I/O implementation change, this will need
+        to change. The goal is to catch changes that unintentionally add
+        additional systemcalls (ex. additional calls have been looked at in
+        bpo-21679 and gh-120754).
+        """
+        self.f.write(b"Hello, World!")
+        self.f.close()
+
+
+        def check_readall(name, code, prelude="", cleanup="",
+                          extra_checks=None):
+            with self.subTest(name=name):
+                syscalls = strace_helper.get_events(code, _strace_flags,
+                                                      prelude=prelude,
+                                                      cleanup=cleanup)
+
+                # Some system calls (ex. mmap) can be used for both File I/O and
+                # memory allocation. Filter out the ones used for memory
+                # allocation.
+                syscalls = strace_helper.filter_memory(syscalls)
+
+                # The first call should be an open that returns a
+                # file descriptor (fd). Afer that calls may vary. Once the file
+                # is opened, check calls refer to it by fd as the filename
+                # could be removed from the filesystem, renamed, etc. See:
+                # Time-of-check time-of-use (TOCTOU) software bug class.
+                #
+                # There are a number of related but distinct open system calls
+                # so not checking precise name here.
+                self.assertGreater(
+                    len(syscalls),
+                    1,
+                    f"Should have had at least an open call|calls={syscalls}")
+                fd_str = syscalls[0].returncode
+
+                # All other calls should contain the fd in their argument set.
+                for ev in syscalls[1:]:
+                    self.assertIn(
+                        fd_str,
+                        ev.args,
+                        f"Looking for file descriptor in arguments|ev={ev}"
+                    )
+
+                # There are a number of related syscalls used to implement
+                # behaviors in a libc (ex. fstat, newfstatat, statx, open, openat).
+                # Allow any that use the same substring.
+                def count_similarname(name):
+                    return len([ev for ev in syscalls if name in ev.syscall])
+
+                checks = [
+                    # Should open and close the file exactly once
+                    ("open", 1),
+                    ("close", 1),
+                    # There should no longer be an isatty call (All files being
+                    # tested are block devices / not character devices).
+                    ('ioctl', 0),
+                    # Should only have one fstat (bpo-21679, gh-120754)
+                    # note: It's important this uses a fd rather than filename,
+                    # That is validated by the `fd` check above.
+                    # note: fstat, newfstatat, and statx have all been observed
+                    # here in the underlying C library implementations.
+                    ("stat", 1)
+                ]
+
+                if extra_checks:
+                    checks += extra_checks
+
+                for call, count in checks:
+                    self.assertEqual(
+                        count_similarname(call),
+                        count,
+                        msg=f"call={call}|count={count}|syscalls={syscalls}"
+                    )
+
+        # "open, read, close" file using different common patterns.
+        check_readall(
+            "open builtin with default options",
+            f"""
+            f = open('{TESTFN}')
+            f.read()
+            f.close()
+            """
+        )
+
+        check_readall(
+            "open in binary mode",
+            f"""
+            f = open('{TESTFN}', 'rb')
+            f.read()
+            f.close()
+            """
+        )
+
+        check_readall(
+            "open in text mode",
+            f"""
+            f = open('{TESTFN}', 'rt')
+            f.read()
+            f.close()
+            """,
+            # GH-122111: read_text uses BufferedIO which requires looking up
+            # position in file. `read_bytes` disables that buffering and avoids
+            # these calls which is tested the `pathlib read_bytes` case.
+            extra_checks=[("seek", 1)]
+        )
+
+        check_readall(
+            "pathlib read_bytes",
+            "p.read_bytes()",
+            prelude=f"""from pathlib import Path; p = Path("{TESTFN}")""",
+            # GH-122111: Buffering is disabled so these calls are avoided.
+            extra_checks=[("seek", 0)]
+        )
+
+        check_readall(
+            "pathlib read_text",
+            "p.read_text()",
+            prelude=f"""from pathlib import Path; p = Path("{TESTFN}")"""
+        )
+
+        # Focus on just `read()`.
+        calls = strace_helper.get_syscalls(
+            prelude=f"f = open('{TESTFN}')",
+            code="f.read()",
+            cleanup="f.close()",
+            strace_flags=_strace_flags
+        )
+        # One to read all the bytes
+        # One to read the EOF and get a size 0 return.
+        self.assertEqual(calls.count("read"), 2)
+
+
+
 class CAutoFileTests(AutoFileTests, unittest.TestCase):
     FileIO = _io.FileIO
     modulename = '_io'
@@ -391,7 +532,7 @@ def testAbles(self):
             self.assertEqual(f.isatty(), False)
             f.close()
 
-            if sys.platform != "win32" and not is_emscripten:
+            if sys.platform != "win32":
                 try:
                     f = self.FileIO("/dev/tty", "a")
                 except OSError:
diff --git a/Lib/test/test_float.py b/Lib/test/test_float.py
index 4ca4103f420..53f454d1891 100644
--- a/Lib/test/test_float.py
+++ b/Lib/test/test_float.py
@@ -35,6 +35,28 @@ class FloatSubclass(float):
 class OtherFloatSubclass(float):
     pass
 
+class MyIndex:
+    def __init__(self, value):
+        self.value = value
+
+    def __index__(self):
+        return self.value
+
+class MyInt:
+    def __init__(self, value):
+        self.value = value
+
+    def __int__(self):
+        return self.value
+
+class FloatLike:
+    def __init__(self, value):
+        self.value = value
+
+    def __float__(self):
+        return self.value
+
+
 class GeneralFloatCases(unittest.TestCase):
 
     def test_float(self):
@@ -184,10 +206,6 @@ def test_float_with_comma(self):
 
     def test_floatconversion(self):
         # Make sure that calls to __float__() work properly
-        class Foo1(object):
-            def __float__(self):
-                return 42.
-
         class Foo2(float):
             def __float__(self):
                 return 42.
@@ -209,52 +227,35 @@ class FooStr(str):
             def __float__(self):
                 return float(str(self)) + 1
 
-        self.assertEqual(float(Foo1()), 42.)
+        self.assertEqual(float(FloatLike(42.)), 42.)
         self.assertEqual(float(Foo2()), 42.)
         with self.assertWarns(DeprecationWarning):
             self.assertEqual(float(Foo3(21)), 42.)
         self.assertRaises(TypeError, float, Foo4(42))
         self.assertEqual(float(FooStr('8')), 9.)
 
-        class Foo5:
-            def __float__(self):
-                return ""
-        self.assertRaises(TypeError, time.sleep, Foo5())
+        self.assertRaises(TypeError, time.sleep, FloatLike(""))
 
         # Issue #24731
-        class F:
-            def __float__(self):
-                return OtherFloatSubclass(42.)
+        f = FloatLike(OtherFloatSubclass(42.))
         with self.assertWarns(DeprecationWarning):
-            self.assertEqual(float(F()), 42.)
+            self.assertEqual(float(f), 42.)
         with self.assertWarns(DeprecationWarning):
-            self.assertIs(type(float(F())), float)
+            self.assertIs(type(float(f)), float)
         with self.assertWarns(DeprecationWarning):
-            self.assertEqual(FloatSubclass(F()), 42.)
+            self.assertEqual(FloatSubclass(f), 42.)
         with self.assertWarns(DeprecationWarning):
-            self.assertIs(type(FloatSubclass(F())), FloatSubclass)
-
-        class MyIndex:
-            def __init__(self, value):
-                self.value = value
-            def __index__(self):
-                return self.value
+            self.assertIs(type(FloatSubclass(f)), FloatSubclass)
 
         self.assertEqual(float(MyIndex(42)), 42.0)
         self.assertRaises(OverflowError, float, MyIndex(2**2000))
-
-        class MyInt:
-            def __int__(self):
-                return 42
-
-        self.assertRaises(TypeError, float, MyInt())
+        self.assertRaises(TypeError, float, MyInt(42))
 
     def test_keyword_args(self):
         with self.assertRaisesRegex(TypeError, 'keyword argument'):
             float(x='3.14')
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; TypeError: Unexpected keyword argument newarg
     def test_keywords_in_subclass(self):
         class subclass(float):
             pass
@@ -282,6 +283,37 @@ def __new__(cls, arg, newarg=None):
         self.assertEqual(float(u), 2.5)
         self.assertEqual(u.newarg, 3)
 
+    def assertEqualAndType(self, actual, expected_value, expected_type):
+        self.assertEqual(actual, expected_value)
+        self.assertIs(type(actual), expected_type)
+
+    def test_from_number(self, cls=float):
+        def eq(actual, expected):
+            self.assertEqual(actual, expected)
+            self.assertIs(type(actual), cls)
+
+        eq(cls.from_number(3.14), 3.14)
+        eq(cls.from_number(314), 314.0)
+        eq(cls.from_number(OtherFloatSubclass(3.14)), 3.14)
+        eq(cls.from_number(FloatLike(3.14)), 3.14)
+        eq(cls.from_number(MyIndex(314)), 314.0)
+
+        x = cls.from_number(NAN)
+        self.assertTrue(x != x)
+        self.assertIs(type(x), cls)
+        if cls is float:
+            self.assertIs(cls.from_number(NAN), NAN)
+
+        self.assertRaises(TypeError, cls.from_number, '3.14')
+        self.assertRaises(TypeError, cls.from_number, b'3.14')
+        self.assertRaises(TypeError, cls.from_number, 3.14j)
+        self.assertRaises(TypeError, cls.from_number, MyInt(314))
+        self.assertRaises(TypeError, cls.from_number, {})
+        self.assertRaises(TypeError, cls.from_number)
+
+    def test_from_number_subclass(self):
+        self.test_from_number(FloatSubclass)
+
     def test_is_integer(self):
         self.assertFalse((1.1).is_integer())
         self.assertTrue((1.).is_integer())
@@ -400,9 +432,8 @@ def test_float_mod(self):
         self.assertEqualAndEqualSign(mod(1e-100, -1.0), -1.0)
         self.assertEqualAndEqualSign(mod(1.0, -1.0), -0.0)
 
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; TypeError: must be real number, not complex
     @support.requires_IEEE_754
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_float_pow(self):
         # test builtin pow and ** operator for IEEE 754 special cases.
         # Special cases taken from section F.9.4.4 of the C99 specification
@@ -622,6 +653,24 @@ class F(float, H):
         value = F('nan')
         self.assertEqual(hash(value), object.__hash__(value))
 
+    def test_issue_gh143006(self):
+        # When comparing negative non-integer float and int with the
+        # same number of bits in the integer part, __neg__() in the
+        # int subclass returning not an int caused an assertion error.
+        class EvilInt(int):
+            def __neg__(self):
+                return ""
+
+        i = -1 << 50
+        f = float(i) - 0.5
+        i = EvilInt(i)
+        self.assertFalse(f == i)
+        self.assertTrue(f != i)
+        self.assertTrue(f < i)
+        self.assertTrue(f <= i)
+        self.assertFalse(f > i)
+        self.assertFalse(f >= i)
+
 
 @unittest.skipUnless(hasattr(float, "__getformat__"), "requires __getformat__")
 class FormatFunctionsTestCase(unittest.TestCase):
@@ -676,6 +725,7 @@ def test_serialized_float_rounding(self):
 
 class FormatTestCase(unittest.TestCase):
 
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; ValueError: Invalid format specifier
     def test_format(self):
         # these should be rewritten to use both format(x, spec) and
         # x.__format__(spec)
@@ -727,6 +777,44 @@ def test_format(self):
         self.assertEqual(format(INF, 'f'), 'inf')
         self.assertEqual(format(INF, 'F'), 'INF')
 
+        # thousands separators
+        x = 123_456.123_456
+        self.assertEqual(format(x, '_f'), '123_456.123456')
+        self.assertEqual(format(x, ',f'), '123,456.123456')
+        self.assertEqual(format(x, '._f'), '123456.123_456')
+        self.assertEqual(format(x, '.,f'), '123456.123,456')
+        self.assertEqual(format(x, '_._f'), '123_456.123_456')
+        self.assertEqual(format(x, ',.,f'), '123,456.123,456')
+        self.assertEqual(format(x, '.10_f'), '123456.123_456_000_0')
+        self.assertEqual(format(x, '.10,f'), '123456.123,456,000,0')
+        self.assertEqual(format(x, '>21._f'), '       123456.123_456')
+        self.assertEqual(format(x, '<21._f'), '123456.123_456       ')
+        self.assertEqual(format(x, '+.11_e'), '+1.234_561_234_56e+05')
+        self.assertEqual(format(x, '+.11,e'), '+1.234,561,234,56e+05')
+        self.assertEqual(format(x, '021_._f'), '0_000_123_456.123_456')
+        self.assertEqual(format(x, '020_._f'), '0_000_123_456.123_456')
+        self.assertEqual(format(x, '+021_._f'), '+0_000_123_456.123_456')
+        self.assertEqual(format(x, '21_._f'), '      123_456.123_456')
+        self.assertEqual(format(x, '>021_._f'), '000000123_456.123_456')
+        self.assertEqual(format(x, '<021_._f'), '123_456.123_456000000')
+        self.assertEqual(format(x, '023_.10_f'), '0_123_456.123_456_000_0')
+        self.assertEqual(format(x, '022_.10_f'), '0_123_456.123_456_000_0')
+        self.assertEqual(format(x, '+023_.10_f'), '+0_123_456.123_456_000_0')
+        self.assertEqual(format(x, '023_.9_f'), '000_123_456.123_456_000')
+        self.assertEqual(format(x, '021_._e'), '0_000_001.234_561e+05')
+        self.assertEqual(format(x, '020_._e'), '0_000_001.234_561e+05')
+        self.assertEqual(format(x, '+021_._e'), '+0_000_001.234_561e+05')
+        self.assertEqual(format(x, '023_.10_e'), '0_001.234_561_234_6e+05')
+        self.assertEqual(format(x, '022_.10_e'), '0_001.234_561_234_6e+05')
+        self.assertEqual(format(x, '023_.9_e'), '000_001.234_561_235e+05')
+
+        self.assertRaises(ValueError, format, x, '._6f')
+        self.assertRaises(ValueError, format, x, '.,_f')
+        self.assertRaises(ValueError, format, x, '.6,_f')
+        self.assertRaises(ValueError, format, x, '.6_,f')
+        self.assertRaises(ValueError, format, x, '.6_n')
+        self.assertRaises(ValueError, format, x, '.6,n')
+
     @support.requires_IEEE_754
     @unittest.skipUnless(sys.float_repr_style == 'short',
                          "applies only when using short float repr style")
@@ -877,10 +965,9 @@ def test_overflow(self):
         self.assertRaises(OverflowError, round, 1.6e308, -308)
         self.assertRaises(OverflowError, round, -1.7e308, -308)
 
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AssertionError: 56294995342131.51 != 56294995342131.5
     @unittest.skipUnless(getattr(sys, 'float_repr_style', '') == 'short',
                          "applies only when using short float repr style")
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_previous_round_bugs(self):
         # particular cases that have occurred in bug reports
         self.assertEqual(round(562949953421312.5, 1),
@@ -897,10 +984,9 @@ def test_previous_round_bugs(self):
         self.assertEqual(round(85.0, -1), 80.0)
         self.assertEqual(round(95.0, -1), 100.0)
 
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AssertionError: 0.01 != 0.0
     @unittest.skipUnless(getattr(sys, 'float_repr_style', '') == 'short',
                          "applies only when using short float repr style")
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_matches_float_format(self):
         # round should give the same results as float formatting
         for i in range(500):
@@ -962,6 +1048,13 @@ def test_None_ndigits(self):
             self.assertEqual(x, 2)
             self.assertIsInstance(x, int)
 
+    @support.cpython_only
+    def test_round_with_none_arg_direct_call(self):
+        for val in [(1.0).__round__(None),
+                    round(1.0),
+                    round(1.0, None)]:
+            self.assertEqual(val, 1)
+            self.assertIs(type(val), int)
 
 # Beginning with Python 2.6 float has cross platform compatible
 # ways to create and represent inf and nan
@@ -1171,8 +1264,7 @@ def test_whitespace(self):
                     self.identical(got, expected)
 
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; ValueError: invalid hexadecimal floating-point string
     def test_from_hex(self):
         MIN = self.MIN
         MAX = self.MAX
diff --git a/Lib/test/test_flufl.py b/Lib/test/test_flufl.py
new file mode 100644
index 00000000000..bd6267d45ae
--- /dev/null
+++ b/Lib/test/test_flufl.py
@@ -0,0 +1,69 @@
+import __future__
+import unittest
+
+
+class FLUFLTests(unittest.TestCase):
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    def test_barry_as_bdfl(self):
+        code = "from __future__ import barry_as_FLUFL\n2 {0} 3"
+        compile(code.format('<>'), '<BDFL test>', 'exec',
+                __future__.CO_FUTURE_BARRY_AS_BDFL)
+        with self.assertRaises(SyntaxError) as cm:
+            compile(code.format('!='), '<FLUFL test>', 'exec',
+                    __future__.CO_FUTURE_BARRY_AS_BDFL)
+        self.assertRegex(str(cm.exception),
+                         "with Barry as BDFL, use '<>' instead of '!='")
+        self.assertIn('2 != 3', cm.exception.text)
+        self.assertEqual(cm.exception.filename, '<FLUFL test>')
+
+        self.assertEqual(cm.exception.lineno, 2)
+        # The old parser reports the end of the token and the new
+        # parser reports the start of the token
+        self.assertEqual(cm.exception.offset, 3)
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    def test_guido_as_bdfl(self):
+        code = '2 {0} 3'
+        compile(code.format('!='), '<BDFL test>', 'exec')
+        with self.assertRaises(SyntaxError) as cm:
+            compile(code.format('<>'), '<FLUFL test>', 'exec')
+        self.assertRegex(str(cm.exception), "invalid syntax")
+        self.assertIn('2 <> 3', cm.exception.text)
+        self.assertEqual(cm.exception.filename, '<FLUFL test>')
+        self.assertEqual(cm.exception.lineno, 1)
+        # The old parser reports the end of the token and the new
+        # parser reports the start of the token
+        self.assertEqual(cm.exception.offset, 3)
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    def test_barry_as_bdfl_look_ma_with_no_compiler_flags(self):
+        # Check that the future import is handled by the parser
+        # even if the compiler flags are not passed.
+        code = "from __future__ import barry_as_FLUFL;2 {0} 3"
+        compile(code.format('<>'), '<BDFL test>', 'exec')
+        with self.assertRaises(SyntaxError) as cm:
+            compile(code.format('!='), '<FLUFL test>', 'exec')
+        self.assertRegex(str(cm.exception), "with Barry as BDFL, use '<>' instead of '!='")
+        self.assertIn('2 != 3', cm.exception.text)
+        self.assertEqual(cm.exception.filename, '<FLUFL test>')
+        self.assertEqual(cm.exception.lineno, 1)
+        self.assertEqual(cm.exception.offset, len(code) - 4)
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    def test_barry_as_bdfl_relative_import(self):
+        code = "from .__future__ import barry_as_FLUFL;2 {0} 3"
+        compile(code.format('!='), '<FLUFL test>', 'exec')
+        with self.assertRaises(SyntaxError) as cm:
+            compile(code.format('<>'), '<BDFL test>', 'exec')
+        self.assertRegex(str(cm.exception), "<BDFL test>")
+        self.assertIn('2 <> 3', cm.exception.text)
+        self.assertEqual(cm.exception.filename, '<BDFL test>')
+        self.assertEqual(cm.exception.lineno, 1)
+        self.assertEqual(cm.exception.offset, len(code) - 4)
+
+
+
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/Lib/test/test_fnmatch.py b/Lib/test/test_fnmatch.py
index 10ed496d4e2..5daaf3b3fdd 100644
--- a/Lib/test/test_fnmatch.py
+++ b/Lib/test/test_fnmatch.py
@@ -1,11 +1,15 @@
 """Test cases for the fnmatch module."""
 
-import unittest
 import os
 import string
+import unittest
 import warnings
+from fnmatch import fnmatch, fnmatchcase, translate, filter, filterfalse
+
+
+IGNORECASE = os.path.normcase('P') == os.path.normcase('p')
+NORMSEP = os.path.normcase('\\') == os.path.normcase('/')
 
-from fnmatch import fnmatch, fnmatchcase, translate, filter
 
 class FnmatchTestCase(unittest.TestCase):
 
@@ -77,23 +81,20 @@ def test_bytes(self):
         self.check_match(b'foo\nbar', b'foo*')
 
     def test_case(self):
-        ignorecase = os.path.normcase('ABC') == os.path.normcase('abc')
         check = self.check_match
         check('abc', 'abc')
-        check('AbC', 'abc', ignorecase)
-        check('abc', 'AbC', ignorecase)
+        check('AbC', 'abc', IGNORECASE)
+        check('abc', 'AbC', IGNORECASE)
         check('AbC', 'AbC')
 
     def test_sep(self):
-        normsep = os.path.normcase('\\') == os.path.normcase('/')
         check = self.check_match
         check('usr/bin', 'usr/bin')
-        check('usr\\bin', 'usr/bin', normsep)
-        check('usr/bin', 'usr\\bin', normsep)
+        check('usr\\bin', 'usr/bin', NORMSEP)
+        check('usr/bin', 'usr\\bin', NORMSEP)
         check('usr\\bin', 'usr\\bin')
 
     def test_char_set(self):
-        ignorecase = os.path.normcase('ABC') == os.path.normcase('abc')
         check = self.check_match
         tescases = string.ascii_lowercase + string.digits + string.punctuation
         for c in tescases:
@@ -101,11 +102,11 @@ def test_char_set(self):
             check(c, '[!az]', c not in 'az')
         # Case insensitive.
         for c in tescases:
-            check(c, '[AZ]', (c in 'az') and ignorecase)
-            check(c, '[!AZ]', (c not in 'az') or not ignorecase)
+            check(c, '[AZ]', (c in 'az') and IGNORECASE)
+            check(c, '[!AZ]', (c not in 'az') or not IGNORECASE)
         for c in string.ascii_uppercase:
-            check(c, '[az]', (c in 'AZ') and ignorecase)
-            check(c, '[!az]', (c not in 'AZ') or not ignorecase)
+            check(c, '[az]', (c in 'AZ') and IGNORECASE)
+            check(c, '[!az]', (c not in 'AZ') or not IGNORECASE)
         # Repeated same character.
         for c in tescases:
             check(c, '[aa]', c == 'a')
@@ -120,8 +121,6 @@ def test_char_set(self):
         check('[!]', '[!]')
 
     def test_range(self):
-        ignorecase = os.path.normcase('ABC') == os.path.normcase('abc')
-        normsep = os.path.normcase('\\') == os.path.normcase('/')
         check = self.check_match
         tescases = string.ascii_lowercase + string.digits + string.punctuation
         for c in tescases:
@@ -131,11 +130,11 @@ def test_range(self):
             check(c, '[!b-dx-z]', c not in 'bcdxyz')
         # Case insensitive.
         for c in tescases:
-            check(c, '[B-D]', (c in 'bcd') and ignorecase)
-            check(c, '[!B-D]', (c not in 'bcd') or not ignorecase)
+            check(c, '[B-D]', (c in 'bcd') and IGNORECASE)
+            check(c, '[!B-D]', (c not in 'bcd') or not IGNORECASE)
         for c in string.ascii_uppercase:
-            check(c, '[b-d]', (c in 'BCD') and ignorecase)
-            check(c, '[!b-d]', (c not in 'BCD') or not ignorecase)
+            check(c, '[b-d]', (c in 'BCD') and IGNORECASE)
+            check(c, '[!b-d]', (c not in 'BCD') or not IGNORECASE)
         # Upper bound == lower bound.
         for c in tescases:
             check(c, '[b-b]', c == 'b')
@@ -144,7 +143,7 @@ def test_range(self):
             check(c, '[!-#]', c not in '-#')
             check(c, '[!--.]', c not in '-.')
             check(c, '[^-`]', c in '^_`')
-            if not (normsep and c == '/'):
+            if not (NORMSEP and c == '/'):
                 check(c, '[[-^]', c in r'[\]^')
                 check(c, r'[\-^]', c in r'\]^')
             check(c, '[b-]', c in '-b')
@@ -160,47 +159,45 @@ def test_range(self):
             check(c, '[d-bx-z]', c in 'xyz')
             check(c, '[!d-bx-z]', c not in 'xyz')
             check(c, '[d-b^-`]', c in '^_`')
-            if not (normsep and c == '/'):
+            if not (NORMSEP and c == '/'):
                 check(c, '[d-b[-^]', c in r'[\]^')
 
     def test_sep_in_char_set(self):
-        normsep = os.path.normcase('\\') == os.path.normcase('/')
         check = self.check_match
         check('/', r'[/]')
         check('\\', r'[\]')
-        check('/', r'[\]', normsep)
-        check('\\', r'[/]', normsep)
+        check('/', r'[\]', NORMSEP)
+        check('\\', r'[/]', NORMSEP)
         check('[/]', r'[/]', False)
         check(r'[\\]', r'[/]', False)
         check('\\', r'[\t]')
-        check('/', r'[\t]', normsep)
+        check('/', r'[\t]', NORMSEP)
         check('t', r'[\t]')
         check('\t', r'[\t]', False)
 
     def test_sep_in_range(self):
-        normsep = os.path.normcase('\\') == os.path.normcase('/')
         check = self.check_match
-        check('a/b', 'a[.-0]b', not normsep)
+        check('a/b', 'a[.-0]b', not NORMSEP)
         check('a\\b', 'a[.-0]b', False)
-        check('a\\b', 'a[Z-^]b', not normsep)
+        check('a\\b', 'a[Z-^]b', not NORMSEP)
         check('a/b', 'a[Z-^]b', False)
 
-        check('a/b', 'a[/-0]b', not normsep)
+        check('a/b', 'a[/-0]b', not NORMSEP)
         check(r'a\b', 'a[/-0]b', False)
         check('a[/-0]b', 'a[/-0]b', False)
         check(r'a[\-0]b', 'a[/-0]b', False)
 
         check('a/b', 'a[.-/]b')
-        check(r'a\b', 'a[.-/]b', normsep)
+        check(r'a\b', 'a[.-/]b', NORMSEP)
         check('a[.-/]b', 'a[.-/]b', False)
         check(r'a[.-\]b', 'a[.-/]b', False)
 
         check(r'a\b', r'a[\-^]b')
-        check('a/b', r'a[\-^]b', normsep)
+        check('a/b', r'a[\-^]b', NORMSEP)
         check(r'a[\-^]b', r'a[\-^]b', False)
         check('a[/-^]b', r'a[\-^]b', False)
 
-        check(r'a\b', r'a[Z-\]b', not normsep)
+        check(r'a\b', r'a[Z-\]b', not NORMSEP)
         check('a/b', r'a[Z-\]b', False)
         check(r'a[Z-\]b', r'a[Z-\]b', False)
         check('a[Z-/]b', r'a[Z-\]b', False)
@@ -221,24 +218,24 @@ class TranslateTestCase(unittest.TestCase):
 
     def test_translate(self):
         import re
-        self.assertEqual(translate('*'), r'(?s:.*)\Z')
-        self.assertEqual(translate('?'), r'(?s:.)\Z')
-        self.assertEqual(translate('a?b*'), r'(?s:a.b.*)\Z')
-        self.assertEqual(translate('[abc]'), r'(?s:[abc])\Z')
-        self.assertEqual(translate('[]]'), r'(?s:[]])\Z')
-        self.assertEqual(translate('[!x]'), r'(?s:[^x])\Z')
-        self.assertEqual(translate('[^x]'), r'(?s:[\^x])\Z')
-        self.assertEqual(translate('[x'), r'(?s:\[x)\Z')
+        self.assertEqual(translate('*'), r'(?s:.*)\z')
+        self.assertEqual(translate('?'), r'(?s:.)\z')
+        self.assertEqual(translate('a?b*'), r'(?s:a.b.*)\z')
+        self.assertEqual(translate('[abc]'), r'(?s:[abc])\z')
+        self.assertEqual(translate('[]]'), r'(?s:[]])\z')
+        self.assertEqual(translate('[!x]'), r'(?s:[^x])\z')
+        self.assertEqual(translate('[^x]'), r'(?s:[\^x])\z')
+        self.assertEqual(translate('[x'), r'(?s:\[x)\z')
         # from the docs
-        self.assertEqual(translate('*.txt'), r'(?s:.*\.txt)\Z')
+        self.assertEqual(translate('*.txt'), r'(?s:.*\.txt)\z')
         # squash consecutive stars
-        self.assertEqual(translate('*********'), r'(?s:.*)\Z')
-        self.assertEqual(translate('A*********'), r'(?s:A.*)\Z')
-        self.assertEqual(translate('*********A'), r'(?s:.*A)\Z')
-        self.assertEqual(translate('A*********?[?]?'), r'(?s:A.*.[?].)\Z')
+        self.assertEqual(translate('*********'), r'(?s:.*)\z')
+        self.assertEqual(translate('A*********'), r'(?s:A.*)\z')
+        self.assertEqual(translate('*********A'), r'(?s:.*A)\z')
+        self.assertEqual(translate('A*********?[?]?'), r'(?s:A.*.[?].)\z')
         # fancy translation to prevent exponential-time match failure
         t = translate('**a*a****a')
-        self.assertEqual(t, r'(?s:(?>.*?a)(?>.*?a).*a)\Z')
+        self.assertEqual(t, r'(?s:(?>.*?a)(?>.*?a).*a)\z')
         # and try pasting multiple translate results - it's an undocumented
         # feature that this works
         r1 = translate('**a**a**a*')
@@ -250,6 +247,75 @@ def test_translate(self):
         self.assertTrue(re.match(fatre, 'cbabcaxc'))
         self.assertFalse(re.match(fatre, 'dabccbad'))
 
+    def test_translate_wildcards(self):
+        for pattern, expect in [
+            ('ab*', r'(?s:ab.*)\z'),
+            ('ab*cd', r'(?s:ab.*cd)\z'),
+            ('ab*cd*', r'(?s:ab(?>.*?cd).*)\z'),
+            ('ab*cd*12', r'(?s:ab(?>.*?cd).*12)\z'),
+            ('ab*cd*12*', r'(?s:ab(?>.*?cd)(?>.*?12).*)\z'),
+            ('ab*cd*12*34', r'(?s:ab(?>.*?cd)(?>.*?12).*34)\z'),
+            ('ab*cd*12*34*', r'(?s:ab(?>.*?cd)(?>.*?12)(?>.*?34).*)\z'),
+        ]:
+            with self.subTest(pattern):
+                translated = translate(pattern)
+                self.assertEqual(translated, expect, pattern)
+
+        for pattern, expect in [
+            ('*ab', r'(?s:.*ab)\z'),
+            ('*ab*', r'(?s:(?>.*?ab).*)\z'),
+            ('*ab*cd', r'(?s:(?>.*?ab).*cd)\z'),
+            ('*ab*cd*', r'(?s:(?>.*?ab)(?>.*?cd).*)\z'),
+            ('*ab*cd*12', r'(?s:(?>.*?ab)(?>.*?cd).*12)\z'),
+            ('*ab*cd*12*', r'(?s:(?>.*?ab)(?>.*?cd)(?>.*?12).*)\z'),
+            ('*ab*cd*12*34', r'(?s:(?>.*?ab)(?>.*?cd)(?>.*?12).*34)\z'),
+            ('*ab*cd*12*34*', r'(?s:(?>.*?ab)(?>.*?cd)(?>.*?12)(?>.*?34).*)\z'),
+        ]:
+            with self.subTest(pattern):
+                translated = translate(pattern)
+                self.assertEqual(translated, expect, pattern)
+
+    def test_translate_expressions(self):
+        for pattern, expect in [
+            ('[', r'(?s:\[)\z'),
+            ('[!', r'(?s:\[!)\z'),
+            ('[]', r'(?s:\[\])\z'),
+            ('[abc', r'(?s:\[abc)\z'),
+            ('[!abc', r'(?s:\[!abc)\z'),
+            ('[abc]', r'(?s:[abc])\z'),
+            ('[!abc]', r'(?s:[^abc])\z'),
+            ('[!abc][!def]', r'(?s:[^abc][^def])\z'),
+            # with [[
+            ('[[', r'(?s:\[\[)\z'),
+            ('[[a', r'(?s:\[\[a)\z'),
+            ('[[]', r'(?s:[\[])\z'),
+            ('[[]a', r'(?s:[\[]a)\z'),
+            ('[[]]', r'(?s:[\[]\])\z'),
+            ('[[]a]', r'(?s:[\[]a\])\z'),
+            ('[[a]', r'(?s:[\[a])\z'),
+            ('[[a]]', r'(?s:[\[a]\])\z'),
+            ('[[a]b', r'(?s:[\[a]b)\z'),
+            # backslashes
+            ('[\\', r'(?s:\[\\)\z'),
+            (r'[\]', r'(?s:[\\])\z'),
+            (r'[\\]', r'(?s:[\\\\])\z'),
+        ]:
+            with self.subTest(pattern):
+                translated = translate(pattern)
+                self.assertEqual(translated, expect, pattern)
+
+    def test_star_indices_locations(self):
+        from fnmatch import _translate
+
+        blocks = ['a^b', '***', '?', '?', '[a-z]', '[1-9]', '*', '++', '[[a']
+        parts, star_indices = _translate(''.join(blocks), '*', '.')
+        expect_parts = ['a', r'\^', 'b', '*',
+                        '.', '.', '[a-z]', '[1-9]', '*',
+                        r'\+', r'\+', r'\[', r'\[', 'a']
+        self.assertListEqual(parts, expect_parts)
+        self.assertListEqual(star_indices, [3, 8])
+
+
 class FilterTestCase(unittest.TestCase):
 
     def test_filter(self):
@@ -263,18 +329,41 @@ def test_mix_bytes_str(self):
         self.assertRaises(TypeError, filter, [b'test'], '*')
 
     def test_case(self):
-        ignorecase = os.path.normcase('P') == os.path.normcase('p')
         self.assertEqual(filter(['Test.py', 'Test.rb', 'Test.PL'], '*.p*'),
-                         ['Test.py', 'Test.PL'] if ignorecase else ['Test.py'])
+                         ['Test.py', 'Test.PL'] if IGNORECASE else ['Test.py'])
         self.assertEqual(filter(['Test.py', 'Test.rb', 'Test.PL'], '*.P*'),
-                         ['Test.py', 'Test.PL'] if ignorecase else ['Test.PL'])
+                         ['Test.py', 'Test.PL'] if IGNORECASE else ['Test.PL'])
 
     def test_sep(self):
-        normsep = os.path.normcase('\\') == os.path.normcase('/')
         self.assertEqual(filter(['usr/bin', 'usr', 'usr\\lib'], 'usr/*'),
-                         ['usr/bin', 'usr\\lib'] if normsep else ['usr/bin'])
+                         ['usr/bin', 'usr\\lib'] if NORMSEP else ['usr/bin'])
         self.assertEqual(filter(['usr/bin', 'usr', 'usr\\lib'], 'usr\\*'),
-                         ['usr/bin', 'usr\\lib'] if normsep else ['usr\\lib'])
+                         ['usr/bin', 'usr\\lib'] if NORMSEP else ['usr\\lib'])
+
+
+class FilterFalseTestCase(unittest.TestCase):
+
+    def test_filterfalse(self):
+        actual = filterfalse(['Python', 'Ruby', 'Perl', 'Tcl'], 'P*')
+        self.assertListEqual(actual, ['Ruby', 'Tcl'])
+        actual = filterfalse([b'Python', b'Ruby', b'Perl', b'Tcl'], b'P*')
+        self.assertListEqual(actual, [b'Ruby', b'Tcl'])
+
+    def test_mix_bytes_str(self):
+        self.assertRaises(TypeError, filterfalse, ['test'], b'*')
+        self.assertRaises(TypeError, filterfalse, [b'test'], '*')
+
+    def test_case(self):
+        self.assertEqual(filterfalse(['Test.py', 'Test.rb', 'Test.PL'], '*.p*'),
+                         ['Test.rb'] if IGNORECASE else ['Test.rb', 'Test.PL'])
+        self.assertEqual(filterfalse(['Test.py', 'Test.rb', 'Test.PL'], '*.P*'),
+                         ['Test.rb'] if IGNORECASE else ['Test.py', 'Test.rb',])
+
+    def test_sep(self):
+        self.assertEqual(filterfalse(['usr/bin', 'usr', 'usr\\lib'], 'usr/*'),
+                         ['usr'] if NORMSEP else ['usr', 'usr\\lib'])
+        self.assertEqual(filterfalse(['usr/bin', 'usr', 'usr\\lib'], 'usr\\*'),
+                         ['usr'] if NORMSEP else ['usr/bin', 'usr'])
 
 
 if __name__ == "__main__":
diff --git a/Lib/test/test_fork1.py b/Lib/test/test_fork1.py
new file mode 100644
index 00000000000..a6523bbc518
--- /dev/null
+++ b/Lib/test/test_fork1.py
@@ -0,0 +1,102 @@
+"""This test checks for correct fork() behavior.
+"""
+
+import _imp as imp
+import os
+import signal
+import sys
+import threading
+import time
+import unittest
+
+from test.fork_wait import ForkWait
+from test import support
+
+
+# Skip test if fork does not exist.
+if not support.has_fork_support:
+    raise unittest.SkipTest("test module requires working os.fork")
+
+
+class ForkTest(ForkWait):
+    def test_threaded_import_lock_fork(self):
+        """Check fork() in main thread works while a subthread is doing an import"""
+        import_started = threading.Event()
+        fake_module_name = "fake test module"
+        partial_module = "partial"
+        complete_module = "complete"
+        def importer():
+            imp.acquire_lock()
+            sys.modules[fake_module_name] = partial_module
+            import_started.set()
+            time.sleep(0.01) # Give the other thread time to try and acquire.
+            sys.modules[fake_module_name] = complete_module
+            imp.release_lock()
+        t = threading.Thread(target=importer)
+        t.start()
+        import_started.wait()
+        exitcode = 42
+        pid = os.fork()
+        try:
+            # PyOS_BeforeFork should have waited for the import to complete
+            # before forking, so the child can recreate the import lock
+            # correctly, but also won't see a partially initialised module
+            if not pid:
+                m = __import__(fake_module_name)
+                if m == complete_module:
+                    os._exit(exitcode)
+                else:
+                    if support.verbose > 1:
+                        print("Child encountered partial module")
+                    os._exit(1)
+            else:
+                t.join()
+                # Exitcode 1 means the child got a partial module (bad.) No
+                # exitcode (but a hang, which manifests as 'got pid 0')
+                # means the child deadlocked (also bad.)
+                self.wait_impl(pid, exitcode=exitcode)
+        finally:
+            try:
+                os.kill(pid, signal.SIGKILL)
+            except OSError:
+                pass
+
+
+    def test_nested_import_lock_fork(self):
+        """Check fork() in main thread works while the main thread is doing an import"""
+        exitcode = 42
+        # Issue 9573: this used to trigger RuntimeError in the child process
+        def fork_with_import_lock(level):
+            release = 0
+            in_child = False
+            try:
+                try:
+                    for i in range(level):
+                        imp.acquire_lock()
+                        release += 1
+                    pid = os.fork()
+                    in_child = not pid
+                finally:
+                    for i in range(release):
+                        imp.release_lock()
+            except RuntimeError:
+                if in_child:
+                    if support.verbose > 1:
+                        print("RuntimeError in child")
+                    os._exit(1)
+                raise
+            if in_child:
+                os._exit(exitcode)
+            self.wait_impl(pid, exitcode=exitcode)
+
+        # Check this works with various levels of nested
+        # import in the main thread
+        for level in range(5):
+            fork_with_import_lock(level)
+
+
+def tearDownModule():
+    support.reap_children()
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/Lib/test/test_format.py b/Lib/test/test_format.py
index 79fbab34c30..d53a3f46134 100644
--- a/Lib/test/test_format.py
+++ b/Lib/test/test_format.py
@@ -4,6 +4,7 @@
 import re
 import test.support as support
 import unittest
+from test.support.import_helper import import_module
 
 maxsize = support.MAX_Py_ssize_t
 
@@ -35,7 +36,7 @@ def testformat(formatstr, args, output=None, limit=None, overflowok=False):
         # when 'limit' is specified, it determines how many characters
         # must match exactly; lengths must always match.
         # ex: limit=5, '12345678' matches '12345___'
-        # (mainly for floating point format tests for which an exact match
+        # (mainly for floating-point format tests for which an exact match
         # can't be guaranteed due to rounding and representation errors)
         elif output and limit is not None and (
                 len(result)!=len(output) or result[:limit]!=output[:limit]):
@@ -282,6 +283,10 @@ def test_common_format(self):
                         "%x format: an integer is required, not str")
         test_exc_common('%x', 3.14, TypeError,
                         "%x format: an integer is required, not float")
+        test_exc_common('%i', '1', TypeError,
+                        "%i format: a real number is required, not str")
+        test_exc_common('%i', b'1', TypeError,
+                        "%i format: a real number is required, not bytes")
 
     def test_str_format(self):
         testformat("%r", "\u0378", "'\\u0378'")  # non printable
@@ -303,9 +308,9 @@ def test_str_format(self):
         test_exc('%c', sys.maxunicode+1, OverflowError,
                  "%c arg not in range(0x110000)")
         #test_exc('%c', 2**128, OverflowError, "%c arg not in range(0x110000)")
-        test_exc('%c', 3.14, TypeError, "%c requires int or char")
-        test_exc('%c', 'ab', TypeError, "%c requires int or char")
-        test_exc('%c', b'x', TypeError, "%c requires int or char")
+        test_exc('%c', 3.14, TypeError, "%c requires an int or a unicode character, not float")
+        test_exc('%c', 'ab', TypeError, "%c requires an int or a unicode character, not a string of length 2")
+        test_exc('%c', b'x', TypeError, "%c requires an int or a unicode character, not bytes")
 
         if maxsize == 2**31-1:
             # crashes 2.2.1 and earlier:
@@ -341,12 +346,12 @@ def __bytes__(self):
         testcommon(b"%s", memoryview(b"abc"), b"abc")
         # %a will give the equivalent of
         # repr(some_obj).encode('ascii', 'backslashreplace')
-        testcommon(b"%a", 3.14, b"3.14")
+        testcommon(b"%a", 3.25, b"3.25")
         testcommon(b"%a", b"ghi", b"b'ghi'")
         testcommon(b"%a", "jkl", b"'jkl'")
         testcommon(b"%a", "\u0544", b"'\\u0544'")
         # %r is an alias for %a
-        testcommon(b"%r", 3.14, b"3.14")
+        testcommon(b"%r", 3.25, b"3.25")
         testcommon(b"%r", b"ghi", b"b'ghi'")
         testcommon(b"%r", "jkl", b"'jkl'")
         testcommon(b"%r", "\u0544", b"'\\u0544'")
@@ -369,11 +374,11 @@ def __bytes__(self):
         test_exc(b"%c", 2**128, OverflowError,
                 "%c arg not in range(256)")
         test_exc(b"%c", b"Za", TypeError,
-                "%c requires an integer in range(256) or a single byte")
+                "%c requires an integer in range(256) or a single byte, not a bytes object of length 2")
         test_exc(b"%c", "Y", TypeError,
-                "%c requires an integer in range(256) or a single byte")
+                "%c requires an integer in range(256) or a single byte, not str")
         test_exc(b"%c", 3.14, TypeError,
-                "%c requires an integer in range(256) or a single byte")
+                "%c requires an integer in range(256) or a single byte, not float")
         test_exc(b"%b", "Xc", TypeError,
                 "%b requires a bytes-like object, "
                  "or an object that implements __bytes__, not 'str'")
@@ -402,25 +407,23 @@ def test_non_ascii(self):
 
         self.assertEqual(format("abc", "\u2007<5"), "abc\u2007\u2007")
         self.assertEqual(format(123, "\u2007<5"), "123\u2007\u2007")
-        self.assertEqual(format(12.3, "\u2007<6"), "12.3\u2007\u2007")
+        self.assertEqual(format(12.5, "\u2007<6"), "12.5\u2007\u2007")
         self.assertEqual(format(0j, "\u2007<4"), "0j\u2007\u2007")
         self.assertEqual(format(1+2j, "\u2007<8"), "(1+2j)\u2007\u2007")
 
         self.assertEqual(format("abc", "\u2007>5"), "\u2007\u2007abc")
         self.assertEqual(format(123, "\u2007>5"), "\u2007\u2007123")
-        self.assertEqual(format(12.3, "\u2007>6"), "\u2007\u200712.3")
+        self.assertEqual(format(12.5, "\u2007>6"), "\u2007\u200712.5")
         self.assertEqual(format(1+2j, "\u2007>8"), "\u2007\u2007(1+2j)")
         self.assertEqual(format(0j, "\u2007>4"), "\u2007\u20070j")
 
         self.assertEqual(format("abc", "\u2007^5"), "\u2007abc\u2007")
         self.assertEqual(format(123, "\u2007^5"), "\u2007123\u2007")
-        self.assertEqual(format(12.3, "\u2007^6"), "\u200712.3\u2007")
+        self.assertEqual(format(12.5, "\u2007^6"), "\u200712.5\u2007")
         self.assertEqual(format(1+2j, "\u2007^8"), "\u2007(1+2j)\u2007")
         self.assertEqual(format(0j, "\u2007^4"), "\u20070j\u2007")
 
-    # TODO: RUSTPYTHON formatting does not support locales
-    # See https://github.com/RustPython/RustPython/issues/5181
-    @unittest.skip("formatting does not support locales")
+    @unittest.expectedFailureIfWindows("TODO: RUSTPYTHON; AssertionError: ',' not found in '123456789'")
     def test_locale(self):
         try:
             oldloc = locale.setlocale(locale.LC_ALL)
@@ -481,7 +484,8 @@ def test_precision(self):
 
     @support.cpython_only
     def test_precision_c_limits(self):
-        from _testcapi import INT_MAX
+        _testcapi = import_module("_testcapi")
+        INT_MAX = _testcapi.INT_MAX
 
         f = 1.2
         with self.assertRaises(ValueError) as cm:
@@ -512,18 +516,23 @@ def test_with_two_underscore_in_format_specifier(self):
         with self.assertRaisesRegex(ValueError, error_msg):
             '{:__}'.format(1)
 
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; Wrong error message
     def test_with_a_commas_and_an_underscore_in_format_specifier(self):
         error_msg = re.escape("Cannot specify both ',' and '_'.")
         with self.assertRaisesRegex(ValueError, error_msg):
             '{:,_}'.format(1)
+        with self.assertRaisesRegex(ValueError, error_msg):
+            '{:.,_f}'.format(1.1)
 
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; Wrong error message
     def test_with_an_underscore_and_a_comma_in_format_specifier(self):
         error_msg = re.escape("Cannot specify both ',' and '_'.")
         with self.assertRaisesRegex(ValueError, error_msg):
             '{:_,}'.format(1)
+        with self.assertRaisesRegex(ValueError, error_msg):
+            '{:._,f}'.format(1.1)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_better_error_message_format(self):
         # https://bugs.python.org/issue20524
         for value in [12j, 12, 12.0, "12"]:
@@ -545,16 +554,14 @@ def test_better_error_message_format(self):
                 with self.assertRaisesRegex(ValueError, err):
                     eval("f'xx{value:{bad_format_spec}}yy'")
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_unicode_in_error_message(self):
         str_err = re.escape(
             "Invalid format specifier '%ЫйЯЧ' for object of type 'str'")
         with self.assertRaisesRegex(ValueError, str_err):
             "{a:%ЫйЯЧ}".format(a='a')
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_negative_zero(self):
         ## default behavior
         self.assertEqual(f"{-0.:.1f}", "-0.0")
@@ -612,8 +619,7 @@ def test_negative_zero(self):
         self.assertEqual(f"{-0.:x>z6.1f}", "xxx0.0")
         self.assertEqual(f"{-0.:🖤>z6.1f}", "🖤🖤🖤0.0")  # multi-byte fill char
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_specifier_z_error(self):
         error_msg = re.compile("Invalid format specifier '.*z.*'")
         with self.assertRaisesRegex(ValueError, error_msg):
@@ -630,6 +636,8 @@ def test_specifier_z_error(self):
         error_msg = re.escape("unsupported format character 'z'")
         with self.assertRaisesRegex(ValueError, error_msg):
             "%z.1f" % 0  # not allowed in old style string interpolation
+        with self.assertRaisesRegex(ValueError, error_msg):
+            b"%z.1f" % 0
 
 
 if __name__ == "__main__":
diff --git a/Lib/test/test_fractions.py b/Lib/test/test_fractions.py
index 67c9b98d67f..49fc9c2ba23 100644
--- a/Lib/test/test_fractions.py
+++ b/Lib/test/test_fractions.py
@@ -1,6 +1,5 @@
 """Tests for Lib/fractions.py."""
 
-import cmath
 from decimal import Decimal
 from test.support import requires_IEEE_754, adjust_int_max_str_digits
 import math
@@ -284,6 +283,13 @@ def __repr__(self):
 class RectComplex(Rect, complex):
     pass
 
+class Ratio:
+    def __init__(self, ratio):
+        self._ratio = ratio
+    def as_integer_ratio(self):
+        return self._ratio
+
+
 class FractionTest(unittest.TestCase):
 
     def assertTypedEquals(self, expected, actual):
@@ -355,6 +361,38 @@ def testInitFromDecimal(self):
         self.assertRaises(OverflowError, F, Decimal('inf'))
         self.assertRaises(OverflowError, F, Decimal('-inf'))
 
+    def testInitFromIntegerRatio(self):
+        self.assertEqual((7, 3), _components(F(Ratio((7, 3)))))
+        errmsg = (r"argument should be a string or a Rational instance or "
+                  r"have the as_integer_ratio\(\) method")
+        # the type also has an "as_integer_ratio" attribute.
+        self.assertRaisesRegex(TypeError, errmsg, F, Ratio)
+        # bad ratio
+        self.assertRaises(TypeError, F, Ratio(7))
+        self.assertRaises(ValueError, F, Ratio((7,)))
+        self.assertRaises(ValueError, F, Ratio((7, 3, 1)))
+        # only single-argument form
+        self.assertRaises(TypeError, F, Ratio((3, 7)), 11)
+        self.assertRaises(TypeError, F, 2, Ratio((-10, 9)))
+
+        # as_integer_ratio not defined in a class
+        class A:
+            pass
+        a = A()
+        a.as_integer_ratio = lambda: (9, 5)
+        self.assertEqual((9, 5), _components(F(a)))
+
+        # as_integer_ratio defined in a metaclass
+        class M(type):
+            def as_integer_ratio(self):
+                return (11, 9)
+        class B(metaclass=M):
+            pass
+        self.assertRaisesRegex(TypeError, errmsg, F, B)
+        self.assertRaisesRegex(TypeError, errmsg, F, B())
+        self.assertRaises(TypeError, F.from_number, B)
+        self.assertRaises(TypeError, F.from_number, B())
+
     def testFromString(self):
         self.assertEqual((5, 1), _components(F("5")))
         self.assertEqual((5, 1), _components(F("005")))
@@ -548,6 +586,37 @@ def testFromDecimal(self):
             ValueError, "cannot convert NaN to integer ratio",
             F.from_decimal, Decimal("snan"))
 
+    def testFromNumber(self, cls=F):
+        def check(arg, numerator, denominator):
+            f = cls.from_number(arg)
+            self.assertIs(type(f), cls)
+            self.assertEqual(f.numerator, numerator)
+            self.assertEqual(f.denominator, denominator)
+
+        check(10, 10, 1)
+        check(2.5, 5, 2)
+        check(Decimal('2.5'), 5, 2)
+        check(F(22, 7), 22, 7)
+        check(DummyFraction(22, 7), 22, 7)
+        check(Rat(22, 7), 22, 7)
+        check(Ratio((22, 7)), 22, 7)
+        self.assertRaises(TypeError, cls.from_number, 3+4j)
+        self.assertRaises(TypeError, cls.from_number, '5/2')
+        self.assertRaises(TypeError, cls.from_number, [])
+        self.assertRaises(OverflowError, cls.from_number, float('inf'))
+        self.assertRaises(OverflowError, cls.from_number, Decimal('inf'))
+
+        # as_integer_ratio not defined in a class
+        class A:
+            pass
+        a = A()
+        a.as_integer_ratio = lambda: (9, 5)
+        check(a, 9, 5)
+
+    def testFromNumber_subclass(self):
+        self.testFromNumber(DummyFraction)
+
+
     def test_is_integer(self):
         self.assertTrue(F(1, 1).is_integer())
         self.assertTrue(F(-1, 1).is_integer())
@@ -794,7 +863,7 @@ def testMixedMultiplication(self):
         self.assertTypedEquals(F(3, 2) * Polar(4, 2), Polar(F(6, 1), 2))
         self.assertTypedEquals(F(3, 2) * Polar(4.0, 2), Polar(6.0, 2))
         self.assertTypedEquals(F(3, 2) * Rect(4, 3), Rect(F(6, 1), F(9, 2)))
-        self.assertTypedEquals(F(3, 2) * RectComplex(4, 3), RectComplex(6.0+0j, 4.5+0j))
+        self.assertTypedEquals(F(3, 2) * RectComplex(4, 3), RectComplex(6.0, 4.5))
         self.assertRaises(TypeError, operator.mul, Polar(4, 2), F(3, 2))
         self.assertTypedEquals(Rect(4, 3) * F(3, 2), 6.0 + 4.5j)
         self.assertEqual(F(3, 2) * SymbolicComplex('X'), SymbolicComplex('3/2 * X'))
@@ -1253,6 +1322,8 @@ def test_format_e_presentation_type(self):
             # Thousands separators
             (F('1234567.123456'), ',.5e', '1.23457e+06'),
             (F('123.123456'), '012_.2e', '0_001.23e+02'),
+            # Thousands separators for fractional part (or for integral too)
+            (F('1234567.123456'), '.5_e', '1.234_57e+06'),
             # z flag is legal, but never makes a difference to the output
             (F(-1, 7**100), 'z.6e', '-3.091690e-85'),
         ]
@@ -1378,6 +1449,12 @@ def test_format_f_presentation_type(self):
             (F('1234567'), ',.2f', '1,234,567.00'),
             (F('12345678'), ',.2f', '12,345,678.00'),
             (F('12345678'), ',f', '12,345,678.000000'),
+            # Thousands separators for fractional part (or for integral too)
+            (F('123456.789123123'), '._f', '123456.789_123'),
+            (F('123456.789123123'), '.7_f', '123456.789_123_1'),
+            (F('123456.789123123'), '.9_f', '123456.789_123_123'),
+            (F('123456.789123123'), '.,f', '123456.789,123'),
+            (F('123456.789123123'), '_.,f', '123_456.789,123'),
             # Underscore as thousands separator
             (F(2, 3), '_.2f', '0.67'),
             (F(2, 3), '_.7f', '0.6666667'),
@@ -1446,6 +1523,8 @@ def test_format_f_presentation_type(self):
             (F(51, 1000), '.1f', '0.1'),
             (F(149, 1000), '.1f', '0.1'),
             (F(151, 1000), '.1f', '0.2'),
+            (F(22, 7), '.02f', '3.14'),  # issue gh-130662
+            (F(22, 7), '005.02f', '03.14'),
         ]
         for fraction, spec, expected in testcases:
             with self.subTest(fraction=fraction, spec=spec):
@@ -1544,17 +1623,16 @@ def test_invalid_formats(self):
             '=010%',
             '>00.2f',
             '>00f',
-            # Too many zeros - minimum width should not have leading zeros
-            '006f',
-            # Leading zeros in precision
-            '.010f',
-            '.02f',
-            '.000f',
             # Missing precision
             '.e',
             '.f',
             '.g',
             '.%',
+            # Thousands separators before precision
+            '._6e',
+            '._6f',
+            '._6g',
+            '._6%',
             # Z instead of z for negative zero suppression
             'Z.2f'
             # z flag not supported for general formatting
@@ -1591,9 +1669,7 @@ 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
+    @unittest.expectedFailure # TODO: RUSTPYTHON; TypeError: '%' not supported between instances of 'Fraction' and 'complex'
     def test_complex_handling(self):
         # See issue gh-102840 for more details.
 
@@ -1621,6 +1697,19 @@ def test_complex_handling(self):
                                  message % ("divmod()", "complex", "Fraction"),
                                  divmod, b, a)
 
+    @unittest.expectedFailure # TODO: RUSTPYTHON; Wrong error message
+    def test_three_argument_pow(self):
+        message = "unsupported operand type(s) for ** or pow(): '%s', '%s', '%s'"
+        self.assertRaisesMessage(TypeError,
+                                 message % ("Fraction", "int", "int"),
+                                 pow, F(3), 4, 5)
+        self.assertRaisesMessage(TypeError,
+                                 message % ("int", "Fraction", "int"),
+                                 pow, 3, F(4), 5)
+        self.assertRaisesMessage(TypeError,
+                                 message % ("int", "int", "Fraction"),
+                                 pow, 3, 4, F(5))
+
 
 if __name__ == '__main__':
     unittest.main()
diff --git a/Lib/test/test_frame.py b/Lib/test/test_frame.py
new file mode 100644
index 00000000000..ae02e2a59f9
--- /dev/null
+++ b/Lib/test/test_frame.py
@@ -0,0 +1,814 @@
+import copy
+import operator
+import re
+import sys
+import textwrap
+import threading
+import unittest
+import weakref
+try:
+    import _testcapi
+except ImportError:
+    _testcapi = None
+
+from collections.abc import Mapping
+from test import support
+from test.support import import_helper, threading_helper
+from test.support.script_helper import assert_python_ok
+from test import mapping_tests
+
+
+class ClearTest(unittest.TestCase):
+    """
+    Tests for frame.clear().
+    """
+
+    def inner(self, x=5, **kwargs):
+        1/0
+
+    def outer(self, **kwargs):
+        try:
+            self.inner(**kwargs)
+        except ZeroDivisionError as e:
+            exc = e
+        return exc
+
+    def clear_traceback_frames(self, tb):
+        """
+        Clear all frames in a traceback.
+        """
+        while tb is not None:
+            tb.tb_frame.clear()
+            tb = tb.tb_next
+
+    def test_clear_locals(self):
+        class C:
+            pass
+        c = C()
+        wr = weakref.ref(c)
+        exc = self.outer(c=c)
+        del c
+        support.gc_collect()
+        # A reference to c is held through the frames
+        self.assertIsNot(None, wr())
+        self.clear_traceback_frames(exc.__traceback__)
+        support.gc_collect()
+        # The reference was released by .clear()
+        self.assertIs(None, wr())
+
+    def test_clear_locals_after_f_locals_access(self):
+        # see gh-113939
+        class C:
+            pass
+
+        wr = None
+        def inner():
+            nonlocal wr
+            c = C()
+            wr = weakref.ref(c)
+            1/0
+
+        try:
+            inner()
+        except ZeroDivisionError as exc:
+            support.gc_collect()
+            self.assertIsNotNone(wr())
+            exc.__traceback__.tb_next.tb_frame.clear()
+            support.gc_collect()
+            self.assertIsNone(wr())
+
+    def test_clear_does_not_clear_specials(self):
+        class C:
+            pass
+        c = C()
+        exc = self.outer(c=c)
+        del c
+        f = exc.__traceback__.tb_frame
+        f.clear()
+        self.assertIsNot(f.f_code, None)
+        self.assertIsNot(f.f_locals, None)
+        self.assertIsNot(f.f_builtins, None)
+        self.assertIsNot(f.f_globals, None)
+
+    def test_clear_generator(self):
+        endly = False
+        def g():
+            nonlocal endly
+            try:
+                yield
+                self.inner()
+            finally:
+                endly = True
+        gen = g()
+        next(gen)
+        self.assertFalse(endly)
+
+        # Cannot clear a suspended frame
+        with self.assertRaisesRegex(RuntimeError, r'suspended frame'):
+            gen.gi_frame.clear()
+        self.assertFalse(endly)
+
+    def test_clear_executing(self):
+        # Attempting to clear an executing frame is forbidden.
+        try:
+            1/0
+        except ZeroDivisionError as e:
+            f = e.__traceback__.tb_frame
+        with self.assertRaises(RuntimeError):
+            f.clear()
+        with self.assertRaises(RuntimeError):
+            f.f_back.clear()
+
+    def test_clear_executing_generator(self):
+        # Attempting to clear an executing generator frame is forbidden.
+        endly = False
+        def g():
+            nonlocal endly
+            try:
+                1/0
+            except ZeroDivisionError as e:
+                f = e.__traceback__.tb_frame
+                with self.assertRaises(RuntimeError):
+                    f.clear()
+                with self.assertRaises(RuntimeError):
+                    f.f_back.clear()
+                yield f
+            finally:
+                endly = True
+        gen = g()
+        f = next(gen)
+        self.assertFalse(endly)
+        # Cannot clear a suspended frame
+        with self.assertRaisesRegex(RuntimeError, 'suspended frame'):
+            f.clear()
+        self.assertFalse(endly)
+
+    def test_lineno_with_tracing(self):
+        def record_line():
+            f = sys._getframe(1)
+            lines.append(f.f_lineno-f.f_code.co_firstlineno)
+
+        def test(trace):
+            record_line()
+            if trace:
+                sys._getframe(0).f_trace = True
+            record_line()
+            record_line()
+
+        expected_lines = [1, 4, 5]
+        lines = []
+        test(False)
+        self.assertEqual(lines, expected_lines)
+        lines = []
+        test(True)
+        self.assertEqual(lines, expected_lines)
+
+    @support.cpython_only
+    def test_clear_refcycles(self):
+        # .clear() doesn't leave any refcycle behind
+        with support.disable_gc():
+            class C:
+                pass
+            c = C()
+            wr = weakref.ref(c)
+            exc = self.outer(c=c)
+            del c
+            self.assertIsNot(None, wr())
+            self.clear_traceback_frames(exc.__traceback__)
+            self.assertIs(None, wr())
+
+
+class FrameAttrsTest(unittest.TestCase):
+
+    def make_frames(self):
+        def outer():
+            x = 5
+            y = 6
+            def inner():
+                z = x + 2
+                1/0
+                t = 9
+            return inner()
+        try:
+            outer()
+        except ZeroDivisionError as e:
+            tb = e.__traceback__
+            frames = []
+            while tb:
+                frames.append(tb.tb_frame)
+                tb = tb.tb_next
+        return frames
+
+    def test_clear_locals(self):
+        # Test f_locals after clear() (issue #21897)
+        f, outer, inner = self.make_frames()
+        outer.clear()
+        inner.clear()
+        self.assertEqual(outer.f_locals, {})
+        self.assertEqual(inner.f_locals, {})
+
+    def test_locals_clear_locals(self):
+        # Test f_locals before and after clear() (to exercise caching)
+        f, outer, inner = self.make_frames()
+        self.assertNotEqual(outer.f_locals, {})
+        self.assertNotEqual(inner.f_locals, {})
+        outer.clear()
+        inner.clear()
+        self.assertEqual(outer.f_locals, {})
+        self.assertEqual(inner.f_locals, {})
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; TypeError: can't delete f_lineno attribute
+    def test_f_lineno_del_segfault(self):
+        f, _, _ = self.make_frames()
+        with self.assertRaises(AttributeError):
+            del f.f_lineno
+
+    def test_f_generator(self):
+        # Test f_generator in different contexts.
+
+        def t0():
+            def nested():
+                frame = sys._getframe()
+                return frame.f_generator
+
+            def gen():
+                yield nested()
+
+            g = gen()
+            try:
+                return next(g)
+            finally:
+                g.close()
+
+        def t1():
+            frame = sys._getframe()
+            return frame.f_generator
+
+        def t2():
+            frame = sys._getframe()
+            yield frame.f_generator
+
+        async def t3():
+            frame = sys._getframe()
+            return frame.f_generator
+
+        # For regular functions f_generator is None
+        self.assertIsNone(t0())
+        self.assertIsNone(t1())
+
+        # For generators f_generator is equal to self
+        g = t2()
+        try:
+            frame_g = next(g)
+            self.assertIs(g, frame_g)
+        finally:
+            g.close()
+
+        # Ditto for coroutines
+        c = t3()
+        try:
+            c.send(None)
+        except StopIteration as ex:
+            self.assertIs(ex.value, c)
+        else:
+            raise AssertionError('coroutine did not exit')
+
+
+class ReprTest(unittest.TestCase):
+    """
+    Tests for repr(frame).
+    """
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    def test_repr(self):
+        def outer():
+            x = 5
+            y = 6
+            def inner():
+                z = x + 2
+                1/0
+                t = 9
+            return inner()
+
+        offset = outer.__code__.co_firstlineno
+        try:
+            outer()
+        except ZeroDivisionError as e:
+            tb = e.__traceback__
+            frames = []
+            while tb:
+                frames.append(tb.tb_frame)
+                tb = tb.tb_next
+        else:
+            self.fail("should have raised")
+
+        f_this, f_outer, f_inner = frames
+        file_repr = re.escape(repr(__file__))
+        self.assertRegex(repr(f_this),
+                         r"^<frame at 0x[0-9a-fA-F]+, file %s, line %d, code test_repr>$"
+                         % (file_repr, offset + 23))
+        self.assertRegex(repr(f_outer),
+                         r"^<frame at 0x[0-9a-fA-F]+, file %s, line %d, code outer>$"
+                         % (file_repr, offset + 7))
+        self.assertRegex(repr(f_inner),
+                         r"^<frame at 0x[0-9a-fA-F]+, file %s, line %d, code inner>$"
+                         % (file_repr, offset + 5))
+
+class TestFrameLocals(unittest.TestCase):
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    def test_scope(self):
+        class A:
+            x = 1
+            sys._getframe().f_locals['x'] = 2
+            sys._getframe().f_locals['y'] = 2
+
+        self.assertEqual(A.x, 2)
+        self.assertEqual(A.y, 2)
+
+        def f():
+            x = 1
+            sys._getframe().f_locals['x'] = 2
+            sys._getframe().f_locals['y'] = 2
+            self.assertEqual(x, 2)
+            self.assertEqual(locals()['y'], 2)
+        f()
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AssertionError: 1 != 2
+    def test_closure(self):
+        x = 1
+        y = 2
+
+        def f():
+            z = x + y
+            d = sys._getframe().f_locals
+            self.assertEqual(d['x'], 1)
+            self.assertEqual(d['y'], 2)
+            d['x'] = 2
+            d['y'] = 3
+
+        f()
+        self.assertEqual(x, 2)
+        self.assertEqual(y, 3)
+
+    def test_closure_with_inline_comprehension(self):
+        lambda: k
+        k = 1
+        lst = [locals() for k in [0]]
+        self.assertEqual(lst[0]['k'], 0)
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AssertionError: 3 != 4
+    def test_as_dict(self):
+        x = 1
+        y = 2
+        d = sys._getframe().f_locals
+        # self, x, y, d
+        self.assertEqual(len(d), 4)
+        self.assertIs(d['d'], d)
+        self.assertEqual(set(d.keys()), set(['x', 'y', 'd', 'self']))
+        self.assertEqual(len(d.values()), 4)
+        self.assertIn(1, d.values())
+        self.assertEqual(len(d.items()), 4)
+        self.assertIn(('x', 1), d.items())
+        self.assertEqual(d.__getitem__('x'), 1)
+        d.__setitem__('x', 2)
+        self.assertEqual(d['x'], 2)
+        self.assertEqual(d.get('x'), 2)
+        self.assertIs(d.get('non_exist', None), None)
+        self.assertEqual(d.__len__(), 4)
+        self.assertEqual(set([key for key in d]), set(['x', 'y', 'd', 'self']))
+        self.assertIn('x', d)
+        self.assertTrue(d.__contains__('x'))
+
+        self.assertEqual(reversed(d), list(reversed(d.keys())))
+
+        d.update({'x': 3, 'z': 4})
+        self.assertEqual(d['x'], 3)
+        self.assertEqual(d['z'], 4)
+
+        with self.assertRaises(TypeError):
+            d.update([1, 2])
+
+        self.assertEqual(d.setdefault('x', 5), 3)
+        self.assertEqual(d.setdefault('new', 5), 5)
+        self.assertEqual(d['new'], 5)
+
+        with self.assertRaises(KeyError):
+            d['non_exist']
+
+    def test_as_number(self):
+        x = 1
+        y = 2
+        d = sys._getframe().f_locals
+        self.assertIn('z', d | {'z': 3})
+        d |= {'z': 3}
+        self.assertEqual(d['z'], 3)
+        d |= {'y': 3}
+        self.assertEqual(d['y'], 3)
+        with self.assertRaises(TypeError):
+            d |= 3
+        with self.assertRaises(TypeError):
+            _ = d | [3]
+
+    def test_non_string_key(self):
+        d = sys._getframe().f_locals
+        d[1] = 2
+        self.assertEqual(d[1], 2)
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; UnboundLocalError: local variable 'b' referenced before assignment
+    def test_write_with_hidden(self):
+        def f():
+            f_locals = [sys._getframe().f_locals for b in [0]][0]
+            f_locals['b'] = 2
+            f_locals['c'] = 3
+            self.assertEqual(b, 2)
+            self.assertEqual(c, 3)
+            b = 0
+            c = 0
+        f()
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AssertionError: <object object at 0xb4000072b6930480> != 'a.b.c'
+    def test_local_objects(self):
+        o = object()
+        k = '.'.join(['a', 'b', 'c'])
+        f_locals = sys._getframe().f_locals
+        f_locals['o'] = f_locals['k']
+        self.assertEqual(o, 'a.b.c')
+
+    def test_copy(self):
+        x = 0
+        d = sys._getframe().f_locals
+        d_copy = d.copy()
+        self.assertIsInstance(d_copy, dict)
+        self.assertEqual(d_copy['x'], 0)
+        d_copy['x'] = 1
+        self.assertEqual(x, 0)
+
+    def test_update_with_self(self):
+        def f():
+            f_locals = sys._getframe().f_locals
+            f_locals.update(f_locals)
+            f_locals.update(f_locals)
+            f_locals.update(f_locals)
+        f()
+
+    def test_repr(self):
+        x = 1
+        # Introduce a reference cycle
+        frame = sys._getframe()
+        self.assertEqual(repr(frame.f_locals), repr(dict(frame.f_locals)))
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AssertionError: ValueError not raised
+    def test_delete(self):
+        x = 1
+        d = sys._getframe().f_locals
+
+        # This needs to be tested before f_extra_locals is created
+        with self.assertRaisesRegex(KeyError, 'non_exist'):
+            del d['non_exist']
+
+        with self.assertRaises(KeyError):
+            d.pop('non_exist')
+
+        with self.assertRaisesRegex(ValueError, 'local variables'):
+            del d['x']
+
+        with self.assertRaises(AttributeError):
+            d.clear()
+
+        with self.assertRaises(ValueError):
+            d.pop('x')
+
+        with self.assertRaises(ValueError):
+            d.pop('x', None)
+
+        # 'm', 'n' is stored in f_extra_locals
+        d['m'] = 1
+        d['n'] = 1
+
+        with self.assertRaises(KeyError):
+            d.pop('non_exist')
+
+        del d['m']
+        self.assertEqual(d.pop('n'), 1)
+
+        self.assertNotIn('m', d)
+        self.assertNotIn('n', d)
+
+        self.assertEqual(d.pop('n', 2), 2)
+
+    @support.cpython_only
+    def test_sizeof(self):
+        proxy = sys._getframe().f_locals
+        support.check_sizeof(self, proxy, support.calcobjsize("P"))
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AssertionError: TypeError not raised
+    def test_unsupport(self):
+        x = 1
+        d = sys._getframe().f_locals
+        with self.assertRaises(TypeError):
+            copy.copy(d)
+
+        with self.assertRaises(TypeError):
+            copy.deepcopy(d)
+
+    def test_is_mapping(self):
+        x = 1
+        d = sys._getframe().f_locals
+        self.assertIsInstance(d, Mapping)
+        match d:
+            case {"x": value}:
+                self.assertEqual(value, 1)
+                kind = "mapping"
+            case _:
+                kind = "other"
+        self.assertEqual(kind, "mapping")
+
+    def _x_stringlikes(self):
+        class StringSubclass(str):
+            pass
+
+        class ImpostorX:
+            def __hash__(self):
+                return hash('x')
+
+            def __eq__(self, other):
+                return other == 'x'
+
+        return StringSubclass('x'), ImpostorX(), 'x'
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AssertionError: dict_keys(['obj', 'x']) != ['obj', 'x', 'proxy']
+    def test_proxy_key_stringlikes_overwrite(self):
+        def f(obj):
+            x = 1
+            proxy = sys._getframe().f_locals
+            proxy[obj] = 2
+            return (
+                list(proxy.keys()),
+                dict(proxy),
+                proxy
+            )
+
+        for obj in self._x_stringlikes():
+            with self.subTest(cls=type(obj).__name__):
+
+                keys_snapshot, proxy_snapshot, proxy = f(obj)
+                expected_keys = ['obj', 'x', 'proxy']
+                expected_dict = {'obj': 'x', 'x': 2, 'proxy': proxy}
+                self.assertEqual(proxy.keys(),  expected_keys)
+                self.assertEqual(proxy, expected_dict)
+                self.assertEqual(keys_snapshot,  expected_keys)
+                self.assertEqual(proxy_snapshot, expected_dict)
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; UnboundLocalError: local variable 'b' referenced before assignment
+    def test_proxy_key_stringlikes_ftrst_write(self):
+        def f(obj):
+            proxy = sys._getframe().f_locals
+            proxy[obj] = 2
+            self.assertEqual(x, 2)
+            x = 1
+
+        for obj in self._x_stringlikes():
+            with self.subTest(cls=type(obj).__name__):
+                f(obj)
+
+    def test_proxy_key_unhashables(self):
+        class StringSubclass(str):
+            __hash__ = None
+
+        class ObjectSubclass:
+            __hash__ = None
+
+        proxy = sys._getframe().f_locals
+
+        for obj in StringSubclass('x'), ObjectSubclass():
+            with self.subTest(cls=type(obj).__name__):
+                with self.assertRaises(TypeError):
+                    proxy[obj]
+                with self.assertRaises(TypeError):
+                    proxy[obj] = 0
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AssertionError: 'dict' != 'FrameLocalsProxy'
+    def test_constructor(self):
+        FrameLocalsProxy = type([sys._getframe().f_locals
+                                 for x in range(1)][0])
+        self.assertEqual(FrameLocalsProxy.__name__, 'FrameLocalsProxy')
+
+        def make_frame():
+            x = 1
+            y = 2
+            return sys._getframe()
+
+        proxy = FrameLocalsProxy(make_frame())
+        self.assertEqual(proxy, {'x': 1, 'y': 2})
+
+        # constructor expects 1 frame argument
+        with self.assertRaises(TypeError):
+            FrameLocalsProxy()     # no arguments
+        with self.assertRaises(TypeError):
+            FrameLocalsProxy(123)  # wrong type
+        with self.assertRaises(TypeError):
+            FrameLocalsProxy(frame=sys._getframe())  # no keyword arguments
+
+    def test_overwrite_locals(self):
+        # Verify we do not crash if we overwrite a local passed as an argument
+        # from an ancestor in the call stack.
+        def f():
+            xs = [1, 2, 3]
+            ys = [4, 5, 6]
+            return g(xs)
+
+        def g(xs):
+            f = sys._getframe()
+            f.f_back.f_locals["xs"] = None
+            f.f_back.f_locals["ys"] = None
+            return xs[1]
+
+        self.assertEqual(f(), 2)
+
+
+class FrameLocalsProxyMappingTests(mapping_tests.TestHashMappingProtocol):
+    """Test that FrameLocalsProxy behaves like a Mapping (with exceptions)"""
+
+    def _f(*args, **kwargs):
+        def _f():
+            return sys._getframe().f_locals
+        return _f()
+    type2test = _f
+
+    @unittest.skipIf(True, 'Locals proxies for different frames never compare as equal')
+    def test_constructor(self):
+        pass
+
+    @unittest.skipIf(True, 'Unlike a mapping: del proxy[key] fails')
+    def test_write(self):
+        pass
+
+    @unittest.skipIf(True, 'Unlike a mapping: no proxy.popitem')
+    def test_popitem(self):
+        pass
+
+    @unittest.skipIf(True, 'Unlike a mapping: no proxy.pop')
+    def test_pop(self):
+        pass
+
+    @unittest.skipIf(True, 'Unlike a mapping: no proxy.clear')
+    def test_clear(self):
+        pass
+
+    @unittest.skipIf(True, 'Unlike a mapping: no proxy.fromkeys')
+    def test_fromkeys(self):
+        pass
+
+    # no del
+    def test_getitem(self):
+        mapping_tests.BasicTestMappingProtocol.test_getitem(self)
+        d = self._full_mapping({'a': 1, 'b': 2})
+        self.assertEqual(d['a'], 1)
+        self.assertEqual(d['b'], 2)
+        d['c'] = 3
+        d['a'] = 4
+        self.assertEqual(d['c'], 3)
+        self.assertEqual(d['a'], 4)
+
+    @unittest.skipIf(True, 'Unlike a mapping: no proxy.update')
+    def test_update(self):
+        pass
+
+    # proxy.copy returns a regular dict
+    def test_copy(self):
+        d = self._full_mapping({1:1, 2:2, 3:3})
+        self.assertEqual(d.copy(), {1:1, 2:2, 3:3})
+        d = self._empty_mapping()
+        self.assertEqual(d.copy(), d)
+        self.assertRaises(TypeError, d.copy, None)
+
+        self.assertIsInstance(d.copy(), dict)
+
+    @unittest.skipIf(True, 'Locals proxies for different frames never compare as equal')
+    def test_eq(self):
+        pass
+
+
+class TestFrameCApi(unittest.TestCase):
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    def test_basic(self):
+        x = 1
+        ctypes = import_helper.import_module('ctypes')
+        PyEval_GetFrameLocals = ctypes.pythonapi.PyEval_GetFrameLocals
+        PyEval_GetFrameLocals.restype = ctypes.py_object
+        frame_locals = PyEval_GetFrameLocals()
+        self.assertTrue(type(frame_locals), dict)
+        self.assertEqual(frame_locals['x'], 1)
+        frame_locals['x'] = 2
+        self.assertEqual(x, 1)
+
+        PyEval_GetFrameGlobals = ctypes.pythonapi.PyEval_GetFrameGlobals
+        PyEval_GetFrameGlobals.restype = ctypes.py_object
+        frame_globals = PyEval_GetFrameGlobals()
+        self.assertTrue(type(frame_globals), dict)
+        self.assertIs(frame_globals, globals())
+
+        PyEval_GetFrameBuiltins = ctypes.pythonapi.PyEval_GetFrameBuiltins
+        PyEval_GetFrameBuiltins.restype = ctypes.py_object
+        frame_builtins = PyEval_GetFrameBuiltins()
+        self.assertEqual(frame_builtins, __builtins__)
+
+        PyFrame_GetLocals = ctypes.pythonapi.PyFrame_GetLocals
+        PyFrame_GetLocals.argtypes = [ctypes.py_object]
+        PyFrame_GetLocals.restype = ctypes.py_object
+        frame = sys._getframe()
+        f_locals = PyFrame_GetLocals(frame)
+        self.assertTrue(f_locals['x'], 1)
+        f_locals['x'] = 2
+        self.assertEqual(x, 2)
+
+
+class TestIncompleteFrameAreInvisible(unittest.TestCase):
+
+    def test_issue95818(self):
+        # See GH-95818 for details
+        code = textwrap.dedent(f"""
+            import gc
+
+            gc.set_threshold(1,1,1)
+            class GCHello:
+                def __del__(self):
+                    print("Destroyed from gc")
+
+            def gen():
+                yield
+
+            fd = open({__file__!r})
+            l = [fd, GCHello()]
+            l.append(l)
+            del fd
+            del l
+            gen()
+        """)
+        assert_python_ok("-c", code)
+
+    @support.cpython_only
+    @threading_helper.requires_working_threading()
+    def test_sneaky_frame_object_teardown(self):
+
+        class SneakyDel:
+            def __del__(self):
+                """
+                Stash a reference to the entire stack for walking later.
+
+                It may look crazy, but you'd be surprised how common this is
+                when using a test runner (like pytest). The typical recipe is:
+                ResourceWarning + -Werror + a custom sys.unraisablehook.
+                """
+                nonlocal sneaky_frame_object
+                sneaky_frame_object = sys._getframe()
+
+        class SneakyThread(threading.Thread):
+            """
+            A separate thread isn't needed to make this code crash, but it does
+            make crashes more consistent, since it means sneaky_frame_object is
+            backed by freed memory after the thread completes!
+            """
+
+            def run(self):
+                """Run SneakyDel.__del__ as this frame is popped."""
+                ref = SneakyDel()
+
+        sneaky_frame_object = None
+        t = SneakyThread()
+        t.start()
+        t.join()
+        # sneaky_frame_object can be anything, really, but it's crucial that
+        # SneakyThread.run's frame isn't anywhere on the stack while it's being
+        # torn down:
+        self.assertIsNotNone(sneaky_frame_object)
+        while sneaky_frame_object is not None:
+            self.assertIsNot(
+                sneaky_frame_object.f_code, SneakyThread.run.__code__
+            )
+            sneaky_frame_object = sneaky_frame_object.f_back
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AttributeError: 'NoneType' object has no attribute 'exc_type'
+    def test_entry_frames_are_invisible_during_teardown(self):
+        class C:
+            """A weakref'able class."""
+
+        def f():
+            """Try to find globals and locals as this frame is being cleared."""
+            ref = C()
+            # Ignore the fact that exec(C()) is a nonsense callback. We're only
+            # using exec here because it tries to access the current frame's
+            # globals and locals. If it's trying to get those from a shim frame,
+            # we'll crash before raising:
+            return weakref.ref(ref, exec)
+
+        with support.catch_unraisable_exception() as catcher:
+            # Call from C, so there is a shim frame directly above f:
+            weak = operator.call(f)  # BOOM!
+            # Cool, we didn't crash. Check that the callback actually happened:
+            self.assertIs(catcher.unraisable.exc_type, TypeError)
+        self.assertIsNone(weak())
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/Lib/test/test_frozen.py b/Lib/test/test_frozen.py
new file mode 100644
index 00000000000..0b4a12bcf40
--- /dev/null
+++ b/Lib/test/test_frozen.py
@@ -0,0 +1,56 @@
+"""Basic test of the frozen module (source is in Python/frozen.c)."""
+
+# The Python/frozen.c source code contains a marshalled Python module
+# and therefore depends on the marshal format as well as the bytecode
+# format.  If those formats have been changed then frozen.c needs to be
+# updated.
+#
+# The test_importlib also tests this module but because those tests
+# are much more complicated, it might be unclear why they are failing.
+# Invalid marshalled data in frozen.c could case the interpreter to
+# crash when __hello__ is imported.
+
+import importlib.machinery
+import sys
+import unittest
+from test.support import captured_stdout, import_helper
+
+
+class TestFrozen(unittest.TestCase):
+    def test_frozen(self):
+        name = '__hello__'
+        if name in sys.modules:
+            del sys.modules[name]
+        with import_helper.frozen_modules():
+            import __hello__
+        with captured_stdout() as out:
+            __hello__.main()
+        self.assertEqual(out.getvalue(), 'Hello world!\n')
+
+    def test_frozen_submodule_in_unfrozen_package(self):
+        with import_helper.CleanImport('__phello__', '__phello__.spam'):
+            with import_helper.frozen_modules(enabled=False):
+                import __phello__
+            with import_helper.frozen_modules(enabled=True):
+                import __phello__.spam as spam
+        self.assertIs(spam, __phello__.spam)
+        self.assertIsNot(__phello__.__spec__.loader,
+                         importlib.machinery.FrozenImporter)
+        self.assertIs(spam.__spec__.loader,
+                      importlib.machinery.FrozenImporter)
+
+    def test_unfrozen_submodule_in_frozen_package(self):
+        with import_helper.CleanImport('__phello__', '__phello__.spam'):
+            with import_helper.frozen_modules(enabled=True):
+                import __phello__
+            with import_helper.frozen_modules(enabled=False):
+                import __phello__.spam as spam
+        self.assertIs(spam, __phello__.spam)
+        self.assertIs(__phello__.__spec__.loader,
+                      importlib.machinery.FrozenImporter)
+        self.assertIsNot(spam.__spec__.loader,
+                         importlib.machinery.FrozenImporter)
+
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/Lib/test/test_fstring.py b/Lib/test/test_fstring.py
index 930e409fb2e..f4fca1caec7 100644
--- a/Lib/test/test_fstring.py
+++ b/Lib/test/test_fstring.py
@@ -383,7 +383,7 @@ def test_ast_line_numbers_multiline_fstring(self):
         self.assertEqual(t.body[0].value.values[1].value.col_offset, 11)
         self.assertEqual(t.body[0].value.values[1].value.end_col_offset, 16)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AssertionError: 4 != 5
     def test_ast_line_numbers_with_parentheses(self):
         expr = """
 x = (
@@ -587,7 +587,6 @@ def test_ast_compile_time_concat(self):
         exec(c)
         self.assertEqual(x[0], 'foo3')
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_compile_time_concat_errors(self):
         self.assertAllRaise(SyntaxError,
                             'cannot mix bytes and nonbytes literals',
@@ -600,7 +599,6 @@ def test_literal(self):
         self.assertEqual(f'a', 'a')
         self.assertEqual(f' ', ' ')
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_unterminated_string(self):
         self.assertAllRaise(SyntaxError, 'unterminated string',
                             [r"""f'{"x'""",
@@ -609,7 +607,7 @@ def test_unterminated_string(self):
                              r"""f'{("x}'""",
                              ])
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     @unittest.skipIf(support.is_wasi, "exhausts limited stack on WASI")
     def test_mismatched_parens(self):
         self.assertAllRaise(SyntaxError, r"closing parenthesis '\}' "
@@ -632,14 +630,24 @@ def test_mismatched_parens(self):
                             r"does not match opening parenthesis '\('",
                             ["f'{a(4}'",
                             ])
-        self.assertRaises(SyntaxError, eval, "f'{" + "("*500 + "}'")
+        self.assertRaises(SyntaxError, eval, "f'{" + "("*20 + "}'")
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AssertionError: No exception raised
     @unittest.skipIf(support.is_wasi, "exhausts limited stack on WASI")
     def test_fstring_nested_too_deeply(self):
-        self.assertAllRaise(SyntaxError,
-                            "f-string: expressions nested too deeply",
-                            ['f"{1+2:{1+2:{1+1:{1}}}}"'])
+        def raises_syntax_or_memory_error(txt):
+            try:
+                eval(txt)
+            except SyntaxError:
+                pass
+            except MemoryError:
+                pass
+            except Exception as ex:
+                self.fail(f"Should raise SyntaxError or MemoryError, not {type(ex)}")
+            else:
+                self.fail("No exception raised")
+
+        raises_syntax_or_memory_error('f"{1+2:{1+2:{1+1:{1}}}}"')
 
         def create_nested_fstring(n):
             if n == 0:
@@ -647,9 +655,10 @@ def create_nested_fstring(n):
             prev = create_nested_fstring(n-1)
             return f'f"{{{prev}}}"'
 
-        self.assertAllRaise(SyntaxError,
-                            "too many nested f-strings",
-                            [create_nested_fstring(160)])
+        raises_syntax_or_memory_error(create_nested_fstring(160))
+        raises_syntax_or_memory_error("f'{" + "("*100 + "}'")
+        raises_syntax_or_memory_error("f'{" + "("*1000 + "}'")
+        raises_syntax_or_memory_error("f'{" + "("*10_000 + "}'")
 
     def test_syntax_error_in_nested_fstring(self):
         # See gh-104016 for more information on this crash
@@ -692,7 +701,7 @@ def test_double_braces(self):
                             ["f'{ {{}} }'", # dict in a set
                              ])
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_compile_time_concat(self):
         x = 'def'
         self.assertEqual('abc' f'## {x}ghi', 'abc## defghi')
@@ -730,7 +739,7 @@ def test_compile_time_concat(self):
                             ['''f'{3' f"}"''',  # can't concat to get a valid f-string
                              ])
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_comments(self):
         # These aren't comments, since they're in strings.
         d = {'#': 'hash'}
@@ -807,7 +816,7 @@ def build_fstr(n, extra=''):
         s = "f'{1}' 'x' 'y'" * 1024
         self.assertEqual(eval(s), '1xy' * 1024)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_format_specifier_expressions(self):
         width = 10
         precision = 4
@@ -841,7 +850,6 @@ def test_format_specifier_expressions(self):
                              """f'{"s"!{"r"}}'""",
                              ])
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_custom_format_specifier(self):
         class CustomFormat:
             def __format__(self, format_spec):
@@ -863,7 +871,7 @@ def __format__(self, spec):
         x = X()
         self.assertEqual(f'{x} {x}', '1 2')
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_missing_expression(self):
         self.assertAllRaise(SyntaxError,
                             "f-string: valid expression required before '}'",
@@ -926,7 +934,7 @@ def test_missing_expression(self):
                              "\xa0",
                              ])
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_parens_in_expressions(self):
         self.assertEqual(f'{3,}', '(3,)')
 
@@ -939,13 +947,12 @@ def test_parens_in_expressions(self):
                             ["f'{3)+(4}'",
                              ])
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_newlines_before_syntax_error(self):
         self.assertAllRaise(SyntaxError,
                             "f-string: expecting a valid expression after '{'",
                 ["f'{.}'", "\nf'{.}'", "\n\nf'{.}'"])
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_backslashes_in_string_part(self):
         self.assertEqual(f'\t', '\t')
         self.assertEqual(r'\t', '\\t')
@@ -1004,7 +1011,7 @@ def test_backslashes_in_string_part(self):
         self.assertEqual(fr'\N{AMPERSAND}', '\\Nspam')
         self.assertEqual(f'\\\N{AMPERSAND}', '\\&')
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_misformed_unicode_character_name(self):
         # These test are needed because unicode names are parsed
         # differently inside f-strings.
@@ -1024,7 +1031,7 @@ def test_misformed_unicode_character_name(self):
                              r"'\N{GREEK CAPITAL LETTER DELTA'",
                              ])
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_backslashes_in_expression_part(self):
         self.assertEqual(f"{(
                         1 +
@@ -1040,7 +1047,6 @@ def test_backslashes_in_expression_part(self):
                             ["f'{\n}'",
                              ])
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_invalid_backslashes_inside_fstring_context(self):
         # All of these variations are invalid python syntax,
         # so they are also invalid in f-strings as well.
@@ -1075,7 +1081,7 @@ def test_newlines_in_expressions(self):
         self.assertEqual(rf'''{3+
 4}''', '7')
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AssertionError: "f-string: expecting a valid expression after '{'" does not match "invalid syntax (<string>, line 1)"
     def test_lambda(self):
         x = 5
         self.assertEqual(f'{(lambda y:x*y)("8")!r}', "'88888'")
@@ -1118,7 +1124,6 @@ def test_roundtrip_raw_quotes(self):
         self.assertEqual(fr'\'\"\'', '\\\'\\"\\\'')
         self.assertEqual(fr'\"\'\"\'', '\\"\\\'\\"\\\'')
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_fstring_backslash_before_double_bracket(self):
         deprecated_cases = [
             (r"f'\{{\}}'",   '\\{\\}'),
@@ -1138,7 +1143,6 @@ def test_fstring_backslash_before_double_bracket(self):
         self.assertEqual(fr'\}}{1+1}', '\\}2')
         self.assertEqual(fr'{1+1}\}}', '2\\}')
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_fstring_backslash_before_double_bracket_warns_once(self):
         with self.assertWarns(SyntaxWarning) as w:
             eval(r"f'\{{'")
@@ -1288,6 +1292,7 @@ def test_nested_fstrings(self):
         self.assertEqual(f'{f"{0}"*3}', '000')
         self.assertEqual(f'{f"{y}"*3}', '555')
 
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_invalid_string_prefixes(self):
         single_quote_cases = ["fu''",
                              "uf''",
@@ -1312,7 +1317,7 @@ def test_invalid_string_prefixes(self):
                              "Bf''",
                              "BF''",]
         double_quote_cases = [case.replace("'", '"') for case in single_quote_cases]
-        self.assertAllRaise(SyntaxError, 'invalid syntax',
+        self.assertAllRaise(SyntaxError, 'prefixes are incompatible',
                             single_quote_cases + double_quote_cases)
 
     def test_leading_trailing_spaces(self):
@@ -1342,7 +1347,7 @@ def test_equal_equal(self):
 
         self.assertEqual(f'{0==1}', 'False')
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_conversions(self):
         self.assertEqual(f'{3.14:10.10}', '      3.14')
         self.assertEqual(f'{1.25!s:10.10}', '1.25      ')
@@ -1367,7 +1372,6 @@ def test_conversions(self):
         self.assertAllRaise(SyntaxError, "f-string: expecting '}'",
                             ["f'{3!'",
                              "f'{3!s'",
-                             "f'{3!g'",
                              ])
 
         self.assertAllRaise(SyntaxError, 'f-string: missing conversion character',
@@ -1408,14 +1412,13 @@ def test_assignment(self):
                              "f'{x}' = x",
                              ])
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_del(self):
         self.assertAllRaise(SyntaxError, 'invalid syntax',
                             ["del f''",
                              "del '' f''",
                              ])
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_mismatched_braces(self):
         self.assertAllRaise(SyntaxError, "f-string: single '}' is not allowed",
                             ["f'{{}'",
@@ -1514,7 +1517,6 @@ def test_str_format_differences(self):
         self.assertEqual('{d[a]}'.format(d=d), 'string')
         self.assertEqual('{d[0]}'.format(d=d), 'integer')
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_errors(self):
         # see issue 26287
         self.assertAllRaise(TypeError, 'unsupported',
@@ -1557,7 +1559,6 @@ def test_backslash_char(self):
         self.assertEqual(eval('f"\\\n"'), '')
         self.assertEqual(eval('f"\\\r"'), '')
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON; AssertionError: '1+2 = # my comment\n  3' != '1+2 = \n  3'
     def test_debug_conversion(self):
         x = 'A string'
         self.assertEqual(f'{x=}', 'x=' + repr(x))
@@ -1705,7 +1706,7 @@ def test_walrus(self):
         self.assertEqual(f'{(x:=10)}', '10')
         self.assertEqual(x, 10)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AssertionError: "f-string: expecting '=', or '!', or ':', or '}'" does not match "invalid syntax (?, line 1)"
     def test_invalid_syntax_error_message(self):
         with self.assertRaisesRegex(SyntaxError,
                                     "f-string: expecting '=', or '!', or ':', or '}'"):
@@ -1731,7 +1732,7 @@ def test_with_an_underscore_and_a_comma_in_format_specifier(self):
         with self.assertRaisesRegex(ValueError, error_msg):
             f'{1:_,}'
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AssertionError: "f-string: expecting a valid expression after '{'" does not match "invalid syntax (?, line 1)"
     def test_syntax_error_for_starred_expressions(self):
         with self.assertRaisesRegex(SyntaxError, "can't use starred expression here"):
             compile("f'{*a}'", "?", "exec")
@@ -1740,7 +1741,7 @@ def test_syntax_error_for_starred_expressions(self):
                                     "f-string: expecting a valid expression after '{'"):
             compile("f'{**a}'", "?", "exec")
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; -
     def test_not_closing_quotes(self):
         self.assertAllRaise(SyntaxError, "unterminated f-string literal", ['f"', "f'"])
         self.assertAllRaise(SyntaxError, "unterminated triple-quoted f-string literal",
@@ -1760,7 +1761,7 @@ def test_not_closing_quotes(self):
         except SyntaxError as e:
             self.assertEqual(e.text, 'z = f"""')
             self.assertEqual(e.lineno, 3)
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_syntax_error_after_debug(self):
         self.assertAllRaise(SyntaxError, "f-string: expecting a valid expression after '{'",
                             [
@@ -1788,7 +1789,6 @@ def test_debug_in_file(self):
         self.assertEqual(stdout.decode('utf-8').strip().replace('\r\n', '\n').replace('\r', '\n'),
                          "3\n=3")
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_syntax_warning_infinite_recursion_in_file(self):
         with temp_cwd():
             script = 'script.py'
@@ -1878,6 +1878,13 @@ def __format__(self, format):
         # Test multiple format specs in same raw f-string
         self.assertEqual(rf"{UnchangedFormat():\xFF} {UnchangedFormat():\n}", '\\xFF \\n')
 
+    def test_gh139516(self):
+        with temp_cwd():
+            script = 'script.py'
+            with open(script, 'wb') as f:
+                f.write('''def f(a): pass\nf"{f(a=lambda: 'à'\n)}"'''.encode())
+            assert_python_ok(script)
+
 
 if __name__ == '__main__':
     unittest.main()
diff --git a/Lib/test/test_ftplib.py b/Lib/test/test_ftplib.py
index 684f5d438b3..c864d401f9e 100644
--- a/Lib/test/test_ftplib.py
+++ b/Lib/test/test_ftplib.py
@@ -903,7 +903,6 @@ def retr():
         retr()
 
 
-@unittest.skip("TODO: RUSTPYTHON; SSL + asyncore has problem")
 @skipUnless(ssl, "SSL not available")
 @requires_subprocess()
 class TestTLS_FTPClassMixin(TestFTPClass):
@@ -922,7 +921,6 @@ def setUp(self, encoding=DEFAULT_ENCODING):
 
 
 @skipUnless(ssl, "SSL not available")
-@unittest.skip("TODO: RUSTPYTHON; SSL + asyncore has problem")
 @requires_subprocess()
 class TestTLS_FTPClass(TestCase):
     """Specific TLS_FTP class tests."""
@@ -971,7 +969,6 @@ 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)
@@ -984,7 +981,6 @@ 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)
diff --git a/Lib/test/test_funcattrs.py b/Lib/test/test_funcattrs.py
index e06e9f7f4a9..f245213418e 100644
--- a/Lib/test/test_funcattrs.py
+++ b/Lib/test/test_funcattrs.py
@@ -1,6 +1,9 @@
 import textwrap
 import types
+import typing
 import unittest
+import warnings
+from test import support
 
 
 def global_function():
@@ -47,8 +50,7 @@ class FunctionPropertiesTest(FuncAttrsTest):
     def test_module(self):
         self.assertEqual(self.b.__module__, __name__)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_dir_includes_correct_attrs(self):
         self.b.known_attr = 7
         self.assertIn('known_attr', dir(self.b),
@@ -71,15 +73,40 @@ def test(): pass
         test.__code__ = self.b.__code__
         self.assertEqual(test(), 3) # self.b always returns 3, arbitrarily
 
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AssertionError: DeprecationWarning not triggered
+    def test_invalid___code___assignment(self):
+        def A(): pass
+        def B(): yield
+        async def C(): yield
+        async def D(x): await x
+
+        for src in [A, B, C, D]:
+            for dst in [A, B, C, D]:
+                if src == dst:
+                    continue
+
+                assert src.__code__.co_flags != dst.__code__.co_flags
+                prev = dst.__code__
+                try:
+                    with self.assertWarnsRegex(DeprecationWarning, 'code object of non-matching type'):
+                        dst.__code__ = src.__code__
+                finally:
+                    with warnings.catch_warnings():
+                        warnings.filterwarnings('ignore', '', DeprecationWarning)
+                        dst.__code__ = prev
+
     def test___globals__(self):
         self.assertIs(self.b.__globals__, globals())
         self.cannot_set_attr(self.b, '__globals__', 2,
                              (AttributeError, TypeError))
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test___builtins__(self):
-        self.assertIs(self.b.__builtins__, __builtins__)
+        if __name__ == "__main__":
+            builtins_dict = __builtins__.__dict__
+        else:
+            builtins_dict = __builtins__
+
+        self.assertIs(self.b.__builtins__, builtins_dict)
         self.cannot_set_attr(self.b, '__builtins__', 2,
                              (AttributeError, TypeError))
 
@@ -89,7 +116,7 @@ def func(s): return len(s)
         ns = {}
         func2 = type(func)(func.__code__, ns)
         self.assertIs(func2.__globals__, ns)
-        self.assertIs(func2.__builtins__, __builtins__)
+        self.assertIs(func2.__builtins__, builtins_dict)
 
         # Make sure that the function actually works.
         self.assertEqual(func2("abc"), 3)
@@ -194,8 +221,24 @@ def test___qualname__(self):
         # __qualname__ must be a string
         self.cannot_set_attr(self.b, '__qualname__', 7, TypeError)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    def test___type_params__(self):
+        def generic[T](): pass
+        def not_generic(): pass
+        lambda_ = lambda: ...
+        T, = generic.__type_params__
+        self.assertIsInstance(T, typing.TypeVar)
+        self.assertEqual(generic.__type_params__, (T,))
+        for func in (not_generic, lambda_):
+            with self.subTest(func=func):
+                self.assertEqual(func.__type_params__, ())
+                with self.assertRaises(TypeError):
+                    del func.__type_params__
+                with self.assertRaises(TypeError):
+                    func.__type_params__ = 42
+                func.__type_params__ = (T,)
+                self.assertEqual(func.__type_params__, (T,))
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test___code__(self):
         num_one, num_two = 7, 8
         def a(): pass
@@ -226,15 +269,13 @@ def e(): return num_one, num_two
             self.fail("__code__ with different numbers of free vars should "
                       "not be possible")
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_blank_func_defaults(self):
         self.assertEqual(self.b.__defaults__, None)
         del self.b.__defaults__
         self.assertEqual(self.b.__defaults__, None)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_func_default_args(self):
         def first_func(a, b):
             return a+b
@@ -395,8 +436,7 @@ def f():
 
 
 class CellTest(unittest.TestCase):
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_comparison(self):
         # These tests are here simply to exercise the comparison code;
         # their presence should not be interpreted as providing any
@@ -445,6 +485,33 @@ def test_builtin__qualname__(self):
         self.assertEqual([1, 2, 3].append.__qualname__, 'list.append')
         self.assertEqual({'foo': 'bar'}.pop.__qualname__, 'dict.pop')
 
+    @support.cpython_only
+    def test_builtin__self__(self):
+        # See https://github.com/python/cpython/issues/58211.
+        import builtins
+        import time
+
+        # builtin function:
+        self.assertIs(len.__self__, builtins)
+        self.assertIs(time.sleep.__self__, time)
+
+        # builtin classmethod:
+        self.assertIs(dict.fromkeys.__self__, dict)
+        self.assertIs(float.__getformat__.__self__, float)
+
+        # builtin staticmethod:
+        self.assertIsNone(str.maketrans.__self__)
+        self.assertIsNone(bytes.maketrans.__self__)
+
+        # builtin bound instance method:
+        l = [1, 2, 3]
+        self.assertIs(l.append.__self__, l)
+
+        d = {'foo': 'bar'}
+        self.assertEqual(d.pop.__self__, d)
+
+        self.assertIsNone(None.__repr__.__self__)
+
 
 if __name__ == "__main__":
     unittest.main()
diff --git a/Lib/test/test_functools.py b/Lib/test/test_functools.py
index 9ab0c8917e8..c5218be0673 100644
--- a/Lib/test/test_functools.py
+++ b/Lib/test/test_functools.py
@@ -438,6 +438,7 @@ def test_setstate_subclasses(self):
         self.assertIs(type(r[0]), tuple)
 
     @support.skip_if_sanitizer("thread sanitizer crashes in __tsan::FuncEntry", thread=True)
+    @support.skip_if_unlimited_stack_size
     @support.skip_emscripten_stack_overflow()
     def test_recursive_pickle(self):
         with replaced_module('functools', self.module):
@@ -1192,35 +1193,35 @@ def test_disallow_instantiation(self):
             self, type(c_functools.cmp_to_key(None))
         )
 
-    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; + (mycmp)
+    def test_cmp_to_signature(self):
+        return super().test_cmp_to_signature()
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; TypeError: cmp_to_key() got multiple values for argument 'mycmp'
+    def test_cmp_to_key_arguments(self):
+        return super().test_cmp_to_key_arguments()
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; TypeError: cmp_to_key() got multiple values for argument 'mycmp'
+    def test_obj_field(self):
+        return super().test_obj_field()
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; TypeError: cmp_to_key() takes 1 positional argument but 2 were given
     def test_bad_cmp(self):
         return super().test_bad_cmp()
 
-    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; TypeError: cmp_to_key() takes 1 positional argument but 2 were given
     def test_cmp_to_key(self):
         return super().test_cmp_to_key()
 
-    @unittest.expectedFailure  # TODO: RUSTPYTHON
-    def test_cmp_to_key_arguments(self):
-        return super().test_cmp_to_key_arguments()
-
-    @unittest.expectedFailure  # TODO: RUSTPYTHON
-    def test_cmp_to_signature(self):
-        return super().test_cmp_to_signature()
-
-    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; TypeError: cmp_to_key() takes 1 positional argument but 2 were given
     def test_hash(self):
         return super().test_hash()
 
-    @unittest.expectedFailure  # TODO: RUSTPYTHON
-    def test_obj_field(self):
-        return super().test_obj_field()
-
-    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; TypeError: cmp_to_key() takes 1 positional argument but 2 were given
     def test_sort_int(self):
         return super().test_sort_int()
 
-    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; TypeError: cmp_to_key() takes 1 positional argument but 2 were given
     def test_sort_int_str(self):
         return super().test_sort_int_str()
 
@@ -2104,7 +2105,6 @@ 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):
@@ -2173,6 +2173,7 @@ def orig(a: int) -> nonexistent: ...
     @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_if_unlimited_stack_size
     @support.skip_emscripten_stack_overflow()
     def test_lru_recursion(self):
 
@@ -3480,16 +3481,11 @@ def _(item: int, arg: bytes) -> str:
 
     def test_method_signatures(self):
         class A:
-            def m(self, item, arg: int) -> str:
-                return str(item)
-            @classmethod
-            def cm(cls, item, arg: int) -> str:
-                return str(item)
             @functools.singledispatchmethod
             def func(self, item, arg: int) -> str:
                 return str(item)
             @func.register
-            def _(self, item, arg: bytes) -> str:
+            def _(self, item: int, arg: bytes) -> str:
                 return str(item)
 
             @functools.singledispatchmethod
@@ -3498,7 +3494,7 @@ def cls_func(cls, item, arg: int) -> str:
                 return str(arg)
             @func.register
             @classmethod
-            def _(cls, item, arg: bytes) -> str:
+            def _(cls, item: int, arg: bytes) -> str:
                 return str(item)
 
             @functools.singledispatchmethod
@@ -3507,7 +3503,7 @@ def static_func(item, arg: int) -> str:
                 return str(arg)
             @func.register
             @staticmethod
-            def _(item, arg: bytes) -> str:
+            def _(item: int, arg: bytes) -> str:
                 return str(item)
 
         self.assertEqual(str(Signature.from_callable(A.func)),
@@ -3592,7 +3588,6 @@ class MyClass(metaclass=MyMeta):
         ):
             MyClass.prop
 
-    @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:
diff --git a/Lib/test/test_future_stmt/nested_scope.py b/Lib/test/test_future_stmt/nested_scope.py
index 3d7fc860a37..a8433a42cbb 100644
--- a/Lib/test/test_future_stmt/nested_scope.py
+++ b/Lib/test/test_future_stmt/nested_scope.py
@@ -1,6 +1,6 @@
 """This is a test"""
 
-from __future__ import nested_scopes; import site
+from __future__ import nested_scopes; import site  # noqa: F401
 
 def f(x):
     def g(y):
diff --git a/Lib/test/test_future_stmt/test_future.py b/Lib/test/test_future_stmt/test_future.py
index e57c7227cec..faa5f4cc683 100644
--- a/Lib/test/test_future_stmt/test_future.py
+++ b/Lib/test/test_future_stmt/test_future.py
@@ -67,23 +67,21 @@ def test_future_single_import(self):
         with import_helper.CleanImport(
             'test.test_future_stmt.test_future_single_import',
         ):
-            from test.test_future_stmt import test_future_single_import
+            from test.test_future_stmt import test_future_single_import  # noqa: F401
 
     def test_future_multiple_imports(self):
         with import_helper.CleanImport(
             'test.test_future_stmt.test_future_multiple_imports',
         ):
-            from test.test_future_stmt import test_future_multiple_imports
+            from test.test_future_stmt import test_future_multiple_imports  # noqa: F401
 
     def test_future_multiple_features(self):
         with import_helper.CleanImport(
             "test.test_future_stmt.test_future_multiple_features",
         ):
-            from test.test_future_stmt import test_future_multiple_features
+            from test.test_future_stmt import test_future_multiple_features  # noqa: F401
 
-    # TODO: RUSTPYTHON
-    # AssertionError: 1 != 24
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AssertionError: 1 != 24
     def test_unknown_future_flag(self):
         code = """
             from __future__ import nested_scopes
@@ -114,9 +112,7 @@ def test_future_import_not_on_top(self):
         """
         self.assertSyntaxError(code, lineno=3)
 
-    # TODO: RUSTPYTHON
-    # AssertionError: SyntaxError not raised
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AssertionError: SyntaxError not raised
     def test_future_import_with_extra_string(self):
         code = """
             '''Docstring'''
@@ -139,18 +135,14 @@ def test_multiple_import_statements_on_same_line(self):
         """
         self.assertSyntaxError(code, offset=54)
 
-    # TODO: RUSTPYTHON
-    # AssertionError: 1 != 24
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AssertionError: 1 != 24
     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
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_future_import_braces(self):
         code = """
             from __future__ import braces
@@ -165,7 +157,7 @@ def test_future_import_braces(self):
 
     def test_module_with_future_import_not_on_top(self):
         with self.assertRaises(SyntaxError) as cm:
-            from test.test_future_stmt import badsyntax_future
+            from test.test_future_stmt import badsyntax_future  # noqa: F401
         self.check_syntax_error(cm.exception, "badsyntax_future", lineno=3)
 
     def test_ensure_flags_dont_clash(self):
@@ -188,6 +180,7 @@ def test_unicode_literals_exec(self):
         exec("from __future__ import unicode_literals; x = ''", {}, scope)
         self.assertIsInstance(scope["x"], str)
 
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; barry_as_FLUFL (<> operator) not supported
     def test_syntactical_future_repl(self):
         p = spawn_python('-i')
         p.stdin.write(b"from __future__ import barry_as_FLUFL\n")
@@ -195,8 +188,7 @@ def test_syntactical_future_repl(self):
         out = kill_python(p)
         self.assertNotIn(b'SyntaxError: invalid syntax', out)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
-    # SyntaxError: future feature spam is not defined
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_future_dotted_import(self):
         with self.assertRaises(ImportError):
             exec("from .__future__ import spam")
@@ -273,6 +265,7 @@ def _exec_future(self, code):
         )
         return scope
 
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AssertionError: "t'{a + b}'" != "t'{a    +  b}'"
     def test_annotations(self):
         eq = self.assertAnnotationEqual
         eq('...')
@@ -436,6 +429,11 @@ def test_annotations(self):
         eq('(((a)))', 'a')
         eq('(((a, b)))', '(a, b)')
         eq("1 + 2 + 3")
+        eq("t''")
+        eq("t'{a    +  b}'")
+        eq("t'{a!s}'")
+        eq("t'{a:b}'")
+        eq("t'{a:b=}'")
 
     def test_fstring_debug_annotations(self):
         # f-strings with '=' don't round trip very well, so set the expected
@@ -482,9 +480,7 @@ def bar():
         self.assertEqual(foo.__code__.co_cellvars, ())
         self.assertEqual(foo().__code__.co_freevars, ())
 
-    # TODO: RUSTPYTHON
-    # AssertionError: SyntaxError not raised
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AssertionError: SyntaxError not raised
     def test_annotations_forbidden(self):
         with self.assertRaises(SyntaxError):
             self._exec_future("test: (yield)")
diff --git a/Lib/test/test_gc.py b/Lib/test/test_gc.py
new file mode 100644
index 00000000000..879a2875aaa
--- /dev/null
+++ b/Lib/test/test_gc.py
@@ -0,0 +1,1703 @@
+import unittest
+import unittest.mock
+from test import support
+from test.support import (verbose, refcount_test,
+                          cpython_only, requires_subprocess,
+                          requires_gil_enabled,
+                          Py_GIL_DISABLED)
+from test.support.import_helper import import_module
+from test.support.os_helper import temp_dir, TESTFN, unlink
+from test.support.script_helper import assert_python_ok, make_script, run_test_script
+from test.support import threading_helper, gc_threshold
+
+import gc
+import sys
+import sysconfig
+import textwrap
+import threading
+import time
+import weakref
+
+try:
+    import _testcapi
+    from _testcapi import with_tp_del
+    from _testcapi import ContainerNoGC
+except ImportError:
+    _testcapi = None
+    def with_tp_del(cls):
+        class C(object):
+            def __new__(cls, *args, **kwargs):
+                raise unittest.SkipTest('requires _testcapi.with_tp_del')
+        return C
+    ContainerNoGC = None
+
+try:
+    import _testinternalcapi
+except ImportError:
+    _testinternalcapi = None
+
+### Support code
+###############################################################################
+
+# Bug 1055820 has several tests of longstanding bugs involving weakrefs and
+# cyclic gc.
+
+# An instance of C1055820 has a self-loop, so becomes cyclic trash when
+# unreachable.
+class C1055820(object):
+    def __init__(self, i):
+        self.i = i
+        self.loop = self
+
+class GC_Detector(object):
+    # Create an instance I.  Then gc hasn't happened again so long as
+    # I.gc_happened is false.
+
+    def __init__(self):
+        self.gc_happened = False
+
+        def it_happened(ignored):
+            self.gc_happened = True
+
+        # Create a piece of cyclic trash that triggers it_happened when
+        # gc collects it.
+        self.wr = weakref.ref(C1055820(666), it_happened)
+
+@with_tp_del
+class Uncollectable(object):
+    """Create a reference cycle with multiple __del__ methods.
+
+    An object in a reference cycle will never have zero references,
+    and so must be garbage collected.  If one or more objects in the
+    cycle have __del__ methods, the gc refuses to guess an order,
+    and leaves the cycle uncollected."""
+    def __init__(self, partner=None):
+        if partner is None:
+            self.partner = Uncollectable(partner=self)
+        else:
+            self.partner = partner
+    def __tp_del__(self):
+        pass
+
+if sysconfig.get_config_vars().get('PY_CFLAGS', ''):
+    BUILD_WITH_NDEBUG = ('-DNDEBUG' in sysconfig.get_config_vars()['PY_CFLAGS'])
+else:
+    # Usually, sys.gettotalrefcount() is only present if Python has been
+    # compiled in debug mode. If it's missing, expect that Python has
+    # been released in release mode: with NDEBUG defined.
+    BUILD_WITH_NDEBUG = (not hasattr(sys, 'gettotalrefcount'))
+
+### Tests
+###############################################################################
+
+class GCTests(unittest.TestCase):
+    def test_list(self):
+        l = []
+        l.append(l)
+        gc.collect()
+        del l
+        self.assertEqual(gc.collect(), 1)
+
+    def test_dict(self):
+        d = {}
+        d[1] = d
+        gc.collect()
+        del d
+        self.assertEqual(gc.collect(), 1)
+
+    def test_tuple(self):
+        # since tuples are immutable we close the loop with a list
+        l = []
+        t = (l,)
+        l.append(t)
+        gc.collect()
+        del t
+        del l
+        self.assertEqual(gc.collect(), 2)
+
+    def test_class(self):
+        class A:
+            pass
+        A.a = A
+        gc.collect()
+        del A
+        self.assertNotEqual(gc.collect(), 0)
+
+    def test_newstyleclass(self):
+        class A(object):
+            pass
+        gc.collect()
+        del A
+        self.assertNotEqual(gc.collect(), 0)
+
+    def test_instance(self):
+        class A:
+            pass
+        a = A()
+        a.a = a
+        gc.collect()
+        del a
+        self.assertNotEqual(gc.collect(), 0)
+
+    def test_newinstance(self):
+        class A(object):
+            pass
+        a = A()
+        a.a = a
+        gc.collect()
+        del a
+        self.assertNotEqual(gc.collect(), 0)
+        class B(list):
+            pass
+        class C(B, A):
+            pass
+        a = C()
+        a.a = a
+        gc.collect()
+        del a
+        self.assertNotEqual(gc.collect(), 0)
+        del B, C
+        self.assertNotEqual(gc.collect(), 0)
+        A.a = A()
+        del A
+        self.assertNotEqual(gc.collect(), 0)
+        self.assertEqual(gc.collect(), 0)
+
+    def test_method(self):
+        # Tricky: self.__init__ is a bound method, it references the instance.
+        class A:
+            def __init__(self):
+                self.init = self.__init__
+        a = A()
+        gc.collect()
+        del a
+        self.assertNotEqual(gc.collect(), 0)
+
+    @cpython_only
+    def test_legacy_finalizer(self):
+        # A() is uncollectable if it is part of a cycle, make sure it shows up
+        # in gc.garbage.
+        @with_tp_del
+        class A:
+            def __tp_del__(self): pass
+        class B:
+            pass
+        a = A()
+        a.a = a
+        id_a = id(a)
+        b = B()
+        b.b = b
+        gc.collect()
+        del a
+        del b
+        self.assertNotEqual(gc.collect(), 0)
+        for obj in gc.garbage:
+            if id(obj) == id_a:
+                del obj.a
+                break
+        else:
+            self.fail("didn't find obj in garbage (finalizer)")
+        gc.garbage.remove(obj)
+
+    @cpython_only
+    def test_legacy_finalizer_newclass(self):
+        # A() is uncollectable if it is part of a cycle, make sure it shows up
+        # in gc.garbage.
+        @with_tp_del
+        class A(object):
+            def __tp_del__(self): pass
+        class B(object):
+            pass
+        a = A()
+        a.a = a
+        id_a = id(a)
+        b = B()
+        b.b = b
+        gc.collect()
+        del a
+        del b
+        self.assertNotEqual(gc.collect(), 0)
+        for obj in gc.garbage:
+            if id(obj) == id_a:
+                del obj.a
+                break
+        else:
+            self.fail("didn't find obj in garbage (finalizer)")
+        gc.garbage.remove(obj)
+
+    def test_function(self):
+        # Tricky: f -> d -> f, code should call d.clear() after the exec to
+        # break the cycle.
+        d = {}
+        exec("def f(): pass\n", d)
+        gc.collect()
+        del d
+        # In the free-threaded build, the count returned by `gc.collect()`
+        # is 3 because it includes f's code object.
+        self.assertIn(gc.collect(), (2, 3))
+
+    # TODO: RUSTPYTHON - weakref clear ordering differs from 3.15+
+    @unittest.expectedFailure
+    def test_function_tp_clear_leaves_consistent_state(self):
+        # https://github.com/python/cpython/issues/91636
+        code = """if 1:
+
+        import gc
+        import weakref
+
+        class LateFin:
+            __slots__ = ('ref',)
+
+            def __del__(self):
+
+                # 8. Now `latefin`'s finalizer is called. Here we
+                #    obtain a reference to `func`, which is currently
+                #    undergoing `tp_clear`.
+                global func
+                func = self.ref()
+
+        class Cyclic(tuple):
+            __slots__ = ()
+
+            # 4. The finalizers of all garbage objects are called. In
+            #    this case this is only us as `func` doesn't have a
+            #    finalizer.
+            def __del__(self):
+
+                # 5. Create a weakref to `func` now. In previous
+                #    versions of Python, this would avoid having it
+                #    cleared by the garbage collector before calling
+                #    the finalizers.  Now, weakrefs get cleared after
+                #    calling finalizers.
+                self[1].ref = weakref.ref(self[0])
+
+                # 6. Drop the global reference to `latefin`. The only
+                #    remaining reference is the one we have.
+                global latefin
+                del latefin
+
+            # 7. Now `func` is `tp_clear`-ed. This drops the last
+            #    reference to `Cyclic`, which gets `tp_dealloc`-ed.
+            #    This drops the last reference to `latefin`.
+
+        latefin = LateFin()
+        def func():
+            pass
+        cyc = tuple.__new__(Cyclic, (func, latefin))
+
+        # 1. Create a reference cycle of `cyc` and `func`.
+        func.__module__ = cyc
+
+        # 2. Make the cycle unreachable, but keep the global reference
+        #    to `latefin` so that it isn't detected as garbage. This
+        #    way its finalizer will not be called immediately.
+        del func, cyc
+
+        # 3. Invoke garbage collection,
+        #    which will find `cyc` and `func` as garbage.
+        gc.collect()
+
+        # 9. Previously, this would crash because the weakref
+        #    created in the finalizer revealed the function after
+        #    `tp_clear` was called and `func_qualname`
+        #    had been NULL-ed out by func_clear().  Now, we clear
+        #    weakrefs to unreachable objects before calling `tp_clear`
+        #    but after calling finalizers.
+        print(f"{func=}")
+        """
+        rc, stdout, stderr = assert_python_ok("-c", code)
+        self.assertEqual(rc, 0)
+        # The `func` global is None because the weakref was cleared.
+        self.assertRegex(stdout, rb"""\A\s*func=None""")
+        self.assertFalse(stderr)
+
+    # TODO: RUSTPYTHON - _datetime module not available
+    @unittest.expectedFailure
+    def test_datetime_weakref_cycle(self):
+        # https://github.com/python/cpython/issues/132413
+        # If the weakref used by the datetime extension gets cleared by the GC (due to being
+        # in an unreachable cycle) then datetime functions would crash (get_module_state()
+        # was returning a NULL pointer).  This bug is fixed by clearing weakrefs without
+        # callbacks *after* running finalizers.
+        code = """if 1:
+        import _datetime
+        class C:
+            def __del__(self):
+                print('__del__ called')
+                _datetime.timedelta(days=1)  # crash?
+
+        l = [C()]
+        l.append(l)
+        """
+        rc, stdout, stderr = assert_python_ok("-c", code)
+        self.assertEqual(rc, 0)
+        self.assertEqual(stdout.strip(), b'__del__ called')
+
+    @refcount_test
+    def test_frame(self):
+        def f():
+            frame = sys._getframe()
+        gc.collect()
+        f()
+        self.assertEqual(gc.collect(), 1)
+
+    def test_saveall(self):
+        # Verify that cyclic garbage like lists show up in gc.garbage if the
+        # SAVEALL option is enabled.
+
+        # First make sure we don't save away other stuff that just happens to
+        # be waiting for collection.
+        gc.collect()
+        # if this fails, someone else created immortal trash
+        self.assertEqual(gc.garbage, [])
+
+        L = []
+        L.append(L)
+        id_L = id(L)
+
+        debug = gc.get_debug()
+        gc.set_debug(debug | gc.DEBUG_SAVEALL)
+        del L
+        gc.collect()
+        gc.set_debug(debug)
+
+        self.assertEqual(len(gc.garbage), 1)
+        obj = gc.garbage.pop()
+        self.assertEqual(id(obj), id_L)
+
+    def test_del(self):
+        # __del__ methods can trigger collection, make this to happen
+        thresholds = gc.get_threshold()
+        gc.enable()
+        gc.set_threshold(1)
+
+        class A:
+            def __del__(self):
+                dir(self)
+        a = A()
+        del a
+
+        gc.disable()
+        gc.set_threshold(*thresholds)
+
+    def test_del_newclass(self):
+        # __del__ methods can trigger collection, make this to happen
+        thresholds = gc.get_threshold()
+        gc.enable()
+        gc.set_threshold(1)
+
+        class A(object):
+            def __del__(self):
+                dir(self)
+        a = A()
+        del a
+
+        gc.disable()
+        gc.set_threshold(*thresholds)
+
+    # The following two tests are fragile:
+    # They precisely count the number of allocations,
+    # which is highly implementation-dependent.
+    # For example, disposed tuples are not freed, but reused.
+    # To minimize variations, though, we first store the get_count() results
+    # and check them at the end.
+    @refcount_test
+    @requires_gil_enabled('needs precise allocation counts')
+    def test_get_count(self):
+        gc.collect()
+        a, b, c = gc.get_count()
+        x = []
+        d, e, f = gc.get_count()
+        self.assertEqual((b, c), (0, 0))
+        self.assertEqual((e, f), (0, 0))
+        # This is less fragile than asserting that a equals 0.
+        self.assertLess(a, 5)
+        # Between the two calls to get_count(), at least one object was
+        # created (the list).
+        self.assertGreater(d, a)
+
+    @refcount_test
+    def test_collect_generations(self):
+        gc.collect()
+        # This object will "trickle" into generation N + 1 after
+        # each call to collect(N)
+        x = []
+        gc.collect(0)
+        # x is now in the old gen
+        a, b, c = gc.get_count()
+        # We don't check a since its exact values depends on
+        # internal implementation details of the interpreter.
+        self.assertEqual((b, c), (1, 0))
+
+    def test_trashcan(self):
+        class Ouch:
+            n = 0
+            def __del__(self):
+                Ouch.n = Ouch.n + 1
+                if Ouch.n % 17 == 0:
+                    gc.collect()
+
+        # "trashcan" is a hack to prevent stack overflow when deallocating
+        # very deeply nested tuples etc.  It works in part by abusing the
+        # type pointer and refcount fields, and that can yield horrible
+        # problems when gc tries to traverse the structures.
+        # If this test fails (as it does in 2.0, 2.1 and 2.2), it will
+        # most likely die via segfault.
+
+        # Note:  In 2.3 the possibility for compiling without cyclic gc was
+        # removed, and that in turn allows the trashcan mechanism to work
+        # via much simpler means (e.g., it never abuses the type pointer or
+        # refcount fields anymore).  Since it's much less likely to cause a
+        # problem now, the various constants in this expensive (we force a lot
+        # of full collections) test are cut back from the 2.2 version.
+        gc.enable()
+        N = 150
+        for count in range(2):
+            t = []
+            for i in range(N):
+                t = [t, Ouch()]
+            u = []
+            for i in range(N):
+                u = [u, Ouch()]
+            v = {}
+            for i in range(N):
+                v = {1: v, 2: Ouch()}
+        gc.disable()
+
+    @threading_helper.requires_working_threading()
+    def test_trashcan_threads(self):
+        # Issue #13992: trashcan mechanism should be thread-safe
+        NESTING = 60
+        N_THREADS = 2
+
+        def sleeper_gen():
+            """A generator that releases the GIL when closed or dealloc'ed."""
+            try:
+                yield
+            finally:
+                time.sleep(0.000001)
+
+        class C(list):
+            # Appending to a list is atomic, which avoids the use of a lock.
+            inits = []
+            dels = []
+            def __init__(self, alist):
+                self[:] = alist
+                C.inits.append(None)
+            def __del__(self):
+                # This __del__ is called by subtype_dealloc().
+                C.dels.append(None)
+                # `g` will release the GIL when garbage-collected.  This
+                # helps assert subtype_dealloc's behaviour when threads
+                # switch in the middle of it.
+                g = sleeper_gen()
+                next(g)
+                # Now that __del__ is finished, subtype_dealloc will proceed
+                # to call list_dealloc, which also uses the trashcan mechanism.
+
+        def make_nested():
+            """Create a sufficiently nested container object so that the
+            trashcan mechanism is invoked when deallocating it."""
+            x = C([])
+            for i in range(NESTING):
+                x = [C([x])]
+            del x
+
+        def run_thread():
+            """Exercise make_nested() in a loop."""
+            while not exit:
+                make_nested()
+
+        old_switchinterval = sys.getswitchinterval()
+        support.setswitchinterval(1e-5)
+        try:
+            exit = []
+            threads = []
+            for i in range(N_THREADS):
+                t = threading.Thread(target=run_thread)
+                threads.append(t)
+            with threading_helper.start_threads(threads, lambda: exit.append(1)):
+                time.sleep(1.0)
+        finally:
+            sys.setswitchinterval(old_switchinterval)
+        gc.collect()
+        self.assertEqual(len(C.inits), len(C.dels))
+
+    def test_boom(self):
+        class Boom:
+            def __getattr__(self, someattribute):
+                del self.attr
+                raise AttributeError
+
+        a = Boom()
+        b = Boom()
+        a.attr = b
+        b.attr = a
+
+        gc.collect()
+        garbagelen = len(gc.garbage)
+        del a, b
+        # a<->b are in a trash cycle now.  Collection will invoke
+        # Boom.__getattr__ (to see whether a and b have __del__ methods), and
+        # __getattr__ deletes the internal "attr" attributes as a side effect.
+        # That causes the trash cycle to get reclaimed via refcounts falling to
+        # 0, thus mutating the trash graph as a side effect of merely asking
+        # whether __del__ exists.  This used to (before 2.3b1) crash Python.
+        # Now __getattr__ isn't called.
+        self.assertEqual(gc.collect(), 2)
+        self.assertEqual(len(gc.garbage), garbagelen)
+
+    def test_boom2(self):
+        class Boom2:
+            def __init__(self):
+                self.x = 0
+
+            def __getattr__(self, someattribute):
+                self.x += 1
+                if self.x > 1:
+                    del self.attr
+                raise AttributeError
+
+        a = Boom2()
+        b = Boom2()
+        a.attr = b
+        b.attr = a
+
+        gc.collect()
+        garbagelen = len(gc.garbage)
+        del a, b
+        # Much like test_boom(), except that __getattr__ doesn't break the
+        # cycle until the second time gc checks for __del__.  As of 2.3b1,
+        # there isn't a second time, so this simply cleans up the trash cycle.
+        # We expect a, b, a.__dict__ and b.__dict__ (4 objects) to get
+        # reclaimed this way.
+        self.assertEqual(gc.collect(), 2)
+        self.assertEqual(len(gc.garbage), garbagelen)
+
+    def test_get_referents(self):
+        alist = [1, 3, 5]
+        got = gc.get_referents(alist)
+        got.sort()
+        self.assertEqual(got, alist)
+
+        atuple = tuple(alist)
+        got = gc.get_referents(atuple)
+        got.sort()
+        self.assertEqual(got, alist)
+
+        adict = {1: 3, 5: 7}
+        expected = [1, 3, 5, 7]
+        got = gc.get_referents(adict)
+        got.sort()
+        self.assertEqual(got, expected)
+
+        got = gc.get_referents([1, 2], {3: 4}, (0, 0, 0))
+        got.sort()
+        self.assertEqual(got, [0, 0] + list(range(5)))
+
+        self.assertEqual(gc.get_referents(1, 'a', 4j), [])
+
+    def test_is_tracked(self):
+        # Atomic built-in types are not tracked, user-defined objects and
+        # mutable containers are.
+        # NOTE: types with special optimizations (e.g. tuple) have tests
+        # in their own test files instead.
+        self.assertFalse(gc.is_tracked(None))
+        self.assertFalse(gc.is_tracked(1))
+        self.assertFalse(gc.is_tracked(1.0))
+        self.assertFalse(gc.is_tracked(1.0 + 5.0j))
+        self.assertFalse(gc.is_tracked(True))
+        self.assertFalse(gc.is_tracked(False))
+        self.assertFalse(gc.is_tracked(b"a"))
+        self.assertFalse(gc.is_tracked("a"))
+        self.assertFalse(gc.is_tracked(bytearray(b"a")))
+        self.assertFalse(gc.is_tracked(type))
+        self.assertFalse(gc.is_tracked(int))
+        self.assertFalse(gc.is_tracked(object))
+        self.assertFalse(gc.is_tracked(object()))
+
+        class UserClass:
+            pass
+
+        class UserInt(int):
+            pass
+
+        # Base class is object; no extra fields.
+        class UserClassSlots:
+            __slots__ = ()
+
+        # Base class is fixed size larger than object; no extra fields.
+        class UserFloatSlots(float):
+            __slots__ = ()
+
+        # Base class is variable size; no extra fields.
+        class UserIntSlots(int):
+            __slots__ = ()
+
+        self.assertTrue(gc.is_tracked(gc))
+        self.assertTrue(gc.is_tracked(UserClass))
+        self.assertTrue(gc.is_tracked(UserClass()))
+        self.assertTrue(gc.is_tracked(UserInt()))
+        self.assertTrue(gc.is_tracked([]))
+        self.assertTrue(gc.is_tracked(set()))
+        self.assertTrue(gc.is_tracked(UserClassSlots()))
+        self.assertTrue(gc.is_tracked(UserFloatSlots()))
+        self.assertTrue(gc.is_tracked(UserIntSlots()))
+
+    def test_is_finalized(self):
+        # Objects not tracked by the always gc return false
+        self.assertFalse(gc.is_finalized(3))
+
+        storage = []
+        class Lazarus:
+            def __del__(self):
+                storage.append(self)
+
+        lazarus = Lazarus()
+        self.assertFalse(gc.is_finalized(lazarus))
+
+        del lazarus
+        gc.collect()
+
+        lazarus = storage.pop()
+        self.assertTrue(gc.is_finalized(lazarus))
+
+    def test_bug1055820b(self):
+        # Corresponds to temp2b.py in the bug report.
+
+        ouch = []
+        def callback(ignored):
+            ouch[:] = [wr() for wr in WRs]
+
+        Cs = [C1055820(i) for i in range(2)]
+        WRs = [weakref.ref(c, callback) for c in Cs]
+        c = None
+
+        gc.collect()
+        self.assertEqual(len(ouch), 0)
+        # Make the two instances trash, and collect again.  The bug was that
+        # the callback materialized a strong reference to an instance, but gc
+        # cleared the instance's dict anyway.
+        Cs = None
+        gc.collect()
+        self.assertEqual(len(ouch), 2)  # else the callbacks didn't run
+        for x in ouch:
+            # The weakref should be cleared before executing the callback.
+            self.assertIsNone(x)
+
+    def test_bug21435(self):
+        # This is a poor test - its only virtue is that it happened to
+        # segfault on Tim's Windows box before the patch for 21435 was
+        # applied.  That's a nasty bug relying on specific pieces of cyclic
+        # trash appearing in exactly the right order in finalize_garbage()'s
+        # input list.
+        # But there's no reliable way to force that order from Python code,
+        # so over time chances are good this test won't really be testing much
+        # of anything anymore.  Still, if it blows up, there's _some_
+        # problem ;-)
+        gc.collect()
+
+        class A:
+            pass
+
+        class B:
+            def __init__(self, x):
+                self.x = x
+
+            def __del__(self):
+                self.attr = None
+
+        def do_work():
+            a = A()
+            b = B(A())
+
+            a.attr = b
+            b.attr = a
+
+        do_work()
+        gc.collect() # this blows up (bad C pointer) when it fails
+
+    @cpython_only
+    @requires_subprocess()
+    @unittest.skipIf(_testcapi is None, "requires _testcapi")
+    def test_garbage_at_shutdown(self):
+        import subprocess
+        code = """if 1:
+            import gc
+            import _testcapi
+            @_testcapi.with_tp_del
+            class X:
+                def __init__(self, name):
+                    self.name = name
+                def __repr__(self):
+                    return "<X %%r>" %% self.name
+                def __tp_del__(self):
+                    pass
+
+            x = X('first')
+            x.x = x
+            x.y = X('second')
+            del x
+            gc.set_debug(%s)
+        """
+        def run_command(code):
+            p = subprocess.Popen([sys.executable, "-Wd", "-c", code],
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE)
+            stdout, stderr = p.communicate()
+            p.stdout.close()
+            p.stderr.close()
+            self.assertEqual(p.returncode, 0)
+            self.assertEqual(stdout, b"")
+            return stderr
+
+        stderr = run_command(code % "0")
+        self.assertIn(b"ResourceWarning: gc: 2 uncollectable objects at "
+                      b"shutdown; use", stderr)
+        self.assertNotIn(b"<X 'first'>", stderr)
+        one_line_re = b"gc: uncollectable <X 0x[0-9A-Fa-f]+>"
+        expected_re = one_line_re + b"\r?\n" + one_line_re
+        self.assertNotRegex(stderr, expected_re)
+        # With DEBUG_UNCOLLECTABLE, the garbage list gets printed
+        stderr = run_command(code % "gc.DEBUG_UNCOLLECTABLE")
+        self.assertIn(b"ResourceWarning: gc: 2 uncollectable objects at "
+                      b"shutdown", stderr)
+        self.assertTrue(
+            (b"[<X 'first'>, <X 'second'>]" in stderr) or
+            (b"[<X 'second'>, <X 'first'>]" in stderr), stderr)
+        # we expect two lines with uncollectable objects
+        self.assertRegex(stderr, expected_re)
+        # With DEBUG_SAVEALL, no additional message should get printed
+        # (because gc.garbage also contains normally reclaimable cyclic
+        # references, and its elements get printed at runtime anyway).
+        stderr = run_command(code % "gc.DEBUG_SAVEALL")
+        self.assertNotIn(b"uncollectable objects at shutdown", stderr)
+
+    def test_gc_main_module_at_shutdown(self):
+        # Create a reference cycle through the __main__ module and check
+        # it gets collected at interpreter shutdown.
+        code = """if 1:
+            class C:
+                def __del__(self):
+                    print('__del__ called')
+            l = [C()]
+            l.append(l)
+            """
+        rc, out, err = assert_python_ok('-c', code)
+        self.assertEqual(out.strip(), b'__del__ called')
+
+    def test_gc_ordinary_module_at_shutdown(self):
+        # Same as above, but with a non-__main__ module.
+        with temp_dir() as script_dir:
+            module = """if 1:
+                class C:
+                    def __del__(self):
+                        print('__del__ called')
+                l = [C()]
+                l.append(l)
+                """
+            code = """if 1:
+                import sys
+                sys.path.insert(0, %r)
+                import gctest
+                """ % (script_dir,)
+            make_script(script_dir, 'gctest', module)
+            rc, out, err = assert_python_ok('-c', code)
+            self.assertEqual(out.strip(), b'__del__ called')
+
+    @unittest.skipIf(Py_GIL_DISABLED, "requires GC generations or increments")
+    def test_gc_debug_stats(self):
+        # Checks that debug information is printed to stderr
+        # when DEBUG_STATS is set.
+        code = """if 1:
+            import gc
+            gc.set_debug(%s)
+            gc.collect()
+            """
+        _, _, err = assert_python_ok("-c", code % "gc.DEBUG_STATS")
+        self.assertRegex(err, b"gc: collecting generation [0-9]+")
+        self.assertRegex(
+            err,
+            b"gc: objects in each generation: [0-9]+ [0-9]+ [0-9]+",
+        )
+        self.assertRegex(
+            err, b"gc: objects in permanent generation: [0-9]+"
+        )
+        self.assertRegex(
+            err,
+            b"gc: done, .* unreachable, .* uncollectable, .* elapsed",
+        )
+
+        _, _, err = assert_python_ok("-c", code % "0")
+        self.assertNotIn(b"elapsed", err)
+
+    def test_global_del_SystemExit(self):
+        code = """if 1:
+            class ClassWithDel:
+                def __del__(self):
+                    print('__del__ called')
+            a = ClassWithDel()
+            a.link = a
+            raise SystemExit(0)"""
+        self.addCleanup(unlink, TESTFN)
+        with open(TESTFN, 'w', encoding="utf-8") as script:
+            script.write(code)
+        rc, out, err = assert_python_ok(TESTFN)
+        self.assertEqual(out.strip(), b'__del__ called')
+
+    def test_get_stats(self):
+        stats = gc.get_stats()
+        self.assertEqual(len(stats), 3)
+        for st in stats:
+            self.assertIsInstance(st, dict)
+            self.assertEqual(
+                set(st),
+                {"collected", "collections", "uncollectable", "candidates", "duration"}
+            )
+            self.assertGreaterEqual(st["collected"], 0)
+            self.assertGreaterEqual(st["collections"], 0)
+            self.assertGreaterEqual(st["uncollectable"], 0)
+            self.assertGreaterEqual(st["candidates"], 0)
+            self.assertGreaterEqual(st["duration"], 0)
+        # Check that collection counts are incremented correctly
+        if gc.isenabled():
+            self.addCleanup(gc.enable)
+            gc.disable()
+        old = gc.get_stats()
+        gc.collect(0)
+        new = gc.get_stats()
+        self.assertEqual(new[0]["collections"], old[0]["collections"] + 1)
+        self.assertEqual(new[1]["collections"], old[1]["collections"])
+        self.assertEqual(new[2]["collections"], old[2]["collections"])
+        self.assertGreater(new[0]["duration"], old[0]["duration"])
+        self.assertEqual(new[1]["duration"], old[1]["duration"])
+        self.assertEqual(new[2]["duration"], old[2]["duration"])
+        for stat in ["collected", "uncollectable", "candidates"]:
+            self.assertGreaterEqual(new[0][stat], old[0][stat])
+            self.assertEqual(new[1][stat], old[1][stat])
+            self.assertEqual(new[2][stat], old[2][stat])
+        gc.collect(2)
+        old, new = new, gc.get_stats()
+        self.assertEqual(new[0]["collections"], old[0]["collections"])
+        self.assertEqual(new[1]["collections"], old[1]["collections"])
+        self.assertEqual(new[2]["collections"], old[2]["collections"] + 1)
+        self.assertEqual(new[0]["duration"], old[0]["duration"])
+        self.assertEqual(new[1]["duration"], old[1]["duration"])
+        self.assertGreater(new[2]["duration"], old[2]["duration"])
+        for stat in ["collected", "uncollectable", "candidates"]:
+            self.assertEqual(new[0][stat], old[0][stat])
+            self.assertEqual(new[1][stat], old[1][stat])
+            self.assertGreaterEqual(new[2][stat], old[2][stat])
+
+    def test_freeze(self):
+        gc.freeze()
+        self.assertGreater(gc.get_freeze_count(), 0)
+        gc.unfreeze()
+        self.assertEqual(gc.get_freeze_count(), 0)
+
+    def test_get_objects(self):
+        gc.collect()
+        l = []
+        l.append(l)
+        self.assertTrue(
+                any(l is element for element in gc.get_objects())
+        )
+
+    @requires_gil_enabled('need generational GC')
+    def test_get_objects_generations(self):
+        gc.collect()
+        l = []
+        l.append(l)
+        self.assertTrue(
+                any(l is element for element in gc.get_objects(generation=0))
+        )
+        gc.collect()
+        self.assertFalse(
+                any(l is element for element in gc.get_objects(generation=0))
+        )
+        del l
+        gc.collect()
+
+    def test_get_objects_arguments(self):
+        gc.collect()
+        self.assertEqual(len(gc.get_objects()),
+                         len(gc.get_objects(generation=None)))
+
+        self.assertRaises(ValueError, gc.get_objects, 1000)
+        self.assertRaises(ValueError, gc.get_objects, -1000)
+        self.assertRaises(TypeError, gc.get_objects, "1")
+        self.assertRaises(TypeError, gc.get_objects, 1.234)
+
+    def test_resurrection_only_happens_once_per_object(self):
+        class A:  # simple self-loop
+            def __init__(self):
+                self.me = self
+
+        class Lazarus(A):
+            resurrected = 0
+            resurrected_instances = []
+
+            def __del__(self):
+                Lazarus.resurrected += 1
+                Lazarus.resurrected_instances.append(self)
+
+        gc.collect()
+        gc.disable()
+
+        # We start with 0 resurrections
+        laz = Lazarus()
+        self.assertEqual(Lazarus.resurrected, 0)
+
+        # Deleting the instance and triggering a collection
+        # resurrects the object
+        del laz
+        gc.collect()
+        self.assertEqual(Lazarus.resurrected, 1)
+        self.assertEqual(len(Lazarus.resurrected_instances), 1)
+
+        # Clearing the references and forcing a collection
+        # should not resurrect the object again.
+        Lazarus.resurrected_instances.clear()
+        self.assertEqual(Lazarus.resurrected, 1)
+        gc.collect()
+        self.assertEqual(Lazarus.resurrected, 1)
+
+        gc.enable()
+
+    def test_resurrection_is_transitive(self):
+        class Cargo:
+            def __init__(self):
+                self.me = self
+
+        class Lazarus:
+            resurrected_instances = []
+
+            def __del__(self):
+                Lazarus.resurrected_instances.append(self)
+
+        gc.collect()
+        gc.disable()
+
+        laz = Lazarus()
+        cargo = Cargo()
+        cargo_id = id(cargo)
+
+        # Create a cycle between cargo and laz
+        laz.cargo = cargo
+        cargo.laz = laz
+
+        # Drop the references, force a collection and check that
+        # everything was resurrected.
+        del laz, cargo
+        gc.collect()
+        self.assertEqual(len(Lazarus.resurrected_instances), 1)
+        instance = Lazarus.resurrected_instances.pop()
+        self.assertHasAttr(instance, "cargo")
+        self.assertEqual(id(instance.cargo), cargo_id)
+
+        gc.collect()
+        gc.enable()
+
+    def test_resurrection_does_not_block_cleanup_of_other_objects(self):
+
+        # When a finalizer resurrects objects, stats were reporting them as
+        # having been collected.  This affected both collect()'s return
+        # value and the dicts returned by get_stats().
+        N = 100
+
+        class A:  # simple self-loop
+            def __init__(self):
+                self.me = self
+
+        class Z(A):  # resurrecting __del__
+            def __del__(self):
+                zs.append(self)
+
+        zs = []
+
+        def getstats():
+            d = gc.get_stats()[-1]
+            return d['collected'], d['uncollectable']
+
+        gc.collect()
+        gc.disable()
+
+        # No problems if just collecting A() instances.
+        oldc, oldnc = getstats()
+        for i in range(N):
+            A()
+        t = gc.collect()
+        c, nc = getstats()
+        self.assertEqual(t, N) # instance objects
+        self.assertEqual(c - oldc, N)
+        self.assertEqual(nc - oldnc, 0)
+
+        # But Z() is not actually collected.
+        oldc, oldnc = c, nc
+        Z()
+        # Nothing is collected - Z() is merely resurrected.
+        t = gc.collect()
+        c, nc = getstats()
+        self.assertEqual(t, 0)
+        self.assertEqual(c - oldc, 0)
+        self.assertEqual(nc - oldnc, 0)
+
+        # Z() should not prevent anything else from being collected.
+        oldc, oldnc = c, nc
+        for i in range(N):
+            A()
+        Z()
+        t = gc.collect()
+        c, nc = getstats()
+        self.assertEqual(t, N)
+        self.assertEqual(c - oldc, N)
+        self.assertEqual(nc - oldnc, 0)
+
+        # The A() trash should have been reclaimed already but the
+        # 2 copies of Z are still in zs (and the associated dicts).
+        oldc, oldnc = c, nc
+        zs.clear()
+        t = gc.collect()
+        c, nc = getstats()
+        self.assertEqual(t, 2)
+        self.assertEqual(c - oldc, 2)
+        self.assertEqual(nc - oldnc, 0)
+
+        gc.enable()
+
+    @unittest.skipIf(ContainerNoGC is None,
+                     'requires ContainerNoGC extension type')
+    def test_trash_weakref_clear(self):
+        # Test that trash weakrefs are properly cleared (bpo-38006).
+        #
+        # Structure we are creating:
+        #
+        #   Z <- Y <- A--+--> WZ -> C
+        #             ^  |
+        #             +--+
+        # where:
+        #   WZ is a weakref to Z with callback C
+        #   Y doesn't implement tp_traverse
+        #   A contains a reference to itself, Y and WZ
+        #
+        # A, Y, Z, WZ are all trash.  The GC doesn't know that Z is trash
+        # because Y does not implement tp_traverse.  To show the bug, WZ needs
+        # to live long enough so that Z is deallocated before it.  Then, if
+        # gcmodule is buggy, when Z is being deallocated, C will run.
+        #
+        # To ensure WZ lives long enough, we put it in a second reference
+        # cycle.  That trick only works due to the ordering of the GC prev/next
+        # linked lists.  So, this test is a bit fragile.
+        #
+        # The bug reported in bpo-38006 is caused because the GC did not
+        # clear WZ before starting the process of calling tp_clear on the
+        # trash.  Normally, handle_weakrefs() would find the weakref via Z and
+        # clear it.  However, since the GC cannot find Z, WR is not cleared and
+        # it can execute during delete_garbage().  That can lead to disaster
+        # since the callback might tinker with objects that have already had
+        # tp_clear called on them (leaving them in possibly invalid states).
+
+        callback = unittest.mock.Mock()
+
+        class A:
+            __slots__ = ['a', 'y', 'wz']
+
+        class Z:
+            pass
+
+        # setup required object graph, as described above
+        a = A()
+        a.a = a
+        a.y = ContainerNoGC(Z())
+        a.wz = weakref.ref(a.y.value, callback)
+        # create second cycle to keep WZ alive longer
+        wr_cycle = [a.wz]
+        wr_cycle.append(wr_cycle)
+        # ensure trash unrelated to this test is gone
+        gc.collect()
+        gc.disable()
+        # release references and create trash
+        del a, wr_cycle
+        gc.collect()
+        # if called, it means there is a bug in the GC.  The weakref should be
+        # cleared before Z dies.
+        callback.assert_not_called()
+        gc.enable()
+
+    @cpython_only
+    def test_get_referents_on_capsule(self):
+        # gh-124538: Calling gc.get_referents() on an untracked capsule must not crash.
+        import _datetime
+        import _socket
+        untracked_capsule = _datetime.datetime_CAPI
+        tracked_capsule = _socket.CAPI
+
+        # For whoever sees this in the future: if this is failing
+        # after making datetime's capsule tracked, that's fine -- this isn't something
+        # users are relying on. Just find a different capsule that is untracked.
+        self.assertFalse(gc.is_tracked(untracked_capsule))
+        self.assertTrue(gc.is_tracked(tracked_capsule))
+
+        self.assertEqual(len(gc.get_referents(untracked_capsule)), 0)
+        gc.get_referents(tracked_capsule)
+
+    @cpython_only
+    def test_get_objects_during_gc(self):
+        # gh-125859: Calling gc.get_objects() or gc.get_referrers() during a
+        # collection should not crash.
+        test = self
+        collected = False
+
+        class GetObjectsOnDel:
+            def __del__(self):
+                nonlocal collected
+                collected = True
+                objs = gc.get_objects()
+                # NB: can't use "in" here because some objects override __eq__
+                for obj in objs:
+                    test.assertTrue(obj is not self)
+                test.assertEqual(gc.get_referrers(self), [])
+
+        obj = GetObjectsOnDel()
+        obj.cycle = obj
+        del obj
+
+        gc.collect()
+        self.assertTrue(collected)
+
+    def test_traverse_frozen_objects(self):
+        # See GH-126312: Objects that were not frozen could traverse over
+        # a frozen object on the free-threaded build, which would cause
+        # a negative reference count.
+        x = [1, 2, 3]
+        gc.freeze()
+        y = [x]
+        y.append(y)
+        del y
+        gc.collect()
+        gc.unfreeze()
+
+    def test_deferred_refcount_frozen(self):
+        # Also from GH-126312: objects that use deferred reference counting
+        # weren't ignored if they were frozen. Unfortunately, it's pretty
+        # difficult to come up with a case that triggers this.
+        #
+        # Calling gc.collect() while the garbage collector is frozen doesn't
+        # trigger this normally, but it *does* if it's inside unittest for whatever
+        # reason. We can't call unittest from inside a test, so it has to be
+        # in a subprocess.
+        source = textwrap.dedent("""
+        import gc
+        import unittest
+
+
+        class Test(unittest.TestCase):
+            def test_something(self):
+                gc.freeze()
+                gc.collect()
+                gc.unfreeze()
+
+
+        if __name__ == "__main__":
+            unittest.main()
+        """)
+        assert_python_ok("-c", source)
+
+    def test_do_not_cleanup_type_subclasses_before_finalization(self):
+        #  See https://github.com/python/cpython/issues/135552
+        # If we cleanup weakrefs for tp_subclasses before calling
+        # the finalizer (__del__) then the line `fail = BaseNode.next.next`
+        # should fail because we are trying to access a subclass
+        # attribute. But subclass type cache was not properly invalidated.
+        code = """
+            class BaseNode:
+                def __del__(self):
+                    BaseNode.next = BaseNode.next.next
+                    fail = BaseNode.next.next
+
+            class Node(BaseNode):
+                pass
+
+            BaseNode.next = Node()
+            BaseNode.next.next = Node()
+        """
+        # this test checks garbage collection while interp
+        # finalization
+        assert_python_ok("-c", textwrap.dedent(code))
+
+        code_inside_function = textwrap.dedent(F"""
+            def test():
+                {textwrap.indent(code, '    ')}
+
+            test()
+        """)
+        # this test checks regular garbage collection
+        assert_python_ok("-c", code_inside_function)
+
+
+    @unittest.skipUnless(Py_GIL_DISABLED, "requires free-threaded GC")
+    @unittest.skipIf(_testinternalcapi is None, "requires _testinternalcapi")
+    def test_tuple_untrack_counts(self):
+        # This ensures that the free-threaded GC is counting untracked tuples
+        # in the "long_lived_total" count.  This is required to avoid
+        # performance issues from running the GC too frequently.  See
+        # GH-142531 as an example.
+        gc.collect()
+        count = _testinternalcapi.get_long_lived_total()
+        n = 20_000
+        tuples = [(x,) for x in range(n)]
+        gc.collect()
+        new_count = _testinternalcapi.get_long_lived_total()
+        self.assertFalse(gc.is_tracked(tuples[0]))
+        # Use n // 2 just in case some other objects were collected.
+        self.assertTrue(new_count - count > (n // 2))
+
+
+class IncrementalGCTests(unittest.TestCase):
+    @unittest.skipIf(_testinternalcapi is None, "requires _testinternalcapi")
+    @requires_gil_enabled("Free threading does not support incremental GC")
+    def test_incremental_gc_handles_fast_cycle_creation(self):
+        # Run this test in a fresh process.  The number of alive objects (which can
+        # be from unit tests run before this one) can influence how quickly cyclic
+        # garbage is found.
+        script = support.findfile("_test_gc_fast_cycles.py")
+        run_test_script(script)
+
+
+class GCCallbackTests(unittest.TestCase):
+    def setUp(self):
+        # Save gc state and disable it.
+        self.enabled = gc.isenabled()
+        gc.disable()
+        self.debug = gc.get_debug()
+        gc.set_debug(0)
+        gc.callbacks.append(self.cb1)
+        gc.callbacks.append(self.cb2)
+        self.othergarbage = []
+
+    def tearDown(self):
+        # Restore gc state
+        del self.visit
+        gc.callbacks.remove(self.cb1)
+        gc.callbacks.remove(self.cb2)
+        gc.set_debug(self.debug)
+        if self.enabled:
+            gc.enable()
+        # destroy any uncollectables
+        gc.collect()
+        for obj in gc.garbage:
+            if isinstance(obj, Uncollectable):
+                obj.partner = None
+        del gc.garbage[:]
+        del self.othergarbage
+        gc.collect()
+
+    def preclean(self):
+        # Remove all fluff from the system.  Invoke this function
+        # manually rather than through self.setUp() for maximum
+        # safety.
+        self.visit = []
+        gc.collect()
+        garbage, gc.garbage[:] = gc.garbage[:], []
+        self.othergarbage.append(garbage)
+        self.visit = []
+
+    def cb1(self, phase, info):
+        self.visit.append((1, phase, dict(info)))
+
+    def cb2(self, phase, info):
+        self.visit.append((2, phase, dict(info)))
+        if phase == "stop" and hasattr(self, "cleanup"):
+            # Clean Uncollectable from garbage
+            uc = [e for e in gc.garbage if isinstance(e, Uncollectable)]
+            gc.garbage[:] = [e for e in gc.garbage
+                             if not isinstance(e, Uncollectable)]
+            for e in uc:
+                e.partner = None
+
+    def test_collect(self):
+        self.preclean()
+        gc.collect()
+        # Algorithmically verify the contents of self.visit
+        # because it is long and tortuous.
+
+        # Count the number of visits to each callback
+        n = [v[0] for v in self.visit]
+        n1 = [i for i in n if i == 1]
+        n2 = [i for i in n if i == 2]
+        self.assertEqual(n1, [1]*2)
+        self.assertEqual(n2, [2]*2)
+
+        # Count that we got the right number of start and stop callbacks.
+        n = [v[1] for v in self.visit]
+        n1 = [i for i in n if i == "start"]
+        n2 = [i for i in n if i == "stop"]
+        self.assertEqual(n1, ["start"]*2)
+        self.assertEqual(n2, ["stop"]*2)
+
+        # Check that we got the right info dict for all callbacks
+        for v in self.visit:
+            info = v[2]
+            self.assertIn("generation", info)
+            self.assertIn("collected", info)
+            self.assertIn("uncollectable", info)
+            self.assertIn("candidates", info)
+            self.assertIn("duration", info)
+
+    def test_collect_generation(self):
+        self.preclean()
+        gc.collect(2)
+        for v in self.visit:
+            info = v[2]
+            self.assertEqual(info["generation"], 2)
+
+    @cpython_only
+    def test_collect_garbage(self):
+        self.preclean()
+        # Each of these cause two objects to be garbage:
+        Uncollectable()
+        Uncollectable()
+        C1055820(666)
+        gc.collect()
+        for v in self.visit:
+            if v[1] != "stop":
+                continue
+            info = v[2]
+            self.assertEqual(info["collected"], 1)
+            self.assertEqual(info["uncollectable"], 4)
+
+        # We should now have the Uncollectables in gc.garbage
+        self.assertEqual(len(gc.garbage), 4)
+        for e in gc.garbage:
+            self.assertIsInstance(e, Uncollectable)
+
+        # Now, let our callback handle the Uncollectable instances
+        self.cleanup=True
+        self.visit = []
+        gc.garbage[:] = []
+        gc.collect()
+        for v in self.visit:
+            if v[1] != "stop":
+                continue
+            info = v[2]
+            self.assertEqual(info["collected"], 0)
+            self.assertEqual(info["uncollectable"], 2)
+
+        # Uncollectables should be gone
+        self.assertEqual(len(gc.garbage), 0)
+
+
+    @requires_subprocess()
+    @unittest.skipIf(BUILD_WITH_NDEBUG,
+                     'built with -NDEBUG')
+    def test_refcount_errors(self):
+        self.preclean()
+        # Verify the "handling" of objects with broken refcounts
+
+        # Skip the test if ctypes is not available
+        import_module("ctypes")
+
+        import subprocess
+        code = textwrap.dedent('''
+            from test.support import gc_collect, SuppressCrashReport
+
+            a = [1, 2, 3]
+            b = [a, a]
+            a.append(b)
+
+            # Avoid coredump when Py_FatalError() calls abort()
+            SuppressCrashReport().__enter__()
+
+            # Simulate the refcount of "a" being too low (compared to the
+            # references held on it by live data), but keeping it above zero
+            # (to avoid deallocating it):
+            import ctypes
+            ctypes.pythonapi.Py_DecRef(ctypes.py_object(a))
+            del a
+            del b
+
+            # The garbage collector should now have a fatal error
+            # when it reaches the broken object
+            gc_collect()
+        ''')
+        p = subprocess.Popen([sys.executable, "-c", code],
+                             stdout=subprocess.PIPE,
+                             stderr=subprocess.PIPE)
+        stdout, stderr = p.communicate()
+        p.stdout.close()
+        p.stderr.close()
+        # Verify that stderr has a useful error message:
+        self.assertRegex(stderr,
+            br'gc.*\.c:[0-9]+: .*: Assertion "gc_get_refs\(.+\) .*" failed.')
+        self.assertRegex(stderr,
+            br'refcount is too small')
+        # "address : 0x7fb5062efc18"
+        # "address : 7FB5062EFC18"
+        address_regex = br'[0-9a-fA-Fx]+'
+        self.assertRegex(stderr,
+            br'object address  : ' + address_regex)
+        self.assertRegex(stderr,
+            br'object refcount : 1')
+        self.assertRegex(stderr,
+            br'object type     : ' + address_regex)
+        self.assertRegex(stderr,
+            br'object type name: list')
+        self.assertRegex(stderr,
+            br'object repr     : \[1, 2, 3, \[\[...\], \[...\]\]\]')
+
+
+class GCTogglingTests(unittest.TestCase):
+    def setUp(self):
+        gc.enable()
+
+    def tearDown(self):
+        gc.disable()
+
+    @unittest.skipIf(Py_GIL_DISABLED, "requires GC generations or increments")
+    def test_bug1055820c(self):
+        # Corresponds to temp2c.py in the bug report.  This is pretty
+        # elaborate.
+
+        c0 = C1055820(0)
+        # Move c0 into generation 2.
+        gc.collect()
+
+        c1 = C1055820(1)
+        c1.keep_c0_alive = c0
+        del c0.loop # now only c1 keeps c0 alive
+
+        c2 = C1055820(2)
+        c2wr = weakref.ref(c2) # no callback!
+
+        ouch = []
+        def callback(ignored):
+            ouch[:] = [c2wr()]
+
+        # The callback gets associated with a wr on an object in generation 2.
+        c0wr = weakref.ref(c0, callback)
+
+        c0 = c1 = c2 = None
+
+        # What we've set up:  c0, c1, and c2 are all trash now.  c0 is in
+        # generation 2.  The only thing keeping it alive is that c1 points to
+        # it. c1 and c2 are in generation 0, and are in self-loops.  There's a
+        # global weakref to c2 (c2wr), but that weakref has no callback.
+        # There's also a global weakref to c0 (c0wr), and that does have a
+        # callback, and that callback references c2 via c2wr().
+        #
+        #               c0 has a wr with callback, which references c2wr
+        #               ^
+        #               |
+        #               |     Generation 2 above dots
+        #. . . . . . . .|. . . . . . . . . . . . . . . . . . . . . . . .
+        #               |     Generation 0 below dots
+        #               |
+        #               |
+        #            ^->c1   ^->c2 has a wr but no callback
+        #            |  |    |  |
+        #            <--v    <--v
+        #
+        # So this is the nightmare:  when generation 0 gets collected, we see
+        # that c2 has a callback-free weakref, and c1 doesn't even have a
+        # weakref.  Collecting generation 0 doesn't see c0 at all, and c0 is
+        # the only object that has a weakref with a callback.  gc clears c1
+        # and c2.  Clearing c1 has the side effect of dropping the refcount on
+        # c0 to 0, so c0 goes away (despite that it's in an older generation)
+        # and c0's wr callback triggers.  That in turn materializes a reference
+        # to c2 via c2wr(), but c2 gets cleared anyway by gc.
+
+        # We want to let gc happen "naturally", to preserve the distinction
+        # between generations.
+        junk = []
+        i = 0
+        detector = GC_Detector()
+        if Py_GIL_DISABLED:
+            # The free-threaded build doesn't have multiple generations, so
+            # just trigger a GC manually.
+            gc.collect()
+        assert not detector.gc_happened
+        while not detector.gc_happened:
+            i += 1
+            if i > 100000:
+                self.fail("gc didn't happen after 100000 iterations")
+            self.assertEqual(len(ouch), 0)
+            junk.append([])  # this will eventually trigger gc
+
+        self.assertEqual(len(ouch), 1)  # else the callback wasn't invoked
+        for x in ouch:
+            # If the callback resurrected c2, the instance would be damaged,
+            # with an empty __dict__.
+            self.assertEqual(x, None)
+
+    @gc_threshold(1000, 0, 0)
+    @unittest.skipIf(Py_GIL_DISABLED, "requires GC generations or increments")
+    def test_bug1055820d(self):
+        # Corresponds to temp2d.py in the bug report.  This is very much like
+        # test_bug1055820c, but uses a __del__ method instead of a weakref
+        # callback to sneak in a resurrection of cyclic trash.
+
+        ouch = []
+        class D(C1055820):
+            def __del__(self):
+                ouch[:] = [c2wr()]
+
+        d0 = D(0)
+        # Move all the above into generation 2.
+        gc.collect()
+
+        c1 = C1055820(1)
+        c1.keep_d0_alive = d0
+        del d0.loop # now only c1 keeps d0 alive
+
+        c2 = C1055820(2)
+        c2wr = weakref.ref(c2) # no callback!
+
+        d0 = c1 = c2 = None
+
+        # What we've set up:  d0, c1, and c2 are all trash now.  d0 is in
+        # generation 2.  The only thing keeping it alive is that c1 points to
+        # it.  c1 and c2 are in generation 0, and are in self-loops.  There's
+        # a global weakref to c2 (c2wr), but that weakref has no callback.
+        # There are no other weakrefs.
+        #
+        #               d0 has a __del__ method that references c2wr
+        #               ^
+        #               |
+        #               |     Generation 2 above dots
+        #. . . . . . . .|. . . . . . . . . . . . . . . . . . . . . . . .
+        #               |     Generation 0 below dots
+        #               |
+        #               |
+        #            ^->c1   ^->c2 has a wr but no callback
+        #            |  |    |  |
+        #            <--v    <--v
+        #
+        # So this is the nightmare:  when generation 0 gets collected, we see
+        # that c2 has a callback-free weakref, and c1 doesn't even have a
+        # weakref.  Collecting generation 0 doesn't see d0 at all.  gc clears
+        # c1 and c2.  Clearing c1 has the side effect of dropping the refcount
+        # on d0 to 0, so d0 goes away (despite that it's in an older
+        # generation) and d0's __del__ triggers.  That in turn materializes
+        # a reference to c2 via c2wr(), but c2 gets cleared anyway by gc.
+
+        # We want to let gc happen "naturally", to preserve the distinction
+        # between generations.
+        detector = GC_Detector()
+        junk = []
+        i = 0
+        if Py_GIL_DISABLED:
+            # The free-threaded build doesn't have multiple generations, so
+            # just trigger a GC manually.
+            gc.collect()
+        while not detector.gc_happened:
+            i += 1
+            if i > 50000:
+                self.fail("gc didn't happen after 50000 iterations")
+            self.assertEqual(len(ouch), 0)
+            junk.append([])  # this will eventually trigger gc
+
+        self.assertEqual(len(ouch), 1)  # else __del__ wasn't invoked
+        for x in ouch:
+            # If __del__ resurrected c2, the instance would be damaged, with an
+            # empty __dict__.
+            self.assertEqual(x, None)
+
+    @gc_threshold(1000, 0, 0)
+    def test_indirect_calls_with_gc_disabled(self):
+        junk = []
+        i = 0
+        detector = GC_Detector()
+        while not detector.gc_happened:
+            i += 1
+            if i > 100000:
+                self.fail("gc didn't happen after 100000 iterations")
+            junk.append([])  # this will eventually trigger gc
+
+        try:
+            gc.disable()
+            junk = []
+            i = 0
+            detector = GC_Detector()
+            while not detector.gc_happened:
+                i += 1
+                if i > 100000:
+                    break
+                junk.append([])  # this may eventually trigger gc (if it is enabled)
+
+            self.assertEqual(i, 100001)
+        finally:
+            gc.enable()
+
+    # Ensure that setting *threshold0* to zero disables collection.
+    @gc_threshold(0)
+    def test_threshold_zero(self):
+        junk = []
+        i = 0
+        detector = GC_Detector()
+        while not detector.gc_happened:
+            i += 1
+            if i > 50000:
+                break
+            junk.append([])  # this may eventually trigger gc (if it is enabled)
+
+        self.assertEqual(i, 50001)
+
+
+class PythonFinalizationTests(unittest.TestCase):
+    def test_ast_fini(self):
+        # bpo-44184: Regression test for subtype_dealloc() when deallocating
+        # an AST instance also destroy its AST type: subtype_dealloc() must
+        # not access the type memory after deallocating the instance, since
+        # the type memory can be freed as well. The test is also related to
+        # _PyAST_Fini() which clears references to AST types.
+        code = textwrap.dedent("""
+            import ast
+            import codecs
+            from test import support
+
+            # Small AST tree to keep their AST types alive
+            tree = ast.parse("def f(x, y): return 2*x-y")
+
+            # Store the tree somewhere to survive until the last GC collection
+            support.late_deletion(tree)
+        """)
+        assert_python_ok("-c", code)
+
+    def test_warnings_fini(self):
+        # See https://github.com/python/cpython/issues/137384
+        code = textwrap.dedent('''
+            import asyncio
+            from contextvars import ContextVar
+
+            context_loop = ContextVar("context_loop", default=None)
+            loop = asyncio.new_event_loop()
+            context_loop.set(loop)
+        ''')
+
+        assert_python_ok("-c", code)
+
+
+def setUpModule():
+    global enabled, debug
+    enabled = gc.isenabled()
+    gc.disable()
+    assert not gc.isenabled()
+    debug = gc.get_debug()
+    gc.set_debug(debug & ~gc.DEBUG_LEAK) # this test is supposed to leak
+    gc.collect() # Delete 2nd generation garbage
+
+
+def tearDownModule():
+    gc.set_debug(debug)
+    # test gc.enable() even if GC is disabled by default
+    if verbose:
+        print("restoring automatic collection")
+    # make sure to always test gc.enable()
+    gc.enable()
+    assert gc.isenabled()
+    if not enabled:
+        gc.disable()
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/Lib/test/test_generator_stop.py b/Lib/test/test_generator_stop.py
new file mode 100644
index 00000000000..9cacdfff4a2
--- /dev/null
+++ b/Lib/test/test_generator_stop.py
@@ -0,0 +1,35 @@
+from __future__ import generator_stop
+
+import unittest
+
+
+class TestPEP479(unittest.TestCase):
+    def test_stopiteration_wrapping(self):
+        def f():
+            raise StopIteration
+        def g():
+            yield f()
+        with self.assertRaisesRegex(RuntimeError,
+                                    "generator raised StopIteration"):
+            next(g())
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AssertionError: <class 'NoneType'> is not <class 'StopIteration'>
+    def test_stopiteration_wrapping_context(self):
+        def f():
+            raise StopIteration
+        def g():
+            yield f()
+
+        try:
+            next(g())
+        except RuntimeError as exc:
+            self.assertIs(type(exc.__cause__), StopIteration)
+            self.assertIs(type(exc.__context__), StopIteration)
+            self.assertTrue(exc.__suppress_context__)
+        else:
+            self.fail('__cause__, __context__, or __suppress_context__ '
+                      'were not properly set')
+
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/Lib/test/test_generators.py b/Lib/test/test_generators.py
index 853767135aa..8da74ff530d 100644
--- a/Lib/test/test_generators.py
+++ b/Lib/test/test_generators.py
@@ -6,6 +6,7 @@
 import unittest
 import weakref
 import inspect
+import textwrap
 import types
 
 from test import support
@@ -48,7 +49,6 @@ def test_raise_and_yield_from(self):
 
 class FinalizationTest(unittest.TestCase):
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_frame_resurrect(self):
         # A generator frame can be resurrected by a generator's finalization.
         def gen():
@@ -68,7 +68,7 @@ def gen():
         del frame
         support.gc_collect()
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AssertionError: False is not true
     def test_refcycle(self):
         # A generator caught in a refcycle gets finalized anyway.
         old_garbage = gc.garbage[:]
@@ -84,7 +84,7 @@ def gen():
         g = gen()
         next(g)
         g.send(g)
-        self.assertGreater(sys.getrefcount(g), 2)
+        self.assertGreaterEqual(sys.getrefcount(g), 2)
         self.assertFalse(finalized)
         del g
         support.gc_collect()
@@ -114,6 +114,41 @@ def g3(): return (yield from f())
                 gen.send(2)
             self.assertEqual(cm.exception.value, 2)
 
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AssertionError: 0 != 1
+    def test_generator_resurrect(self):
+        # Test that a resurrected generator still has a valid gi_code
+        resurrected = []
+
+        # Resurrect a generator in a finalizer
+        exec(textwrap.dedent("""
+            def gen():
+                try:
+                    yield
+                except:
+                    resurrected.append(g)
+
+            g = gen()
+            next(g)
+        """), {"resurrected": resurrected})
+
+        support.gc_collect()
+
+        self.assertEqual(len(resurrected), 1)
+        self.assertIsInstance(resurrected[0].gi_code, types.CodeType)
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AssertionError: <frame object at 0xb4000073269f09e0> is not None
+    def test_exhausted_generator_frame_cycle(self):
+        def g():
+            yield
+
+        generator = g()
+        frame = generator.gi_frame
+        self.assertIsNone(frame.f_back)
+        next(generator)
+        self.assertIsNone(frame.f_back)
+        next(generator, None)
+        self.assertIsNone(frame.f_back)
+
 
 class GeneratorTest(unittest.TestCase):
 
@@ -176,7 +211,6 @@ def f():
             g.send(0)
         self.assertEqual(next(g), 1)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON; NotImplementedError
     def test_handle_frame_object_in_creation(self):
 
         #Attempt to expose partially constructed frames
@@ -249,6 +283,56 @@ def loop():
         #This should not raise
         loop()
 
+    def test_genexpr_only_calls_dunder_iter_once(self):
+
+        class Iterator:
+
+            def __init__(self):
+                self.val = 0
+
+            def __next__(self):
+                if self.val == 2:
+                    raise StopIteration
+                self.val += 1
+                return self.val
+
+            # No __iter__ method
+
+        class C:
+
+            def __iter__(self):
+                return Iterator()
+
+        self.assertEqual([1, 2], list(i for i in C()))
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AssertionError: False is not true
+    def test_close_clears_frame(self):
+        # gh-142766: Test that closing a generator clears its frame
+        class DetectDelete:
+            def __init__(self):
+                DetectDelete.deleted = False
+
+            def __del__(self):
+                DetectDelete.deleted = True
+
+        def generator(arg):
+            yield
+
+        # Test a freshly created generator (not suspended)
+        g = generator(DetectDelete())
+        g.close()
+        self.assertTrue(DetectDelete.deleted)
+
+        # Test a suspended generator
+        g = generator(DetectDelete())
+        next(g)
+        g.close()
+        self.assertTrue(DetectDelete.deleted)
+
+        # Clear via gi_frame.clear()
+        g = generator(DetectDelete())
+        g.gi_frame.clear()
+        self.assertTrue(DetectDelete.deleted)
 
 class ModifyUnderlyingIterableTest(unittest.TestCase):
     iterables = [
@@ -277,23 +361,27 @@ def gen(it):
                 yield x
         return gen(range(10))
 
-    def process_tests(self, get_generator):
+    def process_tests(self, get_generator, is_expr):
+        err_iterator = "'.*' object is not an iterator"
+        err_iterable = "'.*' object is not iterable"
         for obj in self.iterables:
             g_obj = get_generator(obj)
             with self.subTest(g_obj=g_obj, obj=obj):
-                self.assertListEqual(list(g_obj), list(obj))
+                if is_expr:
+                    self.assertRaisesRegex(TypeError, err_iterator, list, g_obj)
+                else:
+                    self.assertListEqual(list(g_obj), list(obj))
 
             g_iter = get_generator(iter(obj))
             with self.subTest(g_iter=g_iter, obj=obj):
                 self.assertListEqual(list(g_iter), list(obj))
 
-        err_regex = "'.*' object is not iterable"
         for obj in self.non_iterables:
             g_obj = get_generator(obj)
             with self.subTest(g_obj=g_obj):
-                self.assertRaisesRegex(TypeError, err_regex, list, g_obj)
+                err = err_iterator if is_expr else err_iterable
+                self.assertRaisesRegex(TypeError, err, list, g_obj)
 
-    @unittest.expectedFailure # AssertionError: TypeError not raised by list
     def test_modify_f_locals(self):
         def modify_f_locals(g, local, obj):
             g.gi_frame.f_locals[local] = obj
@@ -305,10 +393,9 @@ def get_generator_genexpr(obj):
         def get_generator_genfunc(obj):
             return modify_f_locals(self.genfunc(), 'it', obj)
 
-        self.process_tests(get_generator_genexpr)
-        self.process_tests(get_generator_genfunc)
+        self.process_tests(get_generator_genexpr, True)
+        self.process_tests(get_generator_genfunc, False)
 
-    @unittest.expectedFailure # AssertionError: "'.*' object is not iterable" does not match "'complex' object is not an iterator"
     def test_new_gen_from_gi_code(self):
         def new_gen_from_gi_code(g, obj):
             generator_func = types.FunctionType(g.gi_code, {})
@@ -320,8 +407,8 @@ def get_generator_genexpr(obj):
         def get_generator_genfunc(obj):
             return new_gen_from_gi_code(self.genfunc(), obj)
 
-        self.process_tests(get_generator_genexpr)
-        self.process_tests(get_generator_genfunc)
+        self.process_tests(get_generator_genexpr, True)
+        self.process_tests(get_generator_genfunc, False)
 
 
 class ExceptionTest(unittest.TestCase):
@@ -452,7 +539,6 @@ def gen():
         self.assertEqual(next(g), "done")
         self.assertIsNone(sys.exception())
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_except_throw_bad_exception(self):
         class E(Exception):
             def __new__(cls, *args, **kwargs):
@@ -544,7 +630,6 @@ def f():
         gen.send(None)
         self.assertIsNone(gen.close())
 
-    @unittest.expectedFailure # AssertionError: None != 0
     def test_close_return_value(self):
         def f():
             try:
@@ -591,7 +676,6 @@ def f():
             next(gen)
         self.assertIsNone(gen.close())
 
-    @unittest.expectedFailure # AssertionError: None != 0
     def test_close_closed(self):
         def f():
             try:
@@ -617,7 +701,6 @@ def f():
         with self.assertRaises(RuntimeError):
             gen.close()
 
-    @unittest.expectedFailure # AssertionError: <test.test_generators.GeneratorCloseTest.test_close_releases_frame_locals.<locals>.Foo object at 0xb400007e3c212160> is not None
     def test_close_releases_frame_locals(self):
         # See gh-118272
 
@@ -641,6 +724,7 @@ def genfn():
 
 # See https://github.com/python/cpython/issues/125723
 class GeneratorDeallocTest(unittest.TestCase):
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; frame uses shared Arc, no ownership transfer
     def test_frame_outlives_generator(self):
         def g1():
             a = 42
@@ -680,7 +764,7 @@ def get_frame(index):
                 self.assertIn('a', frame_locals)
                 self.assertEqual(frame_locals['a'], 42)
 
-    @unittest.expectedFailure # AssertionError: 'a' not found in {'frame_locals1': None}
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; frame locals don't survive generator deallocation
     def test_frame_locals_outlive_generator(self):
         frame_locals1 = None
 
@@ -829,7 +913,8 @@ def check_stack_names(self, frame, expected):
         while frame:
             name = frame.f_code.co_name
             # Stop checking frames when we get to our test helper.
-            if name.startswith('check_') or name.startswith('call_'):
+            if (name.startswith('check_') or name.startswith('call_')
+                    or name.startswith('test')):
                 break
 
             names.append(name)
@@ -870,9 +955,27 @@ def call_throw(gen):
 
         self.check_yield_from_example(call_throw)
 
+    def test_throw_with_yield_from_custom_generator(self):
+
+        class CustomGen:
+            def __init__(self, test):
+                self.test = test
+            def throw(self, *args):
+                self.test.check_stack_names(sys._getframe(), ['throw', 'g'])
+            def __iter__(self):
+                return self
+            def __next__(self):
+                return 42
+
+        def g(target):
+            yield from target
+
+        gen = g(CustomGen(self))
+        gen.send(None)
+        gen.throw(RuntimeError)
+
 
 class YieldFromTests(unittest.TestCase):
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_generator_gi_yieldfrom(self):
         def a():
             self.assertEqual(inspect.getgeneratorstate(gen_b), inspect.GEN_RUNNING)
@@ -1078,7 +1181,7 @@ def b():
       File "<stdin>", line 1, in ?
       File "<stdin>", line 2, in g
       File "<stdin>", line 2, in f
-    ZeroDivisionError: integer division or modulo by zero
+    ZeroDivisionError: division by zero
     >>> next(k)  # and the generator cannot be resumed
     Traceback (most recent call last):
       File "<stdin>", line 1, in ?
@@ -1272,7 +1375,7 @@ def b():
 >>> [s for s in dir(i) if not s.startswith('_')]
 ['close', 'gi_code', 'gi_frame', 'gi_running', 'gi_suspended', 'gi_yieldfrom', 'send', 'throw']
 >>> from test.support import HAVE_DOCSTRINGS
->>> print(i.__next__.__doc__ if HAVE_DOCSTRINGS else 'Implement next(self).')
+>>> print(i.__next__.__doc__ if HAVE_DOCSTRINGS else 'Implement next(self).')  # TODO: RUSTPYTHON # doctest: +EXPECTED_FAILURE
 Implement next(self).
 >>> iter(i) is i
 True
@@ -2424,17 +2527,17 @@ def printsolution(self, x):
   ...
 SyntaxError: 'yield from' outside function
 
->>> def f(): x = yield = y
+>>> def f(): x = yield = y  # TODO: RUSTPYTHON # doctest: +EXPECTED_FAILURE
 Traceback (most recent call last):
   ...
 SyntaxError: assignment to yield expression not possible
 
->>> def f(): (yield bar) = y
+>>> def f(): (yield bar) = y  # TODO: RUSTPYTHON # doctest: +EXPECTED_FAILURE
 Traceback (most recent call last):
   ...
 SyntaxError: cannot assign to yield expression here. Maybe you meant '==' instead of '='?
 
->>> def f(): (yield bar) += y
+>>> def f(): (yield bar) += y  # TODO: RUSTPYTHON # doctest: +EXPECTED_FAILURE
 Traceback (most recent call last):
   ...
 SyntaxError: 'yield expression' is an illegal expression for augmented assignment
@@ -2630,17 +2733,21 @@ def printsolution(self, x):
 
 Our ill-behaved code should be invoked during GC:
 
->>> with support.catch_unraisable_exception() as cm:
+>>> with support.catch_unraisable_exception() as cm:  # TODO: RUSTPYTHON # doctest: +EXPECTED_FAILURE
 ...     g = f()
 ...     next(g)
+...     gen_repr = repr(g)
 ...     del g
 ...
+...     cm.unraisable.err_msg == (f'Exception ignored while closing '
+...                               f'generator {gen_repr}')
 ...     cm.unraisable.exc_type == RuntimeError
 ...     "generator ignored GeneratorExit" in str(cm.unraisable.exc_value)
 ...     cm.unraisable.exc_traceback is not None
 True
 True
 True
+True
 
 And errors thrown during closing should propagate:
 
@@ -2744,11 +2851,13 @@ def printsolution(self, x):
 ...             raise RuntimeError(message)
 ...         invoke("del failed")
 ...
->>> with support.catch_unraisable_exception() as cm:
-...     l = Leaker()
-...     del l
+>>> with support.catch_unraisable_exception() as cm:  # TODO: RUSTPYTHON # doctest: +EXPECTED_FAILURE
+...     leaker = Leaker()
+...     del_repr = repr(type(leaker).__del__)
+...     del leaker
 ...
-...     cm.unraisable.object == Leaker.__del__
+...     cm.unraisable.err_msg == (f'Exception ignored while '
+...                               f'calling deallocator {del_repr}')
 ...     cm.unraisable.exc_type == RuntimeError
 ...     str(cm.unraisable.exc_value) == "del failed"
 ...     cm.unraisable.exc_traceback is not None
@@ -2775,7 +2884,8 @@ def printsolution(self, x):
             }
 
 def load_tests(loader, tests, pattern):
-    # tests.addTest(doctest.DocTestSuite()) # TODO: RUSTPYTHON
+    from test.support.rustpython import DocTestChecker  # TODO: RUSTPYTHON
+    tests.addTest(doctest.DocTestSuite(checker=DocTestChecker()))  # TODO: RUSTPYTHON
     return tests
 
 
diff --git a/Lib/test/test_genericalias.py b/Lib/test/test_genericalias.py
index c1c49dc29d8..4f5b10650ac 100644
--- a/Lib/test/test_genericalias.py
+++ b/Lib/test/test_genericalias.py
@@ -57,6 +57,11 @@
 from weakref import WeakSet, ReferenceType, ref
 import typing
 from typing import Unpack
+try:
+    from tkinter import Event
+except ImportError:
+    Event = None
+from string.templatelib import Template, Interpolation
 
 from typing import TypeVar
 T = TypeVar('T')
@@ -96,7 +101,7 @@
 
 class BaseTest(unittest.TestCase):
     """Test basics."""
-    generic_types = [type, tuple, list, dict, set, frozenset, enumerate,
+    generic_types = [type, tuple, list, dict, set, frozenset, enumerate, memoryview,
                      defaultdict, deque,
                      SequenceMatcher,
                      dircmp,
@@ -133,12 +138,19 @@ class BaseTest(unittest.TestCase):
                      Future, _WorkItem,
                      Morsel,
                      DictReader, DictWriter,
-                     array]
+                     array,
+                     staticmethod,
+                     classmethod,
+                     Template,
+                     Interpolation,
+                    ]
     if ctypes is not None:
-        generic_types.extend((ctypes.Array, ctypes.LibraryLoader))
+        generic_types.extend((ctypes.Array, ctypes.LibraryLoader, ctypes.py_object))
     if ValueProxy is not None:
         generic_types.extend((ValueProxy, DictProxy, ListProxy, ApplyResult,
                               MPSimpleQueue, MPQueue, MPJoinableQueue))
+    if Event is not None:
+        generic_types.append(Event)
 
     def test_subscriptable(self):
         for t in self.generic_types:
@@ -151,7 +163,6 @@ def test_subscriptable(self):
                 self.assertEqual(alias.__args__, (int,))
                 self.assertEqual(alias.__parameters__, ())
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON; wrong error message
     def test_unsubscriptable(self):
         for t in int, str, float, Sized, Hashable:
             tname = t.__name__
@@ -210,7 +221,6 @@ class MyList(list):
         self.assertEqual(t.__args__, (int,))
         self.assertEqual(t.__parameters__, ())
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_repr(self):
         class MyList(list):
             pass
@@ -226,13 +236,63 @@ class MyGeneric:
         self.assertEqual(repr(x2), 'tuple[*tuple[int, str]]')
         x3 = tuple[*tuple[int, ...]]
         self.assertEqual(repr(x3), 'tuple[*tuple[int, ...]]')
-        self.assertTrue(repr(MyList[int]).endswith('.BaseTest.test_repr.<locals>.MyList[int]'))
+        self.assertEndsWith(repr(MyList[int]), '.BaseTest.test_repr.<locals>.MyList[int]')
         self.assertEqual(repr(list[str]()), '[]')  # instances should keep their normal repr
 
         # gh-105488
-        self.assertTrue(repr(MyGeneric[int]).endswith('MyGeneric[int]'))
-        self.assertTrue(repr(MyGeneric[[]]).endswith('MyGeneric[[]]'))
-        self.assertTrue(repr(MyGeneric[[int, str]]).endswith('MyGeneric[[int, str]]'))
+        self.assertEndsWith(repr(MyGeneric[int]), 'MyGeneric[int]')
+        self.assertEndsWith(repr(MyGeneric[[]]), 'MyGeneric[[]]')
+        self.assertEndsWith(repr(MyGeneric[[int, str]]), 'MyGeneric[[int, str]]')
+
+    def test_evil_repr1(self):
+        # gh-143635
+        class Zap:
+            def __init__(self, container):
+                self.container = container
+            def __getattr__(self, name):
+                if name == "__origin__":
+                    self.container.clear()
+                    return None
+                if name == "__args__":
+                    return ()
+                raise AttributeError
+
+        params = []
+        params.append(Zap(params))
+        alias = GenericAlias(list, (params,))
+        repr_str = repr(alias)
+        self.assertTrue(repr_str.startswith("list[["), repr_str)
+
+    def test_evil_repr2(self):
+        class Zap:
+            def __init__(self, container):
+                self.container = container
+            def __getattr__(self, name):
+                if name == "__qualname__":
+                    self.container.clear()
+                    return "abcd"
+                if name == "__module__":
+                    return None
+                raise AttributeError
+
+        params = []
+        params.append(Zap(params))
+        alias = GenericAlias(list, (params,))
+        repr_str = repr(alias)
+        self.assertTrue(repr_str.startswith("list[["), repr_str)
+
+    def test_evil_repr3(self):
+        # gh-143823
+        lst = []
+        class X:
+            def __repr__(self):
+                lst.clear()
+                return "x"
+
+        lst += [X(), 1]
+        ga = GenericAlias(int, lst)
+        with self.assertRaises(IndexError):
+            repr(ga)
 
     def test_exposed_type(self):
         import types
@@ -334,7 +394,6 @@ def test_parameter_chaining(self):
         with self.assertRaises(TypeError):
             dict[T, T][str, int]
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_equality(self):
         self.assertEqual(list[int], list[int])
         self.assertEqual(dict[str, int], dict[str, int])
@@ -353,7 +412,7 @@ def test_isinstance(self):
 
     def test_issubclass(self):
         class L(list): ...
-        self.assertTrue(issubclass(L, list))
+        self.assertIsSubclass(L, list)
         with self.assertRaises(TypeError):
             issubclass(L, list[str])
 
@@ -365,7 +424,6 @@ def test_type_generic(self):
         self.assertEqual(t(test), Test)
         self.assertEqual(t(0), int)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON; wrong error message
     def test_type_subclass_generic(self):
         class MyType(type):
             pass
@@ -426,7 +484,6 @@ def test_union_generic(self):
         self.assertEqual(a.__args__, (list[T], tuple[T, ...]))
         self.assertEqual(a.__parameters__, (T,))
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_dir(self):
         ga = list[int]
         dir_of_gen_alias = set(dir(ga))
@@ -492,6 +549,76 @@ def test_del_iter(self):
         iter_x = iter(t)
         del iter_x
 
+    def test_paramspec_specialization(self):
+        # gh-124445
+        T = TypeVar("T")
+        U = TypeVar("U")
+        type X[**P] = Callable[P, int]
+
+        generic = X[[T]]
+        self.assertEqual(generic.__args__, ([T],))
+        self.assertEqual(generic.__parameters__, (T,))
+        specialized = generic[str]
+        self.assertEqual(specialized.__args__, ([str],))
+        self.assertEqual(specialized.__parameters__, ())
+
+        generic = X[(T,)]
+        self.assertEqual(generic.__args__, (T,))
+        self.assertEqual(generic.__parameters__, (T,))
+        specialized = generic[str]
+        self.assertEqual(specialized.__args__, (str,))
+        self.assertEqual(specialized.__parameters__, ())
+
+        generic = X[[T, U]]
+        self.assertEqual(generic.__args__, ([T, U],))
+        self.assertEqual(generic.__parameters__, (T, U))
+        specialized = generic[str, int]
+        self.assertEqual(specialized.__args__, ([str, int],))
+        self.assertEqual(specialized.__parameters__, ())
+
+        generic = X[(T, U)]
+        self.assertEqual(generic.__args__, (T, U))
+        self.assertEqual(generic.__parameters__, (T, U))
+        specialized = generic[str, int]
+        self.assertEqual(specialized.__args__, (str, int))
+        self.assertEqual(specialized.__parameters__, ())
+
+    def test_nested_paramspec_specialization(self):
+        # gh-124445
+        type X[**P, T] = Callable[P, T]
+
+        x_list = X[[int, str], float]
+        self.assertEqual(x_list.__args__, ([int, str], float))
+        self.assertEqual(x_list.__parameters__, ())
+
+        x_tuple = X[(int, str), float]
+        self.assertEqual(x_tuple.__args__, ((int, str), float))
+        self.assertEqual(x_tuple.__parameters__, ())
+
+        U = TypeVar("U")
+        V = TypeVar("V")
+
+        multiple_params_list = X[[int, U], V]
+        self.assertEqual(multiple_params_list.__args__, ([int, U], V))
+        self.assertEqual(multiple_params_list.__parameters__, (U, V))
+        multiple_params_list_specialized = multiple_params_list[str, float]
+        self.assertEqual(multiple_params_list_specialized.__args__, ([int, str], float))
+        self.assertEqual(multiple_params_list_specialized.__parameters__, ())
+
+        multiple_params_tuple = X[(int, U), V]
+        self.assertEqual(multiple_params_tuple.__args__, ((int, U), V))
+        self.assertEqual(multiple_params_tuple.__parameters__, (U, V))
+        multiple_params_tuple_specialized = multiple_params_tuple[str, float]
+        self.assertEqual(multiple_params_tuple_specialized.__args__, ((int, str), float))
+        self.assertEqual(multiple_params_tuple_specialized.__parameters__, ())
+
+        deeply_nested = X[[U, [V], int], V]
+        self.assertEqual(deeply_nested.__args__, ([U, [V], int], V))
+        self.assertEqual(deeply_nested.__parameters__, (U, V))
+        deeply_nested_specialized = deeply_nested[str, float]
+        self.assertEqual(deeply_nested_specialized.__args__, ([str, [float], int], float))
+        self.assertEqual(deeply_nested_specialized.__parameters__, ())
+
 
 class TypeIterationTests(unittest.TestCase):
     _UNITERABLE_TYPES = (list, tuple)
diff --git a/Lib/test/test_genericclass.py b/Lib/test/test_genericclass.py
index aa843f6d9f0..e530b463966 100644
--- a/Lib/test/test_genericclass.py
+++ b/Lib/test/test_genericclass.py
@@ -1,5 +1,6 @@
 import unittest
 from test import support
+from test.support.import_helper import import_module
 
 
 class TestMROEntry(unittest.TestCase):
@@ -98,7 +99,7 @@ def __mro_entries__(self):
                 return ()
         d = C_too_few()
         with self.assertRaises(TypeError):
-            class D(d): ...
+            class E(d): ...
 
     def test_mro_entry_errors_2(self):
         class C_not_callable:
@@ -111,7 +112,7 @@ def __mro_entries__(self):
                 return object
         c = C_not_tuple()
         with self.assertRaises(TypeError):
-            class D(c): ...
+            class E(c): ...
 
     def test_mro_entry_metaclass(self):
         meta_args = []
@@ -227,8 +228,6 @@ def __class_getitem__(cls, one, two):
         with self.assertRaises(TypeError):
             C_too_many[int]
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_class_getitem_errors_2(self):
         class C:
             def __class_getitem__(cls, item):
@@ -279,7 +278,9 @@ def __class_getitem__(cls, item):
 class CAPITest(unittest.TestCase):
 
     def test_c_class(self):
-        from _testcapi import Generic, GenericAlias
+        _testcapi = import_module("_testcapi")
+        Generic = _testcapi.Generic
+        GenericAlias = _testcapi.GenericAlias
         self.assertIsInstance(Generic.__class_getitem__(int), GenericAlias)
 
         IntGeneric = Generic[int]
diff --git a/Lib/test/test_genericpath.py b/Lib/test/test_genericpath.py
index ab580dfad0f..1a44cedcd36 100644
--- a/Lib/test/test_genericpath.py
+++ b/Lib/test/test_genericpath.py
@@ -170,7 +170,6 @@ def test_exists_fd(self):
             os.close(w)
         self.assertFalse(self.pathmodule.exists(r))
 
-    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_exists_bool(self):
         for fd in False, True:
             with self.assertWarnsRegex(RuntimeWarning,
diff --git a/Lib/test/test_getopt.py b/Lib/test/test_getopt.py
index 295a2c81363..8d0d5084abb 100644
--- a/Lib/test/test_getopt.py
+++ b/Lib/test/test_getopt.py
@@ -19,21 +19,34 @@ def assertError(self, *args, **kwargs):
         self.assertRaises(getopt.GetoptError, *args, **kwargs)
 
     def test_short_has_arg(self):
-        self.assertTrue(getopt.short_has_arg('a', 'a:'))
-        self.assertFalse(getopt.short_has_arg('a', 'a'))
+        self.assertIs(getopt.short_has_arg('a', 'a:'), True)
+        self.assertIs(getopt.short_has_arg('a', 'a'), False)
+        self.assertEqual(getopt.short_has_arg('a', 'a::'), '?')
         self.assertError(getopt.short_has_arg, 'a', 'b')
 
     def test_long_has_args(self):
         has_arg, option = getopt.long_has_args('abc', ['abc='])
-        self.assertTrue(has_arg)
+        self.assertIs(has_arg, True)
         self.assertEqual(option, 'abc')
 
         has_arg, option = getopt.long_has_args('abc', ['abc'])
-        self.assertFalse(has_arg)
+        self.assertIs(has_arg, False)
         self.assertEqual(option, 'abc')
 
+        has_arg, option = getopt.long_has_args('abc', ['abc=?'])
+        self.assertEqual(has_arg, '?')
+        self.assertEqual(option, 'abc')
+
+        has_arg, option = getopt.long_has_args('abc', ['abcd='])
+        self.assertIs(has_arg, True)
+        self.assertEqual(option, 'abcd')
+
         has_arg, option = getopt.long_has_args('abc', ['abcd'])
-        self.assertFalse(has_arg)
+        self.assertIs(has_arg, False)
+        self.assertEqual(option, 'abcd')
+
+        has_arg, option = getopt.long_has_args('abc', ['abcd=?'])
+        self.assertEqual(has_arg, '?')
         self.assertEqual(option, 'abcd')
 
         self.assertError(getopt.long_has_args, 'abc', ['def'])
@@ -49,9 +62,9 @@ def test_do_shorts(self):
         self.assertEqual(opts, [('-a', '1')])
         self.assertEqual(args, [])
 
-        #opts, args = getopt.do_shorts([], 'a=1', 'a:', [])
-        #self.assertEqual(opts, [('-a', '1')])
-        #self.assertEqual(args, [])
+        opts, args = getopt.do_shorts([], 'a=1', 'a:', [])
+        self.assertEqual(opts, [('-a', '=1')])
+        self.assertEqual(args, [])
 
         opts, args = getopt.do_shorts([], 'a', 'a:', ['1'])
         self.assertEqual(opts, [('-a', '1')])
@@ -61,6 +74,14 @@ def test_do_shorts(self):
         self.assertEqual(opts, [('-a', '1')])
         self.assertEqual(args, ['2'])
 
+        opts, args = getopt.do_shorts([], 'a', 'a::', ['1'])
+        self.assertEqual(opts, [('-a', '')])
+        self.assertEqual(args, ['1'])
+
+        opts, args = getopt.do_shorts([], 'a1', 'a::', [])
+        self.assertEqual(opts, [('-a', '1')])
+        self.assertEqual(args, [])
+
         self.assertError(getopt.do_shorts, [], 'a1', 'a', [])
         self.assertError(getopt.do_shorts, [], 'a', 'a:', [])
 
@@ -77,6 +98,22 @@ def test_do_longs(self):
         self.assertEqual(opts, [('--abcd', '1')])
         self.assertEqual(args, [])
 
+        opts, args = getopt.do_longs([], 'abc', ['abc=?'], ['1'])
+        self.assertEqual(opts, [('--abc', '')])
+        self.assertEqual(args, ['1'])
+
+        opts, args = getopt.do_longs([], 'abc', ['abcd=?'], ['1'])
+        self.assertEqual(opts, [('--abcd', '')])
+        self.assertEqual(args, ['1'])
+
+        opts, args = getopt.do_longs([], 'abc=1', ['abc=?'], [])
+        self.assertEqual(opts, [('--abc', '1')])
+        self.assertEqual(args, [])
+
+        opts, args = getopt.do_longs([], 'abc=1', ['abcd=?'], [])
+        self.assertEqual(opts, [('--abcd', '1')])
+        self.assertEqual(args, [])
+
         opts, args = getopt.do_longs([], 'abc', ['ab', 'abc', 'abcd'], [])
         self.assertEqual(opts, [('--abc', '')])
         self.assertEqual(args, [])
@@ -95,7 +132,7 @@ def test_getopt(self):
         # note: the empty string between '-a' and '--beta' is significant:
         # it simulates an empty string option argument ('-a ""') on the
         # command line.
-        cmdline = ['-a', '1', '-b', '--alpha=2', '--beta', '-a', '3', '-a',
+        cmdline = ['-a1', '-b', '--alpha=2', '--beta', '-a', '3', '-a',
                    '', '--beta', 'arg1', 'arg2']
 
         opts, args = getopt.getopt(cmdline, 'a:b', ['alpha=', 'beta'])
@@ -106,33 +143,53 @@ def test_getopt(self):
         # accounted for in the code that calls getopt().
         self.assertEqual(args, ['arg1', 'arg2'])
 
+        cmdline = ['-a1', '--alpha=2', '--alpha=', '-a', '--alpha', 'arg1', 'arg2']
+        opts, args = getopt.getopt(cmdline, 'a::', ['alpha=?'])
+        self.assertEqual(opts, [('-a', '1'), ('--alpha', '2'), ('--alpha', ''),
+                                ('-a', ''), ('--alpha', '')])
+        self.assertEqual(args, ['arg1', 'arg2'])
+
         self.assertError(getopt.getopt, cmdline, 'a:b', ['alpha', 'beta'])
 
     def test_gnu_getopt(self):
         # Test handling of GNU style scanning mode.
-        cmdline = ['-a', 'arg1', '-b', '1', '--alpha', '--beta=2']
+        cmdline = ['-a', 'arg1', '-b', '1', '--alpha', '--beta=2', '--beta',
+                   '3', 'arg2']
 
         # GNU style
         opts, args = getopt.gnu_getopt(cmdline, 'ab:', ['alpha', 'beta='])
-        self.assertEqual(args, ['arg1'])
-        self.assertEqual(opts, [('-a', ''), ('-b', '1'),
-                                ('--alpha', ''), ('--beta', '2')])
+        self.assertEqual(args, ['arg1', 'arg2'])
+        self.assertEqual(opts, [('-a', ''), ('-b', '1'), ('--alpha', ''),
+                                ('--beta', '2'), ('--beta', '3')])
+
+        opts, args = getopt.gnu_getopt(cmdline, 'ab::', ['alpha', 'beta=?'])
+        self.assertEqual(args, ['arg1', '1', '3', 'arg2'])
+        self.assertEqual(opts, [('-a', ''), ('-b', ''), ('--alpha', ''),
+                                ('--beta', '2'), ('--beta', '')])
 
         # recognize "-" as an argument
         opts, args = getopt.gnu_getopt(['-a', '-', '-b', '-'], 'ab:', [])
         self.assertEqual(args, ['-'])
         self.assertEqual(opts, [('-a', ''), ('-b', '-')])
 
+        # Return positional arguments intermixed with options.
+        opts, args = getopt.gnu_getopt(cmdline, '-ab:', ['alpha', 'beta='])
+        self.assertEqual(args, ['arg2'])
+        self.assertEqual(opts, [('-a', ''), (None, ['arg1']), ('-b', '1'), ('--alpha', ''),
+                                ('--beta', '2'), ('--beta', '3')])
+
         # Posix style via +
         opts, args = getopt.gnu_getopt(cmdline, '+ab:', ['alpha', 'beta='])
         self.assertEqual(opts, [('-a', '')])
-        self.assertEqual(args, ['arg1', '-b', '1', '--alpha', '--beta=2'])
+        self.assertEqual(args, ['arg1', '-b', '1', '--alpha', '--beta=2',
+                                '--beta', '3', 'arg2'])
 
         # Posix style via POSIXLY_CORRECT
         self.env["POSIXLY_CORRECT"] = "1"
         opts, args = getopt.gnu_getopt(cmdline, 'ab:', ['alpha', 'beta='])
         self.assertEqual(opts, [('-a', '')])
-        self.assertEqual(args, ['arg1', '-b', '1', '--alpha', '--beta=2'])
+        self.assertEqual(args, ['arg1', '-b', '1', '--alpha', '--beta=2',
+                                '--beta', '3', 'arg2'])
 
     def test_issue4629(self):
         longopts, shortopts = getopt.getopt(['--help='], '', ['help='])
diff --git a/Lib/test/test_getpass.py b/Lib/test/test_getpass.py
index 80dda2caaa3..9c3def2c3be 100644
--- a/Lib/test/test_getpass.py
+++ b/Lib/test/test_getpass.py
@@ -161,6 +161,81 @@ def test_falls_back_to_stdin(self):
             self.assertIn('Warning', stderr.getvalue())
             self.assertIn('Password:', stderr.getvalue())
 
+    def test_echo_char_replaces_input_with_asterisks(self):
+        mock_result = '*************'
+        with mock.patch('os.open') as os_open, \
+                mock.patch('io.FileIO'), \
+                mock.patch('io.TextIOWrapper') as textio, \
+                mock.patch('termios.tcgetattr'), \
+                mock.patch('termios.tcsetattr'), \
+                mock.patch('getpass._raw_input') as mock_input:
+            os_open.return_value = 3
+            mock_input.return_value = mock_result
+
+            result = getpass.unix_getpass(echo_char='*')
+            mock_input.assert_called_once_with('Password: ', textio(),
+                                               input=textio(), echo_char='*')
+            self.assertEqual(result, mock_result)
+
+    def test_raw_input_with_echo_char(self):
+        passwd = 'my1pa$$word!'
+        mock_input = StringIO(f'{passwd}\n')
+        mock_output = StringIO()
+        with mock.patch('sys.stdin', mock_input), \
+                mock.patch('sys.stdout', mock_output):
+            result = getpass._raw_input('Password: ', mock_output, mock_input,
+                                        '*')
+        self.assertEqual(result, passwd)
+        self.assertEqual('Password: ************', mock_output.getvalue())
+
+    def test_control_chars_with_echo_char(self):
+        passwd = 'pass\twd\b'
+        expect_result = 'pass\tw'
+        mock_input = StringIO(f'{passwd}\n')
+        mock_output = StringIO()
+        with mock.patch('sys.stdin', mock_input), \
+                mock.patch('sys.stdout', mock_output):
+            result = getpass._raw_input('Password: ', mock_output, mock_input,
+                                        '*')
+        self.assertEqual(result, expect_result)
+        self.assertEqual('Password: *******\x08 \x08', mock_output.getvalue())
+
+
+class GetpassEchoCharTest(unittest.TestCase):
+
+    def test_accept_none(self):
+        getpass._check_echo_char(None)
+
+    @support.subTests('echo_char', ["*", "A", " "])
+    def test_accept_single_printable_ascii(self, echo_char):
+        getpass._check_echo_char(echo_char)
+
+    def test_reject_empty_string(self):
+        self.assertRaises(ValueError, getpass.getpass, echo_char="")
+
+    @support.subTests('echo_char', ["***", "AA", "aA*!"])
+    def test_reject_multi_character_strings(self, echo_char):
+        self.assertRaises(ValueError, getpass.getpass, echo_char=echo_char)
+
+    @support.subTests('echo_char', [
+        '\N{LATIN CAPITAL LETTER AE}',  # non-ASCII single character
+        '\N{HEAVY BLACK HEART}',        # non-ASCII multibyte character
+    ])
+    def test_reject_non_ascii(self, echo_char):
+        self.assertRaises(ValueError, getpass.getpass, echo_char=echo_char)
+
+    @support.subTests('echo_char', [
+        ch for ch in map(chr, range(0, 128))
+        if not ch.isprintable()
+    ])
+    def test_reject_non_printable_characters(self, echo_char):
+        self.assertRaises(ValueError, getpass.getpass, echo_char=echo_char)
+
+    # TypeError Rejection
+    @support.subTests('echo_char', [b"*", 0, 0.0, [], {}])
+    def test_reject_non_string(self, echo_char):
+        self.assertRaises(TypeError, getpass.getpass, echo_char=echo_char)
+
 
 if __name__ == "__main__":
     unittest.main()
diff --git a/Lib/test/test_gettext.py b/Lib/test/test_gettext.py
index 0653bb762a9..9ad37909a8e 100644
--- a/Lib/test/test_gettext.py
+++ b/Lib/test/test_gettext.py
@@ -6,13 +6,12 @@
 from functools import partial
 
 from test import support
-from test.support import os_helper
+from test.support import cpython_only, os_helper
+from test.support.import_helper import ensure_lazy_imports
 
 
 # TODO:
 #  - Add new tests, for example for "dgettext"
-#  - Remove dummy tests, for example testing for single and double quotes
-#    has no sense, it would have if we were testing a parser (i.e. pygettext)
 #  - Tests should have only one assert.
 
 GNU_MO_DATA = b'''\
@@ -231,30 +230,6 @@ def test_some_translations_with_context(self):
         eq(pgettext('my other context', 'nudge nudge'),
            'wink wink (in "my other context")')
 
-    def test_double_quotes(self):
-        eq = self.assertEqual
-        # double quotes
-        eq(_("albatross"), 'albatross')
-        eq(_("mullusk"), 'bacon')
-        eq(_(r"Raymond Luxury Yach-t"), 'Throatwobbler Mangrove')
-        eq(_(r"nudge nudge"), 'wink wink')
-
-    def test_triple_single_quotes(self):
-        eq = self.assertEqual
-        # triple single quotes
-        eq(_('''albatross'''), 'albatross')
-        eq(_('''mullusk'''), 'bacon')
-        eq(_(r'''Raymond Luxury Yach-t'''), 'Throatwobbler Mangrove')
-        eq(_(r'''nudge nudge'''), 'wink wink')
-
-    def test_triple_double_quotes(self):
-        eq = self.assertEqual
-        # triple double quotes
-        eq(_("""albatross"""), 'albatross')
-        eq(_("""mullusk"""), 'bacon')
-        eq(_(r"""Raymond Luxury Yach-t"""), 'Throatwobbler Mangrove')
-        eq(_(r"""nudge nudge"""), 'wink wink')
-
     def test_multiline_strings(self):
         eq = self.assertEqual
         # multiline strings
@@ -367,30 +342,6 @@ def test_some_translations_with_context_and_domain(self):
         eq(gettext.dpgettext('gettext', 'my other context', 'nudge nudge'),
            'wink wink (in "my other context")')
 
-    def test_double_quotes(self):
-        eq = self.assertEqual
-        # double quotes
-        eq(self._("albatross"), 'albatross')
-        eq(self._("mullusk"), 'bacon')
-        eq(self._(r"Raymond Luxury Yach-t"), 'Throatwobbler Mangrove')
-        eq(self._(r"nudge nudge"), 'wink wink')
-
-    def test_triple_single_quotes(self):
-        eq = self.assertEqual
-        # triple single quotes
-        eq(self._('''albatross'''), 'albatross')
-        eq(self._('''mullusk'''), 'bacon')
-        eq(self._(r'''Raymond Luxury Yach-t'''), 'Throatwobbler Mangrove')
-        eq(self._(r'''nudge nudge'''), 'wink wink')
-
-    def test_triple_double_quotes(self):
-        eq = self.assertEqual
-        # triple double quotes
-        eq(self._("""albatross"""), 'albatross')
-        eq(self._("""mullusk"""), 'bacon')
-        eq(self._(r"""Raymond Luxury Yach-t"""), 'Throatwobbler Mangrove')
-        eq(self._(r"""nudge nudge"""), 'wink wink')
-
     def test_multiline_strings(self):
         eq = self.assertEqual
         # multiline strings
@@ -434,8 +385,6 @@ def _test_plural_forms(self, ngettext, gettext,
                 x = ngettext(singular, plural, None)
             self.assertEqual(x, tplural)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_plural_forms(self):
         self._test_plural_forms(
             self.ngettext, self.gettext,
@@ -446,8 +395,6 @@ def test_plural_forms(self):
             '%d file deleted', '%d files deleted',
             '%d file deleted', '%d files deleted')
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_plural_context_forms(self):
         ngettext = partial(self.npgettext, 'With context')
         gettext = partial(self.pgettext, 'With context')
@@ -460,8 +407,6 @@ def test_plural_context_forms(self):
             '%d file deleted', '%d files deleted',
             '%d file deleted', '%d files deleted')
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_plural_wrong_context_forms(self):
         self._test_plural_forms(
             partial(self.npgettext, 'Unknown context'),
@@ -494,8 +439,6 @@ def setUp(self):
         self.pgettext = partial(gettext.dpgettext, 'gettext')
         self.npgettext = partial(gettext.dnpgettext, 'gettext')
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_plural_forms_wrong_domain(self):
         self._test_plural_forms(
             partial(gettext.dngettext, 'unknown'),
@@ -504,8 +447,6 @@ def test_plural_forms_wrong_domain(self):
             'There is %s file', 'There are %s files',
             numbers_only=False)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_plural_context_forms_wrong_domain(self):
         self._test_plural_forms(
             partial(gettext.dnpgettext, 'unknown', 'With context'),
@@ -526,8 +467,6 @@ def setUp(self):
         self.pgettext = t.pgettext
         self.npgettext = t.npgettext
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_plural_forms_null_translations(self):
         t = gettext.NullTranslations()
         self._test_plural_forms(
@@ -536,8 +475,6 @@ def test_plural_forms_null_translations(self):
             'There is %s file', 'There are %s files',
             numbers_only=False)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_plural_context_forms_null_translations(self):
         t = gettext.NullTranslations()
         self._test_plural_forms(
@@ -630,6 +567,7 @@ def test_ar(self):
         s = ''.join([ str(f(x)) for x in range(200) ])
         eq(s, "01233333333444444444444444444444444444444444444444444444444444444444444444444444444444444444444444445553333333344444444444444444444444444444444444444444444444444444444444444444444444444444444444444444")
 
+    @support.skip_wasi_stack_overflow()
     def test_security(self):
         raises = self.assertRaises
         # Test for a dangerous expression
@@ -994,6 +932,17 @@ def test__all__(self):
         support.check__all__(self, gettext,
                              not_exported={'c2py', 'ENOENT'})
 
+    @cpython_only
+    def test_lazy_import(self):
+        ensure_lazy_imports("gettext", {"re", "warnings", "locale"})
+
+
+class TranslationFallbackTestCase(unittest.TestCase):
+    def test_translation_fallback(self):
+        with os_helper.temp_cwd() as tempdir:
+            t = gettext.translation('gettext', localedir=tempdir, fallback=True)
+            self.assertIsInstance(t, gettext.NullTranslations)
+
 
 if __name__ == '__main__':
     unittest.main()
diff --git a/Lib/test/test_glob.py b/Lib/test/test_glob.py
index c3fb8939a69..d0ed5129253 100644
--- a/Lib/test/test_glob.py
+++ b/Lib/test/test_glob.py
@@ -459,111 +459,59 @@ def test_translate_matching(self):
     def test_translate(self):
         def fn(pat):
             return glob.translate(pat, seps='/')
-        self.assertEqual(fn('foo'), r'(?s:foo)\Z')
-        self.assertEqual(fn('foo/bar'), r'(?s:foo/bar)\Z')
-        self.assertEqual(fn('*'), r'(?s:[^/.][^/]*)\Z')
-        self.assertEqual(fn('?'), r'(?s:(?!\.)[^/])\Z')
-        self.assertEqual(fn('a*'), r'(?s:a[^/]*)\Z')
-        self.assertEqual(fn('*a'), r'(?s:(?!\.)[^/]*a)\Z')
-        self.assertEqual(fn('.*'), r'(?s:\.[^/]*)\Z')
-        self.assertEqual(fn('?aa'), r'(?s:(?!\.)[^/]aa)\Z')
-        self.assertEqual(fn('aa?'), r'(?s:aa[^/])\Z')
-        self.assertEqual(fn('aa[ab]'), r'(?s:aa[ab])\Z')
-        self.assertEqual(fn('**'), r'(?s:(?!\.)[^/]*)\Z')
-        self.assertEqual(fn('***'), r'(?s:(?!\.)[^/]*)\Z')
-        self.assertEqual(fn('a**'), r'(?s:a[^/]*)\Z')
-        self.assertEqual(fn('**b'), r'(?s:(?!\.)[^/]*b)\Z')
+        self.assertEqual(fn('foo'), r'(?s:foo)\z')
+        self.assertEqual(fn('foo/bar'), r'(?s:foo/bar)\z')
+        self.assertEqual(fn('*'), r'(?s:[^/.][^/]*)\z')
+        self.assertEqual(fn('?'), r'(?s:(?!\.)[^/])\z')
+        self.assertEqual(fn('a*'), r'(?s:a[^/]*)\z')
+        self.assertEqual(fn('*a'), r'(?s:(?!\.)[^/]*a)\z')
+        self.assertEqual(fn('.*'), r'(?s:\.[^/]*)\z')
+        self.assertEqual(fn('?aa'), r'(?s:(?!\.)[^/]aa)\z')
+        self.assertEqual(fn('aa?'), r'(?s:aa[^/])\z')
+        self.assertEqual(fn('aa[ab]'), r'(?s:aa[ab])\z')
+        self.assertEqual(fn('**'), r'(?s:(?!\.)[^/]*)\z')
+        self.assertEqual(fn('***'), r'(?s:(?!\.)[^/]*)\z')
+        self.assertEqual(fn('a**'), r'(?s:a[^/]*)\z')
+        self.assertEqual(fn('**b'), r'(?s:(?!\.)[^/]*b)\z')
         self.assertEqual(fn('/**/*/*.*/**'),
-                         r'(?s:/(?!\.)[^/]*/[^/.][^/]*/(?!\.)[^/]*\.[^/]*/(?!\.)[^/]*)\Z')
+                         r'(?s:/(?!\.)[^/]*/[^/.][^/]*/(?!\.)[^/]*\.[^/]*/(?!\.)[^/]*)\z')
 
     def test_translate_include_hidden(self):
         def fn(pat):
             return glob.translate(pat, include_hidden=True, seps='/')
-        self.assertEqual(fn('foo'), r'(?s:foo)\Z')
-        self.assertEqual(fn('foo/bar'), r'(?s:foo/bar)\Z')
-        self.assertEqual(fn('*'), r'(?s:[^/]+)\Z')
-        self.assertEqual(fn('?'), r'(?s:[^/])\Z')
-        self.assertEqual(fn('a*'), r'(?s:a[^/]*)\Z')
-        self.assertEqual(fn('*a'), r'(?s:[^/]*a)\Z')
-        self.assertEqual(fn('.*'), r'(?s:\.[^/]*)\Z')
-        self.assertEqual(fn('?aa'), r'(?s:[^/]aa)\Z')
-        self.assertEqual(fn('aa?'), r'(?s:aa[^/])\Z')
-        self.assertEqual(fn('aa[ab]'), r'(?s:aa[ab])\Z')
-        self.assertEqual(fn('**'), r'(?s:[^/]*)\Z')
-        self.assertEqual(fn('***'), r'(?s:[^/]*)\Z')
-        self.assertEqual(fn('a**'), r'(?s:a[^/]*)\Z')
-        self.assertEqual(fn('**b'), r'(?s:[^/]*b)\Z')
-        self.assertEqual(fn('/**/*/*.*/**'), r'(?s:/[^/]*/[^/]+/[^/]*\.[^/]*/[^/]*)\Z')
+        self.assertEqual(fn('foo'), r'(?s:foo)\z')
+        self.assertEqual(fn('foo/bar'), r'(?s:foo/bar)\z')
+        self.assertEqual(fn('*'), r'(?s:[^/]+)\z')
+        self.assertEqual(fn('?'), r'(?s:[^/])\z')
+        self.assertEqual(fn('a*'), r'(?s:a[^/]*)\z')
+        self.assertEqual(fn('*a'), r'(?s:[^/]*a)\z')
+        self.assertEqual(fn('.*'), r'(?s:\.[^/]*)\z')
+        self.assertEqual(fn('?aa'), r'(?s:[^/]aa)\z')
+        self.assertEqual(fn('aa?'), r'(?s:aa[^/])\z')
+        self.assertEqual(fn('aa[ab]'), r'(?s:aa[ab])\z')
+        self.assertEqual(fn('**'), r'(?s:[^/]*)\z')
+        self.assertEqual(fn('***'), r'(?s:[^/]*)\z')
+        self.assertEqual(fn('a**'), r'(?s:a[^/]*)\z')
+        self.assertEqual(fn('**b'), r'(?s:[^/]*b)\z')
+        self.assertEqual(fn('/**/*/*.*/**'), r'(?s:/[^/]*/[^/]+/[^/]*\.[^/]*/[^/]*)\z')
 
     def test_translate_recursive(self):
         def fn(pat):
             return glob.translate(pat, recursive=True, include_hidden=True, seps='/')
-        self.assertEqual(fn('*'), r'(?s:[^/]+)\Z')
-        self.assertEqual(fn('?'), r'(?s:[^/])\Z')
-        self.assertEqual(fn('**'), r'(?s:.*)\Z')
-        self.assertEqual(fn('**/**'), r'(?s:.*)\Z')
-        self.assertEqual(fn('***'), r'(?s:[^/]*)\Z')
-        self.assertEqual(fn('a**'), r'(?s:a[^/]*)\Z')
-        self.assertEqual(fn('**b'), r'(?s:[^/]*b)\Z')
-        self.assertEqual(fn('/**/*/*.*/**'), r'(?s:/(?:.+/)?[^/]+/[^/]*\.[^/]*/.*)\Z')
+        self.assertEqual(fn('*'), r'(?s:[^/]+)\z')
+        self.assertEqual(fn('?'), r'(?s:[^/])\z')
+        self.assertEqual(fn('**'), r'(?s:.*)\z')
+        self.assertEqual(fn('**/**'), r'(?s:.*)\z')
+        self.assertEqual(fn('***'), r'(?s:[^/]*)\z')
+        self.assertEqual(fn('a**'), r'(?s:a[^/]*)\z')
+        self.assertEqual(fn('**b'), r'(?s:[^/]*b)\z')
+        self.assertEqual(fn('/**/*/*.*/**'), r'(?s:/(?:.+/)?[^/]+/[^/]*\.[^/]*/.*)\z')
 
     def test_translate_seps(self):
         def fn(pat):
             return glob.translate(pat, recursive=True, include_hidden=True, seps=['/', '\\'])
-        self.assertEqual(fn('foo/bar\\baz'), r'(?s:foo[/\\]bar[/\\]baz)\Z')
-        self.assertEqual(fn('**/*'), r'(?s:(?:.+[/\\])?[^/\\]+)\Z')
-
-
-@skip_unless_symlink
-class SymlinkLoopGlobTests(unittest.TestCase):
-
-    # gh-109959: On Linux, glob._isdir() and glob._lexists() can return False
-    # randomly when checking the "link/" symbolic link.
-    # https://github.com/python/cpython/issues/109959#issuecomment-2577550700
-    @unittest.skip("flaky test")
-    def test_selflink(self):
-        tempdir = TESTFN + "_dir"
-        os.makedirs(tempdir)
-        self.addCleanup(shutil.rmtree, tempdir)
-        with change_cwd(tempdir):
-            os.makedirs('dir')
-            create_empty_file(os.path.join('dir', 'file'))
-            os.symlink(os.curdir, os.path.join('dir', 'link'))
-
-            results = glob.glob('**', recursive=True)
-            self.assertEqual(len(results), len(set(results)))
-            results = set(results)
-            depth = 0
-            while results:
-                path = os.path.join(*(['dir'] + ['link'] * depth))
-                self.assertIn(path, results)
-                results.remove(path)
-                if not results:
-                    break
-                path = os.path.join(path, 'file')
-                self.assertIn(path, results)
-                results.remove(path)
-                depth += 1
-
-            results = glob.glob(os.path.join('**', 'file'), recursive=True)
-            self.assertEqual(len(results), len(set(results)))
-            results = set(results)
-            depth = 0
-            while results:
-                path = os.path.join(*(['dir'] + ['link'] * depth + ['file']))
-                self.assertIn(path, results)
-                results.remove(path)
-                depth += 1
-
-            results = glob.glob(os.path.join('**', ''), recursive=True)
-            self.assertEqual(len(results), len(set(results)))
-            results = set(results)
-            depth = 0
-            while results:
-                path = os.path.join(*(['dir'] + ['link'] * depth + ['']))
-                self.assertIn(path, results)
-                results.remove(path)
-                depth += 1
+        self.assertEqual(fn('foo/bar\\baz'), r'(?s:foo[/\\]bar[/\\]baz)\z')
+        self.assertEqual(fn('**/*'), r'(?s:(?:.+[/\\])?[^/\\]+)\z')
 
 
 if __name__ == "__main__":
diff --git a/Lib/test/test_grammar.py b/Lib/test/test_grammar.py
index aae5c2b1ce3..77bd5a163ce 100644
--- a/Lib/test/test_grammar.py
+++ b/Lib/test/test_grammar.py
@@ -221,7 +221,6 @@ def test_ellipsis(self):
         self.assertTrue(x is Ellipsis)
         self.assertRaises(SyntaxError, eval, ".. .")
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_eof_error(self):
         samples = ("def foo(", "\ndef foo(", "def foo(\n")
         for s in samples:
diff --git a/Lib/test/test_gzip.py b/Lib/test/test_gzip.py
index 4a8813c4da1..ccbacc7c19b 100644
--- a/Lib/test/test_gzip.py
+++ b/Lib/test/test_gzip.py
@@ -1036,7 +1036,6 @@ def test_encoding_error_handler(self):
                 as f:
             self.assertEqual(f.read(), "foobar")
 
-    @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_hashlib.py b/Lib/test/test_hashlib.py
index cd9cbe9bff7..5c38813f3f5 100644
--- a/Lib/test/test_hashlib.py
+++ b/Lib/test/test_hashlib.py
@@ -1,6 +1,4 @@
-# Test hashlib module
-#
-# $Id$
+# Test the hashlib module.
 #
 #  Copyright (C) 2005-2010   Gregory P. Smith (greg@krypto.org)
 #  Licensed to PSF under a Contributor Agreement.
@@ -12,50 +10,46 @@
 import importlib
 import io
 import itertools
+import logging
 import os
+import re
 import sys
 import sysconfig
+import tempfile
 import threading
 import unittest
 import warnings
 from test import support
 from test.support import _4G, bigmemtest
+from test.support import hashlib_helper
 from test.support.import_helper import import_fresh_module
-from test.support import os_helper
+from test.support import requires_resource
 from test.support import threading_helper
-from test.support import warnings_helper
 from http.client import HTTPException
 
-# Were we compiled --with-pydebug or with #define Py_DEBUG?
-COMPILED_WITH_PYDEBUG = hasattr(sys, 'gettotalrefcount')
 
-# default builtin hash module
-default_builtin_hashes = {'md5', 'sha1', 'sha256', 'sha512', 'sha3', 'blake2'}
+default_builtin_hashes = {'md5', 'sha1', 'sha2', 'sha3', 'blake2'}
 # --with-builtin-hashlib-hashes override
 builtin_hashes = sysconfig.get_config_var("PY_BUILTIN_HASHLIB_HASHES")
 if builtin_hashes is None:
     builtin_hashes = default_builtin_hashes
 else:
-    builtin_hashes = {
-        m.strip() for m in builtin_hashes.strip('"').lower().split(",")
-    }
+    builtin_hash_names = builtin_hashes.strip('"').lower().split(",")
+    builtin_hashes = set(map(str.strip, builtin_hash_names))
 
-# hashlib with and without OpenSSL backend for PBKDF2
-# only import builtin_hashlib when all builtin hashes are available.
-# Otherwise import prints noise on stderr
+# Public 'hashlib' module with OpenSSL backend for PBKDF2.
 openssl_hashlib = import_fresh_module('hashlib', fresh=['_hashlib'])
-if builtin_hashes == default_builtin_hashes:
-    builtin_hashlib = import_fresh_module('hashlib', blocked=['_hashlib'])
-else:
-    builtin_hashlib = None
 
 try:
-    from _hashlib import HASH, HASHXOF, openssl_md_meth_names, get_fips_mode
+    import _hashlib
 except ImportError:
-    HASH = None
-    HASHXOF = None
-    openssl_md_meth_names = frozenset()
-
+    _hashlib = None
+# The extension module may exist but only define some of these. gh-141907
+HASH = getattr(_hashlib, 'HASH', None)
+HASHXOF = getattr(_hashlib, 'HASHXOF', None)
+openssl_md_meth_names = getattr(_hashlib, 'openssl_md_meth_names', frozenset())
+get_fips_mode = getattr(_hashlib, 'get_fips_mode', None)
+if not get_fips_mode:
     def get_fips_mode():
         return 0
 
@@ -66,9 +60,12 @@ def get_fips_mode():
 
 requires_blake2 = unittest.skipUnless(_blake2, 'requires _blake2')
 
-# bpo-46913: Don't test the _sha3 extension on a Python UBSAN build
-SKIP_SHA3 = support.check_sanitizer(ub=True)
-requires_sha3 = unittest.skipUnless(not SKIP_SHA3, 'requires _sha3')
+try:
+    import _sha3
+except ImportError:
+    _sha3 = None
+
+requires_sha3 = unittest.skipUnless(_sha3, 'requires _sha3')
 
 
 def hexstr(s):
@@ -108,8 +105,8 @@ class HashLibTestCase(unittest.TestCase):
 
     shakes = {'shake_128', 'shake_256'}
 
-    # Issue #14693: fallback modules are always compiled under POSIX
-    _warn_on_extension_import = os.name == 'posix' or COMPILED_WITH_PYDEBUG
+    # gh-58898: Fallback modules are always compiled under POSIX.
+    _warn_on_extension_import = (os.name == 'posix' or support.Py_DEBUG)
 
     def _conditional_import_module(self, module_name):
         """Import a module and return a reference to it or None on failure."""
@@ -117,7 +114,11 @@ def _conditional_import_module(self, module_name):
             return importlib.import_module(module_name)
         except ModuleNotFoundError as error:
             if self._warn_on_extension_import and module_name in builtin_hashes:
-                warnings.warn('Did a C extension fail to compile? %s' % error)
+                logging.getLogger(__name__).warning(
+                    'Did a C extension fail to compile? %s',
+                    error,
+                    exc_info=error,
+                )
         return None
 
     def __init__(self, *args, **kwargs):
@@ -131,27 +132,24 @@ def __init__(self, *args, **kwargs):
 
         self.constructors_to_test = {}
         for algorithm in algorithms:
-            if SKIP_SHA3 and algorithm.startswith('sha3_'):
-                continue
             self.constructors_to_test[algorithm] = set()
 
         # For each algorithm, test the direct constructor and the use
         # of hashlib.new given the algorithm name.
         for algorithm, constructors in self.constructors_to_test.items():
             constructors.add(getattr(hashlib, algorithm))
-            def _test_algorithm_via_hashlib_new(data=None, _alg=algorithm, **kwargs):
-                if data is None:
-                    return hashlib.new(_alg, **kwargs)
-                return hashlib.new(_alg, data, **kwargs)
-            constructors.add(_test_algorithm_via_hashlib_new)
+            def c(*args, __algorithm_name=algorithm, **kwargs):
+                return hashlib.new(__algorithm_name, *args, **kwargs)
+            c.__name__ = f'do_test_algorithm_via_hashlib_new_{algorithm}'
+            constructors.add(c)
 
         _hashlib = self._conditional_import_module('_hashlib')
         self._hashlib = _hashlib
         if _hashlib:
-            # These two algorithms should always be present when this module
+            # These algorithms should always be present when this module
             # is compiled.  If not, something was compiled wrong.
-            self.assertTrue(hasattr(_hashlib, 'openssl_md5'))
-            self.assertTrue(hasattr(_hashlib, 'openssl_sha1'))
+            self.assertHasAttr(_hashlib, 'openssl_md5')
+            self.assertHasAttr(_hashlib, 'openssl_sha1')
             for algorithm, constructors in self.constructors_to_test.items():
                 constructor = getattr(_hashlib, 'openssl_'+algorithm, None)
                 if constructor:
@@ -173,28 +171,24 @@ def add_builtin_constructor(name):
         _sha1 = self._conditional_import_module('_sha1')
         if _sha1:
             add_builtin_constructor('sha1')
-        _sha256 = self._conditional_import_module('_sha256')
-        if _sha256:
+        _sha2 = self._conditional_import_module('_sha2')
+        if _sha2:
             add_builtin_constructor('sha224')
             add_builtin_constructor('sha256')
-        _sha512 = self._conditional_import_module('_sha512')
-        if _sha512:
             add_builtin_constructor('sha384')
             add_builtin_constructor('sha512')
+        _sha3 = self._conditional_import_module('_sha3')
+        if _sha3:
+            add_builtin_constructor('sha3_224')
+            add_builtin_constructor('sha3_256')
+            add_builtin_constructor('sha3_384')
+            add_builtin_constructor('sha3_512')
+            add_builtin_constructor('shake_128')
+            add_builtin_constructor('shake_256')
         if _blake2:
             add_builtin_constructor('blake2s')
             add_builtin_constructor('blake2b')
 
-        if not SKIP_SHA3:
-            _sha3 = self._conditional_import_module('_sha3')
-            if _sha3:
-                add_builtin_constructor('sha3_224')
-                add_builtin_constructor('sha3_256')
-                add_builtin_constructor('sha3_384')
-                add_builtin_constructor('sha3_512')
-                add_builtin_constructor('shake_128')
-                add_builtin_constructor('shake_256')
-
         super(HashLibTestCase, self).__init__(*args, **kwargs)
 
     @property
@@ -252,6 +246,80 @@ def test_usedforsecurity_false(self):
             self._hashlib.new("md5", usedforsecurity=False)
             self._hashlib.openssl_md5(usedforsecurity=False)
 
+    @unittest.skipIf(get_fips_mode(), "skip in FIPS mode")
+    def test_clinic_signature(self):
+        for constructor in self.hash_constructors:
+            with self.subTest(constructor.__name__):
+                constructor(b'')
+                constructor(data=b'')
+                constructor(string=b'')  # should be deprecated in the future
+
+            digest_name = constructor(b'').name
+            with self.subTest(digest_name):
+                hashlib.new(digest_name, b'')
+                hashlib.new(digest_name, data=b'')
+                hashlib.new(digest_name, string=b'')
+                # Make sure that _hashlib contains the constructor
+                # to test when using a combination of libcrypto and
+                # interned hash implementations.
+                if self._hashlib and digest_name in self._hashlib._constructors:
+                    self._hashlib.new(digest_name, b'')
+                    self._hashlib.new(digest_name, data=b'')
+                    self._hashlib.new(digest_name, string=b'')
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; duplicate positional/keyword arg error message differs
+    @unittest.skipIf(get_fips_mode(), "skip in FIPS mode")
+    def test_clinic_signature_errors(self):
+        nomsg = b''
+        mymsg = b'msg'
+        conflicting_call = re.escape(
+            "'data' and 'string' are mutually exclusive "
+            "and support for 'string' keyword parameter "
+            "is slated for removal in a future version."
+        )
+        duplicated_param = re.escape("given by name ('data') and position")
+        unexpected_param = re.escape("got an unexpected keyword argument '_'")
+        for args, kwds, errmsg in [
+            # Reject duplicated arguments before unknown keyword arguments.
+            ((nomsg,), dict(data=nomsg, _=nomsg), duplicated_param),
+            ((mymsg,), dict(data=nomsg, _=nomsg), duplicated_param),
+            # Reject duplicated arguments before conflicting ones.
+            *itertools.product(
+                [[nomsg], [mymsg]],
+                [dict(data=nomsg), dict(data=nomsg, string=nomsg)],
+                [duplicated_param]
+            ),
+            # Reject unknown keyword arguments before conflicting ones.
+            *itertools.product(
+                [()],
+                [
+                    dict(_=None),
+                    dict(data=nomsg, _=None),
+                    dict(string=nomsg, _=None),
+                    dict(string=nomsg, data=nomsg, _=None),
+                ],
+                [unexpected_param]
+            ),
+            ((nomsg,), dict(_=None), unexpected_param),
+            ((mymsg,), dict(_=None), unexpected_param),
+            # Reject conflicting arguments.
+            [(nomsg,), dict(string=nomsg), conflicting_call],
+            [(mymsg,), dict(string=nomsg), conflicting_call],
+            [(), dict(data=nomsg, string=nomsg), conflicting_call],
+        ]:
+            for constructor in self.hash_constructors:
+                digest_name = constructor(b'').name
+                with self.subTest(constructor.__name__, args=args, kwds=kwds):
+                    with self.assertRaisesRegex(TypeError, errmsg):
+                        constructor(*args, **kwds)
+                with self.subTest(digest_name, args=args, kwds=kwds):
+                    with self.assertRaisesRegex(TypeError, errmsg):
+                        hashlib.new(digest_name, *args, **kwds)
+                    if (self._hashlib and
+                            digest_name in self._hashlib._constructors):
+                        with self.assertRaisesRegex(TypeError, errmsg):
+                            self._hashlib.new(digest_name, *args, **kwds)
+
     def test_unknown_hash(self):
         self.assertRaises(ValueError, hashlib.new, 'spam spam spam spam spam')
         self.assertRaises(TypeError, hashlib.new, 1)
@@ -259,6 +327,7 @@ def test_unknown_hash(self):
     def test_new_upper_to_lower(self):
         self.assertEqual(hashlib.new("SHA256").name, "sha256")
 
+    @support.thread_unsafe("modifies sys.modules")
     def test_get_builtin_constructor(self):
         get_builtin_constructor = getattr(hashlib,
                                           '__get_builtin_constructor')
@@ -295,8 +364,6 @@ def test_hexdigest(self):
                 self.assertIsInstance(h.digest(), bytes)
                 self.assertEqual(hexstr(h.digest()), h.hexdigest())
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_digest_length_overflow(self):
         # See issue #34922
         large_sizes = (2**29, 2**32-10, 2**32+10, 2**61, 2**64-10, 2**64+10)
@@ -358,6 +425,35 @@ def test_large_update(self):
             self.assertEqual(m1.digest(*args), m4_copy.digest(*args))
             self.assertEqual(m4.digest(*args), m4_digest)
 
+    @requires_resource('cpu')
+    def test_sha256_update_over_4gb(self):
+        zero_1mb = b"\0" * 1024 * 1024
+        h = hashlib.sha256()
+        for i in range(0, 4096):
+            h.update(zero_1mb)
+        h.update(b"hello world")
+        self.assertEqual(h.hexdigest(), "a5364f7a52ebe2e25f1838a4ca715a893b6fd7a23f2a0d9e9762120da8b1bf53")
+
+    @requires_resource('cpu')
+    def test_sha3_256_update_over_4gb(self):
+        zero_1mb = b"\0" * 1024 * 1024
+        h = hashlib.sha3_256()
+        for i in range(0, 4096):
+            h.update(zero_1mb)
+        h.update(b"hello world")
+        self.assertEqual(h.hexdigest(), "e2d4535e3b613135c14f2fe4e026d7ad8d569db44901740beffa30d430acb038")
+
+    @requires_resource('cpu')
+    def test_blake2_update_over_4gb(self):
+        # blake2s or blake2b doesn't matter based on how our C code is structured, this tests the
+        # common loop macro logic.
+        zero_1mb = b"\0" * 1024 * 1024
+        h = hashlib.blake2s()
+        for i in range(0, 4096):
+            h.update(zero_1mb)
+        h.update(b"hello world")
+        self.assertEqual(h.hexdigest(), "8a268e83dd30528bc0907fa2008c91de8f090a0b6e0e60a5ff0d999d8485526f")
+
     def check(self, name, data, hexdigest, shake=False, **kwargs):
         length = len(hexdigest)//2
         hexdigest = hexdigest.lower()
@@ -393,21 +489,18 @@ def check_file_digest(self, name, data, hexdigest):
         digests = [name]
         digests.extend(self.constructors_to_test[name])
 
-        with open(os_helper.TESTFN, "wb") as f:
+        with tempfile.TemporaryFile() as f:
             f.write(data)
 
-        try:
             for digest in digests:
                 buf = io.BytesIO(data)
                 buf.seek(0)
                 self.assertEqual(
                     hashlib.file_digest(buf, digest).hexdigest(), hexdigest
                 )
-                with open(os_helper.TESTFN, "rb") as f:
-                    digestobj = hashlib.file_digest(f, digest)
+                f.seek(0)
+                digestobj = hashlib.file_digest(f, digest)
                 self.assertEqual(digestobj.hexdigest(), hexdigest)
-        finally:
-            os.unlink(os_helper.TESTFN)
 
     def check_no_unicode(self, algorithm_name):
         # Unicode objects are not allowed as input.
@@ -454,9 +547,9 @@ def check_blocksize_name(self, name, block_size=0, digest_size=0,
                 self.assertEqual(len(m.hexdigest()), 2*digest_size)
             self.assertEqual(m.name, name)
             # split for sha3_512 / _sha3.sha3 object
-            self.assertIn(name.split("_")[0], repr(m))
+            self.assertIn(name.split("_")[0], repr(m).lower())
 
-    def test_blocksize_name(self):
+    def test_blocksize_and_name(self):
         self.check_blocksize_name('md5', 64, 16)
         self.check_blocksize_name('sha1', 64, 20)
         self.check_blocksize_name('sha224', 64, 28)
@@ -464,8 +557,6 @@ def test_blocksize_name(self):
         self.check_blocksize_name('sha384', 128, 48)
         self.check_blocksize_name('sha512', 128, 64)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     @requires_sha3
     def test_blocksize_name_sha3(self):
         self.check_blocksize_name('sha3_224', 144, 28)
@@ -479,16 +570,19 @@ def check_sha3(self, name, capacity, rate, suffix):
         constructors = self.constructors_to_test[name]
         for hash_object_constructor in constructors:
             m = hash_object_constructor()
-            if HASH is not None and isinstance(m, HASH):
-                # _hashopenssl's variant does not have extra SHA3 attributes
-                continue
+            if name.startswith('shake_'):
+                if HASHXOF is not None and isinstance(m, HASHXOF):
+                    # _hashopenssl's variant does not have extra SHA3 attributes
+                    continue
+            else:
+                if HASH is not None and isinstance(m, HASH):
+                    # _hashopenssl's variant does not have extra SHA3 attributes
+                    continue
             self.assertEqual(capacity + rate, 1600)
             self.assertEqual(m._capacity_bits, capacity)
             self.assertEqual(m._rate_bits, rate)
             self.assertEqual(m._suffix, suffix)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     @requires_sha3
     def test_extra_sha3(self):
         self.check_sha3('sha3_224', 448, 1152, b'\x06')
@@ -700,8 +794,6 @@ def check_blake2(self, constructor, salt_size, person_size, key_size,
         self.assertRaises(ValueError, constructor, node_offset=-1)
         self.assertRaises(OverflowError, constructor, node_offset=max_offset+1)
 
-        self.assertRaises(TypeError, constructor, data=b'')
-        self.assertRaises(TypeError, constructor, string=b'')
         self.assertRaises(TypeError, constructor, '')
 
         constructor(
@@ -741,8 +833,7 @@ def selftest_seq(length, seed):
                 outer.update(keyed.digest())
         return outer.hexdigest()
 
-    # TODO: RUSTPYTHON add to constructor const value
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; add to constructor const value
     @requires_blake2
     def test_blake2b(self):
         self.check_blake2(hashlib.blake2b, 16, 16, 64, 64, (1<<64)-1)
@@ -764,8 +855,7 @@ def test_case_blake2b_1(self):
           "ba80a53f981c4d0d6a2797b69f12f6e94c212f14685ac4b74b12bb6fdbffa2d1"+
           "7d87c5392aab792dc252d5de4533cc9518d38aa8dbf1925ab92386edd4009923")
 
-    # TODO: RUSTPYTHON implement all blake2 fields
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; implement all blake2 fields
     @requires_blake2
     def test_case_blake2b_all_parameters(self):
         # This checks that all the parameters work in general, and also that
@@ -784,15 +874,14 @@ def test_case_blake2b_all_parameters(self):
           inner_size=7,
           last_node=True)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; blake2 key parameter not supported
     @requires_blake2
     def test_blake2b_vectors(self):
         for msg, key, md in read_vectors('blake2b'):
             key = bytes.fromhex(key)
             self.check('blake2b', msg, md, key=key)
 
-    # TODO: RUSTPYTHON add to constructor const value
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; add to constructor const value
     @requires_blake2
     def test_blake2s(self):
         self.check_blake2(hashlib.blake2s, 8, 8, 32, 32, (1<<48)-1)
@@ -812,8 +901,7 @@ def test_case_blake2s_1(self):
         self.check('blake2s', b"abc",
           "508c5e8c327c14e2e1a72ba34eeb452f37458b209ed63a294d999b4c86675982")
 
-    # TODO: RUSTPYTHON implement all blake2 fields
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; implement all blake2 fields
     @requires_blake2
     def test_case_blake2s_all_parameters(self):
         # This checks that all the parameters work in general, and also that
@@ -832,7 +920,7 @@ def test_case_blake2s_all_parameters(self):
           inner_size=7,
           last_node=True)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; blake2 key parameter not supported
     @requires_blake2
     def test_blake2s_vectors(self):
         for msg, key, md in read_vectors('blake2s'):
@@ -903,10 +991,13 @@ def test_case_shake256_vector(self):
 
     def test_gil(self):
         # Check things work fine with an input larger than the size required
-        # for multithreaded operation (which is hardwired to 2048).
-        gil_minsize = 2048
-
+        # for multithreaded operation. Currently, all cryptographic modules
+        # have the same constant value (2048) but in the future it might not
+        # be the case.
+        mods = ['_md5', '_sha1', '_sha2', '_sha3', '_blake2', '_hashlib']
+        gil_minsize = hashlib_helper.find_gil_minsize(mods)
         for cons in self.hash_constructors:
+            # constructors belong to one of the above modules
             m = cons(usedforsecurity=False)
             m.update(b'1')
             m.update(b'#' * gil_minsize)
@@ -915,6 +1006,8 @@ def test_gil(self):
             m = cons(b'x' * gil_minsize, usedforsecurity=False)
             m.update(b'1')
 
+    def test_sha256_gil(self):
+        gil_minsize = hashlib_helper.find_gil_minsize(['_sha2', '_hashlib'])
         m = hashlib.sha256()
         m.update(b'1')
         m.update(b'#' * gil_minsize)
@@ -992,10 +1085,9 @@ def test_disallow_instantiation(self):
     def test_hash_disallow_instantiation(self):
         # internal types like _hashlib.HASH are not constructable
         support.check_disallow_instantiation(self, HASH)
-        support.check_disallow_instantiation(self, HASHXOF)
+        if HASHXOF is not None:
+            support.check_disallow_instantiation(self, HASHXOF)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_readonly_types(self):
         for algorithm, constructors in self.constructors_to_test.items():
             # all other types have DISALLOW_INSTANTIATION
@@ -1116,15 +1208,7 @@ def _test_pbkdf2_hmac(self, pbkdf2, supported):
                 iterations=1, dklen=None)
             self.assertEqual(out, self.pbkdf2_results['sha1'][0][0])
 
-    @unittest.skipIf(builtin_hashlib is None, "test requires builtin_hashlib")
-    def test_pbkdf2_hmac_py(self):
-        with warnings_helper.check_warnings():
-            self._test_pbkdf2_hmac(
-                builtin_hashlib.pbkdf2_hmac, builtin_hashes
-            )
-
-    @unittest.skipUnless(hasattr(openssl_hashlib, 'pbkdf2_hmac'),
-                     '   test requires OpenSSL > 1.0')
+    @unittest.skipIf(openssl_hashlib is None, "requires OpenSSL bindings")
     def test_pbkdf2_hmac_c(self):
         self._test_pbkdf2_hmac(openssl_hashlib.pbkdf2_hmac, openssl_md_meth_names)
 
@@ -1175,29 +1259,38 @@ def test_normalized_name(self):
     def test_file_digest(self):
         data = b'a' * 65536
         d1 = hashlib.sha256()
-        self.addCleanup(os.unlink, os_helper.TESTFN)
-        with open(os_helper.TESTFN, "wb") as f:
+        with tempfile.NamedTemporaryFile(delete_on_close=False) as fp:
             for _ in range(10):
                 d1.update(data)
-                f.write(data)
+                fp.write(data)
+            fp.close()
+
+            with open(fp.name, "rb") as f:
+                d2 = hashlib.file_digest(f, hashlib.sha256)
 
-        with open(os_helper.TESTFN, "rb") as f:
-            d2 = hashlib.file_digest(f, hashlib.sha256)
+            self.assertEqual(d1.hexdigest(), d2.hexdigest())
+            self.assertEqual(d1.name, d2.name)
+            self.assertIs(type(d1), type(d2))
 
-        self.assertEqual(d1.hexdigest(), d2.hexdigest())
-        self.assertEqual(d1.name, d2.name)
-        self.assertIs(type(d1), type(d2))
+            with self.assertRaises(ValueError):
+                with open(fp.name, "r") as f:
+                    hashlib.file_digest(f, "sha256")
+
+            with self.assertRaises(ValueError):
+                with open(fp.name, "wb") as f:
+                    hashlib.file_digest(f, "sha256")
 
         with self.assertRaises(ValueError):
             hashlib.file_digest(None, "sha256")
 
-        with self.assertRaises(ValueError):
-            with open(os_helper.TESTFN, "r") as f:
-                hashlib.file_digest(f, "sha256")
+        class NonBlocking:
+            def readinto(self, buf):
+                return None
+            def readable(self):
+                return True
 
-        with self.assertRaises(ValueError):
-            with open(os_helper.TESTFN, "wb") as f:
-                hashlib.file_digest(f, "sha256")
+        with self.assertRaises(BlockingIOError):
+            hashlib.file_digest(NonBlocking(), hashlib.sha256)
 
 
 if __name__ == "__main__":
diff --git a/Lib/test/test_hmac.py b/Lib/test/test_hmac.py
index 1726975e864..42b8db39271 100644
--- a/Lib/test/test_hmac.py
+++ b/Lib/test/test_hmac.py
@@ -1,149 +1,429 @@
+"""Test suite for HMAC.
+
+Python provides three different implementations of HMAC:
+
+- OpenSSL HMAC using OpenSSL hash functions.
+- HACL* HMAC using HACL* hash functions.
+- Generic Python HMAC using user-defined hash functions.
+
+The generic Python HMAC implementation is able to use OpenSSL
+callables or names, HACL* named hash functions or arbitrary
+objects implementing PEP 247 interface.
+
+In the two first cases, Python HMAC wraps a C HMAC object (either OpenSSL
+or HACL*-based). As a last resort, HMAC is re-implemented in pure Python.
+It is however interesting to test the pure Python implementation against
+the OpenSSL and HACL* hash functions.
+"""
+
 import binascii
 import functools
 import hmac
 import hashlib
+import random
+import types
 import unittest
-import unittest.mock
 import warnings
-
-from test.support import hashlib_helper, check_disallow_instantiation
-
 from _operator import _compare_digest as operator_compare_digest
+from test.support import _4G, bigmemtest
+from test.support import check_disallow_instantiation
+from test.support import hashlib_helper, import_helper
+from test.support.hashlib_helper import (
+    BuiltinHashFunctionsTrait,
+    HashFunctionsTrait,
+    NamedHashFunctionsTrait,
+    OpenSSLHashFunctionsTrait,
+)
+from test.support.import_helper import import_fresh_module
+from unittest.mock import patch
 
 try:
-    import _hashlib as _hashopenssl
-    from _hashlib import HMAC as C_HMAC
-    from _hashlib import hmac_new as c_hmac_new
+    import _hashlib
     from _hashlib import compare_digest as openssl_compare_digest
 except ImportError:
-    _hashopenssl = None
-    C_HMAC = None
-    c_hmac_new = None
+    _hashlib = None
     openssl_compare_digest = None
 
 try:
-    import _sha256 as sha256_module
+    import _sha2 as sha2
 except ImportError:
-    sha256_module = None
+    sha2 = None
 
 
-def ignore_warning(func):
-    @functools.wraps(func)
-    def wrapper(*args, **kwargs):
-        with warnings.catch_warnings():
-            warnings.filterwarnings("ignore",
-                                    category=DeprecationWarning)
-            return func(*args, **kwargs)
-    return wrapper
+def requires_builtin_sha2():
+    return unittest.skipIf(sha2 is None, "requires _sha2")
 
 
-class TestVectorsTestCase(unittest.TestCase):
+class ModuleMixin:
+    """Mixin with a HMAC module implementation."""
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    def assert_hmac_internals(
-            self, h, digest, hashname, digest_size, block_size
-    ):
-        self.assertEqual(h.hexdigest().upper(), digest.upper())
-        self.assertEqual(h.digest(), binascii.unhexlify(digest))
+    hmac = None
+
+
+class PyModuleMixin(ModuleMixin):
+    """Pure Python implementation of HMAC.
+
+    The underlying hash functions may be OpenSSL-based or HACL* based,
+    depending on whether OpenSSL is present or not.
+    """
+
+    @classmethod
+    def setUpClass(cls):
+        super().setUpClass()
+        cls.hmac = import_fresh_module('hmac', blocked=['_hashlib', '_hmac'])
+
+
+@hashlib_helper.requires_builtin_hmac()
+class BuiltinModuleMixin(ModuleMixin):
+    """Built-in HACL* implementation of HMAC."""
+
+    @classmethod
+    def setUpClass(cls):
+        super().setUpClass()
+        cls.hmac = import_fresh_module('_hmac')
+
+
+# Sentinel object used to detect whether a digestmod is given or not.
+DIGESTMOD_SENTINEL = object()
+
+
+class CreatorMixin:
+    """Mixin exposing a method creating a HMAC object."""
+
+    def hmac_new(self, key, msg=None, digestmod=DIGESTMOD_SENTINEL):
+        """Create a new HMAC object.
+
+        Implementations should accept arbitrary 'digestmod' as this
+        method can be used to test which exceptions are being raised.
+        """
+        raise NotImplementedError
+
+    def bind_hmac_new(self, digestmod):
+        """Return a specialization of hmac_new() with a bound digestmod."""
+        return functools.partial(self.hmac_new, digestmod=digestmod)
+
+
+class DigestMixin:
+    """Mixin exposing a method computing a HMAC digest."""
+
+    def hmac_digest(self, key, msg=None, digestmod=DIGESTMOD_SENTINEL):
+        """Compute a HMAC digest.
+
+        Implementations should accept arbitrary 'digestmod' as this
+        method can be used to test which exceptions are being raised.
+        """
+        raise NotImplementedError
+
+    def bind_hmac_digest(self, digestmod):
+        """Return a specialization of hmac_digest() with a bound digestmod."""
+        return functools.partial(self.hmac_digest, digestmod=digestmod)
+
+
+def _call_newobj_func(new_func, key, msg, digestmod):
+    if digestmod is DIGESTMOD_SENTINEL:  # to test when digestmod is missing
+        return new_func(key, msg)  # expected to raise
+    # functions creating HMAC objects take a 'digestmod' keyword argument
+    return new_func(key, msg, digestmod=digestmod)
+
+
+def _call_digest_func(digest_func, key, msg, digestmod):
+    if digestmod is DIGESTMOD_SENTINEL:  # to test when digestmod is missing
+        return digest_func(key, msg)  # expected to raise
+    # functions directly computing digests take a 'digest' keyword argument
+    return digest_func(key, msg, digest=digestmod)
+
+
+class ThroughObjectMixin(ModuleMixin, CreatorMixin, DigestMixin):
+    """Mixin delegating to <module>.HMAC() and <module>.HMAC(...).digest().
+
+    Both the C implementation and the Python implementation of HMAC should
+    expose a HMAC class with the same functionalities.
+    """
+
+    def hmac_new(self, key, msg=None, digestmod=DIGESTMOD_SENTINEL):
+        """Create a HMAC object via a module-level class constructor."""
+        return _call_newobj_func(self.hmac.HMAC, key, msg, digestmod)
+
+    def hmac_digest(self, key, msg=None, digestmod=DIGESTMOD_SENTINEL):
+        """Call the digest() method on a HMAC object obtained by hmac_new()."""
+        return _call_newobj_func(self.hmac_new, key, msg, digestmod).digest()
+
+
+class ThroughModuleAPIMixin(ModuleMixin, CreatorMixin, DigestMixin):
+    """Mixin delegating to <module>.new() and <module>.digest()."""
+
+    def hmac_new(self, key, msg=None, digestmod=DIGESTMOD_SENTINEL):
+        """Create a HMAC object via a module-level function."""
+        return _call_newobj_func(self.hmac.new, key, msg, digestmod)
+
+    def hmac_digest(self, key, msg=None, digestmod=DIGESTMOD_SENTINEL):
+        """One-shot HMAC digest computation."""
+        return _call_digest_func(self.hmac.digest, key, msg, digestmod)
+
+
+@hashlib_helper.requires_hashlib()
+class ThroughOpenSSLAPIMixin(CreatorMixin, DigestMixin):
+    """Mixin delegating to _hashlib.hmac_new() and _hashlib.hmac_digest()."""
+
+    def hmac_new(self, key, msg=None, digestmod=DIGESTMOD_SENTINEL):
+        return _call_newobj_func(_hashlib.hmac_new, key, msg, digestmod)
+
+    def hmac_digest(self, key, msg=None, digestmod=DIGESTMOD_SENTINEL):
+        return _call_digest_func(_hashlib.hmac_digest, key, msg, digestmod)
+
+
+class ThroughBuiltinAPIMixin(BuiltinModuleMixin, CreatorMixin, DigestMixin):
+    """Mixin delegating to _hmac.new() and _hmac.compute_digest()."""
+
+    def hmac_new(self, key, msg=None, digestmod=DIGESTMOD_SENTINEL):
+        return _call_newobj_func(self.hmac.new, key, msg, digestmod)
+
+    def hmac_digest(self, key, msg=None, digestmod=DIGESTMOD_SENTINEL):
+        return _call_digest_func(self.hmac.compute_digest, key, msg, digestmod)
+
+
+class ObjectCheckerMixin:
+    """Mixin for checking HMAC objects (pure Python, OpenSSL or built-in)."""
+
+    def check_object(self, h, hexdigest, hashname, digest_size, block_size):
+        """Check a HMAC object 'h' against the given values."""
+        self.check_internals(h, hashname, digest_size, block_size)
+        self.check_hexdigest(h, hexdigest, digest_size)
+
+    def check_internals(self, h, hashname, digest_size, block_size):
+        """Check the constant attributes of a HMAC object."""
         self.assertEqual(h.name, f"hmac-{hashname}")
         self.assertEqual(h.digest_size, digest_size)
         self.assertEqual(h.block_size, block_size)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    def check_hexdigest(self, h, hexdigest, digest_size):
+        """Check the HMAC digest of 'h' and its size."""
+        self.assertEqual(len(h.digest()), digest_size)
+        self.assertEqual(h.digest(), binascii.unhexlify(hexdigest))
+        self.assertEqual(h.hexdigest().upper(), hexdigest.upper())
+
+
+class AssertersMixin(CreatorMixin, DigestMixin, ObjectCheckerMixin):
+    """Mixin class for common tests."""
+
+    def hmac_new_by_name(self, key, msg=None, *, hashname):
+        """Alternative implementation of hmac_new().
+
+        This is typically useful when one needs to test against an HMAC
+        implementation which only recognizes underlying hash functions
+        by their name (all HMAC implementations must at least recognize
+        hash functions by their names but some may use aliases such as
+        `hashlib.sha1` instead of "sha1").
+
+        Unlike hmac_new(), this method may assert the type of 'hashname'
+        as it should only be used in tests that are expected to create
+        a HMAC object.
+        """
+        self.assertIsInstance(hashname, str)
+        return self.hmac_new(key, msg, digestmod=hashname)
+
+    def hmac_digest_by_name(self, key, msg=None, *, hashname):
+        """Alternative implementation of hmac_digest().
+
+        Unlike hmac_digest(), this method may assert the type of 'hashname'
+        as it should only be used in tests that are expected to compute a
+        HMAC digest.
+        """
+        self.assertIsInstance(hashname, str)
+        return self.hmac_digest(key, msg, digestmod=hashname)
+
     def assert_hmac(
-        self, key, data, digest, hashfunc, hashname, digest_size, block_size
+        self, key, msg, hexdigest, hashfunc, hashname, digest_size, block_size
     ):
-        h = hmac.HMAC(key, data, digestmod=hashfunc)
-        self.assert_hmac_internals(
-            h, digest, hashname, digest_size, block_size
+        """Check that HMAC(key, msg) == digest.
+
+        The 'hashfunc' and 'hashname' are used as 'digestmod' values,
+        thereby allowing to test the underlying dispatching mechanism.
+
+        Note that 'hashfunc' may be a string, a callable, or a PEP-257
+        module. Note that not all HMAC implementations may recognize the
+        same set of types for 'hashfunc', but they should always accept
+        a hash function by its name.
+        """
+        if hashfunc == hashname:
+            choices = [hashname]
+        else:
+            choices = [hashfunc, hashname]
+
+        for digestmod in choices:
+            with self.subTest(digestmod=digestmod):
+                self.assert_hmac_new(
+                    key, msg, hexdigest, digestmod,
+                    hashname, digest_size, block_size
+                )
+                self.assert_hmac_hexdigest(
+                    key, msg, hexdigest, digestmod, digest_size
+                )
+                self.assert_hmac_common_cases(
+                    key, msg, hexdigest, digestmod,
+                    hashname, digest_size, block_size
+                )
+                self.assert_hmac_extra_cases(
+                    key, msg, hexdigest, digestmod,
+                    hashname, digest_size, block_size
+                )
+
+        self.assert_hmac_new_by_name(
+            key, msg, hexdigest, hashname, digest_size, block_size
+        )
+        self.assert_hmac_hexdigest_by_name(
+            key, msg, hexdigest, hashname, digest_size
         )
 
-        h = hmac.HMAC(key, data, digestmod=hashname)
-        self.assert_hmac_internals(
-            h, digest, hashname, digest_size, block_size
+    def assert_hmac_new(
+        self, key, msg, hexdigest, digestmod, hashname, digest_size, block_size
+    ):
+        """Check that HMAC(key, msg) == digest.
+
+        This test uses the `hmac_new()` method to create HMAC objects.
+        """
+        self.check_hmac_new(
+            key, msg, hexdigest, hashname, digest_size, block_size,
+            hmac_new_func=self.hmac_new,
+            hmac_new_kwds={'digestmod': digestmod},
         )
 
-        h = hmac.HMAC(key, digestmod=hashname)
-        h2 = h.copy()
-        h2.update(b"test update")
-        h.update(data)
-        self.assertEqual(h.hexdigest().upper(), digest.upper())
+    def assert_hmac_new_by_name(
+        self, key, msg, hexdigest, hashname, digest_size, block_size
+    ):
+        """Check that HMAC(key, msg) == digest.
+
+        This test uses the `hmac_new_by_name()` method to create HMAC objects.
+        """
+        self.check_hmac_new(
+            key, msg, hexdigest, hashname, digest_size, block_size,
+            hmac_new_func=self.hmac_new_by_name,
+            hmac_new_kwds={'hashname': hashname},
+        )
 
-        h = hmac.new(key, data, digestmod=hashname)
-        self.assert_hmac_internals(
-            h, digest, hashname, digest_size, block_size
+    def check_hmac_new(
+        self, key, msg, hexdigest, hashname, digest_size, block_size,
+        hmac_new_func, hmac_new_kwds=types.MappingProxyType({}),
+    ):
+        """Check that HMAC(key, msg) == digest.
+
+        This also tests that using an empty/None initial message and
+        then calling `h.update(msg)` produces the same result, namely
+        that HMAC(key, msg) is equivalent to HMAC(key).update(msg).
+        """
+        h = hmac_new_func(key, msg, **hmac_new_kwds)
+        self.check_object(h, hexdigest, hashname, digest_size, block_size)
+
+        def hmac_new_feed(*args):
+            h = hmac_new_func(key, *args, **hmac_new_kwds)
+            h.update(msg)
+            self.check_hexdigest(h, hexdigest, digest_size)
+
+        with self.subTest('no initial message'):
+            hmac_new_feed()
+        with self.subTest('initial message is empty'):
+            hmac_new_feed(b'')
+        with self.subTest('initial message is None'):
+            hmac_new_feed(None)
+
+    def assert_hmac_hexdigest(
+        self, key, msg, hexdigest, digestmod, digest_size,
+    ):
+        """Check a HMAC digest computed by hmac_digest()."""
+        self.check_hmac_hexdigest(
+            key, msg, hexdigest, digest_size,
+            hmac_digest_func=self.hmac_digest,
+            hmac_digest_kwds={'digestmod': digestmod},
         )
 
-        h = hmac.new(key, None, digestmod=hashname)
-        h.update(data)
-        self.assertEqual(h.hexdigest().upper(), digest.upper())
+    def assert_hmac_hexdigest_by_name(
+        self, key, msg, hexdigest, hashname, digest_size
+    ):
+        """Check a HMAC digest computed by hmac_digest_by_name()."""
+        self.assertIsInstance(hashname, str)
+        self.check_hmac_hexdigest(
+            key, msg, hexdigest, digest_size,
+            hmac_digest_func=self.hmac_digest_by_name,
+            hmac_digest_kwds={'hashname': hashname},
+        )
 
-        h = hmac.new(key, digestmod=hashname)
-        h.update(data)
-        self.assertEqual(h.hexdigest().upper(), digest.upper())
+    def check_hmac_hexdigest(
+        self, key, msg, hexdigest, digest_size,
+        hmac_digest_func, hmac_digest_kwds=types.MappingProxyType({}),
+    ):
+        """Check and return a HMAC digest computed by hmac_digest_func().
 
-        h = hmac.new(key, data, digestmod=hashfunc)
-        self.assertEqual(h.hexdigest().upper(), digest.upper())
+        This HMAC digest is computed by:
 
-        self.assertEqual(
-            hmac.digest(key, data, digest=hashname),
-            binascii.unhexlify(digest)
-        )
-        self.assertEqual(
-            hmac.digest(key, data, digest=hashfunc),
-            binascii.unhexlify(digest)
-        )
+            hmac_digest_func(key, msg, **hmac_digest_kwds)
 
-        h = hmac.HMAC.__new__(hmac.HMAC)
-        h._init_old(key, data, digestmod=hashname)
-        self.assert_hmac_internals(
-            h, digest, hashname, digest_size, block_size
-        )
+        This is typically useful for checking one-shot HMAC functions.
+        """
+        d = hmac_digest_func(key, msg, **hmac_digest_kwds)
+        self.assertEqual(len(d), digest_size)
+        self.assertEqual(d, binascii.unhexlify(hexdigest))
+        return d
 
-        if c_hmac_new is not None:
-            h = c_hmac_new(key, data, digestmod=hashname)
-            self.assert_hmac_internals(
-                h, digest, hashname, digest_size, block_size
-            )
+    def assert_hmac_common_cases(
+        self, key, msg, hexdigest, digestmod, hashname, digest_size, block_size
+    ):
+        """Common tests executed by all subclasses."""
+        h1 = self.hmac_new_by_name(key, hashname=hashname)
+        h2 = h1.copy()
+        h2.update(b"test update should not affect original")
+        h1.update(msg)
+        self.check_object(h1, hexdigest, hashname, digest_size, block_size)
 
-            h = c_hmac_new(key, digestmod=hashname)
-            h2 = h.copy()
-            h2.update(b"test update")
-            h.update(data)
-            self.assertEqual(h.hexdigest().upper(), digest.upper())
+    def assert_hmac_extra_cases(
+        self, key, msg, hexdigest, digestmod, hashname, digest_size, block_size
+    ):
+        """Extra tests that can be added in subclasses."""
 
-            func = getattr(_hashopenssl, f"openssl_{hashname}")
-            h = c_hmac_new(key, data, digestmod=func)
-            self.assert_hmac_internals(
-                h, digest, hashname, digest_size, block_size
-            )
 
-            h = hmac.HMAC.__new__(hmac.HMAC)
-            h._init_hmac(key, data, digestmod=hashname)
-            self.assert_hmac_internals(
-                h, digest, hashname, digest_size, block_size
-            )
+class PyAssertersMixin(PyModuleMixin, AssertersMixin):
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    @hashlib_helper.requires_hashdigest('md5', openssl=True)
-    def test_md5_vectors(self):
-        # Test the HMAC module against test vectors from the RFC.
+    def assert_hmac_extra_cases(
+        self, key, msg, hexdigest, digestmod, hashname, digest_size, block_size
+    ):
+        h = self.hmac.HMAC.__new__(self.hmac.HMAC)
+        h._init_old(key, msg, digestmod=digestmod)
+        self.check_object(h, hexdigest, hashname, digest_size, block_size)
+
+
+class OpenSSLAssertersMixin(ThroughOpenSSLAPIMixin, AssertersMixin):
+
+    def hmac_new_by_name(self, key, msg=None, *, hashname):
+        self.assertIsInstance(hashname, str)
+        openssl_func = getattr(_hashlib, f"openssl_{hashname}")
+        return self.hmac_new(key, msg, digestmod=openssl_func)
+
+    def hmac_digest_by_name(self, key, msg=None, *, hashname):
+        self.assertIsInstance(hashname, str)
+        openssl_func = getattr(_hashlib, f"openssl_{hashname}")
+        return self.hmac_digest(key, msg, digestmod=openssl_func)
 
-        def md5test(key, data, digest):
-            self.assert_hmac(
-                key, data, digest,
-                hashfunc=hashlib.md5,
-                hashname="md5",
-                digest_size=16,
-                block_size=64
-            )
+
+class BuiltinAssertersMixin(ThroughBuiltinAPIMixin, AssertersMixin):
+    pass
+
+
+class RFCTestCaseMixin(HashFunctionsTrait, AssertersMixin):
+    """Test HMAC implementations against RFC 2202/4231 and NIST test vectors.
+
+    - Test vectors for MD5 and SHA-1 are taken from RFC 2202.
+    - Test vectors for SHA-2 are taken from RFC 4231.
+    - Test vectors for SHA-3 are NIST's test vectors [1].
+
+    [1] https://csrc.nist.gov/projects/message-authentication-codes
+    """
+
+    def test_md5_rfc2202(self):
+        def md5test(key, msg, hexdigest):
+            self.assert_hmac(key, msg, hexdigest, self.md5, "md5", 16, 64)
 
         md5test(b"\x0b" * 16,
                 b"Hi There",
-                "9294727A3638BB1C13F48EF8158BFC9D")
+                "9294727a3638bb1c13f48ef8158bfc9d")
 
         md5test(b"Jefe",
                 b"what do ya want for nothing?",
@@ -170,18 +450,9 @@ def md5test(key, data, digest):
                  b"and Larger Than One Block-Size Data"),
                 "6f630fad67cda0ee1fb1f562db3aa53e")
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    @hashlib_helper.requires_hashdigest('sha1', openssl=True)
-    def test_sha_vectors(self):
-        def shatest(key, data, digest):
-            self.assert_hmac(
-                key, data, digest,
-                hashfunc=hashlib.sha1,
-                hashname="sha1",
-                digest_size=20,
-                block_size=64
-            )
+    def test_sha1_rfc2202(self):
+        def shatest(key, msg, hexdigest):
+            self.assert_hmac(key, msg, hexdigest, self.sha1, "sha1", 20, 64)
 
         shatest(b"\x0b" * 20,
                 b"Hi There",
@@ -212,498 +483,1152 @@ def shatest(key, data, digest):
                  b"and Larger Than One Block-Size Data"),
                 "e8e99d0f45237d786d6bbaa7965c7808bbff1a91")
 
-    def _rfc4231_test_cases(self, hashfunc, hash_name, digest_size, block_size):
-        def hmactest(key, data, hexdigests):
-            digest = hexdigests[hashfunc]
+    def test_sha2_224_rfc4231(self):
+        self._test_sha2_rfc4231(self.sha224, 'sha224', 28, 64)
+
+    def test_sha2_256_rfc4231(self):
+        self._test_sha2_rfc4231(self.sha256, 'sha256', 32, 64)
+
+    def test_sha2_384_rfc4231(self):
+        self._test_sha2_rfc4231(self.sha384, 'sha384', 48, 128)
+
+    def test_sha2_512_rfc4231(self):
+        self._test_sha2_rfc4231(self.sha512, 'sha512', 64, 128)
+
+    def _test_sha2_rfc4231(self, hashfunc, hashname, digest_size, block_size):
+        def hmactest(key, msg, hexdigests):
+            hexdigest = hexdigests[hashname]
 
             self.assert_hmac(
-                key, data, digest,
+                key, msg, hexdigest,
                 hashfunc=hashfunc,
-                hashname=hash_name,
+                hashname=hashname,
                 digest_size=digest_size,
                 block_size=block_size
             )
 
         # 4.2.  Test Case 1
-        hmactest(key = b'\x0b'*20,
-                 data = b'Hi There',
-                 hexdigests = {
-                   hashlib.sha224: '896fb1128abbdf196832107cd49df33f'
-                                   '47b4b1169912ba4f53684b22',
-                   hashlib.sha256: 'b0344c61d8db38535ca8afceaf0bf12b'
-                                   '881dc200c9833da726e9376c2e32cff7',
-                   hashlib.sha384: 'afd03944d84895626b0825f4ab46907f'
-                                   '15f9dadbe4101ec682aa034c7cebc59c'
-                                   'faea9ea9076ede7f4af152e8b2fa9cb6',
-                   hashlib.sha512: '87aa7cdea5ef619d4ff0b4241a1d6cb0'
-                                   '2379f4e2ce4ec2787ad0b30545e17cde'
-                                   'daa833b7d6b8a702038b274eaea3f4e4'
-                                   'be9d914eeb61f1702e696c203a126854',
+        hmactest(key=b'\x0b' * 20,
+                 msg=b'Hi There',
+                 hexdigests={
+                     'sha224': '896fb1128abbdf196832107cd49df33f'
+                               '47b4b1169912ba4f53684b22',
+                     'sha256': 'b0344c61d8db38535ca8afceaf0bf12b'
+                               '881dc200c9833da726e9376c2e32cff7',
+                     'sha384': 'afd03944d84895626b0825f4ab46907f'
+                               '15f9dadbe4101ec682aa034c7cebc59c'
+                               'faea9ea9076ede7f4af152e8b2fa9cb6',
+                     'sha512': '87aa7cdea5ef619d4ff0b4241a1d6cb0'
+                               '2379f4e2ce4ec2787ad0b30545e17cde'
+                               'daa833b7d6b8a702038b274eaea3f4e4'
+                               'be9d914eeb61f1702e696c203a126854',
                  })
 
         # 4.3.  Test Case 2
-        hmactest(key = b'Jefe',
-                 data = b'what do ya want for nothing?',
-                 hexdigests = {
-                   hashlib.sha224: 'a30e01098bc6dbbf45690f3a7e9e6d0f'
-                                   '8bbea2a39e6148008fd05e44',
-                   hashlib.sha256: '5bdcc146bf60754e6a042426089575c7'
-                                   '5a003f089d2739839dec58b964ec3843',
-                   hashlib.sha384: 'af45d2e376484031617f78d2b58a6b1b'
-                                   '9c7ef464f5a01b47e42ec3736322445e'
-                                   '8e2240ca5e69e2c78b3239ecfab21649',
-                   hashlib.sha512: '164b7a7bfcf819e2e395fbe73b56e0a3'
-                                   '87bd64222e831fd610270cd7ea250554'
-                                   '9758bf75c05a994a6d034f65f8f0e6fd'
-                                   'caeab1a34d4a6b4b636e070a38bce737',
+        hmactest(key=b'Jefe',
+                 msg=b'what do ya want for nothing?',
+                 hexdigests={
+                     'sha224': 'a30e01098bc6dbbf45690f3a7e9e6d0f'
+                               '8bbea2a39e6148008fd05e44',
+                     'sha256': '5bdcc146bf60754e6a042426089575c7'
+                               '5a003f089d2739839dec58b964ec3843',
+                     'sha384': 'af45d2e376484031617f78d2b58a6b1b'
+                               '9c7ef464f5a01b47e42ec3736322445e'
+                               '8e2240ca5e69e2c78b3239ecfab21649',
+                     'sha512': '164b7a7bfcf819e2e395fbe73b56e0a3'
+                               '87bd64222e831fd610270cd7ea250554'
+                               '9758bf75c05a994a6d034f65f8f0e6fd'
+                               'caeab1a34d4a6b4b636e070a38bce737',
                  })
 
         # 4.4.  Test Case 3
-        hmactest(key = b'\xaa'*20,
-                 data = b'\xdd'*50,
-                 hexdigests = {
-                   hashlib.sha224: '7fb3cb3588c6c1f6ffa9694d7d6ad264'
-                                   '9365b0c1f65d69d1ec8333ea',
-                   hashlib.sha256: '773ea91e36800e46854db8ebd09181a7'
-                                   '2959098b3ef8c122d9635514ced565fe',
-                   hashlib.sha384: '88062608d3e6ad8a0aa2ace014c8a86f'
-                                   '0aa635d947ac9febe83ef4e55966144b'
-                                   '2a5ab39dc13814b94e3ab6e101a34f27',
-                   hashlib.sha512: 'fa73b0089d56a284efb0f0756c890be9'
-                                   'b1b5dbdd8ee81a3655f83e33b2279d39'
-                                   'bf3e848279a722c806b485a47e67c807'
-                                   'b946a337bee8942674278859e13292fb',
+        hmactest(key=b'\xaa' * 20,
+                 msg=b'\xdd' * 50,
+                 hexdigests={
+                     'sha224': '7fb3cb3588c6c1f6ffa9694d7d6ad264'
+                               '9365b0c1f65d69d1ec8333ea',
+                     'sha256': '773ea91e36800e46854db8ebd09181a7'
+                               '2959098b3ef8c122d9635514ced565fe',
+                     'sha384': '88062608d3e6ad8a0aa2ace014c8a86f'
+                               '0aa635d947ac9febe83ef4e55966144b'
+                               '2a5ab39dc13814b94e3ab6e101a34f27',
+                     'sha512': 'fa73b0089d56a284efb0f0756c890be9'
+                               'b1b5dbdd8ee81a3655f83e33b2279d39'
+                               'bf3e848279a722c806b485a47e67c807'
+                               'b946a337bee8942674278859e13292fb',
                  })
 
         # 4.5.  Test Case 4
-        hmactest(key = bytes(x for x in range(0x01, 0x19+1)),
-                 data = b'\xcd'*50,
-                 hexdigests = {
-                   hashlib.sha224: '6c11506874013cac6a2abc1bb382627c'
-                                   'ec6a90d86efc012de7afec5a',
-                   hashlib.sha256: '82558a389a443c0ea4cc819899f2083a'
-                                   '85f0faa3e578f8077a2e3ff46729665b',
-                   hashlib.sha384: '3e8a69b7783c25851933ab6290af6ca7'
-                                   '7a9981480850009cc5577c6e1f573b4e'
-                                   '6801dd23c4a7d679ccf8a386c674cffb',
-                   hashlib.sha512: 'b0ba465637458c6990e5a8c5f61d4af7'
-                                   'e576d97ff94b872de76f8050361ee3db'
-                                   'a91ca5c11aa25eb4d679275cc5788063'
-                                   'a5f19741120c4f2de2adebeb10a298dd',
+        hmactest(key=bytes(x for x in range(0x01, 0x19 + 1)),
+                 msg=b'\xcd' * 50,
+                 hexdigests={
+                     'sha224': '6c11506874013cac6a2abc1bb382627c'
+                               'ec6a90d86efc012de7afec5a',
+                     'sha256': '82558a389a443c0ea4cc819899f2083a'
+                               '85f0faa3e578f8077a2e3ff46729665b',
+                     'sha384': '3e8a69b7783c25851933ab6290af6ca7'
+                               '7a9981480850009cc5577c6e1f573b4e'
+                               '6801dd23c4a7d679ccf8a386c674cffb',
+                     'sha512': 'b0ba465637458c6990e5a8c5f61d4af7'
+                               'e576d97ff94b872de76f8050361ee3db'
+                               'a91ca5c11aa25eb4d679275cc5788063'
+                               'a5f19741120c4f2de2adebeb10a298dd',
                  })
 
         # 4.7.  Test Case 6
-        hmactest(key = b'\xaa'*131,
-                 data = b'Test Using Larger Than Block-Siz'
-                        b'e Key - Hash Key First',
-                 hexdigests = {
-                   hashlib.sha224: '95e9a0db962095adaebe9b2d6f0dbce2'
-                                   'd499f112f2d2b7273fa6870e',
-                   hashlib.sha256: '60e431591ee0b67f0d8a26aacbf5b77f'
-                                   '8e0bc6213728c5140546040f0ee37f54',
-                   hashlib.sha384: '4ece084485813e9088d2c63a041bc5b4'
-                                   '4f9ef1012a2b588f3cd11f05033ac4c6'
-                                   '0c2ef6ab4030fe8296248df163f44952',
-                   hashlib.sha512: '80b24263c7c1a3ebb71493c1dd7be8b4'
-                                   '9b46d1f41b4aeec1121b013783f8f352'
-                                   '6b56d037e05f2598bd0fd2215d6a1e52'
-                                   '95e64f73f63f0aec8b915a985d786598',
+        hmactest(key=b'\xaa' * 131,
+                 msg=b'Test Using Larger Than Block-Siz'
+                     b'e Key - Hash Key First',
+                 hexdigests={
+                     'sha224': '95e9a0db962095adaebe9b2d6f0dbce2'
+                               'd499f112f2d2b7273fa6870e',
+                     'sha256': '60e431591ee0b67f0d8a26aacbf5b77f'
+                               '8e0bc6213728c5140546040f0ee37f54',
+                     'sha384': '4ece084485813e9088d2c63a041bc5b4'
+                               '4f9ef1012a2b588f3cd11f05033ac4c6'
+                               '0c2ef6ab4030fe8296248df163f44952',
+                     'sha512': '80b24263c7c1a3ebb71493c1dd7be8b4'
+                               '9b46d1f41b4aeec1121b013783f8f352'
+                               '6b56d037e05f2598bd0fd2215d6a1e52'
+                               '95e64f73f63f0aec8b915a985d786598',
                  })
 
         # 4.8.  Test Case 7
-        hmactest(key = b'\xaa'*131,
-                 data = b'This is a test using a larger th'
-                        b'an block-size key and a larger t'
-                        b'han block-size data. The key nee'
-                        b'ds to be hashed before being use'
-                        b'd by the HMAC algorithm.',
-                 hexdigests = {
-                   hashlib.sha224: '3a854166ac5d9f023f54d517d0b39dbd'
-                                   '946770db9c2b95c9f6f565d1',
-                   hashlib.sha256: '9b09ffa71b942fcb27635fbcd5b0e944'
-                                   'bfdc63644f0713938a7f51535c3a35e2',
-                   hashlib.sha384: '6617178e941f020d351e2f254e8fd32c'
-                                   '602420feb0b8fb9adccebb82461e99c5'
-                                   'a678cc31e799176d3860e6110c46523e',
-                   hashlib.sha512: 'e37b6a775dc87dbaa4dfa9f96e5e3ffd'
-                                   'debd71f8867289865df5a32d20cdc944'
-                                   'b6022cac3c4982b10d5eeb55c3e4de15'
-                                   '134676fb6de0446065c97440fa8c6a58',
+        hmactest(key=b'\xaa' * 131,
+                 msg=b'This is a test using a larger th'
+                     b'an block-size key and a larger t'
+                     b'han block-size data. The key nee'
+                     b'ds to be hashed before being use'
+                     b'd by the HMAC algorithm.',
+                 hexdigests={
+                     'sha224': '3a854166ac5d9f023f54d517d0b39dbd'
+                               '946770db9c2b95c9f6f565d1',
+                     'sha256': '9b09ffa71b942fcb27635fbcd5b0e944'
+                               'bfdc63644f0713938a7f51535c3a35e2',
+                     'sha384': '6617178e941f020d351e2f254e8fd32c'
+                               '602420feb0b8fb9adccebb82461e99c5'
+                               'a678cc31e799176d3860e6110c46523e',
+                     'sha512': 'e37b6a775dc87dbaa4dfa9f96e5e3ffd'
+                               'debd71f8867289865df5a32d20cdc944'
+                               'b6022cac3c4982b10d5eeb55c3e4de15'
+                               '134676fb6de0446065c97440fa8c6a58',
                  })
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    @hashlib_helper.requires_hashdigest('sha224', openssl=True)
-    def test_sha224_rfc4231(self):
-        self._rfc4231_test_cases(hashlib.sha224, 'sha224', 28, 64)
-
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    @hashlib_helper.requires_hashdigest('sha256', openssl=True)
-    def test_sha256_rfc4231(self):
-        self._rfc4231_test_cases(hashlib.sha256, 'sha256', 32, 64)
-
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    @hashlib_helper.requires_hashdigest('sha384', openssl=True)
-    def test_sha384_rfc4231(self):
-        self._rfc4231_test_cases(hashlib.sha384, 'sha384', 48, 128)
-
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    @hashlib_helper.requires_hashdigest('sha512', openssl=True)
-    def test_sha512_rfc4231(self):
-        self._rfc4231_test_cases(hashlib.sha512, 'sha512', 64, 128)
+    def test_sha3_224_nist(self):
+        for key, msg, hexdigest in [
+            (
+                bytes(range(28)),
+                b'Sample message for keylen<blocklen',
+                '332cfd59347fdb8e576e77260be4aba2d6dc53117b3bfb52c6d18c04'
+            ), (
+                bytes(range(144)),
+                b'Sample message for keylen=blocklen',
+                'd8b733bcf66c644a12323d564e24dcf3fc75f231f3b67968359100c7'
+            ), (
+                bytes(range(172)),
+                b'Sample message for keylen>blocklen',
+                '078695eecc227c636ad31d063a15dd05a7e819a66ec6d8de1e193e59'
+            )
+        ]:
+            self.assert_hmac(
+                key, msg, hexdigest,
+                hashfunc=self.sha3_224, hashname='sha3_224',
+                digest_size=28, block_size=144
+            )
 
-    @hashlib_helper.requires_hashdigest('sha256')
-    def test_legacy_block_size_warnings(self):
-        class MockCrazyHash(object):
-            """Ain't no block_size attribute here."""
-            def __init__(self, *args):
-                self._x = hashlib.sha256(*args)
-                self.digest_size = self._x.digest_size
-            def update(self, v):
-                self._x.update(v)
-            def digest(self):
-                return self._x.digest()
+    def test_sha3_256_nist(self):
+        for key, msg, hexdigest in [
+            (
+                bytes(range(32)),
+                b'Sample message for keylen<blocklen',
+                '4fe8e202c4f058e8dddc23d8c34e4673'
+                '43e23555e24fc2f025d598f558f67205'
+            ), (
+                bytes(range(136)),
+                b'Sample message for keylen=blocklen',
+                '68b94e2e538a9be4103bebb5aa016d47'
+                '961d4d1aa906061313b557f8af2c3faa'
+            ), (
+                bytes(range(168)),
+                b'Sample message for keylen>blocklen',
+                '9bcf2c238e235c3ce88404e813bd2f3a'
+                '97185ac6f238c63d6229a00b07974258'
+            )
+        ]:
+            self.assert_hmac(
+                key, msg, hexdigest,
+                hashfunc=self.sha3_256, hashname='sha3_256',
+                digest_size=32, block_size=136
+            )
 
-        with warnings.catch_warnings():
-            warnings.simplefilter('error', RuntimeWarning)
-            with self.assertRaises(RuntimeWarning):
-                hmac.HMAC(b'a', b'b', digestmod=MockCrazyHash)
-                self.fail('Expected warning about missing block_size')
+    def test_sha3_384_nist(self):
+        for key, msg, hexdigest in [
+            (
+                bytes(range(48)),
+                b'Sample message for keylen<blocklen',
+                'd588a3c51f3f2d906e8298c1199aa8ff'
+                '6296218127f6b38a90b6afe2c5617725'
+                'bc99987f79b22a557b6520db710b7f42'
+            ), (
+                bytes(range(104)),
+                b'Sample message for keylen=blocklen',
+                'a27d24b592e8c8cbf6d4ce6fc5bf62d8'
+                'fc98bf2d486640d9eb8099e24047837f'
+                '5f3bffbe92dcce90b4ed5b1e7e44fa90'
+            ), (
+                bytes(range(152)),
+                b'Sample message for keylen>blocklen',
+                'e5ae4c739f455279368ebf36d4f5354c'
+                '95aa184c899d3870e460ebc288ef1f94'
+                '70053f73f7c6da2a71bcaec38ce7d6ac'
+            )
+        ]:
+            self.assert_hmac(
+                key, msg, hexdigest,
+                hashfunc=self.sha3_384, hashname='sha3_384',
+                digest_size=48, block_size=104
+            )
 
-            MockCrazyHash.block_size = 1
-            with self.assertRaises(RuntimeWarning):
-                hmac.HMAC(b'a', b'b', digestmod=MockCrazyHash)
-                self.fail('Expected warning about small block_size')
+    def test_sha3_512_nist(self):
+        for key, msg, hexdigest in [
+            (
+                bytes(range(64)),
+                b'Sample message for keylen<blocklen',
+                '4efd629d6c71bf86162658f29943b1c3'
+                '08ce27cdfa6db0d9c3ce81763f9cbce5'
+                'f7ebe9868031db1a8f8eb7b6b95e5c5e'
+                '3f657a8996c86a2f6527e307f0213196'
+            ), (
+                bytes(range(72)),
+                b'Sample message for keylen=blocklen',
+                '544e257ea2a3e5ea19a590e6a24b724c'
+                'e6327757723fe2751b75bf007d80f6b3'
+                '60744bf1b7a88ea585f9765b47911976'
+                'd3191cf83c039f5ffab0d29cc9d9b6da'
+            ), (
+                bytes(range(136)),
+                b'Sample message for keylen>blocklen',
+                '5f464f5e5b7848e3885e49b2c385f069'
+                '4985d0e38966242dc4a5fe3fea4b37d4'
+                '6b65ceced5dcf59438dd840bab22269f'
+                '0ba7febdb9fcf74602a35666b2a32915'
+            )
+        ]:
+            self.assert_hmac(
+                key, msg, hexdigest,
+                hashfunc=self.sha3_512, hashname='sha3_512',
+                digest_size=64, block_size=72
+            )
 
-    def test_with_digestmod_no_default(self):
-        """The digestmod parameter is required as of Python 3.8."""
-        with self.assertRaisesRegex(TypeError, r'required.*digestmod'):
-            key = b"\x0b" * 16
-            data = b"Hi There"
-            hmac.HMAC(key, data, digestmod=None)
-        with self.assertRaisesRegex(TypeError, r'required.*digestmod'):
-            hmac.new(key, data)
-        with self.assertRaisesRegex(TypeError, r'required.*digestmod'):
-            hmac.HMAC(key, msg=data, digestmod='')
-
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    def test_with_fallback(self):
-        cache = getattr(hashlib, '__builtin_constructor_cache')
-        try:
-            cache['foo'] = hashlib.sha256
-            hexdigest = hmac.digest(b'key', b'message', 'foo').hex()
-            expected = '6e9ef29b75fffc5b7abae527d58fdadb2fe42e7219011976917343065f58ed4a'
-            self.assertEqual(hexdigest, expected)
-        finally:
-            cache.pop('foo')
 
+class PurePythonInitHMAC(PyModuleMixin, HashFunctionsTrait):
+
+    @classmethod
+    def setUpClass(cls):
+        super().setUpClass()
+        for meth in ['_init_openssl_hmac', '_init_builtin_hmac']:
+            fn = getattr(cls.hmac.HMAC, meth)
+            cm = patch.object(cls.hmac.HMAC, meth, autospec=True, wraps=fn)
+            cls.enterClassContext(cm)
+
+    @classmethod
+    def tearDownClass(cls):
+        cls.hmac.HMAC._init_openssl_hmac.assert_not_called()
+        cls.hmac.HMAC._init_builtin_hmac.assert_not_called()
+        # Do not assert that HMAC._init_old() has been called as it's tricky
+        # to determine whether a test for a specific hash function has been
+        # executed or not. On regular builds, it will be called but if a
+        # hash function is not available, it's hard to detect for which
+        # test we should checj HMAC._init_old() or not.
+        super().tearDownClass()
+
+
+class PyRFCOpenSSLTestCase(ThroughObjectMixin,
+                           PyAssertersMixin,
+                           OpenSSLHashFunctionsTrait,
+                           RFCTestCaseMixin,
+                           PurePythonInitHMAC,
+                           unittest.TestCase):
+    """Python implementation of HMAC using hmac.HMAC().
+
+    The underlying hash functions are OpenSSL-based but
+    _init_old() is used instead of _init_openssl_hmac().
+    """
+
+
+class PyRFCBuiltinTestCase(ThroughObjectMixin,
+                           PyAssertersMixin,
+                           BuiltinHashFunctionsTrait,
+                           RFCTestCaseMixin,
+                           PurePythonInitHMAC,
+                           unittest.TestCase):
+    """Python implementation of HMAC using hmac.HMAC().
+
+    The underlying hash functions are HACL*-based but
+    _init_old() is used instead of _init_builtin_hmac().
+    """
+
+
+class PyDotNewOpenSSLRFCTestCase(ThroughModuleAPIMixin,
+                                 PyAssertersMixin,
+                                 OpenSSLHashFunctionsTrait,
+                                 RFCTestCaseMixin,
+                                 PurePythonInitHMAC,
+                                 unittest.TestCase):
+    """Python implementation of HMAC using hmac.new().
+
+    The underlying hash functions are OpenSSL-based but
+    _init_old() is used instead of _init_openssl_hmac().
+    """
+
+
+class PyDotNewBuiltinRFCTestCase(ThroughModuleAPIMixin,
+                                 PyAssertersMixin,
+                                 BuiltinHashFunctionsTrait,
+                                 RFCTestCaseMixin,
+                                 PurePythonInitHMAC,
+                                 unittest.TestCase):
+    """Python implementation of HMAC using hmac.new().
+
+    The underlying hash functions are HACL-based but
+    _init_old() is used instead of _init_openssl_hmac().
+    """
+
+
+class OpenSSLRFCTestCase(OpenSSLAssertersMixin,
+                         OpenSSLHashFunctionsTrait,
+                         RFCTestCaseMixin,
+                         unittest.TestCase):
+    """OpenSSL implementation of HMAC.
+
+    The underlying hash functions are also OpenSSL-based.
+    """
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; _hashlib.UnsupportedDigestmodError: unsupported hash type
+    def test_md5_rfc2202(self):
+        return super().test_md5_rfc2202()
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; _hashlib.UnsupportedDigestmodError: unsupported hash type
+    def test_sha1_rfc2202(self):
+        return super().test_sha1_rfc2202()
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; _hashlib.UnsupportedDigestmodError: unsupported hash type
+    def test_sha2_224_rfc4231(self):
+        return super().test_sha2_224_rfc4231()
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; _hashlib.UnsupportedDigestmodError: unsupported hash type
+    def test_sha2_256_rfc4231(self):
+        return super().test_sha2_256_rfc4231()
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; _hashlib.UnsupportedDigestmodError: unsupported hash type
+    def test_sha2_384_rfc4231(self):
+        return super().test_sha2_384_rfc4231()
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; _hashlib.UnsupportedDigestmodError: unsupported hash type
+    def test_sha2_512_rfc4231(self):
+        return super().test_sha2_512_rfc4231()
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; _hashlib.UnsupportedDigestmodError: unsupported hash type
+    def test_sha3_224_nist(self):
+        return super().test_sha3_224_nist()
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; _hashlib.UnsupportedDigestmodError: unsupported hash type
+    def test_sha3_256_nist(self):
+        return super().test_sha3_256_nist()
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; _hashlib.UnsupportedDigestmodError: unsupported hash type
+    def test_sha3_384_nist(self):
+        return super().test_sha3_384_nist()
 
-class ConstructorTestCase(unittest.TestCase):
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; _hashlib.UnsupportedDigestmodError: unsupported hash type
+    def test_sha3_512_nist(self):
+        return super().test_sha3_512_nist()
+
+
+class BuiltinRFCTestCase(BuiltinAssertersMixin,
+                         NamedHashFunctionsTrait,
+                         RFCTestCaseMixin,
+                         unittest.TestCase):
+    """Built-in HACL* implementation of HMAC.
 
-    expected = (
-        "6c845b47f52b3b47f6590c502db7825aad757bf4fadc8fa972f7cd2e76a5bdeb"
-    )
+    The underlying hash functions are also HACL*-based.
+    """
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    @hashlib_helper.requires_hashdigest('sha256')
-    def test_normal(self):
-        # Standard constructor call.
-        try:
-            hmac.HMAC(b"key", digestmod='sha256')
-        except Exception:
-            self.fail("Standard constructor call raised exception.")
+    def assert_hmac_extra_cases(
+        self, key, msg, hexdigest, digestmod, hashname, digest_size, block_size
+    ):
+        # assert one-shot HMAC at the same time
+        with self.subTest(key=key, msg=msg, hashname=hashname):
+            func = getattr(self.hmac, f'compute_{hashname}')
+            self.assertTrue(callable(func))
+            self.check_hmac_hexdigest(key, msg, hexdigest, digest_size, func)
+
+
+class DigestModTestCaseMixin(CreatorMixin, DigestMixin):
+    """Tests for the 'digestmod' parameter for hmac_new() and hmac_digest()."""
+
+    def assert_raises_missing_digestmod(self):
+        """A context manager catching errors when a digestmod is missing."""
+        return self.assertRaisesRegex(TypeError,
+                                      "[M|m]issing.*required.*digestmod")
+
+    def assert_raises_unknown_digestmod(self):
+        """A context manager catching errors when a digestmod is unknown."""
+        return self.assertRaisesRegex(ValueError, "[Uu]nsupported.*")
+
+    def test_constructor_missing_digestmod(self):
+        catcher = self.assert_raises_missing_digestmod
+        self.do_test_constructor_missing_digestmod(catcher)
+
+    def test_constructor_unknown_digestmod(self):
+        catcher = self.assert_raises_unknown_digestmod
+        self.do_test_constructor_unknown_digestmod(catcher)
 
-    @hashlib_helper.requires_hashdigest('sha256')
-    def test_with_str_key(self):
-        # Pass a key of type str, which is an error, because it expects a key
-        # of type bytes
-        with self.assertRaises(TypeError):
-            h = hmac.HMAC("key", digestmod='sha256')
+    def do_test_constructor_missing_digestmod(self, catcher):
+        for func, args, kwds in self.cases_missing_digestmod_in_constructor():
+            with self.subTest(args=args, kwds=kwds), catcher():
+                func(*args, **kwds)
 
-    @hashlib_helper.requires_hashdigest('sha256')
-    def test_dot_new_with_str_key(self):
-        # Pass a key of type str, which is an error, because it expects a key
-        # of type bytes
-        with self.assertRaises(TypeError):
-            h = hmac.new("key", digestmod='sha256')
+    def do_test_constructor_unknown_digestmod(self, catcher):
+        for func, args, kwds in self.cases_unknown_digestmod_in_constructor():
+            with self.subTest(args=args, kwds=kwds), catcher():
+                func(*args, **kwds)
 
-    @hashlib_helper.requires_hashdigest('sha256')
-    def test_withtext(self):
-        # Constructor call with text.
-        try:
-            h = hmac.HMAC(b"key", b"hash this!", digestmod='sha256')
-        except Exception:
-            self.fail("Constructor call with text argument raised exception.")
-        self.assertEqual(h.hexdigest(), self.expected)
+    def cases_missing_digestmod_in_constructor(self):
+        raise NotImplementedError
 
-    @hashlib_helper.requires_hashdigest('sha256')
-    def test_with_bytearray(self):
-        try:
-            h = hmac.HMAC(bytearray(b"key"), bytearray(b"hash this!"),
-                          digestmod="sha256")
-        except Exception:
-            self.fail("Constructor call with bytearray arguments raised exception.")
-        self.assertEqual(h.hexdigest(), self.expected)
+    def make_missing_digestmod_cases(self, func, missing_like=()):
+        """Generate cases for missing digestmod tests.
 
-    @hashlib_helper.requires_hashdigest('sha256')
-    def test_with_memoryview_msg(self):
-        try:
-            h = hmac.HMAC(b"key", memoryview(b"hash this!"), digestmod="sha256")
-        except Exception:
-            self.fail("Constructor call with memoryview msg raised exception.")
-        self.assertEqual(h.hexdigest(), self.expected)
+        Only the Python implementation should consider "falsey" 'digestmod'
+        values as being equivalent to a missing one.
+        """
+        key, msg = b'unused key', b'unused msg'
+        choices = [DIGESTMOD_SENTINEL, *missing_like]
+        return self._invalid_digestmod_cases(func, key, msg, choices)
 
-    @hashlib_helper.requires_hashdigest('sha256')
-    def test_withmodule(self):
-        # Constructor call with text and digest module.
-        try:
-            h = hmac.HMAC(b"key", b"", hashlib.sha256)
-        except Exception:
-            self.fail("Constructor call with hashlib.sha256 raised exception.")
+    def cases_unknown_digestmod_in_constructor(self):
+        raise NotImplementedError
+
+    def make_unknown_digestmod_cases(self, func, bad_digestmods):
+        """Generate cases for unknown digestmod tests."""
+        key, msg = b'unused key', b'unused msg'
+        return self._invalid_digestmod_cases(func, key, msg, bad_digestmods)
+
+    def _invalid_digestmod_cases(self, func, key, msg, choices):
+        cases = []
+        for digestmod in choices:
+            kwargs = {'digestmod': digestmod}
+            cases.append((func, (key,), kwargs))
+            cases.append((func, (key, msg), kwargs))
+            cases.append((func, (key,), kwargs | {'msg': msg}))
+        return cases
+
+
+class ConstructorTestCaseMixin(CreatorMixin, DigestMixin, ObjectCheckerMixin):
+    """HMAC constructor tests based on HMAC-SHA-2/256."""
+
+    key = b"key"
+    msg = b"hash this!"
+    res = "6c845b47f52b3b47f6590c502db7825aad757bf4fadc8fa972f7cd2e76a5bdeb"
+
+    def do_test_constructor(self, hmac_on_key_and_msg):
+        self.do_test_constructor_invalid_types(hmac_on_key_and_msg)
+        self.do_test_constructor_supported_types(hmac_on_key_and_msg)
+
+    def do_test_constructor_invalid_types(self, hmac_on_key_and_msg):
+        self.assertRaises(TypeError, hmac_on_key_and_msg, 1)
+        self.assertRaises(TypeError, hmac_on_key_and_msg, "key")
+
+        self.assertRaises(TypeError, hmac_on_key_and_msg, b"key", 1)
+        self.assertRaises(TypeError, hmac_on_key_and_msg, b"key", "msg")
+
+    def do_test_constructor_supported_types(self, hmac_on_key_and_msg):
+        for tp_key in [bytes, bytearray]:
+            for tp_msg in [bytes, bytearray, memoryview]:
+                with self.subTest(tp_key=tp_key, tp_msg=tp_msg):
+                    h = hmac_on_key_and_msg(tp_key(self.key), tp_msg(self.msg))
+                    self.assertEqual(h.name, "hmac-sha256")
+                    self.assertEqual(h.hexdigest(), self.res)
+
+    @hashlib_helper.requires_hashdigest("sha256")
+    def test_constructor(self):
+        self.do_test_constructor(self.bind_hmac_new("sha256"))
+
+    @hashlib_helper.requires_hashdigest("sha256")
+    def test_digest(self):
+        digest = self.hmac_digest(self.key, self.msg, "sha256")
+        self.assertEqual(digest, binascii.unhexlify(self.res))
+
+
+class PyConstructorBaseMixin(PyModuleMixin,
+                             DigestModTestCaseMixin,
+                             ConstructorTestCaseMixin):
+
+    def cases_missing_digestmod_in_constructor(self):
+        func, choices = self.hmac_new, ['', None, False]
+        return self.make_missing_digestmod_cases(func, choices)
+
+    def cases_unknown_digestmod_in_constructor(self):
+        func, choices = self.hmac_new, ['unknown']
+        return self.make_unknown_digestmod_cases(func, choices)
+
+    @requires_builtin_sha2()
+    def test_constructor_with_module(self):
+        self.do_test_constructor(self.bind_hmac_new(sha2.sha256))
+
+    @requires_builtin_sha2()
+    def test_digest_with_module(self):
+        digest = self.hmac_digest(self.key, self.msg, sha2.sha256)
+        self.assertEqual(digest, binascii.unhexlify(self.res))
+
+
+class PyConstructorTestCase(ThroughObjectMixin, PyConstructorBaseMixin,
+                            unittest.TestCase):
+    """Test the hmac.HMAC() pure Python constructor."""
+
+
+class PyModuleConstructorTestCase(ThroughModuleAPIMixin, PyConstructorBaseMixin,
+                                  unittest.TestCase):
+    """Test the hmac.new() and hmac.digest() functions.
+
+    Note that "self.hmac" is imported by blocking "_hashlib" and "_hmac".
+    For testing functions in "hmac", extend PyMiscellaneousTests instead.
+    """
+
+    def test_hmac_digest_digestmod_parameter(self):
+        func = self.hmac_digest
+
+        def raiser():
+            raise RuntimeError("custom exception")
+
+        with self.assertRaisesRegex(RuntimeError, "custom exception"):
+            func(b'key', b'msg', raiser)
+
+        with self.assertRaisesRegex(ValueError, 'hash type'):
+            func(b'key', b'msg', 'unknown')
+
+        with self.assertRaisesRegex(AttributeError, 'new'):
+            func(b'key', b'msg', 1234)
+        with self.assertRaisesRegex(AttributeError, 'new'):
+            func(b'key', b'msg', None)
+
+
+class ExtensionConstructorTestCaseMixin(DigestModTestCaseMixin,
+                                        ConstructorTestCaseMixin):
+
+    @property
+    def obj_type(self):
+        """The underlying (non-instantiable) C class."""
+        raise NotImplementedError
+
+    @property
+    def exc_type(self):
+        """The exact exception class raised upon invalid 'digestmod' values."""
+        raise NotImplementedError
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    @unittest.skipUnless(C_HMAC is not None, 'need _hashlib')
     def test_internal_types(self):
-        # internal types like _hashlib.C_HMAC are not constructable
-        check_disallow_instantiation(self, C_HMAC)
+        # internal C types are immutable and cannot be instantiated
+        check_disallow_instantiation(self, self.obj_type)
         with self.assertRaisesRegex(TypeError, "immutable type"):
-            C_HMAC.value = None
-
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    @unittest.skipUnless(sha256_module is not None, 'need _sha256')
-    def test_with_sha256_module(self):
-        h = hmac.HMAC(b"key", b"hash this!", digestmod=sha256_module.sha256)
-        self.assertEqual(h.hexdigest(), self.expected)
-        self.assertEqual(h.name, "hmac-sha256")
+            self.obj_type.value = None
+
+    def assert_raises_unknown_digestmod(self):
+        self.assertIsSubclass(self.exc_type, ValueError)
+        return self.assertRaises(self.exc_type)
+
+    def cases_missing_digestmod_in_constructor(self):
+        return self.make_missing_digestmod_cases(self.hmac_new)
+
+    def cases_unknown_digestmod_in_constructor(self):
+        func, choices = self.hmac_new, ['unknown', 1234]
+        return self.make_unknown_digestmod_cases(func, choices)
+
+
+class OpenSSLConstructorTestCase(ThroughOpenSSLAPIMixin,
+                                 ExtensionConstructorTestCaseMixin,
+                                 unittest.TestCase):
+
+    @property
+    def obj_type(self):
+        return _hashlib.HMAC
+
+    @property
+    def exc_type(self):
+        return _hashlib.UnsupportedDigestmodError
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    def test_hmac_digest_digestmod_parameter(self):
+        for value in [object, 'unknown', 1234, None]:
+            with (
+                self.subTest(value=value),
+                self.assert_raises_unknown_digestmod(),
+            ):
+                self.hmac_digest(b'key', b'msg', value)
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AttributeError: module '_hashlib' has no attribute 'hmac_digest'
+    def test_digest(self):
+        return super().test_digest()
+
+
+class BuiltinConstructorTestCase(ThroughBuiltinAPIMixin,
+                                 ExtensionConstructorTestCaseMixin,
+                                 unittest.TestCase):
+
+    @property
+    def obj_type(self):
+        return self.hmac.HMAC
+
+    @property
+    def exc_type(self):
+        return self.hmac.UnknownHashError
+
+    def test_hmac_digest_digestmod_parameter(self):
+        for value in [object, 'unknown', 1234, None]:
+            with (
+                self.subTest(value=value),
+                self.assert_raises_unknown_digestmod(),
+            ):
+                self.hmac_digest(b'key', b'msg', value)
+
+
+class SanityTestCaseMixin(CreatorMixin):
+    """Sanity checks for HMAC objects and their object interface.
+
+    The tests here use a common digestname and do not check all supported
+    hash functions.
+    """
+
+    # The underlying HMAC class to test. May be in C or in Python.
+    hmac_class: type
+    # The underlying hash function name (should be accepted by the HMAC class).
+    digestname: str
+    # The expected digest and block sizes (must be hardcoded).
+    digest_size: int
+    block_size: int
+
+    def test_methods(self):
+        h = self.hmac_new(b"my secret key", digestmod=self.digestname)
+        self.assertIsInstance(h, self.hmac_class)
+        self.assertIsNone(h.update(b"compute the hash of this text!"))
+        self.assertIsInstance(h.digest(), bytes)
+        self.assertIsInstance(h.hexdigest(), str)
+        self.assertIsInstance(h.copy(), self.hmac_class)
+
+    def test_properties(self):
+        h = self.hmac_new(b"my secret key", digestmod=self.digestname)
+        self.assertEqual(h.name, f"hmac-{self.digestname}")
+        self.assertEqual(h.digest_size, self.digest_size)
+        self.assertEqual(h.block_size, self.block_size)
+
+    def test_copy(self):
+        # Test a generic copy() and the attributes it exposes.
+        # See https://github.com/python/cpython/issues/142451.
+        h1 = self.hmac_new(b"my secret key", digestmod=self.digestname)
+        h2 = h1.copy()
+        self.assertEqual(h1.name, h2.name)
+        self.assertEqual(h1.digest_size, h2.digest_size)
+        self.assertEqual(h1.block_size, h2.block_size)
+
+    def test_repr(self):
+        # HMAC object representation may differ across implementations
+        raise NotImplementedError
 
-        digest = hmac.digest(b"key", b"hash this!", sha256_module.sha256)
-        self.assertEqual(digest, binascii.unhexlify(self.expected))
 
+@hashlib_helper.requires_hashdigest('sha256')
+class PySanityTestCase(ThroughObjectMixin, PyModuleMixin, SanityTestCaseMixin,
+                       unittest.TestCase):
 
-class SanityTestCase(unittest.TestCase):
+    @classmethod
+    def setUpClass(cls):
+        super().setUpClass()
+        cls.hmac_class = cls.hmac.HMAC
+        cls.digestname = 'sha256'
+        cls.digest_size = 32
+        cls.block_size = 64
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    @hashlib_helper.requires_hashdigest('sha256')
-    def test_exercise_all_methods(self):
-        # Exercising all methods once.
-        # This must not raise any exceptions
-        try:
-            h = hmac.HMAC(b"my secret key", digestmod="sha256")
-            h.update(b"compute the hash of this text!")
-            h.digest()
-            h.hexdigest()
-            h.copy()
-        except Exception:
-            self.fail("Exception raised during normal usage of HMAC class.")
+    def test_repr(self):
+        h = self.hmac_new(b"my secret key", digestmod=self.digestname)
+        self.assertStartsWith(repr(h), "<hmac.HMAC object at")
 
 
-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")
+@hashlib_helper.requires_openssl_hashdigest('sha256')
+class OpenSSLSanityTestCase(ThroughOpenSSLAPIMixin, SanityTestCaseMixin,
+                            unittest.TestCase):
 
+    @classmethod
+    def setUpClass(cls):
+        super().setUpClass()
+        cls.hmac_class = _hashlib.HMAC
+        cls.digestname = 'sha256'
+        cls.digest_size = 32
+        cls.block_size = 64
 
-class CopyTestCase(unittest.TestCase):
+    def test_repr(self):
+        h = self.hmac_new(b"my secret key", digestmod=self.digestname)
+        self.assertStartsWith(repr(h), f"<{self.digestname} HMAC object @")
 
-    @hashlib_helper.requires_hashdigest('sha256')
-    def test_attributes_old(self):
+
+class BuiltinSanityTestCase(ThroughBuiltinAPIMixin, SanityTestCaseMixin,
+                            unittest.TestCase):
+
+    @classmethod
+    def setUpClass(cls):
+        super().setUpClass()
+        cls.hmac_class = cls.hmac.HMAC
+        cls.digestname = 'sha256'
+        cls.digest_size = 32
+        cls.block_size = 64
+
+    def test_repr(self):
+        h = self.hmac_new(b"my secret key", digestmod=self.digestname)
+        self.assertStartsWith(repr(h), f"<{self.digestname} HMAC object @")
+
+
+class UpdateTestCaseMixin:
+    """Tests for the update() method (streaming HMAC)."""
+
+    def HMAC(self, key, msg=None):
+        """Create a HMAC object."""
+        raise NotImplementedError
+
+    @property
+    def gil_minsize(self):
+        """Get the maximal input length for the GIL to be held."""
+        raise NotImplementedError
+
+    def check_update(self, key, chunks):
+        chunks = list(chunks)
+        msg = b''.join(chunks)
+        h1 = self.HMAC(key, msg)
+
+        h2 = self.HMAC(key)
+        for chunk in chunks:
+            h2.update(chunk)
+
+        self.assertEqual(h1.digest(), h2.digest())
+        self.assertEqual(h1.hexdigest(), h2.hexdigest())
+
+    def test_update(self):
+        key, msg = random.randbytes(16), random.randbytes(16)
+        with self.subTest(key=key, msg=msg):
+            self.check_update(key, [msg])
+
+    def test_update_large(self):
+        gil_minsize = self.gil_minsize
+        key = random.randbytes(16)
+        top = random.randbytes(gil_minsize + 1)
+        bot = random.randbytes(gil_minsize + 1)
+        self.check_update(key, [top, bot])
+
+    def test_update_exceptions(self):
+        h = self.HMAC(b"key")
+        for msg in ['invalid msg', 123, (), []]:
+            with self.subTest(msg=msg):
+                self.assertRaises(TypeError, h.update, msg)
+
+
+@requires_builtin_sha2()
+class PyUpdateTestCase(PyModuleMixin, UpdateTestCaseMixin, unittest.TestCase):
+
+    def HMAC(self, key, msg=None):
+        return self.hmac.HMAC(key, msg, digestmod='sha256')
+
+    @property
+    def gil_minsize(self):
+        return sha2._GIL_MINSIZE
+
+
+@hashlib_helper.requires_openssl_hashdigest('sha256')
+class OpenSSLUpdateTestCase(UpdateTestCaseMixin, unittest.TestCase):
+
+    def HMAC(self, key, msg=None):
+        return _hashlib.hmac_new(key, msg, digestmod='sha256')
+
+    @property
+    def gil_minsize(self):
+        return _hashlib._GIL_MINSIZE
+
+
+class BuiltinUpdateTestCase(BuiltinModuleMixin,
+                            UpdateTestCaseMixin, unittest.TestCase):
+
+    def HMAC(self, key, msg=None):
+        # Even if Python does not build '_sha2', the HACL* sources
+        # are still built, making it possible to use SHA-2 hashes.
+        return self.hmac.new(key, msg, digestmod='sha256')
+
+    @property
+    def gil_minsize(self):
+        return self.hmac._GIL_MINSIZE
+
+
+class CopyBaseTestCase:
+
+    def test_attributes(self):
+        raise NotImplementedError
+
+    def test_realcopy(self):
+        raise NotImplementedError
+
+
+@hashlib_helper.requires_hashdigest('sha256')
+class PythonCopyTestCase(CopyBaseTestCase, unittest.TestCase):
+
+    def test_attributes(self):
         # Testing if attributes are of same type.
         h1 = hmac.HMAC.__new__(hmac.HMAC)
         h1._init_old(b"key", b"msg", digestmod="sha256")
+        self.assertIsNone(h1._hmac)
+        self.assertIsNotNone(h1._inner)
+        self.assertIsNotNone(h1._outer)
+
         h2 = h1.copy()
-        self.assertEqual(type(h1._inner), type(h2._inner),
-            "Types of inner don't match.")
-        self.assertEqual(type(h1._outer), type(h2._outer),
-            "Types of outer don't match.")
+        self.assertIsNone(h2._hmac)
+        self.assertIsNotNone(h2._inner)
+        self.assertIsNotNone(h2._outer)
+        self.assertEqual(type(h1._inner), type(h2._inner))
+        self.assertEqual(type(h1._outer), type(h2._outer))
 
-    @hashlib_helper.requires_hashdigest('sha256')
-    def test_realcopy_old(self):
+    def test_realcopy(self):
         # Testing if the copy method created a real copy.
         h1 = hmac.HMAC.__new__(hmac.HMAC)
         h1._init_old(b"key", b"msg", digestmod="sha256")
         h2 = h1.copy()
         # Using id() in case somebody has overridden __eq__/__ne__.
-        self.assertTrue(id(h1) != id(h2), "No real copy of the HMAC instance.")
-        self.assertTrue(id(h1._inner) != id(h2._inner),
-            "No real copy of the attribute 'inner'.")
-        self.assertTrue(id(h1._outer) != id(h2._outer),
-            "No real copy of the attribute 'outer'.")
-        self.assertIs(h1._hmac, None)
-
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    @unittest.skipIf(_hashopenssl is None, "test requires _hashopenssl")
-    @hashlib_helper.requires_hashdigest('sha256')
-    def test_realcopy_hmac(self):
-        h1 = hmac.HMAC.__new__(hmac.HMAC)
-        h1._init_hmac(b"key", b"msg", digestmod="sha256")
-        h2 = h1.copy()
-        self.assertTrue(id(h1._hmac) != id(h2._hmac))
+        self.assertNotEqual(id(h1), id(h2))
+        self.assertNotEqual(id(h1._inner), id(h2._inner))
+        self.assertNotEqual(id(h1._outer), id(h2._outer))
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    @hashlib_helper.requires_hashdigest('sha256')
     def test_equality(self):
         # Testing if the copy has the same digests.
         h1 = hmac.HMAC(b"key", digestmod="sha256")
         h1.update(b"some random text")
         h2 = h1.copy()
-        self.assertEqual(h1.digest(), h2.digest(),
-            "Digest of copy doesn't match original digest.")
-        self.assertEqual(h1.hexdigest(), h2.hexdigest(),
-            "Hexdigest of copy doesn't match original hexdigest.")
+        self.assertEqual(h1.digest(), h2.digest())
+        self.assertEqual(h1.hexdigest(), h2.hexdigest())
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    @hashlib_helper.requires_hashdigest('sha256')
     def test_equality_new(self):
         # Testing if the copy has the same digests with hmac.new().
         h1 = hmac.new(b"key", digestmod="sha256")
         h1.update(b"some random text")
         h2 = h1.copy()
-        self.assertTrue(
-            id(h1) != id(h2), "No real copy of the HMAC instance."
-        )
-        self.assertEqual(h1.digest(), h2.digest(),
-            "Digest of copy doesn't match original digest.")
-        self.assertEqual(h1.hexdigest(), h2.hexdigest(),
-            "Hexdigest of copy doesn't match original hexdigest.")
+        # Using id() in case somebody has overridden __eq__/__ne__.
+        self.assertNotEqual(id(h1), id(h2))
+        self.assertEqual(h1.digest(), h2.digest())
+        self.assertEqual(h1.hexdigest(), h2.hexdigest())
 
 
-class CompareDigestTestCase(unittest.TestCase):
+class ExtensionCopyTestCase(CopyBaseTestCase):
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    def test_hmac_compare_digest(self):
-        self._test_compare_digest(hmac.compare_digest)
-        if openssl_compare_digest is not None:
-            self.assertIs(hmac.compare_digest, openssl_compare_digest)
-        else:
-            self.assertIs(hmac.compare_digest, operator_compare_digest)
-
-    def test_operator_compare_digest(self):
-        self._test_compare_digest(operator_compare_digest)
-
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    @unittest.skipIf(openssl_compare_digest is None, "test requires _hashlib")
-    def test_openssl_compare_digest(self):
-        self._test_compare_digest(openssl_compare_digest)
-
-    def _test_compare_digest(self, compare_digest):
-        # Testing input type exception handling
-        a, b = 100, 200
-        self.assertRaises(TypeError, compare_digest, a, b)
-        a, b = 100, b"foobar"
-        self.assertRaises(TypeError, compare_digest, a, b)
-        a, b = b"foobar", 200
-        self.assertRaises(TypeError, compare_digest, a, b)
-        a, b = "foobar", b"foobar"
-        self.assertRaises(TypeError, compare_digest, a, b)
-        a, b = b"foobar", "foobar"
-        self.assertRaises(TypeError, compare_digest, a, b)
+    def init(self, h):
+        """Call the dedicate init() method to test."""
+        raise NotImplementedError
+
+    def test_attributes(self):
+        # Testing if attributes are of same type.
+        h1 = hmac.HMAC.__new__(hmac.HMAC)
+
+        self.init(h1)
+        self.assertIsNotNone(h1._hmac)
+        self.assertIsNone(h1._inner)
+        self.assertIsNone(h1._outer)
+
+        h2 = h1.copy()
+        self.assertIsNotNone(h2._hmac)
+        self.assertIsNone(h2._inner)
+        self.assertIsNone(h2._outer)
+
+    def test_realcopy(self):
+        h1 = hmac.HMAC.__new__(hmac.HMAC)
+        self.init(h1)
+        h2 = h1.copy()
+        # Using id() in case somebody has overridden __eq__/__ne__.
+        self.assertNotEqual(id(h1._hmac), id(h2._hmac))
+
+
+@hashlib_helper.requires_openssl_hashdigest('sha256')
+class OpenSSLCopyTestCase(ExtensionCopyTestCase, unittest.TestCase):
+
+    def init(self, h):
+        h._init_openssl_hmac(b"key", b"msg", digestmod="sha256")
+
+
+@hashlib_helper.requires_builtin_hmac()
+class BuiltinCopyTestCase(ExtensionCopyTestCase, unittest.TestCase):
+
+    def init(self, h):
+        # Even if Python does not build '_sha2', the HACL* sources
+        # are still built, making it possible to use SHA-2 hashes.
+        h._init_builtin_hmac(b"key", b"msg", digestmod="sha256")
+
+
+class CompareDigestMixin:
+
+    @staticmethod
+    def compare_digest(a, b):
+        """Implementation of 'a == b' to test."""
+        raise NotImplementedError
 
+    def assert_digest_equal(self, a, b):
+        with self.subTest(a=a, b=b):
+            self.assertTrue(self.compare_digest(a, b))
+        with self.subTest(a=b, b=a):
+            self.assertTrue(self.compare_digest(b, a))
+
+    def assert_digest_not_equal(self, a, b):
+        with self.subTest(a=a, b=b):
+            self.assertFalse(self.compare_digest(a, b))
+        with self.subTest(a=b, b=a):
+            self.assertFalse(self.compare_digest(b, a))
+
+    def test_exceptions(self):
+        for a, b in [
+            # Testing input type exception handling
+            (100, 200), (100, b"foobar"), ("foobar", b"foobar"),
+            # non-ASCII strings
+            ("fooä", "fooä")
+        ]:
+            self.assertRaises(TypeError, self.compare_digest, a, b)
+            self.assertRaises(TypeError, self.compare_digest, b, a)
+
+    def test_bytes(self):
         # Testing bytes of different lengths
         a, b = b"foobar", b"foo"
-        self.assertFalse(compare_digest(a, b))
+        self.assert_digest_not_equal(a, b)
         a, b = b"\xde\xad\xbe\xef", b"\xde\xad"
-        self.assertFalse(compare_digest(a, b))
+        self.assert_digest_not_equal(a, b)
 
         # Testing bytes of same lengths, different values
         a, b = b"foobar", b"foobaz"
-        self.assertFalse(compare_digest(a, b))
+        self.assert_digest_not_equal(a, b)
         a, b = b"\xde\xad\xbe\xef", b"\xab\xad\x1d\xea"
-        self.assertFalse(compare_digest(a, b))
+        self.assert_digest_not_equal(a, b)
 
         # Testing bytes of same lengths, same values
         a, b = b"foobar", b"foobar"
-        self.assertTrue(compare_digest(a, b))
+        self.assert_digest_equal(a, b)
         a, b = b"\xde\xad\xbe\xef", b"\xde\xad\xbe\xef"
-        self.assertTrue(compare_digest(a, b))
+        self.assert_digest_equal(a, b)
 
+    def test_bytearray(self):
         # Testing bytearrays of same lengths, same values
         a, b = bytearray(b"foobar"), bytearray(b"foobar")
-        self.assertTrue(compare_digest(a, b))
+        self.assert_digest_equal(a, b)
 
         # Testing bytearrays of different lengths
         a, b = bytearray(b"foobar"), bytearray(b"foo")
-        self.assertFalse(compare_digest(a, b))
+        self.assert_digest_not_equal(a, b)
 
         # Testing bytearrays of same lengths, different values
         a, b = bytearray(b"foobar"), bytearray(b"foobaz")
-        self.assertFalse(compare_digest(a, b))
+        self.assert_digest_not_equal(a, b)
 
+    def test_mixed_types(self):
         # Testing byte and bytearray of same lengths, same values
         a, b = bytearray(b"foobar"), b"foobar"
-        self.assertTrue(compare_digest(a, b))
-        self.assertTrue(compare_digest(b, a))
+        self.assert_digest_equal(a, b)
 
         # Testing byte bytearray of different lengths
         a, b = bytearray(b"foobar"), b"foo"
-        self.assertFalse(compare_digest(a, b))
-        self.assertFalse(compare_digest(b, a))
+        self.assert_digest_not_equal(a, b)
 
         # Testing byte and bytearray of same lengths, different values
         a, b = bytearray(b"foobar"), b"foobaz"
-        self.assertFalse(compare_digest(a, b))
-        self.assertFalse(compare_digest(b, a))
+        self.assert_digest_not_equal(a, b)
 
+    def test_string(self):
         # Testing str of same lengths
         a, b = "foobar", "foobar"
-        self.assertTrue(compare_digest(a, b))
+        self.assert_digest_equal(a, b)
 
         # Testing str of different lengths
         a, b = "foo", "foobar"
-        self.assertFalse(compare_digest(a, b))
+        self.assert_digest_not_equal(a, b)
 
-        # Testing bytes of same lengths, different values
+        # Testing str of same lengths, different values
         a, b = "foobar", "foobaz"
-        self.assertFalse(compare_digest(a, b))
-
-        # Testing error cases
-        a, b = "foobar", b"foobar"
-        self.assertRaises(TypeError, compare_digest, a, b)
-        a, b = b"foobar", "foobar"
-        self.assertRaises(TypeError, compare_digest, a, b)
-        a, b = b"foobar", 1
-        self.assertRaises(TypeError, compare_digest, a, b)
-        a, b = 100, 200
-        self.assertRaises(TypeError, compare_digest, a, b)
-        a, b = "fooä", "fooä"
-        self.assertRaises(TypeError, compare_digest, a, b)
-
-        # subclasses are supported by ignore __eq__
-        class mystr(str):
+        self.assert_digest_not_equal(a, b)
+
+    def test_string_subclass(self):
+        class S(str):
             def __eq__(self, other):
-                return False
+                raise ValueError("should not be called")
 
-        a, b = mystr("foobar"), mystr("foobar")
-        self.assertTrue(compare_digest(a, b))
-        a, b = mystr("foobar"), "foobar"
-        self.assertTrue(compare_digest(a, b))
-        a, b = mystr("foobar"), mystr("foobaz")
-        self.assertFalse(compare_digest(a, b))
+        a, b = S("foobar"), S("foobar")
+        self.assert_digest_equal(a, b)
+        a, b = S("foobar"), "foobar"
+        self.assert_digest_equal(a, b)
+        a, b = S("foobar"), S("foobaz")
+        self.assert_digest_not_equal(a, b)
 
-        class mybytes(bytes):
+    def test_bytes_subclass(self):
+        class B(bytes):
             def __eq__(self, other):
-                return False
-
-        a, b = mybytes(b"foobar"), mybytes(b"foobar")
-        self.assertTrue(compare_digest(a, b))
-        a, b = mybytes(b"foobar"), b"foobar"
-        self.assertTrue(compare_digest(a, b))
-        a, b = mybytes(b"foobar"), mybytes(b"foobaz")
-        self.assertFalse(compare_digest(a, b))
+                raise ValueError("should not be called")
+
+        a, b = B(b"foobar"), B(b"foobar")
+        self.assert_digest_equal(a, b)
+        a, b = B(b"foobar"), b"foobar"
+        self.assert_digest_equal(a, b)
+        a, b = B(b"foobar"), B(b"foobaz")
+        self.assert_digest_not_equal(a, b)
+
+
+class HMACCompareDigestTestCase(CompareDigestMixin, unittest.TestCase):
+    compare_digest = hmac.compare_digest
+
+    def test_compare_digest_func(self):
+        if openssl_compare_digest is not None:
+            self.assertIs(self.compare_digest, openssl_compare_digest)
+        else:
+            self.assertIs(self.compare_digest, operator_compare_digest)
+
+
+@hashlib_helper.requires_hashlib()
+class OpenSSLCompareDigestTestCase(CompareDigestMixin, unittest.TestCase):
+    compare_digest = openssl_compare_digest
+
+
+class OperatorCompareDigestTestCase(CompareDigestMixin, unittest.TestCase):
+    compare_digest = operator_compare_digest
+
+
+class PyMiscellaneousTests(unittest.TestCase):
+    """Miscellaneous tests for the pure Python HMAC module."""
+
+    @hashlib_helper.requires_builtin_hmac()
+    def test_hmac_constructor_uses_builtin(self):
+        # Block the OpenSSL implementation and check that
+        # HMAC() uses the built-in implementation instead.
+        hmac = import_fresh_module("hmac", blocked=["_hashlib"])
+
+        def watch_method(cls, name):
+            wraps = getattr(cls, name)
+            return patch.object(cls, name, autospec=True, wraps=wraps)
+
+        with (
+            watch_method(hmac.HMAC, '_init_openssl_hmac') as f,
+            watch_method(hmac.HMAC, '_init_builtin_hmac') as g,
+        ):
+            _ = hmac.HMAC(b'key', b'msg', digestmod="sha256")
+            f.assert_not_called()
+            g.assert_called_once()
+
+    @hashlib_helper.requires_hashdigest('sha256')
+    def test_hmac_delegated_properties(self):
+        h = hmac.HMAC(b'key', b'msg', digestmod="sha256")
+        self.assertEqual(h.name, "hmac-sha256")
+        self.assertEqual(h.digest_size, 32)
+        self.assertEqual(h.block_size, 64)
+
+    @hashlib_helper.requires_hashdigest('sha256')
+    def test_legacy_block_size_warnings(self):
+        class MockCrazyHash(object):
+            """Ain't no block_size attribute here."""
+            def __init__(self, *args):
+                self._x = hashlib.sha256(*args)
+                self.digest_size = self._x.digest_size
+            def update(self, v):
+                self._x.update(v)
+            def digest(self):
+                return self._x.digest()
+
+        with warnings.catch_warnings():
+            warnings.simplefilter('error', RuntimeWarning)
+            with self.assertRaises(RuntimeWarning):
+                hmac.HMAC(b'a', b'b', digestmod=MockCrazyHash)
+                self.fail('Expected warning about missing block_size')
+
+            MockCrazyHash.block_size = 1
+            with self.assertRaises(RuntimeWarning):
+                hmac.HMAC(b'a', b'b', digestmod=MockCrazyHash)
+                self.fail('Expected warning about small block_size')
+
+    @hashlib_helper.requires_hashdigest('sha256')
+    def test_with_fallback(self):
+        cache = getattr(hashlib, '__builtin_constructor_cache')
+        try:
+            cache['foo'] = hashlib.sha256
+            hexdigest = hmac.digest(b'key', b'message', 'foo').hex()
+            expected = ('6e9ef29b75fffc5b7abae527d58fdadb'
+                        '2fe42e7219011976917343065f58ed4a')
+            self.assertEqual(hexdigest, expected)
+        finally:
+            cache.pop('foo')
+
+    @hashlib_helper.requires_openssl_hashdigest("md5")
+    @bigmemtest(size=_4G + 5, memuse=2, dry_run=False)
+    def test_hmac_digest_overflow_error_openssl_only(self, size):
+        hmac = import_fresh_module("hmac", blocked=["_hmac"])
+        self.do_test_hmac_digest_overflow_error_switch_to_slow(hmac, size)
+
+    @hashlib_helper.requires_builtin_hashdigest("_md5", "md5")
+    @bigmemtest(size=_4G + 5, memuse=2, dry_run=False)
+    def test_hmac_digest_overflow_error_builtin_only(self, size):
+        hmac = import_fresh_module("hmac", blocked=["_hashlib"])
+        self.do_test_hmac_digest_overflow_error_switch_to_slow(hmac, size)
+
+    def do_test_hmac_digest_overflow_error_switch_to_slow(self, hmac, size):
+        """Check that hmac.digest() falls back to pure Python.
+
+        The *hmac* argument implements the HMAC module interface.
+        The *size* argument is a large key size or message size that would
+        trigger an OverflowError in the C implementation(s) of hmac.digest().
+        """
+
+        bigkey = b'K' * size
+        bigmsg = b'M' * size
+
+        with patch.object(hmac, "_compute_digest_fallback") as slow:
+            hmac.digest(bigkey, b'm', "md5")
+            slow.assert_called_once()
+
+        with patch.object(hmac, "_compute_digest_fallback") as slow:
+            hmac.digest(b'k', bigmsg, "md5")
+            slow.assert_called_once()
+
+    @hashlib_helper.requires_hashdigest("md5", openssl=True)
+    @bigmemtest(size=_4G + 5, memuse=2, dry_run=False)
+    def test_hmac_digest_no_overflow_error_in_fallback(self, size):
+        hmac = import_fresh_module("hmac", blocked=["_hashlib", "_hmac"])
+
+        for key, msg in [(b'K' * size, b'm'), (b'k', b'M' * size)]:
+            with self.subTest(keysize=len(key), msgsize=len(msg)):
+                with patch.object(hmac, "_compute_digest_fallback") as slow:
+                    hmac.digest(key, msg, "md5")
+                    slow.assert_called_once()
+
+
+class BuiltinMiscellaneousTests(BuiltinModuleMixin, unittest.TestCase):
+    """HMAC-BLAKE2 is not standardized as BLAKE2 is a keyed hash function.
+
+    In particular, there is no official test vectors for HMAC-BLAKE2.
+    However, we can test that the HACL* interface is correctly used by
+    checking against the pure Python implementation output.
+    """
+
+    @classmethod
+    def setUpClass(cls):
+        super().setUpClass()
+        cls.blake2 = import_helper.import_module("_blake2")
+        cls.blake2b = cls.blake2.blake2b
+        cls.blake2s = cls.blake2.blake2s
+
+    def assert_hmac_blake_correctness(self, digest, key, msg, hashfunc):
+        self.assertIsInstance(digest, bytes)
+        expect = hmac._compute_digest_fallback(key, msg, hashfunc)
+        self.assertEqual(digest, expect)
+
+    def test_compute_blake2b_32(self):
+        key, msg = random.randbytes(8), random.randbytes(16)
+        digest = self.hmac.compute_blake2b_32(key, msg)
+        self.assert_hmac_blake_correctness(digest, key, msg, self.blake2b)
+
+    def test_compute_blake2s_32(self):
+        key, msg = random.randbytes(8), random.randbytes(16)
+        digest = self.hmac.compute_blake2s_32(key, msg)
+        self.assert_hmac_blake_correctness(digest, key, msg, self.blake2s)
 
 
 if __name__ == "__main__":
diff --git a/Lib/test/test_http_cookiejar.py b/Lib/test/test_http_cookiejar.py
index 51fa4a3d413..04cb440cd4c 100644
--- a/Lib/test/test_http_cookiejar.py
+++ b/Lib/test/test_http_cookiejar.py
@@ -7,7 +7,6 @@
 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
@@ -222,11 +221,19 @@ def test_parse_ns_headers_special_names(self):
         expected = [[("expires", "01 Jan 2040 22:23:32 GMT"), ("version", "0")]]
         self.assertEqual(parse_ns_headers([hdr]), expected)
 
-    def test_join_header_words(self):
-        joined = join_header_words([[("foo", None), ("bar", "baz")]])
-        self.assertEqual(joined, "foo; bar=baz")
-
-        self.assertEqual(join_header_words([[]]), "")
+    @support.subTests('src,expected', [
+            ([[("foo", None), ("bar", "baz")]], "foo; bar=baz"),
+            (([]), ""),
+            (([[]]), ""),
+            (([[("a", "_")]]), "a=_"),
+            (([[("a", ";")]]), 'a=";"'),
+            ([[("n", None), ("foo", "foo;_")], [("bar", "foo_bar")]],
+             'n; foo="foo;_", bar=foo_bar'),
+            ([[("n", "m"), ("foo", None)], [("bar", "foo_bar")]],
+             'n=m; foo, bar=foo_bar'),
+        ])
+    def test_join_header_words(self, src, expected):
+        self.assertEqual(join_header_words(src), expected)
 
     @support.subTests('arg,expect', [
             ("foo", [[("foo", None)]]),
@@ -1427,7 +1434,7 @@ def cookiejar_from_cookie_headers(headers):
         self.assertIsNone(cookie.expires)
 
 
-class LWPCookieTests(unittest.TestCase, ExtraAssertions):
+class LWPCookieTests(unittest.TestCase):
     # Tests taken from libwww-perl, with a few modifications and additions.
 
     def test_netscape_example_1(self):
diff --git a/Lib/test/test_http_cookies.py b/Lib/test/test_http_cookies.py
index 3e0b4d1d5ca..11861b0e81c 100644
--- a/Lib/test/test_http_cookies.py
+++ b/Lib/test/test_http_cookies.py
@@ -6,10 +6,9 @@
 from http import cookies
 import pickle
 from test import support
-from test.support.testcase import ExtraAssertions
 
 
-class CookieTests(unittest.TestCase, ExtraAssertions):
+class CookieTests(unittest.TestCase):
 
     def test_basic(self):
         cases = [
@@ -18,10 +17,10 @@ def test_basic(self):
              'repr': "<SimpleCookie: chips='ahoy' vienna='finger'>",
              'output': 'Set-Cookie: chips=ahoy\nSet-Cookie: vienna=finger'},
 
-            {'data': 'keebler="E=mc2; L=\\"Loves\\"; fudge=\\012;"',
-             'dict': {'keebler' : 'E=mc2; L="Loves"; fudge=\012;'},
-             'repr': '''<SimpleCookie: keebler='E=mc2; L="Loves"; fudge=\\n;'>''',
-             'output': 'Set-Cookie: keebler="E=mc2; L=\\"Loves\\"; fudge=\\012;"'},
+            {'data': 'keebler="E=mc2; L=\\"Loves\\"; fudge=;"',
+             'dict': {'keebler' : 'E=mc2; L="Loves"; fudge=;'},
+             'repr': '''<SimpleCookie: keebler='E=mc2; L="Loves"; fudge=;'>''',
+             'output': 'Set-Cookie: keebler="E=mc2; L=\\"Loves\\"; fudge=;"'},
 
             # Check illegal cookies that have an '=' char in an unquoted value
             {'data': 'keebler=E=mc2',
@@ -132,8 +131,8 @@ def test_unquote(self):
 
     @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
+        # 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 + ';"'
@@ -207,6 +206,14 @@ def test_set_secure_httponly_attrs(self):
         self.assertEqual(C.output(),
             'Set-Cookie: Customer="WILE_E_COYOTE"; HttpOnly; Secure')
 
+    def test_set_secure_httponly_partitioned_attrs(self):
+        C = cookies.SimpleCookie('Customer="WILE_E_COYOTE"')
+        C['Customer']['secure'] = True
+        C['Customer']['httponly'] = True
+        C['Customer']['partitioned'] = True
+        self.assertEqual(C.output(),
+            'Set-Cookie: Customer="WILE_E_COYOTE"; HttpOnly; Partitioned; Secure')
+
     def test_samesite_attrs(self):
         samesite_values = ['Strict', 'Lax', 'strict', 'lax']
         for val in samesite_values:
@@ -565,6 +572,50 @@ def test_repr(self):
                 r'Set-Cookie: key=coded_val; '
                 r'expires=\w+, \d+ \w+ \d+ \d+:\d+:\d+ \w+')
 
+    def test_control_characters(self):
+        for c0 in support.control_characters_c0():
+            morsel = cookies.Morsel()
+
+            # .__setitem__()
+            with self.assertRaises(cookies.CookieError):
+                morsel[c0] = "val"
+            with self.assertRaises(cookies.CookieError):
+                morsel["path"] = c0
+
+            # .setdefault()
+            with self.assertRaises(cookies.CookieError):
+                morsel.setdefault("path", c0)
+            with self.assertRaises(cookies.CookieError):
+                morsel.setdefault(c0, "val")
+
+            # .set()
+            with self.assertRaises(cookies.CookieError):
+                morsel.set(c0, "val", "coded-value")
+            with self.assertRaises(cookies.CookieError):
+                morsel.set("path", c0, "coded-value")
+            with self.assertRaises(cookies.CookieError):
+                morsel.set("path", "val", c0)
+
+    def test_control_characters_output(self):
+        # Tests that even if the internals of Morsel are modified
+        # that a call to .output() has control character safeguards.
+        for c0 in support.control_characters_c0():
+            morsel = cookies.Morsel()
+            morsel.set("key", "value", "coded-value")
+            morsel._key = c0  # Override private variable.
+            cookie = cookies.SimpleCookie()
+            cookie["cookie"] = morsel
+            with self.assertRaises(cookies.CookieError):
+                cookie.output()
+
+            morsel = cookies.Morsel()
+            morsel.set("key", "value", "coded-value")
+            morsel._coded_value = c0  # Override private variable.
+            cookie = cookies.SimpleCookie()
+            cookie["cookie"] = morsel
+            with self.assertRaises(cookies.CookieError):
+                cookie.output()
+
 
 def load_tests(loader, tests, pattern):
     tests.addTest(doctest.DocTestSuite(cookies))
diff --git a/Lib/test/test_httplib.py b/Lib/test/test_httplib.py
index 5267d2fe011..8ce5f853b7c 100644
--- a/Lib/test/test_httplib.py
+++ b/Lib/test/test_httplib.py
@@ -16,7 +16,6 @@
 from test import support
 from test.support import os_helper
 from test.support import socket_helper
-from test.support.testcase import ExtraAssertions
 
 support.requires_working_socket(module=True)
 
@@ -135,7 +134,7 @@ def connect(self):
     def create_connection(self, *pos, **kw):
         return FakeSocket(*self.fake_socket_args)
 
-class HeaderTests(TestCase, ExtraAssertions):
+class HeaderTests(TestCase):
     def test_auto_headers(self):
         # Some headers are added automatically, but should not be added by
         # .request() if they are explicitly set.
@@ -538,7 +537,7 @@ def _parse_chunked(self, data):
         return b''.join(body)
 
 
-class BasicTest(TestCase, ExtraAssertions):
+class BasicTest(TestCase):
     def test_dir_with_added_behavior_on_status(self):
         # see issue40084
         self.assertTrue({'description', 'name', 'phrase', 'value'} <= set(dir(HTTPStatus(404))))
@@ -595,8 +594,9 @@ def is_server_error(self):
             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'
+            PROCESSING = 102, 'Processing', 'Server is processing the request'
+            EARLY_HINTS = (103, 'Early Hints',
+                'Headers sent to prepare for the response')
             # success
             OK = 200, 'OK', 'Request fulfilled, document follows'
             CREATED = 201, 'Created', 'Document created, URL follows'
@@ -607,9 +607,11 @@ def is_server_error(self):
             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'
+            MULTI_STATUS = (207, 'Multi-Status',
+                'Response contains multiple statuses in the body')
+            ALREADY_REPORTED = (208, 'Already Reported',
+                'Operation has already been reported')
+            IM_USED = 226, 'IM Used', 'Request completed using instance manipulations'
             # redirection
             MULTIPLE_CHOICES = (300, 'Multiple Choices',
                 'Object has several resources -- see URI list')
@@ -666,15 +668,19 @@ def is_server_error(self):
             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.')
+                '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_CONTENT = (422, 'Unprocessable Content',
+                'Server is not able to process the contained instructions')
             UNPROCESSABLE_ENTITY = UNPROCESSABLE_CONTENT
-            LOCKED = 423, 'Locked'
-            FAILED_DEPENDENCY = 424, 'Failed Dependency'
-            TOO_EARLY = 425, 'Too Early'
-            UPGRADE_REQUIRED = 426, 'Upgrade Required'
+            LOCKED = 423, 'Locked', 'Resource of a method is locked'
+            FAILED_DEPENDENCY = (424, 'Failed Dependency',
+                'Dependent action of the request failed')
+            TOO_EARLY = (425, 'Too Early',
+                'Server refuses to process a request that might be replayed')
+            UPGRADE_REQUIRED = (426, 'Upgrade Required',
+                'Server refuses to perform the request using the current protocol')
             PRECONDITION_REQUIRED = (428, 'Precondition Required',
                 'The origin server requires the request to be conditional')
             TOO_MANY_REQUESTS = (429, 'Too Many Requests',
@@ -701,10 +707,14 @@ def is_server_error(self):
                 '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'
+            VARIANT_ALSO_NEGOTIATES = (506, 'Variant Also Negotiates',
+                'Server has an internal configuration error')
+            INSUFFICIENT_STORAGE = (507, 'Insufficient Storage',
+                'Server is not able to store the representation')
+            LOOP_DETECTED = (508, 'Loop Detected',
+                'Server encountered an infinite loop while processing a request')
+            NOT_EXTENDED = (510, 'Not Extended',
+                'Request does not meet the resource access policy')
             NETWORK_AUTHENTICATION_REQUIRED = (511,
                 'Network Authentication Required',
                 'The client needs to authenticate to gain network access')
@@ -1560,7 +1570,7 @@ def _encode_request(self, str_url):
         conn.putrequest('GET', '/☃')
 
 
-class ExtendedReadTest(TestCase, ExtraAssertions):
+class ExtendedReadTest(TestCase):
     """
     Test peek(), read1(), readline()
     """
@@ -1753,7 +1763,7 @@ def readline(self, limit):
             raise
 
 
-class OfflineTest(TestCase, ExtraAssertions):
+class OfflineTest(TestCase):
     def test_all(self):
         # Documented objects defined in the module should be in __all__
         expected = {"responses"}  # Allowlist documented dict() object
@@ -2111,6 +2121,7 @@ def test_local_good_hostname(self):
         self.addCleanup(resp.close)
         self.assertEqual(resp.status, 404)
 
+    @unittest.skip("TODO: RUSTPYTHON; Flaky on CI")
     def test_local_bad_hostname(self):
         # The (valid) cert doesn't validate the HTTPS hostname
         import ssl
@@ -2156,10 +2167,11 @@ def test_host_port(self):
             self.assertEqual(h, c.host)
             self.assertEqual(p, c.port)
 
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_tls13_pha(self):
         import ssl
-        if not ssl.HAS_TLSv1_3:
-            self.skipTest('TLS 1.3 support required')
+        if not ssl.HAS_TLSv1_3 or not ssl.HAS_PHA:
+            self.skipTest('TLS 1.3 PHA support required')
         # just check status of PHA flag
         h = client.HTTPSConnection('localhost', 443)
         self.assertTrue(h._context.post_handshake_auth)
@@ -2307,7 +2319,7 @@ def test_getting_header_defaultint(self):
         header = self.resp.getheader('No-Such-Header',default=42)
         self.assertEqual(header, 42)
 
-class TunnelTests(TestCase, ExtraAssertions):
+class TunnelTests(TestCase):
     def setUp(self):
         response_text = (
             'HTTP/1.1 200 OK\r\n\r\n' # Reply to CONNECT
diff --git a/Lib/test/test_httpservers.py b/Lib/test/test_httpservers.py
index f402a34fbdf..b7885f5d2dd 100644
--- a/Lib/test/test_httpservers.py
+++ b/Lib/test/test_httpservers.py
@@ -4,7 +4,7 @@
 Josip Dzolonga, and Michael Otteneder for the 2007/08 GHOP contest.
 """
 from collections import OrderedDict
-from http.server import BaseHTTPRequestHandler, HTTPServer, \
+from http.server import BaseHTTPRequestHandler, HTTPServer, HTTPSServer, \
      SimpleHTTPRequestHandler, CGIHTTPRequestHandler
 from http import server, HTTPStatus
 
@@ -32,9 +32,13 @@
 import unittest
 from test import support
 from test.support import (
-    is_apple, os_helper, requires_subprocess, threading_helper
+    is_apple, import_helper, os_helper, requires_subprocess, threading_helper
 )
-from test.support.testcase import ExtraAssertions
+
+try:
+    import ssl
+except ImportError:
+    ssl = None
 
 support.requires_working_socket(module=True)
 
@@ -47,14 +51,49 @@ def read(self, n=None):
         return ''
 
 
+class DummyRequestHandler(NoLogRequestHandler, SimpleHTTPRequestHandler):
+    pass
+
+
+def create_https_server(
+    certfile,
+    keyfile=None,
+    password=None,
+    *,
+    address=('localhost', 0),
+    request_handler=DummyRequestHandler,
+):
+    return HTTPSServer(
+        address, request_handler,
+        certfile=certfile, keyfile=keyfile, password=password
+    )
+
+
+class TestSSLDisabled(unittest.TestCase):
+    def test_https_server_raises_runtime_error(self):
+        with import_helper.isolated_modules():
+            sys.modules['ssl'] = None
+            certfile = certdata_file("keycert.pem")
+            with self.assertRaises(RuntimeError):
+                create_https_server(certfile)
+
+
 class TestServerThread(threading.Thread):
-    def __init__(self, test_object, request_handler):
+    def __init__(self, test_object, request_handler, tls=None):
         threading.Thread.__init__(self)
         self.request_handler = request_handler
         self.test_object = test_object
+        self.tls = tls
 
     def run(self):
-        self.server = HTTPServer(('localhost', 0), self.request_handler)
+        if self.tls:
+            certfile, keyfile, password = self.tls
+            self.server = create_https_server(
+                certfile, keyfile, password,
+                request_handler=self.request_handler,
+            )
+        else:
+            self.server = HTTPServer(('localhost', 0), self.request_handler)
         self.test_object.HOST, self.test_object.PORT = self.server.socket.getsockname()
         self.test_object.server_started.set()
         self.test_object = None
@@ -68,12 +107,16 @@ def stop(self):
         self.join()
 
 
-class BaseTestCase(unittest.TestCase, ExtraAssertions):
+class BaseTestCase(unittest.TestCase):
+
+    # Optional tuple (certfile, keyfile, password) to use for HTTPS servers.
+    tls = None
+
     def setUp(self):
         self._threads = threading_helper.threading_setup()
         os.environ = os_helper.EnvironmentVarGuard()
         self.server_started = threading.Event()
-        self.thread = TestServerThread(self, self.request_handler)
+        self.thread = TestServerThread(self, self.request_handler, self.tls)
         self.thread.start()
         self.server_started.wait()
 
@@ -355,6 +398,74 @@ def test_single_request(self):
             self.assertEqual(res, b'')
 
 
+def certdata_file(*path):
+    return os.path.join(os.path.dirname(__file__), "certdata", *path)
+
+
+@unittest.skipIf(ssl is None, "requires ssl")
+class BaseHTTPSServerTestCase(BaseTestCase):
+    CERTFILE = certdata_file("keycert.pem")
+    ONLYCERT = certdata_file("ssl_cert.pem")
+    ONLYKEY = certdata_file("ssl_key.pem")
+    CERTFILE_PROTECTED = certdata_file("keycert.passwd.pem")
+    ONLYKEY_PROTECTED = certdata_file("ssl_key.passwd.pem")
+    EMPTYCERT = certdata_file("nullcert.pem")
+    BADCERT = certdata_file("badcert.pem")
+    KEY_PASSWORD = "somepass"
+    BADPASSWORD = "badpass"
+
+    tls = (ONLYCERT, ONLYKEY, None)  # values by default
+
+    request_handler = DummyRequestHandler
+
+    def test_get(self):
+        response = self.request('/')
+        self.assertEqual(response.status, HTTPStatus.OK)
+
+    def request(self, uri, method='GET', body=None, headers={}):
+        context = ssl._create_unverified_context()
+        self.connection = http.client.HTTPSConnection(
+            self.HOST, self.PORT, context=context
+        )
+        self.connection.request(method, uri, body, headers)
+        return self.connection.getresponse()
+
+    def test_valid_certdata(self):
+        valid_certdata= [
+            (self.CERTFILE, None, None),
+            (self.CERTFILE, self.CERTFILE, None),
+            (self.CERTFILE_PROTECTED, None, self.KEY_PASSWORD),
+            (self.ONLYCERT, self.ONLYKEY_PROTECTED, self.KEY_PASSWORD),
+        ]
+        for certfile, keyfile, password in valid_certdata:
+            with self.subTest(
+                certfile=certfile, keyfile=keyfile, password=password
+            ):
+                server = create_https_server(certfile, keyfile, password)
+                self.assertIsInstance(server, HTTPSServer)
+                server.server_close()
+
+    def test_invalid_certdata(self):
+        invalid_certdata = [
+            (self.BADCERT, None, None),
+            (self.EMPTYCERT, None, None),
+            (self.ONLYCERT, None, None),
+            (self.ONLYKEY, None, None),
+            (self.ONLYKEY, self.ONLYCERT, None),
+            (self.CERTFILE_PROTECTED, None, self.BADPASSWORD),
+            # TODO: test the next case and add same case to test_ssl (We
+            # specify a cert and a password-protected file, but no password):
+            # (self.CERTFILE_PROTECTED, None, None),
+            # see issue #132102
+        ]
+        for certfile, keyfile, password in invalid_certdata:
+            with self.subTest(
+                certfile=certfile, keyfile=keyfile, password=password
+            ):
+                with self.assertRaises(ssl.SSLError):
+                    create_https_server(certfile, keyfile, password)
+
+
 class RequestHandlerLoggingTestCase(BaseTestCase):
     class request_handler(BaseHTTPRequestHandler):
         protocol_version = 'HTTP/1.1'
@@ -994,7 +1105,6 @@ def test_url_collapse_path(self):
                                  msg='path = %r\nGot:    %r\nWanted: %r' %
                                  (path, actual, expected))
 
-    @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(
@@ -1005,7 +1115,6 @@ def test_issue19435(self):
         res = self.request('///////////nocgi.py/../cgi-bin/nothere.sh')
         self.assertEqual(res.status, HTTPStatus.NOT_FOUND)
 
-    @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})
@@ -1014,7 +1123,6 @@ 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
@@ -1023,7 +1131,7 @@ def test_large_content_length(self):
             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"')
+    @unittest.skip("TODO: RUSTPYTHON; flaky test")
     def test_large_content_length_truncated(self):
         with support.swap_attr(self.request_handler, 'timeout', 0.001):
             for w in range(18, 65):
@@ -1037,7 +1145,6 @@ def test_invaliduri(self):
         res.read()
         self.assertEqual(res.status, HTTPStatus.NOT_FOUND)
 
-    @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')}
@@ -1046,7 +1153,6 @@ def test_authorization(self):
             (b'Hello World' + self.linesep, 'text/html', HTTPStatus.OK),
             (res.read(), res.getheader('Content-type'), res.status))
 
-    @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')
@@ -1054,7 +1160,6 @@ def test_no_leading_slash(self):
             (b'Hello World' + self.linesep, 'text/html', HTTPStatus.OK),
             (res.read(), res.getheader('Content-type'), res.status))
 
-    @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
@@ -1064,28 +1169,24 @@ def test_os_environ_is_not_altered(self):
             (res.read(), res.getheader('Content-type'), res.status))
         self.assertEqual(os.environ['SERVER_SOFTWARE'], signature)
 
-    @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))
 
-    @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))
 
-    @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))
 
-    @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(
@@ -1093,7 +1194,6 @@ def test_query_with_continuous_slashes(self):
              'text/html', HTTPStatus.OK),
             (res.read(), res.getheader('Content-type'), res.status))
 
-    @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')
@@ -1104,7 +1204,6 @@ def test_cgi_path_in_sub_directories(self):
         finally:
             CGIHTTPRequestHandler.cgi_directories.remove('/sub/dir/cgi-bin')
 
-    @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'
@@ -1165,7 +1264,7 @@ def numWrites(self):
         return len(self.datas)
 
 
-class BaseHTTPRequestHandlerTestCase(unittest.TestCase, ExtraAssertions):
+class BaseHTTPRequestHandlerTestCase(unittest.TestCase):
     """Test the functionality of the BaseHTTPServer.
 
        Test the support for the Expect 100-continue header.
diff --git a/Lib/test/test_imaplib.py b/Lib/test/test_imaplib.py
new file mode 100644
index 00000000000..9155a43a06e
--- /dev/null
+++ b/Lib/test/test_imaplib.py
@@ -0,0 +1,1128 @@
+from test import support
+from test.support import socket_helper
+
+from contextlib import contextmanager
+import imaplib
+import os.path
+import socketserver
+import time
+import calendar
+import threading
+import re
+import socket
+
+from test.support import verbose, run_with_tz, run_with_locale, cpython_only
+from test.support import hashlib_helper
+from test.support import threading_helper
+import unittest
+from unittest import mock
+from datetime import datetime, timezone, timedelta
+try:
+    import ssl
+except ImportError:
+    ssl = None
+
+support.requires_working_socket(module=True)
+
+CERTFILE = os.path.join(os.path.dirname(__file__) or os.curdir, "certdata", "keycert3.pem")
+CAFILE = os.path.join(os.path.dirname(__file__) or os.curdir, "certdata", "pycacert.pem")
+
+
+class TestImaplib(unittest.TestCase):
+
+    def test_Internaldate2tuple(self):
+        t0 = calendar.timegm((2000, 1, 1, 0, 0, 0, -1, -1, -1))
+        tt = imaplib.Internaldate2tuple(
+            b'25 (INTERNALDATE "01-Jan-2000 00:00:00 +0000")')
+        self.assertEqual(time.mktime(tt), t0)
+        tt = imaplib.Internaldate2tuple(
+            b'25 (INTERNALDATE "01-Jan-2000 11:30:00 +1130")')
+        self.assertEqual(time.mktime(tt), t0)
+        tt = imaplib.Internaldate2tuple(
+            b'25 (INTERNALDATE "31-Dec-1999 12:30:00 -1130")')
+        self.assertEqual(time.mktime(tt), t0)
+
+    @run_with_tz('MST+07MDT,M4.1.0,M10.5.0')
+    def test_Internaldate2tuple_issue10941(self):
+        self.assertNotEqual(imaplib.Internaldate2tuple(
+            b'25 (INTERNALDATE "02-Apr-2000 02:30:00 +0000")'),
+            imaplib.Internaldate2tuple(
+                b'25 (INTERNALDATE "02-Apr-2000 03:30:00 +0000")'))
+
+    def timevalues(self):
+        return [2000000000, 2000000000.0, time.localtime(2000000000),
+                (2033, 5, 18, 5, 33, 20, -1, -1, -1),
+                (2033, 5, 18, 5, 33, 20, -1, -1, 1),
+                datetime.fromtimestamp(2000000000,
+                                       timezone(timedelta(0, 2 * 60 * 60))),
+                '"18-May-2033 05:33:20 +0200"']
+
+    @run_with_locale('LC_ALL', 'de_DE', 'fr_FR', '')
+    # DST rules included to work around quirk where the Gnu C library may not
+    # otherwise restore the previous time zone
+    @run_with_tz('STD-1DST,M3.2.0,M11.1.0')
+    def test_Time2Internaldate(self):
+        expected = '"18-May-2033 05:33:20 +0200"'
+
+        for t in self.timevalues():
+            internal = imaplib.Time2Internaldate(t)
+            self.assertEqual(internal, expected)
+
+    def test_that_Time2Internaldate_returns_a_result(self):
+        # Without tzset, we can check only that it successfully
+        # produces a result, not the correctness of the result itself,
+        # since the result depends on the timezone the machine is in.
+        for t in self.timevalues():
+            imaplib.Time2Internaldate(t)
+
+    @socket_helper.skip_if_tcp_blackhole
+    def test_imap4_host_default_value(self):
+        # Check whether the IMAP4_PORT is truly unavailable.
+        with socket.socket() as s:
+            try:
+                s.connect(('', imaplib.IMAP4_PORT))
+                self.skipTest(
+                    "Cannot run the test with local IMAP server running.")
+            except socket.error:
+                pass
+
+        # This is the exception that should be raised.
+        expected_errnos = socket_helper.get_socket_conn_refused_errs()
+        with self.assertRaises(OSError) as cm:
+            imaplib.IMAP4()
+        self.assertIn(cm.exception.errno, expected_errnos)
+
+
+if ssl:
+    class SecureTCPServer(socketserver.TCPServer):
+
+        def get_request(self):
+            newsocket, fromaddr = self.socket.accept()
+            context = ssl.SSLContext(ssl.PROTOCOL_TLS_SERVER)
+            context.load_cert_chain(CERTFILE)
+            connstream = context.wrap_socket(newsocket, server_side=True)
+            return connstream, fromaddr
+
+    IMAP4_SSL = imaplib.IMAP4_SSL
+
+else:
+
+    class SecureTCPServer:
+        pass
+
+    IMAP4_SSL = None
+
+
+class SimpleIMAPHandler(socketserver.StreamRequestHandler):
+    timeout = support.LOOPBACK_TIMEOUT
+    continuation = None
+    capabilities = ''
+
+    def setup(self):
+        super().setup()
+        self.server.is_selected = False
+        self.server.logged = None
+
+    def _send(self, message):
+        if verbose:
+            print("SENT: %r" % message.strip())
+        self.wfile.write(message)
+
+    def _send_line(self, message):
+        self._send(message + b'\r\n')
+
+    def _send_textline(self, message):
+        self._send_line(message.encode('ASCII'))
+
+    def _send_tagged(self, tag, code, message):
+        self._send_textline(' '.join((tag, code, message)))
+
+    def handle(self):
+        # Send a welcome message.
+        self._send_textline('* OK IMAP4rev1')
+        while 1:
+            # Gather up input until we receive a line terminator or we timeout.
+            # Accumulate read(1) because it's simpler to handle the differences
+            # between naked sockets and SSL sockets.
+            line = b''
+            while 1:
+                try:
+                    part = self.rfile.read(1)
+                    if part == b'':
+                        # Naked sockets return empty strings..
+                        return
+                    line += part
+                except OSError:
+                    # ..but SSLSockets raise exceptions.
+                    return
+                if line.endswith(b'\r\n'):
+                    break
+
+            if verbose:
+                print('GOT: %r' % line.strip())
+            if self.continuation:
+                try:
+                    self.continuation.send(line)
+                except StopIteration:
+                    self.continuation = None
+                continue
+            splitline = line.decode('ASCII').split()
+            tag = splitline[0]
+            cmd = splitline[1]
+            args = splitline[2:]
+
+            if hasattr(self, 'cmd_' + cmd):
+                continuation = getattr(self, 'cmd_' + cmd)(tag, args)
+                if continuation:
+                    self.continuation = continuation
+                    next(continuation)
+            else:
+                self._send_tagged(tag, 'BAD', cmd + ' unknown')
+
+    def cmd_CAPABILITY(self, tag, args):
+        caps = ('IMAP4rev1 ' + self.capabilities
+                if self.capabilities
+                else 'IMAP4rev1')
+        self._send_textline('* CAPABILITY ' + caps)
+        self._send_tagged(tag, 'OK', 'CAPABILITY completed')
+
+    def cmd_LOGOUT(self, tag, args):
+        self.server.logged = None
+        self._send_textline('* BYE IMAP4ref1 Server logging out')
+        self._send_tagged(tag, 'OK', 'LOGOUT completed')
+
+    def cmd_LOGIN(self, tag, args):
+        self.server.logged = args[0]
+        self._send_tagged(tag, 'OK', 'LOGIN completed')
+
+    def cmd_SELECT(self, tag, args):
+        self.server.is_selected = True
+        self._send_line(b'* 2 EXISTS')
+        self._send_tagged(tag, 'OK', '[READ-WRITE] SELECT completed.')
+
+    def cmd_UNSELECT(self, tag, args):
+        if self.server.is_selected:
+            self.server.is_selected = False
+            self._send_tagged(tag, 'OK', 'Returned to authenticated state. (Success)')
+        else:
+            self._send_tagged(tag, 'BAD', 'No mailbox selected')
+
+
+class IdleCmdDenyHandler(SimpleIMAPHandler):
+    capabilities = 'IDLE'
+    def cmd_IDLE(self, tag, args):
+        self._send_tagged(tag, 'NO', 'IDLE is not allowed at this time')
+
+
+class IdleCmdHandler(SimpleIMAPHandler):
+    capabilities = 'IDLE'
+    def cmd_IDLE(self, tag, args):
+        # pre-idle-continuation response
+        self._send_line(b'* 0 EXISTS')
+        self._send_textline('+ idling')
+        # simple response
+        self._send_line(b'* 2 EXISTS')
+        # complex response: fragmented data due to literal string
+        self._send_line(b'* 1 FETCH (BODY[HEADER.FIELDS (DATE)] {41}')
+        self._send(b'Date: Fri, 06 Dec 2024 06:00:00 +0000\r\n\r\n')
+        self._send_line(b')')
+        # simple response following a fragmented one
+        self._send_line(b'* 3 EXISTS')
+        # response arriving later
+        time.sleep(1)
+        self._send_line(b'* 1 RECENT')
+        r = yield
+        if r == b'DONE\r\n':
+            self._send_line(b'* 9 RECENT')
+            self._send_tagged(tag, 'OK', 'Idle completed')
+        else:
+            self._send_tagged(tag, 'BAD', 'Expected DONE')
+
+
+class IdleCmdDelayedPacketHandler(SimpleIMAPHandler):
+    capabilities = 'IDLE'
+    def cmd_IDLE(self, tag, args):
+        self._send_textline('+ idling')
+        # response line spanning multiple packets, the last one delayed
+        self._send(b'* 1 EX')
+        time.sleep(0.2)
+        self._send(b'IS')
+        time.sleep(1)
+        self._send(b'TS\r\n')
+        r = yield
+        if r == b'DONE\r\n':
+            self._send_tagged(tag, 'OK', 'Idle completed')
+        else:
+            self._send_tagged(tag, 'BAD', 'Expected DONE')
+
+
+class AuthHandler_CRAM_MD5(SimpleIMAPHandler):
+    capabilities = 'LOGINDISABLED AUTH=CRAM-MD5'
+    def cmd_AUTHENTICATE(self, tag, args):
+        self._send_textline('+ PDE4OTYuNjk3MTcwOTUyQHBvc3RvZmZpY2Uucm'
+                            'VzdG9uLm1jaS5uZXQ=')
+        r = yield
+        if (r == b'dGltIGYxY2E2YmU0NjRiOWVmYT'
+                 b'FjY2E2ZmZkNmNmMmQ5ZjMy\r\n'):
+            self._send_tagged(tag, 'OK', 'CRAM-MD5 successful')
+        else:
+            self._send_tagged(tag, 'NO', 'No access')
+
+
+class NewIMAPTestsMixin:
+    client = None
+
+    def _setup(self, imap_handler, connect=True):
+        """
+        Sets up imap_handler for tests. imap_handler should inherit from either:
+        - SimpleIMAPHandler - for testing IMAP commands,
+        - socketserver.StreamRequestHandler - if raw access to stream is needed.
+        Returns (client, server).
+        """
+        class TestTCPServer(self.server_class):
+            def handle_error(self, request, client_address):
+                """
+                End request and raise the error if one occurs.
+                """
+                self.close_request(request)
+                self.server_close()
+                raise
+
+        self.addCleanup(self._cleanup)
+        self.server = self.server_class((socket_helper.HOST, 0), imap_handler)
+        self.thread = threading.Thread(
+            name=self._testMethodName+'-server',
+            target=self.server.serve_forever,
+            # Short poll interval to make the test finish quickly.
+            # Time between requests is short enough that we won't wake
+            # up spuriously too many times.
+            kwargs={'poll_interval': 0.01})
+        self.thread.daemon = True  # In case this function raises.
+        self.thread.start()
+
+        if connect:
+            self.client = self.imap_class(*self.server.server_address)
+
+        return self.client, self.server
+
+    def _cleanup(self):
+        """
+        Cleans up the test server. This method should not be called manually,
+        it is added to the cleanup queue in the _setup method already.
+        """
+        # if logout was called already we'd raise an exception trying to
+        # shutdown the client once again
+        if self.client is not None and self.client.state != 'LOGOUT':
+            self.client.shutdown()
+        # cleanup the server
+        self.server.shutdown()
+        self.server.server_close()
+        threading_helper.join_thread(self.thread)
+        # Explicitly clear the attribute to prevent dangling thread
+        self.thread = None
+
+    def test_EOF_without_complete_welcome_message(self):
+        # http://bugs.python.org/issue5949
+        class EOFHandler(socketserver.StreamRequestHandler):
+            def handle(self):
+                self.wfile.write(b'* OK')
+        _, server = self._setup(EOFHandler, connect=False)
+        self.assertRaises(imaplib.IMAP4.abort, self.imap_class,
+                          *server.server_address)
+
+    def test_line_termination(self):
+        class BadNewlineHandler(SimpleIMAPHandler):
+            def cmd_CAPABILITY(self, tag, args):
+                self._send(b'* CAPABILITY IMAP4rev1 AUTH\n')
+                self._send_tagged(tag, 'OK', 'CAPABILITY completed')
+        _, server = self._setup(BadNewlineHandler, connect=False)
+        self.assertRaises(imaplib.IMAP4.abort, self.imap_class,
+                          *server.server_address)
+
+    def test_enable_raises_error_if_not_AUTH(self):
+        class EnableHandler(SimpleIMAPHandler):
+            capabilities = 'AUTH ENABLE UTF8=ACCEPT'
+        client, _ = self._setup(EnableHandler)
+        self.assertFalse(client.utf8_enabled)
+        with self.assertRaisesRegex(imaplib.IMAP4.error, 'ENABLE.*NONAUTH'):
+            client.enable('foo')
+        self.assertFalse(client.utf8_enabled)
+
+    def test_enable_raises_error_if_no_capability(self):
+        client, _ = self._setup(SimpleIMAPHandler)
+        with self.assertRaisesRegex(imaplib.IMAP4.error,
+                'does not support ENABLE'):
+            client.enable('foo')
+
+    def test_enable_UTF8_raises_error_if_not_supported(self):
+        client, _ = self._setup(SimpleIMAPHandler)
+        typ, data = client.login('user', 'pass')
+        self.assertEqual(typ, 'OK')
+        with self.assertRaisesRegex(imaplib.IMAP4.error,
+                'does not support ENABLE'):
+            client.enable('UTF8=ACCEPT')
+
+    def test_enable_UTF8_True_append(self):
+        class UTF8AppendServer(SimpleIMAPHandler):
+            capabilities = 'ENABLE UTF8=ACCEPT'
+            def cmd_ENABLE(self, tag, args):
+                self._send_tagged(tag, 'OK', 'ENABLE successful')
+            def cmd_AUTHENTICATE(self, tag, args):
+                self._send_textline('+')
+                self.server.response = yield
+                self._send_tagged(tag, 'OK', 'FAKEAUTH successful')
+            def cmd_APPEND(self, tag, args):
+                self._send_textline('+')
+                self.server.response = args
+                literal = yield
+                self.server.response.append(literal)
+                literal = yield
+                self.server.response.append(literal)
+                self._send_tagged(tag, 'OK', 'okay')
+        client, server = self._setup(UTF8AppendServer)
+        self.assertEqual(client._encoding, 'ascii')
+        code, _ = client.authenticate('MYAUTH', lambda x: b'fake')
+        self.assertEqual(code, 'OK')
+        self.assertEqual(server.response, b'ZmFrZQ==\r\n')  # b64 encoded 'fake'
+        code, _ = client.enable('UTF8=ACCEPT')
+        self.assertEqual(code, 'OK')
+        self.assertEqual(client._encoding, 'utf-8')
+        msg_string = 'Subject: üñí©öðé'
+        typ, data = client.append(
+            None, None, None, (msg_string + '\n').encode('utf-8'))
+        self.assertEqual(typ, 'OK')
+        self.assertEqual(server.response,
+            ['INBOX', 'UTF8',
+             '(~{25}', ('%s\r\n' % msg_string).encode('utf-8'),
+             b')\r\n' ])
+
+    def test_search_disallows_charset_in_utf8_mode(self):
+        class UTF8Server(SimpleIMAPHandler):
+            capabilities = 'AUTH ENABLE UTF8=ACCEPT'
+            def cmd_ENABLE(self, tag, args):
+                self._send_tagged(tag, 'OK', 'ENABLE successful')
+            def cmd_AUTHENTICATE(self, tag, args):
+                self._send_textline('+')
+                self.server.response = yield
+                self._send_tagged(tag, 'OK', 'FAKEAUTH successful')
+        client, _ = self._setup(UTF8Server)
+        typ, _ = client.authenticate('MYAUTH', lambda x: b'fake')
+        self.assertEqual(typ, 'OK')
+        typ, _ = client.enable('UTF8=ACCEPT')
+        self.assertEqual(typ, 'OK')
+        self.assertTrue(client.utf8_enabled)
+        with self.assertRaisesRegex(imaplib.IMAP4.error, 'charset.*UTF8'):
+            client.search('foo', 'bar')
+
+    def test_bad_auth_name(self):
+        class MyServer(SimpleIMAPHandler):
+            def cmd_AUTHENTICATE(self, tag, args):
+                self._send_tagged(tag, 'NO',
+                    'unrecognized authentication type {}'.format(args[0]))
+        client, _ = self._setup(MyServer)
+        with self.assertRaisesRegex(imaplib.IMAP4.error,
+                'unrecognized authentication type METHOD'):
+            client.authenticate('METHOD', lambda: 1)
+
+    def test_invalid_authentication(self):
+        class MyServer(SimpleIMAPHandler):
+            def cmd_AUTHENTICATE(self, tag, args):
+                self._send_textline('+')
+                self.response = yield
+                self._send_tagged(tag, 'NO', '[AUTHENTICATIONFAILED] invalid')
+        client, _ = self._setup(MyServer)
+        with self.assertRaisesRegex(imaplib.IMAP4.error,
+                r'\[AUTHENTICATIONFAILED\] invalid'):
+            client.authenticate('MYAUTH', lambda x: b'fake')
+
+    def test_valid_authentication_bytes(self):
+        class MyServer(SimpleIMAPHandler):
+            def cmd_AUTHENTICATE(self, tag, args):
+                self._send_textline('+')
+                self.server.response = yield
+                self._send_tagged(tag, 'OK', 'FAKEAUTH successful')
+        client, server = self._setup(MyServer)
+        code, _ = client.authenticate('MYAUTH', lambda x: b'fake')
+        self.assertEqual(code, 'OK')
+        self.assertEqual(server.response, b'ZmFrZQ==\r\n')  # b64 encoded 'fake'
+
+    def test_valid_authentication_plain_text(self):
+        class MyServer(SimpleIMAPHandler):
+            def cmd_AUTHENTICATE(self, tag, args):
+                self._send_textline('+')
+                self.server.response = yield
+                self._send_tagged(tag, 'OK', 'FAKEAUTH successful')
+        client, server = self._setup(MyServer)
+        code, _ = client.authenticate('MYAUTH', lambda x: 'fake')
+        self.assertEqual(code, 'OK')
+        self.assertEqual(server.response, b'ZmFrZQ==\r\n')  # b64 encoded 'fake'
+
+    @hashlib_helper.requires_hashdigest('md5', openssl=True)
+    def test_login_cram_md5_bytes(self):
+        client, _ = self._setup(AuthHandler_CRAM_MD5)
+        self.assertIn('AUTH=CRAM-MD5', client.capabilities)
+        ret, _ = client.login_cram_md5("tim", b"tanstaaftanstaaf")
+        self.assertEqual(ret, "OK")
+
+    @hashlib_helper.requires_hashdigest('md5', openssl=True)
+    def test_login_cram_md5_plain_text(self):
+        client, _ = self._setup(AuthHandler_CRAM_MD5)
+        self.assertIn('AUTH=CRAM-MD5', client.capabilities)
+        ret, _ = client.login_cram_md5("tim", "tanstaaftanstaaf")
+        self.assertEqual(ret, "OK")
+
+    def test_login_cram_md5_blocked(self):
+        def side_effect(*a, **kw):
+            raise ValueError
+
+        client, _ = self._setup(AuthHandler_CRAM_MD5)
+        self.assertIn('AUTH=CRAM-MD5', client.capabilities)
+        msg = re.escape("CRAM-MD5 authentication is not supported")
+        with (
+            mock.patch("hmac.HMAC", side_effect=side_effect),
+            self.assertRaisesRegex(imaplib.IMAP4.error, msg)
+        ):
+            client.login_cram_md5("tim", b"tanstaaftanstaaf")
+
+    def test_aborted_authentication(self):
+        class MyServer(SimpleIMAPHandler):
+            def cmd_AUTHENTICATE(self, tag, args):
+                self._send_textline('+')
+                self.response = yield
+                if self.response == b'*\r\n':
+                    self._send_tagged(
+                        tag,
+                        'NO',
+                        '[AUTHENTICATIONFAILED] aborted')
+                else:
+                    self._send_tagged(tag, 'OK', 'MYAUTH successful')
+        client, _ = self._setup(MyServer)
+        with self.assertRaisesRegex(imaplib.IMAP4.error,
+                r'\[AUTHENTICATIONFAILED\] aborted'):
+            client.authenticate('MYAUTH', lambda x: None)
+
+    @mock.patch('imaplib._MAXLINE', 10)
+    def test_linetoolong(self):
+        class TooLongHandler(SimpleIMAPHandler):
+            def handle(self):
+                # send response line longer than the limit set in the next line
+                self.wfile.write(b'* OK ' + 11 * b'x' + b'\r\n')
+        _, server = self._setup(TooLongHandler, connect=False)
+        with self.assertRaisesRegex(imaplib.IMAP4.error,
+                'got more than 10 bytes'):
+            self.imap_class(*server.server_address)
+
+    def test_simple_with_statement(self):
+        _, server = self._setup(SimpleIMAPHandler, connect=False)
+        with self.imap_class(*server.server_address):
+            pass
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AttributeError: 'socket' object has no attribute 'timeout'. Did you mean: 'gettimeout'?
+    def test_imaplib_timeout_test(self):
+        _, server = self._setup(SimpleIMAPHandler, connect=False)
+        with self.imap_class(*server.server_address, timeout=None) as client:
+            self.assertEqual(client.sock.timeout, None)
+        with self.imap_class(*server.server_address, timeout=support.LOOPBACK_TIMEOUT) as client:
+            self.assertEqual(client.sock.timeout, support.LOOPBACK_TIMEOUT)
+        with self.assertRaises(ValueError):
+            self.imap_class(*server.server_address, timeout=0)
+
+    def test_imaplib_timeout_functionality_test(self):
+        class TimeoutHandler(SimpleIMAPHandler):
+            def handle(self):
+                time.sleep(1)
+                SimpleIMAPHandler.handle(self)
+
+        _, server = self._setup(TimeoutHandler)
+        addr = server.server_address[1]
+        with self.assertRaises(TimeoutError):
+            client = self.imap_class("localhost", addr, timeout=0.001)
+
+    def test_with_statement(self):
+        _, server = self._setup(SimpleIMAPHandler, connect=False)
+        with self.imap_class(*server.server_address) as imap:
+            imap.login('user', 'pass')
+            self.assertEqual(server.logged, 'user')
+        self.assertIsNone(server.logged)
+
+    def test_with_statement_logout(self):
+        # It is legal to log out explicitly inside the with block
+        _, server = self._setup(SimpleIMAPHandler, connect=False)
+        with self.imap_class(*server.server_address) as imap:
+            imap.login('user', 'pass')
+            self.assertEqual(server.logged, 'user')
+            imap.logout()
+            self.assertIsNone(server.logged)
+        self.assertIsNone(server.logged)
+
+    # command tests
+
+    def test_idle_capability(self):
+        client, _ = self._setup(SimpleIMAPHandler)
+        with self.assertRaisesRegex(imaplib.IMAP4.error,
+                'does not support IMAP4 IDLE'):
+            with client.idle():
+                pass
+
+    def test_idle_denied(self):
+        client, _ = self._setup(IdleCmdDenyHandler)
+        client.login('user', 'pass')
+        with self.assertRaises(imaplib.IMAP4.error):
+            with client.idle() as idler:
+                pass
+
+    def test_idle_iter(self):
+        client, _ = self._setup(IdleCmdHandler)
+        client.login('user', 'pass')
+        with client.idle() as idler:
+            # iteration should include response between 'IDLE' & '+ idling'
+            response = next(idler)
+            self.assertEqual(response, ('EXISTS', [b'0']))
+            # iteration should produce responses
+            response = next(idler)
+            self.assertEqual(response, ('EXISTS', [b'2']))
+            # fragmented response (with literal string) should arrive whole
+            expected_fetch_data = [
+                (b'1 (BODY[HEADER.FIELDS (DATE)] {41}',
+                    b'Date: Fri, 06 Dec 2024 06:00:00 +0000\r\n\r\n'),
+                b')']
+            typ, data = next(idler)
+            self.assertEqual(typ, 'FETCH')
+            self.assertEqual(data, expected_fetch_data)
+            # response after a fragmented one should arrive separately
+            response = next(idler)
+            self.assertEqual(response, ('EXISTS', [b'3']))
+        # iteration should have consumed untagged responses
+        _, data = client.response('EXISTS')
+        self.assertEqual(data, [None])
+        # responses not iterated should be available after idle
+        _, data = client.response('RECENT')
+        self.assertEqual(data[0], b'1')
+        # responses received after 'DONE' should be available after idle
+        self.assertEqual(data[1], b'9')
+
+    def test_idle_burst(self):
+        client, _ = self._setup(IdleCmdHandler)
+        client.login('user', 'pass')
+        # burst() should yield immediately available responses
+        with client.idle() as idler:
+            batch = list(idler.burst())
+            self.assertEqual(len(batch), 4)
+        # burst() should not have consumed later responses
+        _, data = client.response('RECENT')
+        self.assertEqual(data, [b'1', b'9'])
+
+    def test_idle_delayed_packet(self):
+        client, _ = self._setup(IdleCmdDelayedPacketHandler)
+        client.login('user', 'pass')
+        # If our readline() implementation fails to preserve line fragments
+        # when idle timeouts trigger, a response spanning delayed packets
+        # can be corrupted, leaving the protocol stream in a bad state.
+        try:
+            with client.idle(0.5) as idler:
+                self.assertRaises(StopIteration, next, idler)
+        except client.abort as err:
+            self.fail('multi-packet response was corrupted by idle timeout')
+
+    def test_login(self):
+        client, _ = self._setup(SimpleIMAPHandler)
+        typ, data = client.login('user', 'pass')
+        self.assertEqual(typ, 'OK')
+        self.assertEqual(data[0], b'LOGIN completed')
+        self.assertEqual(client.state, 'AUTH')
+
+    def test_logout(self):
+        client, _ = self._setup(SimpleIMAPHandler)
+        typ, data = client.login('user', 'pass')
+        self.assertEqual(typ, 'OK')
+        self.assertEqual(data[0], b'LOGIN completed')
+        typ, data = client.logout()
+        self.assertEqual(typ, 'BYE', (typ, data))
+        self.assertEqual(data[0], b'IMAP4ref1 Server logging out', (typ, data))
+        self.assertEqual(client.state, 'LOGOUT')
+
+    def test_lsub(self):
+        class LsubCmd(SimpleIMAPHandler):
+            def cmd_LSUB(self, tag, args):
+                self._send_textline('* LSUB () "." directoryA')
+                return self._send_tagged(tag, 'OK', 'LSUB completed')
+        client, _ = self._setup(LsubCmd)
+        client.login('user', 'pass')
+        typ, data = client.lsub()
+        self.assertEqual(typ, 'OK')
+        self.assertEqual(data[0], b'() "." directoryA')
+
+    def test_unselect(self):
+        client, _ = self._setup(SimpleIMAPHandler)
+        client.login('user', 'pass')
+        typ, data = client.select()
+        self.assertEqual(typ, 'OK')
+        self.assertEqual(data[0], b'2')
+
+        typ, data = client.unselect()
+        self.assertEqual(typ, 'OK')
+        self.assertEqual(data[0], b'Returned to authenticated state. (Success)')
+        self.assertEqual(client.state, 'AUTH')
+
+    # property tests
+
+    def test_file_property_should_not_be_accessed(self):
+        client, _ = self._setup(SimpleIMAPHandler)
+        # the 'file' property replaced a private attribute that is now unsafe
+        with self.assertWarns(RuntimeWarning):
+            client.file
+
+
+class NewIMAPTests(NewIMAPTestsMixin, unittest.TestCase):
+    imap_class = imaplib.IMAP4
+    server_class = socketserver.TCPServer
+
+
+@unittest.skipUnless(ssl, "SSL not available")
+class NewIMAPSSLTests(NewIMAPTestsMixin, unittest.TestCase):
+    imap_class = IMAP4_SSL
+    server_class = SecureTCPServer
+
+    def test_ssl_raises(self):
+        ssl_context = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)
+        self.assertEqual(ssl_context.verify_mode, ssl.CERT_REQUIRED)
+        self.assertEqual(ssl_context.check_hostname, True)
+        ssl_context.load_verify_locations(CAFILE)
+
+        # Allow for flexible libssl error messages.
+        regex = re.compile(r"""(
+            IP address mismatch, certificate is not valid for '127.0.0.1'   # OpenSSL
+            |
+            CERTIFICATE_VERIFY_FAILED                                       # AWS-LC
+        )""", re.X)
+        with self.assertRaisesRegex(ssl.CertificateError, regex):
+            _, server = self._setup(SimpleIMAPHandler, connect=False)
+            client = self.imap_class(*server.server_address,
+                                     ssl_context=ssl_context)
+            client.shutdown()
+
+    def test_ssl_verified(self):
+        ssl_context = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)
+        ssl_context.load_verify_locations(CAFILE)
+
+        _, server = self._setup(SimpleIMAPHandler, connect=False)
+        client = self.imap_class("localhost", server.server_address[1],
+                                 ssl_context=ssl_context)
+        client.shutdown()
+
+class ThreadedNetworkedTests(unittest.TestCase):
+    server_class = socketserver.TCPServer
+    imap_class = imaplib.IMAP4
+
+    def make_server(self, addr, hdlr):
+
+        class MyServer(self.server_class):
+            def handle_error(self, request, client_address):
+                self.close_request(request)
+                self.server_close()
+                raise
+
+        if verbose:
+            print("creating server")
+        server = MyServer(addr, hdlr)
+        self.assertEqual(server.server_address, server.socket.getsockname())
+
+        if verbose:
+            print("server created")
+            print("ADDR =", addr)
+            print("CLASS =", self.server_class)
+            print("HDLR =", server.RequestHandlerClass)
+
+        t = threading.Thread(
+            name='%s serving' % self.server_class,
+            target=server.serve_forever,
+            # Short poll interval to make the test finish quickly.
+            # Time between requests is short enough that we won't wake
+            # up spuriously too many times.
+            kwargs={'poll_interval': 0.01})
+        t.daemon = True  # In case this function raises.
+        t.start()
+        if verbose:
+            print("server running")
+        return server, t
+
+    def reap_server(self, server, thread):
+        if verbose:
+            print("waiting for server")
+        server.shutdown()
+        server.server_close()
+        thread.join()
+        if verbose:
+            print("done")
+
+    @contextmanager
+    def reaped_server(self, hdlr):
+        server, thread = self.make_server((socket_helper.HOST, 0), hdlr)
+        try:
+            yield server
+        finally:
+            self.reap_server(server, thread)
+
+    @contextmanager
+    def reaped_pair(self, hdlr):
+        with self.reaped_server(hdlr) as server:
+            client = self.imap_class(*server.server_address)
+            try:
+                yield server, client
+            finally:
+                client.logout()
+
+    @threading_helper.reap_threads
+    def test_connect(self):
+        with self.reaped_server(SimpleIMAPHandler) as server:
+            client = self.imap_class(*server.server_address)
+            client.shutdown()
+
+    @threading_helper.reap_threads
+    def test_bracket_flags(self):
+
+        # This violates RFC 3501, which disallows ']' characters in tag names,
+        # but imaplib has allowed producing such tags forever, other programs
+        # also produce them (eg: OtherInbox's Organizer app as of 20140716),
+        # and Gmail, for example, accepts them and produces them.  So we
+        # support them.  See issue #21815.
+
+        class BracketFlagHandler(SimpleIMAPHandler):
+
+            def handle(self):
+                self.flags = ['Answered', 'Flagged', 'Deleted', 'Seen', 'Draft']
+                super().handle()
+
+            def cmd_AUTHENTICATE(self, tag, args):
+                self._send_textline('+')
+                self.server.response = yield
+                self._send_tagged(tag, 'OK', 'FAKEAUTH successful')
+
+            def cmd_SELECT(self, tag, args):
+                flag_msg = ' \\'.join(self.flags)
+                self._send_line(('* FLAGS (%s)' % flag_msg).encode('ascii'))
+                self._send_line(b'* 2 EXISTS')
+                self._send_line(b'* 0 RECENT')
+                msg = ('* OK [PERMANENTFLAGS %s \\*)] Flags permitted.'
+                        % flag_msg)
+                self._send_line(msg.encode('ascii'))
+                self._send_tagged(tag, 'OK', '[READ-WRITE] SELECT completed.')
+
+            def cmd_STORE(self, tag, args):
+                new_flags = args[2].strip('(').strip(')').split()
+                self.flags.extend(new_flags)
+                flags_msg = '(FLAGS (%s))' % ' \\'.join(self.flags)
+                msg = '* %s FETCH %s' % (args[0], flags_msg)
+                self._send_line(msg.encode('ascii'))
+                self._send_tagged(tag, 'OK', 'STORE completed.')
+
+        with self.reaped_pair(BracketFlagHandler) as (server, client):
+            code, data = client.authenticate('MYAUTH', lambda x: b'fake')
+            self.assertEqual(code, 'OK')
+            self.assertEqual(server.response, b'ZmFrZQ==\r\n')
+            client.select('test')
+            typ, [data] = client.store(b'1', "+FLAGS", "[test]")
+            self.assertIn(b'[test]', data)
+            client.select('test')
+            typ, [data] = client.response('PERMANENTFLAGS')
+            self.assertIn(b'[test]', data)
+
+    @threading_helper.reap_threads
+    def test_issue5949(self):
+
+        class EOFHandler(socketserver.StreamRequestHandler):
+            def handle(self):
+                # EOF without sending a complete welcome message.
+                self.wfile.write(b'* OK')
+
+        with self.reaped_server(EOFHandler) as server:
+            self.assertRaises(imaplib.IMAP4.abort,
+                              self.imap_class, *server.server_address)
+
+    @threading_helper.reap_threads
+    def test_line_termination(self):
+
+        class BadNewlineHandler(SimpleIMAPHandler):
+
+            def cmd_CAPABILITY(self, tag, args):
+                self._send(b'* CAPABILITY IMAP4rev1 AUTH\n')
+                self._send_tagged(tag, 'OK', 'CAPABILITY completed')
+
+        with self.reaped_server(BadNewlineHandler) as server:
+            self.assertRaises(imaplib.IMAP4.abort,
+                              self.imap_class, *server.server_address)
+
+    class UTF8Server(SimpleIMAPHandler):
+        capabilities = 'AUTH ENABLE UTF8=ACCEPT'
+
+        def cmd_ENABLE(self, tag, args):
+            self._send_tagged(tag, 'OK', 'ENABLE successful')
+
+        def cmd_AUTHENTICATE(self, tag, args):
+            self._send_textline('+')
+            self.server.response = yield
+            self._send_tagged(tag, 'OK', 'FAKEAUTH successful')
+
+    @threading_helper.reap_threads
+    def test_enable_raises_error_if_not_AUTH(self):
+        with self.reaped_pair(self.UTF8Server) as (server, client):
+            self.assertFalse(client.utf8_enabled)
+            self.assertRaises(imaplib.IMAP4.error, client.enable, 'foo')
+            self.assertFalse(client.utf8_enabled)
+
+    # XXX Also need a test that enable after SELECT raises an error.
+
+    @threading_helper.reap_threads
+    def test_enable_raises_error_if_no_capability(self):
+        class NoEnableServer(self.UTF8Server):
+            capabilities = 'AUTH'
+        with self.reaped_pair(NoEnableServer) as (server, client):
+            self.assertRaises(imaplib.IMAP4.error, client.enable, 'foo')
+
+    @threading_helper.reap_threads
+    def test_enable_UTF8_raises_error_if_not_supported(self):
+        class NonUTF8Server(SimpleIMAPHandler):
+            pass
+        with self.assertRaises(imaplib.IMAP4.error):
+            with self.reaped_pair(NonUTF8Server) as (server, client):
+                typ, data = client.login('user', 'pass')
+                self.assertEqual(typ, 'OK')
+                client.enable('UTF8=ACCEPT')
+
+    @threading_helper.reap_threads
+    def test_enable_UTF8_True_append(self):
+
+        class UTF8AppendServer(self.UTF8Server):
+            def cmd_APPEND(self, tag, args):
+                self._send_textline('+')
+                self.server.response = args
+                literal = yield
+                self.server.response.append(literal)
+                literal = yield
+                self.server.response.append(literal)
+                self._send_tagged(tag, 'OK', 'okay')
+
+        with self.reaped_pair(UTF8AppendServer) as (server, client):
+            self.assertEqual(client._encoding, 'ascii')
+            code, _ = client.authenticate('MYAUTH', lambda x: b'fake')
+            self.assertEqual(code, 'OK')
+            self.assertEqual(server.response,
+                             b'ZmFrZQ==\r\n')  # b64 encoded 'fake'
+            code, _ = client.enable('UTF8=ACCEPT')
+            self.assertEqual(code, 'OK')
+            self.assertEqual(client._encoding, 'utf-8')
+            msg_string = 'Subject: üñí©öðé'
+            typ, data = client.append(
+                None, None, None, (msg_string + '\n').encode('utf-8'))
+            self.assertEqual(typ, 'OK')
+            self.assertEqual(server.response,
+                ['INBOX', 'UTF8',
+                 '(~{25}', ('%s\r\n' % msg_string).encode('utf-8'),
+                 b')\r\n' ])
+
+    # XXX also need a test that makes sure that the Literal and Untagged_status
+    # regexes uses unicode in UTF8 mode instead of the default ASCII.
+
+    @threading_helper.reap_threads
+    def test_search_disallows_charset_in_utf8_mode(self):
+        with self.reaped_pair(self.UTF8Server) as (server, client):
+            typ, _ = client.authenticate('MYAUTH', lambda x: b'fake')
+            self.assertEqual(typ, 'OK')
+            typ, _ = client.enable('UTF8=ACCEPT')
+            self.assertEqual(typ, 'OK')
+            self.assertTrue(client.utf8_enabled)
+            self.assertRaises(imaplib.IMAP4.error, client.search, 'foo', 'bar')
+
+    @threading_helper.reap_threads
+    def test_bad_auth_name(self):
+
+        class MyServer(SimpleIMAPHandler):
+
+            def cmd_AUTHENTICATE(self, tag, args):
+                self._send_tagged(tag, 'NO', 'unrecognized authentication '
+                                  'type {}'.format(args[0]))
+
+        with self.reaped_pair(MyServer) as (server, client):
+            with self.assertRaises(imaplib.IMAP4.error):
+                client.authenticate('METHOD', lambda: 1)
+
+    @threading_helper.reap_threads
+    def test_invalid_authentication(self):
+
+        class MyServer(SimpleIMAPHandler):
+
+            def cmd_AUTHENTICATE(self, tag, args):
+                self._send_textline('+')
+                self.response = yield
+                self._send_tagged(tag, 'NO', '[AUTHENTICATIONFAILED] invalid')
+
+        with self.reaped_pair(MyServer) as (server, client):
+            with self.assertRaises(imaplib.IMAP4.error):
+                code, data = client.authenticate('MYAUTH', lambda x: b'fake')
+
+    @threading_helper.reap_threads
+    def test_valid_authentication(self):
+
+        class MyServer(SimpleIMAPHandler):
+
+            def cmd_AUTHENTICATE(self, tag, args):
+                self._send_textline('+')
+                self.server.response = yield
+                self._send_tagged(tag, 'OK', 'FAKEAUTH successful')
+
+        with self.reaped_pair(MyServer) as (server, client):
+            code, data = client.authenticate('MYAUTH', lambda x: b'fake')
+            self.assertEqual(code, 'OK')
+            self.assertEqual(server.response,
+                             b'ZmFrZQ==\r\n')  # b64 encoded 'fake'
+
+        with self.reaped_pair(MyServer) as (server, client):
+            code, data = client.authenticate('MYAUTH', lambda x: 'fake')
+            self.assertEqual(code, 'OK')
+            self.assertEqual(server.response,
+                             b'ZmFrZQ==\r\n')  # b64 encoded 'fake'
+
+    @threading_helper.reap_threads
+    @hashlib_helper.requires_hashdigest('md5', openssl=True)
+    def test_login_cram_md5(self):
+
+        class AuthHandler(SimpleIMAPHandler):
+
+            capabilities = 'LOGINDISABLED AUTH=CRAM-MD5'
+
+            def cmd_AUTHENTICATE(self, tag, args):
+                self._send_textline('+ PDE4OTYuNjk3MTcwOTUyQHBvc3RvZmZpY2Uucm'
+                                    'VzdG9uLm1jaS5uZXQ=')
+                r = yield
+                if (r == b'dGltIGYxY2E2YmU0NjRiOWVmYT'
+                         b'FjY2E2ZmZkNmNmMmQ5ZjMy\r\n'):
+                    self._send_tagged(tag, 'OK', 'CRAM-MD5 successful')
+                else:
+                    self._send_tagged(tag, 'NO', 'No access')
+
+        with self.reaped_pair(AuthHandler) as (server, client):
+            self.assertTrue('AUTH=CRAM-MD5' in client.capabilities)
+            ret, data = client.login_cram_md5("tim", "tanstaaftanstaaf")
+            self.assertEqual(ret, "OK")
+
+        with self.reaped_pair(AuthHandler) as (server, client):
+            self.assertTrue('AUTH=CRAM-MD5' in client.capabilities)
+            ret, data = client.login_cram_md5("tim", b"tanstaaftanstaaf")
+            self.assertEqual(ret, "OK")
+
+
+    @threading_helper.reap_threads
+    def test_aborted_authentication(self):
+
+        class MyServer(SimpleIMAPHandler):
+
+            def cmd_AUTHENTICATE(self, tag, args):
+                self._send_textline('+')
+                self.response = yield
+
+                if self.response == b'*\r\n':
+                    self._send_tagged(tag, 'NO', '[AUTHENTICATIONFAILED] aborted')
+                else:
+                    self._send_tagged(tag, 'OK', 'MYAUTH successful')
+
+        with self.reaped_pair(MyServer) as (server, client):
+            with self.assertRaises(imaplib.IMAP4.error):
+                code, data = client.authenticate('MYAUTH', lambda x: None)
+
+
+    def test_linetoolong(self):
+        class TooLongHandler(SimpleIMAPHandler):
+            def handle(self):
+                # Send a very long response line
+                self.wfile.write(b'* OK ' + imaplib._MAXLINE * b'x' + b'\r\n')
+
+        with self.reaped_server(TooLongHandler) as server:
+            self.assertRaises(imaplib.IMAP4.error,
+                              self.imap_class, *server.server_address)
+
+    def test_truncated_large_literal(self):
+        size = 0
+        class BadHandler(SimpleIMAPHandler):
+            def handle(self):
+                self._send_textline('* OK {%d}' % size)
+                self._send_textline('IMAP4rev1')
+
+        for exponent in range(15, 64):
+            size = 1 << exponent
+            with self.subTest(f"size=2e{size}"):
+                with self.reaped_server(BadHandler) as server:
+                    with self.assertRaises(imaplib.IMAP4.abort):
+                        self.imap_class(*server.server_address)
+
+    @threading_helper.reap_threads
+    def test_simple_with_statement(self):
+        # simplest call
+        with self.reaped_server(SimpleIMAPHandler) as server:
+            with self.imap_class(*server.server_address):
+                pass
+
+    @threading_helper.reap_threads
+    def test_with_statement(self):
+        with self.reaped_server(SimpleIMAPHandler) as server:
+            with self.imap_class(*server.server_address) as imap:
+                imap.login('user', 'pass')
+                self.assertEqual(server.logged, 'user')
+            self.assertIsNone(server.logged)
+
+    @threading_helper.reap_threads
+    def test_with_statement_logout(self):
+        # what happens if already logout in the block?
+        with self.reaped_server(SimpleIMAPHandler) as server:
+            with self.imap_class(*server.server_address) as imap:
+                imap.login('user', 'pass')
+                self.assertEqual(server.logged, 'user')
+                imap.logout()
+                self.assertIsNone(server.logged)
+            self.assertIsNone(server.logged)
+
+    @threading_helper.reap_threads
+    @cpython_only
+    @unittest.skipUnless(__debug__, "Won't work if __debug__ is False")
+    def test_dump_ur(self):
+        # See: http://bugs.python.org/issue26543
+        untagged_resp_dict = {'READ-WRITE': [b'']}
+
+        with self.reaped_server(SimpleIMAPHandler) as server:
+            with self.imap_class(*server.server_address) as imap:
+                with mock.patch.object(imap, '_mesg') as mock_mesg:
+                    imap._dump_ur(untagged_resp_dict)
+                    mock_mesg.assert_called_with(
+                        "untagged responses dump:READ-WRITE: [b'']"
+                    )
+
+
+@unittest.skipUnless(ssl, "SSL not available")
+class ThreadedNetworkedTestsSSL(ThreadedNetworkedTests):
+    server_class = SecureTCPServer
+    imap_class = IMAP4_SSL
+
+    @threading_helper.reap_threads
+    def test_ssl_verified(self):
+        ssl_context = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)
+        ssl_context.load_verify_locations(CAFILE)
+
+        # Allow for flexible libssl error messages.
+        regex = re.compile(r"""(
+            IP address mismatch, certificate is not valid for '127.0.0.1'   # OpenSSL
+            |
+            CERTIFICATE_VERIFY_FAILED                                       # AWS-LC
+        )""", re.X)
+        with self.assertRaisesRegex(ssl.CertificateError, regex):
+            with self.reaped_server(SimpleIMAPHandler) as server:
+                client = self.imap_class(*server.server_address,
+                                         ssl_context=ssl_context)
+                client.shutdown()
+
+        with self.reaped_server(SimpleIMAPHandler) as server:
+            client = self.imap_class("localhost", server.server_address[1],
+                                     ssl_context=ssl_context)
+            client.shutdown()
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/Lib/test/test_import/__init__.py b/Lib/test/test_import/__init__.py
index 5865dcef1e3..6920cf45533 100644
--- a/Lib/test/test_import/__init__.py
+++ b/Lib/test/test_import/__init__.py
@@ -35,12 +35,13 @@
     cpython_only,
     is_apple_mobile,
     is_emscripten,
-    is_wasi,
+    is_wasm32,
     run_in_subinterp,
     run_in_subinterp_with_config,
     Py_TRACE_REFS,
     requires_gil_enabled,
     Py_GIL_DISABLED,
+    no_rerun,
     force_not_colorized_test_class,
 )
 from test.support.import_helper import (
@@ -50,7 +51,6 @@
     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:
@@ -150,25 +150,6 @@ def remove_files(name):
     rmtree('__pycache__')
 
 
-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
@@ -365,7 +346,7 @@ def _from_subinterp(cls, name, interpid, pipe, script_kwargs):
 
 
 @force_not_colorized_test_class
-class ImportTests(unittest.TestCase, ExtraAssertions):
+class ImportTests(unittest.TestCase):
 
     def setUp(self):
         remove_files(TESTFN)
@@ -386,7 +367,6 @@ def test_from_import_missing_attr_raises_ImportError(self):
         with self.assertRaises(ImportError):
             from importlib import something_that_should_not_exist_anywhere
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_from_import_missing_attr_has_name_and_path(self):
         with CleanImport('os'):
             import os
@@ -425,14 +405,12 @@ def test_from_import_missing_attr_has_name(self):
         self.assertEqual(cm.exception.name, '_warning')
         self.assertIsNone(cm.exception.path)
 
-    @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)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_from_import_star_invalid_type(self):
         import re
         with ready_to_import() as (name, path):
@@ -462,7 +440,7 @@ def test_case_sensitivity(self):
 
     def test_double_const(self):
         # Importing double_const checks that float constants
-        # serialiazed by marshal as PYC files don't lose precision
+        # serialized 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')
@@ -727,7 +705,6 @@ def test_from_import_message_for_existing_module(self):
         with self.assertRaisesRegex(ImportError, "^cannot import name 'bogus'"):
             from re import bogus
 
-    @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.
@@ -791,7 +768,7 @@ def run():
         finally:
             del sys.path[0]
 
-    @unittest.expectedFailure  # TODO: RUSTPYTHON; FileNotFoundError: [WinError 2] No such file or directory: 'built-in'
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; no C extension support
     @unittest.skipUnless(sys.platform == "win32", "Windows-specific")
     def test_dll_dependency_import(self):
         from _winapi import GetModuleFileName
@@ -837,7 +814,6 @@ 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:
@@ -845,7 +821,6 @@ def test_issue105979(self):
         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
@@ -890,7 +865,6 @@ def test_frozen_module_from_import_error(self):
                 stdout, stderr = popen.communicate()
                 self.assertIn(expected_error, stdout)
 
-    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_non_module_from_import_error(self):
         prefix = """
 import sys
@@ -914,7 +888,6 @@ class NotAModule: ...
             stdout, stderr = popen.communicate()
             self.assertIn(expected_error, stdout)
 
-    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_script_shadowing_stdlib(self):
         script_errors = [
             (
@@ -970,7 +943,6 @@ def test_script_shadowing_stdlib(self):
                 stdout, stderr = popen.communicate()
                 self.assertEqual(stdout, b'')  # no error
 
-    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_package_shadowing_stdlib_module(self):
         script_errors = [
             (
@@ -1012,7 +984,6 @@ def test_package_shadowing_stdlib_module(self):
                 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 = [
             (
@@ -1031,7 +1002,7 @@ def test_script_shadowing_third_party(self):
 
                 expected_error = error + (
                     rb" \(consider renaming '.*numpy.py' if it has the "
-                    rb"same name as a library you intended to import\)\s+\Z"
+                    rb"same name as a library you intended to import\)\s+\z"
                 )
 
                 popen = script_helper.spawn_python(os.path.join(tmp, "numpy.py"))
@@ -1046,27 +1017,25 @@ def test_script_shadowing_third_party(self):
                 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"
+                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"
+                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:
@@ -1087,7 +1056,7 @@ class substr(str):
 """)
             popen = script_helper.spawn_python("main.py", cwd=tmp)
             stdout, stderr = popen.communicate()
-            self.assertEqual(stdout.rstrip(), b"unhashable type: 'substr'")
+            self.assertIn(b"unhashable type: 'substr'", stdout.rstrip())
 
             with open(os.path.join(tmp, "main.py"), "w", encoding='utf-8') as f:
                 f.write("""
@@ -1104,7 +1073,7 @@ class substr(str):
 
             popen = script_helper.spawn_python("main.py", cwd=tmp)
             stdout, stderr = popen.communicate()
-            self.assertEqual(stdout.rstrip(), b"unhashable type: 'substr'")
+            self.assertIn(b"unhashable type: 'substr'", stdout.rstrip())
 
             # Various issues with sys module
             with open(os.path.join(tmp, "main.py"), "w", encoding='utf-8') as f:
@@ -1241,7 +1210,6 @@ def test_script_shadowing_stdlib_cwd_failure(self):
             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 = [
             (
@@ -1270,7 +1238,8 @@ def test_script_shadowing_stdlib_sys_path_modification(self):
                 stdout, stderr = popen.communicate()
                 self.assertRegex(stdout, expected_error)
 
-    @unittest.skip('TODO: RUSTPYTHON; AttributeError: module "_imp" has no attribute "create_dynamic"')
+    # TODO: RUSTPYTHON: _imp.create_dynamic is for C extensions, not applicable
+    @unittest.skip("TODO: RustPython _imp.create_dynamic not implemented")
     def test_create_dynamic_null(self):
         with self.assertRaisesRegex(ValueError, 'embedded null character'):
             class Spec:
@@ -1292,7 +1261,7 @@ class FilePermissionTests(unittest.TestCase):
     @unittest.skipUnless(os.name == 'posix',
                          "test meaningful only on posix systems")
     @unittest.skipIf(
-        is_emscripten or is_wasi,
+        is_wasm32,
         "Emscripten's/WASI's umask is a stub."
     )
     def test_creation_mode(self):
@@ -1429,7 +1398,6 @@ def test_basics(self):
         self.assertEqual(mod.code_filename, self.file_name)
         self.assertEqual(mod.func_filename, self.file_name)
 
-    @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()
@@ -1465,7 +1433,7 @@ def test_foreign_code(self):
         self.assertEqual(mod.constant.co_filename, foreign_code.co_filename)
 
 
-class PathsTests(unittest.TestCase, ExtraAssertions):
+class PathsTests(unittest.TestCase):
     SAMPLES = ('test', 'test\u00e4\u00f6\u00fc\u00df', 'test\u00e9\u00e8',
                'test\u00b0\u00b3\u00b2')
     path = TESTFN
@@ -1519,7 +1487,7 @@ def test_UNC_path(self):
         unload("test_unc_path")
 
 
-class RelativeImportTests(unittest.TestCase, ExtraAssertions):
+class RelativeImportTests(unittest.TestCase):
 
     def tearDown(self):
         unload("test.relimport")
@@ -1617,7 +1585,6 @@ def test_rebinding2(self):
 
 
 class OverridingImportBuiltinTests(unittest.TestCase):
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_override_builtin(self):
         # Test that overriding builtins.__import__ can bypass sys.modules.
         import os
@@ -1846,7 +1813,7 @@ def test_symlinked_dir_importable(self):
 
 
 @cpython_only
-class ImportlibBootstrapTests(unittest.TestCase, ExtraAssertions):
+class ImportlibBootstrapTests(unittest.TestCase):
     # These tests check that importlib is bootstrapped.
 
     def test_frozen_importlib(self):
@@ -2077,7 +2044,7 @@ def exec_module(*args):
             else:
                 importlib.SourceLoader.exec_module = old_exec_module
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; subprocess fails on Windows
     @unittest.skipUnless(TESTFN_UNENCODABLE, 'need TESTFN_UNENCODABLE')
     def test_unencodable_filename(self):
         # Issue #11619: The Python parser and the import machinery must not
@@ -2128,7 +2095,6 @@ def test_rebinding(self):
         from test.test_import.data.circular_imports.subpkg import util
         self.assertIs(util.util, rebinding.util)
 
-    @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
@@ -2139,7 +2105,6 @@ def test_crossreference1(self):
         import test.test_import.data.circular_imports.use
         import test.test_import.data.circular_imports.source
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_crossreference2(self):
         with self.assertRaises(AttributeError) as cm:
             import test.test_import.data.circular_imports.source
@@ -2159,7 +2124,6 @@ def test_circular_from_import(self):
             str(cm.exception),
         )
 
-    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_circular_import(self):
         with self.assertRaisesRegex(
             AttributeError,
@@ -2168,7 +2132,6 @@ def test_circular_import(self):
         ):
             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
@@ -2722,7 +2685,7 @@ def parse(cls, text):
 
 
 @requires_singlephase_init
-class SinglephaseInitTests(unittest.TestCase, ExtraAssertions):
+class SinglephaseInitTests(unittest.TestCase):
 
     NAME = '_testsinglephase'
 
@@ -3242,7 +3205,7 @@ def test_basic_multiple_interpreters_main_no_reset(self):
         #  * 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)
+        #  * m_copy is NULL (cleared when the interpreter was destroyed)
         #    (was from main interpreter)
         #  * module's global state was updated, not reset
 
@@ -3377,7 +3340,7 @@ def test_basic_multiple_interpreters_reset_each(self):
         #  * 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)
+        #  * m_copy is NULL (cleared when the interpreter was destroyed)
         #  * module's global state was initialized, not reset
 
         # Use a subinterpreter that sticks around.
@@ -3405,6 +3368,17 @@ def test_basic_multiple_interpreters_reset_each(self):
         #  * module's global state was initialized, not reset
 
 
+@cpython_only
+class TestMagicNumber(unittest.TestCase):
+    def test_magic_number_endianness(self):
+        magic_number_bytes = _imp.pyc_magic_number_token.to_bytes(4, 'little')
+        self.assertEqual(magic_number_bytes[2:], b'\r\n')
+        # Starting with Python 3.11, Python 3.n starts with magic number 2900+50n.
+        magic_number = int.from_bytes(magic_number_bytes[:2], 'little')
+        start = 2900 + sys.version_info.minor * 50
+        self.assertIn(magic_number, range(start, start + 50))
+
+
 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/subpkg2/__init__.py b/Lib/test/test_import/data/circular_imports/subpkg2/__init__.py
index e69de29bb2d..8b137891791 100644
--- a/Lib/test/test_import/data/circular_imports/subpkg2/__init__.py
+++ b/Lib/test/test_import/data/circular_imports/subpkg2/__init__.py
@@ -0,0 +1 @@
+
diff --git a/Lib/test/test_import/data/package/submodule.py b/Lib/test/test_import/data/package/submodule.py
index e69de29bb2d..8b137891791 100644
--- a/Lib/test/test_import/data/package/submodule.py
+++ b/Lib/test/test_import/data/package/submodule.py
@@ -0,0 +1 @@
+
diff --git a/Lib/test/test_import/data/package2/submodule2.py b/Lib/test/test_import/data/package2/submodule2.py
index e69de29bb2d..8b137891791 100644
--- a/Lib/test/test_import/data/package2/submodule2.py
+++ b/Lib/test/test_import/data/package2/submodule2.py
@@ -0,0 +1 @@
+
diff --git a/Lib/test/test_import/data/unwritable/x.py b/Lib/test/test_import/data/unwritable/x.py
index e69de29bb2d..8b137891791 100644
--- a/Lib/test/test_import/data/unwritable/x.py
+++ b/Lib/test/test_import/data/unwritable/x.py
@@ -0,0 +1 @@
+
diff --git a/Lib/test/test_importlib/builtin/test_finder.py b/Lib/test/test_importlib/builtin/test_finder.py
index 111c4af1ea7..1fb1d2f9efa 100644
--- a/Lib/test/test_importlib/builtin/test_finder.py
+++ b/Lib/test/test_importlib/builtin/test_finder.py
@@ -4,7 +4,6 @@
 
 import sys
 import unittest
-import warnings
 
 
 @unittest.skipIf(util.BUILTINS.good_name is None, 'no reasonable builtin module')
diff --git a/Lib/test/test_importlib/extension/_test_nonmodule_cases.py b/Lib/test/test_importlib/extension/_test_nonmodule_cases.py
new file mode 100644
index 00000000000..8ffd18d221d
--- /dev/null
+++ b/Lib/test/test_importlib/extension/_test_nonmodule_cases.py
@@ -0,0 +1,44 @@
+import types
+import unittest
+from test.test_importlib import util
+
+machinery = util.import_importlib('importlib.machinery')
+
+from test.test_importlib.extension.test_loader import MultiPhaseExtensionModuleTests
+
+
+class NonModuleExtensionTests:
+    setUp = MultiPhaseExtensionModuleTests.setUp
+    load_module_by_name = MultiPhaseExtensionModuleTests.load_module_by_name
+
+    def _test_nonmodule(self):
+        # Test returning a non-module object from create works.
+        name = self.name + '_nonmodule'
+        mod = self.load_module_by_name(name)
+        self.assertNotEqual(type(mod), type(unittest))
+        self.assertEqual(mod.three, 3)
+
+    # issue 27782
+    def test_nonmodule_with_methods(self):
+        # Test creating a non-module object with methods defined.
+        name = self.name + '_nonmodule_with_methods'
+        mod = self.load_module_by_name(name)
+        self.assertNotEqual(type(mod), type(unittest))
+        self.assertEqual(mod.three, 3)
+        self.assertEqual(mod.bar(10, 1), 9)
+
+    def test_null_slots(self):
+        # Test that NULL slots aren't a problem.
+        name = self.name + '_null_slots'
+        module = self.load_module_by_name(name)
+        self.assertIsInstance(module, types.ModuleType)
+        self.assertEqual(module.__name__, name)
+
+
+(Frozen_NonModuleExtensionTests,
+ Source_NonModuleExtensionTests
+ ) = util.test_both(NonModuleExtensionTests, machinery=machinery)
+
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/Lib/test/test_importlib/extension/test_case_sensitivity.py b/Lib/test/test_importlib/extension/test_case_sensitivity.py
index 0bb74fff5fc..5183719162e 100644
--- a/Lib/test/test_importlib/extension/test_case_sensitivity.py
+++ b/Lib/test/test_importlib/extension/test_case_sensitivity.py
@@ -1,4 +1,3 @@
-from importlib import _bootstrap_external
 from test.support import os_helper
 import unittest
 import sys
@@ -8,7 +7,8 @@
 machinery = util.import_importlib('importlib.machinery')
 
 
-@unittest.skipIf(util.EXTENSIONS.filename is None, f'{util.EXTENSIONS.name} not available')
+@unittest.skipIf(util.EXTENSIONS is None or util.EXTENSIONS.filename is None,
+                 'dynamic loading not supported or test module not available')
 @util.case_insensitive_tests
 class ExtensionModuleCaseSensitivityTest(util.CASEOKTestBase):
 
diff --git a/Lib/test/test_importlib/extension/test_finder.py b/Lib/test/test_importlib/extension/test_finder.py
index 35ff9fbef58..cdc8884d668 100644
--- a/Lib/test/test_importlib/extension/test_finder.py
+++ b/Lib/test/test_importlib/extension/test_finder.py
@@ -1,3 +1,4 @@
+from test.support import is_apple_mobile
 from test.test_importlib import abc, util
 
 machinery = util.import_importlib('importlib.machinery')
@@ -11,7 +12,7 @@ class FinderTests(abc.FinderTests):
     """Test the finder for extension modules."""
 
     def setUp(self):
-        if not self.machinery.EXTENSION_SUFFIXES:
+        if not self.machinery.EXTENSION_SUFFIXES or not util.EXTENSIONS:
             raise unittest.SkipTest("Requires dynamic loading support.")
         if util.EXTENSIONS.name in sys.builtin_module_names:
             raise unittest.SkipTest(
@@ -19,14 +20,30 @@ def setUp(self):
             )
 
     def find_spec(self, fullname):
-        importer = self.machinery.FileFinder(util.EXTENSIONS.path,
-                                            (self.machinery.ExtensionFileLoader,
-                                             self.machinery.EXTENSION_SUFFIXES))
+        if is_apple_mobile:
+            # Apple mobile platforms require a specialist loader that uses
+            # .fwork files as placeholders for the true `.so` files.
+            loaders = [
+                (
+                    self.machinery.AppleFrameworkLoader,
+                    [
+                        ext.replace(".so", ".fwork")
+                        for ext in self.machinery.EXTENSION_SUFFIXES
+                    ]
+                )
+            ]
+        else:
+            loaders = [
+                (
+                    self.machinery.ExtensionFileLoader,
+                    self.machinery.EXTENSION_SUFFIXES
+                )
+            ]
+
+        importer = self.machinery.FileFinder(util.EXTENSIONS.path, *loaders)
 
         return importer.find_spec(fullname)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_module(self):
         self.assertTrue(self.find_spec(util.EXTENSIONS.name))
 
diff --git a/Lib/test/test_importlib/extension/test_loader.py b/Lib/test/test_importlib/extension/test_loader.py
index d06558f2ade..0dd21e079eb 100644
--- a/Lib/test/test_importlib/extension/test_loader.py
+++ b/Lib/test/test_importlib/extension/test_loader.py
@@ -1,4 +1,4 @@
-from warnings import catch_warnings
+from test.support import is_apple_mobile
 from test.test_importlib import abc, util
 
 machinery = util.import_importlib('importlib.machinery')
@@ -10,7 +10,8 @@
 import warnings
 import importlib.util
 import importlib
-from test.support.script_helper import assert_python_failure
+from test import support
+from test.support import MISSING_C_DOCSTRINGS, script_helper
 
 
 class LoaderTests:
@@ -18,14 +19,21 @@ class LoaderTests:
     """Test ExtensionFileLoader."""
 
     def setUp(self):
-        if not self.machinery.EXTENSION_SUFFIXES:
+        if not self.machinery.EXTENSION_SUFFIXES or not util.EXTENSIONS:
             raise unittest.SkipTest("Requires dynamic loading support.")
         if util.EXTENSIONS.name in sys.builtin_module_names:
             raise unittest.SkipTest(
                 f"{util.EXTENSIONS.name} is a builtin module"
             )
-        self.loader = self.machinery.ExtensionFileLoader(util.EXTENSIONS.name,
-                                                         util.EXTENSIONS.file_path)
+
+        # Apple extensions must be distributed as frameworks. This requires
+        # a specialist loader.
+        if is_apple_mobile:
+            self.LoaderClass = self.machinery.AppleFrameworkLoader
+        else:
+            self.LoaderClass = self.machinery.ExtensionFileLoader
+
+        self.loader = self.LoaderClass(util.EXTENSIONS.name, util.EXTENSIONS.file_path)
 
     def load_module(self, fullname):
         with warnings.catch_warnings():
@@ -33,13 +41,11 @@ def load_module(self, fullname):
             return self.loader.load_module(fullname)
 
     def test_equality(self):
-        other = self.machinery.ExtensionFileLoader(util.EXTENSIONS.name,
-                                                   util.EXTENSIONS.file_path)
+        other = self.LoaderClass(util.EXTENSIONS.name, util.EXTENSIONS.file_path)
         self.assertEqual(self.loader, other)
 
     def test_inequality(self):
-        other = self.machinery.ExtensionFileLoader('_' + util.EXTENSIONS.name,
-                                                   util.EXTENSIONS.file_path)
+        other = self.LoaderClass('_' + util.EXTENSIONS.name, util.EXTENSIONS.file_path)
         self.assertNotEqual(self.loader, other)
 
     def test_load_module_API(self):
@@ -51,8 +57,6 @@ def test_load_module_API(self):
             with self.assertRaises(ImportError):
                 self.load_module('XXX')
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_module(self):
         with util.uncache(util.EXTENSIONS.name):
             module = self.load_module(util.EXTENSIONS.name)
@@ -61,8 +65,7 @@ def test_module(self):
                                 ('__package__', '')]:
                 self.assertEqual(getattr(module, attr), value)
             self.assertIn(util.EXTENSIONS.name, sys.modules)
-            self.assertIsInstance(module.__loader__,
-                                  self.machinery.ExtensionFileLoader)
+            self.assertIsInstance(module.__loader__, self.LoaderClass)
 
     # No extension module as __init__ available for testing.
     test_package = None
@@ -85,13 +88,11 @@ def test_module_reuse(self):
             module2 = self.load_module(util.EXTENSIONS.name)
             self.assertIs(module1, module2)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_is_package(self):
         self.assertFalse(self.loader.is_package(util.EXTENSIONS.name))
         for suffix in self.machinery.EXTENSION_SUFFIXES:
             path = os.path.join('some', 'path', 'pkg', '__init__' + suffix)
-            loader = self.machinery.ExtensionFileLoader('pkg', path)
+            loader = self.LoaderClass('pkg', path)
             self.assertTrue(loader.is_package('pkg'))
 
 
@@ -104,8 +105,16 @@ class SinglePhaseExtensionModuleTests(abc.LoaderTests):
     # Test loading extension modules without multi-phase initialization.
 
     def setUp(self):
-        if not self.machinery.EXTENSION_SUFFIXES:
+        if not self.machinery.EXTENSION_SUFFIXES or not util.EXTENSIONS:
             raise unittest.SkipTest("Requires dynamic loading support.")
+
+        # Apple extensions must be distributed as frameworks. This requires
+        # a specialist loader.
+        if is_apple_mobile:
+            self.LoaderClass = self.machinery.AppleFrameworkLoader
+        else:
+            self.LoaderClass = self.machinery.ExtensionFileLoader
+
         self.name = '_testsinglephase'
         if self.name in sys.builtin_module_names:
             raise unittest.SkipTest(
@@ -114,8 +123,8 @@ def setUp(self):
         finder = self.machinery.FileFinder(None)
         self.spec = importlib.util.find_spec(self.name)
         assert self.spec
-        self.loader = self.machinery.ExtensionFileLoader(
-            self.name, self.spec.origin)
+
+        self.loader = self.LoaderClass(self.name, self.spec.origin)
 
     def load_module(self):
         with warnings.catch_warnings():
@@ -125,7 +134,7 @@ def load_module(self):
     def load_module_by_name(self, fullname):
         # Load a module from the test extension by name.
         origin = self.spec.origin
-        loader = self.machinery.ExtensionFileLoader(fullname, origin)
+        loader = self.LoaderClass(fullname, origin)
         spec = importlib.util.spec_from_loader(fullname, loader)
         module = importlib.util.module_from_spec(spec)
         loader.exec_module(module)
@@ -142,8 +151,7 @@ def test_module(self):
             with self.assertRaises(AttributeError):
                 module.__path__
             self.assertIs(module, sys.modules[self.name])
-            self.assertIsInstance(module.__loader__,
-                                  self.machinery.ExtensionFileLoader)
+            self.assertIsInstance(module.__loader__, self.LoaderClass)
 
     # No extension module as __init__ available for testing.
     test_package = None
@@ -181,13 +189,20 @@ def test_unloadable_nonascii(self):
  ) = util.test_both(SinglePhaseExtensionModuleTests, machinery=machinery)
 
 
-# @unittest.skip("TODO: RUSTPYTHON, AssertionError")
 class MultiPhaseExtensionModuleTests(abc.LoaderTests):
     # Test loading extension modules with multi-phase initialization (PEP 489).
 
     def setUp(self):
-        if not self.machinery.EXTENSION_SUFFIXES:
+        if not self.machinery.EXTENSION_SUFFIXES or not util.EXTENSIONS:
             raise unittest.SkipTest("Requires dynamic loading support.")
+
+        # Apple extensions must be distributed as frameworks. This requires
+        # a specialist loader.
+        if is_apple_mobile:
+            self.LoaderClass = self.machinery.AppleFrameworkLoader
+        else:
+            self.LoaderClass = self.machinery.ExtensionFileLoader
+
         self.name = '_testmultiphase'
         if self.name in sys.builtin_module_names:
             raise unittest.SkipTest(
@@ -196,8 +211,7 @@ def setUp(self):
         finder = self.machinery.FileFinder(None)
         self.spec = importlib.util.find_spec(self.name)
         assert self.spec
-        self.loader = self.machinery.ExtensionFileLoader(
-            self.name, self.spec.origin)
+        self.loader = self.LoaderClass(self.name, self.spec.origin)
 
     def load_module(self):
         # Load the module from the test extension.
@@ -208,7 +222,7 @@ def load_module(self):
     def load_module_by_name(self, fullname):
         # Load a module from the test extension by name.
         origin = self.spec.origin
-        loader = self.machinery.ExtensionFileLoader(fullname, origin)
+        loader = self.LoaderClass(fullname, origin)
         spec = importlib.util.spec_from_loader(fullname, loader)
         module = importlib.util.module_from_spec(spec)
         loader.exec_module(module)
@@ -234,8 +248,7 @@ def test_module(self):
             with self.assertRaises(AttributeError):
                 module.__path__
             self.assertIs(module, sys.modules[self.name])
-            self.assertIsInstance(module.__loader__,
-                                  self.machinery.ExtensionFileLoader)
+            self.assertIsInstance(module.__loader__, self.LoaderClass)
 
     def test_functionality(self):
         # Test basic functionality of stuff defined in an extension module.
@@ -313,29 +326,6 @@ def test_unloadable_nonascii(self):
             self.load_module_by_name(name)
         self.assertEqual(cm.exception.name, name)
 
-    def test_nonmodule(self):
-        # Test returning a non-module object from create works.
-        name = self.name + '_nonmodule'
-        mod = self.load_module_by_name(name)
-        self.assertNotEqual(type(mod), type(unittest))
-        self.assertEqual(mod.three, 3)
-
-    # issue 27782
-    def test_nonmodule_with_methods(self):
-        # Test creating a non-module object with methods defined.
-        name = self.name + '_nonmodule_with_methods'
-        mod = self.load_module_by_name(name)
-        self.assertNotEqual(type(mod), type(unittest))
-        self.assertEqual(mod.three, 3)
-        self.assertEqual(mod.bar(10, 1), 9)
-
-    def test_null_slots(self):
-        # Test that NULL slots aren't a problem.
-        name = self.name + '_null_slots'
-        module = self.load_module_by_name(name)
-        self.assertIsInstance(module, types.ModuleType)
-        self.assertEqual(module.__name__, name)
-
     def test_bad_modules(self):
         # Test SystemError is raised for misbehaving extensions.
         for name_base in [
@@ -380,7 +370,8 @@ def test_nonascii(self):
             with self.subTest(name):
                 module = self.load_module_by_name(name)
                 self.assertEqual(module.__name__, name)
-                self.assertEqual(module.__doc__, "Module named in %s" % lang)
+                if not MISSING_C_DOCSTRINGS:
+                    self.assertEqual(module.__doc__, "Module named in %s" % lang)
 
 
 (Frozen_MultiPhaseExtensionModuleTests,
@@ -388,5 +379,14 @@ def test_nonascii(self):
  ) = util.test_both(MultiPhaseExtensionModuleTests, machinery=machinery)
 
 
+class NonModuleExtensionTests(unittest.TestCase):
+    def test_nonmodule_cases(self):
+        # The test cases in this file cause the GIL to be enabled permanently
+        # in free-threaded builds, so they are run in a subprocess to isolate
+        # this effect.
+        script = support.findfile("test_importlib/extension/_test_nonmodule_cases.py")
+        script_helper.run_test_script(script)
+
+
 if __name__ == '__main__':
     unittest.main()
diff --git a/Lib/test/test_importlib/extension/test_path_hook.py b/Lib/test/test_importlib/extension/test_path_hook.py
index ec9644dc520..941dcd5432c 100644
--- a/Lib/test/test_importlib/extension/test_path_hook.py
+++ b/Lib/test/test_importlib/extension/test_path_hook.py
@@ -5,6 +5,8 @@
 import unittest
 
 
+@unittest.skipIf(util.EXTENSIONS is None or util.EXTENSIONS.filename is None,
+                 'dynamic loading not supported or test module not available')
 class PathHookTests:
 
     """Test the path hook for extension modules."""
@@ -19,7 +21,7 @@ def hook(self, entry):
     def test_success(self):
         # Path hook should handle a directory where a known extension module
         # exists.
-        self.assertTrue(hasattr(self.hook(util.EXTENSIONS.path), 'find_spec'))
+        self.assertHasAttr(self.hook(util.EXTENSIONS.path), 'find_spec')
 
 
 (Frozen_PathHooksTests,
diff --git a/Lib/test/test_importlib/frozen/test_finder.py b/Lib/test/test_importlib/frozen/test_finder.py
index 5bb075f3770..971cc28b6d3 100644
--- a/Lib/test/test_importlib/frozen/test_finder.py
+++ b/Lib/test/test_importlib/frozen/test_finder.py
@@ -2,11 +2,8 @@
 
 machinery = util.import_importlib('importlib.machinery')
 
-import _imp
-import marshal
 import os.path
 import unittest
-import warnings
 
 from test.support import import_helper, REPO_ROOT, STDLIB_DIR
 
@@ -70,8 +67,6 @@ def check_search_locations(self, spec):
             expected = [os.path.dirname(filename)]
         self.assertListEqual(spec.submodule_search_locations, expected)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_module(self):
         modules = [
             '__hello__',
@@ -114,8 +109,6 @@ def test_module(self):
                 self.check_basic(spec, name)
                 self.check_loader_state(spec, origname, filename)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_package(self):
         packages = [
             '__phello__',
@@ -170,8 +163,6 @@ def test_failure(self):
         spec = self.find('<not real>')
         self.assertIsNone(spec)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_not_using_frozen(self):
         finder = self.machinery.FrozenImporter
         with import_helper.frozen_modules(enabled=False):
diff --git a/Lib/test/test_importlib/frozen/test_loader.py b/Lib/test/test_importlib/frozen/test_loader.py
index b1eb399d937..0824af53e05 100644
--- a/Lib/test/test_importlib/frozen/test_loader.py
+++ b/Lib/test/test_importlib/frozen/test_loader.py
@@ -3,9 +3,7 @@
 machinery = util.import_importlib('importlib.machinery')
 
 from test.support import captured_stdout, import_helper, STDLIB_DIR
-import _imp
 import contextlib
-import marshal
 import os.path
 import sys
 import types
@@ -64,7 +62,7 @@ def exec_module(self, name, origname=None):
             module.main()
 
         self.assertTrue(module.initialized)
-        self.assertTrue(hasattr(module, '__spec__'))
+        self.assertHasAttr(module, '__spec__')
         self.assertEqual(module.__spec__.origin, 'frozen')
         return module, stdout.getvalue()
 
@@ -75,7 +73,7 @@ def test_module(self):
         for attr, value in check.items():
             self.assertEqual(getattr(module, attr), value)
         self.assertEqual(output, 'Hello world!\n')
-        self.assertTrue(hasattr(module, '__spec__'))
+        self.assertHasAttr(module, '__spec__')
         self.assertEqual(module.__spec__.loader_state.origname, name)
 
     @unittest.skipIf(sys.platform == "win32", "TODO: RUSTPYTHON")
@@ -92,7 +90,6 @@ def test_package(self):
         self.assertEqual(output, 'Hello world!\n')
         self.assertEqual(module.__spec__.loader_state.origname, name)
 
-    @unittest.skipIf(sys.platform == 'win32', "TODO:RUSTPYTHON Flaky on Windows")
     def test_lacking_parent(self):
         name = '__phello__.spam'
         with util.uncache('__phello__'):
@@ -141,7 +138,7 @@ def test_get_code(self):
             exec(code, mod.__dict__)
         with captured_stdout() as stdout:
             mod.main()
-        self.assertTrue(hasattr(mod, 'initialized'))
+        self.assertHasAttr(mod, 'initialized')
         self.assertEqual(stdout.getvalue(), 'Hello world!\n')
 
     def test_get_source(self):
diff --git a/Lib/test/test_importlib/import_/test___loader__.py b/Lib/test/test_importlib/import_/test___loader__.py
index a14163919af..858b37effc6 100644
--- a/Lib/test/test_importlib/import_/test___loader__.py
+++ b/Lib/test/test_importlib/import_/test___loader__.py
@@ -1,8 +1,5 @@
 from importlib import machinery
-import sys
-import types
 import unittest
-import warnings
 
 from test.test_importlib import util
 
diff --git a/Lib/test/test_importlib/import_/test_caching.py b/Lib/test/test_importlib/import_/test_caching.py
index aedf0fd4f9d..718e7d041b0 100644
--- a/Lib/test/test_importlib/import_/test_caching.py
+++ b/Lib/test/test_importlib/import_/test_caching.py
@@ -78,7 +78,7 @@ def test_using_cache_for_assigning_to_attribute(self):
             with self.create_mock('pkg.__init__', 'pkg.module') as importer:
                 with util.import_state(meta_path=[importer]):
                     module = self.__import__('pkg.module')
-                    self.assertTrue(hasattr(module, 'module'))
+                    self.assertHasAttr(module, 'module')
                     self.assertEqual(id(module.module),
                                     id(sys.modules['pkg.module']))
 
@@ -88,7 +88,7 @@ def test_using_cache_for_fromlist(self):
         with self.create_mock('pkg.__init__', 'pkg.module') as importer:
             with util.import_state(meta_path=[importer]):
                 module = self.__import__('pkg', fromlist=['module'])
-                self.assertTrue(hasattr(module, 'module'))
+                self.assertHasAttr(module, 'module')
                 self.assertEqual(id(module.module),
                                  id(sys.modules['pkg.module']))
 
diff --git a/Lib/test/test_importlib/import_/test_fromlist.py b/Lib/test/test_importlib/import_/test_fromlist.py
index 4b4b9bc3f5e..feccc7be09a 100644
--- a/Lib/test/test_importlib/import_/test_fromlist.py
+++ b/Lib/test/test_importlib/import_/test_fromlist.py
@@ -63,7 +63,7 @@ def test_nonexistent_object(self):
             with util.import_state(meta_path=[importer]):
                 module = self.__import__('module', fromlist=['non_existent'])
                 self.assertEqual(module.__name__, 'module')
-                self.assertFalse(hasattr(module, 'non_existent'))
+                self.assertNotHasAttr(module, 'non_existent')
 
     def test_module_from_package(self):
         # [module]
@@ -71,7 +71,7 @@ def test_module_from_package(self):
             with util.import_state(meta_path=[importer]):
                 module = self.__import__('pkg', fromlist=['module'])
                 self.assertEqual(module.__name__, 'pkg')
-                self.assertTrue(hasattr(module, 'module'))
+                self.assertHasAttr(module, 'module')
                 self.assertEqual(module.module.__name__, 'pkg.module')
 
     def test_nonexistent_from_package(self):
@@ -79,7 +79,7 @@ def test_nonexistent_from_package(self):
             with util.import_state(meta_path=[importer]):
                 module = self.__import__('pkg', fromlist=['non_existent'])
                 self.assertEqual(module.__name__, 'pkg')
-                self.assertFalse(hasattr(module, 'non_existent'))
+                self.assertNotHasAttr(module, 'non_existent')
 
     def test_module_from_package_triggers_ModuleNotFoundError(self):
         # If a submodule causes an ModuleNotFoundError because it tries
@@ -107,7 +107,7 @@ def basic_star_test(self, fromlist=['*']):
                 mock['pkg'].__all__ = ['module']
                 module = self.__import__('pkg', fromlist=fromlist)
                 self.assertEqual(module.__name__, 'pkg')
-                self.assertTrue(hasattr(module, 'module'))
+                self.assertHasAttr(module, 'module')
                 self.assertEqual(module.module.__name__, 'pkg.module')
 
     def test_using_star(self):
@@ -125,8 +125,8 @@ def test_star_with_others(self):
                 mock['pkg'].__all__ = ['module1']
                 module = self.__import__('pkg', fromlist=['module2', '*'])
                 self.assertEqual(module.__name__, 'pkg')
-                self.assertTrue(hasattr(module, 'module1'))
-                self.assertTrue(hasattr(module, 'module2'))
+                self.assertHasAttr(module, 'module1')
+                self.assertHasAttr(module, 'module2')
                 self.assertEqual(module.module1.__name__, 'pkg.module1')
                 self.assertEqual(module.module2.__name__, 'pkg.module2')
 
@@ -136,7 +136,7 @@ def test_nonexistent_in_all(self):
                 importer['pkg'].__all__ = ['non_existent']
                 module = self.__import__('pkg', fromlist=['*'])
                 self.assertEqual(module.__name__, 'pkg')
-                self.assertFalse(hasattr(module, 'non_existent'))
+                self.assertNotHasAttr(module, 'non_existent')
 
     def test_star_in_all(self):
         with util.mock_spec('pkg.__init__') as importer:
@@ -144,7 +144,7 @@ def test_star_in_all(self):
                 importer['pkg'].__all__ = ['*']
                 module = self.__import__('pkg', fromlist=['*'])
                 self.assertEqual(module.__name__, 'pkg')
-                self.assertFalse(hasattr(module, '*'))
+                self.assertNotHasAttr(module, '*')
 
     def test_invalid_type(self):
         with util.mock_spec('pkg.__init__') as importer:
diff --git a/Lib/test/test_importlib/import_/test_meta_path.py b/Lib/test/test_importlib/import_/test_meta_path.py
index 8689017ba43..4c00f60681a 100644
--- a/Lib/test/test_importlib/import_/test_meta_path.py
+++ b/Lib/test/test_importlib/import_/test_meta_path.py
@@ -43,7 +43,7 @@ def test_empty(self):
                 self.assertIsNone(importlib._bootstrap._find_spec('nothing',
                                                                   None))
                 self.assertEqual(len(w), 1)
-                self.assertTrue(issubclass(w[-1].category, ImportWarning))
+                self.assertIsSubclass(w[-1].category, ImportWarning)
 
 
 (Frozen_CallingOrder,
diff --git a/Lib/test/test_importlib/import_/test_packages.py b/Lib/test/test_importlib/import_/test_packages.py
index eb0831f7d6d..0c29d608326 100644
--- a/Lib/test/test_importlib/import_/test_packages.py
+++ b/Lib/test/test_importlib/import_/test_packages.py
@@ -1,7 +1,6 @@
 from test.test_importlib import util
 import sys
 import unittest
-from test import support
 from test.support import import_helper
 
 
diff --git a/Lib/test/test_importlib/import_/test_path.py b/Lib/test/test_importlib/import_/test_path.py
index 89b52fbd1e1..79e0bdca94c 100644
--- a/Lib/test/test_importlib/import_/test_path.py
+++ b/Lib/test/test_importlib/import_/test_path.py
@@ -1,3 +1,4 @@
+from test.support import os_helper
 from test.test_importlib import util
 
 importlib = util.import_importlib('importlib')
@@ -80,7 +81,7 @@ def test_empty_path_hooks(self):
                 self.assertIsNone(self.find('os'))
                 self.assertIsNone(sys.path_importer_cache[path_entry])
                 self.assertEqual(len(w), 1)
-                self.assertTrue(issubclass(w[-1].category, ImportWarning))
+                self.assertIsSubclass(w[-1].category, ImportWarning)
 
     def test_path_importer_cache_empty_string(self):
         # The empty string should create a finder using the cwd.
@@ -153,6 +154,32 @@ def test_deleted_cwd(self):
             # Do not want FileNotFoundError raised.
             self.assertIsNone(self.machinery.PathFinder.find_spec('whatever'))
 
+    @os_helper.skip_unless_working_chmod
+    def test_permission_error_cwd(self):
+        # gh-115911: Test that an unreadable CWD does not break imports, in
+        # particular during early stages of interpreter startup.
+
+        def noop_hook(*args):
+            raise ImportError
+
+        with (
+            os_helper.temp_dir() as new_dir,
+            os_helper.save_mode(new_dir),
+            os_helper.change_cwd(new_dir),
+            util.import_state(path=[''], path_hooks=[noop_hook]),
+        ):
+            # chmod() is done here (inside the 'with' block) because the order
+            # of teardown operations cannot be the reverse of setup order. See
+            # https://github.com/python/cpython/pull/116131#discussion_r1739649390
+            try:
+                os.chmod(new_dir, 0o000)
+            except OSError:
+                self.skipTest("platform does not allow "
+                              "changing mode of the cwd")
+
+            # Do not want PermissionError raised.
+            self.assertIsNone(self.machinery.PathFinder.find_spec('whatever'))
+
     def test_invalidate_caches_finders(self):
         # Finders with an invalidate_caches() method have it called.
         class FakeFinder:
diff --git a/Lib/test/test_importlib/import_/test_relative_imports.py b/Lib/test/test_importlib/import_/test_relative_imports.py
index 99c24f1fd94..1549cbe96ce 100644
--- a/Lib/test/test_importlib/import_/test_relative_imports.py
+++ b/Lib/test/test_importlib/import_/test_relative_imports.py
@@ -81,7 +81,7 @@ def callback(global_):
             self.__import__('pkg')  # For __import__().
             module = self.__import__('', global_, fromlist=['mod2'], level=1)
             self.assertEqual(module.__name__, 'pkg')
-            self.assertTrue(hasattr(module, 'mod2'))
+            self.assertHasAttr(module, 'mod2')
             self.assertEqual(module.mod2.attr, 'pkg.mod2')
         self.relative_import_test(create, globals_, callback)
 
@@ -107,7 +107,7 @@ def callback(global_):
             module = self.__import__('', global_, fromlist=['module'],
                              level=1)
             self.assertEqual(module.__name__, 'pkg')
-            self.assertTrue(hasattr(module, 'module'))
+            self.assertHasAttr(module, 'module')
             self.assertEqual(module.module.attr, 'pkg.module')
         self.relative_import_test(create, globals_, callback)
 
@@ -131,7 +131,7 @@ def callback(global_):
             module = self.__import__('', global_, fromlist=['subpkg2'],
                                             level=2)
             self.assertEqual(module.__name__, 'pkg')
-            self.assertTrue(hasattr(module, 'subpkg2'))
+            self.assertHasAttr(module, 'subpkg2')
             self.assertEqual(module.subpkg2.attr, 'pkg.subpkg2.__init__')
         self.relative_import_test(create, globals_, callback)
 
@@ -223,6 +223,21 @@ def test_relative_import_no_package_exists_absolute(self):
             self.__import__('sys', {'__package__': '', '__spec__': None},
                             level=1)
 
+    def test_malicious_relative_import(self):
+        # https://github.com/python/cpython/issues/134100
+        # Test to make sure UAF bug with error msg doesn't come back to life
+        import sys
+        loooong = "".ljust(0x23000, "b")
+        name = f"a.{loooong}.c"
+
+        with util.uncache(name):
+            sys.modules[name] = {}
+            with self.assertRaisesRegex(
+                KeyError,
+                r"'a\.b+' not in sys\.modules as expected"
+            ):
+                __import__(f"{loooong}.c", {"__package__": "a"}, level=1)
+
 
 (Frozen_RelativeImports,
  Source_RelativeImports
diff --git a/Lib/test/test_importlib/metadata/__init__.py b/Lib/test/test_importlib/metadata/__init__.py
new file mode 100644
index 00000000000..8b137891791
--- /dev/null
+++ b/Lib/test/test_importlib/metadata/__init__.py
@@ -0,0 +1 @@
+
diff --git a/Lib/test/test_importlib/metadata/_context.py b/Lib/test/test_importlib/metadata/_context.py
new file mode 100644
index 00000000000..8a53eb55d15
--- /dev/null
+++ b/Lib/test/test_importlib/metadata/_context.py
@@ -0,0 +1,13 @@
+import contextlib
+
+
+# from jaraco.context 4.3
+class suppress(contextlib.suppress, contextlib.ContextDecorator):
+    """
+    A version of contextlib.suppress with decorator support.
+
+    >>> @suppress(KeyError)
+    ... def key_error():
+    ...     {}['']
+    >>> key_error()
+    """
diff --git a/Lib/test/test_importlib/metadata/_path.py b/Lib/test/test_importlib/metadata/_path.py
new file mode 100644
index 00000000000..b3cfb9cd549
--- /dev/null
+++ b/Lib/test/test_importlib/metadata/_path.py
@@ -0,0 +1,115 @@
+# from jaraco.path 3.7
+
+import functools
+import pathlib
+from typing import Dict, Protocol, Union
+from typing import runtime_checkable
+
+
+class Symlink(str):
+    """
+    A string indicating the target of a symlink.
+    """
+
+
+FilesSpec = Dict[str, Union[str, bytes, Symlink, 'FilesSpec']]  # type: ignore
+
+
+@runtime_checkable
+class TreeMaker(Protocol):
+    def __truediv__(self, *args, **kwargs): ...  # pragma: no cover
+
+    def mkdir(self, **kwargs): ...  # pragma: no cover
+
+    def write_text(self, content, **kwargs): ...  # pragma: no cover
+
+    def write_bytes(self, content): ...  # pragma: no cover
+
+    def symlink_to(self, target): ...  # pragma: no cover
+
+
+def _ensure_tree_maker(obj: Union[str, TreeMaker]) -> TreeMaker:
+    return obj if isinstance(obj, TreeMaker) else pathlib.Path(obj)  # type: ignore
+
+
+def build(
+    spec: FilesSpec,
+    prefix: Union[str, TreeMaker] = pathlib.Path(),  # type: ignore
+):
+    """
+    Build a set of files/directories, as described by the spec.
+
+    Each key represents a pathname, and the value represents
+    the content. Content may be a nested directory.
+
+    >>> spec = {
+    ...     'README.txt': "A README file",
+    ...     "foo": {
+    ...         "__init__.py": "",
+    ...         "bar": {
+    ...             "__init__.py": "",
+    ...         },
+    ...         "baz.py": "# Some code",
+    ...         "bar.py": Symlink("baz.py"),
+    ...     },
+    ...     "bing": Symlink("foo"),
+    ... }
+    >>> target = getfixture('tmp_path')
+    >>> build(spec, target)
+    >>> target.joinpath('foo/baz.py').read_text(encoding='utf-8')
+    '# Some code'
+    >>> target.joinpath('bing/bar.py').read_text(encoding='utf-8')
+    '# Some code'
+    """
+    for name, contents in spec.items():
+        create(contents, _ensure_tree_maker(prefix) / name)
+
+
+@functools.singledispatch
+def create(content: Union[str, bytes, FilesSpec], path):
+    path.mkdir(exist_ok=True)
+    build(content, prefix=path)  # type: ignore
+
+
+@create.register
+def _(content: bytes, path):
+    path.write_bytes(content)
+
+
+@create.register
+def _(content: str, path):
+    path.write_text(content, encoding='utf-8')
+
+
+@create.register
+def _(content: Symlink, path):
+    path.symlink_to(content)
+
+
+class Recording:
+    """
+    A TreeMaker object that records everything that would be written.
+
+    >>> r = Recording()
+    >>> build({'foo': {'foo1.txt': 'yes'}, 'bar.txt': 'abc'}, r)
+    >>> r.record
+    ['foo/foo1.txt', 'bar.txt']
+    """
+
+    def __init__(self, loc=pathlib.PurePosixPath(), record=None):
+        self.loc = loc
+        self.record = record if record is not None else []
+
+    def __truediv__(self, other):
+        return Recording(self.loc / other, self.record)
+
+    def write_text(self, content, **kwargs):
+        self.record.append(str(self.loc))
+
+    write_bytes = write_text
+
+    def mkdir(self, **kwargs):
+        return
+
+    def symlink_to(self, target):
+        pass
diff --git a/Lib/test/test_importlib/metadata/data/__init__.py b/Lib/test/test_importlib/metadata/data/__init__.py
new file mode 100644
index 00000000000..8b137891791
--- /dev/null
+++ b/Lib/test/test_importlib/metadata/data/__init__.py
@@ -0,0 +1 @@
+
diff --git a/Lib/test/test_importlib/metadata/data/example-21.12-py3-none-any.whl b/Lib/test/test_importlib/metadata/data/example-21.12-py3-none-any.whl
new file mode 100644
index 00000000000..641ab07f7aa
Binary files /dev/null and b/Lib/test/test_importlib/metadata/data/example-21.12-py3-none-any.whl differ
diff --git a/Lib/test/test_importlib/metadata/data/example-21.12-py3.6.egg b/Lib/test/test_importlib/metadata/data/example-21.12-py3.6.egg
new file mode 100644
index 00000000000..cdb298a19b0
Binary files /dev/null and b/Lib/test/test_importlib/metadata/data/example-21.12-py3.6.egg differ
diff --git a/Lib/test/test_importlib/metadata/data/example2-1.0.0-py3-none-any.whl b/Lib/test/test_importlib/metadata/data/example2-1.0.0-py3-none-any.whl
new file mode 100644
index 00000000000..5ca93657f81
Binary files /dev/null and b/Lib/test/test_importlib/metadata/data/example2-1.0.0-py3-none-any.whl differ
diff --git a/Lib/test/test_importlib/metadata/data/sources/example/example/__init__.py b/Lib/test/test_importlib/metadata/data/sources/example/example/__init__.py
new file mode 100644
index 00000000000..ba73b743394
--- /dev/null
+++ b/Lib/test/test_importlib/metadata/data/sources/example/example/__init__.py
@@ -0,0 +1,2 @@
+def main():
+    return 'example'
diff --git a/Lib/test/test_importlib/metadata/data/sources/example/setup.py b/Lib/test/test_importlib/metadata/data/sources/example/setup.py
new file mode 100644
index 00000000000..479488a0348
--- /dev/null
+++ b/Lib/test/test_importlib/metadata/data/sources/example/setup.py
@@ -0,0 +1,11 @@
+from setuptools import setup
+
+setup(
+    name='example',
+    version='21.12',
+    license='Apache Software License',
+    packages=['example'],
+    entry_points={
+        'console_scripts': ['example = example:main', 'Example=example:main'],
+    },
+)
diff --git a/Lib/test/test_importlib/metadata/data/sources/example2/example2/__init__.py b/Lib/test/test_importlib/metadata/data/sources/example2/example2/__init__.py
new file mode 100644
index 00000000000..de645c2e8bc
--- /dev/null
+++ b/Lib/test/test_importlib/metadata/data/sources/example2/example2/__init__.py
@@ -0,0 +1,2 @@
+def main():
+    return "example"
diff --git a/Lib/test/test_importlib/metadata/data/sources/example2/pyproject.toml b/Lib/test/test_importlib/metadata/data/sources/example2/pyproject.toml
new file mode 100644
index 00000000000..011f4751fb9
--- /dev/null
+++ b/Lib/test/test_importlib/metadata/data/sources/example2/pyproject.toml
@@ -0,0 +1,10 @@
+[build-system]
+build-backend = 'trampolim'
+requires = ['trampolim']
+
+[project]
+name = 'example2'
+version = '1.0.0'
+
+[project.scripts]
+example = 'example2:main'
diff --git a/Lib/test/test_importlib/metadata/fixtures.py b/Lib/test/test_importlib/metadata/fixtures.py
new file mode 100644
index 00000000000..826b1b3259b
--- /dev/null
+++ b/Lib/test/test_importlib/metadata/fixtures.py
@@ -0,0 +1,395 @@
+import sys
+import copy
+import json
+import shutil
+import pathlib
+import textwrap
+import functools
+import contextlib
+
+from test.support import import_helper
+from test.support import os_helper
+from test.support import requires_zlib
+
+from . import _path
+from ._path import FilesSpec
+
+
+try:
+    from importlib import resources  # type: ignore
+
+    getattr(resources, 'files')
+    getattr(resources, 'as_file')
+except (ImportError, AttributeError):
+    import importlib_resources as resources  # type: ignore
+
+
+@contextlib.contextmanager
+def tmp_path():
+    """
+    Like os_helper.temp_dir, but yields a pathlib.Path.
+    """
+    with os_helper.temp_dir() as path:
+        yield pathlib.Path(path)
+
+
+@contextlib.contextmanager
+def install_finder(finder):
+    sys.meta_path.append(finder)
+    try:
+        yield
+    finally:
+        sys.meta_path.remove(finder)
+
+
+class Fixtures:
+    def setUp(self):
+        self.fixtures = contextlib.ExitStack()
+        self.addCleanup(self.fixtures.close)
+
+
+class SiteDir(Fixtures):
+    def setUp(self):
+        super().setUp()
+        self.site_dir = self.fixtures.enter_context(tmp_path())
+
+
+class OnSysPath(Fixtures):
+    @staticmethod
+    @contextlib.contextmanager
+    def add_sys_path(dir):
+        sys.path[:0] = [str(dir)]
+        try:
+            yield
+        finally:
+            sys.path.remove(str(dir))
+
+    def setUp(self):
+        super().setUp()
+        self.fixtures.enter_context(self.add_sys_path(self.site_dir))
+        self.fixtures.enter_context(import_helper.isolated_modules())
+
+
+class SiteBuilder(SiteDir):
+    def setUp(self):
+        super().setUp()
+        for cls in self.__class__.mro():
+            with contextlib.suppress(AttributeError):
+                build_files(cls.files, prefix=self.site_dir)
+
+
+class DistInfoPkg(OnSysPath, SiteBuilder):
+    files: FilesSpec = {
+        "distinfo_pkg-1.0.0.dist-info": {
+            "METADATA": """
+                Name: distinfo-pkg
+                Author: Steven Ma
+                Version: 1.0.0
+                Requires-Dist: wheel >= 1.0
+                Requires-Dist: pytest; extra == 'test'
+                Keywords: sample package
+
+                Once upon a time
+                There was a distinfo pkg
+                """,
+            "RECORD": "mod.py,sha256=abc,20\n",
+            "entry_points.txt": """
+                [entries]
+                main = mod:main
+                ns:sub = mod:main
+            """,
+        },
+        "mod.py": """
+            def main():
+                print("hello world")
+            """,
+    }
+
+    def make_uppercase(self):
+        """
+        Rewrite metadata with everything uppercase.
+        """
+        shutil.rmtree(self.site_dir / "distinfo_pkg-1.0.0.dist-info")
+        files = copy.deepcopy(DistInfoPkg.files)
+        info = files["distinfo_pkg-1.0.0.dist-info"]
+        info["METADATA"] = info["METADATA"].upper()
+        build_files(files, self.site_dir)
+
+
+class DistInfoPkgEditable(DistInfoPkg):
+    """
+    Package with a PEP 660 direct_url.json.
+    """
+
+    some_hash = '524127ce937f7cb65665130c695abd18ca386f60bb29687efb976faa1596fdcc'
+    files: FilesSpec = {
+        'distinfo_pkg-1.0.0.dist-info': {
+            'direct_url.json': json.dumps({
+                "archive_info": {
+                    "hash": f"sha256={some_hash}",
+                    "hashes": {"sha256": f"{some_hash}"},
+                },
+                "url": "file:///path/to/distinfo_pkg-1.0.0.editable-py3-none-any.whl",
+            })
+        },
+    }
+
+
+class DistInfoPkgWithDot(OnSysPath, SiteBuilder):
+    files: FilesSpec = {
+        "pkg_dot-1.0.0.dist-info": {
+            "METADATA": """
+                Name: pkg.dot
+                Version: 1.0.0
+                """,
+        },
+    }
+
+
+class DistInfoPkgWithDotLegacy(OnSysPath, SiteBuilder):
+    files: FilesSpec = {
+        "pkg.dot-1.0.0.dist-info": {
+            "METADATA": """
+                Name: pkg.dot
+                Version: 1.0.0
+                """,
+        },
+        "pkg.lot.egg-info": {
+            "METADATA": """
+                Name: pkg.lot
+                Version: 1.0.0
+                """,
+        },
+    }
+
+
+class DistInfoPkgOffPath(SiteBuilder):
+    files = DistInfoPkg.files
+
+
+class EggInfoPkg(OnSysPath, SiteBuilder):
+    files: FilesSpec = {
+        "egginfo_pkg.egg-info": {
+            "PKG-INFO": """
+                Name: egginfo-pkg
+                Author: Steven Ma
+                License: Unknown
+                Version: 1.0.0
+                Classifier: Intended Audience :: Developers
+                Classifier: Topic :: Software Development :: Libraries
+                Keywords: sample package
+                Description: Once upon a time
+                        There was an egginfo package
+                """,
+            "SOURCES.txt": """
+                mod.py
+                egginfo_pkg.egg-info/top_level.txt
+            """,
+            "entry_points.txt": """
+                [entries]
+                main = mod:main
+            """,
+            "requires.txt": """
+                wheel >= 1.0; python_version >= "2.7"
+                [test]
+                pytest
+            """,
+            "top_level.txt": "mod\n",
+        },
+        "mod.py": """
+            def main():
+                print("hello world")
+            """,
+    }
+
+
+class EggInfoPkgPipInstalledNoToplevel(OnSysPath, SiteBuilder):
+    files: FilesSpec = {
+        "egg_with_module_pkg.egg-info": {
+            "PKG-INFO": "Name: egg_with_module-pkg",
+            # SOURCES.txt is made from the source archive, and contains files
+            # (setup.py) that are not present after installation.
+            "SOURCES.txt": """
+                egg_with_module.py
+                setup.py
+                egg_with_module_pkg.egg-info/PKG-INFO
+                egg_with_module_pkg.egg-info/SOURCES.txt
+                egg_with_module_pkg.egg-info/top_level.txt
+            """,
+            # installed-files.txt is written by pip, and is a strictly more
+            # accurate source than SOURCES.txt as to the installed contents of
+            # the package.
+            "installed-files.txt": """
+                ../egg_with_module.py
+                PKG-INFO
+                SOURCES.txt
+                top_level.txt
+            """,
+            # missing top_level.txt (to trigger fallback to installed-files.txt)
+        },
+        "egg_with_module.py": """
+            def main():
+                print("hello world")
+            """,
+    }
+
+
+class EggInfoPkgPipInstalledExternalDataFiles(OnSysPath, SiteBuilder):
+    files: FilesSpec = {
+        "egg_with_module_pkg.egg-info": {
+            "PKG-INFO": "Name: egg_with_module-pkg",
+            # SOURCES.txt is made from the source archive, and contains files
+            # (setup.py) that are not present after installation.
+            "SOURCES.txt": """
+                egg_with_module.py
+                setup.py
+                egg_with_module.json
+                egg_with_module_pkg.egg-info/PKG-INFO
+                egg_with_module_pkg.egg-info/SOURCES.txt
+                egg_with_module_pkg.egg-info/top_level.txt
+            """,
+            # installed-files.txt is written by pip, and is a strictly more
+            # accurate source than SOURCES.txt as to the installed contents of
+            # the package.
+            "installed-files.txt": """
+                ../../../etc/jupyter/jupyter_notebook_config.d/relative.json
+                /etc/jupyter/jupyter_notebook_config.d/absolute.json
+                ../egg_with_module.py
+                PKG-INFO
+                SOURCES.txt
+                top_level.txt
+            """,
+            # missing top_level.txt (to trigger fallback to installed-files.txt)
+        },
+        "egg_with_module.py": """
+            def main():
+                print("hello world")
+            """,
+    }
+
+
+class EggInfoPkgPipInstalledNoModules(OnSysPath, SiteBuilder):
+    files: FilesSpec = {
+        "egg_with_no_modules_pkg.egg-info": {
+            "PKG-INFO": "Name: egg_with_no_modules-pkg",
+            # SOURCES.txt is made from the source archive, and contains files
+            # (setup.py) that are not present after installation.
+            "SOURCES.txt": """
+                setup.py
+                egg_with_no_modules_pkg.egg-info/PKG-INFO
+                egg_with_no_modules_pkg.egg-info/SOURCES.txt
+                egg_with_no_modules_pkg.egg-info/top_level.txt
+            """,
+            # installed-files.txt is written by pip, and is a strictly more
+            # accurate source than SOURCES.txt as to the installed contents of
+            # the package.
+            "installed-files.txt": """
+                PKG-INFO
+                SOURCES.txt
+                top_level.txt
+            """,
+            # top_level.txt correctly reflects that no modules are installed
+            "top_level.txt": b"\n",
+        },
+    }
+
+
+class EggInfoPkgSourcesFallback(OnSysPath, SiteBuilder):
+    files: FilesSpec = {
+        "sources_fallback_pkg.egg-info": {
+            "PKG-INFO": "Name: sources_fallback-pkg",
+            # SOURCES.txt is made from the source archive, and contains files
+            # (setup.py) that are not present after installation.
+            "SOURCES.txt": """
+                sources_fallback.py
+                setup.py
+                sources_fallback_pkg.egg-info/PKG-INFO
+                sources_fallback_pkg.egg-info/SOURCES.txt
+            """,
+            # missing installed-files.txt (i.e. not installed by pip) and
+            # missing top_level.txt (to trigger fallback to SOURCES.txt)
+        },
+        "sources_fallback.py": """
+            def main():
+                print("hello world")
+            """,
+    }
+
+
+class EggInfoFile(OnSysPath, SiteBuilder):
+    files: FilesSpec = {
+        "egginfo_file.egg-info": """
+            Metadata-Version: 1.0
+            Name: egginfo_file
+            Version: 0.1
+            Summary: An example package
+            Home-page: www.example.com
+            Author: Eric Haffa-Vee
+            Author-email: eric@example.coms
+            License: UNKNOWN
+            Description: UNKNOWN
+            Platform: UNKNOWN
+            """,
+    }
+
+
+# dedent all text strings before writing
+orig = _path.create.registry[str]
+_path.create.register(str, lambda content, path: orig(DALS(content), path))
+
+
+build_files = _path.build
+
+
+def build_record(file_defs):
+    return ''.join(f'{name},,\n' for name in record_names(file_defs))
+
+
+def record_names(file_defs):
+    recording = _path.Recording()
+    _path.build(file_defs, recording)
+    return recording.record
+
+
+class FileBuilder:
+    def unicode_filename(self):
+        return os_helper.FS_NONASCII or self.skip(
+            "File system does not support non-ascii."
+        )
+
+
+def DALS(str):
+    "Dedent and left-strip"
+    return textwrap.dedent(str).lstrip()
+
+
+@requires_zlib()
+class ZipFixtures:
+    root = 'test.test_importlib.metadata.data'
+
+    def _fixture_on_path(self, filename):
+        pkg_file = resources.files(self.root).joinpath(filename)
+        file = self.resources.enter_context(resources.as_file(pkg_file))
+        assert file.name.startswith('example'), file.name
+        sys.path.insert(0, str(file))
+        self.resources.callback(sys.path.pop, 0)
+
+    def setUp(self):
+        # Add self.zip_name to the front of sys.path.
+        self.resources = contextlib.ExitStack()
+        self.addCleanup(self.resources.close)
+
+
+def parameterize(*args_set):
+    """Run test method with a series of parameters."""
+
+    def wrapper(func):
+        @functools.wraps(func)
+        def _inner(self):
+            for args in args_set:
+                with self.subTest(**args):
+                    func(self, **args)
+
+        return _inner
+
+    return wrapper
diff --git a/Lib/test/test_importlib/metadata/stubs.py b/Lib/test/test_importlib/metadata/stubs.py
new file mode 100644
index 00000000000..e5b011c399f
--- /dev/null
+++ b/Lib/test/test_importlib/metadata/stubs.py
@@ -0,0 +1,10 @@
+import unittest
+
+
+class fake_filesystem_unittest:
+    """
+    Stubbed version of the pyfakefs module
+    """
+    class TestCase(unittest.TestCase):
+        def setUpPyfakefs(self):
+            self.skipTest("pyfakefs not available")
diff --git a/Lib/test/test_importlib/metadata/test_api.py b/Lib/test/test_importlib/metadata/test_api.py
new file mode 100644
index 00000000000..2256e0c502e
--- /dev/null
+++ b/Lib/test/test_importlib/metadata/test_api.py
@@ -0,0 +1,323 @@
+import re
+import textwrap
+import unittest
+import warnings
+import importlib
+import contextlib
+
+from . import fixtures
+from importlib.metadata import (
+    Distribution,
+    PackageNotFoundError,
+    distribution,
+    entry_points,
+    files,
+    metadata,
+    requires,
+    version,
+)
+
+
+@contextlib.contextmanager
+def suppress_known_deprecation():
+    with warnings.catch_warnings(record=True) as ctx:
+        warnings.simplefilter('default', category=DeprecationWarning)
+        yield ctx
+
+
+class APITests(
+    fixtures.EggInfoPkg,
+    fixtures.EggInfoPkgPipInstalledNoToplevel,
+    fixtures.EggInfoPkgPipInstalledNoModules,
+    fixtures.EggInfoPkgPipInstalledExternalDataFiles,
+    fixtures.EggInfoPkgSourcesFallback,
+    fixtures.DistInfoPkg,
+    fixtures.DistInfoPkgWithDot,
+    fixtures.EggInfoFile,
+    unittest.TestCase,
+):
+    version_pattern = r'\d+\.\d+(\.\d)?'
+
+    def test_retrieves_version_of_self(self):
+        pkg_version = version('egginfo-pkg')
+        assert isinstance(pkg_version, str)
+        assert re.match(self.version_pattern, pkg_version)
+
+    def test_retrieves_version_of_distinfo_pkg(self):
+        pkg_version = version('distinfo-pkg')
+        assert isinstance(pkg_version, str)
+        assert re.match(self.version_pattern, pkg_version)
+
+    def test_for_name_does_not_exist(self):
+        with self.assertRaises(PackageNotFoundError):
+            distribution('does-not-exist')
+
+    def test_name_normalization(self):
+        names = 'pkg.dot', 'pkg_dot', 'pkg-dot', 'pkg..dot', 'Pkg.Dot'
+        for name in names:
+            with self.subTest(name):
+                assert distribution(name).metadata['Name'] == 'pkg.dot'
+
+    def test_prefix_not_matched(self):
+        prefixes = 'p', 'pkg', 'pkg.'
+        for prefix in prefixes:
+            with self.subTest(prefix):
+                with self.assertRaises(PackageNotFoundError):
+                    distribution(prefix)
+
+    def test_for_top_level(self):
+        tests = [
+            ('egginfo-pkg', 'mod'),
+            ('egg_with_no_modules-pkg', ''),
+        ]
+        for pkg_name, expect_content in tests:
+            with self.subTest(pkg_name):
+                self.assertEqual(
+                    distribution(pkg_name).read_text('top_level.txt').strip(),
+                    expect_content,
+                )
+
+    def test_read_text(self):
+        tests = [
+            ('egginfo-pkg', 'mod\n'),
+            ('egg_with_no_modules-pkg', '\n'),
+        ]
+        for pkg_name, expect_content in tests:
+            with self.subTest(pkg_name):
+                top_level = [
+                    path for path in files(pkg_name) if path.name == 'top_level.txt'
+                ][0]
+                self.assertEqual(top_level.read_text(), expect_content)
+
+    def test_entry_points(self):
+        eps = entry_points()
+        assert 'entries' in eps.groups
+        entries = eps.select(group='entries')
+        assert 'main' in entries.names
+        ep = entries['main']
+        self.assertEqual(ep.value, 'mod:main')
+        self.assertEqual(ep.extras, [])
+
+    def test_entry_points_distribution(self):
+        entries = entry_points(group='entries')
+        for entry in ("main", "ns:sub"):
+            ep = entries[entry]
+            self.assertIn(ep.dist.name, ('distinfo-pkg', 'egginfo-pkg'))
+            self.assertEqual(ep.dist.version, "1.0.0")
+
+    def test_entry_points_unique_packages_normalized(self):
+        """
+        Entry points should only be exposed for the first package
+        on sys.path with a given name (even when normalized).
+        """
+        alt_site_dir = self.fixtures.enter_context(fixtures.tmp_path())
+        self.fixtures.enter_context(self.add_sys_path(alt_site_dir))
+        alt_pkg = {
+            "DistInfo_pkg-1.1.0.dist-info": {
+                "METADATA": """
+                Name: distinfo-pkg
+                Version: 1.1.0
+                """,
+                "entry_points.txt": """
+                [entries]
+                main = mod:altmain
+            """,
+            },
+        }
+        fixtures.build_files(alt_pkg, alt_site_dir)
+        entries = entry_points(group='entries')
+        assert not any(
+            ep.dist.name == 'distinfo-pkg' and ep.dist.version == '1.0.0'
+            for ep in entries
+        )
+        # ns:sub doesn't exist in alt_pkg
+        assert 'ns:sub' not in entries.names
+
+    def test_entry_points_missing_name(self):
+        with self.assertRaises(KeyError):
+            entry_points(group='entries')['missing']
+
+    def test_entry_points_missing_group(self):
+        assert entry_points(group='missing') == ()
+
+    def test_entry_points_allows_no_attributes(self):
+        ep = entry_points().select(group='entries', name='main')
+        with self.assertRaises(AttributeError):
+            ep.foo = 4
+
+    def test_metadata_for_this_package(self):
+        md = metadata('egginfo-pkg')
+        assert md['author'] == 'Steven Ma'
+        assert md['LICENSE'] == 'Unknown'
+        assert md['Name'] == 'egginfo-pkg'
+        classifiers = md.get_all('Classifier')
+        assert 'Topic :: Software Development :: Libraries' in classifiers
+
+    def test_missing_key_legacy(self):
+        """
+        Requesting a missing key will still return None, but warn.
+        """
+        md = metadata('distinfo-pkg')
+        with suppress_known_deprecation():
+            assert md['does-not-exist'] is None
+
+    def test_get_key(self):
+        """
+        Getting a key gets the key.
+        """
+        md = metadata('egginfo-pkg')
+        assert md.get('Name') == 'egginfo-pkg'
+
+    def test_get_missing_key(self):
+        """
+        Requesting a missing key will return None.
+        """
+        md = metadata('distinfo-pkg')
+        assert md.get('does-not-exist') is None
+
+    @staticmethod
+    def _test_files(files):
+        root = files[0].root
+        for file in files:
+            assert file.root == root
+            assert not file.hash or file.hash.value
+            assert not file.hash or file.hash.mode == 'sha256'
+            assert not file.size or file.size >= 0
+            assert file.locate().exists()
+            assert isinstance(file.read_binary(), bytes)
+            if file.name.endswith('.py'):
+                file.read_text()
+
+    def test_file_hash_repr(self):
+        util = [p for p in files('distinfo-pkg') if p.name == 'mod.py'][0]
+        self.assertRegex(repr(util.hash), '<FileHash mode: sha256 value: .*>')
+
+    def test_files_dist_info(self):
+        self._test_files(files('distinfo-pkg'))
+
+    def test_files_egg_info(self):
+        self._test_files(files('egginfo-pkg'))
+        self._test_files(files('egg_with_module-pkg'))
+        self._test_files(files('egg_with_no_modules-pkg'))
+        self._test_files(files('sources_fallback-pkg'))
+
+    def test_version_egg_info_file(self):
+        self.assertEqual(version('egginfo-file'), '0.1')
+
+    def test_requires_egg_info_file(self):
+        requirements = requires('egginfo-file')
+        self.assertIsNone(requirements)
+
+    def test_requires_egg_info(self):
+        deps = requires('egginfo-pkg')
+        assert len(deps) == 2
+        assert any(dep == 'wheel >= 1.0; python_version >= "2.7"' for dep in deps)
+
+    def test_requires_egg_info_empty(self):
+        fixtures.build_files(
+            {
+                'requires.txt': '',
+            },
+            self.site_dir.joinpath('egginfo_pkg.egg-info'),
+        )
+        deps = requires('egginfo-pkg')
+        assert deps == []
+
+    def test_requires_dist_info(self):
+        deps = requires('distinfo-pkg')
+        assert len(deps) == 2
+        assert all(deps)
+        assert 'wheel >= 1.0' in deps
+        assert "pytest; extra == 'test'" in deps
+
+    def test_more_complex_deps_requires_text(self):
+        requires = textwrap.dedent(
+            """
+            dep1
+            dep2
+
+            [:python_version < "3"]
+            dep3
+
+            [extra1]
+            dep4
+            dep6@ git+https://example.com/python/dep.git@v1.0.0
+
+            [extra2:python_version < "3"]
+            dep5
+            """
+        )
+        deps = sorted(Distribution._deps_from_requires_text(requires))
+        expected = [
+            'dep1',
+            'dep2',
+            'dep3; python_version < "3"',
+            'dep4; extra == "extra1"',
+            'dep5; (python_version < "3") and extra == "extra2"',
+            'dep6@ git+https://example.com/python/dep.git@v1.0.0 ; extra == "extra1"',
+        ]
+        # It's important that the environment marker expression be
+        # wrapped in parentheses to avoid the following 'and' binding more
+        # tightly than some other part of the environment expression.
+
+        assert deps == expected
+
+    def test_as_json(self):
+        md = metadata('distinfo-pkg').json
+        assert 'name' in md
+        assert md['keywords'] == ['sample', 'package']
+        desc = md['description']
+        assert desc.startswith('Once upon a time\nThere was')
+        assert len(md['requires_dist']) == 2
+
+    def test_as_json_egg_info(self):
+        md = metadata('egginfo-pkg').json
+        assert 'name' in md
+        assert md['keywords'] == ['sample', 'package']
+        desc = md['description']
+        assert desc.startswith('Once upon a time\nThere was')
+        assert len(md['classifier']) == 2
+
+    def test_as_json_odd_case(self):
+        self.make_uppercase()
+        md = metadata('distinfo-pkg').json
+        assert 'name' in md
+        assert len(md['requires_dist']) == 2
+        assert md['keywords'] == ['SAMPLE', 'PACKAGE']
+
+
+class LegacyDots(fixtures.DistInfoPkgWithDotLegacy, unittest.TestCase):
+    def test_name_normalization(self):
+        names = 'pkg.dot', 'pkg_dot', 'pkg-dot', 'pkg..dot', 'Pkg.Dot'
+        for name in names:
+            with self.subTest(name):
+                assert distribution(name).metadata['Name'] == 'pkg.dot'
+
+    def test_name_normalization_versionless_egg_info(self):
+        names = 'pkg.lot', 'pkg_lot', 'pkg-lot', 'pkg..lot', 'Pkg.Lot'
+        for name in names:
+            with self.subTest(name):
+                assert distribution(name).metadata['Name'] == 'pkg.lot'
+
+
+class OffSysPathTests(fixtures.DistInfoPkgOffPath, unittest.TestCase):
+    def test_find_distributions_specified_path(self):
+        dists = Distribution.discover(path=[str(self.site_dir)])
+        assert any(dist.metadata['Name'] == 'distinfo-pkg' for dist in dists)
+
+    def test_distribution_at_pathlib(self):
+        """Demonstrate how to load metadata direct from a directory."""
+        dist_info_path = self.site_dir / 'distinfo_pkg-1.0.0.dist-info'
+        dist = Distribution.at(dist_info_path)
+        assert dist.version == '1.0.0'
+
+    def test_distribution_at_str(self):
+        dist_info_path = self.site_dir / 'distinfo_pkg-1.0.0.dist-info'
+        dist = Distribution.at(str(dist_info_path))
+        assert dist.version == '1.0.0'
+
+
+class InvalidateCache(unittest.TestCase):
+    def test_invalidate_cache(self):
+        # No externally observable behavior, but ensures test coverage...
+        importlib.invalidate_caches()
diff --git a/Lib/test/test_importlib/metadata/test_main.py b/Lib/test/test_importlib/metadata/test_main.py
new file mode 100644
index 00000000000..e4218076f8c
--- /dev/null
+++ b/Lib/test/test_importlib/metadata/test_main.py
@@ -0,0 +1,468 @@
+import re
+import pickle
+import unittest
+import warnings
+import importlib
+import importlib.metadata
+import contextlib
+from test.support import os_helper
+
+try:
+    import pyfakefs.fake_filesystem_unittest as ffs
+except ImportError:
+    from .stubs import fake_filesystem_unittest as ffs
+
+from . import fixtures
+from ._context import suppress
+from ._path import Symlink
+from importlib.metadata import (
+    Distribution,
+    EntryPoint,
+    PackageNotFoundError,
+    _unique,
+    distributions,
+    entry_points,
+    metadata,
+    packages_distributions,
+    version,
+)
+
+
+@contextlib.contextmanager
+def suppress_known_deprecation():
+    with warnings.catch_warnings(record=True) as ctx:
+        warnings.simplefilter('default', category=DeprecationWarning)
+        yield ctx
+
+
+class BasicTests(fixtures.DistInfoPkg, unittest.TestCase):
+    version_pattern = r'\d+\.\d+(\.\d)?'
+
+    def test_retrieves_version_of_self(self):
+        dist = Distribution.from_name('distinfo-pkg')
+        assert isinstance(dist.version, str)
+        assert re.match(self.version_pattern, dist.version)
+
+    def test_for_name_does_not_exist(self):
+        with self.assertRaises(PackageNotFoundError):
+            Distribution.from_name('does-not-exist')
+
+    def test_package_not_found_mentions_metadata(self):
+        """
+        When a package is not found, that could indicate that the
+        package is not installed or that it is installed without
+        metadata. Ensure the exception mentions metadata to help
+        guide users toward the cause. See #124.
+        """
+        with self.assertRaises(PackageNotFoundError) as ctx:
+            Distribution.from_name('does-not-exist')
+
+        assert "metadata" in str(ctx.exception)
+
+    # expected to fail until ABC is enforced
+    @suppress(AssertionError)
+    @suppress_known_deprecation()
+    def test_abc_enforced(self):
+        with self.assertRaises(TypeError):
+            type('DistributionSubclass', (Distribution,), {})()
+
+    @fixtures.parameterize(
+        dict(name=None),
+        dict(name=''),
+    )
+    def test_invalid_inputs_to_from_name(self, name):
+        with self.assertRaises(Exception):
+            Distribution.from_name(name)
+
+
+class ImportTests(fixtures.DistInfoPkg, unittest.TestCase):
+    def test_import_nonexistent_module(self):
+        # Ensure that the MetadataPathFinder does not crash an import of a
+        # non-existent module.
+        with self.assertRaises(ImportError):
+            importlib.import_module('does_not_exist')
+
+    def test_resolve(self):
+        ep = entry_points(group='entries')['main']
+        self.assertEqual(ep.load().__name__, "main")
+
+    def test_entrypoint_with_colon_in_name(self):
+        ep = entry_points(group='entries')['ns:sub']
+        self.assertEqual(ep.value, 'mod:main')
+
+    def test_resolve_without_attr(self):
+        ep = EntryPoint(
+            name='ep',
+            value='importlib.metadata',
+            group='grp',
+        )
+        assert ep.load() is importlib.metadata
+
+
+class NameNormalizationTests(fixtures.OnSysPath, fixtures.SiteDir, unittest.TestCase):
+    @staticmethod
+    def make_pkg(name):
+        """
+        Create minimal metadata for a dist-info package with
+        the indicated name on the file system.
+        """
+        return {
+            f'{name}.dist-info': {
+                'METADATA': 'VERSION: 1.0\n',
+            },
+        }
+
+    def test_dashes_in_dist_name_found_as_underscores(self):
+        """
+        For a package with a dash in the name, the dist-info metadata
+        uses underscores in the name. Ensure the metadata loads.
+        """
+        fixtures.build_files(self.make_pkg('my_pkg'), self.site_dir)
+        assert version('my-pkg') == '1.0'
+
+    def test_dist_name_found_as_any_case(self):
+        """
+        Ensure the metadata loads when queried with any case.
+        """
+        pkg_name = 'CherryPy'
+        fixtures.build_files(self.make_pkg(pkg_name), self.site_dir)
+        assert version(pkg_name) == '1.0'
+        assert version(pkg_name.lower()) == '1.0'
+        assert version(pkg_name.upper()) == '1.0'
+
+    def test_unique_distributions(self):
+        """
+        Two distributions varying only by non-normalized name on
+        the file system should resolve as the same.
+        """
+        fixtures.build_files(self.make_pkg('abc'), self.site_dir)
+        before = list(_unique(distributions()))
+
+        alt_site_dir = self.fixtures.enter_context(fixtures.tmp_path())
+        self.fixtures.enter_context(self.add_sys_path(alt_site_dir))
+        fixtures.build_files(self.make_pkg('ABC'), alt_site_dir)
+        after = list(_unique(distributions()))
+
+        assert len(after) == len(before)
+
+
+class NonASCIITests(fixtures.OnSysPath, fixtures.SiteDir, unittest.TestCase):
+    @staticmethod
+    def pkg_with_non_ascii_description(site_dir):
+        """
+        Create minimal metadata for a package with non-ASCII in
+        the description.
+        """
+        contents = {
+            'portend.dist-info': {
+                'METADATA': 'Description: pôrˈtend',
+            },
+        }
+        fixtures.build_files(contents, site_dir)
+        return 'portend'
+
+    @staticmethod
+    def pkg_with_non_ascii_description_egg_info(site_dir):
+        """
+        Create minimal metadata for an egg-info package with
+        non-ASCII in the description.
+        """
+        contents = {
+            'portend.dist-info': {
+                'METADATA': """
+                Name: portend
+
+                pôrˈtend""",
+            },
+        }
+        fixtures.build_files(contents, site_dir)
+        return 'portend'
+
+    def test_metadata_loads(self):
+        pkg_name = self.pkg_with_non_ascii_description(self.site_dir)
+        meta = metadata(pkg_name)
+        assert meta['Description'] == 'pôrˈtend'
+
+    def test_metadata_loads_egg_info(self):
+        pkg_name = self.pkg_with_non_ascii_description_egg_info(self.site_dir)
+        meta = metadata(pkg_name)
+        assert meta['Description'] == 'pôrˈtend'
+
+
+class DiscoveryTests(
+    fixtures.EggInfoPkg,
+    fixtures.EggInfoPkgPipInstalledNoToplevel,
+    fixtures.EggInfoPkgPipInstalledNoModules,
+    fixtures.EggInfoPkgSourcesFallback,
+    fixtures.DistInfoPkg,
+    unittest.TestCase,
+):
+    def test_package_discovery(self):
+        dists = list(distributions())
+        assert all(isinstance(dist, Distribution) for dist in dists)
+        assert any(dist.metadata['Name'] == 'egginfo-pkg' for dist in dists)
+        assert any(dist.metadata['Name'] == 'egg_with_module-pkg' for dist in dists)
+        assert any(dist.metadata['Name'] == 'egg_with_no_modules-pkg' for dist in dists)
+        assert any(dist.metadata['Name'] == 'sources_fallback-pkg' for dist in dists)
+        assert any(dist.metadata['Name'] == 'distinfo-pkg' for dist in dists)
+
+    def test_invalid_usage(self):
+        with self.assertRaises(ValueError):
+            list(distributions(context='something', name='else'))
+
+    def test_interleaved_discovery(self):
+        """
+        Ensure interleaved searches are safe.
+
+        When the search is cached, it is possible for searches to be
+        interleaved, so make sure those use-cases are safe.
+
+        Ref #293
+        """
+        dists = distributions()
+        next(dists)
+        version('egginfo-pkg')
+        next(dists)
+
+
+class DirectoryTest(fixtures.OnSysPath, fixtures.SiteDir, unittest.TestCase):
+    def test_egg_info(self):
+        # make an `EGG-INFO` directory that's unrelated
+        self.site_dir.joinpath('EGG-INFO').mkdir()
+        # used to crash with `IsADirectoryError`
+        with self.assertRaises(PackageNotFoundError):
+            version('unknown-package')
+
+    def test_egg(self):
+        egg = self.site_dir.joinpath('foo-3.6.egg')
+        egg.mkdir()
+        with self.add_sys_path(egg):
+            with self.assertRaises(PackageNotFoundError):
+                version('foo')
+
+
+class MissingSysPath(fixtures.OnSysPath, unittest.TestCase):
+    site_dir = '/does-not-exist'
+
+    def test_discovery(self):
+        """
+        Discovering distributions should succeed even if
+        there is an invalid path on sys.path.
+        """
+        importlib.metadata.distributions()
+
+
+class InaccessibleSysPath(fixtures.OnSysPath, ffs.TestCase):
+    site_dir = '/access-denied'
+
+    def setUp(self):
+        super().setUp()
+        self.setUpPyfakefs()
+        self.fs.create_dir(self.site_dir, perm_bits=000)
+
+    def test_discovery(self):
+        """
+        Discovering distributions should succeed even if
+        there is an invalid path on sys.path.
+        """
+        list(importlib.metadata.distributions())
+
+
+class TestEntryPoints(unittest.TestCase):
+    def __init__(self, *args):
+        super().__init__(*args)
+        self.ep = importlib.metadata.EntryPoint(
+            name='name', value='value', group='group'
+        )
+
+    def test_entry_point_pickleable(self):
+        revived = pickle.loads(pickle.dumps(self.ep))
+        assert revived == self.ep
+
+    def test_positional_args(self):
+        """
+        Capture legacy (namedtuple) construction, discouraged.
+        """
+        EntryPoint('name', 'value', 'group')
+
+    def test_immutable(self):
+        """EntryPoints should be immutable"""
+        with self.assertRaises(AttributeError):
+            self.ep.name = 'badactor'
+
+    def test_repr(self):
+        assert 'EntryPoint' in repr(self.ep)
+        assert 'name=' in repr(self.ep)
+        assert "'name'" in repr(self.ep)
+
+    def test_hashable(self):
+        """EntryPoints should be hashable"""
+        hash(self.ep)
+
+    def test_module(self):
+        assert self.ep.module == 'value'
+
+    def test_attr(self):
+        assert self.ep.attr is None
+
+    def test_sortable(self):
+        """
+        EntryPoint objects are sortable, but result is undefined.
+        """
+        sorted([
+            EntryPoint(name='b', value='val', group='group'),
+            EntryPoint(name='a', value='val', group='group'),
+        ])
+
+
+class FileSystem(
+    fixtures.OnSysPath, fixtures.SiteDir, fixtures.FileBuilder, unittest.TestCase
+):
+    def test_unicode_dir_on_sys_path(self):
+        """
+        Ensure a Unicode subdirectory of a directory on sys.path
+        does not crash.
+        """
+        fixtures.build_files(
+            {self.unicode_filename(): {}},
+            prefix=self.site_dir,
+        )
+        list(distributions())
+
+
+class PackagesDistributionsPrebuiltTest(fixtures.ZipFixtures, unittest.TestCase):
+    def test_packages_distributions_example(self):
+        self._fixture_on_path('example-21.12-py3-none-any.whl')
+        assert packages_distributions()['example'] == ['example']
+
+    def test_packages_distributions_example2(self):
+        """
+        Test packages_distributions on a wheel built
+        by trampolim.
+        """
+        self._fixture_on_path('example2-1.0.0-py3-none-any.whl')
+        assert packages_distributions()['example2'] == ['example2']
+
+
+class PackagesDistributionsTest(
+    fixtures.OnSysPath, fixtures.SiteDir, unittest.TestCase
+):
+    def test_packages_distributions_neither_toplevel_nor_files(self):
+        """
+        Test a package built without 'top-level.txt' or a file list.
+        """
+        fixtures.build_files(
+            {
+                'trim_example-1.0.0.dist-info': {
+                    'METADATA': """
+                Name: trim_example
+                Version: 1.0.0
+                """,
+                }
+            },
+            prefix=self.site_dir,
+        )
+        packages_distributions()
+
+    def test_packages_distributions_all_module_types(self):
+        """
+        Test top-level modules detected on a package without 'top-level.txt'.
+        """
+        suffixes = importlib.machinery.all_suffixes()
+        metadata = dict(
+            METADATA="""
+                Name: all_distributions
+                Version: 1.0.0
+                """,
+        )
+        files = {
+            'all_distributions-1.0.0.dist-info': metadata,
+        }
+        for i, suffix in enumerate(suffixes):
+            files.update({
+                f'importable-name {i}{suffix}': '',
+                f'in_namespace_{i}': {
+                    f'mod{suffix}': '',
+                },
+                f'in_package_{i}': {
+                    '__init__.py': '',
+                    f'mod{suffix}': '',
+                },
+            })
+        metadata.update(RECORD=fixtures.build_record(files))
+        fixtures.build_files(files, prefix=self.site_dir)
+
+        distributions = packages_distributions()
+
+        for i in range(len(suffixes)):
+            assert distributions[f'importable-name {i}'] == ['all_distributions']
+            assert distributions[f'in_namespace_{i}'] == ['all_distributions']
+            assert distributions[f'in_package_{i}'] == ['all_distributions']
+
+        assert not any(name.endswith('.dist-info') for name in distributions)
+
+    @os_helper.skip_unless_symlink
+    def test_packages_distributions_symlinked_top_level(self) -> None:
+        """
+        Distribution is resolvable from a simple top-level symlink in RECORD.
+        See #452.
+        """
+
+        files: fixtures.FilesSpec = {
+            "symlinked_pkg-1.0.0.dist-info": {
+                "METADATA": """
+                    Name: symlinked-pkg
+                    Version: 1.0.0
+                    """,
+                "RECORD": "symlinked,,\n",
+            },
+            ".symlink.target": {},
+            "symlinked": Symlink(".symlink.target"),
+        }
+
+        fixtures.build_files(files, self.site_dir)
+        assert packages_distributions()['symlinked'] == ['symlinked-pkg']
+
+
+class PackagesDistributionsEggTest(
+    fixtures.EggInfoPkg,
+    fixtures.EggInfoPkgPipInstalledNoToplevel,
+    fixtures.EggInfoPkgPipInstalledNoModules,
+    fixtures.EggInfoPkgSourcesFallback,
+    unittest.TestCase,
+):
+    def test_packages_distributions_on_eggs(self):
+        """
+        Test old-style egg packages with a variation of 'top_level.txt',
+        'SOURCES.txt', and 'installed-files.txt', available.
+        """
+        distributions = packages_distributions()
+
+        def import_names_from_package(package_name):
+            return {
+                import_name
+                for import_name, package_names in distributions.items()
+                if package_name in package_names
+            }
+
+        # egginfo-pkg declares one import ('mod') via top_level.txt
+        assert import_names_from_package('egginfo-pkg') == {'mod'}
+
+        # egg_with_module-pkg has one import ('egg_with_module') inferred from
+        # installed-files.txt (top_level.txt is missing)
+        assert import_names_from_package('egg_with_module-pkg') == {'egg_with_module'}
+
+        # egg_with_no_modules-pkg should not be associated with any import names
+        # (top_level.txt is empty, and installed-files.txt has no .py files)
+        assert import_names_from_package('egg_with_no_modules-pkg') == set()
+
+        # sources_fallback-pkg has one import ('sources_fallback') inferred from
+        # SOURCES.txt (top_level.txt and installed-files.txt is missing)
+        assert import_names_from_package('sources_fallback-pkg') == {'sources_fallback'}
+
+
+class EditableDistributionTest(fixtures.DistInfoPkgEditable, unittest.TestCase):
+    def test_origin(self):
+        dist = Distribution.from_name('distinfo-pkg')
+        assert dist.origin.url.endswith('.whl')
+        assert dist.origin.archive_info.hashes.sha256
diff --git a/Lib/test/test_importlib/metadata/test_zip.py b/Lib/test/test_importlib/metadata/test_zip.py
new file mode 100644
index 00000000000..276f6288c91
--- /dev/null
+++ b/Lib/test/test_importlib/metadata/test_zip.py
@@ -0,0 +1,62 @@
+import sys
+import unittest
+
+from . import fixtures
+from importlib.metadata import (
+    PackageNotFoundError,
+    distribution,
+    distributions,
+    entry_points,
+    files,
+    version,
+)
+
+
+class TestZip(fixtures.ZipFixtures, unittest.TestCase):
+    def setUp(self):
+        super().setUp()
+        self._fixture_on_path('example-21.12-py3-none-any.whl')
+
+    def test_zip_version(self):
+        self.assertEqual(version('example'), '21.12')
+
+    def test_zip_version_does_not_match(self):
+        with self.assertRaises(PackageNotFoundError):
+            version('definitely-not-installed')
+
+    def test_zip_entry_points(self):
+        scripts = entry_points(group='console_scripts')
+        entry_point = scripts['example']
+        self.assertEqual(entry_point.value, 'example:main')
+        entry_point = scripts['Example']
+        self.assertEqual(entry_point.value, 'example:main')
+
+    def test_missing_metadata(self):
+        self.assertIsNone(distribution('example').read_text('does not exist'))
+
+    def test_case_insensitive(self):
+        self.assertEqual(version('Example'), '21.12')
+
+    def test_files(self):
+        for file in files('example'):
+            path = str(file.dist.locate_file(file))
+            assert '.whl/' in path, path
+
+    def test_one_distribution(self):
+        dists = list(distributions(path=sys.path[:1]))
+        assert len(dists) == 1
+
+
+class TestEgg(TestZip):
+    def setUp(self):
+        super().setUp()
+        self._fixture_on_path('example-21.12-py3.6.egg')
+
+    def test_files(self):
+        for file in files('example'):
+            path = str(file.dist.locate_file(file))
+            assert '.egg/' in path, path
+
+    def test_normalized_name(self):
+        dist = distribution('example')
+        assert dist._normalized_name == 'example'
diff --git a/Lib/test/test_importlib/namespace_pkgs/not_a_namespace_pkg/foo/__init__.py b/Lib/test/test_importlib/namespace_pkgs/not_a_namespace_pkg/foo/__init__.py
index e69de29bb2d..8b137891791 100644
--- a/Lib/test/test_importlib/namespace_pkgs/not_a_namespace_pkg/foo/__init__.py
+++ b/Lib/test/test_importlib/namespace_pkgs/not_a_namespace_pkg/foo/__init__.py
@@ -0,0 +1 @@
+
diff --git a/Lib/test/test_importlib/resources/__init__.py b/Lib/test/test_importlib/resources/__init__.py
index e69de29bb2d..8b137891791 100644
--- a/Lib/test/test_importlib/resources/__init__.py
+++ b/Lib/test/test_importlib/resources/__init__.py
@@ -0,0 +1 @@
+
diff --git a/Lib/test/test_importlib/resources/_path.py b/Lib/test/test_importlib/resources/_path.py
index 1f97c961469..b144628cb73 100644
--- a/Lib/test/test_importlib/resources/_path.py
+++ b/Lib/test/test_importlib/resources/_path.py
@@ -2,15 +2,44 @@
 import functools
 
 from typing import Dict, Union
+from typing import runtime_checkable
+from typing import Protocol
 
 
 ####
-# from jaraco.path 3.4.1
+# from jaraco.path 3.7.1
 
-FilesSpec = Dict[str, Union[str, bytes, 'FilesSpec']]  # type: ignore
 
+class Symlink(str):
+    """
+    A string indicating the target of a symlink.
+    """
+
+
+FilesSpec = Dict[str, Union[str, bytes, Symlink, 'FilesSpec']]
+
+
+@runtime_checkable
+class TreeMaker(Protocol):
+    def __truediv__(self, *args, **kwargs): ...  # pragma: no cover
+
+    def mkdir(self, **kwargs): ...  # pragma: no cover
+
+    def write_text(self, content, **kwargs): ...  # pragma: no cover
+
+    def write_bytes(self, content): ...  # pragma: no cover
 
-def build(spec: FilesSpec, prefix=pathlib.Path()):
+    def symlink_to(self, target): ...  # pragma: no cover
+
+
+def _ensure_tree_maker(obj: Union[str, TreeMaker]) -> TreeMaker:
+    return obj if isinstance(obj, TreeMaker) else pathlib.Path(obj)  # type: ignore[return-value]
+
+
+def build(
+    spec: FilesSpec,
+    prefix: Union[str, TreeMaker] = pathlib.Path(),  # type: ignore[assignment]
+):
     """
     Build a set of files/directories, as described by the spec.
 
@@ -25,21 +54,25 @@ def build(spec: FilesSpec, prefix=pathlib.Path()):
     ...             "__init__.py": "",
     ...         },
     ...         "baz.py": "# Some code",
-    ...     }
+    ...         "bar.py": Symlink("baz.py"),
+    ...     },
+    ...     "bing": Symlink("foo"),
     ... }
     >>> target = getfixture('tmp_path')
     >>> build(spec, target)
     >>> target.joinpath('foo/baz.py').read_text(encoding='utf-8')
     '# Some code'
+    >>> target.joinpath('bing/bar.py').read_text(encoding='utf-8')
+    '# Some code'
     """
     for name, contents in spec.items():
-        create(contents, pathlib.Path(prefix) / name)
+        create(contents, _ensure_tree_maker(prefix) / name)
 
 
 @functools.singledispatch
 def create(content: Union[str, bytes, FilesSpec], path):
     path.mkdir(exist_ok=True)
-    build(content, prefix=path)  # type: ignore
+    build(content, prefix=path)  # type: ignore[arg-type]
 
 
 @create.register
@@ -52,5 +85,10 @@ def _(content: str, path):
     path.write_text(content, encoding='utf-8')
 
 
+@create.register
+def _(content: Symlink, path):
+    path.symlink_to(content)
+
+
 # end from jaraco.path
 ####
diff --git a/Lib/test/test_importlib/resources/test_contents.py b/Lib/test/test_importlib/resources/test_contents.py
index 1a13f043a86..4e4e0e9c337 100644
--- a/Lib/test/test_importlib/resources/test_contents.py
+++ b/Lib/test/test_importlib/resources/test_contents.py
@@ -1,7 +1,6 @@
 import unittest
 from importlib import resources
 
-from . import data01
 from . import util
 
 
@@ -19,25 +18,21 @@ def test_contents(self):
         assert self.expected <= contents
 
 
-class ContentsDiskTests(ContentsTests, unittest.TestCase):
-    def setUp(self):
-        self.data = data01
+class ContentsDiskTests(ContentsTests, util.DiskSetup, unittest.TestCase):
+    pass
 
 
 class ContentsZipTests(ContentsTests, util.ZipSetup, unittest.TestCase):
     pass
 
 
-class ContentsNamespaceTests(ContentsTests, unittest.TestCase):
+class ContentsNamespaceTests(ContentsTests, util.DiskSetup, unittest.TestCase):
+    MODULE = 'namespacedata01'
+
     expected = {
         # no __init__ because of namespace design
-        # no subdirectory as incidental difference in fixture
         'binary.file',
+        'subdirectory',
         'utf-16.file',
         'utf-8.file',
     }
-
-    def setUp(self):
-        from . import namespacedata01
-
-        self.data = namespacedata01
diff --git a/Lib/test/test_importlib/resources/test_custom.py b/Lib/test/test_importlib/resources/test_custom.py
index 73127209a27..640f90fc0dd 100644
--- a/Lib/test/test_importlib/resources/test_custom.py
+++ b/Lib/test/test_importlib/resources/test_custom.py
@@ -5,6 +5,7 @@
 from test.support import os_helper
 
 from importlib import resources
+from importlib.resources import abc
 from importlib.resources.abc import TraversableResources, ResourceReader
 from . import util
 
@@ -39,8 +40,9 @@ def setUp(self):
         self.addCleanup(self.fixtures.close)
 
     def test_custom_loader(self):
-        temp_dir = self.fixtures.enter_context(os_helper.temp_dir())
+        temp_dir = pathlib.Path(self.fixtures.enter_context(os_helper.temp_dir()))
         loader = SimpleLoader(MagicResources(temp_dir))
         pkg = util.create_package_from_loader(loader)
         files = resources.files(pkg)
-        assert files is temp_dir
+        assert isinstance(files, abc.Traversable)
+        assert list(files.iterdir()) == []
diff --git a/Lib/test/test_importlib/resources/test_files.py b/Lib/test/test_importlib/resources/test_files.py
index 0e9c5c79a1a..3ce44999f98 100644
--- a/Lib/test/test_importlib/resources/test_files.py
+++ b/Lib/test/test_importlib/resources/test_files.py
@@ -1,4 +1,5 @@
-import typing
+import pathlib
+import py_compile
 import textwrap
 import unittest
 import warnings
@@ -7,11 +8,8 @@
 
 from importlib import resources
 from importlib.resources.abc import Traversable
-from . import data01
 from . import util
-from . import _path
-from test.support import os_helper
-from test.support import import_helper
+from test.support import os_helper, import_helper
 
 
 @contextlib.contextmanager
@@ -32,13 +30,14 @@ def test_read_text(self):
         actual = files.joinpath('utf-8.file').read_text(encoding='utf-8')
         assert actual == 'Hello, UTF-8 world!\n'
 
-    @unittest.skipUnless(
-        hasattr(typing, 'runtime_checkable'),
-        "Only suitable when typing supports runtime_checkable",
-    )
     def test_traversable(self):
         assert isinstance(resources.files(self.data), Traversable)
 
+    def test_joinpath_with_multiple_args(self):
+        files = resources.files(self.data)
+        binfile = files.joinpath('subdirectory', 'binary.file')
+        self.assertTrue(binfile.is_file())
+
     def test_old_parameter(self):
         """
         Files used to take a 'package' parameter. Make sure anyone
@@ -48,74 +47,145 @@ def test_old_parameter(self):
             resources.files(package=self.data)
 
 
-class OpenDiskTests(FilesTests, unittest.TestCase):
-    def setUp(self):
-        self.data = data01
-
-    @unittest.expectedFailureIfWindows("TODO: RUSTPYTHON, line ending issue")
-    def test_read_bytes(self):
-        super().test_read_bytes()
+class OpenDiskTests(FilesTests, util.DiskSetup, unittest.TestCase):
+    pass
 
 
 class OpenZipTests(FilesTests, util.ZipSetup, unittest.TestCase):
     pass
 
 
-class OpenNamespaceTests(FilesTests, unittest.TestCase):
-    def setUp(self):
-        from . import namespacedata01
+class OpenNamespaceTests(FilesTests, util.DiskSetup, unittest.TestCase):
+    MODULE = 'namespacedata01'
 
-        self.data = namespacedata01
+    def test_non_paths_in_dunder_path(self):
+        """
+        Non-path items in a namespace package's ``__path__`` are ignored.
+
+        As reported in python/importlib_resources#311, some tools
+        like Setuptools, when creating editable packages, will inject
+        non-paths into a namespace package's ``__path__``, a
+        sentinel like
+        ``__editable__.sample_namespace-1.0.finder.__path_hook__``
+        to cause the ``PathEntryFinder`` to be called when searching
+        for packages. In that case, resources should still be loadable.
+        """
+        import namespacedata01
 
-    @unittest.expectedFailureIfWindows("TODO: RUSTPYTHON, line ending issue")
-    def test_read_bytes(self):
-        super().test_read_bytes()
+        namespacedata01.__path__.append(
+            '__editable__.sample_namespace-1.0.finder.__path_hook__'
+        )
+
+        resources.files(namespacedata01)
+
+
+class OpenNamespaceZipTests(FilesTests, util.ZipSetup, unittest.TestCase):
+    ZIP_MODULE = 'namespacedata01'
 
 
-class SiteDir:
-    def setUp(self):
-        self.fixtures = contextlib.ExitStack()
-        self.addCleanup(self.fixtures.close)
-        self.site_dir = self.fixtures.enter_context(os_helper.temp_dir())
-        self.fixtures.enter_context(import_helper.DirsOnSysPath(self.site_dir))
-        self.fixtures.enter_context(import_helper.CleanImport())
+class DirectSpec:
+    """
+    Override behavior of ModuleSetup to write a full spec directly.
+    """
 
+    MODULE = 'unused'
+
+    def load_fixture(self, name):
+        self.tree_on_path(self.spec)
+
+
+class ModulesFiles:
+    spec = {
+        'mod.py': '',
+        'res.txt': 'resources are the best',
+    }
 
-class ModulesFilesTests(SiteDir, unittest.TestCase):
     def test_module_resources(self):
         """
         A module can have resources found adjacent to the module.
         """
-        spec = {
-            'mod.py': '',
-            'res.txt': 'resources are the best',
-        }
-        _path.build(spec, self.site_dir)
-        import mod
+        import mod  # type: ignore[import-not-found]
 
         actual = resources.files(mod).joinpath('res.txt').read_text(encoding='utf-8')
-        assert actual == spec['res.txt']
+        assert actual == self.spec['res.txt']
+
+
+class ModuleFilesDiskTests(DirectSpec, util.DiskSetup, ModulesFiles, unittest.TestCase):
+    pass
+
+
+class ModuleFilesZipTests(DirectSpec, util.ZipSetup, ModulesFiles, unittest.TestCase):
+    pass
+
 
+class ImplicitContextFiles:
+    set_val = textwrap.dedent(
+        f"""
+        import {resources.__name__} as res
+        val = res.files().joinpath('res.txt').read_text(encoding='utf-8')
+        """
+    )
+    spec = {
+        'somepkg': {
+            '__init__.py': set_val,
+            'submod.py': set_val,
+            'res.txt': 'resources are the best',
+        },
+        'frozenpkg': {
+            '__init__.py': set_val.replace(resources.__name__, 'c_resources'),
+            'res.txt': 'resources are the best',
+        },
+    }
 
-class ImplicitContextFilesTests(SiteDir, unittest.TestCase):
-    def test_implicit_files(self):
+    def test_implicit_files_package(self):
         """
         Without any parameter, files() will infer the location as the caller.
         """
-        spec = {
-            'somepkg': {
-                '__init__.py': textwrap.dedent(
-                    """
-                    import importlib.resources as res
-                    val = res.files().joinpath('res.txt').read_text(encoding='utf-8')
-                    """
-                ),
-                'res.txt': 'resources are the best',
-            },
-        }
-        _path.build(spec, self.site_dir)
         assert importlib.import_module('somepkg').val == 'resources are the best'
 
+    def test_implicit_files_submodule(self):
+        """
+        Without any parameter, files() will infer the location as the caller.
+        """
+        assert importlib.import_module('somepkg.submod').val == 'resources are the best'
+
+    def _compile_importlib(self):
+        """
+        Make a compiled-only copy of the importlib resources package.
+
+        Currently only code is copied, as importlib resources doesn't itself
+        have any resources.
+        """
+        bin_site = self.fixtures.enter_context(os_helper.temp_dir())
+        c_resources = pathlib.Path(bin_site, 'c_resources')
+        sources = pathlib.Path(resources.__file__).parent
+
+        for source_path in sources.glob('**/*.py'):
+            c_path = c_resources.joinpath(source_path.relative_to(sources)).with_suffix('.pyc')
+            py_compile.compile(source_path, c_path)
+        self.fixtures.enter_context(import_helper.DirsOnSysPath(bin_site))
+
+    def test_implicit_files_with_compiled_importlib(self):
+        """
+        Caller detection works for compiled-only resources module.
+
+        python/cpython#123085
+        """
+        self._compile_importlib()
+        assert importlib.import_module('frozenpkg').val == 'resources are the best'
+
+
+class ImplicitContextFilesDiskTests(
+    DirectSpec, util.DiskSetup, ImplicitContextFiles, unittest.TestCase
+):
+    pass
+
+
+class ImplicitContextFilesZipTests(
+    DirectSpec, util.ZipSetup, ImplicitContextFiles, unittest.TestCase
+):
+    pass
+
 
 if __name__ == '__main__':
     unittest.main()
diff --git a/Lib/test/test_importlib/resources/test_functional.py b/Lib/test/test_importlib/resources/test_functional.py
new file mode 100644
index 00000000000..e8d25fa4d9f
--- /dev/null
+++ b/Lib/test/test_importlib/resources/test_functional.py
@@ -0,0 +1,249 @@
+import unittest
+import os
+import importlib
+
+from test.support import warnings_helper
+
+from importlib import resources
+
+from . import util
+
+# Since the functional API forwards to Traversable, we only test
+# filesystem resources here -- not zip files, namespace packages etc.
+# We do test for two kinds of Anchor, though.
+
+
+class StringAnchorMixin:
+    anchor01 = 'data01'
+    anchor02 = 'data02'
+
+
+class ModuleAnchorMixin:
+    @property
+    def anchor01(self):
+        return importlib.import_module('data01')
+
+    @property
+    def anchor02(self):
+        return importlib.import_module('data02')
+
+
+class FunctionalAPIBase(util.DiskSetup):
+    def setUp(self):
+        super().setUp()
+        self.load_fixture('data02')
+
+    def _gen_resourcetxt_path_parts(self):
+        """Yield various names of a text file in anchor02, each in a subTest"""
+        for path_parts in (
+            ('subdirectory', 'subsubdir', 'resource.txt'),
+            ('subdirectory/subsubdir/resource.txt',),
+            ('subdirectory/subsubdir', 'resource.txt'),
+        ):
+            with self.subTest(path_parts=path_parts):
+                yield path_parts
+
+    def test_read_text(self):
+        self.assertEqual(
+            resources.read_text(self.anchor01, 'utf-8.file'),
+            'Hello, UTF-8 world!\n',
+        )
+        self.assertEqual(
+            resources.read_text(
+                self.anchor02,
+                'subdirectory',
+                'subsubdir',
+                'resource.txt',
+                encoding='utf-8',
+            ),
+            'a resource',
+        )
+        for path_parts in self._gen_resourcetxt_path_parts():
+            self.assertEqual(
+                resources.read_text(
+                    self.anchor02,
+                    *path_parts,
+                    encoding='utf-8',
+                ),
+                'a resource',
+            )
+        # Use generic OSError, since e.g. attempting to read a directory can
+        # fail with PermissionError rather than IsADirectoryError
+        with self.assertRaises(OSError):
+            resources.read_text(self.anchor01)
+        with self.assertRaises(OSError):
+            resources.read_text(self.anchor01, 'no-such-file')
+        with self.assertRaises(UnicodeDecodeError):
+            resources.read_text(self.anchor01, 'utf-16.file')
+        self.assertEqual(
+            resources.read_text(
+                self.anchor01,
+                'binary.file',
+                encoding='latin1',
+            ),
+            '\x00\x01\x02\x03',
+        )
+        self.assertEndsWith(  # ignore the BOM
+            resources.read_text(
+                self.anchor01,
+                'utf-16.file',
+                errors='backslashreplace',
+            ),
+            'Hello, UTF-16 world!\n'.encode('utf-16-le').decode(
+                errors='backslashreplace',
+            ),
+        )
+
+    def test_read_binary(self):
+        self.assertEqual(
+            resources.read_binary(self.anchor01, 'utf-8.file'),
+            b'Hello, UTF-8 world!\n',
+        )
+        for path_parts in self._gen_resourcetxt_path_parts():
+            self.assertEqual(
+                resources.read_binary(self.anchor02, *path_parts),
+                b'a resource',
+            )
+
+    def test_open_text(self):
+        with resources.open_text(self.anchor01, 'utf-8.file') as f:
+            self.assertEqual(f.read(), 'Hello, UTF-8 world!\n')
+        for path_parts in self._gen_resourcetxt_path_parts():
+            with resources.open_text(
+                self.anchor02,
+                *path_parts,
+                encoding='utf-8',
+            ) as f:
+                self.assertEqual(f.read(), 'a resource')
+        # Use generic OSError, since e.g. attempting to read a directory can
+        # fail with PermissionError rather than IsADirectoryError
+        with self.assertRaises(OSError):
+            resources.open_text(self.anchor01)
+        with self.assertRaises(OSError):
+            resources.open_text(self.anchor01, 'no-such-file')
+        with resources.open_text(self.anchor01, 'utf-16.file') as f:
+            with self.assertRaises(UnicodeDecodeError):
+                f.read()
+        with resources.open_text(
+            self.anchor01,
+            'binary.file',
+            encoding='latin1',
+        ) as f:
+            self.assertEqual(f.read(), '\x00\x01\x02\x03')
+        with resources.open_text(
+            self.anchor01,
+            'utf-16.file',
+            errors='backslashreplace',
+        ) as f:
+            self.assertEndsWith(  # ignore the BOM
+                f.read(),
+                'Hello, UTF-16 world!\n'.encode('utf-16-le').decode(
+                    errors='backslashreplace',
+                ),
+            )
+
+    def test_open_binary(self):
+        with resources.open_binary(self.anchor01, 'utf-8.file') as f:
+            self.assertEqual(f.read(), b'Hello, UTF-8 world!\n')
+        for path_parts in self._gen_resourcetxt_path_parts():
+            with resources.open_binary(
+                self.anchor02,
+                *path_parts,
+            ) as f:
+                self.assertEqual(f.read(), b'a resource')
+
+    def test_path(self):
+        with resources.path(self.anchor01, 'utf-8.file') as path:
+            with open(str(path), encoding='utf-8') as f:
+                self.assertEqual(f.read(), 'Hello, UTF-8 world!\n')
+        with resources.path(self.anchor01) as path:
+            with open(os.path.join(path, 'utf-8.file'), encoding='utf-8') as f:
+                self.assertEqual(f.read(), 'Hello, UTF-8 world!\n')
+
+    def test_is_resource(self):
+        is_resource = resources.is_resource
+        self.assertTrue(is_resource(self.anchor01, 'utf-8.file'))
+        self.assertFalse(is_resource(self.anchor01, 'no_such_file'))
+        self.assertFalse(is_resource(self.anchor01))
+        self.assertFalse(is_resource(self.anchor01, 'subdirectory'))
+        for path_parts in self._gen_resourcetxt_path_parts():
+            self.assertTrue(is_resource(self.anchor02, *path_parts))
+
+    def test_contents(self):
+        with warnings_helper.check_warnings((".*contents.*", DeprecationWarning)):
+            c = resources.contents(self.anchor01)
+        self.assertGreaterEqual(
+            set(c),
+            {'utf-8.file', 'utf-16.file', 'binary.file', 'subdirectory'},
+        )
+        with self.assertRaises(OSError), warnings_helper.check_warnings((
+            ".*contents.*",
+            DeprecationWarning,
+        )):
+            list(resources.contents(self.anchor01, 'utf-8.file'))
+
+        for path_parts in self._gen_resourcetxt_path_parts():
+            with self.assertRaises(OSError), warnings_helper.check_warnings((
+                ".*contents.*",
+                DeprecationWarning,
+            )):
+                list(resources.contents(self.anchor01, *path_parts))
+        with warnings_helper.check_warnings((".*contents.*", DeprecationWarning)):
+            c = resources.contents(self.anchor01, 'subdirectory')
+        self.assertGreaterEqual(
+            set(c),
+            {'binary.file'},
+        )
+
+    @warnings_helper.ignore_warnings(category=DeprecationWarning)
+    def test_common_errors(self):
+        for func in (
+            resources.read_text,
+            resources.read_binary,
+            resources.open_text,
+            resources.open_binary,
+            resources.path,
+            resources.is_resource,
+            resources.contents,
+        ):
+            with self.subTest(func=func):
+                # Rejecting None anchor
+                with self.assertRaises(TypeError):
+                    func(None)
+                # Rejecting invalid anchor type
+                with self.assertRaises((TypeError, AttributeError)):
+                    func(1234)
+                # Unknown module
+                with self.assertRaises(ModuleNotFoundError):
+                    func('$missing module$')
+
+    def test_text_errors(self):
+        for func in (
+            resources.read_text,
+            resources.open_text,
+        ):
+            with self.subTest(func=func):
+                # Multiple path arguments need explicit encoding argument.
+                with self.assertRaises(TypeError):
+                    func(
+                        self.anchor02,
+                        'subdirectory',
+                        'subsubdir',
+                        'resource.txt',
+                    )
+
+
+class FunctionalAPITest_StringAnchor(
+    StringAnchorMixin,
+    FunctionalAPIBase,
+    unittest.TestCase,
+):
+    pass
+
+
+class FunctionalAPITest_ModuleAnchor(
+    ModuleAnchorMixin,
+    FunctionalAPIBase,
+    unittest.TestCase,
+):
+    pass
diff --git a/Lib/test/test_importlib/resources/test_open.py b/Lib/test/test_importlib/resources/test_open.py
index 86becb4bfaa..8c00378ad3c 100644
--- a/Lib/test/test_importlib/resources/test_open.py
+++ b/Lib/test/test_importlib/resources/test_open.py
@@ -1,7 +1,6 @@
 import unittest
 
 from importlib import resources
-from . import data01
 from . import util
 
 
@@ -24,7 +23,7 @@ def test_open_binary(self):
         target = resources.files(self.data) / 'binary.file'
         with target.open('rb') as fp:
             result = fp.read()
-            self.assertEqual(result, b'\x00\x01\x02\x03')
+            self.assertEqual(result, bytes(range(4)))
 
     def test_open_text_default_encoding(self):
         target = resources.files(self.data) / 'utf-8.file'
@@ -65,21 +64,21 @@ def test_open_text_FileNotFoundError(self):
             target.open(encoding='utf-8')
 
 
-class OpenDiskTests(OpenTests, unittest.TestCase):
-    def setUp(self):
-        self.data = data01
-
+class OpenDiskTests(OpenTests, util.DiskSetup, unittest.TestCase):
+    pass
 
-class OpenDiskNamespaceTests(OpenTests, unittest.TestCase):
-    def setUp(self):
-        from . import namespacedata01
 
-        self.data = namespacedata01
+class OpenDiskNamespaceTests(OpenTests, util.DiskSetup, unittest.TestCase):
+    MODULE = 'namespacedata01'
 
 
 class OpenZipTests(OpenTests, util.ZipSetup, unittest.TestCase):
     pass
 
 
+class OpenNamespaceZipTests(OpenTests, util.ZipSetup, unittest.TestCase):
+    MODULE = 'namespacedata01'
+
+
 if __name__ == '__main__':
     unittest.main()
diff --git a/Lib/test/test_importlib/resources/test_path.py b/Lib/test/test_importlib/resources/test_path.py
index 34a6bdd2d58..903911f57b3 100644
--- a/Lib/test/test_importlib/resources/test_path.py
+++ b/Lib/test/test_importlib/resources/test_path.py
@@ -1,8 +1,8 @@
 import io
+import pathlib
 import unittest
 
 from importlib import resources
-from . import data01
 from . import util
 
 
@@ -15,23 +15,16 @@ def execute(self, package, path):
 class PathTests:
     def test_reading(self):
         """
-        Path should be readable.
-
-        Test also implicitly verifies the returned object is a pathlib.Path
-        instance.
+        Path should be readable and a pathlib.Path instance.
         """
         target = resources.files(self.data) / 'utf-8.file'
         with resources.as_file(target) as path:
-            self.assertTrue(path.name.endswith("utf-8.file"), repr(path))
-            # pathlib.Path.read_text() was introduced in Python 3.5.
-            with path.open('r', encoding='utf-8') as file:
-                text = file.read()
-            self.assertEqual('Hello, UTF-8 world!\n', text)
-
+            self.assertIsInstance(path, pathlib.Path)
+            self.assertEndsWith(path.name, "utf-8.file")
+            self.assertEqual('Hello, UTF-8 world!\n', path.read_text(encoding='utf-8'))
 
-class PathDiskTests(PathTests, unittest.TestCase):
-    data = data01
 
+class PathDiskTests(PathTests, util.DiskSetup, unittest.TestCase):
     def test_natural_path(self):
         # Guarantee the internal implementation detail that
         # file-system-backed resources do not get the tempdir
diff --git a/Lib/test/test_importlib/resources/test_read.py b/Lib/test/test_importlib/resources/test_read.py
index 088982681e8..59c237d9641 100644
--- a/Lib/test/test_importlib/resources/test_read.py
+++ b/Lib/test/test_importlib/resources/test_read.py
@@ -1,7 +1,7 @@
 import unittest
 
 from importlib import import_module, resources
-from . import data01
+
 from . import util
 
 
@@ -18,7 +18,7 @@ def execute(self, package, path):
 class ReadTests:
     def test_read_bytes(self):
         result = resources.files(self.data).joinpath('binary.file').read_bytes()
-        self.assertEqual(result, b'\0\1\2\3')
+        self.assertEqual(result, bytes(range(4)))
 
     def test_read_text_default_encoding(self):
         result = (
@@ -51,30 +51,42 @@ def test_read_text_with_errors(self):
         )
 
 
-class ReadDiskTests(ReadTests, unittest.TestCase):
-    data = data01
+class ReadDiskTests(ReadTests, util.DiskSetup, unittest.TestCase):
+    pass
 
 
 class ReadZipTests(ReadTests, util.ZipSetup, unittest.TestCase):
     def test_read_submodule_resource(self):
-        submodule = import_module('ziptestdata.subdirectory')
+        submodule = import_module('data01.subdirectory')
         result = resources.files(submodule).joinpath('binary.file').read_bytes()
-        self.assertEqual(result, b'\0\1\2\3')
+        self.assertEqual(result, bytes(range(4, 8)))
 
     def test_read_submodule_resource_by_name(self):
         result = (
-            resources.files('ziptestdata.subdirectory')
-            .joinpath('binary.file')
-            .read_bytes()
+            resources.files('data01.subdirectory').joinpath('binary.file').read_bytes()
         )
-        self.assertEqual(result, b'\0\1\2\3')
+        self.assertEqual(result, bytes(range(4, 8)))
+
 
+class ReadNamespaceTests(ReadTests, util.DiskSetup, unittest.TestCase):
+    MODULE = 'namespacedata01'
 
-class ReadNamespaceTests(ReadTests, unittest.TestCase):
-    def setUp(self):
-        from . import namespacedata01
 
-        self.data = namespacedata01
+class ReadNamespaceZipTests(ReadTests, util.ZipSetup, unittest.TestCase):
+    MODULE = 'namespacedata01'
+
+    def test_read_submodule_resource(self):
+        submodule = import_module('namespacedata01.subdirectory')
+        result = resources.files(submodule).joinpath('binary.file').read_bytes()
+        self.assertEqual(result, bytes(range(12, 16)))
+
+    def test_read_submodule_resource_by_name(self):
+        result = (
+            resources.files('namespacedata01.subdirectory')
+            .joinpath('binary.file')
+            .read_bytes()
+        )
+        self.assertEqual(result, bytes(range(12, 16)))
 
 
 if __name__ == '__main__':
diff --git a/Lib/test/test_importlib/resources/test_reader.py b/Lib/test/test_importlib/resources/test_reader.py
index 8670f72a334..ed5693ab416 100644
--- a/Lib/test/test_importlib/resources/test_reader.py
+++ b/Lib/test/test_importlib/resources/test_reader.py
@@ -1,17 +1,21 @@
 import os.path
-import sys
 import pathlib
 import unittest
 
 from importlib import import_module
 from importlib.readers import MultiplexedPath, NamespaceReader
 
+from . import util
 
-class MultiplexedPathTest(unittest.TestCase):
-    @classmethod
-    def setUpClass(cls):
-        path = pathlib.Path(__file__).parent / 'namespacedata01'
-        cls.folder = str(path)
+
+class MultiplexedPathTest(util.DiskSetup, unittest.TestCase):
+    MODULE = 'namespacedata01'
+
+    def setUp(self):
+        super().setUp()
+        self.folder = pathlib.Path(self.data.__path__[0])
+        self.data01 = pathlib.Path(self.load_fixture('data01').__file__).parent
+        self.data02 = pathlib.Path(self.load_fixture('data02').__file__).parent
 
     def test_init_no_paths(self):
         with self.assertRaises(FileNotFoundError):
@@ -19,7 +23,7 @@ def test_init_no_paths(self):
 
     def test_init_file(self):
         with self.assertRaises(NotADirectoryError):
-            MultiplexedPath(os.path.join(self.folder, 'binary.file'))
+            MultiplexedPath(self.folder / 'binary.file')
 
     def test_iterdir(self):
         contents = {path.name for path in MultiplexedPath(self.folder).iterdir()}
@@ -27,12 +31,13 @@ def test_iterdir(self):
             contents.remove('__pycache__')
         except (KeyError, ValueError):
             pass
-        self.assertEqual(contents, {'binary.file', 'utf-16.file', 'utf-8.file'})
+        self.assertEqual(
+            contents, {'subdirectory', 'binary.file', 'utf-16.file', 'utf-8.file'}
+        )
 
     def test_iterdir_duplicate(self):
-        data01 = os.path.abspath(os.path.join(__file__, '..', 'data01'))
         contents = {
-            path.name for path in MultiplexedPath(self.folder, data01).iterdir()
+            path.name for path in MultiplexedPath(self.folder, self.data01).iterdir()
         }
         for remove in ('__pycache__', '__init__.pyc'):
             try:
@@ -60,17 +65,16 @@ def test_open_file(self):
             path.open()
 
     def test_join_path(self):
-        prefix = os.path.abspath(os.path.join(__file__, '..'))
-        data01 = os.path.join(prefix, 'data01')
-        path = MultiplexedPath(self.folder, data01)
+        prefix = str(self.folder.parent)
+        path = MultiplexedPath(self.folder, self.data01)
         self.assertEqual(
             str(path.joinpath('binary.file'))[len(prefix) + 1 :],
             os.path.join('namespacedata01', 'binary.file'),
         )
-        self.assertEqual(
-            str(path.joinpath('subdirectory'))[len(prefix) + 1 :],
-            os.path.join('data01', 'subdirectory'),
-        )
+        sub = path.joinpath('subdirectory')
+        assert isinstance(sub, MultiplexedPath)
+        assert 'namespacedata01' in str(sub)
+        assert 'data01' in str(sub)
         self.assertEqual(
             str(path.joinpath('imaginary'))[len(prefix) + 1 :],
             os.path.join('namespacedata01', 'imaginary'),
@@ -82,10 +86,8 @@ def test_join_path_compound(self):
         assert not path.joinpath('imaginary/foo.py').exists()
 
     def test_join_path_common_subdir(self):
-        prefix = os.path.abspath(os.path.join(__file__, '..'))
-        data01 = os.path.join(prefix, 'data01')
-        data02 = os.path.join(prefix, 'data02')
-        path = MultiplexedPath(data01, data02)
+        prefix = str(self.data02.parent)
+        path = MultiplexedPath(self.data01, self.data02)
         self.assertIsInstance(path.joinpath('subdirectory'), MultiplexedPath)
         self.assertEqual(
             str(path.joinpath('subdirectory', 'subsubdir'))[len(prefix) + 1 :],
@@ -105,16 +107,8 @@ def test_name(self):
         )
 
 
-class NamespaceReaderTest(unittest.TestCase):
-    site_dir = str(pathlib.Path(__file__).parent)
-
-    @classmethod
-    def setUpClass(cls):
-        sys.path.append(cls.site_dir)
-
-    @classmethod
-    def tearDownClass(cls):
-        sys.path.remove(cls.site_dir)
+class NamespaceReaderTest(util.DiskSetup, unittest.TestCase):
+    MODULE = 'namespacedata01'
 
     def test_init_error(self):
         with self.assertRaises(ValueError):
@@ -124,7 +118,7 @@ def test_resource_path(self):
         namespacedata01 = import_module('namespacedata01')
         reader = NamespaceReader(namespacedata01.__spec__.submodule_search_locations)
 
-        root = os.path.abspath(os.path.join(__file__, '..', 'namespacedata01'))
+        root = self.data.__path__[0]
         self.assertEqual(
             reader.resource_path('binary.file'), os.path.join(root, 'binary.file')
         )
@@ -133,9 +127,8 @@ def test_resource_path(self):
         )
 
     def test_files(self):
-        namespacedata01 = import_module('namespacedata01')
-        reader = NamespaceReader(namespacedata01.__spec__.submodule_search_locations)
-        root = os.path.abspath(os.path.join(__file__, '..', 'namespacedata01'))
+        reader = NamespaceReader(self.data.__spec__.submodule_search_locations)
+        root = self.data.__path__[0]
         self.assertIsInstance(reader.files(), MultiplexedPath)
         self.assertEqual(repr(reader.files()), f"MultiplexedPath('{root}')")
 
diff --git a/Lib/test/test_importlib/resources/test_resource.py b/Lib/test/test_importlib/resources/test_resource.py
index 54d32d9b29f..83fc2ef4ed0 100644
--- a/Lib/test/test_importlib/resources/test_resource.py
+++ b/Lib/test/test_importlib/resources/test_resource.py
@@ -1,15 +1,8 @@
-import contextlib
-import sys
+import os
 import unittest
-import uuid
-import pathlib
 
-from . import data01
-from . import zipdata01, zipdata02
 from . import util
 from importlib import resources, import_module
-from test.support import import_helper, os_helper
-from test.support.os_helper import unlink
 
 
 class ResourceTests:
@@ -29,9 +22,8 @@ def test_is_dir(self):
         self.assertTrue(target.is_dir())
 
 
-class ResourceDiskTests(ResourceTests, unittest.TestCase):
-    def setUp(self):
-        self.data = data01
+class ResourceDiskTests(ResourceTests, util.DiskSetup, unittest.TestCase):
+    pass
 
 
 class ResourceZipTests(ResourceTests, util.ZipSetup, unittest.TestCase):
@@ -42,33 +34,39 @@ def names(traversable):
     return {item.name for item in traversable.iterdir()}
 
 
-class ResourceLoaderTests(unittest.TestCase):
+class ResourceLoaderTests(util.DiskSetup, unittest.TestCase):
     def test_resource_contents(self):
         package = util.create_package(
-            file=data01, path=data01.__file__, contents=['A', 'B', 'C']
+            file=self.data, path=self.data.__file__, contents=['A', 'B', 'C']
         )
         self.assertEqual(names(resources.files(package)), {'A', 'B', 'C'})
 
     def test_is_file(self):
         package = util.create_package(
-            file=data01, path=data01.__file__, contents=['A', 'B', 'C', 'D/E', 'D/F']
+            file=self.data,
+            path=self.data.__file__,
+            contents=['A', 'B', 'C', 'D/E', 'D/F'],
         )
         self.assertTrue(resources.files(package).joinpath('B').is_file())
 
     def test_is_dir(self):
         package = util.create_package(
-            file=data01, path=data01.__file__, contents=['A', 'B', 'C', 'D/E', 'D/F']
+            file=self.data,
+            path=self.data.__file__,
+            contents=['A', 'B', 'C', 'D/E', 'D/F'],
         )
         self.assertTrue(resources.files(package).joinpath('D').is_dir())
 
     def test_resource_missing(self):
         package = util.create_package(
-            file=data01, path=data01.__file__, contents=['A', 'B', 'C', 'D/E', 'D/F']
+            file=self.data,
+            path=self.data.__file__,
+            contents=['A', 'B', 'C', 'D/E', 'D/F'],
         )
         self.assertFalse(resources.files(package).joinpath('Z').is_file())
 
 
-class ResourceCornerCaseTests(unittest.TestCase):
+class ResourceCornerCaseTests(util.DiskSetup, unittest.TestCase):
     def test_package_has_no_reader_fallback(self):
         """
         Test odd ball packages which:
@@ -77,7 +75,7 @@ def test_package_has_no_reader_fallback(self):
         # 3. Are not in a zip file
         """
         module = util.create_package(
-            file=data01, path=data01.__file__, contents=['A', 'B', 'C']
+            file=self.data, path=self.data.__file__, contents=['A', 'B', 'C']
         )
         # Give the module a dummy loader.
         module.__loader__ = object()
@@ -88,43 +86,39 @@ def test_package_has_no_reader_fallback(self):
         self.assertFalse(resources.files(module).joinpath('A').is_file())
 
 
-class ResourceFromZipsTest01(util.ZipSetupBase, unittest.TestCase):
-    ZIP_MODULE = zipdata01  # type: ignore
-
+class ResourceFromZipsTest01(util.ZipSetup, unittest.TestCase):
     def test_is_submodule_resource(self):
-        submodule = import_module('ziptestdata.subdirectory')
+        submodule = import_module('data01.subdirectory')
         self.assertTrue(resources.files(submodule).joinpath('binary.file').is_file())
 
     def test_read_submodule_resource_by_name(self):
         self.assertTrue(
-            resources.files('ziptestdata.subdirectory')
-            .joinpath('binary.file')
-            .is_file()
+            resources.files('data01.subdirectory').joinpath('binary.file').is_file()
         )
 
     def test_submodule_contents(self):
-        submodule = import_module('ziptestdata.subdirectory')
+        submodule = import_module('data01.subdirectory')
         self.assertEqual(
             names(resources.files(submodule)), {'__init__.py', 'binary.file'}
         )
 
     def test_submodule_contents_by_name(self):
         self.assertEqual(
-            names(resources.files('ziptestdata.subdirectory')),
+            names(resources.files('data01.subdirectory')),
             {'__init__.py', 'binary.file'},
         )
 
     def test_as_file_directory(self):
-        with resources.as_file(resources.files('ziptestdata')) as data:
-            assert data.name == 'ziptestdata'
+        with resources.as_file(resources.files('data01')) as data:
+            assert data.name == 'data01'
             assert data.is_dir()
             assert data.joinpath('subdirectory').is_dir()
             assert len(list(data.iterdir()))
         assert not data.parent.exists()
 
 
-class ResourceFromZipsTest02(util.ZipSetupBase, unittest.TestCase):
-    ZIP_MODULE = zipdata02  # type: ignore
+class ResourceFromZipsTest02(util.ZipSetup, unittest.TestCase):
+    MODULE = 'data02'
 
     def test_unrelated_contents(self):
         """
@@ -132,98 +126,48 @@ def test_unrelated_contents(self):
         distinct resources. Ref python/importlib_resources#44.
         """
         self.assertEqual(
-            names(resources.files('ziptestdata.one')),
+            names(resources.files('data02.one')),
             {'__init__.py', 'resource1.txt'},
         )
         self.assertEqual(
-            names(resources.files('ziptestdata.two')),
+            names(resources.files('data02.two')),
             {'__init__.py', 'resource2.txt'},
         )
 
 
-@contextlib.contextmanager
-def zip_on_path(dir):
-    data_path = pathlib.Path(zipdata01.__file__)
-    source_zip_path = data_path.parent.joinpath('ziptestdata.zip')
-    zip_path = pathlib.Path(dir) / f'{uuid.uuid4()}.zip'
-    zip_path.write_bytes(source_zip_path.read_bytes())
-    sys.path.append(str(zip_path))
-    import_module('ziptestdata')
-
-    try:
-        yield
-    finally:
-        with contextlib.suppress(ValueError):
-            sys.path.remove(str(zip_path))
-
-        with contextlib.suppress(KeyError):
-            del sys.path_importer_cache[str(zip_path)]
-            del sys.modules['ziptestdata']
-
-        with contextlib.suppress(OSError):
-            unlink(zip_path)
-
-
-class DeletingZipsTest(unittest.TestCase):
+class DeletingZipsTest(util.ZipSetup, unittest.TestCase):
     """Having accessed resources in a zip file should not keep an open
     reference to the zip.
     """
 
-    def setUp(self):
-        self.fixtures = contextlib.ExitStack()
-        self.addCleanup(self.fixtures.close)
-
-        modules = import_helper.modules_setup()
-        self.addCleanup(import_helper.modules_cleanup, *modules)
-
-        temp_dir = self.fixtures.enter_context(os_helper.temp_dir())
-        self.fixtures.enter_context(zip_on_path(temp_dir))
-
     def test_iterdir_does_not_keep_open(self):
-        [item.name for item in resources.files('ziptestdata').iterdir()]
+        [item.name for item in resources.files('data01').iterdir()]
 
     def test_is_file_does_not_keep_open(self):
-        resources.files('ziptestdata').joinpath('binary.file').is_file()
+        resources.files('data01').joinpath('binary.file').is_file()
 
     def test_is_file_failure_does_not_keep_open(self):
-        resources.files('ziptestdata').joinpath('not-present').is_file()
+        resources.files('data01').joinpath('not-present').is_file()
 
     @unittest.skip("Desired but not supported.")
     def test_as_file_does_not_keep_open(self):  # pragma: no cover
-        resources.as_file(resources.files('ziptestdata') / 'binary.file')
+        resources.as_file(resources.files('data01') / '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
         available for the process duration.
         """
-        resources.as_file(resources.files('ziptestdata') / 'binary.file').__enter__()
+        resources.as_file(resources.files('data01') / 'binary.file').__enter__()
 
     def test_read_binary_does_not_keep_open(self):
-        resources.files('ziptestdata').joinpath('binary.file').read_bytes()
+        resources.files('data01').joinpath('binary.file').read_bytes()
 
     def test_read_text_does_not_keep_open(self):
-        resources.files('ziptestdata').joinpath('utf-8.file').read_text(
-            encoding='utf-8'
-        )
+        resources.files('data01').joinpath('utf-8.file').read_text(encoding='utf-8')
 
 
-class ResourceFromNamespaceTest01(unittest.TestCase):
-    site_dir = str(pathlib.Path(__file__).parent)
-
-    @classmethod
-    def setUpClass(cls):
-        sys.path.append(cls.site_dir)
-
-    @classmethod
-    def tearDownClass(cls):
-        sys.path.remove(cls.site_dir)
-
+class ResourceFromNamespaceTests:
     def test_is_submodule_resource(self):
         self.assertTrue(
             resources.files(import_module('namespacedata01'))
@@ -242,7 +186,9 @@ def test_submodule_contents(self):
             contents.remove('__pycache__')
         except KeyError:
             pass
-        self.assertEqual(contents, {'binary.file', 'utf-8.file', 'utf-16.file'})
+        self.assertEqual(
+            contents, {'subdirectory', 'binary.file', 'utf-8.file', 'utf-16.file'}
+        )
 
     def test_submodule_contents_by_name(self):
         contents = names(resources.files('namespacedata01'))
@@ -250,7 +196,41 @@ def test_submodule_contents_by_name(self):
             contents.remove('__pycache__')
         except KeyError:
             pass
-        self.assertEqual(contents, {'binary.file', 'utf-8.file', 'utf-16.file'})
+        self.assertEqual(
+            contents, {'subdirectory', 'binary.file', 'utf-8.file', 'utf-16.file'}
+        )
+
+    def test_submodule_sub_contents(self):
+        contents = names(resources.files(import_module('namespacedata01.subdirectory')))
+        try:
+            contents.remove('__pycache__')
+        except KeyError:
+            pass
+        self.assertEqual(contents, {'binary.file'})
+
+    def test_submodule_sub_contents_by_name(self):
+        contents = names(resources.files('namespacedata01.subdirectory'))
+        try:
+            contents.remove('__pycache__')
+        except KeyError:
+            pass
+        self.assertEqual(contents, {'binary.file'})
+
+
+class ResourceFromNamespaceDiskTests(
+    util.DiskSetup,
+    ResourceFromNamespaceTests,
+    unittest.TestCase,
+):
+    MODULE = 'namespacedata01'
+
+
+class ResourceFromNamespaceZipTests(
+    util.ZipSetup,
+    ResourceFromNamespaceTests,
+    unittest.TestCase,
+):
+    MODULE = 'namespacedata01'
 
 
 if __name__ == '__main__':
diff --git a/Lib/test/test_importlib/resources/util.py b/Lib/test/test_importlib/resources/util.py
index dbe6ee81476..e2d995f5963 100644
--- a/Lib/test/test_importlib/resources/util.py
+++ b/Lib/test/test_importlib/resources/util.py
@@ -4,11 +4,12 @@
 import sys
 import types
 import pathlib
+import contextlib
 
-from . import data01
-from . import zipdata01
 from importlib.resources.abc import ResourceReader
-from test.support import import_helper
+from test.support import import_helper, os_helper
+from . import zip as zip_
+from . import _path
 
 
 from importlib.machinery import ModuleSpec
@@ -67,7 +68,7 @@ def create_package(file=None, path=None, is_package=True, contents=()):
     )
 
 
-class CommonTests(metaclass=abc.ABCMeta):
+class CommonTestsBase(metaclass=abc.ABCMeta):
     """
     Tests shared by test_open, test_path, and test_read.
     """
@@ -83,34 +84,34 @@ def test_package_name(self):
         """
         Passing in the package name should succeed.
         """
-        self.execute(data01.__name__, 'utf-8.file')
+        self.execute(self.data.__name__, 'utf-8.file')
 
     def test_package_object(self):
         """
         Passing in the package itself should succeed.
         """
-        self.execute(data01, 'utf-8.file')
+        self.execute(self.data, 'utf-8.file')
 
     def test_string_path(self):
         """
         Passing in a string for the path should succeed.
         """
         path = 'utf-8.file'
-        self.execute(data01, path)
+        self.execute(self.data, path)
 
     def test_pathlib_path(self):
         """
         Passing in a pathlib.PurePath object for the path should succeed.
         """
         path = pathlib.PurePath('utf-8.file')
-        self.execute(data01, path)
+        self.execute(self.data, path)
 
     def test_importing_module_as_side_effect(self):
         """
         The anchor package can already be imported.
         """
-        del sys.modules[data01.__name__]
-        self.execute(data01.__name__, 'utf-8.file')
+        del sys.modules[self.data.__name__]
+        self.execute(self.data.__name__, 'utf-8.file')
 
     def test_missing_path(self):
         """
@@ -140,40 +141,66 @@ def test_useless_loader(self):
             self.execute(package, 'utf-8.file')
 
 
-class ZipSetupBase:
-    ZIP_MODULE = None
-
-    @classmethod
-    def setUpClass(cls):
-        data_path = pathlib.Path(cls.ZIP_MODULE.__file__)
-        data_dir = data_path.parent
-        cls._zip_path = str(data_dir / 'ziptestdata.zip')
-        sys.path.append(cls._zip_path)
-        cls.data = importlib.import_module('ziptestdata')
-
-    @classmethod
-    def tearDownClass(cls):
-        try:
-            sys.path.remove(cls._zip_path)
-        except ValueError:
-            pass
-
-        try:
-            del sys.path_importer_cache[cls._zip_path]
-            del sys.modules[cls.data.__name__]
-        except KeyError:
-            pass
-
-        try:
-            del cls.data
-            del cls._zip_path
-        except AttributeError:
-            pass
-
+fixtures = dict(
+    data01={
+        '__init__.py': '',
+        'binary.file': bytes(range(4)),
+        'utf-16.file': '\ufeffHello, UTF-16 world!\n'.encode('utf-16-le'),
+        'utf-8.file': 'Hello, UTF-8 world!\n'.encode('utf-8'),
+        'subdirectory': {
+            '__init__.py': '',
+            'binary.file': bytes(range(4, 8)),
+        },
+    },
+    data02={
+        '__init__.py': '',
+        'one': {'__init__.py': '', 'resource1.txt': 'one resource'},
+        'two': {'__init__.py': '', 'resource2.txt': 'two resource'},
+        'subdirectory': {'subsubdir': {'resource.txt': 'a resource'}},
+    },
+    namespacedata01={
+        'binary.file': bytes(range(4)),
+        'utf-16.file': '\ufeffHello, UTF-16 world!\n'.encode('utf-16-le'),
+        'utf-8.file': 'Hello, UTF-8 world!\n'.encode('utf-8'),
+        'subdirectory': {
+            'binary.file': bytes(range(12, 16)),
+        },
+    },
+)
+
+
+class ModuleSetup:
     def setUp(self):
-        modules = import_helper.modules_setup()
-        self.addCleanup(import_helper.modules_cleanup, *modules)
+        self.fixtures = contextlib.ExitStack()
+        self.addCleanup(self.fixtures.close)
+
+        self.fixtures.enter_context(import_helper.isolated_modules())
+        self.data = self.load_fixture(self.MODULE)
+
+    def load_fixture(self, module):
+        self.tree_on_path({module: fixtures[module]})
+        return importlib.import_module(module)
+
+
+class ZipSetup(ModuleSetup):
+    MODULE = 'data01'
+
+    def tree_on_path(self, spec):
+        temp_dir = self.fixtures.enter_context(os_helper.temp_dir())
+        modules = pathlib.Path(temp_dir) / 'zipped modules.zip'
+        self.fixtures.enter_context(
+            import_helper.DirsOnSysPath(str(zip_.make_zip_file(spec, modules)))
+        )
+
+
+class DiskSetup(ModuleSetup):
+    MODULE = 'data01'
+
+    def tree_on_path(self, spec):
+        temp_dir = self.fixtures.enter_context(os_helper.temp_dir())
+        _path.build(spec, pathlib.Path(temp_dir))
+        self.fixtures.enter_context(import_helper.DirsOnSysPath(temp_dir))
 
 
-class ZipSetup(ZipSetupBase):
-    ZIP_MODULE = zipdata01  # type: ignore
+class CommonTests(DiskSetup, CommonTestsBase):
+    pass
diff --git a/Lib/test/test_importlib/resources/zip.py b/Lib/test/test_importlib/resources/zip.py
new file mode 100644
index 00000000000..fc453f02060
--- /dev/null
+++ b/Lib/test/test_importlib/resources/zip.py
@@ -0,0 +1,24 @@
+"""
+Generate zip test data files.
+"""
+
+import zipfile
+
+
+def make_zip_file(tree, dst):
+    """
+    Zip the files in tree into a new zipfile at dst.
+    """
+    with zipfile.ZipFile(dst, 'w') as zf:
+        for name, contents in walk(tree):
+            zf.writestr(name, contents)
+        zipfile._path.CompleteDirs.inject(zf)
+    return dst
+
+
+def walk(tree, prefix=''):
+    for name, contents in tree.items():
+        if isinstance(contents, dict):
+            yield from walk(contents, prefix=f'{prefix}{name}/')
+        else:
+            yield f'{prefix}{name}', contents
diff --git a/Lib/test/test_importlib/source/test_case_sensitivity.py b/Lib/test/test_importlib/source/test_case_sensitivity.py
index 6a06313319d..e52829e6280 100644
--- a/Lib/test/test_importlib/source/test_case_sensitivity.py
+++ b/Lib/test/test_importlib/source/test_case_sensitivity.py
@@ -9,7 +9,6 @@
 import os
 from test.support import os_helper
 import unittest
-import warnings
 
 
 @util.case_insensitive_tests
diff --git a/Lib/test/test_importlib/source/test_file_loader.py b/Lib/test/test_importlib/source/test_file_loader.py
index fa0efee8da6..f35adec1a8e 100644
--- a/Lib/test/test_importlib/source/test_file_loader.py
+++ b/Lib/test/test_importlib/source/test_file_loader.py
@@ -359,6 +359,7 @@ def test_overridden_unchecked_hash_based_pyc(self):
  ) = util.test_both(SimpleTest, importlib=importlib, machinery=machinery,
                     abc=importlib_abc, util=importlib_util)
 
+
 class SourceDateEpochTestMeta(SourceDateEpochTestMeta,
                               type(Source_SimpleTest)):
     pass
@@ -679,6 +680,7 @@ class SourceLoaderBadBytecodeTestPEP451(
                     machinery=machinery, abc=importlib_abc,
                     util=importlib_util)
 
+
 class SourceLoaderBadBytecodeTestPEP302(
         SourceLoaderBadBytecodeTest, BadBytecodeTestPEP302):
     pass
@@ -690,6 +692,7 @@ class SourceLoaderBadBytecodeTestPEP302(
                     machinery=machinery, abc=importlib_abc,
                     util=importlib_util)
 
+
 class SourcelessLoaderBadBytecodeTest:
 
     @classmethod
@@ -775,6 +778,7 @@ class SourcelessLoaderBadBytecodeTestPEP451(SourcelessLoaderBadBytecodeTest,
                     machinery=machinery, abc=importlib_abc,
                     util=importlib_util)
 
+
 class SourcelessLoaderBadBytecodeTestPEP302(SourcelessLoaderBadBytecodeTest,
         BadBytecodeTestPEP302):
     pass
@@ -786,5 +790,6 @@ class SourcelessLoaderBadBytecodeTestPEP302(SourcelessLoaderBadBytecodeTest,
                     machinery=machinery, abc=importlib_abc,
                     util=importlib_util)
 
+
 if __name__ == '__main__':
     unittest.main()
diff --git a/Lib/test/test_importlib/source/test_finder.py b/Lib/test/test_importlib/source/test_finder.py
index 12db7c7d352..4de736a6bf3 100644
--- a/Lib/test/test_importlib/source/test_finder.py
+++ b/Lib/test/test_importlib/source/test_finder.py
@@ -10,7 +10,6 @@
 import tempfile
 from test.support.import_helper import make_legacy_pyc
 import unittest
-import warnings
 
 
 class FinderTests(abc.FinderTests):
@@ -74,7 +73,7 @@ def run_test(self, test, create=None, *, compile_=None, unlink=None):
                         if error.errno != errno.ENOENT:
                             raise
             loader = self.import_(mapping['.root'], test)
-            self.assertTrue(hasattr(loader, 'load_module'))
+            self.assertHasAttr(loader, 'load_module')
             return loader
 
     def test_module(self):
@@ -101,7 +100,7 @@ def test_module_in_package(self):
         with util.create_modules('pkg.__init__', 'pkg.sub') as mapping:
             pkg_dir = os.path.dirname(mapping['pkg.__init__'])
             loader = self.import_(pkg_dir, 'pkg.sub')
-            self.assertTrue(hasattr(loader, 'load_module'))
+            self.assertHasAttr(loader, 'load_module')
 
     # [sub package]
     def test_package_in_package(self):
@@ -109,7 +108,7 @@ def test_package_in_package(self):
         with context as mapping:
             pkg_dir = os.path.dirname(mapping['pkg.__init__'])
             loader = self.import_(pkg_dir, 'pkg.sub')
-            self.assertTrue(hasattr(loader, 'load_module'))
+            self.assertHasAttr(loader, 'load_module')
 
     # [package over modules]
     def test_package_over_module(self):
@@ -130,7 +129,7 @@ def test_empty_string_for_dir(self):
             file.write("# test file for importlib")
         try:
             loader = self._find(finder, 'mod', loader_only=True)
-            self.assertTrue(hasattr(loader, 'load_module'))
+            self.assertHasAttr(loader, 'load_module')
         finally:
             os.unlink('mod.py')
 
diff --git a/Lib/test/test_importlib/source/test_path_hook.py b/Lib/test/test_importlib/source/test_path_hook.py
index f274330e0b3..6e1c23e6a98 100644
--- a/Lib/test/test_importlib/source/test_path_hook.py
+++ b/Lib/test/test_importlib/source/test_path_hook.py
@@ -15,12 +15,12 @@ def path_hook(self):
 
     def test_success(self):
         with util.create_modules('dummy') as mapping:
-            self.assertTrue(hasattr(self.path_hook()(mapping['.root']),
-                                    'find_spec'))
+            self.assertHasAttr(self.path_hook()(mapping['.root']),
+                               'find_spec')
 
     def test_empty_string(self):
         # The empty string represents the cwd.
-        self.assertTrue(hasattr(self.path_hook()(''), 'find_spec'))
+        self.assertHasAttr(self.path_hook()(''), 'find_spec')
 
 
 (Frozen_PathHookTest,
diff --git a/Lib/test/test_importlib/source/test_source_encoding.py b/Lib/test/test_importlib/source/test_source_encoding.py
index 4f206accf97..c09c9aa12b8 100644
--- a/Lib/test/test_importlib/source/test_source_encoding.py
+++ b/Lib/test/test_importlib/source/test_source_encoding.py
@@ -61,16 +61,12 @@ def test_non_obvious_encoding(self):
     def test_default_encoding(self):
         self.run_test(self.source_line.encode('utf-8'))
 
-    # TODO: RUSTPYTHON, UnicodeDecodeError: invalid utf-8 sequence of 1 bytes from index 17
-    @unittest.expectedFailure
     # [encoding first line]
     def test_encoding_on_first_line(self):
         encoding = 'Latin-1'
         source = self.create_source(encoding)
         self.run_test(source)
 
-    # TODO: RUSTPYTHON, UnicodeDecodeError: invalid utf-8 sequence of 1 bytes from index 34
-    @unittest.expectedFailure
     # [encoding second line]
     def test_encoding_on_second_line(self):
         source = b"#/usr/bin/python\n" + self.create_source('Latin-1')
@@ -85,8 +81,6 @@ def test_bom_and_utf_8(self):
         source = codecs.BOM_UTF8 + self.create_source('utf-8')
         self.run_test(source)
 
-    # TODO: RUSTPYTHON, UnicodeDecodeError: invalid utf-8 sequence of 1 bytes from index 20
-    @unittest.expectedFailure
     # [BOM conflict]
     def test_bom_conflict(self):
         source = codecs.BOM_UTF8 + self.create_source('latin-1')
diff --git a/Lib/test/test_importlib/test_abc.py b/Lib/test/test_importlib/test_abc.py
index 603125f6d92..dd943210ffc 100644
--- a/Lib/test/test_importlib/test_abc.py
+++ b/Lib/test/test_importlib/test_abc.py
@@ -43,14 +43,12 @@ def setUp(self):
     def test_subclasses(self):
         # Test that the expected subclasses inherit.
         for subclass in self.subclasses:
-            self.assertTrue(issubclass(subclass, self.__test),
-                "{0} is not a subclass of {1}".format(subclass, self.__test))
+            self.assertIsSubclass(subclass, self.__test)
 
     def test_superclasses(self):
         # Test that the class inherits from the expected superclasses.
         for superclass in self.superclasses:
-            self.assertTrue(issubclass(self.__test, superclass),
-               "{0} is not a superclass of {1}".format(superclass, self.__test))
+            self.assertIsSubclass(self.__test, superclass)
 
 
 class MetaPathFinder(InheritanceTests):
@@ -416,14 +414,14 @@ def test_source_to_code_source(self):
         # Since compile() can handle strings, so should source_to_code().
         source = 'attr = 42'
         module = self.source_to_module(source)
-        self.assertTrue(hasattr(module, 'attr'))
+        self.assertHasAttr(module, 'attr')
         self.assertEqual(module.attr, 42)
 
     def test_source_to_code_bytes(self):
         # Since compile() can handle bytes, so should source_to_code().
         source = b'attr = 42'
         module = self.source_to_module(source)
-        self.assertTrue(hasattr(module, 'attr'))
+        self.assertHasAttr(module, 'attr')
         self.assertEqual(module.attr, 42)
 
     def test_source_to_code_path(self):
@@ -757,7 +755,7 @@ def test_package_settings(self):
                     warnings.simplefilter('ignore', DeprecationWarning)
                     module = self.loader.load_module(self.name)
                 self.verify_module(module)
-                self.assertFalse(hasattr(module, '__path__'))
+                self.assertNotHasAttr(module, '__path__')
 
     def test_get_source_encoding(self):
         # Source is considered encoded in UTF-8 by default unless otherwise
@@ -795,6 +793,9 @@ def verify_code(self, code_object, *, bytecode_written=False):
             data.extend(self.init._pack_uint32(0))
             data.extend(self.init._pack_uint32(self.loader.source_mtime))
             data.extend(self.init._pack_uint32(self.loader.source_size))
+            # Make sure there's > 1 reference to code_object so that the
+            # marshaled representation below matches the cached representation
+            l = [code_object]
             data.extend(marshal.dumps(code_object))
             self.assertEqual(self.loader.written[self.cached], bytes(data))
 
@@ -913,5 +914,30 @@ def test_universal_newlines(self):
                          SourceOnlyLoaderMock=SPLIT_SOL)
 
 
+class SourceLoaderDeprecationWarningsTests(unittest.TestCase):
+    """Tests SourceLoader deprecation warnings."""
+
+    def test_deprecated_path_mtime(self):
+        from importlib.abc import SourceLoader
+        class DummySourceLoader(SourceLoader):
+            def get_data(self, path):
+                return b''
+
+            def get_filename(self, fullname):
+                return 'foo.py'
+
+            def path_stats(self, path):
+                return {'mtime': 1}
+
+        loader = DummySourceLoader()
+
+        with self.assertWarnsRegex(
+            DeprecationWarning,
+            r"SourceLoader\.path_mtime is deprecated in favour of "
+            r"SourceLoader\.path_stats\(\)\."
+        ):
+            loader.path_mtime('foo.py')
+
+
 if __name__ == '__main__':
     unittest.main()
diff --git a/Lib/test/test_importlib/test_api.py b/Lib/test/test_importlib/test_api.py
index ecf2c47c462..1bc531a2fe3 100644
--- a/Lib/test/test_importlib/test_api.py
+++ b/Lib/test/test_importlib/test_api.py
@@ -6,11 +6,12 @@
 
 import os.path
 import sys
+from test import support
 from test.support import import_helper
 from test.support import os_helper
+import traceback
 import types
 import unittest
-import warnings
 
 
 class ImportModuleTests:
@@ -354,6 +355,20 @@ def test_module_missing_spec(self):
             with self.assertRaises(ModuleNotFoundError):
                 self.init.reload(module)
 
+    def test_reload_traceback_with_non_str(self):
+        # gh-125519
+        with support.captured_stdout() as stdout:
+            try:
+                self.init.reload("typing")
+            except TypeError as exc:
+                traceback.print_exception(exc, file=stdout)
+            else:
+                self.fail("Expected TypeError to be raised")
+        printed_traceback = stdout.getvalue()
+        self.assertIn("TypeError", printed_traceback)
+        self.assertNotIn("AttributeError", printed_traceback)
+        self.assertNotIn("module.__spec__.name", printed_traceback)
+
 
 (Frozen_ReloadTests,
  Source_ReloadTests
@@ -415,8 +430,7 @@ def test_everyone_has___loader__(self):
         for name, module in sys.modules.items():
             if isinstance(module, types.ModuleType):
                 with self.subTest(name=name):
-                    self.assertTrue(hasattr(module, '__loader__'),
-                                    '{!r} lacks a __loader__ attribute'.format(name))
+                    self.assertHasAttr(module, '__loader__')
                     if self.machinery.BuiltinImporter.find_spec(name):
                         self.assertIsNot(module.__loader__, None)
                     elif self.machinery.FrozenImporter.find_spec(name):
@@ -426,7 +440,7 @@ def test_everyone_has___spec__(self):
         for name, module in sys.modules.items():
             if isinstance(module, types.ModuleType):
                 with self.subTest(name=name):
-                    self.assertTrue(hasattr(module, '__spec__'))
+                    self.assertHasAttr(module, '__spec__')
                     if self.machinery.BuiltinImporter.find_spec(name):
                         self.assertIsNot(module.__spec__, None)
                     elif self.machinery.FrozenImporter.find_spec(name):
@@ -438,5 +452,57 @@ def test_everyone_has___spec__(self):
  ) = test_util.test_both(StartupTests, machinery=machinery)
 
 
+class TestModuleAll(unittest.TestCase):
+    def test_machinery(self):
+        extra = (
+            # from importlib._bootstrap and importlib._bootstrap_external
+            'AppleFrameworkLoader',
+            'BYTECODE_SUFFIXES',
+            'BuiltinImporter',
+            'DEBUG_BYTECODE_SUFFIXES',
+            'EXTENSION_SUFFIXES',
+            'ExtensionFileLoader',
+            'FileFinder',
+            'FrozenImporter',
+            'ModuleSpec',
+            'NamespaceLoader',
+            'OPTIMIZED_BYTECODE_SUFFIXES',
+            'PathFinder',
+            'SOURCE_SUFFIXES',
+            'SourceFileLoader',
+            'SourcelessFileLoader',
+            'WindowsRegistryFinder',
+        )
+        support.check__all__(self, machinery['Source'], extra=extra)
+
+    def test_util(self):
+        extra = (
+            # from importlib.abc, importlib._bootstrap
+            # and importlib._bootstrap_external
+            'Loader',
+            'MAGIC_NUMBER',
+            'cache_from_source',
+            'decode_source',
+            'module_from_spec',
+            'source_from_cache',
+            'spec_from_file_location',
+            'spec_from_loader',
+        )
+        support.check__all__(self, util['Source'], extra=extra)
+
+
+class TestDeprecations(unittest.TestCase):
+    def test_machinery_deprecated_attributes(self):
+        from importlib import machinery
+        attributes = (
+            'DEBUG_BYTECODE_SUFFIXES',
+            'OPTIMIZED_BYTECODE_SUFFIXES',
+        )
+        for attr in attributes:
+            with self.subTest(attr=attr):
+                with self.assertWarns(DeprecationWarning):
+                    getattr(machinery, attr)
+
+
 if __name__ == '__main__':
     unittest.main()
diff --git a/Lib/test/test_importlib/test_lazy.py b/Lib/test/test_importlib/test_lazy.py
index cc993f333e3..e48fad8898f 100644
--- a/Lib/test/test_importlib/test_lazy.py
+++ b/Lib/test/test_importlib/test_lazy.py
@@ -2,9 +2,12 @@
 from importlib import abc
 from importlib import util
 import sys
+import time
+import threading
 import types
 import unittest
 
+from test.support import threading_helper
 from test.test_importlib import util as test_util
 
 
@@ -40,6 +43,7 @@ class TestingImporter(abc.MetaPathFinder, abc.Loader):
     module_name = 'lazy_loader_test'
     mutated_name = 'changed'
     loaded = None
+    load_count = 0
     source_code = 'attr = 42; __name__ = {!r}'.format(mutated_name)
 
     def find_spec(self, name, path, target=None):
@@ -48,8 +52,10 @@ def find_spec(self, name, path, target=None):
         return util.spec_from_loader(name, util.LazyLoader(self))
 
     def exec_module(self, module):
+        time.sleep(0.01)  # Simulate a slow load.
         exec(self.source_code, module.__dict__)
         self.loaded = module
+        self.load_count += 1
 
 
 class LazyLoaderTests(unittest.TestCase):
@@ -59,8 +65,9 @@ def test_init(self):
             # Classes that don't define exec_module() trigger TypeError.
             util.LazyLoader(object)
 
-    def new_module(self, source_code=None):
-        loader = TestingImporter()
+    def new_module(self, source_code=None, loader=None):
+        if loader is None:
+            loader = TestingImporter()
         if source_code is not None:
             loader.source_code = source_code
         spec = util.spec_from_loader(TestingImporter.module_name,
@@ -118,12 +125,12 @@ def test_delete_eventual_attr(self):
         # Deleting an attribute should stay deleted.
         module = self.new_module()
         del module.attr
-        self.assertFalse(hasattr(module, 'attr'))
+        self.assertNotHasAttr(module, 'attr')
 
     def test_delete_preexisting_attr(self):
         module = self.new_module()
         del module.__name__
-        self.assertFalse(hasattr(module, '__name__'))
+        self.assertNotHasAttr(module, '__name__')
 
     def test_module_substitution_error(self):
         with test_util.uncache(TestingImporter.module_name):
@@ -140,6 +147,83 @@ def test_module_already_in_sys(self):
             # Force the load; just care that no exception is raised.
             module.__name__
 
+    @threading_helper.requires_working_threading()
+    def test_module_load_race(self):
+        with test_util.uncache(TestingImporter.module_name):
+            loader = TestingImporter()
+            module = self.new_module(loader=loader)
+            self.assertEqual(loader.load_count, 0)
+
+            class RaisingThread(threading.Thread):
+                exc = None
+                def run(self):
+                    try:
+                        super().run()
+                    except Exception as exc:
+                        self.exc = exc
+
+            def access_module():
+                return module.attr
+
+            threads = []
+            for _ in range(2):
+                threads.append(thread := RaisingThread(target=access_module))
+                thread.start()
+
+            # Races could cause errors
+            for thread in threads:
+                thread.join()
+                self.assertIsNone(thread.exc)
+
+            # Or multiple load attempts
+            self.assertEqual(loader.load_count, 1)
+
+    def test_lazy_self_referential_modules(self):
+        # Directory modules with submodules that reference the parent can attempt to access
+        # the parent module during a load. Verify that this common pattern works with lazy loading.
+        # json is a good example in the stdlib.
+        json_modules = [name for name in sys.modules if name.startswith('json')]
+        with test_util.uncache(*json_modules):
+            # Standard lazy loading, unwrapped
+            spec = util.find_spec('json')
+            loader = util.LazyLoader(spec.loader)
+            spec.loader = loader
+            module = util.module_from_spec(spec)
+            sys.modules['json'] = module
+            loader.exec_module(module)
+
+            # Trigger load with attribute lookup, ensure expected behavior
+            test_load = module.loads('{}')
+            self.assertEqual(test_load, {})
+
+    def test_lazy_module_type_override(self):
+        # Verify that lazy loading works with a module that modifies
+        # its __class__ to be a custom type.
+
+        # Example module from PEP 726
+        module = self.new_module(source_code="""\
+import sys
+from types import ModuleType
+
+CONSTANT = 3.14
+
+class ImmutableModule(ModuleType):
+    def __setattr__(self, name, value):
+        raise AttributeError('Read-only attribute!')
+
+    def __delattr__(self, name):
+        raise AttributeError('Read-only attribute!')
+
+sys.modules[__name__].__class__ = ImmutableModule
+""")
+        sys.modules[TestingImporter.module_name] = module
+        self.assertIsInstance(module, util._LazyModule)
+        self.assertEqual(module.CONSTANT, 3.14)
+        with self.assertRaises(AttributeError):
+            module.CONSTANT = 2.71
+        with self.assertRaises(AttributeError):
+            del module.CONSTANT
+
 
 if __name__ == '__main__':
     unittest.main()
diff --git a/Lib/test/test_importlib/test_locks.py b/Lib/test/test_importlib/test_locks.py
index edf0329c753..b1f5f9d6c8b 100644
--- a/Lib/test/test_importlib/test_locks.py
+++ b/Lib/test/test_importlib/test_locks.py
@@ -34,6 +34,7 @@ class ModuleLockAsRLockTests:
     # lock status in repr unsupported
     test_repr = None
     test_locked_repr = None
+    test_repr_count = None
 
     def tearDown(self):
         for splitinit in init.values():
@@ -49,7 +50,6 @@ def tearDown(self):
                          LockType=LOCK_TYPES)
 
 
-@unittest.skipIf(sys.platform == "darwin", "TODO: RUSTPYTHON")
 class DeadlockAvoidanceTests:
 
     def setUp(self):
@@ -99,7 +99,7 @@ def f():
         self.assertEqual(len(results), NTHREADS)
         return results
 
-    @unittest.skip("TODO: RUSTPYTHON, sometimes hangs")
+    @unittest.skip("TODO: RUSTPYTHON; sometimes hangs")
     def test_deadlock(self):
         results = self.run_deadlock_avoidance_test(True)
         # At least one of the threads detected a potential deadlock on its
@@ -109,7 +109,7 @@ def test_deadlock(self):
         self.assertGreaterEqual(nb_deadlocks, 1)
         self.assertEqual(results.count((True, True)), len(results) - nb_deadlocks)
 
-    @unittest.skip("TODO: RUSTPYTHON, flaky test")
+    @unittest.skip("TODO: RUSTPYTHON; flaky test")
     def test_no_deadlock(self):
         results = self.run_deadlock_avoidance_test(False)
         self.assertEqual(results.count((True, False)), 0)
@@ -148,10 +148,14 @@ def test_all_locks(self):
         self.assertEqual(0, len(self.bootstrap._module_locks),
                          self.bootstrap._module_locks)
 
-# TODO: RUSTPYTHON
-# (Frozen_LifetimeTests,
-#  Source_LifetimeTests
-#  ) = test_util.test_both(LifetimeTests, init=init)
+
+(Frozen_LifetimeTests,
+ Source_LifetimeTests
+ ) = test_util.test_both(LifetimeTests, init=init)
+
+# TODO: RUSTPYTHON; dead weakref module locks not cleaned up in frozen bootstrap
+Frozen_LifetimeTests.test_all_locks = unittest.skip("TODO: RUSTPYTHON")(
+    Frozen_LifetimeTests.test_all_locks)
 
 
 def setUpModule():
diff --git a/Lib/test/test_importlib/test_namespace_pkgs.py b/Lib/test/test_importlib/test_namespace_pkgs.py
index 97ce4df0848..6ca0978f9bc 100644
--- a/Lib/test/test_importlib/test_namespace_pkgs.py
+++ b/Lib/test/test_importlib/test_namespace_pkgs.py
@@ -6,7 +6,6 @@
 import sys
 import tempfile
 import unittest
-import warnings
 
 from test.test_importlib import util
 
@@ -81,7 +80,7 @@ def test_cant_import_other(self):
 
     def test_simple_repr(self):
         import foo.one
-        assert repr(foo).startswith("<module 'foo' (namespace) from [")
+        self.assertStartsWith(repr(foo), "<module 'foo' (namespace) from [")
 
 
 class DynamicPathNamespacePackage(NamespacePackageTest):
@@ -287,24 +286,24 @@ def test_project3_succeeds(self):
 
 class ZipWithMissingDirectory(NamespacePackageTest):
     paths = ['missing_directory.zip']
+    # missing_directory.zip contains:
+    #   Length      Date    Time    Name
+    # ---------  ---------- -----   ----
+    #        29  2012-05-03 18:13   foo/one.py
+    #         0  2012-05-03 20:57   bar/
+    #        38  2012-05-03 20:57   bar/two.py
+    # ---------                     -------
+    #        67                     3 files
 
     def test_missing_directory(self):
-        # This will fail because missing_directory.zip contains:
-        #   Length      Date    Time    Name
-        # ---------  ---------- -----   ----
-        #        29  2012-05-03 18:13   foo/one.py
-        #         0  2012-05-03 20:57   bar/
-        #        38  2012-05-03 20:57   bar/two.py
-        # ---------                     -------
-        #        67                     3 files
-
-        # Because there is no 'foo/', the zipimporter currently doesn't
-        #  know that foo is a namespace package
-
         import foo.one
+        self.assertEqual(foo.one.attr, 'portion1 foo one')
+
+    def test_missing_directory2(self):
+        import foo
+        self.assertNotHasAttr(foo, 'one')
 
     def test_present_directory(self):
-        # This succeeds because there is a "bar/" in the zip file
         import bar.two
         self.assertEqual(bar.two.attr, 'missing_directory foo two')
 
diff --git a/Lib/test/test_importlib/test_pkg_import.py b/Lib/test/test_importlib/test_pkg_import.py
index 66f5f8bc253..5ffae6222ba 100644
--- a/Lib/test/test_importlib/test_pkg_import.py
+++ b/Lib/test/test_importlib/test_pkg_import.py
@@ -55,7 +55,7 @@ def test_package_import__semantics(self):
         except SyntaxError: pass
         else: raise RuntimeError('Failed to induce SyntaxError') # self.fail()?
         self.assertNotIn(self.module_name, sys.modules)
-        self.assertFalse(hasattr(sys.modules[self.package_name], 'foo'))
+        self.assertNotHasAttr(sys.modules[self.package_name], 'foo')
 
         # ...make up a variable name that isn't bound in __builtins__
         var = 'a'
diff --git a/Lib/test/test_importlib/test_spec.py b/Lib/test/test_importlib/test_spec.py
index 921b6bbece0..aebeabaf83f 100644
--- a/Lib/test/test_importlib/test_spec.py
+++ b/Lib/test/test_importlib/test_spec.py
@@ -237,7 +237,7 @@ def test_exec(self):
         self.spec.loader = NewLoader()
         module = self.util.module_from_spec(self.spec)
         sys.modules[self.name] = module
-        self.assertFalse(hasattr(module, 'eggs'))
+        self.assertNotHasAttr(module, 'eggs')
         self.bootstrap._exec(self.spec, module)
 
         self.assertEqual(module.eggs, 1)
@@ -348,9 +348,9 @@ def test_reload_init_module_attrs(self):
         self.assertIs(loaded.__loader__, self.spec.loader)
         self.assertEqual(loaded.__package__, self.spec.parent)
         self.assertIs(loaded.__spec__, self.spec)
-        self.assertFalse(hasattr(loaded, '__path__'))
-        self.assertFalse(hasattr(loaded, '__file__'))
-        self.assertFalse(hasattr(loaded, '__cached__'))
+        self.assertNotHasAttr(loaded, '__path__')
+        self.assertNotHasAttr(loaded, '__file__')
+        self.assertNotHasAttr(loaded, '__cached__')
 
 
 (Frozen_ModuleSpecMethodsTests,
@@ -502,7 +502,8 @@ def test_spec_from_loader_is_package_true_with_fileloader(self):
         self.assertEqual(spec.loader, self.fileloader)
         self.assertEqual(spec.origin, self.path)
         self.assertIs(spec.loader_state, None)
-        self.assertEqual(spec.submodule_search_locations, [os.getcwd()])
+        location = cwd if (cwd := os.getcwd()) != '/' else ''
+        self.assertEqual(spec.submodule_search_locations, [location])
         self.assertEqual(spec.cached, self.cached)
         self.assertTrue(spec.has_location)
 
@@ -601,7 +602,8 @@ def test_spec_from_file_location_smsl_empty(self):
         self.assertEqual(spec.loader, self.fileloader)
         self.assertEqual(spec.origin, self.path)
         self.assertIs(spec.loader_state, None)
-        self.assertEqual(spec.submodule_search_locations, [os.getcwd()])
+        location = cwd if (cwd := os.getcwd()) != '/' else ''
+        self.assertEqual(spec.submodule_search_locations, [location])
         self.assertEqual(spec.cached, self.cached)
         self.assertTrue(spec.has_location)
 
@@ -626,7 +628,8 @@ def test_spec_from_file_location_smsl_default(self):
         self.assertEqual(spec.loader, self.pkgloader)
         self.assertEqual(spec.origin, self.path)
         self.assertIs(spec.loader_state, None)
-        self.assertEqual(spec.submodule_search_locations, [os.getcwd()])
+        location = cwd if (cwd := os.getcwd()) != '/' else ''
+        self.assertEqual(spec.submodule_search_locations, [location])
         self.assertEqual(spec.cached, self.cached)
         self.assertTrue(spec.has_location)
 
@@ -686,10 +689,9 @@ def test_spec_from_file_location_relative_path(self):
         self.assertEqual(spec.cached, self.cached)
         self.assertTrue(spec.has_location)
 
-# TODO: RUSTPYTHON
-# (Frozen_FactoryTests,
-#  Source_FactoryTests
-#  ) = test_util.test_both(FactoryTests, util=util, machinery=machinery)
+(Frozen_FactoryTests,
+ Source_FactoryTests
+ ) = test_util.test_both(FactoryTests, util=util, machinery=machinery)
 
 
 if __name__ == '__main__':
diff --git a/Lib/test/test_importlib/test_threaded_import.py b/Lib/test/test_importlib/test_threaded_import.py
index 140be1e6619..c8d156f7f7c 100644
--- a/Lib/test/test_importlib/test_threaded_import.py
+++ b/Lib/test/test_importlib/test_threaded_import.py
@@ -6,7 +6,6 @@
 # randrange, and then Python hangs.
 
 import _imp as imp
-import _multiprocessing  # TODO: RUSTPYTHON
 import os
 import importlib
 import sys
@@ -14,7 +13,7 @@
 import shutil
 import threading
 import unittest
-from unittest import mock
+from test import support
 from test.support import verbose
 from test.support.import_helper import forget, mock_register_at_fork
 from test.support.os_helper import (TESTFN, unlink, rmtree)
@@ -137,12 +136,12 @@ def check_parallel_module_init(self, mock_os):
                 print("OK.")
 
     @unittest.skip("TODO: RUSTPYTHON; flaky")
-    def test_parallel_module_init(self):
+    @support.bigmemtest(size=50, memuse=76*2**20, dry_run=False)
+    def test_parallel_module_init(self, size):
         self.check_parallel_module_init()
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    def test_parallel_meta_path(self):
+    @support.bigmemtest(size=50, memuse=76*2**20, dry_run=False)
+    def test_parallel_meta_path(self, size):
         finder = Finder()
         sys.meta_path.insert(0, finder)
         try:
@@ -152,9 +151,9 @@ def test_parallel_meta_path(self):
         finally:
             sys.meta_path.remove(finder)
 
-    # TODO: RUSTPYTHON; maybe hang?
-    @unittest.expectedFailure
-    def test_parallel_path_hooks(self):
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; maybe hang?
+    @support.bigmemtest(size=50, memuse=76*2**20, dry_run=False)
+    def test_parallel_path_hooks(self, size):
         # Here the Finder instance is only used to check concurrent calls
         # to path_hook().
         finder = Finder()
@@ -248,15 +247,17 @@ def target():
             __import__(TESTFN)
         del sys.modules[TESTFN]
 
-    @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):
+    @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æ\"")
+    @support.bigmemtest(size=1, memuse=1.8*2**30, dry_run=False)
+    def test_concurrent_futures_circular_import(self, size):
         # 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; hang')
-    def test_multiprocessing_pool_circular_import(self):
+    @unittest.skip("TODO: RUSTPYTHON; hang")
+    @support.bigmemtest(size=1, memuse=1.8*2**30, dry_run=False)
+    def test_multiprocessing_pool_circular_import(self, size):
         # Regression test for bpo-41567
         fn = os.path.join(os.path.dirname(__file__),
                           'partial', 'pool_in_threads.py')
@@ -269,7 +270,7 @@ def setUpModule():
     try:
         old_switchinterval = sys.getswitchinterval()
         unittest.addModuleCleanup(sys.setswitchinterval, old_switchinterval)
-        sys.setswitchinterval(1e-5)
+        support.setswitchinterval(1e-5)
     except AttributeError:
         pass
 
diff --git a/Lib/test/test_importlib/test_util.py b/Lib/test/test_importlib/test_util.py
index b9ff9a9f9fc..8c14b96271a 100644
--- a/Lib/test/test_importlib/test_util.py
+++ b/Lib/test/test_importlib/test_util.py
@@ -6,12 +6,13 @@
 importlib_util = util.import_importlib('importlib.util')
 
 import importlib.util
+from importlib import _bootstrap_external
 import os
 import pathlib
-import re
 import string
 import sys
 from test import support
+from test.support import os_helper
 import textwrap
 import types
 import unittest
@@ -27,7 +28,7 @@
 except ImportError:
     _testmultiphase = None
 try:
-    import _xxsubinterpreters as _interpreters
+    import _interpreters
 except ModuleNotFoundError:
     _interpreters = None
 
@@ -319,7 +320,7 @@ def test_length(self):
 
     def test_incorporates_rn(self):
         # The magic number uses \r\n to come out wrong when splitting on lines.
-        self.assertTrue(self.util.MAGIC_NUMBER.endswith(b'\r\n'))
+        self.assertEndsWith(self.util.MAGIC_NUMBER, b'\r\n')
 
 
 (Frozen_MagicNumberTests,
@@ -358,8 +359,6 @@ def test_cache_from_source_no_dot(self):
         self.assertEqual(self.util.cache_from_source(path, optimization=''),
                          expect)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_cache_from_source_debug_override(self):
         # Given the path to a .py file, return the path to its PEP 3147/PEP 488
         # defined .pyc file (i.e. under __pycache__).
@@ -579,7 +578,19 @@ def test_cache_from_source_respects_pycache_prefix_relative(self):
         with util.temporary_pycache_prefix(pycache_prefix):
             self.assertEqual(
                 self.util.cache_from_source(path, optimization=''),
-                expect)
+                os.path.normpath(expect))
+
+    @unittest.skipIf(sys.implementation.cache_tag is None,
+                     'requires sys.implementation.cache_tag to not be None')
+    def test_cache_from_source_in_root_with_pycache_prefix(self):
+        # Regression test for gh-82916
+        pycache_prefix = os.path.join(os.path.sep, 'tmp', 'bytecode')
+        path = 'qux.py'
+        expect = os.path.join(os.path.sep, 'tmp', 'bytecode',
+                              f'qux.{self.tag}.pyc')
+        with util.temporary_pycache_prefix(pycache_prefix):
+            with os_helper.change_cwd('/'):
+                self.assertEqual(self.util.cache_from_source(path), expect)
 
     @unittest.skipIf(sys.implementation.cache_tag is None,
                      'requires sys.implementation.cache_tag to not be None')
@@ -636,7 +647,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 = 2996
+        EXPECTED_MAGIC_NUMBER = 3627
         actual = int.from_bytes(importlib.util.MAGIC_NUMBER[:2], 'little')
 
         msg = (
@@ -657,27 +668,36 @@ def test_magic_number(self):
 @unittest.skipIf(_interpreters is None, 'subinterpreters required')
 class IncompatibleExtensionModuleRestrictionsTests(unittest.TestCase):
 
-    ERROR = re.compile("^<class 'ImportError'>: module (.*) does not support loading in subinterpreters")
-
     def run_with_own_gil(self, script):
-        interpid = _interpreters.create(isolated=True)
-        try:
-            _interpreters.run_string(interpid, script)
-        except _interpreters.RunFailedError as exc:
-            if m := self.ERROR.match(str(exc)):
-                modname, = m.groups()
-                raise ImportError(modname)
+        interpid = _interpreters.create('isolated')
+        def ensure_destroyed():
+            try:
+                _interpreters.destroy(interpid)
+            except _interpreters.InterpreterNotFoundError:
+                pass
+        self.addCleanup(ensure_destroyed)
+        excsnap = _interpreters.exec(interpid, script)
+        if excsnap is not None:
+            if excsnap.type.__name__ == 'ImportError':
+                raise ImportError(excsnap.msg)
 
     def run_with_shared_gil(self, script):
-        interpid = _interpreters.create(isolated=False)
-        try:
-            _interpreters.run_string(interpid, script)
-        except _interpreters.RunFailedError as exc:
-            if m := self.ERROR.match(str(exc)):
-                modname, = m.groups()
-                raise ImportError(modname)
+        interpid = _interpreters.create('legacy')
+        def ensure_destroyed():
+            try:
+                _interpreters.destroy(interpid)
+            except _interpreters.InterpreterNotFoundError:
+                pass
+        self.addCleanup(ensure_destroyed)
+        excsnap = _interpreters.exec(interpid, script)
+        if excsnap is not None:
+            if excsnap.type.__name__ == 'ImportError':
+                raise ImportError(excsnap.msg)
 
     @unittest.skipIf(_testsinglephase is None, "test requires _testsinglephase module")
+    # gh-117649: single-phase init modules are not currently supported in
+    # subinterpreters in the free-threaded build
+    @support.expected_failure_if_gil_disabled()
     def test_single_phase_init_module(self):
         script = textwrap.dedent('''
             from importlib.util import _incompatible_extension_module_restrictions
@@ -702,14 +722,22 @@ def test_single_phase_init_module(self):
                 self.run_with_own_gil(script)
 
     @unittest.skipIf(_testmultiphase is None, "test requires _testmultiphase module")
+    @support.requires_gil_enabled("gh-117649: not supported in free-threaded build")
     def test_incomplete_multi_phase_init_module(self):
+        # Apple extensions must be distributed as frameworks. This requires
+        # a specialist loader.
+        if support.is_apple_mobile:
+            loader = "AppleFrameworkLoader"
+        else:
+            loader = "ExtensionFileLoader"
+
         prescript = textwrap.dedent(f'''
             from importlib.util import spec_from_loader, module_from_spec
-            from importlib.machinery import ExtensionFileLoader
+            from importlib.machinery import {loader}
 
             name = '_test_shared_gil_only'
             filename = {_testmultiphase.__file__!r}
-            loader = ExtensionFileLoader(name, filename)
+            loader = {loader}(name, filename)
             spec = spec_from_loader(name, loader)
 
             ''')
@@ -760,5 +788,74 @@ def test_complete_multi_phase_init_module(self):
             self.run_with_own_gil(script)
 
 
+class PatchAtomicWrites:
+    def __init__(self, truncate_at_length, never_complete=False):
+        self.truncate_at_length = truncate_at_length
+        self.never_complete = never_complete
+        self.seen_write = False
+        self._children = []
+
+    def __enter__(self):
+        import _pyio
+
+        oldwrite = os.write
+
+        # Emulate an os.write that only writes partial data.
+        def write(fd, data):
+            if self.seen_write and self.never_complete:
+                return None
+            self.seen_write = True
+            return oldwrite(fd, data[:self.truncate_at_length])
+
+        # Need to patch _io to be _pyio, so that io.FileIO is affected by the
+        # os.write patch.
+        self.children = [
+            support.swap_attr(_bootstrap_external, '_io', _pyio),
+            support.swap_attr(os, 'write', write)
+        ]
+        for child in self.children:
+            child.__enter__()
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        for child in self.children:
+            child.__exit__(exc_type, exc_val, exc_tb)
+
+
+class MiscTests(unittest.TestCase):
+
+    def test_atomic_write_retries_incomplete_writes(self):
+        truncate_at_length = 100
+        length = truncate_at_length * 2
+
+        with PatchAtomicWrites(truncate_at_length=truncate_at_length) as cm:
+            # Make sure we write something longer than the point where we
+            # truncate.
+            content = b'x' * length
+            _bootstrap_external._write_atomic(os_helper.TESTFN, content)
+        self.assertTrue(cm.seen_write)
+
+        self.assertEqual(os.stat(support.os_helper.TESTFN).st_size, length)
+        os.unlink(support.os_helper.TESTFN)
+
+    def test_atomic_write_errors_if_unable_to_complete(self):
+        truncate_at_length = 100
+
+        with (
+            PatchAtomicWrites(
+                truncate_at_length=truncate_at_length, never_complete=True,
+            ) as cm,
+            self.assertRaises(OSError)
+        ):
+            # Make sure we write something longer than the point where we
+            # truncate.
+            content = b'x' * (truncate_at_length * 2)
+            _bootstrap_external._write_atomic(os_helper.TESTFN, content)
+        self.assertTrue(cm.seen_write)
+
+        with self.assertRaises(OSError):
+            os.stat(support.os_helper.TESTFN) # Check that the file did not get written.
+
+
 if __name__ == '__main__':
     unittest.main()
diff --git a/Lib/test/test_importlib/test_windows.py b/Lib/test/test_importlib/test_windows.py
index f8a9ead9ac8..0ae911bc43d 100644
--- a/Lib/test/test_importlib/test_windows.py
+++ b/Lib/test/test_importlib/test_windows.py
@@ -5,7 +5,7 @@
 import re
 import sys
 import unittest
-import warnings
+from test import support
 from test.support import import_helper
 from contextlib import contextmanager
 from test.test_importlib.util import temp_module
@@ -91,31 +91,61 @@ class WindowsRegistryFinderTests:
     test_module = "spamham{}".format(os.getpid())
 
     def test_find_spec_missing(self):
-        spec = self.machinery.WindowsRegistryFinder.find_spec('spam')
+        with self.assertWarnsRegex(
+            DeprecationWarning,
+            r"importlib\.machinery\.WindowsRegistryFinder is deprecated; "
+            r"use site configuration instead\. Future versions of Python may "
+            r"not enable this finder by default\."
+        ):
+            spec = self.machinery.WindowsRegistryFinder.find_spec('spam')
         self.assertIsNone(spec)
 
     def test_module_found(self):
         with setup_module(self.machinery, self.test_module):
-            spec = self.machinery.WindowsRegistryFinder.find_spec(self.test_module)
+            with self.assertWarnsRegex(
+                DeprecationWarning,
+                r"importlib\.machinery\.WindowsRegistryFinder is deprecated; "
+                r"use site configuration instead\. Future versions of Python may "
+                r"not enable this finder by default\."
+            ):
+                spec = self.machinery.WindowsRegistryFinder.find_spec(self.test_module)
             self.assertIsNotNone(spec)
 
     def test_module_not_found(self):
         with setup_module(self.machinery, self.test_module, path="."):
-            spec = self.machinery.WindowsRegistryFinder.find_spec(self.test_module)
+            with self.assertWarnsRegex(
+                DeprecationWarning,
+                r"importlib\.machinery\.WindowsRegistryFinder is deprecated; "
+                r"use site configuration instead\. Future versions of Python may "
+                r"not enable this finder by default\."
+            ):
+                spec = self.machinery.WindowsRegistryFinder.find_spec(self.test_module)
             self.assertIsNone(spec)
 
+    def test_raises_deprecation_warning(self):
+        # WindowsRegistryFinder is not meant to be instantiated, so the
+        # deprecation warning is raised in the 'find_spec' method instead.
+        with self.assertWarnsRegex(
+            DeprecationWarning,
+            r"importlib\.machinery\.WindowsRegistryFinder is deprecated; "
+            r"use site configuration instead\. Future versions of Python may "
+            r"not enable this finder by default\."
+        ):
+            self.machinery.WindowsRegistryFinder.find_spec('spam')
+
 (Frozen_WindowsRegistryFinderTests,
  Source_WindowsRegistryFinderTests
  ) = test_util.test_both(WindowsRegistryFinderTests, machinery=machinery)
 
 @unittest.skipUnless(sys.platform.startswith('win'), 'requires Windows')
 class WindowsExtensionSuffixTests:
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; no C extension (.pyd) support
     def test_tagged_suffix(self):
         suffixes = self.machinery.EXTENSION_SUFFIXES
-        expected_tag = ".cp{0.major}{0.minor}-{1}.pyd".format(sys.version_info,
-            re.sub('[^a-zA-Z0-9]', '_', get_platform()))
+        abi_flags = "t" if support.Py_GIL_DISABLED else ""
+        ver = sys.version_info
+        platform = re.sub('[^a-zA-Z0-9]', '_', get_platform())
+        expected_tag = f".cp{ver.major}{ver.minor}{abi_flags}-{platform}.pyd"
         try:
             untagged_i = suffixes.index(".pyd")
         except ValueError:
diff --git a/Lib/test/test_importlib/util.py b/Lib/test/test_importlib/util.py
index c25be096e52..85e7ffcb608 100644
--- a/Lib/test/test_importlib/util.py
+++ b/Lib/test/test_importlib/util.py
@@ -6,13 +6,20 @@
 import marshal
 import os
 import os.path
+from test import support
 from test.support import import_helper
+from test.support import is_apple_mobile
 from test.support import os_helper
 import unittest
 import sys
 import tempfile
 import types
 
+try:
+    _testsinglephase = import_helper.import_module("_testsinglephase")
+except unittest.SkipTest:
+    _testsinglephase = None  # TODO: RUSTPYTHON
+
 
 BUILTINS = types.SimpleNamespace()
 BUILTINS.good_name = None
@@ -22,25 +29,39 @@
 if 'importlib' not in sys.builtin_module_names:
     BUILTINS.bad_name = 'importlib'
 
-EXTENSIONS = types.SimpleNamespace()
-EXTENSIONS.path = None
-EXTENSIONS.ext = None
-EXTENSIONS.filename = None
-EXTENSIONS.file_path = None
-EXTENSIONS.name = '_testsinglephase'
-
-def _extension_details():
-    global EXTENSIONS
-    for path in sys.path:
-        for ext in machinery.EXTENSION_SUFFIXES:
-            filename = EXTENSIONS.name + ext
-            file_path = os.path.join(path, filename)
-            if os.path.exists(file_path):
-                EXTENSIONS.path = path
-                EXTENSIONS.ext = ext
-                EXTENSIONS.filename = filename
-                EXTENSIONS.file_path = file_path
-                return
+if support.is_wasi:
+    # dlopen() is a shim for WASI as of WASI SDK which fails by default.
+    # We don't provide an implementation, so tests will fail.
+    # But we also don't want to turn off dynamic loading for those that provide
+    # a working implementation.
+    def _extension_details():
+        global EXTENSIONS
+        EXTENSIONS = None
+else:
+    EXTENSIONS = types.SimpleNamespace()
+    EXTENSIONS.path = None
+    EXTENSIONS.ext = None
+    EXTENSIONS.filename = None
+    EXTENSIONS.file_path = None
+    EXTENSIONS.name = '_testsinglephase'
+
+    def _extension_details():
+        global EXTENSIONS
+        for path in sys.path:
+            for ext in machinery.EXTENSION_SUFFIXES:
+                # Apple mobile platforms mechanically load .so files,
+                # but the findable files are labelled .fwork
+                if is_apple_mobile:
+                    ext = ext.replace(".so", ".fwork")
+
+                filename = EXTENSIONS.name + ext
+                file_path = os.path.join(path, filename)
+                if os.path.exists(file_path):
+                    EXTENSIONS.path = path
+                    EXTENSIONS.ext = ext
+                    EXTENSIONS.filename = filename
+                    EXTENSIONS.file_path = file_path
+                    return
 
 _extension_details()
 
diff --git a/Lib/test/test_inspect/test_inspect.py b/Lib/test/test_inspect/test_inspect.py
index 595966e3405..431c722482b 100644
--- a/Lib/test/test_inspect/test_inspect.py
+++ b/Lib/test/test_inspect/test_inspect.py
@@ -13,8 +13,7 @@
 import os
 import dis
 from os.path import normcase
-# XXX: RUSTPYTHON
-# import _pickle
+# import _pickle # TODO: RUSTPYTHON
 import pickle
 import shutil
 import stat
@@ -123,7 +122,7 @@ def istest(self, predicate, exp):
             else:
                 self.assertFalse(other(obj), 'not %s(%s)' % (other.__name__, exp))
 
-    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; First has 0, Second has 1:  'iskeyword'
     def test__all__(self):
         support.check__all__(self, inspect, not_exported=("modulesbyfile",), extra=("get_annotations",))
 
@@ -176,7 +175,7 @@ def __get__(self, instance, owner):
 
 class TestPredicates(IsTestBase):
 
-    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AttributeError: type object 'defaultdict' has no attribute 'default_factory'
     def test_excluding_predicates(self):
         global tb
         self.istest(inspect.isbuiltin, 'sys.exit')
@@ -238,7 +237,7 @@ class FakePackage:
 
         self.assertFalse(inspect.ispackage(FakePackage()))
 
-    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AssertionError: False is not true
     def test_iscoroutine(self):
         async_gen_coro = async_generator_function_example(1)
         gen_coro = gen_coroutine_function_example(1)
@@ -481,7 +480,7 @@ class C(object):
         self.assertIn('a', members)
         self.assertNotIn('b', members)
 
-    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AssertionError: False is not true
     def test_isabstract(self):
         from abc import ABCMeta, abstractmethod
 
@@ -504,7 +503,7 @@ def foo(self):
         self.assertFalse(inspect.isabstract(int))
         self.assertFalse(inspect.isabstract(5))
 
-    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; + [True, False]
     def test_isabstract_during_init_subclass(self):
         from abc import ABCMeta, abstractmethod
         isabstract_checks = []
@@ -540,7 +539,6 @@ def test_abuse_done(self):
         self.istest(inspect.istraceback, 'git.ex.__traceback__')
         self.istest(inspect.isframe, 'mod.fr')
 
-    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_stack(self):
         self.assertTrue(len(mod.st) >= 5)
         frame1, frame2, frame3, frame4, *_ = mod.st
@@ -569,7 +567,6 @@ def test_stack(self):
         self.assertIn('inspect.stack()', record.code_context[0])
         self.assertEqual(record.index, 0)
 
-    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_trace(self):
         self.assertEqual(len(git.tr), 3)
         frame1, frame2, frame3, = git.tr
@@ -592,7 +589,7 @@ def test_frame(self):
         self.assertEqual(inspect.formatargvalues(args, varargs, varkw, locals),
                          '(x=11, y=14)')
 
-    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AttributeError: 'NoneType' object has no attribute 'f_code'
     def test_previous_frame(self):
         args, varargs, varkw, locals = inspect.getargvalues(mod.fr.f_back)
         self.assertEqual(args, ['a', 'b', 'c', 'd', 'e', 'f'])
@@ -672,7 +669,6 @@ 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")
     def test_getdoc(self):
@@ -892,7 +888,7 @@ def test_getsource_on_generated_class(self):
         self.assertRaises(OSError, inspect.getsourcelines, A)
         self.assertIsNone(inspect.getcomments(A))
 
-    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AssertionError: OSError not raised by getsource
     def test_getsource_on_class_without_firstlineno(self):
         __firstlineno__ = 1
         class C:
@@ -914,7 +910,6 @@ def test_getsource_stdlib_tomllib(self):
         self.assertRaises(OSError, inspect.getsource, tomllib.TOMLDecodeError)
         self.assertRaises(OSError, inspect.getsourcelines, tomllib.TOMLDecodeError)
 
-    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_getsource_stdlib_abc(self):
         # Pure Python implementation
         abc = import_helper.import_fresh_module('abc', blocked=['_abc'])
@@ -966,7 +961,6 @@ def test_range_traceback_toplevel_frame(self):
 class TestDecorators(GetSourceBase):
     fodderModule = mod2
 
-    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_wrapped_decorator(self):
         self.assertSourceEqual(mod2.wrapped, 14, 17)
 
@@ -1167,7 +1161,7 @@ def test_nested_class_definition(self):
         self.assertSourceEqual(mod2.cls183, 183, 188)
         self.assertSourceEqual(mod2.cls183.cls185, 185, 188)
 
-    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; pass
     def test_class_decorator(self):
         self.assertSourceEqual(mod2.cls196, 194, 201)
         self.assertSourceEqual(mod2.cls196.cls200, 198, 201)
@@ -1264,7 +1258,6 @@ def test_class(self):
 class TestComplexDecorator(GetSourceBase):
     fodderModule = mod2
 
-    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_parens_in_decorator(self):
         self.assertSourceEqual(self.fodderModule.complex_decorated, 273, 275)
 
@@ -1541,7 +1534,7 @@ def m1(self): pass
         self.assertIn(('md', 'method', A), attrs, 'missing method descriptor')
         self.assertIn(('dd', 'data', A), attrs, 'missing data descriptor')
 
-    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AssertionError: ('to_bytes', 'method', <class 'int'>) not found in [('__abs__', 'method', <class 'bool'>), ('__add__', 'method', <class 'bool'>), ('__and__', 'method', <class 'bool'>), ('__bool__', 'method', <class 'bool'>), ('__ceil__', 'class method', <class 'int'>), ('__class__', 'data', <class 'object'>), ('__delattr__', 'class method', <class 'object'>), ('__dir__', 'class method', <class 'object'>), ('__divmod__', 'method', <class 'bool'>), ('__doc__', 'data', <class 'bool'>), ('__eq__', 'class method', <class 'int'>), ('__float__', 'method', <class 'bool'>), ('__floor__', 'class method', <class 'int'>), ('__floordiv__', 'method', <class 'bool'>), ('__format__', 'class method', <class 'bool'>), ('__ge__', 'class method', <class 'int'>), ('__getattribute__', 'class method', <class 'object'>), ('__getnewargs__', 'class method', <class 'int'>), ('__getstate__', 'class method', <class 'object'>), ('__gt__', 'class method', <class 'int'>), ('__hash__', 'method', <class 'int'>), ('__index__', 'method', <class 'bool'>), ('__init__', 'method', <class 'object'>), ('__init_subclass__', 'class method', <class 'object'>), ('__int__', 'method', <class 'bool'>), ('__invert__', 'method', <class 'bool'>), ('__le__', 'class method', <class 'int'>), ('__lshift__', 'method', <class 'bool'>), ('__lt__', 'class method', <class 'int'>), ('__mod__', 'method', <class 'bool'>), ('__mul__', 'method', <class 'bool'>), ('__ne__', 'class method', <class 'int'>), ('__neg__', 'method', <class 'bool'>), ('__new__', 'static method', <class 'bool'>), ('__or__', 'method', <class 'bool'>), ('__pos__', 'method', <class 'bool'>), ('__pow__', 'method', <class 'bool'>), ('__radd__', 'method', <class 'bool'>), ('__rand__', 'method', <class 'bool'>), ('__rdivmod__', 'method', <class 'bool'>), ('__reduce__', 'class method', <class 'object'>), ('__reduce_ex__', 'class method', <class 'object'>), ('__repr__', 'method', <class 'bool'>), ('__rfloordiv__', 'method', <class 'bool'>), ('__rlshift__', 'method', <class 'bool'>), ('__rmod__', 'method', <class 'bool'>), ('__rmul__', 'method', <class 'bool'>), ('__ror__', 'method', <class 'bool'>), ('__round__', 'class method', <class 'int'>), ('__rpow__', 'method', <class 'bool'>), ('__rrshift__', 'method', <class 'bool'>), ('__rshift__', 'method', <class 'bool'>), ('__rsub__', 'method', <class 'bool'>), ('__rtruediv__', 'method', <class 'bool'>), ('__rxor__', 'method', <class 'bool'>), ('__setattr__', 'class method', <class 'object'>), ('__sizeof__', 'class method', <class 'int'>), ('__str__', 'method', <class 'object'>), ('__sub__', 'method', <class 'bool'>), ('__subclasshook__', 'class method', <class 'object'>), ('__truediv__', 'method', <class 'bool'>), ('__trunc__', 'class method', <class 'int'>), ('__xor__', 'method', <class 'bool'>), ('as_integer_ratio', 'class method', <class 'int'>), ('bit_count', 'class method', <class 'int'>), ('bit_length', 'class method', <class 'int'>), ('conjugate', 'class method', <class 'int'>), ('denominator', 'data', <class 'int'>), ('from_bytes', 'class method', <class 'int'>), ('imag', 'data', <class 'int'>), ('is_integer', 'class method', <class 'int'>), ('numerator', 'data', <class 'int'>), ('real', 'data', <class 'int'>), ('to_bytes', 'class method', <class 'int'>)] : missing plain method
     def test_classify_builtin_types(self):
         # Simple sanity check that all built-in types can have their
         # attributes classified.
@@ -2024,7 +2017,6 @@ def function():
 _global_ref = object()
 class TestGetClosureVars(unittest.TestCase):
 
-    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_name_resolution(self):
         # Basic test of the 4 different resolution mechanisms
         def f(nonlocal_ref):
@@ -2040,7 +2032,6 @@ def g(local_ref):
                                        builtin_vars, unbound_names)
         self.assertEqual(inspect.getclosurevars(f(_arg)), expected)
 
-    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_generator_closure(self):
         def f(nonlocal_ref):
             def g(local_ref):
@@ -2056,7 +2047,6 @@ def g(local_ref):
                                        builtin_vars, unbound_names)
         self.assertEqual(inspect.getclosurevars(f(_arg)), expected)
 
-    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_method_closure(self):
         class C:
             def f(self, nonlocal_ref):
@@ -2072,7 +2062,6 @@ def g(local_ref):
                                        builtin_vars, unbound_names)
         self.assertEqual(inspect.getclosurevars(C().f(_arg)), expected)
 
-    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_attribute_same_name_as_global_var(self):
         class C:
             _global_ref = object()
@@ -2142,21 +2131,18 @@ def _private_globals(self):
         exec(code, ns)
         return ns["f"], ns
 
-    @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)
 
-    @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)
 
-    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_builtins_as_module(self):
         f, ns = self._private_globals()
         ns["__builtins__"] = os
@@ -2251,7 +2237,6 @@ 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)')
 
-    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_keyword_only(self):
         f = self.makeCallable('a=3, *, c, d=2')
         self.assertEqualCallArgs(f, 'c=3')
@@ -2292,7 +2277,7 @@ def test_multiple_features(self):
                                  '(4,[5,6])]), q=0, **collections.UserDict('
                                  'y=9, z=10)')
 
-    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; + <lambda>() got an unexpected keyword argument 'x'
     def test_errors(self):
         f0 = self.makeCallable('')
         f1 = self.makeCallable('a, b')
@@ -2719,7 +2704,6 @@ def __getattribute__(self, attr):
 
         self.assertFalse(test.called)
 
-    @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
@@ -2747,28 +2731,23 @@ def number_generator():
     def _generatorstate(self):
         return inspect.getgeneratorstate(self.generator)
 
-    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_created(self):
         self.assertEqual(self._generatorstate(), inspect.GEN_CREATED)
 
-    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_suspended(self):
         next(self.generator)
         self.assertEqual(self._generatorstate(), inspect.GEN_SUSPENDED)
 
-    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_closed_after_exhaustion(self):
         for i in self.generator:
             pass
         self.assertEqual(self._generatorstate(), inspect.GEN_CLOSED)
 
-    @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)
 
-    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_closed_after_close(self):
         self.generator.close()
         self.assertEqual(self._generatorstate(), inspect.GEN_CLOSED)
@@ -2789,6 +2768,30 @@ def running_check_generator():
         # Running after the first yield
         next(self.generator)
 
+    def test_types_coroutine_wrapper_state(self):
+        def gen():
+            yield 1
+            yield 2
+
+        @types.coroutine
+        def wrapped_generator_coro():
+            # return a generator iterator so types.coroutine
+            # wraps it into types._GeneratorWrapper.
+            return gen()
+
+        g = wrapped_generator_coro()
+        self.addCleanup(g.close)
+        self.assertIs(type(g), types._GeneratorWrapper)
+
+        # _GeneratorWrapper must provide gi_suspended/cr_suspended
+        # so inspect.get*state() doesn't raise AttributeError.
+        self.assertEqual(inspect.getgeneratorstate(g), inspect.GEN_CREATED)
+        self.assertEqual(inspect.getcoroutinestate(g), inspect.CORO_CREATED)
+
+        next(g)
+        self.assertEqual(inspect.getgeneratorstate(g), inspect.GEN_SUSPENDED)
+        self.assertEqual(inspect.getcoroutinestate(g), inspect.CORO_SUSPENDED)
+
     def test_easy_debugging(self):
         # repr() and str() of a generator state should contain the state name
         names = 'GEN_CREATED GEN_RUNNING GEN_SUSPENDED GEN_CLOSED'.split()
@@ -2861,16 +2864,16 @@ def tearDown(self):
     def _coroutinestate(self):
         return inspect.getcoroutinestate(self.coroutine)
 
-    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AttributeError: 'coroutine' object has no attribute 'cr_suspended'
     def test_created(self):
         self.assertEqual(self._coroutinestate(), inspect.CORO_CREATED)
 
-    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AttributeError: 'coroutine' object has no attribute 'cr_suspended'
     def test_suspended(self):
         self.coroutine.send(None)
         self.assertEqual(self._coroutinestate(), inspect.CORO_SUSPENDED)
 
-    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AttributeError: 'coroutine' object has no attribute 'cr_suspended'
     def test_closed_after_exhaustion(self):
         while True:
             try:
@@ -2880,13 +2883,13 @@ def test_closed_after_exhaustion(self):
 
         self.assertEqual(self._coroutinestate(), inspect.CORO_CLOSED)
 
-    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AttributeError: 'coroutine' object has no attribute 'cr_suspended'
     def test_closed_after_immediate_exception(self):
         with self.assertRaises(RuntimeError):
             self.coroutine.throw(RuntimeError)
         self.assertEqual(self._coroutinestate(), inspect.CORO_CLOSED)
 
-    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AttributeError: 'coroutine' object has no attribute 'cr_suspended'
     def test_closed_after_close(self):
         self.coroutine.close()
         self.assertEqual(self._coroutinestate(), inspect.CORO_CLOSED)
@@ -2936,17 +2939,17 @@ def tearDownClass(cls):
     def _asyncgenstate(self):
         return inspect.getasyncgenstate(self.asyncgen)
 
-    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AttributeError: 'async_generator' object has no attribute 'ag_suspended'
     def test_created(self):
         self.assertEqual(self._asyncgenstate(), inspect.AGEN_CREATED)
 
-    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AttributeError: 'async_generator' object has no attribute 'ag_suspended'
     async def test_suspended(self):
         value = await anext(self.asyncgen)
         self.assertEqual(self._asyncgenstate(), inspect.AGEN_SUSPENDED)
         self.assertEqual(value, 0)
 
-    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AttributeError: 'async_generator' object has no attribute 'ag_suspended'
     async def test_closed_after_exhaustion(self):
         countdown = 7
         with self.assertRaises(StopAsyncIteration):
@@ -2955,13 +2958,13 @@ async def test_closed_after_exhaustion(self):
         self.assertEqual(countdown, 1)
         self.assertEqual(self._asyncgenstate(), inspect.AGEN_CLOSED)
 
-    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AttributeError: 'async_generator' object has no attribute 'ag_suspended'
     async def test_closed_after_immediate_exception(self):
         with self.assertRaises(RuntimeError):
             await self.asyncgen.athrow(RuntimeError)
         self.assertEqual(self._asyncgenstate(), inspect.AGEN_CLOSED)
 
-    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AttributeError: 'async_generator' object has no attribute 'ag_suspended'
     async def test_running(self):
         async def running_check_asyncgen():
             for number in range(5):
@@ -3527,7 +3530,7 @@ def m1d(*args, **kwargs):
                            ('arg2', 1, ..., "positional_or_keyword")),
                           int))
 
-    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; ValueError: no signature found for builtin type <class 'classmethod'>
     def test_signature_on_classmethod(self):
         if not support.MISSING_C_DOCSTRINGS:
             self.assertEqual(self.signature(classmethod),
@@ -3551,7 +3554,7 @@ def foo(cls, arg1, *, arg2=1):
                            ('arg2', 1, ..., "keyword_only")),
                           ...))
 
-    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; ValueError: no signature found for builtin type <class 'staticmethod'>
     def test_signature_on_staticmethod(self):
         if not support.MISSING_C_DOCSTRINGS:
             self.assertEqual(self.signature(staticmethod),
@@ -5146,7 +5149,6 @@ def test():
         sig = test.__signature__ = inspect.Signature(parameters=(spam_param,))
         self.assertEqual(sig, inspect.signature(test))
 
-    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_signature_on_mangled_parameters(self):
         class Spam:
             def foo(self, __p1:1=2, *, __p2:2=3):
@@ -5989,7 +5991,7 @@ def _strip_non_python_syntax(self, input,
         self.assertEqual(computed_clean_signature, clean_signature)
         self.assertEqual(computed_self_parameter, self_parameter)
 
-    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; + (module, /, path, mode, *, dir_fd=None, effective_ids=False, follow_symlinks=True)
     def test_signature_strip_non_python_syntax(self):
         self._strip_non_python_syntax(
             "($module, /, path, mode, *, dir_fd=None, " +
@@ -6293,7 +6295,7 @@ def test_tokenize_module_has_signatures(self):
         import tokenize
         self._test_module_has_signatures(tokenize)
 
-    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; ModuleNotFoundError: No module named 'tracemalloc'
     def test_tracemalloc_module_has_signatures(self):
         import tracemalloc
         self._test_module_has_signatures(tracemalloc)
@@ -6321,7 +6323,7 @@ def test_weakref_module_has_signatures(self):
         no_signature = {'ReferenceType', 'ref'}
         self._test_module_has_signatures(weakref, no_signature)
 
-    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; ValueError: <function TestSignatureDefinitions.test_python_function_override_signature.<locals>.func at 0xa4c07a580> builtin has invalid signature
     def test_python_function_override_signature(self):
         def func(*args, **kwargs):
             pass
@@ -6352,7 +6354,7 @@ def func(*args, **kwargs):
         with self.assertRaises(ValueError):
             inspect.signature(func)
 
-    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AssertionError: None != '(raw, buffer_size=DEFAULT_BUFFER_SIZE)'
     @support.requires_docstrings
     def test_base_class_have_text_signature(self):
         # see issue 43118
@@ -6571,7 +6573,7 @@ def run_on_interactive_mode(self, source):
             raise ValueError("Process didn't exit properly.")
         return output
 
-    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AssertionError: 'The source is: <<<def f():\n    print(0)\n    return 1 + 2\n>>>' not found in 'Traceback (most recent call last):\n  File "<stdin>", line 1, in <module>\n  File "/Users/al03219714/Projects/RustPython4/crates/pylib/Lib/inspect.py", line 1161, in getsource\n    lines, lnum = getsourcelines(object)\n                  ~~~~~~~~~~~~~~^^^^^^^^\n  File "/Users/al03219714/Projects/RustPython4/crates/pylib/Lib/inspect.py", line 1143, in getsourcelines\n    lines, lnum = findsource(object)\n                  ~~~~~~~~~~^^^^^^^^\n  File "/Users/al03219714/Projects/RustPython4/crates/pylib/Lib/inspect.py", line 978, in findsource\n    raise OSError(\'could not get source code\')\nOSError: could not get source code\n'
     @unittest.skipIf(not has_subprocess_support, "test requires subprocess")
     def test_getsource(self):
         output = self.run_on_interactive_mode(textwrap.dedent("""\
diff --git a/Lib/test/test_int.py b/Lib/test/test_int.py
index 7f62ac067c4..f7b26e37e3a 100644
--- a/Lib/test/test_int.py
+++ b/Lib/test/test_int.py
@@ -1,5 +1,4 @@
 import sys
-import time
 
 import unittest
 # TODO: RUSTPYTHON
@@ -18,6 +17,11 @@
 except ImportError:
     _pylong = None
 
+try:
+    import _decimal
+except ImportError:
+    _decimal = None
+
 L = [
         ('0', 0),
         ('1', 1),
@@ -242,8 +246,7 @@ def test_invalid_signs(self):
         with self.assertRaises(ValueError):
             int(' + 1 ')
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_unicode(self):
         self.assertEqual(int("१२३४५६७८९०1234567890"), 12345678901234567890)
         self.assertEqual(int('١٢٣٤٥٦٧٨٩٠'), 1234567890)
@@ -376,6 +379,7 @@ def test_int_memoryview(self):
     def test_string_float(self):
         self.assertRaises(ValueError, int, '1.2')
 
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AssertionError: TypeError not raised
     def test_intconversion(self):
         # Test __int__()
         class ClassicMissingMethods:
@@ -405,68 +409,8 @@ def __trunc__(self):
             class JustTrunc(base):
                 def __trunc__(self):
                     return 42
-            with self.assertWarns(DeprecationWarning):
-                self.assertEqual(int(JustTrunc()), 42)
-
-            class ExceptionalTrunc(base):
-                def __trunc__(self):
-                    1 / 0
-            with self.assertRaises(ZeroDivisionError), \
-                 self.assertWarns(DeprecationWarning):
-                int(ExceptionalTrunc())
-
-            for trunc_result_base in (object, Classic):
-                class Index(trunc_result_base):
-                    def __index__(self):
-                        return 42
-
-                class TruncReturnsNonInt(base):
-                    def __trunc__(self):
-                        return Index()
-                with self.assertWarns(DeprecationWarning):
-                    self.assertEqual(int(TruncReturnsNonInt()), 42)
-
-                class Intable(trunc_result_base):
-                    def __int__(self):
-                        return 42
-
-                class TruncReturnsNonIndex(base):
-                    def __trunc__(self):
-                        return Intable()
-                with self.assertWarns(DeprecationWarning):
-                    self.assertEqual(int(TruncReturnsNonInt()), 42)
-
-                class NonIntegral(trunc_result_base):
-                    def __trunc__(self):
-                        # Check that we avoid infinite recursion.
-                        return NonIntegral()
-
-                class TruncReturnsNonIntegral(base):
-                    def __trunc__(self):
-                        return NonIntegral()
-                try:
-                    with self.assertWarns(DeprecationWarning):
-                        int(TruncReturnsNonIntegral())
-                except TypeError as e:
-                    self.assertEqual(str(e),
-                                      "__trunc__ returned non-Integral"
-                                      " (type NonIntegral)")
-                else:
-                    self.fail("Failed to raise TypeError with %s" %
-                              ((base, trunc_result_base),))
-
-                # Regression test for bugs.python.org/issue16060.
-                class BadInt(trunc_result_base):
-                    def __int__(self):
-                        return 42.0
-
-                class TruncReturnsBadInt(base):
-                    def __trunc__(self):
-                        return BadInt()
-
-                with self.assertRaises(TypeError), \
-                     self.assertWarns(DeprecationWarning):
-                    int(TruncReturnsBadInt())
+            with self.assertRaises(TypeError):
+                int(JustTrunc())
 
     def test_int_subclass_with_index(self):
         class MyIndex(int):
@@ -517,18 +461,6 @@ class BadInt2(int):
             def __int__(self):
                 return True
 
-        class TruncReturnsBadIndex:
-            def __trunc__(self):
-                return BadIndex()
-
-        class TruncReturnsBadInt:
-            def __trunc__(self):
-                return BadInt()
-
-        class TruncReturnsIntSubclass:
-            def __trunc__(self):
-                return True
-
         bad_int = BadIndex()
         with self.assertWarns(DeprecationWarning):
             n = int(bad_int)
@@ -552,26 +484,6 @@ def __trunc__(self):
         self.assertEqual(n, 1)
         self.assertIs(type(n), int)
 
-        bad_int = TruncReturnsBadIndex()
-        with self.assertWarns(DeprecationWarning):
-            n = int(bad_int)
-        self.assertEqual(n, 1)
-        self.assertIs(type(n), int)
-
-        bad_int = TruncReturnsBadInt()
-        with self.assertWarns(DeprecationWarning):
-            self.assertRaises(TypeError, int, bad_int)
-
-        good_int = TruncReturnsIntSubclass()
-        with self.assertWarns(DeprecationWarning):
-            n = int(good_int)
-        self.assertEqual(n, 1)
-        self.assertIs(type(n), int)
-        with self.assertWarns(DeprecationWarning):
-            n = IntSubclass(good_int)
-        self.assertEqual(n, 1)
-        self.assertIs(type(n), IntSubclass)
-
     def test_error_message(self):
         def check(s, base=None):
             with self.assertRaises(ValueError,
@@ -612,6 +524,13 @@ def test_issue31619(self):
         self.assertEqual(int('1_2_3_4_5_6_7_8_9', 16), 0x123456789)
         self.assertEqual(int('1_2_3_4_5_6_7', 32), 1144132807)
 
+    @support.cpython_only
+    def test_round_with_none_arg_direct_call(self):
+        for val in [(1).__round__(None),
+                    round(1),
+                    round(1, None)]:
+            self.assertEqual(val, 1)
+            self.assertIs(type(val), int)
 
 class IntStrDigitLimitsTests(unittest.TestCase):
 
@@ -654,8 +573,7 @@ def check(self, i, base=None):
             else:
                 self.int_class(i, base)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_max_str_digits(self):
         maxdigits = sys.get_int_max_str_digits()
 
@@ -670,8 +588,7 @@ def test_max_str_digits(self):
         with self.assertRaises(ValueError):
             str(i)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_denial_of_service_prevented_int_to_str(self):
         """Regression test: ensure we fail before performing O(N**2) work."""
         maxdigits = sys.get_int_max_str_digits()
@@ -712,7 +629,7 @@ def test_denial_of_service_prevented_int_to_str(self):
         self.assertIn('conversion', str(err.exception))
         self.assertLess(sw_fail_extra_huge.seconds, sw_convert.seconds/2)
 
-    @unittest.skip('TODO: RUSTPYTHON; flaky test')
+    @unittest.skip("TODO: RUSTPYTHON; flaky test")
     def test_denial_of_service_prevented_str_to_int(self):
         """Regression test: ensure we fail before performing O(N**2) work."""
         maxdigits = sys.get_int_max_str_digits()
@@ -796,8 +713,7 @@ def _other_base_helper(self, base):
         with self.assertRaises(ValueError) as err:
             int_class(f'{s}1', base)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_int_from_other_bases(self):
         base = 3
         with self.subTest(base=base):
@@ -872,6 +788,18 @@ def test_pylong_int_divmod(self):
         a, b = divmod(n*3 + 1, n)
         assert a == 3 and b == 1
 
+    @support.cpython_only  # tests implementation details of CPython.
+    @unittest.skipUnless(_pylong, "_pylong module required")
+    def test_pylong_int_divmod_crash(self):
+        # Regression test for https://github.com/python/cpython/issues/142554.
+        bad_int_divmod = lambda a, b: (1,)
+        # 'k' chosen such that divmod(2**(2*k), 2**k) uses _pylong.int_divmod()
+        k = 10_000
+        a, b = (1 << (2 * k)), (1 << k)
+        with mock.patch.object(_pylong, "int_divmod", wraps=bad_int_divmod):
+            msg = r"tuple of length 2 is required from int_divmod\(\)"
+            self.assertRaisesRegex(ValueError, msg, divmod, a, b)
+
     def test_pylong_str_to_int(self):
         v1 = 1 << 100_000
         s = str(v1)
@@ -890,7 +818,7 @@ def test_pylong_str_to_int(self):
 
     @support.cpython_only  # tests implementation details of CPython.
     @unittest.skipUnless(_pylong, "_pylong module required")
-    # @mock.patch.object(_pylong, "int_to_decimal_string") # NOTE(RUSTPYTHON): See comment at top of file
+    #@mock.patch.object(_pylong, "int_to_decimal_string") # NOTE(RUSTPYTHON): See comment at top of file
     def test_pylong_misbehavior_error_path_to_str(
             self, mock_int_to_str):
         with support.adjust_int_max_str_digits(20_000):
@@ -906,7 +834,7 @@ def test_pylong_misbehavior_error_path_to_str(
 
     @support.cpython_only  # tests implementation details of CPython.
     @unittest.skipUnless(_pylong, "_pylong module required")
-    # @mock.patch.object(_pylong, "int_from_string") # NOTE(RUSTPYTHON): See comment at top of file
+    #@mock.patch.object(_pylong, "int_from_string") # NOTE(RUSTPYTHON): See comment at top of file
     def test_pylong_misbehavior_error_path_from_str(
             self, mock_int_from_str):
         big_value = '7'*19_999
@@ -930,9 +858,91 @@ def test_pylong_roundtrip(self):
             n = hibit | getrandbits(bits - 1)
             assert n.bit_length() == bits
             sn = str(n)
-            self.assertFalse(sn.startswith('0'))
+            self.assertNotStartsWith(sn, '0')
             self.assertEqual(n, int(sn))
             bits <<= 1
 
+    @support.requires_resource('cpu')
+    @unittest.skipUnless(_decimal, "C _decimal module required")
+    def test_pylong_roundtrip_huge(self):
+        # k blocks of 1234567890
+        k = 1_000_000 # so 10 million digits in all
+        tentoten = 10**10
+        n = 1234567890 * ((tentoten**k - 1) // (tentoten - 1))
+        sn = "1234567890" * k
+        self.assertEqual(n, int(sn))
+        self.assertEqual(sn, str(n))
+
+    @support.requires_resource('cpu')
+    @unittest.skipUnless(_pylong, "_pylong module required")
+    @unittest.skipUnless(_decimal, "C _decimal module required")
+    def test_whitebox_dec_str_to_int_inner_failsafe(self):
+        # While I believe the number of GUARD digits in this function is
+        # always enough so that no more than one correction step is ever
+        # needed, the code has a "failsafe" path that takes over if I'm
+        # wrong about that. We have no input that reaches that block.
+        # Here we test a contrived input that _does_ reach that block,
+        # provided the number of guard digits is reduced to 1.
+        sn = "9" * 2000156
+        n = 10**len(sn) - 1
+        orig_spread = _pylong._spread.copy()
+        _pylong._spread.clear()
+        try:
+            self.assertEqual(n, _pylong._dec_str_to_int_inner(sn, GUARD=1))
+            self.assertIn(999, _pylong._spread)
+        finally:
+            _pylong._spread.clear()
+            _pylong._spread.update(orig_spread)
+
+    @unittest.skipUnless(_pylong, "pylong module required")
+    @unittest.skipUnless(_decimal, "C _decimal module required")
+    def test_whitebox_dec_str_to_int_inner_monster(self):
+        # I don't think anyone has enough RAM to build a string long enough
+        # for this function to complain. So lie about the string length.
+
+        class LyingStr(str):
+            def __len__(self):
+                return int((1 << 47) / _pylong._LOG_10_BASE_256)
+
+        liar = LyingStr("42")
+        # We have to pass the liar directly to the complaining function. If we
+        # just try `int(liar)`, earlier layers will replace it with plain old
+        # "43".
+        # Embedding `len(liar)` into the f-string failed on the WASI testbot
+        # (don't know what that is):
+        # OverflowError: cannot fit 'int' into an index-sized integer
+        # So a random stab at worming around that.
+        self.assertRaisesRegex(ValueError,
+            f"^cannot convert string of len {liar.__len__()} to int$",
+            _pylong._dec_str_to_int_inner,
+            liar)
+
+    @unittest.skipUnless(_pylong, "_pylong module required")
+    def test_pylong_compute_powers(self):
+        # Basic sanity tests. See end of _pylong.py for manual heavy tests.
+        def consumer(w, base, limit, need_hi):
+            seen = set()
+            need = set()
+            def inner(w):
+                if w <= limit or w in seen:
+                    return
+                seen.add(w)
+                lo = w >> 1
+                hi = w - lo
+                need.add(hi if need_hi else lo)
+                inner(lo)
+                inner(hi)
+            inner(w)
+            d = _pylong.compute_powers(w, base, limit, need_hi=need_hi)
+            self.assertEqual(d.keys(), need)
+            for k, v in d.items():
+                self.assertEqual(v, base ** k)
+
+        for base in 2, 5:
+            for need_hi in False, True:
+                for limit in 1, 11:
+                    for w in range(250, 550):
+                        consumer(w, base, limit, need_hi)
+
 if __name__ == "__main__":
     unittest.main()
diff --git a/Lib/test/test_io.py b/Lib/test/test_io.py
index 741920a5864..497c4e6e224 100644
--- a/Lib/test/test_io.py
+++ b/Lib/test/test_io.py
@@ -445,9 +445,25 @@ def test_invalid_operations(self):
             self.assertRaises(exc, fp.seek, 1, self.SEEK_CUR)
             self.assertRaises(exc, fp.seek, -1, self.SEEK_END)
 
-    @unittest.skipIf(
-        support.is_emscripten, "fstat() of a pipe fd is not supported"
-    )
+    @support.cpython_only
+    def test_startup_optimization(self):
+        # gh-132952: Test that `io` is not imported at startup and that the
+        # __module__ of UnsupportedOperation is set to "io".
+        assert_python_ok("-S", "-c", textwrap.dedent(
+            """
+            import sys
+            assert "io" not in sys.modules
+            try:
+                sys.stdin.truncate()
+            except Exception as e:
+                typ = type(e)
+                assert typ.__module__ == "io", (typ, typ.__module__)
+                assert typ.__name__ == "UnsupportedOperation", (typ, typ.__name__)
+            else:
+                raise AssertionError("Expected UnsupportedOperation")
+            """
+        ))
+
     @unittest.skipUnless(hasattr(os, "pipe"), "requires os.pipe()")
     def test_optional_abilities(self):
         # Test for OSError when optional APIs are not supported
@@ -501,57 +517,65 @@ class UnseekableWriter(self.MockUnseekableIO):
             (text_reader, "r"), (text_writer, "w"),
             (self.BytesIO, "rws"), (self.StringIO, "rws"),
         )
-        for [test, abilities] in tests:
-            with self.subTest(test), test() as obj:
-                readable = "r" in abilities
-                self.assertEqual(obj.readable(), readable)
-                writable = "w" in abilities
-                self.assertEqual(obj.writable(), writable)
-
-                if isinstance(obj, self.TextIOBase):
-                    data = "3"
-                elif isinstance(obj, (self.BufferedIOBase, self.RawIOBase)):
-                    data = b"3"
-                else:
-                    self.fail("Unknown base class")
 
-                if "f" in abilities:
-                    obj.fileno()
-                else:
-                    self.assertRaises(OSError, obj.fileno)
+        def do_test(test, obj, abilities):
+            readable = "r" in abilities
+            self.assertEqual(obj.readable(), readable)
+            writable = "w" in abilities
+            self.assertEqual(obj.writable(), writable)
 
-                if readable:
-                    obj.read(1)
-                    obj.read()
-                else:
-                    self.assertRaises(OSError, obj.read, 1)
-                    self.assertRaises(OSError, obj.read)
+            if isinstance(obj, self.TextIOBase):
+                data = "3"
+            elif isinstance(obj, (self.BufferedIOBase, self.RawIOBase)):
+                data = b"3"
+            else:
+                self.fail("Unknown base class")
 
-                if writable:
-                    obj.write(data)
-                else:
-                    self.assertRaises(OSError, obj.write, data)
-
-                if sys.platform.startswith("win") and test in (
-                        pipe_reader, pipe_writer):
-                    # Pipes seem to appear as seekable on Windows
-                    continue
-                seekable = "s" in abilities
-                self.assertEqual(obj.seekable(), seekable)
-
-                if seekable:
-                    obj.tell()
-                    obj.seek(0)
-                else:
-                    self.assertRaises(OSError, obj.tell)
-                    self.assertRaises(OSError, obj.seek, 0)
+            if "f" in abilities:
+                obj.fileno()
+            else:
+                self.assertRaises(OSError, obj.fileno)
+
+            if readable:
+                obj.read(1)
+                obj.read()
+            else:
+                self.assertRaises(OSError, obj.read, 1)
+                self.assertRaises(OSError, obj.read)
+
+            if writable:
+                obj.write(data)
+            else:
+                self.assertRaises(OSError, obj.write, data)
+
+            if sys.platform.startswith("win") and test in (
+                    pipe_reader, pipe_writer):
+                # Pipes seem to appear as seekable on Windows
+                return
+            seekable = "s" in abilities
+            self.assertEqual(obj.seekable(), seekable)
+
+            if seekable:
+                obj.tell()
+                obj.seek(0)
+            else:
+                self.assertRaises(OSError, obj.tell)
+                self.assertRaises(OSError, obj.seek, 0)
+
+            if writable and seekable:
+                obj.truncate()
+                obj.truncate(0)
+            else:
+                self.assertRaises(OSError, obj.truncate)
+                self.assertRaises(OSError, obj.truncate, 0)
+
+        for [test, abilities] in tests:
+            with self.subTest(test):
+                if test == pipe_writer and not threading_helper.can_start_thread:
+                    self.skipTest("Need threads")
+                with test() as obj:
+                    do_test(test, obj, abilities)
 
-                if writable and seekable:
-                    obj.truncate()
-                    obj.truncate(0)
-                else:
-                    self.assertRaises(OSError, obj.truncate)
-                    self.assertRaises(OSError, obj.truncate, 0)
 
     def test_open_handles_NUL_chars(self):
         fn_with_NUL = 'foo\0bar'
@@ -780,8 +804,8 @@ def test_closefd_attr(self):
             file = self.open(f.fileno(), "r", encoding="utf-8", closefd=False)
             self.assertEqual(file.buffer.raw.closefd, False)
 
-    @unittest.skipIf(sys.platform == 'win32', 'TODO: RUSTPYTHON; cyclic GC not supported, causes file locking')
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AssertionError: filter ('', ResourceWarning) did not catch any warning
+    @unittest.skipIf(sys.platform == "win32", "TODO: RUSTPYTHON; cyclic GC not supported, causes file locking")
     def test_garbage_collection(self):
         # FileIO objects are collected, and collecting them flushes
         # all data to disk.
@@ -896,7 +920,7 @@ def test_types_have_dict(self):
             self.BytesIO()
         )
         for obj in test:
-            self.assertTrue(hasattr(obj, "__dict__"))
+            self.assertHasAttr(obj, "__dict__")
 
     def test_opener(self):
         with self.open(os_helper.TESTFN, "w", encoding="utf-8") as f:
@@ -1090,7 +1114,7 @@ def reader(file, barrier):
 
 class CIOTest(IOTest):
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON; cyclic gc
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; cyclic gc
     def test_IOBase_finalize(self):
         # Issue #12149: segmentation fault on _PyIOBase_finalize when both a
         # class which inherits IOBase and an object of this class are caught
@@ -1109,10 +1133,6 @@ def close(self):
         support.gc_collect()
         self.assertIsNone(wr(), wr)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON; AssertionError: filter ('', ResourceWarning) did not catch any warning
-    def test_destructor(self):
-        return super().test_destructor()
-
 @support.cpython_only
 class TestIOCTypes(unittest.TestCase):
     def setUp(self):
@@ -1147,7 +1167,7 @@ def test_class_hierarchy(self):
         def check_subs(types, base):
             for tp in types:
                 with self.subTest(tp=tp, base=base):
-                    self.assertTrue(issubclass(tp, base))
+                    self.assertIsSubclass(tp, base)
 
         def recursive_check(d):
             for k, v in d.items():
@@ -1803,8 +1823,8 @@ def test_misbehaved_io_read(self):
         # checking this is not so easy.
         self.assertRaises(OSError, bufio.read, 10)
 
-    @unittest.skipIf(sys.platform == 'win32', 'TODO: RUSTPYTHON; cyclic GC not supported, causes file locking')
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AssertionError: filter ('', ResourceWarning) did not catch any warning
+    @unittest.skipIf(sys.platform == "win32", "TODO: RUSTPYTHON; cyclic GC not supported, causes file locking")
     def test_garbage_collection(self):
         # C BufferedReader objects are collected.
         # The Python version has __del__, so it ends into gc.garbage instead
@@ -1839,14 +1859,6 @@ def test_bad_readinto_type(self):
             bufio.readline()
         self.assertIsInstance(cm.exception.__cause__, TypeError)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
-    def test_error_through_destructor(self):
-        return super().test_error_through_destructor()
-
-    @unittest.expectedFailure # TODO: RUSTPYTHON
-    def test_pickling_subclass(self):
-        return super().test_pickling_subclass()
-
 
 class PyBufferedReaderTest(BufferedReaderTest):
     tp = pyio.BufferedReader
@@ -1910,7 +1922,7 @@ def test_write_overflow(self):
         flushed = b"".join(writer._write_stack)
         # At least (total - 8) bytes were implicitly flushed, perhaps more
         # depending on the implementation.
-        self.assertTrue(flushed.startswith(contents[:-8]), flushed)
+        self.assertStartsWith(flushed, contents[:-8])
 
     def check_writes(self, intermediate_func):
         # Lots of writes, test the flushed output is as expected.
@@ -1980,7 +1992,7 @@ def test_write_non_blocking(self):
         self.assertEqual(bufio.write(b"ABCDEFGHI"), 9)
         s = raw.pop_written()
         # Previously buffered bytes were flushed
-        self.assertTrue(s.startswith(b"01234567A"), s)
+        self.assertStartsWith(s, b"01234567A")
 
     def test_write_and_rewind(self):
         raw = self.BytesIO()
@@ -2161,8 +2173,8 @@ def test_initialization(self):
         self.assertRaises(ValueError, bufio.__init__, rawio, buffer_size=-1)
         self.assertRaises(ValueError, bufio.write, b"def")
 
-    @unittest.skipIf(sys.platform == 'win32', 'TODO: RUSTPYTHON; cyclic GC not supported, causes file locking')
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AssertionError: filter ('', ResourceWarning) did not catch any warning
+    @unittest.skipIf(sys.platform == "win32", "TODO: RUSTPYTHON; cyclic GC not supported, causes file locking")
     def test_garbage_collection(self):
         # C BufferedWriter objects are collected, and collecting them flushes
         # all data to disk.
@@ -2185,13 +2197,6 @@ def test_args_error(self):
         with self.assertRaisesRegex(TypeError, "BufferedWriter"):
             self.tp(self.BytesIO(), 1024, 1024, 1024)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
-    def test_error_through_destructor(self):
-        return super().test_error_through_destructor()
-
-    @unittest.expectedFailure # TODO: RUSTPYTHON
-    def test_pickling_subclass(self):
-        return super().test_pickling_subclass()
 
 class PyBufferedWriterTest(BufferedWriterTest):
     tp = pyio.BufferedWriter
@@ -2285,7 +2290,7 @@ def test_write(self):
     def test_peek(self):
         pair = self.tp(self.BytesIO(b"abcdef"), self.MockRawIO())
 
-        self.assertTrue(pair.peek(3).startswith(b"abc"))
+        self.assertStartsWith(pair.peek(3), b"abc")
         self.assertEqual(pair.read(3), b"abc")
 
     def test_readable(self):
@@ -2669,8 +2674,8 @@ def test_interleaved_readline_write(self):
 class CBufferedRandomTest(BufferedRandomTest, SizeofTest):
     tp = io.BufferedRandom
 
-    @unittest.skipIf(sys.platform == 'win32', 'TODO: RUSTPYTHON; cyclic GC not supported, causes file locking')
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AssertionError: filter ('', ResourceWarning) did not catch any warning
+    @unittest.skipIf(sys.platform == "win32", "TODO: RUSTPYTHON; cyclic GC not supported, causes file locking")
     def test_garbage_collection(self):
         CBufferedReaderTest.test_garbage_collection(self)
         CBufferedWriterTest.test_garbage_collection(self)
@@ -2680,14 +2685,6 @@ def test_args_error(self):
         with self.assertRaisesRegex(TypeError, "BufferedRandom"):
             self.tp(self.BytesIO(), 1024, 1024, 1024)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
-    def test_error_through_destructor(self):
-        return super().test_error_through_destructor()
-
-    @unittest.expectedFailure # TODO: RUSTPYTHON
-    def test_pickling_subclass(self):
-        return super().test_pickling_subclass()
-
 
 class PyBufferedRandomTest(BufferedRandomTest):
     tp = pyio.BufferedRandom
@@ -2997,14 +2994,11 @@ def test_reconfigure_line_buffering(self):
 
     @unittest.skipIf(sys.flags.utf8_mode, "utf-8 mode is enabled")
     def test_default_encoding(self):
-        old_environ = dict(os.environ)
-        try:
+        with os_helper.EnvironmentVarGuard() as env:
             # try to get a user preferred encoding different than the current
             # locale encoding to check that TextIOWrapper() uses the current
             # locale encoding and not the user preferred encoding
-            for key in ('LC_ALL', 'LANG', 'LC_CTYPE'):
-                if key in os.environ:
-                    del os.environ[key]
+            env.unset('LC_ALL', 'LANG', 'LC_CTYPE')
 
             current_locale_encoding = locale.getencoding()
             b = self.BytesIO()
@@ -3012,9 +3006,6 @@ def test_default_encoding(self):
                 warnings.simplefilter("ignore", EncodingWarning)
                 t = self.TextIOWrapper(b)
             self.assertEqual(t.encoding, current_locale_encoding)
-        finally:
-            os.environ.clear()
-            os.environ.update(old_environ)
 
     def test_encoding(self):
         # Check the encoding attribute is always set, and valid
@@ -3340,7 +3331,7 @@ def test_seek_and_tell_with_data(data, min_pos=0):
         finally:
             StatefulIncrementalDecoder.codecEnabled = 0
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; LookupError: unknown encoding: euc_jp
     def test_multibyte_seek_and_tell(self):
         f = self.open(os_helper.TESTFN, "w", encoding="euc_jp")
         f.write("AB\n\u3046\u3048\n")
@@ -3387,7 +3378,6 @@ def test_seek_with_encoder_state(self):
         self.assertEqual(f.readline(), "\u00e6\u0300\u0300")
         f.close()
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_encoded_writes(self):
         data = "1234567890"
         tests = ("utf-16",
@@ -3526,7 +3516,6 @@ def test_issue2282(self):
 
         self.assertEqual(buffer.seekable(), txt.seekable())
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_append_bom(self):
         # The BOM is not written again when appending to a non-empty file
         filename = os_helper.TESTFN
@@ -3542,7 +3531,6 @@ def test_append_bom(self):
             with self.open(filename, 'rb') as f:
                 self.assertEqual(f.read(), 'aaaxxx'.encode(charset))
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_seek_bom(self):
         # Same test, but when seeking manually
         filename = os_helper.TESTFN
@@ -3558,7 +3546,6 @@ def test_seek_bom(self):
             with self.open(filename, 'rb') as f:
                 self.assertEqual(f.read(), 'bbbzzz'.encode(charset))
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_seek_append_bom(self):
         # Same test, but first seek to the start and then to the end
         filename = os_helper.TESTFN
@@ -3826,7 +3813,6 @@ def __del__(self):
             """.format(iomod=iomod, kwargs=kwargs)
         return assert_python_ok("-c", code)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_create_at_shutdown_without_encoding(self):
         rc, out, err = self._check_create_at_shutdown()
         if err:
@@ -3836,7 +3822,6 @@ def test_create_at_shutdown_without_encoding(self):
         else:
             self.assertEqual("ok", out.decode().strip())
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_create_at_shutdown_with_encoding(self):
         rc, out, err = self._check_create_at_shutdown(encoding='utf-8',
                                                       errors='strict')
@@ -4084,6 +4069,22 @@ def __setstate__(slf, state):
                 self.assertEqual(newtxt.tag, 'ham')
         del MyTextIO
 
+    @unittest.skipUnless(hasattr(os, "pipe"), "requires os.pipe()")
+    def test_read_non_blocking(self):
+        import os
+        r, w = os.pipe()
+        try:
+            os.set_blocking(r, False)
+            with self.io.open(r, 'rt') as textfile:
+                r = None
+                # Nothing has been written so a non-blocking read raises a BlockingIOError exception.
+                with self.assertRaises(BlockingIOError):
+                    textfile.read()
+        finally:
+            if r is not None:
+                os.close(r)
+            os.close(w)
+
 
 class MemviewBytesIO(io.BytesIO):
     '''A BytesIO object whose read method returns memoryviews
@@ -4108,7 +4109,11 @@ class CTextIOWrapperTest(TextIOWrapperTest):
     io = io
     shutdown_error = "LookupError: unknown encoding: ascii"
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.skipUnless(hasattr(os, "pipe"), "requires os.pipe()")
+    @unittest.expectedFailure
+    def test_read_non_blocking(self):
+        return super().test_read_non_blocking()
+
     def test_initialization(self):
         r = self.BytesIO(b"\xc3\xa9\n\n")
         b = self.BufferedReader(r, 1000)
@@ -4119,8 +4124,8 @@ def test_initialization(self):
         t = self.TextIOWrapper.__new__(self.TextIOWrapper)
         self.assertRaises(Exception, repr, t)
 
-    @unittest.skipIf(sys.platform == 'win32', 'TODO: RUSTPYTHON; cyclic GC not supported, causes file locking')
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AssertionError: filter ('', ResourceWarning) did not catch any warning
+    @unittest.skipIf(sys.platform == "win32", "TODO: RUSTPYTHON; cyclic GC not supported, causes file locking")
     def test_garbage_collection(self):
         # C TextIOWrapper objects are collected, and collecting them flushes
         # all data to disk.
@@ -4184,7 +4189,6 @@ def write(self, data):
         t.write("x"*chunk_size)
         self.assertEqual([b"abcdef", b"ghi", b"x"*chunk_size], buf._write_stack)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_issue119506(self):
         chunk_size = 8192
 
@@ -4207,97 +4211,49 @@ def write(self, data):
         self.assertEqual([b"abcdef", b"middle", b"g"*chunk_size],
                          buf._write_stack)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
-    def test_constructor(self):
-        return super().test_constructor()
-
-    @unittest.expectedFailure # TODO: RUSTPYTHON
-    def test_newlines(self):
-        return super().test_newlines()
-
-    @unittest.expectedFailure # TODO: RUSTPYTHON
-    def test_newlines_input(self):
-        return super().test_newlines_input()
-
-    @unittest.expectedFailure # TODO: RUSTPYTHON
-    def test_non_text_encoding_codecs_are_rejected(self):
-        return super().test_non_text_encoding_codecs_are_rejected()
-
-    @unittest.expectedFailure # TODO: RUSTPYTHON
-    def test_reconfigure_defaults(self):
-        return super().test_reconfigure_defaults()
-
-    @unittest.expectedFailure # TODO: RUSTPYTHON
-    def test_reconfigure_encoding_read(self):
-        return super().test_reconfigure_encoding_read()
-
-    @unittest.expectedFailure # TODO: RUSTPYTHON
-    def test_reconfigure_errors(self):
-        return super().test_reconfigure_errors()
-
-    @unittest.expectedFailure # TODO: RUSTPYTHON
-    def test_reconfigure_line_buffering(self):
-        return super().test_reconfigure_line_buffering()
-
-    @unittest.expectedFailure # TODO: RUSTPYTHON
-    def test_reconfigure_locale(self):
-        return super().test_reconfigure_locale()
-
-    @unittest.expectedFailure # TODO: RUSTPYTHON
-    def test_reconfigure_newline(self):
-        return super().test_reconfigure_newline()
-
-    @unittest.expectedFailure # TODO: RUSTPYTHON
-    def test_reconfigure_write(self):
-        return super().test_reconfigure_write()
-
-    @unittest.expectedFailure # TODO: RUSTPYTHON
-    def test_reconfigure_write_fromascii(self):
-        return super().test_reconfigure_write_fromascii()
-
-    @unittest.expectedFailure # TODO: RUSTPYTHON
-    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()
-
-    @unittest.expectedFailure # TODO: RUSTPYTHON
-    def test_recursive_repr(self):
-        return super().test_recursive_repr()
+    def test_issue142594(self):
+        wrapper = None
+        detached = False
+        class ReentrantRawIO(self.RawIOBase):
+            @property
+            def closed(self):
+                nonlocal detached
+                if wrapper is not None and not detached:
+                    detached = True
+                    wrapper.detach()
+                return False
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
-    def test_pickling_subclass(self):
-        return super().test_pickling_subclass()
+        raw = ReentrantRawIO()
+        wrapper = self.TextIOWrapper(raw)
+        wrapper.close()  # should not crash
 
-    # TODO: RUSTPYTHON; euc_jis_2004 encoding not supported
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; LookupError: unknown encoding: euc_jis_2004
     def test_seek_with_encoder_state(self):
         return super().test_seek_with_encoder_state()
 
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; TypeError: a bytes-like object is required, not 'NoneType'
+    def test_read_non_blocking(self):
+        return super().test_read_non_blocking()
+
 
 class PyTextIOWrapperTest(TextIOWrapperTest):
     io = pyio
     shutdown_error = "LookupError: unknown encoding: ascii"
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON; AssertionError: ValueError not raised
-    def test_constructor(self):
-        return super().test_constructor()
-
-    @unittest.expectedFailure # TODO: RUSTPYTHON
-    def test_newlines(self):
-        return super().test_newlines()
+    @unittest.expectedFailureIfWindows("TODO: RUSTPYTHON; os.set_blocking not available on Windows")
+    def test_read_non_blocking(self):
+        return super().test_read_non_blocking()
 
-    # TODO: RUSTPYTHON; euc_jis_2004 encoding not supported
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; LookupError: unknown encoding: euc_jis_2004
     def test_seek_with_encoder_state(self):
         return super().test_seek_with_encoder_state()
 
+    if sys.platform == "win32":
+        @unittest.skipUnless(hasattr(os, "pipe"), "requires os.pipe()")
+        @unittest.expectedFailure
+        def test_read_non_blocking(self):
+            return super().test_read_non_blocking()
+
 
 class IncrementalNewlineDecoderTest(unittest.TestCase):
 
@@ -4376,7 +4332,6 @@ def _decode_bytewise(s):
         self.assertEqual(decoder.decode(input), "abc")
         self.assertEqual(decoder.newlines, None)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_newline_decoder(self):
         encodings = (
             # None meaning the IncrementalNewlineDecoder takes unicode input
@@ -4474,9 +4429,6 @@ def test_removed_u_mode(self):
                 self.open(os_helper.TESTFN, mode)
             self.assertIn('invalid mode', str(cm.exception))
 
-    @unittest.skipIf(
-        support.is_emscripten, "fstat() of a pipe fd is not supported"
-    )
     @unittest.skipUnless(hasattr(os, "pipe"), "requires os.pipe()")
     def test_open_pipe_with_append(self):
         # bpo-27805: Ignore ESPIPE from lseek() in open().
@@ -4538,7 +4490,7 @@ def test_io_after_close(self):
             self.assertRaises(ValueError, f.writelines, [])
             self.assertRaises(ValueError, next, f)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON; cyclic gc
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; cyclic gc
     def test_blockingioerror(self):
         # Various BlockingIOError issues
         class C(str):
@@ -4646,15 +4598,11 @@ def test_pickling(self):
                         with self.assertRaisesRegex(TypeError, msg):
                             pickle.dumps(f, protocol)
 
-    @unittest.skipIf(
-        support.is_emscripten, "fstat() of a pipe fd is not supported"
-    )
+    @unittest.skipIf(support.is_emscripten, "Emscripten corrupts memory when writing to nonblocking fd")
     def test_nonblock_pipe_write_bigbuf(self):
         self._test_nonblock_pipe_write(16*1024)
 
-    @unittest.skipIf(
-        support.is_emscripten, "fstat() of a pipe fd is not supported"
-    )
+    @unittest.skipIf(support.is_emscripten, "Emscripten corrupts memory when writing to nonblocking fd")
     def test_nonblock_pipe_write_smallbuf(self):
         self._test_nonblock_pipe_write(1024)
 
@@ -4773,7 +4721,6 @@ def test_check_encoding_errors(self):
         proc = assert_python_failure('-X', 'dev', '-c', code)
         self.assertEqual(proc.rc, 10, proc)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON; AssertionError: 0 != 2
     def test_check_encoding_warning(self):
         # PEP 597: Raise warning when encoding is not specified
         # and sys.flags.warn_default_encoding is set.
@@ -4792,12 +4739,9 @@ def test_check_encoding_warning(self):
         proc = assert_python_ok('-X', 'warn_default_encoding', '-c', code)
         warnings = proc.err.splitlines()
         self.assertEqual(len(warnings), 2)
-        self.assertTrue(
-            warnings[0].startswith(b"<string>:5: EncodingWarning: "))
-        self.assertTrue(
-            warnings[1].startswith(b"<string>:8: EncodingWarning: "))
+        self.assertStartsWith(warnings[0], b"<string>:5: EncodingWarning: ")
+        self.assertStartsWith(warnings[1], b"<string>:8: EncodingWarning: ")
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_text_encoding(self):
         # PEP 597, bpo-47000. io.text_encoding() returns "locale" or "utf-8"
         # based on sys.flags.utf8_mode
@@ -4875,20 +4819,6 @@ def test_daemon_threads_shutdown_stdout_deadlock(self):
     def test_daemon_threads_shutdown_stderr_deadlock(self):
         self.check_daemon_threads_shutdown_deadlock('stderr')
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON; AssertionError: 22 != 10 : _PythonRunResult(rc=22, out=b'', err=b'')
-    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
@@ -5023,7 +4953,7 @@ def on_alarm(*args):
                     os.read(r, len(data) * 100)
             exc = cm.exception
             if isinstance(exc, RuntimeError):
-                self.assertTrue(str(exc).startswith("reentrant call"), str(exc))
+                self.assertStartsWith(str(exc), "reentrant call")
         finally:
             signal.alarm(0)
             wio.close()
@@ -5141,13 +5071,13 @@ def alarm2(sig, frame):
                 if e.errno != errno.EBADF:
                     raise
 
-    @unittest.skip("TODO: RUSTPYTHON thread 'main' (103833) panicked at crates/vm/src/stdlib/signal.rs:233:43: RefCell already borrowed")
+    @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.skip("TODO: RUSTPYTHON thread 'main' (103833) panicked at crates/vm/src/stdlib/signal.rs:233:43: RefCell already borrowed")
+    @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):
@@ -5157,9 +5087,9 @@ 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
+    @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):
+        return super().test_interrupted_read_retry_buffered()
 
 class PySignalsTest(SignalsTest):
     io = pyio
@@ -5170,6 +5100,24 @@ class PySignalsTest(SignalsTest):
     test_reentrant_write_text = None
 
 
+class ProtocolsTest(unittest.TestCase):
+    class MyReader:
+        def read(self, sz=-1):
+            return b""
+
+    class MyWriter:
+        def write(self, b: bytes):
+            pass
+
+    def test_reader_subclass(self):
+        self.assertIsSubclass(self.MyReader, io.Reader)
+        self.assertNotIsSubclass(str, io.Reader)
+
+    def test_writer_subclass(self):
+        self.assertIsSubclass(self.MyWriter, io.Writer)
+        self.assertNotIsSubclass(str, io.Writer)
+
+
 def load_tests(loader, tests, pattern):
     tests = (CIOTest, PyIOTest, APIMismatchTest,
              CBufferedReaderTest, PyBufferedReaderTest,
@@ -5181,6 +5129,7 @@ def load_tests(loader, tests, pattern):
              CTextIOWrapperTest, PyTextIOWrapperTest,
              CMiscIOTest, PyMiscIOTest,
              CSignalsTest, PySignalsTest, TestIOCTypes,
+             ProtocolsTest,
              )
 
     # Put the namespaces of the IO module we are testing and some useful mock
diff --git a/Lib/test/test_iter.py b/Lib/test/test_iter.py
index 42b94a55c1d..9c26eb08583 100644
--- a/Lib/test/test_iter.py
+++ b/Lib/test/test_iter.py
@@ -4,11 +4,14 @@
 import unittest
 from test.support import cpython_only
 from test.support.os_helper import TESTFN, unlink
-# XXX: RUSTPYTHON
-# from test.support import check_free_after_iterating, ALWAYS_EQ, NEVER_EQ
-from test.support import ALWAYS_EQ, NEVER_EQ
+from test.support import check_free_after_iterating, ALWAYS_EQ, NEVER_EQ
+from test.support import BrokenIter
 import pickle
 import collections.abc
+import functools
+import contextlib
+import builtins
+import traceback
 
 # Test result of triple loop (too big to inline)
 TRIPLETS = [(0, 0, 0), (0, 0, 1), (0, 0, 2),
@@ -83,6 +86,22 @@ class BadIterableClass:
     def __iter__(self):
         raise ZeroDivisionError
 
+class CallableIterClass:
+    def __init__(self):
+        self.i = 0
+    def __call__(self):
+        i = self.i
+        self.i = i + 1
+        if i > 100:
+            raise IndexError # Emergency stop
+        return i
+
+class EmptyIterClass:
+    def __len__(self):
+        return 0
+    def __getitem__(self, i):
+        raise StopIteration
+
 # Main test suite
 
 class TestCase(unittest.TestCase):
@@ -230,6 +249,78 @@ def test_mutating_seq_class_exhausted_iter(self):
         self.assertEqual(list(empit), [5, 6])
         self.assertEqual(list(a), [0, 1, 2, 3, 4, 5, 6])
 
+    def test_reduce_mutating_builtins_iter(self):
+        # This is a reproducer of issue #101765
+        # where iter `__reduce__` calls could lead to a segfault or SystemError
+        # depending on the order of C argument evaluation, which is undefined
+
+        # Backup builtins
+        builtins_dict = builtins.__dict__
+        orig = {"iter": iter, "reversed": reversed}
+
+        def run(builtin_name, item, sentinel=None):
+            it = iter(item) if sentinel is None else iter(item, sentinel)
+
+            class CustomStr:
+                def __init__(self, name, iterator):
+                    self.name = name
+                    self.iterator = iterator
+                def __hash__(self):
+                    return hash(self.name)
+                def __eq__(self, other):
+                    # Here we exhaust our iterator, possibly changing
+                    # its `it_seq` pointer to NULL
+                    # The `__reduce__` call should correctly get
+                    # the pointers after this call
+                    list(self.iterator)
+                    return other == self.name
+
+            # del is required here
+            # to not prematurely call __eq__ from
+            # the hash collision with the old key
+            del builtins_dict[builtin_name]
+            builtins_dict[CustomStr(builtin_name, it)] = orig[builtin_name]
+
+            return it.__reduce__()
+
+        types = [
+            (EmptyIterClass(),),
+            (bytes(8),),
+            (bytearray(8),),
+            ((1, 2, 3),),
+            (lambda: 0, 0),
+            (tuple[int],)  # GenericAlias
+        ]
+
+        try:
+            run_iter = functools.partial(run, "iter")
+            # The returned value of `__reduce__` should not only be valid
+            # but also *empty*, as `it` was exhausted during `__eq__`
+            # i.e "xyz" returns (iter, ("",))
+            self.assertEqual(run_iter("xyz"), (orig["iter"], ("",)))
+            self.assertEqual(run_iter([1, 2, 3]), (orig["iter"], ([],)))
+
+            # _PyEval_GetBuiltin is also called for `reversed` in a branch of
+            # listiter_reduce_general
+            self.assertEqual(
+                run("reversed", orig["reversed"](list(range(8)))),
+                (reversed, ([],))
+            )
+
+            for case in types:
+                self.assertEqual(run_iter(*case), (orig["iter"], ((),)))
+        finally:
+            # Restore original builtins
+            for key, func in orig.items():
+                # need to suppress KeyErrors in case
+                # a failed test deletes the key without setting anything
+                with contextlib.suppress(KeyError):
+                    # del is required here
+                    # to not invoke our custom __eq__ from
+                    # the hash collision with the old key
+                    del builtins_dict[key]
+                builtins_dict[key] = func
+
     # Test a new_style class with __iter__ but no next() method
     def test_new_style_iter_class(self):
         class IterClass(object):
@@ -239,16 +330,7 @@ def __iter__(self):
 
     # Test two-argument iter() with callable instance
     def test_iter_callable(self):
-        class C:
-            def __init__(self):
-                self.i = 0
-            def __call__(self):
-                i = self.i
-                self.i = i + 1
-                if i > 100:
-                    raise IndexError # Emergency stop
-                return i
-        self.check_iterator(iter(C(), 10), list(range(10)), pickle=False)
+        self.check_iterator(iter(CallableIterClass(), 10), list(range(10)), pickle=True)
 
     # Test two-argument iter() with function
     def test_iter_function(self):
@@ -268,6 +350,31 @@ def spam(state=[0]):
             return i
         self.check_iterator(iter(spam, 20), list(range(10)), pickle=False)
 
+    def test_iter_function_concealing_reentrant_exhaustion(self):
+        # gh-101892: Test two-argument iter() with a function that
+        # exhausts its associated iterator but forgets to either return
+        # a sentinel value or raise StopIteration.
+        HAS_MORE = 1
+        NO_MORE = 2
+
+        def exhaust(iterator):
+            """Exhaust an iterator without raising StopIteration."""
+            list(iterator)
+
+        def spam():
+            # Touching the iterator with exhaust() below will call
+            # spam() once again so protect against recursion.
+            if spam.is_recursive_call:
+                return NO_MORE
+            spam.is_recursive_call = True
+            exhaust(spam.iterator)
+            return HAS_MORE
+
+        spam.is_recursive_call = False
+        spam.iterator = iter(spam, NO_MORE)
+        with self.assertRaises(StopIteration):
+            next(spam.iterator)
+
     # Test exception propagation through function iterator
     def test_exception_function(self):
         def spam(state=[0]):
@@ -1030,8 +1137,7 @@ def test_iter_neg_setstate(self):
         self.assertEqual(next(it), 0)
         self.assertEqual(next(it), 1)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AssertionError: False is not true
     def test_free_after_iterating(self):
         check_free_after_iterating(self, iter, SequenceClass, (0,))
 
@@ -1040,6 +1146,46 @@ def test_error_iter(self):
             self.assertRaises(TypeError, iter, typ())
         self.assertRaises(ZeroDivisionError, iter, BadIterableClass())
 
+    def test_exception_locations(self):
+        # The location of an exception raised from __init__ or
+        # __next__ should be the iterator expression
+
+        def init_raises():
+            try:
+                for x in BrokenIter(init_raises=True):
+                    pass
+            except Exception as e:
+                return e
+
+        def next_raises():
+            try:
+                for x in BrokenIter(next_raises=True):
+                    pass
+            except Exception as e:
+                return e
+
+        def iter_raises():
+            try:
+                for x in BrokenIter(iter_raises=True):
+                    pass
+            except Exception as e:
+                return e
+
+        for func, expected in [(init_raises, "BrokenIter(init_raises=True)"),
+                               (next_raises, "BrokenIter(next_raises=True)"),
+                               (iter_raises, "BrokenIter(iter_raises=True)"),
+                              ]:
+            with self.subTest(func):
+                exc = func()
+                f = traceback.extract_tb(exc.__traceback__)[0]
+                indent = 16
+                co = func.__code__
+                self.assertEqual(f.lineno, co.co_firstlineno + 2)
+                self.assertEqual(f.end_lineno, co.co_firstlineno + 2)
+                self.assertEqual(f.line[f.colno - indent : f.end_colno - indent],
+                                 expected)
+
+
 
 if __name__ == "__main__":
     unittest.main()
diff --git a/Lib/test/test_itertools.py b/Lib/test/test_itertools.py
index e4d44e3d38c..44addde1948 100644
--- a/Lib/test/test_itertools.py
+++ b/Lib/test/test_itertools.py
@@ -16,27 +16,6 @@
 import struct
 import threading
 import gc
-import warnings
-
-def pickle_deprecated(testfunc):
-    """ Run the test three times.
-    First, verify that a Deprecation Warning is raised.
-    Second, run normally but with DeprecationWarnings temporarily disabled.
-    Third, run with warnings promoted to errors.
-    """
-    def inner(self):
-        with self.assertWarns(DeprecationWarning):
-            testfunc(self)
-        with warnings.catch_warnings():
-            warnings.simplefilter("ignore", category=DeprecationWarning)
-            testfunc(self)
-        # XXX: RUSTPYTHON; Patch to make tests pass. It will be removed once 3.14 is released anyway.
-        # with warnings.catch_warnings():
-        #    warnings.simplefilter("error", category=DeprecationWarning)
-        #    with self.assertRaises((DeprecationWarning, AssertionError, SystemError)):
-        #        testfunc(self)
-
-    return inner
 
 maxsize = support.MAX_Py_ssize_t
 minsize = -maxsize-1
@@ -146,8 +125,6 @@ def expand(it, i=0):
             c = expand(compare[took:])
             self.assertEqual(a, c);
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON; [7, 7, 8, 10] != <itertools.accumulate object at 0xb4000073f32b4480>
-    @pickle_deprecated
     def test_accumulate(self):
         self.assertEqual(list(accumulate(range(10))),               # one positional arg
                           [0, 1, 3, 6, 10, 15, 21, 28, 36, 45])
@@ -174,9 +151,6 @@ def test_accumulate(self):
                          [2, 16, 144, 720, 5040, 0, 0, 0, 0, 0])
         with self.assertRaises(TypeError):
             list(accumulate(s, chr))                                # unary-operation
-        for proto in range(pickle.HIGHEST_PROTOCOL + 1):
-            self.pickletest(proto, accumulate(range(10)))           # test pickling
-            self.pickletest(proto, accumulate(range(10), initial=7))
         self.assertEqual(list(accumulate([10, 5, 1], initial=None)), [10, 15, 16])
         self.assertEqual(list(accumulate([10, 5, 1], initial=100)), [100, 110, 115, 116])
         self.assertEqual(list(accumulate([], initial=100)), [100])
@@ -248,61 +222,12 @@ 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:
-            it = chain('abc', 'def')
-            self.assertEqual(list(oper(it)), list('abcdef'))
-            self.assertEqual(next(it), 'a')
-            self.assertEqual(list(oper(it)), list('bcdef'))
-
-            self.assertEqual(list(oper(chain(''))), [])
-            self.assertEqual(take(4, oper(chain('abc', 'def'))), list('abcd'))
-            self.assertRaises(TypeError, list, oper(chain(2, 3)))
-        for proto in range(pickle.HIGHEST_PROTOCOL + 1):
-            self.pickletest(proto, chain('abc', 'def'), compare=list('abcdef'))
-
-    @unittest.expectedFailure # TODO: RUSTPYTHON
-    @pickle_deprecated
-    def test_chain_setstate(self):
-        self.assertRaises(TypeError, chain().__setstate__, ())
-        self.assertRaises(TypeError, chain().__setstate__, [])
-        self.assertRaises(TypeError, chain().__setstate__, 0)
-        self.assertRaises(TypeError, chain().__setstate__, ([],))
-        self.assertRaises(TypeError, chain().__setstate__, (iter([]), []))
-        it = chain()
-        it.__setstate__((iter(['abc', 'def']),))
-        self.assertEqual(list(it), ['a', 'b', 'c', 'd', 'e', 'f'])
-        it = chain()
-        it.__setstate__((iter(['abc', 'def']), iter(['ghi'])))
-        self.assertEqual(list(it), ['ghi', 'a', 'b', 'c', 'd', 'e', 'f'])
-
-    @unittest.expectedFailure # TODO: RUSTPYTHON
-    @pickle_deprecated
     def test_combinations(self):
         self.assertRaises(TypeError, combinations, 'abc')       # missing r argument
         self.assertRaises(TypeError, combinations, 'abc', 2, 1) # too many arguments
         self.assertRaises(TypeError, combinations, None)        # pool is not iterable
         self.assertRaises(ValueError, combinations, 'abc', -2)  # r is negative
 
-        for op in [lambda a:a] + picklecopiers:
-            self.assertEqual(list(op(combinations('abc', 32))), [])     # r > n
-
-            self.assertEqual(list(op(combinations('ABCD', 2))),
-                             [('A','B'), ('A','C'), ('A','D'), ('B','C'), ('B','D'), ('C','D')])
-            testIntermediate = combinations('ABCD', 2)
-            next(testIntermediate)
-            self.assertEqual(list(op(testIntermediate)),
-                             [('A','C'), ('A','D'), ('B','C'), ('B','D'), ('C','D')])
-
-            self.assertEqual(list(op(combinations(range(4), 3))),
-                             [(0,1,2), (0,1,3), (0,2,3), (1,2,3)])
-            testIntermediate = combinations(range(4), 3)
-            next(testIntermediate)
-            self.assertEqual(list(op(testIntermediate)),
-                             [(0,1,3), (0,2,3), (1,2,3)])
-
         def combinations1(iterable, r):
             'Pure python version shown in the docs'
             pool = tuple(iterable)
@@ -356,9 +281,6 @@ def combinations3(iterable, r):
                 self.assertEqual(result, list(combinations2(values, r))) # matches second pure python version
                 self.assertEqual(result, list(combinations3(values, r))) # matches second pure python version
 
-                for proto in range(pickle.HIGHEST_PROTOCOL + 1):
-                    self.pickletest(proto, combinations(values, r))      # test pickling
-
     @support.bigaddrspacetest
     def test_combinations_overflow(self):
         with self.assertRaises((OverflowError, MemoryError)):
@@ -370,8 +292,6 @@ def test_combinations_tuple_reuse(self):
         self.assertEqual(len(set(map(id, combinations('abcde', 3)))), 1)
         self.assertNotEqual(len(set(map(id, list(combinations('abcde', 3))))), 1)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
-    @pickle_deprecated
     def test_combinations_with_replacement(self):
         cwr = combinations_with_replacement
         self.assertRaises(TypeError, cwr, 'abc')       # missing r argument
@@ -379,15 +299,6 @@ def test_combinations_with_replacement(self):
         self.assertRaises(TypeError, cwr, None)        # pool is not iterable
         self.assertRaises(ValueError, cwr, 'abc', -2)  # r is negative
 
-        for op in [lambda a:a] + picklecopiers:
-            self.assertEqual(list(op(cwr('ABC', 2))),
-                             [('A','A'), ('A','B'), ('A','C'), ('B','B'), ('B','C'), ('C','C')])
-            testIntermediate = cwr('ABC', 2)
-            next(testIntermediate)
-            self.assertEqual(list(op(testIntermediate)),
-                             [('A','B'), ('A','C'), ('B','B'), ('B','C'), ('C','C')])
-
-
         def cwr1(iterable, r):
             'Pure python version shown in the docs'
             # number items returned:  (n+r-1)! / r! / (n-1)! when n>0
@@ -445,23 +356,18 @@ def numcombs(n, r):
                 self.assertEqual(result, list(cwr1(values, r)))         # matches first pure python version
                 self.assertEqual(result, list(cwr2(values, r)))         # matches second pure python version
 
-                for proto in range(pickle.HIGHEST_PROTOCOL + 1):
-                    self.pickletest(proto, cwr(values,r))               # test pickling
-
     @support.bigaddrspacetest
     def test_combinations_with_replacement_overflow(self):
         with self.assertRaises((OverflowError, MemoryError)):
             combinations_with_replacement("AA", 2**30)
 
-        # Test implementation detail:  tuple re-use
+    # Test implementation detail:  tuple re-use
     @support.impl_detail("tuple reuse is specific to CPython")
     def test_combinations_with_replacement_tuple_reuse(self):
         cwr = combinations_with_replacement
         self.assertEqual(len(set(map(id, cwr('abcde', 3)))), 1)
         self.assertNotEqual(len(set(map(id, list(cwr('abcde', 3))))), 1)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
-    @pickle_deprecated
     def test_permutations(self):
         self.assertRaises(TypeError, permutations)              # too few arguments
         self.assertRaises(TypeError, permutations, 'abc', 2, 1) # too many arguments
@@ -522,9 +428,6 @@ def permutations2(iterable, r=None):
                     self.assertEqual(result, list(permutations(values, None))) # test r as None
                     self.assertEqual(result, list(permutations(values)))       # test default r
 
-                for proto in range(pickle.HIGHEST_PROTOCOL + 1):
-                    self.pickletest(proto, permutations(values, r))     # test pickling
-
     @support.bigaddrspacetest
     def test_permutations_overflow(self):
         with self.assertRaises((OverflowError, MemoryError)):
@@ -568,8 +471,6 @@ 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'))
         self.assertEqual(list(compress('ABCDEF', [1,0,1,0,1,1])), list('ACEF'))
@@ -586,25 +487,6 @@ def test_compress(self):
         self.assertRaises(TypeError, compress, range(6))            # too few args
         self.assertRaises(TypeError, compress, range(6), None)      # too many args
 
-        # check copy, deepcopy, pickle
-        for op in [lambda a:copy.copy(a), lambda a:copy.deepcopy(a)] + picklecopiers:
-            for data, selectors, result1, result2 in [
-                ('ABCDEF', [1,0,1,0,1,1], 'ACEF', 'CEF'),
-                ('ABCDEF', [0,0,0,0,0,0], '', ''),
-                ('ABCDEF', [1,1,1,1,1,1], 'ABCDEF', 'BCDEF'),
-                ('ABCDEF', [1,0,1], 'AC', 'C'),
-                ('ABC', [0,1,1,1,1,1], 'BC', 'C'),
-                ]:
-
-                self.assertEqual(list(op(compress(data=data, selectors=selectors))), list(result1))
-                self.assertEqual(list(op(compress(data, selectors))), list(result1))
-                testIntermediate = compress(data, selectors)
-                if result1:
-                    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)])
         self.assertEqual(lzip('abc',count(3)), [('a', 3), ('b', 4), ('c', 5)])
@@ -653,19 +535,10 @@ def test_count(self):
             r2 = 'count(%r)'.__mod__(i)
             self.assertEqual(r1, r2)
 
-        # check copy, deepcopy, pickle
-        for value in -3, 3, maxsize-5, maxsize+5:
-            c = count(value)
-            self.assertEqual(next(copy.copy(c)), value)
-            self.assertEqual(next(copy.deepcopy(c)), value)
-            for proto in range(pickle.HIGHEST_PROTOCOL + 1):
-                self.pickletest(proto, count(value))
-
         #check proper internal error handling for large "step' sizes
         count(1, maxsize+5); sys.exc_info()
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON; 'count(10.5)' != 'count(10.5, 1.0)'
-    @pickle_deprecated
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; 'count(10.5)' != 'count(10.5, 1.0)'
     def test_count_with_step(self):
         self.assertEqual(lzip('abc',count(2,3)), [('a', 2), ('b', 5), ('c', 8)])
         self.assertEqual(lzip('abc',count(start=2,step=3)),
@@ -715,17 +588,6 @@ def test_count_with_step(self):
         c = count(10, 1.0)
         self.assertEqual(type(next(c)), int)
         self.assertEqual(type(next(c)), float)
-        for i in (-sys.maxsize-5, -sys.maxsize+5 ,-10, -1, 0, 10, sys.maxsize-5, sys.maxsize+5):
-            for j in  (-sys.maxsize-5, -sys.maxsize+5 ,-10, -1, 0, 1, 10, sys.maxsize-5, sys.maxsize+5):
-                # Test repr
-                r1 = repr(count(i, j))
-                if j == 1:
-                    r2 = ('count(%r)' % i)
-                else:
-                    r2 = ('count(%r, %r)' % (i, j))
-                self.assertEqual(r1, r2)
-                for proto in range(pickle.HIGHEST_PROTOCOL + 1):
-                    self.pickletest(proto, count(i, j))
 
         c = count(maxsize -2, 2)
         self.assertEqual(repr(c), f'count({maxsize - 2}, 2)')
@@ -770,117 +632,6 @@ def test_cycle(self):
         self.assertRaises(TypeError, cycle, 5)
         self.assertEqual(list(islice(cycle(gen3()),10)), [0,1,2,0,1,2,0,1,2,0])
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
-    @pickle_deprecated
-    def test_cycle_copy_pickle(self):
-        # check copy, deepcopy, pickle
-        c = cycle('abc')
-        self.assertEqual(next(c), 'a')
-        #simple copy currently not supported, because __reduce__ returns
-        #an internal iterator
-        #self.assertEqual(take(10, copy.copy(c)), list('bcabcabcab'))
-        self.assertEqual(take(10, copy.deepcopy(c)), list('bcabcabcab'))
-        for proto in range(pickle.HIGHEST_PROTOCOL + 1):
-            self.assertEqual(take(10, pickle.loads(pickle.dumps(c, proto))),
-                             list('bcabcabcab'))
-            next(c)
-            self.assertEqual(take(10, pickle.loads(pickle.dumps(c, proto))),
-                             list('cabcabcabc'))
-            next(c)
-            next(c)
-        for proto in range(pickle.HIGHEST_PROTOCOL + 1):
-            self.pickletest(proto, cycle('abc'))
-
-        for proto in range(pickle.HIGHEST_PROTOCOL + 1):
-            # test with partial consumed input iterable
-            it = iter('abcde')
-            c = cycle(it)
-            _ = [next(c) for i in range(2)]      # consume 2 of 5 inputs
-            p = pickle.dumps(c, proto)
-            d = pickle.loads(p)                  # rebuild the cycle object
-            self.assertEqual(take(20, d), list('cdeabcdeabcdeabcdeab'))
-
-            # test with completely consumed input iterable
-            it = iter('abcde')
-            c = cycle(it)
-            _ = [next(c) for i in range(7)]      # consume 7 of 5 inputs
-            p = pickle.dumps(c, proto)
-            d = pickle.loads(p)                  # rebuild the cycle object
-            self.assertEqual(take(20, d), list('cdeabcdeabcdeabcdeab'))
-
-    @unittest.expectedFailure # TODO: RUSTPYTHON
-    @pickle_deprecated
-    def test_cycle_unpickle_compat(self):
-        testcases = [
-            b'citertools\ncycle\n(c__builtin__\niter\n((lI1\naI2\naI3\natRI1\nbtR((lI1\naI0\ntb.',
-            b'citertools\ncycle\n(c__builtin__\niter\n(](K\x01K\x02K\x03etRK\x01btR(]K\x01aK\x00tb.',
-            b'\x80\x02citertools\ncycle\nc__builtin__\niter\n](K\x01K\x02K\x03e\x85RK\x01b\x85R]K\x01aK\x00\x86b.',
-            b'\x80\x03citertools\ncycle\ncbuiltins\niter\n](K\x01K\x02K\x03e\x85RK\x01b\x85R]K\x01aK\x00\x86b.',
-            b'\x80\x04\x95=\x00\x00\x00\x00\x00\x00\x00\x8c\titertools\x8c\x05cycle\x93\x8c\x08builtins\x8c\x04iter\x93](K\x01K\x02K\x03e\x85RK\x01b\x85R]K\x01aK\x00\x86b.',
-
-            b'citertools\ncycle\n(c__builtin__\niter\n((lp0\nI1\naI2\naI3\natRI1\nbtR(g0\nI1\ntb.',
-            b'citertools\ncycle\n(c__builtin__\niter\n(]q\x00(K\x01K\x02K\x03etRK\x01btR(h\x00K\x01tb.',
-            b'\x80\x02citertools\ncycle\nc__builtin__\niter\n]q\x00(K\x01K\x02K\x03e\x85RK\x01b\x85Rh\x00K\x01\x86b.',
-            b'\x80\x03citertools\ncycle\ncbuiltins\niter\n]q\x00(K\x01K\x02K\x03e\x85RK\x01b\x85Rh\x00K\x01\x86b.',
-            b'\x80\x04\x95<\x00\x00\x00\x00\x00\x00\x00\x8c\titertools\x8c\x05cycle\x93\x8c\x08builtins\x8c\x04iter\x93]\x94(K\x01K\x02K\x03e\x85RK\x01b\x85Rh\x00K\x01\x86b.',
-
-            b'citertools\ncycle\n(c__builtin__\niter\n((lI1\naI2\naI3\natRI1\nbtR((lI1\naI00\ntb.',
-            b'citertools\ncycle\n(c__builtin__\niter\n(](K\x01K\x02K\x03etRK\x01btR(]K\x01aI00\ntb.',
-            b'\x80\x02citertools\ncycle\nc__builtin__\niter\n](K\x01K\x02K\x03e\x85RK\x01b\x85R]K\x01a\x89\x86b.',
-            b'\x80\x03citertools\ncycle\ncbuiltins\niter\n](K\x01K\x02K\x03e\x85RK\x01b\x85R]K\x01a\x89\x86b.',
-            b'\x80\x04\x95<\x00\x00\x00\x00\x00\x00\x00\x8c\titertools\x8c\x05cycle\x93\x8c\x08builtins\x8c\x04iter\x93](K\x01K\x02K\x03e\x85RK\x01b\x85R]K\x01a\x89\x86b.',
-
-            b'citertools\ncycle\n(c__builtin__\niter\n((lp0\nI1\naI2\naI3\natRI1\nbtR(g0\nI01\ntb.',
-            b'citertools\ncycle\n(c__builtin__\niter\n(]q\x00(K\x01K\x02K\x03etRK\x01btR(h\x00I01\ntb.',
-            b'\x80\x02citertools\ncycle\nc__builtin__\niter\n]q\x00(K\x01K\x02K\x03e\x85RK\x01b\x85Rh\x00\x88\x86b.',
-            b'\x80\x03citertools\ncycle\ncbuiltins\niter\n]q\x00(K\x01K\x02K\x03e\x85RK\x01b\x85Rh\x00\x88\x86b.',
-            b'\x80\x04\x95;\x00\x00\x00\x00\x00\x00\x00\x8c\titertools\x8c\x05cycle\x93\x8c\x08builtins\x8c\x04iter\x93]\x94(K\x01K\x02K\x03e\x85RK\x01b\x85Rh\x00\x88\x86b.',
-        ]
-        assert len(testcases) == 20
-        for t in testcases:
-            it = pickle.loads(t)
-            self.assertEqual(take(10, it), [2, 3, 1, 2, 3, 1, 2, 3, 1, 2])
-
-    @unittest.expectedFailure # TODO: RUSTPYTHON
-    @pickle_deprecated
-    def test_cycle_setstate(self):
-        # Verify both modes for restoring state
-
-        # Mode 0 is efficient.  It uses an incompletely consumed input
-        # iterator to build a cycle object and then passes in state with
-        # a list of previously consumed values.  There is no data
-        # overlap between the two.
-        c = cycle('defg')
-        c.__setstate__((list('abc'), 0))
-        self.assertEqual(take(20, c), list('defgabcdefgabcdefgab'))
-
-        # Mode 1 is inefficient.  It starts with a cycle object built
-        # from an iterator over the remaining elements in a partial
-        # cycle and then passes in state with all of the previously
-        # seen values (this overlaps values included in the iterator).
-        c = cycle('defg')
-        c.__setstate__((list('abcdefg'), 1))
-        self.assertEqual(take(20, c), list('defgabcdefgabcdefgab'))
-
-        # The first argument to setstate needs to be a tuple
-        with self.assertRaises(TypeError):
-            cycle('defg').__setstate__([list('abcdefg'), 0])
-
-        # The first argument in the setstate tuple must be a list
-        with self.assertRaises(TypeError):
-            c = cycle('defg')
-            c.__setstate__((tuple('defg'), 0))
-        take(20, c)
-
-        # The second argument in the setstate tuple must be an int
-        with self.assertRaises(TypeError):
-            cycle('defg').__setstate__((list('abcdefg'), 'x'))
-
-        self.assertRaises(TypeError, cycle('').__setstate__, ())
-        self.assertRaises(TypeError, cycle('').__setstate__, ([],))
-
-    @unittest.expectedFailure # TODO: RUSTPYTHON
-    @pickle_deprecated
     def test_groupby(self):
         # Check whether it accepts arguments correctly
         self.assertEqual([], list(groupby([])))
@@ -899,15 +650,6 @@ def test_groupby(self):
                 dup.append(elem)
         self.assertEqual(s, dup)
 
-        # Check normal pickled
-        for proto in range(pickle.HIGHEST_PROTOCOL + 1):
-            dup = []
-            for k, g in pickle.loads(pickle.dumps(groupby(s, testR), proto)):
-                for elem in g:
-                    self.assertEqual(k, elem[0])
-                    dup.append(elem)
-            self.assertEqual(s, dup)
-
         # Check nested case
         dup = []
         for k, g in groupby(s, testR):
@@ -918,18 +660,6 @@ def test_groupby(self):
                     dup.append(elem)
         self.assertEqual(s, dup)
 
-        # Check nested and pickled
-        for proto in range(pickle.HIGHEST_PROTOCOL + 1):
-            dup = []
-            for k, g in pickle.loads(pickle.dumps(groupby(s, testR), proto)):
-                for ik, ig in pickle.loads(pickle.dumps(groupby(g, testR2), proto)):
-                    for elem in ig:
-                        self.assertEqual(k, elem[0])
-                        self.assertEqual(ik, elem[2])
-                        dup.append(elem)
-            self.assertEqual(s, dup)
-
-
         # Check case where inner iterator is not used
         keys = [k for k, g in groupby(s, testR)]
         expectedkeys = set([r[0] for r in s])
@@ -949,13 +679,6 @@ def test_groupby(self):
         list(it)  # exhaust the groupby iterator
         self.assertEqual(list(g3), [])
 
-        for proto in range(pickle.HIGHEST_PROTOCOL + 1):
-            it = groupby(s, testR)
-            _, g = next(it)
-            next(it)
-            next(it)
-            self.assertEqual(list(pickle.loads(pickle.dumps(g, proto))), [])
-
         # Exercise pipes and filters style
         s = 'abracadabra'
         # sort s | uniq
@@ -1038,8 +761,6 @@ 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])
         self.assertEqual(list(filterfalse(None, [0,1,0,2,0])), [0,0,0])
@@ -1050,8 +771,6 @@ def test_filterfalse(self):
         self.assertRaises(TypeError, filterfalse, lambda x:x, range(6), 7)
         self.assertRaises(TypeError, filterfalse, isEven, 3)
         self.assertRaises(TypeError, next, filterfalse(range(6), range(6)))
-        for proto in range(pickle.HIGHEST_PROTOCOL + 1):
-            self.pickletest(proto, filterfalse(isEven, range(6)))
 
     def test_zip(self):
         # XXX This is rather silly now that builtin zip() calls zip()...
@@ -1070,33 +789,12 @@ def test_zip(self):
                          lzip('abc', 'def'))
 
     @support.impl_detail("tuple reuse is specific to CPython")
-    @pickle_deprecated
     def test_zip_tuple_reuse(self):
         ids = list(map(id, zip('abc', 'def')))
         self.assertEqual(min(ids), max(ids))
         ids = list(map(id, list(zip('abc', 'def'))))
         self.assertEqual(len(dict.fromkeys(ids)), len(ids))
 
-        # check copy, deepcopy, pickle
-        ans = [(x,y) for x, y in copy.copy(zip('abc',count()))]
-        self.assertEqual(ans, [('a', 0), ('b', 1), ('c', 2)])
-
-        ans = [(x,y) for x, y in copy.deepcopy(zip('abc',count()))]
-        self.assertEqual(ans, [('a', 0), ('b', 1), ('c', 2)])
-
-        for proto in range(pickle.HIGHEST_PROTOCOL + 1):
-            ans = [(x,y) for x, y in pickle.loads(pickle.dumps(zip('abc',count()), proto))]
-            self.assertEqual(ans, [('a', 0), ('b', 1), ('c', 2)])
-
-        for proto in range(pickle.HIGHEST_PROTOCOL + 1):
-            testIntermediate = zip('abc',count())
-            next(testIntermediate)
-            ans = [(x,y) for x, y in pickle.loads(pickle.dumps(testIntermediate, proto))]
-            self.assertEqual(ans, [('b', 1), ('c', 2)])
-
-        for proto in range(pickle.HIGHEST_PROTOCOL + 1):
-            self.pickletest(proto, zip('abc', count()))
-
     def test_ziplongest(self):
         for args in [
                 ['abc', range(6)],
@@ -1146,15 +844,6 @@ 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):
-            self.pickletest(proto, zip_longest("abc", "def"))
-            self.pickletest(proto, zip_longest("abc", "defgh"))
-            self.pickletest(proto, zip_longest("abc", "defgh", fillvalue=1))
-            self.pickletest(proto, zip_longest("", "defgh"))
-
     def test_zip_longest_bad_iterable(self):
         exception = TypeError()
 
@@ -1370,37 +1059,6 @@ 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
-        for args, result in [
-            ([], [()]),                     # zero iterables
-            (['ab'], [('a',), ('b',)]),     # one iterable
-            ([range(2), range(3)], [(0,0), (0,1), (0,2), (1,0), (1,1), (1,2)]),     # two iterables
-            ([range(0), range(2), range(3)], []),           # first iterable with zero length
-            ([range(2), range(0), range(3)], []),           # middle iterable with zero length
-            ([range(2), range(3), range(0)], []),           # last iterable with zero length
-            ]:
-            self.assertEqual(list(copy.copy(product(*args))), result)
-            self.assertEqual(list(copy.deepcopy(product(*args))), result)
-            for proto in range(pickle.HIGHEST_PROTOCOL + 1):
-                self.pickletest(proto, product(*args))
-
-    @unittest.expectedFailure # TODO: RUSTPYTHON
-    @pickle_deprecated
-    def test_product_issue_25021(self):
-        # test that indices are properly clamped to the length of the tuples
-        p = product((1, 2),(3,))
-        p.__setstate__((0, 0x1000))  # will access tuple element 1 if not clamped
-        self.assertEqual(next(p), (2, 3))
-        # test that empty tuple in the list will result in an immediate StopIteration
-        p = product((1, 2), (), (3,))
-        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'])
         self.assertEqual(lzip(range(3),repeat('a')),
@@ -1419,22 +1077,13 @@ def test_repeat(self):
         list(r)
         self.assertEqual(repr(r), 'repeat((1+0j), 0)')
 
-        # check copy, deepcopy, pickle
-        c = repeat(object='a', times=10)
-        self.assertEqual(next(c), 'a')
-        self.assertEqual(take(2, copy.copy(c)), list('a' * 2))
-        self.assertEqual(take(2, copy.deepcopy(c)), list('a' * 2))
-        for proto in range(pickle.HIGHEST_PROTOCOL + 1):
-            self.pickletest(proto, repeat(object='a', times=10))
-
     def test_repeat_with_negative_times(self):
         self.assertEqual(repr(repeat('a', -1)), "repeat('a', 0)")
         self.assertEqual(repr(repeat('a', -2)), "repeat('a', 0)")
         self.assertEqual(repr(repeat('a', times=-1)), "repeat('a', 0)")
         self.assertEqual(repr(repeat('a', times=-2)), "repeat('a', 0)")
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
-    @pickle_deprecated
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_map(self):
         self.assertEqual(list(map(operator.pow, range(3), range(1,7))),
                          [0**1, 1**2, 2**3])
@@ -1452,21 +1101,6 @@ def test_map(self):
         self.assertRaises(ValueError, next, map(errfunc, [4], [5]))
         self.assertRaises(TypeError, next, map(onearg, [4], [5]))
 
-        # check copy, deepcopy, pickle
-        ans = [('a',0),('b',1),('c',2)]
-
-        c = map(tupleize, 'abc', count())
-        self.assertEqual(list(copy.copy(c)), ans)
-
-        c = map(tupleize, 'abc', count())
-        self.assertEqual(list(copy.deepcopy(c)), ans)
-
-        for proto in range(pickle.HIGHEST_PROTOCOL + 1):
-            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)))),
                          [0**1, 1**2, 2**3])
@@ -1481,21 +1115,7 @@ def test_starmap(self):
         self.assertRaises(ValueError, next, starmap(errfunc, [(4,5)]))
         self.assertRaises(TypeError, next, starmap(onearg, [(4,5)]))
 
-        # check copy, deepcopy, pickle
-        ans = [0**1, 1**2, 2**3]
-
-        c = starmap(operator.pow, zip(range(3), range(1,7)))
-        self.assertEqual(list(copy.copy(c)), ans)
-
-        c = starmap(operator.pow, zip(range(3), range(1,7)))
-        self.assertEqual(list(copy.deepcopy(c)), ans)
-
-        for proto in range(pickle.HIGHEST_PROTOCOL + 1):
-            c = starmap(operator.pow, zip(range(3), range(1,7)))
-            self.pickletest(proto, c)
-
-    @unittest.expectedFailure # TODO: RUSTPYTHON
-    @pickle_deprecated
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_islice(self):
         for args in [          # islice(args) should agree with range(args)
                 (10, 20, 3),
@@ -1552,21 +1172,6 @@ def test_islice(self):
         self.assertEqual(list(islice(c, 1, 3, 50)), [1])
         self.assertEqual(next(c), 3)
 
-        # check copy, deepcopy, pickle
-        for args in [          # islice(args) should agree with range(args)
-                (10, 20, 3),
-                (10, 3, 20),
-                (10, 20),
-                (10, 3),
-                (20,)
-                ]:
-            self.assertEqual(list(copy.copy(islice(range(100), *args))),
-                             list(range(*args)))
-            self.assertEqual(list(copy.deepcopy(islice(range(100), *args))),
-                             list(range(*args)))
-            for proto in range(pickle.HIGHEST_PROTOCOL + 1):
-                self.pickletest(proto, islice(range(100), *args))
-
         # Issue #21321: check source iterator is not referenced
         # from islice() after the latter has been exhausted
         it = (x for x in (1, 2))
@@ -1590,8 +1195,6 @@ 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]
         self.assertEqual(list(takewhile(underten, data)), [1, 3, 5])
@@ -1605,15 +1208,7 @@ def test_takewhile(self):
         self.assertEqual(list(t), [1, 1, 1])
         self.assertRaises(StopIteration, next, t)
 
-        # check copy, deepcopy, pickle
-        self.assertEqual(list(copy.copy(takewhile(underten, data))), [1, 3, 5])
-        self.assertEqual(list(copy.deepcopy(takewhile(underten, data))),
-                        [1, 3, 5])
-        for proto in range(pickle.HIGHEST_PROTOCOL + 1):
-            self.pickletest(proto, takewhile(underten, data))
-
-    @unittest.expectedFailure # TODO: RUSTPYTHON
-    @pickle_deprecated
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_dropwhile(self):
         data = [1, 3, 5, 20, 2, 4, 6, 8]
         self.assertEqual(list(dropwhile(underten, data)), [20, 2, 4, 6, 8])
@@ -1624,15 +1219,7 @@ def test_dropwhile(self):
         self.assertRaises(TypeError, next, dropwhile(10, [(4,5)]))
         self.assertRaises(ValueError, next, dropwhile(errfunc, [(4,5)]))
 
-        # check copy, deepcopy, pickle
-        self.assertEqual(list(copy.copy(dropwhile(underten, data))), [20, 2, 4, 6, 8])
-        self.assertEqual(list(copy.deepcopy(dropwhile(underten, data))),
-                        [20, 2, 4, 6, 8])
-        for proto in range(pickle.HIGHEST_PROTOCOL + 1):
-            self.pickletest(proto, dropwhile(underten, data))
-
-    @unittest.expectedFailure # TODO: RUSTPYTHON
-    @pickle_deprecated
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_tee(self):
         n = 200
 
@@ -1713,7 +1300,7 @@ def test_tee(self):
         t3 = tnew(t1)
         self.assertTrue(list(t1) == list(t2) == list(t3) == list('abc'))
 
-        # test that tee objects are weak referencable
+        # test that tee objects are weak referenceable
         a, b = tee(range(10))
         p = weakref.proxy(a)
         self.assertEqual(getattr(p, '__class__'), type(b))
@@ -1748,41 +1335,6 @@ def test_tee(self):
         self.assertEqual(list(a), long_ans[100:])
         self.assertEqual(list(b), long_ans[60:])
 
-        # check deepcopy
-        a, b = tee('abc')
-        self.assertEqual(list(copy.deepcopy(a)), ans)
-        self.assertEqual(list(copy.deepcopy(b)), ans)
-        self.assertEqual(list(a), ans)
-        self.assertEqual(list(b), ans)
-        a, b = tee(range(10000))
-        self.assertEqual(list(copy.deepcopy(a)), long_ans)
-        self.assertEqual(list(copy.deepcopy(b)), long_ans)
-        self.assertEqual(list(a), long_ans)
-        self.assertEqual(list(b), long_ans)
-
-        # check partially consumed deepcopy
-        a, b = tee('abc')
-        take(2, a)
-        take(1, b)
-        self.assertEqual(list(copy.deepcopy(a)), ans[2:])
-        self.assertEqual(list(copy.deepcopy(b)), ans[1:])
-        self.assertEqual(list(a), ans[2:])
-        self.assertEqual(list(b), ans[1:])
-        a, b = tee(range(10000))
-        take(100, a)
-        take(60, b)
-        self.assertEqual(list(copy.deepcopy(a)), long_ans[100:])
-        self.assertEqual(list(copy.deepcopy(b)), long_ans[60:])
-        self.assertEqual(list(a), long_ans[100:])
-        self.assertEqual(list(b), long_ans[60:])
-
-        # check pickle
-        for proto in range(pickle.HIGHEST_PROTOCOL + 1):
-            self.pickletest(proto, iter(tee('abc')))
-            a, b = tee('abc')
-            self.pickletest(proto, a, compare=ans)
-            self.pickletest(proto, b, compare=ans)
-
     def test_tee_dealloc_segfault(self):
         # gh-115874: segfaults when accessing module state in tp_dealloc.
         script = (
@@ -1950,35 +1502,6 @@ 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
-        data = [1, 2, 3, 4, 5]
-        accumulated = [1, 3, 6, 10, 15]
-
-        for proto in range(pickle.HIGHEST_PROTOCOL + 1):
-            it = accumulate(data)
-            self.assertEqual(list(pickle.loads(pickle.dumps(it, proto))), accumulated[:])
-            self.assertEqual(next(it), 1)
-            self.assertEqual(list(pickle.loads(pickle.dumps(it, proto))), accumulated[1:])
-        it = accumulate(data)
-        self.assertEqual(next(it), 1)
-        self.assertEqual(list(copy.deepcopy(it)), accumulated[1:])
-        self.assertEqual(list(copy.copy(it)), accumulated[1:])
-
-    @unittest.expectedFailure # TODO: RUSTPYTHON
-    @pickle_deprecated
-    def test_accumulate_reducible_none(self):
-        # Issue #25718: total is None
-        it = accumulate([None, None, None], operator.is_)
-        self.assertEqual(next(it), None)
-        for proto in range(pickle.HIGHEST_PROTOCOL + 1):
-            it_copy = pickle.loads(pickle.dumps(it, proto))
-            self.assertEqual(list(it_copy), [True, False])
-        self.assertEqual(list(copy.deepcopy(it)), [True, False])
-        self.assertEqual(list(copy.copy(it)), [True, False])
-
     def test_chain(self):
         self.assertEqual(''.join(chain('ABC', 'DEF')), 'ABCDEF')
 
@@ -2086,27 +1609,169 @@ def batched_recipe(iterable, n):
                 self.assertEqual(r1, r2)
                 self.assertEqual(e1, e2)
 
+
+    def test_groupby_recipe(self):
+
+        # Begin groupby() recipe #######################################
+
+        def groupby(iterable, key=None):
+            # [k for k, g in groupby('AAAABBBCCDAABBB')] → A B C D A B
+            # [list(g) for k, g in groupby('AAAABBBCCD')] → AAAA BBB CC D
+
+            keyfunc = (lambda x: x) if key is None else key
+            iterator = iter(iterable)
+            exhausted = False
+
+            def _grouper(target_key):
+                nonlocal curr_value, curr_key, exhausted
+                yield curr_value
+                for curr_value in iterator:
+                    curr_key = keyfunc(curr_value)
+                    if curr_key != target_key:
+                        return
+                    yield curr_value
+                exhausted = True
+
+            try:
+                curr_value = next(iterator)
+            except StopIteration:
+                return
+            curr_key = keyfunc(curr_value)
+
+            while not exhausted:
+                target_key = curr_key
+                curr_group = _grouper(target_key)
+                yield curr_key, curr_group
+                if curr_key == target_key:
+                    for _ in curr_group:
+                        pass
+
+        # End groupby() recipe #########################################
+
+        # Check whether it accepts arguments correctly
+        self.assertEqual([], list(groupby([])))
+        self.assertEqual([], list(groupby([], key=id)))
+        self.assertRaises(TypeError, list, groupby('abc', []))
+        if False:
+            # Test not applicable to the recipe
+            self.assertRaises(TypeError, list, groupby('abc', None))
+        self.assertRaises(TypeError, groupby, 'abc', lambda x:x, 10)
+
+        # Check normal input
+        s = [(0, 10, 20), (0, 11,21), (0,12,21), (1,13,21), (1,14,22),
+             (2,15,22), (3,16,23), (3,17,23)]
+        dup = []
+        for k, g in groupby(s, lambda r:r[0]):
+            for elem in g:
+                self.assertEqual(k, elem[0])
+                dup.append(elem)
+        self.assertEqual(s, dup)
+
+        # Check nested case
+        dup = []
+        for k, g in groupby(s, testR):
+            for ik, ig in groupby(g, testR2):
+                for elem in ig:
+                    self.assertEqual(k, elem[0])
+                    self.assertEqual(ik, elem[2])
+                    dup.append(elem)
+        self.assertEqual(s, dup)
+
+        # Check case where inner iterator is not used
+        keys = [k for k, g in groupby(s, testR)]
+        expectedkeys = set([r[0] for r in s])
+        self.assertEqual(set(keys), expectedkeys)
+        self.assertEqual(len(keys), len(expectedkeys))
+
+        # Check case where inner iterator is used after advancing the groupby
+        # iterator
+        s = list(zip('AABBBAAAA', range(9)))
+        it = groupby(s, testR)
+        _, g1 = next(it)
+        _, g2 = next(it)
+        _, g3 = next(it)
+        self.assertEqual(list(g1), [])
+        self.assertEqual(list(g2), [])
+        self.assertEqual(next(g3), ('A', 5))
+        list(it)  # exhaust the groupby iterator
+        self.assertEqual(list(g3), [])
+
+        # Exercise pipes and filters style
+        s = 'abracadabra'
+        # sort s | uniq
+        r = [k for k, g in groupby(sorted(s))]
+        self.assertEqual(r, ['a', 'b', 'c', 'd', 'r'])
+        # sort s | uniq -d
+        r = [k for k, g in groupby(sorted(s)) if list(islice(g,1,2))]
+        self.assertEqual(r, ['a', 'b', 'r'])
+        # sort s | uniq -c
+        r = [(len(list(g)), k) for k, g in groupby(sorted(s))]
+        self.assertEqual(r, [(5, 'a'), (2, 'b'), (1, 'c'), (1, 'd'), (2, 'r')])
+        # sort s | uniq -c | sort -rn | head -3
+        r = sorted([(len(list(g)) , k) for k, g in groupby(sorted(s))], reverse=True)[:3]
+        self.assertEqual(r, [(5, 'a'), (2, 'r'), (2, 'b')])
+
+        # iter.__next__ failure
+        class ExpectedError(Exception):
+            pass
+        def delayed_raise(n=0):
+            for i in range(n):
+                yield 'yo'
+            raise ExpectedError
+        def gulp(iterable, keyp=None, func=list):
+            return [func(g) for k, g in groupby(iterable, keyp)]
+
+        # iter.__next__ failure on outer object
+        self.assertRaises(ExpectedError, gulp, delayed_raise(0))
+        # iter.__next__ failure on inner object
+        self.assertRaises(ExpectedError, gulp, delayed_raise(1))
+
+        # __eq__ failure
+        class DummyCmp:
+            def __eq__(self, dst):
+                raise ExpectedError
+        s = [DummyCmp(), DummyCmp(), None]
+
+        # __eq__ failure on outer object
+        self.assertRaises(ExpectedError, gulp, s, func=id)
+        # __eq__ failure on inner object
+        self.assertRaises(ExpectedError, gulp, s)
+
+        # keyfunc failure
+        def keyfunc(obj):
+            if keyfunc.skip > 0:
+                keyfunc.skip -= 1
+                return obj
+            else:
+                raise ExpectedError
+
+        # keyfunc failure on outer object
+        keyfunc.skip = 0
+        self.assertRaises(ExpectedError, gulp, [None], keyfunc)
+        keyfunc.skip = 1
+        self.assertRaises(ExpectedError, gulp, [None, None], keyfunc)
+
+
     @staticmethod
     def islice(iterable, *args):
+        # islice('ABCDEFG', 2) → A B
+        # islice('ABCDEFG', 2, 4) → C D
+        # islice('ABCDEFG', 2, None) → C D E F G
+        # islice('ABCDEFG', 0, None, 2) → A C E G
+
         s = slice(*args)
-        start, stop, step = s.start or 0, s.stop or sys.maxsize, s.step or 1
-        it = iter(range(start, stop, step))
-        try:
-            nexti = next(it)
-        except StopIteration:
-            # Consume *iterable* up to the *start* position.
-            for i, element in zip(range(start), iterable):
-                pass
-            return
-        try:
-            for i, element in enumerate(iterable):
-                if i == nexti:
-                    yield element
-                    nexti = next(it)
-        except StopIteration:
-            # Consume to *stop*.
-            for i, element in zip(range(i + 1, stop), iterable):
-                pass
+        start = 0 if s.start is None else s.start
+        stop = s.stop
+        step = 1 if s.step is None else s.step
+        if start < 0 or (stop is not None and stop < 0) or step <= 0:
+            raise ValueError
+
+        indices = count() if stop is None else range(max(start, stop))
+        next_i = start
+        for i, element in zip(indices, iterable):
+            if i == next_i:
+                yield element
+                next_i += step
 
     def test_islice_recipe(self):
         self.assertEqual(list(self.islice('ABCDEFG', 2)), list('AB'))
@@ -2778,7 +2443,7 @@ def __eq__(self, other):
 
 
 class SubclassWithKwargsTest(unittest.TestCase):
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_keywords_in_subclass(self):
         # count is not subclassable...
         testcases = [
@@ -2806,10 +2471,10 @@ class subclass(cls):
                     subclass(*args, newarg=3)
 
         for cls, args, result in testcases:
-            # Constructors of repeat, zip, compress accept keyword arguments.
+            # Constructors of repeat, zip, map, compress accept keyword arguments.
             # Their subclasses need overriding __new__ to support new
             # keyword arguments.
-            if cls in [repeat, zip, compress]:
+            if cls in [repeat, zip, map, compress]:
                 continue
             with self.subTest(cls):
                 class subclass_with_init(cls):
diff --git a/Lib/test/test_json/__init__.py b/Lib/test/test_json/__init__.py
index 7091364cddb..41c06beaa38 100644
--- a/Lib/test/test_json/__init__.py
+++ b/Lib/test/test_json/__init__.py
@@ -41,7 +41,7 @@ def test_pyjson(self):
                          'json.encoder')
 
 class TestCTest(CTest):
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @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 b6531b237c0..7b3b30ce449 100644
--- a/Lib/test/test_json/test_decode.py
+++ b/Lib/test/test_json/test_decode.py
@@ -4,7 +4,7 @@
 from test.test_json import PyTest, CTest
 from test import support
 
-import unittest # XXX: RUSTPYTHON; importing to be able to skip tests
+import unittest  # XXX: RUSTPYTHON; importing to be able to skip tests
 
 
 class TestDecode:
@@ -18,7 +18,7 @@ def test_float(self):
         self.assertIsInstance(rval, float)
         self.assertEqual(rval, 1.0)
 
-    @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"]:
@@ -135,9 +135,7 @@ def test_limit_int(self):
 
 
 class TestPyDecode(TestDecode, PyTest): pass
-
 class TestCDecode(TestDecode, CTest):
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_limit_int(self):
         return super().test_limit_int()
diff --git a/Lib/test/test_json/test_default.py b/Lib/test/test_json/test_default.py
index b576947c4f2..4d569dadfa4 100644
--- a/Lib/test/test_json/test_default.py
+++ b/Lib/test/test_json/test_default.py
@@ -1,7 +1,8 @@
 import collections
-import unittest # XXX: RUSTPYTHON; importing to be able to skip tests
 from test.test_json import PyTest, CTest
 
+import unittest  # XXX: RUSTPYTHON; importing to be able to skip tests
+
 
 class TestDefault:
     def test_default(self):
@@ -9,8 +10,7 @@ def test_default(self):
             self.dumps(type, default=repr),
             self.dumps(repr(type)))
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_bad_default(self):
         def default(obj):
             if obj is NotImplemented:
diff --git a/Lib/test/test_json/test_fail.py b/Lib/test/test_json/test_fail.py
index cb88e317b4e..4adfcb17c4d 100644
--- a/Lib/test/test_json/test_fail.py
+++ b/Lib/test/test_json/test_fail.py
@@ -1,7 +1,7 @@
-import unittest # XXX: RUSTPYTHON; importing to be able to skip tests
-
 from test.test_json import PyTest, CTest
 
+import unittest  # XXX: RUSTPYTHON; importing to be able to skip tests
+
 # 2007-10-05
 JSONDOCS = [
     # https://json.org/JSON_checker/test/fail1.json
@@ -239,9 +239,7 @@ def test_linecol(self):
                              (line, col, idx))
 
 class TestPyFail(TestFail, PyTest): pass
-
 class TestCFail(TestFail, CTest):
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_failures(self):
         return super().test_failures()
diff --git a/Lib/test/test_json/test_recursion.py b/Lib/test/test_json/test_recursion.py
index 2a24edef629..2fa8d3f528c 100644
--- a/Lib/test/test_json/test_recursion.py
+++ b/Lib/test/test_json/test_recursion.py
@@ -1,7 +1,7 @@
 from test import support
 from test.test_json import PyTest, CTest
 
-import unittest # XXX: RUSTPYTHON; importing to be able to skip tests
+import unittest  # XXX: RUSTPYTHON; importing to be able to skip tests
 
 
 class JSONTestObject:
@@ -70,13 +70,12 @@ def default(self, o):
             self.fail("didn't raise ValueError on default recursion")
 
 
-    # TODO: RUSTPYTHON
-    @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()
+    @unittest.skip("TODO: RUSTPYTHON; crashes")
+    @support.skip_if_unlimited_stack_size
+    @support.skip_emscripten_stack_overflow()
+    @support.skip_wasi_stack_overflow()
     def test_highly_nested_objects_decoding(self):
-        very_deep = 200000
+        very_deep = 500_000
         # test that loading highly-nested objects doesn't segfault when C
         # accelerations are used. See #12017
         with self.assertRaises(RecursionError):
@@ -89,14 +88,14 @@ def test_highly_nested_objects_decoding(self):
             with support.infinite_recursion():
                 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.skip_if_unlimited_stack_size
+    @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(200_000):
+        for x in range(500_000):
             l, d = [l], {'k':d}
         with self.assertRaises(RecursionError):
             with support.infinite_recursion(5000):
@@ -105,9 +104,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()
+    @support.skip_if_unlimited_stack_size
+    @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 c7fc30f2235..e77ec152280 100644
--- a/Lib/test/test_json/test_scanstring.py
+++ b/Lib/test/test_json/test_scanstring.py
@@ -1,7 +1,7 @@
 import sys
 from test.test_json import PyTest, CTest
 
-import unittest # XXX: RUSTPYTHON; importing to be able to skip tests
+import unittest  # XXX: RUSTPYTHON; importing to be able to skip tests
 
 
 class TestScanstring:
@@ -144,7 +144,7 @@ def test_bad_escapes(self):
             with self.assertRaises(self.JSONDecodeError, msg=s):
                 scanstring(s, 1, True)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @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 25b51b307e1..370a2539d10 100644
--- a/Lib/test/test_json/test_speedups.py
+++ b/Lib/test/test_json/test_speedups.py
@@ -1,6 +1,6 @@
 from test.test_json import CTest
 
-import unittest # XXX: RUSTPYTHON; importing to be able to skip tests
+import unittest  # XXX: RUSTPYTHON; importing to be able to skip tests
 
 
 class BadBool:
@@ -40,7 +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)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON; TypeError: 'NoneType' object is not callable
+    @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.
@@ -62,7 +62,7 @@ def bad_encoder2(*args):
         with self.assertRaises(ZeroDivisionError):
             enc('spam', 4)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_bad_markers_argument_to_encoder(self):
         # https://bugs.python.org/issue45269
         with self.assertRaisesRegex(
@@ -72,7 +72,7 @@ def test_bad_markers_argument_to_encoder(self):
             self.json.encoder.c_make_encoder(1, None, None, None, ': ', ', ',
                                              False, False, False)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON; ZeroDivisionError not raised by test
+    @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})
@@ -85,3 +85,35 @@ def test(name):
     def test_unsortable_keys(self):
         with self.assertRaises(TypeError):
             self.json.encoder.JSONEncoder(sort_keys=True).encode({'a': 1, 1: 'a'})
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; TypeError: 'NoneType' object is not callable
+    def test_current_indent_level(self):
+        enc = self.json.encoder.c_make_encoder(
+            markers=None,
+            default=str,
+            encoder=self.json.encoder.c_encode_basestring,
+            indent='\t',
+            key_separator=': ',
+            item_separator=', ',
+            sort_keys=False,
+            skipkeys=False,
+            allow_nan=False)
+        expected = (
+            '[\n'
+            '\t"spam", \n'
+            '\t{\n'
+            '\t\t"ham": "eggs"\n'
+            '\t}\n'
+            ']')
+        self.assertEqual(enc(['spam', {'ham': 'eggs'}], 0)[0], expected)
+        self.assertEqual(enc(['spam', {'ham': 'eggs'}], -3)[0], expected)
+        expected2 = (
+            '[\n'
+            '\t\t\t\t"spam", \n'
+            '\t\t\t\t{\n'
+            '\t\t\t\t\t"ham": "eggs"\n'
+            '\t\t\t\t}\n'
+            '\t\t\t]')
+        self.assertEqual(enc(['spam', {'ham': 'eggs'}], 3)[0], expected2)
+        self.assertRaises(TypeError, enc, ['spam', {'ham': 'eggs'}], 3.0)
+        self.assertRaises(TypeError, enc, ['spam', {'ham': 'eggs'}])
diff --git a/Lib/test/test_json/test_tool.py b/Lib/test/test_json/test_tool.py
index 068a7acb651..7b5d217a215 100644
--- a/Lib/test/test_json/test_tool.py
+++ b/Lib/test/test_json/test_tool.py
@@ -6,22 +6,14 @@
 import subprocess
 
 from test import support
-from test.support import force_not_colorized, os_helper
+from test.support import force_colorized, 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()
+@support.skip_if_pgo_task
 class TestMain(unittest.TestCase):
     data = """
 
@@ -328,6 +320,7 @@ def test_colors(self):
 
 
 @support.requires_subprocess()
+@support.skip_if_pgo_task
 class TestTool(TestMain):
     module = 'json.tool'
 
diff --git a/Lib/test/test_json/test_unicode.py b/Lib/test/test_json/test_unicode.py
index 2118c9827ea..ab1be6ea6e8 100644
--- a/Lib/test/test_json/test_unicode.py
+++ b/Lib/test/test_json/test_unicode.py
@@ -2,7 +2,7 @@
 from collections import OrderedDict
 from test.test_json import PyTest, CTest
 
-import unittest # XXX: RUSTPYTHON; importing to be able to skip tests
+import unittest  # XXX: RUSTPYTHON; importing to be able to skip tests
 
 
 class TestUnicode:
@@ -94,7 +94,6 @@ def test_bytes_encode(self):
         self.assertRaises(TypeError, self.dumps, b"hi")
         self.assertRaises(TypeError, self.dumps, [b"hi"])
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_bytes_decode(self):
         for encoding, bom in [
                 ('utf-8', codecs.BOM_UTF8),
@@ -138,19 +137,15 @@ def test_object_pairs_hook_with_unicode(self):
 
 
 class TestPyUnicode(TestUnicode, PyTest): pass
-
 class TestCUnicode(TestUnicode, CTest):
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     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()
diff --git a/Lib/test/test_keywordonlyarg.py b/Lib/test/test_keywordonlyarg.py
index 8fd2e89122f..918f953cae5 100644
--- a/Lib/test/test_keywordonlyarg.py
+++ b/Lib/test/test_keywordonlyarg.py
@@ -156,7 +156,6 @@ def test_issue13343(self):
         # used to fail with a SystemError.
         lambda *, k1=unittest: None
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_mangling(self):
         class X:
             def f(self, *, __a=42):
diff --git a/Lib/test/test_largefile.py b/Lib/test/test_largefile.py
index 3c11c59baef..41f7b70e5cf 100644
--- a/Lib/test/test_largefile.py
+++ b/Lib/test/test_largefile.py
@@ -2,13 +2,12 @@
 """
 
 import os
-import stat
 import sys
 import unittest
 import socket
 import shutil
 import threading
-from test.support import requires, bigmemtest
+from test.support import requires, bigmemtest, requires_resource
 from test.support import SHORT_TIMEOUT
 from test.support import socket_helper
 from test.support.os_helper import TESTFN, unlink
@@ -29,7 +28,7 @@ def setUp(self):
             mode = 'w+b'
 
         with self.open(TESTFN, mode) as f:
-            current_size = os.fstat(f.fileno())[stat.ST_SIZE]
+            current_size = os.fstat(f.fileno()).st_size
             if current_size == size+1:
                 return
 
@@ -40,13 +39,13 @@ def setUp(self):
             f.seek(size)
             f.write(b'a')
             f.flush()
-            self.assertEqual(os.fstat(f.fileno())[stat.ST_SIZE], size+1)
+            self.assertEqual(os.fstat(f.fileno()).st_size, size+1)
 
     @classmethod
     def tearDownClass(cls):
         with cls.open(TESTFN, 'wb'):
             pass
-        if not os.stat(TESTFN)[stat.ST_SIZE] == 0:
+        if not os.stat(TESTFN).st_size == 0:
             raise cls.failureException('File was not truncated by opening '
                                        'with mode "wb"')
         unlink(TESTFN2)
@@ -67,7 +66,7 @@ def test_large_read(self, _size):
             self.assertEqual(f.tell(), size + 1)
 
     def test_osstat(self):
-        self.assertEqual(os.stat(TESTFN)[stat.ST_SIZE], size+1)
+        self.assertEqual(os.stat(TESTFN).st_size, size+1)
 
     def test_seek_read(self):
         with self.open(TESTFN, 'rb') as f:
@@ -142,6 +141,9 @@ def test_truncate(self):
             f.truncate(1)
             self.assertEqual(f.tell(), 0)       # else pointer moved
             f.seek(0)
+            # Verify readall on a truncated file is well behaved. read()
+            # without a size can be unbounded, this should get just the byte
+            # that remains.
             self.assertEqual(len(f.read()), 1)  # else wasn't truncated
 
     def test_seekable(self):
@@ -152,6 +154,22 @@ def test_seekable(self):
                 f.seek(pos)
                 self.assertTrue(f.seekable())
 
+    @bigmemtest(size=size, memuse=2, dry_run=False)
+    def test_seek_readall(self, _size):
+        # Seek which doesn't change position should readall successfully.
+        with self.open(TESTFN, 'rb') as f:
+            self.assertEqual(f.seek(0, os.SEEK_CUR), 0)
+            self.assertEqual(len(f.read()), size + 1)
+
+        # Seek which changes (or might change) position should readall
+        # successfully.
+        with self.open(TESTFN, 'rb') as f:
+            self.assertEqual(f.seek(20, os.SEEK_SET), 20)
+            self.assertEqual(len(f.read()), size - 19)
+
+        with self.open(TESTFN, 'rb') as f:
+            self.assertEqual(f.seek(-3, os.SEEK_END), size - 2)
+            self.assertEqual(len(f.read()), 3)
 
 def skip_no_disk_space(path, required):
     def decorator(fun):
@@ -173,6 +191,7 @@ class TestCopyfile(LargeFileTest, unittest.TestCase):
     # Exact required disk space would be (size * 2), but let's give it a
     # bit more tolerance.
     @skip_no_disk_space(TESTFN, size * 2.5)
+    @requires_resource('cpu')
     def test_it(self):
         # Internally shutil.copyfile() can use "fast copy" methods like
         # os.sendfile().
@@ -222,6 +241,7 @@ def run(sock):
     # Exact required disk space would be (size * 2), but let's give it a
     # bit more tolerance.
     @skip_no_disk_space(TESTFN, size * 2.5)
+    @requires_resource('cpu')
     def test_it(self):
         port = socket_helper.find_unused_port()
         with socket.create_server(("", port)) as sock:
diff --git a/Lib/test/test_launcher.py b/Lib/test/test_launcher.py
new file mode 100644
index 00000000000..caa1603c78e
--- /dev/null
+++ b/Lib/test/test_launcher.py
@@ -0,0 +1,796 @@
+import contextlib
+import itertools
+import os
+import re
+import shutil
+import subprocess
+import sys
+import sysconfig
+import tempfile
+import unittest
+from pathlib import Path
+from test import support
+
+if sys.platform != "win32":
+    raise unittest.SkipTest("test only applies to Windows")
+
+# Get winreg after the platform check
+import winreg
+
+
+PY_EXE = "py.exe"
+DEBUG_BUILD = False
+if sys.executable.casefold().endswith("_d.exe".casefold()):
+    PY_EXE = "py_d.exe"
+    DEBUG_BUILD = True
+
+# Registry data to create. On removal, everything beneath top-level names will
+# be deleted.
+TEST_DATA = {
+    "PythonTestSuite": {
+        "DisplayName": "Python Test Suite",
+        "SupportUrl": "https://www.python.org/",
+        "3.100": {
+            "DisplayName": "X.Y version",
+            "InstallPath": {
+                None: sys.prefix,
+                "ExecutablePath": "X.Y.exe",
+            }
+        },
+        "3.100-32": {
+            "DisplayName": "X.Y-32 version",
+            "InstallPath": {
+                None: sys.prefix,
+                "ExecutablePath": "X.Y-32.exe",
+            }
+        },
+        "3.100-arm64": {
+            "DisplayName": "X.Y-arm64 version",
+            "InstallPath": {
+                None: sys.prefix,
+                "ExecutablePath": "X.Y-arm64.exe",
+                "ExecutableArguments": "-X fake_arg_for_test",
+            }
+        },
+        "ignored": {
+            "DisplayName": "Ignored because no ExecutablePath",
+            "InstallPath": {
+                None: sys.prefix,
+            }
+        },
+    },
+    "PythonTestSuite1": {
+        "DisplayName": "Python Test Suite Single",
+        "3.100": {
+            "DisplayName": "Single Interpreter",
+            "InstallPath": {
+                None: sys.prefix,
+                "ExecutablePath": sys.executable,
+            }
+        }
+    },
+}
+
+
+TEST_PY_ENV = dict(
+    PY_PYTHON="PythonTestSuite/3.100",
+    PY_PYTHON2="PythonTestSuite/3.100-32",
+    PY_PYTHON3="PythonTestSuite/3.100-arm64",
+)
+
+
+TEST_PY_DEFAULTS = "\n".join([
+    "[defaults]",
+    *[f"{k[3:].lower()}={v}" for k, v in TEST_PY_ENV.items()],
+])
+
+
+TEST_PY_COMMANDS = "\n".join([
+    "[commands]",
+    "test-command=TEST_EXE.exe",
+])
+
+
+def quote(s):
+    s = str(s)
+    return f'"{s}"' if " " in s else s
+
+
+def create_registry_data(root, data):
+    def _create_registry_data(root, key, value):
+        if isinstance(value, dict):
+            # For a dict, we recursively create keys
+            with winreg.CreateKeyEx(root, key) as hkey:
+                for k, v in value.items():
+                    _create_registry_data(hkey, k, v)
+        elif isinstance(value, str):
+            # For strings, we set values. 'key' may be None in this case
+            winreg.SetValueEx(root, key, None, winreg.REG_SZ, value)
+        else:
+            raise TypeError("don't know how to create data for '{}'".format(value))
+
+    for k, v in data.items():
+        _create_registry_data(root, k, v)
+
+
+def enum_keys(root):
+    for i in itertools.count():
+        try:
+            yield winreg.EnumKey(root, i)
+        except OSError as ex:
+            if ex.winerror == 259:
+                break
+            raise
+
+
+def delete_registry_data(root, keys):
+    ACCESS = winreg.KEY_WRITE | winreg.KEY_ENUMERATE_SUB_KEYS
+    for key in list(keys):
+        with winreg.OpenKey(root, key, access=ACCESS) as hkey:
+            delete_registry_data(hkey, enum_keys(hkey))
+        winreg.DeleteKey(root, key)
+
+
+def is_installed(tag):
+    key = rf"Software\Python\PythonCore\{tag}\InstallPath"
+    for root, flag in [
+        (winreg.HKEY_CURRENT_USER, 0),
+        (winreg.HKEY_LOCAL_MACHINE, winreg.KEY_WOW64_64KEY),
+        (winreg.HKEY_LOCAL_MACHINE, winreg.KEY_WOW64_32KEY),
+    ]:
+        try:
+            winreg.CloseKey(winreg.OpenKey(root, key, access=winreg.KEY_READ | flag))
+            return True
+        except OSError:
+            pass
+    return False
+
+
+class PreservePyIni:
+    def __init__(self, path, content):
+        self.path = Path(path)
+        self.content = content
+        self._preserved = None
+
+    def __enter__(self):
+        try:
+            self._preserved = self.path.read_bytes()
+        except FileNotFoundError:
+            self._preserved = None
+        self.path.write_text(self.content, encoding="utf-16")
+
+    def __exit__(self, *exc_info):
+        if self._preserved is None:
+            self.path.unlink()
+        else:
+            self.path.write_bytes(self._preserved)
+
+
+class RunPyMixin:
+    py_exe = None
+
+    @classmethod
+    def find_py(cls):
+        py_exe = None
+        if sysconfig.is_python_build():
+            py_exe = Path(sys.executable).parent / PY_EXE
+        else:
+            for p in os.getenv("PATH").split(";"):
+                if p:
+                    py_exe = Path(p) / PY_EXE
+                    if py_exe.is_file():
+                        break
+            else:
+                py_exe = None
+
+        # Test launch and check version, to exclude installs of older
+        # releases when running outside of a source tree
+        if py_exe:
+            try:
+                with subprocess.Popen(
+                    [py_exe, "-h"],
+                    stdin=subprocess.PIPE,
+                    stdout=subprocess.PIPE,
+                    stderr=subprocess.PIPE,
+                    encoding="ascii",
+                    errors="ignore",
+                ) as p:
+                    p.stdin.close()
+                    version = next(p.stdout, "\n").splitlines()[0].rpartition(" ")[2]
+                    p.stdout.read()
+                    p.wait(10)
+                if not sys.version.startswith(version):
+                    py_exe = None
+            except OSError:
+                py_exe = None
+
+        if not py_exe:
+            raise unittest.SkipTest(
+                "cannot locate '{}' for test".format(PY_EXE)
+            )
+        return py_exe
+
+    def get_py_exe(self):
+        if not self.py_exe:
+            self.py_exe = self.find_py()
+        return self.py_exe
+
+    def run_py(self, args, env=None, allow_fail=False, expect_returncode=0, argv=None):
+        if not self.py_exe:
+            self.py_exe = self.find_py()
+
+        ignore = {"VIRTUAL_ENV", "PY_PYTHON", "PY_PYTHON2", "PY_PYTHON3"}
+        env = {
+            **{k.upper(): v for k, v in os.environ.items() if k.upper() not in ignore},
+            "PYLAUNCHER_DEBUG": "1",
+            "PYLAUNCHER_DRYRUN": "1",
+            "PYLAUNCHER_LIMIT_TO_COMPANY": "",
+            **{k.upper(): v for k, v in (env or {}).items()},
+        }
+        if not argv:
+            argv = [self.py_exe, *args]
+        with subprocess.Popen(
+            argv,
+            env=env,
+            executable=self.py_exe,
+            stdin=subprocess.PIPE,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+        ) as p:
+            p.stdin.close()
+            p.wait(10)
+            out = p.stdout.read().decode("utf-8", "replace")
+            err = p.stderr.read().decode("ascii", "replace").replace("\uFFFD", "?")
+        if p.returncode != expect_returncode and support.verbose and not allow_fail:
+            print("++ COMMAND ++")
+            print([self.py_exe, *args])
+            print("++ STDOUT ++")
+            print(out)
+            print("++ STDERR ++")
+            print(err)
+        if allow_fail and p.returncode != expect_returncode:
+            raise subprocess.CalledProcessError(p.returncode, [self.py_exe, *args], out, err)
+        else:
+            self.assertEqual(expect_returncode, p.returncode)
+        data = {
+            s.partition(":")[0]: s.partition(":")[2].lstrip()
+            for s in err.splitlines()
+            if not s.startswith("#") and ":" in s
+        }
+        data["stdout"] = out
+        data["stderr"] = err
+        return data
+
+    def py_ini(self, content):
+        local_appdata = os.environ.get("LOCALAPPDATA")
+        if not local_appdata:
+            raise unittest.SkipTest("LOCALAPPDATA environment variable is "
+                                    "missing or empty")
+        return PreservePyIni(Path(local_appdata) / "py.ini", content)
+
+    @contextlib.contextmanager
+    def script(self, content, encoding="utf-8"):
+        file = Path(tempfile.mktemp(dir=os.getcwd()) + ".py")
+        if isinstance(content, bytes):
+            file.write_bytes(content)
+        else:
+            file.write_text(content, encoding=encoding)
+        try:
+            yield file
+        finally:
+            file.unlink()
+
+    @contextlib.contextmanager
+    def fake_venv(self):
+        venv = Path.cwd() / "Scripts"
+        venv.mkdir(exist_ok=True, parents=True)
+        venv_exe = (venv / ("python_d.exe" if DEBUG_BUILD else "python.exe"))
+        venv_exe.touch()
+        try:
+            yield venv_exe, {"VIRTUAL_ENV": str(venv.parent)}
+        finally:
+            shutil.rmtree(venv)
+
+
+class TestLauncher(unittest.TestCase, RunPyMixin):
+    @classmethod
+    def setUpClass(cls):
+        with winreg.CreateKey(winreg.HKEY_CURRENT_USER, rf"Software\Python") as key:
+            create_registry_data(key, TEST_DATA)
+
+        if support.verbose:
+            p = subprocess.check_output("reg query HKCU\\Software\\Python /s")
+            #print(p.decode('mbcs'))
+
+
+    @classmethod
+    def tearDownClass(cls):
+        with winreg.OpenKey(winreg.HKEY_CURRENT_USER, rf"Software\Python", access=winreg.KEY_WRITE | winreg.KEY_ENUMERATE_SUB_KEYS) as key:
+            delete_registry_data(key, TEST_DATA)
+
+
+    def test_version(self):
+        data = self.run_py(["-0"])
+        self.assertEqual(self.py_exe, Path(data["argv0"]))
+        self.assertEqual(sys.version.partition(" ")[0], data["version"])
+
+    def test_help_option(self):
+        data = self.run_py(["-h"])
+        self.assertEqual("True", data["SearchInfo.help"])
+
+    def test_list_option(self):
+        for opt, v1, v2 in [
+            ("-0", "True", "False"),
+            ("-0p", "False", "True"),
+            ("--list", "True", "False"),
+            ("--list-paths", "False", "True"),
+        ]:
+            with self.subTest(opt):
+                data = self.run_py([opt])
+                self.assertEqual(v1, data["SearchInfo.list"])
+                self.assertEqual(v2, data["SearchInfo.listPaths"])
+
+    def test_list(self):
+        data = self.run_py(["--list"])
+        found = {}
+        expect = {}
+        for line in data["stdout"].splitlines():
+            m = re.match(r"\s*(.+?)\s+?(\*\s+)?(.+)$", line)
+            if m:
+                found[m.group(1)] = m.group(3)
+        for company in TEST_DATA:
+            company_data = TEST_DATA[company]
+            tags = [t for t in company_data if isinstance(company_data[t], dict)]
+            for tag in tags:
+                arg = f"-V:{company}/{tag}"
+                expect[arg] = company_data[tag]["DisplayName"]
+            expect.pop(f"-V:{company}/ignored", None)
+
+        actual = {k: v for k, v in found.items() if k in expect}
+        try:
+            self.assertDictEqual(expect, actual)
+        except:
+            if support.verbose:
+                print("*** STDOUT ***")
+                print(data["stdout"])
+            raise
+
+    def test_list_paths(self):
+        data = self.run_py(["--list-paths"])
+        found = {}
+        expect = {}
+        for line in data["stdout"].splitlines():
+            m = re.match(r"\s*(.+?)\s+?(\*\s+)?(.+)$", line)
+            if m:
+                found[m.group(1)] = m.group(3)
+        for company in TEST_DATA:
+            company_data = TEST_DATA[company]
+            tags = [t for t in company_data if isinstance(company_data[t], dict)]
+            for tag in tags:
+                arg = f"-V:{company}/{tag}"
+                install = company_data[tag]["InstallPath"]
+                try:
+                    expect[arg] = install["ExecutablePath"]
+                    try:
+                        expect[arg] += " " + install["ExecutableArguments"]
+                    except KeyError:
+                        pass
+                except KeyError:
+                    expect[arg] = str(Path(install[None]) / Path(sys.executable).name)
+
+            expect.pop(f"-V:{company}/ignored", None)
+
+        actual = {k: v for k, v in found.items() if k in expect}
+        try:
+            self.assertDictEqual(expect, actual)
+        except:
+            if support.verbose:
+                print("*** STDOUT ***")
+                print(data["stdout"])
+            raise
+
+    def test_filter_to_company(self):
+        company = "PythonTestSuite"
+        data = self.run_py([f"-V:{company}/"])
+        self.assertEqual("X.Y.exe", data["LaunchCommand"])
+        self.assertEqual(company, data["env.company"])
+        self.assertEqual("3.100", data["env.tag"])
+
+    def test_filter_to_company_with_default(self):
+        company = "PythonTestSuite"
+        data = self.run_py([f"-V:{company}/"], env=dict(PY_PYTHON="3.0"))
+        self.assertEqual("X.Y.exe", data["LaunchCommand"])
+        self.assertEqual(company, data["env.company"])
+        self.assertEqual("3.100", data["env.tag"])
+
+    def test_filter_to_tag(self):
+        company = "PythonTestSuite"
+        data = self.run_py(["-V:3.100"])
+        self.assertEqual("X.Y.exe", data["LaunchCommand"])
+        self.assertEqual(company, data["env.company"])
+        self.assertEqual("3.100", data["env.tag"])
+
+        data = self.run_py(["-V:3.100-32"])
+        self.assertEqual("X.Y-32.exe", data["LaunchCommand"])
+        self.assertEqual(company, data["env.company"])
+        self.assertEqual("3.100-32", data["env.tag"])
+
+        data = self.run_py(["-V:3.100-arm64"])
+        self.assertEqual("X.Y-arm64.exe -X fake_arg_for_test", data["LaunchCommand"])
+        self.assertEqual(company, data["env.company"])
+        self.assertEqual("3.100-arm64", data["env.tag"])
+
+    def test_filter_to_company_and_tag(self):
+        company = "PythonTestSuite"
+        data = self.run_py([f"-V:{company}/3.1"], expect_returncode=103)
+
+        data = self.run_py([f"-V:{company}/3.100"])
+        self.assertEqual("X.Y.exe", data["LaunchCommand"])
+        self.assertEqual(company, data["env.company"])
+        self.assertEqual("3.100", data["env.tag"])
+
+    def test_filter_with_single_install(self):
+        company = "PythonTestSuite1"
+        data = self.run_py(
+            ["-V:Nonexistent"],
+            env={"PYLAUNCHER_LIMIT_TO_COMPANY": company},
+            expect_returncode=103,
+        )
+
+    def test_search_major_3(self):
+        try:
+            data = self.run_py(["-3"], allow_fail=True)
+        except subprocess.CalledProcessError:
+            raise unittest.SkipTest("requires at least one Python 3.x install")
+        self.assertEqual("PythonCore", data["env.company"])
+        self.assertStartsWith(data["env.tag"], "3.")
+
+    def test_search_major_3_32(self):
+        try:
+            data = self.run_py(["-3-32"], allow_fail=True)
+        except subprocess.CalledProcessError:
+            if not any(is_installed(f"3.{i}-32") for i in range(5, 11)):
+                raise unittest.SkipTest("requires at least one 32-bit Python 3.x install")
+            raise
+        self.assertEqual("PythonCore", data["env.company"])
+        self.assertStartsWith(data["env.tag"], "3.")
+        self.assertEndsWith(data["env.tag"], "-32")
+
+    def test_search_major_2(self):
+        try:
+            data = self.run_py(["-2"], allow_fail=True)
+        except subprocess.CalledProcessError:
+            if not is_installed("2.7"):
+                raise unittest.SkipTest("requires at least one Python 2.x install")
+        self.assertEqual("PythonCore", data["env.company"])
+        self.assertStartsWith(data["env.tag"], "2.")
+
+    def test_py_default(self):
+        with self.py_ini(TEST_PY_DEFAULTS):
+            data = self.run_py(["-arg"])
+        self.assertEqual("PythonTestSuite", data["SearchInfo.company"])
+        self.assertEqual("3.100", data["SearchInfo.tag"])
+        self.assertEqual("X.Y.exe -arg", data["stdout"].strip())
+
+    def test_py2_default(self):
+        with self.py_ini(TEST_PY_DEFAULTS):
+            data = self.run_py(["-2", "-arg"])
+        self.assertEqual("PythonTestSuite", data["SearchInfo.company"])
+        self.assertEqual("3.100-32", data["SearchInfo.tag"])
+        self.assertEqual("X.Y-32.exe -arg", data["stdout"].strip())
+
+    def test_py3_default(self):
+        with self.py_ini(TEST_PY_DEFAULTS):
+            data = self.run_py(["-3", "-arg"])
+        self.assertEqual("PythonTestSuite", data["SearchInfo.company"])
+        self.assertEqual("3.100-arm64", data["SearchInfo.tag"])
+        self.assertEqual("X.Y-arm64.exe -X fake_arg_for_test -arg", data["stdout"].strip())
+
+    def test_py_default_env(self):
+        data = self.run_py(["-arg"], env=TEST_PY_ENV)
+        self.assertEqual("PythonTestSuite", data["SearchInfo.company"])
+        self.assertEqual("3.100", data["SearchInfo.tag"])
+        self.assertEqual("X.Y.exe -arg", data["stdout"].strip())
+
+    def test_py2_default_env(self):
+        data = self.run_py(["-2", "-arg"], env=TEST_PY_ENV)
+        self.assertEqual("PythonTestSuite", data["SearchInfo.company"])
+        self.assertEqual("3.100-32", data["SearchInfo.tag"])
+        self.assertEqual("X.Y-32.exe -arg", data["stdout"].strip())
+
+    def test_py3_default_env(self):
+        data = self.run_py(["-3", "-arg"], env=TEST_PY_ENV)
+        self.assertEqual("PythonTestSuite", data["SearchInfo.company"])
+        self.assertEqual("3.100-arm64", data["SearchInfo.tag"])
+        self.assertEqual("X.Y-arm64.exe -X fake_arg_for_test -arg", data["stdout"].strip())
+
+    def test_py_default_short_argv0(self):
+        with self.py_ini(TEST_PY_DEFAULTS):
+            for argv0 in ['"py.exe"', 'py.exe', '"py"', 'py']:
+                with self.subTest(argv0):
+                    data = self.run_py(["--version"], argv=f'{argv0} --version')
+                    self.assertEqual("PythonTestSuite", data["SearchInfo.company"])
+                    self.assertEqual("3.100", data["SearchInfo.tag"])
+                    self.assertEqual("X.Y.exe --version", data["stdout"].strip())
+
+    def test_py_default_in_list(self):
+        data = self.run_py(["-0"], env=TEST_PY_ENV)
+        default = None
+        for line in data["stdout"].splitlines():
+            m = re.match(r"\s*-V:(.+?)\s+?\*\s+(.+)$", line)
+            if m:
+                default = m.group(1)
+                break
+        self.assertEqual("PythonTestSuite/3.100", default)
+
+    def test_virtualenv_in_list(self):
+        with self.fake_venv() as (venv_exe, env):
+            data = self.run_py(["-0p"], env=env)
+            for line in data["stdout"].splitlines():
+                m = re.match(r"\s*\*\s+(.+)$", line)
+                if m:
+                    self.assertEqual(str(venv_exe), m.group(1))
+                    break
+            else:
+                if support.verbose:
+                    print(data["stdout"])
+                    print(data["stderr"])
+                self.fail("did not find active venv path")
+
+            data = self.run_py(["-0"], env=env)
+            for line in data["stdout"].splitlines():
+                m = re.match(r"\s*\*\s+(.+)$", line)
+                if m:
+                    self.assertEqual("Active venv", m.group(1))
+                    break
+            else:
+                self.fail("did not find active venv entry")
+
+    def test_virtualenv_with_env(self):
+        with self.fake_venv() as (venv_exe, env):
+            data1 = self.run_py([], env={**env, "PY_PYTHON": "PythonTestSuite/3"})
+            data2 = self.run_py(["-V:PythonTestSuite/3"], env={**env, "PY_PYTHON": "PythonTestSuite/3"})
+        # Compare stdout, because stderr goes via ascii
+        self.assertEqual(data1["stdout"].strip(), quote(venv_exe))
+        self.assertEqual(data1["SearchInfo.lowPriorityTag"], "True")
+        # Ensure passing the argument doesn't trigger the same behaviour
+        self.assertNotEqual(data2["stdout"].strip(), quote(venv_exe))
+        self.assertNotEqual(data2["SearchInfo.lowPriorityTag"], "True")
+
+    def test_py_shebang(self):
+        with self.py_ini(TEST_PY_DEFAULTS):
+            with self.script("#! /usr/bin/python -prearg") as script:
+                data = self.run_py([script, "-postarg"])
+        self.assertEqual("PythonTestSuite", data["SearchInfo.company"])
+        self.assertEqual("3.100", data["SearchInfo.tag"])
+        self.assertEqual(f"X.Y.exe -prearg {quote(script)} -postarg", data["stdout"].strip())
+
+    def test_python_shebang(self):
+        with self.py_ini(TEST_PY_DEFAULTS):
+            with self.script("#! python -prearg") as script:
+                data = self.run_py([script, "-postarg"])
+        self.assertEqual("PythonTestSuite", data["SearchInfo.company"])
+        self.assertEqual("3.100", data["SearchInfo.tag"])
+        self.assertEqual(f"X.Y.exe -prearg {quote(script)} -postarg", data["stdout"].strip())
+
+    def test_py2_shebang(self):
+        with self.py_ini(TEST_PY_DEFAULTS):
+            with self.script("#! /usr/bin/python2 -prearg") as script:
+                data = self.run_py([script, "-postarg"])
+        self.assertEqual("PythonTestSuite", data["SearchInfo.company"])
+        self.assertEqual("3.100-32", data["SearchInfo.tag"])
+        self.assertEqual(f"X.Y-32.exe -prearg {quote(script)} -postarg",
+                         data["stdout"].strip())
+
+    def test_py3_shebang(self):
+        with self.py_ini(TEST_PY_DEFAULTS):
+            with self.script("#! /usr/bin/python3 -prearg") as script:
+                data = self.run_py([script, "-postarg"])
+        self.assertEqual("PythonTestSuite", data["SearchInfo.company"])
+        self.assertEqual("3.100-arm64", data["SearchInfo.tag"])
+        self.assertEqual(f"X.Y-arm64.exe -X fake_arg_for_test -prearg {quote(script)} -postarg",
+                         data["stdout"].strip())
+
+    def test_py_shebang_nl(self):
+        with self.py_ini(TEST_PY_DEFAULTS):
+            with self.script("#! /usr/bin/python -prearg\n") as script:
+                data = self.run_py([script, "-postarg"])
+        self.assertEqual("PythonTestSuite", data["SearchInfo.company"])
+        self.assertEqual("3.100", data["SearchInfo.tag"])
+        self.assertEqual(f"X.Y.exe -prearg {quote(script)} -postarg",
+                         data["stdout"].strip())
+
+    def test_py2_shebang_nl(self):
+        with self.py_ini(TEST_PY_DEFAULTS):
+            with self.script("#! /usr/bin/python2 -prearg\n") as script:
+                data = self.run_py([script, "-postarg"])
+        self.assertEqual("PythonTestSuite", data["SearchInfo.company"])
+        self.assertEqual("3.100-32", data["SearchInfo.tag"])
+        self.assertEqual(f"X.Y-32.exe -prearg {quote(script)} -postarg",
+                         data["stdout"].strip())
+
+    def test_py3_shebang_nl(self):
+        with self.py_ini(TEST_PY_DEFAULTS):
+            with self.script("#! /usr/bin/python3 -prearg\n") as script:
+                data = self.run_py([script, "-postarg"])
+        self.assertEqual("PythonTestSuite", data["SearchInfo.company"])
+        self.assertEqual("3.100-arm64", data["SearchInfo.tag"])
+        self.assertEqual(f"X.Y-arm64.exe -X fake_arg_for_test -prearg {quote(script)} -postarg",
+                         data["stdout"].strip())
+
+    def test_py_shebang_short_argv0(self):
+        with self.py_ini(TEST_PY_DEFAULTS):
+            with self.script("#! /usr/bin/python -prearg") as script:
+                # Override argv to only pass "py.exe" as the command
+                data = self.run_py([script, "-postarg"], argv=f'"py.exe" "{script}" -postarg')
+        self.assertEqual("PythonTestSuite", data["SearchInfo.company"])
+        self.assertEqual("3.100", data["SearchInfo.tag"])
+        self.assertEqual(f'X.Y.exe -prearg "{script}" -postarg', data["stdout"].strip())
+
+    def test_py_shebang_valid_bom(self):
+        with self.py_ini(TEST_PY_DEFAULTS):
+            content = "#! /usr/bin/python -prearg".encode("utf-8")
+            with self.script(b"\xEF\xBB\xBF" + content) as script:
+                data = self.run_py([script, "-postarg"])
+        self.assertEqual("PythonTestSuite", data["SearchInfo.company"])
+        self.assertEqual("3.100", data["SearchInfo.tag"])
+        self.assertEqual(f"X.Y.exe -prearg {quote(script)} -postarg", data["stdout"].strip())
+
+    def test_py_shebang_invalid_bom(self):
+        with self.py_ini(TEST_PY_DEFAULTS):
+            content = "#! /usr/bin/python3 -prearg".encode("utf-8")
+            with self.script(b"\xEF\xAA\xBF" + content) as script:
+                data = self.run_py([script, "-postarg"])
+        self.assertIn("Invalid BOM", data["stderr"])
+        self.assertEqual("PythonTestSuite", data["SearchInfo.company"])
+        self.assertEqual("3.100", data["SearchInfo.tag"])
+        self.assertEqual(f"X.Y.exe {quote(script)} -postarg", data["stdout"].strip())
+
+    def test_py_handle_64_in_ini(self):
+        with self.py_ini("\n".join(["[defaults]", "python=3.999-64"])):
+            # Expect this to fail, but should get oldStyleTag flipped on
+            data = self.run_py([], allow_fail=True, expect_returncode=103)
+        self.assertEqual("3.999-64", data["SearchInfo.tag"])
+        self.assertEqual("True", data["SearchInfo.oldStyleTag"])
+
+    def test_search_path(self):
+        exe = Path("arbitrary-exe-name.exe").absolute()
+        exe.touch()
+        self.addCleanup(exe.unlink)
+        with self.py_ini(TEST_PY_DEFAULTS):
+            with self.script(f"#! /usr/bin/env {exe.stem} -prearg") as script:
+                data = self.run_py(
+                    [script, "-postarg"],
+                    env={"PATH": f"{exe.parent};{os.getenv('PATH')}"},
+                )
+        self.assertEqual(f"{quote(exe)} -prearg {quote(script)} -postarg",
+                         data["stdout"].strip())
+
+    def test_search_path_exe(self):
+        # Leave the .exe on the name to ensure we don't add it a second time
+        exe = Path("arbitrary-exe-name.exe").absolute()
+        exe.touch()
+        self.addCleanup(exe.unlink)
+        with self.py_ini(TEST_PY_DEFAULTS):
+            with self.script(f"#! /usr/bin/env {exe.name} -prearg") as script:
+                data = self.run_py(
+                    [script, "-postarg"],
+                    env={"PATH": f"{exe.parent};{os.getenv('PATH')}"},
+                )
+        self.assertEqual(f"{quote(exe)} -prearg {quote(script)} -postarg",
+                         data["stdout"].strip())
+
+    def test_recursive_search_path(self):
+        stem = self.get_py_exe().stem
+        with self.py_ini(TEST_PY_DEFAULTS):
+            with self.script(f"#! /usr/bin/env {stem}") as script:
+                data = self.run_py(
+                    [script],
+                    env={"PATH": f"{self.get_py_exe().parent};{os.getenv('PATH')}"},
+                )
+        # The recursive search is ignored and we get normal "py" behavior
+        self.assertEqual(f"X.Y.exe {quote(script)}", data["stdout"].strip())
+
+    def test_install(self):
+        data = self.run_py(["-V:3.10"], env={"PYLAUNCHER_ALWAYS_INSTALL": "1"}, expect_returncode=111)
+        cmd = data["stdout"].strip()
+        # If winget is runnable, we should find it. Otherwise, we'll be trying
+        # to open the Store.
+        try:
+            subprocess.check_call(["winget.exe", "--version"], stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
+        except FileNotFoundError:
+            self.assertIn("ms-windows-store://", cmd)
+        else:
+            self.assertIn("winget.exe", cmd)
+        # Both command lines include the store ID
+        self.assertIn("9PJPW5LDXLZ5", cmd)
+
+    def test_literal_shebang_absolute(self):
+        with self.script("#! C:/some_random_app -witharg") as script:
+            data = self.run_py([script])
+        self.assertEqual(
+            f"C:\\some_random_app -witharg {quote(script)}",
+            data["stdout"].strip(),
+        )
+
+    def test_literal_shebang_relative(self):
+        with self.script("#! ..\\some_random_app -witharg") as script:
+            data = self.run_py([script])
+        self.assertEqual(
+            f"{quote(script.parent.parent / 'some_random_app')} -witharg {quote(script)}",
+            data["stdout"].strip(),
+        )
+
+    def test_literal_shebang_quoted(self):
+        with self.script('#! "some random app" -witharg') as script:
+            data = self.run_py([script])
+        self.assertEqual(
+            f"{quote(script.parent / 'some random app')} -witharg {quote(script)}",
+            data["stdout"].strip(),
+        )
+
+        with self.script('#! some" random "app -witharg') as script:
+            data = self.run_py([script])
+        self.assertEqual(
+            f"{quote(script.parent / 'some random app')} -witharg {quote(script)}",
+            data["stdout"].strip(),
+        )
+
+    def test_literal_shebang_quoted_escape(self):
+        with self.script('#! some\\" random "app -witharg') as script:
+            data = self.run_py([script])
+        self.assertEqual(
+            f"{quote(script.parent / 'some/ random app')} -witharg {quote(script)}",
+            data["stdout"].strip(),
+        )
+
+    def test_literal_shebang_command(self):
+        with self.py_ini(TEST_PY_COMMANDS):
+            with self.script('#! test-command arg1') as script:
+                data = self.run_py([script])
+        self.assertEqual(
+            f"TEST_EXE.exe arg1 {quote(script)}",
+            data["stdout"].strip(),
+        )
+
+    def test_literal_shebang_invalid_template(self):
+        with self.script('#! /usr/bin/not-python arg1') as script:
+            data = self.run_py([script])
+        expect = script.parent / "/usr/bin/not-python"
+        self.assertEqual(
+            f"{quote(expect)} arg1 {quote(script)}",
+            data["stdout"].strip(),
+        )
+
+    def test_shebang_command_in_venv(self):
+        stem = "python-that-is-not-on-path"
+
+        # First ensure that our test name doesn't exist, and the launcher does
+        # not match any installed env
+        with self.script(f'#! /usr/bin/env {stem} arg1') as script:
+            data = self.run_py([script], expect_returncode=103)
+
+        with self.fake_venv() as (venv_exe, env):
+            # Put a "normal" Python on PATH as a distraction.
+            # The active VIRTUAL_ENV should be preferred when the name isn't an
+            # exact match.
+            exe = Path(Path(venv_exe).name).absolute()
+            exe.touch()
+            self.addCleanup(exe.unlink)
+            env["PATH"] = f"{exe.parent};{os.environ['PATH']}"
+
+            with self.script(f'#! /usr/bin/env {stem} arg1') as script:
+                data = self.run_py([script], env=env)
+            self.assertEqual(data["stdout"].strip(), f"{quote(venv_exe)} arg1 {quote(script)}")
+
+            with self.script(f'#! /usr/bin/env {exe.stem} arg1') as script:
+                data = self.run_py([script], env=env)
+            self.assertEqual(data["stdout"].strip(), f"{quote(exe)} arg1 {quote(script)}")
+
+    def test_shebang_executable_extension(self):
+        with self.script('#! /usr/bin/env python3.99') as script:
+            data = self.run_py([script], expect_returncode=103)
+        expect = "# Search PATH for python3.99.exe"
+        actual = [line.strip() for line in data["stderr"].splitlines()
+                  if line.startswith("# Search PATH")]
+        self.assertEqual([expect], actual)
diff --git a/Lib/test/test_linecache.py b/Lib/test/test_linecache.py
index e4aa41ebb43..02f65338428 100644
--- a/Lib/test/test_linecache.py
+++ b/Lib/test/test_linecache.py
@@ -4,10 +4,12 @@
 import unittest
 import os.path
 import tempfile
+import threading
 import tokenize
 from importlib.machinery import ModuleSpec
 from test import support
 from test.support import os_helper
+from test.support import threading_helper
 from test.support.script_helper import assert_python_ok
 
 
@@ -374,5 +376,40 @@ def test_checkcache_with_no_parameter(self):
         self.assertIn(self.unchanged_file, linecache.cache)
 
 
+class MultiThreadingTest(unittest.TestCase):
+    @threading_helper.reap_threads
+    @threading_helper.requires_working_threading()
+    def test_read_write_safety(self):
+
+        with tempfile.TemporaryDirectory() as tmpdirname:
+            filenames = []
+            for i in range(10):
+                name = os.path.join(tmpdirname, f"test_{i}.py")
+                with open(name, "w") as h:
+                    h.write("import time\n")
+                    h.write("import system\n")
+                filenames.append(name)
+
+            def linecache_get_line(b):
+                b.wait()
+                for _ in range(100):
+                    for name in filenames:
+                        linecache.getline(name, 1)
+
+            def check(funcs):
+                barrier = threading.Barrier(len(funcs))
+                threads = []
+
+                for func in funcs:
+                    thread = threading.Thread(target=func, args=(barrier,))
+
+                    threads.append(thread)
+
+                with threading_helper.start_threads(threads):
+                    pass
+
+            check([linecache_get_line] * 20)
+
+
 if __name__ == "__main__":
     unittest.main()
diff --git a/Lib/test/test_list.py b/Lib/test/test_list.py
index ed061384f17..e320a2008a8 100644
--- a/Lib/test/test_list.py
+++ b/Lib/test/test_list.py
@@ -1,8 +1,10 @@
+import signal
 import sys
 import textwrap
-from test import list_tests
+from test import list_tests, support
 from test.support import cpython_only
-from test.support.script_helper import assert_python_ok
+from test.support.import_helper import import_module
+from test.support.script_helper import assert_python_failure, assert_python_ok
 import pickle
 import unittest
 
@@ -48,7 +50,7 @@ def test_keyword_args(self):
         with self.assertRaisesRegex(TypeError, 'keyword argument'):
             list(sequence=[])
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_keywords_in_subclass(self):
         class subclass(list):
             pass
@@ -118,7 +120,6 @@ def test_list_resize_overflow(self):
         with self.assertRaises((MemoryError, OverflowError)):
             lst *= size
 
-    @unittest.skip("TODO: RUSTPYTHON; hangs")
     def test_repr_mutate(self):
         class Obj:
             @staticmethod
@@ -329,6 +330,25 @@ def test_tier2_invalidates_iterator(self):
             a.append(4)
             self.assertEqual(list(it), [])
 
+    @support.cpython_only
+    def test_no_memory(self):
+        # gh-118331: Make sure we don't crash if list allocation fails
+        import_module("_testcapi")
+        code = textwrap.dedent("""
+        import _testcapi, sys
+        # Prime the freelist
+        l = [None]
+        del l
+        _testcapi.set_nomemory(0)
+        l = [None]
+        """)
+        rc, _, _ = assert_python_failure("-c", code)
+        if support.MS_WINDOWS:
+            # STATUS_ACCESS_VIOLATION
+            self.assertNotEqual(rc, 0xC0000005)
+        else:
+            self.assertNotEqual(rc, -int(signal.SIGSEGV))
+
     def test_deopt_from_append_list(self):
         # gh-132011: it used to crash, because
         # of `CALL_LIST_APPEND` specialization failure.
diff --git a/Lib/test/test_listcomps.py b/Lib/test/test_listcomps.py
index 1380c08d28b..964383966c2 100644
--- a/Lib/test/test_listcomps.py
+++ b/Lib/test/test_listcomps.py
@@ -609,7 +609,7 @@ def test_comp_in_try_except(self):
             result = snapshot = None
             try:
                 result = [{func}(value) for value in value]
-            except:
+            except ValueError:
                 snapshot = value
                 raise
         """
@@ -643,13 +643,12 @@ def test_exception_in_post_comp_call(self):
             value = [1, None]
             try:
                 [v for v in value].sort()
-            except:
+            except TypeError:
                 pass
         """
         self._check_in_scopes(code, {"value": [1, None]})
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_frame_locals(self):
         code = """
             val = "a" in [sys._getframe().f_locals for a in [0]][0]
@@ -716,11 +715,9 @@ def test_multiple_comprehension_name_reuse(self):
         self._check_in_scopes(code, {"x": 2, "y": [3]}, ns={"x": 3}, scopes=["class"])
         self._check_in_scopes(code, {"x": 2, "y": [2]}, ns={"x": 3}, scopes=["function", "module"])
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_exception_locations(self):
         # The location of an exception raised from __init__ or
-        # __next__ should should be the iterator expression
+        # __next__ should be the iterator expression
 
         def init_raises():
             try:
@@ -754,6 +751,28 @@ def iter_raises():
                 self.assertEqual(f.line[f.colno - indent : f.end_colno - indent],
                                  expected)
 
+    def test_only_calls_dunder_iter_once(self):
+
+        class Iterator:
+
+            def __init__(self):
+                self.val = 0
+
+            def __next__(self):
+                if self.val == 2:
+                    raise StopIteration
+                self.val += 1
+                return self.val
+
+            # No __iter__ method
+
+        class C:
+
+            def __iter__(self):
+                return Iterator()
+
+        self.assertEqual([1, 2], [i for i in C()])
+
 __test__ = {'doctests' : doctests}
 
 def load_tests(loader, tests, pattern):
diff --git a/Lib/test/test_locale.py b/Lib/test/test_locale.py
index 71d03f3a3f9..8e49aa8954e 100644
--- a/Lib/test/test_locale.py
+++ b/Lib/test/test_locale.py
@@ -1,7 +1,7 @@
 from decimal import Decimal
-from test.support import verbose, is_android, is_emscripten, is_wasi
+from test.support import cpython_only, verbose, is_android, linked_to_musl, os_helper
 from test.support.warnings_helper import check_warnings
-from test.support.import_helper import import_fresh_module
+from test.support.import_helper import ensure_lazy_imports, import_fresh_module
 from unittest import mock
 import unittest
 import locale
@@ -9,6 +9,11 @@
 import sys
 import codecs
 
+class LazyImportTest(unittest.TestCase):
+    @cpython_only
+    def test_lazy_import(self):
+        ensure_lazy_imports("locale", {"re", "warnings"})
+
 
 class BaseLocalizedTest(unittest.TestCase):
     #
@@ -351,10 +356,7 @@ def setUp(self):
 
     @unittest.skipIf(sys.platform.startswith('aix'),
                      'bpo-29972: broken test on AIX')
-    @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("netbsd"),
                      "gh-124108: NetBSD doesn't support UTF-8 for LC_COLLATE")
     def test_strcoll_with_diacritic(self):
@@ -362,10 +364,7 @@ def test_strcoll_with_diacritic(self):
 
     @unittest.skipIf(sys.platform.startswith('aix'),
                      'bpo-29972: broken test on AIX')
-    @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("netbsd"),
                      "gh-124108: NetBSD doesn't support UTF-8 for LC_COLLATE")
     def test_strxfrm_with_diacritic(self):
@@ -541,7 +540,6 @@ def test_defaults_UTF8(self):
         # valid. Furthermore LC_CTYPE=UTF is used by the UTF-8 locale coercing
         # during interpreter startup (on macOS).
         import _locale
-        import os
 
         self.assertEqual(locale._parse_localename('UTF-8'), (None, 'UTF-8'))
 
@@ -551,25 +549,14 @@ def test_defaults_UTF8(self):
         else:
             orig_getlocale = None
 
-        orig_env = {}
         try:
-            for key in ('LC_ALL', 'LC_CTYPE', 'LANG', 'LANGUAGE'):
-                if key in os.environ:
-                    orig_env[key] = os.environ[key]
-                    del os.environ[key]
-
-            os.environ['LC_CTYPE'] = 'UTF-8'
-
-            with check_warnings(('', DeprecationWarning)):
-                self.assertEqual(locale.getdefaultlocale(), (None, 'UTF-8'))
+            with os_helper.EnvironmentVarGuard() as env:
+                env.unset('LC_ALL', 'LC_CTYPE', 'LANG', 'LANGUAGE')
+                env.set('LC_CTYPE', 'UTF-8')
 
+                with check_warnings(('', DeprecationWarning)):
+                    self.assertEqual(locale.getdefaultlocale(), (None, 'UTF-8'))
         finally:
-            for k in orig_env:
-                os.environ[k] = orig_env[k]
-
-            if 'LC_CTYPE' not in orig_env:
-                del os.environ['LC_CTYPE']
-
             if orig_getlocale is not None:
                 _locale._getdefaultlocale = orig_getlocale
 
diff --git a/Lib/test/test_logging.py b/Lib/test/test_logging.py
index 12b61e76423..ef52f147764 100644
--- a/Lib/test/test_logging.py
+++ b/Lib/test/test_logging.py
@@ -4119,8 +4119,6 @@ def test_90195(self):
         # Logger should be enabled, since explicitly mentioned
         self.assertFalse(logger.disabled)
 
-    # 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
@@ -5165,7 +5163,6 @@ def __init__(self, name='MyLogger', level=logging.NOTSET):
             h.close()
             logging.setLoggerClass(logging.Logger)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_logging_at_shutdown(self):
         # bpo-20037: Doing text I/O late at interpreter shutdown must not crash
         code = textwrap.dedent("""
@@ -5185,7 +5182,6 @@ def __del__(self):
         self.assertIn("exception in __del__", err)
         self.assertIn("ValueError: some error", err)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_logging_at_shutdown_open(self):
         # bpo-26789: FileHandler keeps a reference to the builtin open()
         # function to be able to open or reopen the file during Python
diff --git a/Lib/test/test_long.py b/Lib/test/test_long.py
index dbcc85bd69e..a879c6f5df8 100644
--- a/Lib/test/test_long.py
+++ b/Lib/test/test_long.py
@@ -386,15 +386,6 @@ def __long__(self):
                 return 42
         self.assertRaises(TypeError, int, JustLong())
 
-        class LongTrunc:
-            # __long__ should be ignored in 3.x
-            def __long__(self):
-                return 42
-            def __trunc__(self):
-                return 1729
-        with self.assertWarns(DeprecationWarning):
-            self.assertEqual(int(LongTrunc()), 1729)
-
     def check_float_conversion(self, n):
         # Check that int -> float conversion behaviour matches
         # that of the pure Python version above.
@@ -412,7 +403,7 @@ def check_float_conversion(self, n):
                "Got {}, expected {}.".format(n, actual, expected))
         self.assertEqual(actual, expected, msg)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     @support.requires_IEEE_754
     def test_float_conversion(self):
 
@@ -483,6 +474,12 @@ def test_float_conversion(self):
             self.check_float_conversion(value)
             self.check_float_conversion(-value)
 
+    @support.requires_IEEE_754
+    @support.bigmemtest(2**32, memuse=0.2)
+    def test_float_conversion_huge_integer(self, size):
+        v = 1 << size
+        self.assertRaises(OverflowError, float, v)
+
     def test_float_overflow(self):
         for x in -2.0, -1.0, 0.0, 1.0, 2.0:
             self.assertEqual(float(int(x)), x)
@@ -624,6 +621,56 @@ def __lt__(self, other):
                     eq(x > y, Rcmp > 0)
                     eq(x >= y, Rcmp >= 0)
 
+    @support.requires_IEEE_754
+    @support.bigmemtest(2**32, memuse=0.2)
+    def test_mixed_compares_huge_integer(self, size):
+        v = 1 << size
+        f = sys.float_info.max
+        self.assertIs(f == v, False)
+        self.assertIs(f != v, True)
+        self.assertIs(f < v, True)
+        self.assertIs(f <= v, True)
+        self.assertIs(f > v, False)
+        self.assertIs(f >= v, False)
+        f = float('inf')
+        self.assertIs(f == v, False)
+        self.assertIs(f != v, True)
+        self.assertIs(f < v, False)
+        self.assertIs(f <= v, False)
+        self.assertIs(f > v, True)
+        self.assertIs(f >= v, True)
+        f = float('nan')
+        self.assertIs(f == v, False)
+        self.assertIs(f != v, True)
+        self.assertIs(f < v, False)
+        self.assertIs(f <= v, False)
+        self.assertIs(f > v, False)
+        self.assertIs(f >= v, False)
+
+        del v
+        v = (-1) << size
+        f = -sys.float_info.max
+        self.assertIs(f == v, False)
+        self.assertIs(f != v, True)
+        self.assertIs(f < v, False)
+        self.assertIs(f <= v, False)
+        self.assertIs(f > v, True)
+        self.assertIs(f >= v, True)
+        f = float('-inf')
+        self.assertIs(f == v, False)
+        self.assertIs(f != v, True)
+        self.assertIs(f < v, True)
+        self.assertIs(f <= v, True)
+        self.assertIs(f > v, False)
+        self.assertIs(f >= v, False)
+        f = float('nan')
+        self.assertIs(f == v, False)
+        self.assertIs(f != v, True)
+        self.assertIs(f < v, False)
+        self.assertIs(f <= v, False)
+        self.assertIs(f > v, False)
+        self.assertIs(f >= v, False)
+
     def test__format__(self):
         self.assertEqual(format(123456789, 'd'), '123456789')
         self.assertEqual(format(123456789, 'd'), '123456789')
@@ -823,7 +870,7 @@ def check_truediv(self, a, b, skip_small=True):
         self.assertEqual(expected, got, "Incorrectly rounded division {}/{}: "
                          "expected {}, got {}".format(a, b, expected, got))
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     @support.requires_IEEE_754
     def test_correctly_rounded_true_division(self):
         # more stringent tests than those above, checking that the
@@ -944,9 +991,12 @@ def test_huge_lshift_of_zero(self):
         self.assertEqual(0 << (sys.maxsize + 1), 0)
 
     @support.cpython_only
-    @support.bigmemtest(sys.maxsize + 1000, memuse=2/15 * 2, dry_run=False)
+    @support.bigmemtest(2**32, memuse=0.2)
     def test_huge_lshift(self, size):
-        self.assertEqual(1 << (sys.maxsize + 1000), 1 << 1000 << sys.maxsize)
+        v = 5 << size
+        self.assertEqual(v.bit_length(), size + 3)
+        self.assertEqual(v.bit_count(), 2)
+        self.assertEqual(v >> size, 5)
 
     def test_huge_rshift(self):
         huge_shift = 1 << 1000
@@ -958,11 +1008,13 @@ def test_huge_rshift(self):
         self.assertEqual(-2**128 >> huge_shift, -1)
 
     @support.cpython_only
-    @support.bigmemtest(sys.maxsize + 500, memuse=2/15, dry_run=False)
+    @support.bigmemtest(2**32, memuse=0.2)
     def test_huge_rshift_of_huge(self, size):
-        huge = ((1 << 500) + 11) << sys.maxsize
-        self.assertEqual(huge >> (sys.maxsize + 1), (1 << 499) + 5)
-        self.assertEqual(huge >> (sys.maxsize + 1000), 0)
+        huge = ((1 << 500) + 11) << size
+        self.assertEqual(huge.bit_length(), size + 501)
+        self.assertEqual(huge.bit_count(), 4)
+        self.assertEqual(huge >> (size + 1), (1 << 499) + 5)
+        self.assertEqual(huge >> (size + 1000), 0)
 
     def test_small_rshift(self):
         self.assertEqual(42 >> 1, 21)
@@ -1347,7 +1399,7 @@ class SubStr(str):
         self.assertEqual((0).to_bytes(1, SubStr('big')), b'\x00')
         self.assertEqual((0).to_bytes(0, SubStr('little')), b'')
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_from_bytes(self):
         def check(tests, byteorder, signed=False):
             def equivalent_python(byte_array, byteorder, signed=False):
@@ -1426,7 +1478,6 @@ def equivalent_python(byte_array, byteorder, signed=False):
             b'\x00': 0,
             b'\x00\x00': 0,
             b'\x01': 1,
-            b'\x00\x01': 256,
             b'\xff': -1,
             b'\xff\xff': -1,
             b'\x81': -127,
@@ -1609,7 +1660,7 @@ def test_square(self):
                 self.assertEqual(n**2,
                     (1 << (2 * bitlen)) - (1 << (bitlen + 1)) + 1)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test___sizeof__(self):
         self.assertEqual(int.__itemsize__, sys.int_info.sizeof_digit)
 
diff --git a/Lib/test/test_lzma.py b/Lib/test/test_lzma.py
index 1bfc9551ce3..a433f0c6193 100644
--- a/Lib/test/test_lzma.py
+++ b/Lib/test/test_lzma.py
@@ -22,7 +22,7 @@ class CompressorDecompressorTestCase(unittest.TestCase):
 
     # Test error cases.
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; lzma.LZMAError: Invalid format
     def test_simple_bad_args(self):
         self.assertRaises(TypeError, LZMACompressor, [])
         self.assertRaises(TypeError, LZMACompressor, format=3.45)
@@ -63,7 +63,7 @@ def test_simple_bad_args(self):
         lzd.decompress(empty)
         self.assertRaises(EOFError, lzd.decompress, b"quux")
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; lzma.LZMAError: Failed to initialize encoder
     def test_bad_filter_spec(self):
         self.assertRaises(TypeError, LZMACompressor, filters=[b"wobsite"])
         self.assertRaises(ValueError, LZMACompressor, filters=[{"xyzzy": 3}])
@@ -80,7 +80,6 @@ def test_decompressor_after_eof(self):
         lzd.decompress(COMPRESSED_XZ)
         self.assertRaises(EOFError, lzd.decompress, b"nyan")
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_decompressor_memlimit(self):
         lzd = LZMADecompressor(memlimit=1024)
         self.assertRaises(LZMAError, lzd.decompress, COMPRESSED_XZ)
@@ -101,7 +100,6 @@ def _test_decompressor(self, lzd, data, check, unused_data=b""):
         self.assertTrue(lzd.eof)
         self.assertEqual(lzd.unused_data, unused_data)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_decompressor_auto(self):
         lzd = LZMADecompressor()
         self._test_decompressor(lzd, COMPRESSED_XZ, lzma.CHECK_CRC64)
@@ -109,37 +107,30 @@ def test_decompressor_auto(self):
         lzd = LZMADecompressor()
         self._test_decompressor(lzd, COMPRESSED_ALONE, lzma.CHECK_NONE)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_decompressor_xz(self):
         lzd = LZMADecompressor(lzma.FORMAT_XZ)
         self._test_decompressor(lzd, COMPRESSED_XZ, lzma.CHECK_CRC64)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_decompressor_alone(self):
         lzd = LZMADecompressor(lzma.FORMAT_ALONE)
         self._test_decompressor(lzd, COMPRESSED_ALONE, lzma.CHECK_NONE)
 
-    @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)
 
-    @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)
 
-    @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)
 
-    @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)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_decompressor_chunks(self):
         lzd = LZMADecompressor()
         out = []
@@ -152,7 +143,7 @@ def test_decompressor_chunks(self):
         self.assertTrue(lzd.eof)
         self.assertEqual(lzd.unused_data, b"")
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; EOFError: End of stream already reached
     def test_decompressor_chunks_empty(self):
         lzd = LZMADecompressor()
         out = []
@@ -168,7 +159,7 @@ def test_decompressor_chunks_empty(self):
         self.assertTrue(lzd.eof)
         self.assertEqual(lzd.unused_data, b"")
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AttributeError: 'LZMADecompressor' object has no attribute 'check'
     def test_decompressor_chunks_maxsize(self):
         lzd = LZMADecompressor()
         max_length = 100
@@ -260,14 +251,12 @@ def test_decompressor_inputbuf_3(self):
         out.append(lzd.decompress(COMPRESSED_XZ[300:]))
         self.assertEqual(b''.join(out), INPUT)
 
-    @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)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_decompressor_bad_input(self):
         lzd = LZMADecompressor()
         self.assertRaises(LZMAError, lzd.decompress, COMPRESSED_RAW_1)
@@ -281,7 +270,6 @@ def test_decompressor_bad_input(self):
         lzd = LZMADecompressor(lzma.FORMAT_RAW, filters=FILTERS_RAW_1)
         self.assertRaises(LZMAError, lzd.decompress, COMPRESSED_XZ)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_decompressor_bug_28275(self):
         # Test coverage for Issue 28275
         lzd = LZMADecompressor()
@@ -291,28 +279,24 @@ def test_decompressor_bug_28275(self):
 
     # Test that LZMACompressor->LZMADecompressor preserves the input data.
 
-    @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)
 
-    @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)
 
-    @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)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_roundtrip_raw_empty(self):
         lzc = LZMACompressor(lzma.FORMAT_RAW, filters=FILTERS_RAW_4)
         cdata = lzc.compress(INPUT)
@@ -323,7 +307,6 @@ def test_roundtrip_raw_empty(self):
         lzd = LZMADecompressor(lzma.FORMAT_RAW, filters=FILTERS_RAW_4)
         self._test_decompressor(lzd, cdata, lzma.CHECK_NONE)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_roundtrip_chunks(self):
         lzc = LZMACompressor()
         cdata = []
@@ -334,7 +317,6 @@ def test_roundtrip_chunks(self):
         lzd = LZMADecompressor()
         self._test_decompressor(lzd, cdata, lzma.CHECK_CRC64)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_roundtrip_empty_chunks(self):
         lzc = LZMACompressor()
         cdata = []
@@ -350,7 +332,6 @@ def test_roundtrip_empty_chunks(self):
 
     # LZMADecompressor intentionally does not handle concatenated streams.
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_decompressor_multistream(self):
         lzd = LZMADecompressor()
         self._test_decompressor(lzd, COMPRESSED_XZ + COMPRESSED_ALONE,
@@ -411,7 +392,7 @@ class CompressDecompressFunctionTestCase(unittest.TestCase):
 
     # Test error cases:
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; lzma.LZMAError: Failed to initialize encoder
     def test_bad_args(self):
         self.assertRaises(TypeError, lzma.compress)
         self.assertRaises(TypeError, lzma.compress, [])
@@ -441,7 +422,6 @@ def test_bad_args(self):
             lzma.decompress(
                     b"", format=lzma.FORMAT_ALONE, filters=FILTERS_RAW_1)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_decompress_memlimit(self):
         with self.assertRaises(LZMAError):
             lzma.decompress(COMPRESSED_XZ, memlimit=1024)
@@ -454,7 +434,6 @@ def test_decompress_memlimit(self):
 
     # Test LZMADecompressor on known-good input data.
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_decompress_good_input(self):
         ddata = lzma.decompress(COMPRESSED_XZ)
         self.assertEqual(ddata, INPUT)
@@ -484,7 +463,6 @@ def test_decompress_good_input(self):
                 COMPRESSED_RAW_4, lzma.FORMAT_RAW, filters=FILTERS_RAW_4)
         self.assertEqual(ddata, INPUT)
 
-    @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])
@@ -497,7 +475,6 @@ def test_decompress_incomplete_input(self):
         self.assertRaises(LZMAError, lzma.decompress, COMPRESSED_RAW_4[:128],
                           format=lzma.FORMAT_RAW, filters=FILTERS_RAW_4)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_decompress_bad_input(self):
         with self.assertRaises(LZMAError):
             lzma.decompress(COMPRESSED_BOGUS)
@@ -513,7 +490,6 @@ def test_decompress_bad_input(self):
 
     # Test that compress()->decompress() preserves the input data.
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_roundtrip(self):
         cdata = lzma.compress(INPUT)
         ddata = lzma.decompress(cdata)
@@ -539,12 +515,10 @@ def test_decompress_multistream(self):
 
     # Test robust handling of non-LZMA data following the compressed stream(s).
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_decompress_trailing_junk(self):
         ddata = lzma.decompress(COMPRESSED_XZ + COMPRESSED_BOGUS)
         self.assertEqual(ddata, INPUT)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_decompress_multistream_trailing_junk(self):
         ddata = lzma.decompress(COMPRESSED_XZ * 3 + COMPRESSED_BOGUS)
         self.assertEqual(ddata, INPUT * 3)
@@ -581,7 +555,7 @@ def test_init(self):
             self.assertIsInstance(f, LZMAFile)
             self.assertEqual(f.mode, "wb")
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AssertionError: <FakePath '@test_23396_tmp챈'> != '@test_23396_tmp챈'
     def test_init_with_PathLike_filename(self):
         filename = FakePath(TESTFN)
         with TempFile(filename, COMPRESSED_XZ):
@@ -662,7 +636,7 @@ def test_init_bad_mode(self):
         with self.assertRaises(ValueError):
             LZMAFile(BytesIO(COMPRESSED_XZ), "rw")
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; TypeError: Invalid check value
     def test_init_bad_check(self):
         with self.assertRaises(TypeError):
             LZMAFile(BytesIO(), "w", check=b"asd")
@@ -683,7 +657,7 @@ def test_init_bad_check(self):
         with self.assertRaises(ValueError):
             LZMAFile(BytesIO(COMPRESSED_XZ), check=lzma.CHECK_UNKNOWN)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; OverflowError: Python int too large to convert to Rust u32
     def test_init_bad_preset(self):
         with self.assertRaises(TypeError):
             LZMAFile(BytesIO(), "w", preset=4.39)
@@ -703,7 +677,7 @@ def test_init_bad_preset(self):
         with self.assertRaises(ValueError):
             LZMAFile(BytesIO(COMPRESSED_XZ), preset=3)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; lzma.LZMAError: Failed to initialize encoder
     def test_init_bad_filter_spec(self):
         with self.assertRaises(TypeError):
             LZMAFile(BytesIO(), "w", filters=[b"wobsite"])
@@ -721,7 +695,7 @@ def test_init_bad_filter_spec(self):
             LZMAFile(BytesIO(), "w",
                      filters=[{"id": lzma.FILTER_X86, "foo": 0}])
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; lzma.LZMAError: Invalid format
     def test_init_with_preset_and_filters(self):
         with self.assertRaises(ValueError):
             LZMAFile(BytesIO(), "w", format=lzma.FORMAT_RAW,
@@ -840,7 +814,6 @@ def test_writable(self):
             f.close()
         self.assertRaises(ValueError, f.writable)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_read(self):
         with LZMAFile(BytesIO(COMPRESSED_XZ)) as f:
             self.assertEqual(f.read(), INPUT)
@@ -888,7 +861,6 @@ def test_read_10(self):
                 chunks.append(result)
             self.assertEqual(b"".join(chunks), INPUT)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_read_multistream(self):
         with LZMAFile(BytesIO(COMPRESSED_XZ * 5)) as f:
             self.assertEqual(f.read(), INPUT * 5)
@@ -909,12 +881,10 @@ def test_read_multistream_buffer_size_aligned(self):
         finally:
             _streams.BUFFER_SIZE = saved_buffer_size
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_read_trailing_junk(self):
         with LZMAFile(BytesIO(COMPRESSED_XZ + COMPRESSED_BOGUS)) as f:
             self.assertEqual(f.read(), INPUT)
 
-    @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)
@@ -1020,7 +990,6 @@ def test_read_bad_args(self):
         with LZMAFile(BytesIO(COMPRESSED_XZ)) as f:
             self.assertRaises(TypeError, f.read, float())
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_read_bad_data(self):
         with LZMAFile(BytesIO(COMPRESSED_BOGUS)) as f:
             self.assertRaises(LZMAError, f.read)
@@ -1078,7 +1047,6 @@ def test_peek_bad_args(self):
         with LZMAFile(BytesIO(), "w") as f:
             self.assertRaises(ValueError, f.peek)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_iterator(self):
         with BytesIO(INPUT) as f:
             lines = f.readlines()
@@ -1118,7 +1086,6 @@ def test_decompress_limited(self):
         self.assertLessEqual(decomp._buffer.raw.tell(), max_decomp,
             "Excessive amount of data was decompressed")
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_write(self):
         with BytesIO() as dst:
             with LZMAFile(dst, "w") as f:
@@ -1387,7 +1354,7 @@ def test_tell_bad_args(self):
         f.close()
         self.assertRaises(ValueError, f.tell)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AssertionError: True is not false
     def test_issue21872(self):
         # sometimes decompress data incompletely
 
@@ -1471,7 +1438,7 @@ def test_filename(self):
             with lzma.open(TESTFN, "rb") as f:
                 self.assertEqual(f.read(), INPUT * 2)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AssertionError: <FakePath '@test_23396_tmp챈'> != '@test_23396_tmp챈'
     def test_with_pathlike_filename(self):
         filename = FakePath(TESTFN)
         with TempFile(filename):
@@ -1498,7 +1465,6 @@ def test_bad_params(self):
         with self.assertRaises(ValueError):
             lzma.open(TESTFN, "rb", newline="\n")
 
-    @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}
@@ -1529,7 +1495,6 @@ def test_encoding_error_handler(self):
             with lzma.open(bio, "rt", encoding="ascii", errors="ignore") as f:
                 self.assertEqual(f.read(), "foobar")
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_newline(self):
         # Test with explicit newline (universal newline mode disabled).
         text = INPUT.decode("ascii")
@@ -1554,7 +1519,6 @@ def test_x_mode(self):
 
 class MiscellaneousTestCase(unittest.TestCase):
 
-    @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.
@@ -1567,7 +1531,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))
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; TypeError: expected at most 0 arguments, got 1
     def test__encode_filter_properties(self):
         with self.assertRaises(TypeError):
             lzma._encode_filter_properties(b"not a dict")
@@ -1589,7 +1553,6 @@ def test__encode_filter_properties(self):
             })
         self.assertEqual(props, b"]\x00\x00\x80\x00")
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test__decode_filter_properties(self):
         with self.assertRaises(TypeError):
             lzma._decode_filter_properties(lzma.FILTER_X86, {"should be": bytes})
@@ -1613,7 +1576,6 @@ def test__decode_filter_properties(self):
             filterspec = lzma._decode_filter_properties(f, b"")
             self.assertEqual(filterspec, {"id": f})
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_filter_properties_roundtrip(self):
         spec1 = lzma._decode_filter_properties(
                 lzma.FILTER_LZMA1, b"]\x00\x00\x80\x00")
diff --git a/Lib/test/test_mailbox.py b/Lib/test/test_mailbox.py
index 940baf39415..0169948e453 100644
--- a/Lib/test/test_mailbox.py
+++ b/Lib/test/test_mailbox.py
@@ -1,7 +1,6 @@
 import os
 import sys
 import time
-import stat
 import socket
 import email
 import email.message
@@ -13,7 +12,6 @@
 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
@@ -1267,7 +1265,7 @@ def test_relock(self):
         self._box.close()
 
 
-class TestMbox(_TestMboxMMDF, unittest.TestCase, ExtraAssertions):
+class TestMbox(_TestMboxMMDF, unittest.TestCase):
 
     _factory = lambda self, path, factory=None: mailbox.mbox(path, factory)
 
diff --git a/Lib/test/test_marshal.py b/Lib/test/test_marshal.py
index 142b45f6a46..6234b99c242 100644
--- a/Lib/test/test_marshal.py
+++ b/Lib/test/test_marshal.py
@@ -1,5 +1,6 @@
 from test import support
-from test.support import os_helper
+from test.support import is_apple_mobile, os_helper, requires_debug_ranges, is_emscripten
+from test.support.script_helper import assert_python_ok
 import array
 import io
 import marshal
@@ -7,6 +8,7 @@
 import unittest
 import os
 import types
+import textwrap
 
 try:
     import _testcapi
@@ -26,6 +28,13 @@ def helper(self, sample, *extra):
         finally:
             os_helper.unlink(os_helper.TESTFN)
 
+def omit_last_byte(data):
+    """return data[:-1]"""
+    # This file's code is used in CompatibilityTestCase,
+    # but slices need marshal version 5.
+    # Avoid the slice literal.
+    return data[slice(0, -1)]
+
 class IntTestCase(unittest.TestCase, HelperMixin):
     def test_ints(self):
         # Test a range of Python ints larger than the machine word size.
@@ -34,8 +43,12 @@ def test_ints(self):
             for expected in (-n, n):
                 self.helper(expected)
             n = n >> 1
+        n = 1 << 100
+        while n:
+            for expected in (-n, -n+1, n-1, n):
+                self.helper(expected)
+            n = n >> 1
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_int64(self):
         # Simulate int marshaling with TYPE_INT64.
         maxint64 = (1 << 63) - 1
@@ -109,8 +122,6 @@ def test_exceptions(self):
         self.assertEqual(StopIteration, new)
 
 class CodeTestCase(unittest.TestCase):
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_code(self):
         co = ExceptionTestCase.test_exceptions.__code__
         new = marshal.loads(marshal.dumps(co))
@@ -118,8 +129,8 @@ def test_code(self):
 
     def test_many_codeobjects(self):
         # Issue2957: bad recursion count on code objects
-        count = 5000    # more than MAX_MARSHAL_STACK_DEPTH
-        codes = (ExceptionTestCase.test_exceptions.__code__,) * count
+        # more than MAX_MARSHAL_STACK_DEPTH
+        codes = (ExceptionTestCase.test_exceptions.__code__,) * 10_000
         marshal.loads(marshal.dumps(codes))
 
     def test_different_filenames(self):
@@ -129,6 +140,56 @@ def test_different_filenames(self):
         self.assertEqual(co1.co_filename, "f1")
         self.assertEqual(co2.co_filename, "f2")
 
+    def test_no_allow_code(self):
+        data = {'a': [({0},)]}
+        dump = marshal.dumps(data, allow_code=False)
+        self.assertEqual(marshal.loads(dump, allow_code=False), data)
+
+        f = io.BytesIO()
+        marshal.dump(data, f, allow_code=False)
+        f.seek(0)
+        self.assertEqual(marshal.load(f, allow_code=False), data)
+
+        co = ExceptionTestCase.test_exceptions.__code__
+        data = {'a': [({co, 0},)]}
+        dump = marshal.dumps(data, allow_code=True)
+        self.assertEqual(marshal.loads(dump, allow_code=True), data)
+        with self.assertRaises(ValueError):
+            marshal.dumps(data, allow_code=False)
+        with self.assertRaises(ValueError):
+            marshal.loads(dump, allow_code=False)
+
+        marshal.dump(data, io.BytesIO(), allow_code=True)
+        self.assertEqual(marshal.load(io.BytesIO(dump), allow_code=True), data)
+        with self.assertRaises(ValueError):
+            marshal.dump(data, io.BytesIO(), allow_code=False)
+        with self.assertRaises(ValueError):
+            marshal.load(io.BytesIO(dump), allow_code=False)
+
+    @requires_debug_ranges()
+    def test_minimal_linetable_with_no_debug_ranges(self):
+        # Make sure when demarshalling objects with `-X no_debug_ranges`
+        # that the columns are None.
+        co = ExceptionTestCase.test_exceptions.__code__
+        code = textwrap.dedent("""
+        import sys
+        import marshal
+        with open(sys.argv[1], 'rb') as f:
+            co = marshal.load(f)
+            positions = list(co.co_positions())
+            assert positions[0][2] is None
+            assert positions[0][3] is None
+        """)
+
+        try:
+            with open(os_helper.TESTFN, 'wb') as f:
+                marshal.dump(co, f)
+
+            assert_python_ok('-X', 'no_debug_ranges',
+                             '-c', code, os_helper.TESTFN)
+        finally:
+            os_helper.unlink(os_helper.TESTFN)
+
     @support.cpython_only
     def test_same_filename_used(self):
         s = """def f(): pass\ndef g(): pass"""
@@ -164,22 +225,19 @@ def test_sets(self):
 
 
 class BufferTestCase(unittest.TestCase, HelperMixin):
+
     def test_bytearray(self):
         b = bytearray(b"abc")
         self.helper(b)
         new = marshal.loads(marshal.dumps(b))
         self.assertEqual(type(new), bytes)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_memoryview(self):
         b = memoryview(b"abc")
         self.helper(b)
         new = marshal.loads(marshal.dumps(b))
         self.assertEqual(type(new), bytes)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_array(self):
         a = array.array('B', b"abc")
         new = marshal.loads(marshal.dumps(a))
@@ -194,7 +252,8 @@ def test_bug_5888452(self):
     def test_patch_873224(self):
         self.assertRaises(Exception, marshal.loads, b'0')
         self.assertRaises(Exception, marshal.loads, b'f')
-        self.assertRaises(Exception, marshal.loads, marshal.dumps(2**65)[:-1])
+        self.assertRaises(Exception, marshal.loads,
+                          omit_last_byte(marshal.dumps(2**65)))
 
     def test_version_argument(self):
         # Python 2.4.0 crashes for any call to marshal.dumps(x, y)
@@ -211,8 +270,6 @@ def test_fuzz(self):
             except Exception:
                 pass
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_loads_recursion(self):
         def run_tests(N, check):
             # (((...None...),),)
@@ -232,16 +289,19 @@ def check(s):
             self.assertRaises(ValueError, marshal.loads, s)
         run_tests(2**20, check)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON; segfault
+    @unittest.skipIf(support.is_android, "TODO: RUSTPYTHON; segfault")
+    @unittest.skipIf(os.name == 'nt', "TODO: RUSTPYTHON; write depth limit is 2000 not 1000")
     def test_recursion_limit(self):
         # Create a deeply nested structure.
         head = last = []
         # The max stack depth should match the value in Python/marshal.c.
         # BUG: https://bugs.python.org/issue33720
         # Windows always limits the maximum depth on release and debug builds
-        #if os.name == 'nt' and hasattr(sys, 'gettotalrefcount'):
+        #if os.name == 'nt' and support.Py_DEBUG:
         if os.name == 'nt':
             MAX_MARSHAL_STACK_DEPTH = 1000
+        elif sys.platform == 'wasi' or is_emscripten or is_apple_mobile:
+            MAX_MARSHAL_STACK_DEPTH = 1500
         else:
             MAX_MARSHAL_STACK_DEPTH = 2000
         for i in range(MAX_MARSHAL_STACK_DEPTH - 2):
@@ -259,8 +319,6 @@ def test_recursion_limit(self):
         last.append([0])
         self.assertRaises(ValueError, marshal.dumps, head)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_exact_type_match(self):
         # Former bug:
         #   >>> class Int(int): pass
@@ -284,8 +342,6 @@ def test_invalid_longs(self):
         invalid_string = b'l\x02\x00\x00\x00\x00\x00\x00\x00'
         self.assertRaises(ValueError, marshal.loads, invalid_string)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_multiple_dumps_and_loads(self):
         # Issue 12291: marshal.load() should be callable multiple times
         # with interleaved data written by non-marshal code
@@ -315,8 +371,7 @@ def test_loads_reject_unicode_strings(self):
         unicode_string = 'T'
         self.assertRaises(TypeError, marshal.loads, unicode_string)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_bad_reader(self):
         class BadReader(io.BytesIO):
             def readinto(self, buf):
@@ -333,6 +388,56 @@ def test_eof(self):
         for i in range(len(data)):
             self.assertRaises(EOFError, marshal.loads, data[0: i])
 
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    def test_deterministic_sets(self):
+        # bpo-37596: To support reproducible builds, sets and frozensets need to
+        # have their elements serialized in a consistent order (even when they
+        # have been scrambled by hash randomization):
+        for kind in ("set", "frozenset"):
+            for elements in (
+                "float('nan'), b'a', b'b', b'c', 'x', 'y', 'z'",
+                # Also test for bad interactions with backreferencing:
+                "('Spam', 0), ('Spam', 1), ('Spam', 2), ('Spam', 3), ('Spam', 4), ('Spam', 5)",
+            ):
+                s = f"{kind}([{elements}])"
+                with self.subTest(s):
+                    # First, make sure that our test case still has different
+                    # orders under hash seeds 0 and 1. If this check fails, we
+                    # need to update this test with different elements. Skip
+                    # this part if we are configured to use any other hash
+                    # algorithm (for example, using Py_HASH_EXTERNAL):
+                    if sys.hash_info.algorithm in {"fnv", "siphash24"}:
+                        args = ["-c", f"print({s})"]
+                        _, repr_0, _ = assert_python_ok(*args, PYTHONHASHSEED="0")
+                        _, repr_1, _ = assert_python_ok(*args, PYTHONHASHSEED="1")
+                        self.assertNotEqual(repr_0, repr_1)
+                    # Then, perform the actual test:
+                    args = ["-c", f"import marshal; print(marshal.dumps({s}))"]
+                    _, dump_0, _ = assert_python_ok(*args, PYTHONHASHSEED="0")
+                    _, dump_1, _ = assert_python_ok(*args, PYTHONHASHSEED="1")
+                    self.assertEqual(dump_0, dump_1)
+
+    @unittest.skip("TODO: RUSTPYTHON; unexpected payload for constant python value")
+    def test_unmarshallable(self):
+        # Check no crash after encountering unmarshallable objects.
+        # See https://github.com/python/cpython/issues/106287.
+        fset = frozenset([int])
+        code = compile("a = 1", "<string>", "exec")
+        code = code.replace(co_consts=(1, fset, None))
+        cases = (('tuple', (fset,)),
+                 ('list', [fset]),
+                 ('set', fset),
+                 ('dict key', {fset: 'x'}),
+                 ('dict value', {'x': fset}),
+                 ('dict key & value', {fset: fset}),
+                 ('slice', slice(fset, fset)),
+                 ('code', code))
+        for name, arg in cases:
+            with self.subTest(name, arg=arg):
+                with self.assertRaisesRegex(ValueError, "unmarshallable object"):
+                    marshal.dumps((arg, memoryview(b'')))
+
+
 LARGE_SIZE = 2**31
 pointer_size = 8 if sys.maxsize > 0xFFFFFFFF else 4
 
@@ -420,76 +525,56 @@ def helper3(self, rsample, recursive=False, simple=False):
             else:
                 self.assertGreaterEqual(len(s2), len(s3))
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def testInt(self):
         intobj = 123321
         self.helper(intobj)
         self.helper3(intobj, simple=True)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def testFloat(self):
         floatobj = 1.2345
         self.helper(floatobj)
         self.helper3(floatobj)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def testStr(self):
         strobj = "abcde"*3
         self.helper(strobj)
         self.helper3(strobj)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def testBytes(self):
         bytesobj = b"abcde"*3
         self.helper(bytesobj)
         self.helper3(bytesobj)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def testList(self):
         for obj in self.keys:
             listobj = [obj, obj]
             self.helper(listobj)
             self.helper3(listobj)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def testTuple(self):
         for obj in self.keys:
             tupleobj = (obj, obj)
             self.helper(tupleobj)
             self.helper3(tupleobj)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def testSet(self):
         for obj in self.keys:
             setobj = {(obj, 1), (obj, 2)}
             self.helper(setobj)
             self.helper3(setobj)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def testFrozenSet(self):
         for obj in self.keys:
             frozensetobj = frozenset({(obj, 1), (obj, 2)})
             self.helper(frozensetobj)
             self.helper3(frozensetobj)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def testDict(self):
         for obj in self.keys:
             dictobj = {"hello": obj, "goodbye": obj, obj: "hello"}
             self.helper(dictobj)
             self.helper3(dictobj)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def testModule(self):
         with open(__file__, "rb") as f:
             code = f.read()
@@ -533,8 +618,7 @@ class InterningTestCase(unittest.TestCase, HelperMixin):
     strobj = "this is an interned string"
     strobj = sys.intern(strobj)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def testIntern(self):
         s = marshal.loads(marshal.dumps(self.strobj))
         self.assertEqual(s, self.strobj)
@@ -549,6 +633,19 @@ def testNoIntern(self):
         s2 = sys.intern(s)
         self.assertNotEqual(id(s2), id(s))
 
+class SliceTestCase(unittest.TestCase, HelperMixin):
+    def test_slice(self):
+        for obj in (
+            slice(None), slice(1), slice(1, 2), slice(1, 2, 3),
+            slice({'set'}, ('tuple', {'with': 'dict'}, ), self.helper.__code__)
+        ):
+            with self.subTest(obj=str(obj)):
+                self.helper(obj)
+
+                for version in range(4):
+                    with self.assertRaises(ValueError):
+                        marshal.dumps(obj, version)
+
 @support.cpython_only
 @unittest.skipUnless(_testcapi, 'requires _testcapi')
 class CAPI_TestCase(unittest.TestCase, HelperMixin):
@@ -609,7 +706,7 @@ def test_read_last_object_from_file(self):
             self.assertEqual(r, obj)
 
             with open(os_helper.TESTFN, 'wb') as f:
-                f.write(data[:1])
+                f.write(omit_last_byte(data))
             with self.assertRaises(EOFError):
                 _testcapi.pymarshal_read_last_object_from_file(os_helper.TESTFN)
             os_helper.unlink(os_helper.TESTFN)
@@ -626,7 +723,7 @@ def test_read_object_from_file(self):
             self.assertEqual(p, len(data))
 
             with open(os_helper.TESTFN, 'wb') as f:
-                f.write(data[:1])
+                f.write(omit_last_byte(data))
             with self.assertRaises(EOFError):
                 _testcapi.pymarshal_read_object_from_file(os_helper.TESTFN)
             os_helper.unlink(os_helper.TESTFN)
diff --git a/Lib/test/test_math.py b/Lib/test/test_math.py
index d14336f8bac..d8a5eb27501 100644
--- a/Lib/test/test_math.py
+++ b/Lib/test/test_math.py
@@ -1738,6 +1738,7 @@ def testRadians(self):
         self.ftest('radians(-45)', math.radians(-45), -math.pi/4)
         self.ftest('radians(0)', math.radians(0), 0)
 
+    @unittest.expectedFailureIfWindows("TODO: RUSTPYTHON; Error message too long")
     @requires_IEEE_754
     def testRemainder(self):
         from fractions import Fraction
diff --git a/Lib/test/test_memoryio.py b/Lib/test/test_memoryio.py
index b6b95143621..7b321600e88 100644
--- a/Lib/test/test_memoryio.py
+++ b/Lib/test/test_memoryio.py
@@ -6,10 +6,12 @@
 import unittest
 from test import support
 
+import gc
 import io
 import _pyio as pyio
 import pickle
 import sys
+import weakref
 
 class IntLike:
     def __init__(self, num):
@@ -52,6 +54,12 @@ def testSeek(self):
         self.assertEqual(buf[3:], bytesIo.read())
         self.assertRaises(TypeError, bytesIo.seek, 0.0)
 
+        self.assertEqual(sys.maxsize, bytesIo.seek(sys.maxsize))
+        self.assertEqual(self.EOF, bytesIo.read(4))
+
+        self.assertEqual(sys.maxsize - 2, bytesIo.seek(sys.maxsize - 2))
+        self.assertEqual(self.EOF, bytesIo.read(4))
+
     def testTell(self):
         buf = self.buftype("1234567890")
         bytesIo = self.ioclass(buf)
@@ -263,8 +271,8 @@ def test_iterator(self):
         memio = self.ioclass(buf * 10)
 
         self.assertEqual(iter(memio), memio)
-        self.assertTrue(hasattr(memio, '__iter__'))
-        self.assertTrue(hasattr(memio, '__next__'))
+        self.assertHasAttr(memio, '__iter__')
+        self.assertHasAttr(memio, '__next__')
         i = 0
         for line in memio:
             self.assertEqual(line, buf)
@@ -463,6 +471,39 @@ def test_getbuffer(self):
         memio.close()
         self.assertRaises(ValueError, memio.getbuffer)
 
+    def test_getbuffer_empty(self):
+        memio = self.ioclass()
+        buf = memio.getbuffer()
+        self.assertEqual(bytes(buf), b"")
+        # Trying to change the size of the BytesIO while a buffer is exported
+        # raises a BufferError.
+        self.assertRaises(BufferError, memio.write, b'x')
+        buf2 = memio.getbuffer()
+        self.assertRaises(BufferError, memio.write, b'x')
+        buf.release()
+        self.assertRaises(BufferError, memio.write, b'x')
+        buf2.release()
+        memio.write(b'x')
+
+    def test_getbuffer_gc_collect(self):
+        memio = self.ioclass(b"1234567890")
+        buf = memio.getbuffer()
+        memiowr = weakref.ref(memio)
+        bufwr = weakref.ref(buf)
+        # Create a reference loop.
+        a = [buf]
+        a.append(a)
+        # The Python implementation emits an unraisable exception.
+        with support.catch_unraisable_exception():
+            del memio
+        del buf
+        del a
+        # The C implementation emits an unraisable exception.
+        with support.catch_unraisable_exception():
+            gc.collect()
+        self.assertIsNone(memiowr())
+        self.assertIsNone(bufwr())
+
     def test_read1(self):
         buf = self.buftype("1234567890")
         self.assertEqual(self.ioclass(buf).read1(), buf)
@@ -517,6 +558,14 @@ def test_relative_seek(self):
         memio.seek(1, 1)
         self.assertEqual(memio.read(), buf[1:])
 
+    def test_issue141311(self):
+        memio = self.ioclass()
+        # Seek allows PY_SSIZE_T_MAX, read should handle that.
+        # Past end of buffer read should always return 0 (EOF).
+        self.assertEqual(sys.maxsize, memio.seek(sys.maxsize))
+        buf = bytearray(2)
+        self.assertEqual(0, memio.readinto(buf))
+
     def test_unicode(self):
         memio = self.ioclass()
 
@@ -538,6 +587,75 @@ def test_issue5449(self):
         self.ioclass(initial_bytes=buf)
         self.assertRaises(TypeError, self.ioclass, buf, foo=None)
 
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; TypeError: a bytes-like object is required, not 'B'
+    def test_write_concurrent_close(self):
+        class B:
+            def __buffer__(self, flags):
+                memio.close()
+                return memoryview(b"A")
+
+        memio = self.ioclass()
+        self.assertRaises(ValueError, memio.write, B())
+
+    # Prevent crashes when memio.write() or memio.writelines()
+    # concurrently mutates (e.g., closes or exports) 'memio'.
+    # See: https://github.com/python/cpython/issues/143378.
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; TypeError: a bytes-like object is required, not 'B'
+    def test_writelines_concurrent_close(self):
+        class B:
+            def __buffer__(self, flags):
+                memio.close()
+                return memoryview(b"A")
+
+        memio = self.ioclass()
+        self.assertRaises(ValueError, memio.writelines, [B()])
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; TypeError: a bytes-like object is required, not 'B'
+    def test_write_concurrent_export(self):
+        class B:
+            buf = None
+            def __buffer__(self, flags):
+                self.buf = memio.getbuffer()
+                return memoryview(b"A")
+
+        memio = self.ioclass()
+        self.assertRaises(BufferError, memio.write, B())
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; TypeError: a bytes-like object is required, not 'B'
+    def test_writelines_concurrent_export(self):
+        class B:
+            buf = None
+            def __buffer__(self, flags):
+                self.buf = memio.getbuffer()
+                return memoryview(b"A")
+
+        memio = self.ioclass()
+        self.assertRaises(BufferError, memio.writelines, [B()])
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; TypeError: a bytes-like object is required, not 'B'
+    def test_write_mutating_buffer(self):
+        # Test that buffer is exported only once during write().
+        # See: https://github.com/python/cpython/issues/143602.
+        class B:
+            count = 0
+            def __buffer__(self, flags):
+                self.count += 1
+                if self.count == 1:
+                    return memoryview(b"AAA")
+                else:
+                    return memoryview(b"BBBBBBBBB")
+
+        memio = self.ioclass(b'0123456789')
+        memio.seek(2)
+        b = B()
+        n = memio.write(b)
+
+        self.assertEqual(b.count, 1)
+        self.assertEqual(n, 3)
+        self.assertEqual(memio.getvalue(), b"01AAA56789")
+        self.assertEqual(memio.tell(), 5)
+
 
 class TextIOTestMixin:
 
@@ -724,54 +842,6 @@ class CBytesIOTest(PyBytesIOTest):
     ioclass = io.BytesIO
     UnsupportedOperation = io.UnsupportedOperation
 
-    def test_bytes_array(self):
-        super().test_bytes_array()
-
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    def test_flags(self):
-        super().test_flags()
-
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    def test_getbuffer(self):
-        super().test_getbuffer()
-
-    def test_init(self):
-        super().test_init()
-
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    def test_issue5449(self):
-        super().test_issue5449()
-
-    def test_read(self):
-        super().test_read()
-
-    def test_readline(self):
-        super().test_readline()
-
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    def test_relative_seek(self):
-        super().test_relative_seek()
-
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    def test_seek(self):
-        super().test_seek()
-
-    def test_subclassing(self):
-        super().test_subclassing()
-
-    def test_truncate(self):
-        super().test_truncate()
-
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    def test_write(self):
-        super().test_write()
-
     def test_getstate(self):
         memio = self.ioclass()
         state = memio.__getstate__()
@@ -783,8 +853,7 @@ def test_getstate(self):
         memio.close()
         self.assertRaises(ValueError, memio.__getstate__)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; TypeError: Expected type 'bytes' but 'bytearray' found.
     def test_setstate(self):
         # This checks whether __setstate__ does proper input validation.
         memio = self.ioclass()
@@ -816,7 +885,7 @@ def test_sizeof(self):
 
     def _test_cow_mutation(self, mutation):
         # Common code for all BytesIO copy-on-write mutation tests.
-        imm = b' ' * 1024
+        imm = (' ' * 1024).encode("ascii")
         old_rc = sys.getrefcount(imm)
         memio = self.ioclass(imm)
         self.assertEqual(sys.getrefcount(imm), old_rc + 1)
@@ -857,79 +926,25 @@ def test_cow_mutable(self):
         memio = self.ioclass(ba)
         self.assertEqual(sys.getrefcount(ba), old_rc)
 
-class CStringIOTest(PyStringIOTest):
-    ioclass = io.StringIO
-    UnsupportedOperation = io.UnsupportedOperation
-
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    def test_detach(self):
-        super().test_detach()
-
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AssertionError: ValueError not raised by writable
     def test_flags(self):
-        super().test_flags()
-
-    def test_init(self):
-        super().test_init()
-
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    def test_issue5265(self):
-        super().test_issue5265()
-
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    def test_newline_cr(self):
-        super().test_newline_cr()
-
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    def test_newline_crlf(self):
-        super().test_newline_crlf()
-
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    def test_newline_empty(self):
-        super().test_newline_empty()
-
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    def test_newline_none(self):
-        super().test_newline_none()
-
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    def test_newlines_property(self):
-        super().test_newlines_property()
-
-    def test_read(self):
-        super().test_read()
-
-    def test_readline(self):
-        super().test_readline()
+        return super().test_flags()
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    def test_relative_seek(self):
-        super().test_relative_seek()
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AssertionError: ValueError not raised by write
+    def test_write(self):
+        return super().test_write()
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; OverflowError: Python int too large to convert to Rust u64
     def test_seek(self):
-        super().test_seek()
-
-    def test_textio_properties(self):
-        super().test_textio_properties()
+        return super().test_seek()
 
-    def test_truncate(self):
-        super().test_truncate()
+class CStringIOTest(PyStringIOTest):
+    ioclass = io.StringIO
+    UnsupportedOperation = io.UnsupportedOperation
 
     # XXX: For the Python version of io.StringIO, this is highly
     # dependent on the encoding used for the underlying buffer.
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AssertionError: 8 != 2
     def test_widechar(self):
         buf = self.buftype("\U0002030a\U00020347")
         memio = self.ioclass(buf)
@@ -954,8 +969,7 @@ def test_getstate(self):
         memio.close()
         self.assertRaises(ValueError, memio.__getstate__)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AssertionError: ValueError not raised by __setstate__
     def test_setstate(self):
         # This checks whether __setstate__ does proper input validation.
         memio = self.ioclass()
@@ -973,47 +987,49 @@ def test_setstate(self):
         memio.close()
         self.assertRaises(ValueError, memio.__setstate__, ("closed", "", 0, None))
 
-
-class CStringIOPickleTest(PyStringIOPickleTest):
-    UnsupportedOperation = io.UnsupportedOperation
-
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; +
     def test_issue5265(self):
-        super().test_issue5265()
-
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    def test_newline_cr(self):
-        super().test_newline_cr()
-
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    def test_newline_crlf(self):
-        super().test_newline_crlf()
+        return super().test_issue5265()
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; ?                      ++++
     def test_newline_empty(self):
-        super().test_newline_empty()
+        return super().test_newline_empty()
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; ?                   ^^^^^
     def test_newline_none(self):
-        super().test_newline_none()
+        return super().test_newline_none()
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AssertionError: OSError not raised by seek
+    def test_relative_seek(self):
+        return super().test_relative_seek()
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AssertionError: ValueError not raised by writable
+    def test_flags(self):
+        return super().test_flags()
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AttributeError: 'StringIO' object has no attribute 'detach'
+    def test_detach(self):
+        return super().test_detach()
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AttributeError: 'StringIO' object has no attribute 'newlines'. Did you mean: 'readlines'?
     def test_newlines_property(self):
-        super().test_newlines_property()
+        return super().test_newlines_property()
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    def test_relative_seek(self):
-        super().test_relative_seek()
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; OverflowError: Python int too large to convert to Rust u64
+    def test_seek(self):
+        return super().test_seek()
 
-    def test_textio_properties(self):
-        super().test_textio_properties()
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; d
+    def test_newline_cr(self):
+        return super().test_newline_cr()
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; d
+    def test_newline_crlf(self):
+        return super().test_newline_crlf()
+
+
+class CStringIOPickleTest(PyStringIOPickleTest):
+    UnsupportedOperation = io.UnsupportedOperation
 
     class ioclass(io.StringIO):
         def __new__(cls, *args, **kwargs):
@@ -1021,6 +1037,34 @@ def __new__(cls, *args, **kwargs):
         def __init__(self, *args, **kwargs):
             pass
 
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; +
+    def test_issue5265(self):
+        return super().test_issue5265()
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; ?                      ++++
+    def test_newline_empty(self):
+        return super().test_newline_empty()
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; ?                   ^^^^^
+    def test_newline_none(self):
+        return super().test_newline_none()
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AssertionError: OSError not raised by seek
+    def test_relative_seek(self):
+        return super().test_relative_seek()
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AttributeError: 'StringIO' object has no attribute 'newlines'. Did you mean: 'readlines'?
+    def test_newlines_property(self):
+        return super().test_newlines_property()
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; d
+    def test_newline_cr(self):
+        return super().test_newline_cr()
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; d
+    def test_newline_crlf(self):
+        return super().test_newline_crlf()
+
 
 if __name__ == '__main__':
     unittest.main()
diff --git a/Lib/test/test_memoryview.py b/Lib/test/test_memoryview.py
index 5ab9441da4f..891c4d76745 100644
--- a/Lib/test/test_memoryview.py
+++ b/Lib/test/test_memoryview.py
@@ -13,8 +13,15 @@
 import io
 import copy
 import pickle
+import struct
 
-from test.support import import_helper
+from itertools import product
+from test import support
+from test.support import import_helper, threading_helper
+
+
+class MyObject:
+    pass
 
 
 class AbstractMemoryTests:
@@ -53,12 +60,53 @@ def test_getitem(self):
         for tp in self._types:
             self.check_getitem_with_type(tp)
 
+    def test_index(self):
+        for tp in self._types:
+            b = tp(self._source)
+            m = self._view(b)  # may be a sub-view
+            l = m.tolist()
+            k = 2 * len(self._source)
+
+            for chi in self._source:
+                if chi in l:
+                    self.assertEqual(m.index(chi), l.index(chi))
+                else:
+                    self.assertRaises(ValueError, m.index, chi)
+
+                for start, stop in product(range(-k, k), range(-k, k)):
+                    index = -1
+                    try:
+                        index = l.index(chi, start, stop)
+                    except ValueError:
+                        pass
+
+                    if index == -1:
+                        self.assertRaises(ValueError, m.index, chi, start, stop)
+                    else:
+                        self.assertEqual(m.index(chi, start, stop), index)
+
     def test_iter(self):
         for tp in self._types:
             b = tp(self._source)
             m = self._view(b)
             self.assertEqual(list(m), [m[i] for i in range(len(m))])
 
+    def test_count(self):
+        for tp in self._types:
+            b = tp(self._source)
+            m = self._view(b)
+            l = m.tolist()
+            for ch in list(m):
+                self.assertEqual(m.count(ch), l.count(ch))
+
+            b = tp((b'a' * 5) + (b'c' * 3))
+            m = self._view(b)  # may be sliced
+            l = m.tolist()
+            with self.subTest('count', buffer=b):
+                self.assertEqual(m.count(ord('a')), l.count(ord('a')))
+                self.assertEqual(m.count(ord('b')), l.count(ord('b')))
+                self.assertEqual(m.count(ord('c')), l.count(ord('c')))
+
     def test_setitem_readonly(self):
         if not self.ro_type:
             self.skipTest("no read-only type to test")
@@ -191,16 +239,12 @@ def check_attributes_with_type(self, tp):
         self.assertEqual(m.suboffsets, ())
         return m
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_attributes_readonly(self):
         if not self.ro_type:
             self.skipTest("no read-only type to test")
         m = self.check_attributes_with_type(self.ro_type)
         self.assertEqual(m.readonly, True)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_attributes_writable(self):
         if not self.rw_type:
             self.skipTest("no writable type to test")
@@ -231,8 +275,6 @@ def __init__(self, base):
                     self.m = memoryview(base)
             class MySource(tp):
                 pass
-            class MyObject:
-                pass
 
             # Create a reference cycle through a memoryview object.
             # This exercises mbuf_clear().
@@ -345,6 +387,21 @@ def test_hash_writable(self):
         m = self._view(b)
         self.assertRaises(ValueError, hash, m)
 
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; re-entrant buffer release not detected
+    def test_hash_use_after_free(self):
+        # Prevent crash in memoryview(v).__hash__ with re-entrant v.__hash__.
+        # Regression test for https://github.com/python/cpython/issues/142664.
+        class E(array.array):
+            def __hash__(self):
+                mv.release()
+                self.clear()
+                return 123
+
+        v = E('B', b'A' * 4096)
+        mv = memoryview(v).toreadonly()   # must be read-only for hash()
+        self.assertRaises(BufferError, hash, mv)
+        self.assertRaises(BufferError, mv.__hash__)
+
     def test_weakref(self):
         # Check memoryviews are weakrefable
         for tp in self._types:
@@ -400,6 +457,21 @@ def test_issue22668(self):
         self.assertEqual(c.format, "H")
         self.assertEqual(d.format, "H")
 
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; re-entrant buffer release not detected
+    def test_hex_use_after_free(self):
+        # Prevent UAF in memoryview.hex(sep) with re-entrant sep.__len__.
+        # Regression test for https://github.com/python/cpython/issues/143195.
+        ba = bytearray(b'A' * 1024)
+        mv = memoryview(ba)
+
+        class S(bytes):
+            def __len__(self):
+                mv.release()
+                ba.clear()
+                return 1
+
+        self.assertRaises(BufferError, mv.hex, S(b':'))
+
 
 # Variations on source objects for the buffer: bytes-like objects, then arrays
 # with itemsize > 1.
@@ -439,6 +511,18 @@ def _view(self, obj):
     def _check_contents(self, tp, obj, contents):
         self.assertEqual(obj, tp(contents))
 
+    def test_count(self):
+        super().test_count()
+        for tp in self._types:
+            b = tp((b'a' * 5) + (b'c' * 3))
+            m = self._view(b)  # should not be sliced
+            self.assertEqual(len(b), len(m))
+            with self.subTest('count', buffer=b):
+                self.assertEqual(m.count(ord('a')), 5)
+                self.assertEqual(m.count(ord('b')), 0)
+                self.assertEqual(m.count(ord('c')), 3)
+
+
 class BaseMemorySliceTests:
     source_bytes = b"XabcdefY"
 
@@ -472,11 +556,6 @@ def _check_contents(self, tp, obj, contents):
 class BytesMemoryviewTest(unittest.TestCase,
     BaseMemoryviewTests, BaseBytesMemoryTests):
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    def test_gc(self):
-        super().test_gc()
-
     def test_constructor(self):
         for tp in self._types:
             ob = tp(self._source)
@@ -487,6 +566,10 @@ def test_constructor(self):
             self.assertRaises(TypeError, memoryview, argument=ob)
             self.assertRaises(TypeError, memoryview, ob, argument=True)
 
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AssertionError: False is not true : <test.test_memoryview.MyObject object at 0x84ecb1920>
+    def test_gc(self):
+        return super().test_gc()
+
 class ArrayMemoryviewTest(unittest.TestCase,
     BaseMemoryviewTests, BaseArrayMemoryTests):
 
@@ -501,24 +584,24 @@ def test_array_assign(self):
 
 class BytesMemorySliceTest(unittest.TestCase,
     BaseMemorySliceTests, BaseBytesMemoryTests):
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    def test_gc(self):
-        super().test_gc()
     pass
 
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AssertionError: False is not true : <test.test_memoryview.MyObject object at 0x84ecb13e0>
+    def test_gc(self):
+        return super().test_gc()
+
 class ArrayMemorySliceTest(unittest.TestCase,
     BaseMemorySliceTests, BaseArrayMemoryTests):
     pass
 
 class BytesMemorySliceSliceTest(unittest.TestCase,
     BaseMemorySliceSliceTests, BaseBytesMemoryTests):
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    def test_gc(self):
-        super().test_gc()
     pass
 
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AssertionError: False is not true : <test.test_memoryview.MyObject object at 0x84ddca1c0>
+    def test_gc(self):
+        return super().test_gc()
+
 class ArrayMemorySliceSliceTest(unittest.TestCase,
     BaseMemorySliceSliceTests, BaseArrayMemoryTests):
     pass
@@ -544,6 +627,14 @@ def test_ctypes_cast(self):
                 m[2:] = memoryview(p6).cast(format)[2:]
                 self.assertEqual(d.value, 0.6)
 
+    def test_half_float(self):
+        half_data = struct.pack('eee', 0.0, -1.5, 1.5)
+        float_data = struct.pack('fff', 0.0, -1.5, 1.5)
+        half_view = memoryview(half_data).cast('e')
+        float_view = memoryview(float_data).cast('f')
+        self.assertEqual(half_view.nbytes * 2, float_view.nbytes)
+        self.assertListEqual(half_view.tolist(), float_view.tolist())
+
     def test_memoryview_hex(self):
         # Issue #9951: memoryview.hex() segfaults with non-contiguous buffers.
         x = b'0' * 200000
@@ -551,6 +642,26 @@ def test_memoryview_hex(self):
         m2 = m1[::-1]
         self.assertEqual(m2.hex(), '30' * 200000)
 
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; TypeError: Unexpected keyword argument sep
+    def test_memoryview_hex_separator(self):
+        x = bytes(range(97, 102))
+        m1 = memoryview(x)
+        m2 = m1[::-1]
+        self.assertEqual(m2.hex(':'), '65:64:63:62:61')
+        self.assertEqual(m2.hex(':', 2), '65:6463:6261')
+        self.assertEqual(m2.hex(':', -2), '6564:6362:61')
+        self.assertEqual(m2.hex(sep=':', bytes_per_sep=2), '65:6463:6261')
+        self.assertEqual(m2.hex(sep=':', bytes_per_sep=-2), '6564:6362:61')
+        for bytes_per_sep in 5, -5, 2**31-1, -(2**31-1):
+            with self.subTest(bytes_per_sep=bytes_per_sep):
+                self.assertEqual(m2.hex(':', bytes_per_sep), '6564636261')
+        for bytes_per_sep in 2**31, -2**31, 2**1000, -2**1000:
+            with self.subTest(bytes_per_sep=bytes_per_sep):
+                try:
+                    self.assertEqual(m2.hex(':', bytes_per_sep), '6564636261')
+                except OverflowError:
+                    pass
+
     def test_copy(self):
         m = memoryview(b'abc')
         with self.assertRaises(TypeError):
@@ -562,8 +673,7 @@ def test_pickle(self):
             with self.assertRaises(TypeError):
                 pickle.dumps(m, proto)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AssertionError: ValueError not raised
     def test_use_released_memory(self):
         # gh-92888: Previously it was possible to use a memoryview even after
         # backing buffer is freed in certain cases. This tests that those
@@ -666,5 +776,56 @@ def __bool__(self):
             m[0] = MyBool()
         self.assertEqual(ba[:8], b'\0'*8)
 
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AttributeError: 'memoryview' object has no attribute '__buffer__'
+    def test_buffer_reference_loop(self):
+        m = memoryview(b'abc').__buffer__(0)
+        o = MyObject()
+        o.m = m
+        o.o = o
+        wr = weakref.ref(o)
+        del m, o
+        gc.collect()
+        self.assertIsNone(wr())
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AttributeError: module 'pickle' has no attribute 'PickleBuffer'
+    def test_picklebuffer_reference_loop(self):
+        pb = pickle.PickleBuffer(memoryview(b'abc'))
+        o = MyObject()
+        o.pb = pb
+        o.o = o
+        wr = weakref.ref(o)
+        del pb, o
+        gc.collect()
+        self.assertIsNone(wr())
+
+
+@threading_helper.requires_working_threading()
+@support.requires_resource("cpu")
+class RacingTest(unittest.TestCase):
+    def test_racing_getbuf_and_releasebuf(self):
+        """Repeatly access the memoryview for racing."""
+        try:
+            from multiprocessing.managers import SharedMemoryManager
+        except ImportError:
+            self.skipTest("Test requires multiprocessing")
+        from threading import Thread, Event
+
+        start = Event()
+        with SharedMemoryManager() as smm:
+            obj = smm.ShareableList(range(100))
+            def test():
+                # Issue gh-127085, the `ShareableList.count` is just a
+                # convenient way to mess the `exports` counter of `memoryview`,
+                # this issue has no direct relation with `ShareableList`.
+                start.wait(support.SHORT_TIMEOUT)
+                for i in range(10):
+                    obj.count(1)
+            threads = [Thread(target=test) for _ in range(10)]
+            with threading_helper.start_threads(threads):
+                start.set()
+
+            del obj
+
+
 if __name__ == "__main__":
     unittest.main()
diff --git a/Lib/test/test_metaclass.py b/Lib/test/test_metaclass.py
new file mode 100644
index 00000000000..1707df9075a
--- /dev/null
+++ b/Lib/test/test_metaclass.py
@@ -0,0 +1,321 @@
+import doctest
+import unittest
+
+
+doctests = """
+
+Basic class construction.
+
+    >>> class C:
+    ...     def meth(self): print("Hello")
+    ...
+    >>> C.__class__ is type
+    True
+    >>> a = C()
+    >>> a.__class__ is C
+    True
+    >>> a.meth()
+    Hello
+    >>>
+
+Use *args notation for the bases.
+
+    >>> class A: pass
+    >>> class B: pass
+    >>> bases = (A, B)
+    >>> class C(*bases): pass
+    >>> C.__bases__ == bases
+    True
+    >>>
+
+Use a trivial metaclass.
+
+    >>> class M(type):
+    ...     pass
+    ...
+    >>> class C(metaclass=M):
+    ...    def meth(self): print("Hello")
+    ...
+    >>> C.__class__ is M
+    True
+    >>> a = C()
+    >>> a.__class__ is C
+    True
+    >>> a.meth()
+    Hello
+    >>>
+
+Use **kwds notation for the metaclass keyword.
+
+    >>> kwds = {'metaclass': M}
+    >>> class C(**kwds): pass
+    ...
+    >>> C.__class__ is M
+    True
+    >>> a = C()
+    >>> a.__class__ is C
+    True
+    >>>
+
+Use a metaclass with a __prepare__ static method.
+
+    >>> class M(type):
+    ...    @staticmethod
+    ...    def __prepare__(*args, **kwds):
+    ...        print("Prepare called:", args, kwds)
+    ...        return dict()
+    ...    def __new__(cls, name, bases, namespace, **kwds):
+    ...        print("New called:", kwds)
+    ...        return type.__new__(cls, name, bases, namespace)
+    ...    def __init__(cls, *args, **kwds):
+    ...        pass
+    ...
+    >>> class C(metaclass=M):
+    ...     def meth(self): print("Hello")
+    ...
+    Prepare called: ('C', ()) {}
+    New called: {}
+    >>>
+
+Also pass another keyword.
+
+    >>> class C(object, metaclass=M, other="haha"):
+    ...     pass
+    ...
+    Prepare called: ('C', (<class 'object'>,)) {'other': 'haha'}
+    New called: {'other': 'haha'}
+    >>> C.__class__ is M
+    True
+    >>> C.__bases__ == (object,)
+    True
+    >>> a = C()
+    >>> a.__class__ is C
+    True
+    >>>
+
+Check that build_class doesn't mutate the kwds dict.
+
+    >>> kwds = {'metaclass': type}
+    >>> class C(**kwds): pass
+    ...
+    >>> kwds == {'metaclass': type}
+    True
+    >>>
+
+Use various combinations of explicit keywords and **kwds.
+
+    >>> bases = (object,)
+    >>> kwds = {'metaclass': M, 'other': 'haha'}
+    >>> class C(*bases, **kwds): pass
+    ...
+    Prepare called: ('C', (<class 'object'>,)) {'other': 'haha'}
+    New called: {'other': 'haha'}
+    >>> C.__class__ is M
+    True
+    >>> C.__bases__ == (object,)
+    True
+    >>> class B: pass
+    >>> kwds = {'other': 'haha'}
+    >>> class C(B, metaclass=M, *bases, **kwds): pass
+    ...
+    Prepare called: ('C', (<class 'test.test_metaclass.B'>, <class 'object'>)) {'other': 'haha'}
+    New called: {'other': 'haha'}
+    >>> C.__class__ is M
+    True
+    >>> C.__bases__ == (B, object)
+    True
+    >>>
+
+Check for duplicate keywords.
+
+    # TODO: RUSTPYTHON
+    >>> class C(metaclass=type, metaclass=type): pass # doctest: +SKIP
+    ...
+    Traceback (most recent call last):
+    [...]
+    SyntaxError: keyword argument repeated: metaclass
+    >>>
+
+Another way.
+
+    >>> kwds = {'metaclass': type}
+
+    # TODO: RUSTPYTHON
+    >>> class C(metaclass=type, **kwds): pass # doctest: +SKIP
+    ...
+    Traceback (most recent call last):
+    [...]
+    TypeError: __build_class__() got multiple values for keyword argument 'metaclass'
+    >>>
+
+Use a __prepare__ method that returns an instrumented dict.
+
+    >>> class LoggingDict(dict):
+    ...     def __setitem__(self, key, value):
+    ...         print("d[%r] = %r" % (key, value))
+    ...         dict.__setitem__(self, key, value)
+    ...
+    >>> class Meta(type):
+    ...    @staticmethod
+    ...    def __prepare__(name, bases):
+    ...        return LoggingDict()
+    ...
+
+    # TODO: RUSTPYTHON
+    >>> class C(metaclass=Meta): # doctest: +SKIP
+    ...     foo = 2+2
+    ...     foo = 42
+    ...     bar = 123
+    ...
+    d['__module__'] = 'test.test_metaclass'
+    d['__qualname__'] = 'C'
+    d['__firstlineno__'] = 1
+    d['foo'] = 4
+    d['foo'] = 42
+    d['bar'] = 123
+    d['__static_attributes__'] = ()
+    >>>
+
+Use a metaclass that doesn't derive from type.
+
+    >>> def meta(name, bases, namespace, **kwds):
+    ...     print("meta:", name, bases)
+    ...     print("ns:", sorted(namespace.items()))
+    ...     print("kw:", sorted(kwds.items()))
+    ...     return namespace
+    ...
+
+    # TODO: RUSTPYTHON
+    >>> class C(metaclass=meta): # doctest: +SKIP
+    ...     a = 42
+    ...     b = 24
+    ...
+    meta: C ()
+    ns: [('__firstlineno__', 1), ('__module__', 'test.test_metaclass'), ('__qualname__', 'C'), ('__static_attributes__', ()), ('a', 42), ('b', 24)]
+    kw: []
+
+    # TODO: RUSTPYTHON
+    >>> type(C) is dict # doctest: +SKIP
+    True
+
+    # TODO: RUSTPYTHON
+    >>> print(sorted(C.items())) # doctest: +SKIP
+    [('__firstlineno__', 1), ('__module__', 'test.test_metaclass'), ('__qualname__', 'C'), ('__static_attributes__', ()), ('a', 42), ('b', 24)]
+    >>>
+
+And again, with a __prepare__ attribute.
+
+    >>> def prepare(name, bases, **kwds):
+    ...     print("prepare:", name, bases, sorted(kwds.items()))
+    ...     return LoggingDict()
+    ...
+    >>> meta.__prepare__ = prepare
+
+    # TODO: RUSTPYTHON
+    >>> class C(metaclass=meta, other="booh"): # doctest: +SKIP
+    ...    a = 1
+    ...    a = 2
+    ...    b = 3
+    ...
+    prepare: C () [('other', 'booh')]
+    d['__module__'] = 'test.test_metaclass'
+    d['__qualname__'] = 'C'
+    d['__firstlineno__'] = 1
+    d['a'] = 1
+    d['a'] = 2
+    d['b'] = 3
+    d['__static_attributes__'] = ()
+    meta: C ()
+    ns: [('__firstlineno__', 1), ('__module__', 'test.test_metaclass'), ('__qualname__', 'C'), ('__static_attributes__', ()), ('a', 2), ('b', 3)]
+    kw: [('other', 'booh')]
+    >>>
+
+The default metaclass must define a __prepare__() method.
+
+    >>> type.__prepare__()
+    {}
+    >>>
+
+Make sure it works with subclassing.
+
+    >>> class M(type):
+    ...     @classmethod
+    ...     def __prepare__(cls, *args, **kwds):
+    ...         d = super().__prepare__(*args, **kwds)
+    ...         d["hello"] = 42
+    ...         return d
+    ...
+    >>> class C(metaclass=M):
+    ...     print(hello)
+    ...
+    42
+    >>> print(C.hello)
+    42
+    >>>
+
+Test failures in looking up the __prepare__ method work.
+    >>> class ObscureException(Exception):
+    ...     pass
+    >>> class FailDescr:
+    ...     def __get__(self, instance, owner):
+    ...        raise ObscureException
+    >>> class Meta(type):
+    ...     __prepare__ = FailDescr()
+    >>> class X(metaclass=Meta):
+    ...     pass
+    Traceback (most recent call last):
+    [...]
+    test.test_metaclass.ObscureException
+
+Test setting attributes with a non-base type in mro() (gh-127773).
+
+    >>> class Base:
+    ...     value = 1
+    ...
+    >>> class Meta(type):
+    ...     def mro(cls):
+    ...         return (cls, Base, object)
+    ...
+    >>> class WeirdClass(metaclass=Meta):
+    ...     pass
+    ...
+    >>> Base.value
+    1
+
+    # TODO: RUSTPYTHON; AttributeError: type object 'WeirdClass' has no attribute 'value' 
+    >>> WeirdClass.value # doctest: +SKIP
+    1
+    >>> Base.value = 2
+    >>> Base.value
+    2
+
+    # TODO: RUSTPYTHON; AttributeError: type object 'WeirdClass' has no attribute 'value' 
+    >>> WeirdClass.value # doctest: +SKIP
+    2
+    >>> Base.value = 3
+    >>> Base.value
+    3
+
+    # TODO: RUSTPYTHON; AttributeError: type object 'WeirdClass' has no attribute 'value' 
+    >>> WeirdClass.value # doctest: +SKIP
+    3
+
+"""
+
+import sys
+
+# Trace function introduces __locals__ which causes various tests to fail.
+if hasattr(sys, 'gettrace') and sys.gettrace():
+    __test__ = {}
+else:
+    __test__ = {'doctests' : doctests}
+
+def load_tests(loader, tests, pattern):
+    tests.addTest(doctest.DocTestSuite())
+    return tests
+
+
+if __name__ == "__main__":
+    # set __name__ to match doctest expectations
+    __name__ = "test.test_metaclass"
+    unittest.main()
diff --git a/Lib/test/test_minidom.py b/Lib/test/test_minidom.py
new file mode 100644
index 00000000000..26fd366355f
--- /dev/null
+++ b/Lib/test/test_minidom.py
@@ -0,0 +1,1813 @@
+# test for xml.dom.minidom
+
+import copy
+import pickle
+import io
+from test import support
+import unittest
+
+import xml.dom.minidom
+
+from xml.dom.minidom import parse, Attr, Node, Document, Element, parseString
+from xml.dom.minidom import getDOMImplementation
+from xml.parsers.expat import ExpatError
+
+
+tstfile = support.findfile("test.xml", subdir="xmltestdata")
+sample = ("<?xml version='1.0' encoding='us-ascii'?>\n"
+          "<!DOCTYPE doc PUBLIC 'http://xml.python.org/public'"
+          " 'http://xml.python.org/system' [\n"
+          "  <!ELEMENT e EMPTY>\n"
+          "  <!ENTITY ent SYSTEM 'http://xml.python.org/entity'>\n"
+          "]><doc attr='value'> text\n"
+          "<?pi sample?> <!-- comment --> <e/> </doc>")
+
+# The tests of DocumentType importing use these helpers to construct
+# the documents to work with, since not all DOM builders actually
+# create the DocumentType nodes.
+def create_doc_without_doctype(doctype=None):
+    return getDOMImplementation().createDocument(None, "doc", doctype)
+
+def create_nonempty_doctype():
+    doctype = getDOMImplementation().createDocumentType("doc", None, None)
+    doctype.entities._seq = []
+    doctype.notations._seq = []
+    notation = xml.dom.minidom.Notation("my-notation", None,
+                                        "http://xml.python.org/notations/my")
+    doctype.notations._seq.append(notation)
+    entity = xml.dom.minidom.Entity("my-entity", None,
+                                    "http://xml.python.org/entities/my",
+                                    "my-notation")
+    entity.version = "1.0"
+    entity.encoding = "utf-8"
+    entity.actualEncoding = "us-ascii"
+    doctype.entities._seq.append(entity)
+    return doctype
+
+def create_doc_with_doctype():
+    doctype = create_nonempty_doctype()
+    doc = create_doc_without_doctype(doctype)
+    doctype.entities.item(0).ownerDocument = doc
+    doctype.notations.item(0).ownerDocument = doc
+    return doc
+
+class MinidomTest(unittest.TestCase):
+    def confirm(self, test, testname = "Test"):
+        self.assertTrue(test, testname)
+
+    def checkWholeText(self, node, s):
+        t = node.wholeText
+        self.assertEqual(t, s, "looking for %r, found %r" % (s, t))
+
+    def testDocumentAsyncAttr(self):
+        doc = Document()
+        self.assertFalse(doc.async_)
+        self.assertFalse(Document.async_)
+
+    def testParseFromBinaryFile(self):
+        with open(tstfile, 'rb') as file:
+            dom = parse(file)
+            dom.unlink()
+            self.assertIsInstance(dom, Document)
+
+    def testParseFromTextFile(self):
+        with open(tstfile, 'r', encoding='iso-8859-1') as file:
+            dom = parse(file)
+            dom.unlink()
+            self.assertIsInstance(dom, Document)
+
+    def testAttrModeSetsParamsAsAttrs(self):
+        attr = Attr("qName", "namespaceURI", "localName", "prefix")
+        self.assertEqual(attr.name, "qName")
+        self.assertEqual(attr.namespaceURI, "namespaceURI")
+        self.assertEqual(attr.prefix, "prefix")
+        self.assertEqual(attr.localName, "localName")
+
+    def testAttrModeSetsNonOptionalAttrs(self):
+        attr = Attr("qName", "namespaceURI", None, "prefix")
+        self.assertEqual(attr.name, "qName")
+        self.assertEqual(attr.namespaceURI, "namespaceURI")
+        self.assertEqual(attr.prefix, "prefix")
+        self.assertEqual(attr.localName, attr.name)
+
+    def testGetElementsByTagName(self):
+        dom = parse(tstfile)
+        self.assertEqual(dom.getElementsByTagName("LI"),
+                dom.documentElement.getElementsByTagName("LI"))
+        dom.unlink()
+
+    def testInsertBefore(self):
+        dom = parseString("<doc><foo/></doc>")
+        root = dom.documentElement
+        elem = root.childNodes[0]
+        nelem = dom.createElement("element")
+        root.insertBefore(nelem, elem)
+        self.assertEqual(len(root.childNodes), 2)
+        self.assertEqual(root.childNodes.length, 2)
+        self.assertIs(root.childNodes[0], nelem)
+        self.assertIs(root.childNodes.item(0), nelem)
+        self.assertIs(root.childNodes[1], elem)
+        self.assertIs(root.childNodes.item(1), elem)
+        self.assertIs(root.firstChild, nelem)
+        self.assertIs(root.lastChild, elem)
+        self.assertEqual(root.toxml(), "<doc><element/><foo/></doc>")
+        nelem = dom.createElement("element")
+        root.insertBefore(nelem, None)
+        self.assertEqual(len(root.childNodes), 3)
+        self.assertEqual(root.childNodes.length, 3)
+        self.assertIs(root.childNodes[1], elem)
+        self.assertIs(root.childNodes.item(1), elem)
+        self.assertIs(root.childNodes[2], nelem)
+        self.assertIs(root.childNodes.item(2), nelem)
+        self.assertIs(root.lastChild, nelem)
+        self.assertIs(nelem.previousSibling, elem)
+        self.assertEqual(root.toxml(), "<doc><element/><foo/><element/></doc>")
+        nelem2 = dom.createElement("bar")
+        root.insertBefore(nelem2, nelem)
+        self.assertEqual(len(root.childNodes), 4)
+        self.assertEqual(root.childNodes.length, 4)
+        self.assertIs(root.childNodes[2], nelem2)
+        self.assertIs(root.childNodes.item(2), nelem2)
+        self.assertIs(root.childNodes[3], nelem)
+        self.assertIs(root.childNodes.item(3), nelem)
+        self.assertIs(nelem2.nextSibling, nelem)
+        self.assertIs(nelem.previousSibling, nelem2)
+        self.assertEqual(root.toxml(),
+                         "<doc><element/><foo/><bar/><element/></doc>")
+        dom.unlink()
+
+    def _create_fragment_test_nodes(self):
+        dom = parseString("<doc/>")
+        orig = dom.createTextNode("original")
+        c1 = dom.createTextNode("foo")
+        c2 = dom.createTextNode("bar")
+        c3 = dom.createTextNode("bat")
+        dom.documentElement.appendChild(orig)
+        frag = dom.createDocumentFragment()
+        frag.appendChild(c1)
+        frag.appendChild(c2)
+        frag.appendChild(c3)
+        return dom, orig, c1, c2, c3, frag
+
+    def testInsertBeforeFragment(self):
+        dom, orig, c1, c2, c3, frag = self._create_fragment_test_nodes()
+        dom.documentElement.insertBefore(frag, None)
+        self.assertTupleEqual(tuple(dom.documentElement.childNodes),
+                     (orig, c1, c2, c3),
+                     "insertBefore(<fragment>, None)")
+        frag.unlink()
+        dom.unlink()
+
+        dom, orig, c1, c2, c3, frag = self._create_fragment_test_nodes()
+        dom.documentElement.insertBefore(frag, orig)
+        self.assertTupleEqual(tuple(dom.documentElement.childNodes),
+                     (c1, c2, c3, orig),
+                     "insertBefore(<fragment>, orig)")
+        frag.unlink()
+        dom.unlink()
+
+    def testAppendChild(self):
+        dom = parse(tstfile)
+        dom.documentElement.appendChild(dom.createComment("Hello"))
+        self.assertEqual(dom.documentElement.childNodes[-1].nodeName, "#comment")
+        self.assertEqual(dom.documentElement.childNodes[-1].data, "Hello")
+        dom.unlink()
+
+    @support.requires_resource('cpu')
+    def testAppendChildNoQuadraticComplexity(self):
+        impl = getDOMImplementation()
+
+        def work(n):
+            doc = impl.createDocument(None, "some_tag", None)
+            element = doc.documentElement
+            total_calls = 0
+
+            # Count attribute accesses as a proxy for work done
+            def getattribute_counter(self, attr):
+                nonlocal total_calls
+                total_calls += 1
+                return object.__getattribute__(self, attr)
+
+            with support.swap_attr(Element, "__getattribute__", getattribute_counter):
+                for _ in range(n):
+                    child = doc.createElement("child")
+                    element.appendChild(child)
+                    element = child
+            return total_calls
+
+        # Doubling N should not ~quadruple the work.
+        w1 = work(1024)
+        w2 = work(2048)
+        w3 = work(4096)
+
+        self.assertGreater(w1, 0)
+        r1 = w2 / w1
+        r2 = w3 / w2
+        self.assertLess(
+            max(r1, r2), 3.2,
+            msg=f"Possible quadratic behavior: work={w1,w2,w3} ratios={r1,r2}"
+        )
+
+    def testSetAttributeNodeWithoutOwnerDocument(self):
+        # regression test for gh-142754
+        elem = Element("test")
+        attr = Attr("id")
+        attr.value = "test-id"
+        elem.setAttributeNode(attr)
+        self.assertEqual(elem.getAttribute("id"), "test-id")
+
+    def testAppendChildFragment(self):
+        dom, orig, c1, c2, c3, frag = self._create_fragment_test_nodes()
+        dom.documentElement.appendChild(frag)
+        self.assertTupleEqual(tuple(dom.documentElement.childNodes),
+                     (orig, c1, c2, c3),
+                     "appendChild(<fragment>)")
+        frag.unlink()
+        dom.unlink()
+
+    def testReplaceChildFragment(self):
+        dom, orig, c1, c2, c3, frag = self._create_fragment_test_nodes()
+        dom.documentElement.replaceChild(frag, orig)
+        orig.unlink()
+        self.assertTupleEqual(tuple(dom.documentElement.childNodes), (c1, c2, c3),
+                "replaceChild(<fragment>)")
+        frag.unlink()
+        dom.unlink()
+
+    def testLegalChildren(self):
+        dom = Document()
+        elem = dom.createElement('element')
+        text = dom.createTextNode('text')
+        self.assertRaises(xml.dom.HierarchyRequestErr, dom.appendChild, text)
+
+        dom.appendChild(elem)
+        self.assertRaises(xml.dom.HierarchyRequestErr, dom.insertBefore, text,
+                          elem)
+        self.assertRaises(xml.dom.HierarchyRequestErr, dom.replaceChild, text,
+                          elem)
+
+        nodemap = elem.attributes
+        self.assertRaises(xml.dom.HierarchyRequestErr, nodemap.setNamedItem,
+                          text)
+        self.assertRaises(xml.dom.HierarchyRequestErr, nodemap.setNamedItemNS,
+                          text)
+
+        elem.appendChild(text)
+        dom.unlink()
+
+    def testNamedNodeMapSetItem(self):
+        dom = Document()
+        elem = dom.createElement('element')
+        attrs = elem.attributes
+        attrs["foo"] = "bar"
+        a = attrs.item(0)
+        self.assertIs(a.ownerDocument, dom,
+                "NamedNodeMap.__setitem__() sets ownerDocument")
+        self.assertIs(a.ownerElement, elem,
+                "NamedNodeMap.__setitem__() sets ownerElement")
+        self.assertEqual(a.value, "bar",
+                "NamedNodeMap.__setitem__() sets value")
+        self.assertEqual(a.nodeValue, "bar",
+                "NamedNodeMap.__setitem__() sets nodeValue")
+        elem.unlink()
+        dom.unlink()
+
+    def testNonZero(self):
+        dom = parse(tstfile)
+        self.assertTrue(dom)  # should not be zero
+        dom.appendChild(dom.createComment("foo"))
+        self.assertFalse(dom.childNodes[-1].childNodes)
+        dom.unlink()
+
+    def testUnlink(self):
+        dom = parse(tstfile)
+        self.assertTrue(dom.childNodes)
+        dom.unlink()
+        self.assertFalse(dom.childNodes)
+
+    def testContext(self):
+        with parse(tstfile) as dom:
+            self.assertTrue(dom.childNodes)
+        self.assertFalse(dom.childNodes)
+
+    def testElement(self):
+        dom = Document()
+        dom.appendChild(dom.createElement("abc"))
+        self.assertTrue(dom.documentElement)
+        dom.unlink()
+
+    def testAAA(self):
+        dom = parseString("<abc/>")
+        el = dom.documentElement
+        el.setAttribute("spam", "jam2")
+        self.assertEqual(el.toxml(), '<abc spam="jam2"/>', "testAAA")
+        a = el.getAttributeNode("spam")
+        self.assertIs(a.ownerDocument, dom,
+                "setAttribute() sets ownerDocument")
+        self.assertIs(a.ownerElement, dom.documentElement,
+                "setAttribute() sets ownerElement")
+        dom.unlink()
+
+    def testAAB(self):
+        dom = parseString("<abc/>")
+        el = dom.documentElement
+        el.setAttribute("spam", "jam")
+        el.setAttribute("spam", "jam2")
+        self.assertEqual(el.toxml(), '<abc spam="jam2"/>', "testAAB")
+        dom.unlink()
+
+    def testAddAttr(self):
+        dom = Document()
+        child = dom.appendChild(dom.createElement("abc"))
+
+        child.setAttribute("def", "ghi")
+        self.assertEqual(child.getAttribute("def"), "ghi")
+        self.assertEqual(child.attributes["def"].value, "ghi")
+
+        child.setAttribute("jkl", "mno")
+        self.assertEqual(child.getAttribute("jkl"), "mno")
+        self.assertEqual(child.attributes["jkl"].value, "mno")
+
+        self.assertEqual(len(child.attributes), 2)
+
+        child.setAttribute("def", "newval")
+        self.assertEqual(child.getAttribute("def"), "newval")
+        self.assertEqual(child.attributes["def"].value, "newval")
+
+        self.assertEqual(len(child.attributes), 2)
+        dom.unlink()
+
+    def testDeleteAttr(self):
+        dom = Document()
+        child = dom.appendChild(dom.createElement("abc"))
+
+        self.assertEqual(len(child.attributes), 0)
+        child.setAttribute("def", "ghi")
+        self.assertEqual(len(child.attributes), 1)
+        del child.attributes["def"]
+        self.assertEqual(len(child.attributes), 0)
+        dom.unlink()
+
+    def testRemoveAttr(self):
+        dom = Document()
+        child = dom.appendChild(dom.createElement("abc"))
+
+        child.setAttribute("def", "ghi")
+        self.assertEqual(len(child.attributes), 1)
+        self.assertRaises(xml.dom.NotFoundErr, child.removeAttribute, "foo")
+        child.removeAttribute("def")
+        self.assertEqual(len(child.attributes), 0)
+        dom.unlink()
+
+    def testRemoveAttrNS(self):
+        dom = Document()
+        child = dom.appendChild(
+                dom.createElementNS("http://www.python.org", "python:abc"))
+        child.setAttributeNS("http://www.w3.org", "xmlns:python",
+                                                "http://www.python.org")
+        child.setAttributeNS("http://www.python.org", "python:abcattr", "foo")
+        self.assertRaises(xml.dom.NotFoundErr, child.removeAttributeNS,
+            "foo", "http://www.python.org")
+        self.assertEqual(len(child.attributes), 2)
+        child.removeAttributeNS("http://www.python.org", "abcattr")
+        self.assertEqual(len(child.attributes), 1)
+        dom.unlink()
+
+    def testRemoveAttributeNode(self):
+        dom = Document()
+        child = dom.appendChild(dom.createElement("foo"))
+        child.setAttribute("spam", "jam")
+        self.assertEqual(len(child.attributes), 1)
+        node = child.getAttributeNode("spam")
+        self.assertRaises(xml.dom.NotFoundErr, child.removeAttributeNode,
+            None)
+        self.assertIs(node, child.removeAttributeNode(node))
+        self.assertEqual(len(child.attributes), 0)
+        self.assertIsNone(child.getAttributeNode("spam"))
+        dom2 = Document()
+        child2 = dom2.appendChild(dom2.createElement("foo"))
+        node2 = child2.getAttributeNode("spam")
+        self.assertRaises(xml.dom.NotFoundErr, child2.removeAttributeNode,
+            node2)
+        dom.unlink()
+
+    def testHasAttribute(self):
+        dom = Document()
+        child = dom.appendChild(dom.createElement("foo"))
+        child.setAttribute("spam", "jam")
+        self.assertTrue(child.hasAttribute("spam"))
+
+    def testChangeAttr(self):
+        dom = parseString("<abc/>")
+        el = dom.documentElement
+        el.setAttribute("spam", "jam")
+        self.assertEqual(len(el.attributes), 1)
+        el.setAttribute("spam", "bam")
+        # Set this attribute to be an ID and make sure that doesn't change
+        # when changing the value:
+        el.setIdAttribute("spam")
+        self.assertEqual(len(el.attributes), 1)
+        self.assertEqual(el.attributes["spam"].value, "bam")
+        self.assertEqual(el.attributes["spam"].nodeValue, "bam")
+        self.assertEqual(el.getAttribute("spam"), "bam")
+        self.assertTrue(el.getAttributeNode("spam").isId)
+        el.attributes["spam"] = "ham"
+        self.assertEqual(len(el.attributes), 1)
+        self.assertEqual(el.attributes["spam"].value, "ham")
+        self.assertEqual(el.attributes["spam"].nodeValue, "ham")
+        self.assertEqual(el.getAttribute("spam"), "ham")
+        self.assertTrue(el.attributes["spam"].isId)
+        el.setAttribute("spam2", "bam")
+        self.assertEqual(len(el.attributes), 2)
+        self.assertEqual(el.attributes["spam"].value, "ham")
+        self.assertEqual(el.attributes["spam"].nodeValue, "ham")
+        self.assertEqual(el.getAttribute("spam"), "ham")
+        self.assertEqual(el.attributes["spam2"].value, "bam")
+        self.assertEqual(el.attributes["spam2"].nodeValue, "bam")
+        self.assertEqual(el.getAttribute("spam2"), "bam")
+        el.attributes["spam2"] = "bam2"
+
+        self.assertEqual(len(el.attributes), 2)
+        self.assertEqual(el.attributes["spam"].value, "ham")
+        self.assertEqual(el.attributes["spam"].nodeValue, "ham")
+        self.assertEqual(el.getAttribute("spam"), "ham")
+        self.assertEqual(el.attributes["spam2"].value, "bam2")
+        self.assertEqual(el.attributes["spam2"].nodeValue, "bam2")
+        self.assertEqual(el.getAttribute("spam2"), "bam2")
+        dom.unlink()
+
+    def testGetAttrList(self):
+        dom = parseString("<abc/>")
+        self.addCleanup(dom.unlink)
+        el = dom.documentElement
+        el.setAttribute("spam", "jam")
+        self.assertEqual(len(el.attributes.items()), 1)
+        el.setAttribute("foo", "bar")
+        items = el.attributes.items()
+        self.assertEqual(len(items), 2)
+        self.assertIn(('spam', 'jam'), items)
+        self.assertIn(('foo', 'bar'), items)
+
+    def testGetAttrValues(self):
+        dom = parseString("<abc/>")
+        self.addCleanup(dom.unlink)
+        el = dom.documentElement
+        el.setAttribute("spam", "jam")
+        values = [x.value for x in el.attributes.values()]
+        self.assertIn("jam", values)
+        el.setAttribute("foo", "bar")
+        values = [x.value for x in el.attributes.values()]
+        self.assertIn("bar", values)
+        self.assertIn("jam", values)
+
+    def testGetAttribute(self):
+        dom = Document()
+        child = dom.appendChild(
+            dom.createElementNS("http://www.python.org", "python:abc"))
+        self.assertEqual(child.getAttribute('missing'), '')
+
+    def testGetAttributeNS(self):
+        dom = Document()
+        child = dom.appendChild(
+                dom.createElementNS("http://www.python.org", "python:abc"))
+        child.setAttributeNS("http://www.w3.org", "xmlns:python",
+                                                "http://www.python.org")
+        self.assertEqual(child.getAttributeNS("http://www.w3.org", "python"),
+            'http://www.python.org')
+        self.assertEqual(child.getAttributeNS("http://www.w3.org", "other"),
+            '')
+        child2 = child.appendChild(dom.createElement('abc'))
+        self.assertEqual(child2.getAttributeNS("http://www.python.org", "missing"),
+                         '')
+
+    def testGetAttributeNode(self): pass
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    def testGetElementsByTagNameNS(self):
+        d="""<foo xmlns:minidom='http://pyxml.sf.net/minidom'>
+        <minidom:myelem/>
+        </foo>"""
+        dom = parseString(d)
+        elems = dom.getElementsByTagNameNS("http://pyxml.sf.net/minidom",
+                                           "myelem")
+        self.assertEqual(len(elems), 1)
+        self.assertEqual(elems[0].namespaceURI, "http://pyxml.sf.net/minidom")
+        self.assertEqual(elems[0].localName, "myelem")
+        self.assertEqual(elems[0].prefix, "minidom")
+        self.assertEqual(elems[0].tagName, "minidom:myelem")
+        self.assertEqual(elems[0].nodeName, "minidom:myelem")
+        dom.unlink()
+
+    def get_empty_nodelist_from_elements_by_tagName_ns_helper(self, doc, nsuri,
+                                                              lname):
+        nodelist = doc.getElementsByTagNameNS(nsuri, lname)
+        self.assertEqual(len(nodelist), 0)
+
+    def testGetEmptyNodeListFromElementsByTagNameNS(self):
+        doc = parseString('<doc/>')
+        self.get_empty_nodelist_from_elements_by_tagName_ns_helper(
+            doc, 'http://xml.python.org/namespaces/a', 'localname')
+        self.get_empty_nodelist_from_elements_by_tagName_ns_helper(
+            doc, '*', 'splat')
+        self.get_empty_nodelist_from_elements_by_tagName_ns_helper(
+            doc, 'http://xml.python.org/namespaces/a', '*')
+
+        doc = parseString('<doc xmlns="http://xml.python.org/splat"><e/></doc>')
+        self.get_empty_nodelist_from_elements_by_tagName_ns_helper(
+            doc, "http://xml.python.org/splat", "not-there")
+        self.get_empty_nodelist_from_elements_by_tagName_ns_helper(
+            doc, "*", "not-there")
+        self.get_empty_nodelist_from_elements_by_tagName_ns_helper(
+            doc, "http://somewhere.else.net/not-there", "e")
+
+    def testElementReprAndStr(self):
+        dom = Document()
+        el = dom.appendChild(dom.createElement("abc"))
+        string1 = repr(el)
+        string2 = str(el)
+        self.assertEqual(string1, string2)
+        dom.unlink()
+
+    def testElementReprAndStrUnicode(self):
+        dom = Document()
+        el = dom.appendChild(dom.createElement("abc"))
+        string1 = repr(el)
+        string2 = str(el)
+        self.assertEqual(string1, string2)
+        dom.unlink()
+
+    def testElementReprAndStrUnicodeNS(self):
+        dom = Document()
+        el = dom.appendChild(
+            dom.createElementNS("http://www.slashdot.org", "slash:abc"))
+        string1 = repr(el)
+        string2 = str(el)
+        self.assertEqual(string1, string2)
+        self.assertIn("slash:abc", string1)
+        dom.unlink()
+
+    def testAttributeRepr(self):
+        dom = Document()
+        el = dom.appendChild(dom.createElement("abc"))
+        node = el.setAttribute("abc", "def")
+        self.assertEqual(str(node), repr(node))
+        dom.unlink()
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    def testWriteXML(self):
+        str = '<?xml version="1.0" ?><a b="c"/>'
+        dom = parseString(str)
+        domstr = dom.toxml()
+        dom.unlink()
+        self.assertEqual(str, domstr)
+
+    def test_toxml_quote_text(self):
+        dom = Document()
+        elem = dom.appendChild(dom.createElement('elem'))
+        elem.appendChild(dom.createTextNode('&<>"'))
+        cr = elem.appendChild(dom.createElement('cr'))
+        cr.appendChild(dom.createTextNode('\r'))
+        crlf = elem.appendChild(dom.createElement('crlf'))
+        crlf.appendChild(dom.createTextNode('\r\n'))
+        lflf = elem.appendChild(dom.createElement('lflf'))
+        lflf.appendChild(dom.createTextNode('\n\n'))
+        ws = elem.appendChild(dom.createElement('ws'))
+        ws.appendChild(dom.createTextNode('\t\n\r '))
+        domstr = dom.toxml()
+        dom.unlink()
+        self.assertEqual(domstr, '<?xml version="1.0" ?>'
+                '<elem>&amp;&lt;&gt;"'
+                '<cr>\r</cr>'
+                '<crlf>\r\n</crlf>'
+                '<lflf>\n\n</lflf>'
+                '<ws>\t\n\r </ws></elem>')
+
+    def test_toxml_quote_attrib(self):
+        dom = Document()
+        elem = dom.appendChild(dom.createElement('elem'))
+        elem.setAttribute("a", '&<>"')
+        elem.setAttribute("cr", "\r")
+        elem.setAttribute("lf", "\n")
+        elem.setAttribute("crlf", "\r\n")
+        elem.setAttribute("lflf", "\n\n")
+        elem.setAttribute("ws", "\t\n\r ")
+        domstr = dom.toxml()
+        dom.unlink()
+        self.assertEqual(domstr, '<?xml version="1.0" ?>'
+                '<elem a="&amp;&lt;&gt;&quot;" '
+                'cr="&#13;" '
+                'lf="&#10;" '
+                'crlf="&#13;&#10;" '
+                'lflf="&#10;&#10;" '
+                'ws="&#9;&#10;&#13; "/>')
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    def testAltNewline(self):
+        str = '<?xml version="1.0" ?>\n<a b="c"/>\n'
+        dom = parseString(str)
+        domstr = dom.toprettyxml(newl="\r\n")
+        dom.unlink()
+        self.assertEqual(domstr, str.replace("\n", "\r\n"))
+
+    def test_toprettyxml_with_text_nodes(self):
+        # see issue #4147, text nodes are not indented
+        decl = '<?xml version="1.0" ?>\n'
+        self.assertEqual(parseString('<B>A</B>').toprettyxml(),
+                         decl + '<B>A</B>\n')
+        self.assertEqual(parseString('<C>A<B>A</B></C>').toprettyxml(),
+                         decl + '<C>\n\tA\n\t<B>A</B>\n</C>\n')
+        self.assertEqual(parseString('<C><B>A</B>A</C>').toprettyxml(),
+                         decl + '<C>\n\t<B>A</B>\n\tA\n</C>\n')
+        self.assertEqual(parseString('<C><B>A</B><B>A</B></C>').toprettyxml(),
+                         decl + '<C>\n\t<B>A</B>\n\t<B>A</B>\n</C>\n')
+        self.assertEqual(parseString('<C><B>A</B>A<B>A</B></C>').toprettyxml(),
+                         decl + '<C>\n\t<B>A</B>\n\tA\n\t<B>A</B>\n</C>\n')
+
+    def test_toprettyxml_with_adjacent_text_nodes(self):
+        # see issue #4147, adjacent text nodes are indented normally
+        dom = Document()
+        elem = dom.createElement('elem')
+        elem.appendChild(dom.createTextNode('TEXT'))
+        elem.appendChild(dom.createTextNode('TEXT'))
+        dom.appendChild(elem)
+        decl = '<?xml version="1.0" ?>\n'
+        self.assertEqual(dom.toprettyxml(),
+                         decl + '<elem>\n\tTEXT\n\tTEXT\n</elem>\n')
+
+    def test_toprettyxml_preserves_content_of_text_node(self):
+        # see issue #4147
+        for str in ('<B>A</B>', '<A><B>C</B></A>'):
+            dom = parseString(str)
+            dom2 = parseString(dom.toprettyxml())
+            self.assertEqual(
+                dom.getElementsByTagName('B')[0].childNodes[0].toxml(),
+                dom2.getElementsByTagName('B')[0].childNodes[0].toxml())
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    def testProcessingInstruction(self):
+        dom = parseString('<e><?mypi \t\n data \t\n ?></e>')
+        pi = dom.documentElement.firstChild
+        self.assertEqual(pi.target, "mypi")
+        self.assertEqual(pi.data, "data \t\n ")
+        self.assertEqual(pi.nodeName, "mypi")
+        self.assertEqual(pi.nodeType, Node.PROCESSING_INSTRUCTION_NODE)
+        self.assertIsNone(pi.attributes)
+        self.assertFalse(pi.hasChildNodes())
+        self.assertEqual(len(pi.childNodes), 0)
+        self.assertIsNone(pi.firstChild)
+        self.assertIsNone(pi.lastChild)
+        self.assertIsNone(pi.localName)
+        self.assertEqual(pi.namespaceURI, xml.dom.EMPTY_NAMESPACE)
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    def testProcessingInstructionRepr(self):
+        dom = parseString('<e><?mypi \t\n data \t\n ?></e>')
+        pi = dom.documentElement.firstChild
+        self.assertEqual(str(pi.nodeType), repr(pi.nodeType))
+
+    def testTextRepr(self):
+        dom = Document()
+        self.addCleanup(dom.unlink)
+        elem = dom.createElement("elem")
+        elem.appendChild(dom.createTextNode("foo"))
+        el = elem.firstChild
+        self.assertEqual(str(el), repr(el))
+        self.assertEqual('<DOM Text node "\'foo\'">', str(el))
+
+    def testWriteText(self): pass
+
+    def testDocumentElement(self): pass
+
+    def testTooManyDocumentElements(self):
+        doc = parseString("<doc/>")
+        elem = doc.createElement("extra")
+        # Should raise an exception when adding an extra document element.
+        self.assertRaises(xml.dom.HierarchyRequestErr, doc.appendChild, elem)
+        elem.unlink()
+        doc.unlink()
+
+    def testCreateElementNS(self): pass
+
+    def testCreateAttributeNS(self): pass
+
+    def testParse(self): pass
+
+    def testParseString(self): pass
+
+    def testComment(self): pass
+
+    def testAttrListItem(self): pass
+
+    def testAttrListItems(self): pass
+
+    def testAttrListItemNS(self): pass
+
+    def testAttrListKeys(self): pass
+
+    def testAttrListKeysNS(self): pass
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    def testRemoveNamedItem(self):
+        doc = parseString("<doc a=''/>")
+        e = doc.documentElement
+        attrs = e.attributes
+        a1 = e.getAttributeNode("a")
+        a2 = attrs.removeNamedItem("a")
+        self.assertTrue(a1.isSameNode(a2))
+        self.assertRaises(xml.dom.NotFoundErr, attrs.removeNamedItem, "a")
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    def testRemoveNamedItemNS(self):
+        doc = parseString("<doc xmlns:a='http://xml.python.org/' a:b=''/>")
+        e = doc.documentElement
+        attrs = e.attributes
+        a1 = e.getAttributeNodeNS("http://xml.python.org/", "b")
+        a2 = attrs.removeNamedItemNS("http://xml.python.org/", "b")
+        self.assertTrue(a1.isSameNode(a2))
+        self.assertRaises(xml.dom.NotFoundErr, attrs.removeNamedItemNS,
+                          "http://xml.python.org/", "b")
+
+    def testAttrListValues(self): pass
+
+    def testAttrListLength(self): pass
+
+    def testAttrList__getitem__(self): pass
+
+    def testAttrList__setitem__(self): pass
+
+    def testSetAttrValueandNodeValue(self): pass
+
+    def testParseElement(self): pass
+
+    def testParseAttributes(self): pass
+
+    def testParseElementNamespaces(self): pass
+
+    def testParseAttributeNamespaces(self): pass
+
+    def testParseProcessingInstructions(self): pass
+
+    def testChildNodes(self): pass
+
+    def testFirstChild(self): pass
+
+    def testHasChildNodes(self):
+        dom = parseString("<doc><foo/></doc>")
+        doc = dom.documentElement
+        self.assertTrue(doc.hasChildNodes())
+        dom2 = parseString("<doc/>")
+        doc2 = dom2.documentElement
+        self.assertFalse(doc2.hasChildNodes())
+
+    def _testCloneElementCopiesAttributes(self, e1, e2, test):
+        attrs1 = e1.attributes
+        attrs2 = e2.attributes
+        keys1 = list(attrs1.keys())
+        keys2 = list(attrs2.keys())
+        keys1.sort()
+        keys2.sort()
+        self.assertEqual(keys1, keys2)
+        for i in range(len(keys1)):
+            a1 = attrs1.item(i)
+            a2 = attrs2.item(i)
+            self.assertIsNot(a1, a2)
+            self.assertEqual(a1.value, a2.value)
+            self.assertEqual(a1.nodeValue, a2.nodeValue)
+            self.assertEqual(a1.namespaceURI,a2.namespaceURI)
+            self.assertEqual(a1.localName, a2.localName)
+            self.assertIs(a2.ownerElement, e2)
+
+    def _setupCloneElement(self, deep):
+        dom = parseString("<doc attr='value'><foo/></doc>")
+        root = dom.documentElement
+        clone = root.cloneNode(deep)
+        self._testCloneElementCopiesAttributes(
+            root, clone, "testCloneElement" + (deep and "Deep" or "Shallow"))
+        # mutilate the original so shared data is detected
+        root.tagName = root.nodeName = "MODIFIED"
+        root.setAttribute("attr", "NEW VALUE")
+        root.setAttribute("added", "VALUE")
+        return dom, clone
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    def testCloneElementShallow(self):
+        dom, clone = self._setupCloneElement(0)
+        self.assertEqual(len(clone.childNodes), 0)
+        self.assertEqual(clone.childNodes.length, 0)
+        self.assertIsNone(clone.parentNode)
+        self.assertEqual(clone.toxml(), '<doc attr="value"/>')
+
+        dom.unlink()
+
+    def testCloneElementDeep(self):
+        dom, clone = self._setupCloneElement(1)
+        self.assertEqual(len(clone.childNodes), 1)
+        self.assertEqual(clone.childNodes.length, 1)
+        self.assertIsNone(clone.parentNode)
+        self.assertTrue(clone.toxml(), '<doc attr="value"><foo/></doc>')
+        dom.unlink()
+
+    def testCloneDocumentShallow(self):
+        doc = parseString("<?xml version='1.0'?>\n"
+                    "<!-- comment -->"
+                    "<!DOCTYPE doc [\n"
+                    "<!NOTATION notation SYSTEM 'http://xml.python.org/'>\n"
+                    "]>\n"
+                    "<doc attr='value'/>")
+        doc2 = doc.cloneNode(0)
+        self.assertIsNone(doc2,
+                "testCloneDocumentShallow:"
+                " shallow cloning of documents makes no sense!")
+
+    def testCloneDocumentDeep(self):
+        doc = parseString("<?xml version='1.0'?>\n"
+                    "<!-- comment -->"
+                    "<!DOCTYPE doc [\n"
+                    "<!NOTATION notation SYSTEM 'http://xml.python.org/'>\n"
+                    "]>\n"
+                    "<doc attr='value'/>")
+        doc2 = doc.cloneNode(1)
+        self.assertFalse((doc.isSameNode(doc2) or doc2.isSameNode(doc)),
+                "testCloneDocumentDeep: document objects not distinct")
+        self.assertEqual(len(doc.childNodes), len(doc2.childNodes),
+                "testCloneDocumentDeep: wrong number of Document children")
+        self.assertEqual(doc2.documentElement.nodeType, Node.ELEMENT_NODE,
+                "testCloneDocumentDeep: documentElement not an ELEMENT_NODE")
+        self.assertTrue(doc2.documentElement.ownerDocument.isSameNode(doc2),
+            "testCloneDocumentDeep: documentElement owner is not new document")
+        self.assertFalse(doc.documentElement.isSameNode(doc2.documentElement),
+                "testCloneDocumentDeep: documentElement should not be shared")
+        if doc.doctype is not None:
+            # check the doctype iff the original DOM maintained it
+            self.assertEqual(doc2.doctype.nodeType, Node.DOCUMENT_TYPE_NODE,
+                    "testCloneDocumentDeep: doctype not a DOCUMENT_TYPE_NODE")
+            self.assertTrue(doc2.doctype.ownerDocument.isSameNode(doc2))
+            self.assertFalse(doc.doctype.isSameNode(doc2.doctype))
+
+    def testCloneDocumentTypeDeepOk(self):
+        doctype = create_nonempty_doctype()
+        clone = doctype.cloneNode(1)
+        self.confirm(clone is not None
+                and clone.nodeName == doctype.nodeName
+                and clone.name == doctype.name
+                and clone.publicId == doctype.publicId
+                and clone.systemId == doctype.systemId
+                and len(clone.entities) == len(doctype.entities)
+                and clone.entities.item(len(clone.entities)) is None
+                and len(clone.notations) == len(doctype.notations)
+                and clone.notations.item(len(clone.notations)) is None
+                and len(clone.childNodes) == 0)
+        for i in range(len(doctype.entities)):
+            se = doctype.entities.item(i)
+            ce = clone.entities.item(i)
+            self.confirm((not se.isSameNode(ce))
+                    and (not ce.isSameNode(se))
+                    and ce.nodeName == se.nodeName
+                    and ce.notationName == se.notationName
+                    and ce.publicId == se.publicId
+                    and ce.systemId == se.systemId
+                    and ce.encoding == se.encoding
+                    and ce.actualEncoding == se.actualEncoding
+                    and ce.version == se.version)
+        for i in range(len(doctype.notations)):
+            sn = doctype.notations.item(i)
+            cn = clone.notations.item(i)
+            self.confirm((not sn.isSameNode(cn))
+                    and (not cn.isSameNode(sn))
+                    and cn.nodeName == sn.nodeName
+                    and cn.publicId == sn.publicId
+                    and cn.systemId == sn.systemId)
+
+    def testCloneDocumentTypeDeepNotOk(self):
+        doc = create_doc_with_doctype()
+        clone = doc.doctype.cloneNode(1)
+        self.assertIsNone(clone)
+
+    def testCloneDocumentTypeShallowOk(self):
+        doctype = create_nonempty_doctype()
+        clone = doctype.cloneNode(0)
+        self.confirm(clone is not None
+                and clone.nodeName == doctype.nodeName
+                and clone.name == doctype.name
+                and clone.publicId == doctype.publicId
+                and clone.systemId == doctype.systemId
+                and len(clone.entities) == 0
+                and clone.entities.item(0) is None
+                and len(clone.notations) == 0
+                and clone.notations.item(0) is None
+                and len(clone.childNodes) == 0)
+
+    def testCloneDocumentTypeShallowNotOk(self):
+        doc = create_doc_with_doctype()
+        clone = doc.doctype.cloneNode(0)
+        self.assertIsNone(clone)
+
+    def check_import_document(self, deep, testName):
+        doc1 = parseString("<doc/>")
+        doc2 = parseString("<doc/>")
+        self.assertRaises(xml.dom.NotSupportedErr, doc1.importNode, doc2, deep)
+
+    def testImportDocumentShallow(self):
+        self.check_import_document(0, "testImportDocumentShallow")
+
+    def testImportDocumentDeep(self):
+        self.check_import_document(1, "testImportDocumentDeep")
+
+    def testImportDocumentTypeShallow(self):
+        src = create_doc_with_doctype()
+        target = create_doc_without_doctype()
+        self.assertRaises(xml.dom.NotSupportedErr, target.importNode,
+                          src.doctype, 0)
+
+    def testImportDocumentTypeDeep(self):
+        src = create_doc_with_doctype()
+        target = create_doc_without_doctype()
+        self.assertRaises(xml.dom.NotSupportedErr, target.importNode,
+                          src.doctype, 1)
+
+    # Testing attribute clones uses a helper, and should always be deep,
+    # even if the argument to cloneNode is false.
+    def check_clone_attribute(self, deep, testName):
+        doc = parseString("<doc attr='value'/>")
+        attr = doc.documentElement.getAttributeNode("attr")
+        self.assertIsNotNone(attr)
+        clone = attr.cloneNode(deep)
+        self.assertFalse(clone.isSameNode(attr))
+        self.assertFalse(attr.isSameNode(clone))
+        self.assertIsNone(clone.ownerElement,
+                testName + ": ownerElement should be None")
+        self.confirm(clone.ownerDocument.isSameNode(attr.ownerDocument),
+                testName + ": ownerDocument does not match")
+        self.confirm(clone.specified,
+                testName + ": cloned attribute must have specified == True")
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    def testCloneAttributeShallow(self):
+        self.check_clone_attribute(0, "testCloneAttributeShallow")
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    def testCloneAttributeDeep(self):
+        self.check_clone_attribute(1, "testCloneAttributeDeep")
+
+    def check_clone_pi(self, deep, testName):
+        doc = parseString("<?target data?><doc/>")
+        pi = doc.firstChild
+        self.assertEqual(pi.nodeType, Node.PROCESSING_INSTRUCTION_NODE)
+        clone = pi.cloneNode(deep)
+        self.confirm(clone.target == pi.target
+                and clone.data == pi.data)
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    def testClonePIShallow(self):
+        self.check_clone_pi(0, "testClonePIShallow")
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    def testClonePIDeep(self):
+        self.check_clone_pi(1, "testClonePIDeep")
+
+    def check_clone_node_entity(self, clone_document):
+        # bpo-35052: Test user data handler in cloneNode() on a document with
+        # an entity
+        document = xml.dom.minidom.parseString("""
+            <?xml version="1.0" ?>
+            <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN"
+                "http://www.w3.org/TR/html4/strict.dtd"
+                [ <!ENTITY smile "☺"> ]
+            >
+            <doc>Don't let entities make you frown &smile;</doc>
+        """.strip())
+
+        class Handler:
+            def handle(self, operation, key, data, src, dst):
+                self.operation = operation
+                self.key = key
+                self.data = data
+                self.src = src
+                self.dst = dst
+
+        handler = Handler()
+        doctype = document.doctype
+        entity = doctype.entities['smile']
+        entity.setUserData("key", "data", handler)
+
+        if clone_document:
+            # clone Document
+            clone = document.cloneNode(deep=True)
+
+            self.assertEqual(clone.documentElement.firstChild.wholeText,
+                             "Don't let entities make you frown ☺")
+            operation = xml.dom.UserDataHandler.NODE_IMPORTED
+            dst = clone.doctype.entities['smile']
+        else:
+            # clone DocumentType
+            with support.swap_attr(doctype, 'ownerDocument', None):
+                clone = doctype.cloneNode(deep=True)
+
+            operation = xml.dom.UserDataHandler.NODE_CLONED
+            dst = clone.entities['smile']
+
+        self.assertEqual(handler.operation, operation)
+        self.assertEqual(handler.key, "key")
+        self.assertEqual(handler.data, "data")
+        self.assertIs(handler.src, entity)
+        self.assertIs(handler.dst, dst)
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    def testCloneNodeEntity(self):
+        self.check_clone_node_entity(False)
+        self.check_clone_node_entity(True)
+
+    def testNormalize(self):
+        doc = parseString("<doc/>")
+        root = doc.documentElement
+        root.appendChild(doc.createTextNode("first"))
+        root.appendChild(doc.createTextNode("second"))
+        self.confirm(len(root.childNodes) == 2
+                and root.childNodes.length == 2,
+                "testNormalize -- preparation")
+        doc.normalize()
+        self.confirm(len(root.childNodes) == 1
+                and root.childNodes.length == 1
+                and root.firstChild is root.lastChild
+                and root.firstChild.data == "firstsecond"
+                , "testNormalize -- result")
+        doc.unlink()
+
+        doc = parseString("<doc/>")
+        root = doc.documentElement
+        root.appendChild(doc.createTextNode(""))
+        doc.normalize()
+        self.confirm(len(root.childNodes) == 0
+                and root.childNodes.length == 0,
+                "testNormalize -- single empty node removed")
+        doc.unlink()
+
+    def testNormalizeCombineAndNextSibling(self):
+        doc = parseString("<doc/>")
+        root = doc.documentElement
+        root.appendChild(doc.createTextNode("first"))
+        root.appendChild(doc.createTextNode("second"))
+        root.appendChild(doc.createElement("i"))
+        self.confirm(len(root.childNodes) == 3
+                and root.childNodes.length == 3,
+                "testNormalizeCombineAndNextSibling -- preparation")
+        doc.normalize()
+        self.confirm(len(root.childNodes) == 2
+                and root.childNodes.length == 2
+                and root.firstChild.data == "firstsecond"
+                and root.firstChild is not root.lastChild
+                and root.firstChild.nextSibling is root.lastChild
+                and root.firstChild.previousSibling is None
+                and root.lastChild.previousSibling is root.firstChild
+                and root.lastChild.nextSibling is None
+                , "testNormalizeCombinedAndNextSibling -- result")
+        doc.unlink()
+
+    def testNormalizeDeleteWithPrevSibling(self):
+        doc = parseString("<doc/>")
+        root = doc.documentElement
+        root.appendChild(doc.createTextNode("first"))
+        root.appendChild(doc.createTextNode(""))
+        self.confirm(len(root.childNodes) == 2
+                and root.childNodes.length == 2,
+                "testNormalizeDeleteWithPrevSibling -- preparation")
+        doc.normalize()
+        self.confirm(len(root.childNodes) == 1
+                and root.childNodes.length == 1
+                and root.firstChild.data == "first"
+                and root.firstChild is root.lastChild
+                and root.firstChild.nextSibling is None
+                and root.firstChild.previousSibling is None
+                , "testNormalizeDeleteWithPrevSibling -- result")
+        doc.unlink()
+
+    def testNormalizeDeleteWithNextSibling(self):
+        doc = parseString("<doc/>")
+        root = doc.documentElement
+        root.appendChild(doc.createTextNode(""))
+        root.appendChild(doc.createTextNode("second"))
+        self.confirm(len(root.childNodes) == 2
+                and root.childNodes.length == 2,
+                "testNormalizeDeleteWithNextSibling -- preparation")
+        doc.normalize()
+        self.confirm(len(root.childNodes) == 1
+                and root.childNodes.length == 1
+                and root.firstChild.data == "second"
+                and root.firstChild is root.lastChild
+                and root.firstChild.nextSibling is None
+                and root.firstChild.previousSibling is None
+                , "testNormalizeDeleteWithNextSibling -- result")
+        doc.unlink()
+
+    def testNormalizeDeleteWithTwoNonTextSiblings(self):
+        doc = parseString("<doc/>")
+        root = doc.documentElement
+        root.appendChild(doc.createElement("i"))
+        root.appendChild(doc.createTextNode(""))
+        root.appendChild(doc.createElement("i"))
+        self.confirm(len(root.childNodes) == 3
+                and root.childNodes.length == 3,
+                "testNormalizeDeleteWithTwoSiblings -- preparation")
+        doc.normalize()
+        self.confirm(len(root.childNodes) == 2
+                and root.childNodes.length == 2
+                and root.firstChild is not root.lastChild
+                and root.firstChild.nextSibling is root.lastChild
+                and root.firstChild.previousSibling is None
+                and root.lastChild.previousSibling is root.firstChild
+                and root.lastChild.nextSibling is None
+                , "testNormalizeDeleteWithTwoSiblings -- result")
+        doc.unlink()
+
+    def testNormalizeDeleteAndCombine(self):
+        doc = parseString("<doc/>")
+        root = doc.documentElement
+        root.appendChild(doc.createTextNode(""))
+        root.appendChild(doc.createTextNode("second"))
+        root.appendChild(doc.createTextNode(""))
+        root.appendChild(doc.createTextNode("fourth"))
+        root.appendChild(doc.createTextNode(""))
+        self.confirm(len(root.childNodes) == 5
+                and root.childNodes.length == 5,
+                "testNormalizeDeleteAndCombine -- preparation")
+        doc.normalize()
+        self.confirm(len(root.childNodes) == 1
+                and root.childNodes.length == 1
+                and root.firstChild is root.lastChild
+                and root.firstChild.data == "secondfourth"
+                and root.firstChild.previousSibling is None
+                and root.firstChild.nextSibling is None
+                , "testNormalizeDeleteAndCombine -- result")
+        doc.unlink()
+
+    def testNormalizeRecursion(self):
+        doc = parseString("<doc>"
+                            "<o>"
+                              "<i/>"
+                              "t"
+                              #
+                              #x
+                            "</o>"
+                            "<o>"
+                              "<o>"
+                                "t2"
+                                #x2
+                              "</o>"
+                              "t3"
+                              #x3
+                            "</o>"
+                            #
+                          "</doc>")
+        root = doc.documentElement
+        root.childNodes[0].appendChild(doc.createTextNode(""))
+        root.childNodes[0].appendChild(doc.createTextNode("x"))
+        root.childNodes[1].childNodes[0].appendChild(doc.createTextNode("x2"))
+        root.childNodes[1].appendChild(doc.createTextNode("x3"))
+        root.appendChild(doc.createTextNode(""))
+        self.confirm(len(root.childNodes) == 3
+                and root.childNodes.length == 3
+                and len(root.childNodes[0].childNodes) == 4
+                and root.childNodes[0].childNodes.length == 4
+                and len(root.childNodes[1].childNodes) == 3
+                and root.childNodes[1].childNodes.length == 3
+                and len(root.childNodes[1].childNodes[0].childNodes) == 2
+                and root.childNodes[1].childNodes[0].childNodes.length == 2
+                , "testNormalize2 -- preparation")
+        doc.normalize()
+        self.confirm(len(root.childNodes) == 2
+                and root.childNodes.length == 2
+                and len(root.childNodes[0].childNodes) == 2
+                and root.childNodes[0].childNodes.length == 2
+                and len(root.childNodes[1].childNodes) == 2
+                and root.childNodes[1].childNodes.length == 2
+                and len(root.childNodes[1].childNodes[0].childNodes) == 1
+                and root.childNodes[1].childNodes[0].childNodes.length == 1
+                , "testNormalize2 -- childNodes lengths")
+        self.confirm(root.childNodes[0].childNodes[1].data == "tx"
+                and root.childNodes[1].childNodes[0].childNodes[0].data == "t2x2"
+                and root.childNodes[1].childNodes[1].data == "t3x3"
+                , "testNormalize2 -- joined text fields")
+        self.confirm(root.childNodes[0].childNodes[1].nextSibling is None
+                and root.childNodes[0].childNodes[1].previousSibling
+                        is root.childNodes[0].childNodes[0]
+                and root.childNodes[0].childNodes[0].previousSibling is None
+                and root.childNodes[0].childNodes[0].nextSibling
+                        is root.childNodes[0].childNodes[1]
+                and root.childNodes[1].childNodes[1].nextSibling is None
+                and root.childNodes[1].childNodes[1].previousSibling
+                        is root.childNodes[1].childNodes[0]
+                and root.childNodes[1].childNodes[0].previousSibling is None
+                and root.childNodes[1].childNodes[0].nextSibling
+                        is root.childNodes[1].childNodes[1]
+                , "testNormalize2 -- sibling pointers")
+        doc.unlink()
+
+
+    def testBug0777884(self):
+        doc = parseString("<o>text</o>")
+        text = doc.documentElement.childNodes[0]
+        self.assertEqual(text.nodeType, Node.TEXT_NODE)
+        # Should run quietly, doing nothing.
+        text.normalize()
+        doc.unlink()
+
+    def testBug1433694(self):
+        doc = parseString("<o><i/>t</o>")
+        node = doc.documentElement
+        node.childNodes[1].nodeValue = ""
+        node.normalize()
+        self.assertIsNone(node.childNodes[-1].nextSibling,
+                     "Final child's .nextSibling should be None")
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    def testSiblings(self):
+        doc = parseString("<doc><?pi?>text?<elm/></doc>")
+        root = doc.documentElement
+        (pi, text, elm) = root.childNodes
+
+        self.confirm(pi.nextSibling is text and
+                pi.previousSibling is None and
+                text.nextSibling is elm and
+                text.previousSibling is pi and
+                elm.nextSibling is None and
+                elm.previousSibling is text, "testSiblings")
+
+        doc.unlink()
+
+    def testParents(self):
+        doc = parseString(
+            "<doc><elm1><elm2/><elm2><elm3/></elm2></elm1></doc>")
+        root = doc.documentElement
+        elm1 = root.childNodes[0]
+        (elm2a, elm2b) = elm1.childNodes
+        elm3 = elm2b.childNodes[0]
+
+        self.confirm(root.parentNode is doc and
+                elm1.parentNode is root and
+                elm2a.parentNode is elm1 and
+                elm2b.parentNode is elm1 and
+                elm3.parentNode is elm2b, "testParents")
+        doc.unlink()
+
+    def testNodeListItem(self):
+        doc = parseString("<doc><e/><e/></doc>")
+        children = doc.childNodes
+        docelem = children[0]
+        self.confirm(children[0] is children.item(0)
+                and children.item(1) is None
+                and docelem.childNodes.item(0) is docelem.childNodes[0]
+                and docelem.childNodes.item(1) is docelem.childNodes[1]
+                and docelem.childNodes.item(0).childNodes.item(0) is None,
+                "test NodeList.item()")
+        doc.unlink()
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    def testEncodings(self):
+        doc = parseString('<foo>&#x20ac;</foo>')
+        self.assertEqual(doc.toxml(),
+                         '<?xml version="1.0" ?><foo>\u20ac</foo>')
+        self.assertEqual(doc.toxml('utf-8'),
+            b'<?xml version="1.0" encoding="utf-8"?><foo>\xe2\x82\xac</foo>')
+        self.assertEqual(doc.toxml('iso-8859-15'),
+            b'<?xml version="1.0" encoding="iso-8859-15"?><foo>\xa4</foo>')
+        self.assertEqual(doc.toxml('us-ascii'),
+            b'<?xml version="1.0" encoding="us-ascii"?><foo>&#8364;</foo>')
+        self.assertEqual(doc.toxml('utf-16'),
+            '<?xml version="1.0" encoding="utf-16"?>'
+            '<foo>\u20ac</foo>'.encode('utf-16'))
+
+        # Verify that character decoding errors raise exceptions instead
+        # of crashing
+        with self.assertRaises((UnicodeDecodeError, ExpatError)):
+            parseString(
+                b'<fran\xe7ais>Comment \xe7a va ? Tr\xe8s bien ?</fran\xe7ais>'
+            )
+
+        doc.unlink()
+
+    def testStandalone(self):
+        doc = parseString('<foo>&#x20ac;</foo>')
+        self.assertEqual(doc.toxml(),
+                         '<?xml version="1.0" ?><foo>\u20ac</foo>')
+        self.assertEqual(doc.toxml(standalone=None),
+                         '<?xml version="1.0" ?><foo>\u20ac</foo>')
+        self.assertEqual(doc.toxml(standalone=True),
+            '<?xml version="1.0" standalone="yes"?><foo>\u20ac</foo>')
+        self.assertEqual(doc.toxml(standalone=False),
+            '<?xml version="1.0" standalone="no"?><foo>\u20ac</foo>')
+        self.assertEqual(doc.toxml('utf-8', True),
+            b'<?xml version="1.0" encoding="utf-8" standalone="yes"?>'
+            b'<foo>\xe2\x82\xac</foo>')
+
+        doc.unlink()
+
+    class UserDataHandler:
+        called = 0
+        def handle(self, operation, key, data, src, dst):
+            dst.setUserData(key, data + 1, self)
+            src.setUserData(key, None, None)
+            self.called = 1
+
+    def testUserData(self):
+        dom = Document()
+        n = dom.createElement('e')
+        self.assertIsNone(n.getUserData("foo"))
+        n.setUserData("foo", None, None)
+        self.assertIsNone(n.getUserData("foo"))
+        n.setUserData("foo", 12, 12)
+        n.setUserData("bar", 13, 13)
+        self.assertEqual(n.getUserData("foo"), 12)
+        self.assertEqual(n.getUserData("bar"), 13)
+        n.setUserData("foo", None, None)
+        self.assertIsNone(n.getUserData("foo"))
+        self.assertEqual(n.getUserData("bar"), 13)
+
+        handler = self.UserDataHandler()
+        n.setUserData("bar", 12, handler)
+        c = n.cloneNode(1)
+        self.confirm(handler.called
+                and n.getUserData("bar") is None
+                and c.getUserData("bar") == 13)
+        n.unlink()
+        c.unlink()
+        dom.unlink()
+
+    def checkRenameNodeSharedConstraints(self, doc, node):
+        # Make sure illegal NS usage is detected:
+        self.assertRaises(xml.dom.NamespaceErr, doc.renameNode, node,
+                          "http://xml.python.org/ns", "xmlns:foo")
+        doc2 = parseString("<doc/>")
+        self.assertRaises(xml.dom.WrongDocumentErr, doc2.renameNode, node,
+                          xml.dom.EMPTY_NAMESPACE, "foo")
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    def testRenameAttribute(self):
+        doc = parseString("<doc a='v'/>")
+        elem = doc.documentElement
+        attrmap = elem.attributes
+        attr = elem.attributes['a']
+
+        # Simple renaming
+        attr = doc.renameNode(attr, xml.dom.EMPTY_NAMESPACE, "b")
+        self.confirm(attr.name == "b"
+                and attr.nodeName == "b"
+                and attr.localName is None
+                and attr.namespaceURI == xml.dom.EMPTY_NAMESPACE
+                and attr.prefix is None
+                and attr.value == "v"
+                and elem.getAttributeNode("a") is None
+                and elem.getAttributeNode("b").isSameNode(attr)
+                and attrmap["b"].isSameNode(attr)
+                and attr.ownerDocument.isSameNode(doc)
+                and attr.ownerElement.isSameNode(elem))
+
+        # Rename to have a namespace, no prefix
+        attr = doc.renameNode(attr, "http://xml.python.org/ns", "c")
+        self.confirm(attr.name == "c"
+                and attr.nodeName == "c"
+                and attr.localName == "c"
+                and attr.namespaceURI == "http://xml.python.org/ns"
+                and attr.prefix is None
+                and attr.value == "v"
+                and elem.getAttributeNode("a") is None
+                and elem.getAttributeNode("b") is None
+                and elem.getAttributeNode("c").isSameNode(attr)
+                and elem.getAttributeNodeNS(
+                    "http://xml.python.org/ns", "c").isSameNode(attr)
+                and attrmap["c"].isSameNode(attr)
+                and attrmap[("http://xml.python.org/ns", "c")].isSameNode(attr))
+
+        # Rename to have a namespace, with prefix
+        attr = doc.renameNode(attr, "http://xml.python.org/ns2", "p:d")
+        self.confirm(attr.name == "p:d"
+                and attr.nodeName == "p:d"
+                and attr.localName == "d"
+                and attr.namespaceURI == "http://xml.python.org/ns2"
+                and attr.prefix == "p"
+                and attr.value == "v"
+                and elem.getAttributeNode("a") is None
+                and elem.getAttributeNode("b") is None
+                and elem.getAttributeNode("c") is None
+                and elem.getAttributeNodeNS(
+                    "http://xml.python.org/ns", "c") is None
+                and elem.getAttributeNode("p:d").isSameNode(attr)
+                and elem.getAttributeNodeNS(
+                    "http://xml.python.org/ns2", "d").isSameNode(attr)
+                and attrmap["p:d"].isSameNode(attr)
+                and attrmap[("http://xml.python.org/ns2", "d")].isSameNode(attr))
+
+        # Rename back to a simple non-NS node
+        attr = doc.renameNode(attr, xml.dom.EMPTY_NAMESPACE, "e")
+        self.confirm(attr.name == "e"
+                and attr.nodeName == "e"
+                and attr.localName is None
+                and attr.namespaceURI == xml.dom.EMPTY_NAMESPACE
+                and attr.prefix is None
+                and attr.value == "v"
+                and elem.getAttributeNode("a") is None
+                and elem.getAttributeNode("b") is None
+                and elem.getAttributeNode("c") is None
+                and elem.getAttributeNode("p:d") is None
+                and elem.getAttributeNodeNS(
+                    "http://xml.python.org/ns", "c") is None
+                and elem.getAttributeNode("e").isSameNode(attr)
+                and attrmap["e"].isSameNode(attr))
+
+        self.assertRaises(xml.dom.NamespaceErr, doc.renameNode, attr,
+                          "http://xml.python.org/ns", "xmlns")
+        self.checkRenameNodeSharedConstraints(doc, attr)
+        doc.unlink()
+
+    def testRenameElement(self):
+        doc = parseString("<doc/>")
+        elem = doc.documentElement
+
+        # Simple renaming
+        elem = doc.renameNode(elem, xml.dom.EMPTY_NAMESPACE, "a")
+        self.confirm(elem.tagName == "a"
+                and elem.nodeName == "a"
+                and elem.localName is None
+                and elem.namespaceURI == xml.dom.EMPTY_NAMESPACE
+                and elem.prefix is None
+                and elem.ownerDocument.isSameNode(doc))
+
+        # Rename to have a namespace, no prefix
+        elem = doc.renameNode(elem, "http://xml.python.org/ns", "b")
+        self.confirm(elem.tagName == "b"
+                and elem.nodeName == "b"
+                and elem.localName == "b"
+                and elem.namespaceURI == "http://xml.python.org/ns"
+                and elem.prefix is None
+                and elem.ownerDocument.isSameNode(doc))
+
+        # Rename to have a namespace, with prefix
+        elem = doc.renameNode(elem, "http://xml.python.org/ns2", "p:c")
+        self.confirm(elem.tagName == "p:c"
+                and elem.nodeName == "p:c"
+                and elem.localName == "c"
+                and elem.namespaceURI == "http://xml.python.org/ns2"
+                and elem.prefix == "p"
+                and elem.ownerDocument.isSameNode(doc))
+
+        # Rename back to a simple non-NS node
+        elem = doc.renameNode(elem, xml.dom.EMPTY_NAMESPACE, "d")
+        self.confirm(elem.tagName == "d"
+                and elem.nodeName == "d"
+                and elem.localName is None
+                and elem.namespaceURI == xml.dom.EMPTY_NAMESPACE
+                and elem.prefix is None
+                and elem.ownerDocument.isSameNode(doc))
+
+        self.checkRenameNodeSharedConstraints(doc, elem)
+        doc.unlink()
+
+    def testRenameOther(self):
+        # We have to create a comment node explicitly since not all DOM
+        # builders used with minidom add comments to the DOM.
+        doc = xml.dom.minidom.getDOMImplementation().createDocument(
+            xml.dom.EMPTY_NAMESPACE, "e", None)
+        node = doc.createComment("comment")
+        self.assertRaises(xml.dom.NotSupportedErr, doc.renameNode, node,
+                          xml.dom.EMPTY_NAMESPACE, "foo")
+        doc.unlink()
+
+    def testWholeText(self):
+        doc = parseString("<doc>a</doc>")
+        elem = doc.documentElement
+        text = elem.childNodes[0]
+        self.assertEqual(text.nodeType, Node.TEXT_NODE)
+
+        self.checkWholeText(text, "a")
+        elem.appendChild(doc.createTextNode("b"))
+        self.checkWholeText(text, "ab")
+        elem.insertBefore(doc.createCDATASection("c"), text)
+        self.checkWholeText(text, "cab")
+
+        # make sure we don't cross other nodes
+        splitter = doc.createComment("comment")
+        elem.appendChild(splitter)
+        text2 = doc.createTextNode("d")
+        elem.appendChild(text2)
+        self.checkWholeText(text, "cab")
+        self.checkWholeText(text2, "d")
+
+        x = doc.createElement("x")
+        elem.replaceChild(x, splitter)
+        splitter = x
+        self.checkWholeText(text, "cab")
+        self.checkWholeText(text2, "d")
+
+        x = doc.createProcessingInstruction("y", "z")
+        elem.replaceChild(x, splitter)
+        splitter = x
+        self.checkWholeText(text, "cab")
+        self.checkWholeText(text2, "d")
+
+        elem.removeChild(splitter)
+        self.checkWholeText(text, "cabd")
+        self.checkWholeText(text2, "cabd")
+
+    def testPatch1094164(self):
+        doc = parseString("<doc><e/></doc>")
+        elem = doc.documentElement
+        e = elem.firstChild
+        self.assertIs(e.parentNode, elem, "Before replaceChild()")
+        # Check that replacing a child with itself leaves the tree unchanged
+        elem.replaceChild(e, e)
+        self.assertIs(e.parentNode, elem, "After replaceChild()")
+
+    def testReplaceWholeText(self):
+        def setup():
+            doc = parseString("<doc>a<e/>d</doc>")
+            elem = doc.documentElement
+            text1 = elem.firstChild
+            text2 = elem.lastChild
+            splitter = text1.nextSibling
+            elem.insertBefore(doc.createTextNode("b"), splitter)
+            elem.insertBefore(doc.createCDATASection("c"), text1)
+            return doc, elem, text1, splitter, text2
+
+        doc, elem, text1, splitter, text2 = setup()
+        text = text1.replaceWholeText("new content")
+        self.checkWholeText(text, "new content")
+        self.checkWholeText(text2, "d")
+        self.assertEqual(len(elem.childNodes), 3)
+
+        doc, elem, text1, splitter, text2 = setup()
+        text = text2.replaceWholeText("new content")
+        self.checkWholeText(text, "new content")
+        self.checkWholeText(text1, "cab")
+        self.assertEqual(len(elem.childNodes), 5)
+
+        doc, elem, text1, splitter, text2 = setup()
+        text = text1.replaceWholeText("")
+        self.checkWholeText(text2, "d")
+        self.confirm(text is None
+                and len(elem.childNodes) == 2)
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    def testSchemaType(self):
+        doc = parseString(
+            "<!DOCTYPE doc [\n"
+            "  <!ENTITY e1 SYSTEM 'http://xml.python.org/e1'>\n"
+            "  <!ENTITY e2 SYSTEM 'http://xml.python.org/e2'>\n"
+            "  <!ATTLIST doc id   ID       #IMPLIED \n"
+            "                ref  IDREF    #IMPLIED \n"
+            "                refs IDREFS   #IMPLIED \n"
+            "                enum (a|b)    #IMPLIED \n"
+            "                ent  ENTITY   #IMPLIED \n"
+            "                ents ENTITIES #IMPLIED \n"
+            "                nm   NMTOKEN  #IMPLIED \n"
+            "                nms  NMTOKENS #IMPLIED \n"
+            "                text CDATA    #IMPLIED \n"
+            "    >\n"
+            "]><doc id='name' notid='name' text='splat!' enum='b'"
+            "       ref='name' refs='name name' ent='e1' ents='e1 e2'"
+            "       nm='123' nms='123 abc' />")
+        elem = doc.documentElement
+        # We don't want to rely on any specific loader at this point, so
+        # just make sure we can get to all the names, and that the
+        # DTD-based namespace is right.  The names can vary by loader
+        # since each supports a different level of DTD information.
+        t = elem.schemaType
+        self.confirm(t.name is None
+                and t.namespace == xml.dom.EMPTY_NAMESPACE)
+        names = "id notid text enum ref refs ent ents nm nms".split()
+        for name in names:
+            a = elem.getAttributeNode(name)
+            t = a.schemaType
+            self.confirm(hasattr(t, "name")
+                    and t.namespace == xml.dom.EMPTY_NAMESPACE)
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    def testSetIdAttribute(self):
+        doc = parseString("<doc a1='v' a2='w'/>")
+        e = doc.documentElement
+        a1 = e.getAttributeNode("a1")
+        a2 = e.getAttributeNode("a2")
+        self.confirm(doc.getElementById("v") is None
+                and not a1.isId
+                and not a2.isId)
+        e.setIdAttribute("a1")
+        self.confirm(e.isSameNode(doc.getElementById("v"))
+                and a1.isId
+                and not a2.isId)
+        e.setIdAttribute("a2")
+        self.confirm(e.isSameNode(doc.getElementById("v"))
+                and e.isSameNode(doc.getElementById("w"))
+                and a1.isId
+                and a2.isId)
+        # replace the a1 node; the new node should *not* be an ID
+        a3 = doc.createAttribute("a1")
+        a3.value = "v"
+        e.setAttributeNode(a3)
+        self.confirm(doc.getElementById("v") is None
+                and e.isSameNode(doc.getElementById("w"))
+                and not a1.isId
+                and a2.isId
+                and not a3.isId)
+        # renaming an attribute should not affect its ID-ness:
+        doc.renameNode(a2, xml.dom.EMPTY_NAMESPACE, "an")
+        self.confirm(e.isSameNode(doc.getElementById("w"))
+                and a2.isId)
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    def testSetIdAttributeNS(self):
+        NS1 = "http://xml.python.org/ns1"
+        NS2 = "http://xml.python.org/ns2"
+        doc = parseString("<doc"
+                          " xmlns:ns1='" + NS1 + "'"
+                          " xmlns:ns2='" + NS2 + "'"
+                          " ns1:a1='v' ns2:a2='w'/>")
+        e = doc.documentElement
+        a1 = e.getAttributeNodeNS(NS1, "a1")
+        a2 = e.getAttributeNodeNS(NS2, "a2")
+        self.confirm(doc.getElementById("v") is None
+                and not a1.isId
+                and not a2.isId)
+        e.setIdAttributeNS(NS1, "a1")
+        self.confirm(e.isSameNode(doc.getElementById("v"))
+                and a1.isId
+                and not a2.isId)
+        e.setIdAttributeNS(NS2, "a2")
+        self.confirm(e.isSameNode(doc.getElementById("v"))
+                and e.isSameNode(doc.getElementById("w"))
+                and a1.isId
+                and a2.isId)
+        # replace the a1 node; the new node should *not* be an ID
+        a3 = doc.createAttributeNS(NS1, "a1")
+        a3.value = "v"
+        e.setAttributeNode(a3)
+        self.assertTrue(e.isSameNode(doc.getElementById("w")))
+        self.assertFalse(a1.isId)
+        self.assertTrue(a2.isId)
+        self.assertFalse(a3.isId)
+        self.assertIsNone(doc.getElementById("v"))
+        # renaming an attribute should not affect its ID-ness:
+        doc.renameNode(a2, xml.dom.EMPTY_NAMESPACE, "an")
+        self.confirm(e.isSameNode(doc.getElementById("w"))
+                and a2.isId)
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    def testSetIdAttributeNode(self):
+        NS1 = "http://xml.python.org/ns1"
+        NS2 = "http://xml.python.org/ns2"
+        doc = parseString("<doc"
+                          " xmlns:ns1='" + NS1 + "'"
+                          " xmlns:ns2='" + NS2 + "'"
+                          " ns1:a1='v' ns2:a2='w'/>")
+        e = doc.documentElement
+        a1 = e.getAttributeNodeNS(NS1, "a1")
+        a2 = e.getAttributeNodeNS(NS2, "a2")
+        self.confirm(doc.getElementById("v") is None
+                and not a1.isId
+                and not a2.isId)
+        e.setIdAttributeNode(a1)
+        self.confirm(e.isSameNode(doc.getElementById("v"))
+                and a1.isId
+                and not a2.isId)
+        e.setIdAttributeNode(a2)
+        self.confirm(e.isSameNode(doc.getElementById("v"))
+                and e.isSameNode(doc.getElementById("w"))
+                and a1.isId
+                and a2.isId)
+        # replace the a1 node; the new node should *not* be an ID
+        a3 = doc.createAttributeNS(NS1, "a1")
+        a3.value = "v"
+        e.setAttributeNode(a3)
+        self.assertTrue(e.isSameNode(doc.getElementById("w")))
+        self.assertFalse(a1.isId)
+        self.assertTrue(a2.isId)
+        self.assertFalse(a3.isId)
+        self.assertIsNone(doc.getElementById("v"))
+        # renaming an attribute should not affect its ID-ness:
+        doc.renameNode(a2, xml.dom.EMPTY_NAMESPACE, "an")
+        self.confirm(e.isSameNode(doc.getElementById("w"))
+                and a2.isId)
+
+    def assert_recursive_equal(self, doc, doc2):
+        stack = [(doc, doc2)]
+        while stack:
+            n1, n2 = stack.pop()
+            self.assertEqual(n1.nodeType, n2.nodeType)
+            self.assertEqual(len(n1.childNodes), len(n2.childNodes))
+            self.assertEqual(n1.nodeName, n2.nodeName)
+            self.assertFalse(n1.isSameNode(n2))
+            self.assertFalse(n2.isSameNode(n1))
+            if n1.nodeType == Node.DOCUMENT_TYPE_NODE:
+                len(n1.entities)
+                len(n2.entities)
+                len(n1.notations)
+                len(n2.notations)
+                self.assertEqual(len(n1.entities), len(n2.entities))
+                self.assertEqual(len(n1.notations), len(n2.notations))
+                for i in range(len(n1.notations)):
+                    # XXX this loop body doesn't seem to be executed?
+                    no1 = n1.notations.item(i)
+                    no2 = n1.notations.item(i)
+                    self.assertEqual(no1.name, no2.name)
+                    self.assertEqual(no1.publicId, no2.publicId)
+                    self.assertEqual(no1.systemId, no2.systemId)
+                    stack.append((no1, no2))
+                for i in range(len(n1.entities)):
+                    e1 = n1.entities.item(i)
+                    e2 = n2.entities.item(i)
+                    self.assertEqual(e1.notationName, e2.notationName)
+                    self.assertEqual(e1.publicId, e2.publicId)
+                    self.assertEqual(e1.systemId, e2.systemId)
+                    stack.append((e1, e2))
+            if n1.nodeType != Node.DOCUMENT_NODE:
+                self.assertTrue(n1.ownerDocument.isSameNode(doc))
+                self.assertTrue(n2.ownerDocument.isSameNode(doc2))
+            for i in range(len(n1.childNodes)):
+                stack.append((n1.childNodes[i], n2.childNodes[i]))
+
+    def testPickledDocument(self):
+        doc = parseString(sample)
+        for proto in range(2, pickle.HIGHEST_PROTOCOL + 1):
+            s = pickle.dumps(doc, proto)
+            doc2 = pickle.loads(s)
+            self.assert_recursive_equal(doc, doc2)
+
+    def testDeepcopiedDocument(self):
+        doc = parseString(sample)
+        doc2 = copy.deepcopy(doc)
+        self.assert_recursive_equal(doc, doc2)
+
+    def testSerializeCommentNodeWithDoubleHyphen(self):
+        doc = create_doc_without_doctype()
+        doc.appendChild(doc.createComment("foo--bar"))
+        self.assertRaises(ValueError, doc.toxml)
+
+
+    def testEmptyXMLNSValue(self):
+        doc = parseString("<element xmlns=''>\n"
+                          "<foo/>\n</element>")
+        doc2 = parseString(doc.toxml())
+        self.assertEqual(doc2.namespaceURI, xml.dom.EMPTY_NAMESPACE)
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    def testExceptionOnSpacesInXMLNSValue(self):
+        with self.assertRaises((ValueError, ExpatError)):
+            parseString(
+                '<element xmlns:abc="http:abc.com/de f g/hi/j k">' +
+                '<abc:foo /></element>'
+            )
+
+    def testDocRemoveChild(self):
+        doc = parse(tstfile)
+        title_tag = doc.documentElement.getElementsByTagName("TITLE")[0]
+        self.assertRaises( xml.dom.NotFoundErr, doc.removeChild, title_tag)
+        num_children_before = len(doc.childNodes)
+        doc.removeChild(doc.childNodes[0])
+        num_children_after = len(doc.childNodes)
+        self.assertEqual(num_children_after, num_children_before - 1)
+
+    def testProcessingInstructionNameError(self):
+        # wrong variable in .nodeValue property will
+        # lead to "NameError: name 'data' is not defined"
+        doc = parse(tstfile)
+        pi = doc.createProcessingInstruction("y", "z")
+        pi.nodeValue = "crash"
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    def test_minidom_attribute_order(self):
+        xml_str = '<?xml version="1.0" ?><curriculum status="public" company="example"/>'
+        doc = parseString(xml_str)
+        output = io.StringIO()
+        doc.writexml(output)
+        self.assertEqual(output.getvalue(), xml_str)
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    def test_toxml_with_attributes_ordered(self):
+        xml_str = '<?xml version="1.0" ?><curriculum status="public" company="example"/>'
+        doc = parseString(xml_str)
+        self.assertEqual(doc.toxml(), xml_str)
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    def test_toprettyxml_with_attributes_ordered(self):
+        xml_str = '<?xml version="1.0" ?><curriculum status="public" company="example"/>'
+        doc = parseString(xml_str)
+        self.assertEqual(doc.toprettyxml(),
+                         '<?xml version="1.0" ?>\n'
+                         '<curriculum status="public" company="example"/>\n')
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    def test_toprettyxml_with_cdata(self):
+        xml_str = '<?xml version="1.0" ?><root><node><![CDATA[</data>]]></node></root>'
+        doc = parseString(xml_str)
+        self.assertEqual(doc.toprettyxml(),
+                         '<?xml version="1.0" ?>\n'
+                         '<root>\n'
+                         '\t<node><![CDATA[</data>]]></node>\n'
+                         '</root>\n')
+
+    def test_cdata_parsing(self):
+        xml_str = '<?xml version="1.0" ?><root><node><![CDATA[</data>]]></node></root>'
+        dom1 = parseString(xml_str)
+        self.checkWholeText(dom1.getElementsByTagName('node')[0].firstChild, '</data>')
+        dom2 = parseString(dom1.toprettyxml())
+        self.checkWholeText(dom2.getElementsByTagName('node')[0].firstChild, '</data>')
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/Lib/test/test_mmap.py b/Lib/test/test_mmap.py
index f80df63bb86..ed96be53cca 100644
--- a/Lib/test/test_mmap.py
+++ b/Lib/test/test_mmap.py
@@ -618,7 +618,6 @@ def test_non_ascii_byte(self):
             self.assertEqual(m.read_byte(), b)
             m.close()
 
-    @unittest.expectedFailure  # TODO: RUSTPYTHON
     @unittest.skipUnless(os.name == 'nt', 'requires Windows')
     def test_tagname(self):
         data1 = b"0123456789"
@@ -868,7 +867,6 @@ def test_resize_fails_if_mapping_held_elsewhere(self):
         finally:
             f.close()
 
-    @unittest.expectedFailure  # TODO: RUSTPYTHON
     @unittest.skipUnless(os.name == 'nt', 'requires Windows')
     def test_resize_succeeds_with_error_for_second_named_mapping(self):
         """If a more than one mapping exists of the same name, none of them can
diff --git a/Lib/test/test_module/__init__.py b/Lib/test/test_module/__init__.py
index 59c74fd0d41..4704ad29974 100644
--- a/Lib/test/test_module/__init__.py
+++ b/Lib/test/test_module/__init__.py
@@ -1,4 +1,5 @@
 # Test the module type
+import importlib.machinery
 import unittest
 import weakref
 from test.support import gc_collect
@@ -29,7 +30,7 @@ def test_uninitialized(self):
             self.fail("__name__ = %s" % repr(s))
         except AttributeError:
             pass
-        self.assertEqual(foo.__doc__, ModuleType.__doc__)
+        self.assertEqual(foo.__doc__, ModuleType.__doc__ or '')
 
     def test_uninitialized_missing_getattr(self):
         # Issue 8297
@@ -102,8 +103,7 @@ def f():
         gc_collect()
         self.assertEqual(f().__dict__["bar"], 4)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_clear_dict_in_ref_cycle(self):
         destroyed = []
         m = ModuleType("foo")
@@ -152,15 +152,13 @@ def test_module_getattr_errors(self):
         if 'test.test_module.bad_getattr2' in sys.modules:
             del sys.modules['test.test_module.bad_getattr2']
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_module_dir(self):
         import test.test_module.good_getattr as gga
         self.assertEqual(dir(gga), ['a', 'b', 'c'])
         del sys.modules['test.test_module.good_getattr']
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_module_dir_errors(self):
         import test.test_module.bad_getattr as bga
         from test.test_module import bad_getattr2
@@ -270,11 +268,38 @@ def test_module_repr_source(self):
         self.assertEqual(r[-len(ends_with):], ends_with,
                          '{!r} does not end with {!r}'.format(r, ends_with))
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    def test_module_repr_with_namespace_package(self):
+        m = ModuleType('foo')
+        loader = importlib.machinery.NamespaceLoader('foo', ['bar'], 'baz')
+        spec = importlib.machinery.ModuleSpec('foo', loader)
+        m.__loader__ = loader
+        m.__spec__ = spec
+        self.assertEqual(repr(m), "<module 'foo' (namespace) from ['bar']>")
+
+    def test_module_repr_with_namespace_package_and_custom_loader(self):
+        m = ModuleType('foo')
+        loader = BareLoader()
+        spec = importlib.machinery.ModuleSpec('foo', loader)
+        m.__loader__ = loader
+        m.__spec__ = spec
+        expected_repr_pattern = r"<module 'foo' \(<.*\.BareLoader object at .+>\)>"
+        self.assertRegex(repr(m), expected_repr_pattern)
+        self.assertNotIn('from', repr(m))
+
+    def test_module_repr_with_fake_namespace_package(self):
+        m = ModuleType('foo')
+        loader = BareLoader()
+        loader._path = ['spam']
+        spec = importlib.machinery.ModuleSpec('foo', loader)
+        m.__loader__ = loader
+        m.__spec__ = spec
+        expected_repr_pattern = r"<module 'foo' \(<.*\.BareLoader object at .+>\)>"
+        self.assertRegex(repr(m), expected_repr_pattern)
+        self.assertNotIn('from', repr(m))
+
     def test_module_finalization_at_shutdown(self):
         # Module globals and builtins should still be available during shutdown
-        rc, out, err = assert_python_ok("-c", "from test import final_a")
+        rc, out, err = assert_python_ok("-c", "from test.test_module import final_a")
         self.assertFalse(err)
         lines = out.splitlines()
         self.assertEqual(set(lines), {
diff --git a/Lib/test/test_module/final_a.py b/Lib/test/test_module/final_a.py
new file mode 100644
index 00000000000..a983f311124
--- /dev/null
+++ b/Lib/test/test_module/final_a.py
@@ -0,0 +1,19 @@
+"""
+Fodder for module finalization tests in test_module.
+"""
+
+import shutil
+import test.test_module.final_b
+
+x = 'a'
+
+class C:
+    def __del__(self):
+        # Inspect module globals and builtins
+        print("x =", x)
+        print("final_b.x =", test.test_module.final_b.x)
+        print("shutil.rmtree =", getattr(shutil.rmtree, '__name__', None))
+        print("len =", getattr(len, '__name__', None))
+
+c = C()
+_underscored = C()
diff --git a/Lib/test/test_module/final_b.py b/Lib/test/test_module/final_b.py
new file mode 100644
index 00000000000..f3e8d559490
--- /dev/null
+++ b/Lib/test/test_module/final_b.py
@@ -0,0 +1,19 @@
+"""
+Fodder for module finalization tests in test_module.
+"""
+
+import shutil
+import test.test_module.final_a
+
+x = 'b'
+
+class C:
+    def __del__(self):
+        # Inspect module globals and builtins
+        print("x =", x)
+        print("final_a.x =", test.test_module.final_a.x)
+        print("shutil.rmtree =", getattr(shutil.rmtree, '__name__', None))
+        print("len =", getattr(len, '__name__', None))
+
+c = C()
+_underscored = C()
diff --git a/Lib/test/test_modulefinder.py b/Lib/test/test_modulefinder.py
new file mode 100644
index 00000000000..51f7fd257e0
--- /dev/null
+++ b/Lib/test/test_modulefinder.py
@@ -0,0 +1,440 @@
+import os
+import errno
+import importlib.machinery
+import py_compile
+import shutil
+import unittest
+import tempfile
+
+from test import support
+
+import modulefinder
+
+# Each test description is a list of 5 items:
+#
+# 1. a module name that will be imported by modulefinder
+# 2. a list of module names that modulefinder is required to find
+# 3. a list of module names that modulefinder should complain
+#    about because they are not found
+# 4. a list of module names that modulefinder should complain
+#    about because they MAY be not found
+# 5. a string specifying packages to create; the format is obvious imo.
+#
+# Each package will be created in test_dir, and test_dir will be
+# removed after the tests again.
+# Modulefinder searches in a path that contains test_dir, plus
+# the standard Lib directory.
+
+maybe_test = [
+    "a.module",
+    ["a", "a.module", "sys",
+     "b"],
+    ["c"], ["b.something"],
+    """\
+a/__init__.py
+a/module.py
+                                from b import something
+                                from c import something
+b/__init__.py
+                                from sys import *
+""",
+]
+
+maybe_test_new = [
+    "a.module",
+    ["a", "a.module", "sys",
+     "b", "__future__"],
+    ["c"], ["b.something"],
+    """\
+a/__init__.py
+a/module.py
+                                from b import something
+                                from c import something
+b/__init__.py
+                                from __future__ import absolute_import
+                                from sys import *
+"""]
+
+package_test = [
+    "a.module",
+    ["a", "a.b", "a.c", "a.module", "mymodule", "sys"],
+    ["blahblah", "c"], [],
+    """\
+mymodule.py
+a/__init__.py
+                                import blahblah
+                                from a import b
+                                import c
+a/module.py
+                                import sys
+                                from a import b as x
+                                from a.c import sillyname
+a/b.py
+a/c.py
+                                from a.module import x
+                                import mymodule as sillyname
+                                from sys import version_info
+"""]
+
+absolute_import_test = [
+    "a.module",
+    ["a", "a.module",
+     "b", "b.x", "b.y", "b.z",
+     "__future__", "sys", "gc"],
+    ["blahblah", "z"], [],
+    """\
+mymodule.py
+a/__init__.py
+a/module.py
+                                from __future__ import absolute_import
+                                import sys # sys
+                                import blahblah # fails
+                                import gc # gc
+                                import b.x # b.x
+                                from b import y # b.y
+                                from b.z import * # b.z.*
+a/gc.py
+a/sys.py
+                                import mymodule
+a/b/__init__.py
+a/b/x.py
+a/b/y.py
+a/b/z.py
+b/__init__.py
+                                import z
+b/unused.py
+b/x.py
+b/y.py
+b/z.py
+"""]
+
+relative_import_test = [
+    "a.module",
+    ["__future__",
+     "a", "a.module",
+     "a.b", "a.b.y", "a.b.z",
+     "a.b.c", "a.b.c.moduleC",
+     "a.b.c.d", "a.b.c.e",
+     "a.b.x",
+     "gc"],
+    [], [],
+    """\
+mymodule.py
+a/__init__.py
+                                from .b import y, z # a.b.y, a.b.z
+a/module.py
+                                from __future__ import absolute_import # __future__
+                                import gc # gc
+a/gc.py
+a/sys.py
+a/b/__init__.py
+                                from ..b import x # a.b.x
+                                #from a.b.c import moduleC
+                                from .c import moduleC # a.b.moduleC
+a/b/x.py
+a/b/y.py
+a/b/z.py
+a/b/g.py
+a/b/c/__init__.py
+                                from ..c import e # a.b.c.e
+a/b/c/moduleC.py
+                                from ..c import d # a.b.c.d
+a/b/c/d.py
+a/b/c/e.py
+a/b/c/x.py
+"""]
+
+relative_import_test_2 = [
+    "a.module",
+    ["a", "a.module",
+     "a.sys",
+     "a.b", "a.b.y", "a.b.z",
+     "a.b.c", "a.b.c.d",
+     "a.b.c.e",
+     "a.b.c.moduleC",
+     "a.b.c.f",
+     "a.b.x",
+     "a.another"],
+    [], [],
+    """\
+mymodule.py
+a/__init__.py
+                                from . import sys # a.sys
+a/another.py
+a/module.py
+                                from .b import y, z # a.b.y, a.b.z
+a/gc.py
+a/sys.py
+a/b/__init__.py
+                                from .c import moduleC # a.b.c.moduleC
+                                from .c import d # a.b.c.d
+a/b/x.py
+a/b/y.py
+a/b/z.py
+a/b/c/__init__.py
+                                from . import e # a.b.c.e
+a/b/c/moduleC.py
+                                #
+                                from . import f   # a.b.c.f
+                                from .. import x  # a.b.x
+                                from ... import another # a.another
+a/b/c/d.py
+a/b/c/e.py
+a/b/c/f.py
+"""]
+
+relative_import_test_3 = [
+    "a.module",
+    ["a", "a.module"],
+    ["a.bar"],
+    [],
+    """\
+a/__init__.py
+                                def foo(): pass
+a/module.py
+                                from . import foo
+                                from . import bar
+"""]
+
+relative_import_test_4 = [
+    "a.module",
+    ["a", "a.module"],
+    [],
+    [],
+    """\
+a/__init__.py
+                                def foo(): pass
+a/module.py
+                                from . import *
+"""]
+
+bytecode_test = [
+    "a",
+    ["a"],
+    [],
+    [],
+    ""
+]
+
+syntax_error_test = [
+    "a.module",
+    ["a", "a.module", "b"],
+    ["b.module"], [],
+    """\
+a/__init__.py
+a/module.py
+                                import b.module
+b/__init__.py
+b/module.py
+                                ?  # SyntaxError: invalid syntax
+"""]
+
+
+same_name_as_bad_test = [
+    "a.module",
+    ["a", "a.module", "b", "b.c"],
+    ["c"], [],
+    """\
+a/__init__.py
+a/module.py
+                                import c
+                                from b import c
+b/__init__.py
+b/c.py
+"""]
+
+coding_default_utf8_test = [
+    "a_utf8",
+    ["a_utf8", "b_utf8"],
+    [], [],
+    """\
+a_utf8.py
+                                # use the default of utf8
+                                print('Unicode test A code point 2090 \u2090 that is not valid in cp1252')
+                                import b_utf8
+b_utf8.py
+                                # use the default of utf8
+                                print('Unicode test B code point 2090 \u2090 that is not valid in cp1252')
+"""]
+
+coding_explicit_utf8_test = [
+    "a_utf8",
+    ["a_utf8", "b_utf8"],
+    [], [],
+    """\
+a_utf8.py
+                                # coding=utf8
+                                print('Unicode test A code point 2090 \u2090 that is not valid in cp1252')
+                                import b_utf8
+b_utf8.py
+                                # use the default of utf8
+                                print('Unicode test B code point 2090 \u2090 that is not valid in cp1252')
+"""]
+
+coding_explicit_cp1252_test = [
+    "a_cp1252",
+    ["a_cp1252", "b_utf8"],
+    [], [],
+    b"""\
+a_cp1252.py
+                                # coding=cp1252
+                                # 0xe2 is not allowed in utf8
+                                print('CP1252 test P\xe2t\xe9')
+                                import b_utf8
+""" + """\
+b_utf8.py
+                                # use the default of utf8
+                                print('Unicode test A code point 2090 \u2090 that is not valid in cp1252')
+""".encode('utf-8')]
+
+def open_file(path):
+    dirname = os.path.dirname(path)
+    try:
+        os.makedirs(dirname)
+    except OSError as e:
+        if e.errno != errno.EEXIST:
+            raise
+    return open(path, 'wb')
+
+
+def create_package(test_dir, source):
+    ofi = None
+    try:
+        for line in source.splitlines():
+            if type(line) != bytes:
+                line = line.encode('utf-8')
+            if line.startswith(b' ') or line.startswith(b'\t'):
+                ofi.write(line.strip() + b'\n')
+            else:
+                if ofi:
+                    ofi.close()
+                if type(line) == bytes:
+                    line = line.decode('utf-8')
+                ofi = open_file(os.path.join(test_dir, line.strip()))
+    finally:
+        if ofi:
+            ofi.close()
+
+class ModuleFinderTest(unittest.TestCase):
+    def setUp(self):
+        self.test_dir = tempfile.mkdtemp()
+        self.test_path = [self.test_dir, os.path.dirname(tempfile.__file__)]
+
+    def tearDown(self):
+        shutil.rmtree(self.test_dir)
+
+    def _do_test(self, info, report=False, debug=0, replace_paths=[], modulefinder_class=modulefinder.ModuleFinder):
+        import_this, modules, missing, maybe_missing, source = info
+        create_package(self.test_dir, source)
+        mf = modulefinder_class(path=self.test_path, debug=debug,
+                                        replace_paths=replace_paths)
+        mf.import_hook(import_this)
+        if report:
+            mf.report()
+##            # This wouldn't work in general when executed several times:
+##            opath = sys.path[:]
+##            sys.path = self.test_path
+##            try:
+##                __import__(import_this)
+##            except:
+##                import traceback; traceback.print_exc()
+##            sys.path = opath
+##            return
+        modules = sorted(set(modules))
+        found = sorted(mf.modules)
+        # check if we found what we expected, not more, not less
+        self.assertEqual(found, modules)
+
+        # check for missing and maybe missing modules
+        bad, maybe = mf.any_missing_maybe()
+        self.assertEqual(bad, missing)
+        self.assertEqual(maybe, maybe_missing)
+
+    def test_package(self):
+        self._do_test(package_test)
+
+    def test_maybe(self):
+        self._do_test(maybe_test)
+
+    def test_maybe_new(self):
+        self._do_test(maybe_test_new)
+
+    def test_absolute_imports(self):
+        self._do_test(absolute_import_test)
+
+    def test_relative_imports(self):
+        self._do_test(relative_import_test)
+
+    def test_relative_imports_2(self):
+        self._do_test(relative_import_test_2)
+
+    def test_relative_imports_3(self):
+        self._do_test(relative_import_test_3)
+
+    def test_relative_imports_4(self):
+        self._do_test(relative_import_test_4)
+
+    def test_syntax_error(self):
+        self._do_test(syntax_error_test)
+
+    def test_same_name_as_bad(self):
+        self._do_test(same_name_as_bad_test)
+
+    def test_bytecode(self):
+        base_path = os.path.join(self.test_dir, 'a')
+        source_path = base_path + importlib.machinery.SOURCE_SUFFIXES[0]
+        bytecode_path = base_path + importlib.machinery.BYTECODE_SUFFIXES[0]
+        with open_file(source_path) as file:
+            file.write('testing_modulefinder = True\n'.encode('utf-8'))
+        py_compile.compile(source_path, cfile=bytecode_path)
+        os.remove(source_path)
+        self._do_test(bytecode_test)
+
+    # TODO: RUSTPYTHON; panics at code.rs with 'called Option::unwrap() on a None value'
+    @unittest.skip("TODO: RUSTPYTHON; panics in co_filename replacement")
+    def test_replace_paths(self):
+        old_path = os.path.join(self.test_dir, 'a', 'module.py')
+        new_path = os.path.join(self.test_dir, 'a', 'spam.py')
+        with support.captured_stdout() as output:
+            self._do_test(maybe_test, debug=2,
+                          replace_paths=[(old_path, new_path)])
+        output = output.getvalue()
+        expected = "co_filename %r changed to %r" % (old_path, new_path)
+        self.assertIn(expected, output)
+
+    def test_extended_opargs(self):
+        extended_opargs_test = [
+            "a",
+            ["a", "b"],
+            [], [],
+            """\
+a.py
+                                %r
+                                import b
+b.py
+""" % list(range(2**16))]  # 2**16 constants
+        self._do_test(extended_opargs_test)
+
+    def test_coding_default_utf8(self):
+        self._do_test(coding_default_utf8_test)
+
+    def test_coding_explicit_utf8(self):
+        self._do_test(coding_explicit_utf8_test)
+
+    def test_coding_explicit_cp1252(self):
+        self._do_test(coding_explicit_cp1252_test)
+
+    def test_load_module_api(self):
+        class CheckLoadModuleApi(modulefinder.ModuleFinder):
+            def __init__(self, *args, **kwds):
+                super().__init__(*args, **kwds)
+
+            def load_module(self, fqname, fp, pathname, file_info):
+                # confirm that the fileinfo is a tuple of 3 elements
+                suffix, mode, type = file_info
+                return super().load_module(fqname, fp, pathname, file_info)
+
+        self._do_test(absolute_import_test, modulefinder_class=CheckLoadModuleApi)
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/Lib/test/test_monitoring.py b/Lib/test/test_monitoring.py
new file mode 100644
index 00000000000..5125701202b
--- /dev/null
+++ b/Lib/test/test_monitoring.py
@@ -0,0 +1,2465 @@
+"""Test suite for the sys.monitoring."""
+
+import collections
+import dis
+import functools
+import inspect
+import math
+import operator
+import sys
+import textwrap
+import types
+import unittest
+
+import test.support
+from test.support import requires_specialization_ft, script_helper
+
+try:
+    import _testcapi
+except ImportError:
+    _testcapi = None
+try:
+    import _testinternalcapi
+except ImportError:
+    _testinternalcapi = None
+
+PAIR = (0,1)
+
+def f1():
+    pass
+
+def f2():
+    len([])
+    sys.getsizeof(0)
+
+def floop():
+    for item in PAIR:
+        pass
+
+def gen():
+    yield
+    yield
+
+def g1():
+    for _ in gen():
+        pass
+
+TEST_TOOL = 2
+TEST_TOOL2 = 3
+TEST_TOOL3 = 4
+
+def nth_line(func, offset):
+    return func.__code__.co_firstlineno + offset
+
+class MonitoringBasicTest(unittest.TestCase):
+
+    def tearDown(self):
+        sys.monitoring.free_tool_id(TEST_TOOL)
+
+    def test_has_objects(self):
+        m = sys.monitoring
+        m.events
+        m.use_tool_id
+        m.clear_tool_id
+        m.free_tool_id
+        m.get_tool
+        m.get_events
+        m.set_events
+        m.get_local_events
+        m.set_local_events
+        m.register_callback
+        m.restart_events
+        m.DISABLE
+        m.MISSING
+        m.events.NO_EVENTS
+
+    def test_tool(self):
+        sys.monitoring.use_tool_id(TEST_TOOL, "MonitoringTest.Tool")
+        self.assertEqual(sys.monitoring.get_tool(TEST_TOOL), "MonitoringTest.Tool")
+        sys.monitoring.set_events(TEST_TOOL, 15)
+        self.assertEqual(sys.monitoring.get_events(TEST_TOOL), 15)
+        sys.monitoring.set_events(TEST_TOOL, 0)
+        with self.assertRaises(ValueError):
+            sys.monitoring.set_events(TEST_TOOL, sys.monitoring.events.C_RETURN)
+        with self.assertRaises(ValueError):
+            sys.monitoring.set_events(TEST_TOOL, sys.monitoring.events.C_RAISE)
+        sys.monitoring.free_tool_id(TEST_TOOL)
+        self.assertEqual(sys.monitoring.get_tool(TEST_TOOL), None)
+        with self.assertRaises(ValueError):
+            sys.monitoring.set_events(TEST_TOOL, sys.monitoring.events.CALL)
+
+    def test_clear(self):
+        events = []
+        sys.monitoring.use_tool_id(TEST_TOOL, "MonitoringTest.Tool")
+        sys.monitoring.register_callback(TEST_TOOL, E.PY_START, lambda *args: events.append(args))
+        sys.monitoring.register_callback(TEST_TOOL, E.LINE, lambda *args: events.append(args))
+        def f():
+            a = 1
+        sys.monitoring.set_local_events(TEST_TOOL, f.__code__, E.LINE)
+        sys.monitoring.set_events(TEST_TOOL, E.PY_START)
+
+        f()
+        sys.monitoring.clear_tool_id(TEST_TOOL)
+        f()
+
+        # the first f() should trigger a PY_START and a LINE event
+        # the second f() after clear_tool_id should not trigger any event
+        # the callback function should be cleared as well
+        self.assertEqual(len(events), 2)
+        callback = sys.monitoring.register_callback(TEST_TOOL, E.LINE, None)
+        self.assertIs(callback, None)
+
+        sys.monitoring.free_tool_id(TEST_TOOL)
+
+        events = []
+        sys.monitoring.use_tool_id(TEST_TOOL, "MonitoringTest.Tool")
+        sys.monitoring.register_callback(TEST_TOOL, E.LINE, lambda *args: events.append(args))
+        sys.monitoring.set_local_events(TEST_TOOL, f.__code__, E.LINE)
+        f()
+        sys.monitoring.free_tool_id(TEST_TOOL)
+        sys.monitoring.use_tool_id(TEST_TOOL, "MonitoringTest.Tool")
+        f()
+        # the first f() should trigger a LINE event, and even if we use the
+        # tool id immediately after freeing it, the second f() should not
+        # trigger any event
+        self.assertEqual(len(events), 1)
+        sys.monitoring.free_tool_id(TEST_TOOL)
+
+
+class MonitoringTestBase:
+
+    def setUp(self):
+        # Check that a previous test hasn't left monitoring on.
+        for tool in range(6):
+            self.assertEqual(sys.monitoring.get_events(tool), 0)
+        self.assertIs(sys.monitoring.get_tool(TEST_TOOL), None)
+        self.assertIs(sys.monitoring.get_tool(TEST_TOOL2), None)
+        self.assertIs(sys.monitoring.get_tool(TEST_TOOL3), None)
+        sys.monitoring.use_tool_id(TEST_TOOL, "test " + self.__class__.__name__)
+        sys.monitoring.use_tool_id(TEST_TOOL2, "test2 " + self.__class__.__name__)
+        sys.monitoring.use_tool_id(TEST_TOOL3, "test3 " + self.__class__.__name__)
+
+    def tearDown(self):
+        # Check that test hasn't left monitoring on.
+        for tool in range(6):
+            self.assertEqual(sys.monitoring.get_events(tool), 0)
+        sys.monitoring.free_tool_id(TEST_TOOL)
+        sys.monitoring.free_tool_id(TEST_TOOL2)
+        sys.monitoring.free_tool_id(TEST_TOOL3)
+
+
+class MonitoringCountTest(MonitoringTestBase, unittest.TestCase):
+
+    def check_event_count(self, func, event, expected):
+
+        class Counter:
+            def __init__(self):
+                self.count = 0
+            def __call__(self, *args):
+                self.count += 1
+
+        counter = Counter()
+        sys.monitoring.register_callback(TEST_TOOL, event, counter)
+        if event == E.C_RETURN or event == E.C_RAISE:
+            sys.monitoring.set_events(TEST_TOOL, E.CALL)
+        else:
+            sys.monitoring.set_events(TEST_TOOL, event)
+        self.assertEqual(counter.count, 0)
+        counter.count = 0
+        func()
+        self.assertEqual(counter.count, expected)
+        prev = sys.monitoring.register_callback(TEST_TOOL, event, None)
+        counter.count = 0
+        func()
+        self.assertEqual(counter.count, 0)
+        self.assertEqual(prev, counter)
+        sys.monitoring.set_events(TEST_TOOL, 0)
+
+    def test_start_count(self):
+        self.check_event_count(f1, E.PY_START, 1)
+
+    def test_resume_count(self):
+        self.check_event_count(g1, E.PY_RESUME, 2)
+
+    def test_return_count(self):
+        self.check_event_count(f1, E.PY_RETURN, 1)
+
+    def test_call_count(self):
+        self.check_event_count(f2, E.CALL, 3)
+
+    def test_c_return_count(self):
+        self.check_event_count(f2, E.C_RETURN, 2)
+
+
+E = sys.monitoring.events
+
+INSTRUMENTED_EVENTS = [
+    (E.PY_START, "start"),
+    (E.PY_RESUME, "resume"),
+    (E.PY_RETURN, "return"),
+    (E.PY_YIELD, "yield"),
+    (E.JUMP, "jump"),
+    (E.BRANCH, "branch"),
+]
+
+EXCEPT_EVENTS = [
+    (E.RAISE, "raise"),
+    (E.PY_UNWIND, "unwind"),
+    (E.EXCEPTION_HANDLED, "exception_handled"),
+]
+
+SIMPLE_EVENTS = INSTRUMENTED_EVENTS + EXCEPT_EVENTS + [
+    (E.C_RAISE, "c_raise"),
+    (E.C_RETURN, "c_return"),
+]
+
+
+SIMPLE_EVENT_SET = functools.reduce(operator.or_, [ev for (ev, _) in SIMPLE_EVENTS], 0) | E.CALL
+
+
+def just_pass():
+    pass
+
+just_pass.events = [
+    "py_call",
+    "start",
+    "return",
+]
+
+def just_raise():
+    raise Exception
+
+just_raise.events = [
+    'py_call',
+    "start",
+    "raise",
+    "unwind",
+]
+
+def just_call():
+    len([])
+
+just_call.events = [
+    'py_call',
+    "start",
+    "c_call",
+    "c_return",
+    "return",
+]
+
+def caught():
+    try:
+        1/0
+    except Exception:
+        pass
+
+caught.events = [
+    'py_call',
+    "start",
+    "raise",
+    "exception_handled",
+    "branch",
+    "return",
+]
+
+def nested_call():
+    just_pass()
+
+nested_call.events = [
+    "py_call",
+    "start",
+    "py_call",
+    "start",
+    "return",
+    "return",
+]
+
+PY_CALLABLES = (types.FunctionType, types.MethodType)
+
+class MonitoringEventsBase(MonitoringTestBase):
+
+    def gather_events(self, func):
+        events = []
+        for event, event_name in SIMPLE_EVENTS:
+            def record(*args, event_name=event_name):
+                events.append(event_name)
+            sys.monitoring.register_callback(TEST_TOOL, event, record)
+        def record_call(code, offset, obj, arg):
+            if isinstance(obj, PY_CALLABLES):
+                events.append("py_call")
+            else:
+                events.append("c_call")
+        sys.monitoring.register_callback(TEST_TOOL, E.CALL, record_call)
+        sys.monitoring.set_events(TEST_TOOL, SIMPLE_EVENT_SET)
+        events = []
+        try:
+            func()
+        except:
+            pass
+        sys.monitoring.set_events(TEST_TOOL, 0)
+        #Remove the final event, the call to `sys.monitoring.set_events`
+        events = events[:-1]
+        return events
+
+    def check_events(self, func, expected=None):
+        events = self.gather_events(func)
+        if expected is None:
+            expected = func.events
+        self.assertEqual(events, expected)
+
+class MonitoringEventsTest(MonitoringEventsBase, unittest.TestCase):
+
+    def test_just_pass(self):
+        self.check_events(just_pass)
+
+    def test_just_raise(self):
+        try:
+            self.check_events(just_raise)
+        except Exception:
+            pass
+        self.assertEqual(sys.monitoring.get_events(TEST_TOOL), 0)
+
+    def test_just_call(self):
+        self.check_events(just_call)
+
+    def test_caught(self):
+        self.check_events(caught)
+
+    def test_nested_call(self):
+        self.check_events(nested_call)
+
+UP_EVENTS = (E.C_RETURN, E.C_RAISE, E.PY_RETURN, E.PY_UNWIND, E.PY_YIELD)
+DOWN_EVENTS = (E.PY_START, E.PY_RESUME)
+
+from test.profilee import testfunc
+
+class SimulateProfileTest(MonitoringEventsBase, unittest.TestCase):
+
+    def test_balanced(self):
+        events = self.gather_events(testfunc)
+        c = collections.Counter(events)
+        self.assertEqual(c["c_call"], c["c_return"])
+        self.assertEqual(c["start"], c["return"] + c["unwind"])
+        self.assertEqual(c["raise"], c["exception_handled"] + c["unwind"])
+
+    def test_frame_stack(self):
+        self.maxDiff = None
+        stack = []
+        errors = []
+        seen = set()
+        def up(*args):
+            frame = sys._getframe(1)
+            if not stack:
+                errors.append("empty")
+            else:
+                expected = stack.pop()
+                if frame != expected:
+                    errors.append(f" Popping {frame} expected {expected}")
+        def down(*args):
+            frame = sys._getframe(1)
+            stack.append(frame)
+            seen.add(frame.f_code)
+        def call(code, offset, callable, arg):
+            if not isinstance(callable, PY_CALLABLES):
+                stack.append(sys._getframe(1))
+        for event in UP_EVENTS:
+            sys.monitoring.register_callback(TEST_TOOL, event, up)
+        for event in DOWN_EVENTS:
+            sys.monitoring.register_callback(TEST_TOOL, event, down)
+        sys.monitoring.register_callback(TEST_TOOL, E.CALL, call)
+        sys.monitoring.set_events(TEST_TOOL, SIMPLE_EVENT_SET)
+        testfunc()
+        sys.monitoring.set_events(TEST_TOOL, 0)
+        self.assertEqual(errors, [])
+        self.assertEqual(stack, [sys._getframe()])
+        self.assertEqual(len(seen), 9)
+
+
+class CounterWithDisable:
+
+    def __init__(self):
+        self.disable = False
+        self.count = 0
+
+    def __call__(self, *args):
+        self.count += 1
+        if self.disable:
+            return sys.monitoring.DISABLE
+
+
+class RecorderWithDisable:
+
+    def __init__(self, events):
+        self.disable = False
+        self.events = events
+
+    def __call__(self, code, event):
+        self.events.append(event)
+        if self.disable:
+            return sys.monitoring.DISABLE
+
+
+class MontoringDisableAndRestartTest(MonitoringTestBase, unittest.TestCase):
+
+    def test_disable(self):
+        try:
+            counter = CounterWithDisable()
+            sys.monitoring.register_callback(TEST_TOOL, E.PY_START, counter)
+            sys.monitoring.set_events(TEST_TOOL, E.PY_START)
+            self.assertEqual(counter.count, 0)
+            counter.count = 0
+            f1()
+            self.assertEqual(counter.count, 1)
+            counter.disable = True
+            counter.count = 0
+            f1()
+            self.assertEqual(counter.count, 1)
+            counter.count = 0
+            f1()
+            self.assertEqual(counter.count, 0)
+            sys.monitoring.set_events(TEST_TOOL, 0)
+        finally:
+            sys.monitoring.restart_events()
+
+    def test_restart(self):
+        try:
+            counter = CounterWithDisable()
+            sys.monitoring.register_callback(TEST_TOOL, E.PY_START, counter)
+            sys.monitoring.set_events(TEST_TOOL, E.PY_START)
+            counter.disable = True
+            f1()
+            counter.count = 0
+            f1()
+            self.assertEqual(counter.count, 0)
+            sys.monitoring.restart_events()
+            counter.count = 0
+            f1()
+            self.assertEqual(counter.count, 1)
+            sys.monitoring.set_events(TEST_TOOL, 0)
+        finally:
+            sys.monitoring.restart_events()
+
+
+class MultipleMonitorsTest(MonitoringTestBase, unittest.TestCase):
+
+    def test_two_same(self):
+        try:
+            self.assertEqual(sys.monitoring._all_events(), {})
+            counter1 = CounterWithDisable()
+            counter2 = CounterWithDisable()
+            sys.monitoring.register_callback(TEST_TOOL, E.PY_START, counter1)
+            sys.monitoring.register_callback(TEST_TOOL2, E.PY_START, counter2)
+            sys.monitoring.set_events(TEST_TOOL, E.PY_START)
+            sys.monitoring.set_events(TEST_TOOL2, E.PY_START)
+            self.assertEqual(sys.monitoring.get_events(TEST_TOOL), E.PY_START)
+            self.assertEqual(sys.monitoring.get_events(TEST_TOOL2), E.PY_START)
+            self.assertEqual(sys.monitoring._all_events(), {'PY_START': (1 << TEST_TOOL) | (1 << TEST_TOOL2)})
+            counter1.count = 0
+            counter2.count = 0
+            f1()
+            count1 = counter1.count
+            count2 = counter2.count
+            self.assertEqual((count1, count2), (1, 1))
+        finally:
+            sys.monitoring.set_events(TEST_TOOL, 0)
+            sys.monitoring.set_events(TEST_TOOL2, 0)
+            sys.monitoring.register_callback(TEST_TOOL, E.PY_START, None)
+            sys.monitoring.register_callback(TEST_TOOL2, E.PY_START, None)
+            self.assertEqual(sys.monitoring._all_events(), {})
+
+    def test_three_same(self):
+        try:
+            self.assertEqual(sys.monitoring._all_events(), {})
+            counter1 = CounterWithDisable()
+            counter2 = CounterWithDisable()
+            counter3 = CounterWithDisable()
+            sys.monitoring.register_callback(TEST_TOOL, E.PY_START, counter1)
+            sys.monitoring.register_callback(TEST_TOOL2, E.PY_START, counter2)
+            sys.monitoring.register_callback(TEST_TOOL3, E.PY_START, counter3)
+            sys.monitoring.set_events(TEST_TOOL, E.PY_START)
+            sys.monitoring.set_events(TEST_TOOL2, E.PY_START)
+            sys.monitoring.set_events(TEST_TOOL3, E.PY_START)
+            self.assertEqual(sys.monitoring.get_events(TEST_TOOL), E.PY_START)
+            self.assertEqual(sys.monitoring.get_events(TEST_TOOL2), E.PY_START)
+            self.assertEqual(sys.monitoring.get_events(TEST_TOOL3), E.PY_START)
+            self.assertEqual(sys.monitoring._all_events(), {'PY_START': (1 << TEST_TOOL) | (1 << TEST_TOOL2) | (1 << TEST_TOOL3)})
+            counter1.count = 0
+            counter2.count = 0
+            counter3.count = 0
+            f1()
+            count1 = counter1.count
+            count2 = counter2.count
+            count3 = counter3.count
+            self.assertEqual((count1, count2, count3), (1, 1, 1))
+        finally:
+            sys.monitoring.set_events(TEST_TOOL, 0)
+            sys.monitoring.set_events(TEST_TOOL2, 0)
+            sys.monitoring.set_events(TEST_TOOL3, 0)
+            sys.monitoring.register_callback(TEST_TOOL, E.PY_START, None)
+            sys.monitoring.register_callback(TEST_TOOL2, E.PY_START, None)
+            sys.monitoring.register_callback(TEST_TOOL3, E.PY_START, None)
+            self.assertEqual(sys.monitoring._all_events(), {})
+
+    def test_two_different(self):
+        try:
+            self.assertEqual(sys.monitoring._all_events(), {})
+            counter1 = CounterWithDisable()
+            counter2 = CounterWithDisable()
+            sys.monitoring.register_callback(TEST_TOOL, E.PY_START, counter1)
+            sys.monitoring.register_callback(TEST_TOOL2, E.PY_RETURN, counter2)
+            sys.monitoring.set_events(TEST_TOOL, E.PY_START)
+            sys.monitoring.set_events(TEST_TOOL2, E.PY_RETURN)
+            self.assertEqual(sys.monitoring.get_events(TEST_TOOL), E.PY_START)
+            self.assertEqual(sys.monitoring.get_events(TEST_TOOL2), E.PY_RETURN)
+            self.assertEqual(sys.monitoring._all_events(), {'PY_START': 1 << TEST_TOOL, 'PY_RETURN': 1 << TEST_TOOL2})
+            counter1.count = 0
+            counter2.count = 0
+            f1()
+            count1 = counter1.count
+            count2 = counter2.count
+            self.assertEqual((count1, count2), (1, 1))
+        finally:
+            sys.monitoring.set_events(TEST_TOOL, 0)
+            sys.monitoring.set_events(TEST_TOOL2, 0)
+            sys.monitoring.register_callback(TEST_TOOL, E.PY_START, None)
+            sys.monitoring.register_callback(TEST_TOOL2, E.PY_RETURN, None)
+            self.assertEqual(sys.monitoring._all_events(), {})
+
+    def test_two_with_disable(self):
+        try:
+            self.assertEqual(sys.monitoring._all_events(), {})
+            counter1 = CounterWithDisable()
+            counter2 = CounterWithDisable()
+            sys.monitoring.register_callback(TEST_TOOL, E.PY_START, counter1)
+            sys.monitoring.register_callback(TEST_TOOL2, E.PY_START, counter2)
+            sys.monitoring.set_events(TEST_TOOL, E.PY_START)
+            sys.monitoring.set_events(TEST_TOOL2, E.PY_START)
+            self.assertEqual(sys.monitoring.get_events(TEST_TOOL), E.PY_START)
+            self.assertEqual(sys.monitoring.get_events(TEST_TOOL2), E.PY_START)
+            self.assertEqual(sys.monitoring._all_events(), {'PY_START': (1 << TEST_TOOL) | (1 << TEST_TOOL2)})
+            counter1.count = 0
+            counter2.count = 0
+            counter1.disable = True
+            f1()
+            count1 = counter1.count
+            count2 = counter2.count
+            self.assertEqual((count1, count2), (1, 1))
+            counter1.count = 0
+            counter2.count = 0
+            f1()
+            count1 = counter1.count
+            count2 = counter2.count
+            self.assertEqual((count1, count2), (0, 1))
+        finally:
+            sys.monitoring.set_events(TEST_TOOL, 0)
+            sys.monitoring.set_events(TEST_TOOL2, 0)
+            sys.monitoring.register_callback(TEST_TOOL, E.PY_START, None)
+            sys.monitoring.register_callback(TEST_TOOL2, E.PY_START, None)
+            self.assertEqual(sys.monitoring._all_events(), {})
+            sys.monitoring.restart_events()
+
+    def test_with_instruction_event(self):
+        """Test that the second tool can set events with instruction events set by the first tool."""
+        def f():
+            pass
+        code = f.__code__
+
+        try:
+            self.assertEqual(sys.monitoring._all_events(), {})
+            sys.monitoring.set_local_events(TEST_TOOL, code, E.INSTRUCTION | E.LINE)
+            sys.monitoring.set_local_events(TEST_TOOL2, code, E.LINE)
+        finally:
+            sys.monitoring.set_events(TEST_TOOL, 0)
+            sys.monitoring.set_events(TEST_TOOL2, 0)
+            self.assertEqual(sys.monitoring._all_events(), {})
+
+
+class LineMonitoringTest(MonitoringTestBase, unittest.TestCase):
+
+    def test_lines_single(self):
+        try:
+            self.assertEqual(sys.monitoring._all_events(), {})
+            events = []
+            recorder = RecorderWithDisable(events)
+            sys.monitoring.register_callback(TEST_TOOL, E.LINE, recorder)
+            sys.monitoring.set_events(TEST_TOOL, E.LINE)
+            f1()
+            sys.monitoring.set_events(TEST_TOOL, 0)
+            sys.monitoring.register_callback(TEST_TOOL, E.LINE, None)
+            start = nth_line(LineMonitoringTest.test_lines_single, 0)
+            self.assertEqual(events, [start+7, nth_line(f1, 1), start+8])
+        finally:
+            sys.monitoring.set_events(TEST_TOOL, 0)
+            sys.monitoring.register_callback(TEST_TOOL, E.LINE, None)
+            self.assertEqual(sys.monitoring._all_events(), {})
+            sys.monitoring.restart_events()
+
+    def test_lines_loop(self):
+        try:
+            self.assertEqual(sys.monitoring._all_events(), {})
+            events = []
+            recorder = RecorderWithDisable(events)
+            sys.monitoring.register_callback(TEST_TOOL, E.LINE, recorder)
+            sys.monitoring.set_events(TEST_TOOL, E.LINE)
+            floop()
+            sys.monitoring.set_events(TEST_TOOL, 0)
+            sys.monitoring.register_callback(TEST_TOOL, E.LINE, None)
+            start = nth_line(LineMonitoringTest.test_lines_loop, 0)
+            floop_1 = nth_line(floop, 1)
+            floop_2 = nth_line(floop, 2)
+            self.assertEqual(
+                events,
+                [start+7, floop_1, floop_2, floop_1, floop_2, floop_1, start+8]
+            )
+        finally:
+            sys.monitoring.set_events(TEST_TOOL, 0)
+            sys.monitoring.register_callback(TEST_TOOL, E.LINE, None)
+            self.assertEqual(sys.monitoring._all_events(), {})
+            sys.monitoring.restart_events()
+
+    def test_lines_two(self):
+        try:
+            self.assertEqual(sys.monitoring._all_events(), {})
+            events = []
+            recorder = RecorderWithDisable(events)
+            events2 = []
+            recorder2 = RecorderWithDisable(events2)
+            sys.monitoring.register_callback(TEST_TOOL, E.LINE, recorder)
+            sys.monitoring.register_callback(TEST_TOOL2, E.LINE, recorder2)
+            sys.monitoring.set_events(TEST_TOOL, E.LINE); sys.monitoring.set_events(TEST_TOOL2, E.LINE)
+            f1()
+            sys.monitoring.set_events(TEST_TOOL, 0); sys.monitoring.set_events(TEST_TOOL2, 0)
+            sys.monitoring.register_callback(TEST_TOOL, E.LINE, None)
+            sys.monitoring.register_callback(TEST_TOOL2, E.LINE, None)
+            start = nth_line(LineMonitoringTest.test_lines_two, 0)
+            expected = [start+10, nth_line(f1, 1), start+11]
+            self.assertEqual(events, expected)
+            self.assertEqual(events2, expected)
+        finally:
+            sys.monitoring.set_events(TEST_TOOL, 0)
+            sys.monitoring.set_events(TEST_TOOL2, 0)
+            sys.monitoring.register_callback(TEST_TOOL, E.LINE, None)
+            sys.monitoring.register_callback(TEST_TOOL2, E.LINE, None)
+            self.assertEqual(sys.monitoring._all_events(), {})
+            sys.monitoring.restart_events()
+
+    def check_lines(self, func, expected, tool=TEST_TOOL):
+        try:
+            self.assertEqual(sys.monitoring._all_events(), {})
+            events = []
+            recorder = RecorderWithDisable(events)
+            sys.monitoring.register_callback(tool, E.LINE, recorder)
+            sys.monitoring.set_events(tool, E.LINE)
+            func()
+            sys.monitoring.set_events(tool, 0)
+            sys.monitoring.register_callback(tool, E.LINE, None)
+            lines = [ line - func.__code__.co_firstlineno for line in events[1:-1] ]
+            self.assertEqual(lines, expected)
+        finally:
+            sys.monitoring.set_events(tool, 0)
+
+
+    def test_linear(self):
+
+        def func():
+            line = 1
+            line = 2
+            line = 3
+            line = 4
+            line = 5
+
+        self.check_lines(func, [1,2,3,4,5])
+
+    def test_branch(self):
+        def func():
+            if "true".startswith("t"):
+                line = 2
+                line = 3
+            else:
+                line = 5
+            line = 6
+
+        self.check_lines(func, [1,2,3,6])
+
+    def test_try_except(self):
+
+        def func1():
+            try:
+                line = 2
+                line = 3
+            except:
+                line = 5
+            line = 6
+
+        self.check_lines(func1, [1,2,3,6])
+
+        def func2():
+            try:
+                line = 2
+                raise 3
+            except:
+                line = 5
+            line = 6
+
+        self.check_lines(func2, [1,2,3,4,5,6])
+
+    def test_generator_with_line(self):
+
+        def f():
+            def a():
+                yield
+            def b():
+                yield from a()
+            next(b())
+
+        self.check_lines(f, [1,3,5,4,2,4])
+
+class TestDisable(MonitoringTestBase, unittest.TestCase):
+
+    def gen(self, cond):
+        for i in range(10):
+            if cond:
+                yield 1
+            else:
+                yield 2
+
+    def raise_handle_reraise(self):
+        try:
+            1/0
+        except:
+            raise
+
+    def test_disable_legal_events(self):
+        for event, name in INSTRUMENTED_EVENTS:
+            try:
+                counter = CounterWithDisable()
+                counter.disable = True
+                sys.monitoring.register_callback(TEST_TOOL, event, counter)
+                sys.monitoring.set_events(TEST_TOOL, event)
+                for _ in self.gen(1):
+                    pass
+                self.assertLess(counter.count, 4)
+            finally:
+                sys.monitoring.set_events(TEST_TOOL, 0)
+                sys.monitoring.register_callback(TEST_TOOL, event, None)
+
+
+    def test_disable_illegal_events(self):
+        for event, name in EXCEPT_EVENTS:
+            try:
+                counter = CounterWithDisable()
+                counter.disable = True
+                sys.monitoring.register_callback(TEST_TOOL, event, counter)
+                sys.monitoring.set_events(TEST_TOOL, event)
+                with self.assertRaises(ValueError):
+                    self.raise_handle_reraise()
+            finally:
+                sys.monitoring.set_events(TEST_TOOL, 0)
+                sys.monitoring.register_callback(TEST_TOOL, event, None)
+
+
+class ExceptionRecorder:
+
+    event_type = E.RAISE
+
+    def __init__(self, events):
+        self.events = events
+
+    def __call__(self, code, offset, exc):
+        self.events.append(("raise", type(exc)))
+
+class CheckEvents(MonitoringTestBase, unittest.TestCase):
+
+    def get_events(self, func, tool, recorders):
+        try:
+            self.assertEqual(sys.monitoring._all_events(), {})
+            event_list = []
+            all_events = 0
+            for recorder in recorders:
+                ev = recorder.event_type
+                sys.monitoring.register_callback(tool, ev, recorder(event_list))
+                all_events |= ev
+            sys.monitoring.set_events(tool, all_events)
+            func()
+            sys.monitoring.set_events(tool, 0)
+            for recorder in recorders:
+                sys.monitoring.register_callback(tool, recorder.event_type, None)
+            return event_list
+        finally:
+            sys.monitoring.set_events(tool, 0)
+            for recorder in recorders:
+                sys.monitoring.register_callback(tool, recorder.event_type, None)
+
+    def check_events(self, func, expected, tool=TEST_TOOL, recorders=(ExceptionRecorder,)):
+        events = self.get_events(func, tool, recorders)
+        self.assertEqual(events, expected)
+
+    def check_balanced(self, func, recorders):
+        events = self.get_events(func, TEST_TOOL, recorders)
+        self.assertEqual(len(events)%2, 0)
+        for r, h in zip(events[::2],events[1::2]):
+            r0 = r[0]
+            self.assertIn(r0, ("raise", "reraise"))
+            h0 = h[0]
+            self.assertIn(h0, ("handled", "unwind"))
+            self.assertEqual(r[1], h[1])
+
+
+class StopiterationRecorder(ExceptionRecorder):
+
+    event_type = E.STOP_ITERATION
+
+class ReraiseRecorder(ExceptionRecorder):
+
+    event_type = E.RERAISE
+
+    def __call__(self, code, offset, exc):
+        self.events.append(("reraise", type(exc)))
+
+class UnwindRecorder(ExceptionRecorder):
+
+    event_type = E.PY_UNWIND
+
+    def __call__(self, code, offset, exc):
+        self.events.append(("unwind", type(exc), code.co_name))
+
+class ExceptionHandledRecorder(ExceptionRecorder):
+
+    event_type = E.EXCEPTION_HANDLED
+
+    def __call__(self, code, offset, exc):
+        self.events.append(("handled", type(exc)))
+
+class ThrowRecorder(ExceptionRecorder):
+
+    event_type = E.PY_THROW
+
+    def __call__(self, code, offset, exc):
+        self.events.append(("throw", type(exc)))
+
+class CallRecorder:
+
+    event_type = E.CALL
+
+    def __init__(self, events):
+        self.events = events
+
+    def __call__(self, code, offset, func, arg):
+        self.events.append(("call", func.__name__, arg))
+
+class ReturnRecorder:
+
+    event_type = E.PY_RETURN
+
+    def __init__(self, events):
+        self.events = events
+
+    def __call__(self, code, offset, val):
+        self.events.append(("return", code.co_name, val))
+
+
+class ExceptionMonitoringTest(CheckEvents):
+
+    exception_recorders = (
+        ExceptionRecorder,
+        ReraiseRecorder,
+        ExceptionHandledRecorder,
+        UnwindRecorder
+    )
+
+    def test_simple_try_except(self):
+
+        def func1():
+            try:
+                line = 2
+                raise KeyError
+            except:
+                line = 5
+            line = 6
+
+        self.check_events(func1, [("raise", KeyError)])
+
+    @unittest.skipUnless(_testinternalcapi, "requires _testinternalcapi")
+    def test_implicit_stop_iteration(self):
+        """Generators are documented as raising a StopIteration
+           when they terminate.
+           However, we don't do that if we can avoid it, for speed.
+           sys.monitoring handles that by injecting a STOP_ITERATION
+           event when we would otherwise have skip the RAISE event.
+           This test checks that both paths record an equivalent event.
+           """
+
+        def gen():
+            yield 1
+            return 2
+
+        def implicit_stop_iteration(iterator=None):
+            if iterator is None:
+                iterator = gen()
+            for _ in iterator:
+                pass
+
+        recorders=(ExceptionRecorder, StopiterationRecorder,)
+        expected = [("raise", StopIteration)]
+
+        # Make sure that the loop is unspecialized, and that it will not
+        # re-specialize immediately, so that we can we can test the
+        # unspecialized version of the loop first.
+        # Note: this assumes that we don't specialize loops over sets.
+        implicit_stop_iteration(set(range(_testinternalcapi.SPECIALIZATION_THRESHOLD)))
+
+        # This will record a RAISE event for the StopIteration.
+        self.check_events(implicit_stop_iteration, expected, recorders=recorders)
+
+        # Now specialize, so that we see a STOP_ITERATION event.
+        for _ in range(_testinternalcapi.SPECIALIZATION_COOLDOWN):
+            implicit_stop_iteration()
+
+        # This will record a STOP_ITERATION event for the StopIteration.
+        self.check_events(implicit_stop_iteration, expected, recorders=recorders)
+
+    initial = [
+        ("raise", ZeroDivisionError),
+        ("handled", ZeroDivisionError)
+    ]
+
+    reraise = [
+        ("reraise", ZeroDivisionError),
+        ("handled", ZeroDivisionError)
+    ]
+
+    def test_explicit_reraise(self):
+
+        def func():
+            try:
+                try:
+                    1/0
+                except:
+                    raise
+            except:
+                pass
+
+        self.check_balanced(
+            func,
+            recorders = self.exception_recorders)
+
+    def test_explicit_reraise_named(self):
+
+        def func():
+            try:
+                try:
+                    1/0
+                except Exception as ex:
+                    raise
+            except:
+                pass
+
+        self.check_balanced(
+            func,
+            recorders = self.exception_recorders)
+
+    def test_implicit_reraise(self):
+
+        def func():
+            try:
+                try:
+                    1/0
+                except ValueError:
+                    pass
+            except:
+                pass
+
+        self.check_balanced(
+            func,
+            recorders = self.exception_recorders)
+
+
+    def test_implicit_reraise_named(self):
+
+        def func():
+            try:
+                try:
+                    1/0
+                except ValueError as ex:
+                    pass
+            except:
+                pass
+
+        self.check_balanced(
+            func,
+            recorders = self.exception_recorders)
+
+    def test_try_finally(self):
+
+        def func():
+            try:
+                try:
+                    1/0
+                finally:
+                    pass
+            except:
+                pass
+
+        self.check_balanced(
+            func,
+            recorders = self.exception_recorders)
+
+    def test_async_for(self):
+
+        def func():
+
+            async def async_generator():
+                for i in range(1):
+                    raise ZeroDivisionError
+                    yield i
+
+            async def async_loop():
+                try:
+                    async for item in async_generator():
+                        pass
+                except Exception:
+                    pass
+
+            try:
+                async_loop().send(None)
+            except StopIteration:
+                pass
+
+        self.check_balanced(
+            func,
+            recorders = self.exception_recorders)
+
+    def test_throw(self):
+
+        def gen():
+            yield 1
+            yield 2
+
+        def func():
+            try:
+                g = gen()
+                next(g)
+                g.throw(IndexError)
+            except IndexError:
+                pass
+
+        self.check_balanced(
+            func,
+            recorders = self.exception_recorders)
+
+        events = self.get_events(
+            func,
+            TEST_TOOL,
+            self.exception_recorders + (ThrowRecorder,)
+        )
+        self.assertEqual(events[0], ("throw", IndexError))
+
+    @unittest.skipUnless(_testinternalcapi, "requires _testinternalcapi")
+    @requires_specialization_ft
+    def test_no_unwind_for_shim_frame(self):
+        class ValueErrorRaiser:
+            def __init__(self):
+                raise ValueError()
+
+        def f():
+            try:
+                return ValueErrorRaiser()
+            except ValueError:
+                pass
+
+        for _ in range(_testinternalcapi.SPECIALIZATION_THRESHOLD):
+            f()
+        recorders = (
+            ReturnRecorder,
+            UnwindRecorder
+        )
+        events = self.get_events(f, TEST_TOOL, recorders)
+        adaptive_insts = dis.get_instructions(f, adaptive=True)
+        self.assertIn(
+            "CALL_ALLOC_AND_ENTER_INIT",
+            [i.opname for i in adaptive_insts]
+        )
+        #There should be only one unwind event
+        expected = [
+            ('unwind', ValueError, '__init__'),
+            ('return', 'f', None),
+        ]
+
+        self.assertEqual(events, expected)
+
+    # gh-140373
+    def test_gen_unwind(self):
+        def gen():
+            yield 1
+
+        def f():
+            g = gen()
+            next(g)
+            g.close()
+
+        recorders = (
+            UnwindRecorder,
+        )
+        events = self.get_events(f, TEST_TOOL, recorders)
+        expected = [
+            ("unwind", GeneratorExit, "gen"),
+        ]
+        self.assertEqual(events, expected)
+
+class LineRecorder:
+
+    event_type = E.LINE
+
+
+    def __init__(self, events):
+        self.events = events
+
+    def __call__(self, code, line):
+        self.events.append(("line", code.co_name, line - code.co_firstlineno))
+
+class CEventRecorder:
+
+    def __init__(self, events):
+        self.events = events
+
+    def __call__(self, code, offset, func, arg):
+        self.events.append((self.event_name, func.__name__, arg))
+
+class CReturnRecorder(CEventRecorder):
+
+    event_type = E.C_RETURN
+    event_name = "C return"
+
+class CRaiseRecorder(CEventRecorder):
+
+    event_type = E.C_RAISE
+    event_name = "C raise"
+
+MANY_RECORDERS = ExceptionRecorder, CallRecorder, LineRecorder, CReturnRecorder, CRaiseRecorder
+
+class TestManyEvents(CheckEvents):
+
+    def test_simple(self):
+
+        def func1():
+            line1 = 1
+            line2 = 2
+            line3 = 3
+
+        self.check_events(func1, recorders = MANY_RECORDERS, expected = [
+            ('line', 'get_events', 10),
+            ('call', 'func1', sys.monitoring.MISSING),
+            ('line', 'func1', 1),
+            ('line', 'func1', 2),
+            ('line', 'func1', 3),
+            ('line', 'get_events', 11),
+            ('call', 'set_events', 2)])
+
+    def test_c_call(self):
+
+        def func2():
+            line1 = 1
+            [].append(2)
+            line3 = 3
+
+        self.check_events(func2, recorders = MANY_RECORDERS, expected = [
+            ('line', 'get_events', 10),
+            ('call', 'func2', sys.monitoring.MISSING),
+            ('line', 'func2', 1),
+            ('line', 'func2', 2),
+            ('call', 'append', [2]),
+            ('C return', 'append', [2]),
+            ('line', 'func2', 3),
+            ('line', 'get_events', 11),
+            ('call', 'set_events', 2)])
+
+    def test_try_except(self):
+
+        def func3():
+            try:
+                line = 2
+                raise KeyError
+            except:
+                line = 5
+            line = 6
+
+        self.check_events(func3, recorders = MANY_RECORDERS, expected = [
+            ('line', 'get_events', 10),
+            ('call', 'func3', sys.monitoring.MISSING),
+            ('line', 'func3', 1),
+            ('line', 'func3', 2),
+            ('line', 'func3', 3),
+            ('raise', KeyError),
+            ('line', 'func3', 4),
+            ('line', 'func3', 5),
+            ('line', 'func3', 6),
+            ('line', 'get_events', 11),
+            ('call', 'set_events', 2)])
+
+class InstructionRecorder:
+
+    event_type = E.INSTRUCTION
+
+    def __init__(self, events):
+        self.events = events
+
+    def __call__(self, code, offset):
+        # Filter out instructions in check_events to lower noise
+        if code.co_name != "get_events":
+            self.events.append(("instruction", code.co_name, offset))
+
+
+LINE_AND_INSTRUCTION_RECORDERS = InstructionRecorder, LineRecorder
+
+class TestLineAndInstructionEvents(CheckEvents):
+    maxDiff = None
+
+    def test_simple(self):
+
+        def func1():
+            line1 = 1
+            line2 = 2
+            line3 = 3
+
+        self.check_events(func1, recorders = LINE_AND_INSTRUCTION_RECORDERS, expected = [
+            ('line', 'get_events', 10),
+            ('line', 'func1', 1),
+            ('instruction', 'func1', 2),
+            ('instruction', 'func1', 4),
+            ('line', 'func1', 2),
+            ('instruction', 'func1', 6),
+            ('instruction', 'func1', 8),
+            ('line', 'func1', 3),
+            ('instruction', 'func1', 10),
+            ('instruction', 'func1', 12),
+            ('instruction', 'func1', 14),
+            ('instruction', 'func1', 16),
+            ('line', 'get_events', 11)])
+
+    def test_c_call(self):
+
+        def func2():
+            line1 = 1
+            [].append(2)
+            line3 = 3
+
+        self.check_events(func2, recorders = LINE_AND_INSTRUCTION_RECORDERS, expected = [
+            ('line', 'get_events', 10),
+            ('line', 'func2', 1),
+            ('instruction', 'func2', 2),
+            ('instruction', 'func2', 4),
+            ('line', 'func2', 2),
+            ('instruction', 'func2', 6),
+            ('instruction', 'func2', 8),
+            ('instruction', 'func2', 28),
+            ('instruction', 'func2', 30),
+            ('instruction', 'func2', 38),
+            ('line', 'func2', 3),
+            ('instruction', 'func2', 40),
+            ('instruction', 'func2', 42),
+            ('instruction', 'func2', 44),
+            ('instruction', 'func2', 46),
+            ('line', 'get_events', 11)])
+
+    def test_try_except(self):
+
+        def func3():
+            try:
+                line = 2
+                raise KeyError
+            except:
+                line = 5
+            line = 6
+
+        self.check_events(func3, recorders = LINE_AND_INSTRUCTION_RECORDERS, expected = [
+            ('line', 'get_events', 10),
+            ('line', 'func3', 1),
+            ('instruction', 'func3', 2),
+            ('line', 'func3', 2),
+            ('instruction', 'func3', 4),
+            ('instruction', 'func3', 6),
+            ('line', 'func3', 3),
+            ('instruction', 'func3', 8),
+            ('instruction', 'func3', 18),
+            ('instruction', 'func3', 20),
+            ('line', 'func3', 4),
+            ('instruction', 'func3', 22),
+            ('line', 'func3', 5),
+            ('instruction', 'func3', 24),
+            ('instruction', 'func3', 26),
+            ('instruction', 'func3', 28),
+            ('line', 'func3', 6),
+            ('instruction', 'func3', 30),
+            ('instruction', 'func3', 32),
+            ('instruction', 'func3', 34),
+            ('instruction', 'func3', 36),
+            ('line', 'get_events', 11)])
+
+    def test_with_restart(self):
+        def func1():
+            line1 = 1
+            line2 = 2
+            line3 = 3
+
+        self.check_events(func1, recorders = LINE_AND_INSTRUCTION_RECORDERS, expected = [
+            ('line', 'get_events', 10),
+            ('line', 'func1', 1),
+            ('instruction', 'func1', 2),
+            ('instruction', 'func1', 4),
+            ('line', 'func1', 2),
+            ('instruction', 'func1', 6),
+            ('instruction', 'func1', 8),
+            ('line', 'func1', 3),
+            ('instruction', 'func1', 10),
+            ('instruction', 'func1', 12),
+            ('instruction', 'func1', 14),
+            ('instruction', 'func1', 16),
+            ('line', 'get_events', 11)])
+
+        sys.monitoring.restart_events()
+
+        self.check_events(func1, recorders = LINE_AND_INSTRUCTION_RECORDERS, expected = [
+            ('line', 'get_events', 10),
+            ('line', 'func1', 1),
+            ('instruction', 'func1', 2),
+            ('instruction', 'func1', 4),
+            ('line', 'func1', 2),
+            ('instruction', 'func1', 6),
+            ('instruction', 'func1', 8),
+            ('line', 'func1', 3),
+            ('instruction', 'func1', 10),
+            ('instruction', 'func1', 12),
+            ('instruction', 'func1', 14),
+            ('instruction', 'func1', 16),
+            ('line', 'get_events', 11)])
+
+    def test_turn_off_only_instruction(self):
+        """
+        LINE events should be recorded after INSTRUCTION event is turned off
+        """
+        events = []
+        def line(*args):
+            events.append("line")
+        sys.monitoring.set_events(TEST_TOOL, 0)
+        sys.monitoring.register_callback(TEST_TOOL, E.LINE, line)
+        sys.monitoring.register_callback(TEST_TOOL, E.INSTRUCTION, lambda *args: None)
+        sys.monitoring.set_events(TEST_TOOL, E.LINE | E.INSTRUCTION)
+        sys.monitoring.set_events(TEST_TOOL, E.LINE)
+        events = []
+        a = 0
+        sys.monitoring.set_events(TEST_TOOL, 0)
+        self.assertGreater(len(events), 0)
+
+class TestInstallIncrementally(MonitoringTestBase, unittest.TestCase):
+
+    def check_events(self, func, must_include, tool=TEST_TOOL, recorders=(ExceptionRecorder,)):
+        try:
+            self.assertEqual(sys.monitoring._all_events(), {})
+            event_list = []
+            all_events = 0
+            for recorder in recorders:
+                all_events |= recorder.event_type
+                sys.monitoring.set_events(tool, all_events)
+            for recorder in recorders:
+                sys.monitoring.register_callback(tool, recorder.event_type, recorder(event_list))
+            func()
+            sys.monitoring.set_events(tool, 0)
+            for recorder in recorders:
+                sys.monitoring.register_callback(tool, recorder.event_type, None)
+            for line in must_include:
+                self.assertIn(line, event_list)
+        finally:
+            sys.monitoring.set_events(tool, 0)
+            for recorder in recorders:
+                sys.monitoring.register_callback(tool, recorder.event_type, None)
+
+    @staticmethod
+    def func1():
+        line1 = 1
+
+    MUST_INCLUDE_LI = [
+            ('instruction', 'func1', 2),
+            ('line', 'func1', 2),
+            ('instruction', 'func1', 4),
+            ('instruction', 'func1', 6)]
+
+    def test_line_then_instruction(self):
+        recorders = [ LineRecorder, InstructionRecorder ]
+        self.check_events(self.func1,
+                          recorders = recorders, must_include = self.MUST_INCLUDE_LI)
+
+    def test_instruction_then_line(self):
+        recorders = [ InstructionRecorder, LineRecorder ]
+        self.check_events(self.func1,
+                          recorders = recorders, must_include = self.MUST_INCLUDE_LI)
+
+    @staticmethod
+    def func2():
+        len(())
+
+    MUST_INCLUDE_CI = [
+            ('instruction', 'func2', 2),
+            ('call', 'func2', sys.monitoring.MISSING),
+            ('call', 'len', ()),
+            ('instruction', 'func2', 12),
+            ('instruction', 'func2', 14)]
+
+
+
+    def test_call_then_instruction(self):
+        recorders = [ CallRecorder, InstructionRecorder ]
+        self.check_events(self.func2,
+                          recorders = recorders, must_include = self.MUST_INCLUDE_CI)
+
+    def test_instruction_then_call(self):
+        recorders = [ InstructionRecorder, CallRecorder ]
+        self.check_events(self.func2,
+                          recorders = recorders, must_include = self.MUST_INCLUDE_CI)
+
+LOCAL_RECORDERS = CallRecorder, LineRecorder, CReturnRecorder, CRaiseRecorder
+
+class TestLocalEvents(MonitoringTestBase, unittest.TestCase):
+
+    def check_events(self, func, expected, tool=TEST_TOOL, recorders=()):
+        try:
+            self.assertEqual(sys.monitoring._all_events(), {})
+            event_list = []
+            all_events = 0
+            for recorder in recorders:
+                ev = recorder.event_type
+                sys.monitoring.register_callback(tool, ev, recorder(event_list))
+                all_events |= ev
+            sys.monitoring.set_local_events(tool, func.__code__, all_events)
+            func()
+            sys.monitoring.set_local_events(tool, func.__code__, 0)
+            for recorder in recorders:
+                sys.monitoring.register_callback(tool, recorder.event_type, None)
+            self.assertEqual(event_list, expected)
+        finally:
+            sys.monitoring.set_local_events(tool, func.__code__, 0)
+            for recorder in recorders:
+                sys.monitoring.register_callback(tool, recorder.event_type, None)
+
+
+    def test_simple(self):
+
+        def func1():
+            line1 = 1
+            line2 = 2
+            line3 = 3
+
+        self.check_events(func1, recorders = LOCAL_RECORDERS, expected = [
+            ('line', 'func1', 1),
+            ('line', 'func1', 2),
+            ('line', 'func1', 3)])
+
+    def test_c_call(self):
+
+        def func2():
+            line1 = 1
+            [].append(2)
+            line3 = 3
+
+        self.check_events(func2, recorders = LOCAL_RECORDERS, expected = [
+            ('line', 'func2', 1),
+            ('line', 'func2', 2),
+            ('call', 'append', [2]),
+            ('C return', 'append', [2]),
+            ('line', 'func2', 3)])
+
+    def test_try_except(self):
+
+        def func3():
+            try:
+                line = 2
+                raise KeyError
+            except:
+                line = 5
+            line = 6
+
+        self.check_events(func3, recorders = LOCAL_RECORDERS, expected = [
+            ('line', 'func3', 1),
+            ('line', 'func3', 2),
+            ('line', 'func3', 3),
+            ('line', 'func3', 4),
+            ('line', 'func3', 5),
+            ('line', 'func3', 6)])
+
+    def test_set_non_local_event(self):
+        with self.assertRaises(ValueError):
+            sys.monitoring.set_local_events(TEST_TOOL, just_call.__code__, E.RAISE)
+
+def line_from_offset(code, offset):
+    for start, end, line in code.co_lines():
+        if start <= offset < end:
+            if line is None:
+                return f"[offset={offset}]"
+            return line - code.co_firstlineno
+    return -1
+
+class JumpRecorder:
+
+    event_type = E.JUMP
+    name = "jump"
+
+    def __init__(self, events):
+        self.events = events
+
+    def __call__(self, code, from_, to):
+        from_line = line_from_offset(code, from_)
+        to_line = line_from_offset(code, to)
+        self.events.append((self.name, code.co_name, from_line, to_line))
+
+
+class BranchRecorder(JumpRecorder):
+
+    event_type = E.BRANCH
+    name = "branch"
+
+class BranchRightRecorder(JumpRecorder):
+
+    event_type = E.BRANCH_RIGHT
+    name = "branch right"
+
+class BranchLeftRecorder(JumpRecorder):
+
+    event_type = E.BRANCH_LEFT
+    name = "branch left"
+
+class JumpOffsetRecorder:
+
+    event_type = E.JUMP
+    name = "jump"
+
+    def __init__(self, events, offsets=False):
+        self.events = events
+
+    def __call__(self, code, from_, to):
+        self.events.append((self.name, code.co_name, from_, to))
+
+class BranchLeftOffsetRecorder(JumpOffsetRecorder):
+
+    event_type = E.BRANCH_LEFT
+    name = "branch left"
+
+class BranchRightOffsetRecorder(JumpOffsetRecorder):
+
+    event_type = E.BRANCH_RIGHT
+    name = "branch right"
+
+
+JUMP_AND_BRANCH_RECORDERS = JumpRecorder, BranchRecorder
+JUMP_BRANCH_AND_LINE_RECORDERS = JumpRecorder, BranchRecorder, LineRecorder
+FLOW_AND_LINE_RECORDERS = JumpRecorder, BranchRecorder, LineRecorder, ExceptionRecorder, ReturnRecorder
+
+BRANCHES_RECORDERS = BranchLeftRecorder, BranchRightRecorder
+BRANCH_OFFSET_RECORDERS = BranchLeftOffsetRecorder, BranchRightOffsetRecorder
+
+class TestBranchAndJumpEvents(CheckEvents):
+    maxDiff = None
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; - bytecode layout differs from CPython
+    def test_loop(self):
+
+        def func():
+            x = 1
+            for a in range(2):
+                if a:
+                    x = 4
+                else:
+                    x = 6
+            7
+
+        def whilefunc(n=0):
+            while n < 3:
+                n += 1 # line 2
+            3
+
+        self.check_events(func, recorders = JUMP_AND_BRANCH_RECORDERS, expected = [
+            ('branch', 'func', 2, 2),
+            ('branch', 'func', 3, 6),
+            ('jump', 'func', 6, 2),
+            ('branch', 'func', 2, 2),
+            ('branch', 'func', 3, 4),
+            ('jump', 'func', 4, 2),
+            ('branch', 'func', 2, 7)])
+
+        self.check_events(func, recorders = JUMP_BRANCH_AND_LINE_RECORDERS, expected = [
+            ('line', 'get_events', 10),
+            ('line', 'func', 1),
+            ('line', 'func', 2),
+            ('branch', 'func', 2, 2),
+            ('line', 'func', 3),
+            ('branch', 'func', 3, 6),
+            ('line', 'func', 6),
+            ('jump', 'func', 6, 2),
+            ('line', 'func', 2),
+            ('branch', 'func', 2, 2),
+            ('line', 'func', 3),
+            ('branch', 'func', 3, 4),
+            ('line', 'func', 4),
+            ('jump', 'func', 4, 2),
+            ('line', 'func', 2),
+            ('branch', 'func', 2, 7),
+            ('line', 'func', 7),
+            ('line', 'get_events', 11)])
+
+        self.check_events(func, recorders = BRANCHES_RECORDERS, expected = [
+            ('branch left', 'func', 2, 2),
+            ('branch right', 'func', 3, 6),
+            ('branch left', 'func', 2, 2),
+            ('branch left', 'func', 3, 4),
+            ('branch right', 'func', 2, 7)])
+
+        self.check_events(whilefunc, recorders = BRANCHES_RECORDERS, expected = [
+            ('branch left', 'whilefunc', 1, 2),
+            ('branch left', 'whilefunc', 1, 2),
+            ('branch left', 'whilefunc', 1, 2),
+            ('branch right', 'whilefunc', 1, 3)])
+
+        self.check_events(func, recorders = BRANCH_OFFSET_RECORDERS, expected = [
+            ('branch left', 'func', 28, 32),
+            ('branch right', 'func', 44, 58),
+            ('branch left', 'func', 28, 32),
+            ('branch left', 'func', 44, 50),
+            ('branch right', 'func', 28, 70)])
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; - bytecode layout differs from CPython
+    def test_except_star(self):
+
+        class Foo:
+            def meth(self):
+                pass
+
+        def func():
+            try:
+                try:
+                    raise KeyError
+                except* Exception as e:
+                    f = Foo(); f.meth()
+            except KeyError:
+                pass
+
+
+        self.check_events(func, recorders = JUMP_BRANCH_AND_LINE_RECORDERS, expected = [
+            ('line', 'get_events', 10),
+            ('line', 'func', 1),
+            ('line', 'func', 2),
+            ('line', 'func', 3),
+            ('line', 'func', 4),
+            ('branch', 'func', 4, 4),
+            ('line', 'func', 5),
+            ('line', 'meth', 1),
+            ('jump', 'func', 5, '[offset=120]'),
+            ('branch', 'func', '[offset=124]', '[offset=130]'),
+            ('line', 'get_events', 11)])
+
+        self.check_events(func, recorders = FLOW_AND_LINE_RECORDERS, expected = [
+            ('line', 'get_events', 10),
+            ('line', 'func', 1),
+            ('line', 'func', 2),
+            ('line', 'func', 3),
+            ('raise', KeyError),
+            ('line', 'func', 4),
+            ('branch', 'func', 4, 4),
+            ('line', 'func', 5),
+            ('line', 'meth', 1),
+            ('return', 'meth', None),
+            ('jump', 'func', 5, '[offset=120]'),
+            ('branch', 'func', '[offset=124]', '[offset=130]'),
+            ('return', 'func', None),
+            ('line', 'get_events', 11)])
+
+    def test_while_offset_consistency(self):
+
+        def foo(n=0):
+            while n<4:
+                pass
+                n += 1
+            return None
+
+        in_loop = ('branch left', 'foo', 10, 16)
+        exit_loop = ('branch right', 'foo', 10, 40)
+        self.check_events(foo, recorders = BRANCH_OFFSET_RECORDERS, expected = [
+            in_loop,
+            in_loop,
+            in_loop,
+            in_loop,
+            exit_loop])
+
+    def test_async_for(self):
+
+        def func():
+            async def gen():
+                yield 2
+                yield 3
+
+            async def foo():
+                async for y in gen():
+                    2
+                pass # line 3
+
+            try:
+                foo().send(None)
+            except StopIteration:
+                pass
+
+        self.check_events(func, recorders = BRANCHES_RECORDERS, expected = [
+            ('branch left', 'foo', 1, 1),
+            ('branch left', 'foo', 1, 1),
+            ('branch right', 'foo', 1, 3),
+            ('branch left', 'func', 12, 12)])
+
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; - bytecode layout differs from CPython
+    def test_match(self):
+
+        def func(v=1):
+            x = 0
+            for v in range(4):
+                match v:
+                    case 1:
+                        x += 1
+                    case 2:
+                        x += 2
+                    case _:
+                        x += 3
+            return x
+
+        self.check_events(func, recorders = BRANCHES_RECORDERS, expected = [
+            ('branch left', 'func', 2, 2),
+            ('branch right', 'func', 4, 6),
+            ('branch right', 'func', 6, 8),
+            ('branch left', 'func', 2, 2),
+            ('branch left', 'func', 4, 5),
+            ('branch left', 'func', 2, 2),
+            ('branch right', 'func', 4, 6),
+            ('branch left', 'func', 6, 7),
+            ('branch left', 'func', 2, 2),
+            ('branch right', 'func', 4, 6),
+            ('branch right', 'func', 6, 8),
+            ('branch right', 'func', 2, 10)])
+
+    def test_callback_set_frame_lineno(self):
+        def func(s: str) -> int:
+            if s.startswith("t"):
+                return 1
+            else:
+                return 0
+
+        def callback(code, from_, to):
+            # try set frame.f_lineno
+            frame = inspect.currentframe()
+            while frame and frame.f_code is not code:
+                frame = frame.f_back
+
+            self.assertIsNotNone(frame)
+            frame.f_lineno = frame.f_lineno + 1 # run next instruction
+
+        sys.monitoring.set_local_events(TEST_TOOL, func.__code__, E.BRANCH_LEFT)
+        sys.monitoring.register_callback(TEST_TOOL, E.BRANCH_LEFT, callback)
+
+        self.assertEqual(func("true"), 1)
+
+
+class TestBranchConsistency(MonitoringTestBase, unittest.TestCase):
+
+    def check_branches(self, run_func, test_func=None, tool=TEST_TOOL, recorders=BRANCH_OFFSET_RECORDERS):
+        if test_func is None:
+            test_func = run_func
+        try:
+            self.assertEqual(sys.monitoring._all_events(), {})
+            event_list = []
+            all_events = 0
+            for recorder in recorders:
+                ev = recorder.event_type
+                sys.monitoring.register_callback(tool, ev, recorder(event_list))
+                all_events |= ev
+            sys.monitoring.set_local_events(tool, test_func.__code__, all_events)
+            run_func()
+            sys.monitoring.set_local_events(tool, test_func.__code__, 0)
+            for recorder in recorders:
+                sys.monitoring.register_callback(tool, recorder.event_type, None)
+            lefts = set()
+            rights = set()
+            for (src, left, right) in test_func.__code__.co_branches():
+                lefts.add((src, left))
+                rights.add((src, right))
+            for event in event_list:
+                way, _, src, dest = event
+                if "left" in way:
+                    self.assertIn((src, dest), lefts)
+                else:
+                    self.assertIn("right", way)
+                    self.assertIn((src, dest), rights)
+        finally:
+            sys.monitoring.set_local_events(tool, test_func.__code__, 0)
+            for recorder in recorders:
+                sys.monitoring.register_callback(tool, recorder.event_type, None)
+
+    def test_simple(self):
+
+        def func():
+            x = 1
+            for a in range(2):
+                if a:
+                    x = 4
+                else:
+                    x = 6
+            7
+
+        self.check_branches(func)
+
+        def whilefunc(n=0):
+            while n < 3:
+                n += 1 # line 2
+            3
+
+        self.check_branches(whilefunc)
+
+    def test_except_star(self):
+
+        class Foo:
+            def meth(self):
+                pass
+
+        def func():
+            try:
+                try:
+                    raise KeyError
+                except* Exception as e:
+                    f = Foo(); f.meth()
+            except KeyError:
+                pass
+
+
+        self.check_branches(func)
+
+    def test4(self):
+
+        def foo(n=0):
+            while n<4:
+                pass
+                n += 1
+            return None
+
+        self.check_branches(foo)
+
+    def test_async_for(self):
+
+        async def gen():
+            yield 2
+            yield 3
+
+        async def foo():
+            async for y in gen():
+                2
+            pass # line 3
+
+        def func():
+            try:
+                foo().send(None)
+            except StopIteration:
+                pass
+
+        self.check_branches(func, foo)
+
+
+class TestLoadSuperAttr(CheckEvents):
+    RECORDERS = CallRecorder, LineRecorder, CRaiseRecorder, CReturnRecorder
+
+    def _exec(self, co):
+        d = {}
+        exec(co, d, d)
+        return d
+
+    def _exec_super(self, codestr, optimized=False):
+        # The compiler checks for statically visible shadowing of the name
+        # `super`, and declines to emit `LOAD_SUPER_ATTR` if shadowing is found.
+        # So inserting `super = super` prevents the compiler from emitting
+        # `LOAD_SUPER_ATTR`, and allows us to test that monitoring events for
+        # `LOAD_SUPER_ATTR` are equivalent to those we'd get from the
+        # un-optimized `LOAD_GLOBAL super; CALL; LOAD_ATTR` form.
+        assignment = "x = 1" if optimized else "super = super"
+        codestr = f"{assignment}\n{textwrap.dedent(codestr)}"
+        co = compile(codestr, "<string>", "exec")
+        # validate that we really do have a LOAD_SUPER_ATTR, only when optimized
+        self.assertEqual(self._has_load_super_attr(co), optimized)
+        return self._exec(co)
+
+    def _has_load_super_attr(self, co):
+        has = any(instr.opname == "LOAD_SUPER_ATTR" for instr in dis.get_instructions(co))
+        if not has:
+            has = any(
+                isinstance(c, types.CodeType) and self._has_load_super_attr(c)
+                for c in co.co_consts
+            )
+        return has
+
+    def _super_method_call(self, optimized=False):
+        codestr = """
+            class A:
+                def method(self, x):
+                    return x
+
+            class B(A):
+                def method(self, x):
+                    return super(
+                    ).method(
+                        x
+                    )
+
+            b = B()
+            def f():
+                return b.method(1)
+        """
+        d = self._exec_super(codestr, optimized)
+        expected = [
+            ('line', 'get_events', 10),
+            ('call', 'f', sys.monitoring.MISSING),
+            ('line', 'f', 1),
+            ('call', 'method', d["b"]),
+            ('line', 'method', 1),
+            ('call', 'super', sys.monitoring.MISSING),
+            ('C return', 'super', sys.monitoring.MISSING),
+            ('line', 'method', 2),
+            ('line', 'method', 3),
+            ('line', 'method', 2),
+            ('call', 'method', d["b"]),
+            ('line', 'method', 1),
+            ('line', 'method', 1),
+            ('line', 'get_events', 11),
+            ('call', 'set_events', 2),
+        ]
+        return d["f"], expected
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; line number differences in multi-line super() calls
+    def test_method_call(self):
+        nonopt_func, nonopt_expected = self._super_method_call(optimized=False)
+        opt_func, opt_expected = self._super_method_call(optimized=True)
+
+        self.check_events(nonopt_func, recorders=self.RECORDERS, expected=nonopt_expected)
+        self.check_events(opt_func, recorders=self.RECORDERS, expected=opt_expected)
+
+    def _super_method_call_error(self, optimized=False):
+        codestr = """
+            class A:
+                def method(self, x):
+                    return x
+
+            class B(A):
+                def method(self, x):
+                    return super(
+                        x,
+                        self,
+                    ).method(
+                        x
+                    )
+
+            b = B()
+            def f():
+                try:
+                    return b.method(1)
+                except TypeError:
+                    pass
+                else:
+                    assert False, "should have raised TypeError"
+        """
+        d = self._exec_super(codestr, optimized)
+        expected = [
+            ('line', 'get_events', 10),
+            ('call', 'f', sys.monitoring.MISSING),
+            ('line', 'f', 1),
+            ('line', 'f', 2),
+            ('call', 'method', d["b"]),
+            ('line', 'method', 1),
+            ('line', 'method', 2),
+            ('line', 'method', 3),
+            ('line', 'method', 1),
+            ('call', 'super', 1),
+            ('C raise', 'super', 1),
+            ('line', 'f', 3),
+            ('line', 'f', 4),
+            ('line', 'get_events', 11),
+            ('call', 'set_events', 2),
+        ]
+        return d["f"], expected
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; line number differences in multi-line super() calls
+    def test_method_call_error(self):
+        nonopt_func, nonopt_expected = self._super_method_call_error(optimized=False)
+        opt_func, opt_expected = self._super_method_call_error(optimized=True)
+
+        self.check_events(nonopt_func, recorders=self.RECORDERS, expected=nonopt_expected)
+        self.check_events(opt_func, recorders=self.RECORDERS, expected=opt_expected)
+
+    def _super_attr(self, optimized=False):
+        codestr = """
+            class A:
+                x = 1
+
+            class B(A):
+                def method(self):
+                    return super(
+                    ).x
+
+            b = B()
+            def f():
+                return b.method()
+        """
+        d = self._exec_super(codestr, optimized)
+        expected = [
+            ('line', 'get_events', 10),
+            ('call', 'f', sys.monitoring.MISSING),
+            ('line', 'f', 1),
+            ('call', 'method', d["b"]),
+            ('line', 'method', 1),
+            ('call', 'super', sys.monitoring.MISSING),
+            ('C return', 'super', sys.monitoring.MISSING),
+            ('line', 'method', 2),
+            ('line', 'method', 1),
+            ('line', 'get_events', 11),
+            ('call', 'set_events', 2)
+        ]
+        return d["f"], expected
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; line number differences in multi-line super() calls
+    def test_attr(self):
+        nonopt_func, nonopt_expected = self._super_attr(optimized=False)
+        opt_func, opt_expected = self._super_attr(optimized=True)
+
+        self.check_events(nonopt_func, recorders=self.RECORDERS, expected=nonopt_expected)
+        self.check_events(opt_func, recorders=self.RECORDERS, expected=opt_expected)
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; line number differences in multi-line super() calls
+    def test_vs_other_type_call(self):
+        code_template = textwrap.dedent("""
+            class C:
+                def method(self):
+                    return {cls}().__repr__{call}
+            c = C()
+            def f():
+                return c.method()
+        """)
+
+        def get_expected(name, call_method, ns):
+            repr_arg = 0 if name == "int" else sys.monitoring.MISSING
+            return [
+                ('line', 'get_events', 10),
+                ('call', 'f', sys.monitoring.MISSING),
+                ('line', 'f', 1),
+                ('call', 'method', ns["c"]),
+                ('line', 'method', 1),
+                ('call', name, sys.monitoring.MISSING),
+                ('C return', name, sys.monitoring.MISSING),
+                *(
+                    [
+                        ('call', '__repr__', repr_arg),
+                        ('C return', '__repr__', repr_arg),
+                    ] if call_method else []
+                ),
+                ('line', 'get_events', 11),
+                ('call', 'set_events', 2),
+            ]
+
+        for call_method in [True, False]:
+            with self.subTest(call_method=call_method):
+                call_str = "()" if call_method else ""
+                code_super = code_template.format(cls="super", call=call_str)
+                code_int = code_template.format(cls="int", call=call_str)
+                co_super = compile(code_super, '<string>', 'exec')
+                self.assertTrue(self._has_load_super_attr(co_super))
+                ns_super = self._exec(co_super)
+                ns_int = self._exec(code_int)
+
+                self.check_events(
+                    ns_super["f"],
+                    recorders=self.RECORDERS,
+                    expected=get_expected("super", call_method, ns_super)
+                )
+                self.check_events(
+                    ns_int["f"],
+                    recorders=self.RECORDERS,
+                    expected=get_expected("int", call_method, ns_int)
+                )
+
+
+class TestSetGetEvents(MonitoringTestBase, unittest.TestCase):
+
+    def test_global(self):
+        sys.monitoring.set_events(TEST_TOOL, E.PY_START)
+        self.assertEqual(sys.monitoring.get_events(TEST_TOOL), E.PY_START)
+        sys.monitoring.set_events(TEST_TOOL2, E.PY_START)
+        self.assertEqual(sys.monitoring.get_events(TEST_TOOL2), E.PY_START)
+        sys.monitoring.set_events(TEST_TOOL, 0)
+        self.assertEqual(sys.monitoring.get_events(TEST_TOOL), 0)
+        sys.monitoring.set_events(TEST_TOOL2,0)
+        self.assertEqual(sys.monitoring.get_events(TEST_TOOL2), 0)
+
+    def test_local(self):
+        code = f1.__code__
+        sys.monitoring.set_local_events(TEST_TOOL, code, E.PY_START)
+        self.assertEqual(sys.monitoring.get_local_events(TEST_TOOL, code), E.PY_START)
+        sys.monitoring.set_local_events(TEST_TOOL, code, 0)
+        sys.monitoring.set_local_events(TEST_TOOL, code, E.BRANCH)
+        self.assertEqual(sys.monitoring.get_local_events(TEST_TOOL, code), E.BRANCH_LEFT | E.BRANCH_RIGHT)
+        sys.monitoring.set_local_events(TEST_TOOL, code, 0)
+        sys.monitoring.set_local_events(TEST_TOOL2, code, E.PY_START)
+        self.assertEqual(sys.monitoring.get_local_events(TEST_TOOL2, code), E.PY_START)
+        sys.monitoring.set_local_events(TEST_TOOL, code, 0)
+        self.assertEqual(sys.monitoring.get_local_events(TEST_TOOL, code), 0)
+        sys.monitoring.set_local_events(TEST_TOOL2, code, 0)
+        self.assertEqual(sys.monitoring.get_local_events(TEST_TOOL2, code), 0)
+
+class TestUninitialized(unittest.TestCase, MonitoringTestBase):
+
+    @staticmethod
+    def f():
+        pass
+
+    def test_get_local_events_uninitialized(self):
+        self.assertEqual(sys.monitoring.get_local_events(TEST_TOOL, self.f.__code__), 0)
+
+class TestRegressions(MonitoringTestBase, unittest.TestCase):
+
+    def test_105162(self):
+        caught = None
+
+        def inner():
+            nonlocal caught
+            try:
+                yield
+            except Exception:
+                caught = "inner"
+                yield
+
+        def outer():
+            nonlocal caught
+            try:
+                yield from inner()
+            except Exception:
+                caught = "outer"
+                yield
+
+        def run():
+            gen = outer()
+            gen.send(None)
+            gen.throw(Exception)
+        run()
+        self.assertEqual(caught, "inner")
+        caught = None
+        try:
+            sys.monitoring.set_events(TEST_TOOL, E.PY_RESUME)
+            run()
+            self.assertEqual(caught, "inner")
+        finally:
+            sys.monitoring.set_events(TEST_TOOL, 0)
+
+    @unittest.skipUnless(_testinternalcapi, "requires _testinternalcapi")
+    def test_108390(self):
+
+        class Foo:
+            def __init__(self, set_event):
+                if set_event:
+                    sys.monitoring.set_events(TEST_TOOL, E.PY_RESUME)
+
+        def make_foo_optimized_then_set_event():
+            for i in range(_testinternalcapi.SPECIALIZATION_THRESHOLD + 1):
+                Foo(i == _testinternalcapi.SPECIALIZATION_THRESHOLD)
+
+        try:
+            make_foo_optimized_then_set_event()
+        finally:
+            sys.monitoring.set_events(TEST_TOOL, 0)
+
+    def test_gh108976(self):
+        sys.monitoring.use_tool_id(0, "test")
+        self.addCleanup(sys.monitoring.free_tool_id, 0)
+        sys.monitoring.set_events(0, 0)
+        sys.monitoring.register_callback(0, E.LINE, lambda *args: sys.monitoring.set_events(0, 0))
+        sys.monitoring.register_callback(0, E.INSTRUCTION, lambda *args: 0)
+        sys.monitoring.set_events(0, E.LINE | E.INSTRUCTION)
+        sys.monitoring.set_events(0, 0)
+
+    def test_call_function_ex(self):
+        def f(a=1, b=2):
+            return a + b
+        args = (1, 2)
+        empty_args = []
+
+        call_data = []
+        sys.monitoring.use_tool_id(0, "test")
+        self.addCleanup(sys.monitoring.free_tool_id, 0)
+        sys.monitoring.set_events(0, 0)
+        sys.monitoring.register_callback(0, E.CALL, lambda code, offset, callable, arg0: call_data.append((callable, arg0)))
+        sys.monitoring.set_events(0, E.CALL)
+        f(*args)
+        f(*empty_args)
+        sys.monitoring.set_events(0, 0)
+        self.assertEqual(call_data[0], (f, 1))
+        self.assertEqual(call_data[1], (f, sys.monitoring.MISSING))
+
+    def test_instruction_explicit_callback(self):
+        # gh-122247
+        # Calling the instruction event callback explicitly should not
+        # crash CPython
+        def callback(code, instruction_offset):
+            pass
+
+        sys.monitoring.use_tool_id(0, "test")
+        self.addCleanup(sys.monitoring.free_tool_id, 0)
+        sys.monitoring.register_callback(0, sys.monitoring.events.INSTRUCTION, callback)
+        sys.monitoring.set_events(0, sys.monitoring.events.INSTRUCTION)
+        callback(None, 0)  # call the *same* handler while it is registered
+        sys.monitoring.restart_events()
+        sys.monitoring.set_events(0, 0)
+
+
+class TestOptimizer(MonitoringTestBase, unittest.TestCase):
+
+    def test_for_loop(self):
+        def test_func(x):
+            i = 0
+            while i < x:
+                i += 1
+
+        code = test_func.__code__
+        sys.monitoring.set_local_events(TEST_TOOL, code, E.PY_START)
+        self.assertEqual(sys.monitoring.get_local_events(TEST_TOOL, code), E.PY_START)
+        test_func(1000)
+        sys.monitoring.set_local_events(TEST_TOOL, code, 0)
+        self.assertEqual(sys.monitoring.get_local_events(TEST_TOOL, code), 0)
+
+class TestTier2Optimizer(CheckEvents):
+
+    @unittest.skipUnless(_testinternalcapi, "requires _testinternalcapi")
+    def test_monitoring_already_opimized_loop(self):
+        def test_func(recorder):
+            set_events = sys.monitoring.set_events
+            line = E.LINE
+            i = 0
+            for i in range(_testinternalcapi.SPECIALIZATION_THRESHOLD + 51):
+                # Turn on events without branching once i reaches _testinternalcapi.SPECIALIZATION_THRESHOLD.
+                set_events(TEST_TOOL, line * int(i >= _testinternalcapi.SPECIALIZATION_THRESHOLD))
+                pass
+                pass
+                pass
+
+        self.assertEqual(sys.monitoring._all_events(), {})
+        events = []
+        recorder = LineRecorder(events)
+        sys.monitoring.register_callback(TEST_TOOL, E.LINE, recorder)
+        try:
+            test_func(recorder)
+        finally:
+            sys.monitoring.register_callback(TEST_TOOL, E.LINE, None)
+            sys.monitoring.set_events(TEST_TOOL, 0)
+        self.assertGreater(len(events), 250)
+
+class TestMonitoringAtShutdown(unittest.TestCase):
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; - requires subprocess support
+    def test_monitoring_live_at_shutdown(self):
+        # gh-115832: An object destructor running during the final GC of
+        # interpreter shutdown triggered an infinite loop in the
+        # instrumentation code.
+        script = test.support.findfile("_test_monitoring_shutdown.py")
+        script_helper.run_test_script(script)
+
+
+@unittest.skipUnless(_testcapi, "requires _testcapi")
+class TestCApiEventGeneration(MonitoringTestBase, unittest.TestCase):
+
+    class Scope:
+        def __init__(self, *args):
+            self.args = args
+
+        def __enter__(self):
+            _testcapi.monitoring_enter_scope(*self.args)
+
+        def __exit__(self, *args):
+            _testcapi.monitoring_exit_scope()
+
+    def setUp(self):
+        super(TestCApiEventGeneration, self).setUp()
+
+        capi = _testcapi
+
+        self.codelike = capi.CodeLike(2)
+
+        self.cases = [
+            # (Event, function, *args)
+            ( 1, E.PY_START, capi.fire_event_py_start),
+            ( 1, E.PY_RESUME, capi.fire_event_py_resume),
+            ( 1, E.PY_YIELD, capi.fire_event_py_yield, 10),
+            ( 1, E.PY_RETURN, capi.fire_event_py_return, 20),
+            ( 2, E.CALL, capi.fire_event_call, callable, 40),
+            ( 1, E.JUMP, capi.fire_event_jump, 60),
+            ( 1, E.BRANCH_RIGHT, capi.fire_event_branch_right, 70),
+            ( 1, E.BRANCH_LEFT, capi.fire_event_branch_left, 80),
+            ( 1, E.PY_THROW, capi.fire_event_py_throw, ValueError(1)),
+            ( 1, E.RAISE, capi.fire_event_raise, ValueError(2)),
+            ( 1, E.EXCEPTION_HANDLED, capi.fire_event_exception_handled, ValueError(5)),
+            ( 1, E.PY_UNWIND, capi.fire_event_py_unwind, ValueError(6)),
+            ( 1, E.STOP_ITERATION, capi.fire_event_stop_iteration, 7),
+            ( 1, E.STOP_ITERATION, capi.fire_event_stop_iteration, StopIteration(8)),
+        ]
+
+        self.EXPECT_RAISED_EXCEPTION = [E.PY_THROW, E.RAISE, E.EXCEPTION_HANDLED, E.PY_UNWIND]
+
+
+    def check_event_count(self, event, func, args, expected, callback_raises=None):
+        class Counter:
+            def __init__(self, callback_raises):
+                self.callback_raises = callback_raises
+                self.count = 0
+
+            def __call__(self, *args):
+                self.count += 1
+                if self.callback_raises:
+                    exc = self.callback_raises
+                    self.callback_raises = None
+                    raise exc
+
+        try:
+            counter = Counter(callback_raises)
+            sys.monitoring.register_callback(TEST_TOOL, event, counter)
+            if event == E.C_RETURN or event == E.C_RAISE:
+                sys.monitoring.set_events(TEST_TOOL, E.CALL)
+            else:
+                sys.monitoring.set_events(TEST_TOOL, event)
+            event_value = int(math.log2(event))
+            with self.Scope(self.codelike, event_value):
+                counter.count = 0
+                try:
+                    func(*args)
+                except ValueError as e:
+                    self.assertIsInstance(expected, ValueError)
+                    self.assertEqual(str(e), str(expected))
+                    return
+                else:
+                    self.assertEqual(counter.count, expected)
+
+            prev = sys.monitoring.register_callback(TEST_TOOL, event, None)
+            with self.Scope(self.codelike, event_value):
+                counter.count = 0
+                func(*args)
+                self.assertEqual(counter.count, 0)
+                self.assertEqual(prev, counter)
+        finally:
+            sys.monitoring.set_events(TEST_TOOL, 0)
+
+    def test_fire_event(self):
+        for expected, event, function, *args in self.cases:
+            offset = 0
+            self.codelike = _testcapi.CodeLike(1)
+            with self.subTest(function.__name__):
+                args_ = (self.codelike, offset) + tuple(args)
+                self.check_event_count(event, function, args_, expected)
+
+    def test_missing_exception(self):
+        for _, event, function, *args in self.cases:
+            if event not in self.EXPECT_RAISED_EXCEPTION:
+                continue
+            assert args and isinstance(args[-1], BaseException)
+            offset = 0
+            self.codelike = _testcapi.CodeLike(1)
+            with self.subTest(function.__name__):
+                args_ = (self.codelike, offset) + tuple(args[:-1]) + (None,)
+                evt = int(math.log2(event))
+                expected = ValueError(f"Firing event {evt} with no exception set")
+                self.check_event_count(event, function, args_, expected)
+
+    def test_fire_event_failing_callback(self):
+        for expected, event, function, *args in self.cases:
+            offset = 0
+            self.codelike = _testcapi.CodeLike(1)
+            with self.subTest(function.__name__):
+                args_ = (self.codelike, offset) + tuple(args)
+                exc = OSError(42)
+                with self.assertRaises(type(exc)):
+                    self.check_event_count(event, function, args_, expected,
+                                           callback_raises=exc)
+
+
+    CANNOT_DISABLE = { E.PY_THROW, E.RAISE, E.RERAISE,
+                       E.EXCEPTION_HANDLED, E.PY_UNWIND }
+
+    def check_disable(self, event, func, args, expected):
+        try:
+            counter = CounterWithDisable()
+            sys.monitoring.register_callback(TEST_TOOL, event, counter)
+            if event == E.C_RETURN or event == E.C_RAISE:
+                sys.monitoring.set_events(TEST_TOOL, E.CALL)
+            else:
+                sys.monitoring.set_events(TEST_TOOL, event)
+            event_value = int(math.log2(event))
+            with self.Scope(self.codelike, event_value):
+                counter.count = 0
+                func(*args)
+                self.assertEqual(counter.count, expected)
+                counter.disable = True
+                if event in self.CANNOT_DISABLE:
+                    # use try-except rather then assertRaises to avoid
+                    # events from framework code
+                    try:
+                        counter.count = 0
+                        func(*args)
+                        self.assertEqual(counter.count, expected)
+                    except ValueError:
+                        pass
+                    else:
+                        self.Error("Expected a ValueError")
+                else:
+                    counter.count = 0
+                    func(*args)
+                    self.assertEqual(counter.count, expected)
+                    counter.count = 0
+                    func(*args)
+                    self.assertEqual(counter.count, expected - 1)
+        finally:
+            sys.monitoring.set_events(TEST_TOOL, 0)
+
+    def test_disable_event(self):
+        for expected, event, function, *args in self.cases:
+            offset = 0
+            self.codelike = _testcapi.CodeLike(2)
+            with self.subTest(function.__name__):
+                args_ = (self.codelike, 0) + tuple(args)
+                self.check_disable(event, function, args_, expected)
+
+    def test_enter_scope_two_events(self):
+        try:
+            yield_counter = CounterWithDisable()
+            unwind_counter = CounterWithDisable()
+            sys.monitoring.register_callback(TEST_TOOL, E.PY_YIELD, yield_counter)
+            sys.monitoring.register_callback(TEST_TOOL, E.PY_UNWIND, unwind_counter)
+            sys.monitoring.set_events(TEST_TOOL, E.PY_YIELD | E.PY_UNWIND)
+
+            yield_value = int(math.log2(E.PY_YIELD))
+            unwind_value = int(math.log2(E.PY_UNWIND))
+            cl = _testcapi.CodeLike(2)
+            common_args = (cl, 0)
+            with self.Scope(cl, yield_value, unwind_value):
+                yield_counter.count = 0
+                unwind_counter.count = 0
+
+                _testcapi.fire_event_py_unwind(*common_args, ValueError(42))
+                assert(yield_counter.count == 0)
+                assert(unwind_counter.count == 1)
+
+                _testcapi.fire_event_py_yield(*common_args, ValueError(42))
+                assert(yield_counter.count == 1)
+                assert(unwind_counter.count == 1)
+
+                yield_counter.disable = True
+                _testcapi.fire_event_py_yield(*common_args, ValueError(42))
+                assert(yield_counter.count == 2)
+                assert(unwind_counter.count == 1)
+
+                _testcapi.fire_event_py_yield(*common_args, ValueError(42))
+                assert(yield_counter.count == 2)
+                assert(unwind_counter.count == 1)
+
+        finally:
+            sys.monitoring.set_events(TEST_TOOL, 0)
diff --git a/Lib/test/test_multiprocessing_fork/test_manager.py b/Lib/test/test_multiprocessing_fork/test_manager.py
index f8d7eddd652..9efbb83bbb7 100644
--- a/Lib/test/test_multiprocessing_fork/test_manager.py
+++ b/Lib/test/test_multiprocessing_fork/test_manager.py
@@ -3,22 +3,5 @@
 
 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()
diff --git a/Lib/test/test_multiprocessing_fork/test_misc.py b/Lib/test/test_multiprocessing_fork/test_misc.py
index bcf0858258e..891a494020c 100644
--- a/Lib/test/test_multiprocessing_fork/test_misc.py
+++ b/Lib/test/test_multiprocessing_fork/test_misc.py
@@ -3,24 +3,5 @@
 
 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()
diff --git a/Lib/test/test_multiprocessing_fork/test_processes.py b/Lib/test/test_multiprocessing_fork/test_processes.py
index 8c7e6b56896..987d5d7e3c6 100644
--- a/Lib/test/test_multiprocessing_fork/test_processes.py
+++ b/Lib/test/test_multiprocessing_fork/test_processes.py
@@ -3,57 +3,6 @@
 
 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 1065ebf7fe4..1670e34cb17 100644
--- a/Lib/test/test_multiprocessing_fork/test_threads.py
+++ b/Lib/test/test_multiprocessing_fork/test_threads.py
@@ -3,14 +3,5 @@
 
 install_tests_in_module_dict(globals(), 'fork', only_type="threads")
 
-import os, sys  # TODO: RUSTPYTHON
-class WithThreadsTestPool(WithThreadsTestPool):  # 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
-    @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 a4a2aa21a3c..6f6b8f56837 100644
--- a/Lib/test/test_multiprocessing_forkserver/test_processes.py
+++ b/Lib/test/test_multiprocessing_forkserver/test_processes.py
@@ -11,33 +11,11 @@ def test_notify(self): super().test_notify()
     def test_notify_n(self): super().test_notify_n()
 
 class WithProcessesTestLock(WithProcessesTestLock):  # TODO: RUSTPYTHON
-    @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
-    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
-        '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
-        '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
-        '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 1ca30b0bb83..719c752aa05 100644
--- a/Lib/test/test_multiprocessing_forkserver/test_threads.py
+++ b/Lib/test/test_multiprocessing_forkserver/test_threads.py
@@ -3,13 +3,5 @@
 
 install_tests_in_module_dict(globals(), 'forkserver', only_type="threads")
 
-import os  # TODO: RUSTPYTHON
-class WithThreadsTestPool(WithThreadsTestPool):  # TODO: RUSTPYTHON
-    @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
-    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 f3468a86a06..21fd6abd655 100644
--- a/Lib/test/test_multiprocessing_spawn/test_processes.py
+++ b/Lib/test/test_multiprocessing_spawn/test_processes.py
@@ -9,33 +9,11 @@ class WithProcessesTestCondition(WithProcessesTestCondition):  # TODO: RUSTPYTHO
     def test_notify(self): super().test_notify()
 
 class WithProcessesTestLock(WithProcessesTestLock):  # 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
-    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 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 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 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
-
 if __name__ == '__main__':
     unittest.main()
diff --git a/Lib/test/test_named_expressions.py b/Lib/test/test_named_expressions.py
index 68e4a7704f4..fea86fe4308 100644
--- a/Lib/test/test_named_expressions.py
+++ b/Lib/test/test_named_expressions.py
@@ -44,32 +44,24 @@ def test_named_expression_invalid_06(self):
         with self.assertRaisesRegex(SyntaxError, "cannot use assignment expressions with tuple"):
             exec(code, {}, {})
 
-    # TODO: RUSTPYTHON: wrong error message
-    @unittest.expectedFailure
     def test_named_expression_invalid_07(self):
         code = """def spam(a = b := 42): pass"""
 
         with self.assertRaisesRegex(SyntaxError, "invalid syntax"):
             exec(code, {}, {})
 
-    # TODO: RUSTPYTHON: wrong error message
-    @unittest.expectedFailure
     def test_named_expression_invalid_08(self):
         code = """def spam(a: b := 42 = 5): pass"""
 
         with self.assertRaisesRegex(SyntaxError, "invalid syntax"):
             exec(code, {}, {})
 
-    # TODO: RUSTPYTHON: wrong error message
-    @unittest.expectedFailure
     def test_named_expression_invalid_09(self):
         code = """spam(a=b := 'c')"""
 
         with self.assertRaisesRegex(SyntaxError, "invalid syntax"):
             exec(code, {}, {})
 
-    # TODO: RUSTPYTHON: wrong error message
-    @unittest.expectedFailure
     def test_named_expression_invalid_10(self):
         code = """spam(x = y := f(x))"""
 
@@ -103,8 +95,6 @@ def test_named_expression_invalid_13(self):
             "positional argument follows keyword argument"):
             exec(code, {}, {})
 
-    # TODO: RUSTPYTHON: wrong error message
-    @unittest.expectedFailure
     def test_named_expression_invalid_14(self):
         code = """(x := lambda: y := 1)"""
 
@@ -120,8 +110,6 @@ def test_named_expression_invalid_15(self):
             "cannot use assignment expressions with lambda"):
             exec(code, {}, {})
 
-    # TODO: RUSTPYTHON: wrong error message
-    @unittest.expectedFailure
     def test_named_expression_invalid_16(self):
         code = "[i + 1 for i in i := [1,2]]"
 
diff --git a/Lib/test/test_opcache.py b/Lib/test/test_opcache.py
index aeb4de6caa5..2e50c1c62b3 100644
--- a/Lib/test/test_opcache.py
+++ b/Lib/test/test_opcache.py
@@ -4,7 +4,9 @@
 import threading
 import types
 import unittest
-from test.support import threading_helper, check_impl_detail, requires_specialization
+from test.support import (threading_helper, check_impl_detail,
+                          requires_specialization, requires_specialization_ft,
+                          cpython_only, requires_jit_disabled, reset_code)
 from test.support.import_helper import import_module
 
 # Skip this module on other interpreters, it is cpython specific:
@@ -14,18 +16,14 @@
 _testinternalcapi = import_module("_testinternalcapi")
 
 
-def disabling_optimizer(func):
-    def wrapper(*args, **kwargs):
-        if not hasattr(_testinternalcapi, "get_optimizer"):
-            return func(*args, **kwargs)
-        old_opt = _testinternalcapi.get_optimizer()
-        _testinternalcapi.set_optimizer(None)
-        try:
-            return func(*args, **kwargs)
-        finally:
-            _testinternalcapi.set_optimizer(old_opt)
-
-    return wrapper
+def have_dict_key_versions():
+    # max version value that can be stored in the load global cache. This is
+    # determined by the type of module_keys_version and builtin_keys_version
+    # in _PyLoadGlobalCache, uint16_t.
+    max_version = 1<<16
+    # use a wide safety margin (use only half of what's available)
+    limit = max_version // 2
+    return _testinternalcapi.get_next_dict_keys_version() < limit
 
 
 class TestBase(unittest.TestCase):
@@ -34,6 +32,11 @@ def assert_specialized(self, f, opname):
         opnames = {instruction.opname for instruction in instructions}
         self.assertIn(opname, opnames)
 
+    def assert_no_opcode(self, f, opname):
+        instructions = dis.get_instructions(f, adaptive=True)
+        opnames = {instruction.opname for instruction in instructions}
+        self.assertNotIn(opname, opnames)
+
 
 class TestLoadSuperAttrCache(unittest.TestCase):
     def test_descriptor_not_double_executed_on_spec_fail(self):
@@ -52,7 +55,8 @@ def f(self):
 
         d = D()
 
-        self.assertEqual(d.f(), 1)  # warmup
+        for _ in range(_testinternalcapi.SPECIALIZATION_THRESHOLD - 1):
+            self.assertEqual(d.f(), 1)  # warmup
         calls.clear()
         self.assertEqual(d.f(), 1)  # try to specialize
         self.assertEqual(calls, [(d, D)])
@@ -72,7 +76,7 @@ def f(o):
             return o.x
 
         o = C()
-        for i in range(1025):
+        for _ in range(_testinternalcapi.SPECIALIZATION_THRESHOLD):
             assert f(o) == 1
 
         Descriptor.__get__ = lambda self, instance, value: 2
@@ -99,13 +103,13 @@ def __set__(self, instance, value):
         def f():
             return Class.attribute
 
-        for _ in range(1025):
+        for _ in range(_testinternalcapi.SPECIALIZATION_THRESHOLD):
             self.assertTrue(f())
 
         Descriptor.__get__ = __get__
         Descriptor.__set__ = __set__
 
-        for _ in range(1025):
+        for _ in range(_testinternalcapi.SPECIALIZATION_COOLDOWN):
             self.assertFalse(f())
 
     def test_metaclass_descriptor_shadows_class_attribute(self):
@@ -120,7 +124,7 @@ class Class(metaclass=Metaclass):
         def f():
             return Class.attribute
 
-        for _ in range(1025):
+        for _ in range(_testinternalcapi.SPECIALIZATION_THRESHOLD):
             self.assertTrue(f())
 
     def test_metaclass_set_descriptor_after_optimization(self):
@@ -137,12 +141,12 @@ def attribute(self):
         def f():
             return Class.attribute
 
-        for _ in range(1025):
+        for _ in range(_testinternalcapi.SPECIALIZATION_THRESHOLD):
             self.assertTrue(f())
 
         Metaclass.attribute = attribute
 
-        for _ in range(1025):
+        for _ in range(_testinternalcapi.SPECIALIZATION_COOLDOWN):
             self.assertFalse(f())
 
     def test_metaclass_del_descriptor_after_optimization(self):
@@ -157,12 +161,12 @@ class Class(metaclass=Metaclass):
         def f():
             return Class.attribute
 
-        for _ in range(1025):
+        for _ in range(_testinternalcapi.SPECIALIZATION_THRESHOLD):
             self.assertTrue(f())
 
         del Metaclass.attribute
 
-        for _ in range(1025):
+        for _ in range(_testinternalcapi.SPECIALIZATION_COOLDOWN):
             self.assertFalse(f())
 
     def test_type_descriptor_shadows_attribute_method(self):
@@ -172,7 +176,7 @@ class Class:
         def f():
             return Class.mro
 
-        for _ in range(1025):
+        for _ in range(_testinternalcapi.SPECIALIZATION_THRESHOLD):
             self.assertIsNone(f())
 
     def test_type_descriptor_shadows_attribute_member(self):
@@ -182,7 +186,7 @@ class Class:
         def f():
             return Class.__base__
 
-        for _ in range(1025):
+        for _ in range(_testinternalcapi.SPECIALIZATION_THRESHOLD):
             self.assertIs(f(), object)
 
     def test_type_descriptor_shadows_attribute_getset(self):
@@ -192,7 +196,7 @@ class Class:
         def f():
             return Class.__name__
 
-        for _ in range(1025):
+        for _ in range(_testinternalcapi.SPECIALIZATION_THRESHOLD):
             self.assertEqual(f(), "Class")
 
     def test_metaclass_getattribute(self):
@@ -206,7 +210,7 @@ class Class(metaclass=Metaclass):
         def f():
             return Class.attribute
 
-        for _ in range(1025):
+        for _ in range(_testinternalcapi.SPECIALIZATION_THRESHOLD):
             self.assertTrue(f())
 
     def test_metaclass_swap(self):
@@ -226,12 +230,12 @@ class Class(metaclass=OldMetaclass):
         def f():
             return Class.attribute
 
-        for _ in range(1025):
+        for _ in range(_testinternalcapi.SPECIALIZATION_THRESHOLD):
             self.assertTrue(f())
 
         Class.__class__ = NewMetaclass
 
-        for _ in range(1025):
+        for _ in range(_testinternalcapi.SPECIALIZATION_COOLDOWN):
             self.assertFalse(f())
 
     def test_load_shadowing_slot_should_raise_type_error(self):
@@ -248,7 +252,7 @@ def f(o):
         o = Sneaky()
         o.shadowed = 42
 
-        for _ in range(1025):
+        for _ in range(_testinternalcapi.SPECIALIZATION_THRESHOLD):
             with self.assertRaises(TypeError):
                 f(o)
 
@@ -265,7 +269,7 @@ def f(o):
 
         o = Sneaky()
 
-        for _ in range(1025):
+        for _ in range(_testinternalcapi.SPECIALIZATION_THRESHOLD):
             with self.assertRaises(TypeError):
                 f(o)
 
@@ -281,7 +285,7 @@ def f(o):
 
         o = Sneaky()
 
-        for _ in range(1025):
+        for _ in range(_testinternalcapi.SPECIALIZATION_THRESHOLD):
             with self.assertRaises(TypeError):
                 f(o)
 
@@ -297,7 +301,7 @@ def f(o):
 
         o = Sneaky()
 
-        for _ in range(1025):
+        for _ in range(_testinternalcapi.SPECIALIZATION_THRESHOLD):
             with self.assertRaises(TypeError):
                 f(o)
 
@@ -325,13 +329,13 @@ def attribute():
         def f():
             return instance.attribute()
 
-        for _ in range(1025):
+        for _ in range(_testinternalcapi.SPECIALIZATION_THRESHOLD):
             self.assertTrue(f())
 
         Descriptor.__get__ = __get__
         Descriptor.__set__ = __set__
 
-        for _ in range(1025):
+        for _ in range(_testinternalcapi.SPECIALIZATION_COOLDOWN):
             self.assertFalse(f())
 
     def test_metaclass_descriptor_added_after_optimization(self):
@@ -354,13 +358,13 @@ def __set__(self, instance, value):
         def f():
             return Class.attribute()
 
-        for _ in range(1025):
+        for _ in range(_testinternalcapi.SPECIALIZATION_THRESHOLD):
             self.assertTrue(f())
 
         Descriptor.__get__ = __get__
         Descriptor.__set__ = __set__
 
-        for _ in range(1025):
+        for _ in range(_testinternalcapi.SPECIALIZATION_COOLDOWN):
             self.assertFalse(f())
 
     def test_metaclass_descriptor_shadows_class_attribute(self):
@@ -376,7 +380,7 @@ def attribute():
         def f():
             return Class.attribute()
 
-        for _ in range(1025):
+        for _ in range(_testinternalcapi.SPECIALIZATION_THRESHOLD):
             self.assertTrue(f())
 
     def test_metaclass_set_descriptor_after_optimization(self):
@@ -394,12 +398,12 @@ def attribute(self):
         def f():
             return Class.attribute()
 
-        for _ in range(1025):
+        for _ in range(_testinternalcapi.SPECIALIZATION_THRESHOLD):
             self.assertTrue(f())
 
         Metaclass.attribute = attribute
 
-        for _ in range(1025):
+        for _ in range(_testinternalcapi.SPECIALIZATION_COOLDOWN):
             self.assertFalse(f())
 
     def test_metaclass_del_descriptor_after_optimization(self):
@@ -415,12 +419,12 @@ def attribute():
         def f():
             return Class.attribute()
 
-        for _ in range(1025):
+        for _ in range(_testinternalcapi.SPECIALIZATION_THRESHOLD):
             self.assertTrue(f())
 
         del Metaclass.attribute
 
-        for _ in range(1025):
+        for _ in range(_testinternalcapi.SPECIALIZATION_COOLDOWN):
             self.assertFalse(f())
 
     def test_type_descriptor_shadows_attribute_method(self):
@@ -431,7 +435,7 @@ def mro():
         def f():
             return Class.mro()
 
-        for _ in range(1025):
+        for _ in range(_testinternalcapi.SPECIALIZATION_THRESHOLD):
             self.assertEqual(f(), ["Spam", "eggs"])
 
     def test_type_descriptor_shadows_attribute_member(self):
@@ -442,7 +446,7 @@ def __base__():
         def f():
             return Class.__base__()
 
-        for _ in range(1025):
+        for _ in range(_testinternalcapi.SPECIALIZATION_THRESHOLD):
             self.assertNotEqual(f(), "Spam")
 
     def test_metaclass_getattribute(self):
@@ -457,7 +461,7 @@ def attribute():
         def f():
             return Class.attribute()
 
-        for _ in range(1025):
+        for _ in range(_testinternalcapi.SPECIALIZATION_THRESHOLD):
             self.assertTrue(f())
 
     def test_metaclass_swap(self):
@@ -477,22 +481,27 @@ class Class(metaclass=OldMetaclass):
         def f():
             return Class.attribute()
 
-        for _ in range(1025):
+        for _ in range(_testinternalcapi.SPECIALIZATION_THRESHOLD):
             self.assertTrue(f())
 
         Class.__class__ = NewMetaclass
 
-        for _ in range(1025):
+        for _ in range(_testinternalcapi.SPECIALIZATION_COOLDOWN):
             self.assertFalse(f())
 
 
+class InitTakesArg:
+    def __init__(self, arg):
+        self.arg = arg
+
+
 class TestCallCache(TestBase):
     def test_too_many_defaults_0(self):
         def f():
             pass
 
         f.__defaults__ = (None,)
-        for _ in range(1025):
+        for _ in range(_testinternalcapi.SPECIALIZATION_THRESHOLD):
             f()
 
     def test_too_many_defaults_1(self):
@@ -500,7 +509,7 @@ def f(x):
             pass
 
         f.__defaults__ = (None, None)
-        for _ in range(1025):
+        for _ in range(_testinternalcapi.SPECIALIZATION_THRESHOLD):
             f(None)
             f()
 
@@ -509,13 +518,13 @@ def f(x, y):
             pass
 
         f.__defaults__ = (None, None, None)
-        for _ in range(1025):
+        for _ in range(_testinternalcapi.SPECIALIZATION_THRESHOLD):
             f(None, None)
             f(None)
             f()
 
-    @disabling_optimizer
-    @requires_specialization
+    @requires_jit_disabled
+    @requires_specialization_ft
     def test_assign_init_code(self):
         class MyClass:
             def __init__(self):
@@ -525,30 +534,67 @@ def instantiate():
             return MyClass()
 
         # Trigger specialization
-        for _ in range(1025):
+        for _ in range(_testinternalcapi.SPECIALIZATION_THRESHOLD):
             instantiate()
         self.assert_specialized(instantiate, "CALL_ALLOC_AND_ENTER_INIT")
 
         def count_args(self, *args):
             self.num_args = len(args)
 
-        # Set MyClass.__init__.__code__ to a code object that is incompatible
-        # (uses varargs) with the current specialization
+        # Set MyClass.__init__.__code__ to a code object that uses different
+        # args
         MyClass.__init__.__code__ = count_args.__code__
         instantiate()
 
+    @requires_jit_disabled
+    @requires_specialization_ft
+    def test_push_init_frame_fails(self):
+        def instantiate():
+            return InitTakesArg()
+
+        for _ in range(_testinternalcapi.SPECIALIZATION_THRESHOLD):
+            with self.assertRaises(TypeError):
+                instantiate()
+        self.assert_specialized(instantiate, "CALL_ALLOC_AND_ENTER_INIT")
+
+        with self.assertRaises(TypeError):
+            instantiate()
+
+    def test_recursion_check_for_general_calls(self):
+        def test(default=None):
+            return test()
+
+        with self.assertRaises(RecursionError):
+            test()
+
+    def test_dont_specialize_custom_vectorcall(self):
+        def f():
+            raise Exception("no way")
+
+        _testinternalcapi.set_vectorcall_nop(f)
+        for _ in range(_testinternalcapi.SPECIALIZATION_THRESHOLD):
+            f()
+
+
+def make_deferred_ref_count_obj():
+    """Create an object that uses deferred reference counting.
+
+    Only objects that use deferred refence counting may be stored in inline
+    caches in free-threaded builds. This constructs a new class named Foo,
+    which uses deferred reference counting.
+    """
+    return type("Foo", (object,), {})
+
 
 @threading_helper.requires_working_threading()
-@requires_specialization
 class TestRacesDoNotCrash(TestBase):
     # Careful with these. Bigger numbers have a higher chance of catching bugs,
     # but you can also burn through a *ton* of type/dict/function versions:
     ITEMS = 1000
     LOOPS = 4
-    WARMUPS = 2
     WRITERS = 2
 
-    @disabling_optimizer
+    @requires_jit_disabled
     def assert_races_do_not_crash(
         self, opname, get_items, read, write, *, check_items=False
     ):
@@ -558,11 +604,11 @@ def assert_races_do_not_crash(
             # Reset:
             if check_items:
                 for item in items:
-                    item.__code__ = item.__code__.replace()
+                    reset_code(item)
             else:
-                read.__code__ = read.__code__.replace()
+                reset_code(read)
             # Specialize:
-            for _ in range(self.WARMUPS):
+            for _ in range(_testinternalcapi.SPECIALIZATION_THRESHOLD):
                 read(items)
             if check_items:
                 for item in items:
@@ -581,6 +627,7 @@ def assert_races_do_not_crash(
             for writer in writers:
                 writer.join()
 
+    @requires_specialization_ft
     def test_binary_subscr_getitem(self):
         def get_items():
             class C:
@@ -607,9 +654,10 @@ def write(items):
                     pass
                 type(item).__getitem__ = lambda self, item: None
 
-        opname = "BINARY_SUBSCR_GETITEM"
+        opname = "BINARY_OP_SUBSCR_GETITEM"
         self.assert_races_do_not_crash(opname, get_items, read, write)
 
+    @requires_specialization_ft
     def test_binary_subscr_list_int(self):
         def get_items():
             items = []
@@ -630,9 +678,10 @@ def write(items):
                 item.clear()
                 item.append(None)
 
-        opname = "BINARY_SUBSCR_LIST_INT"
+        opname = "BINARY_OP_SUBSCR_LIST_INT"
         self.assert_races_do_not_crash(opname, get_items, read, write)
 
+    @requires_specialization
     def test_for_iter_gen(self):
         def get_items():
             def g():
@@ -664,6 +713,7 @@ def write(items):
         opname = "FOR_ITER_GEN"
         self.assert_races_do_not_crash(opname, get_items, read, write)
 
+    @requires_specialization
     def test_for_iter_list(self):
         def get_items():
             items = []
@@ -685,10 +735,11 @@ def write(items):
         opname = "FOR_ITER_LIST"
         self.assert_races_do_not_crash(opname, get_items, read, write)
 
+    @requires_specialization_ft
     def test_load_attr_class(self):
         def get_items():
             class C:
-                a = object()
+                a = make_deferred_ref_count_obj()
 
             items = []
             for _ in range(self.ITEMS):
@@ -709,11 +760,45 @@ def write(items):
                     del item.a
                 except AttributeError:
                     pass
-                item.a = object()
+                item.a = make_deferred_ref_count_obj()
 
         opname = "LOAD_ATTR_CLASS"
         self.assert_races_do_not_crash(opname, get_items, read, write)
 
+    @requires_specialization_ft
+    def test_load_attr_class_with_metaclass_check(self):
+        def get_items():
+            class Meta(type):
+                pass
+
+            class C(metaclass=Meta):
+                a = make_deferred_ref_count_obj()
+
+            items = []
+            for _ in range(self.ITEMS):
+                item = C
+                items.append(item)
+            return items
+
+        def read(items):
+            for item in items:
+                try:
+                    item.a
+                except AttributeError:
+                    pass
+
+        def write(items):
+            for item in items:
+                try:
+                    del item.a
+                except AttributeError:
+                    pass
+                item.a = make_deferred_ref_count_obj()
+
+        opname = "LOAD_ATTR_CLASS_WITH_METACLASS_CHECK"
+        self.assert_races_do_not_crash(opname, get_items, read, write)
+
+    @requires_specialization_ft
     def test_load_attr_getattribute_overridden(self):
         def get_items():
             class C:
@@ -743,6 +828,7 @@ def write(items):
         opname = "LOAD_ATTR_GETATTRIBUTE_OVERRIDDEN"
         self.assert_races_do_not_crash(opname, get_items, read, write)
 
+    @requires_specialization_ft
     def test_load_attr_instance_value(self):
         def get_items():
             class C:
@@ -766,6 +852,7 @@ def write(items):
         opname = "LOAD_ATTR_INSTANCE_VALUE"
         self.assert_races_do_not_crash(opname, get_items, read, write)
 
+    @requires_specialization_ft
     def test_load_attr_method_lazy_dict(self):
         def get_items():
             class C(Exception):
@@ -795,6 +882,7 @@ def write(items):
         opname = "LOAD_ATTR_METHOD_LAZY_DICT"
         self.assert_races_do_not_crash(opname, get_items, read, write)
 
+    @requires_specialization_ft
     def test_load_attr_method_no_dict(self):
         def get_items():
             class C:
@@ -825,6 +913,7 @@ def write(items):
         opname = "LOAD_ATTR_METHOD_NO_DICT"
         self.assert_races_do_not_crash(opname, get_items, read, write)
 
+    @requires_specialization_ft
     def test_load_attr_method_with_values(self):
         def get_items():
             class C:
@@ -854,6 +943,7 @@ def write(items):
         opname = "LOAD_ATTR_METHOD_WITH_VALUES"
         self.assert_races_do_not_crash(opname, get_items, read, write)
 
+    @requires_specialization_ft
     def test_load_attr_module(self):
         def get_items():
             items = []
@@ -878,6 +968,7 @@ def write(items):
         opname = "LOAD_ATTR_MODULE"
         self.assert_races_do_not_crash(opname, get_items, read, write)
 
+    @requires_specialization_ft
     def test_load_attr_property(self):
         def get_items():
             class C:
@@ -907,6 +998,34 @@ def write(items):
         opname = "LOAD_ATTR_PROPERTY"
         self.assert_races_do_not_crash(opname, get_items, read, write)
 
+    @requires_specialization_ft
+    def test_load_attr_slot(self):
+        def get_items():
+            class C:
+                __slots__ = ["a", "b"]
+
+            items = []
+            for i in range(self.ITEMS):
+                item = C()
+                item.a = i
+                item.b = i + self.ITEMS
+                items.append(item)
+            return items
+
+        def read(items):
+            for item in items:
+                item.a
+                item.b
+
+        def write(items):
+            for item in items:
+                item.a = 100
+                item.b = 200
+
+        opname = "LOAD_ATTR_SLOT"
+        self.assert_races_do_not_crash(opname, get_items, read, write)
+
+    @requires_specialization_ft
     def test_load_attr_with_hint(self):
         def get_items():
             class C:
@@ -917,7 +1036,7 @@ class C:
                 item = C()
                 item.a = None
                 # Resize into a combined unicode dict:
-                for i in range(29):
+                for i in range(_testinternalcapi.SHARED_KEYS_MAX_SIZE - 1):
                     setattr(item, f"_{i}", None)
                 items.append(item)
             return items
@@ -933,7 +1052,10 @@ def write(items):
         opname = "LOAD_ATTR_WITH_HINT"
         self.assert_races_do_not_crash(opname, get_items, read, write)
 
+    @requires_specialization_ft
     def test_load_global_module(self):
+        if not have_dict_key_versions():
+            raise unittest.SkipTest("Low on dict key versions")
         def get_items():
             items = []
             for _ in range(self.ITEMS):
@@ -954,6 +1076,7 @@ def write(items):
             opname, get_items, read, write, check_items=True
         )
 
+    @requires_specialization
     def test_store_attr_instance_value(self):
         def get_items():
             class C:
@@ -976,6 +1099,7 @@ def write(items):
         opname = "STORE_ATTR_INSTANCE_VALUE"
         self.assert_races_do_not_crash(opname, get_items, read, write)
 
+    @requires_specialization
     def test_store_attr_with_hint(self):
         def get_items():
             class C:
@@ -985,7 +1109,7 @@ class C:
             for _ in range(self.ITEMS):
                 item = C()
                 # Resize into a combined unicode dict:
-                for i in range(29):
+                for i in range(_testinternalcapi.SHARED_KEYS_MAX_SIZE - 1):
                     setattr(item, f"_{i}", None)
                 items.append(item)
             return items
@@ -1001,6 +1125,7 @@ def write(items):
         opname = "STORE_ATTR_WITH_HINT"
         self.assert_races_do_not_crash(opname, get_items, read, write)
 
+    @requires_specialization_ft
     def test_store_subscr_list_int(self):
         def get_items():
             items = []
@@ -1024,6 +1149,7 @@ def write(items):
         opname = "STORE_SUBSCR_LIST_INT"
         self.assert_races_do_not_crash(opname, get_items, read, write)
 
+    @requires_specialization_ft
     def test_unpack_sequence_list(self):
         def get_items():
             items = []
@@ -1079,7 +1205,7 @@ def test_dict_dematerialization(self):
         c.a = 1
         c.b = 2
         c.__dict__
-        for _ in range(100):
+        for _ in range(_testinternalcapi.SPECIALIZATION_THRESHOLD):
             c.a
         self.assertEqual(
             _testinternalcapi.get_object_dict_values(c),
@@ -1091,7 +1217,7 @@ def test_dict_dematerialization_multiple_refs(self):
         c.a = 1
         c.b = 2
         d = c.__dict__
-        for _ in range(100):
+        for _ in range(_testinternalcapi.SPECIALIZATION_THRESHOLD):
             c.a
         self.assertIs(c.__dict__, d)
 
@@ -1100,7 +1226,7 @@ def test_dict_dematerialization_copy(self):
         c.a = 1
         c.b = 2
         c2 = copy.copy(c)
-        for _ in range(100):
+        for _ in range(_testinternalcapi.SPECIALIZATION_THRESHOLD):
             c.a
             c2.a
         self.assertEqual(
@@ -1112,7 +1238,7 @@ def test_dict_dematerialization_copy(self):
             (1, 2, '<NULL>')
         )
         c3 = copy.deepcopy(c)
-        for _ in range(100):
+        for _ in range(_testinternalcapi.SPECIALIZATION_THRESHOLD):
             c.a
             c3.a
         self.assertEqual(
@@ -1126,7 +1252,7 @@ def test_dict_dematerialization_pickle(self):
         c.a = 1
         c.b = 2
         c2 = pickle.loads(pickle.dumps(c))
-        for _ in range(100):
+        for _ in range(_testinternalcapi.SPECIALIZATION_THRESHOLD):
             c.a
             c2.a
         self.assertEqual(
@@ -1144,7 +1270,7 @@ class D(dict): pass
         c.a = 1
         c.b = 2
         c.__dict__ = D(c.__dict__)
-        for _ in range(100):
+        for _ in range(_testinternalcapi.SPECIALIZATION_THRESHOLD):
             c.a
         self.assertIs(
             _testinternalcapi.get_object_dict_values(c),
@@ -1155,23 +1281,595 @@ class D(dict): pass
             {'a':1, 'b':2}
         )
 
-    def test_store_attr_with_hint(self):
-        # gh-133441: Regression test for STORE_ATTR_WITH_HINT bytecode
-        class Node:
+    def test_125868(self):
+
+        def make_special_dict():
+            """Create a dictionary an object with a this table:
+            index | key | value
+            ----- | --- | -----
+              0   | 'b' | 'value'
+              1   | 'b' | NULL
+            """
+            class A:
+                pass
+            a = A()
+            a.a = 1
+            a.b = 2
+            d = a.__dict__.copy()
+            del d['a']
+            del d['b']
+            d['b'] = "value"
+            return d
+
+        class NoInlineAorB:
+            pass
+        for i in range(ord('c'), ord('z')):
+            setattr(NoInlineAorB(), chr(i), i)
+
+        c = NoInlineAorB()
+        c.a = 0
+        c.b = 1
+        self.assertFalse(_testinternalcapi.has_inline_values(c))
+
+        def f(o, n):
+            for i in range(n):
+                o.b = i
+        # Prime f to store to dict slot 1
+        f(c, _testinternalcapi.SPECIALIZATION_THRESHOLD)
+
+        test_obj = NoInlineAorB()
+        test_obj.__dict__ = make_special_dict()
+        self.assertEqual(test_obj.b, "value")
+
+        #This should set x.b = 0
+        f(test_obj, 1)
+        self.assertEqual(test_obj.b, 0)
+
+
+class TestSpecializer(TestBase):
+
+    @cpython_only
+    @requires_specialization_ft
+    def test_binary_op(self):
+        def binary_op_add_int():
+            for _ in range(_testinternalcapi.SPECIALIZATION_THRESHOLD):
+                a, b = 1, 2
+                c = a + b
+                self.assertEqual(c, 3)
+
+        binary_op_add_int()
+        self.assert_specialized(binary_op_add_int, "BINARY_OP_ADD_INT")
+        self.assert_no_opcode(binary_op_add_int, "BINARY_OP")
+
+        def binary_op_add_unicode():
+            for _ in range(_testinternalcapi.SPECIALIZATION_THRESHOLD):
+                a, b = "foo", "bar"
+                c = a + b
+                self.assertEqual(c, "foobar")
+
+        binary_op_add_unicode()
+        self.assert_specialized(binary_op_add_unicode, "BINARY_OP_ADD_UNICODE")
+        self.assert_no_opcode(binary_op_add_unicode, "BINARY_OP")
+
+        def binary_op_add_extend():
+            for _ in range(_testinternalcapi.SPECIALIZATION_THRESHOLD):
+                a, b = 6, 3.0
+                c = a + b
+                self.assertEqual(c, 9.0)
+                c = b + a
+                self.assertEqual(c, 9.0)
+                c = a - b
+                self.assertEqual(c, 3.0)
+                c = b - a
+                self.assertEqual(c, -3.0)
+                c = a * b
+                self.assertEqual(c, 18.0)
+                c = b * a
+                self.assertEqual(c, 18.0)
+                c = a / b
+                self.assertEqual(c, 2.0)
+                c = b / a
+                self.assertEqual(c, 0.5)
+
+        binary_op_add_extend()
+        self.assert_specialized(binary_op_add_extend, "BINARY_OP_EXTEND")
+        self.assert_no_opcode(binary_op_add_extend, "BINARY_OP")
+
+        def binary_op_zero_division():
+            def compactlong_lhs(arg):
+                42 / arg
+            def float_lhs(arg):
+                42.0 / arg
+
+            with self.assertRaises(ZeroDivisionError):
+                compactlong_lhs(0)
+            with self.assertRaises(ZeroDivisionError):
+                compactlong_lhs(0.0)
+            with self.assertRaises(ZeroDivisionError):
+                float_lhs(0.0)
+            with self.assertRaises(ZeroDivisionError):
+                float_lhs(0)
+
+            self.assert_no_opcode(compactlong_lhs, "BINARY_OP_EXTEND")
+            self.assert_no_opcode(float_lhs, "BINARY_OP_EXTEND")
+
+        binary_op_zero_division()
+
+        def binary_op_nan():
+            def compactlong_lhs(arg):
+                return (
+                    42 + arg,
+                    42 - arg,
+                    42 * arg,
+                    42 / arg,
+                )
+            def compactlong_rhs(arg):
+                return (
+                    arg + 42,
+                    arg - 42,
+                    arg * 2,
+                    arg / 42,
+                )
+            nan = float('nan')
+            for _ in range(_testinternalcapi.SPECIALIZATION_THRESHOLD):
+                self.assertEqual(compactlong_lhs(1.0), (43.0, 41.0, 42.0, 42.0))
+            for _ in range(_testinternalcapi.SPECIALIZATION_COOLDOWN):
+                self.assertTrue(all(filter(lambda x: x is nan, compactlong_lhs(nan))))
+            for _ in range(_testinternalcapi.SPECIALIZATION_THRESHOLD):
+                self.assertEqual(compactlong_rhs(42.0), (84.0, 0.0, 84.0, 1.0))
+            for _ in range(_testinternalcapi.SPECIALIZATION_COOLDOWN):
+                self.assertTrue(all(filter(lambda x: x is nan, compactlong_rhs(nan))))
+
+            self.assert_no_opcode(compactlong_lhs, "BINARY_OP_EXTEND")
+            self.assert_no_opcode(compactlong_rhs, "BINARY_OP_EXTEND")
+
+        binary_op_nan()
+
+        def binary_op_bitwise_extend():
+            for _ in range(100):
+                a, b = 2, 7
+                x = a | b
+                self.assertEqual(x, 7)
+                y = a & b
+                self.assertEqual(y, 2)
+                z = a ^ b
+                self.assertEqual(z, 5)
+                a, b = 3, 9
+                a |= b
+                self.assertEqual(a, 11)
+                a, b = 11, 9
+                a &= b
+                self.assertEqual(a, 9)
+                a, b = 3, 9
+                a ^= b
+                self.assertEqual(a, 10)
+
+        binary_op_bitwise_extend()
+        self.assert_specialized(binary_op_bitwise_extend, "BINARY_OP_EXTEND")
+        self.assert_no_opcode(binary_op_bitwise_extend, "BINARY_OP")
+
+    @cpython_only
+    @requires_specialization_ft
+    def test_load_super_attr(self):
+        """Ensure that LOAD_SUPER_ATTR is specialized as expected."""
+
+        class A:
             def __init__(self):
-                self.parents = {}
+                meth = super().__init__
+                super().__init__()
+
+        for _ in range(_testinternalcapi.SPECIALIZATION_THRESHOLD):
+            A()
+
+        self.assert_specialized(A.__init__, "LOAD_SUPER_ATTR_ATTR")
+        self.assert_specialized(A.__init__, "LOAD_SUPER_ATTR_METHOD")
+        self.assert_no_opcode(A.__init__, "LOAD_SUPER_ATTR")
 
-            def __setstate__(self, data_dict):
-                self.__dict__ = data_dict
-                self.parents = {}
+        # Temporarily replace super() with something else.
+        real_super = super
 
-        class Dict(dict):
+        def fake_super():
+            def init(self):
+                pass
+
+            return init
+
+        # Force unspecialize
+        globals()['super'] = fake_super
+        try:
+            # Should be unspecialized after enough calls.
+            for _ in range(_testinternalcapi.SPECIALIZATION_COOLDOWN):
+                A()
+        finally:
+            globals()['super'] = real_super
+
+        # Ensure the specialized instructions are not present
+        self.assert_no_opcode(A.__init__, "LOAD_SUPER_ATTR_ATTR")
+        self.assert_no_opcode(A.__init__, "LOAD_SUPER_ATTR_METHOD")
+
+    @cpython_only
+    @requires_specialization_ft
+    def test_contain_op(self):
+        def contains_op_dict():
+            for _ in range(_testinternalcapi.SPECIALIZATION_THRESHOLD):
+                a, b = 1, {1: 2, 2: 5}
+                self.assertTrue(a in b)
+                self.assertFalse(3 in b)
+
+        contains_op_dict()
+        self.assert_specialized(contains_op_dict, "CONTAINS_OP_DICT")
+        self.assert_no_opcode(contains_op_dict, "CONTAINS_OP")
+
+        def contains_op_set():
+            for _ in range(_testinternalcapi.SPECIALIZATION_THRESHOLD):
+                a, b = 1, {1, 2}
+                self.assertTrue(a in b)
+                self.assertFalse(3 in b)
+
+        contains_op_set()
+        self.assert_specialized(contains_op_set, "CONTAINS_OP_SET")
+        self.assert_no_opcode(contains_op_set, "CONTAINS_OP")
+
+    @cpython_only
+    @requires_specialization_ft
+    def test_send_with(self):
+        def run_async(coro):
+            while True:
+                try:
+                    coro.send(None)
+                except StopIteration:
+                    break
+
+        class CM:
+            async def __aenter__(self):
+                return self
+
+            async def __aexit__(self, *exc):
+                pass
+
+        async def send_with():
+            for _ in range(_testinternalcapi.SPECIALIZATION_THRESHOLD):
+                async with CM():
+                    x = 1
+
+        run_async(send_with())
+        # Note there are still unspecialized "SEND" opcodes in the
+        # cleanup paths of the 'with' statement.
+        self.assert_specialized(send_with, "SEND_GEN")
+
+    @cpython_only
+    @requires_specialization_ft
+    def test_send_yield_from(self):
+        def g():
+            yield None
+
+        def send_yield_from():
+            yield from g()
+
+        for _ in range(_testinternalcapi.SPECIALIZATION_THRESHOLD):
+            list(send_yield_from())
+
+        self.assert_specialized(send_yield_from, "SEND_GEN")
+        self.assert_no_opcode(send_yield_from, "SEND")
+
+    @cpython_only
+    @requires_specialization_ft
+    def test_store_attr_slot(self):
+        class C:
+            __slots__ = ['x']
+
+        def set_slot(n):
+            c = C()
+            for i in range(n):
+                c.x = i
+
+        set_slot(_testinternalcapi.SPECIALIZATION_THRESHOLD)
+
+        self.assert_specialized(set_slot, "STORE_ATTR_SLOT")
+        self.assert_no_opcode(set_slot, "STORE_ATTR")
+
+        # Adding a property for 'x' should unspecialize it.
+        C.x = property(lambda self: None, lambda self, x: None)
+        set_slot(_testinternalcapi.SPECIALIZATION_COOLDOWN)
+        self.assert_no_opcode(set_slot, "STORE_ATTR_SLOT")
+
+    @cpython_only
+    @requires_specialization_ft
+    def test_store_attr_instance_value(self):
+        class C:
+            pass
+
+        @reset_code
+        def set_value(n):
+            c = C()
+            for i in range(n):
+                c.x = i
+
+        set_value(_testinternalcapi.SPECIALIZATION_THRESHOLD)
+
+        self.assert_specialized(set_value, "STORE_ATTR_INSTANCE_VALUE")
+        self.assert_no_opcode(set_value, "STORE_ATTR")
+
+        # Adding a property for 'x' should unspecialize it.
+        C.x = property(lambda self: None, lambda self, x: None)
+        set_value(_testinternalcapi.SPECIALIZATION_COOLDOWN)
+        self.assert_no_opcode(set_value, "STORE_ATTR_INSTANCE_VALUE")
+
+    @cpython_only
+    @requires_specialization_ft
+    def test_store_attr_with_hint(self):
+        class C:
             pass
 
-        obj = Node()
-        obj.__setstate__({'parents': {}})
-        obj.__setstate__({'parents': {}})
-        obj.__setstate__(Dict({'parents': {}}))
+        c = C()
+        for i in range(_testinternalcapi.SHARED_KEYS_MAX_SIZE - 1):
+            setattr(c, f"_{i}", None)
+
+        @reset_code
+        def set_value(n):
+            for i in range(n):
+                c.x = i
+
+        set_value(_testinternalcapi.SPECIALIZATION_THRESHOLD)
+
+        self.assert_specialized(set_value, "STORE_ATTR_WITH_HINT")
+        self.assert_no_opcode(set_value, "STORE_ATTR")
+
+        # Adding a property for 'x' should unspecialize it.
+        C.x = property(lambda self: None, lambda self, x: None)
+        set_value(_testinternalcapi.SPECIALIZATION_COOLDOWN)
+        self.assert_no_opcode(set_value, "STORE_ATTR_WITH_HINT")
+
+    @cpython_only
+    @requires_specialization_ft
+    def test_to_bool(self):
+        def to_bool_bool():
+            true_cnt, false_cnt = 0, 0
+            elems = [e % 2 == 0 for e in range(_testinternalcapi.SPECIALIZATION_THRESHOLD)]
+            for e in elems:
+                if e:
+                    true_cnt += 1
+                else:
+                    false_cnt += 1
+            d, m = divmod(_testinternalcapi.SPECIALIZATION_THRESHOLD, 2)
+            self.assertEqual(true_cnt, d + m)
+            self.assertEqual(false_cnt, d)
+
+        to_bool_bool()
+        self.assert_specialized(to_bool_bool, "TO_BOOL_BOOL")
+        self.assert_no_opcode(to_bool_bool, "TO_BOOL")
+
+        def to_bool_int():
+            count = 0
+            for i in range(_testinternalcapi.SPECIALIZATION_THRESHOLD):
+                if i:
+                    count += 1
+                else:
+                    count -= 1
+            self.assertEqual(count, _testinternalcapi.SPECIALIZATION_THRESHOLD - 2)
+
+        to_bool_int()
+        self.assert_specialized(to_bool_int, "TO_BOOL_INT")
+        self.assert_no_opcode(to_bool_int, "TO_BOOL")
+
+        def to_bool_list():
+            count = 0
+            elems = list(range(_testinternalcapi.SPECIALIZATION_THRESHOLD))
+            while elems:
+                count += elems.pop()
+            self.assertEqual(elems, [])
+            self.assertEqual(count, sum(range(_testinternalcapi.SPECIALIZATION_THRESHOLD)))
+
+        to_bool_list()
+        self.assert_specialized(to_bool_list, "TO_BOOL_LIST")
+        self.assert_no_opcode(to_bool_list, "TO_BOOL")
+
+        def to_bool_none():
+            count = 0
+            elems = [None] * _testinternalcapi.SPECIALIZATION_THRESHOLD
+            for e in elems:
+                if not e:
+                    count += 1
+            self.assertEqual(count, _testinternalcapi.SPECIALIZATION_THRESHOLD)
+
+        to_bool_none()
+        self.assert_specialized(to_bool_none, "TO_BOOL_NONE")
+        self.assert_no_opcode(to_bool_none, "TO_BOOL")
+
+        def to_bool_str():
+            count = 0
+            elems = [""] + ["foo"] * (_testinternalcapi.SPECIALIZATION_THRESHOLD - 1)
+            for e in elems:
+                if e:
+                    count += 1
+            self.assertEqual(count, _testinternalcapi.SPECIALIZATION_THRESHOLD - 1)
+
+        to_bool_str()
+        self.assert_specialized(to_bool_str, "TO_BOOL_STR")
+        self.assert_no_opcode(to_bool_str, "TO_BOOL")
+
+    @cpython_only
+    @requires_specialization_ft
+    def test_unpack_sequence(self):
+        def unpack_sequence_two_tuple():
+            for _ in range(_testinternalcapi.SPECIALIZATION_THRESHOLD):
+                t = 1, 2
+                a, b = t
+                self.assertEqual(a, 1)
+                self.assertEqual(b, 2)
+
+        unpack_sequence_two_tuple()
+        self.assert_specialized(unpack_sequence_two_tuple,
+                                "UNPACK_SEQUENCE_TWO_TUPLE")
+        self.assert_no_opcode(unpack_sequence_two_tuple, "UNPACK_SEQUENCE")
+
+        def unpack_sequence_tuple():
+            for _ in range(_testinternalcapi.SPECIALIZATION_THRESHOLD):
+                a, b, c, d = 1, 2, 3, 4
+                self.assertEqual(a, 1)
+                self.assertEqual(b, 2)
+                self.assertEqual(c, 3)
+                self.assertEqual(d, 4)
+
+        unpack_sequence_tuple()
+        self.assert_specialized(unpack_sequence_tuple, "UNPACK_SEQUENCE_TUPLE")
+        self.assert_no_opcode(unpack_sequence_tuple, "UNPACK_SEQUENCE")
+
+        def unpack_sequence_list():
+            for _ in range(_testinternalcapi.SPECIALIZATION_THRESHOLD):
+                a, b = [1, 2]
+                self.assertEqual(a, 1)
+                self.assertEqual(b, 2)
+
+        unpack_sequence_list()
+        self.assert_specialized(unpack_sequence_list, "UNPACK_SEQUENCE_LIST")
+        self.assert_no_opcode(unpack_sequence_list, "UNPACK_SEQUENCE")
+
+    @cpython_only
+    @requires_specialization_ft
+    def test_binary_subscr(self):
+        def binary_subscr_list_int():
+            for _ in range(_testinternalcapi.SPECIALIZATION_THRESHOLD):
+                a = [1, 2, 3]
+                for idx, expected in enumerate(a):
+                    self.assertEqual(a[idx], expected)
+
+        binary_subscr_list_int()
+        self.assert_specialized(binary_subscr_list_int,
+                                "BINARY_OP_SUBSCR_LIST_INT")
+        self.assert_no_opcode(binary_subscr_list_int, "BINARY_OP")
+
+        def binary_subscr_tuple_int():
+            for _ in range(_testinternalcapi.SPECIALIZATION_THRESHOLD):
+                a = (1, 2, 3)
+                for idx, expected in enumerate(a):
+                    self.assertEqual(a[idx], expected)
+
+        binary_subscr_tuple_int()
+        self.assert_specialized(binary_subscr_tuple_int,
+                                "BINARY_OP_SUBSCR_TUPLE_INT")
+        self.assert_no_opcode(binary_subscr_tuple_int, "BINARY_OP")
+
+        def binary_subscr_dict():
+            for _ in range(_testinternalcapi.SPECIALIZATION_THRESHOLD):
+                a = {1: 2, 2: 3}
+                self.assertEqual(a[1], 2)
+                self.assertEqual(a[2], 3)
+
+        binary_subscr_dict()
+        self.assert_specialized(binary_subscr_dict, "BINARY_OP_SUBSCR_DICT")
+        self.assert_no_opcode(binary_subscr_dict, "BINARY_OP")
+
+        def binary_subscr_str_int():
+            for _ in range(_testinternalcapi.SPECIALIZATION_THRESHOLD):
+                a = "foobar"
+                for idx, expected in enumerate(a):
+                    self.assertEqual(a[idx], expected)
+
+        binary_subscr_str_int()
+        self.assert_specialized(binary_subscr_str_int, "BINARY_OP_SUBSCR_STR_INT")
+        self.assert_no_opcode(binary_subscr_str_int, "BINARY_OP")
+
+        def binary_subscr_getitems():
+            class C:
+                def __init__(self, val):
+                    self.val = val
+                def __getitem__(self, item):
+                    return self.val
+
+            items = [C(i) for i in range(_testinternalcapi.SPECIALIZATION_THRESHOLD)]
+            for i in range(_testinternalcapi.SPECIALIZATION_THRESHOLD):
+                self.assertEqual(items[i][i], i)
+
+        binary_subscr_getitems()
+        self.assert_specialized(binary_subscr_getitems, "BINARY_OP_SUBSCR_GETITEM")
+        self.assert_no_opcode(binary_subscr_getitems, "BINARY_OP")
+
+    @cpython_only
+    @requires_specialization_ft
+    def test_compare_op(self):
+        def compare_op_int():
+            for _ in range(_testinternalcapi.SPECIALIZATION_THRESHOLD):
+                a, b = 1, 2
+                c = a == b
+                self.assertFalse(c)
+
+        compare_op_int()
+        self.assert_specialized(compare_op_int, "COMPARE_OP_INT")
+        self.assert_no_opcode(compare_op_int, "COMPARE_OP")
+
+        def compare_op_float():
+            for _ in range(_testinternalcapi.SPECIALIZATION_THRESHOLD):
+                a, b = 1.0, 2.0
+                c = a == b
+                self.assertFalse(c)
+
+        compare_op_float()
+        self.assert_specialized(compare_op_float, "COMPARE_OP_FLOAT")
+        self.assert_no_opcode(compare_op_float, "COMPARE_OP")
+
+        def compare_op_str():
+            for _ in range(_testinternalcapi.SPECIALIZATION_THRESHOLD):
+                a, b = "spam", "ham"
+                c = a == b
+                self.assertFalse(c)
+
+        compare_op_str()
+        self.assert_specialized(compare_op_str, "COMPARE_OP_STR")
+        self.assert_no_opcode(compare_op_str, "COMPARE_OP")
+
+    @cpython_only
+    @requires_specialization_ft
+    def test_load_const(self):
+        def load_const():
+            def unused(): pass
+            # Currently, the empty tuple is immortal, and the otherwise
+            # unused nested function's code object is mortal. This test will
+            # have to use different values if either of that changes.
+            return ()
+
+        load_const()
+        self.assert_specialized(load_const, "LOAD_CONST_IMMORTAL")
+        self.assert_specialized(load_const, "LOAD_CONST_MORTAL")
+        self.assert_no_opcode(load_const, "LOAD_CONST")
+
+    @cpython_only
+    @requires_specialization_ft
+    def test_for_iter(self):
+        L = list(range(10))
+        def for_iter_list():
+            for i in L:
+                self.assertIn(i, L)
+
+        for_iter_list()
+        self.assert_specialized(for_iter_list, "FOR_ITER_LIST")
+        self.assert_no_opcode(for_iter_list, "FOR_ITER")
+
+        t = tuple(range(10))
+        def for_iter_tuple():
+            for i in t:
+                self.assertIn(i, t)
+
+        for_iter_tuple()
+        self.assert_specialized(for_iter_tuple, "FOR_ITER_TUPLE")
+        self.assert_no_opcode(for_iter_tuple, "FOR_ITER")
+
+        r = range(10)
+        def for_iter_range():
+            for i in r:
+                self.assertIn(i, r)
+
+        for_iter_range()
+        self.assert_specialized(for_iter_range, "FOR_ITER_RANGE")
+        self.assert_no_opcode(for_iter_range, "FOR_ITER")
+
+        def for_iter_generator():
+            for i in (i for i in range(10)):
+                i + 1
+
+        for_iter_generator()
+        self.assert_specialized(for_iter_generator, "FOR_ITER_GEN")
+        self.assert_no_opcode(for_iter_generator, "FOR_ITER")
 
 
 if __name__ == "__main__":
diff --git a/Lib/test/test_operator.py b/Lib/test/test_operator.py
index f8b36a3c2f1..1f89986c777 100644
--- a/Lib/test/test_operator.py
+++ b/Lib/test/test_operator.py
@@ -668,18 +668,6 @@ class PyOperatorTestCase(OperatorTestCase, unittest.TestCase):
 class COperatorTestCase(OperatorTestCase, unittest.TestCase):
     module = c_operator
 
-    @unittest.expectedFailure  # TODO: RUSTPYTHON
-    def test_attrgetter_signature(self):
-        return super().test_attrgetter_signature()
-
-    @unittest.expectedFailure  # TODO: RUSTPYTHON
-    def test_itemgetter_signature(self):
-        return super().test_itemgetter_signature()
-
-    @unittest.expectedFailure  # TODO: RUSTPYTHON
-    def test_methodcaller_signature(self):
-        return super().test_methodcaller_signature()
-
 
 @support.thread_unsafe("swaps global operator module")
 class OperatorPickleTestCase:
diff --git a/Lib/test/test_optimizer.py b/Lib/test/test_optimizer.py
new file mode 100644
index 00000000000..fac4d1a4ab4
--- /dev/null
+++ b/Lib/test/test_optimizer.py
@@ -0,0 +1,90 @@
+import unittest
+import types
+from test.support import import_helper
+
+
+_testinternalcapi = import_helper.import_module("_testinternalcapi")
+
+
+class TestRareEventCounters(unittest.TestCase):
+    def setUp(self):
+        _testinternalcapi.reset_rare_event_counters()
+
+    def test_set_class(self):
+        class A:
+            pass
+        class B:
+            pass
+        a = A()
+
+        orig_counter = _testinternalcapi.get_rare_event_counters()["set_class"]
+        a.__class__ = B
+        self.assertEqual(
+            orig_counter + 1,
+            _testinternalcapi.get_rare_event_counters()["set_class"]
+        )
+
+    def test_set_bases(self):
+        class A:
+            pass
+        class B:
+            pass
+        class C(B):
+            pass
+
+        orig_counter = _testinternalcapi.get_rare_event_counters()["set_bases"]
+        C.__bases__ = (A,)
+        self.assertEqual(
+            orig_counter + 1,
+            _testinternalcapi.get_rare_event_counters()["set_bases"]
+        )
+
+    def test_set_eval_frame_func(self):
+        orig_counter = _testinternalcapi.get_rare_event_counters()["set_eval_frame_func"]
+        _testinternalcapi.set_eval_frame_record([])
+        self.assertEqual(
+            orig_counter + 1,
+            _testinternalcapi.get_rare_event_counters()["set_eval_frame_func"]
+        )
+        _testinternalcapi.set_eval_frame_default()
+
+    def test_builtin_dict(self):
+        orig_counter = _testinternalcapi.get_rare_event_counters()["builtin_dict"]
+        if isinstance(__builtins__, types.ModuleType):
+            builtins = __builtins__.__dict__
+        else:
+            builtins = __builtins__
+        builtins["FOO"] = 42
+        self.assertEqual(
+            orig_counter + 1,
+            _testinternalcapi.get_rare_event_counters()["builtin_dict"]
+        )
+        del builtins["FOO"]
+
+    def test_func_modification(self):
+        def func(x=0):
+            pass
+
+        for attribute in (
+            "__code__",
+            "__defaults__",
+            "__kwdefaults__"
+        ):
+            orig_counter = _testinternalcapi.get_rare_event_counters()["func_modification"]
+            setattr(func, attribute, getattr(func, attribute))
+            self.assertEqual(
+                orig_counter + 1,
+                _testinternalcapi.get_rare_event_counters()["func_modification"]
+            )
+
+
+class TestOptimizerSymbols(unittest.TestCase):
+
+    @unittest.skipUnless(hasattr(_testinternalcapi, "uop_symbols_test"),
+                "requires _testinternalcapi.uop_symbols_test")
+    def test_optimizer_symbols(self):
+        _testinternalcapi.uop_symbols_test()
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/Lib/test/test_optparse.py b/Lib/test/test_optparse.py
index c68214961e3..e476e472780 100644
--- a/Lib/test/test_optparse.py
+++ b/Lib/test/test_optparse.py
@@ -14,8 +14,9 @@
 
 from io import StringIO
 from test import support
-from test.support import os_helper
+from test.support import cpython_only, os_helper
 from test.support.i18n_helper import TestTranslationsBase, update_translation_snapshots
+from test.support.import_helper import ensure_lazy_imports
 
 import optparse
 from optparse import make_option, Option, \
@@ -1655,6 +1656,10 @@ def test__all__(self):
         not_exported = {'check_builtin', 'AmbiguousOptionError', 'NO_DEFAULT'}
         support.check__all__(self, optparse, not_exported=not_exported)
 
+    @cpython_only
+    def test_lazy_import(self):
+        ensure_lazy_imports("optparse", {"textwrap"})
+
 
 class TestTranslations(TestTranslationsBase):
     def test_translations(self):
diff --git a/Lib/test/test_ordered_dict.py b/Lib/test/test_ordered_dict.py
index 4b5e17fd4df..378f6c5ab59 100644
--- a/Lib/test/test_ordered_dict.py
+++ b/Lib/test/test_ordered_dict.py
@@ -2,7 +2,9 @@
 import contextlib
 import copy
 import gc
+import operator
 import pickle
+import re
 from random import randrange, shuffle
 import struct
 import sys
@@ -145,7 +147,7 @@ def test_fromkeys(self):
     def test_abc(self):
         OrderedDict = self.OrderedDict
         self.assertIsInstance(OrderedDict(), MutableMapping)
-        self.assertTrue(issubclass(OrderedDict, MutableMapping))
+        self.assertIsSubclass(OrderedDict, MutableMapping)
 
     def test_clear(self):
         OrderedDict = self.OrderedDict
@@ -312,14 +314,14 @@ def check(dup):
         check(dup)
         self.assertIs(dup.x, od.x)
         self.assertIs(dup.z, od.z)
-        self.assertFalse(hasattr(dup, 'y'))
+        self.assertNotHasAttr(dup, 'y')
         dup = copy.deepcopy(od)
         check(dup)
         self.assertEqual(dup.x, od.x)
         self.assertIsNot(dup.x, od.x)
         self.assertEqual(dup.z, od.z)
         self.assertIsNot(dup.z, od.z)
-        self.assertFalse(hasattr(dup, 'y'))
+        self.assertNotHasAttr(dup, 'y')
         # pickle directly pulls the module, so we have to fake it
         with replaced_module('collections', self.module):
             for proto in range(pickle.HIGHEST_PROTOCOL + 1):
@@ -328,7 +330,7 @@ def check(dup):
                     check(dup)
                     self.assertEqual(dup.x, od.x)
                     self.assertEqual(dup.z, od.z)
-                    self.assertFalse(hasattr(dup, 'y'))
+                    self.assertNotHasAttr(dup, 'y')
         check(eval(repr(od)))
         update_test = OrderedDict()
         update_test.update(od)
@@ -667,8 +669,6 @@ def test_dict_update(self):
         dict.update(od, [('spam', 1)])
         self.assertNotIn('NULL', repr(od))
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_reference_loop(self):
         # Issue 25935
         OrderedDict = self.OrderedDict
@@ -680,8 +680,7 @@ class A:
         gc.collect()
         self.assertIsNone(r())
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AssertionError: False is not true
     def test_free_after_iterating(self):
         support.check_free_after_iterating(self, iter, self.OrderedDict)
         support.check_free_after_iterating(self, lambda d: iter(d.keys()), self.OrderedDict)
@@ -743,11 +742,44 @@ def test_ordered_dict_items_result_gc(self):
         # when it's mutated and returned from __next__:
         self.assertTrue(gc.is_tracked(next(it)))
 
+
+class _TriggerSideEffectOnEqual:
+    count = 0   # number of calls to __eq__
+    trigger = 1 # count value when to trigger side effect
+
+    def __eq__(self, other):
+        if self.__class__.count == self.__class__.trigger:
+            self.side_effect()
+        self.__class__.count += 1
+        return True
+
+    def __hash__(self):
+        # all instances represent the same key
+        return -1
+
+    def side_effect(self):
+        raise NotImplementedError
+
 class PurePythonOrderedDictTests(OrderedDictTests, unittest.TestCase):
 
     module = py_coll
     OrderedDict = py_coll.OrderedDict
 
+    def test_issue119004_attribute_error(self):
+        class Key(_TriggerSideEffectOnEqual):
+            def side_effect(self):
+                del dict1[TODEL]
+
+        TODEL = Key()
+        dict1 = self.OrderedDict(dict.fromkeys((0, TODEL, 4.2)))
+        dict2 = self.OrderedDict(dict.fromkeys((0, Key(), 4.2)))
+        # This causes an AttributeError due to the linked list being changed
+        msg = re.escape("'NoneType' object has no attribute 'key'")
+        self.assertRaisesRegex(AttributeError, msg, operator.eq, dict1, dict2)
+        self.assertEqual(Key.count, 2)
+        self.assertDictEqual(dict1, dict.fromkeys((0, 4.2)))
+        self.assertDictEqual(dict2, dict.fromkeys((0, Key(), 4.2)))
+
 
 class CPythonBuiltinDictTests(unittest.TestCase):
     """Builtin dict preserves insertion order.
@@ -768,8 +800,90 @@ class CPythonBuiltinDictTests(unittest.TestCase):
 del method
 
 
+class CPythonOrderedDictSideEffects:
+
+    def check_runtime_error_issue119004(self, dict1, dict2):
+        msg = re.escape("OrderedDict mutated during iteration")
+        self.assertRaisesRegex(RuntimeError, msg, operator.eq, dict1, dict2)
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AssertionError: RuntimeError not raised by eq
+    def test_issue119004_change_size_by_clear(self):
+        class Key(_TriggerSideEffectOnEqual):
+            def side_effect(self):
+                dict1.clear()
+
+        dict1 = self.OrderedDict(dict.fromkeys((0, Key(), 4.2)))
+        dict2 = self.OrderedDict(dict.fromkeys((0, Key(), 4.2)))
+        self.check_runtime_error_issue119004(dict1, dict2)
+        self.assertEqual(Key.count, 2)
+        self.assertDictEqual(dict1, {})
+        self.assertDictEqual(dict2, dict.fromkeys((0, Key(), 4.2)))
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AttributeError: 'NoneType' object has no attribute 'key'
+    def test_issue119004_change_size_by_delete_key(self):
+        class Key(_TriggerSideEffectOnEqual):
+            def side_effect(self):
+                del dict1[TODEL]
+
+        TODEL = Key()
+        dict1 = self.OrderedDict(dict.fromkeys((0, TODEL, 4.2)))
+        dict2 = self.OrderedDict(dict.fromkeys((0, Key(), 4.2)))
+        self.check_runtime_error_issue119004(dict1, dict2)
+        self.assertEqual(Key.count, 2)
+        self.assertDictEqual(dict1, dict.fromkeys((0, 4.2)))
+        self.assertDictEqual(dict2, dict.fromkeys((0, Key(), 4.2)))
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AssertionError: RuntimeError not raised by eq
+    def test_issue119004_change_linked_list_by_clear(self):
+        class Key(_TriggerSideEffectOnEqual):
+            def side_effect(self):
+                dict1.clear()
+                dict1['a'] = dict1['b'] = 'c'
+
+        dict1 = self.OrderedDict(dict.fromkeys((0, Key(), 4.2)))
+        dict2 = self.OrderedDict(dict.fromkeys((0, Key(), 4.2)))
+        self.check_runtime_error_issue119004(dict1, dict2)
+        self.assertEqual(Key.count, 2)
+        self.assertDictEqual(dict1, dict.fromkeys(('a', 'b'), 'c'))
+        self.assertDictEqual(dict2, dict.fromkeys((0, Key(), 4.2)))
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AttributeError: 'NoneType' object has no attribute 'key'
+    def test_issue119004_change_linked_list_by_delete_key(self):
+        class Key(_TriggerSideEffectOnEqual):
+            def side_effect(self):
+                del dict1[TODEL]
+                dict1['a'] = 'c'
+
+        TODEL = Key()
+        dict1 = self.OrderedDict(dict.fromkeys((0, TODEL, 4.2)))
+        dict2 = self.OrderedDict(dict.fromkeys((0, Key(), 4.2)))
+        self.check_runtime_error_issue119004(dict1, dict2)
+        self.assertEqual(Key.count, 2)
+        self.assertDictEqual(dict1, {0: None, 'a': 'c', 4.2: None})
+        self.assertDictEqual(dict2, dict.fromkeys((0, Key(), 4.2)))
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AssertionError: 1 != 2
+    def test_issue119004_change_size_by_delete_key_in_dict_eq(self):
+        class Key(_TriggerSideEffectOnEqual):
+            trigger = 0
+            def side_effect(self):
+                del dict1[TODEL]
+
+        TODEL = Key()
+        dict1 = self.OrderedDict(dict.fromkeys((0, TODEL, 4.2)))
+        dict2 = self.OrderedDict(dict.fromkeys((0, Key(), 4.2)))
+        self.assertEqual(Key.count, 0)
+        # the side effect is in dict.__eq__ and modifies the length
+        self.assertNotEqual(dict1, dict2)
+        self.assertEqual(Key.count, 2)
+        self.assertDictEqual(dict1, dict.fromkeys((0, 4.2)))
+        self.assertDictEqual(dict2, dict.fromkeys((0, Key(), 4.2)))
+
+
 @unittest.skipUnless(c_coll, 'requires the C version of the collections module')
-class CPythonOrderedDictTests(OrderedDictTests, unittest.TestCase):
+class CPythonOrderedDictTests(OrderedDictTests,
+                              CPythonOrderedDictSideEffects,
+                              unittest.TestCase):
 
     module = c_coll
     OrderedDict = c_coll.OrderedDict
@@ -808,8 +922,7 @@ def test_sizeof_exact(self):
         check(iter(od.items()), itersize)
         check(iter(od.values()), itersize)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AssertionError: RuntimeError not raised
     def test_key_change_during_iteration(self):
         OrderedDict = self.OrderedDict
 
@@ -827,8 +940,7 @@ def test_key_change_during_iteration(self):
                 del od['c']
         self.assertEqual(list(od), list('bdeaf'))
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_iterators_pickling(self):
         OrderedDict = self.OrderedDict
         pairs = [('c', 1), ('b', 2), ('a', 3), ('d', 4), ('e', 5), ('f', 6)]
@@ -880,6 +992,7 @@ class CPythonOrderedDictSubclassTests(CPythonOrderedDictTests):
     class OrderedDict(c_coll.OrderedDict):
         pass
 
+
 class PurePythonOrderedDictWithSlotsCopyingTests(unittest.TestCase):
 
     module = py_coll
@@ -887,6 +1000,7 @@ class OrderedDict(py_coll.OrderedDict):
         __slots__ = ('x', 'y')
     test_copying = OrderedDictTests.test_copying
 
+
 @unittest.skipUnless(c_coll, 'requires the C version of the collections module')
 class CPythonOrderedDictWithSlotsCopyingTests(unittest.TestCase):
 
diff --git a/Lib/test/test_os.py b/Lib/test/test_os.py
index f88659764bc..00bd75bab51 100644
--- a/Lib/test/test_os.py
+++ b/Lib/test/test_os.py
@@ -104,7 +104,7 @@ def create_file(filename, content=b'content'):
 
 
 def tearDownModule():
-    asyncio.set_event_loop_policy(None)
+    asyncio.events._set_event_loop_policy(None)
 
 
 class MiscTests(unittest.TestCase):
@@ -187,10 +187,6 @@ def test_access(self):
         os.close(f)
         self.assertTrue(os.access(os_helper.TESTFN, os.W_OK))
 
-    @unittest.skipIf(sys.platform == 'win32', "TODO: RUSTPYTHON; BrokenPipeError: (32, 'The process cannot access the file because it is being used by another process. (os error 32)')")
-    @unittest.skipIf(
-        support.is_emscripten, "Test is unstable under Emscripten."
-    )
     @unittest.skipIf(
         support.is_wasi, "WASI does not support dup."
     )
@@ -233,6 +229,94 @@ def test_read(self):
             self.assertEqual(type(s), bytes)
             self.assertEqual(s, b"spam")
 
+    def test_readinto(self):
+        with open(os_helper.TESTFN, "w+b") as fobj:
+            fobj.write(b"spam")
+            fobj.flush()
+            fd = fobj.fileno()
+            os.lseek(fd, 0, 0)
+            # Oversized so readinto without hitting end.
+            buffer = bytearray(7)
+            s = os.readinto(fd, buffer)
+            self.assertEqual(type(s), int)
+            self.assertEqual(s, 4)
+            # Should overwrite the first 4 bytes of the buffer.
+            self.assertEqual(buffer[:4], b"spam")
+
+            # Readinto at EOF should return 0 and not touch buffer.
+            buffer[:] = b"notspam"
+            s = os.readinto(fd, buffer)
+            self.assertEqual(type(s), int)
+            self.assertEqual(s, 0)
+            self.assertEqual(bytes(buffer), b"notspam")
+            s = os.readinto(fd, buffer)
+            self.assertEqual(s, 0)
+            self.assertEqual(bytes(buffer), b"notspam")
+
+            # Readinto a 0 length bytearray when at EOF should return 0
+            self.assertEqual(os.readinto(fd, bytearray()), 0)
+
+            # Readinto a 0 length bytearray with data available should return 0.
+            os.lseek(fd, 0, 0)
+            self.assertEqual(os.readinto(fd, bytearray()), 0)
+
+    @unittest.skipUnless(hasattr(os, 'get_blocking'),
+                     'needs os.get_blocking() and os.set_blocking()')
+    @unittest.skipUnless(hasattr(os, "pipe"), "requires os.pipe()")
+    @unittest.skipIf(support.is_emscripten, "set_blocking does not work correctly")
+    def test_readinto_non_blocking(self):
+        # Verify behavior of a readinto which would block on a non-blocking fd.
+        r, w = os.pipe()
+        try:
+            os.set_blocking(r, False)
+            with self.assertRaises(BlockingIOError):
+                os.readinto(r, bytearray(5))
+
+            # Pass some data through
+            os.write(w, b"spam")
+            self.assertEqual(os.readinto(r, bytearray(4)), 4)
+
+            # Still don't block or return 0.
+            with self.assertRaises(BlockingIOError):
+                os.readinto(r, bytearray(5))
+
+            # At EOF should return size 0
+            os.close(w)
+            w = None
+            self.assertEqual(os.readinto(r, bytearray(5)), 0)
+            self.assertEqual(os.readinto(r, bytearray(5)), 0)  # Still EOF
+
+        finally:
+            os.close(r)
+            if w is not None:
+                os.close(w)
+
+    def test_readinto_badarg(self):
+        with open(os_helper.TESTFN, "w+b") as fobj:
+            fobj.write(b"spam")
+            fobj.flush()
+            fd = fobj.fileno()
+            os.lseek(fd, 0, 0)
+
+            for bad_arg in ("test", bytes(), 14):
+                with self.subTest(f"bad buffer {type(bad_arg)}"):
+                    with self.assertRaises(TypeError):
+                        os.readinto(fd, bad_arg)
+
+            with self.subTest("doesn't work on file objects"):
+                with self.assertRaises(TypeError):
+                    os.readinto(fobj, bytearray(5))
+
+            # takes two args
+            with self.assertRaises(TypeError):
+                os.readinto(fd)
+
+            # No data should have been read with the bad arguments.
+            buffer = bytearray(4)
+            s = os.readinto(fd, buffer)
+            self.assertEqual(s, 4)
+            self.assertEqual(buffer, b"spam")
+
     @support.cpython_only
     # Skip the test on 32-bit platforms: the number of bytes must fit in a
     # Py_ssize_t type
@@ -252,6 +336,29 @@ def test_large_read(self, size):
         # operating system is free to return less bytes than requested.
         self.assertEqual(data, b'test')
 
+
+    @support.cpython_only
+    # Skip the test on 32-bit platforms: the number of bytes must fit in a
+    # Py_ssize_t type
+    @unittest.skipUnless(INT_MAX < PY_SSIZE_T_MAX,
+                         "needs INT_MAX < PY_SSIZE_T_MAX")
+    @support.bigmemtest(size=INT_MAX + 10, memuse=1, dry_run=False)
+    def test_large_readinto(self, size):
+        self.addCleanup(os_helper.unlink, os_helper.TESTFN)
+        create_file(os_helper.TESTFN, b'test')
+
+        # Issue #21932: For readinto the buffer contains the length rather than
+        # a length being passed explicitly to read, should still get capped to a
+        # valid size / not raise an OverflowError for sizes larger than INT_MAX.
+        buffer = bytearray(INT_MAX + 10)
+        with open(os_helper.TESTFN, "rb") as fp:
+            length = os.readinto(fp.fileno(), buffer)
+
+        # The test does not try to read more than 2 GiB at once because the
+        # operating system is free to return less bytes than requested.
+        self.assertEqual(length, 4)
+        self.assertEqual(buffer[:4], b'test')
+
     def test_write(self):
         # os.write() accepts bytes- and buffer-like objects but not strings
         fd = os.open(os_helper.TESTFN, os.O_CREAT | os.O_WRONLY)
@@ -710,7 +817,7 @@ def test_15261(self):
         self.assertEqual(ctx.exception.errno, errno.EBADF)
 
     def check_file_attributes(self, result):
-        self.assertTrue(hasattr(result, 'st_file_attributes'))
+        self.assertHasAttr(result, 'st_file_attributes')
         self.assertTrue(isinstance(result.st_file_attributes, int))
         self.assertTrue(0 <= result.st_file_attributes <= 0xFFFFFFFF)
 
@@ -805,14 +912,28 @@ def _test_utime(self, set_time, filename=None):
         set_time(filename, (atime_ns, mtime_ns))
         st = os.stat(filename)
 
-        if support_subsecond:
-            self.assertAlmostEqual(st.st_atime, atime_ns * 1e-9, delta=1e-6)
-            self.assertAlmostEqual(st.st_mtime, mtime_ns * 1e-9, delta=1e-6)
+        if support.is_emscripten:
+            # Emscripten timestamps are roundtripped through a 53 bit integer of
+            # nanoseconds. If we want to represent ~50 years which is an 11
+            # digits number of seconds:
+            # 2*log10(60) + log10(24) + log10(365) + log10(60) + log10(50)
+            # is about 11. Because 53 * log10(2) is about 16, we only have 5
+            # digits worth of sub-second precision.
+            # Some day it would be good to fix this upstream.
+            delta=1e-5
+            self.assertAlmostEqual(st.st_atime, atime_ns * 1e-9, delta=1e-5)
+            self.assertAlmostEqual(st.st_mtime, mtime_ns * 1e-9, delta=1e-5)
+            self.assertAlmostEqual(st.st_atime_ns, atime_ns, delta=1e9 * 1e-5)
+            self.assertAlmostEqual(st.st_mtime_ns, mtime_ns, delta=1e9 * 1e-5)
         else:
-            self.assertEqual(st.st_atime, atime_ns * 1e-9)
-            self.assertEqual(st.st_mtime, mtime_ns * 1e-9)
-        self.assertEqual(st.st_atime_ns, atime_ns)
-        self.assertEqual(st.st_mtime_ns, mtime_ns)
+            if support_subsecond:
+                self.assertAlmostEqual(st.st_atime, atime_ns * 1e-9, delta=1e-6)
+                self.assertAlmostEqual(st.st_mtime, mtime_ns * 1e-9, delta=1e-6)
+            else:
+                self.assertEqual(st.st_atime, atime_ns * 1e-9)
+                self.assertEqual(st.st_mtime, mtime_ns * 1e-9)
+            self.assertEqual(st.st_atime_ns, atime_ns)
+            self.assertEqual(st.st_mtime_ns, mtime_ns)
 
     def test_utime(self):
         def set_time(filename, ns):
@@ -825,9 +946,7 @@ def ns_to_sec(ns):
         # Convert a number of nanosecond (int) to a number of seconds (float).
         # Round towards infinity by adding 0.5 nanosecond to avoid rounding
         # issue, os.utime() rounds towards minus infinity.
-        # XXX: RUSTPYTHON os.utime() use `[Duration::from_secs_f64](https://doc.rust-lang.org/std/time/struct.Duration.html#method.try_from_secs_f64)`
-        # return (ns * 1e-9) + 0.5e-9
-        return (ns * 1e-9)
+        return (ns * 1e-9) + 0.5e-9
 
     def test_utime_by_indexed(self):
         # pass times as floating-point seconds as the second indexed parameter
@@ -1300,6 +1419,52 @@ def test_ror_operator(self):
         self._test_underlying_process_env('_A_', '')
         self._test_underlying_process_env(overridden_key, original_value)
 
+    def test_reload_environ(self):
+        # Test os.reload_environ()
+        has_environb = hasattr(os, 'environb')
+
+        # Test with putenv() which doesn't update os.environ
+        os.environ['test_env'] = 'python_value'
+        os.putenv("test_env", "new_value")
+        self.assertEqual(os.environ['test_env'], 'python_value')
+        if has_environb:
+            self.assertEqual(os.environb[b'test_env'], b'python_value')
+
+        os.reload_environ()
+        self.assertEqual(os.environ['test_env'], 'new_value')
+        if has_environb:
+            self.assertEqual(os.environb[b'test_env'], b'new_value')
+
+        # Test with unsetenv() which doesn't update os.environ
+        os.unsetenv('test_env')
+        self.assertEqual(os.environ['test_env'], 'new_value')
+        if has_environb:
+            self.assertEqual(os.environb[b'test_env'], b'new_value')
+
+        os.reload_environ()
+        self.assertNotIn('test_env', os.environ)
+        if has_environb:
+            self.assertNotIn(b'test_env', os.environb)
+
+        if has_environb:
+            # test reload_environ() on os.environb with putenv()
+            os.environb[b'test_env'] = b'python_value2'
+            os.putenv("test_env", "new_value2")
+            self.assertEqual(os.environb[b'test_env'], b'python_value2')
+            self.assertEqual(os.environ['test_env'], 'python_value2')
+
+            os.reload_environ()
+            self.assertEqual(os.environb[b'test_env'], b'new_value2')
+            self.assertEqual(os.environ['test_env'], 'new_value2')
+
+            # test reload_environ() on os.environb with unsetenv()
+            os.unsetenv('test_env')
+            self.assertEqual(os.environb[b'test_env'], b'new_value2')
+            self.assertEqual(os.environ['test_env'], 'new_value2')
+
+            os.reload_environ()
+            self.assertNotIn(b'test_env', os.environb)
+            self.assertNotIn('test_env', os.environ)
 
 class WalkTests(unittest.TestCase):
     """Tests for os.walk()."""
@@ -1370,9 +1535,7 @@ def setUp(self):
         else:
             self.sub2_tree = (sub2_path, ["SUB21"], ["tmp3"])
 
-        if not support.is_emscripten:
-            # Emscripten fails with inaccessible directory
-            os.chmod(sub21_path, 0)
+        os.chmod(sub21_path, 0)
         try:
             os.listdir(sub21_path)
         except PermissionError:
@@ -1668,9 +1831,6 @@ def test_yields_correct_dir_fd(self):
                 # check that listdir() returns consistent information
                 self.assertEqual(set(os.listdir(rootfd)), set(dirs) | set(files))
 
-    @unittest.skipIf(
-        support.is_emscripten, "Cannot dup stdout on Emscripten"
-    )
     @unittest.skipIf(
         support.is_android, "dup return value is unpredictable on Android"
     )
@@ -1687,9 +1847,6 @@ def test_fd_leak(self):
         self.addCleanup(os.close, newfd)
         self.assertEqual(newfd, minfd)
 
-    @unittest.skipIf(
-        support.is_emscripten, "Cannot dup stdout on Emscripten"
-    )
     @unittest.skipIf(
         support.is_android, "dup return value is unpredictable on Android"
     )
@@ -1725,17 +1882,6 @@ def walk(self, top, **kwargs):
             bdirs[:] = list(map(os.fsencode, dirs))
             bfiles[:] = list(map(os.fsencode, files))
 
-    @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; WalkTests doesn't have these methods
-    def test_dir_fd(self):
-        return super().test_dir_fd()
-
-    @unittest.expectedFailure # TODO: RUSTPYTHON; WalkTests doesn't have these methods
-    def test_yields_correct_dir_fd(self):
-        return super().test_yields_correct_dir_fd()
 
 @unittest.skipUnless(hasattr(os, 'fwalk'), "Test needs os.fwalk()")
 class BytesFwalkTests(FwalkTests):
@@ -1770,10 +1916,12 @@ def test_makedir(self):
         os.makedirs(path)
 
     @unittest.skipIf(
-        support.is_emscripten or support.is_wasi,
-        "Emscripten's/WASI's umask is a stub."
+        support.is_wasi,
+        "WASI's umask is a stub."
     )
     def test_mode(self):
+        # Note: in some cases, the umask might already be 2 in which case this
+        # will pass even if os.umask is actually broken.
         with os_helper.temp_umask(0o002):
             base = os_helper.TESTFN
             parent = os.path.join(base, 'dir1')
@@ -1786,8 +1934,8 @@ def test_mode(self):
                 self.assertEqual(os.stat(parent).st_mode & 0o777, 0o775)
 
     @unittest.skipIf(
-        support.is_emscripten or support.is_wasi,
-        "Emscripten's/WASI's umask is a stub."
+        support.is_wasi,
+        "WASI's umask is a stub."
     )
     def test_exist_ok_existing_directory(self):
         path = os.path.join(os_helper.TESTFN, 'dir1')
@@ -1804,8 +1952,8 @@ def test_exist_ok_existing_directory(self):
         os.makedirs(os.path.abspath('/'), exist_ok=True)
 
     @unittest.skipIf(
-        support.is_emscripten or support.is_wasi,
-        "Emscripten's/WASI's umask is a stub."
+        support.is_wasi,
+        "WASI's umask is a stub."
     )
     def test_exist_ok_s_isgid_directory(self):
         path = os.path.join(os_helper.TESTFN, 'dir1')
@@ -2035,7 +2183,7 @@ def test_getrandom0(self):
         self.assertEqual(empty, b'')
 
     def test_getrandom_random(self):
-        self.assertTrue(hasattr(os, 'GRND_RANDOM'))
+        self.assertHasAttr(os, 'GRND_RANDOM')
 
         # Don't test os.getrandom(1, os.GRND_RANDOM) to not consume the rare
         # resource /dev/random
@@ -2319,9 +2467,13 @@ def test_chmod(self):
 
 @unittest.skipIf(support.is_wasi, "Cannot create invalid FD on WASI.")
 class TestInvalidFD(unittest.TestCase):
-    singles = ["fchdir", "dup", "fdatasync", "fstat",
-               "fstatvfs", "fsync", "tcgetpgrp", "ttyname"]
-    singles_fildes = {"fchdir", "fdatasync", "fsync"}
+    singles = ["fchdir", "dup", "fstat", "fstatvfs", "tcgetpgrp", "ttyname"]
+    singles_fildes = {"fchdir"}
+    # systemd-nspawn --suppress-sync=true does not verify fd passed
+    # fdatasync() and fsync(), and always returns success
+    if not support.in_systemd_nspawn_sync_suppressed():
+        singles += ["fdatasync", "fsync"]
+        singles_fildes |= {"fdatasync", "fsync"}
     #singles.append("close")
     #We omit close because it doesn't raise an exception on some platforms
     def get_single(f):
@@ -2350,7 +2502,6 @@ def check_bool(self, f, *args, **kwargs):
                 with self.assertRaises(RuntimeWarning):
                     f(fd, *args, **kwargs)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_fdopen(self):
         self.check(os.fdopen, encoding="utf-8")
         self.check_bool(os.fdopen, encoding="utf-8")
@@ -2380,10 +2531,6 @@ def test_dup2(self):
         self.check(os.dup2, 20)
 
     @unittest.skipUnless(hasattr(os, 'dup2'), 'test needs os.dup2()')
-    @unittest.skipIf(
-        support.is_emscripten,
-        "dup2() with negative fds is broken on Emscripten (see gh-102179)"
-    )
     def test_dup2_negative_fd(self):
         valid_fd = os.open(__file__, os.O_RDONLY)
         self.addCleanup(os.close, valid_fd)
@@ -2407,20 +2554,21 @@ def test_fchmod(self):
     def test_fchown(self):
         self.check(os.fchown, -1, -1)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     @unittest.skipUnless(hasattr(os, 'fpathconf'), 'test needs os.fpathconf()')
-    @unittest.skipIf(
-        support.is_emscripten or support.is_wasi,
-        "musl libc issue on Emscripten/WASI, bpo-46390"
-    )
     def test_fpathconf(self):
         self.assertIn("PC_NAME_MAX", os.pathconf_names)
-        self.check(os.pathconf, "PC_NAME_MAX")
-        self.check(os.fpathconf, "PC_NAME_MAX")
         self.check_bool(os.pathconf, "PC_NAME_MAX")
         self.check_bool(os.fpathconf, "PC_NAME_MAX")
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.skipUnless(hasattr(os, 'fpathconf'), 'test needs os.fpathconf()')
+    @unittest.skipIf(
+        support.linked_to_musl(),
+        'musl pathconf ignores the file descriptor and returns a constant',
+        )
+    def test_fpathconf_bad_fd(self):
+        self.check(os.pathconf, "PC_NAME_MAX")
+        self.check(os.fpathconf, "PC_NAME_MAX")
+
     @unittest.skipUnless(hasattr(os, 'ftruncate'), 'test needs os.ftruncate()')
     def test_ftruncate(self):
         self.check(os.truncate, 0)
@@ -2435,6 +2583,10 @@ def test_lseek(self):
     def test_read(self):
         self.check(os.read, 1)
 
+    @unittest.skipUnless(hasattr(os, 'readinto'), 'test needs os.readinto()')
+    def test_readinto(self):
+        self.check(os.readinto, bytearray(5))
+
     @unittest.skipUnless(hasattr(os, 'readv'), 'test needs os.readv()')
     def test_readv(self):
         buf = bytearray(10)
@@ -2463,13 +2615,8 @@ def test_blocking(self):
         self.check(os.get_blocking)
         self.check(os.set_blocking, True)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
-    def test_fchdir(self):
-        return super().test_fchdir()
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
-    def test_fsync(self):
-        return super().test_fsync()
+
 
 
 @unittest.skipUnless(hasattr(os, 'link'), 'requires os.link')
@@ -3356,9 +3503,6 @@ def test_bad_fd(self):
     @unittest.skipUnless(os.isatty(0) and not win32_is_iot() and (sys.platform.startswith('win') or
             (hasattr(locale, 'nl_langinfo') and hasattr(locale, 'CODESET'))),
             'test requires a tty and either Windows or nl_langinfo(CODESET)')
-    @unittest.skipIf(
-        support.is_emscripten, "Cannot get encoding of stdin on Emscripten"
-    )
     def test_device_encoding(self):
         encoding = os.device_encoding(0)
         self.assertIsNotNone(encoding)
@@ -3487,7 +3631,6 @@ 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)
@@ -3516,7 +3659,6 @@ 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)
@@ -3540,7 +3682,6 @@ def test_nowait(self):
         pid = os.spawnv(os.P_NOWAIT, program, args)
         support.wait_process(pid, exitcode=self.exitcode)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON; fix spawnv bytes
     @requires_os_func('spawnve')
     def test_spawnve_bytes(self):
         # Test bytes handling in parse_arglist and parse_envlist (#28114)
@@ -3625,7 +3766,6 @@ 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)
 
@@ -4990,7 +5130,7 @@ def check_entry(self, entry, name, is_dir, is_file, is_symlink):
                                entry_lstat,
                                os.name == 'nt')
 
-    @unittest.skipIf(sys.platform == 'linux', 'TODO: RUSTPYTHON; flaky test')
+    @unittest.skipIf(sys.platform == "linux", "TODO: RUSTPYTHON; flaky test")
     def test_attributes(self):
         link = os_helper.can_hardlink()
         symlink = os_helper.can_symlink()
@@ -5172,7 +5312,6 @@ def test_bytes_like(self):
             with self.assertRaises(TypeError):
                 os.scandir(path_bytes)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     @unittest.skipUnless(os.listdir in os.supports_fd,
                          'fd support for listdir required for this test.')
     def test_fd(self):
@@ -5254,7 +5393,6 @@ def test_context_manager_exception(self):
         with self.check_no_resource_warning():
             del iterator
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_resource_warning(self):
         self.create_file("file.txt")
         self.create_file("file2.txt")
@@ -5294,8 +5432,8 @@ def test_fsencode_fsdecode(self):
 
     def test_pathlike(self):
         self.assertEqual('#feelthegil', self.fspath(FakePath('#feelthegil')))
-        self.assertTrue(issubclass(FakePath, os.PathLike))
-        self.assertTrue(isinstance(FakePath('x'), os.PathLike))
+        self.assertIsSubclass(FakePath, os.PathLike)
+        self.assertIsInstance(FakePath('x'), os.PathLike)
 
     def test_garbage_in_exception_out(self):
         vapor = type('blah', (), {})
@@ -5321,8 +5459,8 @@ def test_pathlike_subclasshook(self):
         # true on abstract implementation.
         class A(os.PathLike):
             pass
-        self.assertFalse(issubclass(FakePath, A))
-        self.assertTrue(issubclass(FakePath, os.PathLike))
+        self.assertNotIsSubclass(FakePath, A)
+        self.assertIsSubclass(FakePath, os.PathLike)
 
     def test_pathlike_class_getitem(self):
         self.assertIsInstance(os.PathLike[bytes], types.GenericAlias)
@@ -5332,7 +5470,7 @@ class A(os.PathLike):
             __slots__ = ()
             def __fspath__(self):
                 return ''
-        self.assertFalse(hasattr(A(), '__dict__'))
+        self.assertNotHasAttr(A(), '__dict__')
 
     def test_fspath_set_to_None(self):
         class Foo:
@@ -5436,7 +5574,6 @@ def test_fork_warns_when_non_python_thread_exists(self):
         self.assertEqual(err.decode("utf-8"), "")
         self.assertEqual(out.decode("utf-8"), "")
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_fork_at_finalization(self):
         code = """if 1:
             import atexit
diff --git a/Lib/test/test_osx_env.py b/Lib/test/test_osx_env.py
new file mode 100644
index 00000000000..80198edcb80
--- /dev/null
+++ b/Lib/test/test_osx_env.py
@@ -0,0 +1,34 @@
+"""
+Test suite for OS X interpreter environment variables.
+"""
+
+from test.support.os_helper import EnvironmentVarGuard
+import subprocess
+import sys
+import sysconfig
+import unittest
+
+@unittest.skipUnless(sys.platform == 'darwin' and
+                     sysconfig.get_config_var('WITH_NEXT_FRAMEWORK'),
+                     'unnecessary on this platform')
+class OSXEnvironmentVariableTestCase(unittest.TestCase):
+    def _check_sys(self, ev, cond, sv, val = sys.executable + 'dummy'):
+        with EnvironmentVarGuard() as evg:
+            subpc = [str(sys.executable), '-c',
+                'import sys; sys.exit(2 if "%s" %s %s else 3)' % (val, cond, sv)]
+            # ensure environment variable does not exist
+            evg.unset(ev)
+            # test that test on sys.xxx normally fails
+            rc = subprocess.call(subpc)
+            self.assertEqual(rc, 3, "expected %s not %s %s" % (ev, cond, sv))
+            # set environ variable
+            evg.set(ev, val)
+            # test that sys.xxx has been influenced by the environ value
+            rc = subprocess.call(subpc)
+            self.assertEqual(rc, 2, "expected %s %s %s" % (ev, cond, sv))
+
+    def test_pythonexecutable_sets_sys_executable(self):
+        self._check_sys('PYTHONEXECUTABLE', '==', 'sys.executable')
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/Lib/test/test_pathlib/support/__init__.py b/Lib/test/test_pathlib/support/__init__.py
new file mode 100644
index 00000000000..dcaef654d77
--- /dev/null
+++ b/Lib/test/test_pathlib/support/__init__.py
@@ -0,0 +1,2 @@
+# Set to 'True' if the tests are run against the pathlib-abc PyPI package.
+is_pypi = False
diff --git a/Lib/test/test_pathlib/support/lexical_path.py b/Lib/test/test_pathlib/support/lexical_path.py
new file mode 100644
index 00000000000..f29a521af9b
--- /dev/null
+++ b/Lib/test/test_pathlib/support/lexical_path.py
@@ -0,0 +1,51 @@
+"""
+Simple implementation of JoinablePath, for use in pathlib tests.
+"""
+
+import ntpath
+import os.path
+import posixpath
+
+from . import is_pypi
+
+if is_pypi:
+    from pathlib_abc import _JoinablePath
+else:
+    from pathlib.types import _JoinablePath
+
+
+class LexicalPath(_JoinablePath):
+    __slots__ = ('_segments',)
+    parser = os.path
+
+    def __init__(self, *pathsegments):
+        self._segments = pathsegments
+
+    def __hash__(self):
+        return hash(str(self))
+
+    def __eq__(self, other):
+        if not isinstance(other, LexicalPath):
+            return NotImplemented
+        return str(self) == str(other)
+
+    def __str__(self):
+        if not self._segments:
+            return ''
+        return self.parser.join(*self._segments)
+
+    def __repr__(self):
+        return f'{type(self).__name__}({str(self)!r})'
+
+    def with_segments(self, *pathsegments):
+        return type(self)(*pathsegments)
+
+
+class LexicalPosixPath(LexicalPath):
+    __slots__ = ()
+    parser = posixpath
+
+
+class LexicalWindowsPath(LexicalPath):
+    __slots__ = ()
+    parser = ntpath
diff --git a/Lib/test/test_pathlib/support/local_path.py b/Lib/test/test_pathlib/support/local_path.py
new file mode 100644
index 00000000000..d481fd45ead
--- /dev/null
+++ b/Lib/test/test_pathlib/support/local_path.py
@@ -0,0 +1,177 @@
+"""
+Implementations of ReadablePath and WritablePath for local paths, for use in
+pathlib tests.
+
+LocalPathGround is also defined here. It helps establish the "ground truth"
+about local paths in tests.
+"""
+
+import os
+
+from . import is_pypi
+from .lexical_path import LexicalPath
+
+if is_pypi:
+    from shutil import rmtree
+    from pathlib_abc import PathInfo, _ReadablePath, _WritablePath
+    can_symlink = True
+    testfn = "TESTFN"
+else:
+    from pathlib.types import PathInfo, _ReadablePath, _WritablePath
+    from test.support import os_helper
+    can_symlink = os_helper.can_symlink()
+    testfn = os_helper.TESTFN
+    rmtree = os_helper.rmtree
+
+
+class LocalPathGround:
+    can_symlink = can_symlink
+
+    def __init__(self, path_cls):
+        self.path_cls = path_cls
+
+    def setup(self, local_suffix=""):
+        root = self.path_cls(testfn + local_suffix)
+        os.mkdir(root)
+        return root
+
+    def teardown(self, root):
+        rmtree(root)
+
+    def create_file(self, p, data=b''):
+        with open(p, 'wb') as f:
+            f.write(data)
+
+    def create_dir(self, p):
+        os.mkdir(p)
+
+    def create_symlink(self, p, target):
+        os.symlink(target, p)
+
+    def create_hierarchy(self, p):
+        os.mkdir(os.path.join(p, 'dirA'))
+        os.mkdir(os.path.join(p, 'dirB'))
+        os.mkdir(os.path.join(p, 'dirC'))
+        os.mkdir(os.path.join(p, 'dirC', 'dirD'))
+        with open(os.path.join(p, 'fileA'), 'wb') as f:
+            f.write(b"this is file A\n")
+        with open(os.path.join(p, 'dirB', 'fileB'), 'wb') as f:
+            f.write(b"this is file B\n")
+        with open(os.path.join(p, 'dirC', 'fileC'), 'wb') as f:
+            f.write(b"this is file C\n")
+        with open(os.path.join(p, 'dirC', 'novel.txt'), 'wb') as f:
+            f.write(b"this is a novel\n")
+        with open(os.path.join(p, 'dirC', 'dirD', 'fileD'), 'wb') as f:
+            f.write(b"this is file D\n")
+        if self.can_symlink:
+            # Relative symlinks.
+            os.symlink('fileA', os.path.join(p, 'linkA'))
+            os.symlink('non-existing', os.path.join(p, 'brokenLink'))
+            os.symlink('dirB',
+                       os.path.join(p, 'linkB'),
+                       target_is_directory=True)
+            os.symlink(os.path.join('..', 'dirB'),
+                       os.path.join(p, 'dirA', 'linkC'),
+                       target_is_directory=True)
+            # Broken symlink (pointing to itself).
+            os.symlink('brokenLinkLoop', os.path.join(p, 'brokenLinkLoop'))
+
+    isdir = staticmethod(os.path.isdir)
+    isfile = staticmethod(os.path.isfile)
+    islink = staticmethod(os.path.islink)
+    readlink = staticmethod(os.readlink)
+
+    def readtext(self, p):
+        with open(p, 'r', encoding='utf-8') as f:
+            return f.read()
+
+    def readbytes(self, p):
+        with open(p, 'rb') as f:
+            return f.read()
+
+
+class LocalPathInfo(PathInfo):
+    """
+    Simple implementation of PathInfo for a local path
+    """
+    __slots__ = ('_path', '_exists', '_is_dir', '_is_file', '_is_symlink')
+
+    def __init__(self, path):
+        self._path = str(path)
+        self._exists = None
+        self._is_dir = None
+        self._is_file = None
+        self._is_symlink = None
+
+    def exists(self, *, follow_symlinks=True):
+        """Whether this path exists."""
+        if not follow_symlinks and self.is_symlink():
+            return True
+        if self._exists is None:
+            self._exists = os.path.exists(self._path)
+        return self._exists
+
+    def is_dir(self, *, follow_symlinks=True):
+        """Whether this path is a directory."""
+        if not follow_symlinks and self.is_symlink():
+            return False
+        if self._is_dir is None:
+            self._is_dir = os.path.isdir(self._path)
+        return self._is_dir
+
+    def is_file(self, *, follow_symlinks=True):
+        """Whether this path is a regular file."""
+        if not follow_symlinks and self.is_symlink():
+            return False
+        if self._is_file is None:
+            self._is_file = os.path.isfile(self._path)
+        return self._is_file
+
+    def is_symlink(self):
+        """Whether this path is a symbolic link."""
+        if self._is_symlink is None:
+            self._is_symlink = os.path.islink(self._path)
+        return self._is_symlink
+
+
+class ReadableLocalPath(_ReadablePath, LexicalPath):
+    """
+    Simple implementation of a ReadablePath class for local filesystem paths.
+    """
+    __slots__ = ('info',)
+
+    def __init__(self, *pathsegments):
+        super().__init__(*pathsegments)
+        self.info = LocalPathInfo(self)
+
+    def __fspath__(self):
+        return str(self)
+
+    def __open_rb__(self, buffering=-1):
+        return open(self, 'rb')
+
+    def iterdir(self):
+        return (self / name for name in os.listdir(self))
+
+    def readlink(self):
+        return self.with_segments(os.readlink(self))
+
+
+class WritableLocalPath(_WritablePath, LexicalPath):
+    """
+    Simple implementation of a WritablePath class for local filesystem paths.
+    """
+
+    __slots__ = ()
+
+    def __fspath__(self):
+        return str(self)
+
+    def __open_wb__(self, buffering=-1):
+        return open(self, 'wb')
+
+    def mkdir(self, mode=0o777):
+        os.mkdir(self, mode)
+
+    def symlink_to(self, target, target_is_directory=False):
+        os.symlink(target, self, target_is_directory)
diff --git a/Lib/test/test_pathlib/support/zip_path.py b/Lib/test/test_pathlib/support/zip_path.py
new file mode 100644
index 00000000000..2905260c9df
--- /dev/null
+++ b/Lib/test/test_pathlib/support/zip_path.py
@@ -0,0 +1,336 @@
+"""
+Implementations of ReadablePath and WritablePath for zip file members, for use
+in pathlib tests.
+
+ZipPathGround is also defined here. It helps establish the "ground truth"
+about zip file members in tests.
+"""
+
+import errno
+import io
+import posixpath
+import stat
+import zipfile
+from stat import S_IFMT, S_ISDIR, S_ISREG, S_ISLNK
+
+from . import is_pypi
+
+if is_pypi:
+    from pathlib_abc import PathInfo, _ReadablePath, _WritablePath
+else:
+    from pathlib.types import PathInfo, _ReadablePath, _WritablePath
+
+
+class ZipPathGround:
+    can_symlink = True
+
+    def __init__(self, path_cls):
+        self.path_cls = path_cls
+
+    def setup(self, local_suffix=""):
+        return self.path_cls(zip_file=zipfile.ZipFile(io.BytesIO(), "w"))
+
+    def teardown(self, root):
+        root.zip_file.close()
+
+    def create_file(self, path, data=b''):
+        path.zip_file.writestr(str(path), data)
+
+    def create_dir(self, path):
+        zip_info = zipfile.ZipInfo(str(path) + '/')
+        zip_info.external_attr |= stat.S_IFDIR << 16
+        zip_info.external_attr |= stat.FILE_ATTRIBUTE_DIRECTORY
+        path.zip_file.writestr(zip_info, '')
+
+    def create_symlink(self, path, target):
+        zip_info = zipfile.ZipInfo(str(path))
+        zip_info.external_attr = stat.S_IFLNK << 16
+        path.zip_file.writestr(zip_info, target.encode())
+
+    def create_hierarchy(self, p):
+        # Add regular files
+        self.create_file(p.joinpath('fileA'), b'this is file A\n')
+        self.create_file(p.joinpath('dirB/fileB'), b'this is file B\n')
+        self.create_file(p.joinpath('dirC/fileC'), b'this is file C\n')
+        self.create_file(p.joinpath('dirC/dirD/fileD'), b'this is file D\n')
+        self.create_file(p.joinpath('dirC/novel.txt'), b'this is a novel\n')
+        # Add symlinks
+        self.create_symlink(p.joinpath('linkA'), 'fileA')
+        self.create_symlink(p.joinpath('linkB'), 'dirB')
+        self.create_symlink(p.joinpath('dirA/linkC'), '../dirB')
+        self.create_symlink(p.joinpath('brokenLink'), 'non-existing')
+        self.create_symlink(p.joinpath('brokenLinkLoop'), 'brokenLinkLoop')
+
+    def readtext(self, p):
+        with p.zip_file.open(str(p), 'r') as f:
+            f = io.TextIOWrapper(f, encoding='utf-8')
+            return f.read()
+
+    def readbytes(self, p):
+        with p.zip_file.open(str(p), 'r') as f:
+            return f.read()
+
+    readlink = readtext
+
+    def isdir(self, p):
+        path_str = str(p) + "/"
+        return path_str in p.zip_file.NameToInfo
+
+    def isfile(self, p):
+        info = p.zip_file.NameToInfo.get(str(p))
+        if info is None:
+            return False
+        return not stat.S_ISLNK(info.external_attr >> 16)
+
+    def islink(self, p):
+        info = p.zip_file.NameToInfo.get(str(p))
+        if info is None:
+            return False
+        return stat.S_ISLNK(info.external_attr >> 16)
+
+
+class MissingZipPathInfo(PathInfo):
+    """
+    PathInfo implementation that is used when a zip file member is missing.
+    """
+    __slots__ = ()
+
+    def exists(self, follow_symlinks=True):
+        return False
+
+    def is_dir(self, follow_symlinks=True):
+        return False
+
+    def is_file(self, follow_symlinks=True):
+        return False
+
+    def is_symlink(self):
+        return False
+
+    def resolve(self):
+        return self
+
+
+missing_zip_path_info = MissingZipPathInfo()
+
+
+class ZipPathInfo(PathInfo):
+    """
+    PathInfo implementation for an existing zip file member.
+    """
+    __slots__ = ('zip_file', 'zip_info', 'parent', 'children')
+
+    def __init__(self, zip_file, parent=None):
+        self.zip_file = zip_file
+        self.zip_info = None
+        self.parent = parent or self
+        self.children = {}
+
+    def exists(self, follow_symlinks=True):
+        if follow_symlinks and self.is_symlink():
+            return self.resolve().exists()
+        return True
+
+    def is_dir(self, follow_symlinks=True):
+        if follow_symlinks and self.is_symlink():
+            return self.resolve().is_dir()
+        elif self.zip_info is None:
+            return True
+        elif fmt := S_IFMT(self.zip_info.external_attr >> 16):
+            return S_ISDIR(fmt)
+        else:
+            return self.zip_info.filename.endswith('/')
+
+    def is_file(self, follow_symlinks=True):
+        if follow_symlinks and self.is_symlink():
+            return self.resolve().is_file()
+        elif self.zip_info is None:
+            return False
+        elif fmt := S_IFMT(self.zip_info.external_attr >> 16):
+            return S_ISREG(fmt)
+        else:
+            return not self.zip_info.filename.endswith('/')
+
+    def is_symlink(self):
+        if self.zip_info is None:
+            return False
+        elif fmt := S_IFMT(self.zip_info.external_attr >> 16):
+            return S_ISLNK(fmt)
+        else:
+            return False
+
+    def resolve(self, path=None, create=False, follow_symlinks=True):
+        """
+        Traverse zip hierarchy (parents, children and symlinks) starting
+        from this PathInfo. This is called from three places:
+
+        - When a zip file member is added to ZipFile.filelist, this method
+          populates the ZipPathInfo tree (using create=True).
+        - When ReadableZipPath.info is accessed, this method is finds a
+          ZipPathInfo entry for the path without resolving any final symlink
+          (using follow_symlinks=False)
+        - When ZipPathInfo methods are called with follow_symlinks=True, this
+          method resolves any symlink in the final path position.
+        """
+        link_count = 0
+        stack = path.split('/')[::-1] if path else []
+        info = self
+        while True:
+            if info.is_symlink() and (follow_symlinks or stack):
+                link_count += 1
+                if link_count >= 40:
+                    return missing_zip_path_info  # Symlink loop!
+                path = info.zip_file.read(info.zip_info).decode()
+                stack += path.split('/')[::-1] if path else []
+                info = info.parent
+
+            if stack:
+                name = stack.pop()
+            else:
+                return info
+
+            if name == '..':
+                info = info.parent
+            elif name and name != '.':
+                if name not in info.children:
+                    if create:
+                        info.children[name] = ZipPathInfo(info.zip_file, info)
+                    else:
+                        return missing_zip_path_info  # No such child!
+                info = info.children[name]
+
+
+class ZipFileList:
+    """
+    `list`-like object that we inject as `ZipFile.filelist`. We maintain a
+    tree of `ZipPathInfo` objects representing the zip file members.
+    """
+
+    __slots__ = ('tree', '_items')
+
+    def __init__(self, zip_file):
+        self.tree = ZipPathInfo(zip_file)
+        self._items = []
+        for item in zip_file.filelist:
+            self.append(item)
+
+    def __len__(self):
+        return len(self._items)
+
+    def __iter__(self):
+        return iter(self._items)
+
+    def append(self, item):
+        self._items.append(item)
+        self.tree.resolve(item.filename, create=True).zip_info = item
+
+
+class ReadableZipPath(_ReadablePath):
+    """
+    Simple implementation of a ReadablePath class for .zip files.
+    """
+
+    __slots__ = ('_segments', 'zip_file')
+    parser = posixpath
+
+    def __init__(self, *pathsegments, zip_file):
+        self._segments = pathsegments
+        self.zip_file = zip_file
+        if not isinstance(zip_file.filelist, ZipFileList):
+            zip_file.filelist = ZipFileList(zip_file)
+
+    def __hash__(self):
+        return hash((str(self), self.zip_file))
+
+    def __eq__(self, other):
+        if not isinstance(other, ReadableZipPath):
+            return NotImplemented
+        return str(self) == str(other) and self.zip_file is other.zip_file
+
+    def __str__(self):
+        if not self._segments:
+            return ''
+        return self.parser.join(*self._segments)
+
+    def __repr__(self):
+        return f'{type(self).__name__}({str(self)!r}, zip_file={self.zip_file!r})'
+
+    def with_segments(self, *pathsegments):
+        return type(self)(*pathsegments, zip_file=self.zip_file)
+
+    @property
+    def info(self):
+        tree = self.zip_file.filelist.tree
+        return tree.resolve(str(self), follow_symlinks=False)
+
+    def __open_rb__(self, buffering=-1):
+        info = self.info.resolve()
+        if not info.exists():
+            raise FileNotFoundError(errno.ENOENT, "File not found", self)
+        elif info.is_dir():
+            raise IsADirectoryError(errno.EISDIR, "Is a directory", self)
+        return self.zip_file.open(info.zip_info, 'r')
+
+    def iterdir(self):
+        info = self.info.resolve()
+        if not info.exists():
+            raise FileNotFoundError(errno.ENOENT, "File not found", self)
+        elif not info.is_dir():
+            raise NotADirectoryError(errno.ENOTDIR, "Not a directory", self)
+        return (self / name for name in info.children)
+
+    def readlink(self):
+        info = self.info
+        if not info.exists():
+            raise FileNotFoundError(errno.ENOENT, "File not found", self)
+        elif not info.is_symlink():
+            raise OSError(errno.EINVAL, "Not a symlink", self)
+        return self.with_segments(self.zip_file.read(info.zip_info).decode())
+
+
+class WritableZipPath(_WritablePath):
+    """
+    Simple implementation of a WritablePath class for .zip files.
+    """
+
+    __slots__ = ('_segments', 'zip_file')
+    parser = posixpath
+
+    def __init__(self, *pathsegments, zip_file):
+        self._segments = pathsegments
+        self.zip_file = zip_file
+
+    def __hash__(self):
+        return hash((str(self), self.zip_file))
+
+    def __eq__(self, other):
+        if not isinstance(other, WritableZipPath):
+            return NotImplemented
+        return str(self) == str(other) and self.zip_file is other.zip_file
+
+    def __str__(self):
+        if not self._segments:
+            return ''
+        return self.parser.join(*self._segments)
+
+    def __repr__(self):
+        return f'{type(self).__name__}({str(self)!r}, zip_file={self.zip_file!r})'
+
+    def with_segments(self, *pathsegments):
+        return type(self)(*pathsegments, zip_file=self.zip_file)
+
+    def __open_wb__(self, buffering=-1):
+        return self.zip_file.open(str(self), 'w')
+
+    def mkdir(self, mode=0o777):
+        zinfo = zipfile.ZipInfo(str(self) + '/')
+        zinfo.external_attr |= stat.S_IFDIR << 16
+        zinfo.external_attr |= stat.FILE_ATTRIBUTE_DIRECTORY
+        self.zip_file.writestr(zinfo, '')
+
+    def symlink_to(self, target, target_is_directory=False):
+        zinfo = zipfile.ZipInfo(str(self))
+        zinfo.external_attr = stat.S_IFLNK << 16
+        if target_is_directory:
+            zinfo.external_attr |= 0x10
+        self.zip_file.writestr(zinfo, str(target))
diff --git a/Lib/test/test_pathlib/test_copy.py b/Lib/test/test_pathlib/test_copy.py
new file mode 100644
index 00000000000..5f4cf82a031
--- /dev/null
+++ b/Lib/test/test_pathlib/test_copy.py
@@ -0,0 +1,174 @@
+"""
+Tests for copying from pathlib.types._ReadablePath to _WritablePath.
+"""
+
+import contextlib
+import unittest
+
+from .support import is_pypi
+from .support.local_path import LocalPathGround
+from .support.zip_path import ZipPathGround, ReadableZipPath, WritableZipPath
+
+
+class CopyTestBase:
+    def setUp(self):
+        self.source_root = self.source_ground.setup()
+        self.source_ground.create_hierarchy(self.source_root)
+        self.target_root = self.target_ground.setup(local_suffix="_target")
+
+    def tearDown(self):
+        self.source_ground.teardown(self.source_root)
+        self.target_ground.teardown(self.target_root)
+
+    def test_copy_file(self):
+        source = self.source_root / 'fileA'
+        target = self.target_root / 'copyA'
+        result = source.copy(target)
+        self.assertEqual(result, target)
+        self.assertTrue(self.target_ground.isfile(target))
+        self.assertEqual(self.source_ground.readbytes(source),
+                         self.target_ground.readbytes(result))
+
+    def test_copy_file_empty(self):
+        source = self.source_root / 'empty'
+        target = self.target_root / 'copyA'
+        self.source_ground.create_file(source, b'')
+        result = source.copy(target)
+        self.assertEqual(result, target)
+        self.assertTrue(self.target_ground.isfile(target))
+        self.assertEqual(self.target_ground.readbytes(result), b'')
+
+    def test_copy_file_to_existing_file(self):
+        source = self.source_root / 'fileA'
+        target = self.target_root / 'copyA'
+        self.target_ground.create_file(target, b'this is a copy\n')
+        with contextlib.ExitStack() as stack:
+            if isinstance(target, WritableZipPath):
+                stack.enter_context(self.assertWarns(UserWarning))
+            result = source.copy(target)
+        self.assertEqual(result, target)
+        self.assertTrue(self.target_ground.isfile(target))
+        self.assertEqual(self.source_ground.readbytes(source),
+                         self.target_ground.readbytes(result))
+
+    def test_copy_file_to_directory(self):
+        if isinstance(self.target_root, WritableZipPath):
+            self.skipTest('needs local target')
+        source = self.source_root / 'fileA'
+        target = self.target_root / 'copyA'
+        self.target_ground.create_dir(target)
+        self.assertRaises(OSError, source.copy, target)
+
+    def test_copy_file_to_itself(self):
+        source = self.source_root / 'fileA'
+        self.assertRaises(OSError, source.copy, source)
+        self.assertRaises(OSError, source.copy, source, follow_symlinks=False)
+
+    def test_copy_dir(self):
+        source = self.source_root / 'dirC'
+        target = self.target_root / 'copyC'
+        result = source.copy(target)
+        self.assertEqual(result, target)
+        self.assertTrue(self.target_ground.isdir(target))
+        self.assertTrue(self.target_ground.isfile(target / 'fileC'))
+        self.assertEqual(self.target_ground.readtext(target / 'fileC'), 'this is file C\n')
+        self.assertTrue(self.target_ground.isdir(target / 'dirD'))
+        self.assertTrue(self.target_ground.isfile(target / 'dirD' / 'fileD'))
+        self.assertEqual(self.target_ground.readtext(target / 'dirD' / 'fileD'), 'this is file D\n')
+
+    def test_copy_dir_follow_symlinks_true(self):
+        if not self.source_ground.can_symlink:
+            self.skipTest('needs symlink support on source')
+        source = self.source_root / 'dirC'
+        target = self.target_root / 'copyC'
+        self.source_ground.create_symlink(source / 'linkC', 'fileC')
+        self.source_ground.create_symlink(source / 'linkD', 'dirD')
+        result = source.copy(target)
+        self.assertEqual(result, target)
+        self.assertTrue(self.target_ground.isdir(target))
+        self.assertFalse(self.target_ground.islink(target / 'linkC'))
+        self.assertTrue(self.target_ground.isfile(target / 'linkC'))
+        self.assertEqual(self.target_ground.readtext(target / 'linkC'), 'this is file C\n')
+        self.assertFalse(self.target_ground.islink(target / 'linkD'))
+        self.assertTrue(self.target_ground.isdir(target / 'linkD'))
+        self.assertTrue(self.target_ground.isfile(target / 'linkD' / 'fileD'))
+        self.assertEqual(self.target_ground.readtext(target / 'linkD' / 'fileD'), 'this is file D\n')
+
+    def test_copy_dir_follow_symlinks_false(self):
+        if not self.source_ground.can_symlink:
+            self.skipTest('needs symlink support on source')
+        if not self.target_ground.can_symlink:
+            self.skipTest('needs symlink support on target')
+        source = self.source_root / 'dirC'
+        target = self.target_root / 'copyC'
+        self.source_ground.create_symlink(source / 'linkC', 'fileC')
+        self.source_ground.create_symlink(source / 'linkD', 'dirD')
+        result = source.copy(target, follow_symlinks=False)
+        self.assertEqual(result, target)
+        self.assertTrue(self.target_ground.isdir(target))
+        self.assertTrue(self.target_ground.islink(target / 'linkC'))
+        self.assertEqual(self.target_ground.readlink(target / 'linkC'), 'fileC')
+        self.assertTrue(self.target_ground.islink(target / 'linkD'))
+        self.assertEqual(self.target_ground.readlink(target / 'linkD'), 'dirD')
+
+    def test_copy_dir_to_existing_directory(self):
+        if isinstance(self.target_root, WritableZipPath):
+            self.skipTest('needs local target')
+        source = self.source_root / 'dirC'
+        target = self.target_root / 'copyC'
+        self.target_ground.create_dir(target)
+        self.assertRaises(FileExistsError, source.copy, target)
+
+    def test_copy_dir_to_itself(self):
+        source = self.source_root / 'dirC'
+        self.assertRaises(OSError, source.copy, source)
+        self.assertRaises(OSError, source.copy, source, follow_symlinks=False)
+
+    def test_copy_dir_into_itself(self):
+        source = self.source_root / 'dirC'
+        target = self.source_root / 'dirC' / 'dirD' / 'copyC'
+        self.assertRaises(OSError, source.copy, target)
+        self.assertRaises(OSError, source.copy, target, follow_symlinks=False)
+
+    def test_copy_into(self):
+        source = self.source_root / 'fileA'
+        target_dir = self.target_root / 'dirA'
+        self.target_ground.create_dir(target_dir)
+        result = source.copy_into(target_dir)
+        self.assertEqual(result, target_dir / 'fileA')
+        self.assertTrue(self.target_ground.isfile(result))
+        self.assertEqual(self.source_ground.readbytes(source),
+                         self.target_ground.readbytes(result))
+
+    def test_copy_into_empty_name(self):
+        source = self.source_root.with_segments()
+        target_dir = self.target_root / 'dirA'
+        self.target_ground.create_dir(target_dir)
+        self.assertRaises(ValueError, source.copy_into, target_dir)
+
+
+class ZipToZipPathCopyTest(CopyTestBase, unittest.TestCase):
+    source_ground = ZipPathGround(ReadableZipPath)
+    target_ground = ZipPathGround(WritableZipPath)
+
+
+if not is_pypi:
+    from pathlib import Path
+
+    class ZipToLocalPathCopyTest(CopyTestBase, unittest.TestCase):
+        source_ground = ZipPathGround(ReadableZipPath)
+        target_ground = LocalPathGround(Path)
+
+
+    class LocalToZipPathCopyTest(CopyTestBase, unittest.TestCase):
+        source_ground = LocalPathGround(Path)
+        target_ground = ZipPathGround(WritableZipPath)
+
+
+    class LocalToLocalPathCopyTest(CopyTestBase, unittest.TestCase):
+        source_ground = LocalPathGround(Path)
+        target_ground = LocalPathGround(Path)
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/Lib/test/test_pathlib/test_join.py b/Lib/test/test_pathlib/test_join.py
new file mode 100644
index 00000000000..6b51a09e5ac
--- /dev/null
+++ b/Lib/test/test_pathlib/test_join.py
@@ -0,0 +1,395 @@
+"""
+Tests for pathlib.types._JoinablePath
+"""
+
+import unittest
+import threading
+from test.support import threading_helper
+
+from .support import is_pypi
+from .support.lexical_path import LexicalPath
+
+if is_pypi:
+    from pathlib_abc import _PathParser, _JoinablePath
+else:
+    from pathlib.types import _PathParser, _JoinablePath
+
+
+class JoinTestBase:
+    def test_is_joinable(self):
+        p = self.cls()
+        self.assertIsInstance(p, _JoinablePath)
+
+    def test_parser(self):
+        self.assertIsInstance(self.cls.parser, _PathParser)
+
+    def test_constructor(self):
+        P = self.cls
+        p = P('a')
+        self.assertIsInstance(p, P)
+        P()
+        P('a', 'b', 'c')
+        P('/a', 'b', 'c')
+        P('a/b/c')
+        P('/a/b/c')
+
+    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('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.parent.session_id)
+        for parent in p.parents:
+            self.assertEqual(42, parent.session_id)
+
+    def test_join(self):
+        P = self.cls
+        sep = self.cls.parser.sep
+        p = P(f'a{sep}b')
+        pp = p.joinpath('c')
+        self.assertEqual(pp, P(f'a{sep}b{sep}c'))
+        self.assertIs(type(pp), type(p))
+        pp = p.joinpath('c', 'd')
+        self.assertEqual(pp, P(f'a{sep}b{sep}c{sep}d'))
+        pp = p.joinpath(f'{sep}c')
+        self.assertEqual(pp, P(f'{sep}c'))
+
+    def test_div(self):
+        # Basically the same as joinpath().
+        P = self.cls
+        sep = self.cls.parser.sep
+        p = P(f'a{sep}b')
+        pp = p / 'c'
+        self.assertEqual(pp, P(f'a{sep}b{sep}c'))
+        self.assertIs(type(pp), type(p))
+        pp = p / f'c{sep}d'
+        self.assertEqual(pp, P(f'a{sep}b{sep}c{sep}d'))
+        pp = p / 'c' / 'd'
+        self.assertEqual(pp, P(f'a{sep}b{sep}c{sep}d'))
+        pp = 'c' / p / 'd'
+        self.assertEqual(pp, P(f'c{sep}a{sep}b{sep}d'))
+        pp = p/ f'{sep}c'
+        self.assertEqual(pp, P(f'{sep}c'))
+
+    def test_full_match(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'))
+        # 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(self):
+        # `parts` returns a tuple.
+        sep = self.cls.parser.sep
+        P = self.cls
+        p = P(f'a{sep}b')
+        parts = p.parts
+        self.assertEqual(parts, ('a', 'b'))
+        # When the path is absolute, the anchor is a separate part.
+        p = P(f'{sep}a{sep}b')
+        parts = p.parts
+        self.assertEqual(parts, (sep, 'a', 'b'))
+
+    @threading_helper.requires_working_threading()
+    def test_parts_multithreaded(self):
+        P = self.cls
+
+        NUM_THREADS = 10
+        NUM_ITERS = 10
+
+        for _ in range(NUM_ITERS):
+            b = threading.Barrier(NUM_THREADS)
+            path = P('a') / 'b' / 'c' / 'd' / 'e'
+            expected = ('a', 'b', 'c', 'd', 'e')
+
+            def check_parts():
+                b.wait()
+                self.assertEqual(path.parts, expected)
+
+            threads = [threading.Thread(target=check_parts) for _ in range(NUM_THREADS)]
+            with threading_helper.start_threads(threads):
+                pass
+
+    def test_parent(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(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_anchor(self):
+        P = self.cls
+        sep = self.cls.parser.sep
+        self.assertEqual(P('').anchor, '')
+        self.assertEqual(P(f'a{sep}b').anchor, '')
+        self.assertEqual(P(sep).anchor, sep)
+        self.assertEqual(P(f'{sep}a{sep}b').anchor, sep)
+
+    def test_name(self):
+        P = self.cls
+        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.py').name, 'b.py')
+        self.assertEqual(P('/a/b.py').name, 'b.py')
+
+    def test_suffix(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/trailing.dot.').suffix, '.')
+        self.assertEqual(P('/a/trailing.dot.').suffix, '.')
+        self.assertEqual(P('a/..d.o.t..').suffix, '.')
+        self.assertEqual(P('a/inn.er..dots').suffix, '.dots')
+        self.assertEqual(P('photo').suffix, '')
+        self.assertEqual(P('photo.jpg').suffix, '.jpg')
+
+    def test_suffixes(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/trailing.dot.').suffixes, ['.dot', '.'])
+        self.assertEqual(P('/a/trailing.dot.').suffixes, ['.dot', '.'])
+        self.assertEqual(P('a/..d.o.t..').suffixes, ['.o', '.t', '.', '.'])
+        self.assertEqual(P('a/inn.er..dots').suffixes, ['.er', '.', '.dots'])
+        self.assertEqual(P('photo').suffixes, [])
+        self.assertEqual(P('photo.jpg').suffixes, ['.jpg'])
+
+    def test_stem(self):
+        P = self.cls
+        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/trailing.dot.').stem, 'trailing.dot')
+        self.assertEqual(P('a/..d.o.t..').stem, '..d.o.t.')
+        self.assertEqual(P('a/inn.er..dots').stem, 'inn.er.')
+        self.assertEqual(P('photo').stem, 'photo')
+        self.assertEqual(P('photo.jpg').stem, 'photo')
+
+    def test_with_name(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('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(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('foo.gz').with_stem, '')
+        self.assertRaises(ValueError, P('/a/b/foo.gz').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(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'))
+        # Single dot
+        self.assertEqual(P('a/b').with_suffix('.'), P('a/b.'))
+        self.assertEqual(P('/a/b').with_suffix('.'), P('/a/b.'))
+        self.assertEqual(P('a/b.py').with_suffix('.'), P('a/b.'))
+        self.assertEqual(P('/a/b.py').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')
+        # 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, '/.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)
+
+
+class LexicalPathJoinTest(JoinTestBase, unittest.TestCase):
+    cls = LexicalPath
+
+
+if not is_pypi:
+    from pathlib import PurePath, Path
+
+    class PurePathJoinTest(JoinTestBase, unittest.TestCase):
+        cls = PurePath
+
+    class PathJoinTest(JoinTestBase, unittest.TestCase):
+        cls = Path
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/Lib/test/test_pathlib/test_join_posix.py b/Lib/test/test_pathlib/test_join_posix.py
new file mode 100644
index 00000000000..d24fb1087c9
--- /dev/null
+++ b/Lib/test/test_pathlib/test_join_posix.py
@@ -0,0 +1,51 @@
+"""
+Tests for Posix-flavoured pathlib.types._JoinablePath
+"""
+
+import os
+import unittest
+
+from .support import is_pypi
+from .support.lexical_path import LexicalPosixPath
+
+
+class JoinTestBase:
+    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'))
+
+
+class LexicalPosixPathJoinTest(JoinTestBase, unittest.TestCase):
+    cls = LexicalPosixPath
+
+
+if not is_pypi:
+    from pathlib import PurePosixPath, PosixPath
+
+    class PurePosixPathJoinTest(JoinTestBase, unittest.TestCase):
+        cls = PurePosixPath
+
+    if os.name != 'nt':
+        class PosixPathJoinTest(JoinTestBase, unittest.TestCase):
+            cls = PosixPath
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/Lib/test/test_pathlib/test_join_windows.py b/Lib/test/test_pathlib/test_join_windows.py
new file mode 100644
index 00000000000..2cc634f25ef
--- /dev/null
+++ b/Lib/test/test_pathlib/test_join_windows.py
@@ -0,0 +1,290 @@
+"""
+Tests for Windows-flavoured pathlib.types._JoinablePath
+"""
+
+import os
+import unittest
+
+from .support import is_pypi
+from .support.lexical_path import LexicalWindowsPath
+
+
+class JoinTestBase:
+    def test_join(self):
+        P = self.cls
+        p = P('C:/a/b')
+        pp = p.joinpath('x/y')
+        self.assertEqual(pp, P(r'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(r'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('./d:s')
+        self.assertEqual(pp, P(r'C:/a/b\./d:s'))
+        pp = p.joinpath('./dd:s')
+        self.assertEqual(pp, P(r'C:/a/b\./dd:s'))
+        pp = p.joinpath('E:d:s')
+        self.assertEqual(pp, P('E:d:s'))
+        # Joining onto a UNC path with no root
+        pp = P('//server').joinpath('share')
+        self.assertEqual(pp, P(r'//server\share'))
+        pp = P('//./BootPartition').joinpath('Windows')
+        self.assertEqual(pp, P(r'//./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(r'C:/a/b\x/y'))
+        self.assertEqual(p / 'x' / 'y', P(r'C:/a/b\x\y'))
+        self.assertEqual(p / '/x/y', P('C:/x/y'))
+        self.assertEqual(p / '/x' / 'y', P(r'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(r'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 / './d:s', P(r'C:/a/b\./d:s'))
+        self.assertEqual(p / './dd:s', P(r'C:/a/b\./dd:s'))
+        self.assertEqual(p / 'E:d:s', P('E:d:s'))
+
+    def test_str(self):
+        p = self.cls(r'a\b\c')
+        self.assertEqual(str(p), 'a\\b\\c')
+        p = self.cls(r'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(r'\\a\b\c')
+        self.assertEqual(str(p), '\\\\a\\b\\c')
+        p = self.cls(r'\\a\b\c\d')
+        self.assertEqual(str(p), '\\\\a\\b\\c\\d')
+
+    def test_parts(self):
+        P = self.cls
+        p = P(r'c:a\b')
+        parts = p.parts
+        self.assertEqual(parts, ('c:', 'a', 'b'))
+        p = P(r'c:\a\b')
+        parts = p.parts
+        self.assertEqual(parts, ('c:\\', 'a', 'b'))
+        p = P(r'\\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_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\\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_stem(self):
+        P = self.cls
+        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/trailing.dot.').stem, 'trailing.dot')
+
+    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/trailing.dot.').suffix, '.')
+        self.assertEqual(P('c:/a/trailing.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/trailing.dot.').suffixes, ['.dot', '.'])
+        self.assertEqual(P('c:/a/trailing.dot.').suffixes, ['.dot', '.'])
+
+    def test_with_name(self):
+        P = self.cls
+        self.assertEqual(P(r'c:a\b').with_name('d.xml'), P(r'c:a\d.xml'))
+        self.assertEqual(P(r'c:\a\b').with_name('d.xml'), P(r'c:\a\d.xml'))
+        self.assertEqual(P(r'c:a\Dot ending.').with_name('d.xml'), P(r'c:a\d.xml'))
+        self.assertEqual(P(r'c:\a\Dot ending.').with_name('d.xml'), P(r'c:\a\d.xml'))
+        self.assertRaises(ValueError, P(r'c:a\b').with_name, r'd:\e')
+        self.assertRaises(ValueError, P(r'c:a\b').with_name, r'\\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: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('//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)
+
+
+class LexicalWindowsPathJoinTest(JoinTestBase, unittest.TestCase):
+    cls = LexicalWindowsPath
+
+
+if not is_pypi:
+    from pathlib import PureWindowsPath, WindowsPath
+
+    class PureWindowsPathJoinTest(JoinTestBase, unittest.TestCase):
+        cls = PureWindowsPath
+
+    if os.name == 'nt':
+        class WindowsPathJoinTest(JoinTestBase, unittest.TestCase):
+            cls = WindowsPath
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/Lib/test/test_pathlib/test_pathlib.py b/Lib/test/test_pathlib/test_pathlib.py
index 6cbc15d7675..a1ea69a6b90 100644
--- a/Lib/test/test_pathlib/test_pathlib.py
+++ b/Lib/test/test_pathlib/test_pathlib.py
@@ -1,5 +1,5 @@
-# TODO: RUSTPYTHON
-# Has not been tested with Windows style paths
+import collections
+import contextlib
 import io
 import os
 import sys
@@ -16,28 +16,82 @@
 from urllib.request import pathname2url
 
 from test.support import import_helper
-from test.support import is_emscripten, is_wasi
+from test.support import cpython_only
+from test.support import is_emscripten, is_wasi, is_wasm32
 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 fcntl
+except ImportError:
+    fcntl = None
 try:
     import grp, pwd
 except ImportError:
     grp = pwd = None
+try:
+    import posix
+except ImportError:
+    posix = None
 
 
 root_in_posix = False
 if hasattr(os, 'geteuid'):
     root_in_posix = (os.geteuid() == 0)
 
+
+def patch_replace(old_test):
+    def new_replace(self, target):
+        raise OSError(errno.EXDEV, "Cross-device link", self, target)
+
+    def new_test(self):
+        old_replace = self.cls.replace
+        self.cls.replace = new_replace
+        try:
+            old_test(self)
+        finally:
+            self.cls.replace = old_replace
+    return new_test
+
+
+_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.assertIsSubclass(pathlib.UnsupportedOperation, NotImplementedError)
+        self.assertIsInstance(pathlib.UnsupportedOperation(), NotImplementedError)
+
+
+class LazyImportTest(unittest.TestCase):
+    @cpython_only
+    def test_lazy_import(self):
+        import_helper.ensure_lazy_imports("pathlib", {"shutil"})
+
+
 #
 # Tests for the pure classes.
 #
 
-class PurePathTest(test_pathlib_abc.DummyPurePathTest):
+class PurePathTest(unittest.TestCase):
     cls = pathlib.PurePath
 
     # Make sure any symbolic links in the base test path are resolved.
@@ -59,6 +113,72 @@ class PurePathTest(test_pathlib_abc.DummyPurePathTest):
             ],
     }
 
+    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 _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 _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_concrete_class(self):
         if self.cls is pathlib.PurePath:
             expected = pathlib.PureWindowsPath if os.name == 'nt' else pathlib.PurePosixPath
@@ -150,15 +270,6 @@ def test_empty_path(self):
         # 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'))
@@ -182,6 +293,12 @@ def test_pickling_common(self):
                     self.assertEqual(hash(pp), hash(p))
                     self.assertEqual(str(pp), str(p))
 
+    def test_unpicking_3_13(self):
+        data = (b"\x80\x04\x95'\x00\x00\x00\x00\x00\x00\x00\x8c\x0e"
+                b"pathlib._local\x94\x8c\rPurePosixPath\x94\x93\x94)R\x94.")
+        p = pickle.loads(data)
+        self.assertIsInstance(p, pathlib.PurePosixPath)
+
     def test_repr_common(self):
         for pathstr in ('a', 'a/b', 'a/b/c', '/', '/a/b', '/a/b/c'):
             with self.subTest(pathstr=pathstr):
@@ -189,8 +306,8 @@ def test_repr_common(self):
                 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)
+                self.assertStartsWith(r, clsname + '(')
+                self.assertEndsWith(r, ')')
                 inner = r[len(clsname) + 1 : -1]
                 self.assertEqual(eval(inner), p.as_posix())
 
@@ -200,6 +317,31 @@ def test_fspath_common(self):
         self._check_str(p.__fspath__(), ('a/b',))
         self._check_str(os.fspath(p), ('a/b',))
 
+    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 test_bytes_exc_message(self):
         P = self.cls
         message = (r"argument should be a str or an os\.PathLike object "
@@ -216,6 +358,12 @@ def test_as_bytes_common(self):
         P = self.cls
         self.assertEqual(bytes(P('a/b')), b'a' + sep + b'b')
 
+    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_eq_common(self):
         P = self.cls
         self.assertEqual(P('a/b'), P('a/b'))
@@ -277,12 +425,18 @@ def assertLess(a, b):
         with self.assertRaises(TypeError):
             P() < {}
 
+    def make_uri(self, path):
+        if isinstance(path, pathlib.Path):
+            return path.as_uri()
+        with self.assertWarns(DeprecationWarning):
+            return path.as_uri()
+
     def test_as_uri_common(self):
         P = self.cls
         with self.assertRaises(ValueError):
-            P('a').as_uri()
+            self.make_uri(P('a'))
         with self.assertRaises(ValueError):
-            P().as_uri()
+            self.make_uri(P())
 
     def test_repr_roundtrips(self):
         for pathstr in ('a', 'a/b', 'a/b/c', '/', '/a/b', '/a/b/c'):
@@ -295,6 +449,51 @@ def test_repr_roundtrips(self):
                 self.assertEqual(q, p)
                 self.assertEqual(repr(q), r)
 
+    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_name_empty(self):
         P = self.cls
         self.assertEqual(P('').name, '')
@@ -306,6 +505,18 @@ def test_stem_empty(self):
         self.assertEqual(P('').stem, '')
         self.assertEqual(P('.').stem, '')
 
+    @needs_windows
+    def test_with_name_windows(self):
+        P = self.cls
+        self.assertRaises(ValueError, P(r'c:').with_name, 'd.xml')
+        self.assertRaises(ValueError, P(r'c:\\').with_name, 'd.xml')
+        self.assertRaises(ValueError, P(r'\\My\Share').with_name, 'd.xml')
+        # NTFS alternate data streams
+        self.assertEqual(str(P('a').with_name('d:')), '.\\d:')
+        self.assertEqual(str(P('a').with_name('d:e')), '.\\d:e')
+        self.assertEqual(P(r'c:a\b').with_name('d:'), P(r'c:a\d:'))
+        self.assertEqual(P(r'c:a\b').with_name('d:e'), P(r'c:a\d:e'))
+
     def test_with_name_empty(self):
         P = self.cls
         self.assertRaises(ValueError, P('').with_name, 'd.xml')
@@ -314,6 +525,18 @@ def test_with_name_empty(self):
         self.assertRaises(ValueError, P('a/b').with_name, '')
         self.assertRaises(ValueError, P('a/b').with_name, '.')
 
+    @needs_windows
+    def test_with_stem_windows(self):
+        P = self.cls
+        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')
+        # NTFS alternate data streams
+        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'))
+
     def test_with_stem_empty(self):
         P = self.cls
         self.assertRaises(ValueError, P('').with_stem, 'd')
@@ -322,30 +545,102 @@ def test_with_stem_empty(self):
         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_full_match_case_sensitive(self):
+        P = self.cls
+        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))
+
     def test_match_empty(self):
         P = self.cls
         self.assertRaises(ValueError, P('a').match, '')
         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 '/'
+
     @needs_posix
     def test_parse_path_posix(self):
         check = self._check_parse_path
@@ -369,9 +664,9 @@ def test_eq_posix(self):
     @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')
+        self.assertEqual(self.make_uri(P('/')), 'file:///')
+        self.assertEqual(self.make_uri(P('/a/b.c')), 'file:///a/b.c')
+        self.assertEqual(self.make_uri(P('/a/b%#c')), 'file:///a/b%25%23c')
 
     @needs_posix
     def test_as_uri_non_ascii(self):
@@ -381,7 +676,7 @@ def test_as_uri_non_ascii(self):
             os.fsencode('\xe9')
         except UnicodeEncodeError:
             self.skipTest("\\xe9 cannot be encoded to the filesystem encoding")
-        self.assertEqual(P('/a/b\xe9').as_uri(),
+        self.assertEqual(self.make_uri(P('/a/b\xe9')),
                          'file:///a/b' + quote_from_bytes(os.fsencode('\xe9')))
 
     @needs_posix
@@ -475,21 +770,21 @@ def test_eq_windows(self):
     def test_as_uri_windows(self):
         P = self.cls
         with self.assertRaises(ValueError):
-            P('/a/b').as_uri()
+            self.make_uri(P('/a/b'))
         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(),
+            self.make_uri(P('c:a/b'))
+        self.assertEqual(self.make_uri(P('c:/')), 'file:///c:/')
+        self.assertEqual(self.make_uri(P('c:/a/b.c')), 'file:///c:/a/b.c')
+        self.assertEqual(self.make_uri(P('c:/a/b%#c')), 'file:///c:/a/b%25%23c')
+        self.assertEqual(self.make_uri(P('//some/share/')), 'file://some/share/')
+        self.assertEqual(self.make_uri(P('//some/share/a/b.c')),
                          '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(),
+        self.assertEqual(self.make_uri(P('c:/a/b' + FS_NONASCII)),
                          'file:///c:/a/b' + QUOTED_FS_NONASCII)
-        self.assertEqual(P('//some/share/a/b%#c' + FS_NONASCII).as_uri(),
+        self.assertEqual(self.make_uri(P('//some/share/a/b%#c' + FS_NONASCII)),
                          'file://some/share/a/b%25%23c' + QUOTED_FS_NONASCII)
 
     @needs_windows
@@ -510,6 +805,311 @@ def assertOrderedEqual(a, b):
         self.assertFalse(p < q)
         self.assertFalse(p > q)
 
+    @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())
+
+    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')))
+
 
 class PurePosixPathTest(PurePathTest):
     cls = pathlib.PurePosixPath
@@ -531,37 +1131,78 @@ class cls(pathlib.PurePath):
 # Tests for the concrete classes.
 #
 
-class PathTest(test_pathlib_abc.DummyPathTest, PurePathTest):
+class PathTest(PurePathTest):
     """Tests for the FS-accessing functionalities of the Path classes."""
     cls = pathlib.Path
     can_symlink = os_helper.can_symlink()
 
     def setUp(self):
+        name = self.id().split('.')[-1]
+        if name in _tests_needing_symlinks and not self.can_symlink:
+            self.skipTest('requires symlinks')
         super().setUp()
-        os.chmod(self.parser.join(self.base, 'dirE'), 0)
+        os.mkdir(self.base)
+        os.mkdir(os.path.join(self.base, 'dirA'))
+        os.mkdir(os.path.join(self.base, 'dirB'))
+        os.mkdir(os.path.join(self.base, 'dirC'))
+        os.mkdir(os.path.join(self.base, 'dirC', 'dirD'))
+        os.mkdir(os.path.join(self.base, 'dirE'))
+        with open(os.path.join(self.base, 'fileA'), 'wb') as f:
+            f.write(b"this is file A\n")
+        with open(os.path.join(self.base, 'dirB', 'fileB'), 'wb') as f:
+            f.write(b"this is file B\n")
+        with open(os.path.join(self.base, 'dirC', 'fileC'), 'wb') as f:
+            f.write(b"this is file C\n")
+        with open(os.path.join(self.base, 'dirC', 'novel.txt'), 'wb') as f:
+            f.write(b"this is a novel\n")
+        with open(os.path.join(self.base, 'dirC', 'dirD', 'fileD'), 'wb') as f:
+            f.write(b"this is file D\n")
+        os.chmod(os.path.join(self.base, 'dirE'), 0)
+        if self.can_symlink:
+            # Relative symlinks.
+            os.symlink('fileA', os.path.join(self.base, 'linkA'))
+            os.symlink('non-existing', os.path.join(self.base, 'brokenLink'))
+            os.symlink('dirB',
+                       os.path.join(self.base, 'linkB'),
+                       target_is_directory=True)
+            os.symlink(os.path.join('..', 'dirB'),
+                       os.path.join(self.base, 'dirA', 'linkC'),
+                       target_is_directory=True)
+            # This one goes upwards, creating a loop.
+            os.symlink(os.path.join('..', 'dirB'),
+                       os.path.join(self.base, 'dirB', 'linkD'),
+                       target_is_directory=True)
+            # Broken symlink (pointing to itself).
+            os.symlink('brokenLinkLoop', os.path.join(self.base, 'brokenLinkLoop'))
 
     def tearDown(self):
-        os.chmod(self.parser.join(self.base, 'dirE'), 0o777)
+        os.chmod(os.path.join(self.base, 'dirE'), 0o777)
         os_helper.rmtree(self.base)
 
+    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 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:
+    def test_matches_writablepath_docstrings(self):
+        path_names = {name for name in dir(pathlib.types._WritablePath) if name[0] != '_'}
+        for attr_name in path_names:
             if attr_name == 'parser':
-                # On Windows, Path.parser is ntpath, but PathBase.parser is
+                # On Windows, Path.parser is ntpath, but WritablePath.parser is
                 # posixpath, and so their docstrings differ.
                 continue
             our_attr = getattr(self.cls, attr_name)
-            path_attr = getattr(pathlib._abc.PathBase, attr_name)
+            path_attr = getattr(pathlib.types._WritablePath, attr_name)
             self.assertEqual(our_attr.__doc__, path_attr.__doc__)
 
     def test_concrete_class(self):
@@ -675,12 +1316,648 @@ def with_segments(self, *pathsegments):
         for dirpath, dirnames, filenames in p.walk():
             self.assertEqual(42, dirpath.session_id)
 
+    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_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_copy_file_preserve_metadata(self):
+        base = self.cls(self.base)
+        source = base / 'fileA'
+        if hasattr(os, 'chmod'):
+            os.chmod(source, stat.S_IRWXU | stat.S_IRWXO)
+        if hasattr(os, 'chflags') and hasattr(stat, 'UF_NODUMP'):
+            os.chflags(source, stat.UF_NODUMP)
+        source_st = source.stat()
+        target = base / 'copyA'
+        source.copy(target, preserve_metadata=True)
+        self.assertTrue(target.exists())
+        self.assertEqual(source.read_text(), target.read_text())
+        target_st = target.stat()
+        self.assertLessEqual(source_st.st_atime, target_st.st_atime)
+        self.assertLessEqual(source_st.st_mtime, target_st.st_mtime)
+        self.assertEqual(source_st.st_mode, target_st.st_mode)
+        if hasattr(source_st, 'st_flags'):
+            self.assertEqual(source_st.st_flags, target_st.st_flags)
+
+    @needs_symlinks
+    def test_copy_file_to_existing_symlink(self):
+        base = self.cls(self.base)
+        source = base / 'dirB' / 'fileB'
+        target = base / 'linkA'
+        real_target = base / 'fileA'
+        result = source.copy(target)
+        self.assertEqual(result, target)
+        self.assertTrue(target.exists())
+        self.assertTrue(target.is_symlink())
+        self.assertTrue(real_target.exists())
+        self.assertFalse(real_target.is_symlink())
+        self.assertEqual(source.read_text(), real_target.read_text())
+
+    @needs_symlinks
+    def test_copy_file_to_existing_symlink_follow_symlinks_false(self):
+        base = self.cls(self.base)
+        source = base / 'dirB' / 'fileB'
+        target = base / 'linkA'
+        real_target = base / 'fileA'
+        result = source.copy(target, follow_symlinks=False)
+        self.assertEqual(result, target)
+        self.assertTrue(target.exists())
+        self.assertTrue(target.is_symlink())
+        self.assertTrue(real_target.exists())
+        self.assertFalse(real_target.is_symlink())
+        self.assertEqual(source.read_text(), real_target.read_text())
+
+    @os_helper.skip_unless_xattr
+    def test_copy_file_preserve_metadata_xattrs(self):
+        base = self.cls(self.base)
+        source = base / 'fileA'
+        os.setxattr(source, b'user.foo', b'42')
+        target = base / 'copyA'
+        source.copy(target, preserve_metadata=True)
+        self.assertEqual(os.getxattr(target, b'user.foo'), b'42')
+
+    @needs_symlinks
+    def test_copy_symlink_follow_symlinks_true(self):
+        base = self.cls(self.base)
+        source = base / 'linkA'
+        target = base / 'copyA'
+        result = source.copy(target)
+        self.assertEqual(result, target)
+        self.assertTrue(target.exists())
+        self.assertFalse(target.is_symlink())
+        self.assertEqual(source.read_text(), target.read_text())
+
+    @needs_symlinks
+    def test_copy_symlink_follow_symlinks_false(self):
+        base = self.cls(self.base)
+        source = base / 'linkA'
+        target = base / 'copyA'
+        result = source.copy(target, follow_symlinks=False)
+        self.assertEqual(result, target)
+        self.assertTrue(target.exists())
+        self.assertTrue(target.is_symlink())
+        self.assertEqual(source.readlink(), target.readlink())
+
+    @needs_symlinks
+    def test_copy_symlink_to_itself(self):
+        base = self.cls(self.base)
+        source = base / 'linkA'
+        self.assertRaises(OSError, source.copy, source)
+
+    @needs_symlinks
+    def test_copy_symlink_to_existing_symlink(self):
+        base = self.cls(self.base)
+        source = base / 'copySource'
+        target = base / 'copyTarget'
+        source.symlink_to(base / 'fileA')
+        target.symlink_to(base / 'dirC')
+        self.assertRaises(OSError, source.copy, target)
+        self.assertRaises(OSError, source.copy, target, follow_symlinks=False)
+
+    @needs_symlinks
+    def test_copy_symlink_to_existing_directory_symlink(self):
+        base = self.cls(self.base)
+        source = base / 'copySource'
+        target = base / 'copyTarget'
+        source.symlink_to(base / 'fileA')
+        target.symlink_to(base / 'dirC')
+        self.assertRaises(OSError, source.copy, target)
+        self.assertRaises(OSError, source.copy, target, follow_symlinks=False)
+
+    @needs_symlinks
+    def test_copy_directory_symlink_follow_symlinks_false(self):
+        base = self.cls(self.base)
+        source = base / 'linkB'
+        target = base / 'copyA'
+        result = source.copy(target, follow_symlinks=False)
+        self.assertEqual(result, target)
+        self.assertTrue(target.exists())
+        self.assertTrue(target.is_symlink())
+        self.assertEqual(source.readlink(), target.readlink())
+
+    @needs_symlinks
+    def test_copy_directory_symlink_to_itself(self):
+        base = self.cls(self.base)
+        source = base / 'linkB'
+        self.assertRaises(OSError, source.copy, source)
+        self.assertRaises(OSError, source.copy, source, follow_symlinks=False)
+
+    @needs_symlinks
+    def test_copy_directory_symlink_into_itself(self):
+        base = self.cls(self.base)
+        source = base / 'linkB'
+        target = base / 'linkB' / 'copyB'
+        self.assertRaises(OSError, source.copy, target)
+        self.assertRaises(OSError, source.copy, target, follow_symlinks=False)
+        self.assertFalse(target.exists())
+
+    @needs_symlinks
+    def test_copy_directory_symlink_to_existing_symlink(self):
+        base = self.cls(self.base)
+        source = base / 'copySource'
+        target = base / 'copyTarget'
+        source.symlink_to(base / 'dirC')
+        target.symlink_to(base / 'fileA')
+        self.assertRaises(FileExistsError, source.copy, target)
+        self.assertRaises(FileExistsError, source.copy, target, follow_symlinks=False)
+
+    @needs_symlinks
+    def test_copy_directory_symlink_to_existing_directory_symlink(self):
+        base = self.cls(self.base)
+        source = base / 'copySource'
+        target = base / 'copyTarget'
+        source.symlink_to(base / 'dirC' / 'dirD')
+        target.symlink_to(base / 'dirC')
+        self.assertRaises(FileExistsError, source.copy, target)
+        self.assertRaises(FileExistsError, source.copy, target, follow_symlinks=False)
+
+    @needs_symlinks
+    def test_copy_dangling_symlink(self):
+        base = self.cls(self.base)
+        source = base / 'source'
+        target = base / 'target'
+
+        source.mkdir()
+        source.joinpath('link').symlink_to('nonexistent')
+
+        self.assertRaises(FileNotFoundError, source.copy, target)
+
+        target2 = base / 'target2'
+        result = source.copy(target2, follow_symlinks=False)
+        self.assertEqual(result, target2)
+        self.assertTrue(target2.joinpath('link').is_symlink())
+        self.assertEqual(target2.joinpath('link').readlink(), self.cls('nonexistent'))
+
+    @needs_symlinks
+    def test_copy_link_preserve_metadata(self):
+        base = self.cls(self.base)
+        source = base / 'linkA'
+        if hasattr(os, 'lchmod'):
+            os.lchmod(source, stat.S_IRWXU | stat.S_IRWXO)
+        if hasattr(os, 'lchflags') and hasattr(stat, 'UF_NODUMP'):
+            os.lchflags(source, stat.UF_NODUMP)
+        source_st = source.lstat()
+        target = base / 'copyA'
+        source.copy(target, follow_symlinks=False, preserve_metadata=True)
+        self.assertTrue(target.exists())
+        self.assertTrue(target.is_symlink())
+        self.assertEqual(source.readlink(), target.readlink())
+        target_st = target.lstat()
+        self.assertLessEqual(source_st.st_atime, target_st.st_atime)
+        self.assertLessEqual(source_st.st_mtime, target_st.st_mtime)
+        self.assertEqual(source_st.st_mode, target_st.st_mode)
+        if hasattr(source_st, 'st_flags'):
+            self.assertEqual(source_st.st_flags, target_st.st_flags)
+
+    def test_copy_error_handling(self):
+        def make_raiser(err):
+            def raiser(*args, **kwargs):
+                raise OSError(err, os.strerror(err))
+            return raiser
+
+        base = self.cls(self.base)
+        source = base / 'fileA'
+        target = base / 'copyA'
+
+        # Raise non-fatal OSError from all available fast copy functions.
+        with contextlib.ExitStack() as ctx:
+            if fcntl and hasattr(fcntl, 'FICLONE'):
+                ctx.enter_context(mock.patch('fcntl.ioctl', make_raiser(errno.EXDEV)))
+            if posix and hasattr(posix, '_fcopyfile'):
+                ctx.enter_context(mock.patch('posix._fcopyfile', make_raiser(errno.ENOTSUP)))
+            if hasattr(os, 'copy_file_range'):
+                ctx.enter_context(mock.patch('os.copy_file_range', make_raiser(errno.EXDEV)))
+            if hasattr(os, 'sendfile'):
+                ctx.enter_context(mock.patch('os.sendfile', make_raiser(errno.ENOTSOCK)))
+
+            source.copy(target)
+            self.assertTrue(target.exists())
+            self.assertEqual(source.read_text(), target.read_text())
+
+        # Raise fatal OSError from first available fast copy function.
+        if fcntl and hasattr(fcntl, 'FICLONE'):
+            patchpoint = 'fcntl.ioctl'
+        elif posix and hasattr(posix, '_fcopyfile'):
+            patchpoint = 'posix._fcopyfile'
+        elif hasattr(os, 'copy_file_range'):
+            patchpoint = 'os.copy_file_range'
+        elif hasattr(os, 'sendfile'):
+            patchpoint = 'os.sendfile'
+        else:
+            return
+        with mock.patch(patchpoint, make_raiser(errno.ENOENT)):
+            self.assertRaises(FileNotFoundError, source.copy, target)
+
+    @unittest.skipIf(sys.platform == "win32" or sys.platform == "wasi", "directories are always readable on Windows and WASI")
+    @unittest.skipIf(root_in_posix, "test fails with root privilege")
+    def test_copy_dir_no_read_permission(self):
+        base = self.cls(self.base)
+        source = base / 'dirE'
+        target = base / 'copyE'
+        self.assertRaises(PermissionError, source.copy, target)
+        self.assertFalse(target.exists())
+
+    def test_copy_dir_preserve_metadata(self):
+        base = self.cls(self.base)
+        source = base / 'dirC'
+        if hasattr(os, 'chmod'):
+            os.chmod(source / 'dirD', stat.S_IRWXU | stat.S_IRWXO)
+        if hasattr(os, 'chflags') and hasattr(stat, 'UF_NODUMP'):
+            os.chflags(source / 'fileC', stat.UF_NODUMP)
+        target = base / 'copyA'
+
+        subpaths = ['.', 'fileC', 'dirD', 'dirD/fileD']
+        source_sts = [source.joinpath(subpath).stat() for subpath in subpaths]
+        source.copy(target, preserve_metadata=True)
+        target_sts = [target.joinpath(subpath).stat() for subpath in subpaths]
+
+        for source_st, target_st in zip(source_sts, target_sts):
+            self.assertLessEqual(source_st.st_atime, target_st.st_atime)
+            self.assertLessEqual(source_st.st_mtime, target_st.st_mtime)
+            self.assertEqual(source_st.st_mode, target_st.st_mode)
+            if hasattr(source_st, 'st_flags'):
+                self.assertEqual(source_st.st_flags, target_st.st_flags)
+
+    @os_helper.skip_unless_xattr
+    def test_copy_dir_preserve_metadata_xattrs(self):
+        base = self.cls(self.base)
+        source = base / 'dirC'
+        source_file = source.joinpath('dirD', 'fileD')
+        os.setxattr(source_file, b'user.foo', b'42')
+        target = base / 'copyA'
+        source.copy(target, preserve_metadata=True)
+        target_file = target.joinpath('dirD', 'fileD')
+        self.assertEqual(os.getxattr(target_file, b'user.foo'), b'42')
+
+    @needs_symlinks
+    def test_move_file_symlink(self):
+        base = self.cls(self.base)
+        source = base / 'linkA'
+        source_readlink = source.readlink()
+        target = base / 'linkA_moved'
+        result = source.move(target)
+        self.assertEqual(result, target)
+        self.assertFalse(source.exists())
+        self.assertTrue(target.is_symlink())
+        self.assertEqual(source_readlink, target.readlink())
+
+    @needs_symlinks
+    def test_move_file_symlink_to_itself(self):
+        base = self.cls(self.base)
+        source = base / 'linkA'
+        self.assertRaises(OSError, source.move, source)
+
+    @needs_symlinks
+    def test_move_dir_symlink(self):
+        base = self.cls(self.base)
+        source = base / 'linkB'
+        source_readlink = source.readlink()
+        target = base / 'linkB_moved'
+        result = source.move(target)
+        self.assertEqual(result, target)
+        self.assertFalse(source.exists())
+        self.assertTrue(target.is_symlink())
+        self.assertEqual(source_readlink, target.readlink())
+
+    @needs_symlinks
+    def test_move_dir_symlink_to_itself(self):
+        base = self.cls(self.base)
+        source = base / 'linkB'
+        self.assertRaises(OSError, source.move, source)
+
+    @needs_symlinks
+    def test_move_dangling_symlink(self):
+        base = self.cls(self.base)
+        source = base / 'brokenLink'
+        source_readlink = source.readlink()
+        target = base / 'brokenLink_moved'
+        result = source.move(target)
+        self.assertEqual(result, target)
+        self.assertFalse(source.exists())
+        self.assertTrue(target.is_symlink())
+        self.assertEqual(source_readlink, target.readlink())
+
+    def test_move_file(self):
+        base = self.cls(self.base)
+        source = base / 'fileA'
+        source_text = source.read_text()
+        target = base / 'fileA_moved'
+        result = source.move(target)
+        self.assertEqual(result, target)
+        self.assertFalse(source.exists())
+        self.assertTrue(target.exists())
+        self.assertEqual(source_text, target.read_text())
+
+    @patch_replace
+    def test_move_file_other_fs(self):
+        self.test_move_file()
+
+    def test_move_file_to_file(self):
+        base = self.cls(self.base)
+        source = base / 'fileA'
+        source_text = source.read_text()
+        target = base / 'dirB' / 'fileB'
+        result = source.move(target)
+        self.assertEqual(result, target)
+        self.assertFalse(source.exists())
+        self.assertTrue(target.exists())
+        self.assertEqual(source_text, target.read_text())
+
+    @patch_replace
+    def test_move_file_to_file_other_fs(self):
+        self.test_move_file_to_file()
+
+    def test_move_file_to_dir(self):
+        base = self.cls(self.base)
+        source = base / 'fileA'
+        target = base / 'dirB'
+        self.assertRaises(OSError, source.move, target)
+
+    @patch_replace
+    def test_move_file_to_dir_other_fs(self):
+        self.test_move_file_to_dir()
+
+    def test_move_file_to_itself(self):
+        base = self.cls(self.base)
+        source = base / 'fileA'
+        self.assertRaises(OSError, source.move, source)
+
+    def test_move_dir(self):
+        base = self.cls(self.base)
+        source = base / 'dirC'
+        target = base / 'dirC_moved'
+        result = source.move(target)
+        self.assertEqual(result, target)
+        self.assertFalse(source.exists())
+        self.assertTrue(target.is_dir())
+        self.assertTrue(target.joinpath('dirD').is_dir())
+        self.assertTrue(target.joinpath('dirD', 'fileD').is_file())
+        self.assertEqual(target.joinpath('dirD', 'fileD').read_text(),
+                         "this is file D\n")
+        self.assertTrue(target.joinpath('fileC').is_file())
+        self.assertTrue(target.joinpath('fileC').read_text(),
+                        "this is file C\n")
+
+    @patch_replace
+    def test_move_dir_other_fs(self):
+        self.test_move_dir()
+
+    def test_move_dir_to_dir(self):
+        base = self.cls(self.base)
+        source = base / 'dirC'
+        target = base / 'dirB'
+        self.assertRaises(OSError, source.move, target)
+        self.assertTrue(source.exists())
+        self.assertTrue(target.exists())
+
+    @patch_replace
+    def test_move_dir_to_dir_other_fs(self):
+        self.test_move_dir_to_dir()
+
+    def test_move_dir_to_itself(self):
+        base = self.cls(self.base)
+        source = base / 'dirC'
+        self.assertRaises(OSError, source.move, source)
+        self.assertTrue(source.exists())
+
+    def test_move_dir_into_itself(self):
+        base = self.cls(self.base)
+        source = base / 'dirC'
+        target = base / 'dirC' / 'bar'
+        self.assertRaises(OSError, source.move, target)
+        self.assertTrue(source.exists())
+        self.assertFalse(target.exists())
+
+    @patch_replace
+    def test_move_dir_into_itself_other_fs(self):
+        self.test_move_dir_into_itself()
+
+    @patch_replace
+    @needs_symlinks
+    def test_move_file_symlink_other_fs(self):
+        self.test_move_file_symlink()
+
+    @patch_replace
+    @needs_symlinks
+    def test_move_file_symlink_to_itself_other_fs(self):
+        self.test_move_file_symlink_to_itself()
+
+    @patch_replace
+    @needs_symlinks
+    def test_move_dir_symlink_other_fs(self):
+        self.test_move_dir_symlink()
+
+    @patch_replace
+    @needs_symlinks
+    def test_move_dir_symlink_to_itself_other_fs(self):
+        self.test_move_dir_symlink_to_itself()
+
+    @patch_replace
+    @needs_symlinks
+    def test_move_dangling_symlink_other_fs(self):
+        self.test_move_dangling_symlink()
+
+    def test_move_into(self):
+        base = self.cls(self.base)
+        source = base / 'fileA'
+        source_text = source.read_text()
+        target_dir = base / 'dirA'
+        result = source.move_into(target_dir)
+        self.assertEqual(result, target_dir / 'fileA')
+        self.assertFalse(source.exists())
+        self.assertTrue(result.exists())
+        self.assertEqual(source_text, result.read_text())
+
+    @patch_replace
+    def test_move_into_other_os(self):
+        self.test_move_into()
+
+    def test_move_into_empty_name(self):
+        source = self.cls('')
+        target_dir = self.base
+        self.assertRaises(ValueError, source.move_into, target_dir)
+
+    @patch_replace
+    def test_move_into_empty_name_other_os(self):
+        self.test_move_into_empty_name()
+
+    @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 _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.
+        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)
+
+    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_resolve_nonexist_relative_issue38671(self):
         p = self.cls('non', 'exist')
 
@@ -691,6 +1968,24 @@ def test_resolve_nonexist_relative_issue38671(self):
         finally:
             os.chdir(old_cwd)
 
+    @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(pathlib.UnsupportedOperation):
+            q.readlink(p)
+
     @os_helper.skip_unless_working_chmod
     def test_chmod(self):
         p = self.cls(self.base) / 'fileA'
@@ -811,6 +2106,174 @@ def test_rmdir(self):
         self.assertFileNotFound(p.stat)
         self.assertFileNotFound(p.unlink)
 
+    def test_delete_file(self):
+        p = self.cls(self.base) / 'fileA'
+        p._delete()
+        self.assertFalse(p.exists())
+        self.assertFileNotFound(p._delete)
+
+    def test_delete_dir(self):
+        base = self.cls(self.base)
+        base.joinpath('dirA')._delete()
+        self.assertFalse(base.joinpath('dirA').exists())
+        self.assertFalse(base.joinpath('dirA', 'linkC').exists(
+            follow_symlinks=False))
+        base.joinpath('dirB')._delete()
+        self.assertFalse(base.joinpath('dirB').exists())
+        self.assertFalse(base.joinpath('dirB', 'fileB').exists())
+        self.assertFalse(base.joinpath('dirB', 'linkD').exists(
+            follow_symlinks=False))
+        base.joinpath('dirC')._delete()
+        self.assertFalse(base.joinpath('dirC').exists())
+        self.assertFalse(base.joinpath('dirC', 'dirD').exists())
+        self.assertFalse(base.joinpath('dirC', 'dirD', 'fileD').exists())
+        self.assertFalse(base.joinpath('dirC', 'fileC').exists())
+        self.assertFalse(base.joinpath('dirC', 'novel.txt').exists())
+
+    def test_delete_missing(self):
+        tmp = self.cls(self.base, 'delete')
+        tmp.mkdir()
+        # filename is guaranteed not to exist
+        filename = tmp / 'foo'
+        self.assertRaises(FileNotFoundError, filename._delete)
+
+    @needs_symlinks
+    def test_delete_symlink(self):
+        tmp = self.cls(self.base, 'delete')
+        tmp.mkdir()
+        dir_ = tmp / 'dir'
+        dir_.mkdir()
+        link = tmp / 'link'
+        link.symlink_to(dir_)
+        link._delete()
+        self.assertTrue(dir_.exists())
+        self.assertFalse(link.exists(follow_symlinks=False))
+
+    @needs_symlinks
+    def test_delete_inner_symlink(self):
+        tmp = self.cls(self.base, 'delete')
+        tmp.mkdir()
+        dir1 = tmp / 'dir1'
+        dir2 = dir1 / 'dir2'
+        dir3 = tmp / 'dir3'
+        for d in dir1, dir2, dir3:
+            d.mkdir()
+        file1 = tmp / 'file1'
+        file1.write_text('foo')
+        link1 = dir1 / 'link1'
+        link1.symlink_to(dir2)
+        link2 = dir1 / 'link2'
+        link2.symlink_to(dir3)
+        link3 = dir1 / 'link3'
+        link3.symlink_to(file1)
+        # make sure symlinks are removed but not followed
+        dir1._delete()
+        self.assertFalse(dir1.exists())
+        self.assertTrue(dir3.exists())
+        self.assertTrue(file1.exists())
+
+    @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_delete_unwritable(self):
+        tmp = self.cls(self.base, 'delete')
+        tmp.mkdir()
+        child_file_path = tmp / 'a'
+        child_dir_path = tmp / 'b'
+        child_file_path.write_text("")
+        child_dir_path.mkdir()
+        old_dir_mode = tmp.stat().st_mode
+        old_child_file_mode = child_file_path.stat().st_mode
+        old_child_dir_mode = child_dir_path.stat().st_mode
+        # Make unwritable.
+        new_mode = stat.S_IREAD | stat.S_IEXEC
+        try:
+            child_file_path.chmod(new_mode)
+            child_dir_path.chmod(new_mode)
+            tmp.chmod(new_mode)
+
+            self.assertRaises(PermissionError, tmp._delete)
+        finally:
+            tmp.chmod(old_dir_mode)
+            child_file_path.chmod(old_child_file_mode)
+            child_dir_path.chmod(old_child_dir_mode)
+
+    @needs_windows
+    def test_delete_inner_junction(self):
+        import _winapi
+        tmp = self.cls(self.base, 'delete')
+        tmp.mkdir()
+        dir1 = tmp / 'dir1'
+        dir2 = dir1 / 'dir2'
+        dir3 = tmp / 'dir3'
+        for d in dir1, dir2, dir3:
+            d.mkdir()
+        file1 = tmp / 'file1'
+        file1.write_text('foo')
+        link1 = dir1 / 'link1'
+        _winapi.CreateJunction(str(dir2), str(link1))
+        link2 = dir1 / 'link2'
+        _winapi.CreateJunction(str(dir3), str(link2))
+        link3 = dir1 / 'link3'
+        _winapi.CreateJunction(str(file1), str(link3))
+        # make sure junctions are removed but not followed
+        dir1._delete()
+        self.assertFalse(dir1.exists())
+        self.assertTrue(dir3.exists())
+        self.assertTrue(file1.exists())
+
+    @needs_windows
+    def test_delete_outer_junction(self):
+        import _winapi
+        tmp = self.cls(self.base, 'delete')
+        tmp.mkdir()
+        src = tmp / 'cheese'
+        dst = tmp / 'shop'
+        src.mkdir()
+        spam = src / 'spam'
+        spam.write_text('')
+        _winapi.CreateJunction(str(src), str(dst))
+        dst._delete()
+        self.assertFalse(dst.exists())
+        self.assertTrue(spam.exists())
+        self.assertTrue(src.exists())
+
+    @unittest.skipUnless(hasattr(os, "mkfifo"), 'requires os.mkfifo()')
+    @unittest.skipIf(sys.platform == "vxworks",
+                     "fifo requires special path on VxWorks")
+    def test_delete_on_named_pipe(self):
+        p = self.cls(self.base, 'pipe')
+        os.mkfifo(p)
+        p._delete()
+        self.assertFalse(p.exists())
+
+        p = self.cls(self.base, 'dir')
+        p.mkdir()
+        os.mkfifo(p / 'mypipe')
+        p._delete()
+        self.assertFalse(p.exists())
+
+    def test_delete_does_not_choke_on_failing_lstat(self):
+        try:
+            orig_lstat = os.lstat
+            tmp = self.cls(self.base, 'delete')
+
+            def raiser(fn, *args, **kwargs):
+                if fn != tmp:
+                    raise OSError()
+                else:
+                    return orig_lstat(fn)
+
+            os.lstat = raiser
+
+            tmp.mkdir()
+            foo = tmp / 'foo'
+            foo.write_text('')
+            tmp._delete()
+        finally:
+            os.lstat = orig_lstat
+
     @os_helper.skip_unless_hardlink
     def test_hardlink_to(self):
         P = self.cls(self.base)
@@ -968,7 +2431,6 @@ def test_mkdir_exist_ok_with_parent(self):
         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)
@@ -1072,13 +2534,200 @@ def test_symlink_to_unsupported(self):
         with self.assertRaises(pathlib.UnsupportedOperation):
             q.symlink_to(p)
 
-    def test_is_junction(self):
+    def test_info_exists_caching(self):
+        p = self.cls(self.base)
+        q = p / 'myfile'
+        self.assertFalse(q.info.exists())
+        self.assertFalse(q.info.exists(follow_symlinks=False))
+        q.write_text('hullo')
+        self.assertFalse(q.info.exists())
+        self.assertFalse(q.info.exists(follow_symlinks=False))
+
+    def test_info_is_dir_caching(self):
+        p = self.cls(self.base)
+        q = p / 'mydir'
+        self.assertFalse(q.info.is_dir())
+        self.assertFalse(q.info.is_dir(follow_symlinks=False))
+        q.mkdir()
+        self.assertFalse(q.info.is_dir())
+        self.assertFalse(q.info.is_dir(follow_symlinks=False))
+
+    def test_info_is_file_caching(self):
+        p = self.cls(self.base)
+        q = p / 'myfile'
+        self.assertFalse(q.info.is_file())
+        self.assertFalse(q.info.is_file(follow_symlinks=False))
+        q.write_text('hullo')
+        self.assertFalse(q.info.is_file())
+        self.assertFalse(q.info.is_file(follow_symlinks=False))
+
+    @needs_symlinks
+    def test_info_is_symlink_caching(self):
+        p = self.cls(self.base)
+        q = p / 'mylink'
+        self.assertFalse(q.info.is_symlink())
+        q.symlink_to('blah')
+        self.assertFalse(q.info.is_symlink())
+
+        q = p / 'mylink'  # same path, new instance.
+        self.assertTrue(q.info.is_symlink())
+        q.unlink()
+        self.assertTrue(q.info.is_symlink())
+
+    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.
+
+    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_stat_no_follow_symlinks(self):
+        p = self.cls(self.base) / 'linkA'
+        st = p.stat()
+        self.assertNotEqual(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_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_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_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_junction_true(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)
 
+    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)
+
     @unittest.skipUnless(hasattr(os, "mkfifo"), "os.mkfifo() required")
     @unittest.skipIf(sys.platform == "vxworks",
                     "fifo requires special path on VxWorks")
@@ -1094,6 +2743,15 @@ def test_is_fifo_true(self):
         self.assertIs(self.cls(self.base, 'myfifo\udfff').is_fifo(), False)
         self.assertIs(self.cls(self.base, 'myfifo\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)
+
     @unittest.skipUnless(hasattr(socket, "AF_UNIX"), "Unix sockets required")
     @unittest.skipIf(
         is_emscripten, "Unix sockets are not implemented on Emscripten."
@@ -1117,6 +2775,24 @@ def test_is_socket_true(self):
         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_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 test_is_char_device_true(self):
         # os.devnull should generally be a char device.
         P = self.cls(os.devnull)
@@ -1128,7 +2804,14 @@ def test_is_char_device_true(self):
         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):
+    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())
         if os.name == 'nt':
             R = self.cls('c:\\')
         else:
@@ -1136,87 +2819,57 @@ def test_is_mount_root(self):
         self.assertTrue(R.is_mount())
         self.assertFalse((R / '\udfff').is_mount())
 
-    def test_passing_kwargs_deprecated(self):
-        with self.assertWarns(DeprecationWarning):
+    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_passing_kwargs_errors(self):
+        with self.assertRaises(TypeError):
             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'
+    @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_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)
+    @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.info.exists() else set()
+        self.assertEqual(given, expect)
+        self.assertEqual(set(p.glob("FILEa*")), set())
 
-        with infinite_recursion(recursion_limit):
-            list(base.walk())
-            list(base.walk(top_down=False))
+    @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('')
@@ -1265,6 +2918,18 @@ def test_glob_pathlike(self):
         self.assertEqual(expect, set(p.glob(P(pattern))))
         self.assertEqual(expect, set(p.glob(FakePath(pattern))))
 
+    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_dot(self):
         P = self.cls
@@ -1278,6 +2943,31 @@ def test_glob_dot(self):
             self.assertEqual(
                 set(P('.').glob('**/*/*')), {P("dirD/fileD")})
 
+    # 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", "..") })
+        if sys.platform == "emscripten":
+            # Emscripten will return ELOOP if there are 49 or more ..'s.
+            # Can remove when https://github.com/emscripten-core/emscripten/pull/24591 is merged.
+            NDOTDOTS = 48
+        else:
+            NDOTDOTS = 50
+        self.assertEqual(set(p.glob("/".join([".."] * NDOTDOTS))), { P(self.base, *[".."] * NDOTDOTS)})
+
     def test_glob_inaccessible(self):
         P = self.cls
         p = P(self.base, "mydir1", "mydir2")
@@ -1293,6 +2983,180 @@ def test_rglob_pathlike(self):
         self.assertEqual(expect, set(p.rglob(P(pattern))))
         self.assertEqual(expect, set(p.rglob(FakePath(pattern))))
 
+    @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/"])
+
+    @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"])
+
+    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_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})
+
+    @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"), target_is_directory=True)
+
+        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_posix
     def test_absolute_posix(self):
         P = self.cls
@@ -1306,7 +3170,7 @@ def test_absolute_posix(self):
         self.assertEqual(str(P('//a/b').absolute()), '//a/b')
 
     @unittest.skipIf(
-        is_emscripten or is_wasi,
+        is_wasm32,
         "umask is not implemented on Emscripten/WASI."
     )
     @needs_posix
@@ -1337,7 +3201,7 @@ def test_resolve_root(self):
             os.chdir(current_directory)
 
     @unittest.skipIf(
-        is_emscripten or is_wasi,
+        is_wasm32,
         "umask is not implemented on Emscripten/WASI."
     )
     @needs_posix
@@ -1444,10 +3308,13 @@ def test_handling_bad_descriptor(self):
     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.assertRaises(ValueError, P.from_uri, 'file://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'))
+        if not is_wasi:
+            self.assertEqual(P.from_uri(f'file://{socket.gethostname()}/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')
@@ -1457,8 +3324,8 @@ def test_from_uri_posix(self):
     @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'))
+        self.assertEqual(P.from_uri(pathname2url('/foo/bar', add_scheme=True)), P('/foo/bar'))
+        self.assertEqual(P.from_uri(pathname2url('//foo/bar', add_scheme=True)), P('//foo/bar'))
 
     @needs_windows
     def test_absolute_windows(self):
@@ -1597,6 +3464,166 @@ def test_group_windows(self):
             P('c:/').group()
 
 
+class PathWalkTest(unittest.TestCase):
+    cls = pathlib.Path
+    base = PathTest.base
+    can_symlink = PathTest.can_symlink
+
+    def setUp(self):
+        name = self.id().split('.')[-1]
+        if name in _tests_needing_symlinks and not self.can_symlink:
+            self.skipTest('requires symlinks')
+        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"
+        self.link_path = self.sub2_path / "link"
+        self.sub2_tree = (self.sub2_path, [], ["tmp3"])
+
+        # 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
+        t2_path = self.cls(self.base, "TEST2")
+        os.makedirs(self.sub11_path)
+        os.makedirs(self.sub2_path)
+        os.makedirs(t2_path)
+
+        tmp1_path = self.walk_path / "tmp1"
+        tmp2_path = self.sub1_path / "tmp2"
+        tmp3_path = self.sub2_path / "tmp3"
+        tmp4_path = self.cls(self.base, "TEST2", "tmp4")
+        for path in tmp1_path, tmp2_path, tmp3_path, tmp4_path:
+            with open(path, "w", encoding='utf-8') as f:
+                f.write(f"I'm {path} and proud of it.  Blame test_pathlib.\n")
+
+        if self.can_symlink:
+            broken_link_path = self.sub2_path / "broken_link"
+            broken_link2_path = self.sub2_path / "broken_link2"
+            os.symlink(t2_path, self.link_path, target_is_directory=True)
+            os.symlink('broken', broken_link_path)
+            os.symlink(os.path.join('tmp3', 'broken'), broken_link2_path)
+            self.sub2_tree = (self.sub2_path, [], ["broken_link", "broken_link2", "link", "tmp3"])
+        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()
+        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 tearDown(self):
+        if 'SUB21' in self.sub2_tree[1]:
+            os.chmod(self.sub2_path / "SUB21", stat.S_IRWXU)
+        os_helper.rmtree(self.base)
+
+    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 = 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))
+
+    @needs_symlinks
+    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")
+
+    @needs_symlinks
+    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
+        else:
+            self.fail("symlink not found")
+
+
 @unittest.skipIf(os.name == 'nt', 'test requires a POSIX-compatible system')
 class PosixPathTest(PathTest, PurePosixPathTest):
     cls = pathlib.PosixPath
diff --git a/Lib/test/test_pathlib/test_pathlib_abc.py b/Lib/test/test_pathlib/test_pathlib_abc.py
deleted file mode 100644
index 2e050362158..00000000000
--- a/Lib/test/test_pathlib/test_pathlib_abc.py
+++ /dev/null
@@ -1,2499 +0,0 @@
-# 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_pathlib/test_read.py b/Lib/test/test_pathlib/test_read.py
new file mode 100644
index 00000000000..482203c290a
--- /dev/null
+++ b/Lib/test/test_pathlib/test_read.py
@@ -0,0 +1,343 @@
+"""
+Tests for pathlib.types._ReadablePath
+"""
+
+import collections.abc
+import io
+import sys
+import unittest
+
+from .support import is_pypi
+from .support.local_path import ReadableLocalPath, LocalPathGround
+from .support.zip_path import ReadableZipPath, ZipPathGround
+
+if is_pypi:
+    from pathlib_abc import PathInfo, _ReadablePath
+    from pathlib_abc._os import magic_open
+else:
+    from pathlib.types import PathInfo, _ReadablePath
+    from pathlib._os import magic_open
+
+
+class ReadTestBase:
+    def setUp(self):
+        self.root = self.ground.setup()
+        self.ground.create_hierarchy(self.root)
+
+    def tearDown(self):
+        self.ground.teardown(self.root)
+
+    def test_is_readable(self):
+        self.assertIsInstance(self.root, _ReadablePath)
+
+    def test_open_r(self):
+        p = self.root / 'fileA'
+        with magic_open(p, 'r', encoding='utf-8') as f:
+            self.assertIsInstance(f, io.TextIOBase)
+            self.assertEqual(f.read(), 'this is file A\n')
+
+    @unittest.skipIf(
+        not getattr(sys.flags, 'warn_default_encoding', 0),
+        "Requires warn_default_encoding",
+    )
+    def test_open_r_encoding_warning(self):
+        p = self.root / 'fileA'
+        with self.assertWarns(EncodingWarning) as wc:
+            with magic_open(p, 'r'):
+                pass
+        self.assertEqual(wc.filename, __file__)
+
+    def test_open_rb(self):
+        p = self.root / 'fileA'
+        with magic_open(p, 'rb') as f:
+            self.assertEqual(f.read(), b'this is file A\n')
+        self.assertRaises(ValueError, magic_open, p, 'rb', encoding='utf8')
+        self.assertRaises(ValueError, magic_open, p, 'rb', errors='strict')
+        self.assertRaises(ValueError, magic_open, p, 'rb', newline='')
+
+    def test_read_bytes(self):
+        p = self.root / 'fileA'
+        self.assertEqual(p.read_bytes(), b'this is file A\n')
+
+    def test_read_text(self):
+        p = self.root / 'fileA'
+        self.assertEqual(p.read_text(encoding='utf-8'), 'this is file A\n')
+        q = self.root / 'abc'
+        self.ground.create_file(q, b'\xe4bcdefg')
+        self.assertEqual(q.read_text(encoding='latin-1'), 'äbcdefg')
+        self.assertEqual(q.read_text(encoding='utf-8', errors='ignore'), 'bcdefg')
+
+    @unittest.skipIf(
+        not getattr(sys.flags, 'warn_default_encoding', 0),
+        "Requires warn_default_encoding",
+    )
+    def test_read_text_encoding_warning(self):
+        p = self.root / 'fileA'
+        with self.assertWarns(EncodingWarning) as wc:
+            p.read_text()
+        self.assertEqual(wc.filename, __file__)
+
+    def test_read_text_with_newlines(self):
+        p = self.root / 'abc'
+        self.ground.create_file(p, b'abcde\r\nfghlk\n\rmnopq')
+        # Check that `\n` character change nothing
+        self.assertEqual(p.read_text(encoding='utf-8', newline='\n'), 'abcde\r\nfghlk\n\rmnopq')
+        # Check that `\r` character replaces `\n`
+        self.assertEqual(p.read_text(encoding='utf-8', newline='\r'), 'abcde\r\nfghlk\n\rmnopq')
+        # Check that `\r\n` character replaces `\n`
+        self.assertEqual(p.read_text(encoding='utf-8', newline='\r\n'), 'abcde\r\nfghlk\n\rmnopq')
+
+    def test_iterdir(self):
+        expected = ['dirA', 'dirB', 'dirC', 'fileA']
+        if self.ground.can_symlink:
+            expected += ['linkA', 'linkB', 'brokenLink', 'brokenLinkLoop']
+        expected = {self.root.joinpath(name) for name in expected}
+        actual = set(self.root.iterdir())
+        self.assertEqual(actual, expected)
+
+    def test_iterdir_nodir(self):
+        p = self.root / 'fileA'
+        self.assertRaises(OSError, p.iterdir)
+
+    def test_iterdir_info(self):
+        for child in self.root.iterdir():
+            self.assertIsInstance(child.info, PathInfo)
+            self.assertTrue(child.info.exists(follow_symlinks=False))
+
+    def test_glob(self):
+        if not self.ground.can_symlink:
+            self.skipTest("requires symlinks")
+
+        p = self.root
+        sep = self.root.parser.sep
+        altsep = self.root.parser.altsep
+        def check(pattern, expected):
+            if altsep:
+                expected = {name.replace(altsep, sep) for name in expected}
+            expected = {p.joinpath(name) for name in expected}
+            actual = set(p.glob(pattern, recurse_symlinks=True))
+            self.assertEqual(actual, expected)
+
+        it = p.glob("fileA")
+        self.assertIsInstance(it, collections.abc.Iterator)
+        self.assertEqual(list(it), [p.joinpath("fileA")])
+        check("*A", ["dirA", "fileA", "linkA"])
+        check("*A", ['dirA', 'fileA', 'linkA'])
+        check("*B/*", ["dirB/fileB", "linkB/fileB"])
+        check("*B/*", ['dirB/fileB', 'linkB/fileB'])
+        check("brokenLink", ['brokenLink'])
+        check("brokenLinkLoop", ['brokenLinkLoop'])
+        check("**/", ["", "dirA/", "dirA/linkC/", "dirB/", "dirC/", "dirC/dirD/", "linkB/"])
+        check("**/*/", ["dirA/", "dirA/linkC/", "dirB/", "dirC/", "dirC/dirD/", "linkB/"])
+        check("*/", ["dirA/", "dirB/", "dirC/", "linkB/"])
+        check("*/dirD/**/", ["dirC/dirD/"])
+        check("*/dirD/**", ["dirC/dirD/", "dirC/dirD/fileD"])
+        check("dir*/**", ["dirA/", "dirA/linkC", "dirA/linkC/fileB", "dirB/", "dirB/fileB", "dirC/",
+                          "dirC/fileC", "dirC/dirD", "dirC/dirD/fileD", "dirC/novel.txt"])
+        check("dir*/**/", ["dirA/", "dirA/linkC/", "dirB/", "dirC/", "dirC/dirD/"])
+        check("dir*/**/..", ["dirA/..", "dirA/linkC/..", "dirB/..", "dirC/..", "dirC/dirD/.."])
+        check("dir*/*/**", ["dirA/linkC/", "dirA/linkC/fileB", "dirC/dirD/", "dirC/dirD/fileD"])
+        check("dir*/*/**/", ["dirA/linkC/", "dirC/dirD/"])
+        check("dir*/*/**/..", ["dirA/linkC/..", "dirC/dirD/.."])
+        check("dir*/*/..", ["dirC/dirD/..", "dirA/linkC/.."])
+        check("dir*/*/../dirD/**/", ["dirC/dirD/../dirD/"])
+        check("dir*/**/fileC", ["dirC/fileC"])
+        check("dir*/file*", ["dirB/fileB", "dirC/fileC"])
+        check("**/*/fileA", [])
+        check("fileB", [])
+        check("**/*/fileB", ["dirB/fileB", "dirA/linkC/fileB", "linkB/fileB"])
+        check("**/fileB", ["dirB/fileB", "dirA/linkC/fileB", "linkB/fileB"])
+        check("*/fileB", ["dirB/fileB", "linkB/fileB"])
+        check("*/fileB", ['dirB/fileB', 'linkB/fileB'])
+        check("**/file*",
+              ["fileA", "dirA/linkC/fileB", "dirB/fileB", "dirC/fileC", "dirC/dirD/fileD",
+               "linkB/fileB"])
+        with self.assertRaisesRegex(ValueError, 'Unacceptable pattern'):
+            list(p.glob(''))
+
+    def test_walk_top_down(self):
+        it = self.root.walk()
+
+        path, dirnames, filenames = next(it)
+        dirnames.sort()
+        filenames.sort()
+        self.assertEqual(path, self.root)
+        self.assertEqual(dirnames, ['dirA', 'dirB', 'dirC'])
+        self.assertEqual(filenames, ['brokenLink', 'brokenLinkLoop', 'fileA', 'linkA', 'linkB']
+                                    if self.ground.can_symlink else ['fileA'])
+
+        path, dirnames, filenames = next(it)
+        self.assertEqual(path, self.root / 'dirA')
+        self.assertEqual(dirnames, [])
+        self.assertEqual(filenames, ['linkC'] if self.ground.can_symlink else [])
+
+        path, dirnames, filenames = next(it)
+        self.assertEqual(path, self.root / 'dirB')
+        self.assertEqual(dirnames, [])
+        self.assertEqual(filenames, ['fileB'])
+
+        path, dirnames, filenames = next(it)
+        filenames.sort()
+        self.assertEqual(path, self.root / 'dirC')
+        self.assertEqual(dirnames, ['dirD'])
+        self.assertEqual(filenames, ['fileC', 'novel.txt'])
+
+        path, dirnames, filenames = next(it)
+        self.assertEqual(path, self.root / 'dirC' / 'dirD')
+        self.assertEqual(dirnames, [])
+        self.assertEqual(filenames, ['fileD'])
+
+        self.assertRaises(StopIteration, next, it)
+
+    def test_walk_prune(self):
+        expected = {self.root, self.root / 'dirA', self.root / 'dirC', self.root / 'dirC' / 'dirD'}
+        actual = set()
+        for path, dirnames, filenames in self.root.walk():
+            actual.add(path)
+            if path == self.root:
+                dirnames.remove('dirB')
+        self.assertEqual(actual, expected)
+
+    def test_walk_bottom_up(self):
+        seen_root = seen_dira = seen_dirb = seen_dirc = seen_dird = False
+        for path, dirnames, filenames in self.root.walk(top_down=False):
+            if path == self.root:
+                self.assertFalse(seen_root)
+                self.assertTrue(seen_dira)
+                self.assertTrue(seen_dirb)
+                self.assertTrue(seen_dirc)
+                self.assertEqual(sorted(dirnames), ['dirA', 'dirB', 'dirC'])
+                self.assertEqual(sorted(filenames),
+                                 ['brokenLink', 'brokenLinkLoop', 'fileA', 'linkA', 'linkB']
+                                 if self.ground.can_symlink else ['fileA'])
+                seen_root = True
+            elif path == self.root / 'dirA':
+                self.assertFalse(seen_root)
+                self.assertFalse(seen_dira)
+                self.assertEqual(dirnames, [])
+                self.assertEqual(filenames, ['linkC'] if self.ground.can_symlink else [])
+                seen_dira = True
+            elif path == self.root / 'dirB':
+                self.assertFalse(seen_root)
+                self.assertFalse(seen_dirb)
+                self.assertEqual(dirnames, [])
+                self.assertEqual(filenames, ['fileB'])
+                seen_dirb = True
+            elif path == self.root / 'dirC':
+                self.assertFalse(seen_root)
+                self.assertFalse(seen_dirc)
+                self.assertTrue(seen_dird)
+                self.assertEqual(dirnames, ['dirD'])
+                self.assertEqual(sorted(filenames), ['fileC', 'novel.txt'])
+                seen_dirc = True
+            elif path == self.root / 'dirC' / 'dirD':
+                self.assertFalse(seen_root)
+                self.assertFalse(seen_dirc)
+                self.assertFalse(seen_dird)
+                self.assertEqual(dirnames, [])
+                self.assertEqual(filenames, ['fileD'])
+                seen_dird = True
+            else:
+                raise AssertionError(f"Unexpected path: {path}")
+        self.assertTrue(seen_root)
+
+    def test_info_exists(self):
+        p = self.root
+        self.assertTrue(p.info.exists())
+        self.assertTrue((p / 'dirA').info.exists())
+        self.assertTrue((p / 'dirA').info.exists(follow_symlinks=False))
+        self.assertTrue((p / 'fileA').info.exists())
+        self.assertTrue((p / 'fileA').info.exists(follow_symlinks=False))
+        self.assertFalse((p / 'non-existing').info.exists())
+        self.assertFalse((p / 'non-existing').info.exists(follow_symlinks=False))
+        if self.ground.can_symlink:
+            self.assertTrue((p / 'linkA').info.exists())
+            self.assertTrue((p / 'linkA').info.exists(follow_symlinks=False))
+            self.assertTrue((p / 'linkB').info.exists())
+            self.assertTrue((p / 'linkB').info.exists(follow_symlinks=True))
+            self.assertFalse((p / 'brokenLink').info.exists())
+            self.assertTrue((p / 'brokenLink').info.exists(follow_symlinks=False))
+            self.assertFalse((p / 'brokenLinkLoop').info.exists())
+            self.assertTrue((p / 'brokenLinkLoop').info.exists(follow_symlinks=False))
+        self.assertFalse((p / 'fileA\udfff').info.exists())
+        self.assertFalse((p / 'fileA\udfff').info.exists(follow_symlinks=False))
+        self.assertFalse((p / 'fileA\x00').info.exists())
+        self.assertFalse((p / 'fileA\x00').info.exists(follow_symlinks=False))
+
+    def test_info_is_dir(self):
+        p = self.root
+        self.assertTrue((p / 'dirA').info.is_dir())
+        self.assertTrue((p / 'dirA').info.is_dir(follow_symlinks=False))
+        self.assertFalse((p / 'fileA').info.is_dir())
+        self.assertFalse((p / 'fileA').info.is_dir(follow_symlinks=False))
+        self.assertFalse((p / 'non-existing').info.is_dir())
+        self.assertFalse((p / 'non-existing').info.is_dir(follow_symlinks=False))
+        if self.ground.can_symlink:
+            self.assertFalse((p / 'linkA').info.is_dir())
+            self.assertFalse((p / 'linkA').info.is_dir(follow_symlinks=False))
+            self.assertTrue((p / 'linkB').info.is_dir())
+            self.assertFalse((p / 'linkB').info.is_dir(follow_symlinks=False))
+            self.assertFalse((p / 'brokenLink').info.is_dir())
+            self.assertFalse((p / 'brokenLink').info.is_dir(follow_symlinks=False))
+            self.assertFalse((p / 'brokenLinkLoop').info.is_dir())
+            self.assertFalse((p / 'brokenLinkLoop').info.is_dir(follow_symlinks=False))
+        self.assertFalse((p / 'dirA\udfff').info.is_dir())
+        self.assertFalse((p / 'dirA\udfff').info.is_dir(follow_symlinks=False))
+        self.assertFalse((p / 'dirA\x00').info.is_dir())
+        self.assertFalse((p / 'dirA\x00').info.is_dir(follow_symlinks=False))
+
+    def test_info_is_file(self):
+        p = self.root
+        self.assertTrue((p / 'fileA').info.is_file())
+        self.assertTrue((p / 'fileA').info.is_file(follow_symlinks=False))
+        self.assertFalse((p / 'dirA').info.is_file())
+        self.assertFalse((p / 'dirA').info.is_file(follow_symlinks=False))
+        self.assertFalse((p / 'non-existing').info.is_file())
+        self.assertFalse((p / 'non-existing').info.is_file(follow_symlinks=False))
+        if self.ground.can_symlink:
+            self.assertTrue((p / 'linkA').info.is_file())
+            self.assertFalse((p / 'linkA').info.is_file(follow_symlinks=False))
+            self.assertFalse((p / 'linkB').info.is_file())
+            self.assertFalse((p / 'linkB').info.is_file(follow_symlinks=False))
+            self.assertFalse((p / 'brokenLink').info.is_file())
+            self.assertFalse((p / 'brokenLink').info.is_file(follow_symlinks=False))
+            self.assertFalse((p / 'brokenLinkLoop').info.is_file())
+            self.assertFalse((p / 'brokenLinkLoop').info.is_file(follow_symlinks=False))
+        self.assertFalse((p / 'fileA\udfff').info.is_file())
+        self.assertFalse((p / 'fileA\udfff').info.is_file(follow_symlinks=False))
+        self.assertFalse((p / 'fileA\x00').info.is_file())
+        self.assertFalse((p / 'fileA\x00').info.is_file(follow_symlinks=False))
+
+    def test_info_is_symlink(self):
+        p = self.root
+        self.assertFalse((p / 'fileA').info.is_symlink())
+        self.assertFalse((p / 'dirA').info.is_symlink())
+        self.assertFalse((p / 'non-existing').info.is_symlink())
+        if self.ground.can_symlink:
+            self.assertTrue((p / 'linkA').info.is_symlink())
+            self.assertTrue((p / 'linkB').info.is_symlink())
+            self.assertTrue((p / 'brokenLink').info.is_symlink())
+            self.assertFalse((p / 'linkA\udfff').info.is_symlink())
+            self.assertFalse((p / 'linkA\x00').info.is_symlink())
+            self.assertTrue((p / 'brokenLinkLoop').info.is_symlink())
+        self.assertFalse((p / 'fileA\udfff').info.is_symlink())
+        self.assertFalse((p / 'fileA\x00').info.is_symlink())
+
+
+class ZipPathReadTest(ReadTestBase, unittest.TestCase):
+    ground = ZipPathGround(ReadableZipPath)
+
+
+class LocalPathReadTest(ReadTestBase, unittest.TestCase):
+    ground = LocalPathGround(ReadableLocalPath)
+
+
+if not is_pypi:
+    from pathlib import Path
+
+    class PathReadTest(ReadTestBase, unittest.TestCase):
+        ground = LocalPathGround(Path)
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/Lib/test/test_pathlib/test_write.py b/Lib/test/test_pathlib/test_write.py
new file mode 100644
index 00000000000..15054e804ec
--- /dev/null
+++ b/Lib/test/test_pathlib/test_write.py
@@ -0,0 +1,143 @@
+"""
+Tests for pathlib.types._WritablePath
+"""
+
+import io
+import os
+import sys
+import unittest
+
+from .support import is_pypi
+from .support.local_path import WritableLocalPath, LocalPathGround
+from .support.zip_path import WritableZipPath, ZipPathGround
+
+if is_pypi:
+    from pathlib_abc import _WritablePath
+    from pathlib_abc._os import magic_open
+else:
+    from pathlib.types import _WritablePath
+    from pathlib._os import magic_open
+
+
+class WriteTestBase:
+    def setUp(self):
+        self.root = self.ground.setup()
+
+    def tearDown(self):
+        self.ground.teardown(self.root)
+
+    def test_is_writable(self):
+        self.assertIsInstance(self.root, _WritablePath)
+
+    def test_open_w(self):
+        p = self.root / 'fileA'
+        with magic_open(p, 'w', encoding='utf-8') as f:
+            self.assertIsInstance(f, io.TextIOBase)
+            f.write('this is file A\n')
+        self.assertEqual(self.ground.readtext(p), 'this is file A\n')
+
+    @unittest.skipIf(
+        not getattr(sys.flags, 'warn_default_encoding', 0),
+        "Requires warn_default_encoding",
+    )
+    def test_open_w_encoding_warning(self):
+        p = self.root / 'fileA'
+        with self.assertWarns(EncodingWarning) as wc:
+            with magic_open(p, 'w'):
+                pass
+        self.assertEqual(wc.filename, __file__)
+
+    def test_open_wb(self):
+        p = self.root / 'fileA'
+        with magic_open(p, 'wb') as f:
+            #self.assertIsInstance(f, io.BufferedWriter)
+            f.write(b'this is file A\n')
+        self.assertEqual(self.ground.readbytes(p), b'this is file A\n')
+        self.assertRaises(ValueError, magic_open, p, 'wb', encoding='utf8')
+        self.assertRaises(ValueError, magic_open, p, 'wb', errors='strict')
+        self.assertRaises(ValueError, magic_open, p, 'wb', newline='')
+
+    def test_write_bytes(self):
+        p = self.root / 'fileA'
+        data = b'abcdefg'
+        self.assertEqual(len(data), p.write_bytes(data))
+        self.assertEqual(self.ground.readbytes(p), data)
+        # Check that trying to write str does not truncate the file.
+        self.assertRaises(TypeError, p.write_bytes, 'somestr')
+        self.assertEqual(self.ground.readbytes(p), data)
+
+    def test_write_text(self):
+        p = self.root / 'fileA'
+        data = 'äbcdefg'
+        self.assertEqual(len(data), p.write_text(data, encoding='latin-1'))
+        self.assertEqual(self.ground.readbytes(p), b'\xe4bcdefg')
+        # Check that trying to write bytes does not truncate the file.
+        self.assertRaises(TypeError, p.write_text, b'somebytes', encoding='utf-8')
+        self.assertEqual(self.ground.readbytes(p), b'\xe4bcdefg')
+
+    @unittest.skipIf(
+        not getattr(sys.flags, 'warn_default_encoding', 0),
+        "Requires warn_default_encoding",
+    )
+    def test_write_text_encoding_warning(self):
+        p = self.root / 'fileA'
+        with self.assertWarns(EncodingWarning) as wc:
+            p.write_text('abcdefg')
+        self.assertEqual(wc.filename, __file__)
+
+    def test_write_text_with_newlines(self):
+        # Check that `\n` character change nothing
+        p = self.root / 'fileA'
+        p.write_text('abcde\r\nfghlk\n\rmnopq', encoding='utf-8', newline='\n')
+        self.assertEqual(self.ground.readbytes(p), b'abcde\r\nfghlk\n\rmnopq')
+
+        # Check that `\r` character replaces `\n`
+        p = self.root / 'fileB'
+        p.write_text('abcde\r\nfghlk\n\rmnopq', encoding='utf-8', newline='\r')
+        self.assertEqual(self.ground.readbytes(p), b'abcde\r\rfghlk\r\rmnopq')
+
+        # Check that `\r\n` character replaces `\n`
+        p = self.root / 'fileC'
+        p.write_text('abcde\r\nfghlk\n\rmnopq', encoding='utf-8', newline='\r\n')
+        self.assertEqual(self.ground.readbytes(p), 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 = self.root / 'fileD'
+        p.write_text('abcde\nfghlk\n\rmnopq', encoding='utf-8')
+        self.assertEqual(self.ground.readbytes(p),
+                         b'abcde' + os_linesep_byte +
+                         b'fghlk' + os_linesep_byte + b'\rmnopq')
+
+    def test_mkdir(self):
+        p = self.root / 'newdirA'
+        self.assertFalse(self.ground.isdir(p))
+        p.mkdir()
+        self.assertTrue(self.ground.isdir(p))
+
+    def test_symlink_to(self):
+        if not self.ground.can_symlink:
+            self.skipTest('needs symlinks')
+        link = self.root.joinpath('linkA')
+        link.symlink_to('fileA')
+        self.assertTrue(self.ground.islink(link))
+        self.assertEqual(self.ground.readlink(link), 'fileA')
+
+
+class ZipPathWriteTest(WriteTestBase, unittest.TestCase):
+    ground = ZipPathGround(WritableZipPath)
+
+
+class LocalPathWriteTest(WriteTestBase, unittest.TestCase):
+    ground = LocalPathGround(WritableLocalPath)
+
+
+if not is_pypi:
+    from pathlib import Path
+
+    class PathWriteTest(WriteTestBase, unittest.TestCase):
+        ground = LocalPathGround(Path)
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/Lib/test/test_peepholer.py b/Lib/test/test_peepholer.py
index c5c10cb5318..08830c25ae7 100644
--- a/Lib/test/test_peepholer.py
+++ b/Lib/test/test_peepholer.py
@@ -82,7 +82,6 @@ def check_lnotab(self, code):
         # 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):
@@ -133,7 +132,6 @@ def f():
         self.assertInBytecode(f, 'LOAD_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():
@@ -160,7 +158,7 @@ def test_pack_unpack(self):
                 self.assertNotInBytecode(code, 'UNPACK_SEQUENCE')
                 self.check_lnotab(code)
 
-    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AssertionError: 1 != 2
     def test_constant_folding_tuples_of_constants(self):
         for line, elem in (
             ('a = 1,2,3', (1, 2, 3)),
@@ -283,7 +281,7 @@ def test_constant_folding_small_int(self):
                     self.assertNotInBytecode(code, 'LOAD_SMALL_INT')
                 self.check_lnotab(code)
 
-    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AssertionError: 'UNARY_NEGATIVE' starts with 'UNARY_'
     def test_constant_folding_unaryop(self):
         intrinsic_positive = 5
         tests = [
@@ -329,7 +327,7 @@ def negzero():
             self.assertNotStartsWith(instr.opname, 'UNARY_')
         self.check_lnotab(negzero)
 
-    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; BINARY_OP               26 ([])
     def test_constant_folding_binop(self):
         tests = [
             ('1 + 2', 'NB_ADD', True, 'LOAD_SMALL_INT', 3),
@@ -531,7 +529,6 @@ def f(x):
         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):
@@ -546,7 +543,6 @@ def f(cond, true_value, false_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():
@@ -560,7 +556,7 @@ def f():
         self.check_jump_targets(f)
         self.check_lnotab(f)
 
-    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; KeyError: 38
     def test_elim_jump_to_uncond_jump2(self):
         # POP_JUMP_IF_FALSE to JUMP_BACKWARD --> POP_JUMP_IF_FALSE to non-jump
         def f():
@@ -572,7 +568,6 @@ def f():
         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
@@ -606,7 +601,7 @@ def f(a, b, c):
         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
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; KeyError: 6
     def test_elim_jump_to_uncond_jump4(self):
         def f():
             for i in range(5):
@@ -614,7 +609,6 @@ def f():
                     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):
@@ -641,6 +635,7 @@ def g()->1+1:
         self.assertNotInBytecode(f, 'BINARY_OP')
         self.check_lnotab(f)
 
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; no BUILD_LIST to BUILD_TUPLE optimization
     def test_in_literal_list(self):
         def containtest():
             return x in [a, b]
@@ -683,7 +678,7 @@ def f(x):
             return 6
         self.check_lnotab(f)
 
-    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AssertionError: 2 != 1
     def test_assignment_idiom_in_comprehensions(self):
         def listcomp():
             return [y for x in a for y in [f(x)]]
@@ -743,7 +738,7 @@ def format(fmt, *values):
         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
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; ValueError: unsupported format character 'z' (0x7a) at index 3
     def test_format_errors(self):
         with self.assertRaisesRegex(TypeError,
                     'not enough arguments for format string'):
@@ -863,14 +858,13 @@ 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_BORROW_LOAD_FAST_BORROW')
 
-    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; RETURN_VALUE
     def test_load_fast_unknown_simple(self):
         def f():
             if condition():
@@ -879,7 +873,7 @@ def f():
         self.assertInBytecode(f, 'LOAD_FAST_CHECK')
         self.assertNotInBytecode(f, 'LOAD_FAST')
 
-    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; RETURN_VALUE
     def test_load_fast_unknown_because_del(self):
         def f():
             x = 1
@@ -888,7 +882,6 @@ def f():
         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)
@@ -915,7 +908,7 @@ def f5(x=0):
         self.assertInBytecode(f5, 'LOAD_FAST_BORROW')
         self.assertNotInBytecode(f5, 'LOAD_FAST_CHECK')
 
-    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; RETURN_VALUE
     def test_load_fast_known_because_already_loaded(self):
         def f():
             if condition():
@@ -925,7 +918,6 @@ def f():
         self.assertInBytecode(f, 'LOAD_FAST_CHECK')
         self.assertInBytecode(f, 'LOAD_FAST_BORROW')
 
-    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_load_fast_known_multiple_branches(self):
         def f():
             if condition():
@@ -936,7 +928,7 @@ def f():
         self.assertInBytecode(f, 'LOAD_FAST_BORROW')
         self.assertNotInBytecode(f, 'LOAD_FAST_CHECK')
 
-    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; L5 to L6 -> L6 [1] lasti
     def test_load_fast_unknown_after_error(self):
         def f():
             try:
@@ -948,7 +940,7 @@ def f():
         # Assert that it doesn't occur in the LOAD_FAST_CHECK branch.
         self.assertInBytecode(f, 'LOAD_FAST_CHECK')
 
-    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; L5 to L6 -> L6 [1] lasti
     def test_load_fast_unknown_after_error_2(self):
         def f():
             try:
@@ -959,7 +951,7 @@ def f():
         self.assertInBytecode(f, 'LOAD_FAST_CHECK')
         self.assertNotInBytecode(f, 'LOAD_FAST')
 
-    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; RETURN_VALUE
     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
@@ -1034,7 +1026,7 @@ def trace(frame, event, arg):
         self.assertNotInBytecode(f, "LOAD_FAST_CHECK")
         self.assertEqual(f.__code__.co_code, co_code)
 
-    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AssertionError: RuntimeWarning not triggered
     def test_setting_lineno_one_undefined(self):
         code = textwrap.dedent("""\
             def f():
@@ -1069,7 +1061,7 @@ def trace(frame, event, arg):
         self.assertNotInBytecode(f, "LOAD_FAST_CHECK")
         self.assertEqual(f.__code__.co_code, co_code)
 
-    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AssertionError: RuntimeWarning not triggered
     def test_setting_lineno_two_undefined(self):
         code = textwrap.dedent("""\
             def f():
diff --git a/Lib/test/test_pep646_syntax.py b/Lib/test/test_pep646_syntax.py
new file mode 100644
index 00000000000..d9a0aa9a90e
--- /dev/null
+++ b/Lib/test/test_pep646_syntax.py
@@ -0,0 +1,338 @@
+import doctest
+import unittest
+
+doctests = """
+
+Setup
+
+    >>> class AClass:
+    ...    def __init__(self):
+    ...        self._setitem_name = None
+    ...        self._setitem_val = None
+    ...        self._delitem_name = None
+    ...    def __setitem__(self, name, val):
+    ...        self._delitem_name = None
+    ...        self._setitem_name = name
+    ...        self._setitem_val = val
+    ...    def __repr__(self):
+    ...        if self._setitem_name is not None:
+    ...            return f"A[{self._setitem_name}]={self._setitem_val}"
+    ...        elif self._delitem_name is not None:
+    ...            return f"delA[{self._delitem_name}]"
+    ...    def __getitem__(self, name):
+    ...        return ParameterisedA(name)
+    ...    def __delitem__(self, name):
+    ...        self._setitem_name = None
+    ...        self._delitem_name = name
+    ...
+    >>> class ParameterisedA:
+    ...    def __init__(self, name):
+    ...        self._name = name
+    ...    def __repr__(self):
+    ...        return f"A[{self._name}]"
+    ...    def __iter__(self):
+    ...        for p in self._name:
+    ...            yield p
+    >>> class B:
+    ...    def __iter__(self):
+    ...        yield StarredB()
+    ...    def __repr__(self):
+    ...        return "B"
+    >>> class StarredB:
+    ...    def __repr__(self):
+    ...        return "StarredB"
+    >>> A = AClass()
+    >>> b = B()
+
+Slices that are supposed to work, starring our custom B class
+
+    >>> A[*b]
+    A[(StarredB,)]
+    >>> A[*b] = 1; A
+    A[(StarredB,)]=1
+    >>> del A[*b]; A
+    delA[(StarredB,)]
+
+    >>> A[*b, *b]
+    A[(StarredB, StarredB)]
+    >>> A[*b, *b] = 1; A
+    A[(StarredB, StarredB)]=1
+    >>> del A[*b, *b]; A
+    delA[(StarredB, StarredB)]
+
+    >>> A[b, *b]
+    A[(B, StarredB)]
+    >>> A[b, *b] = 1; A
+    A[(B, StarredB)]=1
+    >>> del A[b, *b]; A
+    delA[(B, StarredB)]
+
+    >>> A[*b, b]
+    A[(StarredB, B)]
+    >>> A[*b, b] = 1; A
+    A[(StarredB, B)]=1
+    >>> del A[*b, b]; A
+    delA[(StarredB, B)]
+
+    >>> A[b, b, *b]
+    A[(B, B, StarredB)]
+    >>> A[b, b, *b] = 1; A
+    A[(B, B, StarredB)]=1
+    >>> del A[b, b, *b]; A
+    delA[(B, B, StarredB)]
+
+    >>> A[*b, b, b]
+    A[(StarredB, B, B)]
+    >>> A[*b, b, b] = 1; A
+    A[(StarredB, B, B)]=1
+    >>> del A[*b, b, b]; A
+    delA[(StarredB, B, B)]
+
+    >>> A[b, *b, b]
+    A[(B, StarredB, B)]
+    >>> A[b, *b, b] = 1; A
+    A[(B, StarredB, B)]=1
+    >>> del A[b, *b, b]; A
+    delA[(B, StarredB, B)]
+
+    >>> A[b, b, *b, b]
+    A[(B, B, StarredB, B)]
+    >>> A[b, b, *b, b] = 1; A
+    A[(B, B, StarredB, B)]=1
+    >>> del A[b, b, *b, b]; A
+    delA[(B, B, StarredB, B)]
+
+    >>> A[b, *b, b, b]
+    A[(B, StarredB, B, B)]
+    >>> A[b, *b, b, b] = 1; A
+    A[(B, StarredB, B, B)]=1
+    >>> del A[b, *b, b, b]; A
+    delA[(B, StarredB, B, B)]
+
+    >>> A[A[b, *b, b]]
+    A[A[(B, StarredB, B)]]
+    >>> A[A[b, *b, b]] = 1; A
+    A[A[(B, StarredB, B)]]=1
+    >>> del A[A[b, *b, b]]; A
+    delA[A[(B, StarredB, B)]]
+
+    >>> A[*A[b, *b, b]]
+    A[(B, StarredB, B)]
+    >>> A[*A[b, *b, b]] = 1; A
+    A[(B, StarredB, B)]=1
+    >>> del A[*A[b, *b, b]]; A
+    delA[(B, StarredB, B)]
+
+    >>> A[b, ...]
+    A[(B, Ellipsis)]
+    >>> A[b, ...] = 1; A
+    A[(B, Ellipsis)]=1
+    >>> del A[b, ...]; A
+    delA[(B, Ellipsis)]
+
+    >>> A[*A[b, ...]]
+    A[(B, Ellipsis)]
+    >>> A[*A[b, ...]] = 1; A
+    A[(B, Ellipsis)]=1
+    >>> del A[*A[b, ...]]; A
+    delA[(B, Ellipsis)]
+
+Slices that are supposed to work, starring a list
+
+    >>> l = [1, 2, 3]
+
+    >>> A[*l]
+    A[(1, 2, 3)]
+    >>> A[*l] = 1; A
+    A[(1, 2, 3)]=1
+    >>> del A[*l]; A
+    delA[(1, 2, 3)]
+
+    >>> A[*l, 4]
+    A[(1, 2, 3, 4)]
+    >>> A[*l, 4] = 1; A
+    A[(1, 2, 3, 4)]=1
+    >>> del A[*l, 4]; A
+    delA[(1, 2, 3, 4)]
+
+    >>> A[0, *l]
+    A[(0, 1, 2, 3)]
+    >>> A[0, *l] = 1; A
+    A[(0, 1, 2, 3)]=1
+    >>> del A[0, *l]; A
+    delA[(0, 1, 2, 3)]
+
+    >>> A[1:2, *l]
+    A[(slice(1, 2, None), 1, 2, 3)]
+    >>> A[1:2, *l] = 1; A
+    A[(slice(1, 2, None), 1, 2, 3)]=1
+    >>> del A[1:2, *l]; A
+    delA[(slice(1, 2, None), 1, 2, 3)]
+
+    >>> repr(A[1:2, *l]) == repr(A[1:2, 1, 2, 3])
+    True
+
+Slices that are supposed to work, starring a tuple
+
+    >>> t = (1, 2, 3)
+
+    >>> A[*t]
+    A[(1, 2, 3)]
+    >>> A[*t] = 1; A
+    A[(1, 2, 3)]=1
+    >>> del A[*t]; A
+    delA[(1, 2, 3)]
+
+    >>> A[*t, 4]
+    A[(1, 2, 3, 4)]
+    >>> A[*t, 4] = 1; A
+    A[(1, 2, 3, 4)]=1
+    >>> del A[*t, 4]; A
+    delA[(1, 2, 3, 4)]
+
+    >>> A[0, *t]
+    A[(0, 1, 2, 3)]
+    >>> A[0, *t] = 1; A
+    A[(0, 1, 2, 3)]=1
+    >>> del A[0, *t]; A
+    delA[(0, 1, 2, 3)]
+
+    >>> A[1:2, *t]
+    A[(slice(1, 2, None), 1, 2, 3)]
+    >>> A[1:2, *t] = 1; A
+    A[(slice(1, 2, None), 1, 2, 3)]=1
+    >>> del A[1:2, *t]; A
+    delA[(slice(1, 2, None), 1, 2, 3)]
+
+    >>> repr(A[1:2, *t]) == repr(A[1:2, 1, 2, 3])
+    True
+
+Starring an expression (rather than a name) in a slice
+
+    >>> def returns_list():
+    ...     return [1, 2, 3]
+
+    >>> A[returns_list()]
+    A[[1, 2, 3]]
+    >>> A[returns_list()] = 1; A
+    A[[1, 2, 3]]=1
+    >>> del A[returns_list()]; A
+    delA[[1, 2, 3]]
+
+    >>> A[returns_list(), 4]
+    A[([1, 2, 3], 4)]
+    >>> A[returns_list(), 4] = 1; A
+    A[([1, 2, 3], 4)]=1
+    >>> del A[returns_list(), 4]; A
+    delA[([1, 2, 3], 4)]
+
+    >>> A[*returns_list()]
+    A[(1, 2, 3)]
+    >>> A[*returns_list()] = 1; A
+    A[(1, 2, 3)]=1
+    >>> del A[*returns_list()]; A
+    delA[(1, 2, 3)]
+
+    >>> A[*returns_list(), 4]
+    A[(1, 2, 3, 4)]
+    >>> A[*returns_list(), 4] = 1; A
+    A[(1, 2, 3, 4)]=1
+    >>> del A[*returns_list(), 4]; A
+    delA[(1, 2, 3, 4)]
+
+    >>> A[0, *returns_list()]
+    A[(0, 1, 2, 3)]
+    >>> A[0, *returns_list()] = 1; A
+    A[(0, 1, 2, 3)]=1
+    >>> del A[0, *returns_list()]; A
+    delA[(0, 1, 2, 3)]
+
+    >>> A[*returns_list(), *returns_list()]
+    A[(1, 2, 3, 1, 2, 3)]
+    >>> A[*returns_list(), *returns_list()] = 1; A
+    A[(1, 2, 3, 1, 2, 3)]=1
+    >>> del A[*returns_list(), *returns_list()]; A
+    delA[(1, 2, 3, 1, 2, 3)]
+
+Using both a starred object and a start:stop in a slice
+(See also tests in test_syntax confirming that starring *inside* a start:stop
+is *not* valid syntax.)
+
+    >>> A[1:2, *b]
+    A[(slice(1, 2, None), StarredB)]
+    >>> A[*b, 1:2]
+    A[(StarredB, slice(1, 2, None))]
+    >>> A[1:2, *b, 1:2]
+    A[(slice(1, 2, None), StarredB, slice(1, 2, None))]
+    >>> A[*b, 1:2, *b]
+    A[(StarredB, slice(1, 2, None), StarredB)]
+
+    >>> A[1:, *b]
+    A[(slice(1, None, None), StarredB)]
+    >>> A[*b, 1:]
+    A[(StarredB, slice(1, None, None))]
+    >>> A[1:, *b, 1:]
+    A[(slice(1, None, None), StarredB, slice(1, None, None))]
+    >>> A[*b, 1:, *b]
+    A[(StarredB, slice(1, None, None), StarredB)]
+
+    >>> A[:1, *b]
+    A[(slice(None, 1, None), StarredB)]
+    >>> A[*b, :1]
+    A[(StarredB, slice(None, 1, None))]
+    >>> A[:1, *b, :1]
+    A[(slice(None, 1, None), StarredB, slice(None, 1, None))]
+    >>> A[*b, :1, *b]
+    A[(StarredB, slice(None, 1, None), StarredB)]
+
+    >>> A[:, *b]
+    A[(slice(None, None, None), StarredB)]
+    >>> A[*b, :]
+    A[(StarredB, slice(None, None, None))]
+    >>> A[:, *b, :]
+    A[(slice(None, None, None), StarredB, slice(None, None, None))]
+    >>> A[*b, :, *b]
+    A[(StarredB, slice(None, None, None), StarredB)]
+
+*args annotated as starred expression
+
+    >>> def f1(*args: *b): pass
+    >>> f1.__annotations__
+    {'args': StarredB}
+
+    >>> def f2(*args: *b, arg1): pass
+    >>> f2.__annotations__
+    {'args': StarredB}
+
+    >>> def f3(*args: *b, arg1: int): pass
+    >>> f3.__annotations__ # TODO: RUSTPYTHON # doctest: +EXPECTED_FAILURE
+    {'args': StarredB, 'arg1': <class 'int'>}
+
+    >>> def f4(*args: *b, arg1: int = 2): pass
+    >>> f4.__annotations__ # TODO: RUSTPYTHON # doctest: +EXPECTED_FAILURE
+    {'args': StarredB, 'arg1': <class 'int'>}
+
+    >>> def f5(*args: *b = (1,)): pass # TODO: RUSTPYTHON # doctest: +EXPECTED_FAILURE
+    Traceback (most recent call last):
+        ...
+    SyntaxError: invalid syntax
+"""
+
+__test__ = {'doctests' : doctests}
+
+EXPECTED_FAILURE = doctest.register_optionflag('EXPECTED_FAILURE') # TODO: RUSTPYTHON
+class CustomOutputChecker(doctest.OutputChecker): # TODO: RUSTPYTHON
+    def check_output(self, want, got, optionflags): # TODO: RUSTPYTHON
+        if optionflags & EXPECTED_FAILURE: # TODO: RUSTPYTHON
+            if want == got: # TODO: RUSTPYTHON
+                return False # TODO: RUSTPYTHON
+            return True # TODO: RUSTPYTHON
+        return super().check_output(want, got, optionflags) # TODO: RUSTPYTHON
+
+def load_tests(loader, tests, pattern):
+    tests.addTest(doctest.DocTestSuite(checker=CustomOutputChecker())) # TODO: RUSTPYTHON
+    return tests
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/Lib/test/test_perfmaps.py b/Lib/test/test_perfmaps.py
new file mode 100644
index 00000000000..d4c6fe0124a
--- /dev/null
+++ b/Lib/test/test_perfmaps.py
@@ -0,0 +1,23 @@
+import os
+import sys
+import unittest
+
+try:
+    from _testinternalcapi import perf_map_state_teardown, write_perf_map_entry
+except ImportError:
+    raise unittest.SkipTest("requires _testinternalcapi")
+
+
+if sys.platform != 'linux':
+    raise unittest.SkipTest('Linux only')
+
+
+class TestPerfMapWriting(unittest.TestCase):
+    def test_write_perf_map_entry(self):
+        self.assertEqual(write_perf_map_entry(0x1234, 5678, "entry1"), 0)
+        self.assertEqual(write_perf_map_entry(0x2345, 6789, "entry2"), 0)
+        with open(f"/tmp/perf-{os.getpid()}.map") as f:
+            perf_file_contents = f.read()
+            self.assertIn("1234 162e entry1", perf_file_contents)
+            self.assertIn("2345 1a85 entry2", perf_file_contents)
+        perf_map_state_teardown()
diff --git a/Lib/test/test_pickle.py b/Lib/test/test_pickle.py
index 6135cb75d76..c9d4a348448 100644
--- a/Lib/test/test_pickle.py
+++ b/Lib/test/test_pickle.py
@@ -1,18 +1,22 @@
 from _compat_pickle import (IMPORT_MAPPING, REVERSE_IMPORT_MAPPING,
                             NAME_MAPPING, REVERSE_NAME_MAPPING)
 import builtins
-import pickle
-import io
 import collections
+import contextlib
+import io
+import pickle
 import struct
 import sys
+import tempfile
 import warnings
 import weakref
+from textwrap import dedent
 
 import doctest
 import unittest
 from test import support
-from test.support import import_helper
+from test.support import cpython_only, import_helper, os_helper
+from test.support.import_helper import ensure_lazy_imports
 
 from test.pickletester import AbstractHookTests
 from test.pickletester import AbstractUnpickleTests
@@ -33,6 +37,12 @@
     has_c_implementation = False
 
 
+class LazyImportTest(unittest.TestCase):
+    @cpython_only
+    def test_lazy_import(self):
+        ensure_lazy_imports("pickle", {"re"})
+
+
 class PyPickleTests(AbstractPickleModuleTests, unittest.TestCase):
     dump = staticmethod(pickle._dump)
     dumps = staticmethod(pickle._dumps)
@@ -41,14 +51,12 @@ class PyPickleTests(AbstractPickleModuleTests, unittest.TestCase):
     Pickler = pickle._Pickler
     Unpickler = pickle._Unpickler
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    def test_dump_load_oob_buffers(self): # TODO(RUSTPYTHON): Remove this test when it passes
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    def test_dump_load_oob_buffers(self):
         return super().test_dump_load_oob_buffers()
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    def test_dumps_loads_oob_buffers(self): # TODO(RUSTPYTHON): Remove this test when it passes
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    def test_dumps_loads_oob_buffers(self):
         return super().test_dumps_loads_oob_buffers()
 
 
@@ -65,21 +73,6 @@ def loads(self, buf, **kwds):
         u = self.unpickler(f, **kwds)
         return u.load()
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    def test_badly_escaped_string(self): # TODO(RUSTPYTHON): Remove this test when it passes
-        return super().test_badly_escaped_string()
-
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    def test_correctly_quoted_string(self): # TODO(RUSTPYTHON): Remove this test when it passes
-        return super().test_correctly_quoted_string()
-    
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    def test_load_python2_str_as_bytes(self): # TODO(RUSTPYTHON): Remove this test when it passes
-        return super().test_load_python2_str_as_bytes()
-
 
 class PyPicklingErrorTests(AbstractPicklingErrorTests, unittest.TestCase):
 
@@ -92,22 +85,18 @@ def dumps(self, arg, proto=None, **kwargs):
         f.seek(0)
         return bytes(f.read())
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    def test_picklebuffer_error(self): # TODO(RUSTPYTHON): Remove this test when it passes
-        return super().test_picklebuffer_error()
-
-
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    def test_buffer_callback_error(self): # TODO(RUSTPYTHON): Remove this test when it passes
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    def test_buffer_callback_error(self):
         return super().test_buffer_callback_error()
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    def test_non_continuous_buffer(self): # TODO(RUSTPYTHON): Remove this test when it passes
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    def test_non_continuous_buffer(self):
         return super().test_non_continuous_buffer()
 
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    def test_picklebuffer_error(self):
+        return super().test_picklebuffer_error()
+
 
 class PyPicklerTests(AbstractPickleTests, unittest.TestCase):
 
@@ -126,41 +115,35 @@ def loads(self, buf, **kwds):
         u = self.unpickler(f, **kwds)
         return u.load()
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    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
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    def test_buffers_error(self):
         return super().test_buffers_error()
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    def test_bytearray_memoization(self): # TODO(RUSTPYTHON): Remove this test when it passes
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    def test_bytearray_memoization(self):
         return super().test_bytearray_memoization()
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    def test_bytes_memoization(self): # TODO(RUSTPYTHON): Remove this test when it passes
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    def test_bytes_memoization(self):
         return super().test_bytes_memoization()
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    def test_in_band_buffers(self): # TODO(RUSTPYTHON): Remove this test when it passes
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    def test_c_methods(self):
+        return super().test_c_methods()
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    def test_in_band_buffers(self):
         return super().test_in_band_buffers()
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    def test_oob_buffers(self): # TODO(RUSTPYTHON): Remove this test when it passes
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    def test_oob_buffers(self):
         return super().test_oob_buffers()
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    def test_oob_buffers_writable_to_readonly(self): # TODO(RUSTPYTHON): Remove this test when it passes
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    def test_oob_buffers_writable_to_readonly(self):
         return super().test_oob_buffers_writable_to_readonly()
 
+
 class InMemoryPickleTests(AbstractPickleTests, AbstractUnpickleTests,
                           BigmemPickleTests, unittest.TestCase):
 
@@ -179,56 +162,35 @@ def loads(self, buf, **kwds):
     test_find_class = None
     test_custom_find_class = None
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    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
-        return super().test_badly_escaped_string()
-
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    def test_correctly_quoted_string(self): # TODO(RUSTPYTHON): Remove this test when it passes
-        return super().test_correctly_quoted_string()
-
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    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
-        return super().test_oob_buffers_writable_to_readonly()
-
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    def test_buffers_error(self): # TODO(RUSTPYTHON): Remove this test when it passes
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    def test_buffers_error(self):
         return super().test_buffers_error()
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    def test_bytearray_memoization(self): # TODO(RUSTPYTHON): Remove this test when it passes
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    def test_bytearray_memoization(self):
         return super().test_bytearray_memoization()
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    def test_bytes_memoization(self): # TODO(RUSTPYTHON): Remove this test when it passes
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    def test_bytes_memoization(self):
         return super().test_bytes_memoization()
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    def test_in_band_buffers(self): # TODO(RUSTPYTHON): Remove this test when it passes
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    def test_c_methods(self):
+        return super().test_c_methods()
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    def test_in_band_buffers(self):
         return super().test_in_band_buffers()
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    def test_oob_buffers(self): # TODO(RUSTPYTHON): Remove this test when it passes
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    def test_oob_buffers(self):
         return super().test_oob_buffers()
 
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    def test_oob_buffers_writable_to_readonly(self):
+        return super().test_oob_buffers_writable_to_readonly()
+
+
 class PersistentPicklerUnpicklerMixin(object):
 
     def dumps(self, arg, proto=None):
@@ -451,6 +413,7 @@ def _persistent_load(subself, pid):
             del unpickler.persistent_load
             self.assertEqual(unpickler.persistent_load, old_persistent_load)
 
+
 class PyPicklerUnpicklerObjectTests(AbstractPicklerUnpicklerObjectTests, unittest.TestCase):
 
     pickler_class = pickle._Pickler
@@ -526,6 +489,46 @@ def test_issue18339(self):
                 unpickler.memo = {-1: None}
             unpickler.memo = {1: None}
 
+        def test_concurrent_pickler_dump(self):
+            f = io.BytesIO()
+            pickler = self.pickler_class(f)
+            class X:
+                def __reduce__(slf):
+                    self.assertRaises(RuntimeError, pickler.dump, 42)
+                    return list, ()
+            pickler.dump(X())  # should not crash
+            self.assertEqual(pickle.loads(f.getvalue()), [])
+
+        def test_concurrent_pickler_dump_and_init(self):
+            f = io.BytesIO()
+            pickler = self.pickler_class(f)
+            class X:
+                def __reduce__(slf):
+                    self.assertRaises(RuntimeError, pickler.__init__, f)
+                    return list, ()
+            pickler.dump([X()])  # should not fail
+            self.assertEqual(pickle.loads(f.getvalue()), [[]])
+
+        def test_concurrent_unpickler_load(self):
+            global reducer
+            def reducer():
+                self.assertRaises(RuntimeError, unpickler.load)
+                return 42
+            f = io.BytesIO(b'(c%b\nreducer\n(tRl.' % (__name__.encode(),))
+            unpickler = self.unpickler_class(f)
+            unpickled = unpickler.load()  # should not fail
+            self.assertEqual(unpickled, [42])
+
+        def test_concurrent_unpickler_load_and_init(self):
+            global reducer
+            def reducer():
+                self.assertRaises(RuntimeError, unpickler.__init__, f)
+                return 42
+            f = io.BytesIO(b'(c%b\nreducer\n(tRl.' % (__name__.encode(),))
+            unpickler = self.unpickler_class(f)
+            unpickled = unpickler.load()  # should not crash
+            self.assertEqual(unpickled, [42])
+
     class CDispatchTableTests(AbstractDispatchTableTests, unittest.TestCase):
         pickler_class = pickle.Pickler
         def get_dispatch_table(self):
@@ -574,7 +577,7 @@ class SizeofTests(unittest.TestCase):
         check_sizeof = support.check_sizeof
 
         def test_pickler(self):
-            basesize = support.calcobjsize('7P2n3i2n3i2P')
+            basesize = support.calcobjsize('7P2n3i2n4i2P')
             p = _pickle.Pickler(io.BytesIO())
             self.assertEqual(object.__sizeof__(p), basesize)
             MT_size = struct.calcsize('3nP0n')
@@ -591,7 +594,7 @@ def test_pickler(self):
                 0)  # Write buffer is cleared after every dump().
 
         def test_unpickler(self):
-            basesize = support.calcobjsize('2P2n2P 2P2n2i5P 2P3n8P2n2i')
+            basesize = support.calcobjsize('2P2n2P 2P2n2i5P 2P3n8P2n3i')
             unpickler = _pickle.Unpickler
             P = struct.calcsize('P')  # Size of memo table entry.
             n = struct.calcsize('n')  # Size of mark table entry.
@@ -724,10 +727,10 @@ def test_name_mapping(self):
             with self.subTest(((module3, name3), (module2, name2))):
                 if (module2, name2) == ('exceptions', 'OSError'):
                     attr = getattribute(module3, name3)
-                    self.assertTrue(issubclass(attr, OSError))
+                    self.assertIsSubclass(attr, OSError)
                 elif (module2, name2) == ('exceptions', 'ImportError'):
                     attr = getattribute(module3, name3)
-                    self.assertTrue(issubclass(attr, ImportError))
+                    self.assertIsSubclass(attr, ImportError)
                 else:
                     module, name = mapping(module2, name2)
                     if module3[:1] != '_':
@@ -772,8 +775,7 @@ def test_reverse_name_mapping(self):
                 module, name = mapping(module, name)
                 self.assertEqual((module, name), (module3, name3))
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_exceptions(self):
         self.assertEqual(mapping('exceptions', 'StandardError'),
                          ('builtins', 'Exception'))
@@ -823,6 +825,60 @@ def test_multiprocessing_exceptions(self):
                 self.assertEqual(mapping('multiprocessing', name),
                                  ('multiprocessing.context', name))
 
+
+class CommandLineTest(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 dedent(string).strip()
+
+    def set_pickle_data(self, data):
+        with open(self.filename, 'wb') as f:
+            pickle.dump(data, f)
+
+    def invoke_pickle(self, *flags):
+        output = io.StringIO()
+        with contextlib.redirect_stdout(output):
+            pickle._main(args=[*flags, self.filename])
+        return self.text_normalize(output.getvalue())
+
+    def test_invocation(self):
+        # test 'python -m pickle pickle_file'
+        data = {
+            'a': [1, 2.0, 3+4j],
+            'b': ('character string', b'byte string'),
+            'c': 'string'
+        }
+        expect = '''
+            {'a': [1, 2.0, (3+4j)],
+             'b': ('character string', b'byte string'),
+             'c': 'string'}
+        '''
+        self.set_pickle_data(data)
+
+        with self.subTest(data=data):
+            res = self.invoke_pickle()
+            expect = self.text_normalize(expect)
+            self.assertListEqual(res.splitlines(), expect.splitlines())
+
+    @support.force_not_colorized
+    def test_unknown_flag(self):
+        stderr = io.StringIO()
+        with self.assertRaises(SystemExit):
+            # check that the parser help is shown
+            with contextlib.redirect_stderr(stderr):
+                _ = self.invoke_pickle('--unknown')
+        self.assertStartsWith(stderr.getvalue(), 'usage: ')
+
+
 def load_tests(loader, tests, pattern):
     tests.addTest(doctest.DocTestSuite(pickle))
     return tests
diff --git a/Lib/test/test_picklebuffer.py b/Lib/test/test_picklebuffer.py
index a14f6a86b4f..f63be69cfc8 100644
--- a/Lib/test/test_picklebuffer.py
+++ b/Lib/test/test_picklebuffer.py
@@ -34,8 +34,7 @@ def check_memoryview(self, pb, equiv):
                 self.assertEqual(m.format, expected.format)
                 self.assertEqual(m.tobytes(), expected.tobytes())
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_constructor_failure(self):
         with self.assertRaises(TypeError):
             PickleBuffer()
@@ -47,8 +46,7 @@ def test_constructor_failure(self):
         with self.assertRaises(ValueError):
             PickleBuffer(m)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_basics(self):
         pb = PickleBuffer(b"foo")
         self.assertEqual(b"foo", bytes(pb))
@@ -62,8 +60,7 @@ def test_basics(self):
             m[0] = 48
         self.assertEqual(b"0oo", bytes(pb))
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_release(self):
         pb = PickleBuffer(b"foo")
         pb.release()
@@ -74,8 +71,7 @@ def test_release(self):
         # Idempotency
         pb.release()
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_cycle(self):
         b = B(b"foo")
         pb = PickleBuffer(b)
@@ -85,8 +81,7 @@ def test_cycle(self):
         gc.collect()
         self.assertIsNone(wpb())
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_ndarray_2d(self):
         # C-contiguous
         ndarray = import_helper.import_module("_testbuffer").ndarray
@@ -110,23 +105,20 @@ def test_ndarray_2d(self):
 
     # Tests for PickleBuffer.raw()
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def check_raw(self, obj, equiv):
         pb = PickleBuffer(obj)
         with pb.raw() as m:
             self.assertIsInstance(m, memoryview)
             self.check_memoryview(m, equiv)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_raw(self):
         for obj in (b"foo", bytearray(b"foo")):
             with self.subTest(obj=obj):
                 self.check_raw(obj, obj)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_raw_ndarray(self):
         # 1-D, contiguous
         ndarray = import_helper.import_module("_testbuffer").ndarray
@@ -148,15 +140,13 @@ def test_raw_ndarray(self):
         equiv = b'\xc8\x01\x00\x00'
         self.check_raw(arr, equiv)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def check_raw_non_contiguous(self, obj):
         pb = PickleBuffer(obj)
         with self.assertRaisesRegex(BufferError, "non-contiguous"):
             pb.raw()
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_raw_non_contiguous(self):
         # 1-D
         ndarray = import_helper.import_module("_testbuffer").ndarray
@@ -166,8 +156,7 @@ def test_raw_non_contiguous(self):
         arr = ndarray(list(range(12)), shape=(4, 3), format='<i')[::2]
         self.check_raw_non_contiguous(arr)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_raw_released(self):
         pb = PickleBuffer(b"foo")
         pb.release()
diff --git a/Lib/test/test_pickletools.py b/Lib/test/test_pickletools.py
index 6ec8b348f58..1a6256e097a 100644
--- a/Lib/test/test_pickletools.py
+++ b/Lib/test/test_pickletools.py
@@ -62,41 +62,34 @@ def test_optimize_binput_and_memoize(self):
         self.assertIs(unpickled2[1], unpickled2[2])
         self.assertNotIn(pickle.BINPUT, pickled2)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    def test_buffers_error(self): # TODO(RUSTPYTHON): Remove this test when it passes
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    def test_buffers_error(self):
         return super().test_buffers_error()
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    def test_bytearray_memoization(self): # TODO(RUSTPYTHON): Remove this test when it passes
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    def test_bytearray_memoization(self):
         return super().test_bytearray_memoization()
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    def test_bytes_memoization(self): # TODO(RUSTPYTHON): Remove this test when it passes
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    def test_bytes_memoization(self):
         return super().test_bytes_memoization()
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    def test_in_band_buffers(self): # TODO(RUSTPYTHON): Remove this test when it passes
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    def test_c_methods(self):
+        return super().test_c_methods()
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    def test_in_band_buffers(self):
         return super().test_in_band_buffers()
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    def test_oob_buffers(self): # TODO(RUSTPYTHON): Remove this test when it passes
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    def test_oob_buffers(self):
         return super().test_oob_buffers()
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    def test_oob_buffers_writable_to_readonly(self): # TODO(RUSTPYTHON): Remove this test when it passes
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    def test_oob_buffers_writable_to_readonly(self):
         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
-        return super().test_c_methods()
-
 
 class SimpleReader:
     def __init__(self, data):
@@ -241,7 +234,7 @@ def test_mark_without_pos(self):
     def test_no_mark(self):
         self.check_dis_error(b'Nt.', '''\
     0: N    NONE
-    1: t    TUPLE      no MARK exists on stack
+    1: t    TUPLE
 ''', 'no MARK exists on stack')
 
     def test_put(self):
@@ -256,26 +249,16 @@ def test_put(self):
 ''')
 
     def test_put_redefined(self):
-        self.check_dis_error(b'Np1\np1\n.', '''\
+        self.check_dis(b'Np1\np1\nq\x01r\x01\x00\x00\x00\x94.', '''\
     0: N    NONE
     1: p    PUT        1
     4: p    PUT        1
-''', 'memo key 1 already defined')
-        self.check_dis_error(b'Np1\nq\x01.', '''\
-    0: N    NONE
-    1: p    PUT        1
-    4: q    BINPUT     1
-''', 'memo key 1 already defined')
-        self.check_dis_error(b'Np1\nr\x01\x00\x00\x00.', '''\
-    0: N    NONE
-    1: p    PUT        1
-    4: r    LONG_BINPUT 1
-''', 'memo key 1 already defined')
-        self.check_dis_error(b'Np1\n\x94.', '''\
-    0: N    NONE
-    1: p    PUT        1
-    4: \\x94 MEMOIZE    (as 1)
-''', 'memo key None already defined')
+    7: q    BINPUT     1
+    9: r    LONG_BINPUT 1
+   14: \\x94 MEMOIZE    (as 1)
+   15: .    STOP
+highest protocol among opcodes = 4
+''')
 
     def test_put_empty_stack(self):
         self.check_dis_error(b'p0\n', '''\
@@ -429,13 +412,13 @@ def test_string_without_quotes(self):
         self.check_dis_error(b'Sabc"\n.', '',
                              "no string quotes around b'abc\"'")
         self.check_dis_error(b"S'abc\n.", '',
-                             '''strinq quote b"'" not found at both ends of b"'abc"''')
+                             '''string quote b"'" not found at both ends of b"'abc"''')
         self.check_dis_error(b'S"abc\n.', '',
-                             r"""strinq quote b'"' not found at both ends of b'"abc'""")
+                             r"""string quote b'"' not found at both ends of b'"abc'""")
         self.check_dis_error(b"S'abc\"\n.", '',
-                             r"""strinq quote b"'" not found at both ends of b'\\'abc"'""")
+                             r"""string quote b"'" not found at both ends of b'\\'abc"'""")
         self.check_dis_error(b"S\"abc'\n.", '',
-                             r"""strinq quote b'"' not found at both ends of b'"abc\\''""")
+                             r"""string quote b'"' not found at both ends of b'"abc\\''""")
 
     def test_binstring(self):
         self.check_dis(b"T\x03\x00\x00\x00abc.", '''\
@@ -488,6 +471,44 @@ def test_persid(self):
 highest protocol among opcodes = 0
 ''')
 
+    def test_constants(self):
+        self.check_dis(b"(NI00\nI01\n\x89\x88t.", '''\
+    0: (    MARK
+    1: N        NONE
+    2: I        INT        False
+    6: I        INT        True
+   10: \\x89     NEWFALSE
+   11: \\x88     NEWTRUE
+   12: t        TUPLE      (MARK at 0)
+   13: .    STOP
+highest protocol among opcodes = 2
+''')
+
+    def test_integers(self):
+        self.check_dis(b"(I0\nI1\nI10\nI011\nL12\nL13L\nL014\nL015L\nt.", '''\
+    0: (    MARK
+    1: I        INT        0
+    4: I        INT        1
+    7: I        INT        10
+   11: I        INT        11
+   16: L        LONG       12
+   20: L        LONG       13
+   25: L        LONG       14
+   30: L        LONG       15
+   36: t        TUPLE      (MARK at 0)
+   37: .    STOP
+highest protocol among opcodes = 0
+''')
+
+    def test_nondecimal_integers(self):
+        self.check_dis_error(b'I0b10\n.', '', 'invalid literal for int')
+        self.check_dis_error(b'I0o10\n.', '', 'invalid literal for int')
+        self.check_dis_error(b'I0x10\n.', '', 'invalid literal for int')
+        self.check_dis_error(b'L0b10L\n.', '', 'invalid literal for int')
+        self.check_dis_error(b'L0o10L\n.', '', 'invalid literal for int')
+        self.check_dis_error(b'L0x10L\n.', '', 'invalid literal for int')
+
+
 class MiscTestCase(unittest.TestCase):
     def test__all__(self):
         not_exported = {
@@ -522,8 +543,8 @@ def test__all__(self):
 
 
 def load_tests(loader, tests, pattern):
-    # TODO: RUSTPYTHON
-    # tests.addTest(doctest.DocTestSuite(pickletools))
+    from test.support.rustpython import DocTestChecker # TODO: RUSTPYTHON; Remove this
+    tests.addTest(doctest.DocTestSuite(pickletools, checker=DocTestChecker())) # XXX: RUSTPYTHON
     return tests
 
 
diff --git a/Lib/test/test_pkgutil.py b/Lib/test/test_pkgutil.py
index 0d44092dabc..f5444409593 100644
--- a/Lib/test/test_pkgutil.py
+++ b/Lib/test/test_pkgutil.py
@@ -1,6 +1,6 @@
 from pathlib import Path
-from test.support.import_helper import unload, CleanImport
-from test.support.warnings_helper import check_warnings, ignore_warnings
+from test.support.import_helper import unload
+from test.support.warnings_helper import check_warnings
 import unittest
 import sys
 import importlib
@@ -231,7 +231,7 @@ def test_walk_packages_raises_on_string_or_bytes_input(self):
         with self.assertRaises((TypeError, ValueError)):
             list(pkgutil.walk_packages(bytes_input))
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_name_resolution(self):
         import logging
         import logging.handlers
@@ -608,73 +608,6 @@ class ImportlibMigrationTests(unittest.TestCase):
     # 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:
-            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):
-            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):
-            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
-        try:
-            loader = pkgutil.get_loader(name)
-        finally:
-            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_get_importer_avoids_emulation(self):
         # We use an illegal path so *none* of the path hooks should fire
         with check_warnings() as w:
diff --git a/Lib/test/test_plistlib.py b/Lib/test/test_plistlib.py
index cad53c17837..389da145e6d 100644
--- a/Lib/test/test_plistlib.py
+++ b/Lib/test/test_plistlib.py
@@ -752,7 +752,6 @@ def test_non_bmp_characters(self):
                 data = plistlib.dumps(pl, fmt=fmt)
                 self.assertEqual(plistlib.loads(data), pl)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_lone_surrogates(self):
         for fmt in ALL_FORMATS:
             with self.subTest(fmt=fmt):
diff --git a/Lib/test/test_popen.py b/Lib/test/test_popen.py
index e6bfc480cbd..34cda35b17b 100644
--- a/Lib/test/test_popen.py
+++ b/Lib/test/test_popen.py
@@ -57,14 +57,21 @@ def test_return_code(self):
     def test_contextmanager(self):
         with os.popen("echo hello") as f:
             self.assertEqual(f.read(), "hello\n")
+            self.assertFalse(f.closed)
+        self.assertTrue(f.closed)
 
     def test_iterating(self):
         with os.popen("echo hello") as f:
             self.assertEqual(list(f), ["hello\n"])
+            self.assertFalse(f.closed)
+        self.assertTrue(f.closed)
 
     def test_keywords(self):
-        with os.popen(cmd="exit 0", mode="w", buffering=-1):
-            pass
+        with os.popen(cmd="echo hello", mode="r", buffering=-1) as f:
+            self.assertEqual(f.read(), "hello\n")
+            self.assertFalse(f.closed)
+        self.assertTrue(f.closed)
+
 
 if __name__ == "__main__":
     unittest.main()
diff --git a/Lib/test/test_poplib.py b/Lib/test/test_poplib.py
new file mode 100644
index 00000000000..ef2da97f867
--- /dev/null
+++ b/Lib/test/test_poplib.py
@@ -0,0 +1,571 @@
+"""Test script for poplib module."""
+
+# Modified by Giampaolo Rodola' to give poplib.POP3 and poplib.POP3_SSL
+# a real test suite
+
+import poplib
+import socket
+import os
+import errno
+import threading
+
+import unittest
+from unittest import TestCase, skipUnless
+from test import support as test_support
+from test.support import hashlib_helper
+from test.support import socket_helper
+from test.support import threading_helper
+from test.support import asynchat
+from test.support import asyncore
+
+
+test_support.requires_working_socket(module=True)
+
+HOST = socket_helper.HOST
+PORT = 0
+
+SUPPORTS_SSL = False
+if hasattr(poplib, 'POP3_SSL'):
+    import ssl
+
+    SUPPORTS_SSL = True
+    CERTFILE = os.path.join(os.path.dirname(__file__) or os.curdir, "certdata", "keycert3.pem")
+    CAFILE = os.path.join(os.path.dirname(__file__) or os.curdir, "certdata", "pycacert.pem")
+
+requires_ssl = skipUnless(SUPPORTS_SSL, 'SSL not supported')
+
+# the dummy data returned by server when LIST and RETR commands are issued
+LIST_RESP = b'1 1\r\n2 2\r\n3 3\r\n4 4\r\n5 5\r\n.\r\n'
+RETR_RESP = b"""From: postmaster@python.org\
+\r\nContent-Type: text/plain\r\n\
+MIME-Version: 1.0\r\n\
+Subject: Dummy\r\n\
+\r\n\
+line1\r\n\
+line2\r\n\
+line3\r\n\
+.\r\n"""
+
+
+class DummyPOP3Handler(asynchat.async_chat):
+
+    CAPAS = {'UIDL': [], 'IMPLEMENTATION': ['python-testlib-pop-server']}
+    enable_UTF8 = False
+
+    def __init__(self, conn):
+        asynchat.async_chat.__init__(self, conn)
+        self.set_terminator(b"\r\n")
+        self.in_buffer = []
+        self.push('+OK dummy pop3 server ready. <timestamp>')
+        self.tls_active = False
+        self.tls_starting = False
+
+    def collect_incoming_data(self, data):
+        self.in_buffer.append(data)
+
+    def found_terminator(self):
+        line = b''.join(self.in_buffer)
+        line = str(line, 'ISO-8859-1')
+        self.in_buffer = []
+        cmd = line.split(' ')[0].lower()
+        space = line.find(' ')
+        if space != -1:
+            arg = line[space + 1:]
+        else:
+            arg = ""
+        if hasattr(self, 'cmd_' + cmd):
+            method = getattr(self, 'cmd_' + cmd)
+            method(arg)
+        else:
+            self.push('-ERR unrecognized POP3 command "%s".' %cmd)
+
+    def handle_error(self):
+        raise
+
+    def push(self, data):
+        asynchat.async_chat.push(self, data.encode("ISO-8859-1") + b'\r\n')
+
+    def cmd_echo(self, arg):
+        # sends back the received string (used by the test suite)
+        self.push(arg)
+
+    def cmd_user(self, arg):
+        if arg != "guido":
+            self.push("-ERR no such user")
+        self.push('+OK password required')
+
+    def cmd_pass(self, arg):
+        if arg != "python":
+            self.push("-ERR wrong password")
+        self.push('+OK 10 messages')
+
+    def cmd_stat(self, arg):
+        self.push('+OK 10 100')
+
+    def cmd_list(self, arg):
+        if arg:
+            self.push('+OK %s %s' % (arg, arg))
+        else:
+            self.push('+OK')
+            asynchat.async_chat.push(self, LIST_RESP)
+
+    cmd_uidl = cmd_list
+
+    def cmd_retr(self, arg):
+        self.push('+OK %s bytes' %len(RETR_RESP))
+        asynchat.async_chat.push(self, RETR_RESP)
+
+    cmd_top = cmd_retr
+
+    def cmd_dele(self, arg):
+        self.push('+OK message marked for deletion.')
+
+    def cmd_noop(self, arg):
+        self.push('+OK done nothing.')
+
+    def cmd_rpop(self, arg):
+        self.push('+OK done nothing.')
+
+    def cmd_apop(self, arg):
+        self.push('+OK done nothing.')
+
+    def cmd_quit(self, arg):
+        self.push('+OK closing.')
+        self.close_when_done()
+
+    def _get_capas(self):
+        _capas = dict(self.CAPAS)
+        if not self.tls_active and SUPPORTS_SSL:
+            _capas['STLS'] = []
+        return _capas
+
+    def cmd_capa(self, arg):
+        self.push('+OK Capability list follows')
+        if self._get_capas():
+            for cap, params in self._get_capas().items():
+                _ln = [cap]
+                if params:
+                    _ln.extend(params)
+                self.push(' '.join(_ln))
+        self.push('.')
+
+    def cmd_utf8(self, arg):
+        self.push('+OK I know RFC6856'
+                  if self.enable_UTF8
+                  else '-ERR What is UTF8?!')
+
+    if SUPPORTS_SSL:
+
+        def cmd_stls(self, arg):
+            if self.tls_active is False:
+                self.push('+OK Begin TLS negotiation')
+                context = ssl.SSLContext(ssl.PROTOCOL_TLS_SERVER)
+                context.load_cert_chain(CERTFILE)
+                tls_sock = context.wrap_socket(self.socket,
+                                               server_side=True,
+                                               do_handshake_on_connect=False,
+                                               suppress_ragged_eofs=False)
+                self.del_channel()
+                self.set_socket(tls_sock)
+                self.tls_active = True
+                self.tls_starting = True
+                self.in_buffer = []
+                self._do_tls_handshake()
+            else:
+                self.push('-ERR Command not permitted when TLS active')
+
+        def _do_tls_handshake(self):
+            try:
+                self.socket.do_handshake()
+            except ssl.SSLError as err:
+                if err.args[0] in (ssl.SSL_ERROR_WANT_READ,
+                                   ssl.SSL_ERROR_WANT_WRITE):
+                    return
+                elif err.args[0] == ssl.SSL_ERROR_EOF:
+                    return self.handle_close()
+                # TODO: SSLError does not expose alert information
+                elif ("SSLV3_ALERT_BAD_CERTIFICATE" in err.args[1] or
+                      "SSLV3_ALERT_CERTIFICATE_UNKNOWN" in err.args[1]):
+                    return self.handle_close()
+                raise
+            except OSError as err:
+                if err.args[0] == errno.ECONNABORTED:
+                    return self.handle_close()
+            else:
+                self.tls_active = True
+                self.tls_starting = False
+
+        def handle_read(self):
+            if self.tls_starting:
+                self._do_tls_handshake()
+            else:
+                try:
+                    asynchat.async_chat.handle_read(self)
+                except ssl.SSLEOFError:
+                    self.handle_close()
+
+class DummyPOP3Server(asyncore.dispatcher, threading.Thread):
+
+    handler = DummyPOP3Handler
+
+    def __init__(self, address, af=socket.AF_INET):
+        threading.Thread.__init__(self)
+        asyncore.dispatcher.__init__(self)
+        self.daemon = True
+        self.create_socket(af, socket.SOCK_STREAM)
+        self.bind(address)
+        self.listen(5)
+        self.active = False
+        self.active_lock = threading.Lock()
+        self.host, self.port = self.socket.getsockname()[:2]
+        self.handler_instance = None
+
+    def start(self):
+        assert not self.active
+        self.__flag = threading.Event()
+        threading.Thread.start(self)
+        self.__flag.wait()
+
+    def run(self):
+        self.active = True
+        self.__flag.set()
+        try:
+            while self.active and asyncore.socket_map:
+                with self.active_lock:
+                    asyncore.loop(timeout=0.1, count=1)
+        finally:
+            asyncore.close_all(ignore_all=True)
+
+    def stop(self):
+        assert self.active
+        self.active = False
+        self.join()
+
+    def handle_accepted(self, conn, addr):
+        self.handler_instance = self.handler(conn)
+
+    def handle_connect(self):
+        self.close()
+    handle_read = handle_connect
+
+    def writable(self):
+        return 0
+
+    def handle_error(self):
+        raise
+
+
+class TestPOP3Class(TestCase):
+    def assertOK(self, resp):
+        self.assertStartsWith(resp, b"+OK")
+
+    def setUp(self):
+        self.server = DummyPOP3Server((HOST, PORT))
+        self.server.start()
+        self.client = poplib.POP3(self.server.host, self.server.port,
+                                  timeout=test_support.LOOPBACK_TIMEOUT)
+
+    def tearDown(self):
+        self.client.close()
+        self.server.stop()
+        # Explicitly clear the attribute to prevent dangling thread
+        self.server = None
+
+    def test_getwelcome(self):
+        self.assertEqual(self.client.getwelcome(),
+                         b'+OK dummy pop3 server ready. <timestamp>')
+
+    def test_exceptions(self):
+        self.assertRaises(poplib.error_proto, self.client._shortcmd, 'echo -err')
+
+    def test_user(self):
+        self.assertOK(self.client.user('guido'))
+        self.assertRaises(poplib.error_proto, self.client.user, 'invalid')
+
+    def test_pass_(self):
+        self.assertOK(self.client.pass_('python'))
+        self.assertRaises(poplib.error_proto, self.client.user, 'invalid')
+
+    def test_stat(self):
+        self.assertEqual(self.client.stat(), (10, 100))
+
+        original_shortcmd = self.client._shortcmd
+        def mock_shortcmd_invalid_format(cmd):
+            if cmd == 'STAT':
+                return b'+OK'
+            return original_shortcmd(cmd)
+
+        self.client._shortcmd = mock_shortcmd_invalid_format
+        with self.assertRaises(poplib.error_proto):
+            self.client.stat()
+
+        def mock_shortcmd_invalid_data(cmd):
+            if cmd == 'STAT':
+                return b'+OK abc def'
+            return original_shortcmd(cmd)
+
+        self.client._shortcmd = mock_shortcmd_invalid_data
+        with self.assertRaises(poplib.error_proto):
+            self.client.stat()
+
+        def mock_shortcmd_extra_fields(cmd):
+            if cmd == 'STAT':
+                return b'+OK 1 2 3 4 5'
+            return original_shortcmd(cmd)
+
+        self.client._shortcmd = mock_shortcmd_extra_fields
+
+        result = self.client.stat()
+        self.assertEqual(result, (1, 2))
+
+        self.client._shortcmd = original_shortcmd
+
+    def test_list(self):
+        self.assertEqual(self.client.list()[1:],
+                         ([b'1 1', b'2 2', b'3 3', b'4 4', b'5 5'],
+                          25))
+        self.assertEndsWith(self.client.list('1'), b"OK 1 1")
+
+    def test_retr(self):
+        expected = (b'+OK 116 bytes',
+                    [b'From: postmaster@python.org', b'Content-Type: text/plain',
+                     b'MIME-Version: 1.0', b'Subject: Dummy',
+                     b'', b'line1', b'line2', b'line3'],
+                    113)
+        foo = self.client.retr('foo')
+        self.assertEqual(foo, expected)
+
+    def test_too_long_lines(self):
+        self.assertRaises(poplib.error_proto, self.client._shortcmd,
+                          'echo +%s' % ((poplib._MAXLINE + 10) * 'a'))
+
+    def test_dele(self):
+        self.assertOK(self.client.dele('foo'))
+
+    def test_noop(self):
+        self.assertOK(self.client.noop())
+
+    def test_rpop(self):
+        self.assertOK(self.client.rpop('foo'))
+
+    @hashlib_helper.requires_hashdigest('md5', openssl=True)
+    def test_apop_normal(self):
+        self.assertOK(self.client.apop('foo', 'dummypassword'))
+
+    @hashlib_helper.requires_hashdigest('md5', openssl=True)
+    def test_apop_REDOS(self):
+        # Replace welcome with very long evil welcome.
+        # NB The upper bound on welcome length is currently 2048.
+        # At this length, evil input makes each apop call take
+        # on the order of milliseconds instead of microseconds.
+        evil_welcome = b'+OK' + (b'<' * 1000000)
+        with test_support.swap_attr(self.client, 'welcome', evil_welcome):
+            # The evil welcome is invalid, so apop should throw.
+            self.assertRaises(poplib.error_proto, self.client.apop, 'a', 'kb')
+
+    def test_top(self):
+        expected =  (b'+OK 116 bytes',
+                     [b'From: postmaster@python.org', b'Content-Type: text/plain',
+                      b'MIME-Version: 1.0', b'Subject: Dummy', b'',
+                      b'line1', b'line2', b'line3'],
+                     113)
+        self.assertEqual(self.client.top(1, 1), expected)
+
+    def test_uidl(self):
+        self.client.uidl()
+        self.client.uidl('foo')
+
+    def test_utf8_raises_if_unsupported(self):
+        self.server.handler.enable_UTF8 = False
+        self.assertRaises(poplib.error_proto, self.client.utf8)
+
+    def test_utf8(self):
+        self.server.handler.enable_UTF8 = True
+        expected = b'+OK I know RFC6856'
+        result = self.client.utf8()
+        self.assertEqual(result, expected)
+
+    def test_capa(self):
+        capa = self.client.capa()
+        self.assertTrue('IMPLEMENTATION' in capa.keys())
+
+    def test_quit(self):
+        resp = self.client.quit()
+        self.assertTrue(resp)
+        self.assertIsNone(self.client.sock)
+        self.assertIsNone(self.client.file)
+
+    @requires_ssl
+    def test_stls_capa(self):
+        capa = self.client.capa()
+        self.assertTrue('STLS' in capa.keys())
+
+    @requires_ssl
+    def test_stls(self):
+        expected = b'+OK Begin TLS negotiation'
+        resp = self.client.stls()
+        self.assertEqual(resp, expected)
+
+    @requires_ssl
+    def test_stls_context(self):
+        expected = b'+OK Begin TLS negotiation'
+        ctx = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)
+        ctx.load_verify_locations(CAFILE)
+        self.assertEqual(ctx.verify_mode, ssl.CERT_REQUIRED)
+        self.assertEqual(ctx.check_hostname, True)
+        with self.assertRaises(ssl.CertificateError):
+            resp = self.client.stls(context=ctx)
+        self.client = poplib.POP3("localhost", self.server.port,
+                                  timeout=test_support.LOOPBACK_TIMEOUT)
+        resp = self.client.stls(context=ctx)
+        self.assertEqual(resp, expected)
+
+
+if SUPPORTS_SSL:
+    from test.test_ftplib import SSLConnection
+
+    class DummyPOP3_SSLHandler(SSLConnection, DummyPOP3Handler):
+
+        def __init__(self, conn):
+            asynchat.async_chat.__init__(self, conn)
+            self.secure_connection()
+            self.set_terminator(b"\r\n")
+            self.in_buffer = []
+            self.push('+OK dummy pop3 server ready. <timestamp>')
+            self.tls_active = True
+            self.tls_starting = False
+
+
+@requires_ssl
+class TestPOP3_SSLClass(TestPOP3Class):
+    # repeat previous tests by using poplib.POP3_SSL
+
+    def setUp(self):
+        self.server = DummyPOP3Server((HOST, PORT))
+        self.server.handler = DummyPOP3_SSLHandler
+        self.server.start()
+        self.client = poplib.POP3_SSL(self.server.host, self.server.port)
+
+    def test__all__(self):
+        self.assertIn('POP3_SSL', poplib.__all__)
+
+    def test_context(self):
+        ctx = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)
+        ctx.check_hostname = False
+        ctx.verify_mode = ssl.CERT_NONE
+
+        self.client.quit()
+        self.client = poplib.POP3_SSL(self.server.host, self.server.port,
+                                        context=ctx)
+        self.assertIsInstance(self.client.sock, ssl.SSLSocket)
+        self.assertIs(self.client.sock.context, ctx)
+        self.assertStartsWith(self.client.noop(), b'+OK')
+
+    def test_stls(self):
+        self.assertRaises(poplib.error_proto, self.client.stls)
+
+    test_stls_context = test_stls
+
+    def test_stls_capa(self):
+        capa = self.client.capa()
+        self.assertFalse('STLS' in capa.keys())
+
+
+@requires_ssl
+class TestPOP3_TLSClass(TestPOP3Class):
+    # repeat previous tests by using poplib.POP3.stls()
+
+    def setUp(self):
+        self.server = DummyPOP3Server((HOST, PORT))
+        self.server.start()
+        self.client = poplib.POP3(self.server.host, self.server.port,
+                                  timeout=test_support.LOOPBACK_TIMEOUT)
+        self.client.stls()
+
+    def tearDown(self):
+        if self.client.file is not None and self.client.sock is not None:
+            try:
+                self.client.quit()
+            except poplib.error_proto:
+                # happens in the test_too_long_lines case; the overlong
+                # response will be treated as response to QUIT and raise
+                # this exception
+                self.client.close()
+        self.server.stop()
+        # Explicitly clear the attribute to prevent dangling thread
+        self.server = None
+
+    def test_stls(self):
+        self.assertRaises(poplib.error_proto, self.client.stls)
+
+    test_stls_context = test_stls
+
+    def test_stls_capa(self):
+        capa = self.client.capa()
+        self.assertFalse(b'STLS' in capa.keys())
+
+
+class TestTimeouts(TestCase):
+
+    def setUp(self):
+        self.evt = threading.Event()
+        self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+        self.sock.settimeout(60)  # Safety net. Look issue 11812
+        self.port = socket_helper.bind_port(self.sock)
+        self.thread = threading.Thread(target=self.server, args=(self.evt, self.sock))
+        self.thread.daemon = True
+        self.thread.start()
+        self.evt.wait()
+
+    def tearDown(self):
+        self.thread.join()
+        # Explicitly clear the attribute to prevent dangling thread
+        self.thread = None
+
+    def server(self, evt, serv):
+        serv.listen()
+        evt.set()
+        try:
+            conn, addr = serv.accept()
+            conn.send(b"+ Hola mundo\n")
+            conn.close()
+        except TimeoutError:
+            pass
+        finally:
+            serv.close()
+
+    def testTimeoutDefault(self):
+        self.assertIsNone(socket.getdefaulttimeout())
+        socket.setdefaulttimeout(test_support.LOOPBACK_TIMEOUT)
+        try:
+            pop = poplib.POP3(HOST, self.port)
+        finally:
+            socket.setdefaulttimeout(None)
+        self.assertEqual(pop.sock.gettimeout(), test_support.LOOPBACK_TIMEOUT)
+        pop.close()
+
+    def testTimeoutNone(self):
+        self.assertIsNone(socket.getdefaulttimeout())
+        socket.setdefaulttimeout(30)
+        try:
+            pop = poplib.POP3(HOST, self.port, timeout=None)
+        finally:
+            socket.setdefaulttimeout(None)
+        self.assertIsNone(pop.sock.gettimeout())
+        pop.close()
+
+    def testTimeoutValue(self):
+        pop = poplib.POP3(HOST, self.port, timeout=test_support.LOOPBACK_TIMEOUT)
+        self.assertEqual(pop.sock.gettimeout(), test_support.LOOPBACK_TIMEOUT)
+        pop.close()
+        with self.assertRaises(ValueError):
+            poplib.POP3(HOST, self.port, timeout=0)
+
+
+def setUpModule():
+    thread_info = threading_helper.threading_setup()
+    unittest.addModuleCleanup(threading_helper.threading_cleanup, *thread_info)
+
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/Lib/test/test_positional_only_arg.py b/Lib/test/test_positional_only_arg.py
index 4b27f4f4d3f..e002babab44 100644
--- a/Lib/test/test_positional_only_arg.py
+++ b/Lib/test/test_positional_only_arg.py
@@ -2,6 +2,7 @@
 
 import dis
 import pickle
+import types
 import unittest
 
 from test.support import check_syntax_error
@@ -22,13 +23,13 @@ def assertRaisesSyntaxError(self, codestr, regex="invalid syntax"):
         with self.assertRaisesRegex(SyntaxError, regex):
             compile(codestr + "\n", "<test>", "single")
 
-    # TODO: RUSTPYTHON: wrong error message
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; wrong error message
     def test_invalid_syntax_errors(self):
-        check_syntax_error(self, "def f(a, b = 5, /, c): pass", "non-default argument follows default argument")
-        check_syntax_error(self, "def f(a = 5, b, /, c): pass", "non-default argument follows default argument")
-        check_syntax_error(self, "def f(a = 5, b=1, /, c, *, d=2): pass", "non-default argument follows default argument")
-        check_syntax_error(self, "def f(a = 5, b, /): pass", "non-default argument follows default argument")
+        check_syntax_error(self, "def f(a, b = 5, /, c): pass", "parameter without a default follows parameter with a default")
+        check_syntax_error(self, "def f(a = 5, b, /, c): pass", "parameter without a default follows parameter with a default")
+        check_syntax_error(self, "def f(a = 5, b=1, /, c, *, d=2): pass", "parameter without a default follows parameter with a default")
+        check_syntax_error(self, "def f(a = 5, b, /): pass", "parameter without a default follows parameter with a default")
+        check_syntax_error(self, "def f(a, /, b = 5, c): pass", "parameter without a default follows parameter with a default")
         check_syntax_error(self, "def f(*args, /): pass")
         check_syntax_error(self, "def f(*args, a, /): pass")
         check_syntax_error(self, "def f(**kwargs, /): pass")
@@ -45,13 +46,13 @@ def test_invalid_syntax_errors(self):
         check_syntax_error(self, "def f(a, /, c, /, d, *, e): pass")
         check_syntax_error(self, "def f(a, *, c, /, d, e): pass")
 
-    # TODO: RUSTPYTHON: wrong error message
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; wrong error message
     def test_invalid_syntax_errors_async(self):
-        check_syntax_error(self, "async def f(a, b = 5, /, c): pass", "non-default argument follows default argument")
-        check_syntax_error(self, "async def f(a = 5, b, /, c): pass", "non-default argument follows default argument")
-        check_syntax_error(self, "async def f(a = 5, b=1, /, c, d=2): pass", "non-default argument follows default argument")
-        check_syntax_error(self, "async def f(a = 5, b, /): pass", "non-default argument follows default argument")
+        check_syntax_error(self, "async def f(a, b = 5, /, c): pass", "parameter without a default follows parameter with a default")
+        check_syntax_error(self, "async def f(a = 5, b, /, c): pass", "parameter without a default follows parameter with a default")
+        check_syntax_error(self, "async def f(a = 5, b=1, /, c, d=2): pass", "parameter without a default follows parameter with a default")
+        check_syntax_error(self, "async def f(a = 5, b, /): pass", "parameter without a default follows parameter with a default")
+        check_syntax_error(self, "async def f(a, /, b = 5, c): pass", "parameter without a default follows parameter with a default")
         check_syntax_error(self, "async def f(*args, /): pass")
         check_syntax_error(self, "async def f(*args, a, /): pass")
         check_syntax_error(self, "async def f(**kwargs, /): pass")
@@ -163,8 +164,6 @@ def f(a, b, /, c=3):
         with self.assertRaisesRegex(TypeError, r"f\(\) takes from 2 to 3 positional arguments but 4 were given"):
             f(1, 2, 3, 4)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_positional_only_and_kwonlyargs_invalid_calls(self):
         def f(a, b, /, c, *, d, e):
             pass
@@ -236,12 +235,13 @@ def test_lambdas(self):
         x = lambda a, b, /, : a + b
         self.assertEqual(x(1, 2), 3)
 
-    # TODO: RUSTPYTHON: wrong error message
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; wrong error message
     def test_invalid_syntax_lambda(self):
-        check_syntax_error(self, "lambda a, b = 5, /, c: None", "non-default argument follows default argument")
-        check_syntax_error(self, "lambda a = 5, b, /, c: None", "non-default argument follows default argument")
-        check_syntax_error(self, "lambda a = 5, b, /: None", "non-default argument follows default argument")
+        check_syntax_error(self, "lambda a, b = 5, /, c: None", "parameter without a default follows parameter with a default")
+        check_syntax_error(self, "lambda a = 5, b, /, c: None", "parameter without a default follows parameter with a default")
+        check_syntax_error(self, "lambda a = 5, b=1, /, c, *, d=2: None", "parameter without a default follows parameter with a default")
+        check_syntax_error(self, "lambda a = 5, b, /: None", "parameter without a default follows parameter with a default")
+        check_syntax_error(self, "lambda a, /, b = 5, c: None", "parameter without a default follows parameter with a default")
         check_syntax_error(self, "lambda *args, /: None")
         check_syntax_error(self, "lambda *args, a, /: None")
         check_syntax_error(self, "lambda **kwargs, /: None")
@@ -338,8 +338,6 @@ def f(something,/,**kwargs):
 
         self.assertEqual(f(42), (42, {}))
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_mangling(self):
         class X:
             def f(self, __a=42, /):
@@ -439,8 +437,7 @@ def method(self, /):
 
         self.assertEqual(C().method(), sentinel)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_annotations_constant_fold(self):
         def g():
             def f(x: not (int is int), /): ...
@@ -448,7 +445,9 @@ def f(x: not (int is int), /): ...
         # without constant folding we end up with
         # COMPARE_OP(is), IS_OP (0)
         # with constant folding we should expect a IS_OP (1)
-        codes = [(i.opname, i.argval) for i in dis.get_instructions(g)]
+        code_obj = next(const for const in g.__code__.co_consts
+                        if isinstance(const, types.CodeType) and const.co_name == "__annotate__")
+        codes = [(i.opname, i.argval) for i in dis.get_instructions(code_obj)]
         self.assertNotIn(('UNARY_NOT', None), codes)
         self.assertIn(('IS_OP', 1), codes)
 
diff --git a/Lib/test/test_posix.py b/Lib/test/test_posix.py
index a4809a23798..eb0e4d25dc1 100644
--- a/Lib/test/test_posix.py
+++ b/Lib/test/test_posix.py
@@ -583,7 +583,6 @@ def test_confstr(self):
         self.assertGreater(len(path), 0)
         self.assertEqual(posix.confstr(posix.confstr_names["CS_PATH"]), path)
 
-    @unittest.expectedFailureIf(sys.platform in ('darwin', 'linux'), '''TODO: RUSTPYTHON; AssertionError: "configuration names must be strings or integers" does not match "Expected type 'str' but 'float' found."''')
     @unittest.skipUnless(hasattr(posix, 'sysconf'),
                          'test needs posix.sysconf()')
     def test_sysconf(self):
@@ -669,6 +668,19 @@ def test_fstat(self):
         finally:
             fp.close()
 
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    @unittest.skipUnless(hasattr(posix, 'stat'),
+                         'test needs posix.stat()')
+    @unittest.skipUnless(os.stat in os.supports_follow_symlinks,
+                         'test needs follow_symlinks support in os.stat()')
+    def test_stat_fd_zero_follow_symlinks(self):
+        with self.assertRaisesRegex(ValueError,
+                'cannot use fd and follow_symlinks together'):
+            posix.stat(0, follow_symlinks=False)
+        with self.assertRaisesRegex(ValueError,
+                'cannot use fd and follow_symlinks together'):
+            posix.stat(1, follow_symlinks=False)
+
     def test_stat(self):
         self.assertTrue(posix.stat(os_helper.TESTFN))
         self.assertTrue(posix.stat(os.fsencode(os_helper.TESTFN)))
@@ -1018,7 +1030,6 @@ def test_chmod_dir(self):
         target = self.tempdir()
         self.check_chmod(posix.chmod, target)
 
-    @unittest.skipIf(sys.platform in ('darwin', 'linux'), 'TODO: RUSTPYTHON; crash')
     @os_helper.skip_unless_working_chmod
     def test_fchmod_file(self):
         with open(os_helper.TESTFN, 'wb+') as f:
@@ -1075,7 +1086,6 @@ def test_chmod_file_symlink(self):
             self.check_chmod_link(posix.chmod, target, link)
         self.check_chmod_link(posix.chmod, target, link, follow_symlinks=True)
 
-    @unittest.skipIf(sys.platform == 'win32', 'TODO: RUSTPYTHON; flaky')
     @os_helper.skip_unless_symlink
     def test_chmod_dir_symlink(self):
         target = self.tempdir()
@@ -1110,7 +1120,7 @@ def test_lchmod_dir_symlink(self):
 
     def _test_chflags_regular_file(self, chflags_func, target_file, **kwargs):
         st = os.stat(target_file)
-        self.assertTrue(hasattr(st, 'st_flags'))
+        self.assertHasAttr(st, 'st_flags')
 
         # ZFS returns EOPNOTSUPP when attempting to set flag UF_IMMUTABLE.
         flags = st.st_flags | stat.UF_IMMUTABLE
@@ -1146,7 +1156,7 @@ def test_lchflags_regular_file(self):
     def test_lchflags_symlink(self):
         testfn_st = os.stat(os_helper.TESTFN)
 
-        self.assertTrue(hasattr(testfn_st, 'st_flags'))
+        self.assertHasAttr(testfn_st, 'st_flags')
 
         self.addCleanup(os_helper.unlink, _DUMMY_SYMLINK)
         os.symlink(os_helper.TESTFN, _DUMMY_SYMLINK)
@@ -1350,7 +1360,6 @@ def test_get_and_set_scheduler_and_param(self):
         param = posix.sched_param(sched_priority=-large)
         self.assertRaises(OverflowError, posix.sched_setparam, 0, param)
 
-    @unittest.expectedFailureIf(sys.platform == 'linux', "TODO: RUSTPYTHON; TypeError: cannot pickle 'sched_param' object")
     @requires_sched
     def test_sched_param(self):
         param = posix.sched_param(1)
@@ -1370,6 +1379,14 @@ def test_sched_param(self):
         self.assertNotEqual(newparam, param)
         self.assertEqual(newparam.sched_priority, 0)
 
+    @requires_sched
+    def test_bug_140634(self):
+        sched_priority = float('inf')  # any new reference
+        param = posix.sched_param(sched_priority)
+        param.__reduce__()
+        del sched_priority, param  # should not crash
+        support.gc_collect()  # just to be sure
+
     @unittest.skipUnless(hasattr(posix, "sched_rr_get_interval"), "no function")
     def test_sched_rr_get_interval(self):
         try:
@@ -1525,6 +1542,51 @@ def test_pidfd_open(self):
         self.assertEqual(cm.exception.errno, errno.EINVAL)
         os.close(os.pidfd_open(os.getpid(), 0))
 
+    @os_helper.skip_unless_hardlink
+    @os_helper.skip_unless_symlink
+    def test_link_follow_symlinks(self):
+        default_follow = sys.platform.startswith(
+            ('darwin', 'freebsd', 'netbsd', 'openbsd', 'dragonfly', 'sunos5'))
+        default_no_follow = sys.platform.startswith(('win32', 'linux'))
+        orig = os_helper.TESTFN
+        symlink = orig + 'symlink'
+        posix.symlink(orig, symlink)
+        self.addCleanup(os_helper.unlink, symlink)
+
+        with self.subTest('no follow_symlinks'):
+            # no follow_symlinks -> platform depending
+            link = orig + 'link'
+            posix.link(symlink, link)
+            self.addCleanup(os_helper.unlink, link)
+            if os.link in os.supports_follow_symlinks or default_follow:
+                self.assertEqual(posix.lstat(link), posix.lstat(orig))
+            elif default_no_follow:
+                self.assertEqual(posix.lstat(link), posix.lstat(symlink))
+
+        with self.subTest('follow_symlinks=False'):
+            # follow_symlinks=False -> duplicate the symlink itself
+            link = orig + 'link_nofollow'
+            try:
+                posix.link(symlink, link, follow_symlinks=False)
+            except NotImplementedError:
+                if os.link in os.supports_follow_symlinks or default_no_follow:
+                    raise
+            else:
+                self.addCleanup(os_helper.unlink, link)
+                self.assertEqual(posix.lstat(link), posix.lstat(symlink))
+
+        with self.subTest('follow_symlinks=True'):
+            # follow_symlinks=True -> duplicate the target file
+            link = orig + 'link_following'
+            try:
+                posix.link(symlink, link, follow_symlinks=True)
+            except NotImplementedError:
+                if os.link in os.supports_follow_symlinks or default_follow:
+                    raise
+            else:
+                self.addCleanup(os_helper.unlink, link)
+                self.assertEqual(posix.lstat(link), posix.lstat(orig))
+
 
 # tests for the posix *at functions follow
 class TestPosixDirFd(unittest.TestCase):
@@ -1570,7 +1632,6 @@ def test_chown_dir_fd(self):
         with self.prepare_file() as (dir_fd, name, fullname):
             posix.chown(name, os.getuid(), os.getgid(), dir_fd=dir_fd)
 
-    @unittest.expectedFailureIf(sys.platform in ('darwin', 'linux'), 'TODO: RUSTPYTHON; AssertionError: RuntimeWarning not triggered')
     @unittest.skipUnless(os.stat in os.supports_dir_fd, "test needs dir_fd support in os.stat()")
     def test_stat_dir_fd(self):
         with self.prepare() as (dir_fd, name, fullname):
@@ -1973,7 +2034,7 @@ def test_setsigdef_wrong_type(self):
                             [sys.executable, "-c", "pass"],
                             os.environ, setsigdef=[signal.NSIG, signal.NSIG+1])
 
-    @unittest.expectedFailureIf(sys.platform in ('darwin', 'linux'), 'TODO: RUSTPYTHON; NotImplementedError: scheduler parameter is not yet implemented')
+    @unittest.expectedFailureIf(sys.platform in ("darwin", "linux"), "TODO: RUSTPYTHON; NotImplementedError: scheduler parameter is not yet implemented")
     @requires_sched
     @unittest.skipIf(sys.platform.startswith(('freebsd', 'netbsd')),
                      "bpo-34685: test can fail on BSD")
@@ -1994,14 +2055,15 @@ def test_setscheduler_only_param(self):
         )
         support.wait_process(pid, exitcode=0)
 
-    @unittest.expectedFailureIf(sys.platform in ('darwin', 'linux'), 'TODO: RUSTPYTHON; NotImplementedError: scheduler parameter is not yet implemented')
+    @unittest.expectedFailureIf(sys.platform in ("darwin", "linux"), "TODO: RUSTPYTHON; NotImplementedError: scheduler parameter is not yet implemented")
     @requires_sched
     @unittest.skipIf(sys.platform.startswith(('freebsd', 'netbsd')),
                      "bpo-34685: test can fail on BSD")
     @unittest.skipIf(platform.libc_ver()[0] == 'glibc' and
                      os.sched_getscheduler(0) in [
                         os.SCHED_BATCH,
-                        os.SCHED_IDLE],
+                        os.SCHED_IDLE,
+                        os.SCHED_DEADLINE],
                      "Skip test due to glibc posix_spawn policy")
     def test_setscheduler_with_policy(self):
         policy = os.sched_getscheduler(0)
@@ -2081,7 +2143,7 @@ def test_open_file(self):
         with open(outfile, encoding="utf-8") as f:
             self.assertEqual(f.read(), 'hello')
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON; the rust runtime reopens closed stdio fds at startup, so this test fails, even though POSIX_SPAWN_CLOSE does actually have an effect
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; the rust runtime reopens closed stdio fds at startup, so this test fails, even though POSIX_SPAWN_CLOSE does actually have an effect
     def test_close_file(self):
         closefile = os_helper.TESTFN
         self.addCleanup(os_helper.unlink, closefile)
@@ -2186,12 +2248,12 @@ def _verify_available(self, name):
     def test_pwritev(self):
         self._verify_available("HAVE_PWRITEV")
         if self.mac_ver >= (10, 16):
-            self.assertTrue(hasattr(os, "pwritev"), "os.pwritev is not available")
-            self.assertTrue(hasattr(os, "preadv"), "os.readv is not available")
+            self.assertHasAttr(os, "pwritev")
+            self.assertHasAttr(os, "preadv")
 
         else:
-            self.assertFalse(hasattr(os, "pwritev"), "os.pwritev is available")
-            self.assertFalse(hasattr(os, "preadv"), "os.readv is available")
+            self.assertNotHasAttr(os, "pwritev")
+            self.assertNotHasAttr(os, "preadv")
 
     def test_stat(self):
         self._verify_available("HAVE_FSTATAT")
diff --git a/Lib/test/test_posixpath.py b/Lib/test/test_posixpath.py
index 0dc0211eada..21f06712548 100644
--- a/Lib/test/test_posixpath.py
+++ b/Lib/test/test_posixpath.py
@@ -1084,15 +1084,11 @@ def check_error(exc, paths):
                           ['usr/lib/', b'/usr/lib/python3'])
 
 
-# TODO: RUSTPYTHON
-@unittest.skip("TODO: RUSTPYTHON, flaky tests")
 class PosixCommonTest(test_genericpath.CommonTest, unittest.TestCase):
     pathmodule = posixpath
     attributes = ['relpath', 'samefile', 'sameopenfile', 'samestat']
 
 
-# TODO: RUSTPYTHON
-@unittest.skipIf(os.getenv("CI"), "TODO: RUSTPYTHON,  FileExistsError: (17, 'File exists (os error 17)')")
 class PathLikeTests(unittest.TestCase):
 
     path = posixpath
diff --git a/Lib/test/test_pprint.py b/Lib/test/test_pprint.py
index ace75561f25..403d2e90084 100644
--- a/Lib/test/test_pprint.py
+++ b/Lib/test/test_pprint.py
@@ -8,10 +8,12 @@
 import pprint
 import random
 import re
-import test.support
 import types
 import unittest
 
+from test.support import cpython_only
+from test.support.import_helper import ensure_lazy_imports
+
 # list, tuple and dict subclasses that do or don't overwrite __repr__
 class list2(list):
     pass
@@ -130,6 +132,10 @@ def setUp(self):
         self.b = list(range(200))
         self.a[-12] = self.b
 
+    @cpython_only
+    def test_lazy_import(self):
+        ensure_lazy_imports("pprint", {"dataclasses", "re"})
+
     def test_init(self):
         pp = pprint.PrettyPrinter()
         pp = pprint.PrettyPrinter(indent=4, width=40, depth=5,
diff --git a/Lib/test/test_print.py b/Lib/test/test_print.py
index 6107b7032f9..7c71c5eefe2 100644
--- a/Lib/test/test_print.py
+++ b/Lib/test/test_print.py
@@ -146,7 +146,7 @@ class TestPy2MigrationHint(unittest.TestCase):
     if print statement is executed as in Python 2.
     """
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_normal_string(self):
         python2_print_str = 'print "Hello World"'
         with self.assertRaises(SyntaxError) as context:
@@ -155,7 +155,7 @@ def test_normal_string(self):
         self.assertIn("Missing parentheses in call to 'print'. Did you mean print(...)",
                 str(context.exception))
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_string_with_soft_space(self):
         python2_print_str = 'print "Hello World",'
         with self.assertRaises(SyntaxError) as context:
@@ -164,7 +164,7 @@ def test_string_with_soft_space(self):
         self.assertIn("Missing parentheses in call to 'print'. Did you mean print(...)",
                 str(context.exception))
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_string_with_excessive_whitespace(self):
         python2_print_str = 'print  "Hello World", '
         with self.assertRaises(SyntaxError) as context:
@@ -173,7 +173,7 @@ def test_string_with_excessive_whitespace(self):
         self.assertIn("Missing parentheses in call to 'print'. Did you mean print(...)",
                 str(context.exception))
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_string_with_leading_whitespace(self):
         python2_print_str = '''if 1:
             print "Hello World"
@@ -187,7 +187,7 @@ def test_string_with_leading_whitespace(self):
     # bpo-32685: Suggestions for print statement should be proper when
     # it is in the same line as the header of a compound statement
     # and/or followed by a semicolon
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_string_with_semicolon(self):
         python2_print_str = 'print p;'
         with self.assertRaises(SyntaxError) as context:
@@ -196,7 +196,7 @@ def test_string_with_semicolon(self):
         self.assertIn("Missing parentheses in call to 'print'. Did you mean print(...)",
                 str(context.exception))
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_string_in_loop_on_same_line(self):
         python2_print_str = 'for i in s: print i'
         with self.assertRaises(SyntaxError) as context:
@@ -205,39 +205,6 @@ def test_string_in_loop_on_same_line(self):
         self.assertIn("Missing parentheses in call to 'print'. Did you mean print(...)",
                 str(context.exception))
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
-    def test_stream_redirection_hint_for_py2_migration(self):
-        # Test correct hint produced for Py2 redirection syntax
-        with self.assertRaises(TypeError) as context:
-            print >> sys.stderr, "message"
-        self.assertIn('Did you mean "print(<message>, '
-                'file=<output_stream>)"?', str(context.exception))
-
-        # Test correct hint is produced in the case where RHS implements
-        # __rrshift__ but returns NotImplemented
-        with self.assertRaises(TypeError) as context:
-            print >> 42
-        self.assertIn('Did you mean "print(<message>, '
-                'file=<output_stream>)"?', str(context.exception))
-
-        # Test stream redirection hint is specific to print
-        with self.assertRaises(TypeError) as context:
-            max >> sys.stderr
-        self.assertNotIn('Did you mean ', str(context.exception))
-
-        # Test stream redirection hint is specific to rshift
-        with self.assertRaises(TypeError) as context:
-            print << sys.stderr
-        self.assertNotIn('Did you mean', str(context.exception))
-
-        # Ensure right operand implementing rrshift still works
-        class OverrideRRShift:
-            def __rrshift__(self, lhs):
-                return 42 # Force result independent of LHS
-
-        self.assertEqual(print >> OverrideRRShift(), 42)
-
-
 
 if __name__ == "__main__":
     unittest.main()
diff --git a/Lib/test/test_property.py b/Lib/test/test_property.py
index cea241b0f20..26aefdbf042 100644
--- a/Lib/test/test_property.py
+++ b/Lib/test/test_property.py
@@ -87,8 +87,8 @@ def test_property_decorator_baseclass(self):
         self.assertEqual(base.spam, 10)
         self.assertEqual(base._spam, 10)
         delattr(base, "spam")
-        self.assertTrue(not hasattr(base, "spam"))
-        self.assertTrue(not hasattr(base, "_spam"))
+        self.assertNotHasAttr(base, "spam")
+        self.assertNotHasAttr(base, "_spam")
         base.spam = 20
         self.assertEqual(base.spam, 20)
         self.assertEqual(base._spam, 20)
diff --git a/Lib/test/test_pulldom.py b/Lib/test/test_pulldom.py
index 1308c73be6e..f91fa1f8a0f 100644
--- a/Lib/test/test_pulldom.py
+++ b/Lib/test/test_pulldom.py
@@ -23,8 +23,8 @@
 
 
 class PullDOMTestCase(unittest.TestCase):
-    # TODO: RUSTPYTHON FileNotFoundError: [Errno 2] No such file or directory (os error 2): 'xmltestdata/test.xml' -> 'None'
-    @unittest.expectedFailure
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; FileNotFoundError: [Errno 2] No such file or directory (os error 2): 'xmltestdata/test.xml' -> 'None'
     def test_parse(self):
         """Minimal test of DOMEventStream.parse()"""
 
@@ -41,15 +41,14 @@ def test_parse(self):
         with open(tstfile, "rb") as fin:
             list(pulldom.parse(fin))
 
-    # TODO: RUSTPYTHON implement DOM semantic
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; implement DOM semantic
     def test_parse_semantics(self):
         """Test DOMEventStream parsing semantics."""
 
         items = pulldom.parseString(SMALL_SAMPLE)
         evt, node = next(items)
         # Just check the node is a Document:
-        self.assertTrue(hasattr(node, "createElement"))
+        self.assertHasAttr(node, "createElement")
         self.assertEqual(pulldom.START_DOCUMENT, evt)
         evt, node = next(items)
         self.assertEqual(pulldom.START_ELEMENT, evt)
@@ -105,8 +104,7 @@ def test_parse_semantics(self):
         #evt, node = next(items)
         #self.assertEqual(pulldom.END_DOCUMENT, evt)
 
-    # TODO: RUSTPYTHON pulldom.parseString(SMALL_SAMPLE) return iterator with tuple with 2 elements
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; pulldom.parseString(SMALL_SAMPLE) return iterator with tuple with 2 elements
     def test_expandItem(self):
         """Ensure expandItem works as expected."""
         items = pulldom.parseString(SMALL_SAMPLE)
@@ -197,7 +195,7 @@ def _test_thorough(self, pd, before_root=True):
         evt, node = next(pd)
         self.assertEqual(pulldom.START_DOCUMENT, evt)
         # Just check the node is a Document:
-        self.assertTrue(hasattr(node, "createElement"))
+        self.assertHasAttr(node, "createElement")
 
         if before_root:
             evt, node = next(pd)
@@ -303,8 +301,7 @@ class SAX2DOMTestCase(unittest.TestCase):
     def confirm(self, test, testname="Test"):
         self.assertTrue(test, testname)
 
-    # TODO: RUSTPYTHON read from stream io
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; read from stream io
     def test_basic(self):
         """Ensure SAX2DOM can parse from a stream."""
         with io.StringIO(SMALL_SAMPLE) as fin:
diff --git a/Lib/test/test_py_compile.py b/Lib/test/test_py_compile.py
index 54302eba4df..54786505d00 100644
--- a/Lib/test/test_py_compile.py
+++ b/Lib/test/test_py_compile.py
@@ -109,18 +109,17 @@ def test_cwd(self):
         self.assertTrue(os.path.exists(self.pyc_path))
         self.assertFalse(os.path.exists(self.cache_path))
 
-    import platform
-    @unittest.expectedFailureIf(sys.platform == "darwin" and int(platform.release().split(".")[0]) < 20, "TODO: RUSTPYTHON")
+    @unittest.expectedFailureIf(sys.platform == "darwin" and int(__import__("platform").release().split(".")[0]) < 20, "TODO: RUSTPYTHON")
     def test_relative_path(self):
         py_compile.compile(os.path.relpath(self.source_path),
                            os.path.relpath(self.pyc_path))
         self.assertTrue(os.path.exists(self.pyc_path))
         self.assertFalse(os.path.exists(self.cache_path))
 
-    @unittest.skipIf(hasattr(os, 'geteuid') and os.geteuid() == 0,
-                     'non-root user required')
+    @os_helper.skip_if_dac_override
     @unittest.skipIf(os.name == 'nt',
                      'cannot control directory permissions on Windows')
+    @os_helper.skip_unless_working_chmod
     def test_exceptions_propagate(self):
         # Make sure that exceptions raised thanks to issues with writing
         # bytecode.
@@ -133,10 +132,11 @@ def test_exceptions_propagate(self):
         finally:
             os.chmod(self.directory, mode.st_mode)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_bad_coding(self):
-        bad_coding = os.path.join(os.path.dirname(__file__), 'bad_coding2.py')
+        bad_coding = os.path.join(os.path.dirname(__file__),
+                                  'tokenizedata',
+                                  'bad_coding2.py')
         with support.captured_stderr():
             self.assertIsNone(py_compile.compile(bad_coding, doraise=False))
         self.assertFalse(os.path.exists(
@@ -198,6 +198,18 @@ def test_invalidation_mode(self):
                 fp.read(), 'test', {})
         self.assertEqual(flags, 0b1)
 
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    def test_quiet(self):
+        bad_coding = os.path.join(os.path.dirname(__file__),
+                                  'tokenizedata',
+                                  'bad_coding2.py')
+        with support.captured_stderr() as stderr:
+            self.assertIsNone(py_compile.compile(bad_coding, doraise=False, quiet=2))
+            self.assertIsNone(py_compile.compile(bad_coding, doraise=True, quiet=2))
+            self.assertEqual(stderr.getvalue(), '')
+            with self.assertRaises(py_compile.PyCompileError):
+                py_compile.compile(bad_coding, doraise=True, quiet=1)
+
 
 class PyCompileTestsWithSourceEpoch(PyCompileTestsBase,
                                     unittest.TestCase,
@@ -218,27 +230,31 @@ class PyCompileCLITestCase(unittest.TestCase):
     def setUp(self):
         self.directory = tempfile.mkdtemp()
         self.source_path = os.path.join(self.directory, '_test.py')
-        self.cache_path = importlib.util.cache_from_source(self.source_path)
+        self.cache_path = importlib.util.cache_from_source(self.source_path,
+                                optimization='' if __debug__ else 1)
         with open(self.source_path, 'w') as file:
             file.write('x = 123\n')
 
     def tearDown(self):
         os_helper.rmtree(self.directory)
 
+    @support.requires_subprocess()
     def pycompilecmd(self, *args, **kwargs):
         # assert_python_* helpers don't return proc object. We'll just use
         # subprocess.run() instead of spawn_python() and its friends to test
         # stdin support of the CLI.
+        opts = '-m' if __debug__ else '-Om'
         if args and args[0] == '-' and 'input' in kwargs:
-            return subprocess.run([sys.executable, '-m', 'py_compile', '-'],
+            return subprocess.run([sys.executable, opts, 'py_compile', '-'],
                                   input=kwargs['input'].encode(),
                                   capture_output=True)
-        return script_helper.assert_python_ok('-m', 'py_compile', *args, **kwargs)
+        return script_helper.assert_python_ok(opts, 'py_compile', *args, **kwargs)
 
     def pycompilecmd_failure(self, *args):
         return script_helper.assert_python_failure('-m', 'py_compile', *args)
 
     def test_stdin(self):
+        self.assertFalse(os.path.exists(self.cache_path))
         result = self.pycompilecmd('-', input=self.source_path)
         self.assertEqual(result.returncode, 0)
         self.assertEqual(result.stdout, b'')
@@ -253,14 +269,18 @@ def test_with_files(self):
         self.assertTrue(os.path.exists(self.cache_path))
 
     def test_bad_syntax(self):
-        bad_syntax = os.path.join(os.path.dirname(__file__), 'badsyntax_3131.py')
+        bad_syntax = os.path.join(os.path.dirname(__file__),
+                                  'tokenizedata',
+                                  'badsyntax_3131.py')
         rc, stdout, stderr = self.pycompilecmd_failure(bad_syntax)
         self.assertEqual(rc, 1)
         self.assertEqual(stdout, b'')
         self.assertIn(b'SyntaxError', stderr)
 
     def test_bad_syntax_with_quiet(self):
-        bad_syntax = os.path.join(os.path.dirname(__file__), 'badsyntax_3131.py')
+        bad_syntax = os.path.join(os.path.dirname(__file__),
+                                  'tokenizedata',
+                                  'badsyntax_3131.py')
         rc, stdout, stderr = self.pycompilecmd_failure('-q', bad_syntax)
         self.assertEqual(rc, 1)
         self.assertEqual(stdout, b'')
diff --git a/Lib/test/test_pyclbr.py b/Lib/test/test_pyclbr.py
index 9ac4a6efe00..9e7a67ebee5 100644
--- a/Lib/test/test_pyclbr.py
+++ b/Lib/test/test_pyclbr.py
@@ -3,16 +3,17 @@
    Nick Mathewson
 '''
 
+import importlib.machinery
 import sys
+from contextlib import contextmanager
 from textwrap import dedent
 from types import FunctionType, MethodType, BuiltinFunctionType
 import pyclbr
 from unittest import TestCase, main as unittest_main
 from test.test_importlib import util as test_importlib_util
 import warnings
-from test.support.testcase import ExtraAssertions
 
-import unittest # TODO: RUSTPYTHON
+import unittest  # XXX: RUSTPYTHON; importing to be able to skip tests
 
 
 StaticMethodType = type(staticmethod(lambda: None))
@@ -25,7 +26,30 @@
 # is imperfect (as designed), testModule is called with a set of
 # members to ignore.
 
-class PyclbrTest(TestCase, ExtraAssertions):
+
+@contextmanager
+def temporary_main_spec():
+    """
+    A context manager that temporarily sets the `__spec__` attribute
+    of the `__main__` module if it's missing.
+    """
+    main_mod = sys.modules.get("__main__")
+    if main_mod is None:
+        yield  # Do nothing if __main__ is not present
+        return
+
+    original_spec = getattr(main_mod, "__spec__", None)
+    if original_spec is None:
+        main_mod.__spec__ = importlib.machinery.ModuleSpec(
+            name="__main__", loader=None, origin="built-in"
+        )
+    try:
+        yield
+    finally:
+        main_mod.__spec__ = original_spec
+
+
+class PyclbrTest(TestCase):
 
     def assertListEq(self, l1, l2, ignore):
         ''' succeed iff {l1} - {ignore} == {l2} - {ignore} '''
@@ -81,7 +105,7 @@ def ismethod(oclass, obj, name):
         for name, value in dict.items():
             if name in ignore:
                 continue
-            self.assertHasAttr(module, name, ignore)
+            self.assertHasAttr(module, name)
             py_item = getattr(module, name)
             if isinstance(value, pyclbr.Function):
                 self.assertIsInstance(py_item, (FunctionType, BuiltinFunctionType))
@@ -105,6 +129,8 @@ def ismethod(oclass, obj, name):
 
                 actualMethods = []
                 for m in py_item.__dict__.keys():
+                    if m == "__annotate__":
+                        continue
                     if ismethod(py_item, getattr(py_item, m), m):
                         actualMethods.append(m)
 
@@ -146,12 +172,12 @@ def test_easy(self):
         self.checkModule('pyclbr')
         # XXX: Metaclasses are not supported
         # self.checkModule('ast')
-        self.checkModule('doctest', ignore=("TestResults", "_SpoofOut",
-                                            "DocTestCase", '_DocTestSuite'))
+        with temporary_main_spec():
+            self.checkModule('doctest', ignore=("TestResults", "_SpoofOut",
+                                                "DocTestCase", '_DocTestSuite'))
         self.checkModule('difflib', ignore=("Match",))
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_cases(self):
         # see test.pyclbr_input for the rationale behind the ignored symbols
         self.checkModule('test.pyclbr_input', ignore=['om', 'f'])
@@ -217,8 +243,7 @@ def compare(parent1, children1, parent2, children2):
 
         compare(None, actual, None, expected)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_others(self):
         cm = self.checkModule
 
@@ -228,12 +253,14 @@ def test_others(self):
         with warnings.catch_warnings():
             warnings.simplefilter('ignore', DeprecationWarning)
             cm('sre_parse', ignore=('dump', 'groups', 'pos')) # from sre_constants import *; property
-        cm(
-            'pdb',
-            # pyclbr does not handle elegantly `typing` or properties
-            ignore=('Union', '_ModuleTarget', '_ScriptTarget', '_ZipTarget'),
-        )
-        cm('pydoc', ignore=('input', 'output',)) # properties
+        with temporary_main_spec():
+            cm(
+                'pdb',
+                # pyclbr does not handle elegantly `typing` or properties
+                ignore=('Union', '_ModuleTarget', '_ScriptTarget', '_ZipTarget', 'curframe_locals',
+                        '_InteractState', 'rlcompleter'),
+            )
+        cm('pydoc', ignore=('input', 'output',))  # properties
 
         # Tests for modules inside packages
         cm('email.parser')
diff --git a/Lib/test/test_pydoc/__init__.py b/Lib/test/test_pydoc/__init__.py
new file mode 100644
index 00000000000..f2a39a3fe29
--- /dev/null
+++ b/Lib/test/test_pydoc/__init__.py
@@ -0,0 +1,6 @@
+import os
+from test import support
+
+
+def load_tests(*args):
+    return support.load_package_tests(os.path.dirname(__file__), *args)
diff --git a/Lib/test/test_pydoc/module_none.py b/Lib/test/test_pydoc/module_none.py
new file mode 100644
index 00000000000..ebb50fc86e2
--- /dev/null
+++ b/Lib/test/test_pydoc/module_none.py
@@ -0,0 +1,8 @@
+def func():
+    pass
+func.__module__ = None
+
+class A:
+    def method(self):
+        pass
+    method.__module__ = None
diff --git a/Lib/test/test_pydoc/pydoc_mod.py b/Lib/test/test_pydoc/pydoc_mod.py
new file mode 100644
index 00000000000..80c287fb10c
--- /dev/null
+++ b/Lib/test/test_pydoc/pydoc_mod.py
@@ -0,0 +1,51 @@
+"""This is a test module for test_pydoc"""
+
+from __future__ import print_function
+
+import types
+import typing
+
+__author__ = "Benjamin Peterson"
+__credits__ = "Nobody"
+__version__ = "1.2.3.4"
+__xyz__ = "X, Y and Z"
+
+class A:
+    """Hello and goodbye"""
+    def __init__():
+        """Wow, I have no function!"""
+        pass
+
+class B(object):
+    NO_MEANING: str = "eggs"
+    pass
+
+class C(object):
+    def say_no(self):
+        return "no"
+    def get_answer(self):
+        """ Return say_no() """
+        return self.say_no()
+    def is_it_true(self):
+        """ Return self.get_answer() """
+        return self.get_answer()
+    def __class_getitem__(self, item):
+        return types.GenericAlias(self, item)
+
+def doc_func():
+    """
+    This function solves all of the world's problems:
+    hunger
+    lack of Python
+    war
+    """
+
+def nodoc_func():
+    pass
+
+
+list_alias1 = typing.List[int]
+list_alias2 = list[int]
+c_alias = C[int]
+type_union1 = typing.Union[int, str]
+type_union2 = int | str
diff --git a/Lib/test/test_pydoc/pydocfodder.py b/Lib/test/test_pydoc/pydocfodder.py
new file mode 100644
index 00000000000..412aa3743e4
--- /dev/null
+++ b/Lib/test/test_pydoc/pydocfodder.py
@@ -0,0 +1,191 @@
+"""Something just to look at via pydoc."""
+
+import types
+
+def global_func(x, y):
+    """Module global function"""
+
+def global_func2(x, y):
+    """Module global function 2"""
+
+class A:
+    "A class."
+
+    def A_method(self):
+        "Method defined in A."
+    def AB_method(self):
+        "Method defined in A and B."
+    def AC_method(self):
+        "Method defined in A and C."
+    def AD_method(self):
+        "Method defined in A and D."
+    def ABC_method(self):
+        "Method defined in A, B and C."
+    def ABD_method(self):
+        "Method defined in A, B and D."
+    def ACD_method(self):
+        "Method defined in A, C and D."
+    def ABCD_method(self):
+        "Method defined in A, B, C and D."
+
+    def A_classmethod(cls, x):
+        "A class method defined in A."
+    A_classmethod = classmethod(A_classmethod)
+
+    def A_staticmethod(x, y):
+        "A static method defined in A."
+    A_staticmethod = staticmethod(A_staticmethod)
+
+    def _getx(self):
+        "A property getter function."
+    def _setx(self, value):
+        "A property setter function."
+    def _delx(self):
+        "A property deleter function."
+    A_property = property(fdel=_delx, fget=_getx, fset=_setx,
+                          doc="A sample property defined in A.")
+
+    A_int_alias = int
+
+class B(A):
+    "A class, derived from A."
+
+    def AB_method(self):
+        "Method defined in A and B."
+    def ABC_method(self):
+        "Method defined in A, B and C."
+    def ABD_method(self):
+        "Method defined in A, B and D."
+    def ABCD_method(self):
+        "Method defined in A, B, C and D."
+    def B_method(self):
+        "Method defined in B."
+    def BC_method(self):
+        "Method defined in B and C."
+    def BD_method(self):
+        "Method defined in B and D."
+    def BCD_method(self):
+        "Method defined in B, C and D."
+
+    @classmethod
+    def B_classmethod(cls, x):
+        "A class method defined in B."
+
+    global_func = global_func  # same name
+    global_func_alias = global_func
+    global_func2_alias = global_func2
+    B_classmethod_alias = B_classmethod
+    A_classmethod_ref = A.A_classmethod
+    A_staticmethod = A.A_staticmethod  # same name
+    A_staticmethod_alias = A.A_staticmethod
+    A_method_ref = A().A_method
+    A_method_alias = A.A_method
+    B_method_alias = B_method
+    count = list.count  # same name
+    list_count = list.count
+    __repr__ = object.__repr__  # same name
+    object_repr = object.__repr__
+    get = {}.get  # same name
+    dict_get = {}.get
+    from math import sin
+
+
+B.B_classmethod_ref = B.B_classmethod
+
+
+class C(A):
+    "A class, derived from A."
+
+    def AC_method(self):
+        "Method defined in A and C."
+    def ABC_method(self):
+        "Method defined in A, B and C."
+    def ACD_method(self):
+        "Method defined in A, C and D."
+    def ABCD_method(self):
+        "Method defined in A, B, C and D."
+    def BC_method(self):
+        "Method defined in B and C."
+    def BCD_method(self):
+        "Method defined in B, C and D."
+    def C_method(self):
+        "Method defined in C."
+    def CD_method(self):
+        "Method defined in C and D."
+
+class D(B, C):
+    """A class, derived from B and C.
+    """
+
+    def AD_method(self):
+        "Method defined in A and D."
+    def ABD_method(self):
+        "Method defined in A, B and D."
+    def ACD_method(self):
+        "Method defined in A, C and D."
+    def ABCD_method(self):
+        "Method defined in A, B, C and D."
+    def BD_method(self):
+        "Method defined in B and D."
+    def BCD_method(self):
+        "Method defined in B, C and D."
+    def CD_method(self):
+        "Method defined in C and D."
+    def D_method(self):
+        "Method defined in D."
+
+class FunkyProperties(object):
+    """From SF bug 472347, by Roeland Rengelink.
+
+    Property getters etc may not be vanilla functions or methods,
+    and this used to make GUI pydoc blow up.
+    """
+
+    def __init__(self):
+        self.desc = {'x':0}
+
+    class get_desc:
+        def __init__(self, attr):
+            self.attr = attr
+        def __call__(self, inst):
+            print('Get called', self, inst)
+            return inst.desc[self.attr]
+    class set_desc:
+        def __init__(self, attr):
+            self.attr = attr
+        def __call__(self, inst, val):
+            print('Set called', self, inst, val)
+            inst.desc[self.attr] = val
+    class del_desc:
+        def __init__(self, attr):
+            self.attr = attr
+        def __call__(self, inst):
+            print('Del called', self, inst)
+            del inst.desc[self.attr]
+
+    x = property(get_desc('x'), set_desc('x'), del_desc('x'), 'prop x')
+
+
+submodule = types.ModuleType(__name__ + '.submodule',
+    """A submodule, which should appear in its parent's summary""")
+
+global_func_alias = global_func
+A_classmethod = A.A_classmethod  # same name
+A_classmethod2 = A.A_classmethod
+A_classmethod3 = B.A_classmethod
+A_staticmethod = A.A_staticmethod  # same name
+A_staticmethod_alias = A.A_staticmethod
+A_staticmethod_ref = A().A_staticmethod
+A_staticmethod_ref2 = B().A_staticmethod
+A_method = A().A_method  # same name
+A_method2 = A().A_method
+A_method3 = B().A_method
+B_method = B.B_method  # same name
+B_method2 = B.B_method
+count = list.count  # same name
+list_count = list.count
+__repr__ = object.__repr__  # same name
+object_repr = object.__repr__
+get = {}.get  # same name
+dict_get = {}.get
+from math import sin  # noqa: F401
diff --git a/Lib/test/test_pydoc/test_pydoc.py b/Lib/test/test_pydoc/test_pydoc.py
new file mode 100644
index 00000000000..066b9b4dbe1
--- /dev/null
+++ b/Lib/test/test_pydoc/test_pydoc.py
@@ -0,0 +1,2458 @@
+import datetime
+import os
+import sys
+import contextlib
+import importlib.util
+import inspect
+import io
+import pydoc
+import py_compile
+import keyword
+try: # TODO: RUSTPYTHON; Implement `_pickle`
+    import _pickle
+except ImportError:
+    _pickle = None
+import pkgutil
+import re
+import tempfile
+import test.support
+import time
+import types
+import typing
+import unittest
+import unittest.mock
+import urllib.parse
+import xml.etree
+import xml.etree.ElementTree
+import textwrap
+from io import StringIO
+from collections import namedtuple
+from urllib.request import urlopen, urlcleanup
+from test import support
+from test.support import import_helper
+from test.support import os_helper
+from test.support.script_helper import (assert_python_ok,
+                                        assert_python_failure, spawn_python)
+from test.support import threading_helper
+from test.support import (reap_children, captured_stdout,
+                          captured_stderr, is_wasm32,
+                          requires_docstrings, MISSING_C_DOCSTRINGS)
+from test.support.os_helper import (TESTFN, rmtree, unlink)
+from test.test_pydoc import pydoc_mod
+from test.test_pydoc import pydocfodder
+
+
+class nonascii:
+    'Це не латиниця'
+    pass
+
+if test.support.HAVE_DOCSTRINGS:
+    expected_data_docstrings = (
+        'dictionary for instance variables',
+        'list of weak references to the object',
+        ) * 2
+else:
+    expected_data_docstrings = ('', '', '', '')
+
+expected_text_pattern = """
+NAME
+    test.test_pydoc.pydoc_mod - This is a test module for test_pydoc
+%s
+CLASSES
+    builtins.object
+        A
+        B
+        C
+
+    class A(builtins.object)
+     |  Hello and goodbye
+     |
+     |  Methods defined here:
+     |
+     |  __init__()
+     |      Wow, I have no function!
+     |
+     |  ----------------------------------------------------------------------
+     |  Data descriptors defined here:
+     |
+     |  __dict__%s
+     |
+     |  __weakref__%s
+
+    class B(builtins.object)
+     |  Data descriptors defined here:
+     |
+     |  __dict__%s
+     |
+     |  __weakref__%s
+     |
+     |  ----------------------------------------------------------------------
+     |  Data and other attributes defined here:
+     |
+     |  NO_MEANING = 'eggs'
+
+    class C(builtins.object)
+     |  Methods defined here:
+     |
+     |  get_answer(self)
+     |      Return say_no()
+     |
+     |  is_it_true(self)
+     |      Return self.get_answer()
+     |
+     |  say_no(self)
+     |
+     |  ----------------------------------------------------------------------
+     |  Class methods defined here:
+     |
+     |  __class_getitem__(item)
+     |
+     |  ----------------------------------------------------------------------
+     |  Data descriptors defined here:
+     |
+     |  __dict__
+     |      dictionary for instance variables
+     |
+     |  __weakref__
+     |      list of weak references to the object
+
+FUNCTIONS
+    doc_func()
+        This function solves all of the world's problems:
+        hunger
+        lack of Python
+        war
+
+    nodoc_func()
+
+DATA
+    __xyz__ = 'X, Y and Z'
+    c_alias = test.test_pydoc.pydoc_mod.C[int]
+    list_alias1 = typing.List[int]
+    list_alias2 = list[int]
+    type_union1 = int | str
+    type_union2 = int | str
+
+VERSION
+    1.2.3.4
+
+AUTHOR
+    Benjamin Peterson
+
+CREDITS
+    Nobody
+
+FILE
+    %s
+""".strip()
+
+expected_text_data_docstrings = tuple('\n     |      ' + s if s else ''
+                                      for s in expected_data_docstrings)
+
+html2text_of_expected = """
+test.test_pydoc.pydoc_mod (version 1.2.3.4)
+This is a test module for test_pydoc
+
+Modules
+    types
+    typing
+
+Classes
+    builtins.object
+    A
+    B
+    C
+
+class A(builtins.object)
+    Hello and goodbye
+
+    Methods defined here:
+        __init__()
+            Wow, I have no function!
+    ----------------------------------------------------------------------
+    Data descriptors defined here:
+        __dict__
+            dictionary for instance variables
+        __weakref__
+            list of weak references to the object
+
+class B(builtins.object)
+    Data descriptors defined here:
+        __dict__
+            dictionary for instance variables
+        __weakref__
+            list of weak references to the object
+    ----------------------------------------------------------------------
+    Data and other attributes defined here:
+        NO_MEANING = 'eggs'
+
+
+class C(builtins.object)
+    Methods defined here:
+        get_answer(self)
+            Return say_no()
+        is_it_true(self)
+            Return self.get_answer()
+        say_no(self)
+    ----------------------------------------------------------------------
+    Class methods defined here:
+        __class_getitem__(item)
+    ----------------------------------------------------------------------
+    Data descriptors defined here:
+        __dict__
+            dictionary for instance variables
+        __weakref__
+             list of weak references to the object
+
+Functions
+    doc_func()
+        This function solves all of the world's problems:
+        hunger
+        lack of Python
+        war
+    nodoc_func()
+
+Data
+    __xyz__ = 'X, Y and Z'
+    c_alias = test.test_pydoc.pydoc_mod.C[int]
+    list_alias1 = typing.List[int]
+    list_alias2 = list[int]
+    type_union1 = int | str
+    type_union2 = int | str
+
+Author
+    Benjamin Peterson
+
+Credits
+    Nobody
+"""
+
+expected_html_data_docstrings = tuple(s.replace(' ', '&nbsp;')
+                                      for s in expected_data_docstrings)
+
+# output pattern for missing module
+missing_pattern = '''\
+No Python documentation found for %r.
+Use help() to get the interactive help utility.
+Use help(str) for help on the str class.'''.replace('\n', os.linesep)
+
+# output pattern for module with bad imports
+badimport_pattern = "problem in %s - ModuleNotFoundError: No module named %r"
+
+expected_dynamicattribute_pattern = """
+Help on class DA in module %s:
+
+class DA(builtins.object)
+ |  Data descriptors defined here:
+ |
+ |  __dict__%s
+ |
+ |  __weakref__%s
+ |
+ |  ham
+ |
+ |  ----------------------------------------------------------------------
+ |  Data and other attributes inherited from Meta:
+ |
+ |  ham = 'spam'
+""".strip()
+
+expected_virtualattribute_pattern1 = """
+Help on class Class in module %s:
+
+class Class(builtins.object)
+ |  Data and other attributes inherited from Meta:
+ |
+ |  LIFE = 42
+""".strip()
+
+expected_virtualattribute_pattern2 = """
+Help on class Class1 in module %s:
+
+class Class1(builtins.object)
+ |  Data and other attributes inherited from Meta1:
+ |
+ |  one = 1
+""".strip()
+
+expected_virtualattribute_pattern3 = """
+Help on class Class2 in module %s:
+
+class Class2(Class1)
+ |  Method resolution order:
+ |      Class2
+ |      Class1
+ |      builtins.object
+ |
+ |  Data and other attributes inherited from Meta1:
+ |
+ |  one = 1
+ |
+ |  ----------------------------------------------------------------------
+ |  Data and other attributes inherited from Meta3:
+ |
+ |  three = 3
+ |
+ |  ----------------------------------------------------------------------
+ |  Data and other attributes inherited from Meta2:
+ |
+ |  two = 2
+""".strip()
+
+expected_missingattribute_pattern = """
+Help on class C in module %s:
+
+class C(builtins.object)
+ |  Data and other attributes defined here:
+ |
+ |  here = 'present!'
+""".strip()
+
+def run_pydoc(module_name, *args, **env):
+    """
+    Runs pydoc on the specified module. Returns the stripped
+    output of pydoc.
+    """
+    args = args + (module_name,)
+    # do not write bytecode files to avoid caching errors
+    rc, out, err = assert_python_ok('-B', pydoc.__file__, *args, **env)
+    return out.strip()
+
+def run_pydoc_fail(module_name, *args, **env):
+    """
+    Runs pydoc on the specified module expecting a failure.
+    """
+    args = args + (module_name,)
+    rc, out, err = assert_python_failure('-B', pydoc.__file__, *args, **env)
+    return out.strip()
+
+def get_pydoc_html(module):
+    "Returns pydoc generated output as html"
+    doc = pydoc.HTMLDoc()
+    output = doc.docmodule(module)
+    loc = doc.getdocloc(pydoc_mod) or ""
+    if loc:
+        loc = "<br><a href=\"" + loc + "\">Module Docs</a>"
+    return output.strip(), loc
+
+def clean_text(doc):
+    # clean up the extra text formatting that pydoc performs
+    return re.sub('\b.', '', doc)
+
+def get_pydoc_link(module):
+    "Returns a documentation web link of a module"
+    abspath = os.path.abspath
+    dirname = os.path.dirname
+    basedir = dirname(dirname(dirname(abspath(__file__))))
+    doc = pydoc.TextDoc()
+    loc = doc.getdocloc(module, basedir=basedir)
+    return loc
+
+def get_pydoc_text(module):
+    "Returns pydoc generated output as text"
+    doc = pydoc.TextDoc()
+    loc = doc.getdocloc(pydoc_mod) or ""
+    if loc:
+        loc = "\nMODULE DOCS\n    " + loc + "\n"
+
+    output = doc.docmodule(module)
+    output = clean_text(output)
+    return output.strip(), loc
+
+def get_html_title(text):
+    # Bit of hack, but good enough for test purposes
+    header, _, _ = text.partition("</head>")
+    _, _, title = header.partition("<title>")
+    title, _, _ = title.partition("</title>")
+    return title
+
+
+def html2text(html):
+    """A quick and dirty implementation of html2text.
+
+    Tailored for pydoc tests only.
+    """
+    html = html.replace("<dd>", "\n")
+    html = html.replace("<hr>", "-"*70)
+    html = re.sub("<.*?>", "", html)
+    html = pydoc.replace(html, "&nbsp;", " ", "&gt;", ">", "&lt;", "<")
+    return html
+
+
+class PydocBaseTest(unittest.TestCase):
+    def tearDown(self):
+        # Self-testing. Mocking only works if sys.modules['pydoc'] and pydoc
+        # are the same. But some pydoc functions reload the module and change
+        # sys.modules, so check that it was restored.
+        self.assertIs(sys.modules['pydoc'], pydoc)
+
+    def _restricted_walk_packages(self, walk_packages, path=None):
+        """
+        A version of pkgutil.walk_packages() that will restrict itself to
+        a given path.
+        """
+        default_path = path or [os.path.dirname(__file__)]
+        def wrapper(path=None, prefix='', onerror=None):
+            return walk_packages(path or default_path, prefix, onerror)
+        return wrapper
+
+    @contextlib.contextmanager
+    def restrict_walk_packages(self, path=None):
+        walk_packages = pkgutil.walk_packages
+        pkgutil.walk_packages = self._restricted_walk_packages(walk_packages,
+                                                               path)
+        try:
+            yield
+        finally:
+            pkgutil.walk_packages = walk_packages
+
+    def call_url_handler(self, url, expected_title):
+        text = pydoc._url_handler(url, "text/html")
+        result = get_html_title(text)
+        # Check the title to ensure an unexpected error page was not returned
+        self.assertEqual(result, expected_title, text)
+        return text
+
+
+class PydocDocTest(unittest.TestCase):
+    maxDiff = None
+    def tearDown(self):
+        self.assertIs(sys.modules['pydoc'], pydoc)
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    @unittest.skipIf(hasattr(sys, 'gettrace') and sys.gettrace(),
+                     'trace function introduces __locals__ unexpectedly')
+    @requires_docstrings
+    def test_html_doc(self):
+        result, doc_loc = get_pydoc_html(pydoc_mod)
+        text_result = html2text(result)
+        text_lines = [line.strip() for line in text_result.splitlines()]
+        text_lines = [line for line in text_lines if line]
+        del text_lines[1]
+        expected_lines = html2text_of_expected.splitlines()
+        expected_lines = [line.strip() for line in expected_lines if line]
+        self.assertEqual(text_lines, expected_lines)
+        mod_file = inspect.getabsfile(pydoc_mod)
+        mod_url = urllib.parse.quote(mod_file)
+        self.assertIn(mod_url, result)
+        self.assertIn(mod_file, result)
+        self.assertIn(doc_loc, result)
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    @unittest.skipIf(hasattr(sys, 'gettrace') and sys.gettrace(),
+                     'trace function introduces __locals__ unexpectedly')
+    @requires_docstrings
+    def test_text_doc(self):
+        result, doc_loc = get_pydoc_text(pydoc_mod)
+        expected_text = expected_text_pattern % (
+                        (doc_loc,) +
+                        expected_text_data_docstrings +
+                        (inspect.getabsfile(pydoc_mod),))
+        self.assertEqual(expected_text, result)
+
+    def test_text_enum_member_with_value_zero(self):
+        # Test issue #20654 to ensure enum member with value 0 can be
+        # displayed. It used to throw KeyError: 'zero'.
+        import enum
+        class BinaryInteger(enum.IntEnum):
+            zero = 0
+            one = 1
+        doc = pydoc.render_doc(BinaryInteger)
+        self.assertIn('BinaryInteger.zero', doc)
+
+    def test_slotted_dataclass_with_field_docs(self):
+        import dataclasses
+        @dataclasses.dataclass(slots=True)
+        class My:
+            x: int = dataclasses.field(doc='Docstring for x')
+        doc = pydoc.render_doc(My)
+        self.assertIn('Docstring for x', doc)
+
+    def test_mixed_case_module_names_are_lower_cased(self):
+        # issue16484
+        doc_link = get_pydoc_link(xml.etree.ElementTree)
+        self.assertIn('xml.etree.elementtree', doc_link)
+
+    def test_issue8225(self):
+        # Test issue8225 to ensure no doc link appears for xml.etree
+        result, doc_loc = get_pydoc_text(xml.etree)
+        self.assertEqual(doc_loc, "", "MODULE DOCS incorrectly includes a link")
+
+    def test_online_docs_link(self):
+        import encodings.idna
+        import importlib._bootstrap
+
+        module_docs = {
+            'encodings': 'codecs#module-encodings',
+            'encodings.idna': 'codecs#module-encodings.idna',
+        }
+
+        with unittest.mock.patch('pydoc_data.module_docs.module_docs', module_docs):
+            doc = pydoc.TextDoc()
+
+            basedir = os.path.dirname(encodings.__file__)
+            doc_link = doc.getdocloc(encodings, basedir=basedir)
+            self.assertIsNotNone(doc_link)
+            self.assertIn('codecs#module-encodings', doc_link)
+            self.assertNotIn('encodings.html', doc_link)
+
+            doc_link = doc.getdocloc(encodings.idna, basedir=basedir)
+            self.assertIsNotNone(doc_link)
+            self.assertIn('codecs#module-encodings.idna', doc_link)
+            self.assertNotIn('encodings.idna.html', doc_link)
+
+            doc_link = doc.getdocloc(importlib._bootstrap, basedir=basedir)
+            self.assertIsNone(doc_link)
+
+    def test_getpager_with_stdin_none(self):
+        previous_stdin = sys.stdin
+        try:
+            sys.stdin = None
+            pydoc.getpager() # Shouldn't fail.
+        finally:
+            sys.stdin = previous_stdin
+
+    def test_non_str_name(self):
+        # issue14638
+        # Treat illegal (non-str) name like no name
+
+        class A:
+            __name__ = 42
+        class B:
+            pass
+        adoc = pydoc.render_doc(A())
+        bdoc = pydoc.render_doc(B())
+        self.assertEqual(adoc.replace("A", "B"), bdoc)
+
+    def test_not_here(self):
+        missing_module = "test.i_am_not_here"
+        result = str(run_pydoc_fail(missing_module), 'ascii')
+        expected = missing_pattern % missing_module
+        self.assertEqual(expected, result,
+            "documentation for missing module found")
+
+    @requires_docstrings
+    def test_not_ascii(self):
+        result = run_pydoc('test.test_pydoc.test_pydoc.nonascii', PYTHONIOENCODING='ascii')
+        encoded = nonascii.__doc__.encode('ascii', 'backslashreplace')
+        self.assertIn(encoded, result)
+
+    def test_input_strip(self):
+        missing_module = " test.i_am_not_here "
+        result = str(run_pydoc_fail(missing_module), 'ascii')
+        expected = missing_pattern % missing_module.strip()
+        self.assertEqual(expected, result)
+
+    def test_stripid(self):
+        # test with strings, other implementations might have different repr()
+        stripid = pydoc.stripid
+        # strip the id
+        self.assertEqual(stripid('<function stripid at 0x88dcee4>'),
+                         '<function stripid>')
+        self.assertEqual(stripid('<function stripid at 0x01F65390>'),
+                         '<function stripid>')
+        # nothing to strip, return the same text
+        self.assertEqual(stripid('42'), '42')
+        self.assertEqual(stripid("<type 'exceptions.Exception'>"),
+                         "<type 'exceptions.Exception'>")
+
+    @unittest.skip("TODO: RUSTPYTHON; Panic")
+    def test_builtin_with_more_than_four_children(self):
+        """Tests help on builtin object which have more than four child classes.
+
+        When running help() on a builtin class which has child classes, it
+        should contain a "Built-in subclasses" section and only 4 classes
+        should be displayed with a hint on how many more subclasses are present.
+        For example:
+
+        >>> help(object)
+        Help on class object in module builtins:
+
+        class object
+         |  The most base type
+         |
+         |  Built-in subclasses:
+         |      async_generator
+         |      BaseException
+         |      builtin_function_or_method
+         |      bytearray
+         |      ... and 82 other subclasses
+        """
+        doc = pydoc.TextDoc()
+        try:
+            # Make sure HeapType, which has no __module__ attribute, is one
+            # of the known subclasses of object. (doc.docclass() used to
+            # fail if HeapType was imported before running this test, like
+            # when running tests sequentially.)
+            from _testcapi import HeapType
+        except ImportError:
+            pass
+        text = doc.docclass(object)
+        snip = (" |  Built-in subclasses:\n"
+                " |      async_generator\n"
+                " |      BaseException\n"
+                " |      builtin_function_or_method\n"
+                " |      bytearray\n"
+                " |      ... and \\d+ other subclasses")
+        self.assertRegex(text, snip)
+
+    def test_builtin_with_child(self):
+        """Tests help on builtin object which have only child classes.
+
+        When running help() on a builtin class which has child classes, it
+        should contain a "Built-in subclasses" section. For example:
+
+        >>> help(ArithmeticError)
+        Help on class ArithmeticError in module builtins:
+
+        class ArithmeticError(Exception)
+         |  Base class for arithmetic errors.
+         |
+         ...
+         |
+         |  Built-in subclasses:
+         |      FloatingPointError
+         |      OverflowError
+         |      ZeroDivisionError
+        """
+        doc = pydoc.TextDoc()
+        text = doc.docclass(ArithmeticError)
+        snip = (" |  Built-in subclasses:\n"
+                " |      FloatingPointError\n"
+                " |      OverflowError\n"
+                " |      ZeroDivisionError")
+        self.assertIn(snip, text)
+
+    def test_builtin_with_grandchild(self):
+        """Tests help on builtin classes which have grandchild classes.
+
+        When running help() on a builtin class which has child classes, it
+        should contain a "Built-in subclasses" section. However, if it also has
+        grandchildren, these should not show up on the subclasses section.
+        For example:
+
+        >>> help(Exception)
+        Help on class Exception in module builtins:
+
+        class Exception(BaseException)
+         |  Common base class for all non-exit exceptions.
+         |
+         ...
+         |
+         |  Built-in subclasses:
+         |      ArithmeticError
+         |      AssertionError
+         |      AttributeError
+         ...
+        """
+        doc = pydoc.TextDoc()
+        text = doc.docclass(Exception)
+        snip = (" |  Built-in subclasses:\n"
+                " |      ArithmeticError\n"
+                " |      AssertionError\n"
+                " |      AttributeError")
+        self.assertIn(snip, text)
+        # Testing that the grandchild ZeroDivisionError does not show up
+        self.assertNotIn('ZeroDivisionError', text)
+
+    def test_builtin_no_child(self):
+        """Tests help on builtin object which have no child classes.
+
+        When running help() on a builtin class which has no child classes, it
+        should not contain any "Built-in subclasses" section. For example:
+
+        >>> help(ZeroDivisionError)
+
+        Help on class ZeroDivisionError in module builtins:
+
+        class ZeroDivisionError(ArithmeticError)
+         |  Second argument to a division or modulo operation was zero.
+         |
+         |  Method resolution order:
+         |      ZeroDivisionError
+         |      ArithmeticError
+         |      Exception
+         |      BaseException
+         |      object
+         |
+         |  Methods defined here:
+         ...
+        """
+        doc = pydoc.TextDoc()
+        text = doc.docclass(ZeroDivisionError)
+        # Testing that the subclasses section does not appear
+        self.assertNotIn('Built-in subclasses', text)
+
+    def test_builtin_on_metaclasses(self):
+        """Tests help on metaclasses.
+
+        When running help() on a metaclasses such as type, it
+        should not contain any "Built-in subclasses" section.
+        """
+        doc = pydoc.TextDoc()
+        text = doc.docclass(type)
+        # Testing that the subclasses section does not appear
+        self.assertNotIn('Built-in subclasses', text)
+
+    def test_fail_help_cli(self):
+        elines = (missing_pattern % 'abd').splitlines()
+        with spawn_python("-c" "help()") as proc:
+            out, _ = proc.communicate(b"abd")
+            olines = out.decode().splitlines()[-9:-6]
+            olines[0] = olines[0].removeprefix('help> ')
+            self.assertEqual(elines, olines)
+
+    def test_fail_help_output_redirect(self):
+        with StringIO() as buf:
+            helper = pydoc.Helper(output=buf)
+            helper.help("abd")
+            expected = missing_pattern % "abd"
+            self.assertEqual(expected, buf.getvalue().strip().replace('\n', os.linesep))
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    @unittest.skipIf(hasattr(sys, 'gettrace') and sys.gettrace(),
+                     'trace function introduces __locals__ unexpectedly')
+    @unittest.mock.patch('pydoc.pager')
+    @requires_docstrings
+    def test_help_output_redirect(self, pager_mock):
+        # issue 940286, if output is set in Helper, then all output from
+        # Helper.help should be redirected
+        self.maxDiff = None
+
+        unused, doc_loc = get_pydoc_text(pydoc_mod)
+        module = "test.test_pydoc.pydoc_mod"
+        help_header = """
+        Help on module test.test_pydoc.pydoc_mod in test.test_pydoc:
+
+        """.lstrip()
+        help_header = textwrap.dedent(help_header)
+        expected_help_pattern = help_header + expected_text_pattern
+
+        with captured_stdout() as output, captured_stderr() as err:
+            buf = StringIO()
+            helper = pydoc.Helper(output=buf)
+            helper.help(module)
+            result = buf.getvalue().strip()
+            expected_text = expected_help_pattern % (
+                            (doc_loc,) +
+                            expected_text_data_docstrings +
+                            (inspect.getabsfile(pydoc_mod),))
+            self.assertEqual('', output.getvalue())
+            self.assertEqual('', err.getvalue())
+            self.assertEqual(expected_text, result)
+
+        pager_mock.assert_not_called()
+
+    @unittest.skipIf(hasattr(sys, 'gettrace') and sys.gettrace(),
+                     'trace function introduces __locals__ unexpectedly')
+    @requires_docstrings
+    @unittest.mock.patch('pydoc.pager')
+    def test_help_output_redirect_various_requests(self, pager_mock):
+        # issue 940286, if output is set in Helper, then all output from
+        # Helper.help should be redirected
+
+        def run_pydoc_for_request(request, expected_text_part):
+            """Helper function to run pydoc with its output redirected"""
+            with captured_stdout() as output, captured_stderr() as err:
+                buf = StringIO()
+                helper = pydoc.Helper(output=buf)
+                helper.help(request)
+                result = buf.getvalue().strip()
+                self.assertEqual('', output.getvalue(), msg=f'failed on request "{request}"')
+                self.assertEqual('', err.getvalue(), msg=f'failed on request "{request}"')
+                self.assertIn(expected_text_part, result, msg=f'failed on request "{request}"')
+                pager_mock.assert_not_called()
+
+        self.maxDiff = None
+
+        # test for "keywords"
+        run_pydoc_for_request('keywords', 'Here is a list of the Python keywords.')
+        # test for "symbols"
+        run_pydoc_for_request('symbols', 'Here is a list of the punctuation symbols')
+        # test for "topics"
+        run_pydoc_for_request('topics', 'Here is a list of available topics.')
+        # test for "modules" skipped, see test_modules()
+        # test for symbol "%"
+        run_pydoc_for_request('%', 'The power operator')
+        # test for special True, False, None keywords
+        run_pydoc_for_request('True', 'class bool(int)')
+        run_pydoc_for_request('False', 'class bool(int)')
+        run_pydoc_for_request('None', 'class NoneType(object)')
+        # test for keyword "assert"
+        run_pydoc_for_request('assert', 'The "assert" statement')
+        # test for topic "TYPES"
+        run_pydoc_for_request('TYPES', 'The standard type hierarchy')
+        # test for "pydoc.Helper.help"
+        run_pydoc_for_request('pydoc.Helper.help', 'Help on function help in pydoc.Helper:')
+        # test for pydoc.Helper.help
+        run_pydoc_for_request(pydoc.Helper.help, 'Help on function help in module pydoc:')
+        # test for pydoc.Helper() instance skipped because it is always meant to be interactive
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    @unittest.skipIf(hasattr(sys, 'gettrace') and sys.gettrace(),
+                     'trace function introduces __locals__ unexpectedly')
+    @requires_docstrings
+    def test_help_output_pager(self):
+        def run_pydoc_pager(request, what, expected_first_line):
+            with (captured_stdout() as output,
+                  captured_stderr() as err,
+                  unittest.mock.patch('pydoc.pager') as pager_mock,
+                  self.subTest(repr(request))):
+                helper = pydoc.Helper()
+                helper.help(request)
+                self.assertEqual('', err.getvalue())
+                self.assertEqual('\n', output.getvalue())
+                pager_mock.assert_called_once()
+                result = clean_text(pager_mock.call_args.args[0])
+                self.assertEqual(result.splitlines()[0], expected_first_line)
+                self.assertEqual(pager_mock.call_args.args[1], f'Help on {what}')
+
+        run_pydoc_pager('%', 'EXPRESSIONS', 'Operator precedence')
+        run_pydoc_pager('True', 'bool object', 'Help on bool object:')
+        run_pydoc_pager(True, 'bool object', 'Help on bool object:')
+        run_pydoc_pager('assert', 'assert', 'The "assert" statement')
+        run_pydoc_pager('TYPES', 'TYPES', 'The standard type hierarchy')
+        run_pydoc_pager('pydoc.Helper.help', 'pydoc.Helper.help',
+                        'Help on function help in pydoc.Helper:')
+        run_pydoc_pager(pydoc.Helper.help, 'Helper.help',
+                        'Help on function help in module pydoc:')
+        run_pydoc_pager('str', 'str', 'Help on class str in module builtins:')
+        run_pydoc_pager(str, 'str', 'Help on class str in module builtins:')
+        run_pydoc_pager('str.upper', 'str.upper',
+                        'Help on method descriptor upper in str:')
+        run_pydoc_pager(str.upper, 'str.upper',
+                        'Help on method descriptor upper:')
+        run_pydoc_pager(''.upper, 'str.upper',
+                        'Help on built-in function upper:')
+        run_pydoc_pager(str.__add__,
+                        'str.__add__', 'Help on method descriptor __add__:')
+        run_pydoc_pager(''.__add__,
+                        'str.__add__', 'Help on method wrapper __add__:')
+        run_pydoc_pager(int.numerator, 'int.numerator',
+                        'Help on getset descriptor builtins.int.numerator:')
+        run_pydoc_pager(list[int], 'list',
+                        'Help on GenericAlias in module builtins:')
+        run_pydoc_pager('sys', 'sys', 'Help on built-in module sys:')
+        run_pydoc_pager(sys, 'sys', 'Help on built-in module sys:')
+
+    def test_showtopic(self):
+        with captured_stdout() as showtopic_io:
+            helper = pydoc.Helper()
+            helper.showtopic('with')
+        helptext = showtopic_io.getvalue()
+        self.assertIn('The "with" statement', helptext)
+
+    def test_fail_showtopic(self):
+        with captured_stdout() as showtopic_io:
+            helper = pydoc.Helper()
+            helper.showtopic('abd')
+            expected = "no documentation found for 'abd'"
+            self.assertEqual(expected, showtopic_io.getvalue().strip())
+
+    @unittest.mock.patch('pydoc.pager')
+    def test_fail_showtopic_output_redirect(self, pager_mock):
+        with StringIO() as buf:
+            helper = pydoc.Helper(output=buf)
+            helper.showtopic("abd")
+            expected = "no documentation found for 'abd'"
+            self.assertEqual(expected, buf.getvalue().strip())
+
+        pager_mock.assert_not_called()
+
+    @unittest.skipIf(hasattr(sys, 'gettrace') and sys.gettrace(),
+                     'trace function introduces __locals__ unexpectedly')
+    @requires_docstrings
+    @unittest.mock.patch('pydoc.pager')
+    def test_showtopic_output_redirect(self, pager_mock):
+        # issue 940286, if output is set in Helper, then all output from
+        # Helper.showtopic should be redirected
+        self.maxDiff = None
+
+        with captured_stdout() as output, captured_stderr() as err:
+            buf = StringIO()
+            helper = pydoc.Helper(output=buf)
+            helper.showtopic('with')
+            result = buf.getvalue().strip()
+            self.assertEqual('', output.getvalue())
+            self.assertEqual('', err.getvalue())
+            self.assertIn('The "with" statement', result)
+
+        pager_mock.assert_not_called()
+
+    def test_lambda_with_return_annotation(self):
+        func = lambda a, b, c: 1
+        func.__annotations__ = {"return": int}
+        with captured_stdout() as help_io:
+            pydoc.help(func)
+        helptext = help_io.getvalue()
+        self.assertIn("lambda (a, b, c) -> int", helptext)
+
+    def test_lambda_without_return_annotation(self):
+        func = lambda a, b, c: 1
+        func.__annotations__ = {"a": int, "b": int, "c": int}
+        with captured_stdout() as help_io:
+            pydoc.help(func)
+        helptext = help_io.getvalue()
+        self.assertIn("lambda (a: int, b: int, c: int)", helptext)
+
+    def test_lambda_with_return_and_params_annotation(self):
+        func = lambda a, b, c: 1
+        func.__annotations__ = {"a": int, "b": int, "c": int, "return": int}
+        with captured_stdout() as help_io:
+            pydoc.help(func)
+        helptext = help_io.getvalue()
+        self.assertIn("lambda (a: int, b: int, c: int) -> int", helptext)
+
+    def test_namedtuple_fields(self):
+        Person = namedtuple('Person', ['nickname', 'firstname'])
+        with captured_stdout() as help_io:
+            pydoc.help(Person)
+        helptext = help_io.getvalue()
+        self.assertIn("nickname", helptext)
+        self.assertIn("firstname", helptext)
+        self.assertIn("Alias for field number 0", helptext)
+        self.assertIn("Alias for field number 1", helptext)
+
+    def test_namedtuple_public_underscore(self):
+        NT = namedtuple('NT', ['abc', 'def'], rename=True)
+        with captured_stdout() as help_io:
+            pydoc.help(NT)
+        helptext = help_io.getvalue()
+        self.assertIn('_1', helptext)
+        self.assertIn('_replace', helptext)
+        self.assertIn('_asdict', helptext)
+
+    def test_synopsis(self):
+        self.addCleanup(unlink, TESTFN)
+        for encoding in ('ISO-8859-1', 'UTF-8'):
+            with open(TESTFN, 'w', encoding=encoding) as script:
+                if encoding != 'UTF-8':
+                    print('#coding: {}'.format(encoding), file=script)
+                print('"""line 1: h\xe9', file=script)
+                print('line 2: hi"""', file=script)
+            synopsis = pydoc.synopsis(TESTFN, {})
+            self.assertEqual(synopsis, 'line 1: h\xe9')
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    def test_source_synopsis(self):
+        def check(source, expected, encoding=None):
+            if isinstance(source, str):
+                source_file = StringIO(source)
+            else:
+                source_file = io.TextIOWrapper(io.BytesIO(source), encoding=encoding)
+            with source_file:
+                result = pydoc.source_synopsis(source_file)
+                self.assertEqual(result, expected)
+
+        check('"""Single line docstring."""',
+              'Single line docstring.')
+        check('"""First line of docstring.\nSecond line.\nThird line."""',
+              'First line of docstring.')
+        check('"""First line of docstring.\\nSecond line.\\nThird line."""',
+              'First line of docstring.')
+        check('"""  Whitespace around docstring.  """',
+              'Whitespace around docstring.')
+        check('import sys\n"""No docstring"""',
+              None)
+        check('  \n"""Docstring after empty line."""',
+              'Docstring after empty line.')
+        check('# Comment\n"""Docstring after comment."""',
+              'Docstring after comment.')
+        check('  # Indented comment\n"""Docstring after comment."""',
+              'Docstring after comment.')
+        check('""""""', # Empty docstring
+              '')
+        check('', # Empty file
+              None)
+        check('"""Embedded\0null byte"""',
+              None)
+        check('"""Embedded null byte"""\0',
+              None)
+        check('"""Café and résumé."""',
+              'Café and résumé.')
+        check("'''Triple single quotes'''",
+              'Triple single quotes')
+        check('"Single double quotes"',
+              'Single double quotes')
+        check("'Single single quotes'",
+              'Single single quotes')
+        check('"""split\\\nline"""',
+              'splitline')
+        check('"""Unrecognized escape \\sequence"""',
+              'Unrecognized escape \\sequence')
+        check('"""Invalid escape seq\\uence"""',
+              None)
+        check('r"""Raw \\stri\\ng"""',
+              'Raw \\stri\\ng')
+        check('b"""Bytes literal"""',
+              None)
+        check('f"""f-string"""',
+              None)
+        check('"""Concatenated""" \\\n"string" \'literals\'',
+              'Concatenatedstringliterals')
+        check('"""String""" + """expression"""',
+              None)
+        check('("""In parentheses""")',
+              'In parentheses')
+        check('("""Multiple lines """\n"""in parentheses""")',
+              'Multiple lines in parentheses')
+        check('()', # tuple
+              None)
+        check(b'# coding: iso-8859-15\n"""\xa4uro sign"""',
+              '€uro sign', encoding='iso-8859-15')
+        check(b'"""\xa4"""', # Decoding error
+              None, encoding='utf-8')
+
+        with tempfile.NamedTemporaryFile(mode='w+', encoding='utf-8') as temp_file:
+            temp_file.write('"""Real file test."""\n')
+            temp_file.flush()
+            temp_file.seek(0)
+            result = pydoc.source_synopsis(temp_file)
+            self.assertEqual(result, "Real file test.")
+
+    @requires_docstrings
+    def test_synopsis_sourceless(self):
+        os = import_helper.import_fresh_module('os')
+        expected = os.__doc__.splitlines()[0]
+        filename = os.__spec__.cached
+        synopsis = pydoc.synopsis(filename)
+
+        self.assertEqual(synopsis, expected)
+
+    def test_synopsis_sourceless_empty_doc(self):
+        with os_helper.temp_cwd() as test_dir:
+            init_path = os.path.join(test_dir, 'foomod42.py')
+            cached_path = importlib.util.cache_from_source(init_path)
+            with open(init_path, 'w') as fobj:
+                fobj.write("foo = 1")
+            py_compile.compile(init_path)
+            synopsis = pydoc.synopsis(init_path, {})
+            self.assertIsNone(synopsis)
+            synopsis_cached = pydoc.synopsis(cached_path, {})
+            self.assertIsNone(synopsis_cached)
+
+    def test_splitdoc_with_description(self):
+        example_string = "I Am A Doc\n\n\nHere is my description"
+        self.assertEqual(pydoc.splitdoc(example_string),
+                         ('I Am A Doc', '\nHere is my description'))
+
+    def test_is_package_when_not_package(self):
+        with os_helper.temp_cwd() as test_dir:
+            with self.assertWarns(DeprecationWarning) as cm:
+                self.assertFalse(pydoc.ispackage(test_dir))
+            self.assertEqual(cm.filename, __file__)
+
+    def test_is_package_when_is_package(self):
+        with os_helper.temp_cwd() as test_dir:
+            init_path = os.path.join(test_dir, '__init__.py')
+            open(init_path, 'w').close()
+            with self.assertWarns(DeprecationWarning) as cm:
+                self.assertTrue(pydoc.ispackage(test_dir))
+            os.remove(init_path)
+            self.assertEqual(cm.filename, __file__)
+
+    def test_allmethods(self):
+        # issue 17476: allmethods was no longer returning unbound methods.
+        # This test is a bit fragile in the face of changes to object and type,
+        # but I can't think of a better way to do it without duplicating the
+        # logic of the function under test.
+
+        class TestClass(object):
+            def method_returning_true(self):
+                return True
+
+        # What we expect to get back: everything on object...
+        expected = dict(vars(object))
+        # ...plus our unbound method...
+        expected['method_returning_true'] = TestClass.method_returning_true
+        # ...but not the non-methods on object.
+        del expected['__doc__']
+        del expected['__class__']
+        # inspect resolves descriptors on type into methods, but vars doesn't,
+        # so we need to update __subclasshook__ and __init_subclass__.
+        expected['__subclasshook__'] = TestClass.__subclasshook__
+        expected['__init_subclass__'] = TestClass.__init_subclass__
+
+        methods = pydoc.allmethods(TestClass)
+        self.assertDictEqual(methods, expected)
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    @requires_docstrings
+    def test_method_aliases(self):
+        class A:
+            def tkraise(self, aboveThis=None):
+                """Raise this widget in the stacking order."""
+            lift = tkraise
+            def a_size(self):
+                """Return size"""
+        class B(A):
+            def itemconfigure(self, tagOrId, cnf=None, **kw):
+                """Configure resources of an item TAGORID."""
+            itemconfig = itemconfigure
+            b_size = A.a_size
+
+        doc = pydoc.render_doc(B)
+        doc = clean_text(doc)
+        self.assertEqual(doc, '''\
+Python Library Documentation: class B in module %s
+
+class B(A)
+ |  Method resolution order:
+ |      B
+ |      A
+ |      builtins.object
+ |
+ |  Methods defined here:
+ |
+ |  b_size = a_size(self)
+ |
+ |  itemconfig = itemconfigure(self, tagOrId, cnf=None, **kw)
+ |
+ |  itemconfigure(self, tagOrId, cnf=None, **kw)
+ |      Configure resources of an item TAGORID.
+ |
+ |  ----------------------------------------------------------------------
+ |  Methods inherited from A:
+ |
+ |  a_size(self)
+ |      Return size
+ |
+ |  lift = tkraise(self, aboveThis=None)
+ |
+ |  tkraise(self, aboveThis=None)
+ |      Raise this widget in the stacking order.
+ |
+ |  ----------------------------------------------------------------------
+ |  Data descriptors inherited from A:
+ |
+ |  __dict__
+ |      dictionary for instance variables
+ |
+ |  __weakref__
+ |      list of weak references to the object
+''' % __name__)
+
+        doc = pydoc.render_doc(B, renderer=pydoc.HTMLDoc())
+        expected_text = f"""
+Python Library Documentation
+
+class B in module {__name__}
+class B(A)
+    Method resolution order:
+        B
+        A
+        builtins.object
+
+    Methods defined here:
+        b_size = a_size(self)
+        itemconfig = itemconfigure(self, tagOrId, cnf=None, **kw)
+        itemconfigure(self, tagOrId, cnf=None, **kw)
+            Configure resources of an item TAGORID.
+
+    Methods inherited from A:
+        a_size(self)
+            Return size
+        lift = tkraise(self, aboveThis=None)
+        tkraise(self, aboveThis=None)
+            Raise this widget in the stacking order.
+
+    Data descriptors inherited from A:
+        __dict__
+            dictionary for instance variables
+        __weakref__
+            list of weak references to the object
+"""
+        as_text = html2text(doc)
+        expected_lines = [line.strip() for line in expected_text.split("\n") if line]
+        for expected_line in expected_lines:
+            self.assertIn(expected_line, as_text)
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    def test_long_signatures(self):
+        from collections.abc import Callable
+        from typing import Literal, Annotated
+
+        class A:
+            def __init__(self,
+                         arg1: Callable[[int, int, int], str],
+                         arg2: Literal['some value', 'other value'],
+                         arg3: Annotated[int, 'some docs about this type'],
+                         ) -> None:
+                ...
+
+        doc = pydoc.render_doc(A)
+        doc = clean_text(doc)
+        self.assertEqual(doc, '''Python Library Documentation: class A in module %s
+
+class A(builtins.object)
+ |  A(
+ |      arg1: Callable[[int, int, int], str],
+ |      arg2: Literal['some value', 'other value'],
+ |      arg3: Annotated[int, 'some docs about this type']
+ |  ) -> None
+ |
+ |  Methods defined here:
+ |
+ |  __init__(
+ |      self,
+ |      arg1: Callable[[int, int, int], str],
+ |      arg2: Literal['some value', 'other value'],
+ |      arg3: Annotated[int, 'some docs about this type']
+ |  ) -> None
+ |
+ |  ----------------------------------------------------------------------
+ |  Data descriptors defined here:
+ |
+ |  __dict__%s
+ |
+ |  __weakref__%s
+''' % (__name__,
+       '' if MISSING_C_DOCSTRINGS else '\n |      dictionary for instance variables',
+       '' if MISSING_C_DOCSTRINGS else '\n |      list of weak references to the object',
+      ))
+
+        def func(
+            arg1: Callable[[Annotated[int, 'Some doc']], str],
+            arg2: Literal[1, 2, 3, 4, 5, 6, 7, 8],
+        ) -> Annotated[int, 'Some other']:
+            ...
+
+        doc = pydoc.render_doc(func)
+        doc = clean_text(doc)
+        self.assertEqual(doc, '''Python Library Documentation: function func in module %s
+
+func(
+    arg1: Callable[[Annotated[int, 'Some doc']], str],
+    arg2: Literal[1, 2, 3, 4, 5, 6, 7, 8]
+) -> Annotated[int, 'Some other']
+''' % __name__)
+
+        def function_with_really_long_name_so_annotations_can_be_rather_small(
+            arg1: int,
+            arg2: str,
+        ):
+            ...
+
+        doc = pydoc.render_doc(function_with_really_long_name_so_annotations_can_be_rather_small)
+        doc = clean_text(doc)
+        self.assertEqual(doc, '''Python Library Documentation: function function_with_really_long_name_so_annotations_can_be_rather_small in module %s
+
+function_with_really_long_name_so_annotations_can_be_rather_small(
+    arg1: int,
+    arg2: str
+)
+''' % __name__)
+
+        does_not_have_name = lambda \
+            very_long_parameter_name_that_should_not_fit_into_a_single_line, \
+            second_very_long_parameter_name: ...
+
+        doc = pydoc.render_doc(does_not_have_name)
+        doc = clean_text(doc)
+        self.assertEqual(doc, '''Python Library Documentation: function <lambda> in module %s
+
+<lambda> lambda very_long_parameter_name_that_should_not_fit_into_a_single_line, second_very_long_parameter_name
+''' % __name__)
+
+    def test__future__imports(self):
+        # __future__ features are excluded from module help,
+        # except when it's the __future__ module itself
+        import __future__
+        future_text, _ = get_pydoc_text(__future__)
+        future_html, _ = get_pydoc_html(__future__)
+        pydoc_mod_text, _ = get_pydoc_text(pydoc_mod)
+        pydoc_mod_html, _ = get_pydoc_html(pydoc_mod)
+
+        for feature in __future__.all_feature_names:
+            txt = f"{feature} = _Feature"
+            html = f"<strong>{feature}</strong> = _Feature"
+            self.assertIn(txt, future_text)
+            self.assertIn(html, future_html)
+            self.assertNotIn(txt, pydoc_mod_text)
+            self.assertNotIn(html, pydoc_mod_html)
+
+
+class PydocImportTest(PydocBaseTest):
+
+    def setUp(self):
+        self.test_dir = os.mkdir(TESTFN)
+        self.addCleanup(rmtree, TESTFN)
+        importlib.invalidate_caches()
+
+    def test_badimport(self):
+        # This tests the fix for issue 5230, where if pydoc found the module
+        # but the module had an internal import error pydoc would report no doc
+        # found.
+        modname = 'testmod_xyzzy'
+        testpairs = (
+            ('i_am_not_here', 'i_am_not_here'),
+            ('test.i_am_not_here_either', 'test.i_am_not_here_either'),
+            ('test.i_am_not_here.neither_am_i', 'test.i_am_not_here'),
+            ('i_am_not_here.{}'.format(modname), 'i_am_not_here'),
+            ('test.{}'.format(modname), 'test.{}'.format(modname)),
+            )
+
+        sourcefn = os.path.join(TESTFN, modname) + os.extsep + "py"
+        for importstring, expectedinmsg in testpairs:
+            with open(sourcefn, 'w') as f:
+                f.write("import {}\n".format(importstring))
+            result = run_pydoc_fail(modname, PYTHONPATH=TESTFN).decode("ascii")
+            expected = badimport_pattern % (modname, expectedinmsg)
+            self.assertEqual(expected, result)
+
+    def test_apropos_with_bad_package(self):
+        # Issue 7425 - pydoc -k failed when bad package on path
+        pkgdir = os.path.join(TESTFN, "syntaxerr")
+        os.mkdir(pkgdir)
+        badsyntax = os.path.join(pkgdir, "__init__") + os.extsep + "py"
+        with open(badsyntax, 'w') as f:
+            f.write("invalid python syntax = $1\n")
+        with self.restrict_walk_packages(path=[TESTFN]):
+            with captured_stdout() as out:
+                with captured_stderr() as err:
+                    pydoc.apropos('xyzzy')
+            # No result, no error
+            self.assertEqual(out.getvalue(), '')
+            self.assertEqual(err.getvalue(), '')
+            # The package name is still matched
+            with captured_stdout() as out:
+                with captured_stderr() as err:
+                    pydoc.apropos('syntaxerr')
+            self.assertEqual(out.getvalue().strip(), 'syntaxerr')
+            self.assertEqual(err.getvalue(), '')
+
+    def test_apropos_with_unreadable_dir(self):
+        # Issue 7367 - pydoc -k failed when unreadable dir on path
+        self.unreadable_dir = os.path.join(TESTFN, "unreadable")
+        os.mkdir(self.unreadable_dir, 0)
+        self.addCleanup(os.rmdir, self.unreadable_dir)
+        # Note, on Windows the directory appears to be still
+        #   readable so this is not really testing the issue there
+        with self.restrict_walk_packages(path=[TESTFN]):
+            with captured_stdout() as out:
+                with captured_stderr() as err:
+                    pydoc.apropos('SOMEKEY')
+        # No result, no error
+        self.assertEqual(out.getvalue(), '')
+        self.assertEqual(err.getvalue(), '')
+
+    def test_apropos_empty_doc(self):
+        pkgdir = os.path.join(TESTFN, 'walkpkg')
+        os.mkdir(pkgdir)
+        self.addCleanup(rmtree, pkgdir)
+        init_path = os.path.join(pkgdir, '__init__.py')
+        with open(init_path, 'w') as fobj:
+            fobj.write("foo = 1")
+        with self.restrict_walk_packages(path=[TESTFN]), captured_stdout() as stdout:
+            pydoc.apropos('')
+        self.assertIn('walkpkg', stdout.getvalue())
+
+    def test_url_search_package_error(self):
+        # URL handler search should cope with packages that raise exceptions
+        pkgdir = os.path.join(TESTFN, "test_error_package")
+        os.mkdir(pkgdir)
+        init = os.path.join(pkgdir, "__init__.py")
+        with open(init, "wt", encoding="ascii") as f:
+            f.write("""raise ValueError("ouch")\n""")
+        with self.restrict_walk_packages(path=[TESTFN]):
+            # Package has to be importable for the error to have any effect
+            saved_paths = tuple(sys.path)
+            sys.path.insert(0, TESTFN)
+            try:
+                with self.assertRaisesRegex(ValueError, "ouch"):
+                    # Sanity check
+                    import test_error_package  # noqa: F401
+
+                text = self.call_url_handler("search?key=test_error_package",
+                    "Pydoc: Search Results")
+                found = ('<a href="test_error_package.html">'
+                    'test_error_package</a>')
+                self.assertIn(found, text)
+            finally:
+                sys.path[:] = saved_paths
+
+    @unittest.skip('causes undesirable side-effects (#20128)')
+    def test_modules(self):
+        # See Helper.listmodules().
+        num_header_lines = 2
+        num_module_lines_min = 5  # Playing it safe.
+        num_footer_lines = 3
+        expected = num_header_lines + num_module_lines_min + num_footer_lines
+
+        output = StringIO()
+        helper = pydoc.Helper(output=output)
+        helper('modules')
+        result = output.getvalue().strip()
+        num_lines = len(result.splitlines())
+
+        self.assertGreaterEqual(num_lines, expected)
+
+    @unittest.skip('causes undesirable side-effects (#20128)')
+    def test_modules_search(self):
+        # See Helper.listmodules().
+        expected = 'pydoc - '
+
+        output = StringIO()
+        helper = pydoc.Helper(output=output)
+        with captured_stdout() as help_io:
+            helper('modules pydoc')
+        result = help_io.getvalue()
+
+        self.assertIn(expected, result)
+
+    @unittest.skip('some buildbots are not cooperating (#20128)')
+    def test_modules_search_builtin(self):
+        expected = 'gc - '
+
+        output = StringIO()
+        helper = pydoc.Helper(output=output)
+        with captured_stdout() as help_io:
+            helper('modules garbage')
+        result = help_io.getvalue()
+
+        self.assertStartsWith(result, expected)
+
+    def test_importfile(self):
+        try:
+            loaded_pydoc = pydoc.importfile(pydoc.__file__)
+
+            self.assertIsNot(loaded_pydoc, pydoc)
+            self.assertEqual(loaded_pydoc.__name__, 'pydoc')
+            self.assertEqual(loaded_pydoc.__file__, pydoc.__file__)
+            self.assertEqual(loaded_pydoc.__spec__, pydoc.__spec__)
+        finally:
+            sys.modules['pydoc'] = pydoc
+
+
+class Rect:
+    @property
+    def area(self):
+        '''Area of the rect'''
+        return self.w * self.h
+
+
+class Square(Rect):
+    area = property(lambda self: self.side**2)
+
+
+class TestDescriptions(unittest.TestCase):
+    def tearDown(self):
+        self.assertIs(sys.modules['pydoc'], pydoc)
+
+    def test_module(self):
+        # Check that pydocfodder module can be described
+        doc = pydoc.render_doc(pydocfodder)
+        self.assertIn("pydocfodder", doc)
+
+    def test_class(self):
+        class C: "New-style class"
+        c = C()
+
+        self.assertEqual(pydoc.describe(C), 'class C')
+        self.assertEqual(pydoc.describe(c), 'C')
+        expected = 'C in module %s object' % __name__
+        self.assertIn(expected, pydoc.render_doc(c))
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    def test_generic_alias(self):
+        self.assertEqual(pydoc.describe(typing.List[int]), '_GenericAlias')
+        doc = pydoc.render_doc(typing.List[int], renderer=pydoc.plaintext)
+        self.assertIn('_GenericAlias in module typing', doc)
+        self.assertIn('List = class list(object)', doc)
+        if not MISSING_C_DOCSTRINGS:
+            self.assertIn(list.__doc__.strip().splitlines()[0], doc)
+
+        self.assertEqual(pydoc.describe(list[int]), 'GenericAlias')
+        doc = pydoc.render_doc(list[int], renderer=pydoc.plaintext)
+        self.assertIn('GenericAlias in module builtins', doc)
+        self.assertIn('\nclass list(object)', doc)
+        if not MISSING_C_DOCSTRINGS:
+            self.assertIn(list.__doc__.strip().splitlines()[0], doc)
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    def test_union_type(self):
+        self.assertEqual(pydoc.describe(typing.Union[int, str]), 'Union')
+        doc = pydoc.render_doc(typing.Union[int, str], renderer=pydoc.plaintext)
+        self.assertIn('Union in module typing', doc)
+        self.assertIn('class Union(builtins.object)', doc)
+        if typing.Union.__doc__:
+            self.assertIn(typing.Union.__doc__.strip().splitlines()[0], doc)
+
+        self.assertEqual(pydoc.describe(int | str), 'Union')
+        doc = pydoc.render_doc(int | str, renderer=pydoc.plaintext)
+        self.assertIn('Union in module typing', doc)
+        self.assertIn('class Union(builtins.object)', doc)
+        if not MISSING_C_DOCSTRINGS:
+            self.assertIn(types.UnionType.__doc__.strip().splitlines()[0], doc)
+
+    def test_special_form(self):
+        self.assertEqual(pydoc.describe(typing.NoReturn), '_SpecialForm')
+        doc = pydoc.render_doc(typing.NoReturn, renderer=pydoc.plaintext)
+        self.assertIn('_SpecialForm in module typing', doc)
+        if typing.NoReturn.__doc__:
+            self.assertIn('NoReturn = typing.NoReturn', doc)
+            self.assertIn(typing.NoReturn.__doc__.strip().splitlines()[0], doc)
+        else:
+            self.assertIn('NoReturn = class _SpecialForm(_Final)', doc)
+
+    def test_typing_pydoc(self):
+        def foo(data: typing.List[typing.Any],
+                x: int) -> typing.Iterator[typing.Tuple[int, typing.Any]]:
+            ...
+        T = typing.TypeVar('T')
+        class C(typing.Generic[T], typing.Mapping[int, str]): ...
+        self.assertEqual(pydoc.render_doc(foo).splitlines()[-1],
+                         'f\x08fo\x08oo\x08o(data: typing.List[typing.Any], x: int)'
+                         ' -> typing.Iterator[typing.Tuple[int, typing.Any]]')
+        self.assertEqual(pydoc.render_doc(C).splitlines()[2],
+                         'class C\x08C(collections.abc.Mapping, typing.Generic)')
+
+    def test_builtin(self):
+        for name in ('str', 'str.translate', 'builtins.str',
+                     'builtins.str.translate'):
+            # test low-level function
+            self.assertIsNotNone(pydoc.locate(name))
+            # test high-level function
+            try:
+                pydoc.render_doc(name)
+            except ImportError:
+                self.fail('finding the doc of {!r} failed'.format(name))
+
+        for name in ('notbuiltins', 'strrr', 'strr.translate',
+                     'str.trrrranslate', 'builtins.strrr',
+                     'builtins.str.trrranslate'):
+            self.assertIsNone(pydoc.locate(name))
+            self.assertRaises(ImportError, pydoc.render_doc, name)
+
+    @staticmethod
+    def _get_summary_line(o):
+        text = pydoc.plain(pydoc.render_doc(o))
+        lines = text.split('\n')
+        assert len(lines) >= 2
+        return lines[2]
+
+    @staticmethod
+    def _get_summary_lines(o):
+        text = pydoc.plain(pydoc.render_doc(o))
+        lines = text.split('\n')
+        return '\n'.join(lines[2:])
+
+    # these should include "self"
+    def test_unbound_python_method(self):
+        self.assertEqual(self._get_summary_line(textwrap.TextWrapper.wrap),
+            "wrap(self, text)")
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    @requires_docstrings
+    def test_unbound_builtin_method(self):
+        self.assertEqual(self._get_summary_line(_pickle.Pickler.dump),
+            "dump(self, obj, /) unbound _pickle.Pickler method")
+
+    # these no longer include "self"
+    def test_bound_python_method(self):
+        t = textwrap.TextWrapper()
+        self.assertEqual(self._get_summary_line(t.wrap),
+            "wrap(text) method of textwrap.TextWrapper instance")
+    def test_field_order_for_named_tuples(self):
+        Person = namedtuple('Person', ['nickname', 'firstname', 'agegroup'])
+        s = pydoc.render_doc(Person)
+        self.assertLess(s.index('nickname'), s.index('firstname'))
+        self.assertLess(s.index('firstname'), s.index('agegroup'))
+
+        class NonIterableFields:
+            _fields = None
+
+        class NonHashableFields:
+            _fields = [[]]
+
+        # Make sure these doesn't fail
+        pydoc.render_doc(NonIterableFields)
+        pydoc.render_doc(NonHashableFields)
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    @requires_docstrings
+    def test_bound_builtin_method(self):
+        s = StringIO()
+        p = _pickle.Pickler(s)
+        self.assertEqual(self._get_summary_line(p.dump),
+            "dump(obj, /) method of _pickle.Pickler instance")
+
+    # this should *never* include self!
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    @requires_docstrings
+    def test_module_level_callable(self):
+        self.assertEqual(self._get_summary_line(os.stat),
+            "stat(path, *, dir_fd=None, follow_symlinks=True)")
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    def test_module_level_callable_noargs(self):
+        self.assertEqual(self._get_summary_line(time.time),
+            "time()")
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    def test_module_level_callable_o(self):
+        try:
+            import _stat
+        except ImportError:
+            # stat.S_IMODE() and _stat.S_IMODE() have a different signature
+            self.skipTest('_stat extension is missing')
+
+        self.assertEqual(self._get_summary_line(_stat.S_IMODE),
+            "S_IMODE(object, /)")
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    def test_unbound_builtin_method_noargs(self):
+        self.assertEqual(self._get_summary_line(str.lower),
+            "lower(self, /) unbound builtins.str method")
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    def test_bound_builtin_method_noargs(self):
+        self.assertEqual(self._get_summary_line(''.lower),
+            "lower() method of builtins.str instance")
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    def test_unbound_builtin_method_o(self):
+        self.assertEqual(self._get_summary_line(set.add),
+            "add(self, object, /) unbound builtins.set method")
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    def test_bound_builtin_method_o(self):
+        self.assertEqual(self._get_summary_line(set().add),
+            "add(object, /) method of builtins.set instance")
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    def test_unbound_builtin_method_coexist_o(self):
+        self.assertEqual(self._get_summary_line(set.__contains__),
+            "__contains__(self, object, /) unbound builtins.set method")
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    def test_bound_builtin_method_coexist_o(self):
+        self.assertEqual(self._get_summary_line(set().__contains__),
+            "__contains__(object, /) method of builtins.set instance")
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    def test_unbound_builtin_classmethod_noargs(self):
+        self.assertEqual(self._get_summary_line(datetime.datetime.__dict__['utcnow']),
+            "utcnow(type, /) unbound datetime.datetime method")
+
+    def test_bound_builtin_classmethod_noargs(self):
+        self.assertEqual(self._get_summary_line(datetime.datetime.utcnow),
+            "utcnow() class method of datetime.datetime")
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    def test_unbound_builtin_classmethod_o(self):
+        self.assertEqual(self._get_summary_line(dict.__dict__['__class_getitem__']),
+            "__class_getitem__(type, object, /) unbound builtins.dict method")
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    def test_bound_builtin_classmethod_o(self):
+        self.assertEqual(self._get_summary_line(dict.__class_getitem__),
+            "__class_getitem__(object, /) class method of builtins.dict")
+
+    @support.cpython_only
+    @requires_docstrings
+    def test_module_level_callable_unrepresentable_default(self):
+        _testcapi = import_helper.import_module("_testcapi")
+        builtin = _testcapi.func_with_unrepresentable_signature
+        self.assertEqual(self._get_summary_line(builtin),
+            "func_with_unrepresentable_signature(a, b=<x>)")
+
+    @support.cpython_only
+    @requires_docstrings
+    def test_builtin_staticmethod_unrepresentable_default(self):
+        self.assertEqual(self._get_summary_line(str.maketrans),
+            "maketrans(x, y=<unrepresentable>, z=<unrepresentable>, /)")
+        _testcapi = import_helper.import_module("_testcapi")
+        cls = _testcapi.DocStringUnrepresentableSignatureTest
+        self.assertEqual(self._get_summary_line(cls.staticmeth),
+            "staticmeth(a, b=<x>)")
+
+    @support.cpython_only
+    @requires_docstrings
+    def test_unbound_builtin_method_unrepresentable_default(self):
+        self.assertEqual(self._get_summary_line(dict.pop),
+            "pop(self, key, default=<unrepresentable>, /) "
+            "unbound builtins.dict method")
+        _testcapi = import_helper.import_module("_testcapi")
+        cls = _testcapi.DocStringUnrepresentableSignatureTest
+        self.assertEqual(self._get_summary_line(cls.meth),
+            "meth(self, /, a, b=<x>) unbound "
+            "_testcapi.DocStringUnrepresentableSignatureTest method")
+
+    @support.cpython_only
+    @requires_docstrings
+    def test_bound_builtin_method_unrepresentable_default(self):
+        self.assertEqual(self._get_summary_line({}.pop),
+            "pop(key, default=<unrepresentable>, /) "
+            "method of builtins.dict instance")
+        _testcapi = import_helper.import_module("_testcapi")
+        obj = _testcapi.DocStringUnrepresentableSignatureTest()
+        self.assertEqual(self._get_summary_line(obj.meth),
+            "meth(a, b=<x>) "
+            "method of _testcapi.DocStringUnrepresentableSignatureTest instance")
+
+    @support.cpython_only
+    @requires_docstrings
+    def test_unbound_builtin_classmethod_unrepresentable_default(self):
+        _testcapi = import_helper.import_module("_testcapi")
+        cls = _testcapi.DocStringUnrepresentableSignatureTest
+        descr = cls.__dict__['classmeth']
+        self.assertEqual(self._get_summary_line(descr),
+            "classmeth(type, /, a, b=<x>) unbound "
+            "_testcapi.DocStringUnrepresentableSignatureTest method")
+
+    @support.cpython_only
+    @requires_docstrings
+    def test_bound_builtin_classmethod_unrepresentable_default(self):
+        _testcapi = import_helper.import_module("_testcapi")
+        cls = _testcapi.DocStringUnrepresentableSignatureTest
+        self.assertEqual(self._get_summary_line(cls.classmeth),
+            "classmeth(a, b=<x>) class method of "
+            "_testcapi.DocStringUnrepresentableSignatureTest")
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    def test_overridden_text_signature(self):
+        class C:
+            def meth(*args, **kwargs):
+                pass
+            @classmethod
+            def cmeth(*args, **kwargs):
+                pass
+            @staticmethod
+            def smeth(*args, **kwargs):
+                pass
+        for text_signature, unbound, bound in [
+            ("($slf)", "(slf, /)", "()"),
+            ("($slf, /)", "(slf, /)", "()"),
+            ("($slf, /, arg)", "(slf, /, arg)", "(arg)"),
+            ("($slf, /, arg=<x>)", "(slf, /, arg=<x>)", "(arg=<x>)"),
+            ("($slf, arg, /)", "(slf, arg, /)", "(arg, /)"),
+            ("($slf, arg=<x>, /)", "(slf, arg=<x>, /)", "(arg=<x>, /)"),
+            ("(/, slf, arg)", "(/, slf, arg)", "(/, slf, arg)"),
+            ("(/, slf, arg=<x>)", "(/, slf, arg=<x>)", "(/, slf, arg=<x>)"),
+            ("(slf, /, arg)", "(slf, /, arg)", "(arg)"),
+            ("(slf, /, arg=<x>)", "(slf, /, arg=<x>)", "(arg=<x>)"),
+            ("(slf, arg, /)", "(slf, arg, /)", "(arg, /)"),
+            ("(slf, arg=<x>, /)", "(slf, arg=<x>, /)", "(arg=<x>, /)"),
+        ]:
+            with self.subTest(text_signature):
+                C.meth.__text_signature__ = text_signature
+                self.assertEqual(self._get_summary_line(C.meth),
+                        "meth" + unbound)
+                self.assertEqual(self._get_summary_line(C().meth),
+                        "meth" + bound + " method of test.test_pydoc.test_pydoc.C instance")
+                C.cmeth.__func__.__text_signature__ = text_signature
+                self.assertEqual(self._get_summary_line(C.cmeth),
+                        "cmeth" + bound + " class method of test.test_pydoc.test_pydoc.C")
+                C.smeth.__text_signature__ = text_signature
+                self.assertEqual(self._get_summary_line(C.smeth),
+                        "smeth" + unbound)
+
+    @requires_docstrings
+    def test_staticmethod(self):
+        class X:
+            @staticmethod
+            def sm(x, y):
+                '''A static method'''
+                ...
+        self.assertEqual(self._get_summary_lines(X.__dict__['sm']),
+                         'sm(x, y)\n'
+                         '    A static method\n')
+        self.assertEqual(self._get_summary_lines(X.sm), """\
+sm(x, y)
+    A static method
+""")
+        self.assertIn("""
+ |  Static methods defined here:
+ |
+ |  sm(x, y)
+ |      A static method
+""", pydoc.plain(pydoc.render_doc(X)))
+
+    @requires_docstrings
+    def test_classmethod(self):
+        class X:
+            @classmethod
+            def cm(cls, x):
+                '''A class method'''
+                ...
+        self.assertEqual(self._get_summary_lines(X.__dict__['cm']),
+                         'cm(...)\n'
+                         '    A class method\n')
+        self.assertEqual(self._get_summary_lines(X.cm), """\
+cm(x) class method of test.test_pydoc.test_pydoc.X
+    A class method
+""")
+        self.assertIn("""
+ |  Class methods defined here:
+ |
+ |  cm(x)
+ |      A class method
+""", pydoc.plain(pydoc.render_doc(X)))
+
+    @requires_docstrings
+    def test_getset_descriptor(self):
+        # Currently these attributes are implemented as getset descriptors
+        # in CPython.
+        self.assertEqual(self._get_summary_line(int.numerator), "numerator")
+        self.assertEqual(self._get_summary_line(float.real), "real")
+        self.assertEqual(self._get_summary_line(Exception.args), "args")
+        self.assertEqual(self._get_summary_line(memoryview.obj), "obj")
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    @requires_docstrings
+    def test_member_descriptor(self):
+        # Currently these attributes are implemented as member descriptors
+        # in CPython.
+        self.assertEqual(self._get_summary_line(complex.real), "real")
+        self.assertEqual(self._get_summary_line(range.start), "start")
+        self.assertEqual(self._get_summary_line(slice.start), "start")
+        self.assertEqual(self._get_summary_line(property.fget), "fget")
+        self.assertEqual(self._get_summary_line(StopIteration.value), "value")
+
+    @requires_docstrings
+    def test_slot_descriptor(self):
+        class Point:
+            __slots__ = 'x', 'y'
+        self.assertEqual(self._get_summary_line(Point.x), "x")
+
+    @requires_docstrings
+    def test_dict_attr_descriptor(self):
+        class NS:
+            pass
+        self.assertEqual(self._get_summary_line(NS.__dict__['__dict__']),
+                         "__dict__")
+
+    @requires_docstrings
+    def test_structseq_member_descriptor(self):
+        self.assertEqual(self._get_summary_line(type(sys.hash_info).width),
+                         "width")
+        self.assertEqual(self._get_summary_line(type(sys.flags).debug),
+                         "debug")
+        self.assertEqual(self._get_summary_line(type(sys.version_info).major),
+                         "major")
+        self.assertEqual(self._get_summary_line(type(sys.float_info).max),
+                         "max")
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    @requires_docstrings
+    def test_namedtuple_field_descriptor(self):
+        Box = namedtuple('Box', ('width', 'height'))
+        self.assertEqual(self._get_summary_lines(Box.width), """\
+    Alias for field number 0
+""")
+
+    @requires_docstrings
+    def test_property(self):
+        self.assertEqual(self._get_summary_lines(Rect.area), """\
+area
+    Area of the rect
+""")
+        # inherits the docstring from Rect.area
+        self.assertEqual(self._get_summary_lines(Square.area), """\
+area
+    Area of the rect
+""")
+        self.assertIn("""
+ |  area
+ |      Area of the rect
+""", pydoc.plain(pydoc.render_doc(Rect)))
+
+    @requires_docstrings
+    def test_custom_non_data_descriptor(self):
+        class Descr:
+            def __get__(self, obj, cls):
+                if obj is None:
+                    return self
+                return 42
+        class X:
+            attr = Descr()
+
+        self.assertEqual(self._get_summary_lines(X.attr), f"""\
+<{__name__}.TestDescriptions.test_custom_non_data_descriptor.<locals>.Descr object>""")
+
+        X.attr.__doc__ = 'Custom descriptor'
+        self.assertEqual(self._get_summary_lines(X.attr), f"""\
+<{__name__}.TestDescriptions.test_custom_non_data_descriptor.<locals>.Descr object>
+    Custom descriptor
+""")
+
+        X.attr.__name__ = 'foo'
+        self.assertEqual(self._get_summary_lines(X.attr), """\
+foo(...)
+    Custom descriptor
+""")
+
+    @requires_docstrings
+    def test_custom_data_descriptor(self):
+        class Descr:
+            def __get__(self, obj, cls):
+                if obj is None:
+                    return self
+                return 42
+            def __set__(self, obj, cls):
+                1/0
+        class X:
+            attr = Descr()
+
+        self.assertEqual(self._get_summary_lines(X.attr), "")
+
+        X.attr.__doc__ = 'Custom descriptor'
+        self.assertEqual(self._get_summary_lines(X.attr), """\
+    Custom descriptor
+""")
+
+        X.attr.__name__ = 'foo'
+        self.assertEqual(self._get_summary_lines(X.attr), """\
+foo
+    Custom descriptor
+""")
+
+    def test_async_annotation(self):
+        async def coro_function(ign) -> int:
+            return 1
+
+        text = pydoc.plain(pydoc.plaintext.document(coro_function))
+        self.assertIn('async coro_function', text)
+
+        html = pydoc.HTMLDoc().document(coro_function)
+        self.assertIn(
+            'async <a name="-coro_function"><strong>coro_function',
+            html)
+
+    def test_async_generator_annotation(self):
+        async def an_async_generator():
+            yield 1
+
+        text = pydoc.plain(pydoc.plaintext.document(an_async_generator))
+        self.assertIn('async an_async_generator', text)
+
+        html = pydoc.HTMLDoc().document(an_async_generator)
+        self.assertIn(
+            'async <a name="-an_async_generator"><strong>an_async_generator',
+            html)
+
+    @requires_docstrings
+    def test_html_for_https_links(self):
+        def a_fn_with_https_link():
+            """a link https://localhost/"""
+            pass
+
+        html = pydoc.HTMLDoc().document(a_fn_with_https_link)
+        self.assertIn(
+            '<a href="https://localhost/">https://localhost/</a>',
+            html
+        )
+
+    def test_module_none(self):
+        # Issue #128772
+        from test.test_pydoc import module_none
+        pydoc.render_doc(module_none)
+
+
+class PydocFodderTest(unittest.TestCase):
+    def tearDown(self):
+        self.assertIs(sys.modules['pydoc'], pydoc)
+
+    def getsection(self, text, beginline, endline):
+        lines = text.splitlines()
+        beginindex, endindex = 0, None
+        if beginline is not None:
+            beginindex = lines.index(beginline)
+        if endline is not None:
+            endindex = lines.index(endline, beginindex)
+        return lines[beginindex:endindex]
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    def test_text_doc_routines_in_class(self, cls=pydocfodder.B):
+        doc = pydoc.TextDoc()
+        result = doc.docclass(cls)
+        result = clean_text(result)
+        where = 'defined here' if cls is pydocfodder.B else 'inherited from B'
+        lines = self.getsection(result, f' |  Methods {where}:', ' |  ' + '-'*70)
+        self.assertIn(' |  A_method_alias = A_method(self)', lines)
+        self.assertIn(' |  B_method_alias = B_method(self)', lines)
+        self.assertIn(' |  A_staticmethod(x, y) from test.test_pydoc.pydocfodder.A', lines)
+        self.assertIn(' |  A_staticmethod_alias = A_staticmethod(x, y)', lines)
+        self.assertIn(' |  global_func(x, y) from test.test_pydoc.pydocfodder', lines)
+        self.assertIn(' |  global_func_alias = global_func(x, y)', lines)
+        self.assertIn(' |  global_func2_alias = global_func2(x, y) from test.test_pydoc.pydocfodder', lines)
+        if not support.MISSING_C_DOCSTRINGS:
+            self.assertIn(' |  count(self, value, /) from builtins.list', lines)
+            self.assertIn(' |  list_count = count(self, value, /)', lines)
+            self.assertIn(' |  __repr__(self, /) from builtins.object', lines)
+            self.assertIn(' |  object_repr = __repr__(self, /)', lines)
+        else:
+            self.assertIn(' |  count(self, object, /) from builtins.list', lines)
+            self.assertIn(' |  list_count = count(self, object, /)', lines)
+            self.assertIn(' |  __repr__(...) from builtins.object', lines)
+            self.assertIn(' |  object_repr = __repr__(...)', lines)
+
+        lines = self.getsection(result, f' |  Static methods {where}:', ' |  ' + '-'*70)
+        self.assertIn(' |  A_classmethod_ref = A_classmethod(x) class method of test.test_pydoc.pydocfodder.A', lines)
+        note = '' if cls is pydocfodder.B else ' class method of test.test_pydoc.pydocfodder.B'
+        self.assertIn(' |  B_classmethod_ref = B_classmethod(x)' + note, lines)
+        self.assertIn(' |  A_method_ref = A_method() method of test.test_pydoc.pydocfodder.A instance', lines)
+        if not support.MISSING_C_DOCSTRINGS:
+            self.assertIn(' |  get(key, default=None, /) method of builtins.dict instance', lines)
+            self.assertIn(' |  dict_get = get(key, default=None, /) method of builtins.dict instance', lines)
+            self.assertIn(' |  sin(x, /)', lines)
+        else:
+            self.assertIn(' |  get(...) method of builtins.dict instance', lines)
+            self.assertIn(' |  dict_get = get(...) method of builtins.dict instance', lines)
+            self.assertIn(' |  sin(object, /)', lines)
+
+        lines = self.getsection(result, f' |  Class methods {where}:', ' |  ' + '-'*70)
+        self.assertIn(' |  B_classmethod(x)', lines)
+        self.assertIn(' |  B_classmethod_alias = B_classmethod(x)', lines)
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    def test_html_doc_routines_in_class(self, cls=pydocfodder.B):
+        doc = pydoc.HTMLDoc()
+        result = doc.docclass(cls)
+        result = html2text(result)
+        where = 'defined here' if cls is pydocfodder.B else 'inherited from B'
+        lines = self.getsection(result, f'Methods {where}:', '-'*70)
+        self.assertIn('A_method_alias = A_method(self)', lines)
+        self.assertIn('B_method_alias = B_method(self)', lines)
+        self.assertIn('A_staticmethod(x, y) from test.test_pydoc.pydocfodder.A', lines)
+        self.assertIn('A_staticmethod_alias = A_staticmethod(x, y)', lines)
+        self.assertIn('global_func(x, y) from test.test_pydoc.pydocfodder', lines)
+        self.assertIn('global_func_alias = global_func(x, y)', lines)
+        self.assertIn('global_func2_alias = global_func2(x, y) from test.test_pydoc.pydocfodder', lines)
+        if not support.MISSING_C_DOCSTRINGS:
+            self.assertIn('count(self, value, /) from builtins.list', lines)
+            self.assertIn('list_count = count(self, value, /)', lines)
+            self.assertIn('__repr__(self, /) from builtins.object', lines)
+            self.assertIn('object_repr = __repr__(self, /)', lines)
+        else:
+            self.assertIn('count(self, object, /) from builtins.list', lines)
+            self.assertIn('list_count = count(self, object, /)', lines)
+            self.assertIn('__repr__(...) from builtins.object', lines)
+            self.assertIn('object_repr = __repr__(...)', lines)
+
+        lines = self.getsection(result, f'Static methods {where}:', '-'*70)
+        self.assertIn('A_classmethod_ref = A_classmethod(x) class method of test.test_pydoc.pydocfodder.A', lines)
+        note = '' if cls is pydocfodder.B else ' class method of test.test_pydoc.pydocfodder.B'
+        self.assertIn('B_classmethod_ref = B_classmethod(x)' + note, lines)
+        self.assertIn('A_method_ref = A_method() method of test.test_pydoc.pydocfodder.A instance', lines)
+
+        lines = self.getsection(result, f'Class methods {where}:', '-'*70)
+        self.assertIn('B_classmethod(x)', lines)
+        self.assertIn('B_classmethod_alias = B_classmethod(x)', lines)
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    def test_text_doc_inherited_routines_in_class(self):
+        self.test_text_doc_routines_in_class(pydocfodder.D)
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    def test_html_doc_inherited_routines_in_class(self):
+        self.test_html_doc_routines_in_class(pydocfodder.D)
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    def test_text_doc_routines_in_module(self):
+        doc = pydoc.TextDoc()
+        result = doc.docmodule(pydocfodder)
+        result = clean_text(result)
+        lines = self.getsection(result, 'FUNCTIONS', 'FILE')
+        # function alias
+        self.assertIn('    global_func_alias = global_func(x, y)', lines)
+        self.assertIn('    A_staticmethod(x, y)', lines)
+        self.assertIn('    A_staticmethod_alias = A_staticmethod(x, y)', lines)
+        # bound class methods
+        self.assertIn('    A_classmethod(x) class method of A', lines)
+        self.assertIn('    A_classmethod2 = A_classmethod(x) class method of A', lines)
+        self.assertIn('    A_classmethod3 = A_classmethod(x) class method of B', lines)
+        # bound methods
+        self.assertIn('    A_method() method of A instance', lines)
+        self.assertIn('    A_method2 = A_method() method of A instance', lines)
+        self.assertIn('    A_method3 = A_method() method of B instance', lines)
+        self.assertIn('    A_staticmethod_ref = A_staticmethod(x, y)', lines)
+        self.assertIn('    A_staticmethod_ref2 = A_staticmethod(y) method of B instance', lines)
+        if not support.MISSING_C_DOCSTRINGS:
+            self.assertIn('    get(key, default=None, /) method of builtins.dict instance', lines)
+            self.assertIn('    dict_get = get(key, default=None, /) method of builtins.dict instance', lines)
+        else:
+            self.assertIn('    get(...) method of builtins.dict instance', lines)
+            self.assertIn('    dict_get = get(...) method of builtins.dict instance', lines)
+
+        # unbound methods
+        self.assertIn('    B_method(self)', lines)
+        self.assertIn('    B_method2 = B_method(self)', lines)
+        if not support.MISSING_C_DOCSTRINGS:
+            self.assertIn('    count(self, value, /) unbound builtins.list method', lines)
+            self.assertIn('    list_count = count(self, value, /) unbound builtins.list method', lines)
+            self.assertIn('    __repr__(self, /) unbound builtins.object method', lines)
+            self.assertIn('    object_repr = __repr__(self, /) unbound builtins.object method', lines)
+        else:
+            self.assertIn('    count(self, object, /) unbound builtins.list method', lines)
+            self.assertIn('    list_count = count(self, object, /) unbound builtins.list method', lines)
+            self.assertIn('    __repr__(...) unbound builtins.object method', lines)
+            self.assertIn('    object_repr = __repr__(...) unbound builtins.object method', lines)
+
+        # builtin functions
+        if not support.MISSING_C_DOCSTRINGS:
+            self.assertIn('    sin(x, /)', lines)
+        else:
+            self.assertIn('    sin(object, /)', lines)
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    def test_html_doc_routines_in_module(self):
+        doc = pydoc.HTMLDoc()
+        result = doc.docmodule(pydocfodder)
+        result = html2text(result)
+        lines = self.getsection(result, ' Functions', None)
+        # function alias
+        self.assertIn(' global_func_alias = global_func(x, y)', lines)
+        self.assertIn(' A_staticmethod(x, y)', lines)
+        self.assertIn(' A_staticmethod_alias = A_staticmethod(x, y)', lines)
+        # bound class methods
+        self.assertIn('A_classmethod(x) class method of A', lines)
+        self.assertIn(' A_classmethod2 = A_classmethod(x) class method of A', lines)
+        self.assertIn(' A_classmethod3 = A_classmethod(x) class method of B', lines)
+        # bound methods
+        self.assertIn(' A_method() method of A instance', lines)
+        self.assertIn(' A_method2 = A_method() method of A instance', lines)
+        self.assertIn(' A_method3 = A_method() method of B instance', lines)
+        self.assertIn(' A_staticmethod_ref = A_staticmethod(x, y)', lines)
+        self.assertIn(' A_staticmethod_ref2 = A_staticmethod(y) method of B instance', lines)
+        if not support.MISSING_C_DOCSTRINGS:
+            self.assertIn(' get(key, default=None, /) method of builtins.dict instance', lines)
+            self.assertIn(' dict_get = get(key, default=None, /) method of builtins.dict instance', lines)
+        else:
+            self.assertIn(' get(...) method of builtins.dict instance', lines)
+            self.assertIn(' dict_get = get(...) method of builtins.dict instance', lines)
+        # unbound methods
+        self.assertIn(' B_method(self)', lines)
+        self.assertIn(' B_method2 = B_method(self)', lines)
+        if not support.MISSING_C_DOCSTRINGS:
+            self.assertIn(' count(self, value, /) unbound builtins.list method', lines)
+            self.assertIn(' list_count = count(self, value, /) unbound builtins.list method', lines)
+            self.assertIn(' __repr__(self, /) unbound builtins.object method', lines)
+            self.assertIn(' object_repr = __repr__(self, /) unbound builtins.object method', lines)
+        else:
+            self.assertIn(' count(self, object, /) unbound builtins.list method', lines)
+            self.assertIn(' list_count = count(self, object, /) unbound builtins.list method', lines)
+            self.assertIn(' __repr__(...) unbound builtins.object method', lines)
+            self.assertIn(' object_repr = __repr__(...) unbound builtins.object method', lines)
+
+        # builtin functions
+        if not support.MISSING_C_DOCSTRINGS:
+            self.assertIn(' sin(x, /)', lines)
+        else:
+            self.assertIn(' sin(object, /)', lines)
+
+
+@unittest.skipIf(
+    is_wasm32,
+    "Socket server not available on Emscripten/WASI."
+)
+class PydocServerTest(unittest.TestCase):
+    """Tests for pydoc._start_server"""
+    def tearDown(self):
+        self.assertIs(sys.modules['pydoc'], pydoc)
+
+    def test_server(self):
+        # Minimal test that starts the server, checks that it works, then stops
+        # it and checks its cleanup.
+        def my_url_handler(url, content_type):
+            text = 'the URL sent was: (%s, %s)' % (url, content_type)
+            return text
+
+        serverthread = pydoc._start_server(
+            my_url_handler,
+            hostname='localhost',
+            port=0,
+            )
+        self.assertEqual(serverthread.error, None)
+        self.assertTrue(serverthread.serving)
+        self.addCleanup(
+            lambda: serverthread.stop() if serverthread.serving else None
+            )
+        self.assertIn('localhost', serverthread.url)
+
+        self.addCleanup(urlcleanup)
+        self.assertEqual(
+            b'the URL sent was: (/test, text/html)',
+            urlopen(urllib.parse.urljoin(serverthread.url, '/test')).read(),
+            )
+        self.assertEqual(
+            b'the URL sent was: (/test.css, text/css)',
+            urlopen(urllib.parse.urljoin(serverthread.url, '/test.css')).read(),
+            )
+
+        serverthread.stop()
+        self.assertFalse(serverthread.serving)
+        self.assertIsNone(serverthread.docserver)
+        self.assertIsNone(serverthread.url)
+
+
+class PydocUrlHandlerTest(PydocBaseTest):
+    """Tests for pydoc._url_handler"""
+
+    @unittest.skip("TODO: RUSTPYTHON; Panic")
+    def test_content_type_err(self):
+        f = pydoc._url_handler
+        self.assertRaises(TypeError, f, 'A', '')
+        self.assertRaises(TypeError, f, 'B', 'foobar')
+
+    def test_url_requests(self):
+        # Test for the correct title in the html pages returned.
+        # This tests the different parts of the URL handler without
+        # getting too picky about the exact html.
+        requests = [
+            ("", "Pydoc: Index of Modules"),
+            ("get?key=", "Pydoc: Index of Modules"),
+            ("index", "Pydoc: Index of Modules"),
+            ("topics", "Pydoc: Topics"),
+            ("keywords", "Pydoc: Keywords"),
+            ("pydoc", "Pydoc: module pydoc"),
+            ("get?key=pydoc", "Pydoc: module pydoc"),
+            ("search?key=pydoc", "Pydoc: Search Results"),
+            ("topic?key=def", "Pydoc: KEYWORD def"),
+            ("topic?key=STRINGS", "Pydoc: TOPIC STRINGS"),
+            ("foobar", "Pydoc: Error - foobar"),
+            ]
+
+        self.assertIs(sys.modules['pydoc'], pydoc)
+        try:
+            with self.restrict_walk_packages():
+                for url, title in requests:
+                    self.call_url_handler(url, title)
+        finally:
+            # Some requests reload the module and change sys.modules.
+            sys.modules['pydoc'] = pydoc
+
+
+class TestHelper(unittest.TestCase):
+    def mock_interactive_session(self, inputs):
+        """
+        Given a list of inputs, run an interactive help session.  Returns a string
+        of what would be shown on screen.
+        """
+        input_iter = iter(inputs)
+
+        def mock_getline(prompt):
+            output.write(prompt)
+            next_input = next(input_iter)
+            output.write(next_input + os.linesep)
+            return next_input
+
+        with captured_stdout() as output:
+            helper = pydoc.Helper(output=output)
+            with unittest.mock.patch.object(helper, "getline", mock_getline):
+                helper.interact()
+
+        # handle different line endings across platforms consistently
+        return output.getvalue().strip().splitlines(keepends=False)
+
+    def test_keywords(self):
+        self.assertEqual(sorted(pydoc.Helper.keywords),
+                         sorted(keyword.kwlist))
+
+    def test_interact_empty_line_continues(self):
+        # gh-138568: test pressing Enter without input should continue in help session
+        self.assertEqual(
+            self.mock_interactive_session(["", "    ", "quit"]),
+            ["help> ", "help>     ", "help> quit"],
+        )
+
+    def test_interact_quit_commands_exit(self):
+        quit_commands = ["quit", "q", "exit"]
+        for quit_cmd in quit_commands:
+            with self.subTest(quit_command=quit_cmd):
+                self.assertEqual(
+                    self.mock_interactive_session([quit_cmd]),
+                    [f"help> {quit_cmd}"],
+                )
+
+
+class PydocWithMetaClasses(unittest.TestCase):
+    def tearDown(self):
+        self.assertIs(sys.modules['pydoc'], pydoc)
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    @unittest.skipIf(hasattr(sys, 'gettrace') and sys.gettrace(),
+                     'trace function introduces __locals__ unexpectedly')
+    @requires_docstrings
+    def test_DynamicClassAttribute(self):
+        class Meta(type):
+            def __getattr__(self, name):
+                if name == 'ham':
+                    return 'spam'
+                return super().__getattr__(name)
+        class DA(metaclass=Meta):
+            @types.DynamicClassAttribute
+            def ham(self):
+                return 'eggs'
+        expected_text_data_docstrings = tuple('\n |      ' + s if s else ''
+                                      for s in expected_data_docstrings)
+        output = StringIO()
+        helper = pydoc.Helper(output=output)
+        helper(DA)
+        expected_text = expected_dynamicattribute_pattern % (
+                (__name__,) + expected_text_data_docstrings[:2])
+        result = output.getvalue().strip()
+        self.assertEqual(expected_text, result)
+
+    @unittest.skipIf(hasattr(sys, 'gettrace') and sys.gettrace(),
+                     'trace function introduces __locals__ unexpectedly')
+    @requires_docstrings
+    def test_virtualClassAttributeWithOneMeta(self):
+        class Meta(type):
+            def __dir__(cls):
+                return ['__class__', '__module__', '__name__', 'LIFE']
+            def __getattr__(self, name):
+                if name =='LIFE':
+                    return 42
+                return super().__getattr(name)
+        class Class(metaclass=Meta):
+            pass
+        output = StringIO()
+        helper = pydoc.Helper(output=output)
+        helper(Class)
+        expected_text = expected_virtualattribute_pattern1 % __name__
+        result = output.getvalue().strip()
+        self.assertEqual(expected_text, result)
+
+    @unittest.skipIf(hasattr(sys, 'gettrace') and sys.gettrace(),
+                     'trace function introduces __locals__ unexpectedly')
+    @requires_docstrings
+    def test_virtualClassAttributeWithTwoMeta(self):
+        class Meta1(type):
+            def __dir__(cls):
+                return ['__class__', '__module__', '__name__', 'one']
+            def __getattr__(self, name):
+                if name =='one':
+                    return 1
+                return super().__getattr__(name)
+        class Meta2(type):
+            def __dir__(cls):
+                return ['__class__', '__module__', '__name__', 'two']
+            def __getattr__(self, name):
+                if name =='two':
+                    return 2
+                return super().__getattr__(name)
+        class Meta3(Meta1, Meta2):
+            def __dir__(cls):
+                return list(sorted(set(
+                    ['__class__', '__module__', '__name__', 'three'] +
+                    Meta1.__dir__(cls) + Meta2.__dir__(cls))))
+            def __getattr__(self, name):
+                if name =='three':
+                    return 3
+                return super().__getattr__(name)
+        class Class1(metaclass=Meta1):
+            pass
+        class Class2(Class1, metaclass=Meta3):
+            pass
+        output = StringIO()
+        helper = pydoc.Helper(output=output)
+        helper(Class1)
+        expected_text1 = expected_virtualattribute_pattern2 % __name__
+        result1 = output.getvalue().strip()
+        self.assertEqual(expected_text1, result1)
+        output = StringIO()
+        helper = pydoc.Helper(output=output)
+        helper(Class2)
+        expected_text2 = expected_virtualattribute_pattern3 % __name__
+        result2 = output.getvalue().strip()
+        self.assertEqual(expected_text2, result2)
+
+    @unittest.skipIf(hasattr(sys, 'gettrace') and sys.gettrace(),
+                     'trace function introduces __locals__ unexpectedly')
+    @requires_docstrings
+    def test_buggy_dir(self):
+        class M(type):
+            def __dir__(cls):
+                return ['__class__', '__name__', 'missing', 'here']
+        class C(metaclass=M):
+            here = 'present!'
+        output = StringIO()
+        helper = pydoc.Helper(output=output)
+        helper(C)
+        expected_text = expected_missingattribute_pattern % __name__
+        result = output.getvalue().strip()
+        self.assertEqual(expected_text, result)
+
+    def test_resolve_false(self):
+        # Issue #23008: pydoc enum.{,Int}Enum failed
+        # because bool(enum.Enum) is False.
+        with captured_stdout() as help_io:
+            pydoc.help('enum.Enum')
+        helptext = help_io.getvalue()
+        self.assertIn('class Enum', helptext)
+
+
+class TestInternalUtilities(unittest.TestCase):
+
+    def setUp(self):
+        tmpdir = tempfile.TemporaryDirectory()
+        self.argv0dir = tmpdir.name
+        self.argv0 = os.path.join(tmpdir.name, "nonexistent")
+        self.addCleanup(tmpdir.cleanup)
+        self.abs_curdir = abs_curdir = os.getcwd()
+        self.curdir_spellings = ["", os.curdir, abs_curdir]
+
+    def _get_revised_path(self, given_path, argv0=None):
+        # Checking that pydoc.cli() actually calls pydoc._get_revised_path()
+        # is handled via code review (at least for now).
+        if argv0 is None:
+            argv0 = self.argv0
+        return pydoc._get_revised_path(given_path, argv0)
+
+    def _get_starting_path(self):
+        # Get a copy of sys.path without the current directory.
+        clean_path = sys.path.copy()
+        for spelling in self.curdir_spellings:
+            for __ in range(clean_path.count(spelling)):
+                clean_path.remove(spelling)
+        return clean_path
+
+    def test_sys_path_adjustment_adds_missing_curdir(self):
+        clean_path = self._get_starting_path()
+        expected_path = [self.abs_curdir] + clean_path
+        self.assertEqual(self._get_revised_path(clean_path), expected_path)
+
+    def test_sys_path_adjustment_removes_argv0_dir(self):
+        clean_path = self._get_starting_path()
+        expected_path = [self.abs_curdir] + clean_path
+        leading_argv0dir = [self.argv0dir] + clean_path
+        self.assertEqual(self._get_revised_path(leading_argv0dir), expected_path)
+        trailing_argv0dir = clean_path + [self.argv0dir]
+        self.assertEqual(self._get_revised_path(trailing_argv0dir), expected_path)
+
+    def test_sys_path_adjustment_protects_pydoc_dir(self):
+        def _get_revised_path(given_path):
+            return self._get_revised_path(given_path, argv0=pydoc.__file__)
+        clean_path = self._get_starting_path()
+        leading_argv0dir = [self.argv0dir] + clean_path
+        expected_path = [self.abs_curdir] + leading_argv0dir
+        self.assertEqual(_get_revised_path(leading_argv0dir), expected_path)
+        trailing_argv0dir = clean_path + [self.argv0dir]
+        expected_path = [self.abs_curdir] + trailing_argv0dir
+        self.assertEqual(_get_revised_path(trailing_argv0dir), expected_path)
+
+    def test_sys_path_adjustment_when_curdir_already_included(self):
+        clean_path = self._get_starting_path()
+        for spelling in self.curdir_spellings:
+            with self.subTest(curdir_spelling=spelling):
+                # If curdir is already present, no alterations are made at all
+                leading_curdir = [spelling] + clean_path
+                self.assertIsNone(self._get_revised_path(leading_curdir))
+                trailing_curdir = clean_path + [spelling]
+                self.assertIsNone(self._get_revised_path(trailing_curdir))
+                leading_argv0dir = [self.argv0dir] + leading_curdir
+                self.assertIsNone(self._get_revised_path(leading_argv0dir))
+                trailing_argv0dir = trailing_curdir + [self.argv0dir]
+                self.assertIsNone(self._get_revised_path(trailing_argv0dir))
+
+
+def setUpModule():
+    thread_info = threading_helper.threading_setup()
+    unittest.addModuleCleanup(threading_helper.threading_cleanup, *thread_info)
+    unittest.addModuleCleanup(reap_children)
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/Lib/test/test_pyexpat.py b/Lib/test/test_pyexpat.py
index d360e8cd65d..e28c15de62d 100644
--- a/Lib/test/test_pyexpat.py
+++ b/Lib/test/test_pyexpat.py
@@ -1,14 +1,18 @@
 # XXX TypeErrors on calling handlers, or on bad return values from a
 # handler, are obscure and unhelpful.
 
+import abc
+import functools
 import os
+import re
 import sys
 import sysconfig
+import textwrap
 import unittest
 import traceback
 from io import BytesIO
 from test import support
-from test.support import os_helper
+from test.support import import_helper, os_helper
 
 from xml.parsers import expat
 from xml.parsers.expat import errors
@@ -261,7 +265,7 @@ def test_parse_file(self):
         operations = out.out
         self._verify_parse_output(operations)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_parse_again(self):
         parser = expat.ParserCreate()
         file = BytesIO(data)
@@ -282,7 +286,7 @@ def test_legal(self):
         expat.ParserCreate(namespace_separator=None)
         expat.ParserCreate(namespace_separator=' ')
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_illegal(self):
         with self.assertRaisesRegex(TypeError,
                 r"ParserCreate\(\) argument (2|'namespace_separator') "
@@ -309,7 +313,7 @@ def test_zero_length(self):
 
 
 class InterningTest(unittest.TestCase):
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test(self):
         # Test the interning machinery.
         p = expat.ParserCreate()
@@ -325,7 +329,7 @@ def collector(name, *args):
             # L should have the same string repeated over and over.
             self.assertTrue(tag is entry)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_issue9402(self):
         # create an ExternalEntityParserCreate with buffer text
         class ExternalOutputter:
@@ -383,7 +387,7 @@ def test_default_to_disabled(self):
         parser = expat.ParserCreate()
         self.assertFalse(parser.buffer_text)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_buffering_enabled(self):
         # Make sure buffering is turned on
         self.assertTrue(self.parser.buffer_text)
@@ -391,7 +395,7 @@ def test_buffering_enabled(self):
         self.assertEqual(self.stuff, ['123'],
                          "buffered text not properly collapsed")
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test1(self):
         # XXX This test exposes more detail of Expat's text chunking than we
         # XXX like, but it tests what we need to concisely.
@@ -401,7 +405,7 @@ def test1(self):
                          ["<a>", "1", "<b>", "2", "\n", "3", "<c>", "4\n5"],
                          "buffering control not reacting as expected")
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test2(self):
         self.parser.Parse(b"<a>1<b/>&lt;2&gt;<c/>&#32;\n&#x20;3</a>", True)
         self.assertEqual(self.stuff, ["1<2> \n 3"],
@@ -434,7 +438,7 @@ def test6(self):
             ["<a>", "1", "<b>", "</b>", "2", "<c>", "</c>", "345", "</a>"],
             "buffered text not properly split")
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test7(self):
         self.setHandlers(["CommentHandler", "EndElementHandler",
                     "StartElementHandler"])
@@ -536,7 +540,7 @@ def test(self):
 
 
 class sf1296433Test(unittest.TestCase):
-    @unittest.expectedFailure # TODO: RUSTPYTHON; TypeError: Expected type 'str' but 'bytes' found.
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; TypeError: Expected type 'str' but 'bytes' found.
     def test_parse_only_xml_data(self):
         # https://bugs.python.org/issue1296433
         #
@@ -560,15 +564,15 @@ class ChardataBufferTest(unittest.TestCase):
     test setting of chardata buffer size
     """
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_1025_bytes(self):
         self.assertEqual(self.small_buffer_test(1025), 2)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_1000_bytes(self):
         self.assertEqual(self.small_buffer_test(1000), 1)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_wrong_size(self):
         parser = expat.ParserCreate()
         parser.buffer_text = 1
@@ -581,7 +585,7 @@ def test_wrong_size(self):
         with self.assertRaises(TypeError):
             parser.buffer_size = 512.0
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_unchanged_size(self):
         xml1 = b"<?xml version='1.0' encoding='iso8859'?><s>" + b'a' * 512
         xml2 = b'a'*512 + b'</s>'
@@ -605,7 +609,7 @@ def test_unchanged_size(self):
         self.assertEqual(self.n, 2)
 
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_disabling_buffer(self):
         xml1 = b"<?xml version='1.0' encoding='iso8859'?><a>" + b'a' * 512
         xml2 = b'b' * 1024
@@ -650,7 +654,7 @@ def small_buffer_test(self, buffer_len):
         parser.Parse(xml)
         return self.n
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_change_size_1(self):
         xml1 = b"<?xml version='1.0' encoding='iso8859'?><a><s>" + b'a' * 1024
         xml2 = b'aaa</s><s>' + b'a' * 1025 + b'</s></a>'
@@ -667,7 +671,7 @@ def test_change_size_1(self):
         parser.Parse(xml2, True)
         self.assertEqual(self.n, 2)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_change_size_2(self):
         xml1 = b"<?xml version='1.0' encoding='iso8859'?><a>a<s>" + b'a' * 1023
         xml2 = b'aaa</s><s>' + b'a' * 1025 + b'</s></a>'
@@ -684,8 +688,26 @@ def test_change_size_2(self):
         parser.Parse(xml2, True)
         self.assertEqual(self.n, 4)
 
+class ElementDeclHandlerTest(unittest.TestCase):
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AssertionError: TypeError not raised by Parse
+    def test_trigger_leak(self):
+        # Unfixed, this test would leak the memory of the so-called
+        # "content model" in function ``my_ElementDeclHandler`` of pyexpat.
+        # See https://github.com/python/cpython/issues/140593.
+        data = textwrap.dedent('''\
+            <!DOCTYPE quotations SYSTEM "quotations.dtd" [
+                <!ELEMENT root ANY>
+            ]>
+            <root/>
+        ''').encode('UTF-8')
+
+        parser = expat.ParserCreate()
+        parser.NotStandaloneHandler = lambda: 1.234  # arbitrary float
+        parser.ElementDeclHandler = lambda _1, _2: None
+        self.assertRaises(TypeError, parser.Parse, data, True)
+
 class MalformedInputTest(unittest.TestCase):
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test1(self):
         xml = b"\0\r\n"
         parser = expat.ParserCreate()
@@ -695,7 +717,7 @@ def test1(self):
         except expat.ExpatError as e:
             self.assertEqual(str(e), 'unclosed token: line 2, column 0')
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test2(self):
         # \xc2\x85 is UTF-8 encoded U+0085 (NEXT LINE)
         xml = b"<?xml version\xc2\x85='1.0'?>\r\n"
@@ -705,13 +727,13 @@ def test2(self):
             parser.Parse(xml, True)
 
 class ErrorMessageTest(unittest.TestCase):
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_codes(self):
         # verify mapping of errors.codes and errors.messages
         self.assertEqual(errors.XML_ERROR_SYNTAX,
                          errors.messages[errors.codes[errors.XML_ERROR_SYNTAX]])
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_expaterror(self):
         xml = b'<'
         parser = expat.ParserCreate()
@@ -727,7 +749,7 @@ class ForeignDTDTests(unittest.TestCase):
     """
     Tests for the UseForeignDTD method of expat parser objects.
     """
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_use_foreign_dtd(self):
         """
         If UseForeignDTD is passed True and a document without an external
@@ -756,7 +778,7 @@ def resolve_entity(context, base, system_id, public_id):
         parser.Parse(b"<?xml version='1.0'?><element/>")
         self.assertEqual(handler_call_args, [(None, None)])
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_ignore_use_foreign_dtd(self):
         """
         If UseForeignDTD is passed True and a document with an external
@@ -785,7 +807,7 @@ class ParentParserLifetimeTest(unittest.TestCase):
     See https://github.com/python/cpython/issues/139400.
     """
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON; AttributeError: 'xmlparser' object has no attribute 'ExternalEntityParserCreate'
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AttributeError: 'xmlparser' object has no attribute 'ExternalEntityParserCreate'
     def test_parent_parser_outlives_its_subparsers__single(self):
         parser = expat.ParserCreate()
         subparser = parser.ExternalEntityParserCreate(None)
@@ -794,7 +816,7 @@ def test_parent_parser_outlives_its_subparsers__single(self):
         # while it's still being referenced by a related subparser.
         del parser
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON; AttributeError: 'xmlparser' object has no attribute 'ExternalEntityParserCreate'
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AttributeError: 'xmlparser' object has no attribute 'ExternalEntityParserCreate'
     def test_parent_parser_outlives_its_subparsers__multiple(self):
         parser = expat.ParserCreate()
         subparser_one = parser.ExternalEntityParserCreate(None)
@@ -804,7 +826,7 @@ def test_parent_parser_outlives_its_subparsers__multiple(self):
         # while it's still being referenced by a related subparser.
         del parser
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON; AttributeError: 'xmlparser' object has no attribute 'ExternalEntityParserCreate'
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AttributeError: 'xmlparser' object has no attribute 'ExternalEntityParserCreate'
     def test_parent_parser_outlives_its_subparsers__chain(self):
         parser = expat.ParserCreate()
         subparser = parser.ExternalEntityParserCreate(None)
@@ -817,7 +839,7 @@ def test_parent_parser_outlives_its_subparsers__chain(self):
 
 
 class ReparseDeferralTest(unittest.TestCase):
-    @unittest.expectedFailure # TODO: RUSTPYTHON; AttributeError: 'xmlparser' object has no attribute 'GetReparseDeferralEnabled'
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AttributeError: 'xmlparser' object has no attribute 'GetReparseDeferralEnabled'
     def test_getter_setter_round_trip(self):
         parser = expat.ParserCreate()
         enabled = (expat.version_info >= (2, 6, 0))
@@ -828,7 +850,7 @@ def test_getter_setter_round_trip(self):
         parser.SetReparseDeferralEnabled(True)
         self.assertIs(parser.GetReparseDeferralEnabled(), enabled)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON; AttributeError: 'xmlparser' object has no attribute 'GetReparseDeferralEnabled'
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AttributeError: 'xmlparser' object has no attribute 'GetReparseDeferralEnabled'
     def test_reparse_deferral_enabled(self):
         if expat.version_info < (2, 6, 0):
             self.skipTest(f'Expat {expat.version_info} does not '
@@ -853,7 +875,7 @@ def start_element(name, _):
 
         self.assertEqual(started, ['doc'])
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON; AttributeError: 'xmlparser' object has no attribute 'SetReparseDeferralEnabled'
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AttributeError: 'xmlparser' object has no attribute 'SetReparseDeferralEnabled'
     def test_reparse_deferral_disabled(self):
         started = []
 
@@ -873,5 +895,199 @@ def start_element(name, _):
         self.assertEqual(started, ['doc'])
 
 
+class AttackProtectionTestBase(abc.ABC):
+    """
+    Base class for testing protections against XML payloads with
+    disproportionate amplification.
+
+    The protections being tested should detect and prevent attacks
+    that leverage disproportionate amplification from small inputs.
+    """
+
+    @staticmethod
+    def exponential_expansion_payload(*, nrows, ncols, text='.'):
+        """Create a billion laughs attack payload.
+
+        Be careful: the number of total items is pow(n, k), thereby
+        requiring at least pow(ncols, nrows) * sizeof(text) memory!
+        """
+        template = textwrap.dedent(f"""\
+            <?xml version="1.0"?>
+            <!DOCTYPE doc [
+                <!ENTITY row0 "{text}">
+                <!ELEMENT doc (#PCDATA)>
+            {{body}}
+            ]>
+            <doc>&row{nrows};</doc>
+        """).rstrip()
+
+        body = '\n'.join(
+            f'<!ENTITY row{i + 1} "{f"&row{i};" * ncols}">'
+            for i in range(nrows)
+        )
+        body = textwrap.indent(body, ' ' * 4)
+        return template.format(body=body)
+
+    def test_payload_generation(self):
+        # self-test for exponential_expansion_payload()
+        payload = self.exponential_expansion_payload(nrows=2, ncols=3)
+        self.assertEqual(payload, textwrap.dedent("""\
+            <?xml version="1.0"?>
+            <!DOCTYPE doc [
+                <!ENTITY row0 ".">
+                <!ELEMENT doc (#PCDATA)>
+                <!ENTITY row1 "&row0;&row0;&row0;">
+                <!ENTITY row2 "&row1;&row1;&row1;">
+            ]>
+            <doc>&row2;</doc>
+        """).rstrip())
+
+    def assert_root_parser_failure(self, func, /, *args, **kwargs):
+        """Check that func(*args, **kwargs) is invalid for a sub-parser."""
+        msg = "parser must be a root parser"
+        self.assertRaisesRegex(expat.ExpatError, msg, func, *args, **kwargs)
+
+    @abc.abstractmethod
+    def assert_rejected(self, func, /, *args, **kwargs):
+        """Assert that func(*args, **kwargs) triggers the attack protection.
+
+        Note: this method must ensure that the attack protection being tested
+        is the one that is actually triggered at runtime, e.g., by matching
+        the exact error message.
+        """
+
+    @abc.abstractmethod
+    def set_activation_threshold(self, parser, threshold):
+        """Set the activation threshold for the tested protection."""
+
+    @abc.abstractmethod
+    def set_maximum_amplification(self, parser, max_factor):
+        """Set the maximum amplification factor for the tested protection."""
+
+    @abc.abstractmethod
+    def test_set_activation_threshold__threshold_reached(self):
+        """Test when the activation threshold is exceeded."""
+
+    @abc.abstractmethod
+    def test_set_activation_threshold__threshold_not_reached(self):
+        """Test when the activation threshold is not exceeded."""
+
+    def test_set_activation_threshold__invalid_threshold_type(self):
+        parser = expat.ParserCreate()
+        setter = functools.partial(self.set_activation_threshold, parser)
+
+        self.assertRaises(TypeError, setter, 1.0)
+        self.assertRaises(TypeError, setter, -1.5)
+        self.assertRaises(ValueError, setter, -5)
+
+    def test_set_activation_threshold__invalid_threshold_range(self):
+        _testcapi = import_helper.import_module("_testcapi")
+        parser = expat.ParserCreate()
+        setter = functools.partial(self.set_activation_threshold, parser)
+
+        self.assertRaises(OverflowError, setter, _testcapi.ULLONG_MAX + 1)
+
+    def test_set_activation_threshold__fail_for_subparser(self):
+        parser = expat.ParserCreate()
+        subparser = parser.ExternalEntityParserCreate(None)
+        setter = functools.partial(self.set_activation_threshold, subparser)
+        self.assert_root_parser_failure(setter, 12345)
+
+    @abc.abstractmethod
+    def test_set_maximum_amplification__amplification_exceeded(self):
+        """Test when the amplification factor is exceeded."""
+
+    @abc.abstractmethod
+    def test_set_maximum_amplification__amplification_not_exceeded(self):
+        """Test when the amplification factor is not exceeded."""
+
+    def test_set_maximum_amplification__infinity(self):
+        inf = float('inf')  # an 'inf' threshold is allowed by Expat
+        parser = expat.ParserCreate()
+        self.assertIsNone(self.set_maximum_amplification(parser, inf))
+
+    def test_set_maximum_amplification__invalid_max_factor_type(self):
+        parser = expat.ParserCreate()
+        setter = functools.partial(self.set_maximum_amplification, parser)
+
+        self.assertRaises(TypeError, setter, None)
+        self.assertRaises(TypeError, setter, 'abc')
+
+    def test_set_maximum_amplification__invalid_max_factor_range(self):
+        parser = expat.ParserCreate()
+        setter = functools.partial(self.set_maximum_amplification, parser)
+
+        msg = re.escape("'max_factor' must be at least 1.0")
+        self.assertRaisesRegex(expat.ExpatError, msg, setter, float('nan'))
+        self.assertRaisesRegex(expat.ExpatError, msg, setter, 0.99)
+
+    def test_set_maximum_amplification__fail_for_subparser(self):
+        parser = expat.ParserCreate()
+        subparser = parser.ExternalEntityParserCreate(None)
+        setter = functools.partial(self.set_maximum_amplification, subparser)
+        self.assert_root_parser_failure(setter, 123.45)
+
+
+@unittest.skipIf(expat.version_info < (2, 7, 2), "requires Expat >= 2.7.2")
+class MemoryProtectionTest(AttackProtectionTestBase, unittest.TestCase):
+
+    # NOTE: with the default Expat configuration, the billion laughs protection
+    # may hit before the allocation limiter if exponential_expansion_payload()
+    # is not carefully parametrized. As such, the payloads should be chosen so
+    # that either the allocation limiter is hit before other protections are
+    # triggered or no protection at all is triggered.
+
+    def assert_rejected(self, func, /, *args, **kwargs):
+        """Check that func(*args, **kwargs) hits the allocation limit."""
+        msg = r"out of memory: line \d+, column \d+"
+        self.assertRaisesRegex(expat.ExpatError, msg, func, *args, **kwargs)
+
+    def set_activation_threshold(self, parser, threshold):
+        return parser.SetAllocTrackerActivationThreshold(threshold)
+
+    def set_maximum_amplification(self, parser, max_factor):
+        return parser.SetAllocTrackerMaximumAmplification(max_factor)
+
+    def test_set_activation_threshold__threshold_reached(self):
+        parser = expat.ParserCreate()
+        # Choose a threshold expected to be always reached.
+        self.set_activation_threshold(parser, 3)
+        # Check that the threshold is reached by choosing a small factor
+        # and a payload whose peak amplification factor exceeds it.
+        self.assertIsNone(self.set_maximum_amplification(parser, 1.0))
+        payload = self.exponential_expansion_payload(ncols=10, nrows=4)
+        self.assert_rejected(parser.Parse, payload, True)
+
+    def test_set_activation_threshold__threshold_not_reached(self):
+        parser = expat.ParserCreate()
+        # Choose a threshold expected to be never reached.
+        self.set_activation_threshold(parser, pow(10, 5))
+        # Check that the threshold is reached by choosing a small factor
+        # and a payload whose peak amplification factor exceeds it.
+        self.assertIsNone(self.set_maximum_amplification(parser, 1.0))
+        payload = self.exponential_expansion_payload(ncols=10, nrows=4)
+        self.assertIsNotNone(parser.Parse(payload, True))
+
+    def test_set_maximum_amplification__amplification_exceeded(self):
+        parser = expat.ParserCreate()
+        # Unconditionally enable maximum activation factor.
+        self.set_activation_threshold(parser, 0)
+        # Choose a max amplification factor expected to always be exceeded.
+        self.assertIsNone(self.set_maximum_amplification(parser, 1.0))
+        # Craft a payload for which the peak amplification factor is > 1.0.
+        payload = self.exponential_expansion_payload(ncols=1, nrows=2)
+        self.assert_rejected(parser.Parse, payload, True)
+
+    def test_set_maximum_amplification__amplification_not_exceeded(self):
+        parser = expat.ParserCreate()
+        # Unconditionally enable maximum activation factor.
+        self.set_activation_threshold(parser, 0)
+        # Choose a max amplification factor expected to never be exceeded.
+        self.assertIsNone(self.set_maximum_amplification(parser, 1e4))
+        # Craft a payload for which the peak amplification factor is < 1e4.
+        payload = self.exponential_expansion_payload(ncols=1, nrows=2)
+        self.assertIsNotNone(parser.Parse(payload, True))
+
+
 if __name__ == "__main__":
     unittest.main()
diff --git a/Lib/test/test_queue.py b/Lib/test/test_queue.py
index 93cbe1fe230..c855fb8fe2b 100644
--- a/Lib/test/test_queue.py
+++ b/Lib/test/test_queue.py
@@ -2,12 +2,11 @@
 # to ensure the Queue locks remain stable.
 import itertools
 import random
-import sys
 import threading
 import time
 import unittest
 import weakref
-from test.support import gc_collect
+from test.support import gc_collect, bigmemtest
 from test.support import import_helper
 from test.support import threading_helper
 
@@ -964,33 +963,33 @@ def test_order(self):
         # One producer, one consumer => results appended in well-defined order
         self.assertEqual(results, inputs)
 
-    def test_many_threads(self):
+    @bigmemtest(size=50, memuse=100*2**20, dry_run=False)
+    def test_many_threads(self, size):
         # Test multiple concurrent put() and get()
-        N = 50
         q = self.q
         inputs = list(range(10000))
-        results = self.run_threads(N, q, inputs, self.feed, self.consume)
+        results = self.run_threads(size, q, inputs, self.feed, self.consume)
 
         # Multiple consumers without synchronization append the
         # results in random order
         self.assertEqual(sorted(results), inputs)
 
-    def test_many_threads_nonblock(self):
+    @bigmemtest(size=50, memuse=100*2**20, dry_run=False)
+    def test_many_threads_nonblock(self, size):
         # Test multiple concurrent put() and get(block=False)
-        N = 50
         q = self.q
         inputs = list(range(10000))
-        results = self.run_threads(N, q, inputs,
+        results = self.run_threads(size, q, inputs,
                                    self.feed, self.consume_nonblock)
 
         self.assertEqual(sorted(results), inputs)
 
-    def test_many_threads_timeout(self):
+    @bigmemtest(size=50, memuse=100*2**20, dry_run=False)
+    def test_many_threads_timeout(self, size):
         # Test multiple concurrent put() and get(timeout=...)
-        N = 50
         q = self.q
         inputs = list(range(1000))
-        results = self.run_threads(N, q, inputs,
+        results = self.run_threads(size, q, inputs,
                                    self.feed, self.consume_timeout)
 
         self.assertEqual(sorted(results), inputs)
diff --git a/Lib/test/test_raise.py b/Lib/test/test_raise.py
index 605169f4b40..645ef291a58 100644
--- a/Lib/test/test_raise.py
+++ b/Lib/test/test_raise.py
@@ -48,7 +48,7 @@ def test_except_reraise(self):
         def reraise():
             try:
                 raise TypeError("foo")
-            except:
+            except TypeError:
                 try:
                     raise KeyError("caught")
                 except KeyError:
@@ -60,7 +60,7 @@ def test_finally_reraise(self):
         def reraise():
             try:
                 raise TypeError("foo")
-            except:
+            except TypeError:
                 try:
                     raise KeyError("caught")
                 finally:
@@ -73,7 +73,7 @@ def nested_reraise():
         def reraise():
             try:
                 raise TypeError("foo")
-            except:
+            except TypeError:
                 nested_reraise()
         self.assertRaises(TypeError, reraise)
 
@@ -81,7 +81,7 @@ def test_raise_from_None(self):
         try:
             try:
                 raise TypeError("foo")
-            except:
+            except TypeError:
                 raise ValueError() from None
         except ValueError as e:
             self.assertIsInstance(e.__context__, TypeError)
@@ -91,7 +91,7 @@ def test_with_reraise1(self):
         def reraise():
             try:
                 raise TypeError("foo")
-            except:
+            except TypeError:
                 with Context():
                     pass
                 raise
@@ -101,7 +101,7 @@ def test_with_reraise2(self):
         def reraise():
             try:
                 raise TypeError("foo")
-            except:
+            except TypeError:
                 with Context():
                     raise KeyError("caught")
                 raise
@@ -111,7 +111,7 @@ def test_yield_reraise(self):
         def reraise():
             try:
                 raise TypeError("foo")
-            except:
+            except TypeError:
                 yield 1
                 raise
         g = reraise()
@@ -185,7 +185,6 @@ def test_class_cause(self):
         else:
             self.fail("No exception raised")
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON; TypeError: 'classmethod' object is not callable
     def test_class_cause_nonexception_result(self):
         # See https://github.com/python/cpython/issues/140530.
         class ConstructMortal(BaseException):
@@ -311,7 +310,7 @@ def test_instance_context_instance_raise(self):
         try:
             try:
                 raise context
-            except:
+            except IndexError:
                 raise OSError()
         except OSError as e:
             self.assertIs(e.__context__, context)
@@ -323,7 +322,7 @@ def test_class_context_instance_raise(self):
         try:
             try:
                 raise context
-            except:
+            except IndexError:
                 raise OSError()
         except OSError as e:
             self.assertIsNot(e.__context__, context)
@@ -336,7 +335,7 @@ def test_class_context_class_raise(self):
         try:
             try:
                 raise context
-            except:
+            except IndexError:
                 raise OSError
         except OSError as e:
             self.assertIsNot(e.__context__, context)
@@ -348,7 +347,7 @@ def test_c_exception_context(self):
         try:
             try:
                 1/0
-            except:
+            except ZeroDivisionError:
                 raise OSError
         except OSError as e:
             self.assertIsInstance(e.__context__, ZeroDivisionError)
@@ -359,7 +358,7 @@ def test_c_exception_raise(self):
         try:
             try:
                 1/0
-            except:
+            except ZeroDivisionError:
                 xyzzy
         except NameError as e:
             self.assertIsInstance(e.__context__, ZeroDivisionError)
@@ -456,7 +455,7 @@ def f():
             try:
                 try:
                     raise ValueError
-                except:
+                except ValueError:
                     del g
                     raise KeyError
             except Exception as e:
@@ -472,7 +471,7 @@ class C:
             def __del__(self):
                 try:
                     1/0
-                except:
+                except ZeroDivisionError:
                     raise
 
         def f():
diff --git a/Lib/test/test_random.py b/Lib/test/test_random.py
index 2cceaea2446..0217ebd132b 100644
--- a/Lib/test/test_random.py
+++ b/Lib/test/test_random.py
@@ -4,6 +4,7 @@
 import os
 import time
 import pickle
+import shlex
 import warnings
 import test.support
 
@@ -13,6 +14,15 @@
 from fractions import Fraction
 from collections import abc, Counter
 
+
+class MyIndex:
+    def __init__(self, value):
+        self.value = value
+
+    def __index__(self):
+        return self.value
+
+
 class TestBasicOps:
     # Superclass with tests common to all generators.
     # Subclasses must arrange for self.gen to retrieve the Random instance
@@ -141,6 +151,7 @@ def test_sample(self):
         # Exception raised if size of sample exceeds that of population
         self.assertRaises(ValueError, self.gen.sample, population, N+1)
         self.assertRaises(ValueError, self.gen.sample, [], -1)
+        self.assertRaises(TypeError, self.gen.sample, population, 1.0)
 
     def test_sample_distribution(self):
         # For the entire allowable range of 0 <= k <= N, validate that
@@ -224,8 +235,6 @@ def test_sample_with_counts(self):
             sample(['red', 'green', 'blue'], counts=10, k=10)               # counts not iterable
         with self.assertRaises(ValueError):
             sample(['red', 'green', 'blue'], counts=[-3, -7, -8], k=2)      # counts are negative
-        with self.assertRaises(ValueError):
-            sample(['red', 'green', 'blue'], counts=[0, 0, 0], k=2)         # counts are zero
         with self.assertRaises(ValueError):
             sample(['red', 'green'], counts=[10, 10], k=21)                 # population too small
         with self.assertRaises(ValueError):
@@ -233,6 +242,20 @@ def test_sample_with_counts(self):
         with self.assertRaises(ValueError):
             sample(['red', 'green', 'blue'], counts=[1, 2, 3, 4], k=2)      # too many counts
 
+        # Cases with zero counts match equivalents without counts (see gh-130285)
+        self.assertEqual(
+            sample('abc', k=0, counts=[0, 0, 0]),
+            sample([], k=0),
+        )
+        self.assertEqual(
+            sample([], 0, counts=[]),
+            sample([], 0),
+        )
+        with self.assertRaises(ValueError):
+            sample([], 1, counts=[])
+        with self.assertRaises(ValueError):
+            sample('x', 1, counts=[0])
+
     def test_choices(self):
         choices = self.gen.choices
         data = ['red', 'green', 'blue', 'yellow']
@@ -246,6 +269,7 @@ def test_choices(self):
             choices(data, range(4), k=5),
             choices(k=5, population=data, weights=range(4)),
             choices(k=5, population=data, cum_weights=range(4)),
+            choices(data, k=MyIndex(5)),
         ]:
             self.assertEqual(len(sample), 5)
             self.assertEqual(type(sample), list)
@@ -356,118 +380,40 @@ def test_gauss(self):
             self.assertEqual(x1, x2)
             self.assertEqual(y1, y2)
 
+    @support.requires_IEEE_754
+    def test_53_bits_per_float(self):
+        span = 2 ** 53
+        cum = 0
+        for i in range(100):
+            cum |= int(self.gen.random() * span)
+        self.assertEqual(cum, span-1)
+
     def test_getrandbits(self):
+        getrandbits = self.gen.getrandbits
         # Verify ranges
         for k in range(1, 1000):
-            self.assertTrue(0 <= self.gen.getrandbits(k) < 2**k)
-        self.assertEqual(self.gen.getrandbits(0), 0)
+            self.assertTrue(0 <= getrandbits(k) < 2**k)
+        self.assertEqual(getrandbits(0), 0)
 
         # Verify all bits active
-        getbits = self.gen.getrandbits
         for span in [1, 2, 3, 4, 31, 32, 32, 52, 53, 54, 119, 127, 128, 129]:
             all_bits = 2**span-1
             cum = 0
             cpl_cum = 0
             for i in range(100):
-                v = getbits(span)
+                v = getrandbits(span)
                 cum |= v
                 cpl_cum |= all_bits ^ v
             self.assertEqual(cum, all_bits)
             self.assertEqual(cpl_cum, all_bits)
 
         # Verify argument checking
-        self.assertRaises(TypeError, self.gen.getrandbits)
-        self.assertRaises(TypeError, self.gen.getrandbits, 1, 2)
-        self.assertRaises(ValueError, self.gen.getrandbits, -1)
-        self.assertRaises(TypeError, self.gen.getrandbits, 10.1)
-
-    def test_pickling(self):
-        for proto in range(pickle.HIGHEST_PROTOCOL + 1):
-            state = pickle.dumps(self.gen, proto)
-            origseq = [self.gen.random() for i in range(10)]
-            newgen = pickle.loads(state)
-            restoredseq = [newgen.random() for i in range(10)]
-            self.assertEqual(origseq, restoredseq)
-
-    def test_bug_1727780(self):
-        # verify that version-2-pickles can be loaded
-        # fine, whether they are created on 32-bit or 64-bit
-        # platforms, and that version-3-pickles load fine.
-        files = [("randv2_32.pck", 780),
-                 ("randv2_64.pck", 866),
-                 ("randv3.pck", 343)]
-        for file, value in files:
-            with open(support.findfile(file),"rb") as f:
-                r = pickle.load(f)
-            self.assertEqual(int(r.random()*1000), value)
-
-    def test_bug_9025(self):
-        # Had problem with an uneven distribution in int(n*random())
-        # Verify the fix by checking that distributions fall within expectations.
-        n = 100000
-        randrange = self.gen.randrange
-        k = sum(randrange(6755399441055744) % 3 == 2 for i in range(n))
-        self.assertTrue(0.30 < k/n < .37, (k/n))
-
-    def test_randbytes(self):
-        # Verify ranges
-        for n in range(1, 10):
-            data = self.gen.randbytes(n)
-            self.assertEqual(type(data), bytes)
-            self.assertEqual(len(data), n)
-
-        self.assertEqual(self.gen.randbytes(0), b'')
-
-        # Verify argument checking
-        self.assertRaises(TypeError, self.gen.randbytes)
-        self.assertRaises(TypeError, self.gen.randbytes, 1, 2)
-        self.assertRaises(ValueError, self.gen.randbytes, -1)
-        self.assertRaises(TypeError, self.gen.randbytes, 1.0)
-
-    def test_mu_sigma_default_args(self):
-        self.assertIsInstance(self.gen.normalvariate(), float)
-        self.assertIsInstance(self.gen.gauss(), float)
-
-
-try:
-    random.SystemRandom().random()
-except NotImplementedError:
-    SystemRandom_available = False
-else:
-    SystemRandom_available = True
-
-@unittest.skipUnless(SystemRandom_available, "random.SystemRandom not available")
-class SystemRandom_TestBasicOps(TestBasicOps, unittest.TestCase):
-    gen = random.SystemRandom()
-
-    def test_autoseed(self):
-        # Doesn't need to do anything except not fail
-        self.gen.seed()
-
-    def test_saverestore(self):
-        self.assertRaises(NotImplementedError, self.gen.getstate)
-        self.assertRaises(NotImplementedError, self.gen.setstate, None)
-
-    def test_seedargs(self):
-        # Doesn't need to do anything except not fail
-        self.gen.seed(100)
-
-    def test_gauss(self):
-        self.gen.gauss_next = None
-        self.gen.seed(100)
-        self.assertEqual(self.gen.gauss_next, None)
-
-    def test_pickling(self):
-        for proto in range(pickle.HIGHEST_PROTOCOL + 1):
-            self.assertRaises(NotImplementedError, pickle.dumps, self.gen, proto)
-
-    def test_53_bits_per_float(self):
-        # This should pass whenever a C double has 53 bit precision.
-        span = 2 ** 53
-        cum = 0
-        for i in range(100):
-            cum |= int(self.gen.random() * span)
-        self.assertEqual(cum, span-1)
+        self.assertRaises(TypeError, getrandbits)
+        self.assertRaises(TypeError, getrandbits, 1, 2)
+        self.assertRaises(ValueError, getrandbits, -1)
+        self.assertRaises(OverflowError, getrandbits, 1<<1000)
+        self.assertRaises(ValueError, getrandbits, -1<<1000)
+        self.assertRaises(TypeError, getrandbits, 10.1)
 
     def test_bigrand(self):
         # The randrange routine should build-up the required number of bits
@@ -546,6 +492,10 @@ def test_randrange_step(self):
             randrange(1000, step=100)
         with self.assertRaises(TypeError):
             randrange(1000, None, step=100)
+        with self.assertRaises(TypeError):
+            randrange(1000, step=MyIndex(1))
+        with self.assertRaises(TypeError):
+            randrange(1000, None, step=MyIndex(1))
 
     def test_randbelow_logic(self, _log=log, int=int):
         # check bitcount transition points:  2**i and 2**(i+1)-1
@@ -568,6 +518,116 @@ def test_randbelow_logic(self, _log=log, int=int):
             self.assertEqual(k, numbits)        # note the stronger assertion
             self.assertTrue(2**k > n > 2**(k-1))   # note the stronger assertion
 
+    def test_randrange_index(self):
+        randrange = self.gen.randrange
+        self.assertIn(randrange(MyIndex(5)), range(5))
+        self.assertIn(randrange(MyIndex(2), MyIndex(7)), range(2, 7))
+        self.assertIn(randrange(MyIndex(5), MyIndex(15), MyIndex(2)), range(5, 15, 2))
+
+    def test_randint(self):
+        randint = self.gen.randint
+        self.assertIn(randint(2, 5), (2, 3, 4, 5))
+        self.assertEqual(randint(2, 2), 2)
+        self.assertIn(randint(MyIndex(2), MyIndex(5)), (2, 3, 4, 5))
+        self.assertEqual(randint(MyIndex(2), MyIndex(2)), 2)
+
+        self.assertRaises(ValueError, randint, 5, 2)
+        self.assertRaises(TypeError, randint)
+        self.assertRaises(TypeError, randint, 2)
+        self.assertRaises(TypeError, randint, 2, 5, 1)
+        self.assertRaises(TypeError, randint, 2.0, 5)
+        self.assertRaises(TypeError, randint, 2, 5.0)
+
+    def test_pickling(self):
+        for proto in range(pickle.HIGHEST_PROTOCOL + 1):
+            state = pickle.dumps(self.gen, proto)
+            origseq = [self.gen.random() for i in range(10)]
+            newgen = pickle.loads(state)
+            restoredseq = [newgen.random() for i in range(10)]
+            self.assertEqual(origseq, restoredseq)
+
+    def test_bug_1727780(self):
+        # verify that version-2-pickles can be loaded
+        # fine, whether they are created on 32-bit or 64-bit
+        # platforms, and that version-3-pickles load fine.
+        files = [("randv2_32.pck", 780),
+                 ("randv2_64.pck", 866),
+                 ("randv3.pck", 343)]
+        for file, value in files:
+            with open(support.findfile(file),"rb") as f:
+                r = pickle.load(f)
+            self.assertEqual(int(r.random()*1000), value)
+
+    def test_bug_9025(self):
+        # Had problem with an uneven distribution in int(n*random())
+        # Verify the fix by checking that distributions fall within expectations.
+        n = 100000
+        randrange = self.gen.randrange
+        k = sum(randrange(6755399441055744) % 3 == 2 for i in range(n))
+        self.assertTrue(0.30 < k/n < .37, (k/n))
+
+    def test_randrange_bug_1590891(self):
+        start = 1000000000000
+        stop = -100000000000000000000
+        step = -200
+        x = self.gen.randrange(start, stop, step)
+        self.assertTrue(stop < x <= start)
+        self.assertEqual((x+stop)%step, 0)
+
+    def test_randbytes(self):
+        # Verify ranges
+        for n in range(1, 10):
+            data = self.gen.randbytes(n)
+            self.assertEqual(type(data), bytes)
+            self.assertEqual(len(data), n)
+
+        self.assertEqual(self.gen.randbytes(0), b'')
+
+        # Verify argument checking
+        self.assertRaises(TypeError, self.gen.randbytes)
+        self.assertRaises(TypeError, self.gen.randbytes, 1, 2)
+        self.assertRaises(ValueError, self.gen.randbytes, -1)
+        self.assertRaises(OverflowError, self.gen.randbytes, 1<<1000)
+        self.assertRaises((ValueError, OverflowError), self.gen.randbytes, -1<<1000)
+        self.assertRaises(TypeError, self.gen.randbytes, 1.0)
+
+    def test_mu_sigma_default_args(self):
+        self.assertIsInstance(self.gen.normalvariate(), float)
+        self.assertIsInstance(self.gen.gauss(), float)
+
+
+try:
+    random.SystemRandom().random()
+except NotImplementedError:
+    SystemRandom_available = False
+else:
+    SystemRandom_available = True
+
+@unittest.skipUnless(SystemRandom_available, "random.SystemRandom not available")
+class SystemRandom_TestBasicOps(TestBasicOps, unittest.TestCase):
+    gen = random.SystemRandom()
+
+    def test_autoseed(self):
+        # Doesn't need to do anything except not fail
+        self.gen.seed()
+
+    def test_saverestore(self):
+        self.assertRaises(NotImplementedError, self.gen.getstate)
+        self.assertRaises(NotImplementedError, self.gen.setstate, None)
+
+    def test_seedargs(self):
+        # Doesn't need to do anything except not fail
+        self.gen.seed(100)
+
+    def test_gauss(self):
+        self.gen.gauss_next = None
+        self.gen.seed(100)
+        self.assertEqual(self.gen.gauss_next, None)
+
+    def test_pickling(self):
+        for proto in range(pickle.HIGHEST_PROTOCOL + 1):
+            self.assertRaises(NotImplementedError, pickle.dumps, self.gen, proto)
+
 
 class TestRawMersenneTwister(unittest.TestCase):
     @test.support.cpython_only
@@ -753,38 +813,6 @@ def test_long_seed(self):
         seed = (1 << (10000 * 8)) - 1  # about 10K bytes
         self.gen.seed(seed)
 
-    def test_53_bits_per_float(self):
-        # This should pass whenever a C double has 53 bit precision.
-        span = 2 ** 53
-        cum = 0
-        for i in range(100):
-            cum |= int(self.gen.random() * span)
-        self.assertEqual(cum, span-1)
-
-    def test_bigrand(self):
-        # The randrange routine should build-up the required number of bits
-        # in stages so that all bit positions are active.
-        span = 2 ** 500
-        cum = 0
-        for i in range(100):
-            r = self.gen.randrange(span)
-            self.assertTrue(0 <= r < span)
-            cum |= r
-        self.assertEqual(cum, span-1)
-
-    def test_bigrand_ranges(self):
-        for i in [40,80, 160, 200, 211, 250, 375, 512, 550]:
-            start = self.gen.randrange(2 ** (i-2))
-            stop = self.gen.randrange(2 ** i)
-            if stop <= start:
-                continue
-            self.assertTrue(start <= self.gen.randrange(start, stop) < stop)
-
-    def test_rangelimits(self):
-        for start, stop in [(-2,0), (-(2**60)-2,-(2**60)), (2**60,2**60+2)]:
-            self.assertEqual(set(range(start,stop)),
-                set([self.gen.randrange(start,stop) for i in range(100)]))
-
     def test_getrandbits(self):
         super().test_getrandbits()
 
@@ -792,6 +820,25 @@ def test_getrandbits(self):
         self.gen.seed(1234567)
         self.assertEqual(self.gen.getrandbits(100),
                          97904845777343510404718956115)
+        self.gen.seed(1234567)
+        self.assertEqual(self.gen.getrandbits(MyIndex(100)),
+                         97904845777343510404718956115)
+
+    def test_getrandbits_2G_bits(self):
+        size = 2**31
+        self.gen.seed(1234567)
+        x = self.gen.getrandbits(size)
+        self.assertEqual(x.bit_length(), size)
+        self.assertEqual(x & (2**100-1), 890186470919986886340158459475)
+        self.assertEqual(x >> (size-100), 1226514312032729439655761284440)
+
+    @support.bigmemtest(size=2**32, memuse=1/8+2/15, dry_run=False)
+    def test_getrandbits_4G_bits(self, size):
+        self.gen.seed(1234568)
+        x = self.gen.getrandbits(size)
+        self.assertEqual(x.bit_length(), size)
+        self.assertEqual(x & (2**100-1), 287241425661104632871036099814)
+        self.assertEqual(x >> (size-100), 739728759900339699429794460738)
 
     def test_randrange_uses_getrandbits(self):
         # Verify use of getrandbits by randrange
@@ -803,27 +850,6 @@ def test_randrange_uses_getrandbits(self):
         self.assertEqual(self.gen.randrange(2**99),
                          97904845777343510404718956115)
 
-    def test_randbelow_logic(self, _log=log, int=int):
-        # check bitcount transition points:  2**i and 2**(i+1)-1
-        # show that: k = int(1.001 + _log(n, 2))
-        # is equal to or one greater than the number of bits in n
-        for i in range(1, 1000):
-            n = 1 << i # check an exact power of two
-            numbits = i+1
-            k = int(1.00001 + _log(n, 2))
-            self.assertEqual(k, numbits)
-            self.assertEqual(n, 2**(k-1))
-
-            n += n - 1      # check 1 below the next power of two
-            k = int(1.00001 + _log(n, 2))
-            self.assertIn(k, [numbits, numbits+1])
-            self.assertTrue(2**k > n > 2**(k-2))
-
-            n -= n >> 15     # check a little farther below the next power of two
-            k = int(1.00001 + _log(n, 2))
-            self.assertEqual(k, numbits)        # note the stronger assertion
-            self.assertTrue(2**k > n > 2**(k-1))   # note the stronger assertion
-
     def test_randbelow_without_getrandbits(self):
         # Random._randbelow() can only use random() when the built-in one
         # has been overridden but no new getrandbits() method was supplied.
@@ -858,14 +884,6 @@ def test_randbelow_without_getrandbits(self):
             self.gen._randbelow_without_getrandbits(n, maxsize=maxsize)
             self.assertEqual(random_mock.call_count, 2)
 
-    def test_randrange_bug_1590891(self):
-        start = 1000000000000
-        stop = -100000000000000000000
-        step = -200
-        x = self.gen.randrange(start, stop, step)
-        self.assertTrue(stop < x <= start)
-        self.assertEqual((x+stop)%step, 0)
-
     def test_choices_algorithms(self):
         # The various ways of specifying weights should produce the same results
         choices = self.gen.choices
@@ -949,6 +967,14 @@ def test_randbytes_getrandbits(self):
             self.assertEqual(self.gen.randbytes(n),
                              gen2.getrandbits(n * 8).to_bytes(n, 'little'))
 
+    @support.bigmemtest(size=2**29, memuse=1+16/15, dry_run=False)
+    def test_randbytes_256M(self, size):
+        self.gen.seed(2849427419)
+        x = self.gen.randbytes(size)
+        self.assertEqual(len(x), size)
+        self.assertEqual(x[:12].hex(), 'f6fd9ae63855ab91ea238b4f')
+        self.assertEqual(x[-12:].hex(), '0e7af69a84ee99bf4a11becc')
+
     def test_sample_counts_equivalence(self):
         # Test the documented strong equivalence to a sample with repeated elements.
         # We run this test on random.Random() which makes deterministic selections
@@ -1081,6 +1107,7 @@ def test_binomialvariate(self):
             B(n=1, p=-0.5)                     # Negative p
         with self.assertRaises(ValueError):
             B(n=1, p=1.5)                      # p > 1.0
+        self.assertEqual(B(0, 0.5), 0)         # n == 0
         self.assertEqual(B(10, 0.0), 0)        # p == 0.0
         self.assertEqual(B(10, 1.0), 10)       # p == 1.0
         self.assertTrue(B(1, 0.3) in {0, 1})   # n == 1 fast path
@@ -1088,6 +1115,9 @@ def test_binomialvariate(self):
         self.assertTrue(B(1, 0.0) in {0})      # n == 1 fast path
         self.assertTrue(B(1, 1.0) in {1})      # n == 1 fast path
 
+        # BG method very small p
+        self.assertEqual(B(5, 1e-18), 0)
+
         # BG method p <= 0.5 and n*p=1.25
         self.assertTrue(B(5, 0.25) in set(range(6)))
 
@@ -1266,6 +1296,13 @@ def test_betavariate_return_zero(self, gammavariate_mock):
 
 
 class TestRandomSubclassing(unittest.TestCase):
+    def test_random_subclass_with_kwargs(self):
+        # SF bug #1486663 -- this used to erroneously raise a TypeError
+        class Subclass(random.Random):
+            def __init__(self, newarg=None):
+                random.Random.__init__(self)
+        Subclass(newarg=1)
+
     def test_subclasses_overriding_methods(self):
         # Subclasses with an overridden random, but only the original
         # getrandbits method should not rely on getrandbits in for randrange,
@@ -1386,5 +1423,48 @@ def test_after_fork(self):
             support.wait_process(pid, exitcode=0)
 
 
+class CommandLineTest(unittest.TestCase):
+    @support.force_not_colorized
+    def test_parse_args(self):
+        args, help_text = random._parse_args(shlex.split("--choice a b c"))
+        self.assertEqual(args.choice, ["a", "b", "c"])
+        self.assertStartsWith(help_text, "usage: ")
+
+        args, help_text = random._parse_args(shlex.split("--integer 5"))
+        self.assertEqual(args.integer, 5)
+        self.assertStartsWith(help_text, "usage: ")
+
+        args, help_text = random._parse_args(shlex.split("--float 2.5"))
+        self.assertEqual(args.float, 2.5)
+        self.assertStartsWith(help_text, "usage: ")
+
+        args, help_text = random._parse_args(shlex.split("a b c"))
+        self.assertEqual(args.input, ["a", "b", "c"])
+        self.assertStartsWith(help_text, "usage: ")
+
+        args, help_text = random._parse_args(shlex.split("5"))
+        self.assertEqual(args.input, ["5"])
+        self.assertStartsWith(help_text, "usage: ")
+
+        args, help_text = random._parse_args(shlex.split("2.5"))
+        self.assertEqual(args.input, ["2.5"])
+        self.assertStartsWith(help_text, "usage: ")
+
+    def test_main(self):
+        for command, expected in [
+            ("--choice a b c", "b"),
+            ('"a b c"', "b"),
+            ("a b c", "b"),
+            ("--choice 'a a' 'b b' 'c c'", "b b"),
+            ("'a a' 'b b' 'c c'", "b b"),
+            ("--integer 5", 4),
+            ("5", 4),
+            ("--float 2.5", 2.1110546288126204),
+            ("2.5", 2.1110546288126204),
+        ]:
+            random.seed(0)
+            self.assertEqual(random.main(shlex.split(command)), expected)
+
+
 if __name__ == "__main__":
     unittest.main()
diff --git a/Lib/test/test_re.py b/Lib/test/test_re.py
index 8b935dc7f12..df132aa787d 100644
--- a/Lib/test/test_re.py
+++ b/Lib/test/test_re.py
@@ -851,7 +851,6 @@ def test_other_escapes(self):
             with self.subTest(c):
                 self.assertRaises(re.PatternError, re.compile, '[\\%c]' % c)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_named_unicode_escapes(self):
         # test individual Unicode named escapes
         self.assertTrue(re.match(r'\N{LESS-THAN SIGN}', '<'))
@@ -2107,7 +2106,6 @@ def test_issue17998(self):
                 self.assertEqual(re.compile(pattern, re.S).findall(b'xyz'),
                                  [b'xyz'], msg=pattern)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_match_repr(self):
         for string in '[abracadabra]', S('[abracadabra]'):
             m = re.search(r'(.+)(.*?)\1', string)
@@ -2539,7 +2537,6 @@ def test_possessive_quantifiers(self):
         self.assertIsNone(re.match("^x{}+$", "xxx"))
         self.assertTrue(re.match("^x{}+$", "x{}"))
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_fullmatch_possessive_quantifiers(self):
         self.assertTrue(re.fullmatch(r'a++', 'a'))
         self.assertTrue(re.fullmatch(r'a*+', 'a'))
@@ -2592,7 +2589,6 @@ def test_atomic_grouping(self):
         self.assertIsNone(re.match(r'(?>x)++x', 'xxx'))
         self.assertIsNone(re.match(r'(?>x++)x', 'xxx'))
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_fullmatch_atomic_grouping(self):
         self.assertTrue(re.fullmatch(r'(?>a+)', 'a'))
         self.assertTrue(re.fullmatch(r'(?>a*)', 'a'))
@@ -2631,7 +2627,6 @@ 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'])
 
-    @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"))
diff --git a/Lib/test/test_regrtest.py b/Lib/test/test_regrtest.py
index ee1d479b884..82939108b12 100644
--- a/Lib/test/test_regrtest.py
+++ b/Lib/test/test_regrtest.py
@@ -1195,7 +1195,7 @@ def test_slowest_interrupted(self):
                 regex = ('10 slowest tests:\n')
                 self.check_line(output, regex)
 
-    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AssertionError: Regex didn't match: '^lines +cov% +module +\\(path\\)\\n(?: *[0-9]+ *[0-9]{1,2}\\.[0-9]% *[^ ]+ +\\([^)]+\\)+)+' not found in 'Warning: collecting coverage without -j is imprecise. Configure --with-pydebug and run -m test -T -j for best results.\nUsing random seed: 2780369491\n0:00:00 Run 1 test sequentially in a single process\n0:00:00 [1/1] test_regrtest_coverage\n0:00:00 [1/1] test_regrtest_coverage passed\n\n== Tests result: SUCCESS ==\n\n1 test OK.\n\nTotal duration: 102 ms\nTotal tests: run=1\nTotal test files: run=1/1\nResult: SUCCESS\n'
     def test_coverage(self):
         # test --coverage
         test = self.create_test('coverage')
@@ -1870,7 +1870,7 @@ def test_sleep(self):
         self.assertRegex(output,
                          re.compile('%s timed out' % testname, re.MULTILINE))
 
-    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; test_unraisable_exc (test_regrtest_noop39.Tests.test_unraisable_exc) ... ok
     def test_unraisable_exc(self):
         # --fail-env-changed must catch unraisable exception.
         # The exception must be displayed even if sys.stderr is redirected.
@@ -2324,7 +2324,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
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; TypeError: int() argument must be a string, a bytes-like object or a real number, not 'NoneType'
     def test_xml(self):
         code = textwrap.dedent(r"""
             import unittest
@@ -2362,7 +2362,6 @@ 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
diff --git a/Lib/test/test_reprlib.py b/Lib/test/test_reprlib.py
index 173b49e83d1..3396b54cc9f 100644
--- a/Lib/test/test_reprlib.py
+++ b/Lib/test/test_reprlib.py
@@ -207,7 +207,6 @@ def test_lambda(self):
         self.assertStartsWith(r, "<function ReprTests.test_lambda.<locals>.<lambda")
         # XXX anonymous functions?  see func_repr
 
-    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_builtin_function(self):
         eq = self.assertEqual
         # Functions
@@ -846,7 +845,6 @@ def __repr__(self):
 
         self.assertIs(X.f, X.__repr__.__wrapped__)
 
-    @unittest.expectedFailure  # TODO: RUSTPYTHON; AttributeError: 'TypeVar' object has no attribute '__name__'
     def test__type_params__(self):
         class My:
             @recursive_repr()
diff --git a/Lib/test/test_richcmp.py b/Lib/test/test_richcmp.py
index 5f449cdc05c..b967c7623c5 100644
--- a/Lib/test/test_richcmp.py
+++ b/Lib/test/test_richcmp.py
@@ -28,9 +28,6 @@ def __gt__(self, other):
     def __ge__(self, other):
         return self.x >= other
 
-    def __cmp__(self, other):
-        raise support.TestFailed("Number.__cmp__() should not be called")
-
     def __repr__(self):
         return "Number(%r)" % (self.x, )
 
@@ -53,9 +50,6 @@ def __setitem__(self, i, v):
     def __bool__(self):
         raise TypeError("Vectors cannot be used in Boolean contexts")
 
-    def __cmp__(self, other):
-        raise support.TestFailed("Vector.__cmp__() should not be called")
-
     def __repr__(self):
         return "Vector(%r)" % (self.data, )
 
diff --git a/Lib/test/test_runpy.py b/Lib/test/test_runpy.py
index c1e255e7af3..cf7fd581ec3 100644
--- a/Lib/test/test_runpy.py
+++ b/Lib/test/test_runpy.py
@@ -680,7 +680,6 @@ def test_basic_script_no_suffix(self):
             self._check_script(script_name, "<run_path>", script_name,
                                script_name, expect_spec=False)
 
-    @unittest.skipIf(sys.platform == 'win32', "TODO: RUSTPYTHON; weird panic in lz4-flex")
     def test_script_compiled(self):
         with temp_dir() as script_dir:
             mod_name = 'script'
@@ -753,7 +752,6 @@ def test_main_recursion_error(self):
             with infinite_recursion(25):
                 self.assertRaises(RecursionError, run_path, zip_name)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON; detect encoding comments in files
     def test_encoding(self):
         with temp_dir() as script_dir:
             filename = os.path.join(script_dir, 'script.py')
@@ -798,7 +796,7 @@ def assertSigInt(self, cmd, *args, **kwargs):
         # Use -E to ignore PYTHONSAFEPATH
         cmd = [sys.executable, '-E', *cmd]
         proc = subprocess.run(cmd, *args, **kwargs, text=True, stderr=subprocess.PIPE)
-        self.assertTrue(proc.stderr.endswith("\nKeyboardInterrupt\n"), proc.stderr)
+        self.assertEndsWith(proc.stderr, "\nKeyboardInterrupt\n")
         self.assertEqual(proc.returncode, self.EXPECTED_CODE)
 
     def test_pymain_run_file(self):
diff --git a/Lib/test/test_sax.py b/Lib/test/test_sax.py
new file mode 100644
index 00000000000..faaf4dd95b6
--- /dev/null
+++ b/Lib/test/test_sax.py
@@ -0,0 +1,1616 @@
+# regression test for SAX 2.0
+
+from xml.sax import make_parser, ContentHandler, \
+                    SAXException, SAXReaderNotAvailable, SAXParseException
+import unittest
+from unittest import mock
+try:
+    make_parser()
+except SAXReaderNotAvailable:
+    # don't try to test this module if we cannot create a parser
+    raise unittest.SkipTest("no XML parsers available")
+from xml.sax.saxutils import XMLGenerator, escape, unescape, quoteattr, \
+                             XMLFilterBase, prepare_input_source
+from xml.sax.expatreader import create_parser
+from xml.sax.handler import (feature_namespaces, feature_external_ges,
+                             LexicalHandler)
+from xml.sax.xmlreader import InputSource, AttributesImpl, AttributesNSImpl
+from xml import sax
+from io import BytesIO, StringIO
+import codecs
+import os.path
+import pyexpat
+import shutil
+import sys
+from urllib.error import URLError
+import urllib.request
+from test.support import os_helper
+from test.support import findfile, check__all__
+from test.support.os_helper import FakePath, TESTFN
+
+
+TEST_XMLFILE = findfile("test.xml", subdir="xmltestdata")
+TEST_XMLFILE_OUT = findfile("test.xml.out", subdir="xmltestdata")
+try:
+    TEST_XMLFILE.encode("utf-8")
+    TEST_XMLFILE_OUT.encode("utf-8")
+except UnicodeEncodeError:
+    raise unittest.SkipTest("filename is not encodable to utf8")
+
+supports_nonascii_filenames = True
+if not os.path.supports_unicode_filenames:
+    try:
+        os_helper.TESTFN_UNICODE.encode(sys.getfilesystemencoding())
+    except (UnicodeError, TypeError):
+        # Either the file system encoding is None, or the file name
+        # cannot be encoded in the file system encoding.
+        supports_nonascii_filenames = False
+requires_nonascii_filenames = unittest.skipUnless(
+        supports_nonascii_filenames,
+        'Requires non-ascii filenames support')
+
+ns_uri = "http://www.python.org/xml-ns/saxtest/"
+
+class XmlTestBase(unittest.TestCase):
+    def verify_empty_attrs(self, attrs):
+        self.assertRaises(KeyError, attrs.getValue, "attr")
+        self.assertRaises(KeyError, attrs.getValueByQName, "attr")
+        self.assertRaises(KeyError, attrs.getNameByQName, "attr")
+        self.assertRaises(KeyError, attrs.getQNameByName, "attr")
+        self.assertRaises(KeyError, attrs.__getitem__, "attr")
+        self.assertEqual(attrs.getLength(), 0)
+        self.assertEqual(attrs.getNames(), [])
+        self.assertEqual(attrs.getQNames(), [])
+        self.assertEqual(len(attrs), 0)
+        self.assertNotIn("attr", attrs)
+        self.assertEqual(list(attrs.keys()), [])
+        self.assertEqual(attrs.get("attrs"), None)
+        self.assertEqual(attrs.get("attrs", 25), 25)
+        self.assertEqual(list(attrs.items()), [])
+        self.assertEqual(list(attrs.values()), [])
+
+    def verify_empty_nsattrs(self, attrs):
+        self.assertRaises(KeyError, attrs.getValue, (ns_uri, "attr"))
+        self.assertRaises(KeyError, attrs.getValueByQName, "ns:attr")
+        self.assertRaises(KeyError, attrs.getNameByQName, "ns:attr")
+        self.assertRaises(KeyError, attrs.getQNameByName, (ns_uri, "attr"))
+        self.assertRaises(KeyError, attrs.__getitem__, (ns_uri, "attr"))
+        self.assertEqual(attrs.getLength(), 0)
+        self.assertEqual(attrs.getNames(), [])
+        self.assertEqual(attrs.getQNames(), [])
+        self.assertEqual(len(attrs), 0)
+        self.assertNotIn((ns_uri, "attr"), attrs)
+        self.assertEqual(list(attrs.keys()), [])
+        self.assertEqual(attrs.get((ns_uri, "attr")), None)
+        self.assertEqual(attrs.get((ns_uri, "attr"), 25), 25)
+        self.assertEqual(list(attrs.items()), [])
+        self.assertEqual(list(attrs.values()), [])
+
+    def verify_attrs_wattr(self, attrs):
+        self.assertEqual(attrs.getLength(), 1)
+        self.assertEqual(attrs.getNames(), ["attr"])
+        self.assertEqual(attrs.getQNames(), ["attr"])
+        self.assertEqual(len(attrs), 1)
+        self.assertIn("attr", attrs)
+        self.assertEqual(list(attrs.keys()), ["attr"])
+        self.assertEqual(attrs.get("attr"), "val")
+        self.assertEqual(attrs.get("attr", 25), "val")
+        self.assertEqual(list(attrs.items()), [("attr", "val")])
+        self.assertEqual(list(attrs.values()), ["val"])
+        self.assertEqual(attrs.getValue("attr"), "val")
+        self.assertEqual(attrs.getValueByQName("attr"), "val")
+        self.assertEqual(attrs.getNameByQName("attr"), "attr")
+        self.assertEqual(attrs["attr"], "val")
+        self.assertEqual(attrs.getQNameByName("attr"), "attr")
+
+
+def xml_str(doc, encoding=None):
+    if encoding is None:
+        return doc
+    return '<?xml version="1.0" encoding="%s"?>\n%s' % (encoding, doc)
+
+def xml_bytes(doc, encoding, decl_encoding=...):
+    if decl_encoding is ...:
+        decl_encoding = encoding
+    return xml_str(doc, decl_encoding).encode(encoding, 'xmlcharrefreplace')
+
+def make_xml_file(doc, encoding, decl_encoding=...):
+    if decl_encoding is ...:
+        decl_encoding = encoding
+    with open(TESTFN, 'w', encoding=encoding, errors='xmlcharrefreplace') as f:
+        f.write(xml_str(doc, decl_encoding))
+
+
+class ParseTest(unittest.TestCase):
+    data = '<money value="$\xa3\u20ac\U0001017b">$\xa3\u20ac\U0001017b</money>'
+
+    def tearDown(self):
+        os_helper.unlink(TESTFN)
+
+    def check_parse(self, f):
+        from xml.sax import parse
+        result = StringIO()
+        parse(f, XMLGenerator(result, 'utf-8'))
+        self.assertEqual(result.getvalue(), xml_str(self.data, 'utf-8'))
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AttributeError: 'xmlparser' object has no attribute 'SetParamEntityParsing'
+    def test_parse_text(self):
+        encodings = ('us-ascii', 'iso-8859-1', 'utf-8',
+                     'utf-16', 'utf-16le', 'utf-16be')
+        for encoding in encodings:
+            self.check_parse(StringIO(xml_str(self.data, encoding)))
+            make_xml_file(self.data, encoding)
+            with open(TESTFN, 'r', encoding=encoding) as f:
+                self.check_parse(f)
+            self.check_parse(StringIO(self.data))
+            make_xml_file(self.data, encoding, None)
+            with open(TESTFN, 'r', encoding=encoding) as f:
+                self.check_parse(f)
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AttributeError: 'xmlparser' object has no attribute 'SetParamEntityParsing'
+    def test_parse_bytes(self):
+        # UTF-8 is default encoding, US-ASCII is compatible with UTF-8,
+        # UTF-16 is autodetected
+        encodings = ('us-ascii', 'utf-8', 'utf-16', 'utf-16le', 'utf-16be')
+        for encoding in encodings:
+            self.check_parse(BytesIO(xml_bytes(self.data, encoding)))
+            make_xml_file(self.data, encoding)
+            self.check_parse(TESTFN)
+            with open(TESTFN, 'rb') as f:
+                self.check_parse(f)
+            self.check_parse(BytesIO(xml_bytes(self.data, encoding, None)))
+            make_xml_file(self.data, encoding, None)
+            self.check_parse(TESTFN)
+            with open(TESTFN, 'rb') as f:
+                self.check_parse(f)
+        # accept UTF-8 with BOM
+        self.check_parse(BytesIO(xml_bytes(self.data, 'utf-8-sig', 'utf-8')))
+        make_xml_file(self.data, 'utf-8-sig', 'utf-8')
+        self.check_parse(TESTFN)
+        with open(TESTFN, 'rb') as f:
+            self.check_parse(f)
+        self.check_parse(BytesIO(xml_bytes(self.data, 'utf-8-sig', None)))
+        make_xml_file(self.data, 'utf-8-sig', None)
+        self.check_parse(TESTFN)
+        with open(TESTFN, 'rb') as f:
+            self.check_parse(f)
+        # accept data with declared encoding
+        self.check_parse(BytesIO(xml_bytes(self.data, 'iso-8859-1')))
+        make_xml_file(self.data, 'iso-8859-1')
+        self.check_parse(TESTFN)
+        with open(TESTFN, 'rb') as f:
+            self.check_parse(f)
+        # fail on non-UTF-8 incompatible data without declared encoding
+        with self.assertRaises(SAXException):
+            self.check_parse(BytesIO(xml_bytes(self.data, 'iso-8859-1', None)))
+        make_xml_file(self.data, 'iso-8859-1', None)
+        with self.assertRaises(SAXException):
+            self.check_parse(TESTFN)
+        with open(TESTFN, 'rb') as f:
+            with self.assertRaises(SAXException):
+                self.check_parse(f)
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AttributeError: 'xmlparser' object has no attribute 'SetParamEntityParsing'
+    def test_parse_path_object(self):
+        make_xml_file(self.data, 'utf-8', None)
+        self.check_parse(FakePath(TESTFN))
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AttributeError: 'xmlparser' object has no attribute 'SetParamEntityParsing'
+    def test_parse_InputSource(self):
+        # accept data without declared but with explicitly specified encoding
+        make_xml_file(self.data, 'iso-8859-1', None)
+        with open(TESTFN, 'rb') as f:
+            input = InputSource()
+            input.setByteStream(f)
+            input.setEncoding('iso-8859-1')
+            self.check_parse(input)
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AttributeError: 'xmlparser' object has no attribute 'SetParamEntityParsing'
+    def test_parse_close_source(self):
+        builtin_open = open
+        fileobj = None
+
+        def mock_open(*args):
+            nonlocal fileobj
+            fileobj = builtin_open(*args)
+            return fileobj
+
+        with mock.patch('xml.sax.saxutils.open', side_effect=mock_open):
+            make_xml_file(self.data, 'iso-8859-1', None)
+            with self.assertRaises(SAXException):
+                self.check_parse(TESTFN)
+            self.assertTrue(fileobj.closed)
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AttributeError: 'xmlparser' object has no attribute 'SetParamEntityParsing'
+    def check_parseString(self, s):
+        from xml.sax import parseString
+        result = StringIO()
+        parseString(s, XMLGenerator(result, 'utf-8'))
+        self.assertEqual(result.getvalue(), xml_str(self.data, 'utf-8'))
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AttributeError: 'xmlparser' object has no attribute 'SetParamEntityParsing'
+    def test_parseString_text(self):
+        encodings = ('us-ascii', 'iso-8859-1', 'utf-8',
+                     'utf-16', 'utf-16le', 'utf-16be')
+        for encoding in encodings:
+            self.check_parseString(xml_str(self.data, encoding))
+        self.check_parseString(self.data)
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AttributeError: 'xmlparser' object has no attribute 'SetParamEntityParsing'
+    def test_parseString_bytes(self):
+        # UTF-8 is default encoding, US-ASCII is compatible with UTF-8,
+        # UTF-16 is autodetected
+        encodings = ('us-ascii', 'utf-8', 'utf-16', 'utf-16le', 'utf-16be')
+        for encoding in encodings:
+            self.check_parseString(xml_bytes(self.data, encoding))
+            self.check_parseString(xml_bytes(self.data, encoding, None))
+        # accept UTF-8 with BOM
+        self.check_parseString(xml_bytes(self.data, 'utf-8-sig', 'utf-8'))
+        self.check_parseString(xml_bytes(self.data, 'utf-8-sig', None))
+        # accept data with declared encoding
+        self.check_parseString(xml_bytes(self.data, 'iso-8859-1'))
+        # fail on non-UTF-8 incompatible data without declared encoding
+        with self.assertRaises(SAXException):
+            self.check_parseString(xml_bytes(self.data, 'iso-8859-1', None))
+
+class MakeParserTest(unittest.TestCase):
+    def test_make_parser2(self):
+        # Creating parsers several times in a row should succeed.
+        # Testing this because there have been failures of this kind
+        # before.
+        from xml.sax import make_parser
+        p = make_parser()
+        from xml.sax import make_parser
+        p = make_parser()
+        from xml.sax import make_parser
+        p = make_parser()
+        from xml.sax import make_parser
+        p = make_parser()
+        from xml.sax import make_parser
+        p = make_parser()
+        from xml.sax import make_parser
+        p = make_parser()
+
+    def test_make_parser3(self):
+        # Testing that make_parser can handle different types of
+        # iterables.
+        make_parser(['module'])
+        make_parser(('module', ))
+        make_parser({'module'})
+        make_parser(frozenset({'module'}))
+        make_parser({'module': None})
+        make_parser(iter(['module']))
+
+    def test_make_parser4(self):
+        # Testing that make_parser can handle empty iterables.
+        make_parser([])
+        make_parser(tuple())
+        make_parser(set())
+        make_parser(frozenset())
+        make_parser({})
+        make_parser(iter([]))
+
+    def test_make_parser5(self):
+        # Testing that make_parser can handle iterables with more than
+        # one item.
+        make_parser(['module1', 'module2'])
+        make_parser(('module1', 'module2'))
+        make_parser({'module1', 'module2'})
+        make_parser(frozenset({'module1', 'module2'}))
+        make_parser({'module1': None, 'module2': None})
+        make_parser(iter(['module1', 'module2']))
+
+# ===========================================================================
+#
+#   saxutils tests
+#
+# ===========================================================================
+
+class SaxutilsTest(unittest.TestCase):
+    # ===== escape
+    def test_escape_basic(self):
+        self.assertEqual(escape("Donald Duck & Co"), "Donald Duck &amp; Co")
+
+    def test_escape_all(self):
+        self.assertEqual(escape("<Donald Duck & Co>"),
+                         "&lt;Donald Duck &amp; Co&gt;")
+
+    def test_escape_extra(self):
+        self.assertEqual(escape("Hei på deg", {"å" : "&aring;"}),
+                         "Hei p&aring; deg")
+
+    # ===== unescape
+    def test_unescape_basic(self):
+        self.assertEqual(unescape("Donald Duck &amp; Co"), "Donald Duck & Co")
+
+    def test_unescape_all(self):
+        self.assertEqual(unescape("&lt;Donald Duck &amp; Co&gt;"),
+                         "<Donald Duck & Co>")
+
+    def test_unescape_extra(self):
+        self.assertEqual(unescape("Hei på deg", {"å" : "&aring;"}),
+                         "Hei p&aring; deg")
+
+    def test_unescape_amp_extra(self):
+        self.assertEqual(unescape("&amp;foo;", {"&foo;": "splat"}), "&foo;")
+
+    # ===== quoteattr
+    def test_quoteattr_basic(self):
+        self.assertEqual(quoteattr("Donald Duck & Co"),
+                         '"Donald Duck &amp; Co"')
+
+    def test_single_quoteattr(self):
+        self.assertEqual(quoteattr('Includes "double" quotes'),
+                         '\'Includes "double" quotes\'')
+
+    def test_double_quoteattr(self):
+        self.assertEqual(quoteattr("Includes 'single' quotes"),
+                         "\"Includes 'single' quotes\"")
+
+    def test_single_double_quoteattr(self):
+        self.assertEqual(quoteattr("Includes 'single' and \"double\" quotes"),
+                         "\"Includes 'single' and &quot;double&quot; quotes\"")
+
+    # ===== make_parser
+    def test_make_parser(self):
+        # Creating a parser should succeed - it should fall back
+        # to the expatreader
+        p = make_parser(['xml.parsers.no_such_parser'])
+
+
+class PrepareInputSourceTest(unittest.TestCase):
+
+    def setUp(self):
+        self.file = os_helper.TESTFN
+        with open(self.file, "w") as tmp:
+            tmp.write("This was read from a file.")
+
+    def tearDown(self):
+        os_helper.unlink(self.file)
+
+    def make_byte_stream(self):
+        return BytesIO(b"This is a byte stream.")
+
+    def make_character_stream(self):
+        return StringIO("This is a character stream.")
+
+    def checkContent(self, stream, content):
+        self.assertIsNotNone(stream)
+        self.assertEqual(stream.read(), content)
+        stream.close()
+
+
+    def test_character_stream(self):
+        # If the source is an InputSource with a character stream, use it.
+        src = InputSource(self.file)
+        src.setCharacterStream(self.make_character_stream())
+        prep = prepare_input_source(src)
+        self.assertIsNone(prep.getByteStream())
+        self.checkContent(prep.getCharacterStream(),
+                          "This is a character stream.")
+
+    def test_byte_stream(self):
+        # If the source is an InputSource that does not have a character
+        # stream but does have a byte stream, use the byte stream.
+        src = InputSource(self.file)
+        src.setByteStream(self.make_byte_stream())
+        prep = prepare_input_source(src)
+        self.assertIsNone(prep.getCharacterStream())
+        self.checkContent(prep.getByteStream(),
+                          b"This is a byte stream.")
+
+    def test_system_id(self):
+        # If the source is an InputSource that has neither a character
+        # stream nor a byte stream, open the system ID.
+        src = InputSource(self.file)
+        prep = prepare_input_source(src)
+        self.assertIsNone(prep.getCharacterStream())
+        self.checkContent(prep.getByteStream(),
+                          b"This was read from a file.")
+
+    def test_string(self):
+        # If the source is a string, use it as a system ID and open it.
+        prep = prepare_input_source(self.file)
+        self.assertIsNone(prep.getCharacterStream())
+        self.checkContent(prep.getByteStream(),
+                          b"This was read from a file.")
+
+    def test_path_objects(self):
+        # If the source is a Path object, use it as a system ID and open it.
+        prep = prepare_input_source(FakePath(self.file))
+        self.assertIsNone(prep.getCharacterStream())
+        self.checkContent(prep.getByteStream(),
+                          b"This was read from a file.")
+
+    def test_binary_file(self):
+        # If the source is a binary file-like object, use it as a byte
+        # stream.
+        prep = prepare_input_source(self.make_byte_stream())
+        self.assertIsNone(prep.getCharacterStream())
+        self.checkContent(prep.getByteStream(),
+                          b"This is a byte stream.")
+
+    def test_text_file(self):
+        # If the source is a text file-like object, use it as a character
+        # stream.
+        prep = prepare_input_source(self.make_character_stream())
+        self.assertIsNone(prep.getByteStream())
+        self.checkContent(prep.getCharacterStream(),
+                          "This is a character stream.")
+
+
+# ===== XMLGenerator
+
+class XmlgenTest:
+    def test_xmlgen_basic(self):
+        result = self.ioclass()
+        gen = XMLGenerator(result)
+        gen.startDocument()
+        gen.startElement("doc", {})
+        gen.endElement("doc")
+        gen.endDocument()
+
+        self.assertEqual(result.getvalue(), self.xml("<doc></doc>"))
+
+    def test_xmlgen_basic_empty(self):
+        result = self.ioclass()
+        gen = XMLGenerator(result, short_empty_elements=True)
+        gen.startDocument()
+        gen.startElement("doc", {})
+        gen.endElement("doc")
+        gen.endDocument()
+
+        self.assertEqual(result.getvalue(), self.xml("<doc/>"))
+
+    def test_xmlgen_content(self):
+        result = self.ioclass()
+        gen = XMLGenerator(result)
+
+        gen.startDocument()
+        gen.startElement("doc", {})
+        gen.characters("huhei")
+        gen.endElement("doc")
+        gen.endDocument()
+
+        self.assertEqual(result.getvalue(), self.xml("<doc>huhei</doc>"))
+
+    def test_xmlgen_content_empty(self):
+        result = self.ioclass()
+        gen = XMLGenerator(result, short_empty_elements=True)
+
+        gen.startDocument()
+        gen.startElement("doc", {})
+        gen.characters("huhei")
+        gen.endElement("doc")
+        gen.endDocument()
+
+        self.assertEqual(result.getvalue(), self.xml("<doc>huhei</doc>"))
+
+    def test_xmlgen_pi(self):
+        result = self.ioclass()
+        gen = XMLGenerator(result)
+
+        gen.startDocument()
+        gen.processingInstruction("test", "data")
+        gen.startElement("doc", {})
+        gen.endElement("doc")
+        gen.endDocument()
+
+        self.assertEqual(result.getvalue(),
+            self.xml("<?test data?><doc></doc>"))
+
+    def test_xmlgen_content_escape(self):
+        result = self.ioclass()
+        gen = XMLGenerator(result)
+
+        gen.startDocument()
+        gen.startElement("doc", {})
+        gen.characters("<huhei&")
+        gen.endElement("doc")
+        gen.endDocument()
+
+        self.assertEqual(result.getvalue(),
+            self.xml("<doc>&lt;huhei&amp;</doc>"))
+
+    def test_xmlgen_attr_escape(self):
+        result = self.ioclass()
+        gen = XMLGenerator(result)
+
+        gen.startDocument()
+        gen.startElement("doc", {"a": '"'})
+        gen.startElement("e", {"a": "'"})
+        gen.endElement("e")
+        gen.startElement("e", {"a": "'\""})
+        gen.endElement("e")
+        gen.startElement("e", {"a": "\n\r\t"})
+        gen.endElement("e")
+        gen.endElement("doc")
+        gen.endDocument()
+
+        self.assertEqual(result.getvalue(), self.xml(
+            "<doc a='\"'><e a=\"'\"></e>"
+            "<e a=\"'&quot;\"></e>"
+            "<e a=\"&#10;&#13;&#9;\"></e></doc>"))
+
+    def test_xmlgen_encoding(self):
+        encodings = ('iso-8859-15', 'utf-8', 'utf-8-sig',
+                     'utf-16', 'utf-16be', 'utf-16le',
+                     'utf-32', 'utf-32be', 'utf-32le')
+        for encoding in encodings:
+            result = self.ioclass()
+            gen = XMLGenerator(result, encoding=encoding)
+
+            gen.startDocument()
+            gen.startElement("doc", {"a": '\u20ac'})
+            gen.characters("\u20ac")
+            gen.endElement("doc")
+            gen.endDocument()
+
+            self.assertEqual(result.getvalue(),
+                self.xml('<doc a="\u20ac">\u20ac</doc>', encoding=encoding))
+
+    def test_xmlgen_unencodable(self):
+        result = self.ioclass()
+        gen = XMLGenerator(result, encoding='ascii')
+
+        gen.startDocument()
+        gen.startElement("doc", {"a": '\u20ac'})
+        gen.characters("\u20ac")
+        gen.endElement("doc")
+        gen.endDocument()
+
+        self.assertEqual(result.getvalue(),
+            self.xml('<doc a="&#8364;">&#8364;</doc>', encoding='ascii'))
+
+    def test_xmlgen_ignorable(self):
+        result = self.ioclass()
+        gen = XMLGenerator(result)
+
+        gen.startDocument()
+        gen.startElement("doc", {})
+        gen.ignorableWhitespace(" ")
+        gen.endElement("doc")
+        gen.endDocument()
+
+        self.assertEqual(result.getvalue(), self.xml("<doc> </doc>"))
+
+    def test_xmlgen_ignorable_empty(self):
+        result = self.ioclass()
+        gen = XMLGenerator(result, short_empty_elements=True)
+
+        gen.startDocument()
+        gen.startElement("doc", {})
+        gen.ignorableWhitespace(" ")
+        gen.endElement("doc")
+        gen.endDocument()
+
+        self.assertEqual(result.getvalue(), self.xml("<doc> </doc>"))
+
+    def test_xmlgen_encoding_bytes(self):
+        encodings = ('iso-8859-15', 'utf-8', 'utf-8-sig',
+                     'utf-16', 'utf-16be', 'utf-16le',
+                     'utf-32', 'utf-32be', 'utf-32le')
+        for encoding in encodings:
+            result = self.ioclass()
+            gen = XMLGenerator(result, encoding=encoding)
+
+            gen.startDocument()
+            gen.startElement("doc", {"a": '\u20ac'})
+            gen.characters("\u20ac".encode(encoding))
+            gen.ignorableWhitespace(" ".encode(encoding))
+            gen.endElement("doc")
+            gen.endDocument()
+
+            self.assertEqual(result.getvalue(),
+                self.xml('<doc a="\u20ac">\u20ac </doc>', encoding=encoding))
+
+    def test_xmlgen_ns(self):
+        result = self.ioclass()
+        gen = XMLGenerator(result)
+
+        gen.startDocument()
+        gen.startPrefixMapping("ns1", ns_uri)
+        gen.startElementNS((ns_uri, "doc"), "ns1:doc", {})
+        # add an unqualified name
+        gen.startElementNS((None, "udoc"), None, {})
+        gen.endElementNS((None, "udoc"), None)
+        gen.endElementNS((ns_uri, "doc"), "ns1:doc")
+        gen.endPrefixMapping("ns1")
+        gen.endDocument()
+
+        self.assertEqual(result.getvalue(), self.xml(
+           '<ns1:doc xmlns:ns1="%s"><udoc></udoc></ns1:doc>' %
+                                         ns_uri))
+
+    def test_xmlgen_ns_empty(self):
+        result = self.ioclass()
+        gen = XMLGenerator(result, short_empty_elements=True)
+
+        gen.startDocument()
+        gen.startPrefixMapping("ns1", ns_uri)
+        gen.startElementNS((ns_uri, "doc"), "ns1:doc", {})
+        # add an unqualified name
+        gen.startElementNS((None, "udoc"), None, {})
+        gen.endElementNS((None, "udoc"), None)
+        gen.endElementNS((ns_uri, "doc"), "ns1:doc")
+        gen.endPrefixMapping("ns1")
+        gen.endDocument()
+
+        self.assertEqual(result.getvalue(), self.xml(
+           '<ns1:doc xmlns:ns1="%s"><udoc/></ns1:doc>' %
+                                         ns_uri))
+
+    def test_1463026_1(self):
+        result = self.ioclass()
+        gen = XMLGenerator(result)
+
+        gen.startDocument()
+        gen.startElementNS((None, 'a'), 'a', {(None, 'b'):'c'})
+        gen.endElementNS((None, 'a'), 'a')
+        gen.endDocument()
+
+        self.assertEqual(result.getvalue(), self.xml('<a b="c"></a>'))
+
+    def test_1463026_1_empty(self):
+        result = self.ioclass()
+        gen = XMLGenerator(result, short_empty_elements=True)
+
+        gen.startDocument()
+        gen.startElementNS((None, 'a'), 'a', {(None, 'b'):'c'})
+        gen.endElementNS((None, 'a'), 'a')
+        gen.endDocument()
+
+        self.assertEqual(result.getvalue(), self.xml('<a b="c"/>'))
+
+    def test_1463026_2(self):
+        result = self.ioclass()
+        gen = XMLGenerator(result)
+
+        gen.startDocument()
+        gen.startPrefixMapping(None, 'qux')
+        gen.startElementNS(('qux', 'a'), 'a', {})
+        gen.endElementNS(('qux', 'a'), 'a')
+        gen.endPrefixMapping(None)
+        gen.endDocument()
+
+        self.assertEqual(result.getvalue(), self.xml('<a xmlns="qux"></a>'))
+
+    def test_1463026_2_empty(self):
+        result = self.ioclass()
+        gen = XMLGenerator(result, short_empty_elements=True)
+
+        gen.startDocument()
+        gen.startPrefixMapping(None, 'qux')
+        gen.startElementNS(('qux', 'a'), 'a', {})
+        gen.endElementNS(('qux', 'a'), 'a')
+        gen.endPrefixMapping(None)
+        gen.endDocument()
+
+        self.assertEqual(result.getvalue(), self.xml('<a xmlns="qux"/>'))
+
+    def test_1463026_3(self):
+        result = self.ioclass()
+        gen = XMLGenerator(result)
+
+        gen.startDocument()
+        gen.startPrefixMapping('my', 'qux')
+        gen.startElementNS(('qux', 'a'), 'a', {(None, 'b'):'c'})
+        gen.endElementNS(('qux', 'a'), 'a')
+        gen.endPrefixMapping('my')
+        gen.endDocument()
+
+        self.assertEqual(result.getvalue(),
+            self.xml('<my:a xmlns:my="qux" b="c"></my:a>'))
+
+    def test_1463026_3_empty(self):
+        result = self.ioclass()
+        gen = XMLGenerator(result, short_empty_elements=True)
+
+        gen.startDocument()
+        gen.startPrefixMapping('my', 'qux')
+        gen.startElementNS(('qux', 'a'), 'a', {(None, 'b'):'c'})
+        gen.endElementNS(('qux', 'a'), 'a')
+        gen.endPrefixMapping('my')
+        gen.endDocument()
+
+        self.assertEqual(result.getvalue(),
+            self.xml('<my:a xmlns:my="qux" b="c"/>'))
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AttributeError: 'xmlparser' object has no attribute 'SetParamEntityParsing'
+    def test_5027_1(self):
+        # The xml prefix (as in xml:lang below) is reserved and bound by
+        # definition to http://www.w3.org/XML/1998/namespace.  XMLGenerator had
+        # a bug whereby a KeyError is raised because this namespace is missing
+        # from a dictionary.
+        #
+        # This test demonstrates the bug by parsing a document.
+        test_xml = StringIO(
+            '<?xml version="1.0"?>'
+            '<a:g1 xmlns:a="http://example.com/ns">'
+             '<a:g2 xml:lang="en">Hello</a:g2>'
+            '</a:g1>')
+
+        parser = make_parser()
+        parser.setFeature(feature_namespaces, True)
+        result = self.ioclass()
+        gen = XMLGenerator(result)
+        parser.setContentHandler(gen)
+        parser.parse(test_xml)
+
+        self.assertEqual(result.getvalue(),
+                         self.xml(
+                         '<a:g1 xmlns:a="http://example.com/ns">'
+                          '<a:g2 xml:lang="en">Hello</a:g2>'
+                         '</a:g1>'))
+
+    def test_5027_2(self):
+        # The xml prefix (as in xml:lang below) is reserved and bound by
+        # definition to http://www.w3.org/XML/1998/namespace.  XMLGenerator had
+        # a bug whereby a KeyError is raised because this namespace is missing
+        # from a dictionary.
+        #
+        # This test demonstrates the bug by direct manipulation of the
+        # XMLGenerator.
+        result = self.ioclass()
+        gen = XMLGenerator(result)
+
+        gen.startDocument()
+        gen.startPrefixMapping('a', 'http://example.com/ns')
+        gen.startElementNS(('http://example.com/ns', 'g1'), 'g1', {})
+        lang_attr = {('http://www.w3.org/XML/1998/namespace', 'lang'): 'en'}
+        gen.startElementNS(('http://example.com/ns', 'g2'), 'g2', lang_attr)
+        gen.characters('Hello')
+        gen.endElementNS(('http://example.com/ns', 'g2'), 'g2')
+        gen.endElementNS(('http://example.com/ns', 'g1'), 'g1')
+        gen.endPrefixMapping('a')
+        gen.endDocument()
+
+        self.assertEqual(result.getvalue(),
+                         self.xml(
+                         '<a:g1 xmlns:a="http://example.com/ns">'
+                          '<a:g2 xml:lang="en">Hello</a:g2>'
+                         '</a:g1>'))
+
+    def test_no_close_file(self):
+        result = self.ioclass()
+        def func(out):
+            gen = XMLGenerator(out)
+            gen.startDocument()
+            gen.startElement("doc", {})
+        func(result)
+        self.assertFalse(result.closed)
+
+    def test_xmlgen_fragment(self):
+        result = self.ioclass()
+        gen = XMLGenerator(result)
+
+        # Don't call gen.startDocument()
+        gen.startElement("foo", {"a": "1.0"})
+        gen.characters("Hello")
+        gen.endElement("foo")
+        gen.startElement("bar", {"b": "2.0"})
+        gen.endElement("bar")
+        # Don't call gen.endDocument()
+
+        self.assertEqual(result.getvalue(),
+            self.xml('<foo a="1.0">Hello</foo><bar b="2.0"></bar>')[len(self.xml('')):])
+
+class StringXmlgenTest(XmlgenTest, unittest.TestCase):
+    ioclass = StringIO
+
+    def xml(self, doc, encoding='iso-8859-1'):
+        return '<?xml version="1.0" encoding="%s"?>\n%s' % (encoding, doc)
+
+    test_xmlgen_unencodable = None
+
+class BytesXmlgenTest(XmlgenTest, unittest.TestCase):
+    ioclass = BytesIO
+
+    def xml(self, doc, encoding='iso-8859-1'):
+        return ('<?xml version="1.0" encoding="%s"?>\n%s' %
+                (encoding, doc)).encode(encoding, 'xmlcharrefreplace')
+
+class WriterXmlgenTest(BytesXmlgenTest):
+    class ioclass(list):
+        write = list.append
+        closed = False
+
+        def seekable(self):
+            return True
+
+        def tell(self):
+            # return 0 at start and not 0 after start
+            return len(self)
+
+        def getvalue(self):
+            return b''.join(self)
+
+class StreamWriterXmlgenTest(XmlgenTest, unittest.TestCase):
+    def ioclass(self):
+        raw = BytesIO()
+        writer = codecs.getwriter('ascii')(raw, 'xmlcharrefreplace')
+        writer.getvalue = raw.getvalue
+        return writer
+
+    def xml(self, doc, encoding='iso-8859-1'):
+        return ('<?xml version="1.0" encoding="%s"?>\n%s' %
+                (encoding, doc)).encode('ascii', 'xmlcharrefreplace')
+
+class StreamReaderWriterXmlgenTest(XmlgenTest, unittest.TestCase):
+    fname = os_helper.TESTFN + '-codecs'
+
+    def ioclass(self):
+        with self.assertWarns(DeprecationWarning):
+            writer = codecs.open(self.fname, 'w', encoding='ascii',
+                                errors='xmlcharrefreplace', buffering=0)
+        def cleanup():
+            writer.close()
+            os_helper.unlink(self.fname)
+        self.addCleanup(cleanup)
+        def getvalue():
+            # Windows will not let use reopen without first closing
+            writer.close()
+            with open(writer.name, 'rb') as f:
+                return f.read()
+        writer.getvalue = getvalue
+        return writer
+
+    def xml(self, doc, encoding='iso-8859-1'):
+        return ('<?xml version="1.0" encoding="%s"?>\n%s' %
+                (encoding, doc)).encode('ascii', 'xmlcharrefreplace')
+
+start = b'<?xml version="1.0" encoding="iso-8859-1"?>\n'
+
+
+class XMLFilterBaseTest(unittest.TestCase):
+    def test_filter_basic(self):
+        result = BytesIO()
+        gen = XMLGenerator(result)
+        filter = XMLFilterBase()
+        filter.setContentHandler(gen)
+
+        filter.startDocument()
+        filter.startElement("doc", {})
+        filter.characters("content")
+        filter.ignorableWhitespace(" ")
+        filter.endElement("doc")
+        filter.endDocument()
+
+        self.assertEqual(result.getvalue(), start + b"<doc>content </doc>")
+
+# ===========================================================================
+#
+#   expatreader tests
+#
+# ===========================================================================
+
+with open(TEST_XMLFILE_OUT, 'rb') as f:
+    xml_test_out = f.read()
+
+class ExpatReaderTest(XmlTestBase):
+
+    # ===== XMLReader support
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AttributeError: 'xmlparser' object has no attribute 'SetParamEntityParsing'
+    def test_expat_binary_file(self):
+        parser = create_parser()
+        result = BytesIO()
+        xmlgen = XMLGenerator(result)
+
+        parser.setContentHandler(xmlgen)
+        with open(TEST_XMLFILE, 'rb') as f:
+            parser.parse(f)
+
+        self.assertEqual(result.getvalue(), xml_test_out)
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AttributeError: 'xmlparser' object has no attribute 'SetParamEntityParsing'
+    def test_expat_text_file(self):
+        parser = create_parser()
+        result = BytesIO()
+        xmlgen = XMLGenerator(result)
+
+        parser.setContentHandler(xmlgen)
+        with open(TEST_XMLFILE, 'rt', encoding='iso-8859-1') as f:
+            parser.parse(f)
+
+        self.assertEqual(result.getvalue(), xml_test_out)
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AttributeError: 'xmlparser' object has no attribute 'SetParamEntityParsing'
+    @requires_nonascii_filenames
+    def test_expat_binary_file_nonascii(self):
+        fname = os_helper.TESTFN_UNICODE
+        shutil.copyfile(TEST_XMLFILE, fname)
+        self.addCleanup(os_helper.unlink, fname)
+
+        parser = create_parser()
+        result = BytesIO()
+        xmlgen = XMLGenerator(result)
+
+        parser.setContentHandler(xmlgen)
+        parser.parse(open(fname, 'rb'))
+
+        self.assertEqual(result.getvalue(), xml_test_out)
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AttributeError: 'xmlparser' object has no attribute 'SetParamEntityParsing'
+    def test_expat_binary_file_bytes_name(self):
+        fname = os.fsencode(TEST_XMLFILE)
+        parser = create_parser()
+        result = BytesIO()
+        xmlgen = XMLGenerator(result)
+
+        parser.setContentHandler(xmlgen)
+        with open(fname, 'rb') as f:
+            parser.parse(f)
+
+        self.assertEqual(result.getvalue(), xml_test_out)
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AttributeError: 'xmlparser' object has no attribute 'SetParamEntityParsing'
+    def test_expat_binary_file_int_name(self):
+        parser = create_parser()
+        result = BytesIO()
+        xmlgen = XMLGenerator(result)
+
+        parser.setContentHandler(xmlgen)
+        with open(TEST_XMLFILE, 'rb') as f:
+            with open(f.fileno(), 'rb', closefd=False) as f2:
+                parser.parse(f2)
+
+        self.assertEqual(result.getvalue(), xml_test_out)
+
+    # ===== DTDHandler support
+
+    class TestDTDHandler:
+
+        def __init__(self):
+            self._notations = []
+            self._entities  = []
+
+        def notationDecl(self, name, publicId, systemId):
+            self._notations.append((name, publicId, systemId))
+
+        def unparsedEntityDecl(self, name, publicId, systemId, ndata):
+            self._entities.append((name, publicId, systemId, ndata))
+
+
+    class TestEntityRecorder:
+        def __init__(self):
+            self.entities = []
+
+        def resolveEntity(self, publicId, systemId):
+            self.entities.append((publicId, systemId))
+            source = InputSource()
+            source.setPublicId(publicId)
+            source.setSystemId(systemId)
+            return source
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AttributeError: 'xmlparser' object has no attribute 'SetParamEntityParsing'
+    def test_expat_dtdhandler(self):
+        parser = create_parser()
+        handler = self.TestDTDHandler()
+        parser.setDTDHandler(handler)
+
+        parser.feed('<!DOCTYPE doc [\n')
+        parser.feed('  <!ENTITY img SYSTEM "expat.gif" NDATA GIF>\n')
+        parser.feed('  <!NOTATION GIF PUBLIC "-//CompuServe//NOTATION Graphics Interchange Format 89a//EN">\n')
+        parser.feed(']>\n')
+        parser.feed('<doc></doc>')
+        parser.close()
+
+        self.assertEqual(handler._notations,
+            [("GIF", "-//CompuServe//NOTATION Graphics Interchange Format 89a//EN", None)])
+        self.assertEqual(handler._entities, [("img", None, "expat.gif", "GIF")])
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AttributeError: 'xmlparser' object has no attribute 'SetParamEntityParsing'
+    def test_expat_external_dtd_enabled(self):
+        # clear _opener global variable
+        self.addCleanup(urllib.request.urlcleanup)
+
+        parser = create_parser()
+        parser.setFeature(feature_external_ges, True)
+        resolver = self.TestEntityRecorder()
+        parser.setEntityResolver(resolver)
+
+        with self.assertRaises(URLError):
+            parser.feed(
+                '<!DOCTYPE external SYSTEM "unsupported://non-existing">\n'
+            )
+        self.assertEqual(
+            resolver.entities, [(None, 'unsupported://non-existing')]
+        )
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AttributeError: 'xmlparser' object has no attribute 'SetParamEntityParsing'
+    def test_expat_external_dtd_default(self):
+        parser = create_parser()
+        resolver = self.TestEntityRecorder()
+        parser.setEntityResolver(resolver)
+
+        parser.feed(
+            '<!DOCTYPE external SYSTEM "unsupported://non-existing">\n'
+        )
+        parser.feed('<doc />')
+        parser.close()
+        self.assertEqual(resolver.entities, [])
+
+    # ===== EntityResolver support
+
+    class TestEntityResolver:
+
+        def resolveEntity(self, publicId, systemId):
+            inpsrc = InputSource()
+            inpsrc.setByteStream(BytesIO(b"<entity/>"))
+            return inpsrc
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AttributeError: 'xmlparser' object has no attribute 'SetParamEntityParsing'
+    def test_expat_entityresolver_enabled(self):
+        parser = create_parser()
+        parser.setFeature(feature_external_ges, True)
+        parser.setEntityResolver(self.TestEntityResolver())
+        result = BytesIO()
+        parser.setContentHandler(XMLGenerator(result))
+
+        parser.feed('<!DOCTYPE doc [\n')
+        parser.feed('  <!ENTITY test SYSTEM "whatever">\n')
+        parser.feed(']>\n')
+        parser.feed('<doc>&test;</doc>')
+        parser.close()
+
+        self.assertEqual(result.getvalue(), start +
+                         b"<doc><entity></entity></doc>")
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AttributeError: 'xmlparser' object has no attribute 'SetParamEntityParsing'
+    def test_expat_entityresolver_default(self):
+        parser = create_parser()
+        self.assertEqual(parser.getFeature(feature_external_ges), False)
+        parser.setEntityResolver(self.TestEntityResolver())
+        result = BytesIO()
+        parser.setContentHandler(XMLGenerator(result))
+
+        parser.feed('<!DOCTYPE doc [\n')
+        parser.feed('  <!ENTITY test SYSTEM "whatever">\n')
+        parser.feed(']>\n')
+        parser.feed('<doc>&test;</doc>')
+        parser.close()
+
+        self.assertEqual(result.getvalue(), start +
+                         b"<doc></doc>")
+
+    # ===== Attributes support
+
+    class AttrGatherer(ContentHandler):
+
+        def startElement(self, name, attrs):
+            self._attrs = attrs
+
+        def startElementNS(self, name, qname, attrs):
+            self._attrs = attrs
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AttributeError: 'xmlparser' object has no attribute 'SetParamEntityParsing'
+    def test_expat_attrs_empty(self):
+        parser = create_parser()
+        gather = self.AttrGatherer()
+        parser.setContentHandler(gather)
+
+        parser.feed("<doc/>")
+        parser.close()
+
+        self.verify_empty_attrs(gather._attrs)
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AttributeError: 'xmlparser' object has no attribute 'SetParamEntityParsing'
+    def test_expat_attrs_wattr(self):
+        parser = create_parser()
+        gather = self.AttrGatherer()
+        parser.setContentHandler(gather)
+
+        parser.feed("<doc attr='val'/>")
+        parser.close()
+
+        self.verify_attrs_wattr(gather._attrs)
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AttributeError: 'xmlparser' object has no attribute 'SetParamEntityParsing'
+    def test_expat_nsattrs_empty(self):
+        parser = create_parser(1)
+        gather = self.AttrGatherer()
+        parser.setContentHandler(gather)
+
+        parser.feed("<doc/>")
+        parser.close()
+
+        self.verify_empty_nsattrs(gather._attrs)
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AttributeError: 'xmlparser' object has no attribute 'SetParamEntityParsing'
+    def test_expat_nsattrs_wattr(self):
+        parser = create_parser(1)
+        gather = self.AttrGatherer()
+        parser.setContentHandler(gather)
+
+        parser.feed("<doc xmlns:ns='%s' ns:attr='val'/>" % ns_uri)
+        parser.close()
+
+        attrs = gather._attrs
+
+        self.assertEqual(attrs.getLength(), 1)
+        self.assertEqual(attrs.getNames(), [(ns_uri, "attr")])
+        self.assertTrue((attrs.getQNames() == [] or
+                         attrs.getQNames() == ["ns:attr"]))
+        self.assertEqual(len(attrs), 1)
+        self.assertIn((ns_uri, "attr"), attrs)
+        self.assertEqual(attrs.get((ns_uri, "attr")), "val")
+        self.assertEqual(attrs.get((ns_uri, "attr"), 25), "val")
+        self.assertEqual(list(attrs.items()), [((ns_uri, "attr"), "val")])
+        self.assertEqual(list(attrs.values()), ["val"])
+        self.assertEqual(attrs.getValue((ns_uri, "attr")), "val")
+        self.assertEqual(attrs[(ns_uri, "attr")], "val")
+
+    # ===== InputSource support
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AttributeError: 'xmlparser' object has no attribute 'SetParamEntityParsing'
+    def test_expat_inpsource_filename(self):
+        parser = create_parser()
+        result = BytesIO()
+        xmlgen = XMLGenerator(result)
+
+        parser.setContentHandler(xmlgen)
+        parser.parse(TEST_XMLFILE)
+
+        self.assertEqual(result.getvalue(), xml_test_out)
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AttributeError: 'xmlparser' object has no attribute 'SetParamEntityParsing'
+    def test_expat_inpsource_sysid(self):
+        parser = create_parser()
+        result = BytesIO()
+        xmlgen = XMLGenerator(result)
+
+        parser.setContentHandler(xmlgen)
+        parser.parse(InputSource(TEST_XMLFILE))
+
+        self.assertEqual(result.getvalue(), xml_test_out)
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AttributeError: 'xmlparser' object has no attribute 'SetParamEntityParsing'
+    @requires_nonascii_filenames
+    def test_expat_inpsource_sysid_nonascii(self):
+        fname = os_helper.TESTFN_UNICODE
+        shutil.copyfile(TEST_XMLFILE, fname)
+        self.addCleanup(os_helper.unlink, fname)
+
+        parser = create_parser()
+        result = BytesIO()
+        xmlgen = XMLGenerator(result)
+
+        parser.setContentHandler(xmlgen)
+        parser.parse(InputSource(fname))
+
+        self.assertEqual(result.getvalue(), xml_test_out)
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AttributeError: 'xmlparser' object has no attribute 'SetParamEntityParsing'
+    def test_expat_inpsource_byte_stream(self):
+        parser = create_parser()
+        result = BytesIO()
+        xmlgen = XMLGenerator(result)
+
+        parser.setContentHandler(xmlgen)
+        inpsrc = InputSource()
+        with open(TEST_XMLFILE, 'rb') as f:
+            inpsrc.setByteStream(f)
+            parser.parse(inpsrc)
+
+        self.assertEqual(result.getvalue(), xml_test_out)
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AttributeError: 'xmlparser' object has no attribute 'SetParamEntityParsing'
+    def test_expat_inpsource_character_stream(self):
+        parser = create_parser()
+        result = BytesIO()
+        xmlgen = XMLGenerator(result)
+
+        parser.setContentHandler(xmlgen)
+        inpsrc = InputSource()
+        with open(TEST_XMLFILE, 'rt', encoding='iso-8859-1') as f:
+            inpsrc.setCharacterStream(f)
+            parser.parse(inpsrc)
+
+        self.assertEqual(result.getvalue(), xml_test_out)
+
+    # ===== IncrementalParser support
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AttributeError: 'xmlparser' object has no attribute 'SetParamEntityParsing'
+    def test_expat_incremental(self):
+        result = BytesIO()
+        xmlgen = XMLGenerator(result)
+        parser = create_parser()
+        parser.setContentHandler(xmlgen)
+
+        parser.feed("<doc>")
+        parser.feed("</doc>")
+        parser.close()
+
+        self.assertEqual(result.getvalue(), start + b"<doc></doc>")
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AttributeError: 'xmlparser' object has no attribute 'SetParamEntityParsing'
+    def test_expat_incremental_reset(self):
+        result = BytesIO()
+        xmlgen = XMLGenerator(result)
+        parser = create_parser()
+        parser.setContentHandler(xmlgen)
+
+        parser.feed("<doc>")
+        parser.feed("text")
+
+        result = BytesIO()
+        xmlgen = XMLGenerator(result)
+        parser.setContentHandler(xmlgen)
+        parser.reset()
+
+        parser.feed("<doc>")
+        parser.feed("text")
+        parser.feed("</doc>")
+        parser.close()
+
+        self.assertEqual(result.getvalue(), start + b"<doc>text</doc>")
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AttributeError: 'xmlparser' object has no attribute 'SetParamEntityParsing'
+    @unittest.skipIf(pyexpat.version_info < (2, 6, 0),
+                     f'Expat {pyexpat.version_info} does not '
+                     'support reparse deferral')
+    def test_flush_reparse_deferral_enabled(self):
+        result = BytesIO()
+        xmlgen = XMLGenerator(result)
+        parser = create_parser()
+        parser.setContentHandler(xmlgen)
+
+        for chunk in ("<doc", ">"):
+            parser.feed(chunk)
+
+        self.assertEqual(result.getvalue(), start)  # i.e. no elements started
+        self.assertTrue(parser._parser.GetReparseDeferralEnabled())
+
+        parser.flush()
+
+        self.assertTrue(parser._parser.GetReparseDeferralEnabled())
+        self.assertEqual(result.getvalue(), start + b"<doc>")
+
+        parser.feed("</doc>")
+        parser.close()
+
+        self.assertEqual(result.getvalue(), start + b"<doc></doc>")
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AttributeError: 'xmlparser' object has no attribute 'SetParamEntityParsing'
+    def test_flush_reparse_deferral_disabled(self):
+        result = BytesIO()
+        xmlgen = XMLGenerator(result)
+        parser = create_parser()
+        parser.setContentHandler(xmlgen)
+
+        for chunk in ("<doc", ">"):
+            parser.feed(chunk)
+
+        if pyexpat.version_info >= (2, 6, 0):
+            parser._parser.SetReparseDeferralEnabled(False)
+            self.assertEqual(result.getvalue(), start)  # i.e. no elements started
+
+        self.assertFalse(parser._parser.GetReparseDeferralEnabled())
+
+        parser.flush()
+
+        self.assertFalse(parser._parser.GetReparseDeferralEnabled())
+        self.assertEqual(result.getvalue(), start + b"<doc>")
+
+        parser.feed("</doc>")
+        parser.close()
+
+        self.assertEqual(result.getvalue(), start + b"<doc></doc>")
+
+    # ===== Locator support
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AttributeError: 'xmlparser' object has no attribute 'SetParamEntityParsing'
+    def test_expat_locator_noinfo(self):
+        result = BytesIO()
+        xmlgen = XMLGenerator(result)
+        parser = create_parser()
+        parser.setContentHandler(xmlgen)
+
+        parser.feed("<doc>")
+        parser.feed("</doc>")
+        parser.close()
+
+        self.assertEqual(parser.getSystemId(), None)
+        self.assertEqual(parser.getPublicId(), None)
+        self.assertEqual(parser.getLineNumber(), 1)
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AttributeError: 'xmlparser' object has no attribute 'SetParamEntityParsing'
+    def test_expat_locator_withinfo(self):
+        result = BytesIO()
+        xmlgen = XMLGenerator(result)
+        parser = create_parser()
+        parser.setContentHandler(xmlgen)
+        parser.parse(TEST_XMLFILE)
+
+        self.assertEqual(parser.getSystemId(), TEST_XMLFILE)
+        self.assertEqual(parser.getPublicId(), None)
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AttributeError: 'xmlparser' object has no attribute 'SetParamEntityParsing'
+    @requires_nonascii_filenames
+    def test_expat_locator_withinfo_nonascii(self):
+        fname = os_helper.TESTFN_UNICODE
+        shutil.copyfile(TEST_XMLFILE, fname)
+        self.addCleanup(os_helper.unlink, fname)
+
+        result = BytesIO()
+        xmlgen = XMLGenerator(result)
+        parser = create_parser()
+        parser.setContentHandler(xmlgen)
+        parser.parse(fname)
+
+        self.assertEqual(parser.getSystemId(), fname)
+        self.assertEqual(parser.getPublicId(), None)
+
+
+# ===========================================================================
+#
+#   error reporting
+#
+# ===========================================================================
+
+class ErrorReportingTest(unittest.TestCase):
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AttributeError: 'xmlparser' object has no attribute 'SetParamEntityParsing'
+    def test_expat_inpsource_location(self):
+        parser = create_parser()
+        parser.setContentHandler(ContentHandler()) # do nothing
+        source = InputSource()
+        source.setByteStream(BytesIO(b"<foo bar foobar>"))   #ill-formed
+        name = "a file name"
+        source.setSystemId(name)
+        try:
+            parser.parse(source)
+            self.fail()
+        except SAXException as e:
+            self.assertEqual(e.getSystemId(), name)
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AttributeError: 'xmlparser' object has no attribute 'SetParamEntityParsing'
+    def test_expat_incomplete(self):
+        parser = create_parser()
+        parser.setContentHandler(ContentHandler()) # do nothing
+        self.assertRaises(SAXParseException, parser.parse, StringIO("<foo>"))
+        self.assertEqual(parser.getColumnNumber(), 5)
+        self.assertEqual(parser.getLineNumber(), 1)
+
+    def test_sax_parse_exception_str(self):
+        # pass various values from a locator to the SAXParseException to
+        # make sure that the __str__() doesn't fall apart when None is
+        # passed instead of an integer line and column number
+        #
+        # use "normal" values for the locator:
+        str(SAXParseException("message", None,
+                              self.DummyLocator(1, 1)))
+        # use None for the line number:
+        str(SAXParseException("message", None,
+                              self.DummyLocator(None, 1)))
+        # use None for the column number:
+        str(SAXParseException("message", None,
+                              self.DummyLocator(1, None)))
+        # use None for both:
+        str(SAXParseException("message", None,
+                              self.DummyLocator(None, None)))
+
+    class DummyLocator:
+        def __init__(self, lineno, colno):
+            self._lineno = lineno
+            self._colno = colno
+
+        def getPublicId(self):
+            return "pubid"
+
+        def getSystemId(self):
+            return "sysid"
+
+        def getLineNumber(self):
+            return self._lineno
+
+        def getColumnNumber(self):
+            return self._colno
+
+# ===========================================================================
+#
+#   xmlreader tests
+#
+# ===========================================================================
+
+class XmlReaderTest(XmlTestBase):
+
+    # ===== AttributesImpl
+    def test_attrs_empty(self):
+        self.verify_empty_attrs(AttributesImpl({}))
+
+    def test_attrs_wattr(self):
+        self.verify_attrs_wattr(AttributesImpl({"attr" : "val"}))
+
+    def test_nsattrs_empty(self):
+        self.verify_empty_nsattrs(AttributesNSImpl({}, {}))
+
+    def test_nsattrs_wattr(self):
+        attrs = AttributesNSImpl({(ns_uri, "attr") : "val"},
+                                 {(ns_uri, "attr") : "ns:attr"})
+
+        self.assertEqual(attrs.getLength(), 1)
+        self.assertEqual(attrs.getNames(), [(ns_uri, "attr")])
+        self.assertEqual(attrs.getQNames(), ["ns:attr"])
+        self.assertEqual(len(attrs), 1)
+        self.assertIn((ns_uri, "attr"), attrs)
+        self.assertEqual(list(attrs.keys()), [(ns_uri, "attr")])
+        self.assertEqual(attrs.get((ns_uri, "attr")), "val")
+        self.assertEqual(attrs.get((ns_uri, "attr"), 25), "val")
+        self.assertEqual(list(attrs.items()), [((ns_uri, "attr"), "val")])
+        self.assertEqual(list(attrs.values()), ["val"])
+        self.assertEqual(attrs.getValue((ns_uri, "attr")), "val")
+        self.assertEqual(attrs.getValueByQName("ns:attr"), "val")
+        self.assertEqual(attrs.getNameByQName("ns:attr"), (ns_uri, "attr"))
+        self.assertEqual(attrs[(ns_uri, "attr")], "val")
+        self.assertEqual(attrs.getQNameByName((ns_uri, "attr")), "ns:attr")
+
+
+class LexicalHandlerTest(unittest.TestCase):
+    def setUp(self):
+        self.parser = None
+
+        self.specified_version = '1.0'
+        self.specified_encoding = 'UTF-8'
+        self.specified_doctype = 'wish'
+        self.specified_entity_names = ('nbsp', 'source', 'target')
+        self.specified_comment = ('Comment in a DTD',
+                                  'Really! You think so?')
+        self.test_data = StringIO()
+        self.test_data.write('<?xml version="{}" encoding="{}"?>\n'.
+                             format(self.specified_version,
+                                    self.specified_encoding))
+        self.test_data.write('<!DOCTYPE {} [\n'.
+                             format(self.specified_doctype))
+        self.test_data.write('<!-- {} -->\n'.
+                             format(self.specified_comment[0]))
+        self.test_data.write('<!ELEMENT {} (to,from,heading,body,footer)>\n'.
+                             format(self.specified_doctype))
+        self.test_data.write('<!ELEMENT to (#PCDATA)>\n')
+        self.test_data.write('<!ELEMENT from (#PCDATA)>\n')
+        self.test_data.write('<!ELEMENT heading (#PCDATA)>\n')
+        self.test_data.write('<!ELEMENT body (#PCDATA)>\n')
+        self.test_data.write('<!ELEMENT footer (#PCDATA)>\n')
+        self.test_data.write('<!ENTITY {} "&#xA0;">\n'.
+                             format(self.specified_entity_names[0]))
+        self.test_data.write('<!ENTITY {} "Written by: Alexander.">\n'.
+                             format(self.specified_entity_names[1]))
+        self.test_data.write('<!ENTITY {} "Hope it gets to: Aristotle.">\n'.
+                             format(self.specified_entity_names[2]))
+        self.test_data.write(']>\n')
+        self.test_data.write('<{}>'.format(self.specified_doctype))
+        self.test_data.write('<to>Aristotle</to>\n')
+        self.test_data.write('<from>Alexander</from>\n')
+        self.test_data.write('<heading>Supplication</heading>\n')
+        self.test_data.write('<body>Teach me patience!</body>\n')
+        self.test_data.write('<footer>&{};&{};&{};</footer>\n'.
+                             format(self.specified_entity_names[1],
+                                    self.specified_entity_names[0],
+                                    self.specified_entity_names[2]))
+        self.test_data.write('<!-- {} -->\n'.format(self.specified_comment[1]))
+        self.test_data.write('</{}>\n'.format(self.specified_doctype))
+        self.test_data.seek(0)
+
+        # Data received from handlers - to be validated
+        self.version = None
+        self.encoding = None
+        self.standalone = None
+        self.doctype = None
+        self.publicID = None
+        self.systemID = None
+        self.end_of_dtd = False
+        self.comments = []
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AttributeError: 'xmlparser' object has no attribute 'SetParamEntityParsing'
+    def test_handlers(self):
+        class TestLexicalHandler(LexicalHandler):
+            def __init__(self, test_harness, *args, **kwargs):
+                super().__init__(*args, **kwargs)
+                self.test_harness = test_harness
+
+            def startDTD(self, doctype, publicID, systemID):
+                self.test_harness.doctype = doctype
+                self.test_harness.publicID = publicID
+                self.test_harness.systemID = systemID
+
+            def endDTD(self):
+                self.test_harness.end_of_dtd = True
+
+            def comment(self, text):
+                self.test_harness.comments.append(text)
+
+        self.parser = create_parser()
+        self.parser.setContentHandler(ContentHandler())
+        self.parser.setProperty(
+            'http://xml.org/sax/properties/lexical-handler',
+            TestLexicalHandler(self))
+        source = InputSource()
+        source.setCharacterStream(self.test_data)
+        self.parser.parse(source)
+        self.assertEqual(self.doctype, self.specified_doctype)
+        self.assertIsNone(self.publicID)
+        self.assertIsNone(self.systemID)
+        self.assertTrue(self.end_of_dtd)
+        self.assertEqual(len(self.comments),
+                         len(self.specified_comment))
+        self.assertEqual(f' {self.specified_comment[0]} ', self.comments[0])
+
+
+class CDATAHandlerTest(unittest.TestCase):
+    def setUp(self):
+        self.parser = None
+        self.specified_chars = []
+        self.specified_chars.append(('Parseable character data', False))
+        self.specified_chars.append(('<> &% - assorted other XML junk.', True))
+        self.char_index = 0  # Used to index specified results within handlers
+        self.test_data = StringIO()
+        self.test_data.write('<root_doc>\n')
+        self.test_data.write('<some_pcdata>\n')
+        self.test_data.write(f'{self.specified_chars[0][0]}\n')
+        self.test_data.write('</some_pcdata>\n')
+        self.test_data.write('<some_cdata>\n')
+        self.test_data.write(f'<![CDATA[{self.specified_chars[1][0]}]]>\n')
+        self.test_data.write('</some_cdata>\n')
+        self.test_data.write('</root_doc>\n')
+        self.test_data.seek(0)
+
+        # Data received from handlers - to be validated
+        self.chardata = []
+        self.in_cdata = False
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AttributeError: 'xmlparser' object has no attribute 'SetParamEntityParsing'
+    def test_handlers(self):
+        class TestLexicalHandler(LexicalHandler):
+            def __init__(self, test_harness, *args, **kwargs):
+                super().__init__(*args, **kwargs)
+                self.test_harness = test_harness
+
+            def startCDATA(self):
+                self.test_harness.in_cdata = True
+
+            def endCDATA(self):
+                self.test_harness.in_cdata = False
+
+        class TestCharHandler(ContentHandler):
+            def __init__(self, test_harness, *args, **kwargs):
+                super().__init__(*args, **kwargs)
+                self.test_harness = test_harness
+
+            def characters(self, content):
+                if content != '\n':
+                    h = self.test_harness
+                    t = h.specified_chars[h.char_index]
+                    h.assertEqual(t[0], content)
+                    h.assertEqual(t[1], h.in_cdata)
+                    h.char_index += 1
+
+        self.parser = create_parser()
+        self.parser.setContentHandler(TestCharHandler(self))
+        self.parser.setProperty(
+            'http://xml.org/sax/properties/lexical-handler',
+            TestLexicalHandler(self))
+        source = InputSource()
+        source.setCharacterStream(self.test_data)
+        self.parser.parse(source)
+
+        self.assertFalse(self.in_cdata)
+        self.assertEqual(self.char_index, 2)
+
+
+class TestModuleAll(unittest.TestCase):
+    def test_all(self):
+        extra = (
+            'ContentHandler',
+            'ErrorHandler',
+            'InputSource',
+            'SAXException',
+            'SAXNotRecognizedException',
+            'SAXNotSupportedException',
+            'SAXParseException',
+            'SAXReaderNotAvailable',
+        )
+        check__all__(self, sax, extra=extra)
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/Lib/test/test_scope.py b/Lib/test/test_scope.py
index 662d8eefbc0..520fbc1b662 100644
--- a/Lib/test/test_scope.py
+++ b/Lib/test/test_scope.py
@@ -692,7 +692,6 @@ def dec(self):
         self.assertEqual(c.dec(), 1)
         self.assertEqual(c.dec(), 0)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON; figure out how to communicate that `y = 9` should be stored as a global rather than a STORE_NAME, even when the `global y` is in a nested subscope
     def testGlobalInParallelNestedFunctions(self):
         # A symbol table bug leaked the global statement from one
         # function to other nested functions in the same block.
@@ -779,7 +778,7 @@ class X:
         class X:
             locals()["x"] = 43
             del x
-        self.assertFalse(hasattr(X, "x"))
+        self.assertNotHasAttr(X, "x")
         self.assertEqual(x, 42)
 
     @cpython_only
diff --git a/Lib/test/test_script_helper.py b/Lib/test/test_script_helper.py
index e7b54fd7798..4ade2cbc0d4 100644
--- a/Lib/test/test_script_helper.py
+++ b/Lib/test/test_script_helper.py
@@ -82,7 +82,6 @@ def tearDown(self):
         # Reset the private cached state.
         script_helper.__dict__['__cached_interp_requires_environment'] = None
 
-    @unittest.skipIf(sys.platform == "win32", "TODO: RUSTPYTHON, ValueError: illegal environment variable name")
     @mock.patch('subprocess.check_call')
     def test_interpreter_requires_environment_true(self, mock_check_call):
         with mock.patch.dict(os.environ):
@@ -92,7 +91,6 @@ def test_interpreter_requires_environment_true(self, mock_check_call):
             self.assertTrue(script_helper.interpreter_requires_environment())
             self.assertEqual(1, mock_check_call.call_count)
 
-    @unittest.skipIf(sys.platform == "win32", "TODO: RUSTPYTHON, ValueError: illegal environment variable name")
     @mock.patch('subprocess.check_call')
     def test_interpreter_requires_environment_false(self, mock_check_call):
         with mock.patch.dict(os.environ):
@@ -102,7 +100,6 @@ def test_interpreter_requires_environment_false(self, mock_check_call):
             self.assertFalse(script_helper.interpreter_requires_environment())
             self.assertEqual(1, mock_check_call.call_count)
 
-    @unittest.skipIf(sys.platform == "win32", "TODO: RUSTPYTHON, ValueError: illegal environment variable name")
     @mock.patch('subprocess.check_call')
     def test_interpreter_requires_environment_details(self, mock_check_call):
         with mock.patch.dict(os.environ):
@@ -115,7 +112,6 @@ def test_interpreter_requires_environment_details(self, mock_check_call):
             self.assertEqual(sys.executable, check_call_command[0])
             self.assertIn('-E', check_call_command)
 
-    @unittest.skipIf(sys.platform == "win32", "TODO: RUSTPYTHON, ValueError: illegal environment variable name")
     @mock.patch('subprocess.check_call')
     def test_interpreter_requires_environment_with_pythonhome(self, mock_check_call):
         with mock.patch.dict(os.environ):
diff --git a/Lib/test/test_select.py b/Lib/test/test_select.py
new file mode 100644
index 00000000000..6ce8cd423f7
--- /dev/null
+++ b/Lib/test/test_select.py
@@ -0,0 +1,107 @@
+import errno
+import select
+import subprocess
+import sys
+import textwrap
+import unittest
+from test import support
+
+support.requires_working_socket(module=True)
+
+@unittest.skipIf((sys.platform[:3]=='win'),
+                 "can't easily test on this system")
+class SelectTestCase(unittest.TestCase):
+
+    class Nope:
+        pass
+
+    class Almost:
+        def fileno(self):
+            return 'fileno'
+
+    def test_error_conditions(self):
+        self.assertRaises(TypeError, select.select, 1, 2, 3)
+        self.assertRaises(TypeError, select.select, [self.Nope()], [], [])
+        self.assertRaises(TypeError, select.select, [self.Almost()], [], [])
+        self.assertRaises(TypeError, select.select, [], [], [], "not a number")
+        self.assertRaises(ValueError, select.select, [], [], [], -1)
+
+    # Issue #12367: http://www.freebsd.org/cgi/query-pr.cgi?pr=kern/155606
+    @unittest.skipIf(sys.platform.startswith('freebsd'),
+                     'skip because of a FreeBSD bug: kern/155606')
+    def test_errno(self):
+        with open(__file__, 'rb') as fp:
+            fd = fp.fileno()
+            fp.close()
+            try:
+                select.select([fd], [], [], 0)
+            except OSError as err:
+                self.assertEqual(err.errno, errno.EBADF)
+            else:
+                self.fail("exception not raised")
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AssertionError: unexpectedly identical: []
+    def test_returned_list_identity(self):
+        # See issue #8329
+        r, w, x = select.select([], [], [], 1)
+        self.assertIsNot(r, w)
+        self.assertIsNot(r, x)
+        self.assertIsNot(w, x)
+
+    @support.requires_fork()
+    def test_select(self):
+        code = textwrap.dedent('''
+            import time
+            for i in range(10):
+                print("testing...", flush=True)
+                time.sleep(0.050)
+        ''')
+        cmd = [sys.executable, '-I', '-c', code]
+        with subprocess.Popen(cmd, stdout=subprocess.PIPE) as proc:
+            pipe = proc.stdout
+            for timeout in (0, 1, 2, 4, 8, 16) + (None,)*10:
+                if support.verbose:
+                    print(f'timeout = {timeout}')
+                rfd, wfd, xfd = select.select([pipe], [], [], timeout)
+                self.assertEqual(wfd, [])
+                self.assertEqual(xfd, [])
+                if not rfd:
+                    continue
+                if rfd == [pipe]:
+                    line = pipe.readline()
+                    if support.verbose:
+                        print(repr(line))
+                    if not line:
+                        if support.verbose:
+                            print('EOF')
+                        break
+                    continue
+                self.fail('Unexpected return values from select():',
+                          rfd, wfd, xfd)
+
+    # Issue 16230: Crash on select resized list
+    @unittest.skipIf(
+        support.is_emscripten, "Emscripten cannot select a fd multiple times."
+    )
+    @unittest.skip("TODO: RUSTPYTHON timed out")
+    def test_select_mutated(self):
+        a = []
+        class F:
+            def fileno(self):
+                del a[-1]
+                return sys.__stdout__.fileno()
+        a[:] = [F()] * 10
+        self.assertEqual(select.select([], a, []), ([], a[:5], []))
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AssertionError: TypeError not raised by poll
+    def test_disallow_instantiation(self):
+        support.check_disallow_instantiation(self, type(select.poll()))
+
+        if hasattr(select, 'devpoll'):
+            support.check_disallow_instantiation(self, type(select.devpoll()))
+
+def tearDownModule():
+    support.reap_children()
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/Lib/test/test_set.py b/Lib/test/test_set.py
index 8ef2871c61f..c68ba49d916 100644
--- a/Lib/test/test_set.py
+++ b/Lib/test/test_set.py
@@ -1,16 +1,17 @@
-import unittest
-from test import support
-from test.support import warnings_helper
+import collections.abc
+import copy
 import gc
-import weakref
+import itertools
 import operator
-import copy
 import pickle
-from random import randrange, shuffle
+import re
+import unittest
 import warnings
-import collections
-import collections.abc
-import itertools
+import weakref
+from random import randrange, shuffle
+from test import support
+from test.support import warnings_helper
+
 
 class PassThru(Exception):
     pass
@@ -19,6 +20,14 @@ def check_pass_thru():
     raise PassThru
     yield 1
 
+class CustomHash:
+    def __init__(self, hash):
+        self.hash = hash
+    def __hash__(self):
+        return self.hash
+    def __repr__(self):
+        return f'<CustomHash {self.hash} at {id(self):#x}>'
+
 class BadCmp:
     def __hash__(self):
         return 1
@@ -227,14 +236,17 @@ def test_sub_and_super(self):
 
     def test_pickling(self):
         for i in range(pickle.HIGHEST_PROTOCOL + 1):
+            if type(self.s) not in (set, frozenset):
+                self.s.x = ['x']
+                self.s.z = ['z']
             p = pickle.dumps(self.s, i)
             dup = pickle.loads(p)
             self.assertEqual(self.s, dup, "%s != %s" % (self.s, dup))
             if type(self.s) not in (set, frozenset):
-                self.s.x = 10
-                p = pickle.dumps(self.s, i)
-                dup = pickle.loads(p)
                 self.assertEqual(self.s.x, dup.x)
+                self.assertEqual(self.s.z, dup.z)
+                self.assertNotHasAttr(self.s, 'y')
+                del self.s.x, self.s.z
 
     def test_iterator_pickling(self):
         for proto in range(pickle.HIGHEST_PROTOCOL + 1):
@@ -318,8 +330,7 @@ def test_cyclical_repr(self):
             name = repr(s).partition('(')[0]    # strip class name
             self.assertEqual(repr(s), '%s({%s(...)})' % (name, name))
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_do_not_rehash_dict_keys(self):
         n = 10
         d = dict.fromkeys(map(HashCountingInt, range(n)))
@@ -339,8 +350,7 @@ def test_do_not_rehash_dict_keys(self):
         self.assertEqual(sum(elem.hash_count for elem in d), n)
         self.assertEqual(d3, dict.fromkeys(d, 123))
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_container_iterator(self):
         # Bug #3680: tp_traverse was not implemented for set iterator object
         class C(object):
@@ -353,8 +363,7 @@ class C(object):
         gc.collect()
         self.assertTrue(ref() is None, "Cycle was not collected")
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_free_after_iterating(self):
         support.check_free_after_iterating(self, iter, self.thetype)
 
@@ -430,7 +439,7 @@ def test_remove(self):
         self.assertRaises(KeyError, self.s.remove, self.thetype(self.word))
 
     def test_remove_keyerror_unpacking(self):
-        # bug:  www.python.org/sf/1576657
+        # https://bugs.python.org/issue1576657
         for v1 in ['Q', (1,)]:
             try:
                 self.s.remove(v1)
@@ -638,10 +647,68 @@ def __le__(self, some_set):
         myset >= myobj
         self.assertTrue(myobj.le_called)
 
-    @unittest.skipUnless(hasattr(set, "test_c_api"),
-                         'C API test only available in a debug build')
-    def test_c_api(self):
-        self.assertEqual(set().test_c_api(), True)
+    def test_set_membership(self):
+        myfrozenset = frozenset(range(3))
+        myset = {myfrozenset, "abc", 1}
+        self.assertIn(set(range(3)), myset)
+        self.assertNotIn(set(range(1)), myset)
+        myset.discard(set(range(3)))
+        self.assertEqual(myset, {"abc", 1})
+        self.assertRaises(KeyError, myset.remove, set(range(1)))
+        self.assertRaises(KeyError, myset.remove, set(range(3)))
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    def test_unhashable_element(self):
+        myset = {'a'}
+        elem = [1, 2, 3]
+
+        def check_unhashable_element():
+            msg = "cannot use 'list' as a set element (unhashable type: 'list')"
+            return self.assertRaisesRegex(TypeError, re.escape(msg))
+
+        with check_unhashable_element():
+            elem in myset
+        with check_unhashable_element():
+            myset.add(elem)
+        with check_unhashable_element():
+            myset.discard(elem)
+
+        # Only TypeError exception is overriden,
+        # other exceptions are left unchanged.
+        class HashError:
+            def __hash__(self):
+                raise KeyError('error')
+
+        elem2 = HashError()
+        with self.assertRaises(KeyError):
+            elem2 in myset
+        with self.assertRaises(KeyError):
+            myset.add(elem2)
+        with self.assertRaises(KeyError):
+            myset.discard(elem2)
+
+    def test_hash_collision_remove_add(self):
+        self.maxDiff = None
+        # There should be enough space, so all elements with unique hash
+        # will be placed in corresponding cells without collision.
+        n = 64
+        elems = [CustomHash(h) for h in range(n)]
+        # Elements with hash collision.
+        a = CustomHash(n)
+        b = CustomHash(n)
+        elems += [a, b]
+        s = self.thetype(elems)
+        self.assertEqual(len(s), len(elems), s)
+        s.remove(a)
+        # "a" has been replaced with a dummy.
+        del elems[n]
+        self.assertEqual(len(s), len(elems), s)
+        self.assertEqual(s, set(elems))
+        s.add(b)
+        # "b" should not replace the dummy.
+        self.assertEqual(len(s), len(elems), s)
+        self.assertEqual(s, set(elems))
+
 
 class SetSubclass(set):
     pass
@@ -650,15 +717,37 @@ class TestSetSubclass(TestSet):
     thetype = SetSubclass
     basetype = set
 
-class SetSubclassWithKeywordArgs(set):
-    def __init__(self, iterable=[], newarg=None):
-        set.__init__(self, iterable)
-
-class TestSetSubclassWithKeywordArgs(TestSet):
-
     def test_keywords_in_subclass(self):
-        'SF bug #1486663 -- this used to erroneously raise a TypeError'
-        SetSubclassWithKeywordArgs(newarg=1)
+        class subclass(set):
+            pass
+        u = subclass([1, 2])
+        self.assertIs(type(u), subclass)
+        self.assertEqual(set(u), {1, 2})
+        with self.assertRaises(TypeError):
+            subclass(sequence=())
+
+        class subclass_with_init(set):
+            def __init__(self, arg, newarg=None):
+                super().__init__(arg)
+                self.newarg = newarg
+        u = subclass_with_init([1, 2], newarg=3)
+        self.assertIs(type(u), subclass_with_init)
+        self.assertEqual(set(u), {1, 2})
+        self.assertEqual(u.newarg, 3)
+
+        class subclass_with_new(set):
+            def __new__(cls, arg, newarg=None):
+                self = super().__new__(cls, arg)
+                self.newarg = newarg
+                return self
+        u = subclass_with_new([1, 2])
+        self.assertIs(type(u), subclass_with_new)
+        self.assertEqual(set(u), {1, 2})
+        self.assertIsNone(u.newarg)
+        # disallow kwargs in __new__ only (https://bugs.python.org/issue43413#msg402000)
+        with self.assertRaises(TypeError):
+            subclass_with_new([1, 2], newarg=3)
+
 
 class TestFrozenSet(TestJointOps, unittest.TestCase):
     thetype = frozenset
@@ -740,6 +829,34 @@ class TestFrozenSetSubclass(TestFrozenSet):
     thetype = FrozenSetSubclass
     basetype = frozenset
 
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    def test_keywords_in_subclass(self):
+        class subclass(frozenset):
+            pass
+        u = subclass([1, 2])
+        self.assertIs(type(u), subclass)
+        self.assertEqual(set(u), {1, 2})
+        with self.assertRaises(TypeError):
+            subclass(sequence=())
+
+        class subclass_with_init(frozenset):
+            def __init__(self, arg, newarg=None):
+                self.newarg = newarg
+        u = subclass_with_init([1, 2], newarg=3)
+        self.assertIs(type(u), subclass_with_init)
+        self.assertEqual(set(u), {1, 2})
+        self.assertEqual(u.newarg, 3)
+
+        class subclass_with_new(frozenset):
+            def __new__(cls, arg, newarg=None):
+                self = super().__new__(cls, arg)
+                self.newarg = newarg
+                return self
+        u = subclass_with_new([1, 2], newarg=3)
+        self.assertIs(type(u), subclass_with_new)
+        self.assertEqual(set(u), {1, 2})
+        self.assertEqual(u.newarg, 3)
+
     def test_constructor_identity(self):
         s = self.thetype(range(3))
         t = self.thetype(s)
@@ -765,6 +882,25 @@ def test_singleton_empty_frozenset(self):
         # All empty frozenset subclass instances should have different ids
         self.assertEqual(len(set(map(id, efs))), len(efs))
 
+
+class SetSubclassWithSlots(set):
+    __slots__ = ('x', 'y', '__dict__')
+
+class TestSetSubclassWithSlots(unittest.TestCase):
+    thetype = SetSubclassWithSlots
+    setUp = TestJointOps.setUp
+    test_pickling = TestJointOps.test_pickling
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    def test_pickling(self):
+        return super().test_pickling()
+
+class FrozenSetSubclassWithSlots(frozenset):
+    __slots__ = ('x', 'y', '__dict__')
+
+class TestFrozenSetSubclassWithSlots(TestSetSubclassWithSlots):
+    thetype = FrozenSetSubclassWithSlots
+
 # Tests taken from test_sets.py =============================================
 
 empty_set = set()
@@ -779,8 +915,8 @@ def test_repr(self):
 
     def check_repr_against_values(self):
         text = repr(self.set)
-        self.assertTrue(text.startswith('{'))
-        self.assertTrue(text.endswith('}'))
+        self.assertStartsWith(text, '{')
+        self.assertEndsWith(text, '}')
 
         result = text[1:-1].split(', ')
         result.sort()
@@ -961,8 +1097,7 @@ def test_repr(self):
 
 class TestBasicOpsMixedStringBytes(TestBasicOps, unittest.TestCase):
     def setUp(self):
-        self._warning_filters = warnings_helper.check_warnings()
-        self._warning_filters.__enter__()
+        self.enterContext(warnings_helper.check_warnings())
         warnings.simplefilter('ignore', BytesWarning)
         self.case   = "string and bytes set"
         self.values = ["a", "b", b"a", b"b"]
@@ -970,9 +1105,6 @@ def setUp(self):
         self.dup    = set(self.values)
         self.length = 4
 
-    def tearDown(self):
-        self._warning_filters.__exit__(None, None, None)
-
     def test_repr(self):
         self.check_repr_against_values()
 
@@ -1760,6 +1892,7 @@ def test_iter_and_mutate(self):
         list(si)
 
     def test_merge_and_mutate(self):
+        # gh-141805
         class X:
             def __hash__(self):
                 return hash(0)
@@ -1772,6 +1905,33 @@ def __eq__(self, o):
         s = {0}
         s.update(other)
 
+    def test_hash_collision_concurrent_add(self):
+        class X:
+            def __hash__(self):
+                return 0
+        class Y:
+            flag = False
+            def __hash__(self):
+                return 0
+            def __eq__(self, other):
+                if not self.flag:
+                    self.flag = True
+                    s.add(X())
+                return self is other
+
+        a = X()
+        s = set()
+        s.add(a)
+        s.add(X())
+        s.remove(a)
+        # Now the set contains a dummy entry followed by an entry
+        # for an object with hash 0.
+        s.add(Y())
+        # The following operations should not crash.
+        repr(s)
+        list(s)
+        set() | s
+
 
 class TestOperationsMutating:
     """Regression test for bpo-46615"""
diff --git a/Lib/test/test_setcomps.py b/Lib/test/test_setcomps.py
index e8c0c33e980..0bb02ef11f6 100644
--- a/Lib/test/test_setcomps.py
+++ b/Lib/test/test_setcomps.py
@@ -152,7 +152,6 @@
 """
 
 class SetComprehensionTest(unittest.TestCase):
-    @unittest.expectedFailure # TODO: RUSTPYTHON; AttributeError: 'FrameSummary' object has no attribute 'end_lineno'
     def test_exception_locations(self):
         # The location of an exception raised from __init__ or
         # __next__ should should be the iterator expression
diff --git a/Lib/test/test_shlex.py b/Lib/test/test_shlex.py
index baabccf19f4..7c41432b82f 100644
--- a/Lib/test/test_shlex.py
+++ b/Lib/test/test_shlex.py
@@ -3,6 +3,8 @@
 import shlex
 import string
 import unittest
+from test.support import cpython_only
+from test.support import import_helper
 
 
 # The original test data set was from shellwords, by Hartmut Goebel.
@@ -165,14 +167,12 @@ def testSplitNone(self):
         with self.assertRaises(ValueError):
             shlex.split(None)
 
-    # TODO: RUSTPYTHON; ValueError: Error Retrieving Value
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; ValueError: Error Retrieving Value
     def testSplitPosix(self):
         """Test data splitting with posix parser"""
         self.splitTest(self.posix_data, comments=True)
 
-    # TODO: RUSTPYTHON; ValueError: Error Retrieving Value
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; ValueError: Error Retrieving Value
     def testCompat(self):
         """Test compatibility interface"""
         for i in range(len(self.data)):
@@ -313,8 +313,7 @@ def testEmptyStringHandling(self):
         s = shlex.shlex("'')abc", punctuation_chars=True)
         self.assertEqual(list(s), expected)
 
-    # TODO: RUSTPYTHON; ValueError: Error Retrieving Value
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; ValueError: Error Retrieving Value
     def testUnicodeHandling(self):
         """Test punctuation_chars and whitespace_split handle unicode."""
         ss = "\u2119\u01b4\u2602\u210c\u00f8\u1f24"
@@ -334,6 +333,7 @@ def testQuote(self):
         unsafe = '"`$\\!' + unicode_sample
 
         self.assertEqual(shlex.quote(''), "''")
+        self.assertEqual(shlex.quote(None), "''")
         self.assertEqual(shlex.quote(safeunquoted), safeunquoted)
         self.assertEqual(shlex.quote('test file name'), "'test file name'")
         for u in unsafe:
@@ -342,6 +342,8 @@ def testQuote(self):
         for u in unsafe:
             self.assertEqual(shlex.quote("test%s'name'" % u),
                              "'test%s'\"'\"'name'\"'\"''" % u)
+        self.assertRaises(TypeError, shlex.quote, 42)
+        self.assertRaises(TypeError, shlex.quote, b"abc")
 
     def testJoin(self):
         for split_command, command in [
@@ -354,8 +356,7 @@ def testJoin(self):
                 joined = shlex.join(split_command)
                 self.assertEqual(joined, command)
 
-    # TODO: RUSTPYTHON; ValueError: Error Retrieving Value
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; ValueError: Error Retrieving Value
     def testJoinRoundtrip(self):
         all_data = self.data + self.posix_data
         for command, *split_command in all_data:
@@ -371,6 +372,10 @@ def testPunctuationCharsReadOnly(self):
         with self.assertRaises(AttributeError):
             shlex_instance.punctuation_chars = False
 
+    @cpython_only
+    def test_lazy_imports(self):
+        import_helper.ensure_lazy_imports('shlex', {'collections', 're', 'os'})
+
 
 # Allow this test to be used with old shlex.py
 if not getattr(shlex, "split", None):
diff --git a/Lib/test/test_shutil.py b/Lib/test/test_shutil.py
index 0e973255621..62c80aab4b3 100644
--- a/Lib/test/test_shutil.py
+++ b/Lib/test/test_shutil.py
@@ -10,7 +10,6 @@
 import os.path
 import errno
 import functools
-import pathlib
 import subprocess
 import random
 import string
@@ -32,7 +31,6 @@
 from test import support
 from test.support import os_helper
 from test.support.os_helper import TESTFN, FakePath
-from test.support import warnings_helper
 
 TESTFN2 = TESTFN + "2"
 TESTFN_SRC = TESTFN + "_SRC"
@@ -429,12 +427,12 @@ def check_args_to_onerror(self, func, arg, exc):
             else:
                 self.assertIs(func, os.listdir)
                 self.assertIn(arg, [TESTFN, self.child_dir_path])
-            self.assertTrue(issubclass(exc[0], OSError))
+            self.assertIsSubclass(exc[0], OSError)
             self.errorState += 1
         else:
             self.assertEqual(func, os.rmdir)
             self.assertEqual(arg, TESTFN)
-            self.assertTrue(issubclass(exc[0], OSError))
+            self.assertIsSubclass(exc[0], OSError)
             self.errorState = 3
 
     @unittest.skipIf(sys.platform[:6] == 'cygwin',
@@ -557,25 +555,23 @@ def test_rmtree_uses_safe_fd_version_if_available(self):
                              os.listdir in os.supports_fd and
                              os.stat in os.supports_follow_symlinks)
         if _use_fd_functions:
-            self.assertTrue(shutil._use_fd_functions)
             self.assertTrue(shutil.rmtree.avoids_symlink_attacks)
             tmp_dir = self.mkdtemp()
             d = os.path.join(tmp_dir, 'a')
             os.mkdir(d)
             try:
-                real_rmtree = shutil._rmtree_safe_fd
+                real_open = os.open
                 class Called(Exception): pass
                 def _raiser(*args, **kwargs):
                     raise Called
-                shutil._rmtree_safe_fd = _raiser
+                os.open = _raiser
                 self.assertRaises(Called, shutil.rmtree, d)
             finally:
-                shutil._rmtree_safe_fd = real_rmtree
+                os.open = real_open
         else:
-            self.assertFalse(shutil._use_fd_functions)
             self.assertFalse(shutil.rmtree.avoids_symlink_attacks)
 
-    @unittest.skipUnless(shutil._use_fd_functions, "requires safe rmtree")
+    @unittest.skipUnless(shutil.rmtree.avoids_symlink_attacks, "requires safe rmtree")
     def test_rmtree_fails_on_close(self):
         # Test that the error handler is called for failed os.close() and that
         # os.close() is only called once for a file descriptor.
@@ -610,7 +606,7 @@ def onexc(*args):
         self.assertEqual(errors[1][1], dir1)
         self.assertEqual(close_count, 2)
 
-    @unittest.skipUnless(shutil._use_fd_functions, "dir_fd is not supported")
+    @unittest.skipUnless(shutil.rmtree.avoids_symlink_attacks, "dir_fd is not supported")
     def test_rmtree_with_dir_fd(self):
         tmp_dir = self.mkdtemp()
         victim = 'killme'
@@ -624,7 +620,7 @@ def test_rmtree_with_dir_fd(self):
         shutil.rmtree(victim, dir_fd=dir_fd)
         self.assertFalse(os.path.exists(fullname))
 
-    @unittest.skipIf(shutil._use_fd_functions, "dir_fd is supported")
+    @unittest.skipIf(shutil.rmtree.avoids_symlink_attacks, "dir_fd is supported")
     def test_rmtree_with_dir_fd_unsupported(self):
         tmp_dir = self.mkdtemp()
         with self.assertRaises(NotImplementedError):
@@ -906,10 +902,10 @@ def test_copytree_arg_types_of_ignore(self):
         os.mkdir(os.path.join(src_dir, 'test_dir', 'subdir'))
         create_file((src_dir, 'test_dir', 'subdir', 'test.txt'), '456')
 
-        invokations = []
+        invocations = []
 
         def _ignore(src, names):
-            invokations.append(src)
+            invocations.append(src)
             self.assertIsInstance(src, str)
             self.assertIsInstance(names, list)
             self.assertEqual(len(names), len(set(names)))
@@ -934,7 +930,7 @@ def _ignore(src, names):
         self.assertTrue(exists(join(dst_dir, 'test_dir', 'subdir',
                                     'test.txt')))
 
-        self.assertEqual(len(invokations), 9)
+        self.assertEqual(len(invocations), 9)
 
     def test_copytree_retains_permissions(self):
         tmp_dir = self.mkdtemp()
@@ -2145,9 +2141,6 @@ def check_unpack_archive_with_converter(self, format, converter, **kwargs):
     def check_unpack_tarball(self, format):
         self.check_unpack_archive(format, filter='fully_trusted')
         self.check_unpack_archive(format, filter='data')
-        with warnings_helper.check_warnings(
-                ('Python 3.14', DeprecationWarning)):
-            self.check_unpack_archive(format)
 
     def test_unpack_archive_tar(self):
         self.check_unpack_tarball('tar')
@@ -2160,6 +2153,10 @@ def test_unpack_archive_gztar(self):
     def test_unpack_archive_bztar(self):
         self.check_unpack_tarball('bztar')
 
+    @support.requires_zstd()
+    def test_unpack_archive_zstdtar(self):
+        self.check_unpack_tarball('zstdtar')
+
     @support.requires_lzma()
     @unittest.skipIf(AIX and not _maxdataOK(), "AIX MAXDATA must be 0x20000000 or larger")
     def test_unpack_archive_xztar(self):
@@ -3244,12 +3241,8 @@ def test_filesystem_full(self):
                 self.assertRaises(OSError, self.zerocopy_fun, src, dst)
 
 
-@unittest.skipIf(not SUPPORTS_SENDFILE, 'os.sendfile() not supported')
-class TestZeroCopySendfile(_ZeroCopyFileTest, unittest.TestCase):
-    PATCHPOINT = "os.sendfile"
-
-    def zerocopy_fun(self, fsrc, fdst):
-        return shutil._fastcopy_sendfile(fsrc, fdst)
+class _ZeroCopyFileLinuxTest(_ZeroCopyFileTest):
+    BLOCKSIZE_INDEX = None
 
     def test_non_regular_file_src(self):
         with io.BytesIO(self.FILEDATA) as src:
@@ -3270,65 +3263,65 @@ def test_non_regular_file_dst(self):
                 self.assertEqual(dst.read(), self.FILEDATA)
 
     def test_exception_on_second_call(self):
-        def sendfile(*args, **kwargs):
+        def syscall(*args, **kwargs):
             if not flag:
                 flag.append(None)
-                return orig_sendfile(*args, **kwargs)
+                return orig_syscall(*args, **kwargs)
             else:
                 raise OSError(errno.EBADF, "yo")
 
         flag = []
-        orig_sendfile = os.sendfile
-        with unittest.mock.patch('os.sendfile', create=True,
-                                 side_effect=sendfile):
+        orig_syscall = eval(self.PATCHPOINT)
+        with unittest.mock.patch(self.PATCHPOINT, create=True,
+                                 side_effect=syscall):
             with self.get_files() as (src, dst):
                 with self.assertRaises(OSError) as cm:
-                    shutil._fastcopy_sendfile(src, dst)
+                    self.zerocopy_fun(src, dst)
         assert flag
         self.assertEqual(cm.exception.errno, errno.EBADF)
 
     def test_cant_get_size(self):
         # Emulate a case where src file size cannot be determined.
         # Internally bufsize will be set to a small value and
-        # sendfile() will be called repeatedly.
+        # a system call will be called repeatedly.
         with unittest.mock.patch('os.fstat', side_effect=OSError) as m:
             with self.get_files() as (src, dst):
-                shutil._fastcopy_sendfile(src, dst)
+                self.zerocopy_fun(src, dst)
                 assert m.called
         self.assertEqual(read_file(TESTFN2, binary=True), self.FILEDATA)
 
     def test_small_chunks(self):
         # Force internal file size detection to be smaller than the
-        # actual file size. We want to force sendfile() to be called
+        # actual file size. We want to force a system call to be called
         # multiple times, also in order to emulate a src fd which gets
         # bigger while it is being copied.
         mock = unittest.mock.Mock()
         mock.st_size = 65536 + 1
         with unittest.mock.patch('os.fstat', return_value=mock) as m:
             with self.get_files() as (src, dst):
-                shutil._fastcopy_sendfile(src, dst)
+                self.zerocopy_fun(src, dst)
                 assert m.called
         self.assertEqual(read_file(TESTFN2, binary=True), self.FILEDATA)
 
     def test_big_chunk(self):
         # Force internal file size detection to be +100MB bigger than
-        # the actual file size. Make sure sendfile() does not rely on
+        # the actual file size. Make sure a system call does not rely on
         # file size value except for (maybe) a better throughput /
         # performance.
         mock = unittest.mock.Mock()
         mock.st_size = self.FILESIZE + (100 * 1024 * 1024)
         with unittest.mock.patch('os.fstat', return_value=mock) as m:
             with self.get_files() as (src, dst):
-                shutil._fastcopy_sendfile(src, dst)
+                self.zerocopy_fun(src, dst)
                 assert m.called
         self.assertEqual(read_file(TESTFN2, binary=True), self.FILEDATA)
 
     def test_blocksize_arg(self):
-        with unittest.mock.patch('os.sendfile',
+        with unittest.mock.patch(self.PATCHPOINT,
                                  side_effect=ZeroDivisionError) as m:
             self.assertRaises(ZeroDivisionError,
                               shutil.copyfile, TESTFN, TESTFN2)
-            blocksize = m.call_args[0][3]
+            blocksize = m.call_args[0][self.BLOCKSIZE_INDEX]
             # Make sure file size and the block size arg passed to
             # sendfile() are the same.
             self.assertEqual(blocksize, os.path.getsize(TESTFN))
@@ -3338,9 +3331,19 @@ def test_blocksize_arg(self):
             self.addCleanup(os_helper.unlink, TESTFN2 + '3')
             self.assertRaises(ZeroDivisionError,
                               shutil.copyfile, TESTFN2, TESTFN2 + '3')
-            blocksize = m.call_args[0][3]
+            blocksize = m.call_args[0][self.BLOCKSIZE_INDEX]
             self.assertEqual(blocksize, 2 ** 23)
 
+
+@unittest.skipIf(not SUPPORTS_SENDFILE, 'os.sendfile() not supported')
+@unittest.mock.patch.object(shutil, "_USE_CP_COPY_FILE_RANGE", False)
+class TestZeroCopySendfile(_ZeroCopyFileLinuxTest, unittest.TestCase):
+    PATCHPOINT = "os.sendfile"
+    BLOCKSIZE_INDEX = 3
+
+    def zerocopy_fun(self, fsrc, fdst):
+        return shutil._fastcopy_sendfile(fsrc, fdst)
+
     def test_file2file_not_supported(self):
         # Emulate a case where sendfile() only support file->socket
         # fds. In such a case copyfile() is supposed to skip the
@@ -3363,6 +3366,29 @@ def test_file2file_not_supported(self):
             shutil._USE_CP_SENDFILE = True
 
 
+@unittest.skipUnless(shutil._USE_CP_COPY_FILE_RANGE, "os.copy_file_range() not supported")
+class TestZeroCopyCopyFileRange(_ZeroCopyFileLinuxTest, unittest.TestCase):
+    PATCHPOINT = "os.copy_file_range"
+    BLOCKSIZE_INDEX = 2
+
+    def zerocopy_fun(self, fsrc, fdst):
+        return shutil._fastcopy_copy_file_range(fsrc, fdst)
+
+    def test_empty_file(self):
+        srcname = f"{TESTFN}src"
+        dstname = f"{TESTFN}dst"
+        self.addCleanup(lambda: os_helper.unlink(srcname))
+        self.addCleanup(lambda: os_helper.unlink(dstname))
+        with open(srcname, "wb"):
+            pass
+
+        with open(srcname, "rb") as src, open(dstname, "wb") as dst:
+            # _fastcopy_copy_file_range gives up copying empty files due
+            # to a bug in older Linux.
+            with self.assertRaises(shutil._GiveupOnFastCopy):
+                self.zerocopy_fun(src, dst)
+
+
 @unittest.skipIf(not MACOS, 'macOS only')
 class TestZeroCopyMACOS(_ZeroCopyFileTest, unittest.TestCase):
     PATCHPOINT = "posix._fcopyfile"
@@ -3453,10 +3479,10 @@ class PublicAPITests(unittest.TestCase):
     """Ensures that the correct values are exposed in the public API."""
 
     def test_module_all_attribute(self):
-        self.assertTrue(hasattr(shutil, '__all__'))
+        self.assertHasAttr(shutil, '__all__')
         target_api = ['copyfileobj', 'copyfile', 'copymode', 'copystat',
                       'copy', 'copy2', 'copytree', 'move', 'rmtree', 'Error',
-                      'SpecialFileError', 'ExecError', 'make_archive',
+                      'SpecialFileError', 'make_archive',
                       'get_archive_formats', 'register_archive_format',
                       'unregister_archive_format', 'get_unpack_formats',
                       'register_unpack_format', 'unregister_unpack_format',
@@ -3465,6 +3491,8 @@ def test_module_all_attribute(self):
         if hasattr(os, 'statvfs') or os.name == 'nt':
             target_api.append('disk_usage')
         self.assertEqual(set(shutil.__all__), set(target_api))
+        with self.assertWarns(DeprecationWarning):
+            from shutil import ExecError
 
 
 if __name__ == '__main__':
diff --git a/Lib/test/test_signal.py b/Lib/test/test_signal.py
index 2c5cec803d0..07fc97cb6a1 100644
--- a/Lib/test/test_signal.py
+++ b/Lib/test/test_signal.py
@@ -192,7 +192,6 @@ def test_valid_signals(self):
         self.assertNotIn(signal.NSIG, s)
         self.assertLess(len(s), signal.NSIG)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_issue9324(self):
         # Updated for issue #10003, adding SIGBREAK
         handler = lambda x, y: None
@@ -254,9 +253,6 @@ def test_invalid_socket(self):
         self.assertRaises((ValueError, OSError),
                           signal.set_wakeup_fd, fd)
 
-    # Emscripten does not support fstat on pipes yet.
-    # https://github.com/emscripten-core/emscripten/issues/16414
-    @unittest.skipIf(support.is_emscripten, "Emscripten cannot fstat pipes.")
     @unittest.skipUnless(hasattr(os, "pipe"), "requires os.pipe()")
     def test_set_wakeup_fd_result(self):
         r1, w1 = os.pipe()
@@ -275,7 +271,6 @@ def test_set_wakeup_fd_result(self):
         self.assertEqual(signal.set_wakeup_fd(-1), w2)
         self.assertEqual(signal.set_wakeup_fd(-1), -1)
 
-    @unittest.skipIf(support.is_emscripten, "Emscripten cannot fstat pipes.")
     @unittest.skipUnless(support.has_socket_support, "needs working sockets.")
     def test_set_wakeup_fd_socket_result(self):
         sock1 = socket.socket()
@@ -296,7 +291,6 @@ def test_set_wakeup_fd_socket_result(self):
     # On Windows, files are always blocking and Windows does not provide a
     # function to test if a socket is in non-blocking mode.
     @unittest.skipIf(sys.platform == "win32", "tests specific to POSIX")
-    @unittest.skipIf(support.is_emscripten, "Emscripten cannot fstat pipes.")
     @unittest.skipUnless(hasattr(os, "pipe"), "requires os.pipe()")
     def test_set_wakeup_fd_blocking(self):
         rfd, wfd = os.pipe()
@@ -386,7 +380,7 @@ def handler(signum, frame):
         except ZeroDivisionError:
             # An ignored exception should have been printed out on stderr
             err = err.getvalue()
-            if ('Exception ignored when trying to write to the signal wakeup fd'
+            if ('Exception ignored while trying to write to the signal wakeup fd'
                 not in err):
                 raise AssertionError(err)
             if ('OSError: [Errno %d]' % errno.EBADF) not in err:
@@ -575,7 +569,7 @@ def handler(signum, frame):
             signal.raise_signal(signum)
 
         err = err.getvalue()
-        if ('Exception ignored when trying to {action} to the signal wakeup fd'
+        if ('Exception ignored while trying to {action} to the signal wakeup fd'
             not in err):
             raise AssertionError(err)
         """.format(action=action)
@@ -645,7 +639,7 @@ def handler(signum, frame):
                                  "buffer" % written)
 
         # By default, we get a warning when a signal arrives
-        msg = ('Exception ignored when trying to {action} '
+        msg = ('Exception ignored while trying to {action} '
                'to the signal wakeup fd')
         signal.set_wakeup_fd(write.fileno())
 
@@ -1351,6 +1345,7 @@ def handler(signum, frame):
         # Python handler
         self.assertEqual(len(sigs), N, "Some signals were lost")
 
+    @support.requires_gil_enabled("gh-121065: test is flaky on free-threaded build")
     @unittest.skipIf(is_apple, "crashes due to system bug (FB13453490)")
     @unittest.skipUnless(hasattr(signal, "SIGUSR1"),
                          "test needs SIGUSR1")
@@ -1418,7 +1413,6 @@ def test_sigint(self):
         with self.assertRaises(KeyboardInterrupt):
             signal.raise_signal(signal.SIGINT)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     @unittest.skipIf(sys.platform != "win32", "Windows specific test")
     def test_invalid_argument(self):
         try:
@@ -1442,7 +1436,7 @@ def handler(a, b):
         signal.raise_signal(signal.SIGINT)
         self.assertTrue(is_ok)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @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_site.py b/Lib/test/test_site.py
index 56ed457882c..01951e6247b 100644
--- a/Lib/test/test_site.py
+++ b/Lib/test/test_site.py
@@ -591,7 +591,6 @@ def test_lazy_imports(self):
 
 class StartupImportTests(unittest.TestCase):
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     @support.requires_subprocess()
     def test_startup_imports(self):
         # Get sys.path in isolated mode (python3 -I)
diff --git a/Lib/test/test_smtplib.py b/Lib/test/test_smtplib.py
index ade0dc1308c..fb3ea34d766 100644
--- a/Lib/test/test_smtplib.py
+++ b/Lib/test/test_smtplib.py
@@ -1176,7 +1176,6 @@ def auth_buggy(challenge=None):
         finally:
             smtp.close()
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     @hashlib_helper.requires_hashdigest('md5', openssl=True)
     def testAUTH_CRAM_MD5(self):
         self.serv.add_feature("AUTH CRAM-MD5")
@@ -1229,7 +1228,6 @@ def testAUTH_multiple(self):
         self.assertEqual(resp, (235, b'Authentication Succeeded'))
         smtp.close()
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_auth_function(self):
         supported = {'PLAIN', 'LOGIN'}
         try:
diff --git a/Lib/test/test_socket.py b/Lib/test/test_socket.py
index 57539a3862a..fe1fc94b69e 100644
--- a/Lib/test/test_socket.py
+++ b/Lib/test/test_socket.py
@@ -2,8 +2,9 @@
 from unittest import mock
 from test import support
 from test.support import (
-    is_apple, os_helper, refleak_helper, socket_helper, threading_helper
+    cpython_only, is_apple, os_helper, refleak_helper, socket_helper, threading_helper
 )
+from test.support.import_helper import ensure_lazy_imports
 import _thread as thread
 import array
 import contextlib
@@ -49,9 +50,9 @@
 # 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"
+SOLARIS = sys.platform.startswith("sunos")
 WSL = "microsoft-standard-WSL" in platform.release()
 
 try:
@@ -258,6 +259,12 @@ def downgrade_malformed_data_warning():
 # Size in bytes of the int type
 SIZEOF_INT = array.array("i").itemsize
 
+class TestLazyImport(unittest.TestCase):
+    @cpython_only
+    def test_lazy_import(self):
+        ensure_lazy_imports("socket", {"array", "selectors"})
+
+
 class SocketTCPTest(unittest.TestCase):
 
     def setUp(self):
@@ -579,7 +586,7 @@ def clientSetUp(self):
         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
+            cid = socket.VMADDR_CID_LOCAL
         self.cli.connect((cid, VSOCKPORT))
 
     def testStream(self):
@@ -904,9 +911,8 @@ def requireSocket(*args):
 
 class GeneralModuleTests(unittest.TestCase):
 
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; gc.is_tracked not implemented
     @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"):
@@ -969,8 +975,7 @@ def testSocketError(self):
         with self.assertRaises(OSError, msg=msg % 'socket.gaierror'):
             raise socket.gaierror
 
-    # TODO: RUSTPYTHON; error message format differs
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; error message format differs
     def testSendtoErrors(self):
         # Testing that sendto doesn't mask failures. See #10169.
         s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
@@ -1083,9 +1088,7 @@ def test3542SocketOptions(self):
             'IPV6_USE_MIN_MTU',
         }
         for opt in opts:
-            self.assertTrue(
-                hasattr(socket, opt), f"Missing RFC3542 socket option '{opt}'"
-            )
+            self.assertHasAttr(socket, opt)
 
     def testHostnameRes(self):
         # Testing hostname resolution mechanisms
@@ -1154,6 +1157,7 @@ def test_sethostname(self):
 
     @unittest.skipUnless(hasattr(socket, 'if_nameindex'),
                          'socket.if_nameindex() not available.')
+    @support.skip_android_selinux('if_nameindex')
     def testInterfaceNameIndex(self):
         interfaces = socket.if_nameindex()
         for index, name in interfaces:
@@ -1168,14 +1172,16 @@ def testInterfaceNameIndex(self):
             self.assertIsInstance(_name, str)
             self.assertEqual(name, _name)
 
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; OverflowError: Python int too large to convert to Rust u32
     @unittest.skipUnless(hasattr(socket, 'if_indextoname'),
                          'socket.if_indextoname() not available.')
+    @support.skip_android_selinux('if_indextoname')
     def testInvalidInterfaceIndexToName(self):
         with self.assertRaises(OSError) as cm:
             socket.if_indextoname(0)
         self.assertIsNotNone(cm.exception.errno)
 
-        self.assertRaises(OverflowError, socket.if_indextoname, -1)
+        self.assertRaises(ValueError, socket.if_indextoname, -1)
         self.assertRaises(OverflowError, socket.if_indextoname, 2**1000)
         self.assertRaises(TypeError, socket.if_indextoname, '_DEADBEEF')
         if hasattr(socket, 'if_nameindex'):
@@ -1192,6 +1198,7 @@ def testInvalidInterfaceIndexToName(self):
 
     @unittest.skipUnless(hasattr(socket, 'if_nametoindex'),
                          'socket.if_nametoindex() not available.')
+    @support.skip_android_selinux('if_nametoindex')
     def testInvalidInterfaceNameToIndex(self):
         with self.assertRaises(OSError) as cm:
             socket.if_nametoindex("_DEADBEEF")
@@ -1233,24 +1240,24 @@ def testNtoH(self):
             self.assertEqual(swapped & mask, mask)
             self.assertRaises(OverflowError, func, 1<<34)
 
-    @support.cpython_only
-    @unittest.skipIf(_testcapi is None, "requires _testcapi")
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; OverflowError: Python int too large to convert to Rust u16
     def testNtoHErrors(self):
-        import _testcapi
         s_good_values = [0, 1, 2, 0xffff]
         l_good_values = s_good_values + [0xffffffff]
-        l_bad_values = [-1, -2, 1<<32, 1<<1000]
-        s_bad_values = (
-            l_bad_values +
-            [_testcapi.INT_MIN-1, _testcapi.INT_MAX+1] +
-            [1 << 16, _testcapi.INT_MAX]
-        )
+        neg_values = [-1, -2, -(1<<15)-1, -(1<<31)-1, -(1<<63)-1, -1<<1000]
+        l_bad_values = [1<<32, 1<<1000]
+        s_bad_values = l_bad_values + [1 << 16, (1<<31)-1, 1<<31]
         for k in s_good_values:
             socket.ntohs(k)
             socket.htons(k)
         for k in l_good_values:
             socket.ntohl(k)
             socket.htonl(k)
+        for k in neg_values:
+            self.assertRaises(ValueError, socket.ntohs, k)
+            self.assertRaises(ValueError, socket.htons, k)
+            self.assertRaises(ValueError, socket.ntohl, k)
+            self.assertRaises(ValueError, socket.htonl, k)
         for k in s_bad_values:
             self.assertRaises(OverflowError, socket.ntohs, k)
             self.assertRaises(OverflowError, socket.htons, k)
@@ -1595,11 +1602,11 @@ def test_getsockaddrarg(self):
 
     @unittest.skipUnless(os.name == "nt", "Windows specific")
     def test_sock_ioctl(self):
-        self.assertTrue(hasattr(socket.socket, 'ioctl'))
-        self.assertTrue(hasattr(socket, 'SIO_RCVALL'))
-        self.assertTrue(hasattr(socket, 'RCVALL_ON'))
-        self.assertTrue(hasattr(socket, 'RCVALL_OFF'))
-        self.assertTrue(hasattr(socket, 'SIO_KEEPALIVE_VALS'))
+        self.assertHasAttr(socket.socket, 'ioctl')
+        self.assertHasAttr(socket, 'SIO_RCVALL')
+        self.assertHasAttr(socket, 'RCVALL_ON')
+        self.assertHasAttr(socket, 'RCVALL_OFF')
+        self.assertHasAttr(socket, 'SIO_KEEPALIVE_VALS')
         s = socket.socket()
         self.addCleanup(s.close)
         self.assertRaises(ValueError, s.ioctl, -1, None)
@@ -1690,8 +1697,11 @@ def testGetaddrinfo(self):
         # Issue #6697.
         self.assertRaises(UnicodeEncodeError, socket.getaddrinfo, 'localhost', '\uD800')
 
-        # Issue 17269: test workaround for OS X platform bug segfault
         if hasattr(socket, 'AI_NUMERICSERV'):
+            self.assertRaises(socket.gaierror, socket.getaddrinfo, "localhost", "http",
+                              flags=socket.AI_NUMERICSERV)
+
+            # Issue 17269: test workaround for OS X platform bug segfault
             try:
                 # The arguments here are undefined and the call may succeed
                 # or fail.  All we care here is that it doesn't segfault.
@@ -1927,6 +1937,7 @@ def test_getfqdn_filter_localhost(self):
     @unittest.skipIf(sys.platform == 'win32', 'does not work on Windows')
     @unittest.skipIf(AIX, 'Symbolic scope id does not work')
     @unittest.skipUnless(hasattr(socket, 'if_nameindex'), "test needs socket.if_nameindex()")
+    @support.skip_android_selinux('if_nameindex')
     def test_getaddrinfo_ipv6_scopeid_symbolic(self):
         # Just pick up any network interface (Linux, Mac OS X)
         (ifindex, test_interface) = socket.if_nameindex()[0]
@@ -1960,6 +1971,7 @@ def test_getaddrinfo_ipv6_scopeid_numeric(self):
     @unittest.skipIf(sys.platform == 'win32', 'does not work on Windows')
     @unittest.skipIf(AIX, 'Symbolic scope id does not work')
     @unittest.skipUnless(hasattr(socket, 'if_nameindex'), "test needs socket.if_nameindex()")
+    @support.skip_android_selinux('if_nameindex')
     def test_getnameinfo_ipv6_scopeid_symbolic(self):
         # Just pick up any network interface.
         (ifindex, test_interface) = socket.if_nameindex()[0]
@@ -2367,12 +2379,14 @@ def testCreateISOTPSocket(self):
         with socket.socket(socket.PF_CAN, socket.SOCK_DGRAM, socket.CAN_ISOTP) as s:
             pass
 
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; TypeError: AF_CAN address must be a tuple (interface,) or (interface, addr)
     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))
 
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; TypeError: AF_CAN address must be a tuple (interface,) or (interface, addr)
     def testBind(self):
         try:
             with socket.socket(socket.PF_CAN, socket.SOCK_DGRAM, socket.CAN_ISOTP) as s:
@@ -2394,8 +2408,7 @@ def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
         self.interface = "vcan0"
 
-    # TODO: RUSTPYTHON - J1939 constants not fully implemented
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; - J1939 constants not fully implemented
     @unittest.skipUnless(hasattr(socket, "CAN_J1939"),
                          'socket.CAN_J1939 required for this test.')
     def testJ1939Constants(self):
@@ -2437,8 +2450,7 @@ 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
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; - AF_CAN J1939 address format not fully implemented
     def testBind(self):
         try:
             with socket.socket(socket.PF_CAN, socket.SOCK_DGRAM, socket.CAN_J1939) as s:
@@ -2577,6 +2589,7 @@ def testVSOCKConstants(self):
         socket.SO_VM_SOCKETS_BUFFER_MAX_SIZE
         socket.VMADDR_CID_ANY
         socket.VMADDR_PORT_ANY
+        socket.VMADDR_CID_LOCAL
         socket.VMADDR_CID_HOST
         socket.VM_SOCKETS_INVALID_VERSION
         socket.IOCTL_VM_SOCKETS_GET_LOCAL_CID
@@ -2612,23 +2625,88 @@ def testSocketBufferSize(self):
                              socket.SO_VM_SOCKETS_BUFFER_MIN_SIZE))
 
 
-@unittest.skipUnless(HAVE_SOCKET_BLUETOOTH,
+@unittest.skipUnless(hasattr(socket, 'AF_BLUETOOTH'),
                      'Bluetooth sockets required for this test.')
 class BasicBluetoothTest(unittest.TestCase):
 
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AttributeError: module 'socket' has no attribute 'BTPROTO_RFCOMM'
     def testBluetoothConstants(self):
         socket.BDADDR_ANY
         socket.BDADDR_LOCAL
         socket.AF_BLUETOOTH
         socket.BTPROTO_RFCOMM
+        socket.SOL_RFCOMM
+
+        if sys.platform == "win32":
+            socket.SO_BTH_ENCRYPT
+            socket.SO_BTH_MTU
+            socket.SO_BTH_MTU_MAX
+            socket.SO_BTH_MTU_MIN
 
         if sys.platform != "win32":
             socket.BTPROTO_HCI
             socket.SOL_HCI
             socket.BTPROTO_L2CAP
+            socket.SOL_L2CAP
+            socket.BTPROTO_SCO
+            socket.SOL_SCO
+            socket.HCI_DATA_DIR
+
+        if sys.platform == "linux":
+            socket.SOL_BLUETOOTH
+            socket.HCI_DEV_NONE
+            socket.HCI_CHANNEL_RAW
+            socket.HCI_CHANNEL_USER
+            socket.HCI_CHANNEL_MONITOR
+            socket.HCI_CHANNEL_CONTROL
+            socket.HCI_CHANNEL_LOGGING
+            socket.HCI_TIME_STAMP
+            socket.BT_SECURITY
+            socket.BT_SECURITY_SDP
+            socket.BT_FLUSHABLE
+            socket.BT_POWER
+            socket.BT_CHANNEL_POLICY
+            socket.BT_CHANNEL_POLICY_BREDR_ONLY
+            if hasattr(socket, 'BT_PHY'):
+                socket.BT_PHY_BR_1M_1SLOT
+            if hasattr(socket, 'BT_MODE'):
+                socket.BT_MODE_BASIC
+            if hasattr(socket, 'BT_VOICE'):
+                socket.BT_VOICE_TRANSPARENT
+                socket.BT_VOICE_CVSD_16BIT
+            socket.L2CAP_LM
+            socket.L2CAP_LM_MASTER
+            socket.L2CAP_LM_AUTH
+
+        if sys.platform in ("linux", "freebsd"):
+            socket.BDADDR_BREDR
+            socket.BDADDR_LE_PUBLIC
+            socket.BDADDR_LE_RANDOM
+            socket.HCI_FILTER
+
+        if sys.platform.startswith(("freebsd", "netbsd", "dragonfly")):
+            socket.SO_L2CAP_IMTU
+            socket.SO_L2CAP_FLUSH
+            socket.SO_RFCOMM_MTU
+            socket.SO_RFCOMM_FC_INFO
+            socket.SO_SCO_MTU
+
+        if sys.platform == "freebsd":
+            socket.SO_SCO_CONNINFO
+
+        if sys.platform.startswith(("netbsd", "dragonfly")):
+            socket.SO_HCI_EVT_FILTER
+            socket.SO_HCI_PKT_FILTER
+            socket.SO_L2CAP_IQOS
+            socket.SO_L2CAP_LM
+            socket.L2CAP_LM_AUTH
+            socket.SO_RFCOMM_LM
+            socket.RFCOMM_LM_AUTH
+            socket.SO_SCO_HANDLE
 
-            if not sys.platform.startswith("freebsd"):
-                socket.BTPROTO_SCO
+@unittest.skipUnless(HAVE_SOCKET_BLUETOOTH,
+                     'Bluetooth sockets required for this test.')
+class BluetoothTest(unittest.TestCase):
 
     def testCreateRfcommSocket(self):
         with socket.socket(socket.AF_BLUETOOTH, socket.SOCK_STREAM, socket.BTPROTO_RFCOMM) as s:
@@ -2644,12 +2722,31 @@ def testCreateHciSocket(self):
         with socket.socket(socket.AF_BLUETOOTH, socket.SOCK_RAW, socket.BTPROTO_HCI) as s:
             pass
 
-    @unittest.skipIf(sys.platform == "win32" or sys.platform.startswith("freebsd"),
-                     "windows and freebsd do not support SCO sockets")
+    @unittest.skipIf(sys.platform == "win32", "windows does not support SCO sockets")
     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 testBindLeAttL2capSocket(self):
+        BDADDR_LE_PUBLIC = support.get_attribute(socket, 'BDADDR_LE_PUBLIC')
+        with socket.socket(socket.AF_BLUETOOTH, socket.SOCK_SEQPACKET, socket.BTPROTO_L2CAP) as f:
+            # ATT is the only CID allowed in userspace by the Linux kernel
+            CID_ATT = 4
+            f.bind((socket.BDADDR_ANY, 0, CID_ATT, BDADDR_LE_PUBLIC))
+            addr = f.getsockname()
+            self.assertEqual(addr, (socket.BDADDR_ANY, 0, CID_ATT, BDADDR_LE_PUBLIC))
+
+    @unittest.skipUnless(HAVE_SOCKET_BLUETOOTH_L2CAP, 'Bluetooth L2CAP sockets required for this test')
+    def testBindLePsmL2capSocket(self):
+        BDADDR_LE_RANDOM = support.get_attribute(socket, 'BDADDR_LE_RANDOM')
+        with socket.socket(socket.AF_BLUETOOTH, socket.SOCK_SEQPACKET, socket.BTPROTO_L2CAP) as f:
+            # First user PSM in LE L2CAP
+            psm = 0x80
+            f.bind((socket.BDADDR_ANY, psm, 0, BDADDR_LE_RANDOM))
+            addr = f.getsockname()
+            self.assertEqual(addr, (socket.BDADDR_ANY, psm, 0, BDADDR_LE_RANDOM))
+
     @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:
@@ -2663,7 +2760,7 @@ def testBindBrEdrL2capSocket(self):
     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))
+                f.bind((socket.BDADDR_ANY, 0, 0, 0, 0))
             with self.assertRaises(OSError):
                 f.bind((socket.BDADDR_ANY,))
             with self.assertRaises(OSError):
@@ -2710,13 +2807,14 @@ def testBadRfcommAddr(self):
 
     @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')):
+        if sys.platform.startswith(('netbsd', 'dragonfly', 'freebsd')):
+            with socket.socket(socket.AF_BLUETOOTH, socket.SOCK_RAW, socket.BTPROTO_HCI) as s:
                 s.bind(socket.BDADDR_ANY)
                 addr = s.getsockname()
                 self.assertEqual(addr, socket.BDADDR_ANY)
-            else:
-                dev = 0
+        else:
+            dev = 0
+            with socket.socket(socket.AF_BLUETOOTH, socket.SOCK_RAW, socket.BTPROTO_HCI) as s:
                 try:
                     s.bind((dev,))
                 except OSError as err:
@@ -2726,6 +2824,32 @@ def testBindHciSocket(self):
                 addr = s.getsockname()
                 self.assertEqual(addr, dev)
 
+            with (self.subTest('integer'),
+                  socket.socket(socket.AF_BLUETOOTH, socket.SOCK_RAW, socket.BTPROTO_HCI) as s):
+                s.bind(dev)
+                addr = s.getsockname()
+                self.assertEqual(addr, dev)
+
+            with (self.subTest('channel=HCI_CHANNEL_RAW'),
+                  socket.socket(socket.AF_BLUETOOTH, socket.SOCK_RAW, socket.BTPROTO_HCI) as s):
+                channel = socket.HCI_CHANNEL_RAW
+                s.bind((dev, channel))
+                addr = s.getsockname()
+                self.assertEqual(addr, dev)
+
+            with (self.subTest('channel=HCI_CHANNEL_USER'),
+                  socket.socket(socket.AF_BLUETOOTH, socket.SOCK_RAW, socket.BTPROTO_HCI) as s):
+                channel = socket.HCI_CHANNEL_USER
+                try:
+                    s.bind((dev, channel))
+                except OSError as err:
+                    # Needs special permissions.
+                    if err.errno in (errno.EPERM, errno.EBUSY, errno.ERFKILL):
+                        self.skipTest(str(err))
+                    raise
+                addr = s.getsockname()
+                self.assertEqual(addr, (dev, channel))
+
     @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:
@@ -2749,9 +2873,7 @@ def testBadHciAddr(self):
                 with self.assertRaises(OSError):
                     s.bind(())
                 with self.assertRaises(OSError):
-                    s.bind((dev, 0))
-                with self.assertRaises(OSError):
-                    s.bind(dev)
+                    s.bind((dev, socket.HCI_CHANNEL_RAW, 0, 0))
                 with self.assertRaises(OSError):
                     s.bind(socket.BDADDR_ANY)
                 with self.assertRaises(OSError):
@@ -3782,6 +3904,10 @@ def testCMSG_SPACE(self):
         # Test CMSG_SPACE() with various valid and invalid values,
         # checking the assumptions used by sendmsg().
         toobig = self.socklen_t_limit - socket.CMSG_SPACE(1) + 1
+        if SOLARIS and platform.processor() == "sparc":
+            # On Solaris SPARC, number of bytes returned by socket.CMSG_SPACE
+            # increases at different lengths; see gh-91214.
+            toobig -= 3
         values = list(range(257)) + list(range(toobig - 257, toobig))
 
         last = socket.CMSG_SPACE(0)
@@ -3928,6 +4054,7 @@ def _testFDPassCMSG_LEN(self):
         self.createAndSendFDs(1)
 
     @unittest.skipIf(is_apple, "skipping, see issue #12958")
+    @unittest.skipIf(SOLARIS, "skipping, see gh-91214")
     @unittest.skipIf(AIX, "skipping, see issue #22397")
     @requireAttrs(socket, "CMSG_SPACE")
     def testFDPassSeparate(self):
@@ -3939,6 +4066,7 @@ def testFDPassSeparate(self):
 
     @testFDPassSeparate.client_skip
     @unittest.skipIf(is_apple, "skipping, see issue #12958")
+    @unittest.skipIf(SOLARIS, "skipping, see gh-91214")
     @unittest.skipIf(AIX, "skipping, see issue #22397")
     def _testFDPassSeparate(self):
         fd0, fd1 = self.newFDs(2)
@@ -3952,6 +4080,7 @@ def _testFDPassSeparate(self):
             len(MSG))
 
     @unittest.skipIf(is_apple, "skipping, see issue #12958")
+    @unittest.skipIf(SOLARIS, "skipping, see gh-91214")
     @unittest.skipIf(AIX, "skipping, see issue #22397")
     @requireAttrs(socket, "CMSG_SPACE")
     def testFDPassSeparateMinSpace(self):
@@ -3966,6 +4095,7 @@ def testFDPassSeparateMinSpace(self):
 
     @testFDPassSeparateMinSpace.client_skip
     @unittest.skipIf(is_apple, "skipping, see issue #12958")
+    @unittest.skipIf(SOLARIS, "skipping, see gh-91214")
     @unittest.skipIf(AIX, "skipping, see issue #22397")
     def _testFDPassSeparateMinSpace(self):
         fd0, fd1 = self.newFDs(2)
@@ -4998,15 +5128,13 @@ def testInterruptedSendmsgTimeout(self):
 
 
 class TCPCloserTest(ThreadedTCPSocketTest):
-
     def testClose(self):
-        conn, addr = self.serv.accept()
-        conn.close()
+        conn, _ = self.serv.accept()
 
-        sd = self.cli
-        read, write, err = select.select([sd], [], [], 1.0)
-        self.assertEqual(read, [sd])
-        self.assertEqual(sd.recv(1), b'')
+        read, _, _ = select.select([conn], [], [], support.SHORT_TIMEOUT)
+        self.assertEqual(read, [conn])
+        self.assertEqual(conn.recv(1), b'x')
+        conn.close()
 
         # Calling close() many times should be safe.
         conn.close()
@@ -5014,7 +5142,10 @@ def testClose(self):
 
     def _testClose(self):
         self.cli.connect((HOST, self.port))
-        time.sleep(1.0)
+        self.cli.send(b'x')
+        read, _, _ = select.select([self.cli], [], [], support.SHORT_TIMEOUT)
+        self.assertEqual(read, [self.cli])
+        self.assertEqual(self.cli.recv(1), b'')
 
 
 class BasicSocketPairTest(SocketPairTest):
@@ -5973,10 +6104,10 @@ def testTimeoutZero(self):
 class TestExceptions(unittest.TestCase):
 
     def testExceptionTree(self):
-        self.assertTrue(issubclass(OSError, Exception))
-        self.assertTrue(issubclass(socket.herror, OSError))
-        self.assertTrue(issubclass(socket.gaierror, OSError))
-        self.assertTrue(issubclass(socket.timeout, OSError))
+        self.assertIsSubclass(OSError, Exception)
+        self.assertIsSubclass(socket.herror, OSError)
+        self.assertIsSubclass(socket.gaierror, OSError)
+        self.assertIsSubclass(socket.timeout, OSError)
         self.assertIs(socket.error, OSError)
         self.assertIs(socket.timeout, TimeoutError)
 
@@ -6489,8 +6620,6 @@ 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.
@@ -6850,12 +6979,13 @@ 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()
+    def testCount(self):
+        return super().testCount()
 
     @unittest.skip("TODO: RUSTPYTHON; os.sendfile count parameter not handled correctly; flaky")
-    def testCount(self):
-        super().testCount()
+    def testWithTimeout(self):
+        return super().testWithTimeout()
+
 
 @unittest.skipUnless(HAVE_SOCKET_ALG, 'AF_ALG required')
 class LinuxKernelCryptoAPI(unittest.TestCase):
@@ -6873,7 +7003,7 @@ def create_alg(self, typ, name):
 
     # bpo-31705: On kernel older than 4.5, sendto() failed with ENOKEY,
     # at least on ppc64le architecture
-    @unittest.expectedFailure # TODO: RUSTPYTHON - AF_ALG not fully implemented
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; - AF_ALG not fully implemented
     @support.requires_linux_version(4, 5)
     def test_sha256(self):
         expected = bytes.fromhex("ba7816bf8f01cfea414140de5dae2223b00361a396"
@@ -6892,8 +7022,7 @@ def test_sha256(self):
                 op.send(b'')
                 self.assertEqual(op.recv(512), expected)
 
-    # TODO: RUSTPYTHON - AF_ALG not fully implemented
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; - AF_ALG not fully implemented
     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.
@@ -6909,8 +7038,7 @@ 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
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; - AF_ALG not fully implemented
     @support.requires_linux_version(4, 3)
     def test_aes_cbc(self):
         key = bytes.fromhex('06a9214036b8a15b512e03d534120006')
@@ -6952,8 +7080,7 @@ 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
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; - AF_ALG not fully implemented
     @support.requires_linux_version(4, 9)  # see gh-73510
     def test_aead_aes_gcm(self):
         kernel_version = support._get_kernel_version("Linux")
@@ -7023,8 +7150,7 @@ 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
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; - AF_ALG not fully implemented
     @support.requires_linux_version(4, 3)  # see test_aes_cbc
     def test_drbg_pr_sha256(self):
         # deterministic random bit generator, prediction resistance, sha256
@@ -7077,6 +7203,28 @@ class TestMacOSTCPFlags(unittest.TestCase):
     def test_tcp_keepalive(self):
         self.assertTrue(socket.TCP_KEEPALIVE)
 
+@unittest.skipUnless(hasattr(socket, 'TCP_QUICKACK'), 'need socket.TCP_QUICKACK')
+class TestQuickackFlag(unittest.TestCase):
+    def check_set_quickack(self, sock):
+        # quickack already true by default on some OS distributions
+        opt = sock.getsockopt(socket.IPPROTO_TCP, socket.TCP_QUICKACK)
+        if opt:
+            sock.setsockopt(socket.IPPROTO_TCP, socket.TCP_QUICKACK, 0)
+
+        opt = sock.getsockopt(socket.IPPROTO_TCP, socket.TCP_QUICKACK)
+        self.assertFalse(opt)
+
+        sock.setsockopt(socket.IPPROTO_TCP, socket.TCP_QUICKACK, 1)
+
+        opt = sock.getsockopt(socket.IPPROTO_TCP, socket.TCP_QUICKACK)
+        self.assertTrue(opt)
+
+    def test_set_quickack(self):
+        sock = socket.socket(family=socket.AF_INET, type=socket.SOCK_STREAM,
+                             proto=socket.IPPROTO_TCP)
+        with sock:
+            self.check_set_quickack(sock)
+
 
 @unittest.skipUnless(sys.platform.startswith("win"), "requires Windows")
 class TestMSWindowsTCPFlags(unittest.TestCase):
@@ -7090,7 +7238,9 @@ class TestMSWindowsTCPFlags(unittest.TestCase):
                        'TCP_KEEPCNT',
                        # available starting with Windows 10 1709
                        'TCP_KEEPIDLE',
-                       'TCP_KEEPINTVL'
+                       'TCP_KEEPINTVL',
+                       # available starting with Windows 7 / Server 2008 R2
+                       'TCP_QUICKACK',
                        }
 
     def test_new_tcp_flags(self):
@@ -7258,6 +7408,26 @@ def close_fds(fds):
             self.assertEqual(data,  str(index).encode())
 
 
+class FreeThreadingTests(unittest.TestCase):
+
+    def test_close_detach_race(self):
+        s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+
+        def close():
+            for _ in range(1000):
+                s.close()
+
+        def detach():
+            for _ in range(1000):
+                s.detach()
+
+        t1 = threading.Thread(target=close)
+        t2 = threading.Thread(target=detach)
+
+        with threading_helper.start_threads([t1, t2]):
+            pass
+
+
 def setUpModule():
     thread_info = threading_helper.threading_setup()
     unittest.addModuleCleanup(threading_helper.threading_cleanup, *thread_info)
diff --git a/Lib/test/test_sort.py b/Lib/test/test_sort.py
index 37ce489b79f..dfb050a34ec 100644
--- a/Lib/test/test_sort.py
+++ b/Lib/test/test_sort.py
@@ -128,11 +128,31 @@ def bad_key(x):
             x = [e for e, i in augmented] # a stable sort of s
             check("stability", x, s)
 
+    def test_small_stability(self):
+        from itertools import product
+        from operator import itemgetter
+
+        # Exhaustively test stability across all lists of small lengths
+        # and only a few distinct elements.
+        # This can provoke edge cases that randomization is unlikely to find.
+        # But it can grow very expensive quickly, so don't overdo it.
+        NELTS = 3
+        MAXSIZE = 9
+
+        pick0 = itemgetter(0)
+        for length in range(MAXSIZE + 1):
+            # There are NELTS ** length distinct lists.
+            for t in product(range(NELTS), repeat=length):
+                xs = list(zip(t, range(length)))
+                # Stability forced by index in each element.
+                forced = sorted(xs)
+                # Use key= to hide the index from compares.
+                native = sorted(xs, key=pick0)
+                self.assertEqual(forced, native)
 #==============================================================================
 
 class TestBugs(unittest.TestCase):
 
-    @unittest.skip("TODO: RUSTPYTHON; figure out how to detect sort mutation that doesn't change list length")
     def test_bug453523(self):
         # bug 453523 -- list.sort() crasher.
         # If this fails, the most likely outcome is a core dump.
@@ -149,7 +169,6 @@ def __lt__(self, other):
         L = [C() for i in range(50)]
         self.assertRaises(ValueError, L.sort)
 
-    @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 = []
@@ -307,8 +326,7 @@ def test_safe_object_compare(self):
         for L in float_int_lists:
             check_against_PyObject_RichCompareBool(self, L)
 
-    # XXX RUSTPYTHON: added by us but it seems like an implementation detail
-    @support.cpython_only
+    @support.cpython_only  # XXX RUSTPYTHON: added by us but it seems like an implementation detail
     def test_unsafe_object_compare(self):
 
         # This test is by ppperry. It ensures that unsafe_object_compare is
diff --git a/Lib/test/test_sqlite3/test_dbapi.py b/Lib/test/test_sqlite3/test_dbapi.py
index 46f098e4655..8962fe00ed8 100644
--- a/Lib/test/test_sqlite3/test_dbapi.py
+++ b/Lib/test/test_sqlite3/test_dbapi.py
@@ -1088,7 +1088,6 @@ 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')
@@ -1097,7 +1096,6 @@ def test_invalid_array_size(self):
         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()
@@ -1126,7 +1124,6 @@ def test_fetchmany(self):
         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
@@ -1930,7 +1927,6 @@ class MultiprocessTests(unittest.TestCase):
     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:
diff --git a/Lib/test/test_sqlite3/test_factory.py b/Lib/test/test_sqlite3/test_factory.py
index d19b98b2056..2816bd91253 100644
--- a/Lib/test/test_sqlite3/test_factory.py
+++ b/Lib/test/test_sqlite3/test_factory.py
@@ -112,7 +112,6 @@ def test_invalid_factory(self):
 
 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")
diff --git a/Lib/test/test_sqlite3/test_transactions.py b/Lib/test/test_sqlite3/test_transactions.py
index f38d042e598..3b57b7f6a08 100644
--- a/Lib/test/test_sqlite3/test_transactions.py
+++ b/Lib/test/test_sqlite3/test_transactions.py
@@ -31,7 +31,6 @@
 from .util import MemoryDatabaseMixin
 
 
-@unittest.skip("TODO: RUSTPYTHON timeout parameter does not accept int type")
 class TransactionTests(unittest.TestCase):
     def setUp(self):
         # We can disable the busy handlers, since we control
diff --git a/Lib/test/test_ssl.py b/Lib/test/test_ssl.py
index 71b54e286a3..7cfbe0c97dc 100644
--- a/Lib/test/test_ssl.py
+++ b/Lib/test/test_ssl.py
@@ -85,21 +85,8 @@ def data_file(*name):
 CAFILE_NEURONIO = data_file("capath", "4e1295a3.0")
 CAFILE_CACERT = data_file("capath", "5ed36f99.0")
 
-CERTFILE_INFO = {
-    'issuer': ((('countryName', 'XY'),),
-               (('localityName', 'Castle Anthrax'),),
-               (('organizationName', 'Python Software Foundation'),),
-               (('commonName', 'localhost'),)),
-    'notAfter': 'Jan 24 04:21:36 2043 GMT',
-    'notBefore': 'Nov 25 04:21:36 2023 GMT',
-    'serialNumber': '53E14833F7546C29256DD0F034F776C5E983004C',
-    'subject': ((('countryName', 'XY'),),
-             (('localityName', 'Castle Anthrax'),),
-             (('organizationName', 'Python Software Foundation'),),
-             (('commonName', 'localhost'),)),
-    'subjectAltName': (('DNS', 'localhost'),),
-    'version': 3
-}
+with open(data_file('keycert.pem.reference')) as file:
+    CERTFILE_INFO = literal_eval(file.read())
 
 # empty CRL
 CRLFILE = data_file("revocation.crl")
@@ -109,23 +96,8 @@ def data_file(*name):
 SINGED_CERTFILE_ONLY = data_file("cert3.pem")
 SIGNED_CERTFILE_HOSTNAME = 'localhost'
 
-SIGNED_CERTFILE_INFO = {
-    'OCSP': ('http://testca.pythontest.net/testca/ocsp/',),
-    'caIssuers': ('http://testca.pythontest.net/testca/pycacert.cer',),
-    'crlDistributionPoints': ('http://testca.pythontest.net/testca/revocation.crl',),
-    'issuer': ((('countryName', 'XY'),),
-            (('organizationName', 'Python Software Foundation CA'),),
-            (('commonName', 'our-ca-server'),)),
-    'notAfter': 'Oct 28 14:23:16 2037 GMT',
-    'notBefore': 'Aug 29 14:23:16 2018 GMT',
-    'serialNumber': 'CB2D80995A69525C',
-    'subject': ((('countryName', 'XY'),),
-             (('localityName', 'Castle Anthrax'),),
-             (('organizationName', 'Python Software Foundation'),),
-             (('commonName', 'localhost'),)),
-    'subjectAltName': (('DNS', 'localhost'),),
-    'version': 3
-}
+with open(data_file('keycert3.pem.reference')) as file:
+    SIGNED_CERTFILE_INFO = literal_eval(file.read())
 
 SIGNED_CERTFILE2 = data_file("keycert4.pem")
 SIGNED_CERTFILE2_HOSTNAME = 'fakehostname'
@@ -180,7 +152,7 @@ def is_ubuntu():
 
 if is_ubuntu():
     def seclevel_workaround(*ctxs):
-        """"Lower security level to '1' and allow all ciphers for TLS 1.0/1"""
+        """Lower security level to '1' and allow all ciphers for TLS 1.0/1"""
         for ctx in ctxs:
             if (
                 hasattr(ctx, "minimum_version") and
@@ -376,7 +348,7 @@ def test_options(self):
                 value = getattr(ssl, name)
                 self.assertGreaterEqual(value, 0, f"ssl.{name}")
 
-    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AssertionError: TypeError not raised by Certificate
     def test_ssl_types(self):
         ssl_types = [
             _ssl._SSLContext,
@@ -427,6 +399,7 @@ def test_random(self):
         ssl.RAND_add(bytearray(b"this is a random bytearray object"), 75.0)
 
     def test_parse_cert(self):
+        self.maxDiff = None
         # note that this uses an 'unofficial' function in _ssl.c,
         # provided solely for this test, to exercise the certificate
         # parsing code
@@ -568,9 +541,9 @@ def test_openssl_version(self):
             openssl_ver = f"OpenSSL {major:d}.{minor:d}.{patch:d}"
         else:
             openssl_ver = f"OpenSSL {major:d}.{minor:d}.{fix:d}"
-        self.assertTrue(
-            s.startswith((openssl_ver, libressl_ver, "AWS-LC")),
-            (s, t, hex(n))
+        self.assertStartsWith(
+            s, (openssl_ver, libressl_ver, "AWS-LC"),
+            (t, hex(n))
         )
 
     @support.cpython_only
@@ -716,7 +689,7 @@ def test_tls_unique_channel_binding(self):
         with test_wrap_socket(s, server_side=True, certfile=CERTFILE) as ss:
             self.assertIsNone(ss.get_channel_binding("tls-unique"))
 
-    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AssertionError: "<ssl.SSLSocket fd=3, family=2, type=1, proto=0, laddr=('0.0.0.0', 0)>" not found in "unclosed <socket.socket fd=3, family=2, type=1, proto=0, laddr=('0.0.0.0', 0)>"
     def test_dealloc_warn(self):
         ss = test_wrap_socket(socket.socket(socket.AF_INET))
         r = repr(ss)
@@ -1017,7 +990,7 @@ def test_options(self):
         self.assertEqual(0, ctx.options & ~ssl.OP_NO_SSLv3)
 
         # invalid options
-        with self.assertRaises(OverflowError):
+        with self.assertRaises(ValueError):
             ctx.options = -1
         with self.assertRaises(OverflowError):
             ctx.options = 2 ** 100
@@ -1062,7 +1035,7 @@ def test_hostname_checks_common_name(self):
             with self.assertRaises(AttributeError):
                 ctx.hostname_checks_common_name = True
 
-    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AssertionError: <TLSVersion.TLSv1_2: 771> not found in {<TLSVersion.TLSv1: 769>, <TLSVersion.TLSv1_1: 770>, <TLSVersion.SSLv3: 768>}
     @ignore_deprecation
     def test_min_max_version(self):
         ctx = ssl.SSLContext(ssl.PROTOCOL_TLS_SERVER)
@@ -1381,8 +1354,7 @@ def test_load_dh_params(self):
             if Py_DEBUG_WIN32:
                 self.skipTest("not supported on Win32 debug build")
             raise
-        if os.name != 'nt':
-            ctx.load_dh_params(BYTES_DHFILE)
+        ctx.load_dh_params(BYTES_DHFILE)
         self.assertRaises(TypeError, ctx.load_dh_params)
         self.assertRaises(TypeError, ctx.load_dh_params, None)
         with self.assertRaises(FileNotFoundError) as cm:
@@ -1438,7 +1410,7 @@ def dummycallback(sock, servername, ctx):
         ctx.set_servername_callback(None)
         ctx.set_servername_callback(dummycallback)
 
-    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AssertionError: <SSLContext(protocol=17)> is not None
     def test_sni_callback_refcycle(self):
         # Reference cycles through the servername callback are detected
         # and cleared.
@@ -1721,7 +1693,7 @@ def test_lib_reason(self):
         regex = "(NO_START_LINE|UNSUPPORTED_PUBLIC_KEY_TYPE)"
         self.assertRegex(cm.exception.reason, regex)
         s = str(cm.exception)
-        self.assertTrue("NO_START_LINE" in s, s)
+        self.assertIn("NO_START_LINE", s)
 
     def test_subclass(self):
         # Check that the appropriate SSLError subclass is raised
@@ -1736,7 +1708,7 @@ def test_subclass(self):
                 with self.assertRaises(ssl.SSLWantReadError) as cm:
                     c.do_handshake()
                 s = str(cm.exception)
-                self.assertTrue(s.startswith("The operation did not complete (read)"), s)
+                self.assertStartsWith(s, "The operation did not complete (read)")
                 # For compatibility
                 self.assertEqual(cm.exception.errno, ssl.SSL_ERROR_WANT_READ)
 
@@ -2891,12 +2863,13 @@ def test_echo(self):
                 'Cannot create a client socket with a PROTOCOL_TLS_SERVER context',
                 str(e.exception))
 
-    @unittest.skip('TODO: RUSTPYTHON flaky')
+    @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.
         threads = []
 
+        warnings_filters = sys.flags.context_aware_warnings
         global USE_SAME_TEST_CONTEXT
         USE_SAME_TEST_CONTEXT = True
         try:
@@ -2907,7 +2880,7 @@ def test_ssl_in_multiple_threads(self):
                 self.test_crl_check,
                 functools.partial(
                     self.test_check_hostname_idn,
-                    warnings_filters=False,  # gh-126483
+                    warnings_filters=warnings_filters,
                 ),
                 self.test_wrong_cert_tls12,
                 self.test_wrong_cert_tls13,
@@ -4286,7 +4259,7 @@ def servername_cb(ssl_sock, server_name, initial_context):
         self.check_common_name(stats, SIGNED_CERTFILE_HOSTNAME)
         self.assertEqual(calls, [])
 
-    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; + TLSV1_ALERT_ACCESS_DENIED
     def test_sni_callback_alert(self):
         # Returning a TLS alert is reflected to the connecting client
         server_context, other_context, client_context = self.sni_contexts()
@@ -4320,7 +4293,7 @@ def cb_raising(ssl_sock, server_name, initial_context):
             self.assertRegex(cm.exception.reason, regex)
             self.assertEqual(catch.unraisable.exc_type, ZeroDivisionError)
 
-    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AttributeError: 'SSLEOFError' object has no attribute 'reason'
     def test_sni_callback_wrong_return_type(self):
         # Returning the wrong return type terminates the TLS connection
         # with an internal error alert.
@@ -4444,7 +4417,7 @@ def test_session(self):
         self.assertEqual(sess_stat['accept'], 4)
         self.assertEqual(sess_stat['hits'], 2)
 
-    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AssertionError: False != True
     def test_session_handling(self):
         client_context, server_context, hostname = testing_context()
         client_context2, _, _ = testing_context()
@@ -4634,7 +4607,8 @@ def background(sock):
                         raise cm.exc_value
 
 
-@unittest.skipUnless(has_tls_version('TLSv1_3'), "Test needs TLS 1.3")
+@unittest.skipUnless(has_tls_version('TLSv1_3') and ssl.HAS_PHA,
+                     "Test needs TLS 1.3 PHA")
 class TestPostHandshakeAuth(unittest.TestCase):
     def test_pha_setter(self):
         protocols = [
@@ -4660,7 +4634,6 @@ def test_pha_setter(self):
             self.assertEqual(ctx.verify_mode, ssl.CERT_OPTIONAL)
             self.assertEqual(ctx.post_handshake_auth, True)
 
-    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_pha_required(self):
         client_context, server_context, hostname = testing_context()
         server_context.post_handshake_auth = True
@@ -4686,7 +4659,6 @@ def test_pha_required(self):
                 cert_text = s.recv(4096).decode('us-ascii')
                 self.assertIn('Python Software Foundation CA', cert_text)
 
-    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_pha_required_nocert(self):
         client_context, server_context, hostname = testing_context()
         server_context.post_handshake_auth = True
@@ -4728,7 +4700,6 @@ def msg_cb(conn, direction, version, content_type, msg_type, data):
                     # receive alert
                     s.recv(1024)
 
-    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_pha_optional(self):
         if support.verbose:
             sys.stdout.write("\n")
@@ -4753,7 +4724,6 @@ def test_pha_optional(self):
                 s.write(b'HASCERT')
                 self.assertEqual(s.recv(1024), b'TRUE\n')
 
-    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_pha_optional_nocert(self):
         if support.verbose:
             sys.stdout.write("\n")
@@ -4776,7 +4746,6 @@ def test_pha_optional_nocert(self):
                 s.write(b'HASCERT')
                 self.assertEqual(s.recv(1024), b'FALSE\n')
 
-    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_pha_no_pha_client(self):
         client_context, server_context, hostname = testing_context()
         server_context.post_handshake_auth = True
@@ -4793,7 +4762,6 @@ def test_pha_no_pha_client(self):
                 s.write(b'PHA')
                 self.assertIn(b'extension not received', s.recv(1024))
 
-    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_pha_no_pha_server(self):
         # server doesn't have PHA enabled, cert is requested in handshake
         client_context, server_context, hostname = testing_context()
@@ -4831,7 +4799,6 @@ def test_pha_not_tls13(self):
                 s.write(b'PHA')
                 self.assertIn(b'WRONG_SSL_VERSION', s.recv(1024))
 
-    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_bpo37428_pha_cert_none(self):
         # verify that post_handshake_auth does not implicitly enable cert
         # validation.
@@ -5069,7 +5036,7 @@ def msg_cb(conn, direction, version, content_type, msg_type, data):
         with self.assertRaises(TypeError):
             client_context._msg_callback = object()
 
-    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AssertionError: ('read', <TLSVersion.TLSv1_2: 771>, <_TLSContentType.HANDSHAKE: 22>, <_TLSMessageType.SERVER_KEY_EXCHANGE: 12>) not found in []
     def test_msg_callback_tls12(self):
         client_context, server_context, hostname = testing_context()
         client_context.maximum_version = ssl.TLSVersion.TLSv1_2
@@ -5406,7 +5373,7 @@ def test_tlsalerttype(self):
         class Checked_TLSAlertType(enum.IntEnum):
             """Alert types for TLSContentType.ALERT messages
 
-            See RFC 8466, section B.2
+            See RFC 8446, section B.2
             """
             CLOSE_NOTIFY = 0
             UNEXPECTED_MESSAGE = 10
diff --git a/Lib/test/test_stable_abi_ctypes.py b/Lib/test/test_stable_abi_ctypes.py
new file mode 100644
index 00000000000..1e6f69d49e9
--- /dev/null
+++ b/Lib/test/test_stable_abi_ctypes.py
@@ -0,0 +1,1004 @@
+# Generated by Tools/build/stable_abi.py
+
+"""Test that all symbols of the Stable ABI are accessible using ctypes
+"""
+
+import sys
+import unittest
+from test.support.import_helper import import_module
+try:
+    from _testcapi import get_feature_macros
+except ImportError:
+    raise unittest.SkipTest("requires _testcapi")
+
+feature_macros = get_feature_macros()
+
+# Stable ABI is incompatible with Py_TRACE_REFS builds due to PyObject
+# layout differences.
+# See https://github.com/python/cpython/issues/88299#issuecomment-1113366226
+if feature_macros['Py_TRACE_REFS']:
+    raise unittest.SkipTest("incompatible with Py_TRACE_REFS.")
+
+ctypes_test = import_module('ctypes')
+
+class TestStableABIAvailability(unittest.TestCase):
+    def test_available_symbols(self):
+
+        for symbol_name in SYMBOL_NAMES:
+            with self.subTest(symbol_name):
+                ctypes_test.pythonapi[symbol_name]
+
+    def test_feature_macros(self):
+        self.assertEqual(
+            set(get_feature_macros()), EXPECTED_FEATURE_MACROS)
+
+    # The feature macros for Windows are used in creating the DLL
+    # definition, so they must be known on all platforms.
+    # If we are on Windows, we check that the hardcoded data matches
+    # the reality.
+    @unittest.skipIf(sys.platform != "win32", "Windows specific test")
+    def test_windows_feature_macros(self):
+        for name, value in WINDOWS_FEATURE_MACROS.items():
+            if value != 'maybe':
+                with self.subTest(name):
+                    self.assertEqual(feature_macros[name], value)
+
+SYMBOL_NAMES = (
+
+    "PyAIter_Check",
+    "PyArg_Parse",
+    "PyArg_ParseTuple",
+    "PyArg_ParseTupleAndKeywords",
+    "PyArg_UnpackTuple",
+    "PyArg_VaParse",
+    "PyArg_VaParseTupleAndKeywords",
+    "PyArg_ValidateKeywordArguments",
+    "PyBaseObject_Type",
+    "PyBool_FromLong",
+    "PyBool_Type",
+    "PyBuffer_FillContiguousStrides",
+    "PyBuffer_FillInfo",
+    "PyBuffer_FromContiguous",
+    "PyBuffer_GetPointer",
+    "PyBuffer_IsContiguous",
+    "PyBuffer_Release",
+    "PyBuffer_SizeFromFormat",
+    "PyBuffer_ToContiguous",
+    "PyByteArrayIter_Type",
+    "PyByteArray_AsString",
+    "PyByteArray_Concat",
+    "PyByteArray_FromObject",
+    "PyByteArray_FromStringAndSize",
+    "PyByteArray_Resize",
+    "PyByteArray_Size",
+    "PyByteArray_Type",
+    "PyBytesIter_Type",
+    "PyBytes_AsString",
+    "PyBytes_AsStringAndSize",
+    "PyBytes_Concat",
+    "PyBytes_ConcatAndDel",
+    "PyBytes_DecodeEscape",
+    "PyBytes_FromFormat",
+    "PyBytes_FromFormatV",
+    "PyBytes_FromObject",
+    "PyBytes_FromString",
+    "PyBytes_FromStringAndSize",
+    "PyBytes_Repr",
+    "PyBytes_Size",
+    "PyBytes_Type",
+    "PyCFunction_Call",
+    "PyCFunction_GetFlags",
+    "PyCFunction_GetFunction",
+    "PyCFunction_GetSelf",
+    "PyCFunction_New",
+    "PyCFunction_NewEx",
+    "PyCFunction_Type",
+    "PyCMethod_New",
+    "PyCallIter_New",
+    "PyCallIter_Type",
+    "PyCallable_Check",
+    "PyCapsule_GetContext",
+    "PyCapsule_GetDestructor",
+    "PyCapsule_GetName",
+    "PyCapsule_GetPointer",
+    "PyCapsule_Import",
+    "PyCapsule_IsValid",
+    "PyCapsule_New",
+    "PyCapsule_SetContext",
+    "PyCapsule_SetDestructor",
+    "PyCapsule_SetName",
+    "PyCapsule_SetPointer",
+    "PyCapsule_Type",
+    "PyClassMethodDescr_Type",
+    "PyCodec_BackslashReplaceErrors",
+    "PyCodec_Decode",
+    "PyCodec_Decoder",
+    "PyCodec_Encode",
+    "PyCodec_Encoder",
+    "PyCodec_IgnoreErrors",
+    "PyCodec_IncrementalDecoder",
+    "PyCodec_IncrementalEncoder",
+    "PyCodec_KnownEncoding",
+    "PyCodec_LookupError",
+    "PyCodec_NameReplaceErrors",
+    "PyCodec_Register",
+    "PyCodec_RegisterError",
+    "PyCodec_ReplaceErrors",
+    "PyCodec_StreamReader",
+    "PyCodec_StreamWriter",
+    "PyCodec_StrictErrors",
+    "PyCodec_Unregister",
+    "PyCodec_XMLCharRefReplaceErrors",
+    "PyComplex_FromDoubles",
+    "PyComplex_ImagAsDouble",
+    "PyComplex_RealAsDouble",
+    "PyComplex_Type",
+    "PyDescr_NewClassMethod",
+    "PyDescr_NewGetSet",
+    "PyDescr_NewMember",
+    "PyDescr_NewMethod",
+    "PyDictItems_Type",
+    "PyDictIterItem_Type",
+    "PyDictIterKey_Type",
+    "PyDictIterValue_Type",
+    "PyDictKeys_Type",
+    "PyDictProxy_New",
+    "PyDictProxy_Type",
+    "PyDictRevIterItem_Type",
+    "PyDictRevIterKey_Type",
+    "PyDictRevIterValue_Type",
+    "PyDictValues_Type",
+    "PyDict_Clear",
+    "PyDict_Contains",
+    "PyDict_Copy",
+    "PyDict_DelItem",
+    "PyDict_DelItemString",
+    "PyDict_GetItem",
+    "PyDict_GetItemRef",
+    "PyDict_GetItemString",
+    "PyDict_GetItemStringRef",
+    "PyDict_GetItemWithError",
+    "PyDict_Items",
+    "PyDict_Keys",
+    "PyDict_Merge",
+    "PyDict_MergeFromSeq2",
+    "PyDict_New",
+    "PyDict_Next",
+    "PyDict_SetItem",
+    "PyDict_SetItemString",
+    "PyDict_Size",
+    "PyDict_Type",
+    "PyDict_Update",
+    "PyDict_Values",
+    "PyEllipsis_Type",
+    "PyEnum_Type",
+    "PyErr_BadArgument",
+    "PyErr_BadInternalCall",
+    "PyErr_CheckSignals",
+    "PyErr_Clear",
+    "PyErr_Display",
+    "PyErr_DisplayException",
+    "PyErr_ExceptionMatches",
+    "PyErr_Fetch",
+    "PyErr_Format",
+    "PyErr_FormatV",
+    "PyErr_GetExcInfo",
+    "PyErr_GetHandledException",
+    "PyErr_GetRaisedException",
+    "PyErr_GivenExceptionMatches",
+    "PyErr_NewException",
+    "PyErr_NewExceptionWithDoc",
+    "PyErr_NoMemory",
+    "PyErr_NormalizeException",
+    "PyErr_Occurred",
+    "PyErr_Print",
+    "PyErr_PrintEx",
+    "PyErr_ProgramText",
+    "PyErr_ResourceWarning",
+    "PyErr_Restore",
+    "PyErr_SetExcInfo",
+    "PyErr_SetFromErrno",
+    "PyErr_SetFromErrnoWithFilename",
+    "PyErr_SetFromErrnoWithFilenameObject",
+    "PyErr_SetFromErrnoWithFilenameObjects",
+    "PyErr_SetHandledException",
+    "PyErr_SetImportError",
+    "PyErr_SetImportErrorSubclass",
+    "PyErr_SetInterrupt",
+    "PyErr_SetInterruptEx",
+    "PyErr_SetNone",
+    "PyErr_SetObject",
+    "PyErr_SetRaisedException",
+    "PyErr_SetString",
+    "PyErr_SyntaxLocation",
+    "PyErr_SyntaxLocationEx",
+    "PyErr_WarnEx",
+    "PyErr_WarnExplicit",
+    "PyErr_WarnFormat",
+    "PyErr_WriteUnraisable",
+    "PyEval_AcquireLock",
+    "PyEval_AcquireThread",
+    "PyEval_CallFunction",
+    "PyEval_CallMethod",
+    "PyEval_CallObjectWithKeywords",
+    "PyEval_EvalCode",
+    "PyEval_EvalCodeEx",
+    "PyEval_EvalFrame",
+    "PyEval_EvalFrameEx",
+    "PyEval_GetBuiltins",
+    "PyEval_GetFrame",
+    "PyEval_GetFrameBuiltins",
+    "PyEval_GetFrameGlobals",
+    "PyEval_GetFrameLocals",
+    "PyEval_GetFuncDesc",
+    "PyEval_GetFuncName",
+    "PyEval_GetGlobals",
+    "PyEval_GetLocals",
+    "PyEval_InitThreads",
+    "PyEval_ReleaseLock",
+    "PyEval_ReleaseThread",
+    "PyEval_RestoreThread",
+    "PyEval_SaveThread",
+    "PyEval_ThreadsInitialized",
+    "PyExc_ArithmeticError",
+    "PyExc_AssertionError",
+    "PyExc_AttributeError",
+    "PyExc_BaseException",
+    "PyExc_BaseExceptionGroup",
+    "PyExc_BlockingIOError",
+    "PyExc_BrokenPipeError",
+    "PyExc_BufferError",
+    "PyExc_BytesWarning",
+    "PyExc_ChildProcessError",
+    "PyExc_ConnectionAbortedError",
+    "PyExc_ConnectionError",
+    "PyExc_ConnectionRefusedError",
+    "PyExc_ConnectionResetError",
+    "PyExc_DeprecationWarning",
+    "PyExc_EOFError",
+    "PyExc_EncodingWarning",
+    "PyExc_EnvironmentError",
+    "PyExc_Exception",
+    "PyExc_FileExistsError",
+    "PyExc_FileNotFoundError",
+    "PyExc_FloatingPointError",
+    "PyExc_FutureWarning",
+    "PyExc_GeneratorExit",
+    "PyExc_IOError",
+    "PyExc_ImportError",
+    "PyExc_ImportWarning",
+    "PyExc_IndentationError",
+    "PyExc_IndexError",
+    "PyExc_InterruptedError",
+    "PyExc_IsADirectoryError",
+    "PyExc_KeyError",
+    "PyExc_KeyboardInterrupt",
+    "PyExc_LookupError",
+    "PyExc_MemoryError",
+    "PyExc_ModuleNotFoundError",
+    "PyExc_NameError",
+    "PyExc_NotADirectoryError",
+    "PyExc_NotImplementedError",
+    "PyExc_OSError",
+    "PyExc_OverflowError",
+    "PyExc_PendingDeprecationWarning",
+    "PyExc_PermissionError",
+    "PyExc_ProcessLookupError",
+    "PyExc_RecursionError",
+    "PyExc_ReferenceError",
+    "PyExc_ResourceWarning",
+    "PyExc_RuntimeError",
+    "PyExc_RuntimeWarning",
+    "PyExc_StopAsyncIteration",
+    "PyExc_StopIteration",
+    "PyExc_SyntaxError",
+    "PyExc_SyntaxWarning",
+    "PyExc_SystemError",
+    "PyExc_SystemExit",
+    "PyExc_TabError",
+    "PyExc_TimeoutError",
+    "PyExc_TypeError",
+    "PyExc_UnboundLocalError",
+    "PyExc_UnicodeDecodeError",
+    "PyExc_UnicodeEncodeError",
+    "PyExc_UnicodeError",
+    "PyExc_UnicodeTranslateError",
+    "PyExc_UnicodeWarning",
+    "PyExc_UserWarning",
+    "PyExc_ValueError",
+    "PyExc_Warning",
+    "PyExc_ZeroDivisionError",
+    "PyExceptionClass_Name",
+    "PyException_GetArgs",
+    "PyException_GetCause",
+    "PyException_GetContext",
+    "PyException_GetTraceback",
+    "PyException_SetArgs",
+    "PyException_SetCause",
+    "PyException_SetContext",
+    "PyException_SetTraceback",
+    "PyFile_FromFd",
+    "PyFile_GetLine",
+    "PyFile_WriteObject",
+    "PyFile_WriteString",
+    "PyFilter_Type",
+    "PyFloat_AsDouble",
+    "PyFloat_FromDouble",
+    "PyFloat_FromString",
+    "PyFloat_GetInfo",
+    "PyFloat_GetMax",
+    "PyFloat_GetMin",
+    "PyFloat_Type",
+    "PyFrame_GetCode",
+    "PyFrame_GetLineNumber",
+    "PyFrozenSet_New",
+    "PyFrozenSet_Type",
+    "PyGC_Collect",
+    "PyGC_Disable",
+    "PyGC_Enable",
+    "PyGC_IsEnabled",
+    "PyGILState_Ensure",
+    "PyGILState_GetThisThreadState",
+    "PyGILState_Release",
+    "PyGetSetDescr_Type",
+    "PyImport_AddModule",
+    "PyImport_AddModuleObject",
+    "PyImport_AddModuleRef",
+    "PyImport_AppendInittab",
+    "PyImport_ExecCodeModule",
+    "PyImport_ExecCodeModuleEx",
+    "PyImport_ExecCodeModuleObject",
+    "PyImport_ExecCodeModuleWithPathnames",
+    "PyImport_GetImporter",
+    "PyImport_GetMagicNumber",
+    "PyImport_GetMagicTag",
+    "PyImport_GetModule",
+    "PyImport_GetModuleDict",
+    "PyImport_Import",
+    "PyImport_ImportFrozenModule",
+    "PyImport_ImportFrozenModuleObject",
+    "PyImport_ImportModule",
+    "PyImport_ImportModuleLevel",
+    "PyImport_ImportModuleLevelObject",
+    "PyImport_ImportModuleNoBlock",
+    "PyImport_ReloadModule",
+    "PyIndex_Check",
+    "PyInterpreterState_Clear",
+    "PyInterpreterState_Delete",
+    "PyInterpreterState_Get",
+    "PyInterpreterState_GetDict",
+    "PyInterpreterState_GetID",
+    "PyInterpreterState_New",
+    "PyIter_Check",
+    "PyIter_Next",
+    "PyIter_NextItem",
+    "PyIter_Send",
+    "PyListIter_Type",
+    "PyListRevIter_Type",
+    "PyList_Append",
+    "PyList_AsTuple",
+    "PyList_GetItem",
+    "PyList_GetItemRef",
+    "PyList_GetSlice",
+    "PyList_Insert",
+    "PyList_New",
+    "PyList_Reverse",
+    "PyList_SetItem",
+    "PyList_SetSlice",
+    "PyList_Size",
+    "PyList_Sort",
+    "PyList_Type",
+    "PyLongRangeIter_Type",
+    "PyLong_AsDouble",
+    "PyLong_AsInt",
+    "PyLong_AsInt32",
+    "PyLong_AsInt64",
+    "PyLong_AsLong",
+    "PyLong_AsLongAndOverflow",
+    "PyLong_AsLongLong",
+    "PyLong_AsLongLongAndOverflow",
+    "PyLong_AsNativeBytes",
+    "PyLong_AsSize_t",
+    "PyLong_AsSsize_t",
+    "PyLong_AsUInt32",
+    "PyLong_AsUInt64",
+    "PyLong_AsUnsignedLong",
+    "PyLong_AsUnsignedLongLong",
+    "PyLong_AsUnsignedLongLongMask",
+    "PyLong_AsUnsignedLongMask",
+    "PyLong_AsVoidPtr",
+    "PyLong_FromDouble",
+    "PyLong_FromInt32",
+    "PyLong_FromInt64",
+    "PyLong_FromLong",
+    "PyLong_FromLongLong",
+    "PyLong_FromNativeBytes",
+    "PyLong_FromSize_t",
+    "PyLong_FromSsize_t",
+    "PyLong_FromString",
+    "PyLong_FromUInt32",
+    "PyLong_FromUInt64",
+    "PyLong_FromUnsignedLong",
+    "PyLong_FromUnsignedLongLong",
+    "PyLong_FromUnsignedNativeBytes",
+    "PyLong_FromVoidPtr",
+    "PyLong_GetInfo",
+    "PyLong_Type",
+    "PyMap_Type",
+    "PyMapping_Check",
+    "PyMapping_GetItemString",
+    "PyMapping_GetOptionalItem",
+    "PyMapping_GetOptionalItemString",
+    "PyMapping_HasKey",
+    "PyMapping_HasKeyString",
+    "PyMapping_HasKeyStringWithError",
+    "PyMapping_HasKeyWithError",
+    "PyMapping_Items",
+    "PyMapping_Keys",
+    "PyMapping_Length",
+    "PyMapping_SetItemString",
+    "PyMapping_Size",
+    "PyMapping_Values",
+    "PyMarshal_ReadObjectFromString",
+    "PyMarshal_WriteObjectToString",
+    "PyMem_Calloc",
+    "PyMem_Free",
+    "PyMem_Malloc",
+    "PyMem_RawCalloc",
+    "PyMem_RawFree",
+    "PyMem_RawMalloc",
+    "PyMem_RawRealloc",
+    "PyMem_Realloc",
+    "PyMemberDescr_Type",
+    "PyMember_GetOne",
+    "PyMember_SetOne",
+    "PyMemoryView_FromBuffer",
+    "PyMemoryView_FromMemory",
+    "PyMemoryView_FromObject",
+    "PyMemoryView_GetContiguous",
+    "PyMemoryView_Type",
+    "PyMethodDescr_Type",
+    "PyModuleDef_Init",
+    "PyModuleDef_Type",
+    "PyModule_Add",
+    "PyModule_AddFunctions",
+    "PyModule_AddIntConstant",
+    "PyModule_AddObject",
+    "PyModule_AddObjectRef",
+    "PyModule_AddStringConstant",
+    "PyModule_AddType",
+    "PyModule_Create2",
+    "PyModule_ExecDef",
+    "PyModule_FromDefAndSpec2",
+    "PyModule_GetDef",
+    "PyModule_GetDict",
+    "PyModule_GetFilename",
+    "PyModule_GetFilenameObject",
+    "PyModule_GetName",
+    "PyModule_GetNameObject",
+    "PyModule_GetState",
+    "PyModule_New",
+    "PyModule_NewObject",
+    "PyModule_SetDocString",
+    "PyModule_Type",
+    "PyNumber_Absolute",
+    "PyNumber_Add",
+    "PyNumber_And",
+    "PyNumber_AsSsize_t",
+    "PyNumber_Check",
+    "PyNumber_Divmod",
+    "PyNumber_Float",
+    "PyNumber_FloorDivide",
+    "PyNumber_InPlaceAdd",
+    "PyNumber_InPlaceAnd",
+    "PyNumber_InPlaceFloorDivide",
+    "PyNumber_InPlaceLshift",
+    "PyNumber_InPlaceMatrixMultiply",
+    "PyNumber_InPlaceMultiply",
+    "PyNumber_InPlaceOr",
+    "PyNumber_InPlacePower",
+    "PyNumber_InPlaceRemainder",
+    "PyNumber_InPlaceRshift",
+    "PyNumber_InPlaceSubtract",
+    "PyNumber_InPlaceTrueDivide",
+    "PyNumber_InPlaceXor",
+    "PyNumber_Index",
+    "PyNumber_Invert",
+    "PyNumber_Long",
+    "PyNumber_Lshift",
+    "PyNumber_MatrixMultiply",
+    "PyNumber_Multiply",
+    "PyNumber_Negative",
+    "PyNumber_Or",
+    "PyNumber_Positive",
+    "PyNumber_Power",
+    "PyNumber_Remainder",
+    "PyNumber_Rshift",
+    "PyNumber_Subtract",
+    "PyNumber_ToBase",
+    "PyNumber_TrueDivide",
+    "PyNumber_Xor",
+    "PyOS_FSPath",
+    "PyOS_InputHook",
+    "PyOS_InterruptOccurred",
+    "PyOS_double_to_string",
+    "PyOS_getsig",
+    "PyOS_mystricmp",
+    "PyOS_mystrnicmp",
+    "PyOS_setsig",
+    "PyOS_snprintf",
+    "PyOS_string_to_double",
+    "PyOS_strtol",
+    "PyOS_strtoul",
+    "PyOS_vsnprintf",
+    "PyObject_ASCII",
+    "PyObject_AsCharBuffer",
+    "PyObject_AsFileDescriptor",
+    "PyObject_AsReadBuffer",
+    "PyObject_AsWriteBuffer",
+    "PyObject_Bytes",
+    "PyObject_Call",
+    "PyObject_CallFunction",
+    "PyObject_CallFunctionObjArgs",
+    "PyObject_CallMethod",
+    "PyObject_CallMethodObjArgs",
+    "PyObject_CallNoArgs",
+    "PyObject_CallObject",
+    "PyObject_Calloc",
+    "PyObject_CheckBuffer",
+    "PyObject_CheckReadBuffer",
+    "PyObject_ClearWeakRefs",
+    "PyObject_CopyData",
+    "PyObject_DelAttr",
+    "PyObject_DelAttrString",
+    "PyObject_DelItem",
+    "PyObject_DelItemString",
+    "PyObject_Dir",
+    "PyObject_Format",
+    "PyObject_Free",
+    "PyObject_GC_Del",
+    "PyObject_GC_IsFinalized",
+    "PyObject_GC_IsTracked",
+    "PyObject_GC_Track",
+    "PyObject_GC_UnTrack",
+    "PyObject_GenericGetAttr",
+    "PyObject_GenericGetDict",
+    "PyObject_GenericSetAttr",
+    "PyObject_GenericSetDict",
+    "PyObject_GetAIter",
+    "PyObject_GetAttr",
+    "PyObject_GetAttrString",
+    "PyObject_GetBuffer",
+    "PyObject_GetItem",
+    "PyObject_GetIter",
+    "PyObject_GetOptionalAttr",
+    "PyObject_GetOptionalAttrString",
+    "PyObject_GetTypeData",
+    "PyObject_HasAttr",
+    "PyObject_HasAttrString",
+    "PyObject_HasAttrStringWithError",
+    "PyObject_HasAttrWithError",
+    "PyObject_Hash",
+    "PyObject_HashNotImplemented",
+    "PyObject_Init",
+    "PyObject_InitVar",
+    "PyObject_IsInstance",
+    "PyObject_IsSubclass",
+    "PyObject_IsTrue",
+    "PyObject_Length",
+    "PyObject_Malloc",
+    "PyObject_Not",
+    "PyObject_Realloc",
+    "PyObject_Repr",
+    "PyObject_RichCompare",
+    "PyObject_RichCompareBool",
+    "PyObject_SelfIter",
+    "PyObject_SetAttr",
+    "PyObject_SetAttrString",
+    "PyObject_SetItem",
+    "PyObject_Size",
+    "PyObject_Str",
+    "PyObject_Type",
+    "PyObject_Vectorcall",
+    "PyObject_VectorcallMethod",
+    "PyProperty_Type",
+    "PyRangeIter_Type",
+    "PyRange_Type",
+    "PyReversed_Type",
+    "PySeqIter_New",
+    "PySeqIter_Type",
+    "PySequence_Check",
+    "PySequence_Concat",
+    "PySequence_Contains",
+    "PySequence_Count",
+    "PySequence_DelItem",
+    "PySequence_DelSlice",
+    "PySequence_Fast",
+    "PySequence_GetItem",
+    "PySequence_GetSlice",
+    "PySequence_In",
+    "PySequence_InPlaceConcat",
+    "PySequence_InPlaceRepeat",
+    "PySequence_Index",
+    "PySequence_Length",
+    "PySequence_List",
+    "PySequence_Repeat",
+    "PySequence_SetItem",
+    "PySequence_SetSlice",
+    "PySequence_Size",
+    "PySequence_Tuple",
+    "PySetIter_Type",
+    "PySet_Add",
+    "PySet_Clear",
+    "PySet_Contains",
+    "PySet_Discard",
+    "PySet_New",
+    "PySet_Pop",
+    "PySet_Size",
+    "PySet_Type",
+    "PySlice_AdjustIndices",
+    "PySlice_GetIndices",
+    "PySlice_GetIndicesEx",
+    "PySlice_New",
+    "PySlice_Type",
+    "PySlice_Unpack",
+    "PyState_AddModule",
+    "PyState_FindModule",
+    "PyState_RemoveModule",
+    "PyStructSequence_GetItem",
+    "PyStructSequence_New",
+    "PyStructSequence_NewType",
+    "PyStructSequence_SetItem",
+    "PyStructSequence_UnnamedField",
+    "PySuper_Type",
+    "PySys_AddWarnOption",
+    "PySys_AddWarnOptionUnicode",
+    "PySys_AddXOption",
+    "PySys_Audit",
+    "PySys_AuditTuple",
+    "PySys_FormatStderr",
+    "PySys_FormatStdout",
+    "PySys_GetObject",
+    "PySys_GetXOptions",
+    "PySys_HasWarnOptions",
+    "PySys_ResetWarnOptions",
+    "PySys_SetArgv",
+    "PySys_SetArgvEx",
+    "PySys_SetObject",
+    "PySys_SetPath",
+    "PySys_WriteStderr",
+    "PySys_WriteStdout",
+    "PyThreadState_Clear",
+    "PyThreadState_Delete",
+    "PyThreadState_DeleteCurrent",
+    "PyThreadState_Get",
+    "PyThreadState_GetDict",
+    "PyThreadState_GetFrame",
+    "PyThreadState_GetID",
+    "PyThreadState_GetInterpreter",
+    "PyThreadState_New",
+    "PyThreadState_SetAsyncExc",
+    "PyThreadState_Swap",
+    "PyThread_GetInfo",
+    "PyThread_ReInitTLS",
+    "PyThread_acquire_lock",
+    "PyThread_acquire_lock_timed",
+    "PyThread_allocate_lock",
+    "PyThread_create_key",
+    "PyThread_delete_key",
+    "PyThread_delete_key_value",
+    "PyThread_exit_thread",
+    "PyThread_free_lock",
+    "PyThread_get_key_value",
+    "PyThread_get_stacksize",
+    "PyThread_get_thread_ident",
+    "PyThread_init_thread",
+    "PyThread_release_lock",
+    "PyThread_set_key_value",
+    "PyThread_set_stacksize",
+    "PyThread_start_new_thread",
+    "PyThread_tss_alloc",
+    "PyThread_tss_create",
+    "PyThread_tss_delete",
+    "PyThread_tss_free",
+    "PyThread_tss_get",
+    "PyThread_tss_is_created",
+    "PyThread_tss_set",
+    "PyTraceBack_Here",
+    "PyTraceBack_Print",
+    "PyTraceBack_Type",
+    "PyTupleIter_Type",
+    "PyTuple_GetItem",
+    "PyTuple_GetSlice",
+    "PyTuple_New",
+    "PyTuple_Pack",
+    "PyTuple_SetItem",
+    "PyTuple_Size",
+    "PyTuple_Type",
+    "PyType_ClearCache",
+    "PyType_Freeze",
+    "PyType_FromMetaclass",
+    "PyType_FromModuleAndSpec",
+    "PyType_FromSpec",
+    "PyType_FromSpecWithBases",
+    "PyType_GenericAlloc",
+    "PyType_GenericNew",
+    "PyType_GetBaseByToken",
+    "PyType_GetFlags",
+    "PyType_GetFullyQualifiedName",
+    "PyType_GetModule",
+    "PyType_GetModuleByDef",
+    "PyType_GetModuleName",
+    "PyType_GetModuleState",
+    "PyType_GetName",
+    "PyType_GetQualName",
+    "PyType_GetSlot",
+    "PyType_GetTypeDataSize",
+    "PyType_IsSubtype",
+    "PyType_Modified",
+    "PyType_Ready",
+    "PyType_Type",
+    "PyUnicodeDecodeError_Create",
+    "PyUnicodeDecodeError_GetEncoding",
+    "PyUnicodeDecodeError_GetEnd",
+    "PyUnicodeDecodeError_GetObject",
+    "PyUnicodeDecodeError_GetReason",
+    "PyUnicodeDecodeError_GetStart",
+    "PyUnicodeDecodeError_SetEnd",
+    "PyUnicodeDecodeError_SetReason",
+    "PyUnicodeDecodeError_SetStart",
+    "PyUnicodeEncodeError_GetEncoding",
+    "PyUnicodeEncodeError_GetEnd",
+    "PyUnicodeEncodeError_GetObject",
+    "PyUnicodeEncodeError_GetReason",
+    "PyUnicodeEncodeError_GetStart",
+    "PyUnicodeEncodeError_SetEnd",
+    "PyUnicodeEncodeError_SetReason",
+    "PyUnicodeEncodeError_SetStart",
+    "PyUnicodeIter_Type",
+    "PyUnicodeTranslateError_GetEnd",
+    "PyUnicodeTranslateError_GetObject",
+    "PyUnicodeTranslateError_GetReason",
+    "PyUnicodeTranslateError_GetStart",
+    "PyUnicodeTranslateError_SetEnd",
+    "PyUnicodeTranslateError_SetReason",
+    "PyUnicodeTranslateError_SetStart",
+    "PyUnicode_Append",
+    "PyUnicode_AppendAndDel",
+    "PyUnicode_AsASCIIString",
+    "PyUnicode_AsCharmapString",
+    "PyUnicode_AsDecodedObject",
+    "PyUnicode_AsDecodedUnicode",
+    "PyUnicode_AsEncodedObject",
+    "PyUnicode_AsEncodedString",
+    "PyUnicode_AsEncodedUnicode",
+    "PyUnicode_AsLatin1String",
+    "PyUnicode_AsRawUnicodeEscapeString",
+    "PyUnicode_AsUCS4",
+    "PyUnicode_AsUCS4Copy",
+    "PyUnicode_AsUTF16String",
+    "PyUnicode_AsUTF32String",
+    "PyUnicode_AsUTF8AndSize",
+    "PyUnicode_AsUTF8String",
+    "PyUnicode_AsUnicodeEscapeString",
+    "PyUnicode_AsWideChar",
+    "PyUnicode_AsWideCharString",
+    "PyUnicode_BuildEncodingMap",
+    "PyUnicode_Compare",
+    "PyUnicode_CompareWithASCIIString",
+    "PyUnicode_Concat",
+    "PyUnicode_Contains",
+    "PyUnicode_Count",
+    "PyUnicode_Decode",
+    "PyUnicode_DecodeASCII",
+    "PyUnicode_DecodeCharmap",
+    "PyUnicode_DecodeFSDefault",
+    "PyUnicode_DecodeFSDefaultAndSize",
+    "PyUnicode_DecodeLatin1",
+    "PyUnicode_DecodeLocale",
+    "PyUnicode_DecodeLocaleAndSize",
+    "PyUnicode_DecodeRawUnicodeEscape",
+    "PyUnicode_DecodeUTF16",
+    "PyUnicode_DecodeUTF16Stateful",
+    "PyUnicode_DecodeUTF32",
+    "PyUnicode_DecodeUTF32Stateful",
+    "PyUnicode_DecodeUTF7",
+    "PyUnicode_DecodeUTF7Stateful",
+    "PyUnicode_DecodeUTF8",
+    "PyUnicode_DecodeUTF8Stateful",
+    "PyUnicode_DecodeUnicodeEscape",
+    "PyUnicode_EncodeFSDefault",
+    "PyUnicode_EncodeLocale",
+    "PyUnicode_Equal",
+    "PyUnicode_EqualToUTF8",
+    "PyUnicode_EqualToUTF8AndSize",
+    "PyUnicode_FSConverter",
+    "PyUnicode_FSDecoder",
+    "PyUnicode_Find",
+    "PyUnicode_FindChar",
+    "PyUnicode_Format",
+    "PyUnicode_FromEncodedObject",
+    "PyUnicode_FromFormat",
+    "PyUnicode_FromFormatV",
+    "PyUnicode_FromObject",
+    "PyUnicode_FromOrdinal",
+    "PyUnicode_FromString",
+    "PyUnicode_FromStringAndSize",
+    "PyUnicode_FromWideChar",
+    "PyUnicode_GetDefaultEncoding",
+    "PyUnicode_GetLength",
+    "PyUnicode_GetSize",
+    "PyUnicode_InternFromString",
+    "PyUnicode_InternImmortal",
+    "PyUnicode_InternInPlace",
+    "PyUnicode_IsIdentifier",
+    "PyUnicode_Join",
+    "PyUnicode_Partition",
+    "PyUnicode_RPartition",
+    "PyUnicode_RSplit",
+    "PyUnicode_ReadChar",
+    "PyUnicode_Replace",
+    "PyUnicode_Resize",
+    "PyUnicode_RichCompare",
+    "PyUnicode_Split",
+    "PyUnicode_Splitlines",
+    "PyUnicode_Substring",
+    "PyUnicode_Tailmatch",
+    "PyUnicode_Translate",
+    "PyUnicode_Type",
+    "PyUnicode_WriteChar",
+    "PyVectorcall_Call",
+    "PyVectorcall_NARGS",
+    "PyWeakref_GetObject",
+    "PyWeakref_GetRef",
+    "PyWeakref_NewProxy",
+    "PyWeakref_NewRef",
+    "PyWrapperDescr_Type",
+    "PyWrapper_New",
+    "PyZip_Type",
+    "Py_AddPendingCall",
+    "Py_AtExit",
+    "Py_BuildValue",
+    "Py_BytesMain",
+    "Py_CompileString",
+    "Py_DecRef",
+    "Py_DecodeLocale",
+    "Py_EncodeLocale",
+    "Py_EndInterpreter",
+    "Py_EnterRecursiveCall",
+    "Py_Exit",
+    "Py_FatalError",
+    "Py_FileSystemDefaultEncodeErrors",
+    "Py_FileSystemDefaultEncoding",
+    "Py_Finalize",
+    "Py_FinalizeEx",
+    "Py_GenericAlias",
+    "Py_GenericAliasType",
+    "Py_GetArgcArgv",
+    "Py_GetBuildInfo",
+    "Py_GetCompiler",
+    "Py_GetConstant",
+    "Py_GetConstantBorrowed",
+    "Py_GetCopyright",
+    "Py_GetExecPrefix",
+    "Py_GetPath",
+    "Py_GetPlatform",
+    "Py_GetPrefix",
+    "Py_GetProgramFullPath",
+    "Py_GetProgramName",
+    "Py_GetPythonHome",
+    "Py_GetRecursionLimit",
+    "Py_GetVersion",
+    "Py_HasFileSystemDefaultEncoding",
+    "Py_IncRef",
+    "Py_Initialize",
+    "Py_InitializeEx",
+    "Py_Is",
+    "Py_IsFalse",
+    "Py_IsFinalizing",
+    "Py_IsInitialized",
+    "Py_IsNone",
+    "Py_IsTrue",
+    "Py_LeaveRecursiveCall",
+    "Py_Main",
+    "Py_MakePendingCalls",
+    "Py_NewInterpreter",
+    "Py_NewRef",
+    "Py_PACK_FULL_VERSION",
+    "Py_PACK_VERSION",
+    "Py_REFCNT",
+    "Py_ReprEnter",
+    "Py_ReprLeave",
+    "Py_SetPath",
+    "Py_SetProgramName",
+    "Py_SetPythonHome",
+    "Py_SetRecursionLimit",
+    "Py_TYPE",
+    "Py_UTF8Mode",
+    "Py_VaBuildValue",
+    "Py_Version",
+    "Py_XNewRef",
+    "_PyArg_ParseTupleAndKeywords_SizeT",
+    "_PyArg_ParseTuple_SizeT",
+    "_PyArg_Parse_SizeT",
+    "_PyArg_VaParseTupleAndKeywords_SizeT",
+    "_PyArg_VaParse_SizeT",
+    "_PyErr_BadInternalCall",
+    "_PyObject_CallFunction_SizeT",
+    "_PyObject_CallMethod_SizeT",
+    "_PyObject_GC_New",
+    "_PyObject_GC_NewVar",
+    "_PyObject_GC_Resize",
+    "_PyObject_New",
+    "_PyObject_NewVar",
+    "_PyState_AddModule",
+    "_PyThreadState_Init",
+    "_PyThreadState_Prealloc",
+    "_PyWeakref_CallableProxyType",
+    "_PyWeakref_ProxyType",
+    "_PyWeakref_RefType",
+    "_Py_BuildValue_SizeT",
+    "_Py_CheckRecursiveCall",
+    "_Py_Dealloc",
+    "_Py_DecRef",
+    "_Py_EllipsisObject",
+    "_Py_FalseStruct",
+    "_Py_IncRef",
+    "_Py_NoneStruct",
+    "_Py_NotImplementedStruct",
+    "_Py_SetRefcnt",
+    "_Py_SwappedOp",
+    "_Py_TrueStruct",
+    "_Py_VaBuildValue_SizeT",
+)
+if feature_macros['HAVE_FORK']:
+    SYMBOL_NAMES += (
+        'PyOS_AfterFork',
+        'PyOS_AfterFork_Child',
+        'PyOS_AfterFork_Parent',
+        'PyOS_BeforeFork',
+    )
+if feature_macros['MS_WINDOWS']:
+    SYMBOL_NAMES += (
+        'PyErr_SetExcFromWindowsErr',
+        'PyErr_SetExcFromWindowsErrWithFilename',
+        'PyErr_SetExcFromWindowsErrWithFilenameObject',
+        'PyErr_SetExcFromWindowsErrWithFilenameObjects',
+        'PyErr_SetFromWindowsErr',
+        'PyErr_SetFromWindowsErrWithFilename',
+        'PyExc_WindowsError',
+        'PyUnicode_AsMBCSString',
+        'PyUnicode_DecodeCodePageStateful',
+        'PyUnicode_DecodeMBCS',
+        'PyUnicode_DecodeMBCSStateful',
+        'PyUnicode_EncodeCodePage',
+    )
+if feature_macros['PY_HAVE_THREAD_NATIVE_ID']:
+    SYMBOL_NAMES += (
+        'PyThread_get_thread_native_id',
+    )
+if feature_macros['Py_REF_DEBUG']:
+    SYMBOL_NAMES += (
+        '_Py_NegativeRefcount',
+        '_Py_RefTotal',
+    )
+if feature_macros['Py_TRACE_REFS']:
+    SYMBOL_NAMES += (
+    )
+if feature_macros['USE_STACKCHECK']:
+    SYMBOL_NAMES += (
+        'PyOS_CheckStack',
+    )
+
+EXPECTED_FEATURE_MACROS = set(['HAVE_FORK',
+ 'MS_WINDOWS',
+ 'PY_HAVE_THREAD_NATIVE_ID',
+ 'Py_REF_DEBUG',
+ 'Py_TRACE_REFS',
+ 'USE_STACKCHECK'])
+WINDOWS_FEATURE_MACROS = {'HAVE_FORK': False,
+ 'MS_WINDOWS': True,
+ 'PY_HAVE_THREAD_NATIVE_ID': True,
+ 'Py_REF_DEBUG': 'maybe',
+ 'Py_TRACE_REFS': 'maybe',
+ 'USE_STACKCHECK': 'maybe'}
diff --git a/Lib/test/test_stat.py b/Lib/test/test_stat.py
index 49013a4bcd8..a83f7d076f0 100644
--- a/Lib/test/test_stat.py
+++ b/Lib/test/test_stat.py
@@ -157,12 +157,17 @@ def test_mode(self):
 
             os.chmod(TESTFN, 0o700)
             st_mode, modestr = self.get_mode()
-            self.assertEqual(modestr[:3], '-rw')
+            self.assertStartsWith(modestr, '-rw')
             self.assertS_IS("REG", st_mode)
             self.assertEqual(self.statmod.S_IFMT(st_mode),
                              self.statmod.S_IFREG)
             self.assertEqual(self.statmod.S_IMODE(st_mode), 0o666)
 
+    def test_filemode_does_not_misclassify_random_bits(self):
+        # gh-144050 regression test
+        self.assertEqual(self.statmod.filemode(0o77777)[0], "?")
+        self.assertEqual(self.statmod.filemode(0o177777)[0], "?")
+
     @os_helper.skip_unless_working_chmod
     def test_directory(self):
         os.mkdir(TESTFN)
@@ -256,7 +261,7 @@ def test_flags_consistent(self):
                          "FILE_ATTRIBUTE_* constants are Win32 specific")
     def test_file_attribute_constants(self):
         for key, value in sorted(self.file_attributes.items()):
-            self.assertTrue(hasattr(self.statmod, key), key)
+            self.assertHasAttr(self.statmod, key)
             modvalue = getattr(self.statmod, key)
             self.assertEqual(value, modvalue, key)
 
@@ -314,7 +319,7 @@ def test_macosx_attribute_values(self):
         self.assertEqual(self.statmod.S_ISGID, 0o002000)
         self.assertEqual(self.statmod.S_ISVTX, 0o001000)
 
-        self.assertFalse(hasattr(self.statmod, "S_ISTXT"))
+        self.assertNotHasAttr(self.statmod, "S_ISTXT")
         self.assertEqual(self.statmod.S_IREAD, self.statmod.S_IRUSR)
         self.assertEqual(self.statmod.S_IWRITE, self.statmod.S_IWUSR)
         self.assertEqual(self.statmod.S_IEXEC, self.statmod.S_IXUSR)
diff --git a/Lib/test/test_statistics.py b/Lib/test/test_statistics.py
index 9c2714e99d4..e0b74432c94 100644
--- a/Lib/test/test_statistics.py
+++ b/Lib/test/test_statistics.py
@@ -645,7 +645,7 @@ def do_test(self, args):
 
     def test_numerictestcase_is_testcase(self):
         # Ensure that NumericTestCase actually is a TestCase.
-        self.assertTrue(issubclass(NumericTestCase, unittest.TestCase))
+        self.assertIsSubclass(NumericTestCase, unittest.TestCase)
 
     def test_error_msg_numeric(self):
         # Test the error message generated for numeric comparisons.
@@ -683,32 +683,23 @@ class GlobalsTest(unittest.TestCase):
     def test_meta(self):
         # Test for the existence of metadata.
         for meta in self.expected_metadata:
-            self.assertTrue(hasattr(self.module, meta),
-                            "%s not present" % meta)
+            self.assertHasAttr(self.module, meta)
 
     def test_check_all(self):
         # Check everything in __all__ exists and is public.
         module = self.module
         for name in module.__all__:
             # No private names in __all__:
-            self.assertFalse(name.startswith("_"),
+            self.assertNotStartsWith(name, "_",
                              'private name "%s" in __all__' % name)
             # And anything in __all__ must exist:
-            self.assertTrue(hasattr(module, name),
-                            'missing name "%s" in __all__' % name)
+            self.assertHasAttr(module, name)
 
 
 class StatisticsErrorTest(unittest.TestCase):
     def test_has_exception(self):
-        errmsg = (
-                "Expected StatisticsError to be a ValueError, but got a"
-                " subclass of %r instead."
-                )
-        self.assertTrue(hasattr(statistics, 'StatisticsError'))
-        self.assertTrue(
-                issubclass(statistics.StatisticsError, ValueError),
-                errmsg % statistics.StatisticsError.__base__
-                )
+        self.assertHasAttr(statistics, 'StatisticsError')
+        self.assertIsSubclass(statistics.StatisticsError, ValueError)
 
 
 # === Tests for private utility functions ===
@@ -2014,7 +2005,6 @@ def test_iter_list_same(self):
         expected = self.func(data)
         self.assertEqual(self.func(iter(data)), expected)
 
-
 class TestPVariance(VarianceStdevMixin, NumericTestCase, UnivariateTypeMixin):
     # Tests for population variance.
     def setUp(self):
@@ -2122,6 +2112,14 @@ def test_center_not_at_mean(self):
         self.assertEqual(self.func(data), 2.5)
         self.assertEqual(self.func(data, mu=0.5), 6.5)
 
+    def test_gh_140938(self):
+        # Inputs with inf/nan should raise a ValueError
+        with self.assertRaises(ValueError):
+            self.func([1.0, math.inf])
+        with self.assertRaises(ValueError):
+            self.func([1.0, math.nan])
+
+
 class TestSqrtHelpers(unittest.TestCase):
 
     def test_integer_sqrt_of_frac_rto(self):
@@ -2435,17 +2433,22 @@ def integrate(func, low, high, steps=10_000):
         data.append(100)
         self.assertGreater(f_hat(100), 0.0)
 
-    def test_kde_kernel_invcdfs(self):
-        kernel_invcdfs = statistics._kernel_invcdfs
-        kde = statistics.kde
+    def test_kde_kernel_specs(self):
+        # White-box test for the kernel formulas in isolation from
+        # their downstream use in kde() and kde_random()
+        kernel_specs = statistics._kernel_specs
 
         # Verify that cdf / invcdf will round trip
         xarr = [i/100 for i in range(-100, 101)]
-        for kernel, invcdf in kernel_invcdfs.items():
+        parr = [i/1000 + 5/10000 for i in range(1000)]
+        for kernel, spec in kernel_specs.items():
+            cdf = spec['cdf']
+            invcdf = spec['invcdf']
             with self.subTest(kernel=kernel):
-                cdf = kde([0.0], h=1.0, kernel=kernel, cumulative=True)
                 for x in xarr:
-                    self.assertAlmostEqual(invcdf(cdf(x)), x, places=5)
+                    self.assertAlmostEqual(invcdf(cdf(x)), x, places=6)
+                for p in parr:
+                    self.assertAlmostEqual(cdf(invcdf(p)), p, places=11)
 
     @support.requires_resource('cpu')
     def test_kde_random(self):
@@ -2797,7 +2800,7 @@ def test_sqrtprod_helper_function_fundamentals(self):
     @requires_IEEE_754
     @unittest.skipIf(HAVE_DOUBLE_ROUNDING,
                      "accuracy not guaranteed on machines with double rounding")
-    @support.cpython_only    # Allow for a weaker sumprod() implmentation
+    @support.cpython_only    # Allow for a weaker sumprod() implementation
     def test_sqrtprod_helper_function_improved_accuracy(self):
         # Test a known example where accuracy is improved
         x, y, target = 0.8035720646477457, 0.7957468097636939, 0.7996498651651661
diff --git a/Lib/test/test_str.py b/Lib/test/test_str.py
index 6b766272a3f..68037923283 100644
--- a/Lib/test/test_str.py
+++ b/Lib/test/test_str.py
@@ -112,7 +112,6 @@ def test_literals(self):
         # raw strings should not have unicode escapes
         self.assertNotEqual(r"\u0020", " ")
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_ascii(self):
         self.assertEqual(ascii('abc'), "'abc'")
         self.assertEqual(ascii('ab\\c'), "'ab\\\\c'")
@@ -793,7 +792,7 @@ def test_isdecimal(self):
         for ch in ['\U0001D7F6', '\U00011066', '\U000104A0']:
             self.assertTrue(ch.isdecimal(), '{!a} is decimal.'.format(ch))
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AssertionError: False != True
     def test_isdigit(self):
         super().test_isdigit()
         self.checkequalnofix(True, '\u2460', 'isdigit')
@@ -855,6 +854,7 @@ def test_isprintable(self):
         self.assertTrue('\U0001F46F'.isprintable())
         self.assertFalse('\U000E0020'.isprintable())
 
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     @support.requires_resource('cpu')
     def test_isprintable_invariant(self):
         for codepoint in range(sys.maxunicode + 1):
@@ -939,7 +939,7 @@ def test_upper(self):
         self.assertEqual('\U0008fffe'.upper(), '\U0008fffe')
         self.assertEqual('\u2177'.upper(), '\u2167')
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; ?   ^
     def test_capitalize(self):
         string_tests.StringLikeTest.test_capitalize(self)
         self.assertEqual('\U0001044F'.capitalize(), '\U00010427')
@@ -957,7 +957,7 @@ def test_capitalize(self):
         self.assertEqual('finnish'.capitalize(), 'Finnish')
         self.assertEqual('A\u0345\u03a3'.capitalize(), 'A\u0345\u03c2')
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; ?  ^
     def test_title(self):
         super().test_title()
         self.assertEqual('\U0001044F'.title(), '\U00010427')
@@ -975,7 +975,7 @@ def test_title(self):
         self.assertEqual('A\u03a3 \u1fa1xy'.title(), 'A\u03c2 \u1fa9xy')
         self.assertEqual('A\u03a3A'.title(), 'A\u03c3a')
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; + 𐐧
     def test_swapcase(self):
         string_tests.StringLikeTest.test_swapcase(self)
         self.assertEqual('\U0001044F'.swapcase(), '\U00010427')
@@ -1075,7 +1075,7 @@ def test_issue18183(self):
         '\U00100000'.ljust(3, '\U00010000')
         '\U00100000'.rjust(3, '\U00010000')
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; ?   +
     def test_format(self):
         self.assertEqual(''.format(), '')
         self.assertEqual('a'.format(), 'a')
@@ -1464,13 +1464,13 @@ def test_format_huge_precision(self):
         with self.assertRaises(ValueError):
             result = format(2.34, format_string)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AssertionError: ValueError not raised
     def test_format_huge_width(self):
         format_string = "{}f".format(sys.maxsize + 1)
         with self.assertRaises(ValueError):
             result = format(2.34, format_string)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; IndexError: tuple index out of range
     def test_format_huge_item_number(self):
         format_string = "{{{}:.6f}}".format(sys.maxsize + 1)
         with self.assertRaises(ValueError):
@@ -1506,7 +1506,7 @@ def __format__(self, spec):
         self.assertEqual('{:{f}}{g}{}'.format(1, 3, g='g', f=2), ' 1g3')
         self.assertEqual('{f:{}}{}{g}'.format(2, 4, f=1, g='g'), ' 14g')
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; TypeError: %x format: an integer is required, not PseudoInt
     def test_formatting(self):
         string_tests.StringLikeTest.test_formatting(self)
         # Testing Unicode formatting strings...
@@ -1597,7 +1597,7 @@ def __int__(self):
         self.assertRaisesRegex(TypeError, '%u format: a real number is required, not complex', operator.mod, '%u', 3j)
         self.assertRaisesRegex(TypeError, '%i format: a real number is required, not complex', operator.mod, '%i', 2j)
         self.assertRaisesRegex(TypeError, '%d format: a real number is required, not complex', operator.mod, '%d', 1j)
-        self.assertRaisesRegex(TypeError, '%c requires int or char', operator.mod, '%c', pi)
+        self.assertRaisesRegex(TypeError, r'%c requires an int or a unicode character, not .*\.PseudoFloat', operator.mod, '%c', pi)
 
         class RaisingNumber:
             def __int__(self):
@@ -1755,7 +1755,7 @@ def __str__(self):
             'character buffers are decoded to unicode'
         )
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; Pass various keyword argument combinations to the constructor.
     def test_constructor_keyword_args(self):
         """Pass various keyword argument combinations to the constructor."""
         # The object argument can be passed as a keyword.
@@ -1765,7 +1765,7 @@ def test_constructor_keyword_args(self):
         self.assertEqual(str(b'foo', errors='strict'), 'foo')  # not "b'foo'"
         self.assertEqual(str(object=b'foo', errors='strict'), 'foo')
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; Check the constructor argument defaults.
     def test_constructor_defaults(self):
         """Check the constructor argument defaults."""
         # The object argument defaults to '' or b''.
@@ -1777,7 +1777,6 @@ def test_constructor_defaults(self):
         # The errors argument defaults to strict.
         self.assertRaises(UnicodeDecodeError, str, utf8_cent, encoding='ascii')
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_codecs_utf7(self):
         utfTests = [
             ('A\u2262\u0391.', b'A+ImIDkQ.'),             # RFC2152 example
@@ -2287,7 +2286,6 @@ def test_codecs_errors(self):
         self.assertRaises(ValueError, complex, "\ud800")
         self.assertRaises(ValueError, complex, "\udf00")
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_codecs(self):
         # Encoding
         self.assertEqual('hello'.encode('ascii'), b'hello')
@@ -2417,7 +2415,7 @@ def test_ucs4(self):
         else:
             self.fail("Should have raised UnicodeDecodeError")
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AssertionError: <class 'str'> is not <class 'test.test_str.StrSubclass'>
     def test_conversion(self):
         # Make sure __str__() works properly
         class StrWithStr(str):
@@ -2460,8 +2458,10 @@ def __repr__(self):
         self.assertEqual(repr(s1()), '\\n')
 
     def test_printable_repr(self):
-        self.assertEqual(repr('\U00010000'), "'%c'" % (0x10000,)) # printable
-        self.assertEqual(repr('\U00014000'), "'\\U00014000'")     # nonprintable
+        # printable
+        self.assertEqual(repr('\U00010000'), "'%c'" % (0x10000,))
+        # nonprintable (private use area)
+        self.assertEqual(repr('\U00100001'), "'\\U00100001'")
 
     # 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
@@ -2476,7 +2476,7 @@ def test_expandtabs_optimization(self):
         s = 'abc'
         self.assertIs(s.expandtabs(), s)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_raiseMemError(self):
         asciifields = "nnb"
         compactfields = asciifields + "nP"
@@ -2616,12 +2616,13 @@ def test_compare(self):
         self.assertTrue(astral >= bmp2)
         self.assertFalse(astral >= astral2)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AssertionError: False is not true
     def test_free_after_iterating(self):
         support.check_free_after_iterating(self, iter, str)
-        support.check_free_after_iterating(self, reversed, str)
+        if not support.Py_GIL_DISABLED:
+            support.check_free_after_iterating(self, reversed, str)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AssertionError: 22 != 10 : _PythonRunResult(rc=22, out=b'', err=b'')
     def test_check_encoding_errors(self):
         # bpo-37388: str(bytes) and str.decode() must check encoding and errors
         # arguments in dev mode
@@ -2682,7 +2683,7 @@ def test_check_encoding_errors(self):
         proc = assert_python_failure('-X', 'dev', '-c', code)
         self.assertEqual(proc.rc, 10, proc)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AssertionError: "str expected at most 3 arguments, got 4" does not match "expected at most 3 arguments, got 4"
     def test_str_invalid_call(self):
         # too many args
         with self.assertRaisesRegex(TypeError, r"str expected at most 3 arguments, got 4"):
diff --git a/Lib/test/test_strftime.py b/Lib/test/test_strftime.py
index be43c49e40a..375f6aaedd8 100644
--- a/Lib/test/test_strftime.py
+++ b/Lib/test/test_strftime.py
@@ -39,7 +39,21 @@ def _update_variables(self, now):
         if now[3] < 12: self.ampm='(AM|am)'
         else: self.ampm='(PM|pm)'
 
-        self.jan1 = time.localtime(time.mktime((now[0], 1, 1, 0, 0, 0, 0, 1, 0)))
+        jan1 = time.struct_time(
+            (
+                now.tm_year,  # Year
+                1,  # Month (January)
+                1,  # Day (1st)
+                0,  # Hour (0)
+                0,  # Minute (0)
+                0,  # Second (0)
+                -1,  # tm_wday (will be determined)
+                1,  # tm_yday (day 1 of the year)
+                -1,  # tm_isdst (let the system determine)
+            )
+        )
+        # use mktime to get the correct tm_wday and tm_isdst values
+        self.jan1 = time.localtime(time.mktime(jan1))
 
         try:
             if now[8]: self.tz = time.tzname[1]
@@ -54,14 +68,10 @@ def _update_variables(self, now):
         self.now = now
 
     def setUp(self):
-        try:
-            import java
-            java.util.Locale.setDefault(java.util.Locale.US)
-        except ImportError:
-            from locale import setlocale, LC_TIME
-            saved_locale = setlocale(LC_TIME)
-            setlocale(LC_TIME, 'C')
-            self.addCleanup(setlocale, LC_TIME, saved_locale)
+        from locale import setlocale, LC_TIME
+        saved_locale = setlocale(LC_TIME)
+        setlocale(LC_TIME, 'C')
+        self.addCleanup(setlocale, LC_TIME, saved_locale)
 
     def test_strftime(self):
         now = time.time()
@@ -187,8 +197,7 @@ class Y1900Tests(unittest.TestCase):
     def test_y_before_1900(self):
         # Issue #13674, #19634
         t = (1899, 1, 1, 0, 0, 0, 0, 0, 0)
-        if (sys.platform == "win32"
-        or sys.platform.startswith(("aix", "sunos", "solaris"))):
+        if sys.platform.startswith(("aix", "sunos", "solaris")):
             with self.assertRaises(ValueError):
                 time.strftime("%y", t)
         else:
diff --git a/Lib/test/test_string/__init__.py b/Lib/test/test_string/__init__.py
new file mode 100644
index 00000000000..4b16ecc3115
--- /dev/null
+++ b/Lib/test/test_string/__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_string/_support.py b/Lib/test/test_string/_support.py
new file mode 100644
index 00000000000..cfead782b7d
--- /dev/null
+++ b/Lib/test/test_string/_support.py
@@ -0,0 +1,67 @@
+import unittest
+from string.templatelib import Interpolation
+
+
+class TStringBaseCase:
+    def assertInterpolationEqual(self, i, exp):
+        """Test Interpolation equality.
+
+        The *i* argument must be an Interpolation instance.
+
+        The *exp* argument must be a tuple of the form
+        (value, expression, conversion, format_spec) where the final three
+        items may be omitted and are assumed to be '', None and '' respectively.
+        """
+        if len(exp) == 4:
+            actual = (i.value, i.expression, i.conversion, i.format_spec)
+            self.assertEqual(actual, exp)
+        elif len(exp) == 3:
+            self.assertEqual((i.value, i.expression, i.conversion), exp)
+            self.assertEqual(i.format_spec, "")
+        elif len(exp) == 2:
+            self.assertEqual((i.value, i.expression), exp)
+            self.assertEqual(i.conversion, None)
+            self.assertEqual(i.format_spec, "")
+        elif len(exp) == 1:
+            self.assertEqual((i.value,), exp)
+            self.assertEqual(i.expression, "")
+            self.assertEqual(i.conversion, None)
+            self.assertEqual(i.format_spec, "")
+
+    def assertTStringEqual(self, t, strings, interpolations):
+        """Test template string literal equality.
+
+        The *strings* argument must be a tuple of strings equal to *t.strings*.
+
+        The *interpolations* argument must be a sequence of tuples which are
+        compared against *t.interpolations*. Each tuple must match the form
+        described in the `assertInterpolationEqual` method.
+        """
+        self.assertEqual(t.strings, strings)
+        self.assertEqual(len(t.interpolations), len(interpolations))
+
+        for i, exp in zip(t.interpolations, interpolations, strict=True):
+            self.assertInterpolationEqual(i, exp)
+
+
+def convert(value, conversion):
+    if conversion == "a":
+        return ascii(value)
+    elif conversion == "r":
+        return repr(value)
+    elif conversion == "s":
+        return str(value)
+    return value
+
+
+def fstring(template):
+    parts = []
+    for item in template:
+        match item:
+            case str() as s:
+                parts.append(s)
+            case Interpolation(value, _, conversion, format_spec):
+                value = convert(value, conversion)
+                value = format(value, format_spec)
+                parts.append(value)
+    return "".join(parts)
diff --git a/Lib/test/test_string.py b/Lib/test/test_string/test_string.py
similarity index 95%
rename from Lib/test/test_string.py
rename to Lib/test/test_string/test_string.py
index 824b89ad517..5394fe4e12c 100644
--- a/Lib/test/test_string.py
+++ b/Lib/test/test_string/test_string.py
@@ -1,6 +1,15 @@
 import unittest
 import string
 from string import Template
+import types
+from test.support import cpython_only
+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", "collections"})
 
 
 class ModuleTest(unittest.TestCase):
@@ -101,6 +110,24 @@ def test_index_lookup(self):
         with self.assertRaises(KeyError):
             fmt.format("{0[2]}{0[0]}", {})
 
+    def test_auto_numbering_lookup(self):
+        fmt = string.Formatter()
+        namespace = types.SimpleNamespace(foo=types.SimpleNamespace(bar='baz'))
+        widths = [None, types.SimpleNamespace(qux=4)]
+        self.assertEqual(
+            fmt.format("{.foo.bar:{[1].qux}}", namespace, widths), 'baz ')
+
+    def test_auto_numbering_reenterability(self):
+        class ReenteringFormatter(string.Formatter):
+            def format_field(self, value, format_spec):
+                if format_spec.isdigit() and int(format_spec) > 0:
+                    return self.format('{:{}}!', value, int(format_spec) - 1)
+                else:
+                    return super().format_field(value, format_spec)
+        fmt = ReenteringFormatter()
+        x = types.SimpleNamespace(a='X')
+        self.assertEqual(fmt.format('{.a:{}}', x, 3), 'X!!!')
+
     def test_override_get_value(self):
         class NamespaceFormatter(string.Formatter):
             def __init__(self, namespace={}):
diff --git a/Lib/test/test_string/test_templatelib.py b/Lib/test/test_string/test_templatelib.py
new file mode 100644
index 00000000000..1c86717155f
--- /dev/null
+++ b/Lib/test/test_string/test_templatelib.py
@@ -0,0 +1,193 @@
+import pickle
+import unittest
+from collections.abc import Iterator, Iterable
+from string.templatelib import Template, Interpolation, convert
+
+from test.test_string._support import TStringBaseCase, fstring
+
+
+class TestTemplate(unittest.TestCase, TStringBaseCase):
+
+    def test_common(self):
+        self.assertEqual(type(t'').__name__, 'Template')
+        self.assertEqual(type(t'').__qualname__, 'Template')
+        self.assertEqual(type(t'').__module__, 'string.templatelib')
+
+        a = 'a'
+        i = t'{a}'.interpolations[0]
+        self.assertEqual(type(i).__name__, 'Interpolation')
+        self.assertEqual(type(i).__qualname__, 'Interpolation')
+        self.assertEqual(type(i).__module__, 'string.templatelib')
+
+    def test_final_types(self):
+        with self.assertRaisesRegex(TypeError, 'is not an acceptable base type'):
+            class Sub(Template): ...
+
+        with self.assertRaisesRegex(TypeError, 'is not an acceptable base type'):
+            class Sub(Interpolation): ...
+
+    def test_basic_creation(self):
+        # Simple t-string creation
+        t = t'Hello, world'
+        self.assertIsInstance(t, Template)
+        self.assertTStringEqual(t, ('Hello, world',), ())
+        self.assertEqual(fstring(t), 'Hello, world')
+
+        # Empty t-string
+        t = t''
+        self.assertTStringEqual(t, ('',), ())
+        self.assertEqual(fstring(t), '')
+
+        # Multi-line t-string
+        t = t"""Hello,
+world"""
+        self.assertEqual(t.strings, ('Hello,\nworld',))
+        self.assertEqual(len(t.interpolations), 0)
+        self.assertEqual(fstring(t), 'Hello,\nworld')
+
+    def test_interpolation_creation(self):
+        i = Interpolation('Maria', 'name', 'a', 'fmt')
+        self.assertInterpolationEqual(i, ('Maria', 'name', 'a', 'fmt'))
+
+        i = Interpolation('Maria', 'name', 'a')
+        self.assertInterpolationEqual(i, ('Maria', 'name', 'a'))
+
+        i = Interpolation('Maria', 'name')
+        self.assertInterpolationEqual(i, ('Maria', 'name'))
+
+        i = Interpolation('Maria')
+        self.assertInterpolationEqual(i, ('Maria',))
+
+    def test_creation_interleaving(self):
+        # Should add strings on either side
+        t = Template(Interpolation('Maria', 'name', None, ''))
+        self.assertTStringEqual(t, ('', ''), [('Maria', 'name')])
+        self.assertEqual(fstring(t), 'Maria')
+
+        # Should prepend empty string
+        t = Template(Interpolation('Maria', 'name', None, ''), ' is my name')
+        self.assertTStringEqual(t, ('', ' is my name'), [('Maria', 'name')])
+        self.assertEqual(fstring(t), 'Maria is my name')
+
+        # Should append empty string
+        t = Template('Hello, ', Interpolation('Maria', 'name', None, ''))
+        self.assertTStringEqual(t, ('Hello, ', ''), [('Maria', 'name')])
+        self.assertEqual(fstring(t), 'Hello, Maria')
+
+        # Should concatenate strings
+        t = Template('Hello', ', ', Interpolation('Maria', 'name', None, ''),
+                     '!')
+        self.assertTStringEqual(t, ('Hello, ', '!'), [('Maria', 'name')])
+        self.assertEqual(fstring(t), 'Hello, Maria!')
+
+        # Should add strings on either side and in between
+        t = Template(Interpolation('Maria', 'name', None, ''),
+                     Interpolation('Python', 'language', None, ''))
+        self.assertTStringEqual(
+            t, ('', '', ''), [('Maria', 'name'), ('Python', 'language')]
+        )
+        self.assertEqual(fstring(t), 'MariaPython')
+
+    def test_template_values(self):
+        t = t'Hello, world'
+        self.assertEqual(t.values, ())
+
+        name = "Lys"
+        t = t'Hello, {name}'
+        self.assertEqual(t.values, ("Lys",))
+
+        country = "GR"
+        age = 0
+        t = t'Hello, {name}, {age} from {country}'
+        self.assertEqual(t.values, ("Lys", 0, "GR"))
+
+    def test_pickle_template(self):
+        user = 'test'
+        for template in (
+            t'',
+            t"No values",
+            t'With inter {user}',
+            t'With ! {user!r}',
+            t'With format {1 / 0.3:.2f}',
+            Template(),
+            Template('a'),
+            Template(Interpolation('Nikita', 'name', None, '')),
+            Template('a', Interpolation('Nikita', 'name', 'r', '')),
+        ):
+            for proto in range(pickle.HIGHEST_PROTOCOL + 1):
+                with self.subTest(proto=proto, template=template):
+                    pickled = pickle.dumps(template, protocol=proto)
+                    unpickled = pickle.loads(pickled)
+
+                    self.assertEqual(unpickled.values, template.values)
+                    self.assertEqual(fstring(unpickled), fstring(template))
+
+    def test_pickle_interpolation(self):
+        for interpolation in (
+            Interpolation('Nikita', 'name', None, ''),
+            Interpolation('Nikita', 'name', 'r', ''),
+            Interpolation(1/3, 'x', None, '.2f'),
+        ):
+            for proto in range(pickle.HIGHEST_PROTOCOL + 1):
+                with self.subTest(proto=proto, interpolation=interpolation):
+                    pickled = pickle.dumps(interpolation, protocol=proto)
+                    unpickled = pickle.loads(pickled)
+
+                    self.assertEqual(unpickled.value, interpolation.value)
+                    self.assertEqual(unpickled.expression, interpolation.expression)
+                    self.assertEqual(unpickled.conversion, interpolation.conversion)
+                    self.assertEqual(unpickled.format_spec, interpolation.format_spec)
+
+
+class TemplateIterTests(unittest.TestCase):
+    def test_abc(self):
+        self.assertIsInstance(iter(t''), Iterable)
+        self.assertIsInstance(iter(t''), Iterator)
+
+    def test_final(self):
+        TemplateIter = type(iter(t''))
+        with self.assertRaisesRegex(TypeError, 'is not an acceptable base type'):
+            class Sub(TemplateIter): ...
+
+    def test_iter(self):
+        x = 1
+        res = list(iter(t'abc {x} yz'))
+
+        self.assertEqual(res[0], 'abc ')
+        self.assertIsInstance(res[1], Interpolation)
+        self.assertEqual(res[1].value, 1)
+        self.assertEqual(res[1].expression, 'x')
+        self.assertEqual(res[1].conversion, None)
+        self.assertEqual(res[1].format_spec, '')
+        self.assertEqual(res[2], ' yz')
+
+    def test_exhausted(self):
+        # See https://github.com/python/cpython/issues/134119.
+        template_iter = iter(t"{1}")
+        self.assertIsInstance(next(template_iter), Interpolation)
+        self.assertRaises(StopIteration, next, template_iter)
+        self.assertRaises(StopIteration, next, template_iter)
+
+
+class TestFunctions(unittest.TestCase):
+    def test_convert(self):
+        from fractions import Fraction
+
+        for obj in ('Café', None, 3.14, Fraction(1, 2)):
+            with self.subTest(f'{obj=}'):
+                self.assertEqual(convert(obj, None), obj)
+                self.assertEqual(convert(obj, 's'), str(obj))
+                self.assertEqual(convert(obj, 'r'), repr(obj))
+                self.assertEqual(convert(obj, 'a'), ascii(obj))
+
+                # Invalid conversion specifier
+                with self.assertRaises(ValueError):
+                    convert(obj, 'z')
+                with self.assertRaises(ValueError):
+                    convert(obj, 1)
+                with self.assertRaises(ValueError):
+                    convert(obj, object())
+
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/Lib/test/test_string_literals.py b/Lib/test/test_string_literals.py
index c6b2ffb9de8..14327d288a4 100644
--- a/Lib/test/test_string_literals.py
+++ b/Lib/test/test_string_literals.py
@@ -105,7 +105,7 @@ def test_eval_str_incomplete(self):
         self.assertRaises(SyntaxError, eval, r""" '\U000000' """)
         self.assertRaises(SyntaxError, eval, r""" '\U0000000' """)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_eval_str_invalid_escape(self):
         for b in range(1, 128):
             if b in b"""\n\r"'01234567NU\\abfnrtuvx""":
@@ -117,7 +117,9 @@ def test_eval_str_invalid_escape(self):
             warnings.simplefilter('always', category=SyntaxWarning)
             eval("'''\n\\z'''")
         self.assertEqual(len(w), 1)
-        self.assertEqual(str(w[0].message), r"invalid escape sequence '\z'")
+        self.assertEqual(str(w[0].message), r'"\z" is an invalid escape sequence. '
+                         r'Such sequences will not work in the future. '
+                         r'Did you mean "\\z"? A raw string is also an option.')
         self.assertEqual(w[0].filename, '<string>')
         self.assertEqual(w[0].lineno, 2)
 
@@ -127,7 +129,8 @@ def test_eval_str_invalid_escape(self):
                 eval("'''\n\\z'''")
             exc = cm.exception
         self.assertEqual(w, [])
-        self.assertEqual(exc.msg, r"invalid escape sequence '\z'")
+        self.assertEqual(exc.msg, r'"\z" is an invalid escape sequence. '
+                         r'Did you mean "\\z"? A raw string is also an option.')
         self.assertEqual(exc.filename, '<string>')
         self.assertEqual(exc.lineno, 2)
         self.assertEqual(exc.offset, 1)
@@ -144,7 +147,7 @@ def test_eval_str_invalid_escape(self):
         self.assertRegex(str(w[0].message), 'invalid escape sequence')
         self.assertEqual(w[0].filename, '<string>')
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_eval_str_invalid_octal_escape(self):
         for i in range(0o400, 0o1000):
             with self.assertWarns(SyntaxWarning):
@@ -155,7 +158,9 @@ def test_eval_str_invalid_octal_escape(self):
             eval("'''\n\\407'''")
         self.assertEqual(len(w), 1)
         self.assertEqual(str(w[0].message),
-                         r"invalid octal escape sequence '\407'")
+                         r'"\407" is an invalid octal escape sequence. '
+                         r'Such sequences will not work in the future. '
+                         r'Did you mean "\\407"? A raw string is also an option.')
         self.assertEqual(w[0].filename, '<string>')
         self.assertEqual(w[0].lineno, 2)
 
@@ -165,34 +170,34 @@ def test_eval_str_invalid_octal_escape(self):
                 eval("'''\n\\407'''")
             exc = cm.exception
         self.assertEqual(w, [])
-        self.assertEqual(exc.msg, r"invalid octal escape sequence '\407'")
+        self.assertEqual(exc.msg, r'"\407" is an invalid octal escape sequence. '
+                                 r'Did you mean "\\407"? A raw string is also an option.')
         self.assertEqual(exc.filename, '<string>')
         self.assertEqual(exc.lineno, 2)
         self.assertEqual(exc.offset, 1)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_invalid_escape_locations_with_offset(self):
         with warnings.catch_warnings(record=True) as w:
-            warnings.simplefilter('error', category=SyntaxWarning)
-            with self.assertRaises(SyntaxError) as cm:
-                eval("\"'''''''''''''''''''''invalid\\ Escape\"")
-            exc = cm.exception
-        self.assertEqual(w, [])
-        self.assertEqual(exc.msg, r"invalid escape sequence '\ '")
-        self.assertEqual(exc.filename, '<string>')
-        self.assertEqual(exc.lineno, 1)
-        self.assertEqual(exc.offset, 30)
+            warnings.simplefilter('always', category=SyntaxWarning)
+            eval("\"'''''''''''''''''''''invalid\\ Escape\"")
+        self.assertEqual(len(w), 1)
+        self.assertEqual(str(w[0].message),
+                         r'"\ " is an invalid escape sequence. Such sequences '
+                         r'will not work in the future. Did you mean "\\ "? '
+                         r'A raw string is also an option.')
+        self.assertEqual(w[0].filename, '<string>')
+        self.assertEqual(w[0].lineno, 1)
 
         with warnings.catch_warnings(record=True) as w:
-            warnings.simplefilter('error', category=SyntaxWarning)
-            with self.assertRaises(SyntaxError) as cm:
-                eval("\"''Incorrect \\ logic?\"")
-            exc = cm.exception
-        self.assertEqual(w, [])
-        self.assertEqual(exc.msg, r"invalid escape sequence '\ '")
-        self.assertEqual(exc.filename, '<string>')
-        self.assertEqual(exc.lineno, 1)
-        self.assertEqual(exc.offset, 14)
+            warnings.simplefilter('always', category=SyntaxWarning)
+            eval("\"''Incorrect \\ logic?\"")
+        self.assertEqual(len(w), 1)
+        self.assertEqual(str(w[0].message),
+                            r'"\ " is an invalid escape sequence. Such sequences '
+                            r'will not work in the future. Did you mean "\\ "? '
+                            r'A raw string is also an option.')
+        self.assertEqual(w[0].filename, '<string>')
+        self.assertEqual(w[0].lineno, 1)
 
     def test_eval_str_raw(self):
         self.assertEqual(eval(""" r'x' """), 'x')
@@ -220,7 +225,7 @@ def test_eval_bytes_incomplete(self):
         self.assertRaises(SyntaxError, eval, r""" b'\x' """)
         self.assertRaises(SyntaxError, eval, r""" b'\x0' """)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_eval_bytes_invalid_escape(self):
         for b in range(1, 128):
             if b in b"""\n\r"'01234567\\abfnrtvx""":
@@ -232,7 +237,9 @@ def test_eval_bytes_invalid_escape(self):
             warnings.simplefilter('always', category=SyntaxWarning)
             eval("b'''\n\\z'''")
         self.assertEqual(len(w), 1)
-        self.assertEqual(str(w[0].message), r"invalid escape sequence '\z'")
+        self.assertEqual(str(w[0].message), r'"\z" is an invalid escape sequence. '
+                         r'Such sequences will not work in the future. '
+                         r'Did you mean "\\z"? A raw string is also an option.')
         self.assertEqual(w[0].filename, '<string>')
         self.assertEqual(w[0].lineno, 2)
 
@@ -242,11 +249,12 @@ def test_eval_bytes_invalid_escape(self):
                 eval("b'''\n\\z'''")
             exc = cm.exception
         self.assertEqual(w, [])
-        self.assertEqual(exc.msg, r"invalid escape sequence '\z'")
+        self.assertEqual(exc.msg, r'"\z" is an invalid escape sequence. '
+                         r'Did you mean "\\z"? A raw string is also an option.')
         self.assertEqual(exc.filename, '<string>')
         self.assertEqual(exc.lineno, 2)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_eval_bytes_invalid_octal_escape(self):
         for i in range(0o400, 0o1000):
             with self.assertWarns(SyntaxWarning):
@@ -256,8 +264,9 @@ def test_eval_bytes_invalid_octal_escape(self):
             warnings.simplefilter('always', category=SyntaxWarning)
             eval("b'''\n\\407'''")
         self.assertEqual(len(w), 1)
-        self.assertEqual(str(w[0].message),
-                         r"invalid octal escape sequence '\407'")
+        self.assertEqual(str(w[0].message), r'"\407" is an invalid octal escape sequence. '
+                         r'Such sequences will not work in the future. '
+                         r'Did you mean "\\407"? A raw string is also an option.')
         self.assertEqual(w[0].filename, '<string>')
         self.assertEqual(w[0].lineno, 2)
 
@@ -267,7 +276,8 @@ def test_eval_bytes_invalid_octal_escape(self):
                 eval("b'''\n\\407'''")
             exc = cm.exception
         self.assertEqual(w, [])
-        self.assertEqual(exc.msg, r"invalid octal escape sequence '\407'")
+        self.assertEqual(exc.msg, r'"\407" is an invalid octal escape sequence. '
+                         r'Did you mean "\\407"? A raw string is also an option.')
         self.assertEqual(exc.filename, '<string>')
         self.assertEqual(exc.lineno, 2)
 
diff --git a/Lib/test/test_strtod.py b/Lib/test/test_strtod.py
index 45fdcca92e4..03c8afa51ef 100644
--- a/Lib/test/test_strtod.py
+++ b/Lib/test/test_strtod.py
@@ -19,7 +19,7 @@
     (?P<int>\d*)             # having a (possibly empty) integer part
     (?:\.(?P<frac>\d*))?     # followed by an optional fractional part
     (?:E(?P<exp>[-+]?\d+))?  # and an optional exponent
-    \Z
+    \z
 """, re.VERBOSE | re.IGNORECASE).match
 
 # Pure Python version of correctly rounded string->float conversion.
@@ -146,7 +146,7 @@ def test_short_halfway_cases(self):
                     digits *= 5
                     exponent -= 1
 
-    @unittest.skip('TODO: RUSTPYTHON; fails on debug mode, flaky in release mode')
+    @unittest.skip("TODO: RUSTPYTHON; fails on debug mode, flaky in release mode")
     def test_halfway_cases(self):
         # test halfway cases for the round-half-to-even rule
         for i in range(100 * TEST_SIZE):
@@ -173,7 +173,7 @@ def test_halfway_cases(self):
             s = '{}e{}'.format(digits, exponent)
             self.check_strtod(s)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_boundaries(self):
         # boundaries expressed as triples (n, e, u), where
         # n*10**e is an approximation to the boundary value and
@@ -194,7 +194,7 @@ def test_boundaries(self):
                 u *= 10
                 e -= 1
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_underflow_boundary(self):
         # test values close to 2**-1075, the underflow boundary; similar
         # to boundary_tests, except that the random error doesn't scale
@@ -206,7 +206,7 @@ def test_underflow_boundary(self):
                 s = '{}e{}'.format(digits, exponent)
                 self.check_strtod(s)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_bigcomp(self):
         for ndigs in 5, 10, 14, 15, 16, 17, 18, 19, 20, 40, 41, 50:
             dig10 = 10**ndigs
@@ -216,7 +216,7 @@ def test_bigcomp(self):
                 s = '{}e{}'.format(digits, exponent)
                 self.check_strtod(s)
 
-    @unittest.skip('TODO: RUSTPYTHON; flaky test')
+    @unittest.skip("TODO: RUSTPYTHON; flaky test")
     def test_parsing(self):
         # make '0' more likely to be chosen than other digits
         digits = '000000123456789'
@@ -284,7 +284,7 @@ def negative_exp(n):
         self.assertEqual(float(negative_exp(20000)), 1.0)
         self.assertEqual(float(negative_exp(30000)), 1.0)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_particular(self):
         # inputs that produced crashes or incorrectly rounded results with
         # previous versions of dtoa.c, for various reasons
diff --git a/Lib/test/test_struct.py b/Lib/test/test_struct.py
index a03438f1604..733006bb509 100644
--- a/Lib/test/test_struct.py
+++ b/Lib/test/test_struct.py
@@ -5,7 +5,6 @@
 import math
 import operator
 import unittest
-import platform
 import struct
 import sys
 import weakref
@@ -435,56 +434,65 @@ def test_unpack_from(self):
         self.assertEqual(s.unpack_from(buffer=test_string, offset=2),
                          (b'cd01',))
 
-    def test_pack_into(self):
+    def _test_pack_into(self, pack_into):
         test_string = b'Reykjavik rocks, eow!'
-        writable_buf = array.array('b', b' '*100)
-        fmt = '21s'
-        s = struct.Struct(fmt)
+        writable_buf = memoryview(array.array('b', b' '*100))
 
         # Test without offset
-        s.pack_into(writable_buf, 0, test_string)
+        pack_into(writable_buf, 0, test_string)
         from_buf = writable_buf.tobytes()[:len(test_string)]
         self.assertEqual(from_buf, test_string)
 
         # Test with offset.
-        s.pack_into(writable_buf, 10, test_string)
+        pack_into(writable_buf, 10, test_string)
         from_buf = writable_buf.tobytes()[:len(test_string)+10]
         self.assertEqual(from_buf, test_string[:10] + test_string)
 
+        # Test with negative offset.
+        pack_into(writable_buf, -30, test_string)
+        from_buf = writable_buf.tobytes()[-30:-30+len(test_string)]
+        self.assertEqual(from_buf, test_string)
+
         # Go beyond boundaries.
         small_buf = array.array('b', b' '*10)
-        self.assertRaises((ValueError, struct.error), s.pack_into, small_buf, 0,
-                          test_string)
-        self.assertRaises((ValueError, struct.error), s.pack_into, small_buf, 2,
-                          test_string)
+        with self.assertRaises((ValueError, struct.error)):
+            pack_into(small_buf, 0, test_string)
+        with self.assertRaises((ValueError, struct.error)):
+            pack_into(writable_buf, 90, test_string)
+        with self.assertRaises((ValueError, struct.error)):
+            pack_into(writable_buf, -10, test_string)
+        with self.assertRaises((ValueError, struct.error)):
+            pack_into(writable_buf, 150, test_string)
+        with self.assertRaises((ValueError, struct.error)):
+            pack_into(writable_buf, -150, test_string)
+
+        # Test invalid buffer.
+        self.assertRaises(TypeError, pack_into, b' '*100, 0, test_string)
+        self.assertRaises(TypeError, pack_into, ' '*100, 0, test_string)
+        self.assertRaises(TypeError, pack_into, [0]*100, 0, test_string)
+        self.assertRaises(TypeError, pack_into, None, 0, test_string)
+        self.assertRaises(TypeError, pack_into, writable_buf[::2], 0, test_string)
+        self.assertRaises(TypeError, pack_into, writable_buf[::-1], 0, test_string)
+
+        # Test bogus offset (issue bpo-3694)
+        with self.assertRaises(TypeError):
+            pack_into(writable_buf, None, test_string)
+        with self.assertRaises(TypeError):
+            pack_into(writable_buf, 0.0, test_string)
+        with self.assertRaises((IndexError, OverflowError)):
+            pack_into(writable_buf, 2**1000, test_string)
+        with self.assertRaises((IndexError, OverflowError)):
+            pack_into(writable_buf, -2**1000, test_string)
 
-        # Test bogus offset (issue 3694)
-        sb = small_buf
-        self.assertRaises((TypeError, struct.error), struct.pack_into, b'', sb,
-                          None)
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; BufferError: non-contiguous buffer is not a bytes-like object
+    def test_pack_into(self):
+        s = struct.Struct('21s')
+        self._test_pack_into(s.pack_into)
 
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; BufferError: non-contiguous buffer is not a bytes-like object
     def test_pack_into_fn(self):
-        test_string = b'Reykjavik rocks, eow!'
-        writable_buf = array.array('b', b' '*100)
-        fmt = '21s'
-        pack_into = lambda *args: struct.pack_into(fmt, *args)
-
-        # Test without offset.
-        pack_into(writable_buf, 0, test_string)
-        from_buf = writable_buf.tobytes()[:len(test_string)]
-        self.assertEqual(from_buf, test_string)
-
-        # Test with offset.
-        pack_into(writable_buf, 10, test_string)
-        from_buf = writable_buf.tobytes()[:len(test_string)+10]
-        self.assertEqual(from_buf, test_string[:10] + test_string)
-
-        # Go beyond boundaries.
-        small_buf = array.array('b', b' '*10)
-        self.assertRaises((ValueError, struct.error), pack_into, small_buf, 0,
-                          test_string)
-        self.assertRaises((ValueError, struct.error), pack_into, small_buf, 2,
-                          test_string)
+        pack_into = lambda *args: struct.pack_into('21s', *args)
+        self._test_pack_into(pack_into)
 
     def test_unpack_with_buffer(self):
         # SF bug 1563759: struct.unpack doesn't support buffer protocol objects
@@ -821,6 +829,19 @@ def test_endian_table_init_subinterpreters(self):
             results = executor.map(exec, [code] * 5)
             self.assertListEqual(list(results), [None] * 5)
 
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; TypeError: expected at least 1 arguments, got 0
+    def test_operations_on_half_initialized_Struct(self):
+        S = struct.Struct.__new__(struct.Struct)
+
+        spam = array.array('b', b' ')
+        self.assertRaises(RuntimeError, S.iter_unpack, spam)
+        self.assertRaises(RuntimeError, S.pack, 1)
+        self.assertRaises(RuntimeError, S.pack_into, spam, 1)
+        self.assertRaises(RuntimeError, S.unpack, spam)
+        self.assertRaises(RuntimeError, S.unpack_from, spam)
+        self.assertRaises(RuntimeError, getattr, S, 'format')
+        self.assertEqual(S.size, -1)
+
 
 class UnpackIteratorTest(unittest.TestCase):
     """
@@ -895,6 +916,7 @@ def test_module_func(self):
         self.assertRaises(StopIteration, next, it)
 
     def test_half_float(self):
+        _testcapi = import_helper.import_module('_testcapi')
         # Little-endian examples from:
         # http://en.wikipedia.org/wiki/Half_precision_floating-point_format
         format_bits_float__cleanRoundtrip_list = [
@@ -939,8 +961,8 @@ def test_half_float(self):
 
         # Check that packing produces a bit pattern representing a quiet NaN:
         # all exponent bits and the msb of the fraction should all be 1.
-        if platform.machine().startswith('parisc'):
-            # HP PA RISC uses 0 for quiet, see:
+        if _testcapi.nan_msb_is_signaling:
+            # HP PA RISC and some MIPS CPUs use 0 for quiet, see:
             # https://en.wikipedia.org/wiki/NaN#Encoding
             expected = 0x7c
         else:
diff --git a/Lib/test/test_subclassinit.py b/Lib/test/test_subclassinit.py
index c007476e004..0d32aa509bd 100644
--- a/Lib/test/test_subclassinit.py
+++ b/Lib/test/test_subclassinit.py
@@ -134,30 +134,28 @@ class Descriptor:
             def __set_name__(self, owner, name):
                 1/0
 
-        with self.assertRaises(RuntimeError) as cm:
+        with self.assertRaises(ZeroDivisionError) as cm:
             class NotGoingToWork:
                 attr = Descriptor()
 
-        exc = cm.exception
-        self.assertRegex(str(exc), r'\bNotGoingToWork\b')
-        self.assertRegex(str(exc), r'\battr\b')
-        self.assertRegex(str(exc), r'\bDescriptor\b')
-        self.assertIsInstance(exc.__cause__, ZeroDivisionError)
+        notes = cm.exception.__notes__
+        self.assertRegex(str(notes), r'\bNotGoingToWork\b')
+        self.assertRegex(str(notes), r'\battr\b')
+        self.assertRegex(str(notes), r'\bDescriptor\b')
 
     def test_set_name_wrong(self):
         class Descriptor:
             def __set_name__(self):
                 pass
 
-        with self.assertRaises(RuntimeError) as cm:
+        with self.assertRaises(TypeError) as cm:
             class NotGoingToWork:
                 attr = Descriptor()
 
-        exc = cm.exception
-        self.assertRegex(str(exc), r'\bNotGoingToWork\b')
-        self.assertRegex(str(exc), r'\battr\b')
-        self.assertRegex(str(exc), r'\bDescriptor\b')
-        self.assertIsInstance(exc.__cause__, TypeError)
+        notes = cm.exception.__notes__
+        self.assertRegex(str(notes), r'\bNotGoingToWork\b')
+        self.assertRegex(str(notes), r'\battr\b')
+        self.assertRegex(str(notes), r'\bDescriptor\b')
 
     def test_set_name_lookup(self):
         resolved = []
@@ -232,7 +230,7 @@ def __init__(self, name, bases, namespace, otherarg):
                 super().__init__(name, bases, namespace)
 
         with self.assertRaises(TypeError):
-            class MyClass(metaclass=MyMeta, otherarg=1):
+            class MyClass2(metaclass=MyMeta, otherarg=1):
                 pass
 
         class MyMeta(type):
@@ -243,10 +241,10 @@ def __init__(self, name, bases, namespace, otherarg):
                 super().__init__(name, bases, namespace)
                 self.otherarg = otherarg
 
-        class MyClass(metaclass=MyMeta, otherarg=1):
+        class MyClass3(metaclass=MyMeta, otherarg=1):
             pass
 
-        self.assertEqual(MyClass.otherarg, 1)
+        self.assertEqual(MyClass3.otherarg, 1)
 
     def test_errors_changed_pep487(self):
         # These tests failed before Python 3.6, PEP 487
@@ -265,10 +263,10 @@ def __new__(cls, name, bases, namespace, otherarg):
                 self.otherarg = otherarg
                 return self
 
-        class MyClass(metaclass=MyMeta, otherarg=1):
+        class MyClass2(metaclass=MyMeta, otherarg=1):
             pass
 
-        self.assertEqual(MyClass.otherarg, 1)
+        self.assertEqual(MyClass2.otherarg, 1)
 
     def test_type(self):
         t = type('NewClass', (object,), {})
@@ -281,4 +279,3 @@ def test_type(self):
 
 if __name__ == "__main__":
     unittest.main()
-
diff --git a/Lib/test/test_subprocess.py b/Lib/test/test_subprocess.py
index 4d058652723..2ba98616ea6 100644
--- a/Lib/test/test_subprocess.py
+++ b/Lib/test/test_subprocess.py
@@ -4,6 +4,7 @@
 from test.support import check_sanitizer
 from test.support import import_helper
 from test.support import os_helper
+from test.support import strace_helper
 from test.support import warnings_helper
 from test.support.script_helper import assert_python_ok
 import subprocess
@@ -800,7 +801,6 @@ def test_env(self):
             stdout, stderr = p.communicate()
             self.assertEqual(stdout, b"orange")
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     @unittest.skipUnless(sys.platform == "win32", "Windows only issue")
     def test_win32_duplicate_envs(self):
         newenv = os.environ.copy()
@@ -1289,9 +1289,8 @@ def test_universal_newlines_communicate_stdin_stdout_stderr(self):
         self.assertEqual("line1\nline2\nline3\nline4\nline5\n", stdout)
         # Python debug build push something like "[42442 refs]\n"
         # to stderr at exit of subprocess.
-        self.assertTrue(stderr.startswith("eline2\neline6\neline7\n"))
+        self.assertStartsWith(stderr, "eline2\neline6\neline7\n")
 
-    @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.
@@ -1622,7 +1621,7 @@ def test_issue8780(self):
                 "[sys.executable, '-c', 'print(\"Hello World!\")'])",
             'assert retcode == 0'))
         output = subprocess.check_output([sys.executable, '-c', code])
-        self.assertTrue(output.startswith(b'Hello World!'), ascii(output))
+        self.assertStartsWith(output, b'Hello World!')
 
     def test_handles_closed_on_exception(self):
         # If CreateProcess exits with an error, ensure the
@@ -1786,7 +1785,7 @@ def test_post_timeout_communicate_sends_input(self):
             self.assertEqual(
                     proc.returncode, 0,
                     msg=f"STDERR:\n{stderr}\nSTDOUT:\n{stdout}")
-            self.assertTrue(stdout.startswith("spam"), msg=stdout)
+            self.assertStartsWith(stdout, "spam")
             self.assertIn("beans", stdout)
 
 
@@ -1904,7 +1903,6 @@ def test_run_with_pathlike_path_and_arguments(self):
         res = subprocess.run(args)
         self.assertEqual(res.returncode, 57)
 
-    @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
@@ -1982,8 +1980,8 @@ def test_encoding_warning(self):
                             capture_output=True)
         lines = cp.stderr.splitlines()
         self.assertEqual(len(lines), 2, lines)
-        self.assertTrue(lines[0].startswith(b"<string>:2: EncodingWarning: "))
-        self.assertTrue(lines[1].startswith(b"<string>:3: EncodingWarning: "))
+        self.assertStartsWith(lines[0], b"<string>:2: EncodingWarning: ")
+        self.assertStartsWith(lines[1], b"<string>:3: EncodingWarning: ")
 
 
 def _get_test_grp_name():
@@ -2274,14 +2272,12 @@ def test_group_error(self):
         with self.assertRaises(ValueError):
             subprocess.check_call(ZERO_RETURN_CMD, group=65535)
 
-    @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)
 
-    @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=[])
@@ -2318,7 +2314,7 @@ def _test_extra_groups_impl(self, *, gid, group_list):
                                       extra_groups=[name_group])
 
     # No skip necessary, this test won't make it to a setgroup() call.
-    @unittest.skip('TODO: RUSTPYTHON; clarify failure condition')
+    @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])
@@ -2445,7 +2441,6 @@ def raise_it():
                         stdin=subprocess.PIPE, stdout=subprocess.PIPE,
                         stderr=subprocess.PIPE, preexec_fn=raise_it)
 
-    @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.
@@ -3016,7 +3011,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")
 
@@ -3148,7 +3143,7 @@ def test_close_fds_when_max_fd_is_lowered(self):
     # 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')
+    @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")
@@ -3445,7 +3440,7 @@ def __int__(self):
                         1, 2, 3, 4,
                         True, True, 0,
                         None, None, None, -1,
-                        None, True)
+                        None)
                 self.assertIn('fds_to_keep', str(c.exception))
         finally:
             if not gc_enabled:
@@ -3561,7 +3556,6 @@ def test_communicate_repeated_call_after_stdout_close(self):
             except subprocess.TimeoutExpired:
                 pass
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_preexec_at_exit(self):
         code = f"""if 1:
         import atexit
@@ -3583,26 +3577,7 @@ def __del__(self):
 
     @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.")
+    @strace_helper.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
@@ -3610,52 +3585,39 @@ def test_vfork_used_when_expected(self):
         # 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.")
+        # Are intersted in the system calls:
+        # clone,clone2,clone3,fork,vfork,exit,exit_group
+        # Unfortunately using `--trace` with that list to strace fails because
+        # not all are supported on all platforms (ex. clone2 is ia64 only...)
+        # So instead use `%process` which is recommended by strace, and contains
+        # the above.
+        true_binary = "/bin/true"
+        strace_args = ["--trace=%process"]
 
         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,
+            vfork_result = strace_helper.strace_python(
+                f"""\
+                import subprocess
+                subprocess.check_call([{true_binary!r}])""",
+                strace_args
             )
             # Match both vfork() and clone(..., flags=...|CLONE_VFORK|...)
-            self.assertRegex(vfork_result.err, br"(?i)vfork")
+            self.assertRegex(vfork_result.event_bytes, 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"""\
+                non_vfork_result = strace_helper.strace_python(
+                    f"""\
                     import subprocess
                     {preamble}
                     try:
@@ -3663,11 +3625,11 @@ def test_vfork_used_when_expected(self):
                                 [{true_binary!r}], **dict({sp_kwarg}))
                     except PermissionError:
                         if not {expect_permission_error}:
-                            raise"""),
-                    __run_using_command=strace_command,
+                            raise""",
+                    strace_args
                 )
                 # Ensure neither vfork() or clone(..., flags=...|CLONE_VFORK|...).
-                self.assertNotRegex(non_vfork_result.err, br"(?i)vfork")
+                self.assertNotRegex(non_vfork_result.event_bytes, br"(?i)vfork")
 
 
 @unittest.skipUnless(mswindows, "Windows specific tests")
diff --git a/Lib/test/test_sundry.py b/Lib/test/test_sundry.py
index f4a8d434ed1..d6d08ee53f8 100644
--- a/Lib/test/test_sundry.py
+++ b/Lib/test/test_sundry.py
@@ -18,10 +18,11 @@ def test_untested_modules_can_be_imported(self):
                     self.fail('{} has tests even though test_sundry claims '
                               'otherwise'.format(name))
 
-            import html.entities
+            import html.entities  # noqa: F401
 
             try:
-                import tty  # Not available on Windows
+                # Not available on Windows
+                import tty  # noqa: F401
             except ImportError:
                 if support.verbose:
                     print("skipping tty")
diff --git a/Lib/test/test_super.py b/Lib/test/test_super.py
index 5548f4c71a2..ac9d2e0906d 100644
--- a/Lib/test/test_super.py
+++ b/Lib/test/test_super.py
@@ -209,7 +209,6 @@ def f():
 
         self.assertIs(test_class, A)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test___classcell___expected_behaviour(self):
         # See issue #23722
         class Meta(type):
diff --git a/Lib/test/test_support.py b/Lib/test/test_support.py
index 481be2bff92..37b5543badf 100644
--- a/Lib/test/test_support.py
+++ b/Lib/test/test_support.py
@@ -17,13 +17,11 @@
 import warnings
 
 from test import support
-from test.support import (
-    import_helper,
-    os_helper,
-    script_helper,
-    socket_helper,
-    warnings_helper,
-)
+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
 
 TESTFN = os_helper.TESTFN
 
@@ -460,7 +458,7 @@ def test_detect_api_mismatch__ignore(self):
                 self.OtherClass, self.RefClass, ignore=ignore)
         self.assertEqual(set(), missing_items)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_check__all__(self):
         extra = {'tempdir'}
         not_exported = {'template'}
@@ -616,14 +614,13 @@ 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)
         else:
             self.assertTrue(support.has_strftime_extensions)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON; - _testinternalcapi module not available
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; - _testinternalcapi module not available
     def test_get_recursion_depth(self):
         # test support.get_recursion_depth()
         code = textwrap.dedent("""
@@ -667,7 +664,8 @@ def test_recursive(depth, limit):
         """)
         script_helper.assert_python_ok("-c", code)
 
-    @unittest.skip('TODO: RUSTPYTHON; - causes segfault in debug builds')
+    @unittest.skip("TODO: RUSTPYTHON; - causes segfault in debug builds")
+    @support.skip_if_unlimited_stack_size
     def test_recursion(self):
         # Test infinite_recursion() and get_recursion_available() functions.
         def recursive_function(depth):
diff --git a/Lib/test/test_symtable.py b/Lib/test/test_symtable.py
index 8f1a80a5242..1653ab4a718 100644
--- a/Lib/test/test_symtable.py
+++ b/Lib/test/test_symtable.py
@@ -2,6 +2,7 @@
 Test the API of the symtable module.
 """
 
+import re
 import textwrap
 import symtable
 import unittest
@@ -202,9 +203,7 @@ class SymtableTest(unittest.TestCase):
     # XXX: RUSTPYTHON
     # U = find_block(GenericMine, "U")
 
-
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_type(self):
         self.assertEqual(self.top.get_type(), "module")
         self.assertEqual(self.Mine.get_type(), "class")
@@ -222,8 +221,7 @@ def test_type(self):
         self.assertEqual(self.T.get_type(), "type variable")
         self.assertEqual(self.U.get_type(), "type variable")
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_id(self):
         self.assertGreater(self.top.get_id(), 0)
         self.assertGreater(self.Mine.get_id(), 0)
@@ -256,8 +254,7 @@ def test_lineno(self):
         self.assertEqual(self.top.get_lineno(), 0)
         self.assertEqual(self.spam.get_lineno(), 14)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_function_info(self):
         func = self.spam
         self.assertEqual(sorted(func.get_parameters()), ["a", "b", "kw", "var"])
@@ -266,8 +263,7 @@ def test_function_info(self):
         self.assertEqual(sorted(func.get_globals()), ["bar", "glob", "some_assigned_global_var"])
         self.assertEqual(self.internal.get_frees(), ("x",))
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_globals(self):
         self.assertTrue(self.spam.lookup("glob").is_global())
         self.assertFalse(self.spam.lookup("glob").is_declared_global())
@@ -280,16 +276,14 @@ def test_globals(self):
         self.assertTrue(self.top.lookup("some_non_assigned_global_var").is_global())
         self.assertTrue(self.top.lookup("some_assigned_global_var").is_global())
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_nonlocal(self):
         self.assertFalse(self.spam.lookup("some_var").is_nonlocal())
         self.assertTrue(self.other_internal.lookup("some_var").is_nonlocal())
         expected = ("some_var",)
         self.assertEqual(self.other_internal.get_nonlocals(), expected)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_local(self):
         self.assertTrue(self.spam.lookup("x").is_local())
         self.assertFalse(self.spam.lookup("bar").is_local())
@@ -297,13 +291,11 @@ def test_local(self):
         self.assertTrue(self.top.lookup("some_non_assigned_global_var").is_local())
         self.assertTrue(self.top.lookup("some_assigned_global_var").is_local())
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_free(self):
         self.assertTrue(self.internal.lookup("x").is_free())
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_referenced(self):
         self.assertTrue(self.internal.lookup("x").is_referenced())
         self.assertTrue(self.spam.lookup("internal").is_referenced())
@@ -320,8 +312,7 @@ def test_symbol_lookup(self):
 
         self.assertRaises(KeyError, self.top.lookup, "not_here")
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_namespaces(self):
         self.assertTrue(self.top.lookup("Mine").is_namespace())
         self.assertTrue(self.Mine.lookup("a_method").is_namespace())
@@ -346,16 +337,17 @@ def test_assigned(self):
         self.assertTrue(self.Mine.lookup("a_method").is_assigned())
         self.assertFalse(self.internal.lookup("x").is_assigned())
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_annotated(self):
         st1 = symtable.symtable('def f():\n    x: int\n', 'test', 'exec')
-        st2 = st1.get_children()[0]
+        st2 = st1.get_children()[1]
+        self.assertEqual(st2.get_type(), "function")
         self.assertTrue(st2.lookup('x').is_local())
         self.assertTrue(st2.lookup('x').is_annotated())
         self.assertFalse(st2.lookup('x').is_global())
         st3 = symtable.symtable('def f():\n    x = 1\n', 'test', 'exec')
-        st4 = st3.get_children()[0]
+        st4 = st3.get_children()[1]
+        self.assertEqual(st4.get_type(), "function")
         self.assertTrue(st4.lookup('x').is_local())
         self.assertFalse(st4.lookup('x').is_annotated())
 
@@ -373,8 +365,7 @@ def test_annotated(self):
                                 '    x: int',
                                 'test', 'exec')
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_imported(self):
         self.assertTrue(self.top.lookup("sys").is_imported())
 
@@ -384,28 +375,34 @@ def test_name(self):
         self.assertEqual(self.spam.lookup("x").get_name(), "x")
         self.assertEqual(self.Mine.get_name(), "Mine")
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_class_get_methods(self):
-        self.assertEqual(self.Mine.get_methods(), ('a_method',))
+        deprecation_mess = (
+            re.escape('symtable.Class.get_methods() is deprecated '
+                      'and will be removed in Python 3.16.')
+        )
+
+        with self.assertWarnsRegex(DeprecationWarning, deprecation_mess):
+            self.assertEqual(self.Mine.get_methods(), ('a_method',))
 
         top = symtable.symtable(TEST_COMPLEX_CLASS_CODE, "?", "exec")
         this = find_block(top, "ComplexClass")
 
-        self.assertEqual(this.get_methods(), (
-            'a_method', 'a_method_pep_695',
-            'an_async_method', 'an_async_method_pep_695',
-            'a_classmethod', 'a_classmethod_pep_695',
-            'an_async_classmethod', 'an_async_classmethod_pep_695',
-            'a_staticmethod', 'a_staticmethod_pep_695',
-            'an_async_staticmethod', 'an_async_staticmethod_pep_695',
-            'a_fakemethod', 'a_fakemethod_pep_695',
-            'an_async_fakemethod', 'an_async_fakemethod_pep_695',
-            'glob_unassigned_meth', 'glob_unassigned_meth_pep_695',
-            'glob_unassigned_async_meth', 'glob_unassigned_async_meth_pep_695',
-            'glob_assigned_meth', 'glob_assigned_meth_pep_695',
-            'glob_assigned_async_meth', 'glob_assigned_async_meth_pep_695',
-        ))
+        with self.assertWarnsRegex(DeprecationWarning, deprecation_mess):
+            self.assertEqual(this.get_methods(), (
+                'a_method', 'a_method_pep_695',
+                'an_async_method', 'an_async_method_pep_695',
+                'a_classmethod', 'a_classmethod_pep_695',
+                'an_async_classmethod', 'an_async_classmethod_pep_695',
+                'a_staticmethod', 'a_staticmethod_pep_695',
+                'an_async_staticmethod', 'an_async_staticmethod_pep_695',
+                'a_fakemethod', 'a_fakemethod_pep_695',
+                'an_async_fakemethod', 'an_async_fakemethod_pep_695',
+                'glob_unassigned_meth', 'glob_unassigned_meth_pep_695',
+                'glob_unassigned_async_meth', 'glob_unassigned_async_meth_pep_695',
+                'glob_assigned_meth', 'glob_assigned_meth_pep_695',
+                'glob_assigned_async_meth', 'glob_assigned_async_meth_pep_695',
+            ))
 
         # Test generator expressions that are of type TYPE_FUNCTION
         # but will not be reported by get_methods() since they are
@@ -418,7 +415,8 @@ def check_body(body, expected_methods):
             indented = textwrap.indent(body, ' ' * 4)
             top = symtable.symtable(f"class A:\n{indented}", "?", "exec")
             this = find_block(top, "A")
-            self.assertEqual(this.get_methods(), expected_methods)
+            with self.assertWarnsRegex(DeprecationWarning, deprecation_mess):
+                self.assertEqual(this.get_methods(), expected_methods)
 
         # statements with 'genexpr' inside it
         GENEXPRS = (
@@ -459,8 +457,7 @@ def check_body(body, expected_methods):
                         check_body('\n'.join((gen, func)), ('genexpr',))
                         check_body('\n'.join((func, gen)), ('genexpr',))
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_filename_correct(self):
         ### Bug tickler: SyntaxError file name correct whether error raised
         ### while parsing or building symbol table.
@@ -492,8 +489,7 @@ def test_single(self):
     def test_exec(self):
         symbols = symtable.symtable("def f(x): return x", "?", "exec")
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_bytes(self):
         top = symtable.symtable(TEST_CODE.encode('utf8'), "?", "exec")
         self.assertIsNotNone(find_block(top, "Mine"))
@@ -507,8 +503,7 @@ def test_symtable_repr(self):
         self.assertEqual(str(self.top), "<SymbolTable for module ?>")
         self.assertEqual(str(self.spam), "<Function SymbolTable for spam in ?>")
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_symbol_repr(self):
         self.assertEqual(repr(self.spam.lookup("glob")),
                          "<symbol 'glob': GLOBAL_IMPLICIT, USE>")
@@ -524,19 +519,67 @@ def test_symbol_repr(self):
                          "<symbol 'x': FREE, USE>")
         self.assertEqual(repr(self.other_internal.lookup("some_var")),
                          "<symbol 'some_var': FREE, USE|DEF_NONLOCAL|DEF_LOCAL>")
+        self.assertEqual(repr(self.GenericMine.lookup("T")),
+                         "<symbol 'T': LOCAL, DEF_LOCAL|DEF_TYPE_PARAM>")
+
+        st1 = symtable.symtable("[x for x in [1]]", "?", "exec")
+        self.assertEqual(repr(st1.lookup("x")),
+                         "<symbol 'x': LOCAL, USE|DEF_LOCAL|DEF_COMP_ITER>")
+
+        st2 = symtable.symtable("[(lambda: x) for x in [1]]", "?", "exec")
+        self.assertEqual(repr(st2.lookup("x")),
+                         "<symbol 'x': CELL, DEF_LOCAL|DEF_COMP_ITER|DEF_COMP_CELL>")
+
+        st3 = symtable.symtable("def f():\n"
+                                "   x = 1\n"
+                                "   class A:\n"
+                                "       x = 2\n"
+                                "       def method():\n"
+                                "           return x\n",
+                                "?", "exec")
+        # child 0 is for __annotate__
+        func_f = st3.get_children()[1]
+        class_A = func_f.get_children()[0]
+        self.assertEqual(repr(class_A.lookup('x')),
+                         "<symbol 'x': LOCAL, DEF_LOCAL|DEF_FREE_CLASS>")
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_symtable_entry_repr(self):
         expected = f"<symtable entry top({self.top.get_id()}), line {self.top.get_lineno()}>"
         self.assertEqual(repr(self.top._table), expected)
 
+    def test__symtable_refleak(self):
+        # Regression test for reference leak in PyUnicode_FSDecoder.
+        # See https://github.com/python/cpython/issues/139748.
+        mortal_str = 'this is a mortal string'
+        # check error path when 'compile_type' AC conversion failed
+        self.assertRaises(TypeError, symtable.symtable, '', mortal_str, 1)
+
+
+class ComprehensionTests(unittest.TestCase):
+    def get_identifiers_recursive(self, st, res):
+        res.extend(st.get_identifiers())
+        for ch in st.get_children():
+            self.get_identifiers_recursive(ch, res)
+
+    def test_loopvar_in_only_one_scope(self):
+        # ensure that the loop variable appears only once in the symtable
+        comps = [
+            "[x for x in [1]]",
+            "{x for x in [1]}",
+            "{x:x*x for x in [1]}",
+        ]
+        for comp in comps:
+            with self.subTest(comp=comp):
+                st = symtable.symtable(comp, "?", "exec")
+                ids = []
+                self.get_identifiers_recursive(st, ids)
+                self.assertEqual(len([x for x in ids if x == 'x']), 1)
+
 
 class CommandLineTest(unittest.TestCase):
     maxDiff = None
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_file(self):
         filename = os_helper.TESTFN
         self.addCleanup(os_helper.unlink, filename)
diff --git a/Lib/test/test_syntax.py b/Lib/test/test_syntax.py
index 5085798b81e..98246ac2214 100644
--- a/Lib/test/test_syntax.py
+++ b/Lib/test/test_syntax.py
@@ -2293,7 +2293,6 @@ def test_expression_with_assignment(self):
             offset=7
         )
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_curly_brace_after_primary_raises_immediately(self):
         self._check_error("f{}", "invalid syntax", mode="single")
 
@@ -2451,7 +2450,6 @@ def test_except_star_then_except(self):
                           r"cannot have both 'except' and 'except\*' on the same 'try'",
                           lineno=3, end_lineno=3, offset=1, end_offset=7)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_empty_line_after_linecont(self):
         # See issue-40847
         s = r"""\
diff --git a/Lib/test/test_sys.py b/Lib/test/test_sys.py
index 47039aa5114..71c2f7512b1 100644
--- a/Lib/test/test_sys.py
+++ b/Lib/test/test_sys.py
@@ -1,6 +1,5 @@
 import builtins
 import codecs
-# import _datetime # TODO: RUSTPYTHON
 import gc
 import io
 import locale
@@ -176,7 +175,6 @@ def test_original_excepthook(self):
 
         self.assertRaises(TypeError, sys.__excepthook__)
 
-    @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
@@ -211,7 +209,7 @@ class SysModuleTest(unittest.TestCase):
     def tearDown(self):
         test.support.reap_children()
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; latin-1 codec not registered
     def test_exit(self):
         # call with two arguments
         self.assertRaises(TypeError, sys.exit, 42, 42)
@@ -353,7 +351,7 @@ def test_setrecursionlimit(self):
         finally:
             sys.setrecursionlimit(old_limit)
 
-    @unittest.skipIf(getattr(sys, '_rustpython_debugbuild', False), 'TODO: RUSTPYTHON; stack overflow on debug build')
+    @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')
@@ -403,7 +401,6 @@ def test_setrecursionlimit_to_depth(self):
         finally:
             sys.setrecursionlimit(old_limit)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_getwindowsversion(self):
         # Raise SkipTest if sys doesn't have getwindowsversion attribute
         test.support.get_attribute(sys, "getwindowsversion")
@@ -434,7 +431,6 @@ def test_getwindowsversion(self):
         #  still has 5 elements
         maj, min, buildno, plat, csd = sys.getwindowsversion()
 
-    @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)
 
@@ -500,8 +496,6 @@ def test_getframemodulename(self):
         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
     @threading_helper.reap_threads
     @threading_helper.requires_working_threading()
     def test_current_frames(self):
@@ -569,7 +563,6 @@ def g456():
             leave_g.set()
             t.join()
 
-    @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):
@@ -857,7 +850,6 @@ 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",
@@ -886,7 +878,6 @@ 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)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_sys_getwindowsversion_no_instantiation(self):
         # Skip if not being run on Windows.
         test.support.get_attribute(sys, "getwindowsversion")
@@ -898,7 +889,7 @@ def test_clear_type_cache(self):
                                    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):
@@ -1063,12 +1054,12 @@ def check_locale_surrogateescape(self, locale):
                          'stdout: surrogateescape\n'
                          'stderr: backslashreplace\n')
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; iso8859_1 codec not registered
     @support.requires_subprocess()
     def test_c_locale_surrogateescape(self):
         self.check_locale_surrogateescape('C')
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; iso8859_1 codec not registered
     @support.requires_subprocess()
     def test_posix_locale_surrogateescape(self):
         self.check_locale_surrogateescape('POSIX')
@@ -1172,7 +1163,6 @@ def test_is_gil_enabled(self):
         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
@@ -1194,7 +1184,6 @@ def __del__(self):
         rc, stdout, stderr = assert_python_ok('-c', code)
         self.assertEqual(stdout.rstrip(), b'True')
 
-    @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:
@@ -1227,14 +1216,13 @@ def __del__(self):
         self.assertEqual(stdout.rstrip(), b"")
         self.assertEqual(stderr.rstrip(), b"")
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON; AttributeError: module 'sys' has no attribute '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)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     @force_not_colorized
     @support.requires_subprocess()
     def test_sys_tracebacklimit(self):
@@ -1497,6 +1485,7 @@ def hook_func(args):
     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")
 
@@ -1745,7 +1734,12 @@ def delx(self): del self.__x
             x = property(getx, setx, delx, "")
             check(x, size('5Pi'))
         # PyCapsule
-        check(_datetime.datetime_CAPI, size('6P'))
+        try:
+            import _datetime
+        except ModuleNotFoundError:
+            pass
+        else:
+            check(_datetime.datetime_CAPI, size('6P'))
         # rangeiterator
         check(iter(range(1)), size('3l'))
         check(iter(range(2**65)), size('3P'))
@@ -2230,7 +2224,7 @@ def test_jit_is_enabled(self):
         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
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; ---
     def test_jit_is_active(self):
         available = sys._jit.is_available()
         script = textwrap.dedent(
diff --git a/Lib/test/test_sys_setprofile.py b/Lib/test/test_sys_setprofile.py
index d5e3206a5ca..21a09b51926 100644
--- a/Lib/test/test_sys_setprofile.py
+++ b/Lib/test/test_sys_setprofile.py
@@ -100,8 +100,6 @@ class ProfileHookTestCase(TestCaseBase):
     def new_watcher(self):
         return HookWatcher()
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_simple(self):
         def f(p):
             pass
@@ -110,8 +108,6 @@ def f(p):
                               (1, 'return', f_ident),
                               ])
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_exception(self):
         def f(p):
             1/0
@@ -120,8 +116,6 @@ def f(p):
                               (1, 'return', f_ident),
                               ])
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_caught_exception(self):
         def f(p):
             try: 1/0
@@ -131,8 +125,6 @@ def f(p):
                               (1, 'return', f_ident),
                               ])
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_caught_nested_exception(self):
         def f(p):
             try: 1/0
@@ -142,8 +134,6 @@ def f(p):
                               (1, 'return', f_ident),
                               ])
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_nested_exception(self):
         def f(p):
             1/0
@@ -155,8 +145,6 @@ def f(p):
                               (1, 'return', f_ident),
                               ])
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_exception_in_except_clause(self):
         def f(p):
             1/0
@@ -176,8 +164,6 @@ def g(p):
                               (1, 'return', g_ident),
                               ])
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_exception_propagation(self):
         def f(p):
             1/0
@@ -193,8 +179,6 @@ def g(p):
                               (1, 'return', g_ident),
                               ])
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_raise_twice(self):
         def f(p):
             try: 1/0
@@ -204,8 +188,6 @@ def f(p):
                               (1, 'return', f_ident),
                               ])
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_raise_reraise(self):
         def f(p):
             try: 1/0
@@ -215,8 +197,6 @@ def f(p):
                               (1, 'return', f_ident),
                               ])
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_raise(self):
         def f(p):
             raise Exception()
@@ -225,8 +205,6 @@ def f(p):
                               (1, 'return', f_ident),
                               ])
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_distant_exception(self):
         def f():
             1/0
@@ -255,8 +233,6 @@ def j(p):
                               (1, 'return', j_ident),
                               ])
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_generator(self):
         def f():
             for i in range(2):
@@ -279,8 +255,6 @@ def g(p):
                               (1, 'return', g_ident),
                               ])
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_stop_iteration(self):
         def f():
             for i in range(2):
@@ -307,8 +281,6 @@ class ProfileSimulatorTestCase(TestCaseBase):
     def new_watcher(self):
         return ProfileSimulator(self)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_simple(self):
         def f(p):
             pass
@@ -317,8 +289,6 @@ def f(p):
                               (1, 'return', f_ident),
                               ])
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_basic_exception(self):
         def f(p):
             1/0
@@ -327,8 +297,6 @@ def f(p):
                               (1, 'return', f_ident),
                               ])
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_caught_exception(self):
         def f(p):
             try: 1/0
@@ -338,8 +306,6 @@ def f(p):
                               (1, 'return', f_ident),
                               ])
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_distant_exception(self):
         def f():
             1/0
@@ -368,8 +334,6 @@ def j(p):
                               (1, 'return', j_ident),
                               ])
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     # bpo-34125: profiling method_descriptor with **kwargs
     def test_unbound_method(self):
         kwargs = {}
@@ -379,8 +343,6 @@ def f(p):
         self.check_events(f, [(1, 'call', f_ident),
                               (1, 'return', f_ident)])
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     # Test an invalid call (bpo-34126)
     def test_unbound_method_no_args(self):
         def f(p):
@@ -389,8 +351,6 @@ def f(p):
         self.check_events(f, [(1, 'call', f_ident),
                               (1, 'return', f_ident)])
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     # Test an invalid call (bpo-34126)
     def test_unbound_method_invalid_args(self):
         def f(p):
@@ -399,8 +359,6 @@ def f(p):
         self.check_events(f, [(1, 'call', f_ident),
                               (1, 'return', f_ident)])
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     # Test an invalid call (bpo-34125)
     def test_unbound_method_no_keyword_args(self):
         kwargs = {}
@@ -410,8 +368,6 @@ def f(p):
         self.check_events(f, [(1, 'call', f_ident),
                               (1, 'return', f_ident)])
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     # Test an invalid call (bpo-34125)
     def test_unbound_method_invalid_keyword_args(self):
         kwargs = {}
diff --git a/Lib/test/test_sys_settrace.py b/Lib/test/test_sys_settrace.py
index a1e4b091a1d..f9449c7079a 100644
--- a/Lib/test/test_sys_settrace.py
+++ b/Lib/test/test_sys_settrace.py
@@ -1218,8 +1218,6 @@ def test_return(self):
     def test_exception(self):
         self.run_test_for_event('exception')
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_trash_stack(self):
         def f():
             for i in range(5):
@@ -1393,23 +1391,17 @@ def test(self):
 
     ## The first set of 'jump' tests are for things that are allowed:
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     @jump_test(1, 3, [3])
     def test_jump_simple_forwards(output):
         output.append(1)
         output.append(2)
         output.append(3)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     @jump_test(2, 1, [1, 1, 2])
     def test_jump_simple_backwards(output):
         output.append(1)
         output.append(2)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     @jump_test(3, 5, [2, 5])
     def test_jump_out_of_block_forwards(output):
         for i in 1, 2:
@@ -1418,8 +1410,6 @@ def test_jump_out_of_block_forwards(output):
                 output.append(4)
         output.append(5)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     @jump_test(6, 1, [1, 3, 5, 1, 3, 5, 6, 7])
     def test_jump_out_of_block_backwards(output):
         output.append(1)
@@ -1430,8 +1420,6 @@ def test_jump_out_of_block_backwards(output):
             output.append(6)
         output.append(7)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     @async_jump_test(4, 5, [3, 5])
     async def test_jump_out_of_async_for_block_forwards(output):
         for i in [1]:
@@ -1440,8 +1428,6 @@ async def test_jump_out_of_async_for_block_forwards(output):
                 output.append(4)
             output.append(5)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     @async_jump_test(5, 2, [2, 4, 2, 4, 5, 6])
     async def test_jump_out_of_async_for_block_backwards(output):
         for i in [1]:
@@ -1451,8 +1437,6 @@ async def test_jump_out_of_async_for_block_backwards(output):
                 output.append(5)
             output.append(6)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     @jump_test(1, 2, [3])
     def test_jump_to_codeless_line(output):
         output.append(1)
@@ -1465,8 +1449,6 @@ def test_jump_to_same_line(output):
         output.append(2)
         output.append(3)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     # Tests jumping within a finally block, and over one.
     @jump_test(4, 9, [2, 9])
     def test_jump_in_nested_finally(output):
@@ -1480,8 +1462,6 @@ def test_jump_in_nested_finally(output):
                 output.append(8)
             output.append(9)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     @jump_test(6, 7, [2, 7], (ZeroDivisionError, ''))
     def test_jump_in_nested_finally_2(output):
         try:
@@ -1493,8 +1473,6 @@ def test_jump_in_nested_finally_2(output):
             output.append(7)
         output.append(8)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     @jump_test(6, 11, [2, 11], (ZeroDivisionError, ''))
     def test_jump_in_nested_finally_3(output):
         try:
@@ -1535,8 +1513,6 @@ def test_no_jump_infinite_while_loop(output):
             output.append(3)
         output.append(4)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     @jump_test(2, 4, [4, 4])
     def test_jump_forwards_into_while_block(output):
         i = 1
@@ -1545,8 +1521,6 @@ def test_jump_forwards_into_while_block(output):
             output.append(4)
             i += 1
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     @jump_test(5, 3, [3, 3, 3, 5])
     def test_jump_backwards_into_while_block(output):
         i = 1
@@ -1555,40 +1529,30 @@ def test_jump_backwards_into_while_block(output):
             i += 1
         output.append(5)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     @jump_test(2, 3, [1, 3])
     def test_jump_forwards_out_of_with_block(output):
         with tracecontext(output, 1):
             output.append(2)
         output.append(3)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     @async_jump_test(2, 3, [1, 3])
     async def test_jump_forwards_out_of_async_with_block(output):
         async with asynctracecontext(output, 1):
             output.append(2)
         output.append(3)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     @jump_test(3, 1, [1, 2, 1, 2, 3, -2])
     def test_jump_backwards_out_of_with_block(output):
         output.append(1)
         with tracecontext(output, 2):
             output.append(3)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     @async_jump_test(3, 1, [1, 2, 1, 2, 3, -2])
     async def test_jump_backwards_out_of_async_with_block(output):
         output.append(1)
         async with asynctracecontext(output, 2):
             output.append(3)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     @jump_test(2, 5, [5])
     def test_jump_forwards_out_of_try_finally_block(output):
         try:
@@ -1597,8 +1561,6 @@ def test_jump_forwards_out_of_try_finally_block(output):
             output.append(4)
         output.append(5)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     @jump_test(3, 1, [1, 1, 3, 5])
     def test_jump_backwards_out_of_try_finally_block(output):
         output.append(1)
@@ -1607,8 +1569,6 @@ def test_jump_backwards_out_of_try_finally_block(output):
         finally:
             output.append(5)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     @jump_test(2, 6, [6])
     def test_jump_forwards_out_of_try_except_block(output):
         try:
@@ -1618,8 +1578,6 @@ def test_jump_forwards_out_of_try_except_block(output):
             raise
         output.append(6)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     @jump_test(3, 1, [1, 1, 3])
     def test_jump_backwards_out_of_try_except_block(output):
         output.append(1)
@@ -1629,8 +1587,6 @@ def test_jump_backwards_out_of_try_except_block(output):
             output.append(5)
             raise
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     @jump_test(5, 7, [4, 7, 8])
     def test_jump_between_except_blocks(output):
         try:
@@ -1642,8 +1598,6 @@ def test_jump_between_except_blocks(output):
             output.append(7)
         output.append(8)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     @jump_test(5, 6, [4, 6, 7])
     def test_jump_within_except_block(output):
         try:
@@ -1654,8 +1608,6 @@ def test_jump_within_except_block(output):
             output.append(6)
         output.append(7)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     @jump_test(2, 4, [1, 4, 5, -4])
     def test_jump_across_with(output):
         output.append(1)
@@ -1664,8 +1616,6 @@ def test_jump_across_with(output):
         with tracecontext(output, 4):
             output.append(5)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     @async_jump_test(2, 4, [1, 4, 5, -4])
     async def test_jump_across_async_with(output):
         output.append(1)
@@ -1674,8 +1624,6 @@ async def test_jump_across_async_with(output):
         async with asynctracecontext(output, 4):
             output.append(5)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     @jump_test(4, 5, [1, 3, 5, 6])
     def test_jump_out_of_with_block_within_for_block(output):
         output.append(1)
@@ -1685,8 +1633,6 @@ def test_jump_out_of_with_block_within_for_block(output):
             output.append(5)
         output.append(6)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     @async_jump_test(4, 5, [1, 3, 5, 6])
     async def test_jump_out_of_async_with_block_within_for_block(output):
         output.append(1)
@@ -1696,8 +1642,6 @@ async def test_jump_out_of_async_with_block_within_for_block(output):
             output.append(5)
         output.append(6)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     @jump_test(4, 5, [1, 2, 3, 5, -2, 6])
     def test_jump_out_of_with_block_within_with_block(output):
         output.append(1)
@@ -1707,8 +1651,6 @@ def test_jump_out_of_with_block_within_with_block(output):
             output.append(5)
         output.append(6)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     @async_jump_test(4, 5, [1, 2, 3, 5, -2, 6])
     async def test_jump_out_of_async_with_block_within_with_block(output):
         output.append(1)
@@ -1718,8 +1660,6 @@ async def test_jump_out_of_async_with_block_within_with_block(output):
             output.append(5)
         output.append(6)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     @jump_test(5, 6, [2, 4, 6, 7])
     def test_jump_out_of_with_block_within_finally_block(output):
         try:
@@ -1730,8 +1670,6 @@ def test_jump_out_of_with_block_within_finally_block(output):
             output.append(6)
         output.append(7)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     @async_jump_test(5, 6, [2, 4, 6, 7])
     async def test_jump_out_of_async_with_block_within_finally_block(output):
         try:
@@ -1742,8 +1680,6 @@ async def test_jump_out_of_async_with_block_within_finally_block(output):
             output.append(6)
         output.append(7)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     @jump_test(8, 11, [1, 3, 5, 11, 12])
     def test_jump_out_of_complex_nested_blocks(output):
         output.append(1)
@@ -1759,8 +1695,6 @@ def test_jump_out_of_complex_nested_blocks(output):
             output.append(11)
         output.append(12)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     @jump_test(3, 5, [1, 2, 5])
     def test_jump_out_of_with_assignment(output):
         output.append(1)
@@ -1769,8 +1703,6 @@ def test_jump_out_of_with_assignment(output):
             output.append(4)
         output.append(5)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     @async_jump_test(3, 5, [1, 2, 5])
     async def test_jump_out_of_async_with_assignment(output):
         output.append(1)
@@ -1779,8 +1711,6 @@ async def test_jump_out_of_async_with_assignment(output):
             output.append(4)
         output.append(5)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     @jump_test(3, 6, [1, 6, 8, 9])
     def test_jump_over_return_in_try_finally_block(output):
         output.append(1)
@@ -1793,8 +1723,6 @@ def test_jump_over_return_in_try_finally_block(output):
             output.append(8)
         output.append(9)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     @jump_test(5, 8, [1, 3, 8, 10, 11, 13])
     def test_jump_over_break_in_try_finally_block(output):
         output.append(1)
@@ -1811,8 +1739,6 @@ def test_jump_over_break_in_try_finally_block(output):
             break
         output.append(13)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     @jump_test(1, 7, [7, 8])
     def test_jump_over_for_block_before_else(output):
         output.append(1)
@@ -1824,8 +1750,6 @@ def test_jump_over_for_block_before_else(output):
             output.append(7)
         output.append(8)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     @async_jump_test(1, 7, [7, 8])
     async def test_jump_over_async_for_block_before_else(output):
         output.append(1)
@@ -1839,15 +1763,11 @@ async def test_jump_over_async_for_block_before_else(output):
 
     # The second set of 'jump' tests are for things that are not allowed:
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     @jump_test(2, 3, [1], (ValueError, 'after'))
     def test_no_jump_too_far_forwards(output):
         output.append(1)
         output.append(2)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     @jump_test(2, -2, [1], (ValueError, 'before'))
     def test_no_jump_too_far_backwards(output):
         output.append(1)
@@ -1894,8 +1814,6 @@ def test_no_jump_to_except_4(output):
             output.append(4)
             raise e
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     @jump_test(1, 3, [], (ValueError, 'into'))
     def test_no_jump_forwards_into_for_block(output):
         output.append(1)
@@ -1911,8 +1829,6 @@ async def test_no_jump_forwards_into_async_for_block(output):
             output.append(3)
         pass
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     @jump_test(3, 2, [2, 2], (ValueError, 'into'))
     def test_no_jump_backwards_into_for_block(output):
         for i in 1, 2:
@@ -2015,8 +1931,6 @@ def test_no_jump_between_except_blocks_2(output):
             output.append(7)
         output.append(8)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     @jump_test(1, 5, [5])
     def test_jump_into_finally_block(output):
         output.append(1)
@@ -2025,8 +1939,6 @@ def test_jump_into_finally_block(output):
         finally:
             output.append(5)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     @jump_test(3, 6, [2, 6, 7])
     def test_jump_into_finally_block_from_try_block(output):
         try:
@@ -2037,8 +1949,6 @@ def test_jump_into_finally_block_from_try_block(output):
             output.append(6)
         output.append(7)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     @jump_test(5, 1, [1, 3, 1, 3, 5])
     def test_jump_out_of_finally_block(output):
         output.append(1)
@@ -2080,8 +1990,6 @@ def test_no_jump_into_bare_except_block_from_try_block(output):
             raise
         output.append(8)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     @jump_test(3, 6, [2], (ValueError, "into an 'except'"))
     def test_no_jump_into_qualified_except_block_from_try_block(output):
         try:
@@ -2117,8 +2025,6 @@ def test_no_jump_out_of_qualified_except_block(output):
             output.append(6)
             output.append(7)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     @jump_test(3, 5, [1, 2, 5, -2])
     def test_jump_between_with_blocks(output):
         output.append(1)
@@ -2127,8 +2033,6 @@ def test_jump_between_with_blocks(output):
         with tracecontext(output, 4):
             output.append(5)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     @async_jump_test(3, 5, [1, 2, 5, -2])
     async def test_jump_between_async_with_blocks(output):
         output.append(1)
@@ -2137,8 +2041,6 @@ async def test_jump_between_async_with_blocks(output):
         async with asynctracecontext(output, 4):
             output.append(5)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     @jump_test(5, 7, [2, 4], (ValueError, "after"))
     def test_no_jump_over_return_out_of_finally_block(output):
         try:
@@ -2149,8 +2051,6 @@ def test_no_jump_over_return_out_of_finally_block(output):
             return
         output.append(7)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     @jump_test(7, 4, [1, 6], (ValueError, 'into'))
     def test_no_jump_into_for_block_before_else(output):
         output.append(1)
@@ -2187,8 +2087,6 @@ def test_no_jump_without_trace_function(self):
         # triggered.
         no_jump_without_trace_function()
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_large_function(self):
         d = {}
         exec("""def f(output):        # line 0
@@ -2203,8 +2101,6 @@ def test_large_function(self):
         f = d['f']
         self.run_test(f, 2, 1007, [0])
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_jump_to_firstlineno(self):
         # This tests that PDB can jump back to the first line in a
         # file.  See issue #1689458.  It can only be triggered in a
diff --git a/Lib/test/test_sysconfig.py b/Lib/test/test_sysconfig.py
index 82c11bdf7e2..7da1326a721 100644
--- a/Lib/test/test_sysconfig.py
+++ b/Lib/test/test_sysconfig.py
@@ -9,8 +9,10 @@
 import textwrap
 from copy import copy
 
+from test import support
 from test.support import (
     captured_stdout,
+    is_android,
     is_apple_mobile,
     is_wasi,
     PythonSymlink,
@@ -19,14 +21,15 @@
 from test.support.import_helper import import_module
 from test.support.os_helper import (TESTFN, unlink, skip_unless_symlink,
                                     change_cwd)
-from test.support.venv import VirtualEnvironment
+from test.support.venv import VirtualEnvironmentMixin
 
 import sysconfig
 from sysconfig import (get_paths, get_platform, get_config_vars,
                        get_path, get_path_names, _INSTALL_SCHEMES,
                        get_default_scheme, get_scheme_names, get_config_var,
-                       _expand_vars, _get_preferred_schemes)
-from sysconfig.__main__ import _main, _parse_makefile
+                       _expand_vars, _get_preferred_schemes,
+                       is_python_build, _PROJECT_BASE)
+from sysconfig.__main__ import _main, _parse_makefile, _get_pybuilddir, _get_json_data_name
 import _imp
 import _osx_support
 import _sysconfig
@@ -35,10 +38,11 @@
 HAS_USER_BASE = sysconfig._HAS_USER_BASE
 
 
-class TestSysConfig(unittest.TestCase):
+class TestSysConfig(unittest.TestCase, VirtualEnvironmentMixin):
 
     def setUp(self):
         super(TestSysConfig, self).setUp()
+        self.maxDiff = None
         self.sys_path = sys.path[:]
         # patching os.uname
         if hasattr(os, 'uname'):
@@ -50,6 +54,8 @@ def setUp(self):
         os.uname = self._get_uname
         # saving the environment
         self.name = os.name
+        self.prefix = sys.prefix
+        self.exec_prefix = sys.exec_prefix
         self.platform = sys.platform
         self.version = sys.version
         self._framework = sys._framework
@@ -74,6 +80,8 @@ def tearDown(self):
         else:
             del os.uname
         os.name = self.name
+        sys.prefix = self.prefix
+        sys.exec_prefix = self.exec_prefix
         sys.platform = self.platform
         sys.version = self.version
         sys._framework = self._framework
@@ -104,12 +112,6 @@ def _cleanup_testfn(self):
         elif os.path.isdir(path):
             shutil.rmtree(path)
 
-    def venv(self, **venv_create_args):
-        return VirtualEnvironment.from_tmpdir(
-            prefix=f'{self.id()}-venv-',
-            **venv_create_args,
-        )
-
     def test_get_path_names(self):
         self.assertEqual(get_path_names(), sysconfig._SCHEME_KEYS)
 
@@ -160,14 +162,14 @@ def test_get_preferred_schemes(self):
         self.assertIsInstance(schemes, dict)
         self.assertEqual(set(schemes), expected_schemes)
 
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; ?          ++++
     def test_posix_venv_scheme(self):
         # The following directories were hardcoded in the venv module
         # before bpo-45413, here we assert the posix_venv scheme does not regress
         binpath = 'bin'
         incpath = 'include'
         libpath = os.path.join('lib',
-                               # XXX: RUSTPYTHON
-                               f'rustpython{sysconfig._get_python_version_abi()}',
+                               f'python{sysconfig._get_python_version_abi()}',
                                'site-packages')
 
         # Resolve the paths in an imaginary venv/ directory
@@ -185,7 +187,7 @@ def test_posix_venv_scheme(self):
         # The include directory on POSIX isn't exactly the same as before,
         # but it is "within"
         sysconfig_includedir = sysconfig.get_path('include', scheme='posix_venv', vars=vars)
-        self.assertTrue(sysconfig_includedir.startswith(incpath + os.sep))
+        self.assertStartsWith(sysconfig_includedir, incpath + os.sep)
 
     def test_nt_venv_scheme(self):
         # The following directories were hardcoded in the venv module
@@ -386,7 +388,7 @@ def test_get_platform(self):
 
         # XXX more platforms to tests here
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AssertionError: False is not true : /Users/youknowone/Projects/RustPython2/include/python3.14t/pyconfig.h
     @unittest.skipIf(is_wasi, "Incompatible with WASI mapdir and OOT builds")
     @unittest.skipIf(is_apple_mobile,
                      f"{sys.platform} doesn't distribute header files in the runtime environment")
@@ -459,25 +461,25 @@ def test_soabi(self):
         soabi = sysconfig.get_config_var('SOABI')
         self.assertIn(soabi, _imp.extension_suffixes()[0])
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AssertionError: Expected str, not NoneType
     def test_library(self):
         library = sysconfig.get_config_var('LIBRARY')
         ldlibrary = sysconfig.get_config_var('LDLIBRARY')
         major, minor = sys.version_info[:2]
-        if sys.platform == 'win32':
-            self.assertTrue(library.startswith(f'python{major}{minor}'))
-            self.assertTrue(library.endswith('.dll'))
+        abiflags = sysconfig.get_config_var('ABIFLAGS')
+        if sys.platform.startswith('win'):
+            self.assertEqual(library, f'python{major}{minor}{abiflags}.dll')
             self.assertEqual(library, ldlibrary)
         elif is_apple_mobile:
             framework = sysconfig.get_config_var('PYTHONFRAMEWORK')
             self.assertEqual(ldlibrary, f"{framework}.framework/{framework}")
         else:
-            self.assertTrue(library.startswith(f'libpython{major}.{minor}'))
-            self.assertTrue(library.endswith('.a'))
+            self.assertStartsWith(library, f'libpython{major}.{minor}')
+            self.assertEndsWith(library, '.a')
             if sys.platform == 'darwin' and sys._framework:
                 self.skipTest('gh-110824: skip LDLIBRARY test for framework build')
             else:
-                self.assertTrue(ldlibrary.startswith(f'libpython{major}.{minor}'))
+                self.assertStartsWith(ldlibrary, f'libpython{major}.{minor}')
 
     @unittest.skipUnless(sys.platform == "darwin", "test only relevant on MacOSX")
     @requires_subprocess()
@@ -523,7 +525,7 @@ def test_platform_in_subprocess(self):
         self.assertEqual(status, 0)
         self.assertEqual(my_platform, test_platform)
 
-    @unittest.expectedFailureIf(sys.platform != 'win32', 'TODO: RUSTPYTHON')
+    @unittest.expectedFailureIf(sys.platform != "win32", "TODO: RUSTPYTHON")
     @unittest.skipIf(is_wasi, "Incompatible with WASI mapdir and OOT builds")
     @unittest.skipIf(is_apple_mobile,
                      f"{sys.platform} doesn't include config folder at runtime")
@@ -540,13 +542,10 @@ def test_srcdir(self):
             Python_h = os.path.join(srcdir, 'Include', 'Python.h')
             self.assertTrue(os.path.exists(Python_h), Python_h)
             # <srcdir>/PC/pyconfig.h.in always exists even if unused
-            pyconfig_h = os.path.join(srcdir, 'PC', 'pyconfig.h.in')
-            self.assertTrue(os.path.exists(pyconfig_h), pyconfig_h)
             pyconfig_h_in = os.path.join(srcdir, 'pyconfig.h.in')
             self.assertTrue(os.path.exists(pyconfig_h_in), pyconfig_h_in)
             if os.name == 'nt':
-                # <executable dir>/pyconfig.h exists on Windows in a build tree
-                pyconfig_h = os.path.join(sys.executable, '..', 'pyconfig.h')
+                pyconfig_h = os.path.join(srcdir, 'PC', 'pyconfig.h')
                 self.assertTrue(os.path.exists(pyconfig_h), pyconfig_h)
         elif os.name == 'posix':
             makefile_dir = os.path.dirname(sysconfig.get_makefile_filename())
@@ -581,10 +580,8 @@ def test_linux_ext_suffix(self):
                 expected_suffixes = 'i386-linux-gnu.so', 'x86_64-linux-gnux32.so', 'i386-linux-musl.so'
             else: # 8 byte pointer size
                 expected_suffixes = 'x86_64-linux-gnu.so', 'x86_64-linux-musl.so'
-            self.assertTrue(suffix.endswith(expected_suffixes),
-                            f'unexpected suffix {suffix!r}')
+            self.assertEndsWith(suffix, expected_suffixes)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     @unittest.skipUnless(sys.platform == 'android', 'Android-specific test')
     def test_android_ext_suffix(self):
         machine = platform.machine()
@@ -595,86 +592,169 @@ def test_android_ext_suffix(self):
             "aarch64": "aarch64-linux-android",
             "armv7l": "arm-linux-androideabi",
         }[machine]
-        self.assertTrue(suffix.endswith(f"-{expected_triplet}.so"),
-                        f"{machine=}, {suffix=}")
+        self.assertEndsWith(suffix, f"-{expected_triplet}.so")
 
     @unittest.skipUnless(sys.platform == 'darwin', 'OS X-specific test')
     def test_osx_ext_suffix(self):
         suffix = sysconfig.get_config_var('EXT_SUFFIX')
-        self.assertTrue(suffix.endswith('-darwin.so'), suffix)
+        self.assertEndsWith(suffix, '-darwin.so')
+
+    def test_always_set_py_debug(self):
+        self.assertIn('Py_DEBUG', sysconfig.get_config_vars())
+        Py_DEBUG = sysconfig.get_config_var('Py_DEBUG')
+        self.assertIn(Py_DEBUG, (0, 1))
+        self.assertEqual(Py_DEBUG, support.Py_DEBUG)
+
+    def test_always_set_py_gil_disabled(self):
+        self.assertIn('Py_GIL_DISABLED', sysconfig.get_config_vars())
+        Py_GIL_DISABLED = sysconfig.get_config_var('Py_GIL_DISABLED')
+        self.assertIn(Py_GIL_DISABLED, (0, 1))
+        self.assertEqual(Py_GIL_DISABLED, support.Py_GIL_DISABLED)
+
+    def test_abiflags(self):
+        # If this test fails on some platforms, maintainers should update the
+        # test to make it pass, rather than changing the definition of ABIFLAGS.
+        self.assertIn('abiflags', sysconfig.get_config_vars())
+        self.assertIn('ABIFLAGS', sysconfig.get_config_vars())
+        abiflags = sysconfig.get_config_var('abiflags')
+        ABIFLAGS = sysconfig.get_config_var('ABIFLAGS')
+        self.assertIsInstance(abiflags, str)
+        self.assertIsInstance(ABIFLAGS, str)
+        self.assertIn(abiflags, ABIFLAGS)
+        if os.name == 'nt':
+            self.assertEqual(abiflags, '')
+
+        if not sys.platform.startswith('win'):
+            valid_abiflags = ('', 't', 'd', 'td')
+        else:
+            # Windows uses '_d' rather than 'd'; see also test_abi_debug below
+            valid_abiflags = ('', 't', '_d', 't_d')
+
+        self.assertIn(ABIFLAGS, valid_abiflags)
+
+    def test_abi_debug(self):
+        ABIFLAGS = sysconfig.get_config_var('ABIFLAGS')
+        if support.Py_DEBUG:
+            self.assertIn('d', ABIFLAGS)
+        else:
+            self.assertNotIn('d', ABIFLAGS)
+
+        # The 'd' flag should always be the last one on Windows.
+        # On Windows, the debug flag is used differently with a underscore prefix.
+        # For example, `python{X}.{Y}td` on Unix and `python{X}.{Y}t_d.exe` on Windows.
+        if support.Py_DEBUG and sys.platform.startswith('win'):
+            self.assertEndsWith(ABIFLAGS, '_d')
+
+    def test_abi_thread(self):
+        abi_thread = sysconfig.get_config_var('abi_thread')
+        ABIFLAGS = sysconfig.get_config_var('ABIFLAGS')
+        self.assertIsInstance(abi_thread, str)
+        if support.Py_GIL_DISABLED:
+            self.assertEqual(abi_thread, 't')
+            self.assertIn('t', ABIFLAGS)
+        else:
+            self.assertEqual(abi_thread, '')
+            self.assertNotIn('t', ABIFLAGS)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     @requires_subprocess()
-    def test_config_vars_depend_on_site_initialization(self):
+    @unittest.skipIf(os.name == 'nt', 'TODO: RUSTPYTHON; venv creates python.exe but sys.executable is rustpython.exe')
+    def test_makefile_overwrites_config_vars(self):
         script = textwrap.dedent("""
-            import sysconfig
+            import sys, sysconfig
 
-            config_vars = sysconfig.get_config_vars()
+            data = {
+                'prefix': sys.prefix,
+                'exec_prefix': sys.exec_prefix,
+                'base_prefix': sys.base_prefix,
+                'base_exec_prefix': sys.base_exec_prefix,
+                'config_vars': sysconfig.get_config_vars(),
+            }
 
             import json
-            print(json.dumps(config_vars, indent=2))
+            print(json.dumps(data, indent=2))
         """)
 
+        # We need to run the test inside a virtual environment so that
+        # sys.prefix/sys.exec_prefix have a different value from the
+        # prefix/exec_prefix Makefile variables.
         with self.venv() as venv:
-            site_config_vars = json.loads(venv.run('-c', script).stdout)
-            no_site_config_vars = json.loads(venv.run('-S', '-c', script).stdout)
-
-        self.assertNotEqual(site_config_vars, no_site_config_vars)
-        # With the site initialization, the virtual environment should be enabled.
-        self.assertEqual(site_config_vars['base'], venv.prefix)
-        self.assertEqual(site_config_vars['platbase'], venv.prefix)
-        #self.assertEqual(site_config_vars['prefix'], venv.prefix)  # # FIXME: prefix gets overwriten by _init_posix
-        # Without the site initialization, the virtual environment should be disabled.
-        self.assertEqual(no_site_config_vars['base'], site_config_vars['installed_base'])
-        self.assertEqual(no_site_config_vars['platbase'], site_config_vars['installed_platbase'])
-
-    @unittest.expectedFailure # TODO: RUSTPYTHON
-    @requires_subprocess()
-    def test_config_vars_recalculation_after_site_initialization(self):
-        script = textwrap.dedent("""
-            import sysconfig
+            data = json.loads(venv.run('-c', script).stdout)
+
+        # We expect sysconfig.get_config_vars to correctly reflect sys.prefix/sys.exec_prefix
+        self.assertEqual(data['prefix'], data['config_vars']['prefix'])
+        self.assertEqual(data['exec_prefix'], data['config_vars']['exec_prefix'])
+        # As a sanity check, just make sure sys.prefix/sys.exec_prefix really
+        # are different from the Makefile values.
+        # sys.base_prefix/sys.base_exec_prefix should reflect the value of the
+        # prefix/exec_prefix Makefile variables, so we use them in the comparison.
+        self.assertNotEqual(data['prefix'], data['base_prefix'])
+        self.assertNotEqual(data['exec_prefix'], data['base_exec_prefix'])
+
+    @unittest.skipIf(os.name != 'posix', '_sysconfig-vars JSON file is only available on POSIX')
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; JSON is generated at build time in CPython
+    @unittest.skipIf(is_wasi, "_sysconfig-vars JSON file currently isn't available on WASI")
+    @unittest.skipIf(is_android or is_apple_mobile, 'Android and iOS change the prefix')
+    def test_sysconfigdata_json(self):
+        if '_PYTHON_SYSCONFIGDATA_PATH' in os.environ:
+            data_dir = os.environ['_PYTHON_SYSCONFIGDATA_PATH']
+        elif is_python_build():
+            data_dir = os.path.join(_PROJECT_BASE, _get_pybuilddir())
+        else:
+            data_dir = sys._stdlib_dir
 
-            before = sysconfig.get_config_vars()
+        json_data_path = os.path.join(data_dir, _get_json_data_name())
 
-            import site
-            site.main()
+        with open(json_data_path) as f:
+            json_config_vars = json.load(f)
 
-            after = sysconfig.get_config_vars()
+        system_config_vars = get_config_vars()
 
-            import json
-            print(json.dumps({'before': before, 'after': after}, indent=2))
-        """)
+        # Keys dependent on uncontrollable external context
+        ignore_keys = {'userbase'}
+        # Keys dependent on Python being run outside the build directrory
+        if sysconfig.is_python_build():
+            ignore_keys |= {'srcdir'}
+        # Keys dependent on the executable location
+        if os.path.dirname(sys.executable) != system_config_vars['BINDIR']:
+            ignore_keys |= {'projectbase'}
+        # Keys dependent on the environment (different inside virtual environments)
+        if sys.prefix != sys.base_prefix:
+            ignore_keys |= {'prefix', 'exec_prefix', 'base', 'platbase'}
+        # Keys dependent on Python being run from the prefix targetted when building (different on relocatable installs)
+        if sysconfig._installation_is_relocated():
+            ignore_keys |= {'prefix', 'exec_prefix', 'base', 'platbase', 'installed_base', 'installed_platbase', 'srcdir'}
 
-        with self.venv() as venv:
-            config_vars = json.loads(venv.run('-S', '-c', script).stdout)
+        for key in ignore_keys:
+            json_config_vars.pop(key, None)
+            system_config_vars.pop(key, None)
 
-        self.assertNotEqual(config_vars['before'], config_vars['after'])
-        self.assertEqual(config_vars['after']['base'], venv.prefix)
-        #self.assertEqual(config_vars['after']['prefix'], venv.prefix)  # FIXME: prefix gets overwriten by _init_posix
-        #self.assertEqual(config_vars['after']['exec_prefix'], venv.prefix)  # FIXME: exec_prefix gets overwriten by _init_posix
+        self.assertEqual(system_config_vars, json_config_vars)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
-    @requires_subprocess()
-    def test_paths_depend_on_site_initialization(self):
-        script = textwrap.dedent("""
-            import sysconfig
+    def test_sysconfig_config_vars_no_prefix_cache(self):
+        sys.prefix = 'prefix-AAA'
+        sys.exec_prefix = 'exec-prefix-AAA'
 
-            paths = sysconfig.get_paths()
+        config_vars = sysconfig.get_config_vars()
 
-            import json
-            print(json.dumps(paths, indent=2))
-        """)
+        self.assertEqual(config_vars['prefix'], sys.prefix)
+        self.assertEqual(config_vars['base'], sys.prefix)
+        self.assertEqual(config_vars['exec_prefix'], sys.exec_prefix)
+        self.assertEqual(config_vars['platbase'], sys.exec_prefix)
 
-        with self.venv() as venv:
-            site_paths = json.loads(venv.run('-c', script).stdout)
-            no_site_paths = json.loads(venv.run('-S', '-c', script).stdout)
+        sys.prefix = 'prefix-BBB'
+        sys.exec_prefix = 'exec-prefix-BBB'
 
-        self.assertNotEqual(site_paths, no_site_paths)
+        config_vars = sysconfig.get_config_vars()
+
+        self.assertEqual(config_vars['prefix'], sys.prefix)
+        self.assertEqual(config_vars['base'], sys.prefix)
+        self.assertEqual(config_vars['exec_prefix'], sys.exec_prefix)
+        self.assertEqual(config_vars['platbase'], sys.exec_prefix)
 
 
 class MakefileTests(unittest.TestCase):
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AssertionError: False is not true : /Users/youknowone/Projects/RustPython2/lib/python3.14t/config-3.14t-aarch64-apple-darwin/Makefile
     @unittest.skipIf(sys.platform.startswith('win'),
                      'Test is not Windows compatible')
     @unittest.skipIf(is_wasi, "Incompatible with WASI mapdir and OOT builds")
@@ -712,6 +792,18 @@ def deprecated(self, removal_version, deprecation_msg=None, error=Exception, err
         else:
             return self.assertWarns(DeprecationWarning, msg=deprecation_msg)
 
+    def test_expand_makefile_vars(self):
+        with self.deprecated(
+            removal_version=(3, 16),
+            deprecation_msg=(
+                'sysconfig.expand_makefile_vars is deprecated and will be removed in '
+                'Python 3.16. Use sysconfig.get_paths(vars=...) instead.',
+            ),
+            error=AttributeError,
+            error_msg="module 'sysconfig' has no attribute 'expand_makefile_vars'",
+        ):
+            sysconfig.expand_makefile_vars('', {})
+
     def test_is_python_build_check_home(self):
         with self.deprecated(
             removal_version=(3, 15),
diff --git a/Lib/test/test_tabnanny.py b/Lib/test/test_tabnanny.py
index aa71166a380..d7a77eb26e4 100644
--- a/Lib/test/test_tabnanny.py
+++ b/Lib/test/test_tabnanny.py
@@ -14,7 +14,7 @@
                           findfile)
 from test.support.os_helper import unlink
 
-import unittest # TODO: RUSTPYTHON
+import unittest  # XXX: RUSTPYTHON; importing to be able to skip tests
 
 
 SOURCE_CODES = {
@@ -217,8 +217,7 @@ def test_when_tokenize_tokenerror(self):
             with self.assertRaises(SystemExit):
                 self.verify_tabnanny_check(file_path, err=err)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; A python source code file eligible for raising `tabnanny.NannyNag`.
     def test_when_nannynag_error_verbose(self):
         """A python source code file eligible for raising `tabnanny.NannyNag`.
 
@@ -232,8 +231,7 @@ def test_when_nannynag_error_verbose(self):
             tabnanny.verbose = 1
             self.verify_tabnanny_check(file_path, out=out)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; A python source code file eligible for raising `tabnanny.NannyNag`.
     def test_when_nannynag_error(self):
         """A python source code file eligible for raising `tabnanny.NannyNag`."""
         with TemporaryPyFile(SOURCE_CODES["nannynag_errored"]) as file_path:
@@ -318,8 +316,6 @@ def validate_cmd(self, *args, stdout="", stderr="", partial=False, expect_failur
             self.assertListEqual(out.splitlines(), stdout.splitlines())
             self.assertListEqual(err.splitlines(), stderr.splitlines())
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_with_errored_file(self):
         """Should displays error when errored python file is given."""
         with TemporaryPyFile(SOURCE_CODES["wrong_indented"]) as file_path:
@@ -345,8 +341,7 @@ def test_quiet_flag(self):
             stdout = f"{file_path}\n"
             self.validate_cmd("-q", file_path, stdout=stdout)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_verbose_mode(self):
         """Should display more error information if verbose mode is on."""
         with TemporaryPyFile(SOURCE_CODES["nannynag_errored"]) as path:
@@ -355,8 +350,7 @@ def test_verbose_mode(self):
             ).strip()
             self.validate_cmd("-v", path, stdout=stdout, partial=True)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_double_verbose_mode(self):
         """Should display detailed error information if double verbose is on."""
         with TemporaryPyFile(SOURCE_CODES["nannynag_errored"]) as path:
diff --git a/Lib/test/test_tarfile.py b/Lib/test/test_tarfile.py
index 92ce7c32a00..d6cbb350428 100644
--- a/Lib/test/test_tarfile.py
+++ b/Lib/test/test_tarfile.py
@@ -1,18 +1,25 @@
+import errno
 import sys
 import os
 import io
 from hashlib import sha256
-from contextlib import contextmanager
+from contextlib import contextmanager, ExitStack
 from random import Random
 import pathlib
+import shutil
+import re
+import warnings
+import stat
 
 import unittest
 import unittest.mock
 import tarfile
 
+from test import archiver_tests
 from test import support
 from test.support import os_helper
 from test.support import script_helper
+from test.support import warnings_helper
 
 # Check for our compression modules.
 try:
@@ -33,18 +40,24 @@
     lzma = None
 # XXX: RUSTPYTHON; xz is not supported yet
 lzma = None
+try:
+    from compression import zstd
+except ImportError:
+    zstd = None
 
 def sha256sum(data):
     return sha256(data).hexdigest()
 
 TEMPDIR = os.path.abspath(os_helper.TESTFN) + "-tardir"
 tarextdir = TEMPDIR + '-extract-test'
-tarname = support.findfile("testtar.tar")
+tarname = support.findfile("testtar.tar", subdir="archivetestdata")
 gzipname = os.path.join(TEMPDIR, "testtar.tar.gz")
 bz2name = os.path.join(TEMPDIR, "testtar.tar.bz2")
 xzname = os.path.join(TEMPDIR, "testtar.tar.xz")
+zstname = os.path.join(TEMPDIR, "testtar.tar.zst")
 tmpname = os.path.join(TEMPDIR, "tmp.tar")
 dotlessname = os.path.join(TEMPDIR, "testtar")
+SPACE = b" "
 
 sha256_regtype = (
     "e09e4bc8b3c9d9177e77256353b36c159f5f040531bbd4b024a8f9b9196c71ce"
@@ -85,6 +98,12 @@ class LzmaTest:
     open = lzma.LZMAFile if lzma else None
     taropen = tarfile.TarFile.xzopen
 
+@support.requires_zstd()
+class ZstdTest:
+    tarname = zstname
+    suffix = 'zst'
+    open = zstd.ZstdFile if zstd else None
+    taropen = tarfile.TarFile.zstopen
 
 class ReadTest(TarTest):
 
@@ -97,6 +116,14 @@ def setUp(self):
     def tearDown(self):
         self.tar.close()
 
+class StreamModeTest(ReadTest):
+
+    # Only needs to change how the tarfile is opened to set
+    # stream mode
+    def setUp(self):
+        self.tar = tarfile.open(self.tarname, mode=self.mode,
+                                encoding="iso8859-1",
+                                stream=True)
 
 class UstarReadTest(ReadTest, unittest.TestCase):
 
@@ -110,7 +137,7 @@ def test_fileobj_regular_file(self):
                     "regular file extraction failed")
 
     def test_fileobj_readlines(self):
-        self.tar.extract("ustar/regtype", TEMPDIR)
+        self.tar.extract("ustar/regtype", TEMPDIR, filter='data')
         tarinfo = self.tar.getmember("ustar/regtype")
         with open(os.path.join(TEMPDIR, "ustar/regtype"), "r") as fobj1:
             lines1 = fobj1.readlines()
@@ -128,7 +155,7 @@ def test_fileobj_readlines(self):
                     "fileobj.readlines() failed")
 
     def test_fileobj_iter(self):
-        self.tar.extract("ustar/regtype", TEMPDIR)
+        self.tar.extract("ustar/regtype", TEMPDIR, filter='data')
         tarinfo = self.tar.getmember("ustar/regtype")
         with open(os.path.join(TEMPDIR, "ustar/regtype"), "r") as fobj1:
             lines1 = fobj1.readlines()
@@ -138,7 +165,8 @@ def test_fileobj_iter(self):
                     "fileobj.__iter__() failed")
 
     def test_fileobj_seek(self):
-        self.tar.extract("ustar/regtype", TEMPDIR)
+        self.tar.extract("ustar/regtype", TEMPDIR,
+                         filter='data')
         with open(os.path.join(TEMPDIR, "ustar/regtype"), "rb") as fobj:
             data = fobj.read()
 
@@ -227,13 +255,19 @@ def test_add_dir_getmember(self):
         self.add_dir_and_getmember('bar')
         self.add_dir_and_getmember('a'*101)
 
+    @unittest.skipUnless(hasattr(os, "getuid") and hasattr(os, "getgid"),
+                         "Missing getuid or getgid implementation")
     def add_dir_and_getmember(self, name):
+        def filter(tarinfo):
+            tarinfo.uid = tarinfo.gid = 100
+            return tarinfo
+
         with os_helper.temp_cwd():
             with tarfile.open(tmpname, 'w') as tar:
                 tar.format = tarfile.USTAR_FORMAT
                 try:
                     os.mkdir(name)
-                    tar.add(name)
+                    tar.add(name, filter=filter)
                 finally:
                     os.rmdir(name)
             with tarfile.open(tmpname) as tar:
@@ -251,6 +285,8 @@ class Bz2UstarReadTest(Bz2Test, UstarReadTest):
 class LzmaUstarReadTest(LzmaTest, UstarReadTest):
     pass
 
+class ZstdUstarReadTest(ZstdTest, UstarReadTest):
+    pass
 
 class ListTest(ReadTest, unittest.TestCase):
 
@@ -304,11 +340,23 @@ def test_list_verbose(self):
         # accessories if verbose flag is being used
         # ...
         # ?rw-r--r-- tarfile/tarfile     7011 2003-01-06 07:19:43 ustar/conttype
-        # ?rw-r--r-- tarfile/tarfile     7011 2003-01-06 07:19:43 ustar/regtype
+        # -rw-r--r-- tarfile/tarfile     7011 2003-01-06 07:19:43 ustar/regtype
+        # drwxr-xr-x tarfile/tarfile        0 2003-01-05 15:19:43 ustar/dirtype/
         # ...
-        self.assertRegex(out, (br'\?rw-r--r-- tarfile/tarfile\s+7011 '
-                               br'\d{4}-\d\d-\d\d\s+\d\d:\d\d:\d\d '
-                               br'ustar/\w+type ?\r?\n') * 2)
+        #
+        # Array of values to modify the regex below:
+        #  ((file_type, file_permissions, file_length), ...)
+        type_perm_lengths = (
+            (br'\?', b'rw-r--r--', b'7011'), (b'-', b'rw-r--r--', b'7011'),
+            (b'd', b'rwxr-xr-x', b'0'), (b'd', b'rwxr-xr-x', b'255'),
+            (br'\?', b'rw-r--r--', b'0'), (b'l', b'rwxrwxrwx', b'0'),
+            (b'b', b'rw-rw----', b'3,0'), (b'c', b'rw-rw-rw-', b'1,3'),
+            (b'p', b'rw-r--r--', b'0'))
+        self.assertRegex(out, b''.join(
+            [(tp + (br'%s tarfile/tarfile\s+%s ' % (perm, ln) +
+                    br'\d{4}-\d\d-\d\d\s+\d\d:\d\d:\d\d '
+                    br'ustar/\w+type[/>\sa-z-]*\n')) for tp, perm, ln
+             in type_perm_lengths]))
         # Make sure it prints the source of link with verbose flag
         self.assertIn(b'ustar/symtype -> regtype', out)
         self.assertIn(b'./ustar/linktest2/symtype -> ../linktest1/regtype', out)
@@ -343,6 +391,8 @@ class Bz2ListTest(Bz2Test, ListTest):
 class LzmaListTest(LzmaTest, ListTest):
     pass
 
+class ZstdListTest(ZstdTest, ListTest):
+    pass
 
 class CommonReadTest(ReadTest):
 
@@ -354,7 +404,7 @@ def test_is_tarfile_erroneous(self):
         self.assertFalse(tarfile.is_tarfile(tmpname))
 
         # is_tarfile works on path-like objects
-        self.assertFalse(tarfile.is_tarfile(pathlib.Path(tmpname)))
+        self.assertFalse(tarfile.is_tarfile(os_helper.FakePath(tmpname)))
 
         # is_tarfile works on file objects
         with open(tmpname, "rb") as fobj:
@@ -368,7 +418,7 @@ def test_is_tarfile_valid(self):
         self.assertTrue(tarfile.is_tarfile(self.tarname))
 
         # is_tarfile works on path-like objects
-        self.assertTrue(tarfile.is_tarfile(pathlib.Path(self.tarname)))
+        self.assertTrue(tarfile.is_tarfile(os_helper.FakePath(self.tarname)))
 
         # is_tarfile works on file objects
         with open(self.tarname, "rb") as fobj:
@@ -378,6 +428,18 @@ def test_is_tarfile_valid(self):
         with open(self.tarname, "rb") as fobj:
             self.assertTrue(tarfile.is_tarfile(io.BytesIO(fobj.read())))
 
+    def test_is_tarfile_keeps_position(self):
+        # Test for issue44289: tarfile.is_tarfile() modifies
+        # file object's current position
+        with open(self.tarname, "rb") as fobj:
+            tarfile.is_tarfile(fobj)
+            self.assertEqual(fobj.tell(), 0)
+
+        with open(self.tarname, "rb") as fobj:
+            file_like = io.BytesIO(fobj.read())
+            tarfile.is_tarfile(file_like)
+            self.assertEqual(file_like.tell(), 0)
+
     def test_empty_tarfile(self):
         # Test for issue6123: Allow opening empty archives.
         # This test checks if tarfile.open() is able to open an empty tar
@@ -451,7 +513,7 @@ def test_premature_end_of_archive(self):
                 t = tar.next()
 
                 with self.assertRaisesRegex(tarfile.ReadError, "unexpected end of data"):
-                    tar.extract(t, TEMPDIR)
+                    tar.extract(t, TEMPDIR, filter='data')
 
                 with self.assertRaisesRegex(tarfile.ReadError, "unexpected end of data"):
                     tar.extractfile(t).read()
@@ -460,15 +522,39 @@ def test_length_zero_header(self):
         # bpo-39017 (CVE-2019-20907): reading a zero-length header should fail
         # with an exception
         with self.assertRaisesRegex(tarfile.ReadError, "file could not be opened successfully"):
-            with tarfile.open(support.findfile('recursion.tar')) as tar:
+            with tarfile.open(support.findfile('recursion.tar', subdir='archivetestdata')):
                 pass
 
+    def test_extractfile_attrs(self):
+        # gh-74468: TarFile.name must name a file, not a parent archive.
+        file = self.tar.getmember('ustar/regtype')
+        with self.tar.extractfile(file) as fobj:
+            self.assertEqual(fobj.name, 'ustar/regtype')
+            self.assertRaises(AttributeError, fobj.fileno)
+            self.assertEqual(fobj.mode, 'rb')
+            self.assertIs(fobj.readable(), True)
+            self.assertIs(fobj.writable(), False)
+            if self.is_stream:
+                self.assertRaises(AttributeError, fobj.seekable)
+            else:
+                self.assertIs(fobj.seekable(), True)
+            self.assertIs(fobj.closed, False)
+        self.assertIs(fobj.closed, True)
+        self.assertEqual(fobj.name, 'ustar/regtype')
+        self.assertRaises(AttributeError, fobj.fileno)
+        self.assertEqual(fobj.mode, 'rb')
+        self.assertIs(fobj.readable(), True)
+        self.assertIs(fobj.writable(), False)
+        if self.is_stream:
+            self.assertRaises(AttributeError, fobj.seekable)
+        else:
+            self.assertIs(fobj.seekable(), True)
+
+
 class MiscReadTestBase(CommonReadTest):
-    def requires_name_attribute(self):
-        pass
+    is_stream = False
 
     def test_no_name_argument(self):
-        self.requires_name_attribute()
         with open(self.tarname, "rb") as fobj:
             self.assertIsInstance(fobj.name, str)
             with tarfile.open(fileobj=fobj, mode=self.mode) as tar:
@@ -501,7 +587,6 @@ def test_int_name_attribute(self):
                 self.assertIsNone(tar.name)
 
     def test_bytes_name_attribute(self):
-        self.requires_name_attribute()
         tarname = os.fsencode(self.tarname)
         with open(tarname, 'rb') as fobj:
             self.assertIsInstance(fobj.name, bytes)
@@ -509,21 +594,23 @@ def test_bytes_name_attribute(self):
                 self.assertIsInstance(tar.name, bytes)
                 self.assertEqual(tar.name, os.path.abspath(fobj.name))
 
-    def test_pathlike_name(self):
-        tarname = pathlib.Path(self.tarname)
+    def test_pathlike_name(self, tarname=None):
+        if tarname is None:
+            tarname = self.tarname
+        expected = os.path.abspath(tarname)
+        tarname = os_helper.FakePath(tarname)
         with tarfile.open(tarname, mode=self.mode) as tar:
-            self.assertIsInstance(tar.name, str)
-            self.assertEqual(tar.name, os.path.abspath(os.fspath(tarname)))
+            self.assertEqual(tar.name, expected)
         with self.taropen(tarname) as tar:
-            self.assertIsInstance(tar.name, str)
-            self.assertEqual(tar.name, os.path.abspath(os.fspath(tarname)))
+            self.assertEqual(tar.name, expected)
         with tarfile.TarFile.open(tarname, mode=self.mode) as tar:
-            self.assertIsInstance(tar.name, str)
-            self.assertEqual(tar.name, os.path.abspath(os.fspath(tarname)))
+            self.assertEqual(tar.name, expected)
         if self.suffix == '':
             with tarfile.TarFile(tarname, mode='r') as tar:
-                self.assertIsInstance(tar.name, str)
-                self.assertEqual(tar.name, os.path.abspath(os.fspath(tarname)))
+                self.assertEqual(tar.name, expected)
+
+    def test_pathlike_bytes_name(self):
+        self.test_pathlike_name(os.fsencode(self.tarname))
 
     def test_illegal_mode_arg(self):
         with open(tmpname, 'wb'):
@@ -606,21 +693,22 @@ def test_find_members(self):
     def test_extract_hardlink(self):
         # Test hardlink extraction (e.g. bug #857297).
         with tarfile.open(tarname, errorlevel=1, encoding="iso8859-1") as tar:
-            tar.extract("ustar/regtype", TEMPDIR)
+            tar.extract("ustar/regtype", TEMPDIR, filter='data')
             self.addCleanup(os_helper.unlink, os.path.join(TEMPDIR, "ustar/regtype"))
 
-            tar.extract("ustar/lnktype", TEMPDIR)
+            tar.extract("ustar/lnktype", TEMPDIR, filter='data')
             self.addCleanup(os_helper.unlink, os.path.join(TEMPDIR, "ustar/lnktype"))
             with open(os.path.join(TEMPDIR, "ustar/lnktype"), "rb") as f:
                 data = f.read()
             self.assertEqual(sha256sum(data), sha256_regtype)
 
-            tar.extract("ustar/symtype", TEMPDIR)
+            tar.extract("ustar/symtype", TEMPDIR, filter='data')
             self.addCleanup(os_helper.unlink, os.path.join(TEMPDIR, "ustar/symtype"))
             with open(os.path.join(TEMPDIR, "ustar/symtype"), "rb") as f:
                 data = f.read()
             self.assertEqual(sha256sum(data), sha256_regtype)
 
+    @os_helper.skip_unless_working_chmod
     def test_extractall(self):
         # Test if extractall() correctly restores directory permissions
         # and times (see issue1735).
@@ -629,13 +717,14 @@ def test_extractall(self):
         os.mkdir(DIR)
         try:
             directories = [t for t in tar if t.isdir()]
-            tar.extractall(DIR, directories)
+            tar.extractall(DIR, directories, filter='fully_trusted')
             for tarinfo in directories:
                 path = os.path.join(DIR, tarinfo.name)
                 if sys.platform != "win32":
                     # Win32 has no support for fine grained permissions.
                     self.assertEqual(tarinfo.mode & 0o777,
-                                     os.stat(path).st_mode & 0o777)
+                                     os.stat(path).st_mode & 0o777,
+                                     tarinfo.name)
                 def format_mtime(mtime):
                     if isinstance(mtime, float):
                         return "{} ({})".format(mtime, mtime.hex())
@@ -651,6 +740,25 @@ def format_mtime(mtime):
             tar.close()
             os_helper.rmtree(DIR)
 
+    @staticmethod
+    def test_extractall_default_filter():
+        # Test that the default filter is now "data", and the other filter types are not used.
+        DIR = pathlib.Path(TEMPDIR) / "extractall_default_filter"
+        with (
+            os_helper.temp_dir(DIR),
+            tarfile.open(tarname, encoding="iso8859-1") as tar,
+            unittest.mock.patch("tarfile.data_filter", wraps=tarfile.data_filter) as mock_data_filter,
+            unittest.mock.patch("tarfile.tar_filter", wraps=tarfile.tar_filter) as mock_tar_filter,
+            unittest.mock.patch("tarfile.fully_trusted_filter", wraps=tarfile.fully_trusted_filter) as mock_ft_filter
+        ):
+            directories = [t for t in tar if t.isdir()]
+            tar.extractall(DIR, directories)
+
+            mock_data_filter.assert_called()
+            mock_ft_filter.assert_not_called()
+            mock_tar_filter.assert_not_called()
+
+    @os_helper.skip_unless_working_chmod
     def test_extract_directory(self):
         dirtype = "ustar/dirtype"
         DIR = os.path.join(TEMPDIR, "extractdir")
@@ -658,7 +766,7 @@ def test_extract_directory(self):
         try:
             with tarfile.open(tarname, encoding="iso8859-1") as tar:
                 tarinfo = tar.getmember(dirtype)
-                tar.extract(tarinfo, path=DIR)
+                tar.extract(tarinfo, path=DIR, filter='fully_trusted')
                 extracted = os.path.join(DIR, dirtype)
                 self.assertEqual(os.path.getmtime(extracted), tarinfo.mtime)
                 if sys.platform != "win32":
@@ -666,24 +774,24 @@ def test_extract_directory(self):
         finally:
             os_helper.rmtree(DIR)
 
-    def test_extractall_pathlike_name(self):
-        DIR = pathlib.Path(TEMPDIR) / "extractall"
+    def test_extractall_pathlike_dir(self):
+        DIR = os.path.join(TEMPDIR, "extractall")
         with os_helper.temp_dir(DIR), \
              tarfile.open(tarname, encoding="iso8859-1") as tar:
             directories = [t for t in tar if t.isdir()]
-            tar.extractall(DIR, directories)
+            tar.extractall(os_helper.FakePath(DIR), directories, filter='fully_trusted')
             for tarinfo in directories:
-                path = DIR / tarinfo.name
+                path = os.path.join(DIR, tarinfo.name)
                 self.assertEqual(os.path.getmtime(path), tarinfo.mtime)
 
-    def test_extract_pathlike_name(self):
+    def test_extract_pathlike_dir(self):
         dirtype = "ustar/dirtype"
-        DIR = pathlib.Path(TEMPDIR) / "extractall"
+        DIR = os.path.join(TEMPDIR, "extractall")
         with os_helper.temp_dir(DIR), \
              tarfile.open(tarname, encoding="iso8859-1") as tar:
             tarinfo = tar.getmember(dirtype)
-            tar.extract(tarinfo, path=DIR)
-            extracted = DIR / dirtype
+            tar.extract(tarinfo, path=os_helper.FakePath(DIR), filter='fully_trusted')
+            extracted = os.path.join(DIR, dirtype)
             self.assertEqual(os.path.getmtime(extracted), tarinfo.mtime)
 
     def test_init_close_fobj(self):
@@ -722,6 +830,69 @@ def test_zlib_error_does_not_leak(self):
             with self.assertRaises(tarfile.ReadError):
                 tarfile.open(self.tarname)
 
+    def test_next_on_empty_tarfile(self):
+        fd = io.BytesIO()
+        tf = tarfile.open(fileobj=fd, mode="w")
+        tf.close()
+
+        fd.seek(0)
+        with tarfile.open(fileobj=fd, mode="r|") as tf:
+            self.assertEqual(tf.next(), None)
+
+        fd.seek(0)
+        with tarfile.open(fileobj=fd, mode="r") as tf:
+            self.assertEqual(tf.next(), None)
+
+    def _setup_symlink_to_target(self, temp_dirpath):
+        target_filepath = os.path.join(temp_dirpath, "target")
+        ustar_dirpath = os.path.join(temp_dirpath, "ustar")
+        hardlink_filepath = os.path.join(ustar_dirpath, "lnktype")
+        with open(target_filepath, "wb") as f:
+            f.write(b"target")
+        os.makedirs(ustar_dirpath)
+        os.symlink(target_filepath, hardlink_filepath)
+        return target_filepath, hardlink_filepath
+
+    def _assert_on_file_content(self, filepath, digest):
+        with open(filepath, "rb") as f:
+            data = f.read()
+        self.assertEqual(sha256sum(data), digest)
+
+    @unittest.skipUnless(
+        hasattr(os, "link"), "Missing hardlink implementation"
+    )
+    @os_helper.skip_unless_symlink
+    def test_extract_hardlink_on_symlink(self):
+        """
+        This test verifies that extracting a hardlink will not follow an
+        existing symlink after a FileExistsError on os.link.
+        """
+        with os_helper.temp_dir() as DIR:
+            target_filepath, hardlink_filepath = self._setup_symlink_to_target(DIR)
+            with tarfile.open(tarname, encoding="iso8859-1") as tar:
+                tar.extract("ustar/regtype", DIR, filter="data")
+                tar.extract("ustar/lnktype", DIR, filter="data")
+                self._assert_on_file_content(target_filepath, sha256sum(b"target"))
+                self._assert_on_file_content(hardlink_filepath, sha256_regtype)
+
+    @unittest.skipUnless(
+        hasattr(os, "link"), "Missing hardlink implementation"
+    )
+    @os_helper.skip_unless_symlink
+    def test_extractall_hardlink_on_symlink(self):
+        """
+        This test verifies that extracting a hardlink will not follow an
+        existing symlink after a FileExistsError on os.link.
+        """
+        with os_helper.temp_dir() as DIR:
+            target_filepath, hardlink_filepath = self._setup_symlink_to_target(DIR)
+            with tarfile.open(tarname, encoding="iso8859-1") as tar:
+                tar.extractall(
+                    DIR, members=["ustar/regtype", "ustar/lnktype"], filter="data",
+                )
+                self._assert_on_file_content(target_filepath, sha256sum(b"target"))
+                self._assert_on_file_content(hardlink_filepath, sha256_regtype)
+
 
 class MiscReadTest(MiscReadTestBase, unittest.TestCase):
     test_fail_comp = None
@@ -730,17 +901,18 @@ class GzipMiscReadTest(GzipTest, MiscReadTestBase, unittest.TestCase):
     pass
 
 class Bz2MiscReadTest(Bz2Test, MiscReadTestBase, unittest.TestCase):
-    def requires_name_attribute(self):
-        self.skipTest("BZ2File have no name attribute")
+    pass
 
 class LzmaMiscReadTest(LzmaTest, MiscReadTestBase, unittest.TestCase):
-    def requires_name_attribute(self):
-        self.skipTest("LZMAFile have no name attribute")
+    pass
 
+class ZstdMiscReadTest(ZstdTest, MiscReadTestBase, unittest.TestCase):
+    pass
 
 class StreamReadTest(CommonReadTest, unittest.TestCase):
 
     prefix="r|"
+    is_stream = True
 
     def test_read_through(self):
         # Issue #11224: A poorly designed _FileInFile.read() method
@@ -808,6 +980,27 @@ class Bz2StreamReadTest(Bz2Test, StreamReadTest):
 class LzmaStreamReadTest(LzmaTest, StreamReadTest):
     pass
 
+class ZstdStreamReadTest(ZstdTest, StreamReadTest):
+    pass
+
+class TarStreamModeReadTest(StreamModeTest, unittest.TestCase):
+
+    def test_stream_mode_no_cache(self):
+        for _ in self.tar:
+            pass
+        self.assertEqual(self.tar.members, [])
+
+class GzipStreamModeReadTest(GzipTest, TarStreamModeReadTest):
+    pass
+
+class Bz2StreamModeReadTest(Bz2Test, TarStreamModeReadTest):
+    pass
+
+class LzmaStreamModeReadTest(LzmaTest, TarStreamModeReadTest):
+    pass
+
+class ZstdStreamModeReadTest(ZstdTest, TarStreamModeReadTest):
+    pass
 
 class DetectReadTest(TarTest, unittest.TestCase):
     def _testfunc_file(self, name, mode):
@@ -870,6 +1063,25 @@ def test_detect_stream_bz2(self):
 class LzmaDetectReadTest(LzmaTest, DetectReadTest):
     pass
 
+class ZstdDetectReadTest(ZstdTest, DetectReadTest):
+    pass
+
+class GzipBrokenHeaderCorrectException(GzipTest, unittest.TestCase):
+    """
+    See: https://github.com/python/cpython/issues/107396
+    """
+    def runTest(self):
+        f = io.BytesIO(
+            b'\x1f\x8b'  # header
+            b'\x08'  # compression method
+            b'\x04'  # flags
+            b'\0\0\0\0\0\0'  # timestamp, compression data, OS ID
+            b'\0\x01'  # size
+            b'\0\0\0\0\0'  # corrupt data (zeros)
+        )
+        with self.assertRaises(tarfile.ReadError):
+            tarfile.open(fileobj=f, mode='r|gz')
+
 
 class MemberReadTest(ReadTest, unittest.TestCase):
 
@@ -1019,7 +1231,7 @@ def test_longname_directory(self):
                     os.mkdir(longdir)
                     tar.add(longdir)
                 finally:
-                    os.rmdir(longdir)
+                    os.rmdir(longdir.rstrip("/"))
             with tarfile.open(tmpname) as tar:
                 self.assertIsNotNone(tar.getmember(longdir))
                 self.assertIsNotNone(tar.getmember(longdir.removesuffix('/')))
@@ -1038,7 +1250,7 @@ class GNUReadTest(LongnameTest, ReadTest, unittest.TestCase):
     # an all platforms, and after that a test that will work only on
     # platforms/filesystems that prove to support sparse files.
     def _test_sparse_file(self, name):
-        self.tar.extract(name, TEMPDIR)
+        self.tar.extract(name, TEMPDIR, filter='data')
         filename = os.path.join(TEMPDIR, name)
         with open(filename, "rb") as fobj:
             data = fobj.read()
@@ -1069,7 +1281,7 @@ def _fs_supports_holes():
         #
         # The function returns False if page size is larger than 4 KiB.
         # For example, ppc64 uses pages of 64 KiB.
-        if sys.platform.startswith("linux"):
+        if sys.platform.startswith(("linux", "android")):
             # Linux evidentially has 512 byte st_blocks units.
             name = os.path.join(TEMPDIR, "sparse-test")
             with open(name, "wb") as fobj:
@@ -1128,6 +1340,48 @@ def test_pax_number_fields(self):
         finally:
             tar.close()
 
+    def test_pax_header_bad_formats(self):
+        # The fields from the pax header have priority over the
+        # TarInfo.
+        pax_header_replacements = (
+            b" foo=bar\n",
+            b"0 \n",
+            b"1 \n",
+            b"2 \n",
+            b"3 =\n",
+            b"4 =a\n",
+            b"1000000 foo=bar\n",
+            b"0 foo=bar\n",
+            b"-12 foo=bar\n",
+            b"000000000000000000000000036 foo=bar\n",
+        )
+        pax_headers = {"foo": "bar"}
+
+        for replacement in pax_header_replacements:
+            with self.subTest(header=replacement):
+                tar = tarfile.open(tmpname, "w", format=tarfile.PAX_FORMAT,
+                                   encoding="iso8859-1")
+                try:
+                    t = tarfile.TarInfo()
+                    t.name = "pax"  # non-ASCII
+                    t.uid = 1
+                    t.pax_headers = pax_headers
+                    tar.addfile(t)
+                finally:
+                    tar.close()
+
+                with open(tmpname, "rb") as f:
+                    data = f.read()
+                    self.assertIn(b"11 foo=bar\n", data)
+                    data = data.replace(b"11 foo=bar\n", replacement)
+
+                with open(tmpname, "wb") as f:
+                    f.truncate()
+                    f.write(data)
+
+                with self.assertRaisesRegex(tarfile.ReadError, r"method tar: ReadError\('invalid header'\)"):
+                    tarfile.open(tmpname, encoding="iso8859-1")
+
 
 class WriteTestBase(TarTest):
     # Put all write tests in here that are supposed to be tested
@@ -1252,11 +1506,11 @@ def test_ordered_recursion(self):
 
     def test_gettarinfo_pathlike_name(self):
         with tarfile.open(tmpname, self.mode) as tar:
-            path = pathlib.Path(TEMPDIR) / "file"
+            path = os.path.join(TEMPDIR, "file")
             with open(path, "wb") as fobj:
                 fobj.write(b"aaa")
-            tarinfo = tar.gettarinfo(path)
-            tarinfo2 = tar.gettarinfo(os.fspath(path))
+            tarinfo = tar.gettarinfo(os_helper.FakePath(path))
+            tarinfo2 = tar.gettarinfo(path)
             self.assertIsInstance(tarinfo.name, str)
             self.assertEqual(tarinfo.name, tarinfo2.name)
             self.assertEqual(tarinfo.size, 3)
@@ -1405,7 +1659,8 @@ def test_extractall_symlinks(self):
             with tarfile.open(temparchive, errorlevel=2) as tar:
                 # this should not raise OSError: [Errno 17] File exists
                 try:
-                    tar.extractall(path=tempdir)
+                    tar.extractall(path=tempdir,
+                                   filter='fully_trusted')
                 except OSError:
                     self.fail("extractall failed with symlinked files")
         finally:
@@ -1449,7 +1704,7 @@ def test_cwd(self):
             try:
                 for t in tar:
                     if t.name != ".":
-                        self.assertTrue(t.name.startswith("./"), t.name)
+                        self.assertStartsWith(t.name, "./")
             finally:
                 tar.close()
 
@@ -1463,24 +1718,24 @@ def write(self, data):
                         raise exctype
 
             f = BadFile()
-            with self.assertRaises(exctype):
-                tar = tarfile.open(tmpname, self.mode, fileobj=f,
-                                   format=tarfile.PAX_FORMAT,
-                                   pax_headers={'non': 'empty'})
+            with (
+                warnings_helper.check_no_resource_warning(self),
+                self.assertRaises(exctype),
+            ):
+                tarfile.open(tmpname, self.mode, fileobj=f,
+                             format=tarfile.PAX_FORMAT,
+                             pax_headers={'non': 'empty'})
             self.assertFalse(f.closed)
 
+    def test_missing_fileobj(self):
+        with tarfile.open(tmpname, self.mode) as tar:
+            tarinfo = tar.gettarinfo(tarname)
+            with self.assertRaises(ValueError):
+                tar.addfile(tarinfo)
 
-class GzipWriteTest(GzipTest, WriteTest):
-    # TODO: RUSTPYTHON
-    def expectedSuccess(test_item):
-        test_item.__unittest_expecting_failure__ = False
-        return test_item
 
-    # TODO: RUSTPYTHON
-    if sys.platform == "win32":
-        @expectedSuccess
-        def test_cwd(self):
-            super().test_cwd()
+class GzipWriteTest(GzipTest, WriteTest):
+    pass
 
 
 class Bz2WriteTest(Bz2Test, WriteTest):
@@ -1490,6 +1745,8 @@ class Bz2WriteTest(Bz2Test, WriteTest):
 class LzmaWriteTest(LzmaTest, WriteTest):
     pass
 
+class ZstdWriteTest(ZstdTest, WriteTest):
+    pass
 
 class StreamWriteTest(WriteTestBase, unittest.TestCase):
 
@@ -1514,6 +1771,10 @@ def test_stream_padding(self):
 
     @unittest.skipUnless(sys.platform != "win32" and hasattr(os, "umask"),
                          "Missing umask implementation")
+    @unittest.skipIf(
+        support.is_emscripten or support.is_wasi,
+        "Emscripten's/WASI's umask is a stub."
+    )
     def test_file_mode(self):
         # Test for issue #8464: Create files with correct
         # permissions.
@@ -1529,6 +1790,16 @@ def test_file_mode(self):
         finally:
             os.umask(original_umask)
 
+    def test_pathlike_name(self):
+        expected_name = os.path.abspath(tmpname)
+        tarpath = os_helper.FakePath(tmpname)
+
+        for func in (tarfile.open, tarfile.TarFile.open):
+            with self.subTest():
+                with func(tarpath, self.mode) as tar:
+                    self.assertEqual(tar.name, expected_name)
+                os_helper.unlink(tmpname)
+
 
 class GzipStreamWriteTest(GzipTest, StreamWriteTest):
     def test_source_directory_not_leaked(self):
@@ -1547,6 +1818,78 @@ class Bz2StreamWriteTest(Bz2Test, StreamWriteTest):
 class LzmaStreamWriteTest(LzmaTest, StreamWriteTest):
     decompressor = lzma.LZMADecompressor if lzma else None
 
+class ZstdStreamWriteTest(ZstdTest, StreamWriteTest):
+    decompressor = zstd.ZstdDecompressor if zstd else None
+
+class _CompressedWriteTest(TarTest):
+    # This is not actually a standalone test.
+    # It does not inherit WriteTest because it only makes sense with gz,bz2
+    source = (b"And we move to Bristol where they have a special, " +
+              b"Very Silly candidate")
+
+    def _compressed_tar(self, compresslevel):
+        fobj = io.BytesIO()
+        with tarfile.open(tmpname, self.mode, fobj,
+                          compresslevel=compresslevel) as tarfl:
+            tarfl.addfile(tarfile.TarInfo("foo"), io.BytesIO(self.source))
+        return fobj
+
+    def _test_bz2_header(self, compresslevel):
+        fobj = self._compressed_tar(compresslevel)
+        self.assertEqual(fobj.getvalue()[0:10],
+                         b"BZh%d1AY&SY" % compresslevel)
+
+    def _test_gz_header(self, compresslevel):
+        fobj = self._compressed_tar(compresslevel)
+        self.assertEqual(fobj.getvalue()[:3], b"\x1f\x8b\x08")
+
+class Bz2CompressWriteTest(Bz2Test, _CompressedWriteTest, unittest.TestCase):
+    prefix = "w:"
+    def test_compression_levels(self):
+        self._test_bz2_header(1)
+        self._test_bz2_header(5)
+        self._test_bz2_header(9)
+
+class Bz2CompressStreamWriteTest(Bz2Test, _CompressedWriteTest,
+        unittest.TestCase):
+    prefix = "w|"
+    def test_compression_levels(self):
+        self._test_bz2_header(1)
+        self._test_bz2_header(5)
+        self._test_bz2_header(9)
+
+class GzCompressWriteTest(GzipTest,  _CompressedWriteTest, unittest.TestCase):
+    prefix = "w:"
+    def test_compression_levels(self):
+        self._test_gz_header(1)
+        self._test_gz_header(5)
+        self._test_gz_header(9)
+
+class GzCompressStreamWriteTest(GzipTest, _CompressedWriteTest,
+        unittest.TestCase):
+    prefix = "w|"
+    def test_compression_levels(self):
+        self._test_gz_header(1)
+        self._test_gz_header(5)
+        self._test_gz_header(9)
+
+class CompressLevelRaises(unittest.TestCase):
+    def test_compresslevel_wrong_modes(self):
+        compresslevel = 5
+        fobj = io.BytesIO()
+        with self.assertRaises(TypeError):
+            tarfile.open(tmpname, "w:", fobj, compresslevel=compresslevel)
+
+    @support.requires_bz2()
+    def test_wrong_compresslevels(self):
+        # BZ2 checks that the compresslevel is in [1,9]. gz does not
+        fobj = io.BytesIO()
+        with self.assertRaises(ValueError):
+            tarfile.open(tmpname, "w:bz2", fobj, compresslevel=0)
+        with self.assertRaises(ValueError):
+            tarfile.open(tmpname, "w:bz2", fobj, compresslevel=10)
+        with self.assertRaises(ValueError):
+            tarfile.open(tmpname, "w|bz2", fobj, compresslevel=10)
 
 class GNUWriteTest(unittest.TestCase):
     # This testcase checks for correct creation of GNU Longname
@@ -1738,10 +2081,10 @@ def test_create_existing_taropen(self):
         self.assertIn("spameggs42", names[0])
 
     def test_create_pathlike_name(self):
-        with tarfile.open(pathlib.Path(tmpname), self.mode) as tobj:
+        with tarfile.open(os_helper.FakePath(tmpname), self.mode) as tobj:
             self.assertIsInstance(tobj.name, str)
             self.assertEqual(tobj.name, os.path.abspath(tmpname))
-            tobj.add(pathlib.Path(self.file_path))
+            tobj.add(os_helper.FakePath(self.file_path))
             names = tobj.getnames()
         self.assertEqual(len(names), 1)
         self.assertIn('spameggs42', names[0])
@@ -1752,10 +2095,10 @@ def test_create_pathlike_name(self):
         self.assertIn('spameggs42', names[0])
 
     def test_create_taropen_pathlike_name(self):
-        with self.taropen(pathlib.Path(tmpname), "x") as tobj:
+        with self.taropen(os_helper.FakePath(tmpname), "x") as tobj:
             self.assertIsInstance(tobj.name, str)
             self.assertEqual(tobj.name, os.path.abspath(tmpname))
-            tobj.add(pathlib.Path(self.file_path))
+            tobj.add(os_helper.FakePath(self.file_path))
             names = tobj.getnames()
         self.assertEqual(len(names), 1)
         self.assertIn('spameggs42', names[0])
@@ -1793,6 +2136,14 @@ def test_create_with_preset(self):
             tobj.add(self.file_path)
 
 
+class ZstdCreateTest(ZstdTest, CreateTest):
+
+    # Unlike gz and bz2, zstd uses the level keyword instead of compresslevel.
+    # It does not allow for level to be specified when reading.
+    def test_create_with_level(self):
+        with tarfile.open(tmpname, self.mode, level=1) as tobj:
+            tobj.add(self.file_path)
+
 class CreateWithXModeTest(CreateTest):
 
     prefix = "x"
@@ -1988,8 +2339,6 @@ class UnicodeTest:
     def test_iso8859_1_filename(self):
         self._test_unicode_filename("iso8859-1")
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_utf7_filename(self):
         self._test_unicode_filename("utf7")
 
@@ -2276,6 +2625,8 @@ class Bz2AppendTest(Bz2Test, AppendTestBase, unittest.TestCase):
 class LzmaAppendTest(LzmaTest, AppendTestBase, unittest.TestCase):
     pass
 
+class ZstdAppendTest(ZstdTest, AppendTestBase, unittest.TestCase):
+    pass
 
 class LimitsTest(unittest.TestCase):
 
@@ -2416,10 +2767,8 @@ def test__all__(self):
             'SubsequentHeaderError', 'ExFileObject', 'main'}
         support.check__all__(self, tarfile, not_exported=not_exported)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_useful_error_message_when_modules_missing(self):
-        fname = os.path.join(os.path.dirname(__file__), 'testtar.tar.xz')
+        fname = os.path.join(os.path.dirname(__file__), 'archivetestdata', 'testtar.tar.xz')
         with self.assertRaises(tarfile.ReadError) as excinfo:
             error = tarfile.CompressionError('lzma module is not available'),
             with unittest.mock.patch.object(tarfile.TarFile, 'xzopen', side_effect=error):
@@ -2430,6 +2779,31 @@ def test_useful_error_message_when_modules_missing(self):
             str(excinfo.exception),
         )
 
+    @unittest.skipUnless(os_helper.can_symlink(), 'requires symlink support')
+    @unittest.skipUnless(hasattr(os, 'chmod'), "missing os.chmod")
+    @unittest.mock.patch('os.chmod')
+    def test_deferred_directory_attributes_update(self, mock_chmod):
+        # Regression test for gh-127987: setting attributes on arbitrary files
+        tempdir = os.path.join(TEMPDIR, 'test127987')
+        def mock_chmod_side_effect(path, mode, **kwargs):
+            target_path = os.path.realpath(path)
+            if os.path.commonpath([target_path, tempdir]) != tempdir:
+                raise Exception("should not try to chmod anything outside the destination", target_path)
+        mock_chmod.side_effect = mock_chmod_side_effect
+
+        outside_tree_dir = os.path.join(TEMPDIR, 'outside_tree_dir')
+        with ArchiveMaker() as arc:
+            arc.add('x', symlink_to='.')
+            arc.add('x', type=tarfile.DIRTYPE, mode='?rwsrwsrwt')
+            arc.add('x', symlink_to=outside_tree_dir)
+
+        os.makedirs(outside_tree_dir)
+        try:
+            arc.open().extractall(path=tempdir, filter='tar')
+        finally:
+            os_helper.rmtree(outside_tree_dir)
+            os_helper.rmtree(tempdir)
+
 
 class CommandLineTest(unittest.TestCase):
 
@@ -2442,14 +2816,24 @@ def tarfilecmd_failure(self, *args):
         return script_helper.assert_python_failure('-m', 'tarfile', *args)
 
     def make_simple_tarfile(self, tar_name):
-        files = [support.findfile('tokenize_tests.txt'),
+        files = [support.findfile('tokenize_tests.txt',
+                                  subdir='tokenizedata'),
                  support.findfile('tokenize_tests-no-coding-cookie-'
-                                  'and-utf8-bom-sig-only.txt')]
+                                  'and-utf8-bom-sig-only.txt',
+                                  subdir='tokenizedata')]
         self.addCleanup(os_helper.unlink, tar_name)
         with tarfile.open(tar_name, 'w') as tf:
             for tardata in files:
                 tf.add(tardata, arcname=os.path.basename(tardata))
 
+    def make_evil_tarfile(self, tar_name):
+        self.addCleanup(os_helper.unlink, tar_name)
+        with tarfile.open(tar_name, 'w') as tf:
+            benign = tarfile.TarInfo('benign')
+            tf.addfile(benign, fileobj=io.BytesIO(b''))
+            evil = tarfile.TarInfo('../evil')
+            tf.addfile(evil, fileobj=io.BytesIO(b''))
+
     def test_bad_use(self):
         rc, out, err = self.tarfilecmd_failure()
         self.assertEqual(out, b'')
@@ -2474,7 +2858,7 @@ def test_test_command_verbose(self):
                 self.assertIn(b'is a tar archive.\n', out)
 
     def test_test_command_invalid_file(self):
-        zipname = support.findfile('zipdir.zip')
+        zipname = support.findfile('zipdir.zip', subdir='archivetestdata')
         rc, out, err = self.tarfilecmd_failure('-t', zipname)
         self.assertIn(b' is not a tar archive.', err)
         self.assertEqual(out, b'')
@@ -2516,16 +2900,18 @@ def test_list_command_verbose(self):
                 self.assertEqual(out, expected)
 
     def test_list_command_invalid_file(self):
-        zipname = support.findfile('zipdir.zip')
+        zipname = support.findfile('zipdir.zip', subdir='archivetestdata')
         rc, out, err = self.tarfilecmd_failure('-l', zipname)
         self.assertIn(b' is not a tar archive.', err)
         self.assertEqual(out, b'')
         self.assertEqual(rc, 1)
 
     def test_create_command(self):
-        files = [support.findfile('tokenize_tests.txt'),
+        files = [support.findfile('tokenize_tests.txt',
+                                  subdir='tokenizedata'),
                  support.findfile('tokenize_tests-no-coding-cookie-'
-                                  'and-utf8-bom-sig-only.txt')]
+                                  'and-utf8-bom-sig-only.txt',
+                                  subdir='tokenizedata')]
         for opt in '-c', '--create':
             try:
                 out = self.tarfilecmd(opt, tmpname, *files)
@@ -2536,9 +2922,11 @@ def test_create_command(self):
                 os_helper.unlink(tmpname)
 
     def test_create_command_verbose(self):
-        files = [support.findfile('tokenize_tests.txt'),
+        files = [support.findfile('tokenize_tests.txt',
+                                  subdir='tokenizedata'),
                  support.findfile('tokenize_tests-no-coding-cookie-'
-                                  'and-utf8-bom-sig-only.txt')]
+                                  'and-utf8-bom-sig-only.txt',
+                                  subdir='tokenizedata')]
         for opt in '-v', '--verbose':
             try:
                 out = self.tarfilecmd(opt, '-c', tmpname, *files,
@@ -2550,7 +2938,7 @@ def test_create_command_verbose(self):
                 os_helper.unlink(tmpname)
 
     def test_create_command_dotless_filename(self):
-        files = [support.findfile('tokenize_tests.txt')]
+        files = [support.findfile('tokenize_tests.txt', subdir='tokenizedata')]
         try:
             out = self.tarfilecmd('-c', dotlessname, *files)
             self.assertEqual(out, b'')
@@ -2561,7 +2949,7 @@ def test_create_command_dotless_filename(self):
 
     def test_create_command_dot_started_filename(self):
         tar_name = os.path.join(TEMPDIR, ".testtar")
-        files = [support.findfile('tokenize_tests.txt')]
+        files = [support.findfile('tokenize_tests.txt', subdir='tokenizedata')]
         try:
             out = self.tarfilecmd('-c', tar_name, *files)
             self.assertEqual(out, b'')
@@ -2571,10 +2959,12 @@ def test_create_command_dot_started_filename(self):
             os_helper.unlink(tar_name)
 
     def test_create_command_compressed(self):
-        files = [support.findfile('tokenize_tests.txt'),
+        files = [support.findfile('tokenize_tests.txt',
+                                  subdir='tokenizedata'),
                  support.findfile('tokenize_tests-no-coding-cookie-'
-                                  'and-utf8-bom-sig-only.txt')]
-        for filetype in (GzipTest, Bz2Test, LzmaTest):
+                                  'and-utf8-bom-sig-only.txt',
+                                  subdir='tokenizedata')]
+        for filetype in (GzipTest, Bz2Test, LzmaTest, ZstdTest):
             if not filetype.open:
                 continue
             try:
@@ -2606,6 +2996,25 @@ def test_extract_command_verbose(self):
             finally:
                 os_helper.rmtree(tarextdir)
 
+    def test_extract_command_filter(self):
+        self.make_evil_tarfile(tmpname)
+        # Make an inner directory, so the member named '../evil'
+        # is still extracted into `tarextdir`
+        destdir = os.path.join(tarextdir, 'dest')
+        os.mkdir(tarextdir)
+        try:
+            with os_helper.temp_cwd(destdir):
+                self.tarfilecmd_failure('-e', tmpname,
+                                        '-v',
+                                        '--filter', 'data')
+                out = self.tarfilecmd('-e', tmpname,
+                                      '-v',
+                                      '--filter', 'fully_trusted',
+                                      PYTHONIOENCODING='utf-8')
+                self.assertIn(b' file is extracted.', out)
+        finally:
+            os_helper.rmtree(tarextdir)
+
     def test_extract_command_different_directory(self):
         self.make_simple_tarfile(tmpname)
         try:
@@ -2616,7 +3025,7 @@ def test_extract_command_different_directory(self):
             os_helper.rmtree(tarextdir)
 
     def test_extract_command_invalid_file(self):
-        zipname = support.findfile('zipdir.zip')
+        zipname = support.findfile('zipdir.zip', subdir='archivetestdata')
         with os_helper.temp_cwd(tarextdir):
             rc, out, err = self.tarfilecmd_failure('-e', zipname)
         self.assertIn(b' is not a tar archive.', err)
@@ -2689,7 +3098,7 @@ class LinkEmulationTest(ReadTest, unittest.TestCase):
     # symbolic or hard links tarfile tries to extract these types of members
     # as the regular files they point to.
     def _test_link_extraction(self, name):
-        self.tar.extract(name, TEMPDIR)
+        self.tar.extract(name, TEMPDIR, filter='fully_trusted')
         with open(os.path.join(TEMPDIR, name), "rb") as f:
             data = f.read()
         self.assertEqual(sha256sum(data), sha256_regtype)
@@ -2821,8 +3230,10 @@ def test_extract_with_numeric_owner(self, mock_geteuid, mock_chmod,
                                         mock_chown):
         with self._setup_test(mock_geteuid) as (tarfl, filename_1, _,
                                                 filename_2):
-            tarfl.extract(filename_1, TEMPDIR, numeric_owner=True)
-            tarfl.extract(filename_2 , TEMPDIR, numeric_owner=True)
+            tarfl.extract(filename_1, TEMPDIR, numeric_owner=True,
+                          filter='fully_trusted')
+            tarfl.extract(filename_2 , TEMPDIR, numeric_owner=True,
+                          filter='fully_trusted')
 
         # convert to filesystem paths
         f_filename_1 = os.path.join(TEMPDIR, filename_1)
@@ -2840,7 +3251,8 @@ def test_extractall_with_numeric_owner(self, mock_geteuid, mock_chmod,
                                            mock_chown):
         with self._setup_test(mock_geteuid) as (tarfl, filename_1, dirname_1,
                                                 filename_2):
-            tarfl.extractall(TEMPDIR, numeric_owner=True)
+            tarfl.extractall(TEMPDIR, numeric_owner=True,
+                             filter='fully_trusted')
 
         # convert to filesystem paths
         f_filename_1 = os.path.join(TEMPDIR, filename_1)
@@ -2865,7 +3277,8 @@ def test_extractall_with_numeric_owner(self, mock_geteuid, mock_chmod,
     def test_extract_without_numeric_owner(self, mock_geteuid, mock_chmod,
                                            mock_chown):
         with self._setup_test(mock_geteuid) as (tarfl, filename_1, _, _):
-            tarfl.extract(filename_1, TEMPDIR, numeric_owner=False)
+            tarfl.extract(filename_1, TEMPDIR, numeric_owner=False,
+                          filter='fully_trusted')
 
         # convert to filesystem paths
         f_filename_1 = os.path.join(TEMPDIR, filename_1)
@@ -2879,6 +3292,1535 @@ def test_keyword_only(self, mock_geteuid):
                               tarfl.extract, filename_1, TEMPDIR, False, True)
 
 
+class ReplaceTests(ReadTest, unittest.TestCase):
+    def test_replace_name(self):
+        member = self.tar.getmember('ustar/regtype')
+        replaced = member.replace(name='misc/other')
+        self.assertEqual(replaced.name, 'misc/other')
+        self.assertEqual(member.name, 'ustar/regtype')
+        self.assertEqual(self.tar.getmember('ustar/regtype').name,
+                         'ustar/regtype')
+
+    def test_replace_deep(self):
+        member = self.tar.getmember('pax/regtype1')
+        replaced = member.replace()
+        replaced.pax_headers['gname'] = 'not-bar'
+        self.assertEqual(member.pax_headers['gname'], 'bar')
+        self.assertEqual(
+            self.tar.getmember('pax/regtype1').pax_headers['gname'], 'bar')
+
+    def test_replace_shallow(self):
+        member = self.tar.getmember('pax/regtype1')
+        replaced = member.replace(deep=False)
+        replaced.pax_headers['gname'] = 'not-bar'
+        self.assertEqual(member.pax_headers['gname'], 'not-bar')
+        self.assertEqual(
+            self.tar.getmember('pax/regtype1').pax_headers['gname'], 'not-bar')
+
+    def test_replace_all(self):
+        member = self.tar.getmember('ustar/regtype')
+        for attr_name in ('name', 'mtime', 'mode', 'linkname',
+                          'uid', 'gid', 'uname', 'gname'):
+            with self.subTest(attr_name=attr_name):
+                replaced = member.replace(**{attr_name: None})
+                self.assertEqual(getattr(replaced, attr_name), None)
+                self.assertNotEqual(getattr(member, attr_name), None)
+
+    def test_replace_internal(self):
+        member = self.tar.getmember('ustar/regtype')
+        with self.assertRaises(TypeError):
+            member.replace(offset=123456789)
+
+
+class NoneInfoExtractTests(ReadTest):
+    # These mainly check that all kinds of members are extracted successfully
+    # if some metadata is None.
+    # Some of the methods do additional spot checks.
+
+    # We also test that the default filters can deal with None.
+
+    extraction_filter = None
+
+    @classmethod
+    def setUpClass(cls):
+        tar = tarfile.open(tarname, mode='r', encoding="iso8859-1")
+        cls.control_dir = pathlib.Path(TEMPDIR) / "extractall_ctrl"
+        tar.errorlevel = 0
+        with ExitStack() as cm:
+            if cls.extraction_filter is None:
+                cm.enter_context(warnings.catch_warnings(
+                    action="ignore", category=DeprecationWarning))
+            tar.extractall(cls.control_dir, filter=cls.extraction_filter)
+        tar.close()
+        cls.control_paths = set(
+            p.relative_to(cls.control_dir)
+            for p in pathlib.Path(cls.control_dir).glob('**/*'))
+
+    @classmethod
+    def tearDownClass(cls):
+        shutil.rmtree(cls.control_dir)
+
+    def check_files_present(self, directory):
+        got_paths = set(
+            p.relative_to(directory)
+            for p in pathlib.Path(directory).glob('**/*'))
+        if self.extraction_filter in (None, 'data'):
+            # The 'data' filter is expected to reject special files
+            for path in 'ustar/fifotype', 'ustar/blktype', 'ustar/chrtype':
+                got_paths.discard(pathlib.Path(path))
+        self.assertEqual(self.control_paths, got_paths)
+
+    @contextmanager
+    def extract_with_none(self, *attr_names):
+        DIR = pathlib.Path(TEMPDIR) / "extractall_none"
+        self.tar.errorlevel = 0
+        for member in self.tar.getmembers():
+            for attr_name in attr_names:
+                setattr(member, attr_name, None)
+        with os_helper.temp_dir(DIR):
+            self.tar.extractall(DIR, filter='fully_trusted')
+            self.check_files_present(DIR)
+            yield DIR
+
+    def test_extractall_none_mtime(self):
+        # mtimes of extracted files should be later than 'now' -- the mtime
+        # of a previously created directory.
+        now = pathlib.Path(TEMPDIR).stat().st_mtime
+        with self.extract_with_none('mtime') as DIR:
+            for path in pathlib.Path(DIR).glob('**/*'):
+                with self.subTest(path=path):
+                    try:
+                        mtime = path.stat().st_mtime
+                    except OSError:
+                        # Some systems can't stat symlinks, ignore those
+                        if not path.is_symlink():
+                            raise
+                    else:
+                        self.assertGreaterEqual(path.stat().st_mtime, now)
+
+    def test_extractall_none_mode(self):
+        # modes of directories and regular files should match the mode
+        # of a "normally" created directory or regular file
+        dir_mode = pathlib.Path(TEMPDIR).stat().st_mode
+        regular_file = pathlib.Path(TEMPDIR) / 'regular_file'
+        regular_file.write_text('')
+        regular_file_mode = regular_file.stat().st_mode
+        with self.extract_with_none('mode') as DIR:
+            for path in pathlib.Path(DIR).glob('**/*'):
+                with self.subTest(path=path):
+                    if path.is_dir():
+                        self.assertEqual(path.stat().st_mode, dir_mode)
+                    elif path.is_file():
+                        self.assertEqual(path.stat().st_mode,
+                                         regular_file_mode)
+
+    def test_extractall_none_uid(self):
+        with self.extract_with_none('uid'):
+            pass
+
+    def test_extractall_none_gid(self):
+        with self.extract_with_none('gid'):
+            pass
+
+    def test_extractall_none_uname(self):
+        with self.extract_with_none('uname'):
+            pass
+
+    def test_extractall_none_gname(self):
+        with self.extract_with_none('gname'):
+            pass
+
+    def test_extractall_none_ownership(self):
+        with self.extract_with_none('uid', 'gid', 'uname', 'gname'):
+            pass
+
+class NoneInfoExtractTests_Data(NoneInfoExtractTests, unittest.TestCase):
+    extraction_filter = 'data'
+
+class NoneInfoExtractTests_FullyTrusted(NoneInfoExtractTests,
+                                        unittest.TestCase):
+    extraction_filter = 'fully_trusted'
+
+class NoneInfoExtractTests_Tar(NoneInfoExtractTests, unittest.TestCase):
+    extraction_filter = 'tar'
+
+class NoneInfoExtractTests_Default(NoneInfoExtractTests,
+                                   unittest.TestCase):
+    extraction_filter = None
+
+class NoneInfoTests_Misc(unittest.TestCase):
+    def test_add(self):
+        # When addfile() encounters None metadata, it raises a ValueError
+        bio = io.BytesIO()
+        for tarformat in (tarfile.USTAR_FORMAT, tarfile.GNU_FORMAT,
+                          tarfile.PAX_FORMAT):
+            with self.subTest(tarformat=tarformat):
+                tar = tarfile.open(fileobj=bio, mode='w', format=tarformat)
+                tarinfo = tar.gettarinfo(tarname)
+                try:
+                    with open(tarname, 'rb') as f:
+                        tar.addfile(tarinfo, f)
+                except Exception:
+                    if tarformat == tarfile.USTAR_FORMAT:
+                        # In the old, limited format, adding might fail for
+                        # reasons like the UID being too large
+                        pass
+                    else:
+                        raise
+                else:
+                    for attr_name in ('mtime', 'mode', 'uid', 'gid',
+                                    'uname', 'gname'):
+                        with self.subTest(attr_name=attr_name):
+                            replaced = tarinfo.replace(**{attr_name: None})
+                            with self.assertRaisesRegex(ValueError,
+                                                        f"{attr_name}"):
+                                with open(tarname, 'rb') as f:
+                                    tar.addfile(replaced, f)
+
+    def test_list(self):
+        # Change some metadata to None, then compare list() output
+        # word-for-word. We want list() to not raise, and to only change
+        # printout for the affected piece of metadata.
+        # (n.b.: some contents of the test archive are hardcoded.)
+        for attr_names in ({'mtime'}, {'mode'}, {'uid'}, {'gid'},
+                           {'uname'}, {'gname'},
+                           {'uid', 'uname'}, {'gid', 'gname'}):
+            with (self.subTest(attr_names=attr_names),
+                  tarfile.open(tarname, encoding="iso8859-1") as tar):
+                tio_prev = io.TextIOWrapper(io.BytesIO(), 'ascii', newline='\n')
+                with support.swap_attr(sys, 'stdout', tio_prev):
+                    tar.list()
+                for member in tar.getmembers():
+                    for attr_name in attr_names:
+                        setattr(member, attr_name, None)
+                tio_new = io.TextIOWrapper(io.BytesIO(), 'ascii', newline='\n')
+                with support.swap_attr(sys, 'stdout', tio_new):
+                    tar.list()
+                for expected, got in zip(tio_prev.detach().getvalue().split(),
+                                         tio_new.detach().getvalue().split()):
+                    if attr_names == {'mtime'} and re.match(rb'2003-01-\d\d', expected):
+                        self.assertEqual(got, b'????-??-??')
+                    elif attr_names == {'mtime'} and re.match(rb'\d\d:\d\d:\d\d', expected):
+                        self.assertEqual(got, b'??:??:??')
+                    elif attr_names == {'mode'} and re.match(
+                            rb'.([r-][w-][x-]){3}', expected):
+                        self.assertEqual(got, b'??????????')
+                    elif attr_names == {'uname'} and expected.startswith(
+                            (b'tarfile/', b'lars/', b'foo/')):
+                        exp_user, exp_group = expected.split(b'/')
+                        got_user, got_group = got.split(b'/')
+                        self.assertEqual(got_group, exp_group)
+                        self.assertRegex(got_user, b'[0-9]+')
+                    elif attr_names == {'gname'} and expected.endswith(
+                            (b'/tarfile', b'/users', b'/bar')):
+                        exp_user, exp_group = expected.split(b'/')
+                        got_user, got_group = got.split(b'/')
+                        self.assertEqual(got_user, exp_user)
+                        self.assertRegex(got_group, b'[0-9]+')
+                    elif attr_names == {'uid'} and expected.startswith(
+                            (b'1000/')):
+                        exp_user, exp_group = expected.split(b'/')
+                        got_user, got_group = got.split(b'/')
+                        self.assertEqual(got_group, exp_group)
+                        self.assertEqual(got_user, b'None')
+                    elif attr_names == {'gid'} and expected.endswith((b'/100')):
+                        exp_user, exp_group = expected.split(b'/')
+                        got_user, got_group = got.split(b'/')
+                        self.assertEqual(got_user, exp_user)
+                        self.assertEqual(got_group, b'None')
+                    elif attr_names == {'uid', 'uname'} and expected.startswith(
+                            (b'tarfile/', b'lars/', b'foo/', b'1000/')):
+                        exp_user, exp_group = expected.split(b'/')
+                        got_user, got_group = got.split(b'/')
+                        self.assertEqual(got_group, exp_group)
+                        self.assertEqual(got_user, b'None')
+                    elif attr_names == {'gname', 'gid'} and expected.endswith(
+                            (b'/tarfile', b'/users', b'/bar', b'/100')):
+                        exp_user, exp_group = expected.split(b'/')
+                        got_user, got_group = got.split(b'/')
+                        self.assertEqual(got_user, exp_user)
+                        self.assertEqual(got_group, b'None')
+                    else:
+                        # In other cases the output should be the same
+                        self.assertEqual(expected, got)
+
+def _filemode_to_int(mode):
+    """Inverse of `stat.filemode` (for permission bits)
+
+    Using mode strings rather than numbers makes the later tests more readable.
+    """
+    str_mode = mode[1:]
+    result = (
+          {'r': stat.S_IRUSR, '-': 0}[str_mode[0]]
+        | {'w': stat.S_IWUSR, '-': 0}[str_mode[1]]
+        | {'x': stat.S_IXUSR, '-': 0,
+           's': stat.S_IXUSR | stat.S_ISUID,
+           'S': stat.S_ISUID}[str_mode[2]]
+        | {'r': stat.S_IRGRP, '-': 0}[str_mode[3]]
+        | {'w': stat.S_IWGRP, '-': 0}[str_mode[4]]
+        | {'x': stat.S_IXGRP, '-': 0,
+           's': stat.S_IXGRP | stat.S_ISGID,
+           'S': stat.S_ISGID}[str_mode[5]]
+        | {'r': stat.S_IROTH, '-': 0}[str_mode[6]]
+        | {'w': stat.S_IWOTH, '-': 0}[str_mode[7]]
+        | {'x': stat.S_IXOTH, '-': 0,
+           't': stat.S_IXOTH | stat.S_ISVTX,
+           'T': stat.S_ISVTX}[str_mode[8]]
+        )
+    # check we did this right
+    assert stat.filemode(result)[1:] == mode[1:]
+
+    return result
+
+class ArchiveMaker:
+    """Helper to create a tar file with specific contents
+
+    Usage:
+
+        with ArchiveMaker() as t:
+            t.add('filename', ...)
+
+        with t.open() as tar:
+            ... # `tar` is now a TarFile with 'filename' in it!
+    """
+    def __init__(self, **kwargs):
+        self.bio = io.BytesIO()
+        self.tar_kwargs = dict(kwargs)
+
+    def __enter__(self):
+        self.tar_w = tarfile.TarFile(mode='w', fileobj=self.bio, **self.tar_kwargs)
+        return self
+
+    def __exit__(self, *exc):
+        self.tar_w.close()
+        self.contents = self.bio.getvalue()
+        self.bio = None
+
+    def add(self, name, *, type=None, symlink_to=None, hardlink_to=None,
+            mode=None, size=None, content=None, **kwargs):
+        """Add a member to the test archive. Call within `with`.
+
+        Provides many shortcuts:
+        - default `type` is based on symlink_to, hardlink_to, and trailing `/`
+          in name (which is stripped)
+        - size & content defaults are based on each other
+        - content can be str or bytes
+        - mode should be textual ('-rwxrwxrwx')
+
+        (add more! this is unstable internal test-only API)
+        """
+        name = str(name)
+        tarinfo = tarfile.TarInfo(name).replace(**kwargs)
+        if content is not None:
+            if isinstance(content, str):
+                content = content.encode()
+            size = len(content)
+        if size is not None:
+            tarinfo.size = size
+            if content is None:
+                content = bytes(tarinfo.size)
+        if mode:
+            tarinfo.mode = _filemode_to_int(mode)
+        if symlink_to is not None:
+            type = tarfile.SYMTYPE
+            tarinfo.linkname = str(symlink_to)
+        if hardlink_to is not None:
+            type = tarfile.LNKTYPE
+            tarinfo.linkname = str(hardlink_to)
+        if name.endswith('/') and type is None:
+            type = tarfile.DIRTYPE
+        if type is not None:
+            tarinfo.type = type
+        if tarinfo.isreg():
+            fileobj = io.BytesIO(content)
+        else:
+            fileobj = None
+        self.tar_w.addfile(tarinfo, fileobj)
+
+    def open(self, **kwargs):
+        """Open the resulting archive as TarFile. Call after `with`."""
+        bio = io.BytesIO(self.contents)
+        return tarfile.open(fileobj=bio, **kwargs)
+
+# Under WASI, `os_helper.can_symlink` is False to make
+# `skip_unless_symlink` skip symlink tests. "
+# But in the following tests we use can_symlink to *determine* which
+# behavior is expected.
+# Like other symlink tests, skip these on WASI for now.
+if support.is_wasi:
+    def symlink_test(f):
+        return unittest.skip("WASI: Skip symlink test for now")(f)
+else:
+    def symlink_test(f):
+        return f
+
+
+class TestExtractionFilters(unittest.TestCase):
+
+    # A temporary directory for the extraction results.
+    # All files that "escape" the destination path should still end
+    # up in this directory.
+    outerdir = pathlib.Path(TEMPDIR) / 'outerdir'
+
+    # The destination for the extraction, within `outerdir`
+    destdir = outerdir / 'dest'
+
+    @contextmanager
+    def check_context(self, tar, filter, *, check_flag=True):
+        """Extracts `tar` to `self.destdir` and allows checking the result
+
+        If an error occurs, it must be checked using `expect_exception`
+
+        Otherwise, all resulting files must be checked using `expect_file`,
+        except the destination directory itself and parent directories of
+        other files.
+        When checking directories, do so before their contents.
+
+        A file called 'flag' is made in outerdir (i.e. outside destdir)
+        before extraction; it should not be altered nor should its contents
+        be read/copied.
+        """
+        with os_helper.temp_dir(self.outerdir):
+            flag_path = self.outerdir / 'flag'
+            flag_path.write_text('capture me')
+            try:
+                tar.extractall(self.destdir, filter=filter)
+            except Exception as exc:
+                self.raised_exception = exc
+                self.reraise_exception = True
+                self.expected_paths = set()
+            else:
+                self.raised_exception = None
+                self.reraise_exception = False
+                self.expected_paths = set(self.outerdir.glob('**/*'))
+                self.expected_paths.discard(self.destdir)
+                self.expected_paths.discard(flag_path)
+            try:
+                yield self
+            finally:
+                tar.close()
+            if self.reraise_exception:
+                raise self.raised_exception
+            self.assertEqual(self.expected_paths, set())
+            if check_flag:
+                self.assertEqual(flag_path.read_text(), 'capture me')
+            else:
+                assert filter == 'fully_trusted'
+
+    def expect_file(self, name, type=None, symlink_to=None, mode=None,
+                    size=None, content=None):
+        """Check a single file. See check_context."""
+        if self.raised_exception:
+            raise self.raised_exception
+        # use normpath() rather than resolve() so we don't follow symlinks
+        path = pathlib.Path(os.path.normpath(self.destdir / name))
+        self.assertIn(path, self.expected_paths)
+        self.expected_paths.remove(path)
+        if mode is not None and os_helper.can_chmod() and os.name != 'nt':
+            got = stat.filemode(stat.S_IMODE(path.stat().st_mode))
+            self.assertEqual(got, mode)
+        if type is None and isinstance(name, str) and name.endswith('/'):
+            type = tarfile.DIRTYPE
+        if symlink_to is not None:
+            got = (self.destdir / name).readlink()
+            expected = pathlib.Path(symlink_to)
+            # The symlink might be the same (textually) as what we expect,
+            # but some systems change the link to an equivalent path, so
+            # we fall back to samefile().
+            try:
+                if expected != got:
+                    self.assertTrue(got.samefile(expected))
+            except Exception as e:
+                # attach a note, so it's shown even if `samefile` fails
+                e.add_note(f'{expected=}, {got=}')
+                raise
+        elif type == tarfile.REGTYPE or type is None:
+            self.assertTrue(path.is_file())
+        elif type == tarfile.DIRTYPE:
+            self.assertTrue(path.is_dir())
+        elif type == tarfile.FIFOTYPE:
+            self.assertTrue(path.is_fifo())
+        elif type == tarfile.SYMTYPE:
+            self.assertTrue(path.is_symlink())
+        else:
+            raise NotImplementedError(type)
+        if size is not None:
+            self.assertEqual(path.stat().st_size, size)
+        if content is not None:
+            self.assertEqual(path.read_text(), content)
+        for parent in path.parents:
+            self.expected_paths.discard(parent)
+
+    def expect_any_tree(self, name):
+        """Check a directory; forget about its contents."""
+        tree_path = (self.destdir / name).resolve()
+        self.expect_file(tree_path, type=tarfile.DIRTYPE)
+        self.expected_paths = {
+            p for p in self.expected_paths
+            if tree_path not in p.parents
+        }
+
+    def expect_exception(self, exc_type, message_re='.'):
+        with self.assertRaisesRegex(exc_type, message_re):
+            if self.raised_exception is not None:
+                raise self.raised_exception
+        self.reraise_exception = False
+        return self.raised_exception
+
+    def test_benign_file(self):
+        with ArchiveMaker() as arc:
+            arc.add('benign.txt')
+        for filter in 'fully_trusted', 'tar', 'data':
+            with self.check_context(arc.open(), filter):
+                self.expect_file('benign.txt')
+
+    def test_absolute(self):
+        # Test handling a member with an absolute path
+        # Inspired by 'absolute1' in https://github.com/jwilk/traversal-archives
+        with ArchiveMaker() as arc:
+            arc.add(self.outerdir / 'escaped.evil')
+
+        with self.check_context(arc.open(), 'fully_trusted'):
+            self.expect_file('../escaped.evil')
+
+        for filter in 'tar', 'data':
+            with self.check_context(arc.open(), filter):
+                if str(self.outerdir).startswith('/'):
+                    # We strip leading slashes, as e.g. GNU tar does
+                    # (without --absolute-filenames).
+                    outerdir_stripped = str(self.outerdir).lstrip('/')
+                    self.expect_file(f'{outerdir_stripped}/escaped.evil')
+                else:
+                    # On this system, absolute paths don't have leading
+                    # slashes.
+                    # So, there's nothing to strip. We refuse to unpack
+                    # to an absolute path, nonetheless.
+                    self.expect_exception(
+                        tarfile.AbsolutePathError,
+                        """['"].*escaped.evil['"] has an absolute path""")
+
+    @symlink_test
+    def test_parent_symlink(self):
+        # Test interplaying symlinks
+        # Inspired by 'dirsymlink2a' in jwilk/traversal-archives
+        with ArchiveMaker() as arc:
+
+            # `current` links to `.` which is both:
+            #   - the destination directory
+            #   - `current` itself
+            arc.add('current', symlink_to='.')
+
+            # effectively points to ./../
+            arc.add('parent', symlink_to='current/..')
+
+            arc.add('parent/evil')
+
+        if os_helper.can_symlink():
+            with self.check_context(arc.open(), 'fully_trusted'):
+                if self.raised_exception is not None:
+                    # Windows will refuse to create a file that's a symlink to itself
+                    # (and tarfile doesn't swallow that exception)
+                    self.expect_exception(FileExistsError)
+                    # The other cases will fail with this error too.
+                    # Skip the rest of this test.
+                    return
+                else:
+                    self.expect_file('current', symlink_to='.')
+                    self.expect_file('parent', symlink_to='current/..')
+                    self.expect_file('../evil')
+
+            with self.check_context(arc.open(), 'tar'):
+                self.expect_exception(
+                    tarfile.OutsideDestinationError,
+                    """'parent/evil' would be extracted to ['"].*evil['"], """
+                    + "which is outside the destination")
+
+            with self.check_context(arc.open(), 'data'):
+                self.expect_exception(
+                    tarfile.LinkOutsideDestinationError,
+                    """'parent' would link to ['"].*outerdir['"], """
+                    + "which is outside the destination")
+
+        else:
+            # No symlink support. The symlinks are ignored.
+            with self.check_context(arc.open(), 'fully_trusted'):
+                self.expect_file('parent/evil')
+            with self.check_context(arc.open(), 'tar'):
+                self.expect_file('parent/evil')
+            with self.check_context(arc.open(), 'data'):
+                self.expect_file('parent/evil')
+
+    @symlink_test
+    @os_helper.skip_unless_symlink
+    def test_realpath_limit_attack(self):
+        # (CVE-2025-4517)
+
+        with ArchiveMaker() as arc:
+            # populate the symlinks and dirs that expand in os.path.realpath()
+            # The component length is chosen so that in common cases, the unexpanded
+            # path fits in PATH_MAX, but it overflows when the final symlink
+            # is expanded
+            steps = "abcdefghijklmnop"
+            if sys.platform == 'win32':
+                component = 'd' * 25
+            elif 'PC_PATH_MAX' in os.pathconf_names:
+                max_path_len = os.pathconf(self.outerdir.parent, "PC_PATH_MAX")
+                path_sep_len = 1
+                dest_len = len(str(self.destdir)) + path_sep_len
+                component_len = (max_path_len - dest_len) // (len(steps) + path_sep_len)
+                component = 'd' * component_len
+            else:
+                raise NotImplementedError("Need to guess component length for {sys.platform}")
+            path = ""
+            step_path = ""
+            for i in steps:
+                arc.add(os.path.join(path, component), type=tarfile.DIRTYPE,
+                        mode='drwxrwxrwx')
+                arc.add(os.path.join(path, i), symlink_to=component)
+                path = os.path.join(path, component)
+                step_path = os.path.join(step_path, i)
+            # create the final symlink that exceeds PATH_MAX and simply points
+            # to the top dir.
+            # this link will never be expanded by
+            # os.path.realpath(strict=False), nor anything after it.
+            linkpath = os.path.join(*steps, "l"*254)
+            parent_segments = [".."] * len(steps)
+            arc.add(linkpath, symlink_to=os.path.join(*parent_segments))
+            # make a symlink outside to keep the tar command happy
+            arc.add("escape", symlink_to=os.path.join(linkpath, ".."))
+            # use the symlinks above, that are not checked, to create a hardlink
+            # to a file outside of the destination path
+            arc.add("flaglink", hardlink_to=os.path.join("escape", "flag"))
+            # now that we have the hardlink we can overwrite the file
+            arc.add("flaglink", content='overwrite')
+            # we can also create new files as well!
+            arc.add("escape/newfile", content='new')
+
+        with (self.subTest('fully_trusted'),
+              self.check_context(arc.open(), filter='fully_trusted',
+                                 check_flag=False)):
+            if sys.platform == 'win32':
+                self.expect_exception((FileNotFoundError, FileExistsError))
+            elif self.raised_exception:
+                # Cannot symlink/hardlink: tarfile falls back to getmember()
+                self.expect_exception(KeyError)
+                # Otherwise, this block should never enter.
+            else:
+                self.expect_any_tree(component)
+                self.expect_file('flaglink', content='overwrite')
+                self.expect_file('../newfile', content='new')
+                self.expect_file('escape', type=tarfile.SYMTYPE)
+                self.expect_file('a', symlink_to=component)
+
+        for filter in 'tar', 'data':
+            with self.subTest(filter), self.check_context(arc.open(), filter=filter):
+                exc = self.expect_exception((OSError, KeyError))
+                if isinstance(exc, OSError):
+                    if sys.platform == 'win32':
+                        # 3: ERROR_PATH_NOT_FOUND
+                        # 5: ERROR_ACCESS_DENIED
+                        # 206: ERROR_FILENAME_EXCED_RANGE
+                        self.assertIn(exc.winerror, (3, 5, 206))
+                    else:
+                        self.assertEqual(exc.errno, errno.ENAMETOOLONG)
+
+    @symlink_test
+    def test_parent_symlink2(self):
+        # Test interplaying symlinks
+        # Inspired by 'dirsymlink2b' in jwilk/traversal-archives
+
+        # Posix and Windows have different pathname resolution:
+        # either symlink or a '..' component resolve first.
+        # Let's see which we are on.
+        if os_helper.can_symlink():
+            testpath = os.path.join(TEMPDIR, 'resolution_test')
+            os.mkdir(testpath)
+
+            # testpath/current links to `.` which is all of:
+            #   - `testpath`
+            #   - `testpath/current`
+            #   - `testpath/current/current`
+            #   - etc.
+            os.symlink('.', os.path.join(testpath, 'current'))
+
+            # we'll test where `testpath/current/../file` ends up
+            with open(os.path.join(testpath, 'current', '..', 'file'), 'w'):
+                pass
+
+            if os.path.exists(os.path.join(testpath, 'file')):
+                # Windows collapses 'current\..' to '.' first, leaving
+                # 'testpath\file'
+                dotdot_resolves_early = True
+            elif os.path.exists(os.path.join(testpath, '..', 'file')):
+                # Posix resolves 'current' to '.' first, leaving
+                # 'testpath/../file'
+                dotdot_resolves_early = False
+            else:
+                raise AssertionError('Could not determine link resolution')
+
+        with ArchiveMaker() as arc:
+
+            # `current` links to `.` which is both the destination directory
+            # and `current` itself
+            arc.add('current', symlink_to='.')
+
+            # `current/parent` is also available as `./parent`,
+            # and effectively points to `./../`
+            arc.add('current/parent', symlink_to='..')
+
+            arc.add('parent/evil')
+
+        with self.check_context(arc.open(), 'fully_trusted'):
+            if os_helper.can_symlink():
+                self.expect_file('current', symlink_to='.')
+                self.expect_file('parent', symlink_to='..')
+                self.expect_file('../evil')
+            else:
+                self.expect_file('current/')
+                self.expect_file('parent/evil')
+
+        with self.check_context(arc.open(), 'tar'):
+            if os_helper.can_symlink():
+                # Fail when extracting a file outside destination
+                self.expect_exception(
+                        tarfile.OutsideDestinationError,
+                        "'parent/evil' would be extracted to "
+                        + """['"].*evil['"], which is outside """
+                        + "the destination")
+            else:
+                self.expect_file('current/')
+                self.expect_file('parent/evil')
+
+        with self.check_context(arc.open(), 'data'):
+            if os_helper.can_symlink():
+                if dotdot_resolves_early:
+                    # Fail when extracting a file outside destination
+                    self.expect_exception(
+                            tarfile.OutsideDestinationError,
+                            "'parent/evil' would be extracted to "
+                            + """['"].*evil['"], which is outside """
+                            + "the destination")
+                else:
+                    # Fail as soon as we have a symlink outside the destination
+                    self.expect_exception(
+                            tarfile.LinkOutsideDestinationError,
+                            "'current/parent' would link to "
+                            + """['"].*outerdir['"], which is outside """
+                            + "the destination")
+            else:
+                self.expect_file('current/')
+                self.expect_file('parent/evil')
+
+    @symlink_test
+    def test_absolute_symlink(self):
+        # Test symlink to an absolute path
+        # Inspired by 'dirsymlink' in jwilk/traversal-archives
+        with ArchiveMaker() as arc:
+            arc.add('parent', symlink_to=self.outerdir)
+            arc.add('parent/evil')
+
+        with self.check_context(arc.open(), 'fully_trusted'):
+            if os_helper.can_symlink():
+                self.expect_file('parent', symlink_to=self.outerdir)
+                self.expect_file('../evil')
+            else:
+                self.expect_file('parent/evil')
+
+        with self.check_context(arc.open(), 'tar'):
+            if os_helper.can_symlink():
+                self.expect_exception(
+                        tarfile.OutsideDestinationError,
+                        "'parent/evil' would be extracted to "
+                        + """['"].*evil['"], which is outside """
+                        + "the destination")
+            else:
+                self.expect_file('parent/evil')
+
+        with self.check_context(arc.open(), 'data'):
+            self.expect_exception(
+                tarfile.AbsoluteLinkError,
+                "'parent' is a link to an absolute path")
+
+    def test_absolute_hardlink(self):
+        # Test hardlink to an absolute path
+        # Inspired by 'dirsymlink' in https://github.com/jwilk/traversal-archives
+        with ArchiveMaker() as arc:
+            arc.add('parent', hardlink_to=self.outerdir / 'foo')
+
+        with self.check_context(arc.open(), 'fully_trusted'):
+            self.expect_exception(KeyError, ".*foo. not found")
+
+        with self.check_context(arc.open(), 'tar'):
+            self.expect_exception(KeyError, ".*foo. not found")
+
+        with self.check_context(arc.open(), 'data'):
+            self.expect_exception(
+                tarfile.AbsoluteLinkError,
+                "'parent' is a link to an absolute path")
+
+    @symlink_test
+    def test_sly_relative0(self):
+        # Inspired by 'relative0' in jwilk/traversal-archives
+        with ArchiveMaker() as arc:
+            # points to `../../tmp/moo`
+            arc.add('../moo', symlink_to='..//tmp/moo')
+
+        try:
+            with self.check_context(arc.open(), filter='fully_trusted'):
+                if os_helper.can_symlink():
+                    if isinstance(self.raised_exception, FileExistsError):
+                        # XXX TarFile happens to fail creating a parent
+                        # directory.
+                        # This might be a bug, but fixing it would hurt
+                        # security.
+                        # Note that e.g. GNU `tar` rejects '..' components,
+                        # so you could argue this is an invalid archive and we
+                        # just raise an bad type of exception.
+                        self.expect_exception(FileExistsError)
+                    else:
+                        self.expect_file('../moo', symlink_to='..//tmp/moo')
+                else:
+                    # The symlink can't be extracted and is ignored
+                    pass
+        except FileExistsError:
+            pass
+
+        for filter in 'tar', 'data':
+            with self.check_context(arc.open(), filter):
+                self.expect_exception(
+                        tarfile.OutsideDestinationError,
+                        "'../moo' would be extracted to "
+                        + "'.*moo', which is outside "
+                        + "the destination")
+
+    @symlink_test
+    def test_sly_relative2(self):
+        # Inspired by 'relative2' in jwilk/traversal-archives
+        with ArchiveMaker() as arc:
+            arc.add('tmp/')
+            arc.add('tmp/../../moo', symlink_to='tmp/../..//tmp/moo')
+
+        with self.check_context(arc.open(), 'fully_trusted'):
+            self.expect_file('tmp', type=tarfile.DIRTYPE)
+            if os_helper.can_symlink():
+                self.expect_file('../moo', symlink_to='tmp/../../tmp/moo')
+
+        for filter in 'tar', 'data':
+            with self.check_context(arc.open(), filter):
+                self.expect_exception(
+                    tarfile.OutsideDestinationError,
+                    "'tmp/../../moo' would be extracted to "
+                    + """['"].*moo['"], which is outside the """
+                    + "destination")
+
+    @symlink_test
+    def test_deep_symlink(self):
+        # Test that symlinks and hardlinks inside a directory
+        # point to the correct file (`target` of size 3).
+        # If links aren't supported we get a copy of the file.
+        with ArchiveMaker() as arc:
+            arc.add('targetdir/target', size=3)
+            # a hardlink's linkname is relative to the archive
+            arc.add('linkdir/hardlink', hardlink_to=os.path.join(
+                'targetdir', 'target'))
+            # a symlink's  linkname is relative to the link's directory
+            arc.add('linkdir/symlink', symlink_to=os.path.join(
+                '..', 'targetdir', 'target'))
+
+        for filter in 'tar', 'data', 'fully_trusted':
+            with self.check_context(arc.open(), filter):
+                self.expect_file('targetdir/target', size=3)
+                self.expect_file('linkdir/hardlink', size=3)
+                if os_helper.can_symlink():
+                    self.expect_file('linkdir/symlink', size=3,
+                                     symlink_to='../targetdir/target')
+                else:
+                    self.expect_file('linkdir/symlink', size=3)
+
+    @symlink_test
+    def test_chains(self):
+        # Test chaining of symlinks/hardlinks.
+        # Symlinks are created before the files they point to.
+        with ArchiveMaker() as arc:
+            arc.add('linkdir/symlink', symlink_to='hardlink')
+            arc.add('symlink2', symlink_to=os.path.join(
+                'linkdir', 'hardlink2'))
+            arc.add('targetdir/target', size=3)
+            arc.add('linkdir/hardlink', hardlink_to=os.path.join('targetdir', 'target'))
+            arc.add('linkdir/hardlink2', hardlink_to=os.path.join('linkdir', 'symlink'))
+
+        for filter in 'tar', 'data', 'fully_trusted':
+            with self.check_context(arc.open(), filter):
+                self.expect_file('targetdir/target', size=3)
+                self.expect_file('linkdir/hardlink', size=3)
+                self.expect_file('linkdir/hardlink2', size=3)
+                if os_helper.can_symlink():
+                    self.expect_file('linkdir/symlink', size=3,
+                                     symlink_to='hardlink')
+                    self.expect_file('symlink2', size=3,
+                                     symlink_to='linkdir/hardlink2')
+                else:
+                    self.expect_file('linkdir/symlink', size=3)
+                    self.expect_file('symlink2', size=3)
+
+    @symlink_test
+    def test_sneaky_hardlink_fallback(self):
+        # (CVE-2025-4330)
+        # Test that when hardlink extraction falls back to extracting members
+        # from the archive, the extracted member is (re-)filtered.
+        with ArchiveMaker() as arc:
+            # Create a directory structure so the c/escape symlink stays
+            # inside the path
+            arc.add("a/t/dummy")
+            # Create b/ directory
+            arc.add("b/")
+            # Point "c" to the bottom of the tree in "a"
+            arc.add("c", symlink_to=os.path.join("a", "t"))
+            # link to non-existant location under "a"
+            arc.add("c/escape", symlink_to=os.path.join("..", "..",
+                                                        "link_here"))
+            # Move "c" to point to "b" ("c/escape" no longer exists)
+            arc.add("c", symlink_to="b")
+            # Attempt to create a hard link to "c/escape". Since it doesn't
+            # exist it will attempt to extract "cescape" but at "boom".
+            arc.add("boom", hardlink_to=os.path.join("c", "escape"))
+
+        with self.check_context(arc.open(), 'data'):
+            if not os_helper.can_symlink():
+                # When 'c/escape' is extracted, 'c' is a regular
+                # directory, and 'c/escape' *would* point outside
+                # the destination if symlinks were allowed.
+                self.expect_exception(
+                    tarfile.LinkOutsideDestinationError)
+            elif sys.platform == "win32":
+                # On Windows, 'c/escape' points outside the destination
+                self.expect_exception(tarfile.LinkOutsideDestinationError)
+            else:
+                e = self.expect_exception(
+                    tarfile.LinkFallbackError,
+                    "link 'boom' would be extracted as a copy of "
+                    + "'c/escape', which was rejected")
+                self.assertIsInstance(e.__cause__,
+                                      tarfile.LinkOutsideDestinationError)
+        for filter in 'tar', 'fully_trusted':
+            with self.subTest(filter), self.check_context(arc.open(), filter):
+                if not os_helper.can_symlink():
+                    self.expect_file("a/t/dummy")
+                    self.expect_file("b/")
+                    self.expect_file("c/")
+                else:
+                    self.expect_file("a/t/dummy")
+                    self.expect_file("b/")
+                    self.expect_file("a/t/escape", symlink_to='../../link_here')
+                    self.expect_file("boom", symlink_to='../../link_here')
+                    self.expect_file("c", symlink_to='b')
+
+    @symlink_test
+    def test_exfiltration_via_symlink(self):
+        # (CVE-2025-4138)
+        # Test changing symlinks that result in a symlink pointing outside
+        # the extraction directory, unless prevented by 'data' filter's
+        # normalization.
+        with ArchiveMaker() as arc:
+            arc.add("escape", symlink_to=os.path.join('link', 'link', '..', '..', 'link-here'))
+            arc.add("link", symlink_to='./')
+
+        for filter in 'tar', 'data', 'fully_trusted':
+            with self.check_context(arc.open(), filter):
+                if os_helper.can_symlink():
+                    self.expect_file("link", symlink_to='./')
+                    if filter == 'data':
+                        self.expect_file("escape", symlink_to='link-here')
+                    else:
+                        self.expect_file("escape",
+                                         symlink_to='link/link/../../link-here')
+                else:
+                    # Nothing is extracted.
+                    pass
+
+    @symlink_test
+    def test_chmod_outside_dir(self):
+        # (CVE-2024-12718)
+        # Test that members used for delayed updates of directory metadata
+        # are (re-)filtered.
+        with ArchiveMaker() as arc:
+            # "pwn" is a veeeery innocent symlink:
+            arc.add("a/pwn", symlink_to='.')
+            # But now "pwn" is also a directory, so it's scheduled to have its
+            # metadata updated later:
+            arc.add("a/pwn/", mode='drwxrwxrwx')
+            # Oops, "pwn" is not so innocent any more:
+            arc.add("a/pwn", symlink_to='x/../')
+            # Newly created symlink points to the dest dir,
+            # so it's OK for the "data" filter.
+            arc.add('a/x', symlink_to=('../'))
+            # But now "pwn" points outside the dest dir
+
+        for filter in 'tar', 'data', 'fully_trusted':
+            with self.check_context(arc.open(), filter) as cc:
+                if not os_helper.can_symlink():
+                    self.expect_file("a/pwn/")
+                elif filter == 'data':
+                    self.expect_file("a/x", symlink_to='../')
+                    self.expect_file("a/pwn", symlink_to='.')
+                else:
+                    self.expect_file("a/x", symlink_to='../')
+                    self.expect_file("a/pwn", symlink_to='x/../')
+                if sys.platform != "win32":
+                    st_mode = cc.outerdir.stat().st_mode
+                    self.assertNotEqual(st_mode & 0o777, 0o777)
+
+    def test_link_fallback_normalizes(self):
+        # Make sure hardlink fallbacks work for non-normalized paths for all
+        # filters
+        with ArchiveMaker() as arc:
+            arc.add("dir/")
+            arc.add("dir/../afile")
+            arc.add("link1", hardlink_to='dir/../afile')
+            arc.add("link2", hardlink_to='dir/../dir/../afile')
+
+        for filter in 'tar', 'data', 'fully_trusted':
+            with self.check_context(arc.open(), filter) as cc:
+                self.expect_file("dir/")
+                self.expect_file("afile")
+                self.expect_file("link1")
+                self.expect_file("link2")
+
+    def test_modes(self):
+        # Test how file modes are extracted
+        # (Note that the modes are ignored on platforms without working chmod)
+        with ArchiveMaker() as arc:
+            arc.add('all_bits', mode='?rwsrwsrwt')
+            arc.add('perm_bits', mode='?rwxrwxrwx')
+            arc.add('exec_group_other', mode='?rw-rwxrwx')
+            arc.add('read_group_only', mode='?---r-----')
+            arc.add('no_bits', mode='?---------')
+            arc.add('dir/', mode='?---rwsrwt')
+            arc.add('dir_all_bits/', mode='?rwsrwsrwt')
+
+        # On some systems, setting the uid, gid, and/or sticky bit is a no-ops.
+        # Check which bits we can set, so we can compare tarfile machinery to
+        # a simple chmod.
+        tmp_filename = os.path.join(TEMPDIR, "tmp.file")
+        with open(tmp_filename, 'w'):
+            pass
+        try:
+            new_mode = (os.stat(tmp_filename).st_mode
+                        | stat.S_ISVTX | stat.S_ISGID | stat.S_ISUID)
+            try:
+                os.chmod(tmp_filename, new_mode)
+            except OSError as exc:
+                if exc.errno == getattr(errno, "EFTYPE", 0):
+                    # gh-108948: On FreeBSD, regular users cannot set
+                    # the sticky bit.
+                    self.skipTest("chmod() failed with EFTYPE: "
+                                  "regular users cannot set sticky bit")
+                else:
+                    raise
+
+            got_mode = os.stat(tmp_filename).st_mode
+            _t_file = 't' if (got_mode & stat.S_ISVTX) else 'x'
+            _suid_file = 's' if (got_mode & stat.S_ISUID) else 'x'
+            _sgid_file = 's' if (got_mode & stat.S_ISGID) else 'x'
+        finally:
+            os.unlink(tmp_filename)
+
+        os.mkdir(tmp_filename)
+        new_mode = (os.stat(tmp_filename).st_mode
+                    | stat.S_ISVTX | stat.S_ISGID | stat.S_ISUID)
+        os.chmod(tmp_filename, new_mode)
+        got_mode = os.stat(tmp_filename).st_mode
+        _t_dir = 't' if (got_mode & stat.S_ISVTX) else 'x'
+        _suid_dir = 's' if (got_mode & stat.S_ISUID) else 'x'
+        _sgid_dir = 's' if (got_mode & stat.S_ISGID) else 'x'
+        os.rmdir(tmp_filename)
+
+        with self.check_context(arc.open(), 'fully_trusted'):
+            self.expect_file('all_bits',
+                             mode=f'?rw{_suid_file}rw{_sgid_file}rw{_t_file}')
+            self.expect_file('perm_bits', mode='?rwxrwxrwx')
+            self.expect_file('exec_group_other', mode='?rw-rwxrwx')
+            self.expect_file('read_group_only', mode='?---r-----')
+            self.expect_file('no_bits', mode='?---------')
+            self.expect_file('dir/', mode=f'?---rw{_sgid_dir}rw{_t_dir}')
+            self.expect_file('dir_all_bits/',
+                             mode=f'?rw{_suid_dir}rw{_sgid_dir}rw{_t_dir}')
+
+        with self.check_context(arc.open(), 'tar'):
+            self.expect_file('all_bits', mode='?rwxr-xr-x')
+            self.expect_file('perm_bits', mode='?rwxr-xr-x')
+            self.expect_file('exec_group_other', mode='?rw-r-xr-x')
+            self.expect_file('read_group_only', mode='?---r-----')
+            self.expect_file('no_bits', mode='?---------')
+            self.expect_file('dir/', mode='?---r-xr-x')
+            self.expect_file('dir_all_bits/', mode='?rwxr-xr-x')
+
+        with self.check_context(arc.open(), 'data'):
+            normal_dir_mode = stat.filemode(stat.S_IMODE(
+                self.outerdir.stat().st_mode))
+            self.expect_file('all_bits', mode='?rwxr-xr-x')
+            self.expect_file('perm_bits', mode='?rwxr-xr-x')
+            self.expect_file('exec_group_other', mode='?rw-r--r--')
+            self.expect_file('read_group_only', mode='?rw-r-----')
+            self.expect_file('no_bits', mode='?rw-------')
+            self.expect_file('dir/', mode=normal_dir_mode)
+            self.expect_file('dir_all_bits/', mode=normal_dir_mode)
+
+    def test_pipe(self):
+        # Test handling of a special file
+        with ArchiveMaker() as arc:
+            arc.add('foo', type=tarfile.FIFOTYPE)
+
+        for filter in 'fully_trusted', 'tar':
+            with self.check_context(arc.open(), filter):
+                if hasattr(os, 'mkfifo'):
+                    self.expect_file('foo', type=tarfile.FIFOTYPE)
+                else:
+                    # The pipe can't be extracted and is skipped.
+                    pass
+
+        with self.check_context(arc.open(), 'data'):
+            self.expect_exception(
+                tarfile.SpecialFileError,
+                "'foo' is a special file")
+
+    def test_special_files(self):
+        # Creating device files is tricky. Instead of attempting that let's
+        # only check the filter result.
+        for special_type in tarfile.FIFOTYPE, tarfile.CHRTYPE, tarfile.BLKTYPE:
+            tarinfo = tarfile.TarInfo('foo')
+            tarinfo.type = special_type
+            trusted = tarfile.fully_trusted_filter(tarinfo, '')
+            self.assertIs(trusted, tarinfo)
+            tar = tarfile.tar_filter(tarinfo, '')
+            self.assertEqual(tar.type, special_type)
+            with self.assertRaises(tarfile.SpecialFileError) as cm:
+                tarfile.data_filter(tarinfo, '')
+            self.assertIsInstance(cm.exception.tarinfo, tarfile.TarInfo)
+            self.assertEqual(cm.exception.tarinfo.name, 'foo')
+
+    def test_fully_trusted_filter(self):
+        # The 'fully_trusted' filter returns the original TarInfo objects.
+        with tarfile.TarFile.open(tarname) as tar:
+            for tarinfo in tar.getmembers():
+                filtered = tarfile.fully_trusted_filter(tarinfo, '')
+                self.assertIs(filtered, tarinfo)
+
+    def test_tar_filter(self):
+        # The 'tar' filter returns TarInfo objects with the same name/type.
+        # (It can also fail for particularly "evil" input, but we don't have
+        # that in the test archive.)
+        with tarfile.TarFile.open(tarname, encoding="iso8859-1") as tar:
+            for tarinfo in tar.getmembers():
+                try:
+                    filtered = tarfile.tar_filter(tarinfo, '')
+                except UnicodeEncodeError:
+                    continue
+                self.assertIs(filtered.name, tarinfo.name)
+                self.assertIs(filtered.type, tarinfo.type)
+
+    def test_data_filter(self):
+        # The 'data' filter either raises, or returns TarInfo with the same
+        # name/type.
+        with tarfile.TarFile.open(tarname, encoding="iso8859-1") as tar:
+            for tarinfo in tar.getmembers():
+                try:
+                    filtered = tarfile.data_filter(tarinfo, '')
+                except (tarfile.FilterError, UnicodeEncodeError):
+                    continue
+                self.assertIs(filtered.name, tarinfo.name)
+                self.assertIs(filtered.type, tarinfo.type)
+
+    @unittest.skipIf(sys.platform == 'win32', 'requires native bytes paths')
+    def test_filter_unencodable(self):
+        # Sanity check using a valid path.
+        tarinfo = tarfile.TarInfo(os_helper.TESTFN)
+        filtered = tarfile.tar_filter(tarinfo, '')
+        self.assertIs(filtered.name, tarinfo.name)
+        filtered = tarfile.data_filter(tarinfo, '')
+        self.assertIs(filtered.name, tarinfo.name)
+
+        tarinfo = tarfile.TarInfo('test\x00')
+        self.assertRaises(ValueError, tarfile.tar_filter, tarinfo, '')
+        self.assertRaises(ValueError, tarfile.data_filter, tarinfo, '')
+        tarinfo = tarfile.TarInfo('\ud800')
+        self.assertRaises(UnicodeEncodeError, tarfile.tar_filter, tarinfo, '')
+        self.assertRaises(UnicodeEncodeError, tarfile.data_filter, tarinfo, '')
+
+    @unittest.skipIf(sys.platform == 'win32', 'requires native bytes paths')
+    def test_extract_unencodable(self):
+        # Create a member with name \xed\xa0\x80 which is UTF-8 encoded
+        # lone surrogate \ud800.
+        with ArchiveMaker(encoding='ascii', errors='surrogateescape') as arc:
+            arc.add('\udced\udca0\udc80')
+        with os_helper.temp_cwd() as tmp:
+            tar = arc.open(encoding='utf-8', errors='surrogatepass',
+                           errorlevel=1)
+            self.assertEqual(tar.getnames(), ['\ud800'])
+            with self.assertRaises(UnicodeEncodeError):
+                tar.extractall()
+            self.assertEqual(os.listdir(), [])
+
+            tar = arc.open(encoding='utf-8', errors='surrogatepass',
+                           errorlevel=0, debug=1)
+            with support.captured_stderr() as stderr:
+                tar.extractall()
+            self.assertEqual(os.listdir(), [])
+            self.assertIn('tarfile: UnicodeEncodeError ', stderr.getvalue())
+
+    def test_change_default_filter_on_instance(self):
+        tar = tarfile.TarFile(tarname, 'r')
+        def strict_filter(tarinfo, path):
+            if tarinfo.name == 'ustar/regtype':
+                return tarinfo
+            else:
+                return None
+        tar.extraction_filter = strict_filter
+        with self.check_context(tar, None):
+            self.expect_file('ustar/regtype')
+
+    def test_change_default_filter_on_class(self):
+        def strict_filter(tarinfo, path):
+            if tarinfo.name == 'ustar/regtype':
+                return tarinfo
+            else:
+                return None
+        tar = tarfile.TarFile(tarname, 'r')
+        with support.swap_attr(tarfile.TarFile, 'extraction_filter',
+                               staticmethod(strict_filter)):
+            with self.check_context(tar, None):
+                self.expect_file('ustar/regtype')
+
+    def test_change_default_filter_on_subclass(self):
+        class TarSubclass(tarfile.TarFile):
+            def extraction_filter(self, tarinfo, path):
+                if tarinfo.name == 'ustar/regtype':
+                    return tarinfo
+                else:
+                    return None
+
+        tar = TarSubclass(tarname, 'r')
+        with self.check_context(tar, None):
+            self.expect_file('ustar/regtype')
+
+    def test_change_default_filter_to_string(self):
+        tar = tarfile.TarFile(tarname, 'r')
+        tar.extraction_filter = 'data'
+        with self.check_context(tar, None):
+            self.expect_exception(TypeError)
+
+    def test_custom_filter(self):
+        def custom_filter(tarinfo, path):
+            self.assertIs(path, self.destdir)
+            if tarinfo.name == 'move_this':
+                return tarinfo.replace(name='moved')
+            if tarinfo.name == 'ignore_this':
+                return None
+            return tarinfo
+
+        with ArchiveMaker() as arc:
+            arc.add('move_this')
+            arc.add('ignore_this')
+            arc.add('keep')
+        with self.check_context(arc.open(), custom_filter):
+            self.expect_file('moved')
+            self.expect_file('keep')
+
+    def test_bad_filter_name(self):
+        with ArchiveMaker() as arc:
+            arc.add('foo')
+        with self.check_context(arc.open(), 'bad filter name'):
+            self.expect_exception(ValueError)
+
+    def test_stateful_filter(self):
+        # Stateful filters should be possible.
+        # (This doesn't really test tarfile. Rather, it demonstrates
+        # that third parties can implement a stateful filter.)
+        class StatefulFilter:
+            def __enter__(self):
+                self.num_files_processed = 0
+                return self
+
+            def __call__(self, tarinfo, path):
+                try:
+                    tarinfo = tarfile.data_filter(tarinfo, path)
+                except tarfile.FilterError:
+                    return None
+                self.num_files_processed += 1
+                return tarinfo
+
+            def __exit__(self, *exc_info):
+                self.done = True
+
+        with ArchiveMaker() as arc:
+            arc.add('good')
+            arc.add('bad', symlink_to='/')
+            arc.add('good')
+        with StatefulFilter() as custom_filter:
+            with self.check_context(arc.open(), custom_filter):
+                self.expect_file('good')
+        self.assertEqual(custom_filter.num_files_processed, 2)
+        self.assertEqual(custom_filter.done, True)
+
+    def test_errorlevel(self):
+        def extracterror_filter(tarinfo, path):
+            raise tarfile.ExtractError('failed with ExtractError')
+        def filtererror_filter(tarinfo, path):
+            raise tarfile.FilterError('failed with FilterError')
+        def oserror_filter(tarinfo, path):
+            raise OSError('failed with OSError')
+        def tarerror_filter(tarinfo, path):
+            raise tarfile.TarError('failed with base TarError')
+        def valueerror_filter(tarinfo, path):
+            raise ValueError('failed with ValueError')
+
+        with ArchiveMaker() as arc:
+            arc.add('file')
+
+        # If errorlevel is 0, errors affected by errorlevel are ignored
+
+        with self.check_context(arc.open(errorlevel=0), extracterror_filter):
+            pass
+
+        with self.check_context(arc.open(errorlevel=0), filtererror_filter):
+            pass
+
+        with self.check_context(arc.open(errorlevel=0), oserror_filter):
+            pass
+
+        with self.check_context(arc.open(errorlevel=0), tarerror_filter):
+            self.expect_exception(tarfile.TarError)
+
+        with self.check_context(arc.open(errorlevel=0), valueerror_filter):
+            self.expect_exception(ValueError)
+
+        # If 1, all fatal errors are raised
+
+        with self.check_context(arc.open(errorlevel=1), extracterror_filter):
+            pass
+
+        with self.check_context(arc.open(errorlevel=1), filtererror_filter):
+            self.expect_exception(tarfile.FilterError)
+
+        with self.check_context(arc.open(errorlevel=1), oserror_filter):
+            self.expect_exception(OSError)
+
+        with self.check_context(arc.open(errorlevel=1), tarerror_filter):
+            self.expect_exception(tarfile.TarError)
+
+        with self.check_context(arc.open(errorlevel=1), valueerror_filter):
+            self.expect_exception(ValueError)
+
+        # If 2, all non-fatal errors are raised as well.
+
+        with self.check_context(arc.open(errorlevel=2), extracterror_filter):
+            self.expect_exception(tarfile.ExtractError)
+
+        with self.check_context(arc.open(errorlevel=2), filtererror_filter):
+            self.expect_exception(tarfile.FilterError)
+
+        with self.check_context(arc.open(errorlevel=2), oserror_filter):
+            self.expect_exception(OSError)
+
+        with self.check_context(arc.open(errorlevel=2), tarerror_filter):
+            self.expect_exception(tarfile.TarError)
+
+        with self.check_context(arc.open(errorlevel=2), valueerror_filter):
+            self.expect_exception(ValueError)
+
+        # We only handle ExtractionError, FilterError & OSError specially.
+
+        with self.check_context(arc.open(errorlevel='boo!'), filtererror_filter):
+            self.expect_exception(TypeError)  # errorlevel is not int
+
+
+class OverwriteTests(archiver_tests.OverwriteTests, unittest.TestCase):
+    testdir = os.path.join(TEMPDIR, "testoverwrite")
+
+    @classmethod
+    def setUpClass(cls):
+        p = cls.ar_with_file = os.path.join(TEMPDIR, 'tar-with-file.tar')
+        cls.addClassCleanup(os_helper.unlink, p)
+        with tarfile.open(p, 'w') as tar:
+            t = tarfile.TarInfo('test')
+            t.size = 10
+            tar.addfile(t, io.BytesIO(b'newcontent'))
+
+        p = cls.ar_with_dir = os.path.join(TEMPDIR, 'tar-with-dir.tar')
+        cls.addClassCleanup(os_helper.unlink, p)
+        with tarfile.open(p, 'w') as tar:
+            tar.addfile(tar.gettarinfo(os.curdir, 'test'))
+
+        p = os.path.join(TEMPDIR, 'tar-with-implicit-dir.tar')
+        cls.ar_with_implicit_dir = p
+        cls.addClassCleanup(os_helper.unlink, p)
+        with tarfile.open(p, 'w') as tar:
+            t = tarfile.TarInfo('test/file')
+            t.size = 10
+            tar.addfile(t, io.BytesIO(b'newcontent'))
+
+    def open(self, path):
+        return tarfile.open(path, 'r')
+
+    def extractall(self, ar):
+        ar.extractall(self.testdir, filter='fully_trusted')
+
+
+class OffsetValidationTests(unittest.TestCase):
+    tarname = tmpname
+    invalid_posix_header = (
+        # name: 100 bytes
+        tarfile.NUL * tarfile.LENGTH_NAME
+        # mode, space, null terminator: 8 bytes
+        + b"000755" + SPACE + tarfile.NUL
+        # uid, space, null terminator: 8 bytes
+        + b"000001" + SPACE + tarfile.NUL
+        # gid, space, null terminator: 8 bytes
+        + b"000001" + SPACE + tarfile.NUL
+        # size, space: 12 bytes
+        + b"\xff" * 11 + SPACE
+        # mtime, space: 12 bytes
+        + tarfile.NUL * 11 + SPACE
+        # chksum: 8 bytes
+        + b"0011407" + tarfile.NUL
+        # type: 1 byte
+        + tarfile.REGTYPE
+        # linkname: 100 bytes
+        + tarfile.NUL * tarfile.LENGTH_LINK
+        # magic: 6 bytes, version: 2 bytes
+        + tarfile.POSIX_MAGIC
+        # uname: 32 bytes
+        + tarfile.NUL * 32
+        # gname: 32 bytes
+        + tarfile.NUL * 32
+        # devmajor, space, null terminator: 8 bytes
+        + tarfile.NUL * 6 + SPACE + tarfile.NUL
+        # devminor, space, null terminator: 8 bytes
+        + tarfile.NUL * 6 + SPACE + tarfile.NUL
+        # prefix: 155 bytes
+        + tarfile.NUL * tarfile.LENGTH_PREFIX
+        # padding: 12 bytes
+        + tarfile.NUL * 12
+    )
+    invalid_gnu_header = (
+        # name: 100 bytes
+        tarfile.NUL * tarfile.LENGTH_NAME
+        # mode, null terminator: 8 bytes
+        + b"0000755" + tarfile.NUL
+        # uid, null terminator: 8 bytes
+        + b"0000001" + tarfile.NUL
+        # gid, space, null terminator: 8 bytes
+        + b"0000001" + tarfile.NUL
+        # size, space: 12 bytes
+        + b"\xff" * 11 + SPACE
+        # mtime, space: 12 bytes
+        + tarfile.NUL * 11 + SPACE
+        # chksum: 8 bytes
+        + b"0011327" + tarfile.NUL
+        # type: 1 byte
+        + tarfile.REGTYPE
+        # linkname: 100 bytes
+        + tarfile.NUL * tarfile.LENGTH_LINK
+        # magic: 8 bytes
+        + tarfile.GNU_MAGIC
+        # uname: 32 bytes
+        + tarfile.NUL * 32
+        # gname: 32 bytes
+        + tarfile.NUL * 32
+        # devmajor, null terminator: 8 bytes
+        + tarfile.NUL * 8
+        # devminor, null terminator: 8 bytes
+        + tarfile.NUL * 8
+        # padding: 167 bytes
+        + tarfile.NUL * 167
+    )
+    invalid_v7_header = (
+        # name: 100 bytes
+        tarfile.NUL * tarfile.LENGTH_NAME
+        # mode, space, null terminator: 8 bytes
+        + b"000755" + SPACE + tarfile.NUL
+        # uid, space, null terminator: 8 bytes
+        + b"000001" + SPACE + tarfile.NUL
+        # gid, space, null terminator: 8 bytes
+        + b"000001" + SPACE + tarfile.NUL
+        # size, space: 12 bytes
+        + b"\xff" * 11 + SPACE
+        # mtime, space: 12 bytes
+        + tarfile.NUL * 11 + SPACE
+        # chksum: 8 bytes
+        + b"0010070" + tarfile.NUL
+        # type: 1 byte
+        + tarfile.REGTYPE
+        # linkname: 100 bytes
+        + tarfile.NUL * tarfile.LENGTH_LINK
+        # padding: 255 bytes
+        + tarfile.NUL * 255
+    )
+    valid_gnu_header = tarfile.TarInfo("filename").tobuf(tarfile.GNU_FORMAT)
+    data_block = b"\xff" * tarfile.BLOCKSIZE
+
+    def _write_buffer(self, buffer):
+        with open(self.tarname, "wb") as f:
+            f.write(buffer)
+
+    def _get_members(self, ignore_zeros=None):
+        with open(self.tarname, "rb") as f:
+            with tarfile.open(
+                mode="r", fileobj=f, ignore_zeros=ignore_zeros
+            ) as tar:
+                return tar.getmembers()
+
+    def _assert_raises_read_error_exception(self):
+        with self.assertRaisesRegex(
+            tarfile.ReadError, "file could not be opened successfully"
+        ):
+            self._get_members()
+
+    def test_invalid_offset_header_validations(self):
+        for tar_format, invalid_header in (
+            ("posix", self.invalid_posix_header),
+            ("gnu", self.invalid_gnu_header),
+            ("v7", self.invalid_v7_header),
+        ):
+            with self.subTest(format=tar_format):
+                self._write_buffer(invalid_header)
+                self._assert_raises_read_error_exception()
+
+    def test_early_stop_at_invalid_offset_header(self):
+        buffer = self.valid_gnu_header + self.invalid_gnu_header + self.valid_gnu_header
+        self._write_buffer(buffer)
+        members = self._get_members()
+        self.assertEqual(len(members), 1)
+        self.assertEqual(members[0].name, "filename")
+        self.assertEqual(members[0].offset, 0)
+
+    def test_ignore_invalid_archive(self):
+        # 3 invalid headers with their respective data
+        buffer = (self.invalid_gnu_header + self.data_block) * 3
+        self._write_buffer(buffer)
+        members = self._get_members(ignore_zeros=True)
+        self.assertEqual(len(members), 0)
+
+    def test_ignore_invalid_offset_headers(self):
+        for first_block, second_block, expected_offset in (
+            (
+                (self.valid_gnu_header),
+                (self.invalid_gnu_header + self.data_block),
+                0,
+            ),
+            (
+                (self.invalid_gnu_header + self.data_block),
+                (self.valid_gnu_header),
+                1024,
+            ),
+        ):
+            self._write_buffer(first_block + second_block)
+            members = self._get_members(ignore_zeros=True)
+            self.assertEqual(len(members), 1)
+            self.assertEqual(members[0].name, "filename")
+            self.assertEqual(members[0].offset, expected_offset)
+
+
 def setUpModule():
     os_helper.unlink(TEMPDIR)
     os.makedirs(TEMPDIR)
@@ -2889,7 +4831,7 @@ def setUpModule():
         data = fobj.read()
 
     # Create compressed tarfiles.
-    for c in GzipTest, Bz2Test, LzmaTest:
+    for c in GzipTest, Bz2Test, LzmaTest, ZstdTest:
         if c.open:
             os_helper.unlink(c.tarname)
             testtarnames.append(c.tarname)
diff --git a/Lib/test/test_tempfile.py b/Lib/test/test_tempfile.py
index d389529ca3b..f01e5dc7fb1 100644
--- a/Lib/test/test_tempfile.py
+++ b/Lib/test/test_tempfile.py
@@ -328,10 +328,6 @@ 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
@@ -520,11 +516,11 @@ def test_collision_with_existing_file(self):
              _mock_candidate_names('aaa', 'aaa', 'bbb'):
             (fd1, name1) = self.make_temp()
             os.close(fd1)
-            self.assertTrue(name1.endswith('aaa'))
+            self.assertEndsWith(name1, 'aaa')
 
             (fd2, name2) = self.make_temp()
             os.close(fd2)
-            self.assertTrue(name2.endswith('bbb'))
+            self.assertEndsWith(name2, 'bbb')
 
     def test_collision_with_existing_directory(self):
         # _mkstemp_inner tries another name when a directory with
@@ -532,11 +528,11 @@ def test_collision_with_existing_directory(self):
         with _inside_empty_temp_dir(), \
              _mock_candidate_names('aaa', 'aaa', 'bbb'):
             dir = tempfile.mkdtemp()
-            self.assertTrue(dir.endswith('aaa'))
+            self.assertEndsWith(dir, 'aaa')
 
             (fd, name) = self.make_temp()
             os.close(fd)
-            self.assertTrue(name.endswith('bbb'))
+            self.assertEndsWith(name, 'bbb')
 
 
 class TestGetTempPrefix(BaseTestCase):
@@ -832,9 +828,9 @@ def test_collision_with_existing_file(self):
              _mock_candidate_names('aaa', 'aaa', 'bbb'):
             file = tempfile.NamedTemporaryFile(delete=False)
             file.close()
-            self.assertTrue(file.name.endswith('aaa'))
+            self.assertEndsWith(file.name, 'aaa')
             dir = tempfile.mkdtemp()
-            self.assertTrue(dir.endswith('bbb'))
+            self.assertEndsWith(dir, 'bbb')
 
     def test_collision_with_existing_directory(self):
         # mkdtemp tries another name when a directory with
@@ -842,9 +838,9 @@ def test_collision_with_existing_directory(self):
         with _inside_empty_temp_dir(), \
              _mock_candidate_names('aaa', 'aaa', 'bbb'):
             dir1 = tempfile.mkdtemp()
-            self.assertTrue(dir1.endswith('aaa'))
+            self.assertEndsWith(dir1, 'aaa')
             dir2 = tempfile.mkdtemp()
-            self.assertTrue(dir2.endswith('bbb'))
+            self.assertEndsWith(dir2, 'bbb')
 
     def test_for_tempdir_is_bytes_issue40701_api_warts(self):
         orig_tempdir = tempfile.tempdir
@@ -1116,11 +1112,14 @@ def my_func(dir):
             # 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)
+            with self.assertWarnsRegex(
+                expected_warning=ResourceWarning,
+                expected_regex=r"Implicitly cleaning up <_TemporaryFileWrapper file=.*>",
+            ):
+                tmp_name = my_func(dir)
+                support.gc_collect()
             self.assertFalse(os.path.exists(tmp_name),
                         f"NamedTemporaryFile {tmp_name!r} "
                         f"exists after finalizer ")
@@ -1240,9 +1239,6 @@ def test_del_unrolled_file(self):
         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
@@ -1496,9 +1492,6 @@ 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)
@@ -1734,8 +1727,8 @@ def test_cleanup_with_symlink_to_a_directory(self):
                          "were deleted")
         d2.cleanup()
 
+    @unittest.skip("TODO: RUSTPYTHON; No such file or directory \"...\"")
     @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:
diff --git a/Lib/test/test_termios.py b/Lib/test/test_termios.py
new file mode 100644
index 00000000000..e7ebb20b120
--- /dev/null
+++ b/Lib/test/test_termios.py
@@ -0,0 +1,313 @@
+import errno
+import os
+import sys
+import tempfile
+import threading
+import unittest
+from test import support
+from test.support import threading_helper
+from test.support.import_helper import import_module
+
+termios = import_module('termios')
+
+
+@unittest.skipUnless(hasattr(os, 'openpty'), "need os.openpty()")
+class TestFunctions(unittest.TestCase):
+
+    def setUp(self):
+        self.master_fd, self.fd = os.openpty()
+        self.addCleanup(os.close, self.master_fd)
+        self.stream = self.enterContext(open(self.fd, 'wb', buffering=0))
+        tmp = self.enterContext(tempfile.TemporaryFile(mode='wb', buffering=0))
+        self.bad_fd = tmp.fileno()
+
+    def assertRaisesTermiosError(self, err, callable, *args):
+        # Some versions of Android return EACCES when calling termios functions
+        # on a regular file.
+        errs = [err]
+        if sys.platform == 'android' and err == errno.ENOTTY:
+            errs.append(errno.EACCES)
+
+        with self.assertRaises(termios.error) as cm:
+            callable(*args)
+        self.assertIn(cm.exception.args[0], errs)
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; TypeError: Expected type 'int' but 'FileIO' found.
+    def test_tcgetattr(self):
+        attrs = termios.tcgetattr(self.fd)
+        self.assertIsInstance(attrs, list)
+        self.assertEqual(len(attrs), 7)
+        for i in range(6):
+            self.assertIsInstance(attrs[i], int)
+        iflag, oflag, cflag, lflag, ispeed, ospeed, cc = attrs
+        self.assertIsInstance(cc, list)
+        self.assertEqual(len(cc), termios.NCCS)
+        for i, x in enumerate(cc):
+            if ((lflag & termios.ICANON) == 0 and
+                (i == termios.VMIN or i == termios.VTIME)):
+                self.assertIsInstance(x, int)
+            else:
+                self.assertIsInstance(x, bytes)
+                self.assertEqual(len(x), 1)
+        self.assertEqual(termios.tcgetattr(self.stream), attrs)
+
+    @unittest.skip("TODO: RUSTPYTHON segfault")
+    def test_tcgetattr_errors(self):
+        self.assertRaisesTermiosError(errno.ENOTTY, termios.tcgetattr, self.bad_fd)
+        self.assertRaises(ValueError, termios.tcgetattr, -1)
+        self.assertRaises(OverflowError, termios.tcgetattr, 2**1000)
+        self.assertRaises(TypeError, termios.tcgetattr, object())
+        self.assertRaises(TypeError, termios.tcgetattr)
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; TypeError: Expected type 'int' but 'FileIO' found.
+    def test_tcsetattr(self):
+        attrs = termios.tcgetattr(self.fd)
+        termios.tcsetattr(self.fd, termios.TCSANOW, attrs)
+        termios.tcsetattr(self.fd, termios.TCSADRAIN, attrs)
+        termios.tcsetattr(self.fd, termios.TCSAFLUSH, attrs)
+        termios.tcsetattr(self.stream, termios.TCSANOW, attrs)
+
+    @unittest.skip("TODO: RUSTPYTHON segfault")
+    def test_tcsetattr_errors(self):
+        attrs = termios.tcgetattr(self.fd)
+        self.assertRaises(TypeError, termios.tcsetattr, self.fd, termios.TCSANOW, tuple(attrs))
+        self.assertRaises(TypeError, termios.tcsetattr, self.fd, termios.TCSANOW, attrs[:-1])
+        self.assertRaises(TypeError, termios.tcsetattr, self.fd, termios.TCSANOW, attrs + [0])
+        for i in range(6):
+            attrs2 = attrs[:]
+            attrs2[i] = 2**1000
+            self.assertRaises(OverflowError, termios.tcsetattr, self.fd, termios.TCSANOW, attrs2)
+            attrs2[i] = object()
+            self.assertRaises(TypeError, termios.tcsetattr, self.fd, termios.TCSANOW, attrs2)
+        self.assertRaises(TypeError, termios.tcsetattr, self.fd, termios.TCSANOW, attrs[:-1] + [attrs[-1][:-1]])
+        self.assertRaises(TypeError, termios.tcsetattr, self.fd, termios.TCSANOW, attrs[:-1] + [attrs[-1] + [b'\0']])
+        for i in range(len(attrs[-1])):
+            attrs2 = attrs[:]
+            attrs2[-1] = attrs2[-1][:]
+            attrs2[-1][i] = 2**1000
+            self.assertRaises(OverflowError, termios.tcsetattr, self.fd, termios.TCSANOW, attrs2)
+            attrs2[-1][i] = object()
+            self.assertRaises(TypeError, termios.tcsetattr, self.fd, termios.TCSANOW, attrs2)
+            attrs2[-1][i] = b''
+            self.assertRaises(TypeError, termios.tcsetattr, self.fd, termios.TCSANOW, attrs2)
+            attrs2[-1][i] = b'\0\0'
+            self.assertRaises(TypeError, termios.tcsetattr, self.fd, termios.TCSANOW, attrs2)
+        self.assertRaises(TypeError, termios.tcsetattr, self.fd, termios.TCSANOW, object())
+        self.assertRaises(TypeError, termios.tcsetattr, self.fd, termios.TCSANOW)
+        self.assertRaisesTermiosError(errno.EINVAL, termios.tcsetattr, self.fd, -1, attrs)
+        self.assertRaises(OverflowError, termios.tcsetattr, self.fd, 2**1000, attrs)
+        self.assertRaises(TypeError, termios.tcsetattr, self.fd, object(), attrs)
+        self.assertRaisesTermiosError(errno.ENOTTY, termios.tcsetattr, self.bad_fd, termios.TCSANOW, attrs)
+        self.assertRaises(ValueError, termios.tcsetattr, -1, termios.TCSANOW, attrs)
+        self.assertRaises(OverflowError, termios.tcsetattr, 2**1000, termios.TCSANOW, attrs)
+        self.assertRaises(TypeError, termios.tcsetattr, object(), termios.TCSANOW, attrs)
+        self.assertRaises(TypeError, termios.tcsetattr, self.fd, termios.TCSANOW)
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; TypeError: Expected type 'int' but 'FileIO' found.
+    @support.skip_android_selinux('tcsendbreak')
+    def test_tcsendbreak(self):
+        try:
+            termios.tcsendbreak(self.fd, 1)
+        except termios.error as exc:
+            if exc.args[0] == errno.ENOTTY and sys.platform.startswith(('freebsd', "netbsd")):
+                self.skipTest('termios.tcsendbreak() is not supported '
+                              'with pseudo-terminals (?) on this platform')
+            raise
+        termios.tcsendbreak(self.stream, 1)
+
+    @unittest.skip("TODO: RUSTPYTHON segfault")
+    @support.skip_android_selinux('tcsendbreak')
+    def test_tcsendbreak_errors(self):
+        self.assertRaises(OverflowError, termios.tcsendbreak, self.fd, 2**1000)
+        self.assertRaises(TypeError, termios.tcsendbreak, self.fd, 0.0)
+        self.assertRaises(TypeError, termios.tcsendbreak, self.fd, object())
+        self.assertRaisesTermiosError(errno.ENOTTY, termios.tcsendbreak, self.bad_fd, 0)
+        self.assertRaises(ValueError, termios.tcsendbreak, -1, 0)
+        self.assertRaises(OverflowError, termios.tcsendbreak, 2**1000, 0)
+        self.assertRaises(TypeError, termios.tcsendbreak, object(), 0)
+        self.assertRaises(TypeError, termios.tcsendbreak, self.fd)
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; TypeError: Expected type 'int' but 'FileIO' found.
+    @support.skip_android_selinux('tcdrain')
+    def test_tcdrain(self):
+        termios.tcdrain(self.fd)
+        termios.tcdrain(self.stream)
+
+    @unittest.skip("TODO: RUSTPYTHON segfault")
+    @support.skip_android_selinux('tcdrain')
+    def test_tcdrain_errors(self):
+        self.assertRaisesTermiosError(errno.ENOTTY, termios.tcdrain, self.bad_fd)
+        self.assertRaises(ValueError, termios.tcdrain, -1)
+        self.assertRaises(OverflowError, termios.tcdrain, 2**1000)
+        self.assertRaises(TypeError, termios.tcdrain, object())
+        self.assertRaises(TypeError, termios.tcdrain)
+
+    def test_tcflush(self):
+        termios.tcflush(self.fd, termios.TCIFLUSH)
+        termios.tcflush(self.fd, termios.TCOFLUSH)
+        termios.tcflush(self.fd, termios.TCIOFLUSH)
+
+    @unittest.skip("TODO: RUSTPYTHON segfault")
+    def test_tcflush_errors(self):
+        self.assertRaisesTermiosError(errno.EINVAL, termios.tcflush, self.fd, -1)
+        self.assertRaises(OverflowError, termios.tcflush, self.fd, 2**1000)
+        self.assertRaises(TypeError, termios.tcflush, self.fd, object())
+        self.assertRaisesTermiosError(errno.ENOTTY, termios.tcflush, self.bad_fd, termios.TCIFLUSH)
+        self.assertRaises(ValueError, termios.tcflush, -1, termios.TCIFLUSH)
+        self.assertRaises(OverflowError, termios.tcflush, 2**1000, termios.TCIFLUSH)
+        self.assertRaises(TypeError, termios.tcflush, object(), termios.TCIFLUSH)
+        self.assertRaises(TypeError, termios.tcflush, self.fd)
+
+    def test_tcflush_clear_input_or_output(self):
+        wfd = self.fd
+        rfd = self.master_fd
+        # The data is buffered in the input buffer on Linux, and in
+        # the output buffer on other platforms.
+        inbuf = sys.platform in ('linux', 'android')
+
+        os.write(wfd, b'abcdef')
+        self.assertEqual(os.read(rfd, 2), b'ab')
+        if inbuf:
+            # don't flush input
+            termios.tcflush(rfd, termios.TCOFLUSH)
+        else:
+            # don't flush output
+            termios.tcflush(wfd, termios.TCIFLUSH)
+        self.assertEqual(os.read(rfd, 2), b'cd')
+        if inbuf:
+            # flush input
+            termios.tcflush(rfd, termios.TCIFLUSH)
+        else:
+            # flush output
+            termios.tcflush(wfd, termios.TCOFLUSH)
+        os.write(wfd, b'ABCDEF')
+        self.assertEqual(os.read(rfd, 1024), b'ABCDEF')
+
+    @support.skip_android_selinux('tcflow')
+    def test_tcflow(self):
+        termios.tcflow(self.fd, termios.TCOOFF)
+        termios.tcflow(self.fd, termios.TCOON)
+        termios.tcflow(self.fd, termios.TCIOFF)
+        termios.tcflow(self.fd, termios.TCION)
+
+    @unittest.skip("TODO: RUSTPYTHON segfault")
+    @support.skip_android_selinux('tcflow')
+    def test_tcflow_errors(self):
+        self.assertRaisesTermiosError(errno.EINVAL, termios.tcflow, self.fd, -1)
+        self.assertRaises(OverflowError, termios.tcflow, self.fd, 2**1000)
+        self.assertRaises(TypeError, termios.tcflow, self.fd, object())
+        self.assertRaisesTermiosError(errno.ENOTTY, termios.tcflow, self.bad_fd, termios.TCOON)
+        self.assertRaises(ValueError, termios.tcflow, -1, termios.TCOON)
+        self.assertRaises(OverflowError, termios.tcflow, 2**1000, termios.TCOON)
+        self.assertRaises(TypeError, termios.tcflow, object(), termios.TCOON)
+        self.assertRaises(TypeError, termios.tcflow, self.fd)
+
+    @support.skip_android_selinux('tcflow')
+    @unittest.skipUnless(sys.platform in ('linux', 'android'), 'only works on Linux')
+    def test_tcflow_suspend_and_resume_output(self):
+        wfd = self.fd
+        rfd = self.master_fd
+        write_suspended = threading.Event()
+        write_finished = threading.Event()
+
+        def writer():
+            os.write(wfd, b'abc')
+            self.assertTrue(write_suspended.wait(support.SHORT_TIMEOUT))
+            os.write(wfd, b'def')
+            write_finished.set()
+
+        with threading_helper.start_threads([threading.Thread(target=writer)]):
+            self.assertEqual(os.read(rfd, 3), b'abc')
+            try:
+                try:
+                    termios.tcflow(wfd, termios.TCOOFF)
+                finally:
+                    write_suspended.set()
+                self.assertFalse(write_finished.wait(0.5),
+                                 'output was not suspended')
+            finally:
+                termios.tcflow(wfd, termios.TCOON)
+            self.assertTrue(write_finished.wait(support.SHORT_TIMEOUT),
+                            'output was not resumed')
+            self.assertEqual(os.read(rfd, 1024), b'def')
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AttributeError: module 'termios' has no attribute 'tcgetwinsize'
+    def test_tcgetwinsize(self):
+        size = termios.tcgetwinsize(self.fd)
+        self.assertIsInstance(size, tuple)
+        self.assertEqual(len(size), 2)
+        self.assertIsInstance(size[0], int)
+        self.assertIsInstance(size[1], int)
+        self.assertEqual(termios.tcgetwinsize(self.stream), size)
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AttributeError: module 'termios' has no attribute 'tcgetwinsize'
+    def test_tcgetwinsize_errors(self):
+        self.assertRaisesTermiosError(errno.ENOTTY, termios.tcgetwinsize, self.bad_fd)
+        self.assertRaises(ValueError, termios.tcgetwinsize, -1)
+        self.assertRaises(OverflowError, termios.tcgetwinsize, 2**1000)
+        self.assertRaises(TypeError, termios.tcgetwinsize, object())
+        self.assertRaises(TypeError, termios.tcgetwinsize)
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AttributeError: module 'termios' has no attribute 'tcgetwinsize'
+    def test_tcsetwinsize(self):
+        size = termios.tcgetwinsize(self.fd)
+        termios.tcsetwinsize(self.fd, size)
+        termios.tcsetwinsize(self.fd, list(size))
+        termios.tcsetwinsize(self.stream, size)
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AttributeError: module 'termios' has no attribute 'tcgetwinsize'
+    def test_tcsetwinsize_errors(self):
+        size = termios.tcgetwinsize(self.fd)
+        self.assertRaises(TypeError, termios.tcsetwinsize, self.fd, size[:-1])
+        self.assertRaises(TypeError, termios.tcsetwinsize, self.fd, size + (0,))
+        self.assertRaises(TypeError, termios.tcsetwinsize, self.fd, object())
+        self.assertRaises(OverflowError, termios.tcsetwinsize, self.fd, (size[0], 2**1000))
+        self.assertRaises(TypeError, termios.tcsetwinsize, self.fd, (size[0], float(size[1])))
+        self.assertRaises(TypeError, termios.tcsetwinsize, self.fd, (size[0], object()))
+        self.assertRaises(OverflowError, termios.tcsetwinsize, self.fd, (2**1000, size[1]))
+        self.assertRaises(TypeError, termios.tcsetwinsize, self.fd, (float(size[0]), size[1]))
+        self.assertRaises(TypeError, termios.tcsetwinsize, self.fd, (object(), size[1]))
+        self.assertRaisesTermiosError(errno.ENOTTY, termios.tcsetwinsize, self.bad_fd, size)
+        self.assertRaises(ValueError, termios.tcsetwinsize, -1, size)
+        self.assertRaises(OverflowError, termios.tcsetwinsize, 2**1000, size)
+        self.assertRaises(TypeError, termios.tcsetwinsize, object(), size)
+        self.assertRaises(TypeError, termios.tcsetwinsize, self.fd)
+
+
+class TestModule(unittest.TestCase):
+    def test_constants(self):
+        self.assertIsInstance(termios.B0, int)
+        self.assertIsInstance(termios.B38400, int)
+        self.assertIsInstance(termios.TCSANOW, int)
+        self.assertIsInstance(termios.TCSADRAIN, int)
+        self.assertIsInstance(termios.TCSAFLUSH, int)
+        self.assertIsInstance(termios.TCIFLUSH, int)
+        self.assertIsInstance(termios.TCOFLUSH, int)
+        self.assertIsInstance(termios.TCIOFLUSH, int)
+        self.assertIsInstance(termios.TCOOFF, int)
+        self.assertIsInstance(termios.TCOON, int)
+        self.assertIsInstance(termios.TCIOFF, int)
+        self.assertIsInstance(termios.TCION, int)
+        self.assertIsInstance(termios.VTIME, int)
+        self.assertIsInstance(termios.VMIN, int)
+        self.assertIsInstance(termios.NCCS, int)
+        self.assertLess(termios.VTIME, termios.NCCS)
+        self.assertLess(termios.VMIN, termios.NCCS)
+
+    def test_ioctl_constants(self):
+        # gh-119770: ioctl() constants must be positive
+        for name in dir(termios):
+            if not name.startswith('TIO'):
+                continue
+            value = getattr(termios, name)
+            with self.subTest(name=name):
+                self.assertGreaterEqual(value, 0)
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AssertionError: <class 'termios.error'> is a subclass of <class 'OSError'>
+    def test_exception(self):
+        self.assertIsSubclass(termios.error, Exception)
+        self.assertNotIsSubclass(termios.error, OSError)
+
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/Lib/test/test_textwrap.py b/Lib/test/test_textwrap.py
index dfbc2b93dfc..aca1f427656 100644
--- a/Lib/test/test_textwrap.py
+++ b/Lib/test/test_textwrap.py
@@ -605,7 +605,7 @@ def test_break_long(self):
         # bug 1146.  Prevent a long word to be wrongly wrapped when the
         # preceding word is exactly one character shorter than the width
         self.check_wrap(self.text, 12,
-                        ['Did you say ',
+                        ['Did you say',
                          '"supercalifr',
                          'agilisticexp',
                          'ialidocious?',
@@ -633,7 +633,7 @@ def test_nobreak_long(self):
 
     def test_max_lines_long(self):
         self.check_wrap(self.text, 12,
-                        ['Did you say ',
+                        ['Did you say',
                          '"supercalifr',
                          'agilisticexp',
                          '[...]'],
@@ -765,10 +765,67 @@ def test_subsequent_indent(self):
 # of IndentTestCase!
 class DedentTestCase(unittest.TestCase):
 
+    def test_type_error(self):
+        with self.assertRaisesRegex(TypeError, "expected str object, not"):
+            dedent(0)
+
+        with self.assertRaisesRegex(TypeError, "expected str object, not"):
+            dedent(b'')
+
     def assertUnchanged(self, text):
         """assert that dedent() has no effect on 'text'"""
         self.assertEqual(text, dedent(text))
 
+    def test_dedent_whitespace(self):
+        # The empty string.
+        text = ""
+        self.assertUnchanged(text)
+
+        # Only spaces.
+        text = "    "
+        expect = ""
+        self.assertEqual(expect, dedent(text))
+
+        # Only tabs.
+        text = "\t\t\t\t"
+        expect = ""
+        self.assertEqual(expect, dedent(text))
+
+        # A mixture.
+        text = " \t  \t\t  \t "
+        expect = ""
+        self.assertEqual(expect, dedent(text))
+
+        # ASCII whitespace.
+        text = "\f\n\r\t\v "
+        expect = "\n"
+        self.assertEqual(expect, dedent(text))
+
+        # One newline.
+        text = "\n"
+        expect = "\n"
+        self.assertEqual(expect, dedent(text))
+
+        # Windows-style newlines.
+        text = "\r\n" * 5
+        expect = "\n" * 5
+        self.assertEqual(expect, dedent(text))
+
+        # Whitespace mixture.
+        text = "    \n\t\n  \n\t\t\n\n\n       "
+        expect = "\n\n\n\n\n\n"
+        self.assertEqual(expect, dedent(text))
+
+        # Lines consisting only of whitespace are always normalised
+        text = "a\n \n\t\n"
+        expect = "a\n\n\n"
+        self.assertEqual(expect, dedent(text))
+
+        # Whitespace characters on non-empty lines are retained
+        text = "a\r\n\r\n\r\n"
+        expect = "a\r\n\n\n"
+        self.assertEqual(expect, dedent(text))
+
     def test_dedent_nomargin(self):
         # No lines indented.
         text = "Hello there.\nHow are you?\nOh good, I'm glad."
diff --git a/Lib/test/test_threading.py b/Lib/test/test_threading.py
index e635a6f9734..17693ae093f 100644
--- a/Lib/test/test_threading.py
+++ b/Lib/test/test_threading.py
@@ -492,7 +492,6 @@ def func(frame, event, arg):
             sys.settrace(func)
             """)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_join_nondaemon_on_shutdown(self):
         # Issue 1722344
         # Raising SystemExit skipped threading._shutdown
@@ -746,6 +745,7 @@ def test_main_thread_after_fork(self):
                          "main ident True\n"
                          "current is main True\n")
 
+    @unittest.skip("TODO: RUSTPYTHON flaky; process timeout after fork")
     @skip_unless_reliable_fork
     @unittest.skipUnless(hasattr(os, 'waitpid'), "test needs os.waitpid()")
     def test_main_thread_after_fork_from_nonmain_thread(self):
@@ -854,7 +854,6 @@ def func(lock):
     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
@@ -1086,7 +1085,6 @@ def checker():
         self.assertEqual(threading.getprofile(), old_profile)
         self.assertEqual(sys.getprofile(), old_profile)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_locals_at_exit(self):
         # bpo-19466: thread locals must not be deleted before destructors
         # are called
@@ -1164,8 +1162,6 @@ 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
@@ -2143,10 +2139,6 @@ def __init__(self, a, *, b) -> None:
             CustomRLock(1, b=2)
         self.assertEqual(warnings_log, [])
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
-    def test_release_save_unacquired(self):
-        return super().test_release_save_unacquired()
-
     @unittest.skip('TODO: RUSTPYTHON; flaky test')
     def test_different_thread(self):
         return super().test_different_thread()
diff --git a/Lib/test/test_threadsignals.py b/Lib/test/test_threadsignals.py
new file mode 100644
index 00000000000..bf241ada90e
--- /dev/null
+++ b/Lib/test/test_threadsignals.py
@@ -0,0 +1,237 @@
+"""PyUnit testing that threads honor our signal semantics"""
+
+import unittest
+import signal
+import os
+import sys
+from test.support import threading_helper
+import _thread as thread
+import time
+
+if (sys.platform[:3] == 'win'):
+    raise unittest.SkipTest("Can't test signal on %s" % sys.platform)
+
+process_pid = os.getpid()
+signalled_all=thread.allocate_lock()
+
+USING_PTHREAD_COND = (sys.thread_info.name == 'pthread'
+                      and sys.thread_info.lock == 'mutex+cond')
+
+def registerSignals(for_usr1, for_usr2, for_alrm):
+    usr1 = signal.signal(signal.SIGUSR1, for_usr1)
+    usr2 = signal.signal(signal.SIGUSR2, for_usr2)
+    alrm = signal.signal(signal.SIGALRM, for_alrm)
+    return usr1, usr2, alrm
+
+
+# The signal handler. Just note that the signal occurred and
+# from who.
+def handle_signals(sig,frame):
+    signal_blackboard[sig]['tripped'] += 1
+    signal_blackboard[sig]['tripped_by'] = thread.get_ident()
+
+# a function that will be spawned as a separate thread.
+def send_signals():
+    # We use `raise_signal` rather than `kill` because:
+    #   * It verifies that a signal delivered to a background thread still has
+    #     its Python-level handler called on the main thread.
+    #   * It ensures the signal is handled before the thread exits.
+    signal.raise_signal(signal.SIGUSR1)
+    signal.raise_signal(signal.SIGUSR2)
+    signalled_all.release()
+
+
+@threading_helper.requires_working_threading()
+class ThreadSignals(unittest.TestCase):
+
+    def test_signals(self):
+        with threading_helper.wait_threads_exit():
+            # Test signal handling semantics of threads.
+            # We spawn a thread, have the thread send itself two signals, and
+            # wait for it to finish. Check that we got both signals
+            # and that they were run by the main thread.
+            signalled_all.acquire()
+            self.spawnSignallingThread()
+            signalled_all.acquire()
+
+        self.assertEqual( signal_blackboard[signal.SIGUSR1]['tripped'], 1)
+        self.assertEqual( signal_blackboard[signal.SIGUSR1]['tripped_by'],
+                           thread.get_ident())
+        self.assertEqual( signal_blackboard[signal.SIGUSR2]['tripped'], 1)
+        self.assertEqual( signal_blackboard[signal.SIGUSR2]['tripped_by'],
+                           thread.get_ident())
+        signalled_all.release()
+
+    def spawnSignallingThread(self):
+        thread.start_new_thread(send_signals, ())
+
+    def alarm_interrupt(self, sig, frame):
+        raise KeyboardInterrupt
+
+    @unittest.skipIf(USING_PTHREAD_COND,
+                     'POSIX condition variables cannot be interrupted')
+    @unittest.skipIf(sys.platform.startswith('linux') and
+                     not sys.thread_info.version,
+                     'Issue 34004: musl does not allow interruption of locks '
+                     'by signals.')
+    # Issue #20564: sem_timedwait() cannot be interrupted on OpenBSD
+    @unittest.skipIf(sys.platform.startswith('openbsd'),
+                     'lock cannot be interrupted on OpenBSD')
+    def test_lock_acquire_interruption(self):
+        # Mimic receiving a SIGINT (KeyboardInterrupt) with SIGALRM while stuck
+        # in a deadlock.
+        # XXX this test can fail when the legacy (non-semaphore) implementation
+        # of locks is used in thread_pthread.h, see issue #11223.
+        oldalrm = signal.signal(signal.SIGALRM, self.alarm_interrupt)
+        try:
+            lock = thread.allocate_lock()
+            lock.acquire()
+            signal.alarm(1)
+            t1 = time.monotonic()
+            self.assertRaises(KeyboardInterrupt, lock.acquire, timeout=5)
+            dt = time.monotonic() - t1
+            # Checking that KeyboardInterrupt was raised is not sufficient.
+            # We want to assert that lock.acquire() was interrupted because
+            # of the signal, not that the signal handler was called immediately
+            # after timeout return of lock.acquire() (which can fool assertRaises).
+            self.assertLess(dt, 3.0)
+        finally:
+            signal.alarm(0)
+            signal.signal(signal.SIGALRM, oldalrm)
+
+    @unittest.skipIf(USING_PTHREAD_COND,
+                     'POSIX condition variables cannot be interrupted')
+    @unittest.skipIf(sys.platform.startswith('linux') and
+                     not sys.thread_info.version,
+                     'Issue 34004: musl does not allow interruption of locks '
+                     'by signals.')
+    # Issue #20564: sem_timedwait() cannot be interrupted on OpenBSD
+    @unittest.skipIf(sys.platform.startswith('openbsd'),
+                     'lock cannot be interrupted on OpenBSD')
+    def test_rlock_acquire_interruption(self):
+        # Mimic receiving a SIGINT (KeyboardInterrupt) with SIGALRM while stuck
+        # in a deadlock.
+        # XXX this test can fail when the legacy (non-semaphore) implementation
+        # of locks is used in thread_pthread.h, see issue #11223.
+        oldalrm = signal.signal(signal.SIGALRM, self.alarm_interrupt)
+        try:
+            rlock = thread.RLock()
+            # For reentrant locks, the initial acquisition must be in another
+            # thread.
+            def other_thread():
+                rlock.acquire()
+
+            with threading_helper.wait_threads_exit():
+                thread.start_new_thread(other_thread, ())
+                # Wait until we can't acquire it without blocking...
+                while rlock.acquire(blocking=False):
+                    rlock.release()
+                    time.sleep(0.01)
+                signal.alarm(1)
+                t1 = time.monotonic()
+                self.assertRaises(KeyboardInterrupt, rlock.acquire, timeout=5)
+                dt = time.monotonic() - t1
+                # See rationale above in test_lock_acquire_interruption
+                self.assertLess(dt, 3.0)
+        finally:
+            signal.alarm(0)
+            signal.signal(signal.SIGALRM, oldalrm)
+
+    def acquire_retries_on_intr(self, lock):
+        self.sig_recvd = False
+        def my_handler(signal, frame):
+            self.sig_recvd = True
+
+        old_handler = signal.signal(signal.SIGUSR1, my_handler)
+        try:
+            def other_thread():
+                # Acquire the lock in a non-main thread, so this test works for
+                # RLocks.
+                lock.acquire()
+                # Wait until the main thread is blocked in the lock acquire, and
+                # then wake it up with this.
+                time.sleep(0.5)
+                os.kill(process_pid, signal.SIGUSR1)
+                # Let the main thread take the interrupt, handle it, and retry
+                # the lock acquisition.  Then we'll let it run.
+                time.sleep(0.5)
+                lock.release()
+
+            with threading_helper.wait_threads_exit():
+                thread.start_new_thread(other_thread, ())
+                # Wait until we can't acquire it without blocking...
+                while lock.acquire(blocking=False):
+                    lock.release()
+                    time.sleep(0.01)
+                result = lock.acquire()  # Block while we receive a signal.
+                self.assertTrue(self.sig_recvd)
+                self.assertTrue(result)
+        finally:
+            signal.signal(signal.SIGUSR1, old_handler)
+
+    def test_lock_acquire_retries_on_intr(self):
+        self.acquire_retries_on_intr(thread.allocate_lock())
+
+    def test_rlock_acquire_retries_on_intr(self):
+        self.acquire_retries_on_intr(thread.RLock())
+
+    def test_interrupted_timed_acquire(self):
+        # Test to make sure we recompute lock acquisition timeouts when we
+        # receive a signal.  Check this by repeatedly interrupting a lock
+        # acquire in the main thread, and make sure that the lock acquire times
+        # out after the right amount of time.
+        # NOTE: this test only behaves as expected if C signals get delivered
+        # to the main thread.  Otherwise lock.acquire() itself doesn't get
+        # interrupted and the test trivially succeeds.
+        self.start = None
+        self.end = None
+        self.sigs_recvd = 0
+        done = thread.allocate_lock()
+        done.acquire()
+        lock = thread.allocate_lock()
+        lock.acquire()
+        def my_handler(signum, frame):
+            self.sigs_recvd += 1
+        old_handler = signal.signal(signal.SIGUSR1, my_handler)
+        try:
+            def timed_acquire():
+                self.start = time.monotonic()
+                lock.acquire(timeout=0.5)
+                self.end = time.monotonic()
+            def send_signals():
+                for _ in range(40):
+                    time.sleep(0.02)
+                    os.kill(process_pid, signal.SIGUSR1)
+                done.release()
+
+            with threading_helper.wait_threads_exit():
+                # Send the signals from the non-main thread, since the main thread
+                # is the only one that can process signals.
+                thread.start_new_thread(send_signals, ())
+                timed_acquire()
+                # Wait for thread to finish
+                done.acquire()
+                # This allows for some timing and scheduling imprecision
+                self.assertLess(self.end - self.start, 2.0)
+                self.assertGreater(self.end - self.start, 0.3)
+                # If the signal is received several times before PyErr_CheckSignals()
+                # is called, the handler will get called less than 40 times. Just
+                # check it's been called at least once.
+                self.assertGreater(self.sigs_recvd, 0)
+        finally:
+            signal.signal(signal.SIGUSR1, old_handler)
+
+
+def setUpModule():
+    global signal_blackboard
+
+    signal_blackboard = { signal.SIGUSR1 : {'tripped': 0, 'tripped_by': 0 },
+                          signal.SIGUSR2 : {'tripped': 0, 'tripped_by': 0 },
+                          signal.SIGALRM : {'tripped': 0, 'tripped_by': 0 } }
+
+    oldsigs = registerSignals(handle_signals, handle_signals, handle_signals)
+    unittest.addModuleCleanup(registerSignals, *oldsigs)
+
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/Lib/test/test_time.py b/Lib/test/test_time.py
index 35055e03b8e..f66a37edb4c 100644
--- a/Lib/test/test_time.py
+++ b/Lib/test/test_time.py
@@ -2,7 +2,6 @@
 from test.support import warnings_helper
 import decimal
 import enum
-import locale
 import math
 import platform
 import sys
@@ -14,8 +13,12 @@
     import _testcapi
 except ImportError:
     _testcapi = None
+try:
+    import _testinternalcapi
+except ImportError:
+    _testinternalcapi = None
 
-from test.support import skip_if_buggy_ucrt_strfptime
+from test.support import skip_if_buggy_ucrt_strfptime, SuppressCrashReport
 
 # Max year is only limited by the size of C int.
 SIZEOF_INT = sysconfig.get_config_var('SIZEOF_INT') or 4
@@ -38,6 +41,10 @@ class _PyTime(enum.IntEnum):
     # Round away from zero
     ROUND_UP = 3
 
+# _PyTime_t is int64_t
+PyTime_MIN = -2 ** 63
+PyTime_MAX = 2 ** 63 - 1
+
 # Rounding modes supported by PyTime
 ROUNDING_MODES = (
     # (PyTime rounding method, decimal rounding method)
@@ -109,6 +116,7 @@ def test_clock_monotonic(self):
                          'need time.pthread_getcpuclockid()')
     @unittest.skipUnless(hasattr(time, 'clock_gettime'),
                          'need time.clock_gettime()')
+    @unittest.skipIf(support.is_emscripten, "Fails to find clock")
     def test_pthread_getcpuclockid(self):
         clk_id = time.pthread_getcpuclockid(threading.get_ident())
         self.assertTrue(type(clk_id) is int)
@@ -150,13 +158,32 @@ def test_conversions(self):
         self.assertEqual(int(time.mktime(time.localtime(self.t))),
                          int(self.t))
 
-    def test_sleep(self):
+    def test_sleep_exceptions(self):
+        self.assertRaises(TypeError, time.sleep, [])
+        self.assertRaises(TypeError, time.sleep, "a")
+        self.assertRaises(TypeError, time.sleep, complex(0, 0))
+
         self.assertRaises(ValueError, time.sleep, -2)
         self.assertRaises(ValueError, time.sleep, -1)
-        time.sleep(1.2)
+        self.assertRaises(ValueError, time.sleep, -0.1)
+
+        # Improved exception #81267
+        with self.assertRaises(TypeError) as errmsg:
+            time.sleep([])
+        self.assertIn("integer or float", str(errmsg.exception))
+
+    def test_sleep(self):
+        for value in [-0.0, 0, 0.0, 1e-100, 1e-9, 1e-6, 1, 1.2]:
+            with self.subTest(value=value):
+                time.sleep(value)
+
+    def test_epoch(self):
+        # bpo-43869: Make sure that Python use the same Epoch on all platforms:
+        # January 1, 1970, 00:00:00 (UTC).
+        epoch = time.gmtime(0)
+        # Only test the date and time, ignore other gmtime() members
+        self.assertEqual(tuple(epoch)[:6], (1970, 1, 1, 0, 0, 0), epoch)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_strftime(self):
         tt = time.gmtime(self.t)
         for directive in ('a', 'A', 'b', 'B', 'c', 'd', 'H', 'I',
@@ -169,8 +196,44 @@ def test_strftime(self):
                 self.fail('conversion specifier: %r failed.' % format)
 
         self.assertRaises(TypeError, time.strftime, b'%S', tt)
-        # embedded null character
-        self.assertRaises(ValueError, time.strftime, '%S\0', tt)
+
+    def test_strftime_invalid_format(self):
+        tt = time.gmtime(self.t)
+        with SuppressCrashReport():
+            for i in range(1, 128):
+                format = ' %' + chr(i)
+                with self.subTest(format=format):
+                    try:
+                        time.strftime(format, tt)
+                    except ValueError as exc:
+                        self.assertEqual(str(exc), 'Invalid format string')
+
+    def test_strftime_special(self):
+        tt = time.gmtime(self.t)
+        s1 = time.strftime('%c', tt)
+        s2 = time.strftime('%B', tt)
+        # gh-52551, gh-78662: Unicode strings should pass through strftime,
+        # independently from locale.
+        self.assertEqual(time.strftime('\U0001f40d', tt), '\U0001f40d')
+        self.assertEqual(time.strftime('\U0001f4bb%c\U0001f40d%B', tt), f'\U0001f4bb{s1}\U0001f40d{s2}')
+        self.assertEqual(time.strftime('%c\U0001f4bb%B\U0001f40d', tt), f'{s1}\U0001f4bb{s2}\U0001f40d')
+        # Lone surrogates should pass through.
+        self.assertEqual(time.strftime('\ud83d', tt), '\ud83d')
+        self.assertEqual(time.strftime('\udc0d', tt), '\udc0d')
+        self.assertEqual(time.strftime('\ud83d%c\udc0d%B', tt), f'\ud83d{s1}\udc0d{s2}')
+        self.assertEqual(time.strftime('%c\ud83d%B\udc0d', tt), f'{s1}\ud83d{s2}\udc0d')
+        self.assertEqual(time.strftime('%c\udc0d%B\ud83d', tt), f'{s1}\udc0d{s2}\ud83d')
+        # Surrogate pairs should not recombine.
+        self.assertEqual(time.strftime('\ud83d\udc0d', tt), '\ud83d\udc0d')
+        self.assertEqual(time.strftime('%c\ud83d\udc0d%B', tt), f'{s1}\ud83d\udc0d{s2}')
+        # Surrogate-escaped bytes should not recombine.
+        self.assertEqual(time.strftime('\udcf0\udc9f\udc90\udc8d', tt), '\udcf0\udc9f\udc90\udc8d')
+        self.assertEqual(time.strftime('%c\udcf0\udc9f\udc90\udc8d%B', tt), f'{s1}\udcf0\udc9f\udc90\udc8d{s2}')
+        # gh-124531: The null character should not terminate the format string.
+        self.assertEqual(time.strftime('\0', tt), '\0')
+        self.assertEqual(time.strftime('\0'*1000, tt), '\0'*1000)
+        self.assertEqual(time.strftime('\0%c\0%B', tt), f'\0{s1}\0{s2}')
+        self.assertEqual(time.strftime('%c\0%B\0', tt), f'{s1}\0{s2}\0')
 
     def _bounds_checking(self, func):
         # Make sure that strftime() checks the bounds of the various parts
@@ -229,8 +292,6 @@ def _bounds_checking(self, func):
         self.assertRaises(ValueError, func,
                             (1900, 1, 1, 0, 0, 0, 0, 367, -1))
 
-    # TODO: RUSTPYTHON, ValueError: invalid struct_time parameter
-    @unittest.expectedFailure
     def test_strftime_bounding_check(self):
         self._bounds_checking(lambda tup: time.strftime('', tup))
 
@@ -247,8 +308,6 @@ def test_strftime_format_check(self):
                     except ValueError:
                         pass
 
-    # TODO: RUSTPYTHON, ValueError: invalid struct_time parameter
-    @unittest.expectedFailure
     def test_default_values_for_zero(self):
         # Make sure that using all zeros uses the proper default
         # values.  No test for daylight savings since strftime() does
@@ -259,8 +318,6 @@ def test_default_values_for_zero(self):
             result = time.strftime("%Y %m %d %H %M %S %w %j", (2000,)+(0,)*8)
         self.assertEqual(expected, result)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     @skip_if_buggy_ucrt_strfptime
     def test_strptime(self):
         # Should be able to go round-trip from strftime to strptime without
@@ -270,6 +327,8 @@ def test_strptime(self):
                           'j', 'm', 'M', 'p', 'S',
                           'U', 'w', 'W', 'x', 'X', 'y', 'Y', 'Z', '%'):
             format = '%' + directive
+            if directive == 'd':
+                format += ',%Y'  # Avoid GH-70647.
             strf_output = time.strftime(format, tt)
             try:
                 time.strptime(strf_output, format)
@@ -286,14 +345,18 @@ def test_strptime_exception_context(self):
         # check that this doesn't chain exceptions needlessly (see #17572)
         with self.assertRaises(ValueError) as e:
             time.strptime('', '%D')
-        self.assertIs(e.exception.__suppress_context__, True)
-        # additional check for IndexError branch (issue #19545)
+        self.assertTrue(e.exception.__suppress_context__)
+        # additional check for stray % branch
         with self.assertRaises(ValueError) as e:
-            time.strptime('19', '%Y %')
-        self.assertIs(e.exception.__suppress_context__, True)
+            time.strptime('%', '%')
+        self.assertTrue(e.exception.__suppress_context__)
+
+    def test_strptime_leap_year(self):
+        # GH-70647: warns if parsing a format with a day and no year.
+        with self.assertWarnsRegex(DeprecationWarning,
+                                   r'.*day of month without a year.*'):
+            time.strptime('02-07 18:28', '%m-%d %H:%M')
 
-    # TODO: RUSTPYTHON, ValueError: invalid struct_time parameter
-    @unittest.expectedFailure
     def test_asctime(self):
         time.asctime(time.gmtime(self.t))
 
@@ -309,13 +372,9 @@ def test_asctime(self):
         self.assertRaises(TypeError, time.asctime, ())
         self.assertRaises(TypeError, time.asctime, (0,) * 10)
 
-    # TODO: RUSTPYTHON, ValueError: invalid struct_time parameter
-    @unittest.expectedFailure
     def test_asctime_bounding_check(self):
         self._bounds_checking(time.asctime)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_ctime(self):
         t = time.mktime((1973, 9, 16, 1, 3, 52, 0, 0, -1))
         self.assertEqual(time.ctime(t), 'Sun Sep 16 01:03:52 1973')
@@ -415,8 +474,6 @@ def test_insane_timestamps(self):
             for unreasonable in -1e200, 1e200:
                 self.assertRaises(OverflowError, func, unreasonable)
 
-    # TODO: RUSTPYTHON, TypeError: unexpected type NoneType
-    @unittest.expectedFailure
     def test_ctime_without_arg(self):
         # Not sure how to check the values, since the clock could tick
         # at any time.  Make sure these are at least accepted and
@@ -424,8 +481,6 @@ def test_ctime_without_arg(self):
         time.ctime()
         time.ctime(None)
 
-    # TODO: RUSTPYTHON, TypeError: unexpected type NoneType
-    @unittest.expectedFailure
     def test_gmtime_without_arg(self):
         gt0 = time.gmtime()
         gt1 = time.gmtime(None)
@@ -433,8 +488,6 @@ def test_gmtime_without_arg(self):
         t1 = time.mktime(gt1)
         self.assertAlmostEqual(t1, t0, delta=0.2)
 
-    # TODO: RUSTPYTHON, TypeError: unexpected type NoneType
-    @unittest.expectedFailure
     def test_localtime_without_arg(self):
         lt0 = time.localtime()
         lt1 = time.localtime(None)
@@ -469,8 +522,6 @@ def test_mktime_error(self):
             pass
         self.assertEqual(time.strftime('%Z', tt), tzname)
 
-    # TODO: RUSTPYTHON
-    @unittest.skipIf(sys.platform == "win32", "Implement get_clock_info for Windows.")
     def test_monotonic(self):
         # monotonic() should not go backward
         times = [time.monotonic() for n in range(100)]
@@ -497,6 +548,12 @@ def test_monotonic(self):
     def test_perf_counter(self):
         time.perf_counter()
 
+    @unittest.skipIf(
+        support.is_wasi, "process_time not available on WASI"
+    )
+    @unittest.skipIf(
+        support.is_emscripten, "process_time present but doesn't exclude sleep"
+    )
     def test_process_time(self):
         # process_time() should not include time spend during a sleep
         start = time.process_time()
@@ -512,7 +569,7 @@ def test_process_time(self):
 
     def test_thread_time(self):
         if not hasattr(time, 'thread_time'):
-            if sys.platform.startswith(('linux', 'win')):
+            if sys.platform.startswith(('linux', 'android', 'win')):
                 self.fail("time.thread_time() should be available on %r"
                           % (sys.platform,))
             else:
@@ -520,11 +577,10 @@ def test_thread_time(self):
 
         # thread_time() should not include time spend during a sleep
         start = time.thread_time()
-        time.sleep(0.100)
+        time.sleep(0.200)
         stop = time.thread_time()
-        # use 20 ms because thread_time() has usually a resolution of 15 ms
-        # on Windows
-        self.assertLess(stop - start, 0.020)
+        # gh-143528: use 100 ms to support slow CI
+        self.assertLess(stop - start, 0.100)
 
         info = time.get_clock_info('thread_time')
         self.assertTrue(info.monotonic)
@@ -572,8 +628,9 @@ def test_get_clock_info(self):
             'perf_counter',
             'process_time',
             'time',
-            'thread_time',
         ]
+        if hasattr(time, 'thread_time'):
+            clocks.append('thread_time')
 
         for name in clocks:
             with self.subTest(name=name):
@@ -592,17 +649,8 @@ def test_get_clock_info(self):
 
 
 class TestLocale(unittest.TestCase):
-    def setUp(self):
-        self.oldloc = locale.setlocale(locale.LC_ALL)
-
-    def tearDown(self):
-        locale.setlocale(locale.LC_ALL, self.oldloc)
-
+    @support.run_with_locale('LC_ALL', 'fr_FR', '')
     def test_bug_3061(self):
-        try:
-            tmp = locale.setlocale(locale.LC_ALL, "fr_FR")
-        except locale.Error:
-            self.skipTest('could not set locale.LC_ALL to fr_FR')
         # This should not cause an exception
         time.strftime("%B", (2009,2,1,0,0,0,0,0,0))
 
@@ -613,8 +661,6 @@ class _TestAsctimeYear:
     def yearstr(self, y):
         return time.asctime((y,) + (0,) * 8).split()[-1]
 
-    # TODO: RUSTPYTHON, ValueError: invalid struct_time parameter
-    @unittest.expectedFailure
     def test_large_year(self):
         # Check that it doesn't crash for year > 9999
         self.assertEqual(self.yearstr(12345), '12345')
@@ -627,15 +673,17 @@ class _TestStrftimeYear:
     # assumes year >= 1900, so it does not specify the number
     # of digits.
 
-    # TODO: RUSTPYTHON
-    # if time.strftime('%Y', (1,) + (0,) * 8) == '0001':
-    #     _format = '%04d'
-    # else:
-    #     _format = '%d'
+    if time.strftime('%Y', (1,) + (0,) * 8) == '0001':
+        _format = '%04d'
+    else:
+        _format = '%d'
 
     def yearstr(self, y):
         return time.strftime('%Y', (y,) + (0,) * 8)
 
+    @unittest.skipUnless(
+        support.has_strftime_extensions, "requires strftime extension"
+    )
     def test_4dyear(self):
         # Check that we can return the zero padded value.
         if self._format == '%04d':
@@ -646,8 +694,7 @@ def year4d(y):
             self.test_year('%04d', func=year4d)
 
     def skip_if_not_supported(y):
-        msg = "strftime() is limited to [1; 9999] with Visual Studio"
-        # Check that it doesn't crash for year > 9999
+        msg = f"strftime() does not support year {y} on this platform"
         try:
             time.strftime('%Y', (y,) + (0,) * 8)
         except ValueError:
@@ -670,8 +717,6 @@ def test_negative(self):
 class _Test4dYear:
     _format = '%d'
 
-    # TODO: RUSTPYTHON, ValueError: invalid struct_time parameter
-    @unittest.expectedFailure
     def test_year(self, fmt=None, func=None):
         fmt = fmt or self._format
         func = func or self.yearstr
@@ -688,8 +733,6 @@ def test_large_year(self):
         self.assertEqual(self.yearstr(TIME_MAXYEAR).lstrip('+'), str(TIME_MAXYEAR))
         self.assertRaises(OverflowError, self.yearstr, TIME_MAXYEAR + 1)
 
-    # TODO: RUSTPYTHON, ValueError: invalid struct_time parameter
-    @unittest.expectedFailure
     def test_negative(self):
         self.assertEqual(self.yearstr(-1), self._format % -1)
         self.assertEqual(self.yearstr(-1234), '-1234')
@@ -706,30 +749,28 @@ def test_negative(self):
 class TestAsctime4dyear(_TestAsctimeYear, _Test4dYear, unittest.TestCase):
     pass
 
-# class TestStrftime4dyear(_TestStrftimeYear, _Test4dYear, unittest.TestCase):
-#     pass
+class TestStrftime4dyear(_TestStrftimeYear, _Test4dYear, unittest.TestCase):
+    pass
 
 
 class TestPytime(unittest.TestCase):
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     @skip_if_buggy_ucrt_strfptime
     @unittest.skipUnless(time._STRUCT_TM_ITEMS == 11, "needs tm_zone support")
     def test_localtime_timezone(self):
 
         # Get the localtime and examine it for the offset and zone.
         lt = time.localtime()
-        self.assertTrue(hasattr(lt, "tm_gmtoff"))
-        self.assertTrue(hasattr(lt, "tm_zone"))
+        self.assertHasAttr(lt, "tm_gmtoff")
+        self.assertHasAttr(lt, "tm_zone")
 
         # See if the offset and zone are similar to the module
         # attributes.
         if lt.tm_gmtoff is None:
-            self.assertTrue(not hasattr(time, "timezone"))
+            self.assertNotHasAttr(time, "timezone")
         else:
             self.assertEqual(lt.tm_gmtoff, -[time.timezone, time.altzone][lt.tm_isdst])
         if lt.tm_zone is None:
-            self.assertTrue(not hasattr(time, "tzname"))
+            self.assertNotHasAttr(time, "tzname")
         else:
             self.assertEqual(lt.tm_zone, time.tzname[lt.tm_isdst])
 
@@ -748,18 +789,14 @@ def test_localtime_timezone(self):
         self.assertEqual(new_lt9, lt)
         self.assertEqual(new_lt.tm_gmtoff, lt.tm_gmtoff)
         self.assertEqual(new_lt9.tm_zone, lt.tm_zone)
-    
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+
     @unittest.skipUnless(time._STRUCT_TM_ITEMS == 11, "needs tm_zone support")
     def test_strptime_timezone(self):
         t = time.strptime("UTC", "%Z")
         self.assertEqual(t.tm_zone, 'UTC')
         t = time.strptime("+0500", "%z")
         self.assertEqual(t.tm_gmtoff, 5 * 3600)
-    
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+
     @unittest.skipUnless(time._STRUCT_TM_ITEMS == 11, "needs tm_zone support")
     def test_short_times(self):
 
@@ -772,7 +809,8 @@ def test_short_times(self):
         self.assertIs(lt.tm_zone, None)
 
 
-@unittest.skipIf(_testcapi is None, 'need the _testcapi module')
+@unittest.skipIf(_testcapi is None, 'need the _testinternalcapi module')
+@unittest.skipIf(_testinternalcapi is None, 'need the _testinternalcapi module')
 class CPyTimeTestCase:
     """
     Base class to test the C _PyTime_t API.
@@ -780,7 +818,7 @@ class CPyTimeTestCase:
     OVERFLOW_SECONDS = None
 
     def setUp(self):
-        from _testcapi import SIZEOF_TIME_T
+        from _testinternalcapi import SIZEOF_TIME_T
         bits = SIZEOF_TIME_T * 8 - 1
         self.time_t_min = -2 ** bits
         self.time_t_max = 2 ** bits - 1
@@ -859,7 +897,7 @@ def convert_values(ns_timestamps):
         # test rounding
         ns_timestamps = self._rounding_values(use_float)
         valid_values = convert_values(ns_timestamps)
-        for time_rnd, decimal_rnd in ROUNDING_MODES :
+        for time_rnd, decimal_rnd in ROUNDING_MODES:
             with decimal.localcontext() as context:
                 context.rounding = decimal_rnd
 
@@ -908,36 +946,36 @@ class TestCPyTime(CPyTimeTestCase, unittest.TestCase):
     OVERFLOW_SECONDS = math.ceil((2**63 + 1) / SEC_TO_NS)
 
     def test_FromSeconds(self):
-        from _testcapi import PyTime_FromSeconds
+        from _testinternalcapi import _PyTime_FromSeconds
 
-        # PyTime_FromSeconds() expects a C int, reject values out of range
+        # _PyTime_FromSeconds() expects a C int, reject values out of range
         def c_int_filter(secs):
             return (_testcapi.INT_MIN <= secs <= _testcapi.INT_MAX)
 
-        self.check_int_rounding(lambda secs, rnd: PyTime_FromSeconds(secs),
+        self.check_int_rounding(lambda secs, rnd: _PyTime_FromSeconds(secs),
                                 lambda secs: secs * SEC_TO_NS,
                                 value_filter=c_int_filter)
 
         # test nan
         for time_rnd, _ in ROUNDING_MODES:
             with self.assertRaises(TypeError):
-                PyTime_FromSeconds(float('nan'))
+                _PyTime_FromSeconds(float('nan'))
 
     def test_FromSecondsObject(self):
-        from _testcapi import PyTime_FromSecondsObject
+        from _testinternalcapi import _PyTime_FromSecondsObject
 
         self.check_int_rounding(
-            PyTime_FromSecondsObject,
+            _PyTime_FromSecondsObject,
             lambda secs: secs * SEC_TO_NS)
 
         self.check_float_rounding(
-            PyTime_FromSecondsObject,
+            _PyTime_FromSecondsObject,
             lambda ns: self.decimal_round(ns * SEC_TO_NS))
 
         # test nan
         for time_rnd, _ in ROUNDING_MODES:
             with self.assertRaises(ValueError):
-                PyTime_FromSecondsObject(float('nan'), time_rnd)
+                _PyTime_FromSecondsObject(float('nan'), time_rnd)
 
     def test_AsSecondsDouble(self):
         from _testcapi import PyTime_AsSecondsDouble
@@ -952,11 +990,6 @@ def float_converter(ns):
                                 float_converter,
                                 NS_TO_SEC)
 
-        # test nan
-        for time_rnd, _ in ROUNDING_MODES:
-            with self.assertRaises(TypeError):
-                PyTime_AsSecondsDouble(float('nan'))
-
     def create_decimal_converter(self, denominator):
         denom = decimal.Decimal(denominator)
 
@@ -967,7 +1000,7 @@ def converter(value):
         return converter
 
     def test_AsTimeval(self):
-        from _testcapi import PyTime_AsTimeval
+        from _testinternalcapi import _PyTime_AsTimeval
 
         us_converter = self.create_decimal_converter(US_TO_NS)
 
@@ -984,35 +1017,78 @@ def seconds_filter(secs):
         else:
             seconds_filter = self.time_t_filter
 
-        self.check_int_rounding(PyTime_AsTimeval,
+        self.check_int_rounding(_PyTime_AsTimeval,
                                 timeval_converter,
                                 NS_TO_SEC,
                                 value_filter=seconds_filter)
 
-    @unittest.skipUnless(hasattr(_testcapi, 'PyTime_AsTimespec'),
-                         'need _testcapi.PyTime_AsTimespec')
+    @unittest.skipUnless(hasattr(_testinternalcapi, '_PyTime_AsTimespec'),
+                         'need _testinternalcapi._PyTime_AsTimespec')
     def test_AsTimespec(self):
-        from _testcapi import PyTime_AsTimespec
+        from _testinternalcapi import _PyTime_AsTimespec
 
         def timespec_converter(ns):
             return divmod(ns, SEC_TO_NS)
 
-        self.check_int_rounding(lambda ns, rnd: PyTime_AsTimespec(ns),
+        self.check_int_rounding(lambda ns, rnd: _PyTime_AsTimespec(ns),
                                 timespec_converter,
                                 NS_TO_SEC,
                                 value_filter=self.time_t_filter)
 
+    @unittest.skipUnless(hasattr(_testinternalcapi, '_PyTime_AsTimeval_clamp'),
+                         'need _testinternalcapi._PyTime_AsTimeval_clamp')
+    def test_AsTimeval_clamp(self):
+        from _testinternalcapi import _PyTime_AsTimeval_clamp
+
+        if sys.platform == 'win32':
+            from _testcapi import LONG_MIN, LONG_MAX
+            tv_sec_max = LONG_MAX
+            tv_sec_min = LONG_MIN
+        else:
+            tv_sec_max = self.time_t_max
+            tv_sec_min = self.time_t_min
+
+        for t in (PyTime_MIN, PyTime_MAX):
+            ts = _PyTime_AsTimeval_clamp(t, _PyTime.ROUND_CEILING)
+            with decimal.localcontext() as context:
+                context.rounding = decimal.ROUND_CEILING
+                us = self.decimal_round(decimal.Decimal(t) / US_TO_NS)
+            tv_sec, tv_usec = divmod(us, SEC_TO_US)
+            if tv_sec_max < tv_sec:
+                tv_sec = tv_sec_max
+                tv_usec = 0
+            elif tv_sec < tv_sec_min:
+                tv_sec = tv_sec_min
+                tv_usec = 0
+            self.assertEqual(ts, (tv_sec, tv_usec))
+
+    @unittest.skipUnless(hasattr(_testinternalcapi, '_PyTime_AsTimespec_clamp'),
+                         'need _testinternalcapi._PyTime_AsTimespec_clamp')
+    def test_AsTimespec_clamp(self):
+        from _testinternalcapi import _PyTime_AsTimespec_clamp
+
+        for t in (PyTime_MIN, PyTime_MAX):
+            ts = _PyTime_AsTimespec_clamp(t)
+            tv_sec, tv_nsec = divmod(t, NS_TO_SEC)
+            if self.time_t_max < tv_sec:
+                tv_sec = self.time_t_max
+                tv_nsec = 0
+            elif tv_sec < self.time_t_min:
+                tv_sec = self.time_t_min
+                tv_nsec = 0
+            self.assertEqual(ts, (tv_sec, tv_nsec))
+
     def test_AsMilliseconds(self):
-        from _testcapi import PyTime_AsMilliseconds
+        from _testinternalcapi import _PyTime_AsMilliseconds
 
-        self.check_int_rounding(PyTime_AsMilliseconds,
+        self.check_int_rounding(_PyTime_AsMilliseconds,
                                 self.create_decimal_converter(MS_TO_NS),
                                 NS_TO_SEC)
 
     def test_AsMicroseconds(self):
-        from _testcapi import PyTime_AsMicroseconds
+        from _testinternalcapi import _PyTime_AsMicroseconds
 
-        self.check_int_rounding(PyTime_AsMicroseconds,
+        self.check_int_rounding(_PyTime_AsMicroseconds,
                                 self.create_decimal_converter(US_TO_NS),
                                 NS_TO_SEC)
 
@@ -1026,13 +1102,13 @@ class TestOldPyTime(CPyTimeTestCase, unittest.TestCase):
     OVERFLOW_SECONDS = 2 ** 64
 
     def test_object_to_time_t(self):
-        from _testcapi import pytime_object_to_time_t
+        from _testinternalcapi import _PyTime_ObjectToTime_t
 
-        self.check_int_rounding(pytime_object_to_time_t,
+        self.check_int_rounding(_PyTime_ObjectToTime_t,
                                 lambda secs: secs,
                                 value_filter=self.time_t_filter)
 
-        self.check_float_rounding(pytime_object_to_time_t,
+        self.check_float_rounding(_PyTime_ObjectToTime_t,
                                   self.decimal_round,
                                   value_filter=self.time_t_filter)
 
@@ -1052,36 +1128,36 @@ def converter(secs):
         return converter
 
     def test_object_to_timeval(self):
-        from _testcapi import pytime_object_to_timeval
+        from _testinternalcapi import _PyTime_ObjectToTimeval
 
-        self.check_int_rounding(pytime_object_to_timeval,
+        self.check_int_rounding(_PyTime_ObjectToTimeval,
                                 lambda secs: (secs, 0),
                                 value_filter=self.time_t_filter)
 
-        self.check_float_rounding(pytime_object_to_timeval,
+        self.check_float_rounding(_PyTime_ObjectToTimeval,
                                   self.create_converter(SEC_TO_US),
                                   value_filter=self.time_t_filter)
 
          # test nan
         for time_rnd, _ in ROUNDING_MODES:
             with self.assertRaises(ValueError):
-                pytime_object_to_timeval(float('nan'), time_rnd)
+                _PyTime_ObjectToTimeval(float('nan'), time_rnd)
 
     def test_object_to_timespec(self):
-        from _testcapi import pytime_object_to_timespec
+        from _testinternalcapi import _PyTime_ObjectToTimespec
 
-        self.check_int_rounding(pytime_object_to_timespec,
+        self.check_int_rounding(_PyTime_ObjectToTimespec,
                                 lambda secs: (secs, 0),
                                 value_filter=self.time_t_filter)
 
-        self.check_float_rounding(pytime_object_to_timespec,
+        self.check_float_rounding(_PyTime_ObjectToTimespec,
                                   self.create_converter(SEC_TO_NS),
                                   value_filter=self.time_t_filter)
 
         # test nan
         for time_rnd, _ in ROUNDING_MODES:
             with self.assertRaises(ValueError):
-                pytime_object_to_timespec(float('nan'), time_rnd)
+                _PyTime_ObjectToTimespec(float('nan'), time_rnd)
 
 @unittest.skipUnless(sys.platform == "darwin", "test weak linking on macOS")
 class TestTimeWeaklinking(unittest.TestCase):
@@ -1107,11 +1183,11 @@ def test_clock_functions(self):
 
         if mac_ver >= (10, 12):
             for name in clock_names:
-                self.assertTrue(hasattr(time, name), f"time.{name} is not available")
+                self.assertHasAttr(time, name)
 
         else:
             for name in clock_names:
-                self.assertFalse(hasattr(time, name), f"time.{name} is available")
+                self.assertNotHasAttr(time, name)
 
 
 if __name__ == "__main__":
diff --git a/Lib/test/test_timeit.py b/Lib/test/test_timeit.py
index 72a104fc1a6..2aeebea9f93 100644
--- a/Lib/test/test_timeit.py
+++ b/Lib/test/test_timeit.py
@@ -222,8 +222,8 @@ def test_repeat_function_zero_iters(self):
     def assert_exc_string(self, exc_string, expected_exc_name):
         exc_lines = exc_string.splitlines()
         self.assertGreater(len(exc_lines), 2)
-        self.assertTrue(exc_lines[0].startswith('Traceback'))
-        self.assertTrue(exc_lines[-1].startswith(expected_exc_name))
+        self.assertStartsWith(exc_lines[0], 'Traceback')
+        self.assertStartsWith(exc_lines[-1], expected_exc_name)
 
     def test_print_exc(self):
         s = io.StringIO()
@@ -297,9 +297,7 @@ def test_main_negative_reps(self):
     @unittest.skipIf(sys.flags.optimize >= 2, "need __doc__")
     def test_main_help(self):
         s = self.run_main(switches=['-h'])
-        # Note: It's not clear that the trailing space was intended as part of
-        # the help text, but since it's there, check for it.
-        self.assertEqual(s, timeit.__doc__ + ' ')
+        self.assertEqual(s, timeit.__doc__)
 
     def test_main_verbose(self):
         s = self.run_main(switches=['-v'])
diff --git a/Lib/test/test_tokenize.py b/Lib/test/test_tokenize.py
index 44ef4e24165..394a87c3601 100644
--- a/Lib/test/test_tokenize.py
+++ b/Lib/test/test_tokenize.py
@@ -1,17 +1,22 @@
-from test import support
-from test.support import os_helper
-from tokenize import (tokenize, _tokenize, untokenize, NUMBER, NAME, OP,
-                     STRING, ENDMARKER, ENCODING, tok_name, detect_encoding,
-                     open as tokenize_open, Untokenizer, generate_tokens,
-                     NEWLINE)
-from io import BytesIO, StringIO
+import contextlib
+import itertools
+import os
+import re
+import string
+import tempfile
+import token
+import tokenize
 import unittest
+from io import BytesIO, StringIO
 from textwrap import dedent
 from unittest import TestCase, mock
-from test.test_grammar import (VALID_UNDERSCORE_LITERALS,
-                               INVALID_UNDERSCORE_LITERALS)
-import os
-import token
+from test import support
+from test.support import os_helper
+from test.support.script_helper import run_test_script, make_script, run_python_until_end
+from test.support.numbers import (
+    VALID_UNDERSCORE_LITERALS,
+    INVALID_UNDERSCORE_LITERALS,
+)
 
 
 # Converts a source string into a list of textual representation
@@ -24,12 +29,12 @@ def stringify_tokens_from_source(token_generator, source_string):
     missing_trailing_nl = source_string[-1] not in '\r\n'
 
     for type, token, start, end, line in token_generator:
-        if type == ENDMARKER:
+        if type == tokenize.ENDMARKER:
             break
         # Ignore the new line on the last line if the input lacks one
-        if missing_trailing_nl and type == NEWLINE and end[0] == num_lines:
+        if missing_trailing_nl and type == tokenize.NEWLINE and end[0] == num_lines:
             continue
-        type = tok_name[type]
+        type = tokenize.tok_name[type]
         result.append(f"    {type:10} {token!r:13} {start} {end}")
 
     return result
@@ -45,18 +50,37 @@ def check_tokenize(self, s, expected):
         # Format the tokens in s in a table format.
         # The ENDMARKER and final NEWLINE are omitted.
         f = BytesIO(s.encode('utf-8'))
-        result = stringify_tokens_from_source(tokenize(f.readline), s)
+        result = stringify_tokens_from_source(tokenize.tokenize(f.readline), s)
         self.assertEqual(result,
                          ["    ENCODING   'utf-8'       (0, 0) (0, 0)"] +
                          expected.rstrip().splitlines())
 
+    def test_invalid_readline(self):
+        def gen():
+            yield "sdfosdg"
+            yield "sdfosdg"
+        with self.assertRaises(TypeError):
+            list(tokenize.tokenize(gen().__next__))
+
+        def gen():
+            yield b"sdfosdg"
+            yield b"sdfosdg"
+        with self.assertRaises(TypeError):
+            list(tokenize.generate_tokens(gen().__next__))
+
+        def gen():
+            yield "sdfosdg"
+            1/0
+        with self.assertRaises(ZeroDivisionError):
+            list(tokenize.generate_tokens(gen().__next__))
+
     def test_implicit_newline(self):
         # Make sure that the tokenizer puts in an implicit NEWLINE
         # when the input lacks a trailing new line.
         f = BytesIO("x".encode('utf-8'))
-        tokens = list(tokenize(f.readline))
-        self.assertEqual(tokens[-2].type, NEWLINE)
-        self.assertEqual(tokens[-1].type, ENDMARKER)
+        tokens = list(tokenize.tokenize(f.readline))
+        self.assertEqual(tokens[-2].type, tokenize.NEWLINE)
+        self.assertEqual(tokens[-1].type, tokenize.ENDMARKER)
 
     def test_basic(self):
         self.check_tokenize("1 + 1", """\
@@ -83,6 +107,32 @@ def test_basic(self):
     NEWLINE    '\\n'          (4, 26) (4, 27)
     DEDENT     ''            (5, 0) (5, 0)
     """)
+
+        self.check_tokenize("if True:\r\n    # NL\r\n    foo='bar'\r\n\r\n", """\
+    NAME       'if'          (1, 0) (1, 2)
+    NAME       'True'        (1, 3) (1, 7)
+    OP         ':'           (1, 7) (1, 8)
+    NEWLINE    '\\r\\n'        (1, 8) (1, 10)
+    COMMENT    '# NL'        (2, 4) (2, 8)
+    NL         '\\r\\n'        (2, 8) (2, 10)
+    INDENT     '    '        (3, 0) (3, 4)
+    NAME       'foo'         (3, 4) (3, 7)
+    OP         '='           (3, 7) (3, 8)
+    STRING     "\'bar\'"       (3, 8) (3, 13)
+    NEWLINE    '\\r\\n'        (3, 13) (3, 15)
+    NL         '\\r\\n'        (4, 0) (4, 2)
+    DEDENT     ''            (5, 0) (5, 0)
+            """)
+
+        self.check_tokenize("x = 1 + \\\r\n1\r\n", """\
+    NAME       'x'           (1, 0) (1, 1)
+    OP         '='           (1, 2) (1, 3)
+    NUMBER     '1'           (1, 4) (1, 5)
+    OP         '+'           (1, 6) (1, 7)
+    NUMBER     '1'           (2, 0) (2, 1)
+    NEWLINE    '\\r\\n'        (2, 1) (2, 3)
+            """)
+
         indent_error_file = b"""\
 def k(x):
     x += 2
@@ -91,9 +141,18 @@ def k(x):
         readline = BytesIO(indent_error_file).readline
         with self.assertRaisesRegex(IndentationError,
                                     "unindent does not match any "
-                                    "outer indentation level"):
-            for tok in tokenize(readline):
+                                    "outer indentation level") as e:
+            for tok in tokenize.tokenize(readline):
                 pass
+        self.assertEqual(e.exception.lineno, 3)
+        self.assertEqual(e.exception.filename, '<string>')
+        self.assertEqual(e.exception.end_lineno, None)
+        self.assertEqual(e.exception.end_offset, None)
+        self.assertEqual(
+            e.exception.msg,
+            'unindent does not match any outer indentation level')
+        self.assertEqual(e.exception.offset, 9)
+        self.assertEqual(e.exception.text, '  x += 5')
 
     def test_int(self):
         # Ordinary integers and binary operators
@@ -177,7 +236,7 @@ def test_long(self):
     """)
 
     def test_float(self):
-        # Floating point numbers
+        # Floating-point numbers
         self.check_tokenize("x = 3.14159", """\
     NAME       'x'           (1, 0) (1, 1)
     OP         '='           (1, 2) (1, 3)
@@ -219,8 +278,8 @@ def test_float(self):
     def test_underscore_literals(self):
         def number_token(s):
             f = BytesIO(s.encode('utf-8'))
-            for toktype, token, start, end, line in tokenize(f.readline):
-                if toktype == NUMBER:
+            for toktype, token, start, end, line in tokenize.tokenize(f.readline):
+                if toktype == tokenize.NUMBER:
                     return token
             return 'invalid token'
         for lit in VALID_UNDERSCORE_LITERALS:
@@ -228,7 +287,16 @@ def number_token(s):
                 # this won't work with compound complex inputs
                 continue
             self.assertEqual(number_token(lit), lit)
+        # Valid cases with extra underscores in the tokenize module
+        # See gh-105549 for context
+        extra_valid_cases = {"0_7", "09_99"}
         for lit in INVALID_UNDERSCORE_LITERALS:
+            if lit in extra_valid_cases:
+                continue
+            try:
+                number_token(lit)
+            except tokenize.TokenError:
+                continue
             self.assertNotEqual(number_token(lit), lit)
 
     def test_string(self):
@@ -380,21 +448,175 @@ def test_string(self):
     STRING     'rb"\""a\\\\\\nb\\\\\\nc"\""' (1, 0) (3, 4)
     """)
         self.check_tokenize('f"abc"', """\
-    STRING     'f"abc"'      (1, 0) (1, 6)
+    FSTRING_START 'f"'          (1, 0) (1, 2)
+    FSTRING_MIDDLE 'abc'         (1, 2) (1, 5)
+    FSTRING_END '"'           (1, 5) (1, 6)
     """)
         self.check_tokenize('fR"a{b}c"', """\
-    STRING     'fR"a{b}c"'   (1, 0) (1, 9)
+    FSTRING_START 'fR"'         (1, 0) (1, 3)
+    FSTRING_MIDDLE 'a'           (1, 3) (1, 4)
+    OP         '{'           (1, 4) (1, 5)
+    NAME       'b'           (1, 5) (1, 6)
+    OP         '}'           (1, 6) (1, 7)
+    FSTRING_MIDDLE 'c'           (1, 7) (1, 8)
+    FSTRING_END '"'           (1, 8) (1, 9)
+    """)
+        self.check_tokenize('fR"a{{{b!r}}}c"', """\
+    FSTRING_START 'fR"'         (1, 0) (1, 3)
+    FSTRING_MIDDLE 'a{'          (1, 3) (1, 5)
+    OP         '{'           (1, 6) (1, 7)
+    NAME       'b'           (1, 7) (1, 8)
+    OP         '!'           (1, 8) (1, 9)
+    NAME       'r'           (1, 9) (1, 10)
+    OP         '}'           (1, 10) (1, 11)
+    FSTRING_MIDDLE '}'           (1, 11) (1, 12)
+    FSTRING_MIDDLE 'c'           (1, 13) (1, 14)
+    FSTRING_END '"'           (1, 14) (1, 15)
+    """)
+        self.check_tokenize('f"{{{1+1}}}"', """\
+    FSTRING_START 'f"'          (1, 0) (1, 2)
+    FSTRING_MIDDLE '{'           (1, 2) (1, 3)
+    OP         '{'           (1, 4) (1, 5)
+    NUMBER     '1'           (1, 5) (1, 6)
+    OP         '+'           (1, 6) (1, 7)
+    NUMBER     '1'           (1, 7) (1, 8)
+    OP         '}'           (1, 8) (1, 9)
+    FSTRING_MIDDLE '}'           (1, 9) (1, 10)
+    FSTRING_END '"'           (1, 11) (1, 12)
+    """)
+        self.check_tokenize('f"""{f\'\'\'{f\'{f"{1+1}"}\'}\'\'\'}"""', """\
+    FSTRING_START 'f\"""'        (1, 0) (1, 4)
+    OP         '{'           (1, 4) (1, 5)
+    FSTRING_START "f'''"        (1, 5) (1, 9)
+    OP         '{'           (1, 9) (1, 10)
+    FSTRING_START "f'"          (1, 10) (1, 12)
+    OP         '{'           (1, 12) (1, 13)
+    FSTRING_START 'f"'          (1, 13) (1, 15)
+    OP         '{'           (1, 15) (1, 16)
+    NUMBER     '1'           (1, 16) (1, 17)
+    OP         '+'           (1, 17) (1, 18)
+    NUMBER     '1'           (1, 18) (1, 19)
+    OP         '}'           (1, 19) (1, 20)
+    FSTRING_END '"'           (1, 20) (1, 21)
+    OP         '}'           (1, 21) (1, 22)
+    FSTRING_END "'"           (1, 22) (1, 23)
+    OP         '}'           (1, 23) (1, 24)
+    FSTRING_END "'''"         (1, 24) (1, 27)
+    OP         '}'           (1, 27) (1, 28)
+    FSTRING_END '\"""'         (1, 28) (1, 31)
+    """)
+        self.check_tokenize('f"""     x\nstr(data, encoding={invalid!r})\n"""', """\
+    FSTRING_START 'f\"""'        (1, 0) (1, 4)
+    FSTRING_MIDDLE '     x\\nstr(data, encoding=' (1, 4) (2, 19)
+    OP         '{'           (2, 19) (2, 20)
+    NAME       'invalid'     (2, 20) (2, 27)
+    OP         '!'           (2, 27) (2, 28)
+    NAME       'r'           (2, 28) (2, 29)
+    OP         '}'           (2, 29) (2, 30)
+    FSTRING_MIDDLE ')\\n'         (2, 30) (3, 0)
+    FSTRING_END '\"""'         (3, 0) (3, 3)
+    """)
+        self.check_tokenize('f"""123456789\nsomething{None}bad"""', """\
+    FSTRING_START 'f\"""'        (1, 0) (1, 4)
+    FSTRING_MIDDLE '123456789\\nsomething' (1, 4) (2, 9)
+    OP         '{'           (2, 9) (2, 10)
+    NAME       'None'        (2, 10) (2, 14)
+    OP         '}'           (2, 14) (2, 15)
+    FSTRING_MIDDLE 'bad'         (2, 15) (2, 18)
+    FSTRING_END '\"""'         (2, 18) (2, 21)
     """)
         self.check_tokenize('f"""abc"""', """\
-    STRING     'f\"\"\"abc\"\"\"'  (1, 0) (1, 10)
+    FSTRING_START 'f\"""'        (1, 0) (1, 4)
+    FSTRING_MIDDLE 'abc'         (1, 4) (1, 7)
+    FSTRING_END '\"""'         (1, 7) (1, 10)
     """)
         self.check_tokenize(r'f"abc\
 def"', """\
-    STRING     'f"abc\\\\\\ndef"' (1, 0) (2, 4)
+    FSTRING_START 'f"'          (1, 0) (1, 2)
+    FSTRING_MIDDLE 'abc\\\\\\ndef'  (1, 2) (2, 3)
+    FSTRING_END '"'           (2, 3) (2, 4)
     """)
         self.check_tokenize(r'Rf"abc\
 def"', """\
-    STRING     'Rf"abc\\\\\\ndef"' (1, 0) (2, 4)
+    FSTRING_START 'Rf"'         (1, 0) (1, 3)
+    FSTRING_MIDDLE 'abc\\\\\\ndef'  (1, 3) (2, 3)
+    FSTRING_END '"'           (2, 3) (2, 4)
+    """)
+        self.check_tokenize("f'some words {a+b:.3f} more words {c+d=} final words'", """\
+    FSTRING_START "f'"          (1, 0) (1, 2)
+    FSTRING_MIDDLE 'some words ' (1, 2) (1, 13)
+    OP         '{'           (1, 13) (1, 14)
+    NAME       'a'           (1, 14) (1, 15)
+    OP         '+'           (1, 15) (1, 16)
+    NAME       'b'           (1, 16) (1, 17)
+    OP         ':'           (1, 17) (1, 18)
+    FSTRING_MIDDLE '.3f'         (1, 18) (1, 21)
+    OP         '}'           (1, 21) (1, 22)
+    FSTRING_MIDDLE ' more words ' (1, 22) (1, 34)
+    OP         '{'           (1, 34) (1, 35)
+    NAME       'c'           (1, 35) (1, 36)
+    OP         '+'           (1, 36) (1, 37)
+    NAME       'd'           (1, 37) (1, 38)
+    OP         '='           (1, 38) (1, 39)
+    OP         '}'           (1, 39) (1, 40)
+    FSTRING_MIDDLE ' final words' (1, 40) (1, 52)
+    FSTRING_END "'"           (1, 52) (1, 53)
+    """)
+        self.check_tokenize("""\
+f'''{
+3
+=}'''""", """\
+    FSTRING_START "f'''"        (1, 0) (1, 4)
+    OP         '{'           (1, 4) (1, 5)
+    NL         '\\n'          (1, 5) (1, 6)
+    NUMBER     '3'           (2, 0) (2, 1)
+    NL         '\\n'          (2, 1) (2, 2)
+    OP         '='           (3, 0) (3, 1)
+    OP         '}'           (3, 1) (3, 2)
+    FSTRING_END "'''"         (3, 2) (3, 5)
+    """)
+        self.check_tokenize("""\
+f'''__{
+    x:a
+}__'''""", """\
+    FSTRING_START "f'''"        (1, 0) (1, 4)
+    FSTRING_MIDDLE '__'          (1, 4) (1, 6)
+    OP         '{'           (1, 6) (1, 7)
+    NL         '\\n'          (1, 7) (1, 8)
+    NAME       'x'           (2, 4) (2, 5)
+    OP         ':'           (2, 5) (2, 6)
+    FSTRING_MIDDLE 'a\\n'         (2, 6) (3, 0)
+    OP         '}'           (3, 0) (3, 1)
+    FSTRING_MIDDLE '__'          (3, 1) (3, 3)
+    FSTRING_END "'''"         (3, 3) (3, 6)
+    """)
+        self.check_tokenize("""\
+f'''__{
+    x:a
+    b
+     c
+      d
+}__'''""", """\
+    FSTRING_START "f'''"        (1, 0) (1, 4)
+    FSTRING_MIDDLE '__'          (1, 4) (1, 6)
+    OP         '{'           (1, 6) (1, 7)
+    NL         '\\n'          (1, 7) (1, 8)
+    NAME       'x'           (2, 4) (2, 5)
+    OP         ':'           (2, 5) (2, 6)
+    FSTRING_MIDDLE 'a\\n    b\\n     c\\n      d\\n' (2, 6) (6, 0)
+    OP         '}'           (6, 0) (6, 1)
+    FSTRING_MIDDLE '__'          (6, 1) (6, 3)
+    FSTRING_END "'''"         (6, 3) (6, 6)
+    """)
+
+        self.check_tokenize("""\
+    '''Autorzy, którzy tą jednostkę mają wpisani jako AKTUALNA -- czyli
+    aktualni pracownicy, obecni pracownicy'''
+""", """\
+    INDENT     '    '        (1, 0) (1, 4)
+    STRING     "'''Autorzy, którzy tą jednostkę mają wpisani jako AKTUALNA -- czyli\\n    aktualni pracownicy, obecni pracownicy'''" (1, 4) (2, 45)
+    NEWLINE    '\\n'          (2, 45) (2, 46)
+    DEDENT     ''            (3, 0) (3, 0)
     """)
 
     def test_function(self):
@@ -945,29 +1167,95 @@ async def bar(): pass
     DEDENT     ''            (7, 0) (7, 0)
     """)
 
+    def test_newline_after_parenthesized_block_with_comment(self):
+        self.check_tokenize('''\
+[
+    # A comment here
+    1
+]
+''', """\
+    OP         '['           (1, 0) (1, 1)
+    NL         '\\n'          (1, 1) (1, 2)
+    COMMENT    '# A comment here' (2, 4) (2, 20)
+    NL         '\\n'          (2, 20) (2, 21)
+    NUMBER     '1'           (3, 4) (3, 5)
+    NL         '\\n'          (3, 5) (3, 6)
+    OP         ']'           (4, 0) (4, 1)
+    NEWLINE    '\\n'          (4, 1) (4, 2)
+    """)
+
+    def test_closing_parenthesis_from_different_line(self):
+        self.check_tokenize("); x", """\
+    OP         ')'           (1, 0) (1, 1)
+    OP         ';'           (1, 1) (1, 2)
+    NAME       'x'           (1, 3) (1, 4)
+    """)
+
+    def test_multiline_non_ascii_fstring(self):
+        self.check_tokenize("""\
+a = f'''
+    Autorzy, którzy tą jednostkę mają wpisani jako AKTUALNA -- czyli'''""", """\
+    NAME       'a'           (1, 0) (1, 1)
+    OP         '='           (1, 2) (1, 3)
+    FSTRING_START "f\'\'\'"        (1, 4) (1, 8)
+    FSTRING_MIDDLE '\\n    Autorzy, którzy tą jednostkę mają wpisani jako AKTUALNA -- czyli' (1, 8) (2, 68)
+    FSTRING_END "\'\'\'"         (2, 68) (2, 71)
+    """)
+
+    def test_multiline_non_ascii_fstring_with_expr(self):
+        self.check_tokenize("""\
+f'''
+    🔗 This is a test {test_arg1}🔗
+🔗'''""", """\
+    FSTRING_START "f\'\'\'"        (1, 0) (1, 4)
+    FSTRING_MIDDLE '\\n    🔗 This is a test ' (1, 4) (2, 21)
+    OP         '{'           (2, 21) (2, 22)
+    NAME       'test_arg1'   (2, 22) (2, 31)
+    OP         '}'           (2, 31) (2, 32)
+    FSTRING_MIDDLE '🔗\\n🔗'        (2, 32) (3, 1)
+    FSTRING_END "\'\'\'"         (3, 1) (3, 4)
+    """)
+
+        # gh-139516, the '\n' is explicit to ensure no trailing whitespace which would invalidate the test
+        self.check_tokenize('''f"{f(a=lambda: 'à'\n)}"''', """\
+    FSTRING_START \'f"\'          (1, 0) (1, 2)
+    OP         '{'           (1, 2) (1, 3)
+    NAME       'f'           (1, 3) (1, 4)
+    OP         '('           (1, 4) (1, 5)
+    NAME       'a'           (1, 5) (1, 6)
+    OP         '='           (1, 6) (1, 7)
+    NAME       'lambda'      (1, 7) (1, 13)
+    OP         ':'           (1, 13) (1, 14)
+    STRING     "\'à\'"         (1, 15) (1, 18)
+    NL         '\\n'          (1, 18) (1, 19)
+    OP         ')'           (2, 0) (2, 1)
+    OP         '}'           (2, 1) (2, 2)
+    FSTRING_END \'"\'           (2, 2) (2, 3)
+    """)
+
 class GenerateTokensTest(TokenizeTest):
     def check_tokenize(self, s, expected):
         # Format the tokens in s in a table format.
         # The ENDMARKER and final NEWLINE are omitted.
         f = StringIO(s)
-        result = stringify_tokens_from_source(generate_tokens(f.readline), s)
+        result = stringify_tokens_from_source(tokenize.generate_tokens(f.readline), s)
         self.assertEqual(result, expected.rstrip().splitlines())
 
 
 def decistmt(s):
     result = []
-    g = tokenize(BytesIO(s.encode('utf-8')).readline)   # tokenize the string
+    g = tokenize.tokenize(BytesIO(s.encode('utf-8')).readline)   # tokenize the string
     for toknum, tokval, _, _, _  in g:
-        if toknum == NUMBER and '.' in tokval:  # replace NUMBER tokens
+        if toknum == tokenize.NUMBER and '.' in tokval:  # replace NUMBER tokens
             result.extend([
-                (NAME, 'Decimal'),
-                (OP, '('),
-                (STRING, repr(tokval)),
-                (OP, ')')
+                (tokenize.NAME, 'Decimal'),
+                (tokenize.OP, '('),
+                (tokenize.STRING, repr(tokval)),
+                (tokenize.OP, ')')
             ])
         else:
             result.append((toknum, tokval))
-    return untokenize(result).decode('utf-8')
+    return tokenize.untokenize(result).decode('utf-8').strip()
 
 class TestMisc(TestCase):
 
@@ -991,6 +1279,13 @@ def test_decistmt(self):
         self.assertEqual(eval(decistmt(s)),
                          Decimal('-3.217160342717258261933904529E-7'))
 
+    def test___all__(self):
+        expected = token.__all__ + [
+            "TokenInfo", "TokenError", "generate_tokens",
+            "detect_encoding", "untokenize", "open", "tokenize",
+        ]
+        self.assertCountEqual(tokenize.__all__, expected)
+
 
 class TestTokenizerAdheresToPep0263(TestCase):
     """
@@ -998,8 +1293,9 @@ class TestTokenizerAdheresToPep0263(TestCase):
     """
 
     def _testFile(self, filename):
-        path = os.path.join(os.path.dirname(__file__), filename)
-        TestRoundtrip.check_roundtrip(self, open(path, 'rb'))
+        path = os.path.join(os.path.dirname(__file__), 'tokenizedata', filename)
+        with open(path, 'rb') as f:
+            TestRoundtrip.check_roundtrip(self, f)
 
     def test_utf8_coding_cookie_and_no_utf8_bom(self):
         f = 'tokenize_tests-utf8-coding-cookie-and-no-utf8-bom-sig.txt'
@@ -1024,8 +1320,6 @@ def test_utf8_coding_cookie_and_utf8_bom(self):
         f = 'tokenize_tests-utf8-coding-cookie-and-utf8-bom-sig.txt'
         self._testFile(f)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure # "bad_coding.py" and "bad_coding2.py" make the WASM CI fail
     def test_bad_coding_cookie(self):
         self.assertRaises(SyntaxError, self._testFile, 'bad_coding.py')
         self.assertRaises(SyntaxError, self._testFile, 'bad_coding2.py')
@@ -1041,33 +1335,18 @@ def readline():
             nonlocal first
             if not first:
                 first = True
-                return line
+                yield line
             else:
-                return b''
+                yield b''
 
         # skip the initial encoding token and the end tokens
-        tokens = list(_tokenize(readline, encoding='utf-8'))[1:-2]
-        expected_tokens = [(3, '"ЉЊЈЁЂ"', (1, 0), (1, 7), '"ЉЊЈЁЂ"')]
+        tokens = list(tokenize._generate_tokens_from_c_tokenizer(readline().__next__,
+                                                                 encoding='utf-8',
+                                                                 extra_tokens=True))[:-2]
+        expected_tokens = [tokenize.TokenInfo(3, '"ЉЊЈЁЂ"', (1, 0), (1, 7), '"ЉЊЈЁЂ"')]
         self.assertEqual(tokens, expected_tokens,
                          "bytes not decoded with encoding")
 
-    def test__tokenize_does_not_decode_with_encoding_none(self):
-        literal = '"ЉЊЈЁЂ"'
-        first = False
-        def readline():
-            nonlocal first
-            if not first:
-                first = True
-                return literal
-            else:
-                return b''
-
-        # skip the end tokens
-        tokens = list(_tokenize(readline, encoding=None))[:-2]
-        expected_tokens = [(3, '"ЉЊЈЁЂ"', (1, 0), (1, 7), '"ЉЊЈЁЂ"')]
-        self.assertEqual(tokens, expected_tokens,
-                         "string not tokenized when encoding is None")
-
 
 class TestDetectEncoding(TestCase):
 
@@ -1084,24 +1363,63 @@ def readline():
 
     def test_no_bom_no_encoding_cookie(self):
         lines = (
-            b'# something\n',
+            b'#!/home/\xc3\xa4/bin/python\n',
+            b'# something \xe2\x82\xac\n',
             b'print(something)\n',
             b'do_something(else)\n'
         )
-        encoding, consumed_lines = detect_encoding(self.get_readline(lines))
+        encoding, consumed_lines = tokenize.detect_encoding(self.get_readline(lines))
         self.assertEqual(encoding, 'utf-8')
         self.assertEqual(consumed_lines, list(lines[:2]))
 
+    def test_no_bom_no_encoding_cookie_first_line_error(self):
+        lines = (
+            b'#!/home/\xa4/bin/python\n\n',
+            b'print(something)\n',
+            b'do_something(else)\n'
+        )
+        with self.assertRaises(SyntaxError):
+            tokenize.detect_encoding(self.get_readline(lines))
+
+    def test_no_bom_no_encoding_cookie_second_line_error(self):
+        lines = (
+            b'#!/usr/bin/python\n',
+            b'# something \xe2\n',
+            b'print(something)\n',
+            b'do_something(else)\n'
+        )
+        with self.assertRaises(SyntaxError):
+            tokenize.detect_encoding(self.get_readline(lines))
+
     def test_bom_no_cookie(self):
         lines = (
-            b'\xef\xbb\xbf# something\n',
+            b'\xef\xbb\xbf#!/home/\xc3\xa4/bin/python\n',
             b'print(something)\n',
             b'do_something(else)\n'
         )
-        encoding, consumed_lines = detect_encoding(self.get_readline(lines))
+        encoding, consumed_lines = tokenize.detect_encoding(self.get_readline(lines))
         self.assertEqual(encoding, 'utf-8-sig')
         self.assertEqual(consumed_lines,
-                         [b'# something\n', b'print(something)\n'])
+                         [b'#!/home/\xc3\xa4/bin/python\n', b'print(something)\n'])
+
+    def test_bom_no_cookie_first_line_error(self):
+        lines = (
+            b'\xef\xbb\xbf#!/home/\xa4/bin/python\n',
+            b'print(something)\n',
+            b'do_something(else)\n'
+        )
+        with self.assertRaises(SyntaxError):
+            tokenize.detect_encoding(self.get_readline(lines))
+
+    def test_bom_no_cookie_second_line_error(self):
+        lines = (
+            b'\xef\xbb\xbf#!/usr/bin/python\n',
+            b'# something \xe2\n',
+            b'print(something)\n',
+            b'do_something(else)\n'
+        )
+        with self.assertRaises(SyntaxError):
+            tokenize.detect_encoding(self.get_readline(lines))
 
     def test_cookie_first_line_no_bom(self):
         lines = (
@@ -1109,7 +1427,7 @@ def test_cookie_first_line_no_bom(self):
             b'print(something)\n',
             b'do_something(else)\n'
         )
-        encoding, consumed_lines = detect_encoding(self.get_readline(lines))
+        encoding, consumed_lines = tokenize.detect_encoding(self.get_readline(lines))
         self.assertEqual(encoding, 'iso-8859-1')
         self.assertEqual(consumed_lines, [b'# -*- coding: latin-1 -*-\n'])
 
@@ -1119,7 +1437,7 @@ def test_matched_bom_and_cookie_first_line(self):
             b'print(something)\n',
             b'do_something(else)\n'
         )
-        encoding, consumed_lines = detect_encoding(self.get_readline(lines))
+        encoding, consumed_lines = tokenize.detect_encoding(self.get_readline(lines))
         self.assertEqual(encoding, 'utf-8-sig')
         self.assertEqual(consumed_lines, [b'# coding=utf-8\n'])
 
@@ -1130,7 +1448,7 @@ def test_mismatched_bom_and_cookie_first_line_raises_syntaxerror(self):
             b'do_something(else)\n'
         )
         readline = self.get_readline(lines)
-        self.assertRaises(SyntaxError, detect_encoding, readline)
+        self.assertRaises(SyntaxError, tokenize.detect_encoding, readline)
 
     def test_cookie_second_line_no_bom(self):
         lines = (
@@ -1139,7 +1457,7 @@ def test_cookie_second_line_no_bom(self):
             b'print(something)\n',
             b'do_something(else)\n'
         )
-        encoding, consumed_lines = detect_encoding(self.get_readline(lines))
+        encoding, consumed_lines = tokenize.detect_encoding(self.get_readline(lines))
         self.assertEqual(encoding, 'ascii')
         expected = [b'#! something\n', b'# vim: set fileencoding=ascii :\n']
         self.assertEqual(consumed_lines, expected)
@@ -1151,7 +1469,7 @@ def test_matched_bom_and_cookie_second_line(self):
             b'print(something)\n',
             b'do_something(else)\n'
         )
-        encoding, consumed_lines = detect_encoding(self.get_readline(lines))
+        encoding, consumed_lines = tokenize.detect_encoding(self.get_readline(lines))
         self.assertEqual(encoding, 'utf-8-sig')
         self.assertEqual(consumed_lines,
                          [b'#! something\n', b'f# coding=utf-8\n'])
@@ -1164,7 +1482,7 @@ def test_mismatched_bom_and_cookie_second_line_raises_syntaxerror(self):
             b'do_something(else)\n'
         )
         readline = self.get_readline(lines)
-        self.assertRaises(SyntaxError, detect_encoding, readline)
+        self.assertRaises(SyntaxError, tokenize.detect_encoding, readline)
 
     def test_cookie_second_line_noncommented_first_line(self):
         lines = (
@@ -1172,21 +1490,65 @@ def test_cookie_second_line_noncommented_first_line(self):
             b'# vim: set fileencoding=iso8859-15 :\n',
             b"print('\xe2\x82\xac')\n"
         )
-        encoding, consumed_lines = detect_encoding(self.get_readline(lines))
+        encoding, consumed_lines = tokenize.detect_encoding(self.get_readline(lines))
         self.assertEqual(encoding, 'utf-8')
         expected = [b"print('\xc2\xa3')\n"]
         self.assertEqual(consumed_lines, expected)
 
-    def test_cookie_second_line_commented_first_line(self):
+    def test_first_non_utf8_coding_line(self):
         lines = (
-            b"#print('\xc2\xa3')\n",
-            b'# vim: set fileencoding=iso8859-15 :\n',
-            b"print('\xe2\x82\xac')\n"
+            b'#coding:iso-8859-15 \xa4\n',
+            b'print(something)\n'
         )
-        encoding, consumed_lines = detect_encoding(self.get_readline(lines))
-        self.assertEqual(encoding, 'iso8859-15')
-        expected = [b"#print('\xc2\xa3')\n", b'# vim: set fileencoding=iso8859-15 :\n']
-        self.assertEqual(consumed_lines, expected)
+        encoding, consumed_lines = tokenize.detect_encoding(self.get_readline(lines))
+        self.assertEqual(encoding, 'iso-8859-15')
+        self.assertEqual(consumed_lines, list(lines[:1]))
+
+    def test_first_utf8_coding_line_error(self):
+        lines = (
+            b'#coding:ascii \xc3\xa4\n',
+            b'print(something)\n'
+        )
+        with self.assertRaises(SyntaxError):
+            tokenize.detect_encoding(self.get_readline(lines))
+
+    def test_second_non_utf8_coding_line(self):
+        lines = (
+            b'#!/usr/bin/python\n',
+            b'#coding:iso-8859-15 \xa4\n',
+            b'print(something)\n'
+        )
+        encoding, consumed_lines = tokenize.detect_encoding(self.get_readline(lines))
+        self.assertEqual(encoding, 'iso-8859-15')
+        self.assertEqual(consumed_lines, list(lines[:2]))
+
+    def test_second_utf8_coding_line_error(self):
+        lines = (
+            b'#!/usr/bin/python\n',
+            b'#coding:ascii \xc3\xa4\n',
+            b'print(something)\n'
+        )
+        with self.assertRaises(SyntaxError):
+            tokenize.detect_encoding(self.get_readline(lines))
+
+    def test_non_utf8_shebang(self):
+        lines = (
+            b'#!/home/\xa4/bin/python\n',
+            b'#coding:iso-8859-15\n',
+            b'print(something)\n'
+        )
+        encoding, consumed_lines = tokenize.detect_encoding(self.get_readline(lines))
+        self.assertEqual(encoding, 'iso-8859-15')
+        self.assertEqual(consumed_lines, list(lines[:2]))
+
+    def test_utf8_shebang_error(self):
+        lines = (
+            b'#!/home/\xc3\xa4/bin/python\n',
+            b'#coding:ascii\n',
+            b'print(something)\n'
+        )
+        with self.assertRaises(SyntaxError):
+            tokenize.detect_encoding(self.get_readline(lines))
 
     def test_cookie_second_line_empty_first_line(self):
         lines = (
@@ -1194,13 +1556,77 @@ def test_cookie_second_line_empty_first_line(self):
             b'# vim: set fileencoding=iso8859-15 :\n',
             b"print('\xe2\x82\xac')\n"
         )
-        encoding, consumed_lines = detect_encoding(self.get_readline(lines))
+        encoding, consumed_lines = tokenize.detect_encoding(self.get_readline(lines))
         self.assertEqual(encoding, 'iso8859-15')
         expected = [b'\n', b'# vim: set fileencoding=iso8859-15 :\n']
         self.assertEqual(consumed_lines, expected)
 
+    def test_cookie_third_line(self):
+        lines = (
+            b'#!/home/\xc3\xa4/bin/python\n',
+            b'# something\n',
+            b'# vim: set fileencoding=ascii :\n',
+            b'print(something)\n',
+            b'do_something(else)\n'
+        )
+        encoding, consumed_lines = tokenize.detect_encoding(self.get_readline(lines))
+        self.assertEqual(encoding, 'utf-8')
+        self.assertEqual(consumed_lines, list(lines[:2]))
+
+    def test_double_coding_line(self):
+        # If the first line matches the second line is ignored.
+        lines = (
+            b'#coding:iso8859-15\n',
+            b'#coding:latin1\n',
+            b'print(something)\n'
+        )
+        encoding, consumed_lines = tokenize.detect_encoding(self.get_readline(lines))
+        self.assertEqual(encoding, 'iso8859-15')
+        self.assertEqual(consumed_lines, list(lines[:1]))
+
+    def test_double_coding_same_line(self):
+        lines = (
+            b'#coding:iso8859-15 coding:latin1\n',
+            b'print(something)\n'
+        )
+        encoding, consumed_lines = tokenize.detect_encoding(self.get_readline(lines))
+        self.assertEqual(encoding, 'iso8859-15')
+        self.assertEqual(consumed_lines, list(lines[:1]))
+
+    def test_double_coding_utf8(self):
+        lines = (
+            b'#coding:utf-8\n',
+            b'#coding:latin1\n',
+            b'print(something)\n'
+        )
+        encoding, consumed_lines = tokenize.detect_encoding(self.get_readline(lines))
+        self.assertEqual(encoding, 'utf-8')
+        self.assertEqual(consumed_lines, list(lines[:1]))
+
+    def test_nul_in_first_coding_line(self):
+        lines = (
+            b'#coding:iso8859-15\x00\n',
+            b'\n',
+            b'\n',
+            b'print(something)\n'
+        )
+        with self.assertRaisesRegex(SyntaxError,
+                "source code cannot contain null bytes"):
+            tokenize.detect_encoding(self.get_readline(lines))
+
+    def test_nul_in_second_coding_line(self):
+        lines = (
+            b'#!/usr/bin/python\n',
+            b'#coding:iso8859-15\x00\n',
+            b'\n',
+            b'print(something)\n'
+        )
+        with self.assertRaisesRegex(SyntaxError,
+                "source code cannot contain null bytes"):
+            tokenize.detect_encoding(self.get_readline(lines))
+
     def test_latin1_normalization(self):
-        # See get_normal_name() in tokenizer.c.
+        # See get_normal_name() in Parser/tokenizer/helpers.c.
         encodings = ("latin-1", "iso-8859-1", "iso-latin-1", "latin-1-unix",
                      "iso-8859-1-unix", "iso-latin-1-mac")
         for encoding in encodings:
@@ -1211,21 +1637,20 @@ def test_latin1_normalization(self):
                          b"print(things)\n",
                          b"do_something += 4\n")
                 rl = self.get_readline(lines)
-                found, consumed_lines = detect_encoding(rl)
+                found, consumed_lines = tokenize.detect_encoding(rl)
                 self.assertEqual(found, "iso-8859-1")
 
     def test_syntaxerror_latin1(self):
-        # Issue 14629: need to raise SyntaxError if the first
+        # Issue 14629: need to raise TokenError if the first
         # line(s) have non-UTF-8 characters
         lines = (
             b'print("\xdf")', # Latin-1: LATIN SMALL LETTER SHARP S
             )
         readline = self.get_readline(lines)
-        self.assertRaises(SyntaxError, detect_encoding, readline)
-
+        self.assertRaises(SyntaxError, tokenize.detect_encoding, readline)
 
     def test_utf8_normalization(self):
-        # See get_normal_name() in tokenizer.c.
+        # See get_normal_name() in Parser/tokenizer/helpers.c.
         encodings = ("utf-8", "utf-8-mac", "utf-8-unix")
         for encoding in encodings:
             for rep in ("-", "_"):
@@ -1234,39 +1659,40 @@ def test_utf8_normalization(self):
                          b"# coding: " + enc.encode("ascii") + b"\n",
                          b"1 + 3\n")
                 rl = self.get_readline(lines)
-                found, consumed_lines = detect_encoding(rl)
+                found, consumed_lines = tokenize.detect_encoding(rl)
                 self.assertEqual(found, "utf-8")
 
     def test_short_files(self):
         readline = self.get_readline((b'print(something)\n',))
-        encoding, consumed_lines = detect_encoding(readline)
+        encoding, consumed_lines = tokenize.detect_encoding(readline)
         self.assertEqual(encoding, 'utf-8')
         self.assertEqual(consumed_lines, [b'print(something)\n'])
 
-        encoding, consumed_lines = detect_encoding(self.get_readline(()))
+        encoding, consumed_lines = tokenize.detect_encoding(self.get_readline(()))
         self.assertEqual(encoding, 'utf-8')
         self.assertEqual(consumed_lines, [])
 
         readline = self.get_readline((b'\xef\xbb\xbfprint(something)\n',))
-        encoding, consumed_lines = detect_encoding(readline)
+        encoding, consumed_lines = tokenize.detect_encoding(readline)
         self.assertEqual(encoding, 'utf-8-sig')
         self.assertEqual(consumed_lines, [b'print(something)\n'])
 
         readline = self.get_readline((b'\xef\xbb\xbf',))
-        encoding, consumed_lines = detect_encoding(readline)
+        encoding, consumed_lines = tokenize.detect_encoding(readline)
         self.assertEqual(encoding, 'utf-8-sig')
         self.assertEqual(consumed_lines, [])
 
         readline = self.get_readline((b'# coding: bad\n',))
-        self.assertRaises(SyntaxError, detect_encoding, readline)
+        self.assertRaises(SyntaxError, tokenize.detect_encoding, readline)
 
     def test_false_encoding(self):
         # Issue 18873: "Encoding" detected in non-comment lines
         readline = self.get_readline((b'print("#coding=fake")',))
-        encoding, consumed_lines = detect_encoding(readline)
+        encoding, consumed_lines = tokenize.detect_encoding(readline)
         self.assertEqual(encoding, 'utf-8')
         self.assertEqual(consumed_lines, [b'print("#coding=fake")'])
 
+    @support.thread_unsafe
     def test_open(self):
         filename = os_helper.TESTFN + '.py'
         self.addCleanup(os_helper.unlink, filename)
@@ -1276,14 +1702,14 @@ def test_open(self):
             with open(filename, 'w', encoding=encoding) as fp:
                 print("# coding: %s" % encoding, file=fp)
                 print("print('euro:\u20ac')", file=fp)
-            with tokenize_open(filename) as fp:
+            with tokenize.open(filename) as fp:
                 self.assertEqual(fp.encoding, encoding)
                 self.assertEqual(fp.mode, 'r')
 
         # test BOM (no coding cookie)
         with open(filename, 'w', encoding='utf-8-sig') as fp:
             print("print('euro:\u20ac')", file=fp)
-        with tokenize_open(filename) as fp:
+        with tokenize.open(filename) as fp:
             self.assertEqual(fp.encoding, 'utf-8-sig')
             self.assertEqual(fp.mode, 'r')
 
@@ -1310,16 +1736,16 @@ def readline(self):
             ins = Bunk(lines, path)
             # Make sure lacking a name isn't an issue.
             del ins.name
-            detect_encoding(ins.readline)
+            tokenize.detect_encoding(ins.readline)
         with self.assertRaisesRegex(SyntaxError, '.*{}'.format(path)):
             ins = Bunk(lines, path)
-            detect_encoding(ins.readline)
+            tokenize.detect_encoding(ins.readline)
 
     def test_open_error(self):
         # Issue #23840: open() must close the binary file on error
         m = BytesIO(b'#coding:xxx')
         with mock.patch('tokenize._builtin_open', return_value=m):
-            self.assertRaises(SyntaxError, tokenize_open, 'foobar')
+            self.assertRaises(SyntaxError, tokenize.open, 'foobar')
         self.assertTrue(m.closed)
 
 
@@ -1327,17 +1753,20 @@ class TestTokenize(TestCase):
 
     def test_tokenize(self):
         import tokenize as tokenize_module
-        encoding = object()
+        encoding = "utf-8"
         encoding_used = None
         def mock_detect_encoding(readline):
             return encoding, [b'first', b'second']
 
-        def mock__tokenize(readline, encoding):
+        def mock__tokenize(readline, encoding, **kwargs):
             nonlocal encoding_used
             encoding_used = encoding
             out = []
             while True:
-                next_line = readline()
+                try:
+                    next_line = readline()
+                except StopIteration:
+                    return out
                 if next_line:
                     out.append(next_line)
                     continue
@@ -1352,16 +1781,16 @@ def mock_readline():
             return str(counter).encode()
 
         orig_detect_encoding = tokenize_module.detect_encoding
-        orig__tokenize = tokenize_module._tokenize
+        orig_c_token = tokenize_module._generate_tokens_from_c_tokenizer
         tokenize_module.detect_encoding = mock_detect_encoding
-        tokenize_module._tokenize = mock__tokenize
+        tokenize_module._generate_tokens_from_c_tokenizer = mock__tokenize
         try:
-            results = tokenize(mock_readline)
-            self.assertEqual(list(results),
+            results = tokenize.tokenize(mock_readline)
+            self.assertEqual(list(results)[1:],
                              [b'first', b'second', b'1', b'2', b'3', b'4'])
         finally:
             tokenize_module.detect_encoding = orig_detect_encoding
-            tokenize_module._tokenize = orig__tokenize
+            tokenize_module._generate_tokens_from_c_tokenizer = orig_c_token
 
         self.assertEqual(encoding_used, encoding)
 
@@ -1373,23 +1802,23 @@ def test_oneline_defs(self):
         buf = '\n'.join(buf)
 
         # Test that 500 consequent, one-line defs is OK
-        toks = list(tokenize(BytesIO(buf.encode('utf-8')).readline))
+        toks = list(tokenize.tokenize(BytesIO(buf.encode('utf-8')).readline))
         self.assertEqual(toks[-3].string, 'OK') # [-1] is always ENDMARKER
                                                 # [-2] is always NEWLINE
 
     def assertExactTypeEqual(self, opstr, *optypes):
-        tokens = list(tokenize(BytesIO(opstr.encode('utf-8')).readline))
+        tokens = list(tokenize.tokenize(BytesIO(opstr.encode('utf-8')).readline))
         num_optypes = len(optypes)
         self.assertEqual(len(tokens), 3 + num_optypes)
-        self.assertEqual(tok_name[tokens[0].exact_type],
-                         tok_name[ENCODING])
+        self.assertEqual(tokenize.tok_name[tokens[0].exact_type],
+                         tokenize.tok_name[tokenize.ENCODING])
         for i in range(num_optypes):
-            self.assertEqual(tok_name[tokens[i + 1].exact_type],
-                             tok_name[optypes[i]])
-        self.assertEqual(tok_name[tokens[1 + num_optypes].exact_type],
-                         tok_name[token.NEWLINE])
-        self.assertEqual(tok_name[tokens[2 + num_optypes].exact_type],
-                         tok_name[token.ENDMARKER])
+            self.assertEqual(tokenize.tok_name[tokens[i + 1].exact_type],
+                             tokenize.tok_name[optypes[i]])
+        self.assertEqual(tokenize.tok_name[tokens[1 + num_optypes].exact_type],
+                         tokenize.tok_name[token.NEWLINE])
+        self.assertEqual(tokenize.tok_name[tokens[2 + num_optypes].exact_type],
+                         tokenize.tok_name[token.ENDMARKER])
 
     def test_exact_type(self):
         self.assertExactTypeEqual('()', token.LPAR, token.RPAR)
@@ -1439,11 +1868,11 @@ def test_exact_type(self):
         self.assertExactTypeEqual('@=', token.ATEQUAL)
 
         self.assertExactTypeEqual('a**2+b**2==c**2',
-                                  NAME, token.DOUBLESTAR, NUMBER,
+                                  tokenize.NAME, token.DOUBLESTAR, tokenize.NUMBER,
                                   token.PLUS,
-                                  NAME, token.DOUBLESTAR, NUMBER,
+                                  tokenize.NAME, token.DOUBLESTAR, tokenize.NUMBER,
                                   token.EQEQUAL,
-                                  NAME, token.DOUBLESTAR, NUMBER)
+                                  tokenize.NAME, token.DOUBLESTAR, tokenize.NUMBER)
         self.assertExactTypeEqual('{1, 2, 3}',
                                   token.LBRACE,
                                   token.NUMBER, token.COMMA,
@@ -1463,19 +1892,55 @@ def test_pathological_trailing_whitespace(self):
     def test_comment_at_the_end_of_the_source_without_newline(self):
         # See http://bugs.python.org/issue44667
         source = 'b = 1\n\n#test'
-        expected_tokens = [token.NAME, token.EQUAL, token.NUMBER, token.NEWLINE, token.NL, token.COMMENT]
+        expected_tokens = [
+            tokenize.TokenInfo(type=token.ENCODING, string='utf-8', start=(0, 0), end=(0, 0), line=''),
+            tokenize.TokenInfo(type=token.NAME, string='b', start=(1, 0), end=(1, 1), line='b = 1\n'),
+            tokenize.TokenInfo(type=token.OP, string='=', start=(1, 2), end=(1, 3), line='b = 1\n'),
+            tokenize.TokenInfo(type=token.NUMBER, string='1', start=(1, 4), end=(1, 5), line='b = 1\n'),
+            tokenize.TokenInfo(type=token.NEWLINE, string='\n', start=(1, 5), end=(1, 6), line='b = 1\n'),
+            tokenize.TokenInfo(type=token.NL, string='\n', start=(2, 0), end=(2, 1), line='\n'),
+            tokenize.TokenInfo(type=token.COMMENT, string='#test', start=(3, 0), end=(3, 5), line='#test'),
+            tokenize.TokenInfo(type=token.NL, string='', start=(3, 5), end=(3, 6), line='#test'),
+            tokenize.TokenInfo(type=token.ENDMARKER, string='', start=(4, 0), end=(4, 0), line='')
+        ]
+
+        tokens = list(tokenize.tokenize(BytesIO(source.encode('utf-8')).readline))
+        self.assertEqual(tokens, expected_tokens)
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; Diff is 869 characters long. Set self.maxDiff to None to see it.
+    def test_newline_and_space_at_the_end_of_the_source_without_newline(self):
+        # See https://github.com/python/cpython/issues/105435
+        source = 'a\n '
+        expected_tokens = [
+            tokenize.TokenInfo(token.ENCODING, string='utf-8', start=(0, 0), end=(0, 0), line=''),
+            tokenize.TokenInfo(token.NAME, string='a', start=(1, 0), end=(1, 1), line='a\n'),
+            tokenize.TokenInfo(token.NEWLINE, string='\n', start=(1, 1), end=(1, 2), line='a\n'),
+            tokenize.TokenInfo(token.NL, string='', start=(2, 1), end=(2, 2), line=' '),
+            tokenize.TokenInfo(token.ENDMARKER, string='', start=(3, 0), end=(3, 0), line='')
+        ]
+
+        tokens = list(tokenize.tokenize(BytesIO(source.encode('utf-8')).readline))
+        self.assertEqual(tokens, expected_tokens)
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AssertionError: b'SyntaxError' not found in b'OSError: stream did not contain valid UTF-8\n'
+    def test_invalid_character_in_fstring_middle(self):
+        # See gh-103824
+        script = b'''F"""
+        \xe5"""'''
+
+        with os_helper.temp_dir() as temp_dir:
+            filename = os.path.join(temp_dir, "script.py")
+            with open(filename, 'wb') as file:
+                file.write(script)
+            rs, _ = run_python_until_end(filename)
+            self.assertIn(b"SyntaxError", rs.err)
 
-        tokens = list(tokenize(BytesIO(source.encode('utf-8')).readline))
-        self.assertEqual(tok_name[tokens[0].exact_type], tok_name[ENCODING])
-        for i in range(6):
-            self.assertEqual(tok_name[tokens[i + 1].exact_type], tok_name[expected_tokens[i]])
-        self.assertEqual(tok_name[tokens[-1].exact_type], tok_name[token.ENDMARKER])
 
 class UntokenizeTest(TestCase):
 
     def test_bad_input_order(self):
         # raise if previous row
-        u = Untokenizer()
+        u = tokenize.Untokenizer()
         u.prev_row = 2
         u.prev_col = 2
         with self.assertRaises(ValueError) as cm:
@@ -1487,7 +1952,7 @@ def test_bad_input_order(self):
 
     def test_backslash_continuation(self):
         # The problem is that <whitespace>\<newline> leaves no token
-        u = Untokenizer()
+        u = tokenize.Untokenizer()
         u.prev_row = 1
         u.prev_col =  1
         u.tokens = []
@@ -1499,17 +1964,33 @@ def test_backslash_continuation(self):
         TestRoundtrip.check_roundtrip(self, 'a\n  b\n    c\n  \\\n  c\n')
 
     def test_iter_compat(self):
-        u = Untokenizer()
-        token = (NAME, 'Hello')
-        tokens = [(ENCODING, 'utf-8'), token]
+        u = tokenize.Untokenizer()
+        token = (tokenize.NAME, 'Hello')
+        tokens = [(tokenize.ENCODING, 'utf-8'), token]
         u.compat(token, iter([]))
         self.assertEqual(u.tokens, ["Hello "])
-        u = Untokenizer()
+        u = tokenize.Untokenizer()
         self.assertEqual(u.untokenize(iter([token])), 'Hello ')
-        u = Untokenizer()
+        u = tokenize.Untokenizer()
         self.assertEqual(u.untokenize(iter(tokens)), 'Hello ')
         self.assertEqual(u.encoding, 'utf-8')
-        self.assertEqual(untokenize(iter(tokens)), b'Hello ')
+        self.assertEqual(tokenize.untokenize(iter(tokens)), b'Hello ')
+
+
+def contains_ambiguous_backslash(source):
+    """Return `True` if the source contains a backslash on a
+    line by itself. For example:
+
+    a = (1
+        \\
+    )
+
+    Code like this cannot be untokenized exactly. This is because
+    the tokenizer does not produce any tokens for the line containing
+    the backslash and so there is no way to know its indent.
+    """
+    pattern = re.compile(br'\n\s*\\\r?\n')
+    return pattern.search(source) is not None
 
 
 class TestRoundtrip(TestCase):
@@ -1522,6 +2003,9 @@ def check_roundtrip(self, f):
         tokenize.untokenize(), and the latter tokenized again to 2-tuples.
         The test fails if the 3 pair tokenizations do not match.
 
+        If the source code can be untokenized unambiguously, the
+        untokenized code must match the original code exactly.
+
         When untokenize bugs are fixed, untokenize with 5-tuples should
         reproduce code that does not contain a backslash continuation
         following spaces.  A proper test should test this.
@@ -1531,21 +2015,38 @@ def check_roundtrip(self, f):
             code = f.encode('utf-8')
         else:
             code = f.read()
-            f.close()
         readline = iter(code.splitlines(keepends=True)).__next__
-        tokens5 = list(tokenize(readline))
+        tokens5 = list(tokenize.tokenize(readline))
         tokens2 = [tok[:2] for tok in tokens5]
         # Reproduce tokens2 from pairs
-        bytes_from2 = untokenize(tokens2)
+        bytes_from2 = tokenize.untokenize(tokens2)
         readline2 = iter(bytes_from2.splitlines(keepends=True)).__next__
-        tokens2_from2 = [tok[:2] for tok in tokenize(readline2)]
+        tokens2_from2 = [tok[:2] for tok in tokenize.tokenize(readline2)]
         self.assertEqual(tokens2_from2, tokens2)
         # Reproduce tokens2 from 5-tuples
-        bytes_from5 = untokenize(tokens5)
+        bytes_from5 = tokenize.untokenize(tokens5)
         readline5 = iter(bytes_from5.splitlines(keepends=True)).__next__
-        tokens2_from5 = [tok[:2] for tok in tokenize(readline5)]
+        tokens2_from5 = [tok[:2] for tok in tokenize.tokenize(readline5)]
         self.assertEqual(tokens2_from5, tokens2)
 
+        if not contains_ambiguous_backslash(code):
+            # The BOM does not produce a token so there is no way to preserve it.
+            code_without_bom = code.removeprefix(b'\xef\xbb\xbf')
+            readline = iter(code_without_bom.splitlines(keepends=True)).__next__
+            untokenized_code = tokenize.untokenize(tokenize.tokenize(readline))
+            self.assertEqual(code_without_bom, untokenized_code)
+
+    def check_line_extraction(self, f):
+        if isinstance(f, str):
+            code = f.encode('utf-8')
+        else:
+            code = f.read()
+        readline = iter(code.splitlines(keepends=True)).__next__
+        for tok in tokenize.tokenize(readline):
+            if tok.type in  {tokenize.ENCODING, tokenize.ENDMARKER}:
+                continue
+            self.assertEqual(tok.string, tok.line[tok.start[1]: tok.end[1]])
+
     def test_roundtrip(self):
         # There are some standard formatting practices that are easy to get right.
 
@@ -1561,7 +2062,7 @@ def test_roundtrip(self):
 
         self.check_roundtrip("if x == 1 : \n"
                              "  print(x)\n")
-        fn = support.findfile("tokenize_tests.txt")
+        fn = support.findfile("tokenize_tests.txt", subdir="tokenizedata")
         with open(fn, 'rb') as f:
             self.check_roundtrip(f)
         self.check_roundtrip("if x == 1:\n"
@@ -1585,6 +2086,67 @@ def test_roundtrip(self):
                              "    print('Can not import' # comment2\n)"
                              "else:   print('Loaded')\n")
 
+        self.check_roundtrip("f'\\N{EXCLAMATION MARK}'")
+        self.check_roundtrip(r"f'\\N{SNAKE}'")
+        self.check_roundtrip(r"f'\\N{{SNAKE}}'")
+        self.check_roundtrip(r"f'\N{SNAKE}'")
+        self.check_roundtrip(r"f'\\\N{SNAKE}'")
+        self.check_roundtrip(r"f'\\\\\N{SNAKE}'")
+        self.check_roundtrip(r"f'\\\\\\\N{SNAKE}'")
+
+        self.check_roundtrip(r"f'\\N{1}'")
+        self.check_roundtrip(r"f'\\\\N{2}'")
+        self.check_roundtrip(r"f'\\\\\\N{3}'")
+        self.check_roundtrip(r"f'\\\\\\\\N{4}'")
+
+        self.check_roundtrip(r"f'\\N{{'")
+        self.check_roundtrip(r"f'\\\\N{{'")
+        self.check_roundtrip(r"f'\\\\\\N{{'")
+        self.check_roundtrip(r"f'\\\\\\\\N{{'")
+
+        self.check_roundtrip(r"f'\n{{foo}}'")
+        self.check_roundtrip(r"f'\\n{{foo}}'")
+        self.check_roundtrip(r"f'\\\n{{foo}}'")
+        self.check_roundtrip(r"f'\\\\n{{foo}}'")
+
+        self.check_roundtrip(r"f'\t{{foo}}'")
+        self.check_roundtrip(r"f'\\t{{foo}}'")
+        self.check_roundtrip(r"f'\\\t{{foo}}'")
+        self.check_roundtrip(r"f'\\\\t{{foo}}'")
+
+        self.check_roundtrip(r"rf'\t{{foo}}'")
+        self.check_roundtrip(r"rf'\\t{{foo}}'")
+        self.check_roundtrip(r"rf'\\\t{{foo}}'")
+        self.check_roundtrip(r"rf'\\\\t{{foo}}'")
+
+        self.check_roundtrip(r"rf'\{{foo}}'")
+        self.check_roundtrip(r"f'\\{{foo}}'")
+        self.check_roundtrip(r"rf'\\\{{foo}}'")
+        self.check_roundtrip(r"f'\\\\{{foo}}'")
+        cases = [
+    """
+if 1:
+    "foo"
+"bar"
+""",
+    """
+if 1:
+    ("foo"
+     "bar")
+""",
+    """
+if 1:
+    "foo"
+    "bar"
+""" ]
+        for case in cases:
+            self.check_roundtrip(case)
+
+        self.check_roundtrip(r"t'{ {}}'")
+        self.check_roundtrip(r"t'{f'{ {}}'}{ {}}'")
+        self.check_roundtrip(r"f'{t'{ {}}'}{ {}}'")
+
+
     def test_continuation(self):
         # Balancing continuation
         self.check_roundtrip("a = (3,4, \n"
@@ -1611,26 +2173,14 @@ def test_string_concatenation(self):
         # Two string literals on the same line
         self.check_roundtrip("'' ''")
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_random_files(self):
         # Test roundtrip on random python modules.
         # pass the '-ucpu' option to process the full directory.
 
         import glob, random
-        fn = support.findfile("tokenize_tests.txt")
-        tempdir = os.path.dirname(fn) or os.curdir
+        tempdir = os.path.dirname(__file__) or os.curdir
         testfiles = glob.glob(os.path.join(glob.escape(tempdir), "test*.py"))
 
-        # Tokenize is broken on test_pep3131.py because regular expressions are
-        # broken on the obscure unicode identifiers in it. *sigh*
-        # With roundtrip extended to test the 5-tuple mode of untokenize,
-        # 7 more testfiles fail.  Remove them also until the failure is diagnosed.
-
-        testfiles.remove(os.path.join(tempdir, "test_unicode_identifiers.py"))
-        for f in ('buffer', 'builtin', 'fileio', 'inspect', 'os', 'platform', 'sys'):
-            testfiles.remove(os.path.join(tempdir, "test_%s.py") % f)
-
         if not support.is_resource_enabled("cpu"):
             testfiles = random.sample(testfiles, 10)
 
@@ -1640,12 +2190,13 @@ def test_random_files(self):
             with open(testfile, 'rb') as f:
                 with self.subTest(file=testfile):
                     self.check_roundtrip(f)
+                    self.check_line_extraction(f)
 
 
     def roundtrip(self, code):
         if isinstance(code, str):
             code = code.encode('utf-8')
-        return untokenize(tokenize(BytesIO(code).readline)).decode('utf-8')
+        return tokenize.untokenize(tokenize.tokenize(BytesIO(code).readline)).decode('utf-8')
 
     def test_indentation_semantics_retained(self):
         """
@@ -1658,5 +2209,1279 @@ def test_indentation_semantics_retained(self):
         self.check_roundtrip(code)
 
 
+class InvalidPythonTests(TestCase):
+    def test_number_followed_by_name(self):
+        # See issue #gh-105549
+        source = "2sin(x)"
+        expected_tokens = [
+            tokenize.TokenInfo(type=token.NUMBER, string='2', start=(1, 0), end=(1, 1), line='2sin(x)'),
+            tokenize.TokenInfo(type=token.NAME, string='sin', start=(1, 1), end=(1, 4), line='2sin(x)'),
+            tokenize.TokenInfo(type=token.OP, string='(', start=(1, 4), end=(1, 5), line='2sin(x)'),
+            tokenize.TokenInfo(type=token.NAME, string='x', start=(1, 5), end=(1, 6), line='2sin(x)'),
+            tokenize.TokenInfo(type=token.OP, string=')', start=(1, 6), end=(1, 7), line='2sin(x)'),
+            tokenize.TokenInfo(type=token.NEWLINE, string='', start=(1, 7), end=(1, 8), line='2sin(x)'),
+            tokenize.TokenInfo(type=token.ENDMARKER, string='', start=(2, 0), end=(2, 0), line='')
+        ]
+
+        tokens = list(tokenize.generate_tokens(StringIO(source).readline))
+        self.assertEqual(tokens, expected_tokens)
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; Diff is 855 characters long. Set self.maxDiff to None to see it.
+    def test_number_starting_with_zero(self):
+        source = "01234"
+        expected_tokens = [
+            tokenize.TokenInfo(type=token.NUMBER, string='01234', start=(1, 0), end=(1, 5), line='01234'),
+            tokenize.TokenInfo(type=token.NEWLINE, string='', start=(1, 5), end=(1, 6), line='01234'),
+            tokenize.TokenInfo(type=token.ENDMARKER, string='', start=(2, 0), end=(2, 0), line='')
+        ]
+
+        tokens = list(tokenize.generate_tokens(StringIO(source).readline))
+        self.assertEqual(tokens, expected_tokens)
+
+class CTokenizeTest(TestCase):
+    def check_tokenize(self, s, expected):
+        # Format the tokens in s in a table format.
+        # The ENDMARKER and final NEWLINE are omitted.
+        f = StringIO(s)
+        with self.subTest(source=s):
+            result = stringify_tokens_from_source(
+                tokenize._generate_tokens_from_c_tokenizer(f.readline), s
+            )
+            self.assertEqual(result, expected.rstrip().splitlines())
+
+    def test_encoding(self):
+        def readline(encoding):
+            yield "1+1".encode(encoding)
+
+        expected = [
+            tokenize.TokenInfo(type=tokenize.NUMBER, string='1', start=(1, 0), end=(1, 1), line='1+1'),
+            tokenize.TokenInfo(type=tokenize.OP, string='+', start=(1, 1), end=(1, 2), line='1+1'),
+            tokenize.TokenInfo(type=tokenize.NUMBER, string='1', start=(1, 2), end=(1, 3), line='1+1'),
+            tokenize.TokenInfo(type=tokenize.NEWLINE, string='', start=(1, 3), end=(1, 4), line='1+1'),
+            tokenize.TokenInfo(type=tokenize.ENDMARKER, string='', start=(2, 0), end=(2, 0), line='')
+        ]
+        for encoding in ["utf-8", "latin-1", "utf-16"]:
+            with self.subTest(encoding=encoding):
+                tokens = list(tokenize._generate_tokens_from_c_tokenizer(
+                    readline(encoding).__next__,
+                    extra_tokens=True,
+                    encoding=encoding,
+                ))
+                self.assertEqual(tokens, expected)
+
+    def test_int(self):
+
+        self.check_tokenize('0xff <= 255', """\
+    NUMBER     '0xff'        (1, 0) (1, 4)
+    LESSEQUAL  '<='          (1, 5) (1, 7)
+    NUMBER     '255'         (1, 8) (1, 11)
+    """)
+
+        self.check_tokenize('0b10 <= 255', """\
+    NUMBER     '0b10'        (1, 0) (1, 4)
+    LESSEQUAL  '<='          (1, 5) (1, 7)
+    NUMBER     '255'         (1, 8) (1, 11)
+    """)
+
+        self.check_tokenize('0o123 <= 0O123', """\
+    NUMBER     '0o123'       (1, 0) (1, 5)
+    LESSEQUAL  '<='          (1, 6) (1, 8)
+    NUMBER     '0O123'       (1, 9) (1, 14)
+    """)
+
+        self.check_tokenize('1234567 > ~0x15', """\
+    NUMBER     '1234567'     (1, 0) (1, 7)
+    GREATER    '>'           (1, 8) (1, 9)
+    TILDE      '~'           (1, 10) (1, 11)
+    NUMBER     '0x15'        (1, 11) (1, 15)
+    """)
+
+        self.check_tokenize('2134568 != 1231515', """\
+    NUMBER     '2134568'     (1, 0) (1, 7)
+    NOTEQUAL   '!='          (1, 8) (1, 10)
+    NUMBER     '1231515'     (1, 11) (1, 18)
+    """)
+
+        self.check_tokenize('(-124561-1) & 200000000', """\
+    LPAR       '('           (1, 0) (1, 1)
+    MINUS      '-'           (1, 1) (1, 2)
+    NUMBER     '124561'      (1, 2) (1, 8)
+    MINUS      '-'           (1, 8) (1, 9)
+    NUMBER     '1'           (1, 9) (1, 10)
+    RPAR       ')'           (1, 10) (1, 11)
+    AMPER      '&'           (1, 12) (1, 13)
+    NUMBER     '200000000'   (1, 14) (1, 23)
+    """)
+
+        self.check_tokenize('0xdeadbeef != -1', """\
+    NUMBER     '0xdeadbeef'  (1, 0) (1, 10)
+    NOTEQUAL   '!='          (1, 11) (1, 13)
+    MINUS      '-'           (1, 14) (1, 15)
+    NUMBER     '1'           (1, 15) (1, 16)
+    """)
+
+        self.check_tokenize('0xdeadc0de & 12345', """\
+    NUMBER     '0xdeadc0de'  (1, 0) (1, 10)
+    AMPER      '&'           (1, 11) (1, 12)
+    NUMBER     '12345'       (1, 13) (1, 18)
+    """)
+
+        self.check_tokenize('0xFF & 0x15 | 1234', """\
+    NUMBER     '0xFF'        (1, 0) (1, 4)
+    AMPER      '&'           (1, 5) (1, 6)
+    NUMBER     '0x15'        (1, 7) (1, 11)
+    VBAR       '|'           (1, 12) (1, 13)
+    NUMBER     '1234'        (1, 14) (1, 18)
+    """)
+
+    def test_float(self):
+
+        self.check_tokenize('x = 3.14159', """\
+    NAME       'x'           (1, 0) (1, 1)
+    EQUAL      '='           (1, 2) (1, 3)
+    NUMBER     '3.14159'     (1, 4) (1, 11)
+    """)
+
+        self.check_tokenize('x = 314159.', """\
+    NAME       'x'           (1, 0) (1, 1)
+    EQUAL      '='           (1, 2) (1, 3)
+    NUMBER     '314159.'     (1, 4) (1, 11)
+    """)
+
+        self.check_tokenize('x = .314159', """\
+    NAME       'x'           (1, 0) (1, 1)
+    EQUAL      '='           (1, 2) (1, 3)
+    NUMBER     '.314159'     (1, 4) (1, 11)
+    """)
+
+        self.check_tokenize('x = 3e14159', """\
+    NAME       'x'           (1, 0) (1, 1)
+    EQUAL      '='           (1, 2) (1, 3)
+    NUMBER     '3e14159'     (1, 4) (1, 11)
+    """)
+
+        self.check_tokenize('x = 3E123', """\
+    NAME       'x'           (1, 0) (1, 1)
+    EQUAL      '='           (1, 2) (1, 3)
+    NUMBER     '3E123'       (1, 4) (1, 9)
+    """)
+
+        self.check_tokenize('x+y = 3e-1230', """\
+    NAME       'x'           (1, 0) (1, 1)
+    PLUS       '+'           (1, 1) (1, 2)
+    NAME       'y'           (1, 2) (1, 3)
+    EQUAL      '='           (1, 4) (1, 5)
+    NUMBER     '3e-1230'     (1, 6) (1, 13)
+    """)
+
+        self.check_tokenize('x = 3.14e159', """\
+    NAME       'x'           (1, 0) (1, 1)
+    EQUAL      '='           (1, 2) (1, 3)
+    NUMBER     '3.14e159'    (1, 4) (1, 12)
+    """)
+
+    def test_string(self):
+
+        self.check_tokenize('x = \'\'; y = ""', """\
+    NAME       'x'           (1, 0) (1, 1)
+    EQUAL      '='           (1, 2) (1, 3)
+    STRING     "''"          (1, 4) (1, 6)
+    SEMI       ';'           (1, 6) (1, 7)
+    NAME       'y'           (1, 8) (1, 9)
+    EQUAL      '='           (1, 10) (1, 11)
+    STRING     '""'          (1, 12) (1, 14)
+    """)
+
+        self.check_tokenize('x = \'"\'; y = "\'"', """\
+    NAME       'x'           (1, 0) (1, 1)
+    EQUAL      '='           (1, 2) (1, 3)
+    STRING     '\\'"\\''       (1, 4) (1, 7)
+    SEMI       ';'           (1, 7) (1, 8)
+    NAME       'y'           (1, 9) (1, 10)
+    EQUAL      '='           (1, 11) (1, 12)
+    STRING     '"\\'"'        (1, 13) (1, 16)
+    """)
+
+        self.check_tokenize('x = "doesn\'t "shrink", does it"', """\
+    NAME       'x'           (1, 0) (1, 1)
+    EQUAL      '='           (1, 2) (1, 3)
+    STRING     '"doesn\\'t "' (1, 4) (1, 14)
+    NAME       'shrink'      (1, 14) (1, 20)
+    STRING     '", does it"' (1, 20) (1, 31)
+    """)
+
+        self.check_tokenize("x = 'abc' + 'ABC'", """\
+    NAME       'x'           (1, 0) (1, 1)
+    EQUAL      '='           (1, 2) (1, 3)
+    STRING     "'abc'"       (1, 4) (1, 9)
+    PLUS       '+'           (1, 10) (1, 11)
+    STRING     "'ABC'"       (1, 12) (1, 17)
+    """)
+
+        self.check_tokenize('y = "ABC" + "ABC"', """\
+    NAME       'y'           (1, 0) (1, 1)
+    EQUAL      '='           (1, 2) (1, 3)
+    STRING     '"ABC"'       (1, 4) (1, 9)
+    PLUS       '+'           (1, 10) (1, 11)
+    STRING     '"ABC"'       (1, 12) (1, 17)
+    """)
+
+        self.check_tokenize("x = r'abc' + r'ABC' + R'ABC' + R'ABC'", """\
+    NAME       'x'           (1, 0) (1, 1)
+    EQUAL      '='           (1, 2) (1, 3)
+    STRING     "r'abc'"      (1, 4) (1, 10)
+    PLUS       '+'           (1, 11) (1, 12)
+    STRING     "r'ABC'"      (1, 13) (1, 19)
+    PLUS       '+'           (1, 20) (1, 21)
+    STRING     "R'ABC'"      (1, 22) (1, 28)
+    PLUS       '+'           (1, 29) (1, 30)
+    STRING     "R'ABC'"      (1, 31) (1, 37)
+    """)
+
+        self.check_tokenize('y = r"abc" + r"ABC" + R"ABC" + R"ABC"', """\
+    NAME       'y'           (1, 0) (1, 1)
+    EQUAL      '='           (1, 2) (1, 3)
+    STRING     'r"abc"'      (1, 4) (1, 10)
+    PLUS       '+'           (1, 11) (1, 12)
+    STRING     'r"ABC"'      (1, 13) (1, 19)
+    PLUS       '+'           (1, 20) (1, 21)
+    STRING     'R"ABC"'      (1, 22) (1, 28)
+    PLUS       '+'           (1, 29) (1, 30)
+    STRING     'R"ABC"'      (1, 31) (1, 37)
+    """)
+
+        self.check_tokenize("u'abc' + U'abc'", """\
+    STRING     "u'abc'"      (1, 0) (1, 6)
+    PLUS       '+'           (1, 7) (1, 8)
+    STRING     "U'abc'"      (1, 9) (1, 15)
+    """)
+
+        self.check_tokenize('u"abc" + U"abc"', """\
+    STRING     'u"abc"'      (1, 0) (1, 6)
+    PLUS       '+'           (1, 7) (1, 8)
+    STRING     'U"abc"'      (1, 9) (1, 15)
+    """)
+
+        self.check_tokenize("b'abc' + B'abc'", """\
+    STRING     "b'abc'"      (1, 0) (1, 6)
+    PLUS       '+'           (1, 7) (1, 8)
+    STRING     "B'abc'"      (1, 9) (1, 15)
+    """)
+
+        self.check_tokenize('b"abc" + B"abc"', """\
+    STRING     'b"abc"'      (1, 0) (1, 6)
+    PLUS       '+'           (1, 7) (1, 8)
+    STRING     'B"abc"'      (1, 9) (1, 15)
+    """)
+
+        self.check_tokenize("br'abc' + bR'abc' + Br'abc' + BR'abc'", """\
+    STRING     "br'abc'"     (1, 0) (1, 7)
+    PLUS       '+'           (1, 8) (1, 9)
+    STRING     "bR'abc'"     (1, 10) (1, 17)
+    PLUS       '+'           (1, 18) (1, 19)
+    STRING     "Br'abc'"     (1, 20) (1, 27)
+    PLUS       '+'           (1, 28) (1, 29)
+    STRING     "BR'abc'"     (1, 30) (1, 37)
+    """)
+
+        self.check_tokenize('br"abc" + bR"abc" + Br"abc" + BR"abc"', """\
+    STRING     'br"abc"'     (1, 0) (1, 7)
+    PLUS       '+'           (1, 8) (1, 9)
+    STRING     'bR"abc"'     (1, 10) (1, 17)
+    PLUS       '+'           (1, 18) (1, 19)
+    STRING     'Br"abc"'     (1, 20) (1, 27)
+    PLUS       '+'           (1, 28) (1, 29)
+    STRING     'BR"abc"'     (1, 30) (1, 37)
+    """)
+
+        self.check_tokenize("rb'abc' + rB'abc' + Rb'abc' + RB'abc'", """\
+    STRING     "rb'abc'"     (1, 0) (1, 7)
+    PLUS       '+'           (1, 8) (1, 9)
+    STRING     "rB'abc'"     (1, 10) (1, 17)
+    PLUS       '+'           (1, 18) (1, 19)
+    STRING     "Rb'abc'"     (1, 20) (1, 27)
+    PLUS       '+'           (1, 28) (1, 29)
+    STRING     "RB'abc'"     (1, 30) (1, 37)
+    """)
+
+        self.check_tokenize('rb"abc" + rB"abc" + Rb"abc" + RB"abc"', """\
+    STRING     'rb"abc"'     (1, 0) (1, 7)
+    PLUS       '+'           (1, 8) (1, 9)
+    STRING     'rB"abc"'     (1, 10) (1, 17)
+    PLUS       '+'           (1, 18) (1, 19)
+    STRING     'Rb"abc"'     (1, 20) (1, 27)
+    PLUS       '+'           (1, 28) (1, 29)
+    STRING     'RB"abc"'     (1, 30) (1, 37)
+    """)
+
+        self.check_tokenize('"a\\\nde\\\nfg"', """\
+    STRING     '"a\\\\\\nde\\\\\\nfg"\' (1, 0) (3, 3)
+    """)
+
+        self.check_tokenize('u"a\\\nde"', """\
+    STRING     'u"a\\\\\\nde"\'  (1, 0) (2, 3)
+    """)
+
+        self.check_tokenize('rb"a\\\nd"', """\
+    STRING     'rb"a\\\\\\nd"\'  (1, 0) (2, 2)
+    """)
+
+        self.check_tokenize(r'"""a\
+b"""', """\
+    STRING     '\"\""a\\\\\\nb\"\""' (1, 0) (2, 4)
+    """)
+        self.check_tokenize(r'u"""a\
+b"""', """\
+    STRING     'u\"\""a\\\\\\nb\"\""' (1, 0) (2, 4)
+    """)
+        self.check_tokenize(r'rb"""a\
+b\
+c"""', """\
+    STRING     'rb"\""a\\\\\\nb\\\\\\nc"\""' (1, 0) (3, 4)
+    """)
+
+        self.check_tokenize(r'"hola\\\r\ndfgf"', """\
+    STRING     \'"hola\\\\\\\\\\\\r\\\\ndfgf"\' (1, 0) (1, 16)
+    """)
+
+        self.check_tokenize('f"abc"', """\
+    FSTRING_START 'f"'          (1, 0) (1, 2)
+    FSTRING_MIDDLE 'abc'         (1, 2) (1, 5)
+    FSTRING_END '"'           (1, 5) (1, 6)
+    """)
+
+        self.check_tokenize('fR"a{b}c"', """\
+    FSTRING_START 'fR"'         (1, 0) (1, 3)
+    FSTRING_MIDDLE 'a'           (1, 3) (1, 4)
+    LBRACE     '{'           (1, 4) (1, 5)
+    NAME       'b'           (1, 5) (1, 6)
+    RBRACE     '}'           (1, 6) (1, 7)
+    FSTRING_MIDDLE 'c'           (1, 7) (1, 8)
+    FSTRING_END '"'           (1, 8) (1, 9)
+    """)
+
+        self.check_tokenize('f"""abc"""', """\
+    FSTRING_START 'f\"""'        (1, 0) (1, 4)
+    FSTRING_MIDDLE 'abc'         (1, 4) (1, 7)
+    FSTRING_END '\"""'         (1, 7) (1, 10)
+    """)
+
+        self.check_tokenize(r'f"abc\
+def"', """\
+    FSTRING_START \'f"\'          (1, 0) (1, 2)
+    FSTRING_MIDDLE 'abc\\\\\\ndef'  (1, 2) (2, 3)
+    FSTRING_END '"'           (2, 3) (2, 4)
+    """)
+
+        self.check_tokenize('''\
+f"{
+a}"''', """\
+    FSTRING_START 'f"'          (1, 0) (1, 2)
+    LBRACE     '{'           (1, 2) (1, 3)
+    NAME       'a'           (2, 0) (2, 1)
+    RBRACE     '}'           (2, 1) (2, 2)
+    FSTRING_END '"'           (2, 2) (2, 3)
+    """)
+
+        self.check_tokenize(r'Rf"abc\
+def"', """\
+    FSTRING_START 'Rf"'         (1, 0) (1, 3)
+    FSTRING_MIDDLE 'abc\\\\\\ndef'  (1, 3) (2, 3)
+    FSTRING_END '"'           (2, 3) (2, 4)
+    """)
+
+        self.check_tokenize(r'f"hola\\\r\ndfgf"', """\
+    FSTRING_START \'f"\'          (1, 0) (1, 2)
+    FSTRING_MIDDLE 'hola\\\\\\\\\\\\r\\\\ndfgf' (1, 2) (1, 16)
+    FSTRING_END \'"\'           (1, 16) (1, 17)
+    """)
+
+        self.check_tokenize("""\
+f'''__{
+    x:a
+}__'''""", """\
+    FSTRING_START "f'''"        (1, 0) (1, 4)
+    FSTRING_MIDDLE '__'          (1, 4) (1, 6)
+    LBRACE     '{'           (1, 6) (1, 7)
+    NAME       'x'           (2, 4) (2, 5)
+    COLON      ':'           (2, 5) (2, 6)
+    FSTRING_MIDDLE 'a\\n'         (2, 6) (3, 0)
+    RBRACE     '}'           (3, 0) (3, 1)
+    FSTRING_MIDDLE '__'          (3, 1) (3, 3)
+    FSTRING_END "'''"         (3, 3) (3, 6)
+    """)
+
+        self.check_tokenize("""\
+f'''__{
+    x:a
+    b
+     c
+      d
+}__'''""", """\
+    FSTRING_START "f'''"        (1, 0) (1, 4)
+    FSTRING_MIDDLE '__'          (1, 4) (1, 6)
+    LBRACE     '{'           (1, 6) (1, 7)
+    NAME       'x'           (2, 4) (2, 5)
+    COLON      ':'           (2, 5) (2, 6)
+    FSTRING_MIDDLE 'a\\n    b\\n     c\\n      d\\n' (2, 6) (6, 0)
+    RBRACE     '}'           (6, 0) (6, 1)
+    FSTRING_MIDDLE '__'          (6, 1) (6, 3)
+    FSTRING_END "'''"         (6, 3) (6, 6)
+    """)
+
+    def test_function(self):
+
+        self.check_tokenize('def d22(a, b, c=2, d=2, *k): pass', """\
+    NAME       'def'         (1, 0) (1, 3)
+    NAME       'd22'         (1, 4) (1, 7)
+    LPAR       '('           (1, 7) (1, 8)
+    NAME       'a'           (1, 8) (1, 9)
+    COMMA      ','           (1, 9) (1, 10)
+    NAME       'b'           (1, 11) (1, 12)
+    COMMA      ','           (1, 12) (1, 13)
+    NAME       'c'           (1, 14) (1, 15)
+    EQUAL      '='           (1, 15) (1, 16)
+    NUMBER     '2'           (1, 16) (1, 17)
+    COMMA      ','           (1, 17) (1, 18)
+    NAME       'd'           (1, 19) (1, 20)
+    EQUAL      '='           (1, 20) (1, 21)
+    NUMBER     '2'           (1, 21) (1, 22)
+    COMMA      ','           (1, 22) (1, 23)
+    STAR       '*'           (1, 24) (1, 25)
+    NAME       'k'           (1, 25) (1, 26)
+    RPAR       ')'           (1, 26) (1, 27)
+    COLON      ':'           (1, 27) (1, 28)
+    NAME       'pass'        (1, 29) (1, 33)
+    """)
+
+        self.check_tokenize('def d01v_(a=1, *k, **w): pass', """\
+    NAME       'def'         (1, 0) (1, 3)
+    NAME       'd01v_'       (1, 4) (1, 9)
+    LPAR       '('           (1, 9) (1, 10)
+    NAME       'a'           (1, 10) (1, 11)
+    EQUAL      '='           (1, 11) (1, 12)
+    NUMBER     '1'           (1, 12) (1, 13)
+    COMMA      ','           (1, 13) (1, 14)
+    STAR       '*'           (1, 15) (1, 16)
+    NAME       'k'           (1, 16) (1, 17)
+    COMMA      ','           (1, 17) (1, 18)
+    DOUBLESTAR '**'          (1, 19) (1, 21)
+    NAME       'w'           (1, 21) (1, 22)
+    RPAR       ')'           (1, 22) (1, 23)
+    COLON      ':'           (1, 23) (1, 24)
+    NAME       'pass'        (1, 25) (1, 29)
+    """)
+
+        self.check_tokenize('def d23(a: str, b: int=3) -> int: pass', """\
+    NAME       'def'         (1, 0) (1, 3)
+    NAME       'd23'         (1, 4) (1, 7)
+    LPAR       '('           (1, 7) (1, 8)
+    NAME       'a'           (1, 8) (1, 9)
+    COLON      ':'           (1, 9) (1, 10)
+    NAME       'str'         (1, 11) (1, 14)
+    COMMA      ','           (1, 14) (1, 15)
+    NAME       'b'           (1, 16) (1, 17)
+    COLON      ':'           (1, 17) (1, 18)
+    NAME       'int'         (1, 19) (1, 22)
+    EQUAL      '='           (1, 22) (1, 23)
+    NUMBER     '3'           (1, 23) (1, 24)
+    RPAR       ')'           (1, 24) (1, 25)
+    RARROW     '->'          (1, 26) (1, 28)
+    NAME       'int'         (1, 29) (1, 32)
+    COLON      ':'           (1, 32) (1, 33)
+    NAME       'pass'        (1, 34) (1, 38)
+    """)
+
+    def test_comparison(self):
+
+        self.check_tokenize("if 1 < 1 > 1 == 1 >= 5 <= 0x15 <= 0x12 != "
+                            "1 and 5 in 1 not in 1 is 1 or 5 is not 1: pass", """\
+    NAME       'if'          (1, 0) (1, 2)
+    NUMBER     '1'           (1, 3) (1, 4)
+    LESS       '<'           (1, 5) (1, 6)
+    NUMBER     '1'           (1, 7) (1, 8)
+    GREATER    '>'           (1, 9) (1, 10)
+    NUMBER     '1'           (1, 11) (1, 12)
+    EQEQUAL    '=='          (1, 13) (1, 15)
+    NUMBER     '1'           (1, 16) (1, 17)
+    GREATEREQUAL '>='          (1, 18) (1, 20)
+    NUMBER     '5'           (1, 21) (1, 22)
+    LESSEQUAL  '<='          (1, 23) (1, 25)
+    NUMBER     '0x15'        (1, 26) (1, 30)
+    LESSEQUAL  '<='          (1, 31) (1, 33)
+    NUMBER     '0x12'        (1, 34) (1, 38)
+    NOTEQUAL   '!='          (1, 39) (1, 41)
+    NUMBER     '1'           (1, 42) (1, 43)
+    NAME       'and'         (1, 44) (1, 47)
+    NUMBER     '5'           (1, 48) (1, 49)
+    NAME       'in'          (1, 50) (1, 52)
+    NUMBER     '1'           (1, 53) (1, 54)
+    NAME       'not'         (1, 55) (1, 58)
+    NAME       'in'          (1, 59) (1, 61)
+    NUMBER     '1'           (1, 62) (1, 63)
+    NAME       'is'          (1, 64) (1, 66)
+    NUMBER     '1'           (1, 67) (1, 68)
+    NAME       'or'          (1, 69) (1, 71)
+    NUMBER     '5'           (1, 72) (1, 73)
+    NAME       'is'          (1, 74) (1, 76)
+    NAME       'not'         (1, 77) (1, 80)
+    NUMBER     '1'           (1, 81) (1, 82)
+    COLON      ':'           (1, 82) (1, 83)
+    NAME       'pass'        (1, 84) (1, 88)
+    """)
+
+    def test_additive(self):
+
+        self.check_tokenize('x = 1 - y + 15 - 1 + 0x124 + z + a[5]', """\
+    NAME       'x'           (1, 0) (1, 1)
+    EQUAL      '='           (1, 2) (1, 3)
+    NUMBER     '1'           (1, 4) (1, 5)
+    MINUS      '-'           (1, 6) (1, 7)
+    NAME       'y'           (1, 8) (1, 9)
+    PLUS       '+'           (1, 10) (1, 11)
+    NUMBER     '15'          (1, 12) (1, 14)
+    MINUS      '-'           (1, 15) (1, 16)
+    NUMBER     '1'           (1, 17) (1, 18)
+    PLUS       '+'           (1, 19) (1, 20)
+    NUMBER     '0x124'       (1, 21) (1, 26)
+    PLUS       '+'           (1, 27) (1, 28)
+    NAME       'z'           (1, 29) (1, 30)
+    PLUS       '+'           (1, 31) (1, 32)
+    NAME       'a'           (1, 33) (1, 34)
+    LSQB       '['           (1, 34) (1, 35)
+    NUMBER     '5'           (1, 35) (1, 36)
+    RSQB       ']'           (1, 36) (1, 37)
+    """)
+
+    def test_multiplicative(self):
+
+        self.check_tokenize('x = 1//1*1/5*12%0x12@42', """\
+    NAME       'x'           (1, 0) (1, 1)
+    EQUAL      '='           (1, 2) (1, 3)
+    NUMBER     '1'           (1, 4) (1, 5)
+    DOUBLESLASH '//'          (1, 5) (1, 7)
+    NUMBER     '1'           (1, 7) (1, 8)
+    STAR       '*'           (1, 8) (1, 9)
+    NUMBER     '1'           (1, 9) (1, 10)
+    SLASH      '/'           (1, 10) (1, 11)
+    NUMBER     '5'           (1, 11) (1, 12)
+    STAR       '*'           (1, 12) (1, 13)
+    NUMBER     '12'          (1, 13) (1, 15)
+    PERCENT    '%'           (1, 15) (1, 16)
+    NUMBER     '0x12'        (1, 16) (1, 20)
+    AT         '@'           (1, 20) (1, 21)
+    NUMBER     '42'          (1, 21) (1, 23)
+    """)
+
+    def test_unary(self):
+
+        self.check_tokenize('~1 ^ 1 & 1 |1 ^ -1', """\
+    TILDE      '~'           (1, 0) (1, 1)
+    NUMBER     '1'           (1, 1) (1, 2)
+    CIRCUMFLEX '^'           (1, 3) (1, 4)
+    NUMBER     '1'           (1, 5) (1, 6)
+    AMPER      '&'           (1, 7) (1, 8)
+    NUMBER     '1'           (1, 9) (1, 10)
+    VBAR       '|'           (1, 11) (1, 12)
+    NUMBER     '1'           (1, 12) (1, 13)
+    CIRCUMFLEX '^'           (1, 14) (1, 15)
+    MINUS      '-'           (1, 16) (1, 17)
+    NUMBER     '1'           (1, 17) (1, 18)
+    """)
+
+        self.check_tokenize('-1*1/1+1*1//1 - ---1**1', """\
+    MINUS      '-'           (1, 0) (1, 1)
+    NUMBER     '1'           (1, 1) (1, 2)
+    STAR       '*'           (1, 2) (1, 3)
+    NUMBER     '1'           (1, 3) (1, 4)
+    SLASH      '/'           (1, 4) (1, 5)
+    NUMBER     '1'           (1, 5) (1, 6)
+    PLUS       '+'           (1, 6) (1, 7)
+    NUMBER     '1'           (1, 7) (1, 8)
+    STAR       '*'           (1, 8) (1, 9)
+    NUMBER     '1'           (1, 9) (1, 10)
+    DOUBLESLASH '//'          (1, 10) (1, 12)
+    NUMBER     '1'           (1, 12) (1, 13)
+    MINUS      '-'           (1, 14) (1, 15)
+    MINUS      '-'           (1, 16) (1, 17)
+    MINUS      '-'           (1, 17) (1, 18)
+    MINUS      '-'           (1, 18) (1, 19)
+    NUMBER     '1'           (1, 19) (1, 20)
+    DOUBLESTAR '**'          (1, 20) (1, 22)
+    NUMBER     '1'           (1, 22) (1, 23)
+    """)
+
+    def test_selector(self):
+
+        self.check_tokenize("import sys, time\nx = sys.modules['time'].time()", """\
+    NAME       'import'      (1, 0) (1, 6)
+    NAME       'sys'         (1, 7) (1, 10)
+    COMMA      ','           (1, 10) (1, 11)
+    NAME       'time'        (1, 12) (1, 16)
+    NEWLINE    ''            (1, 16) (1, 16)
+    NAME       'x'           (2, 0) (2, 1)
+    EQUAL      '='           (2, 2) (2, 3)
+    NAME       'sys'         (2, 4) (2, 7)
+    DOT        '.'           (2, 7) (2, 8)
+    NAME       'modules'     (2, 8) (2, 15)
+    LSQB       '['           (2, 15) (2, 16)
+    STRING     "'time'"      (2, 16) (2, 22)
+    RSQB       ']'           (2, 22) (2, 23)
+    DOT        '.'           (2, 23) (2, 24)
+    NAME       'time'        (2, 24) (2, 28)
+    LPAR       '('           (2, 28) (2, 29)
+    RPAR       ')'           (2, 29) (2, 30)
+    """)
+
+    def test_method(self):
+
+        self.check_tokenize('@staticmethod\ndef foo(x,y): pass', """\
+    AT         '@'           (1, 0) (1, 1)
+    NAME       'staticmethod' (1, 1) (1, 13)
+    NEWLINE    ''            (1, 13) (1, 13)
+    NAME       'def'         (2, 0) (2, 3)
+    NAME       'foo'         (2, 4) (2, 7)
+    LPAR       '('           (2, 7) (2, 8)
+    NAME       'x'           (2, 8) (2, 9)
+    COMMA      ','           (2, 9) (2, 10)
+    NAME       'y'           (2, 10) (2, 11)
+    RPAR       ')'           (2, 11) (2, 12)
+    COLON      ':'           (2, 12) (2, 13)
+    NAME       'pass'        (2, 14) (2, 18)
+    """)
+
+    def test_tabs(self):
+
+        self.check_tokenize('@staticmethod\ndef foo(x,y): pass', """\
+    AT         '@'           (1, 0) (1, 1)
+    NAME       'staticmethod' (1, 1) (1, 13)
+    NEWLINE    ''            (1, 13) (1, 13)
+    NAME       'def'         (2, 0) (2, 3)
+    NAME       'foo'         (2, 4) (2, 7)
+    LPAR       '('           (2, 7) (2, 8)
+    NAME       'x'           (2, 8) (2, 9)
+    COMMA      ','           (2, 9) (2, 10)
+    NAME       'y'           (2, 10) (2, 11)
+    RPAR       ')'           (2, 11) (2, 12)
+    COLON      ':'           (2, 12) (2, 13)
+    NAME       'pass'        (2, 14) (2, 18)
+    """)
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    def test_async(self):
+
+        self.check_tokenize('async = 1', """\
+    NAME       'async'       (1, 0) (1, 5)
+    EQUAL      '='           (1, 6) (1, 7)
+    NUMBER     '1'           (1, 8) (1, 9)
+    """)
+
+        self.check_tokenize('a = (async = 1)', """\
+    NAME       'a'           (1, 0) (1, 1)
+    EQUAL      '='           (1, 2) (1, 3)
+    LPAR       '('           (1, 4) (1, 5)
+    NAME       'async'       (1, 5) (1, 10)
+    EQUAL      '='           (1, 11) (1, 12)
+    NUMBER     '1'           (1, 13) (1, 14)
+    RPAR       ')'           (1, 14) (1, 15)
+    """)
+
+        self.check_tokenize('async()', """\
+    NAME       'async'       (1, 0) (1, 5)
+    LPAR       '('           (1, 5) (1, 6)
+    RPAR       ')'           (1, 6) (1, 7)
+    """)
+
+        self.check_tokenize('class async(Bar):pass', """\
+    NAME       'class'       (1, 0) (1, 5)
+    NAME       'async'       (1, 6) (1, 11)
+    LPAR       '('           (1, 11) (1, 12)
+    NAME       'Bar'         (1, 12) (1, 15)
+    RPAR       ')'           (1, 15) (1, 16)
+    COLON      ':'           (1, 16) (1, 17)
+    NAME       'pass'        (1, 17) (1, 21)
+    """)
+
+        self.check_tokenize('class async:pass', """\
+    NAME       'class'       (1, 0) (1, 5)
+    NAME       'async'       (1, 6) (1, 11)
+    COLON      ':'           (1, 11) (1, 12)
+    NAME       'pass'        (1, 12) (1, 16)
+    """)
+
+        self.check_tokenize('await = 1', """\
+    NAME       'await'       (1, 0) (1, 5)
+    EQUAL      '='           (1, 6) (1, 7)
+    NUMBER     '1'           (1, 8) (1, 9)
+    """)
+
+        self.check_tokenize('foo.async', """\
+    NAME       'foo'         (1, 0) (1, 3)
+    DOT        '.'           (1, 3) (1, 4)
+    NAME       'async'       (1, 4) (1, 9)
+    """)
+
+        self.check_tokenize('async for a in b: pass', """\
+    NAME       'async'       (1, 0) (1, 5)
+    NAME       'for'         (1, 6) (1, 9)
+    NAME       'a'           (1, 10) (1, 11)
+    NAME       'in'          (1, 12) (1, 14)
+    NAME       'b'           (1, 15) (1, 16)
+    COLON      ':'           (1, 16) (1, 17)
+    NAME       'pass'        (1, 18) (1, 22)
+    """)
+
+        self.check_tokenize('async with a as b: pass', """\
+    NAME       'async'       (1, 0) (1, 5)
+    NAME       'with'        (1, 6) (1, 10)
+    NAME       'a'           (1, 11) (1, 12)
+    NAME       'as'          (1, 13) (1, 15)
+    NAME       'b'           (1, 16) (1, 17)
+    COLON      ':'           (1, 17) (1, 18)
+    NAME       'pass'        (1, 19) (1, 23)
+    """)
+
+        self.check_tokenize('async.foo', """\
+    NAME       'async'       (1, 0) (1, 5)
+    DOT        '.'           (1, 5) (1, 6)
+    NAME       'foo'         (1, 6) (1, 9)
+    """)
+
+        self.check_tokenize('async', """\
+    NAME       'async'       (1, 0) (1, 5)
+    """)
+
+        self.check_tokenize('async\n#comment\nawait', """\
+    NAME       'async'       (1, 0) (1, 5)
+    NEWLINE    ''            (1, 5) (1, 5)
+    NAME       'await'       (3, 0) (3, 5)
+    """)
+
+        self.check_tokenize('async\n...\nawait', """\
+    NAME       'async'       (1, 0) (1, 5)
+    NEWLINE    ''            (1, 5) (1, 5)
+    ELLIPSIS   '...'         (2, 0) (2, 3)
+    NEWLINE    ''            (2, 3) (2, 3)
+    NAME       'await'       (3, 0) (3, 5)
+    """)
+
+        self.check_tokenize('async\nawait', """\
+    NAME       'async'       (1, 0) (1, 5)
+    NEWLINE    ''            (1, 5) (1, 5)
+    NAME       'await'       (2, 0) (2, 5)
+    """)
+
+        self.check_tokenize('foo.async + 1', """\
+    NAME       'foo'         (1, 0) (1, 3)
+    DOT        '.'           (1, 3) (1, 4)
+    NAME       'async'       (1, 4) (1, 9)
+    PLUS       '+'           (1, 10) (1, 11)
+    NUMBER     '1'           (1, 12) (1, 13)
+    """)
+
+        self.check_tokenize('async def foo(): pass', """\
+    NAME       'async'       (1, 0) (1, 5)
+    NAME       'def'         (1, 6) (1, 9)
+    NAME       'foo'         (1, 10) (1, 13)
+    LPAR       '('           (1, 13) (1, 14)
+    RPAR       ')'           (1, 14) (1, 15)
+    COLON      ':'           (1, 15) (1, 16)
+    NAME       'pass'        (1, 17) (1, 21)
+    """)
+
+        self.check_tokenize('''\
+async def foo():
+  def foo(await):
+    await = 1
+  if 1:
+    await
+async += 1
+''', """\
+    NAME       'async'       (1, 0) (1, 5)
+    NAME       'def'         (1, 6) (1, 9)
+    NAME       'foo'         (1, 10) (1, 13)
+    LPAR       '('           (1, 13) (1, 14)
+    RPAR       ')'           (1, 14) (1, 15)
+    COLON      ':'           (1, 15) (1, 16)
+    NEWLINE    ''            (1, 16) (1, 16)
+    INDENT     ''            (2, -1) (2, -1)
+    NAME       'def'         (2, 2) (2, 5)
+    NAME       'foo'         (2, 6) (2, 9)
+    LPAR       '('           (2, 9) (2, 10)
+    NAME       'await'       (2, 10) (2, 15)
+    RPAR       ')'           (2, 15) (2, 16)
+    COLON      ':'           (2, 16) (2, 17)
+    NEWLINE    ''            (2, 17) (2, 17)
+    INDENT     ''            (3, -1) (3, -1)
+    NAME       'await'       (3, 4) (3, 9)
+    EQUAL      '='           (3, 10) (3, 11)
+    NUMBER     '1'           (3, 12) (3, 13)
+    NEWLINE    ''            (3, 13) (3, 13)
+    DEDENT     ''            (4, -1) (4, -1)
+    NAME       'if'          (4, 2) (4, 4)
+    NUMBER     '1'           (4, 5) (4, 6)
+    COLON      ':'           (4, 6) (4, 7)
+    NEWLINE    ''            (4, 7) (4, 7)
+    INDENT     ''            (5, -1) (5, -1)
+    NAME       'await'       (5, 4) (5, 9)
+    NEWLINE    ''            (5, 9) (5, 9)
+    DEDENT     ''            (6, -1) (6, -1)
+    DEDENT     ''            (6, -1) (6, -1)
+    NAME       'async'       (6, 0) (6, 5)
+    PLUSEQUAL  '+='          (6, 6) (6, 8)
+    NUMBER     '1'           (6, 9) (6, 10)
+    NEWLINE    ''            (6, 10) (6, 10)
+    """)
+
+        self.check_tokenize('async def foo():\n  async for i in 1: pass', """\
+    NAME       'async'       (1, 0) (1, 5)
+    NAME       'def'         (1, 6) (1, 9)
+    NAME       'foo'         (1, 10) (1, 13)
+    LPAR       '('           (1, 13) (1, 14)
+    RPAR       ')'           (1, 14) (1, 15)
+    COLON      ':'           (1, 15) (1, 16)
+    NEWLINE    ''            (1, 16) (1, 16)
+    INDENT     ''            (2, -1) (2, -1)
+    NAME       'async'       (2, 2) (2, 7)
+    NAME       'for'         (2, 8) (2, 11)
+    NAME       'i'           (2, 12) (2, 13)
+    NAME       'in'          (2, 14) (2, 16)
+    NUMBER     '1'           (2, 17) (2, 18)
+    COLON      ':'           (2, 18) (2, 19)
+    NAME       'pass'        (2, 20) (2, 24)
+    DEDENT     ''            (2, -1) (2, -1)
+    """)
+
+        self.check_tokenize('async def foo(async): await', """\
+    NAME       'async'       (1, 0) (1, 5)
+    NAME       'def'         (1, 6) (1, 9)
+    NAME       'foo'         (1, 10) (1, 13)
+    LPAR       '('           (1, 13) (1, 14)
+    NAME       'async'       (1, 14) (1, 19)
+    RPAR       ')'           (1, 19) (1, 20)
+    COLON      ':'           (1, 20) (1, 21)
+    NAME       'await'       (1, 22) (1, 27)
+    """)
+
+        self.check_tokenize('''\
+def f():
+
+  def baz(): pass
+  async def bar(): pass
+
+  await = 2''', """\
+    NAME       'def'         (1, 0) (1, 3)
+    NAME       'f'           (1, 4) (1, 5)
+    LPAR       '('           (1, 5) (1, 6)
+    RPAR       ')'           (1, 6) (1, 7)
+    COLON      ':'           (1, 7) (1, 8)
+    NEWLINE    ''            (1, 8) (1, 8)
+    INDENT     ''            (3, -1) (3, -1)
+    NAME       'def'         (3, 2) (3, 5)
+    NAME       'baz'         (3, 6) (3, 9)
+    LPAR       '('           (3, 9) (3, 10)
+    RPAR       ')'           (3, 10) (3, 11)
+    COLON      ':'           (3, 11) (3, 12)
+    NAME       'pass'        (3, 13) (3, 17)
+    NEWLINE    ''            (3, 17) (3, 17)
+    NAME       'async'       (4, 2) (4, 7)
+    NAME       'def'         (4, 8) (4, 11)
+    NAME       'bar'         (4, 12) (4, 15)
+    LPAR       '('           (4, 15) (4, 16)
+    RPAR       ')'           (4, 16) (4, 17)
+    COLON      ':'           (4, 17) (4, 18)
+    NAME       'pass'        (4, 19) (4, 23)
+    NEWLINE    ''            (4, 23) (4, 23)
+    NAME       'await'       (6, 2) (6, 7)
+    EQUAL      '='           (6, 8) (6, 9)
+    NUMBER     '2'           (6, 10) (6, 11)
+    DEDENT     ''            (6, -1) (6, -1)
+    """)
+
+        self.check_tokenize('''\
+async def f():
+
+  def baz(): pass
+  async def bar(): pass
+
+  await = 2''', """\
+    NAME       'async'       (1, 0) (1, 5)
+    NAME       'def'         (1, 6) (1, 9)
+    NAME       'f'           (1, 10) (1, 11)
+    LPAR       '('           (1, 11) (1, 12)
+    RPAR       ')'           (1, 12) (1, 13)
+    COLON      ':'           (1, 13) (1, 14)
+    NEWLINE    ''            (1, 14) (1, 14)
+    INDENT     ''            (3, -1) (3, -1)
+    NAME       'def'         (3, 2) (3, 5)
+    NAME       'baz'         (3, 6) (3, 9)
+    LPAR       '('           (3, 9) (3, 10)
+    RPAR       ')'           (3, 10) (3, 11)
+    COLON      ':'           (3, 11) (3, 12)
+    NAME       'pass'        (3, 13) (3, 17)
+    NEWLINE    ''            (3, 17) (3, 17)
+    NAME       'async'       (4, 2) (4, 7)
+    NAME       'def'         (4, 8) (4, 11)
+    NAME       'bar'         (4, 12) (4, 15)
+    LPAR       '('           (4, 15) (4, 16)
+    RPAR       ')'           (4, 16) (4, 17)
+    COLON      ':'           (4, 17) (4, 18)
+    NAME       'pass'        (4, 19) (4, 23)
+    NEWLINE    ''            (4, 23) (4, 23)
+    NAME       'await'       (6, 2) (6, 7)
+    EQUAL      '='           (6, 8) (6, 9)
+    NUMBER     '2'           (6, 10) (6, 11)
+    DEDENT     ''            (6, -1) (6, -1)
+    """)
+
+    def test_unicode(self):
+
+        self.check_tokenize("Örter = u'places'\ngrün = U'green'", """\
+    NAME       'Örter'       (1, 0) (1, 5)
+    EQUAL      '='           (1, 6) (1, 7)
+    STRING     "u'places'"   (1, 8) (1, 17)
+    NEWLINE    ''            (1, 17) (1, 17)
+    NAME       'grün'        (2, 0) (2, 4)
+    EQUAL      '='           (2, 5) (2, 6)
+    STRING     "U'green'"    (2, 7) (2, 15)
+    """)
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    def test_invalid_syntax(self):
+        def get_tokens(string):
+            the_string = StringIO(string)
+            return list(tokenize._generate_tokens_from_c_tokenizer(the_string.readline))
+
+        for case in [
+            "(1+2]",
+            "(1+2}",
+            "{1+2]",
+            "1_",
+            "1.2_",
+            "1e2_",
+            "1e+",
+
+            "\xa0",
+            "€",
+            "0b12",
+            "0b1_2",
+            "0b2",
+            "0b1_",
+            "0b",
+            "0o18",
+            "0o1_8",
+            "0o8",
+            "0o1_",
+            "0o",
+            "0x1_",
+            "0x",
+            "1_",
+            "012",
+            "1.2_",
+            "1e2_",
+            "1e+",
+            "'sdfsdf",
+            "'''sdfsdf''",
+            "("*1000+"a"+")"*1000,
+            "]",
+            """\
+            f'__{
+                x:d
+            }__'""",
+            " a\n\x00",
+        ]:
+            with self.subTest(case=case):
+                self.assertRaises(tokenize.TokenError, get_tokens, case)
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AssertionError: IndentationError not raised by <lambda>
+    @support.skip_wasi_stack_overflow()
+    def test_max_indent(self):
+        MAXINDENT = 100
+
+        def generate_source(indents):
+            source = ''.join(('  ' * x) + 'if True:\n' for x in range(indents))
+            source += '  ' * indents + 'pass\n'
+            return source
+
+        valid = generate_source(MAXINDENT - 1)
+        the_input = StringIO(valid)
+        tokens = list(tokenize._generate_tokens_from_c_tokenizer(the_input.readline))
+        self.assertEqual(tokens[-2].type, tokenize.DEDENT)
+        self.assertEqual(tokens[-1].type, tokenize.ENDMARKER)
+        compile(valid, "<string>", "exec")
+
+        invalid = generate_source(MAXINDENT)
+        the_input = StringIO(invalid)
+        self.assertRaises(IndentationError, lambda: list(tokenize._generate_tokens_from_c_tokenizer(the_input.readline)))
+        self.assertRaises(
+            IndentationError, compile, invalid, "<string>", "exec"
+        )
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; (0, '')]
+    def test_continuation_lines_indentation(self):
+        def get_tokens(string):
+            the_string = StringIO(string)
+            return [(kind, string) for (kind, string, *_)
+                    in tokenize._generate_tokens_from_c_tokenizer(the_string.readline)]
+
+        code = dedent("""
+            def fib(n):
+                \\
+            '''Print a Fibonacci series up to n.'''
+                \\
+            a, b = 0, 1
+        """)
+
+        self.check_tokenize(code, """\
+    NAME       'def'         (2, 0) (2, 3)
+    NAME       'fib'         (2, 4) (2, 7)
+    LPAR       '('           (2, 7) (2, 8)
+    NAME       'n'           (2, 8) (2, 9)
+    RPAR       ')'           (2, 9) (2, 10)
+    COLON      ':'           (2, 10) (2, 11)
+    NEWLINE    ''            (2, 11) (2, 11)
+    INDENT     ''            (4, -1) (4, -1)
+    STRING     "'''Print a Fibonacci series up to n.'''" (4, 0) (4, 39)
+    NEWLINE    ''            (4, 39) (4, 39)
+    NAME       'a'           (6, 0) (6, 1)
+    COMMA      ','           (6, 1) (6, 2)
+    NAME       'b'           (6, 3) (6, 4)
+    EQUAL      '='           (6, 5) (6, 6)
+    NUMBER     '0'           (6, 7) (6, 8)
+    COMMA      ','           (6, 8) (6, 9)
+    NUMBER     '1'           (6, 10) (6, 11)
+    NEWLINE    ''            (6, 11) (6, 11)
+    DEDENT     ''            (6, -1) (6, -1)
+        """)
+
+        code_no_cont = dedent("""
+            def fib(n):
+                '''Print a Fibonacci series up to n.'''
+                a, b = 0, 1
+        """)
+
+        self.assertEqual(get_tokens(code), get_tokens(code_no_cont))
+
+        code = dedent("""
+            pass
+                \\
+
+            pass
+        """)
+
+        self.check_tokenize(code, """\
+    NAME       'pass'        (2, 0) (2, 4)
+    NEWLINE    ''            (2, 4) (2, 4)
+    NAME       'pass'        (5, 0) (5, 4)
+    NEWLINE    ''            (5, 4) (5, 4)
+        """)
+
+        code_no_cont = dedent("""
+            pass
+            pass
+        """)
+
+        self.assertEqual(get_tokens(code), get_tokens(code_no_cont))
+
+        code = dedent("""
+            if x:
+                y = 1
+                \\
+                        \\
+                    \\
+                \\
+                foo = 1
+        """)
+
+        self.check_tokenize(code, """\
+    NAME       'if'          (2, 0) (2, 2)
+    NAME       'x'           (2, 3) (2, 4)
+    COLON      ':'           (2, 4) (2, 5)
+    NEWLINE    ''            (2, 5) (2, 5)
+    INDENT     ''            (3, -1) (3, -1)
+    NAME       'y'           (3, 4) (3, 5)
+    EQUAL      '='           (3, 6) (3, 7)
+    NUMBER     '1'           (3, 8) (3, 9)
+    NEWLINE    ''            (3, 9) (3, 9)
+    NAME       'foo'         (8, 4) (8, 7)
+    EQUAL      '='           (8, 8) (8, 9)
+    NUMBER     '1'           (8, 10) (8, 11)
+    NEWLINE    ''            (8, 11) (8, 11)
+    DEDENT     ''            (8, -1) (8, -1)
+        """)
+
+        code_no_cont = dedent("""
+            if x:
+                y = 1
+                foo = 1
+        """)
+
+        self.assertEqual(get_tokens(code), get_tokens(code_no_cont))
+
+
+class CTokenizerBufferTests(unittest.TestCase):
+    def test_newline_at_the_end_of_buffer(self):
+        # See issue 99581: Make sure that if we need to add a new line at the
+        # end of the buffer, we have enough space in the buffer, specially when
+        # the current line is as long as the buffer space available.
+        test_script = f"""\
+        #coding: latin-1
+        #{"a"*10000}
+        #{"a"*10002}"""
+        with os_helper.temp_dir() as temp_dir:
+            file_name = make_script(temp_dir, 'foo', test_script)
+            run_test_script(file_name)
+
+
+class CommandLineTest(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 re.sub(r'\s+', ' ', string).strip()
+
+    def set_source(self, content):
+        with open(self.filename, 'w') as fp:
+            fp.write(content)
+
+    def invoke_tokenize(self, *flags):
+        output = StringIO()
+        with contextlib.redirect_stdout(output):
+            tokenize._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_tokenize(*flags)
+            expect = self.text_normalize(expect)
+            self.assertListEqual(res.splitlines(), expect.splitlines())
+
+    def test_invocation(self):
+        # test various combinations of parameters
+        base_flags = ('-e', '--exact')
+
+        self.set_source('''
+            def f():
+                print(x)
+                return None
+        ''')
+
+        for flag in base_flags:
+            with self.subTest(args=flag):
+                _ = self.invoke_tokenize(flag)
+
+        with self.assertRaises(SystemExit):
+            # suppress argparse error message
+            with contextlib.redirect_stderr(StringIO()):
+                _ = self.invoke_tokenize('--unknown')
+
+    def test_without_flag(self):
+        # test 'python -m tokenize source.py'
+        source = 'a = 1'
+        expect = '''
+            0,0-0,0:            ENCODING       'utf-8'
+            1,0-1,1:            NAME           'a'
+            1,2-1,3:            OP             '='
+            1,4-1,5:            NUMBER         '1'
+            1,5-1,6:            NEWLINE        ''
+            2,0-2,0:            ENDMARKER      ''
+        '''
+        self.check_output(source, expect)
+
+    def test_exact_flag(self):
+        # test 'python -m tokenize -e/--exact source.py'
+        source = 'a = 1'
+        expect = '''
+            0,0-0,0:            ENCODING       'utf-8'
+            1,0-1,1:            NAME           'a'
+            1,2-1,3:            EQUAL          '='
+            1,4-1,5:            NUMBER         '1'
+            1,5-1,6:            NEWLINE        ''
+            2,0-2,0:            ENDMARKER      ''
+        '''
+        for flag in ['-e', '--exact']:
+            self.check_output(source, expect, flag)
+
+
+class StringPrefixTest(unittest.TestCase):
+    @staticmethod
+    def determine_valid_prefixes():
+        # Try all lengths until we find a length that has zero valid
+        # prefixes.  This will miss the case where for example there
+        # are no valid 3 character prefixes, but there are valid 4
+        # character prefixes.  That seems unlikely.
+
+        single_char_valid_prefixes = set()
+
+        # Find all of the single character string prefixes. Just get
+        # the lowercase version, we'll deal with combinations of upper
+        # and lower case later.  I'm using this logic just in case
+        # some uppercase-only prefix is added.
+        for letter in itertools.chain(string.ascii_lowercase, string.ascii_uppercase):
+            try:
+                eval(f'{letter}""')
+                single_char_valid_prefixes.add(letter.lower())
+            except SyntaxError:
+                pass
+
+        # This logic assumes that all combinations of valid prefixes only use
+        # the characters that are valid single character prefixes.  That seems
+        # like a valid assumption, but if it ever changes this will need
+        # adjusting.
+        valid_prefixes = set()
+        for length in itertools.count():
+            num_at_this_length = 0
+            for prefix in (
+                "".join(l)
+                for l in itertools.combinations(single_char_valid_prefixes, length)
+            ):
+                for t in itertools.permutations(prefix):
+                    for u in itertools.product(*[(c, c.upper()) for c in t]):
+                        p = "".join(u)
+                        if p == "not":
+                            # 'not' can never be a string prefix,
+                            # because it's a valid expression: not ""
+                            continue
+                        try:
+                            eval(f'{p}""')
+
+                            # No syntax error, so p is a valid string
+                            # prefix.
+
+                            valid_prefixes.add(p)
+                            num_at_this_length += 1
+                        except SyntaxError:
+                            pass
+            if num_at_this_length == 0:
+                return valid_prefixes
+
+
+    def test_prefixes(self):
+        # Get the list of defined string prefixes.  I don't see an
+        # obvious documented way of doing this, but probably the best
+        # thing is to split apart tokenize.StringPrefix.
+
+        # Make sure StringPrefix begins and ends in parens.  We're
+        # assuming it's of the form "(a|b|ab)", if a, b, and cd are
+        # valid string prefixes.
+        self.assertEqual(tokenize.StringPrefix[0], '(')
+        self.assertEqual(tokenize.StringPrefix[-1], ')')
+
+        # Then split apart everything else by '|'.
+        defined_prefixes = set(tokenize.StringPrefix[1:-1].split('|'))
+
+        # Now compute the actual allowed string prefixes and compare
+        # to what is defined in the tokenize module.
+        self.assertEqual(defined_prefixes, self.determine_valid_prefixes())
+
+
 if __name__ == "__main__":
     unittest.main()
diff --git a/Lib/test/test_tomllib/test_error.py b/Lib/test/test_tomllib/test_error.py
index 72446267f04..3a858749285 100644
--- a/Lib/test/test_tomllib/test_error.py
+++ b/Lib/test/test_tomllib/test_error.py
@@ -39,8 +39,19 @@ def test_invalid_char_quotes(self):
             tomllib.loads("v = '\n'")
         self.assertTrue(" '\\n' " in str(exc_info.exception))
 
+    def test_type_error(self):
+        with self.assertRaises(TypeError) as exc_info:
+            tomllib.loads(b"v = 1")  # type: ignore[arg-type]
+        self.assertEqual(str(exc_info.exception), "Expected str object, not 'bytes'")
+
+        with self.assertRaises(TypeError) as exc_info:
+            tomllib.loads(False)  # type: ignore[arg-type]
+        self.assertEqual(str(exc_info.exception), "Expected str object, not 'bool'")
+
     def test_module_name(self):
-        self.assertEqual(tomllib.TOMLDecodeError().__module__, tomllib.__name__)
+        self.assertEqual(
+            tomllib.TOMLDecodeError("", "", 0).__module__, tomllib.__name__
+        )
 
     def test_invalid_parse_float(self):
         def dict_returner(s: str) -> dict:
@@ -55,3 +66,33 @@ def list_returner(s: str) -> list:
             self.assertEqual(
                 str(exc_info.exception), "parse_float must not return dicts or lists"
             )
+
+    def test_deprecated_tomldecodeerror(self):
+        for args in [
+            (),
+            ("err msg",),
+            (None,),
+            (None, "doc"),
+            ("err msg", None),
+            (None, "doc", None),
+            ("err msg", "doc", None),
+            ("one", "two", "three", "four"),
+            ("one", "two", 3, "four", "five"),
+        ]:
+            with self.assertWarns(DeprecationWarning):
+                e = tomllib.TOMLDecodeError(*args)  # type: ignore[arg-type]
+            self.assertEqual(e.args, args)
+
+    def test_tomldecodeerror(self):
+        msg = "error parsing"
+        doc = "v=1\n[table]\nv='val'"
+        pos = 13
+        formatted_msg = "error parsing (at line 3, column 2)"
+        e = tomllib.TOMLDecodeError(msg, doc, pos)
+        self.assertEqual(e.args, (formatted_msg,))
+        self.assertEqual(str(e), formatted_msg)
+        self.assertEqual(e.msg, msg)
+        self.assertEqual(e.doc, doc)
+        self.assertEqual(e.pos, pos)
+        self.assertEqual(e.lineno, 3)
+        self.assertEqual(e.colno, 2)
diff --git a/Lib/test/test_tomllib/test_misc.py b/Lib/test/test_tomllib/test_misc.py
index 9e677a337a2..118fde24d88 100644
--- a/Lib/test/test_tomllib/test_misc.py
+++ b/Lib/test/test_tomllib/test_misc.py
@@ -5,6 +5,7 @@
 import copy
 import datetime
 from decimal import Decimal as D
+import importlib
 from pathlib import Path
 import sys
 import tempfile
@@ -92,6 +93,7 @@ def test_deepcopy(self):
         }
         self.assertEqual(obj_copy, expected_obj)
 
+    @support.skip_if_unlimited_stack_size
     def test_inline_array_recursion_limit(self):
         with support.infinite_recursion(max_depth=100):
             available = support.get_recursion_available()
@@ -103,6 +105,7 @@ def test_inline_array_recursion_limit(self):
                 recursive_array_toml = "arr = " + nest_count * "[" + nest_count * "]"
                 tomllib.loads(recursive_array_toml)
 
+    @support.skip_if_unlimited_stack_size
     def test_inline_table_recursion_limit(self):
         with support.infinite_recursion(max_depth=100):
             available = support.get_recursion_available()
@@ -113,3 +116,11 @@ def test_inline_table_recursion_limit(self):
                               nest_count=nest_count):
                 recursive_table_toml = nest_count * "key = {" + nest_count * "}"
                 tomllib.loads(recursive_table_toml)
+
+    def test_types_import(self):
+        """Test that `_types` module runs.
+
+        The module is for type annotations only, so it is otherwise
+        never imported by tests.
+        """
+        importlib.import_module(f"{tomllib.__name__}._types")
diff --git a/Lib/test/test_trace.py b/Lib/test/test_trace.py
index a90c9d0baaf..5968becf399 100644
--- a/Lib/test/test_trace.py
+++ b/Lib/test/test_trace.py
@@ -1,7 +1,7 @@
 import os
 from pickle import dump
 import sys
-from test.support import captured_stdout, requires_resource, requires_gil_enabled
+from test.support import captured_stdout, requires_resource
 from test.support.os_helper import (TESTFN, rmtree, unlink)
 from test.support.script_helper import assert_python_ok, assert_python_failure
 import textwrap
@@ -130,8 +130,7 @@ def setUp(self):
         self.tracer = Trace(count=1, trace=0, countfuncs=0, countcallers=0)
         self.my_py_filename = fix_ext_py(__file__)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; +  ('/Users/al03219714/Projects/RustPython4/crates/pylib/Lib/test/test_trace.py', 48): 1}
     def test_traced_func_linear(self):
         result = self.tracer.runfunc(traced_func_linear, 2, 5)
         self.assertEqual(result, 7)
@@ -144,8 +143,7 @@ def test_traced_func_linear(self):
 
         self.assertEqual(self.tracer.results().counts, expected)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; +  ('/Users/al03219714/Projects/RustPython4/crates/pylib/Lib/test/test_trace.py', 54): 1}
     def test_traced_func_loop(self):
         self.tracer.runfunc(traced_func_loop, 2, 3)
 
@@ -158,8 +156,7 @@ def test_traced_func_loop(self):
         }
         self.assertEqual(self.tracer.results().counts, expected)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; +  ('/Users/al03219714/Projects/RustPython4/crates/pylib/Lib/test/tracedmodules/testmod.py', 3): 1}
     def test_traced_func_importing(self):
         self.tracer.runfunc(traced_func_importing, 2, 5)
 
@@ -172,8 +169,7 @@ def test_traced_func_importing(self):
 
         self.assertEqual(self.tracer.results().counts, expected)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; +  ('/Users/al03219714/Projects/RustPython4/crates/pylib/Lib/test/test_trace.py', 76): 10}
     def test_trace_func_generator(self):
         self.tracer.runfunc(traced_func_calling_generator)
 
@@ -189,8 +185,7 @@ def test_trace_func_generator(self):
         }
         self.assertEqual(self.tracer.results().counts, expected)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; +  ('/Users/al03219714/Projects/RustPython4/crates/pylib/Lib/test/test_trace.py', 87): 1}
     def test_trace_list_comprehension(self):
         self.tracer.runfunc(traced_caller_list_comprehension)
 
@@ -204,8 +199,7 @@ def test_trace_list_comprehension(self):
         }
         self.assertEqual(self.tracer.results().counts, expected)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; Diff is 996 characters long. Set self.maxDiff to None to see it.
     def test_traced_decorated_function(self):
         self.tracer.runfunc(traced_decorated_function)
 
@@ -225,8 +219,7 @@ def test_traced_decorated_function(self):
         }
         self.assertEqual(self.tracer.results().counts, expected)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; + {('/Users/al03219714/Projects/RustPython4/crates/pylib/Lib/test/test_trace.py', 108): 1}
     def test_linear_methods(self):
         # XXX todo: later add 'static_method_linear' and 'class_method_linear'
         # here, once issue1764286 is resolved
@@ -250,8 +243,7 @@ def setUp(self):
         self.my_py_filename = fix_ext_py(__file__)
         self.addCleanup(sys.settrace, sys.gettrace())
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; KeyError: ('/Users/al03219714/Projects/RustPython4/crates/pylib/Lib/test/test_trace.py', 51)
     def test_exec_counts(self):
         self.tracer = Trace(count=1, trace=0, countfuncs=0, countcallers=0)
         code = r'''traced_func_loop(2, 5)'''
@@ -286,8 +278,6 @@ def tearDown(self):
         if self._saved_tracefunc is not None:
             sys.settrace(self._saved_tracefunc)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_simple_caller(self):
         self.tracer.runfunc(traced_func_simple_caller, 1)
 
@@ -305,8 +295,6 @@ def test_arg_errors(self):
         with self.assertRaises(TypeError):
             self.tracer.runfunc()
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_loop_caller_importing(self):
         self.tracer.runfunc(traced_func_importing_caller, 1)
 
@@ -319,11 +307,9 @@ def test_loop_caller_importing(self):
         }
         self.assertEqual(self.tracer.results().calledfuncs, expected)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     @unittest.skipIf(hasattr(sys, 'gettrace') and sys.gettrace(),
                      'pre-existing trace function throws off measurements')
-    @requires_gil_enabled("gh-117783: immortalization of types affects traced method names")
     def test_inst_method_calling(self):
         obj = TracedClass(20)
         self.tracer.runfunc(obj.inst_method_calling, 1)
@@ -335,8 +321,6 @@ def test_inst_method_calling(self):
         }
         self.assertEqual(self.tracer.results().calledfuncs, expected)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_traced_decorated_function(self):
         self.tracer.runfunc(traced_decorated_function)
 
@@ -357,11 +341,9 @@ def setUp(self):
         self.tracer = Trace(count=0, trace=0, countcallers=1)
         self.filemod = my_file_and_modname()
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     @unittest.skipIf(hasattr(sys, 'gettrace') and sys.gettrace(),
                      'pre-existing trace function throws off measurements')
-    @requires_gil_enabled("gh-117783: immortalization of types affects traced method names")
     def test_loop_caller_importing(self):
         self.tracer.runfunc(traced_func_importing_caller, 1)
 
@@ -401,8 +383,7 @@ def _coverage(self, tracer, cmd=DEFAULT_SCRIPT):
         r = tracer.results()
         r.write_results(show_missing=True, summary=True, coverdir=TESTFN)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AssertionError: 'pprint.py' not found in ''
     @requires_resource('cpu')
     def test_coverage(self):
         tracer = trace.Trace(trace=0, count=1)
@@ -427,8 +408,7 @@ def test_coverage_ignore(self):
             files = os.listdir(TESTFN)
             self.assertEqual(files, ['_importlib.cover'])  # Ignore __import__
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AssertionError: 'test.tracedmodules.testmod' not found in {}
     def test_issue9936(self):
         tracer = trace.Trace(trace=0, count=1)
         modname = 'test.tracedmodules.testmod'
@@ -444,7 +424,7 @@ def test_issue9936(self):
         coverage = {}
         for line in stdout:
             lines, cov, module = line.split()[:3]
-            coverage[module] = (int(lines), int(cov[:-1]))
+            coverage[module] = (float(lines), float(cov[:-1]))
         # XXX This is needed to run regrtest.py as a script
         modname = trace._fullmodname(sys.modules[modname].__file__)
         self.assertIn(modname, coverage)
@@ -493,8 +473,7 @@ def tearDown(self):
         unlink(self.codefile)
         unlink(self.coverfile)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; ---
     def test_cover_files_written_no_highlight(self):
         # Test also that the cover file for the trace module is not created
         # (issue #34171).
@@ -515,8 +494,7 @@ def test_cover_files_written_no_highlight(self):
                 "           print('unreachable')\n"
             )
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; ---
     def test_cover_files_written_with_highlight(self):
         argv = '-m trace --count --missing'.split() + [self.codefile]
         status, stdout, stderr = assert_python_ok(*argv)
@@ -544,8 +522,6 @@ def test_failures(self):
             *_, stderr = assert_python_failure('-m', 'trace', *args)
             self.assertIn(message, stderr)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_listfuncs_flag_success(self):
         filename = TESTFN + '.py'
         modulename = os.path.basename(TESTFN)
@@ -569,8 +545,7 @@ def test_sys_argv_list(self):
                                                         PYTHONIOENCODING='utf-8')
         self.assertIn(direct_stdout.strip(), trace_stdout)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AssertionError: 'lines   cov%   module   (path)' not found in ''
     def test_count_and_summary(self):
         filename = f'{TESTFN}.py'
         coverfilename = f'{TESTFN}.cover'
@@ -593,7 +568,7 @@ def f():
         stdout = stdout.decode()
         self.assertEqual(status, 0)
         self.assertIn('lines   cov%   module   (path)', stdout)
-        self.assertIn(f'6   100%   {modulename}   ({filename})', stdout)
+        self.assertIn(f'6   100.0%   {modulename}   ({filename})', stdout)
 
     def test_run_as_module(self):
         assert_python_ok('-m', 'trace', '-l', '--module', 'timeit', '-n', '1')
@@ -606,8 +581,7 @@ def setUp(self):
         self.tracer = Trace(count=0, trace=1)
         self.filemod = my_file_and_modname()
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; IndexError: list index out of range
     def test_no_source_file(self):
         filename = "<unknown>"
         co = traced_func_linear.__code__
diff --git a/Lib/test/test_traceback.py b/Lib/test/test_traceback.py
index 2ba7fbda5c3..e904c149d03 100644
--- a/Lib/test/test_traceback.py
+++ b/Lib/test/test_traceback.py
@@ -18,8 +18,8 @@
 from test.support import (Error, captured_output, cpython_only, ALWAYS_EQ,
                           requires_debug_ranges, has_no_debug_ranges,
                           requires_subprocess)
-from test.support.os_helper import TESTFN, unlink
-from test.support.script_helper import assert_python_ok, assert_python_failure
+from test.support.os_helper import TESTFN, temp_dir, unlink
+from test.support.script_helper import assert_python_ok, assert_python_failure, make_script
 from test.support.import_helper import forget
 from test.support import force_not_colorized, force_not_colorized_test_class
 
@@ -37,6 +37,12 @@
 test_frame = namedtuple('frame', ['f_code', 'f_globals', 'f_locals'])
 test_tb = namedtuple('tb', ['tb_frame', 'tb_lineno', 'tb_next', 'tb_lasti'])
 
+color_overrides = {"reset": "z", "filename": "fn", "error_highlight": "E"}
+colors = {
+    color_overrides.get(k, k[0].lower()): v
+    for k, v in _colorize.default_theme.traceback.items()
+}
+
 
 LEVENSHTEIN_DATA_FILE = Path(__file__).parent / 'levenshtein_examples.json'
 
@@ -82,13 +88,11 @@ def syntax_error_bad_indentation2(self):
     def tokenizer_error_with_caret_range(self):
         compile("blech  (  ", "?", "exec")
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_caret(self):
         err = self.get_exception_format(self.syntax_error_with_caret,
                                         SyntaxError)
         self.assertEqual(len(err), 4)
-        self.assertTrue(err[1].strip() == "return x!")
+        self.assertEqual(err[1].strip(), "return x!")
         self.assertIn("^", err[2]) # third line has caret
         self.assertEqual(err[1].find("!"), err[2].find("^")) # in the right place
         self.assertEqual(err[2].count("^"), 1)
@@ -196,8 +200,6 @@ def f():
         finally:
             unlink(TESTFN)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_bad_indentation(self):
         err = self.get_exception_format(self.syntax_error_bad_indentation,
                                         IndentationError)
@@ -404,8 +406,7 @@ def test_format_exception_group_syntax_error_with_custom_values(self):
                     self.assertEqual(len(err), 1)
                 self.assertEqual(err[-1], 'SyntaxError: error\n')
 
-    # TODO: RUSTPYTHON; IndexError: index out of range
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; IndexError: index out of range
     @requires_subprocess()
     @force_not_colorized
     def test_encoded_file(self):
@@ -449,16 +450,10 @@ def do_test(firstlines, message, charset, lineno):
             err_line = "raise RuntimeError('{0}')".format(message_ascii)
             err_msg = "RuntimeError: {0}".format(message_ascii)
 
-            self.assertIn(("line %s" % lineno), stdout[1],
-                "Invalid line number: {0!r} instead of {1}".format(
-                    stdout[1], lineno))
-            self.assertTrue(stdout[2].endswith(err_line),
-                "Invalid traceback line: {0!r} instead of {1!r}".format(
-                    stdout[2], err_line))
+            self.assertIn("line %s" % lineno, stdout[1])
+            self.assertEndsWith(stdout[2], err_line)
             actual_err_msg = stdout[3]
-            self.assertTrue(actual_err_msg == err_msg,
-                "Invalid error message: {0!r} instead of {1!r}".format(
-                    actual_err_msg, err_msg))
+            self.assertEqual(actual_err_msg, err_msg)
 
         do_test("", "foo", "ascii", 3)
         for charset in ("ascii", "iso-8859-1", "utf-8", "GBK"):
@@ -477,8 +472,6 @@ def do_test(firstlines, message, charset, lineno):
         # Issue #18960: coding spec should have no effect
         do_test("x=0\n# coding: GBK\n", "h\xe9 ho", 'utf-8', 5)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_print_traceback_at_exit(self):
         # Issue #22599: Ensure that it is possible to use the traceback module
         # to display an exception at Python exit
@@ -512,6 +505,33 @@ def __del__(self):
                     b'ZeroDivisionError: division by zero']
         self.assertEqual(stderr.splitlines(), expected)
 
+    @cpython_only
+    def test_lost_io_open(self):
+        # GH-142737: Display the traceback even if io.open is lost
+        crasher = textwrap.dedent("""\
+            import io
+            import traceback
+            # Trigger fallback mode
+            traceback._print_exception_bltin = None
+            del io.open
+            raise RuntimeError("should not crash")
+        """)
+
+        # Create a temporary script to exercise _Py_FindSourceFile
+        with temp_dir() as script_dir:
+            script = make_script(
+                script_dir=script_dir,
+                script_basename='tb_test_no_io_open',
+                source=crasher)
+            rc, stdout, stderr = assert_python_failure(script)
+
+        self.assertEqual(rc, 1)  # Make sure it's not a crash
+
+        expected = [b'Traceback (most recent call last):',
+                    f'  File "{script}", line 6, in <module>'.encode(),
+                    b'RuntimeError: should not crash']
+        self.assertEqual(stderr.splitlines(), expected)
+
     def test_print_exception(self):
         output = StringIO()
         traceback.print_exception(
@@ -614,13 +634,11 @@ def get_exception(self, callable, slice_start=0, slice_end=-1):
 class CAPIExceptionFormattingLegacyMixin(CAPIExceptionFormattingMixin):
     LEGACY = 1
 
-# @requires_debug_ranges() # XXX: RUSTPYTHON patch
+@requires_debug_ranges()
 class TracebackErrorLocationCaretTestBase:
     """
     Tests for printing code error expressions as part of PEP 657
     """
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_basic_caret(self):
         # NOTE: In caret tests, "if True:" is used as a way to force indicator
         #   display, since the raising expression spans only part of the line.
@@ -640,8 +658,6 @@ def f():
         result_lines = self.get_exception(f)
         self.assertEqual(result_lines, expected_f.splitlines())
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_line_with_unicode(self):
         # Make sure that even if a line contains multi-byte unicode characters
         # the correct carets are printed.
@@ -661,12 +677,11 @@ def f_with_unicode():
         result_lines = self.get_exception(f_with_unicode)
         self.assertEqual(result_lines, expected_f.splitlines())
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_caret_in_type_annotation(self):
         def f_with_type():
             def foo(a: THIS_DOES_NOT_EXIST ) -> int:
                 return 0
+            foo.__annotations__
 
         lineno_f = f_with_type.__code__.co_firstlineno
         expected_f = (
@@ -674,15 +689,15 @@ def foo(a: THIS_DOES_NOT_EXIST ) -> int:
             f'  File "{__file__}", line {self.callable_line}, in get_exception\n'
             '    callable()\n'
             '    ~~~~~~~~^^\n'
-            f'  File "{__file__}", line {lineno_f+1}, in f_with_type\n'
+            f'  File "{__file__}", line {lineno_f+3}, in f_with_type\n'
+            '    foo.__annotations__\n'
+            f'  File "{__file__}", line {lineno_f+1}, in __annotate__\n'
             '    def foo(a: THIS_DOES_NOT_EXIST ) -> int:\n'
             '               ^^^^^^^^^^^^^^^^^^^\n'
         )
         result_lines = self.get_exception(f_with_type)
         self.assertEqual(result_lines, expected_f.splitlines())
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_caret_multiline_expression(self):
         # Make sure no carets are printed for expressions spanning multiple
         # lines.
@@ -708,8 +723,6 @@ def f_with_multiline():
         result_lines = self.get_exception(f_with_multiline)
         self.assertEqual(result_lines, expected_f.splitlines())
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_caret_multiline_expression_syntax_error(self):
         # Make sure an expression spanning multiple lines that has
         # a syntax error is correctly marked with carets.
@@ -774,8 +787,6 @@ def f_with_multiline():
         result_lines = self.get_exception(f_with_multiline)
         self.assertEqual(result_lines, expected_f.splitlines())
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_caret_multiline_expression_bin_op(self):
         # Make sure no carets are printed for expressions spanning multiple
         # lines.
@@ -800,8 +811,6 @@ def f_with_multiline():
         result_lines = self.get_exception(f_with_multiline)
         self.assertEqual(result_lines, expected_f.splitlines())
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_caret_for_binary_operators(self):
         def f_with_binary_operator():
             divisor = 20
@@ -820,8 +829,6 @@ def f_with_binary_operator():
         result_lines = self.get_exception(f_with_binary_operator)
         self.assertEqual(result_lines, expected_error.splitlines())
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_caret_for_binary_operators_with_unicode(self):
         def f_with_binary_operator():
             áóí = 20
@@ -840,8 +847,6 @@ def f_with_binary_operator():
         result_lines = self.get_exception(f_with_binary_operator)
         self.assertEqual(result_lines, expected_error.splitlines())
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_caret_for_binary_operators_two_char(self):
         def f_with_binary_operator():
             divisor = 20
@@ -860,8 +865,6 @@ def f_with_binary_operator():
         result_lines = self.get_exception(f_with_binary_operator)
         self.assertEqual(result_lines, expected_error.splitlines())
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_caret_for_binary_operators_with_spaces_and_parenthesis(self):
         def f_with_binary_operator():
             a = 1
@@ -881,8 +884,6 @@ def f_with_binary_operator():
         result_lines = self.get_exception(f_with_binary_operator)
         self.assertEqual(result_lines, expected_error.splitlines())
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_caret_for_binary_operators_multiline(self):
         def f_with_binary_operator():
             b = 1
@@ -909,8 +910,6 @@ def f_with_binary_operator():
         result_lines = self.get_exception(f_with_binary_operator)
         self.assertEqual(result_lines, expected_error.splitlines())
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_caret_for_binary_operators_multiline_two_char(self):
         def f_with_binary_operator():
             b = 1
@@ -948,8 +947,6 @@ def f_with_binary_operator():
         result_lines = self.get_exception(f_with_binary_operator)
         self.assertEqual(result_lines, expected_error.splitlines())
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_caret_for_binary_operators_multiline_with_unicode(self):
         def f_with_binary_operator():
             b = 1
@@ -972,8 +969,6 @@ def f_with_binary_operator():
         result_lines = self.get_exception(f_with_binary_operator)
         self.assertEqual(result_lines, expected_error.splitlines())
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_caret_for_subscript(self):
         def f_with_subscript():
             some_dict = {'x': {'y': None}}
@@ -992,8 +987,6 @@ def f_with_subscript():
         result_lines = self.get_exception(f_with_subscript)
         self.assertEqual(result_lines, expected_error.splitlines())
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_caret_for_subscript_unicode(self):
         def f_with_subscript():
             some_dict = {'ó': {'á': {'í': {'theta': 1}}}}
@@ -1012,8 +1005,6 @@ def f_with_subscript():
         result_lines = self.get_exception(f_with_subscript)
         self.assertEqual(result_lines, expected_error.splitlines())
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_caret_for_subscript_with_spaces_and_parenthesis(self):
         def f_with_binary_operator():
             a = []
@@ -1033,8 +1024,6 @@ def f_with_binary_operator():
         result_lines = self.get_exception(f_with_binary_operator)
         self.assertEqual(result_lines, expected_error.splitlines())
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_caret_for_subscript_multiline(self):
         def f_with_subscript():
             bbbbb = {}
@@ -1071,8 +1060,6 @@ def f_with_subscript():
         result_lines = self.get_exception(f_with_subscript)
         self.assertEqual(result_lines, expected_error.splitlines())
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_caret_for_call(self):
         def f_with_call():
             def f1(a):
@@ -1096,8 +1083,6 @@ def f2(b):
         result_lines = self.get_exception(f_with_call)
         self.assertEqual(result_lines, expected_error.splitlines())
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_caret_for_call_unicode(self):
         def f_with_call():
             def f1(a):
@@ -1121,8 +1106,6 @@ def f2(b):
         result_lines = self.get_exception(f_with_call)
         self.assertEqual(result_lines, expected_error.splitlines())
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_caret_for_call_with_spaces_and_parenthesis(self):
         def f_with_binary_operator():
             def f(a):
@@ -1144,8 +1127,6 @@ def f(a):
         result_lines = self.get_exception(f_with_binary_operator)
         self.assertEqual(result_lines, expected_error.splitlines())
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_caret_for_call_multiline(self):
         def f_with_call():
             class C:
@@ -1179,8 +1160,6 @@ def g(x):
         result_lines = self.get_exception(f_with_call)
         self.assertEqual(result_lines, expected_error.splitlines())
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_many_lines(self):
         def f():
             x = 1
@@ -1205,8 +1184,6 @@ def f():
         result_lines = self.get_exception(f)
         self.assertEqual(result_lines, expected_error.splitlines())
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_many_lines_no_caret(self):
         def f():
             x = 1
@@ -1229,8 +1206,6 @@ def f():
         result_lines = self.get_exception(f)
         self.assertEqual(result_lines, expected_error.splitlines())
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_many_lines_binary_op(self):
         def f_with_binary_operator():
             b = 1
@@ -1269,8 +1244,6 @@ def f_with_binary_operator():
         result_lines = self.get_exception(f_with_binary_operator)
         self.assertEqual(result_lines, expected_error.splitlines())
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_traceback_specialization_with_syntax_error(self):
         bytecode = compile("1 / 0 / 1 / 2\n", TESTFN, "exec")
 
@@ -1294,8 +1267,6 @@ def test_traceback_specialization_with_syntax_error(self):
         )
         self.assertEqual(result_lines, expected_error.splitlines())
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_traceback_very_long_line(self):
         source = "if True: " + "a" * 256
         bytecode = compile(source, TESTFN, "exec")
@@ -1319,8 +1290,6 @@ def test_traceback_very_long_line(self):
         )
         self.assertEqual(result_lines, expected_error.splitlines())
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_secondary_caret_not_elided(self):
         # Always show a line's indicators if they include the secondary character.
         def f_with_subscript():
@@ -1340,8 +1309,6 @@ def f_with_subscript():
         result_lines = self.get_exception(f_with_subscript)
         self.assertEqual(result_lines, expected_error.splitlines())
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_caret_exception_group(self):
         # Notably, this covers whether indicators handle margin strings correctly.
         # (Exception groups use margin strings to display vertical indicators.)
@@ -1372,8 +1339,6 @@ def assertSpecialized(self, func, expected_specialization):
         specialization_line = result_lines[-1]
         self.assertEqual(specialization_line.lstrip(), expected_specialization)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_specialization_variations(self):
         self.assertSpecialized(lambda: 1/0,
                                       "~^~")
@@ -1406,8 +1371,6 @@ def test_specialization_variations(self):
         self.assertSpecialized(lambda: 1// 0,
                                       "~^^~~")
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_decorator_application_lineno_correct(self):
         def dec_error(func):
             raise TypeError
@@ -1452,8 +1415,6 @@ class A: pass
         )
         self.assertEqual(result_lines, expected_error.splitlines())
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_multiline_method_call_a(self):
         def f():
             (None
@@ -1471,8 +1432,6 @@ def f():
         ]
         self.assertEqual(actual, expected)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_multiline_method_call_b(self):
         def f():
             (None.
@@ -1489,8 +1448,6 @@ def f():
         ]
         self.assertEqual(actual, expected)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_multiline_method_call_c(self):
         def f():
             (None
@@ -1508,8 +1465,6 @@ def f():
         ]
         self.assertEqual(actual, expected)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_wide_characters_unicode_with_problematic_byte_offset(self):
         def f():
             ｗｉｄｔｈ
@@ -1526,8 +1481,6 @@ def f():
         self.assertEqual(actual, expected)
 
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_byte_offset_with_wide_characters_middle(self):
         def f():
             ｗｉｄｔｈ = 1
@@ -1544,8 +1497,6 @@ def f():
         ]
         self.assertEqual(actual, expected)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_byte_offset_multiline(self):
         def f():
             ｗｗｗ = 1
@@ -1568,8 +1519,6 @@ def f():
         ]
         self.assertEqual(actual, expected)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_byte_offset_with_wide_characters_term_highlight(self):
         def f():
             说明说明 = 1
@@ -1588,8 +1537,6 @@ def f():
         ]
         self.assertEqual(actual, expected)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_byte_offset_with_emojis_term_highlight(self):
         def f():
             return "✨🐍" + func_说明说明("📗🚛",
@@ -1607,8 +1554,6 @@ def f():
         ]
         self.assertEqual(actual, expected)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_byte_offset_wide_chars_subscript(self):
         def f():
             my_dct = {
@@ -1632,8 +1577,6 @@ def f():
         ]
         self.assertEqual(actual, expected)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_memory_error(self):
         def f():
             raise MemoryError()
@@ -1647,8 +1590,6 @@ def f():
             '    raise MemoryError()']
         self.assertEqual(actual, expected)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_anchors_for_simple_return_statements_are_elided(self):
         def g():
             1/0
@@ -1738,8 +1679,6 @@ def f():
         ]
         self.assertEqual(result_lines, expected)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_anchors_for_simple_assign_statements_are_elided(self):
         def g():
             1/0
@@ -1829,8 +1768,51 @@ def f():
         ]
         self.assertEqual(result_lines, expected)
 
-
-# @requires_debug_ranges() # XXX: RUSTPYTHON patch
+class TestKeywordTypoSuggestions(unittest.TestCase):
+    TYPO_CASES = [
+        ("with block ad something:\n  pass", "and"),
+        ("fur a in b:\n  pass", "for"),
+        ("for a in b:\n  pass\nelso:\n  pass", "else"),
+        ("whille True:\n  pass", "while"),
+        ("iff x > 5:\n  pass", "if"),
+        ("if x:\n  pass\nelseif y:\n  pass", "elif"),
+        ("tyo:\n  pass\nexcept y:\n  pass", "try"),
+        ("classe MyClass:\n  pass", "class"),
+        ("impor math", "import"),
+        ("form x import y", "from"),
+        ("defn calculate_sum(a, b):\n  return a + b", "def"),
+        ("def foo():\n  returm result", "return"),
+        ("lamda x: x ** 2", "lambda"),
+        ("def foo():\n  yeld i", "yield"),
+        ("def foo():\n  globel counter", "global"),
+        ("frum math import sqrt", "from"),
+        ("asynch def fetch_data():\n  pass", "async"),
+        ("async def foo():\n  awaid fetch_data()", "await"),
+        ('raisee ValueError("Error")', "raise"),
+        ("[x for x\nin range(3)\nof x]", "if"),
+        ("[123 fur x\nin range(3)\nif x]", "for"),
+        ("for x im n:\n  pass", "in"),
+    ]
+
+    def test_keyword_suggestions_from_file(self):
+        with tempfile.TemporaryDirectory() as script_dir:
+            for i, (code, expected_kw) in enumerate(self.TYPO_CASES):
+                with self.subTest(typo=expected_kw):
+                    source = textwrap.dedent(code).strip()
+                    script_name = make_script(script_dir, f"script_{i}", source)
+                    rc, stdout, stderr = assert_python_failure(script_name)
+                    stderr_text = stderr.decode('utf-8')
+                    self.assertIn(f"Did you mean '{expected_kw}'", stderr_text)
+
+    def test_keyword_suggestions_from_command_string(self):
+        for code, expected_kw in self.TYPO_CASES:
+            with self.subTest(typo=expected_kw):
+                source = textwrap.dedent(code).strip()
+                rc, stdout, stderr = assert_python_failure('-c', source)
+                stderr_text = stderr.decode('utf-8')
+                self.assertIn(f"Did you mean '{expected_kw}'", stderr_text)
+
+@requires_debug_ranges()
 @force_not_colorized_test_class
 class PurePythonTracebackErrorCaretTests(
     PurePythonExceptionFormattingMixin,
@@ -1842,9 +1824,121 @@ class PurePythonTracebackErrorCaretTests(
     traceback printing in traceback.py.
     """
 
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; +  '                ~~~~~~~~^^~~']
+    def test_caret_for_binary_operators_two_char(self):
+        return super().test_caret_for_binary_operators_two_char()
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; +  '                ~~~~~~~~^~~']
+    def test_caret_for_binary_operators(self):
+        return super().test_caret_for_binary_operators()
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; +  '           ~~~~~~^^^^^^^^^']
+    def test_caret_for_subscript_with_spaces_and_parenthesis(self):
+        return super().test_caret_for_subscript_with_spaces_and_parenthesis()
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; +  '           ~~~~~~~~~^~~~~~~~~~~~']
+    def test_byte_offset_with_wide_characters_term_highlight(self):
+        return super().test_byte_offset_with_wide_characters_term_highlight()
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; +  '           ~~~~~~~~~~^~']
+    def test_caret_for_binary_operators_with_spaces_and_parenthesis(self):
+        return super().test_caret_for_binary_operators_with_spaces_and_parenthesis()
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; +  '           ~~~~~~~~~~~~~~~~~~~^^^^^']
+    def test_caret_for_subscript(self):
+        return super().test_caret_for_subscript()
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; +  '           ~~~~~~~~~~~~~~~~~~~~~~~~^^^^^^']
+    def test_byte_offset_wide_chars_subscript(self):
+        return super().test_byte_offset_wide_chars_subscript()
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; +  '           ~~~~~~~~~~~~~~~~~~~~~~~~^^^^^^^^']
+    def test_caret_for_subscript_unicode(self):
+        return super().test_caret_for_subscript_unicode()
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; +  '          ~']
+    def test_caret_for_binary_operators_multiline(self):
+        return super().test_caret_for_binary_operators_multiline()
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; +  '        ~~~~~~^~~']
+    def test_caret_for_binary_operators_multiline_with_unicode(self):
+        return super().test_caret_for_binary_operators_multiline_with_unicode()
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; +  '    ^^^^^']
+    def test_traceback_specialization_with_syntax_error(self):
+        return super().test_traceback_specialization_with_syntax_error()
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; +  '    ^^^^^^^^^^^^^']
+    def test_caret_multiline_expression_syntax_error(self):
+        return super().test_caret_multiline_expression_syntax_error()
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; +  '    ~']
+    def test_caret_multiline_expression_bin_op(self):
+        return super().test_caret_multiline_expression_bin_op()
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; +  '    ~~~~~~~~~~~~~~~~~~~^^^^^']
+    def test_secondary_caret_not_elided(self):
+        return super().test_secondary_caret_not_elided()
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; + ~^~
+    def test_specialization_variations(self):
+        return super().test_specialization_variations()
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; -  '     ^^^^']
+    def test_multiline_method_call_b(self):
+        return super().test_multiline_method_call_b()
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; ?                   ^^^^ ++
+    def test_caret_for_binary_operators_with_unicode(self):
+        return super().test_caret_for_binary_operators_with_unicode()
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; ?        ++
+    def test_multiline_method_call_a(self):
+        return super().test_multiline_method_call_a()
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; ?        +++
+    def test_multiline_method_call_c(self):
+        return super().test_multiline_method_call_c()
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; ?       ^
+    def test_many_lines(self):
+        return super().test_many_lines()
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; ?       ^
+    def test_many_lines_no_caret(self):
+        return super().test_many_lines_no_caret()
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; ?       ^ +
+    def test_anchors_for_simple_assign_statements_are_elided(self):
+        return super().test_anchors_for_simple_assign_statements_are_elided()
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; ?       ^ +
+    def test_anchors_for_simple_return_statements_are_elided(self):
+        return super().test_anchors_for_simple_return_statements_are_elided()
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AssertionError: No exception thrown.
+    def test_caret_in_type_annotation(self):
+        return super().test_caret_in_type_annotation()
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; Diff is 652 characters long. Set self.maxDiff to None to see it.
+    def test_decorator_application_lineno_correct(self):
+        return super().test_decorator_application_lineno_correct()
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; Diff is 684 characters long. Set self.maxDiff to None to see it.
+    def test_many_lines_binary_op(self):
+        return super().test_many_lines_binary_op()
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; Diff is 726 characters long. Set self.maxDiff to None to see it.
+    def test_caret_for_binary_operators_multiline_two_char(self):
+        return super().test_caret_for_binary_operators_multiline_two_char()
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; Diff is 732 characters long. Set self.maxDiff to None to see it.
+    def test_caret_for_subscript_multiline(self):
+        return super().test_caret_for_subscript_multiline()
+
 
 @cpython_only
-# @requires_debug_ranges() # XXX: RUSTPYTHON patch
+@requires_debug_ranges()
 @force_not_colorized_test_class
 class CPythonTracebackErrorCaretTests(
     CAPIExceptionFormattingMixin,
@@ -1856,7 +1950,7 @@ class CPythonTracebackErrorCaretTests(
     """
 
 @cpython_only
-# @requires_debug_ranges() # XXX: RUSTPYTHON patch
+@requires_debug_ranges()
 @force_not_colorized_test_class
 class CPythonTracebackLegacyErrorCaretTests(
     CAPIExceptionFormattingLegacyMixin,
@@ -1928,9 +2022,9 @@ def check_traceback_format(self, cleanup_func=None):
         banner = tb_lines[0]
         self.assertEqual(len(tb_lines), 5)
         location, source_line = tb_lines[-2], tb_lines[-1]
-        self.assertTrue(banner.startswith('Traceback'))
-        self.assertTrue(location.startswith('  File'))
-        self.assertTrue(source_line.startswith('    raise'))
+        self.assertStartsWith(banner, 'Traceback')
+        self.assertStartsWith(location, '  File')
+        self.assertStartsWith(source_line, '    raise')
 
     def test_traceback_format(self):
         self.check_traceback_format()
@@ -2163,9 +2257,7 @@ def h(count=10):
         actual = stderr_g.getvalue().splitlines()
         self.assertEqual(actual, expected)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    # @requires_debug_ranges() # XXX: RUSTPYTHON patch
+    @requires_debug_ranges()
     def test_recursive_traceback(self):
         if self.DEBUG_RANGES:
             self._check_recursive_traceback_display(traceback.print_exc)
@@ -2221,6 +2313,7 @@ def deep_eg(self):
         return e
 
     @cpython_only
+    @support.skip_emscripten_stack_overflow()
     def test_exception_group_deep_recursion_capi(self):
         from _testcapi import exception_print
         LIMIT = 75
@@ -2232,6 +2325,7 @@ def test_exception_group_deep_recursion_capi(self):
         self.assertIn('ExceptionGroup', output)
         self.assertLessEqual(output.count('ExceptionGroup'), LIMIT)
 
+    @support.skip_emscripten_stack_overflow()
     def test_exception_group_deep_recursion_traceback(self):
         LIMIT = 75
         eg = self.deep_eg()
@@ -2309,12 +2403,12 @@ def zero_div(self):
     def check_zero_div(self, msg):
         lines = msg.splitlines()
         if has_no_debug_ranges():
-            self.assertTrue(lines[-3].startswith('  File'))
+            self.assertStartsWith(lines[-3], '  File')
             self.assertIn('1/0 # In zero_div', lines[-2])
         else:
-            self.assertTrue(lines[-4].startswith('  File'))
+            self.assertStartsWith(lines[-4], '  File')
             self.assertIn('1/0 # In zero_div', lines[-3])
-        self.assertTrue(lines[-1].startswith('ZeroDivisionError'), lines[-1])
+        self.assertStartsWith(lines[-1], 'ZeroDivisionError')
 
     def test_simple(self):
         try:
@@ -2324,12 +2418,12 @@ def test_simple(self):
         lines = self.get_report(e).splitlines()
         if has_no_debug_ranges():
             self.assertEqual(len(lines), 4)
-            self.assertTrue(lines[3].startswith('ZeroDivisionError'))
+            self.assertStartsWith(lines[3], 'ZeroDivisionError')
         else:
             self.assertEqual(len(lines), 5)
-            self.assertTrue(lines[4].startswith('ZeroDivisionError'))
-        self.assertTrue(lines[0].startswith('Traceback'))
-        self.assertTrue(lines[1].startswith('  File'))
+            self.assertStartsWith(lines[4], 'ZeroDivisionError')
+        self.assertStartsWith(lines[0], 'Traceback')
+        self.assertStartsWith(lines[1], '  File')
         self.assertIn('1/0 # Marker', lines[2])
 
     def test_cause(self):
@@ -2370,9 +2464,9 @@ def test_context_suppression(self):
             e = _
         lines = self.get_report(e).splitlines()
         self.assertEqual(len(lines), 4)
-        self.assertTrue(lines[3].startswith('ZeroDivisionError'))
-        self.assertTrue(lines[0].startswith('Traceback'))
-        self.assertTrue(lines[1].startswith('  File'))
+        self.assertStartsWith(lines[3], 'ZeroDivisionError')
+        self.assertStartsWith(lines[0], 'Traceback')
+        self.assertStartsWith(lines[1], '  File')
         self.assertIn('ZeroDivisionError from None', lines[2])
 
     def test_cause_and_context(self):
@@ -2653,8 +2747,6 @@ def __str__(self):
 
     # #### Exception Groups ####
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_exception_group_basic(self):
         def exc():
             raise ExceptionGroup("eg", [ValueError(1), TypeError(2)])
@@ -2676,8 +2768,6 @@ def exc():
         report = self.get_report(exc)
         self.assertEqual(report, expected)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_exception_group_cause(self):
         def exc():
             EG = ExceptionGroup
@@ -2714,8 +2804,6 @@ def exc():
         report = self.get_report(exc)
         self.assertEqual(report, expected)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_exception_group_context_with_context(self):
         def exc():
             EG = ExceptionGroup
@@ -2763,8 +2851,6 @@ def exc():
         report = self.get_report(exc)
         self.assertEqual(report, expected)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_exception_group_nested(self):
         def exc():
             EG = ExceptionGroup
@@ -2941,8 +3027,6 @@ def test_exception_group_depth_limit(self):
         report = self.get_report(exc)
         self.assertEqual(report, expected)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_exception_group_with_notes(self):
         def exc():
             try:
@@ -2993,8 +3077,6 @@ def exc():
         report = self.get_report(exc)
         self.assertEqual(report, expected)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_exception_group_with_multiple_notes(self):
         def exc():
             try:
@@ -3050,8 +3132,6 @@ def exc():
         report = self.get_report(exc)
         self.assertEqual(report, expected)
 
-    # TODO: RUSTPYTHON
-    '''
     def test_exception_group_wrapped_naked(self):
         # See gh-128799
 
@@ -3103,7 +3183,7 @@ def f():
         # remove trailing writespace:
         report = '\n'.join([l.rstrip() for l in report.split('\n')])
         self.assertEqual(report, expected)
-    '''
+
 
 @force_not_colorized_test_class
 class PyExcReportingTests(BaseExceptionReportingTests, unittest.TestCase):
@@ -3121,6 +3201,10 @@ def get_report(self, e):
         self.assertEqual(sio.getvalue(), s)
         return s
 
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; Diff is 1103 characters long. Set self.maxDiff to None to see it.
+    def test_exception_group_wrapped_naked(self):
+        return super().test_exception_group_wrapped_naked()
+
 
 @force_not_colorized_test_class
 class CExcReportingTests(BaseExceptionReportingTests, unittest.TestCase):
@@ -3172,8 +3256,7 @@ def last_returns_frame4(self):
     def last_returns_frame5(self):
         return self.last_returns_frame4()
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AssertionError: 1 not greater than 5
     def test_extract_stack(self):
         frame = self.last_returns_frame5()
         def extract(**kwargs):
@@ -3264,8 +3347,6 @@ class MiscTracebackCases(unittest.TestCase):
     # Check non-printing functions in traceback module
     #
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_clear(self):
         def outer():
             middle()
@@ -3348,11 +3429,17 @@ class TestStack(unittest.TestCase):
     def test_walk_stack(self):
         def deeper():
             return list(traceback.walk_stack(None))
-        s1 = list(traceback.walk_stack(None))
-        s2 = deeper()
+        s1, s2 = list(traceback.walk_stack(None)), deeper()
         self.assertEqual(len(s2) - len(s1), 1)
         self.assertEqual(s2[1:], s1)
 
+    def test_walk_innermost_frame(self):
+        def inner():
+            return list(traceback.walk_stack(None))
+        frames = inner()
+        innermost_frame, _ = frames[0]
+        self.assertEqual(innermost_frame.f_code.co_name, "inner")
+
     def test_walk_tb(self):
         try:
             1/0
@@ -3423,8 +3510,6 @@ def test_no_locals(self):
         s = traceback.StackSummary.extract(iter([(f, 6)]))
         self.assertEqual(s[0].locals, None)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_format_locals(self):
         def some_inner(k, v):
             a = 1
@@ -3441,8 +3526,6 @@ def some_inner(k, v):
              '    v = 4\n' % (__file__, some_inner.__code__.co_firstlineno + 3)
             ], s.format())
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_custom_format_frame(self):
         class CustomStackSummary(traceback.StackSummary):
             def format_frame_summary(self, frame_summary, colorize=False):
@@ -3485,8 +3568,6 @@ def format_frame_summary(self, frame_summary, colorize=False):
             f'  File "{__file__}", line {lno}, in f\n    1/0\n'
         )
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_summary_should_show_carets(self):
         # See: https://github.com/python/cpython/issues/122353
 
@@ -3643,8 +3724,6 @@ def test_context(self):
         self.assertEqual(type(exc_obj).__name__, exc.exc_type_str)
         self.assertEqual(str(exc_obj), str(exc))
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_long_context_chain(self):
         def f():
             try:
@@ -3726,6 +3805,7 @@ def test_no_save_exc_type(self):
             self.assertIsNone(te.exc_type)
 
     def test_no_refs_to_exception_and_traceback_objects(self):
+        exc_obj = None
         try:
             1/0
         except Exception as e:
@@ -3867,9 +3947,8 @@ def test_traceback_header(self):
         exc = traceback.TracebackException(Exception, Exception("haven"), None)
         self.assertEqual(list(exc.format()), ["Exception: haven\n"])
 
-    # @requires_debug_ranges() # XXX: RUSTPYTHON patch
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; ?                  ^ +
+    @requires_debug_ranges()
     def test_print(self):
         def f():
             x = 12
@@ -3972,8 +4051,6 @@ def test_exception_group_format_exception_onlyi_recursive(self):
 
         self.assertEqual(formatted, expected)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_exception_group_format(self):
         teg = traceback.TracebackException.from_exception(self.eg)
 
@@ -4318,8 +4395,6 @@ def raise_attribute_error_with_bad_name():
         )
         self.assertNotIn("?", result_lines[-1])
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_attribute_error_inside_nested_getattr(self):
         class A:
             bluch = 1
@@ -4363,8 +4438,6 @@ def callable():
         )
         return result_lines[0]
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_import_from_suggestions(self):
         substitution = textwrap.dedent("""\
             noise = more_noise = a = bc = None
@@ -4415,8 +4488,6 @@ def test_import_from_suggestions(self):
             actual = self.get_import_from_suggestion(code, 'bluch')
             self.assertIn(suggestion, actual)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_import_from_suggestions_underscored(self):
         code = "bluch = None"
         self.assertIn("'bluch'", self.get_import_from_suggestion(code, 'blach'))
@@ -4428,8 +4499,6 @@ def test_import_from_suggestions_underscored(self):
         self.assertIn("'_bluch'", self.get_import_from_suggestion(code, '_luch'))
         self.assertNotIn("'_bluch'", self.get_import_from_suggestion(code, 'bluch'))
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_import_from_suggestions_non_string(self):
         modWithNonStringAttr = textwrap.dedent("""\
             globals()[0] = 1
@@ -4779,9 +4848,8 @@ class MiscTest(unittest.TestCase):
 
     def test_all(self):
         expected = set()
-        denylist = {'print_list'}
         for name in dir(traceback):
-            if name.startswith('_') or name in denylist:
+            if name.startswith('_'):
                 continue
             module_object = getattr(traceback, name)
             if getattr(module_object, '__module__', None) == 'traceback':
@@ -4817,8 +4885,7 @@ def CHECK(a, b, expected):
         CHECK("AttributeError", "AttributeErrorTests", 10)
         CHECK("ABA", "AAB", 4)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AssertionError: /Users/al03219714/Projects/RustPython/crates/pylib/Lib/test/levenshtein_examples.json is missing. Run `make regen-test-levenshtein`
     @support.requires_resource('cpu')
     def test_levenshtein_distance_short_circuit(self):
         if not LEVENSHTEIN_DATA_FILE.is_file():
@@ -4875,8 +4942,8 @@ class MyList(list):
 
 
 class TestColorizedTraceback(unittest.TestCase):
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    maxDiff = None
+
     def test_colorized_traceback(self):
         def foo(*args):
             x = {'a':{'b': None}}
@@ -4899,9 +4966,9 @@ def bar():
                 e, capture_locals=True
             )
         lines = "".join(exc.format(colorize=True))
-        red = _colorize.ANSIColors.RED
-        boldr = _colorize.ANSIColors.BOLD_RED
-        reset = _colorize.ANSIColors.RESET
+        red = colors["e"]
+        boldr = colors["E"]
+        reset = colors["z"]
         self.assertIn("y = " + red + "x['a']['b']" + reset + boldr + "['c']" + reset, lines)
         self.assertIn("return " + red + "(lambda *args: foo(*args))" + reset + boldr + "(1,2,3,4)" + reset, lines)
         self.assertIn("return (lambda *args: " + red + "foo" + reset + boldr + "(*args)" + reset + ")(1,2,3,4)", lines)
@@ -4909,8 +4976,6 @@ def bar():
         self.assertIn("return baz1(1,\n            2,3\n            ,4)", lines)
         self.assertIn(red + "bar" + reset + boldr + "()" + reset, lines)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_colorized_syntax_error(self):
         try:
             compile("a $ b", "<string>", "exec")
@@ -4919,21 +4984,18 @@ def test_colorized_syntax_error(self):
                 e, capture_locals=True
             )
         actual = "".join(exc.format(colorize=True))
-        red = _colorize.ANSIColors.RED
-        magenta = _colorize.ANSIColors.MAGENTA
-        boldm = _colorize.ANSIColors.BOLD_MAGENTA
-        boldr = _colorize.ANSIColors.BOLD_RED
-        reset = _colorize.ANSIColors.RESET
-        expected = "".join([
-        f'  File {magenta}"<string>"{reset}, line {magenta}1{reset}\n',
-        f'    a {boldr}${reset} b\n',
-        f'      {boldr}^{reset}\n',
-        f'{boldm}SyntaxError{reset}: {magenta}invalid syntax{reset}\n']
-        )
-        self.assertIn(expected, actual)
+        def expected(t, m, fn, l, f, E, e, z):
+            return "".join(
+                [
+                    f'  File {fn}"<string>"{z}, line {l}1{z}\n',
+                    f'    a {E}${z} b\n',
+                    f'      {E}^{z}\n',
+                    f'{t}SyntaxError{z}: {m}invalid syntax{z}\n'
+                ]
+            )
+        self.assertIn(expected(**colors), actual)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; ModuleNotFoundError: No module named '_testcapi'
     def test_colorized_traceback_is_the_default(self):
         def foo():
             1/0
@@ -4948,26 +5010,22 @@ def foo():
                     exception_print(e)
             actual = tbstderr.getvalue().splitlines()
 
-        red = _colorize.ANSIColors.RED
-        boldr = _colorize.ANSIColors.BOLD_RED
-        magenta = _colorize.ANSIColors.MAGENTA
-        boldm = _colorize.ANSIColors.BOLD_MAGENTA
-        reset = _colorize.ANSIColors.RESET
         lno_foo = foo.__code__.co_firstlineno
-        expected = ['Traceback (most recent call last):',
-            f'  File {magenta}"{__file__}"{reset}, '
-            f'line {magenta}{lno_foo+5}{reset}, in {magenta}test_colorized_traceback_is_the_default{reset}',
-            f'    {red}foo{reset+boldr}(){reset}',
-            f'    {red}~~~{reset+boldr}^^{reset}',
-            f'  File {magenta}"{__file__}"{reset}, '
-            f'line {magenta}{lno_foo+1}{reset}, in {magenta}foo{reset}',
-            f'    {red}1{reset+boldr}/{reset+red}0{reset}',
-            f'    {red}~{reset+boldr}^{reset+red}~{reset}',
-            f'{boldm}ZeroDivisionError{reset}: {magenta}division by zero{reset}']
-        self.assertEqual(actual, expected)
+        def expected(t, m, fn, l, f, E, e, z):
+            return [
+                'Traceback (most recent call last):',
+                f'  File {fn}"{__file__}"{z}, '
+                f'line {l}{lno_foo+5}{z}, in {f}test_colorized_traceback_is_the_default{z}',
+                f'    {e}foo{z}{E}(){z}',
+                f'    {e}~~~{z}{E}^^{z}',
+                f'  File {fn}"{__file__}"{z}, '
+                f'line {l}{lno_foo+1}{z}, in {f}foo{z}',
+                f'    {e}1{z}{E}/{z}{e}0{z}',
+                f'    {e}~{z}{E}^{z}{e}~{z}',
+                f'{t}ZeroDivisionError{z}: {m}division by zero{z}',
+            ]
+        self.assertEqual(actual, expected(**colors))
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_colorized_traceback_from_exception_group(self):
         def foo():
             exceptions = []
@@ -4984,33 +5042,31 @@ def foo():
                 e, capture_locals=True
             )
 
-        red = _colorize.ANSIColors.RED
-        boldr = _colorize.ANSIColors.BOLD_RED
-        magenta = _colorize.ANSIColors.MAGENTA
-        boldm = _colorize.ANSIColors.BOLD_MAGENTA
-        reset = _colorize.ANSIColors.RESET
         lno_foo = foo.__code__.co_firstlineno
         actual = "".join(exc.format(colorize=True)).splitlines()
-        expected = [f"  + Exception Group Traceback (most recent call last):",
-                   f'  |   File {magenta}"{__file__}"{reset}, line {magenta}{lno_foo+9}{reset}, in {magenta}test_colorized_traceback_from_exception_group{reset}',
-                   f'  |     {red}foo{reset}{boldr}(){reset}',
-                   f'  |     {red}~~~{reset}{boldr}^^{reset}',
-                   f"  |     e = ExceptionGroup('test', [ZeroDivisionError('division by zero')])",
-                   f"  |     foo = {foo}",
-                   f'  |     self = <{__name__}.TestColorizedTraceback testMethod=test_colorized_traceback_from_exception_group>',
-                   f'  |   File {magenta}"{__file__}"{reset}, line {magenta}{lno_foo+6}{reset}, in {magenta}foo{reset}',
-                   f'  |     raise ExceptionGroup("test", exceptions)',
-                   f"  |     exceptions = [ZeroDivisionError('division by zero')]",
-                   f'  | {boldm}ExceptionGroup{reset}: {magenta}test (1 sub-exception){reset}',
-                   f'  +-+---------------- 1 ----------------',
-                   f'    | Traceback (most recent call last):',
-                   f'    |   File {magenta}"{__file__}"{reset}, line {magenta}{lno_foo+3}{reset}, in {magenta}foo{reset}',
-                   f'    |     {red}1 {reset}{boldr}/{reset}{red} 0{reset}',
-                   f'    |     {red}~~{reset}{boldr}^{reset}{red}~~{reset}',
-                   f"    |     exceptions = [ZeroDivisionError('division by zero')]",
-                   f'    | {boldm}ZeroDivisionError{reset}: {magenta}division by zero{reset}',
-                   f'    +------------------------------------']
-        self.assertEqual(actual, expected)
+        def expected(t, m, fn, l, f, E, e, z):
+            return [
+                f"  + Exception Group Traceback (most recent call last):",
+                f'  |   File {fn}"{__file__}"{z}, line {l}{lno_foo+9}{z}, in {f}test_colorized_traceback_from_exception_group{z}',
+                f'  |     {e}foo{z}{E}(){z}',
+                f'  |     {e}~~~{z}{E}^^{z}',
+                f"  |     e = ExceptionGroup('test', [ZeroDivisionError('division by zero')])",
+                f"  |     foo = {foo}",
+                f'  |     self = <{__name__}.TestColorizedTraceback testMethod=test_colorized_traceback_from_exception_group>',
+                f'  |   File {fn}"{__file__}"{z}, line {l}{lno_foo+6}{z}, in {f}foo{z}',
+                f'  |     raise ExceptionGroup("test", exceptions)',
+                f"  |     exceptions = [ZeroDivisionError('division by zero')]",
+                f'  | {t}ExceptionGroup{z}: {m}test (1 sub-exception){z}',
+                f'  +-+---------------- 1 ----------------',
+                f'    | Traceback (most recent call last):',
+                f'    |   File {fn}"{__file__}"{z}, line {l}{lno_foo+3}{z}, in {f}foo{z}',
+                f'    |     {e}1 {z}{E}/{z}{e} 0{z}',
+                f'    |     {e}~~{z}{E}^{z}{e}~~{z}',
+                f"    |     exceptions = [ZeroDivisionError('division by zero')]",
+                f'    | {t}ZeroDivisionError{z}: {m}division by zero{z}',
+                f'    +------------------------------------',
+        ]
+        self.assertEqual(actual, expected(**colors))
 
 if __name__ == "__main__":
     unittest.main()
diff --git a/Lib/test/test_tstring.py b/Lib/test/test_tstring.py
new file mode 100644
index 00000000000..a1f686c8f56
--- /dev/null
+++ b/Lib/test/test_tstring.py
@@ -0,0 +1,295 @@
+import unittest
+
+from test.test_string._support import TStringBaseCase, fstring
+
+
+class TestTString(unittest.TestCase, TStringBaseCase):
+    def test_string_representation(self):
+        # Test __repr__
+        t = t"Hello"
+        self.assertEqual(repr(t), "Template(strings=('Hello',), interpolations=())")
+
+        name = "Python"
+        t = t"Hello, {name}"
+        self.assertEqual(repr(t),
+            "Template(strings=('Hello, ', ''), "
+            "interpolations=(Interpolation('Python', 'name', None, ''),))"
+        )
+
+    def test_interpolation_basics(self):
+        # Test basic interpolation
+        name = "Python"
+        t = t"Hello, {name}"
+        self.assertTStringEqual(t, ("Hello, ", ""), [(name, "name")])
+        self.assertEqual(fstring(t), "Hello, Python")
+
+        # Multiple interpolations
+        first = "Python"
+        last = "Developer"
+        t = t"{first} {last}"
+        self.assertTStringEqual(
+            t, ("", " ", ""), [(first, 'first'), (last, 'last')]
+        )
+        self.assertEqual(fstring(t), "Python Developer")
+
+        # Interpolation with expressions
+        a = 10
+        b = 20
+        t = t"Sum: {a + b}"
+        self.assertTStringEqual(t, ("Sum: ", ""), [(a + b, "a + b")])
+        self.assertEqual(fstring(t), "Sum: 30")
+
+        # Interpolation with function
+        def square(x):
+            return x * x
+        t = t"Square: {square(5)}"
+        self.assertTStringEqual(
+            t, ("Square: ", ""), [(square(5), "square(5)")]
+        )
+        self.assertEqual(fstring(t), "Square: 25")
+
+        # Test attribute access in expressions
+        class Person:
+            def __init__(self, name):
+                self.name = name
+
+            def upper(self):
+                return self.name.upper()
+
+        person = Person("Alice")
+        t = t"Name: {person.name}"
+        self.assertTStringEqual(
+            t, ("Name: ", ""), [(person.name, "person.name")]
+        )
+        self.assertEqual(fstring(t), "Name: Alice")
+
+        # Test method calls
+        t = t"Name: {person.upper()}"
+        self.assertTStringEqual(
+            t, ("Name: ", ""), [(person.upper(), "person.upper()")]
+        )
+        self.assertEqual(fstring(t), "Name: ALICE")
+
+        # Test dictionary access
+        data = {"name": "Bob", "age": 30}
+        t = t"Name: {data['name']}, Age: {data['age']}"
+        self.assertTStringEqual(
+            t, ("Name: ", ", Age: ", ""),
+            [(data["name"], "data['name']"), (data["age"], "data['age']")],
+        )
+        self.assertEqual(fstring(t), "Name: Bob, Age: 30")
+
+    def test_format_specifiers(self):
+        # Test basic format specifiers
+        value = 3.14159
+        t = t"Pi: {value:.2f}"
+        self.assertTStringEqual(
+            t, ("Pi: ", ""), [(value, "value", None, ".2f")]
+        )
+        self.assertEqual(fstring(t), "Pi: 3.14")
+
+    def test_conversions(self):
+        # Test !s conversion (str)
+        obj = object()
+        t = t"Object: {obj!s}"
+        self.assertTStringEqual(t, ("Object: ", ""), [(obj, "obj", "s")])
+        self.assertEqual(fstring(t), f"Object: {str(obj)}")
+
+        # Test !r conversion (repr)
+        t = t"Data: {obj!r}"
+        self.assertTStringEqual(t, ("Data: ", ""), [(obj, "obj", "r")])
+        self.assertEqual(fstring(t), f"Data: {repr(obj)}")
+
+        # Test !a conversion (ascii)
+        text = "Café"
+        t = t"ASCII: {text!a}"
+        self.assertTStringEqual(t, ("ASCII: ", ""), [(text, "text", "a")])
+        self.assertEqual(fstring(t), f"ASCII: {ascii(text)}")
+
+        # Test !z conversion (error)
+        num = 1
+        with self.assertRaises(SyntaxError):
+            eval("t'{num!z}'")
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; ?          ++++++
+    def test_debug_specifier(self):
+        # Test debug specifier
+        value = 42
+        t = t"Value: {value=}"
+        self.assertTStringEqual(
+            t, ("Value: value=", ""), [(value, "value", "r")]
+        )
+        self.assertEqual(fstring(t), "Value: value=42")
+
+        # Test debug specifier with format (conversion default to !r)
+        t = t"Value: {value=:.2f}"
+        self.assertTStringEqual(
+            t, ("Value: value=", ""), [(value, "value", None, ".2f")]
+        )
+        self.assertEqual(fstring(t), "Value: value=42.00")
+
+        # Test debug specifier with conversion
+        t = t"Value: {value=!s}"
+        self.assertTStringEqual(
+            t, ("Value: value=", ""), [(value, "value", "s")]
+        )
+
+        # Test white space in debug specifier
+        t = t"Value: {value = }"
+        self.assertTStringEqual(
+            t, ("Value: value = ", ""), [(value, "value", "r")]
+        )
+        self.assertEqual(fstring(t), "Value: value = 42")
+
+    def test_raw_tstrings(self):
+        path = r"C:\Users"
+        t = rt"{path}\Documents"
+        self.assertTStringEqual(t, ("", r"\Documents"), [(path, "path")])
+        self.assertEqual(fstring(t), r"C:\Users\Documents")
+
+        # Test alternative prefix
+        t = tr"{path}\Documents"
+        self.assertTStringEqual(t, ("", r"\Documents"), [(path, "path")])
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AssertionError: "can only concatenate string.templatelib.Template \(not "str"\) to string.templatelib.Template" does not match "can only concatenate Template (not 'str') to Template"
+    def test_template_concatenation(self):
+        # Test template + template
+        t1 = t"Hello, "
+        t2 = t"world"
+        combined = t1 + t2
+        self.assertTStringEqual(combined, ("Hello, world",), ())
+        self.assertEqual(fstring(combined), "Hello, world")
+
+        # Test template + string
+        t1 = t"Hello"
+        expected_msg = 'can only concatenate string.templatelib.Template ' \
+            '\\(not "str"\\) to string.templatelib.Template'
+        with self.assertRaisesRegex(TypeError, expected_msg):
+            t1 + ", world"
+
+        # Test template + template with interpolation
+        name = "Python"
+        t1 = t"Hello, "
+        t2 = t"{name}"
+        combined = t1 + t2
+        self.assertTStringEqual(combined, ("Hello, ", ""), [(name, "name")])
+        self.assertEqual(fstring(combined), "Hello, Python")
+
+        # Test string + template
+        expected_msg = 'can only concatenate str ' \
+            '\\(not "string.templatelib.Template"\\) to str'
+        with self.assertRaisesRegex(TypeError, expected_msg):
+            "Hello, " + t"{name}"
+
+    def test_nested_templates(self):
+        # Test a template inside another template expression
+        name = "Python"
+        inner = t"{name}"
+        t = t"Language: {inner}"
+
+        t_interp = t.interpolations[0]
+        self.assertEqual(t.strings, ("Language: ", ""))
+        self.assertEqual(t_interp.value.strings, ("", ""))
+        self.assertEqual(t_interp.value.interpolations[0].value, name)
+        self.assertEqual(t_interp.value.interpolations[0].expression, "name")
+        self.assertEqual(t_interp.value.interpolations[0].conversion, None)
+        self.assertEqual(t_interp.value.interpolations[0].format_spec, "")
+        self.assertEqual(t_interp.expression, "inner")
+        self.assertEqual(t_interp.conversion, None)
+        self.assertEqual(t_interp.format_spec, "")
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON multiple instances of AssertionError
+    def test_syntax_errors(self):
+        for case, err in (
+            ("t'", "unterminated t-string literal"),
+            ("t'''", "unterminated triple-quoted t-string literal"),
+            ("t''''", "unterminated triple-quoted t-string literal"),
+            ("t'{", "'{' was never closed"),
+            ("t'{'", "t-string: expecting '}'"),
+            ("t'{a'", "t-string: expecting '}'"),
+            ("t'}'", "t-string: single '}' is not allowed"),
+            ("t'{}'", "t-string: valid expression required before '}'"),
+            ("t'{=x}'", "t-string: valid expression required before '='"),
+            ("t'{!x}'", "t-string: valid expression required before '!'"),
+            ("t'{:x}'", "t-string: valid expression required before ':'"),
+            ("t'{x;y}'", "t-string: expecting '=', or '!', or ':', or '}'"),
+            ("t'{x=y}'", "t-string: expecting '!', or ':', or '}'"),
+            ("t'{x!s!}'", "t-string: expecting ':' or '}'"),
+            ("t'{x!s:'", "t-string: expecting '}', or format specs"),
+            ("t'{x!}'", "t-string: missing conversion character"),
+            ("t'{x=!}'", "t-string: missing conversion character"),
+            ("t'{x!z}'", "t-string: invalid conversion character 'z': "
+                         "expected 's', 'r', or 'a'"),
+            ("t'{lambda:1}'", "t-string: lambda expressions are not allowed "
+                              "without parentheses"),
+            ("t'{x:{;}}'", "t-string: expecting a valid expression after '{'"),
+            ("t'{1:d\n}'", "t-string: newlines are not allowed in format specifiers")
+        ):
+            with self.subTest(case), self.assertRaisesRegex(SyntaxError, err):
+                eval(case)
+
+    def test_runtime_errors(self):
+        # Test missing variables
+        with self.assertRaises(NameError):
+            eval("t'Hello, {name}'")
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    def test_literal_concatenation(self):
+        # Test concatenation of t-string literals
+        t = t"Hello, " t"world"
+        self.assertTStringEqual(t, ("Hello, world",), ())
+        self.assertEqual(fstring(t), "Hello, world")
+
+        # Test concatenation with interpolation
+        name = "Python"
+        t = t"Hello, " t"{name}"
+        self.assertTStringEqual(t, ("Hello, ", ""), [(name, "name")])
+        self.assertEqual(fstring(t), "Hello, Python")
+
+        # Test disallowed mix of t-string and string/f-string (incl. bytes)
+        what = 't'
+        expected_msg = 'cannot mix t-string literals with string or bytes literals'
+        for case in (
+            "t'{what}-string literal' 'str literal'",
+            "t'{what}-string literal' u'unicode literal'",
+            "t'{what}-string literal' f'f-string literal'",
+            "t'{what}-string literal' r'raw string literal'",
+            "t'{what}-string literal' rf'raw f-string literal'",
+            "t'{what}-string literal' b'bytes literal'",
+            "t'{what}-string literal' br'raw bytes literal'",
+            "'str literal' t'{what}-string literal'",
+            "u'unicode literal' t'{what}-string literal'",
+            "f'f-string literal' t'{what}-string literal'",
+            "r'raw string literal' t'{what}-string literal'",
+            "rf'raw f-string literal' t'{what}-string literal'",
+            "b'bytes literal' t'{what}-string literal'",
+            "br'raw bytes literal' t'{what}-string literal'",
+        ):
+            with self.subTest(case):
+                with self.assertRaisesRegex(SyntaxError, expected_msg):
+                    eval(case)
+
+    def test_triple_quoted(self):
+        # Test triple-quoted t-strings
+        t = t"""
+        Hello,
+        world
+        """
+        self.assertTStringEqual(
+            t, ("\n        Hello,\n        world\n        ",), ()
+        )
+        self.assertEqual(fstring(t), "\n        Hello,\n        world\n        ")
+
+        # Test triple-quoted with interpolation
+        name = "Python"
+        t = t"""
+        Hello,
+        {name}
+        """
+        self.assertTStringEqual(
+            t, ("\n        Hello,\n        ", "\n        "), [(name, "name")]
+        )
+        self.assertEqual(fstring(t), "\n        Hello,\n        Python\n        ")
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/Lib/test/test_tuple.py b/Lib/test/test_tuple.py
index 153df0e52dd..a97ca8c9ad3 100644
--- a/Lib/test/test_tuple.py
+++ b/Lib/test/test_tuple.py
@@ -42,8 +42,7 @@ def test_keyword_args(self):
         with self.assertRaisesRegex(TypeError, 'keyword argument'):
             tuple(sequence=())
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_keywords_in_subclass(self):
         class subclass(tuple):
             pass
@@ -292,12 +291,18 @@ def test_repr(self):
         self.assertEqual(repr(a0), "()")
         self.assertEqual(repr(a2), "(0, 1, 2)")
 
+    # Checks that t is not tracked without any GC collections.
+    def _not_tracked_instantly(self, t):
+        self.assertFalse(gc.is_tracked(t), t)
+
+    # Checks that t is not tracked after GC collection.
     def _not_tracked(self, t):
         # Nested tuples can take several collections to untrack
         gc.collect()
         gc.collect()
         self.assertFalse(gc.is_tracked(t), t)
 
+    # Checks that t continues to be tracked even after GC collection.
     def _tracked(self, t):
         self.assertTrue(gc.is_tracked(t), t)
         gc.collect()
@@ -309,13 +314,19 @@ def test_track_literals(self):
         # Test GC-optimization of tuple literals
         x, y, z = 1.5, "a", []
 
-        self._not_tracked(())
-        self._not_tracked((1,))
-        self._not_tracked((1, 2))
-        self._not_tracked((1, 2, "a"))
-        self._not_tracked((1, 2, (None, True, False, ()), int))
-        self._not_tracked((object(),))
+        # We check that those objects aren't tracked at all.
+        # It's essential for the GC performance, see gh-139951.
+        self._not_tracked_instantly(())
+        self._not_tracked_instantly((1,))
+        self._not_tracked_instantly((1, 2))
+        self._not_tracked_instantly((1, 2, "a"))
+        self._not_tracked_instantly((1, 2) * 5)
+        self._not_tracked_instantly((12, 10**10, 'a_' * 100))
+        self._not_tracked_instantly((object(),))
+
         self._not_tracked(((1, x), y, (2, 3)))
+        self._not_tracked((1, 2, (None, True, False, ()), int))
+        self._not_tracked((object(), ()))
 
         # Tuples with mutable elements are always tracked, even if those
         # elements are not tracked right now.
@@ -345,6 +356,12 @@ def check_track_dynamic(self, tp, always_track):
         self._tracked(tp(tuple([obj]) for obj in [x, y, z]))
         self._tracked(tuple(tp([obj]) for obj in [x, y, z]))
 
+        t = tp([1, x, y, z])
+        self.assertEqual(type(t), tp)
+        self._tracked(t)
+        self.assertEqual(type(t[:]), tuple)
+        self._tracked(t[:])
+
     @support.cpython_only
     def test_track_dynamic(self):
         # Test GC-optimization of dynamically constructed tuples.
diff --git a/Lib/test/test_type_aliases.py b/Lib/test/test_type_aliases.py
new file mode 100644
index 00000000000..ee1791bc1d0
--- /dev/null
+++ b/Lib/test/test_type_aliases.py
@@ -0,0 +1,415 @@
+import pickle
+import types
+import unittest
+from test.support import check_syntax_error, run_code
+from test.typinganndata import mod_generics_cache
+
+from typing import (
+    Callable, TypeAliasType, TypeVar, TypeVarTuple, ParamSpec, Unpack, get_args,
+)
+
+
+class TypeParamsInvalidTest(unittest.TestCase):
+    def test_name_collisions(self):
+        check_syntax_error(self, 'type TA1[A, **A] = None', "duplicate type parameter 'A'")
+        check_syntax_error(self, 'type T[A, *A] = None', "duplicate type parameter 'A'")
+        check_syntax_error(self, 'type T[*A, **A] = None', "duplicate type parameter 'A'")
+
+    def test_name_non_collision_02(self):
+        ns = run_code("""type TA1[A] = lambda A: A""")
+        self.assertIsInstance(ns["TA1"], TypeAliasType)
+        self.assertTrue(callable(ns["TA1"].__value__))
+        self.assertEqual("arg", ns["TA1"].__value__("arg"))
+
+    def test_name_non_collision_03(self):
+        ns = run_code("""
+            class Outer[A]:
+                type TA1[A] = None
+            """
+        )
+        outer_A, = ns["Outer"].__type_params__
+        inner_A, = ns["Outer"].TA1.__type_params__
+        self.assertIsNot(outer_A, inner_A)
+
+
+class TypeParamsAccessTest(unittest.TestCase):
+    def test_alias_access_01(self):
+        ns = run_code("type TA1[A, B] = dict[A, B]")
+        alias = ns["TA1"]
+        self.assertIsInstance(alias, TypeAliasType)
+        self.assertEqual(alias.__type_params__, get_args(alias.__value__))
+
+    def test_alias_access_02(self):
+        ns = run_code("""
+            type TA1[A, B] = TA1[A, B] | int
+            """
+        )
+        alias = ns["TA1"]
+        self.assertIsInstance(alias, TypeAliasType)
+        A, B = alias.__type_params__
+        self.assertEqual(alias.__value__, alias[A, B] | int)
+
+    def test_alias_access_03(self):
+        ns = run_code("""
+            class Outer[A]:
+                def inner[B](self):
+                    type TA1[C] = TA1[A, B] | int
+                    return TA1
+            """
+        )
+        cls = ns["Outer"]
+        A, = cls.__type_params__
+        B, = cls.inner.__type_params__
+        alias = cls.inner(None)
+        self.assertIsInstance(alias, TypeAliasType)
+        alias2 = cls.inner(None)
+        self.assertIsNot(alias, alias2)
+        self.assertEqual(len(alias.__type_params__), 1)
+
+        self.assertEqual(alias.__value__, alias[A, B] | int)
+
+
+class TypeParamsAliasValueTest(unittest.TestCase):
+    def test_alias_value_01(self):
+        type TA1 = int
+
+        self.assertIsInstance(TA1, TypeAliasType)
+        self.assertEqual(TA1.__value__, int)
+        self.assertEqual(TA1.__parameters__, ())
+        self.assertEqual(TA1.__type_params__, ())
+
+        type TA2 = TA1 | str
+
+        self.assertIsInstance(TA2, TypeAliasType)
+        a, b = TA2.__value__.__args__
+        self.assertEqual(a, TA1)
+        self.assertEqual(b, str)
+        self.assertEqual(TA2.__parameters__, ())
+        self.assertEqual(TA2.__type_params__, ())
+
+    def test_alias_value_02(self):
+        class Parent[A]:
+            type TA1[B] = dict[A, B]
+
+        self.assertIsInstance(Parent.TA1, TypeAliasType)
+        self.assertEqual(len(Parent.TA1.__parameters__), 1)
+        self.assertEqual(len(Parent.__parameters__), 1)
+        a, = Parent.__parameters__
+        b, = Parent.TA1.__parameters__
+        self.assertEqual(Parent.__type_params__, (a,))
+        self.assertEqual(Parent.TA1.__type_params__, (b,))
+        self.assertEqual(Parent.TA1.__value__, dict[a, b])
+
+    def test_alias_value_03(self):
+        def outer[A]():
+            type TA1[B] = dict[A, B]
+            return TA1
+
+        o = outer()
+        self.assertIsInstance(o, TypeAliasType)
+        self.assertEqual(len(o.__parameters__), 1)
+        self.assertEqual(len(outer.__type_params__), 1)
+        b = o.__parameters__[0]
+        self.assertEqual(o.__type_params__, (b,))
+
+    def test_alias_value_04(self):
+        def more_generic[T, *Ts, **P]():
+            type TA[T2, *Ts2, **P2] = tuple[Callable[P, tuple[T, *Ts]], Callable[P2, tuple[T2, *Ts2]]]
+            return TA
+
+        alias = more_generic()
+        self.assertIsInstance(alias, TypeAliasType)
+        T2, Ts2, P2 = alias.__type_params__
+        self.assertEqual(alias.__parameters__, (T2, *Ts2, P2))
+        T, Ts, P = more_generic.__type_params__
+        self.assertEqual(alias.__value__, tuple[Callable[P, tuple[T, *Ts]], Callable[P2, tuple[T2, *Ts2]]])
+
+    def test_subscripting(self):
+        type NonGeneric = int
+        type Generic[A] = dict[A, A]
+        type VeryGeneric[T, *Ts, **P] = Callable[P, tuple[T, *Ts]]
+
+        with self.assertRaises(TypeError):
+            NonGeneric[int]
+
+        specialized = Generic[int]
+        self.assertIsInstance(specialized, types.GenericAlias)
+        self.assertIs(specialized.__origin__, Generic)
+        self.assertEqual(specialized.__args__, (int,))
+
+        specialized2 = VeryGeneric[int, str, float, [bool, range]]
+        self.assertIsInstance(specialized2, types.GenericAlias)
+        self.assertIs(specialized2.__origin__, VeryGeneric)
+        self.assertEqual(specialized2.__args__, (int, str, float, [bool, range]))
+
+    def test_repr(self):
+        type Simple = int
+        type VeryGeneric[T, *Ts, **P] = Callable[P, tuple[T, *Ts]]
+
+        self.assertEqual(repr(Simple), "Simple")
+        self.assertEqual(repr(VeryGeneric), "VeryGeneric")
+        self.assertEqual(repr(VeryGeneric[int, bytes, str, [float, object]]),
+                         "VeryGeneric[int, bytes, str, [float, object]]")
+        self.assertEqual(repr(VeryGeneric[int, []]),
+                         "VeryGeneric[int, []]")
+        self.assertEqual(repr(VeryGeneric[int, [VeryGeneric[int], list[str]]]),
+                         "VeryGeneric[int, [VeryGeneric[int], list[str]]]")
+
+    def test_recursive_repr(self):
+        type Recursive = Recursive
+        self.assertEqual(repr(Recursive), "Recursive")
+
+        type X = list[Y]
+        type Y = list[X]
+        self.assertEqual(repr(X), "X")
+        self.assertEqual(repr(Y), "Y")
+
+        type GenericRecursive[X] = list[X | GenericRecursive[X]]
+        self.assertEqual(repr(GenericRecursive), "GenericRecursive")
+        self.assertEqual(repr(GenericRecursive[int]), "GenericRecursive[int]")
+        self.assertEqual(repr(GenericRecursive[GenericRecursive[int]]),
+                         "GenericRecursive[GenericRecursive[int]]")
+
+    def test_raising(self):
+        type MissingName = list[_My_X]
+        with self.assertRaisesRegex(
+            NameError,
+            "cannot access free variable '_My_X' where it is not associated with a value",
+        ):
+            MissingName.__value__
+        _My_X = int
+        self.assertEqual(MissingName.__value__, list[int])
+        del _My_X
+        # Cache should still work:
+        self.assertEqual(MissingName.__value__, list[int])
+
+        # Explicit exception:
+        type ExprException = 1 / 0
+        with self.assertRaises(ZeroDivisionError):
+            ExprException.__value__
+
+
+class TypeAliasConstructorTest(unittest.TestCase):
+    def test_basic(self):
+        TA = TypeAliasType("TA", int)
+        self.assertEqual(TA.__name__, "TA")
+        self.assertIs(TA.__value__, int)
+        self.assertEqual(TA.__type_params__, ())
+        self.assertEqual(TA.__module__, __name__)
+
+    def test_attributes_with_exec(self):
+        ns = {}
+        exec("type TA = int", ns, ns)
+        TA = ns["TA"]
+        self.assertEqual(TA.__name__, "TA")
+        self.assertIs(TA.__value__, int)
+        self.assertEqual(TA.__type_params__, ())
+        self.assertIs(TA.__module__, None)
+
+    def test_generic(self):
+        T = TypeVar("T")
+        TA = TypeAliasType("TA", list[T], type_params=(T,))
+        self.assertEqual(TA.__name__, "TA")
+        self.assertEqual(TA.__value__, list[T])
+        self.assertEqual(TA.__type_params__, (T,))
+        self.assertEqual(TA.__module__, __name__)
+        self.assertIs(type(TA[int]), types.GenericAlias)
+
+    def test_not_generic(self):
+        TA = TypeAliasType("TA", list[int], type_params=())
+        self.assertEqual(TA.__name__, "TA")
+        self.assertEqual(TA.__value__, list[int])
+        self.assertEqual(TA.__type_params__, ())
+        self.assertEqual(TA.__module__, __name__)
+        with self.assertRaisesRegex(
+            TypeError,
+            "Only generic type aliases are subscriptable",
+        ):
+            TA[int]
+
+    def test_type_params_order_with_defaults(self):
+        HasNoDefaultT = TypeVar("HasNoDefaultT")
+        WithDefaultT = TypeVar("WithDefaultT", default=int)
+
+        HasNoDefaultP = ParamSpec("HasNoDefaultP")
+        WithDefaultP = ParamSpec("WithDefaultP", default=HasNoDefaultP)
+
+        HasNoDefaultTT = TypeVarTuple("HasNoDefaultTT")
+        WithDefaultTT = TypeVarTuple("WithDefaultTT", default=HasNoDefaultTT)
+
+        for type_params in [
+            (HasNoDefaultT, WithDefaultT),
+            (HasNoDefaultP, WithDefaultP),
+            (HasNoDefaultTT, WithDefaultTT),
+        ]:
+            with self.subTest(type_params=type_params):
+                TypeAliasType("A", int, type_params=type_params)  # ok
+
+        msg = "follows default type parameter"
+        for type_params in [
+            (WithDefaultT, HasNoDefaultT),
+            (WithDefaultP, HasNoDefaultP),
+            (WithDefaultTT, HasNoDefaultTT),
+            (WithDefaultT, HasNoDefaultP),  # different types
+        ]:
+            with self.subTest(type_params=type_params):
+                with self.assertRaisesRegex(TypeError, msg):
+                    TypeAliasType("A", int, type_params=type_params)
+
+    def test_expects_type_like(self):
+        T = TypeVar("T")
+
+        msg = "Expected a type param"
+        with self.assertRaisesRegex(TypeError, msg):
+            TypeAliasType("A", int, type_params=(1,))
+        with self.assertRaisesRegex(TypeError, msg):
+            TypeAliasType("A", int, type_params=(1, 2))
+        with self.assertRaisesRegex(TypeError, msg):
+            TypeAliasType("A", int, type_params=(T, 2))
+
+    def test_keywords(self):
+        TA = TypeAliasType(name="TA", value=int)
+        self.assertEqual(TA.__name__, "TA")
+        self.assertIs(TA.__value__, int)
+        self.assertEqual(TA.__type_params__, ())
+        self.assertEqual(TA.__module__, __name__)
+
+    def test_errors(self):
+        with self.assertRaises(TypeError):
+            TypeAliasType()
+        with self.assertRaises(TypeError):
+            TypeAliasType("TA")
+        with self.assertRaises(TypeError):
+            TypeAliasType("TA", list, ())
+        with self.assertRaises(TypeError):
+            TypeAliasType("TA", list, type_params=42)
+
+
+class TypeAliasTypeTest(unittest.TestCase):
+    def test_immutable(self):
+        with self.assertRaises(TypeError):
+            TypeAliasType.whatever = "not allowed"
+
+    def test_no_subclassing(self):
+        with self.assertRaisesRegex(TypeError, "not an acceptable base type"):
+            class MyAlias(TypeAliasType):
+                pass
+
+    def test_union(self):
+        type Alias1 = int
+        type Alias2 = str
+        union = Alias1 | Alias2
+        self.assertIsInstance(union, types.UnionType)
+        self.assertEqual(get_args(union), (Alias1, Alias2))
+        union2 = Alias1 | list[float]
+        self.assertIsInstance(union2, types.UnionType)
+        self.assertEqual(get_args(union2), (Alias1, list[float]))
+        union3 = list[range] | Alias1
+        self.assertIsInstance(union3, types.UnionType)
+        self.assertEqual(get_args(union3), (list[range], Alias1))
+
+    def test_module(self):
+        self.assertEqual(TypeAliasType.__module__, "typing")
+        type Alias = int
+        self.assertEqual(Alias.__module__, __name__)
+        self.assertEqual(mod_generics_cache.Alias.__module__,
+                         mod_generics_cache.__name__)
+        self.assertEqual(mod_generics_cache.OldStyle.__module__,
+                         mod_generics_cache.__name__)
+
+    def test_unpack(self):
+        type Alias = tuple[int, int]
+        unpacked = (*Alias,)[0]
+        self.assertEqual(unpacked, Unpack[Alias])
+
+        class Foo[*Ts]:
+            pass
+
+        x = Foo[str, *Alias]
+        self.assertEqual(x.__args__, (str, Unpack[Alias]))
+
+
+# All these type aliases are used for pickling tests:
+T = TypeVar('T')
+type SimpleAlias = int
+type RecursiveAlias = dict[str, RecursiveAlias]
+type GenericAlias[X] = list[X]
+type GenericAliasMultipleTypes[X, Y] = dict[X, Y]
+type RecursiveGenericAlias[X] = dict[str, RecursiveAlias[X]]
+type BoundGenericAlias[X: int] = set[X]
+type ConstrainedGenericAlias[LongName: (str, bytes)] = list[LongName]
+type AllTypesAlias[A, *B, **C] = Callable[C, A] | tuple[*B]
+
+
+class TypeAliasPickleTest(unittest.TestCase):
+    def test_pickling(self):
+        things_to_test = [
+            SimpleAlias,
+            RecursiveAlias,
+
+            GenericAlias,
+            GenericAlias[T],
+            GenericAlias[int],
+
+            GenericAliasMultipleTypes,
+            GenericAliasMultipleTypes[str, T],
+            GenericAliasMultipleTypes[T, str],
+            GenericAliasMultipleTypes[int, str],
+
+            RecursiveGenericAlias,
+            RecursiveGenericAlias[T],
+            RecursiveGenericAlias[int],
+
+            BoundGenericAlias,
+            BoundGenericAlias[int],
+            BoundGenericAlias[T],
+
+            ConstrainedGenericAlias,
+            ConstrainedGenericAlias[str],
+            ConstrainedGenericAlias[T],
+
+            AllTypesAlias,
+            AllTypesAlias[int, str, T, [T, object]],
+
+            # Other modules:
+            mod_generics_cache.Alias,
+            mod_generics_cache.OldStyle,
+        ]
+        for thing in things_to_test:
+            for proto in range(pickle.HIGHEST_PROTOCOL + 1):
+                with self.subTest(thing=thing, proto=proto):
+                    pickled = pickle.dumps(thing, protocol=proto)
+                    self.assertEqual(pickle.loads(pickled), thing)
+
+    type ClassLevel = str
+
+    def test_pickling_local(self):
+        type A = int
+        things_to_test = [
+            self.ClassLevel,
+            A,
+        ]
+        for thing in things_to_test:
+            for proto in range(pickle.HIGHEST_PROTOCOL + 1):
+                with self.subTest(thing=thing, proto=proto):
+                    with self.assertRaises(pickle.PickleError):
+                        pickle.dumps(thing, protocol=proto)
+
+
+class TypeParamsExoticGlobalsTest(unittest.TestCase):
+    def test_exec_with_unusual_globals(self):
+        class customdict(dict):
+            def __missing__(self, key):
+                return key
+
+        code = compile("type Alias = undefined", "test", "exec")
+        ns = customdict()
+        exec(code, ns)
+        Alias = ns["Alias"]
+        self.assertEqual(Alias.__value__, "undefined")
+
+        code = compile("class A: type Alias = undefined", "test", "exec")
+        ns = customdict()
+        exec(code, ns)
+        Alias = ns["A"].Alias
+        self.assertEqual(Alias.__value__, "undefined")
diff --git a/Lib/test/test_type_annotations.py b/Lib/test/test_type_annotations.py
new file mode 100644
index 00000000000..4c58fade1b4
--- /dev/null
+++ b/Lib/test/test_type_annotations.py
@@ -0,0 +1,874 @@
+import annotationlib
+import inspect
+import textwrap
+import types
+import unittest
+from test.support import run_code, check_syntax_error, import_helper, cpython_only
+from test.test_inspect import inspect_stringized_annotations
+
+
+class TypeAnnotationTests(unittest.TestCase):
+
+    def test_lazy_create_annotations(self):
+        # type objects lazy create their __annotations__ dict on demand.
+        # the annotations dict is stored in type.__dict__ (as __annotations_cache__).
+        # a freshly created type shouldn't have an annotations dict yet.
+        foo = type("Foo", (), {})
+        for i in range(3):
+            self.assertFalse("__annotations_cache__" in foo.__dict__)
+            d = foo.__annotations__
+            self.assertTrue("__annotations_cache__" in foo.__dict__)
+            self.assertEqual(foo.__annotations__, d)
+            self.assertEqual(foo.__dict__['__annotations_cache__'], d)
+            del foo.__annotations__
+
+    def test_setting_annotations(self):
+        foo = type("Foo", (), {})
+        for i in range(3):
+            self.assertFalse("__annotations_cache__" in foo.__dict__)
+            d = {'a': int}
+            foo.__annotations__ = d
+            self.assertTrue("__annotations_cache__" in foo.__dict__)
+            self.assertEqual(foo.__annotations__, d)
+            self.assertEqual(foo.__dict__['__annotations_cache__'], d)
+            del foo.__annotations__
+
+    def test_annotations_getset_raises(self):
+        # builtin types don't have __annotations__ (yet!)
+        with self.assertRaises(AttributeError):
+            print(float.__annotations__)
+        with self.assertRaises(TypeError):
+            float.__annotations__ = {}
+        with self.assertRaises(TypeError):
+            del float.__annotations__
+
+        # double delete
+        foo = type("Foo", (), {})
+        foo.__annotations__ = {}
+        del foo.__annotations__
+        with self.assertRaises(AttributeError):
+            del foo.__annotations__
+
+    def test_annotations_are_created_correctly(self):
+        class C:
+            a:int=3
+            b:str=4
+        self.assertEqual(C.__annotations__, {"a": int, "b": str})
+        self.assertTrue("__annotations_cache__" in C.__dict__)
+        del C.__annotations__
+        self.assertFalse("__annotations_cache__" in C.__dict__)
+
+    def test_pep563_annotations(self):
+        isa = inspect_stringized_annotations
+        self.assertEqual(
+            isa.__annotations__, {"a": "int", "b": "str"},
+        )
+        self.assertEqual(
+            isa.MyClass.__annotations__, {"a": "int", "b": "str"},
+        )
+
+    def test_explicitly_set_annotations(self):
+        class C:
+            __annotations__ = {"what": int}
+        self.assertEqual(C.__annotations__, {"what": int})
+
+    def test_explicitly_set_annotate(self):
+        class C:
+            __annotate__ = lambda format: {"what": int}
+        self.assertEqual(C.__annotations__, {"what": int})
+        self.assertIsInstance(C.__annotate__, types.FunctionType)
+        self.assertEqual(C.__annotate__(annotationlib.Format.VALUE), {"what": int})
+
+    def test_del_annotations_and_annotate(self):
+        # gh-132285
+        called = False
+        class A:
+            def __annotate__(format):
+                nonlocal called
+                called = True
+                return {'a': int}
+
+        self.assertEqual(A.__annotations__, {'a': int})
+        self.assertTrue(called)
+        self.assertTrue(A.__annotate__)
+
+        del A.__annotations__
+        called = False
+
+        self.assertEqual(A.__annotations__, {})
+        self.assertFalse(called)
+        self.assertIs(A.__annotate__, None)
+
+    def test_descriptor_still_works(self):
+        class C:
+            def __init__(self, name=None, bases=None, d=None):
+                self.my_annotations = None
+
+            @property
+            def __annotations__(self):
+                if not hasattr(self, 'my_annotations'):
+                    self.my_annotations = {}
+                if not isinstance(self.my_annotations, dict):
+                    self.my_annotations = {}
+                return self.my_annotations
+
+            @__annotations__.setter
+            def __annotations__(self, value):
+                if not isinstance(value, dict):
+                    raise ValueError("can only set __annotations__ to a dict")
+                self.my_annotations = value
+
+            @__annotations__.deleter
+            def __annotations__(self):
+                if getattr(self, 'my_annotations', False) is None:
+                    raise AttributeError('__annotations__')
+                self.my_annotations = None
+
+        c = C()
+        self.assertEqual(c.__annotations__, {})
+        d = {'a':'int'}
+        c.__annotations__ = d
+        self.assertEqual(c.__annotations__, d)
+        with self.assertRaises(ValueError):
+            c.__annotations__ = 123
+        del c.__annotations__
+        with self.assertRaises(AttributeError):
+            del c.__annotations__
+        self.assertEqual(c.__annotations__, {})
+
+
+        class D(metaclass=C):
+            pass
+
+        self.assertEqual(D.__annotations__, {})
+        d = {'a':'int'}
+        D.__annotations__ = d
+        self.assertEqual(D.__annotations__, d)
+        with self.assertRaises(ValueError):
+            D.__annotations__ = 123
+        del D.__annotations__
+        with self.assertRaises(AttributeError):
+            del D.__annotations__
+        self.assertEqual(D.__annotations__, {})
+
+    def test_partially_executed_module(self):
+        partialexe = import_helper.import_fresh_module("test.typinganndata.partialexecution")
+        self.assertEqual(
+            partialexe.a.__annotations__,
+            {"v1": int, "v2": int},
+        )
+        self.assertEqual(partialexe.b.annos, {"v1": int})
+
+    @cpython_only
+    def test_no_cell(self):
+        # gh-130924: Test that uses of annotations in local scopes do not
+        # create cell variables.
+        def f(x):
+            a: x
+            return x
+
+        self.assertEqual(f.__code__.co_cellvars, ())
+
+
+def build_module(code: str, name: str = "top") -> types.ModuleType:
+    ns = run_code(code)
+    mod = types.ModuleType(name)
+    mod.__dict__.update(ns)
+    return mod
+
+
+class TestSetupAnnotations(unittest.TestCase):
+    def check(self, code: str):
+        code = textwrap.dedent(code)
+        for scope in ("module", "class"):
+            with self.subTest(scope=scope):
+                if scope == "class":
+                    code = f"class C:\n{textwrap.indent(code, '    ')}"
+                    ns = run_code(code)
+                    annotations = ns["C"].__annotations__
+                else:
+                    annotations = build_module(code).__annotations__
+                self.assertEqual(annotations, {"x": int})
+
+    def test_top_level(self):
+        self.check("x: int = 1")
+
+    def test_blocks(self):
+        self.check("if True:\n    x: int = 1")
+        self.check("""
+            while True:
+                x: int = 1
+                break
+        """)
+        self.check("""
+            while False:
+                pass
+            else:
+                x: int = 1
+        """)
+        self.check("""
+            for i in range(1):
+                x: int = 1
+        """)
+        self.check("""
+            for i in range(1):
+                pass
+            else:
+                x: int = 1
+        """)
+
+    def test_try(self):
+        self.check("""
+            try:
+                x: int = 1
+            except:
+                pass
+        """)
+        self.check("""
+            try:
+                pass
+            except:
+                pass
+            else:
+                x: int = 1
+        """)
+        self.check("""
+            try:
+                pass
+            except:
+                pass
+            finally:
+                x: int = 1
+        """)
+        self.check("""
+            try:
+                1/0
+            except:
+                x: int = 1
+        """)
+
+    def test_try_star(self):
+        self.check("""
+            try:
+                x: int = 1
+            except* Exception:
+                pass
+        """)
+        self.check("""
+            try:
+                pass
+            except* Exception:
+                pass
+            else:
+                x: int = 1
+        """)
+        self.check("""
+            try:
+                pass
+            except* Exception:
+                pass
+            finally:
+                x: int = 1
+        """)
+        self.check("""
+            try:
+                1/0
+            except* Exception:
+                x: int = 1
+        """)
+
+    def test_match(self):
+        self.check("""
+            match 0:
+                case 0:
+                    x: int = 1
+        """)
+
+
+class AnnotateTests(unittest.TestCase):
+    """See PEP 649."""
+    def test_manual_annotate(self):
+        def f():
+            pass
+        mod = types.ModuleType("mod")
+        class X:
+            pass
+
+        for obj in (f, mod, X):
+            with self.subTest(obj=obj):
+                self.check_annotations(obj)
+
+    def check_annotations(self, f):
+        self.assertEqual(f.__annotations__, {})
+        self.assertIs(f.__annotate__, None)
+
+        with self.assertRaisesRegex(TypeError, "__annotate__ must be callable or None"):
+            f.__annotate__ = 42
+        f.__annotate__ = lambda: 42
+        with self.assertRaisesRegex(TypeError, r"takes 0 positional arguments but 1 was given"):
+            print(f.__annotations__)
+
+        f.__annotate__ = lambda x: 42
+        with self.assertRaisesRegex(TypeError, r"__annotate__ returned non-dict of type 'int'"):
+            print(f.__annotations__)
+
+        f.__annotate__ = lambda x: {"x": x}
+        self.assertEqual(f.__annotations__, {"x": 1})
+
+        # Setting annotate to None does not invalidate the cached __annotations__
+        f.__annotate__ = None
+        self.assertEqual(f.__annotations__, {"x": 1})
+
+        # But setting it to a new callable does
+        f.__annotate__ = lambda x: {"y": x}
+        self.assertEqual(f.__annotations__, {"y": 1})
+
+        # Setting f.__annotations__ also clears __annotate__
+        f.__annotations__ = {"z": 43}
+        self.assertIs(f.__annotate__, None)
+
+    def test_user_defined_annotate(self):
+        class X:
+            a: int
+
+            def __annotate__(format):
+                return {"a": str}
+        self.assertEqual(X.__annotate__(annotationlib.Format.VALUE), {"a": str})
+        self.assertEqual(annotationlib.get_annotations(X), {"a": str})
+
+        mod = build_module(
+            """
+            a: int
+            def __annotate__(format):
+                return {"a": str}
+            """
+        )
+        self.assertEqual(mod.__annotate__(annotationlib.Format.VALUE), {"a": str})
+        self.assertEqual(annotationlib.get_annotations(mod), {"a": str})
+
+
+class DeferredEvaluationTests(unittest.TestCase):
+    def test_function(self):
+        def func(x: undefined, /, y: undefined, *args: undefined, z: undefined, **kwargs: undefined) -> undefined:
+            pass
+
+        with self.assertRaises(NameError):
+            func.__annotations__
+
+        undefined = 1
+        self.assertEqual(func.__annotations__, {
+            "x": 1,
+            "y": 1,
+            "args": 1,
+            "z": 1,
+            "kwargs": 1,
+            "return": 1,
+        })
+
+    def test_async_function(self):
+        async def func(x: undefined, /, y: undefined, *args: undefined, z: undefined, **kwargs: undefined) -> undefined:
+            pass
+
+        with self.assertRaises(NameError):
+            func.__annotations__
+
+        undefined = 1
+        self.assertEqual(func.__annotations__, {
+            "x": 1,
+            "y": 1,
+            "args": 1,
+            "z": 1,
+            "kwargs": 1,
+            "return": 1,
+        })
+
+    def test_class(self):
+        class X:
+            a: undefined
+
+        with self.assertRaises(NameError):
+            X.__annotations__
+
+        undefined = 1
+        self.assertEqual(X.__annotations__, {"a": 1})
+
+    def test_module(self):
+        ns = run_code("x: undefined = 1")
+        anno = ns["__annotate__"]
+        with self.assertRaises(NotImplementedError):
+            anno(3)
+
+        with self.assertRaises(NameError):
+            anno(1)
+
+        ns["undefined"] = 1
+        self.assertEqual(anno(1), {"x": 1})
+
+    def test_class_scoping(self):
+        class Outer:
+            def meth(self, x: Nested): ...
+            x: Nested
+            class Nested: ...
+
+        self.assertEqual(Outer.meth.__annotations__, {"x": Outer.Nested})
+        self.assertEqual(Outer.__annotations__, {"x": Outer.Nested})
+
+    def test_no_exotic_expressions(self):
+        preludes = [
+            "",
+            "class X:\n ",
+            "def f():\n ",
+            "async def f():\n ",
+        ]
+        for prelude in preludes:
+            with self.subTest(prelude=prelude):
+                check_syntax_error(self, prelude + "def func(x: (yield)): ...", "yield expression cannot be used within an annotation")
+                check_syntax_error(self, prelude + "def func(x: (yield from x)): ...", "yield expression cannot be used within an annotation")
+                check_syntax_error(self, prelude + "def func(x: (y := 3)): ...", "named expression cannot be used within an annotation")
+                check_syntax_error(self, prelude + "def func(x: (await 42)): ...", "await expression cannot be used within an annotation")
+                check_syntax_error(self, prelude + "def func(x: [y async for y in x]): ...", "asynchronous comprehension outside of an asynchronous function")
+                check_syntax_error(self, prelude + "def func(x: {y async for y in x}): ...", "asynchronous comprehension outside of an asynchronous function")
+                check_syntax_error(self, prelude + "def func(x: {y: y async for y in x}): ...", "asynchronous comprehension outside of an asynchronous function")
+
+    def test_no_exotic_expressions_in_unevaluated_annotations(self):
+        preludes = [
+            "",
+            "class X: ",
+            "def f(): ",
+            "async def f(): ",
+        ]
+        for prelude in preludes:
+            with self.subTest(prelude=prelude):
+                check_syntax_error(self, prelude + "(x): (yield)", "yield expression cannot be used within an annotation")
+                check_syntax_error(self, prelude + "(x): (yield from x)", "yield expression cannot be used within an annotation")
+                check_syntax_error(self, prelude + "(x): (y := 3)", "named expression cannot be used within an annotation")
+                check_syntax_error(self, prelude + "(x): (__debug__ := 3)", "named expression cannot be used within an annotation")
+                check_syntax_error(self, prelude + "(x): (await 42)", "await expression cannot be used within an annotation")
+                check_syntax_error(self, prelude + "(x): [y async for y in x]", "asynchronous comprehension outside of an asynchronous function")
+                check_syntax_error(self, prelude + "(x): {y async for y in x}", "asynchronous comprehension outside of an asynchronous function")
+                check_syntax_error(self, prelude + "(x): {y: y async for y in x}", "asynchronous comprehension outside of an asynchronous function")
+
+    def test_ignore_non_simple_annotations(self):
+        ns = run_code("class X: (y): int")
+        self.assertEqual(ns["X"].__annotations__, {})
+        ns = run_code("class X: int.b: int")
+        self.assertEqual(ns["X"].__annotations__, {})
+        ns = run_code("class X: int[str]: int")
+        self.assertEqual(ns["X"].__annotations__, {})
+
+    def test_generated_annotate(self):
+        def func(x: int):
+            pass
+        class X:
+            x: int
+        mod = build_module("x: int")
+        for obj in (func, X, mod):
+            with self.subTest(obj=obj):
+                annotate = obj.__annotate__
+                self.assertIsInstance(annotate, types.FunctionType)
+                self.assertEqual(annotate.__name__, "__annotate__")
+                with self.assertRaises(NotImplementedError):
+                    annotate(annotationlib.Format.FORWARDREF)
+                with self.assertRaises(NotImplementedError):
+                    annotate(annotationlib.Format.STRING)
+                with self.assertRaises(TypeError):
+                    annotate(None)
+                self.assertEqual(annotate(annotationlib.Format.VALUE), {"x": int})
+
+                sig = inspect.signature(annotate)
+                self.assertEqual(sig, inspect.Signature([
+                    inspect.Parameter("format", inspect.Parameter.POSITIONAL_ONLY)
+                ]))
+
+    def test_comprehension_in_annotation(self):
+        # This crashed in an earlier version of the code
+        ns = run_code("x: [y for y in range(10)]")
+        self.assertEqual(ns["__annotate__"](1), {"x": list(range(10))})
+
+    def test_future_annotations(self):
+        code = """
+        from __future__ import annotations
+
+        def f(x: int) -> int: pass
+        """
+        ns = run_code(code)
+        f = ns["f"]
+        self.assertIsInstance(f.__annotate__, types.FunctionType)
+        annos = {"x": "int", "return": "int"}
+        self.assertEqual(f.__annotate__(annotationlib.Format.VALUE), annos)
+        self.assertEqual(f.__annotations__, annos)
+
+    def test_set_annotations(self):
+        function_code = textwrap.dedent("""
+        def f(x: int):
+            pass
+        """)
+        class_code = textwrap.dedent("""
+        class f:
+            x: int
+        """)
+        for future in (False, True):
+            for label, code in (("function", function_code), ("class", class_code)):
+                with self.subTest(future=future, label=label):
+                    if future:
+                        code = "from __future__ import annotations\n" + code
+                    ns = run_code(code)
+                    f = ns["f"]
+                    anno = "int" if future else int
+                    self.assertEqual(f.__annotations__, {"x": anno})
+
+                    f.__annotations__ = {"x": str}
+                    self.assertEqual(f.__annotations__, {"x": str})
+
+    def test_name_clash_with_format(self):
+        # this test would fail if __annotate__'s parameter was called "format"
+        # during symbol table construction
+        code = """
+        class format: pass
+
+        def f(x: format): pass
+        """
+        ns = run_code(code)
+        f = ns["f"]
+        self.assertEqual(f.__annotations__, {"x": ns["format"]})
+
+        code = """
+        class Outer:
+            class format: pass
+
+            def meth(self, x: format): ...
+        """
+        ns = run_code(code)
+        self.assertEqual(ns["Outer"].meth.__annotations__, {"x": ns["Outer"].format})
+
+        code = """
+        def f(format):
+            def inner(x: format): pass
+            return inner
+        res = f("closure var")
+        """
+        ns = run_code(code)
+        self.assertEqual(ns["res"].__annotations__, {"x": "closure var"})
+
+        code = """
+        def f(x: format):
+            pass
+        """
+        ns = run_code(code)
+        # picks up the format() builtin
+        self.assertEqual(ns["f"].__annotations__, {"x": format})
+
+        code = """
+        def outer():
+            def f(x: format):
+                pass
+            if False:
+                class format: pass
+            return f
+        f = outer()
+        """
+        ns = run_code(code)
+        with self.assertRaisesRegex(
+            NameError,
+            "cannot access free variable 'format' where it is not associated with a value in enclosing scope",
+        ):
+            ns["f"].__annotations__
+
+
+class ConditionalAnnotationTests(unittest.TestCase):
+    def check_scopes(self, code, true_annos, false_annos):
+        for scope in ("class", "module"):
+            for (cond, expected) in (
+                # Constants (so code might get optimized out)
+                (True, true_annos), (False, false_annos),
+                # Non-constant expressions
+                ("not not len", true_annos), ("not len", false_annos),
+            ):
+                with self.subTest(scope=scope, cond=cond):
+                    code_to_run = code.format(cond=cond)
+                    if scope == "class":
+                        code_to_run = "class Cls:\n" + textwrap.indent(textwrap.dedent(code_to_run), " " * 4)
+                    ns = run_code(code_to_run)
+                    if scope == "class":
+                        self.assertEqual(ns["Cls"].__annotations__, expected)
+                    else:
+                        self.assertEqual(ns["__annotate__"](annotationlib.Format.VALUE),
+                                         expected)
+
+    def test_with(self):
+        code = """
+            class Swallower:
+                def __enter__(self):
+                    pass
+
+                def __exit__(self, *args):
+                    return True
+
+            with Swallower():
+                if {cond}:
+                    about_to_raise: int
+                    raise Exception
+                in_with: "with"
+        """
+        self.check_scopes(code, {"about_to_raise": int}, {"in_with": "with"})
+
+    def test_simple_if(self):
+        code = """
+            if {cond}:
+                in_if: "if"
+            else:
+                in_if: "else"
+        """
+        self.check_scopes(code, {"in_if": "if"}, {"in_if": "else"})
+
+    def test_if_elif(self):
+        code = """
+            if not len:
+                in_if: "if"
+            elif {cond}:
+                in_elif: "elif"
+            else:
+                in_else: "else"
+        """
+        self.check_scopes(
+            code,
+            {"in_elif": "elif"},
+            {"in_else": "else"}
+        )
+
+    def test_try(self):
+        code = """
+            try:
+                if {cond}:
+                    raise Exception
+                in_try: "try"
+            except Exception:
+                in_except: "except"
+            finally:
+                in_finally: "finally"
+        """
+        self.check_scopes(
+            code,
+            {"in_except": "except", "in_finally": "finally"},
+            {"in_try": "try", "in_finally": "finally"}
+        )
+
+    def test_try_star(self):
+        code = """
+            try:
+                if {cond}:
+                    raise Exception
+                in_try_star: "try"
+            except* Exception:
+                in_except_star: "except"
+            finally:
+                in_finally: "finally"
+        """
+        self.check_scopes(
+            code,
+            {"in_except_star": "except", "in_finally": "finally"},
+            {"in_try_star": "try", "in_finally": "finally"}
+        )
+
+    def test_while(self):
+        code = """
+            while {cond}:
+                in_while: "while"
+                break
+            else:
+                in_else: "else"
+        """
+        self.check_scopes(
+            code,
+            {"in_while": "while"},
+            {"in_else": "else"}
+        )
+
+    def test_for(self):
+        code = """
+            for _ in ([1] if {cond} else []):
+                in_for: "for"
+            else:
+                in_else: "else"
+        """
+        self.check_scopes(
+            code,
+            {"in_for": "for", "in_else": "else"},
+            {"in_else": "else"}
+        )
+
+    def test_match(self):
+        code = """
+            match {cond}:
+                case True:
+                    x: "true"
+                case False:
+                    x: "false"
+        """
+        self.check_scopes(
+            code,
+            {"x": "true"},
+            {"x": "false"}
+        )
+
+    def test_nesting_override(self):
+        code = """
+            if {cond}:
+                x: "foo"
+                if {cond}:
+                    x: "bar"
+        """
+        self.check_scopes(
+            code,
+            {"x": "bar"},
+            {}
+        )
+
+    def test_nesting_outer(self):
+        code = """
+            if {cond}:
+                outer_before: "outer_before"
+                if len:
+                    inner_if: "inner_if"
+                else:
+                    inner_else: "inner_else"
+                outer_after: "outer_after"
+        """
+        self.check_scopes(
+            code,
+            {"outer_before": "outer_before", "inner_if": "inner_if",
+             "outer_after": "outer_after"},
+            {}
+        )
+
+    def test_nesting_inner(self):
+        code = """
+            if len:
+                outer_before: "outer_before"
+                if {cond}:
+                    inner_if: "inner_if"
+                else:
+                    inner_else: "inner_else"
+                outer_after: "outer_after"
+        """
+        self.check_scopes(
+            code,
+            {"outer_before": "outer_before", "inner_if": "inner_if",
+             "outer_after": "outer_after"},
+            {"outer_before": "outer_before", "inner_else": "inner_else",
+             "outer_after": "outer_after"},
+        )
+
+    def test_non_name_annotations(self):
+        code = """
+            before: "before"
+            if {cond}:
+                a = "x"
+                a[0]: int
+            else:
+                a = object()
+                a.b: str
+            after: "after"
+        """
+        expected = {"before": "before", "after": "after"}
+        self.check_scopes(code, expected, expected)
+
+
+class RegressionTests(unittest.TestCase):
+    # gh-132479
+    def test_complex_comprehension_inlining(self):
+        # Test that the various repro cases from the issue don't crash
+        cases = [
+            """
+            (unique_name_0): 0
+            unique_name_1: (
+                0
+                for (
+                    0
+                    for unique_name_2 in 0
+                    for () in (0 for unique_name_3 in unique_name_4 for unique_name_5 in name_1)
+                ).name_3 in {0: 0 for name_1 in unique_name_8}
+                if name_1
+            )
+            """,
+            """
+            unique_name_0: 0
+            unique_name_1: {
+                0: 0
+                for unique_name_2 in [0 for name_0 in unique_name_4]
+                if {
+                    0: 0
+                    for unique_name_5 in 0
+                    if name_0
+                    if ((name_0 for unique_name_8 in unique_name_9) for [] in 0)
+                }
+            }
+            """,
+            """
+            0[0]: {0 for name_0 in unique_name_1}
+            unique_name_2: {
+                0: (lambda: name_0 for unique_name_4 in unique_name_5)
+                for unique_name_6 in ()
+                if name_0
+            }
+            """,
+        ]
+        for case in cases:
+            case = textwrap.dedent(case)
+            compile(case, "<test>", "exec")
+
+    def test_complex_comprehension_inlining_exec(self):
+        code = """
+            unique_name_1 = unique_name_5 = [1]
+            name_0 = 42
+            unique_name_7: {name_0 for name_0 in unique_name_1}
+            unique_name_2: {
+                0: (lambda: name_0 for unique_name_4 in unique_name_5)
+                for unique_name_6 in [1]
+                if name_0
+            }
+        """
+        mod = build_module(code)
+        annos = mod.__annotations__
+        self.assertEqual(annos.keys(), {"unique_name_7", "unique_name_2"})
+        self.assertEqual(annos["unique_name_7"], {True})
+        genexp = annos["unique_name_2"][0]
+        lamb = list(genexp)[0]
+        self.assertEqual(lamb(), 42)
+
+    # gh-138349
+    def test_module_level_annotation_plus_listcomp(self):
+        cases = [
+            """
+            def report_error():
+                pass
+            try:
+                [0 for name_2 in unique_name_0 if (lambda: name_2)]
+            except:
+                pass
+            annotated_name: 0
+            """,
+            """
+            class Generic:
+                pass
+            try:
+                [0 for name_2 in unique_name_0 if (0 for unique_name_1 in unique_name_2 for unique_name_3 in name_2)]
+            except:
+                pass
+            annotated_name: 0
+            """,
+            """
+            class Generic:
+                pass
+            annotated_name: 0
+            try:
+                [0 for name_2 in [[0]] for unique_name_1 in unique_name_2 if (lambda: name_2)]
+            except:
+                pass
+            """,
+        ]
+        for code in cases:
+            with self.subTest(code=code):
+                mod = build_module(code)
+                annos = mod.__annotations__
+                self.assertEqual(annos, {"annotated_name": 0})
diff --git a/Lib/test/test_type_comments.py b/Lib/test/test_type_comments.py
index 578c138767d..4f41171b2df 100644
--- a/Lib/test/test_type_comments.py
+++ b/Lib/test/test_type_comments.py
@@ -1,7 +1,6 @@
 import ast
 import sys
 import unittest
-from test import support
 
 
 funcdef = """\
@@ -67,6 +66,14 @@ def foo():
     pass
 """
 
+parenthesized_withstmt = """\
+with (a as b):  # type: int
+    pass
+
+with (a, b):  # type: int
+    pass
+"""
+
 vardecl = """\
 a = 0  # type: int
 """
@@ -244,8 +251,7 @@ def parse_all(self, source, minver=lowest, maxver=highest, expected_regex=""):
     def classic_parse(self, source):
         return ast.parse(source)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AttributeError: 'FunctionDef' object has no attribute 'type_comment'
     def test_funcdef(self):
         for tree in self.parse_all(funcdef):
             self.assertEqual(tree.body[0].type_comment, "() -> int")
@@ -254,8 +260,7 @@ def test_funcdef(self):
         self.assertEqual(tree.body[0].type_comment, None)
         self.assertEqual(tree.body[1].type_comment, None)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AssertionError: SyntaxError not raised : feature_version=(3, 4)
     def test_asyncdef(self):
         for tree in self.parse_all(asyncdef, minver=5):
             self.assertEqual(tree.body[0].type_comment, "() -> int")
@@ -264,75 +269,71 @@ def test_asyncdef(self):
         self.assertEqual(tree.body[0].type_comment, None)
         self.assertEqual(tree.body[1].type_comment, None)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_asyncvar(self):
-        for tree in self.parse_all(asyncvar, maxver=6):
-            pass
+        with self.assertRaises(SyntaxError):
+            self.classic_parse(asyncvar)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AssertionError: SyntaxError not raised : feature_version=(3, 4)
     def test_asynccomp(self):
         for tree in self.parse_all(asynccomp, minver=6):
             pass
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AssertionError: SyntaxError not raised : feature_version=(3, 4)
     def test_matmul(self):
         for tree in self.parse_all(matmul, minver=5):
             pass
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_fstring(self):
-        for tree in self.parse_all(fstring, minver=6):
+        for tree in self.parse_all(fstring):
             pass
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AssertionError: SyntaxError not raised : feature_version=(3, 4)
     def test_underscorednumber(self):
         for tree in self.parse_all(underscorednumber, minver=6):
             pass
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AssertionError: SyntaxError not raised : feature_version=(3, 4)
     def test_redundantdef(self):
         for tree in self.parse_all(redundantdef, maxver=0,
                                 expected_regex="^Cannot have two type comments on def"):
             pass
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AttributeError: 'FunctionDef' object has no attribute 'type_comment'
     def test_nonasciidef(self):
         for tree in self.parse_all(nonasciidef):
             self.assertEqual(tree.body[0].type_comment, "() -> àçčéñt")
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AttributeError: 'For' object has no attribute 'type_comment'
     def test_forstmt(self):
         for tree in self.parse_all(forstmt):
             self.assertEqual(tree.body[0].type_comment, "int")
         tree = self.classic_parse(forstmt)
         self.assertEqual(tree.body[0].type_comment, None)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AttributeError: 'With' object has no attribute 'type_comment'
     def test_withstmt(self):
         for tree in self.parse_all(withstmt):
             self.assertEqual(tree.body[0].type_comment, "int")
         tree = self.classic_parse(withstmt)
         self.assertEqual(tree.body[0].type_comment, None)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AttributeError: 'With' object has no attribute 'type_comment'
+    def test_parenthesized_withstmt(self):
+        for tree in self.parse_all(parenthesized_withstmt):
+            self.assertEqual(tree.body[0].type_comment, "int")
+            self.assertEqual(tree.body[1].type_comment, "int")
+        tree = self.classic_parse(parenthesized_withstmt)
+        self.assertEqual(tree.body[0].type_comment, None)
+        self.assertEqual(tree.body[1].type_comment, None)
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AssertionError: None != 'int'
     def test_vardecl(self):
         for tree in self.parse_all(vardecl):
             self.assertEqual(tree.body[0].type_comment, "int")
         tree = self.classic_parse(vardecl)
         self.assertEqual(tree.body[0].type_comment, None)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; +  (11, ' whatever')]
     def test_ignores(self):
         for tree in self.parse_all(ignores):
             self.assertEqual(
@@ -348,16 +349,15 @@ def test_ignores(self):
         tree = self.classic_parse(ignores)
         self.assertEqual(tree.type_ignores, [])
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AssertionError: SyntaxError not raised : feature_version=(3, 4)
     def test_longargs(self):
-        for tree in self.parse_all(longargs):
+        for tree in self.parse_all(longargs, minver=8):
             for t in tree.body:
                 # The expected args are encoded in the function name
                 todo = set(t.name[1:])
                 self.assertEqual(len(t.args.args) + len(t.args.posonlyargs),
                                  len(todo) - bool(t.args.vararg) - bool(t.args.kwarg))
-                self.assertTrue(t.name.startswith('f'), t.name)
+                self.assertStartsWith(t.name, 'f')
                 for index, c in enumerate(t.name[1:]):
                     todo.remove(c)
                     if c == 'v':
@@ -380,8 +380,7 @@ def test_longargs(self):
                     self.assertIsNone(arg.type_comment, "%s(%s:%r)" %
                                       (t.name, arg.arg, arg.type_comment))
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; Tests for inappropriately-placed type comments.
     def test_inappropriate_type_comments(self):
         """Tests for inappropriately-placed type comments.
 
@@ -406,8 +405,7 @@ def check_both_ways(source):
         check_both_ways("pass  # type: ignorewhatever\n")
         check_both_ways("pass  # type: ignoreé\n")
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; ValueError: mode must be "exec", "eval", "ipython", or "single"
     def test_func_type_input(self):
 
         def parse_func_type_input(source):
diff --git a/Lib/test/test_type_params.py b/Lib/test/test_type_params.py
new file mode 100644
index 00000000000..af26a6a0a01
--- /dev/null
+++ b/Lib/test/test_type_params.py
@@ -0,0 +1,1468 @@
+import annotationlib
+import textwrap
+import types
+import unittest
+import pickle
+import weakref
+from test.support import check_syntax_error, run_code, run_no_yield_async_fn
+
+from typing import Generic, NoDefault, Sequence, TypeAliasType, TypeVar, TypeVarTuple, ParamSpec, get_args
+
+
+class TypeParamsInvalidTest(unittest.TestCase):
+    def test_name_collisions(self):
+        check_syntax_error(self, 'def func[**A, A](): ...', "duplicate type parameter 'A'")
+        check_syntax_error(self, 'def func[A, *A](): ...', "duplicate type parameter 'A'")
+        check_syntax_error(self, 'def func[*A, **A](): ...', "duplicate type parameter 'A'")
+
+        check_syntax_error(self, 'class C[**A, A](): ...', "duplicate type parameter 'A'")
+        check_syntax_error(self, 'class C[A, *A](): ...', "duplicate type parameter 'A'")
+        check_syntax_error(self, 'class C[*A, **A](): ...', "duplicate type parameter 'A'")
+
+    def test_name_non_collision_02(self):
+        ns = run_code("""def func[A](A): return A""")
+        func = ns["func"]
+        self.assertEqual(func(1), 1)
+        A, = func.__type_params__
+        self.assertEqual(A.__name__, "A")
+
+    def test_name_non_collision_03(self):
+        ns = run_code("""def func[A](*A): return A""")
+        func = ns["func"]
+        self.assertEqual(func(1), (1,))
+        A, = func.__type_params__
+        self.assertEqual(A.__name__, "A")
+
+    def test_name_non_collision_04(self):
+        # Mangled names should not cause a conflict.
+        ns = run_code("""
+            class ClassA:
+                def func[__A](self, __A): return __A
+            """
+        )
+        cls = ns["ClassA"]
+        self.assertEqual(cls().func(1), 1)
+        A, = cls.func.__type_params__
+        self.assertEqual(A.__name__, "__A")
+
+    def test_name_non_collision_05(self):
+        ns = run_code("""
+            class ClassA:
+                def func[_ClassA__A](self, __A): return __A
+            """
+        )
+        cls = ns["ClassA"]
+        self.assertEqual(cls().func(1), 1)
+        A, = cls.func.__type_params__
+        self.assertEqual(A.__name__, "_ClassA__A")
+
+    def test_name_non_collision_06(self):
+        ns = run_code("""
+            class ClassA[X]:
+                def func(self, X): return X
+            """
+        )
+        cls = ns["ClassA"]
+        self.assertEqual(cls().func(1), 1)
+        X, = cls.__type_params__
+        self.assertEqual(X.__name__, "X")
+
+    def test_name_non_collision_07(self):
+        ns = run_code("""
+            class ClassA[X]:
+                def func(self):
+                    X = 1
+                    return X
+            """
+        )
+        cls = ns["ClassA"]
+        self.assertEqual(cls().func(), 1)
+        X, = cls.__type_params__
+        self.assertEqual(X.__name__, "X")
+
+    def test_name_non_collision_08(self):
+        ns = run_code("""
+            class ClassA[X]:
+                def func(self):
+                    return [X for X in [1, 2]]
+            """
+        )
+        cls = ns["ClassA"]
+        self.assertEqual(cls().func(), [1, 2])
+        X, = cls.__type_params__
+        self.assertEqual(X.__name__, "X")
+
+    def test_name_non_collision_9(self):
+        ns = run_code("""
+            class ClassA[X]:
+                def func[X](self):
+                    ...
+            """
+        )
+        cls = ns["ClassA"]
+        outer_X, = cls.__type_params__
+        inner_X, = cls.func.__type_params__
+        self.assertEqual(outer_X.__name__, "X")
+        self.assertEqual(inner_X.__name__, "X")
+        self.assertIsNot(outer_X, inner_X)
+
+    def test_name_non_collision_10(self):
+        ns = run_code("""
+            class ClassA[X]:
+                X: int
+            """
+        )
+        cls = ns["ClassA"]
+        X, = cls.__type_params__
+        self.assertEqual(X.__name__, "X")
+        self.assertIs(cls.__annotations__["X"], int)
+
+    def test_name_non_collision_13(self):
+        ns = run_code("""
+            X = 1
+            def outer():
+                def inner[X]():
+                    global X
+                    X = 2
+                return inner
+            """
+        )
+        self.assertEqual(ns["X"], 1)
+        outer = ns["outer"]
+        outer()()
+        self.assertEqual(ns["X"], 2)
+
+    def test_disallowed_expressions(self):
+        check_syntax_error(self, "type X = (yield)")
+        check_syntax_error(self, "type X = (yield from x)")
+        check_syntax_error(self, "type X = (await 42)")
+        check_syntax_error(self, "async def f(): type X = (yield)")
+        check_syntax_error(self, "type X = (y := 3)")
+        check_syntax_error(self, "class X[T: (yield)]: pass")
+        check_syntax_error(self, "class X[T: (yield from x)]: pass")
+        check_syntax_error(self, "class X[T: (await 42)]: pass")
+        check_syntax_error(self, "class X[T: (y := 3)]: pass")
+        check_syntax_error(self, "class X[T](y := Sequence[T]): pass")
+        check_syntax_error(self, "def f[T](y: (x := Sequence[T])): pass")
+        check_syntax_error(self, "class X[T]([(x := 3) for _ in range(2)] and B): pass")
+        check_syntax_error(self, "def f[T: [(x := 3) for _ in range(2)]](): pass")
+        check_syntax_error(self, "type T = [(x := 3) for _ in range(2)]")
+
+    def test_incorrect_mro_explicit_object(self):
+        with self.assertRaisesRegex(TypeError, r"\(MRO\) for bases object, Generic"):
+            class My[X](object): ...
+
+
+class TypeParamsNonlocalTest(unittest.TestCase):
+    def test_nonlocal_disallowed_01(self):
+        code = """
+            def outer():
+                X = 1
+                def inner[X]():
+                    nonlocal X
+                return X
+            """
+        check_syntax_error(self, code)
+
+    def test_nonlocal_disallowed_02(self):
+        code = """
+            def outer2[T]():
+                def inner1():
+                    nonlocal T
+        """
+        check_syntax_error(self, textwrap.dedent(code))
+
+    def test_nonlocal_disallowed_03(self):
+        code = """
+            class Cls[T]:
+                nonlocal T
+        """
+        check_syntax_error(self, textwrap.dedent(code))
+
+    def test_nonlocal_allowed(self):
+        code = """
+            def func[T]():
+                T = "func"
+                def inner():
+                    nonlocal T
+                    T = "inner"
+                inner()
+                assert T == "inner"
+        """
+        ns = run_code(code)
+        func = ns["func"]
+        T, = func.__type_params__
+        self.assertEqual(T.__name__, "T")
+
+
+class TypeParamsAccessTest(unittest.TestCase):
+    def test_class_access_01(self):
+        ns = run_code("""
+            class ClassA[A, B](dict[A, B]):
+                ...
+            """
+        )
+        cls = ns["ClassA"]
+        A, B = cls.__type_params__
+        self.assertEqual(types.get_original_bases(cls), (dict[A, B], Generic[A, B]))
+
+    def test_class_access_02(self):
+        ns = run_code("""
+            class MyMeta[A, B](type): ...
+            class ClassA[A, B](metaclass=MyMeta[A, B]):
+                ...
+            """
+        )
+        meta = ns["MyMeta"]
+        cls = ns["ClassA"]
+        A1, B1 = meta.__type_params__
+        A2, B2 = cls.__type_params__
+        self.assertIsNot(A1, A2)
+        self.assertIsNot(B1, B2)
+        self.assertIs(type(cls), meta)
+
+    def test_class_access_03(self):
+        code = """
+            def my_decorator(a):
+                ...
+            @my_decorator(A)
+            class ClassA[A, B]():
+                ...
+            """
+
+        with self.assertRaisesRegex(NameError, "name 'A' is not defined"):
+            run_code(code)
+
+    def test_function_access_01(self):
+        ns = run_code("""
+            def func[A, B](a: dict[A, B]):
+                ...
+            """
+        )
+        func = ns["func"]
+        A, B = func.__type_params__
+        self.assertEqual(func.__annotations__["a"], dict[A, B])
+
+    def test_function_access_02(self):
+        code = """
+            def func[A](a = list[A]()):
+                ...
+            """
+
+        with self.assertRaisesRegex(NameError, "name 'A' is not defined"):
+            run_code(code)
+
+    def test_function_access_03(self):
+        code = """
+            def my_decorator(a):
+                ...
+            @my_decorator(A)
+            def func[A]():
+                ...
+            """
+
+        with self.assertRaisesRegex(NameError, "name 'A' is not defined"):
+            run_code(code)
+
+    def test_method_access_01(self):
+        ns = run_code("""
+            class ClassA:
+                x = int
+                def func[T](self, a: x, b: T):
+                    ...
+            """
+        )
+        cls = ns["ClassA"]
+        self.assertIs(cls.func.__annotations__["a"], int)
+        T, = cls.func.__type_params__
+        self.assertIs(cls.func.__annotations__["b"], T)
+
+    def test_nested_access_01(self):
+        ns = run_code("""
+            class ClassA[A]:
+                def funcB[B](self):
+                    class ClassC[C]:
+                        def funcD[D](self):
+                            return lambda: (A, B, C, D)
+                    return ClassC
+            """
+        )
+        cls = ns["ClassA"]
+        A, = cls.__type_params__
+        B, = cls.funcB.__type_params__
+        classC = cls().funcB()
+        C, = classC.__type_params__
+        D, = classC.funcD.__type_params__
+        self.assertEqual(classC().funcD()(), (A, B, C, D))
+
+    def test_out_of_scope_01(self):
+        code = """
+            class ClassA[T]: ...
+            x = T
+            """
+
+        with self.assertRaisesRegex(NameError, "name 'T' is not defined"):
+            run_code(code)
+
+    def test_out_of_scope_02(self):
+        code = """
+            class ClassA[A]:
+                def funcB[B](self): ...
+
+                x = B
+            """
+
+        with self.assertRaisesRegex(NameError, "name 'B' is not defined"):
+            run_code(code)
+
+    def test_class_scope_interaction_01(self):
+        ns = run_code("""
+            class C:
+                x = 1
+                def method[T](self, arg: x): pass
+        """)
+        cls = ns["C"]
+        self.assertEqual(cls.method.__annotations__["arg"], 1)
+
+    def test_class_scope_interaction_02(self):
+        ns = run_code("""
+            class C:
+                class Base: pass
+                class Child[T](Base): pass
+        """)
+        cls = ns["C"]
+        self.assertEqual(cls.Child.__bases__, (cls.Base, Generic))
+        T, = cls.Child.__type_params__
+        self.assertEqual(types.get_original_bases(cls.Child), (cls.Base, Generic[T]))
+
+    def test_class_deref(self):
+        ns = run_code("""
+            class C[T]:
+                T = "class"
+                type Alias = T
+        """)
+        cls = ns["C"]
+        self.assertEqual(cls.Alias.__value__, "class")
+
+    def test_shadowing_nonlocal(self):
+        ns = run_code("""
+            def outer[T]():
+                T = "outer"
+                def inner():
+                    nonlocal T
+                    T = "inner"
+                    return T
+                return lambda: T, inner
+        """)
+        outer = ns["outer"]
+        T, = outer.__type_params__
+        self.assertEqual(T.__name__, "T")
+        getter, inner = outer()
+        self.assertEqual(getter(), "outer")
+        self.assertEqual(inner(), "inner")
+        self.assertEqual(getter(), "inner")
+
+    def test_reference_previous_typevar(self):
+        def func[S, T: Sequence[S]]():
+            pass
+
+        S, T = func.__type_params__
+        self.assertEqual(T.__bound__, Sequence[S])
+
+    def test_super(self):
+        class Base:
+            def meth(self):
+                return "base"
+
+        class Child(Base):
+            # Having int in the annotation ensures the class gets cells for both
+            # __class__ and __classdict__
+            def meth[T](self, arg: int) -> T:
+                return super().meth() + "child"
+
+        c = Child()
+        self.assertEqual(c.meth(1), "basechild")
+
+    def test_type_alias_containing_lambda(self):
+        type Alias[T] = lambda: T
+        T, = Alias.__type_params__
+        self.assertIs(Alias.__value__(), T)
+
+    def test_class_base_containing_lambda(self):
+        # Test that scopes nested inside hidden functions work correctly
+        outer_var = "outer"
+        class Base[T]: ...
+        class Child[T](Base[lambda: (int, outer_var, T)]): ...
+        base, _ = types.get_original_bases(Child)
+        func, = get_args(base)
+        T, = Child.__type_params__
+        self.assertEqual(func(), (int, "outer", T))
+
+    def test_comprehension_01(self):
+        type Alias[T: ([T for T in (T, [1])[1]], T)] = [T for T in T.__name__]
+        self.assertEqual(Alias.__value__, ["T"])
+        T, = Alias.__type_params__
+        self.assertEqual(T.__constraints__, ([1], T))
+
+    def test_comprehension_02(self):
+        type Alias[T: [lambda: T for T in (T, [1])[1]]] = [lambda: T for T in T.__name__]
+        func, = Alias.__value__
+        self.assertEqual(func(), "T")
+        T, = Alias.__type_params__
+        func, = T.__bound__
+        self.assertEqual(func(), 1)
+
+    def test_comprehension_03(self):
+        def F[T: [lambda: T for T in (T, [1])[1]]](): return [lambda: T for T in T.__name__]
+        func, = F()
+        self.assertEqual(func(), "T")
+        T, = F.__type_params__
+        func, = T.__bound__
+        self.assertEqual(func(), 1)
+
+    def test_gen_exp_in_nested_class(self):
+        code = """
+            from test.test_type_params import make_base
+
+            class C[T]:
+                T = "class"
+                class Inner(make_base(T for _ in (1,)), make_base(T)):
+                    pass
+        """
+        C = run_code(code)["C"]
+        T, = C.__type_params__
+        base1, base2 = C.Inner.__bases__
+        self.assertEqual(list(base1.__arg__), [T])
+        self.assertEqual(base2.__arg__, "class")
+
+    def test_gen_exp_in_nested_generic_class(self):
+        code = """
+            from test.test_type_params import make_base
+
+            class C[T]:
+                T = "class"
+                class Inner[U](make_base(T for _ in (1,)), make_base(T)):
+                    pass
+        """
+        ns = run_code(code)
+        inner = ns["C"].Inner
+        base1, base2, _ = inner.__bases__
+        self.assertEqual(list(base1.__arg__), [ns["C"].__type_params__[0]])
+        self.assertEqual(base2.__arg__, "class")
+
+    def test_listcomp_in_nested_class(self):
+        code = """
+            from test.test_type_params import make_base
+
+            class C[T]:
+                T = "class"
+                class Inner(make_base([T for _ in (1,)]), make_base(T)):
+                    pass
+        """
+        C = run_code(code)["C"]
+        T, = C.__type_params__
+        base1, base2 = C.Inner.__bases__
+        self.assertEqual(base1.__arg__, [T])
+        self.assertEqual(base2.__arg__, "class")
+
+    def test_listcomp_in_nested_generic_class(self):
+        code = """
+            from test.test_type_params import make_base
+
+            class C[T]:
+                T = "class"
+                class Inner[U](make_base([T for _ in (1,)]), make_base(T)):
+                    pass
+        """
+        ns = run_code(code)
+        inner = ns["C"].Inner
+        base1, base2, _ = inner.__bases__
+        self.assertEqual(base1.__arg__, [ns["C"].__type_params__[0]])
+        self.assertEqual(base2.__arg__, "class")
+
+    def test_gen_exp_in_generic_method(self):
+        code = """
+            class C[T]:
+                T = "class"
+                def meth[U](x: (T for _ in (1,)), y: T):
+                    pass
+        """
+        ns = run_code(code)
+        meth = ns["C"].meth
+        self.assertEqual(list(meth.__annotations__["x"]), [ns["C"].__type_params__[0]])
+        self.assertEqual(meth.__annotations__["y"], "class")
+
+    def test_nested_scope_in_generic_alias(self):
+        code = """
+            T = "global"
+            class C:
+                T = "class"
+                {}
+        """
+        cases = [
+            "type Alias[T] = (T for _ in (1,))",
+            "type Alias = (T for _ in (1,))",
+            "type Alias[T] = [T for _ in (1,)]",
+            "type Alias = [T for _ in (1,)]",
+        ]
+        for case in cases:
+            with self.subTest(case=case):
+                ns = run_code(code.format(case))
+                alias = ns["C"].Alias
+                value = list(alias.__value__)[0]
+                if alias.__type_params__:
+                    self.assertIs(value, alias.__type_params__[0])
+                else:
+                    self.assertEqual(value, "global")
+
+    def test_lambda_in_alias_in_class(self):
+        code = """
+            T = "global"
+            class C:
+                T = "class"
+                type Alias = lambda: T
+        """
+        C = run_code(code)["C"]
+        self.assertEqual(C.Alias.__value__(), "global")
+
+    def test_lambda_in_alias_in_generic_class(self):
+        code = """
+            class C[T]:
+                T = "class"
+                type Alias = lambda: T
+        """
+        C = run_code(code)["C"]
+        self.assertIs(C.Alias.__value__(), C.__type_params__[0])
+
+    def test_lambda_in_generic_alias_in_class(self):
+        # A lambda nested in the alias cannot see the class scope, but can see
+        # a surrounding annotation scope.
+        code = """
+            T = U = "global"
+            class C:
+                T = "class"
+                U = "class"
+                type Alias[T] = lambda: (T, U)
+        """
+        C = run_code(code)["C"]
+        T, U = C.Alias.__value__()
+        self.assertIs(T, C.Alias.__type_params__[0])
+        self.assertEqual(U, "global")
+
+    def test_lambda_in_generic_alias_in_generic_class(self):
+        # A lambda nested in the alias cannot see the class scope, but can see
+        # a surrounding annotation scope.
+        code = """
+            class C[T, U]:
+                T = "class"
+                U = "class"
+                type Alias[T] = lambda: (T, U)
+        """
+        C = run_code(code)["C"]
+        T, U = C.Alias.__value__()
+        self.assertIs(T, C.Alias.__type_params__[0])
+        self.assertIs(U, C.__type_params__[1])
+
+    def test_type_special_case(self):
+        # https://github.com/python/cpython/issues/119011
+        self.assertEqual(type.__type_params__, ())
+        self.assertEqual(object.__type_params__, ())
+
+
+def make_base(arg):
+    class Base:
+        __arg__ = arg
+    return Base
+
+
+def global_generic_func[T]():
+    pass
+
+class GlobalGenericClass[T]:
+    pass
+
+
+class TypeParamsLazyEvaluationTest(unittest.TestCase):
+    def test_qualname(self):
+        class Foo[T]:
+            pass
+
+        def func[T]():
+            pass
+
+        self.assertEqual(Foo.__qualname__, "TypeParamsLazyEvaluationTest.test_qualname.<locals>.Foo")
+        self.assertEqual(func.__qualname__, "TypeParamsLazyEvaluationTest.test_qualname.<locals>.func")
+        self.assertEqual(global_generic_func.__qualname__, "global_generic_func")
+        self.assertEqual(GlobalGenericClass.__qualname__, "GlobalGenericClass")
+
+    def test_recursive_class(self):
+        class Foo[T: Foo, U: (Foo, Foo)]:
+            pass
+
+        type_params = Foo.__type_params__
+        self.assertEqual(len(type_params), 2)
+        self.assertEqual(type_params[0].__name__, "T")
+        self.assertIs(type_params[0].__bound__, Foo)
+        self.assertEqual(type_params[0].__constraints__, ())
+        self.assertIs(type_params[0].__default__, NoDefault)
+
+        self.assertEqual(type_params[1].__name__, "U")
+        self.assertIs(type_params[1].__bound__, None)
+        self.assertEqual(type_params[1].__constraints__, (Foo, Foo))
+        self.assertIs(type_params[1].__default__, NoDefault)
+
+    def test_evaluation_error(self):
+        class Foo[T: Undefined, U: (Undefined,)]:
+            pass
+
+        type_params = Foo.__type_params__
+        with self.assertRaises(NameError):
+            type_params[0].__bound__
+        self.assertEqual(type_params[0].__constraints__, ())
+        self.assertIs(type_params[1].__bound__, None)
+        self.assertIs(type_params[0].__default__, NoDefault)
+        self.assertIs(type_params[1].__default__, NoDefault)
+        with self.assertRaises(NameError):
+            type_params[1].__constraints__
+
+        Undefined = "defined"
+        self.assertEqual(type_params[0].__bound__, "defined")
+        self.assertEqual(type_params[0].__constraints__, ())
+
+        self.assertIs(type_params[1].__bound__, None)
+        self.assertEqual(type_params[1].__constraints__, ("defined",))
+
+
+class TypeParamsClassScopeTest(unittest.TestCase):
+    def test_alias(self):
+        class X:
+            T = int
+            type U = T
+        self.assertIs(X.U.__value__, int)
+
+        ns = run_code("""
+            glb = "global"
+            class X:
+                cls = "class"
+                type U = (glb, cls)
+        """)
+        cls = ns["X"]
+        self.assertEqual(cls.U.__value__, ("global", "class"))
+
+    def test_bound(self):
+        class X:
+            T = int
+            def foo[U: T](self): ...
+        self.assertIs(X.foo.__type_params__[0].__bound__, int)
+
+        ns = run_code("""
+            glb = "global"
+            class X:
+                cls = "class"
+                def foo[T: glb, U: cls](self): ...
+        """)
+        cls = ns["X"]
+        T, U = cls.foo.__type_params__
+        self.assertEqual(T.__bound__, "global")
+        self.assertEqual(U.__bound__, "class")
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AssertionError: <class 'int'> is not <class 'float'>
+    def test_modified_later(self):
+        class X:
+            T = int
+            def foo[U: T](self): ...
+            type Alias = T
+        X.T = float
+        self.assertIs(X.foo.__type_params__[0].__bound__, float)
+        self.assertIs(X.Alias.__value__, float)
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; + global
+    def test_binding_uses_global(self):
+        ns = run_code("""
+            x = "global"
+            def outer():
+                x = "nonlocal"
+                class Cls:
+                    type Alias = x
+                    val = Alias.__value__
+                    def meth[T: x](self, arg: x): ...
+                    bound = meth.__type_params__[0].__bound__
+                    annotation = meth.__annotations__["arg"]
+                    x = "class"
+                return Cls
+        """)
+        cls = ns["outer"]()
+        self.assertEqual(cls.val, "global")
+        self.assertEqual(cls.bound, "global")
+        self.assertEqual(cls.annotation, "global")
+
+    def test_no_binding_uses_nonlocal(self):
+        ns = run_code("""
+            x = "global"
+            def outer():
+                x = "nonlocal"
+                class Cls:
+                    type Alias = x
+                    val = Alias.__value__
+                    def meth[T: x](self, arg: x): ...
+                    bound = meth.__type_params__[0].__bound__
+                return Cls
+        """)
+        cls = ns["outer"]()
+        self.assertEqual(cls.val, "nonlocal")
+        self.assertEqual(cls.bound, "nonlocal")
+        self.assertEqual(cls.meth.__annotations__["arg"], "nonlocal")
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; + global
+    def test_explicit_global(self):
+        ns = run_code("""
+            x = "global"
+            def outer():
+                x = "nonlocal"
+                class Cls:
+                    global x
+                    type Alias = x
+                Cls.x = "class"
+                return Cls
+        """)
+        cls = ns["outer"]()
+        self.assertEqual(cls.Alias.__value__, "global")
+
+    def test_explicit_global_with_no_static_bound(self):
+        ns = run_code("""
+            def outer():
+                class Cls:
+                    global x
+                    type Alias = x
+                Cls.x = "class"
+                return Cls
+        """)
+        ns["x"] = "global"
+        cls = ns["outer"]()
+        self.assertEqual(cls.Alias.__value__, "global")
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; + global from class
+    def test_explicit_global_with_assignment(self):
+        ns = run_code("""
+            x = "global"
+            def outer():
+                x = "nonlocal"
+                class Cls:
+                    global x
+                    type Alias = x
+                    x = "global from class"
+                Cls.x = "class"
+                return Cls
+        """)
+        cls = ns["outer"]()
+        self.assertEqual(cls.Alias.__value__, "global from class")
+
+    def test_explicit_nonlocal(self):
+        ns = run_code("""
+            x = "global"
+            def outer():
+                x = "nonlocal"
+                class Cls:
+                    nonlocal x
+                    type Alias = x
+                    x = "class"
+                return Cls
+        """)
+        cls = ns["outer"]()
+        self.assertEqual(cls.Alias.__value__, "class")
+
+    def test_nested_free(self):
+        ns = run_code("""
+            def f():
+                T = str
+                class C:
+                    T = int
+                    class D[U](T):
+                        x = T
+                return C
+        """)
+        C = ns["f"]()
+        self.assertIn(int, C.D.__bases__)
+        self.assertIs(C.D.x, str)
+
+
+class DynamicClassTest(unittest.TestCase):
+    def _set_type_params(self, ns, params):
+        ns['__type_params__'] = params
+
+    def test_types_new_class_with_callback(self):
+        T = TypeVar('T', infer_variance=True)
+        Klass = types.new_class('Klass', (Generic[T],), {},
+                                lambda ns: self._set_type_params(ns, (T,)))
+
+        self.assertEqual(Klass.__bases__, (Generic,))
+        self.assertEqual(Klass.__orig_bases__, (Generic[T],))
+        self.assertEqual(Klass.__type_params__, (T,))
+        self.assertEqual(Klass.__parameters__, (T,))
+
+    def test_types_new_class_no_callback(self):
+        T = TypeVar('T', infer_variance=True)
+        Klass = types.new_class('Klass', (Generic[T],), {})
+
+        self.assertEqual(Klass.__bases__, (Generic,))
+        self.assertEqual(Klass.__orig_bases__, (Generic[T],))
+        self.assertEqual(Klass.__type_params__, ())  # must be explicitly set
+        self.assertEqual(Klass.__parameters__, (T,))
+
+
+class TypeParamsManglingTest(unittest.TestCase):
+    def test_mangling(self):
+        class Foo[__T]:
+            param = __T
+            def meth[__U](self, arg: __T, arg2: __U):
+                return (__T, __U)
+            type Alias[__V] = (__T, __V)
+
+        T = Foo.__type_params__[0]
+        self.assertEqual(T.__name__, "__T")
+        U = Foo.meth.__type_params__[0]
+        self.assertEqual(U.__name__, "__U")
+        V = Foo.Alias.__type_params__[0]
+        self.assertEqual(V.__name__, "__V")
+
+        anno = Foo.meth.__annotations__
+        self.assertIs(anno["arg"], T)
+        self.assertIs(anno["arg2"], U)
+        self.assertEqual(Foo().meth(1, 2), (T, U))
+
+        self.assertEqual(Foo.Alias.__value__, (T, V))
+
+    def test_no_leaky_mangling_in_module(self):
+        ns = run_code("""
+            __before = "before"
+            class X[T]: pass
+            __after = "after"
+        """)
+        self.assertEqual(ns["__before"], "before")
+        self.assertEqual(ns["__after"], "after")
+
+    def test_no_leaky_mangling_in_function(self):
+        ns = run_code("""
+            def f():
+                class X[T]: pass
+                _X_foo = 2
+                __foo = 1
+                assert locals()['__foo'] == 1
+                return __foo
+        """)
+        self.assertEqual(ns["f"](), 1)
+
+    def test_no_leaky_mangling_in_class(self):
+        ns = run_code("""
+            class Outer:
+                __before = "before"
+                class Inner[T]:
+                    __x = "inner"
+                __after = "after"
+        """)
+        Outer = ns["Outer"]
+        self.assertEqual(Outer._Outer__before, "before")
+        self.assertEqual(Outer.Inner._Inner__x, "inner")
+        self.assertEqual(Outer._Outer__after, "after")
+
+    def test_no_mangling_in_bases(self):
+        ns = run_code("""
+            class __Base:
+                def __init_subclass__(self, **kwargs):
+                    self.kwargs = kwargs
+
+            class Derived[T](__Base, __kwarg=1):
+                pass
+        """)
+        Derived = ns["Derived"]
+        self.assertEqual(Derived.__bases__, (ns["__Base"], Generic))
+        self.assertEqual(Derived.kwargs, {"__kwarg": 1})
+
+    def test_no_mangling_in_nested_scopes(self):
+        ns = run_code("""
+            from test.test_type_params import make_base
+
+            class __X:
+                pass
+
+            class Y[T: __X](
+                make_base(lambda: __X),
+                # doubly nested scope
+                make_base(lambda: (lambda: __X)),
+                # list comprehension
+                make_base([__X for _ in (1,)]),
+                # genexp
+                make_base(__X for _ in (1,)),
+            ):
+                pass
+        """)
+        Y = ns["Y"]
+        T, = Y.__type_params__
+        self.assertIs(T.__bound__, ns["__X"])
+        base0 = Y.__bases__[0]
+        self.assertIs(base0.__arg__(), ns["__X"])
+        base1 = Y.__bases__[1]
+        self.assertIs(base1.__arg__()(), ns["__X"])
+        base2 = Y.__bases__[2]
+        self.assertEqual(base2.__arg__, [ns["__X"]])
+        base3 = Y.__bases__[3]
+        self.assertEqual(list(base3.__arg__), [ns["__X"]])
+
+    def test_type_params_are_mangled(self):
+        ns = run_code("""
+            from test.test_type_params import make_base
+
+            class Foo[__T, __U: __T](make_base(__T), make_base(lambda: __T)):
+                param = __T
+        """)
+        Foo = ns["Foo"]
+        T, U = Foo.__type_params__
+        self.assertEqual(T.__name__, "__T")
+        self.assertEqual(U.__name__, "__U")
+        self.assertIs(U.__bound__, T)
+        self.assertIs(Foo.param, T)
+
+        base1, base2, *_ = Foo.__bases__
+        self.assertIs(base1.__arg__, T)
+        self.assertIs(base2.__arg__(), T)
+
+
+class TypeParamsComplexCallsTest(unittest.TestCase):
+    def test_defaults(self):
+        # Generic functions with both defaults and kwdefaults trigger a specific code path
+        # in the compiler.
+        def func[T](a: T = "a", *, b: T = "b"):
+            return (a, b)
+
+        T, = func.__type_params__
+        self.assertIs(func.__annotations__["a"], T)
+        self.assertIs(func.__annotations__["b"], T)
+        self.assertEqual(func(), ("a", "b"))
+        self.assertEqual(func(1), (1, "b"))
+        self.assertEqual(func(b=2), ("a", 2))
+
+    def test_complex_base(self):
+        class Base:
+            def __init_subclass__(cls, **kwargs) -> None:
+                cls.kwargs = kwargs
+
+        kwargs = {"c": 3}
+        # Base classes with **kwargs trigger a different code path in the compiler.
+        class C[T](Base, a=1, b=2, **kwargs):
+            pass
+
+        T, = C.__type_params__
+        self.assertEqual(T.__name__, "T")
+        self.assertEqual(C.kwargs, {"a": 1, "b": 2, "c": 3})
+        self.assertEqual(C.__bases__, (Base, Generic))
+
+        bases = (Base,)
+        class C2[T](*bases, **kwargs):
+            pass
+
+        T, = C2.__type_params__
+        self.assertEqual(T.__name__, "T")
+        self.assertEqual(C2.kwargs, {"c": 3})
+        self.assertEqual(C2.__bases__, (Base, Generic))
+
+    def test_starargs_base(self):
+        class C1[T](*()): pass
+
+        T, = C1.__type_params__
+        self.assertEqual(T.__name__, "T")
+        self.assertEqual(C1.__bases__, (Generic,))
+
+        class Base: pass
+        bases = [Base]
+        class C2[T](*bases): pass
+
+        T, = C2.__type_params__
+        self.assertEqual(T.__name__, "T")
+        self.assertEqual(C2.__bases__, (Base, Generic))
+
+
+class TypeParamsTraditionalTypeVarsTest(unittest.TestCase):
+    def test_traditional_01(self):
+        code = """
+            from typing import Generic
+            class ClassA[T](Generic[T]): ...
+        """
+
+        with self.assertRaisesRegex(TypeError, r"Cannot inherit from Generic\[...\] multiple times."):
+            run_code(code)
+
+    def test_traditional_02(self):
+        from typing import TypeVar
+        S = TypeVar("S")
+        with self.assertRaises(TypeError):
+            class ClassA[T](dict[T, S]): ...
+
+    def test_traditional_03(self):
+        # This does not generate a runtime error, but it should be
+        # flagged as an error by type checkers.
+        from typing import TypeVar
+        S = TypeVar("S")
+        def func[T](a: T, b: S) -> T | S:
+            return a
+
+
+class TypeParamsTypeVarTest(unittest.TestCase):
+    def test_typevar_01(self):
+        def func1[A: str, B: str | int, C: (int, str)]():
+            return (A, B, C)
+
+        a, b, c = func1()
+
+        self.assertIsInstance(a, TypeVar)
+        self.assertEqual(a.__bound__, str)
+        self.assertTrue(a.__infer_variance__)
+        self.assertFalse(a.__covariant__)
+        self.assertFalse(a.__contravariant__)
+
+        self.assertIsInstance(b, TypeVar)
+        self.assertEqual(b.__bound__, str | int)
+        self.assertTrue(b.__infer_variance__)
+        self.assertFalse(b.__covariant__)
+        self.assertFalse(b.__contravariant__)
+
+        self.assertIsInstance(c, TypeVar)
+        self.assertEqual(c.__bound__, None)
+        self.assertEqual(c.__constraints__, (int, str))
+        self.assertTrue(c.__infer_variance__)
+        self.assertFalse(c.__covariant__)
+        self.assertFalse(c.__contravariant__)
+
+    def test_typevar_generator(self):
+        def get_generator[A]():
+            def generator1[C]():
+                yield C
+
+            def generator2[B]():
+                yield A
+                yield B
+                yield from generator1()
+            return generator2
+
+        gen = get_generator()
+
+        a, b, c = [x for x in gen()]
+
+        self.assertIsInstance(a, TypeVar)
+        self.assertEqual(a.__name__, "A")
+        self.assertIsInstance(b, TypeVar)
+        self.assertEqual(b.__name__, "B")
+        self.assertIsInstance(c, TypeVar)
+        self.assertEqual(c.__name__, "C")
+
+    def test_typevar_coroutine(self):
+        def get_coroutine[A]():
+            async def coroutine[B]():
+                return (A, B)
+            return coroutine
+
+        co = get_coroutine()
+
+        a, b = run_no_yield_async_fn(co)
+
+        self.assertIsInstance(a, TypeVar)
+        self.assertEqual(a.__name__, "A")
+        self.assertIsInstance(b, TypeVar)
+        self.assertEqual(b.__name__, "B")
+
+
+class TypeParamsTypeVarTupleTest(unittest.TestCase):
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AssertionError: "cannot use bound with TypeVarTuple" does not match "invalid syntax (<test string>, line 1)"
+    def test_typevartuple_01(self):
+        code = """def func1[*A: str](): pass"""
+        check_syntax_error(self, code, "cannot use bound with TypeVarTuple")
+        code = """def func1[*A: (int, str)](): pass"""
+        check_syntax_error(self, code, "cannot use constraints with TypeVarTuple")
+        code = """class X[*A: str]: pass"""
+        check_syntax_error(self, code, "cannot use bound with TypeVarTuple")
+        code = """class X[*A: (int, str)]: pass"""
+        check_syntax_error(self, code, "cannot use constraints with TypeVarTuple")
+        code = """type X[*A: str] = int"""
+        check_syntax_error(self, code, "cannot use bound with TypeVarTuple")
+        code = """type X[*A: (int, str)] = int"""
+        check_syntax_error(self, code, "cannot use constraints with TypeVarTuple")
+
+    def test_typevartuple_02(self):
+        def func1[*A]():
+            return A
+
+        a = func1()
+        self.assertIsInstance(a, TypeVarTuple)
+
+
+class TypeParamsTypeVarParamSpecTest(unittest.TestCase):
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AssertionError: "cannot use bound with ParamSpec" does not match "invalid syntax (<test string>, line 1)"
+    def test_paramspec_01(self):
+        code = """def func1[**A: str](): pass"""
+        check_syntax_error(self, code, "cannot use bound with ParamSpec")
+        code = """def func1[**A: (int, str)](): pass"""
+        check_syntax_error(self, code, "cannot use constraints with ParamSpec")
+        code = """class X[**A: str]: pass"""
+        check_syntax_error(self, code, "cannot use bound with ParamSpec")
+        code = """class X[**A: (int, str)]: pass"""
+        check_syntax_error(self, code, "cannot use constraints with ParamSpec")
+        code = """type X[**A: str] = int"""
+        check_syntax_error(self, code, "cannot use bound with ParamSpec")
+        code = """type X[**A: (int, str)] = int"""
+        check_syntax_error(self, code, "cannot use constraints with ParamSpec")
+
+    def test_paramspec_02(self):
+        def func1[**A]():
+            return A
+
+        a = func1()
+        self.assertIsInstance(a, ParamSpec)
+        self.assertTrue(a.__infer_variance__)
+        self.assertFalse(a.__covariant__)
+        self.assertFalse(a.__contravariant__)
+
+
+class TypeParamsTypeParamsDunder(unittest.TestCase):
+    def test_typeparams_dunder_class_01(self):
+        class Outer[A, B]:
+            class Inner[C, D]:
+                @staticmethod
+                def get_typeparams():
+                    return A, B, C, D
+
+        a, b, c, d = Outer.Inner.get_typeparams()
+        self.assertEqual(Outer.__type_params__, (a, b))
+        self.assertEqual(Outer.Inner.__type_params__, (c, d))
+
+        self.assertEqual(Outer.__parameters__, (a, b))
+        self.assertEqual(Outer.Inner.__parameters__, (c, d))
+
+    def test_typeparams_dunder_class_02(self):
+        class ClassA:
+            pass
+
+        self.assertEqual(ClassA.__type_params__, ())
+
+    def test_typeparams_dunder_class_03(self):
+        code = """
+            class ClassA[A]():
+                pass
+            ClassA.__type_params__ = ()
+            params = ClassA.__type_params__
+        """
+
+        ns = run_code(code)
+        self.assertEqual(ns["params"], ())
+
+    def test_typeparams_dunder_function_01(self):
+        def outer[A, B]():
+            def inner[C, D]():
+                return A, B, C, D
+
+            return inner
+
+        inner = outer()
+        a, b, c, d = inner()
+        self.assertEqual(outer.__type_params__, (a, b))
+        self.assertEqual(inner.__type_params__, (c, d))
+
+    def test_typeparams_dunder_function_02(self):
+        def func1():
+            pass
+
+        self.assertEqual(func1.__type_params__, ())
+
+    def test_typeparams_dunder_function_03(self):
+        code = """
+            def func[A]():
+                pass
+            func.__type_params__ = ()
+        """
+
+        ns = run_code(code)
+        self.assertEqual(ns["func"].__type_params__, ())
+
+
+
+# All these type aliases are used for pickling tests:
+T = TypeVar('T')
+def func1[X](x: X) -> X: ...
+def func2[X, Y](x: X | Y) -> X | Y: ...
+def func3[X, *Y, **Z](x: X, y: tuple[*Y], z: Z) -> X: ...
+def func4[X: int, Y: (bytes, str)](x: X, y: Y) -> X | Y: ...
+
+class Class1[X]: ...
+class Class2[X, Y]: ...
+class Class3[X, *Y, **Z]: ...
+class Class4[X: int, Y: (bytes, str)]: ...
+
+
+class TypeParamsPickleTest(unittest.TestCase):
+    def test_pickling_functions(self):
+        things_to_test = [
+            func1,
+            func2,
+            func3,
+            func4,
+        ]
+        for thing in things_to_test:
+            for proto in range(pickle.HIGHEST_PROTOCOL + 1):
+                with self.subTest(thing=thing, proto=proto):
+                    pickled = pickle.dumps(thing, protocol=proto)
+                    self.assertEqual(pickle.loads(pickled), thing)
+
+    def test_pickling_classes(self):
+        things_to_test = [
+            Class1,
+            Class1[int],
+            Class1[T],
+
+            Class2,
+            Class2[int, T],
+            Class2[T, int],
+            Class2[int, str],
+
+            Class3,
+            Class3[int, T, str, bytes, [float, object, T]],
+
+            Class4,
+            Class4[int, bytes],
+            Class4[T, bytes],
+            Class4[int, T],
+            Class4[T, T],
+        ]
+        for thing in things_to_test:
+            for proto in range(pickle.HIGHEST_PROTOCOL + 1):
+                with self.subTest(thing=thing, proto=proto):
+                    pickled = pickle.dumps(thing, protocol=proto)
+                    self.assertEqual(pickle.loads(pickled), thing)
+
+        for klass in things_to_test:
+            real_class = getattr(klass, '__origin__', klass)
+            thing = klass()
+            for proto in range(pickle.HIGHEST_PROTOCOL + 1):
+                with self.subTest(thing=thing, proto=proto):
+                    pickled = pickle.dumps(thing, protocol=proto)
+                    # These instances are not equal,
+                    # but class check is good enough:
+                    self.assertIsInstance(pickle.loads(pickled), real_class)
+
+
+class TypeParamsWeakRefTest(unittest.TestCase):
+    def test_weakrefs(self):
+        T = TypeVar('T')
+        P = ParamSpec('P')
+        class OldStyle(Generic[T]):
+            pass
+
+        class NewStyle[T]:
+            pass
+
+        cases = [
+            T,
+            TypeVar('T', bound=int),
+            P,
+            P.args,
+            P.kwargs,
+            TypeVarTuple('Ts'),
+            OldStyle,
+            OldStyle[int],
+            OldStyle(),
+            NewStyle,
+            NewStyle[int],
+            NewStyle(),
+            Generic[T],
+        ]
+        for case in cases:
+            with self.subTest(case=case):
+                weakref.ref(case)
+
+
+class TypeParamsRuntimeTest(unittest.TestCase):
+    def test_name_error(self):
+        # gh-109118: This crashed the interpreter due to a refcounting bug
+        code = """
+        class name_2[name_5]:
+            class name_4[name_5](name_0):
+                pass
+        """
+        with self.assertRaises(NameError):
+            run_code(code)
+
+        # Crashed with a slightly different stack trace
+        code = """
+        class name_2[name_5]:
+            class name_4[name_5: name_5](name_0):
+                pass
+        """
+        with self.assertRaises(NameError):
+            run_code(code)
+
+    def test_broken_class_namespace(self):
+        code = """
+        class WeirdMapping(dict):
+            def __missing__(self, key):
+                if key == "T":
+                    raise RuntimeError
+                raise KeyError(key)
+
+        class Meta(type):
+            def __prepare__(name, bases):
+                return WeirdMapping()
+
+        class MyClass[V](metaclass=Meta):
+            class Inner[U](T):
+                pass
+        """
+        with self.assertRaises(RuntimeError):
+            run_code(code)
+
+
+class DefaultsTest(unittest.TestCase):
+    def test_defaults_on_func(self):
+        ns = run_code("""
+            def func[T=int, **U=float, *V=None]():
+                pass
+        """)
+
+        T, U, V = ns["func"].__type_params__
+        self.assertIs(T.__default__, int)
+        self.assertIs(U.__default__, float)
+        self.assertIs(V.__default__, None)
+
+    def test_defaults_on_class(self):
+        ns = run_code("""
+            class C[T=int, **U=float, *V=None]:
+                pass
+        """)
+
+        T, U, V = ns["C"].__type_params__
+        self.assertIs(T.__default__, int)
+        self.assertIs(U.__default__, float)
+        self.assertIs(V.__default__, None)
+
+    def test_defaults_on_type_alias(self):
+        ns = run_code("""
+            type Alias[T = int, **U = float, *V = None] = int
+        """)
+
+        T, U, V = ns["Alias"].__type_params__
+        self.assertIs(T.__default__, int)
+        self.assertIs(U.__default__, float)
+        self.assertIs(V.__default__, None)
+
+    def test_starred_invalid(self):
+        check_syntax_error(self, "type Alias[T = *int] = int")
+        check_syntax_error(self, "type Alias[**P = *int] = int")
+
+    def test_starred_typevartuple(self):
+        ns = run_code("""
+            default = tuple[int, str]
+            type Alias[*Ts = *default] = Ts
+        """)
+
+        Ts, = ns["Alias"].__type_params__
+        self.assertEqual(Ts.__default__, next(iter(ns["default"])))
+
+    def test_nondefault_after_default(self):
+        check_syntax_error(self, "def func[T=int, U](): pass", "non-default type parameter 'U' follows default type parameter")
+        check_syntax_error(self, "class C[T=int, U]: pass", "non-default type parameter 'U' follows default type parameter")
+        check_syntax_error(self, "type A[T=int, U] = int", "non-default type parameter 'U' follows default type parameter")
+
+    def test_lazy_evaluation(self):
+        ns = run_code("""
+            type Alias[T = Undefined, *U = Undefined, **V = Undefined] = int
+        """)
+
+        T, U, V = ns["Alias"].__type_params__
+
+        with self.assertRaises(NameError):
+            T.__default__
+        with self.assertRaises(NameError):
+            U.__default__
+        with self.assertRaises(NameError):
+            V.__default__
+
+        ns["Undefined"] = "defined"
+        self.assertEqual(T.__default__, "defined")
+        self.assertEqual(U.__default__, "defined")
+        self.assertEqual(V.__default__, "defined")
+
+        # Now it is cached
+        ns["Undefined"] = "redefined"
+        self.assertEqual(T.__default__, "defined")
+        self.assertEqual(U.__default__, "defined")
+        self.assertEqual(V.__default__, "defined")
+
+    def test_symtable_key_regression_default(self):
+        # Test against the bugs that would happen if we used .default_
+        # as the key in the symtable.
+        ns = run_code("""
+            type X[T = [T for T in [T]]] = T
+        """)
+
+        T, = ns["X"].__type_params__
+        self.assertEqual(T.__default__, [T])
+
+    def test_symtable_key_regression_name(self):
+        # Test against the bugs that would happen if we used .name
+        # as the key in the symtable.
+        ns = run_code("""
+            type X1[T = A] = T
+            type X2[T = B] = T
+            A = "A"
+            B = "B"
+        """)
+
+        self.assertEqual(ns["X1"].__type_params__[0].__default__, "A")
+        self.assertEqual(ns["X2"].__type_params__[0].__default__, "B")
+
+
+class TestEvaluateFunctions(unittest.TestCase):
+    def test_general(self):
+        type Alias = int
+        Alias2 = TypeAliasType("Alias2", int)
+        def f[T: int = int, **P = int, *Ts = int](): pass
+        T, P, Ts = f.__type_params__
+        T2 = TypeVar("T2", bound=int, default=int)
+        P2 = ParamSpec("P2", default=int)
+        Ts2 = TypeVarTuple("Ts2", default=int)
+        cases = [
+            Alias.evaluate_value,
+            Alias2.evaluate_value,
+            T.evaluate_bound,
+            T.evaluate_default,
+            P.evaluate_default,
+            Ts.evaluate_default,
+            T2.evaluate_bound,
+            T2.evaluate_default,
+            P2.evaluate_default,
+            Ts2.evaluate_default,
+        ]
+        for case in cases:
+            with self.subTest(case=case):
+                self.assertIs(case(1), int)
+                self.assertIs(annotationlib.call_evaluate_function(case, annotationlib.Format.VALUE), int)
+                self.assertIs(annotationlib.call_evaluate_function(case, annotationlib.Format.FORWARDREF), int)
+                self.assertEqual(annotationlib.call_evaluate_function(case, annotationlib.Format.STRING), 'int')
+
+    def test_constraints(self):
+        def f[T: (int, str)](): pass
+        T, = f.__type_params__
+        T2 = TypeVar("T2", int, str)
+        for case in [T, T2]:
+            with self.subTest(case=case):
+                self.assertEqual(case.evaluate_constraints(1), (int, str))
+                self.assertEqual(annotationlib.call_evaluate_function(case.evaluate_constraints, annotationlib.Format.VALUE), (int, str))
+                self.assertEqual(annotationlib.call_evaluate_function(case.evaluate_constraints, annotationlib.Format.FORWARDREF), (int, str))
+                self.assertEqual(annotationlib.call_evaluate_function(case.evaluate_constraints, annotationlib.Format.STRING), '(int, str)')
+
+    def test_const_evaluator(self):
+        T = TypeVar("T", bound=int)
+        self.assertEqual(repr(T.evaluate_bound), "<constevaluator <class 'int'>>")
+
+        ConstEvaluator = type(T.evaluate_bound)
+
+        with self.assertRaisesRegex(TypeError, r"cannot create '_typing\._ConstEvaluator' instances"):
+            ConstEvaluator()  # This used to segfault.
+        with self.assertRaisesRegex(TypeError, r"cannot set 'attribute' attribute of immutable type '_typing\._ConstEvaluator'"):
+            ConstEvaluator.attribute = 1
diff --git a/Lib/test/test_types.py b/Lib/test/test_types.py
index 06099b87427..1bd8efa6a51 100644
--- a/Lib/test/test_types.py
+++ b/Lib/test/test_types.py
@@ -431,7 +431,7 @@ def test(i, format_spec, result):
         test(123456, "1=20", '11111111111111123456')
         test(123456, "*=20", '**************123456')
 
-    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    @unittest.expectedFailureIfWindows("TODO: RUSTPYTHON; AssertionError: '1,234.57' != '1234.57'")
     @run_with_locale('LC_NUMERIC', 'en_US.UTF8', '')
     def test_float__format__locale(self):
         # test locale support for __format__ code 'n'
@@ -441,7 +441,7 @@ def test_float__format__locale(self):
             self.assertEqual(locale.format_string('%g', x, grouping=True), format(x, 'n'))
             self.assertEqual(locale.format_string('%.10g', x, grouping=True), format(x, '.10n'))
 
-    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    @unittest.expectedFailureIfWindows("TODO: RUSTPYTHON; AssertionError: '123,456,789,012,345,678,901,234,567,890' != '123456789012345678901234567890'")
     @run_with_locale('LC_NUMERIC', 'en_US.UTF8', '')
     def test_int__format__locale(self):
         # test locale support for __format__ code 'n' for integers
@@ -632,7 +632,6 @@ 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)
@@ -648,7 +647,6 @@ 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)
@@ -1364,7 +1362,7 @@ def test_copy(self):
         self.assertEqual(view['key1'], 70)
         self.assertEqual(copy['key1'], 27)
 
-    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; TypeError: unsupported operand type(s) for |: 'dict' and 'mappingproxy'
     def test_union(self):
         mapping = {'a': 0, 'b': 1, 'c': 2}
         view = self.mappingproxy(mapping)
@@ -2257,8 +2255,8 @@ def foo(): return gen
         self.assertIs(wrapper.__name__, gen.__name__)
 
         # Test AttributeErrors
-        for name in {'gi_running', 'gi_frame', 'gi_code', 'gi_yieldfrom',
-                     'cr_running', 'cr_frame', 'cr_code', 'cr_await'}:
+        for name in {'gi_running', 'gi_frame', 'gi_code', 'gi_yieldfrom', 'gi_suspended',
+                     'cr_running', 'cr_frame', 'cr_code', 'cr_await', 'cr_suspended'}:
             with self.assertRaises(AttributeError):
                 getattr(wrapper, name)
 
@@ -2267,14 +2265,17 @@ def foo(): return gen
         gen.gi_frame = object()
         gen.gi_code = object()
         gen.gi_yieldfrom = object()
+        gen.gi_suspended = object()
         self.assertIs(wrapper.gi_running, gen.gi_running)
         self.assertIs(wrapper.gi_frame, gen.gi_frame)
         self.assertIs(wrapper.gi_code, gen.gi_code)
         self.assertIs(wrapper.gi_yieldfrom, gen.gi_yieldfrom)
+        self.assertIs(wrapper.gi_suspended, gen.gi_suspended)
         self.assertIs(wrapper.cr_running, gen.gi_running)
         self.assertIs(wrapper.cr_frame, gen.gi_frame)
         self.assertIs(wrapper.cr_code, gen.gi_code)
         self.assertIs(wrapper.cr_await, gen.gi_yieldfrom)
+        self.assertIs(wrapper.cr_suspended, gen.gi_suspended)
 
         wrapper.close()
         gen.close.assert_called_once_with()
@@ -2393,7 +2394,7 @@ def foo(): return gen
         self.assertIs(wrapper.__await__(), gen)
 
         for name in ('__name__', '__qualname__', 'gi_code',
-                     'gi_running', 'gi_frame'):
+                     'gi_running', 'gi_frame', 'gi_suspended'):
             self.assertIs(getattr(foo(), name),
                           getattr(gen, name))
         self.assertIs(foo().cr_code, gen.gi_code)
@@ -2456,8 +2457,8 @@ def coro():
         self.assertEqual(repr(wrapper), str(wrapper))
         self.assertTrue(set(dir(wrapper)).issuperset({
             '__await__', '__iter__', '__next__', 'cr_code', 'cr_running',
-            'cr_frame', 'gi_code', 'gi_frame', 'gi_running', 'send',
-            'close', 'throw'}))
+            'cr_frame', 'cr_suspended', 'gi_code', 'gi_frame', 'gi_running',
+            'gi_suspended', 'send', 'close', 'throw'}))
 
 
 class FunctionTests(unittest.TestCase):
diff --git a/Lib/test/test_typing.py b/Lib/test/test_typing.py
index 3d101c62e12..448d16f1f4a 100644
--- a/Lib/test/test_typing.py
+++ b/Lib/test/test_typing.py
@@ -986,7 +986,6 @@ class C(Generic[T]): pass
                         )
 
 
-    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_two_parameters(self):
         T1 = TypeVar('T1')
         T2 = TypeVar('T2')
@@ -2281,7 +2280,6 @@ 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().
@@ -4211,7 +4209,6 @@ class P(Protocol):
         Alias2 = typing.Union[P, typing.Iterable]
         self.assertEqual(Alias, Alias2)
 
-    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_protocols_pickleable(self):
         global P, CP  # pickle wants to reference the class by name
         T = TypeVar('T')
@@ -4362,7 +4359,6 @@ 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):
@@ -4380,7 +4376,6 @@ def close(self):
         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):
@@ -5289,7 +5284,6 @@ def test_all_repr_eq_any(self):
                     self.assertNotEqual(repr(base), '')
                     self.assertEqual(base, base)
 
-    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_pickle(self):
         global C  # pickle wants to reference the class by name
         T = TypeVar('T')
@@ -5976,7 +5970,6 @@ def test_final_unmodified(self):
         def func(x): ...
         self.assertIs(func, final(func))
 
-    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_dunder_final(self):
         @final
         def func(): ...
@@ -6708,7 +6701,6 @@ 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; + {'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]})
@@ -7419,7 +7411,6 @@ def test_partial_evaluation(self):
             list[EqualToForwardRef('A')],
         )
 
-    @unittest.expectedFailure  # TODO: RUSTPYTHON; ImportError: cannot import name 'fwdref_module'
     def test_with_module(self):
         from test.typinganndata import fwdref_module
 
@@ -8442,7 +8433,6 @@ class Bar(NamedTuple):
         self.assertIsInstance(bar.attr, Vanilla)
         self.assertEqual(bar.attr.name, "attr")
 
-    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_setname_raises_the_same_as_on_other_classes(self):
         class CustomException(BaseException): pass
 
@@ -8909,14 +8899,12 @@ class NewGeneric[T](TypedDict):
         # The TypedDict constructor is not itself a TypedDict
         self.assertIs(is_typeddict(TypedDict), False)
 
-    @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
     def test_get_type_hints_generic(self):
         self.assertEqual(
             get_type_hints(BarGeneric),
@@ -9072,7 +9060,6 @@ class WithImplicitAny(B):
         with self.assertRaises(TypeError):
             WithImplicitAny[str]
 
-    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_non_generic_subscript(self):
         # For backward compatibility, subscription works
         # on arbitrary TypedDict types.
@@ -9200,7 +9187,6 @@ class Child(Base):
         self.assertEqual(Child.__readonly_keys__, frozenset())
         self.assertEqual(Child.__mutable_keys__, frozenset({'a'}))
 
-    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_combine_qualifiers(self):
         class AllTheThings(TypedDict):
             a: Annotated[Required[ReadOnly[int]], "why not"]
@@ -9442,7 +9428,6 @@ def test_repr(self):
         self.assertEqual(repr(Match[str]), 'typing.Match[str]')
         self.assertEqual(repr(Match[bytes]), 'typing.Match[bytes]')
 
-    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_cannot_subclass(self):
         with self.assertRaisesRegex(
             TypeError,
@@ -10854,7 +10839,6 @@ def test_no_call(self):
         with self.assertRaises(TypeError):
             NoDefault()
 
-    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_no_attributes(self):
         with self.assertRaises(AttributeError):
             NoDefault.foo = 3
@@ -10930,7 +10914,6 @@ class TypeIterationTests(BaseTestCase):
         Annotated[T, ''],
     )
 
-    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_cannot_iterate(self):
         expected_error_regex = "object is not iterable"
         for test_type in self._UNITERABLE_TYPES:
diff --git a/Lib/test/test_ucn.py b/Lib/test/test_ucn.py
index 69b58da0202..10f262cff12 100644
--- a/Lib/test/test_ucn.py
+++ b/Lib/test/test_ucn.py
@@ -203,7 +203,6 @@ def check_version(testfile):
                 with self.assertRaises(KeyError):
                     unicodedata.ucd_3_2_0.lookup(seqname)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_errors(self):
         self.assertRaises(TypeError, unicodedata.name)
         self.assertRaises(TypeError, unicodedata.name, 'xx')
diff --git a/Lib/test/test_unicodedata.py b/Lib/test/test_unicodedata.py
index e14123aaa65..bb54818ecb0 100644
--- a/Lib/test/test_unicodedata.py
+++ b/Lib/test/test_unicodedata.py
@@ -24,10 +24,9 @@
 class UnicodeMethodsTest(unittest.TestCase):
 
     # update this, if the database changes
-    expectedchecksum = '63aa77dcb36b0e1df082ee2a6071caeda7f0955e'
+    expectedchecksum = '9e43ee3929471739680c0e705482b4ae1c4122e4'
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; + 9e43ee3929471739680c0e705482b4ae1c4122e4
     @requires_resource('cpu')
     def test_method_checksum(self):
         h = hashlib.sha1()
@@ -79,10 +78,9 @@ class UnicodeFunctionsTest(UnicodeDatabaseTest):
 
     # Update this if the database changes. Make sure to do a full rebuild
     # (e.g. 'make distclean && make') to get the correct checksum.
-    expectedchecksum = '232affd2a50ec4bd69d2482aa0291385cbdefaba'
+    expectedchecksum = '23ab09ed4abdf93db23b97359108ed630dd8311d'
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AttributeError: module 'unicodedata' has no attribute 'digit'
     @requires_resource('cpu')
     def test_function_checksum(self):
         data = []
@@ -122,11 +120,9 @@ def test_no_names_in_pua(self):
             char = chr(i)
             self.assertRaises(ValueError, self.db.name, char)
 
-    # TODO: RUSTPYTHON; LookupError: undefined character name 'LATIN SMLL LETR A'
-    @unittest.expectedFailure
     def test_lookup_nonexistant(self):
         # just make sure that lookup can fail
-        for nonexistant in [
+        for nonexistent in [
             "LATIN SMLL LETR A",
             "OPEN HANDS SIGHS",
             "DREGS",
@@ -134,10 +130,8 @@ def test_lookup_nonexistant(self):
             "MODIFIER LETTER CYRILLIC SMALL QUESTION MARK",
             "???",
         ]:
-            self.assertRaises(KeyError, self.db.lookup, nonexistant)
+            self.assertRaises(KeyError, self.db.lookup, nonexistent)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_digit(self):
         self.assertEqual(self.db.digit('A', None), None)
         self.assertEqual(self.db.digit('9'), 9)
@@ -150,8 +144,6 @@ def test_digit(self):
         self.assertRaises(TypeError, self.db.digit, 'xx')
         self.assertRaises(ValueError, self.db.digit, 'x')
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_numeric(self):
         self.assertEqual(self.db.numeric('A',None), None)
         self.assertEqual(self.db.numeric('9'), 9)
@@ -165,8 +157,6 @@ def test_numeric(self):
         self.assertRaises(TypeError, self.db.numeric, 'xx')
         self.assertRaises(ValueError, self.db.numeric, 'x')
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_decimal(self):
         self.assertEqual(self.db.decimal('A',None), None)
         self.assertEqual(self.db.decimal('9'), 9)
@@ -189,8 +179,7 @@ def test_category(self):
         self.assertRaises(TypeError, self.db.category)
         self.assertRaises(TypeError, self.db.category, 'xx')
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; - L
     def test_bidirectional(self):
         self.assertEqual(self.db.bidirectional('\uFFFE'), '')
         self.assertEqual(self.db.bidirectional(' '), 'WS')
@@ -200,8 +189,6 @@ def test_bidirectional(self):
         self.assertRaises(TypeError, self.db.bidirectional)
         self.assertRaises(TypeError, self.db.bidirectional, 'xx')
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_decomposition(self):
         self.assertEqual(self.db.decomposition('\uFFFE'),'')
         self.assertEqual(self.db.decomposition('\u00bc'), '<fraction> 0031 2044 0034')
@@ -218,8 +205,6 @@ def test_mirrored(self):
         self.assertRaises(TypeError, self.db.mirrored)
         self.assertRaises(TypeError, self.db.mirrored, 'xx')
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_combining(self):
         self.assertEqual(self.db.combining('\uFFFE'), 0)
         self.assertEqual(self.db.combining('a'), 0)
@@ -247,8 +232,6 @@ def test_issue10254(self):
         b = 'C\u0338' * 20  + '\xC7'
         self.assertEqual(self.db.normalize('NFC', a), b)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_issue29456(self):
         # Fix #29456
         u1176_str_a = '\u1100\u1176\u11a8'
@@ -275,8 +258,7 @@ def test_east_asian_width(self):
         self.assertEqual(eaw('\u2010'), 'A')
         self.assertEqual(eaw('\U00020000'), 'W')
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; + W
     def test_east_asian_width_unassigned(self):
         eaw = self.db.east_asian_width
         # unassigned
@@ -294,8 +276,7 @@ def test_east_asian_width_unassigned(self):
             self.assertEqual(eaw(char), 'A')
             self.assertIs(self.db.name(char, None), None)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; + N
     def test_east_asian_width_9_0_changes(self):
         self.assertEqual(self.db.ucd_3_2_0.east_asian_width('\u231a'), 'N')
         self.assertEqual(self.db.east_asian_width('\u231a'), 'W')
@@ -307,8 +288,7 @@ def test_disallow_instantiation(self):
         # Ensure that the type disallows instantiation (bpo-43916)
         check_disallow_instantiation(self, unicodedata.UCD)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; ---
     @force_not_colorized
     def test_failed_import_during_compiling(self):
         # Issue 4367
@@ -326,8 +306,6 @@ def test_failed_import_during_compiling(self):
             "(can't load unicodedata module)"
         self.assertIn(error, result.err.decode("ascii"))
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_decimal_numeric_consistent(self):
         # Test that decimal and numeric are consistent,
         # i.e. if a character has a decimal value,
@@ -341,8 +319,6 @@ def test_decimal_numeric_consistent(self):
                 count += 1
         self.assertTrue(count >= 10) # should have tested at least the ASCII digits
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_digit_numeric_consistent(self):
         # Test that digit and numeric are consistent,
         # i.e. if a character has a digit value,
@@ -359,8 +335,7 @@ def test_digit_numeric_consistent(self):
     def test_bug_1704793(self):
         self.assertEqual(self.db.lookup("GOTHIC LETTER FAIHU"), '\U00010346')
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AssertionError: False is not true
     def test_ucd_510(self):
         import unicodedata
         # In UCD 5.1.0, a mirrored property changed wrt. UCD 3.2.0
@@ -384,8 +359,7 @@ def test_bug_5828(self):
             [0]
         )
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; + Dž
     def test_bug_4971(self):
         # LETTER DZ WITH CARON: DZ, Dz, dz
         self.assertEqual("\u01c4".title(), "\u01c5")
@@ -414,7 +388,7 @@ def unistr(data):
         data = [int(x, 16) for x in data.split(" ")]
         return "".join([chr(x) for x in data])
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AssertionError: False is not true : 13055
     @requires_resource('network')
     @requires_resource('cpu')
     def test_normalization(self):
@@ -502,6 +476,29 @@ def test_bug_834676(self):
         # Check for bug 834676
         unicodedata.normalize('NFC', '\ud55c\uae00')
 
+    def test_normalize_return_type(self):
+        # gh-129569: normalize() return type must always be str
+        normalize = unicodedata.normalize
+
+        class MyStr(str):
+            pass
+
+        normalization_forms = ("NFC", "NFKC", "NFD", "NFKD")
+        input_strings = (
+            # normalized strings
+            "",
+            "ascii",
+            # unnormalized strings
+            "\u1e0b\u0323",
+            "\u0071\u0307\u0323",
+        )
+
+        for form in normalization_forms:
+            for input_str in input_strings:
+                with self.subTest(form=form, input_str=input_str):
+                    self.assertIs(type(normalize(form, input_str)), str)
+                    self.assertIs(type(normalize(form, MyStr(input_str))), str)
+
 
 if __name__ == "__main__":
     unittest.main()
diff --git a/Lib/test/test_unittest/test_async_case.py b/Lib/test/test_unittest/test_async_case.py
index b1ccd644343..57228e78f8c 100644
--- a/Lib/test/test_unittest/test_async_case.py
+++ b/Lib/test/test_unittest/test_async_case.py
@@ -475,7 +475,6 @@ 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
diff --git a/Lib/test/test_unpack.py b/Lib/test/test_unpack.py
index 515ec128a08..305da05b7ce 100644
--- a/Lib/test/test_unpack.py
+++ b/Lib/test/test_unpack.py
@@ -18,6 +18,13 @@
     >>> a == 4 and b == 5 and c == 6
     True
 
+Unpack dict
+
+    >>> d = {4: 'four', 5: 'five', 6: 'six'}
+    >>> a, b, c = d
+    >>> a == 4 and b == 5 and c == 6
+    True
+
 Unpack implied tuple
 
     >>> a, b, c = 7, 8, 9
@@ -66,14 +73,14 @@
     >>> a, b = t
     Traceback (most recent call last):
       ...
-    ValueError: too many values to unpack (expected 2)
+    ValueError: too many values to unpack (expected 2, got 3)
 
 Unpacking tuple of wrong size
 
     >>> a, b = l
     Traceback (most recent call last):
       ...
-    ValueError: too many values to unpack (expected 2)
+    ValueError: too many values to unpack (expected 2, got 3)
 
 Unpacking sequence too short
 
@@ -140,14 +147,59 @@
     >>> () = [42]
     Traceback (most recent call last):
       ...
-    ValueError: too many values to unpack (expected 0)
+    ValueError: too many values to unpack (expected 0, got 1)
+
+Unpacking a larger iterable should raise ValuleError, but it
+should not entirely consume the iterable
 
+    >>> it = iter(range(100))
+    >>> x, y, z = it
+    Traceback (most recent call last):
+      ...
+    ValueError: too many values to unpack (expected 3)
+    >>> next(it)
+    4
+
+Unpacking unbalanced dict
+
+    >>> d = {4: 'four', 5: 'five', 6: 'six', 7: 'seven'}
+    >>> a, b, c = d
+    Traceback (most recent call last):
+      ...
+    ValueError: too many values to unpack (expected 3, got 4)
+
+Ensure that custom `__len__()` is NOT called when showing the error message
+
+    >>> class LengthTooLong:
+    ...     def __len__(self):
+    ...         return 5
+    ...     def __getitem__(self, i):
+    ...         return i*2
+    ...
+    >>> x, y, z = LengthTooLong()
+    Traceback (most recent call last):
+      ...
+    ValueError: too many values to unpack (expected 3)
+
+For evil cases like these as well, no actual count to be shown
+
+    >>> class BadLength:
+    ...     def __len__(self):
+    ...         return 1
+    ...     def __getitem__(self, i):
+    ...         return i*2
+    ...
+    >>> x, y, z = BadLength()
+    Traceback (most recent call last):
+      ...
+    ValueError: too many values to unpack (expected 3)
 """
 
 __test__ = {'doctests' : doctests}
 
 def load_tests(loader, tests, pattern):
-    tests.addTest(doctest.DocTestSuite())
+    from test.support.rustpython import DocTestChecker # TODO: RUSTPYTHON
+    tests.addTest(doctest.DocTestSuite(checker=DocTestChecker())) # XXX: RUSTPYTHON
     return tests
 
 
diff --git a/Lib/test/test_unpack_ex.py b/Lib/test/test_unpack_ex.py
new file mode 100644
index 00000000000..13b789f52dc
--- /dev/null
+++ b/Lib/test/test_unpack_ex.py
@@ -0,0 +1,413 @@
+# Tests for extended unpacking, starred expressions.
+
+import doctest
+import unittest
+
+
+doctests = """
+
+Unpack tuple
+
+    >>> t = (1, 2, 3)
+    >>> a, *b, c = t
+    >>> a == 1 and b == [2] and c == 3
+    True
+
+Unpack list
+
+    >>> l = [4, 5, 6]
+    >>> a, *b = l
+    >>> a == 4 and b == [5, 6]
+    True
+
+Unpack implied tuple
+
+    >>> *a, = 7, 8, 9
+    >>> a == [7, 8, 9]
+    True
+
+Unpack nested implied tuple
+
+    >>> [*[*a]] = [[7,8,9]]
+    >>> a == [[7,8,9]]
+    True
+
+Unpack string... fun!
+
+    >>> a, *b = 'one'
+    >>> a == 'o' and b == ['n', 'e']
+    True
+
+Unpack long sequence
+
+    >>> a, b, c, *d, e, f, g = range(10)
+    >>> (a, b, c, d, e, f, g) == (0, 1, 2, [3, 4, 5, 6], 7, 8, 9)
+    True
+
+Unpack short sequence
+
+    >>> a, *b, c = (1, 2)
+    >>> a == 1 and c == 2 and b == []
+    True
+
+Unpack generic sequence
+
+    >>> class Seq:
+    ...     def __getitem__(self, i):
+    ...         if i >= 0 and i < 3: return i
+    ...         raise IndexError
+    ...
+    >>> a, *b = Seq()
+    >>> a == 0 and b == [1, 2]
+    True
+
+Unpack in for statement
+
+    >>> for a, *b, c in [(1,2,3), (4,5,6,7)]:
+    ...     print(a, b, c)
+    ...
+    1 [2] 3
+    4 [5, 6] 7
+
+Unpack in list
+
+    >>> [a, *b, c] = range(5)
+    >>> a == 0 and b == [1, 2, 3] and c == 4
+    True
+
+Multiple targets
+
+    >>> a, *b, c = *d, e = range(5)
+    >>> a == 0 and b == [1, 2, 3] and c == 4 and d == [0, 1, 2, 3] and e == 4
+    True
+
+Assignment unpacking
+
+    >>> a, b, *c = range(5)
+    >>> a, b, c
+    (0, 1, [2, 3, 4])
+    >>> *a, b, c = a, b, *c
+    >>> a, b, c
+    ([0, 1, 2], 3, 4)
+
+Set display element unpacking
+
+    >>> a = [1, 2, 3]
+    >>> sorted({1, *a, 0, 4})
+    [0, 1, 2, 3, 4]
+
+    >>> {1, *1, 0, 4}
+    Traceback (most recent call last):
+      ...
+    TypeError: 'int' object is not iterable
+
+Dict display element unpacking
+
+    >>> kwds = {'z': 0, 'w': 12}
+    >>> sorted({'x': 1, 'y': 2, **kwds}.items())
+    [('w', 12), ('x', 1), ('y', 2), ('z', 0)]
+
+    >>> sorted({**{'x': 1}, 'y': 2, **{'z': 3}}.items())
+    [('x', 1), ('y', 2), ('z', 3)]
+
+    >>> sorted({**{'x': 1}, 'y': 2, **{'x': 3}}.items())
+    [('x', 3), ('y', 2)]
+
+    >>> sorted({**{'x': 1}, **{'x': 3}, 'x': 4}.items())
+    [('x', 4)]
+
+    >>> {**{}}
+    {}
+
+    >>> a = {}
+    >>> {**a}[0] = 1
+    >>> a
+    {}
+
+    >>> {**1}
+    Traceback (most recent call last):
+    ...
+    TypeError: 'int' object is not a mapping
+
+    >>> {**[]}
+    Traceback (most recent call last):
+    ...
+    TypeError: 'list' object is not a mapping
+
+    >>> len(eval("{" + ", ".join("**{{{}: {}}}".format(i, i)
+    ...                          for i in range(1000)) + "}"))
+    1000
+
+    >>> {0:1, **{0:2}, 0:3, 0:4}
+    {0: 4}
+
+List comprehension element unpacking
+
+    >>> a, b, c = [0, 1, 2], 3, 4
+    >>> [*a, b, c]
+    [0, 1, 2, 3, 4]
+
+    >>> l = [a, (3, 4), {5}, {6: None}, (i for i in range(7, 10))]
+    >>> [*item for item in l]
+    Traceback (most recent call last):
+    ...
+    SyntaxError: iterable unpacking cannot be used in comprehension
+
+    >>> [*[0, 1] for i in range(10)]
+    Traceback (most recent call last):
+    ...
+    SyntaxError: iterable unpacking cannot be used in comprehension
+
+    >>> [*'a' for i in range(10)]
+    Traceback (most recent call last):
+    ...
+    SyntaxError: iterable unpacking cannot be used in comprehension
+
+    >>> [*[] for i in range(10)]
+    Traceback (most recent call last):
+    ...
+    SyntaxError: iterable unpacking cannot be used in comprehension
+
+    >>> {**{} for a in [1]} # TODO: RUSTPYTHON # doctest: +EXPECTED_FAILURE
+    Traceback (most recent call last):
+    ...
+    SyntaxError: dict unpacking cannot be used in dict comprehension
+
+# Pegen is better here.
+# Generator expression in function arguments
+
+#     >>> list(*x for x in (range(5) for i in range(3)))
+#     Traceback (most recent call last):
+#     ...
+#         list(*x for x in (range(5) for i in range(3)))
+#                   ^
+#     SyntaxError: invalid syntax
+
+    >>> dict(**x for x in [{1:2}])
+    Traceback (most recent call last):
+    ...
+        dict(**x for x in [{1:2}])
+                   ^
+    SyntaxError: invalid syntax
+
+Iterable argument unpacking
+
+    >>> print(*[1], *[2], 3)
+    1 2 3
+
+Make sure that they don't corrupt the passed-in dicts.
+
+    >>> def f(x, y):
+    ...     print(x, y)
+    ...
+    >>> original_dict = {'x': 1}
+    >>> f(**original_dict, y=2)
+    1 2
+    >>> original_dict
+    {'x': 1}
+
+Now for some failures
+
+Make sure the raised errors are right for keyword argument unpackings
+
+    >>> from collections.abc import MutableMapping
+    >>> class CrazyDict(MutableMapping):
+    ...     def __init__(self):
+    ...         self.d = {}
+    ...
+    ...     def __iter__(self):
+    ...         for x in self.d.__iter__():
+    ...             if x == 'c':
+    ...                 self.d['z'] = 10
+    ...             yield x
+    ...
+    ...     def __getitem__(self, k):
+    ...         return self.d[k]
+    ...
+    ...     def __len__(self):
+    ...         return len(self.d)
+    ...
+    ...     def __setitem__(self, k, v):
+    ...         self.d[k] = v
+    ...
+    ...     def __delitem__(self, k):
+    ...         del self.d[k]
+    ...
+    >>> d = CrazyDict()
+    >>> d.d = {chr(ord('a') + x): x for x in range(5)}
+    >>> e = {**d}
+    Traceback (most recent call last):
+    ...
+    RuntimeError: dictionary changed size during iteration
+
+    >>> d.d = {chr(ord('a') + x): x for x in range(5)}
+    >>> def f(**kwargs): print(kwargs)
+    >>> f(**d)
+    Traceback (most recent call last):
+    ...
+    RuntimeError: dictionary changed size during iteration
+
+Overridden parameters
+
+    >>> f(x=5, **{'x': 3}, y=2)
+    Traceback (most recent call last):
+      ...
+    TypeError: test.test_unpack_ex.f() got multiple values for keyword argument 'x'
+
+    >>> f(**{'x': 3}, x=5, y=2)
+    Traceback (most recent call last):
+      ...
+    TypeError: test.test_unpack_ex.f() got multiple values for keyword argument 'x'
+
+    >>> f(**{'x': 3}, **{'x': 5}, y=2)
+    Traceback (most recent call last):
+      ...
+    TypeError: test.test_unpack_ex.f() got multiple values for keyword argument 'x'
+
+    >>> f(x=5, **{'x': 3}, **{'x': 2})
+    Traceback (most recent call last):
+      ...
+    TypeError: test.test_unpack_ex.f() got multiple values for keyword argument 'x'
+
+    >>> f(**{1: 3}, **{1: 5})
+    Traceback (most recent call last):
+      ...
+    TypeError: test.test_unpack_ex.f() got multiple values for keyword argument '1'
+
+Unpacking non-sequence
+
+    >>> a, *b = 7
+    Traceback (most recent call last):
+      ...
+    TypeError: cannot unpack non-iterable int object
+
+Unpacking sequence too short
+
+    >>> a, *b, c, d, e = Seq()
+    Traceback (most recent call last):
+      ...
+    ValueError: not enough values to unpack (expected at least 4, got 3)
+
+Unpacking sequence too short and target appears last
+
+    >>> a, b, c, d, *e = Seq()
+    Traceback (most recent call last):
+      ...
+    ValueError: not enough values to unpack (expected at least 4, got 3)
+
+Unpacking a sequence where the test for too long raises a different kind of
+error
+
+    >>> class BozoError(Exception):
+    ...     pass
+    ...
+    >>> class BadSeq:
+    ...     def __getitem__(self, i):
+    ...         if i >= 0 and i < 3:
+    ...             return i
+    ...         elif i == 3:
+    ...             raise BozoError
+    ...         else:
+    ...             raise IndexError
+    ...
+
+Trigger code while not expecting an IndexError (unpack sequence too long, wrong
+error)
+
+    >>> a, *b, c, d, e = BadSeq()
+    Traceback (most recent call last):
+      ...
+    test.test_unpack_ex.BozoError
+
+Now some general starred expressions (all fail).
+
+    >>> a, *b, c, *d, e = range(10) # doctest:+ELLIPSIS
+    Traceback (most recent call last):
+      ...
+    SyntaxError: multiple starred expressions in assignment
+
+    >>> [*b, *c] = range(10) # doctest:+ELLIPSIS
+    Traceback (most recent call last):
+      ...
+    SyntaxError: multiple starred expressions in assignment
+
+    >>> a,*b,*c,*d = range(4) # doctest:+ELLIPSIS
+    Traceback (most recent call last):
+      ...
+    SyntaxError: multiple starred expressions in assignment
+
+    >>> *a = range(10) # doctest:+ELLIPSIS
+    Traceback (most recent call last):
+      ...
+    SyntaxError: starred assignment target must be in a list or tuple
+
+    >>> *a # doctest:+ELLIPSIS
+    Traceback (most recent call last):
+      ...
+    SyntaxError: can't use starred expression here
+
+    >>> *1 # doctest:+ELLIPSIS
+    Traceback (most recent call last):
+      ...
+    SyntaxError: can't use starred expression here
+
+    >>> x = *a # doctest:+ELLIPSIS
+    Traceback (most recent call last):
+      ...
+    SyntaxError: can't use starred expression here
+
+    >>> (*x),y = 1, 2 # TODO: RUSTPYTHON # doctest:+ELLIPSIS +EXPECTED_FAILURE
+    Traceback (most recent call last):
+      ...
+    SyntaxError: cannot use starred expression here
+
+    >>> (((*x))),y = 1, 2 # TODO: RUSTPYTHON # doctest:+ELLIPSIS +EXPECTED_FAILURE
+    Traceback (most recent call last):
+      ...
+    SyntaxError: cannot use starred expression here
+
+    >>> z,(*x),y = 1, 2, 4 # TODO: RUSTPYTHON # doctest:+ELLIPSIS +EXPECTED_FAILURE
+    Traceback (most recent call last):
+      ...
+    SyntaxError: cannot use starred expression here
+
+    >>> z,(*x) = 1, 2 # TODO: RUSTPYTHON # doctest:+ELLIPSIS +EXPECTED_FAILURE
+    Traceback (most recent call last):
+      ...
+    SyntaxError: cannot use starred expression here
+
+    >>> ((*x),y) = 1, 2 # TODO: RUSTPYTHON # doctest:+ELLIPSIS +EXPECTED_FAILURE
+    Traceback (most recent call last):
+      ...
+    SyntaxError: cannot use starred expression here
+
+Some size constraints (all fail.)
+
+    >>> s = ", ".join("a%d" % i for i in range(1<<8)) + ", *rest = range(1<<8 + 1)"
+    >>> compile(s, 'test', 'exec') # doctest:+ELLIPSIS
+    Traceback (most recent call last):
+     ...
+    SyntaxError: too many expressions in star-unpacking assignment
+
+    >>> s = ", ".join("a%d" % i for i in range(1<<8 + 1)) + ", *rest = range(1<<8 + 2)"
+    >>> compile(s, 'test', 'exec') # doctest:+ELLIPSIS
+    Traceback (most recent call last):
+     ...
+    SyntaxError: too many expressions in star-unpacking assignment
+
+(there is an additional limit, on the number of expressions after the
+'*rest', but it's 1<<24 and testing it takes too much memory.)
+
+"""
+
+__test__ = {'doctests' : doctests}
+
+
+def load_tests(loader, tests, pattern):
+    from test.support.rustpython import DocTestChecker # TODO: RUSTPYTHON
+    tests.addTest(doctest.DocTestSuite(checker=DocTestChecker())) # XXX: RUSTPYTHON
+    return tests
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/Lib/test/test_unparse.py b/Lib/test/test_unparse.py
new file mode 100644
index 00000000000..35e4652a87b
--- /dev/null
+++ b/Lib/test/test_unparse.py
@@ -0,0 +1,1066 @@
+"""Tests for ast.unparse."""
+
+import unittest
+import test.support
+import pathlib
+import random
+import tokenize
+import warnings
+import ast
+from test.support.ast_helper import ASTTestMixin
+
+
+def read_pyfile(filename):
+    """Read and return the contents of a Python source file (as a
+    string), taking into account the file encoding."""
+    with tokenize.open(filename) as stream:
+        return stream.read()
+
+
+for_else = """\
+def f():
+    for x in range(10):
+        break
+    else:
+        y = 2
+    z = 3
+"""
+
+while_else = """\
+def g():
+    while True:
+        break
+    else:
+        y = 2
+    z = 3
+"""
+
+relative_import = """\
+from . import fred
+from .. import barney
+from .australia import shrimp as prawns
+"""
+
+nonlocal_ex = """\
+def f():
+    x = 1
+    def g():
+        nonlocal x
+        x = 2
+        y = 7
+        def h():
+            nonlocal x, y
+"""
+
+# also acts as test for 'except ... as ...'
+raise_from = """\
+try:
+    1 / 0
+except ZeroDivisionError as e:
+    raise ArithmeticError from e
+"""
+
+class_decorator = """\
+@f1(arg)
+@f2
+class Foo: pass
+"""
+
+elif1 = """\
+if cond1:
+    suite1
+elif cond2:
+    suite2
+else:
+    suite3
+"""
+
+elif2 = """\
+if cond1:
+    suite1
+elif cond2:
+    suite2
+"""
+
+try_except_finally = """\
+try:
+    suite1
+except ex1:
+    suite2
+except ex2:
+    suite3
+else:
+    suite4
+finally:
+    suite5
+"""
+
+try_except_star_finally = """\
+try:
+    suite1
+except* ex1:
+    suite2
+except* ex2:
+    suite3
+else:
+    suite4
+finally:
+    suite5
+"""
+
+with_simple = """\
+with f():
+    suite1
+"""
+
+with_as = """\
+with f() as x:
+    suite1
+"""
+
+with_two_items = """\
+with f() as x, g() as y:
+    suite1
+"""
+
+docstring_prefixes = (
+    "",
+    "class foo:\n    ",
+    "def foo():\n    ",
+    "async def foo():\n    ",
+)
+
+class ASTTestCase(ASTTestMixin, unittest.TestCase):
+    def check_ast_roundtrip(self, code1, **kwargs):
+        with self.subTest(code1=code1, ast_parse_kwargs=kwargs):
+            ast1 = ast.parse(code1, **kwargs)
+            code2 = ast.unparse(ast1)
+            ast2 = ast.parse(code2, **kwargs)
+            self.assertASTEqual(ast1, ast2)
+
+    def check_invalid(self, node, raises=ValueError):
+        with self.subTest(node=node):
+            self.assertRaises(raises, ast.unparse, node)
+
+    def get_source(self, code1, code2=None, **kwargs):
+        code2 = code2 or code1
+        code1 = ast.unparse(ast.parse(code1, **kwargs))
+        return code1, code2
+
+    def check_src_roundtrip(self, code1, code2=None, **kwargs):
+        code1, code2 = self.get_source(code1, code2, **kwargs)
+        with self.subTest(code1=code1, code2=code2):
+            self.assertEqual(code2, code1)
+
+    def check_src_dont_roundtrip(self, code1, code2=None):
+        code1, code2 = self.get_source(code1, code2)
+        with self.subTest(code1=code1, code2=code2):
+            self.assertNotEqual(code2, code1)
+
+class UnparseTestCase(ASTTestCase):
+    # Tests for specific bugs found in earlier versions of unparse
+
+    def test_fstrings(self):
+        self.check_ast_roundtrip("f'a'")
+        self.check_ast_roundtrip("f'{{}}'")
+        self.check_ast_roundtrip("f'{{5}}'")
+        self.check_ast_roundtrip("f'{{5}}5'")
+        self.check_ast_roundtrip("f'X{{}}X'")
+        self.check_ast_roundtrip("f'{a}'")
+        self.check_ast_roundtrip("f'{ {1:2}}'")
+        self.check_ast_roundtrip("f'a{a}a'")
+        self.check_ast_roundtrip("f'a{a}{a}a'")
+        self.check_ast_roundtrip("f'a{a}a{a}a'")
+        self.check_ast_roundtrip("f'{a!r}x{a!s}12{{}}{a!a}'")
+        self.check_ast_roundtrip("f'{a:10}'")
+        self.check_ast_roundtrip("f'{a:100_000{10}}'")
+        self.check_ast_roundtrip("f'{a!r:10}'")
+        self.check_ast_roundtrip("f'{a:a{b}10}'")
+        self.check_ast_roundtrip(
+                "f'a{b}{c!s}{d!r}{e!a}{f:a}{g:a{b}}{h!s:a}"
+                "{j!s:{a}b}{k!s:a{b}c}{l!a:{b}c{d}}{x+y=}'"
+        )
+
+    def test_fstrings_special_chars(self):
+        # See issue 25180
+        self.check_ast_roundtrip(r"""f'{f"{0}"*3}'""")
+        self.check_ast_roundtrip(r"""f'{f"{y}"*3}'""")
+        self.check_ast_roundtrip("""f''""")
+        self.check_ast_roundtrip('''f"""'end' "quote\\""""''')
+
+    def test_fstrings_complicated(self):
+        # See issue 28002
+        self.check_ast_roundtrip("""f'''{"'"}'''""")
+        self.check_ast_roundtrip('''f\'\'\'-{f"""*{f"+{f'.{x}.'}+"}*"""}-\'\'\'''')
+        self.check_ast_roundtrip('''f\'\'\'-{f"""*{f"+{f'.{x}.'}+"}*"""}-'single quote\\'\'\'\'''')
+        self.check_ast_roundtrip('f"""{\'\'\'\n\'\'\'}"""')
+        self.check_ast_roundtrip('f"""{g(\'\'\'\n\'\'\')}"""')
+        self.check_ast_roundtrip('''f"a\\r\\nb"''')
+        self.check_ast_roundtrip('''f"\\u2028{'x'}"''')
+
+    def test_fstrings_pep701(self):
+        self.check_ast_roundtrip('f" something { my_dict["key"] } something else "')
+        self.check_ast_roundtrip('f"{f"{f"{f"{f"{f"{1+1}"}"}"}"}"}"')
+
+    def test_tstrings(self):
+        self.check_ast_roundtrip("t'foo'")
+        self.check_ast_roundtrip("t'foo {bar}'")
+        self.check_ast_roundtrip("t'foo {bar!s:.2f}'")
+        self.check_ast_roundtrip("t'{a +    b}'")
+        self.check_ast_roundtrip("t'{a +    b:x}'")
+        self.check_ast_roundtrip("t'{a +    b!s}'")
+        self.check_ast_roundtrip("t'{ {a}}'")
+        self.check_ast_roundtrip("t'{ {a}=}'")
+        self.check_ast_roundtrip("t'{{a}}'")
+        self.check_ast_roundtrip("t''")
+        self.check_ast_roundtrip('t""')
+        self.check_ast_roundtrip("t'{(lambda x: x)}'")
+        self.check_ast_roundtrip("t'{t'{x}'}'")
+
+    def test_tstring_with_nonsensical_str_field(self):
+        # `value` suggests that the original code is `t'{test1}`, but `str` suggests otherwise
+        self.assertEqual(
+            ast.unparse(
+                ast.TemplateStr(
+                    values=[
+                        ast.Interpolation(
+                            value=ast.Name(id="test1", ctx=ast.Load()), str="test2", conversion=-1
+                        )
+                    ]
+                )
+            ),
+            "t'{test2}'",
+        )
+
+    def test_tstring_with_none_str_field(self):
+        self.assertEqual(
+            ast.unparse(
+                ast.TemplateStr(
+                    [ast.Interpolation(value=ast.Name(id="test1"), str=None, conversion=-1)]
+                )
+            ),
+            "t'{test1}'",
+        )
+        self.assertEqual(
+            ast.unparse(
+                ast.TemplateStr(
+                    [
+                        ast.Interpolation(
+                            value=ast.Lambda(
+                                args=ast.arguments(args=[ast.arg(arg="x")]),
+                                body=ast.Name(id="x"),
+                            ),
+                            str=None,
+                            conversion=-1,
+                        )
+                    ]
+                )
+            ),
+            "t'{(lambda x: x)}'",
+        )
+        self.assertEqual(
+            ast.unparse(
+                ast.TemplateStr(
+                    values=[
+                        ast.Interpolation(
+                            value=ast.TemplateStr(
+                                # `str` field kept here
+                                [ast.Interpolation(value=ast.Name(id="x"), str="y", conversion=-1)]
+                            ),
+                            str=None,
+                            conversion=-1,
+                        )
+                    ]
+                )
+            ),
+            '''t"{t'{y}'}"''',
+        )
+        self.assertEqual(
+            ast.unparse(
+                ast.TemplateStr(
+                    values=[
+                        ast.Interpolation(
+                            value=ast.TemplateStr(
+                                [ast.Interpolation(value=ast.Name(id="x"), str=None, conversion=-1)]
+                            ),
+                            str=None,
+                            conversion=-1,
+                        )
+                    ]
+                )
+            ),
+            '''t"{t'{x}'}"''',
+        )
+        self.assertEqual(
+            ast.unparse(ast.TemplateStr(
+                [ast.Interpolation(value=ast.Constant(value="foo"), str=None, conversion=114)]
+            )),
+            '''t"{'foo'!r}"''',
+        )
+
+    def test_strings(self):
+        self.check_ast_roundtrip("u'foo'")
+        self.check_ast_roundtrip("r'foo'")
+        self.check_ast_roundtrip("b'foo'")
+
+    def test_del_statement(self):
+        self.check_ast_roundtrip("del x, y, z")
+
+    def test_shifts(self):
+        self.check_ast_roundtrip("45 << 2")
+        self.check_ast_roundtrip("13 >> 7")
+
+    def test_for_else(self):
+        self.check_ast_roundtrip(for_else)
+
+    def test_while_else(self):
+        self.check_ast_roundtrip(while_else)
+
+    def test_unary_parens(self):
+        self.check_ast_roundtrip("(-1)**7")
+        self.check_ast_roundtrip("(-1.)**8")
+        self.check_ast_roundtrip("(-1j)**6")
+        self.check_ast_roundtrip("not True or False")
+        self.check_ast_roundtrip("True or not False")
+
+    def test_integer_parens(self):
+        self.check_ast_roundtrip("3 .__abs__()")
+
+    def test_huge_float(self):
+        self.check_ast_roundtrip("1e1000")
+        self.check_ast_roundtrip("-1e1000")
+        self.check_ast_roundtrip("1e1000j")
+        self.check_ast_roundtrip("-1e1000j")
+
+    def test_nan(self):
+        self.assertASTEqual(
+            ast.parse(ast.unparse(ast.Constant(value=float('nan')))),
+            ast.parse('1e1000 - 1e1000')
+        )
+
+    def test_min_int(self):
+        self.check_ast_roundtrip(str(-(2 ** 31)))
+        self.check_ast_roundtrip(str(-(2 ** 63)))
+
+    def test_imaginary_literals(self):
+        self.check_ast_roundtrip("7j")
+        self.check_ast_roundtrip("-7j")
+        self.check_ast_roundtrip("0j")
+        self.check_ast_roundtrip("-0j")
+
+    def test_lambda_parentheses(self):
+        self.check_ast_roundtrip("(lambda: int)()")
+
+    def test_chained_comparisons(self):
+        self.check_ast_roundtrip("1 < 4 <= 5")
+        self.check_ast_roundtrip("a is b is c is not d")
+
+    def test_function_arguments(self):
+        self.check_ast_roundtrip("def f(): pass")
+        self.check_ast_roundtrip("def f(a): pass")
+        self.check_ast_roundtrip("def f(b = 2): pass")
+        self.check_ast_roundtrip("def f(a, b): pass")
+        self.check_ast_roundtrip("def f(a, b = 2): pass")
+        self.check_ast_roundtrip("def f(a = 5, b = 2): pass")
+        self.check_ast_roundtrip("def f(*, a = 1, b = 2): pass")
+        self.check_ast_roundtrip("def f(*, a = 1, b): pass")
+        self.check_ast_roundtrip("def f(*, a, b = 2): pass")
+        self.check_ast_roundtrip("def f(a, b = None, *, c, **kwds): pass")
+        self.check_ast_roundtrip("def f(a=2, *args, c=5, d, **kwds): pass")
+        self.check_ast_roundtrip("def f(*args, **kwargs): pass")
+
+    def test_relative_import(self):
+        self.check_ast_roundtrip(relative_import)
+
+    def test_nonlocal(self):
+        self.check_ast_roundtrip(nonlocal_ex)
+
+    def test_raise_from(self):
+        self.check_ast_roundtrip(raise_from)
+
+    def test_bytes(self):
+        self.check_ast_roundtrip("b'123'")
+
+    def test_annotations(self):
+        self.check_ast_roundtrip("def f(a : int): pass")
+        self.check_ast_roundtrip("def f(a: int = 5): pass")
+        self.check_ast_roundtrip("def f(*args: [int]): pass")
+        self.check_ast_roundtrip("def f(**kwargs: dict): pass")
+        self.check_ast_roundtrip("def f() -> None: pass")
+
+    def test_set_literal(self):
+        self.check_ast_roundtrip("{'a', 'b', 'c'}")
+
+    def test_empty_set(self):
+        self.assertASTEqual(
+            ast.parse(ast.unparse(ast.Set(elts=[]))),
+            ast.parse('{*()}')
+        )
+
+    def test_set_comprehension(self):
+        self.check_ast_roundtrip("{x for x in range(5)}")
+
+    def test_dict_comprehension(self):
+        self.check_ast_roundtrip("{x: x*x for x in range(10)}")
+
+    def test_class_decorators(self):
+        self.check_ast_roundtrip(class_decorator)
+
+    def test_class_definition(self):
+        self.check_ast_roundtrip("class A(metaclass=type, *[], **{}): pass")
+
+    def test_elifs(self):
+        self.check_ast_roundtrip(elif1)
+        self.check_ast_roundtrip(elif2)
+
+    def test_try_except_finally(self):
+        self.check_ast_roundtrip(try_except_finally)
+
+    def test_try_except_star_finally(self):
+        self.check_ast_roundtrip(try_except_star_finally)
+
+    def test_starred_assignment(self):
+        self.check_ast_roundtrip("a, *b, c = seq")
+        self.check_ast_roundtrip("a, (*b, c) = seq")
+        self.check_ast_roundtrip("a, *b[0], c = seq")
+        self.check_ast_roundtrip("a, *(b, c) = seq")
+
+    def test_with_simple(self):
+        self.check_ast_roundtrip(with_simple)
+
+    def test_with_as(self):
+        self.check_ast_roundtrip(with_as)
+
+    def test_with_two_items(self):
+        self.check_ast_roundtrip(with_two_items)
+
+    def test_dict_unpacking_in_dict(self):
+        # See issue 26489
+        self.check_ast_roundtrip(r"""{**{'y': 2}, 'x': 1}""")
+        self.check_ast_roundtrip(r"""{**{'y': 2}, **{'x': 1}}""")
+
+    def test_slices(self):
+        self.check_ast_roundtrip("a[i]")
+        self.check_ast_roundtrip("a[i,]")
+        self.check_ast_roundtrip("a[i, j]")
+        # The AST for these next two both look like `a[(*a,)]`
+        self.check_ast_roundtrip("a[(*a,)]")
+        self.check_ast_roundtrip("a[*a]")
+        self.check_ast_roundtrip("a[b, *a]")
+        self.check_ast_roundtrip("a[*a, c]")
+        self.check_ast_roundtrip("a[b, *a, c]")
+        self.check_ast_roundtrip("a[*a, *a]")
+        self.check_ast_roundtrip("a[b, *a, *a]")
+        self.check_ast_roundtrip("a[*a, b, *a]")
+        self.check_ast_roundtrip("a[*a, *a, b]")
+        self.check_ast_roundtrip("a[b, *a, *a, c]")
+        self.check_ast_roundtrip("a[(a:=b)]")
+        self.check_ast_roundtrip("a[(a:=b,c)]")
+        self.check_ast_roundtrip("a[()]")
+        self.check_ast_roundtrip("a[i:j]")
+        self.check_ast_roundtrip("a[:j]")
+        self.check_ast_roundtrip("a[i:]")
+        self.check_ast_roundtrip("a[i:j:k]")
+        self.check_ast_roundtrip("a[:j:k]")
+        self.check_ast_roundtrip("a[i::k]")
+        self.check_ast_roundtrip("a[i:j,]")
+        self.check_ast_roundtrip("a[i:j, k]")
+
+    def test_invalid_raise(self):
+        self.check_invalid(ast.Raise(exc=None, cause=ast.Name(id="X", ctx=ast.Load())))
+
+    def test_invalid_fstring_value(self):
+        self.check_invalid(
+            ast.JoinedStr(
+                values=[
+                    ast.Name(id="test", ctx=ast.Load()),
+                    ast.Constant(value="test")
+                ]
+            )
+        )
+
+    def test_fstring_backslash(self):
+        # valid since Python 3.12
+        self.assertEqual(ast.unparse(
+                            ast.FormattedValue(
+                                value=ast.Constant(value="\\\\"),
+                                conversion=-1,
+                                format_spec=None,
+                            )
+                        ), "{'\\\\\\\\'}")
+
+    def test_invalid_yield_from(self):
+        self.check_invalid(ast.YieldFrom(value=None))
+
+    def test_import_from_level_none(self):
+        tree = ast.ImportFrom(module='mod', names=[ast.alias(name='x')])
+        self.assertEqual(ast.unparse(tree), "from mod import x")
+        tree = ast.ImportFrom(module='mod', names=[ast.alias(name='x')], level=None)
+        self.assertEqual(ast.unparse(tree), "from mod import x")
+
+    def test_docstrings(self):
+        docstrings = (
+            'this ends with double quote"',
+            'this includes a """triple quote"""',
+            '\r',
+            '\\r',
+            '\t',
+            '\\t',
+            '\n',
+            '\\n',
+            '\r\\r\t\\t\n\\n',
+            '""">>> content = \"\"\"blabla\"\"\" <<<"""',
+            r'foo\n\x00',
+            "' \\'\\'\\'\"\"\" \"\"\\'\\' \\'",
+            '🐍⛎𩸽üéş^\\\\X\\\\BB\N{LONG RIGHTWARDS SQUIGGLE ARROW}'
+        )
+        for docstring in docstrings:
+            # check as Module docstrings for easy testing
+            self.check_ast_roundtrip(f"'''{docstring}'''")
+
+    def test_constant_tuples(self):
+        locs = ast.fix_missing_locations
+        self.check_src_roundtrip(
+            locs(ast.Module([ast.Expr(ast.Constant(value=(1,)))])), "(1,)")
+        self.check_src_roundtrip(
+            locs(ast.Module([ast.Expr(ast.Constant(value=(1, 2, 3)))])), "(1, 2, 3)"
+        )
+
+    def test_function_type(self):
+        for function_type in (
+            "() -> int",
+            "(int, int) -> int",
+            "(Callable[complex], More[Complex(call.to_typevar())]) -> None"
+        ):
+            self.check_ast_roundtrip(function_type, mode="func_type")
+
+    def test_type_comments(self):
+        for statement in (
+            "a = 5 # type:",
+            "a = 5 # type: int",
+            "a = 5 # type: int and more",
+            "def x(): # type: () -> None\n\tpass",
+            "def x(y): # type: (int) -> None and more\n\tpass",
+            "async def x(): # type: () -> None\n\tpass",
+            "async def x(y): # type: (int) -> None and more\n\tpass",
+            "for x in y: # type: int\n\tpass",
+            "async for x in y: # type: int\n\tpass",
+            "with x(): # type: int\n\tpass",
+            "async with x(): # type: int\n\tpass"
+        ):
+            self.check_ast_roundtrip(statement, type_comments=True)
+
+    def test_type_ignore(self):
+        for statement in (
+            "a = 5 # type: ignore",
+            "a = 5 # type: ignore and more",
+            "def x(): # type: ignore\n\tpass",
+            "def x(y): # type: ignore and more\n\tpass",
+            "async def x(): # type: ignore\n\tpass",
+            "async def x(y): # type: ignore and more\n\tpass",
+            "for x in y: # type: ignore\n\tpass",
+            "async for x in y: # type: ignore\n\tpass",
+            "with x(): # type: ignore\n\tpass",
+            "async with x(): # type: ignore\n\tpass"
+        ):
+            self.check_ast_roundtrip(statement, type_comments=True)
+
+    def test_unparse_interactive_semicolons(self):
+        # gh-129598: Fix ast.unparse() when ast.Interactive contains multiple statements
+        self.check_src_roundtrip("i = 1; 'expr'; raise Exception", mode='single')
+        self.check_src_roundtrip("i: int = 1; j: float = 0; k += l", mode='single')
+        combinable = (
+            "'expr'",
+            "(i := 1)",
+            "import foo",
+            "from foo import bar",
+            "i = 1",
+            "i += 1",
+            "i: int = 1",
+            "return i",
+            "pass",
+            "break",
+            "continue",
+            "del i",
+            "assert i",
+            "global i",
+            "nonlocal j",
+            "await i",
+            "yield i",
+            "yield from i",
+            "raise i",
+            "type t[T] = ...",
+            "i",
+        )
+        for a in combinable:
+            for b in combinable:
+                self.check_src_roundtrip(f"{a}; {b}", mode='single')
+
+    def test_unparse_interactive_integrity_1(self):
+        # rest of unparse_interactive_integrity tests just make sure mode='single' parse and unparse didn't break
+        self.check_src_roundtrip(
+            "if i:\n 'expr'\nelse:\n raise Exception",
+            "if i:\n    'expr'\nelse:\n    raise Exception",
+            mode='single'
+        )
+        self.check_src_roundtrip(
+            "@decorator1\n@decorator2\ndef func():\n 'docstring'\n i = 1; 'expr'; raise Exception",
+            '''@decorator1\n@decorator2\ndef func():\n    """docstring"""\n    i = 1\n    'expr'\n    raise Exception''',
+            mode='single'
+        )
+        self.check_src_roundtrip(
+            "@decorator1\n@decorator2\nclass cls:\n 'docstring'\n i = 1; 'expr'; raise Exception",
+            '''@decorator1\n@decorator2\nclass cls:\n    """docstring"""\n    i = 1\n    'expr'\n    raise Exception''',
+            mode='single'
+        )
+
+    def test_unparse_interactive_integrity_2(self):
+        for statement in (
+            "def x():\n    pass",
+            "def x(y):\n    pass",
+            "async def x():\n    pass",
+            "async def x(y):\n    pass",
+            "for x in y:\n    pass",
+            "async for x in y:\n    pass",
+            "with x():\n    pass",
+            "async with x():\n    pass",
+            "def f():\n    pass",
+            "def f(a):\n    pass",
+            "def f(b=2):\n    pass",
+            "def f(a, b):\n    pass",
+            "def f(a, b=2):\n    pass",
+            "def f(a=5, b=2):\n    pass",
+            "def f(*, a=1, b=2):\n    pass",
+            "def f(*, a=1, b):\n    pass",
+            "def f(*, a, b=2):\n    pass",
+            "def f(a, b=None, *, c, **kwds):\n    pass",
+            "def f(a=2, *args, c=5, d, **kwds):\n    pass",
+            "def f(*args, **kwargs):\n    pass",
+            "class cls:\n\n    def f(self):\n        pass",
+            "class cls:\n\n    def f(self, a):\n        pass",
+            "class cls:\n\n    def f(self, b=2):\n        pass",
+            "class cls:\n\n    def f(self, a, b):\n        pass",
+            "class cls:\n\n    def f(self, a, b=2):\n        pass",
+            "class cls:\n\n    def f(self, a=5, b=2):\n        pass",
+            "class cls:\n\n    def f(self, *, a=1, b=2):\n        pass",
+            "class cls:\n\n    def f(self, *, a=1, b):\n        pass",
+            "class cls:\n\n    def f(self, *, a, b=2):\n        pass",
+            "class cls:\n\n    def f(self, a, b=None, *, c, **kwds):\n        pass",
+            "class cls:\n\n    def f(self, a=2, *args, c=5, d, **kwds):\n        pass",
+            "class cls:\n\n    def f(self, *args, **kwargs):\n        pass",
+        ):
+            self.check_src_roundtrip(statement, mode='single')
+
+    def test_unparse_interactive_integrity_3(self):
+        for statement in (
+            "def x():",
+            "def x(y):",
+            "async def x():",
+            "async def x(y):",
+            "for x in y:",
+            "async for x in y:",
+            "with x():",
+            "async with x():",
+            "def f():",
+            "def f(a):",
+            "def f(b=2):",
+            "def f(a, b):",
+            "def f(a, b=2):",
+            "def f(a=5, b=2):",
+            "def f(*, a=1, b=2):",
+            "def f(*, a=1, b):",
+            "def f(*, a, b=2):",
+            "def f(a, b=None, *, c, **kwds):",
+            "def f(a=2, *args, c=5, d, **kwds):",
+            "def f(*args, **kwargs):",
+        ):
+            src = statement + '\n i=1;j=2'
+            out = statement + '\n    i = 1\n    j = 2'
+
+            self.check_src_roundtrip(src, out, mode='single')
+
+
+class CosmeticTestCase(ASTTestCase):
+    """Test if there are cosmetic issues caused by unnecessary additions"""
+
+    def test_simple_expressions_parens(self):
+        self.check_src_roundtrip("(a := b)")
+        self.check_src_roundtrip("await x")
+        self.check_src_roundtrip("x if x else y")
+        self.check_src_roundtrip("lambda x: x")
+        self.check_src_roundtrip("1 + 1")
+        self.check_src_roundtrip("1 + 2 / 3")
+        self.check_src_roundtrip("(1 + 2) / 3")
+        self.check_src_roundtrip("(1 + 2) * 3 + 4 * (5 + 2)")
+        self.check_src_roundtrip("(1 + 2) * 3 + 4 * (5 + 2) ** 2")
+        self.check_src_roundtrip("~x")
+        self.check_src_roundtrip("x and y")
+        self.check_src_roundtrip("x and y and z")
+        self.check_src_roundtrip("x and (y and x)")
+        self.check_src_roundtrip("(x and y) and z")
+        self.check_src_roundtrip("(x ** y) ** z ** q")
+        self.check_src_roundtrip("x >> y")
+        self.check_src_roundtrip("x << y")
+        self.check_src_roundtrip("x >> y and x >> z")
+        self.check_src_roundtrip("x + y - z * q ^ t ** k")
+        self.check_src_roundtrip("P * V if P and V else n * R * T")
+        self.check_src_roundtrip("lambda P, V, n: P * V == n * R * T")
+        self.check_src_roundtrip("flag & (other | foo)")
+        self.check_src_roundtrip("not x == y")
+        self.check_src_roundtrip("x == (not y)")
+        self.check_src_roundtrip("yield x")
+        self.check_src_roundtrip("yield from x")
+        self.check_src_roundtrip("call((yield x))")
+        self.check_src_roundtrip("return x + (yield x)")
+
+    def test_class_bases_and_keywords(self):
+        self.check_src_roundtrip("class X:\n    pass")
+        self.check_src_roundtrip("class X(A):\n    pass")
+        self.check_src_roundtrip("class X(A, B, C, D):\n    pass")
+        self.check_src_roundtrip("class X(x=y):\n    pass")
+        self.check_src_roundtrip("class X(metaclass=z):\n    pass")
+        self.check_src_roundtrip("class X(x=y, z=d):\n    pass")
+        self.check_src_roundtrip("class X(A, x=y):\n    pass")
+        self.check_src_roundtrip("class X(A, **kw):\n    pass")
+        self.check_src_roundtrip("class X(*args):\n    pass")
+        self.check_src_roundtrip("class X(*args, **kwargs):\n    pass")
+
+    def test_fstrings(self):
+        self.check_src_roundtrip('''f\'\'\'-{f"""*{f"+{f'.{x}.'}+"}*"""}-\'\'\'''')
+        self.check_src_roundtrip('''f\'-{f\'\'\'*{f"""+{f".{f'{x}'}."}+"""}*\'\'\'}-\'''')
+        self.check_src_roundtrip('''f\'-{f\'*{f\'\'\'+{f""".{f"{f'{x}'}"}."""}+\'\'\'}*\'}-\'''')
+        self.check_src_roundtrip('''f"\\u2028{'x'}"''')
+        self.check_src_roundtrip(r"f'{x}\n'")
+        self.check_src_roundtrip('''f"{'\\n'}\\n"''')
+        self.check_src_roundtrip('''f"{f'{x}\\n'}\\n"''')
+
+    def test_docstrings(self):
+        docstrings = (
+            '"""simple doc string"""',
+            '''"""A more complex one
+            with some newlines"""''',
+            '''"""Foo bar baz
+
+            empty newline"""''',
+            '"""With some \t"""',
+            '"""Foo "bar" baz """',
+            '"""\\r"""',
+            '""""""',
+            '"""\'\'\'"""',
+            '"""\'\'\'\'\'\'"""',
+            '"""🐍⛎𩸽üéş^\\\\X\\\\BB⟿"""',
+            '"""end in single \'quote\'"""',
+            "'''end in double \"quote\"'''",
+            '"""almost end in double "quote"."""',
+        )
+
+        for prefix in docstring_prefixes:
+            for docstring in docstrings:
+                self.check_src_roundtrip(f"{prefix}{docstring}")
+
+    def test_docstrings_negative_cases(self):
+        # Test some cases that involve strings in the children of the
+        # first node but aren't docstrings to make sure we don't have
+        # False positives.
+        docstrings_negative = (
+            'a = """false"""',
+            '"""false""" + """unless its optimized"""',
+            '1 + 1\n"""false"""',
+            'f"""no, top level but f-fstring"""'
+        )
+        for prefix in docstring_prefixes:
+            for negative in docstrings_negative:
+                # this cases should be result with single quote
+                # rather then triple quoted docstring
+                src = f"{prefix}{negative}"
+                self.check_ast_roundtrip(src)
+                self.check_src_dont_roundtrip(src)
+
+    def test_unary_op_factor(self):
+        for prefix in ("+", "-", "~"):
+            self.check_src_roundtrip(f"{prefix}1")
+        for prefix in ("not",):
+            self.check_src_roundtrip(f"{prefix} 1")
+
+    def test_slices(self):
+        self.check_src_roundtrip("a[()]")
+        self.check_src_roundtrip("a[1]")
+        self.check_src_roundtrip("a[1, 2]")
+        # Note that `a[*a]`, `a[*a,]`, and `a[(*a,)]` all evaluate to the same
+        # thing at runtime and have the same AST, but only `a[*a,]` passes
+        # this test, because that's what `ast.unparse` produces.
+        self.check_src_roundtrip("a[*a,]")
+        self.check_src_roundtrip("a[1, *a]")
+        self.check_src_roundtrip("a[*a, 2]")
+        self.check_src_roundtrip("a[1, *a, 2]")
+        self.check_src_roundtrip("a[*a, *a]")
+        self.check_src_roundtrip("a[1, *a, *a]")
+        self.check_src_roundtrip("a[*a, 1, *a]")
+        self.check_src_roundtrip("a[*a, *a, 1]")
+        self.check_src_roundtrip("a[1, *a, *a, 2]")
+        self.check_src_roundtrip("a[1:2, *a]")
+        self.check_src_roundtrip("a[*a, 1:2]")
+
+    def test_lambda_parameters(self):
+        self.check_src_roundtrip("lambda: something")
+        self.check_src_roundtrip("four = lambda: 2 + 2")
+        self.check_src_roundtrip("lambda x: x * 2")
+        self.check_src_roundtrip("square = lambda n: n ** 2")
+        self.check_src_roundtrip("lambda x, y: x + y")
+        self.check_src_roundtrip("add = lambda x, y: x + y")
+        self.check_src_roundtrip("lambda x, y, /, z, q, *, u: None")
+        self.check_src_roundtrip("lambda x, *y, **z: None")
+
+    def test_star_expr_assign_target(self):
+        for source_type, source in [
+            ("single assignment", "{target} = foo"),
+            ("multiple assignment", "{target} = {target} = bar"),
+            ("for loop", "for {target} in foo:\n    pass"),
+            ("async for loop", "async for {target} in foo:\n    pass")
+        ]:
+            for target in [
+                "a",
+                "a,",
+                "a, b",
+                "a, *b, c",
+                "a, (b, c), d",
+                "a, (b, c, d), *e",
+                "a, (b, *c, d), e",
+                "a, (b, *c, (d, e), f), g",
+                "[a]",
+                "[a, b]",
+                "[a, *b, c]",
+                "[a, [b, c], d]",
+                "[a, [b, c, d], *e]",
+                "[a, [b, *c, d], e]",
+                "[a, [b, *c, [d, e], f], g]",
+                "a, [b, c], d",
+                "[a, b, (c, d), (e, f)]",
+                "a, b, [*c], d, e"
+            ]:
+                with self.subTest(source_type=source_type, target=target):
+                    self.check_src_roundtrip(source.format(target=target))
+
+    def test_star_expr_assign_target_multiple(self):
+        self.check_src_roundtrip("() = []")
+        self.check_src_roundtrip("[] = ()")
+        self.check_src_roundtrip("() = [a] = c, = [d] = e, f = () = g = h")
+        self.check_src_roundtrip("a = b = c = d")
+        self.check_src_roundtrip("a, b = c, d = e, f = g")
+        self.check_src_roundtrip("[a, b] = [c, d] = [e, f] = g")
+        self.check_src_roundtrip("a, b = [c, d] = e, f = g")
+
+    def test_multiquote_joined_string(self):
+        self.check_ast_roundtrip("f\"'''{1}\\\"\\\"\\\"\" ")
+        self.check_ast_roundtrip("""f"'''{1}""\\"" """)
+        self.check_ast_roundtrip("""f'""\"{1}''' """)
+        self.check_ast_roundtrip("""f'""\"{1}""\\"' """)
+
+        self.check_ast_roundtrip("""f"'''{"\\n"}""\\"" """)
+        self.check_ast_roundtrip("""f'""\"{"\\n"}''' """)
+        self.check_ast_roundtrip("""f'""\"{"\\n"}""\\"' """)
+
+        self.check_ast_roundtrip("""f'''""\"''\\'{"\\n"}''' """)
+        self.check_ast_roundtrip("""f'''""\"''\\'{"\\n\\"'"}''' """)
+        self.check_ast_roundtrip("""f'''""\"''\\'{""\"\\n\\"'''""\" '''\\n'''}''' """)
+
+    def test_backslash_in_format_spec(self):
+        import re
+        msg = re.escape('"\\ " is an invalid escape sequence. '
+                        'Such sequences will not work in the future. '
+                        'Did you mean "\\\\ "? A raw string is also an option.')
+        with self.assertWarnsRegex(SyntaxWarning, msg):
+            self.check_ast_roundtrip("""f"{x:\\ }" """)
+        self.check_ast_roundtrip("""f"{x:\\n}" """)
+
+        self.check_ast_roundtrip("""f"{x:\\\\ }" """)
+
+        with self.assertWarnsRegex(SyntaxWarning, msg):
+            self.check_ast_roundtrip("""f"{x:\\\\\\ }" """)
+        self.check_ast_roundtrip("""f"{x:\\\\\\n}" """)
+
+        self.check_ast_roundtrip("""f"{x:\\\\\\\\ }" """)
+
+    def test_quote_in_format_spec(self):
+        self.check_ast_roundtrip("""f"{x:'}" """)
+        self.check_ast_roundtrip("""f"{x:\\'}" """)
+        self.check_ast_roundtrip("""f"{x:\\\\'}" """)
+
+        self.check_ast_roundtrip("""f'\\'{x:"}' """)
+        self.check_ast_roundtrip("""f'\\'{x:\\"}' """)
+        self.check_ast_roundtrip("""f'\\'{x:\\\\"}' """)
+
+    def test_type_params(self):
+        self.check_ast_roundtrip("type A = int")
+        self.check_ast_roundtrip("type A[T] = int")
+        self.check_ast_roundtrip("type A[T: int] = int")
+        self.check_ast_roundtrip("type A[T = int] = int")
+        self.check_ast_roundtrip("type A[T: int = int] = int")
+        self.check_ast_roundtrip("type A[**P] = int")
+        self.check_ast_roundtrip("type A[**P = int] = int")
+        self.check_ast_roundtrip("type A[*Ts] = int")
+        self.check_ast_roundtrip("type A[*Ts = int] = int")
+        self.check_ast_roundtrip("type A[*Ts = *int] = int")
+        self.check_ast_roundtrip("def f[T: int = int, **P = int, *Ts = *int]():\n    pass")
+        self.check_ast_roundtrip("class C[T: int = int, **P = int, *Ts = *int]():\n    pass")
+
+
+class ManualASTCreationTestCase(unittest.TestCase):
+    """Test that AST nodes created without a type_params field unparse correctly."""
+
+    def test_class(self):
+        node = ast.ClassDef(name="X", bases=[], keywords=[], body=[ast.Pass()], decorator_list=[])
+        ast.fix_missing_locations(node)
+        self.assertEqual(ast.unparse(node), "class X:\n    pass")
+
+    def test_class_with_type_params(self):
+        node = ast.ClassDef(name="X", bases=[], keywords=[], body=[ast.Pass()], decorator_list=[],
+                             type_params=[ast.TypeVar("T")])
+        ast.fix_missing_locations(node)
+        self.assertEqual(ast.unparse(node), "class X[T]:\n    pass")
+
+    def test_function(self):
+        node = ast.FunctionDef(
+            name="f",
+            args=ast.arguments(posonlyargs=[], args=[], vararg=None, kwonlyargs=[], kw_defaults=[], kwarg=None, defaults=[]),
+            body=[ast.Pass()],
+            decorator_list=[],
+            returns=None,
+        )
+        ast.fix_missing_locations(node)
+        self.assertEqual(ast.unparse(node), "def f():\n    pass")
+
+    def test_function_with_type_params(self):
+        node = ast.FunctionDef(
+            name="f",
+            args=ast.arguments(posonlyargs=[], args=[], vararg=None, kwonlyargs=[], kw_defaults=[], kwarg=None, defaults=[]),
+            body=[ast.Pass()],
+            decorator_list=[],
+            returns=None,
+            type_params=[ast.TypeVar("T")],
+        )
+        ast.fix_missing_locations(node)
+        self.assertEqual(ast.unparse(node), "def f[T]():\n    pass")
+
+    def test_function_with_type_params_and_bound(self):
+        node = ast.FunctionDef(
+            name="f",
+            args=ast.arguments(posonlyargs=[], args=[], vararg=None, kwonlyargs=[], kw_defaults=[], kwarg=None, defaults=[]),
+            body=[ast.Pass()],
+            decorator_list=[],
+            returns=None,
+            type_params=[ast.TypeVar("T", bound=ast.Name("int", ctx=ast.Load()))],
+        )
+        ast.fix_missing_locations(node)
+        self.assertEqual(ast.unparse(node), "def f[T: int]():\n    pass")
+
+    def test_function_with_type_params_and_default(self):
+        node = ast.FunctionDef(
+            name="f",
+            args=ast.arguments(),
+            body=[ast.Pass()],
+            type_params=[
+                ast.TypeVar("T", default_value=ast.Constant(value=1)),
+                ast.TypeVarTuple("Ts", default_value=ast.Starred(value=ast.Constant(value=1), ctx=ast.Load())),
+                ast.ParamSpec("P", default_value=ast.Constant(value=1)),
+            ],
+        )
+        ast.fix_missing_locations(node)
+        self.assertEqual(ast.unparse(node), "def f[T = 1, *Ts = *1, **P = 1]():\n    pass")
+
+    def test_async_function(self):
+        node = ast.AsyncFunctionDef(
+            name="f",
+            args=ast.arguments(posonlyargs=[], args=[], vararg=None, kwonlyargs=[], kw_defaults=[], kwarg=None, defaults=[]),
+            body=[ast.Pass()],
+            decorator_list=[],
+            returns=None,
+        )
+        ast.fix_missing_locations(node)
+        self.assertEqual(ast.unparse(node), "async def f():\n    pass")
+
+    def test_async_function_with_type_params(self):
+        node = ast.AsyncFunctionDef(
+            name="f",
+            args=ast.arguments(posonlyargs=[], args=[], vararg=None, kwonlyargs=[], kw_defaults=[], kwarg=None, defaults=[]),
+            body=[ast.Pass()],
+            decorator_list=[],
+            returns=None,
+            type_params=[ast.TypeVar("T")],
+        )
+        ast.fix_missing_locations(node)
+        self.assertEqual(ast.unparse(node), "async def f[T]():\n    pass")
+
+    def test_async_function_with_type_params_and_default(self):
+        node = ast.AsyncFunctionDef(
+            name="f",
+            args=ast.arguments(),
+            body=[ast.Pass()],
+            type_params=[
+                ast.TypeVar("T", default_value=ast.Constant(value=1)),
+                ast.TypeVarTuple("Ts", default_value=ast.Starred(value=ast.Constant(value=1), ctx=ast.Load())),
+                ast.ParamSpec("P", default_value=ast.Constant(value=1)),
+            ],
+        )
+        ast.fix_missing_locations(node)
+        self.assertEqual(ast.unparse(node), "async def f[T = 1, *Ts = *1, **P = 1]():\n    pass")
+
+
+class DirectoryTestCase(ASTTestCase):
+    """Test roundtrip behaviour on all files in Lib and Lib/test."""
+
+    lib_dir = pathlib.Path(__file__).parent / ".."
+    test_directories = (lib_dir, lib_dir / "test")
+    run_always_files = {"test_grammar.py", "test_syntax.py", "test_compile.py",
+                        "test_ast.py", "test_asdl_parser.py", "test_fstring.py",
+                        "test_patma.py", "test_type_alias.py", "test_type_params.py",
+                        "test_tokenize.py", "test_tstring.py"}
+
+    _files_to_test = None
+
+    @classmethod
+    def files_to_test(cls):
+
+        if cls._files_to_test is not None:
+            return cls._files_to_test
+
+        items = [
+            item.resolve()
+            for directory in cls.test_directories
+            for item in directory.glob("*.py")
+            if not item.name.startswith("bad")
+        ]
+
+        # Test limited subset of files unless the 'cpu' resource is specified.
+        if not test.support.is_resource_enabled("cpu"):
+
+            tests_to_run_always = {item for item in items if
+                                   item.name in cls.run_always_files}
+
+            items = set(random.sample(items, 10))
+
+            # Make sure that at least tests that heavily use grammar features are
+            # always considered in order to reduce the chance of missing something.
+            items = list(items | tests_to_run_always)
+
+        # bpo-31174: Store the names sample to always test the same files.
+        # It prevents false alarms when hunting reference leaks.
+        cls._files_to_test = items
+
+        return items
+
+    def test_files(self):
+        with warnings.catch_warnings():
+            warnings.simplefilter('ignore', SyntaxWarning)
+
+            for item in self.files_to_test():
+                if test.support.verbose:
+                    print(f"Testing {item.absolute()}")
+
+                with self.subTest(filename=item):
+                    source = read_pyfile(item)
+                    self.check_ast_roundtrip(source)
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/Lib/test/test_urllib.py b/Lib/test/test_urllib.py
index ae524c5ffba..2dd739b77b8 100644
--- a/Lib/test/test_urllib.py
+++ b/Lib/test/test_urllib.py
@@ -10,6 +10,7 @@
 from test import support
 from test.support import os_helper
 from test.support import socket_helper
+from test.support import control_characters_c0
 import os
 import socket
 try:
@@ -590,6 +591,13 @@ def test_invalid_base64_data(self):
         # missing padding character
         self.assertRaises(ValueError,urllib.request.urlopen,'data:;base64,Cg=')
 
+    def test_invalid_mediatype(self):
+        for c0 in control_characters_c0():
+            self.assertRaises(ValueError,urllib.request.urlopen,
+                              f'data:text/html;{c0},data')
+        for c0 in control_characters_c0():
+            self.assertRaises(ValueError,urllib.request.urlopen,
+                              f'data:text/html{c0};base64,ZGF0YQ==')
 
 class urlretrieve_FileTests(unittest.TestCase):
     """Test urllib.urlretrieve() on local files"""
diff --git a/Lib/test/test_urllib2_localnet.py b/Lib/test/test_urllib2_localnet.py
index d70c0dad7f0..87da54d5384 100644
--- a/Lib/test/test_urllib2_localnet.py
+++ b/Lib/test/test_urllib2_localnet.py
@@ -360,7 +360,7 @@ def stop_server(self):
         self.server.stop()
         self.server = None
 
-    @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")
@@ -369,14 +369,13 @@ def test_proxy_with_bad_password_raises_httperror(self):
             self.opener.open(self.URL)
         cm.exception.close()
 
-    @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")
         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")
     def test_proxy_qop_auth_works(self):
         self.proxy_digest_handler.add_password(self.REALM, self.URL,
                                                self.USER, self.PASSWD)
@@ -385,7 +384,7 @@ def test_proxy_qop_auth_works(self):
             while result.read():
                 pass
 
-    @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)
@@ -510,7 +509,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")
+
     def test_redirection(self):
         expected_response = b"We got here..."
         responses = [
@@ -524,7 +523,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")
+
     def test_chunked(self):
         expected_response = b"hello world"
         chunked_start = (
@@ -539,7 +538,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")
+
     def test_404(self):
         expected_response = b"Bad bad bad..."
         handler = self.start_server([(404, [], expected_response)])
@@ -555,7 +554,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")
+
     def test_200(self):
         expected_response = b"pycon 2008..."
         handler = self.start_server([(200, [], expected_response)])
@@ -563,7 +562,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")
+
     def test_200_with_parameters(self):
         expected_response = b"pycon 2008..."
         handler = self.start_server([(200, [], expected_response)])
@@ -572,14 +571,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")
+
     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_sni(self):
         if ssl is None:
             self.skipTest("ssl module required")
@@ -596,7 +595,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")
+
     def test_sending_headers(self):
         handler = self.start_server()
         req = urllib.request.Request("http://localhost:%s/" % handler.port,
@@ -605,7 +604,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")
+
     def test_sending_headers_camel(self):
         handler = self.start_server()
         req = urllib.request.Request("http://localhost:%s/" % handler.port,
@@ -615,7 +614,7 @@ 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")
+
     def test_basic(self):
         handler = self.start_server()
         with urllib.request.urlopen("http://localhost:%s" % handler.port) as open_url:
@@ -623,7 +622,7 @@ def test_basic(self):
                 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")
+
     def test_info(self):
         handler = self.start_server()
         open_url = urllib.request.urlopen(
@@ -635,7 +634,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")
+
     def test_geturl(self):
         # Make sure same URL as opened is returned by geturl.
         handler = self.start_server()
@@ -644,7 +643,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")
+
     def test_iteration(self):
         expected_response = b"pycon 2008..."
         handler = self.start_server([(200, [], expected_response)])
@@ -652,7 +651,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")
+
     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)
@@ -665,7 +664,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")
+
     def test_issue16464(self):
         # See https://bugs.python.org/issue16464
         # and https://bugs.python.org/issue46648
diff --git a/Lib/test/test_urlparse.py b/Lib/test/test_urlparse.py
index 5e6a46b3d35..b2bde5a9b1d 100644
--- a/Lib/test/test_urlparse.py
+++ b/Lib/test/test_urlparse.py
@@ -1495,7 +1495,6 @@ def test_all(self):
                 expected.append(name)
         self.assertCountEqual(urllib.parse.__all__, expected)
 
-    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_urlsplit_normalization(self):
         # Certain characters should never occur in the netloc,
         # including under normalization.
diff --git a/Lib/test/test_userdict.py b/Lib/test/test_userdict.py
index 61e79f553e8..75de9ea252d 100644
--- a/Lib/test/test_userdict.py
+++ b/Lib/test/test_userdict.py
@@ -1,6 +1,6 @@
 # Check every path through every method of UserDict
 
-from test import mapping_tests, support
+from test import mapping_tests
 import unittest
 import collections
 
@@ -166,7 +166,7 @@ def test_update(self):
 
     def test_missing(self):
         # Make sure UserDict doesn't have a __missing__ method
-        self.assertEqual(hasattr(collections.UserDict, "__missing__"), False)
+        self.assertNotHasAttr(collections.UserDict, "__missing__")
         # Test several cases:
         # (D) subclass defines __missing__ method returning a value
         # (E) subclass defines __missing__ method raising RuntimeError
@@ -213,11 +213,7 @@ class G(collections.UserDict):
         else:
             self.fail("g[42] didn't raise KeyError")
 
-    # Decorate existing test with recursion limit, because
-    # the test is for C structure, but `UserDict` is a Python structure.
-    test_repr_deep = support.infinite_recursion(25)(
-        mapping_tests.TestHashMappingProtocol.test_repr_deep,
-    )
+    test_repr_deep = mapping_tests.TestHashMappingProtocol.test_repr_deep
 
 
 if __name__ == "__main__":
diff --git a/Lib/test/test_userlist.py b/Lib/test/test_userlist.py
index 312702c8e39..da66ae694d5 100644
--- a/Lib/test/test_userlist.py
+++ b/Lib/test/test_userlist.py
@@ -3,7 +3,6 @@
 from collections import UserList
 from test import list_tests
 import unittest
-from test import support
 
 
 class UserListTest(list_tests.CommonTest):
@@ -69,9 +68,8 @@ def test_userlist_copy(self):
 
     # Decorate existing test with recursion limit, because
     # the test is for C structure, but `UserList` is a Python structure.
-    test_repr_deep = support.infinite_recursion(25)(
-        list_tests.CommonTest.test_repr_deep,
-    )
+    # test_repr_deep = list_tests.CommonTest.test_repr_deep
+    test_repr_deep = unittest.skip(list_tests.CommonTest.test_repr_deep) # TODO: RUSTPYTHON; Segfault
 
 if __name__ == "__main__":
     unittest.main()
diff --git a/Lib/test/test_utf8_mode.py b/Lib/test/test_utf8_mode.py
index b3e3e0bb27f..176a2112718 100644
--- a/Lib/test/test_utf8_mode.py
+++ b/Lib/test/test_utf8_mode.py
@@ -46,8 +46,7 @@ def test_posix_locale(self):
                 out = self.get_output('-c', code, LC_ALL=loc)
                 self.assertEqual(out, '1')
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailureIf(MS_WINDOWS, "TODO: RUSTPYTHON")
     def test_xoption(self):
         code = 'import sys; print(sys.flags.utf8_mode)'
 
diff --git a/Lib/test/test_utf8source.py b/Lib/test/test_utf8source.py
index 602b4b69aac..7336cf00a71 100644
--- a/Lib/test/test_utf8source.py
+++ b/Lib/test/test_utf8source.py
@@ -1,5 +1,3 @@
-# This file is marked as binary in the CVS, to prevent MacCVS from recoding it.
-
 import unittest
 
 class PEP3120Test(unittest.TestCase):
@@ -14,11 +12,9 @@ def test_pep3120(self):
             b'\\\xd0\x9f'
         )
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_badsyntax(self):
         try:
-            import test.badsyntax_pep3120
+            import test.tokenizedata.badsyntax_pep3120  # noqa: F401
         except SyntaxError as msg:
             msg = str(msg).lower()
             self.assertTrue('utf-8' in msg)
@@ -28,8 +24,6 @@ def test_badsyntax(self):
 
 class BuiltinCompileTests(unittest.TestCase):
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     # Issue 3574.
     def test_latin1(self):
         # Allow compile() to read Latin-1 source.
diff --git a/Lib/test/test_uuid.py b/Lib/test/test_uuid.py
index ce396aa942b..0e1a723ce3a 100644
--- a/Lib/test/test_uuid.py
+++ b/Lib/test/test_uuid.py
@@ -1,7 +1,3 @@
-import unittest
-from test import support
-from test.support import import_helper
-from test.support.script_helper import assert_python_ok
 import builtins
 import contextlib
 import copy
@@ -9,10 +5,17 @@
 import io
 import os
 import pickle
+import random
 import sys
+import unittest
 import weakref
+from itertools import product
 from unittest import mock
 
+from test import support
+from test.support import import_helper
+from test.support.script_helper import assert_python_ok
+
 py_uuid = import_helper.import_fresh_module('uuid', blocked=['_uuid'])
 c_uuid = import_helper.import_fresh_module('uuid', fresh=['_uuid'])
 
@@ -33,6 +36,47 @@ def get_command_stdout(command, args):
 class BaseTestUUID:
     uuid = None
 
+    def test_nil_uuid(self):
+        nil_uuid = self.uuid.NIL
+
+        s = '00000000-0000-0000-0000-000000000000'
+        i = 0
+        self.assertEqual(nil_uuid, self.uuid.UUID(s))
+        self.assertEqual(nil_uuid, self.uuid.UUID(int=i))
+        self.assertEqual(nil_uuid.int, i)
+        self.assertEqual(str(nil_uuid), s)
+        # The Nil UUID falls within the range of the Apollo NCS variant as per
+        # RFC 9562.
+        # See https://www.rfc-editor.org/rfc/rfc9562.html#section-5.9-4
+        self.assertEqual(nil_uuid.variant, self.uuid.RESERVED_NCS)
+        # A version field of all zeros is "Unused" in RFC 9562, but the version
+        # field also only applies to the 10xx variant, i.e. the variant
+        # specified in RFC 9562. As such, because the Nil UUID falls under a
+        # different variant, its version is considered undefined.
+        # See https://www.rfc-editor.org/rfc/rfc9562.html#table2
+        self.assertIsNone(nil_uuid.version)
+
+    def test_max_uuid(self):
+        max_uuid = self.uuid.MAX
+
+        s = 'ffffffff-ffff-ffff-ffff-ffffffffffff'
+        i = (1 << 128) - 1
+        self.assertEqual(max_uuid, self.uuid.UUID(s))
+        self.assertEqual(max_uuid, self.uuid.UUID(int=i))
+        self.assertEqual(max_uuid.int, i)
+        self.assertEqual(str(max_uuid), s)
+        # The Max UUID falls within the range of the "yet-to-be defined" future
+        # UUID variant as per RFC 9562.
+        # See https://www.rfc-editor.org/rfc/rfc9562.html#section-5.10-4
+        self.assertEqual(max_uuid.variant, self.uuid.RESERVED_FUTURE)
+        # A version field of all ones is "Reserved for future definition" in
+        # RFC 9562, but the version field also only applies to the 10xx
+        # variant, i.e. the variant specified in RFC 9562. As such, because the
+        # Max UUID falls under a different variant, its version is considered
+        # undefined.
+        # See https://www.rfc-editor.org/rfc/rfc9562.html#table2
+        self.assertIsNone(max_uuid.version)
+
     def test_safe_uuid_enum(self):
         class CheckedSafeUUID(enum.Enum):
             safe = 0
@@ -268,7 +312,7 @@ def test_exceptions(self):
 
         # Version number out of range.
         badvalue(lambda: self.uuid.UUID('00'*16, version=0))
-        badvalue(lambda: self.uuid.UUID('00'*16, version=6))
+        badvalue(lambda: self.uuid.UUID('00'*16, version=42))
 
         # Integer value out of range.
         badvalue(lambda: self.uuid.UUID(int=-1))
@@ -682,6 +726,392 @@ def test_uuid5(self):
             equal(u, self.uuid.UUID(v))
             equal(str(u), v)
 
+    def test_uuid6(self):
+        equal = self.assertEqual
+        u = self.uuid.uuid6()
+        equal(u.variant, self.uuid.RFC_4122)
+        equal(u.version, 6)
+
+        fake_nanoseconds = 0x1571_20a1_de1a_c533
+        fake_node_value = 0x54e1_acf6_da7f
+        fake_clock_seq = 0x14c5
+        with (
+            mock.patch.object(self.uuid, '_last_timestamp_v6', None),
+            mock.patch.object(self.uuid, 'getnode', return_value=fake_node_value),
+            mock.patch('time.time_ns', return_value=fake_nanoseconds),
+            mock.patch('random.getrandbits', return_value=fake_clock_seq)
+        ):
+            u = self.uuid.uuid6()
+            equal(u.variant, self.uuid.RFC_4122)
+            equal(u.version, 6)
+
+            # 32 (top) | 16 (mid) | 12 (low) == 60 (timestamp)
+            equal(u.time, 0x1e901fca_7a55_b92)
+            equal(u.fields[0], 0x1e901fca)  # 32 top bits of time
+            equal(u.fields[1], 0x7a55)  # 16 mid bits of time
+            # 4 bits of version + 12 low bits of time
+            equal((u.fields[2] >> 12) & 0xf, 6)
+            equal((u.fields[2] & 0xfff), 0xb92)
+            # 2 bits of variant + 6 high bits of clock_seq
+            equal((u.fields[3] >> 6) & 0xf, 2)
+            equal(u.fields[3] & 0x3f, fake_clock_seq >> 8)
+            # 8 low bits of clock_seq
+            equal(u.fields[4], fake_clock_seq & 0xff)
+            equal(u.fields[5], fake_node_value)
+
+    def test_uuid6_uniqueness(self):
+        # Test that UUIDv6-generated values are unique.
+
+        # Unlike UUIDv8, only 62 bits can be randomized for UUIDv6.
+        # In practice, however, it remains unlikely to generate two
+        # identical UUIDs for the same 60-bit timestamp if neither
+        # the node ID nor the clock sequence is specified.
+        uuids = {self.uuid.uuid6() for _ in range(1000)}
+        self.assertEqual(len(uuids), 1000)
+        versions = {u.version for u in uuids}
+        self.assertSetEqual(versions, {6})
+
+        timestamp = 0x1ec9414c_232a_b00
+        fake_nanoseconds = (timestamp - 0x1b21dd21_3814_000) * 100
+
+        with mock.patch('time.time_ns', return_value=fake_nanoseconds):
+            def gen():
+                with mock.patch.object(self.uuid, '_last_timestamp_v6', None):
+                    return self.uuid.uuid6(node=0, clock_seq=None)
+
+            # By the birthday paradox, sampling N = 1024 UUIDs with identical
+            # node IDs and timestamps results in duplicates with probability
+            # close to 1 (not having a duplicate happens with probability of
+            # order 1E-15) since only the 14-bit clock sequence is randomized.
+            N = 1024
+            uuids = {gen() for _ in range(N)}
+            self.assertSetEqual({u.node for u in uuids}, {0})
+            self.assertSetEqual({u.time for u in uuids}, {timestamp})
+            self.assertLess(len(uuids), N, 'collision property does not hold')
+
+    def test_uuid6_node(self):
+        # Make sure the given node ID appears in the UUID.
+        #
+        # Note: when no node ID is specified, the same logic as for UUIDv1
+        # is applied to UUIDv6. In particular, there is no need to test that
+        # getnode() correctly returns positive integers of exactly 48 bits
+        # since this is done in test_uuid1_eui64().
+        self.assertLessEqual(self.uuid.uuid6().node.bit_length(), 48)
+
+        self.assertEqual(self.uuid.uuid6(0).node, 0)
+
+        # tests with explicit values
+        max_node = 0xffff_ffff_ffff
+        self.assertEqual(self.uuid.uuid6(max_node).node, max_node)
+        big_node = 0xE_1234_5678_ABCD  # 52-bit node
+        res_node = 0x0_1234_5678_ABCD  # truncated to 48 bits
+        self.assertEqual(self.uuid.uuid6(big_node).node, res_node)
+
+        # randomized tests
+        for _ in range(10):
+            # node with > 48 bits is truncated
+            for b in [24, 48, 72]:
+                node = (1 << (b - 1)) | random.getrandbits(b)
+                with self.subTest(node=node, bitlen=b):
+                    self.assertEqual(node.bit_length(), b)
+                    u = self.uuid.uuid6(node=node)
+                    self.assertEqual(u.node, node & 0xffff_ffff_ffff)
+
+    def test_uuid6_clock_seq(self):
+        # Make sure the supplied clock sequence appears in the UUID.
+        #
+        # For UUIDv6, clock sequence bits are stored from bit 48 to bit 62,
+        # with the convention that the least significant bit is bit 0 and
+        # the most significant bit is bit 127.
+        get_clock_seq = lambda u: (u.int >> 48) & 0x3fff
+
+        u = self.uuid.uuid6()
+        self.assertLessEqual(get_clock_seq(u).bit_length(), 14)
+
+        # tests with explicit values
+        big_clock_seq = 0xffff  # 16-bit clock sequence
+        res_clock_seq = 0x3fff  # truncated to 14 bits
+        u = self.uuid.uuid6(clock_seq=big_clock_seq)
+        self.assertEqual(get_clock_seq(u), res_clock_seq)
+
+        # some randomized tests
+        for _ in range(10):
+            # clock_seq with > 14 bits is truncated
+            for b in [7, 14, 28]:
+                node = random.getrandbits(48)
+                clock_seq = (1 << (b - 1)) | random.getrandbits(b)
+                with self.subTest(node=node, clock_seq=clock_seq, bitlen=b):
+                    self.assertEqual(clock_seq.bit_length(), b)
+                    u = self.uuid.uuid6(node=node, clock_seq=clock_seq)
+                    self.assertEqual(get_clock_seq(u), clock_seq & 0x3fff)
+
+    def test_uuid6_test_vectors(self):
+        equal = self.assertEqual
+        # https://www.rfc-editor.org/rfc/rfc9562#name-test-vectors
+        # (separators are put at the 12th and 28th bits)
+        timestamp = 0x1ec9414c_232a_b00
+        fake_nanoseconds = (timestamp - 0x1b21dd21_3814_000) * 100
+        # https://www.rfc-editor.org/rfc/rfc9562#name-example-of-a-uuidv6-value
+        node = 0x9f6bdeced846
+        clock_seq = (3 << 12) | 0x3c8
+
+        with (
+            mock.patch.object(self.uuid, '_last_timestamp_v6', None),
+            mock.patch('time.time_ns', return_value=fake_nanoseconds)
+        ):
+            u = self.uuid.uuid6(node=node, clock_seq=clock_seq)
+            equal(str(u).upper(), '1EC9414C-232A-6B00-B3C8-9F6BDECED846')
+            #   32          16      4      12       2      14         48
+            # time_hi | time_mid | ver | time_lo | var | clock_seq | node
+            equal(u.time, timestamp)
+            equal(u.int & 0xffff_ffff_ffff, node)
+            equal((u.int >> 48) & 0x3fff, clock_seq)
+            equal((u.int >> 62) & 0x3, 0b10)
+            equal((u.int >> 64) & 0xfff, 0xb00)
+            equal((u.int >> 76) & 0xf, 0x6)
+            equal((u.int >> 80) & 0xffff, 0x232a)
+            equal((u.int >> 96) & 0xffff_ffff, 0x1ec9_414c)
+
+    def test_uuid7(self):
+        equal = self.assertEqual
+        u = self.uuid.uuid7()
+        equal(u.variant, self.uuid.RFC_4122)
+        equal(u.version, 7)
+
+        # 1 Jan 2023 12:34:56.123_456_789
+        timestamp_ns = 1672533296_123_456_789  # ns precision
+        timestamp_ms, _ = divmod(timestamp_ns, 1_000_000)
+
+        for _ in range(100):
+            counter_hi = random.getrandbits(11)
+            counter_lo = random.getrandbits(30)
+            counter = (counter_hi << 30) | counter_lo
+
+            tail = random.getrandbits(32)
+            # effective number of bits is 32 + 30 + 11 = 73
+            random_bits = counter << 32 | tail
+
+            # set all remaining MSB of fake random bits to 1 to ensure that
+            # the implementation correctly removes them
+            random_bits = (((1 << 7) - 1) << 73) | random_bits
+            random_data = random_bits.to_bytes(10)
+
+            with (
+                mock.patch.multiple(
+                    self.uuid,
+                    _last_timestamp_v7=None,
+                    _last_counter_v7=0,
+                ),
+                mock.patch('time.time_ns', return_value=timestamp_ns),
+                mock.patch('os.urandom', return_value=random_data) as urand
+            ):
+                u = self.uuid.uuid7()
+                urand.assert_called_once_with(10)
+                equal(u.variant, self.uuid.RFC_4122)
+                equal(u.version, 7)
+
+                equal(self.uuid._last_timestamp_v7, timestamp_ms)
+                equal(self.uuid._last_counter_v7, counter)
+
+                unix_ts_ms = timestamp_ms & 0xffff_ffff_ffff
+                equal(u.time, unix_ts_ms)
+                equal((u.int >> 80) & 0xffff_ffff_ffff, unix_ts_ms)
+
+                equal((u.int >> 75) & 1, 0)  # check that the MSB is 0
+                equal((u.int >> 64) & 0xfff, counter_hi)
+                equal((u.int >> 32) & 0x3fff_ffff, counter_lo)
+                equal(u.int & 0xffff_ffff, tail)
+
+    def test_uuid7_uniqueness(self):
+        # Test that UUIDv7-generated values are unique.
+        #
+        # While UUIDv8 has an entropy of 122 bits, those 122 bits may not
+        # necessarily be sampled from a PRNG. On the other hand, UUIDv7
+        # uses os.urandom() as a PRNG which features better randomness.
+        N = 1000
+        uuids = {self.uuid.uuid7() for _ in range(N)}
+        self.assertEqual(len(uuids), N)
+
+        versions = {u.version for u in uuids}
+        self.assertSetEqual(versions, {7})
+
+    def test_uuid7_monotonicity(self):
+        equal = self.assertEqual
+
+        us = [self.uuid.uuid7() for _ in range(10_000)]
+        equal(us, sorted(us))
+
+        with mock.patch.multiple(
+            self.uuid,
+            _last_timestamp_v7=0,
+            _last_counter_v7=0,
+        ):
+            # 1 Jan 2023 12:34:56.123_456_789
+            timestamp_ns = 1672533296_123_456_789  # ns precision
+            timestamp_ms, _ = divmod(timestamp_ns, 1_000_000)
+
+            # counter_{hi,lo} are chosen so that "counter + 1" does not overflow
+            counter_hi = random.getrandbits(11)
+            counter_lo = random.getrandbits(29)
+            counter = (counter_hi << 30) | counter_lo
+            self.assertLess(counter + 1, 0x3ff_ffff_ffff)
+
+            tail = random.getrandbits(32)
+            random_bits = counter << 32 | tail
+            random_data = random_bits.to_bytes(10)
+
+            with (
+                mock.patch('time.time_ns', return_value=timestamp_ns),
+                mock.patch('os.urandom', return_value=random_data) as urand
+            ):
+                u1 = self.uuid.uuid7()
+                urand.assert_called_once_with(10)
+                equal(self.uuid._last_timestamp_v7, timestamp_ms)
+                equal(self.uuid._last_counter_v7, counter)
+                equal(u1.time, timestamp_ms)
+                equal((u1.int >> 64) & 0xfff, counter_hi)
+                equal((u1.int >> 32) & 0x3fff_ffff, counter_lo)
+                equal(u1.int & 0xffff_ffff, tail)
+
+            # 1 Jan 2023 12:34:56.123_457_032 (same millisecond but not same ns)
+            next_timestamp_ns = 1672533296_123_457_032
+            next_timestamp_ms, _ = divmod(timestamp_ns, 1_000_000)
+            equal(timestamp_ms, next_timestamp_ms)
+
+            next_tail_bytes = os.urandom(4)
+            next_fail = int.from_bytes(next_tail_bytes)
+
+            with (
+                mock.patch('time.time_ns', return_value=next_timestamp_ns),
+                mock.patch('os.urandom', return_value=next_tail_bytes) as urand
+            ):
+                u2 = self.uuid.uuid7()
+                urand.assert_called_once_with(4)
+                # same milli-second
+                equal(self.uuid._last_timestamp_v7, timestamp_ms)
+                # 42-bit counter advanced by 1
+                equal(self.uuid._last_counter_v7, counter + 1)
+                equal(u2.time, timestamp_ms)
+                equal((u2.int >> 64) & 0xfff, counter_hi)
+                equal((u2.int >> 32) & 0x3fff_ffff, counter_lo + 1)
+                equal(u2.int & 0xffff_ffff, next_fail)
+
+            self.assertLess(u1, u2)
+
+    def test_uuid7_timestamp_backwards(self):
+        equal = self.assertEqual
+        # 1 Jan 2023 12:34:56.123_456_789
+        timestamp_ns = 1672533296_123_456_789  # ns precision
+        timestamp_ms, _ = divmod(timestamp_ns, 1_000_000)
+        fake_last_timestamp_v7 = timestamp_ms + 1
+
+        # counter_{hi,lo} are chosen so that "counter + 1" does not overflow
+        counter_hi = random.getrandbits(11)
+        counter_lo = random.getrandbits(29)
+        counter = (counter_hi << 30) | counter_lo
+        self.assertLess(counter + 1, 0x3ff_ffff_ffff)
+
+        tail_bytes = os.urandom(4)
+        tail = int.from_bytes(tail_bytes)
+
+        with (
+            mock.patch.multiple(
+                self.uuid,
+                _last_timestamp_v7=fake_last_timestamp_v7,
+                _last_counter_v7=counter,
+            ),
+            mock.patch('time.time_ns', return_value=timestamp_ns),
+            mock.patch('os.urandom', return_value=tail_bytes) as urand
+        ):
+            u = self.uuid.uuid7()
+            urand.assert_called_once_with(4)
+            equal(u.variant, self.uuid.RFC_4122)
+            equal(u.version, 7)
+            equal(self.uuid._last_timestamp_v7, fake_last_timestamp_v7 + 1)
+            unix_ts_ms = (fake_last_timestamp_v7 + 1) & 0xffff_ffff_ffff
+            equal(u.time, unix_ts_ms)
+            equal((u.int >> 80) & 0xffff_ffff_ffff, unix_ts_ms)
+            # 42-bit counter advanced by 1
+            equal(self.uuid._last_counter_v7, counter + 1)
+            equal((u.int >> 64) & 0xfff, counter_hi)
+            # 42-bit counter advanced by 1 (counter_hi is untouched)
+            equal((u.int >> 32) & 0x3fff_ffff, counter_lo + 1)
+            equal(u.int & 0xffff_ffff, tail)
+
+    def test_uuid7_overflow_counter(self):
+        equal = self.assertEqual
+        # 1 Jan 2023 12:34:56.123_456_789
+        timestamp_ns = 1672533296_123_456_789  # ns precision
+        timestamp_ms, _ = divmod(timestamp_ns, 1_000_000)
+
+        new_counter_hi = random.getrandbits(11)
+        new_counter_lo = random.getrandbits(30)
+        new_counter = (new_counter_hi << 30) | new_counter_lo
+
+        tail = random.getrandbits(32)
+        random_bits = (new_counter << 32) | tail
+        random_data = random_bits.to_bytes(10)
+
+        with (
+            mock.patch.multiple(
+                self.uuid,
+                _last_timestamp_v7=timestamp_ms,
+                # same timestamp, but force an overflow on the counter
+                _last_counter_v7=0x3ff_ffff_ffff,
+            ),
+            mock.patch('time.time_ns', return_value=timestamp_ns),
+            mock.patch('os.urandom', return_value=random_data) as urand
+        ):
+            u = self.uuid.uuid7()
+            urand.assert_called_with(10)
+            equal(u.variant, self.uuid.RFC_4122)
+            equal(u.version, 7)
+            # timestamp advanced due to overflow
+            equal(self.uuid._last_timestamp_v7, timestamp_ms + 1)
+            unix_ts_ms = (timestamp_ms + 1) & 0xffff_ffff_ffff
+            equal(u.time, unix_ts_ms)
+            equal((u.int >> 80) & 0xffff_ffff_ffff, unix_ts_ms)
+            # counter overflowed, so we picked a new one
+            equal(self.uuid._last_counter_v7, new_counter)
+            equal((u.int >> 64) & 0xfff, new_counter_hi)
+            equal((u.int >> 32) & 0x3fff_ffff, new_counter_lo)
+            equal(u.int & 0xffff_ffff, tail)
+
+    def test_uuid8(self):
+        equal = self.assertEqual
+        u = self.uuid.uuid8()
+
+        equal(u.variant, self.uuid.RFC_4122)
+        equal(u.version, 8)
+
+        for (_, hi, mid, lo) in product(
+            range(10),  # repeat 10 times
+            [None, 0, random.getrandbits(48)],
+            [None, 0, random.getrandbits(12)],
+            [None, 0, random.getrandbits(62)],
+        ):
+            u = self.uuid.uuid8(hi, mid, lo)
+            equal(u.variant, self.uuid.RFC_4122)
+            equal(u.version, 8)
+            if hi is not None:
+                equal((u.int >> 80) & 0xffffffffffff, hi)
+            if mid is not None:
+                equal((u.int >> 64) & 0xfff, mid)
+            if lo is not None:
+                equal(u.int & 0x3fffffffffffffff, lo)
+
+    def test_uuid8_uniqueness(self):
+        # Test that UUIDv8-generated values are unique (up to a negligible
+        # probability of failure). There are 122 bits of entropy and assuming
+        # that the underlying mt-19937-based random generator is sufficiently
+        # good, it is unlikely to have a collision of two UUIDs.
+        N = 1000
+        uuids = {self.uuid.uuid8() for _ in range(N)}
+        self.assertEqual(len(uuids), N)
+
+        versions = {u.version for u in uuids}
+        self.assertSetEqual(versions, {8})
+
     @support.requires_fork()
     def testIssue8621(self):
         # On at least some versions of OSX self.uuid.uuid4 generates
@@ -710,6 +1140,23 @@ def test_uuid_weakref(self):
         weak = weakref.ref(strong)
         self.assertIs(strong, weak())
 
+
+class CommandLineTestCases:
+    uuid = None  # to be defined in subclasses
+
+    def do_test_standalone_uuid(self, version):
+        stdout = io.StringIO()
+        with contextlib.redirect_stdout(stdout):
+            self.uuid.main()
+        output = stdout.getvalue().strip()
+        u = self.uuid.UUID(output)
+        self.assertEqual(output, str(u))
+        self.assertEqual(u.version, version)
+
+    @mock.patch.object(sys, "argv", ["", "-u", "uuid1"])
+    def test_cli_uuid1(self):
+        self.do_test_standalone_uuid(1)
+
     @mock.patch.object(sys, "argv", ["", "-u", "uuid3", "-n", "@dns"])
     @mock.patch('sys.stderr', new_callable=io.StringIO)
     def test_cli_namespace_required_for_uuid3(self, mock_err):
@@ -742,6 +1189,20 @@ def test_cli_uuid4_outputted_with_no_args(self):
         self.assertEqual(output, str(uuid_output))
         self.assertEqual(uuid_output.version, 4)
 
+    @mock.patch.object(sys, "argv", ["", "-C", "3"])
+    def test_cli_uuid4_outputted_with_count(self):
+        stdout = io.StringIO()
+        with contextlib.redirect_stdout(stdout):
+            self.uuid.main()
+
+        output = stdout.getvalue().strip().splitlines()
+
+        # Check that 3 UUIDs in the format of uuid4 have been generated
+        self.assertEqual(len(output), 3)
+        for o in output:
+            uuid_output = self.uuid.UUID(o)
+            self.assertEqual(uuid_output.version, 4)
+
     @mock.patch.object(sys, "argv",
                        ["", "-u", "uuid3", "-n", "@dns", "-N", "python.org"])
     def test_cli_uuid3_ouputted_with_valid_namespace_and_name(self):
@@ -770,13 +1231,25 @@ def test_cli_uuid5_ouputted_with_valid_namespace_and_name(self):
         self.assertEqual(output, str(uuid_output))
         self.assertEqual(uuid_output.version, 5)
 
+    @mock.patch.object(sys, "argv", ["", "-u", "uuid6"])
+    def test_cli_uuid6(self):
+        self.do_test_standalone_uuid(6)
+
+    @mock.patch.object(sys, "argv", ["", "-u", "uuid7"])
+    def test_cli_uuid7(self):
+        self.do_test_standalone_uuid(7)
+
+    @mock.patch.object(sys, "argv", ["", "-u", "uuid8"])
+    def test_cli_uuid8(self):
+        self.do_test_standalone_uuid(8)
+
 
-class TestUUIDWithoutExtModule(BaseTestUUID, unittest.TestCase):
+class TestUUIDWithoutExtModule(CommandLineTestCases, BaseTestUUID, unittest.TestCase):
     uuid = py_uuid
 
 
 @unittest.skipUnless(c_uuid, 'requires the C _uuid module')
-class TestUUIDWithExtModule(BaseTestUUID, unittest.TestCase):
+class TestUUIDWithExtModule(CommandLineTestCases, BaseTestUUID, unittest.TestCase):
     uuid = c_uuid
 
     def check_has_stable_libuuid_extractable_node(self):
diff --git a/Lib/test/test_warnings/__init__.py b/Lib/test/test_warnings/__init__.py
index ce1ae9dfa18..71dc20d0b59 100644
--- a/Lib/test/test_warnings/__init__.py
+++ b/Lib/test/test_warnings/__init__.py
@@ -565,7 +565,7 @@ def test_stacklevel(self):
                 self.assertEqual(os.path.basename(w[-1].filename),
                                     "<sys>")
 
-    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; + /Users/al03219714/Projects/RustPython1/crates/pylib/Lib/test/test_warnings/__init__.py
     def test_stacklevel_import(self):
         # Issue #24305: With stacklevel=2, module-level warnings should work.
         import_helper.unload('test.test_warnings.data.import_warning')
@@ -807,43 +807,42 @@ class CWarnTests(WarnTests, unittest.TestCase):
 
     # 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.assertNotHasAttr(self.module.warn, '__code__')
 
-    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AssertionError: 1 != 2
     def test_gh86298_loader_and_spec_loader_disagree(self):
         return super().test_gh86298_loader_and_spec_loader_disagree()
 
-    @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()
-
-    @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()
-
-    @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
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AssertionError: 1 != 2
     def test_gh86298_no_spec(self):
         return super().test_gh86298_no_spec()
 
-    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AssertionError: 1 != 2
     def test_gh86298_no_spec_loader(self):
         return super().test_gh86298_no_spec_loader()
 
-    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AssertionError: 1 != 2
     def test_gh86298_spec_is_none(self):
         return super().test_gh86298_spec_is_none()
 
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AssertionError: AttributeError not raised
+    def test_gh86298_no_loader_and_no_spec_loader(self):
+        return super().test_gh86298_no_loader_and_no_spec_loader()
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AssertionError: ValueError not raised
+    def test_gh86298_loader_is_none_and_spec_is_none(self):
+        return super().test_gh86298_loader_is_none_and_spec_is_none()
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AssertionError: ValueError not raised
+    def test_gh86298_loader_is_none_and_spec_loader_is_none(self):
+        return super().test_gh86298_loader_is_none_and_spec_loader_is_none()
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AssertionError: ValueError not raised
+    def test_gh86298_no_loader_and_spec_is_none(self):
+        return super().test_gh86298_no_loader_and_spec_is_none()
+
 class PyWarnTests(WarnTests, unittest.TestCase):
     module = py_warnings
 
@@ -919,7 +918,7 @@ class _WarningsTests(BaseTest, unittest.TestCase):
 
     module = c_warnings
 
-    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AssertionError: UserWarning not raised by warn
     def test_filter(self):
         # Everything should function even if 'filters' is not in warnings.
         with self.module.catch_warnings() as w:
@@ -930,7 +929,6 @@ def test_filter(self):
             self.assertRaises(UserWarning, self.module.warn,
                                 'convert to error')
 
-    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_onceregistry(self):
         # Replacing or removing the onceregistry should be okay.
         global __warningregistry__
@@ -960,7 +958,6 @@ def test_onceregistry(self):
         finally:
             self.module.onceregistry = original_registry
 
-    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_default_action(self):
         # Replacing or removing defaultaction should be okay.
         message = UserWarning("defaultaction test")
@@ -1012,7 +1009,6 @@ def test_showwarning_missing(self):
                 result = stream.getvalue()
         self.assertIn(text, result)
 
-    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_showwarnmsg_missing(self):
         # Test that _showwarnmsg() missing is okay.
         text = 'del _showwarnmsg test'
@@ -1092,7 +1088,7 @@ def test_stderr_none(self):
         self.assertNotIn(b'Warning!', stderr)
         self.assertNotIn(b'Error', stderr)
 
-    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; TypeError: 'int' object is not iterable
     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
@@ -1245,7 +1241,7 @@ class CWarningsDisplayTests(WarningsDisplayTests, unittest.TestCase):
 class PyWarningsDisplayTests(WarningsDisplayTests, unittest.TestCase):
     module = py_warnings
 
-    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; + ResourceWarning: Enable tracemalloc to get the object allocation traceback
     def test_tracemalloc(self):
         self.addCleanup(os_helper.unlink, os_helper.TESTFN)
 
@@ -1458,7 +1454,6 @@ class PyCatchWarningTests(CatchWarningTests, unittest.TestCase):
 
 class EnvironmentVariableTests(BaseTest):
 
-    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_single_warning(self):
         rc, stdout, stderr = assert_python_ok("-c",
             "import sys; sys.stdout.write(str(sys.warnoptions))",
@@ -1466,7 +1461,6 @@ def test_single_warning(self):
             PYTHONDEVMODE="")
         self.assertEqual(stdout, b"['ignore::DeprecationWarning']")
 
-    @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))",
@@ -1475,7 +1469,6 @@ def test_comma_separated_warnings(self):
         self.assertEqual(stdout,
             b"['ignore::DeprecationWarning', 'ignore::UnicodeWarning']")
 
-    @unittest.expectedFailure  # TODO: RUSTPYTHON
     @force_not_colorized
     def test_envvar_and_command_line(self):
         rc, stdout, stderr = assert_python_ok("-Wignore::UnicodeWarning", "-c",
@@ -1485,7 +1478,6 @@ def test_envvar_and_command_line(self):
         self.assertEqual(stdout,
             b"['ignore::DeprecationWarning', 'ignore::UnicodeWarning']")
 
-    @unittest.expectedFailure  # TODO: RUSTPYTHON
     @force_not_colorized
     def test_conflicting_envvar_and_command_line(self):
         rc, stdout, stderr = assert_python_failure("-Werror::DeprecationWarning", "-c",
@@ -1535,7 +1527,6 @@ def test_default_filter_configuration(self):
         self.assertEqual(stdout_lines, expected_output)
 
 
-    @unittest.expectedFailure  # TODO: RUSTPYTHON
     @unittest.skipUnless(sys.getfilesystemencoding() != 'ascii',
                          'requires non-ascii filesystemencoding')
     def test_nonascii(self):
@@ -1550,10 +1541,6 @@ def test_nonascii(self):
 class CEnvironmentVariableTests(EnvironmentVariableTests, unittest.TestCase):
     module = c_warnings
 
-    @unittest.expectedFailure  # TODO: RUSTPYTHON; Lists differ
-    def test_default_filter_configuration(self):
-        return super().test_default_filter_configuration()
-
 class PyEnvironmentVariableTests(EnvironmentVariableTests, unittest.TestCase):
     module = py_warnings
 
@@ -1623,7 +1610,6 @@ def test_issue_8766(self):
 
 
 class FinalizationTest(unittest.TestCase):
-    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_finalization(self):
         # Issue #19421: warnings.warn() should not crash
         # during Python finalization
@@ -1641,7 +1627,6 @@ def __del__(self):
         self.assertEqual(err.decode().rstrip(),
                          '<string>:7: UserWarning: test')
 
-    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_late_resource_warning(self):
         # Issue #21925: Emitting a ResourceWarning late during the Python
         # shutdown must be logged.
@@ -1851,7 +1836,6 @@ 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:
@@ -1863,7 +1847,6 @@ 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:
@@ -1874,7 +1857,6 @@ 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
 
@@ -1893,7 +1875,6 @@ 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
 
@@ -1915,7 +1896,6 @@ 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
 
@@ -1933,7 +1913,6 @@ 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:
@@ -1950,7 +1929,6 @@ 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
@@ -1970,7 +1948,6 @@ 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:
@@ -1987,7 +1964,6 @@ 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:
@@ -2008,7 +1984,6 @@ 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:
@@ -2028,7 +2003,6 @@ 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
 
@@ -2046,7 +2020,6 @@ 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
 
@@ -2065,7 +2038,6 @@ 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():
@@ -2074,7 +2046,6 @@ 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")
@@ -2085,7 +2056,6 @@ 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
@@ -2113,7 +2083,6 @@ 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_wave.py b/Lib/test/test_wave.py
index 5e771c8de96..346a343761a 100644
--- a/Lib/test/test_wave.py
+++ b/Lib/test/test_wave.py
@@ -2,6 +2,7 @@
 from test import audiotests
 from test import support
 import io
+import os
 import struct
 import sys
 import wave
@@ -222,6 +223,14 @@ def test_read_wrong_sample_width(self):
         with self.assertRaisesRegex(wave.Error, 'bad sample width'):
             wave.open(io.BytesIO(b))
 
+    def test_open_in_write_raises(self):
+        # gh-136523: Wave_write.__del__ should not throw
+        with support.catch_unraisable_exception() as cm:
+            with self.assertRaises(OSError):
+                wave.open(os.curdir, "wb")
+            support.gc_collect()
+            self.assertIsNone(cm.unraisable)
+
 
 if __name__ == '__main__':
     unittest.main()
diff --git a/Lib/test/test_weakref.py b/Lib/test/test_weakref.py
index f421d745a12..cd0bdacaaf0 100644
--- a/Lib/test/test_weakref.py
+++ b/Lib/test/test_weakref.py
@@ -13,7 +13,7 @@
 import textwrap
 
 from test import support
-from test.support import script_helper, ALWAYS_EQ, suppress_immortalization
+from test.support import script_helper, ALWAYS_EQ
 from test.support import gc_collect
 from test.support import import_helper
 from test.support import threading_helper
@@ -289,7 +289,7 @@ def test_ref_reuse(self):
         self.assertEqual(weakref.getweakrefcount(o), 1,
                      "wrong weak ref count for object after deleting proxy")
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_proxy_reuse(self):
         o = C()
         proxy1 = weakref.proxy(o)
@@ -337,7 +337,6 @@ def __bytes__(self):
         self.assertIn("__bytes__", dir(weakref.proxy(instance)))
         self.assertEqual(bytes(weakref.proxy(instance)), b"bytes")
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_proxy_index(self):
         class C:
             def __index__(self):
@@ -346,7 +345,6 @@ def __index__(self):
         p = weakref.proxy(o)
         self.assertEqual(operator.index(p), 10)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_proxy_div(self):
         class C:
             def __floordiv__(self, other):
@@ -359,7 +357,6 @@ def __ifloordiv__(self, other):
         p //= 5
         self.assertEqual(p, 21)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_proxy_matmul(self):
         class C:
             def __matmul__(self, other):
@@ -383,11 +380,11 @@ def __imatmul__(self, other):
     # was not honored, and was broken in different ways for
     # PyWeakref_NewRef() and PyWeakref_NewProxy().  (Two tests.)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_shared_ref_without_callback(self):
         self.check_shared_without_callback(weakref.ref)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_shared_proxy_without_callback(self):
         self.check_shared_without_callback(weakref.proxy)
 
@@ -409,7 +406,7 @@ def check_shared_without_callback(self, makeref):
         p2 = makeref(o)
         self.assertIs(p1, p2, "callbacks were None, NULL in the C API")
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_callable_proxy(self):
         o = Callable()
         ref1 = weakref.proxy(o)
@@ -439,7 +436,7 @@ def check_proxy(self, o, proxy):
         self.assertEqual(proxy.foo, 2,
                      "proxy does not reflect attribute modification")
         del o.foo
-        self.assertFalse(hasattr(proxy, 'foo'),
+        self.assertNotHasAttr(proxy, 'foo',
                      "proxy does not reflect attribute removal")
 
         proxy.foo = 1
@@ -449,7 +446,7 @@ def check_proxy(self, o, proxy):
         self.assertEqual(o.foo, 2,
             "object does not reflect attribute modification via proxy")
         del proxy.foo
-        self.assertFalse(hasattr(o, 'foo'),
+        self.assertNotHasAttr(o, 'foo',
                      "object does not reflect attribute removal via proxy")
 
     def test_proxy_deletion(self):
@@ -504,7 +501,6 @@ def __iter__(self):
         # Calls proxy.__next__
         self.assertEqual(list(weak_it), [4, 5, 6])
 
-    @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.
@@ -594,7 +590,6 @@ def test_getweakrefs(self):
         self.assertEqual(weakref.getweakrefs(1), [],
                      "list of refs does not match for int")
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_newstyle_number_ops(self):
         class F(float):
             pass
@@ -668,7 +663,6 @@ class C(object):
         # deallocation of c2.
         del c2
 
-    @suppress_immortalization()
     def test_callback_in_cycle(self):
         import gc
 
@@ -761,8 +755,7 @@ class D:
         del c1, c2, C, D
         gc.collect()
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
-    @suppress_immortalization()
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_callback_in_cycle_resurrection(self):
         import gc
 
@@ -809,7 +802,7 @@ def C_went_away(ignore):
         gc.collect()
         self.assertEqual(alist, [])
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_callbacks_on_callback(self):
         import gc
 
@@ -848,11 +841,9 @@ def cb(self, ignore):
         gc.collect()
         self.assertEqual(alist, [])
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_gc_during_ref_creation(self):
         self.check_gc_during_creation(weakref.ref)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_gc_during_proxy_creation(self):
         self.check_gc_during_creation(weakref.proxy)
 
@@ -901,7 +892,6 @@ def test_init(self):
         # No exception should be raised here
         gc.collect()
 
-    @suppress_immortalization()
     def test_classes(self):
         # Check that classes are weakrefable.
         class A(object):
@@ -1003,7 +993,7 @@ def cb(wparent):
         del root
         gc.collect()
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_callback_attribute(self):
         x = Object(1)
         callback = lambda ref: None
@@ -1013,7 +1003,7 @@ def test_callback_attribute(self):
         ref2 = weakref.ref(x)
         self.assertIsNone(ref2.__callback__)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_callback_attribute_after_deletion(self):
         x = Object(1)
         ref = weakref.ref(x, self.callback)
@@ -1065,7 +1055,6 @@ def callback(obj):
 
 class SubclassableWeakrefTestCase(TestBase):
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_subclass_refs(self):
         class MyRef(weakref.ref):
             def __init__(self, ob, callback=None, value=42):
@@ -1084,7 +1073,6 @@ def __call__(self):
         self.assertIsNone(mr())
         self.assertTrue(mr.called)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_subclass_refs_dont_replace_standard_refs(self):
         class MyRef(weakref.ref):
             pass
@@ -1128,7 +1116,7 @@ def meth(self):
         self.assertEqual(r.slot1, "abc")
         self.assertEqual(r.slot2, "def")
         self.assertEqual(r.meth(), "abcdef")
-        self.assertFalse(hasattr(r, "__dict__"))
+        self.assertNotHasAttr(r, "__dict__")
 
     def test_subclass_refs_with_cycle(self):
         """Confirm https://bugs.python.org/issue3100 is fixed."""
@@ -1336,11 +1324,9 @@ def check_len_cycles(self, dict_type, cons):
         self.assertIn(n1, (0, 1))
         self.assertEqual(n2, 0)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_weak_keyed_len_cycles(self):
         self.check_len_cycles(weakref.WeakKeyDictionary, lambda k: (k, 1))
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_weak_valued_len_cycles(self):
         self.check_len_cycles(weakref.WeakValueDictionary, lambda k: (1, k))
 
@@ -1368,11 +1354,9 @@ def check_len_race(self, dict_type, cons):
             self.assertGreaterEqual(n2, 0)
             self.assertLessEqual(n2, n1)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_weak_keyed_len_race(self):
         self.check_len_race(weakref.WeakKeyDictionary, lambda k: (k, 1))
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_weak_valued_len_race(self):
         self.check_len_race(weakref.WeakValueDictionary, lambda k: (1, k))
 
@@ -1873,7 +1857,6 @@ def test_weak_valued_delitem(self):
         self.assertEqual(len(d), 1)
         self.assertEqual(list(d.items()), [('something else', o2)])
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_weak_keyed_bad_delitem(self):
         d = weakref.WeakKeyDictionary()
         o = Object('1')
@@ -1942,6 +1925,7 @@ def test_make_weak_keyed_dict_repr(self):
         dict = weakref.WeakKeyDictionary()
         self.assertRegex(repr(dict), '<WeakKeyDictionary at 0x.*>')
 
+    @unittest.skip("TODO: RUSTPYTHON; occasionally crash (malloc corruption)")
     @threading_helper.requires_working_threading()
     def test_threaded_weak_valued_setdefault(self):
         d = weakref.WeakValueDictionary()
@@ -1960,6 +1944,7 @@ def test_threaded_weak_valued_pop(self):
                 x = d.pop(10, 10)
                 self.assertIsNot(x, None)  # we never put None in there!
 
+    @unittest.skip("TODO: RUSTPYTHON; race condition between GC and WeakValueDictionary callback")
     @threading_helper.requires_working_threading()
     def test_threaded_weak_valued_consistency(self):
         # Issue #28427: old keys should not remove new values from
@@ -2053,13 +2038,15 @@ def pop_and_collect(lst):
         if exc:
             raise exc[0]
 
+    @unittest.skip("TODO: RUSTPYTHON; occasionally crash (malloc corruption)")
     @threading_helper.requires_working_threading()
+    @support.requires_resource('cpu')
     def test_threaded_weak_key_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.WeakKeyDictionary, False)
 
-    @unittest.skip('TODO: RUSTPYTHON; occasionally crash (malloc corruption)')
+    @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):
@@ -2067,14 +2054,15 @@ 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 (malloc corruption)')
+    @unittest.skip("TODO: RUSTPYTHON; occasionally crash (malloc corruption)")
     @threading_helper.requires_working_threading()
+    @support.requires_resource('cpu')
     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)')
+    @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):
@@ -2259,7 +2247,6 @@ def error():
         assert f3.atexit == True
         assert f4.atexit == True
 
-    @unittest.skipIf(sys.platform == 'win32', 'TODO: RUSTPYTHON; Windows')
     def test_atexit(self):
         prog = ('from test.test_weakref import FinalizeTestCase;'+
                 'FinalizeTestCase.run_in_child()')
@@ -2270,7 +2257,7 @@ def test_atexit(self):
 
 
 class ModuleTestCase(unittest.TestCase):
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_names(self):
         for name in ('ReferenceType', 'ProxyType', 'CallableProxyType',
                      'WeakMethod', 'WeakSet', 'WeakKeyDictionary', 'WeakValueDictionary'):
@@ -2370,9 +2357,7 @@ def test_names(self):
 __test__ = {'libreftest' : libreftest}
 
 def load_tests(loader, tests, pattern):
-    # TODO: RUSTPYTHON
-    # The doctest fails
-    # tests.addTest(doctest.DocTestSuite())
+    tests.addTest(doctest.DocTestSuite())
     return tests
 
 
diff --git a/Lib/test/test_weakset.py b/Lib/test/test_weakset.py
index 5e8cacc09dc..76e8e5c8ab7 100644
--- a/Lib/test/test_weakset.py
+++ b/Lib/test/test_weakset.py
@@ -403,8 +403,6 @@ def testcontext():
             s.clear()
         self.assertEqual(len(s), 0)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_len_cycles(self):
         N = 20
         items = [RefCycle() for i in range(N)]
@@ -425,8 +423,6 @@ def test_len_cycles(self):
         self.assertIn(n1, (0, 1))
         self.assertEqual(n2, 0)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_len_race(self):
         # Extended sanity checks for len() in the face of cyclic collection
         self.addCleanup(gc.set_threshold, *gc.get_threshold())
diff --git a/Lib/test/test_winconsoleio.py b/Lib/test/test_winconsoleio.py
new file mode 100644
index 00000000000..1bae884ed9a
--- /dev/null
+++ b/Lib/test/test_winconsoleio.py
@@ -0,0 +1,244 @@
+'''Tests for WindowsConsoleIO
+'''
+
+import io
+import os
+import sys
+import tempfile
+import unittest
+from test.support import os_helper, requires_resource
+
+if sys.platform != 'win32':
+    raise unittest.SkipTest("test only relevant on win32")
+
+from _testconsole import write_input
+
+ConIO = io._WindowsConsoleIO
+
+class WindowsConsoleIOTests(unittest.TestCase):
+    def test_abc(self):
+        self.assertIsSubclass(ConIO, io.RawIOBase)
+        self.assertNotIsSubclass(ConIO, io.BufferedIOBase)
+        self.assertNotIsSubclass(ConIO, io.TextIOBase)
+
+    def test_open_fd(self):
+        self.assertRaisesRegex(ValueError,
+            "negative file descriptor", ConIO, -1)
+
+        with tempfile.TemporaryFile() as tmpfile:
+            fd = tmpfile.fileno()
+            # Windows 10: "Cannot open non-console file"
+            # Earlier: "Cannot open console output buffer for reading"
+            self.assertRaisesRegex(ValueError,
+                "Cannot open (console|non-console file)", ConIO, fd)
+
+        try:
+            f = ConIO(0)
+        except ValueError:
+            # cannot open console because it's not a real console
+            pass
+        else:
+            self.assertTrue(f.readable())
+            self.assertFalse(f.writable())
+            self.assertEqual(0, f.fileno())
+            f.close()   # multiple close should not crash
+            f.close()
+            with self.assertWarns(RuntimeWarning):
+                with ConIO(False):
+                    pass
+
+        try:
+            f = ConIO(1, 'w')
+        except ValueError:
+            # cannot open console because it's not a real console
+            pass
+        else:
+            self.assertFalse(f.readable())
+            self.assertTrue(f.writable())
+            self.assertEqual(1, f.fileno())
+            f.close()
+            f.close()
+            with self.assertWarns(RuntimeWarning):
+                with ConIO(False):
+                    pass
+
+        try:
+            f = ConIO(2, 'w')
+        except ValueError:
+            # cannot open console because it's not a real console
+            pass
+        else:
+            self.assertFalse(f.readable())
+            self.assertTrue(f.writable())
+            self.assertEqual(2, f.fileno())
+            f.close()
+            f.close()
+
+    def test_open_name(self):
+        self.assertRaises(ValueError, ConIO, sys.executable)
+
+        f = ConIO("CON")
+        self.assertTrue(f.readable())
+        self.assertFalse(f.writable())
+        self.assertIsNotNone(f.fileno())
+        f.close()   # multiple close should not crash
+        f.close()
+
+        f = ConIO('CONIN$')
+        self.assertTrue(f.readable())
+        self.assertFalse(f.writable())
+        self.assertIsNotNone(f.fileno())
+        f.close()
+        f.close()
+
+        f = ConIO('CONOUT$', 'w')
+        self.assertFalse(f.readable())
+        self.assertTrue(f.writable())
+        self.assertIsNotNone(f.fileno())
+        f.close()
+        f.close()
+
+        # bpo-45354: Windows 11 changed MS-DOS device name handling
+        if sys.getwindowsversion()[:3] < (10, 0, 22000):
+            f = open('C:/con', 'rb', buffering=0)
+            self.assertIsInstance(f, ConIO)
+            f.close()
+
+    def test_subclass_repr(self):
+        class TestSubclass(ConIO):
+            pass
+
+        f = TestSubclass("CON")
+        with f:
+            self.assertIn(TestSubclass.__name__, repr(f))
+
+        self.assertIn(TestSubclass.__name__, repr(f))
+
+    @unittest.skipIf(sys.getwindowsversion()[:2] <= (6, 1),
+        "test does not work on Windows 7 and earlier")
+    def test_conin_conout_names(self):
+        f = open(r'\\.\conin$', 'rb', buffering=0)
+        self.assertIsInstance(f, ConIO)
+        f.close()
+
+        f = open('//?/conout$', 'wb', buffering=0)
+        self.assertIsInstance(f, ConIO)
+        f.close()
+
+    def test_conout_path(self):
+        temp_path = tempfile.mkdtemp()
+        self.addCleanup(os_helper.rmtree, temp_path)
+
+        conout_path = os.path.join(temp_path, 'CONOUT$')
+
+        with open(conout_path, 'wb', buffering=0) as f:
+            # bpo-45354: Windows 11 changed MS-DOS device name handling
+            if (6, 1) < sys.getwindowsversion()[:3] < (10, 0, 22000):
+                self.assertIsInstance(f, ConIO)
+            else:
+                self.assertNotIsInstance(f, ConIO)
+
+    def test_write_empty_data(self):
+        with ConIO('CONOUT$', 'w') as f:
+            self.assertEqual(f.write(b''), 0)
+
+    @requires_resource('console')
+    def test_write(self):
+        testcases = []
+        with ConIO('CONOUT$', 'w') as f:
+            for a in [
+                b'',
+                b'abc',
+                b'\xc2\xa7\xe2\x98\x83\xf0\x9f\x90\x8d',
+                b'\xff'*10,
+            ]:
+                for b in b'\xc2\xa7', b'\xe2\x98\x83', b'\xf0\x9f\x90\x8d':
+                    testcases.append(a + b)
+                    for i in range(1, len(b)):
+                        data = a + b[:i]
+                        testcases.append(data + b'z')
+                        testcases.append(data + b'\xff')
+                        # incomplete multibyte sequence
+                        with self.subTest(data=data):
+                            self.assertEqual(f.write(data), len(a))
+            for data in testcases:
+                with self.subTest(data=data):
+                    self.assertEqual(f.write(data), len(data))
+
+    def assertStdinRoundTrip(self, text):
+        stdin = open('CONIN$', 'r')
+        old_stdin = sys.stdin
+        try:
+            sys.stdin = stdin
+            write_input(
+                stdin.buffer.raw,
+                (text + '\r\n').encode('utf-16-le', 'surrogatepass')
+            )
+            actual = input()
+        finally:
+            sys.stdin = old_stdin
+        self.assertEqual(actual, text)
+
+    @requires_resource('console')
+    def test_input(self):
+        # ASCII
+        self.assertStdinRoundTrip('abc123')
+        # Non-ASCII
+        self.assertStdinRoundTrip('ϼўТλФЙ')
+        # Combining characters
+        self.assertStdinRoundTrip('A͏B ﬖ̳AA̝')
+
+    # bpo-38325
+    @unittest.skipIf(True, "Handling Non-BMP characters is broken")
+    def test_input_nonbmp(self):
+        # Non-BMP
+        self.assertStdinRoundTrip('\U00100000\U0010ffff\U0010fffd')
+
+    @requires_resource('console')
+    def test_partial_reads(self):
+        # Test that reading less than 1 full character works when stdin
+        # contains multibyte UTF-8 sequences
+        source = 'ϼўТλФЙ\r\n'.encode('utf-16-le')
+        expected = 'ϼўТλФЙ\r\n'.encode('utf-8')
+        for read_count in range(1, 16):
+            with open('CONIN$', 'rb', buffering=0) as stdin:
+                write_input(stdin, source)
+
+                actual = b''
+                while not actual.endswith(b'\n'):
+                    b = stdin.read(read_count)
+                    actual += b
+
+                self.assertEqual(actual, expected, 'stdin.read({})'.format(read_count))
+
+    # bpo-38325
+    @unittest.skipIf(True, "Handling Non-BMP characters is broken")
+    def test_partial_surrogate_reads(self):
+        # Test that reading less than 1 full character works when stdin
+        # contains surrogate pairs that cannot be decoded to UTF-8 without
+        # reading an extra character.
+        source = '\U00101FFF\U00101001\r\n'.encode('utf-16-le')
+        expected = '\U00101FFF\U00101001\r\n'.encode('utf-8')
+        for read_count in range(1, 16):
+            with open('CONIN$', 'rb', buffering=0) as stdin:
+                write_input(stdin, source)
+
+                actual = b''
+                while not actual.endswith(b'\n'):
+                    b = stdin.read(read_count)
+                    actual += b
+
+                self.assertEqual(actual, expected, 'stdin.read({})'.format(read_count))
+
+    @requires_resource('console')
+    def test_ctrl_z(self):
+        with open('CONIN$', 'rb', buffering=0) as stdin:
+            source = '\xC4\x1A\r\n'.encode('utf-16-le')
+            expected = '\xC4'.encode('utf-8')
+            write_input(stdin, source)
+            a, b = stdin.read(1), stdin.readall()
+            self.assertEqual(expected[0:1], a)
+            self.assertEqual(expected[1:], b)
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/Lib/test/test_winreg.py b/Lib/test/test_winreg.py
index 924a962781a..1bc830c02c3 100644
--- a/Lib/test/test_winreg.py
+++ b/Lib/test/test_winreg.py
@@ -3,6 +3,7 @@
 
 import gc
 import os, sys, errno
+import itertools
 import threading
 import unittest
 from platform import machine, win32_edition
@@ -291,6 +292,37 @@ def run(self):
             DeleteKey(HKEY_CURRENT_USER, test_key_name+'\\changing_value')
             DeleteKey(HKEY_CURRENT_USER, test_key_name)
 
+    def test_queryvalueex_race_condition(self):
+        # gh-142282: QueryValueEx could read garbage buffer under race
+        # condition when another thread changes the value size
+        done = False
+        ready = threading.Event()
+        values = [b'ham', b'spam']
+
+        class WriterThread(threading.Thread):
+            def run(self):
+                with CreateKey(HKEY_CURRENT_USER, test_key_name) as key:
+                    values_iter = itertools.cycle(values)
+                    while not done:
+                        val = next(values_iter)
+                        SetValueEx(key, 'test_value', 0, REG_BINARY, val)
+                        ready.set()
+
+        thread = WriterThread()
+        thread.start()
+        try:
+            ready.wait()
+            with CreateKey(HKEY_CURRENT_USER, test_key_name) as key:
+                for _ in range(1000):
+                    result, typ = QueryValueEx(key, 'test_value')
+                    # The result must be one of the written values,
+                    # not garbage data from uninitialized buffer
+                    self.assertIn(result, values)
+        finally:
+            done = True
+            thread.join()
+            DeleteKey(HKEY_CURRENT_USER, test_key_name)
+
     def test_long_key(self):
         # Issue2810, in 2.6 and 3.1 when the key name was exactly 256
         # characters, EnumKey raised "WindowsError: More data is
diff --git a/Lib/test/test_winsound.py b/Lib/test/test_winsound.py
new file mode 100644
index 00000000000..9724d830ade
--- /dev/null
+++ b/Lib/test/test_winsound.py
@@ -0,0 +1,187 @@
+# Ridiculously simple test of the winsound module for Windows.
+
+import functools
+import os
+import time
+import unittest
+
+from test import support
+from test.support import import_helper
+from test.support import os_helper
+
+
+support.requires('audio')
+winsound = import_helper.import_module('winsound')
+
+
+# Unless we actually have an ear in the room, we have no idea whether a sound
+# actually plays, and it's incredibly flaky trying to figure out if a sound
+# even *should* play.  Instead of guessing, just call the function and assume
+# it either passed or raised the RuntimeError we expect in case of failure.
+def sound_func(func):
+    @functools.wraps(func)
+    def wrapper(*args, **kwargs):
+        try:
+            ret = func(*args, **kwargs)
+        except RuntimeError as e:
+            if support.verbose:
+                print(func.__name__, 'failed:', e)
+        else:
+            if support.verbose:
+                print(func.__name__, 'returned')
+            return ret
+    return wrapper
+
+
+safe_Beep = sound_func(winsound.Beep)
+safe_MessageBeep = sound_func(winsound.MessageBeep)
+safe_PlaySound = sound_func(winsound.PlaySound)
+
+
+class BeepTest(unittest.TestCase):
+
+    def test_errors(self):
+        self.assertRaises(TypeError, winsound.Beep)
+        self.assertRaises(ValueError, winsound.Beep, 36, 75)
+        self.assertRaises(ValueError, winsound.Beep, 32768, 75)
+
+    def test_extremes(self):
+        safe_Beep(37, 75)
+        safe_Beep(32767, 75)
+
+    def test_increasingfrequency(self):
+        for i in range(100, 2000, 100):
+            safe_Beep(i, 75)
+
+    def test_keyword_args(self):
+        safe_Beep(duration=75, frequency=2000)
+
+
+class MessageBeepTest(unittest.TestCase):
+
+    def tearDown(self):
+        time.sleep(0.5)
+
+    def test_default(self):
+        self.assertRaises(TypeError, winsound.MessageBeep, "bad")
+        self.assertRaises(TypeError, winsound.MessageBeep, 42, 42)
+        safe_MessageBeep()
+
+    def test_ok(self):
+        safe_MessageBeep(winsound.MB_OK)
+
+    def test_asterisk(self):
+        safe_MessageBeep(winsound.MB_ICONASTERISK)
+
+    def test_exclamation(self):
+        safe_MessageBeep(winsound.MB_ICONEXCLAMATION)
+
+    def test_hand(self):
+        safe_MessageBeep(winsound.MB_ICONHAND)
+
+    def test_question(self):
+        safe_MessageBeep(winsound.MB_ICONQUESTION)
+
+    def test_error(self):
+        safe_MessageBeep(winsound.MB_ICONERROR)
+
+    def test_information(self):
+        safe_MessageBeep(winsound.MB_ICONINFORMATION)
+
+    def test_stop(self):
+        safe_MessageBeep(winsound.MB_ICONSTOP)
+
+    def test_warning(self):
+        safe_MessageBeep(winsound.MB_ICONWARNING)
+
+    def test_keyword_args(self):
+        safe_MessageBeep(type=winsound.MB_OK)
+
+
+class PlaySoundTest(unittest.TestCase):
+
+    def test_errors(self):
+        self.assertRaises(TypeError, winsound.PlaySound)
+        self.assertRaises(TypeError, winsound.PlaySound, "bad", "bad")
+        self.assertRaises(
+            RuntimeError,
+            winsound.PlaySound,
+            "none", winsound.SND_ASYNC | winsound.SND_MEMORY
+        )
+        self.assertRaises(TypeError, winsound.PlaySound, b"bad", 0)
+        self.assertRaises(TypeError, winsound.PlaySound, "bad",
+                          winsound.SND_MEMORY)
+        self.assertRaises(TypeError, winsound.PlaySound, 1, 0)
+        # embedded null character
+        self.assertRaises(ValueError, winsound.PlaySound, 'bad\0', 0)
+
+    def test_keyword_args(self):
+        safe_PlaySound(flags=winsound.SND_ALIAS, sound="SystemExit")
+
+    def test_snd_memory(self):
+        with open(support.findfile('pluck-pcm8.wav',
+                                   subdir='audiodata'), 'rb') as f:
+            audio_data = f.read()
+        safe_PlaySound(audio_data, winsound.SND_MEMORY)
+        audio_data = bytearray(audio_data)
+        safe_PlaySound(audio_data, winsound.SND_MEMORY)
+
+    def test_snd_filename(self):
+        fn = support.findfile('pluck-pcm8.wav', subdir='audiodata')
+        safe_PlaySound(fn, winsound.SND_FILENAME | winsound.SND_NODEFAULT)
+
+    def test_snd_filepath(self):
+        fn = support.findfile('pluck-pcm8.wav', subdir='audiodata')
+        path = os_helper.FakePath(fn)
+        safe_PlaySound(path, winsound.SND_FILENAME | winsound.SND_NODEFAULT)
+
+    def test_snd_filepath_as_bytes(self):
+        fn = support.findfile('pluck-pcm8.wav', subdir='audiodata')
+        self.assertRaises(
+            TypeError,
+            winsound.PlaySound,
+            os_helper.FakePath(os.fsencode(fn)),
+            winsound.SND_FILENAME | winsound.SND_NODEFAULT
+        )
+
+    def test_aliases(self):
+        aliases = [
+            "SystemAsterisk",
+            "SystemExclamation",
+            "SystemExit",
+            "SystemHand",
+            "SystemQuestion",
+        ]
+        for alias in aliases:
+            with self.subTest(alias=alias):
+                safe_PlaySound(alias, winsound.SND_ALIAS)
+
+    def test_alias_fallback(self):
+        safe_PlaySound('!"$%&/(#+*', winsound.SND_ALIAS)
+
+    def test_alias_nofallback(self):
+        safe_PlaySound('!"$%&/(#+*', winsound.SND_ALIAS | winsound.SND_NODEFAULT)
+
+    def test_stopasync(self):
+        safe_PlaySound(
+            'SystemQuestion',
+            winsound.SND_ALIAS | winsound.SND_ASYNC | winsound.SND_LOOP
+        )
+        time.sleep(0.5)
+        safe_PlaySound('SystemQuestion', winsound.SND_ALIAS | winsound.SND_NOSTOP)
+        # Issue 8367: PlaySound(None, winsound.SND_PURGE)
+        # does not raise on systems without a sound card.
+        winsound.PlaySound(None, winsound.SND_PURGE)
+
+    def test_sound_sentry(self):
+        safe_PlaySound("SystemExit", winsound.SND_ALIAS | winsound.SND_SENTRY)
+
+    def test_sound_sync(self):
+        safe_PlaySound("SystemExit", winsound.SND_ALIAS | winsound.SND_SYNC)
+
+    def test_sound_system(self):
+        safe_PlaySound("SystemExit", winsound.SND_ALIAS | winsound.SND_SYSTEM)
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/Lib/test/test_with.py b/Lib/test/test_with.py
index b321dac6c66..68ee3725088 100644
--- a/Lib/test/test_with.py
+++ b/Lib/test/test_with.py
@@ -1,9 +1,10 @@
-"""Unit tests for the with statement specified in PEP 343."""
+"""Unit tests for the 'with/async with' statements specified in PEP 343/492."""
 
 
 __author__ = "Mike Bland"
 __email__ = "mbland at acm dot org"
 
+import re
 import sys
 import traceback
 import unittest
@@ -11,6 +12,16 @@
 from contextlib import _GeneratorContextManager, contextmanager, nullcontext
 
 
+def do_with(obj):
+    with obj:
+        pass
+
+
+async def do_async_with(obj):
+    async with obj:
+        pass
+
+
 class MockContextManager(_GeneratorContextManager):
     def __init__(self, *args):
         super().__init__(*args)
@@ -110,34 +121,77 @@ def fooNotDeclared():
             with foo: pass
         self.assertRaises(NameError, fooNotDeclared)
 
-    def testEnterAttributeError1(self):
-        class LacksEnter(object):
-            def __exit__(self, type, value, traceback):
-                pass
-
-        def fooLacksEnter():
-            foo = LacksEnter()
-            with foo: pass
-        self.assertRaisesRegex(TypeError, 'the context manager', fooLacksEnter)
-
-    def testEnterAttributeError2(self):
-        class LacksEnterAndExit(object):
-            pass
+    def testEnterAttributeError(self):
+        class LacksEnter:
+            def __exit__(self, type, value, traceback): ...
 
-        def fooLacksEnterAndExit():
-            foo = LacksEnterAndExit()
-            with foo: pass
-        self.assertRaisesRegex(TypeError, 'the context manager', fooLacksEnterAndExit)
+        with self.assertRaisesRegex(TypeError, re.escape((
+            "object does not support the context manager protocol "
+            "(missed __enter__ method)"
+        ))):
+            do_with(LacksEnter())
 
     def testExitAttributeError(self):
-        class LacksExit(object):
-            def __enter__(self):
-                pass
-
-        def fooLacksExit():
-            foo = LacksExit()
-            with foo: pass
-        self.assertRaisesRegex(TypeError, 'the context manager.*__exit__', fooLacksExit)
+        class LacksExit:
+            def __enter__(self): ...
+
+        msg = re.escape((
+            "object does not support the context manager protocol "
+            "(missed __exit__ method)"
+        ))
+        # a missing __exit__ is reported missing before a missing __enter__
+        with self.assertRaisesRegex(TypeError, msg):
+            do_with(object())
+        with self.assertRaisesRegex(TypeError, msg):
+            do_with(LacksExit())
+
+    def testWithForAsyncManager(self):
+        class AsyncManager:
+            async def __aenter__(self): ...
+            async def __aexit__(self, type, value, traceback): ...
+
+        with self.assertRaisesRegex(TypeError, re.escape((
+            "object does not support the context manager protocol "
+            "(missed __exit__ method) but it supports the asynchronous "
+            "context manager protocol. Did you mean to use 'async with'?"
+        ))):
+            do_with(AsyncManager())
+
+    def testAsyncEnterAttributeError(self):
+        class LacksAsyncEnter:
+            async def __aexit__(self, type, value, traceback): ...
+
+        with self.assertRaisesRegex(TypeError, re.escape((
+            "object does not support the asynchronous context manager protocol "
+            "(missed __aenter__ method)"
+        ))):
+            do_async_with(LacksAsyncEnter()).send(None)
+
+    def testAsyncExitAttributeError(self):
+        class LacksAsyncExit:
+            async def __aenter__(self): ...
+
+        msg = re.escape((
+            "object does not support the asynchronous context manager protocol "
+            "(missed __aexit__ method)"
+        ))
+        # a missing __aexit__ is reported missing before a missing __aenter__
+        with self.assertRaisesRegex(TypeError, msg):
+            do_async_with(object()).send(None)
+        with self.assertRaisesRegex(TypeError, msg):
+            do_async_with(LacksAsyncExit()).send(None)
+
+    def testAsyncWithForSyncManager(self):
+        class SyncManager:
+            def __enter__(self): ...
+            def __exit__(self, type, value, traceback): ...
+
+        with self.assertRaisesRegex(TypeError, re.escape((
+            "object does not support the asynchronous context manager protocol "
+            "(missed __aexit__ method) but it supports the context manager "
+            "protocol. Did you mean to use 'with'?"
+        ))):
+            do_async_with(SyncManager()).send(None)
 
     def assertRaisesSyntaxError(self, codestr):
         def shouldRaiseSyntaxError(s):
@@ -190,6 +244,7 @@ def shouldThrow():
                 pass
         self.assertRaises(RuntimeError, shouldThrow)
 
+
 class ContextmanagerAssertionMixin(object):
 
     def setUp(self):
@@ -624,7 +679,7 @@ def testSingleComplexTarget(self):
         class C: pass
         blah = C()
         with mock_contextmanager_generator() as blah.foo:
-            self.assertEqual(hasattr(blah, "foo"), True)
+            self.assertHasAttr(blah, "foo")
 
     def testMultipleComplexTargets(self):
         class C:
@@ -719,7 +774,7 @@ def testExceptionInExprList(self):
         try:
             with self.Dummy() as a, self.InitRaises():
                 pass
-        except:
+        except RuntimeError:
             pass
         self.assertTrue(a.enter_called)
         self.assertTrue(a.exit_called)
@@ -752,7 +807,7 @@ def testEnterReturnsTuple(self):
             self.assertEqual(10, b1)
             self.assertEqual(20, b2)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON; AttributeError: 'FrameSummary' object has no attribute 'end_lineno'
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AttributeError: 'FrameSummary' object has no attribute 'end_lineno'
     def testExceptionLocation(self):
         # The location of an exception raised from
         # __init__, __enter__ or __exit__ of a context
diff --git a/Lib/test/test_wmi.py b/Lib/test/test_wmi.py
new file mode 100644
index 00000000000..90eb40439d4
--- /dev/null
+++ b/Lib/test/test_wmi.py
@@ -0,0 +1,89 @@
+# Test the internal _wmi module on Windows
+# This is used by the platform module, and potentially others
+
+import unittest
+from test import support
+from test.support import import_helper
+
+
+# Do this first so test will be skipped if module doesn't exist
+_wmi = import_helper.import_module('_wmi', required_on=['win'])
+
+
+def wmi_exec_query(query):
+    # gh-112278: WMI maybe slow response when first call.
+    for _ in support.sleeping_retry(support.LONG_TIMEOUT):
+        try:
+            return _wmi.exec_query(query)
+        except BrokenPipeError:
+            pass
+            # retry on pipe error
+        except WindowsError as exc:
+            if exc.winerror != 258:
+                raise
+            # retry on timeout
+
+
+class WmiTests(unittest.TestCase):
+    def test_wmi_query_os_version(self):
+        r = wmi_exec_query("SELECT Version FROM Win32_OperatingSystem").split("\0")
+        self.assertEqual(1, len(r))
+        k, eq, v = r[0].partition("=")
+        self.assertEqual("=", eq, r[0])
+        self.assertEqual("Version", k, r[0])
+        # Best we can check for the version is that it's digits, dot, digits, anything
+        # Otherwise, we are likely checking the result of the query against itself
+        self.assertRegex(v, r"\d+\.\d+.+$", r[0])
+
+    def test_wmi_query_repeated(self):
+        # Repeated queries should not break
+        for _ in range(10):
+            self.test_wmi_query_os_version()
+
+    def test_wmi_query_error(self):
+        # Invalid queries fail with OSError
+        try:
+            wmi_exec_query("SELECT InvalidColumnName FROM InvalidTableName")
+        except OSError as ex:
+            if ex.winerror & 0xFFFFFFFF == 0x80041010:
+                # This is the expected error code. All others should fail the test
+                return
+        self.fail("Expected OSError")
+
+    def test_wmi_query_repeated_error(self):
+        for _ in range(10):
+            self.test_wmi_query_error()
+
+    def test_wmi_query_not_select(self):
+        # Queries other than SELECT are blocked to avoid potential exploits
+        with self.assertRaises(ValueError):
+            wmi_exec_query("not select, just in case someone tries something")
+
+    @support.requires_resource('cpu')
+    def test_wmi_query_overflow(self):
+        # Ensure very big queries fail
+        # Test multiple times to ensure consistency
+        for _ in range(2):
+            with self.assertRaises(OSError):
+                wmi_exec_query("SELECT * FROM CIM_DataFile")
+
+    def test_wmi_query_multiple_rows(self):
+        # Multiple instances should have an extra null separator
+        r = wmi_exec_query("SELECT ProcessId FROM Win32_Process WHERE ProcessId < 1000")
+        self.assertNotStartsWith(r, "\0")
+        self.assertNotEndsWith(r, "\0")
+        it = iter(r.split("\0"))
+        try:
+            while True:
+                self.assertRegex(next(it), r"ProcessId=\d+")
+                self.assertEqual("", next(it))
+        except StopIteration:
+            pass
+
+    def test_wmi_query_threads(self):
+        from concurrent.futures import ThreadPoolExecutor
+        query = "SELECT ProcessId FROM Win32_Process WHERE ProcessId < 1000"
+        with ThreadPoolExecutor(4) as pool:
+            task = [pool.submit(wmi_exec_query, query) for _ in range(32)]
+            for t in task:
+                self.assertRegex(t.result(), "ProcessId=")
diff --git a/Lib/test/test_xml_etree.py b/Lib/test/test_xml_etree.py
index 2281f48ce25..f9b4f3abcad 100644
--- a/Lib/test/test_xml_etree.py
+++ b/Lib/test/test_xml_etree.py
@@ -155,9 +155,9 @@ class ModuleTest(unittest.TestCase):
     def test_sanity(self):
         # Import sanity.
 
-        from xml.etree import ElementTree
-        from xml.etree import ElementInclude
-        from xml.etree import ElementPath
+        from xml.etree import ElementTree     # noqa: F401
+        from xml.etree import ElementInclude  # noqa: F401
+        from xml.etree import ElementPath     # noqa: F401
 
     def test_all(self):
         names = ("xml.etree.ElementTree", "_elementtree")
@@ -252,8 +252,7 @@ def check_element(element):
             self.assertTrue(ET.iselement(element), msg="not an element")
             direlem = dir(element)
             for attr in 'tag', 'attrib', 'text', 'tail':
-                self.assertTrue(hasattr(element, attr),
-                        msg='no %s member' % attr)
+                self.assertHasAttr(element, attr)
                 self.assertIn(attr, direlem,
                         msg='no %s visible by dir' % attr)
 
@@ -278,7 +277,7 @@ def check_element(element):
         # Make sure all standard element methods exist.
 
         def check_method(method):
-            self.assertTrue(hasattr(method, '__call__'),
+            self.assertHasAttr(method, '__call__',
                     msg="%s not callable" % method)
 
         check_method(element.append)
@@ -339,7 +338,6 @@ def test_set_attribute(self):
         element.attrib = {'A': 'B', 'C': 'D'}
         self.assertEqual(element.attrib, {'A': 'B', 'C': 'D'})
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_simpleops(self):
         # Basic method sanity checks.
 
@@ -372,9 +370,9 @@ def test_simpleops(self):
         self.serialize_check(element, '<tag key="value"><subtag /></tag>') # 4
         element.remove(subelement)
         self.serialize_check(element, '<tag key="value" />') # 5
-        with self.assertRaises(ValueError) as cm:
+        with self.assertRaisesRegex(ValueError,
+                                    r'Element\.remove\(.+\): element not found'):
             element.remove(subelement)
-        self.assertEqual(str(cm.exception), 'list.remove(x): x not in list')
         self.serialize_check(element, '<tag key="value" />') # 6
         element[0:0] = [subelement, subelement, subelement]
         self.serialize_check(element[1], '<subtag />')
@@ -394,7 +392,7 @@ def test_cdata(self):
         self.serialize_check(ET.XML("<tag><![CDATA[hello]]></tag>"),
                 '<tag>hello</tag>')
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_file_init(self):
         stringfile = io.BytesIO(SAMPLE_XML.encode("utf-8"))
         tree = ET.ElementTree(file=stringfile)
@@ -510,7 +508,7 @@ def test_makeelement(self):
         elem[:] = tuple([subelem])
         self.serialize_check(elem, '<tag><subtag key="value" /></tag>')
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_parsefile(self):
         # Test parsing from file.
 
@@ -556,7 +554,7 @@ def test_parsefile(self):
                 '   <empty-element />\n'
                 '</root>')
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_parseliteral(self):
         element = ET.XML("<html><body>text</body></html>")
         self.assertEqual(ET.tostring(element, encoding='unicode'),
@@ -579,210 +577,6 @@ def test_parseliteral(self):
         self.assertEqual(len(ids), 1)
         self.assertEqual(ids["body"].tag, 'body')
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
-    def test_iterparse(self):
-        # Test iterparse interface.
-
-        iterparse = ET.iterparse
-
-        context = iterparse(SIMPLE_XMLFILE)
-        self.assertIsNone(context.root)
-        action, elem = next(context)
-        self.assertIsNone(context.root)
-        self.assertEqual((action, elem.tag), ('end', 'element'))
-        self.assertEqual([(action, elem.tag) for action, elem in context], [
-                ('end', 'element'),
-                ('end', 'empty-element'),
-                ('end', 'root'),
-            ])
-        self.assertEqual(context.root.tag, 'root')
-
-        context = iterparse(SIMPLE_NS_XMLFILE)
-        self.assertEqual([(action, elem.tag) for action, elem in context], [
-                ('end', '{namespace}element'),
-                ('end', '{namespace}element'),
-                ('end', '{namespace}empty-element'),
-                ('end', '{namespace}root'),
-            ])
-
-        with open(SIMPLE_XMLFILE, 'rb') as source:
-            context = iterparse(source)
-            action, elem = next(context)
-            self.assertEqual((action, elem.tag), ('end', 'element'))
-            self.assertEqual([(action, elem.tag) for action, elem in context], [
-                    ('end', 'element'),
-                    ('end', 'empty-element'),
-                    ('end', 'root'),
-                ])
-            self.assertEqual(context.root.tag, 'root')
-
-        events = ()
-        context = iterparse(SIMPLE_XMLFILE, events)
-        self.assertEqual([(action, elem.tag) for action, elem in context], [])
-
-        events = ()
-        context = iterparse(SIMPLE_XMLFILE, events=events)
-        self.assertEqual([(action, elem.tag) for action, elem in context], [])
-
-        events = ("start", "end")
-        context = iterparse(SIMPLE_XMLFILE, events)
-        self.assertEqual([(action, elem.tag) for action, elem in context], [
-                ('start', 'root'),
-                ('start', 'element'),
-                ('end', 'element'),
-                ('start', 'element'),
-                ('end', 'element'),
-                ('start', 'empty-element'),
-                ('end', 'empty-element'),
-                ('end', 'root'),
-            ])
-
-        events = ("start", "end", "start-ns", "end-ns")
-        context = iterparse(SIMPLE_NS_XMLFILE, events)
-        self.assertEqual([(action, elem.tag) if action in ("start", "end")
-                                             else (action, elem)
-                          for action, elem in context], [
-                ('start-ns', ('', 'namespace')),
-                ('start', '{namespace}root'),
-                ('start', '{namespace}element'),
-                ('end', '{namespace}element'),
-                ('start', '{namespace}element'),
-                ('end', '{namespace}element'),
-                ('start', '{namespace}empty-element'),
-                ('end', '{namespace}empty-element'),
-                ('end', '{namespace}root'),
-                ('end-ns', None),
-            ])
-
-        events = ('start-ns', 'end-ns')
-        context = iterparse(io.StringIO(r"<root xmlns=''/>"), events)
-        res = [action for action, elem in context]
-        self.assertEqual(res, ['start-ns', 'end-ns'])
-
-        events = ("start", "end", "bogus")
-        with open(SIMPLE_XMLFILE, "rb") as f:
-            with self.assertRaises(ValueError) as cm:
-                iterparse(f, events)
-            self.assertFalse(f.closed)
-        self.assertEqual(str(cm.exception), "unknown event 'bogus'")
-
-        with warnings_helper.check_no_resource_warning(self):
-            with self.assertRaises(ValueError) as cm:
-                iterparse(SIMPLE_XMLFILE, events)
-            self.assertEqual(str(cm.exception), "unknown event 'bogus'")
-            del cm
-
-        source = io.BytesIO(
-            b"<?xml version='1.0' encoding='iso-8859-1'?>\n"
-            b"<body xmlns='http://&#233;ffbot.org/ns'\n"
-            b"      xmlns:cl\xe9='http://effbot.org/ns'>text</body>\n")
-        events = ("start-ns",)
-        context = iterparse(source, events)
-        self.assertEqual([(action, elem) for action, elem in context], [
-                ('start-ns', ('', 'http://\xe9ffbot.org/ns')),
-                ('start-ns', ('cl\xe9', 'http://effbot.org/ns')),
-            ])
-
-        source = io.StringIO("<document />junk")
-        it = iterparse(source)
-        action, elem = next(it)
-        self.assertEqual((action, elem.tag), ('end', 'document'))
-        with self.assertRaises(ET.ParseError) as cm:
-            next(it)
-        self.assertEqual(str(cm.exception),
-                'junk after document element: line 1, column 12')
-
-        self.addCleanup(os_helper.unlink, TESTFN)
-        with open(TESTFN, "wb") as f:
-            f.write(b"<document />junk")
-        it = iterparse(TESTFN)
-        action, elem = next(it)
-        self.assertEqual((action, elem.tag), ('end', 'document'))
-        with warnings_helper.check_no_resource_warning(self):
-            with self.assertRaises(ET.ParseError) as cm:
-                next(it)
-            self.assertEqual(str(cm.exception),
-                    'junk after document element: line 1, column 12')
-            del cm, it
-
-        # Not exhausting the iterator still closes the resource (bpo-43292)
-        with warnings_helper.check_no_resource_warning(self):
-            it = iterparse(SIMPLE_XMLFILE)
-            del it
-
-        with warnings_helper.check_no_resource_warning(self):
-            it = iterparse(SIMPLE_XMLFILE)
-            it.close()
-            del it
-
-        with warnings_helper.check_no_resource_warning(self):
-            it = iterparse(SIMPLE_XMLFILE)
-            action, elem = next(it)
-            self.assertEqual((action, elem.tag), ('end', 'element'))
-            del it, elem
-
-        with warnings_helper.check_no_resource_warning(self):
-            it = iterparse(SIMPLE_XMLFILE)
-            action, elem = next(it)
-            it.close()
-            self.assertEqual((action, elem.tag), ('end', 'element'))
-            del it, elem
-
-        with self.assertRaises(FileNotFoundError):
-            iterparse("nonexistent")
-
-    @unittest.expectedFailure # TODO: RUSTPYTHON
-    def test_iterparse_close(self):
-        iterparse = ET.iterparse
-
-        it = iterparse(SIMPLE_XMLFILE)
-        it.close()
-        with self.assertRaises(StopIteration):
-            next(it)
-        it.close()  # idempotent
-
-        with open(SIMPLE_XMLFILE, 'rb') as source:
-            it = iterparse(source)
-            it.close()
-            self.assertFalse(source.closed)
-            with self.assertRaises(StopIteration):
-                next(it)
-            it.close()  # idempotent
-
-        it = iterparse(SIMPLE_XMLFILE)
-        action, elem = next(it)
-        self.assertEqual((action, elem.tag), ('end', 'element'))
-        it.close()
-        with self.assertRaises(StopIteration):
-            next(it)
-        it.close()  # idempotent
-
-        with open(SIMPLE_XMLFILE, 'rb') as source:
-            it = iterparse(source)
-            action, elem = next(it)
-            self.assertEqual((action, elem.tag), ('end', 'element'))
-            it.close()
-            self.assertFalse(source.closed)
-            with self.assertRaises(StopIteration):
-                next(it)
-            it.close()  # idempotent
-
-        it = iterparse(SIMPLE_XMLFILE)
-        list(it)
-        it.close()
-        with self.assertRaises(StopIteration):
-            next(it)
-        it.close()  # idempotent
-
-        with open(SIMPLE_XMLFILE, 'rb') as source:
-            it = iterparse(source)
-            list(it)
-            it.close()
-            self.assertFalse(source.closed)
-            with self.assertRaises(StopIteration):
-                next(it)
-            it.close()  # idempotent
-
     def test_writefile(self):
         elem = ET.Element("tag")
         elem.text = "text"
@@ -800,7 +594,7 @@ def test_writefile(self):
         elem[0] = ET.PI("key", "value")
         self.serialize_check(elem, 'text<?key value?><subtag>subtext</subtag>')
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_custom_builder(self):
         # Test parser w. custom builder.
 
@@ -862,7 +656,7 @@ def end_ns(self, prefix):
                 ('end-ns', ''),
             ])
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_custom_builder_only_end_ns(self):
         class Builder(list):
             def end_ns(self, prefix):
@@ -894,7 +688,7 @@ def test_initialize_parser_without_target(self):
         parser2 = ET.XMLParser()
         self.assertIsInstance(parser2.target, ET.TreeBuilder)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_children(self):
         # Test Element children iteration
 
@@ -1174,7 +968,7 @@ def test_tostringlist_xml_declaration(self):
         self.assertRegex(stringlist[0], r"^<\?xml version='1.0' encoding='.+'?>")
         self.assertEqual(['<body', '>', '<tag', ' />', '</body>'], stringlist[1:])
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_encoding(self):
         def check(encoding, body=''):
             xml = ("<?xml version='1.0' encoding='%s'?><xml>%s</xml>" %
@@ -1256,7 +1050,7 @@ def test_issue18347(self):
         self.assertEqual(serialize(e, method="html"),
                 '<html><CamelCase>text</CamelCase></html>')
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_entity(self):
         # Test entity handling.
 
@@ -1294,7 +1088,7 @@ def test_entity(self):
         self.assertEqual(str(cm.exception),
                 'undefined entity &entity;: line 4, column 10')
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_namespace(self):
         # Test namespace issues.
 
@@ -1505,7 +1299,7 @@ def test_tree_write_attribute_order(self):
         self.assertEqual(serialize(root, method='html'),
                 '<cirriculum status="public" company="example"></cirriculum>')
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_attlist_default(self):
         # Test default attribute values; See BPO 42151.
         root = ET.fromstring(ATTLIST_XML)
@@ -1513,6 +1307,243 @@ def test_attlist_default(self):
                          {'{http://www.w3.org/XML/1998/namespace}lang': 'eng'})
 
 
+class IterparseTest(unittest.TestCase):
+    # Test iterparse interface.
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    def test_basic(self):
+        iterparse = ET.iterparse
+
+        it = iterparse(SIMPLE_XMLFILE)
+        self.assertIsNone(it.root)
+        action, elem = next(it)
+        self.assertIsNone(it.root)
+        self.assertEqual((action, elem.tag), ('end', 'element'))
+        self.assertEqual([(action, elem.tag) for action, elem in it], [
+                ('end', 'element'),
+                ('end', 'empty-element'),
+                ('end', 'root'),
+            ])
+        self.assertEqual(it.root.tag, 'root')
+        it.close()
+
+        it = iterparse(SIMPLE_NS_XMLFILE)
+        self.assertEqual([(action, elem.tag) for action, elem in it], [
+                ('end', '{namespace}element'),
+                ('end', '{namespace}element'),
+                ('end', '{namespace}empty-element'),
+                ('end', '{namespace}root'),
+            ])
+        it.close()
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    def test_external_file(self):
+        with open(SIMPLE_XMLFILE, 'rb') as source:
+            it = ET.iterparse(source)
+            action, elem = next(it)
+            self.assertEqual((action, elem.tag), ('end', 'element'))
+            self.assertEqual([(action, elem.tag) for action, elem in it], [
+                    ('end', 'element'),
+                    ('end', 'empty-element'),
+                    ('end', 'root'),
+                ])
+            self.assertEqual(it.root.tag, 'root')
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    def test_events(self):
+        iterparse = ET.iterparse
+
+        events = ()
+        it = iterparse(SIMPLE_XMLFILE, events)
+        self.assertEqual([(action, elem.tag) for action, elem in it], [])
+        it.close()
+
+        events = ()
+        it = iterparse(SIMPLE_XMLFILE, events=events)
+        self.assertEqual([(action, elem.tag) for action, elem in it], [])
+        it.close()
+
+        events = ("start", "end")
+        it = iterparse(SIMPLE_XMLFILE, events)
+        self.assertEqual([(action, elem.tag) for action, elem in it], [
+                ('start', 'root'),
+                ('start', 'element'),
+                ('end', 'element'),
+                ('start', 'element'),
+                ('end', 'element'),
+                ('start', 'empty-element'),
+                ('end', 'empty-element'),
+                ('end', 'root'),
+            ])
+        it.close()
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    def test_namespace_events(self):
+        iterparse = ET.iterparse
+
+        events = ("start", "end", "start-ns", "end-ns")
+        it = iterparse(SIMPLE_NS_XMLFILE, events)
+        self.assertEqual([(action, elem.tag) if action in ("start", "end")
+                                             else (action, elem)
+                          for action, elem in it], [
+                ('start-ns', ('', 'namespace')),
+                ('start', '{namespace}root'),
+                ('start', '{namespace}element'),
+                ('end', '{namespace}element'),
+                ('start', '{namespace}element'),
+                ('end', '{namespace}element'),
+                ('start', '{namespace}empty-element'),
+                ('end', '{namespace}empty-element'),
+                ('end', '{namespace}root'),
+                ('end-ns', None),
+            ])
+        it.close()
+
+        events = ('start-ns', 'end-ns')
+        it = iterparse(io.BytesIO(br"<root xmlns=''/>"), events)
+        res = [action for action, elem in it]
+        self.assertEqual(res, ['start-ns', 'end-ns'])
+        it.close()
+
+    def test_unknown_events(self):
+        iterparse = ET.iterparse
+
+        events = ("start", "end", "bogus")
+        with open(SIMPLE_XMLFILE, "rb") as f:
+            with self.assertRaises(ValueError) as cm:
+                iterparse(f, events)
+            self.assertFalse(f.closed)
+        self.assertEqual(str(cm.exception), "unknown event 'bogus'")
+
+        with warnings_helper.check_no_resource_warning(self):
+            with self.assertRaises(ValueError) as cm:
+                iterparse(SIMPLE_XMLFILE, events)
+            self.assertEqual(str(cm.exception), "unknown event 'bogus'")
+            del cm
+            gc_collect()
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    def test_non_utf8(self):
+        source = io.BytesIO(
+            b"<?xml version='1.0' encoding='iso-8859-1'?>\n"
+            b"<body xmlns='http://&#233;ffbot.org/ns'\n"
+            b"      xmlns:cl\xe9='http://effbot.org/ns'>text</body>\n")
+        events = ("start-ns",)
+        it = ET.iterparse(source, events)
+        self.assertEqual([(action, elem) for action, elem in it], [
+                ('start-ns', ('', 'http://\xe9ffbot.org/ns')),
+                ('start-ns', ('cl\xe9', 'http://effbot.org/ns')),
+            ])
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    def test_parsing_error(self):
+        source = io.BytesIO(b"<document />junk")
+        it = ET.iterparse(source)
+        action, elem = next(it)
+        self.assertEqual((action, elem.tag), ('end', 'document'))
+        with self.assertRaises(ET.ParseError) as cm:
+            next(it)
+        self.assertEqual(str(cm.exception),
+                'junk after document element: line 1, column 12')
+
+    def test_nonexistent_file(self):
+        with self.assertRaises(FileNotFoundError):
+            ET.iterparse("nonexistent")
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    def test_resource_warnings_not_exhausted(self):
+        # Not exhausting the iterator still closes the underlying file (bpo-43292)
+        it = ET.iterparse(SIMPLE_XMLFILE)
+        with warnings_helper.check_no_resource_warning(self):
+            del it
+            gc_collect()
+
+        it = ET.iterparse(SIMPLE_XMLFILE)
+        with warnings_helper.check_no_resource_warning(self):
+            action, elem = next(it)
+            self.assertEqual((action, elem.tag), ('end', 'element'))
+            del it, elem
+            gc_collect()
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    def test_resource_warnings_failed_iteration(self):
+        self.addCleanup(os_helper.unlink, TESTFN)
+        with open(TESTFN, "wb") as f:
+            f.write(b"<document />junk")
+
+        it = ET.iterparse(TESTFN)
+        action, elem = next(it)
+        self.assertEqual((action, elem.tag), ('end', 'document'))
+        with warnings_helper.check_no_resource_warning(self):
+            with self.assertRaises(ET.ParseError) as cm:
+                next(it)
+            self.assertEqual(str(cm.exception),
+                    'junk after document element: line 1, column 12')
+            del cm, it
+            gc_collect()
+
+    def test_resource_warnings_exhausted(self):
+        it = ET.iterparse(SIMPLE_XMLFILE)
+        with warnings_helper.check_no_resource_warning(self):
+            list(it)
+            del it
+            gc_collect()
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    def test_close_not_exhausted(self):
+        iterparse = ET.iterparse
+
+        it = iterparse(SIMPLE_XMLFILE)
+        it.close()
+        with self.assertRaises(StopIteration):
+            next(it)
+        it.close()  # idempotent
+
+        with open(SIMPLE_XMLFILE, 'rb') as source:
+            it = iterparse(source)
+            it.close()
+            self.assertFalse(source.closed)
+            with self.assertRaises(StopIteration):
+                next(it)
+            it.close()  # idempotent
+
+        it = iterparse(SIMPLE_XMLFILE)
+        action, elem = next(it)
+        self.assertEqual((action, elem.tag), ('end', 'element'))
+        it.close()
+        with self.assertRaises(StopIteration):
+            next(it)
+        it.close()  # idempotent
+
+        with open(SIMPLE_XMLFILE, 'rb') as source:
+            it = iterparse(source)
+            action, elem = next(it)
+            self.assertEqual((action, elem.tag), ('end', 'element'))
+            it.close()
+            self.assertFalse(source.closed)
+            with self.assertRaises(StopIteration):
+                next(it)
+            it.close()  # idempotent
+
+    def test_close_exhausted(self):
+        iterparse = ET.iterparse
+        it = iterparse(SIMPLE_XMLFILE)
+        list(it)
+        it.close()
+        with self.assertRaises(StopIteration):
+            next(it)
+        it.close()  # idempotent
+
+        with open(SIMPLE_XMLFILE, 'rb') as source:
+            it = iterparse(source)
+            list(it)
+            it.close()
+            self.assertFalse(source.closed)
+            with self.assertRaises(StopIteration):
+                next(it)
+            it.close()  # idempotent
+
+
 class XMLPullParserTest(unittest.TestCase):
 
     def _feed(self, parser, data, chunk_size=None, flush=False):
@@ -1540,7 +1571,7 @@ def assert_event_tags(self, parser, expected, max_events=None):
         self.assertEqual([(action, elem.tag) for action, elem in events],
                          expected)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_simple_xml(self, chunk_size=None, flush=False):
         parser = ET.XMLPullParser()
         self.assert_event_tags(parser, [])
@@ -1562,19 +1593,19 @@ def test_simple_xml(self, chunk_size=None, flush=False):
         self.assert_event_tags(parser, [('end', 'root')])
         self.assertIsNone(parser.close())
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_simple_xml_chunk_1(self):
         self.test_simple_xml(chunk_size=1, flush=True)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_simple_xml_chunk_5(self):
         self.test_simple_xml(chunk_size=5, flush=True)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_simple_xml_chunk_22(self):
         self.test_simple_xml(chunk_size=22)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_feed_while_iterating(self):
         parser = ET.XMLPullParser()
         it = parser.read_events()
@@ -1587,7 +1618,7 @@ def test_feed_while_iterating(self):
         with self.assertRaises(StopIteration):
             next(it)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_simple_xml_with_ns(self):
         parser = ET.XMLPullParser()
         self.assert_event_tags(parser, [])
@@ -1609,7 +1640,7 @@ def test_simple_xml_with_ns(self):
         self.assert_event_tags(parser, [('end', '{namespace}root')])
         self.assertIsNone(parser.close())
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_ns_events(self):
         parser = ET.XMLPullParser(events=('start-ns', 'end-ns'))
         self._feed(parser, "<!-- comment -->\n")
@@ -1625,7 +1656,7 @@ def test_ns_events(self):
         self.assertEqual(list(parser.read_events()), [('end-ns', None)])
         self.assertIsNone(parser.close())
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_ns_events_start(self):
         parser = ET.XMLPullParser(events=('start-ns', 'start', 'end'))
         self._feed(parser, "<tag xmlns='abc' xmlns:p='xyz'>\n")
@@ -1649,7 +1680,7 @@ def test_ns_events_start(self):
             ('end', '{abc}tag'),
         ])
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_ns_events_start_end(self):
         parser = ET.XMLPullParser(events=('start-ns', 'start', 'end', 'end-ns'))
         self._feed(parser, "<tag xmlns='abc' xmlns:p='xyz'>\n")
@@ -1677,7 +1708,7 @@ def test_ns_events_start_end(self):
             ('end-ns', None),
         ])
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_events(self):
         parser = ET.XMLPullParser(events=())
         self._feed(parser, "<root/>\n")
@@ -1724,7 +1755,7 @@ def test_events(self):
         self._feed(parser, "</root>")
         self.assertIsNone(parser.close())
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_events_comment(self):
         parser = ET.XMLPullParser(events=('start', 'comment', 'end'))
         self._feed(parser, "<!-- text here -->\n")
@@ -1744,7 +1775,7 @@ def test_events_comment(self):
         self._feed(parser, "<!-- text here -->\n")
         self.assert_events(parser, [('comment', (ET.Comment, ' text here '))])
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_events_pi(self):
         parser = ET.XMLPullParser(events=('start', 'pi', 'end'))
         self._feed(parser, "<?pitarget?>\n")
@@ -1775,8 +1806,10 @@ def __next__(self):
     def test_unknown_event(self):
         with self.assertRaises(ValueError):
             ET.XMLPullParser(events=('start', 'end', 'bogus'))
+        with self.assertRaisesRegex(ValueError, "unknown event 'bogus'"):
+            ET.XMLPullParser(events=(x.decode() for x in (b'start', b'end', b'bogus')))
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     @unittest.skipIf(pyexpat.version_info < (2, 6, 0),
                      f'Expat {pyexpat.version_info} does not '
                      'support reparse deferral')
@@ -1801,7 +1834,7 @@ def test_flush_reparse_deferral_enabled(self):
 
         self.assert_event_tags(parser, [('end', 'doc')])
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_flush_reparse_deferral_disabled(self):
         parser = ET.XMLPullParser(events=('start', 'end'))
 
@@ -1984,7 +2017,7 @@ def _my_loader(self, href, parse):
         else:
             return None
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_xinclude_default(self):
         from xml.etree import ElementInclude
         doc = self.xinclude_loader('default.xml')
@@ -1999,7 +2032,7 @@ def test_xinclude_default(self):
             '</root>\n'
             '</document>')
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_xinclude(self):
         from xml.etree import ElementInclude
 
@@ -2064,7 +2097,7 @@ def test_xinclude(self):
             '  </ns0:include>\n'
             '</div>') # C5
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_xinclude_repeated(self):
         from xml.etree import ElementInclude
 
@@ -2072,7 +2105,7 @@ def test_xinclude_repeated(self):
         ElementInclude.include(document, self.xinclude_loader)
         self.assertEqual(1+4*2, len(document.findall(".//p")))
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_xinclude_failures(self):
         from xml.etree import ElementInclude
 
@@ -2177,7 +2210,7 @@ def check(elem):
         elem.set("123", 123)
         check(elem) # attribute value
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_bug_xmltoolkit25(self):
         # typo in ElementTree.findtext
 
@@ -2201,7 +2234,7 @@ def test_bug_xmltoolkitX1(self):
             ET.dump(tree)
             self.assertEqual(stdout.getvalue(), '<doc><table><tbody /></table></doc>\n')
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_bug_xmltoolkit39(self):
         # non-ascii element and attribute names doesn't work
 
@@ -2236,7 +2269,7 @@ def test_bug_xmltoolkit54(self):
                 b'<doc>&#33328;</doc>')
         self.assertEqual(serialize(e), '<doc>\u8230</doc>')
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_bug_xmltoolkit55(self):
         # make sure we're reporting the first error, not the last
 
@@ -2255,7 +2288,7 @@ def read(self, x):
 
         self.assertRaises(OSError, ET.parse, ExceptionFile())
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_bug_xmltoolkit62(self):
         # Don't crash when using custom entities.
 
@@ -2288,7 +2321,7 @@ def xmltoolkit63():
             xmltoolkit63()
         self.assertEqual(sys.getrefcount(None), count)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_bug_200708_newline(self):
         # Preserve newlines in attributes.
 
@@ -2404,7 +2437,7 @@ def test_issue6233(self):
                 b"<?xml version='1.0' encoding='ascii'?>\n"
                 b'<body>t&#227;g</body>')
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_issue6565(self):
         elem = ET.XML("<body><tag/></body>")
         self.assertEqual(summarize_list(elem), ['tag'])
@@ -2450,7 +2483,7 @@ def __bool__(self):
         self.assertIsInstance(e[0].tail, str)
         self.assertEqual(e[0].tail, 'changed')
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_lost_elem(self):
         # Issue #25902: Borrowed element can disappear
         class Tag:
@@ -2476,7 +2509,7 @@ def check_expat224_utf8_bug(self, text):
         root = ET.XML(xml)
         self.assertEqual(root.get('b'), text.decode('utf-8'))
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_expat224_utf8_bug(self):
         # bpo-31170: Expat 2.2.3 had a bug in its UTF-8 decoder.
         # Check that Expat 2.2.4 fixed the bug.
@@ -2489,7 +2522,7 @@ def test_expat224_utf8_bug(self):
         text = b'x' + b'\xc3\xa0' * 1024
         self.check_expat224_utf8_bug(text)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_expat224_utf8_bug_file(self):
         with open(UTF8_BUG_XMLFILE, 'rb') as fp:
             raw = fp.read()
@@ -2639,7 +2672,7 @@ def __deepcopy__(self, memo):
             e[:] = [E('bar')]
             self.assertRaises(TypeError, copy.deepcopy, e)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_cyclic_gc(self):
         class Dummy:
             pass
@@ -2977,32 +3010,72 @@ def __del__(self):
         elem = b.close()
         self.assertEqual(elem[0].tail, 'ABCDEFGHIJKL')
 
-    def test_subscr(self):
-        # Issue #27863
+    def test_subscr_with_clear(self):
+        # See https://github.com/python/cpython/issues/143200.
+        self.do_test_subscr_with_mutating_slice(use_clear_method=True)
+
+    def test_subscr_with_delete(self):
+        # See https://github.com/python/cpython/issues/72050.
+        self.do_test_subscr_with_mutating_slice(use_clear_method=False)
+
+    def do_test_subscr_with_mutating_slice(self, *, use_clear_method):
         class X:
+            def __init__(self, i=0):
+                self.i = i
             def __index__(self):
-                del e[:]
-                return 1
+                if use_clear_method:
+                    e.clear()
+                else:
+                    del e[:]
+                return self.i
 
-        e = ET.Element('elem')
-        e.append(ET.Element('child'))
-        e[:X()]  # shouldn't crash
+        for s in self.get_mutating_slices(X, 10):
+            with self.subTest(s):
+                e = ET.Element('elem')
+                e.extend([ET.Element(f'c{i}') for i in range(10)])
+                e[s]  # shouldn't crash
 
-        e.append(ET.Element('child'))
-        e[0:10:X()]  # shouldn't crash
+    def test_ass_subscr_with_mutating_slice(self):
+        # See https://github.com/python/cpython/issues/72050
+        # and https://github.com/python/cpython/issues/143200.
 
-    def test_ass_subscr(self):
-        # Issue #27863
         class X:
+            def __init__(self, i=0):
+                self.i = i
             def __index__(self):
                 e[:] = []
-                return 1
+                return self.i
+
+        for s in self.get_mutating_slices(X, 10):
+            with self.subTest(s):
+                e = ET.Element('elem')
+                e.extend([ET.Element(f'c{i}') for i in range(10)])
+                e[s] = []  # shouldn't crash
+
+    def get_mutating_slices(self, index_class, n_children):
+        self.assertGreaterEqual(n_children, 10)
+        return [
+            slice(index_class(), None, None),
+            slice(index_class(2), None, None),
+            slice(None, index_class(), None),
+            slice(None, index_class(2), None),
+            slice(0, 2, index_class(1)),
+            slice(0, 2, index_class(2)),
+            slice(0, n_children, index_class(1)),
+            slice(0, n_children, index_class(2)),
+            slice(0, 2 * n_children, index_class(1)),
+            slice(0, 2 * n_children, index_class(2)),
+        ]
 
-        e = ET.Element('elem')
-        for _ in range(10):
-            e.insert(0, ET.Element('child'))
+    def test_ass_subscr_with_mutating_iterable_value(self):
+        class V:
+            def __iter__(self):
+                e.clear()
+                return iter([ET.Element('a'), ET.Element('b')])
 
-        e[0:10:X()] = []  # shouldn't crash
+        e = ET.Element('elem')
+        e.extend([ET.Element(f'c{i}') for i in range(10)])
+        e[:] = V()
 
     def test_treebuilder_start(self):
         # Issue #27863
@@ -3235,7 +3308,7 @@ class MyElement(ET.Element):
 
 
 class ElementFindTest(unittest.TestCase):
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_find_simple(self):
         e = ET.XML(SAMPLE_XML)
         self.assertEqual(e.find('tag').tag, 'tag')
@@ -3259,7 +3332,7 @@ def test_find_simple(self):
         # Issue #16922
         self.assertEqual(ET.XML('<tag><empty /></tag>').findtext('empty'), '')
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_find_xpath(self):
         LINEAR_XML = '''
         <body>
@@ -3282,7 +3355,7 @@ def test_find_xpath(self):
         self.assertRaisesRegex(SyntaxError, 'XPath', e.find, './tag[last()-0]')
         self.assertRaisesRegex(SyntaxError, 'XPath', e.find, './tag[last()+1]')
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_findall(self):
         e = ET.XML(SAMPLE_XML)
         e[2] = ET.XML(SAMPLE_SECTION)
@@ -3471,7 +3544,7 @@ def test_bad_find(self):
         with self.assertRaisesRegex(SyntaxError, 'cannot use absolute path'):
             e.findall('/tag')
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_find_through_ElementTree(self):
         e = ET.XML(SAMPLE_XML)
         self.assertEqual(ET.ElementTree(e).find('tag').tag, 'tag')
@@ -3674,7 +3747,7 @@ class TreeBuilderSubclass(ET.TreeBuilder):
         a = parser.close()
         self.assertEqual(a.text, "texttail")
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_late_tail_mix_pi_comments(self):
         # Issue #37399: The tail of an ignored comment could overwrite the text before it.
         # Test appending tails to comments/pis.
@@ -3787,7 +3860,7 @@ class MyElement(base, ValueError):
             pass
         self._check_element_factory_class(MyElement)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_doctype(self):
         class DoctypeParser:
             _doctype = None
@@ -3865,7 +3938,7 @@ def test_doctype_warning(self):
             parser.feed(self.sample2)
             parser.close()
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_subclass_doctype(self):
         _doctype = None
         class MyParserWithDoctype(ET.XMLParser):
@@ -3907,7 +3980,7 @@ class MyParserWithoutDoctype(ET.XMLParser):
             parser.feed(self.sample2)
             parser.close()
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_parse_string(self):
         parser = ET.XMLParser(target=ET.TreeBuilder())
         parser.feed(self.sample3)
@@ -4094,7 +4167,6 @@ def f():
             e[:1] = (f() for i in range(2))
 
 class IOTest(unittest.TestCase):
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_encoding(self):
         # Test encoding issues.
         elem = ET.Element("tag")
@@ -4366,13 +4438,13 @@ def _get_error(self, s):
         except ET.ParseError as e:
             return e
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_error_position(self):
         self.assertEqual(self._get_error('foo').position, (1, 0))
         self.assertEqual(self._get_error('<tag>&foo;</tag>').position, (1, 5))
         self.assertEqual(self._get_error('foobar<').position, (1, 6))
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_error_code(self):
         import xml.parsers.expat.errors as ERRORS
         self.assertEqual(self._get_error('foo').code,
@@ -4432,7 +4504,7 @@ def test_correct_import_pyET(self):
 # --------------------------------------------------------------------
 
 class BoolTest(unittest.TestCase):
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_warning(self):
         e = ET.fromstring('<a style="new"></a>')
         msg = (
@@ -4462,7 +4534,7 @@ class C14NTest(unittest.TestCase):
     #
     # simple roundtrip tests (from c14n.py)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_simple_roundtrip(self):
         # Basics
         self.assertEqual(c14n_roundtrip("<doc/>"), '<doc></doc>')
@@ -4503,7 +4575,7 @@ def test_simple_roundtrip(self):
         xml = '<X xmlns="http://nps/a"><Y xmlns:b="http://nsp/b" b:targets="abc,xyz"></Y></X>'
         self.assertEqual(c14n_roundtrip(xml), xml)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_c14n_exclusion(self):
         xml = textwrap.dedent("""\
         <root xmlns:x="http://example.com/x">
@@ -4584,7 +4656,7 @@ def test_c14n_exclusion(self):
     # note that this uses generated C14N versions of the standard ET.write
     # output, not roundtripped C14N (see above).
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_xml_c14n2(self):
         datadir = findfile("c14n-20", subdir="xmltestdata")
         full_path = partial(os.path.join, datadir)
diff --git a/Lib/test/test_xml_etree_c.py b/Lib/test/test_xml_etree_c.py
index 3a0fc572f45..270b9d6da8e 100644
--- a/Lib/test/test_xml_etree_c.py
+++ b/Lib/test/test_xml_etree_c.py
@@ -57,6 +57,8 @@ def test_del_attribute(self):
             del element.attrib
         self.assertEqual(element.attrib, {'A': 'B', 'C': 'D'})
 
+    @support.skip_wasi_stack_overflow()
+    @support.skip_emscripten_stack_overflow()
     def test_trashcan(self):
         # If this test fails, it will most likely die via segfault.
         e = root = cET.Element('root')
diff --git a/Lib/test/test_xmlrpc.py b/Lib/test/test_xmlrpc.py
index 6b2e6c44ca4..bb2a1ef0904 100644
--- a/Lib/test/test_xmlrpc.py
+++ b/Lib/test/test_xmlrpc.py
@@ -187,7 +187,7 @@ def test_dump_none(self):
                           xmlrpclib.loads(strg)[0][0])
         self.assertRaises(TypeError, xmlrpclib.dumps, (arg1,))
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_dump_encoding(self):
         value = {'key\u20ac\xa4':
                  'value\u20ac\xa4'}
@@ -228,7 +228,7 @@ def test_dump_bytes(self):
             self.assertIs(type(newvalue), xmlrpclib.Binary)
             self.assertIsNone(m)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_loads_unsupported(self):
         ResponseError = xmlrpclib.ResponseError
         data = '<params><param><value><spam/></value></param></params>'
@@ -278,7 +278,7 @@ def test_load_standard_types(self):
               '<member><name>a</name><value><int>1</int></value></member>'
               '</struct>', {'a': 1, 'b': 2})
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_load_extension_types(self):
         check = self.check_loads
         check('<nil/>', None)
@@ -311,7 +311,7 @@ def test_get_host_info(self):
 
     def test_ssl_presence(self):
         try:
-            import ssl
+            import ssl  # noqa: F401
         except ImportError:
             has_ssl = False
         else:
@@ -832,7 +832,7 @@ def test_nonascii(self):
                 # protocol error; provide additional information in test output
                 self.fail("%s\n%s" % (e, getattr(e, "headers", "")))
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_client_encoding(self):
         start_string = '\u20ac'
         end_string = '\xa4'
@@ -1013,7 +1013,7 @@ class SimpleServerEncodingTestCase(BaseServerTestCase):
     def threadFunc(evt, numrequests, requestHandler=None, encoding=None):
         http_server(evt, numrequests, requestHandler, 'iso-8859-15')
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_server_encoding(self):
         start_string = '\u20ac'
         end_string = '\xa4'
diff --git a/Lib/test/test_yield_from.py b/Lib/test/test_yield_from.py
index 88fa1b88c90..7028a606217 100644
--- a/Lib/test/test_yield_from.py
+++ b/Lib/test/test_yield_from.py
@@ -538,7 +538,7 @@ def g():
             "finishing g",
         ])
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_broken_getattr_handling(self):
         """
         Test subiterator with a broken getattr implementation
@@ -786,7 +786,6 @@ def outer():
                 repr(value),
             ])
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_throwing_GeneratorExit_into_subgen_that_returns(self):
         """
         Test throwing GeneratorExit into a subgenerator that
@@ -817,7 +816,6 @@ def g():
             "Enter f",
         ])
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_throwing_GeneratorExit_into_subgenerator_that_yields(self):
         """
         Test throwing GeneratorExit into a subgenerator that
@@ -884,7 +882,7 @@ def g():
             yield from ()
         self.assertRaises(StopIteration, next, g())
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_delegating_generators_claim_to_be_running(self):
         # Check with basic iteration
         def one():
@@ -911,7 +909,7 @@ def two():
             pass
         self.assertEqual(res, [0, 1, 2, 3])
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON; AssertionError: Lists differ: [0, 1, 2] != [0, 1, 2, 3]
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AssertionError: Lists differ: [0, 1, 2] != [0, 1, 2, 3]
     def test_delegating_generators_claim_to_be_running_with_throw(self):
         # Check with throw
         class MyErr(Exception):
@@ -1073,7 +1071,7 @@ def assert_generator_raised_stop_iteration(self):
     def assert_generator_ignored_generator_exit(self):
         return self.assertRaisesRegex(RuntimeError, r"^generator ignored GeneratorExit$")
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_close_and_throw_work(self):
 
         yielded_first = object()
@@ -1135,7 +1133,6 @@ def outer():
             self.assertIsNone(caught.exception.__context__)
             self.assert_stop_iteration(g)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON; AssertionError: GeneratorExit() is not GeneratorExit()
     def test_close_and_throw_raise_generator_exit(self):
 
         yielded_first = object()
@@ -1212,7 +1209,7 @@ def outer():
             self.assertIsNone(caught.exception.__context__.__context__)
             self.assert_stop_iteration(g)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON; AssertionError: RuntimeError not raised
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AssertionError: RuntimeError not raised
     def test_close_and_throw_raise_stop_iteration(self):
 
         yielded_first = object()
@@ -1452,7 +1449,7 @@ def outer():
             self.assertIsNone(caught.exception.__context__.__context__)
             self.assert_stop_iteration(g)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON; AssertionError: None is not StopIteration()
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AssertionError: None is not StopIteration()
     def test_close_and_throw_yield(self):
 
         yielded_first = object()
@@ -1524,7 +1521,6 @@ def outer():
             self.assertIsNone(caught.exception.__context__)
             self.assert_stop_iteration(g)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_close_and_throw_return(self):
 
         yielded_first = object()
@@ -1535,8 +1531,9 @@ def inner():
             try:
                 yield yielded_first
                 yield yielded_second
-            finally:
-                return returned
+            except:
+                pass
+            return returned
 
         def outer():
             return (yield from inner())
@@ -1591,6 +1588,19 @@ def outer():
             self.assertIsNone(caught.exception.__context__)
             self.assert_stop_iteration(g)
 
+    def test_throws_in_iter(self):
+        # See GH-126366: NULL pointer dereference if __iter__
+        # threw an exception.
+        class Silly:
+            def __iter__(self):
+                raise RuntimeError("nobody expects the spanish inquisition")
+
+        def my_generator():
+            yield from Silly()
+
+        with self.assertRaisesRegex(RuntimeError, "nobody expects the spanish inquisition"):
+            next(iter(my_generator()))
+
 
 if __name__ == '__main__':
     unittest.main()
diff --git a/Lib/test/test_zipapp.py b/Lib/test/test_zipapp.py
index ad132839622..8fb0a68deba 100644
--- a/Lib/test/test_zipapp.py
+++ b/Lib/test/test_zipapp.py
@@ -113,6 +113,19 @@ def test_target_overwrites_source_file(self):
         with self.assertRaises(zipapp.ZipAppError):
             zipapp.create_archive(source, target)
 
+    def test_target_overwrites_filtered_source_file(self):
+        # If there's a filter that excludes the target,
+        # the overwrite check shouldn't trigger.
+        source = self.tmpdir
+        (source / '__main__.py').touch()
+        target = source / 'target.pyz'
+        target.touch()
+        pyz_filter = lambda p: not p.match('*.pyz')
+        zipapp.create_archive(source, target, filter=pyz_filter)
+        with zipfile.ZipFile(target, 'r') as z:
+            self.assertEqual(len(z.namelist()), 1)
+            self.assertIn('__main__.py', z.namelist())
+
     def test_create_archive_filter_exclude_dir(self):
         # Test packing a directory and using a filter to exclude a
         # subdirectory (ensures that the path supplied to include
@@ -246,7 +259,7 @@ def test_pack_to_fileobj(self):
         (source / '__main__.py').touch()
         target = io.BytesIO()
         zipapp.create_archive(str(source), target, interpreter='python')
-        self.assertTrue(target.getvalue().startswith(b'#!python\n'))
+        self.assertStartsWith(target.getvalue(), b'#!python\n')
 
     def test_read_shebang(self):
         # Test that we can read the shebang line correctly.
@@ -287,7 +300,7 @@ def test_write_shebang_to_fileobj(self):
         zipapp.create_archive(str(source), str(target), interpreter='python')
         new_target = io.BytesIO()
         zipapp.create_archive(str(target), new_target, interpreter='python2.7')
-        self.assertTrue(new_target.getvalue().startswith(b'#!python2.7\n'))
+        self.assertStartsWith(new_target.getvalue(), b'#!python2.7\n')
 
     def test_read_from_pathlike_obj(self):
         # Test that we can copy an archive using a path-like object
@@ -313,7 +326,7 @@ def test_read_from_fileobj(self):
         new_target = io.BytesIO()
         temp_archive.seek(0)
         zipapp.create_archive(temp_archive, new_target, interpreter='python2.7')
-        self.assertTrue(new_target.getvalue().startswith(b'#!python2.7\n'))
+        self.assertStartsWith(new_target.getvalue(), b'#!python2.7\n')
 
     def test_remove_shebang(self):
         # Test that we can remove the shebang from a file.
diff --git a/Lib/test/test_zipfile/_path/test_path.py b/Lib/test/test_zipfile/_path/test_path.py
index 5c69c77f7d8..f34251bc93c 100644
--- a/Lib/test/test_zipfile/_path/test_path.py
+++ b/Lib/test/test_zipfile/_path/test_path.py
@@ -567,7 +567,6 @@ 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')
     @parameterize(
         ['alpharep', 'path_type', 'subpath'],
         itertools.product(
diff --git a/Lib/test/test_zoneinfo/data/update_test_data.py b/Lib/test/test_zoneinfo/data/update_test_data.py
index e69de29bb2d..f531ab316a1 100644
--- a/Lib/test/test_zoneinfo/data/update_test_data.py
+++ b/Lib/test/test_zoneinfo/data/update_test_data.py
@@ -0,0 +1,122 @@
+"""
+Script to automatically generate a JSON file containing time zone information.
+
+This is done to allow "pinning" a small subset of the tzdata in the tests,
+since we are testing properties of a file that may be subject to change. For
+example, the behavior in the far future of any given zone is likely to change,
+but "does this give the right answer for this file in 2040" is still an
+important property to test.
+
+This must be run from a computer with zoneinfo data installed.
+"""
+from __future__ import annotations
+
+import base64
+import functools
+import json
+import lzma
+import pathlib
+import textwrap
+import typing
+
+import zoneinfo
+
+KEYS = [
+    "Africa/Abidjan",
+    "Africa/Casablanca",
+    "America/Los_Angeles",
+    "America/Santiago",
+    "Asia/Tokyo",
+    "Australia/Sydney",
+    "Europe/Dublin",
+    "Europe/Lisbon",
+    "Europe/London",
+    "Pacific/Kiritimati",
+    "UTC",
+]
+
+TEST_DATA_LOC = pathlib.Path(__file__).parent
+
+
+@functools.lru_cache(maxsize=None)
+def get_zoneinfo_path() -> pathlib.Path:
+    """Get the first zoneinfo directory on TZPATH containing the "UTC" zone."""
+    key = "UTC"
+    for path in map(pathlib.Path, zoneinfo.TZPATH):
+        if (path / key).exists():
+            return path
+    else:
+        raise OSError("Cannot find time zone data.")
+
+
+def get_zoneinfo_metadata() -> typing.Dict[str, str]:
+    path = get_zoneinfo_path()
+
+    tzdata_zi = path / "tzdata.zi"
+    if not tzdata_zi.exists():
+        # tzdata.zi is necessary to get the version information
+        raise OSError("Time zone data does not include tzdata.zi.")
+
+    with open(tzdata_zi, "r") as f:
+        version_line = next(f)
+
+    _, version = version_line.strip().rsplit(" ", 1)
+
+    if (
+        not version[0:4].isdigit()
+        or len(version) < 5
+        or not version[4:].isalpha()
+    ):
+        raise ValueError(
+            "Version string should be YYYYx, "
+            + "where YYYY is the year and x is a letter; "
+            + f"found: {version}"
+        )
+
+    return {"version": version}
+
+
+def get_zoneinfo(key: str) -> bytes:
+    path = get_zoneinfo_path()
+
+    with open(path / key, "rb") as f:
+        return f.read()
+
+
+def encode_compressed(data: bytes) -> typing.List[str]:
+    compressed_zone = lzma.compress(data)
+    raw = base64.b85encode(compressed_zone)
+
+    raw_data_str = raw.decode("utf-8")
+
+    data_str = textwrap.wrap(raw_data_str, width=70)
+    return data_str
+
+
+def load_compressed_keys() -> typing.Dict[str, typing.List[str]]:
+    output = {key: encode_compressed(get_zoneinfo(key)) for key in KEYS}
+
+    return output
+
+
+def update_test_data(fname: str = "zoneinfo_data.json") -> None:
+    TEST_DATA_LOC.mkdir(exist_ok=True, parents=True)
+
+    # Annotation required: https://github.com/python/mypy/issues/8772
+    json_kwargs: typing.Dict[str, typing.Any] = dict(
+        indent=2, sort_keys=True,
+    )
+
+    compressed_keys = load_compressed_keys()
+    metadata = get_zoneinfo_metadata()
+    output = {
+        "metadata": metadata,
+        "data": compressed_keys,
+    }
+
+    with open(TEST_DATA_LOC / fname, "w") as f:
+        json.dump(output, f, **json_kwargs)
+
+
+if __name__ == "__main__":
+    update_test_data()
diff --git a/Lib/test/test_zoneinfo/data/zoneinfo_data.json b/Lib/test/test_zoneinfo/data/zoneinfo_data.json
index 48e70ac6d38..ec4414a0cde 100644
--- a/Lib/test/test_zoneinfo/data/zoneinfo_data.json
+++ b/Lib/test/test_zoneinfo/data/zoneinfo_data.json
@@ -1,190 +1,190 @@
 {
-    "data": {
-      "Africa/Abidjan": [
-        "{Wp48S^xk9=GL@E0stWa761SMbT8$j-~f{VGF<>F7KxBg5R*{Ksocg8-YYVul=v7vZzaHN",
-        "uC=da5UI2rH18c!OnjV{y4u(+A!!VBKmY&$ORw>7UO^(500B;v0RR91bXh%WvBYQl0ssI2",
-        "00dcD"
-      ],
-      "Africa/Casablanca": [
-        "{Wp48S^xk9=GL@E0stWa761SMbT8$j;0b&Kz+C_;7KxBg5R*{N&yjMUR~;C-fDaSOU;q-~",
-        "FqW+4{YBjbcw}`a!dW>b)R2-0a+uwf`P3{_Y@HuCz}S$J$ZJ>R_V<~|Fk>sgX4=%0vUrh-",
-        "lt@YP^Wrus;j?`Th#xRPzf<<~Hp4DH^gZX>d{+WOp~HNu8!{uWu}&XphAd{j1;rB4|9?R!",
-        "pqruAFUMt8#*WcrVS{;kLlY(cJRV$w?d2car%R<ALOSO?^`4;ZZtI)%f^^G^>s>q9BgTU4",
-        "Ht-tQKZ7Z`9QqOb?R#b%z?rk>!CkH7jy3wja4NG2q)H}fNRKg8v{);Em;K3Cncf4C6&Oaj",
-        "V+DbX%o4+)CV3+e!Lm6dutu(0BQpH1T?W(~cQtKV*^_Pdx!LirjpTs?Bmt@vktjLq4;)O!",
-        "rrly=c*rwTwMJFd0I57`hgkc?=nyI4RZf9W$6DCWugmf&)wk^tWH17owj=#PGH7Xv-?9$j",
-        "njwDlkOE+BFNR9YXEmBpO;rqEw=e2IR-8^(W;8ma?M3JVd($2T>IW+0tk|Gm8>ftukRQ9J",
-        "8k3brzqMnVyjsLI-CKneFa)Lxvp_a<CkQEd#(pMA^rr}rBNElGA=*!M)puBdoErR9{kWL@",
-        "w=svMc6eZ^-(vQZrV<u^PY#nOIUDJ8%A&;BUVlY9=;@i2j2J1_`P>q40f}0J3VVoWL5rox",
-        "`Kptivcp}o5xA^@>qNI%?zo=Yj4AMV?kbAA)j(1%)+Pp)bSn+7Yk`M{oE}L-Z!G6<Dgq&*",
-        "(C-mFJfbEGDH5M^vBr65rcnsx*~|Em_GeU#B)(+T!|MG-nxj0@IPbp-nHejH3~>OMr5G+h",
-        "p)$3Lg{ono{4cN>Vr&>L4kXH;_VnBL5U!LgzqE%P7QQ*<E!guRW2SE@ayq@)G2nXqA2tGo",
-        "QIgc6>tue}O`3(TZ0`aKn&~8trOQ-rBXCp)f@P6RMO4l0+;b|5-pk9_ryNh}Zc*v%mvz_#",
-        "yd<xXt%~gT90dn4e{Ac<baL-)Y{L7&5G($I$>6fjB0g9{MmMnu8bG%#C~ugXK^S^k@?ab#",
-        "O|aE>dDTt4s4n69(~@t~!wniV%g<uWQat_i6>7khFx~I*4>Y|V$4j5%KPF*-FyKIi@!Ho&",
-        "x8QQsksYt8)D+W)Ni!=G`ogSu^vLL-l#7A7=iIAKL2SuZk9F}NfNk86VI)9WZE?%2wC-ya",
-        "F~z#Qsq)LH0|_D8^5fU8X%GeQ4TB>R-dlziA&tZe&1ada208!$nk`7bOFO2S00G<w{Sp8G",
-        "{cR_IvBYQl0ssI200dcD"
-      ],
-      "America/Los_Angeles": [
-        "{Wp48S^xk9=GL@E0stWa761SMbT8$j;0qH3OkDsf7KxBg5R*;z{h&-RlhRYu$%jt%!jv+I",
-        "JxhE=%W1?wYb!37Rb?(rgwFIAQI{L#8r*zy!$TMtER_1(vn(Zix^{AVB1(jwr$iL6h0Z!2",
-        "8Gb~UW@0~e512{Z%8}Qzdnjl~wJ1{c2>`Z@1A~t&lyL{p{eM{5)QGf7Mo5FW9==mlyXJt2",
-        "UwpntR7H0eSq!(aYq#aqUz&RM*tvuMI)AsM?K3-dV3-TT{t)!Iy#JTo=tXkzAM9~j2YbiO",
-        "ls3(H8Dc>Y|D1aqL51vjLbpYG;GvGTQB4bXuJ%mA;(B4eUpu$$@zv2vVcq-Y)VKbzp^tei",
-        "uzy}R{Luv<C;_cPe*n$Z<jeC9ogWF9=1mvvUYXS>DjpuVb`79O+CBmg{Wx!bvx$eu4zRE&",
-        "PehMb=&G<9$>iZ|bFE)0=4I?KLFGBC0I(0_svgw0%FiMsT%koo*!nEYc6GY@QnU}&4Isg;",
-        "l=|khi(!VaiSE2=Ny`&&tpi~~;{$u<GHlsr3Ze!iYsU205RFKsLnrXwOL?Mq08xffgS{6h",
-        "E|figx+&N%wbO}re@|}$l;g_6J-Wl%j|qev8A<T?NJ)`;2neGi_DHE4ET*W!c*ggPAgU+L",
-        "E9=bH7;maCUikw^R)UM;TdVvNkQ;FGgN=yQER`SZ1nOgPXr0LCebLety&}kVdmVmB=8eSg",
-        "td!1%p=a2wooIL!Da}OPXvKBfRo?YxqS>N}%f|7mBhAy;<Er2&_LfND#qXN~Mkgf!@4VFA",
-        "Hr%$c)wrKA2cJYWK2>s3YT^sy!$eG~?`9mNJC9@4Bac_p^BZh)Yd_rWW5qh-?tKY(>5VHO",
-        "L*iT8P@wCavLj^yYbnDR+4ukhS+xPrpl)iqB?u)bj9a2aW==g6G3lCJd>(+Blf<d4CF%7u",
-        "tlBUDki}J-!_Dy}5S(MrxSXy~$Z+hgH3P^<<w7D72L7I-R%H3(xm&q_DXxkp$owLTS6Wzk",
-        "hc3nn;laROa3)6hl&gH#)2Lif8fZe$@CdeJ-Zn&*>r)~^40F4f>cRZ^UF;RibfZ>0m73hR",
-        "C{$vTfC(STN`g7(B<=Z2556{}0`?p&|Akkst!4Xy4OT;A@c$XTUI3FRRjy*KA7uC56FD)z",
-        "^X{WV*sr(w!c$W357o!&eLO2wTDNOyw@gf(&R<<LF_3URI4=Ei`-%dM3T66j#9!aG7&b_@",
-        "g1-9vo?DzXZ5vGaf~w__p_@_X?OdvQ_r5bvy2hpESTf+{p?jL+!~!{g8-<-5$@d8EZV&-5",
-        "@a|;^1gB*R-~{EHFA-td_G2bt;~Y}>t;=-Tu1TV{>%8ZVATC9tjD8|(&`$9YHvZ9bVe#>w",
-        "|8c;Tg|xE&)`*}LwM*E}q}q8^Qja%p`_U)*5DdLI9O@!e=3jFjOCrCq28b_bb;s>%D#iJB",
-        "CWJi{JH!Js;6nfayos$kq^OEX00HO-lokL0!mqm{vBYQl0ssI200dcD"
-      ],
-      "America/Santiago": [
-        "{Wp48S^xk9=GL@E0stWa761SMbT8$j;0fRZ<6QtM7KxBg84(fsEAUJ$J{f-TXlPEUec5Ee",
-        "n+hsD4lC(QYax=JdSpoyje8%VM`GW}<Unz6IOY4=y66tfqG2X4E8xIJQ(~?r{`L~T!sI~o",
-        "VBl7Ao!R1A76Y8P6Y<TfwVHf@sl@S-D4OuAy5mq0MKJZ>{bJ8@y$A8O&*$pw{(f~Os#}2w",
-        "eX6^Rgi$IT%n^V^85L>$_c7{cB^#ogV=rHBJGiz-RQNFGK?gdPi|q)j`&8)}KJ{qo6dixa",
-        "9@yYyVg+%lo0nO+Tw0-w2hJ%mafy<Co(;L+24CYl&?rN0mrh90nxG?%1&Ed@za`Yd>WL)|",
-        ")<o0dZL-*?RFtH7dAv%G*O%l?qvq!0F5C?K#_ZoT{P$77IMoj3&8w3f&n36zquu~s`s0T)",
-        ";>?W6Bi%FWuGPA1Dru$XR4SZANsAthU2EoKH<MU4wYvUTlZGcLIDR+hSik>F6oEtKq`rwP",
-        "(VNegnI_NI%;ma$)wj{k!@KFB30Yo)IOr<QX7IQ@TBq9d;e3QAtYU?$PS-WoaiqwFrg4PR",
-        "A->l>)$)D|+(5h&+%2vuwGuy^@S8FT^s21V5};>VA9Iu;?8bHz#r<;JtfZDI1(FT@edh0#",
-        "MYW$A1qkMGIwTZqqdYNE3gl#zp&NbL9Mp=voqN|;?gqR&4$)1`znddtEyuKS*^nMMD=0^>",
-        "7^z6-C4P67UWOXuMBubP>j6i~03aR@jD^-Y`JSYu#Yp0P8dLLJ0QOPE8=BoiuRX59YW7xg",
-        "WiexjHX%&0?`ZQCdxCdL^qd1v@kOjQKaWo2Y1++~LcA%FTq?5o<?(jL(_Uo}I}k_Fwflcr",
-        "aovwSR_(ILA6li<iBLPQ0#rEet;W-*54kj#sZEGK*tAF{)HNkn#&Hc5`#eaRF;N#$<xQU?",
-        "E%zm?2+b5Ho>%}fX1-RIvlB)1#iTNomGnUL=nM!>Ix|AGtON7!F1O?53kqlC2o-`ZGw*+s",
-        "NM$^9znsIJMwlgscE`|O3|;BRgsQMYm~`uv+nvuv`nigRa}X=BX=A5Sw$)WEklF7&c>_~$",
-        "zJ(m--bqXgiN^w-U=BJH9C0Qro(x90zo@rK;&TJ$nI@&k$ORgOb2<MjjIhYfr;pFUGdMd!",
-        "0d&bOvyq3AZPCez8E(XSg2hBu2A&^k?w|1u8v3JE>s%gWbc}ok_27)Eoku~Fq|B-Ps+4J_",
-        "HPJMLJ2^_)cOU$p&3kNAlrV!)%~6r$BJ>OOi~=-<6byle{?zd4J{NG}o8tw|+#ZNLcpNwk",
-        "TuPE~sbJB8_RZb2DopStO+Wwux~F#S59zm%00I98;S&G=b(j+6vBYQl0ssI200dcD"
-      ],
-      "Asia/Tokyo": [
-        "{Wp48S^xk9=GL@E0stWa761SMbT8$j-~luMgIxeB7KxBg5R*;y?l4Rl4neXH3cv!OtfK@h",
-        "KZzauI)S!FSDREPhhBS6Fb$&Vv#7%;?Te|>pF^0HBr&z_Tk<%vMW_QqjevRZOp8XVFgP<8",
-        "TkT#`9H&0Ua;gT1#rZLV0HqbAKK;_z@nO;6t0L<i8TZ+%T<;ci2bYSG1u!mUSO5S3XcbN8",
-        "dIxbZ00Ex?wE_SDJu@vkvBYQl0ssI200dcD"
-      ],
-      "Australia/Sydney": [
-        "{Wp48S^xk9=GL@E0stWa761SMbT8$j;0T)o7+nA=7KxBg5R*_t6jS5T`_Ull(nK1_YY;k%",
-        ";_YdTuU3*!K)eKg@^kzjAtbo@Jd|KGai=Q%%sX5FI?*?LG!|m9cKH5~IEwI=PAr_Yc}w35",
-        ">}hOdk<>TdUa07R(LPI6@!GU$ty4=mwqHG-XVe*n(Yvgdlr+FqIU18!osi)48t~eWX8)&L",
-        "G)Ud^0zz@*AF+2r7E}N<P$kOfo*88g)_bOO?7N1Jr|HJyg+HXc7f4}?%Dur3w|~JU?<x4K",
-        "%RRC~q_D87;UyN{nLRu!fEqKeRR*U$vs>f9Y72K~o-T%}D&z%}#7g<qim`EbfhF7ntyAiP",
-        "%LFNc&!$@Kv)Olyf&Y9%(#SkM+%yI}S%b+@ZM2dH7DpmndGMIda<(`#E9q|?H(HzClx+l;",
-        "M?IEz1eF}r?}ay!V9?9rKD^-ayjE@wUMD$2kC!iwH`n=eVrJPmJyNKaW`LdJ68&u;2nF1K",
-        "kZjKCY_A<>2br?oH6ZiYH^%>J3D)TPKV(JY*bwjuw5=DsPB@~CrR<E_U_fJTF9ufU%!cXK",
-        "_4uM#!%%Q1e1G~{E}~vGVE0{Kxecm^NjtJM`c8EFHFTiUIVl@YUD8F+s!u8jz~6hte@oa|",
-        "qayb*^Lwd(etNmBro;aXQjkY8g(*`_JQ0%{V3QP2l!GGQ7D+v&k_PK0F(?f{GziU5>OZeN",
-        "x>A*H&CHrWt0`EP`m!F%waepl#|w#&`XgVc?~2M3uw$fGX~tf_Il!q#Aa<*8xlzQ2+7r6Z",
-        "^;Laa9F(WB_O&Dy2r>~@kSi16W{=6+i5GV=Uq~KX*~&HUN4oz7*O(gXIr}sDVcD`Ikgw#|",
-        "50ssal8s)Qy;?YGCf;*UKKKN!T4!Kqy_G;7<gSrPK{)5#a>PfQapugqvVBKy12v3TVH^L2",
-        "0?#5*VP~MOYfe$h`*L!7@tiW|_^X1N%<}`7YahiUYtMu5XwmOf3?dr+@zXHwW`z}ZDqZlT",
-        "<2Cs(<1%M!i6o&VK89BY0J7HPIo;O62s=|IbV^@y$N&#<x=a876<(U>=>i^F00FcHoDl#3",
-        "Mdv&xvBYQl0ssI200dcD"
-      ],
-      "Europe/Dublin": [
-        "{Wp48S^xk9=GL@E0stWa761SMbT8$j;0>b$_+0=h7KxBg5R*;&J77#T_U2R5sleVWFDmK~",
-        "Kzj5oh@`<njquRZ&tJIS(cXp1>QKHvW^6V{jU-w>qg1tSt0c^vh;?qAqA0%t?;#S~6U8Qi",
-        "v&f1s9IH#g$m1k1a#3+lylw4mwT4QnEUUQdwg+xnEcBlgu31bAVabn41OMZVLGz6NDwG%X",
-        "uQar!b>GI{qSahE`AG}$kRWbuI~JCt;38)Xwbb~Qggs55t+MAHIxgDxzTJ;2xXx99+qCy4",
-        "45kC#v_l8fx|G&jlVvaciR<-wwf22l%4(t@S6tnX39#_K(4S0fu$FUs$isu<UOJYm|4)2i",
-        "aEpsajn@}B#rnY=Cg_TXsm-A)*adXV&$klNTn3n{XXlaquu}6m{k%oRmY0Yyhlj*<W{D5m",
-        "22}OiqnwHT!tnK`wPqx?wiF%v{ipTrOkcJ5P@7OC4(-l`*&SB$Wd4Vf8gn?>d<i@%mP*e*",
-        "ttDj`9M1;9$YV@dhT)DVcwdq(Ly~KDm_&KL?{_mFwwYtJqRZBk)i1FVQy!40w_KyAg?hIA",
-        "=_{(3#S0eWsF8f%_4Zza$4@$lSmov+Huyn$vP^zJ|8-<C3#q#0kEs9cNg^xUR(m?wEWt-D",
-        "GctAh2nIo~fz%$m$I41=b_WuJ6M9g#A9_Epwqw{d0B|vzmg#_y<=_>9IKzCXB<o`d)**5V",
-        "6g!<<Jw1n5TrN-$)aYz4cLsTmpsUf-6L7ix+kk>78NkARYq@9Dc0TGkhz);NtM_SSzEffN",
-        "l{2^*CKGdp52h!52A)6q9fUSltXF{T*Ehc9Q7u8!W7pE(Fv$D$cKUAt6wY=DA1mGgxC*VX",
-        "q_If3G#FY6-Voj`fIKk`0}Cc72_SD{v>468LV{pyBI33^p0E?}RwDA6Pkq--C~0jF&Z@Pv",
-        "!dx_1SN_)jwz@P$(oK%P!Tk9?fRjK88yxhxlcFtTjjZ$DYssSsa#ufYrR+}}nKS+r384o~",
-        "!Uw$nwTbF~qgRsgr0N#d@KIinx%<pnyQ!|>hQB(SJyjJtDtIy(%mDm}ZBGN}dV6K~om|=U",
-        "VGkbciQ=^$_14|gT21!YQ)@y*Rd0i_lS6gtPBE9+ah%WIJPwzUTjIr+J1XckkmA!6WE16%",
-        "CVAl{Dn&-)=G$Bjh?bh0$Xt1UDcgXJjXzzojuw0>paV~?Sa`VN3FysqF<S*L0RYSAY3jt(",
-        "8wCD04RfyEcP(RNT%x7k(7m-9H3{zuQ`RZy-Rz%*&dldDVFF+TwSAPO1wRX^5W5@xJ9{vW",
-        "w?rc^NH({%Ie<rxKqSVy!Le-_`U&@W_(D+>xTzfKVAu*ucq#+m=|KSSMvp_#@-lwd+q*ue",
-        "FQ^5<D+|jLr?k{O39i8AX2Qb^zi9A<7XD1y!-W2|0Hk8JVkN;gl><|<0R-u4qYMbRqzSn&",
-        "Q7jSuvc%b+EZc%>nI(+&0Tl1Y>a6v4`uNFD-7$QrhHgS7Wnv~rDgfH;rQw3+m`LJxoM4v#",
-        "gK@?|B{RHJ*VxZgk#!p<_&-sjxOda0YaiJ1UnG41VPv(Et%ElzKRMcO$AfgU+Xnwg5p2_+",
-        "NrnZ1WfEj^fmHd^sx@%JWKkh#zaK0ox%rdP)zUmGZZnqmZ_9L=%6R8ibJH0bOT$AGhDo6{",
-        "fJ?;_U;D|^>5by2ul@i4Zf()InfFN}00EQ=q#FPL>RM>svBYQl0ssI200dcD"
-      ],
-      "Europe/Lisbon": [
-        "{Wp48S^xk9=GL@E0stWa761SMbT8$j;0=rf*IfWA7KxBg5R*;*X|PN+G3LqthM?xgkNUN_",
-        ")gCt1Sc%YT6^TTomk4yVHXeyvQj8}l<;q&s7K}#Vnc8lII1?)AHh$*>OKUU4S;*h>v*ep0",
-        "xTi1cK2{aY*|2D*-~K<;-{_W+r@NvZ7-|NZv($ek_C%VfP0xjWeZP#CPXD`IKkakjh(kUd",
-        "&H)m;^Q(jGjIyiyrcUMtOP)u3A>sw6ux;Bmp3x$4QvQKMx5TrCx_!$srWQuXNs&`9=^IY1",
-        "yc&C31!sQh7P=Mk*#6x8Z@5^%ehR8UW<EvzdWer9z;R6PrdUaWab3G>$OWw0KMw}P1ycI^",
-        "4eh12oBUOV?S>n*d!+EM@>x#9PZD12iD=zaC;7`8dTfkU_6d}OZvSFSbGgXeKw}XyX@D=(",
-        ")D0!^DBGr8pXWBT$S-yhLP>Z3ys^VW<kSQr?{jhl<+{Fki;mTI=&Stgy$rttN?ulQM$lDr",
-        "G7))C7Dx=J6V-e^(Qk|r;f~TvIw1KqRIC{8f^jPy#blstV{-&2a}ZJe!Zr2c_R4NT)L@bs",
-        "+gRRm6Wn)VWVNHeK*TEV=f#2KZqu%y?mTx#EfRiK0)TG7$$~=LGxx@0D|lS2up|oCON{YQ",
-        "oN5-H$!_n-Kx2*=RO!epEX>3}RQ6{NGGVJG6vf*MH93vvNW6yLjie1;{4tVhg-KnSf|G`!",
-        "Z;j$7gJ1ows~RD=@n7I6aFd8rOR_7Y?E-$clI%1o5gA@O!KPa^(8^iFFeFykI-+z>E$mvp",
-        "E_h`vbHPjqkLs`Dn-0FV`R@z|h!S(Lb;M&|Exr<u8#s-T(>!biY`%bfp$6`hK;GDhdP|^Q",
-        "*Ty*}1d41K>H2B{jrjE9aFK>yAQJBX9CD%-384S;0fw`PlprHGS`^b$oS-`I4VH7ji8ou-",
-        "g|060jfb1XcxiInT0oO<S+<vh^)XY;lr@|IeXj}%k;}|kSlDGaYidk^zB|gEYaet~F%QYd",
-        "f7pbnQKLZ0o7=kso86doS;J@aQ>oeR7#%e5Ug5#KW)nV<Rc;|LjUDdhk8*dYJQwYN?hzH%",
-        "0<XB$!(rpf2nxaL22M`L4pKx>SRvLHNe$SQHM@2)`S9L7>RL@<XAlxVQfb2=%lcu!h+Um0",
-        "Q+Z=itevTFy}-Jl<g5crK55BF`VsoPH~qP3QrG%YtrD#s{=gA7p)QI<i=EwY(cel8`B=#u",
-        "Yq<K;4T(QBF_GvrYueSk*}gfrCSg22+YH-1N<WYkp|DA-P-&va<Xu<}^yafJKlzezB-lS{",
-        "a++P_^gYmgrc9FO-K3s~`jAcqVV!k?NV2IFV^86`cr>Qx%fmm7?3u7P5TywFQ}C@S(pq}|",
-        "eLPT{C^{<0Q?uU&kSVd%!~8q3;Z0s3OqzF`$HRkePL5Ywgiwn{R(<RY8ut&RJ;$?J*w*n)",
-        ">zi+jmOBFrVpW;)@UsU#%$8BcV#h@}m$#!Fglo&bwb78aYqOG_W7h{eb(+39&-mk4EIXq_",
-        "_`30=8sfA3=!3TO_TyS5X22~?6nKngZ|bq=grdq=9X)3xAkA42L!~rmS)n3w-~;lgz%Fhn",
-        "(?rXdp2ho~9?wmVs2JwVt~?@FVD%`tN69{(i3oQa;O0<Hp#T5?$WIy3h`IlL00Hv}jT-;}",
-        "Z2tpNvBYQl0ssI200dcD"
-      ],
-      "Europe/London": [
-        "{Wp48S^xk9=GL@E0stWa761SMbT8$j;0`|pJ6!-O7KxBg5R*;$9DqzW!kQs3DZt(=0_!m1",
-        "4wvE`6N%Vj#u6PS_3S?~(2)&xn8}2}3Wr#kG8n2!x8>$E$lF&~Y#_H6bu6(BiwblJ>;-Fs",
-        "gA$Y$*?=X)n1pFkKn}F~`>=4)+LLQk?L*P!bhAm0;`N~z3QbUIyVrm%kOZ(n1JJsm0pyb8",
-        "!GV{d*C!9KXv;4v<seWRpo=ZZxGf)-5Qsn$3dw`uhF)+6#mgUoNF-Y2jN73pVhdTs*p0`Z",
-        "AbnT1puEtudB{Nul>D4Q>-k#+x(!V5L@w5M>v2V5<gcLskF+p`aGTSn{sY8^@MUc;2o{&V",
-        "R!$180N}BtfYKS)i9w=!<~&l?1Cv^PWs!&a9{s(35^yqGU$72DKX|IkRtDblB>a`B>t(|B",
-        "|Fqr4^-{S*%Ep~ojUtx_CRbSQ(uFwu2=KH)Q@EBs@ZqRXn4mU;B!68;;IQs3Ub=n&UU%*m",
-        "k&zwD36&JSwsN(%k&x?H+tN^6)23c`I0=5^N_R0~1>tsFZ`^`3z~rXSXT&qcwa#n!%+Z#P",
-        "PG}(D^_CCILXnF|GKwabBh*xFS?4rwGo2vtJUwzrbv_$5PO+`?$l{H-jGB@X%S!OAhw;D4",
-        "XFycN3!XqQ&EorJOD3>~^U%Luw!jF<;6_q-f-S|6<EHry?%{@fuyH`_+D%uTA@g0$5e!Yi",
-        "P1vQuevyS;jE(-R>{cQDfZ2(4Xf1MMLr1=SA=MwVf2%Pp%VP;jn)|5Tf!-DbUGn%I-r<KG",
-        "4jJ(Y#L-fJUpUb$yNfvhX*iqWZoG7T*WUfE6iQD9_^EWqExH`rc&jJ<o^E8-mM10WrZ_Vv",
-        "xx9nj<vMlEt*KfP*pyth!c_AKnrKtQTACX08#{pioAFnDq!53+h*hO^f*yrWjg0u2pUcgv",
-        "UlpEZ9G_dlhlW1J^h@gTt7{KPL2mRal;1juJ3Q8-!GXO#IPzT4ciJ-nB+nkphssM}Q7IAT",
-        "pM}AT%y(J!78F?>kYaH7?$$O!t)wwClAisr3eUoeB^~T=U*_P~Y2*KdnO87>B!19sV=xZ5",
-        "yApq26RxgqA|*tmsvtL#OhcF(C<0EGWHP)BF<g*iSWicU6k1<Ps?BQ$IWg-#s2uF-qXgJ_",
-        "!H_mZIMx*L%&a*_6;_trMCULk0ZYM<hfJlYBddHwRyYUDu3!C_lJZWTQ?c-R&@9054pj0k",
-        "kQ{Xi{A$&)&b#^G*}8w^qE5i<@aDxaJQs2E$W)AIqUXO{gQ;U8|FA%BD~sORzq44)AntUu",
-        "QHBO{{Pi<EpK!$x4(~7w)la!dN=M@L_j};6|5G&QfuO~2?Q7996z)78fqW<D#8tKNV(*qc",
-        "mfA>l?h)_*7!{LoJiv%RsOs!q->n+DcV%9~B@Rb<ISu%16c5H-7zQIq+SuS+s<lQOWK5+C",
-        "d*>C_1G_1g6`Yd~8|%-=2l~oGN!~TVv2Bnk>7wW8L@^?vX$f3AiT)(4nrCuTm9%(XC6Nai",
-        "E(;}7&=YZagjAN$O-cN;1u{dTkElmB0GT$|Wa)QMmKrx<|LCJ9qlUoFsUbD^H^6_8(w<0{",
-        "ftj&O1~p_%lh5z;zNV&sP<T$*OgK)_0B#JDtXOkhC;Bo7h)#RUy;vBiVLN-T$*7t*t9@ey",
-        "3Woa&24QZ_z38BQ@A(A<(9n@%R?}B`7%w2wowt~UU;bAlqCzr(H$M5t==jGIqMqCsE=Jwa",
-        "$3P+3^&|~i28@=d_u6Cgthe(Lq(wxKpdSDL|7X6Un<nrt00Gwuz#ISo`BbmvvBYQl0ssI2",
-        "00dcD"
-      ],
-      "Pacific/Kiritimati": [
-        "{Wp48S^xk9=GL@E0stWa761SMbT8$j-~jCaVO;<!7KxBg5R*{K!`A|q%C5j6({{dSEy5>+",
-        "NF2>iK{8KMUf+)<-)VxXbLxD(alL}N$AT-ogNbJSMMYeX+Z{jS)b8TK^PB=FxyBxzfmFto",
-        "eo0R`a(%NO?#aEH9|?Cv00000NIsFh6BW2800DjO0RR918Pu^`vBYQl0ssI200dcD"
-      ],
-      "UTC": [
-        "{Wp48S^xk9=GL@E0stWa761SMbT8$j-~e#|9bEt_7KxBg5R*|3h1|xhHLji!C57qW6L*|H",
-        "pEErm00000ygu;I+>V)?00B92fhY-(AGY&-0RR9100dcD"
-      ]
-    },
-    "metadata": {
-      "version": "2020a"
-    }
-  }
\ No newline at end of file
+  "data": {
+    "Africa/Abidjan": [
+      "{Wp48S^xk9=GL@E0stWa761SMbT8$j-~f{VGF<>F7KxBg5R*{Ksocg8-YYVul=v7vZzaHN",
+      "uC=da5UI2rH18c!OnjV{y4u(+A!!VBKmY&$ORw>7UO^(500B;v0RR91bXh%WvBYQl0ssI2",
+      "00dcD"
+    ],
+    "Africa/Casablanca": [
+      "{Wp48S^xk9=GL@E0stWa761SMbT8$j;0b&Kz+C_;7KxBg5R*{N&yjMUR~;C-fDaSOU;q-~",
+      "FqW+4{YBjbcw}`a!dW>b)R2-0a+uwf`P3{_Y@HuCz}S$J$ZJ>R_V<~|Fk>sgX4=%0vUrh-",
+      "lt@YP^Wrus;j?`Th#xRPzf<<~Hp4DH^gZX>d{+WOp~HNu8!{uWu}&XphAd{j1;rB4|9?R!",
+      "pqruAFUMt8#*WcrVS{;kLlY(cJRV$w?d2car%R<ALOSO?^`4;ZZtI)%f^^G^>s>q9BgTU4",
+      "Ht-tQKZ7Z`9QqOb?R#b%z?rk>!CkH7jy3wja4NG2q)H}fNRKg8v{);Em;K3Cncf4C6&Oaj",
+      "V+DbX%o4+)CV3+e!Lm6dutu(0BQpH1T?W(~cQtKV*^_Pdx!LirjpTs?Bmt@vktjLq4;)O!",
+      "rrly=c*rwTwMJFd0I57`hgkc?=nyI4RZf9W$6DCWugmf&)wk^tWH17owj=#PGH7Xv-?9$j",
+      "njwDlkOE+BFNR9YXEmBpO;rqEw=e2IR-8^(W;8ma?M3JVd($2T>IW+0tk|Gm8>ftukRQ9J",
+      "8k3brzqMnVyjsLI-CKneFa)Lxvp_a<CkQEd#(pMA^rr}rBNElGA=*!M)puBdoErR9{kWL@",
+      "w=svMc6eZ^-(vQZrV<u^PY#nOIUDJ8%A&;BUVlY9=;@i2j2J1_`P>q40f}0J3VVoWL5rox",
+      "`Kptivcp}o5xA^@>qNI%?zo=Yj4AMV?kbAA)j(1%)+Pp)bSn+7Yk`M{oE}L-Z!G6<Dgq&*",
+      "(C-mFJfbEGDH5M^vBr65rcnsx*~|Em_GeU#B)(+T!|MG-nxj0@IPbp-nHejH3~>OMr5G+h",
+      "p)$3Lg{ono{4cN>Vr&>L4kXH;_VnBL5U!LgzqE%P7QQ*<E!guRW2SE@ayq@)G2nXqA2tGo",
+      "QIgc6>tue}O`3(TZ0`aKn&~8trOQ-rBXCp)f@P6RMO4l0+;b|5-pk9_ryNh}Zc*v%mvz_#",
+      "yd<xXt%~gT90dn4e{Ac<baL-)Y{L7&5G($I$>6fjB0g9{MmMnu8bG%#C~ugXK^S^k@?ab#",
+      "O|aE>dDTt4s4n69(~@t~!wniV%g<uWQat_i6>7khFx~I*4>Y|V$4j5%KPF*-FyKIi@!Ho&",
+      "x8QQsksYt8)D+W)Ni!=G`ogSu^vLL-l#7A7=iIAKL2SuZk9F}NfNk86VI)9WZE?%2wC-ya",
+      "F~z#Qsq)LH0|_D8^5fU8X%GeQ4TB>R-dlziA&tZe&1ada208!$nk`7bOFO2S00G<w{Sp8G",
+      "{cR_IvBYQl0ssI200dcD"
+    ],
+    "America/Los_Angeles": [
+      "{Wp48S^xk9=GL@E0stWa761SMbT8$j;0qH3OkDsf7KxBg5R*;z{h&-RlhRYu$%jt%!jv+I",
+      "JxhE=%W1?wYb!37Rb?(rgwFIAQI{L#8r*zy!$TMtER_1(vn(Zix^{AVB1(jwr$iL6h0Z!2",
+      "8Gb~UW@0~e512{Z%8}Qzdnjl~wJ1{c2>`Z@1A~t&lyL{p{eM{5)QGf7Mo5FW9==mlyXJt2",
+      "UwpntR7H0eSq!(aYq#aqUz&RM*tvuMI)AsM?K3-dV3-TT{t)!Iy#JTo=tXkzAM9~j2YbiO",
+      "ls3(H8Dc>Y|D1aqL51vjLbpYG;GvGTQB4bXuJ%mA;(B4eUpu$$@zv2vVcq-Y)VKbzp^tei",
+      "uzy}R{Luv<C;_cPe*n$Z<jeC9ogWF9=1mvvUYXS>DjpuVb`79O+CBmg{Wx!bvx$eu4zRE&",
+      "PehMb=&G<9$>iZ|bFE)0=4I?KLFGBC0I(0_svgw0%FiMsT%koo*!nEYc6GY@QnU}&4Isg;",
+      "l=|khi(!VaiSE2=Ny`&&tpi~~;{$u<GHlsr3Ze!iYsU205RFKsLnrXwOL?Mq08xffgS{6h",
+      "E|figx+&N%wbO}re@|}$l;g_6J-Wl%j|qev8A<T?NJ)`;2neGi_DHE4ET*W!c*ggPAgU+L",
+      "E9=bH7;maCUikw^R)UM;TdVvNkQ;FGgN=yQER`SZ1nOgPXr0LCebLety&}kVdmVmB=8eSg",
+      "td!1%p=a2wooIL!Da}OPXvKBfRo?YxqS>N}%f|7mBhAy;<Er2&_LfND#qXN~Mkgf!@4VFA",
+      "Hr%$c)wrKA2cJYWK2>s3YT^sy!$eG~?`9mNJC9@4Bac_p^BZh)Yd_rWW5qh-?tKY(>5VHO",
+      "L*iT8P@wCavLj^yYbnDR+4ukhS+xPrpl)iqB?u)bj9a2aW==g6G3lCJd>(+Blf<d4CF%7u",
+      "tlBUDki}J-!_Dy}5S(MrxSXy~$Z+hgH3P^<<w7D72L7I-R%H3(xm&q_DXxkp$owLTS6Wzk",
+      "hc3nn;laROa3)6hl&gH#)2Lif8fZe$@CdeJ-Zn&*>r)~^40F4f>cRZ^UF;RibfZ>0m73hR",
+      "C{$vTfC(STN`g7(B<=Z2556{}0`?p&|Akkst!4Xy4OT;A@c$XTUI3FRRjy*KA7uC56FD)z",
+      "^X{WV*sr(w!c$W357o!&eLO2wTDNOyw@gf(&R<<LF_3URI4=Ei`-%dM3T66j#9!aG7&b_@",
+      "g1-9vo?DzXZ5vGaf~w__p_@_X?OdvQ_r5bvy2hpESTf+{p?jL+!~!{g8-<-5$@d8EZV&-5",
+      "@a|;^1gB*R-~{EHFA-td_G2bt;~Y}>t;=-Tu1TV{>%8ZVATC9tjD8|(&`$9YHvZ9bVe#>w",
+      "|8c;Tg|xE&)`*}LwM*E}q}q8^Qja%p`_U)*5DdLI9O@!e=3jFjOCrCq28b_bb;s>%D#iJB",
+      "CWJi{JH!Js;6nfayos$kq^OEX00HO-lokL0!mqm{vBYQl0ssI200dcD"
+    ],
+    "America/Santiago": [
+      "{Wp48S^xk9=GL@E0stWa761SMbT8$j;0fRZ<6QtM7KxBg84(fsEAUJ$J{f-TXlPEUec5Ee",
+      "n+hsD4lC(QYax=JdSpoyje8%VM`GW}<Unz6IOY4=y66tfqG2X4E8xIJQ(~?r{`L~T!sI~o",
+      "VBl7Ao!R1A76Y8P6Y<TfwVHf@sl@S-D4OuAy5mq0MKJZ>{bJ8@y$A8O&*$pw{(f~Os#}2w",
+      "eX6^Rgi$IT%n^V^85L>$_c7{cB^#ogV=rHBJGiz-RQNFGK?gdPi|q)j`&8)}KJ{qo6dixa",
+      "9@yYyVg+%lo0nO+Tw0-w2hJ%mafy<Co(;L+24CYl&?rN0mrh90nxG?%1&Ed@za`Yd>WL)|",
+      ")<o0dZL-*?RFtH7dAv%G*O%l?qvq!0F5C?K#_ZoT{P$77IMoj3&8w3f&n36zquu~s`s0T)",
+      ";>?W6Bi%FWuGPA1Dru$XR4SZANsAthU2EoKH<MU4wYvUTlZGcLIDR+hSik>F6oEtKq`rwP",
+      "(VNegnI_NI%;ma$)wj{k!@KFB30Yo)IOr<QX7IQ@TBq9d;e3QAtYU?$PS-WoaiqwFrg4PR",
+      "A->l>)$)D|+(5h&+%2vuwGuy^@S8FT^s21V5};>VA9Iu;?8bHz#r<;JtfZDI1(FT@edh0#",
+      "MYW$A1qkMGIwTZqqdYNE3gl#zp&NbL9Mp=voqN|;?gqR&4$)1`znddtEyuKS*^nMMD=0^>",
+      "7^z6-C4P67UWOXuMBubP>j6i~03aR@jD^-Y`JSYu#Yp0P8dLLJ0QOPE8=BoiuRX59YW7xg",
+      "WiexjHX%&0?`ZQCdxCdL^qd1v@kOjQKaWo2Y1++~LcA%FTq?5o<?(jL(_Uo}I}k_Fwflcr",
+      "aovwSR_(ILA6li<iBLPQ0#rEet;W-*54kj#sZEGK*tAF{)HNkn#&Hc5`#eaRF;N#$<xQU?",
+      "E%zm?2+b5Ho>%}fX1-RIvlB)1#iTNomGnUL=nM!>Ix|AGtON7!F1O?53kqlC2o-`ZGw*+s",
+      "NM$^9znsIJMwlgscE`|O3|;BRgsQMYm~`uv+nvuv`nigRa}X=BX=A5Sw$)WEklF7&c>_~$",
+      "zJ(m--bqXgiN^w-U=BJH9C0Qro(x90zo@rK;&TJ$nI@&k$ORgOb2<MjjIhYfr;pFUGdMd!",
+      "0d&bOvyq3AZPCez8E(XSg2hBu2A&^k?w|1u8v3JE>s%gWbc}ok_27)Eoku~Fq|B-Ps+4J_",
+      "HPJMLJ2^_)cOU$p&3kNAlrV!)%~6r$BJ>OOi~=-<6byle{?zd4J{NG}o8tw|+#ZNLcpNwk",
+      "TuPE~sbJB8_RZb2DopStO+Wwux~F#S59zm%00I98;S&G=b(j+6vBYQl0ssI200dcD"
+    ],
+    "Asia/Tokyo": [
+      "{Wp48S^xk9=GL@E0stWa761SMbT8$j-~luMgIxeB7KxBg5R*;y?l4Rl4neXH3cv!OtfK@h",
+      "KZzauI)S!FSDREPhhBS6Fb$&Vv#7%;?Te|>pF^0HBr&z_Tk<%vMW_QqjevRZOp8XVFgP<8",
+      "TkT#`9H&0Ua;gT1#rZLV0HqbAKK;_z@nO;6t0L<i8TZ+%T<;ci2bYSG1u!mUSO5S3XcbN8",
+      "dIxbZ00Ex?wE_SDJu@vkvBYQl0ssI200dcD"
+    ],
+    "Australia/Sydney": [
+      "{Wp48S^xk9=GL@E0stWa761SMbT8$j;0T)o7+nA=7KxBg5R*_t6jS5T`_Ull(nK1_YY;k%",
+      ";_YdTuU3*!K)eKg@^kzjAtbo@Jd|KGai=Q%%sX5FI?*?LG!|m9cKH5~IEwI=PAr_Yc}w35",
+      ">}hOdk<>TdUa07R(LPI6@!GU$ty4=mwqHG-XVe*n(Yvgdlr+FqIU18!osi)48t~eWX8)&L",
+      "G)Ud^0zz@*AF+2r7E}N<P$kOfo*88g)_bOO?7N1Jr|HJyg+HXc7f4}?%Dur3w|~JU?<x4K",
+      "%RRC~q_D87;UyN{nLRu!fEqKeRR*U$vs>f9Y72K~o-T%}D&z%}#7g<qim`EbfhF7ntyAiP",
+      "%LFNc&!$@Kv)Olyf&Y9%(#SkM+%yI}S%b+@ZM2dH7DpmndGMIda<(`#E9q|?H(HzClx+l;",
+      "M?IEz1eF}r?}ay!V9?9rKD^-ayjE@wUMD$2kC!iwH`n=eVrJPmJyNKaW`LdJ68&u;2nF1K",
+      "kZjKCY_A<>2br?oH6ZiYH^%>J3D)TPKV(JY*bwjuw5=DsPB@~CrR<E_U_fJTF9ufU%!cXK",
+      "_4uM#!%%Q1e1G~{E}~vGVE0{Kxecm^NjtJM`c8EFHFTiUIVl@YUD8F+s!u8jz~6hte@oa|",
+      "qayb*^Lwd(etNmBro;aXQjkY8g(*`_JQ0%{V3QP2l!GGQ7D+v&k_PK0F(?f{GziU5>OZeN",
+      "x>A*H&CHrWt0`EP`m!F%waepl#|w#&`XgVc?~2M3uw$fGX~tf_Il!q#Aa<*8xlzQ2+7r6Z",
+      "^;Laa9F(WB_O&Dy2r>~@kSi16W{=6+i5GV=Uq~KX*~&HUN4oz7*O(gXIr}sDVcD`Ikgw#|",
+      "50ssal8s)Qy;?YGCf;*UKKKN!T4!Kqy_G;7<gSrPK{)5#a>PfQapugqvVBKy12v3TVH^L2",
+      "0?#5*VP~MOYfe$h`*L!7@tiW|_^X1N%<}`7YahiUYtMu5XwmOf3?dr+@zXHwW`z}ZDqZlT",
+      "<2Cs(<1%M!i6o&VK89BY0J7HPIo;O62s=|IbV^@y$N&#<x=a876<(U>=>i^F00FcHoDl#3",
+      "Mdv&xvBYQl0ssI200dcD"
+    ],
+    "Europe/Dublin": [
+      "{Wp48S^xk9=GL@E0stWa761SMbT8$j;0>b$_+0=h7KxBg5R*;&J77#T_U2R5sleVWFDmK~",
+      "Kzj5oh@`<njquRZ&tJIS(cXp1>QKHvW^6V{jU-w>qg1tSt0c^vh;?qAqA0%t?;#S~6U8Qi",
+      "v&f1s9IH#g$m1k1a#3+lylw4mwT4QnEUUQdwg+xnEcBlgu31bAVabn41OMZVLGz6NDwG%X",
+      "uQar!b>GI{qSahE`AG}$kRWbuI~JCt;38)Xwbb~Qggs55t+MAHIxgDxzTJ;2xXx99+qCy4",
+      "45kC#v_l8fx|G&jlVvaciR<-wwf22l%4(t@S6tnX39#_K(4S0fu$FUs$isu<UOJYm|4)2i",
+      "aEpsajn@}B#rnY=Cg_TXsm-A)*adXV&$klNTn3n{XXlaquu}6m{k%oRmY0Yyhlj*<W{D5m",
+      "22}OiqnwHT!tnK`wPqx?wiF%v{ipTrOkcJ5P@7OC4(-l`*&SB$Wd4Vf8gn?>d<i@%mP*e*",
+      "ttDj`9M1;9$YV@dhT)DVcwdq(Ly~KDm_&KL?{_mFwwYtJqRZBk)i1FVQy!40w_KyAg?hIA",
+      "=_{(3#S0eWsF8f%_4Zza$4@$lSmov+Huyn$vP^zJ|8-<C3#q#0kEs9cNg^xUR(m?wEWt-D",
+      "GctAh2nIo~fz%$m$I41=b_WuJ6M9g#A9_Epwqw{d0B|vzmg#_y<=_>9IKzCXB<o`d)**5V",
+      "6g!<<Jw1n5TrN-$)aYz4cLsTmpsUf-6L7ix+kk>78NkARYq@9Dc0TGkhz);NtM_SSzEffN",
+      "l{2^*CKGdp52h!52A)6q9fUSltXF{T*Ehc9Q7u8!W7pE(Fv$D$cKUAt6wY=DA1mGgxC*VX",
+      "q_If3G#FY6-Voj`fIKk`0}Cc72_SD{v>468LV{pyBI33^p0E?}RwDA6Pkq--C~0jF&Z@Pv",
+      "!dx_1SN_)jwz@P$(oK%P!Tk9?fRjK88yxhxlcFtTjjZ$DYssSsa#ufYrR+}}nKS+r384o~",
+      "!Uw$nwTbF~qgRsgr0N#d@KIinx%<pnyQ!|>hQB(SJyjJtDtIy(%mDm}ZBGN}dV6K~om|=U",
+      "VGkbciQ=^$_14|gT21!YQ)@y*Rd0i_lS6gtPBE9+ah%WIJPwzUTjIr+J1XckkmA!6WE16%",
+      "CVAl{Dn&-)=G$Bjh?bh0$Xt1UDcgXJjXzzojuw0>paV~?Sa`VN3FysqF<S*L0RYSAY3jt(",
+      "8wCD04RfyEcP(RNT%x7k(7m-9H3{zuQ`RZy-Rz%*&dldDVFF+TwSAPO1wRX^5W5@xJ9{vW",
+      "w?rc^NH({%Ie<rxKqSVy!Le-_`U&@W_(D+>xTzfKVAu*ucq#+m=|KSSMvp_#@-lwd+q*ue",
+      "FQ^5<D+|jLr?k{O39i8AX2Qb^zi9A<7XD1y!-W2|0Hk8JVkN;gl><|<0R-u4qYMbRqzSn&",
+      "Q7jSuvc%b+EZc%>nI(+&0Tl1Y>a6v4`uNFD-7$QrhHgS7Wnv~rDgfH;rQw3+m`LJxoM4v#",
+      "gK@?|B{RHJ*VxZgk#!p<_&-sjxOda0YaiJ1UnG41VPv(Et%ElzKRMcO$AfgU+Xnwg5p2_+",
+      "NrnZ1WfEj^fmHd^sx@%JWKkh#zaK0ox%rdP)zUmGZZnqmZ_9L=%6R8ibJH0bOT$AGhDo6{",
+      "fJ?;_U;D|^>5by2ul@i4Zf()InfFN}00EQ=q#FPL>RM>svBYQl0ssI200dcD"
+    ],
+    "Europe/Lisbon": [
+      "{Wp48S^xk9=GL@E0stWa761SMbT8$j;0=rf*IfWA7KxBg5R*;*X|PN+G3LqthM?xgkNUN_",
+      ")gCt1Sc%YT6^TTomk4yVHXeyvQj8}l<;q&s7K}#Vnc8lII1?)AHh$*>OKUU4S;*h>v*ep0",
+      "xTi1cK2{aY*|2D*-~K<;-{_W+r@NvZ7-|NZv($ek_C%VfP0xjWeZP#CPXD`IKkakjh(kUd",
+      "&H)m;^Q(jGjIyiyrcUMtOP)u3A>sw6ux;Bmp3x$4QvQKMx5TrCx_!$srWQuXNs&`9=^IY1",
+      "yc&C31!sQh7P=Mk*#6x8Z@5^%ehR8UW<EvzdWer9z;R6PrdUaWab3G>$OWw0KMw}P1ycI^",
+      "4eh12oBUOV?S>n*d!+EM@>x#9PZD12iD=zaC;7`8dTfkU_6d}OZvSFSbGgXeKw}XyX@D=(",
+      ")D0!^DBGr8pXWBT$S-yhLP>Z3ys^VW<kSQr?{jhl<+{Fki;mTI=&Stgy$rttN?ulQM$lDr",
+      "G7))C7Dx=J6V-e^(Qk|r;f~TvIw1KqRIC{8f^jPy#blstV{-&2a}ZJe!Zr2c_R4NT)L@bs",
+      "+gRRm6Wn)VWVNHeK*TEV=f#2KZqu%y?mTx#EfRiK0)TG7$$~=LGxx@0D|lS2up|oCON{YQ",
+      "oN5-H$!_n-Kx2*=RO!epEX>3}RQ6{NGGVJG6vf*MH93vvNW6yLjie1;{4tVhg-KnSf|G`!",
+      "Z;j$7gJ1ows~RD=@n7I6aFd8rOR_7Y?E-$clI%1o5gA@O!KPa^(8^iFFeFykI-+z>E$mvp",
+      "E_h`vbHPjqkLs`Dn-0FV`R@z|h!S(Lb;M&|Exr<u8#s-T(>!biY`%bfp$6`hK;GDhdP|^Q",
+      "*Ty*}1d41K>H2B{jrjE9aFK>yAQJBX9CD%-384S;0fw`PlprHGS`^b$oS-`I4VH7ji8ou-",
+      "g|060jfb1XcxiInT0oO<S+<vh^)XY;lr@|IeXj}%k;}|kSlDGaYidk^zB|gEYaet~F%QYd",
+      "f7pbnQKLZ0o7=kso86doS;J@aQ>oeR7#%e5Ug5#KW)nV<Rc;|LjUDdhk8*dYJQwYN?hzH%",
+      "0<XB$!(rpf2nxaL22M`L4pKx>SRvLHNe$SQHM@2)`S9L7>RL@<XAlxVQfb2=%lcu!h+Um0",
+      "Q+Z=itevTFy}-Jl<g5crK55BF`VsoPH~qP3QrG%YtrD#s{=gA7p)QI<i=EwY(cel8`B=#u",
+      "Yq<K;4T(QBF_GvrYueSk*}gfrCSg22+YH-1N<WYkp|DA-P-&va<Xu<}^yafJKlzezB-lS{",
+      "a++P_^gYmgrc9FO-K3s~`jAcqVV!k?NV2IFV^86`cr>Qx%fmm7?3u7P5TywFQ}C@S(pq}|",
+      "eLPT{C^{<0Q?uU&kSVd%!~8q3;Z0s3OqzF`$HRkePL5Ywgiwn{R(<RY8ut&RJ;$?J*w*n)",
+      ">zi+jmOBFrVpW;)@UsU#%$8BcV#h@}m$#!Fglo&bwb78aYqOG_W7h{eb(+39&-mk4EIXq_",
+      "_`30=8sfA3=!3TO_TyS5X22~?6nKngZ|bq=grdq=9X)3xAkA42L!~rmS)n3w-~;lgz%Fhn",
+      "(?rXdp2ho~9?wmVs2JwVt~?@FVD%`tN69{(i3oQa;O0<Hp#T5?$WIy3h`IlL00Hv}jT-;}",
+      "Z2tpNvBYQl0ssI200dcD"
+    ],
+    "Europe/London": [
+      "{Wp48S^xk9=GL@E0stWa761SMbT8$j;0`|pJ6!-O7KxBg5R*;$9DqzW!kQs3DZt(=0_!m1",
+      "4wvE`6N%Vj#u6PS_3S?~(2)&xn8}2}3Wr#kG8n2!x8>$E$lF&~Y#_H6bu6(BiwblJ>;-Fs",
+      "gA$Y$*?=X)n1pFkKn}F~`>=4)+LLQk?L*P!bhAm0;`N~z3QbUIyVrm%kOZ(n1JJsm0pyb8",
+      "!GV{d*C!9KXv;4v<seWRpo=ZZxGf)-5Qsn$3dw`uhF)+6#mgUoNF-Y2jN73pVhdTs*p0`Z",
+      "AbnT1puEtudB{Nul>D4Q>-k#+x(!V5L@w5M>v2V5<gcLskF+p`aGTSn{sY8^@MUc;2o{&V",
+      "R!$180N}BtfYKS)i9w=!<~&l?1Cv^PWs!&a9{s(35^yqGU$72DKX|IkRtDblB>a`B>t(|B",
+      "|Fqr4^-{S*%Ep~ojUtx_CRbSQ(uFwu2=KH)Q@EBs@ZqRXn4mU;B!68;;IQs3Ub=n&UU%*m",
+      "k&zwD36&JSwsN(%k&x?H+tN^6)23c`I0=5^N_R0~1>tsFZ`^`3z~rXSXT&qcwa#n!%+Z#P",
+      "PG}(D^_CCILXnF|GKwabBh*xFS?4rwGo2vtJUwzrbv_$5PO+`?$l{H-jGB@X%S!OAhw;D4",
+      "XFycN3!XqQ&EorJOD3>~^U%Luw!jF<;6_q-f-S|6<EHry?%{@fuyH`_+D%uTA@g0$5e!Yi",
+      "P1vQuevyS;jE(-R>{cQDfZ2(4Xf1MMLr1=SA=MwVf2%Pp%VP;jn)|5Tf!-DbUGn%I-r<KG",
+      "4jJ(Y#L-fJUpUb$yNfvhX*iqWZoG7T*WUfE6iQD9_^EWqExH`rc&jJ<o^E8-mM10WrZ_Vv",
+      "xx9nj<vMlEt*KfP*pyth!c_AKnrKtQTACX08#{pioAFnDq!53+h*hO^f*yrWjg0u2pUcgv",
+      "UlpEZ9G_dlhlW1J^h@gTt7{KPL2mRal;1juJ3Q8-!GXO#IPzT4ciJ-nB+nkphssM}Q7IAT",
+      "pM}AT%y(J!78F?>kYaH7?$$O!t)wwClAisr3eUoeB^~T=U*_P~Y2*KdnO87>B!19sV=xZ5",
+      "yApq26RxgqA|*tmsvtL#OhcF(C<0EGWHP)BF<g*iSWicU6k1<Ps?BQ$IWg-#s2uF-qXgJ_",
+      "!H_mZIMx*L%&a*_6;_trMCULk0ZYM<hfJlYBddHwRyYUDu3!C_lJZWTQ?c-R&@9054pj0k",
+      "kQ{Xi{A$&)&b#^G*}8w^qE5i<@aDxaJQs2E$W)AIqUXO{gQ;U8|FA%BD~sORzq44)AntUu",
+      "QHBO{{Pi<EpK!$x4(~7w)la!dN=M@L_j};6|5G&QfuO~2?Q7996z)78fqW<D#8tKNV(*qc",
+      "mfA>l?h)_*7!{LoJiv%RsOs!q->n+DcV%9~B@Rb<ISu%16c5H-7zQIq+SuS+s<lQOWK5+C",
+      "d*>C_1G_1g6`Yd~8|%-=2l~oGN!~TVv2Bnk>7wW8L@^?vX$f3AiT)(4nrCuTm9%(XC6Nai",
+      "E(;}7&=YZagjAN$O-cN;1u{dTkElmB0GT$|Wa)QMmKrx<|LCJ9qlUoFsUbD^H^6_8(w<0{",
+      "ftj&O1~p_%lh5z;zNV&sP<T$*OgK)_0B#JDtXOkhC;Bo7h)#RUy;vBiVLN-T$*7t*t9@ey",
+      "3Woa&24QZ_z38BQ@A(A<(9n@%R?}B`7%w2wowt~UU;bAlqCzr(H$M5t==jGIqMqCsE=Jwa",
+      "$3P+3^&|~i28@=d_u6Cgthe(Lq(wxKpdSDL|7X6Un<nrt00Gwuz#ISo`BbmvvBYQl0ssI2",
+      "00dcD"
+    ],
+    "Pacific/Kiritimati": [
+      "{Wp48S^xk9=GL@E0stWa761SMbT8$j-~jCaVO;<!7KxBg5R*{K!`A|q%C5j6({{dSEy5>+",
+      "NF2>iK{8KMUf+)<-)VxXbLxD(alL}N$AT-ogNbJSMMYeX+Z{jS)b8TK^PB=FxyBxzfmFto",
+      "eo0R`a(%NO?#aEH9|?Cv00000NIsFh6BW2800DjO0RR918Pu^`vBYQl0ssI200dcD"
+    ],
+    "UTC": [
+      "{Wp48S^xk9=GL@E0stWa761SMbT8$j-~e#|9bEt_7KxBg5R*|3h1|xhHLji!C57qW6L*|H",
+      "pEErm00000ygu;I+>V)?00B92fhY-(AGY&-0RR9100dcD"
+    ]
+  },
+  "metadata": {
+    "version": "2020a"
+  }
+}
\ No newline at end of file
diff --git a/Lib/test/test_zoneinfo/test_zoneinfo.py b/Lib/test/test_zoneinfo/test_zoneinfo.py
index e05bd046e83..85877c984c8 100644
--- a/Lib/test/test_zoneinfo/test_zoneinfo.py
+++ b/Lib/test/test_zoneinfo/test_zoneinfo.py
@@ -18,9 +18,11 @@
 from functools import cached_property
 
 from test.support import MISSING_C_DOCSTRINGS
+from test.support.os_helper import EnvironmentVarGuard, FakePath
 from test.test_zoneinfo import _support as test_support
-from test.test_zoneinfo._support import OS_ENV_LOCK, TZPATH_TEST_LOCK, ZoneInfoTestBase
+from test.test_zoneinfo._support import TZPATH_TEST_LOCK, ZoneInfoTestBase
 from test.support.import_helper import import_module, CleanImport
+from test.support.script_helper import assert_python_ok
 
 lzma = import_module('lzma')
 py_zoneinfo, c_zoneinfo = test_support.get_modules()
@@ -57,6 +59,10 @@ def tearDownModule():
     shutil.rmtree(TEMP_DIR)
 
 
+class CustomError(Exception):
+    pass
+
+
 class TzPathUserMixin:
     """
     Adds a setUp() and tearDown() to make TZPATH manipulations thread-safe.
@@ -222,6 +228,7 @@ def test_bad_keys(self):
             "America.Los_Angeles",
             "🇨🇦",  # Non-ascii
             "America/New\ud800York",  # Contains surrogate character
+            "Europe",  # Is a directory, see issue gh-85702
         ]
 
         for bad_key in bad_keys:
@@ -245,6 +252,8 @@ def test_bad_zones(self):
         bad_zones = [
             b"",  # Empty file
             b"AAAA3" + b" " * 15,  # Bad magic
+            # Truncated V2 file (should not loop indefinitely)
+            b"TZif2" + (b"\x00" * 39) + b"TZif2" + (b"\x00" * 39) + b"\n" + b"Part",
         ]
 
         for bad_zone in bad_zones:
@@ -402,6 +411,25 @@ def test_time_fixed_offset(self):
                 self.assertEqual(t.utcoffset(), offset.utcoffset)
                 self.assertEqual(t.dst(), offset.dst)
 
+    def test_cache_exception(self):
+        class Incomparable(str):
+            eq_called = False
+            def __eq__(self, other):
+                self.eq_called = True
+                raise CustomError
+            __hash__ = str.__hash__
+
+        key = "America/Los_Angeles"
+        tz1 = self.klass(key)
+        key = Incomparable(key)
+        try:
+            tz2 = self.klass(key)
+        except CustomError:
+            self.assertTrue(key.eq_called)
+        else:
+            self.assertFalse(key.eq_called)
+            self.assertIs(tz2, tz1)
+
 
 class CZoneInfoTest(ZoneInfoTest):
     module = c_zoneinfo
@@ -1505,6 +1533,46 @@ def test_clear_cache_two_keys(self):
         self.assertIsNot(dub0, dub1)
         self.assertIs(tok0, tok1)
 
+    def test_clear_cache_refleak(self):
+        class Stringy(str):
+            allow_comparisons = True
+            def __eq__(self, other):
+                if not self.allow_comparisons:
+                    raise CustomError
+                return super().__eq__(other)
+            __hash__ = str.__hash__
+
+        key = Stringy("America/Los_Angeles")
+        self.klass(key)
+        key.allow_comparisons = False
+        try:
+            # Note: This is try/except rather than assertRaises because
+            # there is no guarantee that the key is even still in the cache,
+            # or that the key for the cache is the original `key` object.
+            self.klass.clear_cache(only_keys="America/Los_Angeles")
+        except CustomError:
+            pass
+
+    def test_weak_cache_descriptor_use_after_free(self):
+        class BombDescriptor:
+            def __get__(self, obj, owner):
+                return {}
+
+        class EvilZoneInfo(self.klass):
+            pass
+
+        # Must be set after the class creation.
+        EvilZoneInfo._weak_cache = BombDescriptor()
+
+        key = "America/Los_Angeles"
+        zone1 = EvilZoneInfo(key)
+        self.assertEqual(str(zone1), key)
+
+        EvilZoneInfo.clear_cache()
+        zone2 = EvilZoneInfo(key)
+        self.assertEqual(str(zone2), key)
+        self.assertIsNot(zone2, zone1)
+
 
 class CZoneInfoCacheTest(ZoneInfoCacheTest):
     module = c_zoneinfo
@@ -1657,24 +1725,9 @@ class TzPathTest(TzPathUserMixin, ZoneInfoTestBase):
     @staticmethod
     @contextlib.contextmanager
     def python_tzpath_context(value):
-        path_var = "PYTHONTZPATH"
-        unset_env_sentinel = object()
-        old_env = unset_env_sentinel
-        try:
-            with OS_ENV_LOCK:
-                old_env = os.environ.get(path_var, None)
-                os.environ[path_var] = value
-                yield
-        finally:
-            if old_env is unset_env_sentinel:
-                # In this case, `old_env` was never retrieved from the
-                # environment for whatever reason, so there's no need to
-                # reset the environment TZPATH.
-                pass
-            elif old_env is None:
-                del os.environ[path_var]
-            else:
-                os.environ[path_var] = old_env  # pragma: nocover
+        with EnvironmentVarGuard() as env:
+            env["PYTHONTZPATH"] = value
+            yield
 
     def test_env_variable(self):
         """Tests that the environment variable works with reset_tzpath."""
@@ -1728,8 +1781,7 @@ def test_env_variable_relative_paths(self):
                 with self.subTest("filtered", path_var=path_var):
                     self.assertSequenceEqual(tzpath, expected_paths)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; + /home/runner/work/RustPython/RustPython/crates/pylib/Lib/test/test_zoneinfo/test_zoneinfo.py
     def test_env_variable_relative_paths_warning_location(self):
         path_var = "path/to/somewhere"
 
@@ -1755,6 +1807,7 @@ def test_reset_tzpath_relative_paths(self):
             ("/usr/share/zoneinfo", "../relative/path",),
             ("path/to/somewhere", "../relative/path",),
             ("/usr/share/zoneinfo", "path/to/somewhere", "../relative/path",),
+            (FakePath("path/to/somewhere"),)
         ]
         for input_paths in bad_values:
             with self.subTest(input_paths=input_paths):
@@ -1766,6 +1819,9 @@ def test_tzpath_type_error(self):
             "/etc/zoneinfo:/usr/share/zoneinfo",
             b"/etc/zoneinfo:/usr/share/zoneinfo",
             0,
+            (b"/bytes/path", "/valid/path"),
+            (FakePath(b"/bytes/path"),),
+            (0,),
         ]
 
         for bad_value in bad_values:
@@ -1776,6 +1832,7 @@ def test_tzpath_type_error(self):
     def test_tzpath_attribute(self):
         tzpath_0 = [f"{DRIVE}/one", f"{DRIVE}/two"]
         tzpath_1 = [f"{DRIVE}/three"]
+        tzpath_pathlike = (FakePath(f"{DRIVE}/usr/share/zoneinfo"),)
 
         with self.tzpath_context(tzpath_0):
             query_0 = self.module.TZPATH
@@ -1783,8 +1840,12 @@ def test_tzpath_attribute(self):
         with self.tzpath_context(tzpath_1):
             query_1 = self.module.TZPATH
 
+        with self.tzpath_context(tzpath_pathlike):
+            query_pathlike = self.module.TZPATH
+
         self.assertSequenceEqual(tzpath_0, query_0)
         self.assertSequenceEqual(tzpath_1, query_1)
+        self.assertSequenceEqual(tuple([os.fspath(p) for p in tzpath_pathlike]), query_pathlike)
 
 
 class CTzPathTest(TzPathTest):
@@ -1824,8 +1885,7 @@ def test_getattr_error(self):
         with self.assertRaises(AttributeError):
             self.module.NOATTRIBUTE
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; dir(self.module) should at least contain everything in __all__.
     def test_dir_contains_all(self):
         """dir(self.module) should at least contain everything in __all__."""
         module_all_set = set(self.module.__all__)
@@ -1920,6 +1980,26 @@ class CTestModule(TestModule):
     module = c_zoneinfo
 
 
+class MiscTests(unittest.TestCase):
+    def test_pydatetime(self):
+        # Test that zoneinfo works if the C implementation of datetime
+        # is not available and the Python implementation of datetime is used.
+        # The Python implementation of zoneinfo should be used in thet case.
+        #
+        # Run the test in a subprocess, as importing _zoneinfo with
+        # _datettime disabled causes crash in the previously imported
+        # _zoneinfo.
+        assert_python_ok('-c', '''if 1:
+            import sys
+            sys.modules['_datetime'] = None
+            import datetime
+            import zoneinfo
+            tzinfo = zoneinfo.ZoneInfo('Europe/London')
+            datetime.datetime(2025, 10, 26, 2, 0, tzinfo=tzinfo)
+            ''',
+            PYTHONTZPATH=str(ZONEINFO_DATA.tzpath))
+
+
 class ExtensionBuiltTest(unittest.TestCase):
     """Smoke test to ensure that the C and Python extensions are both tested.
 
@@ -1929,16 +2009,13 @@ class ExtensionBuiltTest(unittest.TestCase):
     rely on these tests as an indication of stable properties of these classes.
     """
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AssertionError: type object 'ZoneInfo' has unexpected attribute '_weak_cache'
     def test_cache_location(self):
         # The pure Python version stores caches on attributes, but the C
         # extension stores them in C globals (at least for now)
-        self.assertFalse(hasattr(c_zoneinfo.ZoneInfo, "_weak_cache"))
-        self.assertTrue(hasattr(py_zoneinfo.ZoneInfo, "_weak_cache"))
+        self.assertNotHasAttr(c_zoneinfo.ZoneInfo, "_weak_cache")
+        self.assertHasAttr(py_zoneinfo.ZoneInfo, "_weak_cache")
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_gc_tracked(self):
         import gc
 
diff --git a/Lib/test/test_zoneinfo/test_zoneinfo_property.py b/Lib/test/test_zoneinfo/test_zoneinfo_property.py
index feaa77f3e7f..c00815e2fd4 100644
--- a/Lib/test/test_zoneinfo/test_zoneinfo_property.py
+++ b/Lib/test/test_zoneinfo/test_zoneinfo_property.py
@@ -146,20 +146,22 @@ def setUp(self):
     @add_key_examples
     def test_pickle_unpickle_cache(self, key):
         zi = self.klass(key)
-        pkl_str = pickle.dumps(zi)
-        zi_rt = pickle.loads(pkl_str)
+        for proto in range(pickle.HIGHEST_PROTOCOL + 1):
+            pkl_str = pickle.dumps(zi, proto)
+            zi_rt = pickle.loads(pkl_str)
 
-        self.assertIs(zi, zi_rt)
+            self.assertIs(zi, zi_rt)
 
     @hypothesis.given(key=valid_keys())
     @add_key_examples
     def test_pickle_unpickle_no_cache(self, key):
         zi = self.klass.no_cache(key)
-        pkl_str = pickle.dumps(zi)
-        zi_rt = pickle.loads(pkl_str)
+        for proto in range(pickle.HIGHEST_PROTOCOL + 1):
+            pkl_str = pickle.dumps(zi, proto)
+            zi_rt = pickle.loads(pkl_str)
 
-        self.assertIsNot(zi, zi_rt)
-        self.assertEqual(str(zi), str(zi_rt))
+            self.assertIsNot(zi, zi_rt)
+            self.assertEqual(str(zi), str(zi_rt))
 
     @hypothesis.given(key=valid_keys())
     @add_key_examples
diff --git a/Lib/test/tokenizedata/__init__.py b/Lib/test/tokenizedata/__init__.py
new file mode 100644
index 00000000000..e69de29bb2d
diff --git a/Lib/test/tokenizedata/bad_coding.py b/Lib/test/tokenizedata/bad_coding.py
new file mode 100644
index 00000000000..971b0a8f3d6
--- /dev/null
+++ b/Lib/test/tokenizedata/bad_coding.py
@@ -0,0 +1 @@
+# -*- coding: uft-8 -*-
diff --git a/Lib/test/tokenizedata/bad_coding2.py b/Lib/test/tokenizedata/bad_coding2.py
new file mode 100644
index 00000000000..bb2bb7e1e75
--- /dev/null
+++ b/Lib/test/tokenizedata/bad_coding2.py
@@ -0,0 +1,2 @@
+#coding: utf8
+print('我')
diff --git a/Lib/test/tokenizedata/badsyntax_3131.py b/Lib/test/tokenizedata/badsyntax_3131.py
new file mode 100644
index 00000000000..901d3744ca0
--- /dev/null
+++ b/Lib/test/tokenizedata/badsyntax_3131.py
@@ -0,0 +1,2 @@
+# -*- coding: utf-8 -*-
+€ = 2
diff --git a/Lib/test/tokenizedata/badsyntax_pep3120.py b/Lib/test/tokenizedata/badsyntax_pep3120.py
new file mode 100644
index 00000000000..d14b4c96ede
--- /dev/null
+++ b/Lib/test/tokenizedata/badsyntax_pep3120.py
@@ -0,0 +1 @@
+print("b�se")
diff --git a/Lib/test/tokenizedata/coding20731.py b/Lib/test/tokenizedata/coding20731.py
new file mode 100644
index 00000000000..b0e227ad110
--- /dev/null
+++ b/Lib/test/tokenizedata/coding20731.py
@@ -0,0 +1,4 @@
+#coding:latin1
+
+
+
diff --git a/Lib/test/tokenizedata/tokenize_tests-latin1-coding-cookie-and-utf8-bom-sig.txt b/Lib/test/tokenizedata/tokenize_tests-latin1-coding-cookie-and-utf8-bom-sig.txt
new file mode 100644
index 00000000000..1b5335b64ed
--- /dev/null
+++ b/Lib/test/tokenizedata/tokenize_tests-latin1-coding-cookie-and-utf8-bom-sig.txt
@@ -0,0 +1,13 @@
+# -*- coding: latin1 -*-
+# IMPORTANT: this file has the utf-8 BOM signature '\xef\xbb\xbf'
+# at the start of it.  Make sure this is preserved if any changes
+# are made!  Also note that the coding cookie above conflicts with
+# the presence of a utf-8 BOM signature -- this is intended.
+
+# Arbitrary encoded utf-8 text (stolen from test_doctest2.py).
+x = 'ЉЊЈЁЂ'
+def y():
+    """
+    And again in a comment.  ЉЊЈЁЂ
+    """
+    pass
diff --git a/Lib/test/tokenizedata/tokenize_tests-no-coding-cookie-and-utf8-bom-sig-only.txt b/Lib/test/tokenizedata/tokenize_tests-no-coding-cookie-and-utf8-bom-sig-only.txt
new file mode 100644
index 00000000000..23fd2168ae5
--- /dev/null
+++ b/Lib/test/tokenizedata/tokenize_tests-no-coding-cookie-and-utf8-bom-sig-only.txt
@@ -0,0 +1,11 @@
+# IMPORTANT: this file has the utf-8 BOM signature '\xef\xbb\xbf'
+# at the start of it.  Make sure this is preserved if any changes
+# are made!
+
+# Arbitrary encoded utf-8 text (stolen from test_doctest2.py).
+x = 'ЉЊЈЁЂ'
+def y():
+    """
+    And again in a comment.  ЉЊЈЁЂ
+    """
+    pass
diff --git a/Lib/test/tokenizedata/tokenize_tests-utf8-coding-cookie-and-no-utf8-bom-sig.txt b/Lib/test/tokenizedata/tokenize_tests-utf8-coding-cookie-and-no-utf8-bom-sig.txt
new file mode 100644
index 00000000000..04561e48472
--- /dev/null
+++ b/Lib/test/tokenizedata/tokenize_tests-utf8-coding-cookie-and-no-utf8-bom-sig.txt
@@ -0,0 +1,13 @@
+# -*- coding: utf-8 -*-
+# IMPORTANT: unlike the other test_tokenize-*.txt files, this file
+# does NOT have the utf-8 BOM signature '\xef\xbb\xbf' at the start
+# of it.  Make sure this is not added inadvertently by your editor
+# if any changes are made to this file!
+
+# Arbitrary encoded utf-8 text (stolen from test_doctest2.py).
+x = 'ЉЊЈЁЂ'
+def y():
+    """
+    And again in a comment.  ЉЊЈЁЂ
+    """
+    pass
diff --git a/Lib/test/tokenizedata/tokenize_tests-utf8-coding-cookie-and-utf8-bom-sig.txt b/Lib/test/tokenizedata/tokenize_tests-utf8-coding-cookie-and-utf8-bom-sig.txt
new file mode 100644
index 00000000000..4b20ff6ad6d
--- /dev/null
+++ b/Lib/test/tokenizedata/tokenize_tests-utf8-coding-cookie-and-utf8-bom-sig.txt
@@ -0,0 +1,12 @@
+# -*- coding: utf-8 -*-
+# IMPORTANT: this file has the utf-8 BOM signature '\xef\xbb\xbf'
+# at the start of it.  Make sure this is preserved if any changes
+# are made!
+
+# Arbitrary encoded utf-8 text (stolen from test_doctest2.py).
+x = 'ЉЊЈЁЂ'
+def y():
+    """
+    And again in a comment.  ЉЊЈЁЂ
+    """
+    pass
diff --git a/Lib/test/tokenizedata/tokenize_tests.txt b/Lib/test/tokenizedata/tokenize_tests.txt
new file mode 100644
index 00000000000..c4f5a58a946
--- /dev/null
+++ b/Lib/test/tokenizedata/tokenize_tests.txt
@@ -0,0 +1,189 @@
+# Tests for the 'tokenize' module.
+# Large bits stolen from test_grammar.py.
+
+# Comments
+"#"
+#'
+#"
+#\
+       #
+    # abc
+'''#
+#'''
+
+x = 1  #
+
+# Balancing continuation
+
+a = (3, 4,
+  5, 6)
+y = [3, 4,
+  5]
+z = {'a':5,
+  'b':6}
+x = (len(repr(y)) + 5*x - a[
+   3 ]
+   - x + len({
+   }
+    )
+  )
+
+# Backslash means line continuation:
+x = 1 \
++ 1
+
+# Backslash does not means continuation in comments :\
+x = 0
+
+# Ordinary integers
+0xff != 255
+0o377 != 255
+2147483647   != 0o17777777777
+-2147483647-1 != 0o20000000000
+0o37777777777 != -1
+0xffffffff != -1; 0o37777777777 != -1; -0o1234567 == 0O001234567; 0b10101 == 0B00010101
+
+# Long integers
+x = 0
+x = 0
+x = 0xffffffffffffffff
+x = 0xffffffffffffffff
+x = 0o77777777777777777
+x = 0B11101010111111111
+x = 123456789012345678901234567890
+x = 123456789012345678901234567890
+
+# Floating-point numbers
+x = 3.14
+x = 314.
+x = 0.314
+# XXX x = 000.314
+x = .314
+x = 3e14
+x = 3E14
+x = 3e-14
+x = 3e+14
+x = 3.e14
+x = .3e14
+x = 3.1e4
+
+# String literals
+x = ''; y = "";
+x = '\''; y = "'";
+x = '"'; y = "\"";
+x = "doesn't \"shrink\" does it"
+y = 'doesn\'t "shrink" does it'
+x = "does \"shrink\" doesn't it"
+y = 'does "shrink" doesn\'t it'
+x = """
+The "quick"
+brown fox
+jumps over
+the 'lazy' dog.
+"""
+y = '\nThe "quick"\nbrown fox\njumps over\nthe \'lazy\' dog.\n'
+y = '''
+The "quick"
+brown fox
+jumps over
+the 'lazy' dog.
+''';
+y = "\n\
+The \"quick\"\n\
+brown fox\n\
+jumps over\n\
+the 'lazy' dog.\n\
+";
+y = '\n\
+The \"quick\"\n\
+brown fox\n\
+jumps over\n\
+the \'lazy\' dog.\n\
+';
+x = r'\\' + R'\\'
+x = r'\'' + ''
+y = r'''
+foo bar \\
+baz''' + R'''
+foo'''
+y = r"""foo
+bar \\ baz
+""" + R'''spam
+'''
+x = b'abc' + B'ABC'
+y = b"abc" + B"ABC"
+x = br'abc' + Br'ABC' + bR'ABC' + BR'ABC'
+y = br"abc" + Br"ABC" + bR"ABC" + BR"ABC"
+x = rb'abc' + rB'ABC' + Rb'ABC' + RB'ABC'
+y = rb"abc" + rB"ABC" + Rb"ABC" + RB"ABC"
+x = br'\\' + BR'\\'
+x = rb'\\' + RB'\\'
+x = br'\'' + ''
+x = rb'\'' + ''
+y = br'''
+foo bar \\
+baz''' + BR'''
+foo'''
+y = Br"""foo
+bar \\ baz
+""" + bR'''spam
+'''
+y = rB"""foo
+bar \\ baz
+""" + Rb'''spam
+'''
+
+# Indentation
+if 1:
+    x = 2
+if 1:
+        x = 2
+if 1:
+    while 0:
+     if 0:
+           x = 2
+     x = 2
+if 0:
+  if 2:
+   while 0:
+        if 1:
+          x = 2
+
+# Operators
+
+def d22(a, b, c=1, d=2): pass
+def d01v(a=1, *restt, **restd): pass
+
+(x, y) != ({'a':1}, {'b':2})
+
+# comparison
+if 1 < 1 > 1 == 1 >= 1 <= 1 != 1 != 1 in 1 not in 1 is 1 is not 1: pass
+
+# binary
+x = 1 & 1
+x = 1 ^ 1
+x = 1 | 1
+
+# shift
+x = 1 << 1 >> 1
+
+# additive
+x = 1 - 1 + 1 - 1 + 1
+
+# multiplicative
+x = 1 / 1 * 1 % 1
+
+# unary
+x = ~1 ^ 1 & 1 | 1 & 1 ^ -1
+x = -1*1/1 + 1*1 - ---1*1
+
+# selector
+import sys, time
+x = sys.modules['time'].time()
+
+@staticmethod
+def foo(): pass
+
+@staticmethod
+def foo(x:1)->1: pass
+
diff --git a/Lib/test/typinganndata/fwdref_module.py b/Lib/test/typinganndata/fwdref_module.py
new file mode 100644
index 00000000000..7347a7a4245
--- /dev/null
+++ b/Lib/test/typinganndata/fwdref_module.py
@@ -0,0 +1,6 @@
+from typing import ForwardRef
+
+MyList = list[int]
+MyDict = dict[str, 'MyList']
+
+fw = ForwardRef('MyDict', module=__name__)
diff --git a/Lib/test/typinganndata/partialexecution/__init__.py b/Lib/test/typinganndata/partialexecution/__init__.py
new file mode 100644
index 00000000000..c39074ea84b
--- /dev/null
+++ b/Lib/test/typinganndata/partialexecution/__init__.py
@@ -0,0 +1 @@
+from . import a
diff --git a/Lib/test/typinganndata/partialexecution/a.py b/Lib/test/typinganndata/partialexecution/a.py
new file mode 100644
index 00000000000..ed0b8dcbd55
--- /dev/null
+++ b/Lib/test/typinganndata/partialexecution/a.py
@@ -0,0 +1,5 @@
+v1: int
+
+from . import b
+
+v2: int
diff --git a/Lib/test/typinganndata/partialexecution/b.py b/Lib/test/typinganndata/partialexecution/b.py
new file mode 100644
index 00000000000..36b8d2e52a3
--- /dev/null
+++ b/Lib/test/typinganndata/partialexecution/b.py
@@ -0,0 +1,3 @@
+from . import a
+
+annos = a.__annotations__
diff --git a/Lib/textwrap.py b/Lib/textwrap.py
index 7ca393d1c37..41366fbf443 100644
--- a/Lib/textwrap.py
+++ b/Lib/textwrap.py
@@ -2,7 +2,7 @@
 """
 
 # Copyright (C) 1999-2001 Gregory P. Ward.
-# Copyright (C) 2002, 2003 Python Software Foundation.
+# Copyright (C) 2002 Python Software Foundation.
 # Written by Greg Ward <gward@python.net>
 
 import re
@@ -86,7 +86,7 @@ class TextWrapper:
               -(?: (?<=%(lt)s{2}-) | (?<=%(lt)s-%(lt)s-))
               (?= %(lt)s -? %(lt)s)
             | # end of word
-              (?=%(ws)s|\Z)
+              (?=%(ws)s|\z)
             | # em-dash
               (?<=%(wp)s) (?=-{2,}\w)
             )
@@ -107,7 +107,7 @@ class TextWrapper:
     sentence_end_re = re.compile(r'[a-z]'             # lowercase letter
                                  r'[\.\!\?]'          # sentence-ending punct.
                                  r'[\"\']?'           # optional end-of-quote
-                                 r'\Z')               # end of chunk
+                                 r'\z')               # end of chunk
 
     def __init__(self,
                  width=70,
@@ -211,7 +211,7 @@ def _handle_long_word(self, reversed_chunks, cur_line, cur_len, width):
 
         # If we're allowed to break long words, then do so: put as much
         # of the next chunk onto the current line as will fit.
-        if self.break_long_words:
+        if self.break_long_words and space_left > 0:
             end = space_left
             chunk = reversed_chunks[-1]
             if self.break_on_hyphens and len(chunk) > space_left:
@@ -413,9 +413,6 @@ def shorten(text, width, **kwargs):
 
 # -- Loosely related functionality -------------------------------------
 
-_whitespace_only_re = re.compile('^[ \t]+$', re.MULTILINE)
-_leading_whitespace_re = re.compile('(^[ \t]*)(?:[^ \t\n])', re.MULTILINE)
-
 def dedent(text):
     """Remove any common leading whitespace from every line in `text`.
 
@@ -429,42 +426,22 @@ def dedent(text):
 
     Entirely blank lines are normalized to a newline character.
     """
-    # Look for the longest leading string of spaces and tabs common to
-    # all lines.
-    margin = None
-    text = _whitespace_only_re.sub('', text)
-    indents = _leading_whitespace_re.findall(text)
-    for indent in indents:
-        if margin is None:
-            margin = indent
-
-        # Current line more deeply indented than previous winner:
-        # no change (previous winner is still on top).
-        elif indent.startswith(margin):
-            pass
-
-        # Current line consistent with and no deeper than previous winner:
-        # it's the new winner.
-        elif margin.startswith(indent):
-            margin = indent
-
-        # Find the largest common whitespace between current line and previous
-        # winner.
-        else:
-            for i, (x, y) in enumerate(zip(margin, indent)):
-                if x != y:
-                    margin = margin[:i]
-                    break
+    try:
+        lines = text.split('\n')
+    except (AttributeError, TypeError):
+        msg = f'expected str object, not {type(text).__qualname__!r}'
+        raise TypeError(msg) from None
 
-    # sanity check (testing/debugging only)
-    if 0 and margin:
-        for line in text.split("\n"):
-            assert not line or line.startswith(margin), \
-                   "line = %r, margin = %r" % (line, margin)
+    # Get length of leading whitespace, inspired by ``os.path.commonprefix()``.
+    non_blank_lines = [l for l in lines if l and not l.isspace()]
+    l1 = min(non_blank_lines, default='')
+    l2 = max(non_blank_lines, default='')
+    margin = 0
+    for margin, c in enumerate(l1):
+        if c != l2[margin] or c not in ' \t':
+            break
 
-    if margin:
-        text = re.sub(r'(?m)^' + margin, '', text)
-    return text
+    return '\n'.join([l[margin:] if not l.isspace() else '' for l in lines])
 
 
 def indent(text, prefix, predicate=None):
@@ -475,19 +452,20 @@ def indent(text, prefix, predicate=None):
     it will default to adding 'prefix' to all non-empty lines that do not
     consist solely of whitespace characters.
     """
-    if predicate is None:
-        # str.splitlines(True) doesn't produce empty string.
-        #  ''.splitlines(True) => []
-        #  'foo\n'.splitlines(True) => ['foo\n']
-        # So we can use just `not s.isspace()` here.
-        predicate = lambda s: not s.isspace()
-
     prefixed_lines = []
-    for line in text.splitlines(True):
-        if predicate(line):
-            prefixed_lines.append(prefix)
-        prefixed_lines.append(line)
-
+    if predicate is None:
+        # str.splitlines(keepends=True) doesn't produce the empty string,
+        # so we need to use `str.isspace()` rather than a truth test.
+        # Inlining the predicate leads to a ~30% performance improvement.
+        for line in text.splitlines(True):
+            if not line.isspace():
+                prefixed_lines.append(prefix)
+            prefixed_lines.append(line)
+    else:
+        for line in text.splitlines(True):
+            if predicate(line):
+                prefixed_lines.append(prefix)
+            prefixed_lines.append(line)
     return ''.join(prefixed_lines)
 
 
diff --git a/Lib/timeit.py b/Lib/timeit.py
old mode 100755
new mode 100644
index 258dedccd08..e767f018782
--- a/Lib/timeit.py
+++ b/Lib/timeit.py
@@ -1,5 +1,3 @@
-#! /usr/bin/env python3
-
 """Tool for measuring execution time of small code snippets.
 
 This module avoids a number of common traps for measuring execution
@@ -46,7 +44,6 @@
     timeit(string, string) -> float
     repeat(string, string) -> list
     default_timer() -> float
-
 """
 
 import gc
@@ -174,16 +171,14 @@ def timeit(self, number=default_number):
         the timer function to be used are passed to the constructor.
         """
         it = itertools.repeat(None, number)
-        # XXX RUSTPYTHON TODO: gc module implementation
-        # gcold = gc.isenabled()
-        # gc.disable()
-        # try:
-        #     timing = self.inner(it, self.timer)
-        # finally:
-        #     if gcold:
-        #         gc.enable()
-        # return timing
-        return self.inner(it, self.timer)
+        gcold = gc.isenabled()
+        gc.disable()
+        try:
+            timing = self.inner(it, self.timer)
+        finally:
+            if gcold:
+                gc.enable()
+        return timing
 
     def repeat(self, repeat=default_repeat, number=default_number):
         """Call timeit() a few times.
@@ -306,7 +301,7 @@ def main(args=None, *, _wrap_timer=None):
                 precision += 1
             verbose += 1
         if o in ("-h", "--help"):
-            print(__doc__, end=' ')
+            print(__doc__, end="")
             return 0
     setup = "\n".join(setup) or "pass"
 
diff --git a/Lib/tokenize.py b/Lib/tokenize.py
index d72968e4250..1f31258ce36 100644
--- a/Lib/tokenize.py
+++ b/Lib/tokenize.py
@@ -24,10 +24,7 @@
 __credits__ = ('GvR, ESR, Tim Peters, Thomas Wouters, Fred Drake, '
                'Skip Montanaro, Raymond Hettinger, Trent Nelson, '
                'Michael Foord')
-try:
-    from builtins import open as _builtin_open
-except ImportError:
-    pass
+from builtins import open as _builtin_open
 from codecs import lookup, BOM_UTF8
 import collections
 import functools
@@ -37,13 +34,14 @@
 import sys
 from token import *
 from token import EXACT_TOKEN_TYPES
+import _tokenize
 
-cookie_re = re.compile(r'^[ \t\f]*#.*?coding[:=][ \t]*([-\w.]+)', re.ASCII)
+cookie_re = re.compile(br'^[ \t\f]*#.*?coding[:=][ \t]*([-\w.]+)', re.ASCII)
 blank_re = re.compile(br'^[ \t\f]*(?:[#\r\n]|$)', re.ASCII)
 
 import token
 __all__ = token.__all__ + ["tokenize", "generate_tokens", "detect_encoding",
-                           "untokenize", "TokenInfo"]
+                           "untokenize", "TokenInfo", "open", "TokenError"]
 del token
 
 class TokenInfo(collections.namedtuple('TokenInfo', 'type string start end line')):
@@ -88,7 +86,7 @@ def _all_string_prefixes():
     # The valid string prefixes. Only contain the lower case versions,
     #  and don't contain any permutations (include 'fr', but not
     #  'rf'). The various permutations will be generated.
-    _valid_string_prefixes = ['b', 'r', 'u', 'f', 'br', 'fr']
+    _valid_string_prefixes = ['b', 'r', 'u', 'f', 't', 'br', 'fr', 'tr']
     # if we add binary f-strings, add: ['fb', 'fbr']
     result = {''}
     for prefix in _valid_string_prefixes:
@@ -134,7 +132,7 @@ def _compile(expr):
                 group("'", r'\\\r?\n'),
                 StringPrefix + r'"[^\n"\\]*(?:\\.[^\n"\\]*)*' +
                 group('"', r'\\\r?\n'))
-PseudoExtras = group(r'\\\r?\n|\Z', Comment, Triple)
+PseudoExtras = group(r'\\\r?\n|\z', Comment, Triple)
 PseudoToken = Whitespace + group(PseudoExtras, Number, Funny, ContStr, Name)
 
 # For a given string prefix plus quotes, endpats maps it to a regex
@@ -146,6 +144,7 @@ def _compile(expr):
     endpats[_prefix + '"'] = Double
     endpats[_prefix + "'''"] = Single3
     endpats[_prefix + '"""'] = Double3
+del _prefix
 
 # A set of all of the single and triple quoted string prefixes,
 #  including the opening quotes.
@@ -156,13 +155,12 @@ def _compile(expr):
         single_quoted.add(u)
     for u in (t + '"""', t + "'''"):
         triple_quoted.add(u)
+del t, u
 
 tabsize = 8
 
 class TokenError(Exception): pass
 
-class StopTokenizing(Exception): pass
-
 
 class Untokenizer:
 
@@ -170,6 +168,8 @@ def __init__(self):
         self.tokens = []
         self.prev_row = 1
         self.prev_col = 0
+        self.prev_type = None
+        self.prev_line = ""
         self.encoding = None
 
     def add_whitespace(self, start):
@@ -177,14 +177,51 @@ def add_whitespace(self, start):
         if row < self.prev_row or row == self.prev_row and col < self.prev_col:
             raise ValueError("start ({},{}) precedes previous end ({},{})"
                              .format(row, col, self.prev_row, self.prev_col))
-        row_offset = row - self.prev_row
-        if row_offset:
-            self.tokens.append("\\\n" * row_offset)
-            self.prev_col = 0
+        self.add_backslash_continuation(start)
         col_offset = col - self.prev_col
         if col_offset:
             self.tokens.append(" " * col_offset)
 
+    def add_backslash_continuation(self, start):
+        """Add backslash continuation characters if the row has increased
+        without encountering a newline token.
+
+        This also inserts the correct amount of whitespace before the backslash.
+        """
+        row = start[0]
+        row_offset = row - self.prev_row
+        if row_offset == 0:
+            return
+
+        newline = '\r\n' if self.prev_line.endswith('\r\n') else '\n'
+        line = self.prev_line.rstrip('\\\r\n')
+        ws = ''.join(_itertools.takewhile(str.isspace, reversed(line)))
+        self.tokens.append(ws + f"\\{newline}" * row_offset)
+        self.prev_col = 0
+
+    def escape_brackets(self, token):
+        characters = []
+        consume_until_next_bracket = False
+        for character in token:
+            if character == "}":
+                if consume_until_next_bracket:
+                    consume_until_next_bracket = False
+                else:
+                    characters.append(character)
+            if character == "{":
+                n_backslashes = sum(
+                    1 for char in _itertools.takewhile(
+                        "\\".__eq__,
+                        characters[-2::-1]
+                    )
+                )
+                if n_backslashes % 2 == 0 or characters[-1] != "N":
+                    characters.append(character)
+                else:
+                    consume_until_next_bracket = True
+            characters.append(character)
+        return "".join(characters)
+
     def untokenize(self, iterable):
         it = iter(iterable)
         indents = []
@@ -214,12 +251,22 @@ def untokenize(self, iterable):
                     self.tokens.append(indent)
                     self.prev_col = len(indent)
                 startline = False
+            elif tok_type in {FSTRING_MIDDLE, TSTRING_MIDDLE}:
+                if '{' in token or '}' in token:
+                    token = self.escape_brackets(token)
+                    last_line = token.splitlines()[-1]
+                    end_line, end_col = end
+                    extra_chars = last_line.count("{{") + last_line.count("}}")
+                    end = (end_line, end_col + extra_chars)
+
             self.add_whitespace(start)
             self.tokens.append(token)
             self.prev_row, self.prev_col = end
             if tok_type in (NEWLINE, NL):
                 self.prev_row += 1
                 self.prev_col = 0
+            self.prev_type = tok_type
+            self.prev_line = line
         return "".join(self.tokens)
 
     def compat(self, token, iterable):
@@ -227,6 +274,7 @@ def compat(self, token, iterable):
         toks_append = self.tokens.append
         startline = token[0] in (NEWLINE, NL)
         prevstring = False
+        in_fstring_or_tstring = 0
 
         for tok in _itertools.chain([token], iterable):
             toknum, tokval = tok[:2]
@@ -245,6 +293,10 @@ def compat(self, token, iterable):
             else:
                 prevstring = False
 
+            if toknum in {FSTRING_START, TSTRING_START}:
+                in_fstring_or_tstring += 1
+            elif toknum in {FSTRING_END, TSTRING_END}:
+                in_fstring_or_tstring -= 1
             if toknum == INDENT:
                 indents.append(tokval)
                 continue
@@ -256,7 +308,19 @@ def compat(self, token, iterable):
             elif startline and indents:
                 toks_append(indents[-1])
                 startline = False
+            elif toknum in {FSTRING_MIDDLE, TSTRING_MIDDLE}:
+                tokval = self.escape_brackets(tokval)
+
+            # Insert a space between two consecutive brackets if we are in an f-string or t-string
+            if tokval in {"{", "}"} and self.tokens and self.tokens[-1] == tokval and in_fstring_or_tstring:
+                tokval = ' ' + tokval
+
+            # Insert a space between two consecutive f-strings
+            if toknum in (STRING, FSTRING_START) and self.prev_type in (STRING, FSTRING_END):
+                self.tokens.append(" ")
+
             toks_append(tokval)
+            self.prev_type = toknum
 
 
 def untokenize(iterable):
@@ -268,16 +332,10 @@ def untokenize(iterable):
     with at least two elements, a token number and token value.  If
     only two tokens are passed, the resulting output is poor.
 
-    Round-trip invariant for full input:
-        Untokenized source will match input source exactly
-
-    Round-trip invariant for limited input:
-        # Output bytes will tokenize back to the input
-        t1 = [tok[:2] for tok in tokenize(f.readline)]
-        newcode = untokenize(t1)
-        readline = BytesIO(newcode).readline
-        t2 = [tok[:2] for tok in tokenize(readline)]
-        assert t1 == t2
+    The result is guaranteed to tokenize back to match the input so
+    that the conversion is lossless and round-trips are assured.
+    The guarantee applies only to the token type and token string as
+    the spacing between tokens (column positions) may change.
     """
     ut = Untokenizer()
     out = ut.untokenize(iterable)
@@ -287,7 +345,7 @@ def untokenize(iterable):
 
 
 def _get_normal_name(orig_enc):
-    """Imitates get_normal_name in tokenizer.c."""
+    """Imitates get_normal_name in Parser/tokenizer/helpers.c."""
     # Only care about the first 12 characters.
     enc = orig_enc[:12].lower().replace("_", "-")
     if enc == "utf-8" or enc.startswith("utf-8-"):
@@ -327,22 +385,23 @@ def read_or_stop():
         except StopIteration:
             return b''
 
-    def find_cookie(line):
+    def check(line, encoding):
+        # Check if the line matches the encoding.
+        if 0 in line:
+            raise SyntaxError("source code cannot contain null bytes")
         try:
-            # Decode as UTF-8. Either the line is an encoding declaration,
-            # in which case it should be pure ASCII, or it must be UTF-8
-            # per default encoding.
-            line_string = line.decode('utf-8')
+            line.decode(encoding)
         except UnicodeDecodeError:
             msg = "invalid or missing encoding declaration"
             if filename is not None:
                 msg = '{} for {!r}'.format(msg, filename)
             raise SyntaxError(msg)
 
-        match = cookie_re.match(line_string)
+    def find_cookie(line):
+        match = cookie_re.match(line)
         if not match:
             return None
-        encoding = _get_normal_name(match.group(1))
+        encoding = _get_normal_name(match.group(1).decode())
         try:
             codec = lookup(encoding)
         except LookupError:
@@ -375,18 +434,23 @@ def find_cookie(line):
 
     encoding = find_cookie(first)
     if encoding:
+        check(first, encoding)
         return encoding, [first]
     if not blank_re.match(first):
+        check(first, default)
         return default, [first]
 
     second = read_or_stop()
     if not second:
+        check(first, default)
         return default, [first]
 
     encoding = find_cookie(second)
     if encoding:
+        check(first + second, encoding)
         return encoding, [first, second]
 
+    check(first + second, default)
     return default, [first, second]
 
 
@@ -405,7 +469,6 @@ def open(filename):
         buffer.close()
         raise
 
-
 def tokenize(readline):
     """
     The tokenize() generator requires one argument, readline, which
@@ -426,193 +489,13 @@ def tokenize(readline):
     which tells you which encoding was used to decode the bytes stream.
     """
     encoding, consumed = detect_encoding(readline)
-    empty = _itertools.repeat(b"")
-    rl_gen = _itertools.chain(consumed, iter(readline, b""), empty)
-    return _tokenize(rl_gen.__next__, encoding)
-
-
-def _tokenize(readline, encoding):
-    lnum = parenlev = continued = 0
-    numchars = '0123456789'
-    contstr, needcont = '', 0
-    contline = None
-    indents = [0]
-
+    rl_gen = _itertools.chain(consumed, iter(readline, b""))
     if encoding is not None:
         if encoding == "utf-8-sig":
             # BOM will already have been stripped.
             encoding = "utf-8"
         yield TokenInfo(ENCODING, encoding, (0, 0), (0, 0), '')
-    last_line = b''
-    line = b''
-    while True:                                # loop over lines in stream
-        try:
-            # We capture the value of the line variable here because
-            # readline uses the empty string '' to signal end of input,
-            # hence `line` itself will always be overwritten at the end
-            # of this loop.
-            last_line = line
-            line = readline()
-        except StopIteration:
-            line = b''
-
-        if encoding is not None:
-            line = line.decode(encoding)
-        lnum += 1
-        pos, max = 0, len(line)
-
-        if contstr:                            # continued string
-            if not line:
-                raise TokenError("EOF in multi-line string", strstart)
-            endmatch = endprog.match(line)
-            if endmatch:
-                pos = end = endmatch.end(0)
-                yield TokenInfo(STRING, contstr + line[:end],
-                       strstart, (lnum, end), contline + line)
-                contstr, needcont = '', 0
-                contline = None
-            elif needcont and line[-2:] != '\\\n' and line[-3:] != '\\\r\n':
-                yield TokenInfo(ERRORTOKEN, contstr + line,
-                           strstart, (lnum, len(line)), contline)
-                contstr = ''
-                contline = None
-                continue
-            else:
-                contstr = contstr + line
-                contline = contline + line
-                continue
-
-        elif parenlev == 0 and not continued:  # new statement
-            if not line: break
-            column = 0
-            while pos < max:                   # measure leading whitespace
-                if line[pos] == ' ':
-                    column += 1
-                elif line[pos] == '\t':
-                    column = (column//tabsize + 1)*tabsize
-                elif line[pos] == '\f':
-                    column = 0
-                else:
-                    break
-                pos += 1
-            if pos == max:
-                break
-
-            if line[pos] in '#\r\n':           # skip comments or blank lines
-                if line[pos] == '#':
-                    comment_token = line[pos:].rstrip('\r\n')
-                    yield TokenInfo(COMMENT, comment_token,
-                           (lnum, pos), (lnum, pos + len(comment_token)), line)
-                    pos += len(comment_token)
-
-                yield TokenInfo(NL, line[pos:],
-                           (lnum, pos), (lnum, len(line)), line)
-                continue
-
-            if column > indents[-1]:           # count indents or dedents
-                indents.append(column)
-                yield TokenInfo(INDENT, line[:pos], (lnum, 0), (lnum, pos), line)
-            while column < indents[-1]:
-                if column not in indents:
-                    raise IndentationError(
-                        "unindent does not match any outer indentation level",
-                        ("<tokenize>", lnum, pos, line))
-                indents = indents[:-1]
-
-                yield TokenInfo(DEDENT, '', (lnum, pos), (lnum, pos), line)
-
-        else:                                  # continued statement
-            if not line:
-                raise TokenError("EOF in multi-line statement", (lnum, 0))
-            continued = 0
-
-        while pos < max:
-            pseudomatch = _compile(PseudoToken).match(line, pos)
-            if pseudomatch:                                # scan for tokens
-                start, end = pseudomatch.span(1)
-                spos, epos, pos = (lnum, start), (lnum, end), end
-                if start == end:
-                    continue
-                token, initial = line[start:end], line[start]
-
-                if (initial in numchars or                 # ordinary number
-                    (initial == '.' and token != '.' and token != '...')):
-                    yield TokenInfo(NUMBER, token, spos, epos, line)
-                elif initial in '\r\n':
-                    if parenlev > 0:
-                        yield TokenInfo(NL, token, spos, epos, line)
-                    else:
-                        yield TokenInfo(NEWLINE, token, spos, epos, line)
-
-                elif initial == '#':
-                    assert not token.endswith("\n")
-                    yield TokenInfo(COMMENT, token, spos, epos, line)
-
-                elif token in triple_quoted:
-                    endprog = _compile(endpats[token])
-                    endmatch = endprog.match(line, pos)
-                    if endmatch:                           # all on one line
-                        pos = endmatch.end(0)
-                        token = line[start:pos]
-                        yield TokenInfo(STRING, token, spos, (lnum, pos), line)
-                    else:
-                        strstart = (lnum, start)           # multiple lines
-                        contstr = line[start:]
-                        contline = line
-                        break
-
-                # Check up to the first 3 chars of the token to see if
-                #  they're in the single_quoted set. If so, they start
-                #  a string.
-                # We're using the first 3, because we're looking for
-                #  "rb'" (for example) at the start of the token. If
-                #  we switch to longer prefixes, this needs to be
-                #  adjusted.
-                # Note that initial == token[:1].
-                # Also note that single quote checking must come after
-                #  triple quote checking (above).
-                elif (initial in single_quoted or
-                      token[:2] in single_quoted or
-                      token[:3] in single_quoted):
-                    if token[-1] == '\n':                  # continued string
-                        strstart = (lnum, start)
-                        # Again, using the first 3 chars of the
-                        #  token. This is looking for the matching end
-                        #  regex for the correct type of quote
-                        #  character. So it's really looking for
-                        #  endpats["'"] or endpats['"'], by trying to
-                        #  skip string prefix characters, if any.
-                        endprog = _compile(endpats.get(initial) or
-                                           endpats.get(token[1]) or
-                                           endpats.get(token[2]))
-                        contstr, needcont = line[start:], 1
-                        contline = line
-                        break
-                    else:                                  # ordinary string
-                        yield TokenInfo(STRING, token, spos, epos, line)
-
-                elif initial.isidentifier():               # ordinary name
-                    yield TokenInfo(NAME, token, spos, epos, line)
-                elif initial == '\\':                      # continued stmt
-                    continued = 1
-                else:
-                    if initial in '([{':
-                        parenlev += 1
-                    elif initial in ')]}':
-                        parenlev -= 1
-                    yield TokenInfo(OP, token, spos, epos, line)
-            else:
-                yield TokenInfo(ERRORTOKEN, line[pos],
-                           (lnum, pos), (lnum, pos+1), line)
-                pos += 1
-
-    # Add an implicit NEWLINE if the input doesn't end in one
-    if last_line and last_line[-1] not in '\r\n' and not last_line.strip().startswith("#"):
-        yield TokenInfo(NEWLINE, '', (lnum - 1, len(last_line)), (lnum - 1, len(last_line) + 1), '')
-    for indent in indents[1:]:                 # pop remaining indent levels
-        yield TokenInfo(DEDENT, '', (lnum, 0), (lnum, 0), '')
-    yield TokenInfo(ENDMARKER, '', (lnum, 0), (lnum, 0), '')
-
+    yield from _generate_tokens_from_c_tokenizer(rl_gen.__next__, encoding, extra_tokens=True)
 
 def generate_tokens(readline):
     """Tokenize a source reading Python code as unicode strings.
@@ -620,9 +503,9 @@ def generate_tokens(readline):
     This has the same API as tokenize(), except that it expects the *readline*
     callable to return str objects instead of bytes.
     """
-    return _tokenize(readline, None)
+    return _generate_tokens_from_c_tokenizer(readline, extra_tokens=True)
 
-def main():
+def _main(args=None):
     import argparse
 
     # Helper error handling routines
@@ -641,13 +524,13 @@ def error(message, filename=None, location=None):
         sys.exit(1)
 
     # Parse the arguments and options
-    parser = argparse.ArgumentParser(prog='python -m tokenize')
+    parser = argparse.ArgumentParser(color=True)
     parser.add_argument(dest='filename', nargs='?',
                         metavar='filename.py',
                         help='the file to tokenize; defaults to stdin')
     parser.add_argument('-e', '--exact', dest='exact', action='store_true',
                         help='display token names using the exact type')
-    args = parser.parse_args()
+    args = parser.parse_args(args)
 
     try:
         # Tokenize the input
@@ -657,7 +540,9 @@ def error(message, filename=None, location=None):
                 tokens = list(tokenize(f.readline))
         else:
             filename = "<stdin>"
-            tokens = _tokenize(sys.stdin.readline, None)
+            tokens = _generate_tokens_from_c_tokenizer(
+                sys.stdin.readline, extra_tokens=True)
+
 
         # Output the tokenization
         for token in tokens:
@@ -683,5 +568,31 @@ def error(message, filename=None, location=None):
         perror("unexpected error: %s" % err)
         raise
 
+def _transform_msg(msg):
+    """Transform error messages from the C tokenizer into the Python tokenize
+
+    The C tokenizer is more picky than the Python one, so we need to massage
+    the error messages a bit for backwards compatibility.
+    """
+    if "unterminated triple-quoted string literal" in msg:
+        return "EOF in multi-line string"
+    return msg
+
+def _generate_tokens_from_c_tokenizer(source, encoding=None, extra_tokens=False):
+    """Tokenize a source reading Python code as unicode strings using the internal C tokenizer"""
+    if encoding is None:
+        it = _tokenize.TokenizerIter(source, extra_tokens=extra_tokens)
+    else:
+        it = _tokenize.TokenizerIter(source, encoding=encoding, extra_tokens=extra_tokens)
+    try:
+        for info in it:
+            yield TokenInfo._make(info)
+    except SyntaxError as e:
+        if type(e) != SyntaxError:
+            raise e from None
+        msg = _transform_msg(e.msg)
+        raise TokenError(msg, (e.lineno, e.offset)) from None
+
+
 if __name__ == "__main__":
-    main()
+    _main()
diff --git a/Lib/tomllib/_parser.py b/Lib/tomllib/_parser.py
index 9c80a6a547d..3ee47aa9e0a 100644
--- a/Lib/tomllib/_parser.py
+++ b/Lib/tomllib/_parser.py
@@ -4,10 +4,7 @@
 
 from __future__ import annotations
 
-from collections.abc import Iterable
-import string
 from types import MappingProxyType
-from typing import Any, BinaryIO, NamedTuple
 
 from ._re import (
     RE_DATETIME,
@@ -17,7 +14,13 @@
     match_to_localtime,
     match_to_number,
 )
-from ._types import Key, ParseFloat, Pos
+
+TYPE_CHECKING = False
+if TYPE_CHECKING:
+    from collections.abc import Iterable
+    from typing import IO, Any
+
+    from ._types import Key, ParseFloat, Pos
 
 ASCII_CTRL = frozenset(chr(i) for i in range(32)) | frozenset(chr(127))
 
@@ -33,9 +36,11 @@
 
 TOML_WS = frozenset(" \t")
 TOML_WS_AND_NEWLINE = TOML_WS | frozenset("\n")
-BARE_KEY_CHARS = frozenset(string.ascii_letters + string.digits + "-_")
+BARE_KEY_CHARS = frozenset(
+    "abcdefghijklmnopqrstuvwxyz" "ABCDEFGHIJKLMNOPQRSTUVWXYZ" "0123456789" "-_"
+)
 KEY_INITIAL_CHARS = BARE_KEY_CHARS | frozenset("\"'")
-HEXDIGIT_CHARS = frozenset(string.hexdigits)
+HEXDIGIT_CHARS = frozenset("abcdef" "ABCDEF" "0123456789")
 
 BASIC_STR_ESCAPE_REPLACEMENTS = MappingProxyType(
     {
@@ -50,11 +55,73 @@
 )
 
 
+class DEPRECATED_DEFAULT:
+    """Sentinel to be used as default arg during deprecation
+    period of TOMLDecodeError's free-form arguments."""
+
+
 class TOMLDecodeError(ValueError):
-    """An error raised if a document is not valid TOML."""
+    """An error raised if a document is not valid TOML.
+
+    Adds the following attributes to ValueError:
+    msg: The unformatted error message
+    doc: The TOML document being parsed
+    pos: The index of doc where parsing failed
+    lineno: The line corresponding to pos
+    colno: The column corresponding to pos
+    """
+
+    def __init__(
+        self,
+        msg: str = DEPRECATED_DEFAULT,  # type: ignore[assignment]
+        doc: str = DEPRECATED_DEFAULT,  # type: ignore[assignment]
+        pos: Pos = DEPRECATED_DEFAULT,  # type: ignore[assignment]
+        *args: Any,
+    ):
+        if (
+            args
+            or not isinstance(msg, str)
+            or not isinstance(doc, str)
+            or not isinstance(pos, int)
+        ):
+            import warnings
+
+            warnings.warn(
+                "Free-form arguments for TOMLDecodeError are deprecated. "
+                "Please set 'msg' (str), 'doc' (str) and 'pos' (int) arguments only.",
+                DeprecationWarning,
+                stacklevel=2,
+            )
+            if pos is not DEPRECATED_DEFAULT:  # type: ignore[comparison-overlap]
+                args = pos, *args
+            if doc is not DEPRECATED_DEFAULT:  # type: ignore[comparison-overlap]
+                args = doc, *args
+            if msg is not DEPRECATED_DEFAULT:  # type: ignore[comparison-overlap]
+                args = msg, *args
+            ValueError.__init__(self, *args)
+            return
+
+        lineno = doc.count("\n", 0, pos) + 1
+        if lineno == 1:
+            colno = pos + 1
+        else:
+            colno = pos - doc.rindex("\n", 0, pos)
+
+        if pos >= len(doc):
+            coord_repr = "end of document"
+        else:
+            coord_repr = f"line {lineno}, column {colno}"
+        errmsg = f"{msg} (at {coord_repr})"
+        ValueError.__init__(self, errmsg)
+
+        self.msg = msg
+        self.doc = doc
+        self.pos = pos
+        self.lineno = lineno
+        self.colno = colno
 
 
-def load(fp: BinaryIO, /, *, parse_float: ParseFloat = float) -> dict[str, Any]:
+def load(fp: IO[bytes], /, *, parse_float: ParseFloat = float) -> dict[str, Any]:
     """Parse TOML from a binary file object."""
     b = fp.read()
     try:
@@ -71,9 +138,14 @@ def loads(s: str, /, *, parse_float: ParseFloat = float) -> dict[str, Any]:  # n
 
     # The spec allows converting "\r\n" to "\n", even in string
     # literals. Let's do so to simplify parsing.
-    src = s.replace("\r\n", "\n")
+    try:
+        src = s.replace("\r\n", "\n")
+    except (AttributeError, TypeError):
+        raise TypeError(
+            f"Expected str object, not '{type(s).__qualname__}'"
+        ) from None
     pos = 0
-    out = Output(NestedDict(), Flags())
+    out = Output()
     header: Key = ()
     parse_float = make_safe_parse_float(parse_float)
 
@@ -113,7 +185,7 @@ def loads(s: str, /, *, parse_float: ParseFloat = float) -> dict[str, Any]:  # n
                 pos, header = create_dict_rule(src, pos, out)
             pos = skip_chars(src, pos, TOML_WS)
         elif char != "#":
-            raise suffixed_err(src, pos, "Invalid statement")
+            raise TOMLDecodeError("Invalid statement", src, pos)
 
         # 3. Skip comment
         pos = skip_comment(src, pos)
@@ -124,8 +196,8 @@ def loads(s: str, /, *, parse_float: ParseFloat = float) -> dict[str, Any]:  # n
         except IndexError:
             break
         if char != "\n":
-            raise suffixed_err(
-                src, pos, "Expected newline or end of document after a statement"
+            raise TOMLDecodeError(
+                "Expected newline or end of document after a statement", src, pos
             )
         pos += 1
 
@@ -224,9 +296,10 @@ def append_nest_to_list(self, key: Key) -> None:
             cont[last_key] = [{}]
 
 
-class Output(NamedTuple):
-    data: NestedDict
-    flags: Flags
+class Output:
+    def __init__(self) -> None:
+        self.data = NestedDict()
+        self.flags = Flags()
 
 
 def skip_chars(src: str, pos: Pos, chars: Iterable[str]) -> Pos:
@@ -251,12 +324,12 @@ def skip_until(
     except ValueError:
         new_pos = len(src)
         if error_on_eof:
-            raise suffixed_err(src, new_pos, f"Expected {expect!r}") from None
+            raise TOMLDecodeError(f"Expected {expect!r}", src, new_pos) from None
 
     if not error_on.isdisjoint(src[pos:new_pos]):
         while src[pos] not in error_on:
             pos += 1
-        raise suffixed_err(src, pos, f"Found invalid character {src[pos]!r}")
+        raise TOMLDecodeError(f"Found invalid character {src[pos]!r}", src, pos)
     return new_pos
 
 
@@ -287,15 +360,17 @@ def create_dict_rule(src: str, pos: Pos, out: Output) -> tuple[Pos, Key]:
     pos, key = parse_key(src, pos)
 
     if out.flags.is_(key, Flags.EXPLICIT_NEST) or out.flags.is_(key, Flags.FROZEN):
-        raise suffixed_err(src, pos, f"Cannot declare {key} twice")
+        raise TOMLDecodeError(f"Cannot declare {key} twice", src, pos)
     out.flags.set(key, Flags.EXPLICIT_NEST, recursive=False)
     try:
         out.data.get_or_create_nest(key)
     except KeyError:
-        raise suffixed_err(src, pos, "Cannot overwrite a value") from None
+        raise TOMLDecodeError("Cannot overwrite a value", src, pos) from None
 
     if not src.startswith("]", pos):
-        raise suffixed_err(src, pos, "Expected ']' at the end of a table declaration")
+        raise TOMLDecodeError(
+            "Expected ']' at the end of a table declaration", src, pos
+        )
     return pos + 1, key
 
 
@@ -305,7 +380,7 @@ def create_list_rule(src: str, pos: Pos, out: Output) -> tuple[Pos, Key]:
     pos, key = parse_key(src, pos)
 
     if out.flags.is_(key, Flags.FROZEN):
-        raise suffixed_err(src, pos, f"Cannot mutate immutable namespace {key}")
+        raise TOMLDecodeError(f"Cannot mutate immutable namespace {key}", src, pos)
     # Free the namespace now that it points to another empty list item...
     out.flags.unset_all(key)
     # ...but this key precisely is still prohibited from table declaration
@@ -313,10 +388,12 @@ def create_list_rule(src: str, pos: Pos, out: Output) -> tuple[Pos, Key]:
     try:
         out.data.append_nest_to_list(key)
     except KeyError:
-        raise suffixed_err(src, pos, "Cannot overwrite a value") from None
+        raise TOMLDecodeError("Cannot overwrite a value", src, pos) from None
 
     if not src.startswith("]]", pos):
-        raise suffixed_err(src, pos, "Expected ']]' at the end of an array declaration")
+        raise TOMLDecodeError(
+            "Expected ']]' at the end of an array declaration", src, pos
+        )
     return pos + 2, key
 
 
@@ -331,22 +408,22 @@ def key_value_rule(
     for cont_key in relative_path_cont_keys:
         # Check that dotted key syntax does not redefine an existing table
         if out.flags.is_(cont_key, Flags.EXPLICIT_NEST):
-            raise suffixed_err(src, pos, f"Cannot redefine namespace {cont_key}")
+            raise TOMLDecodeError(f"Cannot redefine namespace {cont_key}", src, pos)
         # Containers in the relative path can't be opened with the table syntax or
         # dotted key/value syntax in following table sections.
         out.flags.add_pending(cont_key, Flags.EXPLICIT_NEST)
 
     if out.flags.is_(abs_key_parent, Flags.FROZEN):
-        raise suffixed_err(
-            src, pos, f"Cannot mutate immutable namespace {abs_key_parent}"
+        raise TOMLDecodeError(
+            f"Cannot mutate immutable namespace {abs_key_parent}", src, pos
         )
 
     try:
         nest = out.data.get_or_create_nest(abs_key_parent)
     except KeyError:
-        raise suffixed_err(src, pos, "Cannot overwrite a value") from None
+        raise TOMLDecodeError("Cannot overwrite a value", src, pos) from None
     if key_stem in nest:
-        raise suffixed_err(src, pos, "Cannot overwrite a value")
+        raise TOMLDecodeError("Cannot overwrite a value", src, pos)
     # Mark inline table and array namespaces recursively immutable
     if isinstance(value, (dict, list)):
         out.flags.set(header + key, Flags.FROZEN, recursive=True)
@@ -363,7 +440,7 @@ def parse_key_value_pair(
     except IndexError:
         char = None
     if char != "=":
-        raise suffixed_err(src, pos, "Expected '=' after a key in a key/value pair")
+        raise TOMLDecodeError("Expected '=' after a key in a key/value pair", src, pos)
     pos += 1
     pos = skip_chars(src, pos, TOML_WS)
     pos, value = parse_value(src, pos, parse_float)
@@ -401,7 +478,7 @@ def parse_key_part(src: str, pos: Pos) -> tuple[Pos, str]:
         return parse_literal_str(src, pos)
     if char == '"':
         return parse_one_line_basic_str(src, pos)
-    raise suffixed_err(src, pos, "Invalid initial character for a key part")
+    raise TOMLDecodeError("Invalid initial character for a key part", src, pos)
 
 
 def parse_one_line_basic_str(src: str, pos: Pos) -> tuple[Pos, str]:
@@ -425,7 +502,7 @@ def parse_array(src: str, pos: Pos, parse_float: ParseFloat) -> tuple[Pos, list[
         if c == "]":
             return pos + 1, array
         if c != ",":
-            raise suffixed_err(src, pos, "Unclosed array")
+            raise TOMLDecodeError("Unclosed array", src, pos)
         pos += 1
 
         pos = skip_comments_and_array_ws(src, pos)
@@ -445,20 +522,20 @@ def parse_inline_table(src: str, pos: Pos, parse_float: ParseFloat) -> tuple[Pos
         pos, key, value = parse_key_value_pair(src, pos, parse_float)
         key_parent, key_stem = key[:-1], key[-1]
         if flags.is_(key, Flags.FROZEN):
-            raise suffixed_err(src, pos, f"Cannot mutate immutable namespace {key}")
+            raise TOMLDecodeError(f"Cannot mutate immutable namespace {key}", src, pos)
         try:
             nest = nested_dict.get_or_create_nest(key_parent, access_lists=False)
         except KeyError:
-            raise suffixed_err(src, pos, "Cannot overwrite a value") from None
+            raise TOMLDecodeError("Cannot overwrite a value", src, pos) from None
         if key_stem in nest:
-            raise suffixed_err(src, pos, f"Duplicate inline table key {key_stem!r}")
+            raise TOMLDecodeError(f"Duplicate inline table key {key_stem!r}", src, pos)
         nest[key_stem] = value
         pos = skip_chars(src, pos, TOML_WS)
         c = src[pos : pos + 1]
         if c == "}":
             return pos + 1, nested_dict.dict
         if c != ",":
-            raise suffixed_err(src, pos, "Unclosed inline table")
+            raise TOMLDecodeError("Unclosed inline table", src, pos)
         if isinstance(value, (dict, list)):
             flags.set(key, Flags.FROZEN, recursive=True)
         pos += 1
@@ -480,7 +557,7 @@ def parse_basic_str_escape(
             except IndexError:
                 return pos, ""
             if char != "\n":
-                raise suffixed_err(src, pos, "Unescaped '\\' in a string")
+                raise TOMLDecodeError("Unescaped '\\' in a string", src, pos)
             pos += 1
         pos = skip_chars(src, pos, TOML_WS_AND_NEWLINE)
         return pos, ""
@@ -491,7 +568,7 @@ def parse_basic_str_escape(
     try:
         return pos, BASIC_STR_ESCAPE_REPLACEMENTS[escape_id]
     except KeyError:
-        raise suffixed_err(src, pos, "Unescaped '\\' in a string") from None
+        raise TOMLDecodeError("Unescaped '\\' in a string", src, pos) from None
 
 
 def parse_basic_str_escape_multiline(src: str, pos: Pos) -> tuple[Pos, str]:
@@ -501,11 +578,13 @@ def parse_basic_str_escape_multiline(src: str, pos: Pos) -> tuple[Pos, str]:
 def parse_hex_char(src: str, pos: Pos, hex_len: int) -> tuple[Pos, str]:
     hex_str = src[pos : pos + hex_len]
     if len(hex_str) != hex_len or not HEXDIGIT_CHARS.issuperset(hex_str):
-        raise suffixed_err(src, pos, "Invalid hex value")
+        raise TOMLDecodeError("Invalid hex value", src, pos)
     pos += hex_len
     hex_int = int(hex_str, 16)
     if not is_unicode_scalar_value(hex_int):
-        raise suffixed_err(src, pos, "Escaped character is not a Unicode scalar value")
+        raise TOMLDecodeError(
+            "Escaped character is not a Unicode scalar value", src, pos
+        )
     return pos, chr(hex_int)
 
 
@@ -562,7 +641,7 @@ def parse_basic_str(src: str, pos: Pos, *, multiline: bool) -> tuple[Pos, str]:
         try:
             char = src[pos]
         except IndexError:
-            raise suffixed_err(src, pos, "Unterminated string") from None
+            raise TOMLDecodeError("Unterminated string", src, pos) from None
         if char == '"':
             if not multiline:
                 return pos + 1, result + src[start_pos:pos]
@@ -577,7 +656,7 @@ def parse_basic_str(src: str, pos: Pos, *, multiline: bool) -> tuple[Pos, str]:
             start_pos = pos
             continue
         if char in error_on:
-            raise suffixed_err(src, pos, f"Illegal character {char!r}")
+            raise TOMLDecodeError(f"Illegal character {char!r}", src, pos)
         pos += 1
 
 
@@ -625,7 +704,7 @@ def parse_value(  # noqa: C901
         try:
             datetime_obj = match_to_datetime(datetime_match)
         except ValueError as e:
-            raise suffixed_err(src, pos, "Invalid date or datetime") from e
+            raise TOMLDecodeError("Invalid date or datetime", src, pos) from e
         return datetime_match.end(), datetime_obj
     localtime_match = RE_LOCALTIME.match(src, pos)
     if localtime_match:
@@ -646,24 +725,7 @@ def parse_value(  # noqa: C901
     if first_four in {"-inf", "+inf", "-nan", "+nan"}:
         return pos + 4, parse_float(first_four)
 
-    raise suffixed_err(src, pos, "Invalid value")
-
-
-def suffixed_err(src: str, pos: Pos, msg: str) -> TOMLDecodeError:
-    """Return a `TOMLDecodeError` where error message is suffixed with
-    coordinates in source."""
-
-    def coord_repr(src: str, pos: Pos) -> str:
-        if pos >= len(src):
-            return "end of document"
-        line = src.count("\n", 0, pos) + 1
-        if line == 1:
-            column = pos + 1
-        else:
-            column = pos - src.rindex("\n", 0, pos)
-        return f"line {line}, column {column}"
-
-    return TOMLDecodeError(f"{msg} (at {coord_repr(src, pos)})")
+    raise TOMLDecodeError("Invalid value", src, pos)
 
 
 def is_unicode_scalar_value(codepoint: int) -> bool:
diff --git a/Lib/tomllib/_re.py b/Lib/tomllib/_re.py
index a97cab2f9db..eb8beb19747 100644
--- a/Lib/tomllib/_re.py
+++ b/Lib/tomllib/_re.py
@@ -7,9 +7,12 @@
 from datetime import date, datetime, time, timedelta, timezone, tzinfo
 from functools import lru_cache
 import re
-from typing import Any
 
-from ._types import ParseFloat
+TYPE_CHECKING = False
+if TYPE_CHECKING:
+    from typing import Any
+
+    from ._types import ParseFloat
 
 # E.g.
 # - 00:32:00.999999
@@ -84,6 +87,9 @@ def match_to_datetime(match: re.Match[str]) -> datetime | date:
     return datetime(year, month, day, hour, minute, sec, micros, tzinfo=tz)
 
 
+# No need to limit cache size. This is only ever called on input
+# that matched RE_DATETIME, so there is an implicit bound of
+# 24 (hours) * 60 (minutes) * 2 (offset direction) = 2880.
 @lru_cache(maxsize=None)
 def cached_tz(hour_str: str, minute_str: str, sign_str: str) -> timezone:
     sign = 1 if sign_str == "+" else -1
diff --git a/Lib/trace.py b/Lib/trace.py
old mode 100755
new mode 100644
index 64fc8037e35..cf8817f4383
--- a/Lib/trace.py
+++ b/Lib/trace.py
@@ -1,5 +1,3 @@
-#!/usr/bin/env python3
-
 # portions copyright 2001, Autonomous Zones Industries, Inc., all rights...
 # err...  reserved and offered to the public under the terms of the
 # Python 2.2 license.
@@ -281,14 +279,13 @@ def write_results(self, show_missing=True, summary=False, coverdir=None, *,
             n_hits, n_lines = self.write_results_file(coverpath, source,
                                                       lnotab, count, encoding)
             if summary and n_lines:
-                percent = int(100 * n_hits / n_lines)
-                sums[modulename] = n_lines, percent, modulename, filename
+                sums[modulename] = n_lines, n_hits, modulename, filename
 
         if summary and sums:
             print("lines   cov%   module   (path)")
             for m in sorted(sums):
-                n_lines, percent, modulename, filename = sums[m]
-                print("%5d   %3d%%   %s   (%s)" % sums[m])
+                n_lines, n_hits, modulename, filename = sums[m]
+                print(f"{n_lines:5d}   {n_hits/n_lines:.1%}   {modulename}   ({filename})")
 
         if self.outfile:
             # try and store counts and module info into self.outfile
@@ -402,7 +399,7 @@ def __init__(self, count=1, trace=1, countfuncs=0, countcallers=0,
         @param countfuncs true iff it should just output a list of
                      (filename, modulename, funcname,) for functions
                      that were called at least once;  This overrides
-                     `count' and `trace'
+                     'count' and 'trace'
         @param ignoremods a list of the names of modules to ignore
         @param ignoredirs a list of the names of directories to ignore
                      all of the (recursive) contents of
@@ -534,7 +531,7 @@ def globaltrace_countfuncs(self, frame, why, arg):
     def globaltrace_lt(self, frame, why, arg):
         """Handler for call events.
 
-        If the code block being entered is to be ignored, returns `None',
+        If the code block being entered is to be ignored, returns 'None',
         else returns self.localtrace.
         """
         if why == 'call':
@@ -607,7 +604,7 @@ def results(self):
 def main():
     import argparse
 
-    parser = argparse.ArgumentParser()
+    parser = argparse.ArgumentParser(color=True)
     parser.add_argument('--version', action='version', version='trace 2.0')
 
     grp = parser.add_argument_group('Main options',
diff --git a/Lib/traceback.py b/Lib/traceback.py
index 572a3177cb0..5a34a2b87b6 100644
--- a/Lib/traceback.py
+++ b/Lib/traceback.py
@@ -6,16 +6,20 @@
 import sys
 import textwrap
 import warnings
-from contextlib import suppress
+import codeop
+import keyword
+import tokenize
+import io
 import _colorize
-from _colorize import ANSIColors
+
+from contextlib import suppress
 
 __all__ = ['extract_stack', 'extract_tb', 'format_exception',
            'format_exception_only', 'format_list', 'format_stack',
            'format_tb', 'print_exc', 'format_exc', 'print_exception',
            'print_last', 'print_stack', 'print_tb', 'clear_frames',
            'FrameSummary', 'StackSummary', 'TracebackException',
-           'walk_stack', 'walk_tb']
+           'walk_stack', 'walk_tb', 'print_list']
 
 #
 # Formatting and printing lists of traceback lines.
@@ -183,15 +187,13 @@ def _format_final_exc_line(etype, value, *, insert_final_newline=True, colorize=
     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}"
+        theme = _colorize.get_theme(force_color=True).traceback
     else:
-        if value is None or not valuestr:
-            line = f"{etype}{end_char}"
-        else:
-            line = f"{etype}: {valuestr}{end_char}"
+        theme = _colorize.get_theme(force_no_color=True).traceback
+    if value is None or not valuestr:
+        line = f"{theme.type}{etype}{theme.reset}{end_char}"
+    else:
+        line = f"{theme.type}{etype}{theme.reset}: {theme.message}{valuestr}{theme.reset}{end_char}"
     return line
 
 
@@ -384,10 +386,14 @@ 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_back.f_back
-    while f is not None:
-        yield f, f.f_lineno
-        f = f.f_back
+        f = sys._getframe().f_back
+
+    def walk_stack_generator(frame):
+        while frame is not None:
+            yield frame, frame.f_lineno
+            frame = frame.f_back
+
+    return walk_stack_generator(f)
 
 
 def walk_tb(tb):
@@ -531,21 +537,22 @@ def format_frame_summary(self, frame_summary, **kwargs):
         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,
-                    )
-            )
+            theme = _colorize.get_theme(force_color=True).traceback
         else:
-            row.append('  File "{}", line {}, in {}\n'.format(
-                filename, frame_summary.lineno, frame_summary.name))
+            theme = _colorize.get_theme(force_no_color=True).traceback
+        row.append(
+            '  File {}"{}"{}, line {}{}{}, in {}{}{}\n'.format(
+                theme.filename,
+                filename,
+                theme.reset,
+                theme.line_no,
+                frame_summary.lineno,
+                theme.reset,
+                theme.frame,
+                frame_summary.name,
+                theme.reset,
+            )
+        )
         if frame_summary._dedented_lines and frame_summary._dedented_lines.strip():
             if (
                 frame_summary.colno is None or
@@ -664,11 +671,11 @@ def output_line(lineno):
                         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)
+                                colorized_line_parts.append(theme.error_highlight + "".join(char for char, _ in caret_group) + theme.reset)
+                                colorized_carets_parts.append(theme.error_highlight + "".join(caret for _, caret in caret_group) + theme.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)
+                                colorized_line_parts.append(theme.error_range + "".join(char for char, _ in caret_group) + theme.reset)
+                                colorized_carets_parts.append(theme.error_range + "".join(caret for _, caret in caret_group) + theme.reset)
                             else:
                                 colorized_line_parts.append("".join(char for char, _ in caret_group))
                                 colorized_carets_parts.append("".join(caret for _, caret in caret_group))
@@ -1086,6 +1093,7 @@ def __init__(self, exc_type, exc_value, exc_traceback, *, limit=None,
             self.end_offset = exc_value.end_offset
             self.msg = exc_value.msg
             self._is_syntax_error = True
+            self._exc_metadata = getattr(exc_value, "_metadata", None)
         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)
@@ -1269,24 +1277,120 @@ def format_exception_only(self, *, show_group=False, _depth=0, **kwargs):
             for ex in self.exceptions:
                 yield from ex.format_exception_only(show_group=show_group, _depth=_depth+1, colorize=colorize)
 
+    def _find_keyword_typos(self):
+        assert self._is_syntax_error
+        try:
+            import _suggestions
+        except ImportError:
+            _suggestions = None
+
+        # Only try to find keyword typos if there is no custom message
+        if self.msg != "invalid syntax" and "Perhaps you forgot a comma" not in self.msg:
+            return
+
+        if not self._exc_metadata:
+            return
+
+        line, offset, source = self._exc_metadata
+        end_line = int(self.lineno) if self.lineno is not None else 0
+        lines = None
+        from_filename = False
+
+        if source is None:
+            if self.filename:
+                try:
+                    with open(self.filename) as f:
+                        lines = f.read().splitlines()
+                except Exception:
+                    line, end_line, offset = 0,1,0
+                else:
+                    from_filename = True
+            lines = lines if lines is not None else self.text.splitlines()
+        else:
+            lines = source.splitlines()
+
+        error_code = lines[line -1 if line > 0 else 0:end_line]
+        error_code = textwrap.dedent('\n'.join(error_code))
+
+        # Do not continue if the source is too large
+        if len(error_code) > 1024:
+            return
+
+        error_lines = error_code.splitlines()
+        tokens = tokenize.generate_tokens(io.StringIO(error_code).readline)
+        tokens_left_to_process = 10
+        import difflib
+        for token in tokens:
+            start, end = token.start, token.end
+            if token.type != tokenize.NAME:
+                continue
+            # Only consider NAME tokens on the same line as the error
+            the_end = end_line if line == 0 else end_line + 1
+            if from_filename and token.start[0]+line != the_end:
+                continue
+            wrong_name = token.string
+            if wrong_name in keyword.kwlist:
+                continue
+
+            # Limit the number of valid tokens to consider to not spend
+            # to much time in this function
+            tokens_left_to_process -= 1
+            if tokens_left_to_process < 0:
+                break
+            # Limit the number of possible matches to try
+            max_matches = 3
+            matches = []
+            if _suggestions is not None:
+                suggestion = _suggestions._generate_suggestions(keyword.kwlist, wrong_name)
+                if suggestion:
+                    matches.append(suggestion)
+            matches.extend(difflib.get_close_matches(wrong_name, keyword.kwlist, n=max_matches, cutoff=0.5))
+            matches = matches[:max_matches]
+            for suggestion in matches:
+                if not suggestion or suggestion == wrong_name:
+                    continue
+                # Try to replace the token with the keyword
+                the_lines = error_lines.copy()
+                the_line = the_lines[start[0] - 1][:]
+                chars = list(the_line)
+                chars[token.start[1]:token.end[1]] = suggestion
+                the_lines[start[0] - 1] = ''.join(chars)
+                code = '\n'.join(the_lines)
+
+                # Check if it works
+                try:
+                    codeop.compile_command(code, symbol="exec", flags=codeop.PyCF_ONLY_AST)
+                except SyntaxError:
+                    continue
+
+                # Keep token.line but handle offsets correctly
+                self.text = token.line
+                self.offset = token.start[1] + 1
+                self.end_offset = token.end[1] + 1
+                self.lineno = start[0]
+                self.end_lineno = end[0]
+                self.msg = f"invalid syntax. Did you mean '{suggestion}'?"
+                return
+
+
     def _format_syntax_error(self, stype, **kwargs):
         """Format SyntaxError exceptions (internal helper)."""
         # Show exactly where the problem was found.
         colorize = kwargs.get("colorize", False)
+        if colorize:
+            theme = _colorize.get_theme(force_color=True).traceback
+        else:
+            theme = _colorize.get_theme(force_no_color=True).traceback
         filename_suffix = ''
         if self.lineno is not None:
-            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)
+            yield '  File {}"{}"{}, line {}{}{}\n'.format(
+                theme.filename,
+                self.filename or "<string>",
+                theme.reset,
+                theme.line_no,
+                self.lineno,
+                theme.reset,
+                )
         elif self.filename is not None:
             filename_suffix = ' ({})'.format(self.filename)
 
@@ -1295,6 +1399,9 @@ def _format_syntax_error(self, stype, **kwargs):
             # text  = "   foo\n"
             # rtext = "   foo"
             # ltext =    "foo"
+            with suppress(Exception):
+                self._find_keyword_typos()
+            text = self.text
             rtext = text.rstrip('\n')
             ltext = rtext.lstrip(' \n\f')
             spaces = len(rtext) - len(ltext)
@@ -1333,11 +1440,11 @@ def _format_syntax_error(self, stype, **kwargs):
                         # colorize from colno to end_colno
                         ltext = (
                             ltext[:colno] +
-                            ANSIColors.BOLD_RED + ltext[colno:end_colno] + ANSIColors.RESET +
+                            theme.error_highlight + ltext[colno:end_colno] + theme.reset +
                             ltext[end_colno:]
                         )
-                        start_color = ANSIColors.BOLD_RED
-                        end_color = ANSIColors.RESET
+                        start_color = theme.error_highlight
+                        end_color = theme.reset
                     yield '    {}\n'.format(ltext)
                     yield '    {}{}{}{}\n'.format(
                         "".join(caretspace),
@@ -1348,17 +1455,15 @@ def _format_syntax_error(self, stype, **kwargs):
                 else:
                     yield '    {}\n'.format(ltext)
         msg = self.msg or "<no detail available>"
-        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)
+        yield "{}{}{}: {}{}{}{}\n".format(
+            theme.type,
+            stype,
+            theme.reset,
+            theme.message,
+            msg,
+            theme.reset,
+            filename_suffix,
+        )
 
     def format(self, *, chain=True, _ctx=None, **kwargs):
         """Format the exception.
diff --git a/Lib/types.py b/Lib/types.py
index 6efac339434..fa6324fb434 100644
--- a/Lib/types.py
+++ b/Lib/types.py
@@ -274,10 +274,14 @@ def gi_running(self):
     @property
     def gi_yieldfrom(self):
         return self.__wrapped.gi_yieldfrom
+    @property
+    def gi_suspended(self):
+        return self.__wrapped.gi_suspended
     cr_code = gi_code
     cr_frame = gi_frame
     cr_running = gi_running
     cr_await = gi_yieldfrom
+    cr_suspended = gi_suspended
     def __next__(self):
         return next(self.__wrapped)
     def __iter__(self):
diff --git a/Lib/typing.py b/Lib/typing.py
index 92b78defd11..380211183a4 100644
--- a/Lib/typing.py
+++ b/Lib/typing.py
@@ -1545,9 +1545,9 @@ def __init__(self, origin, nparams, *, inst=True, name=None, defaults=()):
         self._nparams = nparams
         self._defaults = defaults
         if origin.__module__ == 'builtins':
-            self.__doc__ = f'A generic version of {origin.__qualname__}.'
+            self.__doc__ = f'Deprecated alias to {origin.__qualname__}.'
         else:
-            self.__doc__ = f'A generic version of {origin.__module__}.{origin.__qualname__}.'
+            self.__doc__ = f'Deprecated alias to {origin.__module__}.{origin.__qualname__}.'
 
     @_tp_cache
     def __getitem__(self, params):
diff --git a/Lib/urllib/request.py b/Lib/urllib/request.py
index 566b8087aec..8d7470a2273 100644
--- a/Lib/urllib/request.py
+++ b/Lib/urllib/request.py
@@ -1634,6 +1634,11 @@ def data_open(self, req):
         scheme, data = url.split(":",1)
         mediatype, data = data.split(",",1)
 
+        # Disallow control characters within mediatype.
+        if re.search(r"[\x00-\x1F\x7F]", mediatype):
+            raise ValueError(
+                "Control characters not allowed in data: mediatype")
+
         # even base64 encoded data URLs might be quoted so unquote in any case:
         data = unquote_to_bytes(data)
         if mediatype.endswith(";base64"):
diff --git a/Lib/uuid.py b/Lib/uuid.py
index 55f46eb5106..313f2fc46cb 100644
--- a/Lib/uuid.py
+++ b/Lib/uuid.py
@@ -1,8 +1,12 @@
-r"""UUID objects (universally unique identifiers) according to RFC 4122.
+r"""UUID objects (universally unique identifiers) according to RFC 4122/9562.
 
-This module provides immutable UUID objects (class UUID) and the functions
-uuid1(), uuid3(), uuid4(), uuid5() for generating version 1, 3, 4, and 5
-UUIDs as specified in RFC 4122.
+This module provides immutable UUID objects (class UUID) and functions for
+generating UUIDs corresponding to a specific UUID version as specified in
+RFC 4122/9562, e.g., uuid1() for UUID version 1, uuid3() for UUID version 3,
+and so on.
+
+Note that UUID version 2 is deliberately omitted as it is outside the scope
+of the RFC.
 
 If all you want is a unique ID, you should probably call uuid1() or uuid4().
 Note that uuid1() may compromise privacy since it creates a UUID containing
@@ -42,10 +46,19 @@
     # make a UUID from a 16-byte string
     >>> uuid.UUID(bytes=x.bytes)
     UUID('00010203-0405-0607-0809-0a0b0c0d0e0f')
+
+    # get the Nil UUID
+    >>> uuid.NIL
+    UUID('00000000-0000-0000-0000-000000000000')
+
+    # get the Max UUID
+    >>> uuid.MAX
+    UUID('ffffffff-ffff-ffff-ffff-ffffffffffff')
 """
 
 import os
 import sys
+import time
 
 from enum import Enum, _simple_enum
 
@@ -85,6 +98,19 @@ class SafeUUID:
     unknown = None
 
 
+_UINT_128_MAX = (1 << 128) - 1
+# 128-bit mask to clear the variant and version bits of a UUID integral value
+_RFC_4122_CLEARFLAGS_MASK = ~((0xf000 << 64) | (0xc000 << 48))
+# RFC 4122 variant bits and version bits to activate on a UUID integral value.
+_RFC_4122_VERSION_1_FLAGS = ((1 << 76) | (0x8000 << 48))
+_RFC_4122_VERSION_3_FLAGS = ((3 << 76) | (0x8000 << 48))
+_RFC_4122_VERSION_4_FLAGS = ((4 << 76) | (0x8000 << 48))
+_RFC_4122_VERSION_5_FLAGS = ((5 << 76) | (0x8000 << 48))
+_RFC_4122_VERSION_6_FLAGS = ((6 << 76) | (0x8000 << 48))
+_RFC_4122_VERSION_7_FLAGS = ((7 << 76) | (0x8000 << 48))
+_RFC_4122_VERSION_8_FLAGS = ((8 << 76) | (0x8000 << 48))
+
+
 class UUID:
     """Instances of the UUID class represent UUIDs as specified in RFC 4122.
     UUID objects are immutable, hashable, and usable as dictionary keys.
@@ -108,7 +134,16 @@ class UUID:
 
         fields      a tuple of the six integer fields of the UUID,
                     which are also available as six individual attributes
-                    and two derived attributes:
+                    and two derived attributes. Those attributes are not
+                    always relevant to all UUID versions:
+
+                        The 'time_*' attributes are only relevant to version 1.
+
+                        The 'clock_seq*' and 'node' attributes are only relevant
+                        to versions 1 and 6.
+
+                        The 'time' attribute is only relevant to versions 1, 6
+                        and 7.
 
             time_low                the first 32 bits of the UUID
             time_mid                the next 16 bits of the UUID
@@ -117,19 +152,20 @@ class UUID:
             clock_seq_low           the next 8 bits of the UUID
             node                    the last 48 bits of the UUID
 
-            time                    the 60-bit timestamp
+            time                    the 60-bit timestamp for UUIDv1/v6,
+                                    or the 48-bit timestamp for UUIDv7
             clock_seq               the 14-bit sequence number
 
         hex         the UUID as a 32-character hexadecimal string
 
         int         the UUID as a 128-bit integer
 
-        urn         the UUID as a URN as specified in RFC 4122
+        urn         the UUID as a URN as specified in RFC 4122/9562
 
         variant     the UUID variant (one of the constants RESERVED_NCS,
                     RFC_4122, RESERVED_MICROSOFT, or RESERVED_FUTURE)
 
-        version     the UUID version number (1 through 5, meaningful only
+        version     the UUID version number (1 through 8, meaningful only
                     when the variant is RFC_4122)
 
         is_safe     An enum indicating whether the UUID has been generated in
@@ -174,57 +210,69 @@ def __init__(self, hex=None, bytes=None, bytes_le=None, fields=None,
         if [hex, bytes, bytes_le, fields, int].count(None) != 4:
             raise TypeError('one of the hex, bytes, bytes_le, fields, '
                             'or int arguments must be given')
-        if hex is not None:
+        if int is not None:
+            pass
+        elif hex is not None:
             hex = hex.replace('urn:', '').replace('uuid:', '')
             hex = hex.strip('{}').replace('-', '')
             if len(hex) != 32:
                 raise ValueError('badly formed hexadecimal UUID string')
             int = int_(hex, 16)
-        if bytes_le is not None:
+        elif bytes_le is not None:
             if len(bytes_le) != 16:
                 raise ValueError('bytes_le is not a 16-char string')
+            assert isinstance(bytes_le, bytes_), repr(bytes_le)
             bytes = (bytes_le[4-1::-1] + bytes_le[6-1:4-1:-1] +
                      bytes_le[8-1:6-1:-1] + bytes_le[8:])
-        if bytes is not None:
+            int = int_.from_bytes(bytes)  # big endian
+        elif bytes is not None:
             if len(bytes) != 16:
                 raise ValueError('bytes is not a 16-char string')
             assert isinstance(bytes, bytes_), repr(bytes)
             int = int_.from_bytes(bytes)  # big endian
-        if fields is not None:
+        elif fields is not None:
             if len(fields) != 6:
                 raise ValueError('fields is not a 6-tuple')
             (time_low, time_mid, time_hi_version,
              clock_seq_hi_variant, clock_seq_low, node) = fields
-            if not 0 <= time_low < 1<<32:
+            if not 0 <= time_low < (1 << 32):
                 raise ValueError('field 1 out of range (need a 32-bit value)')
-            if not 0 <= time_mid < 1<<16:
+            if not 0 <= time_mid < (1 << 16):
                 raise ValueError('field 2 out of range (need a 16-bit value)')
-            if not 0 <= time_hi_version < 1<<16:
+            if not 0 <= time_hi_version < (1 << 16):
                 raise ValueError('field 3 out of range (need a 16-bit value)')
-            if not 0 <= clock_seq_hi_variant < 1<<8:
+            if not 0 <= clock_seq_hi_variant < (1 << 8):
                 raise ValueError('field 4 out of range (need an 8-bit value)')
-            if not 0 <= clock_seq_low < 1<<8:
+            if not 0 <= clock_seq_low < (1 << 8):
                 raise ValueError('field 5 out of range (need an 8-bit value)')
-            if not 0 <= node < 1<<48:
+            if not 0 <= node < (1 << 48):
                 raise ValueError('field 6 out of range (need a 48-bit value)')
             clock_seq = (clock_seq_hi_variant << 8) | clock_seq_low
             int = ((time_low << 96) | (time_mid << 80) |
                    (time_hi_version << 64) | (clock_seq << 48) | node)
-        if int is not None:
-            if not 0 <= int < 1<<128:
-                raise ValueError('int is out of range (need a 128-bit value)')
+        if not 0 <= int <= _UINT_128_MAX:
+            raise ValueError('int is out of range (need a 128-bit value)')
         if version is not None:
-            if not 1 <= version <= 5:
+            if not 1 <= version <= 8:
                 raise ValueError('illegal version number')
-            # Set the variant to RFC 4122.
-            int &= ~(0xc000 << 48)
-            int |= 0x8000 << 48
+            # clear the variant and the version number bits
+            int &= _RFC_4122_CLEARFLAGS_MASK
+            # Set the variant to RFC 4122/9562.
+            int |= 0x8000_0000_0000_0000  # (0x8000 << 48)
             # Set the version number.
-            int &= ~(0xf000 << 64)
             int |= version << 76
         object.__setattr__(self, 'int', int)
         object.__setattr__(self, 'is_safe', is_safe)
 
+    @classmethod
+    def _from_int(cls, value):
+        """Create a UUID from an integer *value*. Internal use only."""
+        assert 0 <= value <= _UINT_128_MAX, repr(value)
+        self = object.__new__(cls)
+        object.__setattr__(self, 'int', value)
+        object.__setattr__(self, 'is_safe', SafeUUID.unknown)
+        return self
+
     def __getstate__(self):
         d = {'int': self.int}
         if self.is_safe != SafeUUID.unknown:
@@ -281,9 +329,8 @@ def __setattr__(self, name, value):
         raise TypeError('UUID objects are immutable')
 
     def __str__(self):
-        hex = '%032x' % self.int
-        return '%s-%s-%s-%s-%s' % (
-            hex[:8], hex[8:12], hex[12:16], hex[16:20], hex[20:])
+        x = self.hex
+        return f'{x[:8]}-{x[8:12]}-{x[12:16]}-{x[16:20]}-{x[20:]}'
 
     @property
     def bytes(self):
@@ -322,8 +369,22 @@ def clock_seq_low(self):
 
     @property
     def time(self):
-        return (((self.time_hi_version & 0x0fff) << 48) |
-                (self.time_mid << 32) | self.time_low)
+        if self.version == 6:
+            # time_hi (32) | time_mid (16) | ver (4) | time_lo (12) | ... (64)
+            time_hi = self.int >> 96
+            time_lo = (self.int >> 64) & 0x0fff
+            return time_hi << 28 | (self.time_mid << 12) | time_lo
+        elif self.version == 7:
+            # unix_ts_ms (48) | ... (80)
+            return self.int >> 80
+        else:
+            # time_lo (32) | time_mid (16) | ver (4) | time_hi (12) | ... (64)
+            #
+            # For compatibility purposes, we do not warn or raise when the
+            # version is not 1 (timestamp is irrelevant to other versions).
+            time_hi = (self.int >> 64) & 0x0fff
+            time_lo = self.int >> 96
+            return time_hi << 48 | (self.time_mid << 32) | time_lo
 
     @property
     def clock_seq(self):
@@ -336,7 +397,7 @@ def node(self):
 
     @property
     def hex(self):
-        return '%032x' % self.int
+        return self.bytes.hex()
 
     @property
     def urn(self):
@@ -355,7 +416,7 @@ def variant(self):
 
     @property
     def version(self):
-        # The version bits are only meaningful for RFC 4122 UUIDs.
+        # The version bits are only meaningful for RFC 4122/9562 UUIDs.
         if self.variant == RFC_4122:
             return int((self.int >> 76) & 0xf)
 
@@ -374,7 +435,7 @@ def _get_command_stdout(command, *args):
         # for are actually localized, but in theory some system could do so.)
         env = dict(os.environ)
         env['LC_ALL'] = 'C'
-        # Empty strings will be quoted by popen so we should just ommit it
+        # Empty strings will be quoted by popen so we should just omit it
         if args != ('',):
             command = (executable, *args)
         else:
@@ -572,7 +633,7 @@ def _netstat_getnode():
 try:
     import _uuid
     _generate_time_safe = getattr(_uuid, "generate_time_safe", None)
-    _has_stable_extractable_node = getattr(_uuid, "has_stable_extractable_node", False)
+    _has_stable_extractable_node = _uuid.has_stable_extractable_node
     _UuidCreate = getattr(_uuid, "UuidCreate", None)
 except ImportError:
     _uuid = None
@@ -679,7 +740,6 @@ def uuid1(node=None, clock_seq=None):
         return UUID(bytes=uuid_time, is_safe=is_safe)
 
     global _last_timestamp
-    import time
     nanoseconds = time.time_ns()
     # 0x01b21dd213814000 is the number of 100-ns intervals between the
     # UUID epoch 1582-10-15 00:00:00 and the Unix epoch 1970-01-01 00:00:00.
@@ -704,24 +764,171 @@ def uuid3(namespace, name):
     """Generate a UUID from the MD5 hash of a namespace UUID and a name."""
     if isinstance(name, str):
         name = bytes(name, "utf-8")
-    from hashlib import md5
-    digest = md5(
-        namespace.bytes + name,
-        usedforsecurity=False
-    ).digest()
-    return UUID(bytes=digest[:16], version=3)
+    import hashlib
+    h = hashlib.md5(namespace.bytes + name, usedforsecurity=False)
+    int_uuid_3 = int.from_bytes(h.digest())
+    int_uuid_3 &= _RFC_4122_CLEARFLAGS_MASK
+    int_uuid_3 |= _RFC_4122_VERSION_3_FLAGS
+    return UUID._from_int(int_uuid_3)
 
 def uuid4():
     """Generate a random UUID."""
-    return UUID(bytes=os.urandom(16), version=4)
+    int_uuid_4 = int.from_bytes(os.urandom(16))
+    int_uuid_4 &= _RFC_4122_CLEARFLAGS_MASK
+    int_uuid_4 |= _RFC_4122_VERSION_4_FLAGS
+    return UUID._from_int(int_uuid_4)
 
 def uuid5(namespace, name):
     """Generate a UUID from the SHA-1 hash of a namespace UUID and a name."""
     if isinstance(name, str):
         name = bytes(name, "utf-8")
-    from hashlib import sha1
-    hash = sha1(namespace.bytes + name).digest()
-    return UUID(bytes=hash[:16], version=5)
+    import hashlib
+    h = hashlib.sha1(namespace.bytes + name, usedforsecurity=False)
+    int_uuid_5 = int.from_bytes(h.digest()[:16])
+    int_uuid_5 &= _RFC_4122_CLEARFLAGS_MASK
+    int_uuid_5 |= _RFC_4122_VERSION_5_FLAGS
+    return UUID._from_int(int_uuid_5)
+
+
+_last_timestamp_v6 = None
+
+def uuid6(node=None, clock_seq=None):
+    """Similar to :func:`uuid1` but where fields are ordered differently
+    for improved DB locality.
+
+    More precisely, given a 60-bit timestamp value as specified for UUIDv1,
+    for UUIDv6 the first 48 most significant bits are stored first, followed
+    by the 4-bit version (same position), followed by the remaining 12 bits
+    of the original 60-bit timestamp.
+    """
+    global _last_timestamp_v6
+    import time
+    nanoseconds = time.time_ns()
+    # 0x01b21dd213814000 is the number of 100-ns intervals between the
+    # UUID epoch 1582-10-15 00:00:00 and the Unix epoch 1970-01-01 00:00:00.
+    timestamp = nanoseconds // 100 + 0x01b21dd213814000
+    if _last_timestamp_v6 is not None and timestamp <= _last_timestamp_v6:
+        timestamp = _last_timestamp_v6 + 1
+    _last_timestamp_v6 = timestamp
+    if clock_seq is None:
+        import random
+        clock_seq = random.getrandbits(14)  # instead of stable storage
+    time_hi_and_mid = (timestamp >> 12) & 0xffff_ffff_ffff
+    time_lo = timestamp & 0x0fff  # keep 12 bits and clear version bits
+    clock_s = clock_seq & 0x3fff  # keep 14 bits and clear variant bits
+    if node is None:
+        node = getnode()
+    # --- 32 + 16 ---   -- 4 --   -- 12 --  -- 2 --   -- 14 ---    48
+    # time_hi_and_mid | version | time_lo | variant | clock_seq | node
+    int_uuid_6 = time_hi_and_mid << 80
+    int_uuid_6 |= time_lo << 64
+    int_uuid_6 |= clock_s << 48
+    int_uuid_6 |= node & 0xffff_ffff_ffff
+    # by construction, the variant and version bits are already cleared
+    int_uuid_6 |= _RFC_4122_VERSION_6_FLAGS
+    return UUID._from_int(int_uuid_6)
+
+
+_last_timestamp_v7 = None
+_last_counter_v7 = 0  # 42-bit counter
+
+def _uuid7_get_counter_and_tail():
+    rand = int.from_bytes(os.urandom(10))
+    # 42-bit counter with MSB set to 0
+    counter = (rand >> 32) & 0x1ff_ffff_ffff
+    # 32-bit random data
+    tail = rand & 0xffff_ffff
+    return counter, tail
+
+
+def uuid7():
+    """Generate a UUID from a Unix timestamp in milliseconds and random bits.
+
+    UUIDv7 objects feature monotonicity within a millisecond.
+    """
+    # --- 48 ---   -- 4 --   --- 12 ---   -- 2 --   --- 30 ---   - 32 -
+    # unix_ts_ms | version | counter_hi | variant | counter_lo | random
+    #
+    # 'counter = counter_hi | counter_lo' is a 42-bit counter constructed
+    # with Method 1 of RFC 9562, §6.2, and its MSB is set to 0.
+    #
+    # 'random' is a 32-bit random value regenerated for every new UUID.
+    #
+    # If multiple UUIDs are generated within the same millisecond, the LSB
+    # of 'counter' is incremented by 1. When overflowing, the timestamp is
+    # advanced and the counter is reset to a random 42-bit integer with MSB
+    # set to 0.
+
+    global _last_timestamp_v7
+    global _last_counter_v7
+
+    nanoseconds = time.time_ns()
+    timestamp_ms = nanoseconds // 1_000_000
+
+    if _last_timestamp_v7 is None or timestamp_ms > _last_timestamp_v7:
+        counter, tail = _uuid7_get_counter_and_tail()
+    else:
+        if timestamp_ms < _last_timestamp_v7:
+            timestamp_ms = _last_timestamp_v7 + 1
+        # advance the 42-bit counter
+        counter = _last_counter_v7 + 1
+        if counter > 0x3ff_ffff_ffff:
+            # advance the 48-bit timestamp
+            timestamp_ms += 1
+            counter, tail = _uuid7_get_counter_and_tail()
+        else:
+            # 32-bit random data
+            tail = int.from_bytes(os.urandom(4))
+
+    unix_ts_ms = timestamp_ms & 0xffff_ffff_ffff
+    counter_msbs = counter >> 30
+    # keep 12 counter's MSBs and clear variant bits
+    counter_hi = counter_msbs & 0x0fff
+    # keep 30 counter's LSBs and clear version bits
+    counter_lo = counter & 0x3fff_ffff
+    # ensure that the tail is always a 32-bit integer (by construction,
+    # it is already the case, but future interfaces may allow the user
+    # to specify the random tail)
+    tail &= 0xffff_ffff
+
+    int_uuid_7 = unix_ts_ms << 80
+    int_uuid_7 |= counter_hi << 64
+    int_uuid_7 |= counter_lo << 32
+    int_uuid_7 |= tail
+    # by construction, the variant and version bits are already cleared
+    int_uuid_7 |= _RFC_4122_VERSION_7_FLAGS
+    res = UUID._from_int(int_uuid_7)
+
+    # defer global update until all computations are done
+    _last_timestamp_v7 = timestamp_ms
+    _last_counter_v7 = counter
+    return res
+
+
+def uuid8(a=None, b=None, c=None):
+    """Generate a UUID from three custom blocks.
+
+    * 'a' is the first 48-bit chunk of the UUID (octets 0-5);
+    * 'b' is the mid 12-bit chunk (octets 6-7);
+    * 'c' is the last 62-bit chunk (octets 8-15).
+
+    When a value is not specified, a pseudo-random value is generated.
+    """
+    if a is None:
+        import random
+        a = random.getrandbits(48)
+    if b is None:
+        import random
+        b = random.getrandbits(12)
+    if c is None:
+        import random
+        c = random.getrandbits(62)
+    int_uuid_8 = (a & 0xffff_ffff_ffff) << 80
+    int_uuid_8 |= (b & 0xfff) << 64
+    int_uuid_8 |= c & 0x3fff_ffff_ffff_ffff
+    # by construction, the variant and version bits are already cleared
+    int_uuid_8 |= _RFC_4122_VERSION_8_FLAGS
+    return UUID._from_int(int_uuid_8)
 
 
 def main():
@@ -730,7 +937,10 @@ def main():
         "uuid1": uuid1,
         "uuid3": uuid3,
         "uuid4": uuid4,
-        "uuid5": uuid5
+        "uuid5": uuid5,
+        "uuid6": uuid6,
+        "uuid7": uuid7,
+        "uuid8": uuid8,
     }
     uuid_namespace_funcs = ("uuid3", "uuid5")
     namespaces = {
@@ -742,18 +952,24 @@ def main():
 
     import argparse
     parser = argparse.ArgumentParser(
-        description="Generates a uuid using the selected uuid function.")
-    parser.add_argument("-u", "--uuid", choices=uuid_funcs.keys(), default="uuid4",
-                        help="The function to use to generate the uuid. "
-                        "By default uuid4 function is used.")
+        formatter_class=argparse.ArgumentDefaultsHelpFormatter,
+        description="Generate a UUID using the selected UUID function.",
+        color=True,
+    )
+    parser.add_argument("-u", "--uuid",
+                        choices=uuid_funcs.keys(),
+                        default="uuid4",
+                        help="function to generate the UUID")
     parser.add_argument("-n", "--namespace",
-                        help="The namespace is a UUID, or '@ns' where 'ns' is a "
-                        "well-known predefined UUID addressed by namespace name. "
-                        "Such as @dns, @url, @oid, and @x500. "
-                        "Only required for uuid3/uuid5 functions.")
+                        choices=["any UUID", *namespaces.keys()],
+                        help="uuid3/uuid5 only: "
+                        "a UUID, or a well-known predefined UUID addressed "
+                        "by namespace name")
     parser.add_argument("-N", "--name",
-                        help="The name used as part of generating the uuid. "
-                        "Only required for uuid3/uuid5 functions.")
+                        help="uuid3/uuid5 only: "
+                        "name used as part of generating the UUID")
+    parser.add_argument("-C", "--count", metavar="NUM", type=int, default=1,
+                        help="generate NUM fresh UUIDs")
 
     args = parser.parse_args()
     uuid_func = uuid_funcs[args.uuid]
@@ -768,9 +984,11 @@ def main():
                 "Run 'python -m uuid -h' for more information."
             )
         namespace = namespaces[namespace] if namespace in namespaces else UUID(namespace)
-        print(uuid_func(namespace, name))
+        for _ in range(args.count):
+            print(uuid_func(namespace, name))
     else:
-        print(uuid_func())
+        for _ in range(args.count):
+            print(uuid_func())
 
 
 # The following standard UUIDs are for use with uuid3() or uuid5().
@@ -780,5 +998,10 @@ def main():
 NAMESPACE_OID = UUID('6ba7b812-9dad-11d1-80b4-00c04fd430c8')
 NAMESPACE_X500 = UUID('6ba7b814-9dad-11d1-80b4-00c04fd430c8')
 
+# RFC 9562 Sections 5.9 and 5.10 define the special Nil and Max UUID formats.
+
+NIL = UUID('00000000-0000-0000-0000-000000000000')
+MAX = UUID('ffffffff-ffff-ffff-ffff-ffffffffffff')
+
 if __name__ == "__main__":
     main()
diff --git a/Lib/wave.py b/Lib/wave.py
index a34af244c3e..b8476e26486 100644
--- a/Lib/wave.py
+++ b/Lib/wave.py
@@ -441,6 +441,8 @@ class Wave_write:
     _datawritten -- the size of the audio samples actually written
     """
 
+    _file = None
+
     def __init__(self, f):
         self._i_opened_the_file = None
         if isinstance(f, str):
diff --git a/Lib/weakref.py b/Lib/weakref.py
index 25b70927e29..94e4278143c 100644
--- a/Lib/weakref.py
+++ b/Lib/weakref.py
@@ -19,7 +19,7 @@
      ReferenceType,
      _remove_dead_weakref)
 
-from _weakrefset import WeakSet, _IterationGuard
+from _weakrefset import WeakSet
 
 import _collections_abc  # Import after _weakref to avoid circular import.
 import sys
@@ -105,34 +105,14 @@ def __init__(self, other=(), /, **kw):
         def remove(wr, selfref=ref(self), _atomic_removal=_remove_dead_weakref):
             self = selfref()
             if self is not None:
-                if self._iterating:
-                    self._pending_removals.append(wr.key)
-                else:
-                    # Atomic removal is necessary since this function
-                    # can be called asynchronously by the GC
-                    _atomic_removal(self.data, wr.key)
+                # Atomic removal is necessary since this function
+                # can be called asynchronously by the GC
+                _atomic_removal(self.data, wr.key)
         self._remove = remove
-        # A list of keys to be removed
-        self._pending_removals = []
-        self._iterating = set()
         self.data = {}
         self.update(other, **kw)
 
-    def _commit_removals(self, _atomic_removal=_remove_dead_weakref):
-        pop = self._pending_removals.pop
-        d = self.data
-        # We shouldn't encounter any KeyError, because this method should
-        # always be called *before* mutating the dict.
-        while True:
-            try:
-                key = pop()
-            except IndexError:
-                return
-            _atomic_removal(d, key)
-
     def __getitem__(self, key):
-        if self._pending_removals:
-            self._commit_removals()
         o = self.data[key]()
         if o is None:
             raise KeyError(key)
@@ -140,18 +120,12 @@ def __getitem__(self, key):
             return o
 
     def __delitem__(self, key):
-        if self._pending_removals:
-            self._commit_removals()
         del self.data[key]
 
     def __len__(self):
-        if self._pending_removals:
-            self._commit_removals()
         return len(self.data)
 
     def __contains__(self, key):
-        if self._pending_removals:
-            self._commit_removals()
         try:
             o = self.data[key]()
         except KeyError:
@@ -162,38 +136,28 @@ def __repr__(self):
         return "<%s at %#x>" % (self.__class__.__name__, id(self))
 
     def __setitem__(self, key, value):
-        if self._pending_removals:
-            self._commit_removals()
         self.data[key] = KeyedRef(value, self._remove, key)
 
     def copy(self):
-        if self._pending_removals:
-            self._commit_removals()
         new = WeakValueDictionary()
-        with _IterationGuard(self):
-            for key, wr in self.data.items():
-                o = wr()
-                if o is not None:
-                    new[key] = o
+        for key, wr in self.data.copy().items():
+            o = wr()
+            if o is not None:
+                new[key] = o
         return new
 
     __copy__ = copy
 
     def __deepcopy__(self, memo):
         from copy import deepcopy
-        if self._pending_removals:
-            self._commit_removals()
         new = self.__class__()
-        with _IterationGuard(self):
-            for key, wr in self.data.items():
-                o = wr()
-                if o is not None:
-                    new[deepcopy(key, memo)] = o
+        for key, wr in self.data.copy().items():
+            o = wr()
+            if o is not None:
+                new[deepcopy(key, memo)] = o
         return new
 
     def get(self, key, default=None):
-        if self._pending_removals:
-            self._commit_removals()
         try:
             wr = self.data[key]
         except KeyError:
@@ -207,21 +171,15 @@ def get(self, key, default=None):
                 return o
 
     def items(self):
-        if self._pending_removals:
-            self._commit_removals()
-        with _IterationGuard(self):
-            for k, wr in self.data.items():
-                v = wr()
-                if v is not None:
-                    yield k, v
+        for k, wr in self.data.copy().items():
+            v = wr()
+            if v is not None:
+                yield k, v
 
     def keys(self):
-        if self._pending_removals:
-            self._commit_removals()
-        with _IterationGuard(self):
-            for k, wr in self.data.items():
-                if wr() is not None:
-                    yield k
+        for k, wr in self.data.copy().items():
+            if wr() is not None:
+                yield k
 
     __iter__ = keys
 
@@ -235,23 +193,15 @@ def itervaluerefs(self):
         keep the values around longer than needed.
 
         """
-        if self._pending_removals:
-            self._commit_removals()
-        with _IterationGuard(self):
-            yield from self.data.values()
+        yield from self.data.copy().values()
 
     def values(self):
-        if self._pending_removals:
-            self._commit_removals()
-        with _IterationGuard(self):
-            for wr in self.data.values():
-                obj = wr()
-                if obj is not None:
-                    yield obj
+        for wr in self.data.copy().values():
+            obj = wr()
+            if obj is not None:
+                yield obj
 
     def popitem(self):
-        if self._pending_removals:
-            self._commit_removals()
         while True:
             key, wr = self.data.popitem()
             o = wr()
@@ -259,8 +209,6 @@ def popitem(self):
                 return key, o
 
     def pop(self, key, *args):
-        if self._pending_removals:
-            self._commit_removals()
         try:
             o = self.data.pop(key)()
         except KeyError:
@@ -279,16 +227,12 @@ def setdefault(self, key, default=None):
         except KeyError:
             o = None
         if o is None:
-            if self._pending_removals:
-                self._commit_removals()
             self.data[key] = KeyedRef(default, self._remove, key)
             return default
         else:
             return o
 
     def update(self, other=None, /, **kwargs):
-        if self._pending_removals:
-            self._commit_removals()
         d = self.data
         if other is not None:
             if not hasattr(other, "items"):
@@ -308,9 +252,7 @@ def valuerefs(self):
         keep the values around longer than needed.
 
         """
-        if self._pending_removals:
-            self._commit_removals()
-        return list(self.data.values())
+        return list(self.data.copy().values())
 
     def __ior__(self, other):
         self.update(other)
@@ -369,57 +311,22 @@ def __init__(self, dict=None):
         def remove(k, selfref=ref(self)):
             self = selfref()
             if self is not None:
-                if self._iterating:
-                    self._pending_removals.append(k)
-                else:
-                    try:
-                        del self.data[k]
-                    except KeyError:
-                        pass
+                try:
+                    del self.data[k]
+                except KeyError:
+                    pass
         self._remove = remove
-        # A list of dead weakrefs (keys to be removed)
-        self._pending_removals = []
-        self._iterating = set()
-        self._dirty_len = False
         if dict is not None:
             self.update(dict)
 
-    def _commit_removals(self):
-        # NOTE: We don't need to call this method before mutating the dict,
-        # because a dead weakref never compares equal to a live weakref,
-        # even if they happened to refer to equal objects.
-        # However, it means keys may already have been removed.
-        pop = self._pending_removals.pop
-        d = self.data
-        while True:
-            try:
-                key = pop()
-            except IndexError:
-                return
-
-            try:
-                del d[key]
-            except KeyError:
-                pass
-
-    def _scrub_removals(self):
-        d = self.data
-        self._pending_removals = [k for k in self._pending_removals if k in d]
-        self._dirty_len = False
-
     def __delitem__(self, key):
-        self._dirty_len = True
         del self.data[ref(key)]
 
     def __getitem__(self, key):
         return self.data[ref(key)]
 
     def __len__(self):
-        if self._dirty_len and self._pending_removals:
-            # self._pending_removals may still contain keys which were
-            # explicitly removed, we have to scrub them (see issue #21173).
-            self._scrub_removals()
-        return len(self.data) - len(self._pending_removals)
+        return len(self.data)
 
     def __repr__(self):
         return "<%s at %#x>" % (self.__class__.__name__, id(self))
@@ -429,11 +336,10 @@ def __setitem__(self, key, value):
 
     def copy(self):
         new = WeakKeyDictionary()
-        with _IterationGuard(self):
-            for key, value in self.data.items():
-                o = key()
-                if o is not None:
-                    new[o] = value
+        for key, value in self.data.copy().items():
+            o = key()
+            if o is not None:
+                new[o] = value
         return new
 
     __copy__ = copy
@@ -441,11 +347,10 @@ def copy(self):
     def __deepcopy__(self, memo):
         from copy import deepcopy
         new = self.__class__()
-        with _IterationGuard(self):
-            for key, value in self.data.items():
-                o = key()
-                if o is not None:
-                    new[o] = deepcopy(value, memo)
+        for key, value in self.data.copy().items():
+            o = key()
+            if o is not None:
+                new[o] = deepcopy(value, memo)
         return new
 
     def get(self, key, default=None):
@@ -459,26 +364,23 @@ def __contains__(self, key):
         return wr in self.data
 
     def items(self):
-        with _IterationGuard(self):
-            for wr, value in self.data.items():
-                key = wr()
-                if key is not None:
-                    yield key, value
+        for wr, value in self.data.copy().items():
+            key = wr()
+            if key is not None:
+                yield key, value
 
     def keys(self):
-        with _IterationGuard(self):
-            for wr in self.data:
-                obj = wr()
-                if obj is not None:
-                    yield obj
+        for wr in self.data.copy():
+            obj = wr()
+            if obj is not None:
+                yield obj
 
     __iter__ = keys
 
     def values(self):
-        with _IterationGuard(self):
-            for wr, value in self.data.items():
-                if wr() is not None:
-                    yield value
+        for wr, value in self.data.copy().items():
+            if wr() is not None:
+                yield value
 
     def keyrefs(self):
         """Return a list of weak references to the keys.
@@ -493,7 +395,6 @@ def keyrefs(self):
         return list(self.data)
 
     def popitem(self):
-        self._dirty_len = True
         while True:
             key, value = self.data.popitem()
             o = key()
@@ -501,7 +402,6 @@ def popitem(self):
                 return o, value
 
     def pop(self, key, *args):
-        self._dirty_len = True
         return self.data.pop(ref(key), *args)
 
     def setdefault(self, key, default=None):
diff --git a/Lib/xml/dom/__init__.py b/Lib/xml/dom/__init__.py
index 97cf9a64299..dd7fb996afd 100644
--- a/Lib/xml/dom/__init__.py
+++ b/Lib/xml/dom/__init__.py
@@ -137,4 +137,4 @@ class UserDataHandler:
 EMPTY_NAMESPACE = None
 EMPTY_PREFIX = None
 
-from .domreg import getDOMImplementation, registerDOMImplementation
+from .domreg import getDOMImplementation, registerDOMImplementation  # noqa: F401
diff --git a/Lib/xml/dom/minidom.py b/Lib/xml/dom/minidom.py
index db51f350ea0..16b33b90184 100644
--- a/Lib/xml/dom/minidom.py
+++ b/Lib/xml/dom/minidom.py
@@ -292,13 +292,6 @@ def _append_child(self, node):
     childNodes.append(node)
     node.parentNode = self
 
-def _in_document(node):
-    # return True iff node is part of a document tree
-    while node is not None:
-        if node.nodeType == Node.DOCUMENT_NODE:
-            return True
-        node = node.parentNode
-    return False
 
 def _write_data(writer, text, attr):
     "Writes datachars to writer."
@@ -371,6 +364,7 @@ class Attr(Node):
     def __init__(self, qName, namespaceURI=EMPTY_NAMESPACE, localName=None,
                  prefix=None):
         self.ownerElement = None
+        self.ownerDocument = None
         self._name = qName
         self.namespaceURI = namespaceURI
         self._prefix = prefix
@@ -696,6 +690,7 @@ class Element(Node):
 
     def __init__(self, tagName, namespaceURI=EMPTY_NAMESPACE, prefix=None,
                  localName=None):
+        self.ownerDocument = None
         self.parentNode = None
         self.tagName = self.nodeName = tagName
         self.prefix = prefix
@@ -1555,7 +1550,7 @@ def _clear_id_cache(node):
     if node.nodeType == Node.DOCUMENT_NODE:
         node._id_cache.clear()
         node._id_search_stack = None
-    elif _in_document(node):
+    elif node.ownerDocument:
         node.ownerDocument._id_cache.clear()
         node.ownerDocument._id_search_stack= None
 
diff --git a/Lib/xml/etree/ElementTree.py b/Lib/xml/etree/ElementTree.py
index 9bb09ab5407..dafe5b1b8a0 100644
--- a/Lib/xml/etree/ElementTree.py
+++ b/Lib/xml/etree/ElementTree.py
@@ -267,7 +267,11 @@ def remove(self, subelement):
 
         """
         # assert iselement(element)
-        self._children.remove(subelement)
+        try:
+            self._children.remove(subelement)
+        except ValueError:
+            # to align the error message with the C implementation
+            raise ValueError("Element.remove(x): element not found") from None
 
     def find(self, path, namespaces=None):
         """Find first matching element by tag name or path.
diff --git a/Lib/xml/sax/__init__.py b/Lib/xml/sax/__init__.py
index b657310207c..fe4582c6f8b 100644
--- a/Lib/xml/sax/__init__.py
+++ b/Lib/xml/sax/__init__.py
@@ -21,9 +21,9 @@
 
 from .xmlreader import InputSource
 from .handler import ContentHandler, ErrorHandler
-from ._exceptions import SAXException, SAXNotRecognizedException, \
-                        SAXParseException, SAXNotSupportedException, \
-                        SAXReaderNotAvailable
+from ._exceptions import (SAXException, SAXNotRecognizedException,
+                          SAXParseException, SAXNotSupportedException,
+                          SAXReaderNotAvailable)
 
 
 def parse(source, handler, errorHandler=ErrorHandler()):
@@ -55,7 +55,7 @@ def parseString(string, handler, errorHandler=ErrorHandler()):
 # tell modulefinder that importing sax potentially imports expatreader
 _false = 0
 if _false:
-    import xml.sax.expatreader
+    import xml.sax.expatreader    # noqa: F401
 
 import os, sys
 if not sys.flags.ignore_environment and "PY_SAX_PARSER" in os.environ:
@@ -92,3 +92,9 @@ def make_parser(parser_list=()):
 def _create_parser(parser_name):
     drv_module = __import__(parser_name,{},{},['create_parser'])
     return drv_module.create_parser()
+
+
+__all__ = ['ContentHandler', 'ErrorHandler', 'InputSource', 'SAXException',
+           'SAXNotRecognizedException', 'SAXNotSupportedException',
+           'SAXParseException', 'SAXReaderNotAvailable',
+           'default_parser_list', 'make_parser', 'parse', 'parseString']
diff --git a/Lib/xml/sax/handler.py b/Lib/xml/sax/handler.py
index e8d417e5194..3183c3fe96d 100644
--- a/Lib/xml/sax/handler.py
+++ b/Lib/xml/sax/handler.py
@@ -371,7 +371,7 @@ def startDTD(self, name, public_id, system_id):
 
         name is the name of the document element type, public_id the
         public identifier of the DTD (or None if none were supplied)
-        and system_id the system identfier of the external subset (or
+        and system_id the system identifier of the external subset (or
         None if none were supplied)."""
 
     def endDTD(self):
diff --git a/Lib/xmlrpc/server.py b/Lib/xmlrpc/server.py
index 4dddb1d10e0..3e6871157d0 100644
--- a/Lib/xmlrpc/server.py
+++ b/Lib/xmlrpc/server.py
@@ -239,7 +239,7 @@ def register_multicall_functions(self):
 
         see http://www.xmlrpc.com/discuss/msgReader$1208"""
 
-        self.funcs.update({'system.multicall' : self.system_multicall})
+        self.funcs['system.multicall'] = self.system_multicall
 
     def _marshaled_dispatch(self, data, dispatch_method = None, path = None):
         """Dispatches an XML-RPC method from marshalled (XML) data.
@@ -578,6 +578,7 @@ class SimpleXMLRPCServer(socketserver.TCPServer,
     """
 
     allow_reuse_address = True
+    allow_reuse_port = False
 
     # Warning: this is for debugging purposes only! Never set this to True in
     # production code, as will be sending out sensitive information (exception
diff --git a/Lib/zipapp.py b/Lib/zipapp.py
index 4ffacc49fa7..7a4ef96ea0f 100644
--- a/Lib/zipapp.py
+++ b/Lib/zipapp.py
@@ -134,7 +134,11 @@ def create_archive(source, target=None, interpreter=None, main=None,
     # Create the list of files to add to the archive now, in case
     # the target is being created in the source directory - we
     # don't want the target being added to itself
-    files_to_add = sorted(source.rglob('*'))
+    files_to_add = {}
+    for path in sorted(source.rglob('*')):
+        relative_path = path.relative_to(source)
+        if filter is None or filter(relative_path):
+            files_to_add[path] = relative_path
 
     # The target cannot be in the list of files to add. If it were, we'd
     # end up overwriting the source file and writing the archive into
@@ -159,10 +163,8 @@ def create_archive(source, target=None, interpreter=None, main=None,
         compression = (zipfile.ZIP_DEFLATED if compressed else
                        zipfile.ZIP_STORED)
         with zipfile.ZipFile(fd, 'w', compression=compression) as z:
-            for child in files_to_add:
-                arcname = child.relative_to(source)
-                if filter is None or filter(arcname):
-                    z.write(child, arcname.as_posix())
+            for path, relative_path in files_to_add.items():
+                z.write(path, relative_path.as_posix())
             if main_py:
                 z.writestr('__main__.py', main_py.encode('utf-8'))
 
@@ -185,7 +187,7 @@ def main(args=None):
     """
     import argparse
 
-    parser = argparse.ArgumentParser()
+    parser = argparse.ArgumentParser(color=True)
     parser.add_argument('--output', '-o', default=None,
             help="The name of the output archive. "
                  "Required if SOURCE is an archive.")
diff --git a/Lib/zipfile/__init__.py b/Lib/zipfile/__init__.py
index c01f13729e1..ac2332e5846 100644
--- a/Lib/zipfile/__init__.py
+++ b/Lib/zipfile/__init__.py
@@ -31,10 +31,15 @@
 except ImportError:
     lzma = None
 
+try:
+    from compression import zstd # We may need its compression method
+except ImportError:
+    zstd = None
+
 __all__ = ["BadZipFile", "BadZipfile", "error",
            "ZIP_STORED", "ZIP_DEFLATED", "ZIP_BZIP2", "ZIP_LZMA",
-           "is_zipfile", "ZipInfo", "ZipFile", "PyZipFile", "LargeZipFile",
-           "Path"]
+           "ZIP_ZSTANDARD", "is_zipfile", "ZipInfo", "ZipFile", "PyZipFile",
+           "LargeZipFile", "Path"]
 
 class BadZipFile(Exception):
     pass
@@ -58,12 +63,14 @@ class LargeZipFile(Exception):
 ZIP_DEFLATED = 8
 ZIP_BZIP2 = 12
 ZIP_LZMA = 14
+ZIP_ZSTANDARD = 93
 # Other ZIP compression methods not supported
 
 DEFAULT_VERSION = 20
 ZIP64_VERSION = 45
 BZIP2_VERSION = 46
 LZMA_VERSION = 63
+ZSTANDARD_VERSION = 63
 # we recognize (but not necessarily support) all features up to that version
 MAX_EXTRACT_VERSION = 63
 
@@ -227,8 +234,19 @@ def strip(cls, data, xids):
 
 def _check_zipfile(fp):
     try:
-        if _EndRecData(fp):
-            return True         # file has correct magic number
+        endrec = _EndRecData(fp)
+        if endrec:
+            if endrec[_ECD_ENTRIES_TOTAL] == 0 and endrec[_ECD_SIZE] == 0 and endrec[_ECD_OFFSET] == 0:
+                return True     # Empty zipfiles are still zipfiles
+            elif endrec[_ECD_DISK_NUMBER] == endrec[_ECD_DISK_START]:
+                # Central directory is on the same disk
+                fp.seek(sum(_handle_prepended_data(endrec)))
+                if endrec[_ECD_SIZE] >= sizeCentralDir:
+                    data = fp.read(sizeCentralDir)   # CD is where we expect it to be
+                    if len(data) == sizeCentralDir:
+                        centdir = struct.unpack(structCentralDir, data) # CD is the right size
+                        if centdir[_CD_SIGNATURE] == stringCentralDir:
+                            return True         # First central directory entry  has correct magic number
     except OSError:
         pass
     return False
@@ -241,7 +259,9 @@ def is_zipfile(filename):
     result = False
     try:
         if hasattr(filename, "read"):
+            pos = filename.tell()
             result = _check_zipfile(fp=filename)
+            filename.seek(pos)
         else:
             with open(filename, "rb") as fp:
                 result = _check_zipfile(fp)
@@ -249,6 +269,19 @@ def is_zipfile(filename):
         pass
     return result
 
+def _handle_prepended_data(endrec, debug=0):
+    size_cd = endrec[_ECD_SIZE]             # bytes in central directory
+    offset_cd = endrec[_ECD_OFFSET]         # offset of central directory
+
+    # "concat" is zero, unless zip was concatenated to another file
+    concat = endrec[_ECD_LOCATION] - size_cd - offset_cd
+
+    if debug > 2:
+        inferred = concat + offset_cd
+        print("given, inferred, offset", offset_cd, inferred, concat)
+
+    return offset_cd, concat
+
 def _EndRecData64(fpin, offset, endrec):
     """
     Read the ZIP64 end-of-archive records and use that to update endrec
@@ -519,6 +552,8 @@ def FileHeader(self, zip64=None):
             min_version = max(BZIP2_VERSION, min_version)
         elif self.compress_type == ZIP_LZMA:
             min_version = max(LZMA_VERSION, min_version)
+        elif self.compress_type == ZIP_ZSTANDARD:
+            min_version = max(ZSTANDARD_VERSION, min_version)
 
         self.extract_version = max(min_version, self.extract_version)
         self.create_version = max(min_version, self.create_version)
@@ -619,6 +654,28 @@ def from_file(cls, filename, arcname=None, *, strict_timestamps=True):
 
         return zinfo
 
+    def _for_archive(self, archive):
+        """Resolve suitable defaults from the archive.
+
+        Resolve the date_time, compression attributes, and external attributes
+        to suitable defaults as used by :method:`ZipFile.writestr`.
+
+        Return self.
+        """
+        # gh-91279: Set the SOURCE_DATE_EPOCH to a specific timestamp
+        epoch = os.environ.get('SOURCE_DATE_EPOCH')
+        get_time = int(epoch) if epoch else time.time()
+        self.date_time = time.localtime(get_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
+
     def is_dir(self):
         """Return True if this archive member is a directory."""
         if self.filename.endswith('/'):
@@ -758,6 +815,7 @@ def decompress(self, data):
     14: 'lzma',
     18: 'terse',
     19: 'lz77',
+    93: 'zstd',
     97: 'wavpack',
     98: 'ppmd',
 }
@@ -777,6 +835,10 @@ def _check_compression(compression):
         if not lzma:
             raise RuntimeError(
                 "Compression requires the (missing) lzma module")
+    elif compression == ZIP_ZSTANDARD:
+        if not zstd:
+            raise RuntimeError(
+                "Compression requires the (missing) compression.zstd module")
     else:
         raise NotImplementedError("That compression method is not supported")
 
@@ -793,6 +855,8 @@ def _get_compressor(compress_type, compresslevel=None):
     # compresslevel is ignored for ZIP_LZMA
     elif compress_type == ZIP_LZMA:
         return LZMACompressor()
+    elif compress_type == ZIP_ZSTANDARD:
+        return zstd.ZstdCompressor(level=compresslevel)
     else:
         return None
 
@@ -807,6 +871,8 @@ def _get_decompressor(compress_type):
         return bz2.BZ2Decompressor()
     elif compress_type == ZIP_LZMA:
         return LZMADecompressor()
+    elif compress_type == ZIP_ZSTANDARD:
+        return zstd.ZstdDecompressor()
     else:
         descr = compressor_names.get(compress_type)
         if descr:
@@ -1326,7 +1392,8 @@ class ZipFile:
     mode: The mode can be either read 'r', write 'w', exclusive create 'x',
           or append 'a'.
     compression: ZIP_STORED (no compression), ZIP_DEFLATED (requires zlib),
-                 ZIP_BZIP2 (requires bz2) or ZIP_LZMA (requires lzma).
+                 ZIP_BZIP2 (requires bz2), ZIP_LZMA (requires lzma), or
+                 ZIP_ZSTANDARD (requires compression.zstd).
     allowZip64: if True ZipFile will create files with ZIP64 extensions when
                 needed, otherwise it will raise an exception when this would
                 be necessary.
@@ -1335,6 +1402,9 @@ class ZipFile:
                    When using ZIP_STORED or ZIP_LZMA this keyword has no effect.
                    When using ZIP_DEFLATED integers 0 through 9 are accepted.
                    When using ZIP_BZIP2 integers 1 through 9 are accepted.
+                   When using ZIP_ZSTANDARD integers -7 though 22 are common,
+                   see the CompressionParameter enum in compression.zstd for
+                   details.
 
     """
 
@@ -1468,21 +1538,17 @@ def _RealGetContents(self):
             raise BadZipFile("File is not a zip file")
         if self.debug > 1:
             print(endrec)
-        size_cd = endrec[_ECD_SIZE]             # bytes in central directory
-        offset_cd = endrec[_ECD_OFFSET]         # offset of central directory
         self._comment = endrec[_ECD_COMMENT]    # archive comment
 
-        # "concat" is zero, unless zip was concatenated to another file
-        concat = endrec[_ECD_LOCATION] - size_cd - offset_cd
+        offset_cd, concat = _handle_prepended_data(endrec, self.debug)
 
-        if self.debug > 2:
-            inferred = concat + offset_cd
-            print("given, inferred, offset", offset_cd, inferred, concat)
         # self.start_dir:  Position of start of central directory
         self.start_dir = offset_cd + concat
+
         if self.start_dir < 0:
             raise BadZipFile("Bad offset for central directory")
         fp.seek(self.start_dir, 0)
+        size_cd = endrec[_ECD_SIZE]
         data = fp.read(size_cd)
         fp = io.BytesIO(data)
         total = 0
@@ -1771,8 +1837,8 @@ def _open_to_write(self, zinfo, force_zip64=False):
     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'. You can specify the
+           as possible. 'member' may be a filename or a ZipInfo object. You can
+           specify a different directory using 'path'. You can specify the
            password to decrypt the file using 'pwd'.
         """
         if path is None:
@@ -1784,8 +1850,8 @@ def extract(self, member, path=None, pwd=None):
 
     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
+           directory. 'path' specifies a different directory to extract to.
+           'members' is optional and must be a subset of the list returned
            by namelist(). You can specify the password to decrypt all files
            using 'pwd'.
         """
@@ -1929,18 +1995,10 @@ def writestr(self, zinfo_or_arcname, data,
         the name of the file in the archive."""
         if isinstance(data, str):
             data = data.encode("utf-8")
-        if not isinstance(zinfo_or_arcname, ZipInfo):
-            zinfo = ZipInfo(filename=zinfo_or_arcname,
-                            date_time=time.localtime(time.time())[:6])
-            zinfo.compress_type = self.compression
-            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:
-                zinfo.external_attr = 0o600 << 16     # ?rw-------
-        else:
+        if isinstance(zinfo_or_arcname, ZipInfo):
             zinfo = zinfo_or_arcname
+        else:
+            zinfo = ZipInfo(zinfo_or_arcname)._for_archive(self)
 
         if not self.fp:
             raise ValueError(
@@ -2059,6 +2117,8 @@ def _write_end_record(self):
                 min_version = max(BZIP2_VERSION, min_version)
             elif zinfo.compress_type == ZIP_LZMA:
                 min_version = max(LZMA_VERSION, min_version)
+            elif zinfo.compress_type == ZIP_ZSTANDARD:
+                min_version = max(ZSTANDARD_VERSION, min_version)
 
             extract_version = max(min_version, zinfo.extract_version)
             create_version = max(min_version, zinfo.create_version)
@@ -2301,7 +2361,7 @@ def main(args=None):
     import argparse
 
     description = 'A simple command-line interface for zipfile module.'
-    parser = argparse.ArgumentParser(description=description)
+    parser = argparse.ArgumentParser(description=description, color=True)
     group = parser.add_mutually_exclusive_group(required=True)
     group.add_argument('-l', '--list', metavar='<zipfile>',
                        help='Show listing of a zipfile')
diff --git a/Lib/zipfile/_path/__init__.py b/Lib/zipfile/_path/__init__.py
index 02f81171b4f..80f5d607731 100644
--- a/Lib/zipfile/_path/__init__.py
+++ b/Lib/zipfile/_path/__init__.py
@@ -281,7 +281,7 @@ class Path:
     >>> str(path.parent)
     'mem'
 
-    If the zipfile has no filename, such attributes are not
+    If the zipfile has no filename, such attributes are not
     valid and accessing them will raise an Exception.
 
     >>> zf.filename = None
diff --git a/Lib/zipfile/_path/glob.py b/Lib/zipfile/_path/glob.py
index 4ed74cc48d9..bd2839304b7 100644
--- a/Lib/zipfile/_path/glob.py
+++ b/Lib/zipfile/_path/glob.py
@@ -36,9 +36,9 @@ def extend(self, pattern):
         Apply '(?s:)' to create a non-matching group that
         matches newlines (valid on Unix).
 
-        Append '\Z' to imply fullmatch even when match is used.
+        Append '\z' to imply fullmatch even when match is used.
         """
-        return rf'(?s:{pattern})\Z'
+        return rf'(?s:{pattern})\z'
 
     def match_dirs(self, pattern):
         """
diff --git a/Lib/zoneinfo/__init__.py b/Lib/zoneinfo/__init__.py
index f5510ee0497..df2ae909f53 100644
--- a/Lib/zoneinfo/__init__.py
+++ b/Lib/zoneinfo/__init__.py
@@ -12,7 +12,10 @@
 
 try:
     from _zoneinfo import ZoneInfo
-except ImportError:  # pragma: nocover
+except (ImportError, AttributeError):  # pragma: nocover
+    # AttributeError: module 'datetime' has no attribute 'datetime_CAPI'.
+    # This happens when the '_datetime' module is not available and the
+    # pure Python implementation is used instead.
     from ._zoneinfo import ZoneInfo
 
 reset_tzpath = _tzpath.reset_tzpath
diff --git a/Lib/zoneinfo/_common.py b/Lib/zoneinfo/_common.py
index 03cc42149f9..59f3f0ce853 100644
--- a/Lib/zoneinfo/_common.py
+++ b/Lib/zoneinfo/_common.py
@@ -118,11 +118,10 @@ def get_abbr(idx):
         c = fobj.read(1)  # Should be \n
         assert c == b"\n", c
 
-        tz_bytes = b""
-        while (c := fobj.read(1)) != b"\n":
-            tz_bytes += c
-
-        tz_str = tz_bytes
+        line = fobj.readline()
+        if not line.endswith(b"\n"):
+            raise ValueError("Invalid TZif file: unexpected end of file")
+        tz_str = line.rstrip(b"\n")
     else:
         tz_str = None
 
diff --git a/Lib/zoneinfo/_tzpath.py b/Lib/zoneinfo/_tzpath.py
index 5db17bea045..177d32c35ef 100644
--- a/Lib/zoneinfo/_tzpath.py
+++ b/Lib/zoneinfo/_tzpath.py
@@ -13,6 +13,13 @@ def _reset_tzpath(to=None, stacklevel=4):
                 + f"not {type(tzpaths)}: {tzpaths!r}"
             )
 
+        tzpaths = [os.fspath(p) for p in tzpaths]
+        if not all(isinstance(p, str) for p in tzpaths):
+            raise TypeError(
+                "All elements of a tzpath sequence must be strings or "
+                "os.PathLike objects which convert to strings."
+            )
+
         if not all(map(os.path.isabs, tzpaths)):
             raise ValueError(_get_invalid_paths_message(tzpaths))
         base_tzpath = tzpaths
@@ -124,7 +131,8 @@ def available_timezones():
     # Start with loading from the tzdata package if it exists: this has a
     # pre-assembled list of zones that only requires opening one file.
     try:
-        with resources.files("tzdata").joinpath("zones").open("r") as f:
+        zones_file = resources.files("tzdata").joinpath("zones")
+        with zones_file.open("r", encoding="utf-8") as f:
             for zone in f:
                 zone = zone.strip()
                 if zone:
diff --git a/benches/microbenchmarks.rs b/benches/microbenchmarks.rs
index ba5dcd6c2ec..3fef2f8dd7e 100644
--- a/benches/microbenchmarks.rs
+++ b/benches/microbenchmarks.rs
@@ -134,6 +134,8 @@ fn bench_rustpython_code(group: &mut BenchmarkGroup<WallTime>, bench: &MicroBenc
             if let Some(idx) = iterations {
                 scope
                     .locals
+                    .as_ref()
+                    .expect("new_scope_with_builtins always provides locals")
                     .as_object()
                     .set_item("ITERATIONS", vm.new_pyobj(idx), vm)
                     .expect("Error adding ITERATIONS local variable");
diff --git a/crates/codegen/Cargo.toml b/crates/codegen/Cargo.toml
index ce7e8d74f59..78065962fff 100644
--- a/crates/codegen/Cargo.toml
+++ b/crates/codegen/Cargo.toml
@@ -8,6 +8,10 @@ rust-version.workspace = true
 repository.workspace = true
 license.workspace = true
 
+[features]
+default = ["std"]
+std = ["thiserror/std", "itertools/use_std"]
+
 [dependencies]
 rustpython-compiler-core = { workspace = true }
 rustpython-literal = {workspace = true }
diff --git a/crates/codegen/src/compile.rs b/crates/codegen/src/compile.rs
index b961be42517..fab31076218 100644
--- a/crates/codegen/src/compile.rs
+++ b/crates/codegen/src/compile.rs
@@ -13,7 +13,7 @@ use crate::{
     IndexMap, IndexSet, ToPythonName,
     error::{CodegenError, CodegenErrorType, InternalError, PatternUnreachableReason},
     ir::{self, BlockIdx},
-    symboltable::{self, CompilerScope, SymbolFlags, SymbolScope, SymbolTable},
+    symboltable::{self, CompilerScope, Symbol, SymbolFlags, SymbolScope, SymbolTable},
     unparse::UnparseExpr,
 };
 use alloc::borrow::Cow;
@@ -22,16 +22,14 @@ use malachite_bigint::BigInt;
 use num_complex::Complex;
 use num_traits::{Num, ToPrimitive};
 use ruff_python_ast as ast;
-use ruff_text_size::{Ranged, TextRange};
-use std::collections::HashSet;
-
+use ruff_text_size::{Ranged, TextRange, TextSize};
 use rustpython_compiler_core::{
     Mode, OneIndexed, PositionEncoding, SourceFile, SourceLocation,
     bytecode::{
         self, AnyInstruction, Arg as OpArgMarker, BinaryOperator, BuildSliceArgCount, CodeObject,
         ComparisonOperator, ConstantData, ConvertValueOparg, Instruction, IntrinsicFunction1,
-        Invert, OpArg, OpArgType, PseudoInstruction, SpecialMethod, UnpackExArgs,
-        encode_load_attr_arg, encode_load_super_attr_arg,
+        Invert, LoadAttr, LoadSuperAttr, OpArg, OpArgType, PseudoInstruction, SpecialMethod,
+        UnpackExArgs, oparg,
     },
 };
 use rustpython_wtf8::Wtf8Buf;
@@ -58,7 +56,7 @@ impl ExprExt for ast::Expr {
                 | ast::Expr::NoneLiteral(_)
                 | ast::Expr::BooleanLiteral(_)
                 | ast::Expr::EllipsisLiteral(_)
-        )
+        ) || matches!(self, ast::Expr::Tuple(ast::ExprTuple { elts, .. }) if elts.iter().all(ExprExt::is_constant))
     }
 
     fn is_constant_slice(&self) -> bool {
@@ -123,15 +121,20 @@ enum SuperCallType<'a> {
     ZeroArg,
 }
 
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+enum BuiltinGeneratorCallKind {
+    Tuple,
+    List,
+    Set,
+    All,
+    Any,
+}
+
 #[derive(Debug, Clone)]
 pub struct FBlockInfo {
     pub fb_type: FBlockType,
     pub fb_block: BlockIdx,
     pub fb_exit: BlockIdx,
-    // 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,
 }
@@ -157,6 +160,13 @@ struct Compiler {
     ctx: CompileContext,
     opts: CompileOpts,
     in_annotation: bool,
+    /// True when compiling in "single" (interactive) mode.
+    /// Expression statements at module scope emit CALL_INTRINSIC_1(Print).
+    interactive: bool,
+    /// Counter for dead-code elimination during constant folding.
+    /// When > 0, the compiler walks AST (consuming sub_tables) but emits no bytecode.
+    /// Mirrors CPython's `c_do_not_emit_bytecode`.
+    do_not_emit_bytecode: u32,
 }
 
 #[derive(Clone, Copy)]
@@ -206,6 +216,12 @@ impl CompileContext {
     }
 }
 
+/// Segment of a parsed %-format string for optimize_format_str.
+struct FormatSegment {
+    literal: String,
+    conversion: Option<oparg::ConvertValueOparg>,
+}
+
 #[derive(Debug, Clone, Copy, PartialEq)]
 enum ComprehensionType {
     Generator,
@@ -215,7 +231,7 @@ enum ComprehensionType {
 }
 
 fn validate_duplicate_params(params: &ast::Parameters) -> Result<(), CodegenErrorType> {
-    let mut seen_params = HashSet::new();
+    let mut seen_params = IndexSet::default();
     for param in params {
         let param_name = param.name().as_str();
         if !seen_params.insert(param_name) {
@@ -313,9 +329,9 @@ macro_rules! emit {
         $c.emit_arg($arg_val, |x| $enum::$op { $arg: x })
     };
 
-    // Tuple variant (e.g., Foo::B(42))
+    // Tuple variant (e.g., Foo::B(42)). Should never be reached, here for validation.
     ($c:expr, $enum:ident :: $op:ident($arg_val:expr $(,)? ) $(,)?) => {
-        $c.emit_arg($arg_val, $enum::$op)
+        panic!("No instruction should be defined as `Instruction::Foo(value)` use `Instruction::Foo { x: value }` instead")
     };
 
     // No-arg variant (e.g., Foo::C)
@@ -467,6 +483,8 @@ impl Compiler {
             },
             opts,
             in_annotation: false,
+            interactive: false,
+            do_not_emit_bytecode: 0,
         }
     }
 
@@ -497,56 +515,46 @@ impl Compiler {
         slice: &ast::Expr,
         ctx: ast::ExprContext,
     ) -> CompileResult<()> {
-        // 1. Check subscripter and index for Load context
-        // 2. VISIT value
-        // 3. Handle two-element slice specially
-        // 4. Otherwise VISIT slice and emit appropriate instruction
-
-        // For Load context, some checks are skipped for now
-        // if ctx == ast::ExprContext::Load {
-        //     check_subscripter(value);
-        //     check_index(value, slice);
-        // }
+        // Save full subscript expression range (set by compile_expression before this call)
+        let subscript_range = self.current_source_range;
 
         // VISIT(c, expr, e->v.Subscript.value)
         self.compile_expression(value)?;
 
         // Handle two-element non-constant slice with BINARY_SLICE/STORE_SLICE
-        if slice.should_use_slice_optimization() && !matches!(ctx, ast::ExprContext::Del) {
+        let use_slice_opt = matches!(ctx, ast::ExprContext::Load | ast::ExprContext::Store)
+            && slice.should_use_slice_optimization();
+        if use_slice_opt {
             match slice {
                 ast::Expr::Slice(s) => self.compile_slice_two_parts(s)?,
                 _ => unreachable!(
                     "should_use_slice_optimization should only return true for ast::Expr::Slice"
                 ),
             };
-            match ctx {
-                ast::ExprContext::Load => {
-                    emit!(self, Instruction::BinarySlice);
-                }
-                ast::ExprContext::Store => {
-                    emit!(self, Instruction::StoreSlice);
-                }
-                _ => unreachable!(),
-            }
         } else {
             // VISIT(c, expr, e->v.Subscript.slice)
             self.compile_expression(slice)?;
+        }
 
-            // Emit appropriate instruction based on context
-            match ctx {
-                ast::ExprContext::Load => emit!(
-                    self,
-                    Instruction::BinaryOp {
-                        op: BinaryOperator::Subscr
-                    }
-                ),
-                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(),
-                    )));
+        // Restore full subscript expression range before emitting
+        self.set_source_range(subscript_range);
+
+        match (use_slice_opt, ctx) {
+            (true, ast::ExprContext::Load) => emit!(self, Instruction::BinarySlice),
+            (true, ast::ExprContext::Store) => emit!(self, Instruction::StoreSlice),
+            (true, _) => unreachable!(),
+            (false, ast::ExprContext::Load) => emit!(
+                self,
+                Instruction::BinaryOp {
+                    op: BinaryOperator::Subscr
                 }
+            ),
+            (false, ast::ExprContext::Store) => emit!(self, Instruction::StoreSubscr),
+            (false, ast::ExprContext::Del) => emit!(self, Instruction::DeleteSubscr),
+            (false, ast::ExprContext::Invalid) => {
+                return Err(self.error(CodegenErrorType::SyntaxError(
+                    "Invalid expression context".to_owned(),
+                )));
             }
         }
 
@@ -576,6 +584,31 @@ impl Compiler {
             _ => n > 4,
         };
 
+        // Fold all-constant collections (>= 3 elements) regardless of size
+        if !seen_star
+            && pushed == 0
+            && n >= 3
+            && elts.iter().all(|e| e.is_constant())
+            && let Some(folded) = self.try_fold_constant_collection(elts)?
+        {
+            match collection_type {
+                CollectionType::Tuple => {
+                    self.emit_load_const(folded);
+                }
+                CollectionType::List => {
+                    emit!(self, Instruction::BuildList { count: 0 });
+                    self.emit_load_const(folded);
+                    emit!(self, Instruction::ListExtend { i: 1 });
+                }
+                CollectionType::Set => {
+                    emit!(self, Instruction::BuildSet { count: 0 });
+                    self.emit_load_const(folded);
+                    emit!(self, Instruction::SetUpdate { i: 1 });
+                }
+            }
+            return Ok(());
+        }
+
         // If no stars and not too big, compile all elements and build once
         if !seen_star && !big {
             for elt in elts {
@@ -584,13 +617,13 @@ impl Compiler {
             let total_size = n + pushed;
             match collection_type {
                 CollectionType::List => {
-                    emit!(self, Instruction::BuildList { size: total_size });
+                    emit!(self, Instruction::BuildList { count: total_size });
                 }
                 CollectionType::Set => {
-                    emit!(self, Instruction::BuildSet { size: total_size });
+                    emit!(self, Instruction::BuildSet { count: total_size });
                 }
                 CollectionType::Tuple => {
-                    emit!(self, Instruction::BuildTuple { size: total_size });
+                    emit!(self, Instruction::BuildTuple { count: total_size });
                 }
             }
             return Ok(());
@@ -606,13 +639,13 @@ impl Compiler {
                 if !sequence_built {
                     match collection_type {
                         CollectionType::List => {
-                            emit!(self, Instruction::BuildList { size: i + pushed });
+                            emit!(self, Instruction::BuildList { count: i + pushed });
                         }
                         CollectionType::Set => {
-                            emit!(self, Instruction::BuildSet { size: i + pushed });
+                            emit!(self, Instruction::BuildSet { count: i + pushed });
                         }
                         CollectionType::Tuple => {
-                            emit!(self, Instruction::BuildList { size: i + pushed });
+                            emit!(self, Instruction::BuildList { count: i + pushed });
                         }
                     }
                     sequence_built = true;
@@ -622,13 +655,13 @@ impl Compiler {
                 self.compile_expression(value)?;
                 match collection_type {
                     CollectionType::List => {
-                        emit!(self, Instruction::ListExtend { i: 0 });
+                        emit!(self, Instruction::ListExtend { i: 1 });
                     }
                     CollectionType::Set => {
-                        emit!(self, Instruction::SetUpdate { i: 0 });
+                        emit!(self, Instruction::SetUpdate { i: 1 });
                     }
                     CollectionType::Tuple => {
-                        emit!(self, Instruction::ListExtend { i: 0 });
+                        emit!(self, Instruction::ListExtend { i: 1 });
                     }
                 }
             } else {
@@ -639,13 +672,13 @@ impl Compiler {
                     // Sequence already exists, append to it
                     match collection_type {
                         CollectionType::List => {
-                            emit!(self, Instruction::ListAppend { i: 0 });
+                            emit!(self, Instruction::ListAppend { i: 1 });
                         }
                         CollectionType::Set => {
-                            emit!(self, Instruction::SetAdd { i: 0 });
+                            emit!(self, Instruction::SetAdd { i: 1 });
                         }
                         CollectionType::Tuple => {
-                            emit!(self, Instruction::ListAppend { i: 0 });
+                            emit!(self, Instruction::ListAppend { i: 1 });
                         }
                     }
                 } else {
@@ -659,13 +692,13 @@ impl Compiler {
         if !sequence_built {
             match collection_type {
                 CollectionType::List => {
-                    emit!(self, Instruction::BuildList { size: i + pushed });
+                    emit!(self, Instruction::BuildList { count: i + pushed });
                 }
                 CollectionType::Set => {
-                    emit!(self, Instruction::BuildSet { size: i + pushed });
+                    emit!(self, Instruction::BuildSet { count: i + pushed });
                 }
                 CollectionType::Tuple => {
-                    emit!(self, Instruction::BuildTuple { size: i + pushed });
+                    emit!(self, Instruction::BuildTuple { count: i + pushed });
                 }
             }
         } else if collection_type == CollectionType::Tuple {
@@ -704,37 +737,64 @@ impl Compiler {
             .expect("symbol_table_stack is empty! This is a compiler bug.")
     }
 
-    /// Get the index of a free variable.
-    fn get_free_var_index(&mut self, name: &str) -> CompileResult<u32> {
+    /// Check if a name is imported in current scope or any enclosing scope.
+    fn is_name_imported(&self, name: &str) -> bool {
+        let current = self.current_symbol_table();
+        if let Some(sym) = current.symbols.get(name) {
+            if sym.flags.contains(SymbolFlags::IMPORTED) {
+                // Module/class scope imports use plain LOAD_ATTR
+                // Function-local imports use method mode (scope is Local)
+                return !matches!(
+                    current.typ,
+                    CompilerScope::Function | CompilerScope::AsyncFunction | CompilerScope::Lambda
+                );
+            }
+            if sym.scope == SymbolScope::Local {
+                return false;
+            }
+        }
+        // Check enclosing scopes for module-level imports accessed as globals
+        self.symbol_table_stack.iter().rev().skip(1).any(|table| {
+            table
+                .symbols
+                .get(name)
+                .is_some_and(|sym| sym.flags.contains(SymbolFlags::IMPORTED))
+        })
+    }
+
+    /// Get the cell-relative index of a free variable.
+    /// Returns ncells + freevar_idx. Fixed up to localsplus index during finalize.
+    fn get_free_var_index(&mut self, name: &str) -> CompileResult<oparg::VarNum> {
         let info = self.code_stack.last_mut().unwrap();
         let idx = info
             .metadata
             .freevars
             .get_index_of(name)
             .unwrap_or_else(|| info.metadata.freevars.insert_full(name.to_owned()).0);
-        Ok((idx + info.metadata.cellvars.len()).to_u32())
+        Ok((idx + info.metadata.cellvars.len()).to_u32().into())
     }
 
-    /// Get the index of a cell variable.
-    fn get_cell_var_index(&mut self, name: &str) -> CompileResult<u32> {
+    /// Get the cell-relative index of a cell variable.
+    /// Returns cellvar_idx. Fixed up to localsplus index during finalize.
+    fn get_cell_var_index(&mut self, name: &str) -> CompileResult<oparg::VarNum> {
         let info = self.code_stack.last_mut().unwrap();
         let idx = info
             .metadata
             .cellvars
             .get_index_of(name)
             .unwrap_or_else(|| info.metadata.cellvars.insert_full(name.to_owned()).0);
-        Ok(idx.to_u32())
+        Ok(idx.to_u32().into())
     }
 
     /// Get the index of a local variable.
-    fn get_local_var_index(&mut self, name: &str) -> CompileResult<u32> {
+    fn get_local_var_index(&mut self, name: &str) -> CompileResult<oparg::VarNum> {
         let info = self.code_stack.last_mut().unwrap();
         let idx = info
             .metadata
             .varnames
             .get_index_of(name)
             .unwrap_or_else(|| info.metadata.varnames.insert_full(name.to_owned()).0);
-        Ok(idx.to_u32())
+        Ok(idx.to_u32().into())
     }
 
     /// Get the index of a global name.
@@ -960,7 +1020,7 @@ impl Compiler {
                         )));
                     }
                 };
-                self.emit_arg(idx, Instruction::LoadDeref);
+                emit!(self, Instruction::LoadDeref { i: idx });
 
                 // Load first parameter (typically 'self').
                 // Safety: can_optimize_super_call() ensures argcount > 0, and
@@ -980,12 +1040,21 @@ impl Compiler {
         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 {
-        // TODO: Implement PEP 709 inlined comprehensions properly
-        // For now, disabled to avoid stack underflow issues
-        false
+    /// Check if this is an inlined comprehension context (PEP 709).
+    /// PEP 709: Inline comprehensions in function-like scopes.
+    /// TODO: Module/class scope inlining needs more work (Cell name resolution edge cases).
+    /// Generator expressions are never inlined.
+    fn is_inlined_comprehension_context(&self, comprehension_type: ComprehensionType) -> bool {
+        if comprehension_type == ComprehensionType::Generator {
+            return false;
+        }
+        if !self.ctx.in_func() {
+            return false;
+        }
+        self.symbol_table_stack
+            .last()
+            .and_then(|t| t.sub_tables.get(t.next_sub_table))
+            .is_some_and(|st| st.comp_inlined)
     }
 
     /// Enter a new scope
@@ -1015,16 +1084,34 @@ impl Compiler {
         // Use varnames from symbol table (already collected in definition order)
         let varname_cache: IndexSet<String> = ste.varnames.iter().cloned().collect();
 
-        // Build cellvars using dictbytype (CELL scope, sorted)
+        // Build cellvars using dictbytype (CELL scope or COMP_CELL flag, sorted)
         let mut cellvar_cache = IndexSet::default();
-        let mut cell_names: Vec<_> = ste
+        // CPython ordering: parameter cells first (in parameter order),
+        // then non-parameter cells (alphabetically sorted)
+        let cell_symbols: Vec<_> = ste
             .symbols
             .iter()
-            .filter(|(_, s)| s.scope == SymbolScope::Cell)
-            .map(|(name, _)| name.clone())
+            .filter(|(_, s)| {
+                s.scope == SymbolScope::Cell || s.flags.contains(SymbolFlags::COMP_CELL)
+            })
+            .map(|(name, sym)| (name.clone(), sym.flags))
             .collect();
-        cell_names.sort();
-        for name in cell_names {
+        let mut param_cells = Vec::new();
+        let mut nonparam_cells = Vec::new();
+        for (name, flags) in cell_symbols {
+            if flags.contains(SymbolFlags::PARAMETER) {
+                param_cells.push(name);
+            } else {
+                nonparam_cells.push(name);
+            }
+        }
+        // param_cells are already in parameter order (from varname_cache insertion order)
+        param_cells.sort_by_key(|n| varname_cache.get_index_of(n.as_str()).unwrap_or(usize::MAX));
+        nonparam_cells.sort();
+        for name in param_cells {
+            cellvar_cache.insert(name);
+        }
+        for name in nonparam_cells {
             cellvar_cache.insert(name);
         }
 
@@ -1043,8 +1130,9 @@ impl Compiler {
         }
 
         // 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 {
+        if ste.has_conditional_annotations
+            && matches!(scope_type, CompilerScope::Class | CompilerScope::Module)
+        {
             cellvar_cache.insert("__conditional_annotations__".to_string());
         }
 
@@ -1087,12 +1175,20 @@ impl Compiler {
             ),
             CompilerScope::Annotation => (
                 bytecode::CodeFlags::NEWLOCALS | bytecode::CodeFlags::OPTIMIZED,
-                0,
+                1, // format is positional-only
                 1, // annotation scope takes one argument (format)
                 0,
             ),
         };
 
+        // Set CO_NESTED for scopes defined inside another function/class/etc.
+        // (i.e., not at module level)
+        let flags = if self.code_stack.len() > 1 {
+            flags | bytecode::CodeFlags::NESTED
+        } else {
+            flags
+        };
+
         // Get private name from parent scope
         let private = if !self.code_stack.is_empty() {
             self.code_stack.last().unwrap().private.clone()
@@ -1142,6 +1238,26 @@ impl Compiler {
             self.set_qualname();
         }
 
+        // Emit COPY_FREE_VARS first, then MAKE_CELL (CPython order)
+        {
+            let nfrees = self.code_stack.last().unwrap().metadata.freevars.len();
+            if nfrees > 0 {
+                emit!(
+                    self,
+                    Instruction::CopyFreeVars {
+                        n: u32::try_from(nfrees).expect("too many freevars"),
+                    }
+                );
+            }
+        }
+        {
+            let ncells = self.code_stack.last().unwrap().metadata.cellvars.len();
+            for i in 0..ncells {
+                let i_varnum: oparg::VarNum = u32::try_from(i).expect("too many cellvars").into();
+                emit!(self, Instruction::MakeCell { i: i_varnum });
+            }
+        }
+
         // Emit RESUME (handles async preamble and module lineno 0)
         // CPython: LOCATION(lineno, lineno, 0, 0), then loc.lineno = 0 for module
         self.emit_resume_for_scope(scope_type, lineno);
@@ -1152,8 +1268,10 @@ impl Compiler {
     /// Emit RESUME instruction with proper handling for async preamble and module lineno.
     /// codegen_enter_scope equivalent for RESUME emission.
     fn emit_resume_for_scope(&mut self, scope_type: CompilerScope, lineno: u32) {
-        // For async functions/coroutines, emit RETURN_GENERATOR + POP_TOP before RESUME
-        if scope_type == CompilerScope::AsyncFunction {
+        // For generators and async functions, emit RETURN_GENERATOR + POP_TOP before RESUME
+        let is_gen =
+            scope_type == CompilerScope::AsyncFunction || self.current_symbol_table().is_generator;
+        if is_gen {
             emit!(self, Instruction::ReturnGenerator);
             emit!(self, Instruction::PopTop);
         }
@@ -1172,19 +1290,20 @@ impl Compiler {
             character_offset: OneIndexed::MIN, // col = 0
         };
         let end_location = location; // end_lineno = lineno, end_col = 0
-        let except_handler = self.current_except_handler();
+        let except_handler = None;
 
         self.current_block().instructions.push(ir::InstructionInfo {
             instr: Instruction::Resume {
-                arg: OpArgMarker::marker(),
+                context: OpArgMarker::marker(),
             }
             .into(),
-            arg: OpArg(bytecode::ResumeType::AtFuncStart as u32),
+            arg: OpArg::new(oparg::ResumeLocation::AtFuncStart.into()),
             target: BlockIdx::NULL,
             location,
             end_location,
             except_handler,
             lineno_override,
+            cache_entries: 0,
         });
     }
 
@@ -1213,7 +1332,8 @@ impl Compiler {
         // enter_scope sets default values based on scope_type, but push_output
         // allows callers to specify exact values
         if let Some(info) = self.code_stack.last_mut() {
-            info.flags = flags;
+            // Preserve NESTED flag set by enter_scope
+            info.flags = flags | (info.flags & bytecode::CodeFlags::NESTED);
             info.metadata.argcount = arg_count;
             info.metadata.posonlyargcount = posonlyarg_count;
             info.metadata.kwonlyargcount = kwonlyarg_count;
@@ -1238,27 +1358,39 @@ impl Compiler {
     }
 
     /// Exit annotation scope - similar to exit_scope but restores annotation_block to parent
-    fn exit_annotation_scope(&mut self) -> CodeObject {
+    fn exit_annotation_scope(&mut self, saved_ctx: CompileContext) -> CodeObject {
         self.pop_annotation_symbol_table();
+        self.ctx = saved_ctx;
 
         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> {
+    /// Enter annotation scope using the symbol table's annotation_block.
+    /// Returns None if no annotation_block exists.
+    /// On success, returns the saved CompileContext to pass to exit_annotation_scope.
+    fn enter_annotation_scope(
+        &mut self,
+        _func_name: &str,
+    ) -> CompileResult<Option<CompileContext>> {
         if !self.push_annotation_symbol_table() {
-            return Ok(false);
+            return Ok(None);
         }
 
+        // Annotation scopes are never async (even inside async functions)
+        let saved_ctx = self.ctx;
+        self.ctx = CompileContext {
+            loop_data: None,
+            in_class: saved_ctx.in_class,
+            func: FunctionContext::Function,
+            in_async_scope: 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,
+            "__annotate__",
             CompilerScope::Annotation,
             key,
             lineno.to_u32(),
@@ -1275,26 +1407,34 @@ impl Compiler {
         // VALUE_WITH_FAKE_GLOBALS = 2 (from annotationlib.Format)
         self.emit_format_validation()?;
 
-        Ok(true)
+        Ok(Some(saved_ctx))
     }
 
     /// 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));
+        emit!(
+            self,
+            Instruction::LoadFast {
+                var_num: oparg::VarNum::from_u32(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 });
+        emit!(
+            self,
+            Instruction::CompareOp {
+                opname: ComparisonOperator::Greater
+            }
+        );
 
         // 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 { delta: body_block });
 
         // Raise NotImplementedError
         emit!(
@@ -1306,7 +1446,7 @@ impl Compiler {
         emit!(
             self,
             Instruction::RaiseVarargs {
-                kind: bytecode::RaiseKind::Raise
+                argc: bytecode::RaiseKind::Raise
             }
         );
 
@@ -1324,48 +1464,15 @@ impl Compiler {
         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,
-        )
+        self.push_fblock_full(fb_type, fb_block, fb_exit, 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();
@@ -1378,9 +1485,6 @@ impl Compiler {
             fb_type,
             fb_block,
             fb_exit,
-            fb_handler,
-            fb_stack_depth,
-            fb_preserve_lasti,
             fb_datum,
         });
         Ok(())
@@ -1410,13 +1514,13 @@ impl Compiler {
             FBlockType::ForLoop => {
                 // Pop the iterator
                 if preserve_tos {
-                    emit!(self, Instruction::Swap { index: 2 });
+                    emit!(self, Instruction::Swap { i: 2 });
                 }
                 emit!(self, Instruction::PopIter);
             }
 
             FBlockType::TryExcept => {
-                // No POP_BLOCK with exception table, just pop fblock
+                emit!(self, PseudoInstruction::PopBlock);
             }
 
             FBlockType::FinallyTry => {
@@ -1427,47 +1531,40 @@ impl Compiler {
             }
 
             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 PopExcept)
+                // codegen_unwind_fblock(FINALLY_END)
                 if preserve_tos {
-                    emit!(self, Instruction::Swap { index: 2 });
+                    emit!(self, Instruction::Swap { i: 2 });
                 }
-                emit!(self, Instruction::PopTop); // exc
+                emit!(self, Instruction::PopTop); // exc_value
                 if preserve_tos {
-                    emit!(self, Instruction::Swap { index: 2 });
+                    emit!(self, Instruction::Swap { i: 2 });
                 }
-                emit!(self, Instruction::PopExcept); // prev_exc is restored
+                emit!(self, PseudoInstruction::PopBlock);
+                emit!(self, Instruction::PopExcept);
             }
 
             FBlockType::With | FBlockType::AsyncWith => {
-                // Stack when entering: [..., __exit__, return_value (if preserve_tos)]
-                // Need to call __exit__(None, None, None)
-
+                // Stack: [..., exit_func, self_exit, return_value (if preserve_tos)]
                 emit!(self, PseudoInstruction::PopBlock);
 
-                // If preserving return value, swap it below __exit__
                 if preserve_tos {
-                    emit!(self, Instruction::Swap { index: 2 });
+                    // Rotate return value below the exit pair
+                    // [exit_func, self_exit, value] → [value, exit_func, self_exit]
+                    emit!(self, Instruction::Swap { i: 3 }); // [value, self_exit, exit_func]
+                    emit!(self, Instruction::Swap { i: 2 }); // [value, exit_func, self_exit]
                 }
-                // Stack after swap: [..., return_value, __exit__] or [..., __exit__]
 
-                // Call __exit__(None, None, None)
-                // Call protocol: [callable, self_or_null, arg1, arg2, arg3]
-                emit!(self, Instruction::PushNull);
-                // Stack: [..., __exit__, NULL]
+                // Call exit_func(self_exit, None, None, None)
                 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 });
+                emit!(self, Instruction::Call { argc: 3 });
 
                 // For async with, await the result
                 if matches!(info.fb_type, FBlockType::AsyncWith) {
-                    emit!(self, Instruction::GetAwaitable);
+                    emit!(self, Instruction::GetAwaitable { r#where: 2 });
                     self.emit_load_const(ConstantData::None);
-                    self.compile_yield_from_sequence(true)?;
+                    let _ = self.compile_yield_from_sequence(true)?;
                 }
 
                 // Pop the __exit__ result
@@ -1475,9 +1572,16 @@ impl Compiler {
             }
 
             FBlockType::HandlerCleanup => {
+                // codegen_unwind_fblock(HANDLER_CLEANUP)
+                if let FBlockDatum::ExceptionName(_) = info.fb_datum {
+                    // Named handler: PopBlock for inner SETUP_CLEANUP
+                    emit!(self, PseudoInstruction::PopBlock);
+                }
                 if preserve_tos {
-                    emit!(self, Instruction::Swap { index: 2 });
+                    emit!(self, Instruction::Swap { i: 2 });
                 }
+                // PopBlock for outer SETUP_CLEANUP (ExceptionHandler)
+                emit!(self, PseudoInstruction::PopBlock);
                 emit!(self, Instruction::PopExcept);
 
                 // If there's an exception name, clean it up
@@ -1490,7 +1594,7 @@ impl Compiler {
 
             FBlockType::PopValue => {
                 if preserve_tos {
-                    emit!(self, Instruction::Swap { index: 2 });
+                    emit!(self, Instruction::Swap { i: 2 });
                 }
                 emit!(self, Instruction::PopTop);
             }
@@ -1551,49 +1655,20 @@ impl Compiler {
                     self.unwind_fblock(&fblock_info, preserve_tos)?;
                 }
                 UnwindInfo::FinallyTry { body, fblock_idx } => {
+                    // codegen_unwind_fblock(FINALLY_TRY)
+                    emit!(self, PseudoInstruction::PopBlock);
+
                     // 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 {
-                        // Find the outer handler for exceptions during finally body execution.
-                        // CRITICAL: Only search fblocks with index < fblock_idx (= outer fblocks).
-                        // Inner FinallyTry blocks may have been restored after their unwind
-                        // processing, and we must NOT use their handlers - that would cause
-                        // the inner finally body to execute again on exception.
-                        let (handler, stack_depth, preserve_lasti) = {
-                            let code = self.code_stack.last().unwrap();
-                            let mut found = None;
-                            // Only search fblocks at indices 0..fblock_idx (outer fblocks)
-                            // After removal, fblock_idx now points to where saved_fblock was,
-                            // so indices 0..fblock_idx are the outer fblocks
-                            for i in (0..fblock_idx).rev() {
-                                let fblock = &code.fblock[i];
-                                if let Some(handler) = fblock.fb_handler {
-                                    found = Some((
-                                        Some(handler),
-                                        fblock.fb_stack_depth + 1, // +1 for return value
-                                        fblock.fb_preserve_lasti,
-                                    ));
-                                    break;
-                                }
-                            }
-                            found.unwrap_or((None, 1, false))
-                        };
-
-                        self.push_fblock_with_handler(
+                        self.push_fblock(
                             FBlockType::PopValue,
                             saved_fblock.fb_block,
                             saved_fblock.fb_block,
-                            handler,
-                            stack_depth,
-                            preserve_lasti,
                         )?;
                     }
 
@@ -1613,36 +1688,24 @@ impl Compiler {
         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 {
         self._name_inner(name, |i| &mut i.metadata.names)
     }
-    fn varname(&mut self, name: &str) -> CompileResult<bytecode::NameIdx> {
+
+    fn varname(&mut self, name: &str) -> CompileResult<oparg::VarNum> {
         // Note: __debug__ checks are now handled in symboltable phase
-        Ok(self._name_inner(name, |i| &mut i.metadata.varnames))
+        Ok(oparg::VarNum::from_u32(
+            self._name_inner(name, |i| &mut i.metadata.varnames),
+        ))
     }
+
     fn _name_inner(
         &mut self,
         name: &str,
         cache: impl FnOnce(&mut ir::CodeInfo) -> &mut IndexSet<String>,
-    ) -> bytecode::NameIdx {
+    ) -> u32 {
         let name = self.mangle(name);
         let cache = cache(self.current_code_info());
         cache
@@ -1752,8 +1815,27 @@ impl Compiler {
         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;
+
+        // Module-level __conditional_annotations__ cell
+        let has_module_cond_ann = symbol_table.has_conditional_annotations;
+        if has_module_cond_ann {
+            self.current_code_info()
+                .metadata
+                .cellvars
+                .insert("__conditional_annotations__".to_string());
+        }
+
         self.symbol_table_stack.push(symbol_table);
 
+        // Emit MAKE_CELL for module-level cells (before RESUME)
+        if has_module_cond_ann {
+            let ncells = self.code_stack.last().unwrap().metadata.cellvars.len();
+            for i in 0..ncells {
+                let i_varnum: oparg::VarNum = u32::try_from(i).expect("too many cellvars").into();
+                emit!(self, Instruction::MakeCell { i: i_varnum });
+            }
+        }
+
         self.emit_resume_for_scope(CompilerScope::Module, 1);
 
         let (doc, statements) = split_doc(&body.body, &self.opts);
@@ -1762,7 +1844,7 @@ impl Compiler {
                 value: value.into(),
             });
             let doc = self.name("__doc__");
-            emit!(self, Instruction::StoreGlobal(doc))
+            emit!(self, Instruction::StoreName { namei: doc })
         }
 
         // Handle annotations based on future_annotations flag
@@ -1776,7 +1858,7 @@ impl Compiler {
 
                 // PEP 649: Initialize __conditional_annotations__ set after __annotate__
                 if self.current_symbol_table().has_conditional_annotations {
-                    emit!(self, Instruction::BuildSet { size: 0 });
+                    emit!(self, Instruction::BuildSet { count: 0 });
                     self.store_name("__conditional_annotations__")?;
                 }
             }
@@ -1797,6 +1879,7 @@ impl Compiler {
         body: &[ast::Stmt],
         symbol_table: SymbolTable,
     ) -> CompileResult<()> {
+        self.interactive = true;
         // 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);
@@ -1814,7 +1897,7 @@ impl Compiler {
 
                 // PEP 649: Initialize __conditional_annotations__ set after __annotate__
                 if self.current_symbol_table().has_conditional_annotations {
-                    emit!(self, Instruction::BuildSet { size: 0 });
+                    emit!(self, Instruction::BuildSet { count: 0 });
                     self.store_name("__conditional_annotations__")?;
                 }
             }
@@ -1839,7 +1922,7 @@ impl Compiler {
 
             if let ast::Stmt::Expr(ast::StmtExpr { value, .. }) = &last {
                 self.compile_expression(value)?;
-                emit!(self, Instruction::Copy { index: 1_u32 });
+                emit!(self, Instruction::Copy { i: 1 });
                 emit!(
                     self,
                     Instruction::CallIntrinsic1 {
@@ -1878,7 +1961,7 @@ impl Compiler {
                 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 });
+                    emit!(self, Instruction::Copy { i: 1 });
                     self.current_block().instructions.push(store_inst);
                 }
                 _ => self.emit_load_const(ConstantData::None),
@@ -1924,7 +2007,18 @@ impl Compiler {
             .code_stack
             .last()
             .and_then(|info| info.private.as_deref());
-        symboltable::mangle_name(private, name)
+        let mangled_names = self.current_symbol_table().mangled_names.as_ref();
+        symboltable::maybe_mangle_name(private, mangled_names, name)
+    }
+
+    fn module_name_declared_global_in_nested_scope(table: &SymbolTable, name: &str) -> bool {
+        table.sub_tables.iter().any(|subtable| {
+            (!subtable.comp_inlined
+                && subtable
+                    .lookup(name)
+                    .is_some_and(|symbol| symbol.scope == SymbolScope::GlobalExplicit))
+                || Self::module_name_declared_global_in_nested_scope(subtable, name)
+        })
     }
 
     // = compiler_nameop
@@ -1975,15 +2069,17 @@ impl Compiler {
 
         // 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
+        // __class__ and __classdict__: only LOAD uses Cell (stores go to class namespace)
+        // __conditional_annotations__: both LOAD and STORE use Cell (it's a mutable set
+        // that the annotation scope accesses through the closure)
         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__")
+                && ((usage == NameUsage::Load
+                    && (name == "__class__"
+                        || name == "__classdict__"
+                        || name == "__conditional_annotations__"))
+                    || (name == "__conditional_annotations__" && usage == NameUsage::Store))
             {
                 Some(SymbolScope::Cell)
             } else {
@@ -2011,12 +2107,20 @@ impl Compiler {
             }
         };
 
+        let module_global_from_nested_scope = {
+            let current_table = self.current_symbol_table();
+            current_table.typ == CompilerScope::Module
+                && Self::module_name_declared_global_in_nested_scope(current_table, name.as_ref())
+        };
+
         // Determine operation type based on scope
         let op_type = match actual_scope {
             SymbolScope::Free => NameOp::Deref,
             SymbolScope::Cell => NameOp::Deref,
             SymbolScope::Local => {
-                if is_function_like {
+                if module_global_from_nested_scope {
+                    NameOp::Global
+                } else if is_function_like {
                     NameOp::Fast
                 } else {
                     NameOp::Name
@@ -2034,64 +2138,94 @@ impl Compiler {
                 }
             }
             SymbolScope::GlobalExplicit => NameOp::Global,
-            SymbolScope::Unknown => NameOp::Name,
+            SymbolScope::Unknown => {
+                if module_global_from_nested_scope {
+                    NameOp::Global
+                } else {
+                    NameOp::Name
+                }
+            }
         };
 
         // Generate appropriate instructions based on operation type
         match op_type {
             NameOp::Deref => {
-                let idx = match actual_scope {
+                let i = match actual_scope {
                     SymbolScope::Free => self.get_free_var_index(&name)?,
                     SymbolScope::Cell => self.get_cell_var_index(&name)?,
                     _ => unreachable!("Invalid scope for Deref operation"),
                 };
 
-                let op = match usage {
+                // Mark cell variables accessed inside inlined comprehensions as hidden
+                if self.current_code_info().in_inlined_comp {
+                    let info = self.code_stack.last_mut().unwrap();
+                    if info
+                        .metadata
+                        .fast_hidden
+                        .get(name.as_ref())
+                        .is_none_or(|&v| v)
+                    {
+                        info.metadata.fast_hidden.insert(name.to_string(), true);
+                    }
+                }
+
+                match usage {
                     NameUsage::Load => {
                         // ClassBlock (not inlined comp): LOAD_LOCALS first, then LOAD_FROM_DICT_OR_DEREF
                         if self.ctx.in_class && !self.ctx.in_func() {
                             emit!(self, Instruction::LoadLocals);
-                            Instruction::LoadFromDictOrDeref
+                            emit!(self, Instruction::LoadFromDictOrDeref { i });
                         // can_see_class_scope: LOAD_DEREF(__classdict__) first
                         } else if can_see_class_scope {
                             let classdict_idx = self.get_free_var_index("__classdict__")?;
-                            self.emit_arg(classdict_idx, Instruction::LoadDeref);
-                            Instruction::LoadFromDictOrDeref
+                            emit!(self, Instruction::LoadDeref { i: classdict_idx });
+                            emit!(self, Instruction::LoadFromDictOrDeref { i });
                         } else {
-                            Instruction::LoadDeref
+                            emit!(self, Instruction::LoadDeref { i });
                         }
                     }
-                    NameUsage::Store => Instruction::StoreDeref,
-                    NameUsage::Delete => Instruction::DeleteDeref,
+                    NameUsage::Store => emit!(self, Instruction::StoreDeref { i }),
+                    NameUsage::Delete => emit!(self, Instruction::DeleteDeref { i }),
                 };
-                self.emit_arg(idx, op);
             }
             NameOp::Fast => {
-                let idx = self.get_local_var_index(&name)?;
-                let op = match usage {
-                    NameUsage::Load => Instruction::LoadFast,
-                    NameUsage::Store => Instruction::StoreFast,
-                    NameUsage::Delete => Instruction::DeleteFast,
+                let var_num = self.get_local_var_index(&name)?;
+                // Mark variables accessed inside inlined comprehensions as hidden
+                if self.current_code_info().in_inlined_comp {
+                    let info = self.code_stack.last_mut().unwrap();
+                    if info
+                        .metadata
+                        .fast_hidden
+                        .get(name.as_ref())
+                        .is_none_or(|&v| v)
+                    {
+                        info.metadata.fast_hidden.insert(name.to_string(), true);
+                    }
+                }
+                match usage {
+                    NameUsage::Load => emit!(self, Instruction::LoadFast { var_num }),
+                    NameUsage::Store => emit!(self, Instruction::StoreFast { var_num }),
+                    NameUsage::Delete => emit!(self, Instruction::DeleteFast { var_num }),
                 };
-                self.emit_arg(idx, op);
             }
             NameOp::Global => {
-                let idx = self.get_global_name_index(&name);
-                let op = match usage {
-                    NameUsage::Load => Instruction::LoadGlobal,
-                    NameUsage::Store => Instruction::StoreGlobal,
-                    NameUsage::Delete => Instruction::DeleteGlobal,
+                let namei = self.get_global_name_index(&name);
+                match usage {
+                    NameUsage::Load => {
+                        self.emit_load_global(namei, false);
+                        return Ok(());
+                    }
+                    NameUsage::Store => emit!(self, Instruction::StoreGlobal { namei }),
+                    NameUsage::Delete => emit!(self, Instruction::DeleteGlobal { namei }),
                 };
-                self.emit_arg(idx, op);
             }
             NameOp::Name => {
-                let idx = self.get_global_name_index(&name);
-                let op = match usage {
-                    NameUsage::Load => Instruction::LoadName,
-                    NameUsage::Store => Instruction::StoreName,
-                    NameUsage::Delete => Instruction::DeleteName,
+                let namei = self.get_global_name_index(&name);
+                match usage {
+                    NameUsage::Load => emit!(self, Instruction::LoadName { namei }),
+                    NameUsage::Store => emit!(self, Instruction::StoreName { namei }),
+                    NameUsage::Delete => emit!(self, Instruction::DeleteName { namei }),
                 };
-                self.emit_arg(idx, op);
             }
             NameOp::DictOrGlobals => {
                 // PEP 649: First check classdict (from __classdict__ freevar), then globals
@@ -2100,15 +2234,15 @@ impl Compiler {
                     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);
+                        emit!(self, Instruction::LoadDeref { i: classdict_idx });
+                        emit!(self, Instruction::LoadFromDictOrGlobals { i: idx });
                     }
                     // Store/Delete in annotation scope should use Name ops
                     NameUsage::Store => {
-                        self.emit_arg(idx, Instruction::StoreName);
+                        emit!(self, Instruction::StoreName { namei: idx });
                     }
                     NameUsage::Delete => {
-                        self.emit_arg(idx, Instruction::DeleteName);
+                        emit!(self, Instruction::DeleteName { namei: idx });
                     }
                 }
             }
@@ -2119,6 +2253,7 @@ impl Compiler {
 
     fn compile_statement(&mut self, statement: &ast::Stmt) -> CompileResult<()> {
         trace!("Compiling {statement:?}");
+        let prev_source_range = self.current_source_range;
         self.set_source_range(statement.range());
 
         match &statement {
@@ -2149,14 +2284,22 @@ impl Compiler {
                         value: num_traits::Zero::zero(),
                     });
                     self.emit_load_const(ConstantData::None);
-                    let idx = self.name(&name.name);
-                    emit!(self, Instruction::ImportName { idx });
+                    let namei = self.name(&name.name);
+                    emit!(self, Instruction::ImportName { namei });
                     if let Some(alias) = &name.asname {
-                        for part in name.name.split('.').skip(1) {
-                            let idx = self.name(part);
-                            self.emit_load_attr(idx);
+                        let parts: Vec<&str> = name.name.split('.').skip(1).collect();
+                        for (i, part) in parts.iter().enumerate() {
+                            let namei = self.name(part);
+                            emit!(self, Instruction::ImportFrom { namei });
+                            if i < parts.len() - 1 {
+                                emit!(self, Instruction::Swap { i: 2 });
+                                emit!(self, Instruction::PopTop);
+                            }
+                        }
+                        self.store_name(alias.as_str())?;
+                        if !parts.is_empty() {
+                            emit!(self, Instruction::PopTop);
                         }
-                        self.store_name(alias.as_str())?
                     } else {
                         self.store_name(name.name.split('.').next().unwrap())?
                     }
@@ -2197,7 +2340,7 @@ impl Compiler {
 
                 let module_name = module.as_ref().map_or("", |s| s.as_str());
                 let module_idx = self.name(module_name);
-                emit!(self, Instruction::ImportName { idx: module_idx });
+                emit!(self, Instruction::ImportName { namei: module_idx });
 
                 if import_star {
                     // from .... import *
@@ -2207,6 +2350,7 @@ impl Compiler {
                             func: bytecode::IntrinsicFunction1::ImportStar
                         }
                     );
+                    emit!(self, Instruction::PopTop);
                 } else {
                     // from mod import a, b as c
 
@@ -2214,7 +2358,7 @@ impl Compiler {
                         let name = &name;
                         let idx = self.name(name.name.as_str());
                         // import symbol from module:
-                        emit!(self, Instruction::ImportFrom { idx });
+                        emit!(self, Instruction::ImportFrom { namei: idx });
 
                         // Store module under proper name:
                         if let Some(alias) = &name.asname {
@@ -2229,10 +2373,26 @@ impl Compiler {
                 }
             }
             ast::Stmt::Expr(ast::StmtExpr { value, .. }) => {
-                self.compile_expression(value)?;
+                // Optimize away constant expressions with no side effects.
+                // In interactive mode, always compile (to print the result).
+                let dominated_by_interactive =
+                    self.interactive && !self.ctx.in_func() && !self.ctx.in_class;
+                if !dominated_by_interactive && Self::is_const_expression(value) {
+                    // Skip compilation entirely - the expression has no side effects
+                } else {
+                    self.compile_expression(value)?;
 
-                // Pop result of stack, since we not use it:
-                emit!(self, Instruction::PopTop);
+                    if dominated_by_interactive {
+                        emit!(
+                            self,
+                            Instruction::CallIntrinsic1 {
+                                func: bytecode::IntrinsicFunction1::Print
+                            }
+                        );
+                    }
+
+                    emit!(self, Instruction::PopTop);
+                }
             }
             ast::Stmt::Global(_) | ast::Stmt::Nonlocal(_) => {
                 // Handled during symbol table construction.
@@ -2244,53 +2404,7 @@ impl Compiler {
                 ..
             }) => {
                 self.enter_conditional_block();
-                match elif_else_clauses.as_slice() {
-                    // Only if
-                    [] => {
-                        let after_block = self.new_block();
-                        self.compile_jump_if(test, false, after_block)?;
-                        self.compile_statements(body)?;
-                        self.switch_to_block(after_block);
-                    }
-                    // If, elif*, elif/else
-                    [rest @ .., tail] => {
-                        let after_block = self.new_block();
-                        let mut next_block = self.new_block();
-
-                        self.compile_jump_if(test, false, next_block)?;
-                        self.compile_statements(body)?;
-                        emit!(
-                            self,
-                            PseudoInstruction::Jump {
-                                target: after_block
-                            }
-                        );
-
-                        for clause in rest {
-                            self.switch_to_block(next_block);
-                            next_block = self.new_block();
-                            if let Some(test) = &clause.test {
-                                self.compile_jump_if(test, false, next_block)?;
-                            } else {
-                                unreachable!() // must be elif
-                            }
-                            self.compile_statements(&clause.body)?;
-                            emit!(
-                                self,
-                                PseudoInstruction::Jump {
-                                    target: after_block
-                                }
-                            );
-                        }
-
-                        self.switch_to_block(next_block);
-                        if let Some(test) = &tail.test {
-                            self.compile_jump_if(test, false, after_block)?;
-                        }
-                        self.compile_statements(&tail.body)?;
-                        self.switch_to_block(after_block);
-                    }
-                }
+                self.compile_if(test, body, elif_else_clauses)?;
                 self.leave_conditional_block();
             }
             ast::Stmt::While(ast::StmtWhile {
@@ -2330,7 +2444,11 @@ impl Compiler {
                     None => bytecode::RaiseKind::BareRaise,
                 };
                 self.set_source_range(*range);
-                emit!(self, Instruction::RaiseVarargs { kind });
+                emit!(self, Instruction::RaiseVarargs { argc: kind });
+                // Start a new block so dead code after raise doesn't
+                // corrupt the except stack in label_exception_targets
+                let dead = self.new_block();
+                self.switch_to_block(dead);
             }
             ast::Stmt::Try(ast::StmtTry {
                 body,
@@ -2396,33 +2514,42 @@ impl Compiler {
                             idx: bytecode::CommonConstant::AssertionError
                         }
                     );
-                    emit!(self, Instruction::PushNull);
-                    match msg {
-                        Some(e) => {
-                            self.compile_expression(e)?;
-                            emit!(self, Instruction::Call { nargs: 1 });
-                        }
-                        None => {
-                            emit!(self, Instruction::Call { nargs: 0 });
-                        }
+                    if let Some(e) = msg {
+                        emit!(self, Instruction::PushNull);
+                        self.compile_expression(e)?;
+                        emit!(self, Instruction::Call { argc: 1 });
                     }
                     emit!(
                         self,
                         Instruction::RaiseVarargs {
-                            kind: bytecode::RaiseKind::Raise,
+                            argc: bytecode::RaiseKind::Raise,
                         }
                     );
 
                     self.switch_to_block(after_block);
+                } else {
+                    // Optimized-out asserts still need to consume any nested
+                    // scope symbol tables they contain so later nested scopes
+                    // stay aligned with AST traversal order.
+                    self.consume_skipped_nested_scopes_in_expr(test)?;
+                    if let Some(expr) = msg {
+                        self.consume_skipped_nested_scopes_in_expr(expr)?;
+                    }
                 }
             }
             ast::Stmt::Break(_) => {
+                emit!(self, Instruction::Nop); // NOP for line tracing
                 // Unwind fblock stack until we find a loop, emitting cleanup for each fblock
                 self.compile_break_continue(statement.range(), true)?;
+                let dead = self.new_block();
+                self.switch_to_block(dead);
             }
             ast::Stmt::Continue(_) => {
+                emit!(self, Instruction::Nop); // NOP for line tracing
                 // Unwind fblock stack until we find a loop, emitting cleanup for each fblock
                 self.compile_break_continue(statement.range(), false)?;
+                let dead = self.new_block();
+                self.switch_to_block(dead);
             }
             ast::Stmt::Return(ast::StmtReturn { value, .. }) => {
                 if !self.ctx.in_func() {
@@ -2444,9 +2571,15 @@ impl Compiler {
                                 statement.range(),
                             ));
                         }
-                        self.compile_expression(v)?;
-                        // Unwind fblock stack with preserve_tos=true (preserve return value)
-                        self.unwind_fblock_stack(true, false)?;
+                        let folded_constant = self.try_fold_constant_expr(v)?;
+                        let preserve_tos = folded_constant.is_none();
+                        if preserve_tos {
+                            self.compile_expression(v)?;
+                        }
+                        self.unwind_fblock_stack(preserve_tos, false)?;
+                        if let Some(constant) = folded_constant {
+                            self.emit_load_const(constant);
+                        }
                         self.emit_return_value();
                     }
                     None => {
@@ -2455,13 +2588,15 @@ impl Compiler {
                         self.emit_return_const(ConstantData::None);
                     }
                 }
+                let dead = self.new_block();
+                self.switch_to_block(dead);
             }
             ast::Stmt::Assign(ast::StmtAssign { targets, value, .. }) => {
                 self.compile_expression(value)?;
 
                 for (i, target) in targets.iter().enumerate() {
                     if i + 1 != targets.len() {
-                        emit!(self, Instruction::Copy { index: 1_u32 });
+                        emit!(self, Instruction::Copy { i: 1 });
                     }
                     self.compile_store(target)?;
                 }
@@ -2475,14 +2610,21 @@ impl Compiler {
                 value,
                 simple,
                 ..
-            }) => self.compile_annotated_assign(target, annotation, value.as_deref(), *simple)?,
+            }) => {
+                self.compile_annotated_assign(target, annotation, value.as_deref(), *simple)?;
+                // Bare annotations in function scope emit no code; restore
+                // source range so subsequent instructions keep the correct line.
+                if value.is_none() && self.ctx.in_func() {
+                    self.set_source_range(prev_source_range);
+                }
+            }
             ast::Stmt::Delete(ast::StmtDelete { targets, .. }) => {
                 for target in targets {
                     self.compile_delete(target)?;
                 }
             }
             ast::Stmt::Pass(_) => {
-                // No need to emit any code here :)
+                emit!(self, Instruction::Nop); // NOP for line tracing
             }
             ast::Stmt::TypeAlias(ast::StmtTypeAlias {
                 name,
@@ -2507,31 +2649,99 @@ impl Compiler {
                 });
 
                 if let Some(type_params) = type_params {
-                    // For TypeAlias, we need to use push_symbol_table to properly handle the TypeAlias scope
+                    // Outer scope for TypeParams
                     self.push_symbol_table()?;
+                    let key = self.symbol_table_stack.len() - 1;
+                    let lineno = self.get_source_line_number().get().to_u32();
+                    let scope_name = format!("<generic parameters of {name_string}>");
+                    self.enter_scope(&scope_name, CompilerScope::TypeParams, key, lineno)?;
+
+                    // TypeParams scope is function-like
+                    let prev_ctx = self.ctx;
+                    self.ctx = CompileContext {
+                        loop_data: None,
+                        in_class: prev_ctx.in_class,
+                        func: FunctionContext::Function,
+                        in_async_scope: false,
+                    };
 
-                    // Compile type params and push to stack
+                    // Compile type params inside the scope
                     self.compile_type_params(type_params)?;
-                    // Stack now has [name, type_params_tuple]
+                    // Stack: [type_params_tuple]
 
-                    // Compile value expression (can now see T1, T2)
+                    // Inner closure for lazy value evaluation
+                    self.push_symbol_table()?;
+                    let inner_key = self.symbol_table_stack.len() - 1;
+                    self.enter_scope("TypeAlias", CompilerScope::TypeParams, inner_key, lineno)?;
+                    // Evaluator takes a positional-only format parameter
+                    self.current_code_info().metadata.argcount = 1;
+                    self.current_code_info().metadata.posonlyargcount = 1;
+                    self.current_code_info()
+                        .metadata
+                        .varnames
+                        .insert("format".to_owned());
+                    self.emit_format_validation()?;
                     self.compile_expression(value)?;
-                    // Stack: [name, type_params_tuple, value]
+                    emit!(self, Instruction::ReturnValue);
+                    let value_code = self.exit_scope();
+                    self.make_closure(value_code, bytecode::MakeFunctionFlags::new())?;
+                    // Stack: [type_params_tuple, value_closure]
+
+                    // Swap so unpack_sequence reverse gives correct order
+                    emit!(self, Instruction::Swap { i: 2 });
+                    // Stack: [value_closure, type_params_tuple]
+
+                    // Build tuple and return from TypeParams scope
+                    emit!(self, Instruction::BuildTuple { count: 2 });
+                    emit!(self, Instruction::ReturnValue);
+
+                    let code = self.exit_scope();
+                    self.ctx = prev_ctx;
+                    self.make_closure(code, bytecode::MakeFunctionFlags::new())?;
+                    emit!(self, Instruction::PushNull);
+                    emit!(self, Instruction::Call { argc: 0 });
 
-                    // Pop the TypeAlias scope
-                    self.pop_symbol_table();
+                    // Unpack: (value_closure, type_params_tuple)
+                    // UnpackSequence reverses → stack: [name, type_params_tuple, value_closure]
+                    emit!(self, Instruction::UnpackSequence { count: 2 });
                 } else {
                     // Push None for type_params
                     self.emit_load_const(ConstantData::None);
                     // Stack: [name, None]
 
-                    // Compile value expression
+                    // Create a closure for lazy evaluation of the value
+                    self.push_symbol_table()?;
+                    let key = self.symbol_table_stack.len() - 1;
+                    let lineno = self.get_source_line_number().get().to_u32();
+                    self.enter_scope("TypeAlias", CompilerScope::TypeParams, key, lineno)?;
+                    // Evaluator takes a positional-only format parameter
+                    self.current_code_info().metadata.argcount = 1;
+                    self.current_code_info().metadata.posonlyargcount = 1;
+                    self.current_code_info()
+                        .metadata
+                        .varnames
+                        .insert("format".to_owned());
+                    self.emit_format_validation()?;
+
+                    let prev_ctx = self.ctx;
+                    self.ctx = CompileContext {
+                        loop_data: None,
+                        in_class: prev_ctx.in_class,
+                        func: FunctionContext::Function,
+                        in_async_scope: false,
+                    };
+
                     self.compile_expression(value)?;
-                    // Stack: [name, None, value]
+                    emit!(self, Instruction::ReturnValue);
+
+                    let code = self.exit_scope();
+                    self.ctx = prev_ctx;
+                    self.make_closure(code, bytecode::MakeFunctionFlags::new())?;
+                    // Stack: [name, None, closure]
                 }
 
                 // Build tuple of 3 elements and call intrinsic
-                emit!(self, Instruction::BuildTuple { size: 3 });
+                emit!(self, Instruction::BuildTuple { count: 3 });
                 emit!(
                     self,
                     Instruction::CallIntrinsic1 {
@@ -2552,8 +2762,8 @@ impl Compiler {
             }
             ast::Expr::Attribute(ast::ExprAttribute { value, attr, .. }) => {
                 self.compile_expression(value)?;
-                let idx = self.name(attr.as_str());
-                emit!(self, Instruction::DeleteAttr { idx });
+                let namei = self.name(attr.as_str());
+                emit!(self, Instruction::DeleteAttr { namei });
             }
             ast::Expr::Subscript(ast::ExprSubscript {
                 value, slice, ctx, ..
@@ -2617,22 +2827,19 @@ impl Compiler {
     }
 
     /// Push decorators onto the stack in source order.
-    /// For @dec1 @dec2 def foo(): stack becomes [dec1, NULL, dec2, NULL]
+    /// For @dec1 @dec2 def foo(): stack becomes [dec1, dec2]
     fn prepare_decorators(&mut self, decorator_list: &[ast::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).
+    /// Apply decorators: each decorator calls the function below it.
+    /// Stack: [dec1, dec2, func] → CALL 0 → [dec1, dec2(func)] → CALL 0 → [dec1(dec2(func))]
     fn apply_decorators(&mut self, decorator_list: &[ast::Decorator]) {
         for _ in decorator_list {
-            emit!(self, Instruction::Call { nargs: 1 });
+            emit!(self, Instruction::Call { argc: 0 });
         }
     }
 
@@ -2653,11 +2860,30 @@ impl Compiler {
         // Enter scope with the type parameter name
         self.enter_scope(name, CompilerScope::TypeParams, key, lineno)?;
 
+        // Evaluator takes a positional-only format parameter
+        self.current_code_info().metadata.argcount = 1;
+        self.current_code_info().metadata.posonlyargcount = 1;
+        self.current_code_info()
+            .metadata
+            .varnames
+            .insert("format".to_owned());
+
+        self.emit_format_validation()?;
+
+        // TypeParams scope is function-like
+        let prev_ctx = self.ctx;
+        self.ctx = CompileContext {
+            loop_data: None,
+            in_class: prev_ctx.in_class,
+            func: FunctionContext::Function,
+            in_async_scope: false,
+        };
+
         // Compile the expression
         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 });
+                emit!(self, Instruction::UnpackSequence { count: 1 });
             }
         } else {
             self.compile_expression(expr)?;
@@ -2668,14 +2894,10 @@ impl Compiler {
 
         // Exit scope and create closure
         let code = self.exit_scope();
-        // Note: exit_scope already calls pop_symbol_table, so we don't need to call it again
-
-        // Create type params function with closure
-        self.make_closure(code, bytecode::MakeFunctionFlags::empty())?;
-        emit!(self, Instruction::PushNull);
+        self.ctx = prev_ctx;
 
-        // Call the function immediately
-        emit!(self, Instruction::Call { nargs: 0 });
+        // Create closure for lazy evaluation
+        self.make_closure(code, bytecode::MakeFunctionFlags::new())?;
 
         Ok(())
     }
@@ -2730,7 +2952,7 @@ impl Compiler {
                         );
                     }
 
-                    emit!(self, Instruction::Copy { index: 1_u32 });
+                    emit!(self, Instruction::Copy { i: 1 });
                     self.store_name(name.as_ref())?;
                 }
                 ast::TypeParam::ParamSpec(ast::TypeParamParamSpec { name, default, .. }) => {
@@ -2755,7 +2977,7 @@ impl Compiler {
                         );
                     }
 
-                    emit!(self, Instruction::Copy { index: 1_u32 });
+                    emit!(self, Instruction::Copy { i: 1 });
                     self.store_name(name.as_ref())?;
                 }
                 ast::TypeParam::TypeVarTuple(ast::TypeParamTypeVarTuple {
@@ -2783,7 +3005,7 @@ impl Compiler {
                         );
                     }
 
-                    emit!(self, Instruction::Copy { index: 1_u32 });
+                    emit!(self, Instruction::Copy { i: 1 });
                     self.store_name(name.as_ref())?;
                 }
             };
@@ -2791,7 +3013,7 @@ impl Compiler {
         emit!(
             self,
             Instruction::BuildTuple {
-                size: u32::try_from(type_params.len()).unwrap(),
+                count: u32::try_from(type_params.len()).unwrap(),
             }
         );
         Ok(())
@@ -2804,6 +3026,10 @@ impl Compiler {
         orelse: &[ast::Stmt],
         finalbody: &[ast::Stmt],
     ) -> CompileResult<()> {
+        if finalbody.is_empty() {
+            return self.compile_try_except_no_finally(body, handlers, orelse);
+        }
+
         let handler_block = self.new_block();
         let finally_block = self.new_block();
 
@@ -2824,25 +3050,27 @@ impl Compiler {
         // 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();
+        // Emit NOP at the try: line so LINE events fire for it
+        emit!(self, Instruction::Nop);
 
         // 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() {
-            // 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)
+            let setup_target = finally_except_block.unwrap_or(finally_block);
+            emit!(
+                self,
+                PseudoInstruction::SetupFinally {
+                    delta: setup_target
+                }
+            );
+            // Store finally body in fb_datum for unwind_fblock to compile inline
             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
             )?;
         }
@@ -2858,6 +3086,7 @@ impl Compiler {
             // Pop FinallyTry fblock BEFORE compiling orelse/finally (normal path)
             // This prevents exception table from covering the normal path
             if !finalbody.is_empty() {
+                emit!(self, PseudoInstruction::PopBlock);
                 self.pop_fblock(FBlockType::FinallyTry);
             }
 
@@ -2878,7 +3107,7 @@ impl Compiler {
             }
 
             // Jump to end (skip exception path blocks)
-            emit!(self, PseudoInstruction::Jump { target: end_block });
+            emit!(self, PseudoInstruction::Jump { delta: end_block });
 
             if let Some(finally_except) = finally_except_block {
                 // Restore sub_tables for exception path compilation
@@ -2889,22 +3118,13 @@ impl Compiler {
                 }
 
                 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)
+                // SETUP_CLEANUP before PUSH_EXC_INFO
+                if let Some(cleanup) = finally_cleanup_block {
+                    emit!(self, PseudoInstruction::SetupCleanup { delta: cleanup });
+                }
                 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.push_fblock(FBlockType::FinallyEnd, cleanup, cleanup)?;
                 }
                 self.compile_statements(finalbody)?;
 
@@ -2912,6 +3132,7 @@ impl Compiler {
                 // 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() {
+                    emit!(self, PseudoInstruction::PopBlock);
                     self.pop_fblock(FBlockType::FinallyEnd);
                 }
 
@@ -2919,28 +3140,18 @@ impl Compiler {
                 // 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::Copy { i: 2 });
                 emit!(self, Instruction::PopExcept);
 
                 // RERAISE 0: re-raise the original exception to outer handler
-                emit!(
-                    self,
-                    Instruction::RaiseVarargs {
-                        kind: bytecode::RaiseKind::ReraiseFromStack
-                    }
-                );
+                emit!(self, Instruction::Reraise { depth: 0 });
             }
 
             if let Some(cleanup) = finally_cleanup_block {
                 self.switch_to_block(cleanup);
-                emit!(self, Instruction::Copy { index: 3_u32 });
+                emit!(self, Instruction::Copy { i: 3 });
                 emit!(self, Instruction::PopExcept);
-                emit!(
-                    self,
-                    Instruction::RaiseVarargs {
-                        kind: bytecode::RaiseKind::ReraiseFromStack
-                    }
-                );
+                emit!(self, Instruction::Reraise { depth: 1 });
             }
 
             self.switch_to_block(end_block);
@@ -2948,20 +3159,17 @@ impl Compiler {
         }
 
         // 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
-        )?;
+        emit!(
+            self,
+            PseudoInstruction::SetupFinally {
+                delta: handler_block
+            }
+        );
+        self.push_fblock(FBlockType::TryExcept, handler_block, handler_block)?;
         self.compile_statements(body)?;
+        emit!(self, PseudoInstruction::PopBlock);
         self.pop_fblock(FBlockType::TryExcept);
-        // No PopBlock emit - exception table handles this
-        emit!(self, PseudoInstruction::Jump { target: else_block });
+        emit!(self, PseudoInstruction::Jump { delta: else_block });
 
         // except handlers:
         self.switch_to_block(handler_block);
@@ -2972,14 +3180,13 @@ impl Compiler {
         // 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
-        )?;
+        emit!(
+            self,
+            PseudoInstruction::SetupCleanup {
+                delta: cleanup_block
+            }
+        );
+        self.push_fblock(FBlockType::ExceptionHandler, cleanup_block, cleanup_block)?;
 
         // Exception is on top of stack now, pushed by unwind_blocks
         // PUSH_EXC_INFO transforms [exc] -> [prev_exc, exc] for PopExcept
@@ -2989,8 +3196,10 @@ impl Compiler {
                 type_,
                 name,
                 body,
+                range: handler_range,
                 ..
             }) = &handler;
+            self.set_source_range(*handler_range);
             let next_handler = self.new_block();
 
             // If we gave a typ,
@@ -3005,7 +3214,7 @@ impl Compiler {
                 emit!(
                     self,
                     Instruction::PopJumpIfFalse {
-                        target: next_handler
+                        delta: next_handler
                     }
                 );
                 // Stack: [prev_exc, exc]
@@ -3027,16 +3236,12 @@ impl Compiler {
             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(
+                emit!(self, PseudoInstruction::SetupCleanup { delta: cleanup_end });
+                self.push_fblock_full(
                     FBlockType::HandlerCleanup,
                     cleanup_end,
                     cleanup_end,
-                    Some(cleanup_end),
-                    handler_depth,
-                    true, // preserve_lasti for RERAISE
+                    FBlockDatum::ExceptionName(name.as_ref().unwrap().as_str().to_owned()),
                 )?;
                 Some(cleanup_end)
             } else {
@@ -3049,21 +3254,24 @@ impl Compiler {
             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,
-                PseudoInstruction::Jump {
-                    target: handler_normal_exit,
-                }
-            );
+            // PopBlock for inner SETUP_CLEANUP (named handler only)
+            if handler_cleanup_block.is_some() {
+                emit!(self, PseudoInstruction::PopBlock);
+            }
 
             // 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 {
+                let handler_normal_exit = self.new_block();
+                emit!(
+                    self,
+                    PseudoInstruction::JumpNoInterrupt {
+                        delta: handler_normal_exit,
+                    }
+                );
+
                 self.switch_to_block(cleanup_end);
                 if let Some(alias) = name {
                     // name = None; del name; before RERAISE
@@ -3075,20 +3283,15 @@ impl Compiler {
                 // 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::RaiseVarargs {
-                        kind: bytecode::RaiseKind::ReraiseFromStack,
-                    }
-                );
-            }
+                emit!(self, Instruction::Reraise { depth: 1 });
 
-            // Switch to normal exit block - this is where handler body success continues
-            self.switch_to_block(handler_normal_exit);
+                // Switch to normal exit block - this is where handler body success continues
+                self.switch_to_block(handler_normal_exit);
+            }
 
+            // PopBlock for outer SETUP_CLEANUP (ExceptionHandler)
+            emit!(self, PseudoInstruction::PopBlock);
             // 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::PopExcept);
 
@@ -3100,24 +3303,24 @@ impl Compiler {
                 self.compile_name(alias.as_str(), NameUsage::Delete)?;
             }
 
+            // Pop FinallyTry block before jumping to finally body.
+            // The else_block path also pops this; both paths must agree
+            // on the except stack when entering finally_block.
+            if !finalbody.is_empty() {
+                emit!(self, PseudoInstruction::PopBlock);
+            }
+
             // Jump to finally block
             emit!(
                 self,
-                PseudoInstruction::Jump {
-                    target: finally_block,
+                PseudoInstruction::JumpNoInterrupt {
+                    delta: finally_block,
                 }
             );
 
             // 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
-            )?;
+            self.push_fblock(FBlockType::ExceptionHandler, cleanup_block, cleanup_block)?;
 
             // Emit a new label for the next handler
             self.switch_to_block(next_handler);
@@ -3128,12 +3331,7 @@ impl Compiler {
         // 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::RaiseVarargs {
-                kind: bytecode::RaiseKind::ReraiseFromStack,
-            }
-        );
+        emit!(self, Instruction::Reraise { depth: 0 });
 
         // Pop EXCEPTION_HANDLER fblock
         // Pop after RERAISE so the instruction has the correct exception handler
@@ -3145,14 +3343,9 @@ 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::Copy { index: 3_u32 });
+        emit!(self, Instruction::Copy { i: 3 });
         emit!(self, Instruction::PopExcept);
-        emit!(
-            self,
-            Instruction::RaiseVarargs {
-                kind: bytecode::RaiseKind::ReraiseFromStack,
-            }
-        );
+        emit!(self, Instruction::Reraise { depth: 1 });
 
         // We successfully ran the try block:
         // else:
@@ -3161,7 +3354,7 @@ impl Compiler {
 
         // Pop the FinallyTry fblock before jumping to finally
         if !finalbody.is_empty() {
-            // No PopBlock/EnterFinally emit - exception table handles this
+            emit!(self, PseudoInstruction::PopBlock);
             self.pop_fblock(FBlockType::FinallyTry);
         }
 
@@ -3178,7 +3371,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, PseudoInstruction::Jump { target: end_block });
+            emit!(self, PseudoInstruction::Jump { delta: end_block });
         }
 
         // finally (exception path)
@@ -3196,23 +3389,13 @@ impl Compiler {
 
             // 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,
-                )?;
+                emit!(self, PseudoInstruction::SetupCleanup { delta: cleanup });
             }
-
-            // PUSH_EXC_INFO: [lasti, exc] -> [lasti, prev_exc, exc]
-            // Sets exc as current VM exception, saves prev_exc for restoration
             emit!(self, Instruction::PushExcInfo);
+            if let Some(cleanup) = finally_cleanup_block {
+                self.push_fblock(FBlockType::FinallyEnd, cleanup, cleanup)?;
+            }
 
             // Run finally body
             self.compile_statements(finalbody)?;
@@ -3221,6 +3404,7 @@ impl Compiler {
             // 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() {
+                emit!(self, PseudoInstruction::PopBlock);
                 self.pop_fblock(FBlockType::FinallyEnd);
             }
 
@@ -3228,17 +3412,12 @@ impl Compiler {
             // 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::Copy { i: 2 });
             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,
-                Instruction::RaiseVarargs {
-                    kind: bytecode::RaiseKind::ReraiseFromStack,
-                }
-            );
+            emit!(self, Instruction::Reraise { depth: 0 });
         }
 
         // finally cleanup block
@@ -3247,16 +3426,11 @@ 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::Copy { index: 3_u32 });
+            emit!(self, Instruction::Copy { i: 3 });
             // POP_EXCEPT: restore prev_exc as current exception
             emit!(self, Instruction::PopExcept);
             // RERAISE 1: reraise with lasti from stack
-            emit!(
-                self,
-                Instruction::RaiseVarargs {
-                    kind: bytecode::RaiseKind::ReraiseFromStack,
-                }
-            );
+            emit!(self, Instruction::Reraise { depth: 1 });
         }
 
         // End block - continuation point after try-finally
@@ -3266,6 +3440,175 @@ impl Compiler {
         Ok(())
     }
 
+    fn compile_try_except_no_finally(
+        &mut self,
+        body: &[ast::Stmt],
+        handlers: &[ast::ExceptHandler],
+        orelse: &[ast::Stmt],
+    ) -> CompileResult<()> {
+        let handler_block = self.new_block();
+        let cleanup_block = self.new_block();
+        let orelse_block = self.new_block();
+        let end_block = self.new_block();
+
+        emit!(self, Instruction::Nop);
+        emit!(
+            self,
+            PseudoInstruction::SetupFinally {
+                delta: handler_block
+            }
+        );
+
+        self.push_fblock(FBlockType::TryExcept, handler_block, handler_block)?;
+        self.compile_statements(body)?;
+        self.pop_fblock(FBlockType::TryExcept);
+        emit!(self, PseudoInstruction::PopBlock);
+        self.set_no_location();
+        emit!(
+            self,
+            PseudoInstruction::JumpNoInterrupt {
+                delta: orelse_block
+            }
+        );
+        self.set_no_location();
+
+        self.switch_to_block(handler_block);
+        emit!(
+            self,
+            PseudoInstruction::SetupCleanup {
+                delta: cleanup_block
+            }
+        );
+        self.set_no_location();
+        emit!(self, Instruction::PushExcInfo);
+        self.set_no_location();
+        self.push_fblock(FBlockType::ExceptionHandler, cleanup_block, cleanup_block)?;
+
+        for handler in handlers {
+            let ast::ExceptHandler::ExceptHandler(ast::ExceptHandlerExceptHandler {
+                type_,
+                name,
+                body,
+                range: handler_range,
+                ..
+            }) = handler;
+            self.set_source_range(*handler_range);
+            let next_handler = self.new_block();
+
+            if let Some(exc_type) = type_ {
+                self.compile_expression(exc_type)?;
+                emit!(self, Instruction::CheckExcMatch);
+                emit!(
+                    self,
+                    Instruction::PopJumpIfFalse {
+                        delta: next_handler
+                    }
+                );
+            }
+
+            if let Some(alias) = name {
+                self.store_name(alias.as_str())?;
+
+                let cleanup_end = self.new_block();
+                let handler_normal_exit = self.new_block();
+                emit!(self, PseudoInstruction::SetupCleanup { delta: cleanup_end });
+                self.push_fblock_full(
+                    FBlockType::HandlerCleanup,
+                    cleanup_end,
+                    cleanup_end,
+                    FBlockDatum::ExceptionName(alias.as_str().to_owned()),
+                )?;
+
+                self.compile_statements(body)?;
+
+                self.pop_fblock(FBlockType::HandlerCleanup);
+                emit!(self, PseudoInstruction::PopBlock);
+                self.set_no_location();
+                emit!(
+                    self,
+                    PseudoInstruction::JumpNoInterrupt {
+                        delta: handler_normal_exit
+                    }
+                );
+                self.set_no_location();
+
+                self.switch_to_block(cleanup_end);
+                self.emit_load_const(ConstantData::None);
+                self.set_no_location();
+                self.store_name(alias.as_str())?;
+                self.set_no_location();
+                self.compile_name(alias.as_str(), NameUsage::Delete)?;
+                self.set_no_location();
+                emit!(self, Instruction::Reraise { depth: 1 });
+                self.set_no_location();
+
+                self.switch_to_block(handler_normal_exit);
+                emit!(self, PseudoInstruction::PopBlock);
+                self.set_no_location();
+                self.pop_fblock(FBlockType::ExceptionHandler);
+                emit!(self, Instruction::PopExcept);
+                self.set_no_location();
+
+                self.emit_load_const(ConstantData::None);
+                self.set_no_location();
+                self.store_name(alias.as_str())?;
+                self.set_no_location();
+                self.compile_name(alias.as_str(), NameUsage::Delete)?;
+                self.set_no_location();
+
+                emit!(
+                    self,
+                    PseudoInstruction::JumpNoInterrupt { delta: end_block }
+                );
+                self.set_no_location();
+            } else {
+                emit!(self, Instruction::PopTop);
+                self.push_fblock(FBlockType::HandlerCleanup, end_block, end_block)?;
+
+                self.compile_statements(body)?;
+
+                self.pop_fblock(FBlockType::HandlerCleanup);
+                emit!(self, PseudoInstruction::PopBlock);
+                self.set_no_location();
+                self.pop_fblock(FBlockType::ExceptionHandler);
+                emit!(self, Instruction::PopExcept);
+                self.set_no_location();
+                emit!(
+                    self,
+                    PseudoInstruction::JumpNoInterrupt { delta: end_block }
+                );
+                self.set_no_location();
+            }
+
+            self.push_fblock(FBlockType::ExceptionHandler, cleanup_block, cleanup_block)?;
+            self.switch_to_block(next_handler);
+        }
+
+        emit!(self, Instruction::Reraise { depth: 0 });
+        self.set_no_location();
+        self.pop_fblock(FBlockType::ExceptionHandler);
+
+        self.switch_to_block(cleanup_block);
+        emit!(self, Instruction::Copy { i: 3 });
+        self.set_no_location();
+        emit!(self, Instruction::PopExcept);
+        self.set_no_location();
+        emit!(self, Instruction::Reraise { depth: 1 });
+        self.set_no_location();
+
+        self.switch_to_block(orelse_block);
+        self.set_no_location();
+        self.compile_statements(orelse)?;
+        emit!(
+            self,
+            PseudoInstruction::JumpNoInterrupt { delta: end_block }
+        );
+        self.set_no_location();
+
+        self.switch_to_block(end_block);
+        Ok(())
+    }
+
     fn compile_try_star_except(
         &mut self,
         body: &[ast::Stmt],
@@ -3281,37 +3624,44 @@ impl Compiler {
         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();
+        let finally_cleanup_block = if !finalbody.is_empty() {
+            Some(self.new_block())
+        } else {
+            None
+        };
+        let exit_block = self.new_block();
 
-        // Calculate the stack depth at this point (for exception table)
-        let current_depth = self.handler_stack_depth();
+        // Emit NOP at the try: line so LINE events fire for it
+        emit!(self, Instruction::Nop);
 
         // Push fblock with handler info for exception table generation
         if !finalbody.is_empty() {
-            // No SetupFinally emit - exception table handles this
-            self.push_fblock_with_handler(
+            emit!(
+                self,
+                PseudoInstruction::SetupFinally {
+                    delta: finally_block
+                }
+            );
+            self.push_fblock_full(
                 FBlockType::FinallyTry,
                 finally_block,
                 finally_block,
-                Some(finally_block),
-                current_depth, // stack depth for exception handler
-                true,          // preserve lasti for finally
+                FBlockDatum::FinallyBody(finalbody.to_vec()),
             )?;
         }
 
         // 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
-        )?;
+        emit!(
+            self,
+            PseudoInstruction::SetupFinally {
+                delta: handler_block
+            }
+        );
+        self.push_fblock(FBlockType::TryExcept, handler_block, handler_block)?;
         self.compile_statements(body)?;
+        emit!(self, PseudoInstruction::PopBlock);
         self.pop_fblock(FBlockType::TryExcept);
-        emit!(self, PseudoInstruction::Jump { target: else_block });
+        emit!(self, PseudoInstruction::Jump { delta: else_block });
 
         // Exception handler entry
         self.switch_to_block(handler_block);
@@ -3326,7 +3676,26 @@ impl Compiler {
         let eg_dummy2 = self.new_block();
         self.push_fblock(FBlockType::ExceptionGroupHandler, eg_dummy1, eg_dummy2)?;
 
+        // Initialize handler stack before the loop
+        // BUILD_LIST 0 + COPY 2 to set up [prev_exc, orig, list, rest]
+        emit!(self, Instruction::BuildList { count: 0 });
+        // Stack: [prev_exc, exc, []]
+        emit!(self, Instruction::Copy { i: 2 });
+        // Stack: [prev_exc, orig, list, rest]
+
         let n = handlers.len();
+        if n == 0 {
+            // Empty handlers (invalid AST) - append rest to list and proceed
+            // Stack: [prev_exc, orig, list, rest]
+            emit!(self, Instruction::ListAppend { i: 1 });
+            // Stack: [prev_exc, orig, list]
+            emit!(
+                self,
+                PseudoInstruction::Jump {
+                    delta: reraise_star_block
+                }
+            );
+        }
         for (i, handler) in handlers.iter().enumerate() {
             let ast::ExceptHandler::ExceptHandler(ast::ExceptHandlerExceptHandler {
                 type_,
@@ -3338,17 +3707,6 @@ 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::Copy { 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
@@ -3374,11 +3732,11 @@ impl Compiler {
 
             // ADDOP_I(c, loc, COPY, 1);
             // ADDOP_JUMP(c, loc, POP_JUMP_IF_NONE, no_match);
-            emit!(self, Instruction::Copy { index: 1 });
+            emit!(self, Instruction::Copy { i: 1 });
             emit!(
                 self,
                 Instruction::PopJumpIfNone {
-                    target: no_match_block
+                    delta: no_match_block
                 }
             );
 
@@ -3396,21 +3754,28 @@ impl Compiler {
             // Stack: [prev_exc, orig, list, new_rest]
 
             // 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(
+            emit!(
+                self,
+                PseudoInstruction::SetupCleanup {
+                    delta: handler_except_block
+                }
+            );
+            self.push_fblock_full(
                 FBlockType::HandlerCleanup,
                 next_block,
                 end_block,
-                Some(handler_except_block),
-                eg_handler_depth,
-                true, // preserve lasti
+                if let Some(alias) = name {
+                    FBlockDatum::ExceptionName(alias.as_str().to_owned())
+                } else {
+                    FBlockDatum::None
+                },
             )?;
 
             // Execute handler body
             self.compile_statements(body)?;
 
             // Handler body completed normally
+            emit!(self, PseudoInstruction::PopBlock);
             self.pop_fblock(FBlockType::HandlerCleanup);
 
             // Cleanup name binding
@@ -3421,7 +3786,7 @@ impl Compiler {
             }
 
             // Jump to next handler
-            emit!(self, PseudoInstruction::Jump { target: next_block });
+            emit!(self, PseudoInstruction::Jump { delta: next_block });
 
             // Handler raised an exception (cleanup_end label)
             self.switch_to_block(handler_except_block);
@@ -3440,7 +3805,7 @@ impl Compiler {
             // 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 });
+            emit!(self, Instruction::ListAppend { i: 3 });
             // Stack: [prev_exc, orig, list, new_rest, lasti]
 
             // POP_TOP - pop lasti
@@ -3449,7 +3814,7 @@ impl Compiler {
 
             // JUMP except_with_error
             // We directly JUMP to next_block since no_match_block falls through to it
-            emit!(self, PseudoInstruction::Jump { target: next_block });
+            emit!(self, PseudoInstruction::Jump { delta: next_block });
 
             // No match - pop match (None)
             self.switch_to_block(no_match_block);
@@ -3469,12 +3834,12 @@ impl Compiler {
                 // 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 });
+                emit!(self, Instruction::ListAppend { i: 1 });
                 // Stack: [prev_exc, orig, list]
                 emit!(
                     self,
                     PseudoInstruction::Jump {
-                        target: reraise_star_block
+                        delta: reraise_star_block
                     }
                 );
             }
@@ -3498,14 +3863,14 @@ impl Compiler {
         // Stack: [prev_exc, result]
 
         // COPY 1
-        emit!(self, Instruction::Copy { index: 1 });
+        emit!(self, Instruction::Copy { i: 1 });
         // Stack: [prev_exc, result, result]
 
         // POP_JUMP_IF_NOT_NONE reraise
         emit!(
             self,
             Instruction::PopJumpIfNotNone {
-                target: reraise_block
+                delta: reraise_block
             }
         );
         // Stack: [prev_exc, result]
@@ -3521,10 +3886,11 @@ impl Compiler {
         // Stack: []
 
         if !finalbody.is_empty() {
+            emit!(self, PseudoInstruction::PopBlock);
             self.pop_fblock(FBlockType::FinallyTry);
         }
 
-        emit!(self, PseudoInstruction::Jump { target: end_block });
+        emit!(self, PseudoInstruction::Jump { delta: end_block });
 
         // Reraise the result
         self.switch_to_block(reraise_block);
@@ -3532,7 +3898,7 @@ impl Compiler {
 
         // POP_BLOCK - no-op for us
         // SWAP 2
-        emit!(self, Instruction::Swap { index: 2 });
+        emit!(self, Instruction::Swap { i: 2 });
         // Stack: [result, prev_exc]
 
         // POP_EXCEPT
@@ -3548,13 +3914,17 @@ impl Compiler {
         // 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(
+            emit!(
+                self,
+                PseudoInstruction::SetupFinally {
+                    delta: finally_block
+                }
+            );
+            self.push_fblock_full(
                 FBlockType::FinallyTry,
                 finally_block,
                 finally_block,
-                Some(finally_block),
-                current_depth,
-                true,
+                FBlockDatum::FinallyBody(finalbody.to_vec()),
             )?;
         }
         self.switch_to_block(else_block);
@@ -3562,18 +3932,58 @@ impl Compiler {
 
         if !finalbody.is_empty() {
             // Pop the FinallyTry fblock we just pushed for the else path
+            emit!(self, PseudoInstruction::PopBlock);
             self.pop_fblock(FBlockType::FinallyTry);
         }
 
-        emit!(self, PseudoInstruction::Jump { target: end_block });
+        emit!(self, PseudoInstruction::Jump { delta: end_block });
 
         self.switch_to_block(end_block);
         if !finalbody.is_empty() {
+            // Snapshot sub_tables before first finally compilation
+            let sub_table_cursor = self.symbol_table_stack.last().map(|t| t.next_sub_table);
+
+            // Compile finally body inline for normal path
+            self.compile_statements(finalbody)?;
+            emit!(self, PseudoInstruction::Jump { delta: exit_block });
+
+            // Restore sub_tables for exception path compilation
+            if let Some(cursor) = sub_table_cursor
+                && let Some(current_table) = self.symbol_table_stack.last_mut()
+            {
+                current_table.next_sub_table = cursor;
+            }
+
+            // Exception handler path
             self.switch_to_block(finally_block);
+            emit!(self, Instruction::PushExcInfo);
+
+            if let Some(cleanup) = finally_cleanup_block {
+                emit!(self, PseudoInstruction::SetupCleanup { delta: cleanup });
+                self.push_fblock(FBlockType::FinallyEnd, cleanup, cleanup)?;
+            }
+
             self.compile_statements(finalbody)?;
-            // No EndFinally emit - exception table handles this
+
+            if finally_cleanup_block.is_some() {
+                emit!(self, PseudoInstruction::PopBlock);
+                self.pop_fblock(FBlockType::FinallyEnd);
+            }
+
+            emit!(self, Instruction::Copy { i: 2 });
+            emit!(self, Instruction::PopExcept);
+            emit!(self, Instruction::Reraise { depth: 0 });
+
+            if let Some(cleanup) = finally_cleanup_block {
+                self.switch_to_block(cleanup);
+                emit!(self, Instruction::Copy { i: 3 });
+                emit!(self, Instruction::PopExcept);
+                emit!(self, Instruction::Reraise { depth: 1 });
+            }
         }
 
+        self.switch_to_block(exit_block);
+
         Ok(())
     }
 
@@ -3583,7 +3993,7 @@ impl Compiler {
         &mut self,
         parameters: &ast::Parameters,
     ) -> CompileResult<bytecode::MakeFunctionFlags> {
-        let mut funcflags = bytecode::MakeFunctionFlags::empty();
+        let mut funcflags = bytecode::MakeFunctionFlags::new();
 
         // Handle positional defaults
         let defaults: Vec<_> = core::iter::empty()
@@ -3600,10 +4010,10 @@ impl Compiler {
             emit!(
                 self,
                 Instruction::BuildTuple {
-                    size: defaults.len().to_u32()
+                    count: defaults.len().to_u32()
                 }
             );
-            funcflags |= bytecode::MakeFunctionFlags::DEFAULTS;
+            funcflags.insert(bytecode::MakeFunctionFlag::Defaults);
         }
 
         // Handle keyword-only defaults
@@ -3618,17 +4028,17 @@ impl Compiler {
             // Compile kwdefaults and build dict
             for (arg, default) in &kw_with_defaults {
                 self.emit_load_const(ConstantData::Str {
-                    value: arg.name.as_str().into(),
+                    value: self.mangle(arg.name.as_str()).into_owned().into(),
                 });
                 self.compile_expression(default)?;
             }
             emit!(
                 self,
                 Instruction::BuildMap {
-                    size: kw_with_defaults.len().to_u32(),
+                    count: kw_with_defaults.len().to_u32(),
                 }
             );
-            funcflags |= bytecode::MakeFunctionFlags::KW_ONLY_DEFAULTS;
+            funcflags.insert(bytecode::MakeFunctionFlag::KwOnlyDefaults);
         }
 
         Ok(funcflags)
@@ -3644,6 +4054,9 @@ impl Compiler {
         is_async: bool,
         funcflags: bytecode::MakeFunctionFlags,
     ) -> CompileResult<()> {
+        // Save source range so MAKE_FUNCTION gets the `def` line, not the body's last line
+        let saved_range = self.current_source_range;
+
         // Always enter function scope
         self.enter_function(name, parameters)?;
         self.current_code_info()
@@ -3667,6 +4080,23 @@ impl Compiler {
         // Set qualname
         self.set_qualname();
 
+        // PEP 479: Wrap generator/coroutine body with StopIteration handler
+        let is_gen = is_async || self.current_symbol_table().is_generator;
+        let stop_iteration_block = if is_gen {
+            let handler_block = self.new_block();
+            emit!(
+                self,
+                PseudoInstruction::SetupCleanup {
+                    delta: handler_block
+                }
+            );
+            self.set_no_location();
+            self.push_fblock(FBlockType::StopIteration, handler_block, handler_block)?;
+            Some(handler_block)
+        } else {
+            None
+        };
+
         // Handle docstring - store in co_consts[0] if present
         let (doc_str, body) = split_doc(body, &self.opts);
         if let Some(doc) = &doc_str {
@@ -3679,24 +4109,47 @@ impl Compiler {
                 });
             self.current_code_info().flags |= bytecode::CodeFlags::HAS_DOCSTRING;
         }
-        // If no docstring, don't add None to co_consts
-        // Note: RETURN_GENERATOR + POP_TOP for async functions is emitted in enter_scope()
-
         // Compile body statements
         self.compile_statements(body)?;
 
-        // Emit None at end if needed
+        // Emit implicit `return None` if the body doesn't end with return.
+        // Also ensure None is in co_consts even when not emitting return
+        // (matching CPython: functions without explicit constants always
+        // have None in co_consts).
         match body.last() {
             Some(ast::Stmt::Return(_)) => {}
             _ => {
                 self.emit_return_const(ConstantData::None);
             }
         }
+        // Functions with no other constants should still have None in co_consts
+        if self.current_code_info().metadata.consts.is_empty() {
+            self.arg_constant(ConstantData::None);
+        }
+
+        // Close StopIteration handler and emit handler code
+        if let Some(handler_block) = stop_iteration_block {
+            emit!(self, PseudoInstruction::PopBlock);
+            self.set_no_location();
+            self.pop_fblock(FBlockType::StopIteration);
+            self.switch_to_block(handler_block);
+            emit!(
+                self,
+                Instruction::CallIntrinsic1 {
+                    func: oparg::IntrinsicFunction1::StopIterationError
+                }
+            );
+            self.set_no_location();
+            emit!(self, Instruction::Reraise { depth: 1u32 });
+            self.set_no_location();
+        }
 
         // Exit scope and create function object
         let code = self.exit_scope();
         self.ctx = prev_ctx;
 
+        self.set_source_range(saved_range);
+
         // Create function object with closure
         self.make_closure(code, funcflags)?;
 
@@ -3715,10 +4168,10 @@ impl Compiler {
         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)? {
+        // Try to enter annotation scope - returns None if no annotation_block exists
+        let Some(saved_ctx) = self.enter_annotation_scope(func_name)? else {
             return Ok(false);
-        }
+        };
 
         // Count annotations
         let parameters_iter = core::iter::empty()
@@ -3764,16 +4217,16 @@ impl Compiler {
         emit!(
             self,
             Instruction::BuildMap {
-                size: num_annotations,
+                count: num_annotations,
             }
         );
         emit!(self, Instruction::ReturnValue);
 
         // Exit the annotation scope and get the code object
-        let annotate_code = self.exit_annotation_scope();
+        let annotate_code = self.exit_annotation_scope(saved_ctx);
 
         // Make a closure from the code object
-        self.make_closure(annotate_code, bytecode::MakeFunctionFlags::empty())?;
+        self.make_closure(annotate_code, bytecode::MakeFunctionFlags::new())?;
 
         Ok(true)
     }
@@ -3856,25 +4309,31 @@ impl Compiler {
         // 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
+        // Get parent scope type 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);
         }
 
+        // Annotation scopes are never async (even inside async functions)
+        let saved_ctx = self.ctx;
+        self.ctx = CompileContext {
+            loop_data: None,
+            in_class: saved_ctx.in_class,
+            func: FunctionContext::Function,
+            in_async_scope: 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(&scope_name, CompilerScope::Annotation, key, lineno.to_u32())?;
+        self.enter_scope(
+            "__annotate__",
+            CompilerScope::Annotation,
+            key,
+            lineno.to_u32(),
+        )?;
 
         // Add 'format' parameter to varnames
         self.current_code_info()
@@ -3888,7 +4347,7 @@ impl Compiler {
         if has_conditional {
             // PEP 649: Build dict incrementally, checking conditional annotations
             // Start with empty dict
-            emit!(self, Instruction::BuildMap { size: 0 });
+            emit!(self, Instruction::BuildMap { count: 0 });
 
             // Process each annotation
             for (idx, (name, annotation)) in annotations.iter().enumerate() {
@@ -3901,25 +4360,30 @@ impl Compiler {
                 // 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));
+                    emit!(self, Instruction::LoadDeref { i: idx });
                 } else {
                     let cond_annotations_name = self.name("__conditional_annotations__");
-                    emit!(self, Instruction::LoadGlobal(cond_annotations_name));
+                    self.emit_load_global(cond_annotations_name, false);
                 }
                 // CONTAINS_OP (in)
-                emit!(self, Instruction::ContainsOp(bytecode::Invert::No));
+                emit!(
+                    self,
+                    Instruction::ContainsOp {
+                        invert: bytecode::Invert::No
+                    }
+                );
                 // POP_JUMP_IF_FALSE not_set
                 emit!(
                     self,
                     Instruction::PopJumpIfFalse {
-                        target: not_set_block
+                        delta: not_set_block
                     }
                 );
 
                 // Annotation value
                 self.compile_annotation(annotation)?;
                 // COPY dict to TOS
-                emit!(self, Instruction::Copy { index: 2 });
+                emit!(self, Instruction::Copy { i: 2 });
                 // LOAD_CONST name
                 self.emit_load_const(ConstantData::Str {
                     value: self.mangle(name).into_owned().into(),
@@ -3949,7 +4413,7 @@ impl Compiler {
             emit!(
                 self,
                 Instruction::BuildMap {
-                    size: num_annotations,
+                    count: num_annotations,
                 }
             );
             emit!(self, Instruction::ReturnValue);
@@ -3962,6 +4426,8 @@ impl Compiler {
             .last_mut()
             .expect("no module symbol table")
             .annotation_block = Some(Box::new(annotation_table));
+        // Restore context
+        self.ctx = saved_ctx;
         // Exit code scope
         let pop = self.code_stack.pop();
         let annotate_code = unwrap_internal(
@@ -3970,7 +4436,7 @@ impl Compiler {
         );
 
         // Make a closure from the code object
-        self.make_closure(annotate_code, bytecode::MakeFunctionFlags::empty())?;
+        self.make_closure(annotate_code, bytecode::MakeFunctionFlags::new())?;
 
         // Store as __annotate_func__ for classes, __annotate__ for modules
         let name = if parent_scope_type == CompilerScope::Class {
@@ -3995,20 +4461,31 @@ impl Compiler {
         is_async: bool,
         type_params: Option<&ast::TypeParams>,
     ) -> CompileResult<()> {
+        // Save the source range of the `def` line before compiling decorators/defaults,
+        // so that the function code object gets the correct co_firstlineno.
+        let def_source_range = self.current_source_range;
+
         self.prepare_decorators(decorator_list)?;
 
         // compile defaults and return funcflags
         let funcflags = self.compile_default_arguments(parameters)?;
 
+        // Restore the `def` line range so that enter_function → push_output → get_source_line_number()
+        // records the `def` keyword's line as co_firstlineno, not the last default-argument line.
+        self.set_source_range(def_source_range);
+
         let is_generic = type_params.is_some();
         let mut num_typeparam_args = 0;
 
+        // Save context before entering TypeParams scope
+        let saved_ctx = self.ctx;
+
         if is_generic {
             // Count args to pass to type params scope
-            if funcflags.contains(bytecode::MakeFunctionFlags::DEFAULTS) {
+            if funcflags.contains(&bytecode::MakeFunctionFlag::Defaults) {
                 num_typeparam_args += 1;
             }
-            if funcflags.contains(bytecode::MakeFunctionFlags::KW_ONLY_DEFAULTS) {
+            if funcflags.contains(&bytecode::MakeFunctionFlag::KwOnlyDefaults) {
                 num_typeparam_args += 1;
             }
 
@@ -4022,16 +4499,24 @@ impl Compiler {
                 type_params_name,
             )?;
 
+            // TypeParams scope is function-like
+            self.ctx = CompileContext {
+                loop_data: None,
+                in_class: saved_ctx.in_class,
+                func: FunctionContext::Function,
+                in_async_scope: false,
+            };
+
             // Add parameter names to varnames for the type params scope
             // These will be passed as arguments when the closure is called
             let current_info = self.current_code_info();
-            if funcflags.contains(bytecode::MakeFunctionFlags::DEFAULTS) {
+            if funcflags.contains(&bytecode::MakeFunctionFlag::Defaults) {
                 current_info
                     .metadata
                     .varnames
                     .insert(".defaults".to_owned());
             }
-            if funcflags.contains(bytecode::MakeFunctionFlags::KW_ONLY_DEFAULTS) {
+            if funcflags.contains(&bytecode::MakeFunctionFlag::KwOnlyDefaults) {
                 current_info
                     .metadata
                     .varnames
@@ -4043,16 +4528,16 @@ impl Compiler {
 
             // Load defaults/kwdefaults with LOAD_FAST
             for i in 0..num_typeparam_args {
-                emit!(self, Instruction::LoadFast(i as u32));
+                let var_num = oparg::VarNum::from(i as u32);
+                emit!(self, Instruction::LoadFast { var_num });
             }
         }
 
         // Compile annotations as closure (PEP 649)
-        let annotations_flag = if self.compile_annotations_closure(name, parameters, returns)? {
-            bytecode::MakeFunctionFlags::ANNOTATE
-        } else {
-            bytecode::MakeFunctionFlags::empty()
-        };
+        let mut annotations_flag = bytecode::MakeFunctionFlags::new();
+        if self.compile_annotations_closure(name, parameters, returns)? {
+            annotations_flag.insert(bytecode::MakeFunctionFlag::Annotate);
+        }
 
         // Compile function body
         let final_funcflags = funcflags | annotations_flag;
@@ -4062,7 +4547,7 @@ impl Compiler {
         if is_generic {
             // SWAP to get function on top
             // Stack: [type_params_tuple, function] -> [function, type_params_tuple]
-            emit!(self, Instruction::Swap { index: 2 });
+            emit!(self, Instruction::Swap { i: 2 });
 
             // Call INTRINSIC_SET_FUNCTION_TYPE_PARAMS
             emit!(
@@ -4080,9 +4565,10 @@ impl Compiler {
 
             // Exit type params scope and create closure
             let type_params_code = self.exit_scope();
+            self.ctx = saved_ctx;
 
             // Make closure for type params code
-            self.make_closure(type_params_code, bytecode::MakeFunctionFlags::empty())?;
+            self.make_closure(type_params_code, bytecode::MakeFunctionFlags::new())?;
 
             // Call the type params closure with defaults/kwdefaults as arguments.
             // Call protocol: [callable, self_or_null, arg1, ..., argN]
@@ -4093,31 +4579,31 @@ impl Compiler {
                 match num_typeparam_args {
                     1 => {
                         // Stack: [arg1, closure]
-                        emit!(self, Instruction::Swap { index: 2 }); // [closure, arg1]
+                        emit!(self, Instruction::Swap { i: 2 }); // [closure, arg1]
                         emit!(self, Instruction::PushNull); // [closure, arg1, NULL]
-                        emit!(self, Instruction::Swap { index: 2 }); // [closure, NULL, arg1]
+                        emit!(self, Instruction::Swap { i: 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::Swap { i: 3 }); // [closure, arg2, arg1]
+                        emit!(self, Instruction::Swap { i: 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]
+                        emit!(self, Instruction::Swap { i: 3 }); // [closure, NULL, arg2, arg1]
+                        emit!(self, Instruction::Swap { i: 2 }); // [closure, NULL, arg1, arg2]
                     }
                     _ => unreachable!("only defaults and kwdefaults are supported"),
                 }
                 emit!(
                     self,
                     Instruction::Call {
-                        nargs: num_typeparam_args as u32
+                        argc: num_typeparam_args as u32
                     }
                 );
             } else {
                 // Stack: [closure]
                 emit!(self, Instruction::PushNull);
                 // Stack: [closure, NULL]
-                emit!(self, Instruction::Call { nargs: 0 });
+                emit!(self, Instruction::Call { argc: 0 });
             }
         }
 
@@ -4222,14 +4708,14 @@ impl Compiler {
                     }
                 };
 
-                emit!(self, PseudoInstruction::LoadClosure(idx.to_u32()));
+                emit!(self, PseudoInstruction::LoadClosure { i: idx.to_u32() });
             }
 
             // Build tuple of closure variables
             emit!(
                 self,
                 Instruction::BuildTuple {
-                    size: code.freevars.len().to_u32(),
+                    count: code.freevars.len().to_u32(),
                 }
             );
         }
@@ -4250,57 +4736,57 @@ impl Compiler {
             emit!(
                 self,
                 Instruction::SetFunctionAttribute {
-                    attr: bytecode::MakeFunctionFlags::CLOSURE
+                    flag: bytecode::MakeFunctionFlag::Closure
                 }
             );
         }
 
         // Set annotations if present
-        if flags.contains(bytecode::MakeFunctionFlags::ANNOTATIONS) {
+        if flags.contains(&bytecode::MakeFunctionFlag::Annotations) {
             emit!(
                 self,
                 Instruction::SetFunctionAttribute {
-                    attr: bytecode::MakeFunctionFlags::ANNOTATIONS
+                    flag: bytecode::MakeFunctionFlag::Annotations
                 }
             );
         }
 
         // Set __annotate__ closure if present (PEP 649)
-        if flags.contains(bytecode::MakeFunctionFlags::ANNOTATE) {
+        if flags.contains(&bytecode::MakeFunctionFlag::Annotate) {
             emit!(
                 self,
                 Instruction::SetFunctionAttribute {
-                    attr: bytecode::MakeFunctionFlags::ANNOTATE
+                    flag: bytecode::MakeFunctionFlag::Annotate
                 }
             );
         }
 
         // Set kwdefaults if present
-        if flags.contains(bytecode::MakeFunctionFlags::KW_ONLY_DEFAULTS) {
+        if flags.contains(&bytecode::MakeFunctionFlag::KwOnlyDefaults) {
             emit!(
                 self,
                 Instruction::SetFunctionAttribute {
-                    attr: bytecode::MakeFunctionFlags::KW_ONLY_DEFAULTS
+                    flag: bytecode::MakeFunctionFlag::KwOnlyDefaults
                 }
             );
         }
 
         // Set defaults if present
-        if flags.contains(bytecode::MakeFunctionFlags::DEFAULTS) {
+        if flags.contains(&bytecode::MakeFunctionFlag::Defaults) {
             emit!(
                 self,
                 Instruction::SetFunctionAttribute {
-                    attr: bytecode::MakeFunctionFlags::DEFAULTS
+                    flag: bytecode::MakeFunctionFlag::Defaults
                 }
             );
         }
 
         // Set type_params if present
-        if flags.contains(bytecode::MakeFunctionFlags::TYPE_PARAMS) {
+        if flags.contains(&bytecode::MakeFunctionFlag::TypeParams) {
             emit!(
                 self,
                 Instruction::SetFunctionAttribute {
-                    attr: bytecode::MakeFunctionFlags::TYPE_PARAMS
+                    flag: bytecode::MakeFunctionFlag::TypeParams
                 }
             );
         }
@@ -4308,6 +4794,130 @@ impl Compiler {
         Ok(())
     }
 
+    /// Collect attribute names assigned via `self.xxx = ...` in methods.
+    /// These are stored as __static_attributes__ in the class dict.
+    fn collect_static_attributes(body: &[ast::Stmt], attrs: Option<&mut IndexSet<String>>) {
+        let Some(attrs) = attrs else { return };
+        for stmt in body {
+            let f = match stmt {
+                ast::Stmt::FunctionDef(f) => f,
+                _ => continue,
+            };
+            // Skip @staticmethod and @classmethod decorated functions
+            let has_special_decorator = f.decorator_list.iter().any(|d| {
+                matches!(&d.expression, ast::Expr::Name(n)
+                    if n.id.as_str() == "staticmethod" || n.id.as_str() == "classmethod")
+            });
+            if has_special_decorator {
+                continue;
+            }
+            // Skip implicit classmethods (__init_subclass__, __class_getitem__)
+            let fname = f.name.as_str();
+            if fname == "__init_subclass__" || fname == "__class_getitem__" {
+                continue;
+            }
+            // For __new__, scan for "self" (not the first param "cls")
+            if fname == "__new__" {
+                Self::scan_store_attrs(&f.body, "self", attrs);
+                continue;
+            }
+            let first_param = f
+                .parameters
+                .posonlyargs
+                .first()
+                .or(f.parameters.args.first())
+                .map(|p| &p.parameter.name);
+            let Some(self_name) = first_param else {
+                continue;
+            };
+            Self::scan_store_attrs(&f.body, self_name.as_str(), attrs);
+        }
+    }
+
+    /// Extract self.attr patterns from an assignment target expression.
+    fn scan_target_for_attrs(target: &ast::Expr, name: &str, attrs: &mut IndexSet<String>) {
+        match target {
+            ast::Expr::Attribute(ast::ExprAttribute { value, attr, .. }) => {
+                if let ast::Expr::Name(n) = value.as_ref()
+                    && n.id.as_str() == name
+                {
+                    attrs.insert(attr.to_string());
+                }
+            }
+            ast::Expr::Tuple(t) => {
+                for elt in &t.elts {
+                    Self::scan_target_for_attrs(elt, name, attrs);
+                }
+            }
+            ast::Expr::List(l) => {
+                for elt in &l.elts {
+                    Self::scan_target_for_attrs(elt, name, attrs);
+                }
+            }
+            ast::Expr::Starred(s) => {
+                Self::scan_target_for_attrs(&s.value, name, attrs);
+            }
+            _ => {}
+        }
+    }
+
+    /// Recursively scan statements for `name.attr = value` patterns.
+    fn scan_store_attrs(stmts: &[ast::Stmt], name: &str, attrs: &mut IndexSet<String>) {
+        for stmt in stmts {
+            match stmt {
+                ast::Stmt::Assign(a) => {
+                    for target in &a.targets {
+                        Self::scan_target_for_attrs(target, name, attrs);
+                    }
+                }
+                ast::Stmt::AnnAssign(a) => {
+                    Self::scan_target_for_attrs(&a.target, name, attrs);
+                }
+                ast::Stmt::AugAssign(a) => {
+                    if let ast::Expr::Attribute(ast::ExprAttribute { value, attr, .. }) =
+                        a.target.as_ref()
+                        && let ast::Expr::Name(n) = value.as_ref()
+                        && n.id.as_str() == name
+                    {
+                        attrs.insert(attr.to_string());
+                    }
+                }
+                ast::Stmt::If(s) => {
+                    Self::scan_store_attrs(&s.body, name, attrs);
+                    for clause in &s.elif_else_clauses {
+                        Self::scan_store_attrs(&clause.body, name, attrs);
+                    }
+                }
+                ast::Stmt::For(s) => {
+                    Self::scan_store_attrs(&s.body, name, attrs);
+                    Self::scan_store_attrs(&s.orelse, name, attrs);
+                }
+                ast::Stmt::While(s) => {
+                    Self::scan_store_attrs(&s.body, name, attrs);
+                    Self::scan_store_attrs(&s.orelse, name, attrs);
+                }
+                ast::Stmt::Try(s) => {
+                    Self::scan_store_attrs(&s.body, name, attrs);
+                    for handler in &s.handlers {
+                        let ast::ExceptHandler::ExceptHandler(h) = handler;
+                        Self::scan_store_attrs(&h.body, name, attrs);
+                    }
+                    Self::scan_store_attrs(&s.orelse, name, attrs);
+                    Self::scan_store_attrs(&s.finalbody, name, attrs);
+                }
+                ast::Stmt::With(s) => {
+                    Self::scan_store_attrs(&s.body, name, attrs);
+                }
+                ast::Stmt::Match(s) => {
+                    for case in &s.cases {
+                        Self::scan_store_attrs(&case.body, name, attrs);
+                    }
+                }
+                _ => {}
+            }
+        }
+    }
+
     // Python/compile.c find_ann
     fn find_ann(body: &[ast::Stmt]) -> bool {
         for statement in body {
@@ -4328,12 +4938,26 @@ impl Compiler {
                     Self::find_ann(body) || Self::find_ann(orelse)
                 }
                 ast::Stmt::With(ast::StmtWith { body, .. }) => Self::find_ann(body),
+                ast::Stmt::Match(ast::StmtMatch { cases, .. }) => {
+                    cases.iter().any(|case| Self::find_ann(&case.body))
+                }
                 ast::Stmt::Try(ast::StmtTry {
                     body,
+                    handlers,
                     orelse,
                     finalbody,
                     ..
-                }) => Self::find_ann(body) || Self::find_ann(orelse) || Self::find_ann(finalbody),
+                }) => {
+                    Self::find_ann(body)
+                        || handlers.iter().any(|h| {
+                            let ast::ExceptHandler::ExceptHandler(
+                                ast::ExceptHandlerExceptHandler { body, .. },
+                            ) = h;
+                            Self::find_ann(body)
+                        })
+                        || Self::find_ann(orelse)
+                        || Self::find_ann(finalbody)
+                }
                 _ => false,
             };
             if res {
@@ -4366,49 +4990,74 @@ impl Compiler {
         // 2. Set up class namespace
         let (doc_str, body) = split_doc(body, &self.opts);
 
-        // Load (global) __name__ and store as __module__
+        // Load __name__ and store as __module__
         let dunder_name = self.name("__name__");
-        emit!(self, Instruction::LoadGlobal(dunder_name));
+        emit!(self, Instruction::LoadName { namei: dunder_name });
         let dunder_module = self.name("__module__");
-        emit!(self, Instruction::StoreName(dunder_module));
+        emit!(
+            self,
+            Instruction::StoreName {
+                namei: dunder_module
+            }
+        );
 
         // Store __qualname__
         self.emit_load_const(ConstantData::Str {
             value: qualname.into(),
         });
         let qualname_name = self.name("__qualname__");
-        emit!(self, Instruction::StoreName(qualname_name));
+        emit!(
+            self,
+            Instruction::StoreName {
+                namei: qualname_name
+            }
+        );
+
+        // Store __firstlineno__ before __doc__
+        self.emit_load_const(ConstantData::Integer {
+            value: BigInt::from(firstlineno),
+        });
+        let firstlineno_name = self.name("__firstlineno__");
+        emit!(
+            self,
+            Instruction::StoreName {
+                namei: firstlineno_name
+            }
+        );
+
+        // PEP 649: Initialize __classdict__ cell (before __doc__)
+        if self.current_symbol_table().needs_classdict {
+            emit!(self, Instruction::LoadLocals);
+            let classdict_idx = self.get_cell_var_index("__classdict__")?;
+            emit!(self, Instruction::StoreDeref { i: classdict_idx });
+        }
 
         // 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::StoreName(doc_name));
+            emit!(self, Instruction::StoreName { namei: doc_name });
         }
 
-        // Store __firstlineno__ (new in Python 3.12+)
-        self.emit_load_const(ConstantData::Integer {
-            value: BigInt::from(firstlineno),
-        });
-        let firstlineno_name = self.name("__firstlineno__");
-        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::LoadName(dot_type_params));
+            emit!(
+                self,
+                Instruction::LoadName {
+                    namei: dot_type_params
+                }
+            );
 
             // Store as __type_params__
             let dunder_type_params = self.name("__type_params__");
-            emit!(self, Instruction::StoreName(dunder_type_params));
-        }
-
-        // PEP 649: Initialize __classdict__ cell for class annotation scope
-        if self.current_symbol_table().needs_classdict {
-            emit!(self, Instruction::LoadLocals);
-            let classdict_idx = self.get_cell_var_index("__classdict__")?;
-            emit!(self, Instruction::StoreDeref(classdict_idx));
+            emit!(
+                self,
+                Instruction::StoreName {
+                    namei: dunder_type_params
+                }
+            );
         }
 
         // Handle class annotations based on future_annotations flag
@@ -4419,7 +5068,7 @@ impl Compiler {
             } 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 });
+                    emit!(self, Instruction::BuildSet { count: 0 });
                     self.store_name("__conditional_annotations__")?;
                 }
 
@@ -4428,6 +5077,16 @@ impl Compiler {
             }
         }
 
+        // Collect __static_attributes__: scan methods for self.xxx = ... patterns
+        Self::collect_static_attributes(
+            body,
+            self.code_stack
+                .last_mut()
+                .unwrap()
+                .static_attributes
+                .as_mut(),
+        );
+
         // 3. Compile the class body
         self.compile_statements(body)?;
 
@@ -4441,11 +5100,55 @@ impl Compiler {
             .iter()
             .position(|var| *var == "__class__");
 
+        // Emit __static_attributes__ tuple
+        {
+            let mut attrs: Vec<String> = self
+                .code_stack
+                .last()
+                .unwrap()
+                .static_attributes
+                .as_ref()
+                .map(|s| s.iter().cloned().collect())
+                .unwrap_or_default();
+            attrs.sort();
+            self.emit_load_const(ConstantData::Tuple {
+                elements: attrs
+                    .into_iter()
+                    .map(|s| ConstantData::Str { value: s.into() })
+                    .collect(),
+            });
+            let static_attrs_name = self.name("__static_attributes__");
+            emit!(
+                self,
+                Instruction::StoreName {
+                    namei: static_attrs_name
+                }
+            );
+        }
+
+        // Store __classdictcell__ if __classdict__ is a cell variable
+        if self.current_symbol_table().needs_classdict {
+            let classdict_idx = u32::from(self.get_cell_var_index("__classdict__")?);
+            emit!(self, PseudoInstruction::LoadClosure { i: classdict_idx });
+            let classdictcell = self.name("__classdictcell__");
+            emit!(
+                self,
+                Instruction::StoreName {
+                    namei: classdictcell
+                }
+            );
+        }
+
         if let Some(classcell_idx) = classcell_idx {
-            emit!(self, PseudoInstruction::LoadClosure(classcell_idx.to_u32()));
-            emit!(self, Instruction::Copy { index: 1_u32 });
+            emit!(
+                self,
+                PseudoInstruction::LoadClosure {
+                    i: classcell_idx.to_u32()
+                }
+            );
+            emit!(self, Instruction::Copy { i: 1 });
             let classcell = self.name("__classcell__");
-            emit!(self, Instruction::StoreName(classcell));
+            emit!(self, Instruction::StoreName { namei: classcell });
         } else {
             self.emit_load_const(ConstantData::None);
         }
@@ -4470,6 +5173,9 @@ impl Compiler {
         let is_generic = type_params.is_some();
         let firstlineno = self.get_source_line_number().get().to_u32();
 
+        // Save context before entering any scopes
+        let saved_ctx = self.ctx;
+
         // Step 1: If generic, enter type params scope and compile type params
         if is_generic {
             let type_params_name = format!("<generic parameters of {name}>");
@@ -4484,10 +5190,23 @@ impl Compiler {
             // Set private name for name mangling
             self.code_stack.last_mut().unwrap().private = Some(name.to_owned());
 
+            // TypeParams scope is function-like
+            self.ctx = CompileContext {
+                loop_data: None,
+                in_class: saved_ctx.in_class,
+                func: FunctionContext::Function,
+                in_async_scope: false,
+            };
+
             // 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::StoreName(dot_type_params));
+            emit!(
+                self,
+                Instruction::StoreName {
+                    namei: dot_type_params
+                }
+            );
         }
 
         // Step 2: Compile class body (always done, whether generic or not)
@@ -4508,23 +5227,38 @@ impl Compiler {
             let dot_generic_base = self.name(".generic_base");
 
             // Create .generic_base
-            emit!(self, Instruction::LoadName(dot_type_params));
+            emit!(
+                self,
+                Instruction::LoadName {
+                    namei: dot_type_params
+                }
+            );
             emit!(
                 self,
                 Instruction::CallIntrinsic1 {
                     func: bytecode::IntrinsicFunction1::SubscriptGeneric
                 }
             );
-            emit!(self, Instruction::StoreName(dot_generic_base));
+            emit!(
+                self,
+                Instruction::StoreName {
+                    namei: dot_generic_base
+                }
+            );
 
             // 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();
-            emit!(self, Instruction::LoadName(dot_type_params));
-            func_flags |= bytecode::MakeFunctionFlags::TYPE_PARAMS;
+            let mut func_flags = bytecode::MakeFunctionFlags::new();
+            emit!(
+                self,
+                Instruction::LoadName {
+                    namei: dot_type_params
+                }
+            );
+            func_flags.insert(bytecode::MakeFunctionFlag::TypeParams);
 
             // Create class function with closure
             self.make_closure(class_code, func_flags)?;
@@ -4546,7 +5280,7 @@ impl Compiler {
                 // Need to build: args tuple = (class_func, name, *bases, .generic_base)
 
                 // Build a list starting with class_func and name (2 elements already on stack)
-                emit!(self, Instruction::BuildList { size: 2 });
+                emit!(self, Instruction::BuildList { count: 2 });
 
                 // Add bases to the list
                 if let Some(arguments) = arguments {
@@ -4554,18 +5288,23 @@ impl Compiler {
                         if let ast::Expr::Starred(ast::ExprStarred { value, .. }) = arg {
                             // Starred: compile and extend
                             self.compile_expression(value)?;
-                            emit!(self, Instruction::ListExtend { i: 0 });
+                            emit!(self, Instruction::ListExtend { i: 1 });
                         } else {
                             // Non-starred: compile and append
                             self.compile_expression(arg)?;
-                            emit!(self, Instruction::ListAppend { i: 0 });
+                            emit!(self, Instruction::ListAppend { i: 1 });
                         }
                     }
                 }
 
                 // Add .generic_base as final element
-                emit!(self, Instruction::LoadName(dot_generic_base));
-                emit!(self, Instruction::ListAppend { i: 0 });
+                emit!(
+                    self,
+                    Instruction::LoadName {
+                        namei: dot_generic_base
+                    }
+                );
+                emit!(self, Instruction::ListAppend { i: 1 });
 
                 // Convert list to tuple
                 emit!(
@@ -4595,7 +5334,12 @@ impl Compiler {
                 };
 
                 // Load .generic_base as the last base
-                emit!(self, Instruction::LoadName(dot_generic_base));
+                emit!(
+                    self,
+                    Instruction::LoadName {
+                        namei: dot_generic_base
+                    }
+                );
 
                 let nargs = 2 + u32::try_from(base_count).expect("too many base classes") + 1;
 
@@ -4619,13 +5363,13 @@ impl Compiler {
                     emit!(
                         self,
                         Instruction::CallKw {
-                            nargs: nargs
+                            argc: nargs
                                 + u32::try_from(arguments.keywords.len())
                                     .expect("too many keyword arguments")
                         }
                     );
                 } else {
-                    emit!(self, Instruction::Call { nargs });
+                    emit!(self, Instruction::Call { argc: nargs });
                 }
             }
 
@@ -4634,24 +5378,25 @@ impl Compiler {
 
             // Exit type params scope and wrap in function
             let type_params_code = self.exit_scope();
+            self.ctx = saved_ctx;
 
             // Execute the type params function
-            self.make_closure(type_params_code, bytecode::MakeFunctionFlags::empty())?;
+            self.make_closure(type_params_code, bytecode::MakeFunctionFlags::new())?;
             emit!(self, Instruction::PushNull);
-            emit!(self, Instruction::Call { nargs: 0 });
+            emit!(self, Instruction::Call { argc: 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.make_closure(class_code, bytecode::MakeFunctionFlags::new())?;
             self.emit_load_const(ConstantData::Str { value: name.into() });
 
             if let Some(arguments) = arguments {
-                self.codegen_call_helper(2, arguments)?;
+                self.codegen_call_helper(2, arguments, self.current_source_range)?;
             } else {
-                emit!(self, Instruction::Call { nargs: 2 });
+                emit!(self, Instruction::Call { argc: 2 });
             }
         }
 
@@ -4660,6 +5405,94 @@ impl Compiler {
         self.store_name(name)
     }
 
+    /// Compile an if statement with constant condition elimination.
+    /// = compiler_if in CPython codegen.c
+    fn compile_if(
+        &mut self,
+        test: &ast::Expr,
+        body: &[ast::Stmt],
+        elif_else_clauses: &[ast::ElifElseClause],
+    ) -> CompileResult<()> {
+        let constant = Self::expr_constant(test);
+
+        // If the test is constant false, walk the body (consuming sub_tables)
+        // but don't emit bytecode
+        if constant == Some(false) {
+            self.emit_nop();
+            self.do_not_emit_bytecode += 1;
+            self.compile_statements(body)?;
+            self.do_not_emit_bytecode -= 1;
+            // Compile the elif/else chain (if any)
+            match elif_else_clauses {
+                [] => {}
+                [first, rest @ ..] => {
+                    if let Some(elif_test) = &first.test {
+                        self.compile_if(elif_test, &first.body, rest)?;
+                    } else {
+                        self.compile_statements(&first.body)?;
+                    }
+                }
+            }
+            return Ok(());
+        }
+
+        // If the test is constant true, compile body directly,
+        // but walk elif/else without emitting (including elif tests to consume sub_tables)
+        if constant == Some(true) {
+            self.emit_nop();
+            self.compile_statements(body)?;
+            self.do_not_emit_bytecode += 1;
+            for clause in elif_else_clauses {
+                if let Some(elif_test) = &clause.test {
+                    self.compile_expression(elif_test)?;
+                }
+                self.compile_statements(&clause.body)?;
+            }
+            self.do_not_emit_bytecode -= 1;
+            return Ok(());
+        }
+
+        // Non-constant test: normal compilation
+        match elif_else_clauses {
+            // Only if
+            [] => {
+                let after_block = self.new_block();
+                self.compile_jump_if(test, false, after_block)?;
+                self.compile_statements(body)?;
+                self.switch_to_block(after_block);
+            }
+            // If, elif*, elif/else
+            [rest @ .., tail] => {
+                let after_block = self.new_block();
+                let mut next_block = self.new_block();
+
+                self.compile_jump_if(test, false, next_block)?;
+                self.compile_statements(body)?;
+                emit!(self, PseudoInstruction::Jump { delta: after_block });
+
+                for clause in rest {
+                    self.switch_to_block(next_block);
+                    next_block = self.new_block();
+                    if let Some(test) = &clause.test {
+                        self.compile_jump_if(test, false, next_block)?;
+                    } else {
+                        unreachable!() // must be elif
+                    }
+                    self.compile_statements(&clause.body)?;
+                    emit!(self, PseudoInstruction::Jump { delta: after_block });
+                }
+
+                self.switch_to_block(next_block);
+                if let Some(test) = &tail.test {
+                    self.compile_jump_if(test, false, after_block)?;
+                }
+                self.compile_statements(&tail.body)?;
+                self.switch_to_block(after_block);
+            }
+        }
+        Ok(())
+    }
+
     fn compile_while(
         &mut self,
         test: &ast::Expr,
@@ -4668,32 +5501,45 @@ impl Compiler {
     ) -> CompileResult<()> {
         self.enter_conditional_block();
 
+        let constant = Self::expr_constant(test);
+
+        // while False: body → walk body (consuming sub_tables) but don't emit,
+        // then compile orelse
+        if constant == Some(false) {
+            self.emit_nop();
+            let while_block = self.new_block();
+            let after_block = self.new_block();
+            self.push_fblock(FBlockType::WhileLoop, while_block, after_block)?;
+            self.do_not_emit_bytecode += 1;
+            self.compile_statements(body)?;
+            self.do_not_emit_bytecode -= 1;
+            self.pop_fblock(FBlockType::WhileLoop);
+            self.compile_statements(orelse)?;
+            self.leave_conditional_block();
+            return Ok(());
+        }
+
         let while_block = self.new_block();
         let else_block = self.new_block();
         let after_block = self.new_block();
 
-        // Note: SetupLoop is no longer emitted (break/continue use direct jumps)
         self.switch_to_block(while_block);
-
-        // Push fblock for while loop
         self.push_fblock(FBlockType::WhileLoop, while_block, after_block)?;
 
-        self.compile_jump_if(test, false, else_block)?;
+        // while True: → no condition test, just NOP
+        if constant == Some(true) {
+            self.emit_nop();
+        } else {
+            self.compile_jump_if(test, false, else_block)?;
+        }
 
         let was_in_loop = self.ctx.loop_data.replace((while_block, after_block));
         self.compile_statements(body)?;
         self.ctx.loop_data = was_in_loop;
-        emit!(
-            self,
-            PseudoInstruction::Jump {
-                target: while_block,
-            }
-        );
+        emit!(self, PseudoInstruction::Jump { delta: while_block });
         self.switch_to_block(else_block);
 
-        // Pop fblock
         self.pop_fblock(FBlockType::WhileLoop);
-        // Note: PopBlock is no longer emitted for loops
         self.compile_statements(orelse)?;
         self.switch_to_block(after_block);
 
@@ -4750,7 +5596,7 @@ impl Compiler {
         self.set_source_range(with_range);
 
         // Stack: [cm]
-        emit!(self, Instruction::Copy { index: 1_u32 }); // [cm, cm]
+        emit!(self, Instruction::Copy { i: 1 }); // [cm, cm]
 
         if is_async {
             if self.ctx.func != FunctionContext::AsyncFunction {
@@ -4762,20 +5608,19 @@ impl Compiler {
                 Instruction::LoadSpecial {
                     method: SpecialMethod::AExit
                 }
-            ); // [cm, bound_aexit]
-            emit!(self, Instruction::Swap { index: 2_u32 }); // [bound_aexit, cm]
+            ); // [cm, aexit_func, self_ae]
+            emit!(self, Instruction::Swap { i: 2 }); // [cm, self_ae, aexit_func]
+            emit!(self, Instruction::Swap { i: 3 }); // [aexit_func, self_ae, cm]
             emit!(
                 self,
                 Instruction::LoadSpecial {
                     method: SpecialMethod::AEnter
                 }
-            ); // [bound_aexit, bound_aenter]
-            // bound_aenter is already bound, call with NULL self_or_null
-            emit!(self, Instruction::PushNull); // [bound_aexit, bound_aenter, NULL]
-            emit!(self, Instruction::Call { nargs: 0 }); // [bound_aexit, awaitable]
-            emit!(self, Instruction::GetAwaitable);
+            ); // [aexit_func, self_ae, aenter_func, self_an]
+            emit!(self, Instruction::Call { argc: 0 }); // [aexit_func, self_ae, awaitable]
+            emit!(self, Instruction::GetAwaitable { r#where: 1 });
             self.emit_load_const(ConstantData::None);
-            self.compile_yield_from_sequence(true)?;
+            let _ = self.compile_yield_from_sequence(true)?;
         } else {
             // Load __exit__ and __enter__, then call __enter__
             emit!(
@@ -4783,25 +5628,28 @@ impl Compiler {
                 Instruction::LoadSpecial {
                     method: SpecialMethod::Exit
                 }
-            ); // [cm, bound_exit]
-            emit!(self, Instruction::Swap { index: 2_u32 }); // [bound_exit, cm]
+            ); // [cm, exit_func, self_exit]
+            emit!(self, Instruction::Swap { i: 2 }); // [cm, self_exit, exit_func]
+            emit!(self, Instruction::Swap { i: 3 }); // [exit_func, self_exit, cm]
             emit!(
                 self,
                 Instruction::LoadSpecial {
                     method: SpecialMethod::Enter
                 }
-            ); // [bound_exit, bound_enter]
-            // bound_enter is already bound, call with NULL self_or_null
-            emit!(self, Instruction::PushNull); // [bound_exit, bound_enter, NULL]
-            emit!(self, Instruction::Call { nargs: 0 }); // [bound_exit, enter_result]
+            ); // [exit_func, self_exit, enter_func, self_enter]
+            emit!(self, Instruction::Call { argc: 0 }); // [exit_func, self_exit, result]
         }
 
         // 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(
+        emit!(
+            self,
+            PseudoInstruction::SetupWith {
+                delta: exc_handler_block
+            }
+        );
+        self.push_fblock(
             if is_async {
                 FBlockType::AsyncWith
             } else {
@@ -4809,9 +5657,6 @@ impl Compiler {
             },
             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
@@ -4838,6 +5683,7 @@ impl Compiler {
         }
 
         // Pop fblock before normal exit
+        emit!(self, PseudoInstruction::PopBlock);
         self.pop_fblock(if is_async {
             FBlockType::AsyncWith
         } else {
@@ -4845,98 +5691,71 @@ impl Compiler {
         });
 
         // ===== Normal exit path =====
-        // Stack: [..., __exit__]
-        // Call __exit__(None, None, None)
+        // Stack: [..., exit_func, self_exit]
+        // Call exit_func(self_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);
-        emit!(self, Instruction::Call { nargs: 3 });
+        emit!(self, Instruction::Call { argc: 3 });
         if is_async {
-            emit!(self, Instruction::GetAwaitable);
+            emit!(self, Instruction::GetAwaitable { r#where: 2 });
             self.emit_load_const(ConstantData::None);
-            self.compile_yield_from_sequence(true)?;
+            let _ = self.compile_yield_from_sequence(true)?;
         }
         emit!(self, Instruction::PopTop); // Pop __exit__ result
-        emit!(
-            self,
-            PseudoInstruction::Jump {
-                target: after_block
-            }
-        );
+        emit!(self, PseudoInstruction::Jump { delta: after_block });
 
         // ===== Exception handler path =====
-        // Stack at entry (after unwind): [..., __exit__, lasti, exc]
-        // PUSH_EXC_INFO -> [..., __exit__, lasti, prev_exc, exc]
+        // Stack at entry: [..., exit_func, self_exit, lasti, exc]
+        // PUSH_EXC_INFO -> [..., exit_func, self_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
-        )?;
+        emit!(
+            self,
+            PseudoInstruction::SetupCleanup {
+                delta: cleanup_block
+            }
+        );
+        self.push_fblock(FBlockType::ExceptionHandler, exc_handler_block, after_block)?;
 
-        // 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
+        // WITH_EXCEPT_START: call exit_func(self_exit, type, value, tb)
+        // Stack: [..., exit_func, self_exit, lasti, prev_exc, exc]
         emit!(self, Instruction::WithExceptStart);
 
         if is_async {
-            emit!(self, Instruction::GetAwaitable);
+            emit!(self, Instruction::GetAwaitable { r#where: 2 });
             self.emit_load_const(ConstantData::None);
-            self.compile_yield_from_sequence(true)?;
+            let _ = self.compile_yield_from_sequence(true)?;
         }
 
-        // TO_BOOL + POP_JUMP_IF_TRUE: check if exception is suppressed
         emit!(self, Instruction::ToBool);
         emit!(
             self,
             Instruction::PopJumpIfTrue {
-                target: suppress_block
+                delta: 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.
+        emit!(self, PseudoInstruction::PopBlock);
         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__
+        // Stack: [..., exit_func, self_exit, lasti, prev_exc, exc, True]
         self.switch_to_block(suppress_block);
-        emit!(self, Instruction::PopTop); // pop True (TO_BOOL result)
-        emit!(self, Instruction::PopExcept); // pop exc and restore prev_exc
-        emit!(self, Instruction::PopTop); // pop __exit__
+        emit!(self, Instruction::PopTop); // pop True
+        emit!(self, Instruction::PopExcept); // pop exc, restore prev_exc
         emit!(self, Instruction::PopTop); // pop lasti
-        emit!(
-            self,
-            PseudoInstruction::Jump {
-                target: after_block
-            }
-        );
+        emit!(self, Instruction::PopTop); // pop self_exit
+        emit!(self, Instruction::PopTop); // pop exit_func
+        emit!(self, PseudoInstruction::Jump { delta: after_block });
 
         // ===== Cleanup block (for nested exception during __exit__) =====
         // Stack: [..., __exit__, lasti, prev_exc, lasti2, exc2]
@@ -4949,7 +5768,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::Copy { index: 3 });
+        emit!(self, Instruction::Copy { i: 3 });
         emit!(self, Instruction::PopExcept);
         emit!(self, Instruction::Reraise { depth: 1 });
 
@@ -4974,37 +5793,50 @@ impl Compiler {
         let for_block = self.new_block();
         let else_block = self.new_block();
         let after_block = self.new_block();
+        let mut end_async_for_target = BlockIdx::NULL;
 
         // The thing iterated:
-        self.compile_expression(iter)?;
-
-        if is_async {
-            if self.ctx.func != FunctionContext::AsyncFunction {
-                return Err(self.error(CodegenErrorType::InvalidAsyncFor));
-            }
+        // Optimize: `for x in [a, b, c]` → use tuple instead of list
+        // Skip for async-for (GET_AITER expects the original type)
+        if !is_async
+            && let ast::Expr::List(ast::ExprList { elts, .. }) = iter
+            && !elts.iter().any(|e| matches!(e, ast::Expr::Starred(_)))
+        {
+            for elt in elts {
+                self.compile_expression(elt)?;
+            }
+            emit!(
+                self,
+                Instruction::BuildTuple {
+                    count: u32::try_from(elts.len()).expect("too many elements"),
+                }
+            );
+        } else {
+            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 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
-            )?;
+            // codegen_async_for: push fblock BEFORE SETUP_FINALLY
+            self.push_fblock(FBlockType::ForLoop, for_block, after_block)?;
 
+            // SETUP_FINALLY to guard the __anext__ call
+            emit!(self, PseudoInstruction::SetupFinally { delta: else_block });
             emit!(self, Instruction::GetANext);
             self.emit_load_const(ConstantData::None);
-            self.compile_yield_from_sequence(true)?;
+            end_async_for_target = self.compile_yield_from_sequence(true)?;
+            // POP_BLOCK for SETUP_FINALLY - only GetANext/yield_from are protected
+            emit!(self, PseudoInstruction::PopBlock);
+            emit!(self, Instruction::NotTaken);
+
+            // Success block for __anext__
             self.compile_store(target)?;
-            // Note: PopBlock is no longer emitted (exception table handles this)
         } else {
             // Retrieve Iterator
             emit!(self, Instruction::GetIter);
@@ -5014,7 +5846,7 @@ impl Compiler {
             // Push fblock for for loop
             self.push_fblock(FBlockType::ForLoop, for_block, after_block)?;
 
-            emit!(self, Instruction::ForIter { target: else_block });
+            emit!(self, Instruction::ForIter { delta: else_block });
 
             // Start of loop iteration, set targets:
             self.compile_store(target)?;
@@ -5023,25 +5855,31 @@ 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, PseudoInstruction::Jump { target: for_block });
+        emit!(self, PseudoInstruction::Jump { delta: for_block });
 
         self.switch_to_block(else_block);
 
-        // Pop fblock
+        // Except block for __anext__ / end of sync for
+        // No PopBlock here - for async, POP_BLOCK is already in for_block
         self.pop_fblock(FBlockType::ForLoop);
 
+        // End-of-loop instructions are on the `for` line, not the body's last line
+        let saved_range = self.current_source_range;
+        self.set_source_range(iter.range());
         if is_async {
-            emit!(self, Instruction::EndAsyncFor);
+            self.emit_end_async_for(end_async_for_target);
         } else {
-            // END_FOR + POP_ITER pattern (CPython 3.14)
-            // FOR_ITER jumps to END_FOR, but VM skips it (+1) to reach POP_ITER
             emit!(self, Instruction::EndFor);
             emit!(self, Instruction::PopIter);
         }
+        self.set_source_range(saved_range);
         self.compile_statements(orelse)?;
 
         self.switch_to_block(after_block);
 
+        // Implicit return after for-loop should be attributed to the `for` line
+        self.set_source_range(iter.range());
+
         self.leave_conditional_block();
         Ok(())
     }
@@ -5059,8 +5897,9 @@ impl Compiler {
     }
 
     fn compile_error_forbidden_name(&mut self, name: &str) -> CodegenError {
-        // TODO: make into error (fine for now since it realistically errors out earlier)
-        panic!("Failing due to forbidden name {name:?}");
+        self.error(CodegenErrorType::SyntaxError(format!(
+            "cannot use forbidden name '{name}' in pattern"
+        )))
     }
 
     /// Ensures that `pc.fail_pop` has at least `n + 1` entries.
@@ -5089,7 +5928,7 @@ impl Compiler {
                 emit!(
                     self,
                     PseudoInstruction::Jump {
-                        target: pc.fail_pop[pops]
+                        delta: pc.fail_pop[pops]
                     }
                 );
             }
@@ -5097,7 +5936,7 @@ impl Compiler {
                 emit!(
                     self,
                     Instruction::PopJumpIfFalse {
-                        target: pc.fail_pop[pops]
+                        delta: pc.fail_pop[pops]
                     }
                 );
             }
@@ -5139,7 +5978,7 @@ impl Compiler {
             emit!(
                 self,
                 Instruction::Swap {
-                    index: u32::try_from(count).unwrap()
+                    i: u32::try_from(count).unwrap()
                 }
             );
             count -= 1;
@@ -5199,11 +6038,11 @@ impl Compiler {
                         todo!();
                         // return self.compiler_error(loc, "too many expressions in star-unpacking sequence pattern");
                     }
-                    let args = UnpackExArgs {
+                    let counts = UnpackExArgs {
                         before: u8::try_from(i).unwrap(),
                         after: u8::try_from(n - i - 1).unwrap(),
                     };
-                    emit!(self, Instruction::UnpackEx { args });
+                    emit!(self, Instruction::UnpackEx { counts });
                     seen_star = true;
                 } else {
                     // TODO: Fix error msg
@@ -5216,7 +6055,7 @@ impl Compiler {
             emit!(
                 self,
                 Instruction::UnpackSequence {
-                    size: u32::try_from(n).unwrap()
+                    count: u32::try_from(n).unwrap()
                 }
             );
         }
@@ -5261,7 +6100,7 @@ impl Compiler {
                 continue;
             }
             // Duplicate the subject.
-            emit!(self, Instruction::Copy { index: 1_u32 });
+            emit!(self, Instruction::Copy { i: 1 });
             if i < star {
                 // For indices before the star, use a nonnegative index equal to i.
                 self.emit_load_const(ConstantData::Integer { value: i.into() });
@@ -5339,7 +6178,7 @@ impl Compiler {
 
         // Otherwise, there is a sub-pattern. Duplicate the object on top of the stack.
         pc.on_top += 1;
-        emit!(self, Instruction::Copy { index: 1_u32 });
+        emit!(self, Instruction::Copy { i: 1 });
         // Compile the sub-pattern.
         self.compile_pattern(p.pattern.as_ref().unwrap(), pc)?;
         // After success, decrement the on_top counter.
@@ -5407,12 +6246,9 @@ impl Compiler {
 
         // Check for too many sub-patterns.
         if nargs > u32::MAX as usize || (nargs + n_attrs).saturating_sub(1) > i32::MAX as usize {
-            let msg = format!(
-                "too many sub-patterns in class pattern {:?}",
-                match_class.cls
-            );
-            panic!("{}", msg);
-            // return self.compiler_error(&msg);
+            return Err(self.error(CodegenErrorType::SyntaxError(
+                "too many sub-patterns in class pattern".to_owned(),
+            )));
         }
 
         // Validate keyword attributes if any.
@@ -5438,13 +6274,23 @@ impl Compiler {
             elements: attr_names,
         });
         // 2. Emit MATCH_CLASS with nargs.
-        emit!(self, Instruction::MatchClass(u32::try_from(nargs).unwrap()));
+        emit!(
+            self,
+            Instruction::MatchClass {
+                count: u32::try_from(nargs).unwrap()
+            }
+        );
         // 3. Duplicate the top of the stack.
-        emit!(self, Instruction::Copy { index: 1_u32 });
+        emit!(self, Instruction::Copy { i: 1 });
         // 4. Load None.
         self.emit_load_const(ConstantData::None);
         // 5. Compare with IS_OP 1.
-        emit!(self, Instruction::IsOp(Invert::Yes));
+        emit!(
+            self,
+            Instruction::IsOp {
+                invert: Invert::Yes
+            }
+        );
 
         // At this point the TOS is a tuple of (nargs + n_attrs) attributes (or None).
         pc.on_top += 1;
@@ -5455,7 +6301,7 @@ impl Compiler {
         emit!(
             self,
             Instruction::UnpackSequence {
-                size: u32::try_from(total).unwrap()
+                count: u32::try_from(total).unwrap()
             }
         );
         pc.on_top += total;
@@ -5540,7 +6386,7 @@ impl Compiler {
             emit!(
                 self,
                 Instruction::CompareOp {
-                    op: ComparisonOperator::GreaterOrEqual
+                    opname: ComparisonOperator::GreaterOrEqual
                 }
             );
             self.jump_to_fail_pop(pc, JumpOp::PopJumpIfFalse)?;
@@ -5553,13 +6399,13 @@ impl Compiler {
                 "too many sub-patterns in mapping pattern".to_string(),
             )));
         }
-        #[allow(clippy::cast_possible_truncation)]
-        let size = size as u32; // checked right before
+        #[allow(clippy::cast_possible_truncation, reason = "checked right before")]
+        let size = size as u32;
 
         // Step 2: If we have keys to match
         if size > 0 {
             // Validate and compile keys
-            let mut seen = HashSet::new();
+            let mut seen = IndexSet::default();
             for key in keys {
                 let is_attribute = matches!(key, ast::Expr::Attribute(_));
                 let is_literal = matches!(
@@ -5596,7 +6442,7 @@ impl Compiler {
         // Stack: [subject, key1, key2, ..., key_n]
 
         // Build tuple of keys (empty tuple if size==0)
-        emit!(self, Instruction::BuildTuple { size });
+        emit!(self, Instruction::BuildTuple { count: size });
         // Stack: [subject, keys_tuple]
 
         // Match keys
@@ -5605,19 +6451,24 @@ impl Compiler {
         pc.on_top += 2; // subject and keys_tuple are underneath
 
         // Check if match succeeded
-        emit!(self, Instruction::Copy { index: 1_u32 });
+        emit!(self, Instruction::Copy { i: 1 });
         // Stack: [subject, keys_tuple, values_tuple, values_tuple_copy]
 
         // Check if copy is None (consumes the copy like POP_JUMP_IF_NONE)
         self.emit_load_const(ConstantData::None);
-        emit!(self, Instruction::IsOp(Invert::Yes));
+        emit!(
+            self,
+            Instruction::IsOp {
+                invert: Invert::Yes
+            }
+        );
 
         // Stack: [subject, keys_tuple, values_tuple, bool]
         self.jump_to_fail_pop(pc, JumpOp::PopJumpIfFalse)?;
         // Stack: [subject, keys_tuple, values_tuple]
 
         // Unpack values (the original values_tuple)
-        emit!(self, Instruction::UnpackSequence { size });
+        emit!(self, Instruction::UnpackSequence { count: size });
         // Stack after unpack: [subject, keys_tuple, ...unpacked values...]
         pc.on_top += size as usize; // Unpacked size values, tuple replaced by values
         pc.on_top -= 1;
@@ -5639,16 +6490,16 @@ impl Compiler {
             // Stack: [subject, keys_tuple]
 
             // Build rest dict exactly
-            emit!(self, Instruction::BuildMap { size: 0 });
+            emit!(self, Instruction::BuildMap { count: 0 });
             // Stack: [subject, keys_tuple, {}]
-            emit!(self, Instruction::Swap { index: 3 });
+            emit!(self, Instruction::Swap { i: 3 });
             // Stack: [{}, keys_tuple, subject]
-            emit!(self, Instruction::DictUpdate { index: 2 });
+            emit!(self, Instruction::DictUpdate { i: 2 });
             // Stack after DICT_UPDATE: [rest_dict, keys_tuple]
             // DICT_UPDATE consumes source (subject) and leaves dict in place
 
             // Unpack keys and delete from rest_dict
-            emit!(self, Instruction::UnpackSequence { size });
+            emit!(self, Instruction::UnpackSequence { count: size });
             // Stack: [rest_dict, k1, k2, ..., kn] (if size==0, nothing pushed)
 
             // Delete each key from rest_dict (skipped when size==0)
@@ -5656,14 +6507,9 @@ impl Compiler {
             let mut remaining = size;
             while remaining > 0 {
                 // Copy rest_dict which is at position (1 + remaining) from TOS
-                emit!(
-                    self,
-                    Instruction::Copy {
-                        index: 1 + remaining
-                    }
-                );
+                emit!(self, Instruction::Copy { i: 1 + remaining });
                 // Stack: [rest_dict, k1, ..., kn, rest_dict]
-                emit!(self, Instruction::Swap { index: 2 });
+                emit!(self, Instruction::Swap { i: 2 });
                 // Stack: [rest_dict, k1, ..., kn-1, rest_dict, kn]
                 emit!(self, Instruction::DeleteSubscr);
                 // Stack: [rest_dict, k1, ..., kn-1] (removed kn from rest_dict)
@@ -5697,7 +6543,11 @@ impl Compiler {
         // Ensure the pattern is a MatchOr.
         let end = self.new_block(); // Create a new jump target label.
         let size = p.patterns.len();
-        assert!(size > 1, "MatchOr must have more than one alternative");
+        if size <= 1 {
+            return Err(self.error(CodegenErrorType::SyntaxError(
+                "MatchOr requires at least 2 patterns".to_owned(),
+            )));
+        }
 
         // Save the current pattern context.
         let old_pc = pc.clone();
@@ -5715,7 +6565,7 @@ impl Compiler {
             pc.fail_pop.clear();
             pc.on_top = 0;
             // Emit a COPY(1) instruction before compiling the alternative.
-            emit!(self, Instruction::Copy { index: 1_u32 });
+            emit!(self, Instruction::Copy { i: 1 });
             self.compile_pattern(alt, pc)?;
 
             let n_stores = pc.stores.len();
@@ -5759,7 +6609,7 @@ impl Compiler {
                 }
             }
             // Emit a jump to the common end label and reset any failure jump targets.
-            emit!(self, PseudoInstruction::Jump { target: end });
+            emit!(self, PseudoInstruction::Jump { delta: end });
             self.emit_and_reset_fail_pop(pc)?;
         }
 
@@ -5844,7 +6694,7 @@ impl Compiler {
             emit!(
                 self,
                 Instruction::CompareOp {
-                    op: ComparisonOperator::Equal
+                    opname: ComparisonOperator::Equal
                 }
             );
             self.jump_to_fail_pop(pc, JumpOp::PopJumpIfFalse)?;
@@ -5857,7 +6707,7 @@ impl Compiler {
             emit!(
                 self,
                 Instruction::CompareOp {
-                    op: ComparisonOperator::GreaterOrEqual
+                    opname: ComparisonOperator::GreaterOrEqual
                 }
             );
             self.jump_to_fail_pop(pc, JumpOp::PopJumpIfFalse)?;
@@ -5886,7 +6736,7 @@ impl Compiler {
         emit!(
             self,
             Instruction::CompareOp {
-                op: bytecode::ComparisonOperator::Equal
+                opname: bytecode::ComparisonOperator::Equal
             }
         );
         // emit!(self, Instruction::ToBool);
@@ -5906,7 +6756,7 @@ impl Compiler {
             ast::Singleton::True => ConstantData::Boolean { value: true },
         });
         // Compare using the "Is" operator.
-        emit!(self, Instruction::IsOp(Invert::No));
+        emit!(self, Instruction::IsOp { invert: Invert::No });
         // Jump to the failure label if the comparison is false.
         self.jump_to_fail_pop(pc, JumpOp::PopJumpIfFalse)?;
         Ok(())
@@ -5962,7 +6812,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::Copy { index: 1_u32 });
+                emit!(self, Instruction::Copy { i: 1 });
             }
 
             pattern_context.stores = Vec::with_capacity(1);
@@ -5985,7 +6835,7 @@ impl Compiler {
                 emit!(
                     self,
                     Instruction::PopJumpIfFalse {
-                        target: pattern_context.fail_pop[0]
+                        delta: pattern_context.fail_pop[0]
                     }
                 );
             }
@@ -5995,7 +6845,7 @@ impl Compiler {
             }
 
             self.compile_statements(&m.body)?;
-            emit!(self, PseudoInstruction::Jump { target: end });
+            emit!(self, PseudoInstruction::Jump { delta: end });
             self.emit_and_reset_fail_pop(pattern_context)?;
         }
 
@@ -6009,8 +6859,8 @@ impl Compiler {
             if let Some(ref guard) = m.guard {
                 // Compile guard and jump to end if false
                 self.compile_expression(guard)?;
-                emit!(self, Instruction::Copy { index: 1_u32 });
-                emit!(self, Instruction::PopJumpIfFalse { target: end });
+                emit!(self, Instruction::Copy { i: 1 });
+                emit!(self, Instruction::PopJumpIfFalse { delta: end });
                 emit!(self, Instruction::PopTop);
             }
             self.compile_statements(&m.body)?;
@@ -6035,18 +6885,38 @@ impl Compiler {
     fn compile_addcompare(&mut self, op: &ast::CmpOp) {
         use bytecode::ComparisonOperator::*;
         match op {
-            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::Eq => emit!(self, Instruction::CompareOp { opname: Equal }),
+            ast::CmpOp::NotEq => emit!(self, Instruction::CompareOp { opname: NotEqual }),
+            ast::CmpOp::Lt => emit!(self, Instruction::CompareOp { opname: Less }),
+            ast::CmpOp::LtE => emit!(
+                self,
+                Instruction::CompareOp {
+                    opname: LessOrEqual
+                }
+            ),
+            ast::CmpOp::Gt => emit!(self, Instruction::CompareOp { opname: Greater }),
             ast::CmpOp::GtE => {
-                emit!(self, Instruction::CompareOp { op: GreaterOrEqual })
+                emit!(
+                    self,
+                    Instruction::CompareOp {
+                        opname: GreaterOrEqual
+                    }
+                )
             }
-            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)),
+            ast::CmpOp::In => emit!(self, Instruction::ContainsOp { invert: Invert::No }),
+            ast::CmpOp::NotIn => emit!(
+                self,
+                Instruction::ContainsOp {
+                    invert: Invert::Yes
+                }
+            ),
+            ast::CmpOp::Is => emit!(self, Instruction::IsOp { invert: Invert::No }),
+            ast::CmpOp::IsNot => emit!(
+                self,
+                Instruction::IsOp {
+                    invert: Invert::Yes
+                }
+            ),
         }
     }
 
@@ -6074,6 +6944,8 @@ impl Compiler {
         ops: &[ast::CmpOp],
         comparators: &[ast::Expr],
     ) -> CompileResult<()> {
+        // Save the full Compare expression range for COMPARE_OP positions
+        let compare_range = self.current_source_range;
         let (last_op, mid_ops) = ops.split_last().unwrap();
         let (last_comparator, mid_comparators) = comparators.split_last().unwrap();
 
@@ -6082,6 +6954,7 @@ impl Compiler {
 
         if mid_comparators.is_empty() {
             self.compile_expression(last_comparator)?;
+            self.set_source_range(compare_range);
             self.compile_addcompare(last_op);
 
             return Ok(());
@@ -6094,32 +6967,107 @@ impl Compiler {
             self.compile_expression(comparator)?;
 
             // store rhs for the next comparison in chain
-            emit!(self, Instruction::Swap { index: 2 });
-            emit!(self, Instruction::Copy { index: 2 });
+            self.set_source_range(compare_range);
+            emit!(self, Instruction::Swap { i: 2 });
+            emit!(self, Instruction::Copy { i: 2 });
 
             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::PopJumpIfFalse { target: cleanup });
+            emit!(self, Instruction::Copy { i: 1 });
+            emit!(self, Instruction::PopJumpIfFalse { delta: cleanup });
             emit!(self, Instruction::PopTop);
         }
 
         self.compile_expression(last_comparator)?;
+        self.set_source_range(compare_range);
         self.compile_addcompare(last_op);
 
         let end = self.new_block();
-        emit!(self, PseudoInstruction::Jump { target: end });
+        emit!(self, PseudoInstruction::Jump { delta: end });
 
         // 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::Swap { i: 2 });
+        emit!(self, Instruction::PopTop);
+
+        self.switch_to_block(end);
+        Ok(())
+    }
+
+    fn compile_jump_if_compare(
+        &mut self,
+        left: &ast::Expr,
+        ops: &[ast::CmpOp],
+        comparators: &[ast::Expr],
+        condition: bool,
+        target_block: BlockIdx,
+    ) -> CompileResult<()> {
+        let compare_range = self.current_source_range;
+        let (last_op, mid_ops) = ops.split_last().unwrap();
+        let (last_comparator, mid_comparators) = comparators.split_last().unwrap();
+
+        self.compile_expression(left)?;
+
+        if mid_comparators.is_empty() {
+            self.compile_expression(last_comparator)?;
+            self.set_source_range(compare_range);
+            self.compile_addcompare(last_op);
+            self.emit_pop_jump_by_condition(condition, target_block);
+            return Ok(());
+        }
+
+        let cleanup = self.new_block();
+        let end = self.new_block();
+
+        for (op, comparator) in mid_ops.iter().zip(mid_comparators) {
+            self.compile_expression(comparator)?;
+            self.set_source_range(compare_range);
+            emit!(self, Instruction::Swap { i: 2 });
+            emit!(self, Instruction::Copy { i: 2 });
+            self.compile_addcompare(op);
+            emit!(self, Instruction::PopJumpIfFalse { delta: cleanup });
+        }
+
+        self.compile_expression(last_comparator)?;
+        self.set_source_range(compare_range);
+        self.compile_addcompare(last_op);
+        self.emit_pop_jump_by_condition(condition, target_block);
+        emit!(self, PseudoInstruction::Jump { delta: end });
+
+        self.switch_to_block(cleanup);
         emit!(self, Instruction::PopTop);
+        if !condition {
+            emit!(
+                self,
+                PseudoInstruction::Jump {
+                    delta: target_block
+                }
+            );
+        }
 
         self.switch_to_block(end);
         Ok(())
     }
 
+    fn emit_pop_jump_by_condition(&mut self, condition: bool, target_block: BlockIdx) {
+        if condition {
+            emit!(
+                self,
+                Instruction::PopJumpIfTrue {
+                    delta: target_block
+                }
+            );
+        } else {
+            emit!(
+                self,
+                Instruction::PopJumpIfFalse {
+                    delta: target_block,
+                }
+            );
+        }
+    }
+
     fn compile_annotation(&mut self, annotation: &ast::Expr) -> CompileResult<()> {
         if self.future_annotations {
             self.emit_load_const(ConstantData::Str {
@@ -6137,7 +7085,7 @@ impl Compiler {
                     // *args: *Ts (where Ts is a TypeVarTuple).
                     // Do [annotation_value] = [*Ts].
                     self.compile_expression(value)?;
-                    emit!(self, Instruction::UnpackSequence { size: 1 });
+                    emit!(self, Instruction::UnpackSequence { count: 1 });
                     Ok(())
                 }
                 _ => self.compile_expression(annotation),
@@ -6173,7 +7121,12 @@ impl Compiler {
                 self.compile_annotation(annotation)?;
                 // Load __annotations__
                 let annotations_name = self.name("__annotations__");
-                emit!(self, Instruction::LoadName(annotations_name));
+                emit!(
+                    self,
+                    Instruction::LoadName {
+                        namei: annotations_name
+                    }
+                );
                 // Load the variable name
                 self.emit_load_const(ConstantData::Str {
                     value: self.mangle(id.as_str()).into_owned().into(),
@@ -6199,12 +7152,11 @@ impl Compiler {
 
                     // Only add to __conditional_annotations__ set if actually conditional
                     if is_conditional {
-                        let cond_annotations_name = self.name("__conditional_annotations__");
-                        emit!(self, Instruction::LoadName(cond_annotations_name));
+                        self.load_name("__conditional_annotations__")?;
                         self.emit_load_const(ConstantData::Integer {
                             value: annotation_index.into(),
                         });
-                        emit!(self, Instruction::SetAdd { i: 0_u32 });
+                        emit!(self, Instruction::SetAdd { i: 1 });
                         emit!(self, Instruction::PopTop);
                     }
                 }
@@ -6224,8 +7176,8 @@ impl Compiler {
             }
             ast::Expr::Attribute(ast::ExprAttribute { value, attr, .. }) => {
                 self.compile_expression(value)?;
-                let idx = self.name(attr.as_str());
-                emit!(self, Instruction::StoreAttr { idx });
+                let namei = self.name(attr.as_str());
+                emit!(self, Instruction::StoreAttr { namei });
             }
             ast::Expr::List(ast::ExprList { elts, .. })
             | ast::Expr::Tuple(ast::ExprTuple { elts, .. }) => {
@@ -6247,8 +7199,8 @@ impl Compiler {
                                         target.range(),
                                     )
                                 })?;
-                            let args = bytecode::UnpackExArgs { before, after };
-                            emit!(self, Instruction::UnpackEx { args });
+                            let counts = bytecode::UnpackExArgs { before, after };
+                            emit!(self, Instruction::UnpackEx { counts });
                         }
                     }
                 }
@@ -6257,7 +7209,7 @@ impl Compiler {
                     emit!(
                         self,
                         Instruction::UnpackSequence {
-                            size: elts.len().to_u32(),
+                            count: elts.len().to_u32(),
                         }
                     );
                 }
@@ -6311,8 +7263,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::Copy { index: 2_u32 });
-                emit!(self, Instruction::Copy { index: 2_u32 });
+                emit!(self, Instruction::Copy { i: 2 });
+                emit!(self, Instruction::Copy { i: 2 });
                 emit!(
                     self,
                     Instruction::BinaryOp {
@@ -6324,7 +7276,7 @@ impl Compiler {
             ast::Expr::Attribute(ast::ExprAttribute { value, attr, .. }) => {
                 let attr = attr.as_str();
                 self.compile_expression(value)?;
-                emit!(self, Instruction::Copy { index: 1_u32 });
+                emit!(self, Instruction::Copy { i: 1 });
                 let idx = self.name(attr);
                 self.emit_load_attr(idx);
                 AugAssignKind::Attr { idx }
@@ -6344,14 +7296,14 @@ impl Compiler {
             }
             AugAssignKind::Subscript => {
                 // stack: CONTAINER SLICE RESULT
-                emit!(self, Instruction::Swap { index: 3 });
-                emit!(self, Instruction::Swap { index: 2 });
+                emit!(self, Instruction::Swap { i: 3 });
+                emit!(self, Instruction::Swap { i: 2 });
                 emit!(self, Instruction::StoreSubscr);
             }
             AugAssignKind::Attr { idx } => {
                 // stack: CONTAINER RESULT
-                emit!(self, Instruction::Swap { index: 2 });
-                emit!(self, Instruction::StoreAttr { idx });
+                emit!(self, Instruction::Swap { i: 2 });
+                emit!(self, Instruction::StoreAttr { namei: idx });
             }
         }
 
@@ -6393,8 +7345,11 @@ impl Compiler {
         condition: bool,
         target_block: BlockIdx,
     ) -> CompileResult<()> {
+        let prev_source_range = self.current_source_range;
+        self.set_source_range(expression.range());
+
         // Compile expression for test, and jump to label if false
-        match &expression {
+        let result = match &expression {
             ast::Expr::BoolOp(ast::ExprBoolOp { op, values, .. }) => {
                 match op {
                     ast::BoolOp::And => {
@@ -6440,67 +7395,128 @@ impl Compiler {
                         }
                     }
                 }
+                Ok(())
             }
             ast::Expr::UnaryOp(ast::ExprUnaryOp {
                 op: ast::UnaryOp::Not,
                 operand,
                 ..
-            }) => {
-                self.compile_jump_if(operand, !condition, target_block)?;
+            }) => self.compile_jump_if(operand, !condition, target_block),
+            ast::Expr::Compare(ast::ExprCompare {
+                left,
+                ops,
+                comparators,
+                ..
+            }) if ops.len() > 1 => {
+                self.compile_jump_if_compare(left, ops, comparators, condition, target_block)
+            }
+            // `x is None` / `x is not None` → POP_JUMP_IF_NONE / POP_JUMP_IF_NOT_NONE
+            ast::Expr::Compare(ast::ExprCompare {
+                left,
+                ops,
+                comparators,
+                ..
+            }) if ops.len() == 1
+                && matches!(ops[0], ast::CmpOp::Is | ast::CmpOp::IsNot)
+                && comparators.len() == 1
+                && matches!(&comparators[0], ast::Expr::NoneLiteral(_)) =>
+            {
+                self.compile_expression(left)?;
+                let is_not = matches!(ops[0], ast::CmpOp::IsNot);
+                // is None + jump_if_false → POP_JUMP_IF_NOT_NONE
+                // is None + jump_if_true → POP_JUMP_IF_NONE
+                // is not None + jump_if_false → POP_JUMP_IF_NONE
+                // is not None + jump_if_true → POP_JUMP_IF_NOT_NONE
+                let jump_if_none = condition != is_not;
+                if jump_if_none {
+                    emit!(
+                        self,
+                        Instruction::PopJumpIfNone {
+                            delta: target_block,
+                        }
+                    );
+                } else {
+                    emit!(
+                        self,
+                        Instruction::PopJumpIfNotNone {
+                            delta: target_block,
+                        }
+                    );
+                }
+                Ok(())
             }
             _ => {
                 // Fall back case which always will work!
                 self.compile_expression(expression)?;
+                // Compare already produces a bool; everything else needs TO_BOOL
+                if !matches!(expression, ast::Expr::Compare(_)) {
+                    emit!(self, Instruction::ToBool);
+                }
                 if condition {
                     emit!(
                         self,
                         Instruction::PopJumpIfTrue {
-                            target: target_block,
+                            delta: target_block,
                         }
                     );
                 } else {
                     emit!(
                         self,
                         Instruction::PopJumpIfFalse {
-                            target: target_block,
+                            delta: target_block,
                         }
                     );
                 }
+                Ok(())
             }
-        }
-        Ok(())
+        };
+
+        self.set_source_range(prev_source_range);
+        result
     }
 
     /// Compile a boolean operation as an expression.
     /// This means, that the last value remains on the stack.
     fn compile_bool_op(&mut self, op: &ast::BoolOp, values: &[ast::Expr]) -> CompileResult<()> {
-        let after_block = self.new_block();
+        self.compile_bool_op_with_target(op, values, None)
+    }
 
+    /// Compile a boolean operation as an expression, with an optional
+    /// short-circuit target override. When `short_circuit_target` is `Some`,
+    /// the short-circuit jumps go to that block instead of the default
+    /// `after_block`, enabling jump threading to avoid redundant `__bool__` calls.
+    fn compile_bool_op_with_target(
+        &mut self,
+        op: &ast::BoolOp,
+        values: &[ast::Expr],
+        short_circuit_target: Option<BlockIdx>,
+    ) -> CompileResult<()> {
+        let after_block = self.new_block();
         let (last_value, values) = values.split_last().unwrap();
+        let jump_target = short_circuit_target.unwrap_or(after_block);
 
         for value in values {
-            self.compile_expression(value)?;
-
-            emit!(self, Instruction::Copy { index: 1_u32 });
-            match op {
-                ast::BoolOp::And => {
-                    emit!(
-                        self,
-                        Instruction::PopJumpIfFalse {
-                            target: after_block,
-                        }
-                    );
-                }
-                ast::BoolOp::Or => {
-                    emit!(
-                        self,
-                        Instruction::PopJumpIfTrue {
-                            target: after_block,
-                        }
-                    );
-                }
+            // Optimization: when a non-last value is a BoolOp with the opposite
+            // operator, redirect its short-circuit exits to skip the outer's
+            // redundant __bool__ test (jump threading).
+            if short_circuit_target.is_none()
+                && let ast::Expr::BoolOp(ast::ExprBoolOp {
+                    op: inner_op,
+                    values: inner_values,
+                    ..
+                }) = value
+                && inner_op != op
+            {
+                let pop_block = self.new_block();
+                self.compile_bool_op_with_target(inner_op, inner_values, Some(pop_block))?;
+                self.emit_short_circuit_test(op, after_block);
+                self.switch_to_block(pop_block);
+                emit!(self, Instruction::PopTop);
+                continue;
             }
 
+            self.compile_expression(value)?;
+            self.emit_short_circuit_test(op, jump_target);
             emit!(self, Instruction::PopTop);
         }
 
@@ -6510,21 +7526,148 @@ impl Compiler {
         Ok(())
     }
 
+    /// Emit `Copy 1` + conditional jump for short-circuit evaluation.
+    /// For `And`, emits `PopJumpIfFalse`; for `Or`, emits `PopJumpIfTrue`.
+    fn emit_short_circuit_test(&mut self, op: &ast::BoolOp, target: BlockIdx) {
+        emit!(self, Instruction::Copy { i: 1 });
+        emit!(self, Instruction::ToBool);
+        match op {
+            ast::BoolOp::And => {
+                emit!(self, Instruction::PopJumpIfFalse { delta: target });
+            }
+            ast::BoolOp::Or => {
+                emit!(self, Instruction::PopJumpIfTrue { delta: target });
+            }
+        }
+    }
+
     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;
-        let (packed, unpacked): (Vec<_>, Vec<_>) = items.iter().partition(|x| x.key.is_some());
-        for item in packed {
-            self.compile_expression(item.key.as_ref().unwrap())?;
-            self.compile_expression(&item.value)?;
-            size += 1;
+        let has_unpacking = items.iter().any(|item| item.key.is_none());
+
+        if !has_unpacking {
+            // Match CPython's compiler_subdict chunking strategy:
+            // - n≤15: BUILD_MAP n (all pairs on stack)
+            // - n>15: BUILD_MAP 0 + MAP_ADD chunks of 17, last chunk uses
+            //   BUILD_MAP n (if ≤15) or BUILD_MAP 0 + MAP_ADD
+            const STACK_LIMIT: usize = 15;
+            const BIG_MAP_CHUNK: usize = 17;
+
+            if items.len() <= STACK_LIMIT {
+                for item in items {
+                    self.compile_expression(item.key.as_ref().unwrap())?;
+                    self.compile_expression(&item.value)?;
+                }
+                emit!(
+                    self,
+                    Instruction::BuildMap {
+                        count: u32::try_from(items.len()).expect("too many dict items"),
+                    }
+                );
+            } else {
+                // Split: leading full chunks of BIG_MAP_CHUNK via MAP_ADD,
+                // remainder via BUILD_MAP n or MAP_ADD depending on size
+                let n = items.len();
+                let remainder = n % BIG_MAP_CHUNK;
+                let n_big_chunks = n / BIG_MAP_CHUNK;
+                // If remainder fits on stack (≤15), use BUILD_MAP n for it.
+                // Otherwise it becomes another MAP_ADD chunk.
+                let (big_count, tail_count) = if remainder > 0 && remainder <= STACK_LIMIT {
+                    (n_big_chunks, remainder)
+                } else {
+                    // remainder is 0 or >15: all chunks are MAP_ADD chunks
+                    let total_map_add = if remainder == 0 {
+                        n_big_chunks
+                    } else {
+                        n_big_chunks + 1
+                    };
+                    (total_map_add, 0usize)
+                };
+
+                emit!(self, Instruction::BuildMap { count: 0 });
+
+                let mut idx = 0;
+                for chunk_i in 0..big_count {
+                    if chunk_i > 0 {
+                        emit!(self, Instruction::BuildMap { count: 0 });
+                    }
+                    let chunk_size = if idx + BIG_MAP_CHUNK <= n - tail_count {
+                        BIG_MAP_CHUNK
+                    } else {
+                        n - tail_count - idx
+                    };
+                    for item in &items[idx..idx + chunk_size] {
+                        self.compile_expression(item.key.as_ref().unwrap())?;
+                        self.compile_expression(&item.value)?;
+                        emit!(self, Instruction::MapAdd { i: 1 });
+                    }
+                    if chunk_i > 0 {
+                        emit!(self, Instruction::DictUpdate { i: 1 });
+                    }
+                    idx += chunk_size;
+                }
+
+                // Tail: remaining pairs via BUILD_MAP n + DICT_UPDATE
+                if tail_count > 0 {
+                    for item in &items[idx..idx + tail_count] {
+                        self.compile_expression(item.key.as_ref().unwrap())?;
+                        self.compile_expression(&item.value)?;
+                    }
+                    emit!(
+                        self,
+                        Instruction::BuildMap {
+                            count: tail_count.to_u32(),
+                        }
+                    );
+                    emit!(self, Instruction::DictUpdate { i: 1 });
+                }
+            }
+            return Ok(());
+        }
+
+        // Complex case with ** unpacking: preserve insertion order.
+        // Collect runs of regular k:v pairs and emit BUILD_MAP + DICT_UPDATE
+        // for each run, and DICT_UPDATE for each ** entry.
+        let mut have_dict = false;
+        let mut elements: u32 = 0;
+
+        // Flush pending regular pairs as a BUILD_MAP, merging into the
+        // accumulator dict via DICT_UPDATE when one already exists.
+        macro_rules! flush_pending {
+            () => {
+                #[allow(unused_assignments)]
+                if elements > 0 {
+                    emit!(self, Instruction::BuildMap { count: elements });
+                    if have_dict {
+                        emit!(self, Instruction::DictUpdate { i: 1 });
+                    } else {
+                        have_dict = true;
+                    }
+                    elements = 0;
+                }
+            };
+        }
+
+        for item in items {
+            if let Some(key) = &item.key {
+                // Regular key: value pair
+                self.compile_expression(key)?;
+                self.compile_expression(&item.value)?;
+                elements += 1;
+            } else {
+                // ** unpacking entry
+                flush_pending!();
+                if !have_dict {
+                    emit!(self, Instruction::BuildMap { count: 0 });
+                    have_dict = true;
+                }
+                self.compile_expression(&item.value)?;
+                emit!(self, Instruction::DictUpdate { i: 1 });
+            }
         }
-        emit!(self, Instruction::BuildMap { size });
 
-        for item in unpacked {
-            self.compile_expression(&item.value)?;
-            emit!(self, Instruction::DictUpdate { index: 1 });
+        flush_pending!();
+        if !have_dict {
+            emit!(self, Instruction::BuildMap { count: 0 });
         }
 
         Ok(())
@@ -6544,42 +7687,38 @@ impl Compiler {
     ///     CLEANUP_THROW
     ///   exit:
     ///     END_SEND
-    fn compile_yield_from_sequence(&mut self, is_await: bool) -> CompileResult<()> {
+    fn compile_yield_from_sequence(&mut self, is_await: bool) -> CompileResult<BlockIdx> {
         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 });
+        emit!(self, Instruction::Send { delta: 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(
+        emit!(self, PseudoInstruction::SetupFinally { delta: fail_block });
+        self.push_fblock(
             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)
+        // POP_BLOCK before RESUME
+        emit!(self, PseudoInstruction::PopBlock);
         self.pop_fblock(FBlockType::TryExcept);
 
         // RESUME
         emit!(
             self,
             Instruction::Resume {
-                arg: if is_await {
-                    bytecode::ResumeType::AfterAwait as u32
+                context: if is_await {
+                    oparg::ResumeContext::from(oparg::ResumeLocation::AfterAwait)
                 } else {
-                    bytecode::ResumeType::AfterYieldFrom as u32
+                    oparg::ResumeContext::from(oparg::ResumeLocation::AfterYieldFrom)
                 }
             }
         );
@@ -6587,7 +7726,7 @@ impl Compiler {
         // JUMP_BACKWARD_NO_INTERRUPT send
         emit!(
             self,
-            PseudoInstruction::JumpNoInterrupt { target: send_block }
+            PseudoInstruction::JumpNoInterrupt { delta: send_block }
         );
 
         // fail: CLEANUP_THROW
@@ -6604,7 +7743,39 @@ impl Compiler {
         self.switch_to_block(exit_block);
         emit!(self, Instruction::EndSend);
 
-        Ok(())
+        Ok(send_block)
+    }
+
+    /// Returns true if the expression is a constant with no side effects.
+    fn is_const_expression(expr: &ast::Expr) -> bool {
+        matches!(
+            expr,
+            ast::Expr::StringLiteral(_)
+                | ast::Expr::BytesLiteral(_)
+                | ast::Expr::NumberLiteral(_)
+                | ast::Expr::BooleanLiteral(_)
+                | ast::Expr::NoneLiteral(_)
+                | ast::Expr::EllipsisLiteral(_)
+        ) || matches!(expr, ast::Expr::FString(fstring) if Self::fstring_value_is_const(&fstring.value))
+    }
+
+    fn fstring_value_is_const(fstring: &ast::FStringValue) -> bool {
+        for part in fstring {
+            if !Self::fstring_part_is_const(part) {
+                return false;
+            }
+        }
+        true
+    }
+
+    fn fstring_part_is_const(part: &ast::FStringPart) -> bool {
+        match part {
+            ast::FStringPart::Literal(_) => true,
+            ast::FStringPart::FString(fstring) => fstring
+                .elements
+                .iter()
+                .all(|element| matches!(element, ast::InterpolatedStringElement::Literal(_))),
+        }
     }
 
     fn compile_expression(&mut self, expression: &ast::Expr) -> CompileResult<()> {
@@ -6622,10 +7793,20 @@ impl Compiler {
             ast::Expr::BinOp(ast::ExprBinOp {
                 left, op, right, ..
             }) => {
+                // optimize_format_str: 'format' % (args,) → f-string bytecode
+                if matches!(op, ast::Operator::Mod)
+                    && let ast::Expr::StringLiteral(s) = left.as_ref()
+                    && let ast::Expr::Tuple(ast::ExprTuple { elts, .. }) = right.as_ref()
+                    && !elts.iter().any(|e| matches!(e, ast::Expr::Starred(_)))
+                    && self.try_optimize_format_str(s.value.to_str(), elts, range)?
+                {
+                    return Ok(());
+                }
                 self.compile_expression(left)?;
                 self.compile_expression(right)?;
 
-                // Perform operation:
+                // Restore full expression range before emitting the operation
+                self.set_source_range(range);
                 self.compile_op(op, false);
             }
             ast::Expr::Subscript(ast::ExprSubscript {
@@ -6636,7 +7817,8 @@ impl Compiler {
             ast::Expr::UnaryOp(ast::ExprUnaryOp { op, operand, .. }) => {
                 self.compile_expression(operand)?;
 
-                // Perform operation:
+                // Restore full expression range before emitting the operation
+                self.set_source_range(range);
                 match op {
                     ast::UnaryOp::UAdd => emit!(
                         self,
@@ -6657,7 +7839,11 @@ impl Compiler {
                 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]
+                    // Set source range to super() call for arg-loading instructions
+                    let super_range = value.range();
+                    self.set_source_range(super_range);
                     self.load_args_for_super(&super_type)?;
+                    self.set_source_range(super_range);
                     let idx = self.name(attr.as_str());
                     match super_type {
                         SuperCallType::TwoArg { .. } => {
@@ -6700,6 +7886,14 @@ impl Compiler {
             ast::Expr::Slice(ast::ExprSlice {
                 lower, upper, step, ..
             }) => {
+                // Try constant slice folding first
+                if self.try_fold_constant_slice(
+                    lower.as_deref(),
+                    upper.as_deref(),
+                    step.as_deref(),
+                )? {
+                    return Ok(());
+                }
                 let mut compile_bound = |bound: Option<&ast::Expr>| match bound {
                     Some(exp) => self.compile_expression(exp),
                     None => {
@@ -6727,12 +7921,20 @@ impl Compiler {
                     Some(expression) => self.compile_expression(expression)?,
                     Option::None => self.emit_load_const(ConstantData::None),
                 };
+                if self.ctx.func == FunctionContext::AsyncFunction {
+                    emit!(
+                        self,
+                        Instruction::CallIntrinsic1 {
+                            func: bytecode::IntrinsicFunction1::AsyncGenWrap
+                        }
+                    );
+                }
                 // arg=0: direct yield (wrapped for async generators)
                 emit!(self, Instruction::YieldValue { arg: 0 });
                 emit!(
                     self,
                     Instruction::Resume {
-                        arg: bytecode::ResumeType::AfterYield as u32
+                        context: oparg::ResumeContext::from(oparg::ResumeLocation::AfterYield)
                     }
                 );
             }
@@ -6741,9 +7943,9 @@ impl Compiler {
                     return Err(self.error(CodegenErrorType::InvalidAwait));
                 }
                 self.compile_expression(value)?;
-                emit!(self, Instruction::GetAwaitable);
+                emit!(self, Instruction::GetAwaitable { r#where: 0 });
                 self.emit_load_const(ConstantData::None);
-                self.compile_yield_from_sequence(true)?;
+                let _ = self.compile_yield_from_sequence(true)?;
             }
             ast::Expr::YieldFrom(ast::ExprYieldFrom { value, .. }) => {
                 match self.ctx.func {
@@ -6759,7 +7961,7 @@ impl Compiler {
                 self.compile_expression(value)?;
                 emit!(self, Instruction::GetYieldFromIter);
                 self.emit_load_const(ConstantData::None);
-                self.compile_yield_from_sequence(false)?;
+                let _ = self.compile_yield_from_sequence(false)?;
             }
             ast::Expr::Name(ast::ExprName { id, .. }) => self.load_name(id.as_str())?,
             ast::Expr::Lambda(ast::ExprLambda {
@@ -6785,7 +7987,7 @@ impl Compiler {
                     for element in &defaults {
                         self.compile_expression(element)?;
                     }
-                    emit!(self, Instruction::BuildTuple { size });
+                    emit!(self, Instruction::BuildTuple { count: size });
                 }
 
                 // Prepare keyword-only defaults
@@ -6801,25 +8003,25 @@ impl Compiler {
                     let default_kw_count = kw_with_defaults.len();
                     for (arg, default) in &kw_with_defaults {
                         self.emit_load_const(ConstantData::Str {
-                            value: arg.name.as_str().into(),
+                            value: self.mangle(arg.name.as_str()).into_owned().into(),
                         });
                         self.compile_expression(default)?;
                     }
                     emit!(
                         self,
                         Instruction::BuildMap {
-                            size: default_kw_count.to_u32(),
+                            count: default_kw_count.to_u32(),
                         }
                     );
                 }
 
                 self.enter_function(&name, params)?;
-                let mut func_flags = bytecode::MakeFunctionFlags::empty();
+                let mut func_flags = bytecode::MakeFunctionFlags::new();
                 if have_defaults {
-                    func_flags |= bytecode::MakeFunctionFlags::DEFAULTS;
+                    func_flags.insert(bytecode::MakeFunctionFlag::Defaults);
                 }
                 if have_kwdefaults {
-                    func_flags |= bytecode::MakeFunctionFlags::KW_ONLY_DEFAULTS;
+                    func_flags.insert(bytecode::MakeFunctionFlag::KwOnlyDefaults);
                 }
 
                 // Set qualname for lambda
@@ -6851,7 +8053,7 @@ impl Compiler {
                     "<listcomp>",
                     Some(
                         Instruction::BuildList {
-                            size: OpArgMarker::marker(),
+                            count: OpArgMarker::marker(),
                         }
                         .into(),
                     ),
@@ -6861,7 +8063,7 @@ impl Compiler {
                         emit!(
                             compiler,
                             Instruction::ListAppend {
-                                i: generators.len().to_u32(),
+                                i: (generators.len() + 1).to_u32(),
                             }
                         );
                         Ok(())
@@ -6877,7 +8079,7 @@ impl Compiler {
                     "<setcomp>",
                     Some(
                         Instruction::BuildSet {
-                            size: OpArgMarker::marker(),
+                            count: OpArgMarker::marker(),
                         }
                         .into(),
                     ),
@@ -6887,7 +8089,7 @@ impl Compiler {
                         emit!(
                             compiler,
                             Instruction::SetAdd {
-                                i: generators.len().to_u32(),
+                                i: (generators.len() + 1).to_u32(),
                             }
                         );
                         Ok(())
@@ -6906,7 +8108,7 @@ impl Compiler {
                     "<dictcomp>",
                     Some(
                         Instruction::BuildMap {
-                            size: OpArgMarker::marker(),
+                            count: OpArgMarker::marker(),
                         }
                         .into(),
                     ),
@@ -6919,7 +8121,7 @@ impl Compiler {
                         emit!(
                             compiler,
                             Instruction::MapAdd {
-                                i: generators.len().to_u32(),
+                                i: (generators.len() + 1).to_u32(),
                             }
                         );
 
@@ -6949,12 +8151,22 @@ impl Compiler {
                         compiler.compile_comprehension_element(elt)?;
 
                         compiler.mark_generator();
+                        if compiler.ctx.func == FunctionContext::AsyncFunction {
+                            emit!(
+                                compiler,
+                                Instruction::CallIntrinsic1 {
+                                    func: bytecode::IntrinsicFunction1::AsyncGenWrap
+                                }
+                            );
+                        }
                         // arg=0: direct yield (wrapped for async generators)
                         emit!(compiler, Instruction::YieldValue { arg: 0 });
                         emit!(
                             compiler,
                             Instruction::Resume {
-                                arg: bytecode::ResumeType::AfterYield as u32
+                                context: oparg::ResumeContext::from(
+                                    oparg::ResumeLocation::AfterYield
+                                )
                             }
                         );
                         emit!(compiler, Instruction::PopTop);
@@ -6984,12 +8196,7 @@ impl Compiler {
 
                 // True case
                 self.compile_expression(body)?;
-                emit!(
-                    self,
-                    PseudoInstruction::Jump {
-                        target: after_block,
-                    }
-                );
+                emit!(self, PseudoInstruction::Jump { delta: after_block });
 
                 // False case
                 self.switch_to_block(else_block);
@@ -7005,8 +8212,16 @@ impl Compiler {
                 node_index: _,
                 range: _,
             }) => {
+                // Walrus targets in inlined comps should NOT be hidden from locals()
+                if self.current_code_info().in_inlined_comp
+                    && let ast::Expr::Name(ast::ExprName { id, .. }) = target.as_ref()
+                {
+                    let name = self.mangle(id.as_str());
+                    let info = self.code_stack.last_mut().unwrap();
+                    info.metadata.fast_hidden.insert(name.to_string(), false);
+                }
                 self.compile_expression(value)?;
-                emit!(self, Instruction::Copy { index: 1_u32 });
+                emit!(self, Instruction::Copy { i: 1 });
                 self.compile_store(target)?;
             }
             ast::Expr::FString(fstring) => {
@@ -7016,23 +8231,8 @@ impl Compiler {
                 self.compile_expr_tstring(tstring)?;
             }
             ast::Expr::StringLiteral(string) => {
-                let value = string.value.to_str();
-                if value.contains(char::REPLACEMENT_CHARACTER) {
-                    let value = string
-                        .value
-                        .iter()
-                        .map(|lit| {
-                            let source = self.source_file.slice(lit.range);
-                            crate::string_parser::parse_string_literal(source, lit.flags.into())
-                        })
-                        .collect();
-                    // might have a surrogate literal; should reparse to be sure
-                    self.emit_load_const(ConstantData::Str { value });
-                } else {
-                    self.emit_load_const(ConstantData::Str {
-                        value: value.into(),
-                    });
-                }
+                let value = self.compile_string_value(string);
+                self.emit_load_const(ConstantData::Str { value });
             }
             ast::Expr::BytesLiteral(bytes) => {
                 let iter = bytes.value.iter().flat_map(|x| x.iter().copied());
@@ -7089,28 +8289,182 @@ impl Compiler {
                         sub_size += 1;
                     }
                 }
-                emit!(self, Instruction::BuildMap { size: sub_size });
+                emit!(self, Instruction::BuildMap { count: sub_size });
                 size += 1;
             }
         }
         if size > 1 {
             // Merge all dicts: first dict is accumulator, merge rest into it
             for _ in 1..size {
-                emit!(self, Instruction::DictMerge { index: 1 });
+                emit!(self, Instruction::DictMerge { i: 1 });
+            }
+        }
+        Ok(())
+    }
+
+    fn detect_builtin_generator_call(
+        &self,
+        func: &ast::Expr,
+        args: &ast::Arguments,
+    ) -> Option<BuiltinGeneratorCallKind> {
+        let ast::Expr::Name(ast::ExprName { id, .. }) = func else {
+            return None;
+        };
+        if args.args.len() != 1
+            || !args.keywords.is_empty()
+            || !matches!(args.args[0], ast::Expr::Generator(_))
+        {
+            return None;
+        }
+        match id.as_str() {
+            "tuple" => Some(BuiltinGeneratorCallKind::Tuple),
+            "list" => Some(BuiltinGeneratorCallKind::List),
+            "set" => Some(BuiltinGeneratorCallKind::Set),
+            "all" => Some(BuiltinGeneratorCallKind::All),
+            "any" => Some(BuiltinGeneratorCallKind::Any),
+            _ => None,
+        }
+    }
+
+    /// Emit the optimized inline loop for builtin(genexpr) calls.
+    ///
+    /// Stack on entry: `[func, iter]` where `iter` is the already-compiled
+    /// generator iterator and `func` is the builtin candidate.
+    /// On return the compiler is positioned at the fallback block with
+    /// `[func, iter]` still on the stack (for the normal CALL path).
+    fn optimize_builtin_generator_call(
+        &mut self,
+        kind: BuiltinGeneratorCallKind,
+        end: BlockIdx,
+    ) -> CompileResult<()> {
+        let common_constant = match kind {
+            BuiltinGeneratorCallKind::Tuple => bytecode::CommonConstant::BuiltinTuple,
+            BuiltinGeneratorCallKind::List => bytecode::CommonConstant::BuiltinList,
+            BuiltinGeneratorCallKind::Set => bytecode::CommonConstant::BuiltinSet,
+            BuiltinGeneratorCallKind::All => bytecode::CommonConstant::BuiltinAll,
+            BuiltinGeneratorCallKind::Any => bytecode::CommonConstant::BuiltinAny,
+        };
+
+        let loop_block = self.new_block();
+        let cleanup = self.new_block();
+        let fallback = self.new_block();
+        let result = matches!(
+            kind,
+            BuiltinGeneratorCallKind::All | BuiltinGeneratorCallKind::Any
+        )
+        .then(|| self.new_block());
+
+        // Stack: [func, iter] — copy func (TOS1) for identity check
+        emit!(self, Instruction::Copy { i: 2 });
+        emit!(
+            self,
+            Instruction::LoadCommonConstant {
+                idx: common_constant
+            }
+        );
+        emit!(self, Instruction::IsOp { invert: Invert::No });
+        emit!(self, Instruction::PopJumpIfFalse { delta: fallback });
+        emit!(self, Instruction::NotTaken);
+        // Remove func from [func, iter] → [iter]
+        emit!(self, Instruction::Swap { i: 2 });
+        emit!(self, Instruction::PopTop);
+
+        if matches!(
+            kind,
+            BuiltinGeneratorCallKind::Tuple | BuiltinGeneratorCallKind::List
+        ) {
+            // [iter] → [iter, list] → [list, iter]
+            emit!(self, Instruction::BuildList { count: 0 });
+            emit!(self, Instruction::Swap { i: 2 });
+        } else if matches!(kind, BuiltinGeneratorCallKind::Set) {
+            // [iter] → [iter, set] → [set, iter]
+            emit!(self, Instruction::BuildSet { count: 0 });
+            emit!(self, Instruction::Swap { i: 2 });
+        }
+
+        self.switch_to_block(loop_block);
+        emit!(self, Instruction::ForIter { delta: cleanup });
+
+        match kind {
+            BuiltinGeneratorCallKind::Tuple | BuiltinGeneratorCallKind::List => {
+                emit!(self, Instruction::ListAppend { i: 2 });
+                emit!(self, PseudoInstruction::Jump { delta: loop_block });
+            }
+            BuiltinGeneratorCallKind::Set => {
+                emit!(self, Instruction::SetAdd { i: 2 });
+                emit!(self, PseudoInstruction::Jump { delta: loop_block });
+            }
+            BuiltinGeneratorCallKind::All => {
+                let result = result.expect("all() optimization should have a result block");
+                emit!(self, Instruction::ToBool);
+                emit!(self, Instruction::PopJumpIfFalse { delta: result });
+                emit!(self, Instruction::NotTaken);
+                emit!(self, PseudoInstruction::Jump { delta: loop_block });
+            }
+            BuiltinGeneratorCallKind::Any => {
+                let result = result.expect("any() optimization should have a result block");
+                emit!(self, Instruction::ToBool);
+                emit!(self, Instruction::PopJumpIfTrue { delta: result });
+                emit!(self, Instruction::NotTaken);
+                emit!(self, PseudoInstruction::Jump { delta: loop_block });
+            }
+        }
+
+        if let Some(result_block) = result {
+            self.switch_to_block(result_block);
+            emit!(self, Instruction::PopIter);
+            self.emit_load_const(ConstantData::Boolean {
+                value: matches!(kind, BuiltinGeneratorCallKind::Any),
+            });
+            emit!(self, PseudoInstruction::Jump { delta: end });
+        }
+
+        self.switch_to_block(cleanup);
+        emit!(self, Instruction::EndFor);
+        emit!(self, Instruction::PopIter);
+        match kind {
+            BuiltinGeneratorCallKind::Tuple => {
+                emit!(
+                    self,
+                    Instruction::CallIntrinsic1 {
+                        func: IntrinsicFunction1::ListToTuple
+                    }
+                );
+            }
+            BuiltinGeneratorCallKind::List | BuiltinGeneratorCallKind::Set => {}
+            BuiltinGeneratorCallKind::All => {
+                self.emit_load_const(ConstantData::Boolean { value: true });
+            }
+            BuiltinGeneratorCallKind::Any => {
+                self.emit_load_const(ConstantData::Boolean { value: false });
             }
         }
+        emit!(self, PseudoInstruction::Jump { delta: end });
+
+        self.switch_to_block(fallback);
         Ok(())
     }
 
     fn compile_call(&mut self, func: &ast::Expr, args: &ast::Arguments) -> CompileResult<()> {
+        // Save the call expression's source range so CALL instructions use the
+        // call start line, not the last argument's line.
+        let call_range = self.current_source_range;
+        let uses_ex_call = self.call_uses_ex_call(args);
+
         // Method call: obj → LOAD_ATTR_METHOD → [method, self_or_null] → args → CALL
         // Regular call: func → PUSH_NULL → args → CALL
         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()) {
+            if !uses_ex_call
+                && 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]
+                // Set source range to the super() call for LOAD_GLOBAL/LOAD_DEREF/etc.
+                let super_range = value.range();
+                self.set_source_range(super_range);
                 self.load_args_for_super(&super_type)?;
+                self.set_source_range(super_range);
                 let idx = self.name(attr.as_str());
                 match super_type {
                     SuperCallType::TwoArg { .. } => {
@@ -7120,25 +8474,64 @@ impl Compiler {
                         self.emit_load_zero_super_method(idx);
                     }
                 }
-                self.codegen_call_helper(0, args)?;
+                // NOP for line tracking at .method( line
+                self.set_source_range(attr.range());
+                emit!(self, Instruction::Nop);
+                // CALL at .method( line (not the full expression line)
+                self.codegen_call_helper(0, args, attr.range())?;
             } else {
-                // Normal method call: compile object, then LOAD_ATTR with method flag
-                // LOAD_ATTR(method=1) pushes [method, self_or_null] on stack
                 self.compile_expression(value)?;
                 let idx = self.name(attr.as_str());
-                self.emit_load_attr_method(idx);
-                self.codegen_call_helper(0, args)?;
+                // Imported names and CALL_FUNCTION_EX-style calls use plain
+                // LOAD_ATTR + PUSH_NULL; other names use method-call mode.
+                // Check current scope and enclosing scopes for IMPORTED flag.
+                let is_import = matches!(value.as_ref(), ast::Expr::Name(ast::ExprName { id, .. })
+                    if self.is_name_imported(id.as_str()));
+                if is_import || uses_ex_call {
+                    self.emit_load_attr(idx);
+                    emit!(self, Instruction::PushNull);
+                } else {
+                    self.emit_load_attr_method(idx);
+                }
+                self.codegen_call_helper(0, args, call_range)?;
             }
+        } else if let Some(kind) = (!uses_ex_call)
+            .then(|| self.detect_builtin_generator_call(func, args))
+            .flatten()
+        {
+            // Optimized builtin(genexpr) path: compile the genexpr only once
+            // so its code object appears exactly once in co_consts.
+            let end = self.new_block();
+            self.compile_expression(func)?;
+            self.compile_expression(&args.args[0])?;
+            // Stack: [func, iter]
+            self.optimize_builtin_generator_call(kind, end)?;
+            // Fallback block: [func, iter] → [func, null, iter] → CALL
+            emit!(self, Instruction::PushNull);
+            emit!(self, Instruction::Swap { i: 2 });
+            self.set_source_range(call_range);
+            emit!(self, Instruction::Call { argc: 1 });
+            self.switch_to_block(end);
         } 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.codegen_call_helper(0, args)?;
+            self.codegen_call_helper(0, args, call_range)?;
         }
         Ok(())
     }
 
+    fn call_uses_ex_call(&self, arguments: &ast::Arguments) -> bool {
+        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());
+        let too_big = arguments.args.len() + arguments.keywords.len() > 15;
+        has_starred || has_double_star || too_big
+    }
+
     /// Compile subkwargs: emit key-value pairs for BUILD_MAP
     fn codegen_subkwargs(
         &mut self,
@@ -7153,7 +8546,7 @@ impl Compiler {
         let big = n * 2 > 8; // STACK_USE_GUIDELINE approximation
 
         if big {
-            emit!(self, Instruction::BuildMap { size: 0 });
+            emit!(self, Instruction::BuildMap { count: 0 });
         }
 
         for kw in &keywords[begin..end] {
@@ -7164,22 +8557,25 @@ impl Compiler {
             self.compile_expression(&kw.value)?;
 
             if big {
-                emit!(self, Instruction::MapAdd { i: 0 });
+                emit!(self, Instruction::MapAdd { i: 1 });
             }
         }
 
         if !big {
-            emit!(self, Instruction::BuildMap { size: n.to_u32() });
+            emit!(self, Instruction::BuildMap { count: n.to_u32() });
         }
 
         Ok(())
     }
 
     /// Compile call arguments and emit the appropriate CALL instruction.
+    /// `call_range` is the source range of the call expression, used to set
+    /// the correct line number on the CALL instruction.
     fn codegen_call_helper(
         &mut self,
         additional_positional: u32,
         arguments: &ast::Arguments,
+        call_range: TextRange,
     ) -> CompileResult<()> {
         let nelts = arguments.args.len();
         let nkwelts = arguments.keywords.len();
@@ -7191,8 +8587,10 @@ impl Compiler {
             .any(|arg| matches!(arg, ast::Expr::Starred(_)));
         let has_double_star = arguments.keywords.iter().any(|k| k.arg.is_none());
 
-        // Check if exceeds stack guideline
-        let too_big = nelts + nkwelts * 2 > 8;
+        // Check if exceeds stack guideline (STACK_USE_GUIDELINE / 2 = 15)
+        // With CALL_KW, kwargs values go on stack but keys go in a const tuple,
+        // so stack usage is: func + null + positional_args + kwarg_values + kwnames_tuple
+        let too_big = nelts + nkwelts > 15;
 
         if !has_starred && !has_double_star && !too_big {
             // Simple call path: no * or ** args
@@ -7210,15 +8608,18 @@ impl Compiler {
                     self.compile_expression(&keyword.value)?;
                 }
 
+                // Restore call expression range for kwnames and CALL_KW
+                self.set_source_range(call_range);
                 self.emit_load_const(ConstantData::Tuple {
                     elements: kwarg_names,
                 });
 
-                let nargs = additional_positional + nelts.to_u32() + nkwelts.to_u32();
-                emit!(self, Instruction::CallKw { nargs });
+                let argc = additional_positional + nelts.to_u32() + nkwelts.to_u32();
+                emit!(self, Instruction::CallKw { argc });
             } else {
-                let nargs = additional_positional + nelts.to_u32();
-                emit!(self, Instruction::Call { nargs });
+                self.set_source_range(call_range);
+                let argc = additional_positional + nelts.to_u32();
+                emit!(self, Instruction::Call { argc });
             }
         } else {
             // ex_call path: has * or ** args
@@ -7228,26 +8629,26 @@ impl Compiler {
                 && 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
+                // Single starred arg: pass value directly to CallFunctionEx.
+                // Runtime will convert to tuple and validate with function name.
                 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
-                            }
-                        );
-                    }
+                    self.compile_expression(value)?;
+                }
+            } else if !has_starred {
+                for arg in &arguments.args {
+                    self.compile_expression(arg)?;
+                }
+                self.set_source_range(call_range);
+                let positional_count = additional_positional + nelts.to_u32();
+                if positional_count == 0 {
+                    self.emit_load_const(ConstantData::Tuple { elements: vec![] });
+                } else {
+                    emit!(
+                        self,
+                        Instruction::BuildTuple {
+                            count: positional_count
+                        }
+                    );
                 }
             } else {
                 // Use starunpack_helper to build a list, then convert to tuple
@@ -7276,19 +8677,19 @@ impl Compiler {
                             // Pack up preceding keywords using codegen_subkwargs
                             self.codegen_subkwargs(&arguments.keywords, i - nseen, i)?;
                             if have_dict {
-                                emit!(self, Instruction::DictMerge { index: 1 });
+                                emit!(self, Instruction::DictMerge { i: 1 });
                             }
                             have_dict = true;
                             nseen = 0;
                         }
 
                         if !have_dict {
-                            emit!(self, Instruction::BuildMap { size: 0 });
+                            emit!(self, Instruction::BuildMap { count: 0 });
                             have_dict = true;
                         }
 
                         self.compile_expression(&keyword.value)?;
-                        emit!(self, Instruction::DictMerge { index: 1 });
+                        emit!(self, Instruction::DictMerge { i: 1 });
                     } else {
                         nseen += 1;
                     }
@@ -7298,7 +8699,7 @@ impl Compiler {
                 if nseen > 0 {
                     self.codegen_subkwargs(&arguments.keywords, nkwelts - nseen, nkwelts)?;
                     if have_dict {
-                        emit!(self, Instruction::DictMerge { index: 1 });
+                        emit!(self, Instruction::DictMerge { i: 1 });
                     }
                     have_dict = true;
                 }
@@ -7308,6 +8709,7 @@ impl Compiler {
                 emit!(self, Instruction::PushNull);
             }
 
+            self.set_source_range(call_range);
             emit!(self, Instruction::CallFunctionEx);
         }
 
@@ -7326,6 +8728,92 @@ impl Compiler {
         })
     }
 
+    fn consume_next_sub_table(&mut self) -> CompileResult<()> {
+        {
+            let _ = self.push_symbol_table()?;
+        }
+        let _ = self.pop_symbol_table();
+        Ok(())
+    }
+
+    fn consume_skipped_nested_scopes_in_expr(
+        &mut self,
+        expression: &ast::Expr,
+    ) -> CompileResult<()> {
+        use ast::visitor::Visitor;
+
+        struct SkippedScopeVisitor<'a> {
+            compiler: &'a mut Compiler,
+            error: Option<CodegenError>,
+        }
+
+        impl SkippedScopeVisitor<'_> {
+            fn consume_scope(&mut self) {
+                if self.error.is_none() {
+                    self.error = self.compiler.consume_next_sub_table().err();
+                }
+            }
+        }
+
+        impl ast::visitor::Visitor<'_> for SkippedScopeVisitor<'_> {
+            fn visit_expr(&mut self, expr: &ast::Expr) {
+                if self.error.is_some() {
+                    return;
+                }
+
+                match expr {
+                    ast::Expr::Lambda(ast::ExprLambda { parameters, .. }) => {
+                        // Defaults are scanned before enter_scope in the
+                        // symbol table builder, so their nested scopes
+                        // precede the lambda scope in sub_tables.
+                        if let Some(params) = parameters.as_deref() {
+                            for default in params
+                                .posonlyargs
+                                .iter()
+                                .chain(&params.args)
+                                .chain(&params.kwonlyargs)
+                                .filter_map(|p| p.default.as_deref())
+                            {
+                                self.visit_expr(default);
+                            }
+                        }
+                        self.consume_scope();
+                    }
+                    ast::Expr::ListComp(ast::ExprListComp { generators, .. })
+                    | ast::Expr::SetComp(ast::ExprSetComp { generators, .. })
+                    | ast::Expr::Generator(ast::ExprGenerator { generators, .. }) => {
+                        // leave_scope runs before the first iterator is
+                        // scanned, so the comprehension scope comes first
+                        // in sub_tables, then any nested scopes from the
+                        // first iterator.
+                        self.consume_scope();
+                        if let Some(first) = generators.first() {
+                            self.visit_expr(&first.iter);
+                        }
+                    }
+                    ast::Expr::DictComp(ast::ExprDictComp { generators, .. }) => {
+                        self.consume_scope();
+                        if let Some(first) = generators.first() {
+                            self.visit_expr(&first.iter);
+                        }
+                    }
+                    _ => ast::visitor::walk_expr(self, expr),
+                }
+            }
+        }
+
+        let mut visitor = SkippedScopeVisitor {
+            compiler: self,
+            error: None,
+        };
+        visitor.visit_expr(expression);
+        if let Some(err) = visitor.error {
+            Err(err)
+        } else {
+            Ok(())
+        }
+    }
+
     fn compile_comprehension(
         &mut self,
         name: &str,
@@ -7368,14 +8856,18 @@ impl Compiler {
         // We must have at least one generator:
         assert!(!generators.is_empty());
 
-        if is_inlined {
+        if is_inlined && !has_an_async_gen && !element_contains_await {
             // PEP 709: Inlined comprehension - compile inline without new scope
-            return self.compile_inlined_comprehension(
+            let was_in_inlined_comp = self.current_code_info().in_inlined_comp;
+            self.current_code_info().in_inlined_comp = true;
+            let result = self.compile_inlined_comprehension(
                 init_collection,
                 generators,
                 compile_element,
                 has_an_async_gen,
             );
+            self.current_code_info().in_inlined_comp = was_in_inlined_comp;
+            return result;
         }
 
         // Non-inlined path: create a new code object (generator expressions, etc.)
@@ -7402,28 +8894,44 @@ impl Compiler {
         // Create magnificent function <listcomp>:
         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;
-
         // Set qualname for comprehension
         self.set_qualname();
 
         let arg0 = self.varname(".0")?;
 
         let return_none = init_collection.is_none();
+
+        // PEP 479: Wrap generator/coroutine body with StopIteration handler
+        let is_gen_scope = self.current_symbol_table().is_generator || is_async;
+        let stop_iteration_block = if is_gen_scope {
+            let handler_block = self.new_block();
+            emit!(
+                self,
+                PseudoInstruction::SetupCleanup {
+                    delta: handler_block
+                }
+            );
+            self.set_no_location();
+            self.push_fblock(FBlockType::StopIteration, handler_block, handler_block)?;
+            Some(handler_block)
+        } else {
+            None
+        };
+
         // Create empty object of proper type:
         if let Some(init_collection) = init_collection {
-            self._emit(init_collection, OpArg(0), BlockIdx::NULL)
+            self._emit(init_collection, OpArg::new(0), BlockIdx::NULL)
         }
 
         let mut loop_labels = vec![];
         for generator in generators {
             let loop_block = self.new_block();
+            let if_cleanup_block = self.new_block();
             let after_block = self.new_block();
 
             if loop_labels.is_empty() {
                 // Load iterator onto stack (passed as first argument):
-                emit!(self, Instruction::LoadFast(arg0));
+                emit!(self, Instruction::LoadFast { var_num: arg0 });
             } else {
                 // Evaluate iterated item:
                 self.compile_expression(&generator.iter)?;
@@ -7436,51 +8944,56 @@ impl Compiler {
                 }
             }
 
-            loop_labels.push((loop_block, after_block, generator.is_async));
             self.switch_to_block(loop_block);
+            let mut end_async_for_target = BlockIdx::NULL;
             if generator.is_async {
+                emit!(self, PseudoInstruction::SetupFinally { delta: 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(
+                self.push_fblock(
                     FBlockType::AsyncComprehensionGenerator,
                     loop_block,
                     after_block,
-                    Some(after_block),
-                    current_depth,
-                    false,
                 )?;
                 self.emit_load_const(ConstantData::None);
-                self.compile_yield_from_sequence(true)?;
-                self.compile_store(&generator.target)?;
+                end_async_for_target = self.compile_yield_from_sequence(true)?;
+                // POP_BLOCK before store: only __anext__/yield_from are
+                // protected by SetupFinally targeting END_ASYNC_FOR.
+                emit!(self, PseudoInstruction::PopBlock);
                 self.pop_fblock(FBlockType::AsyncComprehensionGenerator);
+                self.compile_store(&generator.target)?;
             } else {
-                emit!(
-                    self,
-                    Instruction::ForIter {
-                        target: after_block,
-                    }
-                );
+                emit!(self, Instruction::ForIter { delta: after_block });
                 self.compile_store(&generator.target)?;
             }
+            loop_labels.push((
+                loop_block,
+                if_cleanup_block,
+                after_block,
+                generator.is_async,
+                end_async_for_target,
+            ));
 
             // Now evaluate the ifs:
             for if_condition in &generator.ifs {
-                self.compile_jump_if(if_condition, false, loop_block)?
+                self.compile_jump_if(if_condition, false, if_cleanup_block)?
             }
         }
 
         compile_element(self)?;
 
-        for (loop_block, after_block, is_async) in loop_labels.iter().rev().copied() {
-            emit!(self, PseudoInstruction::Jump { target: loop_block });
+        for (loop_block, if_cleanup_block, after_block, is_async, end_async_for_target) in
+            loop_labels.iter().rev().copied()
+        {
+            emit!(self, PseudoInstruction::Jump { delta: loop_block });
+
+            self.switch_to_block(if_cleanup_block);
+            emit!(self, PseudoInstruction::Jump { delta: loop_block });
 
             self.switch_to_block(after_block);
             if is_async {
-                emit!(self, Instruction::EndAsyncFor);
-                emit!(self, Instruction::PopTop);
+                // EndAsyncFor pops both the exception and the aiter
+                // (handler depth is before GetANext, so aiter is at handler depth)
+                self.emit_end_async_for(end_async_for_target);
             } else {
                 // END_FOR + POP_ITER pattern (CPython 3.14)
                 emit!(self, Instruction::EndFor);
@@ -7494,13 +9007,29 @@ impl Compiler {
 
         self.emit_return_value();
 
+        // Close StopIteration handler and emit handler code
+        if let Some(handler_block) = stop_iteration_block {
+            emit!(self, PseudoInstruction::PopBlock);
+            self.set_no_location();
+            self.pop_fblock(FBlockType::StopIteration);
+            self.switch_to_block(handler_block);
+            emit!(
+                self,
+                Instruction::CallIntrinsic1 {
+                    func: oparg::IntrinsicFunction1::StopIterationError
+                }
+            );
+            self.set_no_location();
+            emit!(self, Instruction::Reraise { depth: 1u32 });
+            self.set_no_location();
+        }
+
         let code = self.exit_scope();
 
         self.ctx = prev_ctx;
 
         // Create comprehension function with closure
-        self.make_closure(code, bytecode::MakeFunctionFlags::empty())?;
-        emit!(self, Instruction::PushNull);
+        self.make_closure(code, bytecode::MakeFunctionFlags::new())?;
 
         // Evaluate iterated item:
         self.compile_expression(&generators[0].iter)?;
@@ -7514,44 +9043,16 @@ impl Compiler {
         };
 
         // Call just created <listcomp> function:
-        emit!(self, Instruction::Call { nargs: 1 });
+        emit!(self, Instruction::Call { argc: 0 });
         if is_async_list_set_dict_comprehension {
-            emit!(self, Instruction::GetAwaitable);
+            emit!(self, Instruction::GetAwaitable { r#where: 0 });
             self.emit_load_const(ConstantData::None);
-            self.compile_yield_from_sequence(true)?;
+            let _ = self.compile_yield_from_sequence(true)?;
         }
 
         Ok(())
     }
 
-    /// Collect variable names from an assignment target expression
-    fn collect_target_names(&self, target: &ast::Expr, names: &mut Vec<String>) {
-        match target {
-            ast::Expr::Name(name) => {
-                let name_str = name.id.to_string();
-                if !names.contains(&name_str) {
-                    names.push(name_str);
-                }
-            }
-            ast::Expr::Tuple(tuple) => {
-                for elt in &tuple.elts {
-                    self.collect_target_names(elt, names);
-                }
-            }
-            ast::Expr::List(list) => {
-                for elt in &list.elts {
-                    self.collect_target_names(elt, names);
-                }
-            }
-            ast::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(
@@ -7559,56 +9060,134 @@ impl Compiler {
         init_collection: Option<AnyInstruction>,
         generators: &[ast::Comprehension],
         compile_element: &dyn Fn(&mut Self) -> CompileResult<()>,
-        _has_an_async_gen: bool,
+        has_async: 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.
+        // PEP 709: Consume the comprehension's sub_table.
         // The symbols are already merged into parent scope by analyze_symbol_table.
-        let _comp_table = self
+        let current_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);
-        }
+            .expect("no current symbol table");
+        let comp_table = current_table.sub_tables[current_table.next_sub_table].clone();
+        current_table.next_sub_table += 1;
 
-        // Step 1: Compile the outermost iterator
+        // Compile the outermost iterator first. Its expression may reference
+        // nested scopes (e.g. lambdas) whose sub_tables sit at the current
+        // position in the parent's list. Those must be consumed before we
+        // splice in the comprehension's own children.
         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 {
+
+        // Splice the comprehension's children (e.g. nested inlined
+        // comprehensions) into the parent so the compiler can find them.
+        if !comp_table.sub_tables.is_empty() {
+            let current_table = self
+                .symbol_table_stack
+                .last_mut()
+                .expect("no current symbol table");
+            let insert_pos = current_table.next_sub_table;
+            for (i, st) in comp_table.sub_tables.iter().enumerate() {
+                current_table.sub_tables.insert(insert_pos + i, st.clone());
+            }
+        }
+        if has_async && 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
+        // Collect local variables that need to be saved/restored.
+        // All DEF_LOCAL && !DEF_NONLOCAL names from the comp table, plus class block names.
+        let in_class_block = {
+            let ct = self.current_symbol_table();
+            ct.typ == CompilerScope::Class && !self.current_code_info().in_inlined_comp
+        };
+        let mut pushed_locals: Vec<String> = Vec::new();
+        for (name, sym) in &comp_table.symbols {
+            if sym.flags.contains(SymbolFlags::PARAMETER) {
+                continue; // skip .0
+            }
+            // Walrus operator targets (ASSIGNED_IN_COMPREHENSION without ITER)
+            // are not local to the comprehension; they leak to the outer scope.
+            let is_walrus = sym.flags.contains(SymbolFlags::ASSIGNED_IN_COMPREHENSION)
+                && !sym.flags.contains(SymbolFlags::ITER);
+            let is_local = sym
+                .flags
+                .intersects(SymbolFlags::ASSIGNED | SymbolFlags::ITER)
+                && !sym.flags.contains(SymbolFlags::NONLOCAL)
+                && !is_walrus;
+            if is_local || in_class_block {
+                pushed_locals.push(name.clone());
+            }
+        }
+
+        // TweakInlinedComprehensionScopes: temporarily override parent symbols
+        // with comp scopes where they differ.
+        let mut temp_symbols: IndexMap<String, Symbol> = IndexMap::default();
+        for (name, comp_sym) in &comp_table.symbols {
+            if comp_sym.flags.contains(SymbolFlags::PARAMETER) {
+                continue; // skip .0
+            }
+            let comp_scope = comp_sym.scope;
+
+            let current_table = self.symbol_table_stack.last().expect("no symbol table");
+            if let Some(outer_sym) = current_table.symbols.get(name) {
+                let outer_scope = outer_sym.scope;
+                if (comp_scope != outer_scope
+                    && comp_scope != SymbolScope::Free
+                    && !(comp_scope == SymbolScope::Cell && outer_scope == SymbolScope::Free))
+                    || in_class_block
+                {
+                    temp_symbols.insert(name.clone(), outer_sym.clone());
+                    let current_table =
+                        self.symbol_table_stack.last_mut().expect("no symbol table");
+                    current_table.symbols.insert(name.clone(), comp_sym.clone());
+                }
+            }
+        }
+
+        // Step 2: Save local variables that will be shadowed by the comprehension.
+        // For each variable, we push the fast local value via LoadFastAndClear.
+        // For merged CELL variables, LoadFastAndClear saves the cell object from
+        // the merged slot, and MAKE_CELL creates a new empty cell in-place.
+        // MAKE_CELL has no stack effect (operates only on fastlocals).
+        let mut total_stack_items: usize = 0;
         for name in &pushed_locals {
-            let idx = self.varname(name)?;
-            emit!(self, Instruction::LoadFastAndClear(idx));
+            let var_num = self.varname(name)?;
+            emit!(self, Instruction::LoadFastAndClear { var_num });
+            total_stack_items += 1;
+            // If the comp symbol is CELL, emit MAKE_CELL to create fresh cell
+            if let Some(comp_sym) = comp_table.symbols.get(name)
+                && comp_sym.scope == SymbolScope::Cell
+            {
+                let i = if self
+                    .current_symbol_table()
+                    .symbols
+                    .get(name)
+                    .is_some_and(|s| s.scope == SymbolScope::Free)
+                {
+                    self.get_free_var_index(name)?
+                } else {
+                    self.get_cell_var_index(name)?
+                };
+                emit!(self, Instruction::MakeCell { i });
+            }
         }
 
-        // Step 3: SWAP iterator to TOS (above saved locals)
-        if !pushed_locals.is_empty() {
+        // Step 3: SWAP iterator to TOS (above saved locals + cell values)
+        if total_stack_items > 0 {
             emit!(
                 self,
                 Instruction::Swap {
-                    index: u32::try_from(pushed_locals.len() + 1).unwrap()
+                    i: u32::try_from(total_stack_items + 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);
+            self._emit(init_collection, OpArg::new(0), BlockIdx::NULL);
             // SWAP to get iterator on top
-            emit!(self, Instruction::Swap { index: 2 });
+            emit!(self, Instruction::Swap { i: 2 });
         }
 
         // Set up exception handler for cleanup on exception
@@ -7616,30 +9195,23 @@ impl Compiler {
         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,
-            )?;
+            emit!(
+                self,
+                PseudoInstruction::SetupFinally {
+                    delta: cleanup_block
+                }
+            );
+            self.push_fblock(FBlockType::TryExcept, cleanup_block, end_block)?;
         }
 
         // Step 5: Compile the comprehension loop(s)
-        let mut loop_labels = vec![];
+        let mut loop_labels: Vec<(BlockIdx, BlockIdx, BlockIdx, bool, BlockIdx)> = vec![];
         for (i, generator) in generators.iter().enumerate() {
             let loop_block = self.new_block();
+            let if_cleanup_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);
@@ -7648,27 +9220,38 @@ impl Compiler {
                 }
             }
 
-            loop_labels.push((loop_block, after_block, generator.is_async));
             self.switch_to_block(loop_block);
 
+            let mut end_async_for_target = BlockIdx::NULL;
             if generator.is_async {
+                emit!(self, PseudoInstruction::SetupFinally { delta: after_block });
                 emit!(self, Instruction::GetANext);
+                self.push_fblock(
+                    FBlockType::AsyncComprehensionGenerator,
+                    loop_block,
+                    after_block,
+                )?;
                 self.emit_load_const(ConstantData::None);
-                self.compile_yield_from_sequence(true)?;
+                end_async_for_target = self.compile_yield_from_sequence(true)?;
+                emit!(self, PseudoInstruction::PopBlock);
+                self.pop_fblock(FBlockType::AsyncComprehensionGenerator);
                 self.compile_store(&generator.target)?;
             } else {
-                emit!(
-                    self,
-                    Instruction::ForIter {
-                        target: after_block,
-                    }
-                );
+                emit!(self, Instruction::ForIter { delta: after_block });
                 self.compile_store(&generator.target)?;
             }
 
+            loop_labels.push((
+                loop_block,
+                if_cleanup_block,
+                after_block,
+                generator.is_async,
+                end_async_for_target,
+            ));
+
             // Evaluate the if conditions
             for if_condition in &generator.ifs {
-                self.compile_jump_if(if_condition, false, loop_block)?;
+                self.compile_jump_if(if_condition, false, if_cleanup_block)?;
             }
         }
 
@@ -7676,71 +9259,75 @@ impl Compiler {
         compile_element(self)?;
 
         // Step 7: Close all loops
-        for (loop_block, after_block, is_async) in loop_labels.iter().rev().copied() {
-            emit!(self, PseudoInstruction::Jump { target: loop_block });
+        for &(loop_block, if_cleanup_block, after_block, is_async, end_async_for_target) in
+            loop_labels.iter().rev()
+        {
+            emit!(self, PseudoInstruction::Jump { delta: loop_block });
+
+            self.switch_to_block(if_cleanup_block);
+            emit!(self, PseudoInstruction::Jump { delta: loop_block });
+
             self.switch_to_block(after_block);
             if is_async {
-                emit!(self, Instruction::EndAsyncFor);
-                // Pop the iterator
-                emit!(self, Instruction::PopTop);
+                self.emit_end_async_for(end_async_for_target);
             } else {
-                // END_FOR + POP_ITER pattern (CPython 3.14)
                 emit!(self, Instruction::EndFor);
                 emit!(self, Instruction::PopIter);
             }
         }
 
-        // Step 8: Clean up - restore saved locals
-        if !pushed_locals.is_empty() {
+        // Step 8: Clean up - restore saved locals (and cell values)
+        if total_stack_items > 0 {
+            emit!(self, PseudoInstruction::PopBlock);
             self.pop_fblock(FBlockType::TryExcept);
 
             // Normal path: jump past cleanup
-            emit!(self, PseudoInstruction::Jump { target: end_block });
+            emit!(self, PseudoInstruction::Jump { delta: 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 });
+            // Stack: [saved_values..., collection, exception]
+            emit!(self, Instruction::Swap { i: 2 });
             emit!(self, Instruction::PopTop); // Pop incomplete collection
 
-            // Restore locals
+            // Restore locals and cell values
             emit!(
                 self,
                 Instruction::Swap {
-                    index: u32::try_from(pushed_locals.len() + 1).unwrap()
+                    i: u32::try_from(total_stack_items + 1).unwrap()
                 }
             );
             for name in pushed_locals.iter().rev() {
-                let idx = self.varname(name)?;
-                emit!(self, Instruction::StoreFast(idx));
+                let var_num = self.varname(name)?;
+                emit!(self, Instruction::StoreFast { var_num });
             }
             // Re-raise the exception
-            emit!(
-                self,
-                Instruction::RaiseVarargs {
-                    kind: bytecode::RaiseKind::ReraiseFromStack
-                }
-            );
+            emit!(self, Instruction::Reraise { depth: 0 });
 
             // Normal end path
             self.switch_to_block(end_block);
         }
 
-        // SWAP result to TOS (above saved locals)
-        if !pushed_locals.is_empty() {
+        // SWAP result to TOS (above saved values)
+        if total_stack_items > 0 {
             emit!(
                 self,
                 Instruction::Swap {
-                    index: u32::try_from(pushed_locals.len() + 1).unwrap()
+                    i: u32::try_from(total_stack_items + 1).unwrap()
                 }
             );
         }
 
-        // Restore saved locals
+        // Restore saved locals (StoreFast restores the saved cell object for merged cells)
         for name in pushed_locals.iter().rev() {
-            let idx = self.varname(name)?;
-            emit!(self, Instruction::StoreFast(idx));
+            let var_num = self.varname(name)?;
+            emit!(self, Instruction::StoreFast { var_num });
+        }
+
+        // RevertInlinedComprehensionScopes: restore original symbols
+        let current_table = self.symbol_table_stack.last_mut().expect("no symbol table");
+        for (name, original_sym) in temp_symbols {
+            current_table.symbols.insert(name, original_sym);
         }
 
         Ok(())
@@ -7769,11 +9356,14 @@ impl Compiler {
 
     // Low level helper functions:
     fn _emit<I: Into<AnyInstruction>>(&mut self, instr: I, arg: OpArg, target: BlockIdx) {
+        if self.do_not_emit_bytecode > 0 {
+            return;
+        }
         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();
+        let except_handler = None;
         self.current_block().instructions.push(ir::InstructionInfo {
             instr: instr.into(),
             arg,
@@ -7782,11 +9372,20 @@ impl Compiler {
             end_location,
             except_handler,
             lineno_override: None,
+            cache_entries: 0,
         });
     }
 
+    /// Mark the last emitted instruction as having no source location.
+    /// Prevents it from triggering LINE events in sys.monitoring.
+    fn set_no_location(&mut self) {
+        if let Some(last) = self.current_block().instructions.last_mut() {
+            last.lineno_override = Some(-1);
+        }
+    }
+
     fn emit_no_arg<I: Into<AnyInstruction>>(&mut self, ins: I) {
-        self._emit(ins, OpArg::null(), BlockIdx::NULL)
+        self._emit(ins, OpArg::NULL, BlockIdx::NULL)
     }
 
     fn emit_arg<A: OpArgType, T: EmitArg<A>, I: Into<AnyInstruction>>(
@@ -7800,14 +9399,134 @@ impl Compiler {
 
     // fn block_done()
 
-    fn arg_constant(&mut self, constant: ConstantData) -> u32 {
-        let info = self.current_code_info();
-        info.metadata.consts.insert_full(constant).0.to_u32()
-    }
-
-    fn emit_load_const(&mut self, constant: ConstantData) {
-        let idx = self.arg_constant(constant);
-        self.emit_arg(idx, |idx| Instruction::LoadConst { idx })
+    /// Convert a string literal AST node to Wtf8Buf, handling surrogate literals correctly.
+    fn compile_string_value(&self, string: &ast::ExprStringLiteral) -> Wtf8Buf {
+        let value = string.value.to_str();
+        if value.contains(char::REPLACEMENT_CHARACTER) {
+            // Might have a surrogate literal; reparse from source to preserve them.
+            string
+                .value
+                .iter()
+                .map(|lit| {
+                    let source = self.source_file.slice(lit.range);
+                    crate::string_parser::parse_string_literal(source, lit.flags.into())
+                })
+                .collect()
+        } else {
+            value.into()
+        }
+    }
+
+    fn compile_fstring_literal_value(
+        &self,
+        string: &ast::InterpolatedStringLiteralElement,
+        flags: ast::FStringFlags,
+    ) -> Wtf8Buf {
+        if string.value.contains(char::REPLACEMENT_CHARACTER) {
+            let source = self.source_file.slice(string.range);
+            crate::string_parser::parse_fstring_literal_element(source.into(), flags.into()).into()
+        } else {
+            string.value.to_string().into()
+        }
+    }
+
+    fn compile_fstring_part_literal_value(&self, string: &ast::StringLiteral) -> Wtf8Buf {
+        if string.value.contains(char::REPLACEMENT_CHARACTER) {
+            let source = self.source_file.slice(string.range);
+            crate::string_parser::parse_string_literal(source, string.flags.into()).into()
+        } else {
+            string.value.to_string().into()
+        }
+    }
+
+    fn arg_constant(&mut self, constant: ConstantData) -> oparg::ConstIdx {
+        let info = self.current_code_info();
+        info.metadata.consts.insert_full(constant).0.to_u32().into()
+    }
+
+    /// Try to fold a collection of constant expressions into a single ConstantData::Tuple.
+    /// Returns None if any element cannot be folded.
+    fn try_fold_constant_collection(
+        &mut self,
+        elts: &[ast::Expr],
+    ) -> CompileResult<Option<ConstantData>> {
+        let mut constants = Vec::with_capacity(elts.len());
+        for elt in elts {
+            let Some(constant) = self.try_fold_constant_expr(elt)? else {
+                return Ok(None);
+            };
+            constants.push(constant);
+        }
+        Ok(Some(ConstantData::Tuple {
+            elements: constants,
+        }))
+    }
+
+    fn try_fold_constant_expr(&mut self, expr: &ast::Expr) -> CompileResult<Option<ConstantData>> {
+        Ok(Some(match expr {
+            ast::Expr::NumberLiteral(num) => match &num.value {
+                ast::Number::Int(int) => ConstantData::Integer {
+                    value: ruff_int_to_bigint(int).map_err(|e| self.error(e))?,
+                },
+                ast::Number::Float(f) => ConstantData::Float { value: *f },
+                ast::Number::Complex { real, imag } => ConstantData::Complex {
+                    value: Complex::new(*real, *imag),
+                },
+            },
+            ast::Expr::StringLiteral(s) => ConstantData::Str {
+                value: self.compile_string_value(s),
+            },
+            ast::Expr::BytesLiteral(b) => ConstantData::Bytes {
+                value: b.value.bytes().collect(),
+            },
+            ast::Expr::BooleanLiteral(b) => ConstantData::Boolean { value: b.value },
+            ast::Expr::NoneLiteral(_) => ConstantData::None,
+            ast::Expr::EllipsisLiteral(_) => ConstantData::Ellipsis,
+            ast::Expr::Tuple(ast::ExprTuple { elts, .. }) => {
+                let mut elements = Vec::with_capacity(elts.len());
+                for elt in elts {
+                    let Some(constant) = self.try_fold_constant_expr(elt)? else {
+                        return Ok(None);
+                    };
+                    elements.push(constant);
+                }
+                ConstantData::Tuple { elements }
+            }
+            _ => return Ok(None),
+        }))
+    }
+
+    fn emit_load_const(&mut self, constant: ConstantData) {
+        let idx = self.arg_constant(constant);
+        self.emit_arg(idx, |consti| Instruction::LoadConst { consti })
+    }
+
+    /// Fold constant slice: if all parts are compile-time constants, emit LOAD_CONST(slice).
+    fn try_fold_constant_slice(
+        &mut self,
+        lower: Option<&ast::Expr>,
+        upper: Option<&ast::Expr>,
+        step: Option<&ast::Expr>,
+    ) -> CompileResult<bool> {
+        let to_const = |expr: Option<&ast::Expr>, this: &mut Self| -> CompileResult<_> {
+            match expr {
+                None => Ok(Some(ConstantData::None)),
+                Some(expr) => this.try_fold_constant_expr(expr),
+            }
+        };
+
+        let (Some(start), Some(stop), Some(step_val)) = (
+            to_const(lower, self)?,
+            to_const(upper, self)?,
+            to_const(step, self)?,
+        ) else {
+            return Ok(false);
+        };
+
+        self.emit_load_const(ConstantData::Slice {
+            elements: Box::new([start, stop, step_val]),
+        });
+        Ok(true)
     }
 
     fn emit_return_const(&mut self, constant: ConstantData) {
@@ -7815,46 +9534,57 @@ impl Compiler {
         emit!(self, Instruction::ReturnValue)
     }
 
+    fn emit_end_async_for(&mut self, send_target: BlockIdx) {
+        self._emit(Instruction::EndAsyncFor, OpArg::NULL, send_target);
+    }
+
     /// Emit LOAD_ATTR for attribute access (method=false).
     /// Encodes: (name_idx << 1) | 0
     fn emit_load_attr(&mut self, name_idx: u32) {
-        let encoded = encode_load_attr_arg(name_idx, false);
-        self.emit_arg(encoded, |arg| Instruction::LoadAttr { idx: arg })
+        let encoded = LoadAttr::new(name_idx, false);
+        self.emit_arg(encoded, |namei| Instruction::LoadAttr { namei })
     }
 
     /// Emit LOAD_ATTR with method flag set (for method calls).
     /// Encodes: (name_idx << 1) | 1
     fn emit_load_attr_method(&mut self, name_idx: u32) {
-        let encoded = encode_load_attr_arg(name_idx, true);
-        self.emit_arg(encoded, |arg| Instruction::LoadAttr { idx: arg })
+        let encoded = LoadAttr::new(name_idx, true);
+        self.emit_arg(encoded, |namei| Instruction::LoadAttr { namei })
+    }
+
+    /// Emit LOAD_GLOBAL.
+    /// Encodes: (name_idx << 1) | push_null_bit
+    fn emit_load_global(&mut self, name_idx: u32, push_null: bool) {
+        let encoded = (name_idx << 1) | u32::from(push_null);
+        self.emit_arg(encoded, |namei| Instruction::LoadGlobal { namei });
     }
 
     /// Emit LOAD_SUPER_ATTR for 2-arg super().attr access.
     /// Encodes: (name_idx << 2) | 0b10 (method=0, class=1)
     fn emit_load_super_attr(&mut self, name_idx: u32) {
-        let encoded = encode_load_super_attr_arg(name_idx, false, true);
-        self.emit_arg(encoded, |arg| Instruction::LoadSuperAttr { arg })
+        let encoded = LoadSuperAttr::new(name_idx, false, true);
+        self.emit_arg(encoded, |namei| Instruction::LoadSuperAttr { namei })
     }
 
     /// Emit LOAD_SUPER_ATTR for 2-arg super().method() call.
     /// Encodes: (name_idx << 2) | 0b11 (method=1, class=1)
     fn emit_load_super_method(&mut self, name_idx: u32) {
-        let encoded = encode_load_super_attr_arg(name_idx, true, true);
-        self.emit_arg(encoded, |arg| Instruction::LoadSuperAttr { arg })
+        let encoded = LoadSuperAttr::new(name_idx, true, true);
+        self.emit_arg(encoded, |namei| Instruction::LoadSuperAttr { namei })
     }
 
     /// Emit LOAD_SUPER_ATTR for 0-arg super().attr access.
     /// Encodes: (name_idx << 2) | 0b00 (method=0, class=0)
     fn emit_load_zero_super_attr(&mut self, name_idx: u32) {
-        let encoded = encode_load_super_attr_arg(name_idx, false, false);
-        self.emit_arg(encoded, |arg| Instruction::LoadSuperAttr { arg })
+        let encoded = LoadSuperAttr::new(name_idx, false, false);
+        self.emit_arg(encoded, |namei| Instruction::LoadSuperAttr { namei })
     }
 
     /// Emit LOAD_SUPER_ATTR for 0-arg super().method() call.
     /// Encodes: (name_idx << 2) | 0b01 (method=1, class=0)
     fn emit_load_zero_super_method(&mut self, name_idx: u32) {
-        let encoded = encode_load_super_attr_arg(name_idx, true, false);
-        self.emit_arg(encoded, |arg| Instruction::LoadSuperAttr { arg })
+        let encoded = LoadSuperAttr::new(name_idx, true, false);
+        self.emit_arg(encoded, |namei| Instruction::LoadSuperAttr { namei })
     }
 
     fn emit_return_value(&mut self) {
@@ -7865,6 +9595,44 @@ impl Compiler {
         self.code_stack.last_mut().expect("no code on stack")
     }
 
+    /// Evaluate whether an expression is a compile-time constant boolean.
+    /// Returns Some(true) for truthy constants, Some(false) for falsy constants,
+    /// None for non-constant expressions.
+    /// = expr_constant in CPython compile.c
+    fn expr_constant(expr: &ast::Expr) -> Option<bool> {
+        match expr {
+            ast::Expr::BooleanLiteral(ast::ExprBooleanLiteral { value, .. }) => Some(*value),
+            ast::Expr::NoneLiteral(_) => Some(false),
+            ast::Expr::EllipsisLiteral(_) => Some(true),
+            ast::Expr::NumberLiteral(ast::ExprNumberLiteral { value, .. }) => match value {
+                ast::Number::Int(i) => {
+                    let n: i64 = i.as_i64().unwrap_or(1);
+                    Some(n != 0)
+                }
+                ast::Number::Float(f) => Some(*f != 0.0),
+                ast::Number::Complex { real, imag, .. } => Some(*real != 0.0 || *imag != 0.0),
+            },
+            ast::Expr::StringLiteral(ast::ExprStringLiteral { value, .. }) => {
+                Some(!value.to_str().is_empty())
+            }
+            ast::Expr::BytesLiteral(ast::ExprBytesLiteral { value, .. }) => {
+                Some(value.bytes().next().is_some())
+            }
+            ast::Expr::Tuple(ast::ExprTuple { elts, .. }) => {
+                if elts.is_empty() {
+                    Some(false)
+                } else {
+                    None // non-empty tuples may have side effects in elements
+                }
+            }
+            _ => None,
+        }
+    }
+
+    fn emit_nop(&mut self) {
+        emit!(self, Instruction::Nop);
+    }
+
     /// Enter a conditional block (if/for/while/match/try/with)
     /// PEP 649: Track conditional annotation context
     fn enter_conditional_block(&mut self) {
@@ -7886,6 +9654,35 @@ impl Compiler {
         range: ruff_text_size::TextRange,
         is_break: bool,
     ) -> CompileResult<()> {
+        if self.do_not_emit_bytecode > 0 {
+            // Still validate that we're inside a loop even in dead code
+            let code = self.current_code_info();
+            let mut found_loop = false;
+            for i in (0..code.fblock.len()).rev() {
+                match code.fblock[i].fb_type {
+                    FBlockType::WhileLoop | FBlockType::ForLoop => {
+                        found_loop = true;
+                        break;
+                    }
+                    FBlockType::ExceptionGroupHandler => {
+                        return Err(self.error_ranged(
+                            CodegenErrorType::BreakContinueReturnInExceptStar,
+                            range,
+                        ));
+                    }
+                    _ => {}
+                }
+            }
+            if !found_loop {
+                if is_break {
+                    return Err(self.error_ranged(CodegenErrorType::InvalidBreak, range));
+                } else {
+                    return Err(self.error_ranged(CodegenErrorType::InvalidContinue, range));
+                }
+            }
+            return Ok(());
+        }
+
         // 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
@@ -7934,7 +9731,10 @@ impl Compiler {
             With {
                 is_async: bool,
             },
-            HandlerCleanup,
+            HandlerCleanup {
+                name: Option<String>,
+            },
+            TryExcept,
             FinallyTry {
                 body: Vec<ruff_python_ast::Stmt>,
                 fblock_idx: usize,
@@ -7955,7 +9755,14 @@ impl Compiler {
                         unwind_actions.push(UnwindAction::With { is_async: true });
                     }
                     FBlockType::HandlerCleanup => {
-                        unwind_actions.push(UnwindAction::HandlerCleanup);
+                        let name = match &code.fblock[i].fb_datum {
+                            FBlockDatum::ExceptionName(name) => Some(name.clone()),
+                            _ => None,
+                        };
+                        unwind_actions.push(UnwindAction::HandlerCleanup { name });
+                    }
+                    FBlockType::TryExcept => {
+                        unwind_actions.push(UnwindAction::TryExcept);
                     }
                     FBlockType::FinallyTry => {
                         // Need to execute finally body before break/continue
@@ -7983,25 +9790,44 @@ impl Compiler {
         for action in unwind_actions {
             match action {
                 UnwindAction::With { is_async } => {
-                    // compiler_call_exit_with_nones
-                    emit!(self, Instruction::PushNull);
+                    // Stack: [..., exit_func, self_exit]
+                    emit!(self, PseudoInstruction::PopBlock);
                     self.emit_load_const(ConstantData::None);
                     self.emit_load_const(ConstantData::None);
                     self.emit_load_const(ConstantData::None);
-                    emit!(self, Instruction::Call { nargs: 3 });
+                    emit!(self, Instruction::Call { argc: 3 });
 
                     if is_async {
-                        emit!(self, Instruction::GetAwaitable);
+                        emit!(self, Instruction::GetAwaitable { r#where: 2 });
                         self.emit_load_const(ConstantData::None);
-                        self.compile_yield_from_sequence(true)?;
+                        let _ = self.compile_yield_from_sequence(true)?;
                     }
 
                     emit!(self, Instruction::PopTop);
                 }
-                UnwindAction::HandlerCleanup => {
+                UnwindAction::HandlerCleanup { ref name } => {
+                    // codegen_unwind_fblock(HANDLER_CLEANUP)
+                    if name.is_some() {
+                        // Named handler: PopBlock for inner SETUP_CLEANUP
+                        emit!(self, PseudoInstruction::PopBlock);
+                    }
+                    // PopBlock for outer SETUP_CLEANUP (ExceptionHandler)
+                    emit!(self, PseudoInstruction::PopBlock);
                     emit!(self, Instruction::PopExcept);
+                    if let Some(name) = name {
+                        self.emit_load_const(ConstantData::None);
+                        self.store_name(name)?;
+                        self.compile_name(name, NameUsage::Delete)?;
+                    }
+                }
+                UnwindAction::TryExcept => {
+                    // codegen_unwind_fblock(TRY_EXCEPT)
+                    emit!(self, PseudoInstruction::PopBlock);
                 }
                 UnwindAction::FinallyTry { body, fblock_idx } => {
+                    // codegen_unwind_fblock(FINALLY_TRY)
+                    emit!(self, PseudoInstruction::PopBlock);
+
                     // compile finally body inline
                     // Temporarily pop the FinallyTry fblock so nested break/continue
                     // in the finally body won't see it again.
@@ -8016,11 +9842,10 @@ impl Compiler {
                     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 PopExcept)
-                    emit!(self, Instruction::PopTop); // exc
-                    emit!(self, Instruction::PopExcept); // prev_exc is restored
+                    // codegen_unwind_fblock(FINALLY_END)
+                    emit!(self, Instruction::PopTop); // exc_value
+                    emit!(self, PseudoInstruction::PopBlock);
+                    emit!(self, Instruction::PopExcept);
                 }
                 UnwindAction::PopValue => {
                     // Pop the return value - continue/break cancels the pending return
@@ -8036,44 +9861,11 @@ impl Compiler {
 
         // Jump to target
         let target = if is_break { exit_block } else { loop_block };
-        emit!(self, PseudoInstruction::Jump { target });
+        emit!(self, PseudoInstruction::Jump { delta: target });
 
         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]
@@ -8179,45 +9971,201 @@ impl Compiler {
 
     fn compile_expr_fstring(&mut self, fstring: &ast::ExprFString) -> CompileResult<()> {
         let fstring = &fstring.value;
+        let mut element_count = 0;
+        let mut pending_literal = None;
         for part in fstring {
-            self.compile_fstring_part(part)?;
-        }
-        let part_count: u32 = fstring
-            .iter()
-            .len()
-            .try_into()
-            .expect("BuildString size overflowed");
-        if part_count > 1 {
-            emit!(self, Instruction::BuildString { size: part_count });
+            self.compile_fstring_part_into(part, &mut pending_literal, &mut element_count)?;
         }
-
-        Ok(())
+        self.finish_fstring(pending_literal, element_count)
     }
 
-    fn compile_fstring_part(&mut self, part: &ast::FStringPart) -> CompileResult<()> {
+    fn compile_fstring_part_into(
+        &mut self,
+        part: &ast::FStringPart,
+        pending_literal: &mut Option<Wtf8Buf>,
+        element_count: &mut u32,
+    ) -> CompileResult<()> {
         match part {
             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);
-                    let value =
-                        crate::string_parser::parse_string_literal(source, string.flags.into());
-                    self.emit_load_const(ConstantData::Str {
-                        value: value.into(),
-                    });
+                let value = self.compile_fstring_part_literal_value(string);
+                if let Some(pending) = pending_literal.as_mut() {
+                    pending.push_wtf8(value.as_ref());
                 } else {
-                    self.emit_load_const(ConstantData::Str {
-                        value: string.value.to_string().into(),
-                    });
+                    *pending_literal = Some(value);
                 }
                 Ok(())
             }
-            ast::FStringPart::FString(fstring) => self.compile_fstring(fstring),
+            ast::FStringPart::FString(fstring) => self.compile_fstring_elements_into(
+                fstring.flags,
+                &fstring.elements,
+                pending_literal,
+                element_count,
+            ),
+        }
+    }
+
+    fn finish_fstring(
+        &mut self,
+        mut pending_literal: Option<Wtf8Buf>,
+        mut element_count: u32,
+    ) -> CompileResult<()> {
+        let keep_empty = element_count == 0;
+        self.emit_pending_fstring_literal(&mut pending_literal, &mut element_count, keep_empty);
+
+        if element_count == 0 {
+            self.emit_load_const(ConstantData::Str {
+                value: Wtf8Buf::new(),
+            });
+        } else if element_count > 1 {
+            emit!(
+                self,
+                Instruction::BuildString {
+                    count: element_count
+                }
+            );
+        }
+
+        Ok(())
+    }
+
+    fn emit_pending_fstring_literal(
+        &mut self,
+        pending_literal: &mut Option<Wtf8Buf>,
+        element_count: &mut u32,
+        keep_empty: bool,
+    ) {
+        let Some(value) = pending_literal.take() else {
+            return;
+        };
+
+        // CPython drops empty literal fragments when they are adjacent to
+        // formatted values, but still emits an empty string for a fully-empty
+        // f-string.
+        if value.is_empty() && (!keep_empty || *element_count > 0) {
+            return;
+        }
+
+        self.emit_load_const(ConstantData::Str { value });
+        *element_count += 1;
+    }
+
+    /// Optimize `'format_str' % (args,)` into f-string bytecode.
+    /// Returns true if optimization was applied, false to fall back to normal BINARY_OP %.
+    /// Matches CPython's codegen.c `compiler_formatted_value` optimization.
+    fn try_optimize_format_str(
+        &mut self,
+        format_str: &str,
+        args: &[ast::Expr],
+        range: ruff_text_size::TextRange,
+    ) -> CompileResult<bool> {
+        // Parse format string into segments
+        let Some(segments) = Self::parse_percent_format(format_str) else {
+            return Ok(false);
+        };
+
+        // Verify arg count matches specifier count
+        let spec_count = segments.iter().filter(|s| s.conversion.is_some()).count();
+        if spec_count != args.len() {
+            return Ok(false);
+        }
+
+        self.set_source_range(range);
+
+        // Special case: no specifiers, just %% escaping → constant fold
+        if spec_count == 0 {
+            let folded: String = segments.iter().map(|s| s.literal.as_str()).collect();
+            self.emit_load_const(ConstantData::Str {
+                value: folded.into(),
+            });
+            return Ok(true);
+        }
+
+        // Emit f-string style bytecode
+        let mut part_count: u32 = 0;
+        let mut arg_idx = 0;
+
+        for seg in &segments {
+            if !seg.literal.is_empty() {
+                self.emit_load_const(ConstantData::Str {
+                    value: seg.literal.clone().into(),
+                });
+                part_count += 1;
+            }
+            if let Some(conv) = seg.conversion {
+                self.compile_expression(&args[arg_idx])?;
+                self.set_source_range(range);
+                emit!(self, Instruction::ConvertValue { oparg: conv });
+                emit!(self, Instruction::FormatSimple);
+                part_count += 1;
+                arg_idx += 1;
+            }
+        }
+
+        if part_count == 0 {
+            self.emit_load_const(ConstantData::Str {
+                value: String::new().into(),
+            });
+        } else if part_count > 1 {
+            emit!(self, Instruction::BuildString { count: part_count });
         }
+
+        Ok(true)
     }
 
-    fn compile_fstring(&mut self, fstring: &ast::FString) -> CompileResult<()> {
-        self.compile_fstring_elements(fstring.flags, &fstring.elements)
+    /// Parse a %-format string into segments of (literal_prefix, optional conversion).
+    /// Returns None if the format string contains unsupported specifiers.
+    fn parse_percent_format(format_str: &str) -> Option<Vec<FormatSegment>> {
+        let mut segments = Vec::new();
+        let mut chars = format_str.chars().peekable();
+        let mut current_literal = String::new();
+
+        while let Some(ch) = chars.next() {
+            if ch == '%' {
+                match chars.peek() {
+                    Some('%') => {
+                        chars.next();
+                        current_literal.push('%');
+                    }
+                    Some('s') => {
+                        chars.next();
+                        segments.push(FormatSegment {
+                            literal: core::mem::take(&mut current_literal),
+                            conversion: Some(oparg::ConvertValueOparg::Str),
+                        });
+                    }
+                    Some('r') => {
+                        chars.next();
+                        segments.push(FormatSegment {
+                            literal: core::mem::take(&mut current_literal),
+                            conversion: Some(oparg::ConvertValueOparg::Repr),
+                        });
+                    }
+                    Some('a') => {
+                        chars.next();
+                        segments.push(FormatSegment {
+                            literal: core::mem::take(&mut current_literal),
+                            conversion: Some(oparg::ConvertValueOparg::Ascii),
+                        });
+                    }
+                    _ => {
+                        // Unsupported: %d, %f, %(name)s, %10s, etc.
+                        return None;
+                    }
+                }
+            } else {
+                current_literal.push(ch);
+            }
+        }
+
+        // Trailing literal
+        if !current_literal.is_empty() {
+            segments.push(FormatSegment {
+                literal: current_literal,
+                conversion: None,
+            });
+        }
+
+        Some(segments)
     }
 
     fn compile_fstring_elements(
@@ -8226,24 +10174,31 @@ impl Compiler {
         fstring_elements: &ast::InterpolatedStringElements,
     ) -> CompileResult<()> {
         let mut element_count = 0;
+        let mut pending_literal: Option<Wtf8Buf> = None;
+        self.compile_fstring_elements_into(
+            flags,
+            fstring_elements,
+            &mut pending_literal,
+            &mut element_count,
+        )?;
+        self.finish_fstring(pending_literal, element_count)
+    }
+
+    fn compile_fstring_elements_into(
+        &mut self,
+        flags: ast::FStringFlags,
+        fstring_elements: &ast::InterpolatedStringElements,
+        pending_literal: &mut Option<Wtf8Buf>,
+        element_count: &mut u32,
+    ) -> CompileResult<()> {
         for element in fstring_elements {
-            element_count += 1;
             match element {
                 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);
-                        let value = crate::string_parser::parse_fstring_literal_element(
-                            source.into(),
-                            flags.into(),
-                        );
-                        self.emit_load_const(ConstantData::Str {
-                            value: value.into(),
-                        });
+                    let value = self.compile_fstring_literal_value(string, flags);
+                    if let Some(pending) = pending_literal.as_mut() {
+                        pending.push_wtf8(value.as_ref());
                     } else {
-                        self.emit_load_const(ConstantData::Str {
-                            value: string.value.to_string().into(),
-                        });
+                        *pending_literal = Some(value);
                     }
                 }
                 ast::InterpolatedStringElement::Interpolation(fstring_expr) => {
@@ -8257,10 +10212,17 @@ impl Compiler {
                     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();
-
-                        self.emit_load_const(ConstantData::Str { value: text.into() });
-                        element_count += 1;
+                        let text = [
+                            strip_fstring_debug_comments(leading).as_str(),
+                            source,
+                            strip_fstring_debug_comments(trailing).as_str(),
+                        ]
+                        .concat();
+
+                        let text: Wtf8Buf = text.into();
+                        pending_literal
+                            .get_or_insert_with(Wtf8Buf::new)
+                            .push_wtf8(text.as_ref());
 
                         // If debug text is present, apply repr conversion when no `format_spec` specified.
                         // See action_helpers.c: fstring_find_expr_replacement
@@ -8272,6 +10234,8 @@ impl Compiler {
                         }
                     }
 
+                    self.emit_pending_fstring_literal(pending_literal, element_count, false);
+
                     self.compile_expression(&fstring_expr.expression)?;
 
                     match conversion {
@@ -8293,22 +10257,10 @@ impl Compiler {
                             emit!(self, Instruction::FormatSimple);
                         }
                     }
-                }
-            }
-        }
 
-        if element_count == 0 {
-            // ensure to put an empty string on the stack if there aren't any fstring elements
-            self.emit_load_const(ConstantData::Str {
-                value: Wtf8Buf::new(),
-            });
-        } else if element_count > 1 {
-            emit!(
-                self,
-                Instruction::BuildString {
-                    size: element_count
+                    *element_count += 1;
                 }
-            );
+            }
         }
 
         Ok(())
@@ -8334,13 +10286,18 @@ impl Compiler {
         }
 
         // Add trailing string
-        all_strings.push(std::mem::take(&mut current_string));
+        all_strings.push(core::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 });
+        emit!(
+            self,
+            Instruction::BuildTuple {
+                count: interp_count
+            }
+        );
 
         // 2. Load all string parts
         let string_count: u32 = all_strings
@@ -8352,10 +10309,15 @@ impl Compiler {
         }
 
         // 3. Build strings tuple
-        emit!(self, Instruction::BuildTuple { size: string_count });
+        emit!(
+            self,
+            Instruction::BuildTuple {
+                count: string_count
+            }
+        );
 
         // 4. Swap so strings is below interpolations: [interps, strings] -> [strings, interps]
-        emit!(self, Instruction::Swap { index: 2 });
+        emit!(self, Instruction::Swap { i: 2 });
 
         // 5. Build the Template
         emit!(self, Instruction::BuildTemplate);
@@ -8378,14 +10340,24 @@ impl Compiler {
                 }
                 ast::InterpolatedStringElement::Interpolation(interp) => {
                     // Finish current string segment
-                    strings.push(std::mem::take(current_string));
+                    strings.push(core::mem::take(current_string));
 
                     // Compile the interpolation value
                     self.compile_expression(&interp.expression)?;
 
-                    // Load the expression source string
+                    // Load the expression source string, including any
+                    // whitespace between '{' and the expression start
                     let expr_range = interp.expression.range();
-                    let expr_source = self.source_file.slice(expr_range);
+                    let expr_source = if interp.range.start() < expr_range.start()
+                        && interp.range.end() >= expr_range.end()
+                    {
+                        let after_brace = interp.range.start() + TextSize::new(1);
+                        self.source_file
+                            .slice(TextRange::new(after_brace, expr_range.end()))
+                    } else {
+                        // Fallback for programmatically constructed ASTs with dummy ranges
+                        self.source_file.slice(expr_range)
+                    };
                     self.emit_load_const(ConstantData::Str {
                         value: expr_source.to_string().into(),
                     });
@@ -8411,8 +10383,8 @@ impl Compiler {
 
                     // Emit BUILD_INTERPOLATION
                     // oparg encoding: (conversion << 2) | has_format_spec
-                    let oparg = (conversion << 2) | (has_format_spec as u32);
-                    emit!(self, Instruction::BuildInterpolation { oparg });
+                    let format = (conversion << 2) | u32::from(has_format_spec);
+                    emit!(self, Instruction::BuildInterpolation { format });
 
                     *interp_count += 1;
                 }
@@ -8445,7 +10417,7 @@ impl EmitArg<bytecode::Label> for BlockIdx {
         self,
         f: impl FnOnce(OpArgMarker<bytecode::Label>) -> I,
     ) -> (AnyInstruction, OpArg, BlockIdx) {
-        (f(OpArgMarker::marker()).into(), OpArg::null(), self)
+        (f(OpArgMarker::marker()).into(), OpArg::NULL, self)
     }
 }
 
@@ -8455,32 +10427,34 @@ impl EmitArg<bytecode::Label> for BlockIdx {
 // = _PyCompile_CleanDoc
 fn clean_doc(doc: &str) -> String {
     let doc = expandtabs(doc, 8);
-    // First pass: find minimum indentation of any non-blank lines
-    // after first line.
+    // First pass: find minimum indentation of non-blank lines AFTER the first line.
+    // A "blank line" is one containing only spaces (or empty).
     let margin = doc
-        .lines()
-        // Find the non-blank lines
-        .filter(|line| !line.trim().is_empty())
-        // get the one with the least indentation
-        .map(|line| line.chars().take_while(|c| c == &' ').count())
-        .min();
-    if let Some(margin) = margin {
-        let mut cleaned = String::with_capacity(doc.len());
-        // copy first line without leading whitespace
-        if let Some(first_line) = doc.lines().next() {
-            cleaned.push_str(first_line.trim_start());
-        }
-        // copy subsequent lines without margin.
-        for line in doc.split('\n').skip(1) {
-            cleaned.push('\n');
-            let cleaned_line = line.chars().skip(margin).collect::<String>();
-            cleaned.push_str(&cleaned_line);
-        }
-
-        cleaned
-    } else {
-        doc.to_owned()
-    }
+        .split('\n')
+        .skip(1) // skip first line
+        .filter(|line| line.chars().any(|c| c != ' ')) // non-blank lines only
+        .map(|line| line.chars().take_while(|c| *c == ' ').count())
+        .min()
+        .unwrap_or(0);
+
+    let mut cleaned = String::with_capacity(doc.len());
+    // Strip all leading spaces from the first line
+    if let Some(first_line) = doc.split('\n').next() {
+        let trimmed = first_line.trim_start();
+        // Early exit: no leading spaces on first line AND margin == 0
+        if trimmed.len() == first_line.len() && margin == 0 {
+            return doc.to_owned();
+        }
+        cleaned.push_str(trimmed);
+    }
+    // Subsequent lines: skip up to `margin` leading spaces
+    for line in doc.split('\n').skip(1) {
+        cleaned.push('\n');
+        let skip = line.chars().take(margin).take_while(|c| *c == ' ').count();
+        cleaned.push_str(&line[skip..]);
+    }
+
+    cleaned
 }
 
 // copied from rustpython_common::str, so we don't have to depend on it just for this function
@@ -8583,6 +10557,27 @@ impl ToU32 for usize {
     }
 }
 
+/// Strip Python comments from f-string debug text (leading/trailing around `=`).
+/// A comment starts with `#` and extends to the end of the line.
+/// The newline character itself is preserved.
+fn strip_fstring_debug_comments(text: &str) -> String {
+    let mut result = String::with_capacity(text.len());
+    let mut in_comment = false;
+    for ch in text.chars() {
+        if in_comment {
+            if ch == '\n' {
+                in_comment = false;
+                result.push(ch);
+            }
+        } else if ch == '#' {
+            in_comment = true;
+        } else {
+            result.push(ch);
+        }
+    }
+    result
+}
+
 #[cfg(test)]
 mod ruff_tests {
     use super::*;
@@ -8714,10 +10709,43 @@ mod ruff_tests {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use rustpython_compiler_core::SourceFileBuilder;
+    use rustpython_compiler_core::{SourceFileBuilder, bytecode::OpArg};
+
+    fn assert_scope_exit_locations(code: &CodeObject) {
+        for (instr, (location, _)) in code.instructions.iter().zip(code.locations.iter()) {
+            if matches!(
+                instr.op,
+                Instruction::ReturnValue
+                    | Instruction::RaiseVarargs { .. }
+                    | Instruction::Reraise { .. }
+            ) {
+                assert!(
+                    location.line.get() > 0,
+                    "scope-exit instruction {instr:?} is missing a line number"
+                );
+            }
+        }
+        for constant in code.constants.iter() {
+            if let ConstantData::Code { code } = constant {
+                assert_scope_exit_locations(code);
+            }
+        }
+    }
 
     fn compile_exec(source: &str) -> CodeObject {
         let opts = CompileOpts::default();
+        compile_exec_with_options(source, opts)
+    }
+
+    fn compile_exec_optimized(source: &str) -> CodeObject {
+        let opts = CompileOpts {
+            optimize: 1,
+            ..CompileOpts::default()
+        };
+        compile_exec_with_options(source, opts)
+    }
+
+    fn compile_exec_with_options(source: &str, opts: CompileOpts) -> CodeObject {
         let source_file = SourceFileBuilder::new("source_path", source).finish();
         let parsed = ruff_python_parser::parse(
             source_file.source_text(),
@@ -8737,6 +10765,37 @@ mod tests {
         compiler.exit_scope()
     }
 
+    fn find_code<'a>(code: &'a CodeObject, name: &str) -> Option<&'a CodeObject> {
+        if code.obj_name == name {
+            return Some(code);
+        }
+        code.constants.iter().find_map(|constant| {
+            if let ConstantData::Code { code } = constant {
+                find_code(code, name)
+            } else {
+                None
+            }
+        })
+    }
+
+    fn has_common_constant(code: &CodeObject, expected: bytecode::CommonConstant) -> bool {
+        code.instructions.iter().any(|unit| match unit.op {
+            Instruction::LoadCommonConstant { idx } => {
+                idx.get(OpArg::new(u32::from(u8::from(unit.arg)))) == expected
+            }
+            _ => false,
+        })
+    }
+
+    fn has_intrinsic_1(code: &CodeObject, expected: IntrinsicFunction1) -> bool {
+        code.instructions.iter().any(|unit| match unit.op {
+            Instruction::CallIntrinsic1 { func } => {
+                func.get(OpArg::new(u32::from(u8::from(unit.arg)))) == expected
+            }
+            _ => false,
+        })
+    }
+
     macro_rules! assert_dis_snapshot {
         ($value:expr) => {
             insta::assert_snapshot!(
@@ -8777,6 +10836,24 @@ if (True and False) or (False and True):
         ));
     }
 
+    #[test]
+    fn test_nested_bool_op() {
+        assert_dis_snapshot!(compile_exec(
+            "\
+x = Test() and False or False
+"
+        ));
+    }
+
+    #[test]
+    fn test_const_bool_not_op() {
+        assert_dis_snapshot!(compile_exec_optimized(
+            "\
+x = not True
+"
+        ));
+    }
+
     #[test]
     fn test_nested_double_async_with() {
         assert_dis_snapshot!(compile_exec(
@@ -8794,4 +10871,548 @@ async def test():
 "
         ));
     }
+
+    #[test]
+    fn test_scope_exit_instructions_keep_line_numbers() {
+        let code = compile_exec(
+            "\
+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')
+",
+        );
+        assert_scope_exit_locations(&code);
+    }
+
+    #[test]
+    fn test_attribute_ex_call_uses_plain_load_attr() {
+        let code = compile_exec(
+            "\
+def f(cls, args, kwargs):
+    cls.__new__(cls, *args)
+    cls.__new__(cls, *args, **kwargs)
+",
+        );
+        let f = find_code(&code, "f").expect("missing function code");
+
+        let ex_call_count = f
+            .instructions
+            .iter()
+            .filter(|unit| matches!(unit.op, Instruction::CallFunctionEx))
+            .count();
+        let load_attr_count = f
+            .instructions
+            .iter()
+            .filter(|unit| matches!(unit.op, Instruction::LoadAttr { .. }))
+            .count();
+
+        assert_eq!(ex_call_count, 2);
+        assert_eq!(load_attr_count, 2);
+
+        for unit in f.instructions.iter() {
+            if let Instruction::LoadAttr { namei } = unit.op {
+                let load_attr = namei.get(OpArg::new(u32::from(u8::from(unit.arg))));
+                assert!(
+                    !load_attr.is_method(),
+                    "CALL_FUNCTION_EX should use plain LOAD_ATTR"
+                );
+            }
+        }
+    }
+
+    #[test]
+    fn test_simple_attribute_call_keeps_method_load() {
+        let code = compile_exec(
+            "\
+def f(obj, arg):
+    return obj.method(arg)
+",
+        );
+        let f = find_code(&code, "f").expect("missing function code");
+        let load_attr = f
+            .instructions
+            .iter()
+            .find_map(|unit| match unit.op {
+                Instruction::LoadAttr { namei } => {
+                    Some(namei.get(OpArg::new(u32::from(u8::from(unit.arg)))))
+                }
+                _ => None,
+            })
+            .expect("missing LOAD_ATTR");
+
+        assert!(
+            load_attr.is_method(),
+            "simple method calls should stay optimized"
+        );
+    }
+
+    #[test]
+    fn test_builtin_any_genexpr_call_is_optimized() {
+        let code = compile_exec(
+            "\
+def f(xs):
+    return any(x for x in xs)
+",
+        );
+        let f = find_code(&code, "f").expect("missing function code");
+
+        assert!(has_common_constant(f, bytecode::CommonConstant::BuiltinAny));
+        assert!(
+            f.instructions
+                .iter()
+                .any(|unit| matches!(unit.op, Instruction::PopJumpIfTrue { .. }))
+        );
+        assert!(
+            f.instructions
+                .iter()
+                .any(|unit| matches!(unit.op, Instruction::NotTaken))
+        );
+        assert_eq!(
+            f.instructions
+                .iter()
+                .filter(|unit| matches!(unit.op, Instruction::PushNull))
+                .count(),
+            1,
+            "fallback call path should remain for shadowed any()"
+        );
+    }
+
+    #[test]
+    fn test_builtin_tuple_list_set_genexpr_calls_are_optimized() {
+        let code = compile_exec(
+            "\
+def tuple_f(xs):
+    return tuple(x for x in xs)
+
+def list_f(xs):
+    return list(x for x in xs)
+
+def set_f(xs):
+    return set(x for x in xs)
+",
+        );
+
+        let tuple_f = find_code(&code, "tuple_f").expect("missing tuple_f code");
+        assert!(has_common_constant(
+            tuple_f,
+            bytecode::CommonConstant::BuiltinTuple
+        ));
+        assert!(has_intrinsic_1(tuple_f, IntrinsicFunction1::ListToTuple));
+        let tuple_list_append = tuple_f
+            .instructions
+            .iter()
+            .find_map(|unit| match unit.op {
+                Instruction::ListAppend { .. } => Some(u32::from(u8::from(unit.arg))),
+                _ => None,
+            })
+            .expect("tuple(genexpr) fast path should emit LIST_APPEND");
+        assert_eq!(tuple_list_append, 2);
+
+        let list_f = find_code(&code, "list_f").expect("missing list_f code");
+        assert!(has_common_constant(
+            list_f,
+            bytecode::CommonConstant::BuiltinList
+        ));
+        assert!(
+            list_f
+                .instructions
+                .iter()
+                .any(|unit| matches!(unit.op, Instruction::ListAppend { .. }))
+        );
+
+        let set_f = find_code(&code, "set_f").expect("missing set_f code");
+        assert!(has_common_constant(
+            set_f,
+            bytecode::CommonConstant::BuiltinSet
+        ));
+        assert!(
+            set_f
+                .instructions
+                .iter()
+                .any(|unit| matches!(unit.op, Instruction::SetAdd { .. }))
+        );
+    }
+
+    #[test]
+    fn test_module_store_uses_store_global_when_nested_scope_declares_global() {
+        let code = compile_exec(
+            "\
+_address_fmt_re = None
+
+class C:
+    def f(self):
+        global _address_fmt_re
+        if _address_fmt_re is None:
+            _address_fmt_re = 1
+",
+        );
+
+        assert!(code.instructions.iter().any(|unit| match unit.op {
+            Instruction::StoreGlobal { namei } => {
+                let idx = namei.get(OpArg::new(u32::from(u8::from(unit.arg))));
+                code.names[usize::try_from(idx).unwrap()].as_str() == "_address_fmt_re"
+            }
+            _ => false,
+        }));
+    }
+
+    #[test]
+    fn test_conditional_return_epilogue_is_duplicated() {
+        let code = compile_exec(
+            "\
+def f(base, cls, state):
+    if base is object:
+        obj = object.__new__(cls)
+    else:
+        obj = base.__new__(cls, state)
+    return obj
+",
+        );
+        let f = find_code(&code, "f").expect("missing function code");
+        let return_count = f
+            .instructions
+            .iter()
+            .filter(|unit| matches!(unit.op, Instruction::ReturnValue))
+            .count();
+
+        assert_eq!(return_count, 2);
+    }
+
+    #[test]
+    fn test_assert_without_message_raises_class_directly() {
+        let code = compile_exec(
+            "\
+def f(x):
+    assert x
+",
+        );
+        let f = find_code(&code, "f").expect("missing function code");
+        let call_count = f
+            .instructions
+            .iter()
+            .filter(|unit| matches!(unit.op, Instruction::Call { .. }))
+            .count();
+        let push_null_count = f
+            .instructions
+            .iter()
+            .filter(|unit| matches!(unit.op, Instruction::PushNull))
+            .count();
+
+        assert_eq!(call_count, 0);
+        assert_eq!(push_null_count, 0);
+    }
+
+    #[test]
+    fn test_chained_compare_jump_uses_single_cleanup_copy() {
+        let code = compile_exec(
+            "\
+def f(code):
+    if not 1 <= code <= 2147483647:
+        raise ValueError('x')
+",
+        );
+        let f = find_code(&code, "f").expect("missing function code");
+        let copy_count = f
+            .instructions
+            .iter()
+            .filter(|unit| matches!(unit.op, Instruction::Copy { .. }))
+            .count();
+        let pop_top_count = f
+            .instructions
+            .iter()
+            .filter(|unit| matches!(unit.op, Instruction::PopTop))
+            .count();
+
+        assert_eq!(copy_count, 1);
+        assert_eq!(pop_top_count, 1);
+    }
+
+    #[test]
+    fn test_constant_slice_folding_handles_string_and_bigint_bounds() {
+        let code = compile_exec(
+            "\
+def f(obj):
+    return obj['a':123456789012345678901234567890]
+",
+        );
+        let f = find_code(&code, "f").expect("missing function code");
+        let slice = f
+            .constants
+            .iter()
+            .find_map(|constant| match constant {
+                ConstantData::Slice { elements } => Some(elements),
+                _ => None,
+            })
+            .expect("missing folded slice constant");
+
+        assert!(matches!(slice[0], ConstantData::Str { .. }));
+        assert!(matches!(slice[1], ConstantData::Integer { .. }));
+        assert!(matches!(slice[2], ConstantData::None));
+    }
+
+    #[test]
+    fn test_exception_cleanup_jump_to_return_is_inlined() {
+        let code = compile_exec(
+            "\
+def f(names, cls):
+    try:
+        cls.attr = names
+    except:
+        pass
+    return names
+",
+        );
+        let f = find_code(&code, "f").expect("missing function code");
+        let return_count = f
+            .instructions
+            .iter()
+            .filter(|unit| matches!(unit.op, Instruction::ReturnValue))
+            .count();
+
+        assert_eq!(return_count, 2);
+    }
+
+    #[test]
+    fn test_fstring_adjacent_literals_are_merged() {
+        let code = compile_exec(
+            "\
+def f(cls, proto):
+    raise TypeError(
+        f\"cannot pickle {cls.__name__!r} object: \"
+        f\"a class that defines __slots__ without \"
+        f\"defining __getstate__ cannot be pickled \"
+        f\"with protocol {proto}\"
+    )
+",
+        );
+        let f = find_code(&code, "f").expect("missing function code");
+        let string_consts = f
+            .instructions
+            .iter()
+            .filter_map(|unit| match unit.op {
+                Instruction::LoadConst { consti } => {
+                    Some(&f.constants[consti.get(OpArg::new(u32::from(u8::from(unit.arg))))])
+                }
+                _ => None,
+            })
+            .filter_map(|constant| match constant {
+                ConstantData::Str { value } => Some(value.to_string()),
+                _ => None,
+            })
+            .collect::<Vec<_>>();
+
+        assert!(
+            string_consts.iter().any(|value| {
+                value
+                    == " object: a class that defines __slots__ without defining __getstate__ cannot be pickled with protocol "
+            }),
+            "expected merged trailing f-string literal, got {string_consts:?}"
+        );
+        assert!(
+            !string_consts.iter().any(|value| value == " object: "),
+            "did not expect split trailing literal, got {string_consts:?}"
+        );
+    }
+
+    #[test]
+    fn test_literal_only_fstring_statement_is_optimized_away() {
+        let code = compile_exec(
+            "\
+def f():
+    f'''Not a docstring'''
+",
+        );
+        let f = find_code(&code, "f").expect("missing function code");
+
+        assert!(
+            !f.instructions
+                .iter()
+                .any(|unit| matches!(unit.op, Instruction::PopTop)),
+            "literal-only f-string statement should be removed"
+        );
+        assert!(
+            !f.constants.iter().any(|constant| matches!(
+                constant,
+                ConstantData::Str { value } if value.to_string() == "Not a docstring"
+            )),
+            "literal-only f-string should not survive in constants"
+        );
+    }
+
+    #[test]
+    fn test_empty_fstring_literals_are_elided_around_interpolation() {
+        let code = compile_exec(
+            "\
+def f(x):
+    if '' f'{x}':
+        return 1
+    return 2
+",
+        );
+        let f = find_code(&code, "f").expect("missing function code");
+
+        let empty_string_loads = f
+            .instructions
+            .iter()
+            .filter_map(|unit| match unit.op {
+                Instruction::LoadConst { consti } => {
+                    Some(&f.constants[consti.get(OpArg::new(u32::from(u8::from(unit.arg))))])
+                }
+                _ => None,
+            })
+            .filter(|constant| {
+                matches!(
+                    constant,
+                    ConstantData::Str { value } if value.is_empty()
+                )
+            })
+            .count();
+        let build_string_count = f
+            .instructions
+            .iter()
+            .filter(|unit| matches!(unit.op, Instruction::BuildString { .. }))
+            .count();
+
+        assert_eq!(empty_string_loads, 0);
+        assert_eq!(build_string_count, 0);
+    }
+
+    #[test]
+    fn test_large_power_is_not_constant_folded() {
+        let code = compile_exec("x = 2**100\n");
+
+        assert!(code.instructions.iter().any(|unit| match unit.op {
+            Instruction::BinaryOp { op } => {
+                op.get(OpArg::new(u32::from(u8::from(unit.arg)))) == oparg::BinaryOperator::Power
+            }
+            _ => false,
+        }));
+    }
+
+    #[test]
+    fn test_list_of_constant_tuples_uses_list_extend() {
+        let code = compile_exec(
+            "\
+deprecated_cases = [('a', 'b'), ('c', 'd'), ('e', 'f'), ('g', 'h'), ('i', 'j')]
+",
+        );
+
+        assert!(
+            code.instructions
+                .iter()
+                .any(|unit| matches!(unit.op, Instruction::ListExtend { .. })),
+            "expected constant tuple list folding"
+        );
+    }
+
+    #[test]
+    fn test_constant_list_iterable_uses_tuple() {
+        let code = compile_exec(
+            "\
+def f():
+    return {x: y for x, y in [(1, 2), ]}
+",
+        );
+        let f = find_code(&code, "f").expect("missing function code");
+
+        assert!(
+            !f.instructions
+                .iter()
+                .any(|unit| matches!(unit.op, Instruction::BuildList { .. })),
+            "constant list iterable should avoid BUILD_LIST before GET_ITER"
+        );
+        assert!(f.constants.iter().any(|constant| matches!(
+            constant,
+            ConstantData::Tuple { elements }
+                if matches!(
+                    elements.as_slice(),
+                    [ConstantData::Tuple { elements: inner }]
+                        if matches!(
+                            inner.as_slice(),
+                            [
+                                ConstantData::Integer { .. },
+                                ConstantData::Integer { .. }
+                            ]
+                        )
+                )
+        )));
+    }
+
+    #[test]
+    fn test_constant_set_iterable_keeps_runtime_set_build() {
+        let code = compile_exec(
+            "\
+def f():
+    return [x for x in {1, 2, 3}]
+",
+        );
+        let f = find_code(&code, "f").expect("missing function code");
+
+        assert!(
+            f.instructions
+                .iter()
+                .any(|unit| matches!(unit.op, Instruction::BuildSet { .. })),
+            "constant set iterable should keep BUILD_SET before GET_ITER"
+        );
+        assert!(f.constants.iter().any(|constant| matches!(
+            constant,
+            ConstantData::Tuple { elements }
+                if matches!(
+                    elements.as_slice(),
+                    [
+                        ConstantData::Integer { .. },
+                        ConstantData::Integer { .. },
+                        ConstantData::Integer { .. }
+                    ]
+                )
+        )));
+    }
+
+    #[test]
+    fn test_optimized_assert_preserves_nested_scope_order() {
+        compile_exec_optimized(
+            "\
+class S:
+    def f(self, sequence):
+        _formats = [self._types_mapping[type(item)] for item in sequence]
+        _list_len = len(_formats)
+        assert sum(len(fmt) <= 8 for fmt in _formats) == _list_len
+        _recreation_codes = [self._extract_recreation_code(item) for item in sequence]
+",
+        );
+    }
+
+    #[test]
+    fn test_optimized_assert_with_nested_scope_in_first_iter() {
+        // First iterator of a comprehension is evaluated in the enclosing
+        // scope, so nested scopes inside it (the generator here) must also
+        // be consumed when the assert is optimized away.
+        compile_exec_optimized(
+            "\
+def f(items):
+    assert [x for x in (y for y in items)]
+    return [x for x in items]
+",
+        );
+    }
+
+    #[test]
+    fn test_optimized_assert_with_lambda_defaults() {
+        // Lambda default values are evaluated in the enclosing scope,
+        // so nested scopes inside defaults must be consumed.
+        compile_exec_optimized(
+            "\
+def f(items):
+    assert (lambda x=[i for i in items]: x)()
+    return [x for x in items]
+",
+        );
+    }
 }
diff --git a/crates/codegen/src/error.rs b/crates/codegen/src/error.rs
index 9f1dcc27058..086f9dfd739 100644
--- a/crates/codegen/src/error.rs
+++ b/crates/codegen/src/error.rs
@@ -107,9 +107,9 @@ impl fmt::Display for CodegenErrorType {
             Delete(target) => write!(f, "cannot delete {target}"),
             SyntaxError(err) => write!(f, "{}", err.as_str()),
             MultipleStarArgs => {
-                write!(f, "two starred expressions in assignment")
+                write!(f, "multiple starred expressions in assignment")
             }
-            InvalidStarExpr => write!(f, "cannot use starred expression here"),
+            InvalidStarExpr => write!(f, "can't use starred expression here"),
             InvalidBreak => write!(f, "'break' outside loop"),
             InvalidContinue => write!(f, "'continue' outside loop"),
             InvalidReturn => write!(f, "'return' outside function"),
diff --git a/crates/codegen/src/ir.rs b/crates/codegen/src/ir.rs
index 59b5f7d4d09..bc709147479 100644
--- a/crates/codegen/src/ir.rs
+++ b/crates/codegen/src/ir.rs
@@ -1,15 +1,17 @@
+use alloc::collections::VecDeque;
 use core::ops;
 
 use crate::{IndexMap, IndexSet, error::InternalError};
 use malachite_bigint::BigInt;
-use num_traits::ToPrimitive;
+use num_traits::{ToPrimitive, Zero};
 
 use rustpython_compiler_core::{
     OneIndexed, SourceLocation,
     bytecode::{
-        AnyInstruction, Arg, CodeFlags, CodeObject, CodeUnit, CodeUnits, ConstantData,
-        ExceptionTableEntry, InstrDisplayContext, Instruction, InstructionMetadata, Label, OpArg,
-        PseudoInstruction, PyCodeLocationInfoKind, encode_exception_table,
+        AnyInstruction, Arg, CO_FAST_CELL, CO_FAST_FREE, CO_FAST_HIDDEN, CO_FAST_LOCAL, CodeFlags,
+        CodeObject, CodeUnit, CodeUnits, ConstantData, ExceptionTableEntry, InstrDisplayContext,
+        Instruction, InstructionMetadata, Label, OpArg, PseudoInstruction, PyCodeLocationInfoKind,
+        encode_exception_table, oparg,
     },
     varint::{write_signed_varint, write_varint},
 };
@@ -23,6 +25,9 @@ struct LineTableLocation {
     end_col: i32,
 }
 
+const MAX_INT_SIZE_BITS: u64 = 128;
+const MIN_CONST_SEQUENCE_SIZE: usize = 3;
+
 /// Metadata for a code unit
 // = _PyCompile_CodeUnitMetadata
 #[derive(Clone, Debug)]
@@ -105,10 +110,12 @@ pub struct InstructionInfo {
     pub except_handler: Option<ExceptHandlerInfo>,
     /// Override line number for linetable (e.g., line 0 for module RESUME)
     pub lineno_override: Option<i32>,
+    /// Number of CACHE code units emitted after this instruction
+    pub cache_entries: u32,
 }
 
 /// Exception handler information for an instruction.
-#[derive(Clone, Copy, Debug)]
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
 pub struct ExceptHandlerInfo {
     /// Block to jump to when exception occurs
     pub handler_block: BlockIdx,
@@ -121,10 +128,19 @@ pub struct ExceptHandlerInfo {
 // spell-checker:ignore petgraph
 // TODO: look into using petgraph for handling blocks and stuff? it's heavier than this, but it
 // might enable more analysis/optimizations
-#[derive(Debug)]
+#[derive(Debug, Clone)]
 pub struct Block {
     pub instructions: Vec<InstructionInfo>,
     pub next: BlockIdx,
+    // Post-codegen analysis fields (set by label_exception_targets)
+    /// Whether this block is an exception handler target (b_except_handler)
+    pub except_handler: bool,
+    /// Whether to preserve lasti for this handler block (b_preserve_lasti)
+    pub preserve_lasti: bool,
+    /// Stack depth at block entry, set by stack depth analysis
+    pub start_depth: Option<u32>,
+    /// Whether this block is only reachable via exception table (b_cold)
+    pub cold: bool,
 }
 
 impl Default for Block {
@@ -132,6 +148,10 @@ impl Default for Block {
         Self {
             instructions: Vec::new(),
             next: BlockIdx::NULL,
+            except_handler: false,
+            preserve_lasti: false,
+            start_depth: None,
+            cold: false,
         }
     }
 }
@@ -172,28 +192,52 @@ impl CodeInfo {
         mut self,
         opts: &crate::compile::CompileOpts,
     ) -> crate::InternalResult<CodeObject> {
-        // Always fold tuple constants
+        // Constant folding passes
+        self.fold_binop_constants();
+        self.remove_nops();
+        self.fold_unary_negative();
+        self.fold_binop_constants(); // re-run after unary folding: -1 + 2 → 1
+        self.remove_nops(); // remove NOPs so tuple/list/set see contiguous LOADs
         self.fold_tuple_constants();
-        // Python only applies LOAD_SMALL_INT conversion to module-level code
-        // (not inside functions). Module code lacks OPTIMIZED flag.
-        // Note: RustPython incorrectly sets NEWLOCALS on modules, so only check OPTIMIZED
-        let is_module_level = !self.flags.contains(CodeFlags::OPTIMIZED);
-        if is_module_level {
-            self.convert_to_load_small_int();
-        }
+        self.fold_list_constants();
+        self.fold_set_constants();
+        self.remove_nops(); // remove NOPs from collection folding
+        self.fold_const_iterable_for_iter();
+        self.convert_to_load_small_int();
         self.remove_unused_consts();
         self.remove_nops();
 
-        if opts.optimize > 0 {
-            self.dce();
-            self.peephole_optimize();
-        }
-
-        // Always apply LOAD_FAST_BORROW optimization
+        // DCE always runs (removes dead code after terminal instructions)
+        self.dce();
+        // Peephole optimizer creates superinstructions matching CPython
+        self.peephole_optimize();
+
+        // Phase 1: _PyCfg_OptimizeCodeUnit (flowgraph.c)
+        // Split blocks so each block has at most one branch as its last instruction
+        split_blocks_at_jumps(&mut self.blocks);
+        mark_except_handlers(&mut self.blocks);
+        label_exception_targets(&mut self.blocks);
+        // optimize_cfg: jump threading (before push_cold_blocks_to_end)
+        jump_threading(&mut self.blocks);
+        self.eliminate_unreachable_blocks();
+        self.remove_nops();
+        // TODO: insert_superinstructions disabled pending StoreFastLoadFast VM fix
+        push_cold_blocks_to_end(&mut self.blocks);
+
+        // Phase 2: _PyCfg_OptimizedCfgToInstructionSequence (flowgraph.c)
+        normalize_jumps(&mut self.blocks);
+        inline_small_or_no_lineno_blocks(&mut self.blocks);
+        self.dce(); // re-run within-block DCE after normalize_jumps creates new instructions
+        self.eliminate_unreachable_blocks();
+        resolve_line_numbers(&mut self.blocks);
+        duplicate_end_returns(&mut self.blocks);
+        self.dce(); // truncate after terminal in blocks that got return duplicated
+        self.eliminate_unreachable_blocks(); // remove now-unreachable last block
+        // optimize_load_fast: after normalize_jumps
         self.optimize_load_fast_borrow();
+        self.optimize_load_global_push_null();
 
         let max_stackdepth = self.max_stackdepth()?;
-        let cell2arg = self.cell2arg();
 
         let Self {
             flags,
@@ -219,7 +263,7 @@ impl CodeInfo {
             varnames: varname_cache,
             cellvars: cellvar_cache,
             freevars: freevar_cache,
-            fast_hidden: _,
+            fast_hidden,
             argcount: arg_count,
             posonlyargcount: posonlyarg_count,
             kwonlyargcount: kwonlyarg_count,
@@ -230,110 +274,207 @@ impl CodeInfo {
         let mut locations = Vec::new();
         let mut linetable_locations: Vec<LineTableLocation> = 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 {
-                // Real instructions are already encoded by compile.rs
-                let Some(instr) = info.instr.pseudo() else {
-                    continue;
-                };
-
-                match instr {
-                    // POP_BLOCK pseudo → NOP
-                    PseudoInstruction::PopBlock => {
-                        info.instr = Instruction::Nop.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();
+        // Build cellfixedoffsets for cell-local merging
+        let cellfixedoffsets =
+            build_cellfixedoffsets(&varname_cache, &cellvar_cache, &freevar_cache);
+        // Convert pseudo ops (LoadClosure uses cellfixedoffsets) and fixup DEREF opargs
+        convert_pseudo_ops(&mut blocks, &cellfixedoffsets);
+        fixup_deref_opargs(&mut blocks, &cellfixedoffsets);
+        // Remove redundant NOPs, keeping line-marker NOPs only when
+        // they are needed to preserve tracing.
+        let mut block_order = Vec::new();
+        let mut current = BlockIdx(0);
+        while current != BlockIdx::NULL {
+            block_order.push(current);
+            current = blocks[current.idx()].next;
+        }
+        for block_idx in block_order {
+            let bi = block_idx.idx();
+            let mut src_instructions = core::mem::take(&mut blocks[bi].instructions);
+            let mut kept = Vec::with_capacity(src_instructions.len());
+            let mut prev_lineno = -1i32;
+
+            for src in 0..src_instructions.len() {
+                let instr = src_instructions[src];
+                let lineno = instr
+                    .lineno_override
+                    .unwrap_or_else(|| instr.location.line.get() as i32);
+                let mut remove = false;
+
+                if matches!(instr.instr.real(), Some(Instruction::Nop)) {
+                    // Remove location-less NOPs.
+                    if lineno < 0 || prev_lineno == lineno {
+                        remove = true;
                     }
-                    PseudoInstruction::Jump { .. } | PseudoInstruction::JumpNoInterrupt { .. } => {
-                        // Jump pseudo instructions are handled later
+                    // Remove if the next instruction has same line or no line.
+                    else if src < src_instructions.len() - 1 {
+                        let next_lineno =
+                            src_instructions[src + 1]
+                                .lineno_override
+                                .unwrap_or_else(|| {
+                                    src_instructions[src + 1].location.line.get() as i32
+                                });
+                        if next_lineno == lineno {
+                            remove = true;
+                        } else if next_lineno < 0 {
+                            src_instructions[src + 1].lineno_override = Some(lineno);
+                            remove = true;
+                        }
                     }
-                    PseudoInstruction::AnnotationsPlaceholder
-                    | PseudoInstruction::JumpIfFalse { .. }
-                    | PseudoInstruction::JumpIfTrue { .. }
-                    | PseudoInstruction::SetupCleanup
-                    | PseudoInstruction::SetupFinally
-                    | PseudoInstruction::SetupWith
-                    | PseudoInstruction::StoreFastMaybeNull(_) => {
-                        unimplemented!("Got a placeholder pseudo instruction ({instr:?})")
+                    // Last instruction in block: compare with first real location
+                    // in the next non-empty block.
+                    else {
+                        let mut next = blocks[bi].next;
+                        while next != BlockIdx::NULL && blocks[next.idx()].instructions.is_empty() {
+                            next = blocks[next.idx()].next;
+                        }
+                        if next != BlockIdx::NULL {
+                            let mut next_lineno = None;
+                            for next_instr in &blocks[next.idx()].instructions {
+                                let line = next_instr
+                                    .lineno_override
+                                    .unwrap_or_else(|| next_instr.location.line.get() as i32);
+                                if matches!(next_instr.instr.real(), Some(Instruction::Nop))
+                                    && line < 0
+                                {
+                                    continue;
+                                }
+                                next_lineno = Some(line);
+                                break;
+                            }
+                            if next_lineno.is_some_and(|line| line == lineno) {
+                                remove = true;
+                            }
+                        }
                     }
                 }
+
+                if !remove {
+                    kept.push(instr);
+                    prev_lineno = lineno;
+                }
+            }
+
+            blocks[bi].instructions = kept;
+        }
+
+        // Final DCE: truncate instructions after terminal ops in linearized blocks.
+        // This catches dead code created by normalize_jumps after the initial DCE.
+        for block in blocks.iter_mut() {
+            if let Some(pos) = block
+                .instructions
+                .iter()
+                .position(|ins| ins.instr.is_scope_exit() || ins.instr.is_unconditional_jump())
+            {
+                block.instructions.truncate(pos + 1);
+            }
+        }
+
+        // Pre-compute cache_entries for real (non-pseudo) instructions
+        for block in blocks.iter_mut() {
+            for instr in &mut block.instructions {
+                if let AnyInstruction::Real(op) = instr.instr {
+                    instr.cache_entries = op.cache_entries() as u32;
+                }
             }
         }
 
-        let mut block_to_offset = vec![Label(0); blocks.len()];
+        let mut block_to_offset = vec![Label::from_u32(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
+        // This is the index into the final instructions array, including EXTENDED_ARG and CACHE
         let mut block_to_index = vec![0u32; blocks.len()];
+        // The offset (in code units) of END_SEND from SEND in the yield-from sequence.
+        const END_SEND_OFFSET: u32 = 5;
         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_offset[idx.idx()] = Label::from_u32(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() + instr.cache_entries as usize;
                 }
             }
 
             instructions.reserve_exact(num_instructions);
             locations.reserve_exact(num_instructions);
 
-            let mut recompile_extended_arg = false;
+            let mut recompile = false;
             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;
+                let mut current_offset = block_to_offset[next_block.idx()].as_u32();
                 for info in &mut block.instructions {
                     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() != info.arg.instr_size();
-                        info.arg = new_arg;
-                    }
+                    let mut op = info.instr.expect_real();
+                    let old_arg_size = info.arg.instr_size();
+                    let old_cache_entries = info.cache_entries;
+                    // Keep offsets fixed within this pass: changes in jump
+                    // arg/cache sizes only take effect in the next iteration.
+                    let offset_after = current_offset + old_arg_size as u32 + old_cache_entries;
 
-                    // Convert JUMP pseudo to real instructions (direction depends on offset)
-                    let op = match info.instr {
-                        AnyInstruction::Pseudo(PseudoInstruction::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 {
+                    if target != BlockIdx::NULL {
+                        let target_offset = block_to_offset[target.idx()].as_u32();
+                        // Direction must be based on concrete instruction offsets.
+                        // Empty blocks can share offsets, so block-order-based resolution
+                        // may classify some jumps incorrectly.
+                        op = match op {
+                            Instruction::JumpForward { .. } if target_offset <= current_offset => {
                                 Instruction::JumpBackward {
-                                    target: Arg::marker(),
+                                    delta: Arg::marker(),
                                 }
                             }
-                        }
-                        AnyInstruction::Pseudo(PseudoInstruction::JumpNoInterrupt { .. })
-                            if target != BlockIdx::NULL =>
-                        {
-                            // JumpNoInterrupt is always backward (used in yield-from/await loops)
-                            Instruction::JumpBackwardNoInterrupt {
-                                target: Arg::marker(),
+                            Instruction::JumpBackward { .. } if target_offset > current_offset => {
+                                Instruction::JumpForward {
+                                    delta: Arg::marker(),
+                                }
                             }
-                        }
-                        other => other.expect_real(),
-                    };
+                            Instruction::JumpBackwardNoInterrupt { .. }
+                                if target_offset > current_offset =>
+                            {
+                                Instruction::JumpForward {
+                                    delta: Arg::marker(),
+                                }
+                            }
+                            _ => op,
+                        };
+                        info.instr = op.into();
+                        let updated_cache = op.cache_entries() as u32;
+                        recompile |= updated_cache != old_cache_entries;
+                        info.cache_entries = updated_cache;
+                        let new_arg = if matches!(op, Instruction::EndAsyncFor) {
+                            let arg = offset_after
+                                .checked_sub(target_offset + END_SEND_OFFSET)
+                                .expect("END_ASYNC_FOR target must be before instruction");
+                            OpArg::new(arg)
+                        } else if matches!(
+                            op,
+                            Instruction::JumpBackward { .. }
+                                | Instruction::JumpBackwardNoInterrupt { .. }
+                        ) {
+                            let arg = offset_after
+                                .checked_sub(target_offset)
+                                .expect("backward jump target must be before instruction");
+                            OpArg::new(arg)
+                        } else {
+                            let arg = target_offset
+                                .checked_sub(offset_after)
+                                .expect("forward jump target must be after instruction");
+                            OpArg::new(arg)
+                        };
+                        recompile |= new_arg.instr_size() != old_arg_size;
+                        info.arg = new_arg;
+                    }
 
+                    let cache_count = info.cache_entries as usize;
                     let (extras, lo_arg) = info.arg.split();
+                    let loc_pair = (info.location, info.end_location);
                     locations.extend(core::iter::repeat_n(
-                        (info.location, info.end_location),
-                        info.arg.instr_size(),
+                        loc_pair,
+                        info.arg.instr_size() + cache_count,
                     ));
                     // Collect linetable locations with lineno_override support
                     let lt_loc = LineTableLocation {
@@ -345,17 +486,28 @@ impl CodeInfo {
                         end_col: info.end_location.character_offset.to_zero_indexed() as i32,
                     };
                     linetable_locations.extend(core::iter::repeat_n(lt_loc, info.arg.instr_size()));
+                    // CACHE entries inherit parent instruction's location
+                    if cache_count > 0 {
+                        linetable_locations.extend(core::iter::repeat_n(lt_loc, cache_count));
+                    }
                     instructions.extend(
                         extras
                             .map(|byte| CodeUnit::new(Instruction::ExtendedArg, byte))
                             .chain([CodeUnit { op, arg: lo_arg }]),
                     );
-                    current_offset += info.arg.instr_size() as u32;
+                    // Emit CACHE code units after the instruction (all zeroed)
+                    if cache_count > 0 {
+                        instructions.extend(core::iter::repeat_n(
+                            CodeUnit::new(Instruction::Cache, 0.into()),
+                            cache_count,
+                        ));
+                    }
+                    current_offset = offset_after;
                 }
                 next_block = block.next;
             }
 
-            if !recompile_extended_arg {
+            if !recompile {
                 break;
             }
 
@@ -374,6 +526,41 @@ impl CodeInfo {
         // Generate exception table before moving source_path
         let exceptiontable = generate_exception_table(&blocks, &block_to_index);
 
+        // Build localspluskinds with cell-local merging
+        let nlocals = varname_cache.len();
+        let ncells = cellvar_cache.len();
+        let nfrees = freevar_cache.len();
+        let numdropped = cellvar_cache
+            .iter()
+            .filter(|cv| varname_cache.contains(cv.as_str()))
+            .count();
+        let nlocalsplus = nlocals + ncells - numdropped + nfrees;
+        let mut localspluskinds = vec![0u8; nlocalsplus];
+        // Mark locals
+        for kind in localspluskinds.iter_mut().take(nlocals) {
+            *kind = CO_FAST_LOCAL;
+        }
+        // Mark cells (merged and non-merged)
+        for (i, cellvar) in cellvar_cache.iter().enumerate() {
+            let idx = cellfixedoffsets[i] as usize;
+            if varname_cache.contains(cellvar.as_str()) {
+                localspluskinds[idx] |= CO_FAST_CELL; // merged: LOCAL | CELL
+            } else {
+                localspluskinds[idx] = CO_FAST_CELL;
+            }
+        }
+        // Mark frees
+        for i in 0..nfrees {
+            let idx = cellfixedoffsets[ncells + i] as usize;
+            localspluskinds[idx] = CO_FAST_FREE;
+        }
+        // Apply CO_FAST_HIDDEN for inlined comprehension variables
+        for (name, &hidden) in &fast_hidden {
+            if hidden && let Some(idx) = varname_cache.get_index_of(name.as_str()) {
+                localspluskinds[idx] |= CO_FAST_HIDDEN;
+            }
+        }
+
         Ok(CodeObject {
             flags,
             posonlyarg_count,
@@ -392,44 +579,14 @@ impl CodeInfo {
             varnames: varname_cache.into_iter().collect(),
             cellvars: cellvar_cache.into_iter().collect(),
             freevars: freevar_cache.into_iter().collect(),
-            cell2arg,
+            localspluskinds: localspluskinds.into_boxed_slice(),
             linetable,
             exceptiontable,
         })
     }
 
-    fn cell2arg(&self) -> Option<Box<[i32]>> {
-        if self.metadata.cellvars.is_empty() {
-            return None;
-        }
-
-        let total_args = self.metadata.argcount
-            + self.metadata.kwonlyargcount
-            + self.flags.contains(CodeFlags::VARARGS) as u32
-            + self.flags.contains(CodeFlags::VARKEYWORDS) as u32;
-
-        let mut found_cellarg = false;
-        let cell2arg = self
-            .metadata
-            .cellvars
-            .iter()
-            .map(|var| {
-                self.metadata
-                    .varnames
-                    .get_index_of(var)
-                    // check that it's actually an arg
-                    .filter(|i| *i < total_args as usize)
-                    .map_or(-1, |i| {
-                        found_cellarg = true;
-                        i as i32
-                    })
-            })
-            .collect::<Box<[_]>>();
-
-        if found_cellarg { Some(cell2arg) } else { None }
-    }
-
     fn dce(&mut self) {
+        // Truncate instructions after terminal instructions within each block
         for block in &mut self.blocks {
             let mut last_instr = None;
             for (i, ins) in block.instructions.iter().enumerate() {
@@ -444,6 +601,340 @@ impl CodeInfo {
         }
     }
 
+    /// Clear blocks that are unreachable (not entry, not a jump target,
+    /// and only reachable via fall-through from a terminal block).
+    fn eliminate_unreachable_blocks(&mut self) {
+        let mut reachable = vec![false; self.blocks.len()];
+        reachable[0] = true;
+
+        // Fixpoint: only mark targets of already-reachable blocks
+        let mut changed = true;
+        while changed {
+            changed = false;
+            for i in 0..self.blocks.len() {
+                if !reachable[i] {
+                    continue;
+                }
+                // Mark jump targets and exception handlers
+                for ins in &self.blocks[i].instructions {
+                    if ins.target != BlockIdx::NULL && !reachable[ins.target.idx()] {
+                        reachable[ins.target.idx()] = true;
+                        changed = true;
+                    }
+                    if let Some(eh) = &ins.except_handler
+                        && !reachable[eh.handler_block.idx()]
+                    {
+                        reachable[eh.handler_block.idx()] = true;
+                        changed = true;
+                    }
+                }
+                // Mark fall-through
+                let next = self.blocks[i].next;
+                if next != BlockIdx::NULL
+                    && !reachable[next.idx()]
+                    && !self.blocks[i].instructions.last().is_some_and(|ins| {
+                        ins.instr.is_scope_exit() || ins.instr.is_unconditional_jump()
+                    })
+                {
+                    reachable[next.idx()] = true;
+                    changed = true;
+                }
+            }
+        }
+
+        for (i, block) in self.blocks.iter_mut().enumerate() {
+            if !reachable[i] {
+                block.instructions.clear();
+            }
+        }
+    }
+
+    /// Fold LOAD_CONST/LOAD_SMALL_INT + UNARY_NEGATIVE → LOAD_CONST (negative value)
+    fn fold_unary_negative(&mut self) {
+        for block in &mut self.blocks {
+            let mut i = 0;
+            while i + 1 < block.instructions.len() {
+                let next = &block.instructions[i + 1];
+                let Some(Instruction::UnaryNegative) = next.instr.real() else {
+                    i += 1;
+                    continue;
+                };
+                let curr = &block.instructions[i];
+                let value = match curr.instr.real() {
+                    Some(Instruction::LoadConst { .. }) => {
+                        let idx = u32::from(curr.arg) as usize;
+                        match self.metadata.consts.get_index(idx) {
+                            Some(ConstantData::Integer { value }) => {
+                                Some(ConstantData::Integer { value: -value })
+                            }
+                            Some(ConstantData::Float { value }) => {
+                                Some(ConstantData::Float { value: -value })
+                            }
+                            _ => None,
+                        }
+                    }
+                    Some(Instruction::LoadSmallInt { .. }) => {
+                        let v = u32::from(curr.arg) as i32;
+                        Some(ConstantData::Integer {
+                            value: BigInt::from(-v),
+                        })
+                    }
+                    _ => None,
+                };
+                if let Some(neg_const) = value {
+                    let (const_idx, _) = self.metadata.consts.insert_full(neg_const);
+                    // Replace LOAD_CONST/LOAD_SMALL_INT with new LOAD_CONST
+                    let load_location = block.instructions[i].location;
+                    block.instructions[i].instr = Instruction::LoadConst {
+                        consti: Arg::marker(),
+                    }
+                    .into();
+                    block.instructions[i].arg = OpArg::new(const_idx as u32);
+                    // Replace UNARY_NEGATIVE with NOP, inheriting the LOAD_CONST
+                    // location so that remove_nops can clean it up
+                    block.instructions[i + 1].instr = Instruction::Nop.into();
+                    block.instructions[i + 1].location = load_location;
+                    block.instructions[i + 1].end_location = block.instructions[i].end_location;
+                    // Skip the NOP, don't re-check
+                    i += 2;
+                } else {
+                    i += 1;
+                }
+            }
+        }
+    }
+
+    /// Constant folding: fold LOAD_CONST/LOAD_SMALL_INT + LOAD_CONST/LOAD_SMALL_INT + BINARY_OP
+    /// into a single LOAD_CONST when the result is computable at compile time.
+    /// = fold_binops_on_constants in CPython flowgraph.c
+    fn fold_binop_constants(&mut self) {
+        use oparg::BinaryOperator as BinOp;
+
+        for block in &mut self.blocks {
+            let mut i = 0;
+            while i + 2 < block.instructions.len() {
+                // Check pattern: LOAD_CONST/LOAD_SMALL_INT, LOAD_CONST/LOAD_SMALL_INT, BINARY_OP
+                let Some(Instruction::BinaryOp { .. }) = block.instructions[i + 2].instr.real()
+                else {
+                    i += 1;
+                    continue;
+                };
+
+                let op_raw = u32::from(block.instructions[i + 2].arg);
+                let Ok(op) = BinOp::try_from(op_raw) else {
+                    i += 1;
+                    continue;
+                };
+
+                let left = Self::get_const_value_from(&self.metadata, &block.instructions[i]);
+                let right = Self::get_const_value_from(&self.metadata, &block.instructions[i + 1]);
+
+                let (Some(left_val), Some(right_val)) = (left, right) else {
+                    i += 1;
+                    continue;
+                };
+
+                let result = Self::eval_binop(&left_val, &right_val, op);
+
+                if let Some(result_const) = result {
+                    // Check result size limit (CPython limits to 4096 bytes)
+                    if Self::const_too_big(&result_const) {
+                        i += 1;
+                        continue;
+                    }
+                    let (const_idx, _) = self.metadata.consts.insert_full(result_const);
+                    // Replace first instruction with LOAD_CONST result
+                    block.instructions[i].instr = Instruction::LoadConst {
+                        consti: Arg::marker(),
+                    }
+                    .into();
+                    block.instructions[i].arg = OpArg::new(const_idx as u32);
+                    // NOP out the second and third instructions
+                    let loc = block.instructions[i].location;
+                    let end_loc = block.instructions[i].end_location;
+                    block.instructions[i + 1].instr = Instruction::Nop.into();
+                    block.instructions[i + 1].location = loc;
+                    block.instructions[i + 1].end_location = end_loc;
+                    block.instructions[i + 2].instr = Instruction::Nop.into();
+                    block.instructions[i + 2].location = loc;
+                    block.instructions[i + 2].end_location = end_loc;
+                    // Don't advance - check if the result can be folded again
+                    // (e.g., 2 ** 31 - 1)
+                    i = i.saturating_sub(1); // re-check with previous instruction
+                } else {
+                    i += 1;
+                }
+            }
+        }
+    }
+
+    fn get_const_value_from(
+        metadata: &CodeUnitMetadata,
+        info: &InstructionInfo,
+    ) -> Option<ConstantData> {
+        match info.instr.real() {
+            Some(Instruction::LoadConst { .. }) => {
+                let idx = u32::from(info.arg) as usize;
+                metadata.consts.get_index(idx).cloned()
+            }
+            Some(Instruction::LoadSmallInt { .. }) => {
+                let v = u32::from(info.arg) as i32;
+                Some(ConstantData::Integer {
+                    value: BigInt::from(v),
+                })
+            }
+            _ => None,
+        }
+    }
+
+    fn eval_binop(
+        left: &ConstantData,
+        right: &ConstantData,
+        op: oparg::BinaryOperator,
+    ) -> Option<ConstantData> {
+        use oparg::BinaryOperator as BinOp;
+        match (left, right) {
+            (ConstantData::Integer { value: l }, ConstantData::Integer { value: r }) => {
+                let result = match op {
+                    BinOp::Add => l + r,
+                    BinOp::Subtract => l - r,
+                    BinOp::Multiply => {
+                        if !l.is_zero() && !r.is_zero() && l.bits() + r.bits() > MAX_INT_SIZE_BITS {
+                            return None;
+                        }
+                        l * r
+                    }
+                    BinOp::FloorDivide => {
+                        if r.is_zero() {
+                            return None;
+                        }
+                        // Python floor division: round towards negative infinity
+                        let (q, rem) = (l.clone() / r.clone(), l.clone() % r.clone());
+                        if !rem.is_zero() && (rem < BigInt::from(0)) != (*r < BigInt::from(0)) {
+                            q - 1
+                        } else {
+                            q
+                        }
+                    }
+                    BinOp::Remainder => {
+                        if r.is_zero() {
+                            return None;
+                        }
+                        // Python modulo: result has same sign as divisor
+                        let rem = l.clone() % r.clone();
+                        if !rem.is_zero() && (rem < BigInt::from(0)) != (*r < BigInt::from(0)) {
+                            rem + r
+                        } else {
+                            rem
+                        }
+                    }
+                    BinOp::Power => {
+                        let exp: u64 = r.try_into().ok()?;
+                        let exp_usize = usize::try_from(exp).ok()?;
+                        if !l.is_zero() && exp > 0 && l.bits() > MAX_INT_SIZE_BITS / exp {
+                            return None;
+                        }
+                        num_traits::pow::pow(l.clone(), exp_usize)
+                    }
+                    BinOp::Lshift => {
+                        let shift: u64 = r.try_into().ok()?;
+                        let shift_usize = usize::try_from(shift).ok()?;
+                        if shift > MAX_INT_SIZE_BITS
+                            || (!l.is_zero() && l.bits() > MAX_INT_SIZE_BITS - shift)
+                        {
+                            return None;
+                        }
+                        l << shift_usize
+                    }
+                    BinOp::Rshift => {
+                        let shift: u32 = r.try_into().ok()?;
+                        l >> (shift as usize)
+                    }
+                    BinOp::And => l & r,
+                    BinOp::Or => l | r,
+                    BinOp::Xor => l ^ r,
+                    _ => return None,
+                };
+                Some(ConstantData::Integer { value: result })
+            }
+            (ConstantData::Float { value: l }, ConstantData::Float { value: r }) => {
+                let result = match op {
+                    BinOp::Add => l + r,
+                    BinOp::Subtract => l - r,
+                    BinOp::Multiply => l * r,
+                    BinOp::TrueDivide => {
+                        if *r == 0.0 {
+                            return None;
+                        }
+                        l / r
+                    }
+                    BinOp::FloorDivide => {
+                        // Float floor division uses runtime semantics; skip folding
+                        return None;
+                    }
+                    BinOp::Remainder => {
+                        // Float modulo uses fmod() at runtime; Rust arithmetic differs
+                        return None;
+                    }
+                    BinOp::Power => l.powf(*r),
+                    _ => return None,
+                };
+                if !result.is_finite() {
+                    return None;
+                }
+                Some(ConstantData::Float { value: result })
+            }
+            // Int op Float or Float op Int → Float
+            (ConstantData::Integer { value: l }, ConstantData::Float { value: r }) => {
+                let l_f = l.to_f64()?;
+                Self::eval_binop(
+                    &ConstantData::Float { value: l_f },
+                    &ConstantData::Float { value: *r },
+                    op,
+                )
+            }
+            (ConstantData::Float { value: l }, ConstantData::Integer { value: r }) => {
+                let r_f = r.to_f64()?;
+                Self::eval_binop(
+                    &ConstantData::Float { value: *l },
+                    &ConstantData::Float { value: r_f },
+                    op,
+                )
+            }
+            // String concatenation and repetition
+            (ConstantData::Str { value: l }, ConstantData::Str { value: r })
+                if matches!(op, BinOp::Add) =>
+            {
+                let mut result = l.to_string();
+                result.push_str(&r.to_string());
+                Some(ConstantData::Str {
+                    value: result.into(),
+                })
+            }
+            (ConstantData::Str { value: s }, ConstantData::Integer { value: n })
+                if matches!(op, BinOp::Multiply) =>
+            {
+                let n: usize = n.try_into().ok()?;
+                if n > 4096 {
+                    return None;
+                }
+                let result = s.to_string().repeat(n);
+                Some(ConstantData::Str {
+                    value: result.into(),
+                })
+            }
+            _ => None,
+        }
+    }
+
+    fn const_too_big(c: &ConstantData) -> bool {
+        match c {
+            ConstantData::Integer { value } => value.bits() > 4096 * 8,
+            ConstantData::Str { value } => value.len() > 4096,
+            _ => false,
+        }
+    }
+
     /// Constant folding: fold LOAD_CONST/LOAD_SMALL_INT + BUILD_TUPLE into LOAD_CONST tuple
     /// fold_tuple_of_constants
     fn fold_tuple_constants(&mut self) {
@@ -457,8 +948,21 @@ impl CodeInfo {
                     continue;
                 };
 
-                let tuple_size = instr.arg.0 as usize;
-                if tuple_size == 0 || i < tuple_size {
+                let tuple_size = u32::from(instr.arg) as usize;
+                if tuple_size == 0 {
+                    // BUILD_TUPLE 0 → LOAD_CONST ()
+                    let (const_idx, _) = self.metadata.consts.insert_full(ConstantData::Tuple {
+                        elements: Vec::new(),
+                    });
+                    block.instructions[i].instr = Instruction::LoadConst {
+                        consti: Arg::marker(),
+                    }
+                    .into();
+                    block.instructions[i].arg = OpArg::new(const_idx as u32);
+                    i += 1;
+                    continue;
+                }
+                if i < tuple_size {
                     i += 1;
                     continue;
                 }
@@ -472,7 +976,7 @@ impl CodeInfo {
                     let load_instr = &block.instructions[j];
                     match load_instr.instr.real() {
                         Some(Instruction::LoadConst { .. }) => {
-                            let const_idx = load_instr.arg.0 as usize;
+                            let const_idx = u32::from(load_instr.arg) as usize;
                             if let Some(constant) =
                                 self.metadata.consts.get_index(const_idx).cloned()
                             {
@@ -484,7 +988,7 @@ impl CodeInfo {
                         }
                         Some(Instruction::LoadSmallInt { .. }) => {
                             // arg is the i32 value stored as u32 (two's complement)
-                            let value = load_instr.arg.0 as i32;
+                            let value = u32::from(load_instr.arg) as i32;
                             elements.push(ConstantData::Integer {
                                 value: BigInt::from(value),
                             });
@@ -509,83 +1013,443 @@ impl CodeInfo {
                 let tuple_const = ConstantData::Tuple { elements };
                 let (const_idx, _) = self.metadata.consts.insert_full(tuple_const);
 
-                // Replace preceding LOAD instructions with NOP
+                // Replace preceding LOAD instructions with NOP at the
+                // BUILD_TUPLE location so remove_nops() can eliminate them.
+                let folded_loc = block.instructions[i].location;
                 for j in start_idx..i {
                     block.instructions[j].instr = Instruction::Nop.into();
+                    block.instructions[j].location = folded_loc;
                 }
 
                 // Replace BUILD_TUPLE with LOAD_CONST
-                block.instructions[i].instr = Instruction::LoadConst { idx: Arg::marker() }.into();
-                block.instructions[i].arg = OpArg(const_idx as u32);
+                block.instructions[i].instr = Instruction::LoadConst {
+                    consti: Arg::marker(),
+                }
+                .into();
+                block.instructions[i].arg = OpArg::new(const_idx as u32);
 
                 i += 1;
             }
         }
     }
 
-    /// Peephole optimization: combine consecutive instructions into super-instructions
-    fn peephole_optimize(&mut self) {
+    /// Fold constant list literals: LOAD_CONST* + BUILD_LIST N →
+    /// BUILD_LIST 0 + LOAD_CONST (tuple) + LIST_EXTEND 1
+    fn fold_list_constants(&mut self) {
         for block in &mut self.blocks {
             let mut i = 0;
-            while i + 1 < block.instructions.len() {
-                let combined = {
-                    let curr = &block.instructions[i];
-                    let next = &block.instructions[i + 1];
+            while i < block.instructions.len() {
+                let instr = &block.instructions[i];
+                let Some(Instruction::BuildList { .. }) = instr.instr.real() else {
+                    i += 1;
+                    continue;
+                };
 
-                    // Only combine if both are real instructions (not pseudo)
-                    let (Some(curr_instr), Some(next_instr)) =
-                        (curr.instr.real(), next.instr.real())
-                    else {
-                        i += 1;
-                        continue;
-                    };
+                let list_size = u32::from(instr.arg) as usize;
+                if list_size == 0 || i < list_size {
+                    i += 1;
+                    continue;
+                }
 
-                    match (curr_instr, next_instr) {
-                        // LoadFast + LoadFast -> LoadFastLoadFast (if both indices < 16)
-                        (Instruction::LoadFast(_), Instruction::LoadFast(_)) => {
-                            let idx1 = curr.arg.0;
-                            let idx2 = next.arg.0;
-                            if idx1 < 16 && idx2 < 16 {
-                                let packed = (idx1 << 4) | idx2;
-                                Some((
-                                    Instruction::LoadFastLoadFast { arg: Arg::marker() },
-                                    OpArg(packed),
-                                ))
+                let start_idx = i - list_size;
+                let mut elements = Vec::with_capacity(list_size);
+                let mut all_const = true;
+
+                for j in start_idx..i {
+                    let load_instr = &block.instructions[j];
+                    match load_instr.instr.real() {
+                        Some(Instruction::LoadConst { .. }) => {
+                            let const_idx = u32::from(load_instr.arg) as usize;
+                            if let Some(constant) =
+                                self.metadata.consts.get_index(const_idx).cloned()
+                            {
+                                elements.push(constant);
                             } else {
-                                None
+                                all_const = false;
+                                break;
                             }
                         }
-                        // StoreFast + StoreFast -> StoreFastStoreFast (if both indices < 16)
-                        (Instruction::StoreFast(_), Instruction::StoreFast(_)) => {
-                            let idx1 = curr.arg.0;
-                            let idx2 = next.arg.0;
-                            if idx1 < 16 && idx2 < 16 {
-                                let packed = (idx1 << 4) | idx2;
-                                Some((
-                                    Instruction::StoreFastStoreFast { arg: Arg::marker() },
-                                    OpArg(packed),
-                                ))
-                            } else {
-                                None
-                            }
+                        Some(Instruction::LoadSmallInt { .. }) => {
+                            let value = u32::from(load_instr.arg) as i32;
+                            elements.push(ConstantData::Integer {
+                                value: BigInt::from(value),
+                            });
+                        }
+                        _ => {
+                            all_const = false;
+                            break;
                         }
-                        _ => None,
                     }
-                };
+                }
 
-                if let Some((new_instr, new_arg)) = combined {
-                    // Combine: keep first instruction's location, replace with combined instruction
-                    block.instructions[i].instr = new_instr.into();
-                    block.instructions[i].arg = new_arg;
-                    // Remove the second instruction
-                    block.instructions.remove(i + 1);
-                    // Don't increment i - check if we can combine again with the next instruction
-                } else {
+                if !all_const || list_size < MIN_CONST_SEQUENCE_SIZE {
                     i += 1;
+                    continue;
                 }
-            }
-        }
-    }
+
+                let tuple_const = ConstantData::Tuple { elements };
+                let (const_idx, _) = self.metadata.consts.insert_full(tuple_const);
+
+                let folded_loc = block.instructions[i].location;
+                let end_loc = block.instructions[i].end_location;
+                let eh = block.instructions[i].except_handler;
+
+                // slot[start_idx] → BUILD_LIST 0
+                block.instructions[start_idx].instr = Instruction::BuildList {
+                    count: Arg::marker(),
+                }
+                .into();
+                block.instructions[start_idx].arg = OpArg::new(0);
+                block.instructions[start_idx].location = folded_loc;
+                block.instructions[start_idx].end_location = end_loc;
+                block.instructions[start_idx].except_handler = eh;
+
+                // slot[start_idx+1] → LOAD_CONST (tuple)
+                block.instructions[start_idx + 1].instr = Instruction::LoadConst {
+                    consti: Arg::marker(),
+                }
+                .into();
+                block.instructions[start_idx + 1].arg = OpArg::new(const_idx as u32);
+                block.instructions[start_idx + 1].location = folded_loc;
+                block.instructions[start_idx + 1].end_location = end_loc;
+                block.instructions[start_idx + 1].except_handler = eh;
+
+                // NOP the rest
+                for j in (start_idx + 2)..i {
+                    block.instructions[j].instr = Instruction::Nop.into();
+                    block.instructions[j].location = folded_loc;
+                }
+
+                // slot[i] (was BUILD_LIST) → LIST_EXTEND 1
+                block.instructions[i].instr = Instruction::ListExtend { i: Arg::marker() }.into();
+                block.instructions[i].arg = OpArg::new(1);
+
+                i += 1;
+            }
+        }
+    }
+
+    /// Convert constant list construction before GET_ITER to just LOAD_CONST tuple.
+    /// BUILD_LIST 0 + LOAD_CONST (tuple) + LIST_EXTEND 1 + GET_ITER
+    /// → LOAD_CONST (tuple) + GET_ITER
+    fn fold_const_iterable_for_iter(&mut self) {
+        for block in &mut self.blocks {
+            let mut i = 0;
+            while i + 1 < block.instructions.len() {
+                let is_build = matches!(
+                    block.instructions[i].instr.real(),
+                    Some(Instruction::BuildList { .. })
+                ) && u32::from(block.instructions[i].arg) == 0;
+
+                let is_const = matches!(
+                    block
+                        .instructions
+                        .get(i + 1)
+                        .and_then(|instr| instr.instr.real()),
+                    Some(Instruction::LoadConst { .. })
+                );
+
+                let is_extend = matches!(
+                    block
+                        .instructions
+                        .get(i + 2)
+                        .and_then(|instr| instr.instr.real()),
+                    Some(Instruction::ListExtend { .. })
+                ) && block
+                    .instructions
+                    .get(i + 2)
+                    .is_some_and(|instr| u32::from(instr.arg) == 1);
+
+                let is_iter = matches!(
+                    block
+                        .instructions
+                        .get(i + 3)
+                        .and_then(|instr| instr.instr.real()),
+                    Some(Instruction::GetIter)
+                );
+
+                if is_build && is_const && is_extend && is_iter {
+                    // Replace: BUILD_X 0 → NOP, keep LOAD_CONST, LIST_EXTEND → NOP
+                    let loc = block.instructions[i].location;
+                    block.instructions[i].instr = Instruction::Nop.into();
+                    block.instructions[i].location = loc;
+                    block.instructions[i + 2].instr = Instruction::Nop.into();
+                    block.instructions[i + 2].location = loc;
+                    i += 4;
+                } else if matches!(
+                    block.instructions[i].instr.real(),
+                    Some(Instruction::BuildList { .. })
+                ) && matches!(
+                    block.instructions[i + 1].instr.real(),
+                    Some(Instruction::GetIter)
+                ) {
+                    let seq_size = u32::from(block.instructions[i].arg) as usize;
+
+                    if seq_size != 0 && i >= seq_size {
+                        let start_idx = i - seq_size;
+                        let mut elements = Vec::with_capacity(seq_size);
+                        let mut all_const = true;
+
+                        for j in start_idx..i {
+                            match Self::get_const_value_from(&self.metadata, &block.instructions[j])
+                            {
+                                Some(constant) => elements.push(constant),
+                                None => {
+                                    all_const = false;
+                                    break;
+                                }
+                            }
+                        }
+
+                        if all_const {
+                            let const_data = ConstantData::Tuple { elements };
+                            let (const_idx, _) = self.metadata.consts.insert_full(const_data);
+                            let folded_loc = block.instructions[i].location;
+
+                            for j in start_idx..i {
+                                block.instructions[j].instr = Instruction::Nop.into();
+                                block.instructions[j].location = folded_loc;
+                            }
+
+                            block.instructions[i].instr = Instruction::LoadConst {
+                                consti: Arg::marker(),
+                            }
+                            .into();
+                            block.instructions[i].arg = OpArg::new(const_idx as u32);
+                            i += 2;
+                            continue;
+                        }
+                    }
+
+                    block.instructions[i].instr = Instruction::BuildTuple {
+                        count: Arg::marker(),
+                    }
+                    .into();
+                    i += 2;
+                } else {
+                    i += 1;
+                }
+            }
+        }
+    }
+
+    /// Fold constant set literals: LOAD_CONST* + BUILD_SET N →
+    /// BUILD_SET 0 + LOAD_CONST (frozenset-as-tuple) + SET_UPDATE 1
+    fn fold_set_constants(&mut self) {
+        for block in &mut self.blocks {
+            let mut i = 0;
+            while i < block.instructions.len() {
+                let instr = &block.instructions[i];
+                let Some(Instruction::BuildSet { .. }) = instr.instr.real() else {
+                    i += 1;
+                    continue;
+                };
+
+                let set_size = u32::from(instr.arg) as usize;
+                if set_size < 3 || i < set_size {
+                    i += 1;
+                    continue;
+                }
+
+                let start_idx = i - set_size;
+                let mut elements = Vec::with_capacity(set_size);
+                let mut all_const = true;
+
+                for j in start_idx..i {
+                    let load_instr = &block.instructions[j];
+                    match load_instr.instr.real() {
+                        Some(Instruction::LoadConst { .. }) => {
+                            let const_idx = u32::from(load_instr.arg) as usize;
+                            if let Some(constant) =
+                                self.metadata.consts.get_index(const_idx).cloned()
+                            {
+                                elements.push(constant);
+                            } else {
+                                all_const = false;
+                                break;
+                            }
+                        }
+                        Some(Instruction::LoadSmallInt { .. }) => {
+                            let value = u32::from(load_instr.arg) as i32;
+                            elements.push(ConstantData::Integer {
+                                value: BigInt::from(value),
+                            });
+                        }
+                        _ => {
+                            all_const = false;
+                            break;
+                        }
+                    }
+                }
+
+                if !all_const {
+                    i += 1;
+                    continue;
+                }
+
+                // Use FrozenSet constant (stored as Tuple for now)
+                let const_data = ConstantData::Tuple { elements };
+                let (const_idx, _) = self.metadata.consts.insert_full(const_data);
+
+                let folded_loc = block.instructions[i].location;
+                let end_loc = block.instructions[i].end_location;
+                let eh = block.instructions[i].except_handler;
+
+                block.instructions[start_idx].instr = Instruction::BuildSet {
+                    count: Arg::marker(),
+                }
+                .into();
+                block.instructions[start_idx].arg = OpArg::new(0);
+                block.instructions[start_idx].location = folded_loc;
+                block.instructions[start_idx].end_location = end_loc;
+                block.instructions[start_idx].except_handler = eh;
+
+                block.instructions[start_idx + 1].instr = Instruction::LoadConst {
+                    consti: Arg::marker(),
+                }
+                .into();
+                block.instructions[start_idx + 1].arg = OpArg::new(const_idx as u32);
+                block.instructions[start_idx + 1].location = folded_loc;
+                block.instructions[start_idx + 1].end_location = end_loc;
+                block.instructions[start_idx + 1].except_handler = eh;
+
+                for j in (start_idx + 2)..i {
+                    block.instructions[j].instr = Instruction::Nop.into();
+                    block.instructions[j].location = folded_loc;
+                }
+
+                block.instructions[i].instr = Instruction::SetUpdate { i: Arg::marker() }.into();
+                block.instructions[i].arg = OpArg::new(1);
+
+                i += 1;
+            }
+        }
+    }
+
+    /// Peephole optimization: combine consecutive instructions into super-instructions
+    fn peephole_optimize(&mut self) {
+        for block in &mut self.blocks {
+            let mut i = 0;
+            while i + 1 < block.instructions.len() {
+                let combined = {
+                    let curr = &block.instructions[i];
+                    let next = &block.instructions[i + 1];
+
+                    // Only combine if both are real instructions (not pseudo)
+                    let (Some(curr_instr), Some(next_instr)) =
+                        (curr.instr.real(), next.instr.real())
+                    else {
+                        i += 1;
+                        continue;
+                    };
+
+                    match (curr_instr, next_instr) {
+                        // LoadFast + LoadFast -> LoadFastLoadFast (if both indices < 16)
+                        (Instruction::LoadFast { .. }, Instruction::LoadFast { .. }) => {
+                            let idx1 = u32::from(curr.arg);
+                            let idx2 = u32::from(next.arg);
+                            if idx1 < 16 && idx2 < 16 {
+                                let packed = (idx1 << 4) | idx2;
+                                Some((
+                                    Instruction::LoadFastLoadFast {
+                                        var_nums: Arg::marker(),
+                                    },
+                                    OpArg::new(packed),
+                                ))
+                            } else {
+                                None
+                            }
+                        }
+                        // StoreFast + StoreFast -> StoreFastStoreFast (if both indices < 16)
+                        (Instruction::StoreFast { .. }, Instruction::StoreFast { .. }) => {
+                            let idx1 = u32::from(curr.arg);
+                            let idx2 = u32::from(next.arg);
+                            if idx1 < 16 && idx2 < 16 {
+                                let packed = (idx1 << 4) | idx2;
+                                Some((
+                                    Instruction::StoreFastStoreFast {
+                                        var_nums: Arg::marker(),
+                                    },
+                                    OpArg::new(packed),
+                                ))
+                            } else {
+                                None
+                            }
+                        }
+                        // Note: StoreFast + LoadFast → StoreFastLoadFast is done in a
+                        // separate pass AFTER optimize_load_fast_borrow, because CPython
+                        // only combines STORE_FAST + LOAD_FAST (not LOAD_FAST_BORROW).
+                        (Instruction::LoadConst { consti }, Instruction::ToBool) => {
+                            let consti = consti.get(curr.arg);
+                            let constant = &self.metadata.consts[consti.as_usize()];
+                            if let ConstantData::Boolean { .. } = constant {
+                                Some((curr_instr, OpArg::from(consti.as_u32())))
+                            } else {
+                                None
+                            }
+                        }
+                        (Instruction::LoadConst { consti }, Instruction::UnaryNot) => {
+                            let constant = &self.metadata.consts[consti.get(curr.arg).as_usize()];
+                            match constant {
+                                ConstantData::Boolean { value } => {
+                                    let (const_idx, _) = self
+                                        .metadata
+                                        .consts
+                                        .insert_full(ConstantData::Boolean { value: !value });
+                                    Some((
+                                        (Instruction::LoadConst {
+                                            consti: Arg::marker(),
+                                        }),
+                                        OpArg::new(const_idx as u32),
+                                    ))
+                                }
+                                _ => None,
+                            }
+                        }
+                        _ => None,
+                    }
+                };
+
+                if let Some((new_instr, new_arg)) = combined {
+                    // Combine: keep first instruction's location, replace with combined instruction
+                    block.instructions[i].instr = new_instr.into();
+                    block.instructions[i].arg = new_arg;
+                    // Remove the second instruction
+                    block.instructions.remove(i + 1);
+                    // Don't increment i - check if we can combine again with the next instruction
+                } else {
+                    i += 1;
+                }
+            }
+        }
+    }
+
+    /// LOAD_GLOBAL <even> + PUSH_NULL -> LOAD_GLOBAL <odd>, NOP
+    fn optimize_load_global_push_null(&mut self) {
+        for block in &mut self.blocks {
+            let mut i = 0;
+            while i + 1 < block.instructions.len() {
+                let curr = &block.instructions[i];
+                let next = &block.instructions[i + 1];
+
+                let (Some(Instruction::LoadGlobal { .. }), Some(Instruction::PushNull)) =
+                    (curr.instr.real(), next.instr.real())
+                else {
+                    i += 1;
+                    continue;
+                };
+
+                let oparg = u32::from(block.instructions[i].arg);
+                if (oparg & 1) != 0 {
+                    i += 1;
+                    continue;
+                }
+
+                block.instructions[i].arg = OpArg::new(oparg | 1);
+                block.instructions.remove(i + 1);
+            }
+        }
+    }
 
     /// Convert LOAD_CONST for small integers to LOAD_SMALL_INT
     /// maybe_instr_make_load_smallint
@@ -598,7 +1462,7 @@ impl CodeInfo {
                 };
 
                 // Get the constant value
-                let const_idx = instr.arg.0 as usize;
+                let const_idx = u32::from(instr.arg) as usize;
                 let Some(constant) = self.metadata.consts.get_index(const_idx) else {
                     continue;
                 };
@@ -608,12 +1472,12 @@ impl CodeInfo {
                     continue;
                 };
 
-                // Check if it's in small int range: -5 to 256 (_PY_IS_SMALL_INT)
-                if let Some(small) = value.to_i32().filter(|v| (-5..=256).contains(v)) {
+                // LOAD_SMALL_INT oparg is unsigned, so only 0..=255 can be encoded
+                if let Some(small) = value.to_i32().filter(|v| (0..=255).contains(v)) {
                     // Convert LOAD_CONST to LOAD_SMALL_INT
-                    instr.instr = Instruction::LoadSmallInt { idx: Arg::marker() }.into();
+                    instr.instr = Instruction::LoadSmallInt { i: Arg::marker() }.into();
                     // The arg is the i32 value stored as u32 (two's complement)
-                    instr.arg = OpArg(small as u32);
+                    instr.arg = OpArg::new(small as u32);
                 }
             }
         }
@@ -635,7 +1499,7 @@ impl CodeInfo {
         for block in &self.blocks {
             for instr in &block.instructions {
                 if let Some(Instruction::LoadConst { .. }) = instr.instr.real() {
-                    let idx = instr.arg.0 as usize;
+                    let idx = u32::from(instr.arg) as usize;
                     if idx < nconsts {
                         used[idx] = true;
                     }
@@ -672,33 +1536,78 @@ impl CodeInfo {
         for block in &mut self.blocks {
             for instr in &mut block.instructions {
                 if let Some(Instruction::LoadConst { .. }) = instr.instr.real() {
-                    let old_idx = instr.arg.0 as usize;
+                    let old_idx = u32::from(instr.arg) as usize;
                     if old_idx < nconsts {
-                        instr.arg = OpArg(old_to_new[old_idx] as u32);
+                        instr.arg = OpArg::new(old_to_new[old_idx] as u32);
                     }
                 }
             }
         }
     }
 
-    /// Remove NOP instructions from all blocks
+    /// Remove NOP instructions from all blocks, but keep NOPs that introduce
+    /// a new source line (they serve as line markers for monitoring LINE events).
     fn remove_nops(&mut self) {
         for block in &mut self.blocks {
-            block
-                .instructions
-                .retain(|ins| !matches!(ins.instr.real(), Some(Instruction::Nop)));
+            let mut prev_line = None;
+            block.instructions.retain(|ins| {
+                if matches!(ins.instr.real(), Some(Instruction::Nop)) {
+                    let line = ins.location.line;
+                    if prev_line == Some(line) {
+                        return false;
+                    }
+                }
+                prev_line = Some(ins.location.line);
+                true
+            });
         }
     }
 
     /// Optimize LOAD_FAST to LOAD_FAST_BORROW where safe.
     ///
-    /// A LOAD_FAST can be converted to LOAD_FAST_BORROW if its value is
-    /// consumed within the same basic block (not passed to another block).
-    /// This is a reference counting optimization in CPython; in RustPython
-    /// we implement it for bytecode compatibility.
-    fn optimize_load_fast_borrow(&mut self) {
-        use rustpython_compiler_core::bytecode::InstructionMetadata;
+    /// insert_superinstructions (flowgraph.c): Combine STORE_FAST + LOAD_FAST →
+    /// STORE_FAST_LOAD_FAST. Currently disabled pending VM stack null investigation.
+    #[allow(dead_code)]
+    fn combine_store_fast_load_fast(&mut self) {
+        for block in &mut self.blocks {
+            let mut i = 0;
+            while i + 1 < block.instructions.len() {
+                let curr = &block.instructions[i];
+                let next = &block.instructions[i + 1];
+                let (Some(Instruction::StoreFast { .. }), Some(Instruction::LoadFast { .. })) =
+                    (curr.instr.real(), next.instr.real())
+                else {
+                    i += 1;
+                    continue;
+                };
+                // Skip if instructions are on different lines (matching make_super_instruction)
+                let line1 = curr.location.line;
+                let line2 = next.location.line;
+                if line1 != line2 {
+                    i += 1;
+                    continue;
+                }
+                let idx1 = u32::from(curr.arg);
+                let idx2 = u32::from(next.arg);
+                if idx1 < 16 && idx2 < 16 {
+                    let packed = (idx1 << 4) | idx2;
+                    block.instructions[i].instr = Instruction::StoreFastLoadFast {
+                        var_nums: Arg::marker(),
+                    }
+                    .into();
+                    block.instructions[i].arg = OpArg::new(packed);
+                    // Replace second instruction with NOP (CPython: INSTR_SET_OP0(inst2, NOP))
+                    block.instructions[i + 1].instr = Instruction::Nop.into();
+                    block.instructions[i + 1].arg = OpArg::new(0);
+                    i += 2; // skip the NOP
+                } else {
+                    i += 1;
+                }
+            }
+        }
+    }
 
+    fn optimize_load_fast_borrow(&mut self) {
         // NOT_LOCAL marker: instruction didn't come from a LOAD_FAST
         const NOT_LOCAL: usize = usize::MAX;
 
@@ -715,7 +1624,7 @@ impl CodeInfo {
             // (or NOT_LOCAL if not from LOAD_FAST/LOAD_FAST_LOAD_FAST).
             //
             // CPython (flowgraph.c optimize_load_fast) pre-fills the stack with
-            // dummy refs for values inherited from predecessor blocks.  We take
+            // dummy refs for values inherited from predecessor blocks. We take
             // the simpler approach of aborting the optimisation for the whole
             // block on stack underflow.
             let mut stack: Vec<usize> = Vec::new();
@@ -726,62 +1635,8 @@ impl CodeInfo {
                     continue;
                 };
 
-                // Decompose into (pops, pushes).
-                //
-                // stack_effect() returns pushes − pops, which is ambiguous for
-                // instructions that both pop and push (e.g. BinaryOp: effect=-1
-                // is pop 2 push 1, not pop 1 push 0).  We list those explicitly;
-                // the fallback under-pops and under-pushes, which is conservative
-                // (may miss optimisation opportunities but never miscompiles).
-                let effect = instr.stack_effect(info.arg);
-                let (pops, pushes) = match instr {
-                    // --- pop 2, push 1 ---
-                    Instruction::BinaryOp { .. }
-                    | Instruction::BinaryOpInplaceAddUnicode
-                    | Instruction::CompareOp { .. }
-                    | Instruction::ContainsOp(_)
-                    | Instruction::IsOp(_)
-                    | Instruction::ImportName { .. }
-                    | Instruction::FormatWithSpec => (2, 1),
-
-                    // --- pop 1, push 1 ---
-                    Instruction::UnaryInvert
-                    | Instruction::UnaryNegative
-                    | Instruction::UnaryNot
-                    | Instruction::ToBool
-                    | Instruction::GetIter
-                    | Instruction::GetAIter
-                    | Instruction::FormatSimple
-                    | Instruction::LoadFromDictOrDeref(_)
-                    | Instruction::LoadFromDictOrGlobals(_) => (1, 1),
-
-                    // LoadAttr: pop receiver, push attr.
-                    // method=true: push (method, self_or_null) → (1, 2)
-                    Instruction::LoadAttr { idx } => {
-                        let (_, is_method) =
-                            rustpython_compiler_core::bytecode::decode_load_attr_arg(
-                                idx.get(info.arg),
-                            );
-                        if is_method { (1, 2) } else { (1, 1) }
-                    }
-
-                    // --- pop 3, push 1 ---
-                    Instruction::BinarySlice => (3, 1),
-
-                    // --- variable pops, push 1 ---
-                    Instruction::Call { nargs } => (nargs.get(info.arg) as usize + 2, 1),
-                    Instruction::CallKw { nargs } => (nargs.get(info.arg) as usize + 3, 1),
-
-                    // --- conservative fallback ---
-                    // under-pops (≤ actual pops) and under-pushes (≤ actual pushes),
-                    // which keeps extra refs on the stack → marks them unconsumed →
-                    // prevents optimisation. Safe but may miss opportunities.
-                    _ => {
-                        let p = if effect < 0 { (-effect) as usize } else { 0 };
-                        let q = if effect > 0 { effect as usize } else { 0 };
-                        (p, q)
-                    }
-                };
+                let stack_effect_info = instr.stack_effect_info(info.arg.into());
+                let (pushes, pops) = (stack_effect_info.pushed(), stack_effect_info.popped());
 
                 // Pop values from stack
                 for _ in 0..pops {
@@ -798,7 +1653,7 @@ impl CodeInfo {
 
                 // Push values to stack with source instruction index
                 let source = match instr {
-                    Instruction::LoadFast(_) | Instruction::LoadFastLoadFast { .. } => i,
+                    Instruction::LoadFast { .. } | Instruction::LoadFastLoadFast { .. } => i,
                     _ => NOT_LOCAL,
                 };
                 for _ in 0..pushes {
@@ -826,12 +1681,17 @@ impl CodeInfo {
                     continue;
                 };
                 match instr {
-                    Instruction::LoadFast(_) => {
-                        info.instr = Instruction::LoadFastBorrow(Arg::marker()).into();
+                    Instruction::LoadFast { .. } => {
+                        info.instr = Instruction::LoadFastBorrow {
+                            var_num: Arg::marker(),
+                        }
+                        .into();
                     }
                     Instruction::LoadFastLoadFast { .. } => {
-                        info.instr =
-                            Instruction::LoadFastBorrowLoadFastBorrow { arg: Arg::marker() }.into();
+                        info.instr = Instruction::LoadFastBorrowLoadFastBorrow {
+                            var_nums: Arg::marker(),
+                        }
+                        .into();
                     }
                     _ => {}
                 }
@@ -839,25 +1699,13 @@ impl CodeInfo {
         }
     }
 
-    fn max_stackdepth(&self) -> crate::InternalResult<u32> {
+    fn max_stackdepth(&mut self) -> crate::InternalResult<u32> {
         let mut maxdepth = 0u32;
         let mut stack = Vec::with_capacity(self.blocks.len());
         let mut start_depths = vec![u32::MAX; self.blocks.len()];
-        start_depths[0] = 0;
-        stack.push(BlockIdx(0));
+        stackdepth_push(&mut stack, &mut start_depths, BlockIdx(0), 0);
         const DEBUG: bool = false;
-        // 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 {
@@ -866,12 +1714,12 @@ impl CodeInfo {
             let block = &self.blocks[block_idx];
             for ins in &block.instructions {
                 let instr = &ins.instr;
-                let effect = instr.stack_effect(ins.arg);
+                let effect = instr.stack_effect(ins.arg.into());
                 if DEBUG {
                     let display_arg = if ins.target == BlockIdx::NULL {
                         ins.arg
                     } else {
-                        OpArg(ins.target.0)
+                        OpArg::new(ins.target.0)
                     };
                     let instr_display = instr.display(display_arg, self);
                     eprint!("{instr_display}: {depth} {effect:+} => ");
@@ -891,47 +1739,40 @@ impl CodeInfo {
                 }
                 // Process target blocks for branching instructions
                 if ins.target != BlockIdx::NULL {
-                    // Both jump and non-jump paths have the same stack effect
-                    let target_depth = depth.checked_add_signed(effect).ok_or({
-                        if effect < 0 {
-                            InternalError::StackUnderflow
-                        } else {
-                            InternalError::StackOverflow
+                    if instr.is_block_push() {
+                        // SETUP_* pseudo ops: target is a handler block.
+                        // Handler entry depth uses the jump-path stack effect:
+                        //   SETUP_FINALLY:  +1  (pushes exc)
+                        //   SETUP_CLEANUP:  +2  (pushes lasti + exc)
+                        //   SETUP_WITH:     +1  (pops __enter__ result, pushes lasti + exc)
+                        let handler_effect: u32 = match instr.pseudo() {
+                            Some(PseudoInstruction::SetupCleanup { .. }) => 2,
+                            _ => 1, // SetupFinally and SetupWith
+                        };
+                        let handler_depth = depth + handler_effect;
+                        if handler_depth > maxdepth {
+                            maxdepth = handler_depth;
                         }
-                    })?;
-                    if target_depth > maxdepth {
-                        maxdepth = target_depth
-                    }
-                    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, ins.target, handler_depth);
+                    } else {
+                        // SEND jumps to END_SEND with receiver still on stack.
+                        // END_SEND performs the receiver pop.
+                        let jump_effect = match instr.real() {
+                            Some(Instruction::Send { .. }) => 0i32,
+                            _ => effect,
+                        };
+                        let target_depth = depth.checked_add_signed(jump_effect).ok_or({
+                            if jump_effect < 0 {
+                                InternalError::StackUnderflow
+                            } else {
+                                InternalError::StackOverflow
+                            }
+                        })?;
+                        if target_depth > maxdepth {
+                            maxdepth = target_depth
+                        }
+                        stackdepth_push(&mut stack, &mut start_depths, ins.target, target_depth);
                     }
-                    stackdepth_push(
-                        &mut stack,
-                        &mut start_depths,
-                        handler.handler_block,
-                        handler_depth,
-                    );
                 }
                 depth = new_depth;
                 if instr.is_scope_exit() || instr.is_unconditional_jump() {
@@ -946,27 +1787,61 @@ impl CodeInfo {
         if DEBUG {
             eprintln!("DONE: {maxdepth}");
         }
+
+        for (block, &start_depth) in self.blocks.iter_mut().zip(&start_depths) {
+            block.start_depth = (start_depth != u32::MAX).then_some(start_depth);
+        }
+
+        // Fix up handler stack_depth in ExceptHandlerInfo using start_depths
+        // computed above: depth = start_depth - 1 - preserve_lasti
+        for block in self.blocks.iter_mut() {
+            for ins in &mut block.instructions {
+                if let Some(ref mut handler) = ins.except_handler {
+                    let h_start = start_depths[handler.handler_block.idx()];
+                    if h_start != u32::MAX {
+                        let adjustment = 1 + handler.preserve_lasti as u32;
+                        debug_assert!(
+                            h_start >= adjustment,
+                            "handler start depth {h_start} too shallow for adjustment {adjustment}"
+                        );
+                        handler.stack_depth = h_start.saturating_sub(adjustment);
+                    }
+                }
+            }
+        }
+
         Ok(maxdepth)
     }
 }
 
 impl InstrDisplayContext for CodeInfo {
     type Constant = ConstantData;
-    fn get_constant(&self, i: usize) -> &ConstantData {
-        &self.metadata.consts[i]
+
+    fn get_constant(&self, consti: oparg::ConstIdx) -> &ConstantData {
+        &self.metadata.consts[consti.as_usize()]
     }
+
     fn get_name(&self, i: usize) -> &str {
         self.metadata.names[i].as_ref()
     }
-    fn get_varname(&self, i: usize) -> &str {
-        self.metadata.varnames[i].as_ref()
+
+    fn get_varname(&self, var_num: oparg::VarNum) -> &str {
+        self.metadata.varnames[var_num.as_usize()].as_ref()
     }
-    fn get_cell_name(&self, i: usize) -> &str {
-        self.metadata
-            .cellvars
-            .get_index(i)
-            .unwrap_or_else(|| &self.metadata.freevars[i - self.metadata.cellvars.len()])
-            .as_ref()
+
+    fn get_localsplus_name(&self, var_num: oparg::VarNum) -> &str {
+        let idx = var_num.as_usize();
+        let nlocals = self.metadata.varnames.len();
+        if idx < nlocals {
+            self.metadata.varnames[idx].as_ref()
+        } else {
+            let cell_idx = idx - nlocals;
+            self.metadata
+                .cellvars
+                .get_index(cell_idx)
+                .unwrap_or_else(|| &self.metadata.freevars[cell_idx - self.metadata.cellvars.len()])
+                .as_ref()
+        }
     }
 }
 
@@ -979,7 +1854,6 @@ fn stackdepth_push(
     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);
     }
@@ -1028,6 +1902,18 @@ fn generate_linetable(
 
             // Get line information
             let line = loc.line;
+
+            // NO_LOCATION: emit PyCodeLocationInfoKind::None entries (CACHE, etc.)
+            if line == -1 {
+                linetable.push(
+                    0x80 | ((PyCodeLocationInfoKind::None as u8) << 3) | ((entry_length - 1) as u8),
+                );
+                // Do NOT update prev_line
+                length -= entry_length;
+                i += entry_length;
+                continue;
+            }
+
             let end_line = loc.end_line;
             let line_delta = line - prev_line;
             let end_line_delta = end_line - line;
@@ -1128,8 +2014,8 @@ fn generate_exception_table(blocks: &[Block], block_to_index: &[u32]) -> Box<[u8
     // 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;
+            // instr_size includes EXTENDED_ARG and CACHE entries
+            let instr_size = instr.arg.instr_size() as u32 + instr.cache_entries;
 
             match (&current_entry, instr.except_handler) {
                 // No current entry, no handler - nothing to do
@@ -1191,3 +2077,1068 @@ fn generate_exception_table(blocks: &[Block], block_to_index: &[u32]) -> Box<[u8
 
     encode_exception_table(&entries)
 }
+
+/// Mark exception handler target blocks.
+/// flowgraph.c mark_except_handlers
+pub(crate) fn mark_except_handlers(blocks: &mut [Block]) {
+    // Reset handler flags
+    for block in blocks.iter_mut() {
+        block.except_handler = false;
+        block.preserve_lasti = false;
+    }
+    // Mark target blocks of SETUP_* as except handlers
+    let targets: Vec<usize> = blocks
+        .iter()
+        .flat_map(|b| b.instructions.iter())
+        .filter(|i| i.instr.is_block_push() && i.target != BlockIdx::NULL)
+        .map(|i| i.target.idx())
+        .collect();
+    for idx in targets {
+        blocks[idx].except_handler = true;
+    }
+}
+
+/// flowgraph.c mark_cold
+fn mark_cold(blocks: &mut [Block]) {
+    let n = blocks.len();
+    let mut warm = vec![false; n];
+    let mut queue = VecDeque::new();
+
+    warm[0] = true;
+    queue.push_back(BlockIdx(0));
+
+    while let Some(block_idx) = queue.pop_front() {
+        let block = &blocks[block_idx.idx()];
+
+        let has_fallthrough = block
+            .instructions
+            .last()
+            .map(|ins| !ins.instr.is_scope_exit() && !ins.instr.is_unconditional_jump())
+            .unwrap_or(true);
+        if has_fallthrough && block.next != BlockIdx::NULL {
+            let next_idx = block.next.idx();
+            if !blocks[next_idx].except_handler && !warm[next_idx] {
+                warm[next_idx] = true;
+                queue.push_back(block.next);
+            }
+        }
+
+        for instr in &block.instructions {
+            if instr.target != BlockIdx::NULL {
+                let target_idx = instr.target.idx();
+                if !blocks[target_idx].except_handler && !warm[target_idx] {
+                    warm[target_idx] = true;
+                    queue.push_back(instr.target);
+                }
+            }
+        }
+    }
+
+    for (i, block) in blocks.iter_mut().enumerate() {
+        block.cold = !warm[i];
+    }
+}
+
+/// flowgraph.c push_cold_blocks_to_end
+fn push_cold_blocks_to_end(blocks: &mut Vec<Block>) {
+    if blocks.len() <= 1 {
+        return;
+    }
+
+    mark_cold(blocks);
+
+    // If a cold block falls through to a warm block, add an explicit jump
+    let fixups: Vec<(BlockIdx, BlockIdx)> = iter_blocks(blocks)
+        .filter(|(_, block)| {
+            block.cold
+                && block.next != BlockIdx::NULL
+                && !blocks[block.next.idx()].cold
+                && block
+                    .instructions
+                    .last()
+                    .map(|ins| !ins.instr.is_scope_exit() && !ins.instr.is_unconditional_jump())
+                    .unwrap_or(true)
+        })
+        .map(|(idx, block)| (idx, block.next))
+        .collect();
+
+    for (cold_idx, warm_next) in fixups {
+        let jump_block_idx = BlockIdx(blocks.len() as u32);
+        let loc = blocks[cold_idx.idx()]
+            .instructions
+            .last()
+            .map(|i| i.location)
+            .unwrap_or_default();
+        let end_loc = blocks[cold_idx.idx()]
+            .instructions
+            .last()
+            .map(|i| i.end_location)
+            .unwrap_or_default();
+        let mut jump_block = Block {
+            cold: true,
+            ..Block::default()
+        };
+        jump_block.instructions.push(InstructionInfo {
+            instr: PseudoInstruction::JumpNoInterrupt {
+                delta: Arg::marker(),
+            }
+            .into(),
+            arg: OpArg::new(0),
+            target: warm_next,
+            location: loc,
+            end_location: end_loc,
+            except_handler: None,
+            lineno_override: None,
+            cache_entries: 0,
+        });
+        jump_block.next = blocks[cold_idx.idx()].next;
+        blocks[cold_idx.idx()].next = jump_block_idx;
+        blocks.push(jump_block);
+    }
+
+    // Extract cold block streaks and append at the end
+    let mut cold_head: BlockIdx = BlockIdx::NULL;
+    let mut cold_tail: BlockIdx = BlockIdx::NULL;
+    let mut current = BlockIdx(0);
+    assert!(!blocks[0].cold);
+
+    while current != BlockIdx::NULL {
+        let next = blocks[current.idx()].next;
+        if next == BlockIdx::NULL {
+            break;
+        }
+
+        if blocks[next.idx()].cold {
+            let cold_start = next;
+            let mut cold_end = next;
+            while blocks[cold_end.idx()].next != BlockIdx::NULL
+                && blocks[blocks[cold_end.idx()].next.idx()].cold
+            {
+                cold_end = blocks[cold_end.idx()].next;
+            }
+
+            let after_cold = blocks[cold_end.idx()].next;
+            blocks[current.idx()].next = after_cold;
+            blocks[cold_end.idx()].next = BlockIdx::NULL;
+
+            if cold_head == BlockIdx::NULL {
+                cold_head = cold_start;
+            } else {
+                blocks[cold_tail.idx()].next = cold_start;
+            }
+            cold_tail = cold_end;
+        } else {
+            current = next;
+        }
+    }
+
+    if cold_head != BlockIdx::NULL {
+        let mut last = current;
+        while blocks[last.idx()].next != BlockIdx::NULL {
+            last = blocks[last.idx()].next;
+        }
+        blocks[last.idx()].next = cold_head;
+    }
+}
+
+/// Split blocks at branch points so each block has at most one branch
+/// (conditional/unconditional jump) as its last instruction.
+/// This matches CPython's CFG structure where each basic block has one exit.
+fn split_blocks_at_jumps(blocks: &mut Vec<Block>) {
+    let mut bi = 0;
+    while bi < blocks.len() {
+        // Find the first jump/branch instruction in the block
+        let split_at = {
+            let block = &blocks[bi];
+            let mut found = None;
+            for (i, ins) in block.instructions.iter().enumerate() {
+                if is_conditional_jump(&ins.instr)
+                    || ins.instr.is_unconditional_jump()
+                    || ins.instr.is_scope_exit()
+                {
+                    if i + 1 < block.instructions.len() {
+                        found = Some(i + 1);
+                    }
+                    break;
+                }
+            }
+            found
+        };
+        if let Some(pos) = split_at {
+            let new_block_idx = BlockIdx(blocks.len() as u32);
+            let tail: Vec<InstructionInfo> = blocks[bi].instructions.drain(pos..).collect();
+            let old_next = blocks[bi].next;
+            let cold = blocks[bi].cold;
+            blocks[bi].next = new_block_idx;
+            blocks.push(Block {
+                instructions: tail,
+                next: old_next,
+                cold,
+                ..Block::default()
+            });
+            // Don't increment bi - re-check current block (it might still have issues)
+        } else {
+            bi += 1;
+        }
+    }
+}
+
+/// Jump threading: when a block's last jump targets a block whose first
+/// instruction is an unconditional jump, redirect to the final target.
+/// flowgraph.c optimize_basic_block + jump_thread
+fn jump_threading(blocks: &mut [Block]) {
+    let mut changed = true;
+    while changed {
+        changed = false;
+        for bi in 0..blocks.len() {
+            let last_idx = match blocks[bi].instructions.len().checked_sub(1) {
+                Some(i) => i,
+                None => continue,
+            };
+            let ins = &blocks[bi].instructions[last_idx];
+            let target = ins.target;
+            if target == BlockIdx::NULL {
+                continue;
+            }
+            if !ins.instr.is_unconditional_jump() && !is_conditional_jump(&ins.instr) {
+                continue;
+            }
+            // Check if target block's first instruction is an unconditional jump
+            let target_block = &blocks[target.idx()];
+            if let Some(target_ins) = target_block.instructions.first()
+                && target_ins.instr.is_unconditional_jump()
+                && target_ins.target != BlockIdx::NULL
+                && target_ins.target != target
+            {
+                let final_target = target_ins.target;
+                blocks[bi].instructions[last_idx].target = final_target;
+                changed = true;
+            }
+        }
+    }
+}
+
+fn is_conditional_jump(instr: &AnyInstruction) -> bool {
+    matches!(
+        instr.real(),
+        Some(
+            Instruction::PopJumpIfFalse { .. }
+                | Instruction::PopJumpIfTrue { .. }
+                | Instruction::PopJumpIfNone { .. }
+                | Instruction::PopJumpIfNotNone { .. }
+        )
+    )
+}
+
+/// Invert a conditional jump opcode.
+fn reversed_conditional(instr: &AnyInstruction) -> Option<AnyInstruction> {
+    Some(match instr.real()? {
+        Instruction::PopJumpIfFalse { .. } => Instruction::PopJumpIfTrue {
+            delta: Arg::marker(),
+        }
+        .into(),
+        Instruction::PopJumpIfTrue { .. } => Instruction::PopJumpIfFalse {
+            delta: Arg::marker(),
+        }
+        .into(),
+        Instruction::PopJumpIfNone { .. } => Instruction::PopJumpIfNotNone {
+            delta: Arg::marker(),
+        }
+        .into(),
+        Instruction::PopJumpIfNotNone { .. } => Instruction::PopJumpIfNone {
+            delta: Arg::marker(),
+        }
+        .into(),
+        _ => return None,
+    })
+}
+
+/// flowgraph.c normalize_jumps + remove_redundant_jumps
+fn normalize_jumps(blocks: &mut Vec<Block>) {
+    let mut visit_order = Vec::new();
+    let mut visited = vec![false; blocks.len()];
+    let mut current = BlockIdx(0);
+    while current != BlockIdx::NULL {
+        visit_order.push(current);
+        visited[current.idx()] = true;
+        current = blocks[current.idx()].next;
+    }
+
+    visited.fill(false);
+
+    for &block_idx in &visit_order {
+        let idx = block_idx.idx();
+        visited[idx] = true;
+
+        // Remove redundant unconditional jump to next block
+        let next = blocks[idx].next;
+        if next != BlockIdx::NULL {
+            let last = blocks[idx].instructions.last();
+            let is_jump_to_next = last.is_some_and(|ins| {
+                ins.instr.is_unconditional_jump()
+                    && ins.target != BlockIdx::NULL
+                    && ins.target == next
+            });
+            if is_jump_to_next && let Some(last_instr) = blocks[idx].instructions.last_mut() {
+                last_instr.instr = Instruction::Nop.into();
+                last_instr.target = BlockIdx::NULL;
+            }
+        }
+
+        // Normalize conditional jumps: forward gets NOT_TAKEN, backward gets inverted
+        let last = blocks[idx].instructions.last();
+        if let Some(last_ins) = last
+            && is_conditional_jump(&last_ins.instr)
+            && last_ins.target != BlockIdx::NULL
+        {
+            let target = last_ins.target;
+            let is_forward = !visited[target.idx()];
+
+            if is_forward {
+                // Insert NOT_TAKEN after forward conditional jump
+                let not_taken = InstructionInfo {
+                    instr: Instruction::NotTaken.into(),
+                    arg: OpArg::new(0),
+                    target: BlockIdx::NULL,
+                    location: last_ins.location,
+                    end_location: last_ins.end_location,
+                    except_handler: last_ins.except_handler,
+                    lineno_override: None,
+                    cache_entries: 0,
+                };
+                blocks[idx].instructions.push(not_taken);
+            } else {
+                // Backward conditional jump: invert and create new block
+                // Transform: `cond_jump T` (backward)
+                // Into: `reversed_cond_jump b_next` + new block [NOT_TAKEN, JUMP T]
+                let loc = last_ins.location;
+                let end_loc = last_ins.end_location;
+                let exc_handler = last_ins.except_handler;
+
+                if let Some(reversed) = reversed_conditional(&last_ins.instr) {
+                    let old_next = blocks[idx].next;
+                    let is_cold = blocks[idx].cold;
+
+                    // Create new block with NOT_TAKEN + JUMP to original backward target
+                    let new_block_idx = BlockIdx(blocks.len() as u32);
+                    let mut new_block = Block {
+                        cold: is_cold,
+                        ..Block::default()
+                    };
+                    new_block.instructions.push(InstructionInfo {
+                        instr: Instruction::NotTaken.into(),
+                        arg: OpArg::new(0),
+                        target: BlockIdx::NULL,
+                        location: loc,
+                        end_location: end_loc,
+                        except_handler: exc_handler,
+                        lineno_override: None,
+                        cache_entries: 0,
+                    });
+                    new_block.instructions.push(InstructionInfo {
+                        instr: PseudoInstruction::Jump {
+                            delta: Arg::marker(),
+                        }
+                        .into(),
+                        arg: OpArg::new(0),
+                        target,
+                        location: loc,
+                        end_location: end_loc,
+                        except_handler: exc_handler,
+                        lineno_override: None,
+                        cache_entries: 0,
+                    });
+                    new_block.next = old_next;
+
+                    // Update the conditional jump: invert opcode, target = old next block
+                    let last_mut = blocks[idx].instructions.last_mut().unwrap();
+                    last_mut.instr = reversed;
+                    last_mut.target = old_next;
+
+                    // Splice new block between current and old next
+                    blocks[idx].next = new_block_idx;
+                    blocks.push(new_block);
+
+                    // Extend visited array and update visit order
+                    visited.push(true);
+                }
+            }
+        }
+    }
+
+    // Rebuild visit_order since backward normalization may have added new blocks
+    let mut visit_order = Vec::new();
+    let mut current = BlockIdx(0);
+    while current != BlockIdx::NULL {
+        visit_order.push(current);
+        current = blocks[current.idx()].next;
+    }
+
+    // Replace JUMP → value-producing-instr + RETURN_VALUE with inline return.
+    // This matches CPython's optimize_basic_block: "Replace JUMP to a RETURN".
+    for &block_idx in &visit_order {
+        let idx = block_idx.idx();
+        let mut replacements: Vec<(usize, Vec<InstructionInfo>)> = Vec::new();
+        for (i, ins) in blocks[idx].instructions.iter().enumerate() {
+            if !ins.instr.is_unconditional_jump() || ins.target == BlockIdx::NULL {
+                continue;
+            }
+            // Follow through empty blocks (next_nonempty_block)
+            let mut target_idx = ins.target.idx();
+            while blocks[target_idx].instructions.is_empty()
+                && blocks[target_idx].next != BlockIdx::NULL
+            {
+                target_idx = blocks[target_idx].next.idx();
+            }
+            let target_block = &blocks[target_idx];
+            // Target must be exactly `value; RETURN_VALUE`.
+            if target_block.instructions.len() == 2 {
+                let t0 = &target_block.instructions[0];
+                let t1 = &target_block.instructions[1];
+                if matches!(t0.instr, AnyInstruction::Real(_))
+                    && !t0.instr.is_scope_exit()
+                    && !t0.instr.is_unconditional_jump()
+                    && matches!(t1.instr.real(), Some(Instruction::ReturnValue))
+                {
+                    let mut load = *t0;
+                    let mut ret = *t1;
+                    // Use the jump's location for the inlined return
+                    load.location = ins.location;
+                    load.end_location = ins.end_location;
+                    load.except_handler = ins.except_handler;
+                    ret.location = ins.location;
+                    ret.end_location = ins.end_location;
+                    ret.except_handler = ins.except_handler;
+                    replacements.push((i, vec![load, ret]));
+                }
+            }
+        }
+        // Apply replacements in reverse order
+        for (i, new_insts) in replacements.into_iter().rev() {
+            blocks[idx].instructions.splice(i..i + 1, new_insts);
+        }
+    }
+
+    // Resolve JUMP/JUMP_NO_INTERRUPT pseudo instructions before offset fixpoint.
+    let mut block_order = vec![0u32; blocks.len()];
+    for (pos, &block_idx) in visit_order.iter().enumerate() {
+        block_order[block_idx.idx()] = pos as u32;
+    }
+
+    for &block_idx in &visit_order {
+        let source_pos = block_order[block_idx.idx()];
+        for info in &mut blocks[block_idx.idx()].instructions {
+            let target = info.target;
+            if target == BlockIdx::NULL {
+                continue;
+            }
+            let target_pos = block_order[target.idx()];
+            info.instr = match info.instr {
+                AnyInstruction::Pseudo(PseudoInstruction::Jump { .. }) => {
+                    if target_pos > source_pos {
+                        Instruction::JumpForward {
+                            delta: Arg::marker(),
+                        }
+                        .into()
+                    } else {
+                        Instruction::JumpBackward {
+                            delta: Arg::marker(),
+                        }
+                        .into()
+                    }
+                }
+                AnyInstruction::Pseudo(PseudoInstruction::JumpNoInterrupt { .. }) => {
+                    if target_pos > source_pos {
+                        Instruction::JumpForward {
+                            delta: Arg::marker(),
+                        }
+                        .into()
+                    } else {
+                        Instruction::JumpBackwardNoInterrupt {
+                            delta: Arg::marker(),
+                        }
+                        .into()
+                    }
+                }
+                other => other,
+            };
+        }
+    }
+}
+
+/// flowgraph.c inline_small_or_no_lineno_blocks
+fn inline_small_or_no_lineno_blocks(blocks: &mut [Block]) {
+    const MAX_COPY_SIZE: usize = 4;
+
+    let block_exits_scope = |block: &Block| {
+        block
+            .instructions
+            .last()
+            .is_some_and(|ins| ins.instr.is_scope_exit())
+    };
+    let block_has_no_lineno = |block: &Block| {
+        block
+            .instructions
+            .iter()
+            .all(|ins| !instruction_has_lineno(ins))
+    };
+
+    loop {
+        let mut changes = false;
+        let mut current = BlockIdx(0);
+        while current != BlockIdx::NULL {
+            let next = blocks[current.idx()].next;
+            let Some(last) = blocks[current.idx()].instructions.last().copied() else {
+                current = next;
+                continue;
+            };
+            if !last.instr.is_unconditional_jump() || last.target == BlockIdx::NULL {
+                current = next;
+                continue;
+            }
+
+            let target = last.target;
+            let small_exit_block = block_exits_scope(&blocks[target.idx()])
+                && blocks[target.idx()].instructions.len() <= MAX_COPY_SIZE;
+            let no_lineno_no_fallthrough = block_has_no_lineno(&blocks[target.idx()])
+                && !block_has_fallthrough(&blocks[target.idx()]);
+
+            if small_exit_block || no_lineno_no_fallthrough {
+                if let Some(last_instr) = blocks[current.idx()].instructions.last_mut() {
+                    last_instr.instr = Instruction::Nop.into();
+                    last_instr.arg = OpArg::new(0);
+                    last_instr.target = BlockIdx::NULL;
+                }
+                let appended = blocks[target.idx()].instructions.clone();
+                blocks[current.idx()].instructions.extend(appended);
+                changes = true;
+            }
+
+            current = next;
+        }
+
+        if !changes {
+            break;
+        }
+    }
+}
+
+/// Follow chain of empty blocks to find first non-empty block.
+fn next_nonempty_block(blocks: &[Block], mut idx: BlockIdx) -> BlockIdx {
+    while idx != BlockIdx::NULL
+        && blocks[idx.idx()].instructions.is_empty()
+        && blocks[idx.idx()].next != BlockIdx::NULL
+    {
+        idx = blocks[idx.idx()].next;
+    }
+    idx
+}
+
+fn instruction_lineno(instr: &InstructionInfo) -> i32 {
+    instr
+        .lineno_override
+        .unwrap_or_else(|| instr.location.line.get() as i32)
+}
+
+fn instruction_has_lineno(instr: &InstructionInfo) -> bool {
+    instruction_lineno(instr) > 0
+}
+
+fn block_has_fallthrough(block: &Block) -> bool {
+    block
+        .instructions
+        .last()
+        .is_none_or(|ins| !ins.instr.is_scope_exit() && !ins.instr.is_unconditional_jump())
+}
+
+fn is_jump_instruction(instr: &InstructionInfo) -> bool {
+    instr.instr.is_unconditional_jump() || is_conditional_jump(&instr.instr)
+}
+
+fn is_exit_without_lineno(block: &Block) -> bool {
+    let Some(first) = block.instructions.first() else {
+        return false;
+    };
+    let Some(last) = block.instructions.last() else {
+        return false;
+    };
+    !instruction_has_lineno(first) && last.instr.is_scope_exit()
+}
+
+fn maybe_propagate_location(
+    instr: &mut InstructionInfo,
+    location: SourceLocation,
+    end_location: SourceLocation,
+) {
+    if !instruction_has_lineno(instr) {
+        instr.location = location;
+        instr.end_location = end_location;
+        instr.lineno_override = None;
+    }
+}
+
+fn propagate_locations_in_block(
+    block: &mut Block,
+    location: SourceLocation,
+    end_location: SourceLocation,
+) {
+    let mut prev_location = location;
+    let mut prev_end_location = end_location;
+    for instr in &mut block.instructions {
+        maybe_propagate_location(instr, prev_location, prev_end_location);
+        prev_location = instr.location;
+        prev_end_location = instr.end_location;
+    }
+}
+
+fn compute_predecessors(blocks: &[Block]) -> Vec<u32> {
+    let mut predecessors = vec![0u32; blocks.len()];
+    if blocks.is_empty() {
+        return predecessors;
+    }
+
+    predecessors[0] = 1;
+    let mut current = BlockIdx(0);
+    while current != BlockIdx::NULL {
+        let block = &blocks[current.idx()];
+        if block_has_fallthrough(block) {
+            let next = next_nonempty_block(blocks, block.next);
+            if next != BlockIdx::NULL {
+                predecessors[next.idx()] += 1;
+            }
+        }
+        for ins in &block.instructions {
+            if ins.target != BlockIdx::NULL {
+                let target = next_nonempty_block(blocks, ins.target);
+                if target != BlockIdx::NULL {
+                    predecessors[target.idx()] += 1;
+                }
+            }
+        }
+        current = block.next;
+    }
+    predecessors
+}
+
+fn duplicate_exits_without_lineno(blocks: &mut Vec<Block>, predecessors: &mut Vec<u32>) {
+    let mut current = BlockIdx(0);
+    while current != BlockIdx::NULL {
+        let block = &blocks[current.idx()];
+        let last = match block.instructions.last() {
+            Some(ins) if ins.target != BlockIdx::NULL && is_jump_instruction(ins) => ins,
+            _ => {
+                current = blocks[current.idx()].next;
+                continue;
+            }
+        };
+
+        let target = next_nonempty_block(blocks, last.target);
+        if target == BlockIdx::NULL || !is_exit_without_lineno(&blocks[target.idx()]) {
+            current = blocks[current.idx()].next;
+            continue;
+        }
+        if predecessors[target.idx()] <= 1 {
+            current = blocks[current.idx()].next;
+            continue;
+        }
+
+        // Copy the exit block and splice it into the linked list after current
+        let new_idx = BlockIdx(blocks.len() as u32);
+        let mut new_block = blocks[target.idx()].clone();
+        let jump_loc = last.location;
+        let jump_end_loc = last.end_location;
+        propagate_locations_in_block(&mut new_block, jump_loc, jump_end_loc);
+        let old_next = blocks[current.idx()].next;
+        new_block.next = old_next;
+        blocks.push(new_block);
+        blocks[current.idx()].next = new_idx;
+
+        // Update the jump target
+        let last_mut = blocks[current.idx()].instructions.last_mut().unwrap();
+        last_mut.target = new_idx;
+        predecessors[target.idx()] -= 1;
+        predecessors.push(1);
+
+        // Skip past the newly inserted block
+        current = old_next;
+    }
+
+    current = BlockIdx(0);
+    while current != BlockIdx::NULL {
+        let block = &blocks[current.idx()];
+        if let Some(last) = block.instructions.last()
+            && block_has_fallthrough(block)
+        {
+            let target = next_nonempty_block(blocks, block.next);
+            if target != BlockIdx::NULL
+                && predecessors[target.idx()] == 1
+                && is_exit_without_lineno(&blocks[target.idx()])
+            {
+                let last_location = last.location;
+                let last_end_location = last.end_location;
+                propagate_locations_in_block(
+                    &mut blocks[target.idx()],
+                    last_location,
+                    last_end_location,
+                );
+            }
+        }
+        current = blocks[current.idx()].next;
+    }
+}
+
+fn propagate_line_numbers(blocks: &mut [Block], predecessors: &[u32]) {
+    let mut current = BlockIdx(0);
+    while current != BlockIdx::NULL {
+        let last = blocks[current.idx()].instructions.last().copied();
+        if let Some(last) = last {
+            let (next_block, has_fallthrough) = {
+                let block = &blocks[current.idx()];
+                (block.next, block_has_fallthrough(block))
+            };
+
+            {
+                let block = &mut blocks[current.idx()];
+                let mut prev_location = None;
+                for instr in &mut block.instructions {
+                    if let Some((location, end_location)) = prev_location {
+                        maybe_propagate_location(instr, location, end_location);
+                    }
+                    prev_location = Some((instr.location, instr.end_location));
+                }
+            }
+
+            if has_fallthrough {
+                let target = next_nonempty_block(blocks, next_block);
+                if target != BlockIdx::NULL && predecessors[target.idx()] == 1 {
+                    propagate_locations_in_block(
+                        &mut blocks[target.idx()],
+                        last.location,
+                        last.end_location,
+                    );
+                }
+            }
+
+            if is_jump_instruction(&last) {
+                let target = next_nonempty_block(blocks, last.target);
+                if target != BlockIdx::NULL && predecessors[target.idx()] == 1 {
+                    propagate_locations_in_block(
+                        &mut blocks[target.idx()],
+                        last.location,
+                        last.end_location,
+                    );
+                }
+            }
+        }
+        current = blocks[current.idx()].next;
+    }
+}
+
+fn resolve_line_numbers(blocks: &mut Vec<Block>) {
+    let mut predecessors = compute_predecessors(blocks);
+    duplicate_exits_without_lineno(blocks, &mut predecessors);
+    propagate_line_numbers(blocks, &predecessors);
+}
+
+/// Duplicate `LOAD_CONST None + RETURN_VALUE` for blocks that fall through
+/// to the final return block.
+fn duplicate_end_returns(blocks: &mut [Block]) {
+    // Walk the block chain and keep the last non-empty block.
+    let mut last_block = BlockIdx::NULL;
+    let mut current = BlockIdx(0);
+    while current != BlockIdx::NULL {
+        if !blocks[current.idx()].instructions.is_empty() {
+            last_block = current;
+        }
+        current = blocks[current.idx()].next;
+    }
+    if last_block == BlockIdx::NULL {
+        return;
+    }
+
+    let last_insts = &blocks[last_block.idx()].instructions;
+    // Only apply when the last block is EXACTLY a return-None epilogue
+    let is_return_block = last_insts.len() == 2
+        && matches!(
+            last_insts[0].instr,
+            AnyInstruction::Real(Instruction::LoadConst { .. })
+        )
+        && matches!(
+            last_insts[1].instr,
+            AnyInstruction::Real(Instruction::ReturnValue)
+        );
+    if !is_return_block {
+        return;
+    }
+
+    // Get the return instructions to clone
+    let return_insts: Vec<InstructionInfo> = last_insts[last_insts.len() - 2..].to_vec();
+
+    // Find non-cold blocks that fall through to the last block
+    let mut blocks_to_fix = Vec::new();
+    current = BlockIdx(0);
+    while current != BlockIdx::NULL {
+        let block = &blocks[current.idx()];
+        let next = next_nonempty_block(blocks, block.next);
+        if current != last_block && next == last_block && !block.cold && !block.except_handler {
+            let last_ins = block.instructions.last();
+            let has_fallthrough = last_ins
+                .map(|ins| !ins.instr.is_scope_exit() && !ins.instr.is_unconditional_jump())
+                .unwrap_or(true);
+            // Don't duplicate if block already ends with the same return pattern
+            let already_has_return = block.instructions.len() >= 2 && {
+                let n = block.instructions.len();
+                matches!(
+                    block.instructions[n - 2].instr,
+                    AnyInstruction::Real(Instruction::LoadConst { .. })
+                ) && matches!(
+                    block.instructions[n - 1].instr,
+                    AnyInstruction::Real(Instruction::ReturnValue)
+                )
+            };
+            if has_fallthrough && !already_has_return {
+                blocks_to_fix.push(current);
+            }
+        }
+        current = blocks[current.idx()].next;
+    }
+
+    // Duplicate the return instructions at the end of fall-through blocks
+    for block_idx in blocks_to_fix {
+        blocks[block_idx.idx()]
+            .instructions
+            .extend_from_slice(&return_insts);
+    }
+}
+
+/// Label exception targets: walk CFG with except stack, set per-instruction
+/// handler info and block preserve_lasti flag. Converts POP_BLOCK to NOP.
+/// flowgraph.c label_exception_targets + push_except_block
+pub(crate) fn label_exception_targets(blocks: &mut [Block]) {
+    #[derive(Clone)]
+    struct ExceptEntry {
+        handler_block: BlockIdx,
+        preserve_lasti: bool,
+    }
+
+    let num_blocks = blocks.len();
+    if num_blocks == 0 {
+        return;
+    }
+
+    let mut visited = vec![false; num_blocks];
+    let mut block_stacks: Vec<Option<Vec<ExceptEntry>>> = vec![None; num_blocks];
+
+    // Entry block
+    visited[0] = true;
+    block_stacks[0] = Some(Vec::new());
+
+    let mut todo = vec![BlockIdx(0)];
+
+    while let Some(block_idx) = todo.pop() {
+        let bi = block_idx.idx();
+        let mut stack = block_stacks[bi].take().unwrap_or_default();
+        let mut last_yield_except_depth: i32 = -1;
+
+        let instr_count = blocks[bi].instructions.len();
+        for i in 0..instr_count {
+            // Read all needed fields (each temporary borrow ends immediately)
+            let target = blocks[bi].instructions[i].target;
+            let arg = blocks[bi].instructions[i].arg;
+            let is_push = blocks[bi].instructions[i].instr.is_block_push();
+            let is_pop = blocks[bi].instructions[i].instr.is_pop_block();
+
+            if is_push {
+                // Determine preserve_lasti from instruction type (push_except_block)
+                let preserve_lasti = matches!(
+                    blocks[bi].instructions[i].instr.pseudo(),
+                    Some(
+                        PseudoInstruction::SetupWith { .. }
+                            | PseudoInstruction::SetupCleanup { .. }
+                    )
+                );
+
+                // Set preserve_lasti on handler block
+                if preserve_lasti && target != BlockIdx::NULL {
+                    blocks[target.idx()].preserve_lasti = true;
+                }
+
+                // Propagate except stack to handler block if not visited
+                if target != BlockIdx::NULL && !visited[target.idx()] {
+                    visited[target.idx()] = true;
+                    block_stacks[target.idx()] = Some(stack.clone());
+                    todo.push(target);
+                }
+
+                // Push handler onto except stack
+                stack.push(ExceptEntry {
+                    handler_block: target,
+                    preserve_lasti,
+                });
+            } else if is_pop {
+                debug_assert!(
+                    !stack.is_empty(),
+                    "POP_BLOCK with empty except stack at block {bi} instruction {i}"
+                );
+                stack.pop();
+                // POP_BLOCK → NOP
+                blocks[bi].instructions[i].instr = Instruction::Nop.into();
+            } else {
+                // Set except_handler for this instruction from except stack top
+                // stack_depth placeholder: filled by fixup_handler_depths
+                let handler_info = stack.last().map(|e| ExceptHandlerInfo {
+                    handler_block: e.handler_block,
+                    stack_depth: 0,
+                    preserve_lasti: e.preserve_lasti,
+                });
+                blocks[bi].instructions[i].except_handler = handler_info;
+
+                // Track YIELD_VALUE except stack depth
+                // Record the except stack depth at the point of yield.
+                // With the StopIteration wrapper, depth is naturally correct:
+                // - plain yield outside try: depth=1 → DEPTH1 set
+                // - yield inside try: depth=2+ → no DEPTH1
+                // - yield-from/await: has internal SETUP_FINALLY → depth=2+ → no DEPTH1
+                if let Some(Instruction::YieldValue { .. }) =
+                    blocks[bi].instructions[i].instr.real()
+                {
+                    last_yield_except_depth = stack.len() as i32;
+                }
+
+                // Set RESUME DEPTH1 flag based on last yield's except depth
+                if let Some(Instruction::Resume { context }) =
+                    blocks[bi].instructions[i].instr.real()
+                {
+                    let location = context.get(arg).location();
+                    match location {
+                        oparg::ResumeLocation::AtFuncStart => {}
+                        _ => {
+                            if last_yield_except_depth == 1 {
+                                blocks[bi].instructions[i].arg =
+                                    OpArg::new(oparg::ResumeContext::new(location, true).as_u32());
+                            }
+                            last_yield_except_depth = -1;
+                        }
+                    }
+                }
+
+                // For jump instructions, propagate except stack to target
+                if target != BlockIdx::NULL && !visited[target.idx()] {
+                    visited[target.idx()] = true;
+                    block_stacks[target.idx()] = Some(stack.clone());
+                    todo.push(target);
+                }
+            }
+        }
+
+        // Propagate to fallthrough block (block.next)
+        let next = blocks[bi].next;
+        if next != BlockIdx::NULL && !visited[next.idx()] {
+            let has_fallthrough = blocks[bi]
+                .instructions
+                .last()
+                .map(|ins| !ins.instr.is_scope_exit() && !ins.instr.is_unconditional_jump())
+                .unwrap_or(true); // Empty block falls through
+            if has_fallthrough {
+                visited[next.idx()] = true;
+                block_stacks[next.idx()] = Some(stack);
+                todo.push(next);
+            }
+        }
+    }
+}
+
+/// Convert remaining pseudo ops to real instructions or NOP.
+/// flowgraph.c convert_pseudo_ops
+pub(crate) fn convert_pseudo_ops(blocks: &mut [Block], cellfixedoffsets: &[u32]) {
+    for block in blocks.iter_mut() {
+        for info in &mut block.instructions {
+            let Some(pseudo) = info.instr.pseudo() else {
+                continue;
+            };
+            match pseudo {
+                // Block push pseudo ops → NOP
+                PseudoInstruction::SetupCleanup { .. }
+                | PseudoInstruction::SetupFinally { .. }
+                | PseudoInstruction::SetupWith { .. } => {
+                    info.instr = Instruction::Nop.into();
+                }
+                // PopBlock in reachable blocks is converted to NOP by
+                // label_exception_targets. Dead blocks may still have them.
+                PseudoInstruction::PopBlock => {
+                    info.instr = Instruction::Nop.into();
+                }
+                // LOAD_CLOSURE → LOAD_FAST (using cellfixedoffsets for merged layout)
+                PseudoInstruction::LoadClosure { i } => {
+                    let cell_relative = i.get(info.arg) as usize;
+                    let new_idx = cellfixedoffsets[cell_relative];
+                    info.arg = OpArg::new(new_idx);
+                    info.instr = Instruction::LoadFast {
+                        var_num: Arg::marker(),
+                    }
+                    .into();
+                }
+                // Jump pseudo ops are resolved during block linearization
+                PseudoInstruction::Jump { .. } | PseudoInstruction::JumpNoInterrupt { .. } => {}
+                // These should have been resolved earlier
+                PseudoInstruction::AnnotationsPlaceholder
+                | PseudoInstruction::JumpIfFalse { .. }
+                | PseudoInstruction::JumpIfTrue { .. }
+                | PseudoInstruction::StoreFastMaybeNull { .. } => {
+                    unreachable!("Unexpected pseudo instruction in convert_pseudo_ops: {pseudo:?}")
+                }
+            }
+        }
+    }
+}
+
+/// Build cellfixedoffsets mapping: cell/free index -> localsplus index.
+/// Merged cells (cellvar also in varnames) get the local slot index.
+/// Non-merged cells get slots after nlocals. Free vars follow.
+pub(crate) fn build_cellfixedoffsets(
+    varnames: &IndexSet<String>,
+    cellvars: &IndexSet<String>,
+    freevars: &IndexSet<String>,
+) -> Vec<u32> {
+    let nlocals = varnames.len();
+    let ncells = cellvars.len();
+    let nfrees = freevars.len();
+    let mut fixed = Vec::with_capacity(ncells + nfrees);
+    let mut numdropped = 0usize;
+    for (i, cellvar) in cellvars.iter().enumerate() {
+        if let Some(local_idx) = varnames.get_index_of(cellvar) {
+            fixed.push(local_idx as u32);
+            numdropped += 1;
+        } else {
+            fixed.push((nlocals + i - numdropped) as u32);
+        }
+    }
+    for i in 0..nfrees {
+        fixed.push((nlocals + ncells - numdropped + i) as u32);
+    }
+    fixed
+}
+
+/// Convert DEREF instruction opargs from cell-relative indices to localsplus indices
+/// using the cellfixedoffsets mapping.
+pub(crate) fn fixup_deref_opargs(blocks: &mut [Block], cellfixedoffsets: &[u32]) {
+    for block in blocks.iter_mut() {
+        for info in &mut block.instructions {
+            let Some(instr) = info.instr.real() else {
+                continue;
+            };
+            let needs_fixup = matches!(
+                instr,
+                Instruction::LoadDeref { .. }
+                    | Instruction::StoreDeref { .. }
+                    | Instruction::DeleteDeref { .. }
+                    | Instruction::LoadFromDictOrDeref { .. }
+                    | Instruction::MakeCell { .. }
+            );
+            if needs_fixup {
+                let cell_relative = u32::from(info.arg) as usize;
+                info.arg = OpArg::new(cellfixedoffsets[cell_relative]);
+            }
+        }
+    }
+}
diff --git a/crates/codegen/src/lib.rs b/crates/codegen/src/lib.rs
index 9dd7384170a..c1a318c19cd 100644
--- a/crates/codegen/src/lib.rs
+++ b/crates/codegen/src/lib.rs
@@ -1,4 +1,5 @@
 //! Compile a Python AST or source code into bytecode consumable by RustPython.
+#![cfg_attr(not(feature = "std"), no_std)]
 #![doc(html_logo_url = "https://raw.githubusercontent.com/RustPython/RustPython/main/logo.png")]
 #![doc(html_root_url = "https://docs.rs/rustpython-compiler/")]
 
diff --git a/crates/codegen/src/snapshots/rustpython_codegen__compile__tests__const_bool_not_op.snap b/crates/codegen/src/snapshots/rustpython_codegen__compile__tests__const_bool_not_op.snap
new file mode 100644
index 00000000000..f9a74c2055c
--- /dev/null
+++ b/crates/codegen/src/snapshots/rustpython_codegen__compile__tests__const_bool_not_op.snap
@@ -0,0 +1,9 @@
+---
+source: crates/codegen/src/compile.rs
+expression: "compile_exec_optimized(\"\\\nx = not True\n\")"
+---
+  1           0 RESUME               (0)
+              1 LOAD_CONST           (False)
+              2 STORE_NAME           (0, x)
+              3 LOAD_CONST           (None)
+              4 RETURN_VALUE
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 26583f5da0f..4783c0f2d5e 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,14 +1,23 @@
 ---
 source: crates/codegen/src/compile.rs
+assertion_line: 9553
 expression: "compile_exec(\"\\\nif True and False and False:\n    pass\n\")"
 ---
   1           0 RESUME               (0)
               1 LOAD_CONST           (True)
-              2 POP_JUMP_IF_FALSE    (7)
-              3 LOAD_CONST           (False)
-              4 POP_JUMP_IF_FALSE    (7)
+              2 POP_JUMP_IF_FALSE    (11)
+        >>    3 CACHE
+              4 NOT_TAKEN
               5 LOAD_CONST           (False)
               6 POP_JUMP_IF_FALSE    (7)
+        >>    7 CACHE
+              8 NOT_TAKEN
+              9 LOAD_CONST           (False)
+             10 POP_JUMP_IF_FALSE    (3)
+        >>   11 CACHE
+             12 NOT_TAKEN
 
-  2     >>    7 LOAD_CONST           (None)
-              8 RETURN_VALUE
+  2          13 LOAD_CONST           (None)
+             14 RETURN_VALUE
+             15 LOAD_CONST           (None)
+             16 RETURN_VALUE
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 21976b257ef..043bf380af3 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,16 +1,27 @@
 ---
 source: crates/codegen/src/compile.rs
+assertion_line: 9563
 expression: "compile_exec(\"\\\nif (True and False) or (False and True):\n    pass\n\")"
 ---
   1           0 RESUME               (0)
               1 LOAD_CONST           (True)
               2 POP_JUMP_IF_FALSE    (5)
-              3 LOAD_CONST           (False)
-              4 POP_JUMP_IF_TRUE     (9)
+        >>    3 CACHE
+              4 NOT_TAKEN
         >>    5 LOAD_CONST           (False)
-              6 POP_JUMP_IF_FALSE    (9)
-              7 LOAD_CONST           (True)
-              8 POP_JUMP_IF_FALSE    (9)
+              6 POP_JUMP_IF_TRUE     (9)
+        >>    7 CACHE
+              8 NOT_TAKEN
+        >>    9 LOAD_CONST           (False)
+             10 POP_JUMP_IF_FALSE    (7)
+             11 CACHE
+             12 NOT_TAKEN
+             13 LOAD_CONST           (True)
+             14 POP_JUMP_IF_FALSE    (3)
+             15 CACHE
+             16 NOT_TAKEN
 
-  2     >>    9 LOAD_CONST           (None)
-             10 RETURN_VALUE
+  2          17 LOAD_CONST           (None)
+             18 RETURN_VALUE
+             19 LOAD_CONST           (None)
+             20 RETURN_VALUE
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 e1d41377db7..bf4960582c1 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,14 +1,23 @@
 ---
 source: crates/codegen/src/compile.rs
+assertion_line: 9543
 expression: "compile_exec(\"\\\nif True or False or False:\n    pass\n\")"
 ---
   1           0 RESUME               (0)
               1 LOAD_CONST           (True)
-              2 POP_JUMP_IF_TRUE     (7)
-              3 LOAD_CONST           (False)
-              4 POP_JUMP_IF_TRUE     (7)
-              5 LOAD_CONST           (False)
-              6 POP_JUMP_IF_FALSE    (7)
+              2 POP_JUMP_IF_TRUE     (9)
+        >>    3 CACHE
+              4 NOT_TAKEN
+        >>    5 LOAD_CONST           (False)
+              6 POP_JUMP_IF_TRUE     (5)
+              7 CACHE
+              8 NOT_TAKEN
+        >>    9 LOAD_CONST           (False)
+             10 POP_JUMP_IF_FALSE    (3)
+             11 CACHE
+             12 NOT_TAKEN
 
-  2     >>    7 LOAD_CONST           (None)
-              8 RETURN_VALUE
+  2          13 LOAD_CONST           (None)
+             14 RETURN_VALUE
+             15 LOAD_CONST           (None)
+             16 RETURN_VALUE
diff --git a/crates/codegen/src/snapshots/rustpython_codegen__compile__tests__nested_bool_op.snap b/crates/codegen/src/snapshots/rustpython_codegen__compile__tests__nested_bool_op.snap
new file mode 100644
index 00000000000..bc9268b45bd
--- /dev/null
+++ b/crates/codegen/src/snapshots/rustpython_codegen__compile__tests__nested_bool_op.snap
@@ -0,0 +1,35 @@
+---
+source: crates/codegen/src/compile.rs
+assertion_line: 9688
+expression: "compile_exec(\"\\\nx = Test() and False or False\n\")"
+---
+  1           0 RESUME               (0)
+              1 LOAD_NAME            (0, Test)
+              2 PUSH_NULL
+        >>    3 CALL                 (0)
+              4 CACHE
+              5 CACHE
+              6 CACHE
+              7 COPY                 (1)
+              8 TO_BOOL
+              9 CACHE
+             10 CACHE
+        >>   11 CACHE
+             12 POP_JUMP_IF_FALSE    (11)
+             13 CACHE
+             14 NOT_TAKEN
+             15 POP_TOP
+             16 LOAD_CONST           (False)
+             17 COPY                 (1)
+             18 TO_BOOL
+             19 CACHE
+             20 CACHE
+             21 CACHE
+             22 POP_JUMP_IF_TRUE     (3)
+             23 CACHE
+             24 NOT_TAKEN
+             25 POP_TOP
+             26 LOAD_CONST           (False)
+             27 STORE_NAME           (1, x)
+             28 LOAD_CONST           (None)
+             29 RETURN_VALUE
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 4f67bd10805..ba8be3589d3 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,164 +1,254 @@
 ---
 source: crates/codegen/src/compile.rs
-assertion_line: 8782
 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 RESUME               (0)
-
-  3           1 LOAD_CONST           (<code object test at ??? file "source_path", line 1>):  1               0 RETURN_GENERATOR
+              1 LOAD_CONST           (<code object test at ??? file "source_path", line 1>):  1               0 RETURN_GENERATOR
                   1 POP_TOP
-                  2 RESUME               (0)
+            >>    2 RESUME               (0)
 
-  2               3 LOAD_GLOBAL          (0, StopIteration)
-                  4 PUSH_NULL
-                  5 LOAD_CONST           ("spam")
-                  6 CALL                 (1)
-                  7 LOAD_GLOBAL          (1, StopAsyncIteration)
-                  8 PUSH_NULL
-                  9 LOAD_CONST           ("ham")
-                 10 CALL                 (1)
-                 11 BUILD_TUPLE          (2)
-                 12 GET_ITER
-            >>   13 FOR_ITER             (141)
-                 14 STORE_FAST           (0, stop_exc)
+  2         >>    3 LOAD_GLOBAL          (1, NULL + StopIteration)
+            >>    4 CACHE
+            >>    5 CACHE
+                  6 CACHE
+                  7 CACHE
+                  8 LOAD_CONST           ("spam")
+                  9 CALL                 (1)
+            >>   10 CACHE
+                 11 CACHE
+                 12 CACHE
+                 13 LOAD_GLOBAL          (3, NULL + StopAsyncIteration)
+                 14 CACHE
+                 15 CACHE
+                 16 CACHE
+                 17 CACHE
+                 18 LOAD_CONST           ("ham")
+                 19 CALL                 (1)
+                 20 CACHE
+                 21 CACHE
+                 22 CACHE
+                 23 BUILD_TUPLE          (2)
+                 24 GET_ITER
+                 25 FOR_ITER             (71)
+                 26 CACHE
+                 27 STORE_FAST           (0, stop_exc)
 
-  3              15 LOAD_GLOBAL          (2, self)
-                 16 LOAD_ATTR            (7, subTest, method=true)
-                 17 LOAD_GLOBAL          (4, type)
-                 18 PUSH_NULL
-                 19 LOAD_FAST_BORROW     (0, stop_exc)
-                 20 CALL                 (1)
-                 21 LOAD_CONST           (("type"))
-                 22 CALL_KW              (1)
-                 23 COPY                 (1)
-                 24 LOAD_SPECIAL         (__exit__)
-                 25 SWAP                 (2)
-                 26 LOAD_SPECIAL         (__enter__)
-                 27 PUSH_NULL
-                 28 CALL                 (0)
-                 29 POP_TOP
+  3              28 LOAD_GLOBAL          (4, self)
+                 29 CACHE
+                 30 CACHE
+                 31 CACHE
+            >>   32 CACHE
+                 33 LOAD_ATTR            (7, subTest, method=true)
+                 34 CACHE
+                 35 CACHE
+                 36 CACHE
+                 37 CACHE
+                 38 CACHE
+                 39 CACHE
+                 40 CACHE
+                 41 CACHE
+                 42 CACHE
+                 43 LOAD_GLOBAL          (9, NULL + type)
+                 44 CACHE
+                 45 CACHE
+                 46 CACHE
+                 47 CACHE
+            >>   48 LOAD_FAST            (0, stop_exc)
+                 49 CALL                 (1)
+                 50 CACHE
+                 51 CACHE
+                 52 CACHE
+                 53 LOAD_CONST           (("type"))
+                 54 CALL_KW              (1)
+                 55 CACHE
+                 56 CACHE
+                 57 CACHE
+                 58 COPY                 (1)
+                 59 LOAD_SPECIAL         (__exit__)
+                 60 SWAP                 (2)
+                 61 SWAP                 (3)
+                 62 LOAD_SPECIAL         (__enter__)
+                 63 CALL                 (0)
+                 64 CACHE
+                 65 CACHE
+                 66 CACHE
+                 67 POP_TOP
 
-  5              30 LOAD_GLOBAL          (5, egg)
-                 31 PUSH_NULL
-                 32 CALL                 (0)
-                 33 COPY                 (1)
-                 34 LOAD_SPECIAL         (__aexit__)
-                 35 SWAP                 (2)
-                 36 LOAD_SPECIAL         (__aenter__)
-                 37 PUSH_NULL
-                 38 CALL                 (0)
-                 39 GET_AWAITABLE
-                 40 LOAD_CONST           (None)
-            >>   41 SEND                 (46)
-                 42 YIELD_VALUE          (1)
-                 43 RESUME               (3)
-                 44 JUMP_BACKWARD_NO_INTERRUPT(41)
-                 45 CLEANUP_THROW
-            >>   46 END_SEND
-                 47 POP_TOP
+  4              68 NOP
 
-  6              48 LOAD_FAST            (0, stop_exc)
-                 49 RAISE_VARARGS        (Raise)
+  5              69 LOAD_GLOBAL          (11, NULL + egg)
+                 70 CACHE
+            >>   71 CACHE
+                 72 CACHE
+                 73 CACHE
+                 74 CALL                 (0)
+                 75 CACHE
+                 76 CACHE
+                 77 CACHE
+                 78 COPY                 (1)
+                 79 LOAD_SPECIAL         (__aexit__)
+                 80 SWAP                 (2)
+                 81 SWAP                 (3)
+                 82 LOAD_SPECIAL         (__aenter__)
+                 83 CALL                 (0)
+                 84 CACHE
+                 85 CACHE
+                 86 CACHE
+                 87 GET_AWAITABLE        (1)
+                 88 LOAD_CONST           (None)
+                 89 SEND                 (3)
+                 90 CACHE
+                 91 YIELD_VALUE          (1)
+                 92 RESUME               (3)
+                 93 JUMP_BACKWARD_NO_INTERRUPT(5)
+                 94 END_SEND
+                 95 POP_TOP
 
-  5              50 PUSH_NULL
-                 51 LOAD_CONST           (None)
-                 52 LOAD_CONST           (None)
-                 53 LOAD_CONST           (None)
-                 54 CALL                 (3)
-                 55 GET_AWAITABLE
-                 56 LOAD_CONST           (None)
-            >>   57 SEND                 (62)
-                 58 YIELD_VALUE          (1)
-                 59 RESUME               (3)
-                 60 JUMP_BACKWARD_NO_INTERRUPT(57)
-                 61 CLEANUP_THROW
-            >>   62 END_SEND
-                 63 POP_TOP
-                 64 JUMP_FORWARD         (86)
-                 65 PUSH_EXC_INFO
-                 66 WITH_EXCEPT_START
-                 67 GET_AWAITABLE
-                 68 LOAD_CONST           (None)
-            >>   69 SEND                 (74)
-                 70 YIELD_VALUE          (1)
-                 71 RESUME               (3)
-                 72 JUMP_BACKWARD_NO_INTERRUPT(69)
-                 73 CLEANUP_THROW
-            >>   74 END_SEND
-                 75 TO_BOOL
-                 76 POP_JUMP_IF_TRUE     (78)
-                 77 RERAISE              (2)
-            >>   78 POP_TOP
-                 79 POP_EXCEPT
-                 80 POP_TOP
-                 81 POP_TOP
-                 82 JUMP_FORWARD         (86)
-                 83 COPY                 (3)
-                 84 POP_EXCEPT
-                 85 RERAISE              (1)
-            >>   86 JUMP_FORWARD         (112)
-                 87 PUSH_EXC_INFO
+  6              96 LOAD_FAST            (0, stop_exc)
+                 97 RAISE_VARARGS        (Raise)
 
-  7              88 LOAD_GLOBAL          (6, Exception)
-                 89 CHECK_EXC_MATCH
-                 90 POP_JUMP_IF_FALSE    (108)
-                 91 STORE_FAST           (1, ex)
+  2              98 END_FOR
+                 99 POP_ITER
+                100 LOAD_CONST           (None)
+                101 RETURN_VALUE
 
-  8              92 LOAD_GLOBAL          (2, self)
-                 93 LOAD_ATTR            (15, assertIs, method=true)
-                 94 LOAD_FAST_BORROW     (1, ex)
-                 95 LOAD_FAST_BORROW     (0, stop_exc)
-                 96 CALL                 (2)
-                 97 POP_TOP
-                 98 JUMP_FORWARD         (103)
-                 99 LOAD_CONST           (None)
-                100 STORE_FAST           (1, ex)
-                101 DELETE_FAST          (1, ex)
-                102 RAISE_VARARGS        (ReraiseFromStack)
-            >>  103 POP_EXCEPT
-                104 LOAD_CONST           (None)
-                105 STORE_FAST           (1, ex)
-                106 DELETE_FAST          (1, ex)
-                107 JUMP_FORWARD         (120)
-            >>  108 RAISE_VARARGS        (ReraiseFromStack)
-                109 COPY                 (3)
-                110 POP_EXCEPT
-                111 RAISE_VARARGS        (ReraiseFromStack)
+  5             102 CLEANUP_THROW
+                103 JUMP_BACKWARD_NO_INTERRUPT(10)
+                104 PUSH_EXC_INFO
+                105 WITH_EXCEPT_START
+                106 GET_AWAITABLE        (2)
+                107 LOAD_CONST           (None)
+                108 SEND                 (4)
+                109 CACHE
+                110 YIELD_VALUE          (1)
+                111 RESUME               (3)
+                112 JUMP_BACKWARD_NO_INTERRUPT(5)
+                113 CLEANUP_THROW
+                114 END_SEND
+                115 TO_BOOL
+                116 CACHE
+                117 CACHE
+                118 CACHE
+                119 POP_JUMP_IF_TRUE     (2)
+                120 CACHE
+                121 NOT_TAKEN
+                122 RERAISE              (2)
+                123 POP_TOP
+                124 POP_EXCEPT
+                125 POP_TOP
+                126 POP_TOP
+                127 POP_TOP
+                128 JUMP_FORWARD         (48)
+                129 COPY                 (3)
+                130 POP_EXCEPT
+                131 RERAISE              (1)
+                132 PUSH_EXC_INFO
 
- 10         >>  112 LOAD_GLOBAL          (2, self)
-                113 LOAD_ATTR            (17, fail, method=true)
-                114 LOAD_FAST_BORROW     (0, stop_exc)
-                115 FORMAT_SIMPLE
-                116 LOAD_CONST           (" was suppressed")
-                117 BUILD_STRING         (2)
-                118 CALL                 (1)
-                119 POP_TOP
+  7             133 LOAD_GLOBAL          (12, Exception)
+                134 CACHE
+                135 CACHE
+                136 CACHE
+                137 CACHE
+                138 CHECK_EXC_MATCH
+                139 POP_JUMP_IF_FALSE    (32)
+                140 CACHE
+                141 NOT_TAKEN
+                142 STORE_FAST           (1, ex)
 
-  3         >>  120 PUSH_NULL
-                121 LOAD_CONST           (None)
-                122 LOAD_CONST           (None)
-                123 LOAD_CONST           (None)
-                124 CALL                 (3)
-                125 POP_TOP
-                126 JUMP_FORWARD         (140)
-                127 PUSH_EXC_INFO
-                128 WITH_EXCEPT_START
-                129 TO_BOOL
-                130 POP_JUMP_IF_TRUE     (132)
-                131 RERAISE              (2)
-            >>  132 POP_TOP
-                133 POP_EXCEPT
-                134 POP_TOP
-                135 POP_TOP
-                136 JUMP_FORWARD         (140)
-                137 COPY                 (3)
-                138 POP_EXCEPT
-                139 RERAISE              (1)
-            >>  140 JUMP_BACKWARD        (13)
-            >>  141 END_FOR
-                142 POP_ITER
-                143 LOAD_CONST           (None)
-                144 RETURN_VALUE
+  8             143 LOAD_GLOBAL          (4, self)
+                144 CACHE
+                145 CACHE
+                146 CACHE
+                147 CACHE
+                148 LOAD_ATTR            (15, assertIs, method=true)
+                149 CACHE
+                150 CACHE
+                151 CACHE
+                152 CACHE
+                153 CACHE
+                154 CACHE
+                155 CACHE
+                156 CACHE
+                157 CACHE
+                158 LOAD_FAST_LOAD_FAST  (ex, stop_exc)
+                159 CALL                 (2)
+                160 CACHE
+                161 CACHE
+                162 CACHE
+                163 POP_TOP
+                164 POP_EXCEPT
+                165 LOAD_CONST           (None)
+                166 STORE_FAST           (1, ex)
+                167 DELETE_FAST          (1, ex)
+                168 JUMP_FORWARD         (32)
+                169 LOAD_CONST           (None)
+                170 STORE_FAST           (1, ex)
+                171 DELETE_FAST          (1, ex)
+                172 RERAISE              (1)
+                173 RERAISE              (0)
+                174 COPY                 (3)
+                175 POP_EXCEPT
+                176 RERAISE              (1)
+
+ 10             177 LOAD_GLOBAL          (4, self)
+                178 CACHE
+                179 CACHE
+                180 CACHE
+                181 CACHE
+                182 LOAD_ATTR            (17, fail, method=true)
+                183 CACHE
+                184 CACHE
+                185 CACHE
+                186 CACHE
+            >>  187 CACHE
+                188 CACHE
+                189 CACHE
+                190 CACHE
+                191 CACHE
+                192 LOAD_FAST_BORROW     (0, stop_exc)
+                193 FORMAT_SIMPLE
+                194 LOAD_CONST           (" was suppressed")
+                195 BUILD_STRING         (2)
+                196 CALL                 (1)
+                197 CACHE
+                198 CACHE
+                199 CACHE
+                200 POP_TOP
+                201 NOP
+
+  3             202 LOAD_CONST           (None)
+                203 LOAD_CONST           (None)
+            >>  204 LOAD_CONST           (None)
+                205 CALL                 (3)
+                206 CACHE
+                207 CACHE
+                208 CACHE
+                209 POP_TOP
+                210 JUMP_BACKWARD        (187)
+                211 CACHE
+                212 PUSH_EXC_INFO
+                213 WITH_EXCEPT_START
+                214 TO_BOOL
+                215 CACHE
+                216 CACHE
+                217 CACHE
+                218 POP_JUMP_IF_TRUE     (2)
+                219 CACHE
+                220 NOT_TAKEN
+                221 RERAISE              (2)
+                222 POP_TOP
+                223 POP_EXCEPT
+                224 POP_TOP
+                225 POP_TOP
+                226 POP_TOP
+                227 JUMP_BACKWARD        (204)
+                228 CACHE
+                229 COPY                 (3)
+                230 POP_EXCEPT
+                231 RERAISE              (1)
+
+  2             232 CALL_INTRINSIC_1     (StopIterationError)
+                233 RERAISE              (1)
 
               2 MAKE_FUNCTION
               3 STORE_NAME           (0, test)
diff --git a/crates/codegen/src/string_parser.rs b/crates/codegen/src/string_parser.rs
index 7e1558d2b17..a7ad8c35a46 100644
--- a/crates/codegen/src/string_parser.rs
+++ b/crates/codegen/src/string_parser.rs
@@ -273,8 +273,15 @@ impl StringParser {
 }
 
 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()];
+    let opener_len = flags.opener_len().to_usize();
+    let quote_len = flags.quote_len().to_usize();
+    if source.len() < opener_len + quote_len {
+        // Source unavailable (e.g., compiling from an AST object with no
+        // backing source text).  Return the raw source as-is.
+        return Box::<Wtf8>::from(source);
+    }
+    let source = &source[opener_len..];
+    let source = &source[..source.len() - quote_len];
     StringParser::new(source.into(), flags)
         .parse_string()
         .unwrap_or_else(|x| match x {})
diff --git a/crates/codegen/src/symboltable.rs b/crates/codegen/src/symboltable.rs
index 2b243262b3c..f8d7a2b26ea 100644
--- a/crates/codegen/src/symboltable.rs
+++ b/crates/codegen/src/symboltable.rs
@@ -8,7 +8,7 @@ Inspirational file: https://github.com/python/cpython/blob/main/Python/symtable.
 */
 
 use crate::{
-    IndexMap,
+    IndexMap, IndexSet,
     error::{CodegenError, CodegenErrorType},
 };
 use alloc::{borrow::Cow, fmt};
@@ -16,7 +16,6 @@ use bitflags::bitflags;
 use ruff_python_ast as 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)]
@@ -55,6 +54,9 @@ pub struct SymbolTable {
     /// Whether this type param scope can see the parent class scope
     pub can_see_class_scope: bool,
 
+    /// Whether this scope contains yield/yield from (is a generator function)
+    pub is_generator: bool,
+
     /// Whether this comprehension scope should be inlined (PEP 709)
     /// True for list/set/dict comprehensions in non-generator expressions
     pub comp_inlined: bool,
@@ -69,6 +71,11 @@ pub struct SymbolTable {
 
     /// Whether `from __future__ import annotations` is active
     pub future_annotations: bool,
+
+    /// Names of type parameters that should still be mangled in type param scopes.
+    /// When Some, only names in this set are mangled; other names are left unmangled.
+    /// Set on type param blocks for generic classes; inherited by non-class child scopes.
+    pub mangled_names: Option<IndexSet<String>>,
 }
 
 impl SymbolTable {
@@ -85,10 +92,12 @@ impl SymbolTable {
             needs_class_closure: false,
             needs_classdict: false,
             can_see_class_scope: false,
+            is_generator: false,
             comp_inlined: false,
             annotation_block: None,
             has_conditional_annotations: false,
             future_annotations: false,
+            mangled_names: None,
         }
     }
 
@@ -275,30 +284,126 @@ fn analyze_symbol_table(symbol_table: &mut SymbolTable) -> SymbolTableResult {
    `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, newfree: &mut HashSet<String>) {
+fn drop_class_free(symbol_table: &mut SymbolTable, newfree: &mut IndexSet<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__") {
+    if newfree.shift_remove("__class__") {
         symbol_table.needs_class_closure = true;
     }
 
     // Check if __classdict__ is in the free variables collected from children
-    if newfree.remove("__classdict__") {
+    if newfree.shift_remove("__classdict__") {
         symbol_table.needs_classdict = true;
     }
 
+    // Classes with function definitions need __classdict__ for PEP 649
+    // (but not when `from __future__ import annotations` is active)
+    if !symbol_table.needs_classdict && !symbol_table.future_annotations {
+        let has_functions = symbol_table.sub_tables.iter().any(|t| {
+            matches!(
+                t.typ,
+                CompilerScope::Function | CompilerScope::AsyncFunction
+            )
+        });
+        if has_functions {
+            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__") {
+    if newfree.shift_remove("__conditional_annotations__") {
         symbol_table.has_conditional_annotations = true;
     }
 }
 
+/// Check if an expression contains an `await` node (shallow, not into nested scopes).
+fn expr_contains_await(expr: &ast::Expr) -> bool {
+    use ast::visitor::Visitor;
+    struct AwaitFinder(bool);
+    impl ast::visitor::Visitor<'_> for AwaitFinder {
+        fn visit_expr(&mut self, expr: &ast::Expr) {
+            if !self.0 {
+                if matches!(expr, ast::Expr::Await(_)) {
+                    self.0 = true;
+                } else {
+                    ast::visitor::walk_expr(self, expr);
+                }
+            }
+        }
+    }
+    let mut finder = AwaitFinder(false);
+    finder.visit_expr(expr);
+    finder.0
+}
+
+/// PEP 709: Merge symbols from an inlined comprehension into the parent scope.
+/// Matches symtable.c inline_comprehension().
+fn inline_comprehension(
+    parent_symbols: &mut SymbolMap,
+    comp: &SymbolTable,
+    comp_free: &mut IndexSet<String>,
+    inlined_cells: &mut IndexSet<String>,
+    parent_type: CompilerScope,
+) {
+    for (name, sub_symbol) in &comp.symbols {
+        // Skip the .0 parameter
+        if sub_symbol.flags.contains(SymbolFlags::PARAMETER) {
+            continue;
+        }
+
+        // Track inlined cells
+        if sub_symbol.scope == SymbolScope::Cell
+            || sub_symbol.flags.contains(SymbolFlags::COMP_CELL)
+        {
+            inlined_cells.insert(name.clone());
+        }
+
+        // Handle __class__ in ClassBlock
+        let scope = if sub_symbol.scope == SymbolScope::Free
+            && parent_type == CompilerScope::Class
+            && name == "__class__"
+        {
+            comp_free.swap_remove(name);
+            SymbolScope::GlobalImplicit
+        } else {
+            sub_symbol.scope
+        };
+
+        if let Some(existing) = parent_symbols.get(name) {
+            // Name exists in parent
+            if existing.is_bound() && parent_type != CompilerScope::Class {
+                // Check if the name is free in any child of the comprehension
+                let is_free_in_child = comp.sub_tables.iter().any(|child| {
+                    child
+                        .symbols
+                        .get(name)
+                        .is_some_and(|s| s.scope == SymbolScope::Free)
+                });
+                if !is_free_in_child {
+                    comp_free.swap_remove(name);
+                }
+            }
+        } else {
+            // Name doesn't exist in parent, copy from comprehension.
+            // Reset scope to Unknown so analyze_symbol will resolve it
+            // in the parent's context.
+            let mut symbol = sub_symbol.clone();
+            symbol.scope = if sub_symbol.is_bound() {
+                SymbolScope::Unknown
+            } else {
+                scope
+            };
+            parent_symbols.insert(name.clone(), symbol);
+        }
+    }
+}
+
 type SymbolMap = IndexMap<String, Symbol>;
 
 mod stack {
+    use alloc::vec::Vec;
     use core::ptr::NonNull;
-    use std::panic;
     pub struct StackStack<T> {
         v: Vec<NonNull<T>>,
     }
@@ -310,14 +415,30 @@ mod stack {
     impl<T> StackStack<T> {
         /// Appends a reference to this stack for the duration of the function `f`. When `f`
         /// returns, the reference will be popped off the stack.
+        #[cfg(feature = "std")]
         pub fn with_append<F, R>(&mut self, x: &mut T, f: F) -> R
         where
             F: FnOnce(&mut Self) -> R,
         {
             self.v.push(x.into());
-            let res = panic::catch_unwind(panic::AssertUnwindSafe(|| f(self)));
+            let res = std::panic::catch_unwind(core::panic::AssertUnwindSafe(|| f(self)));
             self.v.pop();
-            res.unwrap_or_else(|x| panic::resume_unwind(x))
+            res.unwrap_or_else(|x| std::panic::resume_unwind(x))
+        }
+
+        /// Appends a reference to this stack for the duration of the function `f`. When `f`
+        /// returns, the reference will be popped off the stack.
+        ///
+        /// Without std, panic cleanup is not guaranteed (no catch_unwind).
+        #[cfg(not(feature = "std"))]
+        pub fn with_append<F, R>(&mut self, x: &mut T, f: F) -> R
+        where
+            F: FnOnce(&mut Self) -> R,
+        {
+            self.v.push(x.into());
+            let result = f(self);
+            self.v.pop();
+            result
         }
 
         pub fn iter(&self) -> impl DoubleEndedIterator<Item = &T> + '_ {
@@ -367,100 +488,119 @@ impl SymbolTableAnalyzer {
         &mut self,
         symbol_table: &mut SymbolTable,
         class_entry: Option<&SymbolMap>,
-    ) -> SymbolTableResult<HashSet<String>> {
+    ) -> SymbolTableResult<IndexSet<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 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)
-        {
+        // Clone class symbols if needed for child scopes with can_see_class_scope
+        let needs_class_symbols = (is_class
+            && (sub_tables.iter().any(|st| st.can_see_class_scope)
+                || annotation_block
+                    .as_ref()
+                    .is_some_and(|b| b.can_see_class_scope)))
+            || (!is_class
+                && class_entry.is_some()
+                && sub_tables.iter().any(|st| st.can_see_class_scope));
+
+        let class_symbols_clone = if is_class && needs_class_symbols {
             Some(symbols.clone())
         } else {
             None
         };
 
+        // Collect (child_free, is_inlined) pairs from child scopes.
+        // We need to process inlined comprehensions after the closure
+        // when we have access to symbol_table.symbols.
+        let mut child_frees: Vec<(IndexSet<String>, bool)> = Vec::new();
+        let mut annotation_free: Option<IndexSet<String>> = 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() {
-                // 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);
+                let child_class_entry = if sub_table.can_see_class_scope {
+                    if is_class {
+                        class_symbols_clone.as_ref()
+                    } else {
+                        class_entry
+                    }
+                } else {
+                    None
+                };
+                let child_free = inner_scope.analyze_symbol_table(sub_table, child_class_entry)?;
+                child_frees.push((child_free, sub_table.comp_inlined));
             }
             // PEP 649: Analyze annotation block if present
             if let Some(annotation_table) = annotation_block {
-                // 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 ann_class_entry = if annotation_table.can_see_class_scope {
+                    if is_class {
+                        class_symbols_clone.as_ref()
+                    } else {
+                        class_entry
+                    }
+                } else {
+                    None
+                };
                 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);
+                annotation_free = Some(child_free);
             }
             Ok(())
         })?;
 
         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);
-                    }
-                }
+        // PEP 709: Process inlined comprehensions.
+        // Merge symbols from inlined comps into parent scope without bail-out.
+        let mut inlined_cells: IndexSet<String> = IndexSet::default();
+        let mut newfree = IndexSet::default();
+        for (idx, (mut child_free, is_inlined)) in child_frees.into_iter().enumerate() {
+            if is_inlined {
+                inline_comprehension(
+                    &mut symbol_table.symbols,
+                    &sub_tables[idx],
+                    &mut child_free,
+                    &mut inlined_cells,
+                    symbol_table.typ,
+                );
             }
+            newfree.extend(child_free);
+        }
+        if let Some(ann_free) = annotation_free {
+            // Propagate annotation-scope free names to this scope so
+            // implicit class-scope cells (__classdict__/__conditional_annotations__)
+            // can be materialized by drop_class_free when needed.
+            newfree.extend(ann_free);
         }
 
+        let sub_tables = &*symbol_table.sub_tables;
+
         // Analyze symbols in current scope
         for symbol in symbol_table.symbols.values_mut() {
             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
             if symbol.scope == SymbolScope::Free || symbol.flags.contains(SymbolFlags::FREE_CLASS) {
                 newfree.insert(symbol.name.clone());
             }
         }
 
+        // PEP 709: Promote LOCAL to CELL and set COMP_CELL for inlined cell vars
+        for symbol in symbol_table.symbols.values_mut() {
+            if inlined_cells.contains(&symbol.name) {
+                if symbol.scope == SymbolScope::Local {
+                    symbol.scope = SymbolScope::Cell;
+                }
+                symbol.flags.insert(SymbolFlags::COMP_CELL);
+            }
+        }
+
         // 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, &mut newfree);
         }
@@ -491,7 +631,6 @@ impl SymbolTableAnalyzer {
                     if !self.tables.as_ref().is_empty() {
                         let scope_depth = self.tables.as_ref().len();
                         // check if the name is already defined in any outer scope
-                        // therefore
                         if scope_depth < 2
                             || self.found_in_outer_scope(&symbol.name, st_typ)
                                 != Some(SymbolScope::Free)
@@ -502,6 +641,25 @@ impl SymbolTableAnalyzer {
                                 location: None,
                             });
                         }
+                        // Check if the nonlocal binding refers to a type parameter
+                        if symbol.flags.contains(SymbolFlags::NONLOCAL) {
+                            for (symbols, _typ) in self.tables.iter().rev() {
+                                if let Some(sym) = symbols.get(&symbol.name) {
+                                    if sym.flags.contains(SymbolFlags::TYPE_PARAM) {
+                                        return Err(SymbolTableError {
+                                            error: format!(
+                                                "nonlocal binding not allowed for type parameter '{}'",
+                                                symbol.name
+                                            ),
+                                            location: None,
+                                        });
+                                    }
+                                    if sym.is_bound() {
+                                        break;
+                                    }
+                                }
+                            }
+                        }
                     } else {
                         return Err(SymbolTableError {
                             error: format!(
@@ -520,24 +678,21 @@ 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, st_typ) {
+                        // If found in enclosing scope (function/TypeParams), use that
                         scope
+                    } else if let Some(class_symbols) = class_entry
+                        && let Some(class_sym) = class_symbols.get(&symbol.name)
+                        && class_sym.is_bound()
+                        && class_sym.scope != SymbolScope::Free
+                    {
+                        // If name is bound in enclosing class, use GlobalImplicit
+                        // so it can be accessed via __classdict__
+                        SymbolScope::GlobalImplicit
                     } else if self.tables.is_empty() {
                         // Don't make assumptions when we don't know.
                         SymbolScope::Unknown
@@ -607,6 +762,12 @@ impl SymbolTableAnalyzer {
         if let Some(decl_depth) = decl_depth {
             // decl_depth is the number of tables between the current one and
             // the one that declared the cell var
+            // For implicit class scope variables (__classdict__, __conditional_annotations__),
+            // only propagate free to annotation/type-param scopes, not regular functions.
+            // Regular method functions don't need these in their freevars.
+            let is_class_implicit =
+                name == "__classdict__" || name == "__conditional_annotations__";
+
             for (table, typ) in self.tables.iter_mut().rev().take(decl_depth) {
                 if let CompilerScope::Class = typ {
                     if let Some(free_class) = table.get_mut(name) {
@@ -617,10 +778,19 @@ impl SymbolTableAnalyzer {
                         symbol.scope = SymbolScope::Free;
                         table.insert(name.to_owned(), symbol);
                     }
+                } else if is_class_implicit
+                    && matches!(
+                        typ,
+                        CompilerScope::Function
+                            | CompilerScope::AsyncFunction
+                            | CompilerScope::Lambda
+                    )
+                {
+                    // Skip: don't add __classdict__/__conditional_annotations__
+                    // as free vars in regular functions — only annotation/type scopes need them
                 } else if !table.contains_key(name) {
                     let mut symbol = Symbol::new(name);
                     symbol.scope = SymbolScope::Free;
-                    // symbol.is_referenced = true;
                     table.insert(name.to_owned(), symbol);
                 }
             }
@@ -636,6 +806,11 @@ impl SymbolTableAnalyzer {
         st_typ: CompilerScope,
     ) -> Option<SymbolScope> {
         sub_tables.iter().find_map(|st| {
+            // PEP 709: For inlined comprehensions, check their children
+            // instead of the comp itself (its symbols are merged into parent).
+            if st.comp_inlined {
+                return self.found_in_inner_scope(&st.sub_tables, name, st_typ);
+            }
             let sym = st.symbols.get(name)?;
             if sym.scope == SymbolScope::Free || sym.flags.contains(SymbolFlags::FREE_CLASS) {
                 if st_typ == CompilerScope::Class && name != "__class__" {
@@ -853,14 +1028,27 @@ impl SymbolTableBuilder {
                     )
             })
             .unwrap_or(false);
-        let table = SymbolTable::new(name.to_owned(), typ, line_number, is_nested);
+        // Inherit mangled_names from parent for non-class scopes
+        let inherited_mangled_names = self
+            .tables
+            .last()
+            .and_then(|t| t.mangled_names.clone())
+            .filter(|_| typ != CompilerScope::Class);
+        let mut table = SymbolTable::new(name.to_owned(), typ, line_number, is_nested);
+        table.future_annotations = self.future_annotations;
+        table.mangled_names = inherited_mangled_names;
         self.tables.push(table);
         // 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 {
+    fn enter_type_param_block(
+        &mut self,
+        name: &str,
+        line_number: u32,
+        for_class: bool,
+    ) -> SymbolTableResult {
         // Check if we're in a class scope
         let in_class = self
             .tables
@@ -869,16 +1057,21 @@ impl SymbolTableBuilder {
 
         self.enter_scope(name, CompilerScope::TypeParams, line_number);
 
-        // If we're in a class, mark that this type param scope can see the class scope
+        // Set properties on the newly created type param scope
         if let Some(table) = self.tables.last_mut() {
             table.can_see_class_scope = in_class;
-
-            // Add __classdict__ as a USE symbol in type param scope if in class
-            if in_class {
-                self.register_name("__classdict__", SymbolUsage::Used, TextRange::default())?;
+            // For generic classes, create mangled_names set so that only
+            // type parameter names get mangled (not bases or other expressions)
+            if for_class {
+                table.mangled_names = Some(IndexSet::default());
             }
         }
 
+        // Add __classdict__ as a USE symbol in type param scope if in class
+        if in_class {
+            self.register_name("__classdict__", SymbolUsage::Used, TextRange::default())?;
+        }
+
         // Register .type_params as a SET symbol (it will be converted to cell variable later)
         self.register_name(".type_params", SymbolUsage::Assigned, TextRange::default())?;
 
@@ -899,7 +1092,8 @@ impl SymbolTableBuilder {
     /// 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;
+        let can_see_class_scope =
+            current.typ == CompilerScope::Class || current.can_see_class_scope;
         let has_conditional = current.has_conditional_annotations;
 
         // Create annotation block if not exists
@@ -973,6 +1167,31 @@ impl SymbolTableBuilder {
             .insert(SymbolFlags::REFERENCED | SymbolFlags::FREE_CLASS);
     }
 
+    /// Walk up the scope chain to determine if we're inside an async function.
+    /// Annotation and TypeParams scopes act as async barriers (always non-async).
+    /// Comprehension scopes are transparent (inherit parent's async context).
+    fn is_in_async_context(&self) -> bool {
+        // Annotations are evaluated in a non-async scope even when
+        // the enclosing function is async.
+        if self.in_annotation {
+            return false;
+        }
+        for table in self.tables.iter().rev() {
+            match table.typ {
+                CompilerScope::AsyncFunction => return true,
+                CompilerScope::Function
+                | CompilerScope::Lambda
+                | CompilerScope::Class
+                | CompilerScope::Module
+                | CompilerScope::Annotation
+                | CompilerScope::TypeParams => return false,
+                // Comprehension inherits parent's async context
+                CompilerScope::Comprehension => continue,
+            }
+        }
+        false
+    }
+
     fn line_index_start(&self, range: TextRange) -> u32 {
         self.source_file
             .to_source_code()
@@ -1012,7 +1231,7 @@ impl SymbolTableBuilder {
         if table.symbols.contains_key(parameter.name.as_str()) {
             return Err(SymbolTableError {
                 error: format!(
-                    "duplicate parameter '{}' in function definition",
+                    "duplicate argument '{}' in function definition",
                     parameter.name
                 ),
                 location: Some(
@@ -1027,19 +1246,35 @@ impl SymbolTableBuilder {
     }
 
     fn scan_annotation(&mut self, annotation: &ast::Expr) -> SymbolTableResult {
+        self.scan_annotation_inner(annotation, false)
+    }
+
+    /// Scan an annotation from an AnnAssign statement (can be conditional)
+    fn scan_ann_assign_annotation(&mut self, annotation: &ast::Expr) -> SymbolTableResult {
+        self.scan_annotation_inner(annotation, true)
+    }
+
+    fn scan_annotation_inner(
+        &mut self,
+        annotation: &ast::Expr,
+        is_ann_assign: bool,
+    ) -> SymbolTableResult {
         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 {
+        // PEP 649: Only AnnAssign annotations can be conditional.
+        // Function parameter/return annotations are never conditional.
+        if is_ann_assign && !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::Assigned,
+                    annotation.range(),
+                )?;
                 self.register_name(
                     "__conditional_annotations__",
                     SymbolUsage::Used,
@@ -1069,15 +1304,6 @@ impl SymbolTableBuilder {
 
         self.leave_annotation_scope();
 
-        // 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
     }
 
@@ -1121,7 +1347,10 @@ impl SymbolTableBuilder {
                 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)
+                    Some(CompilerScope::Class)
+                        | Some(CompilerScope::Module)
+                        | Some(CompilerScope::Function)
+                        | Some(CompilerScope::AsyncFunction)
                 );
                 let saved_annotation_block = if should_save_annotation_block {
                     self.tables.last_mut().unwrap().annotation_block.take()
@@ -1129,12 +1358,20 @@ impl SymbolTableBuilder {
                     None
                 };
 
+                // For generic functions, scan defaults before entering type_param_block
+                // (defaults are evaluated in the enclosing scope, not the type param scope)
+                let has_type_params = type_params.is_some();
+                if has_type_params {
+                    self.scan_parameter_defaults(parameters)?;
+                }
+
                 // 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()),
                         self.line_index_start(type_params.range),
+                        false,
                     )?;
                     self.scan_type_params(type_params)?;
                 }
@@ -1150,6 +1387,7 @@ impl SymbolTableBuilder {
                     self.line_index_start(*range),
                     has_return_annotation,
                     *is_async,
+                    has_type_params, // skip_defaults: already scanned above
                 )?;
                 self.scan_statements(body)?;
                 self.leave_scope();
@@ -1171,11 +1409,16 @@ impl SymbolTableBuilder {
                 range,
                 node_index: _,
             }) => {
+                // Save class_name for the entire ClassDef processing
+                let prev_class = self.class_name.take();
                 if let Some(type_params) = type_params {
                     self.enter_type_param_block(
                         &format!("<generic parameters of {}>", name.as_str()),
                         self.line_index_start(type_params.range),
+                        true, // for_class: enable selective mangling
                     )?;
+                    // Set class_name for mangling in type param scope
+                    self.class_name = Some(name.to_string());
                     self.scan_type_params(type_params)?;
                 }
                 self.enter_scope(
@@ -1184,10 +1427,9 @@ impl SymbolTableBuilder {
                     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.class_name = Some(name.to_string());
                 self.register_name("__module__", SymbolUsage::Assigned, *range)?;
                 self.register_name("__qualname__", SymbolUsage::Assigned, *range)?;
                 self.register_name("__doc__", SymbolUsage::Assigned, *range)?;
@@ -1195,7 +1437,13 @@ impl SymbolTableBuilder {
                 self.scan_statements(body)?;
                 self.leave_scope();
                 self.in_conditional_block = saved_in_conditional;
-                self.class_name = prev_class;
+                // For non-generic classes, restore class_name before base scanning.
+                // Bases are evaluated in the enclosing scope, not the class scope.
+                // For generic classes, bases are scanned within the type_param scope
+                // where class_name is already correctly set.
+                if type_params.is_none() {
+                    self.class_name = prev_class.clone();
+                }
                 if let Some(arguments) = arguments {
                     self.scan_expressions(&arguments.args, ExpressionContext::Load)?;
                     for keyword in &arguments.keywords {
@@ -1205,6 +1453,8 @@ impl SymbolTableBuilder {
                 if type_params.is_some() {
                     self.leave_scope();
                 }
+                // Restore class_name after all ClassDef processing
+                self.class_name = prev_class;
                 self.scan_decorators(decorator_list, ExpressionContext::Load)?;
                 self.register_ident(name, SymbolUsage::Assigned)?;
             }
@@ -1345,7 +1595,22 @@ impl SymbolTableBuilder {
                         self.scan_expression(target, ExpressionContext::Store)?;
                     }
                 }
-                self.scan_annotation(annotation)?;
+                // Only scan annotation in annotation scope for simple name targets.
+                // Non-simple annotations (subscript, attribute, parenthesized) are
+                // never compiled into __annotate__, so scanning them would create
+                // sub_tables that cause mismatch in the annotation scope's sub_table index.
+                let is_simple_name = *simple && matches!(&**target, Expr::Name(_));
+                if is_simple_name {
+                    self.scan_ann_assign_annotation(annotation)?;
+                } else {
+                    // Still validate annotation for forbidden expressions
+                    // (yield, await, named) even for non-simple targets.
+                    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?;
+                }
                 if let Some(value) = value {
                     self.scan_expression(value, ExpressionContext::Load)?;
                 }
@@ -1423,16 +1688,38 @@ impl SymbolTableBuilder {
             }) => {
                 let was_in_type_alias = self.in_type_alias;
                 self.in_type_alias = true;
+                // Check before entering any sub-scopes
+                let in_class = self
+                    .tables
+                    .last()
+                    .is_some_and(|t| t.typ == CompilerScope::Class);
+                let is_generic = type_params.is_some();
                 if let Some(type_params) = type_params {
                     self.enter_type_param_block(
                         "TypeAlias",
                         self.line_index_start(type_params.range),
+                        false,
                     )?;
                     self.scan_type_params(type_params)?;
-                    self.scan_expression(value, ExpressionContext::Load)?;
+                }
+                // Value scope for lazy evaluation
+                self.enter_scope(
+                    "TypeAlias",
+                    CompilerScope::TypeParams,
+                    self.line_index_start(value.range()),
+                );
+                // Evaluator takes a format parameter
+                self.register_name("format", SymbolUsage::Parameter, TextRange::default())?;
+                if in_class {
+                    if let Some(table) = self.tables.last_mut() {
+                        table.can_see_class_scope = true;
+                    }
+                    self.register_name("__classdict__", SymbolUsage::Used, TextRange::default())?;
+                }
+                self.scan_expression(value, ExpressionContext::Load)?;
+                self.leave_scope();
+                if is_generic {
                     self.leave_scope();
-                } else {
-                    self.scan_expression(value, ExpressionContext::Load)?;
                 }
                 self.in_type_alias = was_in_type_alias;
                 self.scan_expression(name, ExpressionContext::Store)?;
@@ -1570,6 +1857,7 @@ impl SymbolTableBuilder {
                 node_index: _,
                 range: _,
             }) => {
+                self.tables.last_mut().unwrap().is_generator = true;
                 if let Some(expression) = value {
                     self.scan_expression(expression, context)?;
                 }
@@ -1579,6 +1867,7 @@ impl SymbolTableBuilder {
                 node_index: _,
                 range: _,
             }) => {
+                self.tables.last_mut().unwrap().is_generator = true;
                 self.scan_expression(value, context)?;
             }
             Expr::UnaryOp(ExprUnaryOp {
@@ -1739,6 +2028,7 @@ impl SymbolTableBuilder {
                         self.line_index_start(expression.range()),
                         false, // lambdas have no return annotation
                         false, // lambdas are never async
+                        false, // don't skip defaults
                     )?;
                 } else {
                     self.enter_scope(
@@ -1856,26 +2146,50 @@ impl SymbolTableBuilder {
         range: TextRange,
         is_generator: bool,
     ) -> SymbolTableResult {
+        // Check for async comprehension outside async function
+        // (list/set/dict comprehensions only, not generator expressions)
+        let has_async_gen = generators.iter().any(|g| g.is_async);
+        if has_async_gen && !is_generator && !self.is_in_async_context() {
+            return Err(SymbolTableError {
+                error: "asynchronous comprehension outside of an asynchronous function".to_owned(),
+                location: Some(
+                    self.source_file
+                        .to_source_code()
+                        .source_location(range.start(), PositionEncoding::Utf8),
+                ),
+            });
+        }
+
         // Comprehensions are compiled as functions, so create a scope for them:
         self.enter_scope(
             scope_name,
             CompilerScope::Comprehension,
             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;
+        // Generator expressions need the is_generator flag
+        self.tables.last_mut().unwrap().is_generator = is_generator;
+
+        // PEP 709: Mark non-generator comprehensions for inlining.
+        // Only in function-like scopes for now. Module/class scope inlining
+        // needs more work (Cell name resolution, __class__ handling).
+        // Also excluded: generator expressions, async comprehensions,
+        // and annotation scopes nested in classes (can_see_class_scope).
+        let element_has_await = expr_contains_await(elt1) || elt2.is_some_and(expr_contains_await);
+        if !is_generator && !has_async_gen && !element_has_await {
+            let parent = self.tables.iter().rev().nth(1);
+            let parent_can_see_class = parent.is_some_and(|t| t.can_see_class_scope);
+            let parent_is_func = parent.is_some_and(|t| {
+                matches!(
+                    t.typ,
+                    CompilerScope::Function
+                        | CompilerScope::AsyncFunction
+                        | CompilerScope::Lambda
+                        | CompilerScope::Comprehension
+                )
+            });
+            if !parent_can_see_class && parent_is_func {
+                self.tables.last_mut().unwrap().comp_inlined = true;
+            }
         }
 
         // Register the passed argument to the generator function as the name ".0"
@@ -1925,11 +2239,18 @@ impl SymbolTableBuilder {
     ) -> SymbolTableResult {
         // Enter a new TypeParams scope for the bound/default expression
         // This allows the expression to access outer scope symbols
+        let in_class = self.tables.last().is_some_and(|t| t.can_see_class_scope);
         let line_number = self.line_index_start(expr.range());
         self.enter_scope(scope_name, CompilerScope::TypeParams, line_number);
+        // Evaluator takes a format parameter
+        self.register_name("format", SymbolUsage::Parameter, TextRange::default())?;
 
-        // Note: In CPython, can_see_class_scope is preserved in the new scope
-        // In RustPython, this is handled through the scope hierarchy
+        if in_class {
+            if let Some(table) = self.tables.last_mut() {
+                table.can_see_class_scope = true;
+            }
+            self.register_name("__classdict__", SymbolUsage::Used, TextRange::default())?;
+        }
 
         // Set scope_info for better error messages
         let old_scope_info = self.scope_info;
@@ -1947,12 +2268,16 @@ impl SymbolTableBuilder {
 
     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();
+        let mut seen_names: IndexSet<&str> = IndexSet::default();
+        // Check for non-default type parameter after default type parameter
+        let mut default_seen = false;
         for type_param in &type_params.type_params {
-            let (name, range) = match type_param {
-                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),
+            let (name, range, has_default) = match type_param {
+                ast::TypeParam::TypeVar(tv) => (tv.name.as_str(), tv.range, tv.default.is_some()),
+                ast::TypeParam::ParamSpec(ps) => (ps.name.as_str(), ps.range, ps.default.is_some()),
+                ast::TypeParam::TypeVarTuple(tvt) => {
+                    (tvt.name.as_str(), tvt.range, tvt.default.is_some())
+                }
             };
             if !seen_names.insert(name) {
                 return Err(SymbolTableError {
@@ -1964,6 +2289,21 @@ impl SymbolTableBuilder {
                     ),
                 });
             }
+            if has_default {
+                default_seen = true;
+            } else if default_seen {
+                return Err(SymbolTableError {
+                    error: format!(
+                        "non-default type parameter '{}' follows default 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)
@@ -2099,6 +2439,20 @@ impl SymbolTableBuilder {
         Ok(())
     }
 
+    /// Scan default parameter values (evaluated in the enclosing scope)
+    fn scan_parameter_defaults(&mut self, parameters: &ast::Parameters) -> SymbolTableResult {
+        for default in parameters
+            .posonlyargs
+            .iter()
+            .chain(parameters.args.iter())
+            .chain(parameters.kwonlyargs.iter())
+            .filter_map(|arg| arg.default.as_ref())
+        {
+            self.scan_expression(default, ExpressionContext::Load)?;
+        }
+        Ok(())
+    }
+
     fn enter_scope_with_parameters(
         &mut self,
         name: &str,
@@ -2106,16 +2460,11 @@ impl SymbolTableBuilder {
         line_number: u32,
         has_return_annotation: bool,
         is_async: bool,
+        skip_defaults: bool,
     ) -> SymbolTableResult {
-        // Evaluate eventual default parameters:
-        for default in parameters
-            .posonlyargs
-            .iter()
-            .chain(parameters.args.iter())
-            .chain(parameters.kwonlyargs.iter())
-            .filter_map(|arg| arg.default.as_ref())
-        {
-            self.scan_expression(default, ExpressionContext::Load)?; // not ExprContext?
+        // Evaluate eventual default parameters (unless already scanned before type_param_block):
+        if !skip_defaults {
+            self.scan_parameter_defaults(parameters)?;
         }
 
         // Annotations are scanned in outer scope:
@@ -2247,7 +2596,18 @@ impl SymbolTableBuilder {
         let scope_depth = self.tables.len();
         let table = self.tables.last_mut().unwrap();
 
-        let name = mangle_name(self.class_name.as_deref(), name);
+        // Add type param names to mangled_names set for selective mangling
+        if matches!(role, SymbolUsage::TypeParam)
+            && let Some(ref mut set) = table.mangled_names
+        {
+            set.insert(name.to_owned());
+        }
+
+        let name = maybe_mangle_name(
+            self.class_name.as_deref(),
+            table.mangled_names.as_ref(),
+            name,
+        );
         // 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;
@@ -2440,11 +2800,27 @@ pub(crate) fn mangle_name<'a>(class_name: Option<&str>, name: &'a str) -> Cow<'a
     if !name.starts_with("__") || name.ends_with("__") || name.contains('.') {
         return name.into();
     }
-    // strip leading underscore
-    let class_name = class_name.strip_prefix(|c| c == '_').unwrap_or(class_name);
+    // Strip leading underscores from class name
+    let class_name = class_name.trim_start_matches('_');
     let mut ret = String::with_capacity(1 + class_name.len() + name.len());
     ret.push('_');
     ret.push_str(class_name);
     ret.push_str(name);
     ret.into()
 }
+
+/// Selective mangling for type parameter scopes around generic classes.
+/// If `mangled_names` is Some, only mangle names that are in the set;
+/// other names are left unmangled.
+pub(crate) fn maybe_mangle_name<'a>(
+    class_name: Option<&str>,
+    mangled_names: Option<&IndexSet<String>>,
+    name: &'a str,
+) -> Cow<'a, str> {
+    if let Some(set) = mangled_names
+        && !set.contains(name)
+    {
+        return name.into();
+    }
+    mangle_name(class_name, name)
+}
diff --git a/crates/codegen/src/unparse.rs b/crates/codegen/src/unparse.rs
index eef2128587a..a590323cb78 100644
--- a/crates/codegen/src/unparse.rs
+++ b/crates/codegen/src/unparse.rs
@@ -363,7 +363,7 @@ impl<'a, 'b, 'c> Unparser<'a, 'b, 'c> {
                 self.p(")")?;
             }
             ast::Expr::FString(ast::ExprFString { value, .. }) => self.unparse_fstring(value)?,
-            ast::Expr::TString(_) => self.p("t\"\"")?,
+            ast::Expr::TString(ast::ExprTString { value, .. }) => self.unparse_tstring(value)?,
             ast::Expr::StringLiteral(ast::ExprStringLiteral { value, .. }) => {
                 if value.is_unicode() {
                     self.p("u")?
@@ -561,7 +561,19 @@ impl<'a, 'b, 'c> Unparser<'a, 'b, 'c> {
             // put a space to avoid escaping the bracket
             "{ "
         } else {
-            "{"
+            // Preserve leading whitespace between '{' and the expression
+            let source_text = self.source.source_text();
+            let start = val.range().start().to_usize();
+            if start > 0
+                && source_text
+                    .as_bytes()
+                    .get(start - 1)
+                    .is_some_and(|b| b.is_ascii_whitespace())
+            {
+                "{ "
+            } else {
+                "{"
+            }
         };
         self.p(brace)?;
         self.p(&buffered)?;
@@ -626,6 +638,19 @@ impl<'a, 'b, 'c> Unparser<'a, 'b, 'c> {
             .str_repr()
             .write(self.f)
     }
+
+    fn unparse_tstring(&mut self, value: &ast::TStringValue) -> fmt::Result {
+        self.p("t")?;
+        let body = fmt::from_fn(|f| {
+            value.iter().try_for_each(|tstring| {
+                Unparser::new(f, self.source).unparse_fstring_body(&tstring.elements)
+            })
+        })
+        .to_string();
+        UnicodeEscape::new_repr(body.as_str().as_ref())
+            .str_repr()
+            .write(self.f)
+    }
 }
 
 pub struct UnparseExpr<'a> {
diff --git a/crates/common/Cargo.toml b/crates/common/Cargo.toml
index 9fd7ea3880a..555336f059a 100644
--- a/crates/common/Cargo.toml
+++ b/crates/common/Cargo.toml
@@ -9,7 +9,9 @@ repository.workspace = true
 license.workspace = true
 
 [features]
-threading = ["parking_lot"]
+default = ["std"]
+std = []
+threading = ["parking_lot", "std"]
 wasm_js = ["getrandom/wasm_js"]
 
 [dependencies]
@@ -26,7 +28,6 @@ malachite-bigint = { workspace = true }
 malachite-q = { workspace = true }
 malachite-base = { workspace = true }
 num-traits = { workspace = true }
-once_cell = { workspace = true }
 parking_lot = { workspace = true, optional = true }
 unicode_names2 = { workspace = true }
 radium = { workspace = true }
diff --git a/crates/common/src/crt_fd.rs b/crates/common/src/crt_fd.rs
index 7c93a30bb65..ab7c94f8b3b 100644
--- a/crates/common/src/crt_fd.rs
+++ b/crates/common/src/crt_fd.rs
@@ -64,8 +64,8 @@ type BorrowedInner<'fd> = BorrowedFd<'fd>;
 #[cfg(windows)]
 mod win {
     use super::*;
-    use std::marker::PhantomData;
-    use std::mem::ManuallyDrop;
+    use core::marker::PhantomData;
+    use core::mem::ManuallyDrop;
 
     #[repr(transparent)]
     pub(super) struct OwnedInner(i32);
diff --git a/crates/common/src/encodings.rs b/crates/common/src/encodings.rs
index c2f139b6bb9..913f0521e16 100644
--- a/crates/common/src/encodings.rs
+++ b/crates/common/src/encodings.rs
@@ -441,13 +441,22 @@ pub mod errors {
             let err_str = &ctx.full_data()[range.start.bytes..range.end.bytes];
             let num_chars = range.end.chars - range.start.chars;
             let mut out = Vec::with_capacity(num_chars);
+            let mut pos = range.start;
             for ch in err_str.code_points() {
-                let ch = ch.to_u32();
-                if !(0xdc80..=0xdcff).contains(&ch) {
-                    // Not a UTF-8b surrogate, fail with original exception
-                    return Err(ctx.error_encoding(range, reason));
+                let ch_u32 = ch.to_u32();
+                if !(0xdc80..=0xdcff).contains(&ch_u32) {
+                    if out.is_empty() {
+                        // Can't handle even the first character
+                        return Err(ctx.error_encoding(range, reason));
+                    }
+                    // Return partial result, restart from this character
+                    return Ok((EncodeReplace::Bytes(ctx.bytes(out)), pos));
                 }
-                out.push((ch - 0xdc00) as u8);
+                out.push((ch_u32 - 0xdc00) as u8);
+                pos += StrSize {
+                    bytes: ch.len_wtf8(),
+                    chars: 1,
+                };
             }
             Ok((EncodeReplace::Bytes(ctx.bytes(out)), range.end))
         }
diff --git a/crates/common/src/fileutils.rs b/crates/common/src/fileutils.rs
index af9e5ad2d96..a20140a6e04 100644
--- a/crates/common/src/fileutils.rs
+++ b/crates/common/src/fileutils.rs
@@ -24,8 +24,9 @@ pub fn fstat(fd: crate::crt_fd::Borrowed<'_>) -> std::io::Result<StatStruct> {
 pub mod windows {
     use crate::crt_fd;
     use crate::windows::ToWideString;
+    use alloc::ffi::CString;
     use libc::{S_IFCHR, S_IFDIR, S_IFMT};
-    use std::ffi::{CString, OsStr, OsString};
+    use std::ffi::{OsStr, OsString};
     use std::os::windows::io::AsRawHandle;
     use std::sync::OnceLock;
     use windows_sys::Win32::Foundation::{
@@ -119,9 +120,9 @@ pub mod windows {
             });
         }
 
-        let mut info = unsafe { std::mem::zeroed() };
-        let mut basic_info: FILE_BASIC_INFO = unsafe { std::mem::zeroed() };
-        let mut id_info: FILE_ID_INFO = unsafe { std::mem::zeroed() };
+        let mut info = unsafe { core::mem::zeroed() };
+        let mut basic_info: FILE_BASIC_INFO = unsafe { core::mem::zeroed() };
+        let mut id_info: FILE_ID_INFO = unsafe { core::mem::zeroed() };
 
         if unsafe { GetFileInformationByHandle(h as _, &mut info) } == 0
             || unsafe {
@@ -129,7 +130,7 @@ pub mod windows {
                     h as _,
                     FileBasicInfo,
                     &mut basic_info as *mut _ as *mut _,
-                    std::mem::size_of_val(&basic_info) as u32,
+                    core::mem::size_of_val(&basic_info) as u32,
                 )
             } == 0
         {
@@ -141,7 +142,7 @@ pub mod windows {
                 h as _,
                 FileIdInfo,
                 &mut id_info as *mut _ as *mut _,
-                std::mem::size_of_val(&id_info) as u32,
+                core::mem::size_of_val(&id_info) as u32,
             )
         } == 0
         {
@@ -334,8 +335,8 @@ pub mod windows {
             .ok_or_else(|| std::io::Error::from_raw_os_error(ERROR_NOT_SUPPORTED as _))?;
 
         let file_name = file_name.to_wide_with_nul();
-        let file_info_buffer_size = std::mem::size_of::<FILE_STAT_BASIC_INFORMATION>() as u32;
-        let mut file_info_buffer = std::mem::MaybeUninit::<FILE_STAT_BASIC_INFORMATION>::uninit();
+        let file_info_buffer_size = core::mem::size_of::<FILE_STAT_BASIC_INFORMATION>() as u32;
+        let mut file_info_buffer = core::mem::MaybeUninit::<FILE_STAT_BASIC_INFORMATION>::uninit();
         unsafe {
             if GetFileInformationByName(
                 file_name.as_ptr(),
diff --git a/crates/common/src/float_ops.rs b/crates/common/src/float_ops.rs
index b431e793139..c6b7c71e494 100644
--- a/crates/common/src/float_ops.rs
+++ b/crates/common/src/float_ops.rs
@@ -1,6 +1,6 @@
+use core::f64;
 use malachite_bigint::{BigInt, ToBigInt};
 use num_traits::{Float, Signed, ToPrimitive, Zero};
-use std::f64;
 
 pub const fn decompose_float(value: f64) -> (f64, i32) {
     if 0.0 == value {
diff --git a/crates/common/src/format.rs b/crates/common/src/format.rs
index 2842bd0a3d4..930c764acf3 100644
--- a/crates/common/src/format.rs
+++ b/crates/common/src/format.rs
@@ -12,6 +12,19 @@ use rustpython_literal::format::Case;
 
 use crate::wtf8::{CodePoint, Wtf8, Wtf8Buf};
 
+/// Locale information for 'n' format specifier.
+/// Contains thousands separator, decimal point, and grouping pattern
+/// from the C library's `localeconv()`.
+#[derive(Clone, Debug)]
+pub struct LocaleInfo {
+    pub thousands_sep: String,
+    pub decimal_point: String,
+    /// Grouping pattern from `lconv.grouping`.
+    /// Each element is a group size. The last non-zero element repeats.
+    /// e.g. `[3, 0]` means groups of 3 repeating forever.
+    pub grouping: Vec<u8>,
+}
+
 trait FormatParse {
     fn parse(text: &Wtf8) -> (Option<Self>, &Wtf8)
     where
@@ -149,6 +162,7 @@ pub enum FormatType {
     GeneralFormat(Case),
     FixedPoint(Case),
     Percentage,
+    Unknown(char),
 }
 
 impl From<&FormatType> for char {
@@ -170,6 +184,7 @@ impl From<&FormatType> for char {
             FormatType::FixedPoint(Case::Lower) => 'f',
             FormatType::FixedPoint(Case::Upper) => 'F',
             FormatType::Percentage => '%',
+            FormatType::Unknown(c) => *c,
         }
     }
 }
@@ -194,6 +209,7 @@ impl FormatParse for FormatType {
             Some('g') => (Some(Self::GeneralFormat(Case::Lower)), chars.as_wtf8()),
             Some('G') => (Some(Self::GeneralFormat(Case::Upper)), chars.as_wtf8()),
             Some('%') => (Some(Self::Percentage), chars.as_wtf8()),
+            Some(c) => (Some(Self::Unknown(c)), chars.as_wtf8()),
             _ => (None, text),
         }
     }
@@ -429,7 +445,8 @@ impl FormatSpec {
                 | FormatType::FixedPoint(_)
                 | FormatType::GeneralFormat(_)
                 | FormatType::Exponent(_)
-                | FormatType::Percentage,
+                | FormatType::Percentage
+                | FormatType::Number(_),
             ) => 3,
             None => 3,
             _ => panic!("Separators only valid for numbers!"),
@@ -456,6 +473,189 @@ impl FormatSpec {
         }
     }
 
+    /// Returns true if this format spec uses the locale-aware 'n' format type.
+    pub fn has_locale_format(&self) -> bool {
+        matches!(self.format_type, Some(FormatType::Number(Case::Lower)))
+    }
+
+    /// Insert locale-aware thousands separators into an integer string.
+    /// Follows CPython's GroupGenerator logic for variable-width grouping.
+    fn insert_locale_grouping(int_part: &str, locale: &LocaleInfo) -> String {
+        if locale.grouping.is_empty() || locale.thousands_sep.is_empty() || int_part.len() <= 1 {
+            return int_part.to_string();
+        }
+
+        let mut group_idx = 0;
+        let mut group_size = locale.grouping[0] as usize;
+
+        if group_size == 0 {
+            return int_part.to_string();
+        }
+
+        // Collect groups of digits from right to left
+        let len = int_part.len();
+        let mut groups: Vec<&str> = Vec::new();
+        let mut pos = len;
+
+        loop {
+            if pos <= group_size {
+                groups.push(&int_part[..pos]);
+                break;
+            }
+
+            groups.push(&int_part[pos - group_size..pos]);
+            pos -= group_size;
+
+            // Advance to next group size
+            if group_idx + 1 < locale.grouping.len() {
+                let next = locale.grouping[group_idx + 1] as usize;
+                if next != 0 {
+                    group_size = next;
+                    group_idx += 1;
+                }
+                // 0 means repeat previous group size forever
+            }
+        }
+
+        // Groups were collected right-to-left, reverse to get left-to-right
+        groups.reverse();
+        groups.join(&locale.thousands_sep)
+    }
+
+    /// Apply locale-aware grouping and decimal point replacement to a formatted number.
+    fn apply_locale_formatting(magnitude_str: String, locale: &LocaleInfo) -> String {
+        let mut parts = magnitude_str.splitn(2, '.');
+        let int_part = parts.next().unwrap();
+        let grouped = Self::insert_locale_grouping(int_part, locale);
+
+        if let Some(frac_part) = parts.next() {
+            format!("{grouped}{}{frac_part}", locale.decimal_point)
+        } else {
+            grouped
+        }
+    }
+
+    /// Format an integer with locale-aware 'n' format.
+    pub fn format_int_locale(
+        &self,
+        num: &BigInt,
+        locale: &LocaleInfo,
+    ) -> Result<String, FormatSpecError> {
+        self.validate_format(FormatType::Decimal)?;
+        let magnitude = num.abs();
+
+        let raw_magnitude_str = match self.format_type {
+            Some(FormatType::Number(Case::Lower)) => self.format_int_radix(magnitude, 10),
+            _ => return self.format_int(num),
+        }?;
+
+        let magnitude_str = Self::apply_locale_formatting(raw_magnitude_str, locale);
+
+        let format_sign = self.sign.unwrap_or(FormatSign::Minus);
+        let sign_str = match num.sign() {
+            Sign::Minus => "-",
+            _ => match format_sign {
+                FormatSign::Plus => "+",
+                FormatSign::Minus => "",
+                FormatSign::MinusOrSpace => " ",
+            },
+        };
+
+        self.format_sign_and_align(&AsciiStr::new(&magnitude_str), sign_str, FormatAlign::Right)
+    }
+
+    /// Format a float with locale-aware 'n' format.
+    pub fn format_float_locale(
+        &self,
+        num: f64,
+        locale: &LocaleInfo,
+    ) -> Result<String, FormatSpecError> {
+        self.validate_format(FormatType::FixedPoint(Case::Lower))?;
+        let precision = self.precision.unwrap_or(6);
+        let magnitude = num.abs();
+
+        let raw_magnitude_str = match &self.format_type {
+            Some(FormatType::Number(case)) => {
+                let precision = if precision == 0 { 1 } else { precision };
+                Ok(float::format_general(
+                    precision,
+                    magnitude,
+                    *case,
+                    self.alternate_form,
+                    false,
+                ))
+            }
+            _ => return self.format_float(num),
+        }?;
+
+        let magnitude_str = Self::apply_locale_formatting(raw_magnitude_str, locale);
+
+        let format_sign = self.sign.unwrap_or(FormatSign::Minus);
+        let sign_str = if num.is_sign_negative() && !num.is_nan() {
+            "-"
+        } else {
+            match format_sign {
+                FormatSign::Plus => "+",
+                FormatSign::Minus => "",
+                FormatSign::MinusOrSpace => " ",
+            }
+        };
+
+        self.format_sign_and_align(&AsciiStr::new(&magnitude_str), sign_str, FormatAlign::Right)
+    }
+
+    /// Format a complex number with locale-aware 'n' format.
+    pub fn format_complex_locale(
+        &self,
+        num: &Complex64,
+        locale: &LocaleInfo,
+    ) -> Result<String, FormatSpecError> {
+        // Reuse format_complex_re_im with 'g' type to get the base formatted parts,
+        // then apply locale grouping. This matches CPython's format_complex_internal:
+        // 'n' → 'g', add_parens=0, skip_re=0.
+        let locale_spec = FormatSpec {
+            format_type: Some(FormatType::GeneralFormat(Case::Lower)),
+            ..*self
+        };
+        let (formatted_re, formatted_im) = locale_spec.format_complex_re_im(num)?;
+
+        // Apply locale grouping to both parts
+        let grouped_re = if formatted_re.is_empty() {
+            formatted_re
+        } else {
+            // Split sign from magnitude, apply grouping, recombine
+            let (sign, mag) = if formatted_re.starts_with('-')
+                || formatted_re.starts_with('+')
+                || formatted_re.starts_with(' ')
+            {
+                formatted_re.split_at(1)
+            } else {
+                ("", formatted_re.as_str())
+            };
+            format!(
+                "{sign}{}",
+                Self::apply_locale_formatting(mag.to_string(), locale)
+            )
+        };
+
+        // formatted_im is like "+1234j" or "-1234j" or "1234j"
+        // Split sign, magnitude, and 'j' suffix
+        let im_str = &formatted_im;
+        let (im_sign, im_rest) = if im_str.starts_with('+') || im_str.starts_with('-') {
+            im_str.split_at(1)
+        } else {
+            ("", im_str.as_str())
+        };
+        let im_mag = im_rest.strip_suffix('j').unwrap_or(im_rest);
+        let im_grouped = Self::apply_locale_formatting(im_mag.to_string(), locale);
+        let grouped_im = format!("{im_sign}{im_grouped}j");
+
+        // No parentheses for 'n' format (CPython: add_parens=0)
+        let magnitude_str = format!("{grouped_re}{grouped_im}");
+
+        self.format_sign_and_align(&AsciiStr::new(&magnitude_str), "", FormatAlign::Right)
+    }
+
     pub fn format_bool(&self, input: bool) -> Result<String, FormatSpecError> {
         let x = u8::from(input);
         match &self.format_type {
@@ -475,6 +675,7 @@ impl FormatSpec {
                 let first_letter = (input.to_string().as_bytes()[0] as char).to_uppercase();
                 Ok(first_letter.collect::<String>() + &input.to_string()[1..])
             }
+            Some(FormatType::Unknown(c)) => Err(FormatSpecError::UnknownFormatCode(*c, "int")),
             _ => Err(FormatSpecError::InvalidFormatSpecifier),
         }
     }
@@ -496,7 +697,8 @@ impl FormatSpec {
             | Some(FormatType::Hex(_))
             | Some(FormatType::String)
             | Some(FormatType::Character)
-            | Some(FormatType::Number(Case::Upper)) => {
+            | Some(FormatType::Number(Case::Upper))
+            | Some(FormatType::Unknown(_)) => {
                 let ch = char::from(self.format_type.as_ref().unwrap());
                 Err(FormatSpecError::UnknownFormatCode(ch, "float"))
             }
@@ -609,6 +811,7 @@ impl FormatSpec {
                 Some(float) => return self.format_float(float),
                 _ => Err(FormatSpecError::UnableToConvert),
             },
+            Some(FormatType::Unknown(c)) => Err(FormatSpecError::UnknownFormatCode(c, "int")),
             None => self.format_int_radix(magnitude, 10),
         }?;
         let format_sign = self.sign.unwrap_or(FormatSign::Minus);
@@ -707,7 +910,8 @@ impl FormatSpec {
             | Some(FormatType::String)
             | Some(FormatType::Character)
             | Some(FormatType::Number(Case::Upper))
-            | Some(FormatType::Percentage) => {
+            | Some(FormatType::Percentage)
+            | Some(FormatType::Unknown(_)) => {
                 let ch = char::from(self.format_type.as_ref().unwrap());
                 Err(FormatSpecError::UnknownFormatCode(ch, "complex"))
             }
diff --git a/crates/common/src/lib.rs b/crates/common/src/lib.rs
index 0181562d043..e514c17541f 100644
--- a/crates/common/src/lib.rs
+++ b/crates/common/src/lib.rs
@@ -1,6 +1,6 @@
 //! A crate to hold types and functions common to all rustpython components.
 
-#![cfg_attr(all(target_os = "wasi", target_env = "p2"), feature(wasip2))]
+#![cfg_attr(not(feature = "std"), no_std)]
 
 extern crate alloc;
 
@@ -12,10 +12,10 @@ pub mod atomic;
 pub mod borrow;
 pub mod boxvec;
 pub mod cformat;
-#[cfg(any(unix, windows, target_os = "wasi"))]
+#[cfg(all(feature = "std", any(unix, windows, target_os = "wasi")))]
 pub mod crt_fd;
 pub mod encodings;
-#[cfg(any(not(target_arch = "wasm32"), target_os = "wasi"))]
+#[cfg(all(feature = "std", any(not(target_arch = "wasm32"), target_os = "wasi")))]
 pub mod fileutils;
 pub mod float_ops;
 pub mod format;
@@ -23,13 +23,14 @@ pub mod hash;
 pub mod int;
 pub mod linked_list;
 pub mod lock;
+#[cfg(feature = "std")]
 pub mod os;
 pub mod rand;
 pub mod rc;
 pub mod refcount;
 pub mod static_cell;
 pub mod str;
-#[cfg(windows)]
+#[cfg(all(feature = "std", windows))]
 pub mod windows;
 
 pub use rustpython_wtf8 as wtf8;
diff --git a/crates/common/src/linked_list.rs b/crates/common/src/linked_list.rs
index fb2b1260346..223d9ce0eb1 100644
--- a/crates/common/src/linked_list.rs
+++ b/crates/common/src/linked_list.rs
@@ -157,6 +157,15 @@ impl<L: Link> LinkedList<L, L::Target> {
         let ptr = L::as_raw(&val);
         assert_ne!(self.head, Some(ptr));
         unsafe {
+            // Verify the node is not already in a list (pointers must be clean)
+            debug_assert!(
+                L::pointers(ptr).as_ref().get_prev().is_none(),
+                "push_front: node already has prev pointer (double-insert?)"
+            );
+            debug_assert!(
+                L::pointers(ptr).as_ref().get_next().is_none(),
+                "push_front: node already has next pointer (double-insert?)"
+            );
             L::pointers(ptr).as_mut().set_next(self.head);
             L::pointers(ptr).as_mut().set_prev(None);
 
@@ -192,6 +201,20 @@ impl<L: Link> LinkedList<L, L::Target> {
     //     }
     // }
 
+    /// Removes the first element from the list and returns it, or None if empty.
+    pub fn pop_front(&mut self) -> Option<L::Handle> {
+        let head = self.head?;
+        unsafe {
+            self.head = L::pointers(head).as_ref().get_next();
+            if let Some(new_head) = self.head {
+                L::pointers(new_head).as_mut().set_prev(None);
+            }
+            L::pointers(head).as_mut().set_next(None);
+            L::pointers(head).as_mut().set_prev(None);
+            Some(L::from_raw(head))
+        }
+    }
+
     /// Returns whether the linked list does not contain any node
     pub const fn is_empty(&self) -> bool {
         self.head.is_none()
@@ -212,7 +235,11 @@ impl<L: Link> LinkedList<L, L::Target> {
     pub unsafe fn remove(&mut self, node: NonNull<L::Target>) -> Option<L::Handle> {
         unsafe {
             if let Some(prev) = L::pointers(node).as_ref().get_prev() {
-                debug_assert_eq!(L::pointers(prev).as_ref().get_next(), Some(node));
+                debug_assert_eq!(
+                    L::pointers(prev).as_ref().get_next(),
+                    Some(node),
+                    "linked list corruption: prev->next != node (prev={prev:p}, node={node:p})"
+                );
                 L::pointers(prev)
                     .as_mut()
                     .set_next(L::pointers(node).as_ref().get_next());
@@ -225,7 +252,11 @@ impl<L: Link> LinkedList<L, L::Target> {
             }
 
             if let Some(next) = L::pointers(node).as_ref().get_next() {
-                debug_assert_eq!(L::pointers(next).as_ref().get_prev(), Some(node));
+                debug_assert_eq!(
+                    L::pointers(next).as_ref().get_prev(),
+                    Some(node),
+                    "linked list corruption: next->prev != node (next={next:p}, node={node:p})"
+                );
                 L::pointers(next)
                     .as_mut()
                     .set_prev(L::pointers(node).as_ref().get_prev());
@@ -333,7 +364,7 @@ impl<T> Pointers<T> {
         }
     }
 
-    const fn get_prev(&self) -> Option<NonNull<T>> {
+    pub const fn get_prev(&self) -> Option<NonNull<T>> {
         // SAFETY: prev is the first field in PointersInner, which is #[repr(C)].
         unsafe {
             let inner = self.inner.get();
@@ -341,7 +372,7 @@ impl<T> Pointers<T> {
             ptr::read(prev)
         }
     }
-    const fn get_next(&self) -> Option<NonNull<T>> {
+    pub const fn get_next(&self) -> Option<NonNull<T>> {
         // SAFETY: next is the second field in PointersInner, which is #[repr(C)].
         unsafe {
             let inner = self.inner.get();
@@ -351,7 +382,7 @@ impl<T> Pointers<T> {
         }
     }
 
-    const fn set_prev(&mut self, value: Option<NonNull<T>>) {
+    pub const fn set_prev(&mut self, value: Option<NonNull<T>>) {
         // SAFETY: prev is the first field in PointersInner, which is #[repr(C)].
         unsafe {
             let inner = self.inner.get();
@@ -359,7 +390,7 @@ impl<T> Pointers<T> {
             ptr::write(prev, value);
         }
     }
-    const fn set_next(&mut self, value: Option<NonNull<T>>) {
+    pub const fn set_next(&mut self, value: Option<NonNull<T>>) {
         // SAFETY: next is the second field in PointersInner, which is #[repr(C)].
         unsafe {
             let inner = self.inner.get();
diff --git a/crates/common/src/lock.rs b/crates/common/src/lock.rs
index ca5ffe8de37..cd7df512d83 100644
--- a/crates/common/src/lock.rs
+++ b/crates/common/src/lock.rs
@@ -10,12 +10,39 @@ cfg_if::cfg_if! {
     if #[cfg(feature = "threading")] {
         pub use parking_lot::{RawMutex, RawRwLock, RawThreadId};
 
-        pub use once_cell::sync::{Lazy, OnceCell};
+        pub use std::sync::OnceLock as OnceCell;
+        pub use core::cell::LazyCell;
     } else {
         mod cell_lock;
         pub use cell_lock::{RawCellMutex as RawMutex, RawCellRwLock as RawRwLock, SingleThreadId as RawThreadId};
 
-        pub use once_cell::unsync::{Lazy, OnceCell};
+        pub use core::cell::{LazyCell, OnceCell};
+    }
+}
+
+// LazyLock: uses std::sync::LazyLock when std is available (even without
+// threading, because Rust test runner uses parallel threads).
+// Without std, uses a LazyCell wrapper (truly single-threaded only).
+cfg_if::cfg_if! {
+    if #[cfg(any(feature = "threading", feature = "std"))] {
+        pub use std::sync::LazyLock;
+    } else {
+        pub struct LazyLock<T, F = fn() -> T>(core::cell::LazyCell<T, F>);
+        // SAFETY: This branch is only active when both "std" and "threading"
+        // features are absent — i.e., truly single-threaded no_std environments
+        // (e.g., embedded or bare-metal WASM). Without std, the Rust runtime
+        // cannot spawn threads, so Sync is trivially satisfied.
+        unsafe impl<T, F> Sync for LazyLock<T, F> {}
+
+        impl<T, F: FnOnce() -> T> LazyLock<T, F> {
+            pub const fn new(f: F) -> Self { Self(core::cell::LazyCell::new(f)) }
+            pub fn force(this: &Self) -> &T { core::cell::LazyCell::force(&this.0) }
+        }
+
+        impl<T, F: FnOnce() -> T> core::ops::Deref for LazyLock<T, F> {
+            type Target = T;
+            fn deref(&self) -> &T { &self.0 }
+        }
     }
 }
 
@@ -40,3 +67,59 @@ pub type PyRwLockWriteGuard<'a, T> = RwLockWriteGuard<'a, RawRwLock, T>;
 pub type PyMappedRwLockWriteGuard<'a, T> = MappedRwLockWriteGuard<'a, RawRwLock, T>;
 
 // can add fn const_{mutex,rw_lock}() if necessary, but we probably won't need to
+
+/// Reset a lock to its initial (unlocked) state by zeroing its bytes.
+///
+/// After `fork()`, any lock held by a now-dead thread would remain
+/// permanently locked. We zero the raw bytes (the unlocked state for all
+/// `parking_lot` raw lock types) instead of using the normal unlock path,
+/// which would interact with stale waiter queues.
+///
+/// # Safety
+///
+/// Must only be called from the single-threaded child process immediately
+/// after `fork()`, before any other thread is created.
+/// The type `T` must represent the unlocked state as all-zero bytes
+/// (true for `parking_lot::RawMutex`, `RawRwLock`, `RawReentrantMutex`, etc.).
+pub unsafe fn zero_reinit_after_fork<T>(lock: *const T) {
+    unsafe {
+        core::ptr::write_bytes(lock as *mut u8, 0, core::mem::size_of::<T>());
+    }
+}
+
+/// Reset a `PyMutex` after `fork()`. See [`zero_reinit_after_fork`].
+///
+/// # Safety
+///
+/// Must only be called from the single-threaded child process immediately
+/// after `fork()`, before any other thread is created.
+#[cfg(unix)]
+pub unsafe fn reinit_mutex_after_fork<T: ?Sized>(mutex: &PyMutex<T>) {
+    unsafe { zero_reinit_after_fork(mutex.raw()) }
+}
+
+/// Reset a `PyRwLock` after `fork()`. See [`zero_reinit_after_fork`].
+///
+/// # Safety
+///
+/// Must only be called from the single-threaded child process immediately
+/// after `fork()`, before any other thread is created.
+#[cfg(unix)]
+pub unsafe fn reinit_rwlock_after_fork<T: ?Sized>(rwlock: &PyRwLock<T>) {
+    unsafe { zero_reinit_after_fork(rwlock.raw()) }
+}
+
+/// Reset a `PyThreadMutex` to its initial (unlocked, unowned) state after `fork()`.
+///
+/// `PyThreadMutex` is used by buffered IO objects (`BufferedReader`,
+/// `BufferedWriter`, `TextIOWrapper`). If a dead parent thread held one of
+/// these locks during `fork()`, the child would deadlock on any IO operation.
+///
+/// # Safety
+///
+/// Must only be called from the single-threaded child process immediately
+/// after `fork()`, before any other thread is created.
+#[cfg(unix)]
+pub unsafe fn reinit_thread_mutex_after_fork<T: ?Sized>(mutex: &PyThreadMutex<T>) {
+    unsafe { mutex.raw().reinit_after_fork() }
+}
diff --git a/crates/common/src/lock/cell_lock.rs b/crates/common/src/lock/cell_lock.rs
index 0e045c5950b..ab9cfb08c84 100644
--- a/crates/common/src/lock/cell_lock.rs
+++ b/crates/common/src/lock/cell_lock.rs
@@ -10,7 +10,10 @@ pub struct RawCellMutex {
 }
 
 unsafe impl RawMutex for RawCellMutex {
-    #[allow(clippy::declare_interior_mutable_const)]
+    #[allow(
+        clippy::declare_interior_mutable_const,
+        reason = "const lock initializer intentionally uses interior mutability"
+    )]
     const INIT: Self = Self {
         locked: Cell::new(false),
     };
@@ -60,7 +63,10 @@ impl RawCellRwLock {
 }
 
 unsafe impl RawRwLock for RawCellRwLock {
-    #[allow(clippy::declare_interior_mutable_const)]
+    #[allow(
+        clippy::declare_interior_mutable_const,
+        reason = "const rwlock initializer intentionally uses interior mutability"
+    )]
     const INIT: Self = Self {
         state: Cell::new(0),
     };
@@ -89,7 +95,7 @@ unsafe impl RawRwLock for RawCellRwLock {
 
     #[inline]
     unsafe fn unlock_shared(&self) {
-        self.state.set(self.state.get() - ONE_READER)
+        self.state.update(|x| x - ONE_READER)
     }
 
     #[inline]
diff --git a/crates/common/src/lock/thread_mutex.rs b/crates/common/src/lock/thread_mutex.rs
index ec10ab1f181..884556c4476 100644
--- a/crates/common/src/lock/thread_mutex.rs
+++ b/crates/common/src/lock/thread_mutex.rs
@@ -20,7 +20,10 @@ pub struct RawThreadMutex<R: RawMutex, G: GetThreadId> {
 }
 
 impl<R: RawMutex, G: GetThreadId> RawThreadMutex<R, G> {
-    #[allow(clippy::declare_interior_mutable_const)]
+    #[allow(
+        clippy::declare_interior_mutable_const,
+        reason = "const initializer for lock primitive contains atomics by design"
+    )]
     pub const INIT: Self = Self {
         owner: AtomicUsize::new(0),
         mutex: R::INIT,
@@ -51,6 +54,18 @@ impl<R: RawMutex, G: GetThreadId> RawThreadMutex<R, G> {
         .is_some()
     }
 
+    /// Like `lock()` but wraps the blocking wait in `wrap_fn`.
+    /// The caller can use this to detach thread state while waiting.
+    pub fn lock_wrapped<F: FnOnce(&dyn Fn())>(&self, wrap_fn: F) -> bool {
+        let id = self.get_thread_id.nonzero_thread_id().get();
+        if self.owner.load(Ordering::Relaxed) == id {
+            return false;
+        }
+        wrap_fn(&|| self.mutex.lock());
+        self.owner.store(id, Ordering::Relaxed);
+        true
+    }
+
     /// Returns `Some(true)` if able to successfully lock without blocking, `Some(false)`
     /// otherwise, and `None` when the mutex is already locked on the current thread.
     pub fn try_lock(&self) -> Option<bool> {
@@ -69,6 +84,23 @@ impl<R: RawMutex, G: GetThreadId> RawThreadMutex<R, G> {
     }
 }
 
+impl<R: RawMutex, G: GetThreadId> RawThreadMutex<R, G> {
+    /// Reset this mutex to its initial (unlocked, unowned) state after `fork()`.
+    ///
+    /// # Safety
+    ///
+    /// Must only be called from the single-threaded child process immediately
+    /// after `fork()`, before any other thread is created.
+    #[cfg(unix)]
+    pub unsafe fn reinit_after_fork(&self) {
+        self.owner.store(0, Ordering::Relaxed);
+        unsafe {
+            let mutex_ptr = &self.mutex as *const R as *mut u8;
+            core::ptr::write_bytes(mutex_ptr, 0, core::mem::size_of::<R>());
+        }
+    }
+}
+
 unsafe impl<R: RawMutex + Send, G: GetThreadId + Send> Send for RawThreadMutex<R, G> {}
 unsafe impl<R: RawMutex + Sync, G: GetThreadId + Sync> Sync for RawThreadMutex<R, G> {}
 
@@ -100,6 +132,11 @@ impl<R: RawMutex, G: GetThreadId, T> From<T> for ThreadMutex<R, G, T> {
     }
 }
 impl<R: RawMutex, G: GetThreadId, T: ?Sized> ThreadMutex<R, G, T> {
+    /// Access the underlying raw thread mutex.
+    pub fn raw(&self) -> &RawThreadMutex<R, G> {
+        &self.raw
+    }
+
     pub fn lock(&self) -> Option<ThreadMutexGuard<'_, R, G, T>> {
         if self.raw.lock() {
             Some(ThreadMutexGuard {
@@ -110,6 +147,23 @@ impl<R: RawMutex, G: GetThreadId, T: ?Sized> ThreadMutex<R, G, T> {
             None
         }
     }
+
+    /// Like `lock()` but wraps the blocking wait in `wrap_fn`.
+    /// The caller can use this to detach thread state while waiting.
+    pub fn lock_wrapped<F: FnOnce(&dyn Fn())>(
+        &self,
+        wrap_fn: F,
+    ) -> Option<ThreadMutexGuard<'_, R, G, T>> {
+        if self.raw.lock_wrapped(wrap_fn) {
+            Some(ThreadMutexGuard {
+                mu: self,
+                marker: PhantomData,
+            })
+        } else {
+            None
+        }
+    }
+
     pub fn try_lock(&self) -> Result<ThreadMutexGuard<'_, R, G, T>, TryLockThreadError> {
         match self.raw.try_lock() {
             Some(true) => Ok(ThreadMutexGuard {
diff --git a/crates/common/src/os.rs b/crates/common/src/os.rs
index a0935239742..2a318f477e5 100644
--- a/crates/common/src/os.rs
+++ b/crates/common/src/os.rs
@@ -94,9 +94,61 @@ pub fn bytes_as_os_str(b: &[u8]) -> Result<&std::ffi::OsStr, Utf8Error> {
 
 #[cfg(unix)]
 pub use std::os::unix::ffi;
-#[cfg(target_os = "wasi")]
+
+// WASIp1 uses stable std::os::wasi::ffi
+#[cfg(all(target_os = "wasi", not(target_env = "p2")))]
 pub use std::os::wasi::ffi;
 
+// WASIp2: std::os::wasip2::ffi is unstable, so we provide a stable implementation
+// leveraging WASI's UTF-8 string guarantee
+#[cfg(all(target_os = "wasi", target_env = "p2"))]
+pub mod ffi {
+    use std::ffi::{OsStr, OsString};
+
+    pub trait OsStrExt: sealed::Sealed {
+        fn as_bytes(&self) -> &[u8];
+        fn from_bytes(slice: &[u8]) -> &Self;
+    }
+
+    impl OsStrExt for OsStr {
+        fn as_bytes(&self) -> &[u8] {
+            // WASI strings are guaranteed to be UTF-8
+            self.to_str().expect("wasip2 strings are UTF-8").as_bytes()
+        }
+
+        fn from_bytes(slice: &[u8]) -> &OsStr {
+            // WASI strings are guaranteed to be UTF-8
+            OsStr::new(core::str::from_utf8(slice).expect("wasip2 strings are UTF-8"))
+        }
+    }
+
+    pub trait OsStringExt: sealed::Sealed {
+        fn from_vec(vec: Vec<u8>) -> Self;
+        fn into_vec(self) -> Vec<u8>;
+    }
+
+    impl OsStringExt for OsString {
+        fn from_vec(vec: Vec<u8>) -> OsString {
+            // WASI strings are guaranteed to be UTF-8
+            OsString::from(String::from_utf8(vec).expect("wasip2 strings are UTF-8"))
+        }
+
+        fn into_vec(self) -> Vec<u8> {
+            // WASI strings are guaranteed to be UTF-8
+            self.to_str()
+                .expect("wasip2 strings are UTF-8")
+                .as_bytes()
+                .to_vec()
+        }
+    }
+
+    mod sealed {
+        pub trait Sealed {}
+        impl Sealed for std::ffi::OsStr {}
+        impl Sealed for std::ffi::OsString {}
+    }
+}
+
 #[cfg(windows)]
 pub fn errno_to_winerror(errno: i32) -> i32 {
     use libc::*;
diff --git a/crates/common/src/refcount.rs b/crates/common/src/refcount.rs
index a5fbfa8fc36..4d871a67a0d 100644
--- a/crates/common/src/refcount.rs
+++ b/crates/common/src/refcount.rs
@@ -1,14 +1,77 @@
-use crate::atomic::{Ordering::*, PyAtomic, Radium};
+use crate::atomic::{Ordering, PyAtomic, Radium};
 
-/// from alloc::sync
-/// A soft limit on the amount of references that may be made to an `Arc`.
-///
-/// Going above this limit will abort your program (although not
-/// necessarily) at _exactly_ `MAX_REFCOUNT + 1` references.
-const MAX_REFCOUNT: usize = isize::MAX as usize;
+// State layout (usize):
+//   [1 bit: destructed] [1 bit: reserved] [1 bit: leaked] [N bits: weak_count] [M bits: strong_count]
+// 64-bit: N=30, M=31.  32-bit: N=14, M=15.
+const FLAG_BITS: u32 = 3;
+const DESTRUCTED: usize = 1 << (usize::BITS - 1);
+const LEAKED: usize = 1 << (usize::BITS - 3);
+const TOTAL_COUNT_WIDTH: u32 = usize::BITS - FLAG_BITS;
+const WEAK_WIDTH: u32 = TOTAL_COUNT_WIDTH / 2;
+const STRONG_WIDTH: u32 = TOTAL_COUNT_WIDTH - WEAK_WIDTH;
+const STRONG: usize = (1 << STRONG_WIDTH) - 1;
+const COUNT: usize = 1;
+const WEAK_COUNT: usize = 1 << STRONG_WIDTH;
+
+#[inline(never)]
+#[cold]
+fn refcount_overflow() -> ! {
+    #[cfg(feature = "std")]
+    std::process::abort();
+    #[cfg(not(feature = "std"))]
+    core::panic!("refcount overflow");
+}
+
+/// State wraps reference count + flags in a single word (platform usize)
+#[derive(Clone, Copy)]
+struct State {
+    inner: usize,
+}
+
+impl State {
+    #[inline]
+    fn from_raw(inner: usize) -> Self {
+        Self { inner }
+    }
 
+    #[inline]
+    fn as_raw(self) -> usize {
+        self.inner
+    }
+
+    #[inline]
+    fn strong(self) -> u32 {
+        ((self.inner & STRONG) / COUNT) as u32
+    }
+
+    #[inline]
+    fn destructed(self) -> bool {
+        (self.inner & DESTRUCTED) != 0
+    }
+
+    #[inline]
+    fn leaked(self) -> bool {
+        (self.inner & LEAKED) != 0
+    }
+
+    #[inline]
+    fn add_strong(self, val: u32) -> Self {
+        Self::from_raw(self.inner + (val as usize) * COUNT)
+    }
+
+    #[inline]
+    fn with_leaked(self, leaked: bool) -> Self {
+        Self::from_raw((self.inner & !LEAKED) | if leaked { LEAKED } else { 0 })
+    }
+}
+
+/// Reference count using state layout with LEAKED support.
+///
+/// State layout (usize):
+/// 64-bit: [1 bit: destructed] [1 bit: reserved] [1 bit: leaked] [30 bits: weak_count] [31 bits: strong_count]
+/// 32-bit: [1 bit: destructed] [1 bit: reserved] [1 bit: leaked] [14 bits: weak_count] [15 bits: strong_count]
 pub struct RefCount {
-    strong: PyAtomic<usize>,
+    state: PyAtomic<usize>,
 }
 
 impl Default for RefCount {
@@ -18,61 +81,196 @@ impl Default for RefCount {
 }
 
 impl RefCount {
-    const MASK: usize = MAX_REFCOUNT;
-
+    /// Create a new RefCount with strong count = 1
     pub fn new() -> Self {
+        // Initial state: strong=1, weak=1 (implicit weak for strong refs)
         Self {
-            strong: Radium::new(1),
+            state: Radium::new(COUNT + WEAK_COUNT),
         }
     }
 
+    /// Get current strong count
     #[inline]
     pub fn get(&self) -> usize {
-        self.strong.load(SeqCst)
+        State::from_raw(self.state.load(Ordering::Relaxed)).strong() as usize
     }
 
+    /// Increment strong count
     #[inline]
     pub fn inc(&self) {
-        let old_size = self.strong.fetch_add(1, Relaxed);
+        let val = State::from_raw(self.state.fetch_add(COUNT, Ordering::Relaxed));
+        if val.destructed() || (val.strong() as usize) > STRONG - 1 {
+            refcount_overflow();
+        }
+        if val.strong() == 0 {
+            // The previous fetch_add created a permission to run decrement again
+            self.state.fetch_add(COUNT, Ordering::Relaxed);
+        }
+    }
 
-        if old_size & Self::MASK == Self::MASK {
-            std::process::abort();
+    #[inline]
+    pub fn inc_by(&self, n: usize) {
+        debug_assert!(n <= STRONG);
+        let val = State::from_raw(self.state.fetch_add(n * COUNT, Ordering::Relaxed));
+        if val.destructed() || (val.strong() as usize) > STRONG - n {
+            refcount_overflow();
         }
     }
 
     /// Returns true if successful
     #[inline]
+    #[must_use]
     pub fn safe_inc(&self) -> bool {
-        self.strong
-            .fetch_update(AcqRel, Acquire, |prev| (prev != 0).then_some(prev + 1))
-            .is_ok()
+        let mut old = State::from_raw(self.state.load(Ordering::Relaxed));
+        loop {
+            if old.destructed() || old.strong() == 0 {
+                return false;
+            }
+            if (old.strong() as usize) >= STRONG {
+                refcount_overflow();
+            }
+            let new_state = old.add_strong(1);
+            match self.state.compare_exchange_weak(
+                old.as_raw(),
+                new_state.as_raw(),
+                Ordering::Relaxed,
+                Ordering::Relaxed,
+            ) {
+                Ok(_) => return true,
+                Err(curr) => old = State::from_raw(curr),
+            }
+        }
     }
 
-    /// Decrement the reference count. Returns true when the refcount drops to 0.
+    /// Decrement strong count. Returns true when count drops to 0.
     #[inline]
+    #[must_use]
     pub fn dec(&self) -> bool {
-        if self.strong.fetch_sub(1, Release) != 1 {
+        let old = State::from_raw(self.state.fetch_sub(COUNT, Ordering::Release));
+
+        // LEAKED objects never reach 0
+        if old.leaked() {
             return false;
         }
 
-        PyAtomic::<usize>::fence(Acquire);
-
-        true
+        if old.strong() == 1 {
+            core::sync::atomic::fence(Ordering::Acquire);
+            return true;
+        }
+        false
     }
-}
-
-impl RefCount {
-    // move these functions out and give separated type once type range is stabilized
 
+    /// Mark this object as leaked (interned). It will never be deallocated.
     pub fn leak(&self) {
         debug_assert!(!self.is_leaked());
-        const BIT_MARKER: usize = (isize::MAX as usize) + 1;
-        debug_assert_eq!(BIT_MARKER.count_ones(), 1);
-        debug_assert_eq!(BIT_MARKER.leading_zeros(), 0);
-        self.strong.fetch_add(BIT_MARKER, Relaxed);
+        let mut old = State::from_raw(self.state.load(Ordering::Relaxed));
+        loop {
+            let new_state = old.with_leaked(true);
+            match self.state.compare_exchange_weak(
+                old.as_raw(),
+                new_state.as_raw(),
+                Ordering::AcqRel,
+                Ordering::Relaxed,
+            ) {
+                Ok(_) => return,
+                Err(curr) => old = State::from_raw(curr),
+            }
+        }
     }
 
+    /// Check if this object is leaked (interned).
     pub fn is_leaked(&self) -> bool {
-        (self.strong.load(Acquire) as isize) < 0
+        State::from_raw(self.state.load(Ordering::Acquire)).leaked()
+    }
+}
+
+// Deferred Drop Infrastructure
+//
+// This mechanism allows untrack_object() calls to be deferred until after
+// the GC collection phase completes, preventing deadlocks that occur when
+// clear (pop_edges) triggers object destruction while holding the tracked_objects lock.
+
+#[cfg(feature = "std")]
+use core::cell::{Cell, RefCell};
+
+#[cfg(feature = "std")]
+thread_local! {
+    /// Flag indicating if we're inside a deferred drop context.
+    /// When true, drop operations should defer untrack calls.
+    static IN_DEFERRED_CONTEXT: Cell<bool> = const { Cell::new(false) };
+
+    /// Queue of deferred untrack operations.
+    /// No Send bound needed - this is thread-local and only accessed from the same thread.
+    static DEFERRED_QUEUE: RefCell<Vec<Box<dyn FnOnce()>>> = const { RefCell::new(Vec::new()) };
+}
+
+#[cfg(feature = "std")]
+struct DeferredDropGuard {
+    was_in_context: bool,
+}
+
+#[cfg(feature = "std")]
+impl Drop for DeferredDropGuard {
+    fn drop(&mut self) {
+        IN_DEFERRED_CONTEXT.with(|in_ctx| {
+            in_ctx.set(self.was_in_context);
+        });
+        // Only flush if we're the outermost context and not already panicking
+        // (flushing during unwinding risks double-panic → process abort).
+        if !self.was_in_context && !std::thread::panicking() {
+            flush_deferred_drops();
+        }
     }
 }
+
+/// Execute a function within a deferred drop context.
+/// Any calls to `try_defer_drop` within this context will be queued
+/// and executed when the context exits (even on panic).
+#[cfg(feature = "std")]
+#[inline]
+pub fn with_deferred_drops<F, R>(f: F) -> R
+where
+    F: FnOnce() -> R,
+{
+    let _guard = IN_DEFERRED_CONTEXT.with(|in_ctx| {
+        let was_in_context = in_ctx.get();
+        in_ctx.set(true);
+        DeferredDropGuard { was_in_context }
+    });
+    f()
+}
+
+/// Try to defer a drop-related operation.
+/// If inside a deferred context, the operation is queued.
+/// Otherwise, it executes immediately.
+#[cfg(feature = "std")]
+#[inline]
+pub fn try_defer_drop<F>(f: F)
+where
+    F: FnOnce() + 'static,
+{
+    let should_defer = IN_DEFERRED_CONTEXT.with(|in_ctx| in_ctx.get());
+
+    if should_defer {
+        DEFERRED_QUEUE.with(|q| {
+            q.borrow_mut().push(Box::new(f));
+        });
+    } else {
+        f();
+    }
+}
+
+/// Flush all deferred drop operations.
+/// This is automatically called when exiting a deferred context.
+#[cfg(feature = "std")]
+#[inline]
+pub fn flush_deferred_drops() {
+    DEFERRED_QUEUE.with(|q| {
+        // Take all queued operations
+        let ops: Vec<_> = q.borrow_mut().drain(..).collect();
+        // Execute them outside the borrow
+        for op in ops {
+            op();
+        }
+    });
+}
diff --git a/crates/common/src/static_cell.rs b/crates/common/src/static_cell.rs
index a8beee08206..bf277e60ea7 100644
--- a/crates/common/src/static_cell.rs
+++ b/crates/common/src/static_cell.rs
@@ -1,4 +1,58 @@
-#[cfg(not(feature = "threading"))]
+#[cfg(feature = "threading")]
+mod threading {
+    use crate::lock::OnceCell;
+
+    pub struct StaticCell<T: 'static> {
+        inner: OnceCell<T>,
+    }
+
+    impl<T> StaticCell<T> {
+        #[doc(hidden)]
+        pub const fn _from_once_cell(inner: OnceCell<T>) -> Self {
+            Self { inner }
+        }
+
+        pub fn get(&'static self) -> Option<&'static T> {
+            self.inner.get()
+        }
+
+        pub fn set(&'static self, value: T) -> Result<(), T> {
+            self.inner.set(value)
+        }
+
+        pub fn get_or_init<F>(&'static self, f: F) -> &'static T
+        where
+            F: FnOnce() -> T,
+        {
+            self.inner.get_or_init(f)
+        }
+
+        pub fn get_or_try_init<F, E>(&'static self, f: F) -> Result<&'static T, E>
+        where
+            F: FnOnce() -> Result<T, E>,
+        {
+            if let Some(val) = self.inner.get() {
+                return Ok(val);
+            }
+            let val = f()?;
+            let _ = self.inner.set(val);
+            Ok(self.inner.get().unwrap())
+        }
+    }
+
+    #[macro_export]
+    macro_rules! static_cell {
+        ($($(#[$attr:meta])* $vis:vis static $name:ident: $t:ty;)+) => {
+            $($(#[$attr])*
+            $vis static $name: $crate::static_cell::StaticCell<$t> =
+                $crate::static_cell::StaticCell::_from_once_cell($crate::lock::OnceCell::new());)+
+        };
+    }
+}
+#[cfg(feature = "threading")]
+pub use threading::*;
+
+#[cfg(all(not(feature = "threading"), feature = "std"))]
 mod non_threading {
     use crate::lock::OnceCell;
     use std::thread::LocalKey;
@@ -22,12 +76,10 @@ mod non_threading {
         }
 
         pub fn set(&'static self, value: T) -> Result<(), T> {
-            // thread-safe because it's a unsync::OnceCell
             self.inner.with(|x| {
                 if x.get().is_some() {
                     Err(value)
                 } else {
-                    // will never fail
                     let _ = x.set(leak(value));
                     Ok(())
                 }
@@ -45,8 +97,15 @@ mod non_threading {
         where
             F: FnOnce() -> Result<T, E>,
         {
-            self.inner
-                .with(|x| x.get_or_try_init(|| f().map(leak)).copied())
+            self.inner.with(|x| {
+                if let Some(val) = x.get() {
+                    Ok(*val)
+                } else {
+                    let val = leak(f()?);
+                    let _ = x.set(val);
+                    Ok(val)
+                }
+            })
         }
     }
 
@@ -65,43 +124,56 @@ mod non_threading {
         };
     }
 }
-#[cfg(not(feature = "threading"))]
+#[cfg(all(not(feature = "threading"), feature = "std"))]
 pub use non_threading::*;
 
-#[cfg(feature = "threading")]
-mod threading {
+// Same as `threading` variant, but wraps unsync::OnceCell with Sync.
+#[cfg(all(not(feature = "threading"), not(feature = "std")))]
+mod no_std {
     use crate::lock::OnceCell;
 
+    // unsync::OnceCell is !Sync, but without std there can be no threads.
+    struct SyncOnceCell<T>(OnceCell<T>);
+    // SAFETY: Without std, threading is impossible.
+    unsafe impl<T> Sync for SyncOnceCell<T> {}
+
     pub struct StaticCell<T: 'static> {
-        inner: OnceCell<T>,
+        inner: SyncOnceCell<T>,
     }
 
     impl<T> StaticCell<T> {
         #[doc(hidden)]
         pub const fn _from_once_cell(inner: OnceCell<T>) -> Self {
-            Self { inner }
+            Self {
+                inner: SyncOnceCell(inner),
+            }
         }
 
         pub fn get(&'static self) -> Option<&'static T> {
-            self.inner.get()
+            self.inner.0.get()
         }
 
         pub fn set(&'static self, value: T) -> Result<(), T> {
-            self.inner.set(value)
+            self.inner.0.set(value)
         }
 
         pub fn get_or_init<F>(&'static self, f: F) -> &'static T
         where
             F: FnOnce() -> T,
         {
-            self.inner.get_or_init(f)
+            self.inner.0.get_or_init(f)
         }
 
         pub fn get_or_try_init<F, E>(&'static self, f: F) -> Result<&'static T, E>
         where
             F: FnOnce() -> Result<T, E>,
         {
-            self.inner.get_or_try_init(f)
+            if let Some(val) = self.inner.0.get() {
+                return Ok(val);
+            }
+            let val = f()?;
+            let _ = self.inner.0.set(val);
+            Ok(self.inner.0.get().unwrap())
         }
     }
 
@@ -114,5 +186,5 @@ mod threading {
         };
     }
 }
-#[cfg(feature = "threading")]
-pub use threading::*;
+#[cfg(all(not(feature = "threading"), not(feature = "std")))]
+pub use no_std::*;
diff --git a/crates/common/src/str.rs b/crates/common/src/str.rs
index a250c5865d3..38e73a683f2 100644
--- a/crates/common/src/str.rs
+++ b/crates/common/src/str.rs
@@ -258,6 +258,7 @@ impl StrData {
         &self.data
     }
 
+    // TODO: rename to to_str
     #[inline]
     pub fn as_str(&self) -> Option<&str> {
         self.kind
@@ -429,13 +430,13 @@ pub fn zfill(bytes: &[u8], width: usize) -> Vec<u8> {
 
 /// Convert a string to ascii compatible, escaping unicode-s into escape
 /// sequences.
-pub fn to_ascii(value: &str) -> AsciiString {
+pub fn to_ascii(value: &Wtf8) -> AsciiString {
     let mut ascii = Vec::new();
-    for c in value.chars() {
-        if c.is_ascii() {
-            ascii.push(c as u8);
+    for cp in value.code_points() {
+        if cp.is_ascii() {
+            ascii.push(cp.to_u32() as u8);
         } else {
-            let c = c as i64;
+            let c = cp.to_u32();
             let hex = if c < 0x100 {
                 format!("\\x{c:02x}")
             } else if c < 0x10000 {
@@ -466,9 +467,6 @@ impl fmt::Display for UnicodeEscapeCodepoint {
 }
 
 pub mod levenshtein {
-    use core::cell::RefCell;
-    use std::thread_local;
-
     pub const MOVE_COST: usize = 2;
     const CASE_COST: usize = 1;
     const MAX_STRING_SIZE: usize = 40;
@@ -490,13 +488,6 @@ pub mod levenshtein {
     }
 
     pub fn levenshtein_distance(a: &[u8], b: &[u8], max_cost: usize) -> usize {
-        thread_local! {
-            #[allow(clippy::declare_interior_mutable_const)]
-            static BUFFER: RefCell<[usize; MAX_STRING_SIZE]> = const {
-                RefCell::new([0usize; MAX_STRING_SIZE])
-            };
-        }
-
         if a == b {
             return 0;
         }
@@ -535,33 +526,33 @@ pub mod levenshtein {
             return max_cost + 1;
         }
 
-        BUFFER.with_borrow_mut(|buffer| {
-            for (i, x) in buffer.iter_mut().take(a_end).enumerate() {
-                *x = (i + 1) * MOVE_COST;
-            }
+        let mut buffer = [0usize; MAX_STRING_SIZE];
 
-            let mut result = 0usize;
-            for (b_index, b_code) in b_bytes[b_begin..(b_begin + b_end)].iter().enumerate() {
-                result = b_index * MOVE_COST;
-                let mut distance = result;
-                let mut minimum = usize::MAX;
-                for (a_index, a_code) in a_bytes[a_begin..(a_begin + a_end)].iter().enumerate() {
-                    let substitute = distance + substitution_cost(*b_code, *a_code);
-                    distance = buffer[a_index];
-                    let insert_delete = usize::min(result, distance) + MOVE_COST;
-                    result = usize::min(insert_delete, substitute);
-
-                    buffer[a_index] = result;
-                    if result < minimum {
-                        minimum = result;
-                    }
-                }
-                if minimum > max_cost {
-                    return max_cost + 1;
+        for (i, x) in buffer.iter_mut().take(a_end).enumerate() {
+            *x = (i + 1) * MOVE_COST;
+        }
+
+        let mut result = 0usize;
+        for (b_index, b_code) in b_bytes[b_begin..(b_begin + b_end)].iter().enumerate() {
+            result = b_index * MOVE_COST;
+            let mut distance = result;
+            let mut minimum = usize::MAX;
+            for (a_index, a_code) in a_bytes[a_begin..(a_begin + a_end)].iter().enumerate() {
+                let substitute = distance + substitution_cost(*b_code, *a_code);
+                distance = buffer[a_index];
+                let insert_delete = usize::min(result, distance) + MOVE_COST;
+                result = usize::min(insert_delete, substitute);
+
+                buffer[a_index] = result;
+                if result < minimum {
+                    minimum = result;
                 }
             }
-            result
-        })
+            if minimum > max_cost {
+                return max_cost + 1;
+            }
+        }
+        result
     }
 }
 
diff --git a/crates/compiler-core/Cargo.toml b/crates/compiler-core/Cargo.toml
index f4e619b95a4..30d45d9f9c4 100644
--- a/crates/compiler-core/Cargo.toml
+++ b/crates/compiler-core/Cargo.toml
@@ -14,11 +14,12 @@ ruff_source_file = { workspace = true }
 rustpython-wtf8 = { workspace = true }
 
 bitflags = { workspace = true }
+bitflagset = { workspace = true }
 itertools = { workspace = true }
 malachite-bigint = { workspace = true }
 num-complex = { workspace = true }
 
-lz4_flex = "0.12"
+lz4_flex = "0.13"
 
 [lints]
 workspace = true
diff --git a/crates/compiler-core/src/bytecode.rs b/crates/compiler-core/src/bytecode.rs
index d177b728efa..a17fe7945de 100644
--- a/crates/compiler-core/src/bytecode.rs
+++ b/crates/compiler-core/src/bytecode.rs
@@ -3,12 +3,17 @@
 
 use crate::{
     marshal::MarshalError,
-    varint::{read_varint, read_varint_with_start, write_varint, write_varint_with_start},
+    varint::{read_varint, read_varint_with_start, write_varint_be, write_varint_with_start},
     {OneIndexed, SourceLocation},
 };
-use alloc::{collections::BTreeSet, fmt, vec::Vec};
+use alloc::{borrow::ToOwned, boxed::Box, collections::BTreeSet, fmt, string::String, vec::Vec};
 use bitflags::bitflags;
-use core::{hash, mem, ops::Deref};
+use core::{
+    cell::UnsafeCell,
+    hash, mem,
+    ops::{Deref, Index, IndexMut},
+    sync::atomic::{AtomicU8, AtomicU16, AtomicUsize, Ordering},
+};
 use itertools::Itertools;
 use malachite_bigint::BigInt;
 use num_complex::Complex64;
@@ -16,19 +21,18 @@ use rustpython_wtf8::{Wtf8, Wtf8Buf};
 
 pub use crate::bytecode::{
     instruction::{
-        AnyInstruction, Arg, Instruction, InstructionMetadata, PseudoInstruction,
-        decode_load_attr_arg, decode_load_super_attr_arg, encode_load_attr_arg,
-        encode_load_super_attr_arg,
+        AnyInstruction, Arg, Instruction, InstructionMetadata, PseudoInstruction, StackEffect,
     },
     oparg::{
         BinaryOperator, BuildSliceArgCount, CommonConstant, ComparisonOperator, ConvertValueOparg,
-        IntrinsicFunction1, IntrinsicFunction2, Invert, Label, MakeFunctionFlags, NameIdx, OpArg,
-        OpArgByte, OpArgState, OpArgType, RaiseKind, ResumeType, SpecialMethod, UnpackExArgs,
+        IntrinsicFunction1, IntrinsicFunction2, Invert, Label, LoadAttr, LoadSuperAttr,
+        MakeFunctionFlag, MakeFunctionFlags, NameIdx, OpArg, OpArgByte, OpArgState, OpArgType,
+        RaiseKind, SpecialMethod, UnpackExArgs,
     },
 };
 
 mod instruction;
-mod oparg;
+pub mod oparg;
 
 /// Exception table entry for zero-cost exception handling
 /// Format: (start, size, target, depth<<1|lasti)
@@ -67,9 +71,9 @@ pub fn encode_exception_table(entries: &[ExceptionTableEntry]) -> alloc::boxed::
         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);
+        write_varint_be(&mut data, size);
+        write_varint_be(&mut data, entry.target);
+        write_varint_be(&mut data, depth_lasti);
     }
     data.into_boxed_slice()
 }
@@ -100,6 +104,103 @@ pub fn find_exception_handler(table: &[u8], offset: u32) -> Option<ExceptionTabl
     None
 }
 
+/// Decode all exception table entries.
+pub fn decode_exception_table(table: &[u8]) -> Vec<ExceptionTableEntry> {
+    let mut entries = Vec::new();
+    let mut pos = 0;
+    while pos < table.len() {
+        let Some(start) = read_varint_with_start(table, &mut pos) else {
+            break;
+        };
+        let Some(size) = read_varint(table, &mut pos) else {
+            break;
+        };
+        let Some(target) = read_varint(table, &mut pos) else {
+            break;
+        };
+        let Some(depth_lasti) = read_varint(table, &mut pos) else {
+            break;
+        };
+        let Some(end) = start.checked_add(size) else {
+            break;
+        };
+        entries.push(ExceptionTableEntry {
+            start,
+            end,
+            target,
+            depth: (depth_lasti >> 1) as u16,
+            push_lasti: (depth_lasti & 1) != 0,
+        });
+    }
+    entries
+}
+
+/// Parse linetable to build a boolean mask indicating which code units
+/// have NO_LOCATION (line == -1). Returns a Vec<bool> of length `num_units`.
+pub fn build_no_location_mask(linetable: &[u8], num_units: usize) -> Vec<bool> {
+    let mut mask = Vec::new();
+    mask.resize(num_units, false);
+    let mut pos = 0;
+    let mut unit_idx = 0;
+
+    while pos < linetable.len() && unit_idx < num_units {
+        let header = linetable[pos];
+        pos += 1;
+        let code = (header >> 3) & 0xf;
+        let length = ((header & 7) + 1) as usize;
+
+        let is_no_location = code == PyCodeLocationInfoKind::None as u8;
+
+        // Skip payload bytes based on location kind
+        match code {
+            0..=9 => pos += 1,   // Short forms: 1 byte payload
+            10..=12 => pos += 2, // OneLine forms: 2 bytes payload
+            13 => {
+                // NoColumns: signed varint (line delta)
+                while pos < linetable.len() {
+                    let b = linetable[pos];
+                    pos += 1;
+                    if b & 0x40 == 0 {
+                        break;
+                    }
+                }
+            }
+            14 => {
+                // Long form: signed varint (line delta) + 3 unsigned varints
+                // line_delta
+                while pos < linetable.len() {
+                    let b = linetable[pos];
+                    pos += 1;
+                    if b & 0x40 == 0 {
+                        break;
+                    }
+                }
+                // end_line_delta, col+1, end_col+1
+                for _ in 0..3 {
+                    while pos < linetable.len() {
+                        let b = linetable[pos];
+                        pos += 1;
+                        if b & 0x40 == 0 {
+                            break;
+                        }
+                    }
+                }
+            }
+            15 => {} // None: no payload
+            _ => {}
+        }
+
+        for _ in 0..length {
+            if unit_idx < num_units {
+                mask[unit_idx] = is_no_location;
+                unit_idx += 1;
+            }
+        }
+    }
+
+    mask
+}
+
 /// CPython 3.11+ linetable location info codes
 #[derive(Copy, Clone, Debug, PartialEq, Eq)]
 #[repr(u8)]
@@ -169,7 +270,7 @@ impl PyCodeLocationInfoKind {
     }
 }
 
-pub trait Constant: Sized {
+pub trait Constant: Sized + Clone {
     type Name: AsRef<str>;
 
     /// Transforms the given Constant to a BorrowedConstant
@@ -191,6 +292,8 @@ impl Constant for ConstantData {
             Self::Bytes { value } => Bytes { value },
             Self::Code { code } => Code { code },
             Self::Tuple { elements } => Tuple { elements },
+            Self::Slice { elements } => Slice { elements },
+            Self::Frozenset { elements } => Frozenset { elements },
             Self::None => None,
             Self::Ellipsis => Ellipsis,
         }
@@ -258,6 +361,53 @@ impl ConstantBag for BasicBag {
     }
 }
 
+#[derive(Clone)]
+pub struct Constants<C: Constant>(Box<[C]>);
+
+impl<C: Constant> Deref for Constants<C> {
+    type Target = [C];
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+impl<C: Constant> Index<oparg::ConstIdx> for Constants<C> {
+    type Output = C;
+
+    fn index(&self, consti: oparg::ConstIdx) -> &Self::Output {
+        &self.0[consti.as_usize()]
+    }
+}
+
+impl<C: Constant> FromIterator<C> for Constants<C> {
+    fn from_iter<T: IntoIterator<Item = C>>(iter: T) -> Self {
+        Self(iter.into_iter().collect())
+    }
+}
+
+// TODO: Newtype "CodeObject.varnames". Make sure only `oparg:VarNum` can be used as index
+impl<T> Index<oparg::VarNum> for [T] {
+    type Output = T;
+
+    fn index(&self, var_num: oparg::VarNum) -> &Self::Output {
+        &self[var_num.as_usize()]
+    }
+}
+
+// TODO: Newtype "CodeObject.varnames". Make sure only `oparg:VarNum` can be used as index
+impl<T> IndexMut<oparg::VarNum> for [T] {
+    fn index_mut(&mut self, var_num: oparg::VarNum) -> &mut Self::Output {
+        &mut self[var_num.as_usize()]
+    }
+}
+
+/// Per-slot kind flags for localsplus (co_localspluskinds).
+pub const CO_FAST_HIDDEN: u8 = 0x10;
+pub const CO_FAST_LOCAL: u8 = 0x20;
+pub const CO_FAST_CELL: u8 = 0x40;
+pub const CO_FAST_FREE: u8 = 0x80;
+
 /// Primary container of a single code object. Each python function has
 /// a code object. Also a module has a code object.
 #[derive(Clone)]
@@ -276,12 +426,14 @@ pub struct CodeObject<C: Constant = ConstantData> {
     pub obj_name: C::Name,
     /// Qualified name of the object (like CPython's co_qualname)
     pub qualname: C::Name,
-    pub cell2arg: Option<Box<[i32]>>,
-    pub constants: Box<[C]>,
+    pub constants: Constants<C>,
     pub names: Box<[C::Name]>,
     pub varnames: Box<[C::Name]>,
     pub cellvars: Box<[C::Name]>,
     pub freevars: Box<[C::Name]>,
+    /// Per-slot kind flags: CO_FAST_LOCAL, CO_FAST_CELL, CO_FAST_FREE, CO_FAST_HIDDEN.
+    /// Length = nlocalsplus (nlocals + ncells + nfrees).
+    pub localspluskinds: Box<[u8]>,
     /// Line number table (CPython 3.11+ format)
     pub linetable: Box<[u8]>,
     /// Exception handling table
@@ -295,6 +447,7 @@ bitflags! {
         const NEWLOCALS = 0x0002;
         const VARARGS = 0x0004;
         const VARKEYWORDS = 0x0008;
+        const NESTED = 0x0010;
         const GENERATOR = 0x0020;
         const COROUTINE = 0x0080;
         const ITERABLE_COROUTINE = 0x0100;
@@ -304,8 +457,8 @@ bitflags! {
     }
 }
 
-#[derive(Copy, Clone)]
 #[repr(C)]
+#[derive(Copy, Clone, Debug)]
 pub struct CodeUnit {
     pub op: Instruction,
     pub arg: OpArgByte,
@@ -313,6 +466,49 @@ pub struct CodeUnit {
 
 const _: () = assert!(mem::size_of::<CodeUnit>() == 2);
 
+/// Adaptive specialization: number of executions before attempting specialization.
+///
+/// Matches CPython's `_Py_BackoffCounter` encoding.
+pub const ADAPTIVE_WARMUP_VALUE: u16 = adaptive_counter_bits(1, 1);
+/// Adaptive specialization: cooldown counter after a successful specialization.
+///
+/// Value/backoff = (52, 0), matching CPython's ADAPTIVE_COOLDOWN bits.
+pub const ADAPTIVE_COOLDOWN_VALUE: u16 = adaptive_counter_bits(52, 0);
+/// Initial JUMP_BACKWARD counter bits (value/backoff = 4095/12).
+pub const JUMP_BACKWARD_INITIAL_VALUE: u16 = adaptive_counter_bits(4095, 12);
+
+const BACKOFF_BITS: u16 = 4;
+const MAX_BACKOFF: u16 = 12;
+const UNREACHABLE_BACKOFF: u16 = 15;
+
+/// Encode an adaptive counter as `(value << 4) | backoff`.
+pub const fn adaptive_counter_bits(value: u16, backoff: u16) -> u16 {
+    (value << BACKOFF_BITS) | backoff
+}
+
+/// True when the adaptive counter should trigger specialization.
+#[inline]
+pub const fn adaptive_counter_triggers(counter: u16) -> bool {
+    counter < UNREACHABLE_BACKOFF
+}
+
+/// Decrement adaptive counter by one countdown step.
+#[inline]
+pub const fn advance_adaptive_counter(counter: u16) -> u16 {
+    counter.wrapping_sub(1 << BACKOFF_BITS)
+}
+
+/// Reset adaptive counter with exponential backoff.
+#[inline]
+pub const fn adaptive_counter_backoff(counter: u16) -> u16 {
+    let backoff = counter & ((1 << BACKOFF_BITS) - 1);
+    if backoff < MAX_BACKOFF {
+        adaptive_counter_bits((1 << (backoff + 1)) - 1, backoff + 1)
+    } else {
+        adaptive_counter_bits((1 << MAX_BACKOFF) - 1, MAX_BACKOFF)
+    }
+}
+
 impl CodeUnit {
     pub const fn new(op: Instruction, arg: OpArgByte) -> Self {
         Self { op, arg }
@@ -330,8 +526,54 @@ impl TryFrom<&[u8]> for CodeUnit {
     }
 }
 
-#[derive(Clone)]
-pub struct CodeUnits(Box<[CodeUnit]>);
+pub struct CodeUnits {
+    units: UnsafeCell<Box<[CodeUnit]>>,
+    adaptive_counters: Box<[AtomicU16]>,
+    /// Pointer-sized cache entries for descriptor pointers.
+    /// Single atomic load/store prevents torn reads when multiple threads
+    /// specialize the same instruction concurrently.
+    pointer_cache: Box<[AtomicUsize]>,
+}
+
+// SAFETY: All cache operations use atomic read/write instructions.
+// - replace_op / compare_exchange_op: AtomicU8 store/CAS (Release)
+// - cache read/write: AtomicU16 load/store (Relaxed)
+// - adaptive counter: AtomicU16 load/store (Relaxed)
+// Ordering is established by:
+// - replace_op (Release) ↔ dispatch loop read_op (Acquire) for cache data visibility
+// - tp_version_tag (Acquire) for descriptor pointer validity
+unsafe impl Sync for CodeUnits {}
+
+impl Clone for CodeUnits {
+    fn clone(&self) -> Self {
+        // SAFETY: No concurrent mutation during clone — cloning is only done
+        // during code object construction or marshaling, not while instrumented.
+        let units = unsafe { &*self.units.get() }.clone();
+        let adaptive_counters = self
+            .adaptive_counters
+            .iter()
+            .map(|c| AtomicU16::new(c.load(Ordering::Relaxed)))
+            .collect();
+        let pointer_cache = self
+            .pointer_cache
+            .iter()
+            .map(|c| AtomicUsize::new(c.load(Ordering::Relaxed)))
+            .collect();
+        Self {
+            units: UnsafeCell::new(units),
+            adaptive_counters,
+            pointer_cache,
+        }
+    }
+}
+
+impl fmt::Debug for CodeUnits {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        // SAFETY: Debug formatting doesn't race with replace_op
+        let inner = unsafe { &*self.units.get() };
+        f.debug_tuple("CodeUnits").field(inner).finish()
+    }
+}
 
 impl TryFrom<&[u8]> for CodeUnits {
     type Error = MarshalError;
@@ -341,25 +583,43 @@ impl TryFrom<&[u8]> for CodeUnits {
             return Err(Self::Error::InvalidBytecode);
         }
 
-        value.chunks_exact(2).map(CodeUnit::try_from).collect()
+        let units = value
+            .chunks_exact(2)
+            .map(CodeUnit::try_from)
+            .collect::<Result<Vec<_>, _>>()?;
+        Ok(units.into())
     }
 }
 
 impl<const N: usize> From<[CodeUnit; N]> for CodeUnits {
     fn from(value: [CodeUnit; N]) -> Self {
-        Self(Box::from(value))
+        Self::from(Vec::from(value))
     }
 }
 
 impl From<Vec<CodeUnit>> for CodeUnits {
     fn from(value: Vec<CodeUnit>) -> Self {
-        Self(value.into_boxed_slice())
+        let units = value.into_boxed_slice();
+        let len = units.len();
+        let adaptive_counters = (0..len)
+            .map(|_| AtomicU16::new(0))
+            .collect::<Vec<_>>()
+            .into_boxed_slice();
+        let pointer_cache = (0..len)
+            .map(|_| AtomicUsize::new(0))
+            .collect::<Vec<_>>()
+            .into_boxed_slice();
+        Self {
+            units: UnsafeCell::new(units),
+            adaptive_counters,
+            pointer_cache,
+        }
     }
 }
 
 impl FromIterator<CodeUnit> for CodeUnits {
     fn from_iter<T: IntoIterator<Item = CodeUnit>>(iter: T) -> Self {
-        Self(iter.into_iter().collect())
+        Self::from(iter.into_iter().collect::<Vec<_>>())
     }
 }
 
@@ -367,7 +627,216 @@ impl Deref for CodeUnits {
     type Target = [CodeUnit];
 
     fn deref(&self) -> &Self::Target {
-        &self.0
+        // SAFETY: Shared references to the slice are valid even while replace_op
+        // may update individual opcode bytes — readers tolerate stale opcodes
+        // (they will re-read on the next iteration).
+        unsafe { &*self.units.get() }
+    }
+}
+
+impl CodeUnits {
+    /// Disable adaptive specialization by setting all counters to unreachable.
+    /// Used for CPython-compiled bytecode where specialization may not be safe.
+    pub fn disable_specialization(&self) {
+        for counter in self.adaptive_counters.iter() {
+            counter.store(UNREACHABLE_BACKOFF, Ordering::Relaxed);
+        }
+    }
+
+    /// Replace the opcode at `index` in-place without changing the arg byte.
+    /// Uses atomic Release store to ensure prior cache writes are visible
+    /// to threads that subsequently read the new opcode with Acquire.
+    ///
+    /// # Safety
+    /// - `index` must be in bounds.
+    /// - `new_op` must have the same arg semantics as the original opcode.
+    pub unsafe fn replace_op(&self, index: usize, new_op: Instruction) {
+        let units = unsafe { &*self.units.get() };
+        let ptr = units.as_ptr().wrapping_add(index) as *const AtomicU8;
+        unsafe { &*ptr }.store(new_op.into(), Ordering::Release);
+    }
+
+    /// Atomically replace opcode only if it still matches `expected`.
+    /// Returns true on success. Uses Release ordering on success.
+    ///
+    /// # Safety
+    /// - `index` must be in bounds.
+    pub unsafe fn compare_exchange_op(
+        &self,
+        index: usize,
+        expected: Instruction,
+        new_op: Instruction,
+    ) -> bool {
+        let units = unsafe { &*self.units.get() };
+        let ptr = units.as_ptr().wrapping_add(index) as *const AtomicU8;
+        unsafe { &*ptr }
+            .compare_exchange(
+                expected.into(),
+                new_op.into(),
+                Ordering::Release,
+                Ordering::Relaxed,
+            )
+            .is_ok()
+    }
+
+    /// Atomically read the opcode at `index` with Acquire ordering.
+    /// Pairs with `replace_op` (Release) to ensure cache data visibility.
+    pub fn read_op(&self, index: usize) -> Instruction {
+        let units = unsafe { &*self.units.get() };
+        let ptr = units.as_ptr().wrapping_add(index) as *const AtomicU8;
+        let byte = unsafe { &*ptr }.load(Ordering::Acquire);
+        // SAFETY: Only valid Instruction values are stored via replace_op/compare_exchange_op.
+        unsafe { mem::transmute::<u8, Instruction>(byte) }
+    }
+
+    /// Atomically read the arg byte at `index` with Relaxed ordering.
+    pub fn read_arg(&self, index: usize) -> OpArgByte {
+        let units = unsafe { &*self.units.get() };
+        let ptr = units.as_ptr().wrapping_add(index) as *const u8;
+        let arg_ptr = unsafe { ptr.add(1) } as *const AtomicU8;
+        OpArgByte::from(unsafe { &*arg_ptr }.load(Ordering::Relaxed))
+    }
+
+    /// Write a u16 value into a CACHE code unit at `index`.
+    /// Each CodeUnit is 2 bytes (#[repr(C)]: op u8 + arg u8), so one u16 fits exactly.
+    /// Uses Relaxed atomic store; ordering is provided by replace_op (Release).
+    ///
+    /// # Safety
+    /// - `index` must be in bounds and point to a CACHE entry.
+    pub unsafe fn write_cache_u16(&self, index: usize, value: u16) {
+        let units = unsafe { &*self.units.get() };
+        let ptr = units.as_ptr().wrapping_add(index) as *const AtomicU16;
+        unsafe { &*ptr }.store(value, Ordering::Relaxed);
+    }
+
+    /// Read a u16 value from a CACHE code unit at `index`.
+    /// Uses Relaxed atomic load; ordering is provided by read_op (Acquire).
+    ///
+    /// # Panics
+    /// Panics if `index` is out of bounds.
+    pub fn read_cache_u16(&self, index: usize) -> u16 {
+        let units = unsafe { &*self.units.get() };
+        assert!(index < units.len(), "read_cache_u16: index out of bounds");
+        let ptr = units.as_ptr().wrapping_add(index) as *const AtomicU16;
+        unsafe { &*ptr }.load(Ordering::Relaxed)
+    }
+
+    /// Write a u32 value across two consecutive CACHE code units starting at `index`.
+    ///
+    /// # Safety
+    /// Same requirements as `write_cache_u16`.
+    pub unsafe fn write_cache_u32(&self, index: usize, value: u32) {
+        unsafe {
+            self.write_cache_u16(index, value as u16);
+            self.write_cache_u16(index + 1, (value >> 16) as u16);
+        }
+    }
+
+    /// Read a u32 value from two consecutive CACHE code units starting at `index`.
+    ///
+    /// # Panics
+    /// Panics if `index + 1` is out of bounds.
+    pub fn read_cache_u32(&self, index: usize) -> u32 {
+        let lo = self.read_cache_u16(index) as u32;
+        let hi = self.read_cache_u16(index + 1) as u32;
+        lo | (hi << 16)
+    }
+
+    /// Store a pointer-sized value atomically in the pointer cache at `index`.
+    ///
+    /// Uses a single `AtomicUsize` store to prevent torn writes when
+    /// multiple threads specialize the same instruction concurrently.
+    ///
+    /// # Safety
+    /// - `index` must be in bounds.
+    /// - `value` must be `0` or a valid `*const PyObject` encoded as `usize`.
+    /// - Callers must follow the cache invalidation/upgrade protocol:
+    ///   invalidate the version guard before writing and publish the new
+    ///   version after writing.
+    pub unsafe fn write_cache_ptr(&self, index: usize, value: usize) {
+        self.pointer_cache[index].store(value, Ordering::Relaxed);
+    }
+
+    /// Load a pointer-sized value atomically from the pointer cache at `index`.
+    ///
+    /// Uses a single `AtomicUsize` load to prevent torn reads.
+    ///
+    /// # Panics
+    /// Panics if `index` is out of bounds.
+    pub fn read_cache_ptr(&self, index: usize) -> usize {
+        self.pointer_cache[index].load(Ordering::Relaxed)
+    }
+
+    /// Read adaptive counter bits for instruction at `index`.
+    /// Uses Relaxed atomic load.
+    pub fn read_adaptive_counter(&self, index: usize) -> u16 {
+        self.adaptive_counters[index].load(Ordering::Relaxed)
+    }
+
+    /// Write adaptive counter bits for instruction at `index`.
+    /// Uses Relaxed atomic store.
+    ///
+    /// # Safety
+    /// - `index` must be in bounds.
+    pub unsafe fn write_adaptive_counter(&self, index: usize, value: u16) {
+        self.adaptive_counters[index].store(value, Ordering::Relaxed);
+    }
+
+    /// Produce a clean copy of the bytecode suitable for serialization
+    /// (marshal) and `co_code`. Specialized opcodes are mapped back to their
+    /// base variants via `deoptimize()` and all CACHE entries are zeroed.
+    pub fn original_bytes(&self) -> Vec<u8> {
+        let len = self.len();
+        let mut out = Vec::with_capacity(len * 2);
+        let mut i = 0;
+        while i < len {
+            let op = self.read_op(i).deoptimize();
+            let arg = self.read_arg(i);
+            let caches = op.cache_entries();
+            out.push(u8::from(op));
+            out.push(u8::from(arg));
+            // Zero-fill all CACHE entries (counter + cached data)
+            for _ in 0..caches {
+                i += 1;
+                out.push(0); // op = Cache = 0
+                out.push(0); // arg = 0
+            }
+            i += 1;
+        }
+        out
+    }
+
+    /// Initialize adaptive warmup counters for all cacheable instructions.
+    /// Called lazily at RESUME (first execution of a code object).
+    /// Counters are stored out-of-line to preserve `op = Instruction::Cache`.
+    /// All writes are atomic (Relaxed) to avoid data races with concurrent readers.
+    pub fn quicken(&self) {
+        let len = self.len();
+        let mut i = 0;
+        while i < len {
+            let op = self.read_op(i);
+            let caches = op.cache_entries();
+            if caches > 0 {
+                // Don't write adaptive counter for instrumented opcodes;
+                // specialization is skipped while monitoring is active.
+                if !op.is_instrumented() {
+                    let cache_base = i + 1;
+                    if cache_base < len {
+                        let initial_counter = if matches!(op, Instruction::JumpBackward { .. }) {
+                            JUMP_BACKWARD_INITIAL_VALUE
+                        } else {
+                            ADAPTIVE_WARMUP_VALUE
+                        };
+                        unsafe {
+                            self.write_adaptive_counter(cache_base, initial_counter);
+                        }
+                    }
+                }
+                i += 1 + caches;
+            } else {
+                i += 1;
+            }
+        }
     }
 }
 
@@ -382,14 +851,37 @@ impl Deref for CodeUnits {
 /// ```
 #[derive(Debug, Clone)]
 pub enum ConstantData {
-    Tuple { elements: Vec<ConstantData> },
-    Integer { value: BigInt },
-    Float { value: f64 },
-    Complex { value: Complex64 },
-    Boolean { value: bool },
-    Str { value: Wtf8Buf },
-    Bytes { value: Vec<u8> },
-    Code { code: Box<CodeObject> },
+    Tuple {
+        elements: Vec<ConstantData>,
+    },
+    Integer {
+        value: BigInt,
+    },
+    Float {
+        value: f64,
+    },
+    Complex {
+        value: Complex64,
+    },
+    Boolean {
+        value: bool,
+    },
+    Str {
+        value: Wtf8Buf,
+    },
+    Bytes {
+        value: Vec<u8>,
+    },
+    Code {
+        code: Box<CodeObject>,
+    },
+    /// Constant slice(start, stop, step)
+    Slice {
+        elements: Box<[ConstantData; 3]>,
+    },
+    Frozenset {
+        elements: Vec<ConstantData>,
+    },
     None,
     Ellipsis,
 }
@@ -411,6 +903,8 @@ impl PartialEq for ConstantData {
             (Bytes { value: a }, Bytes { value: b }) => a == b,
             (Code { code: a }, Code { code: b }) => core::ptr::eq(a.as_ref(), b.as_ref()),
             (Tuple { elements: a }, Tuple { elements: b }) => a == b,
+            (Slice { elements: a }, Slice { elements: b }) => a == b,
+            (Frozenset { elements: a }, Frozenset { elements: b }) => a == b,
             (None, None) => true,
             (Ellipsis, Ellipsis) => true,
             _ => false,
@@ -437,6 +931,8 @@ impl hash::Hash for ConstantData {
             Bytes { value } => value.hash(state),
             Code { code } => core::ptr::hash(code.as_ref(), state),
             Tuple { elements } => elements.hash(state),
+            Slice { elements } => elements.hash(state),
+            Frozenset { elements } => elements.hash(state),
             None => {}
             Ellipsis => {}
         }
@@ -453,6 +949,8 @@ pub enum BorrowedConstant<'a, C: Constant> {
     Bytes { value: &'a [u8] },
     Code { code: &'a CodeObject<C> },
     Tuple { elements: &'a [C] },
+    Slice { elements: &'a [C; 3] },
+    Frozenset { elements: &'a [C] },
     None,
     Ellipsis,
 }
@@ -490,6 +988,28 @@ impl<C: Constant> BorrowedConstant<'_, C> {
                 }
                 write!(f, ")")
             }
+            BorrowedConstant::Slice { elements } => {
+                write!(f, "slice(")?;
+                elements[0].borrow_constant().fmt_display(f)?;
+                write!(f, ", ")?;
+                elements[1].borrow_constant().fmt_display(f)?;
+                write!(f, ", ")?;
+                elements[2].borrow_constant().fmt_display(f)?;
+                write!(f, ")")
+            }
+            BorrowedConstant::Frozenset { elements } => {
+                write!(f, "frozenset({{")?;
+                let mut first = true;
+                for c in *elements {
+                    if first {
+                        first = false
+                    } else {
+                        write!(f, ", ")?;
+                    }
+                    c.borrow_constant().fmt_display(f)?;
+                }
+                write!(f, "}})")
+            }
             BorrowedConstant::None => write!(f, "None"),
             BorrowedConstant::Ellipsis => write!(f, "..."),
         }
@@ -520,6 +1040,15 @@ impl<C: Constant> BorrowedConstant<'_, C> {
                     .map(|c| c.borrow_constant().to_owned())
                     .collect(),
             },
+            BorrowedConstant::Slice { elements } => Slice {
+                elements: Box::new(elements.each_ref().map(|c| c.borrow_constant().to_owned())),
+            },
+            BorrowedConstant::Frozenset { elements } => Frozenset {
+                elements: elements
+                    .iter()
+                    .map(|c| c.borrow_constant().to_owned())
+                    .collect(),
+            },
             BorrowedConstant::None => None,
             BorrowedConstant::Ellipsis => Ellipsis,
         }
@@ -640,7 +1169,7 @@ impl<C: Constant> CodeObject<C> {
             }
 
             // arrow and offset
-            let arrow = if label_targets.contains(&Label(offset as u32)) {
+            let arrow = if label_targets.contains(&Label::from_u32(offset as u32)) {
                 ">>"
             } else {
                 "  "
@@ -669,16 +1198,14 @@ impl<C: Constant> CodeObject<C> {
     pub fn map_bag<Bag: ConstantBag>(self, bag: Bag) -> CodeObject<Bag::Constant> {
         let map_names = |names: Box<[C::Name]>| {
             names
-                .into_vec()
-                .into_iter()
+                .iter()
                 .map(|x| bag.make_name(x.as_ref()))
                 .collect::<Box<[_]>>()
         };
         CodeObject {
             constants: self
                 .constants
-                .into_vec()
-                .into_iter()
+                .iter()
                 .map(|x| bag.make_constant(x.borrow_constant()))
                 .collect(),
             names: map_names(self.names),
@@ -697,7 +1224,7 @@ impl<C: Constant> CodeObject<C> {
             kwonlyarg_count: self.kwonlyarg_count,
             first_line_number: self.first_line_number,
             max_stackdepth: self.max_stackdepth,
-            cell2arg: self.cell2arg,
+            localspluskinds: self.localspluskinds,
             linetable: self.linetable,
             exceptiontable: self.exceptiontable,
         }
@@ -729,7 +1256,7 @@ impl<C: Constant> CodeObject<C> {
             kwonlyarg_count: self.kwonlyarg_count,
             first_line_number: self.first_line_number,
             max_stackdepth: self.max_stackdepth,
-            cell2arg: self.cell2arg.clone(),
+            localspluskinds: self.localspluskinds.clone(),
             linetable: self.linetable.clone(),
             exceptiontable: self.exceptiontable.clone(),
         }
@@ -752,35 +1279,43 @@ impl<C: Constant> fmt::Display for CodeObject<C> {
 pub trait InstrDisplayContext {
     type Constant: Constant;
 
-    fn get_constant(&self, i: usize) -> &Self::Constant;
+    fn get_constant(&self, consti: oparg::ConstIdx) -> &Self::Constant;
 
     fn get_name(&self, i: usize) -> &str;
 
-    fn get_varname(&self, i: usize) -> &str;
+    fn get_varname(&self, var_num: oparg::VarNum) -> &str;
 
-    fn get_cell_name(&self, i: usize) -> &str;
+    /// Get name for a localsplus index (used by DEREF instructions).
+    fn get_localsplus_name(&self, var_num: oparg::VarNum) -> &str;
 }
 
 impl<C: Constant> InstrDisplayContext for CodeObject<C> {
     type Constant = C;
 
-    fn get_constant(&self, i: usize) -> &C {
-        &self.constants[i]
+    fn get_constant(&self, consti: oparg::ConstIdx) -> &C {
+        &self.constants[consti]
     }
 
     fn get_name(&self, i: usize) -> &str {
         self.names[i].as_ref()
     }
 
-    fn get_varname(&self, i: usize) -> &str {
-        self.varnames[i].as_ref()
+    fn get_varname(&self, var_num: oparg::VarNum) -> &str {
+        self.varnames[var_num].as_ref()
     }
 
-    fn get_cell_name(&self, i: usize) -> &str {
-        self.cellvars
-            .get(i)
-            .unwrap_or_else(|| &self.freevars[i - self.cellvars.len()])
-            .as_ref()
+    fn get_localsplus_name(&self, var_num: oparg::VarNum) -> &str {
+        let idx = var_num.as_usize();
+        let nlocals = self.varnames.len();
+        if idx < nlocals {
+            self.varnames[idx].as_ref()
+        } else {
+            let cell_idx = idx - nlocals;
+            self.cellvars
+                .get(cell_idx)
+                .unwrap_or_else(|| &self.freevars[cell_idx - self.cellvars.len()])
+                .as_ref()
+        }
     }
 }
 
@@ -805,6 +1340,7 @@ impl<C: Constant> fmt::Debug for CodeObject<C> {
 #[cfg(test)]
 mod tests {
     use super::*;
+    use alloc::{vec, vec::Vec};
 
     #[test]
     fn test_exception_table_encode_decode() {
diff --git a/crates/compiler-core/src/bytecode/instruction.rs b/crates/compiler-core/src/bytecode/instruction.rs
index 4bf15cf5772..76dc6a79381 100644
--- a/crates/compiler-core/src/bytecode/instruction.rs
+++ b/crates/compiler-core/src/bytecode/instruction.rs
@@ -4,10 +4,10 @@ use crate::{
     bytecode::{
         BorrowedConstant, Constant, InstrDisplayContext,
         oparg::{
-            BinaryOperator, BuildSliceArgCount, CommonConstant, ComparisonOperator,
-            ConvertValueOparg, IntrinsicFunction1, IntrinsicFunction2, Invert, Label,
-            MakeFunctionFlags, NameIdx, OpArg, OpArgByte, OpArgType, RaiseKind, SpecialMethod,
-            UnpackExArgs,
+            self, BinaryOperator, BuildSliceArgCount, CommonConstant, ComparisonOperator,
+            ConvertValueOparg, IntrinsicFunction1, IntrinsicFunction2, Invert, Label, LoadAttr,
+            LoadSuperAttr, MakeFunctionFlag, NameIdx, OpArg, OpArgByte, OpArgType, RaiseKind,
+            SpecialMethod, UnpackExArgs,
         },
     },
     marshal::MarshalError,
@@ -79,28 +79,28 @@ pub enum Instruction {
     ///
     /// Stack: [value, expression_str, format_spec?] -> [interpolation]
     BuildInterpolation {
-        oparg: Arg<u32>,
+        format: Arg<u32>,
     } = 45,
     BuildList {
-        size: Arg<u32>,
+        count: Arg<u32>,
     } = 46,
     BuildMap {
-        size: Arg<u32>,
+        count: Arg<u32>,
     } = 47,
     BuildSet {
-        size: Arg<u32>,
+        count: Arg<u32>,
     } = 48,
     BuildSlice {
         argc: Arg<BuildSliceArgCount>,
     } = 49,
     BuildString {
-        size: Arg<u32>,
+        count: Arg<u32>,
     } = 50,
     BuildTuple {
-        size: Arg<u32>,
+        count: Arg<u32>,
     } = 51,
     Call {
-        nargs: Arg<u32>,
+        argc: Arg<u32>,
     } = 52,
     CallIntrinsic1 {
         func: Arg<IntrinsicFunction1>,
@@ -109,55 +109,69 @@ pub enum Instruction {
         func: Arg<IntrinsicFunction2>,
     } = 54,
     CallKw {
-        nargs: Arg<u32>,
+        argc: Arg<u32>,
     } = 55,
     CompareOp {
-        op: Arg<ComparisonOperator>,
+        opname: Arg<ComparisonOperator>,
     } = 56,
-    ContainsOp(Arg<Invert>) = 57,
+    ContainsOp {
+        invert: Arg<Invert>,
+    } = 57,
     ConvertValue {
         oparg: Arg<ConvertValueOparg>,
     } = 58,
     Copy {
-        index: Arg<u32>,
+        i: Arg<u32>,
     } = 59,
     CopyFreeVars {
-        count: Arg<u32>,
+        n: Arg<u32>,
     } = 60,
     DeleteAttr {
-        idx: Arg<NameIdx>,
+        namei: Arg<NameIdx>,
     } = 61,
-    DeleteDeref(Arg<NameIdx>) = 62,
-    DeleteFast(Arg<NameIdx>) = 63,
-    DeleteGlobal(Arg<NameIdx>) = 64,
-    DeleteName(Arg<NameIdx>) = 65,
+    DeleteDeref {
+        i: Arg<oparg::VarNum>,
+    } = 62,
+    DeleteFast {
+        var_num: Arg<oparg::VarNum>,
+    } = 63,
+    DeleteGlobal {
+        namei: Arg<NameIdx>,
+    } = 64,
+    DeleteName {
+        namei: Arg<NameIdx>,
+    } = 65,
     DictMerge {
-        index: Arg<u32>,
+        i: Arg<u32>,
     } = 66,
     DictUpdate {
-        index: Arg<u32>,
+        i: Arg<u32>,
     } = 67,
     EndAsyncFor = 68,
     ExtendedArg = 69,
     ForIter {
-        target: Arg<Label>,
+        delta: Arg<Label>,
     } = 70,
-    GetAwaitable = 71, // TODO: Make this instruction to hold an oparg
+    GetAwaitable {
+        r#where: Arg<u32>,
+    } = 71,
     ImportFrom {
-        idx: Arg<NameIdx>,
+        namei: Arg<NameIdx>,
     } = 72,
     ImportName {
-        idx: Arg<NameIdx>,
+        namei: Arg<NameIdx>,
     } = 73,
-    IsOp(Arg<Invert>) = 74,
+    IsOp {
+        invert: Arg<Invert>,
+    } = 74,
     JumpBackward {
-        target: Arg<Label>,
+        delta: Arg<Label>,
     } = 75,
     JumpBackwardNoInterrupt {
-        target: Arg<Label>,
+        delta: Arg<Label>,
     } = 76, // Placeholder
     JumpForward {
-        target: Arg<Label>,
+        delta: Arg<Label>,
     } = 77,
     ListAppend {
         i: Arg<u32>,
@@ -166,102 +180,131 @@ pub enum Instruction {
         i: Arg<u32>,
     } = 79,
     LoadAttr {
-        idx: Arg<NameIdx>,
+        namei: Arg<LoadAttr>,
     } = 80,
     LoadCommonConstant {
         idx: Arg<CommonConstant>,
     } = 81,
     LoadConst {
-        idx: Arg<u32>,
+        consti: Arg<oparg::ConstIdx>,
     } = 82,
-    LoadDeref(Arg<NameIdx>) = 83,
-    LoadFast(Arg<NameIdx>) = 84,
-    LoadFastAndClear(Arg<NameIdx>) = 85,
-    LoadFastBorrow(Arg<NameIdx>) = 86,
+    LoadDeref {
+        i: Arg<oparg::VarNum>,
+    } = 83,
+    LoadFast {
+        var_num: Arg<oparg::VarNum>,
+    } = 84,
+    LoadFastAndClear {
+        var_num: Arg<oparg::VarNum>,
+    } = 85,
+    LoadFastBorrow {
+        var_num: Arg<oparg::VarNum>,
+    } = 86,
     LoadFastBorrowLoadFastBorrow {
-        arg: Arg<u32>,
+        var_nums: Arg<oparg::VarNums>,
     } = 87,
-    LoadFastCheck(Arg<NameIdx>) = 88,
+    LoadFastCheck {
+        var_num: Arg<oparg::VarNum>,
+    } = 88,
     LoadFastLoadFast {
-        arg: Arg<u32>,
+        var_nums: Arg<oparg::VarNums>,
     } = 89,
-    LoadFromDictOrDeref(Arg<NameIdx>) = 90,
-    LoadFromDictOrGlobals(Arg<NameIdx>) = 91,
-    LoadGlobal(Arg<NameIdx>) = 92,
-    LoadName(Arg<NameIdx>) = 93,
+    LoadFromDictOrDeref {
+        i: Arg<oparg::VarNum>,
+    } = 90,
+    LoadFromDictOrGlobals {
+        i: Arg<NameIdx>,
+    } = 91,
+    LoadGlobal {
+        namei: Arg<NameIdx>,
+    } = 92,
+    LoadName {
+        namei: Arg<NameIdx>,
+    } = 93,
     LoadSmallInt {
-        idx: Arg<u32>,
+        i: Arg<u32>,
     } = 94,
     LoadSpecial {
         method: Arg<SpecialMethod>,
     } = 95,
     LoadSuperAttr {
-        arg: Arg<u32>,
+        namei: Arg<LoadSuperAttr>,
     } = 96,
-    MakeCell(Arg<NameIdx>) = 97,
+    MakeCell {
+        i: Arg<oparg::VarNum>,
+    } = 97,
     MapAdd {
         i: Arg<u32>,
     } = 98,
-    MatchClass(Arg<u32>) = 99,
+    MatchClass {
+        count: Arg<u32>,
+    } = 99,
     PopJumpIfFalse {
-        target: Arg<Label>,
+        delta: Arg<Label>,
     } = 100,
     PopJumpIfNone {
-        target: Arg<Label>,
+        delta: Arg<Label>,
     } = 101,
     PopJumpIfNotNone {
-        target: Arg<Label>,
+        delta: Arg<Label>,
     } = 102,
     PopJumpIfTrue {
-        target: Arg<Label>,
+        delta: Arg<Label>,
     } = 103,
     RaiseVarargs {
-        kind: Arg<RaiseKind>,
+        argc: Arg<RaiseKind>,
     } = 104,
     Reraise {
         depth: Arg<u32>,
     } = 105,
     Send {
-        target: Arg<Label>,
+        delta: Arg<Label>,
     } = 106,
     SetAdd {
         i: Arg<u32>,
     } = 107,
     SetFunctionAttribute {
-        attr: Arg<MakeFunctionFlags>,
+        flag: Arg<MakeFunctionFlag>,
     } = 108,
     SetUpdate {
         i: Arg<u32>,
     } = 109,
     StoreAttr {
-        idx: Arg<NameIdx>,
+        namei: Arg<NameIdx>,
     } = 110,
-    StoreDeref(Arg<NameIdx>) = 111,
-    StoreFast(Arg<NameIdx>) = 112,
+    StoreDeref {
+        i: Arg<oparg::VarNum>,
+    } = 111,
+    StoreFast {
+        var_num: Arg<oparg::VarNum>,
+    } = 112,
     StoreFastLoadFast {
-        store_idx: Arg<NameIdx>,
-        load_idx: Arg<NameIdx>,
+        var_nums: Arg<oparg::VarNums>,
     } = 113,
     StoreFastStoreFast {
-        arg: Arg<u32>,
+        var_nums: Arg<oparg::VarNums>,
     } = 114,
-    StoreGlobal(Arg<NameIdx>) = 115,
-    StoreName(Arg<NameIdx>) = 116,
+    StoreGlobal {
+        namei: Arg<NameIdx>,
+    } = 115,
+    StoreName {
+        namei: Arg<NameIdx>,
+    } = 116,
     Swap {
-        index: Arg<u32>,
+        i: Arg<u32>,
     } = 117,
     UnpackEx {
-        args: Arg<UnpackExArgs>,
+        counts: Arg<UnpackExArgs>,
     } = 118,
     UnpackSequence {
-        size: Arg<u32>,
+        count: Arg<u32>,
     } = 119,
     YieldValue {
         arg: Arg<u32>,
     } = 120,
     // CPython 3.14 RESUME (128)
     Resume {
-        arg: Arg<u32>,
+        context: Arg<oparg::ResumeContext>,
     } = 128,
     // CPython 3.14 specialized opcodes (129-211)
     BinaryOpAddFloat = 129,                     // Placeholder
@@ -348,28 +391,28 @@ pub enum Instruction {
     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
+    InstrumentedEndFor = 234,
+    InstrumentedPopIter = 235,
+    InstrumentedEndSend = 236,
+    InstrumentedForIter = 237,
+    InstrumentedInstruction = 238,
+    InstrumentedJumpForward = 239,
     InstrumentedNotTaken = 240,
-    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
+    InstrumentedPopJumpIfTrue = 241,
+    InstrumentedPopJumpIfFalse = 242,
+    InstrumentedPopJumpIfNone = 243,
+    InstrumentedPopJumpIfNotNone = 244,
+    InstrumentedResume = 245,
+    InstrumentedReturnValue = 246,
+    InstrumentedYieldValue = 247,
+    InstrumentedEndAsyncFor = 248,
+    InstrumentedLoadSuperAttr = 249,
+    InstrumentedCall = 250,
+    InstrumentedCallKw = 251,
+    InstrumentedCallFunctionEx = 252,
+    InstrumentedJumpBackward = 253,
+    InstrumentedLine = 254,
+    EnterExecutor = 255, // Placeholder
 }
 
 const _: () = assert!(mem::size_of::<Instruction>() == 1);
@@ -392,7 +435,9 @@ impl TryFrom<u8> for Instruction {
         let cpython_end = u8::from(Self::YieldValue { arg: Arg::marker() });
 
         // Resume has a non-contiguous opcode (128)
-        let resume_id = u8::from(Self::Resume { arg: Arg::marker() });
+        let resume_id = u8::from(Self::Resume {
+            context: Arg::marker(),
+        });
         let enter_executor_id = u8::from(Self::EnterExecutor);
 
         let specialized_start = u8::from(Self::BinaryOpAddFloat);
@@ -401,13 +446,9 @@ impl TryFrom<u8> for Instruction {
         let instrumented_start = u8::from(Self::InstrumentedEndFor);
         let instrumented_end = u8::from(Self::InstrumentedLine);
 
-        // No RustPython-only opcodes anymore - all opcodes match CPython 3.14
-        let custom_ops: &[u8] = &[];
-
         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)
         {
@@ -418,19 +459,379 @@ impl TryFrom<u8> for Instruction {
     }
 }
 
+impl Instruction {
+    /// Returns `true` if this is any instrumented opcode
+    /// (regular INSTRUMENTED_*, INSTRUMENTED_LINE, or INSTRUMENTED_INSTRUCTION).
+    pub const fn is_instrumented(self) -> bool {
+        self.to_base().is_some()
+            || matches!(self, Self::InstrumentedLine | Self::InstrumentedInstruction)
+    }
+
+    /// Map a base opcode to its INSTRUMENTED_* variant.
+    /// Returns `None` if this opcode has no instrumented counterpart.
+    ///
+    /// # Panics (debug)
+    /// Panics if called on an already-instrumented opcode.
+    pub fn to_instrumented(self) -> Option<Self> {
+        debug_assert!(
+            !self.is_instrumented(),
+            "to_instrumented called on already-instrumented opcode {self:?}"
+        );
+        Some(match self {
+            Self::Resume { .. } => Self::InstrumentedResume,
+            Self::ReturnValue => Self::InstrumentedReturnValue,
+            Self::YieldValue { .. } => Self::InstrumentedYieldValue,
+            Self::Call { .. } => Self::InstrumentedCall,
+            Self::CallKw { .. } => Self::InstrumentedCallKw,
+            Self::CallFunctionEx => Self::InstrumentedCallFunctionEx,
+            Self::LoadSuperAttr { .. } => Self::InstrumentedLoadSuperAttr,
+            Self::JumpForward { .. } => Self::InstrumentedJumpForward,
+            Self::JumpBackward { .. } => Self::InstrumentedJumpBackward,
+            Self::ForIter { .. } => Self::InstrumentedForIter,
+            Self::EndFor => Self::InstrumentedEndFor,
+            Self::EndSend => Self::InstrumentedEndSend,
+            Self::PopJumpIfTrue { .. } => Self::InstrumentedPopJumpIfTrue,
+            Self::PopJumpIfFalse { .. } => Self::InstrumentedPopJumpIfFalse,
+            Self::PopJumpIfNone { .. } => Self::InstrumentedPopJumpIfNone,
+            Self::PopJumpIfNotNone { .. } => Self::InstrumentedPopJumpIfNotNone,
+            Self::NotTaken => Self::InstrumentedNotTaken,
+            Self::PopIter => Self::InstrumentedPopIter,
+            Self::EndAsyncFor => Self::InstrumentedEndAsyncFor,
+            _ => return None,
+        })
+    }
+
+    /// Map an INSTRUMENTED_* opcode back to its base variant.
+    /// Returns `None` for non-instrumented opcodes, and also for
+    /// `InstrumentedLine` / `InstrumentedInstruction` which are event-layer
+    /// placeholders without a fixed base opcode (the real opcode is stored in
+    /// `CoMonitoringData`).
+    ///
+    /// The returned base opcode uses `Arg::marker()` for typed fields —
+    /// only the opcode byte matters since `replace_op` preserves the arg byte.
+    pub const fn to_base(self) -> Option<Self> {
+        Some(match self {
+            Self::InstrumentedResume => Self::Resume {
+                context: Arg::marker(),
+            },
+            Self::InstrumentedReturnValue => Self::ReturnValue,
+            Self::InstrumentedYieldValue => Self::YieldValue { arg: Arg::marker() },
+            Self::InstrumentedCall => Self::Call {
+                argc: Arg::marker(),
+            },
+            Self::InstrumentedCallKw => Self::CallKw {
+                argc: Arg::marker(),
+            },
+            Self::InstrumentedCallFunctionEx => Self::CallFunctionEx,
+            Self::InstrumentedLoadSuperAttr => Self::LoadSuperAttr {
+                namei: Arg::marker(),
+            },
+            Self::InstrumentedJumpForward => Self::JumpForward {
+                delta: Arg::marker(),
+            },
+            Self::InstrumentedJumpBackward => Self::JumpBackward {
+                delta: Arg::marker(),
+            },
+            Self::InstrumentedForIter => Self::ForIter {
+                delta: Arg::marker(),
+            },
+            Self::InstrumentedEndFor => Self::EndFor,
+            Self::InstrumentedEndSend => Self::EndSend,
+            Self::InstrumentedPopJumpIfTrue => Self::PopJumpIfTrue {
+                delta: Arg::marker(),
+            },
+            Self::InstrumentedPopJumpIfFalse => Self::PopJumpIfFalse {
+                delta: Arg::marker(),
+            },
+            Self::InstrumentedPopJumpIfNone => Self::PopJumpIfNone {
+                delta: Arg::marker(),
+            },
+            Self::InstrumentedPopJumpIfNotNone => Self::PopJumpIfNotNone {
+                delta: Arg::marker(),
+            },
+            Self::InstrumentedNotTaken => Self::NotTaken,
+            Self::InstrumentedPopIter => Self::PopIter,
+            Self::InstrumentedEndAsyncFor => Self::EndAsyncFor,
+            _ => return None,
+        })
+    }
+
+    /// Map a specialized opcode back to its adaptive (base) variant.
+    /// `_PyOpcode_Deopt`
+    pub const fn deopt(self) -> Option<Self> {
+        Some(match self {
+            // RESUME specializations
+            Self::ResumeCheck => Self::Resume {
+                context: Arg::marker(),
+            },
+            // LOAD_CONST specializations
+            Self::LoadConstMortal | Self::LoadConstImmortal => Self::LoadConst {
+                consti: Arg::marker(),
+            },
+            // TO_BOOL specializations
+            Self::ToBoolAlwaysTrue
+            | Self::ToBoolBool
+            | Self::ToBoolInt
+            | Self::ToBoolList
+            | Self::ToBoolNone
+            | Self::ToBoolStr => Self::ToBool,
+            // BINARY_OP specializations
+            Self::BinaryOpMultiplyInt
+            | Self::BinaryOpAddInt
+            | Self::BinaryOpSubtractInt
+            | Self::BinaryOpMultiplyFloat
+            | Self::BinaryOpAddFloat
+            | Self::BinaryOpSubtractFloat
+            | Self::BinaryOpAddUnicode
+            | Self::BinaryOpSubscrListInt
+            | Self::BinaryOpSubscrListSlice
+            | Self::BinaryOpSubscrTupleInt
+            | Self::BinaryOpSubscrStrInt
+            | Self::BinaryOpSubscrDict
+            | Self::BinaryOpSubscrGetitem
+            | Self::BinaryOpExtend
+            | Self::BinaryOpInplaceAddUnicode => Self::BinaryOp { op: Arg::marker() },
+            // STORE_SUBSCR specializations
+            Self::StoreSubscrDict | Self::StoreSubscrListInt => Self::StoreSubscr,
+            // SEND specializations
+            Self::SendGen => Self::Send {
+                delta: Arg::marker(),
+            },
+            // UNPACK_SEQUENCE specializations
+            Self::UnpackSequenceTwoTuple | Self::UnpackSequenceTuple | Self::UnpackSequenceList => {
+                Self::UnpackSequence {
+                    count: Arg::marker(),
+                }
+            }
+            // STORE_ATTR specializations
+            Self::StoreAttrInstanceValue | Self::StoreAttrSlot | Self::StoreAttrWithHint => {
+                Self::StoreAttr {
+                    namei: Arg::marker(),
+                }
+            }
+            // LOAD_GLOBAL specializations
+            Self::LoadGlobalModule | Self::LoadGlobalBuiltin => Self::LoadGlobal {
+                namei: Arg::marker(),
+            },
+            // LOAD_SUPER_ATTR specializations
+            Self::LoadSuperAttrAttr | Self::LoadSuperAttrMethod => Self::LoadSuperAttr {
+                namei: Arg::marker(),
+            },
+            // LOAD_ATTR specializations
+            Self::LoadAttrInstanceValue
+            | Self::LoadAttrModule
+            | Self::LoadAttrWithHint
+            | Self::LoadAttrSlot
+            | Self::LoadAttrClass
+            | Self::LoadAttrClassWithMetaclassCheck
+            | Self::LoadAttrProperty
+            | Self::LoadAttrGetattributeOverridden
+            | Self::LoadAttrMethodWithValues
+            | Self::LoadAttrMethodNoDict
+            | Self::LoadAttrMethodLazyDict
+            | Self::LoadAttrNondescriptorWithValues
+            | Self::LoadAttrNondescriptorNoDict => Self::LoadAttr {
+                namei: Arg::marker(),
+            },
+            // COMPARE_OP specializations
+            Self::CompareOpFloat | Self::CompareOpInt | Self::CompareOpStr => Self::CompareOp {
+                opname: Arg::marker(),
+            },
+            // CONTAINS_OP specializations
+            Self::ContainsOpSet | Self::ContainsOpDict => Self::ContainsOp {
+                invert: Arg::marker(),
+            },
+            // JUMP_BACKWARD specializations
+            Self::JumpBackwardNoJit | Self::JumpBackwardJit => Self::JumpBackward {
+                delta: Arg::marker(),
+            },
+            // FOR_ITER specializations
+            Self::ForIterList | Self::ForIterTuple | Self::ForIterRange | Self::ForIterGen => {
+                Self::ForIter {
+                    delta: Arg::marker(),
+                }
+            }
+            // CALL specializations
+            Self::CallBoundMethodExactArgs
+            | Self::CallPyExactArgs
+            | Self::CallType1
+            | Self::CallStr1
+            | Self::CallTuple1
+            | Self::CallBuiltinClass
+            | Self::CallBuiltinO
+            | Self::CallBuiltinFast
+            | Self::CallBuiltinFastWithKeywords
+            | Self::CallLen
+            | Self::CallIsinstance
+            | Self::CallListAppend
+            | Self::CallMethodDescriptorO
+            | Self::CallMethodDescriptorFastWithKeywords
+            | Self::CallMethodDescriptorNoargs
+            | Self::CallMethodDescriptorFast
+            | Self::CallAllocAndEnterInit
+            | Self::CallPyGeneral
+            | Self::CallBoundMethodGeneral
+            | Self::CallNonPyGeneral => Self::Call {
+                argc: Arg::marker(),
+            },
+            // CALL_KW specializations
+            Self::CallKwBoundMethod | Self::CallKwPy | Self::CallKwNonPy => Self::CallKw {
+                argc: Arg::marker(),
+            },
+            _ => return None,
+        })
+    }
+
+    /// Map a specialized or instrumented opcode back to its adaptive (base) variant.
+    pub const fn deoptimize(self) -> Self {
+        match self.deopt() {
+            Some(v) => v,
+            None => {
+                // Instrumented opcodes map back to their base
+                match self.to_base() {
+                    Some(v) => v,
+                    None => self,
+                }
+            }
+        }
+    }
+
+    /// Number of CACHE code units that follow this instruction.
+    /// _PyOpcode_Caches
+    pub const fn cache_entries(self) -> usize {
+        match self {
+            // LOAD_ATTR: 9 cache entries
+            Self::LoadAttr { .. }
+            | Self::LoadAttrClass
+            | Self::LoadAttrClassWithMetaclassCheck
+            | Self::LoadAttrGetattributeOverridden
+            | Self::LoadAttrInstanceValue
+            | Self::LoadAttrMethodLazyDict
+            | Self::LoadAttrMethodNoDict
+            | Self::LoadAttrMethodWithValues
+            | Self::LoadAttrModule
+            | Self::LoadAttrNondescriptorNoDict
+            | Self::LoadAttrNondescriptorWithValues
+            | Self::LoadAttrProperty
+            | Self::LoadAttrSlot
+            | Self::LoadAttrWithHint => 9,
+
+            // BINARY_OP: 5 cache entries
+            Self::BinaryOp { .. }
+            | Self::BinaryOpAddFloat
+            | Self::BinaryOpAddInt
+            | Self::BinaryOpAddUnicode
+            | Self::BinaryOpExtend
+            | Self::BinaryOpInplaceAddUnicode
+            | Self::BinaryOpMultiplyFloat
+            | Self::BinaryOpMultiplyInt
+            | Self::BinaryOpSubscrDict
+            | Self::BinaryOpSubscrGetitem
+            | Self::BinaryOpSubscrListInt
+            | Self::BinaryOpSubscrListSlice
+            | Self::BinaryOpSubscrStrInt
+            | Self::BinaryOpSubscrTupleInt
+            | Self::BinaryOpSubtractFloat
+            | Self::BinaryOpSubtractInt => 5,
+
+            // LOAD_GLOBAL / STORE_ATTR: 4 cache entries
+            Self::LoadGlobal { .. }
+            | Self::LoadGlobalBuiltin
+            | Self::LoadGlobalModule
+            | Self::StoreAttr { .. }
+            | Self::StoreAttrInstanceValue
+            | Self::StoreAttrSlot
+            | Self::StoreAttrWithHint => 4,
+
+            // CALL / CALL_KW / TO_BOOL: 3 cache entries
+            Self::Call { .. }
+            | Self::CallAllocAndEnterInit
+            | Self::CallBoundMethodExactArgs
+            | Self::CallBoundMethodGeneral
+            | Self::CallBuiltinClass
+            | Self::CallBuiltinFast
+            | Self::CallBuiltinFastWithKeywords
+            | Self::CallBuiltinO
+            | Self::CallIsinstance
+            | Self::CallLen
+            | Self::CallListAppend
+            | Self::CallMethodDescriptorFast
+            | Self::CallMethodDescriptorFastWithKeywords
+            | Self::CallMethodDescriptorNoargs
+            | Self::CallMethodDescriptorO
+            | Self::CallNonPyGeneral
+            | Self::CallPyExactArgs
+            | Self::CallPyGeneral
+            | Self::CallStr1
+            | Self::CallTuple1
+            | Self::CallType1
+            | Self::CallKw { .. }
+            | Self::CallKwBoundMethod
+            | Self::CallKwNonPy
+            | Self::CallKwPy
+            | Self::ToBool
+            | Self::ToBoolAlwaysTrue
+            | Self::ToBoolBool
+            | Self::ToBoolInt
+            | Self::ToBoolList
+            | Self::ToBoolNone
+            | Self::ToBoolStr => 3,
+
+            // 1 cache entry
+            Self::CompareOp { .. }
+            | Self::CompareOpFloat
+            | Self::CompareOpInt
+            | Self::CompareOpStr
+            | Self::ContainsOp { .. }
+            | Self::ContainsOpDict
+            | Self::ContainsOpSet
+            | Self::ForIter { .. }
+            | Self::ForIterGen
+            | Self::ForIterList
+            | Self::ForIterRange
+            | Self::ForIterTuple
+            | Self::JumpBackward { .. }
+            | Self::JumpBackwardJit
+            | Self::JumpBackwardNoJit
+            | Self::LoadSuperAttr { .. }
+            | Self::LoadSuperAttrAttr
+            | Self::LoadSuperAttrMethod
+            | Self::PopJumpIfTrue { .. }
+            | Self::PopJumpIfFalse { .. }
+            | Self::PopJumpIfNone { .. }
+            | Self::PopJumpIfNotNone { .. }
+            | Self::Send { .. }
+            | Self::SendGen
+            | Self::StoreSubscr
+            | Self::StoreSubscrDict
+            | Self::StoreSubscrListInt
+            | Self::UnpackSequence { .. }
+            | Self::UnpackSequenceList
+            | Self::UnpackSequenceTuple
+            | Self::UnpackSequenceTwoTuple => 1,
+
+            // Instrumented opcodes have the same cache entries as their base
+            _ => match self.to_base() {
+                Some(base) => base.cache_entries(),
+                None => 0,
+            },
+        }
+    }
+}
+
 impl InstructionMetadata for Instruction {
     #[inline]
     fn label_arg(&self) -> Option<Arg<Label>> {
         match self {
-            Self::JumpBackward { target: l }
-            | Self::JumpBackwardNoInterrupt { target: l }
-            | Self::JumpForward { target: l }
-            | Self::PopJumpIfTrue { target: l }
-            | Self::PopJumpIfFalse { target: l }
-            | Self::PopJumpIfNone { target: l }
-            | Self::PopJumpIfNotNone { target: l }
-            | Self::ForIter { target: l }
-            | Self::Send { target: l } => Some(*l),
+            Self::JumpBackward { delta: l }
+            | Self::JumpBackwardNoInterrupt { delta: l }
+            | Self::JumpForward { delta: l }
+            | Self::PopJumpIfTrue { delta: l }
+            | Self::PopJumpIfFalse { delta: l }
+            | Self::PopJumpIfNone { delta: l }
+            | Self::PopJumpIfNotNone { delta: l }
+            | Self::ForIter { delta: l }
+            | Self::Send { delta: l } => Some(*l),
             _ => None,
         }
     }
@@ -451,293 +852,247 @@ impl InstructionMetadata for Instruction {
         )
     }
 
-    fn stack_effect(&self, arg: OpArg) -> 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,
-            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(_) => 0, // (dict -- value)
-            Self::StoreSubscr => -3,
-            Self::DeleteSubscr => -2,
-            Self::LoadAttr { idx } => {
-                // Stack effect depends on method flag in encoded oparg
-                // method=false: pop obj, push attr → effect = 0
-                // method=true: pop obj, push (method, self_or_null) → effect = +1
-                let (_, is_method) = decode_load_attr_arg(idx.get(arg));
-                if is_method { 1 } else { 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,
-            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::PopJumpIfTrue { .. } => -1,
-            Self::PopJumpIfFalse { .. } => -1,
-            Self::MakeFunction => {
-                // CPython 3.14 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: 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,
-            Self::FormatWithSpec => -1,
-            Self::ForIter { .. } => 1, // push next value
-            Self::IsOp(_) => -1,
-            Self::ContainsOp(_) => -1,
-            Self::ReturnValue => -1,
-            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::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::WithExceptStart => 1, // push __exit__ result
-            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::BuildList { size, .. } => -(size.get(arg) as i32) + 1,
-            Self::BuildSet { size, .. } => -(size.get(arg) as i32) + 1,
-            Self::BuildMap { size } => {
-                let nargs = size.get(arg) * 2;
-                -(nargs as i32) + 1
-            }
-            Self::DictUpdate { .. } => -1,
-            Self::DictMerge { .. } => -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::ListExtend { .. } => -1,
-            Self::SetAdd { .. } => -1,
-            Self::SetUpdate { .. } => -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 => -1,
-            Self::PopIter => -1,
-            Self::GetAwaitable => 0,
-            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
-            // 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::Cache => 0,
-            Self::BinarySlice => -2, // (container, start, stop -- res)
-            Self::BinaryOpInplaceAddUnicode => 0,
-            Self::EndFor => -1,        // pop next value at end of loop iteration
-            Self::ExitInitCheck => -1, // (should_be_none -- )
-            Self::InterpreterExit => 0,
-            Self::LoadLocals => 1,      // ( -- locals)
-            Self::ReturnGenerator => 1, // pushes None for POP_TOP to consume
-            Self::StoreSlice => -4,     // (v, container, start, stop -- )
-            Self::CopyFreeVars { .. } => 0,
-            Self::EnterExecutor => 0,
-            Self::JumpBackwardNoInterrupt { .. } => 0,
-            Self::JumpBackward { .. } => 0,
-            Self::JumpForward { .. } => 0,
-            Self::LoadFastCheck(_) => 1,
-            Self::LoadFastLoadFast { .. } => 2,
-            Self::LoadFastBorrowLoadFastBorrow { .. } => 2,
-            Self::LoadFromDictOrGlobals(_) => 0,
-            Self::MakeCell(_) => 0,
-            Self::StoreFastStoreFast { .. } => -2, // pops 2 values
-            Self::PopJumpIfNone { .. } => -1,      // (value -- )
-            Self::PopJumpIfNotNone { .. } => -1,   // (value -- )
-            Self::BinaryOpAddFloat => 0,
-            Self::BinaryOpAddInt => 0,
-            Self::BinaryOpAddUnicode => 0,
-            Self::BinaryOpExtend => 0,
-            Self::BinaryOpMultiplyFloat => 0,
-            Self::BinaryOpMultiplyInt => 0,
-            Self::BinaryOpSubtractFloat => 0,
-            Self::BinaryOpSubtractInt => 0,
-            Self::BinaryOpSubscrDict => 0,
-            Self::BinaryOpSubscrGetitem => 0,
-            Self::BinaryOpSubscrListInt => 0,
-            Self::BinaryOpSubscrListSlice => 0,
-            Self::BinaryOpSubscrStrInt => 0,
-            Self::BinaryOpSubscrTupleInt => 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::CallKwBoundMethod => 0,
-            Self::CallKwNonPy => 0,
-            Self::CallKwPy => 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::JumpBackwardJit => 0,
-            Self::JumpBackwardNoJit => 0,
-            Self::LoadAttrClass => 0,
-            Self::LoadAttrClassWithMetaclassCheck => 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::LoadConstImmortal => 0,
-            Self::LoadConstMortal => 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::InstrumentedEndFor => 0,
-            Self::InstrumentedPopIter => -1,
-            Self::InstrumentedEndSend => 0,
-            Self::InstrumentedForIter => 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,
-            // 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 }
-            }
-        }
+    fn stack_effect_info(&self, oparg: u32) -> StackEffect {
+        // Reason for converting oparg to i32 is because of expressions like `1 + (oparg -1)`
+        // that causes underflow errors.
+        let oparg = i32::try_from(oparg).expect("oparg does not fit in an `i32`");
+
+        // NOTE: Please don't "simplify" expressions here (i.e. `1 + (oparg - 1)`)
+        // as it will be harder to see diff with what CPython auto-generates
+        let (pushed, popped) = match self {
+            Self::BinaryOp { .. } => (1, 2),
+            Self::BinaryOpAddFloat => (1, 2),
+            Self::BinaryOpAddInt => (1, 2),
+            Self::BinaryOpAddUnicode => (1, 2),
+            Self::BinaryOpExtend => (1, 2),
+            Self::BinaryOpInplaceAddUnicode => (0, 2),
+            Self::BinaryOpMultiplyFloat => (1, 2),
+            Self::BinaryOpMultiplyInt => (1, 2),
+            Self::BinaryOpSubscrDict => (1, 2),
+            Self::BinaryOpSubscrGetitem => (0, 2),
+            Self::BinaryOpSubscrListInt => (1, 2),
+            Self::BinaryOpSubscrListSlice => (1, 2),
+            Self::BinaryOpSubscrStrInt => (1, 2),
+            Self::BinaryOpSubscrTupleInt => (1, 2),
+            Self::BinaryOpSubtractFloat => (1, 2),
+            Self::BinaryOpSubtractInt => (1, 2),
+            Self::BinarySlice { .. } => (1, 3),
+            Self::BuildInterpolation { .. } => (1, 2 + (oparg & 1)),
+            Self::BuildList { .. } => (1, oparg),
+            Self::BuildMap { .. } => (1, oparg * 2),
+            Self::BuildSet { .. } => (1, oparg),
+            Self::BuildSlice { .. } => (1, oparg),
+            Self::BuildString { .. } => (1, oparg),
+            Self::BuildTemplate { .. } => (1, 2),
+            Self::BuildTuple { .. } => (1, oparg),
+            Self::Cache => (0, 0),
+            Self::Call { .. } => (1, 2 + oparg),
+            Self::CallAllocAndEnterInit => (0, 2 + oparg),
+            Self::CallBoundMethodExactArgs => (0, 2 + oparg),
+            Self::CallBoundMethodGeneral => (0, 2 + oparg),
+            Self::CallBuiltinClass => (1, 2 + oparg),
+            Self::CallBuiltinFast => (1, 2 + oparg),
+            Self::CallBuiltinFastWithKeywords => (1, 2 + oparg),
+            Self::CallBuiltinO => (1, 2 + oparg),
+            Self::CallFunctionEx => (1, 4),
+            Self::CallIntrinsic1 { .. } => (1, 1),
+            Self::CallIntrinsic2 { .. } => (1, 2),
+            Self::CallIsinstance => (1, 2 + oparg),
+            Self::CallKw { .. } => (1, 3 + oparg),
+            Self::CallKwBoundMethod => (0, 3 + oparg),
+            Self::CallKwNonPy => (1, 3 + oparg),
+            Self::CallKwPy => (0, 3 + oparg),
+            Self::CallLen => (1, 3),
+            Self::CallListAppend => (0, 3),
+            Self::CallMethodDescriptorFast => (1, 2 + oparg),
+            Self::CallMethodDescriptorFastWithKeywords => (1, 2 + oparg),
+            Self::CallMethodDescriptorNoargs => (1, 2 + oparg),
+            Self::CallMethodDescriptorO => (1, 2 + oparg),
+            Self::CallNonPyGeneral => (1, 2 + oparg),
+            Self::CallPyExactArgs => (0, 2 + oparg),
+            Self::CallPyGeneral => (0, 2 + oparg),
+            Self::CallStr1 => (1, 3),
+            Self::CallTuple1 => (1, 3),
+            Self::CallType1 => (1, 3),
+            Self::CheckEgMatch => (2, 2),
+            Self::CheckExcMatch => (2, 2),
+            Self::CleanupThrow => (2, 3),
+            Self::CompareOp { .. } => (1, 2),
+            Self::CompareOpFloat => (1, 2),
+            Self::CompareOpInt => (1, 2),
+            Self::CompareOpStr => (1, 2),
+            Self::ContainsOp { .. } => (1, 2),
+            Self::ContainsOpDict => (1, 2),
+            Self::ContainsOpSet => (1, 2),
+            Self::ConvertValue { .. } => (1, 1),
+            Self::Copy { .. } => (2 + (oparg - 1), 1 + (oparg - 1)),
+            Self::CopyFreeVars { .. } => (0, 0),
+            Self::DeleteAttr { .. } => (0, 1),
+            Self::DeleteDeref { .. } => (0, 0),
+            Self::DeleteFast { .. } => (0, 0),
+            Self::DeleteGlobal { .. } => (0, 0),
+            Self::DeleteName { .. } => (0, 0),
+            Self::DeleteSubscr => (0, 2),
+            Self::DictMerge { .. } => (4 + (oparg - 1), 5 + (oparg - 1)),
+            Self::DictUpdate { .. } => (1 + (oparg - 1), 2 + (oparg - 1)),
+            Self::EndAsyncFor => (0, 2),
+            Self::EndFor => (0, 1),
+            Self::EndSend => (1, 2),
+            Self::EnterExecutor => (0, 0),
+            Self::ExitInitCheck => (0, 1),
+            Self::ExtendedArg => (0, 0),
+            Self::ForIter { .. } => (2, 1),
+            Self::ForIterGen => (1, 1),
+            Self::ForIterList => (2, 1),
+            Self::ForIterRange => (2, 1),
+            Self::ForIterTuple => (2, 1),
+            Self::FormatSimple => (1, 1),
+            Self::FormatWithSpec => (1, 2),
+            Self::GetAIter => (1, 1),
+            Self::GetANext => (2, 1),
+            Self::GetAwaitable { .. } => (1, 1),
+            Self::GetIter => (1, 1),
+            Self::GetLen => (2, 1),
+            Self::GetYieldFromIter => (1, 1),
+            Self::ImportFrom { .. } => (2, 1),
+            Self::ImportName { .. } => (1, 2),
+            Self::InstrumentedCall => (1, 2 + oparg),
+            Self::InstrumentedCallFunctionEx => (1, 4),
+            Self::InstrumentedCallKw => (1, 3 + oparg),
+            Self::InstrumentedEndAsyncFor => (0, 2),
+            Self::InstrumentedEndFor => (1, 2),
+            Self::InstrumentedEndSend => (1, 2),
+            Self::InstrumentedForIter => (2, 1),
+            Self::InstrumentedInstruction => (0, 0),
+            Self::InstrumentedJumpBackward => (0, 0),
+            Self::InstrumentedJumpForward => (0, 0),
+            Self::InstrumentedLine => (0, 0),
+            Self::InstrumentedLoadSuperAttr => (1 + (oparg & 1), 3),
+            Self::InstrumentedNotTaken => (0, 0),
+            Self::InstrumentedPopIter => (0, 1),
+            Self::InstrumentedPopJumpIfFalse => (0, 1),
+            Self::InstrumentedPopJumpIfNone => (0, 1),
+            Self::InstrumentedPopJumpIfNotNone => (0, 1),
+            Self::InstrumentedPopJumpIfTrue => (0, 1),
+            Self::InstrumentedResume => (0, 0),
+            Self::InstrumentedReturnValue => (1, 1),
+            Self::InstrumentedYieldValue => (1, 1),
+            Self::InterpreterExit => (0, 1),
+            Self::IsOp { .. } => (1, 2),
+            Self::JumpBackward { .. } => (0, 0),
+            Self::JumpBackwardJit => (0, 0),
+            Self::JumpBackwardNoInterrupt { .. } => (0, 0),
+            Self::JumpBackwardNoJit => (0, 0),
+            Self::JumpForward { .. } => (0, 0),
+            Self::ListAppend { .. } => (1 + (oparg - 1), 2 + (oparg - 1)),
+            Self::ListExtend { .. } => (1 + (oparg - 1), 2 + (oparg - 1)),
+            Self::LoadAttr { .. } => (1 + (oparg & 1), 1),
+            Self::LoadAttrClass => (1 + (oparg & 1), 1),
+            Self::LoadAttrClassWithMetaclassCheck => (1 + (oparg & 1), 1),
+            Self::LoadAttrGetattributeOverridden => (1, 1),
+            Self::LoadAttrInstanceValue => (1 + (oparg & 1), 1),
+            Self::LoadAttrMethodLazyDict => (2, 1),
+            Self::LoadAttrMethodNoDict => (2, 1),
+            Self::LoadAttrMethodWithValues => (2, 1),
+            Self::LoadAttrModule => (1 + (oparg & 1), 1),
+            Self::LoadAttrNondescriptorNoDict => (1, 1),
+            Self::LoadAttrNondescriptorWithValues => (1, 1),
+            Self::LoadAttrProperty => (0, 1),
+            Self::LoadAttrSlot => (1 + (oparg & 1), 1),
+            Self::LoadAttrWithHint => (1 + (oparg & 1), 1),
+            Self::LoadBuildClass => (1, 0),
+            Self::LoadCommonConstant { .. } => (1, 0),
+            Self::LoadConst { .. } => (1, 0),
+            Self::LoadConstImmortal => (1, 0),
+            Self::LoadConstMortal => (1, 0),
+            Self::LoadDeref { .. } => (1, 0),
+            Self::LoadFast { .. } => (1, 0),
+            Self::LoadFastAndClear { .. } => (1, 0),
+            Self::LoadFastBorrow { .. } => (1, 0),
+            Self::LoadFastBorrowLoadFastBorrow { .. } => (2, 0),
+            Self::LoadFastCheck { .. } => (1, 0),
+            Self::LoadFastLoadFast { .. } => (2, 0),
+            Self::LoadFromDictOrDeref { .. } => (1, 1),
+            Self::LoadFromDictOrGlobals { .. } => (1, 1),
+            Self::LoadGlobal { .. } => (1 + (oparg & 1), 0),
+            Self::LoadGlobalBuiltin => (1 + (oparg & 1), 0),
+            Self::LoadGlobalModule => (1 + (oparg & 1), 0),
+            Self::LoadLocals => (1, 0),
+            Self::LoadName { .. } => (1, 0),
+            Self::LoadSmallInt { .. } => (1, 0),
+            Self::LoadSpecial { .. } => (2, 1),
+            Self::LoadSuperAttr { .. } => (1 + (oparg & 1), 3),
+            Self::LoadSuperAttrAttr => (1, 3),
+            Self::LoadSuperAttrMethod => (2, 3),
+            Self::MakeCell { .. } => (0, 0),
+            Self::MakeFunction { .. } => (1, 1),
+            Self::MapAdd { .. } => (1 + (oparg - 1), 3 + (oparg - 1)),
+            Self::MatchClass { .. } => (1, 3),
+            Self::MatchKeys { .. } => (3, 2),
+            Self::MatchMapping => (2, 1),
+            Self::MatchSequence => (2, 1),
+            Self::Nop => (0, 0),
+            Self::NotTaken => (0, 0),
+            Self::PopExcept => (0, 1),
+            Self::PopIter => (0, 1),
+            Self::PopJumpIfFalse { .. } => (0, 1),
+            Self::PopJumpIfNone { .. } => (0, 1),
+            Self::PopJumpIfNotNone { .. } => (0, 1),
+            Self::PopJumpIfTrue { .. } => (0, 1),
+            Self::PopTop => (0, 1),
+            Self::PushExcInfo => (2, 1),
+            Self::PushNull => (1, 0),
+            Self::RaiseVarargs { .. } => (0, oparg),
+            Self::Reraise { .. } => (oparg, 1 + oparg),
+            Self::Reserved => (0, 0),
+            Self::Resume { .. } => (0, 0),
+            Self::ResumeCheck => (0, 0),
+            Self::ReturnGenerator => (1, 0),
+            Self::ReturnValue => (1, 1),
+            Self::Send { .. } => (2, 2),
+            Self::SendGen => (1, 2),
+            Self::SetAdd { .. } => (1 + (oparg - 1), 2 + (oparg - 1)),
+            Self::SetFunctionAttribute { .. } => (1, 2),
+            Self::SetUpdate { .. } => (1 + (oparg - 1), 2 + (oparg - 1)),
+            Self::SetupAnnotations => (0, 0),
+            Self::StoreAttr { .. } => (0, 2),
+            Self::StoreAttrInstanceValue => (0, 2),
+            Self::StoreAttrSlot => (0, 2),
+            Self::StoreAttrWithHint => (0, 2),
+            Self::StoreDeref { .. } => (0, 1),
+            Self::StoreFast { .. } => (0, 1),
+            Self::StoreFastLoadFast { .. } => (1, 1),
+            Self::StoreFastStoreFast { .. } => (0, 2),
+            Self::StoreGlobal { .. } => (0, 1),
+            Self::StoreName { .. } => (0, 1),
+            Self::StoreSlice => (0, 4),
+            Self::StoreSubscr => (0, 3),
+            Self::StoreSubscrDict => (0, 3),
+            Self::StoreSubscrListInt => (0, 3),
+            Self::Swap { .. } => (2 + (oparg - 2), 2 + (oparg - 2)),
+            Self::ToBool => (1, 1),
+            Self::ToBoolAlwaysTrue => (1, 1),
+            Self::ToBoolBool => (1, 1),
+            Self::ToBoolInt => (1, 1),
+            Self::ToBoolList => (1, 1),
+            Self::ToBoolNone => (1, 1),
+            Self::ToBoolStr => (1, 1),
+            Self::UnaryInvert => (1, 1),
+            Self::UnaryNegative => (1, 1),
+            Self::UnaryNot => (1, 1),
+            Self::UnpackEx { .. } => (1 + (oparg & 0xFF) + (oparg >> 8), 1),
+            Self::UnpackSequence { .. } => (oparg, 1),
+            Self::UnpackSequenceList => (oparg, 1),
+            Self::UnpackSequenceTuple => (oparg, 1),
+            Self::UnpackSequenceTwoTuple => (2, 1),
+            Self::WithExceptStart => (7, 6),
+            Self::YieldValue { .. } => (1, 1),
+        };
+
+        debug_assert!((0..=i32::MAX).contains(&pushed));
+        debug_assert!((0..=i32::MAX).contains(&popped));
+
+        StackEffect::new(pushed as u32, popped as u32)
     }
 
     #[allow(clippy::too_many_arguments)]
@@ -771,110 +1126,118 @@ impl InstructionMetadata for Instruction {
             };
         }
 
-        let varname = |i: u32| ctx.get_varname(i as usize);
+        let varname = |var_num: oparg::VarNum| ctx.get_varname(var_num);
         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, ")")
-                    }
+        let cell_name = |i: oparg::VarNum| ctx.get_localsplus_name(i);
+
+        let fmt_const = |op: &str,
+                         arg: OpArg,
+                         f: &mut fmt::Formatter<'_>,
+                         consti: &Arg<oparg::ConstIdx>|
+         -> fmt::Result {
+            let value = ctx.get_constant(consti.get(arg));
+            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::BinarySlice => w!(BINARY_SLICE),
             Self::BinaryOp { op } => write!(f, "{:pad$}({})", "BINARY_OP", op.get(arg)),
-            Self::BuildList { size } => w!(BUILD_LIST, size),
-            Self::BuildMap { size } => w!(BUILD_MAP, size),
-            Self::BuildSet { size } => w!(BUILD_SET, size),
+            Self::BinaryOpInplaceAddUnicode => w!(BINARY_OP_INPLACE_ADD_UNICODE),
+            Self::BuildList { count } => w!(BUILD_LIST, count),
+            Self::BuildMap { count } => w!(BUILD_MAP, count),
+            Self::BuildSet { count } => w!(BUILD_SET, count),
             Self::BuildSlice { argc } => w!(BUILD_SLICE, ?argc),
-            Self::BuildString { size } => w!(BUILD_STRING, size),
-            Self::BuildTuple { size } => w!(BUILD_TUPLE, size),
-            Self::Call { nargs } => w!(CALL, nargs),
+            Self::BuildString { count } => w!(BUILD_STRING, count),
+            Self::BuildTuple { count } => w!(BUILD_TUPLE, count),
+            Self::Call { argc } => w!(CALL, argc),
             Self::CallFunctionEx => w!(CALL_FUNCTION_EX),
-            Self::CallKw { nargs } => w!(CALL_KW, nargs),
+            Self::CallKw { argc } => w!(CALL_KW, argc),
             Self::CallIntrinsic1 { func } => w!(CALL_INTRINSIC_1, ?func),
             Self::CallIntrinsic2 { func } => w!(CALL_INTRINSIC_2, ?func),
+            Self::Cache => w!(CACHE),
             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::CompareOp { opname } => w!(COMPARE_OP, ?opname),
+            Self::ContainsOp { invert } => w!(CONTAINS_OP, ?invert),
             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::Copy { i } => w!(COPY, i),
+            Self::CopyFreeVars { n } => w!(COPY_FREE_VARS, n),
+            Self::DeleteAttr { namei } => w!(DELETE_ATTR, name = namei),
+            Self::DeleteDeref { i } => w!(DELETE_DEREF, cell_name = i),
+            Self::DeleteFast { var_num } => w!(DELETE_FAST, varname = var_num),
+            Self::DeleteGlobal { namei } => w!(DELETE_GLOBAL, name = namei),
+            Self::DeleteName { namei } => w!(DELETE_NAME, name = namei),
             Self::DeleteSubscr => w!(DELETE_SUBSCR),
-            Self::DictMerge { index } => w!(DICT_MERGE, index),
-            Self::DictUpdate { index } => w!(DICT_UPDATE, index),
+            Self::DictMerge { i } => w!(DICT_MERGE, i),
+            Self::DictUpdate { i } => w!(DICT_UPDATE, i),
             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::ExitInitCheck => w!(EXIT_INIT_CHECK),
+            Self::ForIter { delta } => w!(FOR_ITER, delta),
             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::GetAwaitable { r#where } => w!(GET_AWAITABLE, r#where),
             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::JumpBackward { target } => w!(JUMP_BACKWARD, target),
-            Self::JumpBackwardNoInterrupt { target } => w!(JUMP_BACKWARD_NO_INTERRUPT, target),
-            Self::JumpForward { target } => w!(JUMP_FORWARD, target),
+            Self::ImportFrom { namei } => w!(IMPORT_FROM, name = namei),
+            Self::ImportName { namei } => w!(IMPORT_NAME, name = namei),
+            Self::InterpreterExit => w!(INTERPRETER_EXIT),
+            Self::IsOp { invert } => w!(IS_OP, ?invert),
+            Self::JumpBackward { delta } => w!(JUMP_BACKWARD, delta),
+            Self::JumpBackwardNoInterrupt { delta } => w!(JUMP_BACKWARD_NO_INTERRUPT, delta),
+            Self::JumpForward { delta } => w!(JUMP_FORWARD, delta),
             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);
-                let attr_name = name(name_idx);
-                if is_method {
+            Self::LoadAttr { namei } => {
+                let oparg = namei.get(arg);
+                let oparg_u32 = u32::from(oparg);
+                let attr_name = name(oparg.name_idx());
+                if oparg.is_method() {
                     write!(
                         f,
                         "{:pad$}({}, {}, method=true)",
-                        "LOAD_ATTR", encoded, attr_name
+                        "LOAD_ATTR", oparg_u32, attr_name
                     )
                 } else {
-                    write!(f, "{:pad$}({}, {})", "LOAD_ATTR", encoded, attr_name)
+                    write!(f, "{:pad$}({}, {})", "LOAD_ATTR", oparg_u32, attr_name)
                 }
             }
             Self::LoadBuildClass => w!(LOAD_BUILD_CLASS),
-            Self::LoadFromDictOrDeref(i) => w!(LOAD_FROM_DICT_OR_DEREF, cell_name = i),
-            Self::LoadConst { idx } => fmt_const("LOAD_CONST", arg, f, idx),
-            Self::LoadSmallInt { idx } => w!(LOAD_SMALL_INT, 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::LoadFastBorrow(idx) => w!(LOAD_FAST_BORROW, varname = idx),
-            Self::LoadFastCheck(idx) => w!(LOAD_FAST_CHECK, varname = idx),
-            Self::LoadFastLoadFast { arg: packed } => {
-                let oparg = packed.get(arg);
-                let idx1 = oparg >> 4;
-                let idx2 = oparg & 15;
+            Self::LoadCommonConstant { idx } => w!(LOAD_COMMON_CONSTANT, ?idx),
+            Self::LoadFromDictOrDeref { i } => w!(LOAD_FROM_DICT_OR_DEREF, cell_name = i),
+            Self::LoadConst { consti } => fmt_const("LOAD_CONST", arg, f, consti),
+            Self::LoadSmallInt { i } => w!(LOAD_SMALL_INT, i),
+            Self::LoadDeref { i } => w!(LOAD_DEREF, cell_name = i),
+            Self::LoadFast { var_num } => w!(LOAD_FAST, varname = var_num),
+            Self::LoadFastAndClear { var_num } => w!(LOAD_FAST_AND_CLEAR, varname = var_num),
+            Self::LoadFastBorrow { var_num } => w!(LOAD_FAST_BORROW, varname = var_num),
+            Self::LoadFastCheck { var_num } => w!(LOAD_FAST_CHECK, varname = var_num),
+            Self::LoadFastLoadFast { var_nums } => {
+                let oparg = var_nums.get(arg);
+                let (idx1, idx2) = oparg.indexes();
                 let name1 = varname(idx1);
                 let name2 = varname(idx2);
                 write!(f, "{:pad$}({}, {})", "LOAD_FAST_LOAD_FAST", name1, name2)
             }
-            Self::LoadFastBorrowLoadFastBorrow { arg: packed } => {
-                let oparg = packed.get(arg);
-                let idx1 = oparg >> 4;
-                let idx2 = oparg & 15;
+            Self::LoadFastBorrowLoadFastBorrow { var_nums } => {
+                let oparg = var_nums.get(arg);
+                let (idx1, idx2) = oparg.indexes();
                 let name1 = varname(idx1);
                 let name2 = varname(idx2);
                 write!(
@@ -883,62 +1246,136 @@ impl InstructionMetadata for Instruction {
                     "LOAD_FAST_BORROW_LOAD_FAST_BORROW", name1, name2
                 )
             }
-            Self::LoadFromDictOrGlobals(idx) => w!(LOAD_FROM_DICT_OR_GLOBALS, name = idx),
-            Self::LoadGlobal(idx) => w!(LOAD_GLOBAL, name = idx),
-            Self::LoadName(idx) => w!(LOAD_NAME, name = idx),
+            Self::LoadFromDictOrGlobals { i } => w!(LOAD_FROM_DICT_OR_GLOBALS, name = i),
+            Self::LoadGlobal { namei } => {
+                let oparg = namei.get(arg);
+                let name_idx = oparg >> 1;
+                if (oparg & 1) != 0 {
+                    write!(
+                        f,
+                        "{:pad$}({}, NULL + {})",
+                        "LOAD_GLOBAL",
+                        oparg,
+                        name(name_idx)
+                    )
+                } else {
+                    write!(f, "{:pad$}({}, {})", "LOAD_GLOBAL", oparg, name(name_idx))
+                }
+            }
+            Self::LoadGlobalBuiltin => {
+                let oparg = u32::from(arg);
+                let name_idx = oparg >> 1;
+                if (oparg & 1) != 0 {
+                    write!(
+                        f,
+                        "{:pad$}({}, NULL + {})",
+                        "LOAD_GLOBAL_BUILTIN",
+                        oparg,
+                        name(name_idx)
+                    )
+                } else {
+                    write!(
+                        f,
+                        "{:pad$}({}, {})",
+                        "LOAD_GLOBAL_BUILTIN",
+                        oparg,
+                        name(name_idx)
+                    )
+                }
+            }
+            Self::LoadGlobalModule => {
+                let oparg = u32::from(arg);
+                let name_idx = oparg >> 1;
+                if (oparg & 1) != 0 {
+                    write!(
+                        f,
+                        "{:pad$}({}, NULL + {})",
+                        "LOAD_GLOBAL_MODULE",
+                        oparg,
+                        name(name_idx)
+                    )
+                } else {
+                    write!(
+                        f,
+                        "{:pad$}({}, {})",
+                        "LOAD_GLOBAL_MODULE",
+                        oparg,
+                        name(name_idx)
+                    )
+                }
+            }
+            Self::LoadLocals => w!(LOAD_LOCALS),
+            Self::LoadName { namei } => w!(LOAD_NAME, name = namei),
             Self::LoadSpecial { method } => w!(LOAD_SPECIAL, method),
-            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);
+            Self::LoadSuperAttr { namei } => {
+                let oparg = namei.get(arg);
                 write!(
                     f,
                     "{:pad$}({}, {}, method={}, class={})",
-                    "LOAD_SUPER_ATTR", encoded, attr_name, load_method, has_class
+                    "LOAD_SUPER_ATTR",
+                    u32::from(oparg),
+                    name(oparg.name_idx()),
+                    oparg.is_load_method(),
+                    oparg.has_class()
                 )
             }
+            Self::MakeCell { i } => w!(MAKE_CELL, cell_name = i),
             Self::MakeFunction => w!(MAKE_FUNCTION),
             Self::MapAdd { i } => w!(MAP_ADD, i),
-            Self::MatchClass(arg) => w!(MATCH_CLASS, arg),
+            Self::MatchClass { count } => w!(MATCH_CLASS, count),
             Self::MatchKeys => w!(MATCH_KEYS),
             Self::MatchMapping => w!(MATCH_MAPPING),
             Self::MatchSequence => w!(MATCH_SEQUENCE),
             Self::Nop => w!(NOP),
+            Self::NotTaken => w!(NOT_TAKEN),
             Self::PopExcept => w!(POP_EXCEPT),
-            Self::PopJumpIfFalse { target } => w!(POP_JUMP_IF_FALSE, target),
-            Self::PopJumpIfTrue { target } => w!(POP_JUMP_IF_TRUE, target),
+            Self::PopJumpIfFalse { delta } => w!(POP_JUMP_IF_FALSE, delta),
+            Self::PopJumpIfNone { delta } => w!(POP_JUMP_IF_NONE, delta),
+            Self::PopJumpIfNotNone { delta } => w!(POP_JUMP_IF_NOT_NONE, delta),
+            Self::PopJumpIfTrue { delta } => w!(POP_JUMP_IF_TRUE, delta),
             Self::PopTop => w!(POP_TOP),
             Self::EndFor => w!(END_FOR),
             Self::PopIter => w!(POP_ITER),
             Self::PushExcInfo => w!(PUSH_EXC_INFO),
             Self::PushNull => w!(PUSH_NULL),
-            Self::RaiseVarargs { kind } => w!(RAISE_VARARGS, ?kind),
+            Self::RaiseVarargs { argc } => w!(RAISE_VARARGS, ?argc),
             Self::Reraise { depth } => w!(RERAISE, depth),
-            Self::Resume { arg } => w!(RESUME, arg),
+            Self::Resume { context } => w!(RESUME, context),
             Self::ReturnValue => w!(RETURN_VALUE),
             Self::ReturnGenerator => w!(RETURN_GENERATOR),
-            Self::Send { target } => w!(SEND, target),
+            Self::Send { delta } => w!(SEND, delta),
             Self::SetAdd { i } => w!(SET_ADD, i),
-            Self::SetFunctionAttribute { attr } => w!(SET_FUNCTION_ATTRIBUTE, ?attr),
+            Self::SetFunctionAttribute { flag } => w!(SET_FUNCTION_ATTRIBUTE, ?flag),
             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),
-            Self::StoreFastLoadFast {
-                store_idx,
-                load_idx,
-            } => {
+            Self::StoreAttr { namei } => w!(STORE_ATTR, name = namei),
+            Self::StoreDeref { i } => w!(STORE_DEREF, cell_name = i),
+            Self::StoreFast { var_num } => w!(STORE_FAST, varname = var_num),
+            Self::StoreFastLoadFast { var_nums } => {
+                let oparg = var_nums.get(arg);
+                let (store_idx, load_idx) = oparg.indexes();
                 write!(f, "STORE_FAST_LOAD_FAST")?;
-                write!(f, " ({}, {})", store_idx.get(arg), load_idx.get(arg))
+                write!(f, " ({}, {})", store_idx, load_idx)
+            }
+            Self::StoreFastStoreFast { var_nums } => {
+                let oparg = var_nums.get(arg);
+                let (idx1, idx2) = oparg.indexes();
+                write!(
+                    f,
+                    "{:pad$}({}, {})",
+                    "STORE_FAST_STORE_FAST",
+                    varname(idx1),
+                    varname(idx2)
+                )
             }
-            Self::StoreGlobal(idx) => w!(STORE_GLOBAL, name = idx),
-            Self::StoreName(idx) => w!(STORE_NAME, name = idx),
+            Self::StoreGlobal { namei } => w!(STORE_GLOBAL, name = namei),
+            Self::StoreName { namei } => w!(STORE_NAME, name = namei),
+            Self::StoreSlice => w!(STORE_SLICE),
             Self::StoreSubscr => w!(STORE_SUBSCR),
-            Self::Swap { index } => w!(SWAP, index),
+            Self::Swap { i } => w!(SWAP, i),
             Self::ToBool => w!(TO_BOOL),
-            Self::UnpackEx { args } => w!(UNPACK_EX, args),
-            Self::UnpackSequence { size } => w!(UNPACK_SEQUENCE, size),
+            Self::UnpackEx { counts } => w!(UNPACK_EX, counts),
+            Self::UnpackSequence { count } => w!(UNPACK_SEQUENCE, count),
             Self::WithExceptStart => w!(WITH_EXCEPT_START),
             Self::UnaryInvert => w!(UNARY_INVERT),
             Self::UnaryNegative => w!(UNARY_NEGATIVE),
@@ -946,7 +1383,7 @@ impl InstructionMetadata for Instruction {
             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),
+            Self::BuildInterpolation { format } => w!(BUILD_INTERPOLATION, format),
             _ => w!(RUSTPYTHON_PLACEHOLDER),
         }
     }
@@ -960,16 +1397,16 @@ impl InstructionMetadata for Instruction {
 pub enum PseudoInstruction {
     // CPython 3.14.2 pseudo instructions (256-266)
     AnnotationsPlaceholder = 256,
-    Jump { target: Arg<Label> } = 257,
-    JumpIfFalse { target: Arg<Label> } = 258,
-    JumpIfTrue { target: Arg<Label> } = 259,
-    JumpNoInterrupt { target: Arg<Label> } = 260,
-    LoadClosure(Arg<NameIdx>) = 261,
+    Jump { delta: Arg<Label> } = 257,
+    JumpIfFalse { delta: Arg<Label> } = 258,
+    JumpIfTrue { delta: Arg<Label> } = 259,
+    JumpNoInterrupt { delta: Arg<Label> } = 260,
+    LoadClosure { i: Arg<NameIdx> } = 261,
     PopBlock = 262,
-    SetupCleanup = 263,
-    SetupFinally = 264,
-    SetupWith = 265,
-    StoreFastMaybeNull(Arg<NameIdx>) = 266,
+    SetupCleanup { delta: Arg<Label> } = 263,
+    SetupFinally { delta: Arg<Label> } = 264,
+    SetupWith { delta: Arg<Label> } = 265,
+    StoreFastMaybeNull { var_num: Arg<NameIdx> } = 266,
 }
 
 const _: () = assert!(mem::size_of::<PseudoInstruction>() == 2);
@@ -988,7 +1425,9 @@ impl TryFrom<u16> for PseudoInstruction {
     #[inline]
     fn try_from(value: u16) -> Result<Self, MarshalError> {
         let start = u16::from(Self::AnnotationsPlaceholder);
-        let end = u16::from(Self::StoreFastMaybeNull(Arg::marker()));
+        let end = u16::from(Self::StoreFastMaybeNull {
+            var_num: Arg::marker(),
+        });
 
         if (start..=end).contains(&value) {
             Ok(unsafe { mem::transmute::<u16, Self>(value) })
@@ -998,13 +1437,27 @@ impl TryFrom<u16> for PseudoInstruction {
     }
 }
 
+impl PseudoInstruction {
+    /// Returns true if this is a block push pseudo instruction
+    /// (SETUP_FINALLY, SETUP_CLEANUP, or SETUP_WITH).
+    pub fn is_block_push(&self) -> bool {
+        matches!(
+            self,
+            Self::SetupCleanup { .. } | Self::SetupFinally { .. } | Self::SetupWith { .. }
+        )
+    }
+}
+
 impl InstructionMetadata for PseudoInstruction {
     fn label_arg(&self) -> Option<Arg<Label>> {
         match self {
-            Self::Jump { target: l }
-            | Self::JumpIfFalse { target: l }
-            | Self::JumpIfTrue { target: l }
-            | Self::JumpNoInterrupt { target: l } => Some(*l),
+            Self::Jump { delta: l }
+            | Self::JumpIfFalse { delta: l }
+            | Self::JumpIfTrue { delta: l }
+            | Self::JumpNoInterrupt { delta: l }
+            | Self::SetupCleanup { delta: l }
+            | Self::SetupFinally { delta: l }
+            | Self::SetupWith { delta: l } => Some(*l),
             _ => None,
         }
     }
@@ -1013,24 +1466,37 @@ impl InstructionMetadata for PseudoInstruction {
         false
     }
 
-    fn is_unconditional_jump(&self) -> bool {
-        matches!(self, Self::Jump { .. } | Self::JumpNoInterrupt { .. })
+    fn stack_effect_info(&self, _oparg: u32) -> StackEffect {
+        // Reason for converting oparg to i32 is because of expressions like `1 + (oparg -1)`
+        // that causes underflow errors.
+        let _oparg = i32::try_from(_oparg).expect("oparg does not fit in an `i32`");
+
+        // NOTE: Please don't "simplify" expressions here (i.e. `1 + (oparg - 1)`)
+        // as it will be harder to see diff with what CPython auto-generates
+        let (pushed, popped) = match self {
+            Self::AnnotationsPlaceholder => (0, 0),
+            Self::Jump { .. } => (0, 0),
+            Self::JumpIfFalse { .. } => (1, 1),
+            Self::JumpIfTrue { .. } => (1, 1),
+            Self::JumpNoInterrupt { .. } => (0, 0),
+            Self::LoadClosure { .. } => (1, 0),
+            Self::PopBlock => (0, 0),
+            // Normal path effect is 0 (these are NOPs on fall-through).
+            // Handler entry effects are computed directly in max_stackdepth().
+            Self::SetupCleanup { .. } => (0, 0),
+            Self::SetupFinally { .. } => (0, 0),
+            Self::SetupWith { .. } => (0, 0),
+            Self::StoreFastMaybeNull { .. } => (0, 1),
+        };
+
+        debug_assert!((0..=i32::MAX).contains(&pushed));
+        debug_assert!((0..=i32::MAX).contains(&popped));
+
+        StackEffect::new(pushed as u32, popped as u32)
     }
 
-    fn stack_effect(&self, _arg: OpArg) -> i32 {
-        match self {
-            Self::AnnotationsPlaceholder => 0,
-            Self::Jump { .. } => 0,
-            Self::JumpIfFalse { .. } => 0, // peek, don't pop: COPY + TO_BOOL + POP_JUMP_IF_FALSE
-            Self::JumpIfTrue { .. } => 0,  // peek, don't pop: COPY + TO_BOOL + POP_JUMP_IF_TRUE
-            Self::JumpNoInterrupt { .. } => 0,
-            Self::LoadClosure(_) => 1,
-            Self::PopBlock => 0,
-            Self::SetupCleanup => 0,
-            Self::SetupFinally => 0,
-            Self::SetupWith => 0,
-            Self::StoreFastMaybeNull(_) => -1,
-        }
+    fn is_unconditional_jump(&self) -> bool {
+        matches!(self, Self::Jump { .. } | Self::JumpNoInterrupt { .. })
     }
 
     fn fmt_dis(
@@ -1101,7 +1567,9 @@ impl InstructionMetadata for AnyInstruction {
 
     inst_either!(fn is_scope_exit(&self) -> bool);
 
-    inst_either!(fn stack_effect(&self, arg: OpArg) -> i32);
+    inst_either!(fn stack_effect(&self, oparg: u32) -> i32);
+
+    inst_either!(fn stack_effect_info(&self, oparg: u32) -> StackEffect);
 
     inst_either!(fn fmt_dis(
         &self,
@@ -1150,6 +1618,54 @@ impl AnyInstruction {
         self.pseudo()
             .expect("Expected Instruction::Pseudo, found Instruction::Real")
     }
+
+    /// Returns true if this is a block push pseudo instruction
+    /// (SETUP_FINALLY, SETUP_CLEANUP, or SETUP_WITH).
+    pub fn is_block_push(&self) -> bool {
+        matches!(self, Self::Pseudo(p) if p.is_block_push())
+    }
+
+    /// Returns true if this is a POP_BLOCK pseudo instruction.
+    pub fn is_pop_block(&self) -> bool {
+        matches!(self, Self::Pseudo(PseudoInstruction::PopBlock))
+    }
+}
+
+/// What effect the instruction has on the stack.
+#[derive(Clone, Copy)]
+pub struct StackEffect {
+    /// How many items the instruction is pushing on the stack.
+    pushed: u32,
+    /// How many items the instruction is popping from the stack.
+    popped: u32,
+}
+
+impl StackEffect {
+    /// Creates a new [`Self`].
+    pub const fn new(pushed: u32, popped: u32) -> Self {
+        Self { pushed, popped }
+    }
+
+    /// Get the calculated stack effect as [`i32`].
+    pub fn effect(self) -> i32 {
+        self.into()
+    }
+
+    /// Get the pushed count.
+    pub const fn pushed(self) -> u32 {
+        self.pushed
+    }
+
+    /// Get the popped count.
+    pub const fn popped(self) -> u32 {
+        self.popped
+    }
+}
+
+impl From<StackEffect> for i32 {
+    fn from(effect: StackEffect) -> Self {
+        (effect.pushed() as i32) - (effect.popped() as i32)
+    }
 }
 
 pub trait InstructionMetadata {
@@ -1160,17 +1676,14 @@ pub trait InstructionMetadata {
 
     fn is_unconditional_jump(&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), 0);
-    /// ```
-    fn stack_effect(&self, arg: OpArg) -> i32;
+    /// Stack effect info for how many items are pushed/popped from the stack,
+    /// for this instruction.
+    fn stack_effect_info(&self, oparg: u32) -> StackEffect;
+
+    /// Stack effect of [`Self::stack_effect_info`].
+    fn stack_effect(&self, oparg: u32) -> i32 {
+        self.stack_effect_info(oparg).effect()
+    }
 
     #[allow(clippy::too_many_arguments)]
     fn fmt_dis(
@@ -1199,7 +1712,7 @@ impl<T: OpArgType> Arg<T> {
 
     #[inline]
     pub fn new(arg: T) -> (Self, OpArg) {
-        (Self(PhantomData), OpArg(arg.to_op_arg()))
+        (Self(PhantomData), OpArg::new(arg.into()))
     }
 
     #[inline]
@@ -1207,7 +1720,7 @@ impl<T: OpArgType> Arg<T> {
     where
         T: Into<u8>,
     {
-        (Self(PhantomData), OpArgByte(arg.into()))
+        (Self(PhantomData), OpArgByte::new(arg.into()))
     }
 
     #[inline(always)]
@@ -1216,8 +1729,8 @@ impl<T: OpArgType> Arg<T> {
     }
 
     #[inline(always)]
-    pub fn try_get(self, arg: OpArg) -> Option<T> {
-        T::from_op_arg(arg.0)
+    pub fn try_get(self, arg: OpArg) -> Result<T, MarshalError> {
+        T::try_from(u32::from(arg)).map_err(|_| MarshalError::InvalidBytecode)
     }
 
     /// # Safety
@@ -1225,7 +1738,7 @@ impl<T: OpArgType> Arg<T> {
     #[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() }
+        unsafe { T::try_from(u32::from(arg)).unwrap_unchecked() }
     }
 }
 
@@ -1242,32 +1755,3 @@ impl<T: OpArgType> fmt::Debug for Arg<T> {
         write!(f, "Arg<{}>", core::any::type_name::<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 {
-    (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
index e48e226b12a..a0ab45a3abc 100644
--- a/crates/compiler-core/src/bytecode/oparg.rs
+++ b/crates/compiler-core/src/bytecode/oparg.rs
@@ -1,29 +1,35 @@
-use bitflags::bitflags;
+use core::fmt;
 
-use core::{fmt, num::NonZeroU8};
+use crate::{
+    bytecode::{CodeUnit, instruction::Instruction},
+    marshal::MarshalError,
+};
 
-use crate::bytecode::{CodeUnit, instruction::Instruction};
-
-pub trait OpArgType: Copy {
-    fn from_op_arg(x: u32) -> Option<Self>;
-
-    fn to_op_arg(self) -> u32;
-}
+pub trait OpArgType: Copy + Into<u32> + TryFrom<u32> {}
 
 /// Opcode argument that may be extended by a prior ExtendedArg.
 #[derive(Copy, Clone, PartialEq, Eq)]
 #[repr(transparent)]
-pub struct OpArgByte(pub u8);
+pub struct OpArgByte(u8);
 
 impl OpArgByte {
-    pub const fn null() -> Self {
-        Self(0)
+    pub const NULL: Self = Self::new(0);
+
+    #[must_use]
+    pub const fn new(value: u8) -> Self {
+        Self(value)
     }
 }
 
 impl From<u8> for OpArgByte {
     fn from(raw: u8) -> Self {
-        Self(raw)
+        Self::new(raw)
+    }
+}
+
+impl From<OpArgByte> for u8 {
+    fn from(value: OpArgByte) -> Self {
+        value.0
     }
 }
 
@@ -36,11 +42,14 @@ impl fmt::Debug for OpArgByte {
 /// Full 32-bit op_arg, including any possible ExtendedArg extension.
 #[derive(Copy, Clone, Debug)]
 #[repr(transparent)]
-pub struct OpArg(pub u32);
+pub struct OpArg(u32);
 
 impl OpArg {
-    pub const fn null() -> Self {
-        Self(0)
+    pub const NULL: Self = Self::new(0);
+
+    #[must_use]
+    pub const fn new(value: u32) -> Self {
+        Self(value)
     }
 
     /// Returns how many CodeUnits a instruction with this op_arg will be encoded as
@@ -66,7 +75,13 @@ impl OpArg {
 
 impl From<u32> for OpArg {
     fn from(raw: u32) -> Self {
-        Self(raw)
+        Self::new(raw)
+    }
+}
+
+impl From<OpArg> for u32 {
+    fn from(value: OpArg) -> Self {
+        value.0
     }
 }
 
@@ -89,7 +104,7 @@ impl OpArgState {
     #[inline(always)]
     pub fn extend(&mut self, arg: OpArgByte) -> OpArg {
         self.state = (self.state << 8) | u32::from(arg.0);
-        OpArg(self.state)
+        self.state.into()
     }
 
     #[inline(always)]
@@ -98,170 +113,176 @@ impl OpArgState {
     }
 }
 
-/// Oparg values for [`Instruction::ConvertValue`].
+/// Helper macro for defining oparg enums in an optimal way.
 ///
-/// ## See also
+/// Will generate the following:
 ///
-/// - [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)
-    }
+/// - Enum which variant's aren't assigned any value (for optimizations).
+/// - impl [`TryFrom<u8>`]
+/// - impl [`TryFrom<u32>`]
+/// - impl [`Into<u8>`]
+/// - impl [`Into<u32>`]
+/// - impl [`OpArgType`]
+///
+/// # Note
+/// If an enum variant has "alternative" values (i.e. `Foo = 0 | 1`), the first value will be the
+/// result of converting to a number.
+///
+/// # Examples
+///
+/// ```ignore
+/// oparg_enum!(
+///     /// Oparg for the `X` opcode.
+///     #[derive(Clone, Copy)]
+///     pub enum MyOpArg {
+///         /// Some doc.
+///         Foo = 4,
+///         Bar = 8,
+///         Baz = 15 | 16,
+///         Qux = 23 | 42
+///     }
+/// );
+/// ```
+macro_rules! oparg_enum {
+    (
+        $(#[$enum_meta:meta])*
+        $vis:vis enum $name:ident {
+            $(
+                $(#[$variant_meta:meta])*
+                $variant:ident = $value:literal $(| $alternatives:expr)*
+            ),* $(,)?
+        }
+    ) => {
+        $(#[$enum_meta])*
+        $vis enum $name {
+            $(
+                $(#[$variant_meta])*
+                $variant, // Do assign value to variant.
+            )*
+        }
 
-    #[inline(always)]
-    fn to_op_arg(self) -> u32 {
-        self
-    }
+        impl_oparg_enum!(
+            enum $name {
+                $(
+                    $variant = $value $(| $alternatives)*,
+                )*
+            }
+        );
+    };
 }
 
-impl OpArgType for bool {
-    #[inline(always)]
-    fn from_op_arg(x: u32) -> Option<Self> {
-        Some(x != 0)
-    }
+macro_rules! impl_oparg_enum {
+    (
+        enum $name:ident {
+            $(
+                $variant:ident = $value:literal $(| $alternatives:expr)*
+            ),* $(,)?
+        }
+    ) => {
+        impl TryFrom<u8> for $name {
+            type Error = $crate::marshal::MarshalError;
+
+            fn try_from(value: u8) -> Result<Self, Self::Error> {
+                Ok(match value {
+                    $(
+                        $value $(| $alternatives)* => Self::$variant,
+                    )*
+                    _ => return Err(Self::Error::InvalidBytecode),
+                })
+            }
+        }
 
-    #[inline(always)]
-    fn to_op_arg(self) -> u32 {
-        self as u32
-    }
-}
+        impl TryFrom<u32> for $name {
+            type Error = $crate::marshal::MarshalError;
 
-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 try_from(value: u32) -> Result<Self, Self::Error> {
+                u8::try_from(value)
+                    .map_err(|_| Self::Error::InvalidBytecode)
+                    .map(TryInto::try_into)?
             }
+        }
 
-            fn from_op_arg(x: u32) -> Option<Self> {
-                Some(match u8::try_from(x).ok()? {
-                    $($value => Self::$var,)*
-                    _ => return None,
-                })
+        impl From<$name> for u8 {
+            fn from(value: $name) -> Self {
+                match value {
+                    $(
+                        $name::$variant => $value,
+                    )*
+                }
             }
         }
-    };
-}
 
-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,)*
+        impl From<$name> for u32 {
+            fn from(value: $name) -> Self {
+                Self::from(u8::from(value))
+            }
         }
 
-        op_arg_enum_impl!(enum $name {
-            $($(#[$var_attr])* $var = $value,)*
-        });
+        impl OpArgType for $name {}
     };
 }
 
-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
+oparg_enum!(
+    /// Oparg values for [`Instruction::ConvertValue`].
+    ///
+    /// ## See also
+    ///
+    /// - [CPython FVC_* flags](https://github.com/python/cpython/blob/8183fa5e3f78ca6ab862de7fb8b14f3d929421e0/Include/ceval.h#L129-L132)
+    #[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
+    pub enum ConvertValueOparg {
+        /// No conversion.
+        ///
+        /// ```python
+        /// f"{x}"
+        /// f"{x:4}"
+        /// ```
+        // Ruff `ConversionFlag::None` is `-1i8`, when its converted to `u8` its value is `u8::MAX`.
+        None = 0 | 255,
+        /// 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 Label {
+impl fmt::Display for ConvertValueOparg {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        self.0.fmt(f)
+        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}")
     }
 }
 
-op_arg_enum!(
+pub type NameIdx = u32;
+
+impl OpArgType for u32 {}
+
+oparg_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).
@@ -281,10 +302,9 @@ op_arg_enum!(
     }
 );
 
-op_arg_enum!(
+oparg_enum!(
     /// Intrinsic function for CALL_INTRINSIC_1
     #[derive(Copy, Clone, Debug, PartialEq, Eq)]
-    #[repr(u8)]
     pub enum IntrinsicFunction1 {
         // Invalid = 0,
         Print = 1,
@@ -306,10 +326,9 @@ op_arg_enum!(
     }
 );
 
-op_arg_enum!(
+oparg_enum!(
     /// Intrinsic function for CALL_INTRINSIC_2
     #[derive(Copy, Clone, Debug, PartialEq, Eq)]
-    #[repr(u8)]
     pub enum IntrinsicFunction2 {
         PrepReraiseStar = 1,
         TypeVarWithBound = 2,
@@ -320,48 +339,114 @@ op_arg_enum!(
     }
 );
 
-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;
+bitflagset::bitflag! {
+    /// `SET_FUNCTION_ATTRIBUTE` flags.
+    /// Bitmask: Defaults=0x01, KwOnly=0x02, Annotations=0x04,
+    /// Closure=0x08, TypeParams=0x10, Annotate=0x20.
+    /// Stored as bit position (0-5) by `bitflag!` macro.
+    #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
+    #[repr(u8)]
+    pub enum MakeFunctionFlag {
+        Defaults = 0,
+        KwOnlyDefaults = 1,
+        Annotations = 2,
+        Closure = 3,
         /// PEP 649: __annotate__ function closure (instead of __annotations__ dict)
-        const ANNOTATE = 0x20;
+        Annotate = 4,
+        TypeParams = 5,
     }
 }
 
-impl OpArgType for MakeFunctionFlags {
-    #[inline(always)]
-    fn from_op_arg(x: u32) -> Option<Self> {
-        Self::from_bits(x as u8)
+bitflagset::bitflagset! {
+    #[derive(Copy, Clone, PartialEq, Eq)]
+    pub struct MakeFunctionFlags(u8): MakeFunctionFlag
+}
+
+impl TryFrom<u32> for MakeFunctionFlag {
+    type Error = MarshalError;
+
+    /// Decode from CPython-compatible power-of-two value
+    fn try_from(value: u32) -> Result<Self, Self::Error> {
+        match value {
+            0x01 => Ok(Self::Defaults),
+            0x02 => Ok(Self::KwOnlyDefaults),
+            0x04 => Ok(Self::Annotations),
+            0x08 => Ok(Self::Closure),
+            0x10 => Ok(Self::Annotate),
+            0x20 => Ok(Self::TypeParams),
+            _ => Err(MarshalError::InvalidBytecode),
+        }
     }
+}
 
-    #[inline(always)]
-    fn to_op_arg(self) -> u32 {
-        self.bits().into()
+impl From<MakeFunctionFlag> for u32 {
+    /// Encode as CPython-compatible power-of-two value
+    fn from(flag: MakeFunctionFlag) -> Self {
+        1u32 << (flag as u32)
     }
 }
 
-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,
+impl OpArgType for MakeFunctionFlag {}
+
+/// `COMPARE_OP` arg is `(cmp_index << 5) | mask`.  Only the upper
+/// 3 bits identify the comparison; the lower 5 bits are an inline
+/// cache mask for adaptive specialization.
+#[derive(Debug, Copy, Clone, PartialEq, Eq)]
+pub enum ComparisonOperator {
+    Less,
+    LessOrEqual,
+    Equal,
+    NotEqual,
+    Greater,
+    GreaterOrEqual,
+}
+
+impl TryFrom<u8> for ComparisonOperator {
+    type Error = MarshalError;
+    fn try_from(value: u8) -> Result<Self, Self::Error> {
+        Self::try_from(value as u32)
     }
-);
+}
+
+impl TryFrom<u32> for ComparisonOperator {
+    type Error = MarshalError;
+    /// Decode from `COMPARE_OP` arg: `(cmp_index << 5) | mask`.
+    fn try_from(value: u32) -> Result<Self, Self::Error> {
+        match value >> 5 {
+            0 => Ok(Self::Less),
+            1 => Ok(Self::LessOrEqual),
+            2 => Ok(Self::Equal),
+            3 => Ok(Self::NotEqual),
+            4 => Ok(Self::Greater),
+            5 => Ok(Self::GreaterOrEqual),
+            _ => Err(MarshalError::InvalidBytecode),
+        }
+    }
+}
+
+impl From<ComparisonOperator> for u8 {
+    /// Encode as `cmp_index << 5` (mask bits zero).
+    fn from(value: ComparisonOperator) -> Self {
+        match value {
+            ComparisonOperator::Less => 0,
+            ComparisonOperator::LessOrEqual => 1 << 5,
+            ComparisonOperator::Equal => 2 << 5,
+            ComparisonOperator::NotEqual => 3 << 5,
+            ComparisonOperator::Greater => 4 << 5,
+            ComparisonOperator::GreaterOrEqual => 5 << 5,
+        }
+    }
+}
+
+impl From<ComparisonOperator> for u32 {
+    fn from(value: ComparisonOperator) -> Self {
+        Self::from(u8::from(value))
+    }
+}
+
+impl OpArgType for ComparisonOperator {}
 
-op_arg_enum!(
+oparg_enum!(
     /// The possible Binary operators
     ///
     /// # Examples
@@ -374,7 +459,6 @@ op_arg_enum!(
     ///
     /// 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 {
         /// `+`
@@ -502,9 +586,8 @@ impl fmt::Display for BinaryOperator {
     }
 }
 
-op_arg_enum!(
+oparg_enum!(
     /// Whether or not to invert the operation.
-    #[repr(u8)]
     #[derive(Debug, Copy, Clone, PartialEq, Eq)]
     pub enum Invert {
         /// ```py
@@ -520,9 +603,8 @@ op_arg_enum!(
     }
 );
 
-op_arg_enum!(
+oparg_enum!(
     /// Special method for LOAD_SPECIAL opcode (context managers).
-    #[repr(u8)]
     #[derive(Debug, Copy, Clone, PartialEq, Eq)]
     pub enum SpecialMethod {
         /// `__enter__` for sync context manager
@@ -548,10 +630,9 @@ impl fmt::Display for SpecialMethod {
     }
 }
 
-op_arg_enum!(
+oparg_enum!(
     /// Common constants for LOAD_COMMON_CONSTANT opcode.
     /// pycore_opcode_utils.h CONSTANT_*
-    #[repr(u8)]
     #[derive(Debug, Copy, Clone, PartialEq, Eq)]
     pub enum CommonConstant {
         /// `AssertionError` exception type
@@ -564,6 +645,10 @@ op_arg_enum!(
         BuiltinAll = 3,
         /// Built-in `any` function
         BuiltinAny = 4,
+        /// Built-in `list` type
+        BuiltinList = 5,
+        /// Built-in `set` type
+        BuiltinSet = 6,
     }
 );
 
@@ -575,74 +660,303 @@ impl fmt::Display for CommonConstant {
             Self::BuiltinTuple => "tuple",
             Self::BuiltinAll => "all",
             Self::BuiltinAny => "any",
+            Self::BuiltinList => "list",
+            Self::BuiltinSet => "set",
         };
         write!(f, "{name}")
     }
 }
 
-/// 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,
+oparg_enum!(
+    /// 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 = 2,
+        /// ```py
+        /// x[5:10:2]
+        /// ```
+        Three = 3,
+    }
+);
+
+#[derive(Copy, Clone)]
+pub struct UnpackExArgs {
+    pub before: u8,
+    pub after: u8,
 }
 
-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,
-        })
+impl From<u32> for UnpackExArgs {
+    fn from(value: u32) -> Self {
+        let [before, after, ..] = value.to_le_bytes();
+        Self { before, after }
+    }
+}
+
+impl From<UnpackExArgs> for u32 {
+    fn from(value: UnpackExArgs) -> Self {
+        Self::from_le_bytes([value.before, value.after, 0, 0])
     }
+}
 
-    #[inline(always)]
-    fn to_op_arg(self) -> u32 {
-        u32::from(self.argc().get())
+impl OpArgType for UnpackExArgs {}
+
+impl fmt::Display for UnpackExArgs {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "before: {}, after: {}", self.before, self.after)
+    }
+}
+
+macro_rules! newtype_oparg {
+    (
+      $(#[$oparg_meta:meta])*
+      $vis:vis struct $name:ident(u32)
+    ) => {
+        $(#[$oparg_meta])*
+        $vis struct $name(u32);
+
+        impl $name {
+            /// Creates a new [`$name`] instance.
+            #[must_use]
+            pub const fn from_u32(value: u32) -> Self {
+                Self(value)
+            }
+
+            /// Returns the oparg as a `u32` value.
+            #[must_use]
+            pub const fn as_u32(self) -> u32 {
+                self.0
+            }
+
+            /// Returns the oparg as a `usize` value.
+            #[must_use]
+            pub const fn as_usize(self) -> usize {
+              self.0 as usize
+            }
+        }
+
+        impl From<u32> for $name {
+            fn from(value: u32) -> Self {
+                Self::from_u32(value)
+            }
+        }
+
+        impl From<$name> for u32 {
+            fn from(value: $name) -> Self {
+                value.as_u32()
+            }
+        }
+
+        impl From<$name> for usize {
+            fn from(value: $name) -> Self {
+                value.as_usize()
+            }
+        }
+
+        impl ::core::fmt::Display for $name {
+            fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+                self.0.fmt(f)
+            }
+        }
+
+        impl OpArgType for $name {}
     }
 }
 
-impl BuildSliceArgCount {
-    /// Get the numeric value of `Self`.
+newtype_oparg!(
+    #[derive(Clone, Copy)]
+    #[repr(transparent)]
+    pub struct ConstIdx(u32)
+);
+
+newtype_oparg!(
+    #[derive(Clone, Copy)]
+    #[repr(transparent)]
+    pub struct VarNum(u32)
+);
+
+newtype_oparg!(
+    #[derive(Clone, Copy)]
+    #[repr(transparent)]
+    pub struct VarNums(u32)
+);
+
+newtype_oparg!(
+    #[derive(Clone, Copy)]
+    #[repr(transparent)]
+    pub struct LoadAttr(u32)
+);
+
+newtype_oparg!(
+    #[derive(Clone, Copy)]
+    #[repr(transparent)]
+    pub struct LoadSuperAttr(u32)
+);
+
+newtype_oparg!(
+    #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Ord, PartialOrd)]
+    #[repr(transparent)]
+    pub struct Label(u32)
+);
+
+newtype_oparg!(
+    /// Context for [`Instruction::Resume`].
+    ///
+    /// The oparg consists of two parts:
+    /// 1. [`ResumeContext::location`]: Indicates where the instruction occurs.
+    /// 2. [`ResumeContext::is_exception_depth1`]: Is the instruction is at except-depth 1.
+    #[derive(Clone, Copy)]
+    #[repr(transparent)]
+    pub struct ResumeContext(u32)
+);
+
+impl ResumeContext {
+    /// [CPython `RESUME_OPARG_LOCATION_MASK`](https://github.com/python/cpython/blob/v3.14.3/Include/internal/pycore_opcode_utils.h#L84)
+    pub const LOCATION_MASK: u32 = 0x3;
+
+    /// [CPython `RESUME_OPARG_DEPTH1_MASK`](https://github.com/python/cpython/blob/v3.14.3/Include/internal/pycore_opcode_utils.h#L85)
+    pub const DEPTH1_MASK: u32 = 0x4;
+
     #[must_use]
-    pub const fn argc(self) -> NonZeroU8 {
-        let inner = match self {
-            Self::Two => 2,
-            Self::Three => 3,
+    pub const fn new(location: ResumeLocation, is_exception_depth1: bool) -> Self {
+        let value = if is_exception_depth1 {
+            Self::DEPTH1_MASK
+        } else {
+            0
         };
-        // Safety: `inner` can be either 2 or 3.
-        unsafe { NonZeroU8::new_unchecked(inner) }
+
+        Self::from_u32(location.as_u32() | value)
+    }
+
+    /// Resume location is determined by [`Self::LOCATION_MASK`].
+    #[must_use]
+    pub fn location(&self) -> ResumeLocation {
+        // SAFETY: The mask should return a value that is in range.
+        unsafe { ResumeLocation::try_from(self.as_u32() & Self::LOCATION_MASK).unwrap_unchecked() }
+    }
+
+    /// True if the bit at [`Self::DEPTH1_MASK`] is on.
+    #[must_use]
+    pub const fn is_exception_depth1(&self) -> bool {
+        (self.as_u32() & Self::DEPTH1_MASK) != 0
     }
 }
 
 #[derive(Copy, Clone)]
-pub struct UnpackExArgs {
-    pub before: u8,
-    pub after: u8,
+pub enum ResumeLocation {
+    /// At the start of a function, which is neither a generator, coroutine nor an async generator.
+    AtFuncStart,
+    /// After a `yield` expression.
+    AfterYield,
+    /// After a `yield from` expression.
+    AfterYieldFrom,
+    /// After an `await` expression.
+    AfterAwait,
 }
 
-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 })
+impl From<ResumeLocation> for ResumeContext {
+    fn from(location: ResumeLocation) -> Self {
+        Self::new(location, false)
     }
+}
 
-    #[inline(always)]
-    fn to_op_arg(self) -> u32 {
-        u32::from_le_bytes([self.before, self.after, 0, 0])
+impl TryFrom<u32> for ResumeLocation {
+    type Error = MarshalError;
+
+    fn try_from(value: u32) -> Result<Self, Self::Error> {
+        Ok(match value {
+            0 => Self::AtFuncStart,
+            1 => Self::AfterYield,
+            2 => Self::AfterYieldFrom,
+            3 => Self::AfterAwait,
+            _ => return Err(Self::Error::InvalidBytecode),
+        })
     }
 }
 
-impl fmt::Display for UnpackExArgs {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "before: {}, after: {}", self.before, self.after)
+impl ResumeLocation {
+    #[must_use]
+    pub const fn as_u8(&self) -> u8 {
+        match self {
+            Self::AtFuncStart => 0,
+            Self::AfterYield => 1,
+            Self::AfterYieldFrom => 2,
+            Self::AfterAwait => 3,
+        }
+    }
+
+    #[must_use]
+    pub const fn as_u32(&self) -> u32 {
+        self.as_u8() as u32
+    }
+}
+
+impl From<ResumeLocation> for u8 {
+    fn from(location: ResumeLocation) -> Self {
+        location.as_u8()
+    }
+}
+
+impl From<ResumeLocation> for u32 {
+    fn from(location: ResumeLocation) -> Self {
+        location.as_u32()
+    }
+}
+
+impl VarNums {
+    #[must_use]
+    pub const fn idx_1(self) -> VarNum {
+        VarNum::from_u32(self.0 >> 4)
+    }
+
+    #[must_use]
+    pub const fn idx_2(self) -> VarNum {
+        VarNum::from_u32(self.0 & 15)
+    }
+
+    #[must_use]
+    pub const fn indexes(self) -> (VarNum, VarNum) {
+        (self.idx_1(), self.idx_2())
+    }
+}
+
+impl LoadAttr {
+    #[must_use]
+    pub const fn new(name_idx: u32, is_method: bool) -> Self {
+        Self::from_u32((name_idx << 1) | (is_method as u32))
+    }
+
+    #[must_use]
+    pub const fn name_idx(self) -> u32 {
+        self.0 >> 1
+    }
+
+    #[must_use]
+    pub const fn is_method(self) -> bool {
+        (self.0 & 1) == 1
+    }
+}
+
+impl LoadSuperAttr {
+    #[must_use]
+    pub const fn new(name_idx: u32, is_load_method: bool, has_class: bool) -> Self {
+        Self::from_u32((name_idx << 2) | (is_load_method as u32) | ((has_class as u32) << 1))
+    }
+
+    #[must_use]
+    pub const fn name_idx(self) -> u32 {
+        self.0 >> 2
+    }
+
+    #[must_use]
+    pub const fn is_load_method(self) -> bool {
+        (self.0 & 1) == 1
+    }
+
+    #[must_use]
+    pub const fn has_class(self) -> bool {
+        (self.0 & 2) == 2
     }
 }
diff --git a/crates/compiler-core/src/frozen.rs b/crates/compiler-core/src/frozen.rs
index a79569ad7fb..81530610d0e 100644
--- a/crates/compiler-core/src/frozen.rs
+++ b/crates/compiler-core/src/frozen.rs
@@ -1,5 +1,6 @@
 use crate::bytecode::*;
 use crate::marshal::{self, Read, ReadBorrowed, Write};
+use alloc::vec::Vec;
 
 /// A frozen module. Holds a frozen code object and whether it is part of a package
 #[derive(Copy, Clone)]
diff --git a/crates/compiler-core/src/lib.rs b/crates/compiler-core/src/lib.rs
index 151d4cdea52..245713d1a14 100644
--- a/crates/compiler-core/src/lib.rs
+++ b/crates/compiler-core/src/lib.rs
@@ -1,3 +1,4 @@
+#![no_std]
 #![doc(html_logo_url = "https://raw.githubusercontent.com/RustPython/RustPython/main/logo.png")]
 #![doc(html_root_url = "https://docs.rs/rustpython-compiler-core/")]
 
diff --git a/crates/compiler-core/src/marshal.rs b/crates/compiler-core/src/marshal.rs
index decb25d5283..5594d0f4c45 100644
--- a/crates/compiler-core/src/marshal.rs
+++ b/crates/compiler-core/src/marshal.rs
@@ -1,4 +1,5 @@
 use crate::{OneIndexed, SourceLocation, bytecode::*};
+use alloc::{boxed::Box, vec::Vec};
 use core::convert::Infallible;
 use malachite_bigint::{BigInt, Sign};
 use num_complex::Complex64;
@@ -45,70 +46,72 @@ type Result<T, E = MarshalError> = core::result::Result<T, E>;
 #[derive(Clone, Copy)]
 #[repr(u8)]
 enum Type {
-    // Null = b'0',
+    Null = b'0',
     None = b'N',
     False = b'F',
     True = b'T',
     StopIter = b'S',
     Ellipsis = b'.',
     Int = b'i',
+    Int64 = b'I',
+    Long = b'l',
     Float = b'g',
+    FloatStr = b'f',
+    ComplexStr = b'x',
     Complex = b'y',
-    // Long = b'l',  // i32
-    Bytes = b's', // = TYPE_STRING
-    // Interned = b't',
-    // Ref = b'r',
+    Bytes = b's',
+    Interned = b't',
+    Ref = b'r',
     Tuple = b'(',
+    SmallTuple = b')',
     List = b'[',
     Dict = b'{',
     Code = b'c',
     Unicode = b'u',
-    // Unknown = b'?',
     Set = b'<',
     FrozenSet = b'>',
-    Slice = b':', // Added in version 5
+    Slice = b':',
     Ascii = b'a',
-    // AsciiInterned = b'A',
-    // SmallTuple = b')',
-    // ShortAscii = b'z',
-    // ShortAsciiInterned = b'Z',
+    AsciiInterned = b'A',
+    ShortAscii = b'z',
+    ShortAsciiInterned = b'Z',
 }
-// const FLAG_REF: u8 = b'\x80';
 
 impl TryFrom<u8> for Type {
     type Error = MarshalError;
 
     fn try_from(value: u8) -> Result<Self> {
         use Type::*;
-
         Ok(match value {
-            // b'0' => Null,
+            b'0' => Null,
             b'N' => None,
             b'F' => False,
             b'T' => True,
             b'S' => StopIter,
             b'.' => Ellipsis,
             b'i' => Int,
+            b'I' => Int64,
+            b'l' => Long,
+            b'f' => FloatStr,
             b'g' => Float,
+            b'x' => ComplexStr,
             b'y' => Complex,
-            // b'l' => Long,
             b's' => Bytes,
-            // b't' => Interned,
-            // b'r' => Ref,
+            b't' => Interned,
+            b'r' => Ref,
             b'(' => Tuple,
+            b')' => SmallTuple,
             b'[' => List,
             b'{' => Dict,
             b'c' => Code,
             b'u' => Unicode,
-            // b'?' => Unknown,
             b'<' => Set,
             b'>' => FrozenSet,
             b':' => Slice,
             b'a' => Ascii,
-            // b'A' => AsciiInterned,
-            // b')' => SmallTuple,
-            // b'z' => ShortAscii,
-            // b'Z' => ShortAsciiInterned,
+            b'A' => AsciiInterned,
+            b'z' => ShortAscii,
+            b'Z' => ShortAsciiInterned,
             _ => return Err(MarshalError::BadType),
         })
     }
@@ -158,13 +161,17 @@ impl Read for &[u8] {
     fn read_slice(&mut self, n: u32) -> Result<&[u8]> {
         self.read_slice_borrow(n)
     }
+
+    fn read_array<const N: usize>(&mut self) -> Result<&[u8; N]> {
+        let (chunk, rest) = self.split_first_chunk::<N>().ok_or(MarshalError::Eof)?;
+        *self = rest;
+        Ok(chunk)
+    }
 }
 
 impl<'a> ReadBorrowed<'a> for &'a [u8] {
     fn read_slice_borrow(&mut self, n: u32) -> Result<&'a [u8]> {
-        let data = self.get(..n as usize).ok_or(MarshalError::Eof)?;
-        *self = &self[n as usize..];
-        Ok(data)
+        self.split_off(..n as usize).ok_or(MarshalError::Eof)
     }
 }
 
@@ -182,85 +189,68 @@ impl<B: AsRef<[u8]>> Read for Cursor<B> {
     }
 }
 
+/// Deserialize a code object (CPython field order).
 pub fn deserialize_code<R: Read, Bag: ConstantBag>(
     rdr: &mut R,
     bag: Bag,
 ) -> Result<CodeObject<Bag::Constant>> {
-    let len = rdr.read_u32()?;
-    let raw_instructions = rdr.read_slice(len * 2)?;
-    let instructions = CodeUnits::try_from(raw_instructions)?;
-
-    let len = rdr.read_u32()?;
-    let locations = (0..len)
-        .map(|_| {
-            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, SourceLocation)]>>>()?;
-
-    let flags = CodeFlags::from_bits_truncate(rdr.read_u32()?);
-
-    let posonlyarg_count = rdr.read_u32()?;
+    // 1–5: scalar fields
     let arg_count = rdr.read_u32()?;
+    let posonlyarg_count = rdr.read_u32()?;
     let kwonlyarg_count = rdr.read_u32()?;
+    let max_stackdepth = rdr.read_u32()?;
+    let flags = CodeFlags::from_bits_truncate(rdr.read_u32()?);
 
-    let len = rdr.read_u32()?;
-    let source_path = bag.make_name(rdr.read_str(len)?);
+    // 6: co_code
+    let code_bytes = read_marshal_bytes(rdr)?;
 
-    let first_line_number = OneIndexed::new(rdr.read_u32()? as _);
-    let max_stackdepth = rdr.read_u32()?;
+    // 7: co_consts
+    let constants = read_marshal_const_tuple(rdr, bag)?;
 
-    let len = rdr.read_u32()?;
-    let obj_name = bag.make_name(rdr.read_str(len)?);
+    // 8: co_names
+    let names = read_marshal_name_tuple(rdr, &bag)?;
 
-    let len = rdr.read_u32()?;
-    let qualname = bag.make_name(rdr.read_str(len)?);
+    // 9: co_localsplusnames
+    let localsplusnames = read_marshal_str_vec(rdr)?;
 
-    let len = rdr.read_u32()?;
-    let cell2arg = (len != 0)
-        .then(|| {
-            (0..len)
-                .map(|_| Ok(rdr.read_u32()? as i32))
-                .collect::<Result<Box<[i32]>>>()
-        })
-        .transpose()?;
+    // 10: co_localspluskinds
+    let localspluskinds = read_marshal_bytes(rdr)?;
 
-    let len = rdr.read_u32()?;
-    let constants = (0..len)
-        .map(|_| deserialize_value(rdr, bag))
-        .collect::<Result<Box<[_]>>>()?;
-
-    let mut read_names = || {
-        let len = rdr.read_u32()?;
-        (0..len)
-            .map(|_| {
-                let len = rdr.read_u32()?;
-                Ok(bag.make_name(rdr.read_str(len)?))
-            })
-            .collect::<Result<Box<[_]>>>()
+    // 11–13: filename, name, qualname
+    let source_path = bag.make_name(&read_marshal_str(rdr)?);
+    let obj_name = bag.make_name(&read_marshal_str(rdr)?);
+    let qualname = bag.make_name(&read_marshal_str(rdr)?);
+
+    // 14: co_firstlineno
+    let first_line_raw = rdr.read_u32()? as i32;
+    let first_line_number = if first_line_raw > 0 {
+        OneIndexed::new(first_line_raw as usize)
+    } else {
+        None
     };
 
-    let names = read_names()?;
-    let varnames = read_names()?;
-    let cellvars = read_names()?;
-    let freevars = read_names()?;
+    // 15–16: linetable, exceptiontable
+    let linetable = read_marshal_bytes(rdr)?.to_vec().into_boxed_slice();
+    let exceptiontable = read_marshal_bytes(rdr)?.to_vec().into_boxed_slice();
+
+    // Split localsplusnames/kinds → varnames/cellvars/freevars
+    let lp = split_localplus(
+        &localsplusnames
+            .iter()
+            .map(|s| s.as_str())
+            .collect::<Vec<&str>>(),
+        &localspluskinds,
+        arg_count,
+        kwonlyarg_count,
+        flags,
+    )?;
 
-    // Read linetable and exceptiontable
-    let linetable_len = rdr.read_u32()?;
-    let linetable = rdr.read_slice(linetable_len)?.to_vec().into_boxed_slice();
+    // Bytecode already uses flat localsplus indices (no translation needed)
+    let instructions = CodeUnits::try_from(code_bytes.as_slice())?;
+    let locations = linetable_to_locations(&linetable, first_line_raw, instructions.len());
 
-    let exceptiontable_len = rdr.read_u32()?;
-    let exceptiontable = rdr
-        .read_slice(exceptiontable_len)?
-        .to_vec()
-        .into_boxed_slice();
+    // Use original localspluskinds from marshal data (preserves CO_FAST_HIDDEN etc.)
+    let localspluskinds = localspluskinds.into_boxed_slice();
 
     Ok(CodeObject {
         instructions,
@@ -274,19 +264,87 @@ pub fn deserialize_code<R: Read, Bag: ConstantBag>(
         max_stackdepth,
         obj_name,
         qualname,
-        cell2arg,
         constants,
         names,
-        varnames,
-        cellvars,
-        freevars,
+        varnames: lp.varnames.iter().map(|s| bag.make_name(s)).collect(),
+        cellvars: lp.cellvars.iter().map(|s| bag.make_name(s)).collect(),
+        freevars: lp.freevars.iter().map(|s| bag.make_name(s)).collect(),
+        localspluskinds,
         linetable,
         exceptiontable,
     })
 }
 
+/// Read a marshal bytes object (TYPE_STRING = b's').
+fn read_marshal_bytes<R: Read>(rdr: &mut R) -> Result<Vec<u8>> {
+    let type_byte = rdr.read_u8()? & !FLAG_REF;
+    if type_byte != Type::Bytes as u8 {
+        return Err(MarshalError::BadType);
+    }
+    let len = rdr.read_u32()?;
+    Ok(rdr.read_slice(len)?.to_vec())
+}
+
+/// Read a marshal string object.
+fn read_marshal_str<R: Read>(rdr: &mut R) -> Result<alloc::string::String> {
+    let type_byte = rdr.read_u8()? & !FLAG_REF;
+    let s = match type_byte {
+        b'u' | b't' | b'a' | b'A' => {
+            let len = rdr.read_u32()?;
+            rdr.read_str(len)?
+        }
+        b'z' | b'Z' => {
+            let len = rdr.read_u8()? as u32;
+            rdr.read_str(len)?
+        }
+        _ => return Err(MarshalError::BadType),
+    };
+    Ok(alloc::string::String::from(s))
+}
+
+/// Read a marshal tuple of strings, returning owned Strings.
+fn read_marshal_str_vec<R: Read>(rdr: &mut R) -> Result<Vec<alloc::string::String>> {
+    let type_byte = rdr.read_u8()? & !FLAG_REF;
+    let n = match type_byte {
+        b'(' => rdr.read_u32()? as usize,
+        b')' => rdr.read_u8()? as usize,
+        _ => return Err(MarshalError::BadType),
+    };
+    (0..n).map(|_| read_marshal_str(rdr)).collect()
+}
+
+fn read_marshal_name_tuple<R: Read, Bag: ConstantBag>(
+    rdr: &mut R,
+    bag: &Bag,
+) -> Result<Box<[<Bag::Constant as Constant>::Name]>> {
+    let type_byte = rdr.read_u8()? & !FLAG_REF;
+    let n = match type_byte {
+        b'(' => rdr.read_u32()? as usize,
+        b')' => rdr.read_u8()? as usize,
+        _ => return Err(MarshalError::BadType),
+    };
+    (0..n)
+        .map(|_| Ok(bag.make_name(&read_marshal_str(rdr)?)))
+        .collect::<Result<Vec<_>>>()
+        .map(Vec::into_boxed_slice)
+}
+
+/// Read a marshal tuple of constants.
+fn read_marshal_const_tuple<R: Read, Bag: ConstantBag>(
+    rdr: &mut R,
+    bag: Bag,
+) -> Result<Constants<Bag::Constant>> {
+    let type_byte = rdr.read_u8()? & !FLAG_REF;
+    let n = match type_byte {
+        b'(' => rdr.read_u32()? as usize,
+        b')' => rdr.read_u8()? as usize,
+        _ => return Err(MarshalError::BadType),
+    };
+    (0..n).map(|_| deserialize_value(rdr, bag)).collect()
+}
+
 pub trait MarshalBag: Copy {
-    type Value;
+    type Value: Clone;
     type ConstantBag: ConstantBag;
 
     fn make_bool(&self, value: bool) -> Self::Value;
@@ -325,6 +383,15 @@ pub trait MarshalBag: Copy {
         it: impl Iterator<Item = (Self::Value, Self::Value)>,
     ) -> Result<Self::Value>;
 
+    fn make_slice(
+        &self,
+        _start: Self::Value,
+        _stop: Self::Value,
+        _step: Self::Value,
+    ) -> Result<Self::Value> {
+        Err(MarshalError::BadType)
+    }
+
     fn constant_bag(self) -> Self::ConstantBag;
 }
 
@@ -368,6 +435,20 @@ impl<Bag: ConstantBag> MarshalBag for Bag {
         self.make_tuple(elements)
     }
 
+    fn make_slice(
+        &self,
+        start: Self::Value,
+        stop: Self::Value,
+        step: Self::Value,
+    ) -> Result<Self::Value> {
+        let elements = [start, stop, step];
+        Ok(
+            self.make_constant::<Bag::Constant>(BorrowedConstant::Slice {
+                elements: &elements,
+            }),
+        )
+    }
+
     fn make_code(
         &self,
         code: CodeObject<<Self::ConstantBag as ConstantBag>::Constant>,
@@ -387,8 +468,13 @@ impl<Bag: ConstantBag> MarshalBag for Bag {
         Err(MarshalError::BadType)
     }
 
-    fn make_frozenset(&self, _: impl Iterator<Item = Self::Value>) -> Result<Self::Value> {
-        Err(MarshalError::BadType)
+    fn make_frozenset(&self, it: impl Iterator<Item = Self::Value>) -> Result<Self::Value> {
+        let elements: Vec<Self::Value> = it.collect();
+        Ok(
+            self.make_constant::<Bag::Constant>(BorrowedConstant::Frozenset {
+                elements: &elements,
+            }),
+        )
     }
 
     fn make_dict(
@@ -403,8 +489,63 @@ impl<Bag: ConstantBag> MarshalBag for Bag {
     }
 }
 
+pub const MAX_MARSHAL_STACK_DEPTH: usize = 2000;
+
 pub fn deserialize_value<R: Read, Bag: MarshalBag>(rdr: &mut R, bag: Bag) -> Result<Bag::Value> {
-    let typ = Type::try_from(rdr.read_u8()?)?;
+    let mut refs: Vec<Option<Bag::Value>> = Vec::new();
+    deserialize_value_depth(rdr, bag, MAX_MARSHAL_STACK_DEPTH, &mut refs)
+}
+
+fn deserialize_value_depth<R: Read, Bag: MarshalBag>(
+    rdr: &mut R,
+    bag: Bag,
+    depth: usize,
+    refs: &mut Vec<Option<Bag::Value>>,
+) -> Result<Bag::Value> {
+    if depth == 0 {
+        return Err(MarshalError::InvalidBytecode);
+    }
+    let raw = rdr.read_u8()?;
+    let flag = raw & FLAG_REF != 0;
+    let type_code = raw & !FLAG_REF;
+
+    // TYPE_REF: return previously stored object
+    if type_code == Type::Ref as u8 {
+        let idx = rdr.read_u32()? as usize;
+        return refs
+            .get(idx)
+            .and_then(|v| v.clone())
+            .ok_or(MarshalError::InvalidBytecode);
+    }
+
+    // Reserve ref slot before reading (matches write order)
+    let slot = if flag {
+        let idx = refs.len();
+        refs.push(None);
+        Some(idx)
+    } else {
+        None
+    };
+
+    let typ = Type::try_from(type_code)?;
+    let value = deserialize_value_typed(rdr, bag, depth, refs, typ)?;
+
+    if let Some(idx) = slot {
+        refs[idx] = Some(value.clone());
+    }
+    Ok(value)
+}
+
+fn deserialize_value_typed<R: Read, Bag: MarshalBag>(
+    rdr: &mut R,
+    bag: Bag,
+    depth: usize,
+    refs: &mut Vec<Option<Bag::Value>>,
+    typ: Type,
+) -> Result<Bag::Value> {
+    if depth == 0 {
+        return Err(MarshalError::InvalidBytecode);
+    }
     let value = match typ {
         Type::True => bag.make_bool(true),
         Type::False => bag.make_bool(false),
@@ -412,68 +553,127 @@ pub fn deserialize_value<R: Read, Bag: MarshalBag>(rdr: &mut R, bag: Bag) -> Res
         Type::StopIter => bag.make_stop_iter()?,
         Type::Ellipsis => bag.make_ellipsis(),
         Type::Int => {
-            let len = rdr.read_u32()? as i32;
-            let sign = if len < 0 { Sign::Minus } else { Sign::Plus };
-            let bytes = rdr.read_slice(len.unsigned_abs())?;
-            let int = BigInt::from_bytes_le(sign, bytes);
-            bag.make_int(int)
+            let val = rdr.read_u32()? as i32;
+            bag.make_int(BigInt::from(val))
         }
+        Type::Int64 => {
+            let lo = rdr.read_u32()? as u64;
+            let hi = rdr.read_u32()? as u64;
+            bag.make_int(BigInt::from(((hi << 32) | lo) as i64))
+        }
+        Type::Long => bag.make_int(read_pylong(rdr)?),
+        Type::FloatStr => bag.make_float(read_float_str(rdr)?),
         Type::Float => {
             let value = f64::from_bits(rdr.read_u64()?);
             bag.make_float(value)
         }
+        Type::ComplexStr => {
+            let re = read_float_str(rdr)?;
+            let im = read_float_str(rdr)?;
+            bag.make_complex(Complex64 { re, im })
+        }
         Type::Complex => {
             let re = f64::from_bits(rdr.read_u64()?);
             let im = f64::from_bits(rdr.read_u64()?);
             let value = Complex64 { re, im };
             bag.make_complex(value)
         }
-        Type::Ascii | Type::Unicode => {
+        Type::Ascii | Type::AsciiInterned | Type::Unicode | Type::Interned => {
             let len = rdr.read_u32()?;
             let value = rdr.read_wtf8(len)?;
             bag.make_str(value)
         }
+        Type::ShortAscii | Type::ShortAsciiInterned => {
+            let len = rdr.read_u8()? as u32;
+            let value = rdr.read_wtf8(len)?;
+            bag.make_str(value)
+        }
+        Type::SmallTuple => {
+            let len = rdr.read_u8()? as usize;
+            let d = depth - 1;
+            let it = (0..len).map(|_| deserialize_value_depth(rdr, bag, d, refs));
+            itertools::process_results(it, |it| bag.make_tuple(it))?
+        }
+        Type::Null => {
+            return Err(MarshalError::BadType);
+        }
+        Type::Ref => {
+            // Handled in deserialize_value_depth before calling this function
+            return Err(MarshalError::BadType);
+        }
         Type::Tuple => {
             let len = rdr.read_u32()?;
-            let it = (0..len).map(|_| deserialize_value(rdr, bag));
+            let d = depth - 1;
+            let it = (0..len).map(|_| deserialize_value_depth(rdr, bag, d, refs));
             itertools::process_results(it, |it| bag.make_tuple(it))?
         }
         Type::List => {
             let len = rdr.read_u32()?;
-            let it = (0..len).map(|_| deserialize_value(rdr, bag));
+            let d = depth - 1;
+            let it = (0..len).map(|_| deserialize_value_depth(rdr, bag, d, refs));
             itertools::process_results(it, |it| bag.make_list(it))??
         }
         Type::Set => {
             let len = rdr.read_u32()?;
-            let it = (0..len).map(|_| deserialize_value(rdr, bag));
+            let d = depth - 1;
+            let it = (0..len).map(|_| deserialize_value_depth(rdr, bag, d, refs));
             itertools::process_results(it, |it| bag.make_set(it))??
         }
         Type::FrozenSet => {
             let len = rdr.read_u32()?;
-            let it = (0..len).map(|_| deserialize_value(rdr, bag));
+            let d = depth - 1;
+            let it = (0..len).map(|_| deserialize_value_depth(rdr, bag, d, refs));
             itertools::process_results(it, |it| bag.make_frozenset(it))??
         }
         Type::Dict => {
-            let len = rdr.read_u32()?;
-            let it = (0..len).map(|_| {
-                let k = deserialize_value(rdr, bag)?;
-                let v = deserialize_value(rdr, bag)?;
-                Ok::<_, MarshalError>((k, v))
-            });
-            itertools::process_results(it, |it| bag.make_dict(it))??
+            let d = depth - 1;
+            let mut pairs = Vec::new();
+            loop {
+                let raw = rdr.read_u8()?;
+                let type_code = raw & !FLAG_REF;
+                if type_code == b'0' {
+                    break;
+                }
+                // TYPE_REF for key
+                let k = if type_code == Type::Ref as u8 {
+                    let idx = rdr.read_u32()? as usize;
+                    refs.get(idx)
+                        .and_then(|v| v.clone())
+                        .ok_or(MarshalError::InvalidBytecode)?
+                } else {
+                    let flag = raw & FLAG_REF != 0;
+                    let key_slot = if flag {
+                        let idx = refs.len();
+                        refs.push(None);
+                        Some(idx)
+                    } else {
+                        None
+                    };
+                    let key_type = Type::try_from(type_code)?;
+                    let k = deserialize_value_typed(rdr, bag, d, refs, key_type)?;
+                    if let Some(idx) = key_slot {
+                        refs[idx] = Some(k.clone());
+                    }
+                    k
+                };
+                let v = deserialize_value_depth(rdr, bag, d, refs)?;
+                pairs.push((k, v));
+            }
+            bag.make_dict(pairs.into_iter())?
         }
         Type::Bytes => {
-            // Following CPython, after marshaling, byte arrays are converted into bytes.
+            // After marshaling, byte arrays are converted into bytes.
             let len = rdr.read_u32()?;
             let value = rdr.read_slice(len)?;
             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);
+            let d = depth - 1;
+            let start = deserialize_value_depth(rdr, bag, d, refs)?;
+            let stop = deserialize_value_depth(rdr, bag, d, refs)?;
+            let step = deserialize_value_depth(rdr, bag, d, refs)?;
+            bag.make_slice(start, stop, step)?
         }
     };
     Ok(value)
@@ -502,6 +702,7 @@ pub enum DumpableValue<'a, D: Dumpable> {
     Set(&'a [D]),
     Frozenset(&'a [D]),
     Dict(&'a [(D, D)]),
+    Slice(&'a D, &'a D, &'a D),
 }
 
 impl<'a, C: Constant> From<BorrowedConstant<'a, C>> for DumpableValue<'a, C> {
@@ -515,6 +716,10 @@ impl<'a, C: Constant> From<BorrowedConstant<'a, C>> for DumpableValue<'a, C> {
             BorrowedConstant::Bytes { value } => Self::Bytes(value),
             BorrowedConstant::Code { code } => Self::Code(code),
             BorrowedConstant::Tuple { elements } => Self::Tuple(elements),
+            BorrowedConstant::Slice { elements } => {
+                Self::Slice(&elements[0], &elements[1], &elements[2])
+            }
+            BorrowedConstant::Frozenset { elements } => Self::Frozenset(elements),
             BorrowedConstant::None => Self::None,
             BorrowedConstant::Ellipsis => Self::Ellipsis,
         }
@@ -575,12 +780,37 @@ pub fn serialize_value<W: Write, D: Dumpable>(
 ) -> Result<(), D::Error> {
     match constant {
         DumpableValue::Integer(int) => {
-            buf.write_u8(Type::Int as u8);
-            let (sign, bytes) = int.to_bytes_le();
-            let len: i32 = bytes.len().try_into().expect("too long to serialize");
-            let len = if sign == Sign::Minus { -len } else { len };
-            buf.write_u32(len as u32);
-            buf.write_slice(&bytes);
+            if let Ok(val) = i32::try_from(int) {
+                buf.write_u8(Type::Int as u8); // TYPE_INT: 4-byte LE i32
+                buf.write_u32(val as u32);
+            } else {
+                buf.write_u8(Type::Long as u8);
+                let (sign, raw) = int.to_bytes_le();
+                let mut digits = alloc::vec::Vec::new();
+                let mut accum: u32 = 0;
+                let mut bits = 0u32;
+                for &byte in &raw {
+                    accum |= (byte as u32) << bits;
+                    bits += 8;
+                    while bits >= 15 {
+                        digits.push((accum & 0x7fff) as u16);
+                        accum >>= 15;
+                        bits -= 15;
+                    }
+                }
+                if accum > 0 || digits.is_empty() {
+                    digits.push(accum as u16);
+                }
+                while digits.len() > 1 && *digits.last().unwrap() == 0 {
+                    digits.pop();
+                }
+                let n = digits.len() as i32;
+                let n = if sign == Sign::Minus { -n } else { n };
+                buf.write_u32(n as u32);
+                for d in &digits {
+                    buf.write_u16(*d);
+                }
+            }
         }
         DumpableValue::Float(f) => {
             buf.write_u8(Type::Float as u8);
@@ -645,68 +875,411 @@ pub fn serialize_value<W: Write, D: Dumpable>(
         }
         DumpableValue::Dict(d) => {
             buf.write_u8(Type::Dict as u8);
-            write_len(buf, d.len());
             for (k, v) in d {
                 k.with_dump(|val| serialize_value(buf, val))??;
                 v.with_dump(|val| serialize_value(buf, val))??;
             }
+            buf.write_u8(b'0'); // TYPE_NULL
+        }
+        DumpableValue::Slice(start, stop, step) => {
+            buf.write_u8(Type::Slice as u8);
+            start.with_dump(|val| serialize_value(buf, val))??;
+            stop.with_dump(|val| serialize_value(buf, val))??;
+            step.with_dump(|val| serialize_value(buf, val))??;
         }
     }
     Ok(())
 }
 
+/// Serialize a code object in CPython field order.
+///
+/// Split varnames/cellvars/freevars are reassembled into
+/// co_localsplusnames/co_localspluskinds.
 pub fn serialize_code<W: Write, C: Constant>(buf: &mut W, code: &CodeObject<C>) {
-    write_len(buf, code.instructions.len());
-    // SAFETY: it's ok to transmute CodeUnit to [u8; 2]
-    let (_, instructions_bytes, _) = unsafe { code.instructions.align_to() };
-    buf.write_slice(instructions_bytes);
+    // 1–5: scalar fields
+    buf.write_u32(code.arg_count);
+    buf.write_u32(code.posonlyarg_count);
+    buf.write_u32(code.kwonlyarg_count);
+    buf.write_u32(code.max_stackdepth);
+    buf.write_u32(code.flags.bits());
+
+    // 6: co_code (TYPE_STRING) — bytecode already uses flat localsplus indices
+    let bytecode = code.instructions.original_bytes();
+    buf.write_u8(Type::Bytes as u8);
+    write_vec(buf, &bytecode);
 
-    write_len(buf, code.locations.len());
-    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 _);
+    // 7: co_consts (TYPE_TUPLE)
+    buf.write_u8(Type::Tuple as u8);
+    write_len(buf, code.constants.len());
+    for constant in &*code.constants {
+        serialize_value(buf, constant.borrow_constant().into()).unwrap_or_else(|x| match x {})
     }
 
-    buf.write_u32(code.flags.bits());
+    // 8: co_names (tuple of strings)
+    write_marshal_name_tuple(buf, &code.names);
+
+    // 9: co_localsplusnames — varnames ++ cell_only ++ freevars
+    let cell_only_names: Vec<&str> = code
+        .cellvars
+        .iter()
+        .filter(|cv| !code.varnames.iter().any(|v| v.as_ref() == cv.as_ref()))
+        .map(|cv| cv.as_ref())
+        .collect();
+    let total_lp_count = code.varnames.len() + cell_only_names.len() + code.freevars.len();
+    buf.write_u8(Type::Tuple as u8);
+    write_len(buf, total_lp_count);
+    for n in code.varnames.iter() {
+        write_marshal_str(buf, n.as_ref());
+    }
+    for &n in &cell_only_names {
+        write_marshal_str(buf, n);
+    }
+    for n in code.freevars.iter() {
+        write_marshal_str(buf, n.as_ref());
+    }
+    // 10: co_localspluskinds — use the stored kinds directly
+    buf.write_u8(Type::Bytes as u8);
+    write_vec(buf, &code.localspluskinds);
+
+    // 11: co_filename
+    write_marshal_str(buf, code.source_path.as_ref());
+    // 12: co_name
+    write_marshal_str(buf, code.obj_name.as_ref());
+    // 13: co_qualname
+    write_marshal_str(buf, code.qualname.as_ref());
+    // 14: co_firstlineno
+    buf.write_u32(code.first_line_number.map_or(0, |x| x.get() as _));
+    // 15: co_linetable
+    buf.write_u8(Type::Bytes as u8);
+    write_vec(buf, &code.linetable);
+    // 16: co_exceptiontable
+    buf.write_u8(Type::Bytes as u8);
+    write_vec(buf, &code.exceptiontable);
+}
 
-    buf.write_u32(code.posonlyarg_count);
-    buf.write_u32(code.arg_count);
-    buf.write_u32(code.kwonlyarg_count);
+fn write_marshal_str<W: Write>(buf: &mut W, s: &str) {
+    let bytes = s.as_bytes();
+    if bytes.len() < 256 && bytes.is_ascii() {
+        buf.write_u8(b'z'); // TYPE_SHORT_ASCII
+        buf.write_u8(bytes.len() as u8);
+    } else {
+        buf.write_u8(Type::Unicode as u8);
+        write_len(buf, bytes.len());
+    }
+    buf.write_slice(bytes);
+}
 
-    write_vec(buf, code.source_path.as_ref().as_bytes());
+fn write_marshal_name_tuple<W: Write, N: AsRef<str>>(buf: &mut W, names: &[N]) {
+    buf.write_u8(Type::Tuple as u8);
+    write_len(buf, names.len());
+    for name in names {
+        write_marshal_str(buf, name.as_ref());
+    }
+}
 
-    buf.write_u32(code.first_line_number.map_or(0, |x| x.get() as _));
-    buf.write_u32(code.max_stackdepth);
+pub const FLAG_REF: u8 = 0x80;
 
-    write_vec(buf, code.obj_name.as_ref().as_bytes());
-    write_vec(buf, code.qualname.as_ref().as_bytes());
+/// Read a signed 32-bit LE integer.
+pub fn read_i32<R: Read>(rdr: &mut R) -> Result<i32> {
+    let bytes = rdr.read_array::<4>()?;
+    Ok(i32::from_le_bytes(*bytes))
+}
 
-    let cell2arg = code.cell2arg.as_deref().unwrap_or(&[]);
-    write_len(buf, cell2arg.len());
-    for &i in cell2arg {
-        buf.write_u32(i as u32)
+/// Read a TYPE_LONG arbitrary-precision integer (base-2^15 digits).
+pub fn read_pylong<R: Read>(rdr: &mut R) -> Result<BigInt> {
+    const MARSHAL_SHIFT: u32 = 15;
+    const MARSHAL_BASE: u32 = 1 << MARSHAL_SHIFT;
+    let n = read_i32(rdr)?;
+    if n == 0 {
+        return Ok(BigInt::from(0));
+    }
+    let negative = n < 0;
+    let num_digits = n.unsigned_abs() as usize;
+    let mut accum = BigInt::from(0);
+    let mut last_digit = 0u32;
+    for i in 0..num_digits {
+        let d = rdr.read_u16()? as u32;
+        if d >= MARSHAL_BASE {
+            return Err(MarshalError::InvalidBytecode);
+        }
+        last_digit = d;
+        accum += BigInt::from(d) << (i as u32 * MARSHAL_SHIFT);
+    }
+    if num_digits > 0 && last_digit == 0 {
+        return Err(MarshalError::InvalidBytecode);
+    }
+    if negative {
+        accum = -accum;
     }
+    Ok(accum)
+}
 
-    write_len(buf, code.constants.len());
-    for constant in &*code.constants {
-        serialize_value(buf, constant.borrow_constant().into()).unwrap_or_else(|x| match x {})
+/// Read a text-encoded float (1-byte length + ASCII).
+pub fn read_float_str<R: Read>(rdr: &mut R) -> Result<f64> {
+    let n = rdr.read_u8()? as u32;
+    let s = rdr.read_str(n)?;
+    s.parse::<f64>().map_err(|_| MarshalError::InvalidBytecode)
+}
+
+/// Read a 4-byte-length-prefixed byte string.
+pub fn read_pstring<R: Read>(rdr: &mut R) -> Result<&[u8]> {
+    let n = read_i32(rdr)?;
+    if n < 0 {
+        return Err(MarshalError::InvalidBytecode);
+    }
+    rdr.read_slice(n as u32)
+}
+
+const CO_FAST_LOCAL: u8 = 0x20;
+const CO_FAST_CELL: u8 = 0x40;
+const CO_FAST_FREE: u8 = 0x80;
+
+pub struct LocalsPlusResult<S> {
+    pub varnames: Vec<S>,
+    pub cellvars: Vec<S>,
+    pub freevars: Vec<S>,
+    pub cell2arg: Option<Box<[i32]>>,
+    pub deref_map: Vec<u32>,
+}
+
+pub fn split_localplus<S: Clone>(
+    names: &[S],
+    kinds: &[u8],
+    arg_count: u32,
+    kwonlyarg_count: u32,
+    flags: CodeFlags,
+) -> Result<LocalsPlusResult<S>> {
+    if names.len() != kinds.len() {
+        return Err(MarshalError::InvalidBytecode);
+    }
+
+    let mut varnames = Vec::new();
+    let mut cellvars = Vec::new();
+    let mut freevars = Vec::new();
+
+    // First pass: collect varnames (LOCAL entries) and freevars
+    for (name, &kind) in names.iter().zip(kinds.iter()) {
+        if kind & CO_FAST_LOCAL != 0 {
+            varnames.push(name.clone());
+        }
+        if kind & CO_FAST_FREE != 0 {
+            freevars.push(name.clone());
+        }
+    }
+
+    // Second pass: collect cellvars in localsplusnames order.
+    // CELL-only vars come from non-LOCAL CELL entries.
+    // LOCAL|CELL vars are also added to cellvars.
+    // This preserves the original ordering from localsplusnames.
+    let mut arg_cell_positions = Vec::new(); // (cell_idx, localplus_idx)
+    for (i, (name, &kind)) in names.iter().zip(kinds.iter()).enumerate() {
+        let is_local = kind & CO_FAST_LOCAL != 0;
+        let is_cell = kind & CO_FAST_CELL != 0;
+        if is_cell {
+            let cell_idx = cellvars.len();
+            cellvars.push(name.clone());
+            if is_local {
+                arg_cell_positions.push((cell_idx, i));
+            }
+        }
     }
 
-    let mut write_names = |names: &[C::Name]| {
-        write_len(buf, names.len());
-        for name in names {
-            write_vec(buf, name.as_ref().as_bytes());
+    let total_args = {
+        let mut t = arg_count + kwonlyarg_count;
+        if flags.contains(CodeFlags::VARARGS) {
+            t += 1;
         }
+        if flags.contains(CodeFlags::VARKEYWORDS) {
+            t += 1;
+        }
+        t
     };
 
-    write_names(&code.names);
-    write_names(&code.varnames);
-    write_names(&code.cellvars);
-    write_names(&code.freevars);
+    let cell2arg = if !cellvars.is_empty() {
+        let mut mapping = alloc::vec![-1i32; cellvars.len()];
+        for &(cell_idx, localplus_idx) in &arg_cell_positions {
+            if (localplus_idx as u32) < total_args {
+                mapping[cell_idx] = localplus_idx as i32;
+            }
+        }
+        if mapping.iter().any(|&x| x >= 0) {
+            Some(mapping.into_boxed_slice())
+        } else {
+            None
+        }
+    } else {
+        None
+    };
 
-    // Serialize linetable and exceptiontable
-    write_vec(buf, &code.linetable);
-    write_vec(buf, &code.exceptiontable);
+    // Build deref_map: localsplusnames index → cellvar/freevar index
+    let mut deref_map = alloc::vec![u32::MAX; names.len()];
+    let mut cell_idx = 0u32;
+    for (i, &kind) in kinds.iter().enumerate() {
+        if kind & CO_FAST_CELL != 0 {
+            deref_map[i] = cell_idx;
+            cell_idx += 1;
+        }
+    }
+    let ncells = cellvars.len();
+    let mut free_idx = 0u32;
+    for (i, &kind) in kinds.iter().enumerate() {
+        if kind & CO_FAST_FREE != 0 {
+            deref_map[i] = ncells as u32 + free_idx;
+            free_idx += 1;
+        }
+    }
+
+    Ok(LocalsPlusResult {
+        varnames,
+        cellvars,
+        freevars,
+        cell2arg,
+        deref_map,
+    })
+}
+
+pub fn linetable_to_locations(
+    linetable: &[u8],
+    first_line: i32,
+    num_instructions: usize,
+) -> Box<[(SourceLocation, SourceLocation)]> {
+    let default_loc = || {
+        let line = if first_line > 0 {
+            OneIndexed::new(first_line as usize).unwrap_or(OneIndexed::MIN)
+        } else {
+            OneIndexed::MIN
+        };
+        let loc = SourceLocation {
+            line,
+            character_offset: OneIndexed::from_zero_indexed(0),
+        };
+        (loc, loc)
+    };
+    if linetable.is_empty() {
+        return alloc::vec![default_loc(); num_instructions].into_boxed_slice();
+    }
+
+    let mut locations = Vec::with_capacity(num_instructions);
+    let mut pos = 0;
+    let mut line = first_line;
+
+    while pos < linetable.len() && locations.len() < num_instructions {
+        let first_byte = linetable[pos];
+        pos += 1;
+        if first_byte & 0x80 == 0 {
+            break;
+        }
+        let code = (first_byte >> 3) & 0x0f;
+        let length = ((first_byte & 0x07) + 1) as usize;
+        let kind = match PyCodeLocationInfoKind::from_code(code) {
+            Some(k) => k,
+            None => break,
+        };
+
+        let (line_delta, end_line_delta, col, end_col): (i32, i32, Option<u32>, Option<u32>) =
+            match kind {
+                PyCodeLocationInfoKind::None => (0, 0, None, None),
+                PyCodeLocationInfoKind::Long => {
+                    let d = lt_read_signed_varint(linetable, &mut pos);
+                    let ed = lt_read_varint(linetable, &mut pos) as i32;
+                    let c = lt_read_varint(linetable, &mut pos);
+                    let ec = lt_read_varint(linetable, &mut pos);
+                    (
+                        d,
+                        ed,
+                        if c == 0 { None } else { Some(c - 1) },
+                        if ec == 0 { None } else { Some(ec - 1) },
+                    )
+                }
+                PyCodeLocationInfoKind::NoColumns => {
+                    (lt_read_signed_varint(linetable, &mut pos), 0, None, None)
+                }
+                PyCodeLocationInfoKind::OneLine0
+                | PyCodeLocationInfoKind::OneLine1
+                | PyCodeLocationInfoKind::OneLine2 => {
+                    let c = lt_byte(linetable, &mut pos) as u32;
+                    let ec = lt_byte(linetable, &mut pos) as u32;
+                    (kind.one_line_delta().unwrap_or(0), 0, Some(c), Some(ec))
+                }
+                _ if kind.is_short() => {
+                    let d = lt_byte(linetable, &mut pos);
+                    let g = kind.short_column_group().unwrap_or(0);
+                    let c = ((g as u32) << 3) | ((d >> 4) as u32);
+                    (0, 0, Some(c), Some(c + (d & 0x0f) as u32))
+                }
+                _ => (0, 0, None, None),
+            };
+
+        line += line_delta;
+        for _ in 0..length {
+            if locations.len() >= num_instructions {
+                break;
+            }
+            if kind == PyCodeLocationInfoKind::None {
+                locations.push(default_loc());
+            } else {
+                let mk = |l: i32| {
+                    if l > 0 {
+                        OneIndexed::new(l as usize).unwrap_or(OneIndexed::MIN)
+                    } else {
+                        OneIndexed::MIN
+                    }
+                };
+                locations.push((
+                    SourceLocation {
+                        line: mk(line),
+                        character_offset: OneIndexed::from_zero_indexed(col.unwrap_or(0) as usize),
+                    },
+                    SourceLocation {
+                        line: mk(line + end_line_delta),
+                        character_offset: OneIndexed::from_zero_indexed(
+                            end_col.unwrap_or(0) as usize
+                        ),
+                    },
+                ));
+            }
+        }
+    }
+    while locations.len() < num_instructions {
+        locations.push(default_loc());
+    }
+    locations.into_boxed_slice()
+}
+
+fn lt_byte(data: &[u8], pos: &mut usize) -> u8 {
+    if *pos < data.len() {
+        let b = data[*pos];
+        *pos += 1;
+        b
+    } else {
+        0
+    }
+}
+
+/// Linetable uses little-endian varint.
+fn lt_read_varint(data: &[u8], pos: &mut usize) -> u32 {
+    let mut result: u32 = 0;
+    let mut shift = 0;
+    loop {
+        if *pos >= data.len() {
+            break;
+        }
+        let b = data[*pos];
+        *pos += 1;
+        result |= ((b & 0x3f) as u32) << shift;
+        shift += 6;
+        if b & 0x40 == 0 {
+            break;
+        }
+    }
+    result
+}
+
+fn lt_read_signed_varint(data: &[u8], pos: &mut usize) -> i32 {
+    let val = lt_read_varint(data, pos);
+    if val & 1 != 0 {
+        -((val >> 1) as i32)
+    } else {
+        (val >> 1) as i32
+    }
 }
diff --git a/crates/compiler-core/src/varint.rs b/crates/compiler-core/src/varint.rs
index db8eb88b0e3..c07b8b58e6a 100644
--- a/crates/compiler-core/src/varint.rs
+++ b/crates/compiler-core/src/varint.rs
@@ -1,10 +1,14 @@
 //! 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.
+//! Two encodings are used:
+//! - **Little-endian** (low bits first): linetable
+//! - **Big-endian** (high bits first): exception tables
+//!
+//! Both use 6-bit chunks with 0x40 as the continuation bit.
+
+use alloc::vec::Vec;
 
-/// Write a variable-length unsigned integer using 6-bit chunks.
-/// Returns the number of bytes written.
+/// Write a little-endian varint (used by linetable).
 #[inline]
 pub fn write_varint(buf: &mut Vec<u8>, mut val: u32) -> usize {
     let start_len = buf.len();
@@ -16,12 +20,10 @@ pub fn write_varint(buf: &mut Vec<u8>, mut val: u32) -> usize {
     buf.len() - start_len
 }
 
-/// Write a variable-length signed integer.
-/// Returns the number of bytes written.
+/// Write a little-endian signed varint.
 #[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
@@ -29,70 +31,72 @@ pub fn write_signed_varint(buf: &mut Vec<u8>, val: i32) -> usize {
     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.
+/// Write a big-endian varint (used by exception tables).
+pub fn write_varint_be(buf: &mut Vec<u8>, val: u32) -> usize {
+    let start_len = buf.len();
+    if val >= 1 << 30 {
+        buf.push(0x40 | ((val >> 30) & 0x3f) as u8);
+    }
+    if val >= 1 << 24 {
+        buf.push(0x40 | ((val >> 24) & 0x3f) as u8);
+    }
+    if val >= 1 << 18 {
+        buf.push(0x40 | ((val >> 18) & 0x3f) as u8);
+    }
+    if val >= 1 << 12 {
+        buf.push(0x40 | ((val >> 12) & 0x3f) as u8);
+    }
+    if val >= 1 << 6 {
+        buf.push(0x40 | ((val >> 6) & 0x3f) as u8);
+    }
+    buf.push((val & 0x3f) as u8);
+    buf.len() - start_len
+}
+
+/// Write a big-endian varint with the start marker (0x80) on the first byte.
 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
+    write_varint_be(data, val);
     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.
+/// Read a big-endian varint with start marker (0x80).
 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
+        return None;
     }
     *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
-        }
+    let mut cont = first & 0x40 != 0;
+    while cont && *pos < data.len() {
+        let b = data[*pos];
         *pos += 1;
-        val |= ((byte & 0x3f) as u32) << shift;
-        shift += 6;
-        has_continuation = byte & 0x40 != 0;
+        val = (val << 6) | (b & 0x3f) as u32;
+        cont = b & 0x40 != 0;
     }
     Some(val)
 }
 
-/// Read a variable-length unsigned integer.
-/// Returns None if end of data or malformed.
+/// Read a big-endian varint (no start marker).
 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
-        }
+    let first = data[*pos];
+    *pos += 1;
+    let mut val = (first & 0x3f) as u32;
+    let mut cont = first & 0x40 != 0;
+    while cont && *pos < data.len() {
+        let b = data[*pos];
         *pos += 1;
-        val |= ((byte & 0x3f) as u32) << shift;
-        shift += 6;
-        if byte & 0x40 == 0 {
-            break;
-        }
+        val = (val << 6) | (b & 0x3f) as u32;
+        cont = b & 0x40 != 0;
     }
     Some(val)
 }
@@ -102,37 +106,39 @@ mod tests {
     use super::*;
 
     #[test]
-    fn test_write_read_varint() {
+    fn test_le_varint_roundtrip() {
+        // Little-endian is only used internally in linetable,
+        // no read function needed outside of linetable parsing.
         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());
+    fn test_be_varint_roundtrip() {
+        for &val in &[0u32, 1, 63, 64, 127, 128, 4095, 4096, 1_000_000] {
+            let mut buf = Vec::new();
+            write_varint_be(&mut buf, val);
+            let mut pos = 0;
+            assert_eq!(read_varint(&buf, &mut pos), Some(val), "val={val}");
+            assert_eq!(pos, buf.len());
+        }
     }
 
     #[test]
-    fn test_varint_with_start() {
+    fn test_be_varint_with_start() {
         let mut buf = Vec::new();
         write_varint_with_start(&mut buf, 42);
         write_varint_with_start(&mut buf, 100);
+        write_varint_with_start(&mut buf, 71);
 
         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), Some(71));
         assert_eq!(read_varint_with_start(&buf, &mut pos), None);
     }
 }
diff --git a/crates/compiler-source/Cargo.toml b/crates/compiler-source/Cargo.toml
index 068d31e87ed..cb94c17477f 100644
--- a/crates/compiler-source/Cargo.toml
+++ b/crates/compiler-source/Cargo.toml
@@ -1,7 +1,7 @@
 [package]
 name = "rustpython-compiler-source"
 description = "(DEPRECATED) RustPython Source and Index"
-version = "0.5.0+deprecated"
+version = "0.4.1+deprecated"
 authors.workspace = true
 edition.workspace = true
 rust-version.workspace = true
diff --git a/crates/compiler/src/lib.rs b/crates/compiler/src/lib.rs
index 11e3bf0d07a..815d45f2cd8 100644
--- a/crates/compiler/src/lib.rs
+++ b/crates/compiler/src/lib.rs
@@ -27,6 +27,8 @@ pub struct ParseError {
     pub location: SourceLocation,
     pub end_location: SourceLocation,
     pub source_path: String,
+    /// Set when the error is an unclosed bracket (converted from EOF).
+    pub is_unclosed_bracket: bool,
 }
 
 impl ::core::fmt::Display for ParseError {
@@ -46,26 +48,71 @@ pub enum CompileError {
 impl CompileError {
     pub fn from_ruff_parse_error(error: parser::ParseError, source_file: &SourceFile) -> Self {
         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);
-        }
+        let source_text = source_file.source_text();
+
+        // For EOF errors (unclosed brackets), find the unclosed bracket position
+        // and adjust both the error location and message
+        let mut is_unclosed_bracket = false;
+        let (error_type, location, end_location) = if matches!(
+            &error.error,
+            parser::ParseErrorType::Lexical(parser::LexicalErrorType::Eof)
+        ) {
+            if let Some((bracket_char, bracket_offset)) = find_unclosed_bracket(source_text) {
+                let bracket_text_size = ruff_text_size::TextSize::new(bracket_offset as u32);
+                let loc = source_code.source_location(bracket_text_size, PositionEncoding::Utf8);
+                let end_loc = SourceLocation {
+                    line: loc.line,
+                    character_offset: loc.character_offset.saturating_add(1),
+                };
+                let msg = format!("'{}' was never closed", bracket_char);
+                is_unclosed_bracket = true;
+                (parser::ParseErrorType::OtherError(msg), loc, end_loc)
+            } else {
+                let loc =
+                    source_code.source_location(error.location.start(), PositionEncoding::Utf8);
+                let end_loc =
+                    source_code.source_location(error.location.end(), PositionEncoding::Utf8);
+                (error.error, loc, end_loc)
+            }
+        } else if matches!(
+            &error.error,
+            parser::ParseErrorType::Lexical(parser::LexicalErrorType::IndentationError)
+        ) {
+            // For IndentationError, point the offset to the end of the line content
+            // instead of the beginning
+            let loc = source_code.source_location(error.location.start(), PositionEncoding::Utf8);
+            let line_idx = loc.line.to_zero_indexed();
+            let line = source_text.split('\n').nth(line_idx).unwrap_or("");
+            let line_end_col = line.chars().count() + 1; // 1-indexed, past last char
+            let end_loc = SourceLocation {
+                line: loc.line,
+                character_offset: ruff_source_file::OneIndexed::new(line_end_col)
+                    .unwrap_or(loc.character_offset),
+            };
+            (error.error, end_loc, end_loc)
+        } else {
+            let loc = source_code.source_location(error.location.start(), PositionEncoding::Utf8);
+            let mut end_loc =
+                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_loc.character_offset.get() == 1 && end_loc.line > loc.line {
+                let prev_line_end = error.location.end() - ruff_text_size::TextSize::from(1);
+                end_loc = source_code.source_location(prev_line_end, PositionEncoding::Utf8);
+                end_loc.character_offset = end_loc.character_offset.saturating_add(1);
+            }
+
+            (error.error, loc, end_loc)
+        };
 
         Self::Parse(ParseError {
-            error: error.error,
+            error: error_type,
             raw_location: error.location,
             location,
             end_location,
             source_path: source_file.name().to_owned(),
+            is_unclosed_bracket,
         })
     }
 
@@ -102,6 +149,106 @@ impl CompileError {
     }
 }
 
+/// Find the last unclosed opening bracket in source code.
+/// Returns the bracket character and its byte offset, or None if all brackets are balanced.
+fn find_unclosed_bracket(source: &str) -> Option<(char, usize)> {
+    let mut stack: Vec<(char, usize)> = Vec::new();
+    let mut in_string = false;
+    let mut string_quote = '\0';
+    let mut triple_quote = false;
+    let mut escape_next = false;
+    let mut is_raw_string = false;
+
+    let chars: Vec<(usize, char)> = source.char_indices().collect();
+    let mut i = 0;
+
+    while i < chars.len() {
+        let (byte_offset, ch) = chars[i];
+
+        if escape_next {
+            escape_next = false;
+            i += 1;
+            continue;
+        }
+
+        if in_string {
+            if ch == '\\' && !is_raw_string {
+                escape_next = true;
+            } else if triple_quote {
+                if ch == string_quote
+                    && i + 2 < chars.len()
+                    && chars[i + 1].1 == string_quote
+                    && chars[i + 2].1 == string_quote
+                {
+                    in_string = false;
+                    i += 3;
+                    continue;
+                }
+            } else if ch == string_quote {
+                in_string = false;
+            }
+            i += 1;
+            continue;
+        }
+
+        // Check for comments
+        if ch == '#' {
+            // Skip to end of line
+            while i < chars.len() && chars[i].1 != '\n' {
+                i += 1;
+            }
+            continue;
+        }
+
+        // Check for string start (with optional prefix like r, b, f, u, rb, br, etc.)
+        if ch == '\'' || ch == '"' {
+            // Check up to 2 characters before the quote for string prefix
+            is_raw_string = false;
+            for look_back in 1..=2.min(i) {
+                let prev = chars[i - look_back].1;
+                if matches!(prev, 'r' | 'R') {
+                    is_raw_string = true;
+                    break;
+                }
+                if !matches!(prev, 'b' | 'B' | 'f' | 'F' | 'u' | 'U') {
+                    break;
+                }
+            }
+            string_quote = ch;
+            if i + 2 < chars.len() && chars[i + 1].1 == ch && chars[i + 2].1 == ch {
+                triple_quote = true;
+                in_string = true;
+                i += 3;
+                continue;
+            }
+            triple_quote = false;
+            in_string = true;
+            i += 1;
+            continue;
+        }
+
+        match ch {
+            '(' | '[' | '{' => stack.push((ch, byte_offset)),
+            ')' | ']' | '}' => {
+                let expected = match ch {
+                    ')' => '(',
+                    ']' => '[',
+                    '}' => '{',
+                    _ => unreachable!(),
+                };
+                if stack.last().is_some_and(|&(open, _)| open == expected) {
+                    stack.pop();
+                }
+            }
+            _ => {}
+        }
+
+        i += 1;
+    }
+
+    stack.last().copied()
+}
+
 /// Compile a given source code into a bytecode object.
 pub fn compile(
     source: &str,
diff --git a/crates/derive-impl/src/compile_bytecode.rs b/crates/derive-impl/src/compile_bytecode.rs
index 23c90690dad..16984139fcd 100644
--- a/crates/derive-impl/src/compile_bytecode.rs
+++ b/crates/derive-impl/src/compile_bytecode.rs
@@ -4,7 +4,7 @@
 //!     // either:
 //!     source = "python_source_code",
 //!     // or
-//!     file = "file/path/relative/to/$CARGO_MANIFEST_DIR",
+//!     file = "file/path/relative/to/this/file",
 //!
 //!     // the mode to compile the code in
 //!     mode = "exec", // or "eval" or "single"
@@ -17,10 +17,9 @@ use crate::Diagnostic;
 use proc_macro2::{Span, TokenStream};
 use quote::quote;
 use rustpython_compiler_core::{Mode, bytecode::CodeObject, frozen};
-use std::sync::LazyLock;
 use std::{
     collections::HashMap,
-    env, fs,
+    fs,
     path::{Path, PathBuf},
 };
 use syn::{
@@ -29,17 +28,13 @@ use syn::{
     spanned::Spanned,
 };
 
-static CARGO_MANIFEST_DIR: LazyLock<PathBuf> = LazyLock::new(|| {
-    PathBuf::from(env::var_os("CARGO_MANIFEST_DIR").expect("CARGO_MANIFEST_DIR is not present"))
-});
-
 enum CompilationSourceKind {
     /// Source is a File (Path)
-    File(PathBuf),
+    File { base: PathBuf, rel_path: PathBuf },
     /// Direct Raw source code
     SourceCode(String),
     /// Source is a directory
-    Dir(PathBuf),
+    Dir { base: PathBuf, rel_path: PathBuf },
 }
 
 struct CompiledModule {
@@ -85,12 +80,9 @@ impl CompilationSource {
         compiler: &dyn Compiler,
     ) -> Result<HashMap<String, CompiledModule>, Diagnostic> {
         match &self.kind {
-            CompilationSourceKind::Dir(rel_path) => self.compile_dir(
-                &CARGO_MANIFEST_DIR.join(rel_path),
-                String::new(),
-                mode,
-                compiler,
-            ),
+            CompilationSourceKind::Dir { base, rel_path } => {
+                self.compile_dir(base, &base.join(rel_path), String::new(), mode, compiler)
+            }
             _ => Ok(hashmap! {
                 module_name.clone() => CompiledModule {
                     code: self.compile_single(mode, module_name, compiler)?,
@@ -107,8 +99,8 @@ impl CompilationSource {
         compiler: &dyn Compiler,
     ) -> Result<CodeObject, Diagnostic> {
         match &self.kind {
-            CompilationSourceKind::File(rel_path) => {
-                let path = CARGO_MANIFEST_DIR.join(rel_path);
+            CompilationSourceKind::File { base, rel_path } => {
+                let path = base.join(rel_path);
                 let source = fs::read_to_string(&path).map_err(|err| {
                     Diagnostic::spans_error(
                         self.span,
@@ -124,7 +116,7 @@ impl CompilationSource {
                 compiler,
                 || "string literal",
             ),
-            CompilationSourceKind::Dir(_) => {
+            CompilationSourceKind::Dir { .. } => {
                 unreachable!("Can't use compile_single with directory source")
             }
         }
@@ -132,6 +124,7 @@ impl CompilationSource {
 
     fn compile_dir(
         &self,
+        base: &Path,
         path: &Path,
         parent: String,
         mode: Mode,
@@ -160,6 +153,7 @@ impl CompilationSource {
             })?;
             if path.is_dir() {
                 code_map.extend(self.compile_dir(
+                    base,
                     &path,
                     if parent.is_empty() {
                         file_name.to_string()
@@ -188,10 +182,7 @@ impl CompilationSource {
                         )
                     })?;
                     self.compile_string(&source, mode, module_name.clone(), compiler, || {
-                        path.strip_prefix(&*CARGO_MANIFEST_DIR)
-                            .ok()
-                            .unwrap_or(&path)
-                            .display()
+                        path.strip_prefix(base).ok().unwrap_or(&path).display()
                     })
                 };
                 let code = compile_path(&path).or_else(|e| {
@@ -257,6 +248,16 @@ impl PyCompileArgs {
                 .get_ident()
                 .ok_or_else(|| meta.error("unknown arg"))?;
             let check_str = || meta.value()?.call(parse_str);
+            let str_path = || {
+                let s = check_str()?;
+                let mut base_path = s
+                    .span()
+                    .unwrap()
+                    .local_file()
+                    .ok_or_else(|| err_span!(s, "filepath literal has no span information"))?;
+                base_path.pop();
+                Ok::<_, syn::Error>((base_path, PathBuf::from(s.value())))
+            };
             if ident == "mode" {
                 let s = check_str()?;
                 match s.value().parse() {
@@ -274,9 +275,9 @@ impl PyCompileArgs {
                 });
             } else if ident == "file" {
                 assert_source_empty(&source)?;
-                let path = check_str()?.value().into();
+                let (base, rel_path) = str_path()?;
                 source = Some(CompilationSource {
-                    kind: CompilationSourceKind::File(path),
+                    kind: CompilationSourceKind::File { base, rel_path },
                     span: (ident.span(), meta.input.cursor().span()),
                 });
             } else if ident == "dir" {
@@ -285,9 +286,9 @@ impl PyCompileArgs {
                 }
 
                 assert_source_empty(&source)?;
-                let path = check_str()?.value().into();
+                let (base, rel_path) = str_path()?;
                 source = Some(CompilationSource {
-                    kind: CompilationSourceKind::Dir(path),
+                    kind: CompilationSourceKind::Dir { base, rel_path },
                     span: (ident.span(), meta.input.cursor().span()),
                 });
             } else if ident == "crate_name" {
diff --git a/crates/derive-impl/src/lib.rs b/crates/derive-impl/src/lib.rs
index 51bb0af406f..c00299794de 100644
--- a/crates/derive-impl/src/lib.rs
+++ b/crates/derive-impl/src/lib.rs
@@ -26,6 +26,8 @@ use quote::ToTokens;
 use syn::{DeriveInput, Item};
 use syn_ext::types::PunctuatedNestedMeta;
 
+pub use pymodule::PyModuleArgs;
+
 pub use compile_bytecode::Compiler;
 
 fn result_to_tokens(result: Result<TokenStream, impl Into<Diagnostic>>) -> TokenStream {
@@ -54,7 +56,7 @@ pub fn pyexception(attr: PunctuatedNestedMeta, item: Item) -> TokenStream {
     }
 }
 
-pub fn pymodule(attr: PunctuatedNestedMeta, item: Item) -> TokenStream {
+pub fn pymodule(attr: PyModuleArgs, item: Item) -> TokenStream {
     result_to_tokens(pymodule::impl_pymodule(attr, item))
 }
 
diff --git a/crates/derive-impl/src/pyclass.rs b/crates/derive-impl/src/pyclass.rs
index 31a7fcc7569..d4590c6c4d3 100644
--- a/crates/derive-impl/src/pyclass.rs
+++ b/crates/derive-impl/src/pyclass.rs
@@ -1,8 +1,8 @@
 use super::Diagnostic;
 use crate::util::{
     ALL_ALLOWED_NAMES, ClassItemMeta, ContentItem, ContentItemInner, ErrorVec, ExceptionItemMeta,
-    ItemMeta, ItemMetaInner, ItemNursery, SimpleItemMeta, format_doc, pyclass_ident_and_attrs,
-    pyexception_ident_and_attrs, text_signature,
+    ItemMeta, ItemMetaInner, ItemNursery, SimpleItemMeta, format_doc, infer_native_call_flags,
+    pyclass_ident_and_attrs, pyexception_ident_and_attrs, text_signature,
 };
 use core::str::FromStr;
 use proc_macro2::{Delimiter, Group, Span, TokenStream, TokenTree};
@@ -181,7 +181,7 @@ pub(crate) fn impl_pyclass_impl(attr: PunctuatedNestedMeta, item: Item) -> Resul
                 },
                 parse_quote! {
                     fn __extend_py_class(
-                        ctx: &::rustpython_vm::Context,
+                        ctx: &'static ::rustpython_vm::Context,
                         class: &'static ::rustpython_vm::Py<::rustpython_vm::builtins::PyType>,
                     ) {
                         #getset_impl
@@ -222,7 +222,7 @@ pub(crate) fn impl_pyclass_impl(attr: PunctuatedNestedMeta, item: Item) -> Resul
                         const TP_FLAGS: ::rustpython_vm::types::PyTypeFlags = #flags;
 
                         fn impl_extend_class(
-                            ctx: &::rustpython_vm::Context,
+                            ctx: &'static ::rustpython_vm::Context,
                             class: &'static ::rustpython_vm::Py<::rustpython_vm::builtins::PyType>,
                         ) {
                             #impl_ty::__extend_py_class(ctx, class);
@@ -284,7 +284,7 @@ pub(crate) fn impl_pyclass_impl(attr: PunctuatedNestedMeta, item: Item) -> Resul
                 },
                 parse_quote! {
                     fn __extend_py_class(
-                        ctx: &::rustpython_vm::Context,
+                        ctx: &'static ::rustpython_vm::Context,
                         class: &'static ::rustpython_vm::Py<::rustpython_vm::builtins::PyType>,
                     ) {
                         #getset_impl
@@ -917,7 +917,7 @@ where
                 ("__new__", "Constructor"),
                 ("__init__", "Initializer"),
                 // Representable trait
-                // ("__repr__", "Representable"),
+                ("__repr__", "Representable"),
                 // ("__str__", "???"), // allow __str__
                 // Hashable trait
                 ("__hash__", "Hashable"),
@@ -927,9 +927,9 @@ where
                 // 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"),
+                ("__get__", "GetDescriptor"),
+                ("__set__", "SetDescriptor"),
+                ("__delete__", "SetDescriptor"),
                 // AsNumber trait
                 ("__add__", "AsNumber"),
                 ("__radd__", "AsNumber"),
@@ -981,15 +981,15 @@ where
                 ("__index__", "AsNumber"),
                 ("__bool__", "AsNumber"),
                 // AsSequence trait
-                // ("__len__", "AsSequence (or AsMapping)"),
-                // ("__contains__", "AsSequence"),
+                ("__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"),
+                ("__getitem__", "AsMapping (or AsSequence)"),
+                ("__setitem__", "AsMapping (or AsSequence)"),
+                ("__delitem__", "AsMapping (or AsSequence)"),
+                // Iterable/IterNext traits
+                ("__iter__", "Iterable"),
+                ("__next__", "IterNext"),
                 // Comparable trait
                 ("__eq__", "Comparable"),
                 ("__ne__", "Comparable"),
@@ -1015,6 +1015,16 @@ where
 
         let raw = item_meta.raw()?;
         let sig_doc = text_signature(func.sig(), &py_name);
+        let has_receiver = func
+            .sig()
+            .inputs
+            .iter()
+            .any(|arg| matches!(arg, syn::FnArg::Receiver(_)));
+        let drop_first_typed = match self.inner.attr_name {
+            AttrName::Method | AttrName::ClassMethod if !has_receiver && !raw => 1,
+            _ => 0,
+        };
+        let call_flags = infer_native_call_flags(func.sig(), drop_first_typed);
 
         // Add #[allow(non_snake_case)] for setter methods like set___name__
         let method_name = ident.to_string();
@@ -1031,6 +1041,7 @@ where
             doc,
             raw,
             attr_name: self.inner.attr_name,
+            call_flags,
         });
         Ok(())
     }
@@ -1207,13 +1218,18 @@ where
         let item_meta = MemberItemMeta::from_attr(ident.clone(), &item_attr)?;
 
         let (py_name, member_item_kind) = item_meta.member_name()?;
-        let member_kind = match item_meta.member_kind()? {
-            Some(s) => match s.as_str() {
-                "bool" => MemberKind::Bool,
-                _ => unreachable!(),
-            },
-            _ => MemberKind::ObjectEx,
-        };
+        let member_kind = item_meta.member_kind()?;
+        if let Some(ref s) = member_kind {
+            match s.as_str() {
+                "bool" | "object" => {}
+                other => {
+                    return Err(self.new_syn_error(
+                        args.item.span(),
+                        &format!("unknown member type '{other}'"),
+                    ));
+                }
+            }
+        }
 
         // Add #[allow(non_snake_case)] for setter methods
         if matches!(member_item_kind, MemberItemKind::Set) {
@@ -1243,6 +1259,7 @@ struct MethodNurseryItem {
     raw: bool,
     doc: Option<String>,
     attr_name: AttrName,
+    call_flags: TokenStream,
 }
 
 impl MethodNursery {
@@ -1273,7 +1290,7 @@ impl ToTokens for MethodNursery {
             } else {
                 quote! { None }
             };
-            let flags = match &item.attr_name {
+            let binding_flags = match &item.attr_name {
                 AttrName::Method => {
                     quote! { rustpython_vm::function::PyMethodFlags::METHOD }
                 }
@@ -1285,6 +1302,12 @@ impl ToTokens for MethodNursery {
                 }
                 _ => unreachable!(),
             };
+            let call_flags = &item.call_flags;
+            let flags = quote! {
+                rustpython_vm::function::PyMethodFlags::from_bits_retain(
+                    (#binding_flags).bits() | (#call_flags).bits()
+                )
+            };
             // TODO: intern
             // let py_name = if py_name.starts_with("__") && py_name.ends_with("__") {
             //     let name_ident = Ident::new(&py_name, ident.span());
@@ -1393,37 +1416,47 @@ impl ToTokens for GetSetNursery {
     }
 }
 
+/// Member kind as string, matching `rustpython_vm::builtins::descriptor::MemberKind` variants.
+/// None means ObjectEx (default). Valid values: "bool", "object".
+type MemberKindStr = Option<String>;
+
 #[derive(Default)]
-#[allow(clippy::type_complexity)]
 struct MemberNursery {
-    map: HashMap<(String, MemberKind), (Option<Ident>, Option<Ident>)>,
+    map: HashMap<String, MemberNurseryEntry>,
     validated: bool,
 }
 
+struct MemberNurseryEntry {
+    kind: MemberKindStr,
+    getter: Option<Ident>,
+    setter: Option<Ident>,
+}
+
 enum MemberItemKind {
     Get,
     Set,
 }
 
-#[derive(Eq, PartialEq, Hash)]
-enum MemberKind {
-    Bool,
-    ObjectEx,
-}
-
 impl MemberNursery {
     fn add_item(
         &mut self,
         name: String,
         kind: MemberItemKind,
-        member_kind: MemberKind,
+        member_kind: MemberKindStr,
         item_ident: Ident,
     ) -> Result<()> {
         assert!(!self.validated, "new item is not allowed after validation");
-        let entry = self.map.entry((name.clone(), member_kind)).or_default();
+        let entry = self
+            .map
+            .entry(name.clone())
+            .or_insert_with(|| MemberNurseryEntry {
+                kind: member_kind,
+                getter: None,
+                setter: None,
+            });
         let func = match kind {
-            MemberItemKind::Get => &mut entry.0,
-            MemberItemKind::Set => &mut entry.1,
+            MemberItemKind::Get => &mut entry.getter,
+            MemberItemKind::Set => &mut entry.setter,
         };
         if func.is_some() {
             bail_span!(item_ident, "Multiple member accessors with name '{}'", name);
@@ -1434,10 +1467,10 @@ impl MemberNursery {
 
     fn validate(&mut self) -> Result<()> {
         let mut errors = Vec::new();
-        for ((name, _), (getter, setter)) in &self.map {
-            if getter.is_none() {
+        for (name, entry) in &self.map {
+            if entry.getter.is_none() {
                 errors.push(err_span!(
-                    setter.as_ref().unwrap(),
+                    entry.setter.as_ref().unwrap(),
                     "Member '{}' is missing a getter",
                     name
                 ));
@@ -1452,30 +1485,31 @@ impl MemberNursery {
 impl ToTokens for MemberNursery {
     fn to_tokens(&self, tokens: &mut TokenStream) {
         assert!(self.validated, "Call `validate()` before token generation");
-        let properties = self
-            .map
-            .iter()
-            .map(|((name, member_kind), (getter, setter))| {
-                let setter = match setter {
-                    Some(setter) => quote_spanned! { setter.span() => Some(Self::#setter)},
-                    None => quote! { None },
-                };
-                let member_kind = match member_kind {
-                    MemberKind::Bool => {
-                        quote!(::rustpython_vm::builtins::descriptor::MemberKind::Bool)
-                    }
-                    MemberKind::ObjectEx => {
-                        quote!(::rustpython_vm::builtins::descriptor::MemberKind::ObjectEx)
-                    }
-                };
-                quote_spanned! { getter.span() =>
-                    class.set_str_attr(
-                        #name,
-                        ctx.new_member(#name, #member_kind, Self::#getter, #setter, class),
-                        ctx,
-                    );
+        let properties = self.map.iter().map(|(name, entry)| {
+            let setter = match &entry.setter {
+                Some(setter) => quote_spanned! { setter.span() => Some(Self::#setter)},
+                None => quote! { None },
+            };
+            let member_kind = match entry.kind.as_deref() {
+                Some("bool") => {
+                    quote!(::rustpython_vm::builtins::descriptor::MemberKind::Bool)
                 }
-            });
+                Some("object") => {
+                    quote!(::rustpython_vm::builtins::descriptor::MemberKind::Object)
+                }
+                _ => {
+                    quote!(::rustpython_vm::builtins::descriptor::MemberKind::ObjectEx)
+                }
+            };
+            let getter = entry.getter.as_ref().unwrap();
+            quote_spanned! { getter.span() =>
+                class.set_str_attr(
+                    #name,
+                    ctx.new_member(#name, #member_kind, Self::#getter, #setter, class),
+                    ctx,
+                );
+            }
+        });
         tokens.extend(properties);
     }
 }
diff --git a/crates/derive-impl/src/pymodule.rs b/crates/derive-impl/src/pymodule.rs
index 278aab37dbc..b4b5535200c 100644
--- a/crates/derive-impl/src/pymodule.rs
+++ b/crates/derive-impl/src/pymodule.rs
@@ -2,17 +2,102 @@ use crate::error::Diagnostic;
 use crate::pystructseq::PyStructSequenceMeta;
 use crate::util::{
     ALL_ALLOWED_NAMES, AttrItemMeta, AttributeExt, ClassItemMeta, ContentItem, ContentItemInner,
-    ErrorVec, ItemMeta, ItemNursery, ModuleItemMeta, SimpleItemMeta, format_doc, iter_use_idents,
-    pyclass_ident_and_attrs, text_signature,
+    ErrorVec, ItemMeta, ItemNursery, ModuleItemMeta, SimpleItemMeta, format_doc,
+    infer_native_call_flags, 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 quote::{ToTokens, format_ident, quote, quote_spanned};
 use rustpython_doc::DB;
 use std::collections::HashSet;
 use syn::{Attribute, Ident, Item, Result, parse_quote, spanned::Spanned};
 use syn_ext::ext::*;
-use syn_ext::types::PunctuatedNestedMeta;
+use syn_ext::types::NestedMeta;
+
+/// A `with(...)` item that may be gated by `#[cfg(...)]` attributes.
+pub struct WithItem {
+    pub cfg_attrs: Vec<Attribute>,
+    pub path: syn::Path,
+}
+
+impl syn::parse::Parse for WithItem {
+    fn parse(input: syn::parse::ParseStream<'_>) -> Result<Self> {
+        let cfg_attrs = Attribute::parse_outer(input)?;
+        for attr in &cfg_attrs {
+            if !attr.path().is_ident("cfg") {
+                return Err(syn::Error::new_spanned(
+                    attr,
+                    "only #[cfg(...)] is supported in with()",
+                ));
+            }
+        }
+        let path = input.parse()?;
+        Ok(WithItem { cfg_attrs, path })
+    }
+}
+
+/// Parsed arguments for `#[pymodule(...)]`, supporting `#[cfg]` inside `with(...)`.
+pub struct PyModuleArgs {
+    pub metas: Vec<NestedMeta>,
+    pub with_items: Vec<WithItem>,
+}
+
+impl syn::parse::Parse for PyModuleArgs {
+    fn parse(input: syn::parse::ParseStream<'_>) -> Result<Self> {
+        let mut metas = Vec::new();
+        let mut with_items = Vec::new();
+
+        while !input.is_empty() {
+            // Detect `with(...)` — an ident "with" followed by a paren group
+            if input.peek(Ident) && input.peek2(syn::token::Paren) {
+                let fork = input.fork();
+                let ident: Ident = fork.parse()?;
+                if ident == "with" {
+                    // Advance past "with"
+                    let _: Ident = input.parse()?;
+                    let content;
+                    syn::parenthesized!(content in input);
+                    let items =
+                        syn::punctuated::Punctuated::<WithItem, syn::Token![,]>::parse_terminated(
+                            &content,
+                        )?;
+                    with_items.extend(items);
+                    if !input.is_empty() {
+                        input.parse::<syn::Token![,]>()?;
+                    }
+                    continue;
+                }
+            }
+            metas.push(input.parse::<NestedMeta>()?);
+            if input.is_empty() {
+                break;
+            }
+            input.parse::<syn::Token![,]>()?;
+        }
+
+        Ok(PyModuleArgs { metas, with_items })
+    }
+}
+
+/// Generate `#[cfg(not(...))]` attributes that negate the given `#[cfg(...)]` attributes.
+fn negate_cfg_attrs(cfg_attrs: &[Attribute]) -> Vec<Attribute> {
+    if cfg_attrs.is_empty() {
+        return vec![];
+    }
+    let predicates: Vec<_> = cfg_attrs
+        .iter()
+        .map(|attr| match &attr.meta {
+            syn::Meta::List(list) => list.tokens.clone(),
+            _ => unreachable!("only #[cfg(...)] should be here"),
+        })
+        .collect();
+    if predicates.len() == 1 {
+        let predicate = &predicates[0];
+        vec![parse_quote!(#[cfg(not(#predicate))])]
+    } else {
+        vec![parse_quote!(#[cfg(not(all(#(#predicates),*)))])]
+    }
+}
 
 #[derive(Clone, Copy, Eq, PartialEq)]
 enum AttrName {
@@ -62,14 +147,15 @@ struct ModuleContext {
     errors: Vec<syn::Error>,
 }
 
-pub fn impl_pymodule(attr: PunctuatedNestedMeta, module_item: Item) -> Result<TokenStream> {
+pub fn impl_pymodule(args: PyModuleArgs, module_item: Item) -> Result<TokenStream> {
+    let PyModuleArgs { metas, with_items } = args;
     let (doc, mut module_item) = match module_item {
         Item::Mod(m) => (m.attrs.doc(), m),
         other => bail_span!(other, "#[pymodule] can only be on a full module"),
     };
     let fake_ident = Ident::new("pymodule", module_item.span());
     let module_meta =
-        ModuleItemMeta::from_nested(module_item.ident.clone(), fake_ident, attr.into_iter())?;
+        ModuleItemMeta::from_nested(module_item.ident.clone(), fake_ident, metas.into_iter())?;
 
     // generation resources
     let mut context = ModuleContext {
@@ -108,6 +194,59 @@ pub fn impl_pymodule(attr: PunctuatedNestedMeta, module_item: Item) -> Result<To
         context.errors.ok_or_push(r);
     }
 
+    // Detect nested #[pymodule] items (non-sub) and generate submodule init code
+    let mut submodule_inits: Vec<TokenStream> = Vec::new();
+    for item in items.iter() {
+        if let Item::Mod(item_mod) = item {
+            let r = (|| -> Result<()> {
+                let attr = match item_mod
+                    .attrs
+                    .iter()
+                    .find(|a| a.path().is_ident("pymodule"))
+                {
+                    Some(attr) => attr,
+                    None => return Ok(()),
+                };
+                let args_tokens = match &attr.meta {
+                    syn::Meta::Path(_) => TokenStream::new(),
+                    syn::Meta::List(list) => list.tokens.clone(),
+                    _ => return Ok(()),
+                };
+                let mod_args: PyModuleArgs = syn::parse2(args_tokens)?;
+                let fake_ident = Ident::new("pymodule", attr.span());
+                let mod_meta = ModuleItemMeta::from_nested(
+                    item_mod.ident.clone(),
+                    fake_ident,
+                    mod_args.metas.into_iter(),
+                )?;
+                if mod_meta.sub()? {
+                    return Ok(());
+                }
+                let py_name = mod_meta.simple_name()?;
+                let mod_ident = &item_mod.ident;
+                let cfgs: Vec<_> = item_mod
+                    .attrs
+                    .iter()
+                    .filter(|a| a.path().is_ident("cfg"))
+                    .cloned()
+                    .collect();
+                submodule_inits.push(quote! {
+                    #(#cfgs)*
+                    {
+                        let child_def = #mod_ident::module_def(ctx);
+                        let child = child_def.create_module(vm).expect("submodule create_module failed");
+                        child.__init_methods(vm).expect("submodule __init_methods failed");
+                        #mod_ident::module_exec(vm, &child).expect("submodule module_exec failed");
+                        let child: ::rustpython_vm::PyObjectRef = child.into();
+                        vm.__module_set_attr(module, ctx.intern_str(#py_name), child).expect("module set_attr submodule failed");
+                    }
+                });
+                Ok(())
+            })();
+            context.errors.ok_or_push(r);
+        }
+    }
+
     // append additional items
     let module_name = context.name.as_str();
     let function_items = context.function_items.validate()?;
@@ -119,7 +258,6 @@ pub fn impl_pymodule(attr: PunctuatedNestedMeta, module_item: Item) -> Result<To
         quote!(None)
     };
     let is_submodule = module_meta.sub()?;
-    let withs = module_meta.with()?;
     if !is_submodule {
         items.extend([
             parse_quote! {
@@ -154,16 +292,66 @@ pub fn impl_pymodule(attr: PunctuatedNestedMeta, module_item: Item) -> Result<To
             }
         });
     }
-    let method_defs = if withs.is_empty() {
+    // Split with_items into unconditional and cfg-gated groups
+    let (uncond_withs, cond_withs): (Vec<_>, Vec<_>) =
+        with_items.iter().partition(|w| w.cfg_attrs.is_empty());
+    let uncond_paths: Vec<_> = uncond_withs.iter().map(|w| &w.path).collect();
+
+    let method_defs = if with_items.is_empty() {
         quote!(#function_items)
     } else {
+        // For cfg-gated with items, generate conditional const declarations
+        // so the total array size adapts to the cfg at compile time
+        let cond_const_names: Vec<_> = cond_withs
+            .iter()
+            .enumerate()
+            .map(|(i, _)| format_ident!("__WITH_METHODS_{}", i))
+            .collect();
+        let cond_const_decls: Vec<_> = cond_withs
+            .iter()
+            .zip(&cond_const_names)
+            .map(|(w, name)| {
+                let cfg_attrs = &w.cfg_attrs;
+                let neg_attrs = negate_cfg_attrs(&w.cfg_attrs);
+                let path = &w.path;
+                quote! {
+                    #(#cfg_attrs)*
+                    const #name: &'static [::rustpython_vm::function::PyMethodDef] = super::#path::METHOD_DEFS;
+                    #(#neg_attrs)*
+                    const #name: &'static [::rustpython_vm::function::PyMethodDef] = &[];
+                }
+            })
+            .collect();
+
         quote!({
             const OWN_METHODS: &'static [::rustpython_vm::function::PyMethodDef] = &#function_items;
+            #(#cond_const_decls)*
             rustpython_vm::function::PyMethodDef::__const_concat_arrays::<
-                { OWN_METHODS.len() #(+ super::#withs::METHOD_DEFS.len())* },
-            >(&[#(super::#withs::METHOD_DEFS,)* OWN_METHODS])
+                { OWN_METHODS.len()
+                    #(+ super::#uncond_paths::METHOD_DEFS.len())*
+                    #(+ #cond_const_names.len())*
+                },
+            >(&[
+                #(super::#uncond_paths::METHOD_DEFS,)*
+                #(#cond_const_names,)*
+                OWN_METHODS
+            ])
         })
     };
+
+    // Generate __init_attributes calls, wrapping cfg-gated items
+    let init_with_calls: Vec<_> = with_items
+        .iter()
+        .map(|w| {
+            let cfg_attrs = &w.cfg_attrs;
+            let path = &w.path;
+            quote! {
+                #(#cfg_attrs)*
+                super::#path::__init_attributes(vm, module);
+            }
+        })
+        .collect();
+
     items.extend([
         parse_quote! {
             ::rustpython_vm::common::static_cell! {
@@ -178,11 +366,10 @@ pub fn impl_pymodule(attr: PunctuatedNestedMeta, module_item: Item) -> Result<To
                 vm: &::rustpython_vm::VirtualMachine,
                 module: &::rustpython_vm::Py<::rustpython_vm::builtins::PyModule>,
             ) {
-                #(
-                    super::#withs::__init_attributes(vm, module);
-                )*
+                #(#init_with_calls)*
                 let ctx = &vm.ctx;
                 #attribute_items
+                #(#submodule_inits)*
             }
         },
         parse_quote! {
@@ -338,6 +525,7 @@ struct FunctionNurseryItem {
     cfgs: Vec<Attribute>,
     ident: Ident,
     doc: String,
+    call_flags: TokenStream,
 }
 
 impl FunctionNursery {
@@ -363,7 +551,6 @@ struct ValidatedFunctionNursery(FunctionNursery);
 impl ToTokens for ValidatedFunctionNursery {
     fn to_tokens(&self, tokens: &mut TokenStream) {
         let mut inner_tokens = TokenStream::new();
-        let flags = quote! { rustpython_vm::function::PyMethodFlags::empty() };
         for item in &self.0.items {
             let ident = &item.ident;
             let cfgs = &item.cfgs;
@@ -371,6 +558,7 @@ impl ToTokens for ValidatedFunctionNursery {
             let py_names = &item.py_names;
             let doc = &item.doc;
             let doc = quote!(Some(#doc));
+            let flags = &item.call_flags;
 
             inner_tokens.extend(quote![
                 #(
@@ -519,12 +707,14 @@ impl ModuleItem for FunctionItem {
                 py_names
             }
         };
+        let call_flags = infer_native_call_flags(func.sig(), 0);
 
         args.context.function_items.add_item(FunctionNurseryItem {
             ident: ident.to_owned(),
             py_names,
             cfgs: args.cfgs.to_vec(),
             doc,
+            call_flags,
         });
         Ok(())
     }
@@ -566,8 +756,19 @@ impl ModuleItem for ClassItem {
                 class_meta.class_name()?
             };
             let class_new = quote_spanned!(ident.span() =>
-                let new_class = <#ident as ::rustpython_vm::class::PyClassImpl>::make_class(ctx);
-                new_class.set_attr(rustpython_vm::identifier!(ctx, __module__), vm.new_pyobj(#module_name));
+                let new_class = <#ident as ::rustpython_vm::class::PyClassImpl>::make_static_type();
+                // Only set __module__ string if the class doesn't already have a
+                // getset descriptor for __module__ (which provides instance-level
+                // module resolution, e.g. TypeAliasType)
+                {
+                    let module_key = rustpython_vm::identifier!(ctx, __module__);
+                    let has_module_getset = new_class.attributes.read()
+                        .get(module_key)
+                        .is_some_and(|v| v.downcastable::<rustpython_vm::builtins::PyGetSet>());
+                    if !has_module_getset {
+                        new_class.set_attr(module_key, vm.new_pyobj(#module_name));
+                    }
+                }
             );
             (class_name, class_new)
         };
@@ -639,13 +840,29 @@ impl ModuleItem for StructSequenceItem {
                 "#[pystruct_sequence] requires name parameter",
             )
         })?;
-        let module_name = meta.module()?.unwrap_or_else(|| args.context.name.clone());
+        let module_opt = meta.module()?;
+        let has_module = module_opt.is_some();
+        let module_name = module_opt.unwrap_or_else(|| args.context.name.clone());
+        if !has_module {
+            let structseq_attr = &mut args.attrs[self.inner.index];
+            structseq_attr.fill_nested_meta("module", || {
+                parse_quote! {module = #module_name}
+            })?;
+        }
         let no_attr = meta.no_attr()?;
 
         // Generate the class creation code
         let class_new = quote_spanned!(pytype_ident.span() =>
-            let new_class = <#pytype_ident as ::rustpython_vm::class::PyClassImpl>::make_class(ctx);
-            new_class.set_attr(rustpython_vm::identifier!(ctx, __module__), vm.new_pyobj(#module_name));
+            let new_class = <#pytype_ident as ::rustpython_vm::class::PyClassImpl>::make_static_type();
+            {
+                let module_key = rustpython_vm::identifier!(ctx, __module__);
+                let has_module_getset = new_class.attributes.read()
+                    .get(module_key)
+                    .is_some_and(|v| v.downcastable::<rustpython_vm::builtins::PyGetSet>());
+                if !has_module_getset {
+                    new_class.set_attr(module_key, vm.new_pyobj(#module_name));
+                }
+            }
         );
 
         // Handle py_attrs for custom names, or use class_name as default
diff --git a/crates/derive-impl/src/pystructseq.rs b/crates/derive-impl/src/pystructseq.rs
index ccff85fae79..c59a1df2e31 100644
--- a/crates/derive-impl/src/pystructseq.rs
+++ b/crates/derive-impl/src/pystructseq.rs
@@ -299,11 +299,12 @@ pub(crate) fn impl_pystruct_sequence_data(
                     obj: ::rustpython_vm::PyObjectRef,
                 ) -> ::rustpython_vm::PyResult<Self> {
                     let seq: Vec<::rustpython_vm::PyObjectRef> = obj.try_into_value(vm)?;
-                    if seq.len() < #n_required {
+                    if seq.len() != #n_required {
                         return Err(vm.new_type_error(format!(
-                            "{} requires at least {} elements",
+                            "{} requires a {}-sequence ({}-sequence given)",
                             stringify!(#data_ident),
-                            #n_required
+                            #n_required,
+                            seq.len()
                         )));
                     }
                     <Self as ::rustpython_vm::types::PyStructSequenceData>::try_from_elements(seq, vm)
diff --git a/crates/derive-impl/src/util.rs b/crates/derive-impl/src/util.rs
index b09ad9c93fe..068bde9bccd 100644
--- a/crates/derive-impl/src/util.rs
+++ b/crates/derive-impl/src/util.rs
@@ -76,7 +76,7 @@ impl ItemNursery {
 impl ToTokens for ValidatedItemNursery {
     fn to_tokens(&self, tokens: &mut TokenStream) {
         let mut sorted = self.0.0.clone();
-        sorted.sort_by(|a, b| a.sort_order.cmp(&b.sort_order));
+        sorted.sort_by_key(|a| a.sort_order);
         tokens.extend(sorted.iter().map(|item| {
             let cfgs = &item.cfgs;
             let tokens = &item.tokens;
@@ -315,7 +315,7 @@ impl ItemMeta for SimpleItemMeta {
 pub(crate) struct ModuleItemMeta(pub ItemMetaInner);
 
 impl ItemMeta for ModuleItemMeta {
-    const ALLOWED_NAMES: &'static [&'static str] = &["name", "with", "sub"];
+    const ALLOWED_NAMES: &'static [&'static str] = &["name", "sub"];
 
     fn from_inner(inner: ItemMetaInner) -> Self {
         Self(inner)
@@ -330,20 +330,6 @@ impl ModuleItemMeta {
     pub fn sub(&self) -> Result<bool> {
         self.inner()._bool("sub")
     }
-
-    pub fn with(&self) -> Result<Vec<&syn::Path>> {
-        let mut withs = Vec::new();
-        let Some(nested) = self.inner()._optional_list("with")? else {
-            return Ok(withs);
-        };
-        for meta in nested {
-            let NestedMeta::Meta(Meta::Path(path)) = meta else {
-                bail_span!(meta, "#[pymodule(with(...))] arguments should be paths")
-            };
-            withs.push(path);
-        }
-        Ok(withs)
-    }
 }
 
 pub(crate) struct AttrItemMeta(pub ItemMetaInner);
@@ -746,6 +732,77 @@ pub(crate) fn text_signature(sig: &Signature, name: &str) -> String {
     }
 }
 
+pub(crate) fn infer_native_call_flags(sig: &Signature, drop_first_typed: usize) -> TokenStream {
+    // Best-effort mapping of Rust function signatures to CPython-style
+    // METH_* calling convention flags used by CALL specialization.
+    let mut typed_args = Vec::new();
+    for arg in &sig.inputs {
+        let syn::FnArg::Typed(typed) = arg else {
+            continue;
+        };
+        let ty_tokens = &typed.ty;
+        let ty = quote!(#ty_tokens).to_string().replace(' ', "");
+        // `vm: &VirtualMachine` is not a Python-level argument.
+        if ty.starts_with('&') && ty.ends_with("VirtualMachine") {
+            continue;
+        }
+        typed_args.push(ty);
+    }
+
+    let mut user_args = typed_args.into_iter();
+    for _ in 0..drop_first_typed {
+        if user_args.next().is_none() {
+            break;
+        }
+    }
+
+    let mut has_keywords = false;
+    let mut variable_arity = false;
+    let mut fixed_positional = 0usize;
+
+    for ty in user_args {
+        let is_named = |name: &str| {
+            ty == name
+                || ty.starts_with(&format!("{name}<"))
+                || ty.contains(&format!("::{name}<"))
+                || ty.ends_with(&format!("::{name}"))
+        };
+
+        if is_named("FuncArgs") {
+            has_keywords = true;
+            variable_arity = true;
+            continue;
+        }
+        if is_named("KwArgs") {
+            has_keywords = true;
+            variable_arity = true;
+            continue;
+        }
+        if is_named("PosArgs") || is_named("OptionalArg") || is_named("OptionalOption") {
+            variable_arity = true;
+            continue;
+        }
+        fixed_positional += 1;
+    }
+
+    if has_keywords {
+        quote! {
+            rustpython_vm::function::PyMethodFlags::from_bits_retain(
+                rustpython_vm::function::PyMethodFlags::FASTCALL.bits()
+                    | rustpython_vm::function::PyMethodFlags::KEYWORDS.bits()
+            )
+        }
+    } else if variable_arity {
+        quote! { rustpython_vm::function::PyMethodFlags::FASTCALL }
+    } else {
+        match fixed_positional {
+            0 => quote! { rustpython_vm::function::PyMethodFlags::NOARGS },
+            1 => quote! { rustpython_vm::function::PyMethodFlags::O },
+            _ => quote! { rustpython_vm::function::PyMethodFlags::FASTCALL },
+        }
+    }
+}
+
 fn func_sig(sig: &Signature) -> String {
     sig.inputs
         .iter()
diff --git a/crates/derive/src/lib.rs b/crates/derive/src/lib.rs
index 1183b75b714..224aad4ea3c 100644
--- a/crates/derive/src/lib.rs
+++ b/crates/derive/src/lib.rs
@@ -209,7 +209,7 @@ pub fn pyexception(attr: TokenStream, item: TokenStream) -> TokenStream {
 /// - `name`: the name of the function in Python, by default it is the same as the associated Rust function.
 #[proc_macro_attribute]
 pub fn pymodule(attr: TokenStream, item: TokenStream) -> TokenStream {
-    let attr = parse_macro_input!(attr with Punctuated::parse_terminated);
+    let attr = parse_macro_input!(attr as derive_impl::PyModuleArgs);
     let item = parse_macro_input!(item);
     derive_impl::pymodule(attr, item).into()
 }
diff --git a/crates/doc/Cargo.toml b/crates/doc/Cargo.toml
index 3435fabc8b5..a053f9a6383 100644
--- a/crates/doc/Cargo.toml
+++ b/crates/doc/Cargo.toml
@@ -1,5 +1,6 @@
 [package]
 name = "rustpython-doc"
+description = "Python __doc__ database for RustPython"
 version.workspace = true
 authors.workspace = true
 edition.workspace = true
diff --git a/crates/doc/generate.py b/crates/doc/generate.py
index 73cb462bb9f..189e69705e1 100644
--- a/crates/doc/generate.py
+++ b/crates/doc/generate.py
@@ -49,7 +49,7 @@ def key(self) -> str:
     def doc(self) -> str:
         assert self.raw_doc is not None
 
-        return re.sub(UNICODE_ESCAPE, r"\\u{\1}", inspect.cleandoc(self.raw_doc))
+        return re.sub(UNICODE_ESCAPE, r"\\u{\1}", self.raw_doc.strip())
 
 
 def is_c_extension(module: types.ModuleType) -> bool:
@@ -90,7 +90,15 @@ def is_child_of(obj: typing.Any, module: types.ModuleType) -> bool:
     -------
     bool
     """
-    return inspect.getmodule(obj) is module
+    if inspect.getmodule(obj) is module:
+        return True
+    # Some C modules (e.g. _ast) set __module__ to a different name (e.g. "ast"),
+    # causing inspect.getmodule() to return a different module object.
+    # Fall back to checking the module's namespace directly.
+    obj_name = getattr(obj, "__name__", None)
+    if obj_name is not None:
+        return module.__dict__.get(obj_name) is obj
+    return False
 
 
 def iter_modules() -> "Iterable[types.ModuleType]":
diff --git a/crates/doc/src/data.inc.rs b/crates/doc/src/data.inc.rs
index 4411587ca8b..d347962ae59 100644
--- a/crates/doc/src/data.inc.rs
+++ b/crates/doc/src/data.inc.rs
@@ -1,5 +1,5 @@
 // This file was auto-generated by `.github/workflows/update-doc-db.yml`.
-// CPython version: 3.13.9
+// CPython version: 3.14.3
 // spell-checker: disable
 
 pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
@@ -12,8 +12,2905 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "_abc._reset_caches" => "Internal ABC helper to reset both caches of a given class.\n\nShould be only used by refleak.py",
     "_abc._reset_registry" => "Internal ABC helper to reset registry of a given class.\n\nShould be only used by refleak.py",
     "_abc.get_cache_token" => "Returns the current ABC cache token.\n\nThe token is an opaque object (supporting equality testing) identifying the\ncurrent version of the ABC cache for virtual subclasses. The token changes\nwith every call to register() on any ABC.",
+    "_ast.AST.__delattr__" => "Implement delattr(self, name).",
+    "_ast.AST.__eq__" => "Return self==value.",
+    "_ast.AST.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_ast.AST.__ge__" => "Return self>=value.",
+    "_ast.AST.__getattribute__" => "Return getattr(self, name).",
+    "_ast.AST.__getstate__" => "Helper for pickle.",
+    "_ast.AST.__gt__" => "Return self>value.",
+    "_ast.AST.__hash__" => "Return hash(self).",
+    "_ast.AST.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_ast.AST.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_ast.AST.__le__" => "Return self<=value.",
+    "_ast.AST.__lt__" => "Return self<value.",
+    "_ast.AST.__ne__" => "Return self!=value.",
+    "_ast.AST.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_ast.AST.__reduce_ex__" => "Helper for pickle.",
+    "_ast.AST.__replace__" => "Return a copy of the AST node with new values for the specified fields.",
+    "_ast.AST.__repr__" => "Return repr(self).",
+    "_ast.AST.__setattr__" => "Implement setattr(self, name, value).",
+    "_ast.AST.__sizeof__" => "Size of object in memory, in bytes.",
+    "_ast.AST.__str__" => "Return str(self).",
+    "_ast.AST.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_ast.Add" => "Add",
+    "_ast.Add.__delattr__" => "Implement delattr(self, name).",
+    "_ast.Add.__eq__" => "Return self==value.",
+    "_ast.Add.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_ast.Add.__ge__" => "Return self>=value.",
+    "_ast.Add.__getattribute__" => "Return getattr(self, name).",
+    "_ast.Add.__getstate__" => "Helper for pickle.",
+    "_ast.Add.__gt__" => "Return self>value.",
+    "_ast.Add.__hash__" => "Return hash(self).",
+    "_ast.Add.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_ast.Add.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_ast.Add.__le__" => "Return self<=value.",
+    "_ast.Add.__lt__" => "Return self<value.",
+    "_ast.Add.__ne__" => "Return self!=value.",
+    "_ast.Add.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_ast.Add.__reduce_ex__" => "Helper for pickle.",
+    "_ast.Add.__replace__" => "Return a copy of the AST node with new values for the specified fields.",
+    "_ast.Add.__repr__" => "Return repr(self).",
+    "_ast.Add.__setattr__" => "Implement setattr(self, name, value).",
+    "_ast.Add.__sizeof__" => "Size of object in memory, in bytes.",
+    "_ast.Add.__str__" => "Return str(self).",
+    "_ast.Add.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_ast.Add.__weakref__" => "list of weak references to the object",
+    "_ast.And" => "And",
+    "_ast.And.__delattr__" => "Implement delattr(self, name).",
+    "_ast.And.__eq__" => "Return self==value.",
+    "_ast.And.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_ast.And.__ge__" => "Return self>=value.",
+    "_ast.And.__getattribute__" => "Return getattr(self, name).",
+    "_ast.And.__getstate__" => "Helper for pickle.",
+    "_ast.And.__gt__" => "Return self>value.",
+    "_ast.And.__hash__" => "Return hash(self).",
+    "_ast.And.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_ast.And.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_ast.And.__le__" => "Return self<=value.",
+    "_ast.And.__lt__" => "Return self<value.",
+    "_ast.And.__ne__" => "Return self!=value.",
+    "_ast.And.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_ast.And.__reduce_ex__" => "Helper for pickle.",
+    "_ast.And.__replace__" => "Return a copy of the AST node with new values for the specified fields.",
+    "_ast.And.__repr__" => "Return repr(self).",
+    "_ast.And.__setattr__" => "Implement setattr(self, name, value).",
+    "_ast.And.__sizeof__" => "Size of object in memory, in bytes.",
+    "_ast.And.__str__" => "Return str(self).",
+    "_ast.And.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_ast.And.__weakref__" => "list of weak references to the object",
+    "_ast.AnnAssign" => "AnnAssign(expr target, expr annotation, expr? value, int simple)",
+    "_ast.AnnAssign.__delattr__" => "Implement delattr(self, name).",
+    "_ast.AnnAssign.__eq__" => "Return self==value.",
+    "_ast.AnnAssign.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_ast.AnnAssign.__ge__" => "Return self>=value.",
+    "_ast.AnnAssign.__getattribute__" => "Return getattr(self, name).",
+    "_ast.AnnAssign.__getstate__" => "Helper for pickle.",
+    "_ast.AnnAssign.__gt__" => "Return self>value.",
+    "_ast.AnnAssign.__hash__" => "Return hash(self).",
+    "_ast.AnnAssign.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_ast.AnnAssign.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_ast.AnnAssign.__le__" => "Return self<=value.",
+    "_ast.AnnAssign.__lt__" => "Return self<value.",
+    "_ast.AnnAssign.__ne__" => "Return self!=value.",
+    "_ast.AnnAssign.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_ast.AnnAssign.__reduce_ex__" => "Helper for pickle.",
+    "_ast.AnnAssign.__replace__" => "Return a copy of the AST node with new values for the specified fields.",
+    "_ast.AnnAssign.__repr__" => "Return repr(self).",
+    "_ast.AnnAssign.__setattr__" => "Implement setattr(self, name, value).",
+    "_ast.AnnAssign.__sizeof__" => "Size of object in memory, in bytes.",
+    "_ast.AnnAssign.__str__" => "Return str(self).",
+    "_ast.AnnAssign.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_ast.AnnAssign.__weakref__" => "list of weak references to the object",
+    "_ast.Assert" => "Assert(expr test, expr? msg)",
+    "_ast.Assert.__delattr__" => "Implement delattr(self, name).",
+    "_ast.Assert.__eq__" => "Return self==value.",
+    "_ast.Assert.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_ast.Assert.__ge__" => "Return self>=value.",
+    "_ast.Assert.__getattribute__" => "Return getattr(self, name).",
+    "_ast.Assert.__getstate__" => "Helper for pickle.",
+    "_ast.Assert.__gt__" => "Return self>value.",
+    "_ast.Assert.__hash__" => "Return hash(self).",
+    "_ast.Assert.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_ast.Assert.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_ast.Assert.__le__" => "Return self<=value.",
+    "_ast.Assert.__lt__" => "Return self<value.",
+    "_ast.Assert.__ne__" => "Return self!=value.",
+    "_ast.Assert.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_ast.Assert.__reduce_ex__" => "Helper for pickle.",
+    "_ast.Assert.__replace__" => "Return a copy of the AST node with new values for the specified fields.",
+    "_ast.Assert.__repr__" => "Return repr(self).",
+    "_ast.Assert.__setattr__" => "Implement setattr(self, name, value).",
+    "_ast.Assert.__sizeof__" => "Size of object in memory, in bytes.",
+    "_ast.Assert.__str__" => "Return str(self).",
+    "_ast.Assert.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_ast.Assert.__weakref__" => "list of weak references to the object",
+    "_ast.Assign" => "Assign(expr* targets, expr value, string? type_comment)",
+    "_ast.Assign.__delattr__" => "Implement delattr(self, name).",
+    "_ast.Assign.__eq__" => "Return self==value.",
+    "_ast.Assign.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_ast.Assign.__ge__" => "Return self>=value.",
+    "_ast.Assign.__getattribute__" => "Return getattr(self, name).",
+    "_ast.Assign.__getstate__" => "Helper for pickle.",
+    "_ast.Assign.__gt__" => "Return self>value.",
+    "_ast.Assign.__hash__" => "Return hash(self).",
+    "_ast.Assign.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_ast.Assign.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_ast.Assign.__le__" => "Return self<=value.",
+    "_ast.Assign.__lt__" => "Return self<value.",
+    "_ast.Assign.__ne__" => "Return self!=value.",
+    "_ast.Assign.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_ast.Assign.__reduce_ex__" => "Helper for pickle.",
+    "_ast.Assign.__replace__" => "Return a copy of the AST node with new values for the specified fields.",
+    "_ast.Assign.__repr__" => "Return repr(self).",
+    "_ast.Assign.__setattr__" => "Implement setattr(self, name, value).",
+    "_ast.Assign.__sizeof__" => "Size of object in memory, in bytes.",
+    "_ast.Assign.__str__" => "Return str(self).",
+    "_ast.Assign.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_ast.Assign.__weakref__" => "list of weak references to the object",
+    "_ast.AsyncFor" => "AsyncFor(expr target, expr iter, stmt* body, stmt* orelse, string? type_comment)",
+    "_ast.AsyncFor.__delattr__" => "Implement delattr(self, name).",
+    "_ast.AsyncFor.__eq__" => "Return self==value.",
+    "_ast.AsyncFor.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_ast.AsyncFor.__ge__" => "Return self>=value.",
+    "_ast.AsyncFor.__getattribute__" => "Return getattr(self, name).",
+    "_ast.AsyncFor.__getstate__" => "Helper for pickle.",
+    "_ast.AsyncFor.__gt__" => "Return self>value.",
+    "_ast.AsyncFor.__hash__" => "Return hash(self).",
+    "_ast.AsyncFor.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_ast.AsyncFor.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_ast.AsyncFor.__le__" => "Return self<=value.",
+    "_ast.AsyncFor.__lt__" => "Return self<value.",
+    "_ast.AsyncFor.__ne__" => "Return self!=value.",
+    "_ast.AsyncFor.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_ast.AsyncFor.__reduce_ex__" => "Helper for pickle.",
+    "_ast.AsyncFor.__replace__" => "Return a copy of the AST node with new values for the specified fields.",
+    "_ast.AsyncFor.__repr__" => "Return repr(self).",
+    "_ast.AsyncFor.__setattr__" => "Implement setattr(self, name, value).",
+    "_ast.AsyncFor.__sizeof__" => "Size of object in memory, in bytes.",
+    "_ast.AsyncFor.__str__" => "Return str(self).",
+    "_ast.AsyncFor.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_ast.AsyncFor.__weakref__" => "list of weak references to the object",
+    "_ast.AsyncFunctionDef" => "AsyncFunctionDef(identifier name, arguments args, stmt* body, expr* decorator_list, expr? returns, string? type_comment, type_param* type_params)",
+    "_ast.AsyncFunctionDef.__delattr__" => "Implement delattr(self, name).",
+    "_ast.AsyncFunctionDef.__eq__" => "Return self==value.",
+    "_ast.AsyncFunctionDef.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_ast.AsyncFunctionDef.__ge__" => "Return self>=value.",
+    "_ast.AsyncFunctionDef.__getattribute__" => "Return getattr(self, name).",
+    "_ast.AsyncFunctionDef.__getstate__" => "Helper for pickle.",
+    "_ast.AsyncFunctionDef.__gt__" => "Return self>value.",
+    "_ast.AsyncFunctionDef.__hash__" => "Return hash(self).",
+    "_ast.AsyncFunctionDef.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_ast.AsyncFunctionDef.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_ast.AsyncFunctionDef.__le__" => "Return self<=value.",
+    "_ast.AsyncFunctionDef.__lt__" => "Return self<value.",
+    "_ast.AsyncFunctionDef.__ne__" => "Return self!=value.",
+    "_ast.AsyncFunctionDef.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_ast.AsyncFunctionDef.__reduce_ex__" => "Helper for pickle.",
+    "_ast.AsyncFunctionDef.__replace__" => "Return a copy of the AST node with new values for the specified fields.",
+    "_ast.AsyncFunctionDef.__repr__" => "Return repr(self).",
+    "_ast.AsyncFunctionDef.__setattr__" => "Implement setattr(self, name, value).",
+    "_ast.AsyncFunctionDef.__sizeof__" => "Size of object in memory, in bytes.",
+    "_ast.AsyncFunctionDef.__str__" => "Return str(self).",
+    "_ast.AsyncFunctionDef.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_ast.AsyncFunctionDef.__weakref__" => "list of weak references to the object",
+    "_ast.AsyncWith" => "AsyncWith(withitem* items, stmt* body, string? type_comment)",
+    "_ast.AsyncWith.__delattr__" => "Implement delattr(self, name).",
+    "_ast.AsyncWith.__eq__" => "Return self==value.",
+    "_ast.AsyncWith.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_ast.AsyncWith.__ge__" => "Return self>=value.",
+    "_ast.AsyncWith.__getattribute__" => "Return getattr(self, name).",
+    "_ast.AsyncWith.__getstate__" => "Helper for pickle.",
+    "_ast.AsyncWith.__gt__" => "Return self>value.",
+    "_ast.AsyncWith.__hash__" => "Return hash(self).",
+    "_ast.AsyncWith.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_ast.AsyncWith.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_ast.AsyncWith.__le__" => "Return self<=value.",
+    "_ast.AsyncWith.__lt__" => "Return self<value.",
+    "_ast.AsyncWith.__ne__" => "Return self!=value.",
+    "_ast.AsyncWith.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_ast.AsyncWith.__reduce_ex__" => "Helper for pickle.",
+    "_ast.AsyncWith.__replace__" => "Return a copy of the AST node with new values for the specified fields.",
+    "_ast.AsyncWith.__repr__" => "Return repr(self).",
+    "_ast.AsyncWith.__setattr__" => "Implement setattr(self, name, value).",
+    "_ast.AsyncWith.__sizeof__" => "Size of object in memory, in bytes.",
+    "_ast.AsyncWith.__str__" => "Return str(self).",
+    "_ast.AsyncWith.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_ast.AsyncWith.__weakref__" => "list of weak references to the object",
+    "_ast.Attribute" => "Attribute(expr value, identifier attr, expr_context ctx)",
+    "_ast.Attribute.__delattr__" => "Implement delattr(self, name).",
+    "_ast.Attribute.__eq__" => "Return self==value.",
+    "_ast.Attribute.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_ast.Attribute.__ge__" => "Return self>=value.",
+    "_ast.Attribute.__getattribute__" => "Return getattr(self, name).",
+    "_ast.Attribute.__getstate__" => "Helper for pickle.",
+    "_ast.Attribute.__gt__" => "Return self>value.",
+    "_ast.Attribute.__hash__" => "Return hash(self).",
+    "_ast.Attribute.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_ast.Attribute.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_ast.Attribute.__le__" => "Return self<=value.",
+    "_ast.Attribute.__lt__" => "Return self<value.",
+    "_ast.Attribute.__ne__" => "Return self!=value.",
+    "_ast.Attribute.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_ast.Attribute.__reduce_ex__" => "Helper for pickle.",
+    "_ast.Attribute.__replace__" => "Return a copy of the AST node with new values for the specified fields.",
+    "_ast.Attribute.__repr__" => "Return repr(self).",
+    "_ast.Attribute.__setattr__" => "Implement setattr(self, name, value).",
+    "_ast.Attribute.__sizeof__" => "Size of object in memory, in bytes.",
+    "_ast.Attribute.__str__" => "Return str(self).",
+    "_ast.Attribute.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_ast.Attribute.__weakref__" => "list of weak references to the object",
+    "_ast.AugAssign" => "AugAssign(expr target, operator op, expr value)",
+    "_ast.AugAssign.__delattr__" => "Implement delattr(self, name).",
+    "_ast.AugAssign.__eq__" => "Return self==value.",
+    "_ast.AugAssign.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_ast.AugAssign.__ge__" => "Return self>=value.",
+    "_ast.AugAssign.__getattribute__" => "Return getattr(self, name).",
+    "_ast.AugAssign.__getstate__" => "Helper for pickle.",
+    "_ast.AugAssign.__gt__" => "Return self>value.",
+    "_ast.AugAssign.__hash__" => "Return hash(self).",
+    "_ast.AugAssign.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_ast.AugAssign.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_ast.AugAssign.__le__" => "Return self<=value.",
+    "_ast.AugAssign.__lt__" => "Return self<value.",
+    "_ast.AugAssign.__ne__" => "Return self!=value.",
+    "_ast.AugAssign.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_ast.AugAssign.__reduce_ex__" => "Helper for pickle.",
+    "_ast.AugAssign.__replace__" => "Return a copy of the AST node with new values for the specified fields.",
+    "_ast.AugAssign.__repr__" => "Return repr(self).",
+    "_ast.AugAssign.__setattr__" => "Implement setattr(self, name, value).",
+    "_ast.AugAssign.__sizeof__" => "Size of object in memory, in bytes.",
+    "_ast.AugAssign.__str__" => "Return str(self).",
+    "_ast.AugAssign.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_ast.AugAssign.__weakref__" => "list of weak references to the object",
+    "_ast.Await" => "Await(expr value)",
+    "_ast.Await.__delattr__" => "Implement delattr(self, name).",
+    "_ast.Await.__eq__" => "Return self==value.",
+    "_ast.Await.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_ast.Await.__ge__" => "Return self>=value.",
+    "_ast.Await.__getattribute__" => "Return getattr(self, name).",
+    "_ast.Await.__getstate__" => "Helper for pickle.",
+    "_ast.Await.__gt__" => "Return self>value.",
+    "_ast.Await.__hash__" => "Return hash(self).",
+    "_ast.Await.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_ast.Await.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_ast.Await.__le__" => "Return self<=value.",
+    "_ast.Await.__lt__" => "Return self<value.",
+    "_ast.Await.__ne__" => "Return self!=value.",
+    "_ast.Await.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_ast.Await.__reduce_ex__" => "Helper for pickle.",
+    "_ast.Await.__replace__" => "Return a copy of the AST node with new values for the specified fields.",
+    "_ast.Await.__repr__" => "Return repr(self).",
+    "_ast.Await.__setattr__" => "Implement setattr(self, name, value).",
+    "_ast.Await.__sizeof__" => "Size of object in memory, in bytes.",
+    "_ast.Await.__str__" => "Return str(self).",
+    "_ast.Await.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_ast.Await.__weakref__" => "list of weak references to the object",
+    "_ast.BinOp" => "BinOp(expr left, operator op, expr right)",
+    "_ast.BinOp.__delattr__" => "Implement delattr(self, name).",
+    "_ast.BinOp.__eq__" => "Return self==value.",
+    "_ast.BinOp.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_ast.BinOp.__ge__" => "Return self>=value.",
+    "_ast.BinOp.__getattribute__" => "Return getattr(self, name).",
+    "_ast.BinOp.__getstate__" => "Helper for pickle.",
+    "_ast.BinOp.__gt__" => "Return self>value.",
+    "_ast.BinOp.__hash__" => "Return hash(self).",
+    "_ast.BinOp.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_ast.BinOp.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_ast.BinOp.__le__" => "Return self<=value.",
+    "_ast.BinOp.__lt__" => "Return self<value.",
+    "_ast.BinOp.__ne__" => "Return self!=value.",
+    "_ast.BinOp.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_ast.BinOp.__reduce_ex__" => "Helper for pickle.",
+    "_ast.BinOp.__replace__" => "Return a copy of the AST node with new values for the specified fields.",
+    "_ast.BinOp.__repr__" => "Return repr(self).",
+    "_ast.BinOp.__setattr__" => "Implement setattr(self, name, value).",
+    "_ast.BinOp.__sizeof__" => "Size of object in memory, in bytes.",
+    "_ast.BinOp.__str__" => "Return str(self).",
+    "_ast.BinOp.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_ast.BinOp.__weakref__" => "list of weak references to the object",
+    "_ast.BitAnd" => "BitAnd",
+    "_ast.BitAnd.__delattr__" => "Implement delattr(self, name).",
+    "_ast.BitAnd.__eq__" => "Return self==value.",
+    "_ast.BitAnd.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_ast.BitAnd.__ge__" => "Return self>=value.",
+    "_ast.BitAnd.__getattribute__" => "Return getattr(self, name).",
+    "_ast.BitAnd.__getstate__" => "Helper for pickle.",
+    "_ast.BitAnd.__gt__" => "Return self>value.",
+    "_ast.BitAnd.__hash__" => "Return hash(self).",
+    "_ast.BitAnd.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_ast.BitAnd.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_ast.BitAnd.__le__" => "Return self<=value.",
+    "_ast.BitAnd.__lt__" => "Return self<value.",
+    "_ast.BitAnd.__ne__" => "Return self!=value.",
+    "_ast.BitAnd.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_ast.BitAnd.__reduce_ex__" => "Helper for pickle.",
+    "_ast.BitAnd.__replace__" => "Return a copy of the AST node with new values for the specified fields.",
+    "_ast.BitAnd.__repr__" => "Return repr(self).",
+    "_ast.BitAnd.__setattr__" => "Implement setattr(self, name, value).",
+    "_ast.BitAnd.__sizeof__" => "Size of object in memory, in bytes.",
+    "_ast.BitAnd.__str__" => "Return str(self).",
+    "_ast.BitAnd.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_ast.BitAnd.__weakref__" => "list of weak references to the object",
+    "_ast.BitOr" => "BitOr",
+    "_ast.BitOr.__delattr__" => "Implement delattr(self, name).",
+    "_ast.BitOr.__eq__" => "Return self==value.",
+    "_ast.BitOr.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_ast.BitOr.__ge__" => "Return self>=value.",
+    "_ast.BitOr.__getattribute__" => "Return getattr(self, name).",
+    "_ast.BitOr.__getstate__" => "Helper for pickle.",
+    "_ast.BitOr.__gt__" => "Return self>value.",
+    "_ast.BitOr.__hash__" => "Return hash(self).",
+    "_ast.BitOr.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_ast.BitOr.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_ast.BitOr.__le__" => "Return self<=value.",
+    "_ast.BitOr.__lt__" => "Return self<value.",
+    "_ast.BitOr.__ne__" => "Return self!=value.",
+    "_ast.BitOr.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_ast.BitOr.__reduce_ex__" => "Helper for pickle.",
+    "_ast.BitOr.__replace__" => "Return a copy of the AST node with new values for the specified fields.",
+    "_ast.BitOr.__repr__" => "Return repr(self).",
+    "_ast.BitOr.__setattr__" => "Implement setattr(self, name, value).",
+    "_ast.BitOr.__sizeof__" => "Size of object in memory, in bytes.",
+    "_ast.BitOr.__str__" => "Return str(self).",
+    "_ast.BitOr.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_ast.BitOr.__weakref__" => "list of weak references to the object",
+    "_ast.BitXor" => "BitXor",
+    "_ast.BitXor.__delattr__" => "Implement delattr(self, name).",
+    "_ast.BitXor.__eq__" => "Return self==value.",
+    "_ast.BitXor.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_ast.BitXor.__ge__" => "Return self>=value.",
+    "_ast.BitXor.__getattribute__" => "Return getattr(self, name).",
+    "_ast.BitXor.__getstate__" => "Helper for pickle.",
+    "_ast.BitXor.__gt__" => "Return self>value.",
+    "_ast.BitXor.__hash__" => "Return hash(self).",
+    "_ast.BitXor.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_ast.BitXor.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_ast.BitXor.__le__" => "Return self<=value.",
+    "_ast.BitXor.__lt__" => "Return self<value.",
+    "_ast.BitXor.__ne__" => "Return self!=value.",
+    "_ast.BitXor.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_ast.BitXor.__reduce_ex__" => "Helper for pickle.",
+    "_ast.BitXor.__replace__" => "Return a copy of the AST node with new values for the specified fields.",
+    "_ast.BitXor.__repr__" => "Return repr(self).",
+    "_ast.BitXor.__setattr__" => "Implement setattr(self, name, value).",
+    "_ast.BitXor.__sizeof__" => "Size of object in memory, in bytes.",
+    "_ast.BitXor.__str__" => "Return str(self).",
+    "_ast.BitXor.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_ast.BitXor.__weakref__" => "list of weak references to the object",
+    "_ast.BoolOp" => "BoolOp(boolop op, expr* values)",
+    "_ast.BoolOp.__delattr__" => "Implement delattr(self, name).",
+    "_ast.BoolOp.__eq__" => "Return self==value.",
+    "_ast.BoolOp.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_ast.BoolOp.__ge__" => "Return self>=value.",
+    "_ast.BoolOp.__getattribute__" => "Return getattr(self, name).",
+    "_ast.BoolOp.__getstate__" => "Helper for pickle.",
+    "_ast.BoolOp.__gt__" => "Return self>value.",
+    "_ast.BoolOp.__hash__" => "Return hash(self).",
+    "_ast.BoolOp.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_ast.BoolOp.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_ast.BoolOp.__le__" => "Return self<=value.",
+    "_ast.BoolOp.__lt__" => "Return self<value.",
+    "_ast.BoolOp.__ne__" => "Return self!=value.",
+    "_ast.BoolOp.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_ast.BoolOp.__reduce_ex__" => "Helper for pickle.",
+    "_ast.BoolOp.__replace__" => "Return a copy of the AST node with new values for the specified fields.",
+    "_ast.BoolOp.__repr__" => "Return repr(self).",
+    "_ast.BoolOp.__setattr__" => "Implement setattr(self, name, value).",
+    "_ast.BoolOp.__sizeof__" => "Size of object in memory, in bytes.",
+    "_ast.BoolOp.__str__" => "Return str(self).",
+    "_ast.BoolOp.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_ast.BoolOp.__weakref__" => "list of weak references to the object",
+    "_ast.Break" => "Break",
+    "_ast.Break.__delattr__" => "Implement delattr(self, name).",
+    "_ast.Break.__eq__" => "Return self==value.",
+    "_ast.Break.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_ast.Break.__ge__" => "Return self>=value.",
+    "_ast.Break.__getattribute__" => "Return getattr(self, name).",
+    "_ast.Break.__getstate__" => "Helper for pickle.",
+    "_ast.Break.__gt__" => "Return self>value.",
+    "_ast.Break.__hash__" => "Return hash(self).",
+    "_ast.Break.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_ast.Break.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_ast.Break.__le__" => "Return self<=value.",
+    "_ast.Break.__lt__" => "Return self<value.",
+    "_ast.Break.__ne__" => "Return self!=value.",
+    "_ast.Break.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_ast.Break.__reduce_ex__" => "Helper for pickle.",
+    "_ast.Break.__replace__" => "Return a copy of the AST node with new values for the specified fields.",
+    "_ast.Break.__repr__" => "Return repr(self).",
+    "_ast.Break.__setattr__" => "Implement setattr(self, name, value).",
+    "_ast.Break.__sizeof__" => "Size of object in memory, in bytes.",
+    "_ast.Break.__str__" => "Return str(self).",
+    "_ast.Break.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_ast.Break.__weakref__" => "list of weak references to the object",
+    "_ast.Call" => "Call(expr func, expr* args, keyword* keywords)",
+    "_ast.Call.__delattr__" => "Implement delattr(self, name).",
+    "_ast.Call.__eq__" => "Return self==value.",
+    "_ast.Call.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_ast.Call.__ge__" => "Return self>=value.",
+    "_ast.Call.__getattribute__" => "Return getattr(self, name).",
+    "_ast.Call.__getstate__" => "Helper for pickle.",
+    "_ast.Call.__gt__" => "Return self>value.",
+    "_ast.Call.__hash__" => "Return hash(self).",
+    "_ast.Call.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_ast.Call.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_ast.Call.__le__" => "Return self<=value.",
+    "_ast.Call.__lt__" => "Return self<value.",
+    "_ast.Call.__ne__" => "Return self!=value.",
+    "_ast.Call.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_ast.Call.__reduce_ex__" => "Helper for pickle.",
+    "_ast.Call.__replace__" => "Return a copy of the AST node with new values for the specified fields.",
+    "_ast.Call.__repr__" => "Return repr(self).",
+    "_ast.Call.__setattr__" => "Implement setattr(self, name, value).",
+    "_ast.Call.__sizeof__" => "Size of object in memory, in bytes.",
+    "_ast.Call.__str__" => "Return str(self).",
+    "_ast.Call.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_ast.Call.__weakref__" => "list of weak references to the object",
+    "_ast.ClassDef" => "ClassDef(identifier name, expr* bases, keyword* keywords, stmt* body, expr* decorator_list, type_param* type_params)",
+    "_ast.ClassDef.__delattr__" => "Implement delattr(self, name).",
+    "_ast.ClassDef.__eq__" => "Return self==value.",
+    "_ast.ClassDef.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_ast.ClassDef.__ge__" => "Return self>=value.",
+    "_ast.ClassDef.__getattribute__" => "Return getattr(self, name).",
+    "_ast.ClassDef.__getstate__" => "Helper for pickle.",
+    "_ast.ClassDef.__gt__" => "Return self>value.",
+    "_ast.ClassDef.__hash__" => "Return hash(self).",
+    "_ast.ClassDef.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_ast.ClassDef.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_ast.ClassDef.__le__" => "Return self<=value.",
+    "_ast.ClassDef.__lt__" => "Return self<value.",
+    "_ast.ClassDef.__ne__" => "Return self!=value.",
+    "_ast.ClassDef.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_ast.ClassDef.__reduce_ex__" => "Helper for pickle.",
+    "_ast.ClassDef.__replace__" => "Return a copy of the AST node with new values for the specified fields.",
+    "_ast.ClassDef.__repr__" => "Return repr(self).",
+    "_ast.ClassDef.__setattr__" => "Implement setattr(self, name, value).",
+    "_ast.ClassDef.__sizeof__" => "Size of object in memory, in bytes.",
+    "_ast.ClassDef.__str__" => "Return str(self).",
+    "_ast.ClassDef.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_ast.ClassDef.__weakref__" => "list of weak references to the object",
+    "_ast.Compare" => "Compare(expr left, cmpop* ops, expr* comparators)",
+    "_ast.Compare.__delattr__" => "Implement delattr(self, name).",
+    "_ast.Compare.__eq__" => "Return self==value.",
+    "_ast.Compare.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_ast.Compare.__ge__" => "Return self>=value.",
+    "_ast.Compare.__getattribute__" => "Return getattr(self, name).",
+    "_ast.Compare.__getstate__" => "Helper for pickle.",
+    "_ast.Compare.__gt__" => "Return self>value.",
+    "_ast.Compare.__hash__" => "Return hash(self).",
+    "_ast.Compare.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_ast.Compare.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_ast.Compare.__le__" => "Return self<=value.",
+    "_ast.Compare.__lt__" => "Return self<value.",
+    "_ast.Compare.__ne__" => "Return self!=value.",
+    "_ast.Compare.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_ast.Compare.__reduce_ex__" => "Helper for pickle.",
+    "_ast.Compare.__replace__" => "Return a copy of the AST node with new values for the specified fields.",
+    "_ast.Compare.__repr__" => "Return repr(self).",
+    "_ast.Compare.__setattr__" => "Implement setattr(self, name, value).",
+    "_ast.Compare.__sizeof__" => "Size of object in memory, in bytes.",
+    "_ast.Compare.__str__" => "Return str(self).",
+    "_ast.Compare.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_ast.Compare.__weakref__" => "list of weak references to the object",
+    "_ast.Constant" => "Constant(constant value, string? kind)",
+    "_ast.Constant.__delattr__" => "Implement delattr(self, name).",
+    "_ast.Constant.__eq__" => "Return self==value.",
+    "_ast.Constant.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_ast.Constant.__ge__" => "Return self>=value.",
+    "_ast.Constant.__getattribute__" => "Return getattr(self, name).",
+    "_ast.Constant.__getstate__" => "Helper for pickle.",
+    "_ast.Constant.__gt__" => "Return self>value.",
+    "_ast.Constant.__hash__" => "Return hash(self).",
+    "_ast.Constant.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_ast.Constant.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_ast.Constant.__le__" => "Return self<=value.",
+    "_ast.Constant.__lt__" => "Return self<value.",
+    "_ast.Constant.__ne__" => "Return self!=value.",
+    "_ast.Constant.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_ast.Constant.__reduce_ex__" => "Helper for pickle.",
+    "_ast.Constant.__replace__" => "Return a copy of the AST node with new values for the specified fields.",
+    "_ast.Constant.__repr__" => "Return repr(self).",
+    "_ast.Constant.__setattr__" => "Implement setattr(self, name, value).",
+    "_ast.Constant.__sizeof__" => "Size of object in memory, in bytes.",
+    "_ast.Constant.__str__" => "Return str(self).",
+    "_ast.Constant.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_ast.Constant.__weakref__" => "list of weak references to the object",
+    "_ast.Continue" => "Continue",
+    "_ast.Continue.__delattr__" => "Implement delattr(self, name).",
+    "_ast.Continue.__eq__" => "Return self==value.",
+    "_ast.Continue.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_ast.Continue.__ge__" => "Return self>=value.",
+    "_ast.Continue.__getattribute__" => "Return getattr(self, name).",
+    "_ast.Continue.__getstate__" => "Helper for pickle.",
+    "_ast.Continue.__gt__" => "Return self>value.",
+    "_ast.Continue.__hash__" => "Return hash(self).",
+    "_ast.Continue.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_ast.Continue.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_ast.Continue.__le__" => "Return self<=value.",
+    "_ast.Continue.__lt__" => "Return self<value.",
+    "_ast.Continue.__ne__" => "Return self!=value.",
+    "_ast.Continue.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_ast.Continue.__reduce_ex__" => "Helper for pickle.",
+    "_ast.Continue.__replace__" => "Return a copy of the AST node with new values for the specified fields.",
+    "_ast.Continue.__repr__" => "Return repr(self).",
+    "_ast.Continue.__setattr__" => "Implement setattr(self, name, value).",
+    "_ast.Continue.__sizeof__" => "Size of object in memory, in bytes.",
+    "_ast.Continue.__str__" => "Return str(self).",
+    "_ast.Continue.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_ast.Continue.__weakref__" => "list of weak references to the object",
+    "_ast.Del" => "Del",
+    "_ast.Del.__delattr__" => "Implement delattr(self, name).",
+    "_ast.Del.__eq__" => "Return self==value.",
+    "_ast.Del.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_ast.Del.__ge__" => "Return self>=value.",
+    "_ast.Del.__getattribute__" => "Return getattr(self, name).",
+    "_ast.Del.__getstate__" => "Helper for pickle.",
+    "_ast.Del.__gt__" => "Return self>value.",
+    "_ast.Del.__hash__" => "Return hash(self).",
+    "_ast.Del.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_ast.Del.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_ast.Del.__le__" => "Return self<=value.",
+    "_ast.Del.__lt__" => "Return self<value.",
+    "_ast.Del.__ne__" => "Return self!=value.",
+    "_ast.Del.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_ast.Del.__reduce_ex__" => "Helper for pickle.",
+    "_ast.Del.__replace__" => "Return a copy of the AST node with new values for the specified fields.",
+    "_ast.Del.__repr__" => "Return repr(self).",
+    "_ast.Del.__setattr__" => "Implement setattr(self, name, value).",
+    "_ast.Del.__sizeof__" => "Size of object in memory, in bytes.",
+    "_ast.Del.__str__" => "Return str(self).",
+    "_ast.Del.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_ast.Del.__weakref__" => "list of weak references to the object",
+    "_ast.Delete" => "Delete(expr* targets)",
+    "_ast.Delete.__delattr__" => "Implement delattr(self, name).",
+    "_ast.Delete.__eq__" => "Return self==value.",
+    "_ast.Delete.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_ast.Delete.__ge__" => "Return self>=value.",
+    "_ast.Delete.__getattribute__" => "Return getattr(self, name).",
+    "_ast.Delete.__getstate__" => "Helper for pickle.",
+    "_ast.Delete.__gt__" => "Return self>value.",
+    "_ast.Delete.__hash__" => "Return hash(self).",
+    "_ast.Delete.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_ast.Delete.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_ast.Delete.__le__" => "Return self<=value.",
+    "_ast.Delete.__lt__" => "Return self<value.",
+    "_ast.Delete.__ne__" => "Return self!=value.",
+    "_ast.Delete.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_ast.Delete.__reduce_ex__" => "Helper for pickle.",
+    "_ast.Delete.__replace__" => "Return a copy of the AST node with new values for the specified fields.",
+    "_ast.Delete.__repr__" => "Return repr(self).",
+    "_ast.Delete.__setattr__" => "Implement setattr(self, name, value).",
+    "_ast.Delete.__sizeof__" => "Size of object in memory, in bytes.",
+    "_ast.Delete.__str__" => "Return str(self).",
+    "_ast.Delete.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_ast.Delete.__weakref__" => "list of weak references to the object",
+    "_ast.Dict" => "Dict(expr?* keys, expr* values)",
+    "_ast.Dict.__delattr__" => "Implement delattr(self, name).",
+    "_ast.Dict.__eq__" => "Return self==value.",
+    "_ast.Dict.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_ast.Dict.__ge__" => "Return self>=value.",
+    "_ast.Dict.__getattribute__" => "Return getattr(self, name).",
+    "_ast.Dict.__getstate__" => "Helper for pickle.",
+    "_ast.Dict.__gt__" => "Return self>value.",
+    "_ast.Dict.__hash__" => "Return hash(self).",
+    "_ast.Dict.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_ast.Dict.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_ast.Dict.__le__" => "Return self<=value.",
+    "_ast.Dict.__lt__" => "Return self<value.",
+    "_ast.Dict.__ne__" => "Return self!=value.",
+    "_ast.Dict.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_ast.Dict.__reduce_ex__" => "Helper for pickle.",
+    "_ast.Dict.__replace__" => "Return a copy of the AST node with new values for the specified fields.",
+    "_ast.Dict.__repr__" => "Return repr(self).",
+    "_ast.Dict.__setattr__" => "Implement setattr(self, name, value).",
+    "_ast.Dict.__sizeof__" => "Size of object in memory, in bytes.",
+    "_ast.Dict.__str__" => "Return str(self).",
+    "_ast.Dict.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_ast.Dict.__weakref__" => "list of weak references to the object",
+    "_ast.DictComp" => "DictComp(expr key, expr value, comprehension* generators)",
+    "_ast.DictComp.__delattr__" => "Implement delattr(self, name).",
+    "_ast.DictComp.__eq__" => "Return self==value.",
+    "_ast.DictComp.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_ast.DictComp.__ge__" => "Return self>=value.",
+    "_ast.DictComp.__getattribute__" => "Return getattr(self, name).",
+    "_ast.DictComp.__getstate__" => "Helper for pickle.",
+    "_ast.DictComp.__gt__" => "Return self>value.",
+    "_ast.DictComp.__hash__" => "Return hash(self).",
+    "_ast.DictComp.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_ast.DictComp.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_ast.DictComp.__le__" => "Return self<=value.",
+    "_ast.DictComp.__lt__" => "Return self<value.",
+    "_ast.DictComp.__ne__" => "Return self!=value.",
+    "_ast.DictComp.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_ast.DictComp.__reduce_ex__" => "Helper for pickle.",
+    "_ast.DictComp.__replace__" => "Return a copy of the AST node with new values for the specified fields.",
+    "_ast.DictComp.__repr__" => "Return repr(self).",
+    "_ast.DictComp.__setattr__" => "Implement setattr(self, name, value).",
+    "_ast.DictComp.__sizeof__" => "Size of object in memory, in bytes.",
+    "_ast.DictComp.__str__" => "Return str(self).",
+    "_ast.DictComp.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_ast.DictComp.__weakref__" => "list of weak references to the object",
+    "_ast.Div" => "Div",
+    "_ast.Div.__delattr__" => "Implement delattr(self, name).",
+    "_ast.Div.__eq__" => "Return self==value.",
+    "_ast.Div.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_ast.Div.__ge__" => "Return self>=value.",
+    "_ast.Div.__getattribute__" => "Return getattr(self, name).",
+    "_ast.Div.__getstate__" => "Helper for pickle.",
+    "_ast.Div.__gt__" => "Return self>value.",
+    "_ast.Div.__hash__" => "Return hash(self).",
+    "_ast.Div.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_ast.Div.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_ast.Div.__le__" => "Return self<=value.",
+    "_ast.Div.__lt__" => "Return self<value.",
+    "_ast.Div.__ne__" => "Return self!=value.",
+    "_ast.Div.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_ast.Div.__reduce_ex__" => "Helper for pickle.",
+    "_ast.Div.__replace__" => "Return a copy of the AST node with new values for the specified fields.",
+    "_ast.Div.__repr__" => "Return repr(self).",
+    "_ast.Div.__setattr__" => "Implement setattr(self, name, value).",
+    "_ast.Div.__sizeof__" => "Size of object in memory, in bytes.",
+    "_ast.Div.__str__" => "Return str(self).",
+    "_ast.Div.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_ast.Div.__weakref__" => "list of weak references to the object",
+    "_ast.Eq" => "Eq",
+    "_ast.Eq.__delattr__" => "Implement delattr(self, name).",
+    "_ast.Eq.__eq__" => "Return self==value.",
+    "_ast.Eq.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_ast.Eq.__ge__" => "Return self>=value.",
+    "_ast.Eq.__getattribute__" => "Return getattr(self, name).",
+    "_ast.Eq.__getstate__" => "Helper for pickle.",
+    "_ast.Eq.__gt__" => "Return self>value.",
+    "_ast.Eq.__hash__" => "Return hash(self).",
+    "_ast.Eq.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_ast.Eq.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_ast.Eq.__le__" => "Return self<=value.",
+    "_ast.Eq.__lt__" => "Return self<value.",
+    "_ast.Eq.__ne__" => "Return self!=value.",
+    "_ast.Eq.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_ast.Eq.__reduce_ex__" => "Helper for pickle.",
+    "_ast.Eq.__replace__" => "Return a copy of the AST node with new values for the specified fields.",
+    "_ast.Eq.__repr__" => "Return repr(self).",
+    "_ast.Eq.__setattr__" => "Implement setattr(self, name, value).",
+    "_ast.Eq.__sizeof__" => "Size of object in memory, in bytes.",
+    "_ast.Eq.__str__" => "Return str(self).",
+    "_ast.Eq.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_ast.Eq.__weakref__" => "list of weak references to the object",
+    "_ast.ExceptHandler" => "ExceptHandler(expr? type, identifier? name, stmt* body)",
+    "_ast.ExceptHandler.__delattr__" => "Implement delattr(self, name).",
+    "_ast.ExceptHandler.__eq__" => "Return self==value.",
+    "_ast.ExceptHandler.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_ast.ExceptHandler.__ge__" => "Return self>=value.",
+    "_ast.ExceptHandler.__getattribute__" => "Return getattr(self, name).",
+    "_ast.ExceptHandler.__getstate__" => "Helper for pickle.",
+    "_ast.ExceptHandler.__gt__" => "Return self>value.",
+    "_ast.ExceptHandler.__hash__" => "Return hash(self).",
+    "_ast.ExceptHandler.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_ast.ExceptHandler.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_ast.ExceptHandler.__le__" => "Return self<=value.",
+    "_ast.ExceptHandler.__lt__" => "Return self<value.",
+    "_ast.ExceptHandler.__ne__" => "Return self!=value.",
+    "_ast.ExceptHandler.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_ast.ExceptHandler.__reduce_ex__" => "Helper for pickle.",
+    "_ast.ExceptHandler.__replace__" => "Return a copy of the AST node with new values for the specified fields.",
+    "_ast.ExceptHandler.__repr__" => "Return repr(self).",
+    "_ast.ExceptHandler.__setattr__" => "Implement setattr(self, name, value).",
+    "_ast.ExceptHandler.__sizeof__" => "Size of object in memory, in bytes.",
+    "_ast.ExceptHandler.__str__" => "Return str(self).",
+    "_ast.ExceptHandler.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_ast.ExceptHandler.__weakref__" => "list of weak references to the object",
+    "_ast.Expr" => "Expr(expr value)",
+    "_ast.Expr.__delattr__" => "Implement delattr(self, name).",
+    "_ast.Expr.__eq__" => "Return self==value.",
+    "_ast.Expr.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_ast.Expr.__ge__" => "Return self>=value.",
+    "_ast.Expr.__getattribute__" => "Return getattr(self, name).",
+    "_ast.Expr.__getstate__" => "Helper for pickle.",
+    "_ast.Expr.__gt__" => "Return self>value.",
+    "_ast.Expr.__hash__" => "Return hash(self).",
+    "_ast.Expr.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_ast.Expr.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_ast.Expr.__le__" => "Return self<=value.",
+    "_ast.Expr.__lt__" => "Return self<value.",
+    "_ast.Expr.__ne__" => "Return self!=value.",
+    "_ast.Expr.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_ast.Expr.__reduce_ex__" => "Helper for pickle.",
+    "_ast.Expr.__replace__" => "Return a copy of the AST node with new values for the specified fields.",
+    "_ast.Expr.__repr__" => "Return repr(self).",
+    "_ast.Expr.__setattr__" => "Implement setattr(self, name, value).",
+    "_ast.Expr.__sizeof__" => "Size of object in memory, in bytes.",
+    "_ast.Expr.__str__" => "Return str(self).",
+    "_ast.Expr.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_ast.Expr.__weakref__" => "list of weak references to the object",
+    "_ast.Expression" => "Expression(expr body)",
+    "_ast.Expression.__delattr__" => "Implement delattr(self, name).",
+    "_ast.Expression.__eq__" => "Return self==value.",
+    "_ast.Expression.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_ast.Expression.__ge__" => "Return self>=value.",
+    "_ast.Expression.__getattribute__" => "Return getattr(self, name).",
+    "_ast.Expression.__getstate__" => "Helper for pickle.",
+    "_ast.Expression.__gt__" => "Return self>value.",
+    "_ast.Expression.__hash__" => "Return hash(self).",
+    "_ast.Expression.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_ast.Expression.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_ast.Expression.__le__" => "Return self<=value.",
+    "_ast.Expression.__lt__" => "Return self<value.",
+    "_ast.Expression.__ne__" => "Return self!=value.",
+    "_ast.Expression.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_ast.Expression.__reduce_ex__" => "Helper for pickle.",
+    "_ast.Expression.__replace__" => "Return a copy of the AST node with new values for the specified fields.",
+    "_ast.Expression.__repr__" => "Return repr(self).",
+    "_ast.Expression.__setattr__" => "Implement setattr(self, name, value).",
+    "_ast.Expression.__sizeof__" => "Size of object in memory, in bytes.",
+    "_ast.Expression.__str__" => "Return str(self).",
+    "_ast.Expression.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_ast.Expression.__weakref__" => "list of weak references to the object",
+    "_ast.FloorDiv" => "FloorDiv",
+    "_ast.FloorDiv.__delattr__" => "Implement delattr(self, name).",
+    "_ast.FloorDiv.__eq__" => "Return self==value.",
+    "_ast.FloorDiv.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_ast.FloorDiv.__ge__" => "Return self>=value.",
+    "_ast.FloorDiv.__getattribute__" => "Return getattr(self, name).",
+    "_ast.FloorDiv.__getstate__" => "Helper for pickle.",
+    "_ast.FloorDiv.__gt__" => "Return self>value.",
+    "_ast.FloorDiv.__hash__" => "Return hash(self).",
+    "_ast.FloorDiv.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_ast.FloorDiv.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_ast.FloorDiv.__le__" => "Return self<=value.",
+    "_ast.FloorDiv.__lt__" => "Return self<value.",
+    "_ast.FloorDiv.__ne__" => "Return self!=value.",
+    "_ast.FloorDiv.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_ast.FloorDiv.__reduce_ex__" => "Helper for pickle.",
+    "_ast.FloorDiv.__replace__" => "Return a copy of the AST node with new values for the specified fields.",
+    "_ast.FloorDiv.__repr__" => "Return repr(self).",
+    "_ast.FloorDiv.__setattr__" => "Implement setattr(self, name, value).",
+    "_ast.FloorDiv.__sizeof__" => "Size of object in memory, in bytes.",
+    "_ast.FloorDiv.__str__" => "Return str(self).",
+    "_ast.FloorDiv.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_ast.FloorDiv.__weakref__" => "list of weak references to the object",
+    "_ast.For" => "For(expr target, expr iter, stmt* body, stmt* orelse, string? type_comment)",
+    "_ast.For.__delattr__" => "Implement delattr(self, name).",
+    "_ast.For.__eq__" => "Return self==value.",
+    "_ast.For.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_ast.For.__ge__" => "Return self>=value.",
+    "_ast.For.__getattribute__" => "Return getattr(self, name).",
+    "_ast.For.__getstate__" => "Helper for pickle.",
+    "_ast.For.__gt__" => "Return self>value.",
+    "_ast.For.__hash__" => "Return hash(self).",
+    "_ast.For.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_ast.For.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_ast.For.__le__" => "Return self<=value.",
+    "_ast.For.__lt__" => "Return self<value.",
+    "_ast.For.__ne__" => "Return self!=value.",
+    "_ast.For.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_ast.For.__reduce_ex__" => "Helper for pickle.",
+    "_ast.For.__replace__" => "Return a copy of the AST node with new values for the specified fields.",
+    "_ast.For.__repr__" => "Return repr(self).",
+    "_ast.For.__setattr__" => "Implement setattr(self, name, value).",
+    "_ast.For.__sizeof__" => "Size of object in memory, in bytes.",
+    "_ast.For.__str__" => "Return str(self).",
+    "_ast.For.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_ast.For.__weakref__" => "list of weak references to the object",
+    "_ast.FormattedValue" => "FormattedValue(expr value, int conversion, expr? format_spec)",
+    "_ast.FormattedValue.__delattr__" => "Implement delattr(self, name).",
+    "_ast.FormattedValue.__eq__" => "Return self==value.",
+    "_ast.FormattedValue.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_ast.FormattedValue.__ge__" => "Return self>=value.",
+    "_ast.FormattedValue.__getattribute__" => "Return getattr(self, name).",
+    "_ast.FormattedValue.__getstate__" => "Helper for pickle.",
+    "_ast.FormattedValue.__gt__" => "Return self>value.",
+    "_ast.FormattedValue.__hash__" => "Return hash(self).",
+    "_ast.FormattedValue.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_ast.FormattedValue.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_ast.FormattedValue.__le__" => "Return self<=value.",
+    "_ast.FormattedValue.__lt__" => "Return self<value.",
+    "_ast.FormattedValue.__ne__" => "Return self!=value.",
+    "_ast.FormattedValue.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_ast.FormattedValue.__reduce_ex__" => "Helper for pickle.",
+    "_ast.FormattedValue.__replace__" => "Return a copy of the AST node with new values for the specified fields.",
+    "_ast.FormattedValue.__repr__" => "Return repr(self).",
+    "_ast.FormattedValue.__setattr__" => "Implement setattr(self, name, value).",
+    "_ast.FormattedValue.__sizeof__" => "Size of object in memory, in bytes.",
+    "_ast.FormattedValue.__str__" => "Return str(self).",
+    "_ast.FormattedValue.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_ast.FormattedValue.__weakref__" => "list of weak references to the object",
+    "_ast.FunctionDef" => "FunctionDef(identifier name, arguments args, stmt* body, expr* decorator_list, expr? returns, string? type_comment, type_param* type_params)",
+    "_ast.FunctionDef.__delattr__" => "Implement delattr(self, name).",
+    "_ast.FunctionDef.__eq__" => "Return self==value.",
+    "_ast.FunctionDef.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_ast.FunctionDef.__ge__" => "Return self>=value.",
+    "_ast.FunctionDef.__getattribute__" => "Return getattr(self, name).",
+    "_ast.FunctionDef.__getstate__" => "Helper for pickle.",
+    "_ast.FunctionDef.__gt__" => "Return self>value.",
+    "_ast.FunctionDef.__hash__" => "Return hash(self).",
+    "_ast.FunctionDef.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_ast.FunctionDef.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_ast.FunctionDef.__le__" => "Return self<=value.",
+    "_ast.FunctionDef.__lt__" => "Return self<value.",
+    "_ast.FunctionDef.__ne__" => "Return self!=value.",
+    "_ast.FunctionDef.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_ast.FunctionDef.__reduce_ex__" => "Helper for pickle.",
+    "_ast.FunctionDef.__replace__" => "Return a copy of the AST node with new values for the specified fields.",
+    "_ast.FunctionDef.__repr__" => "Return repr(self).",
+    "_ast.FunctionDef.__setattr__" => "Implement setattr(self, name, value).",
+    "_ast.FunctionDef.__sizeof__" => "Size of object in memory, in bytes.",
+    "_ast.FunctionDef.__str__" => "Return str(self).",
+    "_ast.FunctionDef.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_ast.FunctionDef.__weakref__" => "list of weak references to the object",
+    "_ast.FunctionType" => "FunctionType(expr* argtypes, expr returns)",
+    "_ast.FunctionType.__delattr__" => "Implement delattr(self, name).",
+    "_ast.FunctionType.__eq__" => "Return self==value.",
+    "_ast.FunctionType.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_ast.FunctionType.__ge__" => "Return self>=value.",
+    "_ast.FunctionType.__getattribute__" => "Return getattr(self, name).",
+    "_ast.FunctionType.__getstate__" => "Helper for pickle.",
+    "_ast.FunctionType.__gt__" => "Return self>value.",
+    "_ast.FunctionType.__hash__" => "Return hash(self).",
+    "_ast.FunctionType.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_ast.FunctionType.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_ast.FunctionType.__le__" => "Return self<=value.",
+    "_ast.FunctionType.__lt__" => "Return self<value.",
+    "_ast.FunctionType.__ne__" => "Return self!=value.",
+    "_ast.FunctionType.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_ast.FunctionType.__reduce_ex__" => "Helper for pickle.",
+    "_ast.FunctionType.__replace__" => "Return a copy of the AST node with new values for the specified fields.",
+    "_ast.FunctionType.__repr__" => "Return repr(self).",
+    "_ast.FunctionType.__setattr__" => "Implement setattr(self, name, value).",
+    "_ast.FunctionType.__sizeof__" => "Size of object in memory, in bytes.",
+    "_ast.FunctionType.__str__" => "Return str(self).",
+    "_ast.FunctionType.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_ast.FunctionType.__weakref__" => "list of weak references to the object",
+    "_ast.GeneratorExp" => "GeneratorExp(expr elt, comprehension* generators)",
+    "_ast.GeneratorExp.__delattr__" => "Implement delattr(self, name).",
+    "_ast.GeneratorExp.__eq__" => "Return self==value.",
+    "_ast.GeneratorExp.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_ast.GeneratorExp.__ge__" => "Return self>=value.",
+    "_ast.GeneratorExp.__getattribute__" => "Return getattr(self, name).",
+    "_ast.GeneratorExp.__getstate__" => "Helper for pickle.",
+    "_ast.GeneratorExp.__gt__" => "Return self>value.",
+    "_ast.GeneratorExp.__hash__" => "Return hash(self).",
+    "_ast.GeneratorExp.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_ast.GeneratorExp.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_ast.GeneratorExp.__le__" => "Return self<=value.",
+    "_ast.GeneratorExp.__lt__" => "Return self<value.",
+    "_ast.GeneratorExp.__ne__" => "Return self!=value.",
+    "_ast.GeneratorExp.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_ast.GeneratorExp.__reduce_ex__" => "Helper for pickle.",
+    "_ast.GeneratorExp.__replace__" => "Return a copy of the AST node with new values for the specified fields.",
+    "_ast.GeneratorExp.__repr__" => "Return repr(self).",
+    "_ast.GeneratorExp.__setattr__" => "Implement setattr(self, name, value).",
+    "_ast.GeneratorExp.__sizeof__" => "Size of object in memory, in bytes.",
+    "_ast.GeneratorExp.__str__" => "Return str(self).",
+    "_ast.GeneratorExp.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_ast.GeneratorExp.__weakref__" => "list of weak references to the object",
+    "_ast.Global" => "Global(identifier* names)",
+    "_ast.Global.__delattr__" => "Implement delattr(self, name).",
+    "_ast.Global.__eq__" => "Return self==value.",
+    "_ast.Global.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_ast.Global.__ge__" => "Return self>=value.",
+    "_ast.Global.__getattribute__" => "Return getattr(self, name).",
+    "_ast.Global.__getstate__" => "Helper for pickle.",
+    "_ast.Global.__gt__" => "Return self>value.",
+    "_ast.Global.__hash__" => "Return hash(self).",
+    "_ast.Global.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_ast.Global.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_ast.Global.__le__" => "Return self<=value.",
+    "_ast.Global.__lt__" => "Return self<value.",
+    "_ast.Global.__ne__" => "Return self!=value.",
+    "_ast.Global.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_ast.Global.__reduce_ex__" => "Helper for pickle.",
+    "_ast.Global.__replace__" => "Return a copy of the AST node with new values for the specified fields.",
+    "_ast.Global.__repr__" => "Return repr(self).",
+    "_ast.Global.__setattr__" => "Implement setattr(self, name, value).",
+    "_ast.Global.__sizeof__" => "Size of object in memory, in bytes.",
+    "_ast.Global.__str__" => "Return str(self).",
+    "_ast.Global.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_ast.Global.__weakref__" => "list of weak references to the object",
+    "_ast.Gt" => "Gt",
+    "_ast.Gt.__delattr__" => "Implement delattr(self, name).",
+    "_ast.Gt.__eq__" => "Return self==value.",
+    "_ast.Gt.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_ast.Gt.__ge__" => "Return self>=value.",
+    "_ast.Gt.__getattribute__" => "Return getattr(self, name).",
+    "_ast.Gt.__getstate__" => "Helper for pickle.",
+    "_ast.Gt.__gt__" => "Return self>value.",
+    "_ast.Gt.__hash__" => "Return hash(self).",
+    "_ast.Gt.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_ast.Gt.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_ast.Gt.__le__" => "Return self<=value.",
+    "_ast.Gt.__lt__" => "Return self<value.",
+    "_ast.Gt.__ne__" => "Return self!=value.",
+    "_ast.Gt.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_ast.Gt.__reduce_ex__" => "Helper for pickle.",
+    "_ast.Gt.__replace__" => "Return a copy of the AST node with new values for the specified fields.",
+    "_ast.Gt.__repr__" => "Return repr(self).",
+    "_ast.Gt.__setattr__" => "Implement setattr(self, name, value).",
+    "_ast.Gt.__sizeof__" => "Size of object in memory, in bytes.",
+    "_ast.Gt.__str__" => "Return str(self).",
+    "_ast.Gt.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_ast.Gt.__weakref__" => "list of weak references to the object",
+    "_ast.GtE" => "GtE",
+    "_ast.GtE.__delattr__" => "Implement delattr(self, name).",
+    "_ast.GtE.__eq__" => "Return self==value.",
+    "_ast.GtE.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_ast.GtE.__ge__" => "Return self>=value.",
+    "_ast.GtE.__getattribute__" => "Return getattr(self, name).",
+    "_ast.GtE.__getstate__" => "Helper for pickle.",
+    "_ast.GtE.__gt__" => "Return self>value.",
+    "_ast.GtE.__hash__" => "Return hash(self).",
+    "_ast.GtE.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_ast.GtE.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_ast.GtE.__le__" => "Return self<=value.",
+    "_ast.GtE.__lt__" => "Return self<value.",
+    "_ast.GtE.__ne__" => "Return self!=value.",
+    "_ast.GtE.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_ast.GtE.__reduce_ex__" => "Helper for pickle.",
+    "_ast.GtE.__replace__" => "Return a copy of the AST node with new values for the specified fields.",
+    "_ast.GtE.__repr__" => "Return repr(self).",
+    "_ast.GtE.__setattr__" => "Implement setattr(self, name, value).",
+    "_ast.GtE.__sizeof__" => "Size of object in memory, in bytes.",
+    "_ast.GtE.__str__" => "Return str(self).",
+    "_ast.GtE.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_ast.GtE.__weakref__" => "list of weak references to the object",
+    "_ast.If" => "If(expr test, stmt* body, stmt* orelse)",
+    "_ast.If.__delattr__" => "Implement delattr(self, name).",
+    "_ast.If.__eq__" => "Return self==value.",
+    "_ast.If.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_ast.If.__ge__" => "Return self>=value.",
+    "_ast.If.__getattribute__" => "Return getattr(self, name).",
+    "_ast.If.__getstate__" => "Helper for pickle.",
+    "_ast.If.__gt__" => "Return self>value.",
+    "_ast.If.__hash__" => "Return hash(self).",
+    "_ast.If.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_ast.If.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_ast.If.__le__" => "Return self<=value.",
+    "_ast.If.__lt__" => "Return self<value.",
+    "_ast.If.__ne__" => "Return self!=value.",
+    "_ast.If.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_ast.If.__reduce_ex__" => "Helper for pickle.",
+    "_ast.If.__replace__" => "Return a copy of the AST node with new values for the specified fields.",
+    "_ast.If.__repr__" => "Return repr(self).",
+    "_ast.If.__setattr__" => "Implement setattr(self, name, value).",
+    "_ast.If.__sizeof__" => "Size of object in memory, in bytes.",
+    "_ast.If.__str__" => "Return str(self).",
+    "_ast.If.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_ast.If.__weakref__" => "list of weak references to the object",
+    "_ast.IfExp" => "IfExp(expr test, expr body, expr orelse)",
+    "_ast.IfExp.__delattr__" => "Implement delattr(self, name).",
+    "_ast.IfExp.__eq__" => "Return self==value.",
+    "_ast.IfExp.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_ast.IfExp.__ge__" => "Return self>=value.",
+    "_ast.IfExp.__getattribute__" => "Return getattr(self, name).",
+    "_ast.IfExp.__getstate__" => "Helper for pickle.",
+    "_ast.IfExp.__gt__" => "Return self>value.",
+    "_ast.IfExp.__hash__" => "Return hash(self).",
+    "_ast.IfExp.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_ast.IfExp.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_ast.IfExp.__le__" => "Return self<=value.",
+    "_ast.IfExp.__lt__" => "Return self<value.",
+    "_ast.IfExp.__ne__" => "Return self!=value.",
+    "_ast.IfExp.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_ast.IfExp.__reduce_ex__" => "Helper for pickle.",
+    "_ast.IfExp.__replace__" => "Return a copy of the AST node with new values for the specified fields.",
+    "_ast.IfExp.__repr__" => "Return repr(self).",
+    "_ast.IfExp.__setattr__" => "Implement setattr(self, name, value).",
+    "_ast.IfExp.__sizeof__" => "Size of object in memory, in bytes.",
+    "_ast.IfExp.__str__" => "Return str(self).",
+    "_ast.IfExp.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_ast.IfExp.__weakref__" => "list of weak references to the object",
+    "_ast.Import" => "Import(alias* names)",
+    "_ast.Import.__delattr__" => "Implement delattr(self, name).",
+    "_ast.Import.__eq__" => "Return self==value.",
+    "_ast.Import.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_ast.Import.__ge__" => "Return self>=value.",
+    "_ast.Import.__getattribute__" => "Return getattr(self, name).",
+    "_ast.Import.__getstate__" => "Helper for pickle.",
+    "_ast.Import.__gt__" => "Return self>value.",
+    "_ast.Import.__hash__" => "Return hash(self).",
+    "_ast.Import.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_ast.Import.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_ast.Import.__le__" => "Return self<=value.",
+    "_ast.Import.__lt__" => "Return self<value.",
+    "_ast.Import.__ne__" => "Return self!=value.",
+    "_ast.Import.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_ast.Import.__reduce_ex__" => "Helper for pickle.",
+    "_ast.Import.__replace__" => "Return a copy of the AST node with new values for the specified fields.",
+    "_ast.Import.__repr__" => "Return repr(self).",
+    "_ast.Import.__setattr__" => "Implement setattr(self, name, value).",
+    "_ast.Import.__sizeof__" => "Size of object in memory, in bytes.",
+    "_ast.Import.__str__" => "Return str(self).",
+    "_ast.Import.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_ast.Import.__weakref__" => "list of weak references to the object",
+    "_ast.ImportFrom" => "ImportFrom(identifier? module, alias* names, int? level)",
+    "_ast.ImportFrom.__delattr__" => "Implement delattr(self, name).",
+    "_ast.ImportFrom.__eq__" => "Return self==value.",
+    "_ast.ImportFrom.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_ast.ImportFrom.__ge__" => "Return self>=value.",
+    "_ast.ImportFrom.__getattribute__" => "Return getattr(self, name).",
+    "_ast.ImportFrom.__getstate__" => "Helper for pickle.",
+    "_ast.ImportFrom.__gt__" => "Return self>value.",
+    "_ast.ImportFrom.__hash__" => "Return hash(self).",
+    "_ast.ImportFrom.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_ast.ImportFrom.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_ast.ImportFrom.__le__" => "Return self<=value.",
+    "_ast.ImportFrom.__lt__" => "Return self<value.",
+    "_ast.ImportFrom.__ne__" => "Return self!=value.",
+    "_ast.ImportFrom.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_ast.ImportFrom.__reduce_ex__" => "Helper for pickle.",
+    "_ast.ImportFrom.__replace__" => "Return a copy of the AST node with new values for the specified fields.",
+    "_ast.ImportFrom.__repr__" => "Return repr(self).",
+    "_ast.ImportFrom.__setattr__" => "Implement setattr(self, name, value).",
+    "_ast.ImportFrom.__sizeof__" => "Size of object in memory, in bytes.",
+    "_ast.ImportFrom.__str__" => "Return str(self).",
+    "_ast.ImportFrom.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_ast.ImportFrom.__weakref__" => "list of weak references to the object",
+    "_ast.In" => "In",
+    "_ast.In.__delattr__" => "Implement delattr(self, name).",
+    "_ast.In.__eq__" => "Return self==value.",
+    "_ast.In.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_ast.In.__ge__" => "Return self>=value.",
+    "_ast.In.__getattribute__" => "Return getattr(self, name).",
+    "_ast.In.__getstate__" => "Helper for pickle.",
+    "_ast.In.__gt__" => "Return self>value.",
+    "_ast.In.__hash__" => "Return hash(self).",
+    "_ast.In.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_ast.In.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_ast.In.__le__" => "Return self<=value.",
+    "_ast.In.__lt__" => "Return self<value.",
+    "_ast.In.__ne__" => "Return self!=value.",
+    "_ast.In.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_ast.In.__reduce_ex__" => "Helper for pickle.",
+    "_ast.In.__replace__" => "Return a copy of the AST node with new values for the specified fields.",
+    "_ast.In.__repr__" => "Return repr(self).",
+    "_ast.In.__setattr__" => "Implement setattr(self, name, value).",
+    "_ast.In.__sizeof__" => "Size of object in memory, in bytes.",
+    "_ast.In.__str__" => "Return str(self).",
+    "_ast.In.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_ast.In.__weakref__" => "list of weak references to the object",
+    "_ast.Interactive" => "Interactive(stmt* body)",
+    "_ast.Interactive.__delattr__" => "Implement delattr(self, name).",
+    "_ast.Interactive.__eq__" => "Return self==value.",
+    "_ast.Interactive.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_ast.Interactive.__ge__" => "Return self>=value.",
+    "_ast.Interactive.__getattribute__" => "Return getattr(self, name).",
+    "_ast.Interactive.__getstate__" => "Helper for pickle.",
+    "_ast.Interactive.__gt__" => "Return self>value.",
+    "_ast.Interactive.__hash__" => "Return hash(self).",
+    "_ast.Interactive.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_ast.Interactive.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_ast.Interactive.__le__" => "Return self<=value.",
+    "_ast.Interactive.__lt__" => "Return self<value.",
+    "_ast.Interactive.__ne__" => "Return self!=value.",
+    "_ast.Interactive.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_ast.Interactive.__reduce_ex__" => "Helper for pickle.",
+    "_ast.Interactive.__replace__" => "Return a copy of the AST node with new values for the specified fields.",
+    "_ast.Interactive.__repr__" => "Return repr(self).",
+    "_ast.Interactive.__setattr__" => "Implement setattr(self, name, value).",
+    "_ast.Interactive.__sizeof__" => "Size of object in memory, in bytes.",
+    "_ast.Interactive.__str__" => "Return str(self).",
+    "_ast.Interactive.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_ast.Interactive.__weakref__" => "list of weak references to the object",
+    "_ast.Interpolation" => "Interpolation(expr value, constant str, int conversion, expr? format_spec)",
+    "_ast.Interpolation.__delattr__" => "Implement delattr(self, name).",
+    "_ast.Interpolation.__eq__" => "Return self==value.",
+    "_ast.Interpolation.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_ast.Interpolation.__ge__" => "Return self>=value.",
+    "_ast.Interpolation.__getattribute__" => "Return getattr(self, name).",
+    "_ast.Interpolation.__getstate__" => "Helper for pickle.",
+    "_ast.Interpolation.__gt__" => "Return self>value.",
+    "_ast.Interpolation.__hash__" => "Return hash(self).",
+    "_ast.Interpolation.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_ast.Interpolation.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_ast.Interpolation.__le__" => "Return self<=value.",
+    "_ast.Interpolation.__lt__" => "Return self<value.",
+    "_ast.Interpolation.__ne__" => "Return self!=value.",
+    "_ast.Interpolation.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_ast.Interpolation.__reduce_ex__" => "Helper for pickle.",
+    "_ast.Interpolation.__replace__" => "Return a copy of the AST node with new values for the specified fields.",
+    "_ast.Interpolation.__repr__" => "Return repr(self).",
+    "_ast.Interpolation.__setattr__" => "Implement setattr(self, name, value).",
+    "_ast.Interpolation.__sizeof__" => "Size of object in memory, in bytes.",
+    "_ast.Interpolation.__str__" => "Return str(self).",
+    "_ast.Interpolation.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_ast.Interpolation.__weakref__" => "list of weak references to the object",
+    "_ast.Invert" => "Invert",
+    "_ast.Invert.__delattr__" => "Implement delattr(self, name).",
+    "_ast.Invert.__eq__" => "Return self==value.",
+    "_ast.Invert.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_ast.Invert.__ge__" => "Return self>=value.",
+    "_ast.Invert.__getattribute__" => "Return getattr(self, name).",
+    "_ast.Invert.__getstate__" => "Helper for pickle.",
+    "_ast.Invert.__gt__" => "Return self>value.",
+    "_ast.Invert.__hash__" => "Return hash(self).",
+    "_ast.Invert.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_ast.Invert.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_ast.Invert.__le__" => "Return self<=value.",
+    "_ast.Invert.__lt__" => "Return self<value.",
+    "_ast.Invert.__ne__" => "Return self!=value.",
+    "_ast.Invert.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_ast.Invert.__reduce_ex__" => "Helper for pickle.",
+    "_ast.Invert.__replace__" => "Return a copy of the AST node with new values for the specified fields.",
+    "_ast.Invert.__repr__" => "Return repr(self).",
+    "_ast.Invert.__setattr__" => "Implement setattr(self, name, value).",
+    "_ast.Invert.__sizeof__" => "Size of object in memory, in bytes.",
+    "_ast.Invert.__str__" => "Return str(self).",
+    "_ast.Invert.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_ast.Invert.__weakref__" => "list of weak references to the object",
+    "_ast.Is" => "Is",
+    "_ast.Is.__delattr__" => "Implement delattr(self, name).",
+    "_ast.Is.__eq__" => "Return self==value.",
+    "_ast.Is.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_ast.Is.__ge__" => "Return self>=value.",
+    "_ast.Is.__getattribute__" => "Return getattr(self, name).",
+    "_ast.Is.__getstate__" => "Helper for pickle.",
+    "_ast.Is.__gt__" => "Return self>value.",
+    "_ast.Is.__hash__" => "Return hash(self).",
+    "_ast.Is.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_ast.Is.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_ast.Is.__le__" => "Return self<=value.",
+    "_ast.Is.__lt__" => "Return self<value.",
+    "_ast.Is.__ne__" => "Return self!=value.",
+    "_ast.Is.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_ast.Is.__reduce_ex__" => "Helper for pickle.",
+    "_ast.Is.__replace__" => "Return a copy of the AST node with new values for the specified fields.",
+    "_ast.Is.__repr__" => "Return repr(self).",
+    "_ast.Is.__setattr__" => "Implement setattr(self, name, value).",
+    "_ast.Is.__sizeof__" => "Size of object in memory, in bytes.",
+    "_ast.Is.__str__" => "Return str(self).",
+    "_ast.Is.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_ast.Is.__weakref__" => "list of weak references to the object",
+    "_ast.IsNot" => "IsNot",
+    "_ast.IsNot.__delattr__" => "Implement delattr(self, name).",
+    "_ast.IsNot.__eq__" => "Return self==value.",
+    "_ast.IsNot.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_ast.IsNot.__ge__" => "Return self>=value.",
+    "_ast.IsNot.__getattribute__" => "Return getattr(self, name).",
+    "_ast.IsNot.__getstate__" => "Helper for pickle.",
+    "_ast.IsNot.__gt__" => "Return self>value.",
+    "_ast.IsNot.__hash__" => "Return hash(self).",
+    "_ast.IsNot.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_ast.IsNot.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_ast.IsNot.__le__" => "Return self<=value.",
+    "_ast.IsNot.__lt__" => "Return self<value.",
+    "_ast.IsNot.__ne__" => "Return self!=value.",
+    "_ast.IsNot.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_ast.IsNot.__reduce_ex__" => "Helper for pickle.",
+    "_ast.IsNot.__replace__" => "Return a copy of the AST node with new values for the specified fields.",
+    "_ast.IsNot.__repr__" => "Return repr(self).",
+    "_ast.IsNot.__setattr__" => "Implement setattr(self, name, value).",
+    "_ast.IsNot.__sizeof__" => "Size of object in memory, in bytes.",
+    "_ast.IsNot.__str__" => "Return str(self).",
+    "_ast.IsNot.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_ast.IsNot.__weakref__" => "list of weak references to the object",
+    "_ast.JoinedStr" => "JoinedStr(expr* values)",
+    "_ast.JoinedStr.__delattr__" => "Implement delattr(self, name).",
+    "_ast.JoinedStr.__eq__" => "Return self==value.",
+    "_ast.JoinedStr.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_ast.JoinedStr.__ge__" => "Return self>=value.",
+    "_ast.JoinedStr.__getattribute__" => "Return getattr(self, name).",
+    "_ast.JoinedStr.__getstate__" => "Helper for pickle.",
+    "_ast.JoinedStr.__gt__" => "Return self>value.",
+    "_ast.JoinedStr.__hash__" => "Return hash(self).",
+    "_ast.JoinedStr.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_ast.JoinedStr.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_ast.JoinedStr.__le__" => "Return self<=value.",
+    "_ast.JoinedStr.__lt__" => "Return self<value.",
+    "_ast.JoinedStr.__ne__" => "Return self!=value.",
+    "_ast.JoinedStr.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_ast.JoinedStr.__reduce_ex__" => "Helper for pickle.",
+    "_ast.JoinedStr.__replace__" => "Return a copy of the AST node with new values for the specified fields.",
+    "_ast.JoinedStr.__repr__" => "Return repr(self).",
+    "_ast.JoinedStr.__setattr__" => "Implement setattr(self, name, value).",
+    "_ast.JoinedStr.__sizeof__" => "Size of object in memory, in bytes.",
+    "_ast.JoinedStr.__str__" => "Return str(self).",
+    "_ast.JoinedStr.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_ast.JoinedStr.__weakref__" => "list of weak references to the object",
+    "_ast.LShift" => "LShift",
+    "_ast.LShift.__delattr__" => "Implement delattr(self, name).",
+    "_ast.LShift.__eq__" => "Return self==value.",
+    "_ast.LShift.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_ast.LShift.__ge__" => "Return self>=value.",
+    "_ast.LShift.__getattribute__" => "Return getattr(self, name).",
+    "_ast.LShift.__getstate__" => "Helper for pickle.",
+    "_ast.LShift.__gt__" => "Return self>value.",
+    "_ast.LShift.__hash__" => "Return hash(self).",
+    "_ast.LShift.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_ast.LShift.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_ast.LShift.__le__" => "Return self<=value.",
+    "_ast.LShift.__lt__" => "Return self<value.",
+    "_ast.LShift.__ne__" => "Return self!=value.",
+    "_ast.LShift.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_ast.LShift.__reduce_ex__" => "Helper for pickle.",
+    "_ast.LShift.__replace__" => "Return a copy of the AST node with new values for the specified fields.",
+    "_ast.LShift.__repr__" => "Return repr(self).",
+    "_ast.LShift.__setattr__" => "Implement setattr(self, name, value).",
+    "_ast.LShift.__sizeof__" => "Size of object in memory, in bytes.",
+    "_ast.LShift.__str__" => "Return str(self).",
+    "_ast.LShift.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_ast.LShift.__weakref__" => "list of weak references to the object",
+    "_ast.Lambda" => "Lambda(arguments args, expr body)",
+    "_ast.Lambda.__delattr__" => "Implement delattr(self, name).",
+    "_ast.Lambda.__eq__" => "Return self==value.",
+    "_ast.Lambda.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_ast.Lambda.__ge__" => "Return self>=value.",
+    "_ast.Lambda.__getattribute__" => "Return getattr(self, name).",
+    "_ast.Lambda.__getstate__" => "Helper for pickle.",
+    "_ast.Lambda.__gt__" => "Return self>value.",
+    "_ast.Lambda.__hash__" => "Return hash(self).",
+    "_ast.Lambda.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_ast.Lambda.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_ast.Lambda.__le__" => "Return self<=value.",
+    "_ast.Lambda.__lt__" => "Return self<value.",
+    "_ast.Lambda.__ne__" => "Return self!=value.",
+    "_ast.Lambda.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_ast.Lambda.__reduce_ex__" => "Helper for pickle.",
+    "_ast.Lambda.__replace__" => "Return a copy of the AST node with new values for the specified fields.",
+    "_ast.Lambda.__repr__" => "Return repr(self).",
+    "_ast.Lambda.__setattr__" => "Implement setattr(self, name, value).",
+    "_ast.Lambda.__sizeof__" => "Size of object in memory, in bytes.",
+    "_ast.Lambda.__str__" => "Return str(self).",
+    "_ast.Lambda.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_ast.Lambda.__weakref__" => "list of weak references to the object",
+    "_ast.List" => "List(expr* elts, expr_context ctx)",
+    "_ast.List.__delattr__" => "Implement delattr(self, name).",
+    "_ast.List.__eq__" => "Return self==value.",
+    "_ast.List.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_ast.List.__ge__" => "Return self>=value.",
+    "_ast.List.__getattribute__" => "Return getattr(self, name).",
+    "_ast.List.__getstate__" => "Helper for pickle.",
+    "_ast.List.__gt__" => "Return self>value.",
+    "_ast.List.__hash__" => "Return hash(self).",
+    "_ast.List.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_ast.List.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_ast.List.__le__" => "Return self<=value.",
+    "_ast.List.__lt__" => "Return self<value.",
+    "_ast.List.__ne__" => "Return self!=value.",
+    "_ast.List.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_ast.List.__reduce_ex__" => "Helper for pickle.",
+    "_ast.List.__replace__" => "Return a copy of the AST node with new values for the specified fields.",
+    "_ast.List.__repr__" => "Return repr(self).",
+    "_ast.List.__setattr__" => "Implement setattr(self, name, value).",
+    "_ast.List.__sizeof__" => "Size of object in memory, in bytes.",
+    "_ast.List.__str__" => "Return str(self).",
+    "_ast.List.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_ast.List.__weakref__" => "list of weak references to the object",
+    "_ast.ListComp" => "ListComp(expr elt, comprehension* generators)",
+    "_ast.ListComp.__delattr__" => "Implement delattr(self, name).",
+    "_ast.ListComp.__eq__" => "Return self==value.",
+    "_ast.ListComp.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_ast.ListComp.__ge__" => "Return self>=value.",
+    "_ast.ListComp.__getattribute__" => "Return getattr(self, name).",
+    "_ast.ListComp.__getstate__" => "Helper for pickle.",
+    "_ast.ListComp.__gt__" => "Return self>value.",
+    "_ast.ListComp.__hash__" => "Return hash(self).",
+    "_ast.ListComp.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_ast.ListComp.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_ast.ListComp.__le__" => "Return self<=value.",
+    "_ast.ListComp.__lt__" => "Return self<value.",
+    "_ast.ListComp.__ne__" => "Return self!=value.",
+    "_ast.ListComp.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_ast.ListComp.__reduce_ex__" => "Helper for pickle.",
+    "_ast.ListComp.__replace__" => "Return a copy of the AST node with new values for the specified fields.",
+    "_ast.ListComp.__repr__" => "Return repr(self).",
+    "_ast.ListComp.__setattr__" => "Implement setattr(self, name, value).",
+    "_ast.ListComp.__sizeof__" => "Size of object in memory, in bytes.",
+    "_ast.ListComp.__str__" => "Return str(self).",
+    "_ast.ListComp.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_ast.ListComp.__weakref__" => "list of weak references to the object",
+    "_ast.Load" => "Load",
+    "_ast.Load.__delattr__" => "Implement delattr(self, name).",
+    "_ast.Load.__eq__" => "Return self==value.",
+    "_ast.Load.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_ast.Load.__ge__" => "Return self>=value.",
+    "_ast.Load.__getattribute__" => "Return getattr(self, name).",
+    "_ast.Load.__getstate__" => "Helper for pickle.",
+    "_ast.Load.__gt__" => "Return self>value.",
+    "_ast.Load.__hash__" => "Return hash(self).",
+    "_ast.Load.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_ast.Load.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_ast.Load.__le__" => "Return self<=value.",
+    "_ast.Load.__lt__" => "Return self<value.",
+    "_ast.Load.__ne__" => "Return self!=value.",
+    "_ast.Load.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_ast.Load.__reduce_ex__" => "Helper for pickle.",
+    "_ast.Load.__replace__" => "Return a copy of the AST node with new values for the specified fields.",
+    "_ast.Load.__repr__" => "Return repr(self).",
+    "_ast.Load.__setattr__" => "Implement setattr(self, name, value).",
+    "_ast.Load.__sizeof__" => "Size of object in memory, in bytes.",
+    "_ast.Load.__str__" => "Return str(self).",
+    "_ast.Load.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_ast.Load.__weakref__" => "list of weak references to the object",
+    "_ast.Lt" => "Lt",
+    "_ast.Lt.__delattr__" => "Implement delattr(self, name).",
+    "_ast.Lt.__eq__" => "Return self==value.",
+    "_ast.Lt.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_ast.Lt.__ge__" => "Return self>=value.",
+    "_ast.Lt.__getattribute__" => "Return getattr(self, name).",
+    "_ast.Lt.__getstate__" => "Helper for pickle.",
+    "_ast.Lt.__gt__" => "Return self>value.",
+    "_ast.Lt.__hash__" => "Return hash(self).",
+    "_ast.Lt.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_ast.Lt.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_ast.Lt.__le__" => "Return self<=value.",
+    "_ast.Lt.__lt__" => "Return self<value.",
+    "_ast.Lt.__ne__" => "Return self!=value.",
+    "_ast.Lt.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_ast.Lt.__reduce_ex__" => "Helper for pickle.",
+    "_ast.Lt.__replace__" => "Return a copy of the AST node with new values for the specified fields.",
+    "_ast.Lt.__repr__" => "Return repr(self).",
+    "_ast.Lt.__setattr__" => "Implement setattr(self, name, value).",
+    "_ast.Lt.__sizeof__" => "Size of object in memory, in bytes.",
+    "_ast.Lt.__str__" => "Return str(self).",
+    "_ast.Lt.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_ast.Lt.__weakref__" => "list of weak references to the object",
+    "_ast.LtE" => "LtE",
+    "_ast.LtE.__delattr__" => "Implement delattr(self, name).",
+    "_ast.LtE.__eq__" => "Return self==value.",
+    "_ast.LtE.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_ast.LtE.__ge__" => "Return self>=value.",
+    "_ast.LtE.__getattribute__" => "Return getattr(self, name).",
+    "_ast.LtE.__getstate__" => "Helper for pickle.",
+    "_ast.LtE.__gt__" => "Return self>value.",
+    "_ast.LtE.__hash__" => "Return hash(self).",
+    "_ast.LtE.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_ast.LtE.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_ast.LtE.__le__" => "Return self<=value.",
+    "_ast.LtE.__lt__" => "Return self<value.",
+    "_ast.LtE.__ne__" => "Return self!=value.",
+    "_ast.LtE.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_ast.LtE.__reduce_ex__" => "Helper for pickle.",
+    "_ast.LtE.__replace__" => "Return a copy of the AST node with new values for the specified fields.",
+    "_ast.LtE.__repr__" => "Return repr(self).",
+    "_ast.LtE.__setattr__" => "Implement setattr(self, name, value).",
+    "_ast.LtE.__sizeof__" => "Size of object in memory, in bytes.",
+    "_ast.LtE.__str__" => "Return str(self).",
+    "_ast.LtE.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_ast.LtE.__weakref__" => "list of weak references to the object",
+    "_ast.MatMult" => "MatMult",
+    "_ast.MatMult.__delattr__" => "Implement delattr(self, name).",
+    "_ast.MatMult.__eq__" => "Return self==value.",
+    "_ast.MatMult.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_ast.MatMult.__ge__" => "Return self>=value.",
+    "_ast.MatMult.__getattribute__" => "Return getattr(self, name).",
+    "_ast.MatMult.__getstate__" => "Helper for pickle.",
+    "_ast.MatMult.__gt__" => "Return self>value.",
+    "_ast.MatMult.__hash__" => "Return hash(self).",
+    "_ast.MatMult.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_ast.MatMult.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_ast.MatMult.__le__" => "Return self<=value.",
+    "_ast.MatMult.__lt__" => "Return self<value.",
+    "_ast.MatMult.__ne__" => "Return self!=value.",
+    "_ast.MatMult.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_ast.MatMult.__reduce_ex__" => "Helper for pickle.",
+    "_ast.MatMult.__replace__" => "Return a copy of the AST node with new values for the specified fields.",
+    "_ast.MatMult.__repr__" => "Return repr(self).",
+    "_ast.MatMult.__setattr__" => "Implement setattr(self, name, value).",
+    "_ast.MatMult.__sizeof__" => "Size of object in memory, in bytes.",
+    "_ast.MatMult.__str__" => "Return str(self).",
+    "_ast.MatMult.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_ast.MatMult.__weakref__" => "list of weak references to the object",
+    "_ast.Match" => "Match(expr subject, match_case* cases)",
+    "_ast.Match.__delattr__" => "Implement delattr(self, name).",
+    "_ast.Match.__eq__" => "Return self==value.",
+    "_ast.Match.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_ast.Match.__ge__" => "Return self>=value.",
+    "_ast.Match.__getattribute__" => "Return getattr(self, name).",
+    "_ast.Match.__getstate__" => "Helper for pickle.",
+    "_ast.Match.__gt__" => "Return self>value.",
+    "_ast.Match.__hash__" => "Return hash(self).",
+    "_ast.Match.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_ast.Match.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_ast.Match.__le__" => "Return self<=value.",
+    "_ast.Match.__lt__" => "Return self<value.",
+    "_ast.Match.__ne__" => "Return self!=value.",
+    "_ast.Match.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_ast.Match.__reduce_ex__" => "Helper for pickle.",
+    "_ast.Match.__replace__" => "Return a copy of the AST node with new values for the specified fields.",
+    "_ast.Match.__repr__" => "Return repr(self).",
+    "_ast.Match.__setattr__" => "Implement setattr(self, name, value).",
+    "_ast.Match.__sizeof__" => "Size of object in memory, in bytes.",
+    "_ast.Match.__str__" => "Return str(self).",
+    "_ast.Match.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_ast.Match.__weakref__" => "list of weak references to the object",
+    "_ast.MatchAs" => "MatchAs(pattern? pattern, identifier? name)",
+    "_ast.MatchAs.__delattr__" => "Implement delattr(self, name).",
+    "_ast.MatchAs.__eq__" => "Return self==value.",
+    "_ast.MatchAs.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_ast.MatchAs.__ge__" => "Return self>=value.",
+    "_ast.MatchAs.__getattribute__" => "Return getattr(self, name).",
+    "_ast.MatchAs.__getstate__" => "Helper for pickle.",
+    "_ast.MatchAs.__gt__" => "Return self>value.",
+    "_ast.MatchAs.__hash__" => "Return hash(self).",
+    "_ast.MatchAs.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_ast.MatchAs.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_ast.MatchAs.__le__" => "Return self<=value.",
+    "_ast.MatchAs.__lt__" => "Return self<value.",
+    "_ast.MatchAs.__ne__" => "Return self!=value.",
+    "_ast.MatchAs.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_ast.MatchAs.__reduce_ex__" => "Helper for pickle.",
+    "_ast.MatchAs.__replace__" => "Return a copy of the AST node with new values for the specified fields.",
+    "_ast.MatchAs.__repr__" => "Return repr(self).",
+    "_ast.MatchAs.__setattr__" => "Implement setattr(self, name, value).",
+    "_ast.MatchAs.__sizeof__" => "Size of object in memory, in bytes.",
+    "_ast.MatchAs.__str__" => "Return str(self).",
+    "_ast.MatchAs.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_ast.MatchAs.__weakref__" => "list of weak references to the object",
+    "_ast.MatchClass" => "MatchClass(expr cls, pattern* patterns, identifier* kwd_attrs, pattern* kwd_patterns)",
+    "_ast.MatchClass.__delattr__" => "Implement delattr(self, name).",
+    "_ast.MatchClass.__eq__" => "Return self==value.",
+    "_ast.MatchClass.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_ast.MatchClass.__ge__" => "Return self>=value.",
+    "_ast.MatchClass.__getattribute__" => "Return getattr(self, name).",
+    "_ast.MatchClass.__getstate__" => "Helper for pickle.",
+    "_ast.MatchClass.__gt__" => "Return self>value.",
+    "_ast.MatchClass.__hash__" => "Return hash(self).",
+    "_ast.MatchClass.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_ast.MatchClass.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_ast.MatchClass.__le__" => "Return self<=value.",
+    "_ast.MatchClass.__lt__" => "Return self<value.",
+    "_ast.MatchClass.__ne__" => "Return self!=value.",
+    "_ast.MatchClass.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_ast.MatchClass.__reduce_ex__" => "Helper for pickle.",
+    "_ast.MatchClass.__replace__" => "Return a copy of the AST node with new values for the specified fields.",
+    "_ast.MatchClass.__repr__" => "Return repr(self).",
+    "_ast.MatchClass.__setattr__" => "Implement setattr(self, name, value).",
+    "_ast.MatchClass.__sizeof__" => "Size of object in memory, in bytes.",
+    "_ast.MatchClass.__str__" => "Return str(self).",
+    "_ast.MatchClass.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_ast.MatchClass.__weakref__" => "list of weak references to the object",
+    "_ast.MatchMapping" => "MatchMapping(expr* keys, pattern* patterns, identifier? rest)",
+    "_ast.MatchMapping.__delattr__" => "Implement delattr(self, name).",
+    "_ast.MatchMapping.__eq__" => "Return self==value.",
+    "_ast.MatchMapping.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_ast.MatchMapping.__ge__" => "Return self>=value.",
+    "_ast.MatchMapping.__getattribute__" => "Return getattr(self, name).",
+    "_ast.MatchMapping.__getstate__" => "Helper for pickle.",
+    "_ast.MatchMapping.__gt__" => "Return self>value.",
+    "_ast.MatchMapping.__hash__" => "Return hash(self).",
+    "_ast.MatchMapping.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_ast.MatchMapping.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_ast.MatchMapping.__le__" => "Return self<=value.",
+    "_ast.MatchMapping.__lt__" => "Return self<value.",
+    "_ast.MatchMapping.__ne__" => "Return self!=value.",
+    "_ast.MatchMapping.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_ast.MatchMapping.__reduce_ex__" => "Helper for pickle.",
+    "_ast.MatchMapping.__replace__" => "Return a copy of the AST node with new values for the specified fields.",
+    "_ast.MatchMapping.__repr__" => "Return repr(self).",
+    "_ast.MatchMapping.__setattr__" => "Implement setattr(self, name, value).",
+    "_ast.MatchMapping.__sizeof__" => "Size of object in memory, in bytes.",
+    "_ast.MatchMapping.__str__" => "Return str(self).",
+    "_ast.MatchMapping.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_ast.MatchMapping.__weakref__" => "list of weak references to the object",
+    "_ast.MatchOr" => "MatchOr(pattern* patterns)",
+    "_ast.MatchOr.__delattr__" => "Implement delattr(self, name).",
+    "_ast.MatchOr.__eq__" => "Return self==value.",
+    "_ast.MatchOr.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_ast.MatchOr.__ge__" => "Return self>=value.",
+    "_ast.MatchOr.__getattribute__" => "Return getattr(self, name).",
+    "_ast.MatchOr.__getstate__" => "Helper for pickle.",
+    "_ast.MatchOr.__gt__" => "Return self>value.",
+    "_ast.MatchOr.__hash__" => "Return hash(self).",
+    "_ast.MatchOr.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_ast.MatchOr.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_ast.MatchOr.__le__" => "Return self<=value.",
+    "_ast.MatchOr.__lt__" => "Return self<value.",
+    "_ast.MatchOr.__ne__" => "Return self!=value.",
+    "_ast.MatchOr.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_ast.MatchOr.__reduce_ex__" => "Helper for pickle.",
+    "_ast.MatchOr.__replace__" => "Return a copy of the AST node with new values for the specified fields.",
+    "_ast.MatchOr.__repr__" => "Return repr(self).",
+    "_ast.MatchOr.__setattr__" => "Implement setattr(self, name, value).",
+    "_ast.MatchOr.__sizeof__" => "Size of object in memory, in bytes.",
+    "_ast.MatchOr.__str__" => "Return str(self).",
+    "_ast.MatchOr.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_ast.MatchOr.__weakref__" => "list of weak references to the object",
+    "_ast.MatchSequence" => "MatchSequence(pattern* patterns)",
+    "_ast.MatchSequence.__delattr__" => "Implement delattr(self, name).",
+    "_ast.MatchSequence.__eq__" => "Return self==value.",
+    "_ast.MatchSequence.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_ast.MatchSequence.__ge__" => "Return self>=value.",
+    "_ast.MatchSequence.__getattribute__" => "Return getattr(self, name).",
+    "_ast.MatchSequence.__getstate__" => "Helper for pickle.",
+    "_ast.MatchSequence.__gt__" => "Return self>value.",
+    "_ast.MatchSequence.__hash__" => "Return hash(self).",
+    "_ast.MatchSequence.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_ast.MatchSequence.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_ast.MatchSequence.__le__" => "Return self<=value.",
+    "_ast.MatchSequence.__lt__" => "Return self<value.",
+    "_ast.MatchSequence.__ne__" => "Return self!=value.",
+    "_ast.MatchSequence.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_ast.MatchSequence.__reduce_ex__" => "Helper for pickle.",
+    "_ast.MatchSequence.__replace__" => "Return a copy of the AST node with new values for the specified fields.",
+    "_ast.MatchSequence.__repr__" => "Return repr(self).",
+    "_ast.MatchSequence.__setattr__" => "Implement setattr(self, name, value).",
+    "_ast.MatchSequence.__sizeof__" => "Size of object in memory, in bytes.",
+    "_ast.MatchSequence.__str__" => "Return str(self).",
+    "_ast.MatchSequence.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_ast.MatchSequence.__weakref__" => "list of weak references to the object",
+    "_ast.MatchSingleton" => "MatchSingleton(constant value)",
+    "_ast.MatchSingleton.__delattr__" => "Implement delattr(self, name).",
+    "_ast.MatchSingleton.__eq__" => "Return self==value.",
+    "_ast.MatchSingleton.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_ast.MatchSingleton.__ge__" => "Return self>=value.",
+    "_ast.MatchSingleton.__getattribute__" => "Return getattr(self, name).",
+    "_ast.MatchSingleton.__getstate__" => "Helper for pickle.",
+    "_ast.MatchSingleton.__gt__" => "Return self>value.",
+    "_ast.MatchSingleton.__hash__" => "Return hash(self).",
+    "_ast.MatchSingleton.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_ast.MatchSingleton.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_ast.MatchSingleton.__le__" => "Return self<=value.",
+    "_ast.MatchSingleton.__lt__" => "Return self<value.",
+    "_ast.MatchSingleton.__ne__" => "Return self!=value.",
+    "_ast.MatchSingleton.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_ast.MatchSingleton.__reduce_ex__" => "Helper for pickle.",
+    "_ast.MatchSingleton.__replace__" => "Return a copy of the AST node with new values for the specified fields.",
+    "_ast.MatchSingleton.__repr__" => "Return repr(self).",
+    "_ast.MatchSingleton.__setattr__" => "Implement setattr(self, name, value).",
+    "_ast.MatchSingleton.__sizeof__" => "Size of object in memory, in bytes.",
+    "_ast.MatchSingleton.__str__" => "Return str(self).",
+    "_ast.MatchSingleton.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_ast.MatchSingleton.__weakref__" => "list of weak references to the object",
+    "_ast.MatchStar" => "MatchStar(identifier? name)",
+    "_ast.MatchStar.__delattr__" => "Implement delattr(self, name).",
+    "_ast.MatchStar.__eq__" => "Return self==value.",
+    "_ast.MatchStar.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_ast.MatchStar.__ge__" => "Return self>=value.",
+    "_ast.MatchStar.__getattribute__" => "Return getattr(self, name).",
+    "_ast.MatchStar.__getstate__" => "Helper for pickle.",
+    "_ast.MatchStar.__gt__" => "Return self>value.",
+    "_ast.MatchStar.__hash__" => "Return hash(self).",
+    "_ast.MatchStar.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_ast.MatchStar.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_ast.MatchStar.__le__" => "Return self<=value.",
+    "_ast.MatchStar.__lt__" => "Return self<value.",
+    "_ast.MatchStar.__ne__" => "Return self!=value.",
+    "_ast.MatchStar.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_ast.MatchStar.__reduce_ex__" => "Helper for pickle.",
+    "_ast.MatchStar.__replace__" => "Return a copy of the AST node with new values for the specified fields.",
+    "_ast.MatchStar.__repr__" => "Return repr(self).",
+    "_ast.MatchStar.__setattr__" => "Implement setattr(self, name, value).",
+    "_ast.MatchStar.__sizeof__" => "Size of object in memory, in bytes.",
+    "_ast.MatchStar.__str__" => "Return str(self).",
+    "_ast.MatchStar.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_ast.MatchStar.__weakref__" => "list of weak references to the object",
+    "_ast.MatchValue" => "MatchValue(expr value)",
+    "_ast.MatchValue.__delattr__" => "Implement delattr(self, name).",
+    "_ast.MatchValue.__eq__" => "Return self==value.",
+    "_ast.MatchValue.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_ast.MatchValue.__ge__" => "Return self>=value.",
+    "_ast.MatchValue.__getattribute__" => "Return getattr(self, name).",
+    "_ast.MatchValue.__getstate__" => "Helper for pickle.",
+    "_ast.MatchValue.__gt__" => "Return self>value.",
+    "_ast.MatchValue.__hash__" => "Return hash(self).",
+    "_ast.MatchValue.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_ast.MatchValue.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_ast.MatchValue.__le__" => "Return self<=value.",
+    "_ast.MatchValue.__lt__" => "Return self<value.",
+    "_ast.MatchValue.__ne__" => "Return self!=value.",
+    "_ast.MatchValue.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_ast.MatchValue.__reduce_ex__" => "Helper for pickle.",
+    "_ast.MatchValue.__replace__" => "Return a copy of the AST node with new values for the specified fields.",
+    "_ast.MatchValue.__repr__" => "Return repr(self).",
+    "_ast.MatchValue.__setattr__" => "Implement setattr(self, name, value).",
+    "_ast.MatchValue.__sizeof__" => "Size of object in memory, in bytes.",
+    "_ast.MatchValue.__str__" => "Return str(self).",
+    "_ast.MatchValue.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_ast.MatchValue.__weakref__" => "list of weak references to the object",
+    "_ast.Mod" => "Mod",
+    "_ast.Mod.__delattr__" => "Implement delattr(self, name).",
+    "_ast.Mod.__eq__" => "Return self==value.",
+    "_ast.Mod.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_ast.Mod.__ge__" => "Return self>=value.",
+    "_ast.Mod.__getattribute__" => "Return getattr(self, name).",
+    "_ast.Mod.__getstate__" => "Helper for pickle.",
+    "_ast.Mod.__gt__" => "Return self>value.",
+    "_ast.Mod.__hash__" => "Return hash(self).",
+    "_ast.Mod.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_ast.Mod.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_ast.Mod.__le__" => "Return self<=value.",
+    "_ast.Mod.__lt__" => "Return self<value.",
+    "_ast.Mod.__ne__" => "Return self!=value.",
+    "_ast.Mod.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_ast.Mod.__reduce_ex__" => "Helper for pickle.",
+    "_ast.Mod.__replace__" => "Return a copy of the AST node with new values for the specified fields.",
+    "_ast.Mod.__repr__" => "Return repr(self).",
+    "_ast.Mod.__setattr__" => "Implement setattr(self, name, value).",
+    "_ast.Mod.__sizeof__" => "Size of object in memory, in bytes.",
+    "_ast.Mod.__str__" => "Return str(self).",
+    "_ast.Mod.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_ast.Mod.__weakref__" => "list of weak references to the object",
+    "_ast.Module" => "Module(stmt* body, type_ignore* type_ignores)",
+    "_ast.Module.__delattr__" => "Implement delattr(self, name).",
+    "_ast.Module.__eq__" => "Return self==value.",
+    "_ast.Module.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_ast.Module.__ge__" => "Return self>=value.",
+    "_ast.Module.__getattribute__" => "Return getattr(self, name).",
+    "_ast.Module.__getstate__" => "Helper for pickle.",
+    "_ast.Module.__gt__" => "Return self>value.",
+    "_ast.Module.__hash__" => "Return hash(self).",
+    "_ast.Module.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_ast.Module.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_ast.Module.__le__" => "Return self<=value.",
+    "_ast.Module.__lt__" => "Return self<value.",
+    "_ast.Module.__ne__" => "Return self!=value.",
+    "_ast.Module.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_ast.Module.__reduce_ex__" => "Helper for pickle.",
+    "_ast.Module.__replace__" => "Return a copy of the AST node with new values for the specified fields.",
+    "_ast.Module.__repr__" => "Return repr(self).",
+    "_ast.Module.__setattr__" => "Implement setattr(self, name, value).",
+    "_ast.Module.__sizeof__" => "Size of object in memory, in bytes.",
+    "_ast.Module.__str__" => "Return str(self).",
+    "_ast.Module.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_ast.Module.__weakref__" => "list of weak references to the object",
+    "_ast.Mult" => "Mult",
+    "_ast.Mult.__delattr__" => "Implement delattr(self, name).",
+    "_ast.Mult.__eq__" => "Return self==value.",
+    "_ast.Mult.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_ast.Mult.__ge__" => "Return self>=value.",
+    "_ast.Mult.__getattribute__" => "Return getattr(self, name).",
+    "_ast.Mult.__getstate__" => "Helper for pickle.",
+    "_ast.Mult.__gt__" => "Return self>value.",
+    "_ast.Mult.__hash__" => "Return hash(self).",
+    "_ast.Mult.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_ast.Mult.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_ast.Mult.__le__" => "Return self<=value.",
+    "_ast.Mult.__lt__" => "Return self<value.",
+    "_ast.Mult.__ne__" => "Return self!=value.",
+    "_ast.Mult.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_ast.Mult.__reduce_ex__" => "Helper for pickle.",
+    "_ast.Mult.__replace__" => "Return a copy of the AST node with new values for the specified fields.",
+    "_ast.Mult.__repr__" => "Return repr(self).",
+    "_ast.Mult.__setattr__" => "Implement setattr(self, name, value).",
+    "_ast.Mult.__sizeof__" => "Size of object in memory, in bytes.",
+    "_ast.Mult.__str__" => "Return str(self).",
+    "_ast.Mult.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_ast.Mult.__weakref__" => "list of weak references to the object",
+    "_ast.Name" => "Name(identifier id, expr_context ctx)",
+    "_ast.Name.__delattr__" => "Implement delattr(self, name).",
+    "_ast.Name.__eq__" => "Return self==value.",
+    "_ast.Name.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_ast.Name.__ge__" => "Return self>=value.",
+    "_ast.Name.__getattribute__" => "Return getattr(self, name).",
+    "_ast.Name.__getstate__" => "Helper for pickle.",
+    "_ast.Name.__gt__" => "Return self>value.",
+    "_ast.Name.__hash__" => "Return hash(self).",
+    "_ast.Name.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_ast.Name.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_ast.Name.__le__" => "Return self<=value.",
+    "_ast.Name.__lt__" => "Return self<value.",
+    "_ast.Name.__ne__" => "Return self!=value.",
+    "_ast.Name.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_ast.Name.__reduce_ex__" => "Helper for pickle.",
+    "_ast.Name.__replace__" => "Return a copy of the AST node with new values for the specified fields.",
+    "_ast.Name.__repr__" => "Return repr(self).",
+    "_ast.Name.__setattr__" => "Implement setattr(self, name, value).",
+    "_ast.Name.__sizeof__" => "Size of object in memory, in bytes.",
+    "_ast.Name.__str__" => "Return str(self).",
+    "_ast.Name.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_ast.Name.__weakref__" => "list of weak references to the object",
+    "_ast.NamedExpr" => "NamedExpr(expr target, expr value)",
+    "_ast.NamedExpr.__delattr__" => "Implement delattr(self, name).",
+    "_ast.NamedExpr.__eq__" => "Return self==value.",
+    "_ast.NamedExpr.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_ast.NamedExpr.__ge__" => "Return self>=value.",
+    "_ast.NamedExpr.__getattribute__" => "Return getattr(self, name).",
+    "_ast.NamedExpr.__getstate__" => "Helper for pickle.",
+    "_ast.NamedExpr.__gt__" => "Return self>value.",
+    "_ast.NamedExpr.__hash__" => "Return hash(self).",
+    "_ast.NamedExpr.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_ast.NamedExpr.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_ast.NamedExpr.__le__" => "Return self<=value.",
+    "_ast.NamedExpr.__lt__" => "Return self<value.",
+    "_ast.NamedExpr.__ne__" => "Return self!=value.",
+    "_ast.NamedExpr.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_ast.NamedExpr.__reduce_ex__" => "Helper for pickle.",
+    "_ast.NamedExpr.__replace__" => "Return a copy of the AST node with new values for the specified fields.",
+    "_ast.NamedExpr.__repr__" => "Return repr(self).",
+    "_ast.NamedExpr.__setattr__" => "Implement setattr(self, name, value).",
+    "_ast.NamedExpr.__sizeof__" => "Size of object in memory, in bytes.",
+    "_ast.NamedExpr.__str__" => "Return str(self).",
+    "_ast.NamedExpr.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_ast.NamedExpr.__weakref__" => "list of weak references to the object",
+    "_ast.Nonlocal" => "Nonlocal(identifier* names)",
+    "_ast.Nonlocal.__delattr__" => "Implement delattr(self, name).",
+    "_ast.Nonlocal.__eq__" => "Return self==value.",
+    "_ast.Nonlocal.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_ast.Nonlocal.__ge__" => "Return self>=value.",
+    "_ast.Nonlocal.__getattribute__" => "Return getattr(self, name).",
+    "_ast.Nonlocal.__getstate__" => "Helper for pickle.",
+    "_ast.Nonlocal.__gt__" => "Return self>value.",
+    "_ast.Nonlocal.__hash__" => "Return hash(self).",
+    "_ast.Nonlocal.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_ast.Nonlocal.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_ast.Nonlocal.__le__" => "Return self<=value.",
+    "_ast.Nonlocal.__lt__" => "Return self<value.",
+    "_ast.Nonlocal.__ne__" => "Return self!=value.",
+    "_ast.Nonlocal.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_ast.Nonlocal.__reduce_ex__" => "Helper for pickle.",
+    "_ast.Nonlocal.__replace__" => "Return a copy of the AST node with new values for the specified fields.",
+    "_ast.Nonlocal.__repr__" => "Return repr(self).",
+    "_ast.Nonlocal.__setattr__" => "Implement setattr(self, name, value).",
+    "_ast.Nonlocal.__sizeof__" => "Size of object in memory, in bytes.",
+    "_ast.Nonlocal.__str__" => "Return str(self).",
+    "_ast.Nonlocal.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_ast.Nonlocal.__weakref__" => "list of weak references to the object",
+    "_ast.Not" => "Not",
+    "_ast.Not.__delattr__" => "Implement delattr(self, name).",
+    "_ast.Not.__eq__" => "Return self==value.",
+    "_ast.Not.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_ast.Not.__ge__" => "Return self>=value.",
+    "_ast.Not.__getattribute__" => "Return getattr(self, name).",
+    "_ast.Not.__getstate__" => "Helper for pickle.",
+    "_ast.Not.__gt__" => "Return self>value.",
+    "_ast.Not.__hash__" => "Return hash(self).",
+    "_ast.Not.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_ast.Not.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_ast.Not.__le__" => "Return self<=value.",
+    "_ast.Not.__lt__" => "Return self<value.",
+    "_ast.Not.__ne__" => "Return self!=value.",
+    "_ast.Not.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_ast.Not.__reduce_ex__" => "Helper for pickle.",
+    "_ast.Not.__replace__" => "Return a copy of the AST node with new values for the specified fields.",
+    "_ast.Not.__repr__" => "Return repr(self).",
+    "_ast.Not.__setattr__" => "Implement setattr(self, name, value).",
+    "_ast.Not.__sizeof__" => "Size of object in memory, in bytes.",
+    "_ast.Not.__str__" => "Return str(self).",
+    "_ast.Not.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_ast.Not.__weakref__" => "list of weak references to the object",
+    "_ast.NotEq" => "NotEq",
+    "_ast.NotEq.__delattr__" => "Implement delattr(self, name).",
+    "_ast.NotEq.__eq__" => "Return self==value.",
+    "_ast.NotEq.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_ast.NotEq.__ge__" => "Return self>=value.",
+    "_ast.NotEq.__getattribute__" => "Return getattr(self, name).",
+    "_ast.NotEq.__getstate__" => "Helper for pickle.",
+    "_ast.NotEq.__gt__" => "Return self>value.",
+    "_ast.NotEq.__hash__" => "Return hash(self).",
+    "_ast.NotEq.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_ast.NotEq.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_ast.NotEq.__le__" => "Return self<=value.",
+    "_ast.NotEq.__lt__" => "Return self<value.",
+    "_ast.NotEq.__ne__" => "Return self!=value.",
+    "_ast.NotEq.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_ast.NotEq.__reduce_ex__" => "Helper for pickle.",
+    "_ast.NotEq.__replace__" => "Return a copy of the AST node with new values for the specified fields.",
+    "_ast.NotEq.__repr__" => "Return repr(self).",
+    "_ast.NotEq.__setattr__" => "Implement setattr(self, name, value).",
+    "_ast.NotEq.__sizeof__" => "Size of object in memory, in bytes.",
+    "_ast.NotEq.__str__" => "Return str(self).",
+    "_ast.NotEq.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_ast.NotEq.__weakref__" => "list of weak references to the object",
+    "_ast.NotIn" => "NotIn",
+    "_ast.NotIn.__delattr__" => "Implement delattr(self, name).",
+    "_ast.NotIn.__eq__" => "Return self==value.",
+    "_ast.NotIn.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_ast.NotIn.__ge__" => "Return self>=value.",
+    "_ast.NotIn.__getattribute__" => "Return getattr(self, name).",
+    "_ast.NotIn.__getstate__" => "Helper for pickle.",
+    "_ast.NotIn.__gt__" => "Return self>value.",
+    "_ast.NotIn.__hash__" => "Return hash(self).",
+    "_ast.NotIn.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_ast.NotIn.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_ast.NotIn.__le__" => "Return self<=value.",
+    "_ast.NotIn.__lt__" => "Return self<value.",
+    "_ast.NotIn.__ne__" => "Return self!=value.",
+    "_ast.NotIn.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_ast.NotIn.__reduce_ex__" => "Helper for pickle.",
+    "_ast.NotIn.__replace__" => "Return a copy of the AST node with new values for the specified fields.",
+    "_ast.NotIn.__repr__" => "Return repr(self).",
+    "_ast.NotIn.__setattr__" => "Implement setattr(self, name, value).",
+    "_ast.NotIn.__sizeof__" => "Size of object in memory, in bytes.",
+    "_ast.NotIn.__str__" => "Return str(self).",
+    "_ast.NotIn.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_ast.NotIn.__weakref__" => "list of weak references to the object",
+    "_ast.Or" => "Or",
+    "_ast.Or.__delattr__" => "Implement delattr(self, name).",
+    "_ast.Or.__eq__" => "Return self==value.",
+    "_ast.Or.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_ast.Or.__ge__" => "Return self>=value.",
+    "_ast.Or.__getattribute__" => "Return getattr(self, name).",
+    "_ast.Or.__getstate__" => "Helper for pickle.",
+    "_ast.Or.__gt__" => "Return self>value.",
+    "_ast.Or.__hash__" => "Return hash(self).",
+    "_ast.Or.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_ast.Or.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_ast.Or.__le__" => "Return self<=value.",
+    "_ast.Or.__lt__" => "Return self<value.",
+    "_ast.Or.__ne__" => "Return self!=value.",
+    "_ast.Or.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_ast.Or.__reduce_ex__" => "Helper for pickle.",
+    "_ast.Or.__replace__" => "Return a copy of the AST node with new values for the specified fields.",
+    "_ast.Or.__repr__" => "Return repr(self).",
+    "_ast.Or.__setattr__" => "Implement setattr(self, name, value).",
+    "_ast.Or.__sizeof__" => "Size of object in memory, in bytes.",
+    "_ast.Or.__str__" => "Return str(self).",
+    "_ast.Or.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_ast.Or.__weakref__" => "list of weak references to the object",
+    "_ast.ParamSpec" => "ParamSpec(identifier name, expr? default_value)",
+    "_ast.ParamSpec.__delattr__" => "Implement delattr(self, name).",
+    "_ast.ParamSpec.__eq__" => "Return self==value.",
+    "_ast.ParamSpec.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_ast.ParamSpec.__ge__" => "Return self>=value.",
+    "_ast.ParamSpec.__getattribute__" => "Return getattr(self, name).",
+    "_ast.ParamSpec.__getstate__" => "Helper for pickle.",
+    "_ast.ParamSpec.__gt__" => "Return self>value.",
+    "_ast.ParamSpec.__hash__" => "Return hash(self).",
+    "_ast.ParamSpec.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_ast.ParamSpec.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_ast.ParamSpec.__le__" => "Return self<=value.",
+    "_ast.ParamSpec.__lt__" => "Return self<value.",
+    "_ast.ParamSpec.__ne__" => "Return self!=value.",
+    "_ast.ParamSpec.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_ast.ParamSpec.__reduce_ex__" => "Helper for pickle.",
+    "_ast.ParamSpec.__replace__" => "Return a copy of the AST node with new values for the specified fields.",
+    "_ast.ParamSpec.__repr__" => "Return repr(self).",
+    "_ast.ParamSpec.__setattr__" => "Implement setattr(self, name, value).",
+    "_ast.ParamSpec.__sizeof__" => "Size of object in memory, in bytes.",
+    "_ast.ParamSpec.__str__" => "Return str(self).",
+    "_ast.ParamSpec.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_ast.ParamSpec.__weakref__" => "list of weak references to the object",
+    "_ast.Pass" => "Pass",
+    "_ast.Pass.__delattr__" => "Implement delattr(self, name).",
+    "_ast.Pass.__eq__" => "Return self==value.",
+    "_ast.Pass.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_ast.Pass.__ge__" => "Return self>=value.",
+    "_ast.Pass.__getattribute__" => "Return getattr(self, name).",
+    "_ast.Pass.__getstate__" => "Helper for pickle.",
+    "_ast.Pass.__gt__" => "Return self>value.",
+    "_ast.Pass.__hash__" => "Return hash(self).",
+    "_ast.Pass.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_ast.Pass.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_ast.Pass.__le__" => "Return self<=value.",
+    "_ast.Pass.__lt__" => "Return self<value.",
+    "_ast.Pass.__ne__" => "Return self!=value.",
+    "_ast.Pass.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_ast.Pass.__reduce_ex__" => "Helper for pickle.",
+    "_ast.Pass.__replace__" => "Return a copy of the AST node with new values for the specified fields.",
+    "_ast.Pass.__repr__" => "Return repr(self).",
+    "_ast.Pass.__setattr__" => "Implement setattr(self, name, value).",
+    "_ast.Pass.__sizeof__" => "Size of object in memory, in bytes.",
+    "_ast.Pass.__str__" => "Return str(self).",
+    "_ast.Pass.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_ast.Pass.__weakref__" => "list of weak references to the object",
+    "_ast.Pow" => "Pow",
+    "_ast.Pow.__delattr__" => "Implement delattr(self, name).",
+    "_ast.Pow.__eq__" => "Return self==value.",
+    "_ast.Pow.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_ast.Pow.__ge__" => "Return self>=value.",
+    "_ast.Pow.__getattribute__" => "Return getattr(self, name).",
+    "_ast.Pow.__getstate__" => "Helper for pickle.",
+    "_ast.Pow.__gt__" => "Return self>value.",
+    "_ast.Pow.__hash__" => "Return hash(self).",
+    "_ast.Pow.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_ast.Pow.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_ast.Pow.__le__" => "Return self<=value.",
+    "_ast.Pow.__lt__" => "Return self<value.",
+    "_ast.Pow.__ne__" => "Return self!=value.",
+    "_ast.Pow.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_ast.Pow.__reduce_ex__" => "Helper for pickle.",
+    "_ast.Pow.__replace__" => "Return a copy of the AST node with new values for the specified fields.",
+    "_ast.Pow.__repr__" => "Return repr(self).",
+    "_ast.Pow.__setattr__" => "Implement setattr(self, name, value).",
+    "_ast.Pow.__sizeof__" => "Size of object in memory, in bytes.",
+    "_ast.Pow.__str__" => "Return str(self).",
+    "_ast.Pow.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_ast.Pow.__weakref__" => "list of weak references to the object",
+    "_ast.RShift" => "RShift",
+    "_ast.RShift.__delattr__" => "Implement delattr(self, name).",
+    "_ast.RShift.__eq__" => "Return self==value.",
+    "_ast.RShift.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_ast.RShift.__ge__" => "Return self>=value.",
+    "_ast.RShift.__getattribute__" => "Return getattr(self, name).",
+    "_ast.RShift.__getstate__" => "Helper for pickle.",
+    "_ast.RShift.__gt__" => "Return self>value.",
+    "_ast.RShift.__hash__" => "Return hash(self).",
+    "_ast.RShift.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_ast.RShift.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_ast.RShift.__le__" => "Return self<=value.",
+    "_ast.RShift.__lt__" => "Return self<value.",
+    "_ast.RShift.__ne__" => "Return self!=value.",
+    "_ast.RShift.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_ast.RShift.__reduce_ex__" => "Helper for pickle.",
+    "_ast.RShift.__replace__" => "Return a copy of the AST node with new values for the specified fields.",
+    "_ast.RShift.__repr__" => "Return repr(self).",
+    "_ast.RShift.__setattr__" => "Implement setattr(self, name, value).",
+    "_ast.RShift.__sizeof__" => "Size of object in memory, in bytes.",
+    "_ast.RShift.__str__" => "Return str(self).",
+    "_ast.RShift.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_ast.RShift.__weakref__" => "list of weak references to the object",
+    "_ast.Raise" => "Raise(expr? exc, expr? cause)",
+    "_ast.Raise.__delattr__" => "Implement delattr(self, name).",
+    "_ast.Raise.__eq__" => "Return self==value.",
+    "_ast.Raise.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_ast.Raise.__ge__" => "Return self>=value.",
+    "_ast.Raise.__getattribute__" => "Return getattr(self, name).",
+    "_ast.Raise.__getstate__" => "Helper for pickle.",
+    "_ast.Raise.__gt__" => "Return self>value.",
+    "_ast.Raise.__hash__" => "Return hash(self).",
+    "_ast.Raise.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_ast.Raise.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_ast.Raise.__le__" => "Return self<=value.",
+    "_ast.Raise.__lt__" => "Return self<value.",
+    "_ast.Raise.__ne__" => "Return self!=value.",
+    "_ast.Raise.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_ast.Raise.__reduce_ex__" => "Helper for pickle.",
+    "_ast.Raise.__replace__" => "Return a copy of the AST node with new values for the specified fields.",
+    "_ast.Raise.__repr__" => "Return repr(self).",
+    "_ast.Raise.__setattr__" => "Implement setattr(self, name, value).",
+    "_ast.Raise.__sizeof__" => "Size of object in memory, in bytes.",
+    "_ast.Raise.__str__" => "Return str(self).",
+    "_ast.Raise.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_ast.Raise.__weakref__" => "list of weak references to the object",
+    "_ast.Return" => "Return(expr? value)",
+    "_ast.Return.__delattr__" => "Implement delattr(self, name).",
+    "_ast.Return.__eq__" => "Return self==value.",
+    "_ast.Return.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_ast.Return.__ge__" => "Return self>=value.",
+    "_ast.Return.__getattribute__" => "Return getattr(self, name).",
+    "_ast.Return.__getstate__" => "Helper for pickle.",
+    "_ast.Return.__gt__" => "Return self>value.",
+    "_ast.Return.__hash__" => "Return hash(self).",
+    "_ast.Return.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_ast.Return.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_ast.Return.__le__" => "Return self<=value.",
+    "_ast.Return.__lt__" => "Return self<value.",
+    "_ast.Return.__ne__" => "Return self!=value.",
+    "_ast.Return.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_ast.Return.__reduce_ex__" => "Helper for pickle.",
+    "_ast.Return.__replace__" => "Return a copy of the AST node with new values for the specified fields.",
+    "_ast.Return.__repr__" => "Return repr(self).",
+    "_ast.Return.__setattr__" => "Implement setattr(self, name, value).",
+    "_ast.Return.__sizeof__" => "Size of object in memory, in bytes.",
+    "_ast.Return.__str__" => "Return str(self).",
+    "_ast.Return.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_ast.Return.__weakref__" => "list of weak references to the object",
+    "_ast.Set" => "Set(expr* elts)",
+    "_ast.Set.__delattr__" => "Implement delattr(self, name).",
+    "_ast.Set.__eq__" => "Return self==value.",
+    "_ast.Set.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_ast.Set.__ge__" => "Return self>=value.",
+    "_ast.Set.__getattribute__" => "Return getattr(self, name).",
+    "_ast.Set.__getstate__" => "Helper for pickle.",
+    "_ast.Set.__gt__" => "Return self>value.",
+    "_ast.Set.__hash__" => "Return hash(self).",
+    "_ast.Set.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_ast.Set.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_ast.Set.__le__" => "Return self<=value.",
+    "_ast.Set.__lt__" => "Return self<value.",
+    "_ast.Set.__ne__" => "Return self!=value.",
+    "_ast.Set.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_ast.Set.__reduce_ex__" => "Helper for pickle.",
+    "_ast.Set.__replace__" => "Return a copy of the AST node with new values for the specified fields.",
+    "_ast.Set.__repr__" => "Return repr(self).",
+    "_ast.Set.__setattr__" => "Implement setattr(self, name, value).",
+    "_ast.Set.__sizeof__" => "Size of object in memory, in bytes.",
+    "_ast.Set.__str__" => "Return str(self).",
+    "_ast.Set.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_ast.Set.__weakref__" => "list of weak references to the object",
+    "_ast.SetComp" => "SetComp(expr elt, comprehension* generators)",
+    "_ast.SetComp.__delattr__" => "Implement delattr(self, name).",
+    "_ast.SetComp.__eq__" => "Return self==value.",
+    "_ast.SetComp.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_ast.SetComp.__ge__" => "Return self>=value.",
+    "_ast.SetComp.__getattribute__" => "Return getattr(self, name).",
+    "_ast.SetComp.__getstate__" => "Helper for pickle.",
+    "_ast.SetComp.__gt__" => "Return self>value.",
+    "_ast.SetComp.__hash__" => "Return hash(self).",
+    "_ast.SetComp.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_ast.SetComp.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_ast.SetComp.__le__" => "Return self<=value.",
+    "_ast.SetComp.__lt__" => "Return self<value.",
+    "_ast.SetComp.__ne__" => "Return self!=value.",
+    "_ast.SetComp.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_ast.SetComp.__reduce_ex__" => "Helper for pickle.",
+    "_ast.SetComp.__replace__" => "Return a copy of the AST node with new values for the specified fields.",
+    "_ast.SetComp.__repr__" => "Return repr(self).",
+    "_ast.SetComp.__setattr__" => "Implement setattr(self, name, value).",
+    "_ast.SetComp.__sizeof__" => "Size of object in memory, in bytes.",
+    "_ast.SetComp.__str__" => "Return str(self).",
+    "_ast.SetComp.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_ast.SetComp.__weakref__" => "list of weak references to the object",
+    "_ast.Slice" => "Slice(expr? lower, expr? upper, expr? step)",
+    "_ast.Slice.__delattr__" => "Implement delattr(self, name).",
+    "_ast.Slice.__eq__" => "Return self==value.",
+    "_ast.Slice.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_ast.Slice.__ge__" => "Return self>=value.",
+    "_ast.Slice.__getattribute__" => "Return getattr(self, name).",
+    "_ast.Slice.__getstate__" => "Helper for pickle.",
+    "_ast.Slice.__gt__" => "Return self>value.",
+    "_ast.Slice.__hash__" => "Return hash(self).",
+    "_ast.Slice.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_ast.Slice.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_ast.Slice.__le__" => "Return self<=value.",
+    "_ast.Slice.__lt__" => "Return self<value.",
+    "_ast.Slice.__ne__" => "Return self!=value.",
+    "_ast.Slice.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_ast.Slice.__reduce_ex__" => "Helper for pickle.",
+    "_ast.Slice.__replace__" => "Return a copy of the AST node with new values for the specified fields.",
+    "_ast.Slice.__repr__" => "Return repr(self).",
+    "_ast.Slice.__setattr__" => "Implement setattr(self, name, value).",
+    "_ast.Slice.__sizeof__" => "Size of object in memory, in bytes.",
+    "_ast.Slice.__str__" => "Return str(self).",
+    "_ast.Slice.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_ast.Slice.__weakref__" => "list of weak references to the object",
+    "_ast.Starred" => "Starred(expr value, expr_context ctx)",
+    "_ast.Starred.__delattr__" => "Implement delattr(self, name).",
+    "_ast.Starred.__eq__" => "Return self==value.",
+    "_ast.Starred.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_ast.Starred.__ge__" => "Return self>=value.",
+    "_ast.Starred.__getattribute__" => "Return getattr(self, name).",
+    "_ast.Starred.__getstate__" => "Helper for pickle.",
+    "_ast.Starred.__gt__" => "Return self>value.",
+    "_ast.Starred.__hash__" => "Return hash(self).",
+    "_ast.Starred.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_ast.Starred.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_ast.Starred.__le__" => "Return self<=value.",
+    "_ast.Starred.__lt__" => "Return self<value.",
+    "_ast.Starred.__ne__" => "Return self!=value.",
+    "_ast.Starred.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_ast.Starred.__reduce_ex__" => "Helper for pickle.",
+    "_ast.Starred.__replace__" => "Return a copy of the AST node with new values for the specified fields.",
+    "_ast.Starred.__repr__" => "Return repr(self).",
+    "_ast.Starred.__setattr__" => "Implement setattr(self, name, value).",
+    "_ast.Starred.__sizeof__" => "Size of object in memory, in bytes.",
+    "_ast.Starred.__str__" => "Return str(self).",
+    "_ast.Starred.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_ast.Starred.__weakref__" => "list of weak references to the object",
+    "_ast.Store" => "Store",
+    "_ast.Store.__delattr__" => "Implement delattr(self, name).",
+    "_ast.Store.__eq__" => "Return self==value.",
+    "_ast.Store.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_ast.Store.__ge__" => "Return self>=value.",
+    "_ast.Store.__getattribute__" => "Return getattr(self, name).",
+    "_ast.Store.__getstate__" => "Helper for pickle.",
+    "_ast.Store.__gt__" => "Return self>value.",
+    "_ast.Store.__hash__" => "Return hash(self).",
+    "_ast.Store.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_ast.Store.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_ast.Store.__le__" => "Return self<=value.",
+    "_ast.Store.__lt__" => "Return self<value.",
+    "_ast.Store.__ne__" => "Return self!=value.",
+    "_ast.Store.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_ast.Store.__reduce_ex__" => "Helper for pickle.",
+    "_ast.Store.__replace__" => "Return a copy of the AST node with new values for the specified fields.",
+    "_ast.Store.__repr__" => "Return repr(self).",
+    "_ast.Store.__setattr__" => "Implement setattr(self, name, value).",
+    "_ast.Store.__sizeof__" => "Size of object in memory, in bytes.",
+    "_ast.Store.__str__" => "Return str(self).",
+    "_ast.Store.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_ast.Store.__weakref__" => "list of weak references to the object",
+    "_ast.Sub" => "Sub",
+    "_ast.Sub.__delattr__" => "Implement delattr(self, name).",
+    "_ast.Sub.__eq__" => "Return self==value.",
+    "_ast.Sub.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_ast.Sub.__ge__" => "Return self>=value.",
+    "_ast.Sub.__getattribute__" => "Return getattr(self, name).",
+    "_ast.Sub.__getstate__" => "Helper for pickle.",
+    "_ast.Sub.__gt__" => "Return self>value.",
+    "_ast.Sub.__hash__" => "Return hash(self).",
+    "_ast.Sub.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_ast.Sub.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_ast.Sub.__le__" => "Return self<=value.",
+    "_ast.Sub.__lt__" => "Return self<value.",
+    "_ast.Sub.__ne__" => "Return self!=value.",
+    "_ast.Sub.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_ast.Sub.__reduce_ex__" => "Helper for pickle.",
+    "_ast.Sub.__replace__" => "Return a copy of the AST node with new values for the specified fields.",
+    "_ast.Sub.__repr__" => "Return repr(self).",
+    "_ast.Sub.__setattr__" => "Implement setattr(self, name, value).",
+    "_ast.Sub.__sizeof__" => "Size of object in memory, in bytes.",
+    "_ast.Sub.__str__" => "Return str(self).",
+    "_ast.Sub.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_ast.Sub.__weakref__" => "list of weak references to the object",
+    "_ast.Subscript" => "Subscript(expr value, expr slice, expr_context ctx)",
+    "_ast.Subscript.__delattr__" => "Implement delattr(self, name).",
+    "_ast.Subscript.__eq__" => "Return self==value.",
+    "_ast.Subscript.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_ast.Subscript.__ge__" => "Return self>=value.",
+    "_ast.Subscript.__getattribute__" => "Return getattr(self, name).",
+    "_ast.Subscript.__getstate__" => "Helper for pickle.",
+    "_ast.Subscript.__gt__" => "Return self>value.",
+    "_ast.Subscript.__hash__" => "Return hash(self).",
+    "_ast.Subscript.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_ast.Subscript.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_ast.Subscript.__le__" => "Return self<=value.",
+    "_ast.Subscript.__lt__" => "Return self<value.",
+    "_ast.Subscript.__ne__" => "Return self!=value.",
+    "_ast.Subscript.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_ast.Subscript.__reduce_ex__" => "Helper for pickle.",
+    "_ast.Subscript.__replace__" => "Return a copy of the AST node with new values for the specified fields.",
+    "_ast.Subscript.__repr__" => "Return repr(self).",
+    "_ast.Subscript.__setattr__" => "Implement setattr(self, name, value).",
+    "_ast.Subscript.__sizeof__" => "Size of object in memory, in bytes.",
+    "_ast.Subscript.__str__" => "Return str(self).",
+    "_ast.Subscript.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_ast.Subscript.__weakref__" => "list of weak references to the object",
+    "_ast.TemplateStr" => "TemplateStr(expr* values)",
+    "_ast.TemplateStr.__delattr__" => "Implement delattr(self, name).",
+    "_ast.TemplateStr.__eq__" => "Return self==value.",
+    "_ast.TemplateStr.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_ast.TemplateStr.__ge__" => "Return self>=value.",
+    "_ast.TemplateStr.__getattribute__" => "Return getattr(self, name).",
+    "_ast.TemplateStr.__getstate__" => "Helper for pickle.",
+    "_ast.TemplateStr.__gt__" => "Return self>value.",
+    "_ast.TemplateStr.__hash__" => "Return hash(self).",
+    "_ast.TemplateStr.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_ast.TemplateStr.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_ast.TemplateStr.__le__" => "Return self<=value.",
+    "_ast.TemplateStr.__lt__" => "Return self<value.",
+    "_ast.TemplateStr.__ne__" => "Return self!=value.",
+    "_ast.TemplateStr.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_ast.TemplateStr.__reduce_ex__" => "Helper for pickle.",
+    "_ast.TemplateStr.__replace__" => "Return a copy of the AST node with new values for the specified fields.",
+    "_ast.TemplateStr.__repr__" => "Return repr(self).",
+    "_ast.TemplateStr.__setattr__" => "Implement setattr(self, name, value).",
+    "_ast.TemplateStr.__sizeof__" => "Size of object in memory, in bytes.",
+    "_ast.TemplateStr.__str__" => "Return str(self).",
+    "_ast.TemplateStr.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_ast.TemplateStr.__weakref__" => "list of weak references to the object",
+    "_ast.Try" => "Try(stmt* body, excepthandler* handlers, stmt* orelse, stmt* finalbody)",
+    "_ast.Try.__delattr__" => "Implement delattr(self, name).",
+    "_ast.Try.__eq__" => "Return self==value.",
+    "_ast.Try.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_ast.Try.__ge__" => "Return self>=value.",
+    "_ast.Try.__getattribute__" => "Return getattr(self, name).",
+    "_ast.Try.__getstate__" => "Helper for pickle.",
+    "_ast.Try.__gt__" => "Return self>value.",
+    "_ast.Try.__hash__" => "Return hash(self).",
+    "_ast.Try.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_ast.Try.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_ast.Try.__le__" => "Return self<=value.",
+    "_ast.Try.__lt__" => "Return self<value.",
+    "_ast.Try.__ne__" => "Return self!=value.",
+    "_ast.Try.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_ast.Try.__reduce_ex__" => "Helper for pickle.",
+    "_ast.Try.__replace__" => "Return a copy of the AST node with new values for the specified fields.",
+    "_ast.Try.__repr__" => "Return repr(self).",
+    "_ast.Try.__setattr__" => "Implement setattr(self, name, value).",
+    "_ast.Try.__sizeof__" => "Size of object in memory, in bytes.",
+    "_ast.Try.__str__" => "Return str(self).",
+    "_ast.Try.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_ast.Try.__weakref__" => "list of weak references to the object",
+    "_ast.TryStar" => "TryStar(stmt* body, excepthandler* handlers, stmt* orelse, stmt* finalbody)",
+    "_ast.TryStar.__delattr__" => "Implement delattr(self, name).",
+    "_ast.TryStar.__eq__" => "Return self==value.",
+    "_ast.TryStar.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_ast.TryStar.__ge__" => "Return self>=value.",
+    "_ast.TryStar.__getattribute__" => "Return getattr(self, name).",
+    "_ast.TryStar.__getstate__" => "Helper for pickle.",
+    "_ast.TryStar.__gt__" => "Return self>value.",
+    "_ast.TryStar.__hash__" => "Return hash(self).",
+    "_ast.TryStar.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_ast.TryStar.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_ast.TryStar.__le__" => "Return self<=value.",
+    "_ast.TryStar.__lt__" => "Return self<value.",
+    "_ast.TryStar.__ne__" => "Return self!=value.",
+    "_ast.TryStar.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_ast.TryStar.__reduce_ex__" => "Helper for pickle.",
+    "_ast.TryStar.__replace__" => "Return a copy of the AST node with new values for the specified fields.",
+    "_ast.TryStar.__repr__" => "Return repr(self).",
+    "_ast.TryStar.__setattr__" => "Implement setattr(self, name, value).",
+    "_ast.TryStar.__sizeof__" => "Size of object in memory, in bytes.",
+    "_ast.TryStar.__str__" => "Return str(self).",
+    "_ast.TryStar.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_ast.TryStar.__weakref__" => "list of weak references to the object",
+    "_ast.Tuple" => "Tuple(expr* elts, expr_context ctx)",
+    "_ast.Tuple.__delattr__" => "Implement delattr(self, name).",
+    "_ast.Tuple.__eq__" => "Return self==value.",
+    "_ast.Tuple.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_ast.Tuple.__ge__" => "Return self>=value.",
+    "_ast.Tuple.__getattribute__" => "Return getattr(self, name).",
+    "_ast.Tuple.__getstate__" => "Helper for pickle.",
+    "_ast.Tuple.__gt__" => "Return self>value.",
+    "_ast.Tuple.__hash__" => "Return hash(self).",
+    "_ast.Tuple.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_ast.Tuple.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_ast.Tuple.__le__" => "Return self<=value.",
+    "_ast.Tuple.__lt__" => "Return self<value.",
+    "_ast.Tuple.__ne__" => "Return self!=value.",
+    "_ast.Tuple.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_ast.Tuple.__reduce_ex__" => "Helper for pickle.",
+    "_ast.Tuple.__replace__" => "Return a copy of the AST node with new values for the specified fields.",
+    "_ast.Tuple.__repr__" => "Return repr(self).",
+    "_ast.Tuple.__setattr__" => "Implement setattr(self, name, value).",
+    "_ast.Tuple.__sizeof__" => "Size of object in memory, in bytes.",
+    "_ast.Tuple.__str__" => "Return str(self).",
+    "_ast.Tuple.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_ast.Tuple.__weakref__" => "list of weak references to the object",
+    "_ast.Tuple.dims" => "Deprecated. Use elts instead.",
+    "_ast.TypeAlias" => "TypeAlias(expr name, type_param* type_params, expr value)",
+    "_ast.TypeAlias.__delattr__" => "Implement delattr(self, name).",
+    "_ast.TypeAlias.__eq__" => "Return self==value.",
+    "_ast.TypeAlias.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_ast.TypeAlias.__ge__" => "Return self>=value.",
+    "_ast.TypeAlias.__getattribute__" => "Return getattr(self, name).",
+    "_ast.TypeAlias.__getstate__" => "Helper for pickle.",
+    "_ast.TypeAlias.__gt__" => "Return self>value.",
+    "_ast.TypeAlias.__hash__" => "Return hash(self).",
+    "_ast.TypeAlias.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_ast.TypeAlias.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_ast.TypeAlias.__le__" => "Return self<=value.",
+    "_ast.TypeAlias.__lt__" => "Return self<value.",
+    "_ast.TypeAlias.__ne__" => "Return self!=value.",
+    "_ast.TypeAlias.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_ast.TypeAlias.__reduce_ex__" => "Helper for pickle.",
+    "_ast.TypeAlias.__replace__" => "Return a copy of the AST node with new values for the specified fields.",
+    "_ast.TypeAlias.__repr__" => "Return repr(self).",
+    "_ast.TypeAlias.__setattr__" => "Implement setattr(self, name, value).",
+    "_ast.TypeAlias.__sizeof__" => "Size of object in memory, in bytes.",
+    "_ast.TypeAlias.__str__" => "Return str(self).",
+    "_ast.TypeAlias.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_ast.TypeAlias.__weakref__" => "list of weak references to the object",
+    "_ast.TypeIgnore" => "TypeIgnore(int lineno, string tag)",
+    "_ast.TypeIgnore.__delattr__" => "Implement delattr(self, name).",
+    "_ast.TypeIgnore.__eq__" => "Return self==value.",
+    "_ast.TypeIgnore.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_ast.TypeIgnore.__ge__" => "Return self>=value.",
+    "_ast.TypeIgnore.__getattribute__" => "Return getattr(self, name).",
+    "_ast.TypeIgnore.__getstate__" => "Helper for pickle.",
+    "_ast.TypeIgnore.__gt__" => "Return self>value.",
+    "_ast.TypeIgnore.__hash__" => "Return hash(self).",
+    "_ast.TypeIgnore.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_ast.TypeIgnore.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_ast.TypeIgnore.__le__" => "Return self<=value.",
+    "_ast.TypeIgnore.__lt__" => "Return self<value.",
+    "_ast.TypeIgnore.__ne__" => "Return self!=value.",
+    "_ast.TypeIgnore.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_ast.TypeIgnore.__reduce_ex__" => "Helper for pickle.",
+    "_ast.TypeIgnore.__replace__" => "Return a copy of the AST node with new values for the specified fields.",
+    "_ast.TypeIgnore.__repr__" => "Return repr(self).",
+    "_ast.TypeIgnore.__setattr__" => "Implement setattr(self, name, value).",
+    "_ast.TypeIgnore.__sizeof__" => "Size of object in memory, in bytes.",
+    "_ast.TypeIgnore.__str__" => "Return str(self).",
+    "_ast.TypeIgnore.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_ast.TypeIgnore.__weakref__" => "list of weak references to the object",
+    "_ast.TypeVar" => "TypeVar(identifier name, expr? bound, expr? default_value)",
+    "_ast.TypeVar.__delattr__" => "Implement delattr(self, name).",
+    "_ast.TypeVar.__eq__" => "Return self==value.",
+    "_ast.TypeVar.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_ast.TypeVar.__ge__" => "Return self>=value.",
+    "_ast.TypeVar.__getattribute__" => "Return getattr(self, name).",
+    "_ast.TypeVar.__getstate__" => "Helper for pickle.",
+    "_ast.TypeVar.__gt__" => "Return self>value.",
+    "_ast.TypeVar.__hash__" => "Return hash(self).",
+    "_ast.TypeVar.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_ast.TypeVar.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_ast.TypeVar.__le__" => "Return self<=value.",
+    "_ast.TypeVar.__lt__" => "Return self<value.",
+    "_ast.TypeVar.__ne__" => "Return self!=value.",
+    "_ast.TypeVar.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_ast.TypeVar.__reduce_ex__" => "Helper for pickle.",
+    "_ast.TypeVar.__replace__" => "Return a copy of the AST node with new values for the specified fields.",
+    "_ast.TypeVar.__repr__" => "Return repr(self).",
+    "_ast.TypeVar.__setattr__" => "Implement setattr(self, name, value).",
+    "_ast.TypeVar.__sizeof__" => "Size of object in memory, in bytes.",
+    "_ast.TypeVar.__str__" => "Return str(self).",
+    "_ast.TypeVar.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_ast.TypeVar.__weakref__" => "list of weak references to the object",
+    "_ast.TypeVarTuple" => "TypeVarTuple(identifier name, expr? default_value)",
+    "_ast.TypeVarTuple.__delattr__" => "Implement delattr(self, name).",
+    "_ast.TypeVarTuple.__eq__" => "Return self==value.",
+    "_ast.TypeVarTuple.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_ast.TypeVarTuple.__ge__" => "Return self>=value.",
+    "_ast.TypeVarTuple.__getattribute__" => "Return getattr(self, name).",
+    "_ast.TypeVarTuple.__getstate__" => "Helper for pickle.",
+    "_ast.TypeVarTuple.__gt__" => "Return self>value.",
+    "_ast.TypeVarTuple.__hash__" => "Return hash(self).",
+    "_ast.TypeVarTuple.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_ast.TypeVarTuple.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_ast.TypeVarTuple.__le__" => "Return self<=value.",
+    "_ast.TypeVarTuple.__lt__" => "Return self<value.",
+    "_ast.TypeVarTuple.__ne__" => "Return self!=value.",
+    "_ast.TypeVarTuple.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_ast.TypeVarTuple.__reduce_ex__" => "Helper for pickle.",
+    "_ast.TypeVarTuple.__replace__" => "Return a copy of the AST node with new values for the specified fields.",
+    "_ast.TypeVarTuple.__repr__" => "Return repr(self).",
+    "_ast.TypeVarTuple.__setattr__" => "Implement setattr(self, name, value).",
+    "_ast.TypeVarTuple.__sizeof__" => "Size of object in memory, in bytes.",
+    "_ast.TypeVarTuple.__str__" => "Return str(self).",
+    "_ast.TypeVarTuple.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_ast.TypeVarTuple.__weakref__" => "list of weak references to the object",
+    "_ast.UAdd" => "UAdd",
+    "_ast.UAdd.__delattr__" => "Implement delattr(self, name).",
+    "_ast.UAdd.__eq__" => "Return self==value.",
+    "_ast.UAdd.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_ast.UAdd.__ge__" => "Return self>=value.",
+    "_ast.UAdd.__getattribute__" => "Return getattr(self, name).",
+    "_ast.UAdd.__getstate__" => "Helper for pickle.",
+    "_ast.UAdd.__gt__" => "Return self>value.",
+    "_ast.UAdd.__hash__" => "Return hash(self).",
+    "_ast.UAdd.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_ast.UAdd.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_ast.UAdd.__le__" => "Return self<=value.",
+    "_ast.UAdd.__lt__" => "Return self<value.",
+    "_ast.UAdd.__ne__" => "Return self!=value.",
+    "_ast.UAdd.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_ast.UAdd.__reduce_ex__" => "Helper for pickle.",
+    "_ast.UAdd.__replace__" => "Return a copy of the AST node with new values for the specified fields.",
+    "_ast.UAdd.__repr__" => "Return repr(self).",
+    "_ast.UAdd.__setattr__" => "Implement setattr(self, name, value).",
+    "_ast.UAdd.__sizeof__" => "Size of object in memory, in bytes.",
+    "_ast.UAdd.__str__" => "Return str(self).",
+    "_ast.UAdd.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_ast.UAdd.__weakref__" => "list of weak references to the object",
+    "_ast.USub" => "USub",
+    "_ast.USub.__delattr__" => "Implement delattr(self, name).",
+    "_ast.USub.__eq__" => "Return self==value.",
+    "_ast.USub.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_ast.USub.__ge__" => "Return self>=value.",
+    "_ast.USub.__getattribute__" => "Return getattr(self, name).",
+    "_ast.USub.__getstate__" => "Helper for pickle.",
+    "_ast.USub.__gt__" => "Return self>value.",
+    "_ast.USub.__hash__" => "Return hash(self).",
+    "_ast.USub.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_ast.USub.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_ast.USub.__le__" => "Return self<=value.",
+    "_ast.USub.__lt__" => "Return self<value.",
+    "_ast.USub.__ne__" => "Return self!=value.",
+    "_ast.USub.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_ast.USub.__reduce_ex__" => "Helper for pickle.",
+    "_ast.USub.__replace__" => "Return a copy of the AST node with new values for the specified fields.",
+    "_ast.USub.__repr__" => "Return repr(self).",
+    "_ast.USub.__setattr__" => "Implement setattr(self, name, value).",
+    "_ast.USub.__sizeof__" => "Size of object in memory, in bytes.",
+    "_ast.USub.__str__" => "Return str(self).",
+    "_ast.USub.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_ast.USub.__weakref__" => "list of weak references to the object",
+    "_ast.UnaryOp" => "UnaryOp(unaryop op, expr operand)",
+    "_ast.UnaryOp.__delattr__" => "Implement delattr(self, name).",
+    "_ast.UnaryOp.__eq__" => "Return self==value.",
+    "_ast.UnaryOp.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_ast.UnaryOp.__ge__" => "Return self>=value.",
+    "_ast.UnaryOp.__getattribute__" => "Return getattr(self, name).",
+    "_ast.UnaryOp.__getstate__" => "Helper for pickle.",
+    "_ast.UnaryOp.__gt__" => "Return self>value.",
+    "_ast.UnaryOp.__hash__" => "Return hash(self).",
+    "_ast.UnaryOp.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_ast.UnaryOp.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_ast.UnaryOp.__le__" => "Return self<=value.",
+    "_ast.UnaryOp.__lt__" => "Return self<value.",
+    "_ast.UnaryOp.__ne__" => "Return self!=value.",
+    "_ast.UnaryOp.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_ast.UnaryOp.__reduce_ex__" => "Helper for pickle.",
+    "_ast.UnaryOp.__replace__" => "Return a copy of the AST node with new values for the specified fields.",
+    "_ast.UnaryOp.__repr__" => "Return repr(self).",
+    "_ast.UnaryOp.__setattr__" => "Implement setattr(self, name, value).",
+    "_ast.UnaryOp.__sizeof__" => "Size of object in memory, in bytes.",
+    "_ast.UnaryOp.__str__" => "Return str(self).",
+    "_ast.UnaryOp.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_ast.UnaryOp.__weakref__" => "list of weak references to the object",
+    "_ast.While" => "While(expr test, stmt* body, stmt* orelse)",
+    "_ast.While.__delattr__" => "Implement delattr(self, name).",
+    "_ast.While.__eq__" => "Return self==value.",
+    "_ast.While.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_ast.While.__ge__" => "Return self>=value.",
+    "_ast.While.__getattribute__" => "Return getattr(self, name).",
+    "_ast.While.__getstate__" => "Helper for pickle.",
+    "_ast.While.__gt__" => "Return self>value.",
+    "_ast.While.__hash__" => "Return hash(self).",
+    "_ast.While.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_ast.While.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_ast.While.__le__" => "Return self<=value.",
+    "_ast.While.__lt__" => "Return self<value.",
+    "_ast.While.__ne__" => "Return self!=value.",
+    "_ast.While.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_ast.While.__reduce_ex__" => "Helper for pickle.",
+    "_ast.While.__replace__" => "Return a copy of the AST node with new values for the specified fields.",
+    "_ast.While.__repr__" => "Return repr(self).",
+    "_ast.While.__setattr__" => "Implement setattr(self, name, value).",
+    "_ast.While.__sizeof__" => "Size of object in memory, in bytes.",
+    "_ast.While.__str__" => "Return str(self).",
+    "_ast.While.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_ast.While.__weakref__" => "list of weak references to the object",
+    "_ast.With" => "With(withitem* items, stmt* body, string? type_comment)",
+    "_ast.With.__delattr__" => "Implement delattr(self, name).",
+    "_ast.With.__eq__" => "Return self==value.",
+    "_ast.With.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_ast.With.__ge__" => "Return self>=value.",
+    "_ast.With.__getattribute__" => "Return getattr(self, name).",
+    "_ast.With.__getstate__" => "Helper for pickle.",
+    "_ast.With.__gt__" => "Return self>value.",
+    "_ast.With.__hash__" => "Return hash(self).",
+    "_ast.With.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_ast.With.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_ast.With.__le__" => "Return self<=value.",
+    "_ast.With.__lt__" => "Return self<value.",
+    "_ast.With.__ne__" => "Return self!=value.",
+    "_ast.With.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_ast.With.__reduce_ex__" => "Helper for pickle.",
+    "_ast.With.__replace__" => "Return a copy of the AST node with new values for the specified fields.",
+    "_ast.With.__repr__" => "Return repr(self).",
+    "_ast.With.__setattr__" => "Implement setattr(self, name, value).",
+    "_ast.With.__sizeof__" => "Size of object in memory, in bytes.",
+    "_ast.With.__str__" => "Return str(self).",
+    "_ast.With.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_ast.With.__weakref__" => "list of weak references to the object",
+    "_ast.Yield" => "Yield(expr? value)",
+    "_ast.Yield.__delattr__" => "Implement delattr(self, name).",
+    "_ast.Yield.__eq__" => "Return self==value.",
+    "_ast.Yield.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_ast.Yield.__ge__" => "Return self>=value.",
+    "_ast.Yield.__getattribute__" => "Return getattr(self, name).",
+    "_ast.Yield.__getstate__" => "Helper for pickle.",
+    "_ast.Yield.__gt__" => "Return self>value.",
+    "_ast.Yield.__hash__" => "Return hash(self).",
+    "_ast.Yield.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_ast.Yield.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_ast.Yield.__le__" => "Return self<=value.",
+    "_ast.Yield.__lt__" => "Return self<value.",
+    "_ast.Yield.__ne__" => "Return self!=value.",
+    "_ast.Yield.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_ast.Yield.__reduce_ex__" => "Helper for pickle.",
+    "_ast.Yield.__replace__" => "Return a copy of the AST node with new values for the specified fields.",
+    "_ast.Yield.__repr__" => "Return repr(self).",
+    "_ast.Yield.__setattr__" => "Implement setattr(self, name, value).",
+    "_ast.Yield.__sizeof__" => "Size of object in memory, in bytes.",
+    "_ast.Yield.__str__" => "Return str(self).",
+    "_ast.Yield.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_ast.Yield.__weakref__" => "list of weak references to the object",
+    "_ast.YieldFrom" => "YieldFrom(expr value)",
+    "_ast.YieldFrom.__delattr__" => "Implement delattr(self, name).",
+    "_ast.YieldFrom.__eq__" => "Return self==value.",
+    "_ast.YieldFrom.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_ast.YieldFrom.__ge__" => "Return self>=value.",
+    "_ast.YieldFrom.__getattribute__" => "Return getattr(self, name).",
+    "_ast.YieldFrom.__getstate__" => "Helper for pickle.",
+    "_ast.YieldFrom.__gt__" => "Return self>value.",
+    "_ast.YieldFrom.__hash__" => "Return hash(self).",
+    "_ast.YieldFrom.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_ast.YieldFrom.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_ast.YieldFrom.__le__" => "Return self<=value.",
+    "_ast.YieldFrom.__lt__" => "Return self<value.",
+    "_ast.YieldFrom.__ne__" => "Return self!=value.",
+    "_ast.YieldFrom.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_ast.YieldFrom.__reduce_ex__" => "Helper for pickle.",
+    "_ast.YieldFrom.__replace__" => "Return a copy of the AST node with new values for the specified fields.",
+    "_ast.YieldFrom.__repr__" => "Return repr(self).",
+    "_ast.YieldFrom.__setattr__" => "Implement setattr(self, name, value).",
+    "_ast.YieldFrom.__sizeof__" => "Size of object in memory, in bytes.",
+    "_ast.YieldFrom.__str__" => "Return str(self).",
+    "_ast.YieldFrom.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_ast.YieldFrom.__weakref__" => "list of weak references to the object",
+    "_ast.alias" => "alias(identifier name, identifier? asname)",
+    "_ast.alias.__delattr__" => "Implement delattr(self, name).",
+    "_ast.alias.__eq__" => "Return self==value.",
+    "_ast.alias.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_ast.alias.__ge__" => "Return self>=value.",
+    "_ast.alias.__getattribute__" => "Return getattr(self, name).",
+    "_ast.alias.__getstate__" => "Helper for pickle.",
+    "_ast.alias.__gt__" => "Return self>value.",
+    "_ast.alias.__hash__" => "Return hash(self).",
+    "_ast.alias.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_ast.alias.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_ast.alias.__le__" => "Return self<=value.",
+    "_ast.alias.__lt__" => "Return self<value.",
+    "_ast.alias.__ne__" => "Return self!=value.",
+    "_ast.alias.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_ast.alias.__reduce_ex__" => "Helper for pickle.",
+    "_ast.alias.__replace__" => "Return a copy of the AST node with new values for the specified fields.",
+    "_ast.alias.__repr__" => "Return repr(self).",
+    "_ast.alias.__setattr__" => "Implement setattr(self, name, value).",
+    "_ast.alias.__sizeof__" => "Size of object in memory, in bytes.",
+    "_ast.alias.__str__" => "Return str(self).",
+    "_ast.alias.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_ast.alias.__weakref__" => "list of weak references to the object",
+    "_ast.arg" => "arg(identifier arg, expr? annotation, string? type_comment)",
+    "_ast.arg.__delattr__" => "Implement delattr(self, name).",
+    "_ast.arg.__eq__" => "Return self==value.",
+    "_ast.arg.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_ast.arg.__ge__" => "Return self>=value.",
+    "_ast.arg.__getattribute__" => "Return getattr(self, name).",
+    "_ast.arg.__getstate__" => "Helper for pickle.",
+    "_ast.arg.__gt__" => "Return self>value.",
+    "_ast.arg.__hash__" => "Return hash(self).",
+    "_ast.arg.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_ast.arg.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_ast.arg.__le__" => "Return self<=value.",
+    "_ast.arg.__lt__" => "Return self<value.",
+    "_ast.arg.__ne__" => "Return self!=value.",
+    "_ast.arg.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_ast.arg.__reduce_ex__" => "Helper for pickle.",
+    "_ast.arg.__replace__" => "Return a copy of the AST node with new values for the specified fields.",
+    "_ast.arg.__repr__" => "Return repr(self).",
+    "_ast.arg.__setattr__" => "Implement setattr(self, name, value).",
+    "_ast.arg.__sizeof__" => "Size of object in memory, in bytes.",
+    "_ast.arg.__str__" => "Return str(self).",
+    "_ast.arg.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_ast.arg.__weakref__" => "list of weak references to the object",
+    "_ast.arguments" => "arguments(arg* posonlyargs, arg* args, arg? vararg, arg* kwonlyargs, expr?* kw_defaults, arg? kwarg, expr* defaults)",
+    "_ast.arguments.__delattr__" => "Implement delattr(self, name).",
+    "_ast.arguments.__eq__" => "Return self==value.",
+    "_ast.arguments.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_ast.arguments.__ge__" => "Return self>=value.",
+    "_ast.arguments.__getattribute__" => "Return getattr(self, name).",
+    "_ast.arguments.__getstate__" => "Helper for pickle.",
+    "_ast.arguments.__gt__" => "Return self>value.",
+    "_ast.arguments.__hash__" => "Return hash(self).",
+    "_ast.arguments.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_ast.arguments.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_ast.arguments.__le__" => "Return self<=value.",
+    "_ast.arguments.__lt__" => "Return self<value.",
+    "_ast.arguments.__ne__" => "Return self!=value.",
+    "_ast.arguments.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_ast.arguments.__reduce_ex__" => "Helper for pickle.",
+    "_ast.arguments.__replace__" => "Return a copy of the AST node with new values for the specified fields.",
+    "_ast.arguments.__repr__" => "Return repr(self).",
+    "_ast.arguments.__setattr__" => "Implement setattr(self, name, value).",
+    "_ast.arguments.__sizeof__" => "Size of object in memory, in bytes.",
+    "_ast.arguments.__str__" => "Return str(self).",
+    "_ast.arguments.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_ast.arguments.__weakref__" => "list of weak references to the object",
+    "_ast.boolop" => "boolop = And | Or",
+    "_ast.boolop.__delattr__" => "Implement delattr(self, name).",
+    "_ast.boolop.__eq__" => "Return self==value.",
+    "_ast.boolop.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_ast.boolop.__ge__" => "Return self>=value.",
+    "_ast.boolop.__getattribute__" => "Return getattr(self, name).",
+    "_ast.boolop.__getstate__" => "Helper for pickle.",
+    "_ast.boolop.__gt__" => "Return self>value.",
+    "_ast.boolop.__hash__" => "Return hash(self).",
+    "_ast.boolop.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_ast.boolop.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_ast.boolop.__le__" => "Return self<=value.",
+    "_ast.boolop.__lt__" => "Return self<value.",
+    "_ast.boolop.__ne__" => "Return self!=value.",
+    "_ast.boolop.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_ast.boolop.__reduce_ex__" => "Helper for pickle.",
+    "_ast.boolop.__replace__" => "Return a copy of the AST node with new values for the specified fields.",
+    "_ast.boolop.__repr__" => "Return repr(self).",
+    "_ast.boolop.__setattr__" => "Implement setattr(self, name, value).",
+    "_ast.boolop.__sizeof__" => "Size of object in memory, in bytes.",
+    "_ast.boolop.__str__" => "Return str(self).",
+    "_ast.boolop.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_ast.boolop.__weakref__" => "list of weak references to the object",
+    "_ast.cmpop" => "cmpop = Eq | NotEq | Lt | LtE | Gt | GtE | Is | IsNot | In | NotIn",
+    "_ast.cmpop.__delattr__" => "Implement delattr(self, name).",
+    "_ast.cmpop.__eq__" => "Return self==value.",
+    "_ast.cmpop.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_ast.cmpop.__ge__" => "Return self>=value.",
+    "_ast.cmpop.__getattribute__" => "Return getattr(self, name).",
+    "_ast.cmpop.__getstate__" => "Helper for pickle.",
+    "_ast.cmpop.__gt__" => "Return self>value.",
+    "_ast.cmpop.__hash__" => "Return hash(self).",
+    "_ast.cmpop.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_ast.cmpop.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_ast.cmpop.__le__" => "Return self<=value.",
+    "_ast.cmpop.__lt__" => "Return self<value.",
+    "_ast.cmpop.__ne__" => "Return self!=value.",
+    "_ast.cmpop.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_ast.cmpop.__reduce_ex__" => "Helper for pickle.",
+    "_ast.cmpop.__replace__" => "Return a copy of the AST node with new values for the specified fields.",
+    "_ast.cmpop.__repr__" => "Return repr(self).",
+    "_ast.cmpop.__setattr__" => "Implement setattr(self, name, value).",
+    "_ast.cmpop.__sizeof__" => "Size of object in memory, in bytes.",
+    "_ast.cmpop.__str__" => "Return str(self).",
+    "_ast.cmpop.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_ast.cmpop.__weakref__" => "list of weak references to the object",
+    "_ast.comprehension" => "comprehension(expr target, expr iter, expr* ifs, int is_async)",
+    "_ast.comprehension.__delattr__" => "Implement delattr(self, name).",
+    "_ast.comprehension.__eq__" => "Return self==value.",
+    "_ast.comprehension.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_ast.comprehension.__ge__" => "Return self>=value.",
+    "_ast.comprehension.__getattribute__" => "Return getattr(self, name).",
+    "_ast.comprehension.__getstate__" => "Helper for pickle.",
+    "_ast.comprehension.__gt__" => "Return self>value.",
+    "_ast.comprehension.__hash__" => "Return hash(self).",
+    "_ast.comprehension.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_ast.comprehension.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_ast.comprehension.__le__" => "Return self<=value.",
+    "_ast.comprehension.__lt__" => "Return self<value.",
+    "_ast.comprehension.__ne__" => "Return self!=value.",
+    "_ast.comprehension.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_ast.comprehension.__reduce_ex__" => "Helper for pickle.",
+    "_ast.comprehension.__replace__" => "Return a copy of the AST node with new values for the specified fields.",
+    "_ast.comprehension.__repr__" => "Return repr(self).",
+    "_ast.comprehension.__setattr__" => "Implement setattr(self, name, value).",
+    "_ast.comprehension.__sizeof__" => "Size of object in memory, in bytes.",
+    "_ast.comprehension.__str__" => "Return str(self).",
+    "_ast.comprehension.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_ast.comprehension.__weakref__" => "list of weak references to the object",
+    "_ast.excepthandler" => "excepthandler = ExceptHandler(expr? type, identifier? name, stmt* body)",
+    "_ast.excepthandler.__delattr__" => "Implement delattr(self, name).",
+    "_ast.excepthandler.__eq__" => "Return self==value.",
+    "_ast.excepthandler.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_ast.excepthandler.__ge__" => "Return self>=value.",
+    "_ast.excepthandler.__getattribute__" => "Return getattr(self, name).",
+    "_ast.excepthandler.__getstate__" => "Helper for pickle.",
+    "_ast.excepthandler.__gt__" => "Return self>value.",
+    "_ast.excepthandler.__hash__" => "Return hash(self).",
+    "_ast.excepthandler.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_ast.excepthandler.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_ast.excepthandler.__le__" => "Return self<=value.",
+    "_ast.excepthandler.__lt__" => "Return self<value.",
+    "_ast.excepthandler.__ne__" => "Return self!=value.",
+    "_ast.excepthandler.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_ast.excepthandler.__reduce_ex__" => "Helper for pickle.",
+    "_ast.excepthandler.__replace__" => "Return a copy of the AST node with new values for the specified fields.",
+    "_ast.excepthandler.__repr__" => "Return repr(self).",
+    "_ast.excepthandler.__setattr__" => "Implement setattr(self, name, value).",
+    "_ast.excepthandler.__sizeof__" => "Size of object in memory, in bytes.",
+    "_ast.excepthandler.__str__" => "Return str(self).",
+    "_ast.excepthandler.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_ast.excepthandler.__weakref__" => "list of weak references to the object",
+    "_ast.expr" => "expr = BoolOp(boolop op, expr* values)\n     | NamedExpr(expr target, expr value)\n     | BinOp(expr left, operator op, expr right)\n     | UnaryOp(unaryop op, expr operand)\n     | Lambda(arguments args, expr body)\n     | IfExp(expr test, expr body, expr orelse)\n     | Dict(expr?* keys, expr* values)\n     | Set(expr* elts)\n     | ListComp(expr elt, comprehension* generators)\n     | SetComp(expr elt, comprehension* generators)\n     | DictComp(expr key, expr value, comprehension* generators)\n     | GeneratorExp(expr elt, comprehension* generators)\n     | Await(expr value)\n     | Yield(expr? value)\n     | YieldFrom(expr value)\n     | Compare(expr left, cmpop* ops, expr* comparators)\n     | Call(expr func, expr* args, keyword* keywords)\n     | FormattedValue(expr value, int conversion, expr? format_spec)\n     | Interpolation(expr value, constant str, int conversion, expr? format_spec)\n     | JoinedStr(expr* values)\n     | TemplateStr(expr* values)\n     | Constant(constant value, string? kind)\n     | Attribute(expr value, identifier attr, expr_context ctx)\n     | Subscript(expr value, expr slice, expr_context ctx)\n     | Starred(expr value, expr_context ctx)\n     | Name(identifier id, expr_context ctx)\n     | List(expr* elts, expr_context ctx)\n     | Tuple(expr* elts, expr_context ctx)\n     | Slice(expr? lower, expr? upper, expr? step)",
+    "_ast.expr.__delattr__" => "Implement delattr(self, name).",
+    "_ast.expr.__eq__" => "Return self==value.",
+    "_ast.expr.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_ast.expr.__ge__" => "Return self>=value.",
+    "_ast.expr.__getattribute__" => "Return getattr(self, name).",
+    "_ast.expr.__getstate__" => "Helper for pickle.",
+    "_ast.expr.__gt__" => "Return self>value.",
+    "_ast.expr.__hash__" => "Return hash(self).",
+    "_ast.expr.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_ast.expr.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_ast.expr.__le__" => "Return self<=value.",
+    "_ast.expr.__lt__" => "Return self<value.",
+    "_ast.expr.__ne__" => "Return self!=value.",
+    "_ast.expr.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_ast.expr.__reduce_ex__" => "Helper for pickle.",
+    "_ast.expr.__replace__" => "Return a copy of the AST node with new values for the specified fields.",
+    "_ast.expr.__repr__" => "Return repr(self).",
+    "_ast.expr.__setattr__" => "Implement setattr(self, name, value).",
+    "_ast.expr.__sizeof__" => "Size of object in memory, in bytes.",
+    "_ast.expr.__str__" => "Return str(self).",
+    "_ast.expr.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_ast.expr.__weakref__" => "list of weak references to the object",
+    "_ast.expr_context" => "expr_context = Load | Store | Del",
+    "_ast.expr_context.__delattr__" => "Implement delattr(self, name).",
+    "_ast.expr_context.__eq__" => "Return self==value.",
+    "_ast.expr_context.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_ast.expr_context.__ge__" => "Return self>=value.",
+    "_ast.expr_context.__getattribute__" => "Return getattr(self, name).",
+    "_ast.expr_context.__getstate__" => "Helper for pickle.",
+    "_ast.expr_context.__gt__" => "Return self>value.",
+    "_ast.expr_context.__hash__" => "Return hash(self).",
+    "_ast.expr_context.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_ast.expr_context.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_ast.expr_context.__le__" => "Return self<=value.",
+    "_ast.expr_context.__lt__" => "Return self<value.",
+    "_ast.expr_context.__ne__" => "Return self!=value.",
+    "_ast.expr_context.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_ast.expr_context.__reduce_ex__" => "Helper for pickle.",
+    "_ast.expr_context.__replace__" => "Return a copy of the AST node with new values for the specified fields.",
+    "_ast.expr_context.__repr__" => "Return repr(self).",
+    "_ast.expr_context.__setattr__" => "Implement setattr(self, name, value).",
+    "_ast.expr_context.__sizeof__" => "Size of object in memory, in bytes.",
+    "_ast.expr_context.__str__" => "Return str(self).",
+    "_ast.expr_context.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_ast.expr_context.__weakref__" => "list of weak references to the object",
+    "_ast.keyword" => "keyword(identifier? arg, expr value)",
+    "_ast.keyword.__delattr__" => "Implement delattr(self, name).",
+    "_ast.keyword.__eq__" => "Return self==value.",
+    "_ast.keyword.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_ast.keyword.__ge__" => "Return self>=value.",
+    "_ast.keyword.__getattribute__" => "Return getattr(self, name).",
+    "_ast.keyword.__getstate__" => "Helper for pickle.",
+    "_ast.keyword.__gt__" => "Return self>value.",
+    "_ast.keyword.__hash__" => "Return hash(self).",
+    "_ast.keyword.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_ast.keyword.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_ast.keyword.__le__" => "Return self<=value.",
+    "_ast.keyword.__lt__" => "Return self<value.",
+    "_ast.keyword.__ne__" => "Return self!=value.",
+    "_ast.keyword.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_ast.keyword.__reduce_ex__" => "Helper for pickle.",
+    "_ast.keyword.__replace__" => "Return a copy of the AST node with new values for the specified fields.",
+    "_ast.keyword.__repr__" => "Return repr(self).",
+    "_ast.keyword.__setattr__" => "Implement setattr(self, name, value).",
+    "_ast.keyword.__sizeof__" => "Size of object in memory, in bytes.",
+    "_ast.keyword.__str__" => "Return str(self).",
+    "_ast.keyword.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_ast.keyword.__weakref__" => "list of weak references to the object",
+    "_ast.match_case" => "match_case(pattern pattern, expr? guard, stmt* body)",
+    "_ast.match_case.__delattr__" => "Implement delattr(self, name).",
+    "_ast.match_case.__eq__" => "Return self==value.",
+    "_ast.match_case.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_ast.match_case.__ge__" => "Return self>=value.",
+    "_ast.match_case.__getattribute__" => "Return getattr(self, name).",
+    "_ast.match_case.__getstate__" => "Helper for pickle.",
+    "_ast.match_case.__gt__" => "Return self>value.",
+    "_ast.match_case.__hash__" => "Return hash(self).",
+    "_ast.match_case.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_ast.match_case.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_ast.match_case.__le__" => "Return self<=value.",
+    "_ast.match_case.__lt__" => "Return self<value.",
+    "_ast.match_case.__ne__" => "Return self!=value.",
+    "_ast.match_case.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_ast.match_case.__reduce_ex__" => "Helper for pickle.",
+    "_ast.match_case.__replace__" => "Return a copy of the AST node with new values for the specified fields.",
+    "_ast.match_case.__repr__" => "Return repr(self).",
+    "_ast.match_case.__setattr__" => "Implement setattr(self, name, value).",
+    "_ast.match_case.__sizeof__" => "Size of object in memory, in bytes.",
+    "_ast.match_case.__str__" => "Return str(self).",
+    "_ast.match_case.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_ast.match_case.__weakref__" => "list of weak references to the object",
+    "_ast.mod" => "mod = Module(stmt* body, type_ignore* type_ignores)\n    | Interactive(stmt* body)\n    | Expression(expr body)\n    | FunctionType(expr* argtypes, expr returns)",
+    "_ast.mod.__delattr__" => "Implement delattr(self, name).",
+    "_ast.mod.__eq__" => "Return self==value.",
+    "_ast.mod.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_ast.mod.__ge__" => "Return self>=value.",
+    "_ast.mod.__getattribute__" => "Return getattr(self, name).",
+    "_ast.mod.__getstate__" => "Helper for pickle.",
+    "_ast.mod.__gt__" => "Return self>value.",
+    "_ast.mod.__hash__" => "Return hash(self).",
+    "_ast.mod.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_ast.mod.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_ast.mod.__le__" => "Return self<=value.",
+    "_ast.mod.__lt__" => "Return self<value.",
+    "_ast.mod.__ne__" => "Return self!=value.",
+    "_ast.mod.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_ast.mod.__reduce_ex__" => "Helper for pickle.",
+    "_ast.mod.__replace__" => "Return a copy of the AST node with new values for the specified fields.",
+    "_ast.mod.__repr__" => "Return repr(self).",
+    "_ast.mod.__setattr__" => "Implement setattr(self, name, value).",
+    "_ast.mod.__sizeof__" => "Size of object in memory, in bytes.",
+    "_ast.mod.__str__" => "Return str(self).",
+    "_ast.mod.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_ast.mod.__weakref__" => "list of weak references to the object",
+    "_ast.operator" => "operator = Add | Sub | Mult | MatMult | Div | Mod | Pow | LShift | RShift | BitOr | BitXor | BitAnd | FloorDiv",
+    "_ast.operator.__delattr__" => "Implement delattr(self, name).",
+    "_ast.operator.__eq__" => "Return self==value.",
+    "_ast.operator.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_ast.operator.__ge__" => "Return self>=value.",
+    "_ast.operator.__getattribute__" => "Return getattr(self, name).",
+    "_ast.operator.__getstate__" => "Helper for pickle.",
+    "_ast.operator.__gt__" => "Return self>value.",
+    "_ast.operator.__hash__" => "Return hash(self).",
+    "_ast.operator.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_ast.operator.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_ast.operator.__le__" => "Return self<=value.",
+    "_ast.operator.__lt__" => "Return self<value.",
+    "_ast.operator.__ne__" => "Return self!=value.",
+    "_ast.operator.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_ast.operator.__reduce_ex__" => "Helper for pickle.",
+    "_ast.operator.__replace__" => "Return a copy of the AST node with new values for the specified fields.",
+    "_ast.operator.__repr__" => "Return repr(self).",
+    "_ast.operator.__setattr__" => "Implement setattr(self, name, value).",
+    "_ast.operator.__sizeof__" => "Size of object in memory, in bytes.",
+    "_ast.operator.__str__" => "Return str(self).",
+    "_ast.operator.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_ast.operator.__weakref__" => "list of weak references to the object",
+    "_ast.pattern" => "pattern = MatchValue(expr value)\n        | MatchSingleton(constant value)\n        | MatchSequence(pattern* patterns)\n        | MatchMapping(expr* keys, pattern* patterns, identifier? rest)\n        | MatchClass(expr cls, pattern* patterns, identifier* kwd_attrs, pattern* kwd_patterns)\n        | MatchStar(identifier? name)\n        | MatchAs(pattern? pattern, identifier? name)\n        | MatchOr(pattern* patterns)",
+    "_ast.pattern.__delattr__" => "Implement delattr(self, name).",
+    "_ast.pattern.__eq__" => "Return self==value.",
+    "_ast.pattern.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_ast.pattern.__ge__" => "Return self>=value.",
+    "_ast.pattern.__getattribute__" => "Return getattr(self, name).",
+    "_ast.pattern.__getstate__" => "Helper for pickle.",
+    "_ast.pattern.__gt__" => "Return self>value.",
+    "_ast.pattern.__hash__" => "Return hash(self).",
+    "_ast.pattern.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_ast.pattern.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_ast.pattern.__le__" => "Return self<=value.",
+    "_ast.pattern.__lt__" => "Return self<value.",
+    "_ast.pattern.__ne__" => "Return self!=value.",
+    "_ast.pattern.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_ast.pattern.__reduce_ex__" => "Helper for pickle.",
+    "_ast.pattern.__replace__" => "Return a copy of the AST node with new values for the specified fields.",
+    "_ast.pattern.__repr__" => "Return repr(self).",
+    "_ast.pattern.__setattr__" => "Implement setattr(self, name, value).",
+    "_ast.pattern.__sizeof__" => "Size of object in memory, in bytes.",
+    "_ast.pattern.__str__" => "Return str(self).",
+    "_ast.pattern.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_ast.pattern.__weakref__" => "list of weak references to the object",
+    "_ast.stmt" => "stmt = FunctionDef(identifier name, arguments args, stmt* body, expr* decorator_list, expr? returns, string? type_comment, type_param* type_params)\n     | AsyncFunctionDef(identifier name, arguments args, stmt* body, expr* decorator_list, expr? returns, string? type_comment, type_param* type_params)\n     | ClassDef(identifier name, expr* bases, keyword* keywords, stmt* body, expr* decorator_list, type_param* type_params)\n     | Return(expr? value)\n     | Delete(expr* targets)\n     | Assign(expr* targets, expr value, string? type_comment)\n     | TypeAlias(expr name, type_param* type_params, expr value)\n     | AugAssign(expr target, operator op, expr value)\n     | AnnAssign(expr target, expr annotation, expr? value, int simple)\n     | For(expr target, expr iter, stmt* body, stmt* orelse, string? type_comment)\n     | AsyncFor(expr target, expr iter, stmt* body, stmt* orelse, string? type_comment)\n     | While(expr test, stmt* body, stmt* orelse)\n     | If(expr test, stmt* body, stmt* orelse)\n     | With(withitem* items, stmt* body, string? type_comment)\n     | AsyncWith(withitem* items, stmt* body, string? type_comment)\n     | Match(expr subject, match_case* cases)\n     | Raise(expr? exc, expr? cause)\n     | Try(stmt* body, excepthandler* handlers, stmt* orelse, stmt* finalbody)\n     | TryStar(stmt* body, excepthandler* handlers, stmt* orelse, stmt* finalbody)\n     | Assert(expr test, expr? msg)\n     | Import(alias* names)\n     | ImportFrom(identifier? module, alias* names, int? level)\n     | Global(identifier* names)\n     | Nonlocal(identifier* names)\n     | Expr(expr value)\n     | Pass\n     | Break\n     | Continue",
+    "_ast.stmt.__delattr__" => "Implement delattr(self, name).",
+    "_ast.stmt.__eq__" => "Return self==value.",
+    "_ast.stmt.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_ast.stmt.__ge__" => "Return self>=value.",
+    "_ast.stmt.__getattribute__" => "Return getattr(self, name).",
+    "_ast.stmt.__getstate__" => "Helper for pickle.",
+    "_ast.stmt.__gt__" => "Return self>value.",
+    "_ast.stmt.__hash__" => "Return hash(self).",
+    "_ast.stmt.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_ast.stmt.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_ast.stmt.__le__" => "Return self<=value.",
+    "_ast.stmt.__lt__" => "Return self<value.",
+    "_ast.stmt.__ne__" => "Return self!=value.",
+    "_ast.stmt.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_ast.stmt.__reduce_ex__" => "Helper for pickle.",
+    "_ast.stmt.__replace__" => "Return a copy of the AST node with new values for the specified fields.",
+    "_ast.stmt.__repr__" => "Return repr(self).",
+    "_ast.stmt.__setattr__" => "Implement setattr(self, name, value).",
+    "_ast.stmt.__sizeof__" => "Size of object in memory, in bytes.",
+    "_ast.stmt.__str__" => "Return str(self).",
+    "_ast.stmt.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_ast.stmt.__weakref__" => "list of weak references to the object",
+    "_ast.type_ignore" => "type_ignore = TypeIgnore(int lineno, string tag)",
+    "_ast.type_ignore.__delattr__" => "Implement delattr(self, name).",
+    "_ast.type_ignore.__eq__" => "Return self==value.",
+    "_ast.type_ignore.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_ast.type_ignore.__ge__" => "Return self>=value.",
+    "_ast.type_ignore.__getattribute__" => "Return getattr(self, name).",
+    "_ast.type_ignore.__getstate__" => "Helper for pickle.",
+    "_ast.type_ignore.__gt__" => "Return self>value.",
+    "_ast.type_ignore.__hash__" => "Return hash(self).",
+    "_ast.type_ignore.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_ast.type_ignore.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_ast.type_ignore.__le__" => "Return self<=value.",
+    "_ast.type_ignore.__lt__" => "Return self<value.",
+    "_ast.type_ignore.__ne__" => "Return self!=value.",
+    "_ast.type_ignore.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_ast.type_ignore.__reduce_ex__" => "Helper for pickle.",
+    "_ast.type_ignore.__replace__" => "Return a copy of the AST node with new values for the specified fields.",
+    "_ast.type_ignore.__repr__" => "Return repr(self).",
+    "_ast.type_ignore.__setattr__" => "Implement setattr(self, name, value).",
+    "_ast.type_ignore.__sizeof__" => "Size of object in memory, in bytes.",
+    "_ast.type_ignore.__str__" => "Return str(self).",
+    "_ast.type_ignore.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_ast.type_ignore.__weakref__" => "list of weak references to the object",
+    "_ast.type_param" => "type_param = TypeVar(identifier name, expr? bound, expr? default_value)\n           | ParamSpec(identifier name, expr? default_value)\n           | TypeVarTuple(identifier name, expr? default_value)",
+    "_ast.type_param.__delattr__" => "Implement delattr(self, name).",
+    "_ast.type_param.__eq__" => "Return self==value.",
+    "_ast.type_param.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_ast.type_param.__ge__" => "Return self>=value.",
+    "_ast.type_param.__getattribute__" => "Return getattr(self, name).",
+    "_ast.type_param.__getstate__" => "Helper for pickle.",
+    "_ast.type_param.__gt__" => "Return self>value.",
+    "_ast.type_param.__hash__" => "Return hash(self).",
+    "_ast.type_param.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_ast.type_param.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_ast.type_param.__le__" => "Return self<=value.",
+    "_ast.type_param.__lt__" => "Return self<value.",
+    "_ast.type_param.__ne__" => "Return self!=value.",
+    "_ast.type_param.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_ast.type_param.__reduce_ex__" => "Helper for pickle.",
+    "_ast.type_param.__replace__" => "Return a copy of the AST node with new values for the specified fields.",
+    "_ast.type_param.__repr__" => "Return repr(self).",
+    "_ast.type_param.__setattr__" => "Implement setattr(self, name, value).",
+    "_ast.type_param.__sizeof__" => "Size of object in memory, in bytes.",
+    "_ast.type_param.__str__" => "Return str(self).",
+    "_ast.type_param.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_ast.type_param.__weakref__" => "list of weak references to the object",
+    "_ast.unaryop" => "unaryop = Invert | Not | UAdd | USub",
+    "_ast.unaryop.__delattr__" => "Implement delattr(self, name).",
+    "_ast.unaryop.__eq__" => "Return self==value.",
+    "_ast.unaryop.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_ast.unaryop.__ge__" => "Return self>=value.",
+    "_ast.unaryop.__getattribute__" => "Return getattr(self, name).",
+    "_ast.unaryop.__getstate__" => "Helper for pickle.",
+    "_ast.unaryop.__gt__" => "Return self>value.",
+    "_ast.unaryop.__hash__" => "Return hash(self).",
+    "_ast.unaryop.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_ast.unaryop.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_ast.unaryop.__le__" => "Return self<=value.",
+    "_ast.unaryop.__lt__" => "Return self<value.",
+    "_ast.unaryop.__ne__" => "Return self!=value.",
+    "_ast.unaryop.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_ast.unaryop.__reduce_ex__" => "Helper for pickle.",
+    "_ast.unaryop.__replace__" => "Return a copy of the AST node with new values for the specified fields.",
+    "_ast.unaryop.__repr__" => "Return repr(self).",
+    "_ast.unaryop.__setattr__" => "Implement setattr(self, name, value).",
+    "_ast.unaryop.__sizeof__" => "Size of object in memory, in bytes.",
+    "_ast.unaryop.__str__" => "Return str(self).",
+    "_ast.unaryop.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_ast.unaryop.__weakref__" => "list of weak references to the object",
+    "_ast.withitem" => "withitem(expr context_expr, expr? optional_vars)",
+    "_ast.withitem.__delattr__" => "Implement delattr(self, name).",
+    "_ast.withitem.__eq__" => "Return self==value.",
+    "_ast.withitem.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_ast.withitem.__ge__" => "Return self>=value.",
+    "_ast.withitem.__getattribute__" => "Return getattr(self, name).",
+    "_ast.withitem.__getstate__" => "Helper for pickle.",
+    "_ast.withitem.__gt__" => "Return self>value.",
+    "_ast.withitem.__hash__" => "Return hash(self).",
+    "_ast.withitem.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_ast.withitem.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_ast.withitem.__le__" => "Return self<=value.",
+    "_ast.withitem.__lt__" => "Return self<value.",
+    "_ast.withitem.__ne__" => "Return self!=value.",
+    "_ast.withitem.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_ast.withitem.__reduce_ex__" => "Helper for pickle.",
+    "_ast.withitem.__replace__" => "Return a copy of the AST node with new values for the specified fields.",
+    "_ast.withitem.__repr__" => "Return repr(self).",
+    "_ast.withitem.__setattr__" => "Implement setattr(self, name, value).",
+    "_ast.withitem.__sizeof__" => "Size of object in memory, in bytes.",
+    "_ast.withitem.__str__" => "Return str(self).",
+    "_ast.withitem.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_ast.withitem.__weakref__" => "list of weak references to the object",
     "_asyncio" => "Accelerator module for asyncio",
-    "_asyncio.Future" => "This class is *almost* compatible with concurrent.futures.Future.\n\nDifferences:\n\n- result() and exception() do not take a timeout argument and\n  raise an exception when the future isn't done yet.\n\n- Callbacks registered with add_done_callback() are always called\n  via the event loop's call_soon_threadsafe().\n\n- This class is not compatible with the wait() and as_completed()\n  methods in the concurrent.futures package.",
+    "_asyncio.Future" => "This class is *almost* compatible with concurrent.futures.Future.\n\n    Differences:\n\n    - result() and exception() do not take a timeout argument and\n      raise an exception when the future isn't done yet.\n\n    - Callbacks registered with add_done_callback() are always called\n      via the event loop's call_soon_threadsafe().\n\n    - This class is not compatible with the wait() and as_completed()\n      methods in the concurrent.futures package.",
     "_asyncio.Future.__await__" => "Return an iterator to be used in await expression.",
     "_asyncio.Future.__class_getitem__" => "See PEP 585",
     "_asyncio.Future.__del__" => "Called when the instance is about to be destroyed.",
@@ -98,7 +2995,9 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "_asyncio._swap_current_task" => "Temporarily swap in the supplied task and return the original one (or None).\n\nThis is intended for use during eager coroutine execution.",
     "_asyncio._unregister_eager_task" => "Unregister a task.\n\nReturns None.",
     "_asyncio._unregister_task" => "Unregister a task.\n\nReturns None.",
+    "_asyncio.all_tasks" => "Return a set of all tasks for the loop.",
     "_asyncio.current_task" => "Return a currently executed task.",
+    "_asyncio.future_add_to_awaited_by" => "Record that `fut` is awaited on by `waiter`.",
     "_asyncio.get_event_loop" => "Return an asyncio event loop.\n\nWhen called from a coroutine or a callback (e.g. scheduled with\ncall_soon or similar API), this function will always return the\nrunning event loop.\n\nIf there is no running event loop set, the function will return\nthe result of `get_event_loop_policy().get_event_loop()` call.",
     "_asyncio.get_running_loop" => "Return the running event loop.  Raise a RuntimeError if there is none.\n\nThis function is thread-specific.",
     "_bisect" => "Bisection algorithms.\n\nThis module provides support for maintaining a list in sorted order without\nhaving to sort the list after each insertion. For long lists of items with\nexpensive comparison operations, this can be an improvement over the more\ncommon approach.",
@@ -209,6 +3108,7 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "_bz2.BZ2Decompressor.eof" => "True if the end-of-stream marker has been reached.",
     "_bz2.BZ2Decompressor.needs_input" => "True if more input is needed before more decompressed data can be produced.",
     "_bz2.BZ2Decompressor.unused_data" => "Data found after the end of the compressed stream.",
+    "_codecs._unregister_error" => "Un-register the specified error handler for the error handling `errors'.\n\nOnly custom error handlers can be un-registered. An exception is raised\nif the error handling is a built-in one (e.g., 'strict'), or if an error\noccurs.\n\nOtherwise, this returns True if a custom handler has been successfully\nun-registered, and False if no custom handler for the specified error\nhandling exists.",
     "_codecs.decode" => "Decodes obj using the codec registered for encoding.\n\nDefault encoding is 'utf-8'.  errors may be given to set a\ndifferent error handling scheme.  Default is 'strict' meaning that encoding\nerrors raise a ValueError.  Other possible values are 'ignore', 'replace'\nand 'backslashreplace' as well as any other name registered with\ncodecs.register_error that can handle ValueErrors.",
     "_codecs.encode" => "Encodes obj using the codec registered for encoding.\n\nThe default encoding is 'utf-8'.  errors may be given to set a\ndifferent error handling scheme.  Default is 'strict' meaning that encoding\nerrors raise a ValueError.  Other possible values are 'ignore', 'replace'\nand 'backslashreplace' as well as any other name registered with\ncodecs.register_error that can handle ValueErrors.",
     "_codecs.lookup" => "Looks up a codec tuple in the Python codec registry and returns a CodecInfo object.",
@@ -217,7 +3117,213 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "_codecs.register_error" => "Register the specified error handler under the name errors.\n\nhandler must be a callable object, that will be called with an exception\ninstance containing information about the location of the encoding/decoding\nerror and must return a (replacement, new position) tuple.",
     "_codecs.unregister" => "Unregister a codec search function and clear the registry's cache.\n\nIf the search function is not registered, do nothing.",
     "_collections" => "High performance data structures.\n- deque:        ordered collection accessible from endpoints only\n- defaultdict:  dict subclass with a default value factory",
+    "_collections.OrderedDict" => "Dictionary that remembers insertion order",
+    "_collections.OrderedDict.__class_getitem__" => "See PEP 585",
+    "_collections.OrderedDict.__contains__" => "True if the dictionary has the specified key, else False.",
+    "_collections.OrderedDict.__delattr__" => "Implement delattr(self, name).",
+    "_collections.OrderedDict.__delitem__" => "Delete self[key].",
+    "_collections.OrderedDict.__eq__" => "Return self==value.",
+    "_collections.OrderedDict.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_collections.OrderedDict.__ge__" => "Return self>=value.",
+    "_collections.OrderedDict.__getattribute__" => "Return getattr(self, name).",
+    "_collections.OrderedDict.__getitem__" => "Return self[key].",
+    "_collections.OrderedDict.__getstate__" => "Helper for pickle.",
+    "_collections.OrderedDict.__gt__" => "Return self>value.",
+    "_collections.OrderedDict.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_collections.OrderedDict.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_collections.OrderedDict.__ior__" => "Return self|=value.",
+    "_collections.OrderedDict.__iter__" => "Implement iter(self).",
+    "_collections.OrderedDict.__le__" => "Return self<=value.",
+    "_collections.OrderedDict.__len__" => "Return len(self).",
+    "_collections.OrderedDict.__lt__" => "Return self<value.",
+    "_collections.OrderedDict.__ne__" => "Return self!=value.",
+    "_collections.OrderedDict.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_collections.OrderedDict.__or__" => "Return self|value.",
+    "_collections.OrderedDict.__reduce__" => "Return state information for pickling",
+    "_collections.OrderedDict.__reduce_ex__" => "Helper for pickle.",
+    "_collections.OrderedDict.__repr__" => "Return repr(self).",
+    "_collections.OrderedDict.__reversed__" => "od.__reversed__() <==> reversed(od)",
+    "_collections.OrderedDict.__ror__" => "Return value|self.",
+    "_collections.OrderedDict.__setattr__" => "Implement setattr(self, name, value).",
+    "_collections.OrderedDict.__setitem__" => "Set self[key] to value.",
+    "_collections.OrderedDict.__str__" => "Return str(self).",
+    "_collections.OrderedDict.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_collections.OrderedDict.clear" => "Remove all items from ordered dict.",
+    "_collections.OrderedDict.copy" => "A shallow copy of ordered dict.",
+    "_collections.OrderedDict.fromkeys" => "Create a new ordered dictionary with keys from iterable and values set to value.",
+    "_collections.OrderedDict.get" => "Return the value for key if key is in the dictionary, else default.",
+    "_collections.OrderedDict.move_to_end" => "Move an existing element to the end (or beginning if last is false).\n\nRaise KeyError if the element does not exist.",
+    "_collections.OrderedDict.pop" => "od.pop(key[,default]) -> v, remove specified key and return the corresponding value.\n\nIf the key is not found, return the default if given; otherwise,\nraise a KeyError.",
+    "_collections.OrderedDict.popitem" => "Remove and return a (key, value) pair from the dictionary.\n\nPairs are returned in LIFO order if last is true or FIFO order if false.",
+    "_collections.OrderedDict.setdefault" => "Insert key with a value of default if key is not in the dictionary.\n\nReturn the value for key if key is in the dictionary, else default.",
     "_collections._count_elements" => "Count elements in the iterable, updating the mapping",
+    "_collections._deque_iterator.__delattr__" => "Implement delattr(self, name).",
+    "_collections._deque_iterator.__eq__" => "Return self==value.",
+    "_collections._deque_iterator.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_collections._deque_iterator.__ge__" => "Return self>=value.",
+    "_collections._deque_iterator.__getattribute__" => "Return getattr(self, name).",
+    "_collections._deque_iterator.__getstate__" => "Helper for pickle.",
+    "_collections._deque_iterator.__gt__" => "Return self>value.",
+    "_collections._deque_iterator.__hash__" => "Return hash(self).",
+    "_collections._deque_iterator.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_collections._deque_iterator.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_collections._deque_iterator.__iter__" => "Implement iter(self).",
+    "_collections._deque_iterator.__le__" => "Return self<=value.",
+    "_collections._deque_iterator.__length_hint__" => "Private method returning an estimate of len(list(it)).",
+    "_collections._deque_iterator.__lt__" => "Return self<value.",
+    "_collections._deque_iterator.__ne__" => "Return self!=value.",
+    "_collections._deque_iterator.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_collections._deque_iterator.__next__" => "Implement next(self).",
+    "_collections._deque_iterator.__reduce__" => "Return state information for pickling.",
+    "_collections._deque_iterator.__reduce_ex__" => "Helper for pickle.",
+    "_collections._deque_iterator.__repr__" => "Return repr(self).",
+    "_collections._deque_iterator.__setattr__" => "Implement setattr(self, name, value).",
+    "_collections._deque_iterator.__sizeof__" => "Size of object in memory, in bytes.",
+    "_collections._deque_iterator.__str__" => "Return str(self).",
+    "_collections._deque_iterator.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_collections._deque_reverse_iterator.__delattr__" => "Implement delattr(self, name).",
+    "_collections._deque_reverse_iterator.__eq__" => "Return self==value.",
+    "_collections._deque_reverse_iterator.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_collections._deque_reverse_iterator.__ge__" => "Return self>=value.",
+    "_collections._deque_reverse_iterator.__getattribute__" => "Return getattr(self, name).",
+    "_collections._deque_reverse_iterator.__getstate__" => "Helper for pickle.",
+    "_collections._deque_reverse_iterator.__gt__" => "Return self>value.",
+    "_collections._deque_reverse_iterator.__hash__" => "Return hash(self).",
+    "_collections._deque_reverse_iterator.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_collections._deque_reverse_iterator.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_collections._deque_reverse_iterator.__iter__" => "Implement iter(self).",
+    "_collections._deque_reverse_iterator.__le__" => "Return self<=value.",
+    "_collections._deque_reverse_iterator.__length_hint__" => "Private method returning an estimate of len(list(it)).",
+    "_collections._deque_reverse_iterator.__lt__" => "Return self<value.",
+    "_collections._deque_reverse_iterator.__ne__" => "Return self!=value.",
+    "_collections._deque_reverse_iterator.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_collections._deque_reverse_iterator.__next__" => "Implement next(self).",
+    "_collections._deque_reverse_iterator.__reduce__" => "Return state information for pickling.",
+    "_collections._deque_reverse_iterator.__reduce_ex__" => "Helper for pickle.",
+    "_collections._deque_reverse_iterator.__repr__" => "Return repr(self).",
+    "_collections._deque_reverse_iterator.__setattr__" => "Implement setattr(self, name, value).",
+    "_collections._deque_reverse_iterator.__sizeof__" => "Size of object in memory, in bytes.",
+    "_collections._deque_reverse_iterator.__str__" => "Return str(self).",
+    "_collections._deque_reverse_iterator.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_collections._tuplegetter.__delattr__" => "Implement delattr(self, name).",
+    "_collections._tuplegetter.__delete__" => "Delete an attribute of instance.",
+    "_collections._tuplegetter.__eq__" => "Return self==value.",
+    "_collections._tuplegetter.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_collections._tuplegetter.__ge__" => "Return self>=value.",
+    "_collections._tuplegetter.__get__" => "Return an attribute of instance, which is of type owner.",
+    "_collections._tuplegetter.__getattribute__" => "Return getattr(self, name).",
+    "_collections._tuplegetter.__getstate__" => "Helper for pickle.",
+    "_collections._tuplegetter.__gt__" => "Return self>value.",
+    "_collections._tuplegetter.__hash__" => "Return hash(self).",
+    "_collections._tuplegetter.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_collections._tuplegetter.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_collections._tuplegetter.__le__" => "Return self<=value.",
+    "_collections._tuplegetter.__lt__" => "Return self<value.",
+    "_collections._tuplegetter.__ne__" => "Return self!=value.",
+    "_collections._tuplegetter.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_collections._tuplegetter.__reduce_ex__" => "Helper for pickle.",
+    "_collections._tuplegetter.__repr__" => "Return repr(self).",
+    "_collections._tuplegetter.__set__" => "Set an attribute of instance to value.",
+    "_collections._tuplegetter.__setattr__" => "Implement setattr(self, name, value).",
+    "_collections._tuplegetter.__sizeof__" => "Size of object in memory, in bytes.",
+    "_collections._tuplegetter.__str__" => "Return str(self).",
+    "_collections._tuplegetter.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_collections.defaultdict" => "defaultdict(default_factory=None, /, [...]) --> dict with default factory\n\nThe default factory is called without arguments to produce\na new value when a key is not present, in __getitem__ only.\nA defaultdict compares equal to a dict with the same items.\nAll remaining arguments are treated the same as if they were\npassed to the dict constructor, including keyword arguments.",
+    "_collections.defaultdict.__class_getitem__" => "See PEP 585",
+    "_collections.defaultdict.__contains__" => "True if the dictionary has the specified key, else False.",
+    "_collections.defaultdict.__copy__" => "D.copy() -> a shallow copy of D.",
+    "_collections.defaultdict.__delattr__" => "Implement delattr(self, name).",
+    "_collections.defaultdict.__delitem__" => "Delete self[key].",
+    "_collections.defaultdict.__eq__" => "Return self==value.",
+    "_collections.defaultdict.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_collections.defaultdict.__ge__" => "Return self>=value.",
+    "_collections.defaultdict.__getattribute__" => "Return getattr(self, name).",
+    "_collections.defaultdict.__getitem__" => "Return self[key].",
+    "_collections.defaultdict.__getstate__" => "Helper for pickle.",
+    "_collections.defaultdict.__gt__" => "Return self>value.",
+    "_collections.defaultdict.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_collections.defaultdict.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_collections.defaultdict.__ior__" => "Return self|=value.",
+    "_collections.defaultdict.__iter__" => "Implement iter(self).",
+    "_collections.defaultdict.__le__" => "Return self<=value.",
+    "_collections.defaultdict.__len__" => "Return len(self).",
+    "_collections.defaultdict.__lt__" => "Return self<value.",
+    "_collections.defaultdict.__missing__" => "__missing__(key) # Called by __getitem__ for missing key; pseudo-code:\n  if self.default_factory is None: raise KeyError((key,))\n  self[key] = value = self.default_factory()\n  return value",
+    "_collections.defaultdict.__ne__" => "Return self!=value.",
+    "_collections.defaultdict.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_collections.defaultdict.__or__" => "Return self|value.",
+    "_collections.defaultdict.__reduce__" => "Return state information for pickling.",
+    "_collections.defaultdict.__reduce_ex__" => "Helper for pickle.",
+    "_collections.defaultdict.__repr__" => "Return repr(self).",
+    "_collections.defaultdict.__reversed__" => "Return a reverse iterator over the dict keys.",
+    "_collections.defaultdict.__ror__" => "Return value|self.",
+    "_collections.defaultdict.__setattr__" => "Implement setattr(self, name, value).",
+    "_collections.defaultdict.__setitem__" => "Set self[key] to value.",
+    "_collections.defaultdict.__sizeof__" => "Return the size of the dict in memory, in bytes.",
+    "_collections.defaultdict.__str__" => "Return str(self).",
+    "_collections.defaultdict.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_collections.defaultdict.clear" => "Remove all items from the dict.",
+    "_collections.defaultdict.copy" => "D.copy() -> a shallow copy of D.",
+    "_collections.defaultdict.default_factory" => "Factory for default value called by __missing__().",
+    "_collections.defaultdict.fromkeys" => "Create a new dictionary with keys from iterable and values set to value.",
+    "_collections.defaultdict.get" => "Return the value for key if key is in the dictionary, else default.",
+    "_collections.defaultdict.items" => "Return a set-like object providing a view on the dict's items.",
+    "_collections.defaultdict.keys" => "Return a set-like object providing a view on the dict's keys.",
+    "_collections.defaultdict.pop" => "D.pop(k[,d]) -> v, remove specified key and return the corresponding value.\n\nIf the key is not found, return the default if given; otherwise,\nraise a KeyError.",
+    "_collections.defaultdict.popitem" => "Remove and return a (key, value) pair as a 2-tuple.\n\nPairs are returned in LIFO (last-in, first-out) order.\nRaises KeyError if the dict is empty.",
+    "_collections.defaultdict.setdefault" => "Insert key with a value of default if key is not in the dictionary.\n\nReturn the value for key if key is in the dictionary, else default.",
+    "_collections.defaultdict.update" => "D.update([E, ]**F) -> None.  Update D from mapping/iterable E and F.\nIf E is present and has a .keys() method, then does:  for k in E.keys(): D[k] = E[k]\nIf E is present and lacks a .keys() method, then does:  for k, v in E: D[k] = v\nIn either case, this is followed by: for k in F:  D[k] = F[k]",
+    "_collections.defaultdict.values" => "Return an object providing a view on the dict's values.",
+    "_collections.deque" => "A list-like sequence optimized for data accesses near its endpoints.",
+    "_collections.deque.__add__" => "Return self+value.",
+    "_collections.deque.__class_getitem__" => "See PEP 585",
+    "_collections.deque.__contains__" => "Return bool(key in self).",
+    "_collections.deque.__copy__" => "Return a shallow copy of a deque.",
+    "_collections.deque.__delattr__" => "Implement delattr(self, name).",
+    "_collections.deque.__delitem__" => "Delete self[key].",
+    "_collections.deque.__eq__" => "Return self==value.",
+    "_collections.deque.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_collections.deque.__ge__" => "Return self>=value.",
+    "_collections.deque.__getattribute__" => "Return getattr(self, name).",
+    "_collections.deque.__getitem__" => "Return self[key].",
+    "_collections.deque.__getstate__" => "Helper for pickle.",
+    "_collections.deque.__gt__" => "Return self>value.",
+    "_collections.deque.__iadd__" => "Implement self+=value.",
+    "_collections.deque.__imul__" => "Implement self*=value.",
+    "_collections.deque.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_collections.deque.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_collections.deque.__iter__" => "Implement iter(self).",
+    "_collections.deque.__le__" => "Return self<=value.",
+    "_collections.deque.__len__" => "Return len(self).",
+    "_collections.deque.__lt__" => "Return self<value.",
+    "_collections.deque.__mul__" => "Return self*value.",
+    "_collections.deque.__ne__" => "Return self!=value.",
+    "_collections.deque.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_collections.deque.__reduce__" => "Return state information for pickling.",
+    "_collections.deque.__reduce_ex__" => "Helper for pickle.",
+    "_collections.deque.__repr__" => "Return repr(self).",
+    "_collections.deque.__reversed__" => "Return a reverse iterator over the deque.",
+    "_collections.deque.__rmul__" => "Return value*self.",
+    "_collections.deque.__setattr__" => "Implement setattr(self, name, value).",
+    "_collections.deque.__setitem__" => "Set self[key] to value.",
+    "_collections.deque.__sizeof__" => "Return the size of the deque in memory, in bytes.",
+    "_collections.deque.__str__" => "Return str(self).",
+    "_collections.deque.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_collections.deque.append" => "Add an element to the right side of the deque.",
+    "_collections.deque.appendleft" => "Add an element to the left side of the deque.",
+    "_collections.deque.clear" => "Remove all elements from the deque.",
+    "_collections.deque.copy" => "Return a shallow copy of a deque.",
+    "_collections.deque.count" => "Return number of occurrences of value.",
+    "_collections.deque.extend" => "Extend the right side of the deque with elements from the iterable.",
+    "_collections.deque.extendleft" => "Extend the left side of the deque with elements from the iterable.",
+    "_collections.deque.index" => "Return first index of value.\n\nRaises ValueError if the value is not present.",
+    "_collections.deque.insert" => "Insert value before index.",
+    "_collections.deque.maxlen" => "maximum size of a deque or None if unbounded",
+    "_collections.deque.pop" => "Remove and return the rightmost element.",
+    "_collections.deque.popleft" => "Remove and return the leftmost element.",
+    "_collections.deque.remove" => "Remove first occurrence of value.",
+    "_collections.deque.reverse" => "Reverse *IN PLACE*.",
+    "_collections.deque.rotate" => "Rotate the deque n steps to the right.  If n is negative, rotates left.",
     "_contextvars" => "Context Variables",
     "_contextvars.Context.__contains__" => "Return bool(key in self).",
     "_contextvars.Context.__delattr__" => "Implement delattr(self, name).",
@@ -275,7 +3381,9 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "_contextvars.ContextVar.set" => "Call to set a new value for the context variable in the current context.\n\nThe required value argument is the new value for the context variable.\n\nReturns a Token object that can be used to restore the variable to its previous\nvalue via the `ContextVar.reset()` method.",
     "_contextvars.Token.__class_getitem__" => "See PEP 585",
     "_contextvars.Token.__delattr__" => "Implement delattr(self, name).",
+    "_contextvars.Token.__enter__" => "Enter into Token context manager.",
     "_contextvars.Token.__eq__" => "Return self==value.",
+    "_contextvars.Token.__exit__" => "Exit from Token context manager, restore the linked ContextVar.",
     "_contextvars.Token.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
     "_contextvars.Token.__ge__" => "Return self>=value.",
     "_contextvars.Token.__getattribute__" => "Return getattr(self, name).",
@@ -317,8 +3425,6 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "_csv.Dialect.__sizeof__" => "Size of object in memory, in bytes.",
     "_csv.Dialect.__str__" => "Return str(self).",
     "_csv.Dialect.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
-    "_csv.Error.__cause__" => "exception cause",
-    "_csv.Error.__context__" => "exception context",
     "_csv.Error.__delattr__" => "Implement delattr(self, name).",
     "_csv.Error.__eq__" => "Return self==value.",
     "_csv.Error.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
@@ -339,8 +3445,8 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "_csv.Error.__sizeof__" => "Size of object in memory, in bytes.",
     "_csv.Error.__str__" => "Return str(self).",
     "_csv.Error.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
-    "_csv.Error.add_note" => "Exception.add_note(note) --\nadd a note to the exception",
-    "_csv.Error.with_traceback" => "Exception.with_traceback(tb) --\nset self.__traceback__ to tb and return self.",
+    "_csv.Error.add_note" => "Add a note to the exception",
+    "_csv.Error.with_traceback" => "Set self.__traceback__ to tb and return self.",
     "_csv.Reader" => "CSV reader\n\nReader objects are responsible for reading and parsing tabular data\nin CSV format.",
     "_csv.Reader.__delattr__" => "Implement delattr(self, name).",
     "_csv.Reader.__eq__" => "Return self==value.",
@@ -397,11 +3503,67 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "_csv.unregister_dialect" => "Delete the name/dialect mapping associated with a string name.",
     "_csv.writer" => "Return a writer object that will write user data on the given file object.\n\nThe \"fileobj\" argument can be any object that supports the file API.\nThe optional \"dialect\" argument defines a CSV dialect.  The function\nalso accepts optional keyword arguments which override settings\nprovided by the dialect.",
     "_ctypes" => "Create and manipulate C compatible data types in Python.",
+    "_ctypes.ArgumentError.__delattr__" => "Implement delattr(self, name).",
+    "_ctypes.ArgumentError.__eq__" => "Return self==value.",
+    "_ctypes.ArgumentError.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_ctypes.ArgumentError.__ge__" => "Return self>=value.",
+    "_ctypes.ArgumentError.__getattribute__" => "Return getattr(self, name).",
+    "_ctypes.ArgumentError.__getstate__" => "Helper for pickle.",
+    "_ctypes.ArgumentError.__gt__" => "Return self>value.",
+    "_ctypes.ArgumentError.__hash__" => "Return hash(self).",
+    "_ctypes.ArgumentError.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_ctypes.ArgumentError.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_ctypes.ArgumentError.__le__" => "Return self<=value.",
+    "_ctypes.ArgumentError.__lt__" => "Return self<value.",
+    "_ctypes.ArgumentError.__ne__" => "Return self!=value.",
+    "_ctypes.ArgumentError.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_ctypes.ArgumentError.__reduce_ex__" => "Helper for pickle.",
+    "_ctypes.ArgumentError.__repr__" => "Return repr(self).",
+    "_ctypes.ArgumentError.__setattr__" => "Implement setattr(self, name, value).",
+    "_ctypes.ArgumentError.__sizeof__" => "Size of object in memory, in bytes.",
+    "_ctypes.ArgumentError.__str__" => "Return str(self).",
+    "_ctypes.ArgumentError.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_ctypes.ArgumentError.__weakref__" => "list of weak references to the object",
+    "_ctypes.ArgumentError.add_note" => "Add a note to the exception",
+    "_ctypes.ArgumentError.with_traceback" => "Set self.__traceback__ to tb and return self.",
     "_ctypes.Array" => "Abstract base class for arrays.\n\nThe recommended way to create concrete array types is by multiplying any\nctypes data type with a non-negative integer. Alternatively, you can subclass\nthis type and define _length_ and _type_ class variables. Array elements can\nbe read and written using standard subscript and slice accesses for slice\nreads, the resulting object is not itself an Array.",
+    "_ctypes.CField" => "Structure/Union member",
+    "_ctypes.CField.__delattr__" => "Implement delattr(self, name).",
+    "_ctypes.CField.__delete__" => "Delete an attribute of instance.",
+    "_ctypes.CField.__eq__" => "Return self==value.",
+    "_ctypes.CField.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_ctypes.CField.__ge__" => "Return self>=value.",
+    "_ctypes.CField.__get__" => "Return an attribute of instance, which is of type owner.",
+    "_ctypes.CField.__getattribute__" => "Return getattr(self, name).",
+    "_ctypes.CField.__getstate__" => "Helper for pickle.",
+    "_ctypes.CField.__gt__" => "Return self>value.",
+    "_ctypes.CField.__hash__" => "Return hash(self).",
+    "_ctypes.CField.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_ctypes.CField.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_ctypes.CField.__le__" => "Return self<=value.",
+    "_ctypes.CField.__lt__" => "Return self<value.",
+    "_ctypes.CField.__ne__" => "Return self!=value.",
+    "_ctypes.CField.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_ctypes.CField.__reduce__" => "Helper for pickle.",
+    "_ctypes.CField.__reduce_ex__" => "Helper for pickle.",
+    "_ctypes.CField.__repr__" => "Return repr(self).",
+    "_ctypes.CField.__set__" => "Set an attribute of instance to value.",
+    "_ctypes.CField.__setattr__" => "Implement setattr(self, name, value).",
+    "_ctypes.CField.__sizeof__" => "Size of object in memory, in bytes.",
+    "_ctypes.CField.__str__" => "Return str(self).",
+    "_ctypes.CField.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_ctypes.CField.bit_offset" => "additional offset in bits (relative to byte_offset); zero for non-bitfields",
+    "_ctypes.CField.bit_size" => "size of this field in bits",
+    "_ctypes.CField.byte_offset" => "offset in bytes of this field. For bitfields: excludes bit_offset.",
+    "_ctypes.CField.byte_size" => "size of this field in bytes",
+    "_ctypes.CField.is_anonymous" => "true if this field is anonymous",
+    "_ctypes.CField.is_bitfield" => "true if this is a bitfield",
+    "_ctypes.CField.name" => "name of this field",
+    "_ctypes.CField.offset" => "offset in bytes of this field (same as byte_offset)",
+    "_ctypes.CField.size" => "size in bytes of this field. For bitfields, this is a legacy packed value; use byte_size instead",
+    "_ctypes.CField.type" => "type of this field",
     "_ctypes.CFuncPtr" => "Function Pointer",
     "_ctypes.COMError" => "Raised when a COM method call failed.",
-    "_ctypes.COMError.__cause__" => "exception cause",
-    "_ctypes.COMError.__context__" => "exception context",
     "_ctypes.COMError.__delattr__" => "Implement delattr(self, name).",
     "_ctypes.COMError.__eq__" => "Return self==value.",
     "_ctypes.COMError.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
@@ -422,28 +3584,26 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "_ctypes.COMError.__sizeof__" => "Size of object in memory, in bytes.",
     "_ctypes.COMError.__str__" => "Return str(self).",
     "_ctypes.COMError.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
-    "_ctypes.COMError.add_note" => "Exception.add_note(note) --\nadd a note to the exception",
-    "_ctypes.COMError.with_traceback" => "Exception.with_traceback(tb) --\nset self.__traceback__ to tb and return self.",
+    "_ctypes.COMError.add_note" => "Add a note to the exception",
+    "_ctypes.COMError.with_traceback" => "Set self.__traceback__ to tb and return self.",
     "_ctypes.CopyComPointer" => "CopyComPointer(src, dst) -> HRESULT value",
     "_ctypes.FormatError" => "FormatError([integer]) -> string\n\nConvert a win32 error code into a string. If the error code is not\ngiven, the return value of a call to GetLastError() is used.",
     "_ctypes.FreeLibrary" => "FreeLibrary(handle) -> void\n\nFree the handle of an executable previously loaded by LoadLibrary.",
     "_ctypes.LoadLibrary" => "LoadLibrary(name, load_flags) -> handle\n\nLoad an executable (usually a DLL), and return a handle to it.\nThe handle may be used to locate exported functions in this\nmodule. load_flags are as defined for LoadLibraryEx in the\nWindows API.",
-    "_ctypes.POINTER" => "Create and return a new ctypes pointer type.\n\n  type\n    A ctypes type.\n\nPointer types are cached and reused internally,\nso calling this function repeatedly is cheap.",
     "_ctypes.Structure" => "Structure base class",
     "_ctypes.Union" => "Union base class",
     "_ctypes._Pointer" => "XXX to be provided",
     "_ctypes._SimpleCData" => "XXX to be provided",
     "_ctypes._dyld_shared_cache_contains_path" => "check if path is in the shared cache",
-    "_ctypes.addressof" => "addressof(C instance) -> integer\nReturn the address of the C instance internal buffer",
+    "_ctypes.addressof" => "Return the address of the C instance internal buffer",
     "_ctypes.alignment" => "alignment(C type) -> integer\nalignment(C instance) -> integer\nReturn the alignment requirements of a C instance",
     "_ctypes.buffer_info" => "Return buffer interface information",
-    "_ctypes.byref" => "byref(C instance[, offset=0]) -> byref-object\nReturn a pointer lookalike to a C instance, only usable\nas function argument",
+    "_ctypes.byref" => "Return a pointer lookalike to a C instance, only usable as function argument.",
     "_ctypes.dlclose" => "dlclose a library",
     "_ctypes.dlopen" => "dlopen(name, flag={RTLD_GLOBAL|RTLD_LOCAL}) open a shared library",
     "_ctypes.dlsym" => "find symbol in shared library",
-    "_ctypes.pointer" => "Create a new pointer instance, pointing to 'obj'.\n\nThe returned object is of the type POINTER(type(obj)). Note that if you\njust want to pass a pointer to an object to a foreign function call, you\nshould use byref(obj) which is much faster.",
-    "_ctypes.resize" => "Resize the memory buffer of a ctypes instance",
-    "_ctypes.sizeof" => "sizeof(C type) -> integer\nsizeof(C instance) -> integer\nReturn the size in bytes of a C instance",
+    "_ctypes.sizeof" => "Return the size in bytes of a C instance.",
+    "_curses.assume_default_colors" => "Allow use of default values for colors on terminals supporting this feature.\n\nAssign terminal default foreground/background colors to color number -1.\nChange the definition of the color-pair 0 to (fg, bg).\n\nUse this to support transparency in your application.",
     "_curses.baudrate" => "Return the output speed of the terminal in bits per second.",
     "_curses.beep" => "Emit a short attention sound.",
     "_curses.can_change_color" => "Return True if the programmer can change the colors displayed by the terminal.",
@@ -453,13 +3613,11 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "_curses.curs_set" => "Set the cursor state.\n\n  visibility\n    0 for invisible, 1 for normal visible, or 2 for very visible.\n\nIf the terminal supports the visibility requested, the previous cursor\nstate is returned; otherwise, an exception is raised.  On many terminals,\nthe \"visible\" mode is an underline cursor and the \"very visible\" mode is\na block cursor.",
     "_curses.def_prog_mode" => "Save the current terminal mode as the \"program\" mode.\n\nThe \"program\" mode is the mode when the running program is using curses.\n\nSubsequent calls to reset_prog_mode() will restore this mode.",
     "_curses.def_shell_mode" => "Save the current terminal mode as the \"shell\" mode.\n\nThe \"shell\" mode is the mode when the running program is not using curses.\n\nSubsequent calls to reset_shell_mode() will restore this mode.",
-    "_curses.delay_output" => "Insert a pause in output.\n\nms\n  Duration in milliseconds.",
+    "_curses.delay_output" => "Insert a pause in output.\n\n  ms\n    Duration in milliseconds.",
     "_curses.doupdate" => "Update the physical screen to match the virtual screen.",
     "_curses.echo" => "Enter echo mode.\n\n  flag\n    If false, the effect is the same as calling noecho().\n\nIn echo mode, each character input is echoed to the screen as it is entered.",
     "_curses.endwin" => "De-initialize the library, and return terminal to normal status.",
     "_curses.erasechar" => "Return the user's current erase character.",
-    "_curses.error.__cause__" => "exception cause",
-    "_curses.error.__context__" => "exception context",
     "_curses.error.__delattr__" => "Implement delattr(self, name).",
     "_curses.error.__eq__" => "Return self==value.",
     "_curses.error.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
@@ -481,8 +3639,8 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "_curses.error.__str__" => "Return str(self).",
     "_curses.error.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
     "_curses.error.__weakref__" => "list of weak references to the object",
-    "_curses.error.add_note" => "Exception.add_note(note) --\nadd a note to the exception",
-    "_curses.error.with_traceback" => "Exception.with_traceback(tb) --\nset self.__traceback__ to tb and return self.",
+    "_curses.error.add_note" => "Add a note to the exception",
+    "_curses.error.with_traceback" => "Set self.__traceback__ to tb and return self.",
     "_curses.flash" => "Flash the screen.\n\nThat is, change it to reverse-video and then change it back in a short interval.",
     "_curses.flushinp" => "Flush all input buffers.\n\nThis throws away any typeahead that has been typed by the user and has not\nyet been processed by the program.",
     "_curses.get_escdelay" => "Gets the curses ESCDELAY setting.\n\nGets the number of milliseconds to wait after reading an escape character,\nto distinguish between an individual escape character entered on the\nkeyboard from escape sequences sent by cursor and function keys.",
@@ -495,20 +3653,20 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "_curses.has_extended_color_support" => "Return True if the module supports extended colors; otherwise, return False.\n\nExtended color support allows more than 256 color-pairs for terminals\nthat support more than 16 colors (e.g. xterm-256color).",
     "_curses.has_ic" => "Return True if the terminal has insert- and delete-character capabilities.",
     "_curses.has_il" => "Return True if the terminal has insert- and delete-line capabilities.",
-    "_curses.has_key" => "Return True if the current terminal type recognizes a key with that value.\n\nkey\n  Key number.",
+    "_curses.has_key" => "Return True if the current terminal type recognizes a key with that value.\n\n  key\n    Key number.",
     "_curses.init_color" => "Change the definition of a color.\n\n  color_number\n    The number of the color to be changed (0 - (COLORS-1)).\n  r\n    Red component (0 - 1000).\n  g\n    Green component (0 - 1000).\n  b\n    Blue component (0 - 1000).\n\nWhen init_color() is used, all occurrences of that color on the screen\nimmediately change to the new definition.  This function is a no-op on\nmost terminals; it is active only if can_change_color() returns true.",
     "_curses.init_pair" => "Change the definition of a color-pair.\n\n  pair_number\n    The number of the color-pair to be changed (1 - (COLOR_PAIRS-1)).\n  fg\n    Foreground color number (-1 - (COLORS-1)).\n  bg\n    Background color number (-1 - (COLORS-1)).\n\nIf the color-pair was previously initialized, the screen is refreshed and\nall occurrences of that color-pair are changed to the new definition.",
     "_curses.initscr" => "Initialize the library.\n\nReturn a WindowObject which represents the whole screen.",
-    "_curses.is_term_resized" => "Return True if resize_term() would modify the window structure, False otherwise.\n\nnlines\n  Height.\nncols\n  Width.",
+    "_curses.is_term_resized" => "Return True if resize_term() would modify the window structure, False otherwise.\n\n  nlines\n    Height.\n  ncols\n    Width.",
     "_curses.isendwin" => "Return True if endwin() has been called.",
-    "_curses.keyname" => "Return the name of specified key.\n\nkey\n  Key number.",
+    "_curses.keyname" => "Return the name of specified key.\n\n  key\n    Key number.",
     "_curses.killchar" => "Return the user's current line kill character.",
     "_curses.longname" => "Return the terminfo long name field describing the current terminal.\n\nThe maximum length of a verbose description is 128 characters.  It is defined\nonly after the call to initscr().",
     "_curses.meta" => "Enable/disable meta keys.\n\nIf yes is True, allow 8-bit characters to be input.  If yes is False,\nallow only 7-bit characters.",
     "_curses.mouseinterval" => "Set and retrieve the maximum time between press and release in a click.\n\n  interval\n    Time in milliseconds.\n\nSet the maximum time that can elapse between press and release events in\norder for them to be recognized as a click, and return the previous interval\nvalue.",
     "_curses.mousemask" => "Set the mouse events to be reported, and return a tuple (availmask, oldmask).\n\nReturn a tuple (availmask, oldmask).  availmask indicates which of the\nspecified mouse events can be reported; on complete failure it returns 0.\noldmask is the previous value of the given window's mouse event mask.\nIf this function is never called, no mouse events are ever reported.",
-    "_curses.napms" => "Sleep for specified time.\n\nms\n  Duration in milliseconds.",
-    "_curses.newpad" => "Create and return a pointer to a new pad data structure.\n\nnlines\n  Height.\nncols\n  Width.",
+    "_curses.napms" => "Sleep for specified time.\n\n  ms\n    Duration in milliseconds.",
+    "_curses.newpad" => "Create and return a pointer to a new pad data structure.\n\n  nlines\n    Height.\n  ncols\n    Width.",
     "_curses.newwin" => "newwin(nlines, ncols, [begin_y=0, begin_x=0])\nReturn a new window.\n\n  nlines\n    Height.\n  ncols\n    Width.\n  begin_y\n    Top side y-coordinate.\n  begin_x\n    Left side x-coordinate.\n\nBy default, the window will extend from the specified position to the lower\nright corner of the screen.",
     "_curses.nl" => "Enter newline mode.\n\n  flag\n    If false, the effect is the same as calling nonl().\n\nThis mode translates the return key into newline on input, and translates\nnewline into return and line-feed on output.  Newline mode is initially on.",
     "_curses.nocbreak" => "Leave cbreak mode.\n\nReturn to normal \"cooked\" mode with line buffering.",
@@ -516,7 +3674,7 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "_curses.nonl" => "Leave newline mode.\n\nDisable translation of return into newline on input, and disable low-level\ntranslation of newline into newline/return on output.",
     "_curses.noqiflush" => "Disable queue flushing.\n\nWhen queue flushing is disabled, normal flush of input and output queues\nassociated with the INTR, QUIT and SUSP characters will not be done.",
     "_curses.noraw" => "Leave raw mode.\n\nReturn to normal \"cooked\" mode with line buffering.",
-    "_curses.pair_content" => "Return a tuple (fg, bg) containing the colors for the requested color pair.\n\npair_number\n  The number of the color pair (0 - (COLOR_PAIRS-1)).",
+    "_curses.pair_content" => "Return a tuple (fg, bg) containing the colors for the requested color pair.\n\n  pair_number\n    The number of the color pair (0 - (COLOR_PAIRS-1)).",
     "_curses.pair_number" => "Return the number of the color-pair set by the specified attribute value.\n\ncolor_pair() is the counterpart to this function.",
     "_curses.putp" => "Emit the value of a specified terminfo capability for the current terminal.\n\nNote that the output of putp() always goes to standard output.",
     "_curses.qiflush" => "Enable queue flushing.\n\n  flag\n    If false, the effect is the same as calling noqiflush().\n\nIf queue flushing is enabled, all output in the display driver queue\nwill be flushed when the INTR, QUIT and SUSP characters are read.",
@@ -530,20 +3688,20 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "_curses.set_escdelay" => "Sets the curses ESCDELAY setting.\n\n  ms\n    length of the delay in milliseconds.\n\nSets the number of milliseconds to wait after reading an escape character,\nto distinguish between an individual escape character entered on the\nkeyboard from escape sequences sent by cursor and function keys.",
     "_curses.set_tabsize" => "Sets the curses TABSIZE setting.\n\n  size\n    rendered cell width of a tab character.\n\nSets the number of columns used by the curses library when converting a tab\ncharacter to spaces as it adds the tab to a window.",
     "_curses.setsyx" => "Set the virtual screen cursor.\n\n  y\n    Y-coordinate.\n  x\n    X-coordinate.\n\nIf y and x are both -1, then leaveok is set.",
-    "_curses.setupterm" => "Initialize the terminal.\n\nterm\n  Terminal name.\n  If omitted, the value of the TERM environment variable will be used.\nfd\n  File descriptor to which any initialization sequences will be sent.\n  If not supplied, the file descriptor for sys.stdout will be used.",
+    "_curses.setupterm" => "Initialize the terminal.\n\n  term\n    Terminal name.\n    If omitted, the value of the TERM environment variable will be used.\n  fd\n    File descriptor to which any initialization sequences will be sent.\n    If not supplied, the file descriptor for sys.stdout will be used.",
     "_curses.start_color" => "Initializes eight basic colors and global variables COLORS and COLOR_PAIRS.\n\nMust be called if the programmer wants to use colors, and before any other\ncolor manipulation routine is called.  It is good practice to call this\nroutine right after initscr().\n\nIt also restores the colors on the terminal to the values they had when the\nterminal was just turned on.",
     "_curses.termattrs" => "Return a logical OR of all video attributes supported by the terminal.",
     "_curses.termname" => "Return the value of the environment variable TERM, truncated to 14 characters.",
     "_curses.tigetflag" => "Return the value of the Boolean capability.\n\n  capname\n    The terminfo capability name.\n\nThe value -1 is returned if capname is not a Boolean capability, or 0 if\nit is canceled or absent from the terminal description.",
     "_curses.tigetnum" => "Return the value of the numeric capability.\n\n  capname\n    The terminfo capability name.\n\nThe value -2 is returned if capname is not a numeric capability, or -1 if\nit is canceled or absent from the terminal description.",
     "_curses.tigetstr" => "Return the value of the string capability.\n\n  capname\n    The terminfo capability name.\n\nNone is returned if capname is not a string capability, or is canceled or\nabsent from the terminal description.",
-    "_curses.tparm" => "Instantiate the specified byte string with the supplied parameters.\n\nstr\n  Parameterized byte string obtained from the terminfo database.",
+    "_curses.tparm" => "Instantiate the specified byte string with the supplied parameters.\n\n  str\n    Parameterized byte string obtained from the terminfo database.",
     "_curses.typeahead" => "Specify that the file descriptor fd be used for typeahead checking.\n\n  fd\n    File descriptor.\n\nIf fd is -1, then no typeahead checking is done.",
     "_curses.unctrl" => "Return a string which is a printable representation of the character ch.\n\nControl characters are displayed as a caret followed by the character,\nfor example as ^C.  Printing characters are left as they are.",
     "_curses.unget_wch" => "Push ch so the next get_wch() will return it.",
     "_curses.ungetch" => "Push ch so the next getch() will return it.",
     "_curses.ungetmouse" => "Push a KEY_MOUSE event onto the input queue.\n\nThe following getmouse() will return the given state data.",
-    "_curses.use_default_colors" => "Allow use of default values for colors on terminals supporting this feature.\n\nUse this to support transparency in your application.  The default color\nis assigned to the color number -1.",
+    "_curses.use_default_colors" => "Equivalent to assume_default_colors(-1, -1).",
     "_curses.use_env" => "Use environment variables LINES and COLUMNS.\n\nIf used, this function should be called before initscr() or newterm() are\ncalled.\n\nWhen flag is False, the values of lines and columns specified in the terminfo\ndatabase will be used, even if environment variables LINES and COLUMNS (used\nby default) are set, or if curses is running in a window (in which case\ndefault behavior would be to use the window size if LINES and COLUMNS are\nnot set).",
     "_curses.window.__delattr__" => "Implement delattr(self, name).",
     "_curses.window.__eq__" => "Return self==value.",
@@ -570,26 +3728,29 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "_curses.window.addnstr" => "addnstr([y, x,] str, n, [attr])\nPaint at most n characters of the string.\n\n  y\n    Y-coordinate.\n  x\n    X-coordinate.\n  str\n    String to add.\n  n\n    Maximal number of characters.\n  attr\n    Attributes for characters.\n\nPaint at most n characters of the string str at (y, x) with\nattributes attr, overwriting anything previously on the display.\nBy default, the character position and attributes are the\ncurrent settings for the window object.",
     "_curses.window.addstr" => "addstr([y, x,] str, [attr])\nPaint the string.\n\n  y\n    Y-coordinate.\n  x\n    X-coordinate.\n  str\n    String to add.\n  attr\n    Attributes for characters.\n\nPaint the string str at (y, x) with attributes attr,\noverwriting anything previously on the display.\nBy default, the character position and attributes are the\ncurrent settings for the window object.",
     "_curses.window.attroff" => "Remove attribute attr from the \"background\" set.",
-    "_curses.window.attron" => "Add attribute attr from the \"background\" set.",
+    "_curses.window.attron" => "Add attribute attr to the \"background\" set.",
     "_curses.window.attrset" => "Set the \"background\" set of attributes.",
-    "_curses.window.bkgd" => "Set the background property of the window.\n\nch\n  Background character.\nattr\n  Background attributes.",
-    "_curses.window.bkgdset" => "Set the window's background.\n\nch\n  Background character.\nattr\n  Background attributes.",
+    "_curses.window.bkgd" => "Set the background property of the window.\n\n  ch\n    Background character.\n  attr\n    Background attributes.",
+    "_curses.window.bkgdset" => "Set the window's background.\n\n  ch\n    Background character.\n  attr\n    Background attributes.",
     "_curses.window.border" => "Draw a border around the edges of the window.\n\n  ls\n    Left side.\n  rs\n    Right side.\n  ts\n    Top side.\n  bs\n    Bottom side.\n  tl\n    Upper-left corner.\n  tr\n    Upper-right corner.\n  bl\n    Bottom-left corner.\n  br\n    Bottom-right corner.\n\nEach parameter specifies the character to use for a specific part of the\nborder.  The characters can be specified as integers or as one-character\nstrings.  A 0 value for any parameter will cause the default character to be\nused for that parameter.",
     "_curses.window.box" => "box([verch=0, horch=0])\nDraw a border around the edges of the window.\n\n  verch\n    Left and right side.\n  horch\n    Top and bottom side.\n\nSimilar to border(), but both ls and rs are verch and both ts and bs are\nhorch.  The default corner characters are always used by this function.",
+    "_curses.window.chgat" => "chgat([y, x,] [n=-1,] attr)\nSet the attributes of characters.\n\n  y\n    Y-coordinate.\n  x\n    X-coordinate.\n  n\n    Number of characters.\n  attr\n    Attributes for characters.\n\nSet the attributes of num characters at the current cursor position, or at\nposition (y, x) if supplied.  If no value of num is given or num = -1, the\nattribute will be set on all the characters to the end of the line.  This\nfunction does not move the cursor.  The changed line will be touched using\nthe touchline() method so that the contents will be redisplayed by the next\nwindow refresh.",
     "_curses.window.delch" => "delch([y, x])\nDelete any character at (y, x).\n\n  y\n    Y-coordinate.\n  x\n    X-coordinate.",
     "_curses.window.derwin" => "derwin([nlines=0, ncols=0,] begin_y, begin_x)\nCreate a sub-window (window-relative coordinates).\n\n  nlines\n    Height.\n  ncols\n    Width.\n  begin_y\n    Top side y-coordinate.\n  begin_x\n    Left side x-coordinate.\n\nderwin() is the same as calling subwin(), except that begin_y and begin_x\nare relative to the origin of the window, rather than relative to the entire\nscreen.",
-    "_curses.window.echochar" => "Add character ch with attribute attr, and refresh.\n\nch\n  Character to add.\nattr\n  Attributes for the character.",
-    "_curses.window.enclose" => "Return True if the screen-relative coordinates are enclosed by the window.\n\ny\n  Y-coordinate.\nx\n  X-coordinate.",
+    "_curses.window.echochar" => "Add character ch with attribute attr, and refresh.\n\n  ch\n    Character to add.\n  attr\n    Attributes for the character.",
+    "_curses.window.enclose" => "Return True if the screen-relative coordinates are enclosed by the window.\n\n  y\n    Y-coordinate.\n  x\n    X-coordinate.",
     "_curses.window.encoding" => "the typecode character used to create the array",
     "_curses.window.get_wch" => "get_wch([y, x])\nGet a wide character from terminal keyboard.\n\n  y\n    Y-coordinate.\n  x\n    X-coordinate.\n\nReturn a character for most keys, or an integer for function keys,\nkeypad keys, and other special keys.",
     "_curses.window.getbkgd" => "Return the window's current background character/attribute pair.",
     "_curses.window.getch" => "getch([y, x])\nGet a character code from terminal keyboard.\n\n  y\n    Y-coordinate.\n  x\n    X-coordinate.\n\nThe integer returned does not have to be in ASCII range: function keys,\nkeypad keys and so on return numbers higher than 256.  In no-delay mode, -1\nis returned if there is no input, else getch() waits until a key is pressed.",
     "_curses.window.getkey" => "getkey([y, x])\nGet a character (string) from terminal keyboard.\n\n  y\n    Y-coordinate.\n  x\n    X-coordinate.\n\nReturning a string instead of an integer, as getch() does.  Function keys,\nkeypad keys and other special keys return a multibyte string containing the\nkey name.  In no-delay mode, an exception is raised if there is no input.",
+    "_curses.window.getstr" => "getstr([[y, x,] n=2047])\nRead a string from the user, with primitive line editing capacity.\n\n  y\n    Y-coordinate.\n  x\n    X-coordinate.\n  n\n    Maximal number of characters.",
     "_curses.window.hline" => "hline([y, x,] ch, n, [attr=_curses.A_NORMAL])\nDisplay a horizontal line.\n\n  y\n    Starting Y-coordinate.\n  x\n    Starting X-coordinate.\n  ch\n    Character to draw.\n  n\n    Line length.\n  attr\n    Attributes for the characters.",
     "_curses.window.inch" => "inch([y, x])\nReturn the character at the given position in the window.\n\n  y\n    Y-coordinate.\n  x\n    X-coordinate.\n\nThe bottom 8 bits are the character proper, and upper bits are the attributes.",
     "_curses.window.insch" => "insch([y, x,] ch, [attr=_curses.A_NORMAL])\nInsert a character before the current or specified position.\n\n  y\n    Y-coordinate.\n  x\n    X-coordinate.\n  ch\n    Character to insert.\n  attr\n    Attributes for the character.\n\nAll characters to the right of the cursor are shifted one position right, with\nthe rightmost characters on the line being lost.",
     "_curses.window.insnstr" => "insnstr([y, x,] str, n, [attr])\nInsert at most n characters of the string.\n\n  y\n    Y-coordinate.\n  x\n    X-coordinate.\n  str\n    String to insert.\n  n\n    Maximal number of characters.\n  attr\n    Attributes for characters.\n\nInsert a character string (as many characters as will fit on the line)\nbefore the character under the cursor, up to n characters.  If n is zero\nor negative, the entire string is inserted.  All characters to the right\nof the cursor are shifted right, with the rightmost characters on the line\nbeing lost.  The cursor position does not change (after moving to y, x, if\nspecified).",
     "_curses.window.insstr" => "insstr([y, x,] str, [attr])\nInsert the string before the current or specified position.\n\n  y\n    Y-coordinate.\n  x\n    X-coordinate.\n  str\n    String to insert.\n  attr\n    Attributes for characters.\n\nInsert a character string (as many characters as will fit on the line)\nbefore the character under the cursor.  All characters to the right of\nthe cursor are shifted right, with the rightmost characters on the line\nbeing lost.  The cursor position does not change (after moving to y, x,\nif specified).",
+    "_curses.window.instr" => "instr([y, x,] n=2047)\nReturn a string of characters, extracted from the window.\n\n  y\n    Y-coordinate.\n  x\n    X-coordinate.\n  n\n    Maximal number of characters.\n\nReturn a string of characters, extracted from the window starting at the\ncurrent cursor position, or at y, x if specified.  Attributes are stripped\nfrom the characters.  If n is specified, instr() returns a string at most\nn characters long (exclusive of the trailing NUL).",
     "_curses.window.is_linetouched" => "Return True if the specified line was modified, otherwise return False.\n\n  line\n    Line number.\n\nRaise a curses.error exception if line is not valid for the given window.",
     "_curses.window.noutrefresh" => "noutrefresh([pminrow, pmincol, sminrow, smincol, smaxrow, smaxcol])\nMark for refresh but wait.\n\nThis function updates the data structure representing the desired state of the\nwindow, but does not force an update of the physical screen.  To accomplish\nthat, call doupdate().",
     "_curses.window.overlay" => "overlay(destwin, [sminrow, smincol, dminrow, dmincol, dmaxrow, dmaxcol])\nOverlay the window on top of destwin.\n\nThe windows need not be the same size, only the overlapping region is copied.\nThis copy is non-destructive, which means that the current background\ncharacter does not overwrite the old contents of destwin.\n\nTo get fine-grained control over the copied region, the second form of\noverlay() can be used.  sminrow and smincol are the upper-left coordinates\nof the source window, and the other variables mark a rectangle in the\ndestination window.",
@@ -604,8 +3765,6 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "_curses.window.touchline" => "touchline(start, count, [changed=True])\nPretend count lines have been changed, starting with line start.\n\nIf changed is supplied, it specifies whether the affected lines are marked\nas having been changed (changed=True) or unchanged (changed=False).",
     "_curses.window.vline" => "vline([y, x,] ch, n, [attr=_curses.A_NORMAL])\nDisplay a vertical line.\n\n  y\n    Starting Y-coordinate.\n  x\n    Starting X-coordinate.\n  ch\n    Character to draw.\n  n\n    Line length.\n  attr\n    Attributes for the character.",
     "_curses_panel.bottom_panel" => "Return the bottom panel in the panel stack.",
-    "_curses_panel.error.__cause__" => "exception cause",
-    "_curses_panel.error.__context__" => "exception context",
     "_curses_panel.error.__delattr__" => "Implement delattr(self, name).",
     "_curses_panel.error.__eq__" => "Return self==value.",
     "_curses_panel.error.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
@@ -627,8 +3786,8 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "_curses_panel.error.__str__" => "Return str(self).",
     "_curses_panel.error.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
     "_curses_panel.error.__weakref__" => "list of weak references to the object",
-    "_curses_panel.error.add_note" => "Exception.add_note(note) --\nadd a note to the exception",
-    "_curses_panel.error.with_traceback" => "Exception.with_traceback(tb) --\nset self.__traceback__ to tb and return self.",
+    "_curses_panel.error.add_note" => "Add a note to the exception",
+    "_curses_panel.error.with_traceback" => "Set self.__traceback__ to tb and return self.",
     "_curses_panel.new_panel" => "Return a panel object, associating it with the given window win.",
     "_curses_panel.panel.__delattr__" => "Implement delattr(self, name).",
     "_curses_panel.panel.__eq__" => "Return self==value.",
@@ -665,9 +3824,232 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "_curses_panel.panel.window" => "Return the window object associated with the panel.",
     "_curses_panel.top_panel" => "Return the top panel in the panel stack.",
     "_curses_panel.update_panels" => "Updates the virtual screen after changes in the panel stack.\n\nThis does not call curses.doupdate(), so you'll have to do this yourself.",
-    "_datetime" => "Fast implementation of the datetime type.",
-    "_dbm.error.__cause__" => "exception cause",
-    "_dbm.error.__context__" => "exception context",
+    "_datetime" => "Fast implementation of the datetime module.",
+    "_datetime.date" => "date(year, month, day) --> date object",
+    "_datetime.date.__add__" => "Return self+value.",
+    "_datetime.date.__delattr__" => "Implement delattr(self, name).",
+    "_datetime.date.__eq__" => "Return self==value.",
+    "_datetime.date.__format__" => "Formats self with strftime.",
+    "_datetime.date.__ge__" => "Return self>=value.",
+    "_datetime.date.__getattribute__" => "Return getattr(self, name).",
+    "_datetime.date.__getstate__" => "Helper for pickle.",
+    "_datetime.date.__gt__" => "Return self>value.",
+    "_datetime.date.__hash__" => "Return hash(self).",
+    "_datetime.date.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_datetime.date.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_datetime.date.__le__" => "Return self<=value.",
+    "_datetime.date.__lt__" => "Return self<value.",
+    "_datetime.date.__ne__" => "Return self!=value.",
+    "_datetime.date.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_datetime.date.__radd__" => "Return value+self.",
+    "_datetime.date.__reduce__" => "__reduce__() -> (cls, state)",
+    "_datetime.date.__reduce_ex__" => "Helper for pickle.",
+    "_datetime.date.__replace__" => "The same as replace().",
+    "_datetime.date.__repr__" => "Return repr(self).",
+    "_datetime.date.__rsub__" => "Return value-self.",
+    "_datetime.date.__setattr__" => "Implement setattr(self, name, value).",
+    "_datetime.date.__sizeof__" => "Size of object in memory, in bytes.",
+    "_datetime.date.__str__" => "Return str(self).",
+    "_datetime.date.__sub__" => "Return self-value.",
+    "_datetime.date.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_datetime.date.ctime" => "Return ctime() style string.",
+    "_datetime.date.fromisocalendar" => "int, int, int -> Construct a date from the ISO year, week number and weekday.\n\nThis is the inverse of the date.isocalendar() function",
+    "_datetime.date.fromisoformat" => "str -> Construct a date from a string in ISO 8601 format.",
+    "_datetime.date.fromordinal" => "int -> date corresponding to a proleptic Gregorian ordinal.",
+    "_datetime.date.fromtimestamp" => "Create a date from a POSIX timestamp.\n\nThe timestamp is a number, e.g. created via time.time(), that is interpreted\nas local time.",
+    "_datetime.date.isocalendar" => "Return a named tuple containing ISO year, week number, and weekday.",
+    "_datetime.date.isoformat" => "Return string in ISO 8601 format, YYYY-MM-DD.",
+    "_datetime.date.isoweekday" => "Return the day of the week represented by the date.\nMonday == 1 ... Sunday == 7",
+    "_datetime.date.replace" => "Return date with new specified fields.",
+    "_datetime.date.strftime" => "format -> strftime() style string.",
+    "_datetime.date.strptime" => "string, format -> new date parsed from a string (like time.strptime()).",
+    "_datetime.date.timetuple" => "Return time tuple, compatible with time.localtime().",
+    "_datetime.date.today" => "Current date or datetime:  same as self.__class__.fromtimestamp(time.time()).",
+    "_datetime.date.toordinal" => "Return proleptic Gregorian ordinal.  January 1 of year 1 is day 1.",
+    "_datetime.date.weekday" => "Return the day of the week represented by the date.\nMonday == 0 ... Sunday == 6",
+    "_datetime.datetime" => "datetime(year, month, day[, hour[, minute[, second[, microsecond[,tzinfo]]]]])\n\nThe year, month and day arguments are required. tzinfo may be None, or an\ninstance of a tzinfo subclass. The remaining arguments may be ints.",
+    "_datetime.datetime.__add__" => "Return self+value.",
+    "_datetime.datetime.__delattr__" => "Implement delattr(self, name).",
+    "_datetime.datetime.__eq__" => "Return self==value.",
+    "_datetime.datetime.__format__" => "Formats self with strftime.",
+    "_datetime.datetime.__ge__" => "Return self>=value.",
+    "_datetime.datetime.__getattribute__" => "Return getattr(self, name).",
+    "_datetime.datetime.__getstate__" => "Helper for pickle.",
+    "_datetime.datetime.__gt__" => "Return self>value.",
+    "_datetime.datetime.__hash__" => "Return hash(self).",
+    "_datetime.datetime.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_datetime.datetime.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_datetime.datetime.__le__" => "Return self<=value.",
+    "_datetime.datetime.__lt__" => "Return self<value.",
+    "_datetime.datetime.__ne__" => "Return self!=value.",
+    "_datetime.datetime.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_datetime.datetime.__radd__" => "Return value+self.",
+    "_datetime.datetime.__reduce__" => "__reduce__() -> (cls, state)",
+    "_datetime.datetime.__reduce_ex__" => "__reduce_ex__(proto) -> (cls, state)",
+    "_datetime.datetime.__replace__" => "The same as replace().",
+    "_datetime.datetime.__repr__" => "Return repr(self).",
+    "_datetime.datetime.__rsub__" => "Return value-self.",
+    "_datetime.datetime.__setattr__" => "Implement setattr(self, name, value).",
+    "_datetime.datetime.__sizeof__" => "Size of object in memory, in bytes.",
+    "_datetime.datetime.__str__" => "Return str(self).",
+    "_datetime.datetime.__sub__" => "Return self-value.",
+    "_datetime.datetime.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_datetime.datetime.astimezone" => "tz -> convert to local time in new timezone tz",
+    "_datetime.datetime.combine" => "date, time -> datetime with same date and time fields",
+    "_datetime.datetime.ctime" => "Return ctime() style string.",
+    "_datetime.datetime.date" => "Return date object with same year, month and day.",
+    "_datetime.datetime.dst" => "Return self.tzinfo.dst(self).",
+    "_datetime.datetime.fromisocalendar" => "int, int, int -> Construct a date from the ISO year, week number and weekday.\n\nThis is the inverse of the date.isocalendar() function",
+    "_datetime.datetime.fromisoformat" => "string -> datetime from a string in most ISO 8601 formats",
+    "_datetime.datetime.fromordinal" => "int -> date corresponding to a proleptic Gregorian ordinal.",
+    "_datetime.datetime.fromtimestamp" => "timestamp[, tz] -> tz's local time from POSIX timestamp.",
+    "_datetime.datetime.isocalendar" => "Return a named tuple containing ISO year, week number, and weekday.",
+    "_datetime.datetime.isoformat" => "[sep] -> string in ISO 8601 format, YYYY-MM-DDT[HH[:MM[:SS[.mmm[uuu]]]]][+HH:MM].\nsep is used to separate the year from the time, and defaults to 'T'.\nThe optional argument timespec specifies the number of additional terms\nof the time to include. Valid options are 'auto', 'hours', 'minutes',\n'seconds', 'milliseconds' and 'microseconds'.",
+    "_datetime.datetime.isoweekday" => "Return the day of the week represented by the date.\nMonday == 1 ... Sunday == 7",
+    "_datetime.datetime.now" => "Returns new datetime object representing current time local to tz.\n\n  tz\n    Timezone object.\n\nIf no tz is specified, uses local timezone.",
+    "_datetime.datetime.replace" => "Return datetime with new specified fields.",
+    "_datetime.datetime.strftime" => "format -> strftime() style string.",
+    "_datetime.datetime.strptime" => "string, format -> new datetime parsed from a string (like time.strptime()).",
+    "_datetime.datetime.time" => "Return time object with same time but with tzinfo=None.",
+    "_datetime.datetime.timestamp" => "Return POSIX timestamp as float.",
+    "_datetime.datetime.timetuple" => "Return time tuple, compatible with time.localtime().",
+    "_datetime.datetime.timetz" => "Return time object with same time and tzinfo.",
+    "_datetime.datetime.today" => "Current date or datetime:  same as self.__class__.fromtimestamp(time.time()).",
+    "_datetime.datetime.toordinal" => "Return proleptic Gregorian ordinal.  January 1 of year 1 is day 1.",
+    "_datetime.datetime.tzname" => "Return self.tzinfo.tzname(self).",
+    "_datetime.datetime.utcfromtimestamp" => "Construct a naive UTC datetime from a POSIX timestamp.",
+    "_datetime.datetime.utcnow" => "Return a new datetime representing UTC day and time.",
+    "_datetime.datetime.utcoffset" => "Return self.tzinfo.utcoffset(self).",
+    "_datetime.datetime.utctimetuple" => "Return UTC time tuple, compatible with time.localtime().",
+    "_datetime.datetime.weekday" => "Return the day of the week represented by the date.\nMonday == 0 ... Sunday == 6",
+    "_datetime.time" => "time([hour[, minute[, second[, microsecond[, tzinfo]]]]]) --> a time object\n\nAll arguments are optional. tzinfo may be None, or an instance of\na tzinfo subclass. The remaining arguments may be ints.",
+    "_datetime.time.__delattr__" => "Implement delattr(self, name).",
+    "_datetime.time.__eq__" => "Return self==value.",
+    "_datetime.time.__format__" => "Formats self with strftime.",
+    "_datetime.time.__ge__" => "Return self>=value.",
+    "_datetime.time.__getattribute__" => "Return getattr(self, name).",
+    "_datetime.time.__getstate__" => "Helper for pickle.",
+    "_datetime.time.__gt__" => "Return self>value.",
+    "_datetime.time.__hash__" => "Return hash(self).",
+    "_datetime.time.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_datetime.time.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_datetime.time.__le__" => "Return self<=value.",
+    "_datetime.time.__lt__" => "Return self<value.",
+    "_datetime.time.__ne__" => "Return self!=value.",
+    "_datetime.time.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_datetime.time.__reduce__" => "__reduce__() -> (cls, state)",
+    "_datetime.time.__reduce_ex__" => "__reduce_ex__(proto) -> (cls, state)",
+    "_datetime.time.__replace__" => "The same as replace().",
+    "_datetime.time.__repr__" => "Return repr(self).",
+    "_datetime.time.__setattr__" => "Implement setattr(self, name, value).",
+    "_datetime.time.__sizeof__" => "Size of object in memory, in bytes.",
+    "_datetime.time.__str__" => "Return str(self).",
+    "_datetime.time.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_datetime.time.dst" => "Return self.tzinfo.dst(self).",
+    "_datetime.time.fromisoformat" => "string -> time from a string in ISO 8601 format",
+    "_datetime.time.isoformat" => "Return string in ISO 8601 format, [HH[:MM[:SS[.mmm[uuu]]]]][+HH:MM].\n\nThe optional argument timespec specifies the number of additional terms\nof the time to include. Valid options are 'auto', 'hours', 'minutes',\n'seconds', 'milliseconds' and 'microseconds'.",
+    "_datetime.time.replace" => "Return time with new specified fields.",
+    "_datetime.time.strftime" => "format -> strftime() style string.",
+    "_datetime.time.strptime" => "string, format -> new time parsed from a string (like time.strptime()).",
+    "_datetime.time.tzname" => "Return self.tzinfo.tzname(self).",
+    "_datetime.time.utcoffset" => "Return self.tzinfo.utcoffset(self).",
+    "_datetime.timedelta" => "Difference between two datetime values.\n\ntimedelta(days=0, seconds=0, microseconds=0, milliseconds=0, minutes=0, hours=0, weeks=0)\n\nAll arguments are optional and default to 0.\nArguments may be integers or floats, and may be positive or negative.",
+    "_datetime.timedelta.__abs__" => "abs(self)",
+    "_datetime.timedelta.__add__" => "Return self+value.",
+    "_datetime.timedelta.__bool__" => "True if self else False",
+    "_datetime.timedelta.__delattr__" => "Implement delattr(self, name).",
+    "_datetime.timedelta.__divmod__" => "Return divmod(self, value).",
+    "_datetime.timedelta.__eq__" => "Return self==value.",
+    "_datetime.timedelta.__floordiv__" => "Return self//value.",
+    "_datetime.timedelta.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_datetime.timedelta.__ge__" => "Return self>=value.",
+    "_datetime.timedelta.__getattribute__" => "Return getattr(self, name).",
+    "_datetime.timedelta.__getstate__" => "Helper for pickle.",
+    "_datetime.timedelta.__gt__" => "Return self>value.",
+    "_datetime.timedelta.__hash__" => "Return hash(self).",
+    "_datetime.timedelta.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_datetime.timedelta.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_datetime.timedelta.__le__" => "Return self<=value.",
+    "_datetime.timedelta.__lt__" => "Return self<value.",
+    "_datetime.timedelta.__mod__" => "Return self%value.",
+    "_datetime.timedelta.__mul__" => "Return self*value.",
+    "_datetime.timedelta.__ne__" => "Return self!=value.",
+    "_datetime.timedelta.__neg__" => "-self",
+    "_datetime.timedelta.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_datetime.timedelta.__pos__" => "+self",
+    "_datetime.timedelta.__radd__" => "Return value+self.",
+    "_datetime.timedelta.__rdivmod__" => "Return divmod(value, self).",
+    "_datetime.timedelta.__reduce__" => "__reduce__() -> (cls, state)",
+    "_datetime.timedelta.__reduce_ex__" => "Helper for pickle.",
+    "_datetime.timedelta.__repr__" => "Return repr(self).",
+    "_datetime.timedelta.__rfloordiv__" => "Return value//self.",
+    "_datetime.timedelta.__rmod__" => "Return value%self.",
+    "_datetime.timedelta.__rmul__" => "Return value*self.",
+    "_datetime.timedelta.__rsub__" => "Return value-self.",
+    "_datetime.timedelta.__rtruediv__" => "Return value/self.",
+    "_datetime.timedelta.__setattr__" => "Implement setattr(self, name, value).",
+    "_datetime.timedelta.__sizeof__" => "Size of object in memory, in bytes.",
+    "_datetime.timedelta.__str__" => "Return str(self).",
+    "_datetime.timedelta.__sub__" => "Return self-value.",
+    "_datetime.timedelta.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_datetime.timedelta.__truediv__" => "Return self/value.",
+    "_datetime.timedelta.days" => "Number of days.",
+    "_datetime.timedelta.microseconds" => "Number of microseconds (>= 0 and less than 1 second).",
+    "_datetime.timedelta.seconds" => "Number of seconds (>= 0 and less than 1 day).",
+    "_datetime.timedelta.total_seconds" => "Total seconds in the duration.",
+    "_datetime.timezone" => "Fixed offset from UTC implementation of tzinfo.",
+    "_datetime.timezone.__delattr__" => "Implement delattr(self, name).",
+    "_datetime.timezone.__eq__" => "Return self==value.",
+    "_datetime.timezone.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_datetime.timezone.__ge__" => "Return self>=value.",
+    "_datetime.timezone.__getattribute__" => "Return getattr(self, name).",
+    "_datetime.timezone.__getinitargs__" => "pickle support",
+    "_datetime.timezone.__getstate__" => "Helper for pickle.",
+    "_datetime.timezone.__gt__" => "Return self>value.",
+    "_datetime.timezone.__hash__" => "Return hash(self).",
+    "_datetime.timezone.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_datetime.timezone.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_datetime.timezone.__le__" => "Return self<=value.",
+    "_datetime.timezone.__lt__" => "Return self<value.",
+    "_datetime.timezone.__ne__" => "Return self!=value.",
+    "_datetime.timezone.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_datetime.timezone.__reduce__" => "-> (cls, state)",
+    "_datetime.timezone.__reduce_ex__" => "Helper for pickle.",
+    "_datetime.timezone.__repr__" => "Return repr(self).",
+    "_datetime.timezone.__setattr__" => "Implement setattr(self, name, value).",
+    "_datetime.timezone.__sizeof__" => "Size of object in memory, in bytes.",
+    "_datetime.timezone.__str__" => "Return str(self).",
+    "_datetime.timezone.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_datetime.timezone.dst" => "Return None.",
+    "_datetime.timezone.fromutc" => "datetime in UTC -> datetime in local time.",
+    "_datetime.timezone.tzname" => "If name is specified when timezone is created, returns the name.  Otherwise returns offset as 'UTC(+|-)HH:MM'.",
+    "_datetime.timezone.utcoffset" => "Return fixed offset.",
+    "_datetime.tzinfo" => "Abstract base class for time zone info objects.",
+    "_datetime.tzinfo.__delattr__" => "Implement delattr(self, name).",
+    "_datetime.tzinfo.__eq__" => "Return self==value.",
+    "_datetime.tzinfo.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_datetime.tzinfo.__ge__" => "Return self>=value.",
+    "_datetime.tzinfo.__getattribute__" => "Return getattr(self, name).",
+    "_datetime.tzinfo.__getstate__" => "Helper for pickle.",
+    "_datetime.tzinfo.__gt__" => "Return self>value.",
+    "_datetime.tzinfo.__hash__" => "Return hash(self).",
+    "_datetime.tzinfo.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_datetime.tzinfo.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_datetime.tzinfo.__le__" => "Return self<=value.",
+    "_datetime.tzinfo.__lt__" => "Return self<value.",
+    "_datetime.tzinfo.__ne__" => "Return self!=value.",
+    "_datetime.tzinfo.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_datetime.tzinfo.__reduce__" => "-> (cls, state)",
+    "_datetime.tzinfo.__reduce_ex__" => "Helper for pickle.",
+    "_datetime.tzinfo.__repr__" => "Return repr(self).",
+    "_datetime.tzinfo.__setattr__" => "Implement setattr(self, name, value).",
+    "_datetime.tzinfo.__sizeof__" => "Size of object in memory, in bytes.",
+    "_datetime.tzinfo.__str__" => "Return str(self).",
+    "_datetime.tzinfo.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_datetime.tzinfo.dst" => "datetime -> DST offset as timedelta positive east of UTC.",
+    "_datetime.tzinfo.fromutc" => "datetime in UTC -> datetime in local time.",
+    "_datetime.tzinfo.tzname" => "datetime -> string name of time zone.",
+    "_datetime.tzinfo.utcoffset" => "datetime -> timedelta showing offset from UTC, negative values indicating West of UTC",
     "_dbm.error.__delattr__" => "Implement delattr(self, name).",
     "_dbm.error.__eq__" => "Return self==value.",
     "_dbm.error.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
@@ -689,24 +4071,744 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "_dbm.error.__str__" => "Return str(self).",
     "_dbm.error.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
     "_dbm.error.__weakref__" => "list of weak references to the object",
-    "_dbm.error.add_note" => "Exception.add_note(note) --\nadd a note to the exception",
+    "_dbm.error.add_note" => "Add a note to the exception",
     "_dbm.error.errno" => "POSIX exception code",
     "_dbm.error.filename" => "exception filename",
     "_dbm.error.filename2" => "second exception filename",
     "_dbm.error.strerror" => "exception strerror",
-    "_dbm.error.with_traceback" => "Exception.with_traceback(tb) --\nset self.__traceback__ to tb and return self.",
-    "_dbm.open" => "Return a database object.\n\nfilename\n  The filename to open.\nflags\n  How to open the file.  \"r\" for reading, \"w\" for writing, etc.\nmode\n  If creating a new file, the mode bits for the new file\n  (e.g. os.O_RDWR).",
+    "_dbm.error.with_traceback" => "Set self.__traceback__ to tb and return self.",
+    "_dbm.open" => "Return a database object.\n\n  filename\n    The filename to open.\n  flags\n    How to open the file.  \"r\" for reading, \"w\" for writing, etc.\n  mode\n    If creating a new file, the mode bits for the new file\n    (e.g. os.O_RDWR).",
     "_decimal" => "C decimal arithmetic module",
+    "_decimal.Clamped.__delattr__" => "Implement delattr(self, name).",
+    "_decimal.Clamped.__eq__" => "Return self==value.",
+    "_decimal.Clamped.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_decimal.Clamped.__ge__" => "Return self>=value.",
+    "_decimal.Clamped.__getattribute__" => "Return getattr(self, name).",
+    "_decimal.Clamped.__getstate__" => "Helper for pickle.",
+    "_decimal.Clamped.__gt__" => "Return self>value.",
+    "_decimal.Clamped.__hash__" => "Return hash(self).",
+    "_decimal.Clamped.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_decimal.Clamped.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_decimal.Clamped.__le__" => "Return self<=value.",
+    "_decimal.Clamped.__lt__" => "Return self<value.",
+    "_decimal.Clamped.__ne__" => "Return self!=value.",
+    "_decimal.Clamped.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_decimal.Clamped.__reduce_ex__" => "Helper for pickle.",
+    "_decimal.Clamped.__repr__" => "Return repr(self).",
+    "_decimal.Clamped.__setattr__" => "Implement setattr(self, name, value).",
+    "_decimal.Clamped.__sizeof__" => "Size of object in memory, in bytes.",
+    "_decimal.Clamped.__str__" => "Return str(self).",
+    "_decimal.Clamped.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_decimal.Clamped.__weakref__" => "list of weak references to the object",
+    "_decimal.Clamped.add_note" => "Add a note to the exception",
+    "_decimal.Clamped.with_traceback" => "Set self.__traceback__ to tb and return self.",
+    "_decimal.Context" => "The context affects almost all operations and controls rounding,\nOver/Underflow, raising of exceptions and much more.  A new context\ncan be constructed as follows:\n\n    >>> c = Context(prec=28, Emin=-425000000, Emax=425000000,\n    ...             rounding=ROUND_HALF_EVEN, capitals=1, clamp=1,\n    ...             traps=[InvalidOperation, DivisionByZero, Overflow],\n    ...             flags=[])\n    >>>",
+    "_decimal.Context.Etiny" => "Return a value equal to Emin - prec + 1, which is the minimum exponent value\nfor subnormal results.  When underflow occurs, the exponent is set to Etiny.",
+    "_decimal.Context.Etop" => "Return a value equal to Emax - prec + 1.  This is the maximum exponent\nif the _clamp field of the context is set to 1 (IEEE clamp mode).  Etop()\nmust not be negative.",
+    "_decimal.Context.__delattr__" => "Implement delattr(self, name).",
+    "_decimal.Context.__eq__" => "Return self==value.",
+    "_decimal.Context.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_decimal.Context.__ge__" => "Return self>=value.",
+    "_decimal.Context.__getattribute__" => "Return getattr(self, name).",
+    "_decimal.Context.__getstate__" => "Helper for pickle.",
+    "_decimal.Context.__gt__" => "Return self>value.",
+    "_decimal.Context.__hash__" => "Return hash(self).",
+    "_decimal.Context.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_decimal.Context.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_decimal.Context.__le__" => "Return self<=value.",
+    "_decimal.Context.__lt__" => "Return self<value.",
+    "_decimal.Context.__ne__" => "Return self!=value.",
+    "_decimal.Context.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_decimal.Context.__reduce_ex__" => "Helper for pickle.",
+    "_decimal.Context.__repr__" => "Return repr(self).",
+    "_decimal.Context.__setattr__" => "Implement setattr(self, name, value).",
+    "_decimal.Context.__sizeof__" => "Size of object in memory, in bytes.",
+    "_decimal.Context.__str__" => "Return str(self).",
+    "_decimal.Context.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_decimal.Context.abs" => "Return the absolute value of x.",
+    "_decimal.Context.add" => "Return the sum of x and y.",
+    "_decimal.Context.canonical" => "Return a new instance of x.",
+    "_decimal.Context.clear_flags" => "Reset all flags to False.",
+    "_decimal.Context.clear_traps" => "Set all traps to False.",
+    "_decimal.Context.compare" => "Compare x and y numerically.",
+    "_decimal.Context.compare_signal" => "Compare x and y numerically.  All NaNs signal.",
+    "_decimal.Context.compare_total" => "Compare x and y using their abstract representation.",
+    "_decimal.Context.compare_total_mag" => "Compare x and y using their abstract representation, ignoring sign.",
+    "_decimal.Context.copy" => "Return a duplicate of the context with all flags cleared.",
+    "_decimal.Context.copy_abs" => "Return a copy of x with the sign set to 0.",
+    "_decimal.Context.copy_decimal" => "Return a copy of Decimal x.",
+    "_decimal.Context.copy_negate" => "Return a copy of x with the sign inverted.",
+    "_decimal.Context.copy_sign" => "Copy the sign from y to x.",
+    "_decimal.Context.create_decimal" => "Create a new Decimal instance from num, using self as the context. Unlike the\nDecimal constructor, this function observes the context limits.",
+    "_decimal.Context.create_decimal_from_float" => "Create a new Decimal instance from float f.  Unlike the Decimal.from_float()\nclass method, this function observes the context limits.",
+    "_decimal.Context.divide" => "Return x divided by y.",
+    "_decimal.Context.divide_int" => "Return x divided by y, truncated to an integer.",
+    "_decimal.Context.divmod" => "Return quotient and remainder of the division x / y.",
+    "_decimal.Context.exp" => "Return e ** x.",
+    "_decimal.Context.fma" => "Return x multiplied by y, plus z.",
+    "_decimal.Context.is_canonical" => "Return True if x is canonical, False otherwise.",
+    "_decimal.Context.is_finite" => "Return True if x is finite, False otherwise.",
+    "_decimal.Context.is_infinite" => "Return True if x is infinite, False otherwise.",
+    "_decimal.Context.is_nan" => "Return True if x is a qNaN or sNaN, False otherwise.",
+    "_decimal.Context.is_normal" => "Return True if x is a normal number, False otherwise.",
+    "_decimal.Context.is_qnan" => "Return True if x is a quiet NaN, False otherwise.",
+    "_decimal.Context.is_signed" => "Return True if x is negative, False otherwise.",
+    "_decimal.Context.is_snan" => "Return True if x is a signaling NaN, False otherwise.",
+    "_decimal.Context.is_subnormal" => "Return True if x is subnormal, False otherwise.",
+    "_decimal.Context.is_zero" => "Return True if x is a zero, False otherwise.",
+    "_decimal.Context.ln" => "Return the natural (base e) logarithm of x.",
+    "_decimal.Context.log10" => "Return the base 10 logarithm of x.",
+    "_decimal.Context.logb" => "Return the exponent of the magnitude of the operand's MSD.",
+    "_decimal.Context.logical_and" => "Applies the logical operation 'and' between each operand's digits.\n\nThe operands must be both logical numbers.\n\n    >>> ExtendedContext.logical_and(Decimal('0'), Decimal('0'))\n    Decimal('0')\n    >>> ExtendedContext.logical_and(Decimal('0'), Decimal('1'))\n    Decimal('0')\n    >>> ExtendedContext.logical_and(Decimal('1'), Decimal('0'))\n    Decimal('0')\n    >>> ExtendedContext.logical_and(Decimal('1'), Decimal('1'))\n    Decimal('1')\n    >>> ExtendedContext.logical_and(Decimal('1100'), Decimal('1010'))\n    Decimal('1000')\n    >>> ExtendedContext.logical_and(Decimal('1111'), Decimal('10'))\n    Decimal('10')\n    >>> ExtendedContext.logical_and(110, 1101)\n    Decimal('100')\n    >>> ExtendedContext.logical_and(Decimal(110), 1101)\n    Decimal('100')\n    >>> ExtendedContext.logical_and(110, Decimal(1101))\n    Decimal('100')",
+    "_decimal.Context.logical_invert" => "Invert all the digits in the operand.\n\nThe operand must be a logical number.\n\n    >>> ExtendedContext.logical_invert(Decimal('0'))\n    Decimal('111111111')\n    >>> ExtendedContext.logical_invert(Decimal('1'))\n    Decimal('111111110')\n    >>> ExtendedContext.logical_invert(Decimal('111111111'))\n    Decimal('0')\n    >>> ExtendedContext.logical_invert(Decimal('101010101'))\n    Decimal('10101010')\n    >>> ExtendedContext.logical_invert(1101)\n    Decimal('111110010')",
+    "_decimal.Context.logical_or" => "Applies the logical operation 'or' between each operand's digits.\n\nThe operands must be both logical numbers.\n\n    >>> ExtendedContext.logical_or(Decimal('0'), Decimal('0'))\n    Decimal('0')\n    >>> ExtendedContext.logical_or(Decimal('0'), Decimal('1'))\n    Decimal('1')\n    >>> ExtendedContext.logical_or(Decimal('1'), Decimal('0'))\n    Decimal('1')\n    >>> ExtendedContext.logical_or(Decimal('1'), Decimal('1'))\n    Decimal('1')\n    >>> ExtendedContext.logical_or(Decimal('1100'), Decimal('1010'))\n    Decimal('1110')\n    >>> ExtendedContext.logical_or(Decimal('1110'), Decimal('10'))\n    Decimal('1110')\n    >>> ExtendedContext.logical_or(110, 1101)\n    Decimal('1111')\n    >>> ExtendedContext.logical_or(Decimal(110), 1101)\n    Decimal('1111')\n    >>> ExtendedContext.logical_or(110, Decimal(1101))\n    Decimal('1111')",
+    "_decimal.Context.logical_xor" => "Applies the logical operation 'xor' between each operand's digits.\n\nThe operands must be both logical numbers.\n\n    >>> ExtendedContext.logical_xor(Decimal('0'), Decimal('0'))\n    Decimal('0')\n    >>> ExtendedContext.logical_xor(Decimal('0'), Decimal('1'))\n    Decimal('1')\n    >>> ExtendedContext.logical_xor(Decimal('1'), Decimal('0'))\n    Decimal('1')\n    >>> ExtendedContext.logical_xor(Decimal('1'), Decimal('1'))\n    Decimal('0')\n    >>> ExtendedContext.logical_xor(Decimal('1100'), Decimal('1010'))\n    Decimal('110')\n    >>> ExtendedContext.logical_xor(Decimal('1111'), Decimal('10'))\n    Decimal('1101')\n    >>> ExtendedContext.logical_xor(110, 1101)\n    Decimal('1011')\n    >>> ExtendedContext.logical_xor(Decimal(110), 1101)\n    Decimal('1011')\n    >>> ExtendedContext.logical_xor(110, Decimal(1101))\n    Decimal('1011')",
+    "_decimal.Context.max" => "Compare the values numerically and return the maximum.",
+    "_decimal.Context.max_mag" => "Compare the values numerically with their sign ignored.",
+    "_decimal.Context.min" => "Compare the values numerically and return the minimum.",
+    "_decimal.Context.min_mag" => "Compare the values numerically with their sign ignored.",
+    "_decimal.Context.minus" => "Minus corresponds to the unary prefix minus operator in Python, but applies\nthe context to the result.",
+    "_decimal.Context.multiply" => "Return the product of x and y.",
+    "_decimal.Context.next_minus" => "Return the largest representable number smaller than x.",
+    "_decimal.Context.next_plus" => "Return the smallest representable number larger than x.",
+    "_decimal.Context.next_toward" => "Return the number closest to x, in the direction towards y.",
+    "_decimal.Context.normalize" => "Reduce x to its simplest form. Alias for reduce(x).",
+    "_decimal.Context.number_class" => "Return an indication of the class of x.",
+    "_decimal.Context.plus" => "Plus corresponds to the unary prefix plus operator in Python, but applies\nthe context to the result.",
+    "_decimal.Context.power" => "Compute a**b. If 'a' is negative, then 'b' must be integral. The result\nwill be inexact unless 'a' is integral and the result is finite and can\nbe expressed exactly in 'precision' digits.  In the Python version the\nresult is always correctly rounded, in the C version the result is almost\nalways correctly rounded.\n\nIf modulo is given, compute (a**b) % modulo. The following restrictions\nhold:\n\n    * all three arguments must be integral\n    * 'b' must be nonnegative\n    * at least one of 'a' or 'b' must be nonzero\n    * modulo must be nonzero and less than 10**prec in absolute value",
+    "_decimal.Context.quantize" => "Return a value equal to x (rounded), having the exponent of y.",
+    "_decimal.Context.radix" => "Return 10.",
+    "_decimal.Context.remainder" => "Return the remainder from integer division.  The sign of the result,\nif non-zero, is the same as that of the original dividend.",
+    "_decimal.Context.remainder_near" => "Return x - y * n, where n is the integer nearest the exact value of x / y\n(if the result is 0 then its sign will be the sign of x).",
+    "_decimal.Context.rotate" => "Return a copy of x, rotated by y places.",
+    "_decimal.Context.same_quantum" => "Return True if the two operands have the same exponent.",
+    "_decimal.Context.scaleb" => "Return the first operand after adding the second value to its exp.",
+    "_decimal.Context.shift" => "Return a copy of x, shifted by y places.",
+    "_decimal.Context.sqrt" => "Square root of a non-negative number to context precision.",
+    "_decimal.Context.subtract" => "Return the difference between x and y.",
+    "_decimal.Context.to_eng_string" => "Convert a number to a string, using engineering notation.",
+    "_decimal.Context.to_integral" => "Identical to to_integral_value(x).",
+    "_decimal.Context.to_integral_exact" => "Round to an integer. Signal if the result is rounded or inexact.",
+    "_decimal.Context.to_integral_value" => "Round to an integer.",
+    "_decimal.Context.to_sci_string" => "Convert a number to a string using scientific notation.",
+    "_decimal.ConversionSyntax.__delattr__" => "Implement delattr(self, name).",
+    "_decimal.ConversionSyntax.__eq__" => "Return self==value.",
+    "_decimal.ConversionSyntax.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_decimal.ConversionSyntax.__ge__" => "Return self>=value.",
+    "_decimal.ConversionSyntax.__getattribute__" => "Return getattr(self, name).",
+    "_decimal.ConversionSyntax.__getstate__" => "Helper for pickle.",
+    "_decimal.ConversionSyntax.__gt__" => "Return self>value.",
+    "_decimal.ConversionSyntax.__hash__" => "Return hash(self).",
+    "_decimal.ConversionSyntax.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_decimal.ConversionSyntax.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_decimal.ConversionSyntax.__le__" => "Return self<=value.",
+    "_decimal.ConversionSyntax.__lt__" => "Return self<value.",
+    "_decimal.ConversionSyntax.__ne__" => "Return self!=value.",
+    "_decimal.ConversionSyntax.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_decimal.ConversionSyntax.__reduce_ex__" => "Helper for pickle.",
+    "_decimal.ConversionSyntax.__repr__" => "Return repr(self).",
+    "_decimal.ConversionSyntax.__setattr__" => "Implement setattr(self, name, value).",
+    "_decimal.ConversionSyntax.__sizeof__" => "Size of object in memory, in bytes.",
+    "_decimal.ConversionSyntax.__str__" => "Return str(self).",
+    "_decimal.ConversionSyntax.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_decimal.ConversionSyntax.__weakref__" => "list of weak references to the object",
+    "_decimal.ConversionSyntax.add_note" => "Add a note to the exception",
+    "_decimal.ConversionSyntax.with_traceback" => "Set self.__traceback__ to tb and return self.",
+    "_decimal.Decimal" => "Construct a new Decimal object. 'value' can be an integer, string, tuple,\nor another Decimal object. If no value is given, return Decimal('0'). The\ncontext does not affect the conversion and is only passed to determine if\nthe InvalidOperation trap is active.",
+    "_decimal.Decimal.__abs__" => "abs(self)",
+    "_decimal.Decimal.__add__" => "Return self+value.",
+    "_decimal.Decimal.__bool__" => "True if self else False",
+    "_decimal.Decimal.__delattr__" => "Implement delattr(self, name).",
+    "_decimal.Decimal.__divmod__" => "Return divmod(self, value).",
+    "_decimal.Decimal.__eq__" => "Return self==value.",
+    "_decimal.Decimal.__float__" => "float(self)",
+    "_decimal.Decimal.__floordiv__" => "Return self//value.",
+    "_decimal.Decimal.__ge__" => "Return self>=value.",
+    "_decimal.Decimal.__getattribute__" => "Return getattr(self, name).",
+    "_decimal.Decimal.__getstate__" => "Helper for pickle.",
+    "_decimal.Decimal.__gt__" => "Return self>value.",
+    "_decimal.Decimal.__hash__" => "Return hash(self).",
+    "_decimal.Decimal.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_decimal.Decimal.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_decimal.Decimal.__int__" => "int(self)",
+    "_decimal.Decimal.__le__" => "Return self<=value.",
+    "_decimal.Decimal.__lt__" => "Return self<value.",
+    "_decimal.Decimal.__mod__" => "Return self%value.",
+    "_decimal.Decimal.__mul__" => "Return self*value.",
+    "_decimal.Decimal.__ne__" => "Return self!=value.",
+    "_decimal.Decimal.__neg__" => "-self",
+    "_decimal.Decimal.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_decimal.Decimal.__pos__" => "+self",
+    "_decimal.Decimal.__pow__" => "Return pow(self, value, mod).",
+    "_decimal.Decimal.__radd__" => "Return value+self.",
+    "_decimal.Decimal.__rdivmod__" => "Return divmod(value, self).",
+    "_decimal.Decimal.__reduce_ex__" => "Helper for pickle.",
+    "_decimal.Decimal.__repr__" => "Return repr(self).",
+    "_decimal.Decimal.__rfloordiv__" => "Return value//self.",
+    "_decimal.Decimal.__rmod__" => "Return value%self.",
+    "_decimal.Decimal.__rmul__" => "Return value*self.",
+    "_decimal.Decimal.__rpow__" => "Return pow(value, self, mod).",
+    "_decimal.Decimal.__rsub__" => "Return value-self.",
+    "_decimal.Decimal.__rtruediv__" => "Return value/self.",
+    "_decimal.Decimal.__setattr__" => "Implement setattr(self, name, value).",
+    "_decimal.Decimal.__str__" => "Return str(self).",
+    "_decimal.Decimal.__sub__" => "Return self-value.",
+    "_decimal.Decimal.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_decimal.Decimal.__truediv__" => "Return self/value.",
+    "_decimal.Decimal.adjusted" => "Return the adjusted exponent of the number.  Defined as exp + digits - 1.",
+    "_decimal.Decimal.as_integer_ratio" => "Decimal.as_integer_ratio() -> (int, int)\n\nReturn a pair of integers, whose ratio is exactly equal to the original\nDecimal and with a positive denominator. The ratio is in lowest terms.\nRaise OverflowError on infinities and a ValueError on NaNs.",
+    "_decimal.Decimal.as_tuple" => "Return a tuple representation of the number.",
+    "_decimal.Decimal.canonical" => "Return the canonical encoding of the argument.  Currently, the encoding\nof a Decimal instance is always canonical, so this operation returns its\nargument unchanged.",
+    "_decimal.Decimal.compare" => "Compare self to other.  Return a decimal value:\n\n    a or b is a NaN ==> Decimal('NaN')\n    a < b           ==> Decimal('-1')\n    a == b          ==> Decimal('0')\n    a > b           ==> Decimal('1')",
+    "_decimal.Decimal.compare_signal" => "Identical to compare, except that all NaNs signal.",
+    "_decimal.Decimal.compare_total" => "Compare two operands using their abstract representation rather than\ntheir numerical value.  Similar to the compare() method, but the result\ngives a total ordering on Decimal instances.  Two Decimal instances with\nthe same numeric value but different representations compare unequal\nin this ordering:\n\n    >>> Decimal('12.0').compare_total(Decimal('12'))\n    Decimal('-1')\n\nQuiet and signaling NaNs are also included in the total ordering. The result\nof this function is Decimal('0') if both operands have the same representation,\nDecimal('-1') if the first operand is lower in the total order than the second,\nand Decimal('1') if the first operand is higher in the total order than the\nsecond operand. See the specification for details of the total order.\n\nThis operation is unaffected by context and is quiet: no flags are changed\nand no rounding is performed. As an exception, the C version may raise\nInvalidOperation if the second operand cannot be converted exactly.",
+    "_decimal.Decimal.compare_total_mag" => "Compare two operands using their abstract representation rather than their\nvalue as in compare_total(), but ignoring the sign of each operand.\n\nx.compare_total_mag(y) is equivalent to x.copy_abs().compare_total(y.copy_abs()).\n\nThis operation is unaffected by context and is quiet: no flags are changed\nand no rounding is performed. As an exception, the C version may raise\nInvalidOperation if the second operand cannot be converted exactly.",
+    "_decimal.Decimal.conjugate" => "Return self.",
+    "_decimal.Decimal.copy_abs" => "Return the absolute value of the argument.  This operation is unaffected by\ncontext and is quiet: no flags are changed and no rounding is performed.",
+    "_decimal.Decimal.copy_negate" => "Return the negation of the argument.  This operation is unaffected by context\nand is quiet: no flags are changed and no rounding is performed.",
+    "_decimal.Decimal.copy_sign" => "Return a copy of the first operand with the sign set to be the same as the\nsign of the second operand. For example:\n\n    >>> Decimal('2.3').copy_sign(Decimal('-1.5'))\n    Decimal('-2.3')\n\nThis operation is unaffected by context and is quiet: no flags are changed\nand no rounding is performed. As an exception, the C version may raise\nInvalidOperation if the second operand cannot be converted exactly.",
+    "_decimal.Decimal.exp" => "Return the value of the (natural) exponential function e**x at the given\nnumber.  The function always uses the ROUND_HALF_EVEN mode and the result\nis correctly rounded.",
+    "_decimal.Decimal.fma" => "Fused multiply-add.  Return self*other+third with no rounding of the\nintermediate product self*other.\n\n    >>> Decimal(2).fma(3, 5)\n    Decimal('11')",
+    "_decimal.Decimal.from_float" => "Class method that converts a float to a decimal number, exactly.\nSince 0.1 is not exactly representable in binary floating point,\nDecimal.from_float(0.1) is not the same as Decimal('0.1').\n\n    >>> Decimal.from_float(0.1)\n    Decimal('0.1000000000000000055511151231257827021181583404541015625')\n    >>> Decimal.from_float(float('nan'))\n    Decimal('NaN')\n    >>> Decimal.from_float(float('inf'))\n    Decimal('Infinity')\n    >>> Decimal.from_float(float('-inf'))\n    Decimal('-Infinity')",
+    "_decimal.Decimal.from_number" => "Class method that converts a real number to a decimal number, exactly.\n\n    >>> Decimal.from_number(314)              # int\n    Decimal('314')\n    >>> Decimal.from_number(0.1)              # float\n    Decimal('0.1000000000000000055511151231257827021181583404541015625')\n    >>> Decimal.from_number(Decimal('3.14'))  # another decimal instance\n    Decimal('3.14')",
+    "_decimal.Decimal.is_canonical" => "Return True if the argument is canonical and False otherwise.  Currently,\na Decimal instance is always canonical, so this operation always returns\nTrue.",
+    "_decimal.Decimal.is_finite" => "Return True if the argument is a finite number, and False if the argument\nis infinite or a NaN.",
+    "_decimal.Decimal.is_infinite" => "Return True if the argument is either positive or negative infinity and\nFalse otherwise.",
+    "_decimal.Decimal.is_nan" => "Return True if the argument is a (quiet or signaling) NaN and False\notherwise.",
+    "_decimal.Decimal.is_normal" => "Return True if the argument is a normal finite non-zero number with an\nadjusted exponent greater than or equal to Emin. Return False if the\nargument is zero, subnormal, infinite or a NaN.",
+    "_decimal.Decimal.is_qnan" => "Return True if the argument is a quiet NaN, and False otherwise.",
+    "_decimal.Decimal.is_signed" => "Return True if the argument has a negative sign and False otherwise.\nNote that both zeros and NaNs can carry signs.",
+    "_decimal.Decimal.is_snan" => "Return True if the argument is a signaling NaN and False otherwise.",
+    "_decimal.Decimal.is_subnormal" => "Return True if the argument is subnormal, and False otherwise. A number is\nsubnormal if it is non-zero, finite, and has an adjusted exponent less\nthan Emin.",
+    "_decimal.Decimal.is_zero" => "Return True if the argument is a (positive or negative) zero and False\notherwise.",
+    "_decimal.Decimal.ln" => "Return the natural (base e) logarithm of the operand. The function always\nuses the ROUND_HALF_EVEN mode and the result is correctly rounded.",
+    "_decimal.Decimal.log10" => "Return the base ten logarithm of the operand. The function always uses the\nROUND_HALF_EVEN mode and the result is correctly rounded.",
+    "_decimal.Decimal.logb" => "For a non-zero number, return the adjusted exponent of the operand as a\nDecimal instance.  If the operand is a zero, then Decimal('-Infinity') is\nreturned and the DivisionByZero condition is raised. If the operand is\nan infinity then Decimal('Infinity') is returned.",
+    "_decimal.Decimal.logical_and" => "Applies an 'and' operation between self and other's digits.\n\nBoth self and other must be logical numbers.",
+    "_decimal.Decimal.logical_invert" => "Invert all its digits.\n\nThe self must be logical number.",
+    "_decimal.Decimal.logical_or" => "Applies an 'or' operation between self and other's digits.\n\nBoth self and other must be logical numbers.",
+    "_decimal.Decimal.logical_xor" => "Applies an 'xor' operation between self and other's digits.\n\nBoth self and other must be logical numbers.",
+    "_decimal.Decimal.max" => "Maximum of self and other.  If one operand is a quiet NaN and the other is\nnumeric, the numeric operand is returned.",
+    "_decimal.Decimal.max_mag" => "Similar to the max() method, but the comparison is done using the absolute\nvalues of the operands.",
+    "_decimal.Decimal.min" => "Minimum of self and other. If one operand is a quiet NaN and the other is\nnumeric, the numeric operand is returned.",
+    "_decimal.Decimal.min_mag" => "Similar to the min() method, but the comparison is done using the absolute\nvalues of the operands.",
+    "_decimal.Decimal.next_minus" => "Return the largest number representable in the given context (or in the\ncurrent default context if no context is given) that is smaller than the\ngiven operand.",
+    "_decimal.Decimal.next_plus" => "Return the smallest number representable in the given context (or in the\ncurrent default context if no context is given) that is larger than the\ngiven operand.",
+    "_decimal.Decimal.next_toward" => "If the two operands are unequal, return the number closest to the first\noperand in the direction of the second operand.  If both operands are\nnumerically equal, return a copy of the first operand with the sign set\nto be the same as the sign of the second operand.",
+    "_decimal.Decimal.normalize" => "Normalize the number by stripping the rightmost trailing zeros and\nconverting any result equal to Decimal('0') to Decimal('0e0').  Used\nfor producing canonical values for members of an equivalence class.\nFor example, Decimal('32.100') and Decimal('0.321000e+2') both normalize\nto the equivalent value Decimal('32.1').",
+    "_decimal.Decimal.number_class" => "Return a string describing the class of the operand.  The returned value\nis one of the following ten strings:\n\n    * '-Infinity', indicating that the operand is negative infinity.\n    * '-Normal', indicating that the operand is a negative normal number.\n    * '-Subnormal', indicating that the operand is negative and subnormal.\n    * '-Zero', indicating that the operand is a negative zero.\n    * '+Zero', indicating that the operand is a positive zero.\n    * '+Subnormal', indicating that the operand is positive and subnormal.\n    * '+Normal', indicating that the operand is a positive normal number.\n    * '+Infinity', indicating that the operand is positive infinity.\n    * 'NaN', indicating that the operand is a quiet NaN (Not a Number).\n    * 'sNaN', indicating that the operand is a signaling NaN.",
+    "_decimal.Decimal.quantize" => "Return a value equal to the first operand after rounding and having the\nexponent of the second operand.\n\n    >>> Decimal('1.41421356').quantize(Decimal('1.000'))\n    Decimal('1.414')\n\nUnlike other operations, if the length of the coefficient after the quantize\noperation would be greater than precision, then an InvalidOperation is signaled.\nThis guarantees that, unless there is an error condition, the quantized exponent\nis always equal to that of the right-hand operand.\n\nAlso unlike other operations, quantize never signals Underflow, even if the\nresult is subnormal and inexact.\n\nIf the exponent of the second operand is larger than that of the first, then\nrounding may be necessary. In this case, the rounding mode is determined by the\nrounding argument if given, else by the given context argument; if neither\nargument is given, the rounding mode of the current thread's context is used.",
+    "_decimal.Decimal.radix" => "Return Decimal(10), the radix (base) in which the Decimal class does\nall its arithmetic. Included for compatibility with the specification.",
+    "_decimal.Decimal.remainder_near" => "Return the remainder from dividing self by other.  This differs from\nself % other in that the sign of the remainder is chosen so as to minimize\nits absolute value. More precisely, the return value is self - n * other\nwhere n is the integer nearest to the exact value of self / other, and\nif two integers are equally near then the even one is chosen.\n\nIf the result is zero then its sign will be the sign of self.",
+    "_decimal.Decimal.rotate" => "Return the result of rotating the digits of the first operand by an amount\nspecified by the second operand.  The second operand must be an integer in\nthe range -precision through precision. The absolute value of the second\noperand gives the number of places to rotate. If the second operand is\npositive then rotation is to the left; otherwise rotation is to the right.\nThe coefficient of the first operand is padded on the left with zeros to\nlength precision if necessary. The sign and exponent of the first operand are\nunchanged.",
+    "_decimal.Decimal.same_quantum" => "Test whether self and other have the same exponent or whether both are NaN.\n\nThis operation is unaffected by context and is quiet: no flags are changed\nand no rounding is performed. As an exception, the C version may raise\nInvalidOperation if the second operand cannot be converted exactly.",
+    "_decimal.Decimal.scaleb" => "Return the first operand with the exponent adjusted the second.  Equivalently,\nreturn the first operand multiplied by 10**other. The second operand must be\nan integer.",
+    "_decimal.Decimal.shift" => "Return the result of shifting the digits of the first operand by an amount\nspecified by the second operand.  The second operand must be an integer in\nthe range -precision through precision. The absolute value of the second\noperand gives the number of places to shift. If the second operand is\npositive, then the shift is to the left; otherwise the shift is to the\nright. Digits shifted into the coefficient are zeros. The sign and exponent\nof the first operand are unchanged.",
+    "_decimal.Decimal.sqrt" => "Return the square root of the argument to full precision. The result is\ncorrectly rounded using the ROUND_HALF_EVEN rounding mode.",
+    "_decimal.Decimal.to_eng_string" => "Convert to an engineering-type string.  Engineering notation has an exponent\nwhich is a multiple of 3, so there are up to 3 digits left of the decimal\nplace. For example, Decimal('123E+1') is converted to Decimal('1.23E+3').\n\nThe value of context.capitals determines whether the exponent sign is lower\nor upper case. Otherwise, the context does not affect the operation.",
+    "_decimal.Decimal.to_integral" => "Identical to the to_integral_value() method.  The to_integral() name has been\nkept for compatibility with older versions.",
+    "_decimal.Decimal.to_integral_exact" => "Round to the nearest integer, signaling Inexact or Rounded as appropriate if\nrounding occurs.  The rounding mode is determined by the rounding parameter\nif given, else by the given context. If neither parameter is given, then the\nrounding mode of the current default context is used.",
+    "_decimal.Decimal.to_integral_value" => "Round to the nearest integer without signaling Inexact or Rounded.  The\nrounding mode is determined by the rounding parameter if given, else by\nthe given context. If neither parameter is given, then the rounding mode\nof the current default context is used.",
+    "_decimal.DecimalException.__delattr__" => "Implement delattr(self, name).",
+    "_decimal.DecimalException.__eq__" => "Return self==value.",
+    "_decimal.DecimalException.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_decimal.DecimalException.__ge__" => "Return self>=value.",
+    "_decimal.DecimalException.__getattribute__" => "Return getattr(self, name).",
+    "_decimal.DecimalException.__getstate__" => "Helper for pickle.",
+    "_decimal.DecimalException.__gt__" => "Return self>value.",
+    "_decimal.DecimalException.__hash__" => "Return hash(self).",
+    "_decimal.DecimalException.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_decimal.DecimalException.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_decimal.DecimalException.__le__" => "Return self<=value.",
+    "_decimal.DecimalException.__lt__" => "Return self<value.",
+    "_decimal.DecimalException.__ne__" => "Return self!=value.",
+    "_decimal.DecimalException.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_decimal.DecimalException.__reduce_ex__" => "Helper for pickle.",
+    "_decimal.DecimalException.__repr__" => "Return repr(self).",
+    "_decimal.DecimalException.__setattr__" => "Implement setattr(self, name, value).",
+    "_decimal.DecimalException.__sizeof__" => "Size of object in memory, in bytes.",
+    "_decimal.DecimalException.__str__" => "Return str(self).",
+    "_decimal.DecimalException.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_decimal.DecimalException.__weakref__" => "list of weak references to the object",
+    "_decimal.DecimalException.add_note" => "Add a note to the exception",
+    "_decimal.DecimalException.with_traceback" => "Set self.__traceback__ to tb and return self.",
+    "_decimal.DecimalTuple" => "DecimalTuple(sign, digits, exponent)",
+    "_decimal.DecimalTuple.__add__" => "Return self+value.",
+    "_decimal.DecimalTuple.__class_getitem__" => "See PEP 585",
+    "_decimal.DecimalTuple.__contains__" => "Return bool(key in self).",
+    "_decimal.DecimalTuple.__delattr__" => "Implement delattr(self, name).",
+    "_decimal.DecimalTuple.__eq__" => "Return self==value.",
+    "_decimal.DecimalTuple.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_decimal.DecimalTuple.__ge__" => "Return self>=value.",
+    "_decimal.DecimalTuple.__getattribute__" => "Return getattr(self, name).",
+    "_decimal.DecimalTuple.__getitem__" => "Return self[key].",
+    "_decimal.DecimalTuple.__getnewargs__" => "Return self as a plain tuple.  Used by copy and pickle.",
+    "_decimal.DecimalTuple.__getstate__" => "Helper for pickle.",
+    "_decimal.DecimalTuple.__gt__" => "Return self>value.",
+    "_decimal.DecimalTuple.__hash__" => "Return hash(self).",
+    "_decimal.DecimalTuple.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_decimal.DecimalTuple.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_decimal.DecimalTuple.__iter__" => "Implement iter(self).",
+    "_decimal.DecimalTuple.__le__" => "Return self<=value.",
+    "_decimal.DecimalTuple.__len__" => "Return len(self).",
+    "_decimal.DecimalTuple.__lt__" => "Return self<value.",
+    "_decimal.DecimalTuple.__mul__" => "Return self*value.",
+    "_decimal.DecimalTuple.__ne__" => "Return self!=value.",
+    "_decimal.DecimalTuple.__new__" => "Create new instance of DecimalTuple(sign, digits, exponent)",
+    "_decimal.DecimalTuple.__reduce__" => "Helper for pickle.",
+    "_decimal.DecimalTuple.__reduce_ex__" => "Helper for pickle.",
+    "_decimal.DecimalTuple.__replace__" => "Return a new DecimalTuple object replacing specified fields with new values",
+    "_decimal.DecimalTuple.__repr__" => "Return a nicely formatted representation string",
+    "_decimal.DecimalTuple.__rmul__" => "Return value*self.",
+    "_decimal.DecimalTuple.__setattr__" => "Implement setattr(self, name, value).",
+    "_decimal.DecimalTuple.__sizeof__" => "Size of object in memory, in bytes.",
+    "_decimal.DecimalTuple.__str__" => "Return str(self).",
+    "_decimal.DecimalTuple.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_decimal.DecimalTuple._asdict" => "Return a new dict which maps field names to their values.",
+    "_decimal.DecimalTuple._make" => "Make a new DecimalTuple object from a sequence or iterable",
+    "_decimal.DecimalTuple._replace" => "Return a new DecimalTuple object replacing specified fields with new values",
+    "_decimal.DecimalTuple.count" => "Return number of occurrences of value.",
+    "_decimal.DecimalTuple.digits" => "Alias for field number 1",
+    "_decimal.DecimalTuple.exponent" => "Alias for field number 2",
+    "_decimal.DecimalTuple.index" => "Return first index of value.\n\nRaises ValueError if the value is not present.",
+    "_decimal.DecimalTuple.sign" => "Alias for field number 0",
+    "_decimal.DivisionByZero.__delattr__" => "Implement delattr(self, name).",
+    "_decimal.DivisionByZero.__eq__" => "Return self==value.",
+    "_decimal.DivisionByZero.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_decimal.DivisionByZero.__ge__" => "Return self>=value.",
+    "_decimal.DivisionByZero.__getattribute__" => "Return getattr(self, name).",
+    "_decimal.DivisionByZero.__getstate__" => "Helper for pickle.",
+    "_decimal.DivisionByZero.__gt__" => "Return self>value.",
+    "_decimal.DivisionByZero.__hash__" => "Return hash(self).",
+    "_decimal.DivisionByZero.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_decimal.DivisionByZero.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_decimal.DivisionByZero.__le__" => "Return self<=value.",
+    "_decimal.DivisionByZero.__lt__" => "Return self<value.",
+    "_decimal.DivisionByZero.__ne__" => "Return self!=value.",
+    "_decimal.DivisionByZero.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_decimal.DivisionByZero.__reduce_ex__" => "Helper for pickle.",
+    "_decimal.DivisionByZero.__repr__" => "Return repr(self).",
+    "_decimal.DivisionByZero.__setattr__" => "Implement setattr(self, name, value).",
+    "_decimal.DivisionByZero.__sizeof__" => "Size of object in memory, in bytes.",
+    "_decimal.DivisionByZero.__str__" => "Return str(self).",
+    "_decimal.DivisionByZero.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_decimal.DivisionByZero.__weakref__" => "list of weak references to the object",
+    "_decimal.DivisionByZero.add_note" => "Add a note to the exception",
+    "_decimal.DivisionByZero.with_traceback" => "Set self.__traceback__ to tb and return self.",
+    "_decimal.DivisionImpossible.__delattr__" => "Implement delattr(self, name).",
+    "_decimal.DivisionImpossible.__eq__" => "Return self==value.",
+    "_decimal.DivisionImpossible.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_decimal.DivisionImpossible.__ge__" => "Return self>=value.",
+    "_decimal.DivisionImpossible.__getattribute__" => "Return getattr(self, name).",
+    "_decimal.DivisionImpossible.__getstate__" => "Helper for pickle.",
+    "_decimal.DivisionImpossible.__gt__" => "Return self>value.",
+    "_decimal.DivisionImpossible.__hash__" => "Return hash(self).",
+    "_decimal.DivisionImpossible.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_decimal.DivisionImpossible.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_decimal.DivisionImpossible.__le__" => "Return self<=value.",
+    "_decimal.DivisionImpossible.__lt__" => "Return self<value.",
+    "_decimal.DivisionImpossible.__ne__" => "Return self!=value.",
+    "_decimal.DivisionImpossible.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_decimal.DivisionImpossible.__reduce_ex__" => "Helper for pickle.",
+    "_decimal.DivisionImpossible.__repr__" => "Return repr(self).",
+    "_decimal.DivisionImpossible.__setattr__" => "Implement setattr(self, name, value).",
+    "_decimal.DivisionImpossible.__sizeof__" => "Size of object in memory, in bytes.",
+    "_decimal.DivisionImpossible.__str__" => "Return str(self).",
+    "_decimal.DivisionImpossible.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_decimal.DivisionImpossible.__weakref__" => "list of weak references to the object",
+    "_decimal.DivisionImpossible.add_note" => "Add a note to the exception",
+    "_decimal.DivisionImpossible.with_traceback" => "Set self.__traceback__ to tb and return self.",
+    "_decimal.DivisionUndefined.__delattr__" => "Implement delattr(self, name).",
+    "_decimal.DivisionUndefined.__eq__" => "Return self==value.",
+    "_decimal.DivisionUndefined.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_decimal.DivisionUndefined.__ge__" => "Return self>=value.",
+    "_decimal.DivisionUndefined.__getattribute__" => "Return getattr(self, name).",
+    "_decimal.DivisionUndefined.__getstate__" => "Helper for pickle.",
+    "_decimal.DivisionUndefined.__gt__" => "Return self>value.",
+    "_decimal.DivisionUndefined.__hash__" => "Return hash(self).",
+    "_decimal.DivisionUndefined.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_decimal.DivisionUndefined.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_decimal.DivisionUndefined.__le__" => "Return self<=value.",
+    "_decimal.DivisionUndefined.__lt__" => "Return self<value.",
+    "_decimal.DivisionUndefined.__ne__" => "Return self!=value.",
+    "_decimal.DivisionUndefined.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_decimal.DivisionUndefined.__reduce_ex__" => "Helper for pickle.",
+    "_decimal.DivisionUndefined.__repr__" => "Return repr(self).",
+    "_decimal.DivisionUndefined.__setattr__" => "Implement setattr(self, name, value).",
+    "_decimal.DivisionUndefined.__sizeof__" => "Size of object in memory, in bytes.",
+    "_decimal.DivisionUndefined.__str__" => "Return str(self).",
+    "_decimal.DivisionUndefined.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_decimal.DivisionUndefined.__weakref__" => "list of weak references to the object",
+    "_decimal.DivisionUndefined.add_note" => "Add a note to the exception",
+    "_decimal.DivisionUndefined.with_traceback" => "Set self.__traceback__ to tb and return self.",
+    "_decimal.FloatOperation.__delattr__" => "Implement delattr(self, name).",
+    "_decimal.FloatOperation.__eq__" => "Return self==value.",
+    "_decimal.FloatOperation.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_decimal.FloatOperation.__ge__" => "Return self>=value.",
+    "_decimal.FloatOperation.__getattribute__" => "Return getattr(self, name).",
+    "_decimal.FloatOperation.__getstate__" => "Helper for pickle.",
+    "_decimal.FloatOperation.__gt__" => "Return self>value.",
+    "_decimal.FloatOperation.__hash__" => "Return hash(self).",
+    "_decimal.FloatOperation.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_decimal.FloatOperation.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_decimal.FloatOperation.__le__" => "Return self<=value.",
+    "_decimal.FloatOperation.__lt__" => "Return self<value.",
+    "_decimal.FloatOperation.__ne__" => "Return self!=value.",
+    "_decimal.FloatOperation.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_decimal.FloatOperation.__reduce_ex__" => "Helper for pickle.",
+    "_decimal.FloatOperation.__repr__" => "Return repr(self).",
+    "_decimal.FloatOperation.__setattr__" => "Implement setattr(self, name, value).",
+    "_decimal.FloatOperation.__sizeof__" => "Size of object in memory, in bytes.",
+    "_decimal.FloatOperation.__str__" => "Return str(self).",
+    "_decimal.FloatOperation.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_decimal.FloatOperation.__weakref__" => "list of weak references to the object",
+    "_decimal.FloatOperation.add_note" => "Add a note to the exception",
+    "_decimal.FloatOperation.with_traceback" => "Set self.__traceback__ to tb and return self.",
+    "_decimal.IEEEContext" => "Return a context object initialized to the proper values for one of the\nIEEE interchange formats.  The argument must be a multiple of 32 and less\nthan IEEE_CONTEXT_MAX_BITS.",
+    "_decimal.Inexact.__delattr__" => "Implement delattr(self, name).",
+    "_decimal.Inexact.__eq__" => "Return self==value.",
+    "_decimal.Inexact.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_decimal.Inexact.__ge__" => "Return self>=value.",
+    "_decimal.Inexact.__getattribute__" => "Return getattr(self, name).",
+    "_decimal.Inexact.__getstate__" => "Helper for pickle.",
+    "_decimal.Inexact.__gt__" => "Return self>value.",
+    "_decimal.Inexact.__hash__" => "Return hash(self).",
+    "_decimal.Inexact.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_decimal.Inexact.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_decimal.Inexact.__le__" => "Return self<=value.",
+    "_decimal.Inexact.__lt__" => "Return self<value.",
+    "_decimal.Inexact.__ne__" => "Return self!=value.",
+    "_decimal.Inexact.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_decimal.Inexact.__reduce_ex__" => "Helper for pickle.",
+    "_decimal.Inexact.__repr__" => "Return repr(self).",
+    "_decimal.Inexact.__setattr__" => "Implement setattr(self, name, value).",
+    "_decimal.Inexact.__sizeof__" => "Size of object in memory, in bytes.",
+    "_decimal.Inexact.__str__" => "Return str(self).",
+    "_decimal.Inexact.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_decimal.Inexact.__weakref__" => "list of weak references to the object",
+    "_decimal.Inexact.add_note" => "Add a note to the exception",
+    "_decimal.Inexact.with_traceback" => "Set self.__traceback__ to tb and return self.",
+    "_decimal.InvalidContext.__delattr__" => "Implement delattr(self, name).",
+    "_decimal.InvalidContext.__eq__" => "Return self==value.",
+    "_decimal.InvalidContext.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_decimal.InvalidContext.__ge__" => "Return self>=value.",
+    "_decimal.InvalidContext.__getattribute__" => "Return getattr(self, name).",
+    "_decimal.InvalidContext.__getstate__" => "Helper for pickle.",
+    "_decimal.InvalidContext.__gt__" => "Return self>value.",
+    "_decimal.InvalidContext.__hash__" => "Return hash(self).",
+    "_decimal.InvalidContext.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_decimal.InvalidContext.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_decimal.InvalidContext.__le__" => "Return self<=value.",
+    "_decimal.InvalidContext.__lt__" => "Return self<value.",
+    "_decimal.InvalidContext.__ne__" => "Return self!=value.",
+    "_decimal.InvalidContext.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_decimal.InvalidContext.__reduce_ex__" => "Helper for pickle.",
+    "_decimal.InvalidContext.__repr__" => "Return repr(self).",
+    "_decimal.InvalidContext.__setattr__" => "Implement setattr(self, name, value).",
+    "_decimal.InvalidContext.__sizeof__" => "Size of object in memory, in bytes.",
+    "_decimal.InvalidContext.__str__" => "Return str(self).",
+    "_decimal.InvalidContext.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_decimal.InvalidContext.__weakref__" => "list of weak references to the object",
+    "_decimal.InvalidContext.add_note" => "Add a note to the exception",
+    "_decimal.InvalidContext.with_traceback" => "Set self.__traceback__ to tb and return self.",
+    "_decimal.InvalidOperation.__delattr__" => "Implement delattr(self, name).",
+    "_decimal.InvalidOperation.__eq__" => "Return self==value.",
+    "_decimal.InvalidOperation.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_decimal.InvalidOperation.__ge__" => "Return self>=value.",
+    "_decimal.InvalidOperation.__getattribute__" => "Return getattr(self, name).",
+    "_decimal.InvalidOperation.__getstate__" => "Helper for pickle.",
+    "_decimal.InvalidOperation.__gt__" => "Return self>value.",
+    "_decimal.InvalidOperation.__hash__" => "Return hash(self).",
+    "_decimal.InvalidOperation.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_decimal.InvalidOperation.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_decimal.InvalidOperation.__le__" => "Return self<=value.",
+    "_decimal.InvalidOperation.__lt__" => "Return self<value.",
+    "_decimal.InvalidOperation.__ne__" => "Return self!=value.",
+    "_decimal.InvalidOperation.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_decimal.InvalidOperation.__reduce_ex__" => "Helper for pickle.",
+    "_decimal.InvalidOperation.__repr__" => "Return repr(self).",
+    "_decimal.InvalidOperation.__setattr__" => "Implement setattr(self, name, value).",
+    "_decimal.InvalidOperation.__sizeof__" => "Size of object in memory, in bytes.",
+    "_decimal.InvalidOperation.__str__" => "Return str(self).",
+    "_decimal.InvalidOperation.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_decimal.InvalidOperation.__weakref__" => "list of weak references to the object",
+    "_decimal.InvalidOperation.add_note" => "Add a note to the exception",
+    "_decimal.InvalidOperation.with_traceback" => "Set self.__traceback__ to tb and return self.",
+    "_decimal.Overflow.__delattr__" => "Implement delattr(self, name).",
+    "_decimal.Overflow.__eq__" => "Return self==value.",
+    "_decimal.Overflow.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_decimal.Overflow.__ge__" => "Return self>=value.",
+    "_decimal.Overflow.__getattribute__" => "Return getattr(self, name).",
+    "_decimal.Overflow.__getstate__" => "Helper for pickle.",
+    "_decimal.Overflow.__gt__" => "Return self>value.",
+    "_decimal.Overflow.__hash__" => "Return hash(self).",
+    "_decimal.Overflow.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_decimal.Overflow.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_decimal.Overflow.__le__" => "Return self<=value.",
+    "_decimal.Overflow.__lt__" => "Return self<value.",
+    "_decimal.Overflow.__ne__" => "Return self!=value.",
+    "_decimal.Overflow.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_decimal.Overflow.__reduce_ex__" => "Helper for pickle.",
+    "_decimal.Overflow.__repr__" => "Return repr(self).",
+    "_decimal.Overflow.__setattr__" => "Implement setattr(self, name, value).",
+    "_decimal.Overflow.__sizeof__" => "Size of object in memory, in bytes.",
+    "_decimal.Overflow.__str__" => "Return str(self).",
+    "_decimal.Overflow.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_decimal.Overflow.__weakref__" => "list of weak references to the object",
+    "_decimal.Overflow.add_note" => "Add a note to the exception",
+    "_decimal.Overflow.with_traceback" => "Set self.__traceback__ to tb and return self.",
+    "_decimal.Rounded.__delattr__" => "Implement delattr(self, name).",
+    "_decimal.Rounded.__eq__" => "Return self==value.",
+    "_decimal.Rounded.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_decimal.Rounded.__ge__" => "Return self>=value.",
+    "_decimal.Rounded.__getattribute__" => "Return getattr(self, name).",
+    "_decimal.Rounded.__getstate__" => "Helper for pickle.",
+    "_decimal.Rounded.__gt__" => "Return self>value.",
+    "_decimal.Rounded.__hash__" => "Return hash(self).",
+    "_decimal.Rounded.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_decimal.Rounded.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_decimal.Rounded.__le__" => "Return self<=value.",
+    "_decimal.Rounded.__lt__" => "Return self<value.",
+    "_decimal.Rounded.__ne__" => "Return self!=value.",
+    "_decimal.Rounded.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_decimal.Rounded.__reduce_ex__" => "Helper for pickle.",
+    "_decimal.Rounded.__repr__" => "Return repr(self).",
+    "_decimal.Rounded.__setattr__" => "Implement setattr(self, name, value).",
+    "_decimal.Rounded.__sizeof__" => "Size of object in memory, in bytes.",
+    "_decimal.Rounded.__str__" => "Return str(self).",
+    "_decimal.Rounded.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_decimal.Rounded.__weakref__" => "list of weak references to the object",
+    "_decimal.Rounded.add_note" => "Add a note to the exception",
+    "_decimal.Rounded.with_traceback" => "Set self.__traceback__ to tb and return self.",
+    "_decimal.Subnormal.__delattr__" => "Implement delattr(self, name).",
+    "_decimal.Subnormal.__eq__" => "Return self==value.",
+    "_decimal.Subnormal.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_decimal.Subnormal.__ge__" => "Return self>=value.",
+    "_decimal.Subnormal.__getattribute__" => "Return getattr(self, name).",
+    "_decimal.Subnormal.__getstate__" => "Helper for pickle.",
+    "_decimal.Subnormal.__gt__" => "Return self>value.",
+    "_decimal.Subnormal.__hash__" => "Return hash(self).",
+    "_decimal.Subnormal.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_decimal.Subnormal.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_decimal.Subnormal.__le__" => "Return self<=value.",
+    "_decimal.Subnormal.__lt__" => "Return self<value.",
+    "_decimal.Subnormal.__ne__" => "Return self!=value.",
+    "_decimal.Subnormal.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_decimal.Subnormal.__reduce_ex__" => "Helper for pickle.",
+    "_decimal.Subnormal.__repr__" => "Return repr(self).",
+    "_decimal.Subnormal.__setattr__" => "Implement setattr(self, name, value).",
+    "_decimal.Subnormal.__sizeof__" => "Size of object in memory, in bytes.",
+    "_decimal.Subnormal.__str__" => "Return str(self).",
+    "_decimal.Subnormal.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_decimal.Subnormal.__weakref__" => "list of weak references to the object",
+    "_decimal.Subnormal.add_note" => "Add a note to the exception",
+    "_decimal.Subnormal.with_traceback" => "Set self.__traceback__ to tb and return self.",
+    "_decimal.Underflow.__delattr__" => "Implement delattr(self, name).",
+    "_decimal.Underflow.__eq__" => "Return self==value.",
+    "_decimal.Underflow.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_decimal.Underflow.__ge__" => "Return self>=value.",
+    "_decimal.Underflow.__getattribute__" => "Return getattr(self, name).",
+    "_decimal.Underflow.__getstate__" => "Helper for pickle.",
+    "_decimal.Underflow.__gt__" => "Return self>value.",
+    "_decimal.Underflow.__hash__" => "Return hash(self).",
+    "_decimal.Underflow.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_decimal.Underflow.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_decimal.Underflow.__le__" => "Return self<=value.",
+    "_decimal.Underflow.__lt__" => "Return self<value.",
+    "_decimal.Underflow.__ne__" => "Return self!=value.",
+    "_decimal.Underflow.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_decimal.Underflow.__reduce_ex__" => "Helper for pickle.",
+    "_decimal.Underflow.__repr__" => "Return repr(self).",
+    "_decimal.Underflow.__setattr__" => "Implement setattr(self, name, value).",
+    "_decimal.Underflow.__sizeof__" => "Size of object in memory, in bytes.",
+    "_decimal.Underflow.__str__" => "Return str(self).",
+    "_decimal.Underflow.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_decimal.Underflow.__weakref__" => "list of weak references to the object",
+    "_decimal.Underflow.add_note" => "Add a note to the exception",
+    "_decimal.Underflow.with_traceback" => "Set self.__traceback__ to tb and return self.",
     "_decimal.getcontext" => "Get the current default context.",
     "_decimal.localcontext" => "Return a context manager that will set the default context to a copy of ctx\non entry to the with-statement and restore the previous default context when\nexiting the with-statement. If no context is specified, a copy of the current\ndefault context is used.",
     "_decimal.setcontext" => "Set a new default context.",
+    "_elementtree.Element.__bool__" => "True if self else False",
+    "_elementtree.Element.__delattr__" => "Implement delattr(self, name).",
+    "_elementtree.Element.__delitem__" => "Delete self[key].",
+    "_elementtree.Element.__eq__" => "Return self==value.",
+    "_elementtree.Element.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_elementtree.Element.__ge__" => "Return self>=value.",
+    "_elementtree.Element.__getattribute__" => "Return getattr(self, name).",
+    "_elementtree.Element.__getitem__" => "Return self[key].",
+    "_elementtree.Element.__gt__" => "Return self>value.",
+    "_elementtree.Element.__hash__" => "Return hash(self).",
+    "_elementtree.Element.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_elementtree.Element.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_elementtree.Element.__le__" => "Return self<=value.",
+    "_elementtree.Element.__len__" => "Return len(self).",
+    "_elementtree.Element.__lt__" => "Return self<value.",
+    "_elementtree.Element.__ne__" => "Return self!=value.",
+    "_elementtree.Element.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_elementtree.Element.__reduce__" => "Helper for pickle.",
+    "_elementtree.Element.__reduce_ex__" => "Helper for pickle.",
+    "_elementtree.Element.__repr__" => "Return repr(self).",
+    "_elementtree.Element.__setattr__" => "Implement setattr(self, name, value).",
+    "_elementtree.Element.__setitem__" => "Set self[key] to value.",
+    "_elementtree.Element.__str__" => "Return str(self).",
+    "_elementtree.Element.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_elementtree.Element.attrib" => "A dictionary containing the element's attributes",
+    "_elementtree.Element.tag" => "A string identifying what kind of data this element represents",
+    "_elementtree.Element.tail" => "A string of text directly after the end tag, or None",
+    "_elementtree.Element.text" => "A string of text directly after the start tag, or None",
+    "_elementtree.ParseError.__delattr__" => "Implement delattr(self, name).",
+    "_elementtree.ParseError.__eq__" => "Return self==value.",
+    "_elementtree.ParseError.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_elementtree.ParseError.__ge__" => "Return self>=value.",
+    "_elementtree.ParseError.__getattribute__" => "Return getattr(self, name).",
+    "_elementtree.ParseError.__getstate__" => "Helper for pickle.",
+    "_elementtree.ParseError.__gt__" => "Return self>value.",
+    "_elementtree.ParseError.__hash__" => "Return hash(self).",
+    "_elementtree.ParseError.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_elementtree.ParseError.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_elementtree.ParseError.__le__" => "Return self<=value.",
+    "_elementtree.ParseError.__lt__" => "Return self<value.",
+    "_elementtree.ParseError.__ne__" => "Return self!=value.",
+    "_elementtree.ParseError.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_elementtree.ParseError.__reduce_ex__" => "Helper for pickle.",
+    "_elementtree.ParseError.__repr__" => "Return repr(self).",
+    "_elementtree.ParseError.__setattr__" => "Implement setattr(self, name, value).",
+    "_elementtree.ParseError.__sizeof__" => "Size of object in memory, in bytes.",
+    "_elementtree.ParseError.__str__" => "Return str(self).",
+    "_elementtree.ParseError.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_elementtree.ParseError.__weakref__" => "list of weak references to the object",
+    "_elementtree.ParseError._metadata" => "exception private metadata",
+    "_elementtree.ParseError.add_note" => "Add a note to the exception",
+    "_elementtree.ParseError.end_lineno" => "exception end lineno",
+    "_elementtree.ParseError.end_offset" => "exception end offset",
+    "_elementtree.ParseError.filename" => "exception filename",
+    "_elementtree.ParseError.lineno" => "exception lineno",
+    "_elementtree.ParseError.msg" => "exception msg",
+    "_elementtree.ParseError.offset" => "exception offset",
+    "_elementtree.ParseError.print_file_and_line" => "exception print_file_and_line",
+    "_elementtree.ParseError.text" => "exception text",
+    "_elementtree.ParseError.with_traceback" => "Set self.__traceback__ to tb and return self.",
+    "_elementtree.TreeBuilder.__delattr__" => "Implement delattr(self, name).",
+    "_elementtree.TreeBuilder.__eq__" => "Return self==value.",
+    "_elementtree.TreeBuilder.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_elementtree.TreeBuilder.__ge__" => "Return self>=value.",
+    "_elementtree.TreeBuilder.__getattribute__" => "Return getattr(self, name).",
+    "_elementtree.TreeBuilder.__getstate__" => "Helper for pickle.",
+    "_elementtree.TreeBuilder.__gt__" => "Return self>value.",
+    "_elementtree.TreeBuilder.__hash__" => "Return hash(self).",
+    "_elementtree.TreeBuilder.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_elementtree.TreeBuilder.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_elementtree.TreeBuilder.__le__" => "Return self<=value.",
+    "_elementtree.TreeBuilder.__lt__" => "Return self<value.",
+    "_elementtree.TreeBuilder.__ne__" => "Return self!=value.",
+    "_elementtree.TreeBuilder.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_elementtree.TreeBuilder.__reduce__" => "Helper for pickle.",
+    "_elementtree.TreeBuilder.__reduce_ex__" => "Helper for pickle.",
+    "_elementtree.TreeBuilder.__repr__" => "Return repr(self).",
+    "_elementtree.TreeBuilder.__setattr__" => "Implement setattr(self, name, value).",
+    "_elementtree.TreeBuilder.__sizeof__" => "Size of object in memory, in bytes.",
+    "_elementtree.TreeBuilder.__str__" => "Return str(self).",
+    "_elementtree.TreeBuilder.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_elementtree.XMLParser.__delattr__" => "Implement delattr(self, name).",
+    "_elementtree.XMLParser.__eq__" => "Return self==value.",
+    "_elementtree.XMLParser.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_elementtree.XMLParser.__ge__" => "Return self>=value.",
+    "_elementtree.XMLParser.__getattribute__" => "Return getattr(self, name).",
+    "_elementtree.XMLParser.__getstate__" => "Helper for pickle.",
+    "_elementtree.XMLParser.__gt__" => "Return self>value.",
+    "_elementtree.XMLParser.__hash__" => "Return hash(self).",
+    "_elementtree.XMLParser.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_elementtree.XMLParser.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_elementtree.XMLParser.__le__" => "Return self<=value.",
+    "_elementtree.XMLParser.__lt__" => "Return self<value.",
+    "_elementtree.XMLParser.__ne__" => "Return self!=value.",
+    "_elementtree.XMLParser.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_elementtree.XMLParser.__reduce__" => "Helper for pickle.",
+    "_elementtree.XMLParser.__reduce_ex__" => "Helper for pickle.",
+    "_elementtree.XMLParser.__repr__" => "Return repr(self).",
+    "_elementtree.XMLParser.__setattr__" => "Implement setattr(self, name, value).",
+    "_elementtree.XMLParser.__sizeof__" => "Size of object in memory, in bytes.",
+    "_elementtree.XMLParser.__str__" => "Return str(self).",
+    "_elementtree.XMLParser.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
     "_elementtree._set_factories" => "Change the factories used to create comments and processing instructions.\n\nFor internal use only.",
     "_functools" => "Tools that operate on functions.",
-    "_functools.cmp_to_key" => "Convert a cmp= function into a key= function.\n\nmycmp\n  Function that compares two objects.",
-    "_functools.reduce" => "reduce(function, iterable[, initial], /) -> value\n\nApply a function of two arguments cumulatively to the items of an iterable, from left to right.\n\nThis effectively reduces the iterable to a single value.  If initial is present,\nit is placed before the items of the iterable in the calculation, and serves as\na default when the iterable is empty.\n\nFor example, reduce(lambda x, y: x+y, [1, 2, 3, 4, 5])\ncalculates ((((1 + 2) + 3) + 4) + 5).",
+    "_functools._PlaceholderType" => "The type of the Placeholder singleton.\n\nUsed as a placeholder for partial arguments.",
+    "_functools._PlaceholderType.__delattr__" => "Implement delattr(self, name).",
+    "_functools._PlaceholderType.__eq__" => "Return self==value.",
+    "_functools._PlaceholderType.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_functools._PlaceholderType.__ge__" => "Return self>=value.",
+    "_functools._PlaceholderType.__getattribute__" => "Return getattr(self, name).",
+    "_functools._PlaceholderType.__getstate__" => "Helper for pickle.",
+    "_functools._PlaceholderType.__gt__" => "Return self>value.",
+    "_functools._PlaceholderType.__hash__" => "Return hash(self).",
+    "_functools._PlaceholderType.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_functools._PlaceholderType.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_functools._PlaceholderType.__le__" => "Return self<=value.",
+    "_functools._PlaceholderType.__lt__" => "Return self<value.",
+    "_functools._PlaceholderType.__ne__" => "Return self!=value.",
+    "_functools._PlaceholderType.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_functools._PlaceholderType.__reduce_ex__" => "Helper for pickle.",
+    "_functools._PlaceholderType.__repr__" => "Return repr(self).",
+    "_functools._PlaceholderType.__setattr__" => "Implement setattr(self, name, value).",
+    "_functools._PlaceholderType.__sizeof__" => "Size of object in memory, in bytes.",
+    "_functools._PlaceholderType.__str__" => "Return str(self).",
+    "_functools._PlaceholderType.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_functools._lru_cache_wrapper" => "Create a cached callable that wraps another function.\n\nuser_function:      the function being cached\n\nmaxsize:  0         for no caching\n          None      for unlimited cache size\n          n         for a bounded cache\n\ntyped:    False     cache f(3) and f(3.0) as identical calls\n          True      cache f(3) and f(3.0) as distinct calls\n\ncache_info_type:    namedtuple class with the fields:\n                        hits misses currsize maxsize",
+    "_functools._lru_cache_wrapper.__call__" => "Call self as a function.",
+    "_functools._lru_cache_wrapper.__delattr__" => "Implement delattr(self, name).",
+    "_functools._lru_cache_wrapper.__eq__" => "Return self==value.",
+    "_functools._lru_cache_wrapper.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_functools._lru_cache_wrapper.__ge__" => "Return self>=value.",
+    "_functools._lru_cache_wrapper.__get__" => "Return an attribute of instance, which is of type owner.",
+    "_functools._lru_cache_wrapper.__getattribute__" => "Return getattr(self, name).",
+    "_functools._lru_cache_wrapper.__getstate__" => "Helper for pickle.",
+    "_functools._lru_cache_wrapper.__gt__" => "Return self>value.",
+    "_functools._lru_cache_wrapper.__hash__" => "Return hash(self).",
+    "_functools._lru_cache_wrapper.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_functools._lru_cache_wrapper.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_functools._lru_cache_wrapper.__le__" => "Return self<=value.",
+    "_functools._lru_cache_wrapper.__lt__" => "Return self<value.",
+    "_functools._lru_cache_wrapper.__ne__" => "Return self!=value.",
+    "_functools._lru_cache_wrapper.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_functools._lru_cache_wrapper.__reduce_ex__" => "Helper for pickle.",
+    "_functools._lru_cache_wrapper.__repr__" => "Return repr(self).",
+    "_functools._lru_cache_wrapper.__setattr__" => "Implement setattr(self, name, value).",
+    "_functools._lru_cache_wrapper.__sizeof__" => "Size of object in memory, in bytes.",
+    "_functools._lru_cache_wrapper.__str__" => "Return str(self).",
+    "_functools._lru_cache_wrapper.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_functools._lru_cache_wrapper.cache_clear" => "Clear the cache and cache statistics",
+    "_functools._lru_cache_wrapper.cache_info" => "Report cache statistics",
+    "_functools.cmp_to_key" => "Convert a cmp= function into a key= function.\n\n  mycmp\n    Function that compares two objects.",
+    "_functools.partial" => "Create a new function with partial application of the given arguments\nand keywords.",
+    "_functools.partial.__call__" => "Call self as a function.",
+    "_functools.partial.__class_getitem__" => "See PEP 585",
+    "_functools.partial.__delattr__" => "Implement delattr(self, name).",
+    "_functools.partial.__eq__" => "Return self==value.",
+    "_functools.partial.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_functools.partial.__ge__" => "Return self>=value.",
+    "_functools.partial.__get__" => "Return an attribute of instance, which is of type owner.",
+    "_functools.partial.__getattribute__" => "Return getattr(self, name).",
+    "_functools.partial.__getstate__" => "Helper for pickle.",
+    "_functools.partial.__gt__" => "Return self>value.",
+    "_functools.partial.__hash__" => "Return hash(self).",
+    "_functools.partial.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_functools.partial.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_functools.partial.__le__" => "Return self<=value.",
+    "_functools.partial.__lt__" => "Return self<value.",
+    "_functools.partial.__ne__" => "Return self!=value.",
+    "_functools.partial.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_functools.partial.__reduce_ex__" => "Helper for pickle.",
+    "_functools.partial.__repr__" => "Return repr(self).",
+    "_functools.partial.__setattr__" => "Implement setattr(self, name, value).",
+    "_functools.partial.__sizeof__" => "Size of object in memory, in bytes.",
+    "_functools.partial.__str__" => "Return str(self).",
+    "_functools.partial.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_functools.partial.args" => "tuple of arguments to future partial calls",
+    "_functools.partial.func" => "function object to use in future partial calls",
+    "_functools.partial.keywords" => "dictionary of keyword arguments to future partial calls",
+    "_functools.reduce" => "Apply a function of two arguments cumulatively to the items of an iterable, from left to right.\n\nThis effectively reduces the iterable to a single value.  If initial is present,\nit is placed before the items of the iterable in the calculation, and serves as\na default when the iterable is empty.\n\nFor example, reduce(lambda x, y: x+y, [1, 2, 3, 4, 5])\ncalculates ((((1 + 2) + 3) + 4) + 5).",
     "_gdbm" => "This module provides an interface to the GNU DBM (GDBM) library.\n\nThis module is quite similar to the dbm module, but uses GDBM instead to\nprovide some additional functionality.  Please note that the file formats\ncreated by GDBM and dbm are incompatible.\n\nGDBM objects behave like mappings (dictionaries), except that keys and\nvalues are always immutable bytes-like objects or strings.  Printing\na GDBM object doesn't print the keys and values, and the items() and\nvalues() methods are not supported.",
-    "_gdbm.error.__cause__" => "exception cause",
-    "_gdbm.error.__context__" => "exception context",
     "_gdbm.error.__delattr__" => "Implement delattr(self, name).",
     "_gdbm.error.__eq__" => "Return self==value.",
     "_gdbm.error.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
@@ -728,12 +4830,12 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "_gdbm.error.__str__" => "Return str(self).",
     "_gdbm.error.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
     "_gdbm.error.__weakref__" => "list of weak references to the object",
-    "_gdbm.error.add_note" => "Exception.add_note(note) --\nadd a note to the exception",
+    "_gdbm.error.add_note" => "Add a note to the exception",
     "_gdbm.error.errno" => "POSIX exception code",
     "_gdbm.error.filename" => "exception filename",
     "_gdbm.error.filename2" => "second exception filename",
     "_gdbm.error.strerror" => "exception strerror",
-    "_gdbm.error.with_traceback" => "Exception.with_traceback(tb) --\nset self.__traceback__ to tb and return self.",
+    "_gdbm.error.with_traceback" => "Set self.__traceback__ to tb and return self.",
     "_gdbm.open" => "Open a dbm database and return a dbm object.\n\nThe filename argument is the name of the database file.\n\nThe optional flags argument can be 'r' (to open an existing database\nfor reading only -- default), 'w' (to open an existing database for\nreading and writing), 'c' (which creates the database if it doesn't\nexist), or 'n' (which always creates a new empty database).\n\nSome versions of gdbm support additional flags which must be\nappended to one of the flags described above.  The module constant\n'open_flags' is a string of valid additional flags.  The 'f' flag\nopens the database in fast mode; altered data will not automatically\nbe written to the disk after every change.  This results in faster\nwrites to the database, but may result in an inconsistent database\nif the program crashes while the database is still open.  Use the\nsync() method to force any unwritten data to be written to the disk.\nThe 's' flag causes all database operations to be synchronized to\ndisk.  The 'u' flag disables locking of the database file.\n\nThe optional mode argument is the Unix mode of the file, used only\nwhen the database has to be created.  It defaults to octal 0o666.",
     "_hashlib" => "OpenSSL interface for hashlib module",
     "_hashlib.HASH" => "A hash is an object used to calculate a checksum of a string of information.\n\nMethods:\n\nupdate() -- updates the current digest with an additional string\ndigest() -- return the current digest value\nhexdigest() -- return the current digest as a string of hexadecimal digits\ncopy() -- return a copy of the current hash object\n\nAttributes:\n\nname -- the hash algorithm being used by this object\ndigest_size -- number of bytes in this hashes output",
@@ -814,8 +4916,6 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "_hashlib.HMAC.digest" => "Return the digest of the bytes passed to the update() method so far.",
     "_hashlib.HMAC.hexdigest" => "Return hexadecimal digest of the bytes passed to the update() method so far.\n\nThis may be used to exchange the value safely in email or other non-binary\nenvironments.",
     "_hashlib.HMAC.update" => "Update the HMAC object with msg.",
-    "_hashlib.UnsupportedDigestmodError.__cause__" => "exception cause",
-    "_hashlib.UnsupportedDigestmodError.__context__" => "exception context",
     "_hashlib.UnsupportedDigestmodError.__delattr__" => "Implement delattr(self, name).",
     "_hashlib.UnsupportedDigestmodError.__eq__" => "Return self==value.",
     "_hashlib.UnsupportedDigestmodError.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
@@ -837,8 +4937,8 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "_hashlib.UnsupportedDigestmodError.__str__" => "Return str(self).",
     "_hashlib.UnsupportedDigestmodError.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
     "_hashlib.UnsupportedDigestmodError.__weakref__" => "list of weak references to the object",
-    "_hashlib.UnsupportedDigestmodError.add_note" => "Exception.add_note(note) --\nadd a note to the exception",
-    "_hashlib.UnsupportedDigestmodError.with_traceback" => "Exception.with_traceback(tb) --\nset self.__traceback__ to tb and return self.",
+    "_hashlib.UnsupportedDigestmodError.add_note" => "Add a note to the exception",
+    "_hashlib.UnsupportedDigestmodError.with_traceback" => "Set self.__traceback__ to tb and return self.",
     "_hashlib.compare_digest" => "Return 'a == b'.\n\nThis function uses an approach designed to prevent\ntiming analysis, making it appropriate for cryptography.\n\na and b must both be of the same type: either str (ASCII only),\nor any bytes-like object.\n\nNote: If a and b are of different lengths, or if an error occurs,\na timing attack could theoretically reveal information about the\ntypes and lengths of a and b--but not their values.",
     "_hashlib.get_fips_mode" => "Determine the OpenSSL FIPS mode of operation.\n\nFor OpenSSL 3.0.0 and newer it returns the state of the default provider\nin the default OSSL context. It's not quite the same as FIPS_mode() but good\nenough for unittests.\n\nEffectively any non-zero return value indicates FIPS mode;\nvalues other than 1 may have additional significance.",
     "_hashlib.hmac_digest" => "Single-shot HMAC.",
@@ -859,16 +4959,67 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "_hashlib.pbkdf2_hmac" => "Password based key derivation function 2 (PKCS #5 v2.0) with HMAC as pseudorandom function.",
     "_hashlib.scrypt" => "scrypt password-based key derivation function.",
     "_heapq" => "Heap queue algorithm (a.k.a. priority queue).\n\nHeaps are arrays for which a[k] <= a[2*k+1] and a[k] <= a[2*k+2] for\nall k, counting elements from 0.  For the sake of comparison,\nnon-existing elements are considered to be infinite.  The interesting\nproperty of a heap is that a[0] is always its smallest element.\n\nUsage:\n\nheap = []            # creates an empty heap\nheappush(heap, item) # pushes a new item on the heap\nitem = heappop(heap) # pops the smallest item from the heap\nitem = heap[0]       # smallest item on the heap without popping it\nheapify(x)           # transforms list into a heap, in-place, in linear time\nitem = heapreplace(heap, item) # pops and returns smallest item, and adds\n                               # new item; the heap size is unchanged\n\nOur API differs from textbook heap algorithms as follows:\n\n- We use 0-based indexing.  This makes the relationship between the\n  index for a node and the indexes for its children slightly less\n  obvious, but is more suitable since Python uses 0-based indexing.\n\n- Our heappop() method returns the smallest item, not the largest.\n\nThese two make it possible to view the heap as a regular Python list\nwithout surprises: heap[0] is the smallest item, and heap.sort()\nmaintains the heap invariant!",
-    "_heapq._heapify_max" => "Maxheap variant of heapify.",
-    "_heapq._heappop_max" => "Maxheap variant of heappop.",
-    "_heapq._heapreplace_max" => "Maxheap variant of heapreplace.",
     "_heapq.heapify" => "Transform list into a heap, in-place, in O(len(heap)) time.",
+    "_heapq.heapify_max" => "Maxheap variant of heapify.",
     "_heapq.heappop" => "Pop the smallest item off the heap, maintaining the heap invariant.",
+    "_heapq.heappop_max" => "Maxheap variant of heappop.",
     "_heapq.heappush" => "Push item onto heap, maintaining the heap invariant.",
+    "_heapq.heappush_max" => "Push item onto max heap, maintaining the heap invariant.",
     "_heapq.heappushpop" => "Push item on the heap, then pop and return the smallest item from the heap.\n\nThe combined action runs more efficiently than heappush() followed by\na separate call to heappop().",
+    "_heapq.heappushpop_max" => "Maxheap variant of heappushpop.\n\nThe combined action runs more efficiently than heappush_max() followed by\na separate call to heappop_max().",
     "_heapq.heapreplace" => "Pop and return the current smallest value, and add the new item.\n\nThis is more efficient than heappop() followed by heappush(), and can be\nmore appropriate when using a fixed-size heap.  Note that the value\nreturned may be larger than item!  That constrains reasonable uses of\nthis routine unless written as part of a conditional replacement:\n\n    if item > heap[0]:\n        item = heapreplace(heap, item)",
+    "_heapq.heapreplace_max" => "Maxheap variant of heapreplace.",
+    "_hmac.HMAC.__delattr__" => "Implement delattr(self, name).",
+    "_hmac.HMAC.__eq__" => "Return self==value.",
+    "_hmac.HMAC.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_hmac.HMAC.__ge__" => "Return self>=value.",
+    "_hmac.HMAC.__getattribute__" => "Return getattr(self, name).",
+    "_hmac.HMAC.__getstate__" => "Helper for pickle.",
+    "_hmac.HMAC.__gt__" => "Return self>value.",
+    "_hmac.HMAC.__hash__" => "Return hash(self).",
+    "_hmac.HMAC.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_hmac.HMAC.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_hmac.HMAC.__le__" => "Return self<=value.",
+    "_hmac.HMAC.__lt__" => "Return self<value.",
+    "_hmac.HMAC.__ne__" => "Return self!=value.",
+    "_hmac.HMAC.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_hmac.HMAC.__reduce__" => "Helper for pickle.",
+    "_hmac.HMAC.__reduce_ex__" => "Helper for pickle.",
+    "_hmac.HMAC.__repr__" => "Return repr(self).",
+    "_hmac.HMAC.__setattr__" => "Implement setattr(self, name, value).",
+    "_hmac.HMAC.__sizeof__" => "Size of object in memory, in bytes.",
+    "_hmac.HMAC.__str__" => "Return str(self).",
+    "_hmac.HMAC.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_hmac.HMAC.copy" => "Return a copy (\"clone\") of the HMAC object.",
+    "_hmac.HMAC.digest" => "Return the digest of the bytes passed to the update() method so far.\n\nThis method may raise a MemoryError.",
+    "_hmac.HMAC.hexdigest" => "Return hexadecimal digest of the bytes passed to the update() method so far.\n\nThis may be used to exchange the value safely in email or other non-binary\nenvironments.\n\nThis method may raise a MemoryError.",
+    "_hmac.HMAC.update" => "Update the HMAC object with the given message.",
+    "_hmac.UnknownHashError.__delattr__" => "Implement delattr(self, name).",
+    "_hmac.UnknownHashError.__eq__" => "Return self==value.",
+    "_hmac.UnknownHashError.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_hmac.UnknownHashError.__ge__" => "Return self>=value.",
+    "_hmac.UnknownHashError.__getattribute__" => "Return getattr(self, name).",
+    "_hmac.UnknownHashError.__getstate__" => "Helper for pickle.",
+    "_hmac.UnknownHashError.__gt__" => "Return self>value.",
+    "_hmac.UnknownHashError.__hash__" => "Return hash(self).",
+    "_hmac.UnknownHashError.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_hmac.UnknownHashError.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_hmac.UnknownHashError.__le__" => "Return self<=value.",
+    "_hmac.UnknownHashError.__lt__" => "Return self<value.",
+    "_hmac.UnknownHashError.__ne__" => "Return self!=value.",
+    "_hmac.UnknownHashError.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_hmac.UnknownHashError.__reduce_ex__" => "Helper for pickle.",
+    "_hmac.UnknownHashError.__repr__" => "Return repr(self).",
+    "_hmac.UnknownHashError.__setattr__" => "Implement setattr(self, name, value).",
+    "_hmac.UnknownHashError.__sizeof__" => "Size of object in memory, in bytes.",
+    "_hmac.UnknownHashError.__str__" => "Return str(self).",
+    "_hmac.UnknownHashError.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_hmac.UnknownHashError.__weakref__" => "list of weak references to the object",
+    "_hmac.UnknownHashError.add_note" => "Add a note to the exception",
+    "_hmac.UnknownHashError.with_traceback" => "Set self.__traceback__ to tb and return self.",
+    "_hmac.new" => "Return a new HMAC object.",
     "_imp" => "(Extremely) low-level import machinery bits as used by importlib.",
-    "_imp._fix_co_filename" => "Changes code.co_filename to specify the passed-in file path.\n\ncode\n  Code object to change.\npath\n  File path to use.",
+    "_imp._fix_co_filename" => "Changes code.co_filename to specify the passed-in file path.\n\n  code\n    Code object to change.\n  path\n    File path to use.",
     "_imp._frozen_module_names" => "Returns the list of available frozen modules.",
     "_imp._override_frozen_modules_for_tests" => "(internal-only) Override PyConfig.use_frozen_modules.\n\n(-1: \"off\", 1: \"on\", 0: no override)\nSee frozen_modules() in Lib/test/support/import_helper.py.",
     "_imp._override_multi_interp_extensions_check" => "(internal-only) Override PyInterpreterConfig.check_multi_interp_extensions.\n\n(-1: \"never\", 1: \"always\", 0: no override)",
@@ -887,8 +5038,6 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "_imp.lock_held" => "Return True if the import lock is currently held, else False.\n\nOn platforms without threads, return False.",
     "_imp.release_lock" => "Release the interpreter's import lock.\n\nOn platforms without threads, this function does nothing.",
     "_interpchannels" => "This module provides primitive operations to manage Python interpreters.\nThe 'interpreters' module provides a more convenient interface.",
-    "_interpchannels.ChannelClosedError.__cause__" => "exception cause",
-    "_interpchannels.ChannelClosedError.__context__" => "exception context",
     "_interpchannels.ChannelClosedError.__delattr__" => "Implement delattr(self, name).",
     "_interpchannels.ChannelClosedError.__eq__" => "Return self==value.",
     "_interpchannels.ChannelClosedError.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
@@ -910,10 +5059,8 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "_interpchannels.ChannelClosedError.__str__" => "Return str(self).",
     "_interpchannels.ChannelClosedError.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
     "_interpchannels.ChannelClosedError.__weakref__" => "list of weak references to the object",
-    "_interpchannels.ChannelClosedError.add_note" => "Exception.add_note(note) --\nadd a note to the exception",
-    "_interpchannels.ChannelClosedError.with_traceback" => "Exception.with_traceback(tb) --\nset self.__traceback__ to tb and return self.",
-    "_interpchannels.ChannelEmptyError.__cause__" => "exception cause",
-    "_interpchannels.ChannelEmptyError.__context__" => "exception context",
+    "_interpchannels.ChannelClosedError.add_note" => "Add a note to the exception",
+    "_interpchannels.ChannelClosedError.with_traceback" => "Set self.__traceback__ to tb and return self.",
     "_interpchannels.ChannelEmptyError.__delattr__" => "Implement delattr(self, name).",
     "_interpchannels.ChannelEmptyError.__eq__" => "Return self==value.",
     "_interpchannels.ChannelEmptyError.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
@@ -935,10 +5082,8 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "_interpchannels.ChannelEmptyError.__str__" => "Return str(self).",
     "_interpchannels.ChannelEmptyError.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
     "_interpchannels.ChannelEmptyError.__weakref__" => "list of weak references to the object",
-    "_interpchannels.ChannelEmptyError.add_note" => "Exception.add_note(note) --\nadd a note to the exception",
-    "_interpchannels.ChannelEmptyError.with_traceback" => "Exception.with_traceback(tb) --\nset self.__traceback__ to tb and return self.",
-    "_interpchannels.ChannelError.__cause__" => "exception cause",
-    "_interpchannels.ChannelError.__context__" => "exception context",
+    "_interpchannels.ChannelEmptyError.add_note" => "Add a note to the exception",
+    "_interpchannels.ChannelEmptyError.with_traceback" => "Set self.__traceback__ to tb and return self.",
     "_interpchannels.ChannelError.__delattr__" => "Implement delattr(self, name).",
     "_interpchannels.ChannelError.__eq__" => "Return self==value.",
     "_interpchannels.ChannelError.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
@@ -960,8 +5105,8 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "_interpchannels.ChannelError.__str__" => "Return str(self).",
     "_interpchannels.ChannelError.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
     "_interpchannels.ChannelError.__weakref__" => "list of weak references to the object",
-    "_interpchannels.ChannelError.add_note" => "Exception.add_note(note) --\nadd a note to the exception",
-    "_interpchannels.ChannelError.with_traceback" => "Exception.with_traceback(tb) --\nset self.__traceback__ to tb and return self.",
+    "_interpchannels.ChannelError.add_note" => "Add a note to the exception",
+    "_interpchannels.ChannelError.with_traceback" => "Set self.__traceback__ to tb and return self.",
     "_interpchannels.ChannelID" => "A channel ID identifies a channel and may be used as an int.",
     "_interpchannels.ChannelID.__delattr__" => "Implement delattr(self, name).",
     "_interpchannels.ChannelID.__eq__" => "Return self==value.",
@@ -1036,8 +5181,6 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "_interpchannels.ChannelInfo.recv_released" => "current interpreter *was* bound to the recv end",
     "_interpchannels.ChannelInfo.send_associated" => "current interpreter is bound to the send end",
     "_interpchannels.ChannelInfo.send_released" => "current interpreter *was* bound to the send end",
-    "_interpchannels.ChannelNotEmptyError.__cause__" => "exception cause",
-    "_interpchannels.ChannelNotEmptyError.__context__" => "exception context",
     "_interpchannels.ChannelNotEmptyError.__delattr__" => "Implement delattr(self, name).",
     "_interpchannels.ChannelNotEmptyError.__eq__" => "Return self==value.",
     "_interpchannels.ChannelNotEmptyError.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
@@ -1059,10 +5202,8 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "_interpchannels.ChannelNotEmptyError.__str__" => "Return str(self).",
     "_interpchannels.ChannelNotEmptyError.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
     "_interpchannels.ChannelNotEmptyError.__weakref__" => "list of weak references to the object",
-    "_interpchannels.ChannelNotEmptyError.add_note" => "Exception.add_note(note) --\nadd a note to the exception",
-    "_interpchannels.ChannelNotEmptyError.with_traceback" => "Exception.with_traceback(tb) --\nset self.__traceback__ to tb and return self.",
-    "_interpchannels.ChannelNotFoundError.__cause__" => "exception cause",
-    "_interpchannels.ChannelNotFoundError.__context__" => "exception context",
+    "_interpchannels.ChannelNotEmptyError.add_note" => "Add a note to the exception",
+    "_interpchannels.ChannelNotEmptyError.with_traceback" => "Set self.__traceback__ to tb and return self.",
     "_interpchannels.ChannelNotFoundError.__delattr__" => "Implement delattr(self, name).",
     "_interpchannels.ChannelNotFoundError.__eq__" => "Return self==value.",
     "_interpchannels.ChannelNotFoundError.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
@@ -1084,8 +5225,8 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "_interpchannels.ChannelNotFoundError.__str__" => "Return str(self).",
     "_interpchannels.ChannelNotFoundError.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
     "_interpchannels.ChannelNotFoundError.__weakref__" => "list of weak references to the object",
-    "_interpchannels.ChannelNotFoundError.add_note" => "Exception.add_note(note) --\nadd a note to the exception",
-    "_interpchannels.ChannelNotFoundError.with_traceback" => "Exception.with_traceback(tb) --\nset self.__traceback__ to tb and return self.",
+    "_interpchannels.ChannelNotFoundError.add_note" => "Add a note to the exception",
+    "_interpchannels.ChannelNotFoundError.with_traceback" => "Set self.__traceback__ to tb and return self.",
     "_interpchannels.close" => "channel_close(cid, *, send=None, recv=None, force=False)\n\nClose the channel for all interpreters.\n\nIf the channel is empty then the keyword args are ignored and both\nends are immediately closed.  Otherwise, if 'force' is True then\nall queued items are released and both ends are immediately\nclosed.\n\nIf the channel is not empty *and* 'force' is False then following\nhappens:\n\n * recv is True (regardless of send):\n   - raise ChannelNotEmptyError\n * recv is None and send is None:\n   - raise ChannelNotEmptyError\n * send is True and recv is not True:\n   - fully close the 'send' end\n   - close the 'recv' end to interpreters not already receiving\n   - fully close it once empty\n\nClosing an already closed channel results in a ChannelClosedError.\n\nOnce the channel's ID has no more ref counts in any interpreter\nthe channel will be destroyed.",
     "_interpchannels.create" => "channel_create(unboundop) -> cid\n\nCreate a new cross-interpreter channel and return a unique generated ID.",
     "_interpchannels.destroy" => "channel_destroy(cid)\n\nClose and finalize the channel.  Afterward attempts to use the channel\nwill behave as though it never existed.",
@@ -1099,16 +5240,63 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "_interpchannels.send" => "channel_send(cid, obj, *, blocking=True, timeout=None)\n\nAdd the object's data to the channel's queue.\nBy default this waits for the object to be received.",
     "_interpchannels.send_buffer" => "channel_send_buffer(cid, obj, *, blocking=True, timeout=None)\n\nAdd the object's buffer to the channel's queue.\nBy default this waits for the object to be received.",
     "_interpqueues" => "This module provides primitive operations to manage Python interpreters.\nThe 'interpreters' module provides a more convenient interface.",
+    "_interpqueues.QueueError" => "Indicates that a queue-related error happened.",
+    "_interpqueues.QueueError.__delattr__" => "Implement delattr(self, name).",
+    "_interpqueues.QueueError.__eq__" => "Return self==value.",
+    "_interpqueues.QueueError.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_interpqueues.QueueError.__ge__" => "Return self>=value.",
+    "_interpqueues.QueueError.__getattribute__" => "Return getattr(self, name).",
+    "_interpqueues.QueueError.__getstate__" => "Helper for pickle.",
+    "_interpqueues.QueueError.__gt__" => "Return self>value.",
+    "_interpqueues.QueueError.__hash__" => "Return hash(self).",
+    "_interpqueues.QueueError.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_interpqueues.QueueError.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_interpqueues.QueueError.__le__" => "Return self<=value.",
+    "_interpqueues.QueueError.__lt__" => "Return self<value.",
+    "_interpqueues.QueueError.__ne__" => "Return self!=value.",
+    "_interpqueues.QueueError.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_interpqueues.QueueError.__reduce_ex__" => "Helper for pickle.",
+    "_interpqueues.QueueError.__repr__" => "Return repr(self).",
+    "_interpqueues.QueueError.__setattr__" => "Implement setattr(self, name, value).",
+    "_interpqueues.QueueError.__sizeof__" => "Size of object in memory, in bytes.",
+    "_interpqueues.QueueError.__str__" => "Return str(self).",
+    "_interpqueues.QueueError.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_interpqueues.QueueError.__weakref__" => "list of weak references to the object",
+    "_interpqueues.QueueError.add_note" => "Add a note to the exception",
+    "_interpqueues.QueueError.with_traceback" => "Set self.__traceback__ to tb and return self.",
+    "_interpqueues.QueueNotFoundError.__delattr__" => "Implement delattr(self, name).",
+    "_interpqueues.QueueNotFoundError.__eq__" => "Return self==value.",
+    "_interpqueues.QueueNotFoundError.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_interpqueues.QueueNotFoundError.__ge__" => "Return self>=value.",
+    "_interpqueues.QueueNotFoundError.__getattribute__" => "Return getattr(self, name).",
+    "_interpqueues.QueueNotFoundError.__getstate__" => "Helper for pickle.",
+    "_interpqueues.QueueNotFoundError.__gt__" => "Return self>value.",
+    "_interpqueues.QueueNotFoundError.__hash__" => "Return hash(self).",
+    "_interpqueues.QueueNotFoundError.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_interpqueues.QueueNotFoundError.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_interpqueues.QueueNotFoundError.__le__" => "Return self<=value.",
+    "_interpqueues.QueueNotFoundError.__lt__" => "Return self<value.",
+    "_interpqueues.QueueNotFoundError.__ne__" => "Return self!=value.",
+    "_interpqueues.QueueNotFoundError.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_interpqueues.QueueNotFoundError.__reduce_ex__" => "Helper for pickle.",
+    "_interpqueues.QueueNotFoundError.__repr__" => "Return repr(self).",
+    "_interpqueues.QueueNotFoundError.__setattr__" => "Implement setattr(self, name, value).",
+    "_interpqueues.QueueNotFoundError.__sizeof__" => "Size of object in memory, in bytes.",
+    "_interpqueues.QueueNotFoundError.__str__" => "Return str(self).",
+    "_interpqueues.QueueNotFoundError.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_interpqueues.QueueNotFoundError.__weakref__" => "list of weak references to the object",
+    "_interpqueues.QueueNotFoundError.add_note" => "Add a note to the exception",
+    "_interpqueues.QueueNotFoundError.with_traceback" => "Set self.__traceback__ to tb and return self.",
     "_interpqueues.bind" => "bind(qid)\n\nTake a reference to the identified queue.\nThe queue is not destroyed until there are no references left.",
-    "_interpqueues.create" => "create(maxsize, fmt, unboundop) -> qid\n\nCreate a new cross-interpreter queue and return its unique generated ID.\nIt is a new reference as though bind() had been called on the queue.\n\nThe caller is responsible for calling destroy() for the new queue\nbefore the runtime is finalized.",
+    "_interpqueues.create" => "create(maxsize, unboundop, fallback) -> qid\n\nCreate a new cross-interpreter queue and return its unique generated ID.\nIt is a new reference as though bind() had been called on the queue.\n\nThe caller is responsible for calling destroy() for the new queue\nbefore the runtime is finalized.",
     "_interpqueues.destroy" => "destroy(qid)\n\nClear and destroy the queue.  Afterward attempts to use the queue\nwill behave as though it never existed.",
-    "_interpqueues.get" => "get(qid) -> (obj, fmt)\n\nReturn a new object from the data at the front of the queue.\nThe object's format is also returned.\n\nIf there is nothing to receive then raise QueueEmpty.",
+    "_interpqueues.get" => "get(qid) -> (obj, unboundop)\n\nReturn a new object from the data at the front of the queue.\nThe unbound op is also returned.\n\nIf there is nothing to receive then raise QueueEmpty.",
     "_interpqueues.get_count" => "get_count(qid)\n\nReturn the number of items in the queue.",
     "_interpqueues.get_maxsize" => "get_maxsize(qid)\n\nReturn the maximum number of items in the queue.",
     "_interpqueues.get_queue_defaults" => "get_queue_defaults(qid)\n\nReturn the queue's default values, set when it was created.",
     "_interpqueues.is_full" => "is_full(qid)\n\nReturn true if the queue has a maxsize and has reached it.",
-    "_interpqueues.list_all" => "list_all() -> [(qid, fmt)]\n\nReturn the list of IDs for all queues.\nEach corresponding default format is also included.",
-    "_interpqueues.put" => "put(qid, obj, fmt)\n\nAdd the object's data to the queue.",
+    "_interpqueues.list_all" => "list_all() -> [(qid, unboundop, fallback)]\n\nReturn the list of IDs for all queues.\nEach corresponding default unbound op and fallback is also included.",
+    "_interpqueues.put" => "put(qid, obj)\n\nAdd the object's data to the queue.",
     "_interpqueues.release" => "release(qid)\n\nRelease a reference to the queue.\nThe queue is destroyed once there are no references left.",
     "_interpreters" => "This module provides primitive operations to manage Python interpreters.\nThe 'interpreters' module provides a more convenient interface.",
     "_interpreters.CrossInterpreterBufferView.__buffer__" => "Return a buffer object that exposes the underlying memory of the object.",
@@ -1133,9 +5321,78 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "_interpreters.CrossInterpreterBufferView.__sizeof__" => "Size of object in memory, in bytes.",
     "_interpreters.CrossInterpreterBufferView.__str__" => "Return str(self).",
     "_interpreters.CrossInterpreterBufferView.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
-    "_interpreters.call" => "call(id, callable, args=None, kwargs=None, *, restrict=False)\n\nCall the provided object in the identified interpreter.\nPass the given args and kwargs, if possible.\n\n\"callable\" may be a plain function with no free vars that takes\nno arguments.\n\nThe function's code object is used and all its state\nis ignored, including its __globals__ dict.",
+    "_interpreters.InterpreterError" => "A cross-interpreter operation failed",
+    "_interpreters.InterpreterError.__delattr__" => "Implement delattr(self, name).",
+    "_interpreters.InterpreterError.__eq__" => "Return self==value.",
+    "_interpreters.InterpreterError.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_interpreters.InterpreterError.__ge__" => "Return self>=value.",
+    "_interpreters.InterpreterError.__getattribute__" => "Return getattr(self, name).",
+    "_interpreters.InterpreterError.__getstate__" => "Helper for pickle.",
+    "_interpreters.InterpreterError.__gt__" => "Return self>value.",
+    "_interpreters.InterpreterError.__hash__" => "Return hash(self).",
+    "_interpreters.InterpreterError.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_interpreters.InterpreterError.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_interpreters.InterpreterError.__le__" => "Return self<=value.",
+    "_interpreters.InterpreterError.__lt__" => "Return self<value.",
+    "_interpreters.InterpreterError.__ne__" => "Return self!=value.",
+    "_interpreters.InterpreterError.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_interpreters.InterpreterError.__reduce_ex__" => "Helper for pickle.",
+    "_interpreters.InterpreterError.__repr__" => "Return repr(self).",
+    "_interpreters.InterpreterError.__setattr__" => "Implement setattr(self, name, value).",
+    "_interpreters.InterpreterError.__sizeof__" => "Size of object in memory, in bytes.",
+    "_interpreters.InterpreterError.__str__" => "Return str(self).",
+    "_interpreters.InterpreterError.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_interpreters.InterpreterError.add_note" => "Add a note to the exception",
+    "_interpreters.InterpreterError.with_traceback" => "Set self.__traceback__ to tb and return self.",
+    "_interpreters.InterpreterNotFoundError" => "An interpreter was not found",
+    "_interpreters.InterpreterNotFoundError.__delattr__" => "Implement delattr(self, name).",
+    "_interpreters.InterpreterNotFoundError.__eq__" => "Return self==value.",
+    "_interpreters.InterpreterNotFoundError.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_interpreters.InterpreterNotFoundError.__ge__" => "Return self>=value.",
+    "_interpreters.InterpreterNotFoundError.__getattribute__" => "Return getattr(self, name).",
+    "_interpreters.InterpreterNotFoundError.__getstate__" => "Helper for pickle.",
+    "_interpreters.InterpreterNotFoundError.__gt__" => "Return self>value.",
+    "_interpreters.InterpreterNotFoundError.__hash__" => "Return hash(self).",
+    "_interpreters.InterpreterNotFoundError.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_interpreters.InterpreterNotFoundError.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_interpreters.InterpreterNotFoundError.__le__" => "Return self<=value.",
+    "_interpreters.InterpreterNotFoundError.__lt__" => "Return self<value.",
+    "_interpreters.InterpreterNotFoundError.__ne__" => "Return self!=value.",
+    "_interpreters.InterpreterNotFoundError.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_interpreters.InterpreterNotFoundError.__reduce_ex__" => "Helper for pickle.",
+    "_interpreters.InterpreterNotFoundError.__repr__" => "Return repr(self).",
+    "_interpreters.InterpreterNotFoundError.__setattr__" => "Implement setattr(self, name, value).",
+    "_interpreters.InterpreterNotFoundError.__sizeof__" => "Size of object in memory, in bytes.",
+    "_interpreters.InterpreterNotFoundError.__str__" => "Return str(self).",
+    "_interpreters.InterpreterNotFoundError.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_interpreters.InterpreterNotFoundError.add_note" => "Add a note to the exception",
+    "_interpreters.InterpreterNotFoundError.with_traceback" => "Set self.__traceback__ to tb and return self.",
+    "_interpreters.NotShareableError.__delattr__" => "Implement delattr(self, name).",
+    "_interpreters.NotShareableError.__eq__" => "Return self==value.",
+    "_interpreters.NotShareableError.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_interpreters.NotShareableError.__ge__" => "Return self>=value.",
+    "_interpreters.NotShareableError.__getattribute__" => "Return getattr(self, name).",
+    "_interpreters.NotShareableError.__getstate__" => "Helper for pickle.",
+    "_interpreters.NotShareableError.__gt__" => "Return self>value.",
+    "_interpreters.NotShareableError.__hash__" => "Return hash(self).",
+    "_interpreters.NotShareableError.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_interpreters.NotShareableError.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_interpreters.NotShareableError.__le__" => "Return self<=value.",
+    "_interpreters.NotShareableError.__lt__" => "Return self<value.",
+    "_interpreters.NotShareableError.__ne__" => "Return self!=value.",
+    "_interpreters.NotShareableError.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_interpreters.NotShareableError.__reduce_ex__" => "Helper for pickle.",
+    "_interpreters.NotShareableError.__repr__" => "Return repr(self).",
+    "_interpreters.NotShareableError.__setattr__" => "Implement setattr(self, name, value).",
+    "_interpreters.NotShareableError.__sizeof__" => "Size of object in memory, in bytes.",
+    "_interpreters.NotShareableError.__str__" => "Return str(self).",
+    "_interpreters.NotShareableError.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_interpreters.NotShareableError.__weakref__" => "list of weak references to the object",
+    "_interpreters.NotShareableError.add_note" => "Add a note to the exception",
+    "_interpreters.NotShareableError.with_traceback" => "Set self.__traceback__ to tb and return self.",
+    "_interpreters.call" => "call(id, callable, args=None, kwargs=None, *, restrict=False)\n\nCall the provided object in the identified interpreter.\nPass the given args and kwargs, if possible.",
     "_interpreters.capture_exception" => "capture_exception(exc=None) -> types.SimpleNamespace\n\nReturn a snapshot of an exception.  If \"exc\" is None\nthen the current exception, if any, is used (but not cleared).\n\nThe returned snapshot is the same as what _interpreters.exec() returns.",
-    "_interpreters.create" => "create([config], *, reqrefs=False) -> ID\n\nCreate a new interpreter and return a unique generated ID.\n\nThe caller is responsible for destroying the interpreter before exiting,\ntypically by using _interpreters.destroy().  This can be managed \nautomatically by passing \"reqrefs=True\" and then using _incref() and\n_decref()` appropriately.\n\n\"config\" must be a valid interpreter config or the name of a\npredefined config (\"isolated\" or \"legacy\").  The default\nis \"isolated\".",
+    "_interpreters.create" => "create([config], *, reqrefs=False) -> ID\n\nCreate a new interpreter and return a unique generated ID.\n\nThe caller is responsible for destroying the interpreter before exiting,\ntypically by using _interpreters.destroy().  This can be managed \nautomatically by passing \"reqrefs=True\" and then using _incref() and\n_decref() appropriately.\n\n\"config\" must be a valid interpreter config or the name of a\npredefined config (\"isolated\" or \"legacy\").  The default\nis \"isolated\".",
     "_interpreters.destroy" => "destroy(id, *, restrict=False)\n\nDestroy the identified interpreter.\n\nAttempting to destroy the current interpreter raises InterpreterError.\nSo does an unrecognized ID.",
     "_interpreters.exec" => "exec(id, code, shared=None, *, restrict=False)\n\nExecute the provided code in the identified interpreter.\nThis is equivalent to running the builtin exec() under the target\ninterpreter, using the __dict__ of its __main__ module as both\nglobals and locals.\n\n\"code\" may be a string containing the text of a Python script.\n\nFunctions (and code objects) are also supported, with some restrictions.\nThe code/function must not take any arguments or be a closure\n(i.e. have cell vars).  Methods and other callables are not supported.\n\nIf a function is provided, its code object is used and all its state\nis ignored, including its __globals__ dict.",
     "_interpreters.get_config" => "get_config(id, *, restrict=False) -> types.SimpleNamespace\n\nReturn a representation of the config used to initialize the interpreter.",
@@ -1149,7 +5406,35 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "_interpreters.run_string" => "run_string(id, script, shared=None, *, restrict=False)\n\nExecute the provided string in the identified interpreter.\n\n(See _interpreters.exec().",
     "_interpreters.set___main___attrs" => "set___main___attrs(id, ns, *, restrict=False)\n\nBind the given attributes in the interpreter's __main__ module.",
     "_interpreters.whence" => "whence(id) -> int\n\nReturn an identifier for where the interpreter was created.",
-    "_io" => "The io module provides the Python interfaces to stream handling. The\nbuiltin open function is defined in this module.\n\nAt the top of the I/O hierarchy is the abstract base class IOBase. It\ndefines the basic interface to a stream. Note, however, that there is no\nseparation between reading and writing to streams; implementations are\nallowed to raise an OSError if they do not support a given operation.\n\nExtending IOBase is RawIOBase which deals simply with the reading and\nwriting of raw bytes to a stream. FileIO subclasses RawIOBase to provide\nan interface to OS files.\n\nBufferedIOBase deals with buffering on a raw byte stream (RawIOBase). Its\nsubclasses, BufferedWriter, BufferedReader, and BufferedRWPair buffer\nstreams that are readable, writable, and both respectively.\nBufferedRandom provides a buffered interface to random access\nstreams. BytesIO is a simple stream of in-memory bytes.\n\nAnother IOBase subclass, TextIOBase, deals with the encoding and decoding\nof streams into text. TextIOWrapper, which extends it, is a buffered text\ninterface to a buffered raw stream (`BufferedIOBase`). Finally, StringIO\nis an in-memory stream for text.\n\nArgument names are not part of the specification, and only the arguments\nof open() are intended to be used as keyword arguments.\n\ndata:\n\nDEFAULT_BUFFER_SIZE\n\n   An int containing the default buffer size used by the module's buffered\n   I/O classes. open() uses the file's blksize (as obtained by os.stat) if\n   possible.",
+    "_io" => "The io module provides the Python interfaces to stream handling. The\nbuiltin open function is defined in this module.\n\nAt the top of the I/O hierarchy is the abstract base class IOBase. It\ndefines the basic interface to a stream. Note, however, that there is no\nseparation between reading and writing to streams; implementations are\nallowed to raise an OSError if they do not support a given operation.\n\nExtending IOBase is RawIOBase which deals simply with the reading and\nwriting of raw bytes to a stream. FileIO subclasses RawIOBase to provide\nan interface to OS files.\n\nBufferedIOBase deals with buffering on a raw byte stream (RawIOBase). Its\nsubclasses, BufferedWriter, BufferedReader, and BufferedRWPair buffer\nstreams that are readable, writable, and both respectively.\nBufferedRandom provides a buffered interface to random access\nstreams. BytesIO is a simple stream of in-memory bytes.\n\nAnother IOBase subclass, TextIOBase, deals with the encoding and decoding\nof streams into text. TextIOWrapper, which extends it, is a buffered text\ninterface to a buffered raw stream (`BufferedIOBase`). Finally, StringIO\nis an in-memory stream for text.\n\nArgument names are not part of the specification, and only the arguments\nof open() are intended to be used as keyword arguments.\n\ndata:\n\nDEFAULT_BUFFER_SIZE\n\n   An int containing the default buffer size used by the module's buffered\n   I/O classes.",
+    "_io.BlockingIOError" => "I/O operation would block.",
+    "_io.BlockingIOError.__delattr__" => "Implement delattr(self, name).",
+    "_io.BlockingIOError.__eq__" => "Return self==value.",
+    "_io.BlockingIOError.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_io.BlockingIOError.__ge__" => "Return self>=value.",
+    "_io.BlockingIOError.__getattribute__" => "Return getattr(self, name).",
+    "_io.BlockingIOError.__getstate__" => "Helper for pickle.",
+    "_io.BlockingIOError.__gt__" => "Return self>value.",
+    "_io.BlockingIOError.__hash__" => "Return hash(self).",
+    "_io.BlockingIOError.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_io.BlockingIOError.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_io.BlockingIOError.__le__" => "Return self<=value.",
+    "_io.BlockingIOError.__lt__" => "Return self<value.",
+    "_io.BlockingIOError.__ne__" => "Return self!=value.",
+    "_io.BlockingIOError.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_io.BlockingIOError.__reduce_ex__" => "Helper for pickle.",
+    "_io.BlockingIOError.__repr__" => "Return repr(self).",
+    "_io.BlockingIOError.__setattr__" => "Implement setattr(self, name, value).",
+    "_io.BlockingIOError.__sizeof__" => "Size of object in memory, in bytes.",
+    "_io.BlockingIOError.__str__" => "Return str(self).",
+    "_io.BlockingIOError.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_io.BlockingIOError.add_note" => "Add a note to the exception",
+    "_io.BlockingIOError.errno" => "POSIX exception code",
+    "_io.BlockingIOError.filename" => "exception filename",
+    "_io.BlockingIOError.filename2" => "second exception filename",
+    "_io.BlockingIOError.strerror" => "exception strerror",
+    "_io.BlockingIOError.winerror" => "Win32 exception code",
+    "_io.BlockingIOError.with_traceback" => "Set self.__traceback__ to tb and return self.",
     "_io.BufferedRWPair" => "A buffered reader and writer object together.\n\nA buffered reader object and buffered writer object put together to\nform a sequential IO object that can read and write. This is typically\nused with a socket or two-way pipe.\n\nreader and writer are RawIOBase objects that are readable and\nwriteable respectively. If the buffer_size is omitted it defaults to\nDEFAULT_BUFFER_SIZE.",
     "_io.BufferedRWPair.__del__" => "Called when the instance is about to be destroyed.",
     "_io.BufferedRWPair.__delattr__" => "Implement delattr(self, name).",
@@ -1333,6 +5618,7 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "_io.FileIO.__sizeof__" => "Size of object in memory, in bytes.",
     "_io.FileIO.__str__" => "Return str(self).",
     "_io.FileIO.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_io.FileIO._blksize" => "Stat st_blksize if available",
     "_io.FileIO.close" => "Close the file.\n\nA closed file cannot be used for further I/O operations.  close() may be\ncalled more than once without error.",
     "_io.FileIO.closed" => "True if the file is closed",
     "_io.FileIO.closefd" => "True if the file descriptor will be closed by close().",
@@ -1340,9 +5626,9 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "_io.FileIO.flush" => "Flush write buffers, if applicable.\n\nThis is not implemented for read-only and non-blocking streams.",
     "_io.FileIO.isatty" => "True if the file is connected to a TTY device.",
     "_io.FileIO.mode" => "String giving the file mode",
-    "_io.FileIO.read" => "Read at most size bytes, returned as bytes.\n\nOnly makes one system call, so less data may be returned than requested.\nIn non-blocking mode, returns None if no data is available.\nReturn an empty bytes object at EOF.",
+    "_io.FileIO.read" => "Read at most size bytes, returned as bytes.\n\nIf size is less than 0, read all bytes in the file making multiple read calls.\nSee ``FileIO.readall``.\n\nAttempts to make only one system call, retrying only per PEP 475 (EINTR). This\nmeans less data may be returned than requested.\n\nIn non-blocking mode, returns None if no data is available. Return an empty\nbytes object at EOF.",
     "_io.FileIO.readable" => "True if file was opened in a read mode.",
-    "_io.FileIO.readall" => "Read all data from the file, returned as bytes.\n\nIn non-blocking mode, returns as much as is immediately available,\nor None if no data is available.  Return an empty bytes object at EOF.",
+    "_io.FileIO.readall" => "Read all data from the file, returned as bytes.\n\nReads until either there is an error or read() returns size 0 (indicates EOF).\nIf the file is already at EOF, returns an empty bytes object.\n\nIn non-blocking mode, returns as much data as could be read before EAGAIN. If no\ndata is available (EAGAIN is returned before bytes are read) returns None.",
     "_io.FileIO.readinto" => "Same as RawIOBase.readinto().",
     "_io.FileIO.readline" => "Read and return a line from the stream.\n\nIf size is specified, at most size bytes will be read.\n\nThe line terminator is always b'\\n' for binary files; for text\nfiles, the newlines argument to open can be used to select the line\nterminator(s) recognized.",
     "_io.FileIO.readlines" => "Return a list of lines from the stream.\n\nhint can be specified to control the number of lines read: no more\nlines will be read if the total size (in bytes/characters) of all\nlines so far exceeds hint.",
@@ -1447,6 +5733,34 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "_io.TextIOWrapper.seek" => "Set the stream position, and return the new stream position.\n\n  cookie\n    Zero or an opaque number returned by tell().\n  whence\n    The relative position to seek from.\n\nFour operations are supported, given by the following argument\ncombinations:\n\n- seek(0, SEEK_SET): Rewind to the start of the stream.\n- seek(cookie, SEEK_SET): Restore a previous position;\n  'cookie' must be a number returned by tell().\n- seek(0, SEEK_END): Fast-forward to the end of the stream.\n- seek(0, SEEK_CUR): Leave the current stream position unchanged.\n\nAny other argument combinations are invalid,\nand may raise exceptions.",
     "_io.TextIOWrapper.tell" => "Return the stream position as an opaque number.\n\nThe return value of tell() can be given as input to seek(), to restore a\nprevious stream position.",
     "_io.TextIOWrapper.writelines" => "Write a list of lines to stream.\n\nLine separators are not added, so it is usual for each of the\nlines provided to have a line separator at the end.",
+    "_io.UnsupportedOperation.__delattr__" => "Implement delattr(self, name).",
+    "_io.UnsupportedOperation.__eq__" => "Return self==value.",
+    "_io.UnsupportedOperation.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_io.UnsupportedOperation.__ge__" => "Return self>=value.",
+    "_io.UnsupportedOperation.__getattribute__" => "Return getattr(self, name).",
+    "_io.UnsupportedOperation.__getstate__" => "Helper for pickle.",
+    "_io.UnsupportedOperation.__gt__" => "Return self>value.",
+    "_io.UnsupportedOperation.__hash__" => "Return hash(self).",
+    "_io.UnsupportedOperation.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_io.UnsupportedOperation.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_io.UnsupportedOperation.__le__" => "Return self<=value.",
+    "_io.UnsupportedOperation.__lt__" => "Return self<value.",
+    "_io.UnsupportedOperation.__ne__" => "Return self!=value.",
+    "_io.UnsupportedOperation.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_io.UnsupportedOperation.__reduce_ex__" => "Helper for pickle.",
+    "_io.UnsupportedOperation.__repr__" => "Return repr(self).",
+    "_io.UnsupportedOperation.__setattr__" => "Implement setattr(self, name, value).",
+    "_io.UnsupportedOperation.__sizeof__" => "Size of object in memory, in bytes.",
+    "_io.UnsupportedOperation.__str__" => "Return str(self).",
+    "_io.UnsupportedOperation.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_io.UnsupportedOperation.__weakref__" => "list of weak references to the object",
+    "_io.UnsupportedOperation.add_note" => "Add a note to the exception",
+    "_io.UnsupportedOperation.errno" => "POSIX exception code",
+    "_io.UnsupportedOperation.filename" => "exception filename",
+    "_io.UnsupportedOperation.filename2" => "second exception filename",
+    "_io.UnsupportedOperation.strerror" => "exception strerror",
+    "_io.UnsupportedOperation.winerror" => "Win32 exception code",
+    "_io.UnsupportedOperation.with_traceback" => "Set self.__traceback__ to tb and return self.",
     "_io._BufferedIOBase" => "Base class for buffered IO objects.\n\nThe main difference with RawIOBase is that the read() method\nsupports omitting the size argument, and does not have a default\nimplementation that defers to readinto().\n\nIn addition, read(), readinto() and write() may raise\nBlockingIOError if the underlying raw stream is in non-blocking\nmode and not ready; unlike their raw counterparts, they will never\nreturn None.\n\nA typical implementation should not inherit from a RawIOBase\nimplementation, but wrap one.",
     "_io._BufferedIOBase.__del__" => "Called when the instance is about to be destroyed.",
     "_io._BufferedIOBase.__delattr__" => "Implement delattr(self, name).",
@@ -1678,7 +5992,7 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "_io._WindowsConsoleIO.writable" => "True if console is an output buffer.",
     "_io._WindowsConsoleIO.write" => "Write buffer b to file, return number of bytes written.\n\nOnly makes one system call, so not all of the data may be written.\nThe number of bytes actually written is returned.",
     "_io._WindowsConsoleIO.writelines" => "Write a list of lines to stream.\n\nLine separators are not added, so it is usual for each of the\nlines provided to have a line separator at the end.",
-    "_io.open" => "Open file and return a stream.  Raise OSError upon failure.\n\nfile is either a text or byte string giving the name (and the path\nif the file isn't in the current working directory) of the file to\nbe opened or an integer file descriptor of the file to be\nwrapped. (If a file descriptor is given, it is closed when the\nreturned I/O object is closed, unless closefd is set to False.)\n\nmode is an optional string that specifies the mode in which the file\nis opened. It defaults to 'r' which means open for reading in text\nmode.  Other common values are 'w' for writing (truncating the file if\nit already exists), 'x' for creating and writing to a new file, and\n'a' for appending (which on some Unix systems, means that all writes\nappend to the end of the file regardless of the current seek position).\nIn text mode, if encoding is not specified the encoding used is platform\ndependent: locale.getencoding() is called to get the current locale encoding.\n(For reading and writing raw bytes use binary mode and leave encoding\nunspecified.) The available modes are:\n\n========= ===============================================================\nCharacter Meaning\n--------- ---------------------------------------------------------------\n'r'       open for reading (default)\n'w'       open for writing, truncating the file first\n'x'       create a new file and open it for writing\n'a'       open for writing, appending to the end of the file if it exists\n'b'       binary mode\n't'       text mode (default)\n'+'       open a disk file for updating (reading and writing)\n========= ===============================================================\n\nThe default mode is 'rt' (open for reading text). For binary random\naccess, the mode 'w+b' opens and truncates the file to 0 bytes, while\n'r+b' opens the file without truncation. The 'x' mode implies 'w' and\nraises an `FileExistsError` if the file already exists.\n\nPython distinguishes between files opened in binary and text modes,\neven when the underlying operating system doesn't. Files opened in\nbinary mode (appending 'b' to the mode argument) return contents as\nbytes objects without any decoding. In text mode (the default, or when\n't' is appended to the mode argument), the contents of the file are\nreturned as strings, the bytes having been first decoded using a\nplatform-dependent encoding or using the specified encoding if given.\n\nbuffering is an optional integer used to set the buffering policy.\nPass 0 to switch buffering off (only allowed in binary mode), 1 to select\nline buffering (only usable in text mode), and an integer > 1 to indicate\nthe size of a fixed-size chunk buffer.  When no buffering argument is\ngiven, the default buffering policy works as follows:\n\n* Binary files are buffered in fixed-size chunks; the size of the buffer\n  is chosen using a heuristic trying to determine the underlying device's\n  \"block size\" and falling back on `io.DEFAULT_BUFFER_SIZE`.\n  On many systems, the buffer will typically be 4096 or 8192 bytes long.\n\n* \"Interactive\" text files (files for which isatty() returns True)\n  use line buffering.  Other text files use the policy described above\n  for binary files.\n\nencoding is the name of the encoding used to decode or encode the\nfile. This should only be used in text mode. The default encoding is\nplatform dependent, but any encoding supported by Python can be\npassed.  See the codecs module for the list of supported encodings.\n\nerrors is an optional string that specifies how encoding errors are to\nbe handled---this argument should not be used in binary mode. Pass\n'strict' to raise a ValueError exception if there is an encoding error\n(the default of None has the same effect), or pass 'ignore' to ignore\nerrors. (Note that ignoring encoding errors can lead to data loss.)\nSee the documentation for codecs.register or run 'help(codecs.Codec)'\nfor a list of the permitted encoding error strings.\n\nnewline controls how universal newlines works (it only applies to text\nmode). It can be None, '', '\\n', '\\r', and '\\r\\n'.  It works as\nfollows:\n\n* On input, if newline is None, universal newlines mode is\n  enabled. Lines in the input can end in '\\n', '\\r', or '\\r\\n', and\n  these are translated into '\\n' before being returned to the\n  caller. If it is '', universal newline mode is enabled, but line\n  endings are returned to the caller untranslated. If it has any of\n  the other legal values, input lines are only terminated by the given\n  string, and the line ending is returned to the caller untranslated.\n\n* On output, if newline is None, any '\\n' characters written are\n  translated to the system default line separator, os.linesep. If\n  newline is '' or '\\n', no translation takes place. If newline is any\n  of the other legal values, any '\\n' characters written are translated\n  to the given string.\n\nIf closefd is False, the underlying file descriptor will be kept open\nwhen the file is closed. This does not work when a file name is given\nand must be True in that case.\n\nA custom opener can be used by passing a callable as *opener*. The\nunderlying file descriptor for the file object is then obtained by\ncalling *opener* with (*file*, *flags*). *opener* must return an open\nfile descriptor (passing os.open as *opener* results in functionality\nsimilar to passing None).\n\nopen() returns a file object whose type depends on the mode, and\nthrough which the standard file operations such as reading and writing\nare performed. When open() is used to open a file in a text mode ('w',\n'r', 'wt', 'rt', etc.), it returns a TextIOWrapper. When used to open\na file in a binary mode, the returned class varies: in read binary\nmode, it returns a BufferedReader; in write binary and append binary\nmodes, it returns a BufferedWriter, and in read/write mode, it returns\na BufferedRandom.\n\nIt is also possible to use a string or bytearray as a file for both\nreading and writing. For strings StringIO can be used like a file\nopened in a text mode, and for bytes a BytesIO can be used like a file\nopened in a binary mode.",
+    "_io.open" => "Open file and return a stream.  Raise OSError upon failure.\n\nfile is either a text or byte string giving the name (and the path\nif the file isn't in the current working directory) of the file to\nbe opened or an integer file descriptor of the file to be\nwrapped. (If a file descriptor is given, it is closed when the\nreturned I/O object is closed, unless closefd is set to False.)\n\nmode is an optional string that specifies the mode in which the file\nis opened. It defaults to 'r' which means open for reading in text\nmode.  Other common values are 'w' for writing (truncating the file if\nit already exists), 'x' for creating and writing to a new file, and\n'a' for appending (which on some Unix systems, means that all writes\nappend to the end of the file regardless of the current seek position).\nIn text mode, if encoding is not specified the encoding used is platform\ndependent: locale.getencoding() is called to get the current locale encoding.\n(For reading and writing raw bytes use binary mode and leave encoding\nunspecified.) The available modes are:\n\n========= ===============================================================\nCharacter Meaning\n--------- ---------------------------------------------------------------\n'r'       open for reading (default)\n'w'       open for writing, truncating the file first\n'x'       create a new file and open it for writing\n'a'       open for writing, appending to the end of the file if it exists\n'b'       binary mode\n't'       text mode (default)\n'+'       open a disk file for updating (reading and writing)\n========= ===============================================================\n\nThe default mode is 'rt' (open for reading text). For binary random\naccess, the mode 'w+b' opens and truncates the file to 0 bytes, while\n'r+b' opens the file without truncation. The 'x' mode implies 'w' and\nraises an `FileExistsError` if the file already exists.\n\nPython distinguishes between files opened in binary and text modes,\neven when the underlying operating system doesn't. Files opened in\nbinary mode (appending 'b' to the mode argument) return contents as\nbytes objects without any decoding. In text mode (the default, or when\n't' is appended to the mode argument), the contents of the file are\nreturned as strings, the bytes having been first decoded using a\nplatform-dependent encoding or using the specified encoding if given.\n\nbuffering is an optional integer used to set the buffering policy.\nPass 0 to switch buffering off (only allowed in binary mode), 1 to select\nline buffering (only usable in text mode), and an integer > 1 to indicate\nthe size of a fixed-size chunk buffer.  When no buffering argument is\ngiven, the default buffering policy works as follows:\n\n* Binary files are buffered in fixed-size chunks; the size of the buffer\n is max(min(blocksize, 8 MiB), DEFAULT_BUFFER_SIZE)\n when the device block size is available.\n On most systems, the buffer will typically be 128 kilobytes long.\n\n* \"Interactive\" text files (files for which isatty() returns True)\n  use line buffering.  Other text files use the policy described above\n  for binary files.\n\nencoding is the name of the encoding used to decode or encode the\nfile. This should only be used in text mode. The default encoding is\nplatform dependent, but any encoding supported by Python can be\npassed.  See the codecs module for the list of supported encodings.\n\nerrors is an optional string that specifies how encoding errors are to\nbe handled---this argument should not be used in binary mode. Pass\n'strict' to raise a ValueError exception if there is an encoding error\n(the default of None has the same effect), or pass 'ignore' to ignore\nerrors. (Note that ignoring encoding errors can lead to data loss.)\nSee the documentation for codecs.register or run 'help(codecs.Codec)'\nfor a list of the permitted encoding error strings.\n\nnewline controls how universal newlines works (it only applies to text\nmode). It can be None, '', '\\n', '\\r', and '\\r\\n'.  It works as\nfollows:\n\n* On input, if newline is None, universal newlines mode is\n  enabled. Lines in the input can end in '\\n', '\\r', or '\\r\\n', and\n  these are translated into '\\n' before being returned to the\n  caller. If it is '', universal newline mode is enabled, but line\n  endings are returned to the caller untranslated. If it has any of\n  the other legal values, input lines are only terminated by the given\n  string, and the line ending is returned to the caller untranslated.\n\n* On output, if newline is None, any '\\n' characters written are\n  translated to the system default line separator, os.linesep. If\n  newline is '' or '\\n', no translation takes place. If newline is any\n  of the other legal values, any '\\n' characters written are translated\n  to the given string.\n\nIf closefd is False, the underlying file descriptor will be kept open\nwhen the file is closed. This does not work when a file name is given\nand must be True in that case.\n\nA custom opener can be used by passing a callable as *opener*. The\nunderlying file descriptor for the file object is then obtained by\ncalling *opener* with (*file*, *flags*). *opener* must return an open\nfile descriptor (passing os.open as *opener* results in functionality\nsimilar to passing None).\n\nopen() returns a file object whose type depends on the mode, and\nthrough which the standard file operations such as reading and writing\nare performed. When open() is used to open a file in a text mode ('w',\n'r', 'wt', 'rt', etc.), it returns a TextIOWrapper. When used to open\na file in a binary mode, the returned class varies: in read binary\nmode, it returns a BufferedReader; in write binary and append binary\nmodes, it returns a BufferedWriter, and in read/write mode, it returns\na BufferedRandom.\n\nIt is also possible to use a string or bytearray as a file for both\nreading and writing. For strings StringIO can be used like a file\nopened in a text mode, and for bytes a BytesIO can be used like a file\nopened in a binary mode.",
     "_io.open_code" => "Opens the provided file with the intent to import the contents.\n\nThis may perform extra validation beyond open(), but is otherwise interchangeable\nwith calling open(path, 'rb').",
     "_io.text_encoding" => "A helper function to choose the text encoding.\n\nWhen encoding is not None, this function returns it.\nOtherwise, this function returns the default text encoding\n(i.e. \"locale\" or \"utf-8\" depends on UTF-8 mode).\n\nThis function emits an EncodingWarning if encoding is None and\nsys.flags.warn_default_encoding is true.\n\nThis can be used in APIs with an encoding=None parameter.\nHowever, please consider using encoding=\"utf-8\" for new APIs.",
     "_json" => "json speedups",
@@ -1745,6 +6059,29 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "_json.make_scanner.strict" => "strict",
     "_json.scanstring" => "scanstring(string, end, strict=True) -> (string, end)\n\nScan the string s for a JSON string. End is the index of the\ncharacter in s after the quote that started the JSON string.\nUnescapes all valid JSON string escape sequences and raises ValueError\non attempt to decode an invalid string. If strict is False then literal\ncontrol characters are allowed in the string.\n\nReturns a tuple of the decoded string and the index of the character in s\nafter the end quote.",
     "_locale" => "Support for POSIX locales.",
+    "_locale.Error.__delattr__" => "Implement delattr(self, name).",
+    "_locale.Error.__eq__" => "Return self==value.",
+    "_locale.Error.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_locale.Error.__ge__" => "Return self>=value.",
+    "_locale.Error.__getattribute__" => "Return getattr(self, name).",
+    "_locale.Error.__getstate__" => "Helper for pickle.",
+    "_locale.Error.__gt__" => "Return self>value.",
+    "_locale.Error.__hash__" => "Return hash(self).",
+    "_locale.Error.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_locale.Error.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_locale.Error.__le__" => "Return self<=value.",
+    "_locale.Error.__lt__" => "Return self<value.",
+    "_locale.Error.__ne__" => "Return self!=value.",
+    "_locale.Error.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_locale.Error.__reduce_ex__" => "Helper for pickle.",
+    "_locale.Error.__repr__" => "Return repr(self).",
+    "_locale.Error.__setattr__" => "Implement setattr(self, name, value).",
+    "_locale.Error.__sizeof__" => "Size of object in memory, in bytes.",
+    "_locale.Error.__str__" => "Return str(self).",
+    "_locale.Error.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_locale.Error.__weakref__" => "list of weak references to the object",
+    "_locale.Error.add_note" => "Add a note to the exception",
+    "_locale.Error.with_traceback" => "Set self.__traceback__ to tb and return self.",
     "_locale.bind_textdomain_codeset" => "Bind the C library's domain to codeset.",
     "_locale.bindtextdomain" => "Bind the C library's domain to dir.",
     "_locale.dcgettext" => "Return translation of msg in domain and category.",
@@ -1758,7 +6095,7 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "_locale.strxfrm" => "Return a string that can be used as a key for locale-aware comparisons.",
     "_locale.textdomain" => "Set the C library's textdmain to domain, returning the new domain.",
     "_lsprof" => "Fast profiler",
-    "_lsprof.Profiler" => "Profiler(timer=None, timeunit=None, subcalls=True, builtins=True)\n\nBuilds a profiler object using the specified timer function.\nThe default timer is a fast built-in one based on real time.\nFor custom timer functions returning integers, timeunit can\nbe a float specifying a scale (i.e. how long each integer unit\nis, in seconds).",
+    "_lsprof.Profiler" => "Build a profiler object using the specified timer function.\n\nThe default timer is a fast built-in one based on real time.\nFor custom timer functions returning integers, 'timeunit' can\nbe a float specifying a scale (that is, how long each integer unit\nis, in seconds).",
     "_lsprof.Profiler.__delattr__" => "Implement delattr(self, name).",
     "_lsprof.Profiler.__eq__" => "Return self==value.",
     "_lsprof.Profiler.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
@@ -1780,9 +6117,9 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "_lsprof.Profiler.__sizeof__" => "Size of object in memory, in bytes.",
     "_lsprof.Profiler.__str__" => "Return str(self).",
     "_lsprof.Profiler.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
-    "_lsprof.Profiler.clear" => "clear()\n\nClear all profiling information collected so far.",
-    "_lsprof.Profiler.disable" => "disable()\n\nStop collecting profiling information.",
-    "_lsprof.Profiler.enable" => "enable(subcalls=True, builtins=True)\n\nStart collecting profiling information.\nIf 'subcalls' is True, also records for each function\nstatistics separated according to its current caller.\nIf 'builtins' is True, records the time spent in\nbuilt-in functions separately from their caller.",
+    "_lsprof.Profiler.clear" => "Clear all profiling information collected so far.",
+    "_lsprof.Profiler.disable" => "Stop collecting profiling information.",
+    "_lsprof.Profiler.enable" => "Start collecting profiling information.\n\n  subcalls\n    If True, also records for each function\n    statistics separated according to its current caller.\n  builtins\n    If True, records the time spent in\n    built-in functions separately from their caller.",
     "_lsprof.Profiler.getstats" => "list of profiler_entry objects.\n\ngetstats() -> list of profiler_entry objects\n\nReturn all information collected by the profiler.\nEach profiler_entry is a tuple-like object with the\nfollowing attributes:\n\n    code          code object\n    callcount     how many times this was called\n    reccallcount  how many times called recursively\n    totaltime     total time in this entry\n    inlinetime    inline time in this entry (not in subcalls)\n    calls         details of the calls\n\nThe calls attribute is either None or a list of\nprofiler_subentry objects:\n\n    code          called code object\n    callcount     how many times this is called\n    reccallcount  how many times this is called recursively\n    totaltime     total time spent in this call\n    inlinetime    inline time (not in further subcalls)",
     "_lsprof.profiler_entry.__add__" => "Return self+value.",
     "_lsprof.profiler_entry.__class_getitem__" => "See PEP 585",
@@ -1909,8 +6246,6 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "_lzma.LZMADecompressor.needs_input" => "True if more input is needed before more decompressed data can be produced.",
     "_lzma.LZMADecompressor.unused_data" => "Data found after the end of the compressed stream.",
     "_lzma.LZMAError" => "Call to liblzma failed.",
-    "_lzma.LZMAError.__cause__" => "exception cause",
-    "_lzma.LZMAError.__context__" => "exception context",
     "_lzma.LZMAError.__delattr__" => "Implement delattr(self, name).",
     "_lzma.LZMAError.__eq__" => "Return self==value.",
     "_lzma.LZMAError.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
@@ -1932,8 +6267,8 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "_lzma.LZMAError.__str__" => "Return str(self).",
     "_lzma.LZMAError.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
     "_lzma.LZMAError.__weakref__" => "list of weak references to the object",
-    "_lzma.LZMAError.add_note" => "Exception.add_note(note) --\nadd a note to the exception",
-    "_lzma.LZMAError.with_traceback" => "Exception.with_traceback(tb) --\nset self.__traceback__ to tb and return self.",
+    "_lzma.LZMAError.add_note" => "Add a note to the exception",
+    "_lzma.LZMAError.with_traceback" => "Set self.__traceback__ to tb and return self.",
     "_lzma._decode_filter_properties" => "Return a bytes object encoding the options (properties) of the filter specified by *filter* (a dict).\n\nThe result does not include the filter ID itself, only the options.",
     "_lzma._encode_filter_properties" => "Return a bytes object encoding the options (properties) of the filter specified by *filter* (a dict).\n\nThe result does not include the filter ID itself, only the options.",
     "_lzma.is_check_supported" => "Test whether the given integrity check is supported.\n\nAlways returns True for CHECK_NONE and CHECK_CRC32.",
@@ -2091,6 +6426,7 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "_opcode.get_intrinsic1_descs" => "Return a list of names of the unary intrinsics.",
     "_opcode.get_intrinsic2_descs" => "Return a list of names of the binary intrinsics.",
     "_opcode.get_nb_ops" => "Return array of symbols of binary ops.\n\nIndexed by the BINARY_OP oparg value.",
+    "_opcode.get_special_method_names" => "Return a list of special method names.",
     "_opcode.get_specialization_stats" => "Return the specialization stats",
     "_opcode.has_arg" => "Return True if the opcode uses its oparg, False otherwise.",
     "_opcode.has_const" => "Return True if the opcode accesses a constant, False otherwise.",
@@ -2106,6 +6442,29 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "_operator.abs" => "Same as abs(a).",
     "_operator.add" => "Same as a + b.",
     "_operator.and_" => "Same as a & b.",
+    "_operator.attrgetter" => "Return a callable object that fetches the given attribute(s) from its operand.\nAfter f = attrgetter('name'), the call f(r) returns r.name.\nAfter g = attrgetter('name', 'date'), the call g(r) returns (r.name, r.date).\nAfter h = attrgetter('name.first', 'name.last'), the call h(r) returns\n(r.name.first, r.name.last).",
+    "_operator.attrgetter.__call__" => "Call self as a function.",
+    "_operator.attrgetter.__delattr__" => "Implement delattr(self, name).",
+    "_operator.attrgetter.__eq__" => "Return self==value.",
+    "_operator.attrgetter.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_operator.attrgetter.__ge__" => "Return self>=value.",
+    "_operator.attrgetter.__getattribute__" => "Return getattr(self, name).",
+    "_operator.attrgetter.__getstate__" => "Helper for pickle.",
+    "_operator.attrgetter.__gt__" => "Return self>value.",
+    "_operator.attrgetter.__hash__" => "Return hash(self).",
+    "_operator.attrgetter.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_operator.attrgetter.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_operator.attrgetter.__le__" => "Return self<=value.",
+    "_operator.attrgetter.__lt__" => "Return self<value.",
+    "_operator.attrgetter.__ne__" => "Return self!=value.",
+    "_operator.attrgetter.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_operator.attrgetter.__reduce__" => "Return state information for pickling",
+    "_operator.attrgetter.__reduce_ex__" => "Helper for pickle.",
+    "_operator.attrgetter.__repr__" => "Return repr(self).",
+    "_operator.attrgetter.__setattr__" => "Implement setattr(self, name, value).",
+    "_operator.attrgetter.__sizeof__" => "Size of object in memory, in bytes.",
+    "_operator.attrgetter.__str__" => "Return str(self).",
+    "_operator.attrgetter.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
     "_operator.call" => "Same as obj(*args, **kwargs).",
     "_operator.concat" => "Same as a + b, for a and b sequences.",
     "_operator.contains" => "Same as b in a (note reversed operands).",
@@ -2132,8 +6491,33 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "_operator.ipow" => "Same as a **= b.",
     "_operator.irshift" => "Same as a >>= b.",
     "_operator.is_" => "Same as a is b.",
+    "_operator.is_none" => "Same as a is None.",
     "_operator.is_not" => "Same as a is not b.",
+    "_operator.is_not_none" => "Same as a is not None.",
     "_operator.isub" => "Same as a -= b.",
+    "_operator.itemgetter" => "Return a callable object that fetches the given item(s) from its operand.\nAfter f = itemgetter(2), the call f(r) returns r[2].\nAfter g = itemgetter(2, 5, 3), the call g(r) returns (r[2], r[5], r[3])",
+    "_operator.itemgetter.__call__" => "Call self as a function.",
+    "_operator.itemgetter.__delattr__" => "Implement delattr(self, name).",
+    "_operator.itemgetter.__eq__" => "Return self==value.",
+    "_operator.itemgetter.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_operator.itemgetter.__ge__" => "Return self>=value.",
+    "_operator.itemgetter.__getattribute__" => "Return getattr(self, name).",
+    "_operator.itemgetter.__getstate__" => "Helper for pickle.",
+    "_operator.itemgetter.__gt__" => "Return self>value.",
+    "_operator.itemgetter.__hash__" => "Return hash(self).",
+    "_operator.itemgetter.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_operator.itemgetter.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_operator.itemgetter.__le__" => "Return self<=value.",
+    "_operator.itemgetter.__lt__" => "Return self<value.",
+    "_operator.itemgetter.__ne__" => "Return self!=value.",
+    "_operator.itemgetter.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_operator.itemgetter.__reduce__" => "Return state information for pickling",
+    "_operator.itemgetter.__reduce_ex__" => "Helper for pickle.",
+    "_operator.itemgetter.__repr__" => "Return repr(self).",
+    "_operator.itemgetter.__setattr__" => "Implement setattr(self, name, value).",
+    "_operator.itemgetter.__sizeof__" => "Size of object in memory, in bytes.",
+    "_operator.itemgetter.__str__" => "Return str(self).",
+    "_operator.itemgetter.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
     "_operator.itruediv" => "Same as a /= b.",
     "_operator.ixor" => "Same as a ^= b.",
     "_operator.le" => "Same as a <= b.",
@@ -2141,6 +6525,29 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "_operator.lshift" => "Same as a << b.",
     "_operator.lt" => "Same as a < b.",
     "_operator.matmul" => "Same as a @ b.",
+    "_operator.methodcaller" => "Return a callable object that calls the given method on its operand.\nAfter f = methodcaller('name'), the call f(r) returns r.name().\nAfter g = methodcaller('name', 'date', foo=1), the call g(r) returns\nr.name('date', foo=1).",
+    "_operator.methodcaller.__call__" => "Call self as a function.",
+    "_operator.methodcaller.__delattr__" => "Implement delattr(self, name).",
+    "_operator.methodcaller.__eq__" => "Return self==value.",
+    "_operator.methodcaller.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_operator.methodcaller.__ge__" => "Return self>=value.",
+    "_operator.methodcaller.__getattribute__" => "Return getattr(self, name).",
+    "_operator.methodcaller.__getstate__" => "Helper for pickle.",
+    "_operator.methodcaller.__gt__" => "Return self>value.",
+    "_operator.methodcaller.__hash__" => "Return hash(self).",
+    "_operator.methodcaller.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_operator.methodcaller.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_operator.methodcaller.__le__" => "Return self<=value.",
+    "_operator.methodcaller.__lt__" => "Return self<value.",
+    "_operator.methodcaller.__ne__" => "Return self!=value.",
+    "_operator.methodcaller.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_operator.methodcaller.__reduce__" => "Return state information for pickling",
+    "_operator.methodcaller.__reduce_ex__" => "Helper for pickle.",
+    "_operator.methodcaller.__repr__" => "Return repr(self).",
+    "_operator.methodcaller.__setattr__" => "Implement setattr(self, name, value).",
+    "_operator.methodcaller.__sizeof__" => "Size of object in memory, in bytes.",
+    "_operator.methodcaller.__str__" => "Return str(self).",
+    "_operator.methodcaller.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
     "_operator.mod" => "Same as a % b.",
     "_operator.mul" => "Same as a * b.",
     "_operator.ne" => "Same as a != b.",
@@ -2210,8 +6617,32 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "_overlapped.UnregisterWaitEx" => "Unregister wait handle.",
     "_overlapped.WSAConnect" => "Bind a remote address to a connectionless (UDP) socket.",
     "_pickle" => "Optimized C implementation for the Python pickle module.",
-    "_pickle.PickleError.__cause__" => "exception cause",
-    "_pickle.PickleError.__context__" => "exception context",
+    "_pickle.PickleBuffer" => "Wrapper for potentially out-of-band buffers",
+    "_pickle.PickleBuffer.__buffer__" => "Return a buffer object that exposes the underlying memory of the object.",
+    "_pickle.PickleBuffer.__delattr__" => "Implement delattr(self, name).",
+    "_pickle.PickleBuffer.__eq__" => "Return self==value.",
+    "_pickle.PickleBuffer.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_pickle.PickleBuffer.__ge__" => "Return self>=value.",
+    "_pickle.PickleBuffer.__getattribute__" => "Return getattr(self, name).",
+    "_pickle.PickleBuffer.__getstate__" => "Helper for pickle.",
+    "_pickle.PickleBuffer.__gt__" => "Return self>value.",
+    "_pickle.PickleBuffer.__hash__" => "Return hash(self).",
+    "_pickle.PickleBuffer.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_pickle.PickleBuffer.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_pickle.PickleBuffer.__le__" => "Return self<=value.",
+    "_pickle.PickleBuffer.__lt__" => "Return self<value.",
+    "_pickle.PickleBuffer.__ne__" => "Return self!=value.",
+    "_pickle.PickleBuffer.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_pickle.PickleBuffer.__reduce__" => "Helper for pickle.",
+    "_pickle.PickleBuffer.__reduce_ex__" => "Helper for pickle.",
+    "_pickle.PickleBuffer.__release_buffer__" => "Release the buffer object that exposes the underlying memory of the object.",
+    "_pickle.PickleBuffer.__repr__" => "Return repr(self).",
+    "_pickle.PickleBuffer.__setattr__" => "Implement setattr(self, name, value).",
+    "_pickle.PickleBuffer.__sizeof__" => "Size of object in memory, in bytes.",
+    "_pickle.PickleBuffer.__str__" => "Return str(self).",
+    "_pickle.PickleBuffer.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_pickle.PickleBuffer.raw" => "Return a memoryview of the raw memory underlying this buffer.\nWill raise BufferError is the buffer isn't contiguous.",
+    "_pickle.PickleBuffer.release" => "Release the underlying buffer exposed by the PickleBuffer object.",
     "_pickle.PickleError.__delattr__" => "Implement delattr(self, name).",
     "_pickle.PickleError.__eq__" => "Return self==value.",
     "_pickle.PickleError.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
@@ -2233,9 +6664,9 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "_pickle.PickleError.__str__" => "Return str(self).",
     "_pickle.PickleError.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
     "_pickle.PickleError.__weakref__" => "list of weak references to the object",
-    "_pickle.PickleError.add_note" => "Exception.add_note(note) --\nadd a note to the exception",
-    "_pickle.PickleError.with_traceback" => "Exception.with_traceback(tb) --\nset self.__traceback__ to tb and return self.",
-    "_pickle.Pickler" => "This takes a binary file for writing a pickle data stream.\n\nThe optional *protocol* argument tells the pickler to use the given\nprotocol; supported protocols are 0, 1, 2, 3, 4 and 5.  The default\nprotocol is 4. It was introduced in Python 3.4, and is incompatible\nwith previous versions.\n\nSpecifying a negative protocol version selects the highest protocol\nversion supported.  The higher the protocol used, the more recent the\nversion of Python needed to read the pickle produced.\n\nThe *file* argument must have a write() method that accepts a single\nbytes argument. It can thus be a file object opened for binary\nwriting, an io.BytesIO instance, or any other custom object that meets\nthis interface.\n\nIf *fix_imports* is True and protocol is less than 3, pickle will try\nto map the new Python 3 names to the old module names used in Python\n2, so that the pickle data stream is readable with Python 2.\n\nIf *buffer_callback* is None (the default), buffer views are\nserialized into *file* as part of the pickle stream.\n\nIf *buffer_callback* is not None, then it can be called any number\nof times with a buffer view.  If the callback returns a false value\n(such as None), the given buffer is out-of-band; otherwise the\nbuffer is serialized in-band, i.e. inside the pickle stream.\n\nIt is an error if *buffer_callback* is not None and *protocol*\nis None or smaller than 5.",
+    "_pickle.PickleError.add_note" => "Add a note to the exception",
+    "_pickle.PickleError.with_traceback" => "Set self.__traceback__ to tb and return self.",
+    "_pickle.Pickler" => "This takes a binary file for writing a pickle data stream.\n\nThe optional *protocol* argument tells the pickler to use the given\nprotocol; supported protocols are 0, 1, 2, 3, 4 and 5.  The default\nprotocol is 5. It was introduced in Python 3.8, and is incompatible\nwith previous versions.\n\nSpecifying a negative protocol version selects the highest protocol\nversion supported.  The higher the protocol used, the more recent the\nversion of Python needed to read the pickle produced.\n\nThe *file* argument must have a write() method that accepts a single\nbytes argument. It can thus be a file object opened for binary\nwriting, an io.BytesIO instance, or any other custom object that meets\nthis interface.\n\nIf *fix_imports* is True and protocol is less than 3, pickle will try\nto map the new Python 3 names to the old module names used in Python\n2, so that the pickle data stream is readable with Python 2.\n\nIf *buffer_callback* is None (the default), buffer views are\nserialized into *file* as part of the pickle stream.\n\nIf *buffer_callback* is not None, then it can be called any number\nof times with a buffer view.  If the callback returns a false value\n(such as None), the given buffer is out-of-band; otherwise the\nbuffer is serialized in-band, i.e. inside the pickle stream.\n\nIt is an error if *buffer_callback* is not None and *protocol*\nis None or smaller than 5.",
     "_pickle.Pickler.__delattr__" => "Implement delattr(self, name).",
     "_pickle.Pickler.__eq__" => "Return self==value.",
     "_pickle.Pickler.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
@@ -2259,8 +6690,6 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "_pickle.Pickler.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
     "_pickle.Pickler.clear_memo" => "Clears the pickler's \"memo\".\n\nThe memo is the data structure that remembers which objects the\npickler has already seen, so that shared or recursive objects are\npickled by reference and not by value.  This method is useful when\nre-using picklers.",
     "_pickle.Pickler.dump" => "Write a pickled representation of the given object to the open file.",
-    "_pickle.PicklingError.__cause__" => "exception cause",
-    "_pickle.PicklingError.__context__" => "exception context",
     "_pickle.PicklingError.__delattr__" => "Implement delattr(self, name).",
     "_pickle.PicklingError.__eq__" => "Return self==value.",
     "_pickle.PicklingError.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
@@ -2282,8 +6711,8 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "_pickle.PicklingError.__str__" => "Return str(self).",
     "_pickle.PicklingError.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
     "_pickle.PicklingError.__weakref__" => "list of weak references to the object",
-    "_pickle.PicklingError.add_note" => "Exception.add_note(note) --\nadd a note to the exception",
-    "_pickle.PicklingError.with_traceback" => "Exception.with_traceback(tb) --\nset self.__traceback__ to tb and return self.",
+    "_pickle.PicklingError.add_note" => "Add a note to the exception",
+    "_pickle.PicklingError.with_traceback" => "Set self.__traceback__ to tb and return self.",
     "_pickle.Unpickler" => "This takes a binary file for reading a pickle data stream.\n\nThe protocol version of the pickle is detected automatically, so no\nprotocol argument is needed.  Bytes past the pickled object's\nrepresentation are ignored.\n\nThe argument *file* must have two methods, a read() method that takes\nan integer argument, and a readline() method that requires no\narguments.  Both methods should return bytes.  Thus *file* can be a\nbinary file object opened for reading, an io.BytesIO object, or any\nother custom object that meets this interface.\n\nOptional keyword arguments are *fix_imports*, *encoding* and *errors*,\nwhich are used to control compatibility support for pickle stream\ngenerated by Python 2.  If *fix_imports* is True, pickle will try to\nmap the old Python 2 names to the new names used in Python 3.  The\n*encoding* and *errors* tell pickle how to decode 8-bit string\ninstances pickled by Python 2; these default to 'ASCII' and 'strict',\nrespectively.  The *encoding* can be 'bytes' to read these 8-bit\nstring instances as bytes objects.",
     "_pickle.Unpickler.__delattr__" => "Implement delattr(self, name).",
     "_pickle.Unpickler.__eq__" => "Return self==value.",
@@ -2308,8 +6737,6 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "_pickle.Unpickler.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
     "_pickle.Unpickler.find_class" => "Return an object from a specified module.\n\nIf necessary, the module will be imported. Subclasses may override\nthis method (e.g. to restrict unpickling of arbitrary classes and\nfunctions).\n\nThis method is called whenever a class or a function object is\nneeded.  Both arguments passed are str objects.",
     "_pickle.Unpickler.load" => "Load a pickle.\n\nRead a pickled object representation from the open file object given\nin the constructor, and return the reconstituted object hierarchy\nspecified therein.",
-    "_pickle.UnpicklingError.__cause__" => "exception cause",
-    "_pickle.UnpicklingError.__context__" => "exception context",
     "_pickle.UnpicklingError.__delattr__" => "Implement delattr(self, name).",
     "_pickle.UnpicklingError.__eq__" => "Return self==value.",
     "_pickle.UnpicklingError.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
@@ -2331,10 +6758,10 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "_pickle.UnpicklingError.__str__" => "Return str(self).",
     "_pickle.UnpicklingError.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
     "_pickle.UnpicklingError.__weakref__" => "list of weak references to the object",
-    "_pickle.UnpicklingError.add_note" => "Exception.add_note(note) --\nadd a note to the exception",
-    "_pickle.UnpicklingError.with_traceback" => "Exception.with_traceback(tb) --\nset self.__traceback__ to tb and return self.",
-    "_pickle.dump" => "Write a pickled representation of obj to the open file object file.\n\nThis is equivalent to ``Pickler(file, protocol).dump(obj)``, but may\nbe more efficient.\n\nThe optional *protocol* argument tells the pickler to use the given\nprotocol; supported protocols are 0, 1, 2, 3, 4 and 5.  The default\nprotocol is 4. It was introduced in Python 3.4, and is incompatible\nwith previous versions.\n\nSpecifying a negative protocol version selects the highest protocol\nversion supported.  The higher the protocol used, the more recent the\nversion of Python needed to read the pickle produced.\n\nThe *file* argument must have a write() method that accepts a single\nbytes argument.  It can thus be a file object opened for binary\nwriting, an io.BytesIO instance, or any other custom object that meets\nthis interface.\n\nIf *fix_imports* is True and protocol is less than 3, pickle will try\nto map the new Python 3 names to the old module names used in Python\n2, so that the pickle data stream is readable with Python 2.\n\nIf *buffer_callback* is None (the default), buffer views are serialized\ninto *file* as part of the pickle stream.  It is an error if\n*buffer_callback* is not None and *protocol* is None or smaller than 5.",
-    "_pickle.dumps" => "Return the pickled representation of the object as a bytes object.\n\nThe optional *protocol* argument tells the pickler to use the given\nprotocol; supported protocols are 0, 1, 2, 3, 4 and 5.  The default\nprotocol is 4. It was introduced in Python 3.4, and is incompatible\nwith previous versions.\n\nSpecifying a negative protocol version selects the highest protocol\nversion supported.  The higher the protocol used, the more recent the\nversion of Python needed to read the pickle produced.\n\nIf *fix_imports* is True and *protocol* is less than 3, pickle will\ntry to map the new Python 3 names to the old module names used in\nPython 2, so that the pickle data stream is readable with Python 2.\n\nIf *buffer_callback* is None (the default), buffer views are serialized\ninto *file* as part of the pickle stream.  It is an error if\n*buffer_callback* is not None and *protocol* is None or smaller than 5.",
+    "_pickle.UnpicklingError.add_note" => "Add a note to the exception",
+    "_pickle.UnpicklingError.with_traceback" => "Set self.__traceback__ to tb and return self.",
+    "_pickle.dump" => "Write a pickled representation of obj to the open file object file.\n\nThis is equivalent to ``Pickler(file, protocol).dump(obj)``, but may\nbe more efficient.\n\nThe optional *protocol* argument tells the pickler to use the given\nprotocol; supported protocols are 0, 1, 2, 3, 4 and 5.  The default\nprotocol is 5. It was introduced in Python 3.8, and is incompatible\nwith previous versions.\n\nSpecifying a negative protocol version selects the highest protocol\nversion supported.  The higher the protocol used, the more recent the\nversion of Python needed to read the pickle produced.\n\nThe *file* argument must have a write() method that accepts a single\nbytes argument.  It can thus be a file object opened for binary\nwriting, an io.BytesIO instance, or any other custom object that meets\nthis interface.\n\nIf *fix_imports* is True and protocol is less than 3, pickle will try\nto map the new Python 3 names to the old module names used in Python\n2, so that the pickle data stream is readable with Python 2.\n\nIf *buffer_callback* is None (the default), buffer views are serialized\ninto *file* as part of the pickle stream.  It is an error if\n*buffer_callback* is not None and *protocol* is None or smaller than 5.",
+    "_pickle.dumps" => "Return the pickled representation of the object as a bytes object.\n\nThe optional *protocol* argument tells the pickler to use the given\nprotocol; supported protocols are 0, 1, 2, 3, 4 and 5.  The default\nprotocol is 5. It was introduced in Python 3.8, and is incompatible\nwith previous versions.\n\nSpecifying a negative protocol version selects the highest protocol\nversion supported.  The higher the protocol used, the more recent the\nversion of Python needed to read the pickle produced.\n\nIf *fix_imports* is True and *protocol* is less than 3, pickle will\ntry to map the new Python 3 names to the old module names used in\nPython 2, so that the pickle data stream is readable with Python 2.\n\nIf *buffer_callback* is None (the default), buffer views are serialized\ninto *file* as part of the pickle stream.  It is an error if\n*buffer_callback* is not None and *protocol* is None or smaller than 5.",
     "_pickle.load" => "Read and return an object from the pickle data stored in a file.\n\nThis is equivalent to ``Unpickler(file).load()``, but may be more\nefficient.\n\nThe protocol version of the pickle is detected automatically, so no\nprotocol argument is needed.  Bytes past the pickled object's\nrepresentation are ignored.\n\nThe argument *file* must have two methods, a read() method that takes\nan integer argument, and a readline() method that requires no\narguments.  Both methods should return bytes.  Thus *file* can be a\nbinary file object opened for reading, an io.BytesIO object, or any\nother custom object that meets this interface.\n\nOptional keyword arguments are *fix_imports*, *encoding* and *errors*,\nwhich are used to control compatibility support for pickle stream\ngenerated by Python 2.  If *fix_imports* is True, pickle will try to\nmap the old Python 2 names to the new names used in Python 3.  The\n*encoding* and *errors* tell pickle how to decode 8-bit string\ninstances pickled by Python 2; these default to 'ASCII' and 'strict',\nrespectively.  The *encoding* can be 'bytes' to read these 8-bit\nstring instances as bytes objects.",
     "_pickle.loads" => "Read and return an object from the given pickle data.\n\nThe protocol version of the pickle is detected automatically, so no\nprotocol argument is needed.  Bytes past the pickled object's\nrepresentation are ignored.\n\nOptional keyword arguments are *fix_imports*, *encoding* and *errors*,\nwhich are used to control compatibility support for pickle stream\ngenerated by Python 2.  If *fix_imports* is True, pickle will try to\nmap the old Python 2 names to the new names used in Python 3.  The\n*encoding* and *errors* tell pickle how to decode 8-bit string\ninstances pickled by Python 2; these default to 'ASCII' and 'strict',\nrespectively.  The *encoding* can be 'bytes' to read these 8-bit\nstring instances as bytes objects.",
     "_posixshmem" => "POSIX shared memory module",
@@ -2344,8 +6771,6 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "_posixsubprocess.fork_exec" => "Spawn a fresh new child process.\n\nFork a child process, close parent file descriptors as appropriate in the\nchild and duplicate the few that are needed before calling exec() in the\nchild process.\n\nIf close_fds is True, close file descriptors 3 and higher, except those listed\nin the sorted tuple pass_fds.\n\nThe preexec_fn, if supplied, will be called immediately before closing file\ndescriptors and exec.\n\nWARNING: preexec_fn is NOT SAFE if your application uses threads.\n         It may trigger infrequent, difficult to debug deadlocks.\n\nIf an error occurs in the child process before the exec, it is\nserialized and written to the errpipe_write fd per subprocess.py.\n\nReturns: the child process's PID.\n\nRaises: Only on an error in the parent process.",
     "_queue" => "C implementation of the Python queue module.\nThis module is an implementation detail, please do not use it directly.",
     "_queue.Empty" => "Exception raised by Queue.get(block=0)/get_nowait().",
-    "_queue.Empty.__cause__" => "exception cause",
-    "_queue.Empty.__context__" => "exception context",
     "_queue.Empty.__delattr__" => "Implement delattr(self, name).",
     "_queue.Empty.__eq__" => "Return self==value.",
     "_queue.Empty.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
@@ -2367,8 +6792,8 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "_queue.Empty.__str__" => "Return str(self).",
     "_queue.Empty.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
     "_queue.Empty.__weakref__" => "list of weak references to the object",
-    "_queue.Empty.add_note" => "Exception.add_note(note) --\nadd a note to the exception",
-    "_queue.Empty.with_traceback" => "Exception.with_traceback(tb) --\nset self.__traceback__ to tb and return self.",
+    "_queue.Empty.add_note" => "Add a note to the exception",
+    "_queue.Empty.with_traceback" => "Set self.__traceback__ to tb and return self.",
     "_queue.SimpleQueue" => "Simple, unbounded, reentrant FIFO queue.",
     "_queue.SimpleQueue.__class_getitem__" => "See PEP 585",
     "_queue.SimpleQueue.__delattr__" => "Implement delattr(self, name).",
@@ -2426,6 +6851,204 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "_random.Random.random" => "random() -> x in the interval [0, 1).",
     "_random.Random.seed" => "seed([n]) -> None.\n\nDefaults to use urandom and falls back to a combination\nof the current time and the process identifier.",
     "_random.Random.setstate" => "setstate(state) -> None.  Restores generator state.",
+    "_remote_debugging.AwaitedInfo" => "Information about what a thread is awaiting",
+    "_remote_debugging.AwaitedInfo.__add__" => "Return self+value.",
+    "_remote_debugging.AwaitedInfo.__class_getitem__" => "See PEP 585",
+    "_remote_debugging.AwaitedInfo.__contains__" => "Return bool(key in self).",
+    "_remote_debugging.AwaitedInfo.__delattr__" => "Implement delattr(self, name).",
+    "_remote_debugging.AwaitedInfo.__eq__" => "Return self==value.",
+    "_remote_debugging.AwaitedInfo.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_remote_debugging.AwaitedInfo.__ge__" => "Return self>=value.",
+    "_remote_debugging.AwaitedInfo.__getattribute__" => "Return getattr(self, name).",
+    "_remote_debugging.AwaitedInfo.__getitem__" => "Return self[key].",
+    "_remote_debugging.AwaitedInfo.__getstate__" => "Helper for pickle.",
+    "_remote_debugging.AwaitedInfo.__gt__" => "Return self>value.",
+    "_remote_debugging.AwaitedInfo.__hash__" => "Return hash(self).",
+    "_remote_debugging.AwaitedInfo.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_remote_debugging.AwaitedInfo.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_remote_debugging.AwaitedInfo.__iter__" => "Implement iter(self).",
+    "_remote_debugging.AwaitedInfo.__le__" => "Return self<=value.",
+    "_remote_debugging.AwaitedInfo.__len__" => "Return len(self).",
+    "_remote_debugging.AwaitedInfo.__lt__" => "Return self<value.",
+    "_remote_debugging.AwaitedInfo.__mul__" => "Return self*value.",
+    "_remote_debugging.AwaitedInfo.__ne__" => "Return self!=value.",
+    "_remote_debugging.AwaitedInfo.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_remote_debugging.AwaitedInfo.__reduce_ex__" => "Helper for pickle.",
+    "_remote_debugging.AwaitedInfo.__replace__" => "Return a copy of the structure with new values for the specified fields.",
+    "_remote_debugging.AwaitedInfo.__repr__" => "Return repr(self).",
+    "_remote_debugging.AwaitedInfo.__rmul__" => "Return value*self.",
+    "_remote_debugging.AwaitedInfo.__setattr__" => "Implement setattr(self, name, value).",
+    "_remote_debugging.AwaitedInfo.__sizeof__" => "Size of object in memory, in bytes.",
+    "_remote_debugging.AwaitedInfo.__str__" => "Return str(self).",
+    "_remote_debugging.AwaitedInfo.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_remote_debugging.AwaitedInfo.awaited_by" => "List of tasks awaited by this thread",
+    "_remote_debugging.AwaitedInfo.count" => "Return number of occurrences of value.",
+    "_remote_debugging.AwaitedInfo.index" => "Return first index of value.\n\nRaises ValueError if the value is not present.",
+    "_remote_debugging.AwaitedInfo.thread_id" => "Thread ID",
+    "_remote_debugging.CoroInfo" => "Information about a coroutine",
+    "_remote_debugging.CoroInfo.__add__" => "Return self+value.",
+    "_remote_debugging.CoroInfo.__class_getitem__" => "See PEP 585",
+    "_remote_debugging.CoroInfo.__contains__" => "Return bool(key in self).",
+    "_remote_debugging.CoroInfo.__delattr__" => "Implement delattr(self, name).",
+    "_remote_debugging.CoroInfo.__eq__" => "Return self==value.",
+    "_remote_debugging.CoroInfo.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_remote_debugging.CoroInfo.__ge__" => "Return self>=value.",
+    "_remote_debugging.CoroInfo.__getattribute__" => "Return getattr(self, name).",
+    "_remote_debugging.CoroInfo.__getitem__" => "Return self[key].",
+    "_remote_debugging.CoroInfo.__getstate__" => "Helper for pickle.",
+    "_remote_debugging.CoroInfo.__gt__" => "Return self>value.",
+    "_remote_debugging.CoroInfo.__hash__" => "Return hash(self).",
+    "_remote_debugging.CoroInfo.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_remote_debugging.CoroInfo.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_remote_debugging.CoroInfo.__iter__" => "Implement iter(self).",
+    "_remote_debugging.CoroInfo.__le__" => "Return self<=value.",
+    "_remote_debugging.CoroInfo.__len__" => "Return len(self).",
+    "_remote_debugging.CoroInfo.__lt__" => "Return self<value.",
+    "_remote_debugging.CoroInfo.__mul__" => "Return self*value.",
+    "_remote_debugging.CoroInfo.__ne__" => "Return self!=value.",
+    "_remote_debugging.CoroInfo.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_remote_debugging.CoroInfo.__reduce_ex__" => "Helper for pickle.",
+    "_remote_debugging.CoroInfo.__replace__" => "Return a copy of the structure with new values for the specified fields.",
+    "_remote_debugging.CoroInfo.__repr__" => "Return repr(self).",
+    "_remote_debugging.CoroInfo.__rmul__" => "Return value*self.",
+    "_remote_debugging.CoroInfo.__setattr__" => "Implement setattr(self, name, value).",
+    "_remote_debugging.CoroInfo.__sizeof__" => "Size of object in memory, in bytes.",
+    "_remote_debugging.CoroInfo.__str__" => "Return str(self).",
+    "_remote_debugging.CoroInfo.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_remote_debugging.CoroInfo.call_stack" => "Coroutine call stack",
+    "_remote_debugging.CoroInfo.count" => "Return number of occurrences of value.",
+    "_remote_debugging.CoroInfo.index" => "Return first index of value.\n\nRaises ValueError if the value is not present.",
+    "_remote_debugging.CoroInfo.task_name" => "Task name",
+    "_remote_debugging.FrameInfo" => "Information about a frame",
+    "_remote_debugging.FrameInfo.__add__" => "Return self+value.",
+    "_remote_debugging.FrameInfo.__class_getitem__" => "See PEP 585",
+    "_remote_debugging.FrameInfo.__contains__" => "Return bool(key in self).",
+    "_remote_debugging.FrameInfo.__delattr__" => "Implement delattr(self, name).",
+    "_remote_debugging.FrameInfo.__eq__" => "Return self==value.",
+    "_remote_debugging.FrameInfo.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_remote_debugging.FrameInfo.__ge__" => "Return self>=value.",
+    "_remote_debugging.FrameInfo.__getattribute__" => "Return getattr(self, name).",
+    "_remote_debugging.FrameInfo.__getitem__" => "Return self[key].",
+    "_remote_debugging.FrameInfo.__getstate__" => "Helper for pickle.",
+    "_remote_debugging.FrameInfo.__gt__" => "Return self>value.",
+    "_remote_debugging.FrameInfo.__hash__" => "Return hash(self).",
+    "_remote_debugging.FrameInfo.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_remote_debugging.FrameInfo.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_remote_debugging.FrameInfo.__iter__" => "Implement iter(self).",
+    "_remote_debugging.FrameInfo.__le__" => "Return self<=value.",
+    "_remote_debugging.FrameInfo.__len__" => "Return len(self).",
+    "_remote_debugging.FrameInfo.__lt__" => "Return self<value.",
+    "_remote_debugging.FrameInfo.__mul__" => "Return self*value.",
+    "_remote_debugging.FrameInfo.__ne__" => "Return self!=value.",
+    "_remote_debugging.FrameInfo.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_remote_debugging.FrameInfo.__reduce_ex__" => "Helper for pickle.",
+    "_remote_debugging.FrameInfo.__replace__" => "Return a copy of the structure with new values for the specified fields.",
+    "_remote_debugging.FrameInfo.__repr__" => "Return repr(self).",
+    "_remote_debugging.FrameInfo.__rmul__" => "Return value*self.",
+    "_remote_debugging.FrameInfo.__setattr__" => "Implement setattr(self, name, value).",
+    "_remote_debugging.FrameInfo.__sizeof__" => "Size of object in memory, in bytes.",
+    "_remote_debugging.FrameInfo.__str__" => "Return str(self).",
+    "_remote_debugging.FrameInfo.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_remote_debugging.FrameInfo.count" => "Return number of occurrences of value.",
+    "_remote_debugging.FrameInfo.filename" => "Source code filename",
+    "_remote_debugging.FrameInfo.funcname" => "Function name",
+    "_remote_debugging.FrameInfo.index" => "Return first index of value.\n\nRaises ValueError if the value is not present.",
+    "_remote_debugging.FrameInfo.lineno" => "Line number",
+    "_remote_debugging.RemoteUnwinder" => "RemoteUnwinder(pid): Inspect stack of a remote Python process.",
+    "_remote_debugging.RemoteUnwinder.__delattr__" => "Implement delattr(self, name).",
+    "_remote_debugging.RemoteUnwinder.__eq__" => "Return self==value.",
+    "_remote_debugging.RemoteUnwinder.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_remote_debugging.RemoteUnwinder.__ge__" => "Return self>=value.",
+    "_remote_debugging.RemoteUnwinder.__getattribute__" => "Return getattr(self, name).",
+    "_remote_debugging.RemoteUnwinder.__getstate__" => "Helper for pickle.",
+    "_remote_debugging.RemoteUnwinder.__gt__" => "Return self>value.",
+    "_remote_debugging.RemoteUnwinder.__hash__" => "Return hash(self).",
+    "_remote_debugging.RemoteUnwinder.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_remote_debugging.RemoteUnwinder.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_remote_debugging.RemoteUnwinder.__le__" => "Return self<=value.",
+    "_remote_debugging.RemoteUnwinder.__lt__" => "Return self<value.",
+    "_remote_debugging.RemoteUnwinder.__ne__" => "Return self!=value.",
+    "_remote_debugging.RemoteUnwinder.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_remote_debugging.RemoteUnwinder.__reduce__" => "Helper for pickle.",
+    "_remote_debugging.RemoteUnwinder.__reduce_ex__" => "Helper for pickle.",
+    "_remote_debugging.RemoteUnwinder.__repr__" => "Return repr(self).",
+    "_remote_debugging.RemoteUnwinder.__setattr__" => "Implement setattr(self, name, value).",
+    "_remote_debugging.RemoteUnwinder.__sizeof__" => "Size of object in memory, in bytes.",
+    "_remote_debugging.RemoteUnwinder.__str__" => "Return str(self).",
+    "_remote_debugging.RemoteUnwinder.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_remote_debugging.RemoteUnwinder.get_all_awaited_by" => "Get all tasks and their awaited_by relationships from the remote process.\n\nThis provides a tree structure showing which tasks are waiting for other tasks.\n\nFor each task, returns:\n1. The call stack frames leading to where the task is currently executing\n2. The name of the task\n3. A list of tasks that this task is waiting for, with their own frames/names/etc\n\nReturns a list of [frames, task_name, subtasks] where:\n- frames: List of (func_name, filename, lineno) showing the call stack\n- task_name: String identifier for the task\n- subtasks: List of tasks being awaited by this task, in same format\n\nRaises:\n    RuntimeError: If AsyncioDebug section is not available in the remote process\n    MemoryError: If memory allocation fails\n    OSError: If reading from the remote process fails\n\nExample output:\n[\n    [\n        [(\"c5\", \"script.py\", 10), (\"c4\", \"script.py\", 14)],\n        \"c2_root\",\n        [\n            [\n                [(\"c1\", \"script.py\", 23)],\n                \"sub_main_2\",\n                [...]\n            ],\n            [...]\n        ]\n    ]\n]",
+    "_remote_debugging.RemoteUnwinder.get_async_stack_trace" => "Get the currently running async tasks and their dependency graphs from the remote process.\n\nThis returns information about running tasks and all tasks that are waiting for them,\nforming a complete dependency graph for each thread's active task.\n\nFor each thread with a running task, returns the running task plus all tasks that\ntransitively depend on it (tasks waiting for the running task, tasks waiting for\nthose tasks, etc.).\n\nReturns a list of per-thread results, where each thread result contains:\n- Thread ID\n- List of task information for the running task and all its waiters\n\nEach task info contains:\n- Task ID (memory address)\n- Task name\n- Call stack frames: List of (func_name, filename, lineno)\n- List of tasks waiting for this task (recursive structure)\n\nRaises:\n    RuntimeError: If AsyncioDebug section is not available in the target process\n    MemoryError: If memory allocation fails\n    OSError: If reading from the remote process fails\n\nExample output (similar structure to get_all_awaited_by but only for running tasks):\n[\n    (140234, [\n        (4345585712, 'main_task',\n         [(\"run_server\", \"server.py\", 127), (\"main\", \"app.py\", 23)],\n         [\n             (4345585800, 'worker_1', [...], [...]),\n             (4345585900, 'worker_2', [...], [...])\n         ])\n    ])\n]",
+    "_remote_debugging.RemoteUnwinder.get_stack_trace" => "Returns a list of stack traces for threads in the target process.\n\nEach element in the returned list is a tuple of (thread_id, frame_list), where:\n- thread_id is the OS thread identifier\n- frame_list is a list of tuples (function_name, filename, line_number) representing\n  the Python stack frames for that thread, ordered from most recent to oldest\n\nThe threads returned depend on the initialization parameters:\n- If only_active_thread was True: returns only the thread holding the GIL\n- If all_threads was True: returns all threads\n- Otherwise: returns only the main thread\n\nExample:\n    [\n        (1234, [\n            ('process_data', 'worker.py', 127),\n            ('run_worker', 'worker.py', 45),\n            ('main', 'app.py', 23)\n        ]),\n        (1235, [\n            ('handle_request', 'server.py', 89),\n            ('serve_forever', 'server.py', 52)\n        ])\n    ]\n\nRaises:\n    RuntimeError: If there is an error copying memory from the target process\n    OSError: If there is an error accessing the target process\n    PermissionError: If access to the target process is denied\n    UnicodeDecodeError: If there is an error decoding strings from the target process",
+    "_remote_debugging.TaskInfo" => "Information about an asyncio task",
+    "_remote_debugging.TaskInfo.__add__" => "Return self+value.",
+    "_remote_debugging.TaskInfo.__class_getitem__" => "See PEP 585",
+    "_remote_debugging.TaskInfo.__contains__" => "Return bool(key in self).",
+    "_remote_debugging.TaskInfo.__delattr__" => "Implement delattr(self, name).",
+    "_remote_debugging.TaskInfo.__eq__" => "Return self==value.",
+    "_remote_debugging.TaskInfo.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_remote_debugging.TaskInfo.__ge__" => "Return self>=value.",
+    "_remote_debugging.TaskInfo.__getattribute__" => "Return getattr(self, name).",
+    "_remote_debugging.TaskInfo.__getitem__" => "Return self[key].",
+    "_remote_debugging.TaskInfo.__getstate__" => "Helper for pickle.",
+    "_remote_debugging.TaskInfo.__gt__" => "Return self>value.",
+    "_remote_debugging.TaskInfo.__hash__" => "Return hash(self).",
+    "_remote_debugging.TaskInfo.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_remote_debugging.TaskInfo.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_remote_debugging.TaskInfo.__iter__" => "Implement iter(self).",
+    "_remote_debugging.TaskInfo.__le__" => "Return self<=value.",
+    "_remote_debugging.TaskInfo.__len__" => "Return len(self).",
+    "_remote_debugging.TaskInfo.__lt__" => "Return self<value.",
+    "_remote_debugging.TaskInfo.__mul__" => "Return self*value.",
+    "_remote_debugging.TaskInfo.__ne__" => "Return self!=value.",
+    "_remote_debugging.TaskInfo.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_remote_debugging.TaskInfo.__reduce_ex__" => "Helper for pickle.",
+    "_remote_debugging.TaskInfo.__replace__" => "Return a copy of the structure with new values for the specified fields.",
+    "_remote_debugging.TaskInfo.__repr__" => "Return repr(self).",
+    "_remote_debugging.TaskInfo.__rmul__" => "Return value*self.",
+    "_remote_debugging.TaskInfo.__setattr__" => "Implement setattr(self, name, value).",
+    "_remote_debugging.TaskInfo.__sizeof__" => "Size of object in memory, in bytes.",
+    "_remote_debugging.TaskInfo.__str__" => "Return str(self).",
+    "_remote_debugging.TaskInfo.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_remote_debugging.TaskInfo.awaited_by" => "Tasks awaiting this task",
+    "_remote_debugging.TaskInfo.coroutine_stack" => "Coroutine call stack",
+    "_remote_debugging.TaskInfo.count" => "Return number of occurrences of value.",
+    "_remote_debugging.TaskInfo.index" => "Return first index of value.\n\nRaises ValueError if the value is not present.",
+    "_remote_debugging.TaskInfo.task_id" => "Task ID (memory address)",
+    "_remote_debugging.TaskInfo.task_name" => "Task name",
+    "_remote_debugging.ThreadInfo" => "Information about a thread",
+    "_remote_debugging.ThreadInfo.__add__" => "Return self+value.",
+    "_remote_debugging.ThreadInfo.__class_getitem__" => "See PEP 585",
+    "_remote_debugging.ThreadInfo.__contains__" => "Return bool(key in self).",
+    "_remote_debugging.ThreadInfo.__delattr__" => "Implement delattr(self, name).",
+    "_remote_debugging.ThreadInfo.__eq__" => "Return self==value.",
+    "_remote_debugging.ThreadInfo.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_remote_debugging.ThreadInfo.__ge__" => "Return self>=value.",
+    "_remote_debugging.ThreadInfo.__getattribute__" => "Return getattr(self, name).",
+    "_remote_debugging.ThreadInfo.__getitem__" => "Return self[key].",
+    "_remote_debugging.ThreadInfo.__getstate__" => "Helper for pickle.",
+    "_remote_debugging.ThreadInfo.__gt__" => "Return self>value.",
+    "_remote_debugging.ThreadInfo.__hash__" => "Return hash(self).",
+    "_remote_debugging.ThreadInfo.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_remote_debugging.ThreadInfo.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_remote_debugging.ThreadInfo.__iter__" => "Implement iter(self).",
+    "_remote_debugging.ThreadInfo.__le__" => "Return self<=value.",
+    "_remote_debugging.ThreadInfo.__len__" => "Return len(self).",
+    "_remote_debugging.ThreadInfo.__lt__" => "Return self<value.",
+    "_remote_debugging.ThreadInfo.__mul__" => "Return self*value.",
+    "_remote_debugging.ThreadInfo.__ne__" => "Return self!=value.",
+    "_remote_debugging.ThreadInfo.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_remote_debugging.ThreadInfo.__reduce_ex__" => "Helper for pickle.",
+    "_remote_debugging.ThreadInfo.__replace__" => "Return a copy of the structure with new values for the specified fields.",
+    "_remote_debugging.ThreadInfo.__repr__" => "Return repr(self).",
+    "_remote_debugging.ThreadInfo.__rmul__" => "Return value*self.",
+    "_remote_debugging.ThreadInfo.__setattr__" => "Implement setattr(self, name, value).",
+    "_remote_debugging.ThreadInfo.__sizeof__" => "Size of object in memory, in bytes.",
+    "_remote_debugging.ThreadInfo.__str__" => "Return str(self).",
+    "_remote_debugging.ThreadInfo.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_remote_debugging.ThreadInfo.count" => "Return number of occurrences of value.",
+    "_remote_debugging.ThreadInfo.frame_info" => "Frame information",
+    "_remote_debugging.ThreadInfo.index" => "Return first index of value.\n\nRaises ValueError if the value is not present.",
+    "_remote_debugging.ThreadInfo.thread_id" => "Thread ID",
     "_sha1.SHA1Type.__delattr__" => "Implement delattr(self, name).",
     "_sha1.SHA1Type.__eq__" => "Return self==value.",
     "_sha1.SHA1Type.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
@@ -2713,6 +7336,33 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "_sha3.shake_256.hexdigest" => "Return the digest value as a string of hexadecimal digits.",
     "_sha3.shake_256.update" => "Update this hash object's state with the provided bytes-like object.",
     "_signal" => "This module provides mechanisms to use signal handlers in Python.\n\nFunctions:\n\nalarm() -- cause SIGALRM after a specified time [Unix only]\nsetitimer() -- cause a signal (described below) after a specified\n               float time and the timer may restart then [Unix only]\ngetitimer() -- get current value of timer [Unix only]\nsignal() -- set the action for a given signal\ngetsignal() -- get the signal action for a given signal\npause() -- wait until a signal arrives [Unix only]\ndefault_int_handler() -- default SIGINT handler\n\nsignal constants:\nSIG_DFL -- used to refer to the system default handler\nSIG_IGN -- used to ignore the signal\nNSIG -- number of defined signals\nSIGINT, SIGTERM, etc. -- signal numbers\n\nitimer constants:\nITIMER_REAL -- decrements in real time, and delivers SIGALRM upon\n               expiration\nITIMER_VIRTUAL -- decrements only when the process is executing,\n               and delivers SIGVTALRM upon expiration\nITIMER_PROF -- decrements both when the process is executing and\n               when the system is executing on behalf of the process.\n               Coupled with ITIMER_VIRTUAL, this timer is usually\n               used to profile the time spent by the application\n               in user and kernel space. SIGPROF is delivered upon\n               expiration.\n\n\n*** IMPORTANT NOTICE ***\nA signal handler function is called with two arguments:\nthe first is the signal number, the second is the interrupted stack frame.",
+    "_signal.ItimerError.__delattr__" => "Implement delattr(self, name).",
+    "_signal.ItimerError.__eq__" => "Return self==value.",
+    "_signal.ItimerError.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_signal.ItimerError.__ge__" => "Return self>=value.",
+    "_signal.ItimerError.__getattribute__" => "Return getattr(self, name).",
+    "_signal.ItimerError.__getstate__" => "Helper for pickle.",
+    "_signal.ItimerError.__gt__" => "Return self>value.",
+    "_signal.ItimerError.__hash__" => "Return hash(self).",
+    "_signal.ItimerError.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_signal.ItimerError.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_signal.ItimerError.__le__" => "Return self<=value.",
+    "_signal.ItimerError.__lt__" => "Return self<value.",
+    "_signal.ItimerError.__ne__" => "Return self!=value.",
+    "_signal.ItimerError.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_signal.ItimerError.__reduce_ex__" => "Helper for pickle.",
+    "_signal.ItimerError.__repr__" => "Return repr(self).",
+    "_signal.ItimerError.__setattr__" => "Implement setattr(self, name, value).",
+    "_signal.ItimerError.__sizeof__" => "Size of object in memory, in bytes.",
+    "_signal.ItimerError.__str__" => "Return str(self).",
+    "_signal.ItimerError.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_signal.ItimerError.__weakref__" => "list of weak references to the object",
+    "_signal.ItimerError.add_note" => "Add a note to the exception",
+    "_signal.ItimerError.errno" => "POSIX exception code",
+    "_signal.ItimerError.filename" => "exception filename",
+    "_signal.ItimerError.filename2" => "second exception filename",
+    "_signal.ItimerError.strerror" => "exception strerror",
+    "_signal.ItimerError.with_traceback" => "Set self.__traceback__ to tb and return self.",
     "_signal.alarm" => "Arrange for SIGALRM to arrive after the given number of seconds.",
     "_signal.default_int_handler" => "The default handler for SIGINT installed by Python.\n\nIt raises KeyboardInterrupt.",
     "_signal.getitimer" => "Returns current value of given itimer.",
@@ -2731,6 +7381,45 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "_signal.sigwait" => "Wait for a signal.\n\nSuspend execution of the calling thread until the delivery of one of the\nsignals specified in the signal set sigset.  The function accepts the signal\nand returns the signal number.",
     "_signal.sigwaitinfo" => "Wait synchronously until one of the signals in *sigset* is delivered.\n\nReturns a struct_siginfo containing information about the signal.",
     "_signal.strsignal" => "Return the system description of the given signal.\n\nReturns the description of signal *signalnum*, such as \"Interrupt\"\nfor :const:`SIGINT`. Returns :const:`None` if *signalnum* has no\ndescription. Raises :exc:`ValueError` if *signalnum* is invalid.",
+    "_signal.struct_siginfo" => "struct_siginfo: Result from sigwaitinfo or sigtimedwait.\n\nThis object may be accessed either as a tuple of\n(si_signo, si_code, si_errno, si_pid, si_uid, si_status, si_band),\nor via the attributes si_signo, si_code, and so on.",
+    "_signal.struct_siginfo.__add__" => "Return self+value.",
+    "_signal.struct_siginfo.__class_getitem__" => "See PEP 585",
+    "_signal.struct_siginfo.__contains__" => "Return bool(key in self).",
+    "_signal.struct_siginfo.__delattr__" => "Implement delattr(self, name).",
+    "_signal.struct_siginfo.__eq__" => "Return self==value.",
+    "_signal.struct_siginfo.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_signal.struct_siginfo.__ge__" => "Return self>=value.",
+    "_signal.struct_siginfo.__getattribute__" => "Return getattr(self, name).",
+    "_signal.struct_siginfo.__getitem__" => "Return self[key].",
+    "_signal.struct_siginfo.__getstate__" => "Helper for pickle.",
+    "_signal.struct_siginfo.__gt__" => "Return self>value.",
+    "_signal.struct_siginfo.__hash__" => "Return hash(self).",
+    "_signal.struct_siginfo.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_signal.struct_siginfo.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_signal.struct_siginfo.__iter__" => "Implement iter(self).",
+    "_signal.struct_siginfo.__le__" => "Return self<=value.",
+    "_signal.struct_siginfo.__len__" => "Return len(self).",
+    "_signal.struct_siginfo.__lt__" => "Return self<value.",
+    "_signal.struct_siginfo.__mul__" => "Return self*value.",
+    "_signal.struct_siginfo.__ne__" => "Return self!=value.",
+    "_signal.struct_siginfo.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_signal.struct_siginfo.__reduce_ex__" => "Helper for pickle.",
+    "_signal.struct_siginfo.__replace__" => "Return a copy of the structure with new values for the specified fields.",
+    "_signal.struct_siginfo.__repr__" => "Return repr(self).",
+    "_signal.struct_siginfo.__rmul__" => "Return value*self.",
+    "_signal.struct_siginfo.__setattr__" => "Implement setattr(self, name, value).",
+    "_signal.struct_siginfo.__sizeof__" => "Size of object in memory, in bytes.",
+    "_signal.struct_siginfo.__str__" => "Return str(self).",
+    "_signal.struct_siginfo.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_signal.struct_siginfo.count" => "Return number of occurrences of value.",
+    "_signal.struct_siginfo.index" => "Return first index of value.\n\nRaises ValueError if the value is not present.",
+    "_signal.struct_siginfo.si_band" => "band event for SIGPOLL",
+    "_signal.struct_siginfo.si_code" => "signal code",
+    "_signal.struct_siginfo.si_errno" => "errno associated with this signal",
+    "_signal.struct_siginfo.si_pid" => "sending process ID",
+    "_signal.struct_siginfo.si_signo" => "signal number",
+    "_signal.struct_siginfo.si_status" => "exit value or signal",
+    "_signal.struct_siginfo.si_uid" => "real user ID of sending process",
     "_signal.valid_signals" => "Return a set of valid signal numbers on this platform.\n\nThe signal numbers returned by this function can be safely passed to\nfunctions like `pthread_sigmask`.",
     "_socket" => "Implementation module for socket operations.\n\nSee the socket module for documentation.",
     "_socket.CMSG_LEN" => "CMSG_LEN(length) -> control message length\n\nReturn the total length, without trailing padding, of an ancillary\ndata item with associated data of the given length.  This value can\noften be used as the buffer size for recvmsg() to receive a single\nitem of ancillary data, but RFC 3542 requires portable applications to\nuse CMSG_SPACE() and thus include space for padding, even when the\nitem will be the last in the buffer.  Raises OverflowError if length\nis outside the permissible range of values.",
@@ -2794,6 +7483,34 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "_socket.SocketType.type" => "the socket type",
     "_socket.close" => "close(integer) -> None\n\nClose an integer socket file descriptor.  This is like os.close(), but for\nsockets; on some platforms os.close() won't work for socket file descriptors.",
     "_socket.dup" => "dup(integer) -> integer\n\nDuplicate an integer socket file descriptor.  This is like os.dup(), but for\nsockets; on some platforms os.dup() won't work for socket file descriptors.",
+    "_socket.gaierror.__delattr__" => "Implement delattr(self, name).",
+    "_socket.gaierror.__eq__" => "Return self==value.",
+    "_socket.gaierror.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_socket.gaierror.__ge__" => "Return self>=value.",
+    "_socket.gaierror.__getattribute__" => "Return getattr(self, name).",
+    "_socket.gaierror.__getstate__" => "Helper for pickle.",
+    "_socket.gaierror.__gt__" => "Return self>value.",
+    "_socket.gaierror.__hash__" => "Return hash(self).",
+    "_socket.gaierror.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_socket.gaierror.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_socket.gaierror.__le__" => "Return self<=value.",
+    "_socket.gaierror.__lt__" => "Return self<value.",
+    "_socket.gaierror.__ne__" => "Return self!=value.",
+    "_socket.gaierror.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_socket.gaierror.__reduce_ex__" => "Helper for pickle.",
+    "_socket.gaierror.__repr__" => "Return repr(self).",
+    "_socket.gaierror.__setattr__" => "Implement setattr(self, name, value).",
+    "_socket.gaierror.__sizeof__" => "Size of object in memory, in bytes.",
+    "_socket.gaierror.__str__" => "Return str(self).",
+    "_socket.gaierror.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_socket.gaierror.__weakref__" => "list of weak references to the object",
+    "_socket.gaierror.add_note" => "Add a note to the exception",
+    "_socket.gaierror.errno" => "POSIX exception code",
+    "_socket.gaierror.filename" => "exception filename",
+    "_socket.gaierror.filename2" => "second exception filename",
+    "_socket.gaierror.strerror" => "exception strerror",
+    "_socket.gaierror.winerror" => "Win32 exception code",
+    "_socket.gaierror.with_traceback" => "Set self.__traceback__ to tb and return self.",
     "_socket.getaddrinfo" => "getaddrinfo(host, port [, family, type, proto, flags])\n    -> list of (family, type, proto, canonname, sockaddr)\n\nResolve host and port into addrinfo struct.",
     "_socket.getdefaulttimeout" => "getdefaulttimeout() -> timeout\n\nReturns the default timeout in seconds (float) for new socket objects.\nA value of None indicates that new socket objects have no timeout.\nWhen the socket module is first imported, the default is None.",
     "_socket.gethostbyaddr" => "gethostbyaddr(host) -> (name, aliaslist, addresslist)\n\nReturn the true host name, a list of aliases, and a list of IP addresses,\nfor a host.  The host argument is a string giving a host name or IP number.",
@@ -2804,16 +7521,44 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "_socket.getprotobyname" => "getprotobyname(name) -> integer\n\nReturn the protocol number for the named protocol.  (Rarely used.)",
     "_socket.getservbyname" => "getservbyname(servicename[, protocolname]) -> integer\n\nReturn a port number from a service name and protocol name.\nThe optional protocol name, if given, should be 'tcp' or 'udp',\notherwise any protocol will match.",
     "_socket.getservbyport" => "getservbyport(port[, protocolname]) -> string\n\nReturn the service name from a port number and protocol name.\nThe optional protocol name, if given, should be 'tcp' or 'udp',\notherwise any protocol will match.",
-    "_socket.htonl" => "htonl(integer) -> integer\n\nConvert a 32-bit integer from host to network byte order.",
+    "_socket.herror.__delattr__" => "Implement delattr(self, name).",
+    "_socket.herror.__eq__" => "Return self==value.",
+    "_socket.herror.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_socket.herror.__ge__" => "Return self>=value.",
+    "_socket.herror.__getattribute__" => "Return getattr(self, name).",
+    "_socket.herror.__getstate__" => "Helper for pickle.",
+    "_socket.herror.__gt__" => "Return self>value.",
+    "_socket.herror.__hash__" => "Return hash(self).",
+    "_socket.herror.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_socket.herror.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_socket.herror.__le__" => "Return self<=value.",
+    "_socket.herror.__lt__" => "Return self<value.",
+    "_socket.herror.__ne__" => "Return self!=value.",
+    "_socket.herror.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_socket.herror.__reduce_ex__" => "Helper for pickle.",
+    "_socket.herror.__repr__" => "Return repr(self).",
+    "_socket.herror.__setattr__" => "Implement setattr(self, name, value).",
+    "_socket.herror.__sizeof__" => "Size of object in memory, in bytes.",
+    "_socket.herror.__str__" => "Return str(self).",
+    "_socket.herror.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_socket.herror.__weakref__" => "list of weak references to the object",
+    "_socket.herror.add_note" => "Add a note to the exception",
+    "_socket.herror.errno" => "POSIX exception code",
+    "_socket.herror.filename" => "exception filename",
+    "_socket.herror.filename2" => "second exception filename",
+    "_socket.herror.strerror" => "exception strerror",
+    "_socket.herror.winerror" => "Win32 exception code",
+    "_socket.herror.with_traceback" => "Set self.__traceback__ to tb and return self.",
+    "_socket.htonl" => "Convert a 32-bit unsigned integer from host to network byte order.",
     "_socket.htons" => "Convert a 16-bit unsigned integer from host to network byte order.",
-    "_socket.if_indextoname" => "if_indextoname(if_index)\n\nReturns the interface name corresponding to the interface index if_index.",
+    "_socket.if_indextoname" => "Returns the interface name corresponding to the interface index if_index.",
     "_socket.if_nameindex" => "if_nameindex()\n\nReturns a list of network interface information (index, name) tuples.",
     "_socket.if_nametoindex" => "Returns the interface index corresponding to the interface name if_name.",
     "_socket.inet_aton" => "Convert an IP address in string format (123.45.67.89) to the 32-bit packed binary format used in low-level network functions.",
     "_socket.inet_ntoa" => "Convert an IP address from 32-bit packed binary format to string format.",
     "_socket.inet_ntop" => "inet_ntop(af, packed_ip) -> string formatted IP address\n\nConvert a packed IP address of the given family to string format.",
     "_socket.inet_pton" => "inet_pton(af, ip) -> packed IP address string\n\nConvert an IP address from string format to a packed string suitable\nfor use with low-level network functions.",
-    "_socket.ntohl" => "ntohl(integer) -> integer\n\nConvert a 32-bit integer from network to host byte order.",
+    "_socket.ntohl" => "Convert a 32-bit unsigned integer from network to host byte order.",
     "_socket.ntohs" => "Convert a 16-bit unsigned integer from network to host byte order.",
     "_socket.setdefaulttimeout" => "setdefaulttimeout(timeout)\n\nSet the default timeout in seconds (float) for new socket objects.\nA value of None indicates that new socket objects have no timeout.\nWhen the socket module is first imported, the default is None.",
     "_socket.sethostname" => "sethostname(name)\n\nSets the hostname to name.",
@@ -2875,13 +7620,407 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "_socket.socket.timeout" => "the socket timeout",
     "_socket.socket.type" => "the socket type",
     "_socket.socketpair" => "socketpair([family[, type [, proto]]]) -> (socket object, socket object)\n\nCreate a pair of socket objects from the sockets returned by the platform\nsocketpair() function.\nThe arguments are the same as for socket() except the default family is\nAF_UNIX if defined on the platform; otherwise, the default is AF_INET.",
+    "_sqlite3.Blob.__delattr__" => "Implement delattr(self, name).",
+    "_sqlite3.Blob.__delitem__" => "Delete self[key].",
+    "_sqlite3.Blob.__enter__" => "Blob context manager enter.",
+    "_sqlite3.Blob.__eq__" => "Return self==value.",
+    "_sqlite3.Blob.__exit__" => "Blob context manager exit.",
+    "_sqlite3.Blob.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_sqlite3.Blob.__ge__" => "Return self>=value.",
+    "_sqlite3.Blob.__getattribute__" => "Return getattr(self, name).",
+    "_sqlite3.Blob.__getitem__" => "Return self[key].",
+    "_sqlite3.Blob.__getstate__" => "Helper for pickle.",
+    "_sqlite3.Blob.__gt__" => "Return self>value.",
+    "_sqlite3.Blob.__hash__" => "Return hash(self).",
+    "_sqlite3.Blob.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_sqlite3.Blob.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_sqlite3.Blob.__le__" => "Return self<=value.",
+    "_sqlite3.Blob.__len__" => "Return len(self).",
+    "_sqlite3.Blob.__lt__" => "Return self<value.",
+    "_sqlite3.Blob.__ne__" => "Return self!=value.",
+    "_sqlite3.Blob.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_sqlite3.Blob.__reduce__" => "Helper for pickle.",
+    "_sqlite3.Blob.__reduce_ex__" => "Helper for pickle.",
+    "_sqlite3.Blob.__repr__" => "Return repr(self).",
+    "_sqlite3.Blob.__setattr__" => "Implement setattr(self, name, value).",
+    "_sqlite3.Blob.__setitem__" => "Set self[key] to value.",
+    "_sqlite3.Blob.__sizeof__" => "Size of object in memory, in bytes.",
+    "_sqlite3.Blob.__str__" => "Return str(self).",
+    "_sqlite3.Blob.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_sqlite3.Blob.close" => "Close the blob.",
+    "_sqlite3.Blob.read" => "Read data at the current offset position.\n\n  length\n    Read length in bytes.\n\nIf the end of the blob is reached, the data up to end of file will be returned.\nWhen length is not specified, or is negative, Blob.read() will read until the\nend of the blob.",
+    "_sqlite3.Blob.seek" => "Set the current access position to offset.\n\nThe origin argument defaults to os.SEEK_SET (absolute blob positioning).\nOther values for origin are os.SEEK_CUR (seek relative to the current position)\nand os.SEEK_END (seek relative to the blob's end).",
+    "_sqlite3.Blob.tell" => "Return the current access position for the blob.",
+    "_sqlite3.Blob.write" => "Write data at the current offset.\n\nThis function cannot change the blob length.  Writing beyond the end of the\nblob will result in an exception being raised.",
+    "_sqlite3.Connection" => "SQLite database connection object.",
+    "_sqlite3.Connection.__call__" => "Call self as a function.",
+    "_sqlite3.Connection.__del__" => "Called when the instance is about to be destroyed.",
+    "_sqlite3.Connection.__delattr__" => "Implement delattr(self, name).",
+    "_sqlite3.Connection.__enter__" => "Called when the connection is used as a context manager.\n\nReturns itself as a convenience to the caller.",
+    "_sqlite3.Connection.__eq__" => "Return self==value.",
+    "_sqlite3.Connection.__exit__" => "Called when the connection is used as a context manager.\n\nIf there was any exception, a rollback takes place; otherwise we commit.",
+    "_sqlite3.Connection.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_sqlite3.Connection.__ge__" => "Return self>=value.",
+    "_sqlite3.Connection.__getattribute__" => "Return getattr(self, name).",
+    "_sqlite3.Connection.__getstate__" => "Helper for pickle.",
+    "_sqlite3.Connection.__gt__" => "Return self>value.",
+    "_sqlite3.Connection.__hash__" => "Return hash(self).",
+    "_sqlite3.Connection.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_sqlite3.Connection.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_sqlite3.Connection.__le__" => "Return self<=value.",
+    "_sqlite3.Connection.__lt__" => "Return self<value.",
+    "_sqlite3.Connection.__ne__" => "Return self!=value.",
+    "_sqlite3.Connection.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_sqlite3.Connection.__reduce__" => "Helper for pickle.",
+    "_sqlite3.Connection.__reduce_ex__" => "Helper for pickle.",
+    "_sqlite3.Connection.__repr__" => "Return repr(self).",
+    "_sqlite3.Connection.__setattr__" => "Implement setattr(self, name, value).",
+    "_sqlite3.Connection.__sizeof__" => "Size of object in memory, in bytes.",
+    "_sqlite3.Connection.__str__" => "Return str(self).",
+    "_sqlite3.Connection.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_sqlite3.Connection.backup" => "Makes a backup of the database.",
+    "_sqlite3.Connection.blobopen" => "Open and return a BLOB object.\n\n  table\n    Table name.\n  column\n    Column name.\n  rowid\n    Row id.\n  readonly\n    Open the BLOB without write permissions.\n  name\n    Database name.",
+    "_sqlite3.Connection.close" => "Close the database connection.\n\nAny pending transaction is not committed implicitly.",
+    "_sqlite3.Connection.commit" => "Commit any pending transaction to the database.\n\nIf there is no open transaction, this method is a no-op.",
+    "_sqlite3.Connection.create_aggregate" => "Creates a new aggregate.\n\nNote: Passing keyword arguments 'name', 'n_arg' and 'aggregate_class'\nto _sqlite3.Connection.create_aggregate() is deprecated. Parameters\n'name', 'n_arg' and 'aggregate_class' will become positional-only in\nPython 3.15.",
+    "_sqlite3.Connection.create_collation" => "Creates a collation function.",
+    "_sqlite3.Connection.create_function" => "Creates a new function.\n\nNote: Passing keyword arguments 'name', 'narg' and 'func' to\n_sqlite3.Connection.create_function() is deprecated. Parameters\n'name', 'narg' and 'func' will become positional-only in Python 3.15.",
+    "_sqlite3.Connection.create_window_function" => "Creates or redefines an aggregate window function. Non-standard.\n\n  name\n    The name of the SQL aggregate window function to be created or\n    redefined.\n  num_params\n    The number of arguments the step and inverse methods takes.\n  aggregate_class\n    A class with step(), finalize(), value(), and inverse() methods.\n    Set to None to clear the window function.",
+    "_sqlite3.Connection.cursor" => "Return a cursor for the connection.",
+    "_sqlite3.Connection.deserialize" => "Load a serialized database.\n\n  data\n    The serialized database content.\n  name\n    Which database to reopen with the deserialization.\n\nThe deserialize interface causes the database connection to disconnect from the\ntarget database, and then reopen it as an in-memory database based on the given\nserialized data.\n\nThe deserialize interface will fail with SQLITE_BUSY if the database is\ncurrently in a read transaction or is involved in a backup operation.",
+    "_sqlite3.Connection.enable_load_extension" => "Enable dynamic loading of SQLite extension modules.",
+    "_sqlite3.Connection.execute" => "Executes an SQL statement.",
+    "_sqlite3.Connection.executemany" => "Repeatedly executes an SQL statement.",
+    "_sqlite3.Connection.executescript" => "Executes multiple SQL statements at once.",
+    "_sqlite3.Connection.getconfig" => "Query a boolean connection configuration option.\n\n  op\n    The configuration verb; one of the sqlite3.SQLITE_DBCONFIG codes.",
+    "_sqlite3.Connection.getlimit" => "Get connection run-time limits.\n\n  category\n    The limit category to be queried.",
+    "_sqlite3.Connection.interrupt" => "Abort any pending database operation.",
+    "_sqlite3.Connection.iterdump" => "Returns iterator to the dump of the database in an SQL text format.\n\n  filter\n    An optional LIKE pattern for database objects to dump",
+    "_sqlite3.Connection.load_extension" => "Load SQLite extension module.",
+    "_sqlite3.Connection.rollback" => "Roll back to the start of any pending transaction.\n\nIf there is no open transaction, this method is a no-op.",
+    "_sqlite3.Connection.serialize" => "Serialize a database into a byte string.\n\n  name\n    Which database to serialize.\n\nFor an ordinary on-disk database file, the serialization is just a copy of the\ndisk file. For an in-memory database or a \"temp\" database, the serialization is\nthe same sequence of bytes which would be written to disk if that database\nwere backed up to disk.",
+    "_sqlite3.Connection.set_authorizer" => "Set authorizer callback.\n\nNote: Passing keyword argument 'authorizer_callback' to\n_sqlite3.Connection.set_authorizer() is deprecated. Parameter\n'authorizer_callback' will become positional-only in Python 3.15.",
+    "_sqlite3.Connection.set_progress_handler" => "Set progress handler callback.\n\n  progress_handler\n    A callable that takes no arguments.\n    If the callable returns non-zero, the current query is terminated,\n    and an exception is raised.\n  n\n    The number of SQLite virtual machine instructions that are\n    executed between invocations of 'progress_handler'.\n\nIf 'progress_handler' is None or 'n' is 0, the progress handler is disabled.\n\nNote: Passing keyword argument 'progress_handler' to\n_sqlite3.Connection.set_progress_handler() is deprecated. Parameter\n'progress_handler' will become positional-only in Python 3.15.",
+    "_sqlite3.Connection.set_trace_callback" => "Set a trace callback called for each SQL statement (passed as unicode).\n\nNote: Passing keyword argument 'trace_callback' to\n_sqlite3.Connection.set_trace_callback() is deprecated. Parameter\n'trace_callback' will become positional-only in Python 3.15.",
+    "_sqlite3.Connection.setconfig" => "Set a boolean connection configuration option.\n\n  op\n    The configuration verb; one of the sqlite3.SQLITE_DBCONFIG codes.",
+    "_sqlite3.Connection.setlimit" => "Set connection run-time limits.\n\n  category\n    The limit category to be set.\n  limit\n    The new limit. If the new limit is a negative number, the limit is\n    unchanged.\n\nAttempts to increase a limit above its hard upper bound are silently truncated\nto the hard upper bound. Regardless of whether or not the limit was changed,\nthe prior value of the limit is returned.",
+    "_sqlite3.Cursor" => "SQLite database cursor class.",
+    "_sqlite3.Cursor.__delattr__" => "Implement delattr(self, name).",
+    "_sqlite3.Cursor.__eq__" => "Return self==value.",
+    "_sqlite3.Cursor.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_sqlite3.Cursor.__ge__" => "Return self>=value.",
+    "_sqlite3.Cursor.__getattribute__" => "Return getattr(self, name).",
+    "_sqlite3.Cursor.__getstate__" => "Helper for pickle.",
+    "_sqlite3.Cursor.__gt__" => "Return self>value.",
+    "_sqlite3.Cursor.__hash__" => "Return hash(self).",
+    "_sqlite3.Cursor.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_sqlite3.Cursor.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_sqlite3.Cursor.__iter__" => "Implement iter(self).",
+    "_sqlite3.Cursor.__le__" => "Return self<=value.",
+    "_sqlite3.Cursor.__lt__" => "Return self<value.",
+    "_sqlite3.Cursor.__ne__" => "Return self!=value.",
+    "_sqlite3.Cursor.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_sqlite3.Cursor.__next__" => "Implement next(self).",
+    "_sqlite3.Cursor.__reduce__" => "Helper for pickle.",
+    "_sqlite3.Cursor.__reduce_ex__" => "Helper for pickle.",
+    "_sqlite3.Cursor.__repr__" => "Return repr(self).",
+    "_sqlite3.Cursor.__setattr__" => "Implement setattr(self, name, value).",
+    "_sqlite3.Cursor.__sizeof__" => "Size of object in memory, in bytes.",
+    "_sqlite3.Cursor.__str__" => "Return str(self).",
+    "_sqlite3.Cursor.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_sqlite3.Cursor.close" => "Closes the cursor.",
+    "_sqlite3.Cursor.execute" => "Executes an SQL statement.",
+    "_sqlite3.Cursor.executemany" => "Repeatedly executes an SQL statement.",
+    "_sqlite3.Cursor.executescript" => "Executes multiple SQL statements at once.",
+    "_sqlite3.Cursor.fetchall" => "Fetches all rows from the resultset.",
+    "_sqlite3.Cursor.fetchmany" => "Fetches several rows from the resultset.\n\n  size\n    The default value is set by the Cursor.arraysize attribute.",
+    "_sqlite3.Cursor.fetchone" => "Fetches one row from the resultset.",
+    "_sqlite3.Cursor.setinputsizes" => "Required by DB-API. Does nothing in sqlite3.",
+    "_sqlite3.Cursor.setoutputsize" => "Required by DB-API. Does nothing in sqlite3.",
+    "_sqlite3.DataError.__delattr__" => "Implement delattr(self, name).",
+    "_sqlite3.DataError.__eq__" => "Return self==value.",
+    "_sqlite3.DataError.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_sqlite3.DataError.__ge__" => "Return self>=value.",
+    "_sqlite3.DataError.__getattribute__" => "Return getattr(self, name).",
+    "_sqlite3.DataError.__getstate__" => "Helper for pickle.",
+    "_sqlite3.DataError.__gt__" => "Return self>value.",
+    "_sqlite3.DataError.__hash__" => "Return hash(self).",
+    "_sqlite3.DataError.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_sqlite3.DataError.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_sqlite3.DataError.__le__" => "Return self<=value.",
+    "_sqlite3.DataError.__lt__" => "Return self<value.",
+    "_sqlite3.DataError.__ne__" => "Return self!=value.",
+    "_sqlite3.DataError.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_sqlite3.DataError.__reduce_ex__" => "Helper for pickle.",
+    "_sqlite3.DataError.__repr__" => "Return repr(self).",
+    "_sqlite3.DataError.__setattr__" => "Implement setattr(self, name, value).",
+    "_sqlite3.DataError.__sizeof__" => "Size of object in memory, in bytes.",
+    "_sqlite3.DataError.__str__" => "Return str(self).",
+    "_sqlite3.DataError.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_sqlite3.DataError.__weakref__" => "list of weak references to the object",
+    "_sqlite3.DataError.add_note" => "Add a note to the exception",
+    "_sqlite3.DataError.with_traceback" => "Set self.__traceback__ to tb and return self.",
+    "_sqlite3.DatabaseError.__delattr__" => "Implement delattr(self, name).",
+    "_sqlite3.DatabaseError.__eq__" => "Return self==value.",
+    "_sqlite3.DatabaseError.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_sqlite3.DatabaseError.__ge__" => "Return self>=value.",
+    "_sqlite3.DatabaseError.__getattribute__" => "Return getattr(self, name).",
+    "_sqlite3.DatabaseError.__getstate__" => "Helper for pickle.",
+    "_sqlite3.DatabaseError.__gt__" => "Return self>value.",
+    "_sqlite3.DatabaseError.__hash__" => "Return hash(self).",
+    "_sqlite3.DatabaseError.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_sqlite3.DatabaseError.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_sqlite3.DatabaseError.__le__" => "Return self<=value.",
+    "_sqlite3.DatabaseError.__lt__" => "Return self<value.",
+    "_sqlite3.DatabaseError.__ne__" => "Return self!=value.",
+    "_sqlite3.DatabaseError.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_sqlite3.DatabaseError.__reduce_ex__" => "Helper for pickle.",
+    "_sqlite3.DatabaseError.__repr__" => "Return repr(self).",
+    "_sqlite3.DatabaseError.__setattr__" => "Implement setattr(self, name, value).",
+    "_sqlite3.DatabaseError.__sizeof__" => "Size of object in memory, in bytes.",
+    "_sqlite3.DatabaseError.__str__" => "Return str(self).",
+    "_sqlite3.DatabaseError.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_sqlite3.DatabaseError.__weakref__" => "list of weak references to the object",
+    "_sqlite3.DatabaseError.add_note" => "Add a note to the exception",
+    "_sqlite3.DatabaseError.with_traceback" => "Set self.__traceback__ to tb and return self.",
+    "_sqlite3.Error.__delattr__" => "Implement delattr(self, name).",
+    "_sqlite3.Error.__eq__" => "Return self==value.",
+    "_sqlite3.Error.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_sqlite3.Error.__ge__" => "Return self>=value.",
+    "_sqlite3.Error.__getattribute__" => "Return getattr(self, name).",
+    "_sqlite3.Error.__getstate__" => "Helper for pickle.",
+    "_sqlite3.Error.__gt__" => "Return self>value.",
+    "_sqlite3.Error.__hash__" => "Return hash(self).",
+    "_sqlite3.Error.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_sqlite3.Error.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_sqlite3.Error.__le__" => "Return self<=value.",
+    "_sqlite3.Error.__lt__" => "Return self<value.",
+    "_sqlite3.Error.__ne__" => "Return self!=value.",
+    "_sqlite3.Error.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_sqlite3.Error.__reduce_ex__" => "Helper for pickle.",
+    "_sqlite3.Error.__repr__" => "Return repr(self).",
+    "_sqlite3.Error.__setattr__" => "Implement setattr(self, name, value).",
+    "_sqlite3.Error.__sizeof__" => "Size of object in memory, in bytes.",
+    "_sqlite3.Error.__str__" => "Return str(self).",
+    "_sqlite3.Error.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_sqlite3.Error.__weakref__" => "list of weak references to the object",
+    "_sqlite3.Error.add_note" => "Add a note to the exception",
+    "_sqlite3.Error.with_traceback" => "Set self.__traceback__ to tb and return self.",
+    "_sqlite3.IntegrityError.__delattr__" => "Implement delattr(self, name).",
+    "_sqlite3.IntegrityError.__eq__" => "Return self==value.",
+    "_sqlite3.IntegrityError.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_sqlite3.IntegrityError.__ge__" => "Return self>=value.",
+    "_sqlite3.IntegrityError.__getattribute__" => "Return getattr(self, name).",
+    "_sqlite3.IntegrityError.__getstate__" => "Helper for pickle.",
+    "_sqlite3.IntegrityError.__gt__" => "Return self>value.",
+    "_sqlite3.IntegrityError.__hash__" => "Return hash(self).",
+    "_sqlite3.IntegrityError.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_sqlite3.IntegrityError.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_sqlite3.IntegrityError.__le__" => "Return self<=value.",
+    "_sqlite3.IntegrityError.__lt__" => "Return self<value.",
+    "_sqlite3.IntegrityError.__ne__" => "Return self!=value.",
+    "_sqlite3.IntegrityError.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_sqlite3.IntegrityError.__reduce_ex__" => "Helper for pickle.",
+    "_sqlite3.IntegrityError.__repr__" => "Return repr(self).",
+    "_sqlite3.IntegrityError.__setattr__" => "Implement setattr(self, name, value).",
+    "_sqlite3.IntegrityError.__sizeof__" => "Size of object in memory, in bytes.",
+    "_sqlite3.IntegrityError.__str__" => "Return str(self).",
+    "_sqlite3.IntegrityError.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_sqlite3.IntegrityError.__weakref__" => "list of weak references to the object",
+    "_sqlite3.IntegrityError.add_note" => "Add a note to the exception",
+    "_sqlite3.IntegrityError.with_traceback" => "Set self.__traceback__ to tb and return self.",
+    "_sqlite3.InterfaceError.__delattr__" => "Implement delattr(self, name).",
+    "_sqlite3.InterfaceError.__eq__" => "Return self==value.",
+    "_sqlite3.InterfaceError.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_sqlite3.InterfaceError.__ge__" => "Return self>=value.",
+    "_sqlite3.InterfaceError.__getattribute__" => "Return getattr(self, name).",
+    "_sqlite3.InterfaceError.__getstate__" => "Helper for pickle.",
+    "_sqlite3.InterfaceError.__gt__" => "Return self>value.",
+    "_sqlite3.InterfaceError.__hash__" => "Return hash(self).",
+    "_sqlite3.InterfaceError.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_sqlite3.InterfaceError.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_sqlite3.InterfaceError.__le__" => "Return self<=value.",
+    "_sqlite3.InterfaceError.__lt__" => "Return self<value.",
+    "_sqlite3.InterfaceError.__ne__" => "Return self!=value.",
+    "_sqlite3.InterfaceError.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_sqlite3.InterfaceError.__reduce_ex__" => "Helper for pickle.",
+    "_sqlite3.InterfaceError.__repr__" => "Return repr(self).",
+    "_sqlite3.InterfaceError.__setattr__" => "Implement setattr(self, name, value).",
+    "_sqlite3.InterfaceError.__sizeof__" => "Size of object in memory, in bytes.",
+    "_sqlite3.InterfaceError.__str__" => "Return str(self).",
+    "_sqlite3.InterfaceError.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_sqlite3.InterfaceError.__weakref__" => "list of weak references to the object",
+    "_sqlite3.InterfaceError.add_note" => "Add a note to the exception",
+    "_sqlite3.InterfaceError.with_traceback" => "Set self.__traceback__ to tb and return self.",
+    "_sqlite3.InternalError.__delattr__" => "Implement delattr(self, name).",
+    "_sqlite3.InternalError.__eq__" => "Return self==value.",
+    "_sqlite3.InternalError.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_sqlite3.InternalError.__ge__" => "Return self>=value.",
+    "_sqlite3.InternalError.__getattribute__" => "Return getattr(self, name).",
+    "_sqlite3.InternalError.__getstate__" => "Helper for pickle.",
+    "_sqlite3.InternalError.__gt__" => "Return self>value.",
+    "_sqlite3.InternalError.__hash__" => "Return hash(self).",
+    "_sqlite3.InternalError.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_sqlite3.InternalError.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_sqlite3.InternalError.__le__" => "Return self<=value.",
+    "_sqlite3.InternalError.__lt__" => "Return self<value.",
+    "_sqlite3.InternalError.__ne__" => "Return self!=value.",
+    "_sqlite3.InternalError.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_sqlite3.InternalError.__reduce_ex__" => "Helper for pickle.",
+    "_sqlite3.InternalError.__repr__" => "Return repr(self).",
+    "_sqlite3.InternalError.__setattr__" => "Implement setattr(self, name, value).",
+    "_sqlite3.InternalError.__sizeof__" => "Size of object in memory, in bytes.",
+    "_sqlite3.InternalError.__str__" => "Return str(self).",
+    "_sqlite3.InternalError.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_sqlite3.InternalError.__weakref__" => "list of weak references to the object",
+    "_sqlite3.InternalError.add_note" => "Add a note to the exception",
+    "_sqlite3.InternalError.with_traceback" => "Set self.__traceback__ to tb and return self.",
+    "_sqlite3.NotSupportedError.__delattr__" => "Implement delattr(self, name).",
+    "_sqlite3.NotSupportedError.__eq__" => "Return self==value.",
+    "_sqlite3.NotSupportedError.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_sqlite3.NotSupportedError.__ge__" => "Return self>=value.",
+    "_sqlite3.NotSupportedError.__getattribute__" => "Return getattr(self, name).",
+    "_sqlite3.NotSupportedError.__getstate__" => "Helper for pickle.",
+    "_sqlite3.NotSupportedError.__gt__" => "Return self>value.",
+    "_sqlite3.NotSupportedError.__hash__" => "Return hash(self).",
+    "_sqlite3.NotSupportedError.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_sqlite3.NotSupportedError.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_sqlite3.NotSupportedError.__le__" => "Return self<=value.",
+    "_sqlite3.NotSupportedError.__lt__" => "Return self<value.",
+    "_sqlite3.NotSupportedError.__ne__" => "Return self!=value.",
+    "_sqlite3.NotSupportedError.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_sqlite3.NotSupportedError.__reduce_ex__" => "Helper for pickle.",
+    "_sqlite3.NotSupportedError.__repr__" => "Return repr(self).",
+    "_sqlite3.NotSupportedError.__setattr__" => "Implement setattr(self, name, value).",
+    "_sqlite3.NotSupportedError.__sizeof__" => "Size of object in memory, in bytes.",
+    "_sqlite3.NotSupportedError.__str__" => "Return str(self).",
+    "_sqlite3.NotSupportedError.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_sqlite3.NotSupportedError.__weakref__" => "list of weak references to the object",
+    "_sqlite3.NotSupportedError.add_note" => "Add a note to the exception",
+    "_sqlite3.NotSupportedError.with_traceback" => "Set self.__traceback__ to tb and return self.",
+    "_sqlite3.OperationalError.__delattr__" => "Implement delattr(self, name).",
+    "_sqlite3.OperationalError.__eq__" => "Return self==value.",
+    "_sqlite3.OperationalError.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_sqlite3.OperationalError.__ge__" => "Return self>=value.",
+    "_sqlite3.OperationalError.__getattribute__" => "Return getattr(self, name).",
+    "_sqlite3.OperationalError.__getstate__" => "Helper for pickle.",
+    "_sqlite3.OperationalError.__gt__" => "Return self>value.",
+    "_sqlite3.OperationalError.__hash__" => "Return hash(self).",
+    "_sqlite3.OperationalError.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_sqlite3.OperationalError.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_sqlite3.OperationalError.__le__" => "Return self<=value.",
+    "_sqlite3.OperationalError.__lt__" => "Return self<value.",
+    "_sqlite3.OperationalError.__ne__" => "Return self!=value.",
+    "_sqlite3.OperationalError.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_sqlite3.OperationalError.__reduce_ex__" => "Helper for pickle.",
+    "_sqlite3.OperationalError.__repr__" => "Return repr(self).",
+    "_sqlite3.OperationalError.__setattr__" => "Implement setattr(self, name, value).",
+    "_sqlite3.OperationalError.__sizeof__" => "Size of object in memory, in bytes.",
+    "_sqlite3.OperationalError.__str__" => "Return str(self).",
+    "_sqlite3.OperationalError.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_sqlite3.OperationalError.__weakref__" => "list of weak references to the object",
+    "_sqlite3.OperationalError.add_note" => "Add a note to the exception",
+    "_sqlite3.OperationalError.with_traceback" => "Set self.__traceback__ to tb and return self.",
+    "_sqlite3.PrepareProtocol" => "PEP 246 style object adaption protocol type.",
+    "_sqlite3.PrepareProtocol.__delattr__" => "Implement delattr(self, name).",
+    "_sqlite3.PrepareProtocol.__eq__" => "Return self==value.",
+    "_sqlite3.PrepareProtocol.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_sqlite3.PrepareProtocol.__ge__" => "Return self>=value.",
+    "_sqlite3.PrepareProtocol.__getattribute__" => "Return getattr(self, name).",
+    "_sqlite3.PrepareProtocol.__getstate__" => "Helper for pickle.",
+    "_sqlite3.PrepareProtocol.__gt__" => "Return self>value.",
+    "_sqlite3.PrepareProtocol.__hash__" => "Return hash(self).",
+    "_sqlite3.PrepareProtocol.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_sqlite3.PrepareProtocol.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_sqlite3.PrepareProtocol.__le__" => "Return self<=value.",
+    "_sqlite3.PrepareProtocol.__lt__" => "Return self<value.",
+    "_sqlite3.PrepareProtocol.__ne__" => "Return self!=value.",
+    "_sqlite3.PrepareProtocol.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_sqlite3.PrepareProtocol.__reduce__" => "Helper for pickle.",
+    "_sqlite3.PrepareProtocol.__reduce_ex__" => "Helper for pickle.",
+    "_sqlite3.PrepareProtocol.__repr__" => "Return repr(self).",
+    "_sqlite3.PrepareProtocol.__setattr__" => "Implement setattr(self, name, value).",
+    "_sqlite3.PrepareProtocol.__sizeof__" => "Size of object in memory, in bytes.",
+    "_sqlite3.PrepareProtocol.__str__" => "Return str(self).",
+    "_sqlite3.PrepareProtocol.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_sqlite3.ProgrammingError.__delattr__" => "Implement delattr(self, name).",
+    "_sqlite3.ProgrammingError.__eq__" => "Return self==value.",
+    "_sqlite3.ProgrammingError.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_sqlite3.ProgrammingError.__ge__" => "Return self>=value.",
+    "_sqlite3.ProgrammingError.__getattribute__" => "Return getattr(self, name).",
+    "_sqlite3.ProgrammingError.__getstate__" => "Helper for pickle.",
+    "_sqlite3.ProgrammingError.__gt__" => "Return self>value.",
+    "_sqlite3.ProgrammingError.__hash__" => "Return hash(self).",
+    "_sqlite3.ProgrammingError.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_sqlite3.ProgrammingError.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_sqlite3.ProgrammingError.__le__" => "Return self<=value.",
+    "_sqlite3.ProgrammingError.__lt__" => "Return self<value.",
+    "_sqlite3.ProgrammingError.__ne__" => "Return self!=value.",
+    "_sqlite3.ProgrammingError.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_sqlite3.ProgrammingError.__reduce_ex__" => "Helper for pickle.",
+    "_sqlite3.ProgrammingError.__repr__" => "Return repr(self).",
+    "_sqlite3.ProgrammingError.__setattr__" => "Implement setattr(self, name, value).",
+    "_sqlite3.ProgrammingError.__sizeof__" => "Size of object in memory, in bytes.",
+    "_sqlite3.ProgrammingError.__str__" => "Return str(self).",
+    "_sqlite3.ProgrammingError.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_sqlite3.ProgrammingError.__weakref__" => "list of weak references to the object",
+    "_sqlite3.ProgrammingError.add_note" => "Add a note to the exception",
+    "_sqlite3.ProgrammingError.with_traceback" => "Set self.__traceback__ to tb and return self.",
+    "_sqlite3.Row.__delattr__" => "Implement delattr(self, name).",
+    "_sqlite3.Row.__eq__" => "Return self==value.",
+    "_sqlite3.Row.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_sqlite3.Row.__ge__" => "Return self>=value.",
+    "_sqlite3.Row.__getattribute__" => "Return getattr(self, name).",
+    "_sqlite3.Row.__getitem__" => "Return self[key].",
+    "_sqlite3.Row.__getstate__" => "Helper for pickle.",
+    "_sqlite3.Row.__gt__" => "Return self>value.",
+    "_sqlite3.Row.__hash__" => "Return hash(self).",
+    "_sqlite3.Row.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_sqlite3.Row.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_sqlite3.Row.__iter__" => "Implement iter(self).",
+    "_sqlite3.Row.__le__" => "Return self<=value.",
+    "_sqlite3.Row.__len__" => "Return len(self).",
+    "_sqlite3.Row.__lt__" => "Return self<value.",
+    "_sqlite3.Row.__ne__" => "Return self!=value.",
+    "_sqlite3.Row.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_sqlite3.Row.__reduce__" => "Helper for pickle.",
+    "_sqlite3.Row.__reduce_ex__" => "Helper for pickle.",
+    "_sqlite3.Row.__repr__" => "Return repr(self).",
+    "_sqlite3.Row.__setattr__" => "Implement setattr(self, name, value).",
+    "_sqlite3.Row.__sizeof__" => "Size of object in memory, in bytes.",
+    "_sqlite3.Row.__str__" => "Return str(self).",
+    "_sqlite3.Row.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_sqlite3.Row.keys" => "Returns the keys of the row.",
+    "_sqlite3.Warning.__delattr__" => "Implement delattr(self, name).",
+    "_sqlite3.Warning.__eq__" => "Return self==value.",
+    "_sqlite3.Warning.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_sqlite3.Warning.__ge__" => "Return self>=value.",
+    "_sqlite3.Warning.__getattribute__" => "Return getattr(self, name).",
+    "_sqlite3.Warning.__getstate__" => "Helper for pickle.",
+    "_sqlite3.Warning.__gt__" => "Return self>value.",
+    "_sqlite3.Warning.__hash__" => "Return hash(self).",
+    "_sqlite3.Warning.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_sqlite3.Warning.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_sqlite3.Warning.__le__" => "Return self<=value.",
+    "_sqlite3.Warning.__lt__" => "Return self<value.",
+    "_sqlite3.Warning.__ne__" => "Return self!=value.",
+    "_sqlite3.Warning.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_sqlite3.Warning.__reduce_ex__" => "Helper for pickle.",
+    "_sqlite3.Warning.__repr__" => "Return repr(self).",
+    "_sqlite3.Warning.__setattr__" => "Implement setattr(self, name, value).",
+    "_sqlite3.Warning.__sizeof__" => "Size of object in memory, in bytes.",
+    "_sqlite3.Warning.__str__" => "Return str(self).",
+    "_sqlite3.Warning.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_sqlite3.Warning.__weakref__" => "list of weak references to the object",
+    "_sqlite3.Warning.add_note" => "Add a note to the exception",
+    "_sqlite3.Warning.with_traceback" => "Set self.__traceback__ to tb and return self.",
     "_sqlite3.adapt" => "Adapt given object to given protocol.",
     "_sqlite3.complete_statement" => "Checks if a string contains a complete SQL statement.",
     "_sqlite3.connect" => "Open a connection to the SQLite database file 'database'.\n\nYou can use \":memory:\" to open a database connection to a database that\nresides in RAM instead of on disk.\n\nNote: Passing more than 1 positional argument to _sqlite3.connect() is\ndeprecated. Parameters 'timeout', 'detect_types', 'isolation_level',\n'check_same_thread', 'factory', 'cached_statements' and 'uri' will\nbecome keyword-only parameters in Python 3.15.",
     "_sqlite3.enable_callback_tracebacks" => "Enable or disable callback functions throwing errors to stderr.",
     "_sqlite3.register_adapter" => "Register a function to adapt Python objects to SQLite values.",
     "_sqlite3.register_converter" => "Register a function to convert SQLite values to Python objects.",
-    "_sre.template" => "template\n  A list containing interleaved literal strings (str or bytes) and group\n  indices (int), as returned by re._parser.parse_template():\n      [literal1, group1, ..., literalN, groupN]",
+    "_sre.template" => "template\n    A list containing interleaved literal strings (str or bytes) and group\n    indices (int), as returned by re._parser.parse_template():\n        [literal1, group1, ..., literalN, groupN]",
     "_ssl" => "Implementation module for SSL socket operations.  See the socket module\nfor documentation.",
     "_ssl.Certificate.__delattr__" => "Implement delattr(self, name).",
     "_ssl.Certificate.__eq__" => "Return self==value.",
@@ -2933,6 +8072,92 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "_ssl.RAND_add" => "Mix string into the OpenSSL PRNG state.\n\nentropy (a float) is a lower bound on the entropy contained in\nstring.  See RFC 4086.",
     "_ssl.RAND_bytes" => "Generate n cryptographically strong pseudo-random bytes.",
     "_ssl.RAND_status" => "Returns True if the OpenSSL PRNG has been seeded with enough data and False if not.\n\nIt is necessary to seed the PRNG with RAND_add() on some platforms before\nusing the ssl() function.",
+    "_ssl.SSLCertVerificationError" => "A certificate could not be verified.",
+    "_ssl.SSLCertVerificationError.__delattr__" => "Implement delattr(self, name).",
+    "_ssl.SSLCertVerificationError.__eq__" => "Return self==value.",
+    "_ssl.SSLCertVerificationError.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_ssl.SSLCertVerificationError.__ge__" => "Return self>=value.",
+    "_ssl.SSLCertVerificationError.__getattribute__" => "Return getattr(self, name).",
+    "_ssl.SSLCertVerificationError.__getstate__" => "Helper for pickle.",
+    "_ssl.SSLCertVerificationError.__gt__" => "Return self>value.",
+    "_ssl.SSLCertVerificationError.__hash__" => "Return hash(self).",
+    "_ssl.SSLCertVerificationError.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_ssl.SSLCertVerificationError.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_ssl.SSLCertVerificationError.__le__" => "Return self<=value.",
+    "_ssl.SSLCertVerificationError.__lt__" => "Return self<value.",
+    "_ssl.SSLCertVerificationError.__ne__" => "Return self!=value.",
+    "_ssl.SSLCertVerificationError.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_ssl.SSLCertVerificationError.__reduce_ex__" => "Helper for pickle.",
+    "_ssl.SSLCertVerificationError.__repr__" => "Return repr(self).",
+    "_ssl.SSLCertVerificationError.__setattr__" => "Implement setattr(self, name, value).",
+    "_ssl.SSLCertVerificationError.__sizeof__" => "Size of object in memory, in bytes.",
+    "_ssl.SSLCertVerificationError.__str__" => "Return str(self).",
+    "_ssl.SSLCertVerificationError.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_ssl.SSLCertVerificationError.__weakref__" => "list of weak references to the object",
+    "_ssl.SSLCertVerificationError.add_note" => "Add a note to the exception",
+    "_ssl.SSLCertVerificationError.errno" => "POSIX exception code",
+    "_ssl.SSLCertVerificationError.filename" => "exception filename",
+    "_ssl.SSLCertVerificationError.filename2" => "second exception filename",
+    "_ssl.SSLCertVerificationError.strerror" => "exception strerror",
+    "_ssl.SSLCertVerificationError.winerror" => "Win32 exception code",
+    "_ssl.SSLCertVerificationError.with_traceback" => "Set self.__traceback__ to tb and return self.",
+    "_ssl.SSLEOFError" => "SSL/TLS connection terminated abruptly.",
+    "_ssl.SSLEOFError.__delattr__" => "Implement delattr(self, name).",
+    "_ssl.SSLEOFError.__eq__" => "Return self==value.",
+    "_ssl.SSLEOFError.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_ssl.SSLEOFError.__ge__" => "Return self>=value.",
+    "_ssl.SSLEOFError.__getattribute__" => "Return getattr(self, name).",
+    "_ssl.SSLEOFError.__getstate__" => "Helper for pickle.",
+    "_ssl.SSLEOFError.__gt__" => "Return self>value.",
+    "_ssl.SSLEOFError.__hash__" => "Return hash(self).",
+    "_ssl.SSLEOFError.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_ssl.SSLEOFError.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_ssl.SSLEOFError.__le__" => "Return self<=value.",
+    "_ssl.SSLEOFError.__lt__" => "Return self<value.",
+    "_ssl.SSLEOFError.__ne__" => "Return self!=value.",
+    "_ssl.SSLEOFError.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_ssl.SSLEOFError.__reduce_ex__" => "Helper for pickle.",
+    "_ssl.SSLEOFError.__repr__" => "Return repr(self).",
+    "_ssl.SSLEOFError.__setattr__" => "Implement setattr(self, name, value).",
+    "_ssl.SSLEOFError.__sizeof__" => "Size of object in memory, in bytes.",
+    "_ssl.SSLEOFError.__str__" => "Return str(self).",
+    "_ssl.SSLEOFError.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_ssl.SSLEOFError.__weakref__" => "list of weak references to the object",
+    "_ssl.SSLEOFError.add_note" => "Add a note to the exception",
+    "_ssl.SSLEOFError.errno" => "POSIX exception code",
+    "_ssl.SSLEOFError.filename" => "exception filename",
+    "_ssl.SSLEOFError.filename2" => "second exception filename",
+    "_ssl.SSLEOFError.strerror" => "exception strerror",
+    "_ssl.SSLEOFError.winerror" => "Win32 exception code",
+    "_ssl.SSLEOFError.with_traceback" => "Set self.__traceback__ to tb and return self.",
+    "_ssl.SSLError" => "An error occurred in the SSL implementation.",
+    "_ssl.SSLError.__delattr__" => "Implement delattr(self, name).",
+    "_ssl.SSLError.__eq__" => "Return self==value.",
+    "_ssl.SSLError.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_ssl.SSLError.__ge__" => "Return self>=value.",
+    "_ssl.SSLError.__getattribute__" => "Return getattr(self, name).",
+    "_ssl.SSLError.__getstate__" => "Helper for pickle.",
+    "_ssl.SSLError.__gt__" => "Return self>value.",
+    "_ssl.SSLError.__hash__" => "Return hash(self).",
+    "_ssl.SSLError.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_ssl.SSLError.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_ssl.SSLError.__le__" => "Return self<=value.",
+    "_ssl.SSLError.__lt__" => "Return self<value.",
+    "_ssl.SSLError.__ne__" => "Return self!=value.",
+    "_ssl.SSLError.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_ssl.SSLError.__reduce_ex__" => "Helper for pickle.",
+    "_ssl.SSLError.__repr__" => "Return repr(self).",
+    "_ssl.SSLError.__setattr__" => "Implement setattr(self, name, value).",
+    "_ssl.SSLError.__sizeof__" => "Size of object in memory, in bytes.",
+    "_ssl.SSLError.__str__" => "Return str(self).",
+    "_ssl.SSLError.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_ssl.SSLError.add_note" => "Add a note to the exception",
+    "_ssl.SSLError.errno" => "POSIX exception code",
+    "_ssl.SSLError.filename" => "exception filename",
+    "_ssl.SSLError.filename2" => "second exception filename",
+    "_ssl.SSLError.strerror" => "exception strerror",
+    "_ssl.SSLError.winerror" => "Win32 exception code",
+    "_ssl.SSLError.with_traceback" => "Set self.__traceback__ to tb and return self.",
     "_ssl.SSLSession.__delattr__" => "Implement delattr(self, name).",
     "_ssl.SSLSession.__eq__" => "Return self==value.",
     "_ssl.SSLSession.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
@@ -2958,6 +8183,122 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "_ssl.SSLSession.ticket_lifetime_hint" => "Ticket life time hint.",
     "_ssl.SSLSession.time" => "Session creation time (seconds since epoch).",
     "_ssl.SSLSession.timeout" => "Session timeout (delta in seconds).",
+    "_ssl.SSLSyscallError" => "System error when attempting SSL operation.",
+    "_ssl.SSLSyscallError.__delattr__" => "Implement delattr(self, name).",
+    "_ssl.SSLSyscallError.__eq__" => "Return self==value.",
+    "_ssl.SSLSyscallError.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_ssl.SSLSyscallError.__ge__" => "Return self>=value.",
+    "_ssl.SSLSyscallError.__getattribute__" => "Return getattr(self, name).",
+    "_ssl.SSLSyscallError.__getstate__" => "Helper for pickle.",
+    "_ssl.SSLSyscallError.__gt__" => "Return self>value.",
+    "_ssl.SSLSyscallError.__hash__" => "Return hash(self).",
+    "_ssl.SSLSyscallError.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_ssl.SSLSyscallError.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_ssl.SSLSyscallError.__le__" => "Return self<=value.",
+    "_ssl.SSLSyscallError.__lt__" => "Return self<value.",
+    "_ssl.SSLSyscallError.__ne__" => "Return self!=value.",
+    "_ssl.SSLSyscallError.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_ssl.SSLSyscallError.__reduce_ex__" => "Helper for pickle.",
+    "_ssl.SSLSyscallError.__repr__" => "Return repr(self).",
+    "_ssl.SSLSyscallError.__setattr__" => "Implement setattr(self, name, value).",
+    "_ssl.SSLSyscallError.__sizeof__" => "Size of object in memory, in bytes.",
+    "_ssl.SSLSyscallError.__str__" => "Return str(self).",
+    "_ssl.SSLSyscallError.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_ssl.SSLSyscallError.__weakref__" => "list of weak references to the object",
+    "_ssl.SSLSyscallError.add_note" => "Add a note to the exception",
+    "_ssl.SSLSyscallError.errno" => "POSIX exception code",
+    "_ssl.SSLSyscallError.filename" => "exception filename",
+    "_ssl.SSLSyscallError.filename2" => "second exception filename",
+    "_ssl.SSLSyscallError.strerror" => "exception strerror",
+    "_ssl.SSLSyscallError.winerror" => "Win32 exception code",
+    "_ssl.SSLSyscallError.with_traceback" => "Set self.__traceback__ to tb and return self.",
+    "_ssl.SSLWantReadError" => "Non-blocking SSL socket needs to read more data\nbefore the requested operation can be completed.",
+    "_ssl.SSLWantReadError.__delattr__" => "Implement delattr(self, name).",
+    "_ssl.SSLWantReadError.__eq__" => "Return self==value.",
+    "_ssl.SSLWantReadError.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_ssl.SSLWantReadError.__ge__" => "Return self>=value.",
+    "_ssl.SSLWantReadError.__getattribute__" => "Return getattr(self, name).",
+    "_ssl.SSLWantReadError.__getstate__" => "Helper for pickle.",
+    "_ssl.SSLWantReadError.__gt__" => "Return self>value.",
+    "_ssl.SSLWantReadError.__hash__" => "Return hash(self).",
+    "_ssl.SSLWantReadError.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_ssl.SSLWantReadError.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_ssl.SSLWantReadError.__le__" => "Return self<=value.",
+    "_ssl.SSLWantReadError.__lt__" => "Return self<value.",
+    "_ssl.SSLWantReadError.__ne__" => "Return self!=value.",
+    "_ssl.SSLWantReadError.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_ssl.SSLWantReadError.__reduce_ex__" => "Helper for pickle.",
+    "_ssl.SSLWantReadError.__repr__" => "Return repr(self).",
+    "_ssl.SSLWantReadError.__setattr__" => "Implement setattr(self, name, value).",
+    "_ssl.SSLWantReadError.__sizeof__" => "Size of object in memory, in bytes.",
+    "_ssl.SSLWantReadError.__str__" => "Return str(self).",
+    "_ssl.SSLWantReadError.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_ssl.SSLWantReadError.__weakref__" => "list of weak references to the object",
+    "_ssl.SSLWantReadError.add_note" => "Add a note to the exception",
+    "_ssl.SSLWantReadError.errno" => "POSIX exception code",
+    "_ssl.SSLWantReadError.filename" => "exception filename",
+    "_ssl.SSLWantReadError.filename2" => "second exception filename",
+    "_ssl.SSLWantReadError.strerror" => "exception strerror",
+    "_ssl.SSLWantReadError.winerror" => "Win32 exception code",
+    "_ssl.SSLWantReadError.with_traceback" => "Set self.__traceback__ to tb and return self.",
+    "_ssl.SSLWantWriteError" => "Non-blocking SSL socket needs to write more data\nbefore the requested operation can be completed.",
+    "_ssl.SSLWantWriteError.__delattr__" => "Implement delattr(self, name).",
+    "_ssl.SSLWantWriteError.__eq__" => "Return self==value.",
+    "_ssl.SSLWantWriteError.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_ssl.SSLWantWriteError.__ge__" => "Return self>=value.",
+    "_ssl.SSLWantWriteError.__getattribute__" => "Return getattr(self, name).",
+    "_ssl.SSLWantWriteError.__getstate__" => "Helper for pickle.",
+    "_ssl.SSLWantWriteError.__gt__" => "Return self>value.",
+    "_ssl.SSLWantWriteError.__hash__" => "Return hash(self).",
+    "_ssl.SSLWantWriteError.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_ssl.SSLWantWriteError.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_ssl.SSLWantWriteError.__le__" => "Return self<=value.",
+    "_ssl.SSLWantWriteError.__lt__" => "Return self<value.",
+    "_ssl.SSLWantWriteError.__ne__" => "Return self!=value.",
+    "_ssl.SSLWantWriteError.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_ssl.SSLWantWriteError.__reduce_ex__" => "Helper for pickle.",
+    "_ssl.SSLWantWriteError.__repr__" => "Return repr(self).",
+    "_ssl.SSLWantWriteError.__setattr__" => "Implement setattr(self, name, value).",
+    "_ssl.SSLWantWriteError.__sizeof__" => "Size of object in memory, in bytes.",
+    "_ssl.SSLWantWriteError.__str__" => "Return str(self).",
+    "_ssl.SSLWantWriteError.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_ssl.SSLWantWriteError.__weakref__" => "list of weak references to the object",
+    "_ssl.SSLWantWriteError.add_note" => "Add a note to the exception",
+    "_ssl.SSLWantWriteError.errno" => "POSIX exception code",
+    "_ssl.SSLWantWriteError.filename" => "exception filename",
+    "_ssl.SSLWantWriteError.filename2" => "second exception filename",
+    "_ssl.SSLWantWriteError.strerror" => "exception strerror",
+    "_ssl.SSLWantWriteError.winerror" => "Win32 exception code",
+    "_ssl.SSLWantWriteError.with_traceback" => "Set self.__traceback__ to tb and return self.",
+    "_ssl.SSLZeroReturnError" => "SSL/TLS session closed cleanly.",
+    "_ssl.SSLZeroReturnError.__delattr__" => "Implement delattr(self, name).",
+    "_ssl.SSLZeroReturnError.__eq__" => "Return self==value.",
+    "_ssl.SSLZeroReturnError.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_ssl.SSLZeroReturnError.__ge__" => "Return self>=value.",
+    "_ssl.SSLZeroReturnError.__getattribute__" => "Return getattr(self, name).",
+    "_ssl.SSLZeroReturnError.__getstate__" => "Helper for pickle.",
+    "_ssl.SSLZeroReturnError.__gt__" => "Return self>value.",
+    "_ssl.SSLZeroReturnError.__hash__" => "Return hash(self).",
+    "_ssl.SSLZeroReturnError.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_ssl.SSLZeroReturnError.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_ssl.SSLZeroReturnError.__le__" => "Return self<=value.",
+    "_ssl.SSLZeroReturnError.__lt__" => "Return self<value.",
+    "_ssl.SSLZeroReturnError.__ne__" => "Return self!=value.",
+    "_ssl.SSLZeroReturnError.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_ssl.SSLZeroReturnError.__reduce_ex__" => "Helper for pickle.",
+    "_ssl.SSLZeroReturnError.__repr__" => "Return repr(self).",
+    "_ssl.SSLZeroReturnError.__setattr__" => "Implement setattr(self, name, value).",
+    "_ssl.SSLZeroReturnError.__sizeof__" => "Size of object in memory, in bytes.",
+    "_ssl.SSLZeroReturnError.__str__" => "Return str(self).",
+    "_ssl.SSLZeroReturnError.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_ssl.SSLZeroReturnError.__weakref__" => "list of weak references to the object",
+    "_ssl.SSLZeroReturnError.add_note" => "Add a note to the exception",
+    "_ssl.SSLZeroReturnError.errno" => "POSIX exception code",
+    "_ssl.SSLZeroReturnError.filename" => "exception filename",
+    "_ssl.SSLZeroReturnError.filename2" => "second exception filename",
+    "_ssl.SSLZeroReturnError.strerror" => "exception strerror",
+    "_ssl.SSLZeroReturnError.winerror" => "Win32 exception code",
+    "_ssl.SSLZeroReturnError.with_traceback" => "Set self.__traceback__ to tb and return self.",
     "_ssl._SSLContext.__delattr__" => "Implement delattr(self, name).",
     "_ssl._SSLContext.__eq__" => "Return self==value.",
     "_ssl._SSLContext.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
@@ -3023,7 +8364,7 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "_ssl.get_default_verify_paths" => "Return search paths and environment vars that are used by SSLContext's set_default_verify_paths() to load default CAs.\n\nThe values are 'cert_file_env', 'cert_file', 'cert_dir_env', 'cert_dir'.",
     "_ssl.nid2obj" => "Lookup NID, short name, long name and OID of an ASN1_OBJECT by NID.",
     "_ssl.txt2obj" => "Lookup NID, short name, long name and OID of an ASN1_OBJECT.\n\nBy default objects are looked up by OID. With name=True short and\nlong name are also matched.",
-    "_stat" => "S_IFMT_: file type bits\nS_IFDIR: directory\nS_IFCHR: character device\nS_IFBLK: block device\nS_IFREG: regular file\nS_IFIFO: fifo (named pipe)\nS_IFLNK: symbolic link\nS_IFSOCK: socket file\nS_IFDOOR: door\nS_IFPORT: event port\nS_IFWHT: whiteout\n\nS_ISUID: set UID bit\nS_ISGID: set GID bit\nS_ENFMT: file locking enforcement\nS_ISVTX: sticky bit\nS_IREAD: Unix V7 synonym for S_IRUSR\nS_IWRITE: Unix V7 synonym for S_IWUSR\nS_IEXEC: Unix V7 synonym for S_IXUSR\nS_IRWXU: mask for owner permissions\nS_IRUSR: read by owner\nS_IWUSR: write by owner\nS_IXUSR: execute by owner\nS_IRWXG: mask for group permissions\nS_IRGRP: read by group\nS_IWGRP: write by group\nS_IXGRP: execute by group\nS_IRWXO: mask for others (not in group) permissions\nS_IROTH: read by others\nS_IWOTH: write by others\nS_IXOTH: execute by others\n\nUF_SETTABLE: mask of owner changable flags\nUF_NODUMP: do not dump file\nUF_IMMUTABLE: file may not be changed\nUF_APPEND: file may only be appended to\nUF_OPAQUE: directory is opaque when viewed through a union stack\nUF_NOUNLINK: file may not be renamed or deleted\nUF_COMPRESSED: macOS: file is hfs-compressed\nUF_TRACKED: used for dealing with document IDs\nUF_DATAVAULT: entitlement required for reading and writing\nUF_HIDDEN: macOS: file should not be displayed\nSF_SETTABLE: mask of super user changeable flags\nSF_ARCHIVED: file may be archived\nSF_IMMUTABLE: file may not be changed\nSF_APPEND: file may only be appended to\nSF_RESTRICTED: entitlement required for writing\nSF_NOUNLINK: file may not be renamed or deleted\nSF_SNAPSHOT: file is a snapshot file\nSF_FIRMLINK: file is a firmlink\nSF_DATALESS: file is a dataless object\n\nOn macOS:\nSF_SUPPORTED: mask of super user supported flags\nSF_SYNTHETIC: mask of read-only synthetic flags\n\nST_MODE\nST_INO\nST_DEV\nST_NLINK\nST_UID\nST_GID\nST_SIZE\nST_ATIME\nST_MTIME\nST_CTIME\n\nFILE_ATTRIBUTE_*: Windows file attribute constants\n                   (only present on Windows)",
+    "_stat" => "S_IFMT_: file type bits\nS_IFDIR: directory\nS_IFCHR: character device\nS_IFBLK: block device\nS_IFREG: regular file\nS_IFIFO: fifo (named pipe)\nS_IFLNK: symbolic link\nS_IFSOCK: socket file\nS_IFDOOR: door\nS_IFPORT: event port\nS_IFWHT: whiteout\n\nS_ISUID: set UID bit\nS_ISGID: set GID bit\nS_ENFMT: file locking enforcement\nS_ISVTX: sticky bit\nS_IREAD: Unix V7 synonym for S_IRUSR\nS_IWRITE: Unix V7 synonym for S_IWUSR\nS_IEXEC: Unix V7 synonym for S_IXUSR\nS_IRWXU: mask for owner permissions\nS_IRUSR: read by owner\nS_IWUSR: write by owner\nS_IXUSR: execute by owner\nS_IRWXG: mask for group permissions\nS_IRGRP: read by group\nS_IWGRP: write by group\nS_IXGRP: execute by group\nS_IRWXO: mask for others (not in group) permissions\nS_IROTH: read by others\nS_IWOTH: write by others\nS_IXOTH: execute by others\n\nUF_SETTABLE: mask of owner changeable flags\nUF_NODUMP: do not dump file\nUF_IMMUTABLE: file may not be changed\nUF_APPEND: file may only be appended to\nUF_OPAQUE: directory is opaque when viewed through a union stack\nUF_NOUNLINK: file may not be renamed or deleted\nUF_COMPRESSED: macOS: file is hfs-compressed\nUF_TRACKED: used for dealing with document IDs\nUF_DATAVAULT: entitlement required for reading and writing\nUF_HIDDEN: macOS: file should not be displayed\nSF_SETTABLE: mask of super user changeable flags\nSF_ARCHIVED: file may be archived\nSF_IMMUTABLE: file may not be changed\nSF_APPEND: file may only be appended to\nSF_RESTRICTED: entitlement required for writing\nSF_NOUNLINK: file may not be renamed or deleted\nSF_SNAPSHOT: file is a snapshot file\nSF_FIRMLINK: file is a firmlink\nSF_DATALESS: file is a dataless object\n\nOn macOS:\nSF_SUPPORTED: mask of super user supported flags\nSF_SYNTHETIC: mask of read-only synthetic flags\n\nST_MODE\nST_INO\nST_DEV\nST_NLINK\nST_UID\nST_GID\nST_SIZE\nST_ATIME\nST_MTIME\nST_CTIME\n\nFILE_ATTRIBUTE_*: Windows file attribute constants\n                   (only present on Windows)",
     "_stat.S_IFMT" => "Return the portion of the file's mode that describes the file type.",
     "_stat.S_IMODE" => "Return the portion of the file's mode that can be set by os.chmod().",
     "_stat.S_ISBLK" => "S_ISBLK(mode) -> bool\n\nReturn True if mode is from a block special device file.",
@@ -3041,7 +8382,7 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "_string" => "string helper module",
     "_string.formatter_field_name_split" => "split the argument as a field name",
     "_string.formatter_parser" => "parse the argument as a format string",
-    "_struct" => "Functions to convert between Python values and C structs.\nPython bytes objects are used to hold the data representing the C struct\nand also as format strings (explained below) to describe the layout of data\nin the C struct.\n\nThe optional first format char indicates byte order, size and alignment:\n  @: native order, size & alignment (default)\n  =: native order, std. size & alignment\n  <: little-endian, std. size & alignment\n  >: big-endian, std. size & alignment\n  !: same as >\n\nThe remaining chars indicate types of args and must match exactly;\nthese can be preceded by a decimal repeat count:\n  x: pad byte (no data); c:char; b:signed byte; B:unsigned byte;\n  ?: _Bool (requires C99; if not available, char is used instead)\n  h:short; H:unsigned short; i:int; I:unsigned int;\n  l:long; L:unsigned long; f:float; d:double; e:half-float.\nSpecial cases (preceding decimal count indicates length):\n  s:string (array of char); p: pascal string (with count byte).\nSpecial cases (only available in native format):\n  n:ssize_t; N:size_t;\n  P:an integer type that is wide enough to hold a pointer.\nSpecial case (not in native mode unless 'long long' in platform C):\n  q:long long; Q:unsigned long long\nWhitespace between formats is ignored.\n\nThe variable struct.error is an exception raised on errors.",
+    "_struct" => "Functions to convert between Python values and C structs.\nPython bytes objects are used to hold the data representing the C struct\nand also as format strings (explained below) to describe the layout of data\nin the C struct.\n\nThe optional first format char indicates byte order, size and alignment:\n  @: native order, size & alignment (default)\n  =: native order, std. size & alignment\n  <: little-endian, std. size & alignment\n  >: big-endian, std. size & alignment\n  !: same as >\n\nThe remaining chars indicate types of args and must match exactly;\nthese can be preceded by a decimal repeat count:\n  x: pad byte (no data); c:char; b:signed byte; B:unsigned byte;\n  ?:_Bool; h:short; H:unsigned short; i:int; I:unsigned int;\n  l:long; L:unsigned long; f:float; d:double; e:half-float.\n  F:float complex; D:double complex.\nSpecial cases (preceding decimal count indicates length):\n  s:string (array of char); p: pascal string (with count byte).\nSpecial cases (only available in native format):\n  n:ssize_t; N:size_t;\n  P:an integer type that is wide enough to hold a pointer.\nSpecial case (not in native mode unless 'long long' in platform C):\n  q:long long; Q:unsigned long long\nWhitespace between formats is ignored.\n\nThe variable struct.error is an exception raised on errors.",
     "_struct.Struct" => "Struct(fmt) --> compiled struct object",
     "_struct.Struct.__delattr__" => "Implement delattr(self, name).",
     "_struct.Struct.__eq__" => "Return self==value.",
@@ -3073,6 +8414,29 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "_struct.Struct.unpack_from" => "Return a tuple containing unpacked values.\n\nValues are unpacked according to the format string Struct.format.\n\nThe buffer's size in bytes, starting at position offset, must be\nat least Struct.size.\n\nSee help(struct) for more on format strings.",
     "_struct._clearcache" => "Clear the internal cache.",
     "_struct.calcsize" => "Return size in bytes of the struct described by the format string.",
+    "_struct.error.__delattr__" => "Implement delattr(self, name).",
+    "_struct.error.__eq__" => "Return self==value.",
+    "_struct.error.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_struct.error.__ge__" => "Return self>=value.",
+    "_struct.error.__getattribute__" => "Return getattr(self, name).",
+    "_struct.error.__getstate__" => "Helper for pickle.",
+    "_struct.error.__gt__" => "Return self>value.",
+    "_struct.error.__hash__" => "Return hash(self).",
+    "_struct.error.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_struct.error.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_struct.error.__le__" => "Return self<=value.",
+    "_struct.error.__lt__" => "Return self<value.",
+    "_struct.error.__ne__" => "Return self!=value.",
+    "_struct.error.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_struct.error.__reduce_ex__" => "Helper for pickle.",
+    "_struct.error.__repr__" => "Return repr(self).",
+    "_struct.error.__setattr__" => "Implement setattr(self, name, value).",
+    "_struct.error.__sizeof__" => "Size of object in memory, in bytes.",
+    "_struct.error.__str__" => "Return str(self).",
+    "_struct.error.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_struct.error.__weakref__" => "list of weak references to the object",
+    "_struct.error.add_note" => "Add a note to the exception",
+    "_struct.error.with_traceback" => "Set self.__traceback__ to tb and return self.",
     "_struct.iter_unpack" => "Return an iterator yielding tuples unpacked from the given bytes.\n\nThe bytes are unpacked according to the format string, like\na repeated invocation of unpack_from().\n\nRequires that the bytes length be a multiple of the format struct size.",
     "_struct.pack" => "pack(format, v1, v2, ...) -> bytes\n\nReturn a bytes object containing the values v1, v2, ... packed according\nto the format string.  See help(struct) for more on format strings.",
     "_struct.pack_into" => "pack_into(format, buffer, offset, v1, v2, ...)\n\nPack the values v1, v2, ... according to the format string and write\nthe packed bytes into the writable buffer buf starting at offset.  Note\nthat the offset is a required argument.  See help(struct) for more\non format strings.",
@@ -3141,6 +8505,7 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "_thread.RLock._recursion_count" => "For internal use by reentrancy checks.",
     "_thread.RLock._release_save" => "For internal use by `threading.Condition`.",
     "_thread.RLock.acquire" => "Lock the lock.  `blocking` indicates whether we should wait\nfor the lock to be available or not.  If `blocking` is False\nand another thread holds the lock, the method will return False\nimmediately.  If `blocking` is True and another thread holds\nthe lock, the method will wait for the lock to be released,\ntake it and then return True.\n(note: the blocking operation is interruptible.)\n\nIn all other cases, the method will return True immediately.\nPrecisely, if the current thread already holds the lock, its\ninternal counter is simply incremented. If nobody holds the lock,\nthe lock is taken and its internal counter initialized to 1.",
+    "_thread.RLock.locked" => "locked()\n\nReturn a boolean indicating whether this object is locked right now.",
     "_thread.RLock.release" => "Release the lock, allowing another thread that is blocked waiting for\nthe lock to acquire the lock.  The lock must be in the locked state,\nand must be locked by the same thread that unlocks it; otherwise a\n`RuntimeError` is raised.\n\nDo note that if the lock was acquire()d several times in a row by the\ncurrent thread, release() needs to be called as many times for the lock\nto be available for other threads.",
     "_thread._ExceptHookArgs" => "ExceptHookArgs\n\nType used to pass arguments to threading.excepthook.",
     "_thread._ExceptHookArgs.__add__" => "Return self+value.",
@@ -3202,6 +8567,7 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "_thread._count" => "Return the number of currently running Python threads, excluding\nthe main thread. The returned number comprises all threads created\nthrough `start_new_thread()` as well as `threading.Thread`, and not\nyet finished.\n\nThis function is meant for internal and specialized purposes only.\nIn most applications `threading.enumerate()` should be used instead.",
     "_thread._excepthook" => "Handle uncaught Thread.run() exception.",
     "_thread._get_main_thread_ident" => "Internal only. Return a non-zero integer that uniquely identifies the main thread\nof the main interpreter.",
+    "_thread._get_name" => "Get the name of the current thread.",
     "_thread._is_main_interpreter" => "Return True if the current interpreter is the main Python interpreter.",
     "_thread._local" => "Thread-local data",
     "_thread._local.__delattr__" => "Implement delattr(self, name).",
@@ -3265,12 +8631,11 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "_thread.lock.locked_lock" => "An obsolete synonym of locked().",
     "_thread.lock.release" => "Release the lock, allowing another thread that is blocked waiting for\nthe lock to acquire the lock.  The lock must be in the locked state,\nbut it needn't be locked by the same thread that unlocks it.",
     "_thread.lock.release_lock" => "An obsolete synonym of release().",
+    "_thread.set_name" => "Set the name of the current thread.",
     "_thread.stack_size" => "Return the thread stack size used when creating new threads.  The\noptional size argument specifies the stack size (in bytes) to be used\nfor subsequently created threads, and must be 0 (use platform or\nconfigured default) or a positive integer value of at least 32,768 (32k).\nIf changing the thread stack size is unsupported, a ThreadError\nexception is raised.  If the specified size is invalid, a ValueError\nexception is raised, and the stack size is unmodified.  32k bytes\n currently the minimum supported stack size value to guarantee\nsufficient stack space for the interpreter itself.\n\nNote that some platforms may have particular restrictions on values for\nthe stack size, such as requiring a minimum stack size larger than 32 KiB or\nrequiring allocation in multiples of the system memory page size\n- platform documentation should be referred to for more information\n(4 KiB pages are common; using multiples of 4096 for the stack size is\nthe suggested approach in the absence of more specific information).",
     "_thread.start_joinable_thread" => "*For internal use only*: start a new thread.\n\nLike start_new_thread(), this starts a new thread calling the given function.\nUnlike start_new_thread(), this returns a handle object with methods to join\nor detach the given thread.\nThis function is not for third-party code, please use the\n`threading` module instead. During finalization the runtime will not wait for\nthe thread to exit if daemon is True. If handle is provided it must be a\nnewly created thread._ThreadHandle instance.",
     "_thread.start_new" => "An obsolete synonym of start_new_thread().",
     "_thread.start_new_thread" => "Start a new thread and return its identifier.\n\nThe thread will call the function with positional arguments from the\ntuple args and keyword arguments taken from the optional dictionary\nkwargs.  The thread exits when the function returns; the return value\nis ignored.  The thread will also exit when the function raises an\nunhandled exception; a stack trace will be printed unless the exception\nis SystemExit.",
-    "_tkinter.TclError.__cause__" => "exception cause",
-    "_tkinter.TclError.__context__" => "exception context",
     "_tkinter.TclError.__delattr__" => "Implement delattr(self, name).",
     "_tkinter.TclError.__eq__" => "Return self==value.",
     "_tkinter.TclError.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
@@ -3292,8 +8657,8 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "_tkinter.TclError.__str__" => "Return str(self).",
     "_tkinter.TclError.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
     "_tkinter.TclError.__weakref__" => "list of weak references to the object",
-    "_tkinter.TclError.add_note" => "Exception.add_note(note) --\nadd a note to the exception",
-    "_tkinter.TclError.with_traceback" => "Exception.with_traceback(tb) --\nset self.__traceback__ to tb and return self.",
+    "_tkinter.TclError.add_note" => "Add a note to the exception",
+    "_tkinter.TclError.with_traceback" => "Set self.__traceback__ to tb and return self.",
     "_tkinter.Tcl_Obj.__delattr__" => "Implement delattr(self, name).",
     "_tkinter.Tcl_Obj.__eq__" => "Return self==value.",
     "_tkinter.Tcl_Obj.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
@@ -3360,7 +8725,7 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "_tkinter.TkttType.__sizeof__" => "Size of object in memory, in bytes.",
     "_tkinter.TkttType.__str__" => "Return str(self).",
     "_tkinter.TkttType.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
-    "_tkinter.create" => "wantTk\n  if false, then Tk_Init() doesn't get called\nsync\n  if true, then pass -sync to wish\nuse\n  if not None, then pass -use to wish",
+    "_tkinter.create" => "wantTk\n    if false, then Tk_Init() doesn't get called\n  sync\n    if true, then pass -sync to wish\n  use\n    if not None, then pass -use to wish",
     "_tkinter.getbusywaitinterval" => "Return the current busy-wait interval between successive calls to Tcl_DoOneEvent in a threaded Python interpreter.",
     "_tkinter.setbusywaitinterval" => "Set the busy-wait interval in milliseconds between successive calls to Tcl_DoOneEvent in a threaded Python interpreter.\n\nIt should be set to a divisor of the maximum time between frames in an animation.",
     "_tokenize.TokenizerIter.__delattr__" => "Implement delattr(self, name).",
@@ -3397,15 +8762,499 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "_tracemalloc.reset_peak" => "Set the peak size of memory blocks traced by tracemalloc to the current size.\n\nDo nothing if the tracemalloc module is not tracing memory allocations.",
     "_tracemalloc.start" => "Start tracing Python memory allocations.\n\nAlso set the maximum number of frames stored in the traceback of a\ntrace to nframe.",
     "_tracemalloc.stop" => "Stop tracing Python memory allocations.\n\nAlso clear traces of memory blocks allocated by Python.",
+    "_types" => "Define names for built-in types.",
+    "_types.GenericAlias" => "Represent a PEP 585 generic type\n\nE.g. for t = list[int], t.__origin__ is list and t.__args__ is (int,).",
+    "_types.GenericAlias.__call__" => "Call self as a function.",
+    "_types.GenericAlias.__delattr__" => "Implement delattr(self, name).",
+    "_types.GenericAlias.__eq__" => "Return self==value.",
+    "_types.GenericAlias.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_types.GenericAlias.__ge__" => "Return self>=value.",
+    "_types.GenericAlias.__getattribute__" => "Return getattr(self, name).",
+    "_types.GenericAlias.__getitem__" => "Return self[key].",
+    "_types.GenericAlias.__getstate__" => "Helper for pickle.",
+    "_types.GenericAlias.__gt__" => "Return self>value.",
+    "_types.GenericAlias.__hash__" => "Return hash(self).",
+    "_types.GenericAlias.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_types.GenericAlias.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_types.GenericAlias.__iter__" => "Implement iter(self).",
+    "_types.GenericAlias.__le__" => "Return self<=value.",
+    "_types.GenericAlias.__lt__" => "Return self<value.",
+    "_types.GenericAlias.__ne__" => "Return self!=value.",
+    "_types.GenericAlias.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_types.GenericAlias.__or__" => "Return self|value.",
+    "_types.GenericAlias.__parameters__" => "Type variables in the GenericAlias.",
+    "_types.GenericAlias.__reduce_ex__" => "Helper for pickle.",
+    "_types.GenericAlias.__repr__" => "Return repr(self).",
+    "_types.GenericAlias.__ror__" => "Return value|self.",
+    "_types.GenericAlias.__setattr__" => "Implement setattr(self, name, value).",
+    "_types.GenericAlias.__sizeof__" => "Size of object in memory, in bytes.",
+    "_types.GenericAlias.__str__" => "Return str(self).",
+    "_types.GenericAlias.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_types.NoneType" => "The type of the None singleton.",
+    "_types.NoneType.__bool__" => "True if self else False",
+    "_types.NoneType.__delattr__" => "Implement delattr(self, name).",
+    "_types.NoneType.__eq__" => "Return self==value.",
+    "_types.NoneType.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_types.NoneType.__ge__" => "Return self>=value.",
+    "_types.NoneType.__getattribute__" => "Return getattr(self, name).",
+    "_types.NoneType.__getstate__" => "Helper for pickle.",
+    "_types.NoneType.__gt__" => "Return self>value.",
+    "_types.NoneType.__hash__" => "Return hash(self).",
+    "_types.NoneType.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_types.NoneType.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_types.NoneType.__le__" => "Return self<=value.",
+    "_types.NoneType.__lt__" => "Return self<value.",
+    "_types.NoneType.__ne__" => "Return self!=value.",
+    "_types.NoneType.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_types.NoneType.__reduce__" => "Helper for pickle.",
+    "_types.NoneType.__reduce_ex__" => "Helper for pickle.",
+    "_types.NoneType.__repr__" => "Return repr(self).",
+    "_types.NoneType.__setattr__" => "Implement setattr(self, name, value).",
+    "_types.NoneType.__sizeof__" => "Size of object in memory, in bytes.",
+    "_types.NoneType.__str__" => "Return str(self).",
+    "_types.NoneType.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_types.NotImplementedType" => "The type of the NotImplemented singleton.",
+    "_types.NotImplementedType.__bool__" => "True if self else False",
+    "_types.NotImplementedType.__delattr__" => "Implement delattr(self, name).",
+    "_types.NotImplementedType.__eq__" => "Return self==value.",
+    "_types.NotImplementedType.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_types.NotImplementedType.__ge__" => "Return self>=value.",
+    "_types.NotImplementedType.__getattribute__" => "Return getattr(self, name).",
+    "_types.NotImplementedType.__getstate__" => "Helper for pickle.",
+    "_types.NotImplementedType.__gt__" => "Return self>value.",
+    "_types.NotImplementedType.__hash__" => "Return hash(self).",
+    "_types.NotImplementedType.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_types.NotImplementedType.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_types.NotImplementedType.__le__" => "Return self<=value.",
+    "_types.NotImplementedType.__lt__" => "Return self<value.",
+    "_types.NotImplementedType.__ne__" => "Return self!=value.",
+    "_types.NotImplementedType.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_types.NotImplementedType.__reduce_ex__" => "Helper for pickle.",
+    "_types.NotImplementedType.__repr__" => "Return repr(self).",
+    "_types.NotImplementedType.__setattr__" => "Implement setattr(self, name, value).",
+    "_types.NotImplementedType.__sizeof__" => "Size of object in memory, in bytes.",
+    "_types.NotImplementedType.__str__" => "Return str(self).",
+    "_types.NotImplementedType.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_types.SimpleNamespace" => "A simple attribute-based namespace.",
+    "_types.SimpleNamespace.__delattr__" => "Implement delattr(self, name).",
+    "_types.SimpleNamespace.__eq__" => "Return self==value.",
+    "_types.SimpleNamespace.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_types.SimpleNamespace.__ge__" => "Return self>=value.",
+    "_types.SimpleNamespace.__getattribute__" => "Return getattr(self, name).",
+    "_types.SimpleNamespace.__getstate__" => "Helper for pickle.",
+    "_types.SimpleNamespace.__gt__" => "Return self>value.",
+    "_types.SimpleNamespace.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_types.SimpleNamespace.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_types.SimpleNamespace.__le__" => "Return self<=value.",
+    "_types.SimpleNamespace.__lt__" => "Return self<value.",
+    "_types.SimpleNamespace.__ne__" => "Return self!=value.",
+    "_types.SimpleNamespace.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_types.SimpleNamespace.__reduce__" => "Return state information for pickling",
+    "_types.SimpleNamespace.__reduce_ex__" => "Helper for pickle.",
+    "_types.SimpleNamespace.__replace__" => "Return a copy of the namespace object with new values for the specified attributes.",
+    "_types.SimpleNamespace.__repr__" => "Return repr(self).",
+    "_types.SimpleNamespace.__setattr__" => "Implement setattr(self, name, value).",
+    "_types.SimpleNamespace.__sizeof__" => "Size of object in memory, in bytes.",
+    "_types.SimpleNamespace.__str__" => "Return str(self).",
+    "_types.SimpleNamespace.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
     "_typing" => "Primitives and accelerators for the typing module.",
+    "_typing.Generic" => "Abstract base class for generic types.\n\nOn Python 3.12 and newer, generic classes implicitly inherit from\nGeneric when they declare a parameter list after the class's name::\n\n    class Mapping[KT, VT]:\n        def __getitem__(self, key: KT) -> VT:\n            ...\n        # Etc.\n\nOn older versions of Python, however, generic classes have to\nexplicitly inherit from Generic.\n\nAfter a class has been declared to be generic, it can then be used as\nfollows::\n\n    def lookup_name[KT, VT](mapping: Mapping[KT, VT], key: KT, default: VT) -> VT:\n        try:\n            return mapping[key]\n        except KeyError:\n            return default",
+    "_typing.Generic.__class_getitem__" => "Parameterizes a generic class.\n\nAt least, parameterizing a generic class is the *main* thing this\nmethod does. For example, for some generic class `Foo`, this is called\nwhen we do `Foo[int]` - there, with `cls=Foo` and `params=int`.\n\nHowever, note that this method is also called when defining generic\nclasses in the first place with `class Foo[T]: ...`.",
+    "_typing.Generic.__delattr__" => "Implement delattr(self, name).",
+    "_typing.Generic.__eq__" => "Return self==value.",
+    "_typing.Generic.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_typing.Generic.__ge__" => "Return self>=value.",
+    "_typing.Generic.__getattribute__" => "Return getattr(self, name).",
+    "_typing.Generic.__getstate__" => "Helper for pickle.",
+    "_typing.Generic.__gt__" => "Return self>value.",
+    "_typing.Generic.__hash__" => "Return hash(self).",
+    "_typing.Generic.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_typing.Generic.__init_subclass__" => "Function to initialize subclasses.",
+    "_typing.Generic.__le__" => "Return self<=value.",
+    "_typing.Generic.__lt__" => "Return self<value.",
+    "_typing.Generic.__ne__" => "Return self!=value.",
+    "_typing.Generic.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_typing.Generic.__reduce__" => "Helper for pickle.",
+    "_typing.Generic.__reduce_ex__" => "Helper for pickle.",
+    "_typing.Generic.__repr__" => "Return repr(self).",
+    "_typing.Generic.__setattr__" => "Implement setattr(self, name, value).",
+    "_typing.Generic.__sizeof__" => "Size of object in memory, in bytes.",
+    "_typing.Generic.__str__" => "Return str(self).",
+    "_typing.Generic.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_typing.ParamSpec" => "Parameter specification variable.\n\nThe preferred way to construct a parameter specification is via the\ndedicated syntax for generic functions, classes, and type aliases,\nwhere the use of '**' creates a parameter specification::\n\n    type IntFunc[**P] = Callable[P, int]\n\nThe following syntax creates a parameter specification that defaults\nto a callable accepting two positional-only arguments of types int\nand str:\n\n    type IntFuncDefault[**P = [int, str]] = Callable[P, int]\n\nFor compatibility with Python 3.11 and earlier, ParamSpec objects\ncan also be created as follows::\n\n    P = ParamSpec('P')\n    DefaultP = ParamSpec('DefaultP', default=[int, str])\n\nParameter specification variables exist primarily for the benefit of\nstatic type checkers.  They are used to forward the parameter types of\none callable to another callable, a pattern commonly found in\nhigher-order functions and decorators.  They are only valid when used\nin ``Concatenate``, or as the first argument to ``Callable``, or as\nparameters for user-defined Generics. See class Generic for more\ninformation on generic types.\n\nAn example for annotating a decorator::\n\n    def add_logging[**P, T](f: Callable[P, T]) -> Callable[P, T]:\n        '''A type-safe decorator to add logging to a function.'''\n        def inner(*args: P.args, **kwargs: P.kwargs) -> T:\n            logging.info(f'{f.__name__} was called')\n            return f(*args, **kwargs)\n        return inner\n\n    @add_logging\n    def add_two(x: float, y: float) -> float:\n        '''Add two numbers together.'''\n        return x + y\n\nParameter specification variables can be introspected. e.g.::\n\n    >>> P = ParamSpec(\"P\")\n    >>> P.__name__\n    'P'\n\nNote that only parameter specification variables defined in the global\nscope can be pickled.",
+    "_typing.ParamSpec.__default__" => "The default value for this ParamSpec.",
+    "_typing.ParamSpec.__delattr__" => "Implement delattr(self, name).",
+    "_typing.ParamSpec.__eq__" => "Return self==value.",
+    "_typing.ParamSpec.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_typing.ParamSpec.__ge__" => "Return self>=value.",
+    "_typing.ParamSpec.__getattribute__" => "Return getattr(self, name).",
+    "_typing.ParamSpec.__getstate__" => "Helper for pickle.",
+    "_typing.ParamSpec.__gt__" => "Return self>value.",
+    "_typing.ParamSpec.__hash__" => "Return hash(self).",
+    "_typing.ParamSpec.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_typing.ParamSpec.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_typing.ParamSpec.__le__" => "Return self<=value.",
+    "_typing.ParamSpec.__lt__" => "Return self<value.",
+    "_typing.ParamSpec.__ne__" => "Return self!=value.",
+    "_typing.ParamSpec.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_typing.ParamSpec.__or__" => "Return self|value.",
+    "_typing.ParamSpec.__reduce_ex__" => "Helper for pickle.",
+    "_typing.ParamSpec.__repr__" => "Return repr(self).",
+    "_typing.ParamSpec.__ror__" => "Return value|self.",
+    "_typing.ParamSpec.__setattr__" => "Implement setattr(self, name, value).",
+    "_typing.ParamSpec.__sizeof__" => "Size of object in memory, in bytes.",
+    "_typing.ParamSpec.__str__" => "Return str(self).",
+    "_typing.ParamSpec.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_typing.ParamSpec.args" => "Represents positional arguments.",
+    "_typing.ParamSpec.kwargs" => "Represents keyword arguments.",
+    "_typing.ParamSpecArgs" => "The args for a ParamSpec object.\n\nGiven a ParamSpec object P, P.args is an instance of ParamSpecArgs.\n\nParamSpecArgs objects have a reference back to their ParamSpec::\n\n    >>> P = ParamSpec(\"P\")\n    >>> P.args.__origin__ is P\n    True\n\nThis type is meant for runtime introspection and has no special meaning\nto static type checkers.",
+    "_typing.ParamSpecArgs.__delattr__" => "Implement delattr(self, name).",
+    "_typing.ParamSpecArgs.__eq__" => "Return self==value.",
+    "_typing.ParamSpecArgs.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_typing.ParamSpecArgs.__ge__" => "Return self>=value.",
+    "_typing.ParamSpecArgs.__getattribute__" => "Return getattr(self, name).",
+    "_typing.ParamSpecArgs.__getstate__" => "Helper for pickle.",
+    "_typing.ParamSpecArgs.__gt__" => "Return self>value.",
+    "_typing.ParamSpecArgs.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_typing.ParamSpecArgs.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_typing.ParamSpecArgs.__le__" => "Return self<=value.",
+    "_typing.ParamSpecArgs.__lt__" => "Return self<value.",
+    "_typing.ParamSpecArgs.__ne__" => "Return self!=value.",
+    "_typing.ParamSpecArgs.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_typing.ParamSpecArgs.__reduce__" => "Helper for pickle.",
+    "_typing.ParamSpecArgs.__reduce_ex__" => "Helper for pickle.",
+    "_typing.ParamSpecArgs.__repr__" => "Return repr(self).",
+    "_typing.ParamSpecArgs.__setattr__" => "Implement setattr(self, name, value).",
+    "_typing.ParamSpecArgs.__sizeof__" => "Size of object in memory, in bytes.",
+    "_typing.ParamSpecArgs.__str__" => "Return str(self).",
+    "_typing.ParamSpecArgs.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_typing.ParamSpecKwargs" => "The kwargs for a ParamSpec object.\n\nGiven a ParamSpec object P, P.kwargs is an instance of ParamSpecKwargs.\n\nParamSpecKwargs objects have a reference back to their ParamSpec::\n\n    >>> P = ParamSpec(\"P\")\n    >>> P.kwargs.__origin__ is P\n    True\n\nThis type is meant for runtime introspection and has no special meaning\nto static type checkers.",
+    "_typing.ParamSpecKwargs.__delattr__" => "Implement delattr(self, name).",
+    "_typing.ParamSpecKwargs.__eq__" => "Return self==value.",
+    "_typing.ParamSpecKwargs.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_typing.ParamSpecKwargs.__ge__" => "Return self>=value.",
+    "_typing.ParamSpecKwargs.__getattribute__" => "Return getattr(self, name).",
+    "_typing.ParamSpecKwargs.__getstate__" => "Helper for pickle.",
+    "_typing.ParamSpecKwargs.__gt__" => "Return self>value.",
+    "_typing.ParamSpecKwargs.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_typing.ParamSpecKwargs.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_typing.ParamSpecKwargs.__le__" => "Return self<=value.",
+    "_typing.ParamSpecKwargs.__lt__" => "Return self<value.",
+    "_typing.ParamSpecKwargs.__ne__" => "Return self!=value.",
+    "_typing.ParamSpecKwargs.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_typing.ParamSpecKwargs.__reduce__" => "Helper for pickle.",
+    "_typing.ParamSpecKwargs.__reduce_ex__" => "Helper for pickle.",
+    "_typing.ParamSpecKwargs.__repr__" => "Return repr(self).",
+    "_typing.ParamSpecKwargs.__setattr__" => "Implement setattr(self, name, value).",
+    "_typing.ParamSpecKwargs.__sizeof__" => "Size of object in memory, in bytes.",
+    "_typing.ParamSpecKwargs.__str__" => "Return str(self).",
+    "_typing.ParamSpecKwargs.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_typing.TypeAliasType" => "Type alias.\n\nType aliases are created through the type statement::\n\n    type Alias = int\n\nIn this example, Alias and int will be treated equivalently by static\ntype checkers.\n\nAt runtime, Alias is an instance of TypeAliasType. The __name__\nattribute holds the name of the type alias. The value of the type alias\nis stored in the __value__ attribute. It is evaluated lazily, so the\nvalue is computed only if the attribute is accessed.\n\nType aliases can also be generic::\n\n    type ListOrSet[T] = list[T] | set[T]\n\nIn this case, the type parameters of the alias are stored in the\n__type_params__ attribute.\n\nSee PEP 695 for more information.",
+    "_typing.TypeAliasType.__delattr__" => "Implement delattr(self, name).",
+    "_typing.TypeAliasType.__eq__" => "Return self==value.",
+    "_typing.TypeAliasType.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_typing.TypeAliasType.__ge__" => "Return self>=value.",
+    "_typing.TypeAliasType.__getattribute__" => "Return getattr(self, name).",
+    "_typing.TypeAliasType.__getitem__" => "Return self[key].",
+    "_typing.TypeAliasType.__getstate__" => "Helper for pickle.",
+    "_typing.TypeAliasType.__gt__" => "Return self>value.",
+    "_typing.TypeAliasType.__hash__" => "Return hash(self).",
+    "_typing.TypeAliasType.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_typing.TypeAliasType.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_typing.TypeAliasType.__iter__" => "Implement iter(self).",
+    "_typing.TypeAliasType.__le__" => "Return self<=value.",
+    "_typing.TypeAliasType.__lt__" => "Return self<value.",
+    "_typing.TypeAliasType.__ne__" => "Return self!=value.",
+    "_typing.TypeAliasType.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_typing.TypeAliasType.__or__" => "Return self|value.",
+    "_typing.TypeAliasType.__reduce_ex__" => "Helper for pickle.",
+    "_typing.TypeAliasType.__repr__" => "Return repr(self).",
+    "_typing.TypeAliasType.__ror__" => "Return value|self.",
+    "_typing.TypeAliasType.__setattr__" => "Implement setattr(self, name, value).",
+    "_typing.TypeAliasType.__sizeof__" => "Size of object in memory, in bytes.",
+    "_typing.TypeAliasType.__str__" => "Return str(self).",
+    "_typing.TypeAliasType.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_typing.TypeVar" => "Type variable.\n\nThe preferred way to construct a type variable is via the dedicated\nsyntax for generic functions, classes, and type aliases::\n\n    class Sequence[T]:  # T is a TypeVar\n        ...\n\nThis syntax can also be used to create bound and constrained type\nvariables::\n\n    # S is a TypeVar bound to str\n    class StrSequence[S: str]:\n        ...\n\n    # A is a TypeVar constrained to str or bytes\n    class StrOrBytesSequence[A: (str, bytes)]:\n        ...\n\nType variables can also have defaults:\n\n    class IntDefault[T = int]:\n        ...\n\nHowever, if desired, reusable type variables can also be constructed\nmanually, like so::\n\n   T = TypeVar('T')  # Can be anything\n   S = TypeVar('S', bound=str)  # Can be any subtype of str\n   A = TypeVar('A', str, bytes)  # Must be exactly str or bytes\n   D = TypeVar('D', default=int)  # Defaults to int\n\nType variables exist primarily for the benefit of static type\ncheckers.  They serve as the parameters for generic types as well\nas for generic function and type alias definitions.\n\nThe variance of type variables is inferred by type checkers when they\nare created through the type parameter syntax and when\n``infer_variance=True`` is passed. Manually created type variables may\nbe explicitly marked covariant or contravariant by passing\n``covariant=True`` or ``contravariant=True``. By default, manually\ncreated type variables are invariant. See PEP 484 and PEP 695 for more\ndetails.",
+    "_typing.TypeVar.__delattr__" => "Implement delattr(self, name).",
+    "_typing.TypeVar.__eq__" => "Return self==value.",
+    "_typing.TypeVar.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_typing.TypeVar.__ge__" => "Return self>=value.",
+    "_typing.TypeVar.__getattribute__" => "Return getattr(self, name).",
+    "_typing.TypeVar.__getstate__" => "Helper for pickle.",
+    "_typing.TypeVar.__gt__" => "Return self>value.",
+    "_typing.TypeVar.__hash__" => "Return hash(self).",
+    "_typing.TypeVar.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_typing.TypeVar.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_typing.TypeVar.__le__" => "Return self<=value.",
+    "_typing.TypeVar.__lt__" => "Return self<value.",
+    "_typing.TypeVar.__ne__" => "Return self!=value.",
+    "_typing.TypeVar.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_typing.TypeVar.__or__" => "Return self|value.",
+    "_typing.TypeVar.__reduce_ex__" => "Helper for pickle.",
+    "_typing.TypeVar.__repr__" => "Return repr(self).",
+    "_typing.TypeVar.__ror__" => "Return value|self.",
+    "_typing.TypeVar.__setattr__" => "Implement setattr(self, name, value).",
+    "_typing.TypeVar.__sizeof__" => "Size of object in memory, in bytes.",
+    "_typing.TypeVar.__str__" => "Return str(self).",
+    "_typing.TypeVar.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_typing.TypeVarTuple" => "Type variable tuple. A specialized form of type variable that enables\nvariadic generics.\n\nThe preferred way to construct a type variable tuple is via the\ndedicated syntax for generic functions, classes, and type aliases,\nwhere a single '*' indicates a type variable tuple::\n\n    def move_first_element_to_last[T, *Ts](tup: tuple[T, *Ts]) -> tuple[*Ts, T]:\n        return (*tup[1:], tup[0])\n\nType variables tuples can have default values:\n\n    type AliasWithDefault[*Ts = (str, int)] = tuple[*Ts]\n\nFor compatibility with Python 3.11 and earlier, TypeVarTuple objects\ncan also be created as follows::\n\n    Ts = TypeVarTuple('Ts')  # Can be given any name\n    DefaultTs = TypeVarTuple('Ts', default=(str, int))\n\nJust as a TypeVar (type variable) is a placeholder for a single type,\na TypeVarTuple is a placeholder for an *arbitrary* number of types. For\nexample, if we define a generic class using a TypeVarTuple::\n\n    class C[*Ts]: ...\n\nThen we can parameterize that class with an arbitrary number of type\narguments::\n\n    C[int]       # Fine\n    C[int, str]  # Also fine\n    C[()]        # Even this is fine\n\nFor more details, see PEP 646.\n\nNote that only TypeVarTuples defined in the global scope can be\npickled.",
+    "_typing.TypeVarTuple.__default__" => "The default value for this TypeVarTuple.",
+    "_typing.TypeVarTuple.__delattr__" => "Implement delattr(self, name).",
+    "_typing.TypeVarTuple.__eq__" => "Return self==value.",
+    "_typing.TypeVarTuple.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_typing.TypeVarTuple.__ge__" => "Return self>=value.",
+    "_typing.TypeVarTuple.__getattribute__" => "Return getattr(self, name).",
+    "_typing.TypeVarTuple.__getstate__" => "Helper for pickle.",
+    "_typing.TypeVarTuple.__gt__" => "Return self>value.",
+    "_typing.TypeVarTuple.__hash__" => "Return hash(self).",
+    "_typing.TypeVarTuple.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_typing.TypeVarTuple.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_typing.TypeVarTuple.__iter__" => "Implement iter(self).",
+    "_typing.TypeVarTuple.__le__" => "Return self<=value.",
+    "_typing.TypeVarTuple.__lt__" => "Return self<value.",
+    "_typing.TypeVarTuple.__ne__" => "Return self!=value.",
+    "_typing.TypeVarTuple.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_typing.TypeVarTuple.__reduce_ex__" => "Helper for pickle.",
+    "_typing.TypeVarTuple.__repr__" => "Return repr(self).",
+    "_typing.TypeVarTuple.__setattr__" => "Implement setattr(self, name, value).",
+    "_typing.TypeVarTuple.__sizeof__" => "Size of object in memory, in bytes.",
+    "_typing.TypeVarTuple.__str__" => "Return str(self).",
+    "_typing.TypeVarTuple.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_typing.Union" => "Represent a union type\n\nE.g. for int | str",
+    "_typing.Union.__class_getitem__" => "See PEP 585",
+    "_typing.Union.__delattr__" => "Implement delattr(self, name).",
+    "_typing.Union.__eq__" => "Return self==value.",
+    "_typing.Union.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_typing.Union.__ge__" => "Return self>=value.",
+    "_typing.Union.__getattribute__" => "Return getattr(self, name).",
+    "_typing.Union.__getitem__" => "Return self[key].",
+    "_typing.Union.__getstate__" => "Helper for pickle.",
+    "_typing.Union.__gt__" => "Return self>value.",
+    "_typing.Union.__hash__" => "Return hash(self).",
+    "_typing.Union.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_typing.Union.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_typing.Union.__le__" => "Return self<=value.",
+    "_typing.Union.__lt__" => "Return self<value.",
+    "_typing.Union.__ne__" => "Return self!=value.",
+    "_typing.Union.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_typing.Union.__or__" => "Return self|value.",
+    "_typing.Union.__origin__" => "Always returns the type",
+    "_typing.Union.__parameters__" => "Type variables in the types.UnionType.",
+    "_typing.Union.__reduce__" => "Helper for pickle.",
+    "_typing.Union.__reduce_ex__" => "Helper for pickle.",
+    "_typing.Union.__repr__" => "Return repr(self).",
+    "_typing.Union.__ror__" => "Return value|self.",
+    "_typing.Union.__setattr__" => "Implement setattr(self, name, value).",
+    "_typing.Union.__sizeof__" => "Size of object in memory, in bytes.",
+    "_typing.Union.__str__" => "Return str(self).",
+    "_typing.Union.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
     "_warnings" => "_warnings provides basic warning filtering support.\nIt is a helper module to speed up interpreter start-up.",
-    "_warnings.warn" => "Issue a warning, or maybe ignore it or raise an exception.\n\nmessage\n  Text of the warning message.\ncategory\n  The Warning category subclass. Defaults to UserWarning.\nstacklevel\n  How far up the call stack to make this warning appear. A value of 2 for\n  example attributes the warning to the caller of the code calling warn().\nsource\n  If supplied, the destroyed object which emitted a ResourceWarning\nskip_file_prefixes\n  An optional tuple of module filename prefixes indicating frames to skip\n  during stacklevel computations for stack frame attribution.",
+    "_warnings.warn" => "Issue a warning, or maybe ignore it or raise an exception.\n\n  message\n    Text of the warning message.\n  category\n    The Warning category subclass. Defaults to UserWarning.\n  stacklevel\n    How far up the call stack to make this warning appear. A value of 2 for\n    example attributes the warning to the caller of the code calling warn().\n  source\n    If supplied, the destroyed object which emitted a ResourceWarning\n  skip_file_prefixes\n    An optional tuple of module filename prefixes indicating frames to skip\n    during stacklevel computations for stack frame attribution.",
     "_warnings.warn_explicit" => "Issue a warning, or maybe ignore it or raise an exception.",
     "_weakref" => "Weak-reference support module.",
+    "_weakref.CallableProxyType.__abs__" => "abs(self)",
+    "_weakref.CallableProxyType.__add__" => "Return self+value.",
+    "_weakref.CallableProxyType.__and__" => "Return self&value.",
+    "_weakref.CallableProxyType.__bool__" => "True if self else False",
+    "_weakref.CallableProxyType.__call__" => "Call self as a function.",
+    "_weakref.CallableProxyType.__contains__" => "Return bool(key in self).",
+    "_weakref.CallableProxyType.__delattr__" => "Implement delattr(self, name).",
+    "_weakref.CallableProxyType.__delitem__" => "Delete self[key].",
+    "_weakref.CallableProxyType.__divmod__" => "Return divmod(self, value).",
+    "_weakref.CallableProxyType.__eq__" => "Return self==value.",
+    "_weakref.CallableProxyType.__float__" => "float(self)",
+    "_weakref.CallableProxyType.__floordiv__" => "Return self//value.",
+    "_weakref.CallableProxyType.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_weakref.CallableProxyType.__ge__" => "Return self>=value.",
+    "_weakref.CallableProxyType.__getattribute__" => "Return getattr(self, name).",
+    "_weakref.CallableProxyType.__getitem__" => "Return self[key].",
+    "_weakref.CallableProxyType.__getstate__" => "Helper for pickle.",
+    "_weakref.CallableProxyType.__gt__" => "Return self>value.",
+    "_weakref.CallableProxyType.__iadd__" => "Return self+=value.",
+    "_weakref.CallableProxyType.__iand__" => "Return self&=value.",
+    "_weakref.CallableProxyType.__ifloordiv__" => "Return self//=value.",
+    "_weakref.CallableProxyType.__ilshift__" => "Return self<<=value.",
+    "_weakref.CallableProxyType.__imatmul__" => "Return self@=value.",
+    "_weakref.CallableProxyType.__imod__" => "Return self%=value.",
+    "_weakref.CallableProxyType.__imul__" => "Return self*=value.",
+    "_weakref.CallableProxyType.__index__" => "Return self converted to an integer, if self is suitable for use as an index into a list.",
+    "_weakref.CallableProxyType.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_weakref.CallableProxyType.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_weakref.CallableProxyType.__int__" => "int(self)",
+    "_weakref.CallableProxyType.__invert__" => "~self",
+    "_weakref.CallableProxyType.__ior__" => "Return self|=value.",
+    "_weakref.CallableProxyType.__ipow__" => "Return self**=value.",
+    "_weakref.CallableProxyType.__irshift__" => "Return self>>=value.",
+    "_weakref.CallableProxyType.__isub__" => "Return self-=value.",
+    "_weakref.CallableProxyType.__iter__" => "Implement iter(self).",
+    "_weakref.CallableProxyType.__itruediv__" => "Return self/=value.",
+    "_weakref.CallableProxyType.__ixor__" => "Return self^=value.",
+    "_weakref.CallableProxyType.__le__" => "Return self<=value.",
+    "_weakref.CallableProxyType.__len__" => "Return len(self).",
+    "_weakref.CallableProxyType.__lshift__" => "Return self<<value.",
+    "_weakref.CallableProxyType.__lt__" => "Return self<value.",
+    "_weakref.CallableProxyType.__matmul__" => "Return self@value.",
+    "_weakref.CallableProxyType.__mod__" => "Return self%value.",
+    "_weakref.CallableProxyType.__mul__" => "Return self*value.",
+    "_weakref.CallableProxyType.__ne__" => "Return self!=value.",
+    "_weakref.CallableProxyType.__neg__" => "-self",
+    "_weakref.CallableProxyType.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_weakref.CallableProxyType.__next__" => "Implement next(self).",
+    "_weakref.CallableProxyType.__or__" => "Return self|value.",
+    "_weakref.CallableProxyType.__pos__" => "+self",
+    "_weakref.CallableProxyType.__pow__" => "Return pow(self, value, mod).",
+    "_weakref.CallableProxyType.__radd__" => "Return value+self.",
+    "_weakref.CallableProxyType.__rand__" => "Return value&self.",
+    "_weakref.CallableProxyType.__rdivmod__" => "Return divmod(value, self).",
+    "_weakref.CallableProxyType.__reduce__" => "Helper for pickle.",
+    "_weakref.CallableProxyType.__reduce_ex__" => "Helper for pickle.",
+    "_weakref.CallableProxyType.__repr__" => "Return repr(self).",
+    "_weakref.CallableProxyType.__rfloordiv__" => "Return value//self.",
+    "_weakref.CallableProxyType.__rlshift__" => "Return value<<self.",
+    "_weakref.CallableProxyType.__rmatmul__" => "Return value@self.",
+    "_weakref.CallableProxyType.__rmod__" => "Return value%self.",
+    "_weakref.CallableProxyType.__rmul__" => "Return value*self.",
+    "_weakref.CallableProxyType.__ror__" => "Return value|self.",
+    "_weakref.CallableProxyType.__rpow__" => "Return pow(value, self, mod).",
+    "_weakref.CallableProxyType.__rrshift__" => "Return value>>self.",
+    "_weakref.CallableProxyType.__rshift__" => "Return self>>value.",
+    "_weakref.CallableProxyType.__rsub__" => "Return value-self.",
+    "_weakref.CallableProxyType.__rtruediv__" => "Return value/self.",
+    "_weakref.CallableProxyType.__rxor__" => "Return value^self.",
+    "_weakref.CallableProxyType.__setattr__" => "Implement setattr(self, name, value).",
+    "_weakref.CallableProxyType.__setitem__" => "Set self[key] to value.",
+    "_weakref.CallableProxyType.__sizeof__" => "Size of object in memory, in bytes.",
+    "_weakref.CallableProxyType.__str__" => "Return str(self).",
+    "_weakref.CallableProxyType.__sub__" => "Return self-value.",
+    "_weakref.CallableProxyType.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_weakref.CallableProxyType.__truediv__" => "Return self/value.",
+    "_weakref.CallableProxyType.__xor__" => "Return self^value.",
+    "_weakref.ProxyType.__abs__" => "abs(self)",
+    "_weakref.ProxyType.__add__" => "Return self+value.",
+    "_weakref.ProxyType.__and__" => "Return self&value.",
+    "_weakref.ProxyType.__bool__" => "True if self else False",
+    "_weakref.ProxyType.__contains__" => "Return bool(key in self).",
+    "_weakref.ProxyType.__delattr__" => "Implement delattr(self, name).",
+    "_weakref.ProxyType.__delitem__" => "Delete self[key].",
+    "_weakref.ProxyType.__divmod__" => "Return divmod(self, value).",
+    "_weakref.ProxyType.__eq__" => "Return self==value.",
+    "_weakref.ProxyType.__float__" => "float(self)",
+    "_weakref.ProxyType.__floordiv__" => "Return self//value.",
+    "_weakref.ProxyType.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_weakref.ProxyType.__ge__" => "Return self>=value.",
+    "_weakref.ProxyType.__getattribute__" => "Return getattr(self, name).",
+    "_weakref.ProxyType.__getitem__" => "Return self[key].",
+    "_weakref.ProxyType.__getstate__" => "Helper for pickle.",
+    "_weakref.ProxyType.__gt__" => "Return self>value.",
+    "_weakref.ProxyType.__iadd__" => "Return self+=value.",
+    "_weakref.ProxyType.__iand__" => "Return self&=value.",
+    "_weakref.ProxyType.__ifloordiv__" => "Return self//=value.",
+    "_weakref.ProxyType.__ilshift__" => "Return self<<=value.",
+    "_weakref.ProxyType.__imatmul__" => "Return self@=value.",
+    "_weakref.ProxyType.__imod__" => "Return self%=value.",
+    "_weakref.ProxyType.__imul__" => "Return self*=value.",
+    "_weakref.ProxyType.__index__" => "Return self converted to an integer, if self is suitable for use as an index into a list.",
+    "_weakref.ProxyType.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_weakref.ProxyType.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_weakref.ProxyType.__int__" => "int(self)",
+    "_weakref.ProxyType.__invert__" => "~self",
+    "_weakref.ProxyType.__ior__" => "Return self|=value.",
+    "_weakref.ProxyType.__ipow__" => "Return self**=value.",
+    "_weakref.ProxyType.__irshift__" => "Return self>>=value.",
+    "_weakref.ProxyType.__isub__" => "Return self-=value.",
+    "_weakref.ProxyType.__iter__" => "Implement iter(self).",
+    "_weakref.ProxyType.__itruediv__" => "Return self/=value.",
+    "_weakref.ProxyType.__ixor__" => "Return self^=value.",
+    "_weakref.ProxyType.__le__" => "Return self<=value.",
+    "_weakref.ProxyType.__len__" => "Return len(self).",
+    "_weakref.ProxyType.__lshift__" => "Return self<<value.",
+    "_weakref.ProxyType.__lt__" => "Return self<value.",
+    "_weakref.ProxyType.__matmul__" => "Return self@value.",
+    "_weakref.ProxyType.__mod__" => "Return self%value.",
+    "_weakref.ProxyType.__mul__" => "Return self*value.",
+    "_weakref.ProxyType.__ne__" => "Return self!=value.",
+    "_weakref.ProxyType.__neg__" => "-self",
+    "_weakref.ProxyType.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_weakref.ProxyType.__next__" => "Implement next(self).",
+    "_weakref.ProxyType.__or__" => "Return self|value.",
+    "_weakref.ProxyType.__pos__" => "+self",
+    "_weakref.ProxyType.__pow__" => "Return pow(self, value, mod).",
+    "_weakref.ProxyType.__radd__" => "Return value+self.",
+    "_weakref.ProxyType.__rand__" => "Return value&self.",
+    "_weakref.ProxyType.__rdivmod__" => "Return divmod(value, self).",
+    "_weakref.ProxyType.__reduce__" => "Helper for pickle.",
+    "_weakref.ProxyType.__reduce_ex__" => "Helper for pickle.",
+    "_weakref.ProxyType.__repr__" => "Return repr(self).",
+    "_weakref.ProxyType.__rfloordiv__" => "Return value//self.",
+    "_weakref.ProxyType.__rlshift__" => "Return value<<self.",
+    "_weakref.ProxyType.__rmatmul__" => "Return value@self.",
+    "_weakref.ProxyType.__rmod__" => "Return value%self.",
+    "_weakref.ProxyType.__rmul__" => "Return value*self.",
+    "_weakref.ProxyType.__ror__" => "Return value|self.",
+    "_weakref.ProxyType.__rpow__" => "Return pow(value, self, mod).",
+    "_weakref.ProxyType.__rrshift__" => "Return value>>self.",
+    "_weakref.ProxyType.__rshift__" => "Return self>>value.",
+    "_weakref.ProxyType.__rsub__" => "Return value-self.",
+    "_weakref.ProxyType.__rtruediv__" => "Return value/self.",
+    "_weakref.ProxyType.__rxor__" => "Return value^self.",
+    "_weakref.ProxyType.__setattr__" => "Implement setattr(self, name, value).",
+    "_weakref.ProxyType.__setitem__" => "Set self[key] to value.",
+    "_weakref.ProxyType.__sizeof__" => "Size of object in memory, in bytes.",
+    "_weakref.ProxyType.__str__" => "Return str(self).",
+    "_weakref.ProxyType.__sub__" => "Return self-value.",
+    "_weakref.ProxyType.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_weakref.ProxyType.__truediv__" => "Return self/value.",
+    "_weakref.ProxyType.__xor__" => "Return self^value.",
+    "_weakref.ReferenceType.__call__" => "Call self as a function.",
+    "_weakref.ReferenceType.__class_getitem__" => "See PEP 585",
+    "_weakref.ReferenceType.__delattr__" => "Implement delattr(self, name).",
+    "_weakref.ReferenceType.__eq__" => "Return self==value.",
+    "_weakref.ReferenceType.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_weakref.ReferenceType.__ge__" => "Return self>=value.",
+    "_weakref.ReferenceType.__getattribute__" => "Return getattr(self, name).",
+    "_weakref.ReferenceType.__getstate__" => "Helper for pickle.",
+    "_weakref.ReferenceType.__gt__" => "Return self>value.",
+    "_weakref.ReferenceType.__hash__" => "Return hash(self).",
+    "_weakref.ReferenceType.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_weakref.ReferenceType.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_weakref.ReferenceType.__le__" => "Return self<=value.",
+    "_weakref.ReferenceType.__lt__" => "Return self<value.",
+    "_weakref.ReferenceType.__ne__" => "Return self!=value.",
+    "_weakref.ReferenceType.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_weakref.ReferenceType.__reduce__" => "Helper for pickle.",
+    "_weakref.ReferenceType.__reduce_ex__" => "Helper for pickle.",
+    "_weakref.ReferenceType.__repr__" => "Return repr(self).",
+    "_weakref.ReferenceType.__setattr__" => "Implement setattr(self, name, value).",
+    "_weakref.ReferenceType.__sizeof__" => "Size of object in memory, in bytes.",
+    "_weakref.ReferenceType.__str__" => "Return str(self).",
+    "_weakref.ReferenceType.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
     "_weakref._remove_dead_weakref" => "Atomically remove key from dict if it points to a dead weakref.",
     "_weakref.getweakrefcount" => "Return the number of weak references to 'object'.",
     "_weakref.getweakrefs" => "Return a list of all weak reference objects pointing to 'object'.",
     "_weakref.proxy" => "Create a proxy object that weakly references 'object'.\n\n'callback', if given, is called with a reference to the\nproxy when 'object' is about to be finalized.",
+    "_weakref.ref.__call__" => "Call self as a function.",
+    "_weakref.ref.__class_getitem__" => "See PEP 585",
+    "_weakref.ref.__delattr__" => "Implement delattr(self, name).",
+    "_weakref.ref.__eq__" => "Return self==value.",
+    "_weakref.ref.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_weakref.ref.__ge__" => "Return self>=value.",
+    "_weakref.ref.__getattribute__" => "Return getattr(self, name).",
+    "_weakref.ref.__getstate__" => "Helper for pickle.",
+    "_weakref.ref.__gt__" => "Return self>value.",
+    "_weakref.ref.__hash__" => "Return hash(self).",
+    "_weakref.ref.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_weakref.ref.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_weakref.ref.__le__" => "Return self<=value.",
+    "_weakref.ref.__lt__" => "Return self<value.",
+    "_weakref.ref.__ne__" => "Return self!=value.",
+    "_weakref.ref.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_weakref.ref.__reduce__" => "Helper for pickle.",
+    "_weakref.ref.__reduce_ex__" => "Helper for pickle.",
+    "_weakref.ref.__repr__" => "Return repr(self).",
+    "_weakref.ref.__setattr__" => "Implement setattr(self, name, value).",
+    "_weakref.ref.__sizeof__" => "Size of object in memory, in bytes.",
+    "_weakref.ref.__str__" => "Return str(self).",
+    "_weakref.ref.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
     "_winapi.BatchedWaitForMultipleObjects" => "Supports a larger number of handles than WaitForMultipleObjects\n\nNote that the handles may be waited on other threads, which could cause\nissues for objects like mutexes that become associated with the thread\nthat was waiting for them. Objects may also be left signalled, even if\nthe wait fails.\n\nIt is recommended to use WaitForMultipleObjects whenever possible, and\nonly switch to BatchedWaitForMultipleObjects for scenarios where you\ncontrol all the handles involved, such as your own thread pool or\nfiles, and all wait objects are left unmodified by a wait (for example,\nmanual reset events, threads, and files/pipes).\n\nOverlapped handles returned from this module use manual reset events.",
     "_winapi.CloseHandle" => "Close handle.",
     "_winapi.CopyFile2" => "Copies a file from one name to a new name.\n\nThis is implemented using the CopyFile2 API, which preserves all stat\nand metadata information apart from security attributes.\n\nprogress_routine is reserved for future use, but is currently not\nimplemented. Its value is ignored.",
@@ -3448,6 +9297,142 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "_winapi._mimetypes_read_windows_registry" => "Optimized function for reading all known MIME types from the registry.\n\n*on_type_read* is a callable taking *type* and *ext* arguments, as for\nMimeTypes.add_type.",
     "_wmi.exec_query" => "Runs a WMI query against the local machine.\n\nThis returns a single string with 'name=value' pairs in a flat array separated\nby null characters.",
     "_zoneinfo" => "C implementation of the zoneinfo module",
+    "_zoneinfo.ZoneInfo.__delattr__" => "Implement delattr(self, name).",
+    "_zoneinfo.ZoneInfo.__eq__" => "Return self==value.",
+    "_zoneinfo.ZoneInfo.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_zoneinfo.ZoneInfo.__ge__" => "Return self>=value.",
+    "_zoneinfo.ZoneInfo.__getattribute__" => "Return getattr(self, name).",
+    "_zoneinfo.ZoneInfo.__getstate__" => "Helper for pickle.",
+    "_zoneinfo.ZoneInfo.__gt__" => "Return self>value.",
+    "_zoneinfo.ZoneInfo.__hash__" => "Return hash(self).",
+    "_zoneinfo.ZoneInfo.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_zoneinfo.ZoneInfo.__init_subclass__" => "Function to initialize subclasses.",
+    "_zoneinfo.ZoneInfo.__le__" => "Return self<=value.",
+    "_zoneinfo.ZoneInfo.__lt__" => "Return self<value.",
+    "_zoneinfo.ZoneInfo.__ne__" => "Return self!=value.",
+    "_zoneinfo.ZoneInfo.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_zoneinfo.ZoneInfo.__reduce__" => "Function for serialization with the pickle protocol.",
+    "_zoneinfo.ZoneInfo.__reduce_ex__" => "Helper for pickle.",
+    "_zoneinfo.ZoneInfo.__repr__" => "Return repr(self).",
+    "_zoneinfo.ZoneInfo.__setattr__" => "Implement setattr(self, name, value).",
+    "_zoneinfo.ZoneInfo.__sizeof__" => "Size of object in memory, in bytes.",
+    "_zoneinfo.ZoneInfo.__str__" => "Return str(self).",
+    "_zoneinfo.ZoneInfo.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_zoneinfo.ZoneInfo.dst" => "Retrieve a timedelta representing the amount of DST applied in a zone at the given datetime.",
+    "_zoneinfo.ZoneInfo.fromutc" => "Given a datetime with local time in UTC, retrieve an adjusted datetime in local time.",
+    "_zoneinfo.ZoneInfo.tzname" => "Retrieve a string containing the abbreviation for the time zone that applies in a zone at a given datetime.",
+    "_zoneinfo.ZoneInfo.utcoffset" => "Retrieve a timedelta representing the UTC offset in a zone at the given datetime.",
+    "_zstd" => "Implementation module for Zstandard compression.",
+    "_zstd.ZstdCompressor" => "Create a compressor object for compressing data incrementally.\n\n  level\n    The compression level to use. Defaults to COMPRESSION_LEVEL_DEFAULT.\n  options\n    A dict object that contains advanced compression parameters.\n  zstd_dict\n    A ZstdDict object, a pre-trained Zstandard dictionary.\n\nThread-safe at method level. For one-shot compression, use the compress()\nfunction instead.",
+    "_zstd.ZstdCompressor.__delattr__" => "Implement delattr(self, name).",
+    "_zstd.ZstdCompressor.__eq__" => "Return self==value.",
+    "_zstd.ZstdCompressor.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_zstd.ZstdCompressor.__ge__" => "Return self>=value.",
+    "_zstd.ZstdCompressor.__getattribute__" => "Return getattr(self, name).",
+    "_zstd.ZstdCompressor.__getstate__" => "Helper for pickle.",
+    "_zstd.ZstdCompressor.__gt__" => "Return self>value.",
+    "_zstd.ZstdCompressor.__hash__" => "Return hash(self).",
+    "_zstd.ZstdCompressor.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_zstd.ZstdCompressor.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_zstd.ZstdCompressor.__le__" => "Return self<=value.",
+    "_zstd.ZstdCompressor.__lt__" => "Return self<value.",
+    "_zstd.ZstdCompressor.__ne__" => "Return self!=value.",
+    "_zstd.ZstdCompressor.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_zstd.ZstdCompressor.__reduce__" => "Helper for pickle.",
+    "_zstd.ZstdCompressor.__reduce_ex__" => "Helper for pickle.",
+    "_zstd.ZstdCompressor.__repr__" => "Return repr(self).",
+    "_zstd.ZstdCompressor.__setattr__" => "Implement setattr(self, name, value).",
+    "_zstd.ZstdCompressor.__sizeof__" => "Size of object in memory, in bytes.",
+    "_zstd.ZstdCompressor.__str__" => "Return str(self).",
+    "_zstd.ZstdCompressor.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_zstd.ZstdCompressor.compress" => "Provide data to the compressor object.\n\n  mode\n    Can be these 3 values ZstdCompressor.CONTINUE,\n    ZstdCompressor.FLUSH_BLOCK, ZstdCompressor.FLUSH_FRAME\n\nReturn a chunk of compressed data if possible, or b'' otherwise. When you have\nfinished providing data to the compressor, call the flush() method to finish\nthe compression process.",
+    "_zstd.ZstdCompressor.flush" => "Finish the compression process.\n\n  mode\n    Can be these 2 values ZstdCompressor.FLUSH_FRAME,\n    ZstdCompressor.FLUSH_BLOCK\n\nFlush any remaining data left in internal buffers. Since Zstandard data\nconsists of one or more independent frames, the compressor object can still\nbe used after this method is called.",
+    "_zstd.ZstdCompressor.last_mode" => "The last mode used to this compressor object, its value can be .CONTINUE,\n.FLUSH_BLOCK, .FLUSH_FRAME. Initialized to .FLUSH_FRAME.\n\nIt can be used to get the current state of a compressor, such as, data\nflushed, or a frame ended.",
+    "_zstd.ZstdCompressor.set_pledged_input_size" => "Set the uncompressed content size to be written into the frame header.\n\n  size\n    The size of the uncompressed data to be provided to the compressor.\n\nThis method can be used to ensure the header of the frame about to be written\nincludes the size of the data, unless the CompressionParameter.content_size_flag\nis set to False. If last_mode != FLUSH_FRAME, then a RuntimeError is raised.\n\nIt is important to ensure that the pledged data size matches the actual data\nsize. If they do not match the compressed output data may be corrupted and the\nfinal chunk written may be lost.",
+    "_zstd.ZstdDecompressor" => "Create a decompressor object for decompressing data incrementally.\n\n  zstd_dict\n    A ZstdDict object, a pre-trained Zstandard dictionary.\n  options\n    A dict object that contains advanced decompression parameters.\n\nThread-safe at method level. For one-shot decompression, use the decompress()\nfunction instead.",
+    "_zstd.ZstdDecompressor.__delattr__" => "Implement delattr(self, name).",
+    "_zstd.ZstdDecompressor.__eq__" => "Return self==value.",
+    "_zstd.ZstdDecompressor.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_zstd.ZstdDecompressor.__ge__" => "Return self>=value.",
+    "_zstd.ZstdDecompressor.__getattribute__" => "Return getattr(self, name).",
+    "_zstd.ZstdDecompressor.__getstate__" => "Helper for pickle.",
+    "_zstd.ZstdDecompressor.__gt__" => "Return self>value.",
+    "_zstd.ZstdDecompressor.__hash__" => "Return hash(self).",
+    "_zstd.ZstdDecompressor.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_zstd.ZstdDecompressor.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_zstd.ZstdDecompressor.__le__" => "Return self<=value.",
+    "_zstd.ZstdDecompressor.__lt__" => "Return self<value.",
+    "_zstd.ZstdDecompressor.__ne__" => "Return self!=value.",
+    "_zstd.ZstdDecompressor.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_zstd.ZstdDecompressor.__reduce__" => "Helper for pickle.",
+    "_zstd.ZstdDecompressor.__reduce_ex__" => "Helper for pickle.",
+    "_zstd.ZstdDecompressor.__repr__" => "Return repr(self).",
+    "_zstd.ZstdDecompressor.__setattr__" => "Implement setattr(self, name, value).",
+    "_zstd.ZstdDecompressor.__sizeof__" => "Size of object in memory, in bytes.",
+    "_zstd.ZstdDecompressor.__str__" => "Return str(self).",
+    "_zstd.ZstdDecompressor.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_zstd.ZstdDecompressor.decompress" => "Decompress *data*, returning uncompressed bytes if possible, or b'' otherwise.\n\n  data\n    A bytes-like object, Zstandard data to be decompressed.\n  max_length\n    Maximum size of returned data. When it is negative, the size of\n    output buffer is unlimited. When it is nonnegative, returns at\n    most max_length bytes of decompressed data.\n\nIf *max_length* is nonnegative, returns at most *max_length* bytes of\ndecompressed data. If this limit is reached and further output can be\nproduced, *self.needs_input* will be set to ``False``. In this case, the next\ncall to *decompress()* may provide *data* as b'' to obtain more of the output.\n\nIf all of the input data was decompressed and returned (either because this\nwas less than *max_length* bytes, or because *max_length* was negative),\n*self.needs_input* will be set to True.\n\nAttempting to decompress data after the end of a frame is reached raises an\nEOFError. Any data found after the end of the frame is ignored and saved in\nthe self.unused_data attribute.",
+    "_zstd.ZstdDecompressor.eof" => "True means the end of the first frame has been reached. If decompress data\nafter that, an EOFError exception will be raised.",
+    "_zstd.ZstdDecompressor.needs_input" => "If the max_length output limit in .decompress() method has been reached,\nand the decompressor has (or may has) unconsumed input data, it will be set\nto False. In this case, passing b'' to the .decompress() method may output\nfurther data.",
+    "_zstd.ZstdDecompressor.unused_data" => "A bytes object of un-consumed input data.\n\nWhen ZstdDecompressor object stops after a frame is\ndecompressed, unused input data after the frame. Otherwise this will be b''.",
+    "_zstd.ZstdDict" => "Represents a Zstandard dictionary.\n\n  dict_content\n    The content of a Zstandard dictionary as a bytes-like object.\n  is_raw\n    If true, perform no checks on *dict_content*, useful for some\n    advanced cases. Otherwise, check that the content represents\n    a Zstandard dictionary created by the zstd library or CLI.\n\nThe dictionary can be used for compression or decompression, and can be shared\nby multiple ZstdCompressor or ZstdDecompressor objects.",
+    "_zstd.ZstdDict.__delattr__" => "Implement delattr(self, name).",
+    "_zstd.ZstdDict.__eq__" => "Return self==value.",
+    "_zstd.ZstdDict.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_zstd.ZstdDict.__ge__" => "Return self>=value.",
+    "_zstd.ZstdDict.__getattribute__" => "Return getattr(self, name).",
+    "_zstd.ZstdDict.__getstate__" => "Helper for pickle.",
+    "_zstd.ZstdDict.__gt__" => "Return self>value.",
+    "_zstd.ZstdDict.__hash__" => "Return hash(self).",
+    "_zstd.ZstdDict.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_zstd.ZstdDict.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_zstd.ZstdDict.__le__" => "Return self<=value.",
+    "_zstd.ZstdDict.__len__" => "Return len(self).",
+    "_zstd.ZstdDict.__lt__" => "Return self<value.",
+    "_zstd.ZstdDict.__ne__" => "Return self!=value.",
+    "_zstd.ZstdDict.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_zstd.ZstdDict.__reduce__" => "Helper for pickle.",
+    "_zstd.ZstdDict.__reduce_ex__" => "Helper for pickle.",
+    "_zstd.ZstdDict.__repr__" => "Return repr(self).",
+    "_zstd.ZstdDict.__setattr__" => "Implement setattr(self, name, value).",
+    "_zstd.ZstdDict.__sizeof__" => "Size of object in memory, in bytes.",
+    "_zstd.ZstdDict.__str__" => "Return str(self).",
+    "_zstd.ZstdDict.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_zstd.ZstdDict.as_digested_dict" => "Load as a digested dictionary to compressor.\n\nPass this attribute as zstd_dict argument:\ncompress(dat, zstd_dict=zd.as_digested_dict)\n\n1. Some advanced compression parameters of compressor may be overridden\n   by parameters of digested dictionary.\n2. ZstdDict has a digested dictionaries cache for each compression level.\n   It's faster when loading again a digested dictionary with the same\n   compression level.\n3. No need to use this for decompression.",
+    "_zstd.ZstdDict.as_prefix" => "Load as a prefix to compressor/decompressor.\n\nPass this attribute as zstd_dict argument:\ncompress(dat, zstd_dict=zd.as_prefix)\n\n1. Prefix is compatible with long distance matching, while dictionary is not.\n2. It only works for the first frame, then the compressor/decompressor will\n   return to no prefix state.\n3. When decompressing, must use the same prefix as when compressing.",
+    "_zstd.ZstdDict.as_undigested_dict" => "Load as an undigested dictionary to compressor.\n\nPass this attribute as zstd_dict argument:\ncompress(dat, zstd_dict=zd.as_undigested_dict)\n\n1. The advanced compression parameters of compressor will not be overridden.\n2. Loading an undigested dictionary is costly. If load an undigested dictionary\n   multiple times, consider reusing a compressor object.\n3. No need to use this for decompression.",
+    "_zstd.ZstdDict.dict_content" => "The content of a Zstandard dictionary, as a bytes object.",
+    "_zstd.ZstdDict.dict_id" => "The Zstandard dictionary, an int between 0 and 2**32.\n\nA non-zero value represents an ordinary Zstandard dictionary,\nconforming to the standardised format.\n\nA value of zero indicates a 'raw content' dictionary,\nwithout any restrictions on format or content.",
+    "_zstd.ZstdError" => "An error occurred in the zstd library.",
+    "_zstd.ZstdError.__delattr__" => "Implement delattr(self, name).",
+    "_zstd.ZstdError.__eq__" => "Return self==value.",
+    "_zstd.ZstdError.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_zstd.ZstdError.__ge__" => "Return self>=value.",
+    "_zstd.ZstdError.__getattribute__" => "Return getattr(self, name).",
+    "_zstd.ZstdError.__getstate__" => "Helper for pickle.",
+    "_zstd.ZstdError.__gt__" => "Return self>value.",
+    "_zstd.ZstdError.__hash__" => "Return hash(self).",
+    "_zstd.ZstdError.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_zstd.ZstdError.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_zstd.ZstdError.__le__" => "Return self<=value.",
+    "_zstd.ZstdError.__lt__" => "Return self<value.",
+    "_zstd.ZstdError.__ne__" => "Return self!=value.",
+    "_zstd.ZstdError.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_zstd.ZstdError.__reduce_ex__" => "Helper for pickle.",
+    "_zstd.ZstdError.__repr__" => "Return repr(self).",
+    "_zstd.ZstdError.__setattr__" => "Implement setattr(self, name, value).",
+    "_zstd.ZstdError.__sizeof__" => "Size of object in memory, in bytes.",
+    "_zstd.ZstdError.__str__" => "Return str(self).",
+    "_zstd.ZstdError.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_zstd.ZstdError.__weakref__" => "list of weak references to the object",
+    "_zstd.ZstdError.add_note" => "Add a note to the exception",
+    "_zstd.ZstdError.with_traceback" => "Set self.__traceback__ to tb and return self.",
+    "_zstd.finalize_dict" => "Finalize a Zstandard dictionary.\n\n  custom_dict_bytes\n    Custom dictionary content.\n  samples_bytes\n    Concatenation of samples.\n  samples_sizes\n    Tuple of samples' sizes.\n  dict_size\n    The size of the dictionary.\n  compression_level\n    Optimize for a specific Zstandard compression level, 0 means default.",
+    "_zstd.get_frame_info" => "Get Zstandard frame infomation from a frame header.\n\n  frame_buffer\n    A bytes-like object, containing the header of a Zstandard frame.",
+    "_zstd.get_frame_size" => "Get the size of a Zstandard frame, including the header and optional checksum.\n\n  frame_buffer\n    A bytes-like object, it should start from the beginning of a frame,\n    and contains at least one complete frame.",
+    "_zstd.get_param_bounds" => "Get CompressionParameter/DecompressionParameter bounds.\n\n  parameter\n    The parameter to get bounds.\n  is_compress\n    True for CompressionParameter, False for DecompressionParameter.",
+    "_zstd.set_parameter_types" => "Set CompressionParameter and DecompressionParameter types for validity check.\n\n  c_parameter_type\n    CompressionParameter IntEnum type object\n  d_parameter_type\n    DecompressionParameter IntEnum type object",
+    "_zstd.train_dict" => "Train a Zstandard dictionary on sample data.\n\n  samples_bytes\n    Concatenation of samples.\n  samples_sizes\n    Tuple of samples' sizes.\n  dict_size\n    The size of the dictionary.",
     "array" => "This module defines an object type which can efficiently represent\nan array of basic values: characters, integers, floating-point\nnumbers.  Arrays are sequence types and behave very much like lists,\nexcept that the type of objects stored in them is constrained.",
     "array.ArrayType" => "array(typecode [, initializer]) -> array\n\nReturn a new array whose items are restricted by typecode, and\ninitialized from the optional initializer value, which must be a list,\nstring or iterable over elements of the appropriate type.\n\nArrays represent basic values and behave very much like lists, except\nthe type of objects stored in them is constrained. The type is specified\nat object creation time by using a type code, which is a single character.\nThe following type codes are defined:\n\n    Type code   C Type             Minimum size in bytes\n    'b'         signed integer     1\n    'B'         unsigned integer   1\n    'u'         Unicode character  2 (see note)\n    'h'         signed integer     2\n    'H'         unsigned integer   2\n    'i'         signed integer     2\n    'I'         unsigned integer   2\n    'l'         signed integer     4\n    'L'         unsigned integer   4\n    'q'         signed integer     8 (see note)\n    'Q'         unsigned integer   8 (see note)\n    'f'         floating-point     4\n    'd'         floating-point     8\n\nNOTE: The 'u' typecode corresponds to Python's unicode character. On\nnarrow builds this is 2-bytes on wide builds this is 4-bytes.\n\nNOTE: The 'q' and 'Q' type codes are only available if the platform\nC compiler used to build Python supports 'long long', or, on Windows,\n'__int64'.\n\nMethods:\n\nappend() -- append a new item to the end of the array\nbuffer_info() -- return information giving the current memory info\nbyteswap() -- byteswap all the items of the array\ncount() -- return number of occurrences of an object\nextend() -- extend array by appending multiple elements from an iterable\nfromfile() -- read items from a file object\nfromlist() -- append items from the list\nfrombytes() -- append items from the string\nindex() -- return index of first occurrence of an object\ninsert() -- insert a new item into the array at a provided position\npop() -- remove and return item (default last)\nremove() -- remove first occurrence of an object\nreverse() -- reverse the order of the items in the array\ntofile() -- write all items to a file object\ntolist() -- return the array converted to an ordinary list\ntobytes() -- return the array converted to a string\n\nAttributes:\n\ntypecode -- the typecode character used to create the array\nitemsize -- the length in bytes of one array item",
     "array.ArrayType.__add__" => "Return self+value.",
@@ -3570,11 +9555,9 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "atexit._clear" => "Clear the list of previously registered exit functions.",
     "atexit._ncallbacks" => "Return the number of registered exit functions.",
     "atexit._run_exitfuncs" => "Run all registered exit functions.\n\nIf a callback raises an exception, it is logged with sys.unraisablehook.",
-    "atexit.register" => "Register a function to be executed upon normal program termination\n\nfunc - function to be called at exit\nargs - optional arguments to pass to func\nkwargs - optional keyword arguments to pass to func\n\nfunc is returned to facilitate usage as a decorator.",
+    "atexit.register" => "Register a function to be executed upon normal program termination\n\n    func - function to be called at exit\n    args - optional arguments to pass to func\n    kwargs - optional keyword arguments to pass to func\n\n    func is returned to facilitate usage as a decorator.",
     "atexit.unregister" => "Unregister an exit function which was previously registered using\natexit.register\n\n    func - function to be unregistered",
     "binascii" => "Conversion between binary data and ASCII",
-    "binascii.Error.__cause__" => "exception cause",
-    "binascii.Error.__context__" => "exception context",
     "binascii.Error.__delattr__" => "Implement delattr(self, name).",
     "binascii.Error.__eq__" => "Return self==value.",
     "binascii.Error.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
@@ -3596,10 +9579,8 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "binascii.Error.__str__" => "Return str(self).",
     "binascii.Error.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
     "binascii.Error.__weakref__" => "list of weak references to the object",
-    "binascii.Error.add_note" => "Exception.add_note(note) --\nadd a note to the exception",
-    "binascii.Error.with_traceback" => "Exception.with_traceback(tb) --\nset self.__traceback__ to tb and return self.",
-    "binascii.Incomplete.__cause__" => "exception cause",
-    "binascii.Incomplete.__context__" => "exception context",
+    "binascii.Error.add_note" => "Add a note to the exception",
+    "binascii.Error.with_traceback" => "Set self.__traceback__ to tb and return self.",
     "binascii.Incomplete.__delattr__" => "Implement delattr(self, name).",
     "binascii.Incomplete.__eq__" => "Return self==value.",
     "binascii.Incomplete.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
@@ -3621,9 +9602,9 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "binascii.Incomplete.__str__" => "Return str(self).",
     "binascii.Incomplete.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
     "binascii.Incomplete.__weakref__" => "list of weak references to the object",
-    "binascii.Incomplete.add_note" => "Exception.add_note(note) --\nadd a note to the exception",
-    "binascii.Incomplete.with_traceback" => "Exception.with_traceback(tb) --\nset self.__traceback__ to tb and return self.",
-    "binascii.a2b_base64" => "Decode a line of base64 data.\n\nstrict_mode\n  When set to True, bytes that are not part of the base64 standard are not allowed.\n  The same applies to excess data after padding (= / ==).",
+    "binascii.Incomplete.add_note" => "Add a note to the exception",
+    "binascii.Incomplete.with_traceback" => "Set self.__traceback__ to tb and return self.",
+    "binascii.a2b_base64" => "Decode a line of base64 data.\n\n  strict_mode\n    When set to True, bytes that are not part of the base64 standard are not allowed.\n    The same applies to excess data after padding (= / ==).",
     "binascii.a2b_hex" => "Binary data of hexadecimal representation.\n\nhexstr must contain an even number of hex digits (upper or lower case).\nThis function is also available as \"unhexlify()\".",
     "binascii.a2b_qp" => "Decode a string of qp-encoded data.",
     "binascii.a2b_uu" => "Decode a line of uuencoded data.",
@@ -3637,8 +9618,6 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "binascii.unhexlify" => "Binary data of hexadecimal representation.\n\nhexstr must contain an even number of hex digits (upper or lower case).",
     "builtins" => "Built-in functions, types, exceptions, and other objects.\n\nThis module provides direct access to all 'built-in'\nidentifiers of Python; for example, builtins.len is\nthe full name for the built-in function len().\n\nThis module is not normally accessed explicitly by most\napplications, but can be useful in modules that provide\nobjects with the same name as a built-in value, but in\nwhich the built-in of that name is also needed.",
     "builtins.ArithmeticError" => "Base class for arithmetic errors.",
-    "builtins.ArithmeticError.__cause__" => "exception cause",
-    "builtins.ArithmeticError.__context__" => "exception context",
     "builtins.ArithmeticError.__delattr__" => "Implement delattr(self, name).",
     "builtins.ArithmeticError.__eq__" => "Return self==value.",
     "builtins.ArithmeticError.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
@@ -3659,11 +9638,9 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "builtins.ArithmeticError.__sizeof__" => "Size of object in memory, in bytes.",
     "builtins.ArithmeticError.__str__" => "Return str(self).",
     "builtins.ArithmeticError.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
-    "builtins.ArithmeticError.add_note" => "Exception.add_note(note) --\nadd a note to the exception",
-    "builtins.ArithmeticError.with_traceback" => "Exception.with_traceback(tb) --\nset self.__traceback__ to tb and return self.",
+    "builtins.ArithmeticError.add_note" => "Add a note to the exception",
+    "builtins.ArithmeticError.with_traceback" => "Set self.__traceback__ to tb and return self.",
     "builtins.AssertionError" => "Assertion failed.",
-    "builtins.AssertionError.__cause__" => "exception cause",
-    "builtins.AssertionError.__context__" => "exception context",
     "builtins.AssertionError.__delattr__" => "Implement delattr(self, name).",
     "builtins.AssertionError.__eq__" => "Return self==value.",
     "builtins.AssertionError.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
@@ -3684,11 +9661,9 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "builtins.AssertionError.__sizeof__" => "Size of object in memory, in bytes.",
     "builtins.AssertionError.__str__" => "Return str(self).",
     "builtins.AssertionError.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
-    "builtins.AssertionError.add_note" => "Exception.add_note(note) --\nadd a note to the exception",
-    "builtins.AssertionError.with_traceback" => "Exception.with_traceback(tb) --\nset self.__traceback__ to tb and return self.",
+    "builtins.AssertionError.add_note" => "Add a note to the exception",
+    "builtins.AssertionError.with_traceback" => "Set self.__traceback__ to tb and return self.",
     "builtins.AttributeError" => "Attribute not found.",
-    "builtins.AttributeError.__cause__" => "exception cause",
-    "builtins.AttributeError.__context__" => "exception context",
     "builtins.AttributeError.__delattr__" => "Implement delattr(self, name).",
     "builtins.AttributeError.__eq__" => "Return self==value.",
     "builtins.AttributeError.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
@@ -3708,13 +9683,11 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "builtins.AttributeError.__sizeof__" => "Size of object in memory, in bytes.",
     "builtins.AttributeError.__str__" => "Return str(self).",
     "builtins.AttributeError.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
-    "builtins.AttributeError.add_note" => "Exception.add_note(note) --\nadd a note to the exception",
+    "builtins.AttributeError.add_note" => "Add a note to the exception",
     "builtins.AttributeError.name" => "attribute name",
     "builtins.AttributeError.obj" => "object",
-    "builtins.AttributeError.with_traceback" => "Exception.with_traceback(tb) --\nset self.__traceback__ to tb and return self.",
+    "builtins.AttributeError.with_traceback" => "Set self.__traceback__ to tb and return self.",
     "builtins.BaseException" => "Common base class for all exceptions",
-    "builtins.BaseException.__cause__" => "exception cause",
-    "builtins.BaseException.__context__" => "exception context",
     "builtins.BaseException.__delattr__" => "Implement delattr(self, name).",
     "builtins.BaseException.__eq__" => "Return self==value.",
     "builtins.BaseException.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
@@ -3735,12 +9708,10 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "builtins.BaseException.__sizeof__" => "Size of object in memory, in bytes.",
     "builtins.BaseException.__str__" => "Return str(self).",
     "builtins.BaseException.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
-    "builtins.BaseException.add_note" => "Exception.add_note(note) --\nadd a note to the exception",
-    "builtins.BaseException.with_traceback" => "Exception.with_traceback(tb) --\nset self.__traceback__ to tb and return self.",
+    "builtins.BaseException.add_note" => "Add a note to the exception",
+    "builtins.BaseException.with_traceback" => "Set self.__traceback__ to tb and return self.",
     "builtins.BaseExceptionGroup" => "A combination of multiple unrelated exceptions.",
-    "builtins.BaseExceptionGroup.__cause__" => "exception cause",
     "builtins.BaseExceptionGroup.__class_getitem__" => "See PEP 585",
-    "builtins.BaseExceptionGroup.__context__" => "exception context",
     "builtins.BaseExceptionGroup.__delattr__" => "Implement delattr(self, name).",
     "builtins.BaseExceptionGroup.__eq__" => "Return self==value.",
     "builtins.BaseExceptionGroup.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
@@ -3761,13 +9732,11 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "builtins.BaseExceptionGroup.__sizeof__" => "Size of object in memory, in bytes.",
     "builtins.BaseExceptionGroup.__str__" => "Return str(self).",
     "builtins.BaseExceptionGroup.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
-    "builtins.BaseExceptionGroup.add_note" => "Exception.add_note(note) --\nadd a note to the exception",
+    "builtins.BaseExceptionGroup.add_note" => "Add a note to the exception",
     "builtins.BaseExceptionGroup.exceptions" => "nested exceptions",
     "builtins.BaseExceptionGroup.message" => "exception message",
-    "builtins.BaseExceptionGroup.with_traceback" => "Exception.with_traceback(tb) --\nset self.__traceback__ to tb and return self.",
+    "builtins.BaseExceptionGroup.with_traceback" => "Set self.__traceback__ to tb and return self.",
     "builtins.BlockingIOError" => "I/O operation would block.",
-    "builtins.BlockingIOError.__cause__" => "exception cause",
-    "builtins.BlockingIOError.__context__" => "exception context",
     "builtins.BlockingIOError.__delattr__" => "Implement delattr(self, name).",
     "builtins.BlockingIOError.__eq__" => "Return self==value.",
     "builtins.BlockingIOError.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
@@ -3788,16 +9757,14 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "builtins.BlockingIOError.__sizeof__" => "Size of object in memory, in bytes.",
     "builtins.BlockingIOError.__str__" => "Return str(self).",
     "builtins.BlockingIOError.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
-    "builtins.BlockingIOError.add_note" => "Exception.add_note(note) --\nadd a note to the exception",
+    "builtins.BlockingIOError.add_note" => "Add a note to the exception",
     "builtins.BlockingIOError.errno" => "POSIX exception code",
     "builtins.BlockingIOError.filename" => "exception filename",
     "builtins.BlockingIOError.filename2" => "second exception filename",
     "builtins.BlockingIOError.strerror" => "exception strerror",
     "builtins.BlockingIOError.winerror" => "Win32 exception code",
-    "builtins.BlockingIOError.with_traceback" => "Exception.with_traceback(tb) --\nset self.__traceback__ to tb and return self.",
+    "builtins.BlockingIOError.with_traceback" => "Set self.__traceback__ to tb and return self.",
     "builtins.BrokenPipeError" => "Broken pipe.",
-    "builtins.BrokenPipeError.__cause__" => "exception cause",
-    "builtins.BrokenPipeError.__context__" => "exception context",
     "builtins.BrokenPipeError.__delattr__" => "Implement delattr(self, name).",
     "builtins.BrokenPipeError.__eq__" => "Return self==value.",
     "builtins.BrokenPipeError.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
@@ -3818,16 +9785,14 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "builtins.BrokenPipeError.__sizeof__" => "Size of object in memory, in bytes.",
     "builtins.BrokenPipeError.__str__" => "Return str(self).",
     "builtins.BrokenPipeError.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
-    "builtins.BrokenPipeError.add_note" => "Exception.add_note(note) --\nadd a note to the exception",
+    "builtins.BrokenPipeError.add_note" => "Add a note to the exception",
     "builtins.BrokenPipeError.errno" => "POSIX exception code",
     "builtins.BrokenPipeError.filename" => "exception filename",
     "builtins.BrokenPipeError.filename2" => "second exception filename",
     "builtins.BrokenPipeError.strerror" => "exception strerror",
     "builtins.BrokenPipeError.winerror" => "Win32 exception code",
-    "builtins.BrokenPipeError.with_traceback" => "Exception.with_traceback(tb) --\nset self.__traceback__ to tb and return self.",
+    "builtins.BrokenPipeError.with_traceback" => "Set self.__traceback__ to tb and return self.",
     "builtins.BufferError" => "Buffer error.",
-    "builtins.BufferError.__cause__" => "exception cause",
-    "builtins.BufferError.__context__" => "exception context",
     "builtins.BufferError.__delattr__" => "Implement delattr(self, name).",
     "builtins.BufferError.__eq__" => "Return self==value.",
     "builtins.BufferError.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
@@ -3848,11 +9813,9 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "builtins.BufferError.__sizeof__" => "Size of object in memory, in bytes.",
     "builtins.BufferError.__str__" => "Return str(self).",
     "builtins.BufferError.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
-    "builtins.BufferError.add_note" => "Exception.add_note(note) --\nadd a note to the exception",
-    "builtins.BufferError.with_traceback" => "Exception.with_traceback(tb) --\nset self.__traceback__ to tb and return self.",
+    "builtins.BufferError.add_note" => "Add a note to the exception",
+    "builtins.BufferError.with_traceback" => "Set self.__traceback__ to tb and return self.",
     "builtins.BytesWarning" => "Base class for warnings about bytes and buffer related problems, mostly\nrelated to conversion from str or comparing to str.",
-    "builtins.BytesWarning.__cause__" => "exception cause",
-    "builtins.BytesWarning.__context__" => "exception context",
     "builtins.BytesWarning.__delattr__" => "Implement delattr(self, name).",
     "builtins.BytesWarning.__eq__" => "Return self==value.",
     "builtins.BytesWarning.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
@@ -3873,11 +9836,9 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "builtins.BytesWarning.__sizeof__" => "Size of object in memory, in bytes.",
     "builtins.BytesWarning.__str__" => "Return str(self).",
     "builtins.BytesWarning.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
-    "builtins.BytesWarning.add_note" => "Exception.add_note(note) --\nadd a note to the exception",
-    "builtins.BytesWarning.with_traceback" => "Exception.with_traceback(tb) --\nset self.__traceback__ to tb and return self.",
+    "builtins.BytesWarning.add_note" => "Add a note to the exception",
+    "builtins.BytesWarning.with_traceback" => "Set self.__traceback__ to tb and return self.",
     "builtins.ChildProcessError" => "Child process error.",
-    "builtins.ChildProcessError.__cause__" => "exception cause",
-    "builtins.ChildProcessError.__context__" => "exception context",
     "builtins.ChildProcessError.__delattr__" => "Implement delattr(self, name).",
     "builtins.ChildProcessError.__eq__" => "Return self==value.",
     "builtins.ChildProcessError.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
@@ -3898,16 +9859,14 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "builtins.ChildProcessError.__sizeof__" => "Size of object in memory, in bytes.",
     "builtins.ChildProcessError.__str__" => "Return str(self).",
     "builtins.ChildProcessError.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
-    "builtins.ChildProcessError.add_note" => "Exception.add_note(note) --\nadd a note to the exception",
+    "builtins.ChildProcessError.add_note" => "Add a note to the exception",
     "builtins.ChildProcessError.errno" => "POSIX exception code",
     "builtins.ChildProcessError.filename" => "exception filename",
     "builtins.ChildProcessError.filename2" => "second exception filename",
     "builtins.ChildProcessError.strerror" => "exception strerror",
     "builtins.ChildProcessError.winerror" => "Win32 exception code",
-    "builtins.ChildProcessError.with_traceback" => "Exception.with_traceback(tb) --\nset self.__traceback__ to tb and return self.",
+    "builtins.ChildProcessError.with_traceback" => "Set self.__traceback__ to tb and return self.",
     "builtins.ConnectionAbortedError" => "Connection aborted.",
-    "builtins.ConnectionAbortedError.__cause__" => "exception cause",
-    "builtins.ConnectionAbortedError.__context__" => "exception context",
     "builtins.ConnectionAbortedError.__delattr__" => "Implement delattr(self, name).",
     "builtins.ConnectionAbortedError.__eq__" => "Return self==value.",
     "builtins.ConnectionAbortedError.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
@@ -3928,16 +9887,14 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "builtins.ConnectionAbortedError.__sizeof__" => "Size of object in memory, in bytes.",
     "builtins.ConnectionAbortedError.__str__" => "Return str(self).",
     "builtins.ConnectionAbortedError.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
-    "builtins.ConnectionAbortedError.add_note" => "Exception.add_note(note) --\nadd a note to the exception",
+    "builtins.ConnectionAbortedError.add_note" => "Add a note to the exception",
     "builtins.ConnectionAbortedError.errno" => "POSIX exception code",
     "builtins.ConnectionAbortedError.filename" => "exception filename",
     "builtins.ConnectionAbortedError.filename2" => "second exception filename",
     "builtins.ConnectionAbortedError.strerror" => "exception strerror",
     "builtins.ConnectionAbortedError.winerror" => "Win32 exception code",
-    "builtins.ConnectionAbortedError.with_traceback" => "Exception.with_traceback(tb) --\nset self.__traceback__ to tb and return self.",
+    "builtins.ConnectionAbortedError.with_traceback" => "Set self.__traceback__ to tb and return self.",
     "builtins.ConnectionError" => "Connection error.",
-    "builtins.ConnectionError.__cause__" => "exception cause",
-    "builtins.ConnectionError.__context__" => "exception context",
     "builtins.ConnectionError.__delattr__" => "Implement delattr(self, name).",
     "builtins.ConnectionError.__eq__" => "Return self==value.",
     "builtins.ConnectionError.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
@@ -3958,16 +9915,14 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "builtins.ConnectionError.__sizeof__" => "Size of object in memory, in bytes.",
     "builtins.ConnectionError.__str__" => "Return str(self).",
     "builtins.ConnectionError.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
-    "builtins.ConnectionError.add_note" => "Exception.add_note(note) --\nadd a note to the exception",
+    "builtins.ConnectionError.add_note" => "Add a note to the exception",
     "builtins.ConnectionError.errno" => "POSIX exception code",
     "builtins.ConnectionError.filename" => "exception filename",
     "builtins.ConnectionError.filename2" => "second exception filename",
     "builtins.ConnectionError.strerror" => "exception strerror",
     "builtins.ConnectionError.winerror" => "Win32 exception code",
-    "builtins.ConnectionError.with_traceback" => "Exception.with_traceback(tb) --\nset self.__traceback__ to tb and return self.",
+    "builtins.ConnectionError.with_traceback" => "Set self.__traceback__ to tb and return self.",
     "builtins.ConnectionRefusedError" => "Connection refused.",
-    "builtins.ConnectionRefusedError.__cause__" => "exception cause",
-    "builtins.ConnectionRefusedError.__context__" => "exception context",
     "builtins.ConnectionRefusedError.__delattr__" => "Implement delattr(self, name).",
     "builtins.ConnectionRefusedError.__eq__" => "Return self==value.",
     "builtins.ConnectionRefusedError.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
@@ -3988,16 +9943,14 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "builtins.ConnectionRefusedError.__sizeof__" => "Size of object in memory, in bytes.",
     "builtins.ConnectionRefusedError.__str__" => "Return str(self).",
     "builtins.ConnectionRefusedError.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
-    "builtins.ConnectionRefusedError.add_note" => "Exception.add_note(note) --\nadd a note to the exception",
+    "builtins.ConnectionRefusedError.add_note" => "Add a note to the exception",
     "builtins.ConnectionRefusedError.errno" => "POSIX exception code",
     "builtins.ConnectionRefusedError.filename" => "exception filename",
     "builtins.ConnectionRefusedError.filename2" => "second exception filename",
     "builtins.ConnectionRefusedError.strerror" => "exception strerror",
     "builtins.ConnectionRefusedError.winerror" => "Win32 exception code",
-    "builtins.ConnectionRefusedError.with_traceback" => "Exception.with_traceback(tb) --\nset self.__traceback__ to tb and return self.",
+    "builtins.ConnectionRefusedError.with_traceback" => "Set self.__traceback__ to tb and return self.",
     "builtins.ConnectionResetError" => "Connection reset.",
-    "builtins.ConnectionResetError.__cause__" => "exception cause",
-    "builtins.ConnectionResetError.__context__" => "exception context",
     "builtins.ConnectionResetError.__delattr__" => "Implement delattr(self, name).",
     "builtins.ConnectionResetError.__eq__" => "Return self==value.",
     "builtins.ConnectionResetError.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
@@ -4018,16 +9971,14 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "builtins.ConnectionResetError.__sizeof__" => "Size of object in memory, in bytes.",
     "builtins.ConnectionResetError.__str__" => "Return str(self).",
     "builtins.ConnectionResetError.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
-    "builtins.ConnectionResetError.add_note" => "Exception.add_note(note) --\nadd a note to the exception",
+    "builtins.ConnectionResetError.add_note" => "Add a note to the exception",
     "builtins.ConnectionResetError.errno" => "POSIX exception code",
     "builtins.ConnectionResetError.filename" => "exception filename",
     "builtins.ConnectionResetError.filename2" => "second exception filename",
     "builtins.ConnectionResetError.strerror" => "exception strerror",
     "builtins.ConnectionResetError.winerror" => "Win32 exception code",
-    "builtins.ConnectionResetError.with_traceback" => "Exception.with_traceback(tb) --\nset self.__traceback__ to tb and return self.",
+    "builtins.ConnectionResetError.with_traceback" => "Set self.__traceback__ to tb and return self.",
     "builtins.DeprecationWarning" => "Base class for warnings about deprecated features.",
-    "builtins.DeprecationWarning.__cause__" => "exception cause",
-    "builtins.DeprecationWarning.__context__" => "exception context",
     "builtins.DeprecationWarning.__delattr__" => "Implement delattr(self, name).",
     "builtins.DeprecationWarning.__eq__" => "Return self==value.",
     "builtins.DeprecationWarning.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
@@ -4048,8 +9999,8 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "builtins.DeprecationWarning.__sizeof__" => "Size of object in memory, in bytes.",
     "builtins.DeprecationWarning.__str__" => "Return str(self).",
     "builtins.DeprecationWarning.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
-    "builtins.DeprecationWarning.add_note" => "Exception.add_note(note) --\nadd a note to the exception",
-    "builtins.DeprecationWarning.with_traceback" => "Exception.with_traceback(tb) --\nset self.__traceback__ to tb and return self.",
+    "builtins.DeprecationWarning.add_note" => "Add a note to the exception",
+    "builtins.DeprecationWarning.with_traceback" => "Set self.__traceback__ to tb and return self.",
     "builtins.DynamicClassAttribute" => "Route attribute access on a class to __getattr__.\n\nThis is a descriptor, used to define attributes that act differently when\naccessed through an instance and through a class.  Instance access remains\nnormal, but access to an attribute through a class will be routed to the\nclass's __getattr__ method; this is done by raising AttributeError.\n\nThis allows one to have properties active on an instance, and have virtual\nattributes on the class with the same name.  (Enum used this between Python\nversions 3.4 - 3.9 .)\n\nSubclass from this to use a different method of accessing virtual attributes\nand still be treated properly by the inspect module. (Enum uses this since\nPython 3.10 .)",
     "builtins.DynamicClassAttribute.__delattr__" => "Implement delattr(self, name).",
     "builtins.DynamicClassAttribute.__eq__" => "Return self==value.",
@@ -4073,8 +10024,6 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "builtins.DynamicClassAttribute.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
     "builtins.DynamicClassAttribute.__weakref__" => "list of weak references to the object",
     "builtins.EOFError" => "Read beyond end of file.",
-    "builtins.EOFError.__cause__" => "exception cause",
-    "builtins.EOFError.__context__" => "exception context",
     "builtins.EOFError.__delattr__" => "Implement delattr(self, name).",
     "builtins.EOFError.__eq__" => "Return self==value.",
     "builtins.EOFError.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
@@ -4095,11 +10044,9 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "builtins.EOFError.__sizeof__" => "Size of object in memory, in bytes.",
     "builtins.EOFError.__str__" => "Return str(self).",
     "builtins.EOFError.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
-    "builtins.EOFError.add_note" => "Exception.add_note(note) --\nadd a note to the exception",
-    "builtins.EOFError.with_traceback" => "Exception.with_traceback(tb) --\nset self.__traceback__ to tb and return self.",
+    "builtins.EOFError.add_note" => "Add a note to the exception",
+    "builtins.EOFError.with_traceback" => "Set self.__traceback__ to tb and return self.",
     "builtins.EncodingWarning" => "Base class for warnings about encodings.",
-    "builtins.EncodingWarning.__cause__" => "exception cause",
-    "builtins.EncodingWarning.__context__" => "exception context",
     "builtins.EncodingWarning.__delattr__" => "Implement delattr(self, name).",
     "builtins.EncodingWarning.__eq__" => "Return self==value.",
     "builtins.EncodingWarning.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
@@ -4120,11 +10067,9 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "builtins.EncodingWarning.__sizeof__" => "Size of object in memory, in bytes.",
     "builtins.EncodingWarning.__str__" => "Return str(self).",
     "builtins.EncodingWarning.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
-    "builtins.EncodingWarning.add_note" => "Exception.add_note(note) --\nadd a note to the exception",
-    "builtins.EncodingWarning.with_traceback" => "Exception.with_traceback(tb) --\nset self.__traceback__ to tb and return self.",
+    "builtins.EncodingWarning.add_note" => "Add a note to the exception",
+    "builtins.EncodingWarning.with_traceback" => "Set self.__traceback__ to tb and return self.",
     "builtins.EnvironmentError" => "Base class for I/O related errors.",
-    "builtins.EnvironmentError.__cause__" => "exception cause",
-    "builtins.EnvironmentError.__context__" => "exception context",
     "builtins.EnvironmentError.__delattr__" => "Implement delattr(self, name).",
     "builtins.EnvironmentError.__eq__" => "Return self==value.",
     "builtins.EnvironmentError.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
@@ -4145,16 +10090,14 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "builtins.EnvironmentError.__sizeof__" => "Size of object in memory, in bytes.",
     "builtins.EnvironmentError.__str__" => "Return str(self).",
     "builtins.EnvironmentError.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
-    "builtins.EnvironmentError.add_note" => "Exception.add_note(note) --\nadd a note to the exception",
+    "builtins.EnvironmentError.add_note" => "Add a note to the exception",
     "builtins.EnvironmentError.errno" => "POSIX exception code",
     "builtins.EnvironmentError.filename" => "exception filename",
     "builtins.EnvironmentError.filename2" => "second exception filename",
     "builtins.EnvironmentError.strerror" => "exception strerror",
     "builtins.EnvironmentError.winerror" => "Win32 exception code",
-    "builtins.EnvironmentError.with_traceback" => "Exception.with_traceback(tb) --\nset self.__traceback__ to tb and return self.",
+    "builtins.EnvironmentError.with_traceback" => "Set self.__traceback__ to tb and return self.",
     "builtins.Exception" => "Common base class for all non-exit exceptions.",
-    "builtins.Exception.__cause__" => "exception cause",
-    "builtins.Exception.__context__" => "exception context",
     "builtins.Exception.__delattr__" => "Implement delattr(self, name).",
     "builtins.Exception.__eq__" => "Return self==value.",
     "builtins.Exception.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
@@ -4175,11 +10118,9 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "builtins.Exception.__sizeof__" => "Size of object in memory, in bytes.",
     "builtins.Exception.__str__" => "Return str(self).",
     "builtins.Exception.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
-    "builtins.Exception.add_note" => "Exception.add_note(note) --\nadd a note to the exception",
-    "builtins.Exception.with_traceback" => "Exception.with_traceback(tb) --\nset self.__traceback__ to tb and return self.",
-    "builtins.ExceptionGroup.__cause__" => "exception cause",
+    "builtins.Exception.add_note" => "Add a note to the exception",
+    "builtins.Exception.with_traceback" => "Set self.__traceback__ to tb and return self.",
     "builtins.ExceptionGroup.__class_getitem__" => "See PEP 585",
-    "builtins.ExceptionGroup.__context__" => "exception context",
     "builtins.ExceptionGroup.__delattr__" => "Implement delattr(self, name).",
     "builtins.ExceptionGroup.__eq__" => "Return self==value.",
     "builtins.ExceptionGroup.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
@@ -4201,13 +10142,11 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "builtins.ExceptionGroup.__str__" => "Return str(self).",
     "builtins.ExceptionGroup.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
     "builtins.ExceptionGroup.__weakref__" => "list of weak references to the object",
-    "builtins.ExceptionGroup.add_note" => "Exception.add_note(note) --\nadd a note to the exception",
+    "builtins.ExceptionGroup.add_note" => "Add a note to the exception",
     "builtins.ExceptionGroup.exceptions" => "nested exceptions",
     "builtins.ExceptionGroup.message" => "exception message",
-    "builtins.ExceptionGroup.with_traceback" => "Exception.with_traceback(tb) --\nset self.__traceback__ to tb and return self.",
+    "builtins.ExceptionGroup.with_traceback" => "Set self.__traceback__ to tb and return self.",
     "builtins.FileExistsError" => "File already exists.",
-    "builtins.FileExistsError.__cause__" => "exception cause",
-    "builtins.FileExistsError.__context__" => "exception context",
     "builtins.FileExistsError.__delattr__" => "Implement delattr(self, name).",
     "builtins.FileExistsError.__eq__" => "Return self==value.",
     "builtins.FileExistsError.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
@@ -4228,16 +10167,14 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "builtins.FileExistsError.__sizeof__" => "Size of object in memory, in bytes.",
     "builtins.FileExistsError.__str__" => "Return str(self).",
     "builtins.FileExistsError.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
-    "builtins.FileExistsError.add_note" => "Exception.add_note(note) --\nadd a note to the exception",
+    "builtins.FileExistsError.add_note" => "Add a note to the exception",
     "builtins.FileExistsError.errno" => "POSIX exception code",
     "builtins.FileExistsError.filename" => "exception filename",
     "builtins.FileExistsError.filename2" => "second exception filename",
     "builtins.FileExistsError.strerror" => "exception strerror",
     "builtins.FileExistsError.winerror" => "Win32 exception code",
-    "builtins.FileExistsError.with_traceback" => "Exception.with_traceback(tb) --\nset self.__traceback__ to tb and return self.",
+    "builtins.FileExistsError.with_traceback" => "Set self.__traceback__ to tb and return self.",
     "builtins.FileNotFoundError" => "File not found.",
-    "builtins.FileNotFoundError.__cause__" => "exception cause",
-    "builtins.FileNotFoundError.__context__" => "exception context",
     "builtins.FileNotFoundError.__delattr__" => "Implement delattr(self, name).",
     "builtins.FileNotFoundError.__eq__" => "Return self==value.",
     "builtins.FileNotFoundError.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
@@ -4258,16 +10195,14 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "builtins.FileNotFoundError.__sizeof__" => "Size of object in memory, in bytes.",
     "builtins.FileNotFoundError.__str__" => "Return str(self).",
     "builtins.FileNotFoundError.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
-    "builtins.FileNotFoundError.add_note" => "Exception.add_note(note) --\nadd a note to the exception",
+    "builtins.FileNotFoundError.add_note" => "Add a note to the exception",
     "builtins.FileNotFoundError.errno" => "POSIX exception code",
     "builtins.FileNotFoundError.filename" => "exception filename",
     "builtins.FileNotFoundError.filename2" => "second exception filename",
     "builtins.FileNotFoundError.strerror" => "exception strerror",
     "builtins.FileNotFoundError.winerror" => "Win32 exception code",
-    "builtins.FileNotFoundError.with_traceback" => "Exception.with_traceback(tb) --\nset self.__traceback__ to tb and return self.",
+    "builtins.FileNotFoundError.with_traceback" => "Set self.__traceback__ to tb and return self.",
     "builtins.FloatingPointError" => "Floating-point operation failed.",
-    "builtins.FloatingPointError.__cause__" => "exception cause",
-    "builtins.FloatingPointError.__context__" => "exception context",
     "builtins.FloatingPointError.__delattr__" => "Implement delattr(self, name).",
     "builtins.FloatingPointError.__eq__" => "Return self==value.",
     "builtins.FloatingPointError.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
@@ -4288,11 +10223,9 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "builtins.FloatingPointError.__sizeof__" => "Size of object in memory, in bytes.",
     "builtins.FloatingPointError.__str__" => "Return str(self).",
     "builtins.FloatingPointError.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
-    "builtins.FloatingPointError.add_note" => "Exception.add_note(note) --\nadd a note to the exception",
-    "builtins.FloatingPointError.with_traceback" => "Exception.with_traceback(tb) --\nset self.__traceback__ to tb and return self.",
+    "builtins.FloatingPointError.add_note" => "Add a note to the exception",
+    "builtins.FloatingPointError.with_traceback" => "Set self.__traceback__ to tb and return self.",
     "builtins.FutureWarning" => "Base class for warnings about constructs that will change semantically\nin the future.",
-    "builtins.FutureWarning.__cause__" => "exception cause",
-    "builtins.FutureWarning.__context__" => "exception context",
     "builtins.FutureWarning.__delattr__" => "Implement delattr(self, name).",
     "builtins.FutureWarning.__eq__" => "Return self==value.",
     "builtins.FutureWarning.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
@@ -4313,11 +10246,9 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "builtins.FutureWarning.__sizeof__" => "Size of object in memory, in bytes.",
     "builtins.FutureWarning.__str__" => "Return str(self).",
     "builtins.FutureWarning.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
-    "builtins.FutureWarning.add_note" => "Exception.add_note(note) --\nadd a note to the exception",
-    "builtins.FutureWarning.with_traceback" => "Exception.with_traceback(tb) --\nset self.__traceback__ to tb and return self.",
+    "builtins.FutureWarning.add_note" => "Add a note to the exception",
+    "builtins.FutureWarning.with_traceback" => "Set self.__traceback__ to tb and return self.",
     "builtins.GeneratorExit" => "Request that a generator exit.",
-    "builtins.GeneratorExit.__cause__" => "exception cause",
-    "builtins.GeneratorExit.__context__" => "exception context",
     "builtins.GeneratorExit.__delattr__" => "Implement delattr(self, name).",
     "builtins.GeneratorExit.__eq__" => "Return self==value.",
     "builtins.GeneratorExit.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
@@ -4338,8 +10269,8 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "builtins.GeneratorExit.__sizeof__" => "Size of object in memory, in bytes.",
     "builtins.GeneratorExit.__str__" => "Return str(self).",
     "builtins.GeneratorExit.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
-    "builtins.GeneratorExit.add_note" => "Exception.add_note(note) --\nadd a note to the exception",
-    "builtins.GeneratorExit.with_traceback" => "Exception.with_traceback(tb) --\nset self.__traceback__ to tb and return self.",
+    "builtins.GeneratorExit.add_note" => "Add a note to the exception",
+    "builtins.GeneratorExit.with_traceback" => "Set self.__traceback__ to tb and return self.",
     "builtins.GenericAlias" => "Represent a PEP 585 generic type\n\nE.g. for t = list[int], t.__origin__ is list and t.__args__ is (int,).",
     "builtins.GenericAlias.__call__" => "Call self as a function.",
     "builtins.GenericAlias.__delattr__" => "Implement delattr(self, name).",
@@ -4368,8 +10299,6 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "builtins.GenericAlias.__str__" => "Return str(self).",
     "builtins.GenericAlias.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
     "builtins.IOError" => "Base class for I/O related errors.",
-    "builtins.IOError.__cause__" => "exception cause",
-    "builtins.IOError.__context__" => "exception context",
     "builtins.IOError.__delattr__" => "Implement delattr(self, name).",
     "builtins.IOError.__eq__" => "Return self==value.",
     "builtins.IOError.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
@@ -4390,16 +10319,14 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "builtins.IOError.__sizeof__" => "Size of object in memory, in bytes.",
     "builtins.IOError.__str__" => "Return str(self).",
     "builtins.IOError.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
-    "builtins.IOError.add_note" => "Exception.add_note(note) --\nadd a note to the exception",
+    "builtins.IOError.add_note" => "Add a note to the exception",
     "builtins.IOError.errno" => "POSIX exception code",
     "builtins.IOError.filename" => "exception filename",
     "builtins.IOError.filename2" => "second exception filename",
     "builtins.IOError.strerror" => "exception strerror",
     "builtins.IOError.winerror" => "Win32 exception code",
-    "builtins.IOError.with_traceback" => "Exception.with_traceback(tb) --\nset self.__traceback__ to tb and return self.",
+    "builtins.IOError.with_traceback" => "Set self.__traceback__ to tb and return self.",
     "builtins.ImportError" => "Import can't find module, or can't find name in module.",
-    "builtins.ImportError.__cause__" => "exception cause",
-    "builtins.ImportError.__context__" => "exception context",
     "builtins.ImportError.__delattr__" => "Implement delattr(self, name).",
     "builtins.ImportError.__eq__" => "Return self==value.",
     "builtins.ImportError.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
@@ -4420,15 +10347,13 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "builtins.ImportError.__sizeof__" => "Size of object in memory, in bytes.",
     "builtins.ImportError.__str__" => "Return str(self).",
     "builtins.ImportError.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
-    "builtins.ImportError.add_note" => "Exception.add_note(note) --\nadd a note to the exception",
+    "builtins.ImportError.add_note" => "Add a note to the exception",
     "builtins.ImportError.msg" => "exception message",
     "builtins.ImportError.name" => "module name",
     "builtins.ImportError.name_from" => "name imported from module",
     "builtins.ImportError.path" => "module path",
-    "builtins.ImportError.with_traceback" => "Exception.with_traceback(tb) --\nset self.__traceback__ to tb and return self.",
+    "builtins.ImportError.with_traceback" => "Set self.__traceback__ to tb and return self.",
     "builtins.ImportWarning" => "Base class for warnings about probable mistakes in module imports",
-    "builtins.ImportWarning.__cause__" => "exception cause",
-    "builtins.ImportWarning.__context__" => "exception context",
     "builtins.ImportWarning.__delattr__" => "Implement delattr(self, name).",
     "builtins.ImportWarning.__eq__" => "Return self==value.",
     "builtins.ImportWarning.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
@@ -4449,11 +10374,9 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "builtins.ImportWarning.__sizeof__" => "Size of object in memory, in bytes.",
     "builtins.ImportWarning.__str__" => "Return str(self).",
     "builtins.ImportWarning.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
-    "builtins.ImportWarning.add_note" => "Exception.add_note(note) --\nadd a note to the exception",
-    "builtins.ImportWarning.with_traceback" => "Exception.with_traceback(tb) --\nset self.__traceback__ to tb and return self.",
+    "builtins.ImportWarning.add_note" => "Add a note to the exception",
+    "builtins.ImportWarning.with_traceback" => "Set self.__traceback__ to tb and return self.",
     "builtins.IndentationError" => "Improper indentation.",
-    "builtins.IndentationError.__cause__" => "exception cause",
-    "builtins.IndentationError.__context__" => "exception context",
     "builtins.IndentationError.__delattr__" => "Implement delattr(self, name).",
     "builtins.IndentationError.__eq__" => "Return self==value.",
     "builtins.IndentationError.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
@@ -4474,7 +10397,8 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "builtins.IndentationError.__sizeof__" => "Size of object in memory, in bytes.",
     "builtins.IndentationError.__str__" => "Return str(self).",
     "builtins.IndentationError.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
-    "builtins.IndentationError.add_note" => "Exception.add_note(note) --\nadd a note to the exception",
+    "builtins.IndentationError._metadata" => "exception private metadata",
+    "builtins.IndentationError.add_note" => "Add a note to the exception",
     "builtins.IndentationError.end_lineno" => "exception end lineno",
     "builtins.IndentationError.end_offset" => "exception end offset",
     "builtins.IndentationError.filename" => "exception filename",
@@ -4483,10 +10407,8 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "builtins.IndentationError.offset" => "exception offset",
     "builtins.IndentationError.print_file_and_line" => "exception print_file_and_line",
     "builtins.IndentationError.text" => "exception text",
-    "builtins.IndentationError.with_traceback" => "Exception.with_traceback(tb) --\nset self.__traceback__ to tb and return self.",
+    "builtins.IndentationError.with_traceback" => "Set self.__traceback__ to tb and return self.",
     "builtins.IndexError" => "Sequence index out of range.",
-    "builtins.IndexError.__cause__" => "exception cause",
-    "builtins.IndexError.__context__" => "exception context",
     "builtins.IndexError.__delattr__" => "Implement delattr(self, name).",
     "builtins.IndexError.__eq__" => "Return self==value.",
     "builtins.IndexError.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
@@ -4507,11 +10429,9 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "builtins.IndexError.__sizeof__" => "Size of object in memory, in bytes.",
     "builtins.IndexError.__str__" => "Return str(self).",
     "builtins.IndexError.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
-    "builtins.IndexError.add_note" => "Exception.add_note(note) --\nadd a note to the exception",
-    "builtins.IndexError.with_traceback" => "Exception.with_traceback(tb) --\nset self.__traceback__ to tb and return self.",
+    "builtins.IndexError.add_note" => "Add a note to the exception",
+    "builtins.IndexError.with_traceback" => "Set self.__traceback__ to tb and return self.",
     "builtins.InterruptedError" => "Interrupted by signal.",
-    "builtins.InterruptedError.__cause__" => "exception cause",
-    "builtins.InterruptedError.__context__" => "exception context",
     "builtins.InterruptedError.__delattr__" => "Implement delattr(self, name).",
     "builtins.InterruptedError.__eq__" => "Return self==value.",
     "builtins.InterruptedError.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
@@ -4532,16 +10452,14 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "builtins.InterruptedError.__sizeof__" => "Size of object in memory, in bytes.",
     "builtins.InterruptedError.__str__" => "Return str(self).",
     "builtins.InterruptedError.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
-    "builtins.InterruptedError.add_note" => "Exception.add_note(note) --\nadd a note to the exception",
+    "builtins.InterruptedError.add_note" => "Add a note to the exception",
     "builtins.InterruptedError.errno" => "POSIX exception code",
     "builtins.InterruptedError.filename" => "exception filename",
     "builtins.InterruptedError.filename2" => "second exception filename",
     "builtins.InterruptedError.strerror" => "exception strerror",
     "builtins.InterruptedError.winerror" => "Win32 exception code",
-    "builtins.InterruptedError.with_traceback" => "Exception.with_traceback(tb) --\nset self.__traceback__ to tb and return self.",
+    "builtins.InterruptedError.with_traceback" => "Set self.__traceback__ to tb and return self.",
     "builtins.IsADirectoryError" => "Operation doesn't work on directories.",
-    "builtins.IsADirectoryError.__cause__" => "exception cause",
-    "builtins.IsADirectoryError.__context__" => "exception context",
     "builtins.IsADirectoryError.__delattr__" => "Implement delattr(self, name).",
     "builtins.IsADirectoryError.__eq__" => "Return self==value.",
     "builtins.IsADirectoryError.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
@@ -4562,16 +10480,14 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "builtins.IsADirectoryError.__sizeof__" => "Size of object in memory, in bytes.",
     "builtins.IsADirectoryError.__str__" => "Return str(self).",
     "builtins.IsADirectoryError.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
-    "builtins.IsADirectoryError.add_note" => "Exception.add_note(note) --\nadd a note to the exception",
+    "builtins.IsADirectoryError.add_note" => "Add a note to the exception",
     "builtins.IsADirectoryError.errno" => "POSIX exception code",
     "builtins.IsADirectoryError.filename" => "exception filename",
     "builtins.IsADirectoryError.filename2" => "second exception filename",
     "builtins.IsADirectoryError.strerror" => "exception strerror",
     "builtins.IsADirectoryError.winerror" => "Win32 exception code",
-    "builtins.IsADirectoryError.with_traceback" => "Exception.with_traceback(tb) --\nset self.__traceback__ to tb and return self.",
+    "builtins.IsADirectoryError.with_traceback" => "Set self.__traceback__ to tb and return self.",
     "builtins.KeyError" => "Mapping key not found.",
-    "builtins.KeyError.__cause__" => "exception cause",
-    "builtins.KeyError.__context__" => "exception context",
     "builtins.KeyError.__delattr__" => "Implement delattr(self, name).",
     "builtins.KeyError.__eq__" => "Return self==value.",
     "builtins.KeyError.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
@@ -4592,11 +10508,9 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "builtins.KeyError.__sizeof__" => "Size of object in memory, in bytes.",
     "builtins.KeyError.__str__" => "Return str(self).",
     "builtins.KeyError.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
-    "builtins.KeyError.add_note" => "Exception.add_note(note) --\nadd a note to the exception",
-    "builtins.KeyError.with_traceback" => "Exception.with_traceback(tb) --\nset self.__traceback__ to tb and return self.",
+    "builtins.KeyError.add_note" => "Add a note to the exception",
+    "builtins.KeyError.with_traceback" => "Set self.__traceback__ to tb and return self.",
     "builtins.KeyboardInterrupt" => "Program interrupted by user.",
-    "builtins.KeyboardInterrupt.__cause__" => "exception cause",
-    "builtins.KeyboardInterrupt.__context__" => "exception context",
     "builtins.KeyboardInterrupt.__delattr__" => "Implement delattr(self, name).",
     "builtins.KeyboardInterrupt.__eq__" => "Return self==value.",
     "builtins.KeyboardInterrupt.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
@@ -4617,11 +10531,9 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "builtins.KeyboardInterrupt.__sizeof__" => "Size of object in memory, in bytes.",
     "builtins.KeyboardInterrupt.__str__" => "Return str(self).",
     "builtins.KeyboardInterrupt.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
-    "builtins.KeyboardInterrupt.add_note" => "Exception.add_note(note) --\nadd a note to the exception",
-    "builtins.KeyboardInterrupt.with_traceback" => "Exception.with_traceback(tb) --\nset self.__traceback__ to tb and return self.",
+    "builtins.KeyboardInterrupt.add_note" => "Add a note to the exception",
+    "builtins.KeyboardInterrupt.with_traceback" => "Set self.__traceback__ to tb and return self.",
     "builtins.LookupError" => "Base class for lookup errors.",
-    "builtins.LookupError.__cause__" => "exception cause",
-    "builtins.LookupError.__context__" => "exception context",
     "builtins.LookupError.__delattr__" => "Implement delattr(self, name).",
     "builtins.LookupError.__eq__" => "Return self==value.",
     "builtins.LookupError.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
@@ -4642,11 +10554,9 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "builtins.LookupError.__sizeof__" => "Size of object in memory, in bytes.",
     "builtins.LookupError.__str__" => "Return str(self).",
     "builtins.LookupError.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
-    "builtins.LookupError.add_note" => "Exception.add_note(note) --\nadd a note to the exception",
-    "builtins.LookupError.with_traceback" => "Exception.with_traceback(tb) --\nset self.__traceback__ to tb and return self.",
+    "builtins.LookupError.add_note" => "Add a note to the exception",
+    "builtins.LookupError.with_traceback" => "Set self.__traceback__ to tb and return self.",
     "builtins.MemoryError" => "Out of memory.",
-    "builtins.MemoryError.__cause__" => "exception cause",
-    "builtins.MemoryError.__context__" => "exception context",
     "builtins.MemoryError.__delattr__" => "Implement delattr(self, name).",
     "builtins.MemoryError.__eq__" => "Return self==value.",
     "builtins.MemoryError.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
@@ -4667,11 +10577,9 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "builtins.MemoryError.__sizeof__" => "Size of object in memory, in bytes.",
     "builtins.MemoryError.__str__" => "Return str(self).",
     "builtins.MemoryError.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
-    "builtins.MemoryError.add_note" => "Exception.add_note(note) --\nadd a note to the exception",
-    "builtins.MemoryError.with_traceback" => "Exception.with_traceback(tb) --\nset self.__traceback__ to tb and return self.",
+    "builtins.MemoryError.add_note" => "Add a note to the exception",
+    "builtins.MemoryError.with_traceback" => "Set self.__traceback__ to tb and return self.",
     "builtins.ModuleNotFoundError" => "Module not found.",
-    "builtins.ModuleNotFoundError.__cause__" => "exception cause",
-    "builtins.ModuleNotFoundError.__context__" => "exception context",
     "builtins.ModuleNotFoundError.__delattr__" => "Implement delattr(self, name).",
     "builtins.ModuleNotFoundError.__eq__" => "Return self==value.",
     "builtins.ModuleNotFoundError.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
@@ -4692,15 +10600,13 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "builtins.ModuleNotFoundError.__sizeof__" => "Size of object in memory, in bytes.",
     "builtins.ModuleNotFoundError.__str__" => "Return str(self).",
     "builtins.ModuleNotFoundError.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
-    "builtins.ModuleNotFoundError.add_note" => "Exception.add_note(note) --\nadd a note to the exception",
+    "builtins.ModuleNotFoundError.add_note" => "Add a note to the exception",
     "builtins.ModuleNotFoundError.msg" => "exception message",
     "builtins.ModuleNotFoundError.name" => "module name",
     "builtins.ModuleNotFoundError.name_from" => "name imported from module",
     "builtins.ModuleNotFoundError.path" => "module path",
-    "builtins.ModuleNotFoundError.with_traceback" => "Exception.with_traceback(tb) --\nset self.__traceback__ to tb and return self.",
+    "builtins.ModuleNotFoundError.with_traceback" => "Set self.__traceback__ to tb and return self.",
     "builtins.NameError" => "Name not found globally.",
-    "builtins.NameError.__cause__" => "exception cause",
-    "builtins.NameError.__context__" => "exception context",
     "builtins.NameError.__delattr__" => "Implement delattr(self, name).",
     "builtins.NameError.__eq__" => "Return self==value.",
     "builtins.NameError.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
@@ -4721,9 +10627,9 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "builtins.NameError.__sizeof__" => "Size of object in memory, in bytes.",
     "builtins.NameError.__str__" => "Return str(self).",
     "builtins.NameError.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
-    "builtins.NameError.add_note" => "Exception.add_note(note) --\nadd a note to the exception",
+    "builtins.NameError.add_note" => "Add a note to the exception",
     "builtins.NameError.name" => "name",
-    "builtins.NameError.with_traceback" => "Exception.with_traceback(tb) --\nset self.__traceback__ to tb and return self.",
+    "builtins.NameError.with_traceback" => "Set self.__traceback__ to tb and return self.",
     "builtins.NoneType" => "The type of the None singleton.",
     "builtins.NoneType.__bool__" => "True if self else False",
     "builtins.NoneType.__delattr__" => "Implement delattr(self, name).",
@@ -4748,8 +10654,6 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "builtins.NoneType.__str__" => "Return str(self).",
     "builtins.NoneType.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
     "builtins.NotADirectoryError" => "Operation only works on directories.",
-    "builtins.NotADirectoryError.__cause__" => "exception cause",
-    "builtins.NotADirectoryError.__context__" => "exception context",
     "builtins.NotADirectoryError.__delattr__" => "Implement delattr(self, name).",
     "builtins.NotADirectoryError.__eq__" => "Return self==value.",
     "builtins.NotADirectoryError.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
@@ -4770,16 +10674,14 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "builtins.NotADirectoryError.__sizeof__" => "Size of object in memory, in bytes.",
     "builtins.NotADirectoryError.__str__" => "Return str(self).",
     "builtins.NotADirectoryError.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
-    "builtins.NotADirectoryError.add_note" => "Exception.add_note(note) --\nadd a note to the exception",
+    "builtins.NotADirectoryError.add_note" => "Add a note to the exception",
     "builtins.NotADirectoryError.errno" => "POSIX exception code",
     "builtins.NotADirectoryError.filename" => "exception filename",
     "builtins.NotADirectoryError.filename2" => "second exception filename",
     "builtins.NotADirectoryError.strerror" => "exception strerror",
     "builtins.NotADirectoryError.winerror" => "Win32 exception code",
-    "builtins.NotADirectoryError.with_traceback" => "Exception.with_traceback(tb) --\nset self.__traceback__ to tb and return self.",
+    "builtins.NotADirectoryError.with_traceback" => "Set self.__traceback__ to tb and return self.",
     "builtins.NotImplementedError" => "Method or function hasn't been implemented yet.",
-    "builtins.NotImplementedError.__cause__" => "exception cause",
-    "builtins.NotImplementedError.__context__" => "exception context",
     "builtins.NotImplementedError.__delattr__" => "Implement delattr(self, name).",
     "builtins.NotImplementedError.__eq__" => "Return self==value.",
     "builtins.NotImplementedError.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
@@ -4800,8 +10702,8 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "builtins.NotImplementedError.__sizeof__" => "Size of object in memory, in bytes.",
     "builtins.NotImplementedError.__str__" => "Return str(self).",
     "builtins.NotImplementedError.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
-    "builtins.NotImplementedError.add_note" => "Exception.add_note(note) --\nadd a note to the exception",
-    "builtins.NotImplementedError.with_traceback" => "Exception.with_traceback(tb) --\nset self.__traceback__ to tb and return self.",
+    "builtins.NotImplementedError.add_note" => "Add a note to the exception",
+    "builtins.NotImplementedError.with_traceback" => "Set self.__traceback__ to tb and return self.",
     "builtins.NotImplementedType" => "The type of the NotImplemented singleton.",
     "builtins.NotImplementedType.__bool__" => "True if self else False",
     "builtins.NotImplementedType.__delattr__" => "Implement delattr(self, name).",
@@ -4825,8 +10727,6 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "builtins.NotImplementedType.__str__" => "Return str(self).",
     "builtins.NotImplementedType.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
     "builtins.OSError" => "Base class for I/O related errors.",
-    "builtins.OSError.__cause__" => "exception cause",
-    "builtins.OSError.__context__" => "exception context",
     "builtins.OSError.__delattr__" => "Implement delattr(self, name).",
     "builtins.OSError.__eq__" => "Return self==value.",
     "builtins.OSError.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
@@ -4847,16 +10747,14 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "builtins.OSError.__sizeof__" => "Size of object in memory, in bytes.",
     "builtins.OSError.__str__" => "Return str(self).",
     "builtins.OSError.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
-    "builtins.OSError.add_note" => "Exception.add_note(note) --\nadd a note to the exception",
+    "builtins.OSError.add_note" => "Add a note to the exception",
     "builtins.OSError.errno" => "POSIX exception code",
     "builtins.OSError.filename" => "exception filename",
     "builtins.OSError.filename2" => "second exception filename",
     "builtins.OSError.strerror" => "exception strerror",
     "builtins.OSError.winerror" => "Win32 exception code",
-    "builtins.OSError.with_traceback" => "Exception.with_traceback(tb) --\nset self.__traceback__ to tb and return self.",
+    "builtins.OSError.with_traceback" => "Set self.__traceback__ to tb and return self.",
     "builtins.OverflowError" => "Result too large to be represented.",
-    "builtins.OverflowError.__cause__" => "exception cause",
-    "builtins.OverflowError.__context__" => "exception context",
     "builtins.OverflowError.__delattr__" => "Implement delattr(self, name).",
     "builtins.OverflowError.__eq__" => "Return self==value.",
     "builtins.OverflowError.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
@@ -4877,11 +10775,9 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "builtins.OverflowError.__sizeof__" => "Size of object in memory, in bytes.",
     "builtins.OverflowError.__str__" => "Return str(self).",
     "builtins.OverflowError.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
-    "builtins.OverflowError.add_note" => "Exception.add_note(note) --\nadd a note to the exception",
-    "builtins.OverflowError.with_traceback" => "Exception.with_traceback(tb) --\nset self.__traceback__ to tb and return self.",
+    "builtins.OverflowError.add_note" => "Add a note to the exception",
+    "builtins.OverflowError.with_traceback" => "Set self.__traceback__ to tb and return self.",
     "builtins.PendingDeprecationWarning" => "Base class for warnings about features which will be deprecated\nin the future.",
-    "builtins.PendingDeprecationWarning.__cause__" => "exception cause",
-    "builtins.PendingDeprecationWarning.__context__" => "exception context",
     "builtins.PendingDeprecationWarning.__delattr__" => "Implement delattr(self, name).",
     "builtins.PendingDeprecationWarning.__eq__" => "Return self==value.",
     "builtins.PendingDeprecationWarning.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
@@ -4902,11 +10798,9 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "builtins.PendingDeprecationWarning.__sizeof__" => "Size of object in memory, in bytes.",
     "builtins.PendingDeprecationWarning.__str__" => "Return str(self).",
     "builtins.PendingDeprecationWarning.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
-    "builtins.PendingDeprecationWarning.add_note" => "Exception.add_note(note) --\nadd a note to the exception",
-    "builtins.PendingDeprecationWarning.with_traceback" => "Exception.with_traceback(tb) --\nset self.__traceback__ to tb and return self.",
+    "builtins.PendingDeprecationWarning.add_note" => "Add a note to the exception",
+    "builtins.PendingDeprecationWarning.with_traceback" => "Set self.__traceback__ to tb and return self.",
     "builtins.PermissionError" => "Not enough permissions.",
-    "builtins.PermissionError.__cause__" => "exception cause",
-    "builtins.PermissionError.__context__" => "exception context",
     "builtins.PermissionError.__delattr__" => "Implement delattr(self, name).",
     "builtins.PermissionError.__eq__" => "Return self==value.",
     "builtins.PermissionError.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
@@ -4927,16 +10821,14 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "builtins.PermissionError.__sizeof__" => "Size of object in memory, in bytes.",
     "builtins.PermissionError.__str__" => "Return str(self).",
     "builtins.PermissionError.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
-    "builtins.PermissionError.add_note" => "Exception.add_note(note) --\nadd a note to the exception",
+    "builtins.PermissionError.add_note" => "Add a note to the exception",
     "builtins.PermissionError.errno" => "POSIX exception code",
     "builtins.PermissionError.filename" => "exception filename",
     "builtins.PermissionError.filename2" => "second exception filename",
     "builtins.PermissionError.strerror" => "exception strerror",
     "builtins.PermissionError.winerror" => "Win32 exception code",
-    "builtins.PermissionError.with_traceback" => "Exception.with_traceback(tb) --\nset self.__traceback__ to tb and return self.",
+    "builtins.PermissionError.with_traceback" => "Set self.__traceback__ to tb and return self.",
     "builtins.ProcessLookupError" => "Process not found.",
-    "builtins.ProcessLookupError.__cause__" => "exception cause",
-    "builtins.ProcessLookupError.__context__" => "exception context",
     "builtins.ProcessLookupError.__delattr__" => "Implement delattr(self, name).",
     "builtins.ProcessLookupError.__eq__" => "Return self==value.",
     "builtins.ProcessLookupError.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
@@ -4957,16 +10849,36 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "builtins.ProcessLookupError.__sizeof__" => "Size of object in memory, in bytes.",
     "builtins.ProcessLookupError.__str__" => "Return str(self).",
     "builtins.ProcessLookupError.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
-    "builtins.ProcessLookupError.add_note" => "Exception.add_note(note) --\nadd a note to the exception",
+    "builtins.ProcessLookupError.add_note" => "Add a note to the exception",
     "builtins.ProcessLookupError.errno" => "POSIX exception code",
     "builtins.ProcessLookupError.filename" => "exception filename",
     "builtins.ProcessLookupError.filename2" => "second exception filename",
     "builtins.ProcessLookupError.strerror" => "exception strerror",
     "builtins.ProcessLookupError.winerror" => "Win32 exception code",
-    "builtins.ProcessLookupError.with_traceback" => "Exception.with_traceback(tb) --\nset self.__traceback__ to tb and return self.",
+    "builtins.ProcessLookupError.with_traceback" => "Set self.__traceback__ to tb and return self.",
+    "builtins.PyCapsule" => "Capsule objects let you wrap a C \"void *\" pointer in a Python\nobject.  They're a way of passing data through the Python interpreter\nwithout creating your own custom type.\n\nCapsules are used for communication between extension modules.\nThey provide a way for an extension module to export a C interface\nto other extension modules, so that extension modules can use the\nPython import mechanism to link to one another.",
+    "builtins.PyCapsule.__delattr__" => "Implement delattr(self, name).",
+    "builtins.PyCapsule.__eq__" => "Return self==value.",
+    "builtins.PyCapsule.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "builtins.PyCapsule.__ge__" => "Return self>=value.",
+    "builtins.PyCapsule.__getattribute__" => "Return getattr(self, name).",
+    "builtins.PyCapsule.__getstate__" => "Helper for pickle.",
+    "builtins.PyCapsule.__gt__" => "Return self>value.",
+    "builtins.PyCapsule.__hash__" => "Return hash(self).",
+    "builtins.PyCapsule.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "builtins.PyCapsule.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "builtins.PyCapsule.__le__" => "Return self<=value.",
+    "builtins.PyCapsule.__lt__" => "Return self<value.",
+    "builtins.PyCapsule.__ne__" => "Return self!=value.",
+    "builtins.PyCapsule.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "builtins.PyCapsule.__reduce__" => "Helper for pickle.",
+    "builtins.PyCapsule.__reduce_ex__" => "Helper for pickle.",
+    "builtins.PyCapsule.__repr__" => "Return repr(self).",
+    "builtins.PyCapsule.__setattr__" => "Implement setattr(self, name, value).",
+    "builtins.PyCapsule.__sizeof__" => "Size of object in memory, in bytes.",
+    "builtins.PyCapsule.__str__" => "Return str(self).",
+    "builtins.PyCapsule.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
     "builtins.PythonFinalizationError" => "Operation blocked during Python finalization.",
-    "builtins.PythonFinalizationError.__cause__" => "exception cause",
-    "builtins.PythonFinalizationError.__context__" => "exception context",
     "builtins.PythonFinalizationError.__delattr__" => "Implement delattr(self, name).",
     "builtins.PythonFinalizationError.__eq__" => "Return self==value.",
     "builtins.PythonFinalizationError.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
@@ -4987,11 +10899,9 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "builtins.PythonFinalizationError.__sizeof__" => "Size of object in memory, in bytes.",
     "builtins.PythonFinalizationError.__str__" => "Return str(self).",
     "builtins.PythonFinalizationError.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
-    "builtins.PythonFinalizationError.add_note" => "Exception.add_note(note) --\nadd a note to the exception",
-    "builtins.PythonFinalizationError.with_traceback" => "Exception.with_traceback(tb) --\nset self.__traceback__ to tb and return self.",
+    "builtins.PythonFinalizationError.add_note" => "Add a note to the exception",
+    "builtins.PythonFinalizationError.with_traceback" => "Set self.__traceback__ to tb and return self.",
     "builtins.RecursionError" => "Recursion limit exceeded.",
-    "builtins.RecursionError.__cause__" => "exception cause",
-    "builtins.RecursionError.__context__" => "exception context",
     "builtins.RecursionError.__delattr__" => "Implement delattr(self, name).",
     "builtins.RecursionError.__eq__" => "Return self==value.",
     "builtins.RecursionError.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
@@ -5012,11 +10922,9 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "builtins.RecursionError.__sizeof__" => "Size of object in memory, in bytes.",
     "builtins.RecursionError.__str__" => "Return str(self).",
     "builtins.RecursionError.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
-    "builtins.RecursionError.add_note" => "Exception.add_note(note) --\nadd a note to the exception",
-    "builtins.RecursionError.with_traceback" => "Exception.with_traceback(tb) --\nset self.__traceback__ to tb and return self.",
+    "builtins.RecursionError.add_note" => "Add a note to the exception",
+    "builtins.RecursionError.with_traceback" => "Set self.__traceback__ to tb and return self.",
     "builtins.ReferenceError" => "Weak ref proxy used after referent went away.",
-    "builtins.ReferenceError.__cause__" => "exception cause",
-    "builtins.ReferenceError.__context__" => "exception context",
     "builtins.ReferenceError.__delattr__" => "Implement delattr(self, name).",
     "builtins.ReferenceError.__eq__" => "Return self==value.",
     "builtins.ReferenceError.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
@@ -5037,11 +10945,9 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "builtins.ReferenceError.__sizeof__" => "Size of object in memory, in bytes.",
     "builtins.ReferenceError.__str__" => "Return str(self).",
     "builtins.ReferenceError.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
-    "builtins.ReferenceError.add_note" => "Exception.add_note(note) --\nadd a note to the exception",
-    "builtins.ReferenceError.with_traceback" => "Exception.with_traceback(tb) --\nset self.__traceback__ to tb and return self.",
+    "builtins.ReferenceError.add_note" => "Add a note to the exception",
+    "builtins.ReferenceError.with_traceback" => "Set self.__traceback__ to tb and return self.",
     "builtins.ResourceWarning" => "Base class for warnings about resource usage.",
-    "builtins.ResourceWarning.__cause__" => "exception cause",
-    "builtins.ResourceWarning.__context__" => "exception context",
     "builtins.ResourceWarning.__delattr__" => "Implement delattr(self, name).",
     "builtins.ResourceWarning.__eq__" => "Return self==value.",
     "builtins.ResourceWarning.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
@@ -5062,11 +10968,9 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "builtins.ResourceWarning.__sizeof__" => "Size of object in memory, in bytes.",
     "builtins.ResourceWarning.__str__" => "Return str(self).",
     "builtins.ResourceWarning.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
-    "builtins.ResourceWarning.add_note" => "Exception.add_note(note) --\nadd a note to the exception",
-    "builtins.ResourceWarning.with_traceback" => "Exception.with_traceback(tb) --\nset self.__traceback__ to tb and return self.",
+    "builtins.ResourceWarning.add_note" => "Add a note to the exception",
+    "builtins.ResourceWarning.with_traceback" => "Set self.__traceback__ to tb and return self.",
     "builtins.RuntimeError" => "Unspecified run-time error.",
-    "builtins.RuntimeError.__cause__" => "exception cause",
-    "builtins.RuntimeError.__context__" => "exception context",
     "builtins.RuntimeError.__delattr__" => "Implement delattr(self, name).",
     "builtins.RuntimeError.__eq__" => "Return self==value.",
     "builtins.RuntimeError.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
@@ -5087,11 +10991,9 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "builtins.RuntimeError.__sizeof__" => "Size of object in memory, in bytes.",
     "builtins.RuntimeError.__str__" => "Return str(self).",
     "builtins.RuntimeError.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
-    "builtins.RuntimeError.add_note" => "Exception.add_note(note) --\nadd a note to the exception",
-    "builtins.RuntimeError.with_traceback" => "Exception.with_traceback(tb) --\nset self.__traceback__ to tb and return self.",
+    "builtins.RuntimeError.add_note" => "Add a note to the exception",
+    "builtins.RuntimeError.with_traceback" => "Set self.__traceback__ to tb and return self.",
     "builtins.RuntimeWarning" => "Base class for warnings about dubious runtime behavior.",
-    "builtins.RuntimeWarning.__cause__" => "exception cause",
-    "builtins.RuntimeWarning.__context__" => "exception context",
     "builtins.RuntimeWarning.__delattr__" => "Implement delattr(self, name).",
     "builtins.RuntimeWarning.__eq__" => "Return self==value.",
     "builtins.RuntimeWarning.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
@@ -5112,8 +11014,8 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "builtins.RuntimeWarning.__sizeof__" => "Size of object in memory, in bytes.",
     "builtins.RuntimeWarning.__str__" => "Return str(self).",
     "builtins.RuntimeWarning.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
-    "builtins.RuntimeWarning.add_note" => "Exception.add_note(note) --\nadd a note to the exception",
-    "builtins.RuntimeWarning.with_traceback" => "Exception.with_traceback(tb) --\nset self.__traceback__ to tb and return self.",
+    "builtins.RuntimeWarning.add_note" => "Add a note to the exception",
+    "builtins.RuntimeWarning.with_traceback" => "Set self.__traceback__ to tb and return self.",
     "builtins.SimpleNamespace" => "A simple attribute-based namespace.",
     "builtins.SimpleNamespace.__delattr__" => "Implement delattr(self, name).",
     "builtins.SimpleNamespace.__eq__" => "Return self==value.",
@@ -5137,8 +11039,6 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "builtins.SimpleNamespace.__str__" => "Return str(self).",
     "builtins.SimpleNamespace.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
     "builtins.StopAsyncIteration" => "Signal the end from iterator.__anext__().",
-    "builtins.StopAsyncIteration.__cause__" => "exception cause",
-    "builtins.StopAsyncIteration.__context__" => "exception context",
     "builtins.StopAsyncIteration.__delattr__" => "Implement delattr(self, name).",
     "builtins.StopAsyncIteration.__eq__" => "Return self==value.",
     "builtins.StopAsyncIteration.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
@@ -5159,11 +11059,9 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "builtins.StopAsyncIteration.__sizeof__" => "Size of object in memory, in bytes.",
     "builtins.StopAsyncIteration.__str__" => "Return str(self).",
     "builtins.StopAsyncIteration.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
-    "builtins.StopAsyncIteration.add_note" => "Exception.add_note(note) --\nadd a note to the exception",
-    "builtins.StopAsyncIteration.with_traceback" => "Exception.with_traceback(tb) --\nset self.__traceback__ to tb and return self.",
+    "builtins.StopAsyncIteration.add_note" => "Add a note to the exception",
+    "builtins.StopAsyncIteration.with_traceback" => "Set self.__traceback__ to tb and return self.",
     "builtins.StopIteration" => "Signal the end from iterator.__next__().",
-    "builtins.StopIteration.__cause__" => "exception cause",
-    "builtins.StopIteration.__context__" => "exception context",
     "builtins.StopIteration.__delattr__" => "Implement delattr(self, name).",
     "builtins.StopIteration.__eq__" => "Return self==value.",
     "builtins.StopIteration.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
@@ -5184,12 +11082,10 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "builtins.StopIteration.__sizeof__" => "Size of object in memory, in bytes.",
     "builtins.StopIteration.__str__" => "Return str(self).",
     "builtins.StopIteration.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
-    "builtins.StopIteration.add_note" => "Exception.add_note(note) --\nadd a note to the exception",
+    "builtins.StopIteration.add_note" => "Add a note to the exception",
     "builtins.StopIteration.value" => "generator return value",
-    "builtins.StopIteration.with_traceback" => "Exception.with_traceback(tb) --\nset self.__traceback__ to tb and return self.",
+    "builtins.StopIteration.with_traceback" => "Set self.__traceback__ to tb and return self.",
     "builtins.SyntaxError" => "Invalid syntax.",
-    "builtins.SyntaxError.__cause__" => "exception cause",
-    "builtins.SyntaxError.__context__" => "exception context",
     "builtins.SyntaxError.__delattr__" => "Implement delattr(self, name).",
     "builtins.SyntaxError.__eq__" => "Return self==value.",
     "builtins.SyntaxError.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
@@ -5210,7 +11106,8 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "builtins.SyntaxError.__sizeof__" => "Size of object in memory, in bytes.",
     "builtins.SyntaxError.__str__" => "Return str(self).",
     "builtins.SyntaxError.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
-    "builtins.SyntaxError.add_note" => "Exception.add_note(note) --\nadd a note to the exception",
+    "builtins.SyntaxError._metadata" => "exception private metadata",
+    "builtins.SyntaxError.add_note" => "Add a note to the exception",
     "builtins.SyntaxError.end_lineno" => "exception end lineno",
     "builtins.SyntaxError.end_offset" => "exception end offset",
     "builtins.SyntaxError.filename" => "exception filename",
@@ -5219,10 +11116,8 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "builtins.SyntaxError.offset" => "exception offset",
     "builtins.SyntaxError.print_file_and_line" => "exception print_file_and_line",
     "builtins.SyntaxError.text" => "exception text",
-    "builtins.SyntaxError.with_traceback" => "Exception.with_traceback(tb) --\nset self.__traceback__ to tb and return self.",
+    "builtins.SyntaxError.with_traceback" => "Set self.__traceback__ to tb and return self.",
     "builtins.SyntaxWarning" => "Base class for warnings about dubious syntax.",
-    "builtins.SyntaxWarning.__cause__" => "exception cause",
-    "builtins.SyntaxWarning.__context__" => "exception context",
     "builtins.SyntaxWarning.__delattr__" => "Implement delattr(self, name).",
     "builtins.SyntaxWarning.__eq__" => "Return self==value.",
     "builtins.SyntaxWarning.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
@@ -5243,11 +11138,9 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "builtins.SyntaxWarning.__sizeof__" => "Size of object in memory, in bytes.",
     "builtins.SyntaxWarning.__str__" => "Return str(self).",
     "builtins.SyntaxWarning.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
-    "builtins.SyntaxWarning.add_note" => "Exception.add_note(note) --\nadd a note to the exception",
-    "builtins.SyntaxWarning.with_traceback" => "Exception.with_traceback(tb) --\nset self.__traceback__ to tb and return self.",
+    "builtins.SyntaxWarning.add_note" => "Add a note to the exception",
+    "builtins.SyntaxWarning.with_traceback" => "Set self.__traceback__ to tb and return self.",
     "builtins.SystemError" => "Internal error in the Python interpreter.\n\nPlease report this to the Python maintainer, along with the traceback,\nthe Python version, and the hardware/OS platform and version.",
-    "builtins.SystemError.__cause__" => "exception cause",
-    "builtins.SystemError.__context__" => "exception context",
     "builtins.SystemError.__delattr__" => "Implement delattr(self, name).",
     "builtins.SystemError.__eq__" => "Return self==value.",
     "builtins.SystemError.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
@@ -5268,11 +11161,9 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "builtins.SystemError.__sizeof__" => "Size of object in memory, in bytes.",
     "builtins.SystemError.__str__" => "Return str(self).",
     "builtins.SystemError.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
-    "builtins.SystemError.add_note" => "Exception.add_note(note) --\nadd a note to the exception",
-    "builtins.SystemError.with_traceback" => "Exception.with_traceback(tb) --\nset self.__traceback__ to tb and return self.",
+    "builtins.SystemError.add_note" => "Add a note to the exception",
+    "builtins.SystemError.with_traceback" => "Set self.__traceback__ to tb and return self.",
     "builtins.SystemExit" => "Request to exit from the interpreter.",
-    "builtins.SystemExit.__cause__" => "exception cause",
-    "builtins.SystemExit.__context__" => "exception context",
     "builtins.SystemExit.__delattr__" => "Implement delattr(self, name).",
     "builtins.SystemExit.__eq__" => "Return self==value.",
     "builtins.SystemExit.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
@@ -5293,12 +11184,10 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "builtins.SystemExit.__sizeof__" => "Size of object in memory, in bytes.",
     "builtins.SystemExit.__str__" => "Return str(self).",
     "builtins.SystemExit.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
-    "builtins.SystemExit.add_note" => "Exception.add_note(note) --\nadd a note to the exception",
+    "builtins.SystemExit.add_note" => "Add a note to the exception",
     "builtins.SystemExit.code" => "exception code",
-    "builtins.SystemExit.with_traceback" => "Exception.with_traceback(tb) --\nset self.__traceback__ to tb and return self.",
+    "builtins.SystemExit.with_traceback" => "Set self.__traceback__ to tb and return self.",
     "builtins.TabError" => "Improper mixture of spaces and tabs.",
-    "builtins.TabError.__cause__" => "exception cause",
-    "builtins.TabError.__context__" => "exception context",
     "builtins.TabError.__delattr__" => "Implement delattr(self, name).",
     "builtins.TabError.__eq__" => "Return self==value.",
     "builtins.TabError.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
@@ -5319,7 +11208,8 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "builtins.TabError.__sizeof__" => "Size of object in memory, in bytes.",
     "builtins.TabError.__str__" => "Return str(self).",
     "builtins.TabError.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
-    "builtins.TabError.add_note" => "Exception.add_note(note) --\nadd a note to the exception",
+    "builtins.TabError._metadata" => "exception private metadata",
+    "builtins.TabError.add_note" => "Add a note to the exception",
     "builtins.TabError.end_lineno" => "exception end lineno",
     "builtins.TabError.end_offset" => "exception end offset",
     "builtins.TabError.filename" => "exception filename",
@@ -5328,10 +11218,8 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "builtins.TabError.offset" => "exception offset",
     "builtins.TabError.print_file_and_line" => "exception print_file_and_line",
     "builtins.TabError.text" => "exception text",
-    "builtins.TabError.with_traceback" => "Exception.with_traceback(tb) --\nset self.__traceback__ to tb and return self.",
+    "builtins.TabError.with_traceback" => "Set self.__traceback__ to tb and return self.",
     "builtins.TimeoutError" => "Timeout expired.",
-    "builtins.TimeoutError.__cause__" => "exception cause",
-    "builtins.TimeoutError.__context__" => "exception context",
     "builtins.TimeoutError.__delattr__" => "Implement delattr(self, name).",
     "builtins.TimeoutError.__eq__" => "Return self==value.",
     "builtins.TimeoutError.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
@@ -5352,16 +11240,14 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "builtins.TimeoutError.__sizeof__" => "Size of object in memory, in bytes.",
     "builtins.TimeoutError.__str__" => "Return str(self).",
     "builtins.TimeoutError.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
-    "builtins.TimeoutError.add_note" => "Exception.add_note(note) --\nadd a note to the exception",
+    "builtins.TimeoutError.add_note" => "Add a note to the exception",
     "builtins.TimeoutError.errno" => "POSIX exception code",
     "builtins.TimeoutError.filename" => "exception filename",
     "builtins.TimeoutError.filename2" => "second exception filename",
     "builtins.TimeoutError.strerror" => "exception strerror",
     "builtins.TimeoutError.winerror" => "Win32 exception code",
-    "builtins.TimeoutError.with_traceback" => "Exception.with_traceback(tb) --\nset self.__traceback__ to tb and return self.",
+    "builtins.TimeoutError.with_traceback" => "Set self.__traceback__ to tb and return self.",
     "builtins.TypeError" => "Inappropriate argument type.",
-    "builtins.TypeError.__cause__" => "exception cause",
-    "builtins.TypeError.__context__" => "exception context",
     "builtins.TypeError.__delattr__" => "Implement delattr(self, name).",
     "builtins.TypeError.__eq__" => "Return self==value.",
     "builtins.TypeError.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
@@ -5382,11 +11268,9 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "builtins.TypeError.__sizeof__" => "Size of object in memory, in bytes.",
     "builtins.TypeError.__str__" => "Return str(self).",
     "builtins.TypeError.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
-    "builtins.TypeError.add_note" => "Exception.add_note(note) --\nadd a note to the exception",
-    "builtins.TypeError.with_traceback" => "Exception.with_traceback(tb) --\nset self.__traceback__ to tb and return self.",
+    "builtins.TypeError.add_note" => "Add a note to the exception",
+    "builtins.TypeError.with_traceback" => "Set self.__traceback__ to tb and return self.",
     "builtins.UnboundLocalError" => "Local name referenced but not bound to a value.",
-    "builtins.UnboundLocalError.__cause__" => "exception cause",
-    "builtins.UnboundLocalError.__context__" => "exception context",
     "builtins.UnboundLocalError.__delattr__" => "Implement delattr(self, name).",
     "builtins.UnboundLocalError.__eq__" => "Return self==value.",
     "builtins.UnboundLocalError.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
@@ -5407,12 +11291,10 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "builtins.UnboundLocalError.__sizeof__" => "Size of object in memory, in bytes.",
     "builtins.UnboundLocalError.__str__" => "Return str(self).",
     "builtins.UnboundLocalError.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
-    "builtins.UnboundLocalError.add_note" => "Exception.add_note(note) --\nadd a note to the exception",
+    "builtins.UnboundLocalError.add_note" => "Add a note to the exception",
     "builtins.UnboundLocalError.name" => "name",
-    "builtins.UnboundLocalError.with_traceback" => "Exception.with_traceback(tb) --\nset self.__traceback__ to tb and return self.",
+    "builtins.UnboundLocalError.with_traceback" => "Set self.__traceback__ to tb and return self.",
     "builtins.UnicodeDecodeError" => "Unicode decoding error.",
-    "builtins.UnicodeDecodeError.__cause__" => "exception cause",
-    "builtins.UnicodeDecodeError.__context__" => "exception context",
     "builtins.UnicodeDecodeError.__delattr__" => "Implement delattr(self, name).",
     "builtins.UnicodeDecodeError.__eq__" => "Return self==value.",
     "builtins.UnicodeDecodeError.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
@@ -5433,16 +11315,14 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "builtins.UnicodeDecodeError.__sizeof__" => "Size of object in memory, in bytes.",
     "builtins.UnicodeDecodeError.__str__" => "Return str(self).",
     "builtins.UnicodeDecodeError.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
-    "builtins.UnicodeDecodeError.add_note" => "Exception.add_note(note) --\nadd a note to the exception",
+    "builtins.UnicodeDecodeError.add_note" => "Add a note to the exception",
     "builtins.UnicodeDecodeError.encoding" => "exception encoding",
     "builtins.UnicodeDecodeError.end" => "exception end",
     "builtins.UnicodeDecodeError.object" => "exception object",
     "builtins.UnicodeDecodeError.reason" => "exception reason",
     "builtins.UnicodeDecodeError.start" => "exception start",
-    "builtins.UnicodeDecodeError.with_traceback" => "Exception.with_traceback(tb) --\nset self.__traceback__ to tb and return self.",
+    "builtins.UnicodeDecodeError.with_traceback" => "Set self.__traceback__ to tb and return self.",
     "builtins.UnicodeEncodeError" => "Unicode encoding error.",
-    "builtins.UnicodeEncodeError.__cause__" => "exception cause",
-    "builtins.UnicodeEncodeError.__context__" => "exception context",
     "builtins.UnicodeEncodeError.__delattr__" => "Implement delattr(self, name).",
     "builtins.UnicodeEncodeError.__eq__" => "Return self==value.",
     "builtins.UnicodeEncodeError.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
@@ -5463,16 +11343,14 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "builtins.UnicodeEncodeError.__sizeof__" => "Size of object in memory, in bytes.",
     "builtins.UnicodeEncodeError.__str__" => "Return str(self).",
     "builtins.UnicodeEncodeError.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
-    "builtins.UnicodeEncodeError.add_note" => "Exception.add_note(note) --\nadd a note to the exception",
+    "builtins.UnicodeEncodeError.add_note" => "Add a note to the exception",
     "builtins.UnicodeEncodeError.encoding" => "exception encoding",
     "builtins.UnicodeEncodeError.end" => "exception end",
     "builtins.UnicodeEncodeError.object" => "exception object",
     "builtins.UnicodeEncodeError.reason" => "exception reason",
     "builtins.UnicodeEncodeError.start" => "exception start",
-    "builtins.UnicodeEncodeError.with_traceback" => "Exception.with_traceback(tb) --\nset self.__traceback__ to tb and return self.",
+    "builtins.UnicodeEncodeError.with_traceback" => "Set self.__traceback__ to tb and return self.",
     "builtins.UnicodeError" => "Unicode related error.",
-    "builtins.UnicodeError.__cause__" => "exception cause",
-    "builtins.UnicodeError.__context__" => "exception context",
     "builtins.UnicodeError.__delattr__" => "Implement delattr(self, name).",
     "builtins.UnicodeError.__eq__" => "Return self==value.",
     "builtins.UnicodeError.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
@@ -5493,11 +11371,9 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "builtins.UnicodeError.__sizeof__" => "Size of object in memory, in bytes.",
     "builtins.UnicodeError.__str__" => "Return str(self).",
     "builtins.UnicodeError.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
-    "builtins.UnicodeError.add_note" => "Exception.add_note(note) --\nadd a note to the exception",
-    "builtins.UnicodeError.with_traceback" => "Exception.with_traceback(tb) --\nset self.__traceback__ to tb and return self.",
+    "builtins.UnicodeError.add_note" => "Add a note to the exception",
+    "builtins.UnicodeError.with_traceback" => "Set self.__traceback__ to tb and return self.",
     "builtins.UnicodeTranslateError" => "Unicode translation error.",
-    "builtins.UnicodeTranslateError.__cause__" => "exception cause",
-    "builtins.UnicodeTranslateError.__context__" => "exception context",
     "builtins.UnicodeTranslateError.__delattr__" => "Implement delattr(self, name).",
     "builtins.UnicodeTranslateError.__eq__" => "Return self==value.",
     "builtins.UnicodeTranslateError.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
@@ -5518,16 +11394,14 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "builtins.UnicodeTranslateError.__sizeof__" => "Size of object in memory, in bytes.",
     "builtins.UnicodeTranslateError.__str__" => "Return str(self).",
     "builtins.UnicodeTranslateError.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
-    "builtins.UnicodeTranslateError.add_note" => "Exception.add_note(note) --\nadd a note to the exception",
+    "builtins.UnicodeTranslateError.add_note" => "Add a note to the exception",
     "builtins.UnicodeTranslateError.encoding" => "exception encoding",
     "builtins.UnicodeTranslateError.end" => "exception end",
     "builtins.UnicodeTranslateError.object" => "exception object",
     "builtins.UnicodeTranslateError.reason" => "exception reason",
     "builtins.UnicodeTranslateError.start" => "exception start",
-    "builtins.UnicodeTranslateError.with_traceback" => "Exception.with_traceback(tb) --\nset self.__traceback__ to tb and return self.",
+    "builtins.UnicodeTranslateError.with_traceback" => "Set self.__traceback__ to tb and return self.",
     "builtins.UnicodeWarning" => "Base class for warnings about Unicode related problems, mostly\nrelated to conversion problems.",
-    "builtins.UnicodeWarning.__cause__" => "exception cause",
-    "builtins.UnicodeWarning.__context__" => "exception context",
     "builtins.UnicodeWarning.__delattr__" => "Implement delattr(self, name).",
     "builtins.UnicodeWarning.__eq__" => "Return self==value.",
     "builtins.UnicodeWarning.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
@@ -5548,37 +11422,37 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "builtins.UnicodeWarning.__sizeof__" => "Size of object in memory, in bytes.",
     "builtins.UnicodeWarning.__str__" => "Return str(self).",
     "builtins.UnicodeWarning.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
-    "builtins.UnicodeWarning.add_note" => "Exception.add_note(note) --\nadd a note to the exception",
-    "builtins.UnicodeWarning.with_traceback" => "Exception.with_traceback(tb) --\nset self.__traceback__ to tb and return self.",
-    "builtins.UnionType" => "Represent a PEP 604 union type\n\nE.g. for int | str",
-    "builtins.UnionType.__delattr__" => "Implement delattr(self, name).",
-    "builtins.UnionType.__eq__" => "Return self==value.",
-    "builtins.UnionType.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
-    "builtins.UnionType.__ge__" => "Return self>=value.",
-    "builtins.UnionType.__getattribute__" => "Return getattr(self, name).",
-    "builtins.UnionType.__getitem__" => "Return self[key].",
-    "builtins.UnionType.__getstate__" => "Helper for pickle.",
-    "builtins.UnionType.__gt__" => "Return self>value.",
-    "builtins.UnionType.__hash__" => "Return hash(self).",
-    "builtins.UnionType.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
-    "builtins.UnionType.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
-    "builtins.UnionType.__le__" => "Return self<=value.",
-    "builtins.UnionType.__lt__" => "Return self<value.",
-    "builtins.UnionType.__ne__" => "Return self!=value.",
-    "builtins.UnionType.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
-    "builtins.UnionType.__or__" => "Return self|value.",
-    "builtins.UnionType.__parameters__" => "Type variables in the types.UnionType.",
-    "builtins.UnionType.__reduce__" => "Helper for pickle.",
-    "builtins.UnionType.__reduce_ex__" => "Helper for pickle.",
-    "builtins.UnionType.__repr__" => "Return repr(self).",
-    "builtins.UnionType.__ror__" => "Return value|self.",
-    "builtins.UnionType.__setattr__" => "Implement setattr(self, name, value).",
-    "builtins.UnionType.__sizeof__" => "Size of object in memory, in bytes.",
-    "builtins.UnionType.__str__" => "Return str(self).",
-    "builtins.UnionType.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "builtins.UnicodeWarning.add_note" => "Add a note to the exception",
+    "builtins.UnicodeWarning.with_traceback" => "Set self.__traceback__ to tb and return self.",
+    "builtins.Union" => "Represent a union type\n\nE.g. for int | str",
+    "builtins.Union.__class_getitem__" => "See PEP 585",
+    "builtins.Union.__delattr__" => "Implement delattr(self, name).",
+    "builtins.Union.__eq__" => "Return self==value.",
+    "builtins.Union.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "builtins.Union.__ge__" => "Return self>=value.",
+    "builtins.Union.__getattribute__" => "Return getattr(self, name).",
+    "builtins.Union.__getitem__" => "Return self[key].",
+    "builtins.Union.__getstate__" => "Helper for pickle.",
+    "builtins.Union.__gt__" => "Return self>value.",
+    "builtins.Union.__hash__" => "Return hash(self).",
+    "builtins.Union.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "builtins.Union.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "builtins.Union.__le__" => "Return self<=value.",
+    "builtins.Union.__lt__" => "Return self<value.",
+    "builtins.Union.__ne__" => "Return self!=value.",
+    "builtins.Union.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "builtins.Union.__or__" => "Return self|value.",
+    "builtins.Union.__origin__" => "Always returns the type",
+    "builtins.Union.__parameters__" => "Type variables in the types.UnionType.",
+    "builtins.Union.__reduce__" => "Helper for pickle.",
+    "builtins.Union.__reduce_ex__" => "Helper for pickle.",
+    "builtins.Union.__repr__" => "Return repr(self).",
+    "builtins.Union.__ror__" => "Return value|self.",
+    "builtins.Union.__setattr__" => "Implement setattr(self, name, value).",
+    "builtins.Union.__sizeof__" => "Size of object in memory, in bytes.",
+    "builtins.Union.__str__" => "Return str(self).",
+    "builtins.Union.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
     "builtins.UserWarning" => "Base class for warnings generated by user code.",
-    "builtins.UserWarning.__cause__" => "exception cause",
-    "builtins.UserWarning.__context__" => "exception context",
     "builtins.UserWarning.__delattr__" => "Implement delattr(self, name).",
     "builtins.UserWarning.__eq__" => "Return self==value.",
     "builtins.UserWarning.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
@@ -5599,11 +11473,9 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "builtins.UserWarning.__sizeof__" => "Size of object in memory, in bytes.",
     "builtins.UserWarning.__str__" => "Return str(self).",
     "builtins.UserWarning.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
-    "builtins.UserWarning.add_note" => "Exception.add_note(note) --\nadd a note to the exception",
-    "builtins.UserWarning.with_traceback" => "Exception.with_traceback(tb) --\nset self.__traceback__ to tb and return self.",
+    "builtins.UserWarning.add_note" => "Add a note to the exception",
+    "builtins.UserWarning.with_traceback" => "Set self.__traceback__ to tb and return self.",
     "builtins.ValueError" => "Inappropriate argument value (of correct type).",
-    "builtins.ValueError.__cause__" => "exception cause",
-    "builtins.ValueError.__context__" => "exception context",
     "builtins.ValueError.__delattr__" => "Implement delattr(self, name).",
     "builtins.ValueError.__eq__" => "Return self==value.",
     "builtins.ValueError.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
@@ -5624,11 +11496,9 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "builtins.ValueError.__sizeof__" => "Size of object in memory, in bytes.",
     "builtins.ValueError.__str__" => "Return str(self).",
     "builtins.ValueError.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
-    "builtins.ValueError.add_note" => "Exception.add_note(note) --\nadd a note to the exception",
-    "builtins.ValueError.with_traceback" => "Exception.with_traceback(tb) --\nset self.__traceback__ to tb and return self.",
+    "builtins.ValueError.add_note" => "Add a note to the exception",
+    "builtins.ValueError.with_traceback" => "Set self.__traceback__ to tb and return self.",
     "builtins.Warning" => "Base class for warning categories.",
-    "builtins.Warning.__cause__" => "exception cause",
-    "builtins.Warning.__context__" => "exception context",
     "builtins.Warning.__delattr__" => "Implement delattr(self, name).",
     "builtins.Warning.__eq__" => "Return self==value.",
     "builtins.Warning.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
@@ -5649,11 +11519,9 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "builtins.Warning.__sizeof__" => "Size of object in memory, in bytes.",
     "builtins.Warning.__str__" => "Return str(self).",
     "builtins.Warning.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
-    "builtins.Warning.add_note" => "Exception.add_note(note) --\nadd a note to the exception",
-    "builtins.Warning.with_traceback" => "Exception.with_traceback(tb) --\nset self.__traceback__ to tb and return self.",
+    "builtins.Warning.add_note" => "Add a note to the exception",
+    "builtins.Warning.with_traceback" => "Set self.__traceback__ to tb and return self.",
     "builtins.WindowsError" => "Base class for I/O related errors.",
-    "builtins.WindowsError.__cause__" => "exception cause",
-    "builtins.WindowsError.__context__" => "exception context",
     "builtins.WindowsError.__delattr__" => "Implement delattr(self, name).",
     "builtins.WindowsError.__eq__" => "Return self==value.",
     "builtins.WindowsError.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
@@ -5674,16 +11542,14 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "builtins.WindowsError.__sizeof__" => "Size of object in memory, in bytes.",
     "builtins.WindowsError.__str__" => "Return str(self).",
     "builtins.WindowsError.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
-    "builtins.WindowsError.add_note" => "Exception.add_note(note) --\nadd a note to the exception",
+    "builtins.WindowsError.add_note" => "Add a note to the exception",
     "builtins.WindowsError.errno" => "POSIX exception code",
     "builtins.WindowsError.filename" => "exception filename",
     "builtins.WindowsError.filename2" => "second exception filename",
     "builtins.WindowsError.strerror" => "exception strerror",
     "builtins.WindowsError.winerror" => "Win32 exception code",
-    "builtins.WindowsError.with_traceback" => "Exception.with_traceback(tb) --\nset self.__traceback__ to tb and return self.",
+    "builtins.WindowsError.with_traceback" => "Set self.__traceback__ to tb and return self.",
     "builtins.ZeroDivisionError" => "Second argument to a division or modulo operation was zero.",
-    "builtins.ZeroDivisionError.__cause__" => "exception cause",
-    "builtins.ZeroDivisionError.__context__" => "exception context",
     "builtins.ZeroDivisionError.__delattr__" => "Implement delattr(self, name).",
     "builtins.ZeroDivisionError.__eq__" => "Return self==value.",
     "builtins.ZeroDivisionError.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
@@ -5704,11 +11570,9 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "builtins.ZeroDivisionError.__sizeof__" => "Size of object in memory, in bytes.",
     "builtins.ZeroDivisionError.__str__" => "Return str(self).",
     "builtins.ZeroDivisionError.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
-    "builtins.ZeroDivisionError.add_note" => "Exception.add_note(note) --\nadd a note to the exception",
-    "builtins.ZeroDivisionError.with_traceback" => "Exception.with_traceback(tb) --\nset self.__traceback__ to tb and return self.",
+    "builtins.ZeroDivisionError.add_note" => "Add a note to the exception",
+    "builtins.ZeroDivisionError.with_traceback" => "Set self.__traceback__ to tb and return self.",
     "builtins._IncompleteInputError" => "incomplete input.",
-    "builtins._IncompleteInputError.__cause__" => "exception cause",
-    "builtins._IncompleteInputError.__context__" => "exception context",
     "builtins._IncompleteInputError.__delattr__" => "Implement delattr(self, name).",
     "builtins._IncompleteInputError.__eq__" => "Return self==value.",
     "builtins._IncompleteInputError.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
@@ -5729,7 +11593,8 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "builtins._IncompleteInputError.__sizeof__" => "Size of object in memory, in bytes.",
     "builtins._IncompleteInputError.__str__" => "Return str(self).",
     "builtins._IncompleteInputError.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
-    "builtins._IncompleteInputError.add_note" => "Exception.add_note(note) --\nadd a note to the exception",
+    "builtins._IncompleteInputError._metadata" => "exception private metadata",
+    "builtins._IncompleteInputError.add_note" => "Add a note to the exception",
     "builtins._IncompleteInputError.end_lineno" => "exception end lineno",
     "builtins._IncompleteInputError.end_offset" => "exception end offset",
     "builtins._IncompleteInputError.filename" => "exception filename",
@@ -5738,7 +11603,7 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "builtins._IncompleteInputError.offset" => "exception offset",
     "builtins._IncompleteInputError.print_file_and_line" => "exception print_file_and_line",
     "builtins._IncompleteInputError.text" => "exception text",
-    "builtins._IncompleteInputError.with_traceback" => "Exception.with_traceback(tb) --\nset self.__traceback__ to tb and return self.",
+    "builtins._IncompleteInputError.with_traceback" => "Set self.__traceback__ to tb and return self.",
     "builtins.__build_class__" => "__build_class__(func, name, /, *bases, [metaclass], **kwds) -> class\n\nInternal helper function used by the class statement.",
     "builtins.__import__" => "Import a module.\n\nBecause this function is meant for use by the Python\ninterpreter and not for general use, it is better to use\nimportlib.import_module() to programmatically import a module.\n\nThe globals argument is only used to determine the context;\nthey are not modified.  The locals argument is unused.  The fromlist\nshould be a list of names to emulate ``from name import ...``, or an\nempty list to emulate ``import name``.\nWhen importing a module from a package, note that __import__('A.B', ...)\nreturns package A when fromlist is empty, but its submodule B when\nfromlist is not empty.  The level argument is used to determine whether to\nperform absolute or relative imports: 0 is absolute, while a positive number\nis the number of parent directories to search relative to the current module.",
     "builtins.abs" => "Return the absolute value of the argument.",
@@ -5776,7 +11641,7 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "builtins.async_generator.ag_await" => "object being awaited on, or None",
     "builtins.async_generator.asend" => "asend(v) -> send 'v' in generator.",
     "builtins.async_generator.athrow" => "athrow(value)\nathrow(type[,value[,tb]])\n\nraise exception in generator.\nthe (type, val, tb) signature is deprecated, \nand may be removed in a future version of Python.",
-    "builtins.bin" => "Return the binary representation of an integer.\n\n>>> bin(2796202)\n'0b1010101010101010101010'",
+    "builtins.bin" => "Return the binary representation of an integer.\n\n   >>> bin(2796202)\n   '0b1010101010101010101010'",
     "builtins.bool" => "Returns True when the argument is true, False otherwise.\nThe builtins True and False are the only two instances of the class bool.\nThe class bool is a subclass of the class int, and cannot be subclassed.",
     "builtins.bool.__abs__" => "abs(self)",
     "builtins.bool.__add__" => "Return self+value.",
@@ -5842,12 +11707,12 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "builtins.bool.bit_length" => "Number of bits necessary to represent self in binary.\n\n>>> bin(37)\n'0b100101'\n>>> (37).bit_length()\n6",
     "builtins.bool.conjugate" => "Returns self, the complex conjugate of any int.",
     "builtins.bool.denominator" => "the denominator of a rational number in lowest terms",
-    "builtins.bool.from_bytes" => "Return the integer represented by the given array of bytes.\n\nbytes\n  Holds the array of bytes to convert.  The argument must either\n  support the buffer protocol or be an iterable object producing bytes.\n  Bytes and bytearray are examples of built-in objects that support the\n  buffer protocol.\nbyteorder\n  The byte order used to represent the integer.  If byteorder is 'big',\n  the most significant byte is at the beginning of the byte array.  If\n  byteorder is 'little', the most significant byte is at the end of the\n  byte array.  To request the native byte order of the host system, use\n  sys.byteorder as the byte order value.  Default is to use 'big'.\nsigned\n  Indicates whether two's complement is used to represent the integer.",
+    "builtins.bool.from_bytes" => "Return the integer represented by the given array of bytes.\n\n  bytes\n    Holds the array of bytes to convert.  The argument must either\n    support the buffer protocol or be an iterable object producing bytes.\n    Bytes and bytearray are examples of built-in objects that support the\n    buffer protocol.\n  byteorder\n    The byte order used to represent the integer.  If byteorder is 'big',\n    the most significant byte is at the beginning of the byte array.  If\n    byteorder is 'little', the most significant byte is at the end of the\n    byte array.  To request the native byte order of the host system, use\n    sys.byteorder as the byte order value.  Default is to use 'big'.\n  signed\n    Indicates whether two's complement is used to represent the integer.",
     "builtins.bool.imag" => "the imaginary part of a complex number",
     "builtins.bool.is_integer" => "Returns True. Exists for duck type compatibility with float.is_integer.",
     "builtins.bool.numerator" => "the numerator of a rational number in lowest terms",
     "builtins.bool.real" => "the real part of a complex number",
-    "builtins.bool.to_bytes" => "Return an array of bytes representing an integer.\n\nlength\n  Length of bytes object to use.  An OverflowError is raised if the\n  integer is not representable with the given number of bytes.  Default\n  is length 1.\nbyteorder\n  The byte order used to represent the integer.  If byteorder is 'big',\n  the most significant byte is at the beginning of the byte array.  If\n  byteorder is 'little', the most significant byte is at the end of the\n  byte array.  To request the native byte order of the host system, use\n  sys.byteorder as the byte order value.  Default is to use 'big'.\nsigned\n  Determines whether two's complement is used to represent the integer.\n  If signed is False and a negative integer is given, an OverflowError\n  is raised.",
+    "builtins.bool.to_bytes" => "Return an array of bytes representing an integer.\n\n  length\n    Length of bytes object to use.  An OverflowError is raised if the\n    integer is not representable with the given number of bytes.  Default\n    is length 1.\n  byteorder\n    The byte order used to represent the integer.  If byteorder is 'big',\n    the most significant byte is at the beginning of the byte array.  If\n    byteorder is 'little', the most significant byte is at the end of the\n    byte array.  To request the native byte order of the host system, use\n    sys.byteorder as the byte order value.  Default is to use 'big'.\n  signed\n    Determines whether two's complement is used to represent the integer.\n    If signed is False and a negative integer is given, an OverflowError\n    is raised.",
     "builtins.breakpoint" => "Call sys.breakpointhook(*args, **kws).  sys.breakpointhook() must accept\nwhatever arguments are passed.\n\nBy default, this drops you into the pdb debugger.",
     "builtins.builtin_function_or_method.__call__" => "Call self as a function.",
     "builtins.builtin_function_or_method.__delattr__" => "Implement delattr(self, name).",
@@ -5907,21 +11772,21 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "builtins.bytearray.__sizeof__" => "Returns the size of the bytearray object in memory, in bytes.",
     "builtins.bytearray.__str__" => "Return str(self).",
     "builtins.bytearray.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
-    "builtins.bytearray.append" => "Append a single item to the end of the bytearray.\n\nitem\n  The item to be appended.",
+    "builtins.bytearray.append" => "Append a single item to the end of the bytearray.\n\n  item\n    The item to be appended.",
     "builtins.bytearray.capitalize" => "B.capitalize() -> copy of B\n\nReturn a copy of B with only its first character capitalized (ASCII)\nand the rest lower-cased.",
     "builtins.bytearray.center" => "Return a centered string of length width.\n\nPadding is done using the specified fill character.",
     "builtins.bytearray.clear" => "Remove all items from the bytearray.",
     "builtins.bytearray.copy" => "Return a copy of B.",
-    "builtins.bytearray.count" => "Return the number of non-overlapping occurrences of subsection 'sub' in bytes B[start:end].\n\nstart\n  Optional start position. Default: start of the bytes.\nend\n  Optional stop position. Default: end of the bytes.",
-    "builtins.bytearray.decode" => "Decode the bytearray using the codec registered for encoding.\n\nencoding\n  The encoding with which to decode the bytearray.\nerrors\n  The error handling scheme to use for the handling of decoding errors.\n  The default is 'strict' meaning that decoding errors raise a\n  UnicodeDecodeError. Other possible values are 'ignore' and 'replace'\n  as well as any other name registered with codecs.register_error that\n  can handle UnicodeDecodeErrors.",
-    "builtins.bytearray.endswith" => "Return True if the bytearray ends with the specified suffix, False otherwise.\n\nsuffix\n  A bytes or a tuple of bytes to try.\nstart\n  Optional start position. Default: start of the bytearray.\nend\n  Optional stop position. Default: end of the bytearray.",
+    "builtins.bytearray.count" => "Return the number of non-overlapping occurrences of subsection 'sub' in bytes B[start:end].\n\n  start\n    Optional start position. Default: start of the bytes.\n  end\n    Optional stop position. Default: end of the bytes.",
+    "builtins.bytearray.decode" => "Decode the bytearray using the codec registered for encoding.\n\n  encoding\n    The encoding with which to decode the bytearray.\n  errors\n    The error handling scheme to use for the handling of decoding errors.\n    The default is 'strict' meaning that decoding errors raise a\n    UnicodeDecodeError. Other possible values are 'ignore' and 'replace'\n    as well as any other name registered with codecs.register_error that\n    can handle UnicodeDecodeErrors.",
+    "builtins.bytearray.endswith" => "Return True if the bytearray ends with the specified suffix, False otherwise.\n\n  suffix\n    A bytes or a tuple of bytes to try.\n  start\n    Optional start position. Default: start of the bytearray.\n  end\n    Optional stop position. Default: end of the bytearray.",
     "builtins.bytearray.expandtabs" => "Return a copy where all tab characters are expanded using spaces.\n\nIf tabsize is not given, a tab size of 8 characters is assumed.",
-    "builtins.bytearray.extend" => "Append all the items from the iterator or sequence to the end of the bytearray.\n\niterable_of_ints\n  The iterable of items to append.",
+    "builtins.bytearray.extend" => "Append all the items from the iterator or sequence to the end of the bytearray.\n\n  iterable_of_ints\n    The iterable of items to append.",
     "builtins.bytearray.find" => "Return the lowest index in B where subsection 'sub' is found, such that 'sub' is contained within B[start:end].\n\n  start\n    Optional start position. Default: start of the bytes.\n  end\n    Optional stop position. Default: end of the bytes.\n\nReturn -1 on failure.",
     "builtins.bytearray.fromhex" => "Create a bytearray object from a string of hexadecimal numbers.\n\nSpaces between two numbers are accepted.\nExample: bytearray.fromhex('B9 01EF') -> bytearray(b'\\\\xb9\\\\x01\\\\xef')",
     "builtins.bytearray.hex" => "Create a string of hexadecimal numbers from a bytearray object.\n\n  sep\n    An optional single character or byte to separate hex bytes.\n  bytes_per_sep\n    How many bytes between separators.  Positive values count from the\n    right, negative values count from the left.\n\nExample:\n>>> value = bytearray([0xb9, 0x01, 0xef])\n>>> value.hex()\n'b901ef'\n>>> value.hex(':')\n'b9:01:ef'\n>>> value.hex(':', 2)\n'b9:01ef'\n>>> value.hex(':', -2)\n'b901:ef'",
     "builtins.bytearray.index" => "Return the lowest index in B where subsection 'sub' is found, such that 'sub' is contained within B[start:end].\n\n  start\n    Optional start position. Default: start of the bytes.\n  end\n    Optional stop position. Default: end of the bytes.\n\nRaise ValueError if the subsection is not found.",
-    "builtins.bytearray.insert" => "Insert a single item into the bytearray before the given index.\n\nindex\n  The index where the value is to be inserted.\nitem\n  The item to be inserted.",
+    "builtins.bytearray.insert" => "Insert a single item into the bytearray before the given index.\n\n  index\n    The index where the value is to be inserted.\n  item\n    The item to be inserted.",
     "builtins.bytearray.isalnum" => "B.isalnum() -> bool\n\nReturn True if all characters in B are alphanumeric\nand there is at least one character in B, False otherwise.",
     "builtins.bytearray.isalpha" => "B.isalpha() -> bool\n\nReturn True if all characters in B are alphabetic\nand there is at least one character in B, False otherwise.",
     "builtins.bytearray.isascii" => "B.isascii() -> bool\n\nReturn True if B is empty or all characters in B are ASCII,\nFalse otherwise.",
@@ -5937,10 +11802,11 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "builtins.bytearray.maketrans" => "Return a translation table usable for the bytes or bytearray translate method.\n\nThe returned table will be one where each byte in frm is mapped to the byte at\nthe same position in to.\n\nThe bytes objects frm and to must be of the same length.",
     "builtins.bytearray.partition" => "Partition the bytearray into three parts using the given separator.\n\nThis will search for the separator sep in the bytearray. If the separator is\nfound, returns a 3-tuple containing the part before the separator, the\nseparator itself, and the part after it as new bytearray objects.\n\nIf the separator is not found, returns a 3-tuple containing the copy of the\noriginal bytearray object and two empty bytearray objects.",
     "builtins.bytearray.pop" => "Remove and return a single item from B.\n\n  index\n    The index from where to remove the item.\n    -1 (the default value) means remove the last item.\n\nIf no index argument is given, will pop the last item.",
-    "builtins.bytearray.remove" => "Remove the first occurrence of a value in the bytearray.\n\nvalue\n  The value to remove.",
+    "builtins.bytearray.remove" => "Remove the first occurrence of a value in the bytearray.\n\n  value\n    The value to remove.",
     "builtins.bytearray.removeprefix" => "Return a bytearray with the given prefix string removed if present.\n\nIf the bytearray starts with the prefix string, return\nbytearray[len(prefix):].  Otherwise, return a copy of the original\nbytearray.",
     "builtins.bytearray.removesuffix" => "Return a bytearray with the given suffix string removed if present.\n\nIf the bytearray ends with the suffix string and that suffix is not\nempty, return bytearray[:-len(suffix)].  Otherwise, return a copy of\nthe original bytearray.",
     "builtins.bytearray.replace" => "Return a copy with all occurrences of substring old replaced by new.\n\n  count\n    Maximum number of occurrences to replace.\n    -1 (the default value) means replace all occurrences.\n\nIf the optional argument count is given, only the first count occurrences are\nreplaced.",
+    "builtins.bytearray.resize" => "Resize the internal buffer of bytearray to len.\n\n  size\n    New size to resize to.",
     "builtins.bytearray.reverse" => "Reverse the order of the values in B in place.",
     "builtins.bytearray.rfind" => "Return the highest index in B where subsection 'sub' is found, such that 'sub' is contained within B[start:end].\n\n  start\n    Optional start position. Default: start of the bytes.\n  end\n    Optional stop position. Default: end of the bytes.\n\nReturn -1 on failure.",
     "builtins.bytearray.rindex" => "Return the highest index in B where subsection 'sub' is found, such that 'sub' is contained within B[start:end].\n\n  start\n    Optional start position. Default: start of the bytes.\n  end\n    Optional stop position. Default: end of the bytes.\n\nRaise ValueError if the subsection is not found.",
@@ -5948,9 +11814,9 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "builtins.bytearray.rpartition" => "Partition the bytearray into three parts using the given separator.\n\nThis will search for the separator sep in the bytearray, starting at the end.\nIf the separator is found, returns a 3-tuple containing the part before the\nseparator, the separator itself, and the part after it as new bytearray\nobjects.\n\nIf the separator is not found, returns a 3-tuple containing two empty bytearray\nobjects and the copy of the original bytearray object.",
     "builtins.bytearray.rsplit" => "Return a list of the sections in the bytearray, using sep as the delimiter.\n\n  sep\n    The delimiter according which to split the bytearray.\n    None (the default value) means split on ASCII whitespace characters\n    (space, tab, return, newline, formfeed, vertical tab).\n  maxsplit\n    Maximum number of splits to do.\n    -1 (the default value) means no limit.\n\nSplitting is done starting at the end of the bytearray and working to the front.",
     "builtins.bytearray.rstrip" => "Strip trailing bytes contained in the argument.\n\nIf the argument is omitted or None, strip trailing ASCII whitespace.",
-    "builtins.bytearray.split" => "Return a list of the sections in the bytearray, using sep as the delimiter.\n\nsep\n  The delimiter according which to split the bytearray.\n  None (the default value) means split on ASCII whitespace characters\n  (space, tab, return, newline, formfeed, vertical tab).\nmaxsplit\n  Maximum number of splits to do.\n  -1 (the default value) means no limit.",
+    "builtins.bytearray.split" => "Return a list of the sections in the bytearray, using sep as the delimiter.\n\n  sep\n    The delimiter according which to split the bytearray.\n    None (the default value) means split on ASCII whitespace characters\n    (space, tab, return, newline, formfeed, vertical tab).\n  maxsplit\n    Maximum number of splits to do.\n    -1 (the default value) means no limit.",
     "builtins.bytearray.splitlines" => "Return a list of the lines in the bytearray, breaking at line boundaries.\n\nLine breaks are not included in the resulting list unless keepends is given and\ntrue.",
-    "builtins.bytearray.startswith" => "Return True if the bytearray starts with the specified prefix, False otherwise.\n\nprefix\n  A bytes or a tuple of bytes to try.\nstart\n  Optional start position. Default: start of the bytearray.\nend\n  Optional stop position. Default: end of the bytearray.",
+    "builtins.bytearray.startswith" => "Return True if the bytearray starts with the specified prefix, False otherwise.\n\n  prefix\n    A bytes or a tuple of bytes to try.\n  start\n    Optional start position. Default: start of the bytearray.\n  end\n    Optional stop position. Default: end of the bytearray.",
     "builtins.bytearray.strip" => "Strip leading and trailing bytes contained in the argument.\n\nIf the argument is omitted or None, strip leading and trailing ASCII whitespace.",
     "builtins.bytearray.swapcase" => "B.swapcase() -> copy of B\n\nReturn a copy of B with uppercase ASCII characters converted\nto lowercase ASCII and vice versa.",
     "builtins.bytearray.title" => "B.title() -> copy of B\n\nReturn a titlecased version of B, i.e. ASCII words start with uppercase\ncharacters, all remaining cased characters have lowercase.",
@@ -6017,9 +11883,9 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "builtins.bytes.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
     "builtins.bytes.capitalize" => "B.capitalize() -> copy of B\n\nReturn a copy of B with only its first character capitalized (ASCII)\nand the rest lower-cased.",
     "builtins.bytes.center" => "Return a centered string of length width.\n\nPadding is done using the specified fill character.",
-    "builtins.bytes.count" => "Return the number of non-overlapping occurrences of subsection 'sub' in bytes B[start:end].\n\nstart\n  Optional start position. Default: start of the bytes.\nend\n  Optional stop position. Default: end of the bytes.",
-    "builtins.bytes.decode" => "Decode the bytes using the codec registered for encoding.\n\nencoding\n  The encoding with which to decode the bytes.\nerrors\n  The error handling scheme to use for the handling of decoding errors.\n  The default is 'strict' meaning that decoding errors raise a\n  UnicodeDecodeError. Other possible values are 'ignore' and 'replace'\n  as well as any other name registered with codecs.register_error that\n  can handle UnicodeDecodeErrors.",
-    "builtins.bytes.endswith" => "Return True if the bytes ends with the specified suffix, False otherwise.\n\nsuffix\n  A bytes or a tuple of bytes to try.\nstart\n  Optional start position. Default: start of the bytes.\nend\n  Optional stop position. Default: end of the bytes.",
+    "builtins.bytes.count" => "Return the number of non-overlapping occurrences of subsection 'sub' in bytes B[start:end].\n\n  start\n    Optional start position. Default: start of the bytes.\n  end\n    Optional stop position. Default: end of the bytes.",
+    "builtins.bytes.decode" => "Decode the bytes using the codec registered for encoding.\n\n  encoding\n    The encoding with which to decode the bytes.\n  errors\n    The error handling scheme to use for the handling of decoding errors.\n    The default is 'strict' meaning that decoding errors raise a\n    UnicodeDecodeError. Other possible values are 'ignore' and 'replace'\n    as well as any other name registered with codecs.register_error that\n    can handle UnicodeDecodeErrors.",
+    "builtins.bytes.endswith" => "Return True if the bytes ends with the specified suffix, False otherwise.\n\n  suffix\n    A bytes or a tuple of bytes to try.\n  start\n    Optional start position. Default: start of the bytes.\n  end\n    Optional stop position. Default: end of the bytes.",
     "builtins.bytes.expandtabs" => "Return a copy where all tab characters are expanded using spaces.\n\nIf tabsize is not given, a tab size of 8 characters is assumed.",
     "builtins.bytes.find" => "Return the lowest index in B where subsection 'sub' is found, such that 'sub' is contained within B[start,end].\n\n  start\n    Optional start position. Default: start of the bytes.\n  end\n    Optional stop position. Default: end of the bytes.\n\nReturn -1 on failure.",
     "builtins.bytes.fromhex" => "Create a bytes object from a string of hexadecimal numbers.\n\nSpaces between two numbers are accepted.\nExample: bytes.fromhex('B9 01EF') -> b'\\\\xb9\\\\x01\\\\xef'.",
@@ -6048,9 +11914,9 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "builtins.bytes.rpartition" => "Partition the bytes into three parts using the given separator.\n\nThis will search for the separator sep in the bytes, starting at the end. If\nthe separator is found, returns a 3-tuple containing the part before the\nseparator, the separator itself, and the part after it.\n\nIf the separator is not found, returns a 3-tuple containing two empty bytes\nobjects and the original bytes object.",
     "builtins.bytes.rsplit" => "Return a list of the sections in the bytes, using sep as the delimiter.\n\n  sep\n    The delimiter according which to split the bytes.\n    None (the default value) means split on ASCII whitespace characters\n    (space, tab, return, newline, formfeed, vertical tab).\n  maxsplit\n    Maximum number of splits to do.\n    -1 (the default value) means no limit.\n\nSplitting is done starting at the end of the bytes and working to the front.",
     "builtins.bytes.rstrip" => "Strip trailing bytes contained in the argument.\n\nIf the argument is omitted or None, strip trailing ASCII whitespace.",
-    "builtins.bytes.split" => "Return a list of the sections in the bytes, using sep as the delimiter.\n\nsep\n  The delimiter according which to split the bytes.\n  None (the default value) means split on ASCII whitespace characters\n  (space, tab, return, newline, formfeed, vertical tab).\nmaxsplit\n  Maximum number of splits to do.\n  -1 (the default value) means no limit.",
+    "builtins.bytes.split" => "Return a list of the sections in the bytes, using sep as the delimiter.\n\n  sep\n    The delimiter according which to split the bytes.\n    None (the default value) means split on ASCII whitespace characters\n    (space, tab, return, newline, formfeed, vertical tab).\n  maxsplit\n    Maximum number of splits to do.\n    -1 (the default value) means no limit.",
     "builtins.bytes.splitlines" => "Return a list of the lines in the bytes, breaking at line boundaries.\n\nLine breaks are not included in the resulting list unless keepends is given and\ntrue.",
-    "builtins.bytes.startswith" => "Return True if the bytes starts with the specified prefix, False otherwise.\n\nprefix\n  A bytes or a tuple of bytes to try.\nstart\n  Optional start position. Default: start of the bytes.\nend\n  Optional stop position. Default: end of the bytes.",
+    "builtins.bytes.startswith" => "Return True if the bytes starts with the specified prefix, False otherwise.\n\n  prefix\n    A bytes or a tuple of bytes to try.\n  start\n    Optional start position. Default: start of the bytes.\n  end\n    Optional stop position. Default: end of the bytes.",
     "builtins.bytes.strip" => "Strip leading and trailing bytes contained in the argument.\n\nIf the argument is omitted or None, strip leading and trailing ASCII whitespace.",
     "builtins.bytes.swapcase" => "B.swapcase() -> copy of B\n\nReturn a copy of B with uppercase ASCII characters converted\nto lowercase ASCII and vice versa.",
     "builtins.bytes.title" => "B.title() -> copy of B\n\nReturn a titlecased version of B, i.e. ASCII words start with uppercase\ncharacters, all remaining cased characters have lowercase.",
@@ -6083,7 +11949,7 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "builtins.bytes_iterator.__str__" => "Return str(self).",
     "builtins.bytes_iterator.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
     "builtins.callable" => "Return whether the object is callable (i.e., some kind of function).\n\nNote that classes are callable, as are instances of classes with a\n__call__() method.",
-    "builtins.cell" => "Create a new cell object.\n\n contents\n   the contents of the cell. If not specified, the cell will be empty,\n   and \nfurther attempts to access its cell_contents attribute will\n   raise a ValueError.",
+    "builtins.cell" => "Create a new cell object.\n\n  contents\n    the contents of the cell. If not specified, the cell will be empty,\n    and \n further attempts to access its cell_contents attribute will\n    raise a ValueError.",
     "builtins.cell.__delattr__" => "Implement delattr(self, name).",
     "builtins.cell.__eq__" => "Return self==value.",
     "builtins.cell.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
@@ -6214,6 +12080,7 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "builtins.complex.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
     "builtins.complex.__truediv__" => "Return self/value.",
     "builtins.complex.conjugate" => "Return the complex conjugate of its argument. (3-4j).conjugate() == 3+4j.",
+    "builtins.complex.from_number" => "Convert number to a complex floating-point number.",
     "builtins.complex.imag" => "the imaginary part of a complex number",
     "builtins.complex.real" => "the real part of a complex number",
     "builtins.coroutine.__await__" => "Return an iterator to be used in await expression.",
@@ -6544,6 +12411,7 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "builtins.float.__trunc__" => "Return the Integral closest to x between 0 and x.",
     "builtins.float.as_integer_ratio" => "Return a pair of integers, whose ratio is exactly equal to the original float.\n\nThe ratio is in lowest terms and has a positive denominator.  Raise\nOverflowError on infinities and a ValueError on NaNs.\n\n>>> (10.0).as_integer_ratio()\n(10, 1)\n>>> (0.0).as_integer_ratio()\n(0, 1)\n>>> (-.25).as_integer_ratio()\n(-1, 4)",
     "builtins.float.conjugate" => "Return self, the complex conjugate of any float.",
+    "builtins.float.from_number" => "Convert real number to a floating-point number.",
     "builtins.float.fromhex" => "Create a floating-point number from a hexadecimal string.\n\n>>> float.fromhex('0x1.ffffp10')\n2047.984375\n>>> float.fromhex('-0x1p-1074')\n-5e-324",
     "builtins.float.hex" => "Return a hexadecimal representation of a floating-point number.\n\n>>> (-0.1).hex()\n'-0x1.999999999999ap-4'\n>>> 3.14159.hex()\n'0x1.921f9f01b866ep+1'",
     "builtins.float.imag" => "the imaginary part of a complex number",
@@ -6568,10 +12436,19 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "builtins.frame.__reduce_ex__" => "Helper for pickle.",
     "builtins.frame.__repr__" => "Return repr(self).",
     "builtins.frame.__setattr__" => "Implement setattr(self, name, value).",
-    "builtins.frame.__sizeof__" => "F.__sizeof__() -> size of F in memory, in bytes",
+    "builtins.frame.__sizeof__" => "Return the size of the frame in memory, in bytes.",
     "builtins.frame.__str__" => "Return str(self).",
     "builtins.frame.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
-    "builtins.frame.clear" => "F.clear(): clear most references held by the frame",
+    "builtins.frame.clear" => "Clear all references held by the frame.",
+    "builtins.frame.f_builtins" => "Return the built-in variables in the frame.",
+    "builtins.frame.f_code" => "Return the code object being executed in this frame.",
+    "builtins.frame.f_generator" => "Return the generator or coroutine associated with this frame, or None.",
+    "builtins.frame.f_globals" => "Return the global variables in the frame.",
+    "builtins.frame.f_lasti" => "Return the index of the last attempted instruction in the frame.",
+    "builtins.frame.f_lineno" => "Return the current line number in the frame.",
+    "builtins.frame.f_locals" => "Return the mapping used by the frame to look up local variables.",
+    "builtins.frame.f_trace" => "Return the trace function for this frame, or None if no trace function is set.",
+    "builtins.frame.f_trace_opcodes" => "Return True if opcode tracing is enabled, False otherwise.",
     "builtins.frozenset" => "Build an immutable unordered collection of unique elements.",
     "builtins.frozenset.__and__" => "Return self&value.",
     "builtins.frozenset.__class_getitem__" => "See PEP 585",
@@ -6614,7 +12491,8 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "builtins.frozenset.issuperset" => "Report whether this set contains another set.",
     "builtins.frozenset.symmetric_difference" => "Return a new set with elements in either the set or other but not both.",
     "builtins.frozenset.union" => "Return a new set with elements from the set and all others.",
-    "builtins.function" => "Create a function object.\n\ncode\n  a code object\nglobals\n  the globals dictionary\nname\n  a string that overrides the name from the code object\nargdefs\n  a tuple that specifies the default argument values\nclosure\n  a tuple that supplies the bindings for free variables\nkwdefaults\n  a dictionary that specifies the default keyword argument values",
+    "builtins.function" => "Create a function object.\n\n  code\n    a code object\n  globals\n    the globals dictionary\n  name\n    a string that overrides the name from the code object\n  argdefs\n    a tuple that specifies the default argument values\n  closure\n    a tuple that supplies the bindings for free variables\n  kwdefaults\n    a dictionary that specifies the default keyword argument values",
+    "builtins.function.__annotate__" => "Get the code object for a function.",
     "builtins.function.__call__" => "Call self as a function.",
     "builtins.function.__delattr__" => "Implement delattr(self, name).",
     "builtins.function.__eq__" => "Return self==value.",
@@ -6696,7 +12574,7 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "builtins.globals" => "Return the dictionary containing the current scope's global variables.\n\nNOTE: Updates to this dictionary *will* affect name lookups in the current\nglobal scope and vice-versa.",
     "builtins.hasattr" => "Return whether the object has an attribute with the given name.\n\nThis is done by calling getattr(obj, name) and catching AttributeError.",
     "builtins.hash" => "Return the hash value for the given object.\n\nTwo objects that compare equal must also have the same hash value, but the\nreverse is not necessarily true.",
-    "builtins.hex" => "Return the hexadecimal representation of an integer.\n\n>>> hex(12648430)\n'0xc0ffee'",
+    "builtins.hex" => "Return the hexadecimal representation of an integer.\n\n   >>> hex(12648430)\n   '0xc0ffee'",
     "builtins.id" => "Return the identity of an object.\n\nThis is guaranteed to be unique among simultaneously existing objects.\n(CPython uses the object's memory address.)",
     "builtins.input" => "Read a string from standard input.  The trailing newline is stripped.\n\nThe prompt string, if given, is printed to standard output without a\ntrailing newline before reading input.\n\nIf the user hits EOF (*nix: Ctrl-D, Windows: Ctrl-Z+Return), raise EOFError.\nOn *nix systems, readline is used if available.",
     "builtins.int" => "int([x]) -> integer\nint(x, base=10) -> integer\n\nConvert a number or string to an integer, or return 0 if no arguments\nare given.  If x is a number, return x.__int__().  For floating-point\nnumbers, this truncates towards zero.\n\nIf x is not a number or if base is given, then x must be a string,\nbytes, or bytearray instance representing an integer literal in the\ngiven base.  The literal can be preceded by '+' or '-' and be surrounded\nby whitespace.  The base defaults to 10.  Valid bases are 0 and 2-36.\nBase 0 means to interpret the base from the string as an integer literal.\n>>> int('0b100', base=0)\n4",
@@ -6764,12 +12642,12 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "builtins.int.bit_length" => "Number of bits necessary to represent self in binary.\n\n>>> bin(37)\n'0b100101'\n>>> (37).bit_length()\n6",
     "builtins.int.conjugate" => "Returns self, the complex conjugate of any int.",
     "builtins.int.denominator" => "the denominator of a rational number in lowest terms",
-    "builtins.int.from_bytes" => "Return the integer represented by the given array of bytes.\n\nbytes\n  Holds the array of bytes to convert.  The argument must either\n  support the buffer protocol or be an iterable object producing bytes.\n  Bytes and bytearray are examples of built-in objects that support the\n  buffer protocol.\nbyteorder\n  The byte order used to represent the integer.  If byteorder is 'big',\n  the most significant byte is at the beginning of the byte array.  If\n  byteorder is 'little', the most significant byte is at the end of the\n  byte array.  To request the native byte order of the host system, use\n  sys.byteorder as the byte order value.  Default is to use 'big'.\nsigned\n  Indicates whether two's complement is used to represent the integer.",
+    "builtins.int.from_bytes" => "Return the integer represented by the given array of bytes.\n\n  bytes\n    Holds the array of bytes to convert.  The argument must either\n    support the buffer protocol or be an iterable object producing bytes.\n    Bytes and bytearray are examples of built-in objects that support the\n    buffer protocol.\n  byteorder\n    The byte order used to represent the integer.  If byteorder is 'big',\n    the most significant byte is at the beginning of the byte array.  If\n    byteorder is 'little', the most significant byte is at the end of the\n    byte array.  To request the native byte order of the host system, use\n    sys.byteorder as the byte order value.  Default is to use 'big'.\n  signed\n    Indicates whether two's complement is used to represent the integer.",
     "builtins.int.imag" => "the imaginary part of a complex number",
     "builtins.int.is_integer" => "Returns True. Exists for duck type compatibility with float.is_integer.",
     "builtins.int.numerator" => "the numerator of a rational number in lowest terms",
     "builtins.int.real" => "the real part of a complex number",
-    "builtins.int.to_bytes" => "Return an array of bytes representing an integer.\n\nlength\n  Length of bytes object to use.  An OverflowError is raised if the\n  integer is not representable with the given number of bytes.  Default\n  is length 1.\nbyteorder\n  The byte order used to represent the integer.  If byteorder is 'big',\n  the most significant byte is at the beginning of the byte array.  If\n  byteorder is 'little', the most significant byte is at the end of the\n  byte array.  To request the native byte order of the host system, use\n  sys.byteorder as the byte order value.  Default is to use 'big'.\nsigned\n  Determines whether two's complement is used to represent the integer.\n  If signed is False and a negative integer is given, an OverflowError\n  is raised.",
+    "builtins.int.to_bytes" => "Return an array of bytes representing an integer.\n\n  length\n    Length of bytes object to use.  An OverflowError is raised if the\n    integer is not representable with the given number of bytes.  Default\n    is length 1.\n  byteorder\n    The byte order used to represent the integer.  If byteorder is 'big',\n    the most significant byte is at the beginning of the byte array.  If\n    byteorder is 'little', the most significant byte is at the end of the\n    byte array.  To request the native byte order of the host system, use\n    sys.byteorder as the byte order value.  Default is to use 'big'.\n  signed\n    Determines whether two's complement is used to represent the integer.\n    If signed is False and a negative integer is given, an OverflowError\n    is raised.",
     "builtins.isinstance" => "Return whether an object is an instance of a class or of a subclass thereof.\n\nA tuple, as in ``isinstance(x, (A, B, ...))``, may be given as the target to\ncheck against. This is equivalent to ``isinstance(x, A) or isinstance(x, B)\nor ...`` etc.",
     "builtins.issubclass" => "Return whether 'cls' is derived from another class or is the same class.\n\nA tuple, as in ``issubclass(x, (A, B, ...))``, may be given as the target to\ncheck against. This is equivalent to ``issubclass(x, A) or issubclass(x, B)\nor ...``.",
     "builtins.iter" => "iter(iterable) -> iterator\niter(callable, sentinel) -> iterator\n\nGet an iterator from an object.  In the first form, the argument must\nsupply its own iterator, or be a sequence.\nIn the second form, the callable is called until it returns the sentinel.",
@@ -6845,7 +12723,7 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "builtins.list_iterator.__str__" => "Return str(self).",
     "builtins.list_iterator.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
     "builtins.locals" => "Return a dictionary containing the current scope's local variables.\n\nNOTE: Whether or not updates to this dictionary will affect name lookups in\nthe local scope and vice-versa is *implementation dependent* and not\ncovered by any backwards compatibility guarantees.",
-    "builtins.map" => "Make an iterator that computes the function using arguments from\neach of the iterables.  Stops when the shortest iterable is exhausted.",
+    "builtins.map" => "Make an iterator that computes the function using arguments from\neach of the iterables.  Stops when the shortest iterable is exhausted.\n\nIf strict is true and one of the arguments is exhausted before the others,\nraise a ValueError.",
     "builtins.map.__delattr__" => "Implement delattr(self, name).",
     "builtins.map.__eq__" => "Return self==value.",
     "builtins.map.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
@@ -6866,6 +12744,7 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "builtins.map.__reduce_ex__" => "Helper for pickle.",
     "builtins.map.__repr__" => "Return repr(self).",
     "builtins.map.__setattr__" => "Implement setattr(self, name, value).",
+    "builtins.map.__setstate__" => "Set state information for unpickling.",
     "builtins.map.__sizeof__" => "Size of object in memory, in bytes.",
     "builtins.map.__str__" => "Return str(self).",
     "builtins.map.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
@@ -6954,6 +12833,7 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "builtins.memory_iterator.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
     "builtins.memoryview" => "Create a new memoryview object which references the given object.",
     "builtins.memoryview.__buffer__" => "Return a buffer object that exposes the underlying memory of the object.",
+    "builtins.memoryview.__class_getitem__" => "See PEP 585",
     "builtins.memoryview.__delattr__" => "Implement delattr(self, name).",
     "builtins.memoryview.__delitem__" => "Delete self[key].",
     "builtins.memoryview.__eq__" => "Return self==value.",
@@ -6986,17 +12866,19 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "builtins.memoryview.c_contiguous" => "A bool indicating whether the memory is C contiguous.",
     "builtins.memoryview.cast" => "Cast a memoryview to a new format or shape.",
     "builtins.memoryview.contiguous" => "A bool indicating whether the memory is contiguous.",
+    "builtins.memoryview.count" => "Count the number of occurrences of a value.",
     "builtins.memoryview.f_contiguous" => "A bool indicating whether the memory is Fortran contiguous.",
-    "builtins.memoryview.format" => "A string containing the format (in struct module style)\nfor each element in the view.",
+    "builtins.memoryview.format" => "A string containing the format (in struct module style)\n for each element in the view.",
     "builtins.memoryview.hex" => "Return the data in the buffer as a str of hexadecimal numbers.\n\n  sep\n    An optional single character or byte to separate hex bytes.\n  bytes_per_sep\n    How many bytes between separators.  Positive values count from the\n    right, negative values count from the left.\n\nExample:\n>>> value = memoryview(b'\\xb9\\x01\\xef')\n>>> value.hex()\n'b901ef'\n>>> value.hex(':')\n'b9:01:ef'\n>>> value.hex(':', 2)\n'b9:01ef'\n>>> value.hex(':', -2)\n'b901:ef'",
+    "builtins.memoryview.index" => "Return the index of the first occurrence of a value.\n\nRaises ValueError if the value is not present.",
     "builtins.memoryview.itemsize" => "The size in bytes of each element of the memoryview.",
-    "builtins.memoryview.nbytes" => "The amount of space in bytes that the array would use in\na contiguous representation.",
-    "builtins.memoryview.ndim" => "An integer indicating how many dimensions of a multi-dimensional\narray the memory represents.",
+    "builtins.memoryview.nbytes" => "The amount of space in bytes that the array would use in\n a contiguous representation.",
+    "builtins.memoryview.ndim" => "An integer indicating how many dimensions of a multi-dimensional\n array the memory represents.",
     "builtins.memoryview.obj" => "The underlying object of the memoryview.",
     "builtins.memoryview.readonly" => "A bool indicating whether the memory is read only.",
     "builtins.memoryview.release" => "Release the underlying buffer exposed by the memoryview object.",
-    "builtins.memoryview.shape" => "A tuple of ndim integers giving the shape of the memory\nas an N-dimensional array.",
-    "builtins.memoryview.strides" => "A tuple of ndim integers giving the size in bytes to access\neach element for each dimension of the array.",
+    "builtins.memoryview.shape" => "A tuple of ndim integers giving the shape of the memory\n as an N-dimensional array.",
+    "builtins.memoryview.strides" => "A tuple of ndim integers giving the size in bytes to access\n each element for each dimension of the array.",
     "builtins.memoryview.suboffsets" => "A tuple of integers used internally for PIL-style arrays.",
     "builtins.memoryview.tobytes" => "Return the data in the buffer as a byte string.\n\nOrder can be {'C', 'F', 'A'}. When order is 'C' or 'F', the data of the\noriginal array is converted to C or Fortran order. For contiguous views,\n'A' returns an exact copy of the physical memory. In particular, in-memory\nFortran order is preserved. For non-contiguous views, the data is converted\nto C first. order=None is the same as order='C'.",
     "builtins.memoryview.tolist" => "Return the data in the buffer as a list of elements.",
@@ -7115,10 +12997,11 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "builtins.object.__sizeof__" => "Size of object in memory, in bytes.",
     "builtins.object.__str__" => "Return str(self).",
     "builtins.object.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
-    "builtins.oct" => "Return the octal representation of an integer.\n\n>>> oct(342391)\n'0o1234567'",
+    "builtins.oct" => "Return the octal representation of an integer.\n\n   >>> oct(342391)\n   '0o1234567'",
+    "builtins.open" => "Open file and return a stream.  Raise OSError upon failure.\n\nfile is either a text or byte string giving the name (and the path\nif the file isn't in the current working directory) of the file to\nbe opened or an integer file descriptor of the file to be\nwrapped. (If a file descriptor is given, it is closed when the\nreturned I/O object is closed, unless closefd is set to False.)\n\nmode is an optional string that specifies the mode in which the file\nis opened. It defaults to 'r' which means open for reading in text\nmode.  Other common values are 'w' for writing (truncating the file if\nit already exists), 'x' for creating and writing to a new file, and\n'a' for appending (which on some Unix systems, means that all writes\nappend to the end of the file regardless of the current seek position).\nIn text mode, if encoding is not specified the encoding used is platform\ndependent: locale.getencoding() is called to get the current locale encoding.\n(For reading and writing raw bytes use binary mode and leave encoding\nunspecified.) The available modes are:\n\n========= ===============================================================\nCharacter Meaning\n--------- ---------------------------------------------------------------\n'r'       open for reading (default)\n'w'       open for writing, truncating the file first\n'x'       create a new file and open it for writing\n'a'       open for writing, appending to the end of the file if it exists\n'b'       binary mode\n't'       text mode (default)\n'+'       open a disk file for updating (reading and writing)\n========= ===============================================================\n\nThe default mode is 'rt' (open for reading text). For binary random\naccess, the mode 'w+b' opens and truncates the file to 0 bytes, while\n'r+b' opens the file without truncation. The 'x' mode implies 'w' and\nraises an `FileExistsError` if the file already exists.\n\nPython distinguishes between files opened in binary and text modes,\neven when the underlying operating system doesn't. Files opened in\nbinary mode (appending 'b' to the mode argument) return contents as\nbytes objects without any decoding. In text mode (the default, or when\n't' is appended to the mode argument), the contents of the file are\nreturned as strings, the bytes having been first decoded using a\nplatform-dependent encoding or using the specified encoding if given.\n\nbuffering is an optional integer used to set the buffering policy.\nPass 0 to switch buffering off (only allowed in binary mode), 1 to select\nline buffering (only usable in text mode), and an integer > 1 to indicate\nthe size of a fixed-size chunk buffer.  When no buffering argument is\ngiven, the default buffering policy works as follows:\n\n* Binary files are buffered in fixed-size chunks; the size of the buffer\n is max(min(blocksize, 8 MiB), DEFAULT_BUFFER_SIZE)\n when the device block size is available.\n On most systems, the buffer will typically be 128 kilobytes long.\n\n* \"Interactive\" text files (files for which isatty() returns True)\n  use line buffering.  Other text files use the policy described above\n  for binary files.\n\nencoding is the name of the encoding used to decode or encode the\nfile. This should only be used in text mode. The default encoding is\nplatform dependent, but any encoding supported by Python can be\npassed.  See the codecs module for the list of supported encodings.\n\nerrors is an optional string that specifies how encoding errors are to\nbe handled---this argument should not be used in binary mode. Pass\n'strict' to raise a ValueError exception if there is an encoding error\n(the default of None has the same effect), or pass 'ignore' to ignore\nerrors. (Note that ignoring encoding errors can lead to data loss.)\nSee the documentation for codecs.register or run 'help(codecs.Codec)'\nfor a list of the permitted encoding error strings.\n\nnewline controls how universal newlines works (it only applies to text\nmode). It can be None, '', '\\n', '\\r', and '\\r\\n'.  It works as\nfollows:\n\n* On input, if newline is None, universal newlines mode is\n  enabled. Lines in the input can end in '\\n', '\\r', or '\\r\\n', and\n  these are translated into '\\n' before being returned to the\n  caller. If it is '', universal newline mode is enabled, but line\n  endings are returned to the caller untranslated. If it has any of\n  the other legal values, input lines are only terminated by the given\n  string, and the line ending is returned to the caller untranslated.\n\n* On output, if newline is None, any '\\n' characters written are\n  translated to the system default line separator, os.linesep. If\n  newline is '' or '\\n', no translation takes place. If newline is any\n  of the other legal values, any '\\n' characters written are translated\n  to the given string.\n\nIf closefd is False, the underlying file descriptor will be kept open\nwhen the file is closed. This does not work when a file name is given\nand must be True in that case.\n\nA custom opener can be used by passing a callable as *opener*. The\nunderlying file descriptor for the file object is then obtained by\ncalling *opener* with (*file*, *flags*). *opener* must return an open\nfile descriptor (passing os.open as *opener* results in functionality\nsimilar to passing None).\n\nopen() returns a file object whose type depends on the mode, and\nthrough which the standard file operations such as reading and writing\nare performed. When open() is used to open a file in a text mode ('w',\n'r', 'wt', 'rt', etc.), it returns a TextIOWrapper. When used to open\na file in a binary mode, the returned class varies: in read binary\nmode, it returns a BufferedReader; in write binary and append binary\nmodes, it returns a BufferedWriter, and in read/write mode, it returns\na BufferedRandom.\n\nIt is also possible to use a string or bytearray as a file for both\nreading and writing. For strings StringIO can be used like a file\nopened in a text mode, and for bytes a BytesIO can be used like a file\nopened in a binary mode.",
     "builtins.ord" => "Return the ordinal value of a character.\n\nIf the argument is a one-character string, return the Unicode code\npoint of that character.\n\nIf the argument is a bytes or bytearray object of length 1, return its\nsingle byte value.",
     "builtins.pow" => "Equivalent to base**exp with 2 arguments or base**exp % mod with 3 arguments\n\nSome types, such as ints, are able to use a more efficient algorithm when\ninvoked using the three argument form.",
-    "builtins.print" => "Prints the values to a stream, or to sys.stdout by default.\n\nsep\n  string inserted between values, default a space.\nend\n  string appended after the last value, default a newline.\nfile\n  a file-like object (stream); defaults to the current sys.stdout.\nflush\n  whether to forcibly flush the stream.",
+    "builtins.print" => "Prints the values to a stream, or to sys.stdout by default.\n\n  sep\n    string inserted between values, default a space.\n  end\n    string appended after the last value, default a newline.\n  file\n    a file-like object (stream); defaults to the current sys.stdout.\n  flush\n    whether to forcibly flush the stream.",
     "builtins.property" => "Property attribute.\n\n  fget\n    function to be used for getting an attribute value\n  fset\n    function to be used for setting an attribute value\n  fdel\n    function to be used for del'ing an attribute\n  doc\n    docstring\n\nTypical use is to define a managed attribute x:\n\nclass C(object):\n    def getx(self): return self._x\n    def setx(self, value): self._x = value\n    def delx(self): del self._x\n    x = property(getx, setx, delx, \"I'm the 'x' property.\")\n\nDecorators make defining new properties or modifying existing ones easy:\n\nclass C(object):\n    @property\n    def x(self):\n        \"I am the 'x' property.\"\n        return self._x\n    @x.setter\n    def x(self, value):\n        self._x = value\n    @x.deleter\n    def x(self):\n        del self._x",
     "builtins.property.__delattr__" => "Implement delattr(self, name).",
     "builtins.property.__delete__" => "Delete an attribute of instance.",
@@ -7392,8 +13275,8 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "builtins.str.casefold" => "Return a version of the string suitable for caseless comparisons.",
     "builtins.str.center" => "Return a centered string of length width.\n\nPadding is done using the specified fill character (default is a space).",
     "builtins.str.count" => "Return the number of non-overlapping occurrences of substring sub in string S[start:end].\n\nOptional arguments start and end are interpreted as in slice notation.",
-    "builtins.str.encode" => "Encode the string using the codec registered for encoding.\n\nencoding\n  The encoding in which to encode the string.\nerrors\n  The error handling scheme to use for encoding errors.\n  The default is 'strict' meaning that encoding errors raise a\n  UnicodeEncodeError.  Other possible values are 'ignore', 'replace' and\n  'xmlcharrefreplace' as well as any other name registered with\n  codecs.register_error that can handle UnicodeEncodeErrors.",
-    "builtins.str.endswith" => "Return True if the string ends with the specified suffix, False otherwise.\n\nsuffix\n  A string or a tuple of strings to try.\nstart\n  Optional start position. Default: start of the string.\nend\n  Optional stop position. Default: end of the string.",
+    "builtins.str.encode" => "Encode the string using the codec registered for encoding.\n\n  encoding\n    The encoding in which to encode the string.\n  errors\n    The error handling scheme to use for encoding errors.\n    The default is 'strict' meaning that encoding errors raise a\n    UnicodeEncodeError.  Other possible values are 'ignore', 'replace' and\n    'xmlcharrefreplace' as well as any other name registered with\n    codecs.register_error that can handle UnicodeEncodeErrors.",
+    "builtins.str.endswith" => "Return True if the string ends with the specified suffix, False otherwise.\n\n  suffix\n    A string or a tuple of strings to try.\n  start\n    Optional start position. Default: start of the string.\n  end\n    Optional stop position. Default: end of the string.",
     "builtins.str.expandtabs" => "Return a copy where all tab characters are expanded using spaces.\n\nIf tabsize is not given, a tab size of 8 characters is assumed.",
     "builtins.str.find" => "Return the lowest index in S where substring sub is found, such that sub is contained within S[start:end].\n\nOptional arguments start and end are interpreted as in slice notation.\nReturn -1 on failure.",
     "builtins.str.format" => "Return a formatted version of the string, using substitutions from args and kwargs.\nThe substitutions are identified by braces ('{' and '}').",
@@ -7428,7 +13311,7 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "builtins.str.rstrip" => "Return a copy of the string with trailing whitespace removed.\n\nIf chars is given and not None, remove characters in chars instead.",
     "builtins.str.split" => "Return a list of the substrings in the string, using sep as the separator string.\n\n  sep\n    The separator used to split the string.\n\n    When set to None (the default value), will split on any whitespace\n    character (including \\n \\r \\t \\f and spaces) and will discard\n    empty strings from the result.\n  maxsplit\n    Maximum number of splits.\n    -1 (the default value) means no limit.\n\nSplitting starts at the front of the string and works to the end.\n\nNote, str.split() is mainly useful for data that has been intentionally\ndelimited.  With natural text that includes punctuation, consider using\nthe regular expression module.",
     "builtins.str.splitlines" => "Return a list of the lines in the string, breaking at line boundaries.\n\nLine breaks are not included in the resulting list unless keepends is given and\ntrue.",
-    "builtins.str.startswith" => "Return True if the string starts with the specified prefix, False otherwise.\n\nprefix\n  A string or a tuple of strings to try.\nstart\n  Optional start position. Default: start of the string.\nend\n  Optional stop position. Default: end of the string.",
+    "builtins.str.startswith" => "Return True if the string starts with the specified prefix, False otherwise.\n\n  prefix\n    A string or a tuple of strings to try.\n  start\n    Optional start position. Default: start of the string.\n  end\n    Optional stop position. Default: end of the string.",
     "builtins.str.strip" => "Return a copy of the string with leading and trailing whitespace removed.\n\nIf chars is given and not None, remove characters in chars instead.",
     "builtins.str.swapcase" => "Convert uppercase characters to lowercase and lowercase characters to uppercase.",
     "builtins.str.title" => "Return a version of the string where each word is titlecased.\n\nMore specifically, words start with uppercased characters and all remaining\ncased characters have lower case.",
@@ -7701,6 +13584,7 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "faulthandler._stack_overflow" => "Recursive call to raise a stack overflow.",
     "faulthandler.cancel_dump_traceback_later" => "Cancel the previous call to dump_traceback_later().",
     "faulthandler.disable" => "Disable the fault handler.",
+    "faulthandler.dump_c_stack" => "Dump the C stack of the current thread.",
     "faulthandler.dump_traceback" => "Dump the traceback of the current thread, or of all threads if all_threads is True, into file.",
     "faulthandler.dump_traceback_later" => "Dump the traceback of all threads in timeout seconds,\nor each timeout seconds if repeat is True. If exit is True, call _exit(1) which is not safe.",
     "faulthandler.enable" => "Enable the fault handler.",
@@ -7708,10 +13592,10 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "faulthandler.register" => "Register a handler for the signal 'signum': dump the traceback of the current thread, or of all threads if all_threads is True, into file.",
     "faulthandler.unregister" => "Unregister the handler of the signal 'signum' registered by register().",
     "fcntl" => "This module performs file control and I/O control on file\ndescriptors.  It is an interface to the fcntl() and ioctl() Unix\nroutines.  File descriptors can be obtained with the fileno() method of\na file or socket object.",
-    "fcntl.fcntl" => "Perform the operation `cmd` on file descriptor fd.\n\nThe values used for `cmd` are operating system dependent, and are available\nas constants in the fcntl module, using the same names as used in\nthe relevant C header files.  The argument arg is optional, and\ndefaults to 0; it may be an int or a string.  If arg is given as a string,\nthe return value of fcntl is a string of that length, containing the\nresulting value put in the arg buffer by the operating system.  The length\nof the arg string is not allowed to exceed 1024 bytes.  If the arg given\nis an integer or if none is specified, the result value is an integer\ncorresponding to the return value of the fcntl call in the C code.",
-    "fcntl.flock" => "Perform the lock operation `operation` on file descriptor `fd`.\n\nSee the Unix manual page for flock(2) for details (On some systems, this\nfunction is emulated using fcntl()).",
-    "fcntl.ioctl" => "Perform the operation `request` on file descriptor `fd`.\n\nThe values used for `request` are operating system dependent, and are available\nas constants in the fcntl or termios library modules, using the same names as\nused in the relevant C header files.\n\nThe argument `arg` is optional, and defaults to 0; it may be an int or a\nbuffer containing character data (most likely a string or an array).\n\nIf the argument is a mutable buffer (such as an array) and if the\nmutate_flag argument (which is only allowed in this case) is true then the\nbuffer is (in effect) passed to the operating system and changes made by\nthe OS will be reflected in the contents of the buffer after the call has\nreturned.  The return value is the integer returned by the ioctl system\ncall.\n\nIf the argument is a mutable buffer and the mutable_flag argument is false,\nthe behavior is as if a string had been passed.\n\nIf the argument is an immutable buffer (most likely a string) then a copy\nof the buffer is passed to the operating system and the return value is a\nstring of the same length containing whatever the operating system put in\nthe buffer.  The length of the arg buffer in this case is not allowed to\nexceed 1024 bytes.\n\nIf the arg given is an integer or if none is specified, the result value is\nan integer corresponding to the return value of the ioctl call in the C\ncode.",
-    "fcntl.lockf" => "A wrapper around the fcntl() locking calls.\n\n`fd` is the file descriptor of the file to lock or unlock, and operation is one\nof the following values:\n\n    LOCK_UN - unlock\n    LOCK_SH - acquire a shared lock\n    LOCK_EX - acquire an exclusive lock\n\nWhen operation is LOCK_SH or LOCK_EX, it can also be bitwise ORed with\nLOCK_NB to avoid blocking on lock acquisition.  If LOCK_NB is used and the\nlock cannot be acquired, an OSError will be raised and the exception will\nhave an errno attribute set to EACCES or EAGAIN (depending on the operating\nsystem -- for portability, check for either value).\n\n`len` is the number of bytes to lock, with the default meaning to lock to\nEOF.  `start` is the byte offset, relative to `whence`, to that the lock\nstarts.  `whence` is as with fileobj.seek(), specifically:\n\n    0 - relative to the start of the file (SEEK_SET)\n    1 - relative to the current buffer position (SEEK_CUR)\n    2 - relative to the end of the file (SEEK_END)",
+    "fcntl.fcntl" => "Perform the operation cmd on file descriptor fd.\n\nThe values used for cmd are operating system dependent, and are\navailable as constants in the fcntl module, using the same names as used\nin the relevant C header files.  The argument arg is optional, and\ndefaults to 0; it may be an integer, a bytes-like object or a string.\nIf arg is given as a string, it will be encoded to binary using the\nUTF-8 encoding.\n\nIf the arg given is an integer or if none is specified, the result value\nis an integer corresponding to the return value of the fcntl() call in\nthe C code.\n\nIf arg is given as a bytes-like object, the return value of fcntl() is a\nbytes object of that length, containing the resulting value put in the\narg buffer by the operating system.  The length of the arg buffer is not\nallowed to exceed 1024 bytes.",
+    "fcntl.flock" => "Perform the lock operation on file descriptor fd.\n\nSee the Unix manual page for flock(2) for details (On some systems, this\nfunction is emulated using fcntl()).",
+    "fcntl.ioctl" => "Perform the operation request on file descriptor fd.\n\nThe values used for request are operating system dependent, and are\navailable as constants in the fcntl or termios library modules, using\nthe same names as used in the relevant C header files.\n\nThe argument arg is optional, and defaults to 0; it may be an integer, a\nbytes-like object or a string.  If arg is given as a string, it will be\nencoded to binary using the UTF-8 encoding.\n\nIf the arg given is an integer or if none is specified, the result value\nis an integer corresponding to the return value of the ioctl() call in\nthe C code.\n\nIf the argument is a mutable buffer (such as a bytearray) and the\nmutate_flag argument is true (default) then the buffer is (in effect)\npassed to the operating system and changes made by the OS will be\nreflected in the contents of the buffer after the call has returned.\nThe return value is the integer returned by the ioctl() system call.\n\nIf the argument is a mutable buffer and the mutable_flag argument is\nfalse, the behavior is as if an immutable buffer had been passed.\n\nIf the argument is an immutable buffer then a copy of the buffer is\npassed to the operating system and the return value is a bytes object of\nthe same length containing whatever the operating system put in the\nbuffer.  The length of the arg buffer in this case is not allowed to\nexceed 1024 bytes.",
+    "fcntl.lockf" => "A wrapper around the fcntl() locking calls.\n\nfd is the file descriptor of the file to lock or unlock, and operation\nis one of the following values:\n\n    LOCK_UN - unlock\n    LOCK_SH - acquire a shared lock\n    LOCK_EX - acquire an exclusive lock\n\nWhen operation is LOCK_SH or LOCK_EX, it can also be bitwise ORed with\nLOCK_NB to avoid blocking on lock acquisition.  If LOCK_NB is used and\nthe lock cannot be acquired, an OSError will be raised and the exception\nwill have an errno attribute set to EACCES or EAGAIN (depending on the\noperating system -- for portability, check for either value).\n\nlen is the number of bytes to lock, with the default meaning to lock to\nEOF.  start is the byte offset, relative to whence, to that the lock\nstarts.  whence is as with fileobj.seek(), specifically:\n\n    0 - relative to the start of the file (SEEK_SET)\n    1 - relative to the current buffer position (SEEK_CUR)\n    2 - relative to the end of the file (SEEK_END)",
     "gc" => "This module provides access to the garbage collector for reference cycles.\n\nenable() -- Enable automatic garbage collection.\ndisable() -- Disable automatic garbage collection.\nisenabled() -- Returns true if automatic collection is enabled.\ncollect() -- Do a full collection right now.\nget_count() -- Return the current collection counts.\nget_stats() -- Return list of dictionaries containing per-generation stats.\nset_debug() -- Set debugging flags.\nget_debug() -- Get debugging flags.\nset_threshold() -- Set the collection thresholds.\nget_threshold() -- Return the current collection thresholds.\nget_objects() -- Return a list of all objects tracked by the collector.\nis_tracked() -- Returns true if a given object is tracked.\nis_finalized() -- Returns true if a given object has been already finalized.\nget_referrers() -- Return the list of objects that refer to an object.\nget_referents() -- Return the list of objects that an object refers to.\nfreeze() -- Freeze all tracked objects and ignore them for future collections.\nunfreeze() -- Unfreeze all objects in the permanent generation.\nget_freeze_count() -- Return the number of objects in the permanent generation.",
     "gc.collect" => "Run the garbage collector.\n\nWith no arguments, run a full collection.  The optional argument\nmay be an integer specifying which generation to collect.  A ValueError\nis raised if the generation number is invalid.\n\nThe number of unreachable objects is returned.",
     "gc.disable" => "Disable automatic garbage collection.",
@@ -7788,7 +13672,7 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "itertools._grouper.__ne__" => "Return self!=value.",
     "itertools._grouper.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
     "itertools._grouper.__next__" => "Implement next(self).",
-    "itertools._grouper.__reduce__" => "Return state information for pickling.",
+    "itertools._grouper.__reduce__" => "Helper for pickle.",
     "itertools._grouper.__reduce_ex__" => "Helper for pickle.",
     "itertools._grouper.__repr__" => "Return repr(self).",
     "itertools._grouper.__setattr__" => "Implement setattr(self, name, value).",
@@ -7813,11 +13697,10 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "itertools._tee.__ne__" => "Return self!=value.",
     "itertools._tee.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
     "itertools._tee.__next__" => "Implement next(self).",
-    "itertools._tee.__reduce__" => "Return state information for pickling.",
+    "itertools._tee.__reduce__" => "Helper for pickle.",
     "itertools._tee.__reduce_ex__" => "Helper for pickle.",
     "itertools._tee.__repr__" => "Return repr(self).",
     "itertools._tee.__setattr__" => "Implement setattr(self, name, value).",
-    "itertools._tee.__setstate__" => "Set state information for unpickling.",
     "itertools._tee.__sizeof__" => "Size of object in memory, in bytes.",
     "itertools._tee.__str__" => "Return str(self).",
     "itertools._tee.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
@@ -7836,7 +13719,7 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "itertools._tee_dataobject.__lt__" => "Return self<value.",
     "itertools._tee_dataobject.__ne__" => "Return self!=value.",
     "itertools._tee_dataobject.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
-    "itertools._tee_dataobject.__reduce__" => "Return state information for pickling.",
+    "itertools._tee_dataobject.__reduce__" => "Helper for pickle.",
     "itertools._tee_dataobject.__reduce_ex__" => "Helper for pickle.",
     "itertools._tee_dataobject.__repr__" => "Return repr(self).",
     "itertools._tee_dataobject.__setattr__" => "Implement setattr(self, name, value).",
@@ -7860,11 +13743,10 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "itertools.accumulate.__ne__" => "Return self!=value.",
     "itertools.accumulate.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
     "itertools.accumulate.__next__" => "Implement next(self).",
-    "itertools.accumulate.__reduce__" => "Return state information for pickling.",
+    "itertools.accumulate.__reduce__" => "Helper for pickle.",
     "itertools.accumulate.__reduce_ex__" => "Helper for pickle.",
     "itertools.accumulate.__repr__" => "Return repr(self).",
     "itertools.accumulate.__setattr__" => "Implement setattr(self, name, value).",
-    "itertools.accumulate.__setstate__" => "Set state information for unpickling.",
     "itertools.accumulate.__sizeof__" => "Size of object in memory, in bytes.",
     "itertools.accumulate.__str__" => "Return str(self).",
     "itertools.accumulate.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
@@ -7910,11 +13792,10 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "itertools.chain.__ne__" => "Return self!=value.",
     "itertools.chain.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
     "itertools.chain.__next__" => "Implement next(self).",
-    "itertools.chain.__reduce__" => "Return state information for pickling.",
+    "itertools.chain.__reduce__" => "Helper for pickle.",
     "itertools.chain.__reduce_ex__" => "Helper for pickle.",
     "itertools.chain.__repr__" => "Return repr(self).",
     "itertools.chain.__setattr__" => "Implement setattr(self, name, value).",
-    "itertools.chain.__setstate__" => "Set state information for unpickling.",
     "itertools.chain.__sizeof__" => "Size of object in memory, in bytes.",
     "itertools.chain.__str__" => "Return str(self).",
     "itertools.chain.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
@@ -7936,11 +13817,10 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "itertools.combinations.__ne__" => "Return self!=value.",
     "itertools.combinations.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
     "itertools.combinations.__next__" => "Implement next(self).",
-    "itertools.combinations.__reduce__" => "Return state information for pickling.",
+    "itertools.combinations.__reduce__" => "Helper for pickle.",
     "itertools.combinations.__reduce_ex__" => "Helper for pickle.",
     "itertools.combinations.__repr__" => "Return repr(self).",
     "itertools.combinations.__setattr__" => "Implement setattr(self, name, value).",
-    "itertools.combinations.__setstate__" => "Set state information for unpickling.",
     "itertools.combinations.__sizeof__" => "Returns size in memory, in bytes.",
     "itertools.combinations.__str__" => "Return str(self).",
     "itertools.combinations.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
@@ -7961,11 +13841,10 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "itertools.combinations_with_replacement.__ne__" => "Return self!=value.",
     "itertools.combinations_with_replacement.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
     "itertools.combinations_with_replacement.__next__" => "Implement next(self).",
-    "itertools.combinations_with_replacement.__reduce__" => "Return state information for pickling.",
+    "itertools.combinations_with_replacement.__reduce__" => "Helper for pickle.",
     "itertools.combinations_with_replacement.__reduce_ex__" => "Helper for pickle.",
     "itertools.combinations_with_replacement.__repr__" => "Return repr(self).",
     "itertools.combinations_with_replacement.__setattr__" => "Implement setattr(self, name, value).",
-    "itertools.combinations_with_replacement.__setstate__" => "Set state information for unpickling.",
     "itertools.combinations_with_replacement.__sizeof__" => "Returns size in memory, in bytes.",
     "itertools.combinations_with_replacement.__str__" => "Return str(self).",
     "itertools.combinations_with_replacement.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
@@ -7986,7 +13865,7 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "itertools.compress.__ne__" => "Return self!=value.",
     "itertools.compress.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
     "itertools.compress.__next__" => "Implement next(self).",
-    "itertools.compress.__reduce__" => "Return state information for pickling.",
+    "itertools.compress.__reduce__" => "Helper for pickle.",
     "itertools.compress.__reduce_ex__" => "Helper for pickle.",
     "itertools.compress.__repr__" => "Return repr(self).",
     "itertools.compress.__setattr__" => "Implement setattr(self, name, value).",
@@ -8010,7 +13889,7 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "itertools.count.__ne__" => "Return self!=value.",
     "itertools.count.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
     "itertools.count.__next__" => "Implement next(self).",
-    "itertools.count.__reduce__" => "Return state information for pickling.",
+    "itertools.count.__reduce__" => "Helper for pickle.",
     "itertools.count.__reduce_ex__" => "Helper for pickle.",
     "itertools.count.__repr__" => "Return repr(self).",
     "itertools.count.__setattr__" => "Implement setattr(self, name, value).",
@@ -8034,11 +13913,10 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "itertools.cycle.__ne__" => "Return self!=value.",
     "itertools.cycle.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
     "itertools.cycle.__next__" => "Implement next(self).",
-    "itertools.cycle.__reduce__" => "Return state information for pickling.",
+    "itertools.cycle.__reduce__" => "Helper for pickle.",
     "itertools.cycle.__reduce_ex__" => "Helper for pickle.",
     "itertools.cycle.__repr__" => "Return repr(self).",
     "itertools.cycle.__setattr__" => "Implement setattr(self, name, value).",
-    "itertools.cycle.__setstate__" => "Set state information for unpickling.",
     "itertools.cycle.__sizeof__" => "Size of object in memory, in bytes.",
     "itertools.cycle.__str__" => "Return str(self).",
     "itertools.cycle.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
@@ -8059,11 +13937,10 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "itertools.dropwhile.__ne__" => "Return self!=value.",
     "itertools.dropwhile.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
     "itertools.dropwhile.__next__" => "Implement next(self).",
-    "itertools.dropwhile.__reduce__" => "Return state information for pickling.",
+    "itertools.dropwhile.__reduce__" => "Helper for pickle.",
     "itertools.dropwhile.__reduce_ex__" => "Helper for pickle.",
     "itertools.dropwhile.__repr__" => "Return repr(self).",
     "itertools.dropwhile.__setattr__" => "Implement setattr(self, name, value).",
-    "itertools.dropwhile.__setstate__" => "Set state information for unpickling.",
     "itertools.dropwhile.__sizeof__" => "Size of object in memory, in bytes.",
     "itertools.dropwhile.__str__" => "Return str(self).",
     "itertools.dropwhile.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
@@ -8084,14 +13961,14 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "itertools.filterfalse.__ne__" => "Return self!=value.",
     "itertools.filterfalse.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
     "itertools.filterfalse.__next__" => "Implement next(self).",
-    "itertools.filterfalse.__reduce__" => "Return state information for pickling.",
+    "itertools.filterfalse.__reduce__" => "Helper for pickle.",
     "itertools.filterfalse.__reduce_ex__" => "Helper for pickle.",
     "itertools.filterfalse.__repr__" => "Return repr(self).",
     "itertools.filterfalse.__setattr__" => "Implement setattr(self, name, value).",
     "itertools.filterfalse.__sizeof__" => "Size of object in memory, in bytes.",
     "itertools.filterfalse.__str__" => "Return str(self).",
     "itertools.filterfalse.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
-    "itertools.groupby" => "make an iterator that returns consecutive keys and groups from the iterable\n\niterable\n  Elements to divide into groups according to the key function.\nkey\n  A function for computing the group category for each element.\n  If the key function is not specified or is None, the element itself\n  is used for grouping.",
+    "itertools.groupby" => "make an iterator that returns consecutive keys and groups from the iterable\n\n  iterable\n    Elements to divide into groups according to the key function.\n  key\n    A function for computing the group category for each element.\n    If the key function is not specified or is None, the element itself\n    is used for grouping.",
     "itertools.groupby.__delattr__" => "Implement delattr(self, name).",
     "itertools.groupby.__eq__" => "Return self==value.",
     "itertools.groupby.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
@@ -8108,11 +13985,10 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "itertools.groupby.__ne__" => "Return self!=value.",
     "itertools.groupby.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
     "itertools.groupby.__next__" => "Implement next(self).",
-    "itertools.groupby.__reduce__" => "Return state information for pickling.",
+    "itertools.groupby.__reduce__" => "Helper for pickle.",
     "itertools.groupby.__reduce_ex__" => "Helper for pickle.",
     "itertools.groupby.__repr__" => "Return repr(self).",
     "itertools.groupby.__setattr__" => "Implement setattr(self, name, value).",
-    "itertools.groupby.__setstate__" => "Set state information for unpickling.",
     "itertools.groupby.__sizeof__" => "Size of object in memory, in bytes.",
     "itertools.groupby.__str__" => "Return str(self).",
     "itertools.groupby.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
@@ -8133,15 +14009,14 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "itertools.islice.__ne__" => "Return self!=value.",
     "itertools.islice.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
     "itertools.islice.__next__" => "Implement next(self).",
-    "itertools.islice.__reduce__" => "Return state information for pickling.",
+    "itertools.islice.__reduce__" => "Helper for pickle.",
     "itertools.islice.__reduce_ex__" => "Helper for pickle.",
     "itertools.islice.__repr__" => "Return repr(self).",
     "itertools.islice.__setattr__" => "Implement setattr(self, name, value).",
-    "itertools.islice.__setstate__" => "Set state information for unpickling.",
     "itertools.islice.__sizeof__" => "Size of object in memory, in bytes.",
     "itertools.islice.__str__" => "Return str(self).",
     "itertools.islice.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
-    "itertools.pairwise" => "Return an iterator of overlapping pairs taken from the input iterator.\n\ns -> (s0,s1), (s1,s2), (s2, s3), ...",
+    "itertools.pairwise" => "Return an iterator of overlapping pairs taken from the input iterator.\n\n    s -> (s0,s1), (s1,s2), (s2, s3), ...",
     "itertools.pairwise.__delattr__" => "Implement delattr(self, name).",
     "itertools.pairwise.__eq__" => "Return self==value.",
     "itertools.pairwise.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
@@ -8182,11 +14057,10 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "itertools.permutations.__ne__" => "Return self!=value.",
     "itertools.permutations.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
     "itertools.permutations.__next__" => "Implement next(self).",
-    "itertools.permutations.__reduce__" => "Return state information for pickling.",
+    "itertools.permutations.__reduce__" => "Helper for pickle.",
     "itertools.permutations.__reduce_ex__" => "Helper for pickle.",
     "itertools.permutations.__repr__" => "Return repr(self).",
     "itertools.permutations.__setattr__" => "Implement setattr(self, name, value).",
-    "itertools.permutations.__setstate__" => "Set state information for unpickling.",
     "itertools.permutations.__sizeof__" => "Returns size in memory, in bytes.",
     "itertools.permutations.__str__" => "Return str(self).",
     "itertools.permutations.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
@@ -8207,11 +14081,10 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "itertools.product.__ne__" => "Return self!=value.",
     "itertools.product.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
     "itertools.product.__next__" => "Implement next(self).",
-    "itertools.product.__reduce__" => "Return state information for pickling.",
+    "itertools.product.__reduce__" => "Helper for pickle.",
     "itertools.product.__reduce_ex__" => "Helper for pickle.",
     "itertools.product.__repr__" => "Return repr(self).",
     "itertools.product.__setattr__" => "Implement setattr(self, name, value).",
-    "itertools.product.__setstate__" => "Set state information for unpickling.",
     "itertools.product.__sizeof__" => "Returns size in memory, in bytes.",
     "itertools.product.__str__" => "Return str(self).",
     "itertools.product.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
@@ -8233,7 +14106,7 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "itertools.repeat.__ne__" => "Return self!=value.",
     "itertools.repeat.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
     "itertools.repeat.__next__" => "Implement next(self).",
-    "itertools.repeat.__reduce__" => "Return state information for pickling.",
+    "itertools.repeat.__reduce__" => "Helper for pickle.",
     "itertools.repeat.__reduce_ex__" => "Helper for pickle.",
     "itertools.repeat.__repr__" => "Return repr(self).",
     "itertools.repeat.__setattr__" => "Implement setattr(self, name, value).",
@@ -8257,7 +14130,7 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "itertools.starmap.__ne__" => "Return self!=value.",
     "itertools.starmap.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
     "itertools.starmap.__next__" => "Implement next(self).",
-    "itertools.starmap.__reduce__" => "Return state information for pickling.",
+    "itertools.starmap.__reduce__" => "Helper for pickle.",
     "itertools.starmap.__reduce_ex__" => "Helper for pickle.",
     "itertools.starmap.__repr__" => "Return repr(self).",
     "itertools.starmap.__setattr__" => "Implement setattr(self, name, value).",
@@ -8281,11 +14154,10 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "itertools.takewhile.__ne__" => "Return self!=value.",
     "itertools.takewhile.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
     "itertools.takewhile.__next__" => "Implement next(self).",
-    "itertools.takewhile.__reduce__" => "Return state information for pickling.",
+    "itertools.takewhile.__reduce__" => "Helper for pickle.",
     "itertools.takewhile.__reduce_ex__" => "Helper for pickle.",
     "itertools.takewhile.__repr__" => "Return repr(self).",
     "itertools.takewhile.__setattr__" => "Implement setattr(self, name, value).",
-    "itertools.takewhile.__setstate__" => "Set state information for unpickling.",
     "itertools.takewhile.__sizeof__" => "Size of object in memory, in bytes.",
     "itertools.takewhile.__str__" => "Return str(self).",
     "itertools.takewhile.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
@@ -8307,11 +14179,10 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "itertools.zip_longest.__ne__" => "Return self!=value.",
     "itertools.zip_longest.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
     "itertools.zip_longest.__next__" => "Implement next(self).",
-    "itertools.zip_longest.__reduce__" => "Return state information for pickling.",
+    "itertools.zip_longest.__reduce__" => "Helper for pickle.",
     "itertools.zip_longest.__reduce_ex__" => "Helper for pickle.",
     "itertools.zip_longest.__repr__" => "Return repr(self).",
     "itertools.zip_longest.__setattr__" => "Implement setattr(self, name, value).",
-    "itertools.zip_longest.__setstate__" => "Set state information for unpickling.",
     "itertools.zip_longest.__sizeof__" => "Size of object in memory, in bytes.",
     "itertools.zip_longest.__str__" => "Return str(self).",
     "itertools.zip_longest.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
@@ -8350,7 +14221,7 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "math.fsum" => "Return an accurate floating-point sum of values in the iterable seq.\n\nAssumes IEEE-754 floating-point arithmetic.",
     "math.gamma" => "Gamma function at x.",
     "math.gcd" => "Greatest Common Divisor.",
-    "math.hypot" => "hypot(*coordinates) -> value\n\nMultidimensional Euclidean distance from the origin to a point.\n\nRoughly equivalent to:\n    sqrt(sum(x**2 for x in coordinates))\n\nFor a two dimensional point (x, y), gives the hypotenuse\nusing the Pythagorean theorem:  sqrt(x*x + y*y).\n\nFor example, the hypotenuse of a 3/4/5 right triangle is:\n\n    >>> hypot(3.0, 4.0)\n    5.0",
+    "math.hypot" => "Multidimensional Euclidean distance from the origin to a point.\n\nRoughly equivalent to:\n    sqrt(sum(x**2 for x in coordinates))\n\nFor a two dimensional point (x, y), gives the hypotenuse\nusing the Pythagorean theorem:  sqrt(x*x + y*y).\n\nFor example, the hypotenuse of a 3/4/5 right triangle is:\n\n    >>> hypot(3.0, 4.0)\n    5.0",
     "math.isclose" => "Determine whether two floating-point numbers are close in value.\n\n  rel_tol\n    maximum difference for being considered \"close\", relative to the\n    magnitude of the input values\n  abs_tol\n    maximum difference for being considered \"close\", regardless of the\n    magnitude of the input values\n\nReturn True if a is close in value to b, and False otherwise.\n\nFor the values to be considered close, the difference between them\nmust be smaller than at least one of the tolerances.\n\n-inf, inf and NaN behave similarly to the IEEE 754 Standard.  That\nis, NaN is not close to anything, even itself.  inf and -inf are\nonly close to themselves.",
     "math.isfinite" => "Return True if x is neither an infinity nor a NaN, and False otherwise.",
     "math.isinf" => "Return True if x is a positive or negative infinity, and False otherwise.",
@@ -8373,7 +14244,7 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "math.sin" => "Return the sine of x (measured in radians).",
     "math.sinh" => "Return the hyperbolic sine of x.",
     "math.sqrt" => "Return the square root of x.",
-    "math.sumprod" => "Return the sum of products of values from two iterables p and q.\n\nRoughly equivalent to:\n\n    sum(itertools.starmap(operator.mul, zip(p, q, strict=True)))\n\nFor float and mixed int/float inputs, the intermediate products\nand sums are computed with extended precision.",
+    "math.sumprod" => "Return the sum of products of values from two iterables p and q.\n\nRoughly equivalent to:\n\n    sum(map(operator.mul, p, q, strict=True))\n\nFor float and mixed int/float inputs, the intermediate products\nand sums are computed with extended precision.",
     "math.tan" => "Return the tangent of x (measured in radians).",
     "math.tanh" => "Return the hyperbolic tangent of x.",
     "math.trunc" => "Truncates the Real x to the nearest Integral toward 0.\n\nUses the __trunc__ magic method.",
@@ -8455,6 +14326,7 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "nt.DirEntry.path" => "the entry's full path name; equivalent to os.path.join(scandir_path, entry.name)",
     "nt.DirEntry.stat" => "Return stat_result object for the entry; cached per entry.",
     "nt._add_dll_directory" => "Add a path to the DLL search path.\n\nThis search path is used when resolving dependencies for imported\nextension modules (the module itself is resolved through sys.path),\nand also by ctypes.\n\nReturns an opaque value that may be passed to os.remove_dll_directory\nto remove this directory from the search path.",
+    "nt._create_environ" => "Create the environment dictionary.",
     "nt._exit" => "Exit to the system with specified status, without normal exit processing.",
     "nt._findfirstfile" => "A function to get the real file name without accessing the file in Windows.",
     "nt._getdiskusage" => "Return disk usage statistics about the given path as a (total, free) tuple.",
@@ -8484,8 +14356,8 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "nt.device_encoding" => "Return a string describing the encoding of a terminal's file descriptor.\n\nThe file descriptor must be attached to a terminal.\nIf the device is not a terminal, return None.",
     "nt.dup" => "Return a duplicate of a file descriptor.",
     "nt.dup2" => "Duplicate file descriptor.",
-    "nt.execv" => "Execute an executable path with arguments, replacing current process.\n\npath\n  Path of executable file.\nargv\n  Tuple or list of strings.",
-    "nt.execve" => "Execute an executable path with arguments, replacing current process.\n\npath\n  Path of executable file.\nargv\n  Tuple or list of strings.\nenv\n  Dictionary of strings mapping to strings.",
+    "nt.execv" => "Execute an executable path with arguments, replacing current process.\n\n  path\n    Path of executable file.\n  argv\n    Tuple or list of strings.",
+    "nt.execve" => "Execute an executable path with arguments, replacing current process.\n\n  path\n    Path of executable file.\n  argv\n    Tuple or list of strings.\n  env\n    Dictionary of strings mapping to strings.",
     "nt.fchmod" => "Change the access permissions of the file given by file descriptor fd.\n\n  fd\n    The file descriptor of the file to be modified.\n  mode\n    Operating-system mode bitfield.\n    Be careful when using number literals for *mode*. The conventional UNIX notation for\n    numeric modes uses an octal base, which needs to be indicated with a ``0o`` prefix in\n    Python.\n\nEquivalent to os.chmod(fd, mode).",
     "nt.fspath" => "Return the file system path representation of the object.\n\nIf the object is str or bytes, then allow it to pass through as-is. If the\nobject defines __fspath__(), then return the result of that method. All other\ntypes raise a TypeError.",
     "nt.fstat" => "Perform a stat system call on the given file descriptor.\n\nLike stat(), but for an open file descriptor.\nEquivalent to os.stat(fd).",
@@ -8515,6 +14387,7 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "nt.pipe" => "Create a pipe.\n\nReturns a tuple of two file descriptors:\n  (read_fd, write_fd)",
     "nt.putenv" => "Change or add an environment variable.",
     "nt.read" => "Read from a file descriptor.  Returns a bytes object.",
+    "nt.readinto" => "Read into a buffer object from a file descriptor.\n\nThe buffer should be mutable and bytes-like. On success, returns the number of\nbytes read. Less bytes may be read than the size of the buffer. The underlying\nsystem call will be retried when interrupted by a signal, unless the signal\nhandler raises an exception. Other errors will not be retried and an error will\nbe raised.\n\nReturns 0 if *fd* is at end of file or if the provided *buffer* has length 0\n(which can be used to check for errors without reading data). Never returns\nnegative.",
     "nt.readlink" => "Return a string representing the path to which the symbolic link points.\n\nIf dir_fd is not None, it should be a file descriptor open to a directory,\nand path should be relative; path will then be relative to that directory.\n\ndir_fd may not be implemented on your platform.  If it is unavailable,\nusing it will raise a NotImplementedError.",
     "nt.remove" => "Remove a file (same as unlink()).\n\nIf dir_fd is not None, it should be a file descriptor open to a directory,\n  and path should be relative; path will then be relative to that directory.\ndir_fd may not be implemented on your platform.\n  If it is unavailable, using it will raise a NotImplementedError.",
     "nt.rename" => "Rename a file or directory.\n\nIf either src_dir_fd or dst_dir_fd is not None, it should be a file\n  descriptor open to a directory, and the respective path string (src or dst)\n  should be relative; the path will then be relative to that directory.\nsrc_dir_fd and dst_dir_fd, may not be implemented on your platform.\n  If they are unavailable, using them will raise a NotImplementedError.",
@@ -8524,13 +14397,128 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "nt.set_blocking" => "Set the blocking mode of the specified file descriptor.\n\nSet the O_NONBLOCK flag if blocking is False,\nclear the O_NONBLOCK flag otherwise.",
     "nt.set_handle_inheritable" => "Set the inheritable flag of the specified handle.",
     "nt.set_inheritable" => "Set the inheritable flag of the specified file descriptor.",
-    "nt.spawnv" => "Execute the program specified by path in a new process.\n\nmode\n  Mode of process creation.\npath\n  Path of executable file.\nargv\n  Tuple or list of strings.",
-    "nt.spawnve" => "Execute the program specified by path in a new process.\n\nmode\n  Mode of process creation.\npath\n  Path of executable file.\nargv\n  Tuple or list of strings.\nenv\n  Dictionary of strings mapping to strings.",
+    "nt.spawnv" => "Execute the program specified by path in a new process.\n\n  mode\n    Mode of process creation.\n  path\n    Path of executable file.\n  argv\n    Tuple or list of strings.",
+    "nt.spawnve" => "Execute the program specified by path in a new process.\n\n  mode\n    Mode of process creation.\n  path\n    Path of executable file.\n  argv\n    Tuple or list of strings.\n  env\n    Dictionary of strings mapping to strings.",
     "nt.startfile" => "Start a file with its associated application.\n\nWhen \"operation\" is not specified or \"open\", this acts like\ndouble-clicking the file in Explorer, or giving the file name as an\nargument to the DOS \"start\" command: the file is opened with whatever\napplication (if any) its extension is associated.\nWhen another \"operation\" is given, it specifies what should be done with\nthe file.  A typical operation is \"print\".\n\n\"arguments\" is passed to the application, but should be omitted if the\nfile is a document.\n\n\"cwd\" is the working directory for the operation. If \"filepath\" is\nrelative, it will be resolved against this directory. This argument\nshould usually be an absolute path.\n\n\"show_cmd\" can be used to override the recommended visibility option.\nSee the Windows ShellExecute documentation for values.\n\nstartfile returns as soon as the associated application is launched.\nThere is no option to wait for the application to close, and no way\nto retrieve the application's exit status.\n\nThe filepath is relative to the current directory.  If you want to use\nan absolute path, make sure the first character is not a slash (\"/\");\nthe underlying Win32 ShellExecute function doesn't work if it is.",
     "nt.stat" => "Perform a stat system call on the given path.\n\n  path\n    Path to be examined; can be string, bytes, a path-like object or\n    open-file-descriptor int.\n  dir_fd\n    If not None, it should be a file descriptor open to a directory,\n    and path should be a relative string; path will then be relative to\n    that directory.\n  follow_symlinks\n    If False, and the last element of the path is a symbolic link,\n    stat will examine the symbolic link itself instead of the file\n    the link points to.\n\ndir_fd and follow_symlinks may not be implemented\n  on your platform.  If they are unavailable, using them will raise a\n  NotImplementedError.\n\nIt's an error to use dir_fd or follow_symlinks when specifying path as\n  an open file descriptor.",
+    "nt.stat_result" => "stat_result: Result from stat, fstat, or lstat.\n\nThis object may be accessed either as a tuple of\n  (mode, ino, dev, nlink, uid, gid, size, atime, mtime, ctime)\nor via the attributes st_mode, st_ino, st_dev, st_nlink, st_uid, and so on.\n\nPosix/windows: If your platform supports st_blksize, st_blocks, st_rdev,\nor st_flags, they are available as attributes only.\n\nSee os.stat for more information.",
+    "nt.stat_result.__add__" => "Return self+value.",
+    "nt.stat_result.__class_getitem__" => "See PEP 585",
+    "nt.stat_result.__contains__" => "Return bool(key in self).",
+    "nt.stat_result.__delattr__" => "Implement delattr(self, name).",
+    "nt.stat_result.__eq__" => "Return self==value.",
+    "nt.stat_result.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "nt.stat_result.__ge__" => "Return self>=value.",
+    "nt.stat_result.__getattribute__" => "Return getattr(self, name).",
+    "nt.stat_result.__getitem__" => "Return self[key].",
+    "nt.stat_result.__getstate__" => "Helper for pickle.",
+    "nt.stat_result.__gt__" => "Return self>value.",
+    "nt.stat_result.__hash__" => "Return hash(self).",
+    "nt.stat_result.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "nt.stat_result.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "nt.stat_result.__iter__" => "Implement iter(self).",
+    "nt.stat_result.__le__" => "Return self<=value.",
+    "nt.stat_result.__len__" => "Return len(self).",
+    "nt.stat_result.__lt__" => "Return self<value.",
+    "nt.stat_result.__mul__" => "Return self*value.",
+    "nt.stat_result.__ne__" => "Return self!=value.",
+    "nt.stat_result.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "nt.stat_result.__reduce_ex__" => "Helper for pickle.",
+    "nt.stat_result.__replace__" => "Return a copy of the structure with new values for the specified fields.",
+    "nt.stat_result.__repr__" => "Return repr(self).",
+    "nt.stat_result.__rmul__" => "Return value*self.",
+    "nt.stat_result.__setattr__" => "Implement setattr(self, name, value).",
+    "nt.stat_result.__sizeof__" => "Size of object in memory, in bytes.",
+    "nt.stat_result.__str__" => "Return str(self).",
+    "nt.stat_result.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "nt.stat_result.count" => "Return number of occurrences of value.",
+    "nt.stat_result.index" => "Return first index of value.\n\nRaises ValueError if the value is not present.",
+    "nt.stat_result.st_atime" => "time of last access",
+    "nt.stat_result.st_atime_ns" => "time of last access in nanoseconds",
+    "nt.stat_result.st_birthtime" => "time of creation",
+    "nt.stat_result.st_birthtime_ns" => "time of creation in nanoseconds",
+    "nt.stat_result.st_ctime" => "time of last change",
+    "nt.stat_result.st_ctime_ns" => "time of last change in nanoseconds",
+    "nt.stat_result.st_dev" => "device",
+    "nt.stat_result.st_file_attributes" => "Windows file attribute bits",
+    "nt.stat_result.st_gid" => "group ID of owner",
+    "nt.stat_result.st_ino" => "inode",
+    "nt.stat_result.st_mode" => "protection bits",
+    "nt.stat_result.st_mtime" => "time of last modification",
+    "nt.stat_result.st_mtime_ns" => "time of last modification in nanoseconds",
+    "nt.stat_result.st_nlink" => "number of hard links",
+    "nt.stat_result.st_reparse_tag" => "Windows reparse tag",
+    "nt.stat_result.st_size" => "total size, in bytes",
+    "nt.stat_result.st_uid" => "user ID of owner",
+    "nt.statvfs_result" => "statvfs_result: Result from statvfs or fstatvfs.\n\nThis object may be accessed either as a tuple of\n  (bsize, frsize, blocks, bfree, bavail, files, ffree, favail, flag, namemax),\nor via the attributes f_bsize, f_frsize, f_blocks, f_bfree, and so on.\n\nSee os.statvfs for more information.",
+    "nt.statvfs_result.__add__" => "Return self+value.",
+    "nt.statvfs_result.__class_getitem__" => "See PEP 585",
+    "nt.statvfs_result.__contains__" => "Return bool(key in self).",
+    "nt.statvfs_result.__delattr__" => "Implement delattr(self, name).",
+    "nt.statvfs_result.__eq__" => "Return self==value.",
+    "nt.statvfs_result.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "nt.statvfs_result.__ge__" => "Return self>=value.",
+    "nt.statvfs_result.__getattribute__" => "Return getattr(self, name).",
+    "nt.statvfs_result.__getitem__" => "Return self[key].",
+    "nt.statvfs_result.__getstate__" => "Helper for pickle.",
+    "nt.statvfs_result.__gt__" => "Return self>value.",
+    "nt.statvfs_result.__hash__" => "Return hash(self).",
+    "nt.statvfs_result.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "nt.statvfs_result.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "nt.statvfs_result.__iter__" => "Implement iter(self).",
+    "nt.statvfs_result.__le__" => "Return self<=value.",
+    "nt.statvfs_result.__len__" => "Return len(self).",
+    "nt.statvfs_result.__lt__" => "Return self<value.",
+    "nt.statvfs_result.__mul__" => "Return self*value.",
+    "nt.statvfs_result.__ne__" => "Return self!=value.",
+    "nt.statvfs_result.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "nt.statvfs_result.__reduce_ex__" => "Helper for pickle.",
+    "nt.statvfs_result.__replace__" => "Return a copy of the structure with new values for the specified fields.",
+    "nt.statvfs_result.__repr__" => "Return repr(self).",
+    "nt.statvfs_result.__rmul__" => "Return value*self.",
+    "nt.statvfs_result.__setattr__" => "Implement setattr(self, name, value).",
+    "nt.statvfs_result.__sizeof__" => "Size of object in memory, in bytes.",
+    "nt.statvfs_result.__str__" => "Return str(self).",
+    "nt.statvfs_result.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "nt.statvfs_result.count" => "Return number of occurrences of value.",
+    "nt.statvfs_result.index" => "Return first index of value.\n\nRaises ValueError if the value is not present.",
     "nt.strerror" => "Translate an error code to a message string.",
     "nt.symlink" => "Create a symbolic link pointing to src named dst.\n\ntarget_is_directory is required on Windows if the target is to be\n  interpreted as a directory.  (On Windows, symlink requires\n  Windows 6.0 or greater, and raises a NotImplementedError otherwise.)\n  target_is_directory is ignored on non-Windows platforms.\n\nIf dir_fd is not None, it should be a file descriptor open to a directory,\n  and path should be relative; path will then be relative to that directory.\ndir_fd may not be implemented on your platform.\n  If it is unavailable, using it will raise a NotImplementedError.",
     "nt.system" => "Execute the command in a subshell.",
+    "nt.terminal_size" => "A tuple of (columns, lines) for holding terminal window size",
+    "nt.terminal_size.__add__" => "Return self+value.",
+    "nt.terminal_size.__class_getitem__" => "See PEP 585",
+    "nt.terminal_size.__contains__" => "Return bool(key in self).",
+    "nt.terminal_size.__delattr__" => "Implement delattr(self, name).",
+    "nt.terminal_size.__eq__" => "Return self==value.",
+    "nt.terminal_size.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "nt.terminal_size.__ge__" => "Return self>=value.",
+    "nt.terminal_size.__getattribute__" => "Return getattr(self, name).",
+    "nt.terminal_size.__getitem__" => "Return self[key].",
+    "nt.terminal_size.__getstate__" => "Helper for pickle.",
+    "nt.terminal_size.__gt__" => "Return self>value.",
+    "nt.terminal_size.__hash__" => "Return hash(self).",
+    "nt.terminal_size.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "nt.terminal_size.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "nt.terminal_size.__iter__" => "Implement iter(self).",
+    "nt.terminal_size.__le__" => "Return self<=value.",
+    "nt.terminal_size.__len__" => "Return len(self).",
+    "nt.terminal_size.__lt__" => "Return self<value.",
+    "nt.terminal_size.__mul__" => "Return self*value.",
+    "nt.terminal_size.__ne__" => "Return self!=value.",
+    "nt.terminal_size.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "nt.terminal_size.__reduce_ex__" => "Helper for pickle.",
+    "nt.terminal_size.__replace__" => "Return a copy of the structure with new values for the specified fields.",
+    "nt.terminal_size.__repr__" => "Return repr(self).",
+    "nt.terminal_size.__rmul__" => "Return value*self.",
+    "nt.terminal_size.__setattr__" => "Implement setattr(self, name, value).",
+    "nt.terminal_size.__sizeof__" => "Size of object in memory, in bytes.",
+    "nt.terminal_size.__str__" => "Return str(self).",
+    "nt.terminal_size.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "nt.terminal_size.columns" => "width of the terminal window in characters",
+    "nt.terminal_size.count" => "Return number of occurrences of value.",
+    "nt.terminal_size.index" => "Return first index of value.\n\nRaises ValueError if the value is not present.",
+    "nt.terminal_size.lines" => "height of the terminal window in characters",
     "nt.times" => "Return a collection containing process timing information.\n\nThe object returned behaves like a named tuple with these fields:\n  (utime, stime, cutime, cstime, elapsed_time)\nAll fields are floating-point numbers.",
     "nt.times_result" => "times_result: Result from os.times().\n\nThis object may be accessed either as a tuple of\n  (user, system, children_user, children_system, elapsed),\nor via the attributes user, system, children_user, children_system,\nand elapsed.\n\nSee os.times for more information.",
     "nt.times_result.__add__" => "Return self+value.",
@@ -8655,6 +14643,7 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "posix.WIFSTOPPED" => "Return True if the process returning status was stopped.",
     "posix.WSTOPSIG" => "Return the signal that stopped the process that provided the status value.",
     "posix.WTERMSIG" => "Return the signal that terminated the process that provided the status value.",
+    "posix._create_environ" => "Create the environment dictionary.",
     "posix._exit" => "Exit to the system with specified status, without normal exit processing.",
     "posix._fcopyfile" => "Efficiently copy content or metadata of 2 regular file descriptors (macOS).",
     "posix._inputhook" => "Calls PyOS_CallInputHook droppong the GIL first",
@@ -8680,8 +14669,8 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "posix.eventfd" => "Creates and returns an event notification file descriptor.",
     "posix.eventfd_read" => "Read eventfd value",
     "posix.eventfd_write" => "Write eventfd value.",
-    "posix.execv" => "Execute an executable path with arguments, replacing current process.\n\npath\n  Path of executable file.\nargv\n  Tuple or list of strings.",
-    "posix.execve" => "Execute an executable path with arguments, replacing current process.\n\npath\n  Path of executable file.\nargv\n  Tuple or list of strings.\nenv\n  Dictionary of strings mapping to strings.",
+    "posix.execv" => "Execute an executable path with arguments, replacing current process.\n\n  path\n    Path of executable file.\n  argv\n    Tuple or list of strings.",
+    "posix.execve" => "Execute an executable path with arguments, replacing current process.\n\n  path\n    Path of executable file.\n  argv\n    Tuple or list of strings.\n  env\n    Dictionary of strings mapping to strings.",
     "posix.fchdir" => "Change to the directory of the given file descriptor.\n\nfd must be opened on a directory, not a file.\nEquivalent to os.chdir(fd).",
     "posix.fchmod" => "Change the access permissions of the file given by file descriptor fd.\n\n  fd\n    The file descriptor of the file to be modified.\n  mode\n    Operating-system mode bitfield.\n    Be careful when using number literals for *mode*. The conventional UNIX notation for\n    numeric modes uses an octal base, which needs to be indicated with a ``0o`` prefix in\n    Python.\n\nEquivalent to os.chmod(fd, mode).",
     "posix.fchown" => "Change the owner and group id of the file specified by file descriptor.\n\nEquivalent to os.chown(fd, uid, gid).",
@@ -8702,7 +14691,7 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "posix.getegid" => "Return the current process's effective group id.",
     "posix.geteuid" => "Return the current process's effective user id.",
     "posix.getgid" => "Return the current process's group id.",
-    "posix.getgrouplist" => "Returns a list of groups to which a user belongs.\n\nuser\n  username to lookup\ngroup\n  base group id of the user",
+    "posix.getgrouplist" => "Returns a list of groups to which a user belongs.\n\n  user\n    username to lookup\n  group\n    base group id of the user",
     "posix.getgroups" => "Return list of supplemental group IDs for the process.",
     "posix.getloadavg" => "Return average recent system load information.\n\nReturn the number of processes in the system run queue averaged over\nthe last 1, 5, and 15 minutes as a tuple of three floats.\nRaises OSError if the load average was unobtainable.",
     "posix.getlogin" => "Return the actual login name.",
@@ -8728,7 +14717,7 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "posix.link" => "Create a hard link to a file.\n\nIf either src_dir_fd or dst_dir_fd is not None, it should be a file\n  descriptor open to a directory, and the respective path string (src or dst)\n  should be relative; the path will then be relative to that directory.\nIf follow_symlinks is False, and the last element of src is a symbolic\n  link, link will create a link to the symbolic link itself instead of the\n  file the link points to.\nsrc_dir_fd, dst_dir_fd, and follow_symlinks may not be implemented on your\n  platform.  If they are unavailable, using them will raise a\n  NotImplementedError.",
     "posix.listdir" => "Return a list containing the names of the files in the directory.\n\npath can be specified as either str, bytes, or a path-like object.  If path is bytes,\n  the filenames returned will also be bytes; in all other circumstances\n  the filenames returned will be str.\nIf path is None, uses the path='.'.\nOn some platforms, path may also be specified as an open file descriptor;\\\n  the file descriptor must refer to a directory.\n  If this functionality is unavailable, using it raises NotImplementedError.\n\nThe list is in arbitrary order.  It does not include the special\nentries '.' and '..' even if they are present in the directory.",
     "posix.listxattr" => "Return a list of extended attributes on path.\n\npath may be either None, a string, a path-like object, or an open file descriptor.\nif path is None, listxattr will examine the current directory.\nIf follow_symlinks is False, and the last element of the path is a symbolic\n  link, listxattr will examine the symbolic link itself instead of the file\n  the link points to.",
-    "posix.lockf" => "Apply, test or remove a POSIX lock on an open file descriptor.\n\nfd\n  An open file descriptor.\ncommand\n  One of F_LOCK, F_TLOCK, F_ULOCK or F_TEST.\nlength\n  The number of bytes to lock, starting at the current position.",
+    "posix.lockf" => "Apply, test or remove a POSIX lock on an open file descriptor.\n\n  fd\n    An open file descriptor.\n  command\n    One of F_LOCK, F_TLOCK, F_ULOCK or F_TEST.\n  length\n    The number of bytes to lock, starting at the current position.",
     "posix.login_tty" => "Prepare the tty of which fd is a file descriptor for a new login session.\n\nMake the calling process a session leader; make the tty the\ncontrolling tty, the stdin, the stdout, and the stderr of the\ncalling process; close fd.",
     "posix.lseek" => "Set the position of a file descriptor.  Return the new position.\n\n  fd\n    An open file descriptor, as returned by os.open().\n  position\n    Position, interpreted relative to 'whence'.\n  whence\n    The relative position to seek from. Valid values are:\n    - SEEK_SET: seek from the start of the file.\n    - SEEK_CUR: seek from the current file position.\n    - SEEK_END: seek from the end of the file.\n\nThe return value is the number of bytes relative to the beginning of the file.",
     "posix.lstat" => "Perform a stat system call on the given path, without following symbolic links.\n\nLike stat(), but do not follow symbolic links.\nEquivalent to stat(path, follow_symlinks=False).",
@@ -8748,8 +14737,8 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "posix.posix_fadvise" => "Announce an intention to access data in a specific pattern.\n\nAnnounce an intention to access data in a specific pattern, thus allowing\nthe kernel to make optimizations.\nThe advice applies to the region of the file specified by fd starting at\noffset and continuing for length bytes.\nadvice is one of POSIX_FADV_NORMAL, POSIX_FADV_SEQUENTIAL,\nPOSIX_FADV_RANDOM, POSIX_FADV_NOREUSE, POSIX_FADV_WILLNEED, or\nPOSIX_FADV_DONTNEED.",
     "posix.posix_fallocate" => "Ensure a file has allocated at least a particular number of bytes on disk.\n\nEnsure that the file specified by fd encompasses a range of bytes\nstarting at offset bytes from the beginning and continuing for length bytes.",
     "posix.posix_openpt" => "Open and return a file descriptor for a master pseudo-terminal device.\n\nPerforms a posix_openpt() C function call. The oflag argument is used to\nset file status flags and file access modes as specified in the manual page\nof posix_openpt() of your system.",
-    "posix.posix_spawn" => "Execute the program specified by path in a new process.\n\npath\n  Path of executable file.\nargv\n  Tuple or list of strings.\nenv\n  Dictionary of strings mapping to strings.\nfile_actions\n  A sequence of file action tuples.\nsetpgroup\n  The pgroup to use with the POSIX_SPAWN_SETPGROUP flag.\nresetids\n  If the value is `true` the POSIX_SPAWN_RESETIDS will be activated.\nsetsid\n  If the value is `true` the POSIX_SPAWN_SETSID or POSIX_SPAWN_SETSID_NP will be activated.\nsetsigmask\n  The sigmask to use with the POSIX_SPAWN_SETSIGMASK flag.\nsetsigdef\n  The sigmask to use with the POSIX_SPAWN_SETSIGDEF flag.\nscheduler\n  A tuple with the scheduler policy (optional) and parameters.",
-    "posix.posix_spawnp" => "Execute the program specified by path in a new process.\n\npath\n  Path of executable file.\nargv\n  Tuple or list of strings.\nenv\n  Dictionary of strings mapping to strings.\nfile_actions\n  A sequence of file action tuples.\nsetpgroup\n  The pgroup to use with the POSIX_SPAWN_SETPGROUP flag.\nresetids\n  If the value is `True` the POSIX_SPAWN_RESETIDS will be activated.\nsetsid\n  If the value is `True` the POSIX_SPAWN_SETSID or POSIX_SPAWN_SETSID_NP will be activated.\nsetsigmask\n  The sigmask to use with the POSIX_SPAWN_SETSIGMASK flag.\nsetsigdef\n  The sigmask to use with the POSIX_SPAWN_SETSIGDEF flag.\nscheduler\n  A tuple with the scheduler policy (optional) and parameters.",
+    "posix.posix_spawn" => "Execute the program specified by path in a new process.\n\n  path\n    Path of executable file.\n  argv\n    Tuple or list of strings.\n  env\n    Dictionary of strings mapping to strings.\n  file_actions\n    A sequence of file action tuples.\n  setpgroup\n    The pgroup to use with the POSIX_SPAWN_SETPGROUP flag.\n  resetids\n    If the value is `true` the POSIX_SPAWN_RESETIDS will be activated.\n  setsid\n    If the value is `true` the POSIX_SPAWN_SETSID or POSIX_SPAWN_SETSID_NP will be activated.\n  setsigmask\n    The sigmask to use with the POSIX_SPAWN_SETSIGMASK flag.\n  setsigdef\n    The sigmask to use with the POSIX_SPAWN_SETSIGDEF flag.\n  scheduler\n    A tuple with the scheduler policy (optional) and parameters.",
+    "posix.posix_spawnp" => "Execute the program specified by path in a new process.\n\n  path\n    Path of executable file.\n  argv\n    Tuple or list of strings.\n  env\n    Dictionary of strings mapping to strings.\n  file_actions\n    A sequence of file action tuples.\n  setpgroup\n    The pgroup to use with the POSIX_SPAWN_SETPGROUP flag.\n  resetids\n    If the value is `True` the POSIX_SPAWN_RESETIDS will be activated.\n  setsid\n    If the value is `True` the POSIX_SPAWN_SETSID or POSIX_SPAWN_SETSID_NP will be activated.\n  setsigmask\n    The sigmask to use with the POSIX_SPAWN_SETSIGMASK flag.\n  setsigdef\n    The sigmask to use with the POSIX_SPAWN_SETSIGDEF flag.\n  scheduler\n    A tuple with the scheduler policy (optional) and parameters.",
     "posix.pread" => "Read a number of bytes from a file descriptor starting at a particular offset.\n\nRead length bytes from file descriptor fd, starting at offset bytes from\nthe beginning of the file.  The file offset remains unchanged.",
     "posix.preadv" => "Reads from a file descriptor into a number of mutable bytes-like objects.\n\nCombines the functionality of readv() and pread(). As readv(), it will\ntransfer data into each buffer until it is full and then move on to the next\nbuffer in the sequence to hold the rest of the data. Its fourth argument,\nspecifies the file offset at which the input operation is to be performed. It\nwill return the total number of bytes read (which can be less than the total\ncapacity of all the objects).\n\nThe flags argument contains a bitwise OR of zero or more of the following flags:\n\n- RWF_HIPRI\n- RWF_NOWAIT\n\nUsing non-zero flags requires Linux 4.6 or newer.",
     "posix.ptsname" => "Return the name of the slave pseudo-terminal device.\n\n  fd\n    File descriptor of a master pseudo-terminal device.\n\nIf the ptsname_r() C function is available, it is called;\notherwise, performs a ptsname() C function call.",
@@ -8757,6 +14746,7 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "posix.pwrite" => "Write bytes to a file descriptor starting at a particular offset.\n\nWrite buffer to fd, starting at offset bytes from the beginning of\nthe file.  Returns the number of bytes written.  Does not change the\ncurrent file offset.",
     "posix.pwritev" => "Writes the contents of bytes-like objects to a file descriptor at a given offset.\n\nCombines the functionality of writev() and pwrite(). All buffers must be a sequence\nof bytes-like objects. Buffers are processed in array order. Entire contents of first\nbuffer is written before proceeding to second, and so on. The operating system may\nset a limit (sysconf() value SC_IOV_MAX) on the number of buffers that can be used.\nThis function writes the contents of each object to the file descriptor and returns\nthe total number of bytes written.\n\nThe flags argument contains a bitwise OR of zero or more of the following flags:\n\n- RWF_DSYNC\n- RWF_SYNC\n- RWF_APPEND\n\nUsing non-zero flags requires Linux 4.7 or newer.",
     "posix.read" => "Read from a file descriptor.  Returns a bytes object.",
+    "posix.readinto" => "Read into a buffer object from a file descriptor.\n\nThe buffer should be mutable and bytes-like. On success, returns the number of\nbytes read. Less bytes may be read than the size of the buffer. The underlying\nsystem call will be retried when interrupted by a signal, unless the signal\nhandler raises an exception. Other errors will not be retried and an error will\nbe raised.\n\nReturns 0 if *fd* is at end of file or if the provided *buffer* has length 0\n(which can be used to check for errors without reading data). Never returns\nnegative.",
     "posix.readlink" => "Return a string representing the path to which the symbolic link points.\n\nIf dir_fd is not None, it should be a file descriptor open to a directory,\nand path should be relative; path will then be relative to that directory.\n\ndir_fd may not be implemented on your platform.  If it is unavailable,\nusing it will raise a NotImplementedError.",
     "posix.readv" => "Read from a file descriptor fd into an iterable of buffers.\n\nThe buffers should be mutable buffers accepting bytes.\nreadv will transfer data into each buffer until it is full\nand then move on to the next buffer in the sequence to hold\nthe rest of the data.\n\nreadv returns the total number of bytes read,\nwhich may be less than the total capacity of all the buffers.",
     "posix.register_at_fork" => "Register callables to be called when forking a new process.\n\n  before\n    A callable to be called in the parent before the fork() syscall.\n  after_in_child\n    A callable to be called in the child after fork().\n  after_in_parent\n    A callable to be called in the parent after fork().\n\n'before' callbacks are called in reverse order.\n'after_in_child' and 'after_in_parent' callbacks are called in order.",
@@ -8771,7 +14761,7 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "posix.sched_getaffinity" => "Return the affinity of the process identified by pid (or the current process if zero).\n\nThe affinity is returned as a set of CPU identifiers.",
     "posix.sched_getparam" => "Returns scheduling parameters for the process identified by pid.\n\nIf pid is 0, returns parameters for the calling process.\nReturn value is an instance of sched_param.",
     "posix.sched_getscheduler" => "Get the scheduling policy for the process identified by pid.\n\nPassing 0 for pid returns the scheduling policy for the calling process.",
-    "posix.sched_param" => "Currently has only one field: sched_priority\n\nsched_priority\n  A scheduling parameter.",
+    "posix.sched_param" => "Currently has only one field: sched_priority\n\n  sched_priority\n    A scheduling parameter.",
     "posix.sched_param.__add__" => "Return self+value.",
     "posix.sched_param.__class_getitem__" => "See PEP 585",
     "posix.sched_param.__contains__" => "Return bool(key in self).",
@@ -8816,7 +14806,7 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "posix.seteuid" => "Set the current process's effective user id.",
     "posix.setgid" => "Set the current process's group id.",
     "posix.setgroups" => "Set the groups of the current process to list.",
-    "posix.setns" => "Move the calling thread into different namespaces.\n\nfd\n  A file descriptor to a namespace.\nnstype\n  Type of namespace.",
+    "posix.setns" => "Move the calling thread into different namespaces.\n\n  fd\n    A file descriptor to a namespace.\n  nstype\n    Type of namespace.",
     "posix.setpgid" => "Call the system call setpgid(pid, pgrp).",
     "posix.setpgrp" => "Make the current process the leader of its process group.",
     "posix.setpriority" => "Set program scheduling priority.",
@@ -8829,7 +14819,90 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "posix.setxattr" => "Set extended attribute attribute on path to value.\n\npath may be either a string, a path-like object,  or an open file descriptor.\nIf follow_symlinks is False, and the last element of the path is a symbolic\n  link, setxattr will modify the symbolic link itself instead of the file\n  the link points to.",
     "posix.splice" => "Transfer count bytes from one pipe to a descriptor or vice versa.\n\n  src\n    Source file descriptor.\n  dst\n    Destination file descriptor.\n  count\n    Number of bytes to copy.\n  offset_src\n    Starting offset in src.\n  offset_dst\n    Starting offset in dst.\n  flags\n    Flags to modify the semantics of the call.\n\nIf offset_src is None, then src is read from the current position;\nrespectively for offset_dst. The offset associated to the file\ndescriptor that refers to a pipe must be None.",
     "posix.stat" => "Perform a stat system call on the given path.\n\n  path\n    Path to be examined; can be string, bytes, a path-like object or\n    open-file-descriptor int.\n  dir_fd\n    If not None, it should be a file descriptor open to a directory,\n    and path should be a relative string; path will then be relative to\n    that directory.\n  follow_symlinks\n    If False, and the last element of the path is a symbolic link,\n    stat will examine the symbolic link itself instead of the file\n    the link points to.\n\ndir_fd and follow_symlinks may not be implemented\n  on your platform.  If they are unavailable, using them will raise a\n  NotImplementedError.\n\nIt's an error to use dir_fd or follow_symlinks when specifying path as\n  an open file descriptor.",
+    "posix.stat_result" => "stat_result: Result from stat, fstat, or lstat.\n\nThis object may be accessed either as a tuple of\n  (mode, ino, dev, nlink, uid, gid, size, atime, mtime, ctime)\nor via the attributes st_mode, st_ino, st_dev, st_nlink, st_uid, and so on.\n\nPosix/windows: If your platform supports st_blksize, st_blocks, st_rdev,\nor st_flags, they are available as attributes only.\n\nSee os.stat for more information.",
+    "posix.stat_result.__add__" => "Return self+value.",
+    "posix.stat_result.__class_getitem__" => "See PEP 585",
+    "posix.stat_result.__contains__" => "Return bool(key in self).",
+    "posix.stat_result.__delattr__" => "Implement delattr(self, name).",
+    "posix.stat_result.__eq__" => "Return self==value.",
+    "posix.stat_result.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "posix.stat_result.__ge__" => "Return self>=value.",
+    "posix.stat_result.__getattribute__" => "Return getattr(self, name).",
+    "posix.stat_result.__getitem__" => "Return self[key].",
+    "posix.stat_result.__getstate__" => "Helper for pickle.",
+    "posix.stat_result.__gt__" => "Return self>value.",
+    "posix.stat_result.__hash__" => "Return hash(self).",
+    "posix.stat_result.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "posix.stat_result.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "posix.stat_result.__iter__" => "Implement iter(self).",
+    "posix.stat_result.__le__" => "Return self<=value.",
+    "posix.stat_result.__len__" => "Return len(self).",
+    "posix.stat_result.__lt__" => "Return self<value.",
+    "posix.stat_result.__mul__" => "Return self*value.",
+    "posix.stat_result.__ne__" => "Return self!=value.",
+    "posix.stat_result.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "posix.stat_result.__reduce_ex__" => "Helper for pickle.",
+    "posix.stat_result.__replace__" => "Return a copy of the structure with new values for the specified fields.",
+    "posix.stat_result.__repr__" => "Return repr(self).",
+    "posix.stat_result.__rmul__" => "Return value*self.",
+    "posix.stat_result.__setattr__" => "Implement setattr(self, name, value).",
+    "posix.stat_result.__sizeof__" => "Size of object in memory, in bytes.",
+    "posix.stat_result.__str__" => "Return str(self).",
+    "posix.stat_result.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "posix.stat_result.count" => "Return number of occurrences of value.",
+    "posix.stat_result.index" => "Return first index of value.\n\nRaises ValueError if the value is not present.",
+    "posix.stat_result.st_atime" => "time of last access",
+    "posix.stat_result.st_atime_ns" => "time of last access in nanoseconds",
+    "posix.stat_result.st_birthtime" => "time of creation",
+    "posix.stat_result.st_blksize" => "blocksize for filesystem I/O",
+    "posix.stat_result.st_blocks" => "number of blocks allocated",
+    "posix.stat_result.st_ctime" => "time of last change",
+    "posix.stat_result.st_ctime_ns" => "time of last change in nanoseconds",
+    "posix.stat_result.st_dev" => "device",
+    "posix.stat_result.st_flags" => "user defined flags for file",
+    "posix.stat_result.st_gen" => "generation number",
+    "posix.stat_result.st_gid" => "group ID of owner",
+    "posix.stat_result.st_ino" => "inode",
+    "posix.stat_result.st_mode" => "protection bits",
+    "posix.stat_result.st_mtime" => "time of last modification",
+    "posix.stat_result.st_mtime_ns" => "time of last modification in nanoseconds",
+    "posix.stat_result.st_nlink" => "number of hard links",
+    "posix.stat_result.st_rdev" => "device type (if inode device)",
+    "posix.stat_result.st_size" => "total size, in bytes",
+    "posix.stat_result.st_uid" => "user ID of owner",
     "posix.statvfs" => "Perform a statvfs system call on the given path.\n\npath may always be specified as a string.\nOn some platforms, path may also be specified as an open file descriptor.\n  If this functionality is unavailable, using it raises an exception.",
+    "posix.statvfs_result" => "statvfs_result: Result from statvfs or fstatvfs.\n\nThis object may be accessed either as a tuple of\n  (bsize, frsize, blocks, bfree, bavail, files, ffree, favail, flag, namemax),\nor via the attributes f_bsize, f_frsize, f_blocks, f_bfree, and so on.\n\nSee os.statvfs for more information.",
+    "posix.statvfs_result.__add__" => "Return self+value.",
+    "posix.statvfs_result.__class_getitem__" => "See PEP 585",
+    "posix.statvfs_result.__contains__" => "Return bool(key in self).",
+    "posix.statvfs_result.__delattr__" => "Implement delattr(self, name).",
+    "posix.statvfs_result.__eq__" => "Return self==value.",
+    "posix.statvfs_result.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "posix.statvfs_result.__ge__" => "Return self>=value.",
+    "posix.statvfs_result.__getattribute__" => "Return getattr(self, name).",
+    "posix.statvfs_result.__getitem__" => "Return self[key].",
+    "posix.statvfs_result.__getstate__" => "Helper for pickle.",
+    "posix.statvfs_result.__gt__" => "Return self>value.",
+    "posix.statvfs_result.__hash__" => "Return hash(self).",
+    "posix.statvfs_result.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "posix.statvfs_result.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "posix.statvfs_result.__iter__" => "Implement iter(self).",
+    "posix.statvfs_result.__le__" => "Return self<=value.",
+    "posix.statvfs_result.__len__" => "Return len(self).",
+    "posix.statvfs_result.__lt__" => "Return self<value.",
+    "posix.statvfs_result.__mul__" => "Return self*value.",
+    "posix.statvfs_result.__ne__" => "Return self!=value.",
+    "posix.statvfs_result.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "posix.statvfs_result.__reduce_ex__" => "Helper for pickle.",
+    "posix.statvfs_result.__replace__" => "Return a copy of the structure with new values for the specified fields.",
+    "posix.statvfs_result.__repr__" => "Return repr(self).",
+    "posix.statvfs_result.__rmul__" => "Return value*self.",
+    "posix.statvfs_result.__setattr__" => "Implement setattr(self, name, value).",
+    "posix.statvfs_result.__sizeof__" => "Size of object in memory, in bytes.",
+    "posix.statvfs_result.__str__" => "Return str(self).",
+    "posix.statvfs_result.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "posix.statvfs_result.count" => "Return number of occurrences of value.",
+    "posix.statvfs_result.index" => "Return first index of value.\n\nRaises ValueError if the value is not present.",
     "posix.strerror" => "Translate an error code to a message string.",
     "posix.symlink" => "Create a symbolic link pointing to src named dst.\n\ntarget_is_directory is required on Windows if the target is to be\n  interpreted as a directory.  (On Windows, symlink requires\n  Windows 6.0 or greater, and raises a NotImplementedError otherwise.)\n  target_is_directory is ignored on non-Windows platforms.\n\nIf dir_fd is not None, it should be a file descriptor open to a directory,\n  and path should be relative; path will then be relative to that directory.\ndir_fd may not be implemented on your platform.\n  If it is unavailable, using it will raise a NotImplementedError.",
     "posix.sync" => "Force write of everything to disk.",
@@ -8837,11 +14910,45 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "posix.system" => "Execute the command in a subshell.",
     "posix.tcgetpgrp" => "Return the process group associated with the terminal specified by fd.",
     "posix.tcsetpgrp" => "Set the process group associated with the terminal specified by fd.",
-    "posix.timerfd_create" => "Create and return a timer file descriptor.\n\nclockid\n  A valid clock ID constant as timer file descriptor.\n\n  time.CLOCK_REALTIME\n  time.CLOCK_MONOTONIC\n  time.CLOCK_BOOTTIME\nflags\n  0 or a bit mask of os.TFD_NONBLOCK or os.TFD_CLOEXEC.\n\n  os.TFD_NONBLOCK\n      If *TFD_NONBLOCK* is set as a flag, read doesn't blocks.\n      If *TFD_NONBLOCK* is not set as a flag, read block until the timer fires.\n\n  os.TFD_CLOEXEC\n      If *TFD_CLOEXEC* is set as a flag, enable the close-on-exec flag",
-    "posix.timerfd_gettime" => "Return a tuple of a timer file descriptor's (interval, next expiration) in float seconds.\n\nfd\n  A timer file descriptor.",
-    "posix.timerfd_gettime_ns" => "Return a tuple of a timer file descriptor's (interval, next expiration) in nanoseconds.\n\nfd\n  A timer file descriptor.",
-    "posix.timerfd_settime" => "Alter a timer file descriptor's internal timer in seconds.\n\nfd\n  A timer file descriptor.\nflags\n  0 or a bit mask of TFD_TIMER_ABSTIME or TFD_TIMER_CANCEL_ON_SET.\ninitial\n  The initial expiration time, in seconds.\ninterval\n  The timer's interval, in seconds.",
-    "posix.timerfd_settime_ns" => "Alter a timer file descriptor's internal timer in nanoseconds.\n\nfd\n  A timer file descriptor.\nflags\n  0 or a bit mask of TFD_TIMER_ABSTIME or TFD_TIMER_CANCEL_ON_SET.\ninitial\n  initial expiration timing in seconds.\ninterval\n  interval for the timer in seconds.",
+    "posix.terminal_size" => "A tuple of (columns, lines) for holding terminal window size",
+    "posix.terminal_size.__add__" => "Return self+value.",
+    "posix.terminal_size.__class_getitem__" => "See PEP 585",
+    "posix.terminal_size.__contains__" => "Return bool(key in self).",
+    "posix.terminal_size.__delattr__" => "Implement delattr(self, name).",
+    "posix.terminal_size.__eq__" => "Return self==value.",
+    "posix.terminal_size.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "posix.terminal_size.__ge__" => "Return self>=value.",
+    "posix.terminal_size.__getattribute__" => "Return getattr(self, name).",
+    "posix.terminal_size.__getitem__" => "Return self[key].",
+    "posix.terminal_size.__getstate__" => "Helper for pickle.",
+    "posix.terminal_size.__gt__" => "Return self>value.",
+    "posix.terminal_size.__hash__" => "Return hash(self).",
+    "posix.terminal_size.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "posix.terminal_size.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "posix.terminal_size.__iter__" => "Implement iter(self).",
+    "posix.terminal_size.__le__" => "Return self<=value.",
+    "posix.terminal_size.__len__" => "Return len(self).",
+    "posix.terminal_size.__lt__" => "Return self<value.",
+    "posix.terminal_size.__mul__" => "Return self*value.",
+    "posix.terminal_size.__ne__" => "Return self!=value.",
+    "posix.terminal_size.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "posix.terminal_size.__reduce_ex__" => "Helper for pickle.",
+    "posix.terminal_size.__replace__" => "Return a copy of the structure with new values for the specified fields.",
+    "posix.terminal_size.__repr__" => "Return repr(self).",
+    "posix.terminal_size.__rmul__" => "Return value*self.",
+    "posix.terminal_size.__setattr__" => "Implement setattr(self, name, value).",
+    "posix.terminal_size.__sizeof__" => "Size of object in memory, in bytes.",
+    "posix.terminal_size.__str__" => "Return str(self).",
+    "posix.terminal_size.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "posix.terminal_size.columns" => "width of the terminal window in characters",
+    "posix.terminal_size.count" => "Return number of occurrences of value.",
+    "posix.terminal_size.index" => "Return first index of value.\n\nRaises ValueError if the value is not present.",
+    "posix.terminal_size.lines" => "height of the terminal window in characters",
+    "posix.timerfd_create" => "Create and return a timer file descriptor.\n\n  clockid\n    A valid clock ID constant as timer file descriptor.\n\n    time.CLOCK_REALTIME\n    time.CLOCK_MONOTONIC\n    time.CLOCK_BOOTTIME\n  flags\n    0 or a bit mask of os.TFD_NONBLOCK or os.TFD_CLOEXEC.\n\n    os.TFD_NONBLOCK\n        If *TFD_NONBLOCK* is set as a flag, read doesn't blocks.\n        If *TFD_NONBLOCK* is not set as a flag, read block until the timer fires.\n\n    os.TFD_CLOEXEC\n        If *TFD_CLOEXEC* is set as a flag, enable the close-on-exec flag",
+    "posix.timerfd_gettime" => "Return a tuple of a timer file descriptor's (interval, next expiration) in float seconds.\n\n  fd\n    A timer file descriptor.",
+    "posix.timerfd_gettime_ns" => "Return a tuple of a timer file descriptor's (interval, next expiration) in nanoseconds.\n\n  fd\n    A timer file descriptor.",
+    "posix.timerfd_settime" => "Alter a timer file descriptor's internal timer in seconds.\n\n  fd\n    A timer file descriptor.\n  flags\n    0 or a bit mask of TFD_TIMER_ABSTIME or TFD_TIMER_CANCEL_ON_SET.\n  initial\n    The initial expiration time, in seconds.\n  interval\n    The timer's interval, in seconds.",
+    "posix.timerfd_settime_ns" => "Alter a timer file descriptor's internal timer in nanoseconds.\n\n  fd\n    A timer file descriptor.\n  flags\n    0 or a bit mask of TFD_TIMER_ABSTIME or TFD_TIMER_CANCEL_ON_SET.\n  initial\n    initial expiration timing in seconds.\n  interval\n    interval for the timer in seconds.",
     "posix.times" => "Return a collection containing process timing information.\n\nThe object returned behaves like a named tuple with these fields:\n  (utime, stime, cutime, cstime, elapsed_time)\nAll fields are floating-point numbers.",
     "posix.times_result" => "times_result: Result from os.times().\n\nThis object may be accessed either as a tuple of\n  (user, system, children_user, children_system, elapsed),\nor via the attributes user, system, children_user, children_system,\nand elapsed.\n\nSee os.times for more information.",
     "posix.times_result.__add__" => "Return self+value.",
@@ -8881,7 +14988,7 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "posix.times_result.system" => "system time",
     "posix.times_result.user" => "user time",
     "posix.truncate" => "Truncate a file, specified by path, to a specific length.\n\nOn some platforms, path may also be specified as an open file descriptor.\n  If this functionality is unavailable, using it raises an exception.",
-    "posix.ttyname" => "Return the name of the terminal device connected to 'fd'.\n\nfd\n  Integer file descriptor handle.",
+    "posix.ttyname" => "Return the name of the terminal device connected to 'fd'.\n\n  fd\n    Integer file descriptor handle.",
     "posix.umask" => "Set the current numeric umask and return the previous umask.",
     "posix.uname" => "Return an object identifying the current operating system.\n\nThe object behaves like a named tuple with the following fields:\n  (sysname, nodename, release, version, machine)",
     "posix.uname_result" => "uname_result: Result from os.uname().\n\nThis object may be accessed either as a tuple of\n  (sysname, nodename, release, version, machine),\nor via the attributes sysname, nodename, release, version, and machine.\n\nSee os.uname for more information.",
@@ -8924,7 +15031,7 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "posix.unlink" => "Remove a file (same as remove()).\n\nIf dir_fd is not None, it should be a file descriptor open to a directory,\n  and path should be relative; path will then be relative to that directory.\ndir_fd may not be implemented on your platform.\n  If it is unavailable, using it will raise a NotImplementedError.",
     "posix.unlockpt" => "Unlock a pseudo-terminal master/slave pair.\n\n  fd\n    File descriptor of a master pseudo-terminal device.\n\nPerforms an unlockpt() C function call.",
     "posix.unsetenv" => "Delete an environment variable.",
-    "posix.unshare" => "Disassociate parts of a process (or thread) execution context.\n\nflags\n  Namespaces to be unshared.",
+    "posix.unshare" => "Disassociate parts of a process (or thread) execution context.\n\n  flags\n    Namespaces to be unshared.",
     "posix.urandom" => "Return a bytes object containing random bytes suitable for cryptographic use.",
     "posix.utime" => "Set the access and modified time of path.\n\npath may always be specified as a string.\nOn some platforms, path may also be specified as an open file descriptor.\n  If this functionality is unavailable, using it raises an exception.\n\nIf times is not None, it must be a tuple (atime, mtime);\n    atime and mtime should be expressed as float seconds since the epoch.\nIf ns is specified, it must be a tuple (atime_ns, mtime_ns);\n    atime_ns and mtime_ns should be expressed as integer nanoseconds\n    since the epoch.\nIf times is None and ns is unspecified, utime uses the current time.\nSpecifying tuples for both times and ns is an error.\n\nIf dir_fd is not None, it should be a file descriptor open to a directory,\n  and path should be relative; path will then be relative to that directory.\nIf follow_symlinks is False, and the last element of the path is a symbolic\n  link, utime will modify the symbolic link itself instead of the file the\n  link points to.\nIt is an error to use dir_fd or follow_symlinks when specifying path\n  as an open file descriptor.\ndir_fd and follow_symlinks may not be available on your platform.\n  If they are unavailable, using them will raise a NotImplementedError.",
     "posix.wait" => "Wait for completion of a child process.\n\nReturns a tuple of information about the child process:\n    (pid, status)",
@@ -9012,14 +15119,39 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "pwd.struct_passwd.pw_uid" => "user id",
     "pyexpat" => "Python wrapper for Expat parser.",
     "pyexpat.ErrorString" => "Returns string error for given number.",
+    "pyexpat.ExpatError.__delattr__" => "Implement delattr(self, name).",
+    "pyexpat.ExpatError.__eq__" => "Return self==value.",
+    "pyexpat.ExpatError.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "pyexpat.ExpatError.__ge__" => "Return self>=value.",
+    "pyexpat.ExpatError.__getattribute__" => "Return getattr(self, name).",
+    "pyexpat.ExpatError.__getstate__" => "Helper for pickle.",
+    "pyexpat.ExpatError.__gt__" => "Return self>value.",
+    "pyexpat.ExpatError.__hash__" => "Return hash(self).",
+    "pyexpat.ExpatError.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "pyexpat.ExpatError.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "pyexpat.ExpatError.__le__" => "Return self<=value.",
+    "pyexpat.ExpatError.__lt__" => "Return self<value.",
+    "pyexpat.ExpatError.__ne__" => "Return self!=value.",
+    "pyexpat.ExpatError.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "pyexpat.ExpatError.__reduce_ex__" => "Helper for pickle.",
+    "pyexpat.ExpatError.__repr__" => "Return repr(self).",
+    "pyexpat.ExpatError.__setattr__" => "Implement setattr(self, name, value).",
+    "pyexpat.ExpatError.__sizeof__" => "Size of object in memory, in bytes.",
+    "pyexpat.ExpatError.__str__" => "Return str(self).",
+    "pyexpat.ExpatError.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "pyexpat.ExpatError.__weakref__" => "list of weak references to the object",
+    "pyexpat.ExpatError.add_note" => "Add a note to the exception",
+    "pyexpat.ExpatError.with_traceback" => "Set self.__traceback__ to tb and return self.",
     "pyexpat.ParserCreate" => "Return a new XML parser object.",
     "pyexpat.XMLParserType" => "XML parser",
     "pyexpat.XMLParserType.ExternalEntityParserCreate" => "Create a parser for parsing an external entity based on the information passed to the ExternalEntityRefHandler.",
     "pyexpat.XMLParserType.GetBase" => "Return base URL string for the parser.",
     "pyexpat.XMLParserType.GetInputContext" => "Return the untranslated text of the input that caused the current event.\n\nIf the event was generated by a large amount of text (such as a start tag\nfor an element with many attributes), not all of the text may be available.",
     "pyexpat.XMLParserType.GetReparseDeferralEnabled" => "Retrieve reparse deferral enabled status; always returns false with Expat <2.6.0.",
-    "pyexpat.XMLParserType.Parse" => "Parse XML data.\n\n`isfinal' should be true at end of input.",
+    "pyexpat.XMLParserType.Parse" => "Parse XML data.\n\n'isfinal' should be true at end of input.",
     "pyexpat.XMLParserType.ParseFile" => "Parse XML data from file-like object.",
+    "pyexpat.XMLParserType.SetAllocTrackerActivationThreshold" => "Sets the number of allocated bytes of dynamic memory needed to activate protection against disproportionate use of RAM.\n\nBy default, parser objects have an allocation activation threshold of 64 MiB.",
+    "pyexpat.XMLParserType.SetAllocTrackerMaximumAmplification" => "Sets the maximum amplification factor between direct input and bytes of dynamic memory allocated.\n\nThe amplification factor is calculated as \"allocated / direct\" while parsing,\nwhere \"direct\" is the number of bytes read from the primary document in parsing\nand \"allocated\" is the number of bytes of dynamic memory allocated in the parser\nhierarchy.\n\nThe 'max_factor' value must be a non-NaN floating point value greater than\nor equal to 1.0. Amplification factors greater than 100.0 can be observed\nnear the start of parsing even with benign files in practice. In particular,\nthe activation threshold should be carefully chosen to avoid false positives.\n\nBy default, parser objects have a maximum amplification factor of 100.0.",
     "pyexpat.XMLParserType.SetBase" => "Set the base URL for the parser.",
     "pyexpat.XMLParserType.SetParamEntityParsing" => "Controls parsing of parameter entities (including the external DTD subset).\n\nPossible flag values are XML_PARAM_ENTITY_PARSING_NEVER,\nXML_PARAM_ENTITY_PARSING_UNLESS_STANDALONE and\nXML_PARAM_ENTITY_PARSING_ALWAYS. Returns true if setting the flag\nwas successful.",
     "pyexpat.XMLParserType.SetReparseDeferralEnabled" => "Enable/Disable reparse deferral; enabled by default with Expat >=2.6.0.",
@@ -9045,6 +15177,29 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "pyexpat.XMLParserType.__sizeof__" => "Size of object in memory, in bytes.",
     "pyexpat.XMLParserType.__str__" => "Return str(self).",
     "pyexpat.XMLParserType.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "pyexpat.error.__delattr__" => "Implement delattr(self, name).",
+    "pyexpat.error.__eq__" => "Return self==value.",
+    "pyexpat.error.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "pyexpat.error.__ge__" => "Return self>=value.",
+    "pyexpat.error.__getattribute__" => "Return getattr(self, name).",
+    "pyexpat.error.__getstate__" => "Helper for pickle.",
+    "pyexpat.error.__gt__" => "Return self>value.",
+    "pyexpat.error.__hash__" => "Return hash(self).",
+    "pyexpat.error.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "pyexpat.error.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "pyexpat.error.__le__" => "Return self<=value.",
+    "pyexpat.error.__lt__" => "Return self<value.",
+    "pyexpat.error.__ne__" => "Return self!=value.",
+    "pyexpat.error.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "pyexpat.error.__reduce_ex__" => "Helper for pickle.",
+    "pyexpat.error.__repr__" => "Return repr(self).",
+    "pyexpat.error.__setattr__" => "Implement setattr(self, name, value).",
+    "pyexpat.error.__sizeof__" => "Size of object in memory, in bytes.",
+    "pyexpat.error.__str__" => "Return str(self).",
+    "pyexpat.error.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "pyexpat.error.__weakref__" => "list of weak references to the object",
+    "pyexpat.error.add_note" => "Add a note to the exception",
+    "pyexpat.error.with_traceback" => "Set self.__traceback__ to tb and return self.",
     "readline" => "Importing this module enables command line editing using GNU readline.",
     "readline.add_history" => "Add an item to the history buffer.",
     "readline.append_history_file" => "Append the last nelements items of the history list to file.\n\nThe default filename is ~/.history.",
@@ -9148,10 +15303,10 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "select.epoll.closed" => "True if the epoll handler is closed",
     "select.epoll.fileno" => "Return the epoll control file descriptor.",
     "select.epoll.fromfd" => "Create an epoll object from a given control fd.",
-    "select.epoll.modify" => "Modify event mask for a registered file descriptor.\n\nfd\n  the target file descriptor of the operation\neventmask\n  a bit set composed of the various EPOLL constants",
+    "select.epoll.modify" => "Modify event mask for a registered file descriptor.\n\n  fd\n    the target file descriptor of the operation\n  eventmask\n    a bit set composed of the various EPOLL constants",
     "select.epoll.poll" => "Wait for events on the epoll file descriptor.\n\n  timeout\n    the maximum time to wait in seconds (as float);\n    a timeout of None or -1 makes poll wait indefinitely\n  maxevents\n    the maximum number of events returned; -1 means no limit\n\nReturns a list containing any descriptors that have events to report,\nas a list of (fd, events) 2-tuples.",
     "select.epoll.register" => "Registers a new fd or raises an OSError if the fd is already registered.\n\n  fd\n    the target file descriptor of the operation\n  eventmask\n    a bit set composed of the various EPOLL constants\n\nThe epoll interface supports all file descriptors that support poll.",
-    "select.epoll.unregister" => "Remove a registered file descriptor from the epoll object.\n\nfd\n  the target file descriptor of the operation",
+    "select.epoll.unregister" => "Remove a registered file descriptor from the epoll object.\n\n  fd\n    the target file descriptor of the operation",
     "select.kevent" => "kevent(ident, filter=KQ_FILTER_READ, flags=KQ_EV_ADD, fflags=0, data=0, udata=0)\n\nThis object is the equivalent of the struct kevent for the C API.\n\nSee the kqueue manpage for more detailed information about the meaning\nof the arguments.\n\nOne minor note: while you might hope that udata could store a\nreference to a python object, it cannot, because it is impossible to\nkeep a proper reference count of the object once it's passed into the\nkernel. Therefore, I have restricted it to only storing an integer.  I\nrecommend ignoring it and simply using the 'ident' field to key off\nof. You could also set up a dictionary on the python side to store a\nudata->object mapping.",
     "select.kevent.__delattr__" => "Implement delattr(self, name).",
     "select.kevent.__eq__" => "Return self==value.",
@@ -9198,7 +15353,7 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "select.kqueue.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
     "select.kqueue.close" => "Close the kqueue control file descriptor.\n\nFurther operations on the kqueue object will raise an exception.",
     "select.kqueue.closed" => "True if the kqueue handler is closed",
-    "select.kqueue.control" => "Calls the kernel kevent function.\n\nchangelist\n  Must be an iterable of kevent objects describing the changes to be made\n  to the kernel's watch list or None.\nmaxevents\n  The maximum number of events that the kernel will return.\ntimeout\n  The maximum time to wait in seconds, or else None to wait forever.\n  This accepts floats for smaller timeouts, too.",
+    "select.kqueue.control" => "Calls the kernel kevent function.\n\n  changelist\n    Must be an iterable of kevent objects describing the changes to be made\n    to the kernel's watch list or None.\n  maxevents\n    The maximum number of events that the kernel will return.\n  timeout\n    The maximum time to wait in seconds, or else None to wait forever.\n    This accepts floats for smaller timeouts, too.",
     "select.kqueue.fileno" => "Return the kqueue control file descriptor.",
     "select.kqueue.fromfd" => "Create a kqueue object from a given control fd.",
     "select.poll" => "Returns a polling object.\n\nThis object supports registering and unregistering file descriptors, and then\npolling them for I/O events.",
@@ -9211,14 +15366,17 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "sys._baserepl" => "Private function for getting the base REPL",
     "sys._clear_internal_caches" => "Clear all internal performance-related caches.",
     "sys._clear_type_cache" => "Clear the internal type lookup cache.",
+    "sys._clear_type_descriptors" => "Private function for clearing certain descriptors from a type's dictionary.\n\nSee gh-135228 for context.",
     "sys._current_exceptions" => "Return a dict mapping each thread's identifier to its current raised exception.\n\nThis function should be used for specialized purposes only.",
     "sys._current_frames" => "Return a dict mapping each thread's thread id to its current stack frame.\n\nThis function should be used for specialized purposes only.",
     "sys._debugmallocstats" => "Print summary info to stderr about the state of pymalloc's structures.\n\nIn Py_DEBUG mode, also perform some expensive internal consistency\nchecks.",
+    "sys._dump_tracelets" => "Dump the graph of tracelets in graphviz format",
     "sys._enablelegacywindowsfsencoding" => "Changes the default filesystem encoding to mbcs:replace.\n\nThis is done for consistency with earlier versions of Python. See PEP\n529 for more information.\n\nThis is equivalent to defining the PYTHONLEGACYWINDOWSFSENCODING\nenvironment variable before launching Python.",
     "sys._get_cpu_count_config" => "Private function for getting PyConfig.cpu_count",
     "sys._getframe" => "Return a frame object from the call stack.\n\nIf optional integer depth is given, return the frame object that many\ncalls below the top of the stack.  If that is deeper than the call\nstack, ValueError is raised.  The default for depth is zero, returning\nthe frame at the top of the call stack.\n\nThis function should be used for internal and specialized purposes\nonly.",
     "sys._getframemodulename" => "Return the name of the module for a calling frame.\n\nThe default depth returns the module containing the call to this API.\nA more typical use in a library will pass a depth of 1 to get the user's\nmodule rather than the library module.\n\nIf no frame, module, or name can be found, returns None.",
     "sys._is_gil_enabled" => "Return True if the GIL is currently enabled and False otherwise.",
+    "sys._is_immortal" => "Return True if the given object is \"immortal\" per PEP 683.\n\nThis function should be used for specialized purposes only.",
     "sys._is_interned" => "Return True if the given string is \"interned\".",
     "sys._setprofileallthreads" => "Set the profiling function in all running threads belonging to the current interpreter.\n\nIt will be called on each function call and return.  See the profiler\nchapter in the library manual.",
     "sys._settraceallthreads" => "Set the global debug tracing function in all running threads belonging to the current interpreter.\n\nIt will be called on each function call. See the debugger chapter\nin the library manual.",
@@ -9251,7 +15409,9 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "sys.getwindowsversion" => "Return info about the running version of Windows as a named tuple.\n\nThe members are named: major, minor, build, platform, service_pack,\nservice_pack_major, service_pack_minor, suite_mask, product_type and\nplatform_version. For backward compatibility, only the first 5 items\nare available by indexing. All elements are numbers, except\nservice_pack and platform_type which are strings, and platform_version\nwhich is a 3-tuple. Platform is always 2. Product_type may be 1 for a\nworkstation, 2 for a domain controller, 3 for a server.\nPlatform_version is a 3-tuple containing a version number that is\nintended for identifying the OS rather than feature detection.",
     "sys.intern" => "``Intern'' the given string.\n\nThis enters the string in the (global) table of interned strings whose\npurpose is to speed up dictionary lookups. Return the string itself or\nthe previously interned string object with the same value.",
     "sys.is_finalizing" => "Return True if Python is exiting.",
+    "sys.is_remote_debug_enabled" => "Return True if remote debugging is enabled, False otherwise.",
     "sys.is_stack_trampoline_active" => "Return *True* if a stack profiler trampoline is active.",
+    "sys.remote_exec" => "Executes a file containing Python code in a given remote Python process.\n\nThis function returns immediately, and the code will be executed by the\ntarget process's main thread at the next available opportunity, similarly\nto how signals are handled. There is no interface to determine when the\ncode has been executed. The caller is responsible for making sure that\nthe file still exists whenever the remote process tries to read it and that\nit hasn't been overwritten.\n\nThe remote process must be running a CPython interpreter of the same major\nand minor version as the local process. If either the local or remote\ninterpreter is pre-release (alpha, beta, or release candidate) then the\nlocal and remote interpreters must be the same exact version.\n\nArgs:\n     pid (int): The process ID of the target Python process.\n     script (str|bytes): The path to a file containing\n         the Python code to be executed.",
     "sys.set_asyncgen_hooks" => "set_asyncgen_hooks([firstiter] [, finalizer])\n\nSet a finalizer for async generators objects.",
     "sys.set_coroutine_origin_tracking_depth" => "Enable or disable origin tracking for coroutine objects in this thread.\n\nCoroutine objects will track 'depth' frames of traceback information\nabout where they came from, available in their cr_origin attribute.\n\nSet a depth of 0 to disable.",
     "sys.set_int_max_str_digits" => "Set the maximum string digits limit for non-binary int<->str conversions.",
@@ -9268,8 +15428,6 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "syslog.setlogmask" => "Set the priority mask to maskpri and return the previous mask value.",
     "syslog.syslog" => "syslog([priority=LOG_INFO,] message)\nSend the string message to the system logger.",
     "termios" => "This module provides an interface to the Posix calls for tty I/O control.\nFor a complete description of these calls, see the Posix or Unix manual\npages. It is only available for those Unix versions that support Posix\ntermios style tty I/O control.\n\nAll functions in this module take a file descriptor fd as their first\nargument. This can be an integer file descriptor, such as returned by\nsys.stdin.fileno(), or a file object, such as sys.stdin itself.",
-    "termios.error.__cause__" => "exception cause",
-    "termios.error.__context__" => "exception context",
     "termios.error.__delattr__" => "Implement delattr(self, name).",
     "termios.error.__eq__" => "Return self==value.",
     "termios.error.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
@@ -9291,8 +15449,8 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "termios.error.__str__" => "Return str(self).",
     "termios.error.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
     "termios.error.__weakref__" => "list of weak references to the object",
-    "termios.error.add_note" => "Exception.add_note(note) --\nadd a note to the exception",
-    "termios.error.with_traceback" => "Exception.with_traceback(tb) --\nset self.__traceback__ to tb and return self.",
+    "termios.error.add_note" => "Add a note to the exception",
+    "termios.error.with_traceback" => "Set self.__traceback__ to tb and return self.",
     "termios.tcdrain" => "Wait until all output written to file descriptor fd has been transmitted.",
     "termios.tcflow" => "Suspend or resume input or output on file descriptor fd.\n\nThe action argument can be termios.TCOOFF to suspend output,\ntermios.TCOON to restart output, termios.TCIOFF to suspend input,\nor termios.TCION to restart input.",
     "termios.tcflush" => "Discard queued data on file descriptor fd.\n\nThe queue selector specifies which queue: termios.TCIFLUSH for the input\nqueue, termios.TCOFLUSH for the output queue, or termios.TCIOFLUSH for\nboth queues.",
@@ -9323,7 +15481,7 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "time.sleep" => "sleep(seconds)\n\nDelay execution for a given number of seconds.  The argument may be\na floating-point number for subsecond precision.",
     "time.strftime" => "strftime(format[, tuple]) -> string\n\nConvert a time tuple to a string according to a format specification.\nSee the library reference manual for formatting codes. When the time tuple\nis not present, current time as returned by localtime() is used.\n\nCommonly used format codes:\n\n%Y  Year with century as a decimal number.\n%m  Month as a decimal number [01,12].\n%d  Day of the month as a decimal number [01,31].\n%H  Hour (24-hour clock) as a decimal number [00,23].\n%M  Minute as a decimal number [00,59].\n%S  Second as a decimal number [00,61].\n%z  Time zone offset from UTC.\n%a  Locale's abbreviated weekday name.\n%A  Locale's full weekday name.\n%b  Locale's abbreviated month name.\n%B  Locale's full month name.\n%c  Locale's appropriate date and time representation.\n%I  Hour (12-hour clock) as a decimal number [01,12].\n%p  Locale's equivalent of either AM or PM.\n\nOther codes may be available on your platform.  See documentation for\nthe C library strftime function.",
     "time.strptime" => "strptime(string, format) -> struct_time\n\nParse a string to a time tuple according to a format specification.\nSee the library reference manual for formatting codes (same as\nstrftime()).\n\nCommonly used format codes:\n\n%Y  Year with century as a decimal number.\n%m  Month as a decimal number [01,12].\n%d  Day of the month as a decimal number [01,31].\n%H  Hour (24-hour clock) as a decimal number [00,23].\n%M  Minute as a decimal number [00,59].\n%S  Second as a decimal number [00,61].\n%z  Time zone offset from UTC.\n%a  Locale's abbreviated weekday name.\n%A  Locale's full weekday name.\n%b  Locale's abbreviated month name.\n%B  Locale's full month name.\n%c  Locale's appropriate date and time representation.\n%I  Hour (12-hour clock) as a decimal number [01,12].\n%p  Locale's equivalent of either AM or PM.\n\nOther codes may be available on your platform.  See documentation for\nthe C library strftime function.",
-    "time.struct_time" => "The time value as returned by gmtime(), localtime(), and strptime(), and\naccepted by asctime(), mktime() and strftime().  May be considered as a\nsequence of 9 integers.\n\nNote that several fields' values are not the same as those defined by\nthe C language standard for struct tm.  For example, the value of the\nfield tm_year is the actual year, not year - 1900.  See individual\nfields' descriptions for details.",
+    "time.struct_time" => "The time value as returned by gmtime(), localtime(), and strptime(), and\n accepted by asctime(), mktime() and strftime().  May be considered as a\n sequence of 9 integers.\n\n Note that several fields' values are not the same as those defined by\n the C language standard for struct tm.  For example, the value of the\n field tm_year is the actual year, not year - 1900.  See individual\n fields' descriptions for details.",
     "time.struct_time.__add__" => "Return self+value.",
     "time.struct_time.__class_getitem__" => "See PEP 585",
     "time.struct_time.__contains__" => "Return bool(key in self).",
@@ -9371,7 +15529,7 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "time.time" => "time() -> floating-point number\n\nReturn the current time in seconds since the Epoch.\nFractions of a second may be present if the system clock provides them.",
     "time.time_ns" => "time_ns() -> int\n\nReturn the current time in nanoseconds since the Epoch.",
     "time.tzset" => "tzset()\n\nInitialize, or reinitialize, the local timezone to the value stored in\nos.environ['TZ']. The TZ environment variable should be specified in\nstandard Unix timezone format as documented in the tzset man page\n(eg. 'US/Eastern', 'Europe/Amsterdam'). Unknown timezones will silently\nfall back to UTC. If the TZ environment variable is not set, the local\ntimezone is set to the systems best guess of wallclock time.\nChanging the TZ environment variable without calling tzset *may* change\nthe local timezone used by methods such as localtime, but this behaviour\nshould not be relied on.",
-    "unicodedata" => "This module provides access to the Unicode Character Database which\ndefines character properties for all Unicode characters. The data in\nthis database is based on the UnicodeData.txt file version\n15.1.0 which is publicly available from ftp://ftp.unicode.org/.\n\nThe module uses the same names and symbols as defined by the\nUnicodeData File Format 15.1.0.",
+    "unicodedata" => "This module provides access to the Unicode Character Database which\ndefines character properties for all Unicode characters. The data in\nthis database is based on the UnicodeData.txt file version\n16.0.0 which is publicly available from ftp://ftp.unicode.org/.\n\nThe module uses the same names and symbols as defined by the\nUnicodeData File Format 16.0.0.",
     "unicodedata.UCD.__delattr__" => "Implement delattr(self, name).",
     "unicodedata.UCD.__eq__" => "Return self==value.",
     "unicodedata.UCD.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
@@ -9419,21 +15577,21 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "unicodedata.name" => "Returns the name assigned to the character chr as a string.\n\nIf no name is defined, default is returned, or, if not given,\nValueError is raised.",
     "unicodedata.normalize" => "Return the normal form 'form' for the Unicode string unistr.\n\nValid values for form are 'NFC', 'NFKC', 'NFD', and 'NFKD'.",
     "unicodedata.numeric" => "Converts a Unicode character into its equivalent numeric value.\n\nReturns the numeric value assigned to the character chr as float.\nIf no such value is defined, default is returned, or, if not given,\nValueError is raised.",
-    "winreg" => "This module provides access to the Windows registry API.\n\nFunctions:\n\nCloseKey() - Closes a registry key.\nConnectRegistry() - Establishes a connection to a predefined registry handle\n                    on another computer.\nCreateKey() - Creates the specified key, or opens it if it already exists.\nDeleteKey() - Deletes the specified key.\nDeleteValue() - Removes a named value from the specified registry key.\nEnumKey() - Enumerates subkeys of the specified open registry key.\nEnumValue() - Enumerates values of the specified open registry key.\nExpandEnvironmentStrings() - Expand the env strings in a REG_EXPAND_SZ\n                             string.\nFlushKey() - Writes all the attributes of the specified key to the registry.\nLoadKey() - Creates a subkey under HKEY_USER or HKEY_LOCAL_MACHINE and\n            stores registration information from a specified file into that\n            subkey.\nOpenKey() - Opens the specified key.\nOpenKeyEx() - Alias of OpenKey().\nQueryValue() - Retrieves the value associated with the unnamed value for a\n               specified key in the registry.\nQueryValueEx() - Retrieves the type and data for a specified value name\n                 associated with an open registry key.\nQueryInfoKey() - Returns information about the specified key.\nSaveKey() - Saves the specified key, and all its subkeys a file.\nSetValue() - Associates a value with a specified key.\nSetValueEx() - Stores data in the value field of an open registry key.\n\nSpecial objects:\n\nHKEYType -- type object for HKEY objects\nerror -- exception raised for Win32 errors\n\nInteger constants:\nMany constants are defined - see the documentation for each function\nto see what constants are used, and where.",
+    "winreg" => "This module provides access to the Windows registry API.\n\nFunctions:\n\nCloseKey() - Closes a registry key.\nConnectRegistry() - Establishes a connection to a predefined registry handle\n                    on another computer.\nCreateKey() - Creates the specified key, or opens it if it already exists.\nDeleteKey() - Deletes the specified key.\nDeleteValue() - Removes a named value from the specified registry key.\nDeleteTree() - Deletes the specified key and all its subkeys and values recursively.\nEnumKey() - Enumerates subkeys of the specified open registry key.\nEnumValue() - Enumerates values of the specified open registry key.\nExpandEnvironmentStrings() - Expand the env strings in a REG_EXPAND_SZ\n                             string.\nFlushKey() - Writes all the attributes of the specified key to the registry.\nLoadKey() - Creates a subkey under HKEY_USER or HKEY_LOCAL_MACHINE and\n            stores registration information from a specified file into that\n            subkey.\nOpenKey() - Opens the specified key.\nOpenKeyEx() - Alias of OpenKey().\nQueryValue() - Retrieves the value associated with the unnamed value for a\n               specified key in the registry.\nQueryValueEx() - Retrieves the type and data for a specified value name\n                 associated with an open registry key.\nQueryInfoKey() - Returns information about the specified key.\nSaveKey() - Saves the specified key, and all its subkeys a file.\nSetValue() - Associates a value with a specified key.\nSetValueEx() - Stores data in the value field of an open registry key.\n\nSpecial objects:\n\nHKEYType -- type object for HKEY objects\nerror -- exception raised for Win32 errors\n\nInteger constants:\nMany constants are defined - see the documentation for each function\nto see what constants are used, and where.",
     "winreg.CloseKey" => "Closes a previously opened registry key.\n\n  hkey\n    A previously opened key.\n\nNote that if the key is not closed using this method, it will be\nclosed when the hkey object is destroyed by Python.",
     "winreg.ConnectRegistry" => "Establishes a connection to the registry on another computer.\n\n  computer_name\n    The name of the remote computer, of the form r\"\\\\computername\".  If\n    None, the local computer is used.\n  key\n    The predefined key to connect to.\n\nThe return value is the handle of the opened key.\nIf the function fails, an OSError exception is raised.",
     "winreg.CreateKey" => "Creates or opens the specified key.\n\n  key\n    An already open key, or one of the predefined HKEY_* constants.\n  sub_key\n    The name of the key this method opens or creates.\n\nIf key is one of the predefined keys, sub_key may be None. In that case,\nthe handle returned is the same key handle passed in to the function.\n\nIf the key already exists, this function opens the existing key.\n\nThe return value is the handle of the opened key.\nIf the function fails, an OSError exception is raised.",
     "winreg.CreateKeyEx" => "Creates or opens the specified key.\n\n  key\n    An already open key, or one of the predefined HKEY_* constants.\n  sub_key\n    The name of the key this method opens or creates.\n  reserved\n    A reserved integer, and must be zero.  Default is zero.\n  access\n    An integer that specifies an access mask that describes the\n    desired security access for the key. Default is KEY_WRITE.\n\nIf key is one of the predefined keys, sub_key may be None. In that case,\nthe handle returned is the same key handle passed in to the function.\n\nIf the key already exists, this function opens the existing key\n\nThe return value is the handle of the opened key.\nIf the function fails, an OSError exception is raised.",
     "winreg.DeleteKey" => "Deletes the specified key.\n\n  key\n    An already open key, or any one of the predefined HKEY_* constants.\n  sub_key\n    A string that must be the name of a subkey of the key identified by\n    the key parameter. This value must not be None, and the key may not\n    have subkeys.\n\nThis method can not delete keys with subkeys.\n\nIf the function succeeds, the entire key, including all of its values,\nis removed.  If the function fails, an OSError exception is raised.",
     "winreg.DeleteKeyEx" => "Deletes the specified key (intended for 64-bit OS).\n\n  key\n    An already open key, or any one of the predefined HKEY_* constants.\n  sub_key\n    A string that must be the name of a subkey of the key identified by\n    the key parameter. This value must not be None, and the key may not\n    have subkeys.\n  access\n    An integer that specifies an access mask that describes the\n    desired security access for the key. Default is KEY_WOW64_64KEY.\n  reserved\n    A reserved integer, and must be zero.  Default is zero.\n\nWhile this function is intended to be used for 64-bit OS, it is also\n available on 32-bit systems.\n\nThis method can not delete keys with subkeys.\n\nIf the function succeeds, the entire key, including all of its values,\nis removed.  If the function fails, an OSError exception is raised.\nOn unsupported Windows versions, NotImplementedError is raised.",
-    "winreg.DeleteValue" => "Removes a named value from a registry key.\n\nkey\n  An already open key, or any one of the predefined HKEY_* constants.\nvalue\n  A string that identifies the value to remove.",
+    "winreg.DeleteValue" => "Removes a named value from a registry key.\n\n  key\n    An already open key, or any one of the predefined HKEY_* constants.\n  value\n    A string that identifies the value to remove.",
     "winreg.DisableReflectionKey" => "Disables registry reflection for 32bit processes running on a 64bit OS.\n\n  key\n    An already open key, or any one of the predefined HKEY_* constants.\n\nWill generally raise NotImplementedError if executed on a 32bit OS.\n\nIf the key is not on the reflection list, the function succeeds but has\nno effect.  Disabling reflection for a key does not affect reflection\nof any subkeys.",
     "winreg.EnableReflectionKey" => "Restores registry reflection for the specified disabled key.\n\n  key\n    An already open key, or any one of the predefined HKEY_* constants.\n\nWill generally raise NotImplementedError if executed on a 32bit OS.\nRestoring reflection for a key does not affect reflection of any\nsubkeys.",
     "winreg.EnumKey" => "Enumerates subkeys of an open registry key.\n\n  key\n    An already open key, or any one of the predefined HKEY_* constants.\n  index\n    An integer that identifies the index of the key to retrieve.\n\nThe function retrieves the name of one subkey each time it is called.\nIt is typically called repeatedly until an OSError exception is\nraised, indicating no more values are available.",
     "winreg.EnumValue" => "Enumerates values of an open registry key.\n\n  key\n    An already open key, or any one of the predefined HKEY_* constants.\n  index\n    An integer that identifies the index of the value to retrieve.\n\nThe function retrieves the name of one subkey each time it is called.\nIt is typically called repeatedly, until an OSError exception\nis raised, indicating no more values.\n\nThe result is a tuple of 3 items:\n  value_name\n    A string that identifies the value.\n  value_data\n    An object that holds the value data, and whose type depends\n    on the underlying registry type.\n  data_type\n    An integer that identifies the type of the value data.",
     "winreg.ExpandEnvironmentStrings" => "Expand environment vars.",
     "winreg.FlushKey" => "Writes all the attributes of a key to the registry.\n\n  key\n    An already open key, or any one of the predefined HKEY_* constants.\n\nIt is not necessary to call FlushKey to change a key.  Registry changes\nare flushed to disk by the registry using its lazy flusher.  Registry\nchanges are also flushed to disk at system shutdown.  Unlike\nCloseKey(), the FlushKey() method returns only when all the data has\nbeen written to the registry.\n\nAn application should only call FlushKey() if it requires absolute\ncertainty that registry changes are on disk.  If you don't know whether\na FlushKey() call is required, it probably isn't.",
-    "winreg.HKEYType" => "PyHKEY Object - A Python object, representing a win32 registry key.\n\nThis object wraps a Windows HKEY object, automatically closing it when\nthe object is destroyed.  To guarantee cleanup, you can call either\nthe Close() method on the PyHKEY, or the CloseKey() method.\n\nAll functions which accept a handle object also accept an integer --\nhowever, use of the handle object is encouraged.\n\nFunctions:\nClose() - Closes the underlying handle.\nDetach() - Returns the integer Win32 handle, detaching it from the object\n\nProperties:\nhandle - The integer Win32 handle.\n\nOperations:\n__bool__ - Handles with an open object return true, otherwise false.\n__int__ - Converting a handle to an integer returns the Win32 handle.\nrich comparison - Handle objects are compared using the handle value.",
+    "winreg.HKEYType" => "PyHKEY Object - A Python object, representing a win32 registry key.\n\nThis object wraps a Windows HKEY object, automatically closing it when\nthe object is destroyed.  To guarantee cleanup, you can call either\nthe Close() method on the PyHKEY, or the CloseKey() method.\n\nAll functions which accept a handle object also accept an integer --\nhowever, use of the handle object is encouraged.\n\nFunctions:\nClose() - Closes the underlying handle.\nDetach() - Returns the integer Win32 handle, detaching it from the object\n\nProperties:\nhandle - The integer Win32 handle.\n\nOperations:\n__bool__ - Handles with an open object return true, otherwise false.\n__int__ - Converting a handle to an integer returns the Win32 handle.\n__enter__, __exit__ - Context manager support for 'with' statement,\nautomatically closes handle.",
     "winreg.HKEYType.Close" => "Closes the underlying Windows handle.\n\nIf the handle is already closed, no error is raised.",
     "winreg.HKEYType.Detach" => "Detaches the Windows handle from the handle object.\n\nThe result is the value of the handle before it is detached.  If the\nhandle is already detached, this will return zero.\n\nAfter calling this function, the handle is effectively invalidated,\nbut the handle is not closed.  You would call this function when you\nneed the underlying win32 handle to exist beyond the lifetime of the\nhandle object.",
     "winreg.HKEYType.__abs__" => "abs(self)",
@@ -9496,12 +15654,12 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "winreg.SaveKey" => "Saves the specified key, and all its subkeys to the specified file.\n\n  key\n    An already open key, or any one of the predefined HKEY_* constants.\n  file_name\n    The name of the file to save registry data to.  This file cannot\n    already exist. If this filename includes an extension, it cannot be\n    used on file allocation table (FAT) file systems by the LoadKey(),\n    ReplaceKey() or RestoreKey() methods.\n\nIf key represents a key on a remote computer, the path described by\nfile_name is relative to the remote computer.\n\nThe caller of this method must possess the SeBackupPrivilege\nsecurity privilege.  This function passes NULL for security_attributes\nto the API.",
     "winreg.SetValue" => "Associates a value with a specified key.\n\n  key\n    An already open key, or any one of the predefined HKEY_* constants.\n  sub_key\n    A string that names the subkey with which the value is associated.\n  type\n    An integer that specifies the type of the data.  Currently this must\n    be REG_SZ, meaning only strings are supported.\n  value\n    A string that specifies the new value.\n\nIf the key specified by the sub_key parameter does not exist, the\nSetValue function creates it.\n\nValue lengths are limited by available memory. Long values (more than\n2048 bytes) should be stored as files with the filenames stored in\nthe configuration registry to help the registry perform efficiently.\n\nThe key identified by the key parameter must have been opened with\nKEY_SET_VALUE access.",
     "winreg.SetValueEx" => "Stores data in the value field of an open registry key.\n\n  key\n    An already open key, or any one of the predefined HKEY_* constants.\n  value_name\n    A string containing the name of the value to set, or None.\n  reserved\n    Can be anything - zero is always passed to the API.\n  type\n    An integer that specifies the type of the data, one of:\n    REG_BINARY -- Binary data in any form.\n    REG_DWORD -- A 32-bit number.\n    REG_DWORD_LITTLE_ENDIAN -- A 32-bit number in little-endian format. Equivalent to REG_DWORD\n    REG_DWORD_BIG_ENDIAN -- A 32-bit number in big-endian format.\n    REG_EXPAND_SZ -- A null-terminated string that contains unexpanded\n                     references to environment variables (for example,\n                     %PATH%).\n    REG_LINK -- A Unicode symbolic link.\n    REG_MULTI_SZ -- A sequence of null-terminated strings, terminated\n                    by two null characters.  Note that Python handles\n                    this termination automatically.\n    REG_NONE -- No defined value type.\n    REG_QWORD -- A 64-bit number.\n    REG_QWORD_LITTLE_ENDIAN -- A 64-bit number in little-endian format. Equivalent to REG_QWORD.\n    REG_RESOURCE_LIST -- A device-driver resource list.\n    REG_SZ -- A null-terminated string.\n  value\n    A string that specifies the new value.\n\nThis method can also set additional value and type information for the\nspecified key.  The key identified by the key parameter must have been\nopened with KEY_SET_VALUE access.\n\nTo open the key, use the CreateKeyEx() or OpenKeyEx() methods.\n\nValue lengths are limited by available memory. Long values (more than\n2048 bytes) should be stored as files with the filenames stored in\nthe configuration registry to help the registry perform efficiently.",
-    "winsound" => "PlaySound(sound, flags) - play a sound\nSND_FILENAME - sound is a wav file name\nSND_ALIAS - sound is a registry sound association name\nSND_LOOP - Play the sound repeatedly; must also specify SND_ASYNC\nSND_MEMORY - sound is a memory image of a wav file\nSND_PURGE - stop all instances of the specified sound\nSND_ASYNC - PlaySound returns immediately\nSND_NODEFAULT - Do not play a default beep if the sound can not be found\nSND_NOSTOP - Do not interrupt any sounds currently playing\nSND_NOWAIT - Return immediately if the sound driver is busy\nSND_APPLICATION - sound is an application-specific alias in the registry.\nBeep(frequency, duration) - Make a beep through the PC speaker.\nMessageBeep(type) - Call Windows MessageBeep.",
-    "winsound.Beep" => "A wrapper around the Windows Beep API.\n\nfrequency\n  Frequency of the sound in hertz.\n  Must be in the range 37 through 32,767.\nduration\n  How long the sound should play, in milliseconds.",
+    "winsound" => "PlaySound(sound, flags) - play a sound\nSND_FILENAME - sound is a wav file name\nSND_ALIAS - sound is a registry sound association name\nSND_LOOP - Play the sound repeatedly; must also specify SND_ASYNC\nSND_MEMORY - sound is a memory image of a wav file\nSND_PURGE - stop all instances of the specified sound\nSND_ASYNC - PlaySound returns immediately\nSND_NODEFAULT - Do not play a default beep if the sound can not be found\nSND_NOSTOP - Do not interrupt any sounds currently playing\nSND_NOWAIT - Return immediately if the sound driver is busy\nSND_APPLICATION - sound is an application-specific alias in the registry.\nSND_SENTRY - Triggers a SoundSentry event when the sound is played.\nSND_SYNC - Play the sound synchronously, default behavior.\nSND_SYSTEM - Assign sound to the audio session for system notification sounds.\n\nBeep(frequency, duration) - Make a beep through the PC speaker.\nMessageBeep(type) - Call Windows MessageBeep.",
+    "winsound.Beep" => "A wrapper around the Windows Beep API.\n\n  frequency\n    Frequency of the sound in hertz.\n    Must be in the range 37 through 32,767.\n  duration\n    How long the sound should play, in milliseconds.",
     "winsound.MessageBeep" => "Call Windows MessageBeep(x).\n\nx defaults to MB_OK.",
-    "winsound.PlaySound" => "A wrapper around the Windows PlaySound API.\n\nsound\n  The sound to play; a filename, data, or None.\nflags\n  Flag values, ored together.  See module documentation.",
+    "winsound.PlaySound" => "A wrapper around the Windows PlaySound API.\n\n  sound\n    The sound to play; a filename, data, or None.\n  flags\n    Flag values, ored together.  See module documentation.",
     "zlib" => "The functions in this module allow compression and decompression using the\nzlib library, which is based on GNU zip.\n\nadler32(string[, start]) -- Compute an Adler-32 checksum.\ncompress(data[, level]) -- Compress data, with compression level 0-9 or -1.\ncompressobj([level[, ...]]) -- Return a compressor object.\ncrc32(string[, start]) -- Compute a CRC-32 checksum.\ndecompress(string,[wbits],[bufsize]) -- Decompresses a compressed string.\ndecompressobj([wbits[, zdict]]) -- Return a decompressor object.\n\n'wbits' is window buffer size and container format.\nCompressor objects support compress() and flush() methods; decompressor\nobjects support decompress() and flush().",
-    "zlib._ZlibDecompressor" => "Create a decompressor object for decompressing data incrementally.\n\nwbits = 15\nzdict\n   The predefined compression dictionary. This is a sequence of bytes\n   (such as a bytes object) containing subsequences that are expected\n   to occur frequently in the data that is to be compressed. Those\n   subsequences that are expected to be most common should come at the\n   end of the dictionary. This must be the same dictionary as used by the\n   compressor that produced the input data.",
+    "zlib._ZlibDecompressor" => "Create a decompressor object for decompressing data incrementally.\n\n  wbits = 15\n  zdict\n     The predefined compression dictionary. This is a sequence of bytes\n     (such as a bytes object) containing subsequences that are expected\n     to occur frequently in the data that is to be compressed. Those\n     subsequences that are expected to be most common should come at the\n     end of the dictionary. This must be the same dictionary as used by the\n     compressor that produced the input data.",
     "zlib._ZlibDecompressor.__delattr__" => "Implement delattr(self, name).",
     "zlib._ZlibDecompressor.__eq__" => "Return self==value.",
     "zlib._ZlibDecompressor.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
@@ -9528,13 +15686,11 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "zlib._ZlibDecompressor.needs_input" => "True if more input is needed before more decompressed data can be produced.",
     "zlib._ZlibDecompressor.unused_data" => "Data found after the end of the compressed stream.",
     "zlib.adler32" => "Compute an Adler-32 checksum of data.\n\n  value\n    Starting value of the checksum.\n\nThe returned checksum is an integer.",
-    "zlib.compress" => "Returns a bytes object containing compressed data.\n\ndata\n  Binary data to be compressed.\nlevel\n  Compression level, in 0-9 or -1.\nwbits\n  The window buffer size and container format.",
-    "zlib.compressobj" => "Return a compressor object.\n\nlevel\n  The compression level (an integer in the range 0-9 or -1; default is\n  currently equivalent to 6).  Higher compression levels are slower,\n  but produce smaller results.\nmethod\n  The compression algorithm.  If given, this must be DEFLATED.\nwbits\n  +9 to +15: The base-two logarithm of the window size.  Include a zlib\n      container.\n  -9 to -15: Generate a raw stream.\n  +25 to +31: Include a gzip container.\nmemLevel\n  Controls the amount of memory used for internal compression state.\n  Valid values range from 1 to 9.  Higher values result in higher memory\n  usage, faster compression, and smaller output.\nstrategy\n  Used to tune the compression algorithm.  Possible values are\n  Z_DEFAULT_STRATEGY, Z_FILTERED, and Z_HUFFMAN_ONLY.\nzdict\n  The predefined compression dictionary - a sequence of bytes\n  containing subsequences that are likely to occur in the input data.",
+    "zlib.compress" => "Returns a bytes object containing compressed data.\n\n  data\n    Binary data to be compressed.\n  level\n    Compression level, in 0-9 or -1.\n  wbits\n    The window buffer size and container format.",
+    "zlib.compressobj" => "Return a compressor object.\n\n  level\n    The compression level (an integer in the range 0-9 or -1; default is\n    currently equivalent to 6).  Higher compression levels are slower,\n    but produce smaller results.\n  method\n    The compression algorithm.  If given, this must be DEFLATED.\n  wbits\n    +9 to +15: The base-two logarithm of the window size.  Include a zlib\n        container.\n    -9 to -15: Generate a raw stream.\n    +25 to +31: Include a gzip container.\n  memLevel\n    Controls the amount of memory used for internal compression state.\n    Valid values range from 1 to 9.  Higher values result in higher memory\n    usage, faster compression, and smaller output.\n  strategy\n    Used to tune the compression algorithm.  Possible values are\n    Z_DEFAULT_STRATEGY, Z_FILTERED, and Z_HUFFMAN_ONLY.\n  zdict\n    The predefined compression dictionary - a sequence of bytes\n    containing subsequences that are likely to occur in the input data.",
     "zlib.crc32" => "Compute a CRC-32 checksum of data.\n\n  value\n    Starting value of the checksum.\n\nThe returned checksum is an integer.",
-    "zlib.decompress" => "Returns a bytes object containing the uncompressed data.\n\ndata\n  Compressed data.\nwbits\n  The window buffer size and container format.\nbufsize\n  The initial output buffer size.",
-    "zlib.decompressobj" => "Return a decompressor object.\n\nwbits\n  The window buffer size and container format.\nzdict\n  The predefined compression dictionary.  This must be the same\n  dictionary as used by the compressor that produced the input data.",
-    "zlib.error.__cause__" => "exception cause",
-    "zlib.error.__context__" => "exception context",
+    "zlib.decompress" => "Returns a bytes object containing the uncompressed data.\n\n  data\n    Compressed data.\n  wbits\n    The window buffer size and container format.\n  bufsize\n    The initial output buffer size.",
+    "zlib.decompressobj" => "Return a decompressor object.\n\n  wbits\n    The window buffer size and container format.\n  zdict\n    The predefined compression dictionary.  This must be the same\n    dictionary as used by the compressor that produced the input data.",
     "zlib.error.__delattr__" => "Implement delattr(self, name).",
     "zlib.error.__eq__" => "Return self==value.",
     "zlib.error.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
@@ -9556,6 +15712,6 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "zlib.error.__str__" => "Return str(self).",
     "zlib.error.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
     "zlib.error.__weakref__" => "list of weak references to the object",
-    "zlib.error.add_note" => "Exception.add_note(note) --\nadd a note to the exception",
-    "zlib.error.with_traceback" => "Exception.with_traceback(tb) --\nset self.__traceback__ to tb and return self.",
+    "zlib.error.add_note" => "Add a note to the exception",
+    "zlib.error.with_traceback" => "Set self.__traceback__ to tb and return self.",
 };
diff --git a/crates/doc/src/lib.rs b/crates/doc/src/lib.rs
index cc81f17fc55..8b7f5d8f75b 100644
--- a/crates/doc/src/lib.rs
+++ b/crates/doc/src/lib.rs
@@ -1,3 +1,5 @@
+#![no_std]
+
 include!("./data.inc.rs");
 
 #[cfg(test)]
diff --git a/crates/jit/Cargo.toml b/crates/jit/Cargo.toml
index e3e89636181..2d485ac884c 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.128"
-cranelift-jit = "0.128"
-cranelift-module = "0.128"
+cranelift = "0.130.0"
+cranelift-jit = "0.130.0"
+cranelift-module = "0.130.0"
 
 [dev-dependencies]
 rustpython-derive = { workspace = true }
diff --git a/crates/jit/src/instructions.rs b/crates/jit/src/instructions.rs
index 19931038fe0..88f6fe7411a 100644
--- a/crates/jit/src/instructions.rs
+++ b/crates/jit/src/instructions.rs
@@ -1,11 +1,12 @@
 // spell-checker: disable
 use super::{JitCompileError, JitSig, JitType};
+use alloc::collections::BTreeSet;
 use cranelift::codegen::ir::FuncRef;
 use cranelift::prelude::*;
 use num_traits::cast::ToPrimitive;
 use rustpython_compiler_core::bytecode::{
     self, BinaryOperator, BorrowedConstant, CodeObject, ComparisonOperator, Instruction,
-    IntrinsicFunction1, Label, OpArg, OpArgState,
+    IntrinsicFunction1, Label, OpArg, OpArgState, oparg,
 };
 use std::collections::HashMap;
 
@@ -93,7 +94,10 @@ impl<'a, 'b> FunctionCompiler<'a, 'b> {
         let params = compiler.builder.func.dfg.block_params(entry_block).to_vec();
         for (i, (ty, val)) in arg_types.iter().zip(params).enumerate() {
             compiler
-                .store_variable(i as u32, JitValue::from_type_and_value(ty.clone(), val))
+                .store_variable(
+                    (i as u32).into(),
+                    JitValue::from_type_and_value(ty.clone(), val),
+                )
                 .unwrap();
         }
         compiler
@@ -104,14 +108,10 @@ impl<'a, 'b> FunctionCompiler<'a, 'b> {
         self.stack.drain(stack_len - count..).collect()
     }
 
-    fn store_variable(
-        &mut self,
-        idx: bytecode::NameIdx,
-        val: JitValue,
-    ) -> Result<(), JitCompileError> {
+    fn store_variable(&mut self, idx: oparg::VarNum, val: JitValue) -> Result<(), JitCompileError> {
         let builder = &mut self.builder;
         let ty = val.to_jit_type().ok_or(JitCompileError::NotSupported)?;
-        let local = self.variables[idx as usize].get_or_insert_with(|| {
+        let local = self.variables[idx].get_or_insert_with(|| {
             let var = builder.declare_var(ty.to_cranelift());
             Local {
                 var,
@@ -154,19 +154,85 @@ impl<'a, 'b> FunctionCompiler<'a, 'b> {
             .or_insert_with(|| builder.create_block())
     }
 
+    fn jump_target_forward(offset: u32, caches: u32, arg: OpArg) -> Result<Label, JitCompileError> {
+        let after = offset
+            .checked_add(1)
+            .and_then(|i| i.checked_add(caches))
+            .ok_or(JitCompileError::BadBytecode)?;
+        let target = after
+            .checked_add(u32::from(arg))
+            .ok_or(JitCompileError::BadBytecode)?;
+        Ok(Label::from_u32(target))
+    }
+
+    fn jump_target_backward(
+        offset: u32,
+        caches: u32,
+        arg: OpArg,
+    ) -> Result<Label, JitCompileError> {
+        let after = offset
+            .checked_add(1)
+            .and_then(|i| i.checked_add(caches))
+            .ok_or(JitCompileError::BadBytecode)?;
+        let target = after
+            .checked_sub(u32::from(arg))
+            .ok_or(JitCompileError::BadBytecode)?;
+        Ok(Label::from_u32(target))
+    }
+
+    fn instruction_target(
+        offset: u32,
+        instruction: Instruction,
+        arg: OpArg,
+    ) -> Result<Option<Label>, JitCompileError> {
+        let caches = instruction.cache_entries() as u32;
+        let target = match instruction {
+            Instruction::JumpForward { .. } => {
+                Some(Self::jump_target_forward(offset, caches, arg)?)
+            }
+            Instruction::JumpBackward { .. } | Instruction::JumpBackwardNoInterrupt { .. } => {
+                Some(Self::jump_target_backward(offset, caches, arg)?)
+            }
+            Instruction::PopJumpIfFalse { .. }
+            | Instruction::PopJumpIfTrue { .. }
+            | Instruction::PopJumpIfNone { .. }
+            | Instruction::PopJumpIfNotNone { .. }
+            | Instruction::ForIter { .. }
+            | Instruction::Send { .. } => Some(Self::jump_target_forward(offset, caches, arg)?),
+            _ => None,
+        };
+        Ok(target)
+    }
+
     pub fn compile<C: bytecode::Constant>(
         &mut self,
         func_ref: FuncRef,
         bytecode: &CodeObject<C>,
     ) -> Result<(), JitCompileError> {
-        let label_targets = bytecode.label_targets();
+        // JIT should consume a stable instruction stream: de-specialized opcodes
+        // with zeroed CACHE entries, not runtime-mutated quickened code.
+        let clean_instructions: bytecode::CodeUnits = bytecode
+            .instructions
+            .original_bytes()
+            .as_slice()
+            .try_into()
+            .map_err(|_| JitCompileError::BadBytecode)?;
+
+        let mut label_targets = BTreeSet::new();
+        let mut target_arg_state = OpArgState::default();
+        for (offset, &raw_instr) in clean_instructions.iter().enumerate() {
+            let (instruction, arg) = target_arg_state.get(raw_instr);
+            if let Some(target) = Self::instruction_target(offset as u32, instruction, arg)? {
+                label_targets.insert(target);
+            }
+        }
         let mut arg_state = OpArgState::default();
 
         // Track whether we have "returned" in the current block
         let mut in_unreachable_code = false;
 
-        for (offset, &raw_instr) in bytecode.instructions.iter().enumerate() {
-            let label = Label(offset as u32);
+        for (offset, &raw_instr) in clean_instructions.iter().enumerate() {
+            let label = Label::from_u32(offset as u32);
             let (instruction, arg) = arg_state.get(raw_instr);
 
             // If this is a label that some earlier jump can target,
@@ -206,7 +272,7 @@ impl<'a, 'b> FunctionCompiler<'a, 'b> {
             }
 
             // Actually compile this instruction:
-            self.add_instruction(func_ref, bytecode, instruction, arg)?;
+            self.add_instruction(func_ref, bytecode, offset as u32, instruction, arg)?;
 
             // If that was an unconditional branch or return, mark future instructions unreachable
             match instruction {
@@ -288,6 +354,7 @@ impl<'a, 'b> FunctionCompiler<'a, 'b> {
         &mut self,
         func_ref: FuncRef,
         bytecode: &CodeObject<C>,
+        offset: u32,
         instruction: Instruction,
         arg: OpArg,
     ) -> Result<(), JitCompileError> {
@@ -453,13 +520,13 @@ impl<'a, 'b> FunctionCompiler<'a, 'b> {
 
                 Ok(())
             }
-            Instruction::BuildTuple { size } => {
-                let elements = self.pop_multiple(size.get(arg) as usize);
+            Instruction::BuildTuple { count } => {
+                let elements = self.pop_multiple(count.get(arg) as usize);
                 self.stack.push(JitValue::Tuple(elements));
                 Ok(())
             }
-            Instruction::Call { nargs } => {
-                let nargs = nargs.get(arg);
+            Instruction::Call { argc } => {
+                let nargs = argc.get(arg);
 
                 let mut args = Vec::new();
                 for _ in 0..nargs {
@@ -503,8 +570,8 @@ impl<'a, 'b> FunctionCompiler<'a, 'b> {
                     _ => Err(JitCompileError::NotSupported),
                 }
             }
-            Instruction::CompareOp { op, .. } => {
-                let op = op.get(arg);
+            Instruction::CompareOp { opname } => {
+                let op = opname.get(arg);
                 // the rhs is popped off first
                 let b = self.stack.pop().ok_or(JitCompileError::BadBytecode)?;
                 let a = self.stack.pop().ok_or(JitCompileError::BadBytecode)?;
@@ -557,29 +624,34 @@ impl<'a, 'b> FunctionCompiler<'a, 'b> {
                     _ => Err(JitCompileError::NotSupported),
                 }
             }
-            Instruction::ExtendedArg => Ok(()),
-
-            Instruction::JumpBackward { target }
-            | Instruction::JumpBackwardNoInterrupt { target }
-            | Instruction::JumpForward { target } => {
-                let target_block = self.get_or_create_block(target.get(arg));
+            Instruction::ExtendedArg
+            | Instruction::Cache
+            | Instruction::MakeCell { .. }
+            | Instruction::CopyFreeVars { .. } => Ok(()),
+
+            Instruction::JumpBackward { .. }
+            | Instruction::JumpBackwardNoInterrupt { .. }
+            | Instruction::JumpForward { .. } => {
+                let target = Self::instruction_target(offset, instruction, arg)?
+                    .ok_or(JitCompileError::BadBytecode)?;
+                let target_block = self.get_or_create_block(target);
                 self.builder.ins().jump(target_block, &[]);
                 Ok(())
             }
-            Instruction::LoadConst { idx } => {
-                let val = self
-                    .prepare_const(bytecode.constants[idx.get(arg) as usize].borrow_constant())?;
+            Instruction::LoadConst { consti } => {
+                let val =
+                    self.prepare_const(bytecode.constants[consti.get(arg)].borrow_constant())?;
                 self.stack.push(val);
                 Ok(())
             }
-            Instruction::LoadSmallInt { idx } => {
-                let small_int = idx.get(arg) as i64;
+            Instruction::LoadSmallInt { i } => {
+                let small_int = i.get(arg) as i64;
                 let val = self.builder.ins().iconst(types::I64, small_int);
                 self.stack.push(JitValue::Int(val));
                 Ok(())
             }
-            Instruction::LoadFast(idx) | Instruction::LoadFastBorrow(idx) => {
-                let local = self.variables[idx.get(arg) as usize]
+            Instruction::LoadFast { var_num } | Instruction::LoadFastBorrow { var_num } => {
+                let local = self.variables[var_num.get(arg)]
                     .as_ref()
                     .ok_or(JitCompileError::BadBytecode)?;
                 self.stack.push(JitValue::from_type_and_value(
@@ -588,13 +660,12 @@ impl<'a, 'b> FunctionCompiler<'a, 'b> {
                 ));
                 Ok(())
             }
-            Instruction::LoadFastLoadFast { arg: packed }
-            | Instruction::LoadFastBorrowLoadFastBorrow { arg: packed } => {
-                let oparg = packed.get(arg);
-                let idx1 = oparg >> 4;
-                let idx2 = oparg & 0xF;
+            Instruction::LoadFastLoadFast { var_nums }
+            | Instruction::LoadFastBorrowLoadFastBorrow { var_nums } => {
+                let oparg = var_nums.get(arg);
+                let (idx1, idx2) = oparg.indexes();
                 for idx in [idx1, idx2] {
-                    let local = self.variables[idx as usize]
+                    let local = self.variables[idx]
                         .as_ref()
                         .ok_or(JitCompileError::BadBytecode)?;
                     self.stack.push(JitValue::from_type_and_value(
@@ -604,21 +675,27 @@ impl<'a, 'b> FunctionCompiler<'a, 'b> {
                 }
                 Ok(())
             }
-            Instruction::LoadGlobal(idx) => {
-                let name = &bytecode.names[idx.get(arg) as usize];
+            Instruction::LoadGlobal { namei } => {
+                let oparg = namei.get(arg);
+                let name = &bytecode.names[(oparg >> 1) as usize];
 
                 if name.as_ref() != bytecode.obj_name.as_ref() {
                     Err(JitCompileError::NotSupported)
                 } else {
                     self.stack.push(JitValue::FuncRef(func_ref));
+                    if (oparg & 1) != 0 {
+                        self.stack.push(JitValue::Null);
+                    }
                     Ok(())
                 }
             }
-            Instruction::Nop => Ok(()),
-            Instruction::PopJumpIfFalse { target } => {
+            Instruction::Nop | Instruction::NotTaken => Ok(()),
+            Instruction::PopJumpIfFalse { .. } => {
                 let cond = self.stack.pop().ok_or(JitCompileError::BadBytecode)?;
                 let val = self.boolean_val(cond)?;
-                let then_block = self.get_or_create_block(target.get(arg));
+                let then_label = Self::instruction_target(offset, instruction, arg)?
+                    .ok_or(JitCompileError::BadBytecode)?;
+                let then_block = self.get_or_create_block(then_label);
                 let else_block = self.builder.create_block();
 
                 self.builder
@@ -628,10 +705,12 @@ impl<'a, 'b> FunctionCompiler<'a, 'b> {
 
                 Ok(())
             }
-            Instruction::PopJumpIfTrue { target } => {
+            Instruction::PopJumpIfTrue { .. } => {
                 let cond = self.stack.pop().ok_or(JitCompileError::BadBytecode)?;
                 let val = self.boolean_val(cond)?;
-                let then_block = self.get_or_create_block(target.get(arg));
+                let then_label = Self::instruction_target(offset, instruction, arg)?
+                    .ok_or(JitCompileError::BadBytecode)?;
+                let then_block = self.get_or_create_block(then_label);
                 let else_block = self.builder.create_block();
 
                 self.builder
@@ -645,7 +724,7 @@ impl<'a, 'b> FunctionCompiler<'a, 'b> {
                 self.stack.pop();
                 Ok(())
             }
-            Instruction::Resume { arg: _resume_arg } => {
+            Instruction::Resume { .. } => {
                 // TODO: Implement the resume instruction
                 Ok(())
             }
@@ -653,11 +732,33 @@ impl<'a, 'b> FunctionCompiler<'a, 'b> {
                 let val = self.stack.pop().ok_or(JitCompileError::BadBytecode)?;
                 self.return_value(val)
             }
-            Instruction::StoreFast(idx) => {
+            Instruction::StoreFast { var_num } => {
+                let val = self.stack.pop().ok_or(JitCompileError::BadBytecode)?;
+                self.store_variable(var_num.get(arg), val)
+            }
+            Instruction::StoreFastLoadFast { var_nums } => {
+                let oparg = var_nums.get(arg);
+                let (store_idx, load_idx) = oparg.indexes();
                 let val = self.stack.pop().ok_or(JitCompileError::BadBytecode)?;
-                self.store_variable(idx.get(arg), val)
+                self.store_variable(store_idx, val)?;
+                let local = self.variables[load_idx]
+                    .as_ref()
+                    .ok_or(JitCompileError::BadBytecode)?;
+                self.stack.push(JitValue::from_type_and_value(
+                    local.ty.clone(),
+                    self.builder.use_var(local.var),
+                ));
+                Ok(())
+            }
+            Instruction::StoreFastStoreFast { var_nums } => {
+                let oparg = var_nums.get(arg);
+                let (idx1, idx2) = oparg.indexes();
+                let val1 = self.stack.pop().ok_or(JitCompileError::BadBytecode)?;
+                self.store_variable(idx1, val1)?;
+                let val2 = self.stack.pop().ok_or(JitCompileError::BadBytecode)?;
+                self.store_variable(idx2, val2)
             }
-            Instruction::Swap { index } => {
+            Instruction::Swap { i: index } => {
                 let len = self.stack.len();
                 let i = len - 1;
                 let j = len - 1 - index.get(arg) as usize;
@@ -691,7 +792,7 @@ impl<'a, 'b> FunctionCompiler<'a, 'b> {
                     _ => Err(JitCompileError::NotSupported),
                 }
             }
-            Instruction::UnpackSequence { size } => {
+            Instruction::UnpackSequence { count } => {
                 let val = self.stack.pop().ok_or(JitCompileError::BadBytecode)?;
 
                 let elements = match val {
@@ -699,7 +800,7 @@ impl<'a, 'b> FunctionCompiler<'a, 'b> {
                     _ => return Err(JitCompileError::NotSupported),
                 };
 
-                if elements.len() != size.get(arg) as usize {
+                if elements.len() != count.get(arg) as usize {
                     return Err(JitCompileError::NotSupported);
                 }
 
diff --git a/crates/jit/tests/common.rs b/crates/jit/tests/common.rs
index a862d9eef69..349b3b6f39c 100644
--- a/crates/jit/tests/common.rs
+++ b/crates/jit/tests/common.rs
@@ -1,6 +1,6 @@
 use core::ops::ControlFlow;
 use rustpython_compiler_core::bytecode::{
-    CodeObject, ConstantData, Instruction, OpArg, OpArgState,
+    CodeObject, ConstantData, Constants, Instruction, OpArg, OpArgState,
 };
 use rustpython_jit::{CompiledCode, JitType};
 use rustpython_wtf8::{Wtf8, Wtf8Buf};
@@ -42,6 +42,7 @@ impl Function {
     }
 }
 
+#[allow(dead_code)]
 #[derive(Debug, Clone)]
 enum StackValue {
     String(String),
@@ -49,6 +50,8 @@ enum StackValue {
     Map(HashMap<Wtf8Buf, StackValue>),
     Code(Box<CodeObject>),
     Function(Function),
+    Slice(Box<[StackValue; 3]>),
+    Frozenset(Vec<StackValue>),
 }
 
 impl From<ConstantData> for StackValue {
@@ -59,6 +62,13 @@ impl From<ConstantData> for StackValue {
             }
             ConstantData::None => StackValue::None,
             ConstantData::Code { code } => StackValue::Code(code),
+            ConstantData::Slice { elements } => {
+                let [start, stop, step] = *elements;
+                StackValue::Slice(Box::new([start.into(), stop.into(), step.into()]))
+            }
+            ConstantData::Frozenset { elements } => {
+                StackValue::Frozenset(elements.into_iter().map(Into::into).collect())
+            }
             c => unimplemented!("constant {:?} isn't yet supported in py_function!", c),
         }
     }
@@ -76,14 +86,17 @@ fn extract_annotations_from_annotate_code(code: &CodeObject) -> HashMap<Wtf8Buf,
         let (instruction, arg) = op_arg_state.get(word);
 
         match instruction {
-            Instruction::LoadConst { idx } => {
-                stack.push((true, idx.get(arg) as usize));
+            Instruction::LoadConst { consti } => {
+                stack.push((true, consti.get(arg).as_usize()));
+            }
+            Instruction::LoadName { namei } => {
+                stack.push((false, namei.get(arg) as usize));
             }
-            Instruction::LoadName(idx) | Instruction::LoadGlobal(idx) => {
-                stack.push((false, idx.get(arg) as usize));
+            Instruction::LoadGlobal { namei } => {
+                stack.push((false, (namei.get(arg) >> 1) as usize));
             }
-            Instruction::BuildMap { size, .. } => {
-                let count = size.get(arg) as usize;
+            Instruction::BuildMap { count } => {
+                let count = count.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);
@@ -96,7 +109,8 @@ fn extract_annotations_from_annotate_code(code: &CodeObject) -> HashMap<Wtf8Buf,
 
                         // Key should be a const string (parameter name)
                         if key_is_const
-                            && let ConstantData::Str { value } = &code.constants[key_idx]
+                            && let ConstantData::Str { value } =
+                                &code.constants[(key_idx as u32).into()]
                         {
                             let param_name = value;
                             // Value can be a name (type ref) or a const string (forward ref)
@@ -136,9 +150,11 @@ fn extract_annotations_from_annotate_code(code: &CodeObject) -> HashMap<Wtf8Buf,
                 return annotations;
             }
             Instruction::Resume { .. }
-            | Instruction::LoadFast(_)
+            | Instruction::LoadFast { .. }
             | Instruction::CompareOp { .. }
-            | Instruction::ExtendedArg => {
+            | Instruction::ExtendedArg
+            | Instruction::Cache
+            | Instruction::NotTaken => {
                 // Ignore these instructions for annotation extraction
             }
             Instruction::ReturnValue => {
@@ -180,22 +196,21 @@ impl StackMachine {
         &mut self,
         instruction: Instruction,
         arg: OpArg,
-        constants: &[ConstantData],
+        constants: &Constants<ConstantData>,
         names: &[String],
     ) -> ControlFlow<()> {
         match instruction {
-            Instruction::Resume { .. } => {
-                // No-op for JIT tests - just marks function entry point
+            Instruction::Resume { .. } | Instruction::Cache | Instruction::NotTaken => {
+                // No-op for JIT tests
             }
-            Instruction::LoadConst { idx } => {
-                let idx = idx.get(arg);
-                self.stack.push(constants[idx as usize].clone().into())
+            Instruction::LoadConst { consti } => {
+                self.stack.push(constants[consti.get(arg)].clone().into())
             }
-            Instruction::LoadName(idx) => self
+            Instruction::LoadName { namei } => self
                 .stack
-                .push(StackValue::String(names[idx.get(arg) as usize].clone())),
-            Instruction::StoreName(idx) => {
-                let idx = idx.get(arg);
+                .push(StackValue::String(names[namei.get(arg) as usize].clone())),
+            Instruction::StoreName { namei } => {
+                let idx = namei.get(arg);
                 self.locals
                     .insert(names[idx as usize].clone(), self.stack.pop().unwrap());
             }
@@ -204,9 +219,9 @@ impl StackMachine {
                 self.stack.pop().unwrap();
                 self.stack.pop().unwrap();
             }
-            Instruction::BuildMap { size, .. } => {
+            Instruction::BuildMap { count } => {
                 let mut map = HashMap::new();
-                for _ in 0..size.get(arg) {
+                for _ in 0..count.get(arg) {
                     let value = self.stack.pop().unwrap();
                     let name = if let Some(StackValue::String(name)) = self.stack.pop() {
                         Wtf8Buf::from(name)
@@ -229,7 +244,7 @@ impl StackMachine {
                     annotations: HashMap::new(), // empty annotations, will be set later if needed
                 }));
             }
-            Instruction::SetFunctionAttribute { attr } => {
+            Instruction::SetFunctionAttribute { flag } => {
                 // Stack: [..., attr_value, func] -> [..., func]
                 let func = if let Some(StackValue::Function(func)) = self.stack.pop() {
                     func
@@ -238,42 +253,40 @@ impl StackMachine {
                 };
                 let attr_value = self.stack.pop().expect("Expected attribute value on stack");
 
-                let flags = attr.get(arg);
+                let flag_value = flag.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);
+                match flag_value {
+                    rustpython_compiler_core::bytecode::MakeFunctionFlag::Annotate => {
+                        // Handle ANNOTATE flag (PEP 649 style - Python 3.14+)
+                        if let StackValue::Function(annotate_func) = attr_value {
+                            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");
+                            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 {
-                        let updated_func = Function {
-                            code: func.code,
-                            annotations,
-                        };
-                        self.stack.push(StackValue::Function(updated_func));
-                    } else {
-                        panic!("Expected annotations to be a map");
+                    rustpython_compiler_core::bytecode::MakeFunctionFlag::Annotations => {
+                        // Handle old ANNOTATIONS flag (Python 3.12 style)
+                        if let StackValue::Map(annotations) = attr_value {
+                            let updated_func = Function {
+                                code: func.code,
+                                annotations,
+                            };
+                            self.stack.push(StackValue::Function(updated_func));
+                        } else {
+                            panic!("Expected annotations to be a map");
+                        }
+                    }
+                    _ => {
+                        // For other attributes, just push the function back unchanged
+                        self.stack.push(StackValue::Function(func));
                     }
-                } else {
-                    // For other attributes, just push the function back unchanged
-                    self.stack.push(StackValue::Function(func));
                 }
             }
             Instruction::ReturnValue => return ControlFlow::Break(()),
diff --git a/crates/literal/Cargo.toml b/crates/literal/Cargo.toml
index bd6a2699742..3f0bec33c30 100644
--- a/crates/literal/Cargo.toml
+++ b/crates/literal/Cargo.toml
@@ -15,7 +15,7 @@ hexf-parse = "0.2.1"
 is-macro.workspace = true
 lexical-parse-float = { version = "1.0.6", features = ["format"] }
 num-traits = { workspace = true }
-unic-ucd-category = { workspace = true }
+icu_properties = { workspace = true }
 
 [dev-dependencies]
 rand = { workspace = true }
diff --git a/crates/literal/src/char.rs b/crates/literal/src/char.rs
index cd64f6dfa9e..5b446cc1a19 100644
--- a/crates/literal/src/char.rs
+++ b/crates/literal/src/char.rs
@@ -1,4 +1,4 @@
-use unic_ucd_category::GeneralCategory;
+use icu_properties::props::{EnumeratedProperty, GeneralCategory};
 
 /// According to python following categories aren't printable:
 /// * Cc (Other, Control)
@@ -10,6 +10,17 @@ use unic_ucd_category::GeneralCategory;
 /// * Zp Separator, Paragraph ('\u2029', PARAGRAPH SEPARATOR)
 /// * Zs (Separator, Space) other than ASCII space('\x20').
 pub fn is_printable(c: char) -> bool {
-    let cat = GeneralCategory::of(c);
-    !(cat.is_other() || cat.is_separator())
+    let cat = GeneralCategory::for_char(c);
+
+    !matches!(
+        cat,
+        GeneralCategory::SpaceSeparator
+            | GeneralCategory::LineSeparator
+            | GeneralCategory::ParagraphSeparator
+            | GeneralCategory::Control
+            | GeneralCategory::Format
+            | GeneralCategory::Surrogate
+            | GeneralCategory::PrivateUse
+            | GeneralCategory::Unassigned
+    )
 }
diff --git a/crates/literal/src/complex.rs b/crates/literal/src/complex.rs
index 076f2807c99..c91d1c1439e 100644
--- a/crates/literal/src/complex.rs
+++ b/crates/literal/src/complex.rs
@@ -1,4 +1,6 @@
 use crate::float;
+use alloc::borrow::ToOwned;
+use alloc::string::{String, ToString};
 
 /// Convert a complex number to a string.
 pub fn to_string(re: f64, im: f64) -> String {
diff --git a/crates/literal/src/escape.rs b/crates/literal/src/escape.rs
index 72ceaf60d5b..1099c0a02bc 100644
--- a/crates/literal/src/escape.rs
+++ b/crates/literal/src/escape.rs
@@ -1,3 +1,4 @@
+use alloc::string::String;
 use rustpython_wtf8::{CodePoint, Wtf8};
 
 #[derive(Debug, PartialEq, Eq, Copy, Clone, Hash, is_macro::Is)]
@@ -55,9 +56,9 @@ pub unsafe trait Escape {
     /// # Safety
     ///
     /// This string must only contain printable characters.
-    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 {
+    unsafe fn write_source(&self, formatter: &mut impl core::fmt::Write) -> core::fmt::Result;
+    fn write_body_slow(&self, formatter: &mut impl core::fmt::Write) -> core::fmt::Result;
+    fn write_body(&self, formatter: &mut impl core::fmt::Write) -> core::fmt::Result {
         if self.changed() {
             self.write_body_slow(formatter)
         } else {
@@ -117,7 +118,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) -> core::fmt::Result {
+    pub fn write(&self, formatter: &mut impl core::fmt::Write) -> core::fmt::Result {
         let quote = self.0.layout().quote.to_char();
         formatter.write_char(quote)?;
         self.0.write_body(formatter)?;
@@ -216,7 +217,7 @@ impl UnicodeEscape<'_> {
     fn write_char(
         ch: CodePoint,
         quote: Quote,
-        formatter: &mut impl std::fmt::Write,
+        formatter: &mut impl core::fmt::Write,
     ) -> core::fmt::Result {
         let Some(ch) = ch.to_char() else {
             return write!(formatter, "\\u{:04x}", ch.to_u32());
@@ -260,15 +261,15 @@ unsafe impl Escape for UnicodeEscape<'_> {
         &self.layout
     }
 
-    unsafe fn write_source(&self, formatter: &mut impl std::fmt::Write) -> core::fmt::Result {
+    unsafe fn write_source(&self, formatter: &mut impl core::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())
+            core::str::from_utf8_unchecked(self.source.as_bytes())
         })
     }
 
     #[cold]
-    fn write_body_slow(&self, formatter: &mut impl std::fmt::Write) -> core::fmt::Result {
+    fn write_body_slow(&self, formatter: &mut impl core::fmt::Write) -> core::fmt::Result {
         for ch in self.source.code_points() {
             Self::write_char(ch, self.layout().quote, formatter)?;
         }
@@ -378,7 +379,11 @@ impl AsciiEscape<'_> {
         }
     }
 
-    fn write_char(ch: u8, quote: Quote, formatter: &mut impl std::fmt::Write) -> core::fmt::Result {
+    fn write_char(
+        ch: u8,
+        quote: Quote,
+        formatter: &mut impl core::fmt::Write,
+    ) -> core::fmt::Result {
         match ch {
             b'\t' => formatter.write_str("\\t"),
             b'\n' => formatter.write_str("\\n"),
@@ -404,15 +409,15 @@ unsafe impl Escape for AsciiEscape<'_> {
         &self.layout
     }
 
-    unsafe fn write_source(&self, formatter: &mut impl std::fmt::Write) -> core::fmt::Result {
+    unsafe fn write_source(&self, formatter: &mut impl core::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)
+            core::str::from_utf8_unchecked(self.source)
         })
     }
 
     #[cold]
-    fn write_body_slow(&self, formatter: &mut impl std::fmt::Write) -> core::fmt::Result {
+    fn write_body_slow(&self, formatter: &mut impl core::fmt::Write) -> core::fmt::Result {
         for ch in self.source {
             Self::write_char(*ch, self.layout().quote, formatter)?;
         }
@@ -423,7 +428,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) -> core::fmt::Result {
+    pub fn write(&self, formatter: &mut impl core::fmt::Write) -> core::fmt::Result {
         let quote = self.0.layout().quote.to_char();
         formatter.write_char('b')?;
         formatter.write_char(quote)?;
diff --git a/crates/literal/src/float.rs b/crates/literal/src/float.rs
index 4d0d65cbb34..0fc51782438 100644
--- a/crates/literal/src/float.rs
+++ b/crates/literal/src/float.rs
@@ -1,6 +1,9 @@
 use crate::format::Case;
+use alloc::borrow::ToOwned;
+use alloc::format;
+use alloc::string::{String, ToString};
+use core::f64;
 use num_traits::{Float, Zero};
-use std::f64;
 
 pub fn parse_str(literal: &str) -> Option<f64> {
     parse_inner(literal.trim().as_bytes())
@@ -23,7 +26,7 @@ fn parse_inner(literal: &[u8]) -> Option<f64> {
 }
 
 pub fn is_integer(v: f64) -> bool {
-    (v - v.round()).abs() < f64::EPSILON
+    v.is_finite() && v.fract() == 0.0
 }
 
 fn format_nan(case: Case) -> String {
diff --git a/crates/literal/src/lib.rs b/crates/literal/src/lib.rs
index 29971070129..a863dd87738 100644
--- a/crates/literal/src/lib.rs
+++ b/crates/literal/src/lib.rs
@@ -1,3 +1,7 @@
+#![no_std]
+
+extern crate alloc;
+
 pub mod char;
 pub mod complex;
 pub mod escape;
diff --git a/crates/pylib/Cargo.toml b/crates/pylib/Cargo.toml
index dcbb5928599..0a9326640c1 100644
--- a/crates/pylib/Cargo.toml
+++ b/crates/pylib/Cargo.toml
@@ -2,7 +2,7 @@
 name = "rustpython-pylib"
 description = "A subset of the Python standard library for use with RustPython"
 license-file = "Lib/PSF-LICENSE"
-include = ["Cargo.toml", "src/**/*.rs", "Lib/", "!Lib/**/test/", "!Lib/**/*.pyc"]
+include = ["Cargo.toml", "build.rs", "src/**/*.rs", "Lib/", "!Lib/**/test/", "!Lib/**/*.pyc"]
 authors = ["CPython Developers"]
 version.workspace = true
 edition.workspace = true
diff --git a/crates/pylib/src/lib.rs b/crates/pylib/src/lib.rs
index f8a47ba67da..db957f633fc 100644
--- a/crates/pylib/src/lib.rs
+++ b/crates/pylib/src/lib.rs
@@ -2,6 +2,8 @@
 //! common way to use this crate is to just add the `"freeze-stdlib"` feature to `rustpython-vm`,
 //! in order to automatically include the python part of the standard library into the binary.
 
+#![no_std]
+
 // windows needs to read the symlink out of `Lib` as git turns it into a text file,
 // so build.rs sets this env var
 pub const LIB_PATH: &str = match option_env!("win_lib_path") {
@@ -11,4 +13,4 @@ pub const LIB_PATH: &str = match option_env!("win_lib_path") {
 
 #[cfg(feature = "freeze-stdlib")]
 pub const FROZEN_STDLIB: &rustpython_compiler_core::frozen::FrozenLib =
-    rustpython_derive::py_freeze!(dir = "./Lib", crate_name = "rustpython_compiler_core");
+    rustpython_derive::py_freeze!(dir = "../Lib", crate_name = "rustpython_compiler_core");
diff --git a/crates/sre_engine/src/engine.rs b/crates/sre_engine/src/engine.rs
index f1f25a2d920..73e263012fc 100644
--- a/crates/sre_engine/src/engine.rs
+++ b/crates/sre_engine/src/engine.rs
@@ -6,6 +6,7 @@ use crate::string::{
 };
 
 use super::{MAXREPEAT, SreAtCode, SreCatCode, SreInfo, SreOpcode, StrDrive, StringCursor};
+use alloc::{vec, vec::Vec};
 use core::{convert::TryFrom, ptr::null};
 use optional::Optioned;
 
@@ -283,8 +284,10 @@ fn _match<S: StrDrive>(req: &Request<'_, S>, state: &mut State, mut ctx: MatchCo
     let mut context_stack = vec![];
     let mut popped_result = false;
 
-    // NOTE: 'result loop is not an actual loop but break label
-    #[allow(clippy::never_loop)]
+    #[allow(
+        clippy::never_loop,
+        reason = "'result loop is not an actual loop but break label"
+    )]
     'coro: loop {
         popped_result = 'result: loop {
             let yielded = 'context: loop {
@@ -467,7 +470,10 @@ fn _match<S: StrDrive>(req: &Request<'_, S>, state: &mut State, mut ctx: MatchCo
                     Jump::PossessiveRepeat1 => {
                         let min_count = ctx.peek_code(req, 2) as isize;
                         if ctx.count < min_count {
-                            break 'context ctx.next_offset(4, Jump::PossessiveRepeat2);
+                            // modified next.toplevel from inherited to false
+                            let mut next = ctx.next_offset(4, Jump::PossessiveRepeat2);
+                            next.toplevel = false;
+                            break 'context next;
                         }
                         // zero match protection
                         ctx.cursor.position = usize::MAX;
@@ -491,7 +497,9 @@ fn _match<S: StrDrive>(req: &Request<'_, S>, state: &mut State, mut ctx: MatchCo
                         {
                             state.marks.push();
                             ctx.cursor = state.cursor;
-                            break 'context ctx.next_offset(4, Jump::PossessiveRepeat4);
+                            let mut next = ctx.next_offset(4, Jump::PossessiveRepeat4);
+                            next.toplevel = false; // modified next.toplevel from inherited to false
+                            break 'context next;
                         }
                         ctx.cursor = state.cursor;
                         ctx.skip_code_from(req, 1);
@@ -829,7 +837,9 @@ fn _match<S: StrDrive>(req: &Request<'_, S>, state: &mut State, mut ctx: MatchCo
                         /* <ATOMIC_GROUP> <skip> pattern <SUCCESS> tail */
                         SreOpcode::ATOMIC_GROUP => {
                             state.cursor = ctx.cursor;
-                            break 'context ctx.next_offset(2, Jump::AtomicGroup1);
+                            let mut next_ctx = ctx.next_offset(2, Jump::AtomicGroup1);
+                            next_ctx.toplevel = false; // modified next.toplevel from inherited to false
+                            break 'context next_ctx;
                         }
                         /* <POSSESSIVE_REPEAT> <skip> <1=min> <2=max> pattern
                         <SUCCESS> tail */
diff --git a/crates/sre_engine/src/lib.rs b/crates/sre_engine/src/lib.rs
index 08c21de9df8..df598974ba9 100644
--- a/crates/sre_engine/src/lib.rs
+++ b/crates/sre_engine/src/lib.rs
@@ -1,3 +1,7 @@
+#![no_std]
+
+extern crate alloc;
+
 pub mod constants;
 pub mod engine;
 pub mod string;
diff --git a/crates/sre_engine/tests/tests.rs b/crates/sre_engine/tests/tests.rs
index 72a11c55b13..795c9a05d42 100644
--- a/crates/sre_engine/tests/tests.rs
+++ b/crates/sre_engine/tests/tests.rs
@@ -145,6 +145,18 @@ fn test_possessive_quantifier() {
     assert!(state.py_match(&req));
 }
 
+#[test]
+fn test_possessive_repeat_fullmatch() {
+    // pattern p = re.compile("([0-9]++(?:\.[0-9]+)*+)", re.I   )
+    // [INFO, 4, 0, 1, 4294967295, MARK, 0, POSSESSIVE_REPEAT_ONE, 10, 1, MAXREPEAT, IN, 5, RANGE, 48, 57, FAILURE, SUCCESS, POSSESSIVE_REPEAT, 16, 0, MAXREPEAT, LITERAL, 46, REPEAT_ONE, 10, 1, MAXREPEAT, IN, 5, RANGE, 48, 57, FAILURE, SUCCESS, SUCCESS, MARK, 1, SUCCESS]
+    // START GENERATED by generate_tests.py
+    #[rustfmt::skip] let p = Pattern { pattern: "([0-9]++(?:\\.[0-9]+)*+)", code: &[14, 4, 0, 1, 4294967295, 17, 0, 29, 10, 1, 4294967295, 13, 5, 22, 48, 57, 0, 1, 28, 16, 0, 4294967295, 16, 46, 24, 10, 1, 4294967295, 13, 5, 22, 48, 57, 0, 1, 1, 17, 1, 1] };
+    // END GENERATED
+    let (mut req, mut state) = p.state("1.25.38");
+    req.match_all = true;
+    assert!(state.py_match(&req), "should match");
+}
+
 #[test]
 fn test_possessive_atomic_group() {
     // pattern p = re.compile('(?>x)++x')
diff --git a/crates/stdlib/Cargo.toml b/crates/stdlib/Cargo.toml
index 3770fc42644..f828507d6cf 100644
--- a/crates/stdlib/Cargo.toml
+++ b/crates/stdlib/Cargo.toml
@@ -11,7 +11,8 @@ license.workspace = true
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [features]
-default = ["compiler"]
+default = ["compiler", "host_env"]
+host_env = ["rustpython-vm/host_env"]
 compiler = ["rustpython-vm/compiler"]
 threading = ["rustpython-common/threading", "rustpython-vm/threading"]
 sqlite = ["dep:libsqlite3-sys"]
@@ -30,6 +31,11 @@ rustpython-derive = { workspace = true }
 rustpython-vm = { workspace = true, default-features = false, features = ["compiler"]}
 rustpython-common = { workspace = true }
 
+ruff_python_parser = { workspace = true }
+ruff_python_ast = { workspace = true }
+ruff_text_size = { workspace = true }
+ruff_source_file = { workspace = true }
+
 ahash = { workspace = true }
 ascii = { workspace = true }
 cfg-if = { workspace = true }
@@ -42,7 +48,6 @@ libc = { workspace = true }
 nix = { workspace = true }
 num-complex = { workspace = true }
 malachite-bigint = { workspace = true }
-num-integer = { workspace = true }
 num-traits = { workspace = true }
 num_enum = { workspace = true }
 parking_lot = { workspace = true }
@@ -57,35 +62,31 @@ xml = "1.2"
 
 # random
 rand_core = { workspace = true }
-mt19937 = "3.1"
+mt19937 = "<=3.2"  # upgrade it once rand is upgraded
 
 # Crypto:
-digest = "0.10.3"
+digest = "0.10.7"
 md-5 = "0.10.1"
 sha-1 = "0.10.0"
 sha2 = "0.10.2"
 sha3 = "0.10.1"
 blake2 = "0.10.4"
+hmac = "0.12"
+pbkdf2 = { version = "0.12", features = ["hmac"] }
+constant_time_eq = { workspace = true }
 
 ## unicode stuff
 unicode_names2 = { workspace = true }
-# TODO: use unic for this; needed for title case:
-# https://github.com/RustPython/RustPython/pull/832#discussion_r275428939
-unicode-casing = { workspace = true }
 # update version all at the same time
-unic-char-property = { workspace = true }
-unic-normal        = { workspace = true }
-unic-ucd-bidi      = { workspace = true }
-unic-ucd-category  = { workspace = true }
+icu_properties = { workspace = true }
+icu_normalizer = { workspace = true }
 unic-ucd-age       = { workspace = true }
-unic-ucd-ident     = { workspace = true }
 ucd = "0.1.1"
-unicode-bidi-mirroring = { workspace = true }
 
 # compression
 adler32 = "1.2.0"
 crc32fast = "1.3.2"
-flate2 = { version = "<=1.1.8", default-features = false, features = ["zlib-rs"] }
+flate2 = { version = "1.1.9", default-features = false, features = ["zlib-rs"] }
 libz-sys = { package = "libz-rs-sys", version = "0.5" }
 bzip2 = "0.6"
 
@@ -98,7 +99,7 @@ chrono.workspace = true
 # uuid
 [target.'cfg(not(any(target_os = "ios", target_os = "android", target_os = "windows", target_arch = "wasm32", target_os = "redox")))'.dependencies]
 mac_address = "1.1.3"
-uuid = { version = "1.19.0", features = ["v1"] }
+uuid = { version = "1.22.0", features = ["v1"] }
 
 [target.'cfg(all(unix, not(target_os = "redox"), not(target_os = "ios")))'.dependencies]
 termios = "0.3.3"
@@ -108,20 +109,20 @@ rustix = { workspace = true }
 
 # mmap + socket dependencies
 [target.'cfg(not(target_arch = "wasm32"))'.dependencies]
-memmap2 = "0.9.9"
+memmap2 = "0.9.10"
 page_size = "0.6"
 gethostname = "1.0.2"
-socket2 = { version = "0.6.0", features = ["all"] }
+socket2 = { version = "0.6.3", features = ["all"] }
 dns-lookup = "3.0"
 
 # OpenSSL dependencies (optional, for ssl-openssl feature)
-openssl = { version = "0.10.72", optional = true }
+openssl = { version = "0.10.76", optional = true }
 openssl-sys = { version = "0.9.110", optional = true }
 openssl-probe = { version = "0.2.1", optional = true }
 foreign-types-shared = { version = "0.1.1", optional = true }
 
 # Rustls dependencies (optional, for ssl-rustls feature)
-rustls = { version = "0.23.36", default-features = false, features = ["std", "tls12", "aws_lc_rs"], optional = true }
+rustls = { version = "0.23.37", 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 }
@@ -130,14 +131,14 @@ 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.15.2", optional = true }
+aws-lc-rs = { version = "1.16.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 }
 
 [target.'cfg(not(any(target_os = "android", target_arch = "wasm32")))'.dependencies]
-libsqlite3-sys = { version = "0.36", features = ["bundled"], optional = true }
-lzma-sys = "0.1"
-xz2 = "0.1"
+libsqlite3-sys = { version = "0.37", features = ["bundled"], optional = true }
+liblzma = "0.4"
+liblzma-sys = "0.4"
 
 [target.'cfg(windows)'.dependencies]
 paste = { workspace = true }
@@ -155,7 +156,9 @@ features = [
   "Win32_Storage_FileSystem",
   "Win32_System_Diagnostics_Debug",
   "Win32_System_Environment",
+  "Win32_System_Console",
   "Win32_System_IO",
+  "Win32_System_Memory",
   "Win32_System_Threading"
 ]
 
diff --git a/crates/stdlib/build.rs b/crates/stdlib/build.rs
index 83ebd81ead6..95c34c4fb3c 100644
--- a/crates/stdlib/build.rs
+++ b/crates/stdlib/build.rs
@@ -4,7 +4,10 @@ fn main() {
     println!(r#"cargo::rustc-check-cfg=cfg(osslconf, values("OPENSSL_NO_COMP"))"#);
     println!(r#"cargo::rustc-check-cfg=cfg(openssl_vendored)"#);
 
-    #[allow(clippy::unusual_byte_groupings)]
+    #[allow(
+        clippy::unusual_byte_groupings,
+        reason = "hex groups follow OpenSSL version field boundaries"
+    )]
     let ossl_vers = [
         (0x1_00_01_00_0, "ossl101"),
         (0x1_00_02_00_0, "ossl102"),
@@ -25,7 +28,10 @@ fn main() {
 
     #[cfg(feature = "ssl-openssl")]
     {
-        #[allow(clippy::unusual_byte_groupings)]
+        #[allow(
+            clippy::unusual_byte_groupings,
+            reason = "OpenSSL version number is parsed with grouped hex fields"
+        )]
         if let Ok(v) = std::env::var("DEP_OPENSSL_VERSION_NUMBER") {
             println!("cargo:rustc-env=OPENSSL_API_VERSION={v}");
             // cfg setup from openssl crate's build script
diff --git a/crates/stdlib/src/_asyncio.rs b/crates/stdlib/src/_asyncio.rs
index 7e8ae5292e2..afa372cffe6 100644
--- a/crates/stdlib/src/_asyncio.rs
+++ b/crates/stdlib/src/_asyncio.rs
@@ -6,6 +6,7 @@ pub(crate) use _asyncio::module_def;
 
 #[pymodule]
 pub(crate) mod _asyncio {
+    use crate::common::wtf8::{Wtf8Buf, wtf8_concat};
     use crate::{
         common::lock::PyRwLock,
         vm::{
@@ -17,6 +18,7 @@ pub(crate) mod _asyncio {
             extend_module,
             function::{FuncArgs, KwArgs, OptionalArg, OptionalOption, PySetterValue},
             protocol::PyIterReturn,
+            recursion::ReprGuard,
             types::{
                 Callable, Constructor, Destructor, Initializer, IterNext, Iterable, Representable,
                 SelfIter,
@@ -24,8 +26,8 @@ pub(crate) mod _asyncio {
             warn,
         },
     };
+    use core::sync::atomic::{AtomicBool, AtomicI32, AtomicU64, Ordering};
     use crossbeam_utils::atomic::AtomicCell;
-    use std::sync::atomic::{AtomicBool, AtomicI32, AtomicU64, Ordering};
 
     pub(crate) fn module_exec(vm: &VirtualMachine, module: &Py<PyModule>) -> PyResult<()> {
         __module_exec(vm, module);
@@ -45,6 +47,15 @@ pub(crate) mod _asyncio {
             "_current_tasks" => current_tasks,
         });
 
+        // Register fork handler to clear task state in child process
+        #[cfg(unix)]
+        {
+            let on_fork = vm
+                .get_attribute_opt(module.to_owned().into(), vm.ctx.intern_str("_on_fork"))?
+                .expect("_on_fork not found in _asyncio module");
+            vm.state.after_forkers_child.lock().push(on_fork);
+        }
+
         Ok(())
     }
 
@@ -140,7 +151,7 @@ pub(crate) mod _asyncio {
         fn init(zelf: PyRef<Self>, args: Self::Args, vm: &VirtualMachine) -> PyResult<()> {
             // Future does not accept positional arguments
             if !args.args.is_empty() {
-                return Err(vm.new_type_error("Future() takes no positional arguments".to_string()));
+                return Err(vm.new_type_error("Future() takes no positional arguments"));
             }
             // Extract only 'loop' keyword argument
             let loop_ = args.kwargs.get("loop").cloned();
@@ -149,7 +160,7 @@ pub(crate) mod _asyncio {
     }
 
     #[pyclass(
-        flags(BASETYPE, HAS_DICT),
+        flags(BASETYPE, HAS_DICT, HAS_WEAKREF),
         with(Constructor, Initializer, Destructor, Representable, Iterable)
     )]
     impl PyFuture {
@@ -254,7 +265,7 @@ pub(crate) mod _asyncio {
         #[pymethod]
         fn set_result(zelf: PyRef<Self>, result: PyObjectRef, vm: &VirtualMachine) -> PyResult<()> {
             if zelf.fut_loop.read().is_none() {
-                return Err(vm.new_runtime_error("Future object is not initialized.".to_string()));
+                return Err(vm.new_runtime_error("Future object is not initialized."));
             }
             if zelf.fut_state.load() != FutureState::Pending {
                 return Err(new_invalid_state_error(vm, "invalid state"));
@@ -272,7 +283,7 @@ pub(crate) mod _asyncio {
             vm: &VirtualMachine,
         ) -> PyResult<()> {
             if zelf.fut_loop.read().is_none() {
-                return Err(vm.new_runtime_error("Future object is not initialized.".to_string()));
+                return Err(vm.new_runtime_error("Future object is not initialized."));
             }
             if zelf.fut_state.load() != FutureState::Pending {
                 return Err(new_invalid_state_error(vm, "invalid state"));
@@ -325,7 +336,7 @@ pub(crate) mod _asyncio {
             vm: &VirtualMachine,
         ) -> PyResult<()> {
             if zelf.fut_loop.read().is_none() {
-                return Err(vm.new_runtime_error("Future object is not initialized.".to_string()));
+                return Err(vm.new_runtime_error("Future object is not initialized."));
             }
             let ctx = match args.context.flatten() {
                 Some(c) => c,
@@ -353,7 +364,7 @@ pub(crate) mod _asyncio {
         #[pymethod]
         fn remove_done_callback(&self, func: PyObjectRef, vm: &VirtualMachine) -> PyResult<usize> {
             if self.fut_loop.read().is_none() {
-                return Err(vm.new_runtime_error("Future object is not initialized.".to_string()));
+                return Err(vm.new_runtime_error("Future object is not initialized."));
             }
             let mut cleared_callback0 = 0usize;
 
@@ -450,7 +461,7 @@ pub(crate) mod _asyncio {
         #[pymethod]
         fn cancel(zelf: PyRef<Self>, args: CancelArgs, vm: &VirtualMachine) -> PyResult<bool> {
             if zelf.fut_loop.read().is_none() {
-                return Err(vm.new_runtime_error("Future object is not initialized.".to_string()));
+                return Err(vm.new_runtime_error("Future object is not initialized."));
             }
             if zelf.fut_state.load() != FutureState::Pending {
                 // Clear log_tb even when cancel fails
@@ -488,7 +499,8 @@ pub(crate) mod _asyncio {
         }
 
         fn make_cancelled_error_impl(&self, vm: &VirtualMachine) -> PyBaseExceptionRef {
-            if let Some(exc) = self.fut_cancelled_exc.read().clone()
+            // If a saved CancelledError exists, take it (clearing the stored reference)
+            if let Some(exc) = self.fut_cancelled_exc.write().take()
                 && let Ok(exc) = exc.downcast::<PyBaseException>()
             {
                 return exc;
@@ -497,12 +509,10 @@ pub(crate) mod _asyncio {
             let msg = self.fut_cancel_msg.read().clone();
             let args = if let Some(m) = msg { vec![m] } else { vec![] };
 
-            let exc = match get_cancelled_error_type(vm) {
+            match get_cancelled_error_type(vm) {
                 Ok(cancelled_error) => vm.new_exception(cancelled_error, args),
                 Err(_) => vm.new_runtime_error("cancelled"),
-            };
-            *self.fut_cancelled_exc.write() = Some(exc.clone().into());
-            exc
+            }
         }
 
         fn schedule_callbacks(zelf: &PyRef<Self>, vm: &VirtualMachine) -> PyResult<()> {
@@ -587,9 +597,7 @@ pub(crate) mod _asyncio {
                     self.fut_blocking.store(v, Ordering::Relaxed);
                     Ok(())
                 }
-                PySetterValue::Delete => {
-                    Err(vm.new_attribute_error("cannot delete attribute".to_string()))
-                }
+                PySetterValue::Delete => Err(vm.new_attribute_error("cannot delete attribute")),
             }
         }
 
@@ -659,16 +667,12 @@ pub(crate) mod _asyncio {
             match value {
                 PySetterValue::Assign(v) => {
                     if v {
-                        return Err(vm.new_value_error(
-                            "_log_traceback can only be set to False".to_string(),
-                        ));
+                        return Err(vm.new_value_error("_log_traceback can only be set to False"));
                     }
                     self.fut_log_tb.store(false, Ordering::Relaxed);
                     Ok(())
                 }
-                PySetterValue::Delete => {
-                    Err(vm.new_attribute_error("cannot delete attribute".to_string()))
-                }
+                PySetterValue::Delete => Err(vm.new_attribute_error("cannot delete attribute")),
             }
         }
 
@@ -760,11 +764,6 @@ pub(crate) mod _asyncio {
             Ok(())
         }
 
-        #[pymethod]
-        fn __iter__(zelf: PyRef<Self>, vm: &VirtualMachine) -> PyResult<PyFutureIter> {
-            Self::__await__(zelf, vm)
-        }
-
         #[pymethod]
         fn __await__(zelf: PyRef<Self>, _vm: &VirtualMachine) -> PyResult<PyFutureIter> {
             Ok(PyFutureIter {
@@ -830,9 +829,13 @@ pub(crate) mod _asyncio {
 
     impl Representable for PyFuture {
         fn repr_str(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<String> {
-            let info = get_future_repr_info(zelf.as_object(), vm)?;
             let class_name = zelf.class().name().to_string();
-            Ok(format!("<{} {}>", class_name, info))
+            if let Some(_guard) = ReprGuard::enter(vm, zelf.as_object()) {
+                let info = get_future_repr_info(zelf.as_object(), vm)?;
+                Ok(format!("<{} {}>", class_name, info))
+            } else {
+                Ok(format!("<{} ...>", class_name))
+            }
         }
     }
 
@@ -845,7 +848,7 @@ pub(crate) mod _asyncio {
         }
     }
 
-    fn get_future_repr_info(future: &PyObject, vm: &VirtualMachine) -> PyResult<String> {
+    fn get_future_repr_info(future: &PyObject, vm: &VirtualMachine) -> PyResult<Wtf8Buf> {
         // Try to use asyncio.base_futures._future_repr_info
         // Import from sys.modules if available, otherwise try regular import
         let sys_modules = vm.sys_module.get_attr("modules", vm)?;
@@ -878,29 +881,34 @@ pub(crate) mod _asyncio {
             Err(_) => return get_future_repr_info_fallback(future, vm),
         };
 
-        let parts: Vec<String> = list
-            .borrow_vec()
-            .iter()
-            .filter_map(|x: &PyObjectRef| x.str(vm).ok().map(|s| s.as_str().to_string()))
-            .collect();
-        Ok(parts.join(" "))
+        let mut result = Wtf8Buf::new();
+        let parts = list.borrow_vec();
+        for (i, x) in parts.iter().enumerate() {
+            if i > 0 {
+                result.push_str(" ");
+            }
+            if let Ok(s) = x.str(vm) {
+                result.push_wtf8(s.as_wtf8());
+            }
+        }
+        Ok(result)
     }
 
-    fn get_future_repr_info_fallback(future: &PyObject, vm: &VirtualMachine) -> PyResult<String> {
+    fn get_future_repr_info_fallback(future: &PyObject, vm: &VirtualMachine) -> PyResult<Wtf8Buf> {
         // Fallback: build repr from properties directly
         if let Ok(Some(state)) =
             vm.get_attribute_opt(future.to_owned(), vm.ctx.intern_str("_state"))
         {
-            let state_str = state
+            let s = state
                 .str(vm)
-                .map(|s| s.as_str().to_lowercase())
-                .unwrap_or_else(|_| "unknown".to_string());
-            return Ok(state_str);
+                .map(|s| s.as_wtf8().to_lowercase())
+                .unwrap_or_else(|_| Wtf8Buf::from("unknown"));
+            return Ok(s);
         }
-        Ok("state=unknown".to_string())
+        Ok(Wtf8Buf::from("state=unknown"))
     }
 
-    fn get_task_repr_info(task: &PyObject, vm: &VirtualMachine) -> PyResult<String> {
+    fn get_task_repr_info(task: &PyObject, vm: &VirtualMachine) -> PyResult<Wtf8Buf> {
         // vm.import returns the top-level module, get base_tasks submodule
         match vm
             .import("asyncio.base_tasks", 0)
@@ -913,12 +921,15 @@ pub(crate) mod _asyncio {
                         let list: PyListRef = info.downcast().map_err(|_| {
                             vm.new_type_error("_task_repr_info should return a list")
                         })?;
-                        let parts: Vec<String> = list
-                            .borrow_vec()
-                            .iter()
-                            .map(|x: &PyObjectRef| x.str(vm).map(|s| s.as_str().to_string()))
-                            .collect::<PyResult<Vec<_>>>()?;
-                        Ok(parts.join(" "))
+                        let mut result = Wtf8Buf::new();
+                        let parts = list.borrow_vec();
+                        for (i, x) in parts.iter().enumerate() {
+                            if i > 0 {
+                                result.push_str(" ");
+                            }
+                            result.push_wtf8(x.str(vm)?.as_wtf8());
+                        }
+                        Ok(result)
                     }
                     _ => get_future_repr_info(task, vm),
                 }
@@ -1000,10 +1011,12 @@ pub(crate) mod _asyncio {
             // Warn about deprecated (type, val, tb) signature
             if exc_val.is_present() || exc_tb.is_present() {
                 warn::warn(
-                    vm.ctx.new_str(
-                        "the (type, val, tb) signature of throw() is deprecated, \
+                    vm.ctx
+                        .new_str(
+                            "the (type, val, tb) signature of throw() is deprecated, \
                          use throw(val) instead",
-                    ),
+                        )
+                        .into(),
                     Some(vm.ctx.exceptions.deprecation_warning.to_owned()),
                     1,
                     None,
@@ -1030,7 +1043,7 @@ pub(crate) mod _asyncio {
                 // Must be a subclass of BaseException
                 if !exc_class.fast_issubclass(vm.ctx.exceptions.base_exception_type) {
                     return Err(vm.new_type_error(
-                        "exceptions must be classes or instances deriving from BaseException, not type".to_string()
+                        "exceptions must be classes or instances deriving from BaseException, not type"
                     ));
                 }
 
@@ -1047,9 +1060,9 @@ pub(crate) mod _asyncio {
                 if let OptionalArg::Present(ref val) = exc_val
                     && !vm.is_none(val)
                 {
-                    return Err(vm.new_type_error(
-                        "instance exception may not have a separate value".to_string(),
-                    ));
+                    return Err(
+                        vm.new_type_error("instance exception may not have a separate value")
+                    );
                 }
                 exc_type
             } else {
@@ -1144,7 +1157,7 @@ pub(crate) mod _asyncio {
     }
 
     #[pyclass(
-        flags(BASETYPE, HAS_DICT),
+        flags(BASETYPE, HAS_DICT, HAS_WEAKREF),
         with(Constructor, Initializer, Destructor, Representable, Iterable)
     )]
     impl PyTask {
@@ -1290,7 +1303,8 @@ pub(crate) mod _asyncio {
         }
 
         fn make_cancelled_error_impl(&self, vm: &VirtualMachine) -> PyBaseExceptionRef {
-            if let Some(exc) = self.base.fut_cancelled_exc.read().clone()
+            // If a saved CancelledError exists, take it (clearing the stored reference)
+            if let Some(exc) = self.base.fut_cancelled_exc.write().take()
                 && let Ok(exc) = exc.downcast::<PyBaseException>()
             {
                 return exc;
@@ -1299,12 +1313,10 @@ pub(crate) mod _asyncio {
             let msg = self.base.fut_cancel_msg.read().clone();
             let args = if let Some(m) = msg { vec![m] } else { vec![] };
 
-            let exc = match get_cancelled_error_type(vm) {
+            match get_cancelled_error_type(vm) {
                 Ok(cancelled_error) => vm.new_exception(cancelled_error, args),
                 Err(_) => vm.new_runtime_error("cancelled"),
-            };
-            *self.base.fut_cancelled_exc.write() = Some(exc.clone().into());
-            exc
+            }
         }
 
         #[pymethod]
@@ -1314,7 +1326,7 @@ pub(crate) mod _asyncio {
             vm: &VirtualMachine,
         ) -> PyResult<()> {
             if zelf.base.fut_loop.read().is_none() {
-                return Err(vm.new_runtime_error("Future object is not initialized.".to_string()));
+                return Err(vm.new_runtime_error("Future object is not initialized."));
             }
             let ctx = match args.context.flatten() {
                 Some(c) => c,
@@ -1342,7 +1354,7 @@ pub(crate) mod _asyncio {
         #[pymethod]
         fn remove_done_callback(&self, func: PyObjectRef, vm: &VirtualMachine) -> PyResult<usize> {
             if self.base.fut_loop.read().is_none() {
-                return Err(vm.new_runtime_error("Future object is not initialized.".to_string()));
+                return Err(vm.new_runtime_error("Future object is not initialized."));
             }
             let mut cleared_callback0 = 0usize;
 
@@ -1661,9 +1673,7 @@ pub(crate) mod _asyncio {
                     self.base.fut_blocking.store(v, Ordering::Relaxed);
                     Ok(())
                 }
-                PySetterValue::Delete => {
-                    Err(vm.new_attribute_error("cannot delete attribute".to_string()))
-                }
+                PySetterValue::Delete => Err(vm.new_attribute_error("cannot delete attribute")),
             }
         }
 
@@ -1693,7 +1703,7 @@ pub(crate) mod _asyncio {
                     Ok(())
                 }
                 PySetterValue::Delete => {
-                    Err(vm.new_attribute_error("can't delete _log_destroy_pending".to_owned()))
+                    Err(vm.new_attribute_error("can't delete _log_destroy_pending"))
                 }
             }
         }
@@ -1712,16 +1722,12 @@ pub(crate) mod _asyncio {
             match value {
                 PySetterValue::Assign(v) => {
                     if v {
-                        return Err(vm.new_value_error(
-                            "_log_traceback can only be set to False".to_string(),
-                        ));
+                        return Err(vm.new_value_error("_log_traceback can only be set to False"));
                     }
                     self.base.fut_log_tb.store(false, Ordering::Relaxed);
                     Ok(())
                 }
-                PySetterValue::Delete => {
-                    Err(vm.new_attribute_error("cannot delete attribute".to_string()))
-                }
+                PySetterValue::Delete => Err(vm.new_attribute_error("cannot delete attribute")),
             }
         }
 
@@ -1817,13 +1823,6 @@ pub(crate) mod _asyncio {
             }
         }
 
-        #[pymethod]
-        fn __iter__(zelf: PyRef<Self>, _vm: &VirtualMachine) -> PyResult<PyFutureIter> {
-            Ok(PyFutureIter {
-                future: PyRwLock::new(Some(zelf.into())),
-            })
-        }
-
         #[pymethod]
         fn __await__(zelf: PyRef<Self>, _vm: &VirtualMachine) -> PyResult<PyFutureIter> {
             Ok(PyFutureIter {
@@ -1912,37 +1911,29 @@ pub(crate) mod _asyncio {
     }
 
     impl Representable for PyTask {
-        fn repr_str(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<String> {
+        fn repr_wtf8(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<Wtf8Buf> {
             let class_name = zelf.class().name().to_string();
 
-            // Try to use _task_repr_info if available
-            if let Ok(info) = get_task_repr_info(zelf.as_object(), vm)
-                && info != "state=unknown"
-            {
-                return Ok(format!("<{} {}>", class_name, info));
-            }
-
-            // Fallback: build repr from task properties directly
-            let state = zelf.base.fut_state.load().as_str().to_lowercase();
-            let name = zelf
-                .task_name
-                .read()
-                .as_ref()
-                .and_then(|n| n.str(vm).ok())
-                .map(|s| s.as_str().to_string())
-                .unwrap_or_else(|| "?".to_string());
-            let coro_repr = zelf
-                .task_coro
-                .read()
-                .as_ref()
-                .and_then(|c| c.repr(vm).ok())
-                .map(|s| s.as_str().to_string())
-                .unwrap_or_else(|| "?".to_string());
+            if let Some(_guard) = ReprGuard::enter(vm, zelf.as_object()) {
+                // Try to use _task_repr_info if available
+                if let Ok(info) = get_task_repr_info(zelf.as_object(), vm)
+                    && info.as_bytes() != b"state=unknown"
+                {
+                    return Ok(wtf8_concat!("<", class_name, " ", info, ">"));
+                }
 
-            Ok(format!(
-                "<{} {} name='{}' coro={}>",
-                class_name, state, name, coro_repr
-            ))
+                // Fallback: build repr from task properties directly
+                let state = zelf.base.fut_state.load().as_str().to_lowercase();
+                let name = zelf.task_name.read().as_ref().and_then(|n| n.str(vm).ok());
+                let coro_repr = zelf.task_coro.read().as_ref().and_then(|c| c.repr(vm).ok());
+                let name = name.as_ref().map_or("?".as_ref(), |s| s.as_wtf8());
+                let coro_repr = coro_repr.as_ref().map_or("?".as_ref(), |s| s.as_wtf8());
+                Ok(wtf8_concat!(
+                    "<", class_name, " ", state, " name='", name, "' coro=", coro_repr, ">"
+                ))
+            } else {
+                Ok(Wtf8Buf::from(format!("<{class_name} ...>")))
+            }
         }
     }
 
@@ -2131,10 +2122,8 @@ pub(crate) mod _asyncio {
         // Check if task awaits on itself
         let task_obj: PyObjectRef = task.clone().into();
         if result.is(&task_obj) {
-            let msg = format!(
-                "Task cannot await on itself: {}",
-                task_obj.repr(vm)?.as_str()
-            );
+            let task_repr = task_obj.repr(vm)?;
+            let msg = format!("Task cannot await on itself: {}", task_repr.as_wtf8());
             task.base.fut_state.store(FutureState::Finished);
             *task.base.fut_exception.write() = Some(vm.new_runtime_error(msg).into());
             PyTask::schedule_callbacks(task, vm)?;
@@ -2203,9 +2192,12 @@ pub(crate) mod _asyncio {
             *task.task_fut_waiter.write() = Some(result.clone());
 
             let task_obj: PyObjectRef = task.clone().into();
-            let wakeup_wrapper = TaskWakeupMethWrapper::new(task_obj).into_ref(&vm.ctx);
+            let wakeup_wrapper = TaskWakeupMethWrapper::new(task_obj.clone()).into_ref(&vm.ctx);
             vm.call_method(&result, "add_done_callback", (wakeup_wrapper,))?;
 
+            // Track awaited_by relationship for introspection
+            future_add_to_awaited_by(result.clone(), task_obj, vm)?;
+
             // If task_must_cancel is set, cancel the awaited future immediately
             // This propagates the cancellation through the future chain
             if task.task_must_cancel.load(Ordering::Relaxed) {
@@ -2231,7 +2223,8 @@ pub(crate) mod _asyncio {
                 vm.call_method(&loop_obj, "call_soon", (step_wrapper,))?;
             }
         } else {
-            let msg = format!("Task got bad yield: {}", result.repr(vm)?.as_str());
+            let result_repr = result.repr(vm)?;
+            let msg = format!("Task got bad yield: {}", result_repr.as_wtf8());
             task.base.fut_state.store(FutureState::Finished);
             *task.base.fut_exception.write() = Some(vm.new_runtime_error(msg).into());
             PyTask::schedule_callbacks(task, vm)?;
@@ -2295,6 +2288,9 @@ pub(crate) mod _asyncio {
             .downcast()
             .map_err(|_| vm.new_type_error("task_wakeup called with non-Task object"))?;
 
+        // Remove awaited_by relationship before resuming
+        future_discard_from_awaited_by(fut.clone(), task.clone(), vm)?;
+
         *task_ref.task_fut_waiter.write() = None;
 
         // Call result() on the awaited future to get either result or exception
@@ -2376,7 +2372,6 @@ pub(crate) mod _asyncio {
             Some(l) if !vm.is_none(&l) => l,
             _ => {
                 // When loop is None or not provided, use the running loop
-                // and raise an error if there's no running loop
                 match vm.asyncio_running_loop.borrow().clone() {
                     Some(l) => l,
                     None => return Err(vm.new_runtime_error("no running event loop")),
@@ -2384,6 +2379,23 @@ pub(crate) mod _asyncio {
             }
         };
 
+        // Fast path: if the loop is the current thread's running loop,
+        // return the per-thread running task directly
+        let is_current_loop = vm
+            .asyncio_running_loop
+            .borrow()
+            .as_ref()
+            .is_some_and(|rl| rl.is(&loop_obj));
+
+        if is_current_loop {
+            return Ok(vm
+                .asyncio_running_task
+                .borrow()
+                .clone()
+                .unwrap_or_else(|| vm.ctx.none()));
+        }
+
+        // Slow path: look up in the module-level dict for cross-thread queries
         let current_tasks = get_current_tasks_dict(vm)?;
         let dict: PyDictRef = current_tasks.downcast().unwrap();
 
@@ -2464,89 +2476,112 @@ pub(crate) mod _asyncio {
 
     #[pyfunction]
     fn _enter_task(loop_: PyObjectRef, task: PyObjectRef, vm: &VirtualMachine) -> PyResult<()> {
-        let current_tasks = get_current_tasks_dict(vm)?;
-        let dict: PyDictRef = current_tasks.downcast().unwrap();
-
-        if dict.contains_key(&*loop_, vm) {
-            return Err(
-                vm.new_runtime_error("Cannot enter task while another task is already running")
-            );
+        // Per-thread check, matching CPython's ts->asyncio_running_task
+        {
+            let running_task = vm.asyncio_running_task.borrow();
+            if running_task.is_some() {
+                return Err(vm.new_runtime_error(format!(
+                    "Cannot enter into task {:?} while another task {:?} is being executed.",
+                    task,
+                    running_task.as_ref().unwrap()
+                )));
+            }
         }
 
-        dict.set_item(&*loop_, task, vm)?;
+        *vm.asyncio_running_task.borrow_mut() = Some(task.clone());
+
+        // Also update the module-level dict for cross-thread queries
+        if let Ok(current_tasks) = get_current_tasks_dict(vm)
+            && let Ok(dict) = current_tasks.downcast::<rustpython_vm::builtins::PyDict>()
+        {
+            let _ = dict.set_item(&*loop_, task, vm);
+        }
         Ok(())
     }
 
     #[pyfunction]
     fn _leave_task(loop_: PyObjectRef, task: PyObjectRef, vm: &VirtualMachine) -> PyResult<()> {
-        let current_tasks = get_current_tasks_dict(vm)?;
-        let dict: PyDictRef = current_tasks.downcast().unwrap();
-
-        let current = dict.get_item(&*loop_, vm).ok();
-        match current {
-            None => {
-                return Err(
-                    vm.new_runtime_error("_leave_task: task is not the current task".to_owned())
-                );
-            }
-            Some(current) if !current.is(&task) => {
-                return Err(
-                    vm.new_runtime_error("_leave_task: task is not the current task".to_owned())
-                );
+        // Per-thread check, matching CPython's ts->asyncio_running_task
+        {
+            let running_task = vm.asyncio_running_task.borrow();
+            match running_task.as_ref() {
+                None => {
+                    return Err(vm.new_runtime_error("_leave_task: task is not the current task"));
+                }
+                Some(current) if !current.is(&task) => {
+                    return Err(vm.new_runtime_error("_leave_task: task is not the current task"));
+                }
+                _ => {}
             }
-            _ => {}
         }
 
-        dict.del_item(&*loop_, vm)?;
+        *vm.asyncio_running_task.borrow_mut() = None;
+
+        // Also update the module-level dict
+        if let Ok(current_tasks) = get_current_tasks_dict(vm)
+            && let Ok(dict) = current_tasks.downcast::<rustpython_vm::builtins::PyDict>()
+        {
+            let _ = dict.del_item(&*loop_, vm);
+        }
         Ok(())
     }
 
     #[pyfunction]
     fn _swap_current_task(loop_: PyObjectRef, task: PyObjectRef, vm: &VirtualMachine) -> PyResult {
-        let current_tasks = get_current_tasks_dict(vm)?;
-        let dict: PyDictRef = current_tasks.downcast().unwrap();
-
-        let prev = match dict.get_item(&*loop_, vm) {
-            Ok(t) => t,
-            Err(_) => vm.ctx.none(),
-        };
+        // Per-thread swap, matching CPython's swap_current_task
+        let prev = vm
+            .asyncio_running_task
+            .borrow()
+            .clone()
+            .unwrap_or_else(|| vm.ctx.none());
 
         if vm.is_none(&task) {
-            let _ = dict.del_item(&*loop_, vm);
+            *vm.asyncio_running_task.borrow_mut() = None;
         } else {
-            dict.set_item(&*loop_, task, vm)?;
+            *vm.asyncio_running_task.borrow_mut() = Some(task.clone());
+        }
+
+        // Also update the module-level dict for cross-thread queries
+        if let Ok(current_tasks) = get_current_tasks_dict(vm)
+            && let Ok(dict) = current_tasks.downcast::<rustpython_vm::builtins::PyDict>()
+        {
+            if vm.is_none(&task) {
+                let _ = dict.del_item(&*loop_, vm);
+            } else {
+                let _ = dict.set_item(&*loop_, task, vm);
+            }
         }
 
         Ok(prev)
     }
 
+    /// Reset task state after fork in child process.
+    #[pyfunction]
+    fn _on_fork(vm: &VirtualMachine) -> PyResult<()> {
+        // Clear current_tasks dict so child process doesn't inherit parent's tasks
+        if let Ok(current_tasks) = get_current_tasks_dict(vm) {
+            vm.call_method(&current_tasks, "clear", ())?;
+        }
+        // Clear the running loop and task
+        *vm.asyncio_running_loop.borrow_mut() = None;
+        *vm.asyncio_running_task.borrow_mut() = None;
+        Ok(())
+    }
+
     #[pyfunction]
     fn future_add_to_awaited_by(
         fut: PyObjectRef,
         waiter: PyObjectRef,
         vm: &VirtualMachine,
     ) -> PyResult<()> {
-        // Use optimized method for native Future/Task
+        // Only operate on native Future/Task objects (including subclasses).
+        // Non-native objects are silently ignored.
         if let Some(task) = fut.downcast_ref::<PyTask>() {
             return task.base.awaited_by_add(waiter, vm);
         }
         if let Some(future) = fut.downcast_ref::<PyFuture>() {
             return future.awaited_by_add(waiter, vm);
         }
-
-        // Fallback for non-native futures (Python subclasses)
-        if let Ok(Some(awaited_by)) =
-            vm.get_attribute_opt(fut.clone(), vm.ctx.intern_str("_asyncio_awaited_by"))
-            && !vm.is_none(&awaited_by)
-        {
-            vm.call_method(&awaited_by, "add", (waiter,))?;
-            return Ok(());
-        }
-
-        let new_set = PySet::default().into_ref(&vm.ctx);
-        new_set.add(waiter, vm)?;
-        fut.set_attr(vm.ctx.intern_str("_asyncio_awaited_by"), new_set, vm)?;
-
         Ok(())
     }
 
@@ -2556,21 +2591,14 @@ pub(crate) mod _asyncio {
         waiter: PyObjectRef,
         vm: &VirtualMachine,
     ) -> PyResult<()> {
-        // Use optimized method for native Future/Task
+        // Only operate on native Future/Task objects (including subclasses).
+        // Non-native objects are silently ignored.
         if let Some(task) = fut.downcast_ref::<PyTask>() {
             return task.base.awaited_by_discard(&waiter, vm);
         }
         if let Some(future) = fut.downcast_ref::<PyFuture>() {
             return future.awaited_by_discard(&waiter, vm);
         }
-
-        // Fallback for non-native futures
-        if let Ok(Some(awaited_by)) =
-            vm.get_attribute_opt(fut.clone(), vm.ctx.intern_str("_asyncio_awaited_by"))
-            && !vm.is_none(&awaited_by)
-        {
-            vm.call_method(&awaited_by, "discard", (waiter,))?;
-        }
         Ok(())
     }
 
@@ -2596,6 +2624,14 @@ pub(crate) mod _asyncio {
         fn __self__(&self, vm: &VirtualMachine) -> PyObjectRef {
             self.task.read().clone().unwrap_or_else(|| vm.ctx.none())
         }
+
+        #[pygetset]
+        fn __qualname__(&self, vm: &VirtualMachine) -> PyResult<Option<PyObjectRef>> {
+            match self.task.read().as_ref() {
+                Some(t) => vm.get_attribute_opt(t.clone(), vm.ctx.intern_str("__qualname__")),
+                None => Ok(None),
+            }
+        }
     }
 
     impl Callable for TaskStepMethWrapper {
@@ -2610,12 +2646,12 @@ pub(crate) mod _asyncio {
     }
 
     impl Representable for TaskStepMethWrapper {
-        fn repr_str(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<String> {
-            let task = zelf.task.read().clone();
-            match task {
-                Some(t) => Ok(t.repr(vm)?.as_str().to_string()),
-                None => Ok("<TaskStepMethWrapper>".to_string()),
-            }
+        fn repr_str(zelf: &Py<Self>, _vm: &VirtualMachine) -> PyResult<String> {
+            Ok(format!(
+                "<{} object at {:#x}>",
+                zelf.class().name(),
+                zelf.get_id()
+            ))
         }
     }
 
@@ -2634,6 +2670,14 @@ pub(crate) mod _asyncio {
                 task: PyRwLock::new(Some(task)),
             }
         }
+
+        #[pygetset]
+        fn __qualname__(&self, vm: &VirtualMachine) -> PyResult<Option<PyObjectRef>> {
+            match self.task.read().as_ref() {
+                Some(t) => vm.get_attribute_opt(t.clone(), vm.ctx.intern_str("__qualname__")),
+                None => Ok(None),
+            }
+        }
     }
 
     impl Callable for TaskWakeupMethWrapper {
@@ -2648,12 +2692,12 @@ pub(crate) mod _asyncio {
     }
 
     impl Representable for TaskWakeupMethWrapper {
-        fn repr_str(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<String> {
-            let task = zelf.task.read().clone();
-            match task {
-                Some(t) => Ok(t.repr(vm)?.as_str().to_string()),
-                None => Ok("<TaskWakeupMethWrapper>".to_string()),
-            }
+        fn repr_str(zelf: &Py<Self>, _vm: &VirtualMachine) -> PyResult<String> {
+            Ok(format!(
+                "<{} object at {:#x}>",
+                zelf.class().name(),
+                zelf.get_id()
+            ))
         }
     }
 
@@ -2703,7 +2747,7 @@ pub(crate) mod _asyncio {
             .ok_or_else(|| vm.new_attribute_error("CancelledError not found"))?;
         exc_type
             .downcast()
-            .map_err(|_| vm.new_type_error("CancelledError is not a type".to_string()))
+            .map_err(|_| vm.new_type_error("CancelledError is not a type"))
     }
 
     fn is_cancelled_error(exc: &PyBaseExceptionRef, vm: &VirtualMachine) -> bool {
diff --git a/crates/stdlib/src/_opcode.rs b/crates/stdlib/src/_opcode.rs
index 4f56be03092..4b3b30520bd 100644
--- a/crates/stdlib/src/_opcode.rs
+++ b/crates/stdlib/src/_opcode.rs
@@ -82,16 +82,16 @@ mod _opcode {
                 Self::try_from(opcode).map(|op| op.inner()),
                 Ok(AnyInstruction::Real(
                     Instruction::DeleteAttr { .. }
-                        | Instruction::DeleteGlobal(_)
-                        | Instruction::DeleteName(_)
+                        | Instruction::DeleteGlobal { .. }
+                        | Instruction::DeleteName { .. }
                         | Instruction::ImportFrom { .. }
                         | Instruction::ImportName { .. }
                         | Instruction::LoadAttr { .. }
-                        | Instruction::LoadGlobal(_)
-                        | Instruction::LoadName(_)
+                        | Instruction::LoadGlobal { .. }
+                        | Instruction::LoadName { .. }
                         | Instruction::StoreAttr { .. }
-                        | Instruction::StoreGlobal(_)
-                        | Instruction::StoreName(_)
+                        | Instruction::StoreGlobal { .. }
+                        | Instruction::StoreName { .. }
                 ))
             )
         }
@@ -116,10 +116,10 @@ mod _opcode {
             matches!(
                 Self::try_from(opcode).map(|op| op.inner()),
                 Ok(AnyInstruction::Real(
-                    Instruction::DeleteDeref(_)
-                        | Instruction::LoadFromDictOrDeref(_)
-                        | Instruction::LoadDeref(_)
-                        | Instruction::StoreDeref(_)
+                    Instruction::DeleteDeref { .. }
+                        | Instruction::LoadFromDictOrDeref { .. }
+                        | Instruction::LoadDeref { .. }
+                        | Instruction::StoreDeref { .. }
                 ))
             )
         }
@@ -130,10 +130,10 @@ mod _opcode {
             matches!(
                 Self::try_from(opcode).map(|op| op.inner()),
                 Ok(AnyInstruction::Real(
-                    Instruction::DeleteFast(_)
-                        | Instruction::LoadFast(_)
-                        | Instruction::LoadFastAndClear(_)
-                        | Instruction::StoreFast(_)
+                    Instruction::DeleteFast { .. }
+                        | Instruction::LoadFast { .. }
+                        | Instruction::LoadFastAndClear { .. }
+                        | Instruction::StoreFast { .. }
                         | Instruction::StoreFastLoadFast { .. }
                 ))
             )
@@ -197,8 +197,13 @@ mod _opcode {
 
         let opcode = Opcode::try_from_pyint(args.opcode, vm)?;
 
+        // Raise ValueError if specialized.
+        if opcode.inner().real().is_some_and(|op| op.deopt().is_some()) {
+            return Err(vm.new_value_error("invalid opcode or oparg"));
+        }
+
         let _ = jump; // Python API accepts jump but it's not used
-        Ok(opcode.stack_effect(oparg.into()))
+        Ok(opcode.stack_effect(oparg))
     }
 
     #[pyfunction]
diff --git a/crates/stdlib/src/_remote_debugging.rs b/crates/stdlib/src/_remote_debugging.rs
new file mode 100644
index 00000000000..618ea9fe0a8
--- /dev/null
+++ b/crates/stdlib/src/_remote_debugging.rs
@@ -0,0 +1,107 @@
+pub(crate) use _remote_debugging::module_def;
+
+#[pymodule]
+mod _remote_debugging {
+    use crate::vm::{
+        Py, PyObjectRef, PyResult, VirtualMachine,
+        builtins::PyType,
+        function::FuncArgs,
+        types::{Constructor, PyStructSequence},
+    };
+
+    #[pystruct_sequence_data]
+    struct FrameInfoData {
+        filename: String,
+        lineno: i64,
+        funcname: String,
+    }
+
+    #[pyattr]
+    #[pystruct_sequence(
+        name = "FrameInfo",
+        module = "_remote_debugging",
+        data = "FrameInfoData"
+    )]
+    struct FrameInfo;
+
+    #[pyclass(with(PyStructSequence))]
+    impl FrameInfo {}
+
+    #[pystruct_sequence_data]
+    struct TaskInfoData {
+        task_id: PyObjectRef,
+        task_name: PyObjectRef,
+        coroutine_stack: PyObjectRef,
+        awaited_by: PyObjectRef,
+    }
+
+    #[pyattr]
+    #[pystruct_sequence(name = "TaskInfo", module = "_remote_debugging", data = "TaskInfoData")]
+    struct TaskInfo;
+
+    #[pyclass(with(PyStructSequence))]
+    impl TaskInfo {}
+
+    #[pystruct_sequence_data]
+    struct CoroInfoData {
+        call_stack: PyObjectRef,
+        task_name: PyObjectRef,
+    }
+
+    #[pyattr]
+    #[pystruct_sequence(name = "CoroInfo", module = "_remote_debugging", data = "CoroInfoData")]
+    struct CoroInfo;
+
+    #[pyclass(with(PyStructSequence))]
+    impl CoroInfo {}
+
+    #[pystruct_sequence_data]
+    struct ThreadInfoData {
+        thread_id: PyObjectRef,
+        frame_info: PyObjectRef,
+    }
+
+    #[pyattr]
+    #[pystruct_sequence(
+        name = "ThreadInfo",
+        module = "_remote_debugging",
+        data = "ThreadInfoData"
+    )]
+    struct ThreadInfo;
+
+    #[pyclass(with(PyStructSequence))]
+    impl ThreadInfo {}
+
+    #[pystruct_sequence_data]
+    struct AwaitedInfoData {
+        thread_id: PyObjectRef,
+        awaited_by: PyObjectRef,
+    }
+
+    #[pyattr]
+    #[pystruct_sequence(
+        name = "AwaitedInfo",
+        module = "_remote_debugging",
+        data = "AwaitedInfoData"
+    )]
+    struct AwaitedInfo;
+
+    #[pyclass(with(PyStructSequence))]
+    impl AwaitedInfo {}
+
+    #[pyattr]
+    #[pyclass(name = "RemoteUnwinder", module = "_remote_debugging")]
+    #[derive(Debug, PyPayload)]
+    struct RemoteUnwinder {}
+
+    impl Constructor for RemoteUnwinder {
+        type Args = FuncArgs;
+
+        fn py_new(_cls: &Py<PyType>, _args: Self::Args, vm: &VirtualMachine) -> PyResult<Self> {
+            Err(vm.new_not_implemented_error("_remote_debugging is not available"))
+        }
+    }
+
+    #[pyclass(with(Constructor))]
+    impl RemoteUnwinder {}
+}
diff --git a/crates/stdlib/src/_sqlite3.rs b/crates/stdlib/src/_sqlite3.rs
index 825fff06b75..db1350e0b91 100644
--- a/crates/stdlib/src/_sqlite3.rs
+++ b/crates/stdlib/src/_sqlite3.rs
@@ -12,6 +12,12 @@ pub(crate) use _sqlite3::module_def;
 
 #[pymodule]
 mod _sqlite3 {
+    use core::{
+        ffi::{CStr, c_int, c_longlong, c_uint, c_void},
+        fmt::Debug,
+        ops::Deref,
+        ptr::{NonNull, null, null_mut},
+    };
     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,
@@ -56,7 +62,7 @@ mod _sqlite3 {
         convert::IntoObject,
         function::{
             ArgCallable, ArgIterable, FsPath, FuncArgs, OptionalArg, PyComparisonValue,
-            PySetterValue,
+            PySetterValue, TimeoutSeconds,
         },
         object::{Traverse, TraverseFn},
         protocol::{
@@ -70,13 +76,7 @@ mod _sqlite3 {
         },
         utils::ToCString,
     };
-    use std::{
-        ffi::{CStr, c_int, c_longlong, c_uint, c_void},
-        fmt::Debug,
-        ops::Deref,
-        ptr::{NonNull, null, null_mut},
-        thread::ThreadId,
-    };
+    use std::thread::ThreadId;
 
     macro_rules! exceptions {
         ($(($x:ident, $base:expr)),*) => {
@@ -89,7 +89,7 @@ mod _sqlite3 {
                 $(
                     #[allow(dead_code)]
                     fn [<new_ $x:snake>](vm: &VirtualMachine, msg: String) -> PyBaseExceptionRef {
-                        vm.new_exception_msg([<$x:snake _type>]().to_owned(), msg)
+                        vm.new_exception_msg([<$x:snake _type>]().to_owned(), msg.into())
                     }
                     fn [<$x:snake _type>]() -> &'static Py<PyType> {
                         [<$x:snake:upper>].get().expect("exception type not initialize")
@@ -333,8 +333,8 @@ mod _sqlite3 {
     struct ConnectArgs {
         #[pyarg(any)]
         database: FsPath,
-        #[pyarg(any, default = 5.0)]
-        timeout: f64,
+        #[pyarg(any, default = TimeoutSeconds::new(5.0))]
+        timeout: TimeoutSeconds,
         #[pyarg(any, default = 0)]
         detect_types: c_int,
         #[pyarg(any, default = Some(vm.ctx.empty_str.to_owned()))]
@@ -451,7 +451,7 @@ mod _sqlite3 {
         ) {
             let context = SqliteContext::from(context);
             let (func, vm) = unsafe { (*context.user_data::<Self>()).retrieve() };
-            let args = unsafe { std::slice::from_raw_parts(argv, argc as usize) };
+            let args = unsafe { core::slice::from_raw_parts(argv, argc as usize) };
 
             let f = || -> PyResult<()> {
                 let db = context.db_handle();
@@ -478,7 +478,7 @@ mod _sqlite3 {
         ) {
             let context = SqliteContext::from(context);
             let (cls, vm) = unsafe { (*context.user_data::<Self>()).retrieve() };
-            let args = unsafe { std::slice::from_raw_parts(argv, argc as usize) };
+            let args = unsafe { core::slice::from_raw_parts(argv, argc as usize) };
             let instance = context.aggregate_context::<*const PyObject>();
             if unsafe { (*instance).is_null() } {
                 match cls.call((), vm) {
@@ -556,7 +556,7 @@ mod _sqlite3 {
         ) {
             let context = SqliteContext::from(context);
             let (_, vm) = unsafe { (*context.user_data::<Self>()).retrieve() };
-            let args = unsafe { std::slice::from_raw_parts(argv, argc as usize) };
+            let args = unsafe { core::slice::from_raw_parts(argv, argc as usize) };
             let instance = context.aggregate_context::<*const PyObject>();
             let instance = unsafe { &**instance };
 
@@ -723,7 +723,7 @@ mod _sqlite3 {
         converter: ArgCallable,
         vm: &VirtualMachine,
     ) -> PyResult<()> {
-        let name = typename.as_str().to_uppercase();
+        let name = typename.expect_str().to_uppercase();
         converters().set_item(&name, converter.into(), vm)
     }
 
@@ -882,7 +882,7 @@ mod _sqlite3 {
     }
 
     impl Debug for Connection {
-        fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> Result<(), std::fmt::Error> {
+        fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> Result<(), core::fmt::Error> {
             write!(f, "Sqlite3 Connection")
         }
     }
@@ -976,7 +976,7 @@ mod _sqlite3 {
         }
     }
 
-    #[pyclass(with(Constructor, Callable, Initializer), flags(BASETYPE))]
+    #[pyclass(with(Constructor, Callable, Initializer), flags(BASETYPE, HAS_WEAKREF))]
     impl Connection {
         fn drop_db(&self) {
             self.db.lock().take();
@@ -991,7 +991,7 @@ mod _sqlite3 {
         fn initialize_db(args: &ConnectArgs, vm: &VirtualMachine) -> PyResult<Sqlite> {
             let path = args.database.to_cstring(vm)?;
             let db = Sqlite::from(SqliteRaw::open(path.as_ptr(), args.uri, vm)?);
-            let timeout = (args.timeout * 1000.0) as c_int;
+            let timeout = (args.timeout.to_secs_f64() * 1000.0) as c_int;
             db.busy_timeout(timeout);
             if let Some(isolation_level) = &args.isolation_level {
                 begin_statement_ptr_from_isolation_level(isolation_level, vm)?;
@@ -1040,8 +1040,10 @@ mod _sqlite3 {
                 )));
             }
 
-            if let Some(cursor_ref) = cursor.downcast_ref::<Cursor>() {
-                let _ = unsafe { cursor_ref.row_factory.swap(zelf.row_factory.to_owned()) };
+            if let Some(cursor_ref) = cursor.downcast_ref::<Cursor>()
+                && let Some(factory) = zelf.row_factory.to_owned()
+            {
+                let _ = unsafe { cursor_ref.row_factory.swap(Some(factory)) };
             }
 
             Ok(cursor)
@@ -1507,9 +1509,9 @@ mod _sqlite3 {
                     let _ = unsafe { self.isolation_level.swap(value) };
                     Ok(())
                 }
-                PySetterValue::Delete => Err(vm.new_attribute_error(
-                    "'isolation_level' attribute cannot be deleted".to_owned(),
-                )),
+                PySetterValue::Delete => {
+                    Err(vm.new_attribute_error("'isolation_level' attribute cannot be deleted"))
+                }
             }
         }
 
@@ -1624,7 +1626,10 @@ mod _sqlite3 {
         size: Option<c_int>,
     }
 
-    #[pyclass(with(Constructor, Initializer, IterNext, Iterable), flags(BASETYPE))]
+    #[pyclass(
+        with(Constructor, Initializer, IterNext, Iterable),
+        flags(BASETYPE, HAS_WEAKREF)
+    )]
     impl Cursor {
         fn new(
             connection: PyRef<Connection>,
@@ -1883,15 +1888,26 @@ mod _sqlite3 {
             args: FetchManyArgs,
             vm: &VirtualMachine,
         ) -> PyResult<Vec<PyObjectRef>> {
-            let max_rows = args
-                .size
-                .unwrap_or_else(|| zelf.arraysize.load(Ordering::Relaxed));
+            let max_rows = match args.size {
+                Some(size) => {
+                    if size < 0 {
+                        return Err(vm.new_value_error("fetchmany may not be negative"));
+                    }
+
+                    size
+                }
+                None => zelf.arraysize.load(Ordering::Relaxed),
+            };
 
             let mut list = vec![];
-            while let PyIterReturn::Return(row) = Cursor::next(zelf, vm)? {
-                list.push(row);
-                if max_rows > 0 && list.len() as c_int >= max_rows {
-                    break;
+            let mut remaining = max_rows;
+            while remaining > 0 {
+                match Cursor::next(zelf, vm)? {
+                    PyIterReturn::Return(row) => {
+                        list.push(row);
+                        remaining -= 1;
+                    }
+                    PyIterReturn::StopIteration(_) => break,
                 }
             }
             Ok(list)
@@ -1955,9 +1971,26 @@ mod _sqlite3 {
         fn arraysize(&self) -> c_int {
             self.arraysize.load(Ordering::Relaxed)
         }
+
         #[pygetset(setter)]
-        fn set_arraysize(&self, val: c_int) {
+        fn set_arraysize(&self, val: c_int, vm: &VirtualMachine) -> PyResult<()> {
+            if val < 0 {
+                return Err(vm.new_value_error("arraysize may not be negative"));
+            }
+
             self.arraysize.store(val, Ordering::Relaxed);
+
+            Ok(())
+        }
+
+        #[pygetset]
+        fn row_factory(&self) -> Option<PyObjectRef> {
+            self.row_factory.to_owned()
+        }
+
+        #[pygetset(setter)]
+        fn set_row_factory(&self, val: Option<PyObjectRef>) {
+            let _ = unsafe { self.row_factory.swap(val) };
         }
 
         fn build_row_cast_map(
@@ -2077,7 +2110,7 @@ mod _sqlite3 {
                     } else {
                         let nbytes = st.column_bytes(i);
                         let blob = unsafe {
-                            std::slice::from_raw_parts(blob.cast::<u8>(), nbytes as usize)
+                            core::slice::from_raw_parts(blob.cast::<u8>(), nbytes as usize)
                         };
                         let blob = vm.ctx.new_bytes(blob.to_vec());
                         converter.call((blob,), vm)?
@@ -2194,8 +2227,8 @@ mod _sqlite3 {
                     let Some(obj) = obj.downcast_ref::<PyStr>() else {
                         break;
                     };
-                    let a_iter = name.as_str().chars().flat_map(|x| x.to_uppercase());
-                    let b_iter = obj.as_str().chars().flat_map(|x| x.to_uppercase());
+                    let a_iter = name.expect_str().chars().flat_map(|x| x.to_uppercase());
+                    let b_iter = obj.expect_str().chars().flat_map(|x| x.to_uppercase());
 
                     if a_iter.eq(b_iter) {
                         return self.data.getitem_by_index(vm, i);
@@ -2684,7 +2717,7 @@ mod _sqlite3 {
     }
 
     impl Debug for Statement {
-        fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> Result<(), std::fmt::Error> {
+        fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> Result<(), core::fmt::Error> {
             write!(
                 f,
                 "{} Statement",
@@ -2918,7 +2951,7 @@ mod _sqlite3 {
             };
             let mut s = Vec::with_capacity(16);
             s.extend(b"BEGIN ");
-            s.extend(isolation_level.as_str().bytes());
+            s.extend(isolation_level.expect_str().bytes());
             s.push(b'\0');
             self._exec(&s, vm)
         }
@@ -3469,7 +3502,7 @@ mod _sqlite3 {
             return e;
         }
 
-        vm.new_exception_msg_dict(typ, msg, dict)
+        vm.new_exception_msg_dict(typ, msg.into(), dict)
     }
 
     static BEGIN_STATEMENTS: &[&[u8]] = &[
diff --git a/crates/stdlib/src/_testconsole.rs b/crates/stdlib/src/_testconsole.rs
new file mode 100644
index 00000000000..0db508e3da5
--- /dev/null
+++ b/crates/stdlib/src/_testconsole.rs
@@ -0,0 +1,76 @@
+pub(crate) use _testconsole::module_def;
+
+#[pymodule]
+mod _testconsole {
+    use crate::vm::{
+        PyObjectRef, PyResult, VirtualMachine, convert::IntoPyException, function::ArgBytesLike,
+    };
+    use windows_sys::Win32::Foundation::INVALID_HANDLE_VALUE;
+
+    type Handle = windows_sys::Win32::Foundation::HANDLE;
+
+    #[pyfunction]
+    fn write_input(file: PyObjectRef, s: ArgBytesLike, vm: &VirtualMachine) -> PyResult<()> {
+        use windows_sys::Win32::System::Console::{INPUT_RECORD, KEY_EVENT, WriteConsoleInputW};
+
+        // Get the fd from the file object via fileno()
+        let fd_obj = vm.call_method(&file, "fileno", ())?;
+        let fd: i32 = fd_obj.try_into_value(vm)?;
+
+        let handle = unsafe { libc::get_osfhandle(fd) } as Handle;
+        if handle == INVALID_HANDLE_VALUE {
+            return Err(std::io::Error::last_os_error().into_pyexception(vm));
+        }
+
+        let data = s.borrow_buf();
+        let data = &*data;
+
+        // Interpret as UTF-16-LE pairs
+        if !data.len().is_multiple_of(2) {
+            return Err(vm.new_value_error("buffer must contain UTF-16-LE data (even length)"));
+        }
+        let wchars: Vec<u16> = data
+            .chunks_exact(2)
+            .map(|chunk| u16::from_le_bytes([chunk[0], chunk[1]]))
+            .collect();
+
+        let size = wchars.len() as u32;
+
+        // Create INPUT_RECORD array
+        let mut records: Vec<INPUT_RECORD> = Vec::with_capacity(wchars.len());
+        for &wc in &wchars {
+            // SAFETY: zeroing and accessing the union field for KEY_EVENT
+            let mut rec: INPUT_RECORD = unsafe { core::mem::zeroed() };
+            rec.EventType = KEY_EVENT as u16;
+            rec.Event.KeyEvent.bKeyDown = 1; // TRUE
+            rec.Event.KeyEvent.wRepeatCount = 1;
+            rec.Event.KeyEvent.uChar.UnicodeChar = wc;
+            records.push(rec);
+        }
+
+        let mut total: u32 = 0;
+        while total < size {
+            let mut wrote: u32 = 0;
+            let res = unsafe {
+                WriteConsoleInputW(
+                    handle,
+                    records[total as usize..].as_ptr(),
+                    size - total,
+                    &mut wrote,
+                )
+            };
+            if res == 0 {
+                return Err(std::io::Error::last_os_error().into_pyexception(vm));
+            }
+            total += wrote;
+        }
+
+        Ok(())
+    }
+
+    #[pyfunction]
+    fn read_output(_file: PyObjectRef) -> Option<()> {
+        // Stub, same as CPython
+        None
+    }
+}
diff --git a/crates/stdlib/src/_tokenize.rs b/crates/stdlib/src/_tokenize.rs
new file mode 100644
index 00000000000..13bd1661305
--- /dev/null
+++ b/crates/stdlib/src/_tokenize.rs
@@ -0,0 +1,756 @@
+pub(crate) use _tokenize::module_def;
+
+#[pymodule]
+mod _tokenize {
+    use crate::{
+        common::lock::PyRwLock,
+        vm::{
+            AsObject, Py, PyObjectRef, PyPayload, PyResult, VirtualMachine,
+            builtins::{PyBytes, PyStr, PyType},
+            convert::ToPyObject,
+            function::ArgCallable,
+            protocol::PyIterReturn,
+            types::{Constructor, IterNext, Iterable, SelfIter},
+        },
+    };
+    use core::fmt;
+    use ruff_python_ast::PySourceType;
+    use ruff_python_ast::token::{Token, TokenKind};
+    use ruff_python_parser::{
+        LexicalErrorType, ParseError, ParseErrorType, parse_unchecked_source,
+    };
+    use ruff_source_file::{LineIndex, LineRanges};
+    use ruff_text_size::{Ranged, TextSize};
+
+    const TOKEN_ENDMARKER: u8 = 0;
+    const TOKEN_DEDENT: u8 = 6;
+    const TOKEN_OP: u8 = 55;
+    const TOKEN_COMMENT: u8 = 65;
+    const TOKEN_NL: u8 = 66;
+
+    #[pyattr]
+    #[pyclass(name = "TokenizerIter")]
+    #[derive(PyPayload)]
+    pub struct PyTokenizerIter {
+        readline: ArgCallable,
+        extra_tokens: bool,
+        encoding: Option<String>,
+        state: PyRwLock<TokenizerState>,
+    }
+
+    impl PyTokenizerIter {
+        fn readline(&self, vm: &VirtualMachine) -> PyResult<String> {
+            let raw_line = match self.readline.invoke((), vm) {
+                Ok(v) => v,
+                Err(err) => {
+                    if err.fast_isinstance(vm.ctx.exceptions.stop_iteration) {
+                        return Ok(String::new());
+                    }
+                    return Err(err);
+                }
+            };
+            Ok(match &self.encoding {
+                Some(encoding) => {
+                    let bytes = raw_line
+                        .downcast::<PyBytes>()
+                        .map_err(|_| vm.new_type_error("readline() returned a non-bytes object"))?;
+                    vm.state
+                        .codec_registry
+                        .decode_text(bytes.into(), encoding, None, vm)
+                        .map(|s| s.to_string())?
+                }
+                None => raw_line
+                    .downcast::<PyStr>()
+                    .map(|s| s.to_string())
+                    .map_err(|_| vm.new_type_error("readline() returned a non-string object"))?,
+            })
+        }
+    }
+
+    impl fmt::Debug for PyTokenizerIter {
+        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+            f.debug_struct("PyTokenizerIter")
+                .field("extra_tokens", &self.extra_tokens)
+                .field("encoding", &self.encoding)
+                .finish()
+        }
+    }
+
+    #[pyclass(with(Constructor, Iterable, IterNext))]
+    impl PyTokenizerIter {}
+
+    impl Constructor for PyTokenizerIter {
+        type Args = PyTokenizerIterArgs;
+
+        fn py_new(_cls: &Py<PyType>, args: Self::Args, _vm: &VirtualMachine) -> PyResult<Self> {
+            let Self::Args {
+                readline,
+                extra_tokens,
+                encoding,
+            } = args;
+
+            Ok(Self {
+                readline,
+                extra_tokens,
+                encoding: encoding.map(|s| s.to_string()),
+                state: PyRwLock::new(TokenizerState {
+                    phase: TokenizerPhase::Reading {
+                        source: String::new(),
+                    },
+                }),
+            })
+        }
+    }
+
+    impl SelfIter for PyTokenizerIter {}
+
+    impl IterNext for PyTokenizerIter {
+        fn next(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<PyIterReturn> {
+            let mut state = zelf.state.read().clone();
+
+            loop {
+                match &mut state.phase {
+                    TokenizerPhase::Reading { source } => {
+                        let line = zelf.readline(vm)?;
+                        if line.is_empty() {
+                            let accumulated = core::mem::take(source);
+                            let parsed = parse_unchecked_source(&accumulated, PySourceType::Python);
+                            let tokens: Vec<Token> = parsed.tokens().iter().copied().collect();
+                            let errors: Vec<ParseError> = parsed.errors().to_vec();
+                            let line_index = LineIndex::from_source_text(&accumulated);
+                            let implicit_nl = !accumulated.ends_with('\n');
+                            state.phase = TokenizerPhase::Yielding {
+                                source: accumulated,
+                                tokens,
+                                errors,
+                                index: 0,
+                                line_index,
+                                need_implicit_nl: implicit_nl,
+                                pending_fstring_parts: Vec::new(),
+                                pending_empty_fstring_middle: None,
+                            };
+                        } else {
+                            source.push_str(&line);
+                        }
+                    }
+                    TokenizerPhase::Yielding { .. } => {
+                        let result = emit_next_token(&mut state, zelf.extra_tokens, vm)?;
+                        *zelf.state.write() = state;
+                        return Ok(result);
+                    }
+                    TokenizerPhase::Done => {
+                        return Ok(PyIterReturn::StopIteration(None));
+                    }
+                }
+            }
+        }
+    }
+
+    /// Emit the next token from the Yielding phase.
+    fn emit_next_token(
+        state: &mut TokenizerState,
+        extra_tokens: bool,
+        vm: &VirtualMachine,
+    ) -> PyResult<PyIterReturn> {
+        let TokenizerPhase::Yielding {
+            source,
+            tokens,
+            errors,
+            index,
+            line_index,
+            need_implicit_nl,
+            pending_fstring_parts,
+            pending_empty_fstring_middle,
+        } = &mut state.phase
+        else {
+            unreachable!()
+        };
+
+        // Emit pending empty FSTRING_MIDDLE (for format spec nesting)
+        if let Some((mid_type, mid_line, mid_col, mid_line_str)) =
+            pending_empty_fstring_middle.take()
+        {
+            return Ok(PyIterReturn::Return(make_token_tuple(
+                vm,
+                mid_type,
+                "",
+                mid_line,
+                mid_col as isize,
+                mid_line,
+                mid_col as isize,
+                &mid_line_str,
+            )));
+        }
+
+        // Emit any pending fstring sub-tokens first
+        if let Some((tok_type, tok_str, sl, sc, el, ec)) = pending_fstring_parts.pop() {
+            let offset: usize = source
+                .lines()
+                .take(sl.saturating_sub(1))
+                .map(|l| l.len() + 1)
+                .sum();
+            let full_line = source.full_line_str(TextSize::from(offset.min(source.len()) as u32));
+            return Ok(PyIterReturn::Return(make_token_tuple(
+                vm,
+                tok_type,
+                &tok_str,
+                sl,
+                sc as isize,
+                el,
+                ec as isize,
+                full_line,
+            )));
+        }
+
+        let source_len = TextSize::from(source.len() as u32);
+
+        while *index < tokens.len() {
+            let token = tokens[*index];
+            *index += 1;
+            let kind = token.kind();
+            let range = token.range();
+
+            // Check for lexical indentation errors.
+            // Skip when source has tabs — ruff and CPython handle tab
+            // indentation differently (CPython uses tabsize=8), so ruff may
+            // report false IndentationErrors for valid mixed-tab code.
+            if !source.contains('\t') {
+                for err in errors.iter() {
+                    if !matches!(
+                        err.error,
+                        ParseErrorType::Lexical(LexicalErrorType::IndentationError)
+                    ) {
+                        continue;
+                    }
+                    if err.location.start() <= range.start() && range.start() < err.location.end() {
+                        return Err(raise_indentation_error(vm, err, source, line_index));
+                    }
+                }
+            }
+
+            if kind == TokenKind::EndOfFile {
+                continue;
+            }
+
+            if !extra_tokens && matches!(kind, TokenKind::Comment | TokenKind::NonLogicalNewline) {
+                continue;
+            }
+
+            let raw_type = token_kind_value(kind);
+            let token_type = if extra_tokens && raw_type > TOKEN_DEDENT && raw_type < TOKEN_OP {
+                TOKEN_OP
+            } else {
+                raw_type
+            };
+
+            let (token_str, start_line, start_col, end_line, end_col, line_str) =
+                if kind == TokenKind::Dedent {
+                    let last_line = source.lines().count();
+                    let default_pos = if extra_tokens {
+                        (last_line + 1, 0)
+                    } else {
+                        (last_line, 0)
+                    };
+                    let (pos, dedent_line) =
+                        next_non_dedent_info(tokens, *index, source, line_index, default_pos);
+                    ("", pos.0, pos.1, pos.0, pos.1, dedent_line)
+                } else {
+                    let start_lc = line_index.line_column(range.start(), source);
+                    let start_line = start_lc.line.get();
+                    let start_col = start_lc.column.to_zero_indexed();
+                    let implicit_newline = range.start() >= source_len;
+                    let in_source = range.end() <= source_len;
+
+                    let (s, el, ec) = if kind == TokenKind::Newline {
+                        if extra_tokens {
+                            if implicit_newline {
+                                ("", start_line, start_col + 1)
+                            } else {
+                                let s = if source[range].starts_with('\r') {
+                                    "\r\n"
+                                } else {
+                                    "\n"
+                                };
+                                (s, start_line, start_col + s.len())
+                            }
+                        } else {
+                            ("", start_line, start_col)
+                        }
+                    } else if kind == TokenKind::NonLogicalNewline {
+                        let s = if in_source { &source[range] } else { "" };
+                        (s, start_line, start_col + s.len())
+                    } else {
+                        let end_lc = line_index.line_column(range.end(), source);
+                        let s = if in_source { &source[range] } else { "" };
+                        (s, end_lc.line.get(), end_lc.column.to_zero_indexed())
+                    };
+                    let line_str = source.full_line_str(range.start());
+                    (s, start_line, start_col, el, ec, line_str)
+                };
+
+            // Handle FSTRING_MIDDLE/TSTRING_MIDDLE brace unescaping
+            if matches!(kind, TokenKind::FStringMiddle | TokenKind::TStringMiddle)
+                && (token_str.contains("{{") || token_str.contains("}}"))
+            {
+                let mut parts =
+                    split_fstring_middle(token_str, token_type, start_line, start_col).into_iter();
+                let (tt, ts, sl, sc, el, ec) = parts.next().unwrap();
+                let rest: Vec<_> = parts.collect();
+                for p in rest.into_iter().rev() {
+                    pending_fstring_parts.push(p);
+                }
+                return Ok(PyIterReturn::Return(make_token_tuple(
+                    vm,
+                    tt,
+                    &ts,
+                    sl,
+                    sc as isize,
+                    el,
+                    ec as isize,
+                    line_str,
+                )));
+            }
+
+            // After emitting a Rbrace inside an fstring, check if the
+            // next token is also Rbrace without an intervening FStringMiddle.
+            // CPython emits an empty FSTRING_MIDDLE in that position.
+            if kind == TokenKind::Rbrace
+                && tokens
+                    .get(*index)
+                    .is_some_and(|t| t.kind() == TokenKind::Rbrace)
+            {
+                let mid_type = find_fstring_middle_type(tokens, *index);
+                *pending_empty_fstring_middle =
+                    Some((mid_type, end_line, end_col, line_str.to_string()));
+            }
+
+            return Ok(PyIterReturn::Return(make_token_tuple(
+                vm,
+                token_type,
+                token_str,
+                start_line,
+                start_col as isize,
+                end_line,
+                end_col as isize,
+                line_str,
+            )));
+        }
+
+        // Emit implicit NL before ENDMARKER if source
+        // doesn't end with newline and last token is Comment
+        if extra_tokens && core::mem::take(need_implicit_nl) {
+            let last_tok = tokens
+                .iter()
+                .rev()
+                .find(|t| t.kind() != TokenKind::EndOfFile);
+            if let Some(last) = last_tok.filter(|t| t.kind() == TokenKind::Comment) {
+                let end_lc = line_index.line_column(last.range().end(), source);
+                let nl_line = end_lc.line.get();
+                let nl_col = end_lc.column.to_zero_indexed();
+                return Ok(PyIterReturn::Return(make_token_tuple(
+                    vm,
+                    TOKEN_NL,
+                    "",
+                    nl_line,
+                    nl_col as isize,
+                    nl_line,
+                    nl_col as isize + 1,
+                    source.full_line_str(last.range().start()),
+                )));
+            }
+        }
+
+        // Check for unclosed brackets before ENDMARKER — CPython's tokenizer
+        // raises SyntaxError("EOF in multi-line statement") in this case.
+        {
+            let bracket_count: i32 = tokens
+                .iter()
+                .map(|t| match t.kind() {
+                    TokenKind::Lpar | TokenKind::Lsqb | TokenKind::Lbrace => 1,
+                    TokenKind::Rpar | TokenKind::Rsqb | TokenKind::Rbrace => -1,
+                    _ => 0,
+                })
+                .sum();
+            if bracket_count > 0 {
+                let last_line = source.lines().count();
+                return Err(raise_syntax_error(
+                    vm,
+                    "EOF in multi-line statement",
+                    last_line + 1,
+                    0,
+                ));
+            }
+        }
+
+        // All tokens consumed — emit ENDMARKER
+        let last_line = source.lines().count();
+        let (em_line, em_col, em_line_str): (usize, isize, &str) = if extra_tokens {
+            (last_line + 1, 0, "")
+        } else {
+            let last_line_text =
+                source.full_line_str(TextSize::from(source.len().saturating_sub(1) as u32));
+            (last_line, -1, last_line_text)
+        };
+
+        let result = make_token_tuple(
+            vm,
+            TOKEN_ENDMARKER,
+            "",
+            em_line,
+            em_col,
+            em_line,
+            em_col,
+            em_line_str,
+        );
+        state.phase = TokenizerPhase::Done;
+        Ok(PyIterReturn::Return(result))
+    }
+
+    /// Determine whether to emit FSTRING_MIDDLE (60) or TSTRING_MIDDLE (63)
+    /// by looking back for the most recent FStringStart/TStringStart.
+    fn find_fstring_middle_type(tokens: &[Token], index: usize) -> u8 {
+        let mut depth = 0i32;
+        for i in (0..index).rev() {
+            match tokens[i].kind() {
+                TokenKind::FStringEnd | TokenKind::TStringEnd => depth += 1,
+                TokenKind::FStringStart => {
+                    if depth == 0 {
+                        return 60; // FSTRING_MIDDLE
+                    }
+                    depth -= 1;
+                }
+                TokenKind::TStringStart => {
+                    if depth == 0 {
+                        return 63; // TSTRING_MIDDLE
+                    }
+                    depth -= 1;
+                }
+                _ => {}
+            }
+        }
+        60 // default to FSTRING_MIDDLE
+    }
+
+    /// Find the next non-DEDENT token's position and source line.
+    /// Returns ((line, col), line_str).
+    fn next_non_dedent_info<'a>(
+        tokens: &[Token],
+        index: usize,
+        source: &'a str,
+        line_index: &LineIndex,
+        default_pos: (usize, usize),
+    ) -> ((usize, usize), &'a str) {
+        for future in &tokens[index..] {
+            match future.kind() {
+                TokenKind::Dedent => continue,
+                TokenKind::EndOfFile => return (default_pos, ""),
+                _ => {
+                    let flc = line_index.line_column(future.range().start(), source);
+                    let pos = (flc.line.get(), flc.column.to_zero_indexed());
+                    return (pos, source.full_line_str(future.range().start()));
+                }
+            }
+        }
+        (default_pos, "")
+    }
+
+    /// Raise a SyntaxError with the given message and position.
+    fn raise_syntax_error(
+        vm: &VirtualMachine,
+        msg: &str,
+        lineno: usize,
+        offset: usize,
+    ) -> rustpython_vm::builtins::PyBaseExceptionRef {
+        let exc = vm.new_exception_msg(vm.ctx.exceptions.syntax_error.to_owned(), msg.into());
+        let obj = exc.as_object();
+        let _ = obj.set_attr("msg", vm.ctx.new_str(msg), vm);
+        let _ = obj.set_attr("lineno", vm.ctx.new_int(lineno), vm);
+        let _ = obj.set_attr("offset", vm.ctx.new_int(offset), vm);
+        let _ = obj.set_attr("filename", vm.ctx.new_str("<string>"), vm);
+        let _ = obj.set_attr("text", vm.ctx.none(), vm);
+        exc
+    }
+
+    /// Raise an IndentationError from a parse error.
+    fn raise_indentation_error(
+        vm: &VirtualMachine,
+        err: &ParseError,
+        source: &str,
+        line_index: &LineIndex,
+    ) -> rustpython_vm::builtins::PyBaseExceptionRef {
+        let err_lc = line_index.line_column(err.location.start(), source);
+        let err_line_text = source.full_line_str(err.location.start());
+        let err_text = err_line_text.trim_end_matches('\n').trim_end_matches('\r');
+        let msg = format!("{}", err.error);
+        let exc = vm.new_exception_msg(
+            vm.ctx.exceptions.indentation_error.to_owned(),
+            msg.clone().into(),
+        );
+        let obj = exc.as_object();
+        let _ = obj.set_attr("lineno", vm.ctx.new_int(err_lc.line.get()), vm);
+        let _ = obj.set_attr("offset", vm.ctx.new_int(err_text.len() as i64 + 1), vm);
+        let _ = obj.set_attr("msg", vm.ctx.new_str(msg), vm);
+        let _ = obj.set_attr("filename", vm.ctx.new_str("<string>"), vm);
+        let _ = obj.set_attr("text", vm.ctx.new_str(err_text), vm);
+        exc
+    }
+
+    /// Split an FSTRING_MIDDLE/TSTRING_MIDDLE token containing `{{`/`}}`
+    /// into multiple unescaped sub-tokens.
+    /// Returns vec of (type, string, start_line, start_col, end_line, end_col).
+    fn split_fstring_middle(
+        raw: &str,
+        token_type: u8,
+        start_line: usize,
+        start_col: usize,
+    ) -> Vec<(u8, String, usize, usize, usize, usize)> {
+        let mut parts = Vec::new();
+        let mut current = String::new();
+        // Track source position (line, col) — these correspond to the
+        // original source positions (with {{ and }} still doubled)
+        let mut cur_line = start_line;
+        let mut cur_col = start_col;
+        // Track the start position of the current accumulating part
+        let mut part_start_line = cur_line;
+        let mut part_start_col = cur_col;
+        let mut chars = raw.chars().peekable();
+
+        // Compute end position of the current accumulated text
+        let end_pos = |current: &str, start_line: usize, start_col: usize| -> (usize, usize) {
+            let mut el = start_line;
+            let mut ec = start_col;
+            for ch in current.chars() {
+                if ch == '\n' {
+                    el += 1;
+                    ec = 0;
+                } else {
+                    ec += ch.len_utf8();
+                }
+            }
+            (el, ec)
+        };
+
+        while let Some(ch) = chars.next() {
+            if ch == '{' && chars.peek() == Some(&'{') {
+                chars.next();
+                current.push('{');
+                cur_col += 2; // skip both {{ in source
+            } else if ch == '}' && chars.peek() == Some(&'}') {
+                chars.next();
+                // Flush accumulated text before }}
+                if !current.is_empty() {
+                    let (el, ec) = end_pos(&current, part_start_line, part_start_col);
+                    parts.push((
+                        token_type,
+                        core::mem::take(&mut current),
+                        part_start_line,
+                        part_start_col,
+                        el,
+                        ec,
+                    ));
+                }
+                // Emit unescaped '}' at source position of }}
+                parts.push((
+                    token_type,
+                    "}".to_string(),
+                    cur_line,
+                    cur_col,
+                    cur_line,
+                    cur_col + 1,
+                ));
+                cur_col += 2; // skip both }} in source
+                part_start_line = cur_line;
+                part_start_col = cur_col;
+            } else {
+                if current.is_empty() {
+                    part_start_line = cur_line;
+                    part_start_col = cur_col;
+                }
+                current.push(ch);
+                if ch == '\n' {
+                    cur_line += 1;
+                    cur_col = 0;
+                } else {
+                    cur_col += ch.len_utf8();
+                }
+            }
+        }
+
+        if !current.is_empty() {
+            let (el, ec) = end_pos(&current, part_start_line, part_start_col);
+            parts.push((token_type, current, part_start_line, part_start_col, el, ec));
+        }
+
+        parts
+    }
+
+    #[allow(clippy::too_many_arguments)]
+    fn make_token_tuple(
+        vm: &VirtualMachine,
+        token_type: u8,
+        string: &str,
+        start_line: usize,
+        start_col: isize,
+        end_line: usize,
+        end_col: isize,
+        line: &str,
+    ) -> PyObjectRef {
+        vm.ctx
+            .new_tuple(vec![
+                token_type.to_pyobject(vm),
+                vm.ctx.new_str(string).into(),
+                vm.ctx
+                    .new_tuple(vec![start_line.to_pyobject(vm), start_col.to_pyobject(vm)])
+                    .into(),
+                vm.ctx
+                    .new_tuple(vec![end_line.to_pyobject(vm), end_col.to_pyobject(vm)])
+                    .into(),
+                vm.ctx.new_str(line).into(),
+            ])
+            .into()
+    }
+
+    #[derive(FromArgs)]
+    pub struct PyTokenizerIterArgs {
+        #[pyarg(positional)]
+        readline: ArgCallable,
+        #[pyarg(named)]
+        extra_tokens: bool,
+        #[pyarg(named, optional)]
+        encoding: Option<rustpython_vm::PyRef<PyStr>>,
+    }
+
+    #[derive(Clone, Debug)]
+    struct TokenizerState {
+        phase: TokenizerPhase,
+    }
+
+    #[derive(Clone, Debug)]
+    enum TokenizerPhase {
+        Reading {
+            source: String,
+        },
+        Yielding {
+            source: String,
+            tokens: Vec<Token>,
+            errors: Vec<ParseError>,
+            index: usize,
+            line_index: LineIndex,
+            need_implicit_nl: bool,
+            /// Pending sub-tokens from FSTRING_MIDDLE splitting
+            pending_fstring_parts: Vec<(u8, String, usize, usize, usize, usize)>,
+            /// Pending empty FSTRING_MIDDLE for format spec nesting:
+            /// (type, line, col, line_str)
+            pending_empty_fstring_middle: Option<(u8, usize, usize, String)>,
+        },
+        Done,
+    }
+
+    const fn token_kind_value(kind: TokenKind) -> u8 {
+        match kind {
+            TokenKind::EndOfFile => 0,
+            TokenKind::Name
+            | TokenKind::For
+            | TokenKind::In
+            | TokenKind::Pass
+            | TokenKind::Class
+            | TokenKind::And
+            | TokenKind::Is
+            | TokenKind::Raise
+            | TokenKind::True
+            | TokenKind::False
+            | TokenKind::Assert
+            | TokenKind::Try
+            | TokenKind::While
+            | TokenKind::Yield
+            | TokenKind::Lambda
+            | TokenKind::None
+            | TokenKind::Not
+            | TokenKind::Or
+            | TokenKind::Break
+            | TokenKind::Continue
+            | TokenKind::Global
+            | TokenKind::Nonlocal
+            | TokenKind::Return
+            | TokenKind::Except
+            | TokenKind::Import
+            | TokenKind::Case
+            | TokenKind::Match
+            | TokenKind::Type
+            | TokenKind::Await
+            | TokenKind::With
+            | TokenKind::Del
+            | TokenKind::Finally
+            | TokenKind::From
+            | TokenKind::Def
+            | TokenKind::If
+            | TokenKind::Else
+            | TokenKind::Elif
+            | TokenKind::As
+            | TokenKind::Async => 1,
+            TokenKind::Int | TokenKind::Complex | TokenKind::Float => 2,
+            TokenKind::String => 3,
+            TokenKind::Newline => 4,
+            TokenKind::NonLogicalNewline => TOKEN_NL,
+            TokenKind::Indent => 5,
+            TokenKind::Dedent => 6,
+            TokenKind::Lpar => 7,
+            TokenKind::Rpar => 8,
+            TokenKind::Lsqb => 9,
+            TokenKind::Rsqb => 10,
+            TokenKind::Colon => 11,
+            TokenKind::Comma => 12,
+            TokenKind::Semi => 13,
+            TokenKind::Plus => 14,
+            TokenKind::Minus => 15,
+            TokenKind::Star => 16,
+            TokenKind::Slash => 17,
+            TokenKind::Vbar => 18,
+            TokenKind::Amper => 19,
+            TokenKind::Less => 20,
+            TokenKind::Greater => 21,
+            TokenKind::Equal => 22,
+            TokenKind::Dot => 23,
+            TokenKind::Percent => 24,
+            TokenKind::Lbrace => 25,
+            TokenKind::Rbrace => 26,
+            TokenKind::EqEqual => 27,
+            TokenKind::NotEqual => 28,
+            TokenKind::LessEqual => 29,
+            TokenKind::GreaterEqual => 30,
+            TokenKind::Tilde => 31,
+            TokenKind::CircumFlex => 32,
+            TokenKind::LeftShift => 33,
+            TokenKind::RightShift => 34,
+            TokenKind::DoubleStar => 35,
+            TokenKind::PlusEqual => 36,
+            TokenKind::MinusEqual => 37,
+            TokenKind::StarEqual => 38,
+            TokenKind::SlashEqual => 39,
+            TokenKind::PercentEqual => 40,
+            TokenKind::AmperEqual => 41,
+            TokenKind::VbarEqual => 42,
+            TokenKind::CircumflexEqual => 43,
+            TokenKind::LeftShiftEqual => 44,
+            TokenKind::RightShiftEqual => 45,
+            TokenKind::DoubleStarEqual => 46,
+            TokenKind::DoubleSlash => 47,
+            TokenKind::DoubleSlashEqual => 48,
+            TokenKind::At => 49,
+            TokenKind::AtEqual => 50,
+            TokenKind::Rarrow => 51,
+            TokenKind::Ellipsis => 52,
+            TokenKind::ColonEqual => 53,
+            TokenKind::Exclamation => 54,
+            TokenKind::FStringStart => 59,
+            TokenKind::FStringMiddle => 60,
+            TokenKind::FStringEnd => 61,
+            TokenKind::Comment => TOKEN_COMMENT,
+            TokenKind::TStringStart => 62,
+            TokenKind::TStringMiddle => 63,
+            TokenKind::TStringEnd => 64,
+            TokenKind::IpyEscapeCommand | TokenKind::Question | TokenKind::Unknown => 67, // ERRORTOKEN
+            TokenKind::Lazy => u8::MAX, // Placeholder: RustPython Doesn't support `lazy imports` yet
+        }
+    }
+}
diff --git a/crates/stdlib/src/array.rs b/crates/stdlib/src/array.rs
index 3f33f23d78d..15a64c6d99c 100644
--- a/crates/stdlib/src/array.rs
+++ b/crates/stdlib/src/array.rs
@@ -19,7 +19,7 @@ mod array {
             builtins::{
                 PositionIterInternal, PyByteArray, PyBytes, PyBytesRef, PyDictRef, PyFloat,
                 PyGenericAlias, PyInt, PyList, PyListRef, PyStr, PyStrRef, PyTupleRef, PyType,
-                PyTypeRef,
+                PyTypeRef, PyUtf8StrRef, builtins_iter,
             },
             class_or_notimplemented,
             convert::{ToPyObject, ToPyResult, TryFromBorrowedObject, TryFromObject},
@@ -35,6 +35,7 @@ mod array {
                 SaturatedSlice, SequenceIndex, SequenceIndexOp, SliceableSequenceMutOp,
                 SliceableSequenceOp,
             },
+            stdlib::_warnings,
             types::{
                 AsBuffer, AsMapping, AsSequence, Comparable, Constructor, IterNext, Iterable,
                 PyComparisonOp, Representable, SelfIter,
@@ -155,6 +156,13 @@ mod array {
                     }
                 }
 
+                fn clear(&mut self) -> PyResult<()>{
+                    match self {
+                        $(ArrayContentType::$n(v) => v.clear(),)*
+                    };
+                    Ok(())
+                }
+
                 fn remove(&mut self, obj: PyObjectRef, vm: &VirtualMachine) -> PyResult<()>{
                     match self {
                         $(ArrayContentType::$n(v) => {
@@ -551,7 +559,7 @@ mod array {
 
     impl ArrayElement for WideChar {
         fn try_into_from_object(vm: &VirtualMachine, obj: PyObjectRef) -> PyResult<Self> {
-            PyStrRef::try_from_object(vm, obj)?
+            PyUtf8StrRef::try_from_object(vm, obj)?
                 .as_str()
                 .chars()
                 .exactly_one()
@@ -617,7 +625,7 @@ mod array {
     #[derive(FromArgs)]
     pub struct ArrayNewArgs {
         #[pyarg(positional)]
-        spec: PyStrRef,
+        spec: PyUtf8StrRef,
         #[pyarg(positional, optional)]
         init: OptionalArg<PyObjectRef>,
     }
@@ -638,6 +646,15 @@ mod array {
                 return Err(vm.new_type_error("array.array() takes no keyword arguments"));
             }
 
+            if spec == 'u' {
+                _warnings::warn(
+                    vm.ctx.exceptions.deprecation_warning,
+                    "The 'u' type code is deprecated and will be removed in Python 3.16".to_owned(),
+                    1,
+                    vm,
+                )?;
+            }
+
             let mut array =
                 ArrayContentType::from_char(spec).map_err(|err| vm.new_value_error(err))?;
 
@@ -681,7 +698,7 @@ mod array {
     }
 
     #[pyclass(
-        flags(BASETYPE),
+        flags(BASETYPE, HAS_WEAKREF),
         with(
             Comparable,
             AsBuffer,
@@ -718,6 +735,11 @@ mod array {
             zelf.try_resizable(vm)?.push(x, vm)
         }
 
+        #[pymethod]
+        fn clear(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<()> {
+            zelf.try_resizable(vm)?.clear()
+        }
+
         #[pymethod]
         fn buffer_info(&self) -> (usize, usize) {
             let array = self.read();
@@ -862,7 +884,7 @@ mod array {
             if not_enough_bytes {
                 Err(vm.new_exception_msg(
                     vm.ctx.exceptions.eof_error.to_owned(),
-                    "read() didn't return enough bytes".to_owned(),
+                    "read() didn't return enough bytes".into(),
                 ))
             } else {
                 Ok(())
@@ -1376,9 +1398,13 @@ mod array {
 
         #[pymethod]
         fn __reduce__(&self, vm: &VirtualMachine) -> PyTupleRef {
-            self.internal
-                .lock()
-                .builtins_iter_reduce(|x| x.clone().into(), vm)
+            let func = builtins_iter(vm);
+            self.internal.lock().reduce(
+                func,
+                |x| x.clone().into(),
+                |vm| vm.ctx.empty_tuple.clone().into(),
+                vm,
+            )
         }
     }
 
@@ -1399,7 +1425,7 @@ mod array {
         #[pyarg(positional)]
         arraytype: PyTypeRef,
         #[pyarg(positional)]
-        typecode: PyStrRef,
+        typecode: PyUtf8StrRef,
         #[pyarg(positional)]
         mformat_code: MachineFormatCode,
         #[pyarg(positional)]
@@ -1542,7 +1568,7 @@ mod array {
         Ok(typ)
     }
 
-    fn check_type_code(spec: PyStrRef, vm: &VirtualMachine) -> PyResult<ArrayContentType> {
+    fn check_type_code(spec: PyUtf8StrRef, vm: &VirtualMachine) -> PyResult<ArrayContentType> {
         let spec = spec.as_str().chars().exactly_one().map_err(|_| {
             vm.new_type_error(
                 "_array_reconstructor() argument 2 must be a unicode character, not str",
diff --git a/crates/stdlib/src/binascii.rs b/crates/stdlib/src/binascii.rs
index ee55d482e4c..9af56d4eea7 100644
--- a/crates/stdlib/src/binascii.rs
+++ b/crates/stdlib/src/binascii.rs
@@ -849,7 +849,7 @@ mod decl {
 struct Base64DecodeError(base64::DecodeError);
 
 fn new_binascii_error(msg: String, vm: &VirtualMachine) -> PyBaseExceptionRef {
-    vm.new_exception_msg(decl::error_type(vm), msg)
+    vm.new_exception_msg(decl::error_type(vm), msg.into())
 }
 
 impl ToPyException for Base64DecodeError {
diff --git a/crates/stdlib/src/blake2.rs b/crates/stdlib/src/blake2.rs
index 5d2e991b929..53687c7027a 100644
--- a/crates/stdlib/src/blake2.rs
+++ b/crates/stdlib/src/blake2.rs
@@ -9,11 +9,11 @@ mod _blake2 {
 
     #[pyfunction]
     fn blake2b(args: BlakeHashArgs, vm: &VirtualMachine) -> PyResult {
-        Ok(local_blake2b(args).into_pyobject(vm))
+        Ok(local_blake2b(args, vm)?.into_pyobject(vm))
     }
 
     #[pyfunction]
     fn blake2s(args: BlakeHashArgs, vm: &VirtualMachine) -> PyResult {
-        Ok(local_blake2s(args).into_pyobject(vm))
+        Ok(local_blake2s(args, vm)?.into_pyobject(vm))
     }
 }
diff --git a/crates/stdlib/src/compression.rs b/crates/stdlib/src/compression.rs
index a857b4e53de..ae47ebbff70 100644
--- a/crates/stdlib/src/compression.rs
+++ b/crates/stdlib/src/compression.rs
@@ -296,6 +296,11 @@ impl<D: Decompressor> DecompressState<D> {
         self.eof
     }
 
+    #[cfg_attr(target_os = "android", allow(dead_code))]
+    pub const fn decompressor(&self) -> &D {
+        &self.decompress
+    }
+
     pub fn unused_data(&self) -> PyBytesRef {
         self.unused_data.clone()
     }
diff --git a/crates/stdlib/src/contextvars.rs b/crates/stdlib/src/contextvars.rs
index 700a94692d5..1fc98edb5a7 100644
--- a/crates/stdlib/src/contextvars.rs
+++ b/crates/stdlib/src/contextvars.rs
@@ -15,7 +15,7 @@ mod _contextvars {
         AsObject, Py, PyObjectRef, PyPayload, PyRef, PyResult, VirtualMachine, atomic_func,
         builtins::{PyGenericAlias, PyList, PyStrRef, PyType, PyTypeRef},
         class::StaticType,
-        common::hash::PyHash,
+        common::{hash::PyHash, wtf8::Wtf8Buf},
         function::{ArgCallable, FuncArgs, OptionalArg},
         protocol::{PyMappingMethods, PySequenceMethods},
         types::{AsMapping, AsSequence, Constructor, Hashable, Iterable, Representable},
@@ -26,7 +26,7 @@ mod _contextvars {
     };
     use crossbeam_utils::atomic::AtomicCell;
     use indexmap::IndexMap;
-    use std::sync::LazyLock;
+    use rustpython_common::lock::LazyLock;
 
     // TODO: Real hamt implementation
     type Hamt = IndexMap<PyRef<ContextVar>, PyObjectRef, ahash::RandomState>;
@@ -333,7 +333,7 @@ mod _contextvars {
             if vars.swap_remove(zelf).is_none() {
                 // TODO:
                 // PyErr_SetObject(PyExc_LookupError, (PyObject *)var);
-                let msg = zelf.as_object().repr(vm)?.as_str().to_owned();
+                let msg = zelf.as_object().repr(vm)?.as_wtf8().to_owned();
                 return Err(vm.new_lookup_error(msg));
             }
 
@@ -409,7 +409,7 @@ mod _contextvars {
                 default.clone()
             } else {
                 let msg = zelf.as_object().repr(vm)?;
-                return Err(vm.new_lookup_error(msg.as_str().to_owned()));
+                return Err(vm.new_lookup_error(msg.as_wtf8().to_owned()));
             };
             Ok(Some(value))
         }
@@ -611,11 +611,14 @@ mod _contextvars {
 
     impl Representable for ContextToken {
         #[inline]
-        fn repr_str(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<String> {
+        fn repr_wtf8(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<Wtf8Buf> {
             let used = if zelf.used.get() { " used" } else { "" };
-            let var = Representable::repr_str(&zelf.var, vm)?;
+            let var = Representable::repr_wtf8(&zelf.var, vm)?;
             let ptr = zelf.as_object().get_id() as *const u8;
-            Ok(format!("<Token{used} var={var} at {ptr:p}>"))
+            let mut result = Wtf8Buf::from(format!("<Token{used} var="));
+            result.push_wtf8(&var);
+            result.push_str(&format!(" at {ptr:p}>"));
+            Ok(result)
         }
     }
 
diff --git a/crates/stdlib/src/csv.rs b/crates/stdlib/src/csv.rs
index 7c89ebbba66..a1147fd1cbb 100644
--- a/crates/stdlib/src/csv.rs
+++ b/crates/stdlib/src/csv.rs
@@ -6,7 +6,7 @@ mod _csv {
     use crate::vm::{
         AsObject, Py, PyObject, PyObjectRef, PyPayload, PyRef, PyResult, TryFromObject,
         VirtualMachine,
-        builtins::{PyBaseExceptionRef, PyInt, PyNone, PyStr, PyType, PyTypeRef},
+        builtins::{PyBaseExceptionRef, PyInt, PyNone, PyStr, PyType, PyTypeRef, PyUtf8StrRef},
         function::{ArgIterable, ArgumentError, FromArgs, FuncArgs, OptionalArg},
         protocol::{PyIter, PyIterReturn},
         raise_if_stop,
@@ -16,9 +16,9 @@ mod _csv {
     use csv_core::Terminator;
     use itertools::{self, Itertools};
     use parking_lot::Mutex;
-    use rustpython_vm::match_class;
+    use rustpython_common::{lock::LazyLock, wtf8::Wtf8Buf};
+    use rustpython_vm::{match_class, sliceable::SliceableSequenceOp};
     use std::collections::HashMap;
-    use std::sync::LazyLock;
 
     #[pyattr]
     const QUOTE_MINIMAL: i32 = QuoteStyle::Minimal as i32;
@@ -50,8 +50,8 @@ mod _csv {
     });
     static GLOBAL_FIELD_LIMIT: LazyLock<Mutex<isize>> = LazyLock::new(|| Mutex::new(131072));
 
-    fn new_csv_error(vm: &VirtualMachine, msg: String) -> PyBaseExceptionRef {
-        vm.new_exception_msg(super::_csv::error(vm), msg)
+    fn new_csv_error(vm: &VirtualMachine, msg: impl Into<Wtf8Buf>) -> PyBaseExceptionRef {
+        vm.new_exception_msg(super::_csv::error(vm), msg.into())
     }
 
     #[pyattr]
@@ -138,35 +138,41 @@ mod _csv {
         } else {
             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"#;
-                        vm.new_type_error(msg.to_owned())
+                    Ok(s.as_bytes().iter().copied().exactly_one().map_err(|_| {
+                        vm.new_type_error(format!(
+                            r#""delimiter" must be a unicode character, not a string of length {}"#,
+                            s.len()
+                        ))
                     })?)
                 }
                 attr => {
-                    let msg = format!("\"delimiter\" must be string, not {}", attr.class());
+                    let msg = format!(
+                        r#""delimiter" must be a unicode character, not {}"#,
+                        attr.class()
+                    );
                     Err(vm.new_type_error(msg))
                 }
             })
         }
     }
+
     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(|_| {
-                    vm.new_exception_msg(
-                        super::_csv::error(vm),
-                        r#""quotechar" must be a 1-character string"#.to_owned(),
-                    )
+                Ok(Some(s.as_bytes().iter().copied().exactly_one().map_err(|_| {
+                    new_csv_error(vm, format!(r#""quotechar" must be a unicode character or None, not a string of length {}"#, s.len()))
                 })?))
             }
             _n @ PyNone => {
                 Ok(None)
             }
-            _ => {
-                Err(vm.new_exception_msg(
-                    super::_csv::error(vm),
-                    r#""quotechar" must be string or None, not int"#.to_owned(),
+            attr => {
+                Err(new_csv_error(
+                    vm,
+                    format!(
+                        r#""quotechar" must be a unicode character or None, not {}"#,
+                        attr.class()
+                    ),
                 ))
             }
         })
@@ -174,10 +180,10 @@ mod _csv {
     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(|_| {
-                    vm.new_exception_msg(
-                        super::_csv::error(vm),
-                        r#""escapechar" must be a 1-character string"#.to_owned(),
+                Ok(Some(s.as_bytes().iter().copied().exactly_one().map_err(|_| {
+                    new_csv_error(
+                        vm,
+                        format!(r#""escapechar" must be a unicode character or None, not a string of length {}"#, s.len()),
                     )
                 })?))
             }
@@ -186,7 +192,7 @@ mod _csv {
             }
             attr => {
                 let msg = format!(
-                    "\"escapechar\" must be string or None, not {}",
+                    r#""escapechar" must be a unicode character or None, not {}"#,
                     attr.class()
                 );
                 Err(vm.new_type_error(msg.to_owned()))
@@ -204,15 +210,14 @@ mod _csv {
                     // only capture the first character
                     csv_core::Terminator::Any(*t)
                 } else {
-                    return Err(vm.new_exception_msg(
-                        super::_csv::error(vm),
-                        r#""lineterminator" must be a string"#.to_owned(),
-                    ));
+                    return Err(new_csv_error(vm, r#""lineterminator" must be a string"#));
                 })
             }
-            _ => {
-                let msg = "\"lineterminator\" must be a string".to_string();
-                Err(vm.new_type_error(msg.to_owned()))
+            attr => {
+                Err(vm.new_type_error(format!(
+                    r#""lineterminator" must be a string, not {}"#,
+                    attr.class()
+                )))
             }
         })
     }
@@ -225,7 +230,7 @@ mod _csv {
                 })?)
             }
             attr => {
-                let msg = format!("\"quoting\" must be string or None, not {}", attr.class());
+                let msg = format!(r#""quoting" must be string or None, not {}"#, attr.class());
                 Err(vm.new_type_error(msg.to_owned()))
             }
         })
@@ -267,9 +272,10 @@ mod _csv {
         mut _rest: FuncArgs,
         vm: &VirtualMachine,
     ) -> PyResult<()> {
-        let Some(name) = name.downcast_ref::<PyStr>() else {
-            return Err(vm.new_type_error("argument 0 must be a string"));
-        };
+        let name = name
+            .downcast::<PyStr>()
+            .map_err(|_| vm.new_type_error("argument 0 must be a string"))?;
+        let name: PyUtf8StrRef = name.try_into_utf8(vm)?;
         let dialect = match dialect {
             OptionalArg::Present(d) => PyDialect::try_from_object(vm, d)
                 .map_err(|_| vm.new_type_error("argument 1 must be a dialect object"))?,
@@ -288,17 +294,18 @@ mod _csv {
         mut _rest: FuncArgs,
         vm: &VirtualMachine,
     ) -> PyResult<PyDialect> {
-        let Some(name) = name.downcast_ref::<PyStr>() else {
-            return Err(vm.new_exception_msg(
-                super::_csv::error(vm),
-                format!("argument 0 must be a string, not '{}'", name.class()),
-            ));
-        };
+        let name = name.downcast::<PyStr>().map_err(|obj| {
+            new_csv_error(
+                vm,
+                format!("argument 0 must be a string, not '{}'", obj.class()),
+            )
+        })?;
+        let name: PyUtf8StrRef = name.try_into_utf8(vm)?;
         let g = GLOBAL_HASHMAP.lock();
         if let Some(dialect) = g.get(name.as_str()) {
             return Ok(*dialect);
         }
-        Err(vm.new_exception_msg(super::_csv::error(vm), "unknown dialect".to_string()))
+        Err(new_csv_error(vm, "unknown dialect"))
     }
 
     #[pyfunction]
@@ -307,17 +314,18 @@ mod _csv {
         mut _rest: FuncArgs,
         vm: &VirtualMachine,
     ) -> PyResult<()> {
-        let Some(name) = name.downcast_ref::<PyStr>() else {
-            return Err(vm.new_exception_msg(
-                super::_csv::error(vm),
-                format!("argument 0 must be a string, not '{}'", name.class()),
-            ));
-        };
+        let name = name.downcast::<PyStr>().map_err(|obj| {
+            new_csv_error(
+                vm,
+                format!("argument 0 must be a string, not '{}'", obj.class()),
+            )
+        })?;
+        let name: PyUtf8StrRef = name.try_into_utf8(vm)?;
         let mut g = GLOBAL_HASHMAP.lock();
         if let Some(_removed) = g.remove(name.as_str()) {
             return Ok(());
         }
-        Err(vm.new_exception_msg(super::_csv::error(vm), "unknown dialect".to_string()))
+        Err(new_csv_error(vm, "unknown dialect"))
     }
 
     #[pyfunction]
@@ -526,7 +534,8 @@ mod _csv {
     ) -> Result<DialectItem, ArgumentError> {
         match_class!(match obj {
             s @ PyStr => {
-                Ok(DialectItem::Str(s.as_str().to_string()))
+                let s = s.try_into_utf8(vm).map_err(ArgumentError::Exception)?;
+                Ok(DialectItem::Str(s.as_str().to_owned()))
             }
             PyNone => {
                 Err(ArgumentError::InvalidKeywordArgument("dialect".to_string()))
@@ -570,10 +579,11 @@ mod _csv {
 
             if let Some(escapechar) = args.kwargs.swap_remove("escapechar") {
                 res.escapechar = match_class!(match escapechar {
-                    s @ PyStr => Some(s.as_str().bytes().exactly_one().map_err(|_| {
-                        let msg = r#""escapechar" must be a 1-character string"#;
-                        vm.new_type_error(msg.to_owned())
-                    })?),
+                    s @ PyStr =>
+                        Some(s.as_bytes().iter().copied().exactly_one().map_err(|_| {
+                            let msg = r#""escapechar" must be a 1-character string"#;
+                            vm.new_type_error(msg.to_owned())
+                        })?),
                     _ => None,
                 })
             };
@@ -615,10 +625,12 @@ mod _csv {
             };
             if let Some(quotechar) = args.kwargs.swap_remove("quotechar") {
                 res.quotechar = match_class!(match quotechar {
-                    s @ PyStr => Some(Some(s.as_str().bytes().exactly_one().map_err(|_| {
-                        let msg = r#""quotechar" must be a 1-character string"#;
-                        vm.new_type_error(msg.to_owned())
-                    })?)),
+                    s @ PyStr => Some(Some(s.as_bytes().iter().copied().exactly_one().map_err(
+                        |_| {
+                            let msg = r#""quotechar" must be a 1-character string"#;
+                            vm.new_type_error(msg.to_owned())
+                        }
+                    )?)),
                     PyNone => {
                         if let Some(QuoteStyle::All) = res.quoting {
                             let msg = "quotechar must be set if quoting enabled";
diff --git a/crates/stdlib/src/faulthandler.rs b/crates/stdlib/src/faulthandler.rs
index 6a2a0933404..9c4373c312e 100644
--- a/crates/stdlib/src/faulthandler.rs
+++ b/crates/stdlib/src/faulthandler.rs
@@ -7,7 +7,6 @@ mod decl {
         PyObjectRef, PyResult, VirtualMachine,
         frame::Frame,
         function::{ArgIntoFloat, OptionalArg},
-        py_io::Write,
     };
     use alloc::sync::Arc;
     use core::sync::atomic::{AtomicBool, AtomicI32, Ordering};
@@ -66,11 +65,7 @@ mod decl {
     #[cfg(windows)]
     const FAULTHANDLER_NSIGNALS: usize = 4;
 
-    // CPython uses static arrays for signal handlers which requires mutable static access.
-    // This is safe because:
-    // 1. Signal handlers run in a single-threaded context (from the OS perspective)
-    // 2. FAULTHANDLER_HANDLERS is only modified during enable/disable operations
-    // 3. This matches CPython's faulthandler.c implementation
+    // Signal handlers use mutable statics matching faulthandler.c implementation.
     #[cfg(unix)]
     static mut FAULTHANDLER_HANDLERS: [FaultHandler; FAULTHANDLER_NSIGNALS] = [
         FaultHandler::new(libc::SIGBUS, "Bus error"),
@@ -101,6 +96,9 @@ mod decl {
         all_threads: AtomicBool::new(true),
     };
 
+    #[cfg(feature = "threading")]
+    type ThreadFrameSlot = Arc<rustpython_vm::vm::thread::ThreadSlot>;
+
     // Watchdog thread state for dump_traceback_later
     struct WatchdogState {
         cancel: bool,
@@ -109,51 +107,32 @@ mod decl {
         repeat: bool,
         exit: bool,
         header: String,
+        #[cfg(feature = "threading")]
+        thread_frame_slots: Vec<(u64, ThreadFrameSlot)>,
     }
 
     type WatchdogHandle = Arc<(Mutex<WatchdogState>, Condvar)>;
     static WATCHDOG: Mutex<Option<WatchdogHandle>> = Mutex::new(None);
 
-    // Frame snapshot for signal-safe traceback (RustPython-specific)
-
-    /// Frame information snapshot for signal-safe access
-    #[cfg(any(unix, windows))]
-    #[derive(Clone, Copy)]
-    struct FrameSnapshot {
-        filename: [u8; 256],
-        filename_len: usize,
-        lineno: u32,
-        funcname: [u8; 128],
-        funcname_len: usize,
-    }
+    // Signal-safe output functions
 
+    // PUTS macro
     #[cfg(any(unix, windows))]
-    impl FrameSnapshot {
-        const EMPTY: Self = Self {
-            filename: [0; 256],
-            filename_len: 0,
-            lineno: 0,
-            funcname: [0; 128],
-            funcname_len: 0,
+    fn puts(fd: i32, s: &str) {
+        let _ = unsafe {
+            #[cfg(windows)]
+            {
+                libc::write(fd, s.as_ptr() as *const libc::c_void, s.len() as u32)
+            }
+            #[cfg(not(windows))]
+            {
+                libc::write(fd, s.as_ptr() as *const libc::c_void, s.len())
+            }
         };
     }
 
     #[cfg(any(unix, windows))]
-    const MAX_SNAPSHOT_FRAMES: usize = 100;
-
-    /// Signal-safe global storage for frame snapshots
-    #[cfg(any(unix, windows))]
-    static mut FRAME_SNAPSHOTS: [FrameSnapshot; MAX_SNAPSHOT_FRAMES] =
-        [FrameSnapshot::EMPTY; MAX_SNAPSHOT_FRAMES];
-    #[cfg(any(unix, windows))]
-    static SNAPSHOT_COUNT: core::sync::atomic::AtomicUsize =
-        core::sync::atomic::AtomicUsize::new(0);
-
-    // Signal-safe output functions
-
-    // PUTS macro
-    #[cfg(any(unix, windows))]
-    fn puts(fd: i32, s: &str) {
+    fn puts_bytes(fd: i32, s: &[u8]) {
         let _ = unsafe {
             #[cfg(windows)]
             {
@@ -235,59 +214,69 @@ mod decl {
 
     // write_thread_id (traceback.c:1240-1256)
     #[cfg(any(unix, windows))]
-    fn write_thread_id(fd: i32, is_current: bool) {
+    fn write_thread_id(fd: i32, thread_id: u64, is_current: bool) {
         if is_current {
-            puts(fd, "Current thread 0x");
+            puts(fd, "Current thread ");
         } else {
-            puts(fd, "Thread 0x");
+            puts(fd, "Thread ");
         }
-        let thread_id = current_thread_id();
-        // Use appropriate width based on platform pointer size
         dump_hexadecimal(fd, thread_id, core::mem::size_of::<usize>() * 2);
         puts(fd, " (most recent call first):\n");
     }
 
-    // dump_frame (traceback.c:1037-1087)
+    /// Dump the current thread's live frame chain to fd (signal-safe).
+    /// Walks the `Frame.previous` pointer chain starting from the
+    /// thread-local current frame pointer.
     #[cfg(any(unix, windows))]
-    fn dump_frame(fd: i32, filename: &[u8], lineno: u32, funcname: &[u8]) {
-        puts(fd, "  File \"");
-        let _ = unsafe {
-            #[cfg(windows)]
-            {
-                libc::write(
-                    fd,
-                    filename.as_ptr() as *const libc::c_void,
-                    filename.len() as u32,
-                )
-            }
-            #[cfg(not(windows))]
-            {
-                libc::write(fd, filename.as_ptr() as *const libc::c_void, filename.len())
+    fn dump_live_frames(fd: i32) {
+        const MAX_FRAME_DEPTH: usize = 100;
+
+        let mut frame_ptr = crate::vm::vm::thread::get_current_frame();
+        if frame_ptr.is_null() {
+            puts(fd, "  <no Python frame>\n");
+            return;
+        }
+        let mut depth = 0;
+        while !frame_ptr.is_null() && depth < MAX_FRAME_DEPTH {
+            let frame = unsafe { &*frame_ptr };
+            dump_frame_from_raw(fd, frame);
+            frame_ptr = frame.previous_frame();
+            depth += 1;
+        }
+        if depth >= MAX_FRAME_DEPTH && !frame_ptr.is_null() {
+            puts(fd, "  ...\n");
+        }
+    }
+
+    /// Dump a single frame's info to fd (signal-safe), reading live data.
+    #[cfg(any(unix, windows))]
+    fn dump_frame_from_raw(fd: i32, frame: &Frame) {
+        let filename = frame.code.source_path().as_str();
+        let funcname = frame.code.obj_name.as_str();
+        let lasti = frame.lasti();
+        let lineno = if lasti == 0 {
+            frame.code.first_line_number.map(|n| n.get()).unwrap_or(1) as u32
+        } else {
+            let idx = (lasti as usize).saturating_sub(1);
+            if idx < frame.code.locations.len() {
+                frame.code.locations[idx].0.line.get() as u32
+            } else {
+                frame.code.first_line_number.map(|n| n.get()).unwrap_or(0) as u32
             }
         };
+
+        puts(fd, "  File \"");
+        dump_ascii(fd, filename);
         puts(fd, "\", line ");
         dump_decimal(fd, lineno as usize);
         puts(fd, " in ");
-        let _ = unsafe {
-            #[cfg(windows)]
-            {
-                libc::write(
-                    fd,
-                    funcname.as_ptr() as *const libc::c_void,
-                    funcname.len() as u32,
-                )
-            }
-            #[cfg(not(windows))]
-            {
-                libc::write(fd, funcname.as_ptr() as *const libc::c_void, funcname.len())
-            }
-        };
+        dump_ascii(fd, funcname);
         puts(fd, "\n");
     }
 
-    // faulthandler_dump_traceback
+    // faulthandler_dump_traceback (signal-safe, for fatal errors)
     #[cfg(any(unix, windows))]
-    fn faulthandler_dump_traceback(fd: i32, _all_threads: bool) {
+    fn faulthandler_dump_traceback(fd: i32, all_threads: bool) {
         static REENTRANT: AtomicBool = AtomicBool::new(false);
 
         if REENTRANT.swap(true, Ordering::SeqCst) {
@@ -295,76 +284,85 @@ mod decl {
         }
 
         // Write thread header
-        write_thread_id(fd, true);
-
-        // Try to dump traceback from snapshot
-        let count = SNAPSHOT_COUNT.load(Ordering::Acquire);
-        if count > 0 {
-            // Using index access instead of iterator because FRAME_SNAPSHOTS is static mut
-            #[allow(clippy::needless_range_loop)]
-            for i in 0..count {
-                unsafe {
-                    let snap = &FRAME_SNAPSHOTS[i];
-                    if snap.filename_len > 0 {
-                        dump_frame(
-                            fd,
-                            &snap.filename[..snap.filename_len],
-                            snap.lineno,
-                            &snap.funcname[..snap.funcname_len],
-                        );
-                    }
-                }
-            }
+        if all_threads {
+            write_thread_id(fd, current_thread_id(), true);
         } else {
-            puts(fd, "  <no Python frame>\n");
+            puts(fd, "Stack (most recent call first):\n");
         }
 
+        dump_live_frames(fd);
+
         REENTRANT.store(false, Ordering::SeqCst);
     }
 
-    const MAX_FUNCTION_NAME_LEN: usize = 500;
+    /// MAX_STRING_LENGTH in traceback.c
+    const MAX_STRING_LENGTH: usize = 500;
 
-    fn truncate_name(name: &str) -> String {
-        if name.len() > MAX_FUNCTION_NAME_LEN {
-            format!("{}...", &name[..MAX_FUNCTION_NAME_LEN])
-        } else {
-            name.to_string()
+    /// Truncate a UTF-8 string to at most `max_bytes` without splitting a
+    /// multi-byte codepoint. Signal-safe (no allocation, no panic).
+    #[cfg(any(unix, windows))]
+    fn safe_truncate(s: &str, max_bytes: usize) -> (&str, bool) {
+        if s.len() <= max_bytes {
+            return (s, false);
+        }
+        let mut end = max_bytes;
+        while end > 0 && !s.is_char_boundary(end) {
+            end -= 1;
         }
+        (&s[..end], true)
     }
 
-    fn get_file_for_output(
-        file: OptionalArg<PyObjectRef>,
-        vm: &VirtualMachine,
-    ) -> PyResult<PyObjectRef> {
-        match file {
-            OptionalArg::Present(f) => {
-                // If it's an integer, we can't use it directly as a file object
-                // For now, just return it and let the caller handle it
-                Ok(f)
-            }
-            OptionalArg::Missing => {
-                // Get sys.stderr
-                let stderr = vm.sys_module.get_attr("stderr", vm)?;
-                if vm.is_none(&stderr) {
-                    return Err(vm.new_runtime_error("sys.stderr is None".to_owned()));
-                }
-                Ok(stderr)
-            }
+    /// Write a string to fd, truncating with "..." if it exceeds MAX_STRING_LENGTH.
+    /// Mirrors `_Py_DumpASCII` truncation behavior.
+    #[cfg(any(unix, windows))]
+    fn dump_ascii(fd: i32, s: &str) {
+        let (truncated_s, was_truncated) = safe_truncate(s, MAX_STRING_LENGTH);
+        puts(fd, truncated_s);
+        if was_truncated {
+            puts(fd, "...");
         }
     }
 
-    fn collect_frame_info(frame: &crate::vm::PyRef<Frame>) -> String {
-        let func_name = truncate_name(frame.code.obj_name.as_str());
-        // If lasti is 0, execution hasn't started yet - use first line number or 1
-        let line = if frame.lasti() == 0 {
-            frame.code.first_line_number.map(|n| n.get()).unwrap_or(1)
+    /// Write a frame's info to an fd using signal-safe I/O.
+    #[cfg(any(unix, windows))]
+    fn dump_frame_from_ref(fd: i32, frame: &crate::vm::Py<Frame>) {
+        let funcname = frame.code.obj_name.as_str();
+        let filename = frame.code.source_path().as_str();
+        let lineno = if frame.lasti() == 0 {
+            frame.code.first_line_number.map(|n| n.get()).unwrap_or(1) as u32
         } else {
-            frame.current_location().line.get()
+            frame.current_location().line.get() as u32
         };
-        format!(
-            "  File \"{}\", line {} in {}",
-            frame.code.source_path, line, func_name
-        )
+
+        puts(fd, "  File \"");
+        dump_ascii(fd, filename);
+        puts(fd, "\", line ");
+        dump_decimal(fd, lineno as usize);
+        puts(fd, " in ");
+        dump_ascii(fd, funcname);
+        puts(fd, "\n");
+    }
+
+    /// Dump traceback for a thread given its frame stack (for cross-thread dumping).
+    /// # Safety
+    /// Each `FramePtr` must point to a live frame (caller holds the Mutex).
+    #[cfg(all(any(unix, windows), feature = "threading"))]
+    fn dump_traceback_thread_frames(
+        fd: i32,
+        thread_id: u64,
+        is_current: bool,
+        frames: &[rustpython_vm::vm::FramePtr],
+    ) {
+        write_thread_id(fd, thread_id, is_current);
+
+        if frames.is_empty() {
+            puts(fd, "  <no Python frame>\n");
+        } else {
+            for fp in frames.iter().rev() {
+                // SAFETY: caller holds the Mutex, so the owning thread can't pop.
+                dump_frame_from_ref(fd, unsafe { fp.as_ref() });
+            }
+        }
     }
 
     #[derive(FromArgs)]
@@ -377,22 +375,71 @@ mod decl {
 
     #[pyfunction]
     fn dump_traceback(args: DumpTracebackArgs, vm: &VirtualMachine) -> PyResult<()> {
-        let _ = args.all_threads; // TODO: implement all_threads support
-
-        let file = get_file_for_output(args.file, vm)?;
+        let fd = get_fd_from_file_opt(args.file, vm)?;
 
-        // Collect frame info first to avoid RefCell borrow conflict
-        let frame_lines: Vec<String> = vm.frames.borrow().iter().map(collect_frame_info).collect();
+        #[cfg(any(unix, windows))]
+        {
+            if args.all_threads {
+                dump_all_threads(fd, vm);
+            } else {
+                puts(fd, "Stack (most recent call first):\n");
+                let frames = vm.frames.borrow();
+                for fp in frames.iter().rev() {
+                    // SAFETY: the frame is alive while it's in the Vec
+                    dump_frame_from_ref(fd, unsafe { fp.as_ref() });
+                }
+            }
+        }
 
-        // Now write to file (in reverse order - most recent call first)
-        let mut writer = crate::vm::py_io::PyWriter(file, vm);
-        writeln!(writer, "Stack (most recent call first):")?;
-        for line in frame_lines.iter().rev() {
-            writeln!(writer, "{}", line)?;
+        #[cfg(not(any(unix, windows)))]
+        {
+            let _ = (fd, args.all_threads);
         }
+
         Ok(())
     }
 
+    /// Dump tracebacks of all threads.
+    #[cfg(any(unix, windows))]
+    fn dump_all_threads(fd: i32, vm: &VirtualMachine) {
+        // Get all threads' frame stacks from the shared registry
+        #[cfg(feature = "threading")]
+        {
+            let current_tid = rustpython_vm::stdlib::_thread::get_ident();
+            let registry = vm.state.thread_frames.lock();
+
+            // First dump non-current threads, then current thread last
+            for (&tid, slot) in registry.iter() {
+                if tid == current_tid {
+                    continue;
+                }
+                let frames_guard = slot.frames.lock();
+                dump_traceback_thread_frames(fd, tid, false, &frames_guard);
+                puts(fd, "\n");
+            }
+
+            // Now dump current thread (use vm.frames for most up-to-date data)
+            write_thread_id(fd, current_tid, true);
+            let frames = vm.frames.borrow();
+            if frames.is_empty() {
+                puts(fd, "  <no Python frame>\n");
+            } else {
+                for fp in frames.iter().rev() {
+                    dump_frame_from_ref(fd, unsafe { fp.as_ref() });
+                }
+            }
+        }
+
+        #[cfg(not(feature = "threading"))]
+        {
+            write_thread_id(fd, current_thread_id(), true);
+            let frames = vm.frames.borrow();
+            for fp in frames.iter().rev() {
+                dump_frame_from_ref(fd, unsafe { fp.as_ref() });
+            }
+        }
+    }
+
     #[derive(FromArgs)]
     #[allow(unused)]
     struct EnableArgs {
@@ -416,7 +463,7 @@ mod decl {
 
         // Install signal handlers
         if !faulthandler_enable_internal() {
-            return Err(vm.new_runtime_error("Failed to enable faulthandler".to_owned()));
+            return Err(vm.new_runtime_error("Failed to enable faulthandler"));
         }
 
         Ok(())
@@ -464,9 +511,8 @@ mod decl {
                 .find(|h| h.signum == signum)
         };
 
-        // faulthandler_fatal_error
         if let Some(h) = handler {
-            // Disable handler first (restores previous)
+            // Disable handler (restores previous)
             unsafe {
                 faulthandler_disable_fatal_handler(h);
             }
@@ -480,18 +526,24 @@ mod decl {
             puts(fd, "\n\n");
         }
 
-        // faulthandler_dump_traceback
         let all_threads = FATAL_ERROR.all_threads.load(Ordering::Relaxed);
         faulthandler_dump_traceback(fd, all_threads);
 
-        // restore errno
         set_errno(save_errno);
 
-        // raise
-        // Called immediately thanks to SA_NODEFER flag
+        // Reset to default handler and re-raise to ensure process terminates.
+        // We cannot just restore the previous handler because Rust's runtime
+        // may have installed its own SIGSEGV handler (for stack overflow detection)
+        // that doesn't terminate the process on software-raised signals.
         unsafe {
+            libc::signal(signum, libc::SIG_DFL);
             libc::raise(signum);
         }
+
+        // Fallback if raise() somehow didn't terminate the process
+        unsafe {
+            libc::_exit(1);
+        }
     }
 
     // faulthandler_fatal_error for Windows
@@ -529,14 +581,84 @@ mod decl {
 
         set_errno(save_errno);
 
-        // On Windows, don't explicitly call the previous handler for SIGSEGV
-        if signum == libc::SIGSEGV {
-            return;
-        }
-
         unsafe {
+            libc::signal(signum, libc::SIG_DFL);
             libc::raise(signum);
         }
+
+        // Fallback
+        std::process::exit(1);
+    }
+
+    // Windows vectored exception handler (faulthandler.c:417-480)
+    #[cfg(windows)]
+    static EXC_HANDLER: core::sync::atomic::AtomicUsize = core::sync::atomic::AtomicUsize::new(0);
+
+    #[cfg(windows)]
+    fn faulthandler_ignore_exception(code: u32) -> bool {
+        // bpo-30557: ignore exceptions which are not errors
+        if (code & 0x80000000) == 0 {
+            return true;
+        }
+        // bpo-31701: ignore MSC and COM exceptions
+        if code == 0xE06D7363 || code == 0xE0434352 {
+            return true;
+        }
+        false
+    }
+
+    #[cfg(windows)]
+    unsafe extern "system" fn faulthandler_exc_handler(
+        exc_info: *mut windows_sys::Win32::System::Diagnostics::Debug::EXCEPTION_POINTERS,
+    ) -> i32 {
+        const EXCEPTION_CONTINUE_SEARCH: i32 = 0;
+
+        if !FATAL_ERROR.enabled.load(Ordering::Relaxed) {
+            return EXCEPTION_CONTINUE_SEARCH;
+        }
+
+        let record = unsafe { &*(*exc_info).ExceptionRecord };
+        let code = record.ExceptionCode as u32;
+
+        if faulthandler_ignore_exception(code) {
+            return EXCEPTION_CONTINUE_SEARCH;
+        }
+
+        let fd = FATAL_ERROR.fd.load(Ordering::Relaxed);
+
+        puts(fd, "Windows fatal exception: ");
+        match code {
+            0xC0000005 => puts(fd, "access violation"),
+            0xC000008C => puts(fd, "float divide by zero"),
+            0xC0000091 => puts(fd, "float overflow"),
+            0xC0000094 => puts(fd, "int divide by zero"),
+            0xC0000095 => puts(fd, "integer overflow"),
+            0xC0000006 => puts(fd, "page error"),
+            0xC00000FD => puts(fd, "stack overflow"),
+            0xC000001D => puts(fd, "illegal instruction"),
+            _ => {
+                puts(fd, "code ");
+                dump_hexadecimal(fd, code as u64, 8);
+            }
+        }
+        puts(fd, "\n\n");
+
+        // Disable SIGSEGV handler for access violations to avoid double output
+        if code == 0xC0000005 {
+            unsafe {
+                for handler in FAULTHANDLER_HANDLERS.iter_mut() {
+                    if handler.signum == libc::SIGSEGV {
+                        faulthandler_disable_fatal_handler(handler);
+                        break;
+                    }
+                }
+            }
+        }
+
+        let all_threads = FATAL_ERROR.all_threads.load(Ordering::Relaxed);
+        faulthandler_dump_traceback(fd, all_threads);
+
+        EXCEPTION_CONTINUE_SEARCH
     }
 
     // faulthandler_enable
@@ -595,6 +717,14 @@ mod decl {
             }
         }
 
+        // Register Windows vectored exception handler
+        #[cfg(windows)]
+        {
+            use windows_sys::Win32::System::Diagnostics::Debug::AddVectoredExceptionHandler;
+            let h = unsafe { AddVectoredExceptionHandler(1, Some(faulthandler_exc_handler)) };
+            EXC_HANDLER.store(h as usize, Ordering::Relaxed);
+        }
+
         FATAL_ERROR.enabled.store(true, Ordering::Relaxed);
         true
     }
@@ -611,6 +741,18 @@ mod decl {
                 faulthandler_disable_fatal_handler(handler);
             }
         }
+
+        // Remove Windows vectored exception handler
+        #[cfg(windows)]
+        {
+            use windows_sys::Win32::System::Diagnostics::Debug::RemoveVectoredExceptionHandler;
+            let h = EXC_HANDLER.swap(0, Ordering::Relaxed);
+            if h != 0 {
+                unsafe {
+                    RemoveVectoredExceptionHandler(h as *mut core::ffi::c_void);
+                }
+            }
+        }
     }
 
     #[cfg(not(any(unix, windows)))]
@@ -646,22 +788,21 @@ mod decl {
         let hour = min / 60;
         let min = min % 60;
 
+        // Match Python's timedelta str format: H:MM:SS.ffffff (no leading zero for hours)
         if us != 0 {
-            format!("Timeout ({:02}:{:02}:{:02}.{:06})!\n", hour, min, sec, us)
+            format!("Timeout ({}:{:02}:{:02}.{:06})!\n", hour, min, sec, us)
         } else {
-            format!("Timeout ({:02}:{:02}:{:02})!\n", hour, min, sec)
+            format!("Timeout ({}:{:02}:{:02})!\n", hour, min, sec)
         }
     }
 
     fn get_fd_from_file_opt(file: OptionalArg<PyObjectRef>, vm: &VirtualMachine) -> PyResult<i32> {
         match file {
-            OptionalArg::Present(f) => {
+            OptionalArg::Present(f) if !vm.is_none(&f) => {
                 // Check if it's an integer (file descriptor)
                 if let Ok(fd) = f.try_to_value::<i32>(vm) {
                     if fd < 0 {
-                        return Err(
-                            vm.new_value_error("file is not a valid file descriptor".to_owned())
-                        );
+                        return Err(vm.new_value_error("file is not a valid file descriptor"));
                     }
                     return Ok(fd);
                 }
@@ -669,19 +810,17 @@ mod decl {
                 let fileno = vm.call_method(&f, "fileno", ())?;
                 let fd: i32 = fileno.try_to_value(vm)?;
                 if fd < 0 {
-                    return Err(
-                        vm.new_value_error("file is not a valid file descriptor".to_owned())
-                    );
+                    return Err(vm.new_value_error("file is not a valid file descriptor"));
                 }
                 // Try to flush the file
                 let _ = vm.call_method(&f, "flush", ());
                 Ok(fd)
             }
-            OptionalArg::Missing => {
-                // Get sys.stderr
+            _ => {
+                // file=None or file not passed: fall back to sys.stderr
                 let stderr = vm.sys_module.get_attr("stderr", vm)?;
                 if vm.is_none(&stderr) {
-                    return Err(vm.new_runtime_error("sys.stderr is None".to_owned()));
+                    return Err(vm.new_runtime_error("sys.stderr is None"));
                 }
                 let fileno = vm.call_method(&stderr, "fileno", ())?;
                 let fd: i32 = fileno.try_to_value(vm)?;
@@ -709,8 +848,12 @@ mod decl {
             }
 
             // Extract values before releasing lock for I/O
-            let (repeat, exit, fd, header) =
-                (guard.repeat, guard.exit, guard.fd, guard.header.clone());
+            let repeat = guard.repeat;
+            let exit = guard.exit;
+            let fd = guard.fd;
+            let header = guard.header.clone();
+            #[cfg(feature = "threading")]
+            let thread_frame_slots = guard.thread_frame_slots.clone();
             drop(guard); // Release lock before I/O
 
             // Timeout occurred, dump traceback
@@ -719,35 +862,21 @@ mod decl {
 
             #[cfg(not(target_arch = "wasm32"))]
             {
-                let header_bytes = header.as_bytes();
-                #[cfg(windows)]
-                unsafe {
-                    libc::write(
-                        fd,
-                        header_bytes.as_ptr() as *const libc::c_void,
-                        header_bytes.len() as u32,
-                    );
-                }
-                #[cfg(not(windows))]
-                unsafe {
-                    libc::write(
-                        fd,
-                        header_bytes.as_ptr() as *const libc::c_void,
-                        header_bytes.len(),
-                    );
-                }
-
-                // Note: We cannot dump actual Python traceback from a separate thread
-                // because we don't have access to the VM's frame stack.
-                // Just output a message indicating timeout occurred.
-                let msg = b"<timeout: cannot dump traceback from watchdog thread>\n";
-                #[cfg(windows)]
-                unsafe {
-                    libc::write(fd, msg.as_ptr() as *const libc::c_void, msg.len() as u32);
+                puts_bytes(fd, header.as_bytes());
+
+                // Use thread frame slots when threading is enabled (includes all threads).
+                // Fall back to live frame walking for non-threaded builds.
+                #[cfg(feature = "threading")]
+                {
+                    for (tid, slot) in &thread_frame_slots {
+                        let frames = slot.frames.lock();
+                        dump_traceback_thread_frames(fd, *tid, false, &frames);
+                    }
                 }
-                #[cfg(not(windows))]
-                unsafe {
-                    libc::write(fd, msg.as_ptr() as *const libc::c_void, msg.len());
+                #[cfg(not(feature = "threading"))]
+                {
+                    write_thread_id(fd, current_thread_id(), false);
+                    dump_live_frames(fd);
                 }
 
                 if exit {
@@ -779,7 +908,7 @@ mod decl {
         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()));
+            return Err(vm.new_value_error("timeout must be greater than 0"));
         }
 
         let fd = get_fd_from_file_opt(args.file, vm)?;
@@ -787,11 +916,21 @@ mod decl {
         // Convert timeout to microseconds
         let timeout_us = (timeout * 1_000_000.0) as u64;
         if timeout_us == 0 {
-            return Err(vm.new_value_error("timeout must be greater than 0".to_owned()));
+            return Err(vm.new_value_error("timeout must be greater than 0"));
         }
 
         let header = format_timeout(timeout_us);
 
+        // Snapshot thread frame slots so watchdog can dump tracebacks
+        #[cfg(feature = "threading")]
+        let thread_frame_slots: Vec<(u64, ThreadFrameSlot)> = {
+            let registry = vm.state.thread_frames.lock();
+            registry
+                .iter()
+                .map(|(&id, slot)| (id, Arc::clone(slot)))
+                .collect()
+        };
+
         // Cancel any previous watchdog
         cancel_dump_traceback_later();
 
@@ -804,6 +943,8 @@ mod decl {
                 repeat: args.repeat,
                 exit: args.exit,
                 header,
+                #[cfg(feature = "threading")]
+                thread_frame_slots,
             }),
             Condvar::new(),
         ));
@@ -845,14 +986,13 @@ mod decl {
 
         const NSIG: usize = 64;
 
-        #[derive(Clone)]
+        #[derive(Clone, Copy)]
         pub struct UserSignal {
             pub enabled: bool,
             pub fd: i32,
-            #[allow(dead_code)]
             pub all_threads: bool,
             pub chain: bool,
-            pub previous: libc::sighandler_t,
+            pub previous: libc::sigaction,
         }
 
         impl Default for UserSignal {
@@ -862,7 +1002,8 @@ mod decl {
                     fd: 2, // stderr
                     all_threads: true,
                     chain: false,
-                    previous: libc::SIG_DFL,
+                    // SAFETY: sigaction is a C struct that can be zero-initialized
+                    previous: unsafe { core::mem::zeroed() },
                 }
             }
         }
@@ -892,7 +1033,7 @@ mod decl {
                 && signum < v.len()
                 && v[signum].enabled
             {
-                let old = v[signum].clone();
+                let old = v[signum];
                 v[signum] = UserSignal::default();
                 return Some(old);
             }
@@ -910,38 +1051,33 @@ mod decl {
 
     #[cfg(unix)]
     extern "C" fn faulthandler_user_signal(signum: libc::c_int) {
+        let save_errno = get_errno();
+
         let user = match user_signals::get_user_signal(signum as usize) {
             Some(u) if u.enabled => u,
             _ => return,
         };
 
-        // Write traceback header
-        let header = b"Current thread 0x0000 (most recent call first):\n";
-        let _ = unsafe {
-            libc::write(
-                user.fd,
-                header.as_ptr() as *const libc::c_void,
-                header.len(),
-            )
-        };
-
-        // Note: We cannot easily access RustPython's frame stack from a signal handler
-        // because signal handlers run asynchronously. We just output a placeholder.
-        let msg = b"  <signal handler invoked, traceback unavailable in signal context>\n";
-        let _ = unsafe { libc::write(user.fd, msg.as_ptr() as *const libc::c_void, msg.len()) };
+        faulthandler_dump_traceback(user.fd, user.all_threads);
 
-        // If chain is enabled, call the previous handler
-        if user.chain && user.previous != libc::SIG_DFL && user.previous != libc::SIG_IGN {
-            // Re-register the old handler and raise the signal
+        if user.chain {
+            // Restore the previous handler and re-raise
+            unsafe {
+                libc::sigaction(signum, &user.previous, core::ptr::null_mut());
+            }
+            set_errno(save_errno);
             unsafe {
-                libc::signal(signum, user.previous);
                 libc::raise(signum);
-                // Re-register our handler
-                libc::signal(
-                    signum,
-                    faulthandler_user_signal as *const () as libc::sighandler_t,
-                );
             }
+            // Re-install our handler with the same flags as register()
+            let save_errno2 = get_errno();
+            unsafe {
+                let mut action: libc::sigaction = core::mem::zeroed();
+                action.sa_sigaction = faulthandler_user_signal as *const () as libc::sighandler_t;
+                action.sa_flags = libc::SA_NODEFER;
+                libc::sigaction(signum, &action, core::ptr::null_mut());
+            }
+            set_errno(save_errno2);
         }
     }
 
@@ -958,7 +1094,7 @@ mod decl {
 
         // Check if signal is in valid range
         if !(1..64).contains(&signum) {
-            return Err(vm.new_value_error("signal number out of range".to_owned()));
+            return Err(vm.new_value_error("signal number out of range"));
         }
 
         Ok(())
@@ -989,25 +1125,31 @@ mod decl {
 
         // Get current handler to save as previous
         let previous = if !user_signals::is_enabled(signum) {
-            // Install signal handler
-            let prev = unsafe {
-                libc::signal(
-                    args.signum,
-                    faulthandler_user_signal as *const () as libc::sighandler_t,
-                )
-            };
-            if prev == libc::SIG_ERR {
-                return Err(vm.new_os_error(format!(
-                    "Failed to register signal handler for signal {}",
-                    args.signum
-                )));
+            unsafe {
+                let mut action: libc::sigaction = core::mem::zeroed();
+                action.sa_sigaction = faulthandler_user_signal as *const () as libc::sighandler_t;
+                // SA_RESTART by default; SA_NODEFER only when chaining
+                // (faulthandler.c:860-864)
+                action.sa_flags = if args.chain {
+                    libc::SA_NODEFER
+                } else {
+                    libc::SA_RESTART
+                };
+
+                let mut prev: libc::sigaction = core::mem::zeroed();
+                if libc::sigaction(args.signum, &action, &mut prev) != 0 {
+                    return Err(vm.new_os_error(format!(
+                        "Failed to register signal handler for signal {}",
+                        args.signum
+                    )));
+                }
+                prev
             }
-            prev
         } else {
             // Already registered, keep previous handler
             user_signals::get_user_signal(signum)
                 .map(|u| u.previous)
-                .unwrap_or(libc::SIG_DFL)
+                .unwrap_or(unsafe { core::mem::zeroed() })
         };
 
         user_signals::set_user_signal(
@@ -1032,7 +1174,7 @@ mod decl {
         if let Some(old) = user_signals::clear_user_signal(signum as usize) {
             // Restore previous handler
             unsafe {
-                libc::signal(signum, old.previous);
+                libc::sigaction(signum, &old.previous, core::ptr::null_mut());
             }
             Ok(true)
         } else {
@@ -1043,14 +1185,15 @@ mod decl {
     // Test functions for faulthandler testing
 
     #[pyfunction]
-    fn _read_null() {
-        // This function intentionally causes a segmentation fault by reading from NULL
-        // Used for testing faulthandler
+    fn _read_null(_vm: &VirtualMachine) {
         #[cfg(not(target_arch = "wasm32"))]
-        unsafe {
+        {
             suppress_crash_report();
-            let ptr: *const i32 = core::ptr::null();
-            core::ptr::read_volatile(ptr);
+
+            unsafe {
+                let ptr: *const i32 = core::ptr::null();
+                core::ptr::read_volatile(ptr);
+            }
         }
     }
 
@@ -1062,39 +1205,28 @@ mod decl {
     }
 
     #[pyfunction]
-    fn _sigsegv(_args: SigsegvArgs) {
-        // Raise SIGSEGV signal
+    fn _sigsegv(_args: SigsegvArgs, _vm: &VirtualMachine) {
         #[cfg(not(target_arch = "wasm32"))]
         {
             suppress_crash_report();
 
-            // Reset SIGSEGV to default behavior before raising
-            // This ensures the process will actually crash
+            // Write to NULL pointer to trigger a real hardware SIGSEGV,
+            // matching CPython's *((volatile int *)NULL) = 0;
+            // Using raise(SIGSEGV) doesn't work reliably because Rust's runtime
+            // installs its own signal handler that may swallow software signals.
             unsafe {
-                libc::signal(libc::SIGSEGV, libc::SIG_DFL);
-            }
-
-            #[cfg(windows)]
-            {
-                // On Windows, we need to raise SIGSEGV multiple times
-                loop {
-                    unsafe {
-                        libc::raise(libc::SIGSEGV);
-                    }
-                }
-            }
-            #[cfg(not(windows))]
-            unsafe {
-                libc::raise(libc::SIGSEGV);
+                let ptr: *mut i32 = core::ptr::null_mut();
+                core::ptr::write_volatile(ptr, 0);
             }
         }
     }
 
     #[pyfunction]
-    fn _sigabrt() {
+    fn _sigabrt(_vm: &VirtualMachine) {
         #[cfg(not(target_arch = "wasm32"))]
         {
             suppress_crash_report();
+
             unsafe {
                 libc::abort();
             }
@@ -1102,17 +1234,11 @@ mod decl {
     }
 
     #[pyfunction]
-    fn _sigfpe() {
+    fn _sigfpe(_vm: &VirtualMachine) {
         #[cfg(not(target_arch = "wasm32"))]
         {
             suppress_crash_report();
 
-            // Reset SIGFPE to default behavior before raising
-            unsafe {
-                libc::signal(libc::SIGFPE, libc::SIG_DFL);
-            }
-
-            // Raise SIGFPE
             unsafe {
                 libc::raise(libc::SIGFPE);
             }
@@ -1196,7 +1322,7 @@ mod decl {
 
     #[cfg(windows)]
     #[pyfunction]
-    fn _raise_exception(args: RaiseExceptionArgs) {
+    fn _raise_exception(args: RaiseExceptionArgs, _vm: &VirtualMachine) {
         use windows_sys::Win32::System::Diagnostics::Debug::RaiseException;
 
         suppress_crash_report();
diff --git a/crates/stdlib/src/fcntl.rs b/crates/stdlib/src/fcntl.rs
index 407a2dfd6b3..0f75a09ba0f 100644
--- a/crates/stdlib/src/fcntl.rs
+++ b/crates/stdlib/src/fcntl.rs
@@ -8,7 +8,7 @@ mod fcntl {
         PyResult, VirtualMachine,
         builtins::PyIntRef,
         function::{ArgMemoryBuffer, ArgStrOrBytesLike, Either, OptionalArg},
-        stdlib::io,
+        stdlib::_io,
     };
 
     // TODO: supply these from <asm-generic/fnctl.h> (please file an issue/PR upstream):
@@ -57,7 +57,7 @@ mod fcntl {
 
     #[pyfunction]
     fn fcntl(
-        io::Fildes(fd): io::Fildes,
+        _io::Fildes(fd): _io::Fildes,
         cmd: i32,
         arg: OptionalArg<Either<ArgStrOrBytesLike, PyIntRef>>,
         vm: &VirtualMachine,
@@ -91,7 +91,7 @@ mod fcntl {
 
     #[pyfunction]
     fn ioctl(
-        io::Fildes(fd): io::Fildes,
+        _io::Fildes(fd): _io::Fildes,
         request: i64,
         arg: OptionalArg<Either<Either<ArgMemoryBuffer, ArgStrOrBytesLike>, i32>>,
         mutate_flag: OptionalArg<bool>,
@@ -149,7 +149,7 @@ mod fcntl {
     // XXX: at the time of writing, wasi and redox don't have the necessary constants/function
     #[cfg(not(any(target_os = "wasi", target_os = "redox")))]
     #[pyfunction]
-    fn flock(io::Fildes(fd): io::Fildes, operation: i32, vm: &VirtualMachine) -> PyResult {
+    fn flock(_io::Fildes(fd): _io::Fildes, operation: i32, vm: &VirtualMachine) -> PyResult {
         let ret = unsafe { libc::flock(fd, operation) };
         // TODO: add support for platforms that don't have a builtin `flock` syscall
         if ret < 0 {
@@ -162,7 +162,7 @@ mod fcntl {
     #[cfg(not(any(target_os = "wasi", target_os = "redox")))]
     #[pyfunction]
     fn lockf(
-        io::Fildes(fd): io::Fildes,
+        _io::Fildes(fd): _io::Fildes,
         cmd: i32,
         len: OptionalArg<PyIntRef>,
         start: OptionalArg<PyIntRef>,
diff --git a/crates/stdlib/src/gc.rs b/crates/stdlib/src/gc.rs
deleted file mode 100644
index 9359119a603..00000000000
--- a/crates/stdlib/src/gc.rs
+++ /dev/null
@@ -1,76 +0,0 @@
-pub(crate) use gc::module_def;
-
-#[pymodule]
-mod gc {
-    use crate::vm::{PyResult, VirtualMachine, function::FuncArgs};
-
-    #[pyfunction]
-    fn collect(_args: FuncArgs, _vm: &VirtualMachine) -> i32 {
-        0
-    }
-
-    #[pyfunction]
-    fn isenabled(_args: FuncArgs, _vm: &VirtualMachine) -> bool {
-        false
-    }
-
-    #[pyfunction]
-    fn enable(_args: FuncArgs, vm: &VirtualMachine) -> PyResult {
-        Err(vm.new_not_implemented_error(""))
-    }
-
-    #[pyfunction]
-    fn disable(_args: FuncArgs, vm: &VirtualMachine) -> PyResult {
-        Err(vm.new_not_implemented_error(""))
-    }
-
-    #[pyfunction]
-    fn get_count(_args: FuncArgs, vm: &VirtualMachine) -> PyResult {
-        Err(vm.new_not_implemented_error(""))
-    }
-
-    #[pyfunction]
-    fn get_debug(_args: FuncArgs, vm: &VirtualMachine) -> PyResult {
-        Err(vm.new_not_implemented_error(""))
-    }
-
-    #[pyfunction]
-    fn get_objects(_args: FuncArgs, vm: &VirtualMachine) -> PyResult {
-        Err(vm.new_not_implemented_error(""))
-    }
-
-    #[pyfunction]
-    fn get_referents(_args: FuncArgs, vm: &VirtualMachine) -> PyResult {
-        Err(vm.new_not_implemented_error(""))
-    }
-
-    #[pyfunction]
-    fn get_referrers(_args: FuncArgs, vm: &VirtualMachine) -> PyResult {
-        Err(vm.new_not_implemented_error(""))
-    }
-
-    #[pyfunction]
-    fn get_stats(_args: FuncArgs, vm: &VirtualMachine) -> PyResult {
-        Err(vm.new_not_implemented_error(""))
-    }
-
-    #[pyfunction]
-    fn get_threshold(_args: FuncArgs, vm: &VirtualMachine) -> PyResult {
-        Err(vm.new_not_implemented_error(""))
-    }
-
-    #[pyfunction]
-    fn is_tracked(_args: FuncArgs, vm: &VirtualMachine) -> PyResult {
-        Err(vm.new_not_implemented_error(""))
-    }
-
-    #[pyfunction]
-    fn set_debug(_args: FuncArgs, vm: &VirtualMachine) -> PyResult {
-        Err(vm.new_not_implemented_error(""))
-    }
-
-    #[pyfunction]
-    fn set_threshold(_args: FuncArgs, vm: &VirtualMachine) -> PyResult {
-        Err(vm.new_not_implemented_error(""))
-    }
-}
diff --git a/crates/stdlib/src/grp.rs b/crates/stdlib/src/grp.rs
index c1a52eee62e..eec901b0e57 100644
--- a/crates/stdlib/src/grp.rs
+++ b/crates/stdlib/src/grp.rs
@@ -5,7 +5,7 @@ pub(crate) use grp::module_def;
 mod grp {
     use crate::vm::{
         PyObjectRef, PyResult, VirtualMachine,
-        builtins::{PyIntRef, PyListRef, PyStrRef},
+        builtins::{PyIntRef, PyListRef, PyUtf8StrRef},
         convert::{IntoPyException, ToPyObject},
         exceptions,
         types::PyStructSequence,
@@ -67,7 +67,7 @@ mod grp {
     }
 
     #[pyfunction]
-    fn getgrnam(name: PyStrRef, vm: &VirtualMachine) -> PyResult<GroupData> {
+    fn getgrnam(name: PyUtf8StrRef, vm: &VirtualMachine) -> PyResult<GroupData> {
         let gr_name = name.as_str();
         if gr_name.contains('\0') {
             return Err(exceptions::cstring_error(vm));
diff --git a/crates/stdlib/src/hashlib.rs b/crates/stdlib/src/hashlib.rs
index c9902eff60a..584ed1714d5 100644
--- a/crates/stdlib/src/hashlib.rs
+++ b/crates/stdlib/src/hashlib.rs
@@ -1,4 +1,7 @@
-// spell-checker:ignore usedforsecurity HASHXOF
+// spell-checker:ignore usedforsecurity HASHXOF hashopenssl dklen
+// NOTE: Function names like `openssl_md5` match CPython's `_hashopenssl.c` interface
+// for compatibility, but the implementation uses pure Rust crates (md5, sha2, etc.),
+// not OpenSSL.
 
 pub(crate) use _hashlib::module_def;
 
@@ -7,45 +10,92 @@ pub mod _hashlib {
     use crate::common::lock::PyRwLock;
     use crate::vm::{
         Py, PyObjectRef, PyPayload, PyResult, VirtualMachine,
-        builtins::{PyBytes, PyStrRef, PyTypeRef, PyValueError},
+        builtins::{
+            PyBaseExceptionRef, PyBytes, PyFrozenSet, PyStr, PyTypeRef, PyUtf8StrRef, PyValueError,
+        },
         class::StaticType,
-        convert::ToPyObject,
         function::{ArgBytesLike, ArgStrOrBytesLike, FuncArgs, OptionalArg},
         types::{Constructor, Representable},
     };
     use blake2::{Blake2b512, Blake2s256};
-    use digest::{DynDigest, core_api::BlockSizeUser};
+    use digest::{DynDigest, OutputSizeUser, core_api::BlockSizeUser};
     use digest::{ExtendableOutput, Update};
     use dyn_clone::{DynClone, clone_trait_object};
+    use hmac::Mac;
     use md5::Md5;
     use sha1::Sha1;
     use sha2::{Sha224, Sha256, Sha384, Sha512};
     use sha3::{Sha3_224, Sha3_256, Sha3_384, Sha3_512, Shake128, Shake256};
 
+    const HASH_ALGORITHMS: &[&str] = &[
+        "md5",
+        "sha1",
+        "sha224",
+        "sha256",
+        "sha384",
+        "sha512",
+        "sha3_224",
+        "sha3_256",
+        "sha3_384",
+        "sha3_512",
+        "shake_128",
+        "shake_256",
+        "blake2b",
+        "blake2s",
+    ];
+
+    #[pyattr]
+    const _GIL_MINSIZE: usize = 2048;
+
     #[pyattr]
     #[pyexception(name = "UnsupportedDigestmodError", base = PyValueError, impl)]
     #[derive(Debug)]
     #[repr(transparent)]
     pub struct UnsupportedDigestmodError(PyValueError);
 
+    #[pyattr]
+    fn openssl_md_meth_names(vm: &VirtualMachine) -> PyObjectRef {
+        PyFrozenSet::from_iter(
+            vm,
+            HASH_ALGORITHMS.iter().map(|n| vm.ctx.new_str(*n).into()),
+        )
+        .expect("failed to create openssl_md_meth_names frozenset")
+        .into_ref(&vm.ctx)
+        .into()
+    }
+
+    #[pyattr]
+    fn _constructors(vm: &VirtualMachine) -> PyObjectRef {
+        let dict = vm.ctx.new_dict();
+        for name in HASH_ALGORITHMS {
+            let s = vm.ctx.new_str(*name);
+            dict.set_item(&*s, s.clone().into(), vm).unwrap();
+        }
+        dict.into()
+    }
+
     #[derive(FromArgs, Debug)]
     #[allow(unused)]
     struct NewHashArgs {
         #[pyarg(positional)]
-        name: PyStrRef,
+        name: PyUtf8StrRef,
         #[pyarg(any, optional)]
         data: OptionalArg<ArgBytesLike>,
         #[pyarg(named, default = true)]
         usedforsecurity: bool,
+        #[pyarg(named, optional)]
+        string: OptionalArg<ArgBytesLike>,
     }
 
     #[derive(FromArgs)]
     #[allow(unused)]
     pub struct BlakeHashArgs {
-        #[pyarg(positional, optional)]
+        #[pyarg(any, optional)]
         pub data: OptionalArg<ArgBytesLike>,
         #[pyarg(named, default = true)]
         usedforsecurity: bool,
+        #[pyarg(named, optional)]
+        pub string: OptionalArg<ArgBytesLike>,
     }
 
     impl From<NewHashArgs> for BlakeHashArgs {
@@ -53,6 +103,7 @@ pub mod _hashlib {
             Self {
                 data: args.data,
                 usedforsecurity: args.usedforsecurity,
+                string: args.string,
             }
         }
     }
@@ -61,20 +112,45 @@ pub mod _hashlib {
     #[allow(unused)]
     pub struct HashArgs {
         #[pyarg(any, optional)]
-        pub string: OptionalArg<ArgBytesLike>,
+        pub data: OptionalArg<ArgBytesLike>,
         #[pyarg(named, default = true)]
         usedforsecurity: bool,
+        #[pyarg(named, optional)]
+        pub string: OptionalArg<ArgBytesLike>,
     }
 
     impl From<NewHashArgs> for HashArgs {
         fn from(args: NewHashArgs) -> Self {
             Self {
-                string: args.data,
+                data: args.data,
                 usedforsecurity: args.usedforsecurity,
+                string: args.string,
             }
         }
     }
 
+    const KECCAK_WIDTH_BITS: usize = 1600;
+
+    fn keccak_suffix(name: &str) -> Option<u8> {
+        match name {
+            "sha3_224" | "sha3_256" | "sha3_384" | "sha3_512" => Some(0x06),
+            "shake_128" | "shake_256" => Some(0x1f),
+            _ => None,
+        }
+    }
+
+    fn keccak_rate_bits(name: &str, block_size: usize) -> Option<usize> {
+        keccak_suffix(name).map(|_| block_size * 8)
+    }
+
+    fn keccak_capacity_bits(name: &str, block_size: usize) -> Option<usize> {
+        keccak_rate_bits(name, block_size).map(|rate| KECCAK_WIDTH_BITS - rate)
+    }
+
+    fn missing_hash_attribute<T>(vm: &VirtualMachine, class_name: &str, attr: &str) -> PyResult<T> {
+        Err(vm.new_attribute_error(format!("'{class_name}' object has no attribute '{attr}'")))
+    }
+
     #[derive(FromArgs)]
     #[allow(unused)]
     struct XofDigestArgs {
@@ -83,9 +159,202 @@ pub mod _hashlib {
     }
 
     impl XofDigestArgs {
+        // Match CPython's SHAKE output guard in Modules/sha3module.c.
+        const MAX_SHAKE_OUTPUT_LENGTH: usize = 1 << 29;
+
         fn length(&self, vm: &VirtualMachine) -> PyResult<usize> {
-            usize::try_from(self.length)
-                .map_err(|_| vm.new_value_error("length must be non-negative"))
+            let length = usize::try_from(self.length)
+                .map_err(|_| vm.new_value_error("length must be non-negative"))?;
+            if length >= Self::MAX_SHAKE_OUTPUT_LENGTH {
+                return Err(vm.new_value_error("length is too large"));
+            }
+            Ok(length)
+        }
+    }
+
+    #[derive(FromArgs)]
+    #[allow(unused)]
+    struct HmacDigestArgs {
+        #[pyarg(positional)]
+        key: ArgBytesLike,
+        #[pyarg(positional)]
+        msg: ArgBytesLike,
+        #[pyarg(positional)]
+        digest: PyObjectRef,
+    }
+
+    #[derive(FromArgs)]
+    #[allow(unused)]
+    struct Pbkdf2HmacArgs {
+        #[pyarg(any)]
+        hash_name: PyUtf8StrRef,
+        #[pyarg(any)]
+        password: ArgBytesLike,
+        #[pyarg(any)]
+        salt: ArgBytesLike,
+        #[pyarg(any)]
+        iterations: i64,
+        #[pyarg(any, optional)]
+        dklen: OptionalArg<PyObjectRef>,
+    }
+
+    fn resolve_data(
+        data: OptionalArg<ArgBytesLike>,
+        string: OptionalArg<ArgBytesLike>,
+        vm: &VirtualMachine,
+    ) -> PyResult<OptionalArg<ArgBytesLike>> {
+        match (data.into_option(), string.into_option()) {
+            (Some(d), None) => Ok(OptionalArg::Present(d)),
+            (None, Some(s)) => Ok(OptionalArg::Present(s)),
+            (None, None) => Ok(OptionalArg::Missing),
+            (Some(_), Some(_)) => Err(vm.new_type_error(
+                "'data' and 'string' are mutually exclusive \
+                 and support for 'string' keyword parameter \
+                 is slated for removal in a future version.",
+            )),
+        }
+    }
+
+    fn resolve_digestmod(digestmod: &PyObjectRef, vm: &VirtualMachine) -> PyResult<String> {
+        if let Some(name) = digestmod.downcast_ref::<PyStr>()
+            && let Some(name_str) = name.to_str()
+        {
+            return Ok(name_str.to_lowercase());
+        }
+        if let Ok(name_obj) = digestmod.get_attr("__name__", vm)
+            && let Some(name) = name_obj.downcast_ref::<PyStr>()
+            && let Some(name_str) = name.to_str()
+            && let Some(algo) = name_str.strip_prefix("openssl_")
+        {
+            return Ok(algo.to_owned());
+        }
+        Err(vm.new_exception_msg(
+            UnsupportedDigestmodError::static_type().to_owned(),
+            "unsupported digestmod".into(),
+        ))
+    }
+
+    fn hash_digest_size(name: &str) -> Option<usize> {
+        match name {
+            "md5" => Some(16),
+            "sha1" => Some(20),
+            "sha224" => Some(28),
+            "sha256" => Some(32),
+            "sha384" => Some(48),
+            "sha512" => Some(64),
+            "sha3_224" => Some(28),
+            "sha3_256" => Some(32),
+            "sha3_384" => Some(48),
+            "sha3_512" => Some(64),
+            "blake2b" => Some(64),
+            "blake2s" => Some(32),
+            _ => None,
+        }
+    }
+
+    fn unsupported_hash(name: &str, vm: &VirtualMachine) -> PyBaseExceptionRef {
+        vm.new_exception_msg(
+            UnsupportedDigestmodError::static_type().to_owned(),
+            format!("unsupported hash type {name}").into(),
+        )
+    }
+
+    // Object-safe HMAC trait for type-erased dispatch
+    trait DynHmac: Send + Sync {
+        fn dyn_update(&mut self, data: &[u8]);
+        fn dyn_finalize(&self) -> Vec<u8>;
+        fn dyn_clone(&self) -> Box<dyn DynHmac>;
+    }
+
+    struct TypedHmac<D>(D);
+
+    impl<D> DynHmac for TypedHmac<D>
+    where
+        D: Mac + Clone + Send + Sync + 'static,
+    {
+        fn dyn_update(&mut self, data: &[u8]) {
+            Mac::update(&mut self.0, data);
+        }
+
+        fn dyn_finalize(&self) -> Vec<u8> {
+            self.0.clone().finalize().into_bytes().to_vec()
+        }
+
+        fn dyn_clone(&self) -> Box<dyn DynHmac> {
+            Box::new(TypedHmac(self.0.clone()))
+        }
+    }
+
+    #[pyattr]
+    #[pyclass(module = "_hashlib", name = "HMAC")]
+    #[derive(PyPayload)]
+    pub struct PyHmac {
+        algo_name: String,
+        digest_size: usize,
+        block_size: usize,
+        ctx: PyRwLock<Box<dyn DynHmac>>,
+    }
+
+    impl core::fmt::Debug for PyHmac {
+        fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+            write!(f, "HMAC {}", self.algo_name)
+        }
+    }
+
+    #[pyclass(with(Representable), flags(IMMUTABLETYPE))]
+    impl PyHmac {
+        #[pyslot]
+        fn slot_new(_cls: PyTypeRef, _args: FuncArgs, vm: &VirtualMachine) -> PyResult {
+            Err(vm.new_type_error("cannot create '_hashlib.HMAC' instances"))
+        }
+
+        #[pygetset]
+        fn name(&self) -> String {
+            format!("hmac-{}", self.algo_name)
+        }
+
+        #[pygetset]
+        fn digest_size(&self) -> usize {
+            self.digest_size
+        }
+
+        #[pygetset]
+        fn block_size(&self) -> usize {
+            self.block_size
+        }
+
+        #[pymethod]
+        fn update(&self, msg: ArgBytesLike) {
+            msg.with_ref(|bytes| self.ctx.write().dyn_update(bytes));
+        }
+
+        #[pymethod]
+        fn digest(&self) -> PyBytes {
+            self.ctx.read().dyn_finalize().into()
+        }
+
+        #[pymethod]
+        fn hexdigest(&self) -> String {
+            hex::encode(self.ctx.read().dyn_finalize())
+        }
+
+        #[pymethod]
+        fn copy(&self) -> Self {
+            Self {
+                algo_name: self.algo_name.clone(),
+                digest_size: self.digest_size,
+                block_size: self.block_size,
+                ctx: PyRwLock::new(self.ctx.read().dyn_clone()),
+            }
+        }
+    }
+
+    impl Representable for PyHmac {
+        fn repr_str(zelf: &Py<Self>, _vm: &VirtualMachine) -> PyResult<String> {
+            Ok(format!(
+                "<{} HMAC object @ {:#x}>",
+                zelf.algo_name, zelf as *const _ as usize
+            ))
         }
     }
 
@@ -103,7 +372,7 @@ pub mod _hashlib {
         }
     }
 
-    #[pyclass(with(Representable))]
+    #[pyclass(with(Representable), flags(IMMUTABLETYPE))]
     impl PyHasher {
         fn new(name: &str, d: HashWrapper) -> Self {
             Self {
@@ -132,6 +401,32 @@ pub mod _hashlib {
             self.ctx.read().block_size()
         }
 
+        #[pygetset]
+        fn _capacity_bits(&self, vm: &VirtualMachine) -> PyResult<usize> {
+            let block_size = self.ctx.read().block_size();
+            match keccak_capacity_bits(&self.name, block_size) {
+                Some(capacity) => Ok(capacity),
+                None => missing_hash_attribute(vm, "HASH", "_capacity_bits"),
+            }
+        }
+
+        #[pygetset]
+        fn _rate_bits(&self, vm: &VirtualMachine) -> PyResult<usize> {
+            let block_size = self.ctx.read().block_size();
+            match keccak_rate_bits(&self.name, block_size) {
+                Some(rate) => Ok(rate),
+                None => missing_hash_attribute(vm, "HASH", "_rate_bits"),
+            }
+        }
+
+        #[pygetset]
+        fn _suffix(&self, vm: &VirtualMachine) -> PyResult<PyBytes> {
+            match keccak_suffix(&self.name) {
+                Some(suffix) => Ok(vec![suffix].into()),
+                None => missing_hash_attribute(vm, "HASH", "_suffix"),
+            }
+        }
+
         #[pymethod]
         fn update(&self, data: ArgBytesLike) {
             data.with_ref(|bytes| self.ctx.write().update(bytes));
@@ -176,7 +471,7 @@ pub mod _hashlib {
         }
     }
 
-    #[pyclass]
+    #[pyclass(with(Representable), flags(IMMUTABLETYPE))]
     impl PyHasherXof {
         fn new(name: &str, d: HashXofWrapper) -> Self {
             Self {
@@ -205,6 +500,32 @@ pub mod _hashlib {
             self.ctx.read().block_size()
         }
 
+        #[pygetset]
+        fn _capacity_bits(&self, vm: &VirtualMachine) -> PyResult<usize> {
+            let block_size = self.ctx.read().block_size();
+            match keccak_capacity_bits(&self.name, block_size) {
+                Some(capacity) => Ok(capacity),
+                None => missing_hash_attribute(vm, "HASHXOF", "_capacity_bits"),
+            }
+        }
+
+        #[pygetset]
+        fn _rate_bits(&self, vm: &VirtualMachine) -> PyResult<usize> {
+            let block_size = self.ctx.read().block_size();
+            match keccak_rate_bits(&self.name, block_size) {
+                Some(rate) => Ok(rate),
+                None => missing_hash_attribute(vm, "HASHXOF", "_rate_bits"),
+            }
+        }
+
+        #[pygetset]
+        fn _suffix(&self, vm: &VirtualMachine) -> PyResult<PyBytes> {
+            match keccak_suffix(&self.name) {
+                Some(suffix) => Ok(vec![suffix].into()),
+                None => missing_hash_attribute(vm, "HASHXOF", "_suffix"),
+            }
+        }
+
         #[pymethod]
         fn update(&self, data: ArgBytesLike) {
             data.with_ref(|bytes| self.ctx.write().update(bytes));
@@ -226,95 +547,174 @@ pub mod _hashlib {
         }
     }
 
+    impl Representable for PyHasherXof {
+        fn repr_str(zelf: &Py<Self>, _vm: &VirtualMachine) -> PyResult<String> {
+            Ok(format!(
+                "<{} _hashlib.HASHXOF object @ {:#x}>",
+                zelf.name, zelf as *const _ as usize
+            ))
+        }
+    }
+
     #[pyfunction(name = "new")]
     fn hashlib_new(args: NewHashArgs, vm: &VirtualMachine) -> PyResult<PyObjectRef> {
+        let data = resolve_data(args.data, args.string, vm)?;
         match args.name.as_str().to_lowercase().as_str() {
-            "md5" => Ok(local_md5(args.into()).into_pyobject(vm)),
-            "sha1" => Ok(local_sha1(args.into()).into_pyobject(vm)),
-            "sha224" => Ok(local_sha224(args.into()).into_pyobject(vm)),
-            "sha256" => Ok(local_sha256(args.into()).into_pyobject(vm)),
-            "sha384" => Ok(local_sha384(args.into()).into_pyobject(vm)),
-            "sha512" => Ok(local_sha512(args.into()).into_pyobject(vm)),
-            "sha3_224" => Ok(local_sha3_224(args.into()).into_pyobject(vm)),
-            "sha3_256" => Ok(local_sha3_256(args.into()).into_pyobject(vm)),
-            "sha3_384" => Ok(local_sha3_384(args.into()).into_pyobject(vm)),
-            "sha3_512" => Ok(local_sha3_512(args.into()).into_pyobject(vm)),
-            "shake_128" => Ok(local_shake_128(args.into()).into_pyobject(vm)),
-            "shake_256" => Ok(local_shake_256(args.into()).into_pyobject(vm)),
-            "blake2b" => Ok(local_blake2b(args.into()).into_pyobject(vm)),
-            "blake2s" => Ok(local_blake2s(args.into()).into_pyobject(vm)),
+            "md5" => Ok(PyHasher::new("md5", HashWrapper::new::<Md5>(data)).into_pyobject(vm)),
+            "sha1" => Ok(PyHasher::new("sha1", HashWrapper::new::<Sha1>(data)).into_pyobject(vm)),
+            "sha224" => {
+                Ok(PyHasher::new("sha224", HashWrapper::new::<Sha224>(data)).into_pyobject(vm))
+            }
+            "sha256" => {
+                Ok(PyHasher::new("sha256", HashWrapper::new::<Sha256>(data)).into_pyobject(vm))
+            }
+            "sha384" => {
+                Ok(PyHasher::new("sha384", HashWrapper::new::<Sha384>(data)).into_pyobject(vm))
+            }
+            "sha512" => {
+                Ok(PyHasher::new("sha512", HashWrapper::new::<Sha512>(data)).into_pyobject(vm))
+            }
+            "sha3_224" => {
+                Ok(PyHasher::new("sha3_224", HashWrapper::new::<Sha3_224>(data)).into_pyobject(vm))
+            }
+            "sha3_256" => {
+                Ok(PyHasher::new("sha3_256", HashWrapper::new::<Sha3_256>(data)).into_pyobject(vm))
+            }
+            "sha3_384" => {
+                Ok(PyHasher::new("sha3_384", HashWrapper::new::<Sha3_384>(data)).into_pyobject(vm))
+            }
+            "sha3_512" => {
+                Ok(PyHasher::new("sha3_512", HashWrapper::new::<Sha3_512>(data)).into_pyobject(vm))
+            }
+            "shake_128" => Ok(
+                PyHasherXof::new("shake_128", HashXofWrapper::new_shake_128(data))
+                    .into_pyobject(vm),
+            ),
+            "shake_256" => Ok(
+                PyHasherXof::new("shake_256", HashXofWrapper::new_shake_256(data))
+                    .into_pyobject(vm),
+            ),
+            "blake2b" => Ok(
+                PyHasher::new("blake2b", HashWrapper::new::<Blake2b512>(data)).into_pyobject(vm),
+            ),
+            "blake2s" => Ok(
+                PyHasher::new("blake2s", HashWrapper::new::<Blake2s256>(data)).into_pyobject(vm),
+            ),
             other => Err(vm.new_value_error(format!("Unknown hashing algorithm: {other}"))),
         }
     }
 
     #[pyfunction(name = "openssl_md5")]
-    pub fn local_md5(args: HashArgs) -> PyHasher {
-        PyHasher::new("md5", HashWrapper::new::<Md5>(args.string))
+    pub fn local_md5(args: HashArgs, vm: &VirtualMachine) -> PyResult<PyHasher> {
+        let data = resolve_data(args.data, args.string, vm)?;
+        Ok(PyHasher::new("md5", HashWrapper::new::<Md5>(data)))
     }
 
     #[pyfunction(name = "openssl_sha1")]
-    pub fn local_sha1(args: HashArgs) -> PyHasher {
-        PyHasher::new("sha1", HashWrapper::new::<Sha1>(args.string))
+    pub fn local_sha1(args: HashArgs, vm: &VirtualMachine) -> PyResult<PyHasher> {
+        let data = resolve_data(args.data, args.string, vm)?;
+        Ok(PyHasher::new("sha1", HashWrapper::new::<Sha1>(data)))
     }
 
     #[pyfunction(name = "openssl_sha224")]
-    pub fn local_sha224(args: HashArgs) -> PyHasher {
-        PyHasher::new("sha224", HashWrapper::new::<Sha224>(args.string))
+    pub fn local_sha224(args: HashArgs, vm: &VirtualMachine) -> PyResult<PyHasher> {
+        let data = resolve_data(args.data, args.string, vm)?;
+        Ok(PyHasher::new("sha224", HashWrapper::new::<Sha224>(data)))
     }
 
     #[pyfunction(name = "openssl_sha256")]
-    pub fn local_sha256(args: HashArgs) -> PyHasher {
-        PyHasher::new("sha256", HashWrapper::new::<Sha256>(args.string))
+    pub fn local_sha256(args: HashArgs, vm: &VirtualMachine) -> PyResult<PyHasher> {
+        let data = resolve_data(args.data, args.string, vm)?;
+        Ok(PyHasher::new("sha256", HashWrapper::new::<Sha256>(data)))
     }
 
     #[pyfunction(name = "openssl_sha384")]
-    pub fn local_sha384(args: HashArgs) -> PyHasher {
-        PyHasher::new("sha384", HashWrapper::new::<Sha384>(args.string))
+    pub fn local_sha384(args: HashArgs, vm: &VirtualMachine) -> PyResult<PyHasher> {
+        let data = resolve_data(args.data, args.string, vm)?;
+        Ok(PyHasher::new("sha384", HashWrapper::new::<Sha384>(data)))
     }
 
     #[pyfunction(name = "openssl_sha512")]
-    pub fn local_sha512(args: HashArgs) -> PyHasher {
-        PyHasher::new("sha512", HashWrapper::new::<Sha512>(args.string))
+    pub fn local_sha512(args: HashArgs, vm: &VirtualMachine) -> PyResult<PyHasher> {
+        let data = resolve_data(args.data, args.string, vm)?;
+        Ok(PyHasher::new("sha512", HashWrapper::new::<Sha512>(data)))
     }
 
     #[pyfunction(name = "openssl_sha3_224")]
-    pub fn local_sha3_224(args: HashArgs) -> PyHasher {
-        PyHasher::new("sha3_224", HashWrapper::new::<Sha3_224>(args.string))
+    pub fn local_sha3_224(args: HashArgs, vm: &VirtualMachine) -> PyResult<PyHasher> {
+        let data = resolve_data(args.data, args.string, vm)?;
+        Ok(PyHasher::new(
+            "sha3_224",
+            HashWrapper::new::<Sha3_224>(data),
+        ))
     }
 
     #[pyfunction(name = "openssl_sha3_256")]
-    pub fn local_sha3_256(args: HashArgs) -> PyHasher {
-        PyHasher::new("sha3_256", HashWrapper::new::<Sha3_256>(args.string))
+    pub fn local_sha3_256(args: HashArgs, vm: &VirtualMachine) -> PyResult<PyHasher> {
+        let data = resolve_data(args.data, args.string, vm)?;
+        Ok(PyHasher::new(
+            "sha3_256",
+            HashWrapper::new::<Sha3_256>(data),
+        ))
     }
 
     #[pyfunction(name = "openssl_sha3_384")]
-    pub fn local_sha3_384(args: HashArgs) -> PyHasher {
-        PyHasher::new("sha3_384", HashWrapper::new::<Sha3_384>(args.string))
+    pub fn local_sha3_384(args: HashArgs, vm: &VirtualMachine) -> PyResult<PyHasher> {
+        let data = resolve_data(args.data, args.string, vm)?;
+        Ok(PyHasher::new(
+            "sha3_384",
+            HashWrapper::new::<Sha3_384>(data),
+        ))
     }
 
     #[pyfunction(name = "openssl_sha3_512")]
-    pub fn local_sha3_512(args: HashArgs) -> PyHasher {
-        PyHasher::new("sha3_512", HashWrapper::new::<Sha3_512>(args.string))
+    pub fn local_sha3_512(args: HashArgs, vm: &VirtualMachine) -> PyResult<PyHasher> {
+        let data = resolve_data(args.data, args.string, vm)?;
+        Ok(PyHasher::new(
+            "sha3_512",
+            HashWrapper::new::<Sha3_512>(data),
+        ))
     }
 
     #[pyfunction(name = "openssl_shake_128")]
-    pub fn local_shake_128(args: HashArgs) -> PyHasherXof {
-        PyHasherXof::new("shake_128", HashXofWrapper::new_shake_128(args.string))
+    pub fn local_shake_128(args: HashArgs, vm: &VirtualMachine) -> PyResult<PyHasherXof> {
+        let data = resolve_data(args.data, args.string, vm)?;
+        Ok(PyHasherXof::new(
+            "shake_128",
+            HashXofWrapper::new_shake_128(data),
+        ))
     }
 
     #[pyfunction(name = "openssl_shake_256")]
-    pub fn local_shake_256(args: HashArgs) -> PyHasherXof {
-        PyHasherXof::new("shake_256", HashXofWrapper::new_shake_256(args.string))
+    pub fn local_shake_256(args: HashArgs, vm: &VirtualMachine) -> PyResult<PyHasherXof> {
+        let data = resolve_data(args.data, args.string, vm)?;
+        Ok(PyHasherXof::new(
+            "shake_256",
+            HashXofWrapper::new_shake_256(data),
+        ))
     }
 
     #[pyfunction(name = "openssl_blake2b")]
-    pub fn local_blake2b(args: BlakeHashArgs) -> PyHasher {
-        PyHasher::new("blake2b", HashWrapper::new::<Blake2b512>(args.data))
+    pub fn local_blake2b(args: BlakeHashArgs, vm: &VirtualMachine) -> PyResult<PyHasher> {
+        let data = resolve_data(args.data, args.string, vm)?;
+        Ok(PyHasher::new(
+            "blake2b",
+            HashWrapper::new::<Blake2b512>(data),
+        ))
     }
 
     #[pyfunction(name = "openssl_blake2s")]
-    pub fn local_blake2s(args: BlakeHashArgs) -> PyHasher {
-        PyHasher::new("blake2s", HashWrapper::new::<Blake2s256>(args.data))
+    pub fn local_blake2s(args: BlakeHashArgs, vm: &VirtualMachine) -> PyResult<PyHasher> {
+        let data = resolve_data(args.data, args.string, vm)?;
+        Ok(PyHasher::new(
+            "blake2s",
+            HashWrapper::new::<Blake2s256>(data),
+        ))
+    }
+
+    #[pyfunction]
+    fn get_fips_mode() -> i32 {
+        0
     }
 
     #[pyfunction]
@@ -322,22 +722,26 @@ pub mod _hashlib {
         a: ArgStrOrBytesLike,
         b: ArgStrOrBytesLike,
         vm: &VirtualMachine,
-    ) -> PyResult<PyObjectRef> {
-        const fn is_str(arg: &ArgStrOrBytesLike) -> bool {
-            matches!(arg, ArgStrOrBytesLike::Str(_))
-        }
-
-        if is_str(&a) != is_str(&b) {
-            return Err(vm.new_type_error(format!(
+    ) -> PyResult<bool> {
+        use constant_time_eq::constant_time_eq;
+
+        match (&a, &b) {
+            (ArgStrOrBytesLike::Str(a), ArgStrOrBytesLike::Str(b)) => {
+                if !a.isascii() || !b.isascii() {
+                    return Err(vm.new_type_error(
+                        "comparing strings with non-ASCII characters is not supported",
+                    ));
+                }
+                Ok(constant_time_eq(a.as_bytes(), b.as_bytes()))
+            }
+            (ArgStrOrBytesLike::Buf(a), ArgStrOrBytesLike::Buf(b)) => {
+                Ok(a.with_ref(|a| b.with_ref(|b| constant_time_eq(a, b))))
+            }
+            _ => Err(vm.new_type_error(format!(
                 "a bytes-like object is required, not '{}'",
                 b.as_object().class().name()
-            )));
+            ))),
         }
-
-        let a_hash = a.borrow_bytes().to_vec();
-        let b_hash = b.borrow_bytes().to_vec();
-
-        Ok((a_hash == b_hash).to_pyobject(vm))
     }
 
     #[derive(FromArgs, Debug)]
@@ -346,19 +750,133 @@ pub mod _hashlib {
         #[pyarg(positional)]
         key: ArgBytesLike,
         #[pyarg(any, optional)]
-        msg: OptionalArg<ArgBytesLike>,
+        msg: OptionalArg<Option<ArgBytesLike>>,
         #[pyarg(named, optional)]
         digestmod: OptionalArg<PyObjectRef>,
     }
 
     #[pyfunction]
-    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(),
-        ))
+    fn hmac_new(args: NewHMACHashArgs, vm: &VirtualMachine) -> PyResult<PyHmac> {
+        let digestmod = args
+            .digestmod
+            .into_option()
+            .ok_or_else(|| vm.new_type_error("Missing required parameter 'digestmod'."))?;
+        let name = resolve_digestmod(&digestmod, vm)?;
+
+        let key_buf = args.key.borrow_buf();
+        let msg_data = args.msg.flatten();
+
+        macro_rules! make_hmac {
+            ($hash_ty:ty) => {{
+                let mut mac = <hmac::Hmac<$hash_ty> as Mac>::new_from_slice(&key_buf)
+                    .map_err(|_| vm.new_value_error("invalid key length".to_owned()))?;
+                if let Some(ref m) = msg_data {
+                    m.with_ref(|bytes| Mac::update(&mut mac, bytes));
+                }
+                Ok(PyHmac {
+                    algo_name: name,
+                    digest_size: <$hash_ty as OutputSizeUser>::output_size(),
+                    block_size: <$hash_ty as BlockSizeUser>::block_size(),
+                    ctx: PyRwLock::new(Box::new(TypedHmac(mac))),
+                })
+            }};
+        }
+
+        match name.as_str() {
+            "md5" => make_hmac!(Md5),
+            "sha1" => make_hmac!(Sha1),
+            "sha224" => make_hmac!(Sha224),
+            "sha256" => make_hmac!(Sha256),
+            "sha384" => make_hmac!(Sha384),
+            "sha512" => make_hmac!(Sha512),
+            "sha3_224" => make_hmac!(Sha3_224),
+            "sha3_256" => make_hmac!(Sha3_256),
+            "sha3_384" => make_hmac!(Sha3_384),
+            "sha3_512" => make_hmac!(Sha3_512),
+            _ => Err(unsupported_hash(&name, vm)),
+        }
+    }
+
+    #[pyfunction]
+    fn hmac_digest(args: HmacDigestArgs, vm: &VirtualMachine) -> PyResult<PyBytes> {
+        let name = resolve_digestmod(&args.digest, vm)?;
+
+        let key_buf = args.key.borrow_buf();
+        let msg_buf = args.msg.borrow_buf();
+
+        macro_rules! do_hmac {
+            ($hash_ty:ty) => {{
+                let mut mac = <hmac::Hmac<$hash_ty> as Mac>::new_from_slice(&key_buf)
+                    .map_err(|_| vm.new_value_error("invalid key length".to_owned()))?;
+                Mac::update(&mut mac, &msg_buf);
+                Ok(mac.finalize().into_bytes().to_vec().into())
+            }};
+        }
+
+        match name.as_str() {
+            "md5" => do_hmac!(Md5),
+            "sha1" => do_hmac!(Sha1),
+            "sha224" => do_hmac!(Sha224),
+            "sha256" => do_hmac!(Sha256),
+            "sha384" => do_hmac!(Sha384),
+            "sha512" => do_hmac!(Sha512),
+            "sha3_224" => do_hmac!(Sha3_224),
+            "sha3_256" => do_hmac!(Sha3_256),
+            "sha3_384" => do_hmac!(Sha3_384),
+            "sha3_512" => do_hmac!(Sha3_512),
+            _ => Err(unsupported_hash(&name, vm)),
+        }
+    }
+
+    #[pyfunction]
+    fn pbkdf2_hmac(args: Pbkdf2HmacArgs, vm: &VirtualMachine) -> PyResult<PyBytes> {
+        let name = args.hash_name.as_str().to_lowercase();
+
+        if args.iterations < 1 {
+            return Err(vm.new_value_error("iteration value must be greater than 0."));
+        }
+        let rounds = u32::try_from(args.iterations)
+            .map_err(|_| vm.new_overflow_error("iteration value is too great."))?;
+
+        let dklen: usize = match args.dklen.into_option() {
+            Some(obj) if vm.is_none(&obj) => {
+                hash_digest_size(&name).ok_or_else(|| unsupported_hash(&name, vm))?
+            }
+            Some(obj) => {
+                let len: i64 = obj.try_into_value(vm)?;
+                if len < 1 {
+                    return Err(vm.new_value_error("key length must be greater than 0."));
+                }
+                usize::try_from(len)
+                    .map_err(|_| vm.new_overflow_error("key length is too great."))?
+            }
+            None => hash_digest_size(&name).ok_or_else(|| unsupported_hash(&name, vm))?,
+        };
+
+        let password_buf = args.password.borrow_buf();
+        let salt_buf = args.salt.borrow_buf();
+        let mut dk = vec![0u8; dklen];
+
+        macro_rules! do_pbkdf2 {
+            ($hash_ty:ty) => {{
+                pbkdf2::pbkdf2_hmac::<$hash_ty>(&password_buf, &salt_buf, rounds, &mut dk);
+                Ok(dk.into())
+            }};
+        }
+
+        match name.as_str() {
+            "md5" => do_pbkdf2!(Md5),
+            "sha1" => do_pbkdf2!(Sha1),
+            "sha224" => do_pbkdf2!(Sha224),
+            "sha256" => do_pbkdf2!(Sha256),
+            "sha384" => do_pbkdf2!(Sha384),
+            "sha512" => do_pbkdf2!(Sha512),
+            "sha3_224" => do_pbkdf2!(Sha3_224),
+            "sha3_256" => do_pbkdf2!(Sha3_256),
+            "sha3_384" => do_pbkdf2!(Sha3_384),
+            "sha3_512" => do_pbkdf2!(Sha3_512),
+            _ => Err(unsupported_hash(&name, vm)),
+        }
     }
 
     pub trait ThreadSafeDynDigest: DynClone + DynDigest + Sync + Send {}
@@ -366,7 +884,6 @@ pub mod _hashlib {
 
     clone_trait_object!(ThreadSafeDynDigest);
 
-    /// Generic wrapper patching around the hashing libraries.
     #[derive(Clone)]
     pub struct HashWrapper {
         block_size: usize,
diff --git a/crates/stdlib/src/json.rs b/crates/stdlib/src/json.rs
index 3baeba629c8..41c3dead090 100644
--- a/crates/stdlib/src/json.rs
+++ b/crates/stdlib/src/json.rs
@@ -6,7 +6,7 @@ mod _json {
     use super::machinery;
     use crate::vm::{
         AsObject, Py, PyObjectRef, PyPayload, PyResult, VirtualMachine,
-        builtins::{PyBaseExceptionRef, PyStrRef, PyType},
+        builtins::{PyBaseExceptionRef, PyStrRef, PyType, PyUtf8StrRef},
         convert::ToPyResult,
         function::{IntoFuncArgs, OptionalArg},
         protocol::PyIterReturn,
@@ -91,14 +91,14 @@ mod _json {
     impl JsonScanner {
         fn parse(
             &self,
-            pystr: PyStrRef,
+            pystr: PyUtf8StrRef,
             char_idx: usize,
             byte_idx: usize,
             scan_once: PyObjectRef,
             vm: &VirtualMachine,
         ) -> PyResult<PyIterReturn> {
             flame_guard!("JsonScanner::parse");
-            let bytes = pystr.as_str().as_bytes();
+            let bytes = pystr.as_bytes();
             let wtf8 = pystr.as_wtf8();
 
             let first_byte = match bytes.get(byte_idx) {
@@ -115,7 +115,7 @@ mod _json {
                     // 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))?;
+                            .map_err(|e| py_decode_error(e, pystr.clone().into_wtf8(), vm))?;
                     let end_char_idx = char_idx + 1 + chars_consumed;
                     return Ok(PyIterReturn::Return(
                         vm.new_tuple((wtf8_result, end_char_idx)).into(),
@@ -228,7 +228,7 @@ mod _json {
         /// Returns (parsed_object, end_char_index, end_byte_index).
         fn parse_object(
             &self,
-            pystr: PyStrRef,
+            pystr: PyUtf8StrRef,
             start_char_idx: usize,
             start_byte_idx: usize,
             scan_once: &PyObjectRef,
@@ -237,7 +237,7 @@ mod _json {
         ) -> PyResult<(PyObjectRef, usize, usize)> {
             flame_guard!("JsonScanner::parse_object");
 
-            let bytes = pystr.as_str().as_bytes();
+            let bytes = pystr.as_bytes();
             let wtf8 = pystr.as_wtf8();
             let mut char_idx = start_char_idx;
             let mut byte_idx = start_byte_idx;
@@ -275,7 +275,7 @@ mod _json {
                 // 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))?;
+                        .map_err(|e| py_decode_error(e, pystr.clone().into_wtf8(), vm))?;
 
                 char_idx += chars_consumed;
                 byte_idx += bytes_consumed;
@@ -389,7 +389,7 @@ mod _json {
         /// Returns (parsed_array, end_char_index, end_byte_index).
         fn parse_array(
             &self,
-            pystr: PyStrRef,
+            pystr: PyUtf8StrRef,
             start_char_idx: usize,
             start_byte_idx: usize,
             scan_once: &PyObjectRef,
@@ -398,7 +398,7 @@ mod _json {
         ) -> PyResult<(PyObjectRef, usize, usize)> {
             flame_guard!("JsonScanner::parse_array");
 
-            let bytes = pystr.as_str().as_bytes();
+            let bytes = pystr.as_bytes();
             let mut char_idx = start_char_idx;
             let mut byte_idx = start_byte_idx;
 
@@ -507,15 +507,15 @@ mod _json {
         fn call_scan_once(
             &self,
             scan_once: &PyObjectRef,
-            pystr: PyStrRef,
+            pystr: PyUtf8StrRef,
             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 bytes = pystr.as_bytes();
             let wtf8 = pystr.as_wtf8();
+            let s = pystr.as_str();
 
             let first_byte = match bytes.get(byte_idx) {
                 Some(&b) => b,
@@ -527,7 +527,7 @@ mod _json {
                     // 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))?;
+                            .map_err(|e| py_decode_error(e, pystr.clone().into_wtf8(), vm))?;
                     let py_str = vm.ctx.new_str(wtf8_result.to_string());
                     Ok((
                         py_str.into(),
@@ -620,12 +620,12 @@ mod _json {
         fn make_decode_error(
             &self,
             msg: &str,
-            s: PyStrRef,
+            s: PyUtf8StrRef,
             pos: usize,
             vm: &VirtualMachine,
         ) -> PyBaseExceptionRef {
             let err = machinery::DecodeError::new(msg, pos);
-            py_decode_error(err, s, vm)
+            py_decode_error(err, s.into_wtf8(), vm)
         }
     }
 
@@ -636,6 +636,7 @@ mod _json {
                 return Err(vm.new_value_error("idx cannot be negative"));
             }
             let char_idx = char_idx as usize;
+            let pystr = pystr.try_into_utf8(vm)?;
             let s = pystr.as_str();
 
             // Calculate byte index from char index (O(char_idx) but only at entry point)
@@ -652,14 +653,8 @@ mod _json {
                 }
             };
 
-            zelf.parse(
-                pystr.clone(),
-                char_idx,
-                byte_idx,
-                zelf.to_owned().into(),
-                vm,
-            )
-            .and_then(|x| x.to_pyresult(vm))
+            zelf.parse(pystr, char_idx, byte_idx, zelf.to_owned().into(), vm)
+                .and_then(|x| x.to_pyresult(vm))
         }
     }
 
@@ -674,12 +669,12 @@ mod _json {
     }
 
     #[pyfunction]
-    fn encode_basestring(s: PyStrRef) -> String {
+    fn encode_basestring(s: PyUtf8StrRef) -> String {
         encode_string(s.as_str(), false)
     }
 
     #[pyfunction]
-    fn encode_basestring_ascii(s: PyStrRef) -> String {
+    fn encode_basestring_ascii(s: PyUtf8StrRef) -> String {
         encode_string(s.as_str(), true)
     }
 
diff --git a/crates/stdlib/src/json/machinery.rs b/crates/stdlib/src/json/machinery.rs
index f33a135ab20..2102d437396 100644
--- a/crates/stdlib/src/json/machinery.rs
+++ b/crates/stdlib/src/json/machinery.rs
@@ -44,7 +44,10 @@ static ESCAPE_CHARS: [&str; 0x20] = [
 // And which one need to be escaped (1)
 // The characters that need escaping are 0x00 to 0x1F, 0x22 ("), 0x5C (\), 0x7F (DEL)
 // Non-ASCII unicode characters can be safely included in a JSON string
-#[allow(clippy::unusual_byte_groupings)] // it's groups of 16, come on clippy
+#[allow(
+    clippy::unusual_byte_groupings,
+    reason = "groups of 16 are intentional here"
+)]
 static NEEDS_ESCAPING_BITSET: [u64; 4] = [
     //fedcba9876543210_fedcba9876543210_fedcba9876543210_fedcba9876543210
     0b0000000000000000_0000000000000100_1111111111111111_1111111111111111, // 3_2_1_0
diff --git a/crates/stdlib/src/lib.rs b/crates/stdlib/src/lib.rs
index e61ae918a78..941de413bfc 100644
--- a/crates/stdlib/src/lib.rs
+++ b/crates/stdlib/src/lib.rs
@@ -2,7 +2,6 @@
 // how `mod` works, but we want this sometimes for pymodule declarations
 
 #![allow(clippy::module_inception)]
-#![cfg_attr(all(target_os = "wasi", target_env = "p2"), feature(wasip2))]
 
 #[macro_use]
 extern crate rustpython_derive;
@@ -12,16 +11,15 @@ extern crate alloc;
 pub(crate) mod macros;
 
 mod _asyncio;
+mod _remote_debugging;
 pub mod array;
 mod binascii;
 mod bisect;
+mod bz2;
 mod cmath;
+mod compression; // internal module
 mod contextvars;
 mod csv;
-mod gc;
-
-mod bz2;
-mod compression; // internal module
 #[cfg(not(any(target_os = "android", target_arch = "wasm32")))]
 mod lzma;
 mod zlib;
@@ -36,12 +34,17 @@ mod sha512;
 
 mod json;
 
-#[cfg(not(any(target_os = "ios", target_arch = "wasm32")))]
+#[cfg(all(
+    feature = "host_env",
+    not(any(target_os = "ios", target_arch = "wasm32"))
+))]
 mod locale;
 
 mod _opcode;
+#[path = "_tokenize.rs"]
+mod _tokenize;
 mod math;
-#[cfg(any(unix, windows))]
+#[cfg(all(feature = "host_env", any(unix, windows)))]
 mod mmap;
 mod pyexpat;
 mod pystruct;
@@ -50,20 +53,26 @@ mod statistics;
 mod suggestions;
 // TODO: maybe make this an extension module, if we ever get those
 // mod re;
-#[cfg(not(target_arch = "wasm32"))]
+#[cfg(all(feature = "host_env", not(target_arch = "wasm32")))]
 pub mod socket;
-#[cfg(all(unix, not(target_os = "redox")))]
+#[cfg(all(feature = "host_env", unix, not(target_os = "redox")))]
 mod syslog;
 mod unicodedata;
 
+#[cfg(feature = "host_env")]
 mod faulthandler;
-#[cfg(any(unix, target_os = "wasi"))]
+#[cfg(all(feature = "host_env", any(unix, target_os = "wasi")))]
 mod fcntl;
-#[cfg(not(target_arch = "wasm32"))]
+#[cfg(all(feature = "host_env", not(target_arch = "wasm32")))]
 mod multiprocessing;
-#[cfg(all(unix, not(target_os = "redox"), not(target_os = "android")))]
+#[cfg(all(
+    feature = "host_env",
+    unix,
+    not(target_os = "redox"),
+    not(target_os = "android")
+))]
 mod posixshmem;
-#[cfg(unix)]
+#[cfg(all(feature = "host_env", unix))]
 mod posixsubprocess;
 // libc is missing constants on redox
 #[cfg(all(
@@ -71,36 +80,58 @@ mod posixsubprocess;
     not(any(target_os = "android", target_arch = "wasm32"))
 ))]
 mod _sqlite3;
-#[cfg(all(unix, not(any(target_os = "android", target_os = "redox"))))]
+#[cfg(all(feature = "host_env", windows))]
+mod _testconsole;
+#[cfg(all(
+    feature = "host_env",
+    unix,
+    not(any(target_os = "android", target_os = "redox"))
+))]
 mod grp;
-#[cfg(windows)]
+#[cfg(all(feature = "host_env", windows))]
 mod overlapped;
-#[cfg(all(unix, not(target_os = "redox")))]
+#[cfg(all(feature = "host_env", unix, not(target_os = "redox")))]
 mod resource;
-#[cfg(target_os = "macos")]
+#[cfg(all(feature = "host_env", target_os = "macos"))]
 mod scproxy;
-#[cfg(any(unix, windows, target_os = "wasi"))]
+#[cfg(all(feature = "host_env", any(unix, windows, target_os = "wasi")))]
 mod select;
 
-#[cfg(all(not(target_arch = "wasm32"), feature = "ssl-openssl"))]
+#[cfg(all(
+    feature = "host_env",
+    not(target_arch = "wasm32"),
+    feature = "ssl-openssl"
+))]
 mod openssl;
-#[cfg(all(not(target_arch = "wasm32"), feature = "ssl-rustls"))]
+#[cfg(all(
+    feature = "host_env",
+    not(target_arch = "wasm32"),
+    feature = "ssl-rustls"
+))]
 mod ssl;
 #[cfg(all(feature = "ssl-openssl", feature = "ssl-rustls"))]
 compile_error!("features \"ssl-openssl\" and \"ssl-rustls\" are mutually exclusive");
 
-#[cfg(all(unix, not(target_os = "redox"), not(target_os = "ios")))]
+#[cfg(all(
+    feature = "host_env",
+    unix,
+    not(target_os = "redox"),
+    not(target_os = "ios")
+))]
 mod termios;
-#[cfg(not(any(
-    target_os = "android",
-    target_os = "ios",
-    target_os = "windows",
-    target_arch = "wasm32",
-    target_os = "redox",
-)))]
+#[cfg(all(
+    feature = "host_env",
+    not(any(
+        target_os = "android",
+        target_os = "ios",
+        target_os = "windows",
+        target_arch = "wasm32",
+        target_os = "redox",
+    ))
+))]
 mod uuid;
 
-#[cfg(feature = "tkinter")]
+#[cfg(all(feature = "host_env", feature = "tkinter"))]
 mod tkinter;
 
 use rustpython_common as common;
@@ -115,6 +146,7 @@ pub fn stdlib_module_defs(ctx: &Context) -> Vec<&'static builtins::PyModuleDef>
     vec![
         _asyncio::module_def(ctx),
         _opcode::module_def(ctx),
+        _remote_debugging::module_def(ctx),
         array::module_def(ctx),
         binascii::module_def(ctx),
         bisect::module_def(ctx),
@@ -123,70 +155,100 @@ pub fn stdlib_module_defs(ctx: &Context) -> Vec<&'static builtins::PyModuleDef>
         cmath::module_def(ctx),
         contextvars::module_def(ctx),
         csv::module_def(ctx),
+        #[cfg(feature = "host_env")]
         faulthandler::module_def(ctx),
-        #[cfg(any(unix, target_os = "wasi"))]
+        #[cfg(all(feature = "host_env", any(unix, target_os = "wasi")))]
         fcntl::module_def(ctx),
-        gc::module_def(ctx),
-        #[cfg(all(unix, not(any(target_os = "android", target_os = "redox"))))]
+        #[cfg(all(
+            feature = "host_env",
+            unix,
+            not(any(target_os = "android", target_os = "redox"))
+        ))]
         grp::module_def(ctx),
         hashlib::module_def(ctx),
         json::module_def(ctx),
-        #[cfg(not(any(target_os = "ios", target_arch = "wasm32")))]
+        #[cfg(all(
+            feature = "host_env",
+            not(any(target_os = "ios", target_arch = "wasm32"))
+        ))]
         locale::module_def(ctx),
         #[cfg(not(any(target_os = "android", target_arch = "wasm32")))]
         lzma::module_def(ctx),
         math::module_def(ctx),
         md5::module_def(ctx),
-        #[cfg(any(unix, windows))]
+        #[cfg(all(feature = "host_env", any(unix, windows)))]
         mmap::module_def(ctx),
-        #[cfg(not(target_arch = "wasm32"))]
+        #[cfg(all(feature = "host_env", not(target_arch = "wasm32")))]
         multiprocessing::module_def(ctx),
-        #[cfg(all(not(target_arch = "wasm32"), feature = "ssl-openssl"))]
+        #[cfg(all(
+            feature = "host_env",
+            not(target_arch = "wasm32"),
+            feature = "ssl-openssl"
+        ))]
         openssl::module_def(ctx),
-        #[cfg(windows)]
+        #[cfg(all(feature = "host_env", windows))]
+        _testconsole::module_def(ctx),
+        #[cfg(all(feature = "host_env", windows))]
         overlapped::module_def(ctx),
-        #[cfg(unix)]
+        #[cfg(all(feature = "host_env", unix))]
         posixsubprocess::module_def(ctx),
-        #[cfg(all(unix, not(target_os = "redox"), not(target_os = "android")))]
+        #[cfg(all(
+            feature = "host_env",
+            unix,
+            not(target_os = "redox"),
+            not(target_os = "android")
+        ))]
         posixshmem::module_def(ctx),
         pyexpat::module_def(ctx),
         pystruct::module_def(ctx),
         random::module_def(ctx),
-        #[cfg(all(unix, not(target_os = "redox")))]
+        #[cfg(all(feature = "host_env", unix, not(target_os = "redox")))]
         resource::module_def(ctx),
-        #[cfg(target_os = "macos")]
+        #[cfg(all(feature = "host_env", target_os = "macos"))]
         scproxy::module_def(ctx),
-        #[cfg(any(unix, windows, target_os = "wasi"))]
+        #[cfg(all(feature = "host_env", any(unix, windows, target_os = "wasi")))]
         select::module_def(ctx),
         sha1::module_def(ctx),
         sha256::module_def(ctx),
         sha3::module_def(ctx),
         sha512::module_def(ctx),
-        #[cfg(not(target_arch = "wasm32"))]
+        #[cfg(all(feature = "host_env", not(target_arch = "wasm32")))]
         socket::module_def(ctx),
         #[cfg(all(
             feature = "sqlite",
             not(any(target_os = "android", target_arch = "wasm32"))
         ))]
         _sqlite3::module_def(ctx),
-        #[cfg(all(not(target_arch = "wasm32"), feature = "ssl-rustls"))]
+        #[cfg(all(
+            feature = "host_env",
+            not(target_arch = "wasm32"),
+            feature = "ssl-rustls"
+        ))]
         ssl::module_def(ctx),
         statistics::module_def(ctx),
         suggestions::module_def(ctx),
-        #[cfg(all(unix, not(target_os = "redox")))]
+        _tokenize::module_def(ctx),
+        #[cfg(all(feature = "host_env", unix, not(target_os = "redox")))]
         syslog::module_def(ctx),
-        #[cfg(all(unix, not(any(target_os = "ios", target_os = "redox"))))]
+        #[cfg(all(
+            feature = "host_env",
+            unix,
+            not(any(target_os = "ios", target_os = "redox"))
+        ))]
         termios::module_def(ctx),
-        #[cfg(feature = "tkinter")]
+        #[cfg(all(feature = "host_env", feature = "tkinter"))]
         tkinter::module_def(ctx),
         unicodedata::module_def(ctx),
-        #[cfg(not(any(
-            target_os = "android",
-            target_os = "ios",
-            target_os = "windows",
-            target_arch = "wasm32",
-            target_os = "redox"
-        )))]
+        #[cfg(all(
+            feature = "host_env",
+            not(any(
+                target_os = "android",
+                target_os = "ios",
+                target_os = "windows",
+                target_arch = "wasm32",
+                target_os = "redox"
+            ))
+        ))]
         uuid::module_def(ctx),
         zlib::module_def(ctx),
     ]
diff --git a/crates/stdlib/src/locale.rs b/crates/stdlib/src/locale.rs
index 98db77d0d75..a22c6afe57e 100644
--- a/crates/stdlib/src/locale.rs
+++ b/crates/stdlib/src/locale.rs
@@ -45,7 +45,7 @@ mod _locale {
     use core::{ffi::CStr, ptr};
     use rustpython_vm::{
         PyObjectRef, PyResult, VirtualMachine,
-        builtins::{PyDictRef, PyIntRef, PyListRef, PyStrRef, PyTypeRef},
+        builtins::{PyDictRef, PyIntRef, PyListRef, PyTypeRef, PyUtf8StrRef},
         convert::ToPyException,
         function::OptionalArg,
     };
@@ -101,10 +101,42 @@ mod _locale {
 
     unsafe fn pystr_from_raw_cstr(vm: &VirtualMachine, raw_ptr: *const libc::c_char) -> PyResult {
         let slice = unsafe { CStr::from_ptr(raw_ptr) };
-        let string = slice
-            .to_str()
-            .expect("localeconv always return decodable string");
-        Ok(vm.new_pyobj(string))
+
+        // Fast path: ASCII/UTF-8
+        if let Ok(s) = slice.to_str() {
+            return Ok(vm.new_pyobj(s));
+        }
+
+        // On Windows, locale strings use the ANSI code page encoding
+        #[cfg(windows)]
+        {
+            use windows_sys::Win32::Globalization::{CP_ACP, MultiByteToWideChar};
+            let bytes = slice.to_bytes();
+            unsafe {
+                let len = MultiByteToWideChar(
+                    CP_ACP,
+                    0,
+                    bytes.as_ptr(),
+                    bytes.len() as i32,
+                    ptr::null_mut(),
+                    0,
+                );
+                if len > 0 {
+                    let mut wide = vec![0u16; len as usize];
+                    MultiByteToWideChar(
+                        CP_ACP,
+                        0,
+                        bytes.as_ptr(),
+                        bytes.len() as i32,
+                        wide.as_mut_ptr(),
+                        len,
+                    );
+                    return Ok(vm.new_pyobj(String::from_utf16_lossy(&wide)));
+                }
+            }
+        }
+
+        Ok(vm.new_pyobj(String::from_utf8_lossy(slice.to_bytes()).into_owned()))
     }
 
     #[pyattr(name = "Error", once)]
@@ -117,14 +149,14 @@ mod _locale {
     }
 
     #[pyfunction]
-    fn strcoll(string1: PyStrRef, string2: PyStrRef, vm: &VirtualMachine) -> PyResult {
+    fn strcoll(string1: PyUtf8StrRef, string2: PyUtf8StrRef, vm: &VirtualMachine) -> PyResult {
         let cstr1 = CString::new(string1.as_str()).map_err(|e| e.to_pyexception(vm))?;
         let cstr2 = CString::new(string2.as_str()).map_err(|e| e.to_pyexception(vm))?;
         Ok(vm.new_pyobj(unsafe { libc::strcoll(cstr1.as_ptr(), cstr2.as_ptr()) }))
     }
 
     #[pyfunction]
-    fn strxfrm(string: PyStrRef, vm: &VirtualMachine) -> PyResult {
+    fn strxfrm(string: PyUtf8StrRef, vm: &VirtualMachine) -> PyResult {
         // https://github.com/python/cpython/blob/eaae563b6878aa050b4ad406b67728b6b066220e/Modules/_localemodule.c#L390-L442
         let n1 = string.byte_len() + 1;
         let mut buff = vec![0u8; n1];
@@ -195,7 +227,7 @@ mod _locale {
         #[pyarg(any)]
         category: i32,
         #[pyarg(any, optional)]
-        locale: OptionalArg<Option<PyStrRef>>,
+        locale: OptionalArg<Option<PyUtf8StrRef>>,
     }
 
     /// Maximum code page encoding name length on Windows
@@ -230,34 +262,34 @@ mod _locale {
     fn setlocale(args: LocaleArgs, vm: &VirtualMachine) -> PyResult {
         let error = error(vm);
         if cfg!(windows) && (args.category < LC_ALL || args.category > LC_TIME) {
-            return Err(vm.new_exception_msg(error, String::from("unsupported locale setting")));
+            return Err(vm.new_exception_msg(error, "unsupported locale setting".into()));
         }
         unsafe {
             let result = match args.locale.flatten() {
                 None => libc::setlocale(args.category, ptr::null()),
                 Some(locale) => {
+                    let locale_str = locale.as_str();
                     // On Windows, validate encoding name length
                     #[cfg(windows)]
                     {
                         let valid = if args.category == LC_ALL {
-                            check_locale_name_all(locale.as_str())
+                            check_locale_name_all(locale_str)
                         } else {
-                            check_locale_name(locale.as_str())
+                            check_locale_name(locale_str)
                         };
                         if !valid {
-                            return Err(vm.new_exception_msg(
-                                error,
-                                String::from("unsupported locale setting"),
-                            ));
+                            return Err(
+                                vm.new_exception_msg(error, "unsupported locale setting".into())
+                            );
                         }
                     }
                     let c_locale: CString =
-                        CString::new(locale.as_str()).map_err(|e| e.to_pyexception(vm))?;
+                        CString::new(locale_str).map_err(|e| e.to_pyexception(vm))?;
                     libc::setlocale(args.category, c_locale.as_ptr())
                 }
             };
             if result.is_null() {
-                return Err(vm.new_exception_msg(error, String::from("unsupported locale setting")));
+                return Err(vm.new_exception_msg(error, "unsupported locale setting".into()));
             }
             pystr_from_raw_cstr(vm, result)
         }
diff --git a/crates/stdlib/src/lzma.rs b/crates/stdlib/src/lzma.rs
index 0189c9d2ed0..b98cfb1bf94 100644
--- a/crates/stdlib/src/lzma.rs
+++ b/crates/stdlib/src/lzma.rs
@@ -1,4 +1,4 @@
-// spell-checker:ignore ARMTHUMB
+// spell-checker:ignore ARMTHUMB memlimit
 
 pub(crate) use _lzma::module_def;
 
@@ -9,51 +9,63 @@ mod _lzma {
         DecompressError, DecompressState, DecompressStatus, Decompressor,
     };
     use alloc::fmt;
-    #[pyattr]
-    use lzma_sys::{
-        LZMA_CHECK_CRC32 as CHECK_CRC32, LZMA_CHECK_CRC64 as CHECK_CRC64,
-        LZMA_CHECK_NONE as CHECK_NONE, LZMA_CHECK_SHA256 as CHECK_SHA256,
+    use liblzma::stream::{
+        Action, Check, Error, Filters, LzmaOptions, MatchFinder, Mode, Status, Stream,
+        TELL_ANY_CHECK, TELL_NO_CHECK,
     };
+    // lzma_check, lzma_mode, lzma_match_finder have platform-dependent signedness
+    // (i32 on Windows, u32 elsewhere). Define as fixed-type const to avoid mismatch.
     #[pyattr]
-    use lzma_sys::{
+    use liblzma_sys::{
         LZMA_FILTER_ARM as FILTER_ARM, LZMA_FILTER_ARMTHUMB as FILTER_ARMTHUMB,
-        LZMA_FILTER_IA64 as FILTER_IA64, LZMA_FILTER_LZMA1 as FILTER_LZMA1,
-        LZMA_FILTER_LZMA2 as FILTER_LZMA2, LZMA_FILTER_POWERPC as FILTER_POWERPC,
-        LZMA_FILTER_SPARC as FILTER_SPARC, LZMA_FILTER_X86 as FILTER_X86,
-    };
-    #[pyattr]
-    use lzma_sys::{
-        LZMA_MF_BT2 as MF_BT2, LZMA_MF_BT3 as MF_BT3, LZMA_MF_BT4 as MF_BT4, LZMA_MF_HC3 as MF_HC3,
-        LZMA_MF_HC4 as MF_HC4,
+        LZMA_FILTER_DELTA as FILTER_DELTA, LZMA_FILTER_IA64 as FILTER_IA64,
+        LZMA_FILTER_LZMA1 as FILTER_LZMA1, LZMA_FILTER_LZMA2 as FILTER_LZMA2,
+        LZMA_FILTER_POWERPC as FILTER_POWERPC, LZMA_FILTER_SPARC as FILTER_SPARC,
+        LZMA_FILTER_X86 as FILTER_X86,
     };
     #[pyattr]
-    use lzma_sys::{LZMA_MODE_FAST as MODE_FAST, LZMA_MODE_NORMAL as MODE_NORMAL};
-    #[pyattr]
-    use lzma_sys::{
+    use liblzma_sys::{
         LZMA_PRESET_DEFAULT as PRESET_DEFAULT, LZMA_PRESET_EXTREME as PRESET_EXTREME,
-        LZMA_PRESET_LEVEL_MASK as PRESET_LEVEL_MASK,
     };
     use rustpython_common::lock::PyMutex;
-    use rustpython_vm::builtins::{PyBaseExceptionRef, PyBytesRef, PyType, PyTypeRef};
+    use rustpython_vm::builtins::{PyBaseExceptionRef, PyBytesRef, PyDict, PyType, PyTypeRef};
     use rustpython_vm::convert::ToPyException;
     use rustpython_vm::function::ArgBytesLike;
     use rustpython_vm::types::Constructor;
     use rustpython_vm::{Py, PyObjectRef, PyPayload, PyResult, VirtualMachine};
-    use xz2::stream::{Action, Check, Error, Filters, LzmaOptions, Status, Stream};
-
-    #[cfg(windows)]
-    type EnumVal = i32;
-    #[cfg(not(windows))]
-    type EnumVal = u32;
 
     const BUFSIZ: usize = 8192;
-    // TODO: can't find this in lzma-sys, but find way not to hardcode this
+
+    // liblzma_sys enum types have platform-dependent signedness; `as _` normalizes to i32
+    #[pyattr]
+    const CHECK_NONE: i32 = liblzma_sys::LZMA_CHECK_NONE as _;
     #[pyattr]
-    const FILTER_DELTA: i32 = 3;
+    const CHECK_CRC32: i32 = liblzma_sys::LZMA_CHECK_CRC32 as _;
     #[pyattr]
-    const CHECK_UNKNOWN: i32 = 16;
+    const CHECK_CRC64: i32 = liblzma_sys::LZMA_CHECK_CRC64 as _;
+    #[pyattr]
+    const CHECK_SHA256: i32 = liblzma_sys::LZMA_CHECK_SHA256 as _;
+    #[pyattr]
+    const CHECK_ID_MAX: i32 = 15;
+    #[pyattr]
+    const CHECK_UNKNOWN: i32 = CHECK_ID_MAX + 1;
+
+    #[pyattr]
+    const MF_HC3: i32 = liblzma_sys::LZMA_MF_HC3 as _;
+    #[pyattr]
+    const MF_HC4: i32 = liblzma_sys::LZMA_MF_HC4 as _;
+    #[pyattr]
+    const MF_BT2: i32 = liblzma_sys::LZMA_MF_BT2 as _;
+    #[pyattr]
+    const MF_BT3: i32 = liblzma_sys::LZMA_MF_BT3 as _;
+    #[pyattr]
+    const MF_BT4: i32 = liblzma_sys::LZMA_MF_BT4 as _;
+
+    #[pyattr]
+    const MODE_FAST: i32 = liblzma_sys::LZMA_MODE_FAST as _;
+    #[pyattr]
+    const MODE_NORMAL: i32 = liblzma_sys::LZMA_MODE_NORMAL as _;
 
-    // the variant ids are hardcoded to be equivalent to the C enum values
     enum Format {
         Auto = 0,
         Xz = 1,
@@ -80,47 +92,110 @@ mod _lzma {
     }
 
     fn new_lzma_error(message: impl Into<String>, vm: &VirtualMachine) -> PyBaseExceptionRef {
-        vm.new_exception_msg(vm.class("lzma", "LZMAError"), message.into())
+        let msg: String = message.into();
+        vm.new_exception_msg(vm.class("lzma", "LZMAError"), msg.into())
     }
 
-    #[pyfunction]
-    fn is_check_supported(check: i32) -> bool {
-        unsafe { lzma_sys::lzma_check_is_supported(check as _) != 0 }
+    fn catch_lzma_error(err: Error, vm: &VirtualMachine) -> PyBaseExceptionRef {
+        match err {
+            Error::UnsupportedCheck => new_lzma_error("Unsupported integrity check", vm),
+            Error::Mem => vm.new_memory_error(""),
+            Error::MemLimit => new_lzma_error("Memory usage limit exceeded", vm),
+            Error::Format => new_lzma_error("Input format not supported by decoder", vm),
+            Error::Options => new_lzma_error("Invalid or unsupported options", vm),
+            Error::Data => new_lzma_error("Corrupt input data", vm),
+            Error::Program => new_lzma_error("Internal error", vm),
+            Error::NoCheck => new_lzma_error("Corrupt input data", vm),
+        }
     }
 
-    // TODO: To implement these we need a function to convert a pyobject to a lzma filter and related structs
-    #[pyfunction]
-    fn _encode_filter_properties() -> PyResult<()> {
-        Ok(())
+    fn int_to_check(check: i32) -> Option<Check> {
+        if check == -1 {
+            return Some(Check::Crc64);
+        }
+        match check {
+            CHECK_NONE => Some(Check::None),
+            CHECK_CRC32 => Some(Check::Crc32),
+            CHECK_CRC64 => Some(Check::Crc64),
+            CHECK_SHA256 => Some(Check::Sha256),
+            _ => None,
+        }
     }
 
-    #[pyfunction]
-    fn _decode_filter_properties(_filter_id: u64, _buffer: ArgBytesLike) -> PyResult<()> {
-        Ok(())
+    fn u32_to_mode(val: u32) -> Option<Mode> {
+        match val as i32 {
+            MODE_FAST => Some(Mode::Fast),
+            MODE_NORMAL => Some(Mode::Normal),
+            _ => None,
+        }
     }
 
-    #[pyattr]
-    #[pyclass(name = "LZMADecompressor")]
-    #[derive(PyPayload)]
-    struct LZMADecompressor {
-        state: PyMutex<DecompressState<Stream>>,
+    fn u32_to_mf(val: u32) -> Option<MatchFinder> {
+        match val as i32 {
+            MF_HC3 => Some(MatchFinder::HashChain3),
+            MF_HC4 => Some(MatchFinder::HashChain4),
+            MF_BT2 => Some(MatchFinder::BinaryTree2),
+            MF_BT3 => Some(MatchFinder::BinaryTree3),
+            MF_BT4 => Some(MatchFinder::BinaryTree4),
+            _ => None,
+        }
+    }
+
+    struct LzmaStream {
+        stream: Stream,
+        check: i32,
+        header_buf: [u8; 8],
+        header_collected: u8,
+        track_header: bool,
     }
 
-    impl Decompressor for Stream {
+    impl LzmaStream {
+        fn new(stream: Stream, check: i32, track_header: bool) -> Self {
+            Self {
+                stream,
+                check,
+                header_buf: [0u8; 8],
+                header_collected: 0,
+                track_header,
+            }
+        }
+    }
+
+    impl Decompressor for LzmaStream {
         type Flush = ();
         type Status = Status;
         type Error = Error;
 
         fn total_in(&self) -> u64 {
-            self.total_in()
+            self.stream.total_in()
         }
+
         fn decompress_vec(
             &mut self,
             input: &[u8],
             output: &mut Vec<u8>,
             (): Self::Flush,
         ) -> Result<Self::Status, Self::Error> {
-            self.process_vec(input, output, Action::Run)
+            if self.track_header && self.header_collected < 8 {
+                let need = (8 - self.header_collected) as usize;
+                let n = need.min(input.len());
+                self.header_buf[self.header_collected as usize..][..n].copy_from_slice(&input[..n]);
+                self.header_collected += n as u8;
+            }
+
+            match self.stream.process_vec(input, output, Action::Run) {
+                Ok(Status::GetCheck) => {
+                    if self.header_collected >= 8 {
+                        self.check = (self.header_buf[7] & 0x0F) as i32;
+                    }
+                    Ok(Status::Ok)
+                }
+                Err(Error::NoCheck) => {
+                    self.check = CHECK_NONE;
+                    Ok(Status::Ok)
+                }
+                other => other,
+            }
         }
     }
 
@@ -130,43 +205,426 @@ mod _lzma {
         }
     }
 
+    fn get_dict_opt_u32(
+        spec: &PyObjectRef,
+        key: &str,
+        vm: &VirtualMachine,
+    ) -> PyResult<Option<u32>> {
+        let dict = spec.downcast_ref::<PyDict>().ok_or_else(|| {
+            vm.new_type_error("Filter specifier must be a dict or dict-like object")
+        })?;
+        match dict.get_item_opt(key, vm)? {
+            Some(obj) => Ok(Some(obj.try_into_value::<u32>(vm)?)),
+            None => Ok(None),
+        }
+    }
+
+    fn get_dict_opt_u64(
+        spec: &PyObjectRef,
+        key: &str,
+        vm: &VirtualMachine,
+    ) -> PyResult<Option<u64>> {
+        let dict = spec.downcast_ref::<PyDict>().ok_or_else(|| {
+            vm.new_type_error("Filter specifier must be a dict or dict-like object")
+        })?;
+        match dict.get_item_opt(key, vm)? {
+            Some(obj) => Ok(Some(obj.try_into_value::<u64>(vm)?)),
+            None => Ok(None),
+        }
+    }
+
+    fn parse_filter_spec_lzma(spec: &PyObjectRef, vm: &VirtualMachine) -> PyResult<LzmaOptions> {
+        let preset = get_dict_opt_u32(spec, "preset", vm)?.unwrap_or(PRESET_DEFAULT);
+
+        let mut opts = LzmaOptions::new_preset(preset)
+            .map_err(|_| new_lzma_error(format!("Invalid compression preset: {preset}"), vm))?;
+
+        if let Some(v) = get_dict_opt_u32(spec, "dict_size", vm)? {
+            opts.dict_size(v);
+        }
+        if let Some(v) = get_dict_opt_u32(spec, "lc", vm)? {
+            opts.literal_context_bits(v);
+        }
+        if let Some(v) = get_dict_opt_u32(spec, "lp", vm)? {
+            opts.literal_position_bits(v);
+        }
+        if let Some(v) = get_dict_opt_u32(spec, "pb", vm)? {
+            opts.position_bits(v);
+        }
+        if let Some(v) = get_dict_opt_u32(spec, "mode", vm)? {
+            let mode = u32_to_mode(v)
+                .ok_or_else(|| vm.new_value_error("Invalid filter specifier for LZMA filter"))?;
+            opts.mode(mode);
+        }
+        if let Some(v) = get_dict_opt_u32(spec, "nice_len", vm)? {
+            opts.nice_len(v);
+        }
+        if let Some(v) = get_dict_opt_u32(spec, "mf", vm)? {
+            let mf = u32_to_mf(v)
+                .ok_or_else(|| vm.new_value_error("Invalid filter specifier for LZMA filter"))?;
+            opts.match_finder(mf);
+        }
+        if let Some(v) = get_dict_opt_u32(spec, "depth", vm)? {
+            opts.depth(v);
+        }
+
+        Ok(opts)
+    }
+
+    fn parse_filter_spec_delta(spec: &PyObjectRef, vm: &VirtualMachine) -> PyResult<u32> {
+        let dist = get_dict_opt_u32(spec, "dist", vm)?.unwrap_or(1);
+        if dist == 0 || dist > 256 {
+            return Err(vm.new_value_error("Invalid filter specifier for delta filter"));
+        }
+        Ok(dist)
+    }
+
+    fn parse_filter_spec_bcj(spec: &PyObjectRef, vm: &VirtualMachine) -> PyResult<u32> {
+        Ok(get_dict_opt_u32(spec, "start_offset", vm)?.unwrap_or(0))
+    }
+
+    fn add_bcj_filter(
+        filters: &mut Filters,
+        filter_id: u64,
+        start_offset: u32,
+    ) -> Result<(), Error> {
+        if start_offset == 0 {
+            match filter_id {
+                FILTER_X86 => {
+                    filters.x86();
+                }
+                FILTER_POWERPC => {
+                    filters.powerpc();
+                }
+                FILTER_IA64 => {
+                    filters.ia64();
+                }
+                FILTER_ARM => {
+                    filters.arm();
+                }
+                FILTER_ARMTHUMB => {
+                    filters.arm_thumb();
+                }
+                FILTER_SPARC => {
+                    filters.sparc();
+                }
+                _ => unreachable!(),
+            }
+            Ok(())
+        } else {
+            let props = start_offset.to_le_bytes();
+            match filter_id {
+                FILTER_X86 => {
+                    filters.x86_properties(&props)?;
+                }
+                FILTER_POWERPC => {
+                    filters.powerpc_properties(&props)?;
+                }
+                FILTER_IA64 => {
+                    filters.ia64_properties(&props)?;
+                }
+                FILTER_ARM => {
+                    filters.arm_properties(&props)?;
+                }
+                FILTER_ARMTHUMB => {
+                    filters.arm_thumb_properties(&props)?;
+                }
+                FILTER_SPARC => {
+                    filters.sparc_properties(&props)?;
+                }
+                _ => unreachable!(),
+            }
+            Ok(())
+        }
+    }
+
+    fn parse_filter_chain_spec(
+        filter_specs: Vec<PyObjectRef>,
+        vm: &VirtualMachine,
+    ) -> PyResult<Filters> {
+        const LZMA_FILTERS_MAX: usize = 4;
+        if filter_specs.len() > LZMA_FILTERS_MAX {
+            return Err(new_lzma_error(
+                format!("Too many filters - liblzma supports a maximum of {LZMA_FILTERS_MAX}"),
+                vm,
+            ));
+        }
+
+        let mut filters = Filters::new();
+        for spec in &filter_specs {
+            let filter_id = get_dict_opt_u64(spec, "id", vm)?
+                .ok_or_else(|| vm.new_value_error("Filter specifier must have an \"id\" entry"))?;
+
+            match filter_id {
+                FILTER_LZMA1 => {
+                    let opts = parse_filter_spec_lzma(spec, vm)?;
+                    filters.lzma1(&opts);
+                }
+                FILTER_LZMA2 => {
+                    let opts = parse_filter_spec_lzma(spec, vm)?;
+                    filters.lzma2(&opts);
+                }
+                FILTER_DELTA => {
+                    let dist = parse_filter_spec_delta(spec, vm)?;
+                    filters
+                        .delta_properties(&[(dist - 1) as u8])
+                        .map_err(|e| catch_lzma_error(e, vm))?;
+                }
+                FILTER_X86 | FILTER_POWERPC | FILTER_IA64 | FILTER_ARM | FILTER_ARMTHUMB
+                | FILTER_SPARC => {
+                    let start_offset = parse_filter_spec_bcj(spec, vm)?;
+                    add_bcj_filter(&mut filters, filter_id, start_offset)
+                        .map_err(|e| catch_lzma_error(e, vm))?;
+                }
+                _ => {
+                    return Err(vm.new_value_error(format!("Invalid filter ID: {filter_id}")));
+                }
+            }
+        }
+
+        Ok(filters)
+    }
+
+    const DEFAULT_LC: u32 = liblzma_sys::LZMA_LC_DEFAULT;
+    const DEFAULT_LP: u32 = liblzma_sys::LZMA_LP_DEFAULT;
+    const DEFAULT_PB: u32 = liblzma_sys::LZMA_PB_DEFAULT;
+    const DICT_POW2: [u8; 10] = [18, 20, 21, 22, 22, 23, 23, 24, 25, 26];
+
+    fn preset_dict_size(preset: u32) -> u32 {
+        let level = (preset & liblzma_sys::LZMA_PRESET_LEVEL_MASK) as usize;
+        if level > 9 {
+            return 0;
+        }
+        1u32 << DICT_POW2[level]
+    }
+
+    fn lzma2_dict_size_from_prop(prop: u8) -> u32 {
+        if prop > 40 {
+            return u32::MAX;
+        }
+        if prop == 40 {
+            return u32::MAX;
+        }
+        let prop = prop as u32;
+        (2 | (prop & 1)) << (prop / 2 + 11)
+    }
+
+    fn lzma2_prop_from_dict_size(dict_size: u32) -> u8 {
+        if dict_size == u32::MAX {
+            return 40;
+        }
+        for i in 0u8..40 {
+            if lzma2_dict_size_from_prop(i) >= dict_size {
+                return i;
+            }
+        }
+        40
+    }
+
+    fn encode_lzma1_properties(lc: u32, lp: u32, pb: u32, dict_size: u32) -> Vec<u8> {
+        let mut result = vec![0u8; 5];
+        result[0] = ((pb * 5 + lp) * 9 + lc) as u8;
+        result[1..5].copy_from_slice(&dict_size.to_le_bytes());
+        result
+    }
+
+    fn decode_lzma1_properties(props: &[u8]) -> Option<(u32, u32, u32, u32)> {
+        if props.len() < 5 {
+            return None;
+        }
+        let mut d = props[0] as u32;
+        let lc = d % 9;
+        d /= 9;
+        let lp = d % 5;
+        let pb = d / 5;
+        let dict_size = u32::from_le_bytes([props[1], props[2], props[3], props[4]]);
+        Some((lc, lp, pb, dict_size))
+    }
+
+    fn build_filter_spec(
+        filter_id: u64,
+        props: &[u8],
+        vm: &VirtualMachine,
+    ) -> PyResult<PyObjectRef> {
+        let dict = vm.ctx.new_dict();
+        dict.set_item("id", vm.new_pyobj(filter_id), vm)?;
+
+        match filter_id {
+            FILTER_LZMA1 => {
+                let (lc, lp, pb, dict_size) = decode_lzma1_properties(props)
+                    .ok_or_else(|| new_lzma_error("Invalid or unsupported options", vm))?;
+                dict.set_item("lc", vm.new_pyobj(lc), vm)?;
+                dict.set_item("lp", vm.new_pyobj(lp), vm)?;
+                dict.set_item("pb", vm.new_pyobj(pb), vm)?;
+                dict.set_item("dict_size", vm.new_pyobj(dict_size), vm)?;
+            }
+            FILTER_LZMA2 => {
+                if props.len() != 1 {
+                    return Err(new_lzma_error("Invalid or unsupported options", vm));
+                }
+                let dict_size = lzma2_dict_size_from_prop(props[0]);
+                dict.set_item("dict_size", vm.new_pyobj(dict_size), vm)?;
+            }
+            FILTER_DELTA => {
+                if props.len() != 1 {
+                    return Err(new_lzma_error("Invalid or unsupported options", vm));
+                }
+                let dist = props[0] as u32 + 1;
+                dict.set_item("dist", vm.new_pyobj(dist), vm)?;
+            }
+            FILTER_X86 | FILTER_POWERPC | FILTER_IA64 | FILTER_ARM | FILTER_ARMTHUMB
+            | FILTER_SPARC => {
+                if props.is_empty() {
+                    // default: no start_offset
+                } else if props.len() == 4 {
+                    let start_offset = u32::from_le_bytes([props[0], props[1], props[2], props[3]]);
+                    dict.set_item("start_offset", vm.new_pyobj(start_offset), vm)?;
+                } else {
+                    return Err(new_lzma_error("Invalid or unsupported options", vm));
+                }
+            }
+            _ => {
+                return Err(vm.new_value_error(format!("Invalid filter ID: {filter_id}")));
+            }
+        }
+
+        Ok(dict.into())
+    }
+
+    #[pyfunction]
+    fn is_check_supported(check_id: i32) -> bool {
+        unsafe { liblzma_sys::lzma_check_is_supported(check_id as _) != 0 }
+    }
+
+    #[pyfunction]
+    fn _encode_filter_properties(
+        filter_spec: PyObjectRef,
+        vm: &VirtualMachine,
+    ) -> PyResult<Vec<u8>> {
+        let filter_id = get_dict_opt_u64(&filter_spec, "id", vm)?
+            .ok_or_else(|| vm.new_value_error("Filter specifier must have an \"id\" entry"))?;
+
+        match filter_id {
+            FILTER_LZMA1 => {
+                let preset =
+                    get_dict_opt_u32(&filter_spec, "preset", vm)?.unwrap_or(PRESET_DEFAULT);
+                let lc = get_dict_opt_u32(&filter_spec, "lc", vm)?.unwrap_or(DEFAULT_LC);
+                let lp = get_dict_opt_u32(&filter_spec, "lp", vm)?.unwrap_or(DEFAULT_LP);
+                let pb = get_dict_opt_u32(&filter_spec, "pb", vm)?.unwrap_or(DEFAULT_PB);
+                let dict_size = get_dict_opt_u32(&filter_spec, "dict_size", vm)?
+                    .unwrap_or_else(|| preset_dict_size(preset));
+                Ok(encode_lzma1_properties(lc, lp, pb, dict_size))
+            }
+            FILTER_LZMA2 => {
+                let preset =
+                    get_dict_opt_u32(&filter_spec, "preset", vm)?.unwrap_or(PRESET_DEFAULT);
+                let dict_size = get_dict_opt_u32(&filter_spec, "dict_size", vm)?
+                    .unwrap_or_else(|| preset_dict_size(preset));
+                Ok(vec![lzma2_prop_from_dict_size(dict_size)])
+            }
+            FILTER_DELTA => {
+                let dist = get_dict_opt_u32(&filter_spec, "dist", vm)?.unwrap_or(1);
+                if dist == 0 || dist > 256 {
+                    return Err(vm.new_value_error("Invalid filter specifier for delta filter"));
+                }
+                Ok(vec![(dist - 1) as u8])
+            }
+            FILTER_X86 | FILTER_POWERPC | FILTER_IA64 | FILTER_ARM | FILTER_ARMTHUMB
+            | FILTER_SPARC => {
+                let start_offset = get_dict_opt_u32(&filter_spec, "start_offset", vm)?.unwrap_or(0);
+                if start_offset == 0 {
+                    Ok(vec![])
+                } else {
+                    Ok(start_offset.to_le_bytes().to_vec())
+                }
+            }
+            _ => Err(vm.new_value_error(format!("Invalid filter ID: {filter_id}"))),
+        }
+    }
+
+    #[pyfunction]
+    fn _decode_filter_properties(
+        filter_id: u64,
+        encoded_props: ArgBytesLike,
+        vm: &VirtualMachine,
+    ) -> PyResult<PyObjectRef> {
+        let props = encoded_props.borrow_buf();
+        build_filter_spec(filter_id, &props, vm)
+    }
+
+    #[pyattr]
+    #[pyclass(name = "LZMADecompressor")]
+    #[derive(PyPayload)]
+    struct LZMADecompressor {
+        state: PyMutex<DecompressState<LzmaStream>>,
+    }
+
     impl fmt::Debug for LZMADecompressor {
         fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
             write!(f, "_lzma.LZMADecompressor")
         }
     }
+
     #[derive(FromArgs)]
     pub struct LZMADecompressorConstructorArgs {
         #[pyarg(any, default = FORMAT_AUTO)]
         format: i32,
         #[pyarg(any, optional)]
-        mem_limit: Option<u64>,
+        memlimit: Option<u64>,
         #[pyarg(any, optional)]
-        filters: Option<u32>,
+        filters: Option<Vec<PyObjectRef>>,
     }
 
     impl Constructor for LZMADecompressor {
         type Args = LZMADecompressorConstructorArgs;
 
         fn py_new(_cls: &Py<PyType>, args: Self::Args, vm: &VirtualMachine) -> PyResult<Self> {
-            if args.format == FORMAT_RAW && args.mem_limit.is_some() {
+            if args.format == FORMAT_RAW && args.memlimit.is_some() {
                 return Err(vm.new_value_error("Cannot specify memory limit with FORMAT_RAW"));
             }
-            let mem_limit = args.mem_limit.unwrap_or(u64::MAX);
-            let filters = args.filters.unwrap_or(0);
-            let stream_result = match args.format {
-                FORMAT_AUTO => Stream::new_auto_decoder(mem_limit, filters),
-                FORMAT_XZ => Stream::new_stream_decoder(mem_limit, filters),
-                FORMAT_ALONE => Stream::new_lzma_decoder(mem_limit),
-                // TODO: FORMAT_RAW
-                _ => return Err(new_lzma_error("Invalid format", vm)),
+
+            if args.format == FORMAT_RAW && args.filters.is_none() {
+                return Err(vm.new_value_error("Must specify filters for FORMAT_RAW"));
+            }
+            if args.format != FORMAT_RAW && args.filters.is_some() {
+                return Err(vm.new_value_error("Cannot specify filters except with FORMAT_RAW"));
+            }
+
+            let memlimit = args.memlimit.unwrap_or(u64::MAX);
+            let decoder_flags = TELL_ANY_CHECK | TELL_NO_CHECK;
+
+            let lzma_stream = match args.format {
+                FORMAT_AUTO => {
+                    let stream = Stream::new_auto_decoder(memlimit, decoder_flags)
+                        .map_err(|e| catch_lzma_error(e, vm))?;
+                    LzmaStream::new(stream, CHECK_UNKNOWN, true)
+                }
+                FORMAT_XZ => {
+                    let stream = Stream::new_stream_decoder(memlimit, decoder_flags)
+                        .map_err(|e| catch_lzma_error(e, vm))?;
+                    LzmaStream::new(stream, CHECK_UNKNOWN, true)
+                }
+                FORMAT_ALONE => {
+                    let stream =
+                        Stream::new_lzma_decoder(memlimit).map_err(|e| catch_lzma_error(e, vm))?;
+                    LzmaStream::new(stream, CHECK_NONE, false)
+                }
+                FORMAT_RAW => {
+                    let filter_specs = args.filters.unwrap(); // safe: checked above
+                    let filters = parse_filter_chain_spec(filter_specs, vm)?;
+                    let stream =
+                        Stream::new_raw_decoder(&filters).map_err(|e| catch_lzma_error(e, vm))?;
+                    LzmaStream::new(stream, CHECK_NONE, false)
+                }
+                _ => {
+                    return Err(
+                        vm.new_value_error(format!("Invalid container format: {}", args.format))
+                    );
+                }
             };
+
             Ok(Self {
-                state: PyMutex::new(DecompressState::new(
-                    stream_result
-                        .map_err(|_| new_lzma_error("Failed to initialize decoder", vm))?,
-                    vm,
-                )),
+                state: PyMutex::new(DecompressState::new(lzma_stream, vm)),
             })
         }
     }
@@ -182,11 +640,16 @@ mod _lzma {
             state
                 .decompress(data, max_length, BUFSIZ, vm)
                 .map_err(|e| match e {
-                    DecompressError::Decompress(err) => vm.new_os_error(err.to_string()),
+                    DecompressError::Decompress(err) => catch_lzma_error(err, vm),
                     DecompressError::Eof(err) => err.to_pyexception(vm),
                 })
         }
 
+        #[pygetset]
+        fn check(&self) -> i32 {
+            self.state.lock().decompressor().check
+        }
+
         #[pygetset]
         fn eof(&self) -> bool {
             self.state.lock().eof()
@@ -199,12 +662,8 @@ mod _lzma {
 
         #[pygetset]
         fn needs_input(&self) -> bool {
-            // False if the decompress() method can provide more
-            // decompressed data before requiring new uncompressed input.
             self.state.lock().needs_input()
         }
-
-        // TODO: mro()?
     }
 
     struct CompressorInner {
@@ -243,7 +702,7 @@ mod _lzma {
         ) -> PyResult<Self::Status> {
             self.stream
                 .process_vec(input, output, flush)
-                .map_err(|_| new_lzma_error("Failed to compress data", vm))
+                .map_err(|e| catch_lzma_error(e, vm))
         }
 
         fn total_in(&mut self) -> usize {
@@ -274,36 +733,6 @@ mod _lzma {
         }
     }
 
-    fn int_to_check(check: i32) -> Option<Check> {
-        if check == -1 {
-            return Some(Check::None);
-        }
-        match check as EnumVal {
-            CHECK_NONE => Some(Check::None),
-            CHECK_CRC32 => Some(Check::Crc32),
-            CHECK_CRC64 => Some(Check::Crc64),
-            CHECK_SHA256 => Some(Check::Sha256),
-            _ => None,
-        }
-    }
-
-    fn parse_filter_chain_spec(
-        filter_specs: Vec<PyObjectRef>,
-        vm: &VirtualMachine,
-    ) -> PyResult<Filters> {
-        // TODO: don't hardcode
-        const LZMA_FILTERS_MAX: usize = 4;
-        if filter_specs.len() > LZMA_FILTERS_MAX {
-            return Err(new_lzma_error(
-                format!("Too many filters - liblzma supports a maximum of {LZMA_FILTERS_MAX}"),
-                vm,
-            ));
-        }
-        let filters = Filters::new();
-        for _item in filter_specs {}
-        Ok(filters)
-    }
-
     impl LZMACompressor {
         fn init_xz(
             check: i32,
@@ -312,14 +741,13 @@ mod _lzma {
             vm: &VirtualMachine,
         ) -> PyResult<Stream> {
             let real_check =
-                int_to_check(check).ok_or_else(|| vm.new_type_error("Invalid check value"))?;
-            if let Some(filters) = filters {
-                let filters = parse_filter_chain_spec(filters, vm)?;
-                Ok(Stream::new_stream_encoder(&filters, real_check)
-                    .map_err(|_| new_lzma_error("Failed to initialize encoder", vm))?)
+                int_to_check(check).ok_or_else(|| vm.new_value_error("Invalid check value"))?;
+            if let Some(filter_specs) = filters {
+                let filters = parse_filter_chain_spec(filter_specs, vm)?;
+                Stream::new_stream_encoder(&filters, real_check)
+                    .map_err(|e| catch_lzma_error(e, vm))
             } else {
-                Ok(Stream::new_easy_encoder(preset, real_check)
-                    .map_err(|_| new_lzma_error("Failed to initialize encoder", vm))?)
+                Stream::new_easy_encoder(preset, real_check).map_err(|e| catch_lzma_error(e, vm))
             }
         }
 
@@ -329,65 +757,76 @@ mod _lzma {
             vm: &VirtualMachine,
         ) -> PyResult<Stream> {
             if let Some(_filter_specs) = filter_specs {
-                Err(new_lzma_error(
-                    "TODO: RUSTPYTHON: LZMA: Alone filter specs",
-                    vm,
-                ))
+                // TODO: validate single LZMA1 filter and use its options
+                let options = LzmaOptions::new_preset(preset).map_err(|_| {
+                    new_lzma_error(format!("Invalid compression preset: {preset}"), vm)
+                })?;
+                Stream::new_lzma_encoder(&options).map_err(|e| catch_lzma_error(e, vm))
             } else {
-                let options = LzmaOptions::new_preset(preset)
-                    .map_err(|_| new_lzma_error("Failed to initialize encoder", vm))?;
-                let stream = Stream::new_lzma_encoder(&options)
-                    .map_err(|_| new_lzma_error("Failed to initialize encoder", vm))?;
-                Ok(stream)
+                let options = LzmaOptions::new_preset(preset).map_err(|_| {
+                    new_lzma_error(format!("Invalid compression preset: {preset}"), vm)
+                })?;
+                Stream::new_lzma_encoder(&options).map_err(|e| catch_lzma_error(e, vm))
             }
         }
+
+        fn init_raw(
+            filter_specs: Option<Vec<PyObjectRef>>,
+            vm: &VirtualMachine,
+        ) -> PyResult<Stream> {
+            let filter_specs = filter_specs
+                .ok_or_else(|| vm.new_value_error("Must specify filters for FORMAT_RAW"))?;
+            let filters = parse_filter_chain_spec(filter_specs, vm)?;
+            Stream::new_raw_encoder(&filters).map_err(|e| catch_lzma_error(e, vm))
+        }
     }
 
     #[derive(FromArgs)]
     pub struct LZMACompressorConstructorArgs {
-        // format=FORMAT_XZ, check=-1, preset=None, filters=None
-        //  {'format': 3, 'filters': [{'id': 3, 'dist': 2}, {'id': 33, 'preset': 2147483654}]}
         #[pyarg(any, default = FORMAT_XZ)]
         format: i32,
         #[pyarg(any, default = -1)]
         check: i32,
         #[pyarg(any, optional)]
-        preset: Option<u32>,
+        preset: Option<PyObjectRef>,
         #[pyarg(any, optional)]
         filters: Option<Vec<PyObjectRef>>,
-        #[pyarg(any, optional)]
-        _filter_specs: Option<Vec<PyObjectRef>>,
-        #[pyarg(positional, optional)]
-        preset_obj: Option<PyObjectRef>,
     }
 
     impl Constructor for LZMACompressor {
         type Args = LZMACompressorConstructorArgs;
 
         fn py_new(_cls: &Py<PyType>, args: Self::Args, vm: &VirtualMachine) -> PyResult<Self> {
-            let preset = args.preset.unwrap_or(PRESET_DEFAULT);
-            #[allow(clippy::unnecessary_cast)]
-            if args.format != FORMAT_XZ as i32
-                && args.check != -1
-                && args.check != CHECK_NONE as i32
-            {
+            if args.format != FORMAT_XZ && args.check != -1 && args.check != CHECK_NONE {
                 return Err(new_lzma_error(
                     "Integrity checks are only supported by FORMAT_XZ",
                     vm,
                 ));
             }
-            if args.preset_obj.is_some() && args.filters.is_some() {
+
+            if args.preset.is_some() && args.filters.is_some() {
                 return Err(new_lzma_error(
                     "Cannot specify both preset and filter chain",
                     vm,
                 ));
             }
+
+            let preset: u32 = match &args.preset {
+                Some(obj) => obj.clone().try_into_value(vm)?,
+                None => PRESET_DEFAULT,
+            };
+
             let stream = match args.format {
                 FORMAT_XZ => Self::init_xz(args.check, preset, args.filters, vm)?,
                 FORMAT_ALONE => Self::init_alone(preset, args.filters, vm)?,
-                // TODO: RAW
-                _ => return Err(new_lzma_error("Invalid format", vm)),
+                FORMAT_RAW => Self::init_raw(args.filters, vm)?,
+                _ => {
+                    return Err(
+                        vm.new_value_error(format!("Invalid container format: {}", args.format))
+                    );
+                }
             };
+
             Ok(Self {
                 state: PyMutex::new(CompressState::new(CompressorInner::new(stream))),
             })
@@ -399,15 +838,12 @@ mod _lzma {
         #[pymethod]
         fn compress(&self, data: ArgBytesLike, vm: &VirtualMachine) -> PyResult<Vec<u8>> {
             let mut state = self.state.lock();
-            // TODO: Flush check
             state.compress(&data.borrow_buf(), vm)
         }
 
         #[pymethod]
         fn flush(&self, vm: &VirtualMachine) -> PyResult<Vec<u8>> {
-            // TODO: flush check
             let mut state = self.state.lock();
-            // TODO: check if action is correct
             state.flush(Action::Finish, vm)
         }
     }
diff --git a/crates/stdlib/src/math.rs b/crates/stdlib/src/math.rs
index 238c7fd4928..b2ef4a42ba7 100644
--- a/crates/stdlib/src/math.rs
+++ b/crates/stdlib/src/math.rs
@@ -102,13 +102,13 @@ mod math {
                 )));
             }
             if b == 1.0 {
-                return Err(vm.new_value_error("math domain error".to_owned()));
+                return Err(vm.new_value_error("math domain 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::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::Error::EDOM => vm.new_value_error("expected a positive input"),
                 _ => pymath_exception(err, vm),
             });
         }
@@ -132,7 +132,7 @@ mod math {
         // 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::Error::EDOM => vm.new_value_error("expected a positive input"),
                 _ => pymath_exception(err, vm),
             });
         }
@@ -151,7 +151,7 @@ mod math {
         // 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::Error::EDOM => vm.new_value_error("expected a positive input"),
                 _ => pymath_exception(err, vm),
             });
         }
@@ -712,7 +712,8 @@ mod math {
                 }
                 // Finalize float path
                 if !flt_p_values.is_empty() {
-                    let flt_result = pymath::math::sumprod(&flt_p_values, &flt_q_values);
+                    let flt_result = pymath::math::sumprod(&flt_p_values, &flt_q_values)
+                        .map_err(|err| pymath_exception(err, vm))?;
                     let flt_obj: PyObjectRef = vm.ctx.new_float(flt_result).into();
                     obj_total = Some(match obj_total {
                         Some(total) => vm._add(&total, &flt_obj)?,
@@ -732,9 +733,9 @@ mod math {
 
             // Collect current + remaining elements
             let p_remaining: Result<Vec<PyObjectRef>, _> =
-                std::iter::once(Ok(p_i)).chain(p_iter).collect();
+                core::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();
+                core::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() {
diff --git a/crates/stdlib/src/md5.rs b/crates/stdlib/src/md5.rs
index 11923b165ed..2ff6cd24ff7 100644
--- a/crates/stdlib/src/md5.rs
+++ b/crates/stdlib/src/md5.rs
@@ -7,6 +7,6 @@ mod _md5 {
 
     #[pyfunction]
     fn md5(args: HashArgs, vm: &VirtualMachine) -> PyResult {
-        Ok(local_md5(args).into_pyobject(vm))
+        Ok(local_md5(args, vm)?.into_pyobject(vm))
     }
 }
diff --git a/crates/stdlib/src/mmap.rs b/crates/stdlib/src/mmap.rs
index 625b6db5f6c..a99d0cc131d 100644
--- a/crates/stdlib/src/mmap.rs
+++ b/crates/stdlib/src/mmap.rs
@@ -42,6 +42,10 @@ mod mmap {
             CloseHandle, DUPLICATE_SAME_ACCESS, DuplicateHandle, HANDLE, INVALID_HANDLE_VALUE,
         },
         Storage::FileSystem::{FILE_BEGIN, GetFileSize, SetEndOfFile, SetFilePointerEx},
+        System::Memory::{
+            CreateFileMappingW, FILE_MAP_COPY, FILE_MAP_READ, FILE_MAP_WRITE, FlushViewOfFile,
+            MapViewOfFile, PAGE_READONLY, PAGE_READWRITE, PAGE_WRITECOPY, UnmapViewOfFile,
+        },
         System::Threading::GetCurrentProcess,
     };
 
@@ -193,10 +197,57 @@ mod mmap {
         vm.ctx.exceptions.os_error.to_owned()
     }
 
+    /// Named file mapping on Windows using raw Win32 APIs.
+    /// Supports tagname parameter for inter-process shared memory.
+    #[cfg(windows)]
+    struct NamedMmap {
+        map_handle: HANDLE,
+        view_ptr: *mut u8,
+        len: usize,
+    }
+
+    #[cfg(windows)]
+    // SAFETY: The memory mapping is managed by the OS and is safe to share
+    // across threads. Access is synchronized by PyMutex in PyMmap.
+    unsafe impl Send for NamedMmap {}
+    #[cfg(windows)]
+    unsafe impl Sync for NamedMmap {}
+
+    #[cfg(windows)]
+    impl core::fmt::Debug for NamedMmap {
+        fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+            f.debug_struct("NamedMmap")
+                .field("map_handle", &self.map_handle)
+                .field("view_ptr", &self.view_ptr)
+                .field("len", &self.len)
+                .finish()
+        }
+    }
+
+    #[cfg(windows)]
+    impl Drop for NamedMmap {
+        fn drop(&mut self) {
+            unsafe {
+                if !self.view_ptr.is_null() {
+                    UnmapViewOfFile(
+                        windows_sys::Win32::System::Memory::MEMORY_MAPPED_VIEW_ADDRESS {
+                            Value: self.view_ptr as *mut _,
+                        },
+                    );
+                }
+                if !self.map_handle.is_null() {
+                    CloseHandle(self.map_handle);
+                }
+            }
+        }
+    }
+
     #[derive(Debug)]
     enum MmapObj {
         Write(MmapMut),
         Read(Mmap),
+        #[cfg(windows)]
+        Named(NamedMmap),
     }
 
     impl MmapObj {
@@ -204,6 +255,10 @@ mod mmap {
             match self {
                 MmapObj::Read(mmap) => &mmap[..],
                 MmapObj::Write(mmap) => &mmap[..],
+                #[cfg(windows)]
+                MmapObj::Named(named) => unsafe {
+                    core::slice::from_raw_parts(named.view_ptr, named.len)
+                },
             }
         }
     }
@@ -276,7 +331,6 @@ mod mmap {
         #[pyarg(any)]
         length: isize,
         #[pyarg(any, default)]
-        #[allow(dead_code)]
         tagname: Option<PyObjectRef>,
         #[pyarg(any, default = AccessMode::Default)]
         access: AccessMode,
@@ -494,11 +548,26 @@ mod mmap {
             let mut map_size = args.validate_new_args(vm)?;
             let MmapNewArgs {
                 fileno,
+                tagname,
                 access,
                 offset,
                 ..
             } = args;
 
+            // Parse tagname: None or a string
+            let tag_str: Option<String> = match tagname {
+                Some(ref obj) if !vm.is_none(obj) => {
+                    let s = obj
+                        .try_to_value::<String>(vm)
+                        .map_err(|_| vm.new_type_error("tagname must be a string or None"))?;
+                    if s.contains('\0') {
+                        return Err(vm.new_value_error("tagname must not contain null characters"));
+                    }
+                    Some(s)
+                }
+                _ => None,
+            };
+
             // Get file handle from fileno
             // fileno -1 or 0 means anonymous mapping
             let fh: Option<HANDLE> = if fileno != -1 && fileno != 0 {
@@ -576,7 +645,7 @@ mod mmap {
                             SetFilePointerEx(
                                 duplicated_handle,
                                 required_size,
-                                std::ptr::null_mut(),
+                                core::ptr::null_mut(),
                                 FILE_BEGIN,
                             )
                         };
@@ -595,6 +664,75 @@ mod mmap {
                 }
             }
 
+            // When tagname is provided, use raw Win32 APIs for named shared memory
+            if let Some(ref tag) = tag_str {
+                let (fl_protect, desired_access) = match access {
+                    AccessMode::Default | AccessMode::Write => (PAGE_READWRITE, FILE_MAP_WRITE),
+                    AccessMode::Read => (PAGE_READONLY, FILE_MAP_READ),
+                    AccessMode::Copy => (PAGE_WRITECOPY, FILE_MAP_COPY),
+                };
+
+                let fh = if let Some(fh) = fh {
+                    // Close the duplicated handle - we'll use the original
+                    // file handle for CreateFileMappingW
+                    if duplicated_handle != INVALID_HANDLE_VALUE {
+                        unsafe { CloseHandle(duplicated_handle) };
+                    }
+                    fh
+                } else {
+                    INVALID_HANDLE_VALUE
+                };
+
+                let tag_wide: Vec<u16> = tag.encode_utf16().chain(core::iter::once(0)).collect();
+
+                let total_size = (offset as u64)
+                    .checked_add(map_size as u64)
+                    .ok_or_else(|| vm.new_overflow_error("mmap offset plus size would overflow"))?;
+                let size_hi = (total_size >> 32) as u32;
+                let size_lo = total_size as u32;
+
+                let map_handle = unsafe {
+                    CreateFileMappingW(
+                        fh,
+                        core::ptr::null(),
+                        fl_protect,
+                        size_hi,
+                        size_lo,
+                        tag_wide.as_ptr(),
+                    )
+                };
+                if map_handle.is_null() {
+                    return Err(io::Error::last_os_error().to_pyexception(vm));
+                }
+
+                let off_hi = (offset as u64 >> 32) as u32;
+                let off_lo = offset as u32;
+
+                let view =
+                    unsafe { MapViewOfFile(map_handle, desired_access, off_hi, off_lo, map_size) };
+                if view.Value.is_null() {
+                    unsafe { CloseHandle(map_handle) };
+                    return Err(io::Error::last_os_error().to_pyexception(vm));
+                }
+
+                let named = NamedMmap {
+                    map_handle,
+                    view_ptr: view.Value as *mut u8,
+                    len: map_size,
+                };
+
+                return Ok(Self {
+                    closed: AtomicCell::new(false),
+                    mmap: PyMutex::new(Some(MmapObj::Named(named))),
+                    handle: AtomicCell::new(INVALID_HANDLE_VALUE as isize),
+                    offset,
+                    size: AtomicCell::new(map_size),
+                    pos: AtomicCell::new(0),
+                    exports: AtomicCell::new(0),
+                    access,
+                });
+            }
+
             let mut mmap_opt = MmapOptions::new();
             let mmap_opt = mmap_opt.offset(offset as u64).len(map_size);
 
@@ -617,7 +755,7 @@ mod mmap {
 
                 // Keep the handle alive
                 let raw = owned_handle.as_raw_handle() as isize;
-                std::mem::forget(owned_handle);
+                core::mem::forget(owned_handle);
                 (raw, mmap)
             } else {
                 // Anonymous mapping
@@ -687,7 +825,7 @@ mod mmap {
 
     impl AsSequence for PyMmap {
         fn as_sequence() -> &'static PySequenceMethods {
-            use std::sync::LazyLock;
+            use rustpython_common::lock::LazyLock;
             static AS_SEQUENCE: LazyLock<PySequenceMethods> = LazyLock::new(|| PySequenceMethods {
                 length: atomic_func!(|seq, _vm| Ok(PyMmap::sequence_downcast(seq).__len__())),
                 item: atomic_func!(|seq, i, vm| {
@@ -711,7 +849,7 @@ mod mmap {
 
     #[pyclass(
         with(Constructor, AsMapping, AsSequence, AsBuffer, Representable),
-        flags(BASETYPE)
+        flags(BASETYPE, HAS_WEAKREF)
     )]
     impl PyMmap {
         fn as_bytes_mut(&self) -> BorrowedValueMut<'_, [u8]> {
@@ -719,6 +857,10 @@ mod mmap {
                 match m.as_mut().expect("mmap closed or invalid") {
                     MmapObj::Read(_) => panic!("mmap can't modify a readonly memory map."),
                     MmapObj::Write(mmap) => &mut mmap[..],
+                    #[cfg(windows)]
+                    MmapObj::Named(named) => unsafe {
+                        core::slice::from_raw_parts_mut(named.view_ptr, named.len)
+                    },
                 }
             })
             .into()
@@ -749,15 +891,19 @@ mod mmap {
         fn try_writable<R>(
             &self,
             vm: &VirtualMachine,
-            f: impl FnOnce(&mut MmapMut) -> R,
+            f: impl FnOnce(&mut [u8]) -> R,
         ) -> PyResult<R> {
             if matches!(self.access, AccessMode::Read) {
                 return Err(vm.new_type_error("mmap can't modify a readonly memory map."));
             }
 
             match self.check_valid(vm)?.deref_mut().as_mut().unwrap() {
-                MmapObj::Write(mmap) => Ok(f(mmap)),
-                _ => unreachable!("already check"),
+                MmapObj::Write(mmap) => Ok(f(&mut mmap[..])),
+                #[cfg(windows)]
+                MmapObj::Named(named) => Ok(f(unsafe {
+                    core::slice::from_raw_parts_mut(named.view_ptr, named.len)
+                })),
+                _ => unreachable!("already checked"),
             }
         }
 
@@ -873,6 +1019,14 @@ mod mmap {
                     mmap.flush_range(offset, size)
                         .map_err(|e| e.to_pyexception(vm))?;
                 }
+                #[cfg(windows)]
+                MmapObj::Named(named) => {
+                    let ptr = unsafe { named.view_ptr.add(offset) };
+                    let result = unsafe { FlushViewOfFile(ptr as *const _, size) };
+                    if result == 0 {
+                        return Err(io::Error::last_os_error().to_pyexception(vm));
+                    }
+                }
             }
 
             Ok(())
@@ -1044,11 +1198,17 @@ mod mmap {
             }
 
             let handle = self.handle.load();
-            let is_anonymous = handle == INVALID_HANDLE_VALUE as isize;
 
             // Get the lock on mmap
             let mut mmap_guard = self.mmap.lock();
 
+            // Check if this is a Named mmap - these cannot be resized
+            if let Some(MmapObj::Named(_)) = mmap_guard.as_ref() {
+                return Err(vm.new_os_error("mmap: cannot resize a named memory mapping"));
+            }
+
+            let is_anonymous = handle == INVALID_HANDLE_VALUE as isize;
+
             if is_anonymous {
                 // For anonymous mmap, we need to:
                 // 1. Create a new anonymous mmap with the new size
@@ -1067,10 +1227,7 @@ mod mmap {
 
                 // Copy data from old mmap to new mmap
                 if let Some(old_mmap) = mmap_guard.as_ref() {
-                    let src = match old_mmap {
-                        MmapObj::Write(m) => &m[..copy_size],
-                        MmapObj::Read(m) => &m[..copy_size],
-                    };
+                    let src = &old_mmap.as_slice()[..copy_size];
                     new_mmap[..copy_size].copy_from_slice(src);
                 }
 
@@ -1088,7 +1245,7 @@ mod mmap {
                     SetFilePointerEx(
                         handle as HANDLE,
                         required_size,
-                        std::ptr::null_mut(),
+                        core::ptr::null_mut(),
                         FILE_BEGIN,
                     )
                 };
@@ -1267,7 +1424,7 @@ mod mmap {
         #[cfg(windows)]
         #[pymethod]
         fn __sizeof__(&self) -> usize {
-            std::mem::size_of::<Self>()
+            core::mem::size_of::<Self>()
         }
     }
 
@@ -1297,7 +1454,7 @@ mod mmap {
             };
 
             // Don't close the file handle - we're borrowing it
-            std::mem::forget(file);
+            core::mem::forget(file);
 
             result
         }
diff --git a/crates/stdlib/src/multiprocessing.rs b/crates/stdlib/src/multiprocessing.rs
index f3a7831defe..fe30abfdcb5 100644
--- a/crates/stdlib/src/multiprocessing.rs
+++ b/crates/stdlib/src/multiprocessing.rs
@@ -3,8 +3,372 @@ pub(crate) use _multiprocessing::module_def;
 #[cfg(windows)]
 #[pymodule]
 mod _multiprocessing {
-    use crate::vm::{PyResult, VirtualMachine, function::ArgBytesLike};
+    use crate::vm::{
+        Context, FromArgs, Py, PyPayload, PyRef, PyResult, VirtualMachine,
+        builtins::{PyDict, PyType, PyTypeRef},
+        function::{ArgBytesLike, FuncArgs, KwArgs},
+        types::Constructor,
+    };
+    use core::sync::atomic::{AtomicI32, AtomicU32, Ordering};
+    use windows_sys::Win32::Foundation::{
+        CloseHandle, ERROR_TOO_MANY_POSTS, HANDLE, INVALID_HANDLE_VALUE, WAIT_FAILED,
+        WAIT_OBJECT_0, WAIT_TIMEOUT,
+    };
     use windows_sys::Win32::Networking::WinSock::{self, SOCKET};
+    use windows_sys::Win32::System::Threading::{
+        CreateSemaphoreW, GetCurrentThreadId, INFINITE, ReleaseSemaphore, WaitForSingleObjectEx,
+    };
+
+    // These match the values in Lib/multiprocessing/synchronize.py
+    const RECURSIVE_MUTEX: i32 = 0;
+    const SEMAPHORE: i32 = 1;
+
+    macro_rules! ismine {
+        ($self:expr) => {
+            $self.count.load(Ordering::Acquire) > 0
+                && $self.last_tid.load(Ordering::Acquire) == unsafe { GetCurrentThreadId() }
+        };
+    }
+
+    #[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: AtomicU32,
+        count: AtomicI32,
+    }
+
+    #[derive(Debug)]
+    struct SemHandle {
+        raw: HANDLE,
+    }
+
+    unsafe impl Send for SemHandle {}
+    unsafe impl Sync for SemHandle {}
+
+    impl SemHandle {
+        fn create(value: i32, maxvalue: i32, vm: &VirtualMachine) -> PyResult<Self> {
+            let handle =
+                unsafe { CreateSemaphoreW(core::ptr::null(), value, maxvalue, core::ptr::null()) };
+            if handle == 0 as HANDLE {
+                return Err(vm.new_last_os_error());
+            }
+            Ok(SemHandle { raw: handle })
+        }
+
+        #[inline]
+        fn as_raw(&self) -> HANDLE {
+            self.raw
+        }
+    }
+
+    impl Drop for SemHandle {
+        fn drop(&mut self) {
+            if self.raw != 0 as HANDLE && self.raw != INVALID_HANDLE_VALUE {
+                unsafe {
+                    CloseHandle(self.raw);
+                }
+            }
+        }
+    }
+
+    /// _GetSemaphoreValue - get value of semaphore by briefly acquiring and releasing
+    fn get_semaphore_value(handle: HANDLE) -> Result<i32, ()> {
+        match unsafe { WaitForSingleObjectEx(handle, 0, 0) } {
+            WAIT_OBJECT_0 => {
+                let mut previous: i32 = 0;
+                if unsafe { ReleaseSemaphore(handle, 1, &mut previous) } == 0 {
+                    return Err(());
+                }
+                Ok(previous + 1)
+            }
+            WAIT_TIMEOUT => Ok(0),
+            _ => Err(()),
+        }
+    }
+
+    #[pyclass(with(Constructor), flags(BASETYPE))]
+    impl SemLock {
+        #[pygetset]
+        fn handle(&self) -> isize {
+            self.handle.as_raw() 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()
+        }
+
+        #[pymethod]
+        fn acquire(&self, args: FuncArgs, vm: &VirtualMachine) -> PyResult<bool> {
+            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();
+
+            // Calculate timeout in milliseconds
+            let full_msecs: u32 = if !blocking {
+                0
+            } else if timeout_obj.as_ref().is_none_or(|o| vm.is_none(o)) {
+                INFINITE
+            } else {
+                let timeout: f64 = timeout_obj.unwrap().try_float(vm)?.to_f64();
+                let timeout = timeout * 1000.0; // convert to ms
+                if timeout < 0.0 {
+                    0
+                } else if timeout >= 0.5 * INFINITE as f64 {
+                    return Err(vm.new_overflow_error("timeout is too large"));
+                } else {
+                    (timeout + 0.5) as u32
+                }
+            };
+
+            // Check whether we already own the lock
+            if self.kind == RECURSIVE_MUTEX && ismine!(self) {
+                self.count.fetch_add(1, Ordering::Release);
+                return Ok(true);
+            }
+
+            // Check whether we can acquire without blocking
+            match unsafe { WaitForSingleObjectEx(self.handle.as_raw(), 0, 0) } {
+                WAIT_OBJECT_0 => {
+                    self.last_tid
+                        .store(unsafe { GetCurrentThreadId() }, Ordering::Release);
+                    self.count.fetch_add(1, Ordering::Release);
+                    return Ok(true);
+                }
+                WAIT_FAILED => return Err(vm.new_last_os_error()),
+                _ => {}
+            }
+
+            // Poll with signal checking (CPython uses WaitForMultipleObjectsEx
+            // with sigint_event; we poll since RustPython has no sigint event)
+            let poll_ms: u32 = 100;
+            let mut elapsed: u32 = 0;
+            loop {
+                let wait_ms = if full_msecs == INFINITE {
+                    poll_ms
+                } else {
+                    let remaining = full_msecs.saturating_sub(elapsed);
+                    if remaining == 0 {
+                        return Ok(false);
+                    }
+                    remaining.min(poll_ms)
+                };
+
+                let handle = self.handle.as_raw();
+                let res = vm.allow_threads(|| unsafe { WaitForSingleObjectEx(handle, wait_ms, 0) });
+
+                match res {
+                    WAIT_OBJECT_0 => {
+                        self.last_tid
+                            .store(unsafe { GetCurrentThreadId() }, Ordering::Release);
+                        self.count.fetch_add(1, Ordering::Release);
+                        return Ok(true);
+                    }
+                    WAIT_TIMEOUT => {
+                        vm.check_signals()?;
+                        if full_msecs != INFINITE {
+                            elapsed = elapsed.saturating_add(wait_ms);
+                        }
+                    }
+                    WAIT_FAILED => return Err(vm.new_last_os_error()),
+                    _ => {
+                        return Err(vm.new_runtime_error(format!(
+                            "WaitForSingleObject() gave unrecognized value {res}"
+                        )));
+                    }
+                }
+            }
+        }
+
+        #[pymethod]
+        fn release(&self, vm: &VirtualMachine) -> PyResult<()> {
+            if self.kind == RECURSIVE_MUTEX {
+                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".into(),
+                    ));
+                }
+                if self.count.load(Ordering::Acquire) > 1 {
+                    self.count.fetch_sub(1, Ordering::Release);
+                    return Ok(());
+                }
+            }
+
+            if unsafe { ReleaseSemaphore(self.handle.as_raw(), 1, core::ptr::null_mut()) } == 0 {
+                let err = unsafe { windows_sys::Win32::Foundation::GetLastError() };
+                if err == ERROR_TOO_MANY_POSTS {
+                    return Err(vm.new_value_error("semaphore or lock released too many times"));
+                }
+                return Err(vm.new_last_os_error());
+            }
+
+            self.count.fetch_sub(1, Ordering::Release);
+            Ok(())
+        }
+
+        #[pymethod(name = "__enter__")]
+        fn enter(&self, vm: &VirtualMachine) -> PyResult<bool> {
+            self.acquire(
+                FuncArgs::new::<Vec<_>, KwArgs>(
+                    vec![vm.ctx.new_bool(true).into()],
+                    KwArgs::default(),
+                ),
+                vm,
+            )
+        }
+
+        #[pymethod]
+        fn __exit__(&self, _args: FuncArgs, vm: &VirtualMachine) -> PyResult<()> {
+            self.release(vm)
+        }
+
+        #[pyclassmethod(name = "_rebuild")]
+        fn rebuild(
+            cls: PyTypeRef,
+            handle: isize,
+            kind: i32,
+            maxvalue: i32,
+            name: Option<String>,
+            vm: &VirtualMachine,
+        ) -> PyResult {
+            // On Windows, _rebuild receives the handle directly (no sem_open)
+            let zelf = SemLock {
+                handle: SemHandle {
+                    raw: handle as HANDLE,
+                },
+                kind,
+                maxvalue,
+                name,
+                last_tid: AtomicU32::new(0),
+                count: AtomicI32::new(0),
+            };
+            zelf.into_ref_with_type(vm, cls).map(Into::into)
+        }
+
+        #[pymethod]
+        fn _after_fork(&self) {
+            self.count.store(0, Ordering::Release);
+            self.last_tid.store(0, Ordering::Release);
+        }
+
+        #[pymethod]
+        fn __reduce__(&self, vm: &VirtualMachine) -> PyResult {
+            Err(vm.new_type_error("cannot pickle 'SemLock' object"))
+        }
+
+        #[pymethod]
+        fn _count(&self) -> i32 {
+            self.count.load(Ordering::Acquire)
+        }
+
+        #[pymethod]
+        fn _is_mine(&self) -> bool {
+            ismine!(self)
+        }
+
+        #[pymethod]
+        fn _get_value(&self, vm: &VirtualMachine) -> PyResult<i32> {
+            get_semaphore_value(self.handle.as_raw()).map_err(|_| vm.new_last_os_error())
+        }
+
+        #[pymethod]
+        fn _is_zero(&self, vm: &VirtualMachine) -> PyResult<bool> {
+            let val =
+                get_semaphore_value(self.handle.as_raw()).map_err(|_| vm.new_last_os_error())?;
+            Ok(val == 0)
+        }
+
+        #[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());
+            class.set_attr(
+                ctx.intern_str("SEM_VALUE_MAX"),
+                ctx.new_int(i32::MAX).into(),
+            );
+        }
+    }
+
+    impl Constructor for SemLock {
+        type Args = SemLockNewArgs;
+
+        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"));
+            }
+            if args.maxvalue <= 0 {
+                return Err(vm.new_value_error("maxvalue must be positive"));
+            }
+            if args.value < 0 || args.value > args.maxvalue {
+                return Err(vm.new_value_error("invalid value"));
+            }
+
+            let handle = SemHandle::create(args.value, args.maxvalue, vm)?;
+            let name = if args.unlink { None } else { Some(args.name) };
+
+            Ok(SemLock {
+                handle,
+                kind: args.kind,
+                maxvalue: args.maxvalue,
+                name,
+                last_tid: AtomicU32::new(0),
+                count: AtomicI32::new(0),
+            })
+        }
+    }
+
+    // On Windows, sem_unlink is a no-op
+    #[pyfunction]
+    fn sem_unlink(_name: String) {}
+
+    #[pyattr]
+    fn flags(vm: &VirtualMachine) -> PyRef<PyDict> {
+        // On Windows, no HAVE_SEM_OPEN / HAVE_SEM_TIMEDWAIT / HAVE_BROKEN_SEM_GETVALUE
+        vm.ctx.new_dict()
+    }
 
     #[pyfunction]
     fn closesocket(socket: usize, vm: &VirtualMachine) -> PyResult<()> {
@@ -17,14 +381,15 @@ mod _multiprocessing {
     }
 
     #[pyfunction]
-    fn recv(socket: usize, size: usize, vm: &VirtualMachine) -> PyResult<libc::c_int> {
-        let mut buf = vec![0; size];
+    fn recv(socket: usize, size: usize, vm: &VirtualMachine) -> PyResult<Vec<u8>> {
+        let mut buf = vec![0u8; size];
         let n_read =
             unsafe { WinSock::recv(socket as SOCKET, buf.as_mut_ptr() as *mut _, size as i32, 0) };
         if n_read < 0 {
             Err(vm.new_last_os_error())
         } else {
-            Ok(n_read)
+            buf.truncate(n_read as usize);
+            Ok(buf)
         }
     }
 
@@ -52,12 +417,10 @@ mod _multiprocessing {
         function::{FuncArgs, KwArgs},
         types::Constructor,
     };
+    use alloc::ffi::CString;
+    use core::sync::atomic::{AtomicI32, AtomicU64, Ordering};
     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")]
@@ -92,7 +455,7 @@ mod _multiprocessing {
                 tv_sec: 0,
                 tv_usec: 0,
             };
-            if unsafe { libc::gettimeofday(&mut now, std::ptr::null_mut()) } < 0 {
+            if unsafe { libc::gettimeofday(&mut now, core::ptr::null_mut()) } < 0 {
                 return Err(SemWaitError::OsError(Errno::last()));
             }
 
@@ -122,15 +485,15 @@ mod _multiprocessing {
                 tv_sec: (delay / 1_000_000) as _,
                 tv_usec: (delay % 1_000_000) as _,
             };
-            unsafe {
+            vm.allow_threads(|| unsafe {
                 libc::select(
                     0,
-                    std::ptr::null_mut(),
-                    std::ptr::null_mut(),
-                    std::ptr::null_mut(),
+                    core::ptr::null_mut(),
+                    core::ptr::null_mut(),
+                    core::ptr::null_mut(),
                     &mut tv_delay,
                 )
-            };
+            });
 
             // check for signals - preserve the exception (e.g., KeyboardInterrupt)
             if let Err(exc) = vm.check_signals() {
@@ -302,7 +665,7 @@ mod _multiprocessing {
                     tv_sec: 0,
                     tv_usec: 0,
                 };
-                let res = unsafe { libc::gettimeofday(&mut tv, std::ptr::null_mut()) };
+                let res = unsafe { libc::gettimeofday(&mut tv, core::ptr::null_mut()) };
                 if res < 0 {
                     return Err(vm.new_os_error("gettimeofday failed".to_string()));
                 }
@@ -344,41 +707,69 @@ mod _multiprocessing {
 
             // if (res < 0 && errno == EAGAIN && blocking)
             if res < 0 && Errno::last() == Errno::EAGAIN && blocking {
-                // Couldn't acquire immediately, need to block
+                // Couldn't acquire immediately, need to block.
+                //
+                // Save errno inside the allow_threads closure, before
+                // attach_thread() runs — matches CPython which saves
+                // `err = errno` before Py_END_ALLOW_THREADS.
+
                 #[cfg(not(target_vendor = "apple"))]
                 {
+                    let mut saved_errno;
                     loop {
+                        let sem_ptr = self.handle.as_ptr();
                         // 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) };
+                        let (r, e) = if let Some(ref dl) = deadline {
+                            vm.allow_threads(|| {
+                                let r = unsafe { libc::sem_timedwait(sem_ptr, dl) };
+                                (
+                                    r,
+                                    if r < 0 {
+                                        Errno::last()
+                                    } else {
+                                        Errno::from_raw(0)
+                                    },
+                                )
+                            })
                         } else {
-                            res = unsafe { libc::sem_wait(self.handle.as_ptr()) };
-                        }
+                            vm.allow_threads(|| {
+                                let r = unsafe { libc::sem_wait(sem_ptr) };
+                                (
+                                    r,
+                                    if r < 0 {
+                                        Errno::last()
+                                    } else {
+                                        Errno::from_raw(0)
+                                    },
+                                )
+                            })
+                        };
+                        res = r;
+                        saved_errno = e;
 
                         if res >= 0 {
                             break;
                         }
-                        let err = Errno::last();
-                        if err == Errno::EINTR {
+                        if saved_errno == Errno::EINTR {
                             vm.check_signals()?;
                             continue;
                         }
                         break;
                     }
+                    if res < 0 {
+                        return handle_wait_error(vm, saved_errno);
+                    }
                 }
                 #[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,
+                            Ok(()) => {}
                             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)) => {
@@ -387,30 +778,42 @@ mod _multiprocessing {
                         }
                     } else {
                         // No timeout: use sem_wait (available on macOS)
+                        let mut saved_errno;
                         loop {
-                            res = unsafe { libc::sem_wait(self.handle.as_ptr()) };
+                            let sem_ptr = self.handle.as_ptr();
+                            let (r, e) = vm.allow_threads(|| {
+                                let r = unsafe { libc::sem_wait(sem_ptr) };
+                                (
+                                    r,
+                                    if r < 0 {
+                                        Errno::last()
+                                    } else {
+                                        Errno::from_raw(0)
+                                    },
+                                )
+                            });
+                            res = r;
+                            saved_errno = e;
                             if res >= 0 {
                                 break;
                             }
-                            let err = Errno::last();
-                            if err == Errno::EINTR {
+                            if saved_errno == Errno::EINTR {
                                 vm.check_signals()?;
                                 continue;
                             }
                             break;
                         }
+                        if res < 0 {
+                            return handle_wait_error(vm, saved_errno);
+                        }
                     }
                 }
-            }
-
-            // result handling:
-            if res < 0 {
+            } else if res < 0 {
+                // Non-blocking path failed, or blocking=false
                 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)),
@@ -432,7 +835,7 @@ mod _multiprocessing {
                 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(),
+                        "attempt to release recursive lock not owned by thread".into(),
                     ));
                 }
                 // if (self->count > 1) { --self->count; Py_RETURN_NONE; }
@@ -452,9 +855,7 @@ mod _multiprocessing {
                         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(),
-                        ));
+                        return Err(vm.new_value_error("semaphore or lock released too many times"));
                     }
                 }
                 #[cfg(target_vendor = "apple")]
@@ -473,9 +874,9 @@ mod _multiprocessing {
                             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(),
-                            ));
+                            return Err(
+                                vm.new_value_error("semaphore or lock released too many times")
+                            );
                         }
                     }
                 }
@@ -523,7 +924,7 @@ mod _multiprocessing {
             vm: &VirtualMachine,
         ) -> PyResult {
             let Some(ref name_str) = name else {
-                return Err(vm.new_value_error("cannot rebuild SemLock without name".to_owned()));
+                return Err(vm.new_value_error("cannot rebuild SemLock without name"));
             };
             let handle = SemHandle::open_existing(name_str, vm)?;
             // return newsemlockobject(type, handle, kind, maxvalue, name_copy);
@@ -551,7 +952,7 @@ mod _multiprocessing {
         /// 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()))
+            Err(vm.new_type_error("cannot pickle 'SemLock' object"))
         }
 
         /// Num of `acquire()`s minus num of `release()`s for this process.
@@ -648,11 +1049,11 @@ mod _multiprocessing {
         // _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()));
+                return Err(vm.new_value_error("unrecognized kind"));
             }
             // Value validation
             if args.value < 0 || args.value > args.maxvalue {
-                return Err(vm.new_value_error("invalid value".to_owned()));
+                return Err(vm.new_value_error("invalid value"));
             }
 
             let value = args.value as u32;
@@ -717,7 +1118,15 @@ mod _multiprocessing {
             full.push('/');
         }
         full.push_str(name);
-        CString::new(full).map_err(|_| vm.new_value_error("embedded null character".to_owned()))
+        CString::new(full).map_err(|_| vm.new_value_error("embedded null character"))
+    }
+
+    fn handle_wait_error(vm: &VirtualMachine, saved_errno: Errno) -> PyResult<bool> {
+        match saved_errno {
+            Errno::EAGAIN | Errno::ETIMEDOUT => Ok(false),
+            Errno::EINTR => vm.check_signals().map(|_| false),
+            _ => Err(os_error(vm, saved_errno)),
+        }
     }
 
     fn os_error(vm: &VirtualMachine, err: Errno) -> PyBaseExceptionRef {
diff --git a/crates/stdlib/src/openssl.rs b/crates/stdlib/src/openssl.rs
index 29f32b46386..00461f1b468 100644
--- a/crates/stdlib/src/openssl.rs
+++ b/crates/stdlib/src/openssl.rs
@@ -26,7 +26,7 @@ cfg_if::cfg_if! {
 pub(crate) use _ssl::module_def;
 
 use openssl_probe::ProbeResult;
-use std::sync::LazyLock;
+use rustpython_common::lock::LazyLock;
 
 // define our own copy of ProbeResult so we can handle the vendor case
 // easily, without having to have a bunch of cfgs
@@ -43,7 +43,12 @@ fn probe() -> &'static ProbeResult {
 }
 
 #[allow(non_upper_case_globals)]
-#[pymodule(with(cert::ssl_cert, ssl_error::ssl_error, ossl101, ossl111, windows))]
+#[pymodule(with(
+    cert::ssl_cert,
+    ssl_error::ssl_error,
+    #[cfg(ossl101)] ossl101,
+    #[cfg(ossl111)] ossl111,
+    #[cfg(windows)] windows))]
 mod _ssl {
     use super::{bio, probe};
 
@@ -90,7 +95,6 @@ mod _ssl {
         fmt,
         io::{Read, Write},
         path::{Path, PathBuf},
-        sync::LazyLock,
         time::Instant,
     };
 
@@ -101,7 +105,7 @@ mod _ssl {
         // if openssl is vendored, it doesn't know the locations
         // of system certificates - cache the probe result now.
         #[cfg(openssl_vendored)]
-        std::sync::LazyLock::force(&super::PROBE);
+        rustpython_common::lock::LazyLock::force(&super::PROBE);
 
         __module_exec(vm, module);
         Ok(())
@@ -273,6 +277,8 @@ mod _ssl {
     const HAS_TLSv1_3: bool = cfg!(ossl111);
     #[pyattr]
     const HAS_PSK: bool = true;
+    #[pyattr]
+    const HAS_PHA: bool = cfg!(ossl111);
 
     // Encoding constants for Certificate.public_bytes()
     #[pyattr]
@@ -388,11 +394,11 @@ mod _ssl {
         let nid = obj.nid();
         let short_name = nid
             .short_name()
-            .map_err(|_| vm.new_value_error("NID has no short name".to_owned()))?
+            .map_err(|_| vm.new_value_error("NID has no short name"))?
             .to_owned();
         let long_name = nid
             .long_name()
-            .map_err(|_| vm.new_value_error("NID has no long name".to_owned()))?
+            .map_err(|_| vm.new_value_error("NID has no long name"))?
             .to_owned();
         Ok((
             nid.as_raw(),
@@ -564,7 +570,7 @@ mod _ssl {
 
     // Get or create an ex_data index for SNI callback data
     fn get_sni_ex_data_index() -> libc::c_int {
-        use std::sync::LazyLock;
+        use rustpython_common::lock::LazyLock;
         static SNI_EX_DATA_IDX: LazyLock<libc::c_int> = LazyLock::new(|| unsafe {
             sys::SSL_get_ex_new_index(
                 0,
@@ -608,7 +614,7 @@ 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;
+        use rustpython_common::lock::LazyLock;
         static MSG_CB_EX_DATA_IDX: LazyLock<libc::c_int> = LazyLock::new(|| unsafe {
             sys::SSL_get_ex_new_index(
                 0,
@@ -1127,7 +1133,11 @@ mod _ssl {
             self.ctx.read().options().bits() as _
         }
         #[pygetset(setter)]
-        fn set_options(&self, new_opts: libc::c_ulong) {
+        fn set_options(&self, new_opts: i64, vm: &VirtualMachine) -> PyResult<()> {
+            if new_opts < 0 {
+                return Err(vm.new_value_error("invalid options value"));
+            }
+            let new_opts = new_opts as libc::c_ulong;
             let mut ctx = self.builder();
             // Get current options
             let current = ctx.options().bits() as libc::c_ulong;
@@ -1147,6 +1157,7 @@ mod _ssl {
             if set != 0 {
                 ctx.set_options(SslOptions::from_bits_truncate(set as _));
             }
+            Ok(())
         }
         #[pygetset]
         fn protocol(&self) -> i32 {
@@ -1310,14 +1321,12 @@ mod _ssl {
         fn set_num_tickets(&self, value: isize, vm: &VirtualMachine) -> PyResult<()> {
             // Check for negative values
             if value < 0 {
-                return Err(
-                    vm.new_value_error("num_tickets must be a non-negative integer".to_owned())
-                );
+                return Err(vm.new_value_error("num_tickets must be a non-negative integer"));
             }
 
             // Check that this is a server context
             if self.protocol != SslVersion::TlsServer {
-                return Err(vm.new_value_error("SSLContext is not a server context.".to_owned()));
+                return Err(vm.new_value_error("SSLContext is not a server context."));
             }
 
             #[cfg(ossl110)]
@@ -1410,7 +1419,7 @@ mod _ssl {
                 }
             } else {
                 if !callback.is_callable() {
-                    return Err(vm.new_type_error("callback must be callable".to_owned()));
+                    return Err(vm.new_type_error("callback must be callable"));
                 }
                 *self.psk_client_callback.lock() = Some(callback);
                 // Note: The actual callback will be invoked via SSL app_data mechanism
@@ -1446,7 +1455,7 @@ mod _ssl {
                 }
             } else {
                 if !callback.is_callable() {
-                    return Err(vm.new_type_error("callback must be callable".to_owned()));
+                    return Err(vm.new_type_error("callback must be callable"));
                 }
                 *self.psk_server_callback.lock() = Some(callback);
                 if let OptionalArg::Present(hint) = identity_hint {
@@ -1577,12 +1586,12 @@ mod _ssl {
             let store_ptr = unsafe { sys::SSL_CTX_get_cert_store(ctx.as_ptr()) };
 
             if store_ptr.is_null() {
-                return Err(vm.new_memory_error("failed to get cert store".to_owned()));
+                return Err(vm.new_memory_error("failed to get cert store"));
             }
 
             let objs_ptr = unsafe { sys::X509_STORE_get0_objects(store_ptr) };
             if objs_ptr.is_null() {
-                return Err(vm.new_memory_error("failed to query cert store".to_owned()));
+                return Err(vm.new_memory_error("failed to query cert store"));
             }
 
             let mut x509_count = 0;
@@ -1716,9 +1725,7 @@ mod _ssl {
         ) -> PyResult<()> {
             // Check if this is a server context
             if self.protocol == SslVersion::TlsClient {
-                return Err(vm.new_value_error(
-                    "sni_callback cannot be set on TLS_CLIENT context".to_owned(),
-                ));
+                return Err(vm.new_value_error("sni_callback cannot be set on TLS_CLIENT context"));
             }
 
             let mut callback_guard = self.sni_callback.lock();
@@ -1727,7 +1734,7 @@ mod _ssl {
                 if !vm.is_none(&callback_obj) {
                     // Check if callable
                     if !callback_obj.is_callable() {
-                        return Err(vm.new_type_error("not a callable object".to_owned()));
+                        return Err(vm.new_type_error("not a callable object"));
                     }
 
                     // Set the callback
@@ -1794,7 +1801,7 @@ mod _ssl {
                 if !vm.is_none(&callback_obj) {
                     // Check if callable
                     if !callback_obj.is_callable() {
-                        return Err(vm.new_type_error("not a callable object".to_owned()));
+                        return Err(vm.new_type_error("not a callable object"));
                     }
 
                     // Set the callback
@@ -2510,7 +2517,7 @@ mod _ssl {
             unsafe {
                 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()));
+                    return Err(vm.new_runtime_error("Failed to set SSL context"));
                 }
             }
 
@@ -2795,7 +2802,7 @@ mod _ssl {
             #[cfg(not(ossl111))]
             {
                 Err(vm.new_not_implemented_error(
-                    "Post-handshake auth is not supported by your OpenSSL version.".to_owned(),
+                    "Post-handshake auth is not supported by your OpenSSL version.",
                 ))
             }
         }
@@ -2852,10 +2859,11 @@ mod _ssl {
                     // Wait briefly for peer's close_notify before retrying
                     match socket_stream.select(SslNeeds::Read, &deadline) {
                         SelectRet::TimedOut => {
-                            return Err(vm.new_exception_msg(
-                                vm.ctx.exceptions.timeout_error.to_owned(),
-                                "The read operation timed out".to_owned(),
-                            ));
+                            return Err(socket::timeout_error_msg(
+                                vm,
+                                "The read operation timed out".to_string(),
+                            )
+                            .upcast());
                         }
                         SelectRet::Closed => {
                             return Err(socket_closed_error(vm));
@@ -2894,10 +2902,7 @@ mod _ssl {
                         } else {
                             "The write operation timed out"
                         };
-                        return Err(vm.new_exception_msg(
-                            vm.ctx.exceptions.timeout_error.to_owned(),
-                            msg.to_owned(),
-                        ));
+                        return Err(socket::timeout_error_msg(vm, msg.to_string()).upcast());
                     }
                     SelectRet::Closed => {
                         return Err(socket_closed_error(vm));
@@ -3105,32 +3110,26 @@ mod _ssl {
             // Check if value is SSLSession type
             let session = value
                 .downcast_ref::<PySslSession>()
-                .ok_or_else(|| vm.new_type_error("Value is not a SSLSession.".to_owned()))?;
+                .ok_or_else(|| vm.new_type_error("Value is not a SSLSession."))?;
 
             // Check if session refers to the same SSLContext
             if !std::ptr::eq(
                 self.ctx.read().ctx.read().as_ptr(),
                 session.ctx.ctx.read().as_ptr(),
             ) {
-                return Err(
-                    vm.new_value_error("Session refers to a different SSLContext.".to_owned())
-                );
+                return Err(vm.new_value_error("Session refers to a different SSLContext."));
             }
 
             // Check if this is a client socket
             if self.socket_type != SslServerOrClient::Client {
-                return Err(
-                    vm.new_value_error("Cannot set session for server-side SSLSocket.".to_owned())
-                );
+                return Err(vm.new_value_error("Cannot set session for server-side SSLSocket."));
             }
 
             // Check if handshake is not finished
             let stream = self.connection.read();
             unsafe {
                 if sys::SSL_is_init_finished(stream.ssl().as_ptr()) != 0 {
-                    return Err(
-                        vm.new_value_error("Cannot set session after handshake.".to_owned())
-                    );
+                    return Err(vm.new_value_error("Cannot set session after handshake."));
                 }
 
                 let ret = sys::SSL_set_session(stream.ssl().as_ptr(), session.session);
@@ -3171,7 +3170,7 @@ mod _ssl {
                 }
                 OptionalArg::Missing => {
                     if n < 0 {
-                        return Err(vm.new_value_error("size should not be negative".to_owned()));
+                        return Err(vm.new_value_error("size should not be negative"));
                     }
                     n as usize
                 }
@@ -3591,7 +3590,7 @@ mod _ssl {
             unsafe {
                 let bio = sys::BIO_new(sys::BIO_s_mem());
                 if bio.is_null() {
-                    return Err(vm.new_memory_error("failed to allocate BIO".to_owned()));
+                    return Err(vm.new_memory_error("failed to allocate BIO"));
                 }
 
                 sys::BIO_set_retry_read(bio);
@@ -4070,18 +4069,6 @@ mod _ssl {
     }
 }
 
-#[cfg(not(ossl101))]
-#[pymodule(sub)]
-mod ossl101 {}
-
-#[cfg(not(ossl111))]
-#[pymodule(sub)]
-mod ossl111 {}
-
-#[cfg(not(windows))]
-#[pymodule(sub)]
-mod windows {}
-
 #[allow(non_upper_case_globals)]
 #[cfg(ossl101)]
 #[pymodule(sub)]
diff --git a/crates/stdlib/src/overlapped.rs b/crates/stdlib/src/overlapped.rs
index 573d1fc0c85..76d18cb7a9a 100644
--- a/crates/stdlib/src/overlapped.rs
+++ b/crates/stdlib/src/overlapped.rs
@@ -8,13 +8,14 @@ mod _overlapped {
     // straight-forward port of Modules/overlapped.c
 
     use crate::vm::{
-        Py, PyObjectRef, PyPayload, PyResult, VirtualMachine,
-        builtins::{PyBaseExceptionRef, PyBytesRef, PyType},
+        AsObject, Py, PyObjectRef, PyPayload, PyResult, VirtualMachine,
+        builtins::{PyBaseExceptionRef, PyBytesRef, PyModule, PyStrRef, PyTupleRef, PyType},
         common::lock::PyMutex,
-        convert::{ToPyException, ToPyObject},
+        convert::ToPyObject,
         function::OptionalArg,
+        object::{Traverse, TraverseFn},
         protocol::PyBuffer,
-        types::Constructor,
+        types::{Constructor, Destructor},
     };
     use windows_sys::Win32::{
         Foundation::{self, GetLastError, HANDLE},
@@ -22,6 +23,13 @@ mod _overlapped {
         System::IO::OVERLAPPED,
     };
 
+    pub(crate) fn module_exec(vm: &VirtualMachine, module: &Py<PyModule>) -> PyResult<()> {
+        let _ = vm.import("_socket", 0)?;
+        initialize_winsock_extensions(vm)?;
+        __module_exec(vm, module);
+        Ok(())
+    }
+
     #[pyattr]
     use windows_sys::Win32::{
         Foundation::{
@@ -49,8 +57,8 @@ mod _overlapped {
 
     fn initialize_winsock_extensions(vm: &VirtualMachine) -> PyResult<()> {
         use windows_sys::Win32::Networking::WinSock::{
-            IPPROTO_TCP, SIO_GET_EXTENSION_FUNCTION_POINTER, SOCK_STREAM, SOCKET_ERROR, WSAIoctl,
-            closesocket, socket,
+            INVALID_SOCKET, IPPROTO_TCP, SIO_GET_EXTENSION_FUNCTION_POINTER, SOCK_STREAM,
+            SOCKET_ERROR, WSAGetLastError, WSAIoctl, closesocket, socket,
         };
 
         // GUIDs for extension functions
@@ -89,10 +97,9 @@ mod _overlapped {
         }
 
         let s = unsafe { socket(AF_INET as i32, SOCK_STREAM, IPPROTO_TCP) };
-        if s == windows_sys::Win32::Networking::WinSock::INVALID_SOCKET {
-            return Err(
-                vm.new_os_error("Failed to create socket for WSA extension init".to_owned())
-            );
+        if s == INVALID_SOCKET {
+            let err = unsafe { WSAGetLastError() } as u32;
+            return Err(set_from_windows_err(err, vm));
         }
 
         let mut dw_bytes: u32 = 0;
@@ -105,17 +112,18 @@ mod _overlapped {
                         s,
                         SIO_GET_EXTENSION_FUNCTION_POINTER,
                         &$guid as *const _ as *const _,
-                        std::mem::size_of_val(&$guid) as u32,
+                        core::mem::size_of_val(&$guid) as u32,
                         &mut func_ptr as *mut _ as *mut _,
-                        std::mem::size_of::<usize>() as u32,
+                        core::mem::size_of::<usize>() as u32,
                         &mut dw_bytes,
-                        std::ptr::null_mut(),
+                        core::ptr::null_mut(),
                         None,
                     )
                 };
                 if ret == SOCKET_ERROR {
+                    let err = unsafe { WSAGetLastError() } as u32;
                     unsafe { closesocket(s) };
-                    return Err(vm.new_os_error("Failed to get WSA extension function".to_owned()));
+                    return Err(set_from_windows_err(err, vm));
                 }
                 let _ = $lock.set(func_ptr);
             }};
@@ -131,7 +139,7 @@ mod _overlapped {
     }
 
     #[pyattr]
-    #[pyclass(name)]
+    #[pyclass(name, traverse)]
     #[derive(PyPayload)]
     struct Overlapped {
         inner: PyMutex<OverlappedInner>,
@@ -147,6 +155,35 @@ mod _overlapped {
     unsafe impl Sync for OverlappedInner {}
     unsafe impl Send for OverlappedInner {}
 
+    unsafe impl Traverse for OverlappedInner {
+        fn traverse(&self, traverse_fn: &mut TraverseFn<'_>) {
+            match &self.data {
+                OverlappedData::Read(buf) | OverlappedData::Accept(buf) => {
+                    buf.traverse(traverse_fn);
+                }
+                OverlappedData::ReadInto(buf) | OverlappedData::Write(buf) => {
+                    buf.traverse(traverse_fn);
+                }
+                OverlappedData::WriteTo(wt) => {
+                    wt.buf.traverse(traverse_fn);
+                }
+                OverlappedData::ReadFrom(rf) => {
+                    if let Some(result) = &rf.result {
+                        result.traverse(traverse_fn);
+                    }
+                    rf.allocated_buffer.traverse(traverse_fn);
+                }
+                OverlappedData::ReadFromInto(rfi) => {
+                    if let Some(result) = &rfi.result {
+                        result.traverse(traverse_fn);
+                    }
+                    rfi.user_buffer.traverse(traverse_fn);
+                }
+                _ => {}
+            }
+        }
+    }
+
     impl core::fmt::Debug for Overlapped {
         fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
             let zelf = self.inner.lock();
@@ -182,6 +219,8 @@ mod _overlapped {
     }
 
     struct OverlappedReadFrom {
+        // A (buffer, (host, port)) tuple
+        result: Option<PyObjectRef>,
         // The actual read buffer
         allocated_buffer: PyBytesRef,
         address: SOCKADDR_IN6,
@@ -191,6 +230,7 @@ mod _overlapped {
     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)
                 .field("address_length", &self.address_length)
                 .finish()
@@ -198,6 +238,8 @@ mod _overlapped {
     }
 
     struct OverlappedReadFromInto {
+        // A (number of bytes read, (host, port)) tuple
+        result: Option<PyObjectRef>,
         /* Buffer passed by the user */
         user_buffer: PyBuffer,
         address: SOCKADDR_IN6,
@@ -207,6 +249,7 @@ mod _overlapped {
     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)
                 .field("address_length", &self.address_length)
                 .finish()
@@ -234,15 +277,19 @@ mod _overlapped {
         }
     }
 
-    fn from_windows_err(err: u32, vm: &VirtualMachine) -> PyBaseExceptionRef {
-        use Foundation::{ERROR_CONNECTION_ABORTED, ERROR_CONNECTION_REFUSED};
-        debug_assert_ne!(err, 0, "call errno_err instead");
-        let exc = match err {
-            ERROR_CONNECTION_REFUSED => vm.ctx.exceptions.connection_refused_error,
-            ERROR_CONNECTION_ABORTED => vm.ctx.exceptions.connection_aborted_error,
-            err => return std::io::Error::from_raw_os_error(err as i32).to_pyexception(vm),
+    fn set_from_windows_err(err: u32, vm: &VirtualMachine) -> PyBaseExceptionRef {
+        let err = if err == 0 {
+            unsafe { GetLastError() }
+        } else {
+            err
         };
-        vm.new_exception_empty(exc.to_owned())
+        let errno = crate::vm::common::os::winerror_to_errno(err as i32);
+        let message = std::io::Error::from_raw_os_error(err as i32).to_string();
+        let exc = vm.new_errno_error(errno, message);
+        let _ = exc
+            .as_object()
+            .set_attr("winerror", err.to_pyobject(vm), vm);
+        exc.upcast()
     }
 
     fn HasOverlappedIoCompleted(overlapped: &OVERLAPPED) -> bool {
@@ -250,140 +297,122 @@ mod _overlapped {
     }
 
     /// Parse a Python address tuple to SOCKADDR
-    fn parse_address(addr_obj: &PyObjectRef, vm: &VirtualMachine) -> PyResult<(Vec<u8>, i32)> {
-        use crate::vm::builtins::PyTuple;
-        use windows_sys::Win32::Networking::WinSock::WSAStringToAddressW;
+    fn parse_address(addr_obj: &PyTupleRef, vm: &VirtualMachine) -> PyResult<(Vec<u8>, i32)> {
+        use windows_sys::Win32::Networking::WinSock::{WSAGetLastError, WSAStringToAddressW};
 
-        let tuple = addr_obj
-            .downcast_ref::<PyTuple>()
-            .ok_or_else(|| vm.new_type_error("address must be a tuple".to_owned()))?;
+        match addr_obj.len() {
+            2 => {
+                // IPv4: (host, port)
+                let host: PyStrRef = addr_obj[0].clone().try_into_value(vm)?;
+                let port: u16 = addr_obj[1].clone().try_to_value(vm)?;
 
-        let tuple_len = tuple.len();
+                let mut addr: SOCKADDR_IN = unsafe { core::mem::zeroed() };
+                addr.sin_family = AF_INET;
 
-        if tuple_len == 2 {
-            // IPv4: (host, port)
-            let host: String = tuple[0].try_to_value(vm)?;
-            let port: u16 = tuple[1].try_to_value(vm)?;
+                let host_wide: Vec<u16> = host.as_wtf8().encode_wide().chain([0]).collect();
+                let mut addr_len = core::mem::size_of::<SOCKADDR_IN>() as i32;
 
-            let mut addr: SOCKADDR_IN = unsafe { std::mem::zeroed() };
-            addr.sin_family = AF_INET;
-            addr.sin_port = port.to_be();
+                let ret = unsafe {
+                    WSAStringToAddressW(
+                        host_wide.as_ptr(),
+                        AF_INET as i32,
+                        core::ptr::null(),
+                        &mut addr as *mut _ as *mut SOCKADDR,
+                        &mut addr_len,
+                    )
+                };
 
-            // Convert host string to address
-            let host_wide: Vec<u16> = host.encode_utf16().chain(std::iter::once(0)).collect();
-            let mut addr_len = std::mem::size_of::<SOCKADDR_IN>() as i32;
+                if ret < 0 {
+                    let err = unsafe { WSAGetLastError() } as u32;
+                    return Err(set_from_windows_err(err, vm));
+                }
 
-            let ret = unsafe {
-                WSAStringToAddressW(
-                    host_wide.as_ptr(),
-                    AF_INET as i32,
-                    std::ptr::null(),
-                    &mut addr as *mut _ as *mut SOCKADDR,
-                    &mut addr_len,
-                )
-            };
+                // Restore port (WSAStringToAddressW overwrites it)
+                addr.sin_port = port.to_be();
 
-            if ret != 0 {
-                return Err(vm.new_os_error(format!("Invalid IPv4 address: {}", host)));
+                let bytes = unsafe {
+                    core::slice::from_raw_parts(
+                        &addr as *const _ as *const u8,
+                        core::mem::size_of::<SOCKADDR_IN>(),
+                    )
+                };
+                Ok((bytes.to_vec(), addr_len))
             }
+            4 => {
+                // IPv6: (host, port, flowinfo, scope_id)
+                let host: PyStrRef = addr_obj[0].clone().try_into_value(vm)?;
+                let port: u16 = addr_obj[1].clone().try_to_value(vm)?;
+                let flowinfo: u32 = addr_obj[2].clone().try_to_value(vm)?;
+                let scope_id: u32 = addr_obj[3].clone().try_to_value(vm)?;
 
-            // Restore port (WSAStringToAddressW overwrites it)
-            addr.sin_port = port.to_be();
+                let mut addr: SOCKADDR_IN6 = unsafe { core::mem::zeroed() };
+                addr.sin6_family = AF_INET6;
 
-            let bytes = unsafe {
-                std::slice::from_raw_parts(
-                    &addr as *const _ as *const u8,
-                    std::mem::size_of::<SOCKADDR_IN>(),
-                )
-            };
-            Ok((bytes.to_vec(), std::mem::size_of::<SOCKADDR_IN>() as i32))
-        } else if tuple_len == 4 {
-            // IPv6: (host, port, flowinfo, scope_id)
-            let host: String = tuple[0].try_to_value(vm)?;
-            let port: u16 = tuple[1].try_to_value(vm)?;
-            let flowinfo: u32 = tuple[2].try_to_value(vm)?;
-            let scope_id: u32 = tuple[3].try_to_value(vm)?;
-
-            let mut addr: SOCKADDR_IN6 = unsafe { std::mem::zeroed() };
-            addr.sin6_family = AF_INET6;
-            addr.sin6_port = port.to_be();
-            addr.sin6_flowinfo = flowinfo;
-            addr.Anonymous.sin6_scope_id = scope_id;
+                let host_wide: Vec<u16> = host.as_wtf8().encode_wide().chain([0]).collect();
+                let mut addr_len = core::mem::size_of::<SOCKADDR_IN6>() as i32;
 
-            let host_wide: Vec<u16> = host.encode_utf16().chain(std::iter::once(0)).collect();
-            let mut addr_len = std::mem::size_of::<SOCKADDR_IN6>() as i32;
-
-            let ret = unsafe {
-                WSAStringToAddressW(
-                    host_wide.as_ptr(),
-                    AF_INET6 as i32,
-                    std::ptr::null(),
-                    &mut addr as *mut _ as *mut SOCKADDR,
-                    &mut addr_len,
-                )
-            };
+                let ret = unsafe {
+                    WSAStringToAddressW(
+                        host_wide.as_ptr(),
+                        AF_INET6 as i32,
+                        core::ptr::null(),
+                        &mut addr as *mut _ as *mut SOCKADDR,
+                        &mut addr_len,
+                    )
+                };
 
-            if ret != 0 {
-                return Err(vm.new_os_error(format!("Invalid IPv6 address: {}", host)));
-            }
+                if ret < 0 {
+                    let err = unsafe { WSAGetLastError() } as u32;
+                    return Err(set_from_windows_err(err, vm));
+                }
 
-            // Restore fields that WSAStringToAddressW might overwrite
-            addr.sin6_port = port.to_be();
-            addr.sin6_flowinfo = flowinfo;
-            addr.Anonymous.sin6_scope_id = scope_id;
+                // Restore fields that WSAStringToAddressW might overwrite
+                addr.sin6_port = port.to_be();
+                addr.sin6_flowinfo = flowinfo;
+                addr.Anonymous.sin6_scope_id = scope_id;
 
-            let bytes = unsafe {
-                std::slice::from_raw_parts(
-                    &addr as *const _ as *const u8,
-                    std::mem::size_of::<SOCKADDR_IN6>(),
-                )
-            };
-            Ok((bytes.to_vec(), std::mem::size_of::<SOCKADDR_IN6>() as i32))
-        } else {
-            Err(vm.new_value_error("address tuple must have 2 or 4 elements".to_owned()))
+                let bytes = unsafe {
+                    core::slice::from_raw_parts(
+                        &addr as *const _ as *const u8,
+                        core::mem::size_of::<SOCKADDR_IN6>(),
+                    )
+                };
+                Ok((bytes.to_vec(), addr_len))
+            }
+            _ => Err(vm.new_value_error("illegal address_as_bytes argument")),
         }
     }
 
     /// Parse a SOCKADDR_IN6 (which can also hold IPv4 addresses) to a Python address tuple
-    fn unparse_address(addr: &SOCKADDR_IN6, _addr_len: i32, vm: &VirtualMachine) -> PyObjectRef {
+    fn unparse_address(addr: &SOCKADDR_IN6, _addr_len: i32, vm: &VirtualMachine) -> PyResult {
+        use core::net::{Ipv4Addr, Ipv6Addr};
+
         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 ip_str =
+                    Ipv4Addr::new(ip_bytes.s_b1, ip_bytes.s_b2, ip_bytes.s_b3, ip_bytes.s_b4)
+                        .to_string();
                 let port = u16::from_be(addr_in.sin_port);
-                (ip_str, port).to_pyobject(vm)
+                Ok((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 ip_str = Ipv6Addr::from(ip_bytes).to_string();
                 let port = u16::from_be(addr.sin6_port);
-                let flowinfo = addr.sin6_flowinfo;
+                let flowinfo = u32::from_be(addr.sin6_flowinfo);
                 let scope_id = addr.Anonymous.sin6_scope_id;
-                (ip_str, port, flowinfo, scope_id).to_pyobject(vm)
+                Ok((ip_str, port, flowinfo, scope_id).to_pyobject(vm))
             } else {
-                // Unknown address family, return None
-                vm.ctx.none()
+                Err(vm.new_value_error("recvfrom returned unsupported address family"))
             }
         }
     }
 
-    #[pyclass(with(Constructor))]
+    #[pyclass(with(Constructor, Destructor))]
     impl Overlapped {
         #[pygetset]
         fn address(&self, _vm: &VirtualMachine) -> usize {
@@ -428,7 +457,7 @@ mod _overlapped {
             };
             // CancelIoEx returns ERROR_NOT_FOUND if the I/O completed in-between
             if ret == 0 && unsafe { GetLastError() } != Foundation::ERROR_NOT_FOUND {
-                return Err(vm.new_last_os_error());
+                return Err(set_from_windows_err(0, vm));
             }
             Ok(())
         }
@@ -436,25 +465,24 @@ mod _overlapped {
         #[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,
+                ERROR_BROKEN_PIPE, 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()));
+                return Err(vm.new_value_error("operation not yet attempted"));
             }
             if matches!(inner.data, OverlappedData::NotStarted) {
-                return Err(vm.new_value_error("operation failed to start".to_owned()));
+                return Err(vm.new_value_error("operation failed to start"));
             }
 
             // Get the result
             let mut transferred: u32 = 0;
             let ret = unsafe {
-                GetOverlappedResult(
+                windows_sys::Win32::System::IO::GetOverlappedResult(
                     inner.handle,
                     &inner.overlapped,
                     &mut transferred,
@@ -473,62 +501,65 @@ mod _overlapped {
             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(_) => {}
-                        OverlappedData::ReadFromInto(_) => {}
-                        _ => return Err(from_windows_err(err, vm)),
+                    let allow_broken_pipe = match &inner.data {
+                        OverlappedData::Read(_) | OverlappedData::ReadInto(_) => true,
+                        OverlappedData::ReadFrom(_) => true,
+                        OverlappedData::ReadFromInto(rfi) => rfi.result.is_some(),
+                        _ => false,
+                    };
+                    if !allow_broken_pipe {
+                        return Err(set_from_windows_err(err, vm));
                     }
                 }
-                ERROR_IO_PENDING => {
-                    return Err(from_windows_err(err, vm));
-                }
-                _ => return Err(from_windows_err(err, vm)),
+                _ => return Err(set_from_windows_err(err, vm)),
             }
 
             // Return result based on operation type
-            match &inner.data {
+            match &mut inner.data {
                 OverlappedData::Read(buf) => {
-                    let bytes = buf.as_bytes();
-                    let result = if transferred as usize != bytes.len() {
-                        vm.ctx.new_bytes(bytes[..transferred as usize].to_vec())
+                    let len = buf.as_bytes().len();
+                    let result = if transferred as usize != len {
+                        let resized = vm
+                            .ctx
+                            .new_bytes(buf.as_bytes()[..transferred as usize].to_vec());
+                        *buf = resized.clone();
+                        resized
                     } else {
                         buf.clone()
                     };
                     Ok(result.into())
                 }
-                OverlappedData::ReadInto(_) => Ok(vm.ctx.new_int(transferred).into()),
-                OverlappedData::Write(_) | OverlappedData::WriteTo(_) => {
-                    Ok(vm.ctx.new_int(transferred).into())
-                }
-                OverlappedData::Accept(_) => Ok(vm.ctx.none()),
-                OverlappedData::Connect(_) => Ok(vm.ctx.none()),
-                OverlappedData::Disconnect => Ok(vm.ctx.none()),
-                OverlappedData::ConnectNamedPipe => Ok(vm.ctx.none()),
-                OverlappedData::WaitNamedPipeAndConnect => Ok(vm.ctx.none()),
-                OverlappedData::TransmitFile => Ok(vm.ctx.none()),
                 OverlappedData::ReadFrom(rf) => {
-                    let bytes = rf.allocated_buffer.as_bytes();
-                    let resized_buf = if transferred as usize != bytes.len() {
-                        vm.ctx.new_bytes(bytes[..transferred as usize].to_vec())
+                    let len = rf.allocated_buffer.as_bytes().len();
+                    let resized_buf = if transferred as usize != len {
+                        let resized = vm.ctx.new_bytes(
+                            rf.allocated_buffer.as_bytes()[..transferred as usize].to_vec(),
+                        );
+                        rf.allocated_buffer = resized.clone();
+                        resized
                     } else {
                         rf.allocated_buffer.clone()
                     };
-                    let addr_tuple = unparse_address(&rf.address, rf.address_length, vm);
-                    Ok(vm
-                        .ctx
-                        .new_tuple(vec![resized_buf.into(), addr_tuple])
-                        .into())
+                    let addr_tuple = unparse_address(&rf.address, rf.address_length, vm)?;
+                    if let Some(result) = &rf.result {
+                        return Ok(result.clone());
+                    }
+                    let result = vm.ctx.new_tuple(vec![resized_buf.into(), addr_tuple]);
+                    rf.result = Some(result.clone().into());
+                    Ok(result.into())
                 }
                 OverlappedData::ReadFromInto(rfi) => {
-                    let addr_tuple = unparse_address(&rfi.address, rfi.address_length, vm);
-                    Ok(vm
+                    let addr_tuple = unparse_address(&rfi.address, rfi.address_length, vm)?;
+                    if let Some(result) = &rfi.result {
+                        return Ok(result.clone());
+                    }
+                    let result = vm
                         .ctx
-                        .new_tuple(vec![vm.ctx.new_int(transferred).into(), addr_tuple])
-                        .into())
+                        .new_tuple(vec![vm.ctx.new_int(transferred).into(), addr_tuple]);
+                    rfi.result = Some(result.clone().into());
+                    Ok(result.into())
                 }
-                _ => Ok(vm.ctx.none()),
+                _ => Ok(vm.ctx.new_int(transferred).into()),
             }
         }
 
@@ -542,13 +573,13 @@ mod _overlapped {
 
             let mut inner = zelf.inner.lock();
             if !matches!(inner.data, OverlappedData::None) {
-                return Err(vm.new_value_error("operation already attempted".to_owned()));
+                return Err(vm.new_value_error("operation already attempted"));
             }
 
             #[cfg(target_pointer_width = "32")]
             let size = core::cmp::min(size, isize::MAX as u32);
 
-            let buf = vec![0u8; std::cmp::max(size, 1) as usize];
+            let buf = vec![0u8; core::cmp::max(size, 1) as usize];
             let buf = vm.ctx.new_bytes(buf);
             inner.handle = handle as HANDLE;
             inner.data = OverlappedData::Read(buf.clone());
@@ -574,12 +605,12 @@ mod _overlapped {
             match err {
                 ERROR_BROKEN_PIPE => {
                     mark_as_completed(&mut inner.overlapped);
-                    Err(from_windows_err(err, vm))
+                    Err(set_from_windows_err(err, vm))
                 }
                 ERROR_SUCCESS | ERROR_MORE_DATA | ERROR_IO_PENDING => Ok(vm.ctx.none()),
                 _ => {
                     inner.data = OverlappedData::NotStarted;
-                    Err(from_windows_err(err, vm))
+                    Err(set_from_windows_err(err, vm))
                 }
             }
         }
@@ -599,16 +630,19 @@ mod _overlapped {
 
             let mut inner = zelf.inner.lock();
             if !matches!(inner.data, OverlappedData::None) {
-                return Err(vm.new_value_error("operation already attempted".to_owned()));
+                return Err(vm.new_value_error("operation already attempted"));
             }
 
             inner.handle = handle as HANDLE;
             let buf_len = buf.desc.len;
+            if buf_len > u32::MAX as usize {
+                return Err(vm.new_value_error("buffer too large"));
+            }
 
             // For async read, buffer must be contiguous - we can't use a temporary copy
             // because Windows writes data directly to the buffer after this call returns
             let Some(contiguous) = buf.as_contiguous_mut() else {
-                return Err(vm.new_buffer_error("buffer is not contiguous".to_owned()));
+                return Err(vm.new_buffer_error("buffer is not contiguous"));
             };
 
             inner.data = OverlappedData::ReadInto(buf.clone());
@@ -634,12 +668,12 @@ mod _overlapped {
             match err {
                 ERROR_BROKEN_PIPE => {
                     mark_as_completed(&mut inner.overlapped);
-                    Err(from_windows_err(err, vm))
+                    Err(set_from_windows_err(err, vm))
                 }
                 ERROR_SUCCESS | ERROR_MORE_DATA | ERROR_IO_PENDING => Ok(vm.ctx.none()),
                 _ => {
                     inner.data = OverlappedData::NotStarted;
-                    Err(from_windows_err(err, vm))
+                    Err(set_from_windows_err(err, vm))
                 }
             }
         }
@@ -660,7 +694,7 @@ mod _overlapped {
 
             let mut inner = zelf.inner.lock();
             if !matches!(inner.data, OverlappedData::None) {
-                return Err(vm.new_value_error("operation already attempted".to_owned()));
+                return Err(vm.new_value_error("operation already attempted"));
             }
 
             let mut flags = flags.unwrap_or(0);
@@ -668,7 +702,7 @@ mod _overlapped {
             #[cfg(target_pointer_width = "32")]
             let size = core::cmp::min(size, isize::MAX as u32);
 
-            let buf = vec![0u8; std::cmp::max(size, 1) as usize];
+            let buf = vec![0u8; core::cmp::max(size, 1) as usize];
             let buf = vm.ctx.new_bytes(buf);
             inner.handle = handle as HANDLE;
             inner.data = OverlappedData::Read(buf.clone());
@@ -701,12 +735,12 @@ mod _overlapped {
             match err {
                 ERROR_BROKEN_PIPE => {
                     mark_as_completed(&mut inner.overlapped);
-                    Err(from_windows_err(err, vm))
+                    Err(set_from_windows_err(err, vm))
                 }
                 ERROR_SUCCESS | ERROR_MORE_DATA | ERROR_IO_PENDING => Ok(vm.ctx.none()),
                 _ => {
                     inner.data = OverlappedData::NotStarted;
-                    Err(from_windows_err(err, vm))
+                    Err(set_from_windows_err(err, vm))
                 }
             }
         }
@@ -727,15 +761,18 @@ mod _overlapped {
 
             let mut inner = zelf.inner.lock();
             if !matches!(inner.data, OverlappedData::None) {
-                return Err(vm.new_value_error("operation already attempted".to_owned()));
+                return Err(vm.new_value_error("operation already attempted"));
             }
 
             let mut flags = flags;
             inner.handle = handle as HANDLE;
             let buf_len = buf.desc.len;
+            if buf_len > u32::MAX as usize {
+                return Err(vm.new_value_error("buffer too large"));
+            }
 
             let Some(contiguous) = buf.as_contiguous_mut() else {
-                return Err(vm.new_buffer_error("buffer is not contiguous".to_owned()));
+                return Err(vm.new_buffer_error("buffer is not contiguous"));
             };
 
             inner.data = OverlappedData::ReadInto(buf.clone());
@@ -768,12 +805,12 @@ mod _overlapped {
             match err {
                 ERROR_BROKEN_PIPE => {
                     mark_as_completed(&mut inner.overlapped);
-                    Err(from_windows_err(err, vm))
+                    Err(set_from_windows_err(err, vm))
                 }
                 ERROR_SUCCESS | ERROR_MORE_DATA | ERROR_IO_PENDING => Ok(vm.ctx.none()),
                 _ => {
                     inner.data = OverlappedData::NotStarted;
-                    Err(from_windows_err(err, vm))
+                    Err(set_from_windows_err(err, vm))
                 }
             }
         }
@@ -791,16 +828,19 @@ mod _overlapped {
 
             let mut inner = zelf.inner.lock();
             if !matches!(inner.data, OverlappedData::None) {
-                return Err(vm.new_value_error("operation already attempted".to_owned()));
+                return Err(vm.new_value_error("operation already attempted"));
             }
 
             inner.handle = handle as HANDLE;
             let buf_len = buf.desc.len;
+            if buf_len > u32::MAX as usize {
+                return Err(vm.new_value_error("buffer too large"));
+            }
 
             // For async write, buffer must be contiguous - we can't use a temporary copy
             // because Windows reads from the buffer after this call returns
             let Some(contiguous) = buf.as_contiguous() else {
-                return Err(vm.new_buffer_error("buffer is not contiguous".to_owned()));
+                return Err(vm.new_buffer_error("buffer is not contiguous"));
             };
 
             inner.data = OverlappedData::Write(buf.clone());
@@ -827,7 +867,7 @@ mod _overlapped {
                 ERROR_SUCCESS | ERROR_IO_PENDING => Ok(vm.ctx.none()),
                 _ => {
                     inner.data = OverlappedData::NotStarted;
-                    Err(from_windows_err(err, vm))
+                    Err(set_from_windows_err(err, vm))
                 }
             }
         }
@@ -846,14 +886,17 @@ mod _overlapped {
 
             let mut inner = zelf.inner.lock();
             if !matches!(inner.data, OverlappedData::None) {
-                return Err(vm.new_value_error("operation already attempted".to_owned()));
+                return Err(vm.new_value_error("operation already attempted"));
             }
 
             inner.handle = handle as HANDLE;
             let buf_len = buf.desc.len;
+            if buf_len > u32::MAX as usize {
+                return Err(vm.new_value_error("buffer too large"));
+            }
 
             let Some(contiguous) = buf.as_contiguous() else {
-                return Err(vm.new_buffer_error("buffer is not contiguous".to_owned()));
+                return Err(vm.new_buffer_error("buffer is not contiguous"));
             };
 
             inner.data = OverlappedData::Write(buf.clone());
@@ -887,7 +930,7 @@ mod _overlapped {
                 ERROR_SUCCESS | ERROR_IO_PENDING => Ok(vm.ctx.none()),
                 _ => {
                     inner.data = OverlappedData::NotStarted;
-                    Err(from_windows_err(err, vm))
+                    Err(set_from_windows_err(err, vm))
                 }
             }
         }
@@ -903,15 +946,13 @@ mod _overlapped {
             use windows_sys::Win32::Foundation::{ERROR_IO_PENDING, ERROR_SUCCESS};
             use windows_sys::Win32::Networking::WinSock::WSAGetLastError;
 
-            initialize_winsock_extensions(vm)?;
-
             let mut inner = zelf.inner.lock();
             if !matches!(inner.data, OverlappedData::None) {
-                return Err(vm.new_value_error("operation already attempted".to_owned()));
+                return Err(vm.new_value_error("operation already attempted"));
             }
 
             // Buffer size: local address + remote address
-            let size = std::mem::size_of::<SOCKADDR_IN6>() + 16;
+            let size = core::mem::size_of::<SOCKADDR_IN6>() + 16;
             let buf = vec![0u8; size * 2];
             let buf = vm.ctx.new_bytes(buf);
 
@@ -931,7 +972,7 @@ mod _overlapped {
                 lpOverlapped: *mut OVERLAPPED,
             ) -> i32;
 
-            let accept_ex: AcceptExFn = unsafe { std::mem::transmute(*ACCEPT_EX.get().unwrap()) };
+            let accept_ex: AcceptExFn = unsafe { core::mem::transmute(*ACCEPT_EX.get().unwrap()) };
 
             let ret = unsafe {
                 accept_ex(
@@ -957,7 +998,7 @@ mod _overlapped {
                 ERROR_SUCCESS | ERROR_IO_PENDING => Ok(vm.ctx.none()),
                 _ => {
                     inner.data = OverlappedData::NotStarted;
-                    Err(from_windows_err(err, vm))
+                    Err(set_from_windows_err(err, vm))
                 }
             }
         }
@@ -967,17 +1008,15 @@ mod _overlapped {
         fn ConnectEx(
             zelf: &Py<Self>,
             socket: isize,
-            address: PyObjectRef,
+            address: PyTupleRef,
             vm: &VirtualMachine,
         ) -> PyResult {
             use windows_sys::Win32::Foundation::{ERROR_IO_PENDING, ERROR_SUCCESS};
             use windows_sys::Win32::Networking::WinSock::WSAGetLastError;
 
-            initialize_winsock_extensions(vm)?;
-
             let mut inner = zelf.inner.lock();
             if !matches!(inner.data, OverlappedData::None) {
-                return Err(vm.new_value_error("operation already attempted".to_owned()));
+                return Err(vm.new_value_error("operation already attempted"));
             }
 
             let (addr_bytes, addr_len) = parse_address(&address, vm)?;
@@ -997,7 +1036,7 @@ mod _overlapped {
             ) -> i32;
 
             let connect_ex: ConnectExFn =
-                unsafe { std::mem::transmute(*CONNECT_EX.get().unwrap()) };
+                unsafe { core::mem::transmute(*CONNECT_EX.get().unwrap()) };
 
             // Get pointer to the stored address data
             let addr_ptr = match &inner.data {
@@ -1010,9 +1049,9 @@ mod _overlapped {
                     socket as _,
                     addr_ptr as *const SOCKADDR,
                     addr_len,
-                    std::ptr::null(),
+                    core::ptr::null(),
                     0,
-                    std::ptr::null_mut(),
+                    core::ptr::null_mut(),
                     &mut inner.overlapped,
                 )
             };
@@ -1028,7 +1067,7 @@ mod _overlapped {
                 ERROR_SUCCESS | ERROR_IO_PENDING => Ok(vm.ctx.none()),
                 _ => {
                     inner.data = OverlappedData::NotStarted;
-                    Err(from_windows_err(err, vm))
+                    Err(set_from_windows_err(err, vm))
                 }
             }
         }
@@ -1044,11 +1083,9 @@ mod _overlapped {
             use windows_sys::Win32::Foundation::{ERROR_IO_PENDING, ERROR_SUCCESS};
             use windows_sys::Win32::Networking::WinSock::WSAGetLastError;
 
-            initialize_winsock_extensions(vm)?;
-
             let mut inner = zelf.inner.lock();
             if !matches!(inner.data, OverlappedData::None) {
-                return Err(vm.new_value_error("operation already attempted".to_owned()));
+                return Err(vm.new_value_error("operation already attempted"));
             }
 
             inner.handle = socket as HANDLE;
@@ -1062,7 +1099,7 @@ mod _overlapped {
             ) -> i32;
 
             let disconnect_ex: DisconnectExFn =
-                unsafe { std::mem::transmute(*DISCONNECT_EX.get().unwrap()) };
+                unsafe { core::mem::transmute(*DISCONNECT_EX.get().unwrap()) };
 
             let ret = unsafe { disconnect_ex(socket as _, &mut inner.overlapped, flags, 0) };
 
@@ -1077,13 +1114,16 @@ mod _overlapped {
                 ERROR_SUCCESS | ERROR_IO_PENDING => Ok(vm.ctx.none()),
                 _ => {
                     inner.data = OverlappedData::NotStarted;
-                    Err(from_windows_err(err, vm))
+                    Err(set_from_windows_err(err, vm))
                 }
             }
         }
 
         // TransmitFile
-        #[allow(clippy::too_many_arguments)]
+        #[allow(
+            clippy::too_many_arguments,
+            reason = "mirrors Windows TransmitFile argument structure"
+        )]
         #[pymethod]
         fn TransmitFile(
             zelf: &Py<Self>,
@@ -1099,11 +1139,9 @@ mod _overlapped {
             use windows_sys::Win32::Foundation::{ERROR_IO_PENDING, ERROR_SUCCESS};
             use windows_sys::Win32::Networking::WinSock::WSAGetLastError;
 
-            initialize_winsock_extensions(vm)?;
-
             let mut inner = zelf.inner.lock();
             if !matches!(inner.data, OverlappedData::None) {
-                return Err(vm.new_value_error("operation already attempted".to_owned()));
+                return Err(vm.new_value_error("operation already attempted"));
             }
 
             inner.handle = socket as HANDLE;
@@ -1122,7 +1160,7 @@ mod _overlapped {
             ) -> i32;
 
             let transmit_file: TransmitFileFn =
-                unsafe { std::mem::transmute(*TRANSMIT_FILE.get().unwrap()) };
+                unsafe { core::mem::transmute(*TRANSMIT_FILE.get().unwrap()) };
 
             let ret = unsafe {
                 transmit_file(
@@ -1131,7 +1169,7 @@ mod _overlapped {
                     count_to_write,
                     count_per_send,
                     &mut inner.overlapped,
-                    std::ptr::null(),
+                    core::ptr::null(),
                     flags,
                 )
             };
@@ -1147,7 +1185,7 @@ mod _overlapped {
                 ERROR_SUCCESS | ERROR_IO_PENDING => Ok(vm.ctx.none()),
                 _ => {
                     inner.data = OverlappedData::NotStarted;
-                    Err(from_windows_err(err, vm))
+                    Err(set_from_windows_err(err, vm))
                 }
             }
         }
@@ -1162,7 +1200,7 @@ mod _overlapped {
 
             let mut inner = zelf.inner.lock();
             if !matches!(inner.data, OverlappedData::None) {
-                return Err(vm.new_value_error("operation already attempted".to_owned()));
+                return Err(vm.new_value_error("operation already attempted"));
             }
 
             inner.handle = pipe as HANDLE;
@@ -1185,40 +1223,11 @@ mod _overlapped {
                 ERROR_SUCCESS | ERROR_IO_PENDING => Ok(false),
                 _ => {
                     inner.data = OverlappedData::NotStarted;
-                    Err(from_windows_err(err, vm))
+                    Err(set_from_windows_err(err, vm))
                 }
             }
         }
 
-        // ConnectPipe - this is a static method that returns a handle
-        #[pymethod]
-        fn ConnectPipe(address: String, vm: &VirtualMachine) -> PyResult<isize> {
-            use windows_sys::Win32::Storage::FileSystem::{
-                CreateFileW, FILE_FLAG_OVERLAPPED, FILE_GENERIC_READ, FILE_GENERIC_WRITE,
-                OPEN_EXISTING,
-            };
-
-            let address_wide: Vec<u16> = address.encode_utf16().chain(std::iter::once(0)).collect();
-
-            let handle = unsafe {
-                CreateFileW(
-                    address_wide.as_ptr(),
-                    FILE_GENERIC_READ | FILE_GENERIC_WRITE,
-                    0,
-                    std::ptr::null(),
-                    OPEN_EXISTING,
-                    FILE_FLAG_OVERLAPPED,
-                    std::ptr::null_mut(),
-                )
-            };
-
-            if handle == windows_sys::Win32::Foundation::INVALID_HANDLE_VALUE {
-                return Err(vm.new_last_os_error());
-            }
-
-            Ok(handle as isize)
-        }
-
         // WSASendTo
         #[pymethod]
         fn WSASendTo(
@@ -1226,7 +1235,7 @@ mod _overlapped {
             handle: isize,
             buf: PyBuffer,
             flags: u32,
-            address: PyObjectRef,
+            address: PyTupleRef,
             vm: &VirtualMachine,
         ) -> PyResult {
             use windows_sys::Win32::Foundation::{ERROR_IO_PENDING, ERROR_SUCCESS};
@@ -1234,16 +1243,19 @@ mod _overlapped {
 
             let mut inner = zelf.inner.lock();
             if !matches!(inner.data, OverlappedData::None) {
-                return Err(vm.new_value_error("operation already attempted".to_owned()));
+                return Err(vm.new_value_error("operation already attempted"));
             }
 
             let (addr_bytes, addr_len) = parse_address(&address, vm)?;
 
             inner.handle = handle as HANDLE;
             let buf_len = buf.desc.len;
+            if buf_len > u32::MAX as usize {
+                return Err(vm.new_value_error("buffer too large"));
+            }
 
             let Some(contiguous) = buf.as_contiguous() else {
-                return Err(vm.new_buffer_error("buffer is not contiguous".to_owned()));
+                return Err(vm.new_buffer_error("buffer is not contiguous"));
             };
 
             // Store both buffer and address in OverlappedData to keep them alive
@@ -1289,7 +1301,7 @@ mod _overlapped {
                 ERROR_SUCCESS | ERROR_IO_PENDING => Ok(vm.ctx.none()),
                 _ => {
                     inner.data = OverlappedData::NotStarted;
-                    Err(from_windows_err(err, vm))
+                    Err(set_from_windows_err(err, vm))
                 }
             }
         }
@@ -1310,7 +1322,7 @@ mod _overlapped {
 
             let mut inner = zelf.inner.lock();
             if !matches!(inner.data, OverlappedData::None) {
-                return Err(vm.new_value_error("operation already attempted".to_owned()));
+                return Err(vm.new_value_error("operation already attempted"));
             }
 
             let mut flags = flags.unwrap_or(0);
@@ -1318,14 +1330,15 @@ mod _overlapped {
             #[cfg(target_pointer_width = "32")]
             let size = core::cmp::min(size, isize::MAX as u32);
 
-            let buf = vec![0u8; std::cmp::max(size, 1) as usize];
+            let buf = vec![0u8; core::cmp::max(size, 1) as usize];
             let buf = vm.ctx.new_bytes(buf);
             inner.handle = handle as HANDLE;
 
-            let address: SOCKADDR_IN6 = unsafe { std::mem::zeroed() };
-            let address_length = std::mem::size_of::<SOCKADDR_IN6>() as i32;
+            let address: SOCKADDR_IN6 = unsafe { core::mem::zeroed() };
+            let address_length = core::mem::size_of::<SOCKADDR_IN6>() as i32;
 
             inner.data = OverlappedData::ReadFrom(OverlappedReadFrom {
+                result: None,
                 allocated_buffer: buf.clone(),
                 address,
                 address_length,
@@ -1370,12 +1383,12 @@ mod _overlapped {
             match err {
                 ERROR_BROKEN_PIPE => {
                     mark_as_completed(&mut inner.overlapped);
-                    Err(from_windows_err(err, vm))
+                    Err(set_from_windows_err(err, vm))
                 }
                 ERROR_SUCCESS | ERROR_MORE_DATA | ERROR_IO_PENDING => Ok(vm.ctx.none()),
                 _ => {
                     inner.data = OverlappedData::NotStarted;
-                    Err(from_windows_err(err, vm))
+                    Err(set_from_windows_err(err, vm))
                 }
             }
         }
@@ -1397,26 +1410,26 @@ mod _overlapped {
 
             let mut inner = zelf.inner.lock();
             if !matches!(inner.data, OverlappedData::None) {
-                return Err(vm.new_value_error("operation already attempted".to_owned()));
+                return Err(vm.new_value_error("operation already attempted"));
             }
 
             let mut flags = flags.unwrap_or(0);
             inner.handle = handle as HANDLE;
 
             let Some(contiguous) = buf.as_contiguous_mut() else {
-                return Err(vm.new_buffer_error("buffer is not contiguous".to_owned()));
+                return Err(vm.new_buffer_error("buffer is not contiguous"));
             };
 
-            // Validate size against buffer length to prevent buffer overflow
-            let buf_len = buf.desc.len as u32;
-            if size > buf_len {
-                return Err(vm.new_value_error("size exceeds buffer length".to_owned()));
+            let buf_len = buf.desc.len;
+            if buf_len > u32::MAX as usize {
+                return Err(vm.new_value_error("buffer too large"));
             }
 
-            let address: SOCKADDR_IN6 = unsafe { std::mem::zeroed() };
-            let address_length = std::mem::size_of::<SOCKADDR_IN6>() as i32;
+            let address: SOCKADDR_IN6 = unsafe { core::mem::zeroed() };
+            let address_length = core::mem::size_of::<SOCKADDR_IN6>() as i32;
 
             inner.data = OverlappedData::ReadFromInto(OverlappedReadFromInto {
+                result: None,
                 user_buffer: buf.clone(),
                 address,
                 address_length,
@@ -1461,12 +1474,12 @@ mod _overlapped {
             match err {
                 ERROR_BROKEN_PIPE => {
                     mark_as_completed(&mut inner.overlapped);
-                    Err(from_windows_err(err, vm))
+                    Err(set_from_windows_err(err, vm))
                 }
                 ERROR_SUCCESS | ERROR_MORE_DATA | ERROR_IO_PENDING => Ok(vm.ctx.none()),
                 _ => {
                     inner.data = OverlappedData::NotStarted;
-                    Err(from_windows_err(err, vm))
+                    Err(set_from_windows_err(err, vm))
                 }
             }
         }
@@ -1480,7 +1493,7 @@ mod _overlapped {
 
             if event == INVALID_HANDLE_VALUE {
                 event = unsafe {
-                    windows_sys::Win32::System::Threading::CreateEventA(
+                    windows_sys::Win32::System::Threading::CreateEventW(
                         core::ptr::null(),
                         Foundation::TRUE,
                         Foundation::FALSE,
@@ -1488,11 +1501,11 @@ mod _overlapped {
                     ) as isize
                 };
                 if event == NULL {
-                    return Err(vm.new_last_os_error());
+                    return Err(set_from_windows_err(0, vm));
                 }
             }
 
-            let mut overlapped: OVERLAPPED = unsafe { std::mem::zeroed() };
+            let mut overlapped: OVERLAPPED = unsafe { core::mem::zeroed() };
             if event != NULL {
                 overlapped.hEvent = event as HANDLE;
             }
@@ -1508,6 +1521,97 @@ mod _overlapped {
         }
     }
 
+    impl Destructor for Overlapped {
+        fn del(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<()> {
+            use windows_sys::Win32::Foundation::{
+                ERROR_NOT_FOUND, ERROR_OPERATION_ABORTED, ERROR_SUCCESS,
+            };
+            use windows_sys::Win32::System::IO::{CancelIoEx, GetOverlappedResult};
+
+            let mut inner = zelf.inner.lock();
+            let olderr = unsafe { GetLastError() };
+
+            // Cancel pending I/O and wait for completion
+            if !HasOverlappedIoCompleted(&inner.overlapped)
+                && !matches!(inner.data, OverlappedData::NotStarted)
+            {
+                let cancelled = unsafe { CancelIoEx(inner.handle, &inner.overlapped) } != 0;
+                let mut transferred: u32 = 0;
+                let ret = unsafe {
+                    GetOverlappedResult(
+                        inner.handle,
+                        &inner.overlapped,
+                        &mut transferred,
+                        if cancelled { 1 } else { 0 },
+                    )
+                };
+
+                let err = if ret != 0 {
+                    ERROR_SUCCESS
+                } else {
+                    unsafe { GetLastError() }
+                };
+                match err {
+                    ERROR_SUCCESS | ERROR_NOT_FOUND | ERROR_OPERATION_ABORTED => {}
+                    _ => {
+                        let msg = format!(
+                            "{:?} still has pending operation at deallocation, the process may crash",
+                            zelf
+                        );
+                        let exc = vm.new_runtime_error(msg);
+                        let err_msg = Some(format!(
+                            "Exception ignored while deallocating overlapped operation {:?}",
+                            zelf
+                        ));
+                        let obj: PyObjectRef = zelf.to_owned().into();
+                        vm.run_unraisable(exc, err_msg, obj);
+                    }
+                }
+            }
+
+            // Close the event handle
+            if !inner.overlapped.hEvent.is_null() {
+                unsafe {
+                    Foundation::CloseHandle(inner.overlapped.hEvent);
+                }
+                inner.overlapped.hEvent = core::ptr::null_mut();
+            }
+
+            // Restore last error
+            unsafe { Foundation::SetLastError(olderr) };
+
+            Ok(())
+        }
+    }
+
+    #[pyfunction]
+    fn ConnectPipe(address: String, vm: &VirtualMachine) -> PyResult<isize> {
+        use windows_sys::Win32::Foundation::{GENERIC_READ, GENERIC_WRITE};
+        use windows_sys::Win32::Storage::FileSystem::{
+            CreateFileW, FILE_FLAG_OVERLAPPED, OPEN_EXISTING,
+        };
+
+        let address_wide: Vec<u16> = address.encode_utf16().chain(core::iter::once(0)).collect();
+
+        let handle = unsafe {
+            CreateFileW(
+                address_wide.as_ptr(),
+                GENERIC_READ | GENERIC_WRITE,
+                0,
+                core::ptr::null(),
+                OPEN_EXISTING,
+                FILE_FLAG_OVERLAPPED,
+                core::ptr::null_mut(),
+            )
+        };
+
+        if handle == windows_sys::Win32::Foundation::INVALID_HANDLE_VALUE {
+            return Err(set_from_windows_err(0, vm));
+        }
+
+        Ok(handle as isize)
+    }
+
     #[pyfunction]
     fn CreateIoCompletionPort(
         handle: isize,
@@ -1525,7 +1629,7 @@ mod _overlapped {
             ) as isize
         };
         if r == 0 {
-            return Err(vm.new_last_os_error());
+            return Err(set_from_windows_err(0, vm));
         }
         Ok(r)
     }
@@ -1534,7 +1638,7 @@ mod _overlapped {
     fn GetQueuedCompletionStatus(port: isize, msecs: u32, vm: &VirtualMachine) -> PyResult {
         let mut bytes_transferred = 0;
         let mut completion_key = 0;
-        let mut overlapped: *mut OVERLAPPED = std::ptr::null_mut();
+        let mut overlapped: *mut OVERLAPPED = core::ptr::null_mut();
         let ret = unsafe {
             windows_sys::Win32::System::IO::GetQueuedCompletionStatus(
                 port as HANDLE,
@@ -1553,7 +1657,7 @@ mod _overlapped {
             if err == Foundation::WAIT_TIMEOUT {
                 return Ok(vm.ctx.none());
             } else {
-                return Err(vm.new_last_os_error());
+                return Err(set_from_windows_err(err, vm));
             }
         }
 
@@ -1583,7 +1687,7 @@ mod _overlapped {
             )
         };
         if ret == 0 {
-            return Err(vm.new_last_os_error());
+            return Err(set_from_windows_err(0, vm));
         }
         Ok(())
     }
@@ -1592,12 +1696,12 @@ mod _overlapped {
     // Uses Arc for reference counting to prevent use-after-free when callback
     // and UnregisterWait race - the data stays alive until both are done
     static WAIT_CALLBACK_REGISTRY: std::sync::OnceLock<
-        std::sync::Mutex<std::collections::HashMap<isize, std::sync::Arc<PostCallbackData>>>,
+        std::sync::Mutex<std::collections::HashMap<isize, alloc::sync::Arc<PostCallbackData>>>,
     > = std::sync::OnceLock::new();
 
-    fn wait_callback_registry()
-    -> &'static std::sync::Mutex<std::collections::HashMap<isize, std::sync::Arc<PostCallbackData>>>
-    {
+    fn wait_callback_registry() -> &'static std::sync::Mutex<
+        std::collections::HashMap<isize, alloc::sync::Arc<PostCallbackData>>,
+    > {
         WAIT_CALLBACK_REGISTRY
             .get_or_init(|| std::sync::Mutex::new(std::collections::HashMap::new()))
     }
@@ -1620,7 +1724,7 @@ mod _overlapped {
     ) {
         // Reconstruct Arc from raw pointer - this gives us ownership of one reference
         // The Arc prevents use-after-free since we own a reference count
-        let data = unsafe { std::sync::Arc::from_raw(parameter as *const PostCallbackData) };
+        let data = unsafe { alloc::sync::Arc::from_raw(parameter as *const PostCallbackData) };
 
         unsafe {
             let _ = windows_sys::Win32::System::IO::PostQueuedCompletionStatus(
@@ -1646,15 +1750,15 @@ mod _overlapped {
             RegisterWaitForSingleObject, WT_EXECUTEINWAITTHREAD, WT_EXECUTEONLYONCE,
         };
 
-        let data = std::sync::Arc::new(PostCallbackData {
+        let data = alloc::sync::Arc::new(PostCallbackData {
             completion_port: completion_port as HANDLE,
             overlapped: overlapped as *mut OVERLAPPED,
         });
 
         // Create raw pointer for the callback - this increments refcount
-        let data_ptr = std::sync::Arc::into_raw(data.clone());
+        let data_ptr = alloc::sync::Arc::into_raw(data.clone());
 
-        let mut new_wait_object: HANDLE = std::ptr::null_mut();
+        let mut new_wait_object: HANDLE = core::ptr::null_mut();
         let ret = unsafe {
             RegisterWaitForSingleObject(
                 &mut new_wait_object,
@@ -1669,9 +1773,9 @@ mod _overlapped {
         if ret == 0 {
             // Registration failed - reconstruct Arc to drop the extra reference
             unsafe {
-                let _ = std::sync::Arc::from_raw(data_ptr);
+                let _ = alloc::sync::Arc::from_raw(data_ptr);
             }
-            return Err(vm.new_last_os_error());
+            return Err(set_from_windows_err(0, vm));
         }
 
         // Store in registry for cleanup tracking
@@ -1703,7 +1807,7 @@ mod _overlapped {
         // (callback may have already fired, or may never fire)
         cleanup_wait_callback_data(wait_handle);
         if ret == 0 {
-            return Err(vm.new_last_os_error());
+            return Err(set_from_windows_err(0, vm));
         }
         Ok(())
     }
@@ -1716,17 +1820,19 @@ mod _overlapped {
         // Cleanup callback data regardless of UnregisterWaitEx result
         cleanup_wait_callback_data(wait_handle);
         if ret == 0 {
-            return Err(vm.new_last_os_error());
+            return Err(set_from_windows_err(0, vm));
         }
         Ok(())
     }
 
     #[pyfunction]
     fn BindLocal(socket: isize, family: i32, vm: &VirtualMachine) -> PyResult<()> {
-        use windows_sys::Win32::Networking::WinSock::{INADDR_ANY, SOCKET_ERROR, bind};
+        use windows_sys::Win32::Networking::WinSock::{
+            INADDR_ANY, SOCKET_ERROR, WSAGetLastError, bind,
+        };
 
         let ret = if family == AF_INET as i32 {
-            let mut addr: SOCKADDR_IN = unsafe { std::mem::zeroed() };
+            let mut addr: SOCKADDR_IN = unsafe { core::mem::zeroed() };
             addr.sin_family = AF_INET;
             addr.sin_port = 0;
             addr.sin_addr.S_un.S_addr = INADDR_ANY;
@@ -1734,27 +1840,28 @@ mod _overlapped {
                 bind(
                     socket as _,
                     &addr as *const _ as *const SOCKADDR,
-                    std::mem::size_of::<SOCKADDR_IN>() as i32,
+                    core::mem::size_of::<SOCKADDR_IN>() as i32,
                 )
             }
         } else if family == AF_INET6 as i32 {
             // in6addr_any is all zeros, which we have from zeroed()
-            let mut addr: SOCKADDR_IN6 = unsafe { std::mem::zeroed() };
+            let mut addr: SOCKADDR_IN6 = unsafe { core::mem::zeroed() };
             addr.sin6_family = AF_INET6;
             addr.sin6_port = 0;
             unsafe {
                 bind(
                     socket as _,
                     &addr as *const _ as *const SOCKADDR,
-                    std::mem::size_of::<SOCKADDR_IN6>() as i32,
+                    core::mem::size_of::<SOCKADDR_IN6>() as i32,
                 )
             }
         } else {
-            return Err(vm.new_value_error("family must be AF_INET or AF_INET6".to_owned()));
+            return Err(vm.new_value_error("expected tuple of length 2 or 4"));
         };
 
         if ret == SOCKET_ERROR {
-            return Err(vm.new_last_os_error());
+            let err = unsafe { WSAGetLastError() } as u32;
+            return Err(set_from_windows_err(err, vm));
         }
         Ok(())
     }
@@ -1771,28 +1878,31 @@ mod _overlapped {
         const LANG_NEUTRAL: u32 = 0;
         const SUBLANG_DEFAULT: u32 = 1;
 
-        let mut buffer: *mut u16 = std::ptr::null_mut();
+        let mut buffer: *mut u16 = core::ptr::null_mut();
 
         let len = unsafe {
             FormatMessageW(
                 FORMAT_MESSAGE_ALLOCATE_BUFFER
                     | FORMAT_MESSAGE_FROM_SYSTEM
                     | FORMAT_MESSAGE_IGNORE_INSERTS,
-                std::ptr::null(),
+                core::ptr::null(),
                 error_code,
                 (SUBLANG_DEFAULT << 10) | LANG_NEUTRAL,
                 &mut buffer as *mut _ as *mut u16,
                 0,
-                std::ptr::null(),
+                core::ptr::null(),
             )
         };
 
         if len == 0 || buffer.is_null() {
+            if !buffer.is_null() {
+                unsafe { LocalFree(buffer as *mut _) };
+            }
             return Ok(format!("unknown error code {}", error_code));
         }
 
         // Convert to Rust string, trimming trailing whitespace
-        let slice = unsafe { std::slice::from_raw_parts(buffer, len as usize) };
+        let slice = unsafe { core::slice::from_raw_parts(buffer, len as usize) };
         let msg = String::from_utf16_lossy(slice).trim_end().to_string();
 
         unsafe { LocalFree(buffer as *mut _) };
@@ -1801,8 +1911,8 @@ mod _overlapped {
     }
 
     #[pyfunction]
-    fn WSAConnect(socket: isize, address: PyObjectRef, vm: &VirtualMachine) -> PyResult<()> {
-        use windows_sys::Win32::Networking::WinSock::{SOCKET_ERROR, WSAConnect};
+    fn WSAConnect(socket: isize, address: PyTupleRef, vm: &VirtualMachine) -> PyResult<()> {
+        use windows_sys::Win32::Networking::WinSock::{SOCKET_ERROR, WSAConnect, WSAGetLastError};
 
         let (addr_bytes, addr_len) = parse_address(&address, vm)?;
 
@@ -1811,15 +1921,16 @@ mod _overlapped {
                 socket as _,
                 addr_bytes.as_ptr() as *const SOCKADDR,
                 addr_len,
-                std::ptr::null(),
-                std::ptr::null_mut(),
-                std::ptr::null(),
-                std::ptr::null(),
+                core::ptr::null(),
+                core::ptr::null_mut(),
+                core::ptr::null(),
+                core::ptr::null(),
             )
         };
 
         if ret == SOCKET_ERROR {
-            return Err(vm.new_last_os_error());
+            let err = unsafe { WSAGetLastError() } as u32;
+            return Err(set_from_windows_err(err, vm));
         }
         Ok(())
     }
@@ -1833,26 +1944,26 @@ mod _overlapped {
         vm: &VirtualMachine,
     ) -> PyResult<isize> {
         if !vm.is_none(&event_attributes) {
-            return Err(vm.new_value_error("EventAttributes must be None".to_owned()));
+            return Err(vm.new_value_error("EventAttributes must be None"));
         }
 
         let name_wide: Option<Vec<u16>> =
-            name.map(|n| n.encode_utf16().chain(std::iter::once(0)).collect());
+            name.map(|n| n.encode_utf16().chain(core::iter::once(0)).collect());
         let name_ptr = name_wide
             .as_ref()
             .map(|n| n.as_ptr())
-            .unwrap_or(std::ptr::null());
+            .unwrap_or(core::ptr::null());
 
         let event = unsafe {
             windows_sys::Win32::System::Threading::CreateEventW(
-                std::ptr::null(),
+                core::ptr::null(),
                 if manual_reset { 1 } else { 0 },
                 if initial_state { 1 } else { 0 },
                 name_ptr,
             ) as isize
         };
         if event == NULL {
-            return Err(vm.new_last_os_error());
+            return Err(set_from_windows_err(0, vm));
         }
         Ok(event)
     }
@@ -1861,7 +1972,7 @@ mod _overlapped {
     fn SetEvent(handle: isize, vm: &VirtualMachine) -> PyResult<()> {
         let ret = unsafe { windows_sys::Win32::System::Threading::SetEvent(handle as HANDLE) };
         if ret == 0 {
-            return Err(vm.new_last_os_error());
+            return Err(set_from_windows_err(0, vm));
         }
         Ok(())
     }
@@ -1870,7 +1981,7 @@ mod _overlapped {
     fn ResetEvent(handle: isize, vm: &VirtualMachine) -> PyResult<()> {
         let ret = unsafe { windows_sys::Win32::System::Threading::ResetEvent(handle as HANDLE) };
         if ret == 0 {
-            return Err(vm.new_last_os_error());
+            return Err(set_from_windows_err(0, vm));
         }
         Ok(())
     }
diff --git a/crates/stdlib/src/posixshmem.rs b/crates/stdlib/src/posixshmem.rs
index 2a142d8b6f3..f5481619bba 100644
--- a/crates/stdlib/src/posixshmem.rs
+++ b/crates/stdlib/src/posixshmem.rs
@@ -8,13 +8,15 @@ mod _posixshmem {
 
     use crate::{
         common::os::errno_io_error,
-        vm::{FromArgs, PyResult, VirtualMachine, builtins::PyStrRef, convert::IntoPyException},
+        vm::{
+            FromArgs, PyResult, VirtualMachine, builtins::PyUtf8StrRef, convert::IntoPyException,
+        },
     };
 
     #[derive(FromArgs)]
     struct ShmOpenArgs {
         #[pyarg(any)]
-        name: PyStrRef,
+        name: PyUtf8StrRef,
         #[pyarg(any)]
         flags: libc::c_int,
         #[pyarg(any, default = 0o600)]
@@ -37,7 +39,7 @@ mod _posixshmem {
     }
 
     #[pyfunction]
-    fn shm_unlink(name: PyStrRef, vm: &VirtualMachine) -> PyResult<()> {
+    fn shm_unlink(name: PyUtf8StrRef, 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()) };
diff --git a/crates/stdlib/src/posixsubprocess.rs b/crates/stdlib/src/posixsubprocess.rs
index 3d5e4c356d9..fec2ceb16d5 100644
--- a/crates/stdlib/src/posixsubprocess.rs
+++ b/crates/stdlib/src/posixsubprocess.rs
@@ -38,7 +38,7 @@ mod _posixsubprocess {
             && vm
                 .state
                 .finalizing
-                .load(std::sync::atomic::Ordering::Acquire)
+                .load(core::sync::atomic::Ordering::Acquire)
         {
             return Err(vm.new_python_finalization_error(
                 "preexec_fn not supported at interpreter shutdown".to_owned(),
@@ -226,7 +226,6 @@ gen_args! {
     uid: Option<Uid>,
     child_umask: i32,
     preexec_fn: Option<PyObjectRef>,
-    _use_vfork: bool,
 }
 
 // can't reallocate inside of exec(), so we reallocate prior to fork() and pass this along
diff --git a/crates/stdlib/src/pyexpat.rs b/crates/stdlib/src/pyexpat.rs
index 7d603c72ed5..40418f54c30 100644
--- a/crates/stdlib/src/pyexpat.rs
+++ b/crates/stdlib/src/pyexpat.rs
@@ -41,7 +41,7 @@ macro_rules! create_bool_property {
 mod _pyexpat {
     use crate::vm::{
         Context, Py, PyObjectRef, PyPayload, PyRef, PyResult, TryFromObject, VirtualMachine,
-        builtins::{PyBytesRef, PyException, PyModule, PyStr, PyStrRef, PyType},
+        builtins::{PyBytesRef, PyException, PyModule, PyStr, PyStrRef, PyType, PyUtf8StrRef},
         extend_module,
         function::{ArgBytesLike, Either, IntoFuncArgs, OptionalArg},
         types::Constructor,
@@ -390,7 +390,7 @@ mod _pyexpat {
         #[pyarg(any, optional)]
         encoding: Option<PyStrRef>,
         #[pyarg(any, optional)]
-        namespace_separator: Option<PyStrRef>,
+        namespace_separator: Option<PyUtf8StrRef>,
         #[pyarg(any, optional)]
         intern: Option<PyObjectRef>,
     }
@@ -403,11 +403,9 @@ mod _pyexpat {
         // 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 {
+                if s.as_str().chars().count() > 1 {
                     return Err(vm.new_value_error(
-                        "namespace_separator must be at most one character, omitted, or None"
-                            .to_owned(),
+                        "namespace_separator must be at most one character, omitted, or None",
                     ));
                 }
                 Some(s.as_str().to_owned())
diff --git a/crates/stdlib/src/pystruct.rs b/crates/stdlib/src/pystruct.rs
index d3be417edb3..9c5d67f396c 100644
--- a/crates/stdlib/src/pystruct.rs
+++ b/crates/stdlib/src/pystruct.rs
@@ -19,6 +19,7 @@ pub(crate) mod _struct {
         types::{Constructor, IterNext, Iterable, Representable, SelfIter},
     };
     use crossbeam_utils::atomic::AtomicCell;
+    use rustpython_common::wtf8::{Wtf8Buf, wtf8_concat};
 
     #[derive(Traverse)]
     struct IntoStructFormatBytes(PyStrRef);
@@ -305,8 +306,8 @@ pub(crate) mod _struct {
 
     impl Representable for PyStruct {
         #[inline]
-        fn repr_str(zelf: &Py<Self>, _vm: &VirtualMachine) -> PyResult<String> {
-            Ok(format!("Struct('{}')", zelf.format.as_str()))
+        fn repr_wtf8(zelf: &Py<Self>, _vm: &VirtualMachine) -> PyResult<Wtf8Buf> {
+            Ok(wtf8_concat!("Struct('", zelf.format.as_wtf8(), "')"))
         }
     }
 
diff --git a/crates/stdlib/src/random.rs b/crates/stdlib/src/random.rs
index 35e6473d8f6..52d45f16b2b 100644
--- a/crates/stdlib/src/random.rs
+++ b/crates/stdlib/src/random.rs
@@ -67,9 +67,16 @@ mod _random {
         }
 
         #[pymethod]
-        fn getrandbits(&self, k: isize, vm: &VirtualMachine) -> PyResult<BigInt> {
+        fn getrandbits(&self, k: PyObjectRef, vm: &VirtualMachine) -> PyResult<BigInt> {
+            let k_int = k.try_index(vm)?;
+            let k_bigint = k_int.as_bigint();
+            if k_bigint.is_negative() {
+                return Err(vm.new_value_error("number of bits must be non-negative"));
+            }
+            let k: isize = k_int
+                .try_to_primitive(vm)
+                .map_err(|_| vm.new_overflow_error("getrandbits: number of bits too large"))?;
             match k {
-                ..0 => Err(vm.new_value_error("number of bits must be non-negative")),
                 0 => Ok(BigInt::zero()),
                 mut k => {
                     let mut rng = self.rng.lock();
diff --git a/crates/stdlib/src/re.rs b/crates/stdlib/src/re.rs
index fdb14d427fc..c72039f10c5 100644
--- a/crates/stdlib/src/re.rs
+++ b/crates/stdlib/src/re.rs
@@ -317,7 +317,7 @@ mod re {
     #[pyfunction]
     fn purge(_vm: &VirtualMachine) {}
 
-    #[pyclass]
+    #[pyclass(flags(HAS_WEAKREF))]
     impl PyPattern {
         #[pymethod(name = "match")]
         fn match_(&self, text: PyStrRef) -> Option<PyMatch> {
diff --git a/crates/stdlib/src/select.rs b/crates/stdlib/src/select.rs
index 09a85cf1c00..b52144247f7 100644
--- a/crates/stdlib/src/select.rs
+++ b/crates/stdlib/src/select.rs
@@ -61,7 +61,7 @@ mod platform {
 #[cfg(target_os = "wasi")]
 mod platform {
     pub use libc::{FD_SETSIZE, timeval};
-    pub use std::os::wasi::io::RawFd;
+    pub use std::os::fd::RawFd;
 
     pub fn check_err(x: i32) -> bool {
         x < 0
@@ -223,7 +223,7 @@ mod decl {
         #[cfg(unix)]
         {
             use crate::vm::class::PyClassImpl;
-            poll::PyPoll::make_class(&vm.ctx);
+            poll::PyPoll::make_static_type();
         }
 
         __module_exec(vm, module);
@@ -280,7 +280,7 @@ mod decl {
 
         loop {
             let mut tv = timeout.map(sec_to_timeval);
-            let res = super::select(nfds, &mut r, &mut w, &mut x, tv.as_mut());
+            let res = vm.allow_threads(|| super::select(nfds, &mut r, &mut w, &mut x, tv.as_mut()));
 
             match res {
                 Ok(_) => break,
@@ -337,7 +337,7 @@ mod decl {
             common::lock::PyMutex,
             convert::{IntoPyException, ToPyObject},
             function::OptionalArg,
-            stdlib::io::Fildes,
+            stdlib::_io::Fildes,
         };
         use core::{convert::TryFrom, time::Duration};
         use libc::pollfd;
@@ -502,7 +502,9 @@ mod decl {
                 let deadline = timeout.map(|d| Instant::now() + d);
                 let mut poll_timeout = timeout_ms;
                 loop {
-                    let res = unsafe { libc::poll(fds.as_mut_ptr(), fds.len() as _, poll_timeout) };
+                    let res = vm.allow_threads(|| unsafe {
+                        libc::poll(fds.as_mut_ptr(), fds.len() as _, poll_timeout)
+                    });
                     match nix::Error::result(res) {
                         Ok(_) => break,
                         Err(nix::Error::EINTR) => vm.check_signals()?,
@@ -527,9 +529,9 @@ mod decl {
 
     #[cfg(any(target_os = "linux", target_os = "android", target_os = "redox"))]
     #[pyattr(name = "epoll", once)]
-    fn epoll(vm: &VirtualMachine) -> PyTypeRef {
+    fn epoll(_vm: &VirtualMachine) -> PyTypeRef {
         use crate::vm::class::PyClassImpl;
-        epoll::PyEpoll::make_class(&vm.ctx)
+        epoll::PyEpoll::make_static_type()
     }
 
     #[cfg(any(target_os = "linux", target_os = "android", target_os = "redox"))]
@@ -552,7 +554,7 @@ mod decl {
             common::lock::{PyRwLock, PyRwLockReadGuard},
             convert::{IntoPyException, ToPyObject},
             function::OptionalArg,
-            stdlib::io::Fildes,
+            stdlib::_io::Fildes,
             types::Constructor,
         };
         use core::ops::Deref;
@@ -695,11 +697,13 @@ mod decl {
 
                 loop {
                     events.clear();
-                    match epoll::wait(
-                        epoll,
-                        rustix::buffer::spare_capacity(&mut events),
-                        poll_timeout.as_ref(),
-                    ) {
+                    match vm.allow_threads(|| {
+                        epoll::wait(
+                            epoll,
+                            rustix::buffer::spare_capacity(&mut events),
+                            poll_timeout.as_ref(),
+                        )
+                    }) {
                         Ok(_) => break,
                         Err(rustix::io::Errno::INTR) => vm.check_signals()?,
                         Err(e) => return Err(e.into_pyexception(vm)),
diff --git a/crates/stdlib/src/sha1.rs b/crates/stdlib/src/sha1.rs
index 28d4bcbbee1..3e3d4928c79 100644
--- a/crates/stdlib/src/sha1.rs
+++ b/crates/stdlib/src/sha1.rs
@@ -7,6 +7,6 @@ mod _sha1 {
 
     #[pyfunction]
     fn sha1(args: HashArgs, vm: &VirtualMachine) -> PyResult {
-        Ok(local_sha1(args).into_pyobject(vm))
+        Ok(local_sha1(args, vm)?.into_pyobject(vm))
     }
 }
diff --git a/crates/stdlib/src/sha256.rs b/crates/stdlib/src/sha256.rs
index bf4a39373ea..b4c26dc0dd6 100644
--- a/crates/stdlib/src/sha256.rs
+++ b/crates/stdlib/src/sha256.rs
@@ -5,12 +5,12 @@ mod _sha256 {
 
     #[pyfunction]
     fn sha224(args: HashArgs, vm: &VirtualMachine) -> PyResult {
-        Ok(local_sha224(args).into_pyobject(vm))
+        Ok(local_sha224(args, vm)?.into_pyobject(vm))
     }
 
     #[pyfunction]
     fn sha256(args: HashArgs, vm: &VirtualMachine) -> PyResult {
-        Ok(local_sha256(args).into_pyobject(vm))
+        Ok(local_sha256(args, vm)?.into_pyobject(vm))
     }
 
     pub(crate) fn module_exec(vm: &VirtualMachine, module: &Py<PyModule>) -> PyResult<()> {
diff --git a/crates/stdlib/src/sha3.rs b/crates/stdlib/src/sha3.rs
index e7342d0dd69..0eb2dfa84d5 100644
--- a/crates/stdlib/src/sha3.rs
+++ b/crates/stdlib/src/sha3.rs
@@ -10,31 +10,31 @@ mod _sha3 {
 
     #[pyfunction]
     fn sha3_224(args: HashArgs, vm: &VirtualMachine) -> PyResult {
-        Ok(local_sha3_224(args).into_pyobject(vm))
+        Ok(local_sha3_224(args, vm)?.into_pyobject(vm))
     }
 
     #[pyfunction]
     fn sha3_256(args: HashArgs, vm: &VirtualMachine) -> PyResult {
-        Ok(local_sha3_256(args).into_pyobject(vm))
+        Ok(local_sha3_256(args, vm)?.into_pyobject(vm))
     }
 
     #[pyfunction]
     fn sha3_384(args: HashArgs, vm: &VirtualMachine) -> PyResult {
-        Ok(local_sha3_384(args).into_pyobject(vm))
+        Ok(local_sha3_384(args, vm)?.into_pyobject(vm))
     }
 
     #[pyfunction]
     fn sha3_512(args: HashArgs, vm: &VirtualMachine) -> PyResult {
-        Ok(local_sha3_512(args).into_pyobject(vm))
+        Ok(local_sha3_512(args, vm)?.into_pyobject(vm))
     }
 
     #[pyfunction]
     fn shake_128(args: HashArgs, vm: &VirtualMachine) -> PyResult {
-        Ok(local_shake_128(args).into_pyobject(vm))
+        Ok(local_shake_128(args, vm)?.into_pyobject(vm))
     }
 
     #[pyfunction]
     fn shake_256(args: HashArgs, vm: &VirtualMachine) -> PyResult {
-        Ok(local_shake_256(args).into_pyobject(vm))
+        Ok(local_shake_256(args, vm)?.into_pyobject(vm))
     }
 }
diff --git a/crates/stdlib/src/sha512.rs b/crates/stdlib/src/sha512.rs
index 303c0067daa..b7c6f02ed66 100644
--- a/crates/stdlib/src/sha512.rs
+++ b/crates/stdlib/src/sha512.rs
@@ -5,12 +5,12 @@ mod _sha512 {
 
     #[pyfunction]
     fn sha384(args: HashArgs, vm: &VirtualMachine) -> PyResult {
-        Ok(local_sha384(args).into_pyobject(vm))
+        Ok(local_sha384(args, vm)?.into_pyobject(vm))
     }
 
     #[pyfunction]
     fn sha512(args: HashArgs, vm: &VirtualMachine) -> PyResult {
-        Ok(local_sha512(args).into_pyobject(vm))
+        Ok(local_sha512(args, vm)?.into_pyobject(vm))
     }
 
     pub(crate) fn module_exec(vm: &VirtualMachine, module: &Py<PyModule>) -> PyResult<()> {
diff --git a/crates/stdlib/src/socket.rs b/crates/stdlib/src/socket.rs
index 6b33fe52e37..d3fe59144ef 100644
--- a/crates/stdlib/src/socket.rs
+++ b/crates/stdlib/src/socket.rs
@@ -12,14 +12,15 @@ mod _socket {
         AsObject, Py, PyObjectRef, PyPayload, PyRef, PyResult, VirtualMachine,
         builtins::{
             PyBaseExceptionRef, PyListRef, PyModule, PyOSError, PyStrRef, PyTupleRef, PyTypeRef,
+            PyUtf8StrRef,
         },
         common::os::ErrorExt,
         convert::{IntoPyException, ToPyObject, TryFromBorrowedObject, TryFromObject},
         function::{
-            ArgBytesLike, ArgMemoryBuffer, ArgStrOrBytesLike, Either, FsPath, OptionalArg,
-            OptionalOption,
+            ArgBytesLike, ArgIntoFloat, ArgMemoryBuffer, ArgStrOrBytesLike, Either, FsPath,
+            OptionalArg, OptionalOption,
         },
-        types::{Constructor, DefaultConstructor, Initializer, Representable},
+        types::{Constructor, DefaultConstructor, Destructor, Initializer, Representable},
         utils::ToCString,
     };
 
@@ -1104,7 +1105,8 @@ mod _socket {
             loop {
                 if deadline.is_some() || matches!(select, SelectKind::Connect) {
                     let interval = deadline.as_ref().map(|d| d.time_until()).transpose()?;
-                    let res = sock_select(&*self.sock()?, select, interval);
+                    let sock = self.sock()?;
+                    let res = vm.allow_threads(|| sock_select(&sock, select, interval));
                     match res {
                         Ok(true) => return Err(IoOrPyException::Timeout),
                         Err(e) if e.kind() == io::ErrorKind::Interrupted => {
@@ -1117,8 +1119,9 @@ mod _socket {
                 }
 
                 let err = loop {
-                    // loop on interrupt
-                    match f() {
+                    // Detach thread state around the blocking syscall so
+                    // stop-the-world can park this thread (e.g. before fork).
+                    match vm.allow_threads(&mut f) {
                         Ok(x) => return Ok(x),
                         Err(e) if e.kind() == io::ErrorKind::Interrupted => vm.check_signals()?,
                         Err(e) => break e,
@@ -1224,6 +1227,7 @@ mod _socket {
                             obj.class().name()
                         ))
                     })?;
+                    let interface = interface.try_into_utf8(vm).map_err(IoOrPyException::from)?;
                     let ifname = interface.as_str();
 
                     // Get interface index
@@ -1253,11 +1257,12 @@ mod _socket {
                         (*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) };
+                    let storage: socket2::SockAddrStorage =
+                        unsafe { core::mem::transmute(storage) };
                     Ok(unsafe {
                         socket2::SockAddr::new(
                             storage,
-                            std::mem::size_of::<libc::sockaddr_can>() as libc::socklen_t,
+                            core::mem::size_of::<libc::sockaddr_can>() as libc::socklen_t,
                         )
                     })
                 }
@@ -1290,15 +1295,17 @@ mod _socket {
                         ))
                     })?;
 
+                    let alg_type = alg_type.try_into_utf8(vm).map_err(IoOrPyException::from)?;
+                    let alg_name = alg_name.try_into_utf8(vm).map_err(IoOrPyException::from)?;
                     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());
+                        return Err(vm.new_value_error("type too long").into());
                     }
                     if name_str.len() >= 64 {
-                        return Err(vm.new_value_error("name too long".to_owned()).into());
+                        return Err(vm.new_value_error("name too long").into());
                     }
 
                     // Create sockaddr_alg
@@ -1316,11 +1323,12 @@ mod _socket {
                             (*alg_addr).salg_name[i] = b;
                         }
                     }
-                    let storage: socket2::SockAddrStorage = unsafe { std::mem::transmute(storage) };
+                    let storage: socket2::SockAddrStorage =
+                        unsafe { core::mem::transmute(storage) };
                     Ok(unsafe {
                         socket2::SockAddr::new(
                             storage,
-                            std::mem::size_of::<libc::sockaddr_alg>() as libc::socklen_t,
+                            core::mem::size_of::<libc::sockaddr_alg>() as libc::socklen_t,
                         )
                     })
                 }
@@ -1336,7 +1344,8 @@ mod _socket {
         ) -> Result<(), IoOrPyException> {
             let sock_addr = self.extract_address(address, caller, vm)?;
 
-            let err = match self.sock()?.connect(&sock_addr) {
+            let sock = self.sock()?;
+            let err = match vm.allow_threads(|| sock.connect(&sock_addr)) {
                 Ok(()) => return Ok(()),
                 Err(e) => e,
             };
@@ -1375,13 +1384,20 @@ mod _socket {
 
     impl DefaultConstructor for PySocket {}
 
+    #[derive(FromArgs)]
+    pub struct SocketInitArgs {
+        #[pyarg(any, optional)]
+        family: OptionalArg<i32>,
+        #[pyarg(any, optional)]
+        r#type: OptionalArg<i32>,
+        #[pyarg(any, optional)]
+        proto: OptionalArg<i32>,
+        #[pyarg(any, optional)]
+        fileno: OptionalOption<PyObjectRef>,
+    }
+
     impl Initializer for PySocket {
-        type Args = (
-            OptionalArg<i32>,
-            OptionalArg<i32>,
-            OptionalArg<i32>,
-            OptionalOption<PyObjectRef>,
-        );
+        type Args = SocketInitArgs;
 
         fn init(zelf: PyRef<Self>, args: Self::Args, vm: &VirtualMachine) -> PyResult<()> {
             Self::_init(zelf, args, vm).map_err(|e| e.into_pyexception(vm))
@@ -1401,17 +1417,55 @@ mod _socket {
         }
     }
 
-    #[pyclass(with(Constructor, Initializer, Representable), flags(BASETYPE))]
+    impl Destructor for PySocket {
+        fn del(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<()> {
+            // Emit ResourceWarning if socket is still open
+            if zelf.sock.read().is_some() {
+                let laddr = if let Ok(sock) = zelf.sock()
+                    && let Ok(addr) = sock.local_addr()
+                    && let Ok(repr) = get_addr_tuple(&addr, vm).repr(vm)
+                {
+                    format!(", laddr={}", repr.as_wtf8())
+                } else {
+                    String::new()
+                };
+
+                let msg = format!(
+                    "unclosed <socket.socket fd={}, family={}, type={}, proto={}{}>",
+                    zelf.fileno(),
+                    zelf.family.load(),
+                    zelf.kind.load(),
+                    zelf.proto.load(),
+                    laddr
+                );
+                let _ = crate::vm::warn::warn(
+                    vm.ctx.new_str(msg).into(),
+                    Some(vm.ctx.exceptions.resource_warning.to_owned()),
+                    1,
+                    None,
+                    vm,
+                );
+            }
+            let _ = zelf.close();
+            Ok(())
+        }
+    }
+
+    #[pyclass(
+        with(Constructor, Initializer, Representable, Destructor),
+        flags(BASETYPE)
+    )]
     impl PySocket {
         fn _init(
             zelf: PyRef<Self>,
-            (family, socket_kind, proto, fileno): <Self as Initializer>::Args,
+            args: <Self as Initializer>::Args,
             vm: &VirtualMachine,
         ) -> Result<(), IoOrPyException> {
-            let mut family = family.unwrap_or(-1);
-            let mut socket_kind = socket_kind.unwrap_or(-1);
-            let mut proto = proto.unwrap_or(-1);
+            let mut family = args.family.unwrap_or(-1);
+            let mut socket_kind = args.r#type.unwrap_or(-1);
+            let mut proto = args.proto.unwrap_or(-1);
 
+            let fileno = args.fileno;
             let sock;
 
             // On Windows, fileno can be bytes from socket.share() for fromshare()
@@ -1420,7 +1474,7 @@ mod _socket {
                 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>();
+                    let expected_size = core::mem::size_of::<c::WSAPROTOCOL_INFOW>();
 
                     if bytes_data.len() != expected_size {
                         return Err(vm
@@ -1431,9 +1485,9 @@ mod _socket {
                             .into());
                     }
 
-                    let mut info: c::WSAPROTOCOL_INFOW = unsafe { std::mem::zeroed() };
+                    let mut info: c::WSAPROTOCOL_INFOW = unsafe { core::mem::zeroed() };
                     unsafe {
-                        std::ptr::copy_nonoverlapping(
+                        core::ptr::copy_nonoverlapping(
                             bytes_data.as_ptr(),
                             &mut info as *mut c::WSAPROTOCOL_INFOW as *mut u8,
                             expected_size,
@@ -1477,7 +1531,7 @@ mod _socket {
                                 Some(errcode!(ENOTSOCK)) | Some(errcode!(EBADF))
                             ) =>
                     {
-                        std::mem::forget(sock);
+                        core::mem::forget(sock);
                         return Err(e.into());
                     }
                     _ => {}
@@ -1621,9 +1675,9 @@ mod _socket {
 
             // Handle nbytes parameter
             let read_len = if let OptionalArg::Present(nbytes) = nbytes {
-                let nbytes = nbytes.to_usize().ok_or_else(|| {
-                    vm.new_value_error("negative buffersize in recv_into".to_owned())
-                })?;
+                let nbytes = nbytes
+                    .to_usize()
+                    .ok_or_else(|| vm.new_value_error("negative buffersize in recv_into"))?;
                 nbytes.min(buf.len())
             } else {
                 buf.len()
@@ -1830,7 +1884,7 @@ mod _socket {
             // 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()));
+                    return Err(vm.new_type_error("assoclen must be non-negative"));
                 }
                 OptionalArg::Present(val) => Some(val as u32),
                 OptionalArg::Missing => None,
@@ -1842,17 +1896,18 @@ mod _socket {
             // 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 space =
+                    unsafe { libc::CMSG_SPACE(core::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_len = libc::CMSG_LEN(core::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());
+                    core::ptr::copy_nonoverlapping(op_bytes.as_ptr(), data, op_bytes.len());
                 }
             }
 
@@ -1873,26 +1928,27 @@ mod _socket {
                     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);
+                    core::ptr::copy_nonoverlapping(ivlen.as_ptr(), data, 4);
                     // Write iv
-                    std::ptr::copy_nonoverlapping(iv_bytes.as_ptr(), data.add(4), iv_bytes.len());
+                    core::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 space =
+                    unsafe { libc::CMSG_SPACE(core::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_len = libc::CMSG_LEN(core::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(
+                    core::ptr::copy_nonoverlapping(
                         assoclen_bytes.as_ptr(),
                         data,
                         assoclen_bytes.len(),
@@ -1911,7 +1967,7 @@ mod _socket {
                 .collect();
 
             // Set up msghdr
-            let mut msghdr: libc::msghdr = unsafe { std::mem::zeroed() };
+            let mut msghdr: libc::msghdr = unsafe { core::mem::zeroed() };
             msghdr.msg_iov = iovecs.as_ptr() as *mut _;
             msghdr.msg_iovlen = iovecs.len() as _;
             if !control_buf.is_empty() {
@@ -1947,15 +2003,13 @@ mod _socket {
             use core::mem::MaybeUninit;
 
             if bufsize < 0 {
-                return Err(vm.new_value_error("negative buffer size in recvmsg".to_owned()));
+                return Err(vm.new_value_error("negative buffer size in recvmsg"));
             }
             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())
-                );
+                return Err(vm.new_value_error("negative ancillary buffer size in recvmsg"));
             }
             let ancbufsize = ancbufsize as usize;
             let flags = flags.unwrap_or(0);
@@ -2122,38 +2176,6 @@ 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 {
@@ -2201,12 +2223,27 @@ mod _socket {
         }
 
         #[pymethod]
-        fn settimeout(&self, timeout: Option<Duration>) -> io::Result<()> {
-            self.timeout
-                .store(timeout.map_or(-1.0, |d| d.as_secs_f64()));
+        fn settimeout(&self, timeout: Option<ArgIntoFloat>, vm: &VirtualMachine) -> PyResult<()> {
+            let timeout = match timeout {
+                Some(t) => {
+                    let f = t.into_float();
+                    if f.is_nan() {
+                        return Err(vm.new_value_error("Invalid value NaN (not a number)"));
+                    }
+                    if f < 0.0 || !f.is_finite() {
+                        return Err(vm.new_value_error("Timeout value out of range"));
+                    }
+                    Some(f)
+                }
+                None => None,
+            };
+            self.timeout.store(timeout.unwrap_or(-1.0));
             // even if timeout is > 0 the socket needs to be nonblocking in order for us to select() on
             // it
-            self.sock()?.set_nonblocking(timeout.is_some())
+            self.sock()
+                .map_err(|e| e.into_pyexception(vm))?
+                .set_nonblocking(timeout.is_some())
+                .map_err(|e| e.into_pyexception(vm))
         }
 
         #[pymethod]
@@ -2359,11 +2396,11 @@ mod _socket {
                             fd as _,
                             cmd,
                             &option_val as *const u32 as *const _,
-                            std::mem::size_of::<u32>() as u32,
-                            std::ptr::null_mut(),
+                            core::mem::size_of::<u32>() as u32,
+                            core::ptr::null_mut(),
                             0,
                             &mut recv,
-                            std::ptr::null_mut(),
+                            core::ptr::null_mut(),
                             None,
                         )
                     };
@@ -2402,11 +2439,11 @@ mod _socket {
                             fd as _,
                             cmd,
                             &ka as *const TcpKeepalive as *const _,
-                            std::mem::size_of::<TcpKeepalive>() as u32,
-                            std::ptr::null_mut(),
+                            core::mem::size_of::<TcpKeepalive>() as u32,
+                            core::ptr::null_mut(),
                             0,
                             &mut recv,
-                            std::ptr::null_mut(),
+                            core::ptr::null_mut(),
                             None,
                         )
                     };
@@ -2437,9 +2474,9 @@ mod _socket {
 
             let info = unsafe { info.assume_init() };
             let bytes = unsafe {
-                std::slice::from_raw_parts(
+                core::slice::from_raw_parts(
                     &info as *const c::WSAPROTOCOL_INFOW as *const u8,
-                    std::mem::size_of::<c::WSAPROTOCOL_INFOW>(),
+                    core::mem::size_of::<c::WSAPROTOCOL_INFOW>(),
                 )
             };
 
@@ -2463,7 +2500,7 @@ mod _socket {
     }
 
     struct Address {
-        host: PyStrRef,
+        host: PyUtf8StrRef,
         port: u16,
     }
 
@@ -2488,6 +2525,7 @@ mod _socket {
     impl Address {
         fn from_tuple(tuple: &[PyObjectRef], vm: &VirtualMachine) -> PyResult<Self> {
             let host = PyStrRef::try_from_object(vm, tuple[0].clone())?;
+            let host = host.try_into_utf8(vm)?;
             let port = i32::try_from_borrowed_object(vm, &tuple[1])?;
             let port = port
                 .to_u16()
@@ -2604,12 +2642,12 @@ mod _socket {
 
     #[cfg(all(unix, not(target_os = "redox")))]
     #[pyfunction]
-    fn sethostname(hostname: PyStrRef) -> nix::Result<()> {
+    fn sethostname(hostname: PyUtf8StrRef) -> nix::Result<()> {
         nix::unistd::sethostname(hostname.as_str())
     }
 
     #[pyfunction]
-    fn inet_aton(ip_string: PyStrRef, vm: &VirtualMachine) -> PyResult<Vec<u8>> {
+    fn inet_aton(ip_string: PyUtf8StrRef, vm: &VirtualMachine) -> PyResult<Vec<u8>> {
         ip_string
             .as_str()
             .parse::<Ipv4Addr>()
@@ -2820,14 +2858,13 @@ mod _socket {
                         .codec_registry
                         .encode_text(s.to_owned(), "idna", None, vm)?;
                 let host_str = core::str::from_utf8(encoded.as_bytes())
-                    .map_err(|_| vm.new_runtime_error("idna output is not utf8".to_owned()))?;
+                    .map_err(|_| vm.new_runtime_error("idna output is not utf8"))?;
                 Some(host_str.to_owned())
             }
             Some(ArgStrOrBytesLike::Buf(b)) => {
                 let bytes = b.borrow_buf();
-                let host_str = core::str::from_utf8(&bytes).map_err(|_| {
-                    vm.new_unicode_decode_error("host bytes is not utf8".to_owned())
-                })?;
+                let host_str = core::str::from_utf8(&bytes)
+                    .map_err(|_| vm.new_unicode_decode_error("host bytes is not utf8"))?;
                 Some(host_str.to_owned())
             }
             None => None,
@@ -2848,9 +2885,7 @@ mod _socket {
                         // For bytes, check if it's valid UTF-8
                         let bytes = b.borrow_buf();
                         core::str::from_utf8(&bytes)
-                            .map_err(|_| {
-                                vm.new_unicode_decode_error("port is not utf8".to_owned())
-                            })?
+                            .map_err(|_| vm.new_unicode_decode_error("port is not utf8"))?
                             .to_owned()
                     }
                 };
@@ -2883,7 +2918,7 @@ mod _socket {
 
     #[pyfunction]
     fn gethostbyaddr(
-        addr: PyStrRef,
+        addr: PyUtf8StrRef,
         vm: &VirtualMachine,
     ) -> Result<(String, PyListRef, PyListRef), IoOrPyException> {
         let addr = get_addr(vm, addr, c::AF_UNSPEC)?;
@@ -2898,7 +2933,7 @@ mod _socket {
     }
 
     #[pyfunction]
-    fn gethostbyname(name: PyStrRef, vm: &VirtualMachine) -> Result<String, IoOrPyException> {
+    fn gethostbyname(name: PyUtf8StrRef, vm: &VirtualMachine) -> Result<String, IoOrPyException> {
         let addr = get_addr(vm, name, c::AF_INET)?;
         match addr {
             SocketAddr::V4(ip) => Ok(ip.ip().to_string()),
@@ -2908,7 +2943,7 @@ mod _socket {
 
     #[pyfunction]
     fn gethostbyname_ex(
-        name: PyStrRef,
+        name: PyUtf8StrRef,
         vm: &VirtualMachine,
     ) -> Result<(String, PyListRef, PyListRef), IoOrPyException> {
         let addr = get_addr(vm, name, c::AF_INET)?;
@@ -2923,7 +2958,7 @@ mod _socket {
     }
 
     #[pyfunction]
-    fn inet_pton(af_inet: i32, ip_string: PyStrRef, vm: &VirtualMachine) -> PyResult<Vec<u8>> {
+    fn inet_pton(af_inet: i32, ip_string: PyUtf8StrRef, vm: &VirtualMachine) -> PyResult<Vec<u8>> {
         static ERROR_MSG: &str = "illegal IP address string passed to inet_pton";
         let ip_addr = match af_inet {
             c::AF_INET => ip_string
@@ -2994,10 +3029,10 @@ mod _socket {
             protocol: 0,
         };
         let service = addr.port.to_string();
-        let mut res =
-            dns_lookup::getaddrinfo(Some(addr.host.as_str()), Some(&service), Some(hints))
-                .map_err(|e| convert_socket_error(vm, e, SocketError::GaiError))?
-                .filter_map(Result::ok);
+        let host_str = addr.host.as_str();
+        let mut res = dns_lookup::getaddrinfo(Some(host_str), Some(&service), Some(hints))
+            .map_err(|e| convert_socket_error(vm, e, SocketError::GaiError))?
+            .filter_map(Result::ok);
         let mut ainfo = res.next().unwrap();
         if res.next().is_some() {
             return Err(vm
@@ -3103,7 +3138,6 @@ mod _socket {
         }
         #[cfg(windows)]
         {
-            use std::ptr;
             use windows_sys::Win32::NetworkManagement::Ndis::NET_LUID_LH;
 
             let table = MibTable::get_raw().map_err(|err| err.into_pyexception(vm))?;
@@ -3130,14 +3164,14 @@ mod _socket {
                 }
             }
             struct MibTable {
-                ptr: ptr::NonNull<IpHelper::MIB_IF_TABLE2>,
+                ptr: core::ptr::NonNull<IpHelper::MIB_IF_TABLE2>,
             }
             impl MibTable {
                 fn get_raw() -> io::Result<Self> {
-                    let mut ptr = ptr::null_mut();
+                    let mut ptr = core::ptr::null_mut();
                     let ret = unsafe { IpHelper::GetIfTable2Ex(IpHelper::MibIfTableRaw, &mut ptr) };
                     if ret == 0 {
-                        let ptr = unsafe { ptr::NonNull::new_unchecked(ptr) };
+                        let ptr = unsafe { core::ptr::NonNull::new_unchecked(ptr) };
                         Ok(Self { ptr })
                     } else {
                         Err(io::Error::from_raw_os_error(ret as i32))
@@ -3149,7 +3183,7 @@ mod _socket {
                     unsafe {
                         let p = self.ptr.as_ptr();
                         let ptr = &raw const (*p).Table as *const IpHelper::MIB_IF_ROW2;
-                        std::slice::from_raw_parts(ptr, (*p).NumEntries as usize)
+                        core::slice::from_raw_parts(ptr, (*p).NumEntries as usize)
                     }
                 }
             }
@@ -3163,7 +3197,7 @@ mod _socket {
 
     fn get_addr(
         vm: &VirtualMachine,
-        pyname: PyStrRef,
+        pyname: PyUtf8StrRef,
         af: i32,
     ) -> Result<SocketAddr, IoOrPyException> {
         let name = pyname.as_str();
@@ -3216,7 +3250,7 @@ mod _socket {
         let name = vm
             .state
             .codec_registry
-            .encode_text(pyname, "idna", None, vm)?;
+            .encode_text(pyname.into_wtf8(), "idna", None, vm)?;
         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))
@@ -3366,8 +3400,22 @@ mod _socket {
     }
 
     #[pyfunction]
-    fn setdefaulttimeout(timeout: Option<Duration>) {
-        DEFAULT_TIMEOUT.store(timeout.map_or(-1.0, |d| d.as_secs_f64()));
+    fn setdefaulttimeout(timeout: Option<ArgIntoFloat>, vm: &VirtualMachine) -> PyResult<()> {
+        let val = match timeout {
+            Some(t) => {
+                let f = t.into_float();
+                if f.is_nan() {
+                    return Err(vm.new_value_error("Invalid value NaN (not a number)"));
+                }
+                if f < 0.0 || !f.is_finite() {
+                    return Err(vm.new_value_error("Timeout value out of range"));
+                }
+                f
+            }
+            None => -1.0,
+        };
+        DEFAULT_TIMEOUT.store(val);
+        Ok(())
     }
 
     #[pyfunction]
diff --git a/crates/stdlib/src/ssl.rs b/crates/stdlib/src/ssl.rs
index 5bb6c259e66..06c0010a79d 100644
--- a/crates/stdlib/src/ssl.rs
+++ b/crates/stdlib/src/ssl.rs
@@ -40,12 +40,15 @@ mod _ssl {
         vm::{
             AsObject, Py, PyObject, PyObjectRef, PyPayload, PyRef, PyResult, TryFromObject,
             VirtualMachine,
-            builtins::{PyBaseExceptionRef, PyBytesRef, PyListRef, PyStrRef, PyType, PyTypeRef},
+            builtins::{
+                PyBaseExceptionRef, PyBytesRef, PyListRef, PyStrRef, PyType, PyTypeRef,
+                PyUtf8StrRef,
+            },
             convert::IntoPyException,
             function::{
                 ArgBytesLike, ArgMemoryBuffer, Either, FuncArgs, OptionalArg, PyComparisonValue,
             },
-            stdlib::warnings,
+            stdlib::_warnings,
             types::{Comparable, Constructor, Hashable, PyComparisonOp, Representable},
         },
     };
@@ -57,10 +60,16 @@ mod _ssl {
     };
     use alloc::sync::Arc;
     use core::{
+        hash::{Hash, Hasher},
         sync::atomic::{AtomicUsize, Ordering},
         time::Duration,
     };
-    use std::{collections::HashMap, time::SystemTime};
+    use rustls::crypto::aws_lc_rs::ALL_CIPHER_SUITES;
+    use std::{
+        collections::{HashMap, hash_map::DefaultHasher},
+        io::BufRead,
+        time::SystemTime,
+    };
 
     // Rustls imports
     use parking_lot::{Mutex as ParkingMutex, RwLock as ParkingRwLock};
@@ -318,6 +327,8 @@ mod _ssl {
     const HAS_TLSv1_2: bool = true; // rustls supports TLS 1.2
     #[pyattr]
     const HAS_TLSv1_3: bool = true;
+    #[pyattr]
+    const HAS_PHA: bool = false; // Post-Handshake Auth not supported in rustls
 
     // Encoding constants (matching OpenSSL)
     #[pyattr]
@@ -597,8 +608,6 @@ mod _ssl {
     /// - "ALL" or "DEFAULT" → all available
     /// - "!MD5" → exclusion (ignored, rustls doesn't support weak ciphers anyway)
     fn parse_cipher_string(cipher_str: &str) -> Result<Vec<rustls::SupportedCipherSuite>, String> {
-        use rustls::crypto::aws_lc_rs::ALL_CIPHER_SUITES;
-
         if cipher_str.is_empty() {
             return Err("No cipher can be selected".to_string());
         }
@@ -801,7 +810,7 @@ mod _ssl {
         sock: PyObjectRef,
         server_side: bool,
         #[pyarg(positional, optional)]
-        server_hostname: OptionalArg<Option<PyStrRef>>,
+        server_hostname: OptionalArg<Option<PyUtf8StrRef>>,
         #[pyarg(named, optional)]
         owner: OptionalArg<PyObjectRef>,
         #[pyarg(named, optional)]
@@ -815,7 +824,7 @@ mod _ssl {
         #[pyarg(named, optional)]
         server_side: OptionalArg<bool>,
         #[pyarg(named, optional)]
-        server_hostname: OptionalArg<Option<PyStrRef>>,
+        server_hostname: OptionalArg<Option<PyUtf8StrRef>>,
         #[pyarg(named, optional)]
         owner: OptionalArg<PyObjectRef>,
         #[pyarg(named, optional)]
@@ -848,18 +857,13 @@ mod _ssl {
         binary_form: OptionalArg<bool>,
     }
 
-    #[pyclass(with(Constructor), flags(BASETYPE))]
+    #[pyclass(with(Constructor, Representable), flags(BASETYPE))]
     impl PySSLContext {
         // Helper method to convert DER certificate bytes to Python dict
         fn cert_der_to_dict(&self, vm: &VirtualMachine, cert_der: &[u8]) -> PyResult<PyObjectRef> {
             cert::cert_der_to_dict_helper(vm, cert_der)
         }
 
-        #[pymethod]
-        fn __repr__(&self) -> String {
-            format!("<SSLContext(protocol={})>", self.protocol)
-        }
-
         #[pygetset]
         fn check_hostname(&self) -> bool {
             *self.check_hostname.read()
@@ -950,7 +954,7 @@ mod _ssl {
         fn set_options(&self, value: i32, vm: &VirtualMachine) -> PyResult<()> {
             // Validate that the value is non-negative
             if value < 0 {
-                return Err(vm.new_overflow_error("options must be non-negative".to_owned()));
+                return Err(vm.new_value_error("options must be non-negative"));
             }
 
             // Deprecated SSL/TLS protocol version options
@@ -967,7 +971,7 @@ mod _ssl {
 
             // Warn if any deprecated options are being newly set
             if (set & opt_no) != 0 {
-                warnings::warn(
+                _warnings::warn(
                     vm.ctx.exceptions.deprecation_warning,
                     "ssl.OP_NO_SSL*/ssl.OP_NO_TLS* options are deprecated".to_owned(),
                     2, // stack_level = 2
@@ -1080,19 +1084,17 @@ mod _ssl {
 
                 // Convert callable result to string
                 let password_from_callable = if let Ok(pwd_str) =
-                    PyStrRef::try_from_object(vm, pwd_result.clone())
+                    PyUtf8StrRef::try_from_object(vm, pwd_result.clone())
                 {
                     pwd_str.as_str().to_owned()
                 } else if let Ok(pwd_bytes_like) = ArgBytesLike::try_from_object(vm, pwd_result) {
                     String::from_utf8(pwd_bytes_like.borrow_buf().to_vec()).map_err(|_| {
-                        vm.new_type_error(
-                            "password callback returned invalid UTF-8 bytes".to_owned(),
-                        )
+                        vm.new_type_error("password callback returned invalid UTF-8 bytes")
                     })?
                 } else {
-                    return Err(vm.new_type_error(
-                        "password callback must return a string or bytes".to_owned(),
-                    ));
+                    return Err(
+                        vm.new_type_error("password callback must return a string or bytes")
+                    );
                 };
 
                 // Validate callable password length
@@ -1235,9 +1237,7 @@ mod _ssl {
             let has_cadata = matches!(&args.cadata, OptionalArg::Present(Some(_)));
 
             if !has_cafile && !has_capath && !has_cadata {
-                return Err(
-                    vm.new_type_error("cafile, capath and cadata cannot be all omitted".to_owned())
-                );
+                return Err(vm.new_type_error("cafile, capath and cadata cannot be all omitted"));
             }
 
             // Parse arguments BEFORE acquiring locks to reduce lock scope
@@ -1501,7 +1501,7 @@ mod _ssl {
         }
 
         #[pymethod]
-        fn set_ciphers(&self, ciphers: PyStrRef, vm: &VirtualMachine) -> PyResult<()> {
+        fn set_ciphers(&self, ciphers: PyUtf8StrRef, vm: &VirtualMachine) -> PyResult<()> {
             let cipher_str = ciphers.as_str();
 
             // Parse cipher string and store selected ciphers
@@ -1520,7 +1520,6 @@ mod _ssl {
         fn get_ciphers(&self, vm: &VirtualMachine) -> PyResult<PyListRef> {
             // Dynamically generate cipher list from rustls ALL_CIPHER_SUITES
             // This automatically includes all cipher suites supported by the current rustls version
-            use rustls::crypto::aws_lc_rs::ALL_CIPHER_SUITES;
 
             let cipher_list = ALL_CIPHER_SUITES
                 .iter()
@@ -1737,17 +1736,17 @@ mod _ssl {
         fn load_dh_params(&self, filepath: PyObjectRef, vm: &VirtualMachine) -> PyResult<()> {
             // Validate filepath is not None
             if vm.is_none(&filepath) {
-                return Err(vm.new_type_error("DH params filepath cannot be None".to_owned()));
+                return Err(vm.new_type_error("DH params filepath cannot be None"));
             }
 
             // Validate filepath is str or bytes
-            let path_str = if let Ok(s) = PyStrRef::try_from_object(vm, filepath.clone()) {
+            let path_str = if let Ok(s) = PyUtf8StrRef::try_from_object(vm, filepath.clone()) {
                 s.as_str().to_owned()
             } else if let Ok(b) = ArgBytesLike::try_from_object(vm, filepath) {
                 String::from_utf8(b.borrow_buf().to_vec())
-                    .map_err(|_| vm.new_value_error("Invalid path encoding".to_owned()))?
+                    .map_err(|_| vm.new_value_error("Invalid path encoding"))?
             } else {
-                return Err(vm.new_type_error("DH params filepath must be str or bytes".to_owned()));
+                return Err(vm.new_type_error("DH params filepath must be str or bytes"));
             };
 
             // Check if file exists
@@ -1792,17 +1791,17 @@ mod _ssl {
         fn set_ecdh_curve(&self, name: PyObjectRef, vm: &VirtualMachine) -> PyResult<()> {
             // Validate name is not None
             if vm.is_none(&name) {
-                return Err(vm.new_type_error("ECDH curve name cannot be None".to_owned()));
+                return Err(vm.new_type_error("ECDH curve name cannot be None"));
             }
 
             // Validate name is str or bytes
-            let curve_name = if let Ok(s) = PyStrRef::try_from_object(vm, name.clone()) {
+            let curve_name = if let Ok(s) = PyUtf8StrRef::try_from_object(vm, name.clone()) {
                 s.as_str().to_owned()
             } else if let Ok(b) = ArgBytesLike::try_from_object(vm, name) {
                 String::from_utf8(b.borrow_buf().to_vec())
-                    .map_err(|_| vm.new_value_error("Invalid curve name encoding".to_owned()))?
+                    .map_err(|_| vm.new_value_error("Invalid curve name encoding"))?
             } else {
-                return Err(vm.new_type_error("ECDH curve name must be str or bytes".to_owned()));
+                return Err(vm.new_type_error("ECDH curve name must be str or bytes"));
             };
 
             // Validate curve name (common curves for compatibility)
@@ -1995,9 +1994,9 @@ mod _ssl {
             vm: &VirtualMachine,
         ) -> PyResult<String> {
             match arg {
-                Either::A(s) => Ok(s.as_str().to_owned()),
+                Either::A(s) => Ok(s.clone().try_into_utf8(vm)?.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())),
+                    .map_err(|_| vm.new_value_error("path contains invalid UTF-8")),
             }
         }
 
@@ -2012,25 +2011,26 @@ mod _ssl {
         ) -> PyResult<(Option<String>, Option<PyObjectRef>)> {
             match password {
                 OptionalArg::Present(p) => {
-                    // Try string first
-                    if let Ok(pwd_str) = PyStrRef::try_from_object(vm, p.clone()) {
+                    if vm.is_none(p) {
+                        return Ok((None, None));
+                    }
+
+                    // Try string
+                    if let Ok(pwd_str) = PyUtf8StrRef::try_from_object(vm, p.clone()) {
                         Ok((Some(pwd_str.as_str().to_owned()), None))
                     }
                     // Try bytes-like
                     else if let Ok(pwd_bytes_like) = ArgBytesLike::try_from_object(vm, p.clone())
                     {
-                        let pwd = String::from_utf8(pwd_bytes_like.borrow_buf().to_vec()).map_err(
-                            |_| vm.new_type_error("password bytes must be valid UTF-8".to_owned()),
-                        )?;
+                        let pwd = String::from_utf8(pwd_bytes_like.borrow_buf().to_vec())
+                            .map_err(|_| vm.new_type_error("password bytes must be valid UTF-8"))?;
                         Ok((Some(pwd), None))
                     }
                     // Try callable
                     else if p.is_callable() {
                         Ok((None, Some(p.clone())))
                     } else {
-                        Err(vm.new_type_error(
-                            "password should be a string, bytes, or callable".to_owned(),
-                        ))
+                        Err(vm.new_type_error("password should be a string or callable"))
                     }
                 }
                 _ => Ok((None, None)),
@@ -2171,10 +2171,10 @@ mod _ssl {
         fn parse_cadata_arg(
             &self,
             arg: &Either<PyStrRef, ArgBytesLike>,
-            _vm: &VirtualMachine,
+            vm: &VirtualMachine,
         ) -> PyResult<Vec<u8>> {
             match arg {
-                Either::A(s) => Ok(s.as_str().as_bytes().to_vec()),
+                Either::A(s) => Ok(s.clone().try_into_utf8(vm)?.as_str().as_bytes().to_vec()),
                 Either::B(b) => Ok(b.borrow_buf().to_vec()),
             }
         }
@@ -2186,6 +2186,13 @@ mod _ssl {
         }
     }
 
+    impl Representable for PySSLContext {
+        #[inline]
+        fn repr_str(zelf: &Py<Self>, _vm: &VirtualMachine) -> PyResult<String> {
+            Ok(format!("<SSLContext(protocol={})>", zelf.protocol))
+        }
+    }
+
     impl Constructor for PySSLContext {
         type Args = (i32,);
 
@@ -2369,7 +2376,7 @@ mod _ssl {
         Completed,       // unwrap() completed successfully
     }
 
-    #[pyclass(with(Constructor), flags(BASETYPE))]
+    #[pyclass(with(Constructor, Representable), flags(BASETYPE))]
     impl PySSLSocket {
         // Check if this is BIO mode
         pub(crate) fn is_bio_mode(&self) -> bool {
@@ -2616,7 +2623,7 @@ mod _ssl {
         pub(crate) fn sock_wait_for_io_with_timeout(
             &self,
             kind: SelectKind,
-            timeout: Option<std::time::Duration>,
+            timeout: Option<core::time::Duration>,
             vm: &VirtualMachine,
         ) -> PyResult<bool> {
             if self.is_bio_mode() {
@@ -3016,11 +3023,6 @@ mod _ssl {
             }
         }
 
-        #[pymethod]
-        fn __repr__(&self) -> String {
-            "<SSLSocket>".to_string()
-        }
-
         // Helper function to convert Python PROTO_* constants to rustls versions
         fn get_rustls_versions(
             minimum: i32,
@@ -3577,7 +3579,7 @@ mod _ssl {
                             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)
                     };
@@ -3606,7 +3608,7 @@ mod _ssl {
                             Some(conn) => conn,
                             None => return Err(create_ssl_zero_return_error(vm).upcast()),
                         };
-                        use std::io::BufRead;
+
                         let mut reader = conn.reader();
                         reader.fill_buf().map(|buf| buf.len()).unwrap_or(0)
                     };
@@ -3624,18 +3626,17 @@ mod _ssl {
                             return return_data(buf, &buffer, vm);
                         }
                     }
-                    // Clean closure with close_notify
-                    // CPython behavior depends on whether we've sent our close_notify:
-                    // - If we've already sent close_notify (unwrap was called): raise SSLZeroReturnError
-                    // - If we haven't sent close_notify yet: return empty bytes
+                    // Clean closure via close_notify from peer.
+                    // If we already sent close_notify (unwrap was called),
+                    // raise SSLZeroReturnError (bidirectional shutdown).
+                    // Otherwise return empty bytes, which callers (asyncore,
+                    // asyncio sslproto) interpret as EOF.
                     let our_shutdown_state = *self.shutdown_state.lock();
                     if our_shutdown_state == ShutdownState::SentCloseNotify
                         || our_shutdown_state == ShutdownState::Completed
                     {
-                        // We already sent close_notify, now receiving peer's → SSLZeroReturnError
                         Err(create_ssl_zero_return_error(vm).upcast())
                     } else {
-                        // We haven't sent close_notify yet → return empty bytes
                         return_data(vec![], &buffer, vm)
                     }
                 }
@@ -3674,7 +3675,6 @@ mod _ssl {
             // Use rustls Reader's fill_buf() to check buffered plaintext
             // fill_buf() returns a reference to buffered data without consuming it
             // This matches OpenSSL's SSL_pending() behavior
-            use std::io::BufRead;
             let mut reader = conn.reader();
             match reader.fill_buf() {
                 Ok(buf) => Ok(buf.len()),
@@ -3894,7 +3894,7 @@ mod _ssl {
         #[pygetset(setter)]
         fn set_server_hostname(
             &self,
-            value: Option<PyStrRef>,
+            value: Option<PyUtf8StrRef>,
             vm: &VirtualMachine,
         ) -> PyResult<()> {
             // Check if handshake is already done
@@ -3905,11 +3905,14 @@ mod _ssl {
             }
 
             // Validate hostname
-            if let Some(hostname_str) = &value {
-                validate_hostname(hostname_str.as_str(), vm)?;
-            }
+            let hostname_string = value
+                .map(|s| {
+                    validate_hostname(s.as_str(), vm)?;
+                    Ok::<String, _>(s.as_str().to_owned())
+                })
+                .transpose()?;
 
-            *self.server_hostname.write() = value.map(|s| s.as_str().to_string());
+            *self.server_hostname.write() = hostname_string;
             Ok(())
         }
 
@@ -4157,7 +4160,7 @@ mod _ssl {
 
                             // Calculate deadline for timeout mode
                             let deadline = timeout.map(|t| {
-                                std::time::Instant::now() + std::time::Duration::from_secs_f64(t)
+                                std::time::Instant::now() + core::time::Duration::from_secs_f64(t)
                             });
 
                             // Wait for peer's close_notify
@@ -4181,10 +4184,11 @@ mod _ssl {
                                     let now = std::time::Instant::now();
                                     if now >= dl {
                                         // Timeout reached - raise TimeoutError
-                                        return Err(vm.new_exception_msg(
-                                            vm.ctx.exceptions.timeout_error.to_owned(),
-                                            "The read operation timed out".to_owned(),
-                                        ));
+                                        return Err(timeout_error_msg(
+                                            vm,
+                                            "The read operation timed out".to_string(),
+                                        )
+                                        .upcast());
                                     }
                                     Some(dl - now)
                                 } else {
@@ -4200,11 +4204,11 @@ mod _ssl {
 
                                 if timed_out {
                                     // Timeout waiting for peer's close_notify
-                                    // Raise TimeoutError
-                                    return Err(vm.new_exception_msg(
-                                        vm.ctx.exceptions.timeout_error.to_owned(),
-                                        "The read operation timed out".to_owned(),
-                                    ));
+                                    return Err(timeout_error_msg(
+                                        vm,
+                                        "The read operation timed out".to_string(),
+                                    )
+                                    .upcast());
                                 }
 
                                 // Try to read data from socket
@@ -4529,7 +4533,7 @@ mod _ssl {
         #[pymethod]
         fn get_channel_binding(
             &self,
-            cb_type: OptionalArg<PyStrRef>,
+            cb_type: OptionalArg<PyUtf8StrRef>,
             vm: &VirtualMachine,
         ) -> PyResult<Option<PyBytesRef>> {
             let cb_type_str = cb_type.as_ref().map_or("tls-unique", |s| s.as_str());
@@ -4555,6 +4559,13 @@ mod _ssl {
         }
     }
 
+    impl Representable for PySSLSocket {
+        #[inline]
+        fn repr_str(_zelf: &Py<Self>, _vm: &VirtualMachine) -> PyResult<String> {
+            Ok("<SSLSocket>".to_owned())
+        }
+    }
+
     impl Constructor for PySSLSocket {
         type Args = ();
 
@@ -4628,7 +4639,7 @@ mod _ssl {
                 if !is_contiguous {
                     return Err(vm.new_exception_msg(
                         vm.ctx.exceptions.buffer_error.to_owned(),
-                        "non-contiguous buffer is not supported".to_owned(),
+                        "non-contiguous buffer is not supported".into(),
                     ));
                 }
             }
@@ -4724,8 +4735,6 @@ 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;
 
             let mut hasher = DefaultHasher::new();
             self.session_data.hash(&mut hasher);
@@ -4755,7 +4764,7 @@ mod _ssl {
 
     #[derive(FromArgs)]
     struct Txt2ObjArgs {
-        txt: PyStrRef,
+        txt: PyUtf8StrRef,
         #[pyarg(named, optional)]
         name: OptionalArg<bool>,
     }
@@ -4901,13 +4910,13 @@ mod _ssl {
     /// This is a simplified wrapper around cert_der_to_dict_helper that handles
     /// file reading and PEM/DER auto-detection. Used by test suite.
     #[pyfunction]
-    fn _test_decode_cert(path: PyStrRef, vm: &VirtualMachine) -> PyResult<PyObjectRef> {
+    fn _test_decode_cert(path: PyUtf8StrRef, vm: &VirtualMachine) -> PyResult<PyObjectRef> {
         // Read certificate file
-        let cert_data = std::fs::read(path.as_str()).map_err(|e| {
+        let path_str = path.as_str();
+        let cert_data = std::fs::read(path_str).map_err(|e| {
             vm.new_os_error(format!(
                 "Failed to read certificate file {}: {}",
-                path.as_str(),
-                e
+                path_str, e
             ))
         })?;
 
@@ -4944,11 +4953,9 @@ mod _ssl {
     }
 
     #[pyfunction]
-    fn PEM_cert_to_DER_cert(pem_cert: PyStrRef, vm: &VirtualMachine) -> PyResult<PyBytesRef> {
-        let pem_str = pem_cert.as_str();
-
+    fn PEM_cert_to_DER_cert(pem_cert: PyUtf8StrRef, vm: &VirtualMachine) -> PyResult<PyBytesRef> {
         // Parse PEM format
-        let mut cursor = std::io::Cursor::new(pem_str.as_bytes());
+        let mut cursor = std::io::Cursor::new(pem_cert.as_bytes());
         let mut certs = rustls_pemfile::certs(&mut cursor);
 
         if let Some(Ok(cert)) = certs.next() {
@@ -4961,22 +4968,27 @@ mod _ssl {
     // Windows-specific certificate store enumeration functions
     #[cfg(windows)]
     #[pyfunction]
-    fn enum_certificates(store_name: PyStrRef, vm: &VirtualMachine) -> PyResult<Vec<PyObjectRef>> {
+    fn enum_certificates(
+        store_name: PyUtf8StrRef,
+        vm: &VirtualMachine,
+    ) -> PyResult<Vec<PyObjectRef>> {
         use schannel::{RawPointer, cert_context::ValidUses, cert_store::CertStore};
         use windows_sys::Win32::Security::Cryptography;
 
+        let store_name_str = store_name.as_str();
+
         // Try both Current User and Local Machine stores
         let open_fns = [CertStore::open_current_user, CertStore::open_local_machine];
         let stores = open_fns
             .iter()
-            .filter_map(|open| open(store_name.as_str()).ok())
+            .filter_map(|open| open(store_name_str).ok())
             .collect::<Vec<_>>();
 
         // If no stores could be opened, raise OSError
         if stores.is_empty() {
             return Err(vm.new_os_error(format!(
                 "failed to open certificate store {:?}",
-                store_name.as_str()
+                store_name_str
             )));
         }
 
@@ -5011,16 +5023,16 @@ mod _ssl {
 
     #[cfg(windows)]
     #[pyfunction]
-    fn enum_crls(store_name: PyStrRef, vm: &VirtualMachine) -> PyResult<Vec<PyObjectRef>> {
+    fn enum_crls(store_name: PyUtf8StrRef, vm: &VirtualMachine) -> PyResult<Vec<PyObjectRef>> {
         use windows_sys::Win32::Security::Cryptography::{
             CRL_CONTEXT, CertCloseStore, CertEnumCRLsInStore, CertOpenSystemStoreW,
             X509_ASN_ENCODING,
         };
 
-        let store_name_wide: Vec<u16> = store_name
-            .as_str()
+        let store_name_str = store_name.as_str();
+        let store_name_wide: Vec<u16> = store_name_str
             .encode_utf16()
-            .chain(std::iter::once(0))
+            .chain(core::iter::once(0))
             .collect();
 
         // Open system store
@@ -5029,7 +5041,7 @@ mod _ssl {
         if store.is_null() {
             return Err(vm.new_os_error(format!(
                 "failed to open certificate store {:?}",
-                store_name.as_str()
+                store_name_str
             )));
         }
 
@@ -5044,7 +5056,7 @@ mod _ssl {
 
             let crl = unsafe { &*crl_context };
             let crl_bytes =
-                unsafe { std::slice::from_raw_parts(crl.pbCrlEncoded, crl.cbCrlEncoded as usize) };
+                unsafe { core::slice::from_raw_parts(crl.pbCrlEncoded, crl.cbCrlEncoded as usize) };
 
             let enc_type = if crl.dwCertEncodingType == X509_ASN_ENCODING {
                 vm.new_pyobj("x509_asn")
@@ -5135,9 +5147,6 @@ 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;
-
             let mut hasher = DefaultHasher::new();
             zelf.der_bytes.hash(&mut hasher);
             Ok(hasher.finish() as PyHash)
diff --git a/crates/stdlib/src/ssl/compat.rs b/crates/stdlib/src/ssl/compat.rs
index 5bf2cd8b60f..14812375a8b 100644
--- a/crates/stdlib/src/ssl/compat.rs
+++ b/crates/stdlib/src/ssl/compat.rs
@@ -1161,6 +1161,113 @@ fn handshake_write_loop(
 ///
 /// Waits for and reads TLS records from the peer, handling SNI callback setup.
 /// Returns (made_progress, is_first_sni_read).
+/// TLS record header size (content_type + version + length).
+const TLS_RECORD_HEADER_SIZE: usize = 5;
+
+/// Read exactly one TLS record from the TCP socket.
+///
+/// OpenSSL reads one TLS record at a time (no read-ahead by default).
+/// Rustls, however, consumes all available TCP data when fed via read_tls().
+/// If a close_notify or other control record arrives alongside application
+/// data, the eager read drains the TCP buffer, leaving the control record in
+/// rustls's internal buffer where select() cannot see it.  This causes
+/// asyncore-based servers (which rely on select() for readability) to miss
+/// the data and the peer times out.
+///
+/// Fix: peek at the TCP buffer to find the first complete TLS record boundary
+/// and recv() only that many bytes.  Any remaining data stays in the kernel
+/// buffer and remains visible to select().
+fn recv_one_tls_record(socket: &PySSLSocket, vm: &VirtualMachine) -> SslResult<PyObjectRef> {
+    // Peek at what is available without consuming it.
+    let peeked_obj = match socket.sock_peek(SSL3_RT_MAX_PLAIN_LENGTH, vm) {
+        Ok(d) => d,
+        Err(e) => {
+            if is_blocking_io_error(&e, vm) {
+                return Err(SslError::WantRead);
+            }
+            return Err(SslError::Py(e));
+        }
+    };
+
+    let peeked = ArgBytesLike::try_from_object(vm, peeked_obj)
+        .map_err(|_| SslError::Syscall("Expected bytes-like object from peek".to_string()))?;
+    let peeked_bytes = peeked.borrow_buf();
+
+    if peeked_bytes.is_empty() {
+        // Empty peek means the peer has closed the TCP connection (FIN).
+        // Non-blocking sockets would have returned EAGAIN/EWOULDBLOCK
+        // (caught above as WantRead), so empty bytes here always means EOF.
+        return Err(SslError::Eof);
+    }
+
+    if peeked_bytes.len() < TLS_RECORD_HEADER_SIZE {
+        // Not enough data for a TLS record header yet.
+        // Read all available bytes so rustls can buffer the partial header;
+        // this avoids busy-waiting because the kernel buffer is now empty
+        // and select() will only wake us when new data arrives.
+        return socket.sock_recv(peeked_bytes.len(), vm).map_err(|e| {
+            if is_blocking_io_error(&e, vm) {
+                SslError::WantRead
+            } else {
+                SslError::Py(e)
+            }
+        });
+    }
+
+    // Parse the TLS record length from the header.
+    let record_body_len = u16::from_be_bytes([peeked_bytes[3], peeked_bytes[4]]) as usize;
+    let total_record_size = TLS_RECORD_HEADER_SIZE + record_body_len;
+
+    let recv_size = if peeked_bytes.len() >= total_record_size {
+        // Complete record available — consume exactly one record.
+        total_record_size
+    } else {
+        // Incomplete record — consume everything so the kernel buffer is
+        // drained and select() will block until more data arrives.
+        peeked_bytes.len()
+    };
+
+    // Must drop the borrow before calling sock_recv (which re-enters Python).
+    drop(peeked_bytes);
+    drop(peeked);
+
+    socket.sock_recv(recv_size, vm).map_err(|e| {
+        if is_blocking_io_error(&e, vm) {
+            SslError::WantRead
+        } else {
+            SslError::Py(e)
+        }
+    })
+}
+
+/// Read a single TLS record for post-handshake I/O while preserving the
+/// SSL-vs-socket error precedence from the old sock_recv() path.
+fn recv_one_tls_record_for_data(
+    conn: &mut TlsConnection,
+    socket: &PySSLSocket,
+    vm: &VirtualMachine,
+) -> SslResult<PyObjectRef> {
+    match recv_one_tls_record(socket, vm) {
+        Ok(data) => Ok(data),
+        Err(SslError::Eof) => {
+            if let Err(rustls_err) = conn.process_new_packets() {
+                return Err(SslError::from_rustls(rustls_err));
+            }
+            Ok(vm.ctx.new_bytes(vec![]).into())
+        }
+        Err(SslError::Py(e)) => {
+            if let Err(rustls_err) = conn.process_new_packets() {
+                return Err(SslError::from_rustls(rustls_err));
+            }
+            if is_connection_closed_error(&e, vm) {
+                return Err(SslError::Eof);
+            }
+            Err(SslError::Py(e))
+        }
+        Err(e) => Err(e),
+    }
+}
+
 fn handshake_read_data(
     conn: &mut TlsConnection,
     socket: &PySSLSocket,
@@ -1189,23 +1296,25 @@ fn handshake_read_data(
         }
     }
 
-    let data_obj = match socket.sock_recv(SSL3_RT_MAX_PLAIN_LENGTH, vm) {
-        Ok(d) => d,
-        Err(e) => {
-            if is_blocking_io_error(&e, vm) {
-                return Err(SslError::WantRead);
-            }
-            // In socket mode, if recv times out and we're only waiting for read
-            // (no wants_write), we might be waiting for optional NewSessionTicket in TLS 1.3
-            // Consider the handshake complete
-            if !is_bio && !conn.wants_write() {
-                // Check if it's a timeout exception
-                if e.fast_isinstance(vm.ctx.exceptions.timeout_error) {
-                    // Timeout waiting for optional data - handshake is complete
+    let data_obj = if !is_bio {
+        // In socket mode, read one TLS record at a time to avoid consuming
+        // application data that may arrive alongside the final handshake
+        // record.  This matches OpenSSL's default (no read-ahead) behaviour
+        // and keeps remaining data in the kernel buffer where select() can
+        // detect it.
+        recv_one_tls_record(socket, vm)?
+    } else {
+        match socket.sock_recv(SSL3_RT_MAX_PLAIN_LENGTH, vm) {
+            Ok(d) => d,
+            Err(e) => {
+                if is_blocking_io_error(&e, vm) {
+                    return Err(SslError::WantRead);
+                }
+                if !conn.wants_write() && e.fast_isinstance(vm.ctx.exceptions.timeout_error) {
                     return Ok((false, false));
                 }
+                return Err(SslError::Py(e));
             }
-            return Err(SslError::Py(e));
         }
     };
 
@@ -1637,17 +1746,8 @@ pub(super) fn ssl_read(
                 }
                 // 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));
-                    }
-                };
+                // Use single-record reading to avoid consuming close_notify alongside data.
+                let data = recv_one_tls_record_for_data(conn, socket, vm)?;
 
                 let bytes_read = data
                     .clone()
@@ -2049,28 +2149,27 @@ fn ssl_ensure_data_available(
             // else: non-blocking socket (timeout=0) or blocking socket (timeout=None) - skip select
         }
 
-        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
-                // already received and buffered the alert from a previous read
-                if let Err(rustls_err) = conn.process_new_packets() {
-                    return Err(SslError::from_rustls(rustls_err));
-                }
-                // In SSL context, connection closed errors (ECONNABORTED, ECONNRESET) indicate
-                // unexpected connection termination - the peer closed without proper TLS shutdown.
-                // This is semantically equivalent to "EOF occurred in violation of protocol"
-                // because no close_notify alert was received.
-                // On Windows, TCP RST can arrive before we read the TLS alert, causing these errors.
-                if is_connection_closed_error(&e, vm) {
-                    return Err(SslError::Eof);
+        // Read one TLS record at a time for non-BIO sockets (matching
+        // OpenSSL's default no-read-ahead behaviour).  This prevents
+        // consuming a close_notify that arrives alongside application data,
+        // keeping it in the kernel buffer where select() can detect it.
+        let data = if !is_bio {
+            recv_one_tls_record_for_data(conn, socket, vm)?
+        } else {
+            match socket.sock_recv(2048, vm) {
+                Ok(data) => data,
+                Err(e) => {
+                    if is_blocking_io_error(&e, vm) {
+                        return Err(SslError::WantRead);
+                    }
+                    if let Err(rustls_err) = conn.process_new_packets() {
+                        return Err(SslError::from_rustls(rustls_err));
+                    }
+                    if is_connection_closed_error(&e, vm) {
+                        return Err(SslError::Eof);
+                    }
+                    return Err(SslError::Py(e));
                 }
-                return Err(SslError::Py(e));
             }
         };
 
diff --git a/crates/stdlib/src/ssl/oid.rs b/crates/stdlib/src/ssl/oid.rs
index 2e13733a2a2..d85898c0f79 100644
--- a/crates/stdlib/src/ssl/oid.rs
+++ b/crates/stdlib/src/ssl/oid.rs
@@ -132,7 +132,8 @@ impl OidTable {
 }
 
 /// Global OID table
-static OID_TABLE: std::sync::LazyLock<OidTable> = std::sync::LazyLock::new(OidTable::build);
+static OID_TABLE: rustpython_common::lock::LazyLock<OidTable> =
+    rustpython_common::lock::LazyLock::new(OidTable::build);
 
 /// Macro to define OID entry using oid-registry constant
 macro_rules! oid_static {
diff --git a/crates/stdlib/src/statistics.rs b/crates/stdlib/src/statistics.rs
index 641d8864ed3..2f7eb85284a 100644
--- a/crates/stdlib/src/statistics.rs
+++ b/crates/stdlib/src/statistics.rs
@@ -5,7 +5,10 @@ mod _statistics {
     use crate::vm::{PyResult, VirtualMachine, function::ArgIntoFloat};
 
     // See https://github.com/python/cpython/blob/6846d6712a0894f8e1a91716c11dd79f42864216/Modules/_statisticsmodule.c#L28-L120
-    #[allow(clippy::excessive_precision)]
+    #[allow(
+        clippy::excessive_precision,
+        reason = "constants are kept at CPython precision"
+    )]
     fn normal_dist_inv_cdf(p: f64, mu: f64, sigma: f64) -> Option<f64> {
         if p <= 0.0 || p >= 1.0 {
             return None;
@@ -53,7 +56,10 @@ mod _statistics {
         let r = (-(r.ln())).sqrt();
         let num;
         let den;
-        #[allow(clippy::excessive_precision)]
+        #[allow(
+            clippy::excessive_precision,
+            reason = "piecewise polynomial coefficients match CPython"
+        )]
         if r <= 5.0 {
             let r = r - 1.6;
             // Hash sum-49.33206503301610289036
diff --git a/crates/stdlib/src/termios.rs b/crates/stdlib/src/termios.rs
index 48dfae25a73..de402724434 100644
--- a/crates/stdlib/src/termios.rs
+++ b/crates/stdlib/src/termios.rs
@@ -261,13 +261,12 @@ mod termios {
     }
 
     fn termios_error(err: std::io::Error, vm: &VirtualMachine) -> PyBaseExceptionRef {
-        vm.new_exception(
+        vm.new_os_subtype_error(
             error_type(vm),
-            vec![
-                err.posix_errno().to_pyobject(vm),
-                vm.ctx.new_str(err.to_string()).into(),
-            ],
+            Some(err.posix_errno()),
+            vm.ctx.new_str(err.to_string()),
         )
+        .upcast()
     }
 
     #[pyattr(name = "error", once)]
diff --git a/crates/stdlib/src/unicodedata.rs b/crates/stdlib/src/unicodedata.rs
index a859e39df10..6ee5b0c2ee8 100644
--- a/crates/stdlib/src/unicodedata.rs
+++ b/crates/stdlib/src/unicodedata.rs
@@ -20,14 +20,12 @@ enum NormalizeForm {
 impl<'a> TryFromBorrowedObject<'a> for NormalizeForm {
     fn try_from_borrowed_object(vm: &VirtualMachine, obj: &'a PyObject) -> PyResult<Self> {
         obj.try_value_with(
-            |form: &PyStr| {
-                Ok(match form.as_str() {
-                    "NFC" => Self::Nfc,
-                    "NFKC" => Self::Nfkc,
-                    "NFD" => Self::Nfd,
-                    "NFKD" => Self::Nfkd,
-                    _ => return Err(vm.new_value_error("invalid normalization form")),
-                })
+            |form: &PyStr| match form.as_bytes() {
+                b"NFC" => Ok(Self::Nfc),
+                b"NFKC" => Ok(Self::Nfkc),
+                b"NFD" => Ok(Self::Nfd),
+                b"NFKD" => Ok(Self::Nfkd),
+                _ => Err(vm.new_value_error("invalid normalization form")),
             },
             vm,
         )
@@ -36,20 +34,25 @@ impl<'a> TryFromBorrowedObject<'a> for NormalizeForm {
 
 #[pymodule]
 mod unicodedata {
+    use super::NormalizeForm::*;
     use crate::vm::{
         Py, PyObjectRef, PyPayload, PyRef, PyResult, VirtualMachine,
         builtins::{PyModule, PyStrRef},
         function::OptionalArg,
     };
+
+    use icu_normalizer::{ComposingNormalizerBorrowed, DecomposingNormalizerBorrowed};
+    use icu_properties::{
+        CodePointSetData,
+        props::{
+            BidiClass, BidiMirrored, CanonicalCombiningClass, EastAsianWidth, EnumeratedProperty,
+            GeneralCategory, NamedEnumeratedProperty,
+        },
+    };
     use itertools::Itertools;
     use rustpython_common::wtf8::{CodePoint, Wtf8Buf};
-    use ucd::{Codepoint, EastAsianWidth};
-    use unic_char_property::EnumeratedCharProperty;
-    use unic_normal::StrNormalForm;
+    use ucd::{Codepoint, DecompositionType, Number, NumericType};
     use unic_ucd_age::{Age, UNICODE_VERSION, UnicodeVersion};
-    use unic_ucd_bidi::BidiClass;
-    use unic_ucd_category::GeneralCategory;
-    use unicode_bidi_mirroring::is_mirroring;
 
     pub(crate) fn module_exec(vm: &VirtualMachine, module: &Py<PyModule>) -> PyResult<()> {
         __module_exec(vm, module);
@@ -62,9 +65,15 @@ mod unicodedata {
             "lookup",
             "name",
             "bidirectional",
+            "combining",
+            "decimal",
+            "decomposition",
+            "digit",
             "east_asian_width",
-            "normalize",
+            "is_normalized",
             "mirrored",
+            "normalize",
+            "numeric",
         ] {
             module.set_attr(attr, ucd.get_attr(attr, vm)?, vm)?;
         }
@@ -112,20 +121,25 @@ mod unicodedata {
                 .extract_char(character, vm)?
                 .map_or(GeneralCategory::Unassigned, |c| {
                     c.to_char()
-                        .map_or(GeneralCategory::Surrogate, GeneralCategory::of)
+                        .map_or(GeneralCategory::Surrogate, GeneralCategory::for_char)
                 })
-                .abbr_name()
+                .short_name()
                 .to_owned())
         }
 
         #[pymethod]
         fn lookup(&self, name: PyStrRef, vm: &VirtualMachine) -> PyResult<String> {
-            if let Some(character) = unicode_names2::character(name.as_str())
+            if let Some(name_str) = name.to_str()
+                && let Some(character) = unicode_names2::character(name_str)
                 && self.check_age(character.into())
             {
                 return Ok(character.to_string());
             }
-            Err(vm.new_lookup_error(format!("undefined character name '{name}'")))
+            Err(vm.new_key_error(
+                vm.ctx
+                    .new_str(format!("undefined character name '{name}'"))
+                    .into(),
+            ))
         }
 
         #[pymethod]
@@ -155,8 +169,8 @@ mod unicodedata {
             let bidi = match self.extract_char(character, vm)? {
                 Some(c) => c
                     .to_char()
-                    .map_or(BidiClass::LeftToRight, BidiClass::of)
-                    .abbr_name(),
+                    .map_or(BidiClass::LeftToRight, BidiClass::for_char)
+                    .short_name(),
                 None => "",
             };
             Ok(bidi)
@@ -172,30 +186,74 @@ mod unicodedata {
             Ok(self
                 .extract_char(character, vm)?
                 .and_then(|c| c.to_char())
-                .map_or(EastAsianWidth::Neutral, |c| c.east_asian_width())
-                .abbr_name())
+                .map_or(EastAsianWidth::Neutral, EastAsianWidth::for_char)
+                .short_name())
         }
 
         #[pymethod]
         fn normalize(&self, form: super::NormalizeForm, unistr: PyStrRef) -> PyResult<Wtf8Buf> {
-            use super::NormalizeForm::*;
             let text = unistr.as_wtf8();
             let normalized_text = match form {
-                Nfc => text.map_utf8(|s| s.nfc()).collect(),
-                Nfkc => text.map_utf8(|s| s.nfkc()).collect(),
-                Nfd => text.map_utf8(|s| s.nfd()).collect(),
-                Nfkd => text.map_utf8(|s| s.nfkd()).collect(),
+                Nfc => {
+                    let normalizer = ComposingNormalizerBorrowed::new_nfc();
+                    text.map_utf8(|s| normalizer.normalize_iter(s.chars()))
+                        .collect()
+                }
+                Nfkc => {
+                    let normalizer = ComposingNormalizerBorrowed::new_nfkc();
+                    text.map_utf8(|s| normalizer.normalize_iter(s.chars()))
+                        .collect()
+                }
+                Nfd => {
+                    let normalizer = DecomposingNormalizerBorrowed::new_nfd();
+                    text.map_utf8(|s| normalizer.normalize_iter(s.chars()))
+                        .collect()
+                }
+                Nfkd => {
+                    let normalizer = DecomposingNormalizerBorrowed::new_nfkd();
+                    text.map_utf8(|s| normalizer.normalize_iter(s.chars()))
+                        .collect()
+                }
             };
             Ok(normalized_text)
         }
 
+        #[pymethod]
+        fn is_normalized(&self, form: super::NormalizeForm, unistr: PyStrRef) -> PyResult<bool> {
+            let text = unistr.as_wtf8();
+            let normalized: Wtf8Buf = match form {
+                Nfc => {
+                    let normalizer = ComposingNormalizerBorrowed::new_nfc();
+                    text.map_utf8(|s| normalizer.normalize_iter(s.chars()))
+                        .collect()
+                }
+                Nfkc => {
+                    let normalizer = ComposingNormalizerBorrowed::new_nfkc();
+                    text.map_utf8(|s| normalizer.normalize_iter(s.chars()))
+                        .collect()
+                }
+                Nfd => {
+                    let normalizer = DecomposingNormalizerBorrowed::new_nfd();
+                    text.map_utf8(|s| normalizer.normalize_iter(s.chars()))
+                        .collect()
+                }
+                Nfkd => {
+                    let normalizer = DecomposingNormalizerBorrowed::new_nfkd();
+                    text.map_utf8(|s| normalizer.normalize_iter(s.chars()))
+                        .collect()
+                }
+            };
+            Ok(text == &*normalized)
+        }
+
         #[pymethod]
         fn mirrored(&self, character: PyStrRef, vm: &VirtualMachine) -> PyResult<i32> {
             match self.extract_char(character, vm)? {
                 Some(c) => {
                     if let Some(ch) = c.to_char() {
                         // Check if the character is mirrored in bidirectional text using Unicode standard
-                        Ok(if is_mirroring(ch) { 1 } else { 0 })
+                        let bidi_mirrored = CodePointSetData::new::<BidiMirrored>();
+                        Ok(if bidi_mirrored.contains(ch) { 1 } else { 0 })
                     } else {
                         Ok(0)
                     }
@@ -204,26 +262,119 @@ mod unicodedata {
             }
         }
 
+        #[pymethod]
+        fn combining(&self, character: PyStrRef, vm: &VirtualMachine) -> PyResult<u8> {
+            Ok(self
+                .extract_char(character, vm)?
+                .and_then(|c| c.to_char())
+                .map_or(0, |ch| {
+                    CanonicalCombiningClass::for_char(ch).to_icu4c_value()
+                }))
+        }
+
+        #[pymethod]
+        fn decomposition(&self, character: PyStrRef, vm: &VirtualMachine) -> PyResult<String> {
+            let ch = match self.extract_char(character, vm)?.and_then(|c| c.to_char()) {
+                Some(ch) => ch,
+                None => return Ok(String::new()),
+            };
+            let chars: Vec<char> = ch.decomposition_map().collect();
+            // If decomposition maps to just the character itself, there's no decomposition
+            if chars.len() == 1 && chars[0] == ch {
+                return Ok(String::new());
+            }
+            let hex_parts = chars.iter().map(|c| format!("{:04X}", *c as u32)).join(" ");
+            let tag = match ch.decomposition_type() {
+                Some(DecompositionType::Canonical) | None => return Ok(hex_parts),
+                Some(dt) => decomposition_type_tag(dt),
+            };
+            Ok(format!("<{tag}> {hex_parts}"))
+        }
+
+        #[pymethod]
+        fn digit(
+            &self,
+            character: PyStrRef,
+            default: OptionalArg<PyObjectRef>,
+            vm: &VirtualMachine,
+        ) -> PyResult {
+            let ch = self.extract_char(character, vm)?.and_then(|c| c.to_char());
+            if let Some(ch) = ch
+                && matches!(
+                    ch.numeric_type(),
+                    Some(NumericType::Decimal) | Some(NumericType::Digit)
+                )
+                && let Some(Number::Integer(n)) = ch.numeric_value()
+            {
+                return Ok(vm.ctx.new_int(n).into());
+            }
+            default.ok_or_else(|| vm.new_value_error("not a digit"))
+        }
+
+        #[pymethod]
+        fn decimal(
+            &self,
+            character: PyStrRef,
+            default: OptionalArg<PyObjectRef>,
+            vm: &VirtualMachine,
+        ) -> PyResult {
+            let ch = self.extract_char(character, vm)?.and_then(|c| c.to_char());
+            if let Some(ch) = ch
+                && ch.numeric_type() == Some(NumericType::Decimal)
+                && let Some(Number::Integer(n)) = ch.numeric_value()
+            {
+                return Ok(vm.ctx.new_int(n).into());
+            }
+            default.ok_or_else(|| vm.new_value_error("not a decimal"))
+        }
+
+        #[pymethod]
+        fn numeric(
+            &self,
+            character: PyStrRef,
+            default: OptionalArg<PyObjectRef>,
+            vm: &VirtualMachine,
+        ) -> PyResult {
+            let ch = self.extract_char(character, vm)?.and_then(|c| c.to_char());
+            if let Some(ch) = ch {
+                match ch.numeric_value() {
+                    Some(Number::Integer(n)) => {
+                        return Ok(vm.ctx.new_float(n as f64).into());
+                    }
+                    Some(Number::Rational(num, den)) => {
+                        return Ok(vm.ctx.new_float(num as f64 / den as f64).into());
+                    }
+                    None => {}
+                }
+            }
+            default.ok_or_else(|| vm.new_value_error("not a numeric character"))
+        }
+
         #[pygetset]
         fn unidata_version(&self) -> String {
             self.unic_version.to_string()
         }
     }
 
-    trait EastAsianWidthAbbrName {
-        fn abbr_name(&self) -> &'static str;
-    }
-
-    impl EastAsianWidthAbbrName for EastAsianWidth {
-        fn abbr_name(&self) -> &'static str {
-            match self {
-                Self::Narrow => "Na",
-                Self::Wide => "W",
-                Self::Neutral => "N",
-                Self::Ambiguous => "A",
-                Self::FullWidth => "F",
-                Self::HalfWidth => "H",
-            }
+    fn decomposition_type_tag(dt: DecompositionType) -> &'static str {
+        match dt {
+            DecompositionType::Canonical => "canonical",
+            DecompositionType::Compat => "compat",
+            DecompositionType::Circle => "circle",
+            DecompositionType::Final => "final",
+            DecompositionType::Font => "font",
+            DecompositionType::Fraction => "fraction",
+            DecompositionType::Initial => "initial",
+            DecompositionType::Isolated => "isolated",
+            DecompositionType::Medial => "medial",
+            DecompositionType::Narrow => "narrow",
+            DecompositionType::Nobreak => "noBreak",
+            DecompositionType::Small => "small",
+            DecompositionType::Square => "square",
+            DecompositionType::Sub => "sub",
+            DecompositionType::Super => "super",
+            DecompositionType::Vertical => "vertical",
+            DecompositionType::Wide => "wide",
         }
     }
 
diff --git a/crates/stdlib/src/zlib.rs b/crates/stdlib/src/zlib.rs
index 40269f12bbf..35a617ed152 100644
--- a/crates/stdlib/src/zlib.rs
+++ b/crates/stdlib/src/zlib.rs
@@ -466,7 +466,8 @@ mod zlib {
     }
 
     fn new_zlib_error(message: impl Into<String>, vm: &VirtualMachine) -> PyBaseExceptionRef {
-        vm.new_exception_msg(vm.class("zlib", "error"), message.into())
+        let msg: String = message.into();
+        vm.new_exception_msg(vm.class("zlib", "error"), msg.into())
     }
 
     struct Level(Option<flate2::Compression>);
diff --git a/crates/venvlauncher/Cargo.toml b/crates/venvlauncher/Cargo.toml
index ac3ea106b7a..c88dc5d356b 100644
--- a/crates/venvlauncher/Cargo.toml
+++ b/crates/venvlauncher/Cargo.toml
@@ -13,15 +13,5 @@ license.workspace = true
 name = "venvlaunchert"
 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/vm/Cargo.toml b/crates/vm/Cargo.toml
index da01eff65b9..b721418a4cc 100644
--- a/crates/vm/Cargo.toml
+++ b/crates/vm/Cargo.toml
@@ -10,7 +10,8 @@ repository.workspace = true
 license.workspace = true
 
 [features]
-default = ["compiler", "wasmbind", "stdio"]
+default = ["compiler", "wasmbind", "gc", "host_env", "stdio"]
+host_env = []
 stdio = []
 importlib = []
 encodings = ["importlib"]
@@ -19,6 +20,7 @@ flame-it = ["flame", "flamer"]
 freeze-stdlib = ["encodings"]
 jit = ["rustpython-jit"]
 threading = ["rustpython-common/threading"]
+gc = []
 compiler = ["parser", "codegen", "rustpython-compiler"]
 ast = ["ruff_python_ast", "ruff_text_size"]
 codegen = ["rustpython-codegen", "ast"]
@@ -61,7 +63,6 @@ num-complex = { workspace = true }
 num-integer = { workspace = true }
 num-traits = { workspace = true }
 num_enum = { workspace = true }
-once_cell = { workspace = true }
 parking_lot = { workspace = true }
 paste = { workspace = true }
 scoped-tls = { workspace = true }
@@ -71,7 +72,6 @@ static_assertions = { workspace = true }
 strum = { workspace = true }
 strum_macros = { workspace = true }
 thiserror = { workspace = true }
-thread_local = { workspace = true }
 memchr = { workspace = true }
 
 caseless = "0.2.2"
@@ -86,10 +86,7 @@ timsort = "0.1.2"
 # TODO: use unic for this; needed for title case:
 # https://github.com/RustPython/RustPython/pull/832#discussion_r275428939
 unicode-casing = { workspace = true }
-# update version all at the same time
-unic-ucd-bidi = { workspace = true }
-unic-ucd-category = { workspace = true }
-unic-ucd-ident = { workspace = true }
+icu_properties = { workspace = true }
 
 [target.'cfg(unix)'.dependencies]
 rustix = { workspace = true }
@@ -103,7 +100,7 @@ which = "8"
 errno = "0.3"
 widestring = { workspace = true }
 
-[target.'cfg(all(any(target_os = "linux", target_os = "macos", target_os = "windows"), not(any(target_env = "musl", target_env = "sgx"))))'.dependencies]
+[target.'cfg(all(any(target_os = "linux", target_os = "macos", target_os = "windows", target_os = "android"), not(any(target_env = "musl", target_env = "sgx"))))'.dependencies]
 libffi = { workspace = true, features = ["system"] }
 libloading = "0.9"
 
@@ -118,6 +115,7 @@ workspace = true
 features = [
   "Win32_Foundation",
   "Win32_Globalization",
+  "Win32_Media_Audio",
   "Win32_Networking_WinSock",
   "Win32_Security",
   "Win32_Security_Authorization",
@@ -127,6 +125,7 @@ features = [
   "Win32_System_Environment",
   "Win32_System_IO",
   "Win32_System_Ioctl",
+  "Win32_System_JobObjects",
   "Win32_System_Kernel",
   "Win32_System_LibraryLoader",
   "Win32_System_Memory",
diff --git a/crates/vm/src/anystr.rs b/crates/vm/src/anystr.rs
index 79b62a58abf..a9369bf068e 100644
--- a/crates/vm/src/anystr.rs
+++ b/crates/vm/src/anystr.rs
@@ -396,6 +396,10 @@ pub trait AnyStr {
 
     fn py_zfill(&self, width: isize) -> Vec<u8> {
         let width = width.to_usize().unwrap_or(0);
+        let char_len = self.elements().count();
+        let width = self
+            .bytes_len()
+            .saturating_add(width.saturating_sub(char_len));
         rustpython_common::str::zfill(self.as_bytes(), width)
     }
 
diff --git a/crates/vm/src/buffer.rs b/crates/vm/src/buffer.rs
index 6cbddb7333b..db58c909bca 100644
--- a/crates/vm/src/buffer.rs
+++ b/crates/vm/src/buffer.rs
@@ -228,6 +228,11 @@ impl FormatCode {
         let mut arg_count = 0usize;
         let mut codes = vec![];
         while chars.peek().is_some() {
+            // Skip whitespace before repeat count or format char
+            while let Some(b' ' | b'\t' | b'\n' | b'\r') = chars.peek() {
+                chars.next();
+            }
+
             // determine repeat operator:
             let repeat = match chars.peek() {
                 Some(b'0'..=b'9') => {
@@ -246,11 +251,6 @@ 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 = match chars.next() {
                 Some(c) => c,
@@ -725,5 +725,6 @@ pub fn struct_error_type(vm: &VirtualMachine) -> &'static PyTypeRef {
 pub fn new_struct_error(vm: &VirtualMachine, msg: impl Into<String>) -> PyBaseExceptionRef {
     // can't just STRUCT_ERROR.get().unwrap() cause this could be called before from buffer
     // machinery, independent of whether _struct was ever imported
+    let msg: String = msg.into();
     vm.new_exception_msg(struct_error_type(vm).clone(), msg.into())
 }
diff --git a/crates/vm/src/builtins/asyncgenerator.rs b/crates/vm/src/builtins/asyncgenerator.rs
index 59f94ffb312..dcb1c6d6f81 100644
--- a/crates/vm/src/builtins/asyncgenerator.rs
+++ b/crates/vm/src/builtins/asyncgenerator.rs
@@ -40,7 +40,10 @@ impl PyPayload for PyAsyncGen {
     }
 }
 
-#[pyclass(flags(DISALLOW_INSTANTIATION), with(PyRef, Representable, Destructor))]
+#[pyclass(
+    flags(DISALLOW_INSTANTIATION, HAS_WEAKREF),
+    with(PyRef, Representable, Destructor)
+)]
 impl PyAsyncGen {
     pub const fn as_coro(&self) -> &Coro {
         &self.inner
@@ -180,6 +183,7 @@ impl PyRef<PyAsyncGen> {
         exc_tb: OptionalArg,
         vm: &VirtualMachine,
     ) -> PyResult<PyAsyncGenAThrow> {
+        warn_deprecated_throw_signature(&exc_val, &exc_tb, vm)?;
         PyAsyncGen::init_hooks(&self, vm)?;
         Ok(PyAsyncGenAThrow {
             ag: self,
@@ -328,7 +332,7 @@ impl PyAsyncGenASend {
         let res = self.ag.inner.send(self.ag.as_object(), val, vm);
         let res = PyAsyncGenWrappedValue::unbox(&self.ag, res, vm);
         if res.is_err() {
-            self.close();
+            self.set_closed();
         }
         res
     }
@@ -341,8 +345,23 @@ impl PyAsyncGenASend {
         exc_tb: OptionalArg,
         vm: &VirtualMachine,
     ) -> PyResult {
-        if let AwaitableState::Closed = self.state.load() {
-            return Err(vm.new_runtime_error("cannot reuse already awaited __anext__()/asend()"));
+        match self.state.load() {
+            AwaitableState::Closed => {
+                return Err(
+                    vm.new_runtime_error("cannot reuse already awaited __anext__()/asend()")
+                );
+            }
+            AwaitableState::Init => {
+                if self.ag.running_async.load() {
+                    self.state.store(AwaitableState::Closed);
+                    return Err(
+                        vm.new_runtime_error("anext(): asynchronous generator is already running")
+                    );
+                }
+                self.ag.running_async.store(true);
+                self.state.store(AwaitableState::Iter);
+            }
+            AwaitableState::Iter => {}
         }
 
         warn_deprecated_throw_signature(&exc_val, &exc_tb, vm)?;
@@ -355,13 +374,36 @@ impl PyAsyncGenASend {
         );
         let res = PyAsyncGenWrappedValue::unbox(&self.ag, res, vm);
         if res.is_err() {
-            self.close();
+            self.set_closed();
         }
         res
     }
 
     #[pymethod]
-    fn close(&self) {
+    fn close(&self, vm: &VirtualMachine) -> PyResult<()> {
+        if matches!(self.state.load(), AwaitableState::Closed) {
+            return Ok(());
+        }
+        let result = self.throw(
+            vm.ctx.exceptions.generator_exit.to_owned().into(),
+            OptionalArg::Missing,
+            OptionalArg::Missing,
+            vm,
+        );
+        match result {
+            Ok(_) => Err(vm.new_runtime_error("coroutine ignored GeneratorExit")),
+            Err(e)
+                if e.fast_isinstance(vm.ctx.exceptions.stop_iteration)
+                    || e.fast_isinstance(vm.ctx.exceptions.stop_async_iteration)
+                    || e.fast_isinstance(vm.ctx.exceptions.generator_exit) =>
+            {
+                Ok(())
+            }
+            Err(e) => Err(e),
+        }
+    }
+
+    fn set_closed(&self) {
         self.state.store(AwaitableState::Closed);
     }
 }
@@ -472,6 +514,30 @@ impl PyAsyncGenAThrow {
         exc_tb: OptionalArg,
         vm: &VirtualMachine,
     ) -> PyResult {
+        match self.state.load() {
+            AwaitableState::Closed => {
+                return Err(vm.new_runtime_error("cannot reuse already awaited aclose()/athrow()"));
+            }
+            AwaitableState::Init => {
+                if self.ag.running_async.load() {
+                    self.state.store(AwaitableState::Closed);
+                    let msg = if self.aclose {
+                        "aclose(): asynchronous generator is already running"
+                    } else {
+                        "athrow(): asynchronous generator is already running"
+                    };
+                    return Err(vm.new_runtime_error(msg.to_owned()));
+                }
+                if self.ag.inner.closed() {
+                    self.state.store(AwaitableState::Closed);
+                    return Err(vm.new_stop_iteration(None));
+                }
+                self.ag.running_async.store(true);
+                self.state.store(AwaitableState::Iter);
+            }
+            AwaitableState::Iter => {}
+        }
+
         warn_deprecated_throw_signature(&exc_val, &exc_tb, vm)?;
         let ret = self.ag.inner.throw(
             self.ag.as_object(),
@@ -493,8 +559,27 @@ impl PyAsyncGenAThrow {
     }
 
     #[pymethod]
-    fn close(&self) {
-        self.state.store(AwaitableState::Closed);
+    fn close(&self, vm: &VirtualMachine) -> PyResult<()> {
+        if matches!(self.state.load(), AwaitableState::Closed) {
+            return Ok(());
+        }
+        let result = self.throw(
+            vm.ctx.exceptions.generator_exit.to_owned().into(),
+            OptionalArg::Missing,
+            OptionalArg::Missing,
+            vm,
+        );
+        match result {
+            Ok(_) => Err(vm.new_runtime_error("coroutine ignored GeneratorExit")),
+            Err(e)
+                if e.fast_isinstance(vm.ctx.exceptions.stop_iteration)
+                    || e.fast_isinstance(vm.ctx.exceptions.stop_async_iteration)
+                    || e.fast_isinstance(vm.ctx.exceptions.generator_exit) =>
+            {
+                Ok(())
+            }
+            Err(e) => Err(e),
+        }
     }
 
     fn ignored_close(&self, res: &PyResult<PyIterReturn>) -> bool {
@@ -596,35 +681,25 @@ impl PyAnextAwaitable {
         let awaitable = if wrapped.class().is(vm.ctx.types.coroutine_type) {
             // Coroutine - get __await__ later
             wrapped.clone()
-        } else if let Some(generator) = wrapped.downcast_ref::<PyGenerator>() {
-            // Generator with CO_ITERABLE_COROUTINE flag can be awaited
-            // (e.g., generators decorated with @types.coroutine)
-            if generator
-                .as_coro()
-                .frame()
-                .code
-                .flags
-                .contains(crate::bytecode::CodeFlags::ITERABLE_COROUTINE)
+        } else {
+            // Check for generator with CO_ITERABLE_COROUTINE flag
+            if let Some(generator) = wrapped.downcast_ref::<PyGenerator>()
+                && generator
+                    .as_coro()
+                    .frame()
+                    .code
+                    .flags
+                    .contains(crate::bytecode::CodeFlags::ITERABLE_COROUTINE)
             {
                 // Return the generator itself as the iterator
                 return Ok(wrapped.clone());
             }
-            // Fall through: try to get __await__ method for generator subclasses
-            if let Some(await_method) = vm.get_method(wrapped.clone(), identifier!(vm, __await__)) {
-                await_method?.call((), vm)?
-            } else {
-                return Err(vm.new_type_error(format!(
-                    "object {} can't be used in 'await' expression",
-                    wrapped.class().name()
-                )));
-            }
-        } else {
             // Try to get __await__ method
             if let Some(await_method) = vm.get_method(wrapped.clone(), identifier!(vm, __await__)) {
                 await_method?.call((), vm)?
             } else {
                 return Err(vm.new_type_error(format!(
-                    "object {} can't be used in 'await' expression",
+                    "'{}' object can't be awaited",
                     wrapped.class().name()
                 )));
             }
@@ -732,7 +807,13 @@ impl Destructor for PyAsyncGen {
     }
 }
 
-pub fn init(ctx: &Context) {
+impl Drop for PyAsyncGen {
+    fn drop(&mut self) {
+        self.inner.frame().clear_generator();
+    }
+}
+
+pub fn init(ctx: &'static Context) {
     PyAsyncGen::extend_class(ctx, ctx.types.async_generator);
     PyAsyncGenASend::extend_class(ctx, ctx.types.async_generator_asend);
     PyAsyncGenAThrow::extend_class(ctx, ctx.types.async_generator_athrow);
diff --git a/crates/vm/src/builtins/bool.rs b/crates/vm/src/builtins/bool.rs
index 24ded08ab10..2177a890877 100644
--- a/crates/vm/src/builtins/bool.rs
+++ b/crates/vm/src/builtins/bool.rs
@@ -1,4 +1,4 @@
-use super::{PyInt, PyStrRef, PyType, PyTypeRef};
+use super::{PyInt, PyStrRef, PyType, PyTypeRef, PyUtf8StrRef};
 use crate::common::format::FormatSpec;
 use crate::{
     AsObject, Context, Py, PyObject, PyObjectRef, PyResult, TryFromBorrowedObject, VirtualMachine,
@@ -101,7 +101,7 @@ impl Constructor for PyBool {
 #[pyclass(with(Constructor, AsNumber, Representable), flags(_MATCH_SELF))]
 impl PyBool {
     #[pymethod]
-    fn __format__(obj: PyObjectRef, spec: PyStrRef, vm: &VirtualMachine) -> PyResult<String> {
+    fn __format__(obj: PyObjectRef, spec: PyUtf8StrRef, vm: &VirtualMachine) -> PyResult<String> {
         let new_bool = obj.try_to_bool(vm)?;
         FormatSpec::parse(spec.as_str())
             .and_then(|format_spec| format_spec.format_bool(new_bool))
@@ -182,8 +182,26 @@ impl Representable for PyBool {
     }
 }
 
-pub(crate) fn init(context: &Context) {
+fn vectorcall_bool(
+    zelf_obj: &PyObject,
+    args: Vec<PyObjectRef>,
+    nargs: usize,
+    kwnames: Option<&[PyObjectRef]>,
+    vm: &VirtualMachine,
+) -> PyResult {
+    let zelf: &Py<PyType> = zelf_obj.downcast_ref().unwrap();
+    let func_args = FuncArgs::from_vectorcall_owned(args, nargs, kwnames);
+    (zelf.slots.new.load().unwrap())(zelf.to_owned(), func_args, vm)
+}
+
+pub(crate) fn init(context: &'static Context) {
     PyBool::extend_class(context, context.types.bool_type);
+    context
+        .types
+        .bool_type
+        .slots
+        .vectorcall
+        .store(Some(vectorcall_bool));
 }
 
 // pub fn not(vm: &VirtualMachine, obj: &PyObject) -> PyResult<bool> {
diff --git a/crates/vm/src/builtins/builtin_func.rs b/crates/vm/src/builtins/builtin_func.rs
index 422f922df94..1326febd000 100644
--- a/crates/vm/src/builtins/builtin_func.rs
+++ b/crates/vm/src/builtins/builtin_func.rs
@@ -10,11 +10,14 @@ use crate::{
 use alloc::fmt;
 
 // PyCFunctionObject in CPython
+#[repr(C)]
 #[pyclass(name = "builtin_function_or_method", module = false)]
 pub struct PyNativeFunction {
     pub(crate) value: &'static PyMethodDef,
     pub(crate) zelf: Option<PyObjectRef>,
     pub(crate) module: Option<&'static PyStrInterned>, // None for bound method
+    /// Prevent HeapMethodDef from being freed while this function references it
+    pub(crate) _method_def_owner: Option<PyObjectRef>,
 }
 
 impl PyPayload for PyNativeFunction {
@@ -68,13 +71,65 @@ impl Callable for PyNativeFunction {
     #[inline]
     fn call(zelf: &Py<Self>, mut args: FuncArgs, vm: &VirtualMachine) -> PyResult {
         if let Some(z) = &zelf.zelf {
-            args.prepend_arg(z.clone());
+            // STATIC methods store the class in zelf for qualname/repr purposes,
+            // but should not prepend it to args (the Rust function doesn't expect it).
+            if !zelf.value.flags.contains(PyMethodFlags::STATIC) {
+                args.prepend_arg(z.clone());
+            }
         }
         (zelf.value.func)(vm, args)
     }
 }
 
-#[pyclass(with(Callable), flags(HAS_DICT, DISALLOW_INSTANTIATION))]
+// meth_richcompare in CPython
+impl Comparable for PyNativeFunction {
+    fn cmp(
+        zelf: &Py<Self>,
+        other: &PyObject,
+        op: PyComparisonOp,
+        _vm: &VirtualMachine,
+    ) -> PyResult<PyComparisonValue> {
+        op.eq_only(|| {
+            if let Some(other) = other.downcast_ref::<Self>() {
+                let eq = match (zelf.zelf.as_ref(), other.zelf.as_ref()) {
+                    (Some(z), Some(o)) => z.is(o),
+                    (None, None) => true,
+                    _ => false,
+                };
+                let eq = eq && core::ptr::eq(zelf.value, other.value);
+                Ok(eq.into())
+            } else {
+                Ok(PyComparisonValue::NotImplemented)
+            }
+        })
+    }
+}
+
+// meth_repr in CPython
+impl Representable for PyNativeFunction {
+    #[inline]
+    fn repr_str(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<String> {
+        if let Some(bound) = zelf
+            .zelf
+            .as_ref()
+            .filter(|b| !b.class().is(vm.ctx.types.module_type))
+        {
+            Ok(format!(
+                "<built-in method {} of {} object at {:#x}>",
+                zelf.value.name,
+                bound.class().name(),
+                bound.get_id()
+            ))
+        } else {
+            Ok(format!("<built-in function {}>", zelf.value.name))
+        }
+    }
+}
+
+#[pyclass(
+    with(Callable, Comparable, Representable),
+    flags(HAS_DICT, HAS_WEAKREF, DISALLOW_INSTANTIATION)
+)]
 impl PyNativeFunction {
     #[pygetset]
     fn __module__(zelf: NativeFunctionOrMethod) -> Option<&'static PyStrInterned> {
@@ -86,20 +141,19 @@ impl PyNativeFunction {
         zelf.0.value.name
     }
 
+    // meth_get__qualname__ in CPython
     #[pygetset]
     fn __qualname__(zelf: NativeFunctionOrMethod, vm: &VirtualMachine) -> PyResult<PyStrRef> {
         let zelf = zelf.0;
-        let flags = zelf.value.flags;
-        // if flags.contains(PyMethodFlags::CLASS) || flags.contains(PyMethodFlags::STATIC) {
         let qualname = if let Some(bound) = &zelf.zelf {
-            let prefix = if flags.contains(PyMethodFlags::CLASS) {
-                bound
-                    .get_attr("__qualname__", vm)
-                    .unwrap()
-                    .str(vm)
-                    .unwrap()
-                    .to_string()
+            if bound.class().is(vm.ctx.types.module_type) {
+                return Ok(vm.ctx.intern_str(zelf.value.name).to_owned());
+            }
+            let prefix = if bound.class().is(vm.ctx.types.type_type) {
+                // m_self is a type: use PyType_GetQualName(m_self)
+                bound.get_attr("__qualname__", vm)?.str(vm)?.to_string()
             } else {
+                // m_self is an instance: use Py_TYPE(m_self).__qualname__
                 bound.class().name().to_string()
             };
             vm.ctx.new_str(format!("{}.{}", prefix, &zelf.value.name))
@@ -114,15 +168,23 @@ impl PyNativeFunction {
         zelf.0.value.doc
     }
 
+    // meth_get__self__ in CPython
     #[pygetset]
-    fn __self__(_zelf: PyObjectRef, vm: &VirtualMachine) -> PyObjectRef {
-        vm.ctx.none()
+    fn __self__(zelf: NativeFunctionOrMethod, vm: &VirtualMachine) -> PyObjectRef {
+        zelf.0.zelf.clone().unwrap_or_else(|| vm.ctx.none())
     }
 
+    // meth_reduce in CPython
     #[pymethod]
-    const fn __reduce__(&self) -> &'static str {
-        // TODO: return (getattr, (self.object, self.name)) if this is a method
-        self.value.name
+    fn __reduce__(zelf: NativeFunctionOrMethod, vm: &VirtualMachine) -> PyResult {
+        let zelf = zelf.0;
+        if zelf.zelf.is_none() || zelf.module.is_some() {
+            Ok(vm.ctx.new_str(zelf.value.name).into())
+        } else {
+            let getattr = vm.builtins.get_attr("getattr", vm)?;
+            let target = zelf.zelf.clone().unwrap();
+            Ok(vm.new_tuple((getattr, (target, zelf.value.name))).into())
+        }
     }
 
     #[pymethod]
@@ -138,54 +200,20 @@ impl PyNativeFunction {
     }
 }
 
-impl Representable for PyNativeFunction {
-    #[inline]
-    fn repr_str(zelf: &Py<Self>, _vm: &VirtualMachine) -> PyResult<String> {
-        Ok(format!("<built-in function {}>", zelf.value.name))
-    }
-}
-
-// `PyCMethodObject` in CPython
-#[pyclass(name = "builtin_method", module = false, base = PyNativeFunction, ctx = "builtin_method_type")]
+// PyCMethodObject in CPython
+// repr(C) ensures `func` is at offset 0, allowing safe cast from PyNativeMethod to PyNativeFunction
+#[repr(C)]
+#[pyclass(name = "builtin_function_or_method", module = false, base = PyNativeFunction, ctx = "builtin_function_or_method_type")]
 pub struct PyNativeMethod {
     pub(crate) func: PyNativeFunction,
     pub(crate) class: &'static Py<PyType>, // TODO: the actual life is &'self
 }
 
-#[pyclass(
-    with(Callable, Comparable, Representable),
-    flags(HAS_DICT, DISALLOW_INSTANTIATION)
-)]
-impl PyNativeMethod {
-    #[pygetset]
-    fn __qualname__(zelf: PyRef<Self>, vm: &VirtualMachine) -> PyResult<PyStrRef> {
-        let prefix = zelf.class.name().to_string();
-        Ok(vm
-            .ctx
-            .new_str(format!("{}.{}", prefix, &zelf.func.value.name)))
-    }
-
-    #[pymethod]
-    fn __reduce__(
-        &self,
-        vm: &VirtualMachine,
-    ) -> PyResult<(PyObjectRef, (PyObjectRef, &'static str))> {
-        // TODO: return (getattr, (self.object, self.name)) if this is a method
-        let getattr = vm.builtins.get_attr("getattr", vm)?;
-        let target = self
-            .func
-            .zelf
-            .clone()
-            .unwrap_or_else(|| self.class.to_owned().into());
-        let name = self.func.value.name;
-        Ok((getattr, (target, name)))
-    }
-
-    #[pygetset]
-    fn __self__(zelf: PyRef<Self>, _vm: &VirtualMachine) -> Option<PyObjectRef> {
-        zelf.func.zelf.clone()
-    }
-}
+// All Python-visible behavior (getters, slots) is registered by PyNativeFunction::extend_class.
+// PyNativeMethod only extends the Rust-side struct with the defining class reference.
+// The func field at offset 0 (#[repr(C)]) allows NativeFunctionOrMethod to read it safely.
+#[pyclass(flags(HAS_DICT, HAS_WEAKREF, DISALLOW_INSTANTIATION))]
+impl PyNativeMethod {}
 
 impl fmt::Debug for PyNativeMethod {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
@@ -198,63 +226,57 @@ impl fmt::Debug for PyNativeMethod {
     }
 }
 
-impl Comparable for PyNativeMethod {
-    fn cmp(
-        zelf: &Py<Self>,
-        other: &PyObject,
-        op: PyComparisonOp,
-        _vm: &VirtualMachine,
-    ) -> PyResult<PyComparisonValue> {
-        op.eq_only(|| {
-            if let Some(other) = other.downcast_ref::<Self>() {
-                let eq = match (zelf.func.zelf.as_ref(), other.func.zelf.as_ref()) {
-                    (Some(z), Some(o)) => z.is(o),
-                    (None, None) => true,
-                    _ => false,
-                };
-                let eq = eq && core::ptr::eq(zelf.func.value, other.func.value);
-                Ok(eq.into())
-            } else {
-                Ok(PyComparisonValue::NotImplemented)
-            }
-        })
-    }
-}
+/// Vectorcall for builtin functions (PEP 590).
+/// Avoids `prepend_arg` O(n) shift by building args with self at front.
+fn vectorcall_native_function(
+    zelf_obj: &PyObject,
+    args: Vec<PyObjectRef>,
+    nargs: usize,
+    kwnames: Option<&[PyObjectRef]>,
+    vm: &VirtualMachine,
+) -> PyResult {
+    let zelf: &Py<PyNativeFunction> = zelf_obj.downcast_ref().unwrap();
 
-impl Callable for PyNativeMethod {
-    type Args = FuncArgs;
+    // Build FuncArgs with self already at position 0 (no insert(0) needed)
+    let needs_self = zelf
+        .zelf
+        .as_ref()
+        .is_some_and(|_| !zelf.value.flags.contains(PyMethodFlags::STATIC));
 
-    #[inline]
-    fn call(zelf: &Py<Self>, mut args: FuncArgs, vm: &VirtualMachine) -> PyResult {
-        if let Some(zelf) = &zelf.func.zelf {
-            args.prepend_arg(zelf.clone());
-        }
-        (zelf.func.value.func)(vm, args)
-    }
-}
+    let func_args = if needs_self {
+        let self_obj = zelf.zelf.as_ref().unwrap().clone();
+        let mut all_args = Vec::with_capacity(args.len() + 1);
+        all_args.push(self_obj);
+        all_args.extend(args);
+        FuncArgs::from_vectorcall(&all_args, nargs + 1, kwnames)
+    } else {
+        FuncArgs::from_vectorcall(&args, nargs, kwnames)
+    };
 
-impl Representable for PyNativeMethod {
-    #[inline]
-    fn repr_str(zelf: &Py<Self>, _vm: &VirtualMachine) -> PyResult<String> {
-        Ok(format!(
-            "<built-in method {} of {} object at ...>",
-            &zelf.func.value.name,
-            zelf.class.name()
-        ))
-    }
+    (zelf.value.func)(vm, func_args)
 }
 
-pub fn init(context: &Context) {
+pub fn init(context: &'static Context) {
     PyNativeFunction::extend_class(context, context.types.builtin_function_or_method_type);
-    PyNativeMethod::extend_class(context, context.types.builtin_method_type);
+    context
+        .types
+        .builtin_function_or_method_type
+        .slots
+        .vectorcall
+        .store(Some(vectorcall_native_function));
 }
 
+/// Wrapper that provides access to the common PyNativeFunction data
+/// for both PyNativeFunction and PyNativeMethod (which has func as its first field).
 struct NativeFunctionOrMethod(PyRef<PyNativeFunction>);
 
 impl TryFromObject for NativeFunctionOrMethod {
     fn try_from_object(vm: &VirtualMachine, obj: PyObjectRef) -> PyResult<Self> {
         let class = vm.ctx.types.builtin_function_or_method_type;
         if obj.fast_isinstance(class) {
+            // Both PyNativeFunction and PyNativeMethod share the same type now.
+            // PyNativeMethod has `func: PyNativeFunction` as its first field,
+            // so we can safely treat the data pointer as PyNativeFunction for reading.
             Ok(Self(unsafe { obj.downcast_unchecked() }))
         } else {
             Err(vm.new_downcast_type_error(class, &obj))
diff --git a/crates/vm/src/builtins/bytearray.rs b/crates/vm/src/builtins/bytearray.rs
index 5a3aee59072..0285526692c 100644
--- a/crates/vm/src/builtins/bytearray.rs
+++ b/crates/vm/src/builtins/bytearray.rs
@@ -1,7 +1,7 @@
 //! Implementation of the python bytearray object.
 use super::{
     PositionIterInternal, PyBytes, PyBytesRef, PyDictRef, PyGenericAlias, PyIntRef, PyStrRef,
-    PyTuple, PyTupleRef, PyType, PyTypeRef,
+    PyTuple, PyTupleRef, PyType, PyTypeRef, iter::builtins_iter,
 };
 use crate::{
     AsObject, Context, Py, PyObject, PyObjectRef, PyPayload, PyRef, PyResult, TryFromObject,
@@ -67,7 +67,7 @@ impl PyPayload for PyByteArray {
 }
 
 /// Fill bytearray class methods dictionary.
-pub(crate) fn init(context: &Context) {
+pub(crate) fn init(context: &'static Context) {
     PyByteArray::extend_class(context, context.types.bytearray_type);
     PyByteArrayIterator::extend_class(context, context.types.bytearray_iterator_type);
 }
@@ -215,6 +215,15 @@ impl PyByteArray {
         size_of::<Self>() + self.borrow_buf().len() * size_of::<u8>()
     }
 
+    #[pyslot]
+    fn slot_str(zelf: &PyObject, vm: &VirtualMachine) -> PyResult<PyStrRef> {
+        let zelf = zelf.downcast_ref::<Self>().expect("expected bytearray");
+        PyBytesInner::warn_on_str("str() on a bytearray instance", vm)?;
+        let class_name = zelf.class().name();
+        let repr = zelf.inner().repr_with_name(&class_name, vm)?;
+        Ok(vm.ctx.new_str(repr))
+    }
+
     fn __add__(&self, other: ArgBytesLike) -> Self {
         self.inner().add(&other.borrow_buf()).into()
     }
@@ -538,6 +547,15 @@ impl PyByteArray {
         self.borrow_buf_mut().reverse();
     }
 
+    #[pymethod]
+    fn resize(&self, size: isize, vm: &VirtualMachine) -> PyResult<()> {
+        if size < 0 {
+            return Err(vm.new_value_error("bytearray.resize(): new size must be >= 0"));
+        }
+        self.try_resizable(vm)?.elements.resize(size as usize, 0);
+        Ok(())
+    }
+
     // TODO: Uncomment when Python adds __class_getitem__ to bytearray
     // #[pyclassmethod]
     fn __class_getitem__(cls: PyTypeRef, args: PyObjectRef, vm: &VirtualMachine) -> PyGenericAlias {
@@ -857,9 +875,13 @@ impl PyByteArrayIterator {
     }
     #[pymethod]
     fn __reduce__(&self, vm: &VirtualMachine) -> PyTupleRef {
-        self.internal
-            .lock()
-            .builtins_iter_reduce(|x| x.clone().into(), vm)
+        let func = builtins_iter(vm);
+        self.internal.lock().reduce(
+            func,
+            |x| x.clone().into(),
+            |vm| vm.ctx.empty_tuple.clone().into(),
+            vm,
+        )
     }
 
     #[pymethod]
diff --git a/crates/vm/src/builtins/bytes.rs b/crates/vm/src/builtins/bytes.rs
index 64e00cdc919..00cf3d2d113 100644
--- a/crates/vm/src/builtins/bytes.rs
+++ b/crates/vm/src/builtins/bytes.rs
@@ -1,7 +1,8 @@
 use super::{
     PositionIterInternal, PyDictRef, PyGenericAlias, PyIntRef, PyStrRef, PyTuple, PyTupleRef,
-    PyType, PyTypeRef,
+    PyType, PyTypeRef, iter::builtins_iter,
 };
+use crate::common::lock::LazyLock;
 use crate::{
     AsObject, Context, Py, PyObject, PyObjectRef, PyPayload, PyRef, PyResult,
     TryFromBorrowedObject, TryFromObject, VirtualMachine,
@@ -30,7 +31,6 @@ use crate::{
 };
 use bstr::ByteSlice;
 use core::{mem::size_of, ops::Deref};
-use std::sync::LazyLock;
 
 #[pyclass(module = false, name = "bytes")]
 #[derive(Clone, Debug)]
@@ -86,7 +86,7 @@ impl PyPayload for PyBytes {
     }
 }
 
-pub(crate) fn init(context: &Context) {
+pub(crate) fn init(context: &'static Context) {
     PyBytes::extend_class(context, context.types.bytes_type);
     PyBytesIterator::extend_class(context, context.types.bytes_iterator_type);
 }
@@ -224,6 +224,13 @@ impl PyBytes {
         size_of::<Self>() + self.len() * size_of::<u8>()
     }
 
+    #[pyslot]
+    fn slot_str(zelf: &PyObject, vm: &VirtualMachine) -> PyResult<PyStrRef> {
+        let zelf = zelf.downcast_ref::<Self>().expect("expected bytes");
+        PyBytesInner::warn_on_str("str() on a bytes instance", vm)?;
+        Ok(vm.ctx.new_str(zelf.inner.repr_bytes(vm)?))
+    }
+
     fn __add__(&self, other: ArgBytesLike) -> Vec<u8> {
         self.inner.add(&other.borrow_buf())
     }
@@ -747,9 +754,13 @@ impl PyBytesIterator {
 
     #[pymethod]
     fn __reduce__(&self, vm: &VirtualMachine) -> PyTupleRef {
-        self.internal
-            .lock()
-            .builtins_iter_reduce(|x| x.clone().into(), vm)
+        let func = builtins_iter(vm);
+        self.internal.lock().reduce(
+            func,
+            |x| x.clone().into(),
+            |vm| vm.ctx.empty_tuple.clone().into(),
+            vm,
+        )
     }
 
     #[pymethod]
diff --git a/crates/vm/src/builtins/capsule.rs b/crates/vm/src/builtins/capsule.rs
new file mode 100644
index 00000000000..c9c7fd2849d
--- /dev/null
+++ b/crates/vm/src/builtins/capsule.rs
@@ -0,0 +1,33 @@
+use super::PyType;
+use crate::{Context, Py, PyPayload, PyResult, class::PyClassImpl, types::Representable};
+
+/// PyCapsule - a container for C pointers.
+/// In RustPython, this is a minimal implementation for compatibility.
+#[pyclass(module = false, name = "PyCapsule")]
+#[derive(Debug, Clone, Copy)]
+pub struct PyCapsule {
+    // Capsules store opaque pointers; we don't expose the actual pointer functionality
+    // since RustPython doesn't have the same C extension model as CPython.
+    _private: (),
+}
+
+impl PyPayload for PyCapsule {
+    #[inline]
+    fn class(ctx: &Context) -> &'static Py<PyType> {
+        ctx.types.capsule_type
+    }
+}
+
+#[pyclass(with(Representable), flags(DISALLOW_INSTANTIATION))]
+impl PyCapsule {}
+
+impl Representable for PyCapsule {
+    #[inline]
+    fn repr_str(_zelf: &Py<Self>, _vm: &crate::VirtualMachine) -> PyResult<String> {
+        Ok("<capsule object>".to_string())
+    }
+}
+
+pub fn init(context: &'static Context) {
+    PyCapsule::extend_class(context, context.types.capsule_type);
+}
diff --git a/crates/vm/src/builtins/classmethod.rs b/crates/vm/src/builtins/classmethod.rs
index d2f1377be04..8955d31ce40 100644
--- a/crates/vm/src/builtins/classmethod.rs
+++ b/crates/vm/src/builtins/classmethod.rs
@@ -57,13 +57,8 @@ impl GetDescriptor for PyClassMethod {
     ) -> PyResult {
         let (zelf, _obj) = Self::_unwrap(&zelf, obj, vm)?;
         let cls = cls.unwrap_or_else(|| _obj.class().to_owned().into());
-        // 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, callable).into_ref(&vm.ctx).into()),
-            Ok(call_descr_get) => call_descr_get.call((cls.clone(), cls), vm),
-        }
+        Ok(PyBoundMethod::new(cls, callable).into_ref(&vm.ctx).into())
     }
 }
 
@@ -125,7 +120,7 @@ impl PyClassMethod {
 
 #[pyclass(
     with(GetDescriptor, Constructor, Initializer, Representable),
-    flags(BASETYPE, HAS_DICT)
+    flags(BASETYPE, HAS_DICT, HAS_WEAKREF)
 )]
 impl PyClassMethod {
     #[pygetset]
@@ -211,11 +206,11 @@ impl Representable for PyClassMethod {
             class
                 .__qualname__(vm)
                 .downcast_ref::<PyStr>()
-                .map(|n| n.as_str()),
+                .map(|n| n.as_wtf8()),
             class
                 .__module__(vm)
                 .downcast_ref::<PyStr>()
-                .map(|m| m.as_str()),
+                .map(|m| m.as_wtf8()),
         ) {
             (None, _) => return Err(vm.new_type_error("Unknown qualified name")),
             (Some(qualname), Some(module)) if module != "builtins" => {
@@ -227,6 +222,6 @@ impl Representable for PyClassMethod {
     }
 }
 
-pub(crate) fn init(context: &Context) {
+pub(crate) fn init(context: &'static Context) {
     PyClassMethod::extend_class(context, context.types.classmethod_type);
 }
diff --git a/crates/vm/src/builtins/code.rs b/crates/vm/src/builtins/code.rs
index 932100db94f..0ddbd9b8513 100644
--- a/crates/vm/src/builtins/code.rs
+++ b/crates/vm/src/builtins/code.rs
@@ -1,18 +1,23 @@
 //! Infamous code object. The python class `code`
 
 use super::{PyBytesRef, PyStrRef, PyTupleRef, PyType};
+use crate::common::lock::PyMutex;
 use crate::{
     AsObject, Context, Py, PyObject, PyObjectRef, PyPayload, PyRef, PyResult, VirtualMachine,
     builtins::PyStrInterned,
-    bytecode::{self, AsBag, BorrowedConstant, CodeFlags, Constant, ConstantBag},
+    bytecode::{self, AsBag, BorrowedConstant, CodeFlags, Constant, ConstantBag, Instruction},
     class::{PyClassImpl, StaticType},
     convert::{ToPyException, ToPyObject},
     frozen,
     function::OptionalArg,
-    types::{Constructor, Representable},
+    types::{Comparable, Constructor, Hashable, Representable},
 };
 use alloc::fmt;
-use core::{borrow::Borrow, ops::Deref};
+use core::{
+    borrow::Borrow,
+    ops::Deref,
+    sync::atomic::{AtomicPtr, AtomicU64, Ordering},
+};
 use malachite_bigint::BigInt;
 use num_traits::Zero;
 use rustpython_compiler_core::{OneIndexed, bytecode::CodeUnits, bytecode::PyCodeLocationInfoKind};
@@ -189,6 +194,12 @@ impl From<Literal> for PyObjectRef {
     }
 }
 
+impl From<PyObjectRef> for Literal {
+    fn from(obj: PyObjectRef) -> Self {
+        Literal(obj)
+    }
+}
+
 fn borrow_obj_constant(obj: &PyObject) -> BorrowedConstant<'_, Literal> {
     match_class!(match obj {
         ref i @ super::int::PyInt => {
@@ -221,6 +232,23 @@ fn borrow_obj_constant(obj: &PyObject) -> BorrowedConstant<'_, Literal> {
         }
         super::singletons::PyNone => BorrowedConstant::None,
         super::slice::PyEllipsis => BorrowedConstant::Ellipsis,
+        ref s @ super::slice::PySlice => {
+            // Constant pool slices always store Some() for start/step (even for None).
+            // Box::leak the array so it outlives the borrow. Leak is acceptable since
+            // constant pool objects live for the program's lifetime.
+            let start = s.start.clone().unwrap();
+            let stop = s.stop.clone();
+            let step = s.step.clone().unwrap();
+            let arr = Box::leak(Box::new([Literal(start), Literal(stop), Literal(step)]));
+            BorrowedConstant::Slice { elements: arr }
+        }
+        ref fs @ super::set::PyFrozenSet => {
+            // Box::leak the elements so they outlive the borrow. Leak is acceptable since
+            // constant pool objects live for the program's lifetime.
+            let elems: Vec<Literal> = fs.elements().into_iter().map(Literal).collect();
+            let elements = Box::leak(elems.into_boxed_slice());
+            BorrowedConstant::Frozenset { elements }
+        }
         _ => panic!("unexpected payload for constant python value"),
     })
 }
@@ -272,6 +300,30 @@ impl ConstantBag for PyObjBag<'_> {
                     .collect();
                 ctx.new_tuple(elements).into()
             }
+            BorrowedConstant::Slice { elements } => {
+                let [start, stop, step] = elements;
+                let start_obj = self.make_constant(start.borrow_constant()).0;
+                let stop_obj = self.make_constant(stop.borrow_constant()).0;
+                let step_obj = self.make_constant(step.borrow_constant()).0;
+                // Store as PySlice with Some() for all fields (even None values)
+                // so borrow_obj_constant can reference them.
+                use crate::builtins::PySlice;
+                PySlice {
+                    start: Some(start_obj),
+                    stop: stop_obj,
+                    step: Some(step_obj),
+                }
+                .into_ref(ctx)
+                .into()
+            }
+            BorrowedConstant::Frozenset { elements: _ } => {
+                // Creating a frozenset requires VirtualMachine for element hashing.
+                // PyObjBag only has Context, so we cannot construct PyFrozenSet here.
+                // Frozenset constants from .pyc are handled by PyMarshalBag which has VM access.
+                unimplemented!(
+                    "frozenset constant in PyObjBag::make_constant requires VirtualMachine"
+                )
+            }
             BorrowedConstant::None => ctx.none(),
             BorrowedConstant::Ellipsis => ctx.ellipsis.clone().into(),
         };
@@ -320,9 +372,29 @@ impl<B: AsRef<[u8]>> IntoCodeObject for frozen::FrozenCodeObject<B> {
     }
 }
 
+/// Per-code-object monitoring data (_PyCoMonitoringData).
+/// Stores original opcodes displaced by INSTRUMENTED_LINE / INSTRUMENTED_INSTRUCTION.
+pub struct CoMonitoringData {
+    /// Original opcodes at positions with INSTRUMENTED_LINE.
+    /// Indexed by instruction index. 0 = not instrumented for LINE.
+    pub line_opcodes: Vec<u8>,
+
+    /// Original opcodes at positions with INSTRUMENTED_INSTRUCTION.
+    /// Indexed by instruction index. 0 = not instrumented for INSTRUCTION.
+    pub per_instruction_opcodes: Vec<u8>,
+}
+
 #[pyclass(module = false, name = "code")]
 pub struct PyCode {
     pub code: CodeObject,
+    source_path: AtomicPtr<PyStrInterned>,
+    /// Version counter for lazy re-instrumentation.
+    /// Compared against `PyGlobalState::instrumentation_version` at RESUME.
+    pub instrumentation_version: AtomicU64,
+    /// Side-table for INSTRUMENTED_LINE / INSTRUMENTED_INSTRUCTION.
+    pub monitoring_data: PyMutex<Option<CoMonitoringData>>,
+    /// Whether adaptive counters have been initialized (lazy quickening).
+    pub quickened: core::sync::atomic::AtomicBool,
 }
 
 impl Deref for PyCode {
@@ -333,8 +405,27 @@ impl Deref for PyCode {
 }
 
 impl PyCode {
-    pub const fn new(code: CodeObject) -> Self {
-        Self { code }
+    pub fn new(code: CodeObject) -> Self {
+        let sp = code.source_path as *const PyStrInterned as *mut PyStrInterned;
+        Self {
+            code,
+            source_path: AtomicPtr::new(sp),
+            instrumentation_version: AtomicU64::new(0),
+            monitoring_data: PyMutex::new(None),
+            quickened: core::sync::atomic::AtomicBool::new(false),
+        }
+    }
+
+    pub fn source_path(&self) -> &'static PyStrInterned {
+        // SAFETY: always points to a valid &'static PyStrInterned (interned strings are never deallocated)
+        unsafe { &*self.source_path.load(Ordering::Relaxed) }
+    }
+
+    pub fn set_source_path(&self, new: &'static PyStrInterned) {
+        self.source_path.store(
+            new as *const PyStrInterned as *mut PyStrInterned,
+            Ordering::Relaxed,
+        );
     }
     pub fn from_pyc_path(path: &std::path::Path, vm: &VirtualMachine) -> PyResult<PyRef<Self>> {
         let name = match path.file_stem() {
@@ -397,12 +488,81 @@ impl Representable for PyCode {
             "<code object {} at {:#x} file {:?}, line {}>",
             code.obj_name,
             zelf.get_id(),
-            code.source_path.as_str(),
+            zelf.source_path().as_str(),
             code.first_line_number.map_or(-1, |n| n.get() as i32)
         ))
     }
 }
 
+impl Comparable for PyCode {
+    fn cmp(
+        zelf: &Py<Self>,
+        other: &PyObject,
+        op: crate::types::PyComparisonOp,
+        vm: &VirtualMachine,
+    ) -> PyResult<crate::function::PyComparisonValue> {
+        op.eq_only(|| {
+            let other = class_or_notimplemented!(Self, other);
+            let a = &zelf.code;
+            let b = &other.code;
+            let eq = a.obj_name == b.obj_name
+                && a.arg_count == b.arg_count
+                && a.posonlyarg_count == b.posonlyarg_count
+                && a.kwonlyarg_count == b.kwonlyarg_count
+                && a.flags == b.flags
+                && a.first_line_number == b.first_line_number
+                && a.instructions.original_bytes() == b.instructions.original_bytes()
+                && a.linetable == b.linetable
+                && a.exceptiontable == b.exceptiontable
+                && a.names == b.names
+                && a.varnames == b.varnames
+                && a.freevars == b.freevars
+                && a.cellvars == b.cellvars
+                && {
+                    let a_consts: Vec<_> = a.constants.iter().map(|c| c.0.clone()).collect();
+                    let b_consts: Vec<_> = b.constants.iter().map(|c| c.0.clone()).collect();
+                    if a_consts.len() != b_consts.len() {
+                        false
+                    } else {
+                        let mut eq = true;
+                        for (ac, bc) in a_consts.iter().zip(b_consts.iter()) {
+                            if !vm.bool_eq(ac, bc)? {
+                                eq = false;
+                                break;
+                            }
+                        }
+                        eq
+                    }
+                };
+            Ok(eq.into())
+        })
+    }
+}
+
+impl Hashable for PyCode {
+    fn hash(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<crate::common::hash::PyHash> {
+        let code = &zelf.code;
+        // Hash a tuple of key attributes, matching CPython's code_hash
+        let tuple = vm.ctx.new_tuple(vec![
+            vm.ctx.new_str(code.obj_name.as_str()).into(),
+            vm.ctx.new_int(code.arg_count).into(),
+            vm.ctx.new_int(code.posonlyarg_count).into(),
+            vm.ctx.new_int(code.kwonlyarg_count).into(),
+            vm.ctx.new_int(code.varnames.len()).into(),
+            vm.ctx.new_int(code.flags.bits()).into(),
+            vm.ctx
+                .new_int(code.first_line_number.map_or(0, |n| n.get()) as i64)
+                .into(),
+            vm.ctx.new_bytes(code.instructions.original_bytes()).into(),
+            {
+                let consts: Vec<_> = code.constants.iter().map(|c| c.0.clone()).collect();
+                vm.ctx.new_tuple(consts).into()
+            },
+        ]);
+        tuple.as_object().hash(vm)
+    }
+}
+
 // Arguments for code object constructor
 #[derive(FromArgs)]
 pub struct PyCodeNewArgs {
@@ -435,10 +595,10 @@ impl Constructor for PyCode {
             .names
             .iter()
             .map(|obj| {
-                let s = obj.downcast_ref::<super::pystr::PyStr>().ok_or_else(|| {
-                    vm.new_type_error("names must be tuple of strings".to_owned())
-                })?;
-                Ok(vm.ctx.intern_str(s.as_str()))
+                let s = obj
+                    .downcast_ref::<super::pystr::PyStr>()
+                    .ok_or_else(|| vm.new_type_error("names must be tuple of strings"))?;
+                Ok(vm.ctx.intern_str(s.as_wtf8()))
             })
             .collect::<PyResult<Vec<_>>>()?
             .into_boxed_slice();
@@ -447,10 +607,10 @@ impl Constructor for PyCode {
             .varnames
             .iter()
             .map(|obj| {
-                let s = obj.downcast_ref::<super::pystr::PyStr>().ok_or_else(|| {
-                    vm.new_type_error("varnames must be tuple of strings".to_owned())
-                })?;
-                Ok(vm.ctx.intern_str(s.as_str()))
+                let s = obj
+                    .downcast_ref::<super::pystr::PyStr>()
+                    .ok_or_else(|| vm.new_type_error("varnames must be tuple of strings"))?;
+                Ok(vm.ctx.intern_str(s.as_wtf8()))
             })
             .collect::<PyResult<Vec<_>>>()?
             .into_boxed_slice();
@@ -459,10 +619,10 @@ impl Constructor for PyCode {
             .cellvars
             .iter()
             .map(|obj| {
-                let s = obj.downcast_ref::<super::pystr::PyStr>().ok_or_else(|| {
-                    vm.new_type_error("cellvars must be tuple of strings".to_owned())
-                })?;
-                Ok(vm.ctx.intern_str(s.as_str()))
+                let s = obj
+                    .downcast_ref::<super::pystr::PyStr>()
+                    .ok_or_else(|| vm.new_type_error("cellvars must be tuple of strings"))?;
+                Ok(vm.ctx.intern_str(s.as_wtf8()))
             })
             .collect::<PyResult<Vec<_>>>()?
             .into_boxed_slice();
@@ -471,10 +631,10 @@ impl Constructor for PyCode {
             .freevars
             .iter()
             .map(|obj| {
-                let s = obj.downcast_ref::<super::pystr::PyStr>().ok_or_else(|| {
-                    vm.new_type_error("freevars must be tuple of strings".to_owned())
-                })?;
-                Ok(vm.ctx.intern_str(s.as_str()))
+                let s = obj
+                    .downcast_ref::<super::pystr::PyStr>()
+                    .ok_or_else(|| vm.new_type_error("freevars must be tuple of strings"))?;
+                Ok(vm.ctx.intern_str(s.as_wtf8()))
             })
             .collect::<PyResult<Vec<_>>>()?
             .into_boxed_slice();
@@ -494,16 +654,14 @@ impl Constructor for PyCode {
             .map_err(|e| vm.new_value_error(format!("invalid bytecode: {}", e)))?;
 
         // Convert constants
-        let constants: Box<[Literal]> = args
+        let constants = args
             .consts
             .iter()
             .map(|obj| {
-                // Convert PyObject to Literal constant
-                // For now, just wrap it
+                // Convert PyObject to Literal constant. For now, just wrap it
                 Literal(obj.clone())
             })
-            .collect::<Vec<_>>()
-            .into_boxed_slice();
+            .collect();
 
         // Create locations (start and end pairs)
         let row = if args.firstlineno > 0 {
@@ -522,6 +680,38 @@ impl Constructor for PyCode {
             )],
         > = vec![(loc, loc); instructions.len()].into_boxed_slice();
 
+        // Build localspluskinds with cell-local merging
+        let localspluskinds = {
+            use rustpython_compiler_core::bytecode::*;
+            let nlocals = varnames.len();
+            let ncells = cellvars.len();
+            let nfrees = freevars.len();
+            let numdropped = cellvars
+                .iter()
+                .filter(|cv| varnames.iter().any(|v| *v == **cv))
+                .count();
+            let nlocalsplus = nlocals + ncells - numdropped + nfrees;
+            let mut kinds = vec![0u8; nlocalsplus];
+            for kind in kinds.iter_mut().take(nlocals) {
+                *kind = CO_FAST_LOCAL;
+            }
+            let mut cell_numdropped = 0usize;
+            for (i, cv) in cellvars.iter().enumerate() {
+                let merged_idx = varnames.iter().position(|v| **v == **cv);
+                if let Some(local_idx) = merged_idx {
+                    kinds[local_idx] |= CO_FAST_CELL;
+                    cell_numdropped += 1;
+                } else {
+                    kinds[nlocals + i - cell_numdropped] = CO_FAST_CELL;
+                }
+            }
+            let free_start = nlocals + ncells - numdropped;
+            for i in 0..nfrees {
+                kinds[free_start + i] = CO_FAST_FREE;
+            }
+            kinds.into_boxed_slice()
+        };
+
         // Build the CodeObject
         let code = CodeObject {
             instructions,
@@ -530,21 +720,21 @@ impl Constructor for PyCode {
             posonlyarg_count: args.posonlyargcount,
             arg_count: args.argcount,
             kwonlyarg_count: args.kwonlyargcount,
-            source_path: vm.ctx.intern_str(args.filename.as_str()),
+            source_path: vm.ctx.intern_str(args.filename.as_wtf8()),
             first_line_number: if args.firstlineno > 0 {
                 OneIndexed::new(args.firstlineno as usize)
             } else {
                 None
             },
             max_stackdepth: args.stacksize,
-            obj_name: vm.ctx.intern_str(args.name.as_str()),
-            qualname: vm.ctx.intern_str(args.qualname.as_str()),
-            cell2arg: None, // TODO: reuse `fn cell2arg`
+            obj_name: vm.ctx.intern_str(args.name.as_wtf8()),
+            qualname: vm.ctx.intern_str(args.qualname.as_wtf8()),
             constants,
             names,
             varnames,
             cellvars,
             freevars,
+            localspluskinds,
             linetable: args.linetable.as_bytes().to_vec().into_boxed_slice(),
             exceptiontable: args.exceptiontable.as_bytes().to_vec().into_boxed_slice(),
         };
@@ -553,7 +743,10 @@ impl Constructor for PyCode {
     }
 }
 
-#[pyclass(with(Representable, Constructor))]
+#[pyclass(
+    with(Representable, Constructor, Comparable, Hashable),
+    flags(HAS_WEAKREF)
+)]
 impl PyCode {
     #[pygetset]
     const fn co_posonlyargcount(&self) -> usize {
@@ -572,7 +765,7 @@ impl PyCode {
 
     #[pygetset]
     pub fn co_filename(&self) -> PyStrRef {
-        self.code.source_path.to_owned()
+        self.source_path().to_owned()
     }
 
     #[pygetset]
@@ -640,7 +833,12 @@ impl PyCode {
 
     #[pygetset]
     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
+        vm.ctx.new_bytes(self.code.instructions.original_bytes())
+    }
+
+    #[pygetset]
+    pub fn _co_code_adaptive(&self, vm: &VirtualMachine) -> crate::builtins::PyBytesRef {
+        // Return current (possibly quickened/specialized) bytecode
         let bytes = unsafe {
             core::slice::from_raw_parts(
                 self.code.instructions.as_ptr() as *const u8,
@@ -650,12 +848,6 @@ impl PyCode {
         vm.ctx.new_bytes(bytes.to_vec())
     }
 
-    #[pygetset]
-    pub fn _co_code_adaptive(&self, vm: &VirtualMachine) -> crate::builtins::PyBytesRef {
-        // RustPython doesn't have adaptive/specialized bytecode, so return regular co_code
-        self.co_code(vm)
-    }
-
     #[pygetset]
     pub fn co_freevars(&self, vm: &VirtualMachine) -> PyTupleRef {
         let names = self
@@ -680,6 +872,11 @@ impl PyCode {
         vm.ctx.new_bytes(self.code.exceptiontable.to_vec())
     }
 
+    // spell-checker: ignore lnotab
+    // co_lnotab is intentionally not implemented.
+    // It was deprecated since 3.12 and scheduled for removal in 3.14.
+    // Use co_lines() or co_linetable instead.
+
     #[pymethod]
     pub fn co_lines(&self, vm: &VirtualMachine) -> PyResult<PyObjectRef> {
         // TODO: Implement lazy iterator (lineiterator) like CPython for better performance
@@ -872,6 +1069,90 @@ impl PyCode {
         vm.call_method(list.as_object(), "__iter__", ())
     }
 
+    #[pymethod]
+    pub fn co_branches(&self, vm: &VirtualMachine) -> PyResult<PyObjectRef> {
+        let instructions = &self.code.instructions;
+        let mut branches = Vec::new();
+        let mut extended_arg: u32 = 0;
+
+        for (i, unit) in instructions.iter().enumerate() {
+            // De-instrument: use base opcode for instrumented variants
+            let op = unit.op.to_base().unwrap_or(unit.op);
+            let raw_arg = u32::from(u8::from(unit.arg));
+
+            if matches!(op, Instruction::ExtendedArg) {
+                extended_arg = (extended_arg | raw_arg) << 8;
+                continue;
+            }
+
+            let oparg = extended_arg | raw_arg;
+            extended_arg = 0;
+
+            let caches = op.cache_entries();
+            let (src, left, right) = match op {
+                Instruction::ForIter { .. } => {
+                    // left = fall-through past CACHE entries (continue iteration)
+                    // right = past END_FOR (iterator exhausted, skip cleanup)
+                    // arg is relative forward from after instruction+caches
+                    let after_cache = i + 1 + caches;
+                    let target = after_cache + oparg as usize;
+                    let right = if matches!(
+                        instructions.get(target).map(|u| u.op),
+                        Some(Instruction::EndFor) | Some(Instruction::InstrumentedEndFor)
+                    ) {
+                        (target + 1) * 2
+                    } else {
+                        target * 2
+                    };
+                    (i * 2, after_cache * 2, right)
+                }
+                Instruction::PopJumpIfFalse { .. }
+                | Instruction::PopJumpIfTrue { .. }
+                | Instruction::PopJumpIfNone { .. }
+                | Instruction::PopJumpIfNotNone { .. } => {
+                    // left = fall-through past CACHE entries (skip NOT_TAKEN if present)
+                    // right = jump target (relative forward from after instruction+caches)
+                    let after_cache = i + 1 + caches;
+                    let next_op = instructions
+                        .get(after_cache)
+                        .map(|u| u.op.to_base().unwrap_or(u.op));
+                    let fallthrough = if matches!(next_op, Some(Instruction::NotTaken)) {
+                        (after_cache + 1) * 2
+                    } else {
+                        after_cache * 2
+                    };
+                    let right_target = after_cache + oparg as usize;
+                    (i * 2, fallthrough, right_target * 2)
+                }
+                Instruction::EndAsyncFor => {
+                    // src = END_SEND position (next_i - oparg)
+                    let next_i = i + 1;
+                    let Some(src_i) = next_i.checked_sub(oparg as usize) else {
+                        continue;
+                    };
+                    // left = fall-through past NOT_TAKEN
+                    (src_i * 2, (src_i + 2) * 2, next_i * 2)
+                }
+                _ => continue,
+            };
+
+            let tuple = vm.ctx.new_tuple(vec![
+                vm.ctx.new_int(src).into(),
+                vm.ctx.new_int(left).into(),
+                vm.ctx.new_int(right).into(),
+            ]);
+            branches.push(tuple.into());
+        }
+
+        let list = vm.ctx.new_list(branches);
+        vm.call_method(list.as_object(), "__iter__", ())
+    }
+
+    #[pymethod]
+    pub fn __replace__(&self, args: ReplaceArgs, vm: &VirtualMachine) -> PyResult<Self> {
+        self.replace(args, vm)
+    }
+
     #[pymethod]
     pub fn replace(&self, args: ReplaceArgs, vm: &VirtualMachine) -> PyResult<Self> {
         let ReplaceArgs {
@@ -906,7 +1187,7 @@ impl PyCode {
 
         let source_path = match co_filename {
             OptionalArg::Present(source_path) => source_path,
-            OptionalArg::Missing => self.code.source_path.to_owned(),
+            OptionalArg::Missing => self.source_path().to_owned(),
         };
 
         let first_line_number = match co_firstlineno {
@@ -1035,7 +1316,7 @@ impl PyCode {
                 .collect(),
             cellvars,
             freevars,
-            cell2arg: self.code.cell2arg.clone(),
+            localspluskinds: self.code.localspluskinds.clone(),
             linetable,
             exceptiontable,
         };
@@ -1050,22 +1331,34 @@ impl PyCode {
         let idx = usize::try_from(opcode).map_err(|_| idx_err(vm))?;
 
         let varnames_len = self.code.varnames.len();
-        let cellvars_len = self.code.cellvars.len();
+        // Non-parameter cells: cellvars that are NOT also in varnames
+        let nonparam_cellvars: Vec<_> = self
+            .code
+            .cellvars
+            .iter()
+            .filter(|s| {
+                let s_str: &str = s.as_ref();
+                !self.code.varnames.iter().any(|v| {
+                    let v_str: &str = v.as_ref();
+                    v_str == s_str
+                })
+            })
+            .collect();
+        let nonparam_len = nonparam_cellvars.len();
 
         let name = if idx < varnames_len {
-            // Index in varnames
+            // Index in varnames (includes parameter cells)
             self.code.varnames.get(idx).ok_or_else(|| idx_err(vm))?
-        } else if idx < varnames_len + cellvars_len {
-            // Index in cellvars
-            self.code
-                .cellvars
+        } else if idx < varnames_len + nonparam_len {
+            // Index in non-parameter cellvars
+            *nonparam_cellvars
                 .get(idx - varnames_len)
                 .ok_or_else(|| idx_err(vm))?
         } else {
             // Index in freevars
             self.code
                 .freevars
-                .get(idx - varnames_len - cellvars_len)
+                .get(idx - varnames_len - nonparam_len)
                 .ok_or_else(|| idx_err(vm))?
         };
         Ok(name.to_object())
@@ -1153,6 +1446,6 @@ impl<'a> LineTableReader<'a> {
     }
 }
 
-pub fn init(ctx: &Context) {
+pub fn init(ctx: &'static Context) {
     PyCode::extend_class(ctx, ctx.types.code_type);
 }
diff --git a/crates/vm/src/builtins/complex.rs b/crates/vm/src/builtins/complex.rs
index 78729b2f5c0..a284bf4e4d3 100644
--- a/crates/vm/src/builtins/complex.rs
+++ b/crates/vm/src/builtins/complex.rs
@@ -1,16 +1,18 @@
 use super::{PyStr, PyType, PyTypeRef, float};
 use crate::{
     AsObject, Context, Py, PyObject, PyObjectRef, PyPayload, PyRef, PyResult, VirtualMachine,
-    builtins::PyStrRef,
+    builtins::PyUtf8StrRef,
     class::PyClassImpl,
-    common::format::FormatSpec,
+    common::{format::FormatSpec, wtf8::Wtf8Buf},
     convert::{IntoPyException, ToPyObject, ToPyResult},
     function::{FuncArgs, OptionalArg, PyComparisonValue},
     protocol::PyNumberMethods,
-    stdlib::warnings,
-    types::{AsNumber, Comparable, Constructor, Hashable, PyComparisonOp, Representable},
+    stdlib::_warnings,
+    types::{AsNumber, Callable, Comparable, Constructor, Hashable, PyComparisonOp, Representable},
 };
+use core::cell::Cell;
 use core::num::Wrapping;
+use core::ptr::NonNull;
 use num_complex::Complex64;
 use num_traits::Zero;
 use rustpython_common::hash;
@@ -24,11 +26,49 @@ pub struct PyComplex {
     value: Complex64,
 }
 
+// spell-checker:ignore MAXFREELIST
+thread_local! {
+    static COMPLEX_FREELIST: Cell<crate::object::FreeList<PyComplex>> = const { Cell::new(crate::object::FreeList::new()) };
+}
+
 impl PyPayload for PyComplex {
+    const MAX_FREELIST: usize = 100;
+    const HAS_FREELIST: bool = true;
+
     #[inline]
     fn class(ctx: &Context) -> &'static Py<PyType> {
         ctx.types.complex_type
     }
+
+    #[inline]
+    unsafe fn freelist_push(obj: *mut PyObject) -> bool {
+        COMPLEX_FREELIST
+            .try_with(|fl| {
+                let mut list = fl.take();
+                let stored = if list.len() < Self::MAX_FREELIST {
+                    list.push(obj);
+                    true
+                } else {
+                    false
+                };
+                fl.set(list);
+                stored
+            })
+            .unwrap_or(false)
+    }
+
+    #[inline]
+    unsafe fn freelist_pop(_payload: &Self) -> Option<NonNull<PyObject>> {
+        COMPLEX_FREELIST
+            .try_with(|fl| {
+                let mut list = fl.take();
+                let result = list.pop().map(|p| unsafe { NonNull::new_unchecked(p) });
+                fl.set(list);
+                result
+            })
+            .ok()
+            .flatten()
+    }
 }
 
 impl ToPyObject for Complex64 {
@@ -55,7 +95,7 @@ impl PyObjectRef {
 
             let ret_class = result.class().to_owned();
             if let Some(ret) = result.downcast_ref::<PyComplex>() {
-                warnings::warn(
+                _warnings::warn(
                     vm.ctx.exceptions.deprecation_warning,
                     format!(
                         "__complex__ returned non-complex (type {ret_class}).  \
@@ -89,7 +129,7 @@ impl PyObjectRef {
     }
 }
 
-pub fn init(context: &Context) {
+pub fn init(context: &'static Context) {
     PyComplex::extend_class(context, context.types.complex_type);
 }
 
@@ -247,6 +287,44 @@ impl PyComplex {
             Ok(vm.ctx.not_implemented())
         }
     }
+
+    fn complex_real_binop<CCF, RCF, CRF, R>(
+        a: &PyObject,
+        b: &PyObject,
+        cc_op: CCF,
+        cr_op: CRF,
+        rc_op: RCF,
+        vm: &VirtualMachine,
+    ) -> PyResult
+    where
+        CCF: FnOnce(Complex64, Complex64) -> R,
+        CRF: FnOnce(Complex64, f64) -> R,
+        RCF: FnOnce(f64, Complex64) -> R,
+        R: ToPyResult,
+    {
+        let value = match (a.downcast_ref::<PyComplex>(), b.downcast_ref::<PyComplex>()) {
+            // complex + complex
+            (Some(a_complex), Some(b_complex)) => cc_op(a_complex.value, b_complex.value),
+            (Some(a_complex), None) => {
+                let Some(b_real) = float::to_op_float(b, vm)? else {
+                    return Ok(vm.ctx.not_implemented());
+                };
+
+                // complex + real
+                cr_op(a_complex.value, b_real)
+            }
+            (None, Some(b_complex)) => {
+                let Some(a_real) = float::to_op_float(a, vm)? else {
+                    return Ok(vm.ctx.not_implemented());
+                };
+
+                // real + complex
+                rc_op(a_real, b_complex.value)
+            }
+            (None, None) => return Ok(vm.ctx.not_implemented()),
+        };
+        value.to_pyresult(vm)
+    }
 }
 
 #[pyclass(
@@ -276,11 +354,45 @@ impl PyComplex {
     }
 
     #[pymethod]
-    fn __format__(&self, spec: PyStrRef, vm: &VirtualMachine) -> PyResult<String> {
-        FormatSpec::parse(spec.as_str())
-            .and_then(|format_spec| format_spec.format_complex(&self.value))
+    fn __format__(zelf: &Py<Self>, spec: PyUtf8StrRef, vm: &VirtualMachine) -> PyResult<Wtf8Buf> {
+        // Empty format spec: equivalent to str(self)
+        if spec.is_empty() {
+            return Ok(zelf.as_object().str(vm)?.as_wtf8().to_owned());
+        }
+        let format_spec =
+            FormatSpec::parse(spec.as_str()).map_err(|err| err.into_pyexception(vm))?;
+        let result = if format_spec.has_locale_format() {
+            let locale = crate::format::get_locale_info();
+            format_spec.format_complex_locale(&zelf.value, &locale)
+        } else {
+            format_spec.format_complex(&zelf.value)
+        };
+        result
+            .map(Wtf8Buf::from_string)
             .map_err(|err| err.into_pyexception(vm))
     }
+
+    #[pyclassmethod]
+    fn from_number(cls: PyTypeRef, number: PyObjectRef, vm: &VirtualMachine) -> PyResult {
+        if number.class().is(vm.ctx.types.complex_type) && cls.is(vm.ctx.types.complex_type) {
+            return Ok(number);
+        }
+        let value = number
+            .try_complex(vm)?
+            .ok_or_else(|| {
+                vm.new_type_error(format!(
+                    "must be real number, not {}",
+                    number.class().name()
+                ))
+            })?
+            .0;
+        let result = vm.ctx.new_complex(value);
+        if cls.is(vm.ctx.types.complex_type) {
+            Ok(result.into())
+        } else {
+            PyType::call(&cls, vec![result.into()].into(), vm)
+        }
+    }
 }
 
 #[pyclass]
@@ -304,15 +416,7 @@ impl Comparable for PyComplex {
     ) -> PyResult<PyComparisonValue> {
         op.eq_only(|| {
             let result = if let Some(other) = other.downcast_ref::<Self>() {
-                if zelf.value.re.is_nan()
-                    && zelf.value.im.is_nan()
-                    && other.value.re.is_nan()
-                    && other.value.im.is_nan()
-                {
-                    true
-                } else {
-                    zelf.value == other.value
-                }
+                zelf.value == other.value
             } else {
                 match float::to_op_float(other, vm) {
                     Ok(Some(other)) => zelf.value == other.into(),
@@ -344,8 +448,26 @@ impl Hashable for PyComplex {
 impl AsNumber for PyComplex {
     fn as_number() -> &'static PyNumberMethods {
         static AS_NUMBER: PyNumberMethods = PyNumberMethods {
-            add: Some(|a, b, vm| PyComplex::number_op(a, b, |a, b, _vm| a + b, vm)),
-            subtract: Some(|a, b, vm| PyComplex::number_op(a, b, |a, b, _vm| a - b, vm)),
+            add: Some(|a, b, vm| {
+                PyComplex::complex_real_binop(
+                    a,
+                    b,
+                    |a, b| a + b,
+                    |a_complex, b_real| Complex64::new(a_complex.re + b_real, a_complex.im),
+                    |a_real, b_complex| Complex64::new(a_real + b_complex.re, b_complex.im),
+                    vm,
+                )
+            }),
+            subtract: Some(|a, b, vm| {
+                PyComplex::complex_real_binop(
+                    a,
+                    b,
+                    |a, b| a - b,
+                    |a_complex, b_real| Complex64::new(a_complex.re - b_real, a_complex.im),
+                    |a_real, b_complex| Complex64::new(a_real - b_complex.re, -b_complex.im),
+                    vm,
+                )
+            }),
             multiply: Some(|a, b, vm| PyComplex::number_op(a, b, |a, b, _vm| a * b, vm)),
             power: Some(|a, b, c, vm| {
                 if vm.is_none(c) {
@@ -366,7 +488,7 @@ impl AsNumber for PyComplex {
                 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()));
+                    return Err(vm.new_overflow_error("absolute value too large"));
                 }
                 result.to_pyresult(vm)
             }),
diff --git a/crates/vm/src/builtins/coroutine.rs b/crates/vm/src/builtins/coroutine.rs
index d2a70e54229..9746dddda87 100644
--- a/crates/vm/src/builtins/coroutine.rs
+++ b/crates/vm/src/builtins/coroutine.rs
@@ -7,7 +7,7 @@ use crate::{
     function::OptionalArg,
     object::{Traverse, TraverseFn},
     protocol::PyIterReturn,
-    types::{IterNext, Iterable, Representable, SelfIter},
+    types::{Destructor, IterNext, Iterable, Representable, SelfIter},
 };
 use crossbeam_utils::atomic::AtomicCell;
 
@@ -31,7 +31,10 @@ impl PyPayload for PyCoroutine {
     }
 }
 
-#[pyclass(flags(DISALLOW_INSTANTIATION), with(Py, IterNext, Representable))]
+#[pyclass(
+    flags(DISALLOW_INSTANTIATION, HAS_WEAKREF),
+    with(Py, IterNext, Representable, Destructor)
+)]
 impl PyCoroutine {
     pub const fn as_coro(&self) -> &Coro {
         &self.inner
@@ -130,7 +133,7 @@ impl Py<PyCoroutine> {
     }
 
     #[pymethod]
-    fn close(&self, vm: &VirtualMachine) -> PyResult<()> {
+    fn close(&self, vm: &VirtualMachine) -> PyResult<PyObjectRef> {
         self.inner.close(self.as_object(), vm)
     }
 }
@@ -149,6 +152,22 @@ impl IterNext for PyCoroutine {
     }
 }
 
+impl Destructor for PyCoroutine {
+    fn del(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<()> {
+        if zelf.inner.closed() || zelf.inner.running() {
+            return Ok(());
+        }
+        if zelf.inner.frame().lasti() == 0 {
+            zelf.inner.closed.store(true);
+            return Ok(());
+        }
+        if let Err(e) = zelf.inner.close(zelf.as_object(), vm) {
+            vm.run_unraisable(e, None, zelf.as_object().to_owned());
+        }
+        Ok(())
+    }
+}
+
 #[pyclass(module = false, name = "coroutine_wrapper", traverse = "manual")]
 #[derive(Debug)]
 // PyCoroWrapper_Type in CPython
@@ -209,7 +228,7 @@ impl PyCoroutineWrapper {
     }
 
     #[pymethod]
-    fn close(&self, vm: &VirtualMachine) -> PyResult<()> {
+    fn close(&self, vm: &VirtualMachine) -> PyResult<PyObjectRef> {
         self.closed.store(true);
         self.coro.close(vm)
     }
@@ -222,7 +241,13 @@ impl IterNext for PyCoroutineWrapper {
     }
 }
 
-pub fn init(ctx: &Context) {
+impl Drop for PyCoroutine {
+    fn drop(&mut self) {
+        self.inner.frame().clear_generator();
+    }
+}
+
+pub fn init(ctx: &'static Context) {
     PyCoroutine::extend_class(ctx, ctx.types.coroutine_type);
     PyCoroutineWrapper::extend_class(ctx, ctx.types.coroutine_wrapper_type);
 }
diff --git a/crates/vm/src/builtins/descriptor.rs b/crates/vm/src/builtins/descriptor.rs
index 89dafdd14b7..acfe58d723b 100644
--- a/crates/vm/src/builtins/descriptor.rs
+++ b/crates/vm/src/builtins/descriptor.rs
@@ -37,6 +37,8 @@ pub struct PyMethodDescriptor {
     pub method: &'static PyMethodDef,
     // vectorcall: vector_call_func,
     pub objclass: &'static Py<PyType>, // TODO: move to tp_members
+    /// Prevent HeapMethodDef from being freed while this descriptor references it
+    pub(crate) _method_def_owner: Option<PyObjectRef>,
 }
 
 impl PyMethodDescriptor {
@@ -49,6 +51,7 @@ impl PyMethodDescriptor {
             },
             method,
             objclass: typ,
+            _method_def_owner: None,
         }
     }
 }
@@ -88,13 +91,12 @@ impl GetDescriptor for PyMethodDescriptor {
                 } else if descr.method.flags.contains(PyMethodFlags::CLASS) {
                     obj.class().to_owned().into()
                 } else {
-                    unimplemented!()
+                    obj
                 }
             }
             None if descr.method.flags.contains(PyMethodFlags::CLASS) => cls.unwrap(),
             None => return Ok(zelf),
         };
-        // Ok(descr.method.build_bound_method(&vm.ctx, bound, class).into())
         Ok(descr.bind(bound, &vm.ctx).into())
     }
 }
@@ -170,6 +172,7 @@ impl Representable for PyMethodDescriptor {
 
 #[derive(Debug)]
 pub enum MemberKind {
+    Object = 6,
     Bool = 14,
     ObjectEx = 16,
 }
@@ -253,11 +256,20 @@ fn calculate_qualname(descr: &PyDescriptorOwned, vm: &VirtualMachine) -> PyResul
     }
 }
 
-#[pyclass(
-    with(GetDescriptor, Representable),
-    flags(BASETYPE, DISALLOW_INSTANTIATION)
-)]
+#[pyclass(with(GetDescriptor, Representable), flags(DISALLOW_INSTANTIATION))]
 impl PyMemberDescriptor {
+    #[pymember]
+    fn __objclass__(vm: &VirtualMachine, zelf: PyObjectRef) -> PyResult {
+        let zelf: &Py<Self> = zelf.try_to_value(vm)?;
+        Ok(zelf.common.typ.clone().into())
+    }
+
+    #[pymember]
+    fn __name__(vm: &VirtualMachine, zelf: PyObjectRef) -> PyResult {
+        let zelf: &Py<Self> = zelf.try_to_value(vm)?;
+        Ok(zelf.common.name.to_owned().into())
+    }
+
     #[pygetset]
     fn __doc__(&self) -> Option<String> {
         self.member.doc.to_owned()
@@ -276,6 +288,23 @@ impl PyMemberDescriptor {
         })
     }
 
+    #[pymethod]
+    fn __reduce__(&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![
+                        self.common.typ.clone().into(),
+                        vm.ctx.new_str(self.common.name.as_str()).into(),
+                    ])
+                    .into(),
+            ])
+            .into())
+    }
+
     #[pyslot]
     fn descr_set(
         zelf: &PyObject,
@@ -306,6 +335,7 @@ fn get_slot_from_object(
     vm: &VirtualMachine,
 ) -> PyResult {
     let slot = match member.kind {
+        MemberKind::Object => obj.get_slot(offset).unwrap_or_else(|| vm.ctx.none()),
         MemberKind::Bool => obj
             .get_slot(offset)
             .unwrap_or_else(|| vm.ctx.new_bool(false).into()),
@@ -325,25 +355,38 @@ fn set_slot_at_object(
     vm: &VirtualMachine,
 ) -> PyResult<()> {
     match member.kind {
+        MemberKind::Object => match value {
+            PySetterValue::Assign(v) => {
+                obj.set_slot(offset, Some(v));
+            }
+            PySetterValue::Delete => {
+                obj.set_slot(offset, None);
+            }
+        },
         MemberKind::Bool => {
             match value {
                 PySetterValue::Assign(v) => {
                     if !v.class().is(vm.ctx.types.bool_type) {
                         return Err(vm.new_type_error("attribute value type must be bool"));
                     }
-
                     obj.set_slot(offset, Some(v))
                 }
-                PySetterValue::Delete => obj.set_slot(offset, None),
-            };
-        }
-        MemberKind::ObjectEx => {
-            let value = match value {
-                PySetterValue::Assign(v) => Some(v),
-                PySetterValue::Delete => None,
+                PySetterValue::Delete => {
+                    return Err(vm.new_type_error("can't delete numeric/char attribute"));
+                }
             };
-            obj.set_slot(offset, value);
         }
+        MemberKind::ObjectEx => match value {
+            PySetterValue::Assign(v) => {
+                obj.set_slot(offset, Some(v));
+            }
+            PySetterValue::Delete => {
+                if obj.get_slot(offset).is_none() {
+                    return Err(vm.new_attribute_error(member.name.clone()));
+                }
+                obj.set_slot(offset, None);
+            }
+        },
     }
 
     Ok(())
@@ -364,34 +407,84 @@ impl GetDescriptor for PyMemberDescriptor {
     fn descr_get(
         zelf: PyObjectRef,
         obj: Option<PyObjectRef>,
-        cls: Option<PyObjectRef>,
+        _cls: Option<PyObjectRef>,
         vm: &VirtualMachine,
     ) -> PyResult {
         let descr = Self::_as_pyref(&zelf, vm)?;
         match obj {
-            Some(x) => descr.member.get(x, vm),
-            None => {
-                // When accessed from class (not instance), for __doc__ member descriptor,
-                // return the class's docstring if available
-                // When accessed from class (not instance), check if the class has
-                // an attribute with the same name as this member descriptor
-                if let Some(cls) = cls
-                    && let Ok(cls_type) = cls.downcast::<PyType>()
-                    && let Some(interned) = vm.ctx.interned_str(descr.member.name.as_str())
-                    && let Some(attr) = cls_type.attributes.read().get(&interned)
-                {
-                    return Ok(attr.clone());
+            Some(x) => {
+                if !x.class().fast_issubclass(&descr.common.typ) {
+                    return Err(vm.new_type_error(format!(
+                        "descriptor '{}' for '{}' objects doesn't apply to a '{}' object",
+                        descr.common.name,
+                        descr.common.typ.name(),
+                        x.class().name()
+                    )));
                 }
-                Ok(zelf)
+                descr.member.get(x, vm)
             }
+            None => Ok(zelf),
         }
     }
 }
 
-pub fn init(ctx: &Context) {
+/// Vectorcall for method_descriptor: calls native method directly
+fn vectorcall_method_descriptor(
+    zelf_obj: &PyObject,
+    args: Vec<PyObjectRef>,
+    nargs: usize,
+    kwnames: Option<&[PyObjectRef]>,
+    vm: &VirtualMachine,
+) -> PyResult {
+    let zelf: &Py<PyMethodDescriptor> = zelf_obj.downcast_ref().unwrap();
+    let func_args = FuncArgs::from_vectorcall_owned(args, nargs, kwnames);
+    (zelf.method.func)(vm, func_args)
+}
+
+/// Vectorcall for wrapper_descriptor: calls wrapped slot function
+fn vectorcall_wrapper(
+    zelf_obj: &PyObject,
+    mut args: Vec<PyObjectRef>,
+    nargs: usize,
+    kwnames: Option<&[PyObjectRef]>,
+    vm: &VirtualMachine,
+) -> PyResult {
+    let zelf: &Py<PyWrapper> = zelf_obj.downcast_ref().unwrap();
+    // First positional arg is self
+    if nargs == 0 {
+        return Err(vm.new_type_error(format!(
+            "descriptor '{}' of '{}' object needs an argument",
+            zelf.name.as_str(),
+            zelf.typ.name()
+        )));
+    }
+    let obj = args.remove(0);
+    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()
+        )));
+    }
+    let rest = FuncArgs::from_vectorcall_owned(args, nargs - 1, kwnames);
+    zelf.wrapped.call(obj, rest, vm)
+}
+
+pub fn init(ctx: &'static Context) {
     PyMemberDescriptor::extend_class(ctx, ctx.types.member_descriptor_type);
     PyMethodDescriptor::extend_class(ctx, ctx.types.method_descriptor_type);
+    ctx.types
+        .method_descriptor_type
+        .slots
+        .vectorcall
+        .store(Some(vectorcall_method_descriptor));
     PyWrapper::extend_class(ctx, ctx.types.wrapper_descriptor_type);
+    ctx.types
+        .wrapper_descriptor_type
+        .slots
+        .vectorcall
+        .store(Some(vectorcall_wrapper));
     PyMethodWrapper::extend_class(ctx, ctx.types.method_wrapper_type);
 }
 
@@ -499,9 +592,7 @@ impl SlotFunc {
             }
             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())
-                    );
+                    return Err(vm.new_type_error("__hash__() takes no arguments (1 given)"));
                 }
                 let hash = func(&obj, vm)?;
                 Ok(vm.ctx.new_int(hash).into())
@@ -520,26 +611,20 @@ impl SlotFunc {
             }
             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())
-                    );
+                    return Err(vm.new_type_error("__iter__() takes no arguments (1 given)"));
                 }
                 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())
-                    );
+                    return Err(vm.new_type_error("__next__() takes no arguments (1 given)"));
                 }
                 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())
-                    );
+                    return Err(vm.new_type_error("__del__() takes no arguments (1 given)"));
                 }
                 func(&obj, vm)?;
                 Ok(vm.ctx.none())
diff --git a/crates/vm/src/builtins/dict.rs b/crates/vm/src/builtins/dict.rs
index fcb51c2ca0e..eae4ec7fd6b 100644
--- a/crates/vm/src/builtins/dict.rs
+++ b/crates/vm/src/builtins/dict.rs
@@ -2,9 +2,10 @@ use super::{
     IterStatus, PositionIterInternal, PyBaseExceptionRef, PyGenericAlias, PyMappingProxy, PySet,
     PyStr, PyStrRef, PyTupleRef, PyType, PyTypeRef, set::PySetInner,
 };
+use crate::common::lock::LazyLock;
 use crate::object::{Traverse, TraverseFn};
 use crate::{
-    AsObject, Context, Py, PyObject, PyObjectRef, PyPayload, PyRef, PyRefExact, PyResult,
+    AsObject, Context, Py, PyExact, PyObject, PyObjectRef, PyPayload, PyRef, PyRefExact, PyResult,
     TryFromObject, atomic_func,
     builtins::{
         PyTuple,
@@ -14,7 +15,9 @@ use crate::{
     class::{PyClassDef, PyClassImpl},
     common::ascii,
     dict_inner::{self, DictKey},
-    function::{ArgIterable, KwArgs, OptionalArg, PyArithmeticValue::*, PyComparisonValue},
+    function::{
+        ArgIterable, FuncArgs, KwArgs, OptionalArg, PyArithmeticValue::*, PyComparisonValue,
+    },
     iter::PyExactSizeIterator,
     protocol::{PyIterIter, PyIterReturn, PyMappingMethods, PyNumberMethods, PySequenceMethods},
     recursion::ReprGuard,
@@ -25,8 +28,10 @@ use crate::{
     vm::VirtualMachine,
 };
 use alloc::fmt;
+use core::cell::Cell;
+use core::ptr::NonNull;
 use rustpython_common::lock::PyMutex;
-use std::sync::LazyLock;
+use rustpython_common::wtf8::Wtf8Buf;
 
 pub type DictContentType = dict_inner::Dict;
 
@@ -59,11 +64,48 @@ impl fmt::Debug for PyDict {
     }
 }
 
+thread_local! {
+    static DICT_FREELIST: Cell<crate::object::FreeList<PyDict>> = const { Cell::new(crate::object::FreeList::new()) };
+}
+
 impl PyPayload for PyDict {
+    const MAX_FREELIST: usize = 80;
+    const HAS_FREELIST: bool = true;
+
     #[inline]
     fn class(ctx: &Context) -> &'static Py<PyType> {
         ctx.types.dict_type
     }
+
+    #[inline]
+    unsafe fn freelist_push(obj: *mut PyObject) -> bool {
+        DICT_FREELIST
+            .try_with(|fl| {
+                let mut list = fl.take();
+                let stored = if list.len() < Self::MAX_FREELIST {
+                    list.push(obj);
+                    true
+                } else {
+                    false
+                };
+                fl.set(list);
+                stored
+            })
+            .unwrap_or(false)
+    }
+
+    #[inline]
+    unsafe fn freelist_pop(_payload: &Self) -> Option<NonNull<PyObject>> {
+        DICT_FREELIST
+            .try_with(|fl| {
+                let mut list = fl.take();
+                let result = list.pop().map(|p| unsafe { NonNull::new_unchecked(p) });
+                fl.set(list);
+                result
+            })
+            .ok()
+            .flatten()
+    }
 }
 
 impl PyDict {
@@ -78,6 +120,11 @@ impl PyDict {
         &self.entries
     }
 
+    /// Monotonically increasing version for mutation tracking.
+    pub(crate) fn version(&self) -> u64 {
+        self.entries.version()
+    }
+
     /// 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> {
@@ -543,14 +590,19 @@ impl Representable for PyDict {
     #[inline]
     fn repr(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<PyStrRef> {
         let s = if let Some(_guard) = ReprGuard::enter(vm, zelf.as_object()) {
-            let mut str_parts = Vec::with_capacity(zelf.__len__());
+            let mut result = Wtf8Buf::from("{");
+            let mut first = true;
             for (key, value) in zelf {
-                let key_repr = &key.repr(vm)?;
-                let value_repr = value.repr(vm)?;
-                str_parts.push(format!("{key_repr}: {value_repr}"));
+                if !first {
+                    result.push_str(", ");
+                }
+                first = false;
+                result.push_wtf8(key.repr(vm)?.as_wtf8());
+                result.push_str(": ");
+                result.push_wtf8(value.repr(vm)?.as_wtf8());
             }
-
-            vm.ctx.new_str(format!("{{{}}}", str_parts.join(", ")))
+            result.push_char('}');
+            vm.ctx.new_str(result)
         } else {
             vm.ctx.intern_str("{...}").to_owned()
         };
@@ -623,6 +675,33 @@ impl Py<PyDict> {
         }
     }
 
+    /// Return a cached-entry hint for exact dict fast paths.
+    pub(crate) fn hint_for_key<K: DictKey + ?Sized>(
+        &self,
+        key: &K,
+        vm: &VirtualMachine,
+    ) -> PyResult<Option<u16>> {
+        if self.exact_dict(vm) {
+            self.entries.hint_for_key(vm, key)
+        } else {
+            Ok(None)
+        }
+    }
+
+    /// Fast lookup using a cached entry index hint.
+    pub(crate) fn get_item_opt_hint<K: DictKey + ?Sized>(
+        &self,
+        key: &K,
+        hint: u16,
+        vm: &VirtualMachine,
+    ) -> PyResult<Option<PyObjectRef>> {
+        if self.exact_dict(vm) {
+            self.entries.get_hint(vm, key, usize::from(hint))
+        } else {
+            self.get_item_opt(key, vm)
+        }
+    }
+
     pub fn get_item<K: DictKey + ?Sized>(&self, key: &K, vm: &VirtualMachine) -> PyResult {
         if self.exact_dict(vm) {
             self.inner_getitem(key, vm)
@@ -675,7 +754,10 @@ impl Py<PyDict> {
         let self_exact = self.exact_dict(vm);
         let other_exact = other.exact_dict(vm);
         if self_exact && other_exact {
-            self.entries.get_chain(&other.entries, vm, key)
+            // SAFETY: exact_dict checks passed
+            let self_exact = unsafe { PyExact::ref_unchecked(self) };
+            let other_exact = unsafe { PyExact::ref_unchecked(other) };
+            self_exact.get_chain_exact(other_exact, key, vm)
         } else if let Some(value) = self.get_item_opt(key, vm)? {
             Ok(Some(value))
         } else {
@@ -684,6 +766,21 @@ impl Py<PyDict> {
     }
 }
 
+impl PyExact<PyDict> {
+    /// Look up `key` in `self`, falling back to `other`.
+    /// Both dicts must be exact `dict` types (enforced by `PyExact`).
+    pub(crate) fn get_chain_exact<K: DictKey + ?Sized>(
+        &self,
+        other: &Self,
+        key: &K,
+        vm: &VirtualMachine,
+    ) -> PyResult<Option<PyObjectRef>> {
+        debug_assert!(self.class().is(vm.ctx.types.dict_type));
+        debug_assert!(other.class().is(vm.ctx.types.dict_type));
+        self.entries.get_chain(&other.entries, vm, key)
+    }
+}
+
 // Implement IntoIterator so that we can easily iterate dictionaries from rust code.
 impl IntoIterator for PyDictRef {
     type Item = (PyObjectRef, PyObjectRef);
@@ -848,13 +945,17 @@ macro_rules! dict_view {
             #[inline]
             fn repr(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<PyStrRef> {
                 let s = if let Some(_guard) = ReprGuard::enter(vm, zelf.as_object()) {
-                    let mut str_parts = Vec::with_capacity(zelf.__len__());
+                    let mut result = Wtf8Buf::from(format!("{}([", Self::NAME));
+                    let mut first = true;
                     for (key, value) in zelf.dict().clone() {
-                        let s = &Self::item(vm, key, value).repr(vm)?;
-                        str_parts.push(s.as_str().to_owned());
+                        if !first {
+                            result.push_str(", ");
+                        }
+                        first = false;
+                        result.push_wtf8(Self::item(vm, key, value).repr(vm)?.as_wtf8());
                     }
-                    vm.ctx
-                        .new_str(format!("{}([{}])", Self::NAME, str_parts.join(", ")))
+                    result.push_str("])");
+                    vm.ctx.new_str(result)
                 } else {
                     vm.ctx.intern_str("{...}").to_owned()
                 };
@@ -898,7 +999,7 @@ macro_rules! dict_view {
             #[allow(clippy::redundant_closure_call)]
             #[pymethod]
             fn __reduce__(&self, vm: &VirtualMachine) -> PyTupleRef {
-                let iter = builtins_iter(vm).to_owned();
+                let iter = builtins_iter(vm);
                 let internal = self.internal.lock();
                 let entries = match &internal.status {
                     IterStatus::Active(dict) => dict
@@ -968,7 +1069,7 @@ macro_rules! dict_view {
             #[allow(clippy::redundant_closure_call)]
             #[pymethod]
             fn __reduce__(&self, vm: &VirtualMachine) -> PyTupleRef {
-                let iter = builtins_reversed(vm).to_owned();
+                let iter = builtins_reversed(vm);
                 let internal = self.internal.lock();
                 // TODO: entries must be reversed too
                 let entries = match &internal.status {
@@ -1334,8 +1435,28 @@ fn set_inner_number_or(a: &PyObject, b: &PyObject, vm: &VirtualMachine) -> PyRes
     set_inner_number_op(a, b, |a, b| a.union(b, vm), vm)
 }
 
-pub(crate) fn init(context: &Context) {
+fn vectorcall_dict(
+    zelf_obj: &PyObject,
+    args: Vec<PyObjectRef>,
+    nargs: usize,
+    kwnames: Option<&[PyObjectRef]>,
+    vm: &VirtualMachine,
+) -> PyResult {
+    let zelf: &Py<PyType> = zelf_obj.downcast_ref().unwrap();
+    let obj = PyDict::default().into_ref_with_type(vm, zelf.to_owned())?;
+    let func_args = FuncArgs::from_vectorcall_owned(args, nargs, kwnames);
+    PyDict::slot_init(obj.clone().into(), func_args, vm)?;
+    Ok(obj.into())
+}
+
+pub(crate) fn init(context: &'static Context) {
     PyDict::extend_class(context, context.types.dict_type);
+    context
+        .types
+        .dict_type
+        .slots
+        .vectorcall
+        .store(Some(vectorcall_dict));
     PyDictKeys::extend_class(context, context.types.dict_keys_type);
     PyDictKeyIterator::extend_class(context, context.types.dict_keyiterator_type);
     PyDictReverseKeyIterator::extend_class(context, context.types.dict_reversekeyiterator_type);
diff --git a/crates/vm/src/builtins/enumerate.rs b/crates/vm/src/builtins/enumerate.rs
index 29d51f420e1..3cca47ce2d3 100644
--- a/crates/vm/src/builtins/enumerate.rs
+++ b/crates/vm/src/builtins/enumerate.rs
@@ -1,5 +1,6 @@
 use super::{
     IterStatus, PositionIterInternal, PyGenericAlias, PyIntRef, PyTupleRef, PyType, PyTypeRef,
+    iter::builtins_reversed,
 };
 use crate::common::lock::{PyMutex, PyRwLock};
 use crate::{
@@ -124,9 +125,13 @@ impl PyReverseSequenceIterator {
 
     #[pymethod]
     fn __reduce__(&self, vm: &VirtualMachine) -> PyTupleRef {
-        self.internal
-            .lock()
-            .builtins_reversed_reduce(|x| x.clone(), vm)
+        let func = builtins_reversed(vm);
+        self.internal.lock().reduce(
+            func,
+            |x| x.clone(),
+            |vm| vm.ctx.empty_tuple.clone().into(),
+            vm,
+        )
     }
 }
 
@@ -139,7 +144,7 @@ impl IterNext for PyReverseSequenceIterator {
     }
 }
 
-pub fn init(context: &Context) {
+pub fn init(context: &'static Context) {
     PyEnumerate::extend_class(context, context.types.enumerate_type);
     PyReverseSequenceIterator::extend_class(context, context.types.reverse_iter_type);
 }
diff --git a/crates/vm/src/builtins/filter.rs b/crates/vm/src/builtins/filter.rs
index 388fb8bb603..56d951f8a79 100644
--- a/crates/vm/src/builtins/filter.rs
+++ b/crates/vm/src/builtins/filter.rs
@@ -71,6 +71,6 @@ impl IterNext for PyFilter {
     }
 }
 
-pub fn init(context: &Context) {
+pub fn init(context: &'static Context) {
     PyFilter::extend_class(context, context.types.filter_type);
 }
diff --git a/crates/vm/src/builtins/float.rs b/crates/vm/src/builtins/float.rs
index 9941aea9ba2..2b2f05d8278 100644
--- a/crates/vm/src/builtins/float.rs
+++ b/crates/vm/src/builtins/float.rs
@@ -1,11 +1,12 @@
 use super::{
-    PyByteArray, PyBytes, PyInt, PyIntRef, PyStr, PyStrRef, PyType, PyTypeRef, try_bigint_to_f64,
+    PyByteArray, PyBytes, PyInt, PyIntRef, PyStr, PyType, PyTypeRef, PyUtf8StrRef,
+    try_bigint_to_f64,
 };
 use crate::{
     AsObject, Context, Py, PyObject, PyObjectRef, PyPayload, PyRef, PyResult,
     TryFromBorrowedObject, TryFromObject, VirtualMachine,
     class::PyClassImpl,
-    common::{float_ops, format::FormatSpec, hash},
+    common::{float_ops, format::FormatSpec, hash, wtf8::Wtf8Buf},
     convert::{IntoPyException, ToPyObject, ToPyResult},
     function::{
         ArgBytesLike, FuncArgs, OptionalArg, OptionalOption, PyArithmeticValue::*,
@@ -14,6 +15,8 @@ use crate::{
     protocol::PyNumberMethods,
     types::{AsNumber, Callable, Comparable, Constructor, Hashable, PyComparisonOp, Representable},
 };
+use core::cell::Cell;
+use core::ptr::NonNull;
 use malachite_bigint::{BigInt, ToBigInt};
 use num_complex::Complex64;
 use num_traits::{Signed, ToPrimitive, Zero};
@@ -31,11 +34,48 @@ impl PyFloat {
     }
 }
 
+thread_local! {
+    static FLOAT_FREELIST: Cell<crate::object::FreeList<PyFloat>> = const { Cell::new(crate::object::FreeList::new()) };
+}
+
 impl PyPayload for PyFloat {
+    const MAX_FREELIST: usize = 100;
+    const HAS_FREELIST: bool = true;
+
     #[inline]
     fn class(ctx: &Context) -> &'static Py<PyType> {
         ctx.types.float_type
     }
+
+    #[inline]
+    unsafe fn freelist_push(obj: *mut PyObject) -> bool {
+        FLOAT_FREELIST
+            .try_with(|fl| {
+                let mut list = fl.take();
+                let stored = if list.len() < Self::MAX_FREELIST {
+                    list.push(obj);
+                    true
+                } else {
+                    false
+                };
+                fl.set(list);
+                stored
+            })
+            .unwrap_or(false)
+    }
+
+    #[inline]
+    unsafe fn freelist_pop(_payload: &Self) -> Option<NonNull<PyObject>> {
+        FLOAT_FREELIST
+            .try_with(|fl| {
+                let mut list = fl.take();
+                let result = list.pop().map(|p| unsafe { NonNull::new_unchecked(p) });
+                fl.set(list);
+                result
+            })
+            .ok()
+            .flatten()
+    }
 }
 
 impl ToPyObject for f64 {
@@ -79,11 +119,11 @@ macro_rules! impl_try_from_object_float {
 impl_try_from_object_float!(f32, f64);
 
 fn inner_div(v1: f64, v2: f64, vm: &VirtualMachine) -> PyResult<f64> {
-    float_ops::div(v1, v2).ok_or_else(|| vm.new_zero_division_error("float division by zero"))
+    float_ops::div(v1, v2).ok_or_else(|| vm.new_zero_division_error("division by zero"))
 }
 
 fn inner_mod(v1: f64, v2: f64, vm: &VirtualMachine) -> PyResult<f64> {
-    float_ops::mod_(v1, v2).ok_or_else(|| vm.new_zero_division_error("float mod by zero"))
+    float_ops::mod_(v1, v2).ok_or_else(|| vm.new_zero_division_error("division by zero"))
 }
 
 pub fn try_to_bigint(value: f64, vm: &VirtualMachine) -> PyResult<BigInt> {
@@ -107,11 +147,11 @@ pub fn try_to_bigint(value: f64, vm: &VirtualMachine) -> PyResult<BigInt> {
 }
 
 fn inner_floordiv(v1: f64, v2: f64, vm: &VirtualMachine) -> PyResult<f64> {
-    float_ops::floordiv(v1, v2).ok_or_else(|| vm.new_zero_division_error("float floordiv by zero"))
+    float_ops::floordiv(v1, v2).ok_or_else(|| vm.new_zero_division_error("division by zero"))
 }
 
 fn inner_divmod(v1: f64, v2: f64, vm: &VirtualMachine) -> PyResult<(f64, f64)> {
-    float_ops::divmod(v1, v2).ok_or_else(|| vm.new_zero_division_error("float divmod()"))
+    float_ops::divmod(v1, v2).ok_or_else(|| vm.new_zero_division_error("division by zero"))
 }
 
 pub fn float_pow(v1: f64, v2: f64, vm: &VirtualMachine) -> PyResult {
@@ -214,14 +254,26 @@ fn float_from_string(val: PyObjectRef, vm: &VirtualMachine) -> PyResult<f64> {
 )]
 impl PyFloat {
     #[pymethod]
-    fn __format__(&self, spec: PyStrRef, vm: &VirtualMachine) -> PyResult<String> {
-        FormatSpec::parse(spec.as_str())
-            .and_then(|format_spec| format_spec.format_float(self.value))
+    fn __format__(zelf: &Py<Self>, spec: PyUtf8StrRef, vm: &VirtualMachine) -> PyResult<Wtf8Buf> {
+        // Empty format spec: equivalent to str(self)
+        if spec.is_empty() {
+            return Ok(zelf.as_object().str(vm)?.as_wtf8().to_owned());
+        }
+        let format_spec =
+            FormatSpec::parse(spec.as_str()).map_err(|err| err.into_pyexception(vm))?;
+        let result = if format_spec.has_locale_format() {
+            let locale = crate::format::get_locale_info();
+            format_spec.format_float_locale(zelf.value, &locale)
+        } else {
+            format_spec.format_float(zelf.value)
+        };
+        result
+            .map(Wtf8Buf::from_string)
             .map_err(|err| err.into_pyexception(vm))
     }
 
     #[pystaticmethod]
-    fn __getformat__(spec: PyStrRef, vm: &VirtualMachine) -> PyResult<String> {
+    fn __getformat__(spec: PyUtf8StrRef, vm: &VirtualMachine) -> PyResult<String> {
         if !matches!(spec.as_str(), "double" | "float") {
             return Err(
                 vm.new_value_error("__getformat__() argument 1 must be 'double' or 'float'")
@@ -321,7 +373,22 @@ impl PyFloat {
     }
 
     #[pyclassmethod]
-    fn fromhex(cls: PyTypeRef, string: PyStrRef, vm: &VirtualMachine) -> PyResult {
+    fn from_number(cls: PyTypeRef, number: PyObjectRef, vm: &VirtualMachine) -> PyResult {
+        if number.class().is(vm.ctx.types.float_type) && cls.is(vm.ctx.types.float_type) {
+            return Ok(number);
+        }
+
+        let value = number.try_float(vm)?.to_f64();
+        let result = vm.ctx.new_float(value);
+        if cls.is(vm.ctx.types.float_type) {
+            Ok(result.into())
+        } else {
+            PyType::call(&cls, vec![result.into()].into(), vm)
+        }
+    }
+
+    #[pyclassmethod]
+    fn fromhex(cls: PyTypeRef, string: PyUtf8StrRef, vm: &VirtualMachine) -> PyResult {
         let result = crate::literal::float::from_hex(string.as_str().trim())
             .ok_or_else(|| vm.new_value_error("invalid hexadecimal floating-point string"))?;
         PyType::call(&cls, vec![vm.ctx.new_float(result).into()].into(), vm)
@@ -458,7 +525,20 @@ pub(crate) fn get_value(obj: &PyObject) -> f64 {
     obj.downcast_ref::<PyFloat>().unwrap().value
 }
 
+fn vectorcall_float(
+    zelf_obj: &PyObject,
+    args: Vec<PyObjectRef>,
+    nargs: usize,
+    kwnames: Option<&[PyObjectRef]>,
+    vm: &VirtualMachine,
+) -> PyResult {
+    let zelf: &Py<PyType> = zelf_obj.downcast_ref().unwrap();
+    let func_args = FuncArgs::from_vectorcall_owned(args, nargs, kwnames);
+    (zelf.slots.new.load().unwrap())(zelf.to_owned(), func_args, vm)
+}
+
 #[rustfmt::skip] // to avoid line splitting
-pub fn init(context: &Context) {
+pub fn init(context: &'static Context) {
     PyFloat::extend_class(context, context.types.float_type);
+    context.types.float_type.slots.vectorcall.store(Some(vectorcall_float));
 }
diff --git a/crates/vm/src/builtins/frame.rs b/crates/vm/src/builtins/frame.rs
index 28c4e751476..4601eee4467 100644
--- a/crates/vm/src/builtins/frame.rs
+++ b/crates/vm/src/builtins/frame.rs
@@ -4,15 +4,426 @@
 
 use super::{PyCode, PyDictRef, PyIntRef, PyStrRef};
 use crate::{
-    AsObject, Context, Py, PyObjectRef, PyRef, PyResult, VirtualMachine,
+    Context, Py, PyObjectRef, PyRef, PyResult, VirtualMachine,
     class::PyClassImpl,
-    frame::{Frame, FrameRef},
+    frame::{Frame, FrameOwner, FrameRef},
     function::PySetterValue,
     types::Representable,
 };
 use num_traits::Zero;
+use rustpython_compiler_core::bytecode::{
+    self, Constant, Instruction, InstructionMetadata, StackEffect,
+};
+use stack_analysis::*;
+
+/// Stack state analysis for safe line-number jumps.
+///
+/// Models the evaluation stack as a 64-bit integer, encoding the kind of each
+/// stack entry in 3-bit blocks. Used by `set_f_lineno` to verify that a jump
+/// is safe and to determine how many values need to be popped.
+pub(crate) mod stack_analysis {
+    use super::*;
+
+    const BITS_PER_BLOCK: u32 = 3;
+    const MASK: i64 = (1 << BITS_PER_BLOCK) - 1; // 0b111
+    const MAX_STACK_ENTRIES: u32 = 63 / BITS_PER_BLOCK; // 21
+    const WILL_OVERFLOW: u64 = 1u64 << ((MAX_STACK_ENTRIES - 1) * BITS_PER_BLOCK);
+
+    pub const EMPTY_STACK: i64 = 0;
+    pub const UNINITIALIZED: i64 = -2;
+    pub const OVERFLOWED: i64 = -1;
+
+    /// Kind of a stack entry.
+    #[derive(Clone, Copy, PartialEq, Eq, Debug)]
+    #[repr(i64)]
+    pub enum Kind {
+        Iterator = 1,
+        Except = 2,
+        Object = 3,
+        Null = 4,
+        Lasti = 5,
+    }
+
+    impl Kind {
+        fn from_i64(v: i64) -> Option<Self> {
+            match v {
+                1 => Some(Kind::Iterator),
+                2 => Some(Kind::Except),
+                3 => Some(Kind::Object),
+                4 => Some(Kind::Null),
+                5 => Some(Kind::Lasti),
+                _ => None,
+            }
+        }
+    }
+
+    pub fn push_value(stack: i64, kind: i64) -> i64 {
+        if (stack as u64) >= WILL_OVERFLOW {
+            OVERFLOWED
+        } else {
+            (stack << BITS_PER_BLOCK) | kind
+        }
+    }
+
+    pub fn pop_value(stack: i64) -> i64 {
+        stack >> BITS_PER_BLOCK
+    }
+
+    pub fn top_of_stack(stack: i64) -> i64 {
+        stack & MASK
+    }
+
+    fn peek(stack: i64, n: u32) -> i64 {
+        debug_assert!(n >= 1);
+        (stack >> (BITS_PER_BLOCK * (n - 1))) & MASK
+    }
+
+    fn stack_swap(stack: i64, n: u32) -> i64 {
+        debug_assert!(n >= 1);
+        let to_swap = peek(stack, n);
+        let top = top_of_stack(stack);
+        let shift = BITS_PER_BLOCK * (n - 1);
+        let replaced_low = (stack & !(MASK << shift)) | (top << shift);
+        (replaced_low & !MASK) | to_swap
+    }
+
+    fn pop_to_level(mut stack: i64, level: u32) -> i64 {
+        if level == 0 {
+            return EMPTY_STACK;
+        }
+        let max_item: i64 = (1 << BITS_PER_BLOCK) - 1;
+        let level_max_stack = max_item << ((level - 1) * BITS_PER_BLOCK);
+        while stack > level_max_stack {
+            stack = pop_value(stack);
+        }
+        stack
+    }
+
+    fn compatible_kind(from: i64, to: i64) -> bool {
+        if to == 0 {
+            return false;
+        }
+        if to == Kind::Object as i64 {
+            return from != Kind::Null as i64;
+        }
+        if to == Kind::Null as i64 {
+            return true;
+        }
+        from == to
+    }
+
+    pub fn compatible_stack(from_stack: i64, to_stack: i64) -> bool {
+        if from_stack < 0 || to_stack < 0 {
+            return false;
+        }
+        let mut from = from_stack;
+        let mut to = to_stack;
+        while from > to {
+            from = pop_value(from);
+        }
+        while from != 0 {
+            let from_top = top_of_stack(from);
+            let to_top = top_of_stack(to);
+            if !compatible_kind(from_top, to_top) {
+                return false;
+            }
+            from = pop_value(from);
+            to = pop_value(to);
+        }
+        to == 0
+    }
+
+    pub fn explain_incompatible_stack(to_stack: i64) -> &'static str {
+        debug_assert!(to_stack != 0);
+        if to_stack == OVERFLOWED {
+            return "stack is too deep to analyze";
+        }
+        if to_stack == UNINITIALIZED {
+            return "can't jump into an exception handler, or code may be unreachable";
+        }
+        match Kind::from_i64(top_of_stack(to_stack)) {
+            Some(Kind::Except) => "can't jump into an 'except' block as there's no exception",
+            Some(Kind::Lasti) => "can't jump into a re-raising block as there's no location",
+            Some(Kind::Iterator) => "can't jump into the body of a for loop",
+            _ => "incompatible stacks",
+        }
+    }
+
+    /// Analyze bytecode and compute the stack state at each instruction index.
+    pub fn mark_stacks<C: Constant>(code: &bytecode::CodeObject<C>) -> Vec<i64> {
+        let instructions = &*code.instructions;
+        let len = instructions.len();
+
+        let mut stacks = vec![UNINITIALIZED; len + 1];
+        stacks[0] = EMPTY_STACK;
+
+        let mut todo = true;
+        while todo {
+            todo = false;
+
+            let mut i = 0;
+            while i < len {
+                let mut next_stack = stacks[i];
+                let mut opcode = instructions[i].op;
+                let mut oparg: u32 = 0;
+
+                // Accumulate EXTENDED_ARG prefixes
+                while matches!(opcode, Instruction::ExtendedArg) {
+                    oparg = (oparg << 8) | u32::from(u8::from(instructions[i].arg));
+                    i += 1;
+                    if i >= len {
+                        break;
+                    }
+                    stacks[i] = next_stack;
+                    opcode = instructions[i].op;
+                }
+                if i >= len {
+                    break;
+                }
+                oparg = (oparg << 8) | u32::from(u8::from(instructions[i].arg));
+
+                // De-instrument and de-specialize: get the underlying base instruction
+                let opcode = opcode.to_base().unwrap_or(opcode).deoptimize();
+
+                let caches = opcode.cache_entries();
+                let next_i = i + 1 + caches;
+
+                if next_stack == UNINITIALIZED {
+                    i = next_i;
+                    continue;
+                }
+
+                match opcode {
+                    Instruction::PopJumpIfFalse { .. }
+                    | Instruction::PopJumpIfTrue { .. }
+                    | Instruction::PopJumpIfNone { .. }
+                    | Instruction::PopJumpIfNotNone { .. } => {
+                        // Relative forward: target = after_caches + delta
+                        let j = next_i + oparg as usize;
+                        next_stack = pop_value(next_stack);
+                        let target_stack = next_stack;
+                        if j < stacks.len() && stacks[j] == UNINITIALIZED {
+                            stacks[j] = target_stack;
+                        }
+                        if next_i < stacks.len() {
+                            stacks[next_i] = next_stack;
+                        }
+                    }
+                    Instruction::Send { .. } => {
+                        // Relative forward: target = after_caches + delta
+                        let j = next_i + oparg as usize;
+                        if j < stacks.len() && stacks[j] == UNINITIALIZED {
+                            stacks[j] = next_stack;
+                        }
+                        if next_i < stacks.len() {
+                            stacks[next_i] = next_stack;
+                        }
+                    }
+                    Instruction::JumpForward { .. } => {
+                        // Relative forward: target = after_caches + delta
+                        let j = next_i + oparg as usize;
+                        if j < stacks.len() && stacks[j] == UNINITIALIZED {
+                            stacks[j] = next_stack;
+                        }
+                    }
+                    Instruction::JumpBackward { .. }
+                    | Instruction::JumpBackwardNoInterrupt { .. } => {
+                        // Relative backward: target = after_caches - delta
+                        let j = next_i - oparg as usize;
+                        if j < stacks.len() && stacks[j] == UNINITIALIZED {
+                            stacks[j] = next_stack;
+                            if j < i {
+                                todo = true;
+                            }
+                        }
+                    }
+                    Instruction::GetIter | Instruction::GetAIter => {
+                        next_stack = push_value(pop_value(next_stack), Kind::Iterator as i64);
+                        if next_i < stacks.len() {
+                            stacks[next_i] = next_stack;
+                        }
+                    }
+                    Instruction::ForIter { .. } => {
+                        // Fall-through (iteration continues): pushes the next value
+                        let body_stack = push_value(next_stack, Kind::Object as i64);
+                        if next_i < stacks.len() {
+                            stacks[next_i] = body_stack;
+                        }
+                        // Exhaustion path: relative forward from after_caches
+                        let mut j = next_i + oparg as usize;
+                        if j < instructions.len() {
+                            let target_op =
+                                instructions[j].op.to_base().unwrap_or(instructions[j].op);
+                            if matches!(target_op, Instruction::EndFor) {
+                                j += 1;
+                            }
+                        }
+                        if j < stacks.len() && stacks[j] == UNINITIALIZED {
+                            stacks[j] = next_stack;
+                        }
+                    }
+                    Instruction::EndAsyncFor => {
+                        next_stack = pop_value(pop_value(next_stack));
+                        if next_i < stacks.len() {
+                            stacks[next_i] = next_stack;
+                        }
+                    }
+                    Instruction::PushExcInfo => {
+                        next_stack = push_value(next_stack, Kind::Except as i64);
+                        if next_i < stacks.len() {
+                            stacks[next_i] = next_stack;
+                        }
+                    }
+                    Instruction::PopExcept => {
+                        next_stack = pop_value(next_stack);
+                        if next_i < stacks.len() {
+                            stacks[next_i] = next_stack;
+                        }
+                    }
+                    Instruction::ReturnValue => {
+                        // End of block, no fall-through
+                    }
+                    Instruction::RaiseVarargs { .. } => {
+                        // End of block, no fall-through
+                    }
+                    Instruction::Reraise { .. } => {
+                        // End of block, no fall-through
+                    }
+                    Instruction::PushNull => {
+                        next_stack = push_value(next_stack, Kind::Null as i64);
+                        if next_i < stacks.len() {
+                            stacks[next_i] = next_stack;
+                        }
+                    }
+                    Instruction::LoadGlobal { .. } => {
+                        next_stack = push_value(next_stack, Kind::Object as i64);
+                        if oparg & 1 != 0 {
+                            next_stack = push_value(next_stack, Kind::Null as i64);
+                        }
+                        if next_i < stacks.len() {
+                            stacks[next_i] = next_stack;
+                        }
+                    }
+                    Instruction::LoadAttr { .. } => {
+                        // LoadAttr: pops object, pushes result
+                        // If oparg & 1, it also pushes Null (method load)
+                        let attr_oparg = oparg;
+                        if attr_oparg & 1 != 0 {
+                            next_stack = pop_value(next_stack);
+                            next_stack = push_value(next_stack, Kind::Object as i64);
+                            next_stack = push_value(next_stack, Kind::Null as i64);
+                        }
+                        // else: default stack_effect handles it
+                        else {
+                            let effect: StackEffect = opcode.stack_effect_info(oparg);
+                            let popped = effect.popped() as i64;
+                            let pushed = effect.pushed() as i64;
+                            for _ in 0..popped {
+                                next_stack = pop_value(next_stack);
+                            }
+                            for _ in 0..pushed {
+                                next_stack = push_value(next_stack, Kind::Object as i64);
+                            }
+                        }
+                        if next_i < stacks.len() {
+                            stacks[next_i] = next_stack;
+                        }
+                    }
+                    Instruction::Swap { .. } => {
+                        let n = oparg;
+                        next_stack = stack_swap(next_stack, n);
+                        if next_i < stacks.len() {
+                            stacks[next_i] = next_stack;
+                        }
+                    }
+                    Instruction::Copy { .. } => {
+                        let n = oparg;
+                        next_stack = push_value(next_stack, peek(next_stack, n));
+                        if next_i < stacks.len() {
+                            stacks[next_i] = next_stack;
+                        }
+                    }
+                    _ => {
+                        // Default: use stack_effect
+                        let effect: StackEffect = opcode.stack_effect_info(oparg);
+                        let popped = effect.popped() as i64;
+                        let pushed = effect.pushed() as i64;
+                        let mut ns = next_stack;
+                        for _ in 0..popped {
+                            ns = pop_value(ns);
+                        }
+                        for _ in 0..pushed {
+                            ns = push_value(ns, Kind::Object as i64);
+                        }
+                        next_stack = ns;
+                        if next_i < stacks.len() {
+                            stacks[next_i] = next_stack;
+                        }
+                    }
+                }
+                i = next_i;
+            }
+
+            // Scan exception table
+            let exception_table = bytecode::decode_exception_table(&code.exceptiontable);
+            for entry in &exception_table {
+                let start_offset = entry.start as usize;
+                let handler = entry.target as usize;
+                let level = entry.depth as u32;
+                let has_lasti = entry.push_lasti;
+
+                if start_offset < stacks.len()
+                    && stacks[start_offset] != UNINITIALIZED
+                    && handler < stacks.len()
+                    && stacks[handler] == UNINITIALIZED
+                {
+                    todo = true;
+                    let mut target_stack = pop_to_level(stacks[start_offset], level);
+                    if has_lasti {
+                        target_stack = push_value(target_stack, Kind::Lasti as i64);
+                    }
+                    target_stack = push_value(target_stack, Kind::Except as i64);
+                    stacks[handler] = target_stack;
+                }
+            }
+        }
+
+        stacks
+    }
+
+    /// Build a mapping from instruction index to line number.
+    /// Returns -1 for indices with no line start.
+    pub fn mark_lines<C: Constant>(code: &bytecode::CodeObject<C>) -> Vec<i32> {
+        let len = code.instructions.len();
+        let mut line_starts = vec![-1i32; len];
+        let mut last_line: i32 = -1;
+
+        for (i, (loc, _)) in code.locations.iter().enumerate() {
+            if i >= len {
+                break;
+            }
+            let line = loc.line.get() as i32;
+            if line != last_line && line > 0 {
+                line_starts[i] = line;
+                last_line = line;
+            }
+        }
+        line_starts
+    }
 
-pub fn init(context: &Context) {
+    /// Find the first line number >= `line` that has code.
+    pub fn first_line_not_before(lines: &[i32], line: i32) -> i32 {
+        let mut result = i32::MAX;
+        for &l in lines {
+            if l >= line && l < result {
+                result = l;
+            }
+        }
+        if result == i32::MAX { -1 } else { result }
+    }
+}
+
+pub fn init(context: &'static Context) {
     Frame::extend_class(context, context.types.frame_type);
 }
 
@@ -31,24 +442,22 @@ impl Representable for Frame {
 
 #[pyclass(flags(DISALLOW_INSTANTIATION), with(Py))]
 impl Frame {
-    #[pymethod]
-    const fn clear(&self) {
-        // TODO
-    }
-
     #[pygetset]
     fn f_globals(&self) -> PyDictRef {
         self.globals.clone()
     }
 
     #[pygetset]
-    fn f_builtins(&self) -> PyDictRef {
+    fn f_builtins(&self) -> PyObjectRef {
         self.builtins.clone()
     }
 
     #[pygetset]
     fn f_locals(&self, vm: &VirtualMachine) -> PyResult {
-        self.locals(vm).map(Into::into)
+        let result = self.locals(vm).map(Into::into);
+        self.locals_dirty
+            .store(true, core::sync::atomic::Ordering::Release);
+        result
     }
 
     #[pygetset]
@@ -73,6 +482,113 @@ impl Frame {
         }
     }
 
+    #[pygetset(setter)]
+    fn set_f_lineno(&self, value: PySetterValue, vm: &VirtualMachine) -> PyResult<()> {
+        let l_new_lineno = match value {
+            PySetterValue::Assign(val) => {
+                let line_ref: PyIntRef = val
+                    .downcast()
+                    .map_err(|_| vm.new_value_error("lineno must be an integer"))?;
+                line_ref
+                    .try_to_primitive::<i32>(vm)
+                    .map_err(|_| vm.new_value_error("lineno must be an integer"))?
+            }
+            PySetterValue::Delete => {
+                return Err(vm.new_type_error("can't delete f_lineno attribute"));
+            }
+        };
+
+        let first_line = self
+            .code
+            .first_line_number
+            .map(|n| n.get() as i32)
+            .unwrap_or(1);
+
+        if l_new_lineno < first_line {
+            return Err(vm.new_value_error(format!(
+                "line {l_new_lineno} comes before the current code block"
+            )));
+        }
+
+        let py_code: &PyCode = &self.code;
+        let code = &py_code.code;
+        let lines = mark_lines(code);
+
+        // Find the first line >= target that has actual code
+        let new_lineno = first_line_not_before(&lines, l_new_lineno);
+        if new_lineno < 0 {
+            return Err(vm.new_value_error(format!(
+                "line {l_new_lineno} comes after the current code block"
+            )));
+        }
+
+        let stacks = mark_stacks(code);
+        let len = self.code.instructions.len();
+
+        // lasti points past the current instruction (already incremented).
+        // stacks[lasti - 1] gives the stack state before executing the
+        // instruction that triggered this trace event, which is the current
+        // evaluation stack.
+        let current_lasti = self.lasti() as usize;
+        let start_idx = current_lasti.saturating_sub(1);
+        let start_stack = if start_idx < stacks.len() {
+            stacks[start_idx]
+        } else {
+            OVERFLOWED
+        };
+        let mut best_stack = OVERFLOWED;
+        let mut best_addr: i32 = -1;
+        let mut err: i32 = -1;
+        let mut msg = "cannot find bytecode for specified line";
+
+        for i in 0..len {
+            if lines[i] == new_lineno {
+                let target_stack = stacks[i];
+                if compatible_stack(start_stack, target_stack) {
+                    err = 0;
+                    if target_stack > best_stack {
+                        best_stack = target_stack;
+                        best_addr = i as i32;
+                    }
+                } else if err < 0 {
+                    if start_stack == OVERFLOWED {
+                        msg = "stack to deep to analyze";
+                    } else if start_stack == UNINITIALIZED {
+                        msg = "can't jump from unreachable code";
+                    } else {
+                        msg = explain_incompatible_stack(target_stack);
+                        err = 1;
+                    }
+                }
+            }
+        }
+
+        if err != 0 {
+            return Err(vm.new_value_error(msg.to_owned()));
+        }
+
+        // Count how many entries to pop
+        let mut pop_count = 0usize;
+        {
+            let mut s = start_stack;
+            while s > best_stack {
+                pop_count += 1;
+                s = pop_value(s);
+            }
+        }
+
+        // Store the pending unwind for the execution loop to perform.
+        // We cannot pop stack entries here because the execution loop
+        // holds the state mutex, and trying to lock it again would deadlock.
+        self.set_pending_stack_pops(pop_count as u32);
+        self.set_pending_unwind_from_stack(start_stack);
+
+        // Set lasti to best_addr. The executor will read lasti and execute
+        // the instruction at that index next.
+        self.set_lasti(best_addr as u32);
+        Ok(())
+    }
+
     #[pygetset]
     fn f_trace(&self) -> PyObjectRef {
         let boxed = self.trace.lock();
@@ -115,22 +631,126 @@ impl Frame {
             PySetterValue::Delete => Err(vm.new_type_error("can't delete numeric/char attribute")),
         }
     }
+
+    #[pymember(type = "bool")]
+    fn f_trace_opcodes(vm: &VirtualMachine, zelf: PyObjectRef) -> PyResult {
+        let zelf: FrameRef = zelf.downcast().unwrap_or_else(|_| unreachable!());
+        let trace_opcodes = zelf.trace_opcodes.lock();
+        Ok(vm.ctx.new_bool(*trace_opcodes).into())
+    }
+
+    #[pymember(type = "bool", setter)]
+    fn set_f_trace_opcodes(
+        vm: &VirtualMachine,
+        zelf: PyObjectRef,
+        value: PySetterValue,
+    ) -> PyResult<()> {
+        match value {
+            PySetterValue::Assign(value) => {
+                let zelf: FrameRef = zelf.downcast().unwrap_or_else(|_| unreachable!());
+
+                let value: PyIntRef = value
+                    .downcast()
+                    .map_err(|_| vm.new_type_error("attribute value type must be bool"))?;
+
+                let mut trace_opcodes = zelf.trace_opcodes.lock();
+                *trace_opcodes = !value.as_bigint().is_zero();
+
+                // TODO: Implement the equivalent of _PyEval_SetOpcodeTrace()
+
+                Ok(())
+            }
+            PySetterValue::Delete => Err(vm.new_type_error("can't delete numeric/char attribute")),
+        }
+    }
 }
 
 #[pyclass]
 impl Py<Frame> {
+    #[pymethod]
+    // = frame_clear_impl
+    fn clear(&self, vm: &VirtualMachine) -> PyResult<()> {
+        let owner = FrameOwner::from_i8(self.owner.load(core::sync::atomic::Ordering::Acquire));
+        match owner {
+            FrameOwner::Generator => {
+                // Generator frame: check if suspended (lasti > 0 means
+                // FRAME_SUSPENDED). lasti == 0 means FRAME_CREATED and
+                // can be cleared.
+                if self.lasti() != 0 {
+                    return Err(vm.new_runtime_error("cannot clear a suspended frame"));
+                }
+            }
+            FrameOwner::Thread => {
+                // Thread-owned frame: always executing, cannot clear.
+                return Err(vm.new_runtime_error("cannot clear an executing frame"));
+            }
+            FrameOwner::FrameObject => {
+                // Detached frame: safe to clear.
+            }
+        }
+
+        // Clear fastlocals
+        // SAFETY: Frame is not executing (detached or stopped).
+        {
+            let fastlocals = unsafe { self.fastlocals_mut() };
+            for slot in fastlocals.iter_mut() {
+                *slot = None;
+            }
+        }
+
+        // Clear the evaluation stack and cell references
+        self.clear_stack_and_cells();
+
+        // Clear temporary refs
+        self.temporary_refs.lock().clear();
+
+        Ok(())
+    }
+
+    #[pygetset]
+    fn f_generator(&self) -> Option<PyObjectRef> {
+        self.generator.to_owned()
+    }
+
     #[pygetset]
     pub fn f_back(&self, vm: &VirtualMachine) -> Option<PyRef<Frame>> {
-        // TODO: actually store f_back inside Frame struct
+        let previous = self.previous_frame();
+        if previous.is_null() {
+            return None;
+        }
 
-        // get the frame in the frame stack that appears before this one.
-        // won't work if  this frame isn't in the frame stack, hence the todo above
-        vm.frames
+        if let Some(frame) = vm
+            .frames
             .borrow()
             .iter()
-            .rev()
-            .skip_while(|p| !p.is(self.as_object()))
-            .nth(1)
-            .cloned()
+            .find(|fp| {
+                // SAFETY: the caller keeps the FrameRef alive while it's in the Vec
+                let py: &crate::Py<Frame> = unsafe { fp.as_ref() };
+                let ptr: *const Frame = &**py;
+                core::ptr::eq(ptr, previous)
+            })
+            .map(|fp| unsafe { fp.as_ref() }.to_owned())
+        {
+            return Some(frame);
+        }
+
+        #[cfg(feature = "threading")]
+        {
+            let registry = vm.state.thread_frames.lock();
+            for slot in registry.values() {
+                let frames = slot.frames.lock();
+                // SAFETY: the owning thread can't pop while we hold the Mutex,
+                // so FramePtr is valid for the duration of the lock.
+                if let Some(frame) = frames.iter().find_map(|fp| {
+                    let f = unsafe { fp.as_ref() };
+                    let ptr: *const Frame = &**f;
+                    core::ptr::eq(ptr, previous).then(|| f.to_owned())
+                }) {
+                    return Some(frame);
+                }
+            }
+        }
+
+        None
     }
 }
diff --git a/crates/vm/src/builtins/function.rs b/crates/vm/src/builtins/function.rs
index 7eb74dec41e..782daf0b9a6 100644
--- a/crates/vm/src/builtins/function.rs
+++ b/crates/vm/src/builtins/function.rs
@@ -5,33 +5,66 @@ use super::{
     PyAsyncGen, PyCode, PyCoroutine, PyDictRef, PyGenerator, PyModule, PyStr, PyStrRef, PyTuple,
     PyTupleRef, PyType,
 };
-#[cfg(feature = "jit")]
-use crate::common::lock::OnceCell;
+use crate::common::hash::PyHash;
 use crate::common::lock::PyMutex;
 use crate::function::ArgMapping;
-use crate::object::{Traverse, TraverseFn};
+use crate::object::{PyAtomicRef, Traverse, TraverseFn};
 use crate::{
     AsObject, Context, Py, PyObject, PyObjectRef, PyPayload, PyRef, PyResult, VirtualMachine,
     bytecode,
     class::PyClassImpl,
-    frame::Frame,
+    common::wtf8::{Wtf8Buf, wtf8_concat},
+    frame::{Frame, FrameRef},
     function::{FuncArgs, OptionalArg, PyComparisonValue, PySetterValue},
     scope::Scope,
     types::{
-        Callable, Comparable, Constructor, GetAttr, GetDescriptor, PyComparisonOp, Representable,
+        Callable, Comparable, Constructor, GetAttr, GetDescriptor, Hashable, PyComparisonOp,
+        Representable,
     },
 };
+use core::sync::atomic::{AtomicU32, Ordering::Relaxed};
 use itertools::Itertools;
 #[cfg(feature = "jit")]
 use rustpython_jit::CompiledCode;
 
+fn format_missing_args(
+    qualname: impl core::fmt::Display,
+    kind: &str,
+    missing: &mut Vec<impl core::fmt::Display>,
+) -> String {
+    let count = missing.len();
+    let last = if missing.len() > 1 {
+        missing.pop()
+    } else {
+        None
+    };
+    let (and, right): (&str, String) = if let Some(last) = last {
+        (
+            if missing.len() == 1 {
+                "' and '"
+            } else {
+                "', and '"
+            },
+            format!("{last}"),
+        )
+    } else {
+        ("", String::new())
+    };
+    format!(
+        "{qualname}() missing {count} required {kind} argument{}: '{}{}{right}'",
+        if count == 1 { "" } else { "s" },
+        missing.iter().join("', '"),
+        and,
+    )
+}
+
 #[pyclass(module = false, name = "function", traverse = "manual")]
 #[derive(Debug)]
 pub struct PyFunction {
-    code: PyMutex<PyRef<PyCode>>,
+    code: PyAtomicRef<PyCode>,
     globals: PyDictRef,
     builtins: PyObjectRef,
-    closure: Option<PyRef<PyTuple<PyCellRef>>>,
+    pub(crate) closure: Option<PyRef<PyTuple<PyCellRef>>>,
     defaults_and_kwdefaults: PyMutex<(Option<PyTupleRef>, Option<PyDictRef>)>,
     name: PyMutex<PyStrRef>,
     qualname: PyMutex<PyStrRef>,
@@ -40,8 +73,19 @@ pub struct PyFunction {
     annotate: PyMutex<Option<PyObjectRef>>,
     module: PyMutex<PyObjectRef>,
     doc: PyMutex<PyObjectRef>,
+    func_version: AtomicU32,
     #[cfg(feature = "jit")]
-    jitted_code: OnceCell<CompiledCode>,
+    jitted_code: PyMutex<Option<CompiledCode>>,
+}
+
+static FUNC_VERSION_COUNTER: AtomicU32 = AtomicU32::new(1);
+
+/// Atomically allocate the next function version, returning 0 if exhausted.
+/// Once the counter wraps to 0, it stays at 0 permanently.
+fn next_func_version() -> u32 {
+    FUNC_VERSION_COUNTER
+        .fetch_update(Relaxed, Relaxed, |v| (v != 0).then(|| v.wrapping_add(1)))
+        .unwrap_or(0)
 }
 
 unsafe impl Traverse for PyFunction {
@@ -89,28 +133,29 @@ unsafe impl Traverse for PyFunction {
         // 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());
+                core::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());
+            let old_doc =
+                core::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());
+                core::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());
+            let old_name = core::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());
+                core::mem::replace(&mut *guard, Context::genesis().empty_str.to_owned());
             out.push(old_qualname.into());
         }
 
@@ -130,7 +175,7 @@ impl PyFunction {
         let builtins = globals.get_item("__builtins__", vm).unwrap_or_else(|_| {
             // If not in globals, inherit from current execution context
             if let Some(frame) = vm.current_frame() {
-                frame.builtins.clone().into()
+                frame.builtins.clone()
             } else {
                 vm.builtins.dict().into()
             }
@@ -155,7 +200,7 @@ impl PyFunction {
 
         let qualname = vm.ctx.new_str(code.qualname.as_str());
         let func = Self {
-            code: PyMutex::new(code.clone()),
+            code: PyAtomicRef::from(code.clone()),
             globals,
             builtins,
             closure: None,
@@ -167,8 +212,9 @@ impl PyFunction {
             annotate: PyMutex::new(None),
             module: PyMutex::new(module),
             doc: PyMutex::new(doc),
+            func_version: AtomicU32::new(next_func_version()),
             #[cfg(feature = "jit")]
-            jitted_code: OnceCell::new(),
+            jitted_code: PyMutex::new(None),
         };
         Ok(func)
     }
@@ -179,7 +225,7 @@ impl PyFunction {
         func_args: FuncArgs,
         vm: &VirtualMachine,
     ) -> PyResult<()> {
-        let code = &*self.code.lock();
+        let code: &Py<PyCode> = &self.code;
         let nargs = func_args.args.len();
         let n_expected_args = code.arg_count as usize;
         let total_args = code.arg_count as usize + code.kwonlyarg_count as usize;
@@ -191,7 +237,8 @@ impl PyFunction {
         // See also: PyEval_EvalCodeWithName in cpython:
         // https://github.com/python/cpython/blob/main/Python/ceval.c#L3681
 
-        let mut fastlocals = frame.fastlocals.lock();
+        // SAFETY: Frame was just created and not yet executing.
+        let fastlocals = unsafe { frame.fastlocals_mut() };
 
         let mut args_iter = func_args.args.into_iter();
 
@@ -226,13 +273,37 @@ impl PyFunction {
                 } else {
                     n_expected_args.to_string()
                 };
+
+                // Count keyword-only arguments that were actually provided
+                let kw_only_given = if code.kwonlyarg_count > 0 {
+                    let start = code.arg_count as usize;
+                    let end = start + code.kwonlyarg_count as usize;
+                    code.varnames[start..end]
+                        .iter()
+                        .filter(|name| func_args.kwargs.contains_key(name.as_str()))
+                        .count()
+                } else {
+                    0
+                };
+
+                let given_msg = if kw_only_given > 0 {
+                    format!(
+                        "{} positional argument{} (and {} keyword-only argument{}) were",
+                        nargs,
+                        if nargs == 1 { "" } else { "s" },
+                        kw_only_given,
+                        if kw_only_given == 1 { "" } else { "s" },
+                    )
+                } else {
+                    format!("{} {}", nargs, if nargs == 1 { "was" } else { "were" })
+                };
+
                 return Err(vm.new_type_error(format!(
-                    "{}() takes {} positional argument{} but {} {} given",
+                    "{}() takes {} positional argument{} but {} given",
                     self.__qualname__(),
                     takes_msg,
                     if n_expected_args == 1 { "" } else { "s" },
-                    nargs,
-                    if nargs == 1 { "was" } else { "were" }
+                    given_msg,
                 )));
             }
         }
@@ -318,36 +389,12 @@ impl PyFunction {
                     }
                 })
                 .collect();
-            let missing_args_len = missing.len();
 
             if !missing.is_empty() {
-                let last = if missing.len() > 1 {
-                    missing.pop()
-                } else {
-                    None
-                };
-
-                let (and, right) = if let Some(last) = last {
-                    (
-                        if missing.len() == 1 {
-                            "' and '"
-                        } else {
-                            "', and '"
-                        },
-                        last.as_str(),
-                    )
-                } else {
-                    ("", "")
-                };
-
-                return Err(vm.new_type_error(format!(
-                    "{}() missing {} required positional argument{}: '{}{}{}'",
+                return Err(vm.new_type_error(format_missing_args(
                     self.__qualname__(),
-                    missing_args_len,
-                    if missing_args_len == 1 { "" } else { "s" },
-                    missing.iter().join("', '"),
-                    and,
-                    right,
+                    "positional",
+                    &mut missing,
                 )));
             }
 
@@ -367,8 +414,7 @@ impl PyFunction {
         };
 
         if code.kwonlyarg_count > 0 {
-            // TODO: compile a list of missing arguments
-            // let mut missing = vec![];
+            let mut missing = Vec::new();
             // Check if kw only arguments are all present:
             for (slot, kwarg) in fastlocals
                 .iter_mut()
@@ -385,16 +431,15 @@ impl PyFunction {
                 }
 
                 // No default value and not specified.
-                return Err(
-                    vm.new_type_error(format!("Missing required kw only argument: '{kwarg}'"))
-                );
+                missing.push(kwarg);
             }
-        }
 
-        if let Some(cell2arg) = code.cell2arg.as_deref() {
-            for (cell_idx, arg_idx) in cell2arg.iter().enumerate().filter(|(_, i)| **i != -1) {
-                let x = fastlocals[*arg_idx as usize].take();
-                frame.cells_frees[cell_idx].set(x);
+            if !missing.is_empty() {
+                return Err(vm.new_type_error(format_missing_args(
+                    self.__qualname__(),
+                    "keyword-only",
+                    &mut missing,
+                )));
             }
         }
 
@@ -404,81 +449,87 @@ impl PyFunction {
     /// Set function attribute based on MakeFunctionFlags
     pub(crate) fn set_function_attribute(
         &mut self,
-        attr: bytecode::MakeFunctionFlags,
+        attr: bytecode::MakeFunctionFlag,
         attr_value: PyObjectRef,
         vm: &VirtualMachine,
     ) -> PyResult<()> {
         use crate::builtins::PyDict;
-        if attr == bytecode::MakeFunctionFlags::DEFAULTS {
-            let defaults = match attr_value.downcast::<PyTuple>() {
-                Ok(tuple) => tuple,
-                Err(obj) => {
-                    return Err(vm.new_type_error(format!(
-                        "__defaults__ must be a tuple, not {}",
-                        obj.class().name()
-                    )));
-                }
-            };
-            self.defaults_and_kwdefaults.lock().0 = Some(defaults);
-        } else if attr == bytecode::MakeFunctionFlags::KW_ONLY_DEFAULTS {
-            let kwdefaults = match attr_value.downcast::<PyDict>() {
-                Ok(dict) => dict,
-                Err(obj) => {
-                    return Err(vm.new_type_error(format!(
-                        "__kwdefaults__ must be a dict, not {}",
-                        obj.class().name()
-                    )));
-                }
-            };
-            self.defaults_and_kwdefaults.lock().1 = Some(kwdefaults);
-        } else if attr == bytecode::MakeFunctionFlags::ANNOTATIONS {
-            let annotations = match attr_value.downcast::<PyDict>() {
-                Ok(dict) => dict,
-                Err(obj) => {
-                    return Err(vm.new_type_error(format!(
-                        "__annotations__ must be a dict, not {}",
-                        obj.class().name()
-                    )));
-                }
-            };
-            *self.annotations.lock() = Some(annotations);
-        } else if attr == bytecode::MakeFunctionFlags::CLOSURE {
-            // For closure, we need special handling
-            // The closure tuple contains cell objects
-            let closure_tuple = attr_value
-                .clone()
-                .downcast_exact::<PyTuple>(vm)
-                .map_err(|obj| {
+        match attr {
+            bytecode::MakeFunctionFlag::Defaults => {
+                let defaults = match attr_value.downcast::<PyTuple>() {
+                    Ok(tuple) => tuple,
+                    Err(obj) => {
+                        return Err(vm.new_type_error(format!(
+                            "__defaults__ must be a tuple, not {}",
+                            obj.class().name()
+                        )));
+                    }
+                };
+                self.defaults_and_kwdefaults.lock().0 = Some(defaults);
+            }
+            bytecode::MakeFunctionFlag::KwOnlyDefaults => {
+                let kwdefaults = match attr_value.downcast::<PyDict>() {
+                    Ok(dict) => dict,
+                    Err(obj) => {
+                        return Err(vm.new_type_error(format!(
+                            "__kwdefaults__ must be a dict, not {}",
+                            obj.class().name()
+                        )));
+                    }
+                };
+                self.defaults_and_kwdefaults.lock().1 = Some(kwdefaults);
+            }
+            bytecode::MakeFunctionFlag::Annotations => {
+                let annotations = match attr_value.downcast::<PyDict>() {
+                    Ok(dict) => dict,
+                    Err(obj) => {
+                        return Err(vm.new_type_error(format!(
+                            "__annotations__ must be a dict, not {}",
+                            obj.class().name()
+                        )));
+                    }
+                };
+                *self.annotations.lock() = Some(annotations);
+            }
+            bytecode::MakeFunctionFlag::Closure => {
+                let closure_tuple = attr_value
+                    .clone()
+                    .downcast_exact::<PyTuple>(vm)
+                    .map_err(|obj| {
+                        vm.new_type_error(format!(
+                            "closure must be a tuple, not {}",
+                            obj.class().name()
+                        ))
+                    })?
+                    .into_pyref();
+
+                self.closure = Some(closure_tuple.try_into_typed::<PyCell>(vm)?);
+            }
+            bytecode::MakeFunctionFlag::TypeParams => {
+                let type_params = attr_value.clone().downcast::<PyTuple>().map_err(|_| {
                     vm.new_type_error(format!(
-                        "closure must be a tuple, not {}",
-                        obj.class().name()
+                        "__type_params__ must be a tuple, not {}",
+                        attr_value.class().name()
                     ))
-                })?
-                .into_pyref();
-
-            self.closure = Some(closure_tuple.try_into_typed::<PyCell>(vm)?);
-        } else if attr == bytecode::MakeFunctionFlags::TYPE_PARAMS {
-            let type_params = attr_value.clone().downcast::<PyTuple>().map_err(|_| {
-                vm.new_type_error(format!(
-                    "__type_params__ must be a tuple, not {}",
-                    attr_value.class().name()
-                ))
-            })?;
-            *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.type_params.lock() = type_params;
+            }
+            bytecode::MakeFunctionFlag::Annotate => {
+                if !attr_value.is_callable() {
+                    return Err(vm.new_type_error("__annotate__ must be callable"));
+                }
+                *self.annotate.lock() = Some(attr_value);
             }
-            *self.annotate.lock() = Some(attr_value);
-        } else {
-            unreachable!("This is a compiler bug");
         }
         Ok(())
     }
 }
 
 impl Py<PyFunction> {
+    pub(crate) fn is_optimized_for_call_specialization(&self) -> bool {
+        self.code.flags.contains(bytecode::CodeFlags::OPTIMIZED)
+    }
+
     pub fn invoke_with_locals(
         &self,
         func_args: FuncArgs,
@@ -486,7 +537,7 @@ impl Py<PyFunction> {
         vm: &VirtualMachine,
     ) -> PyResult {
         #[cfg(feature = "jit")]
-        if let Some(jitted_code) = self.jitted_code.get() {
+        if let Some(jitted_code) = self.jitted_code.lock().as_ref() {
             use crate::convert::ToPyObject;
             match jit::get_jit_args(self, &func_args, jitted_code, vm) {
                 Ok(args) => {
@@ -495,49 +546,67 @@ impl Py<PyFunction> {
                 Err(err) => info!(
                     "jit: function `{}` is falling back to being interpreted because of the \
                     error: {}",
-                    self.code.lock().obj_name,
-                    err
+                    self.code.obj_name, err
                 ),
             }
         }
 
-        let code = self.code.lock().clone();
+        let code: PyRef<PyCode> = (*self.code).to_owned();
 
         let locals = if code.flags.contains(bytecode::CodeFlags::NEWLOCALS) {
-            ArgMapping::from_dict_exact(vm.ctx.new_dict())
+            None
         } else if let Some(locals) = locals {
-            locals
+            Some(locals)
         } else {
-            ArgMapping::from_dict_exact(self.globals.clone())
+            Some(ArgMapping::from_dict_exact(self.globals.clone()))
         };
 
+        let is_gen = code.flags.contains(bytecode::CodeFlags::GENERATOR);
+        let is_coro = code.flags.contains(bytecode::CodeFlags::COROUTINE);
+        let use_datastack = !(is_gen || is_coro);
+
         // Construct frame:
         let frame = Frame::new(
-            code.clone(),
-            Scope::new(Some(locals), self.globals.clone()),
-            vm.builtins.dict(),
+            code,
+            Scope::new(locals, self.globals.clone()),
+            self.builtins.clone(),
             self.closure.as_ref().map_or(&[], |c| c.as_slice()),
             Some(self.to_owned().into()),
+            use_datastack,
             vm,
         )
         .into_ref(&vm.ctx);
 
         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::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))
+                let obj = PyGenerator::new(frame.clone(), self.__name__(), self.__qualname__())
+                    .into_pyobject(vm);
+                frame.set_generator(&obj);
+                Ok(obj)
             }
             (false, true) => {
-                Ok(PyCoroutine::new(frame, self.__name__(), self.__qualname__()).into_pyobject(vm))
+                let obj = PyCoroutine::new(frame.clone(), self.__name__(), self.__qualname__())
+                    .into_pyobject(vm);
+                frame.set_generator(&obj);
+                Ok(obj)
             }
             (true, true) => {
-                Ok(PyAsyncGen::new(frame, self.__name__(), self.__qualname__()).into_pyobject(vm))
+                let obj = PyAsyncGen::new(frame.clone(), self.__name__(), self.__qualname__())
+                    .into_pyobject(vm);
+                frame.set_generator(&obj);
+                Ok(obj)
+            }
+            (false, false) => {
+                let result = vm.run_frame(frame.clone());
+                // Release data stack memory after frame execution completes.
+                unsafe {
+                    if let Some(base) = frame.materialize_localsplus() {
+                        vm.datastack_pop(base);
+                    }
+                }
+                result
             }
-            (false, false) => vm.run_frame(frame),
         }
     }
 
@@ -545,6 +614,160 @@ impl Py<PyFunction> {
     pub fn invoke(&self, func_args: FuncArgs, vm: &VirtualMachine) -> PyResult {
         self.invoke_with_locals(func_args, None, vm)
     }
+
+    /// Returns the function version, or 0 if invalidated.
+    #[inline]
+    pub fn func_version(&self) -> u32 {
+        self.func_version.load(Relaxed)
+    }
+
+    /// Returns the current version, assigning a fresh one if previously invalidated.
+    /// Returns 0 if the version counter has overflowed.
+    /// `_PyFunction_GetVersionForCurrentState`
+    pub fn get_version_for_current_state(&self) -> u32 {
+        let v = self.func_version.load(Relaxed);
+        if v != 0 {
+            return v;
+        }
+        let new_v = next_func_version();
+        if new_v == 0 {
+            return 0;
+        }
+        self.func_version.store(new_v, Relaxed);
+        new_v
+    }
+
+    /// function_kind(SIMPLE_FUNCTION) equivalent for CALL specialization.
+    /// Returns true if: CO_OPTIMIZED, no VARARGS, no VARKEYWORDS, no kwonly args.
+    pub(crate) fn is_simple_for_call_specialization(&self) -> bool {
+        let code: &Py<PyCode> = &self.code;
+        let flags = code.flags;
+        flags.contains(bytecode::CodeFlags::OPTIMIZED)
+            && !flags.intersects(bytecode::CodeFlags::VARARGS | bytecode::CodeFlags::VARKEYWORDS)
+            && code.kwonlyarg_count == 0
+    }
+
+    /// Check if this function is eligible for exact-args call specialization.
+    /// Returns true if: CO_OPTIMIZED, no VARARGS, no VARKEYWORDS, no kwonly args,
+    /// and effective_nargs matches co_argcount.
+    pub(crate) fn can_specialize_call(&self, effective_nargs: u32) -> bool {
+        let code: &Py<PyCode> = &self.code;
+        let flags = code.flags;
+        flags.contains(bytecode::CodeFlags::OPTIMIZED)
+            && !flags.intersects(bytecode::CodeFlags::VARARGS | bytecode::CodeFlags::VARKEYWORDS)
+            && code.kwonlyarg_count == 0
+            && code.arg_count == effective_nargs
+    }
+
+    /// Runtime guard for CALL_*_EXACT_ARGS specialization: check only argcount.
+    /// Other invariants are guaranteed by function versioning and specialization-time checks.
+    #[inline]
+    pub(crate) fn has_exact_argcount(&self, effective_nargs: u32) -> bool {
+        self.code.arg_count == effective_nargs
+    }
+
+    /// Bytes required for this function's frame on RustPython's thread datastack.
+    /// Returns `None` for generator/coroutine code paths that do not push a
+    /// regular datastack-backed frame in the fast call path.
+    pub(crate) fn datastack_frame_size_bytes(&self) -> Option<usize> {
+        datastack_frame_size_bytes_for_code(&self.code)
+    }
+
+    pub(crate) fn prepare_exact_args_frame(
+        &self,
+        mut args: Vec<PyObjectRef>,
+        vm: &VirtualMachine,
+    ) -> FrameRef {
+        let code: PyRef<PyCode> = (*self.code).to_owned();
+
+        debug_assert_eq!(args.len(), code.arg_count as usize);
+        debug_assert!(code.flags.contains(bytecode::CodeFlags::OPTIMIZED));
+        debug_assert!(
+            !code
+                .flags
+                .intersects(bytecode::CodeFlags::VARARGS | bytecode::CodeFlags::VARKEYWORDS)
+        );
+        debug_assert_eq!(code.kwonlyarg_count, 0);
+        debug_assert!(
+            !code
+                .flags
+                .intersects(bytecode::CodeFlags::GENERATOR | bytecode::CodeFlags::COROUTINE)
+        );
+
+        let locals = if code.flags.contains(bytecode::CodeFlags::NEWLOCALS) {
+            None
+        } else {
+            Some(ArgMapping::from_dict_exact(self.globals.clone()))
+        };
+
+        let frame = Frame::new(
+            code.clone(),
+            Scope::new(locals, self.globals.clone()),
+            self.builtins.clone(),
+            self.closure.as_ref().map_or(&[], |c| c.as_slice()),
+            Some(self.to_owned().into()),
+            true, // Exact-args fast path is only used for non-gen/coro functions.
+            vm,
+        )
+        .into_ref(&vm.ctx);
+
+        {
+            let fastlocals = unsafe { frame.fastlocals_mut() };
+            for (slot, arg) in fastlocals.iter_mut().zip(args.drain(..)) {
+                *slot = Some(arg);
+            }
+        }
+
+        frame
+    }
+
+    /// Fast path for calling a simple function with exact positional args.
+    /// Skips FuncArgs allocation, prepend_arg, and fill_locals_from_args.
+    /// Only valid when: CO_OPTIMIZED, no VARARGS, no VARKEYWORDS, no kwonlyargs,
+    /// and nargs == co_argcount.
+    pub fn invoke_exact_args(&self, args: Vec<PyObjectRef>, vm: &VirtualMachine) -> PyResult {
+        let code: PyRef<PyCode> = (*self.code).to_owned();
+
+        debug_assert_eq!(args.len(), code.arg_count as usize);
+        debug_assert!(code.flags.contains(bytecode::CodeFlags::OPTIMIZED));
+        debug_assert!(
+            !code
+                .flags
+                .intersects(bytecode::CodeFlags::VARARGS | bytecode::CodeFlags::VARKEYWORDS)
+        );
+        debug_assert_eq!(code.kwonlyarg_count, 0);
+
+        // Generator/coroutine code objects are SIMPLE_FUNCTION in call
+        // specialization classification, but their call path must still
+        // go through invoke() to produce generator/coroutine objects.
+        if code
+            .flags
+            .intersects(bytecode::CodeFlags::GENERATOR | bytecode::CodeFlags::COROUTINE)
+        {
+            return self.invoke(FuncArgs::from(args), vm);
+        }
+        let frame = self.prepare_exact_args_frame(args, vm);
+
+        let result = vm.run_frame(frame.clone());
+        unsafe {
+            if let Some(base) = frame.materialize_localsplus() {
+                vm.datastack_pop(base);
+            }
+        }
+        result
+    }
+}
+
+pub(crate) fn datastack_frame_size_bytes_for_code(code: &Py<PyCode>) -> Option<usize> {
+    if code
+        .flags
+        .intersects(bytecode::CodeFlags::GENERATOR | bytecode::CodeFlags::COROUTINE)
+    {
+        return None;
+    }
+    let nlocalsplus = code.localspluskinds.len();
+    let capacity = nlocalsplus.checked_add(code.max_stackdepth as usize)?;
+    capacity.checked_mul(core::mem::size_of::<usize>())
 }
 
 impl PyPayload for PyFunction {
@@ -556,23 +779,24 @@ impl PyPayload for PyFunction {
 
 #[pyclass(
     with(GetDescriptor, Callable, Representable, Constructor),
-    flags(HAS_DICT, METHOD_DESCRIPTOR)
+    flags(HAS_DICT, HAS_WEAKREF, METHOD_DESCRIPTOR)
 )]
 impl PyFunction {
     #[pygetset]
     fn __code__(&self) -> PyRef<PyCode> {
-        self.code.lock().clone()
+        (*self.code).to_owned()
     }
 
     #[pygetset(setter)]
-    fn set___code__(&self, code: PyRef<PyCode>) {
-        *self.code.lock() = code;
-        // TODO: jit support
-        // #[cfg(feature = "jit")]
-        // {
-        //     // If available, clear cached compiled code.
-        //     let _ = self.jitted_code.take();
-        // }
+    fn set___code__(&self, code: PyRef<PyCode>, vm: &VirtualMachine) {
+        #[cfg(feature = "jit")]
+        let mut jit_guard = self.jitted_code.lock();
+        self.code.swap_to_temporary_refs(code, vm);
+        #[cfg(feature = "jit")]
+        {
+            *jit_guard = None;
+        }
+        self.func_version.store(0, Relaxed);
     }
 
     #[pygetset]
@@ -581,7 +805,8 @@ impl PyFunction {
     }
     #[pygetset(setter)]
     fn set___defaults__(&self, defaults: Option<PyTupleRef>) {
-        self.defaults_and_kwdefaults.lock().0 = defaults
+        self.defaults_and_kwdefaults.lock().0 = defaults;
+        self.func_version.store(0, Relaxed);
     }
 
     #[pygetset]
@@ -590,7 +815,8 @@ impl PyFunction {
     }
     #[pygetset(setter)]
     fn set___kwdefaults__(&self, kwdefaults: Option<PyDictRef>) {
-        self.defaults_and_kwdefaults.lock().1 = kwdefaults
+        self.defaults_and_kwdefaults.lock().1 = kwdefaults;
+        self.func_version.store(0, Relaxed);
     }
 
     // {"__closure__",   T_OBJECT,     OFF(func_closure), READONLY},
@@ -708,19 +934,23 @@ impl PyFunction {
         value: PySetterValue<Option<PyObjectRef>>,
         vm: &VirtualMachine,
     ) -> PyResult<()> {
-        let annotations = match value {
+        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)
+                *self.annotations.lock() = Some(annotations);
+                *self.annotate.lock() = None;
             }
-            PySetterValue::Assign(None) | PySetterValue::Delete => None,
-        };
-        *self.annotations.lock() = annotations;
-
-        // Clear __annotate__ when __annotations__ is set
-        *self.annotate.lock() = None;
+            PySetterValue::Assign(None) => {
+                *self.annotations.lock() = None;
+                *self.annotate.lock() = None;
+            }
+            PySetterValue::Delete => {
+                // del only clears cached annotations; __annotate__ is preserved
+                *self.annotations.lock() = None;
+            }
+        }
         Ok(())
     }
 
@@ -802,15 +1032,17 @@ impl PyFunction {
     #[cfg(feature = "jit")]
     #[pymethod]
     fn __jit__(zelf: PyRef<Self>, vm: &VirtualMachine) -> PyResult<()> {
-        zelf.jitted_code
-            .get_or_try_init(|| {
-                let arg_types = jit::get_jit_arg_types(&zelf, vm)?;
-                let ret_type = jit::jit_ret_type(&zelf, vm)?;
-                let code = zelf.code.lock();
-                rustpython_jit::compile(&code.code, &arg_types, ret_type)
-                    .map_err(|err| jit::new_jit_error(err.to_string(), vm))
-            })
-            .map(drop)
+        let mut jit_guard = zelf.jitted_code.lock();
+        if jit_guard.is_some() {
+            return Ok(());
+        }
+        let arg_types = jit::get_jit_arg_types(&zelf, vm)?;
+        let ret_type = jit::jit_ret_type(&zelf, vm)?;
+        let code: &Py<PyCode> = &zelf.code;
+        let compiled = rustpython_jit::compile(&code.code, &arg_types, ret_type)
+            .map_err(|err| jit::new_jit_error(err.to_string(), vm))?;
+        *jit_guard = Some(compiled);
+        Ok(())
     }
 }
 
@@ -944,6 +1176,14 @@ impl Comparable for PyBoundMethod {
     }
 }
 
+impl Hashable for PyBoundMethod {
+    fn hash(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<PyHash> {
+        let self_hash = crate::common::hash::hash_object_id_raw(zelf.object.get_id());
+        let func_hash = zelf.function.hash(vm)?;
+        Ok(crate::common::hash::fix_sentinel(self_hash ^ func_hash))
+    }
+}
+
 impl GetAttr for PyBoundMethod {
     fn getattro(zelf: &Py<Self>, name: &Py<PyStr>, vm: &VirtualMachine) -> PyResult {
         let class_attr = vm
@@ -957,6 +1197,17 @@ impl GetAttr for PyBoundMethod {
     }
 }
 
+impl GetDescriptor for PyBoundMethod {
+    fn descr_get(
+        zelf: PyObjectRef,
+        _obj: Option<PyObjectRef>,
+        _cls: Option<PyObjectRef>,
+        _vm: &VirtualMachine,
+    ) -> PyResult {
+        Ok(zelf)
+    }
+}
+
 #[derive(FromArgs)]
 pub struct PyBoundMethodNewArgs {
     #[pyarg(positional)]
@@ -971,8 +1222,14 @@ impl Constructor for PyBoundMethod {
     fn py_new(
         _cls: &Py<PyType>,
         Self::Args { function, object }: Self::Args,
-        _vm: &VirtualMachine,
+        vm: &VirtualMachine,
     ) -> PyResult<Self> {
+        if !function.is_callable() {
+            return Err(vm.new_type_error("first argument must be callable".to_owned()));
+        }
+        if vm.is_none(&object) {
+            return Err(vm.new_type_error("instance must not be None".to_owned()));
+        }
         Ok(Self::new(object, function))
     }
 }
@@ -982,6 +1239,16 @@ impl PyBoundMethod {
         Self { object, function }
     }
 
+    #[inline]
+    pub(crate) fn function_obj(&self) -> &PyObjectRef {
+        &self.function
+    }
+
+    #[inline]
+    pub(crate) fn self_obj(&self) -> &PyObjectRef {
+        &self.object
+    }
+
     #[deprecated(note = "Use `Self::new(object, function).into_ref(ctx)` instead")]
     pub fn new_ref(object: PyObjectRef, function: PyObjectRef, ctx: &Context) -> PyRef<Self> {
         Self::new(object, function).into_ref(ctx)
@@ -989,19 +1256,27 @@ impl PyBoundMethod {
 }
 
 #[pyclass(
-    with(Callable, Comparable, GetAttr, Constructor, Representable),
-    flags(IMMUTABLETYPE)
+    with(
+        Callable,
+        Comparable,
+        Hashable,
+        GetAttr,
+        GetDescriptor,
+        Constructor,
+        Representable
+    ),
+    flags(IMMUTABLETYPE, HAS_WEAKREF)
 )]
 impl PyBoundMethod {
     #[pymethod]
     fn __reduce__(
         &self,
         vm: &VirtualMachine,
-    ) -> (Option<PyObjectRef>, (PyObjectRef, Option<PyObjectRef>)) {
-        let builtins_getattr = vm.builtins.get_attr("getattr", vm).ok();
+    ) -> PyResult<(PyObjectRef, (PyObjectRef, PyObjectRef))> {
+        let builtins_getattr = vm.builtins.get_attr("getattr", vm)?;
         let func_self = self.object.clone();
-        let func_name = self.function.get_attr("__name__", vm).ok();
-        (builtins_getattr, (func_self, func_name))
+        let func_name = self.function.get_attr("__name__", vm)?;
+        Ok((builtins_getattr, (func_self, func_name)))
     }
 
     #[pygetset]
@@ -1023,28 +1298,6 @@ impl PyBoundMethod {
     fn __module__(&self, vm: &VirtualMachine) -> Option<PyObjectRef> {
         self.function.get_attr("__module__", vm).ok()
     }
-
-    #[pygetset]
-    fn __qualname__(&self, vm: &VirtualMachine) -> PyResult {
-        if self
-            .function
-            .fast_isinstance(vm.ctx.types.builtin_function_or_method_type)
-        {
-            // Special case: we work with `__new__`, which is not really a method.
-            // It is a function, so its `__qualname__` is just `__new__`.
-            // We need to add object's part manually.
-            let obj_name = vm.get_attribute_opt(self.object.clone(), "__qualname__")?;
-            let obj_name: Option<PyStrRef> = obj_name.and_then(|o| o.downcast().ok());
-            return Ok(vm
-                .ctx
-                .new_str(format!(
-                    "{}.__new__",
-                    obj_name.as_ref().map_or("?", |s| s.as_str())
-                ))
-                .into());
-        }
-        self.function.get_attr("__qualname__", vm)
-    }
 }
 
 impl PyPayload for PyBoundMethod {
@@ -1056,22 +1309,23 @@ impl PyPayload for PyBoundMethod {
 
 impl Representable for PyBoundMethod {
     #[inline]
-    fn repr_str(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<String> {
-        #[allow(clippy::needless_match)] // False positive on nightly
-        let func_name =
-            if let Some(qname) = vm.get_attribute_opt(zelf.function.clone(), "__qualname__")? {
-                Some(qname)
-            } else {
-                vm.get_attribute_opt(zelf.function.clone(), "__name__")?
-            };
-        let func_name: Option<PyStrRef> = func_name.and_then(|o| o.downcast().ok());
-        let formatted_func_name = match func_name {
-            Some(name) => name.to_string(),
-            None => "?".to_string(),
+    fn repr_wtf8(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<Wtf8Buf> {
+        let func_name = if let Some(qname) =
+            vm.get_attribute_opt(zelf.function.clone(), identifier!(vm, __qualname__))?
+        {
+            Some(qname)
+        } else {
+            vm.get_attribute_opt(zelf.function.clone(), identifier!(vm, __name__))?
         };
+        let func_name: Option<PyStrRef> = func_name.and_then(|o| o.downcast().ok());
         let object_repr = zelf.object.repr(vm)?;
-        Ok(format!(
-            "<bound method {formatted_func_name} of {object_repr}>",
+        let name = func_name.as_ref().map_or("?".as_ref(), |s| s.as_wtf8());
+        Ok(wtf8_concat!(
+            "<bound method ",
+            name,
+            " of ",
+            object_repr.as_wtf8(),
+            ">"
         ))
     }
 }
@@ -1127,8 +1381,86 @@ impl PyCell {
     }
 }
 
-pub fn init(context: &Context) {
+/// Vectorcall implementation for PyFunction (PEP 590).
+/// Takes owned args to avoid cloning when filling fastlocals.
+pub(crate) fn vectorcall_function(
+    zelf_obj: &PyObject,
+    mut args: Vec<PyObjectRef>,
+    nargs: usize,
+    kwnames: Option<&[PyObjectRef]>,
+    vm: &VirtualMachine,
+) -> PyResult {
+    let zelf: &Py<PyFunction> = zelf_obj.downcast_ref().unwrap();
+    let code: &Py<PyCode> = &zelf.code;
+
+    let has_kwargs = kwnames.is_some_and(|kw| !kw.is_empty());
+    let is_simple = !has_kwargs
+        && code.flags.contains(bytecode::CodeFlags::OPTIMIZED)
+        && !code.flags.contains(bytecode::CodeFlags::VARARGS)
+        && !code.flags.contains(bytecode::CodeFlags::VARKEYWORDS)
+        && code.kwonlyarg_count == 0
+        && !code
+            .flags
+            .intersects(bytecode::CodeFlags::GENERATOR | bytecode::CodeFlags::COROUTINE);
+
+    if is_simple && nargs == code.arg_count as usize {
+        // FAST PATH: simple positional-only call, exact arg count.
+        // Move owned args directly into fastlocals — no clone needed.
+        args.truncate(nargs);
+        let frame = zelf.prepare_exact_args_frame(args, vm);
+
+        let result = vm.run_frame(frame.clone());
+        unsafe {
+            if let Some(base) = frame.materialize_localsplus() {
+                vm.datastack_pop(base);
+            }
+        }
+        return result;
+    }
+
+    // SLOW PATH: construct FuncArgs from owned Vec and delegate to invoke()
+    let func_args = if has_kwargs {
+        FuncArgs::from_vectorcall(&args, nargs, kwnames)
+    } else {
+        args.truncate(nargs);
+        FuncArgs::from(args)
+    };
+    zelf.invoke(func_args, vm)
+}
+
+/// Vectorcall implementation for PyBoundMethod (PEP 590).
+fn vectorcall_bound_method(
+    zelf_obj: &PyObject,
+    mut args: Vec<PyObjectRef>,
+    nargs: usize,
+    kwnames: Option<&[PyObjectRef]>,
+    vm: &VirtualMachine,
+) -> PyResult {
+    let zelf: &Py<PyBoundMethod> = zelf_obj.downcast_ref().unwrap();
+
+    // Insert self at front of existing Vec (avoids 2nd allocation).
+    // O(n) memmove is cheaper than a 2nd heap alloc+dealloc for typical arg counts.
+    args.insert(0, zelf.object.clone());
+    let new_nargs = nargs + 1;
+    zelf.function.vectorcall(args, new_nargs, kwnames, vm)
+}
+
+pub fn init(context: &'static Context) {
     PyFunction::extend_class(context, context.types.function_type);
+    context
+        .types
+        .function_type
+        .slots
+        .vectorcall
+        .store(Some(vectorcall_function));
+
     PyBoundMethod::extend_class(context, context.types.bound_method_type);
+    context
+        .types
+        .bound_method_type
+        .slots
+        .vectorcall
+        .store(Some(vectorcall_bound_method));
+
     PyCell::extend_class(context, context.types.cell_type);
 }
diff --git a/crates/vm/src/builtins/function/jit.rs b/crates/vm/src/builtins/function/jit.rs
index a28335900da..56594a0f462 100644
--- a/crates/vm/src/builtins/function/jit.rs
+++ b/crates/vm/src/builtins/function/jit.rs
@@ -1,7 +1,7 @@
 use crate::{
     AsObject, Py, PyObject, PyObjectRef, PyResult, TryFromObject, VirtualMachine,
     builtins::{
-        PyBaseExceptionRef, PyDict, PyDictRef, PyFunction, PyStrInterned, bool_, float, int,
+        PyBaseExceptionRef, PyCode, PyDict, PyDictRef, PyFunction, PyStrInterned, bool_, float, int,
     },
     bytecode::CodeFlags,
     convert::ToPyObject,
@@ -41,7 +41,7 @@ impl ToPyObject for AbiValue {
 
 pub fn new_jit_error(msg: String, vm: &VirtualMachine) -> PyBaseExceptionRef {
     let jit_error = vm.ctx.exceptions.jit_error.to_owned();
-    vm.new_exception_msg(jit_error, msg)
+    vm.new_exception_msg(jit_error, msg.into())
 }
 
 fn get_jit_arg_type(dict: &Py<PyDict>, name: &str, vm: &VirtualMachine) -> PyResult<JitType> {
@@ -67,7 +67,7 @@ fn get_jit_arg_type(dict: &Py<PyDict>, name: &str, vm: &VirtualMachine) -> PyRes
 }
 
 pub fn get_jit_arg_types(func: &Py<PyFunction>, vm: &VirtualMachine) -> PyResult<Vec<JitType>> {
-    let code = func.code.lock();
+    let code: &Py<PyCode> = &func.code;
     let arg_names = code.arg_names();
 
     if code
@@ -160,7 +160,7 @@ pub(crate) fn get_jit_args<'a>(
     let mut jit_args = jitted_code.args_builder();
     let nargs = func_args.args.len();
 
-    let code = func.code.lock();
+    let code: &Py<PyCode> = &func.code;
     let arg_names = code.arg_names();
     let arg_count = code.arg_count;
     let posonlyarg_count = code.posonlyarg_count;
@@ -220,7 +220,5 @@ pub(crate) fn get_jit_args<'a>(
         }
     }
 
-    drop(code);
-
     jit_args.into_args().ok_or(ArgsError::NotAllArgsPassed)
 }
diff --git a/crates/vm/src/builtins/generator.rs b/crates/vm/src/builtins/generator.rs
index dec7d82add0..2eee2fecd0d 100644
--- a/crates/vm/src/builtins/generator.rs
+++ b/crates/vm/src/builtins/generator.rs
@@ -11,7 +11,7 @@ use crate::{
     function::OptionalArg,
     object::{Traverse, TraverseFn},
     protocol::PyIterReturn,
-    types::{IterNext, Iterable, Representable, SelfIter},
+    types::{Destructor, IterNext, Iterable, Representable, SelfIter},
 };
 
 #[pyclass(module = false, name = "generator", traverse = "manual")]
@@ -33,7 +33,10 @@ impl PyPayload for PyGenerator {
     }
 }
 
-#[pyclass(flags(DISALLOW_INSTANTIATION), with(Py, IterNext, Iterable))]
+#[pyclass(
+    flags(DISALLOW_INSTANTIATION, HAS_WEAKREF),
+    with(Py, IterNext, Iterable, Representable, Destructor)
+)]
 impl PyGenerator {
     pub const fn as_coro(&self) -> &Coro {
         &self.inner
@@ -89,6 +92,11 @@ impl PyGenerator {
         self.inner.frame().yield_from_target()
     }
 
+    #[pygetset]
+    fn gi_suspended(&self, _vm: &VirtualMachine) -> bool {
+        self.inner.suspended()
+    }
+
     #[pyclassmethod]
     fn __class_getitem__(cls: PyTypeRef, args: PyObjectRef, vm: &VirtualMachine) -> PyGenericAlias {
         PyGenericAlias::from_args(cls, args, vm)
@@ -121,7 +129,7 @@ impl Py<PyGenerator> {
     }
 
     #[pymethod]
-    fn close(&self, vm: &VirtualMachine) -> PyResult<()> {
+    fn close(&self, vm: &VirtualMachine) -> PyResult<PyObjectRef> {
         self.inner.close(self.as_object(), vm)
     }
 }
@@ -140,6 +148,31 @@ impl IterNext for PyGenerator {
     }
 }
 
-pub fn init(ctx: &Context) {
+impl Destructor for PyGenerator {
+    fn del(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<()> {
+        // _PyGen_Finalize: close the generator if it's still suspended
+        if zelf.inner.closed() || zelf.inner.running() {
+            return Ok(());
+        }
+        // Generator was never started, just mark as closed
+        if zelf.inner.frame().lasti() == 0 {
+            zelf.inner.closed.store(true);
+            return Ok(());
+        }
+        // Throw GeneratorExit to run finally blocks
+        if let Err(e) = zelf.inner.close(zelf.as_object(), vm) {
+            vm.run_unraisable(e, None, zelf.as_object().to_owned());
+        }
+        Ok(())
+    }
+}
+
+impl Drop for PyGenerator {
+    fn drop(&mut self) {
+        self.inner.frame().clear_generator();
+    }
+}
+
+pub fn init(ctx: &'static Context) {
     PyGenerator::extend_class(ctx, ctx.types.generator_type);
 }
diff --git a/crates/vm/src/builtins/genericalias.rs b/crates/vm/src/builtins/genericalias.rs
index 21034e08f0e..1564229d186 100644
--- a/crates/vm/src/builtins/genericalias.rs
+++ b/crates/vm/src/builtins/genericalias.rs
@@ -1,27 +1,26 @@
-// spell-checker:ignore iparam
-use std::sync::LazyLock;
+// spell-checker:ignore iparam gaiterobject
+use crate::common::lock::LazyLock;
 
 use super::type_;
 use crate::{
     AsObject, Context, Py, PyObject, PyObjectRef, PyPayload, PyRef, PyResult, TryFromObject,
     VirtualMachine, atomic_func,
-    builtins::{PyList, PyStr, PyTuple, PyTupleRef, PyType, PyTypeRef},
+    builtins::{PyList, PyStr, PyTuple, PyTupleRef, PyType},
     class::PyClassImpl,
     common::hash,
     convert::ToPyObject,
     function::{FuncArgs, PyComparisonValue},
     protocol::{PyMappingMethods, PyNumberMethods},
     types::{
-        AsMapping, AsNumber, Callable, Comparable, Constructor, GetAttr, Hashable, Iterable,
-        PyComparisonOp, Representable,
+        AsMapping, AsNumber, Callable, Comparable, Constructor, GetAttr, Hashable, IterNext,
+        Iterable, PyComparisonOp, Representable,
     },
 };
 use alloc::fmt;
 
-// attr_exceptions
-static ATTR_EXCEPTIONS: [&str; 12] = [
+// Attributes that are looked up on the GenericAlias itself, not on __origin__
+static ATTR_EXCEPTIONS: [&str; 9] = [
     "__class__",
-    "__bases__",
     "__origin__",
     "__args__",
     "__unpacked__",
@@ -30,13 +29,14 @@ static ATTR_EXCEPTIONS: [&str; 12] = [
     "__mro_entries__",
     "__reduce_ex__", // needed so we don't look up object.__reduce_ex__
     "__reduce__",
-    "__copy__",
-    "__deepcopy__",
 ];
 
+// Attributes that are blocked from being looked up on __origin__
+static ATTR_BLOCKED: [&str; 3] = ["__bases__", "__copy__", "__deepcopy__"];
+
 #[pyclass(module = "types", name = "GenericAlias")]
 pub struct PyGenericAlias {
-    origin: PyTypeRef,
+    origin: PyObjectRef,
     args: PyTupleRef,
     parameters: PyTupleRef,
     starred: bool, // for __unpacked__ attribute
@@ -62,7 +62,7 @@ impl Constructor for PyGenericAlias {
         if !args.kwargs.is_empty() {
             return Err(vm.new_type_error("GenericAlias() takes no keyword arguments"));
         }
-        let (origin, arguments): (_, PyObjectRef) = args.bind(vm)?;
+        let (origin, arguments): (PyObjectRef, PyObjectRef) = args.bind(vm)?;
         let args = if let Ok(tuple) = arguments.try_to_ref::<PyTuple>(vm) {
             tuple.to_owned()
         } else {
@@ -84,13 +84,18 @@ impl Constructor for PyGenericAlias {
         Iterable,
         Representable
     ),
-    flags(BASETYPE)
+    flags(BASETYPE, HAS_WEAKREF)
 )]
 impl PyGenericAlias {
-    pub fn new(origin: PyTypeRef, args: PyTupleRef, starred: bool, vm: &VirtualMachine) -> Self {
+    pub fn new(
+        origin: impl Into<PyObjectRef>,
+        args: PyTupleRef,
+        starred: bool,
+        vm: &VirtualMachine,
+    ) -> Self {
         let parameters = make_parameters(&args, vm);
         Self {
-            origin,
+            origin: origin.into(),
             args,
             parameters,
             starred,
@@ -98,7 +103,11 @@ impl PyGenericAlias {
     }
 
     /// Create a GenericAlias from an origin and PyObjectRef arguments (helper for compatibility)
-    pub fn from_args(origin: PyTypeRef, args: PyObjectRef, vm: &VirtualMachine) -> Self {
+    pub fn from_args(
+        origin: impl Into<PyObjectRef>,
+        args: PyObjectRef,
+        vm: &VirtualMachine,
+    ) -> Self {
         let args = if let Ok(tuple) = args.try_to_ref::<PyTuple>(vm) {
             tuple.to_owned()
         } else {
@@ -138,15 +147,36 @@ impl PyGenericAlias {
             }
         }
 
+        fn repr_arg(obj: PyObjectRef, vm: &VirtualMachine) -> PyResult<String> {
+            // ParamSpec args can be lists - format their items with repr_item
+            if obj.class().is(vm.ctx.types.list_type) {
+                let list = obj.downcast_ref::<crate::builtins::PyList>().unwrap();
+                let len = list.borrow_vec().len();
+                let mut parts = Vec::with_capacity(len);
+                // Use indexed access so list mutation during repr causes IndexError
+                for i in 0..len {
+                    let item = list
+                        .borrow_vec()
+                        .get(i)
+                        .cloned()
+                        .ok_or_else(|| vm.new_index_error("list index out of range"))?;
+                    parts.push(repr_item(item, vm)?);
+                }
+                Ok(format!("[{}]", parts.join(", ")))
+            } else {
+                repr_item(obj, vm)
+            }
+        }
+
         let repr_str = format!(
             "{}[{}]",
-            repr_item(self.origin.clone().into(), vm)?,
+            repr_item(self.origin.clone(), vm)?,
             if self.args.is_empty() {
                 "()".to_owned()
             } else {
                 self.args
                     .iter()
-                    .map(|o| repr_item(o.clone(), vm))
+                    .map(|o| repr_arg(o.clone(), vm))
                     .collect::<PyResult<Vec<_>>>()?
                     .join(", ")
             }
@@ -172,7 +202,7 @@ impl PyGenericAlias {
 
     #[pygetset]
     fn __origin__(&self) -> PyObjectRef {
-        self.origin.clone().into()
+        self.origin.clone()
     }
 
     #[pygetset]
@@ -182,7 +212,7 @@ impl PyGenericAlias {
 
     #[pygetset]
     fn __typing_unpacked_tuple_args__(&self, vm: &VirtualMachine) -> PyObjectRef {
-        if self.starred && self.origin.is(vm.ctx.types.tuple_type) {
+        if self.starred && self.origin.is(vm.ctx.types.tuple_type.as_object()) {
             self.args.clone().into()
         } else {
             vm.ctx.none()
@@ -213,11 +243,29 @@ impl PyGenericAlias {
     }
 
     #[pymethod]
-    fn __reduce__(zelf: &Py<Self>, vm: &VirtualMachine) -> (PyTypeRef, (PyTypeRef, PyTupleRef)) {
-        (
-            vm.ctx.types.generic_alias_type.to_owned(),
-            (zelf.origin.clone(), zelf.args.clone()),
-        )
+    fn __reduce__(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<PyTupleRef> {
+        if zelf.starred {
+            // (next, (iter(GenericAlias(origin, args)),))
+            let next_fn = vm.builtins.get_attr("next", vm)?;
+            let non_starred = Self::new(zelf.origin.clone(), zelf.args.clone(), false, vm);
+            let iter_obj = PyGenericAliasIterator {
+                obj: crate::common::lock::PyMutex::new(Some(non_starred.into_pyobject(vm))),
+            }
+            .into_pyobject(vm);
+            Ok(PyTuple::new_ref(
+                vec![next_fn, PyTuple::new_ref(vec![iter_obj], &vm.ctx).into()],
+                &vm.ctx,
+            ))
+        } else {
+            Ok(PyTuple::new_ref(
+                vec![
+                    vm.ctx.types.generic_alias_type.to_owned().into(),
+                    PyTuple::new_ref(vec![zelf.origin.clone(), zelf.args.clone().into()], &vm.ctx)
+                        .into(),
+                ],
+                &vm.ctx,
+            ))
+        }
     }
 
     #[pymethod]
@@ -245,8 +293,11 @@ impl PyGenericAlias {
 }
 
 pub(crate) fn make_parameters(args: &Py<PyTuple>, vm: &VirtualMachine) -> PyTupleRef {
+    make_parameters_from_slice(args.as_slice(), vm)
+}
+
+fn make_parameters_from_slice(args: &[PyObjectRef], vm: &VirtualMachine) -> PyTupleRef {
     let mut parameters: Vec<PyObjectRef> = Vec::with_capacity(args.len());
-    let mut iparam = 0;
 
     for arg in args {
         // We don't want __parameters__ descriptor of a bare Python class.
@@ -256,37 +307,34 @@ pub(crate) fn make_parameters(args: &Py<PyTuple>, vm: &VirtualMachine) -> PyTupl
 
         // Check for __typing_subst__ attribute
         if arg.get_attr(identifier!(vm, __typing_subst__), vm).is_ok() {
-            // Use tuple_add equivalent logic
             if tuple_index(&parameters, arg).is_none() {
-                if iparam >= parameters.len() {
-                    parameters.resize(iparam + 1, vm.ctx.none());
-                }
-                parameters[iparam] = arg.clone();
-                iparam += 1;
+                parameters.push(arg.clone());
             }
         } else if let Ok(subparams) = arg.get_attr(identifier!(vm, __parameters__), vm)
             && let Ok(sub_params) = subparams.try_to_ref::<PyTuple>(vm)
         {
-            let len2 = sub_params.len();
-            // Resize if needed
-            if iparam + len2 > parameters.len() {
-                parameters.resize(iparam + len2, vm.ctx.none());
-            }
             for sub_param in sub_params {
-                // Use tuple_add equivalent logic
-                if tuple_index(&parameters[..iparam], sub_param).is_none() {
-                    if iparam >= parameters.len() {
-                        parameters.resize(iparam + 1, vm.ctx.none());
-                    }
-                    parameters[iparam] = sub_param.clone();
-                    iparam += 1;
+                if tuple_index(&parameters, sub_param).is_none() {
+                    parameters.push(sub_param.clone());
+                }
+            }
+        } else if arg.try_to_ref::<PyTuple>(vm).is_ok() || arg.try_to_ref::<PyList>(vm).is_ok() {
+            // Recursively extract parameters from lists/tuples (ParamSpec args)
+            let items: Vec<PyObjectRef> = if let Ok(t) = arg.try_to_ref::<PyTuple>(vm) {
+                t.as_slice().to_vec()
+            } else {
+                let list = arg.downcast_ref::<PyList>().unwrap();
+                list.borrow_vec().to_vec()
+            };
+            let sub = make_parameters_from_slice(&items, vm);
+            for sub_param in sub.iter() {
+                if tuple_index(&parameters, sub_param).is_none() {
+                    parameters.push(sub_param.clone());
                 }
             }
         }
     }
 
-    // Resize to actual size
-    parameters.truncate(iparam);
     PyTuple::new_ref(parameters, &vm.ctx)
 }
 
@@ -433,7 +481,7 @@ pub fn subs_parameters(
     let arg_items = if let Ok(tuple) = item.try_to_ref::<PyTuple>(vm) {
         tuple.as_slice().to_vec()
     } else {
-        vec![item]
+        vec![item.clone()]
     };
     let n_items = arg_items.len();
 
@@ -457,32 +505,55 @@ pub fn subs_parameters(
             continue;
         }
 
-        // Check if this is an unpacked TypeVarTuple's _is_unpacked_typevartuple
+        // Recursively substitute params in lists/tuples
+        let is_list = arg.try_to_ref::<PyList>(vm).is_ok();
+        if arg.try_to_ref::<PyTuple>(vm).is_ok() || is_list {
+            let sub_items: Vec<PyObjectRef> = if let Ok(t) = arg.try_to_ref::<PyTuple>(vm) {
+                t.as_slice().to_vec()
+            } else {
+                arg.downcast_ref::<PyList>().unwrap().borrow_vec().to_vec()
+            };
+            let sub_tuple = PyTuple::new_ref(sub_items, &vm.ctx);
+            let sub_result = subs_parameters(
+                alias.clone(),
+                sub_tuple,
+                parameters.clone(),
+                item.clone(),
+                vm,
+            )?;
+            let substituted: PyObjectRef = if is_list {
+                // Convert tuple back to list
+                PyList::from(sub_result.as_slice().to_vec())
+                    .into_ref(&vm.ctx)
+                    .into()
+            } else {
+                sub_result.into()
+            };
+            new_args.push(substituted);
+            continue;
+        }
+
+        // Check if this is an unpacked TypeVarTuple
         let unpack = is_unpacked_typevartuple(arg, vm)?;
 
-        // Try __typing_subst__ method first,
+        // Try __typing_subst__ method first
         let substituted_arg = if let Ok(subst) = arg.get_attr(identifier!(vm, __typing_subst__), vm)
         {
-            // Find parameter index's tuple_index
             if let Some(iparam) = tuple_index(parameters.as_slice(), arg) {
                 subst.call((arg_items[iparam].clone(),), vm)?
             } else {
-                // This shouldn't happen in well-formed generics but handle gracefully
                 subs_tvars(arg.clone(), &parameters, &arg_items, vm)?
             }
         } else {
-            // Use subs_tvars for objects with __parameters__
             subs_tvars(arg.clone(), &parameters, &arg_items, vm)?
         };
 
         if unpack {
-            // Handle unpacked TypeVarTuple's tuple_extend
             if let Ok(tuple) = substituted_arg.try_to_ref::<PyTuple>(vm) {
                 for elem in tuple {
                     new_args.push(elem.clone());
                 }
             } else {
-                // This shouldn't happen but handle gracefully
                 new_args.push(substituted_arg);
             }
         } else {
@@ -519,7 +590,7 @@ impl AsNumber for PyGenericAlias {
 impl Callable for PyGenericAlias {
     type Args = FuncArgs;
     fn call(zelf: &Py<Self>, args: FuncArgs, vm: &VirtualMachine) -> PyResult {
-        PyType::call(&zelf.origin, args, vm).map(|obj| {
+        zelf.origin.call(args, vm).map(|obj| {
             if let Err(exc) = obj.set_attr(identifier!(vm, __orig_class__), zelf.to_owned(), vm)
                 && !exc.fast_isinstance(vm.ctx.exceptions.attribute_error)
                 && !exc.fast_isinstance(vm.ctx.exceptions.type_error)
@@ -540,17 +611,17 @@ impl Comparable for PyGenericAlias {
     ) -> PyResult<PyComparisonValue> {
         op.eq_only(|| {
             let other = class_or_notimplemented!(Self, other);
+            if zelf.starred != other.starred {
+                return Ok(PyComparisonValue::Implemented(false));
+            }
             Ok(PyComparisonValue::Implemented(
-                if !zelf.__origin__().rich_compare_bool(
-                    &other.__origin__(),
-                    PyComparisonOp::Eq,
-                    vm,
-                )? {
-                    false
-                } else {
-                    zelf.__args__()
-                        .rich_compare_bool(&other.__args__(), PyComparisonOp::Eq, vm)?
-                },
+                zelf.__origin__()
+                    .rich_compare_bool(&other.__origin__(), PyComparisonOp::Eq, vm)?
+                    && zelf.__args__().rich_compare_bool(
+                        &other.__args__(),
+                        PyComparisonOp::Eq,
+                        vm,
+                    )?,
             ))
         })
     }
@@ -559,14 +630,20 @@ impl Comparable for PyGenericAlias {
 impl Hashable for PyGenericAlias {
     #[inline]
     fn hash(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<hash::PyHash> {
-        Ok(zelf.origin.as_object().hash(vm)? ^ zelf.args.as_object().hash(vm)?)
+        Ok(zelf.origin.hash(vm)? ^ zelf.args.as_object().hash(vm)?)
     }
 }
 
 impl GetAttr for PyGenericAlias {
     fn getattro(zelf: &Py<Self>, attr: &Py<PyStr>, vm: &VirtualMachine) -> PyResult {
+        let attr_str = attr.as_wtf8();
         for exc in &ATTR_EXCEPTIONS {
-            if *(*exc) == attr.to_string() {
+            if attr_str == *exc {
+                return zelf.as_object().generic_getattr(attr, vm);
+            }
+        }
+        for blocked in &ATTR_BLOCKED {
+            if attr_str == *blocked {
                 return zelf.as_object().generic_getattr(attr, vm);
             }
         }
@@ -582,52 +659,88 @@ impl Representable for PyGenericAlias {
 }
 
 impl Iterable for PyGenericAlias {
-    // ga_iter
-    // spell-checker:ignore gaiterobject
-    // TODO: gaiterobject
     fn iter(zelf: PyRef<Self>, vm: &VirtualMachine) -> PyResult {
-        // CPython's ga_iter creates an iterator that yields one starred GenericAlias
-        // we don't have gaiterobject yet
+        Ok(PyGenericAliasIterator {
+            obj: crate::common::lock::PyMutex::new(Some(zelf.into())),
+        }
+        .into_pyobject(vm))
+    }
+}
 
-        let starred_alias = Self::new(
-            zelf.origin.clone(),
-            zelf.args.clone(),
-            true, // starred
-            vm,
-        );
-        let starred_ref = PyRef::new_ref(
-            starred_alias,
-            vm.ctx.types.generic_alias_type.to_owned(),
-            None,
-        );
-        let items = vec![starred_ref.into()];
-        let iter_tuple = PyTuple::new_ref(items, &vm.ctx);
-        Ok(iter_tuple.to_pyobject(vm).get_iter(vm)?.into())
+// gaiterobject - yields one starred GenericAlias then exhausts
+#[pyclass(module = "types", name = "generic_alias_iterator")]
+#[derive(Debug, PyPayload)]
+pub struct PyGenericAliasIterator {
+    obj: crate::common::lock::PyMutex<Option<PyObjectRef>>,
+}
+
+#[pyclass(with(Representable, Iterable, IterNext))]
+impl PyGenericAliasIterator {
+    #[pymethod]
+    fn __reduce__(&self, vm: &VirtualMachine) -> PyResult<PyTupleRef> {
+        let iter_fn = vm.builtins.get_attr("iter", vm)?;
+        let guard = self.obj.lock();
+        let arg: PyObjectRef = if let Some(ref obj) = *guard {
+            // Not yet exhausted: (iter, (obj,))
+            PyTuple::new_ref(vec![obj.clone()], &vm.ctx).into()
+        } else {
+            // Exhausted: (iter, ((),))
+            let empty = PyTuple::new_ref(vec![], &vm.ctx);
+            PyTuple::new_ref(vec![empty.into()], &vm.ctx).into()
+        };
+        Ok(PyTuple::new_ref(vec![iter_fn, arg], &vm.ctx))
+    }
+}
+
+impl Representable for PyGenericAliasIterator {
+    fn repr_str(_zelf: &Py<Self>, _vm: &VirtualMachine) -> PyResult<String> {
+        Ok("<generic_alias_iterator>".to_owned())
+    }
+}
+
+impl Iterable for PyGenericAliasIterator {
+    fn iter(zelf: PyRef<Self>, _vm: &VirtualMachine) -> PyResult {
+        Ok(zelf.into())
     }
 }
 
-/// Creates a GenericAlias from type parameters, equivalent to CPython's _Py_subscript_generic
-/// This is used for PEP 695 classes to create Generic[T] from type parameters
+impl crate::types::IterNext for PyGenericAliasIterator {
+    fn next(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<crate::protocol::PyIterReturn> {
+        use crate::protocol::PyIterReturn;
+        let mut guard = zelf.obj.lock();
+        let obj = match guard.take() {
+            Some(obj) => obj,
+            None => return Ok(PyIterReturn::StopIteration(None)),
+        };
+        // Create a starred GenericAlias from the original
+        let alias = obj
+            .downcast_ref::<PyGenericAlias>()
+            .ok_or_else(|| vm.new_type_error("generic_alias_iterator expected GenericAlias"))?;
+        let starred = PyGenericAlias::new(alias.origin.clone(), alias.args.clone(), true, vm);
+        Ok(PyIterReturn::Return(starred.into_pyobject(vm)))
+    }
+}
+
+/// Creates a GenericAlias from type parameters, equivalent to _Py_subscript_generic.
+/// This is used for PEP 695 classes to create Generic[T] from type parameters.
 // _Py_subscript_generic
 pub fn subscript_generic(type_params: PyObjectRef, vm: &VirtualMachine) -> PyResult {
-    // Get typing module and _GenericAlias
     let typing_module = vm.import("typing", 0)?;
     let generic_type = typing_module.get_attr("Generic", vm)?;
-
-    // Call typing._GenericAlias(Generic, type_params)
     let generic_alias_class = typing_module.get_attr("_GenericAlias", vm)?;
 
-    let args = if let Ok(tuple) = type_params.try_to_ref::<PyTuple>(vm) {
+    let params = if let Ok(tuple) = type_params.try_to_ref::<PyTuple>(vm) {
         tuple.to_owned()
     } else {
         PyTuple::new_ref(vec![type_params], &vm.ctx)
     };
 
-    // Create _GenericAlias instance
+    let args = crate::stdlib::_typing::unpack_typevartuples(&params, vm)?;
+
     generic_alias_class.call((generic_type, args.to_pyobject(vm)), vm)
 }
 
-pub fn init(context: &Context) {
-    let generic_alias_type = &context.types.generic_alias_type;
-    PyGenericAlias::extend_class(context, generic_alias_type);
+pub fn init(context: &'static Context) {
+    PyGenericAlias::extend_class(context, context.types.generic_alias_type);
+    PyGenericAliasIterator::extend_class(context, context.types.generic_alias_iterator_type);
 }
diff --git a/crates/vm/src/builtins/getset.rs b/crates/vm/src/builtins/getset.rs
index 86f0524b12c..ff132fb7471 100644
--- a/crates/vm/src/builtins/getset.rs
+++ b/crates/vm/src/builtins/getset.rs
@@ -157,6 +157,6 @@ impl Representable for PyGetSet {
     }
 }
 
-pub(crate) fn init(context: &Context) {
+pub(crate) fn init(context: &'static Context) {
     PyGetSet::extend_class(context, context.types.getset_type);
 }
diff --git a/crates/vm/src/builtins/int.rs b/crates/vm/src/builtins/int.rs
index 765f5e2454b..0ae1c6d8654 100644
--- a/crates/vm/src/builtins/int.rs
+++ b/crates/vm/src/builtins/int.rs
@@ -2,13 +2,14 @@ use super::{PyByteArray, PyBytes, PyStr, PyType, PyTypeRef, float};
 use crate::{
     AsObject, Context, Py, PyObject, PyObjectRef, PyPayload, PyRef, PyRefExact, PyResult,
     TryFromBorrowedObject, VirtualMachine,
-    builtins::PyStrRef,
+    builtins::PyUtf8StrRef,
     bytes_inner::PyBytesInner,
     class::PyClassImpl,
     common::{
         format::FormatSpec,
         hash,
         int::{bigint_to_finite_float, bytes_to_int, true_div},
+        wtf8::Wtf8Buf,
     },
     convert::{IntoPyException, ToPyObject, ToPyResult},
     function::{
@@ -19,9 +20,11 @@ use crate::{
     types::{AsNumber, Comparable, Constructor, Hashable, PyComparisonOp, Representable},
 };
 use alloc::fmt;
+use core::cell::Cell;
 use core::ops::{Neg, Not};
+use core::ptr::NonNull;
 use malachite_bigint::{BigInt, Sign};
-use num_integer::Integer;
+use num_integer::{ExtendedGcd, Integer};
 use num_traits::{One, Pow, PrimInt, Signed, ToPrimitive, Zero};
 
 #[pyclass(module = false, name = "int")]
@@ -47,7 +50,15 @@ where
     }
 }
 
+// spell-checker:ignore MAXFREELIST
+thread_local! {
+    static INT_FREELIST: Cell<crate::object::FreeList<PyInt>> = const { Cell::new(crate::object::FreeList::new()) };
+}
+
 impl PyPayload for PyInt {
+    const MAX_FREELIST: usize = 100;
+    const HAS_FREELIST: bool = true;
+
     #[inline]
     fn class(ctx: &Context) -> &'static Py<PyType> {
         ctx.types.int_type
@@ -56,6 +67,36 @@ impl PyPayload for PyInt {
     fn into_pyobject(self, vm: &VirtualMachine) -> PyObjectRef {
         vm.ctx.new_int(self.value).into()
     }
+
+    #[inline]
+    unsafe fn freelist_push(obj: *mut PyObject) -> bool {
+        INT_FREELIST
+            .try_with(|fl| {
+                let mut list = fl.take();
+                let stored = if list.len() < Self::MAX_FREELIST {
+                    list.push(obj);
+                    true
+                } else {
+                    false
+                };
+                fl.set(list);
+                stored
+            })
+            .unwrap_or(false)
+    }
+
+    #[inline]
+    unsafe fn freelist_pop(_payload: &Self) -> Option<NonNull<PyObject>> {
+        INT_FREELIST
+            .try_with(|fl| {
+                let mut list = fl.take();
+                let result = list.pop().map(|p| unsafe { NonNull::new_unchecked(p) });
+                fl.set(list);
+                result
+            })
+            .ok()
+            .flatten()
+    }
 }
 
 macro_rules! impl_into_pyobject_int {
@@ -122,7 +163,7 @@ fn inner_pow(int1: &BigInt, int2: &BigInt, vm: &VirtualMachine) -> PyResult {
 
 fn inner_mod(int1: &BigInt, int2: &BigInt, vm: &VirtualMachine) -> PyResult {
     if int2.is_zero() {
-        Err(vm.new_zero_division_error("integer modulo by zero"))
+        Err(vm.new_zero_division_error("division by zero"))
     } else {
         Ok(vm.ctx.new_int(int1.mod_floor(int2)).into())
     }
@@ -130,7 +171,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 or modulo by zero"))
+        Err(vm.new_zero_division_error("division by zero"))
     } else {
         Ok(vm.ctx.new_int(int1.div_floor(int2)).into())
     }
@@ -138,7 +179,7 @@ fn inner_floordiv(int1: &BigInt, int2: &BigInt, vm: &VirtualMachine) -> PyResult
 
 fn inner_divmod(int1: &BigInt, int2: &BigInt, vm: &VirtualMachine) -> PyResult {
     if int2.is_zero() {
-        return Err(vm.new_zero_division_error("integer division or modulo by zero"));
+        return Err(vm.new_zero_division_error("division by zero"));
     }
     let (div, modulo) = int1.div_mod_floor(int2);
     Ok(vm.new_tuple((div, modulo)).into())
@@ -197,7 +238,7 @@ fn inner_truediv(i1: &BigInt, i2: &BigInt, vm: &VirtualMachine) -> PyResult {
     if float.is_infinite() {
         Err(vm.new_exception_msg(
             vm.ctx.exceptions.overflow_error.to_owned(),
-            "integer division result too large for a float".to_owned(),
+            "integer division result too large for a float".into(),
         ))
     } else {
         Ok(vm.ctx.new_float(float).into())
@@ -266,6 +307,15 @@ impl PyInt {
         &self.value
     }
 
+    /// Fast decimal string conversion, using i64 path when possible.
+    #[inline]
+    pub fn to_str_radix_10(&self) -> String {
+        match self.value.to_i64() {
+            Some(i) => i.to_string(),
+            None => self.value.to_string(),
+        }
+    }
+
     // _PyLong_AsUnsignedLongMask
     pub fn as_u32_mask(&self) -> u32 {
         let v = self.as_bigint();
@@ -364,7 +414,6 @@ impl PyInt {
                         if a.is_negative() { a + n } else { a }
                     }
                     fn inverse(a: BigInt, n: &BigInt) -> Option<BigInt> {
-                        use num_integer::*;
                         let ExtendedGcd { gcd, x: c, .. } = a.extended_gcd(n);
                         if gcd.is_one() {
                             Some(normalize(c, n))
@@ -444,9 +493,21 @@ impl PyInt {
     }
 
     #[pymethod]
-    fn __format__(&self, spec: PyStrRef, vm: &VirtualMachine) -> PyResult<String> {
-        FormatSpec::parse(spec.as_str())
-            .and_then(|format_spec| format_spec.format_int(&self.value))
+    fn __format__(zelf: &Py<Self>, spec: PyUtf8StrRef, vm: &VirtualMachine) -> PyResult<Wtf8Buf> {
+        // Empty format spec on a subclass: equivalent to str(self)
+        if spec.is_empty() && !zelf.class().is(vm.ctx.types.int_type) {
+            return Ok(zelf.as_object().str(vm)?.as_wtf8().to_owned());
+        }
+        let format_spec =
+            FormatSpec::parse(spec.as_str()).map_err(|err| err.into_pyexception(vm))?;
+        let result = if format_spec.has_locale_format() {
+            let locale = crate::format::get_locale_info();
+            format_spec.format_int_locale(&zelf.value, &locale)
+        } else {
+            format_spec.format_int(&zelf.value)
+        };
+        result
+            .map(Wtf8Buf::from_string)
             .map_err(|err| err.into_pyexception(vm))
     }
 
@@ -597,7 +658,7 @@ impl Comparable for PyInt {
 impl Representable for PyInt {
     #[inline]
     fn repr_str(zelf: &Py<Self>, _vm: &VirtualMachine) -> PyResult<String> {
-        Ok(zelf.value.to_string())
+        Ok(zelf.to_str_radix_10())
     }
 }
 
@@ -729,6 +790,24 @@ pub fn try_to_float(int: &BigInt, vm: &VirtualMachine) -> PyResult<f64> {
         .ok_or_else(|| vm.new_overflow_error("int too large to convert to float"))
 }
 
-pub(crate) fn init(context: &Context) {
+fn vectorcall_int(
+    zelf_obj: &PyObject,
+    args: Vec<PyObjectRef>,
+    nargs: usize,
+    kwnames: Option<&[PyObjectRef]>,
+    vm: &VirtualMachine,
+) -> PyResult {
+    let zelf: &Py<PyType> = zelf_obj.downcast_ref().unwrap();
+    let func_args = FuncArgs::from_vectorcall_owned(args, nargs, kwnames);
+    (zelf.slots.new.load().unwrap())(zelf.to_owned(), func_args, vm)
+}
+
+pub(crate) fn init(context: &'static Context) {
     PyInt::extend_class(context, context.types.int_type);
+    context
+        .types
+        .int_type
+        .slots
+        .vectorcall
+        .store(Some(vectorcall_int));
 }
diff --git a/crates/vm/src/builtins/interpolation.rs b/crates/vm/src/builtins/interpolation.rs
index d8127c151e3..b429fb5b91c 100644
--- a/crates/vm/src/builtins/interpolation.rs
+++ b/crates/vm/src/builtins/interpolation.rs
@@ -1,4 +1,7 @@
-use super::{PyStr, PyStrRef, PyTupleRef, PyType, tuple::IntoPyTuple};
+use super::{
+    PyStr, PyStrRef, PyTupleRef, PyType, PyTypeRef, genericalias::PyGenericAlias,
+    tuple::IntoPyTuple,
+};
 use crate::{
     AsObject, Context, Py, PyObject, PyObjectRef, PyPayload, PyRef, PyResult, VirtualMachine,
     class::PyClassImpl,
@@ -7,6 +10,8 @@ use crate::{
     function::{OptionalArg, PyComparisonValue},
     types::{Comparable, Constructor, Hashable, PyComparisonOp, Representable},
 };
+use itertools::Itertools;
+use rustpython_common::wtf8::Wtf8Buf;
 
 /// Interpolation object for t-strings (PEP 750).
 ///
@@ -39,11 +44,11 @@ impl PyInterpolation {
         let is_valid = vm.is_none(&conversion)
             || conversion
                 .downcast_ref::<PyStr>()
-                .is_some_and(|s| matches!(s.as_str(), "s" | "r" | "a"));
+                .is_some_and(|s| matches!(s.to_str(), Some("s") | Some("r") | Some("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(),
+                "Interpolation() argument 'conversion' must be one of 's', 'a' or 'r'".into(),
             ));
         }
         Ok(Self {
@@ -60,8 +65,13 @@ impl Constructor for PyInterpolation {
 
     fn py_new(_cls: &Py<PyType>, args: Self::Args, vm: &VirtualMachine) -> PyResult<Self> {
         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')) {
+            let has_flag = s
+                .as_bytes()
+                .iter()
+                .exactly_one()
+                .ok()
+                .is_some_and(|s| matches!(*s, b's' | b'r' | b'a'));
+            if !has_flag {
                 return Err(vm.new_value_error(
                     "Interpolation() argument 'conversion' must be one of 's', 'a' or 'r'",
                 ));
@@ -135,6 +145,11 @@ impl PyInterpolation {
         self.format_spec.clone()
     }
 
+    #[pyclassmethod]
+    fn __class_getitem__(cls: PyTypeRef, args: PyObjectRef, vm: &VirtualMachine) -> PyGenericAlias {
+        PyGenericAlias::from_args(cls, args, vm)
+    }
+
     #[pymethod]
     fn __reduce__(zelf: PyRef<Self>, vm: &VirtualMachine) -> PyTupleRef {
         let cls = zelf.class().to_owned();
@@ -186,28 +201,29 @@ impl Hashable for PyInterpolation {
 
 impl Representable for PyInterpolation {
     #[inline]
-    fn repr_str(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<String> {
+    fn repr_wtf8(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<Wtf8Buf> {
         let value_repr = zelf.value.repr(vm)?;
         let expr_repr = zelf.expression.repr(vm)?;
+        let spec_repr = zelf.format_spec.repr(vm)?;
 
-        let conv_str = if vm.is_none(&zelf.conversion) {
-            "None".to_owned()
+        let mut result = Wtf8Buf::from("Interpolation(");
+        result.push_wtf8(value_repr.as_wtf8());
+        result.push_str(", ");
+        result.push_str(&expr_repr);
+        result.push_str(", ");
+        if vm.is_none(&zelf.conversion) {
+            result.push_str("None");
         } else {
-            zelf.conversion.repr(vm)?.as_str().to_owned()
-        };
-
-        let spec_repr = zelf.format_spec.repr(vm)?;
+            result.push_wtf8(zelf.conversion.repr(vm)?.as_wtf8());
+        }
+        result.push_str(", ");
+        result.push_str(&spec_repr);
+        result.push_char(')');
 
-        Ok(format!(
-            "Interpolation({}, {}, {}, {})",
-            value_repr.as_str(),
-            expr_repr.as_str(),
-            conv_str,
-            spec_repr.as_str()
-        ))
+        Ok(result)
     }
 }
 
-pub fn init(context: &Context) {
+pub fn init(context: &'static Context) {
     PyInterpolation::extend_class(context, context.types.interpolation_type);
 }
diff --git a/crates/vm/src/builtins/iter.rs b/crates/vm/src/builtins/iter.rs
index 736303e95ee..f33b0e9bbbb 100644
--- a/crates/vm/src/builtins/iter.rs
+++ b/crates/vm/src/builtins/iter.rs
@@ -4,17 +4,14 @@
 
 use super::{PyInt, PyTupleRef, PyType};
 use crate::{
-    Context, Py, PyObject, PyObjectRef, PyPayload, PyResult, VirtualMachine,
+    Context, Py, PyObjectRef, PyPayload, PyResult, VirtualMachine,
     class::PyClassImpl,
     function::ArgCallable,
     object::{Traverse, TraverseFn},
     protocol::PyIterReturn,
     types::{IterNext, Iterable, SelfIter},
 };
-use rustpython_common::{
-    lock::{PyMutex, PyRwLock, PyRwLockUpgradableReadGuard},
-    static_cell,
-};
+use rustpython_common::lock::{PyMutex, PyRwLock, PyRwLockUpgradableReadGuard};
 
 /// Marks status of iterator.
 #[derive(Debug, Clone)]
@@ -71,33 +68,29 @@ impl<T> PositionIterInternal<T> {
         }
     }
 
-    fn _reduce<F>(&self, func: PyObjectRef, f: F, vm: &VirtualMachine) -> PyTupleRef
+    /// Build a pickle-compatible reduce tuple.
+    ///
+    /// `func` must be resolved **before** acquiring any lock that guards this
+    /// `PositionIterInternal`, so that the builtins lookup cannot trigger
+    /// reentrant iterator access and deadlock.
+    pub fn reduce<F, E>(
+        &self,
+        func: PyObjectRef,
+        active: F,
+        empty: E,
+        vm: &VirtualMachine,
+    ) -> PyTupleRef
     where
         F: FnOnce(&T) -> PyObjectRef,
+        E: FnOnce(&VirtualMachine) -> PyObjectRef,
     {
         if let IterStatus::Active(obj) = &self.status {
-            vm.new_tuple((func, (f(obj),), self.position))
+            vm.new_tuple((func, (active(obj),), self.position))
         } else {
-            vm.new_tuple((func, (vm.ctx.new_list(Vec::new()),)))
+            vm.new_tuple((func, (empty(vm),)))
         }
     }
 
-    pub fn builtins_iter_reduce<F>(&self, f: F, vm: &VirtualMachine) -> PyTupleRef
-    where
-        F: FnOnce(&T) -> PyObjectRef,
-    {
-        let iter = builtins_iter(vm).to_owned();
-        self._reduce(iter, f, vm)
-    }
-
-    pub fn builtins_reversed_reduce<F>(&self, f: F, vm: &VirtualMachine) -> PyTupleRef
-    where
-        F: FnOnce(&T) -> PyObjectRef,
-    {
-        let reversed = builtins_reversed(vm).to_owned();
-        self._reduce(reversed, f, vm)
-    }
-
     fn _next<F, OP>(&mut self, f: F, op: OP) -> PyResult<PyIterReturn>
     where
         F: FnOnce(&T, usize) -> PyResult<PyIterReturn>,
@@ -160,18 +153,12 @@ impl<T> PositionIterInternal<T> {
     }
 }
 
-pub fn builtins_iter(vm: &VirtualMachine) -> &PyObject {
-    static_cell! {
-        static INSTANCE: PyObjectRef;
-    }
-    INSTANCE.get_or_init(|| vm.builtins.get_attr("iter", vm).unwrap())
+pub fn builtins_iter(vm: &VirtualMachine) -> PyObjectRef {
+    vm.builtins.get_attr("iter", vm).unwrap()
 }
 
-pub fn builtins_reversed(vm: &VirtualMachine) -> &PyObject {
-    static_cell! {
-        static INSTANCE: PyObjectRef;
-    }
-    INSTANCE.get_or_init(|| vm.builtins.get_attr("reversed", vm).unwrap())
+pub fn builtins_reversed(vm: &VirtualMachine) -> PyObjectRef {
+    vm.builtins.get_attr("reversed", vm).unwrap()
 }
 
 #[pyclass(module = false, name = "iterator", traverse)]
@@ -211,7 +198,13 @@ impl PySequenceIterator {
 
     #[pymethod]
     fn __reduce__(&self, vm: &VirtualMachine) -> PyTupleRef {
-        self.internal.lock().builtins_iter_reduce(|x| x.clone(), vm)
+        let func = builtins_iter(vm);
+        self.internal.lock().reduce(
+            func,
+            |x| x.clone(),
+            |vm| vm.ctx.empty_tuple.clone().into(),
+            vm,
+        )
     }
 
     #[pymethod]
@@ -252,28 +245,51 @@ impl PyCallableIterator {
             status: PyRwLock::new(IterStatus::Active(callable)),
         }
     }
+
+    #[pymethod]
+    fn __reduce__(&self, vm: &VirtualMachine) -> PyTupleRef {
+        let func = builtins_iter(vm);
+        let status = self.status.read();
+        if let IterStatus::Active(callable) = &*status {
+            let callable_obj: PyObjectRef = callable.clone().into();
+            vm.new_tuple((func, (callable_obj, self.sentinel.clone())))
+        } else {
+            vm.new_tuple((func, (vm.ctx.empty_tuple.clone(),)))
+        }
+    }
 }
 
 impl SelfIter for PyCallableIterator {}
 impl IterNext for PyCallableIterator {
     fn next(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<PyIterReturn> {
-        let status = zelf.status.upgradable_read();
-        let next = if let IterStatus::Active(callable) = &*status {
-            let ret = callable.invoke((), vm)?;
-            if vm.bool_eq(&ret, &zelf.sentinel)? {
-                *PyRwLockUpgradableReadGuard::upgrade(status) = IterStatus::Exhausted;
-                PyIterReturn::StopIteration(None)
-            } else {
-                PyIterReturn::Return(ret)
+        // Clone the callable and release the lock before invoking,
+        // so that reentrant next() calls don't deadlock.
+        let callable = {
+            let status = zelf.status.read();
+            match &*status {
+                IterStatus::Active(callable) => callable.clone(),
+                IterStatus::Exhausted => return Ok(PyIterReturn::StopIteration(None)),
             }
-        } else {
-            PyIterReturn::StopIteration(None)
         };
-        Ok(next)
+
+        let ret = callable.invoke((), vm)?;
+
+        // Re-check: a reentrant call may have exhausted the iterator.
+        let status = zelf.status.upgradable_read();
+        if !matches!(&*status, IterStatus::Active(_)) {
+            return Ok(PyIterReturn::StopIteration(None));
+        }
+
+        if vm.bool_eq(&ret, &zelf.sentinel)? {
+            *PyRwLockUpgradableReadGuard::upgrade(status) = IterStatus::Exhausted;
+            Ok(PyIterReturn::StopIteration(None))
+        } else {
+            Ok(PyIterReturn::Return(ret))
+        }
     }
 }
 
-pub fn init(context: &Context) {
+pub fn init(context: &'static Context) {
     PySequenceIterator::extend_class(context, context.types.iter_type);
     PyCallableIterator::extend_class(context, context.types.callable_iterator);
 }
diff --git a/crates/vm/src/builtins/list.rs b/crates/vm/src/builtins/list.rs
index 9c961d2929d..f3ea11b595b 100644
--- a/crates/vm/src/builtins/list.rs
+++ b/crates/vm/src/builtins/list.rs
@@ -1,4 +1,7 @@
-use super::{PositionIterInternal, PyGenericAlias, PyTupleRef, PyType, PyTypeRef};
+use super::{
+    PositionIterInternal, PyGenericAlias, PyTupleRef, PyType, PyTypeRef,
+    iter::{builtins_iter, builtins_reversed},
+};
 use crate::atomic_func;
 use crate::common::lock::{
     PyMappedRwLockReadGuard, PyMutex, PyRwLock, PyRwLockReadGuard, PyRwLockWriteGuard,
@@ -6,6 +9,7 @@ use crate::common::lock::{
 use crate::object::{Traverse, TraverseFn};
 use crate::{
     AsObject, Context, Py, PyObject, PyObjectRef, PyPayload, PyRef, PyResult,
+    builtins::PyStr,
     class::PyClassImpl,
     convert::ToPyObject,
     function::{ArgSize, FuncArgs, OptionalArg, PyComparisonValue},
@@ -18,16 +22,21 @@ use crate::{
         AsMapping, AsSequence, Comparable, Constructor, Initializer, IterNext, Iterable,
         PyComparisonOp, Representable, SelfIter,
     },
-    utils::collection_repr,
     vm::VirtualMachine,
 };
+use rustpython_common::wtf8::Wtf8Buf;
+
 use alloc::fmt;
+use core::cell::Cell;
 use core::ops::DerefMut;
+use core::ptr::NonNull;
+use core::sync::atomic::{AtomicU32, Ordering};
 
 #[pyclass(module = false, name = "list", unhashable = true, traverse = "manual")]
 #[derive(Default)]
 pub struct PyList {
     elements: PyRwLock<Vec<PyObjectRef>>,
+    mutation_counter: AtomicU32,
 }
 
 impl fmt::Debug for PyList {
@@ -41,6 +50,7 @@ impl From<Vec<PyObjectRef>> for PyList {
     fn from(elements: Vec<PyObjectRef>) -> Self {
         Self {
             elements: PyRwLock::new(elements),
+            mutation_counter: AtomicU32::new(0),
         }
     }
 }
@@ -67,11 +77,48 @@ unsafe impl Traverse for PyList {
     }
 }
 
+thread_local! {
+    static LIST_FREELIST: Cell<crate::object::FreeList<PyList>> = const { Cell::new(crate::object::FreeList::new()) };
+}
+
 impl PyPayload for PyList {
+    const MAX_FREELIST: usize = 80;
+    const HAS_FREELIST: bool = true;
+
     #[inline]
     fn class(ctx: &Context) -> &'static Py<PyType> {
         ctx.types.list_type
     }
+
+    #[inline]
+    unsafe fn freelist_push(obj: *mut PyObject) -> bool {
+        LIST_FREELIST
+            .try_with(|fl| {
+                let mut list = fl.take();
+                let stored = if list.len() < Self::MAX_FREELIST {
+                    list.push(obj);
+                    true
+                } else {
+                    false
+                };
+                fl.set(list);
+                stored
+            })
+            .unwrap_or(false)
+    }
+
+    #[inline]
+    unsafe fn freelist_pop(_payload: &Self) -> Option<NonNull<PyObject>> {
+        LIST_FREELIST
+            .try_with(|fl| {
+                let mut list = fl.take();
+                let result = list.pop().map(|p| unsafe { NonNull::new_unchecked(p) });
+                fl.set(list);
+                result
+            })
+            .ok()
+            .flatten()
+    }
 }
 
 impl ToPyObject for Vec<PyObjectRef> {
@@ -91,7 +138,9 @@ impl PyList {
     }
 
     pub fn borrow_vec_mut(&self) -> PyRwLockWriteGuard<'_, Vec<PyObjectRef>> {
-        self.elements.write()
+        let guard = self.elements.write();
+        self.mutation_counter.fetch_add(1, Ordering::Relaxed);
+        guard
     }
 
     fn repeat(&self, n: isize, vm: &VirtualMachine) -> PyResult<PyRef<Self>> {
@@ -222,7 +271,13 @@ impl PyList {
 
     fn _getitem(&self, needle: &PyObject, vm: &VirtualMachine) -> PyResult {
         match SequenceIndex::try_from_borrowed_object(vm, needle, "list")? {
-            SequenceIndex::Int(i) => self.borrow_vec().getitem_by_index(vm, i),
+            SequenceIndex::Int(i) => {
+                let vec = self.borrow_vec();
+                let pos = vec
+                    .wrap_index(i)
+                    .ok_or_else(|| vm.new_index_error("list index out of range"))?;
+                Ok(vec.do_get(pos))
+            }
             SequenceIndex::Slice(slice) => self
                 .borrow_vec()
                 .getitem_by_slice(vm, slice)
@@ -236,7 +291,16 @@ impl PyList {
 
     fn _setitem(&self, needle: &PyObject, value: PyObjectRef, vm: &VirtualMachine) -> PyResult<()> {
         match SequenceIndex::try_from_borrowed_object(vm, needle, "list")? {
-            SequenceIndex::Int(index) => self.borrow_vec_mut().setitem_by_index(vm, index, value),
+            SequenceIndex::Int(index) => self
+                .borrow_vec_mut()
+                .setitem_by_index(vm, index, value)
+                .map_err(|e| {
+                    if e.class().is(vm.ctx.exceptions.index_error) {
+                        vm.new_index_error("list assignment index out of range".to_owned())
+                    } else {
+                        e
+                    }
+                }),
             SequenceIndex::Slice(slice) => {
                 let sec = extract_cloned(&value, Ok, vm)?;
                 self.borrow_vec_mut().setitem_by_slice(vm, slice, &sec)
@@ -332,12 +396,21 @@ 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 = core::mem::take(self.borrow_vec_mut().deref_mut());
+        let (mut elements, version_before) = {
+            let mut guard = self.elements.write();
+            let version_before = self.mutation_counter.load(Ordering::Relaxed);
+            (core::mem::take(guard.deref_mut()), version_before)
+        };
         let res = do_sort(vm, &mut elements, options.key, options.reverse);
-        core::mem::swap(self.borrow_vec_mut().deref_mut(), &mut elements);
+        let mutated = {
+            let mut guard = self.elements.write();
+            let mutated = self.mutation_counter.load(Ordering::Relaxed) != version_before;
+            core::mem::swap(guard.deref_mut(), &mut elements);
+            mutated
+        };
         res?;
 
-        if !elements.is_empty() {
+        if mutated {
             return Err(vm.new_value_error("list modified during sort"));
         }
 
@@ -445,9 +518,12 @@ impl AsSequence for PyList {
                     .map(|x| x.into())
             }),
             item: atomic_func!(|seq, i, vm| {
-                PyList::sequence_downcast(seq)
-                    .borrow_vec()
-                    .getitem_by_index(vm, i)
+                let list = PyList::sequence_downcast(seq);
+                let vec = list.borrow_vec();
+                let pos = vec
+                    .wrap_index(i)
+                    .ok_or_else(|| vm.new_index_error("list index out of range"))?;
+                Ok(vec.do_get(pos))
             }),
             ass_item: atomic_func!(|seq, i, value, vm| {
                 let zelf = PyList::sequence_downcast(seq);
@@ -456,6 +532,13 @@ impl AsSequence for PyList {
                 } else {
                     zelf.borrow_vec_mut().delitem_by_index(vm, i)
                 }
+                .map_err(|e| {
+                    if e.class().is(vm.ctx.exceptions.index_error) {
+                        vm.new_index_error("list assignment index out of range".to_owned())
+                    } else {
+                        e
+                    }
+                })
             }),
             contains: atomic_func!(|seq, target, vm| {
                 let zelf = PyList::sequence_downcast(seq);
@@ -504,15 +587,51 @@ impl Comparable for PyList {
 
 impl Representable for PyList {
     #[inline]
-    fn repr_str(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<String> {
-        let s = if zelf.__len__() == 0 {
-            "[]".to_owned()
-        } else if let Some(_guard) = ReprGuard::enter(vm, zelf.as_object()) {
-            collection_repr(None, "[", "]", zelf.borrow_vec().iter(), vm)?
+    fn repr(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<PyRef<PyStr>> {
+        if zelf.__len__() == 0 {
+            return Ok(vm.ctx.intern_str("[]").to_owned());
+        }
+
+        if let Some(_guard) = ReprGuard::enter(vm, zelf.as_object()) {
+            // Clone elements before calling repr to release the read lock.
+            // Element repr may mutate the list (e.g., list.clear()), which
+            // needs a write lock and would deadlock if read lock is held.
+            let mut writer = Wtf8Buf::new();
+            writer.push_char('[');
+
+            let mut elements = zelf.borrow_vec().to_vec();
+            let mut size = zelf.__len__();
+            let mut first = true;
+            let mut i = 0;
+            while i < size {
+                if elements.len() != size {
+                    // `repr` mutated the list. refetch it.
+                    elements = zelf.borrow_vec().to_vec();
+                }
+
+                let item = &elements[i];
+
+                if first {
+                    first = false;
+                } else {
+                    writer.push_str(", ");
+                }
+
+                writer.push_wtf8(item.repr(vm)?.as_wtf8());
+
+                size = zelf.__len__(); // Refetch list size as `repr` may mutate the list.
+                i += 1;
+            }
+
+            writer.push_char(']');
+            Ok(vm.ctx.new_str(writer))
         } else {
-            "[...]".to_owned()
-        };
-        Ok(s)
+            Ok(vm.ctx.intern_str("[...]").to_owned())
+        }
+    }
+
+    fn repr_str(_zelf: &Py<Self>, _vm: &VirtualMachine) -> PyResult<String> {
+        unreachable!("repr() is overridden directly")
     }
 }
 
@@ -577,9 +696,30 @@ impl PyListIterator {
 
     #[pymethod]
     fn __reduce__(&self, vm: &VirtualMachine) -> PyTupleRef {
+        let func = builtins_iter(vm);
+        self.internal.lock().reduce(
+            func,
+            |x| x.clone().into(),
+            |vm| vm.ctx.new_list(Vec::new()).into(),
+            vm,
+        )
+    }
+}
+
+impl PyListIterator {
+    /// Fast path for FOR_ITER specialization.
+    pub(crate) fn fast_next(&self) -> Option<PyObjectRef> {
         self.internal
             .lock()
-            .builtins_iter_reduce(|x| x.clone().into(), vm)
+            .next(|list, pos| {
+                let vec = list.borrow_vec();
+                Ok(PyIterReturn::from_result(vec.get(pos).cloned().ok_or(None)))
+            })
+            .ok()
+            .and_then(|r| match r {
+                PyIterReturn::Return(v) => Some(v),
+                PyIterReturn::StopIteration(_) => None,
+            })
     }
 }
 
@@ -622,9 +762,13 @@ impl PyListReverseIterator {
 
     #[pymethod]
     fn __reduce__(&self, vm: &VirtualMachine) -> PyTupleRef {
-        self.internal
-            .lock()
-            .builtins_reversed_reduce(|x| x.clone().into(), vm)
+        let func = builtins_reversed(vm);
+        self.internal.lock().reduce(
+            func,
+            |x| x.clone().into(),
+            |vm| vm.ctx.new_list(Vec::new()).into(),
+            vm,
+        )
     }
 }
 
@@ -638,9 +782,24 @@ impl IterNext for PyListReverseIterator {
     }
 }
 
-pub fn init(context: &Context) {
+fn vectorcall_list(
+    zelf_obj: &PyObject,
+    args: Vec<PyObjectRef>,
+    nargs: usize,
+    kwnames: Option<&[PyObjectRef]>,
+    vm: &VirtualMachine,
+) -> PyResult {
+    let zelf: &Py<PyType> = zelf_obj.downcast_ref().unwrap();
+    let obj = PyList::default().into_ref_with_type(vm, zelf.to_owned())?;
+    let func_args = FuncArgs::from_vectorcall_owned(args, nargs, kwnames);
+    PyList::slot_init(obj.clone().into(), func_args, vm)?;
+    Ok(obj.into())
+}
+
+pub fn init(context: &'static Context) {
     let list_type = &context.types.list_type;
     PyList::extend_class(context, list_type);
+    list_type.slots.vectorcall.store(Some(vectorcall_list));
 
     PyListIterator::extend_class(context, context.types.list_iterator_type);
     PyListReverseIterator::extend_class(context, context.types.list_reverseiterator_type);
diff --git a/crates/vm/src/builtins/map.rs b/crates/vm/src/builtins/map.rs
index f83030824f1..663c1bc94e0 100644
--- a/crates/vm/src/builtins/map.rs
+++ b/crates/vm/src/builtins/map.rs
@@ -1,19 +1,21 @@
-use super::{PyType, PyTypeRef};
+use super::PyType;
 use crate::{
-    Context, Py, PyObjectRef, PyPayload, PyResult, VirtualMachine,
+    AsObject, Context, Py, PyObjectRef, PyPayload, PyRef, PyResult, TryFromObject, VirtualMachine,
     builtins::PyTupleRef,
     class::PyClassImpl,
-    function::PosArgs,
+    function::{ArgIntoBool, OptionalArg, PosArgs},
     protocol::{PyIter, PyIterReturn},
-    raise_if_stop,
     types::{Constructor, IterNext, Iterable, SelfIter},
 };
+use rustpython_common::atomic::{self, PyAtomic, Radium};
 
 #[pyclass(module = false, name = "map", traverse)]
 #[derive(Debug)]
 pub struct PyMap {
     mapper: PyObjectRef,
     iterators: Vec<PyIter>,
+    #[pytraverse(skip)]
+    strict: PyAtomic<bool>,
 }
 
 impl PyPayload for PyMap {
@@ -23,16 +25,27 @@ impl PyPayload for PyMap {
     }
 }
 
+#[derive(FromArgs)]
+pub struct PyMapNewArgs {
+    #[pyarg(named, optional)]
+    strict: OptionalArg<bool>,
+}
+
 impl Constructor for PyMap {
-    type Args = (PyObjectRef, PosArgs<PyIter>);
+    type Args = (PyObjectRef, PosArgs<PyIter>, PyMapNewArgs);
 
     fn py_new(
         _cls: &Py<PyType>,
-        (mapper, iterators): Self::Args,
+        (mapper, iterators, args): Self::Args,
         _vm: &VirtualMachine,
     ) -> PyResult<Self> {
         let iterators = iterators.into_vec();
-        Ok(Self { mapper, iterators })
+        let strict = Radium::new(args.strict.unwrap_or(false));
+        Ok(Self {
+            mapper,
+            iterators,
+            strict,
+        })
     }
 }
 
@@ -48,10 +61,24 @@ impl PyMap {
     }
 
     #[pymethod]
-    fn __reduce__(&self, vm: &VirtualMachine) -> (PyTypeRef, PyTupleRef) {
-        let mut vec = vec![self.mapper.clone()];
-        vec.extend(self.iterators.iter().map(|o| o.clone().into()));
-        (vm.ctx.types.map_type.to_owned(), vm.new_tuple(vec))
+    fn __reduce__(zelf: PyRef<Self>, vm: &VirtualMachine) -> PyResult<PyTupleRef> {
+        let cls = zelf.class().to_owned();
+        let mut vec = vec![zelf.mapper.clone()];
+        vec.extend(zelf.iterators.iter().map(|o| o.clone().into()));
+        let tuple_args = vm.ctx.new_tuple(vec);
+        Ok(if zelf.strict.load(atomic::Ordering::Acquire) {
+            vm.new_tuple((cls, tuple_args, true))
+        } else {
+            vm.new_tuple((cls, tuple_args))
+        })
+    }
+
+    #[pymethod]
+    fn __setstate__(zelf: PyRef<Self>, state: PyObjectRef, vm: &VirtualMachine) -> PyResult<()> {
+        if let Ok(obj) = ArgIntoBool::try_from_object(vm, state) {
+            zelf.strict.store(obj.into(), atomic::Ordering::Release);
+        }
+        Ok(())
     }
 }
 
@@ -60,8 +87,35 @@ impl SelfIter for PyMap {}
 impl IterNext for PyMap {
     fn next(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<PyIterReturn> {
         let mut next_objs = Vec::new();
-        for iterator in &zelf.iterators {
-            let item = raise_if_stop!(iterator.next(vm)?);
+        for (idx, iterator) in zelf.iterators.iter().enumerate() {
+            let item = match iterator.next(vm)? {
+                PyIterReturn::Return(obj) => obj,
+                PyIterReturn::StopIteration(v) => {
+                    if zelf.strict.load(atomic::Ordering::Acquire) {
+                        if idx > 0 {
+                            let plural = if idx == 1 { " " } else { "s 1-" };
+                            return Err(vm.new_value_error(format!(
+                                "map() argument {} is shorter than argument{}{}",
+                                idx + 1,
+                                plural,
+                                idx,
+                            )));
+                        }
+                        for (idx, iterator) in zelf.iterators[1..].iter().enumerate() {
+                            if let PyIterReturn::Return(_) = iterator.next(vm)? {
+                                let plural = if idx == 0 { " " } else { "s 1-" };
+                                return Err(vm.new_value_error(format!(
+                                    "map() argument {} is longer than argument{}{}",
+                                    idx + 2,
+                                    plural,
+                                    idx + 1,
+                                )));
+                            }
+                        }
+                    }
+                    return Ok(PyIterReturn::StopIteration(v));
+                }
+            };
             next_objs.push(item);
         }
 
@@ -70,6 +124,6 @@ impl IterNext for PyMap {
     }
 }
 
-pub fn init(context: &Context) {
+pub fn init(context: &'static Context) {
     PyMap::extend_class(context, context.types.map_type);
 }
diff --git a/crates/vm/src/builtins/mappingproxy.rs b/crates/vm/src/builtins/mappingproxy.rs
index 1036dcfdaf9..df9c61e0a58 100644
--- a/crates/vm/src/builtins/mappingproxy.rs
+++ b/crates/vm/src/builtins/mappingproxy.rs
@@ -3,7 +3,7 @@ use crate::{
     AsObject, Context, Py, PyObject, PyObjectRef, PyPayload, PyRef, PyResult, VirtualMachine,
     atomic_func,
     class::PyClassImpl,
-    common::hash,
+    common::{hash, lock::LazyLock},
     convert::ToPyObject,
     function::{ArgMapping, OptionalArg, PyComparisonValue},
     object::{Traverse, TraverseFn},
@@ -13,7 +13,7 @@ use crate::{
         PyComparisonOp, Representable,
     },
 };
-use std::sync::LazyLock;
+use rustpython_common::wtf8::{Wtf8Buf, wtf8_concat};
 
 #[pyclass(module = false, name = "mappingproxy", traverse)]
 #[derive(Debug)]
@@ -287,12 +287,12 @@ impl Iterable for PyMappingProxy {
 
 impl Representable for PyMappingProxy {
     #[inline]
-    fn repr_str(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<String> {
+    fn repr_wtf8(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<Wtf8Buf> {
         let obj = zelf.to_object(vm)?;
-        Ok(format!("mappingproxy({})", obj.repr(vm)?))
+        Ok(wtf8_concat!("mappingproxy(", obj.repr(vm)?.as_wtf8(), ')'))
     }
 }
 
-pub fn init(context: &Context) {
+pub fn init(context: &'static Context) {
     PyMappingProxy::extend_class(context, context.types.mappingproxy_type)
 }
diff --git a/crates/vm/src/builtins/memory.rs b/crates/vm/src/builtins/memory.rs
index 6db260c80e0..73eb1f1780b 100644
--- a/crates/vm/src/builtins/memory.rs
+++ b/crates/vm/src/builtins/memory.rs
@@ -1,7 +1,8 @@
 use super::{
     PositionIterInternal, PyBytes, PyBytesRef, PyGenericAlias, PyInt, PyListRef, PySlice, PyStr,
-    PyStrRef, PyTuple, PyTupleRef, PyType, PyTypeRef,
+    PyStrRef, PyTuple, PyTupleRef, PyType, PyTypeRef, PyUtf8StrRef, iter::builtins_iter,
 };
+use crate::common::lock::LazyLock;
 use crate::{
     AsObject, Context, Py, PyObject, PyObjectRef, PyPayload, PyRef, PyResult,
     TryFromBorrowedObject, TryFromObject, VirtualMachine, atomic_func,
@@ -30,7 +31,6 @@ 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;
 
 #[derive(FromArgs)]
 pub struct PyMemoryViewNewArgs {
@@ -549,11 +549,10 @@ impl Py<PyMemoryView> {
         Iterable,
         Representable
     ),
-    flags(SEQUENCE)
+    flags(SEQUENCE, HAS_WEAKREF)
 )]
 impl PyMemoryView {
-    // TODO: Uncomment when Python adds __class_getitem__ to memoryview
-    // #[pyclassmethod]
+    #[pyclassmethod]
     fn __class_getitem__(cls: PyTypeRef, args: PyObjectRef, vm: &VirtualMachine) -> PyGenericAlias {
         PyGenericAlias::from_args(cls, args, vm)
     }
@@ -617,13 +616,22 @@ impl PyMemoryView {
     #[pygetset]
     fn suboffsets(&self, vm: &VirtualMachine) -> PyResult<PyTupleRef> {
         self.try_not_released(vm)?;
-        Ok(vm.ctx.new_tuple(
-            self.desc
-                .dim_desc
-                .iter()
-                .map(|(_, _, suboffset)| suboffset.to_pyobject(vm))
-                .collect(),
-        ))
+        let has_suboffsets = self
+            .desc
+            .dim_desc
+            .iter()
+            .any(|(_, _, suboffset)| *suboffset != 0);
+        if has_suboffsets {
+            Ok(vm.ctx.new_tuple(
+                self.desc
+                    .dim_desc
+                    .iter()
+                    .map(|(_, _, suboffset)| suboffset.to_pyobject(vm))
+                    .collect(),
+            ))
+        } else {
+            Ok(vm.ctx.empty_tuple.clone())
+        }
     }
 
     #[pygetset]
@@ -692,7 +700,7 @@ impl PyMemoryView {
         self.try_not_released(vm)?;
         if self.desc.ndim() == 0 {
             // 0-dimensional memoryview has no length
-            Err(vm.new_type_error("0-dim memory has no length".to_owned()))
+            Err(vm.new_type_error("0-dim memory has no length"))
         } else {
             // shape for dim[0]
             Ok(self.desc.dim_desc[0].0)
@@ -740,8 +748,66 @@ impl PyMemoryView {
         self.contiguous_or_collect(|x| bytes_to_hex(x, sep, bytes_per_sep, vm))
     }
 
-    fn cast_to_1d(&self, format: PyStrRef, vm: &VirtualMachine) -> PyResult<Self> {
-        let format_spec = Self::parse_format(format.as_str(), vm)?;
+    #[pymethod]
+    fn count(&self, value: PyObjectRef, vm: &VirtualMachine) -> PyResult<usize> {
+        self.try_not_released(vm)?;
+        if self.desc.ndim() != 1 {
+            return Err(
+                vm.new_not_implemented_error("multi-dimensional sub-views are not implemented")
+            );
+        }
+        let len = self.desc.dim_desc[0].0;
+        let mut count = 0;
+        for i in 0..len {
+            let item = self.getitem_by_idx(i as isize, vm)?;
+            if vm.bool_eq(&item, &value)? {
+                count += 1;
+            }
+        }
+        Ok(count)
+    }
+
+    #[pymethod]
+    fn index(
+        &self,
+        value: PyObjectRef,
+        start: OptionalArg<isize>,
+        stop: OptionalArg<isize>,
+        vm: &VirtualMachine,
+    ) -> PyResult<usize> {
+        self.try_not_released(vm)?;
+        if self.desc.ndim() != 1 {
+            return Err(
+                vm.new_not_implemented_error("multi-dimensional sub-views are not implemented")
+            );
+        }
+        let len = self.desc.dim_desc[0].0;
+        let start = start.unwrap_or(0);
+        let stop = stop.unwrap_or(len as isize);
+
+        let start = if start < 0 {
+            (start + len as isize).max(0) as usize
+        } else {
+            (start as usize).min(len)
+        };
+        let stop = if stop < 0 {
+            (stop + len as isize).max(0) as usize
+        } else {
+            (stop as usize).min(len)
+        };
+
+        for i in start..stop {
+            let item = self.getitem_by_idx(i as isize, vm)?;
+            if vm.bool_eq(&item, &value)? {
+                return Ok(i);
+            }
+        }
+        Err(vm.new_value_error("memoryview.index(x): x not in memoryview"))
+    }
+
+    fn cast_to_1d(&self, format: PyUtf8StrRef, vm: &VirtualMachine) -> PyResult<Self> {
+        let format_str = format.as_str();
+        let format_spec = Self::parse_format(format_str, vm)?;
         let itemsize = format_spec.size();
         if !self.desc.len.is_multiple_of(itemsize) {
             return Err(vm.new_type_error("memoryview: length is not a multiple of itemsize"));
@@ -756,7 +822,7 @@ impl PyMemoryView {
                 len: self.desc.len,
                 readonly: self.desc.readonly,
                 itemsize,
-                format: format.to_string().into(),
+                format: format_str.to_owned().into(),
                 dim_desc: vec![(self.desc.len / itemsize, itemsize as isize, 0)],
             },
             hash: OnceCell::new(),
@@ -891,7 +957,7 @@ impl Py<PyMemoryView> {
 #[derive(FromArgs)]
 struct CastArgs {
     #[pyarg(any)]
-    format: PyStrRef,
+    format: PyUtf8StrRef,
     #[pyarg(any, optional)]
     shape: OptionalArg<Either<PyTupleRef, PyListRef>>,
 }
@@ -1029,15 +1095,16 @@ impl Comparable for PyMemoryView {
 
 impl Hashable for PyMemoryView {
     fn hash(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<PyHash> {
-        zelf.hash
-            .get_or_try_init(|| {
-                zelf.try_not_released(vm)?;
-                if !zelf.desc.readonly {
-                    return Err(vm.new_value_error("cannot hash writable memoryview object"));
-                }
-                Ok(zelf.contiguous_or_collect(|bytes| vm.state.hash_secret.hash_bytes(bytes)))
-            })
-            .copied()
+        if let Some(val) = zelf.hash.get() {
+            return Ok(*val);
+        }
+        zelf.try_not_released(vm)?;
+        if !zelf.desc.readonly {
+            return Err(vm.new_value_error("cannot hash writable memoryview object"));
+        }
+        let val = zelf.contiguous_or_collect(|bytes| vm.state.hash_secret.hash_bytes(bytes));
+        let _ = zelf.hash.set(val);
+        Ok(*zelf.hash.get().unwrap())
     }
 }
 
@@ -1060,7 +1127,7 @@ impl Representable for PyMemoryView {
     }
 }
 
-pub(crate) fn init(ctx: &Context) {
+pub(crate) fn init(ctx: &'static Context) {
     PyMemoryView::extend_class(ctx, ctx.types.memoryview_type);
     PyMemoryViewIterator::extend_class(ctx, ctx.types.memoryviewiterator_type);
 }
@@ -1132,9 +1199,13 @@ impl PyPayload for PyMemoryViewIterator {
 impl PyMemoryViewIterator {
     #[pymethod]
     fn __reduce__(&self, vm: &VirtualMachine) -> PyTupleRef {
-        self.internal
-            .lock()
-            .builtins_iter_reduce(|x| x.clone().into(), vm)
+        let func = builtins_iter(vm);
+        self.internal.lock().reduce(
+            func,
+            |x| x.clone().into(),
+            |vm| vm.ctx.empty_tuple.clone().into(),
+            vm,
+        )
     }
 }
 
diff --git a/crates/vm/src/builtins/mod.rs b/crates/vm/src/builtins/mod.rs
index 994a4f9c758..099787332c9 100644
--- a/crates/vm/src/builtins/mod.rs
+++ b/crates/vm/src/builtins/mod.rs
@@ -9,6 +9,8 @@ pub(crate) mod bytearray;
 pub use bytearray::PyByteArray;
 pub(crate) mod bytes;
 pub use bytes::{PyBytes, PyBytesRef};
+pub(crate) mod capsule;
+pub use capsule::PyCapsule;
 pub(crate) mod classmethod;
 pub use classmethod::PyClassMethod;
 pub(crate) mod code;
@@ -61,7 +63,7 @@ pub(crate) mod bool_;
 pub use bool_::PyBool;
 #[path = "str.rs"]
 pub(crate) mod pystr;
-pub use pystr::{PyStr, PyStrInterned, PyStrRef, PyUtf8Str, PyUtf8StrRef};
+pub use pystr::{PyStr, PyStrInterned, PyStrRef, PyUtf8Str, PyUtf8StrInterned, PyUtf8StrRef};
 #[path = "super.rs"]
 pub(crate) mod super_;
 pub use super_::PySuper;
diff --git a/crates/vm/src/builtins/module.rs b/crates/vm/src/builtins/module.rs
index 60ffb1487fa..cabaf1d63cb 100644
--- a/crates/vm/src/builtins/module.rs
+++ b/crates/vm/src/builtins/module.rs
@@ -5,6 +5,7 @@ use crate::{
     class::PyClassImpl,
     convert::ToPyObject,
     function::{FuncArgs, PyMethodDef, PySetterValue},
+    import::{get_spec_file_origin, is_possibly_shadowing_path, is_stdlib_module_name},
     types::{GetAttr, Initializer, Representable},
 };
 
@@ -81,7 +82,10 @@ impl PyModuleDef {
     }
 }
 
-#[allow(clippy::new_without_default)] // avoid Default implementation
+#[allow(
+    clippy::new_without_default,
+    reason = "avoid a misleading Default implementation"
+)]
 #[pyclass(module = false, name = "module")]
 #[derive(Debug)]
 pub struct PyModule {
@@ -149,20 +153,97 @@ impl Py<PyModule> {
         if let Ok(getattr) = self.dict().get_item(identifier!(vm, __getattr__), vm) {
             return getattr.call((name.to_owned(),), vm);
         }
-        let module_name = if let Some(name) = self.name(vm) {
-            format!(" '{name}'")
+        let dict = self.dict();
+
+        // Get the raw __name__ object (may be a str subclass)
+        let mod_name_obj = dict
+            .get_item_opt(identifier!(vm, __name__), vm)
+            .ok()
+            .flatten();
+        let mod_name_str = mod_name_obj.as_ref().and_then(|n| {
+            n.downcast_ref::<PyStr>()
+                .map(|s| s.to_string_lossy().into_owned())
+        });
+
+        // If __name__ is not set or not a string, use a simpler error message
+        let mod_display = match mod_name_str.as_deref() {
+            Some(s) => s,
+            None => {
+                return Err(vm.new_attribute_error(format!("module has no attribute '{name}'")));
+            }
+        };
+
+        let spec = dict
+            .get_item_opt(vm.ctx.intern_str("__spec__"), vm)
+            .ok()
+            .flatten()
+            .filter(|s| !vm.is_none(s));
+
+        let origin = get_spec_file_origin(&spec, vm);
+
+        let is_possibly_shadowing = origin
+            .as_ref()
+            .map(|o| is_possibly_shadowing_path(o, vm))
+            .unwrap_or(false);
+        // Use the ORIGINAL __name__ object for stdlib check (may raise TypeError
+        // if __name__ is an unhashable str subclass)
+        let is_possibly_shadowing_stdlib = if is_possibly_shadowing {
+            if let Some(ref mod_name) = mod_name_obj {
+                is_stdlib_module_name(mod_name, vm)?
+            } else {
+                false
+            }
         } else {
-            "".to_owned()
+            false
         };
-        Err(vm.new_attribute_error(format!("module{module_name} has no attribute '{name}'")))
-    }
 
-    fn name(&self, vm: &VirtualMachine) -> Option<PyStrRef> {
-        let name = self
-            .as_object()
-            .generic_getattr_opt(identifier!(vm, __name__), None, vm)
-            .unwrap_or_default()?;
-        name.downcast::<PyStr>().ok()
+        if is_possibly_shadowing_stdlib {
+            let origin = origin.as_ref().unwrap();
+            Err(vm.new_attribute_error(format!(
+                "module '{mod_display}' has no attribute '{name}' \
+                 (consider renaming '{origin}' since it has the same \
+                 name as the standard library module named '{mod_display}' \
+                 and prevents importing that standard library module)"
+            )))
+        } else {
+            let is_initializing = PyModule::is_initializing(&dict, vm);
+            if is_initializing {
+                if is_possibly_shadowing {
+                    let origin = origin.as_ref().unwrap();
+                    Err(vm.new_attribute_error(format!(
+                        "module '{mod_display}' has no attribute '{name}' \
+                         (consider renaming '{origin}' if it has the same name \
+                         as a library you intended to import)"
+                    )))
+                } else if let Some(ref origin) = origin {
+                    Err(vm.new_attribute_error(format!(
+                        "partially initialized module '{mod_display}' from '{origin}' \
+                         has no attribute '{name}' \
+                         (most likely due to a circular import)"
+                    )))
+                } else {
+                    Err(vm.new_attribute_error(format!(
+                        "partially initialized module '{mod_display}' \
+                         has no attribute '{name}' \
+                         (most likely due to a circular import)"
+                    )))
+                }
+            } else {
+                // Check for uninitialized submodule
+                let submodule_initializing =
+                    is_uninitialized_submodule(mod_name_str.as_ref(), name, vm);
+                if submodule_initializing {
+                    Err(vm.new_attribute_error(format!(
+                        "cannot access submodule '{name}' of module '{mod_display}' \
+                         (most likely due to a circular import)"
+                    )))
+                } else {
+                    Err(vm.new_attribute_error(format!(
+                        "module '{mod_display}' has no attribute '{name}'"
+                    )))
+                }
+            }
+        }
     }
 
     // TODO: to be replaced by the commented-out dict method above once dictoffset land
@@ -205,7 +286,10 @@ impl Py<PyModule> {
     }
 }
 
-#[pyclass(with(GetAttr, Initializer, Representable), flags(BASETYPE, HAS_DICT))]
+#[pyclass(
+    with(GetAttr, Initializer, Representable),
+    flags(BASETYPE, HAS_DICT, HAS_WEAKREF)
+)]
 impl PyModule {
     #[pyslot]
     fn slot_new(cls: PyTypeRef, _args: FuncArgs, vm: &VirtualMachine) -> PyResult {
@@ -324,7 +408,7 @@ impl PyModule {
             }
             PySetterValue::Delete => {
                 if dict.del_item(identifier!(vm, __annotations__), vm).is_err() {
-                    return Err(vm.new_attribute_error("__annotations__".to_owned()));
+                    return Err(vm.new_attribute_error("__annotations__"));
                 }
                 // Also clear __annotate__
                 dict.del_item(identifier!(vm, __annotate__), vm).ok();
@@ -344,7 +428,7 @@ impl Initializer for PyModule {
                 .flags
                 .has_feature(crate::types::PyTypeFlags::HAS_DICT)
         );
-        zelf.init_dict(vm.ctx.intern_str(args.name.as_str()), args.doc, vm);
+        zelf.init_dict(vm.ctx.intern_str(args.name.as_wtf8()), args.doc, vm);
         Ok(())
     }
 }
@@ -358,8 +442,8 @@ impl GetAttr for PyModule {
 impl Representable for PyModule {
     #[inline]
     fn repr(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<PyStrRef> {
-        let importlib = vm.import("_frozen_importlib", 0)?;
-        let module_repr = importlib.get_attr("_module_repr", vm)?;
+        // Use cached importlib reference (like interp->importlib)
+        let module_repr = vm.importlib.get_attr("_module_repr", vm)?;
         let repr = module_repr.call((zelf.to_owned(),), vm)?;
         repr.downcast()
             .map_err(|_| vm.new_type_error("_module_repr did not return a string"))
@@ -371,6 +455,35 @@ impl Representable for PyModule {
     }
 }
 
-pub(crate) fn init(context: &Context) {
+pub(crate) fn init(context: &'static Context) {
     PyModule::extend_class(context, context.types.module_type);
 }
+
+/// Check if {module_name}.{name} is an uninitialized submodule in sys.modules.
+fn is_uninitialized_submodule(
+    module_name: Option<&String>,
+    name: &Py<PyStr>,
+    vm: &VirtualMachine,
+) -> bool {
+    let mod_name = match module_name {
+        Some(n) => n.as_str(),
+        None => return false,
+    };
+    let full_name = format!("{mod_name}.{name}");
+    let sys_modules = match vm.sys_module.get_attr("modules", vm).ok() {
+        Some(m) => m,
+        None => return false,
+    };
+    let sub_mod = match sys_modules.get_item(&full_name, vm).ok() {
+        Some(m) => m,
+        None => return false,
+    };
+    let spec = match sub_mod.get_attr("__spec__", vm).ok() {
+        Some(s) if !vm.is_none(&s) => s,
+        _ => return false,
+    };
+    spec.get_attr("_initializing", vm)
+        .ok()
+        .and_then(|v| v.try_to_bool(vm).ok())
+        .unwrap_or(false)
+}
diff --git a/crates/vm/src/builtins/namespace.rs b/crates/vm/src/builtins/namespace.rs
index 2cc1693302a..4e872a172a4 100644
--- a/crates/vm/src/builtins/namespace.rs
+++ b/crates/vm/src/builtins/namespace.rs
@@ -1,4 +1,4 @@
-use super::{PyTupleRef, PyType, tuple::IntoPyTuple};
+use super::{PyStr, PyTupleRef, PyType, tuple::IntoPyTuple};
 use crate::{
     AsObject, Context, Py, PyObject, PyObjectRef, PyPayload, PyRef, PyResult, VirtualMachine,
     builtins::PyDict,
@@ -9,6 +9,7 @@ use crate::{
         Comparable, Constructor, DefaultConstructor, Initializer, PyComparisonOp, Representable,
     },
 };
+use rustpython_common::wtf8::Wtf8Buf;
 
 /// A simple attribute-based namespace.
 ///
@@ -27,7 +28,7 @@ impl PyPayload for PyNamespace {
 impl DefaultConstructor for PyNamespace {}
 
 #[pyclass(
-    flags(BASETYPE, HAS_DICT),
+    flags(BASETYPE, HAS_DICT, HAS_WEAKREF),
     with(Constructor, Initializer, Comparable, Representable)
 )]
 impl PyNamespace {
@@ -138,7 +139,7 @@ impl Comparable for PyNamespace {
 
 impl Representable for PyNamespace {
     #[inline]
-    fn repr_str(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<String> {
+    fn repr_wtf8(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<Wtf8Buf> {
         let o = zelf.as_object();
         let name = if o.class().is(vm.ctx.types.namespace_type) {
             "namespace".to_owned()
@@ -148,21 +149,32 @@ impl Representable for PyNamespace {
 
         let repr = if let Some(_guard) = ReprGuard::enter(vm, zelf.as_object()) {
             let dict = zelf.as_object().dict().unwrap();
-            let mut parts = Vec::with_capacity(dict.__len__());
+            let mut result = Wtf8Buf::from(format!("{name}("));
+            let mut first = true;
             for (key, value) in dict {
-                let k = key.repr(vm)?;
-                let key_str = k.as_wtf8();
-                let value_repr = value.repr(vm)?;
-                parts.push(format!("{}={}", &key_str[1..key_str.len() - 1], value_repr));
+                let Some(key_str) = key.downcast_ref::<PyStr>() else {
+                    continue;
+                };
+                if key_str.as_wtf8().is_empty() {
+                    continue;
+                }
+                if !first {
+                    result.push_str(", ");
+                }
+                first = false;
+                result.push_wtf8(key_str.as_wtf8());
+                result.push_char('=');
+                result.push_wtf8(value.repr(vm)?.as_wtf8());
             }
-            format!("{}({})", name, parts.join(", "))
+            result.push_char(')');
+            result
         } else {
-            format!("{name}(...)")
+            Wtf8Buf::from(format!("{name}(...)"))
         };
         Ok(repr)
     }
 }
 
-pub fn init(context: &Context) {
+pub fn init(context: &'static Context) {
     PyNamespace::extend_class(context, context.types.namespace_type);
 }
diff --git a/crates/vm/src/builtins/object.rs b/crates/vm/src/builtins/object.rs
index eb9d226acb4..002b05d38f1 100644
--- a/crates/vm/src/builtins/object.rs
+++ b/crates/vm/src/builtins/object.rs
@@ -1,4 +1,4 @@
-use super::{PyDictRef, PyList, PyStr, PyStrRef, PyType, PyTypeRef};
+use super::{PyDictRef, PyList, PyStr, PyStrRef, PyType, PyTypeRef, PyUtf8StrRef};
 use crate::common::hash::PyHash;
 use crate::types::PyTypeFlags;
 use crate::{
@@ -43,8 +43,7 @@ impl Constructor for PyBaseObject {
                     // Type has its own __new__, so object.__new__ is being called
                     // with excess args. This is the first error case in CPython
                     return Err(vm.new_type_error(
-                        "object.__new__() takes exactly one argument (the type to instantiate)"
-                            .to_owned(),
+                        "object.__new__() takes exactly one argument (the type to instantiate)",
                     ));
                 }
 
@@ -65,26 +64,16 @@ impl Constructor for PyBaseObject {
             }
         }
 
-        // more or less __new__ operator
-        // Only create dict if the class has HAS_DICT flag (i.e., __slots__ was not defined
-        // or __dict__ is in __slots__)
-        let dict = if cls
-            .slots
-            .flags
-            .has_feature(crate::types::PyTypeFlags::HAS_DICT)
-        {
-            Some(vm.ctx.new_dict())
-        } else {
-            None
-        };
-
         // Ensure that all abstract methods are implemented before instantiating instance.
         if let Some(abs_methods) = cls.get_attr(identifier!(vm, __abstractmethods__))
             && let Some(unimplemented_abstract_method_count) = abs_methods.length_opt(vm)
         {
-            let methods: Vec<PyStrRef> = abs_methods.try_to_value(vm)?;
-            let methods: String =
-                Itertools::intersperse(methods.iter().map(|name| name.as_str()), "', '").collect();
+            let methods: Vec<PyUtf8StrRef> = abs_methods.try_to_value(vm)?;
+            let methods: String = Itertools::intersperse(
+                methods.iter().map(|name| name.as_str().to_owned()),
+                "', '".to_owned(),
+            )
+            .collect();
 
             let unimplemented_abstract_method_count = unimplemented_abstract_method_count?;
             let name = cls.name().to_string();
@@ -107,7 +96,7 @@ impl Constructor for PyBaseObject {
             }
         }
 
-        Ok(crate::PyRef::new_ref(Self, cls, dict).into())
+        generic_alloc(cls, 0, vm)
     }
 
     fn py_new(_cls: &Py<PyType>, _args: Self::Args, _vm: &VirtualMachine) -> PyResult<Self> {
@@ -115,6 +104,21 @@ impl Constructor for PyBaseObject {
     }
 }
 
+pub(crate) fn generic_alloc(cls: PyTypeRef, _nitems: usize, vm: &VirtualMachine) -> PyResult {
+    // Only create dict if the class has HAS_DICT flag (i.e., __slots__ was not defined
+    // or __dict__ is in __slots__)
+    let dict = if cls
+        .slots
+        .flags
+        .has_feature(crate::types::PyTypeFlags::HAS_DICT)
+    {
+        Some(vm.ctx.new_dict())
+    } else {
+        None
+    };
+    Ok(crate::PyRef::new_ref(PyBaseObject, cls, dict).into())
+}
+
 impl Initializer for PyBaseObject {
     type Args = FuncArgs;
 
@@ -133,16 +137,16 @@ impl Initializer for PyBaseObject {
         // 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(),
+                "object.__init__() takes exactly one argument (the instance to initialize)",
             ));
         }
 
-        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 {
+        if let (Some(typ_new), Some(object_new)) = (
+            typ.get_attr(identifier!(vm, __new__)),
+            object_type.get_attr(identifier!(vm, __new__)),
+        ) && typ_new.is(&object_new)
+        {
             return Err(vm.new_type_error(format!(
                 "{}.__init__() takes exactly one argument (the instance to initialize)",
                 typ.name()
@@ -217,7 +221,7 @@ fn object_getstate_default(obj: &PyObject, required: bool, vm: &VirtualMachine)
         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__"),
+                Some(slots) => slots.iter().any(|s| s.as_bytes() == b"__weakref__"),
             }
         } else {
             let weakref_name = vm.ctx.intern_str("__weakref__");
@@ -246,15 +250,13 @@ fn object_getstate_default(obj: &PyObject, required: bool, vm: &VirtualMachine)
                 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(),
-                    ));
+                    return Err(vm.new_runtime_error("__slotnames__ changed size during iteration"));
                 }
                 let name = borrowed_names[i].downcast_ref::<PyStr>().unwrap();
                 let Ok(value) = obj.get_attr(name, vm) else {
                     continue;
                 };
-                slots.set_item(name.as_str(), value, vm).unwrap();
+                slots.set_item(name.as_wtf8(), value, vm).unwrap();
             }
 
             if !slots.is_empty() {
@@ -361,7 +363,7 @@ impl PyBaseObject {
     }
 
     #[pyslot]
-    fn slot_setattro(
+    pub(crate) fn slot_setattro(
         obj: &PyObject,
         attr_name: &Py<PyStr>,
         value: PySetterValue,
@@ -384,11 +386,11 @@ impl PyBaseObject {
             class
                 .__qualname__(vm)
                 .downcast_ref::<PyStr>()
-                .map(|n| n.as_str()),
+                .map(|n| n.as_wtf8()),
             class
                 .__module__(vm)
                 .downcast_ref::<PyStr>()
-                .map(|m| m.as_str()),
+                .map(|m| m.as_wtf8()),
         ) {
             (None, _) => Err(vm.new_type_error("Unknown qualified name")),
             (Some(qualname), Some(module)) if module != "builtins" => Ok(PyStr::from(format!(
@@ -460,6 +462,8 @@ impl PyBaseObject {
                 if both_mutable || both_module {
                     let has_dict =
                         |typ: &Py<PyType>| typ.slots.flags.has_feature(PyTypeFlags::HAS_DICT);
+                    let has_weakref =
+                        |typ: &Py<PyType>| typ.slots.flags.has_feature(PyTypeFlags::HAS_WEAKREF);
                     // Compare slots tuples
                     let slots_equal = match (
                         current_cls
@@ -472,7 +476,7 @@ impl PyBaseObject {
                             a.len() == b.len()
                                 && a.iter()
                                     .zip(b.iter())
-                                    .all(|(x, y)| x.as_str() == y.as_str())
+                                    .all(|(x, y)| x.as_wtf8() == y.as_wtf8())
                         }
                         (None, None) => true,
                         _ => false,
@@ -480,6 +484,8 @@ impl PyBaseObject {
                     if current_cls.slots.basicsize != cls.slots.basicsize
                         || !slots_equal
                         || has_dict(current_cls) != has_dict(&cls)
+                        || has_weakref(current_cls) != has_weakref(&cls)
+                        || current_cls.slots.member_count != cls.slots.member_count
                     {
                         return Err(vm.new_type_error(format!(
                             "__class__ assignment: '{}' object layout differs from '{}'",
@@ -556,9 +562,10 @@ pub fn object_set_dict(obj: PyObjectRef, dict: PyDictRef, vm: &VirtualMachine) -
         .map_err(|_| vm.new_attribute_error("This object has no __dict__"))
 }
 
-pub fn init(ctx: &Context) {
-    // Manually set init slot - derive macro doesn't generate extend_slots
+pub fn init(ctx: &'static Context) {
+    // Manually set alloc/init slots - derive macro doesn't generate extend_slots
     // for trait impl that overrides #[pyslot] method
+    ctx.types.object_type.slots.alloc.store(Some(generic_alloc));
     ctx.types
         .object_type
         .slots
@@ -710,7 +717,7 @@ fn reduce_newobj(obj: PyObjectRef, vm: &VirtualMachine) -> PyResult {
     } 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()));
+            return Err(vm.new_system_error("bad internal call"));
         };
         // Use copyreg.__newobj_ex__
         let newobj = copyreg.get_attr("__newobj_ex__", vm)?;
diff --git a/crates/vm/src/builtins/property.rs b/crates/vm/src/builtins/property.rs
index 8cc9ba92e92..d01477dfcbf 100644
--- a/crates/vm/src/builtins/property.rs
+++ b/crates/vm/src/builtins/property.rs
@@ -65,7 +65,10 @@ impl GetDescriptor for PyProperty {
     }
 }
 
-#[pyclass(with(Constructor, Initializer, GetDescriptor), flags(BASETYPE))]
+#[pyclass(
+    with(Constructor, Initializer, GetDescriptor),
+    flags(BASETYPE, HAS_WEAKREF)
+)]
 impl PyProperty {
     // Helper method to get property name
     // Returns the name if available, None if not found, or propagates errors
@@ -133,6 +136,10 @@ impl PyProperty {
         self.getter.read().clone()
     }
 
+    pub(crate) fn get_fget(&self) -> Option<PyObjectRef> {
+        self.getter.read().clone()
+    }
+
     #[pygetset]
     fn fset(&self) -> Option<PyObjectRef> {
         self.setter.read().clone()
@@ -147,9 +154,7 @@ impl PyProperty {
     fn name_getter(&self, vm: &VirtualMachine) -> PyResult {
         match self.get_property_name(vm)? {
             Some(name) => Ok(name),
-            None => Err(
-                vm.new_attribute_error("'property' object has no attribute '__name__'".to_owned())
-            ),
+            None => Err(vm.new_attribute_error("'property' object has no attribute '__name__'")),
         }
     }
 
@@ -395,7 +400,7 @@ impl Initializer for PyProperty {
     }
 }
 
-pub(crate) fn init(context: &Context) {
+pub(crate) fn init(context: &'static Context) {
     PyProperty::extend_class(context, context.types.property_type);
 
     // This is a bit unfortunate, but this instance attribute overlaps with the
diff --git a/crates/vm/src/builtins/range.rs b/crates/vm/src/builtins/range.rs
index 49f50ffbaa2..153a82bb43b 100644
--- a/crates/vm/src/builtins/range.rs
+++ b/crates/vm/src/builtins/range.rs
@@ -2,6 +2,7 @@ use super::{
     PyGenericAlias, PyInt, PyIntRef, PySlice, PyTupleRef, PyType, PyTypeRef, builtins_iter,
     tuple::tuple_hash,
 };
+use crate::common::lock::LazyLock;
 use crate::{
     AsObject, Context, Py, PyObject, PyObjectRef, PyPayload, PyRef, PyResult, TryFromObject,
     VirtualMachine, atomic_func,
@@ -14,12 +15,13 @@ use crate::{
         Representable, SelfIter,
     },
 };
+use core::cell::Cell;
 use core::cmp::max;
+use core::ptr::NonNull;
 use crossbeam_utils::atomic::AtomicCell;
 use malachite_bigint::{BigInt, Sign};
 use num_integer::Integer;
 use num_traits::{One, Signed, ToPrimitive, Zero};
-use std::sync::LazyLock;
 
 // Search flag passed to iter_search
 enum SearchType {
@@ -52,8 +54,9 @@ fn iter_search(
         SearchType::Index => Err(vm.new_value_error(format!(
             "{} not in range",
             item.repr(vm)
-                .map(|v| v.as_str().to_owned())
-                .unwrap_or_else(|_| "value".to_owned())
+                .as_ref()
+                .map_or("value".as_ref(), |s| s.as_wtf8())
+                .to_owned()
         ))),
     }
 }
@@ -66,11 +69,49 @@ pub struct PyRange {
     pub step: PyIntRef,
 }
 
+// spell-checker:ignore MAXFREELIST
+thread_local! {
+    static RANGE_FREELIST: Cell<crate::object::FreeList<PyRange>> = const { Cell::new(crate::object::FreeList::new()) };
+}
+
 impl PyPayload for PyRange {
+    const MAX_FREELIST: usize = 6;
+    const HAS_FREELIST: bool = true;
+
     #[inline]
     fn class(ctx: &Context) -> &'static Py<PyType> {
         ctx.types.range_type
     }
+
+    #[inline]
+    unsafe fn freelist_push(obj: *mut PyObject) -> bool {
+        RANGE_FREELIST
+            .try_with(|fl| {
+                let mut list = fl.take();
+                let stored = if list.len() < Self::MAX_FREELIST {
+                    list.push(obj);
+                    true
+                } else {
+                    false
+                };
+                fl.set(list);
+                stored
+            })
+            .unwrap_or(false)
+    }
+
+    #[inline]
+    unsafe fn freelist_pop(_payload: &Self) -> Option<NonNull<PyObject>> {
+        RANGE_FREELIST
+            .try_with(|fl| {
+                let mut list = fl.take();
+                let result = list.pop().map(|p| unsafe { NonNull::new_unchecked(p) });
+                fl.set(list);
+                result
+            })
+            .ok()
+            .flatten()
+    }
 }
 
 impl PyRange {
@@ -166,7 +207,7 @@ impl PyRange {
 //     obj.downcast_ref::<PyRange>().unwrap().clone()
 // }
 
-pub fn init(context: &Context) {
+pub fn init(context: &'static Context) {
     PyRange::extend_class(context, context.types.range_type);
     PyLongRangeIterator::extend_class(context, context.types.long_range_iterator_type);
     PyRangeIterator::extend_class(context, context.types.range_iterator_type);
@@ -646,18 +687,25 @@ impl PyRangeIterator {
     }
 }
 
+impl PyRangeIterator {
+    /// Fast path for FOR_ITER specialization. Returns the next isize value
+    /// without allocating PyInt or PyIterReturn.
+    pub(crate) fn fast_next(&self) -> Option<isize> {
+        let index = self.index.fetch_add(1);
+        if index < self.length {
+            Some(self.start + (index as isize) * self.step)
+        } else {
+            None
+        }
+    }
+}
+
 impl SelfIter for PyRangeIterator {}
 impl IterNext for PyRangeIterator {
     fn next(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<PyIterReturn> {
-        // TODO: In pathological case (index == usize::MAX) this can wrap around
-        // (since fetch_add wraps). This would result in the iterator spinning again
-        // from the beginning.
-        let index = zelf.index.fetch_add(1);
-        let r = if index < zelf.length {
-            let value = zelf.start + (index as isize) * zelf.step;
-            PyIterReturn::Return(vm.ctx.new_int(value).into())
-        } else {
-            PyIterReturn::StopIteration(None)
+        let r = match zelf.fast_next() {
+            Some(value) => PyIterReturn::Return(vm.ctx.new_int(value).into()),
+            None => PyIterReturn::StopIteration(None),
         };
         Ok(r)
     }
@@ -670,7 +718,7 @@ fn range_iter_reduce(
     index: usize,
     vm: &VirtualMachine,
 ) -> PyResult<PyTupleRef> {
-    let iter = builtins_iter(vm).to_owned();
+    let iter = builtins_iter(vm);
     let stop = start.clone() + length * step.clone();
     let range = PyRange {
         start: PyInt::from(start).into_ref(&vm.ctx),
diff --git a/crates/vm/src/builtins/set.rs b/crates/vm/src/builtins/set.rs
index c3473809734..a6a58367f4f 100644
--- a/crates/vm/src/builtins/set.rs
+++ b/crates/vm/src/builtins/set.rs
@@ -5,11 +5,12 @@ use super::{
     IterStatus, PositionIterInternal, PyDict, PyDictRef, PyGenericAlias, PyTupleRef, PyType,
     PyTypeRef, builtins_iter,
 };
+use crate::common::lock::LazyLock;
 use crate::{
     AsObject, Context, Py, PyObject, PyObjectRef, PyPayload, PyRef, PyResult, TryFromObject,
     atomic_func,
     class::PyClassImpl,
-    common::{ascii, hash::PyHash, lock::PyMutex, rc::PyRc},
+    common::{ascii, hash::PyHash, lock::PyMutex, rc::PyRc, wtf8::Wtf8Buf},
     convert::ToPyResult,
     dict_inner::{self, DictSize},
     function::{ArgIterable, FuncArgs, OptionalArg, PosArgs, PyArithmeticValue, PyComparisonValue},
@@ -30,7 +31,6 @@ use rustpython_common::{
     atomic::{Ordering, PyAtomic, Radium},
     hash,
 };
-use std::sync::LazyLock;
 
 pub type SetContentType = dict_inner::Dict<()>;
 
@@ -318,7 +318,7 @@ impl PySetInner {
         }
     }
 
-    fn repr(&self, class_name: Option<&str>, vm: &VirtualMachine) -> PyResult<String> {
+    fn repr(&self, class_name: Option<&str>, vm: &VirtualMachine) -> PyResult<Wtf8Buf> {
         collection_repr(class_name, "{", "}", self.elements().iter(), vm)
     }
 
@@ -531,7 +531,7 @@ fn reduce_set(
         AsNumber,
         Representable
     ),
-    flags(BASETYPE, _MATCH_SELF)
+    flags(BASETYPE, _MATCH_SELF, HAS_WEAKREF)
 )]
 impl PySet {
     fn __len__(&self) -> usize {
@@ -671,8 +671,7 @@ impl PySet {
 
     #[pymethod]
     pub fn add(&self, item: PyObjectRef, vm: &VirtualMachine) -> PyResult<()> {
-        self.inner.add(item, vm)?;
-        Ok(())
+        self.inner.add(item, vm)
     }
 
     #[pymethod]
@@ -682,8 +681,7 @@ impl PySet {
 
     #[pymethod]
     fn discard(&self, item: PyObjectRef, vm: &VirtualMachine) -> PyResult<()> {
-        self.inner.discard(&item, vm)?;
-        Ok(())
+        self.inner.discard(&item, vm).map(|_| ())
     }
 
     #[pymethod]
@@ -729,8 +727,7 @@ impl PySet {
 
     #[pymethod]
     fn difference_update(&self, others: PosArgs<ArgIterable>, vm: &VirtualMachine) -> PyResult<()> {
-        self.inner.difference_update(others.into_iter(), vm)?;
-        Ok(())
+        self.inner.difference_update(others.into_iter(), vm)
     }
 
     fn __isub__(zelf: PyRef<Self>, set: AnySet, vm: &VirtualMachine) -> PyResult<PyRef<Self>> {
@@ -750,8 +747,7 @@ impl PySet {
         vm: &VirtualMachine,
     ) -> PyResult<()> {
         self.inner
-            .symmetric_difference_update(others.into_iter(), vm)?;
-        Ok(())
+            .symmetric_difference_update(others.into_iter(), vm)
     }
 
     fn __ixor__(zelf: PyRef<Self>, set: AnySet, vm: &VirtualMachine) -> PyResult<PyRef<Self>> {
@@ -942,23 +938,19 @@ impl AsNumber for PySet {
 
 impl Representable for PySet {
     #[inline]
-    fn repr_str(zelf: &crate::Py<Self>, vm: &VirtualMachine) -> PyResult<String> {
+    fn repr_wtf8(zelf: &crate::Py<Self>, vm: &VirtualMachine) -> PyResult<Wtf8Buf> {
         let class = zelf.class();
         let borrowed_name = class.name();
         let class_name = borrowed_name.deref();
-        let s = if zelf.inner.len() == 0 {
-            format!("{class_name}()")
-        } else if let Some(_guard) = ReprGuard::enter(vm, zelf.as_object()) {
-            let name = if class_name != "set" {
-                Some(class_name)
-            } else {
-                None
-            };
-            zelf.inner.repr(name, vm)?
+        if zelf.inner.len() == 0 {
+            return Ok(Wtf8Buf::from(format!("{class_name}()")));
+        }
+        if let Some(_guard) = ReprGuard::enter(vm, zelf.as_object()) {
+            let name = (class_name != "set").then_some(class_name);
+            zelf.inner.repr(name, vm)
         } else {
-            format!("{class_name}(...)")
-        };
-        Ok(s)
+            Ok(Wtf8Buf::from(format!("{class_name}(...)")))
+        }
     }
 }
 
@@ -1004,7 +996,7 @@ impl Constructor for PyFrozenSet {
 }
 
 #[pyclass(
-    flags(BASETYPE, _MATCH_SELF),
+    flags(BASETYPE, _MATCH_SELF, HAS_WEAKREF),
     with(
         Constructor,
         AsSequence,
@@ -1289,18 +1281,18 @@ impl AsNumber for PyFrozenSet {
 
 impl Representable for PyFrozenSet {
     #[inline]
-    fn repr_str(zelf: &crate::Py<Self>, vm: &VirtualMachine) -> PyResult<String> {
+    fn repr_wtf8(zelf: &crate::Py<Self>, vm: &VirtualMachine) -> PyResult<Wtf8Buf> {
         let inner = &zelf.inner;
         let class = zelf.class();
         let class_name = class.name();
-        let s = if inner.len() == 0 {
-            format!("{class_name}()")
-        } else if let Some(_guard) = ReprGuard::enter(vm, zelf.as_object()) {
-            inner.repr(Some(&class_name), vm)?
+        if inner.len() == 0 {
+            return Ok(Wtf8Buf::from(format!("{class_name}()")));
+        }
+        if let Some(_guard) = ReprGuard::enter(vm, zelf.as_object()) {
+            inner.repr(Some(&class_name), vm)
         } else {
-            format!("{class_name}(...)")
-        };
-        Ok(s)
+            Ok(Wtf8Buf::from(format!("{class_name}(...)")))
+        }
     }
 }
 
@@ -1390,7 +1382,7 @@ impl PySetIterator {
     ) -> PyResult<(PyObjectRef, (PyObjectRef,))> {
         let internal = zelf.internal.lock();
         Ok((
-            builtins_iter(vm).to_owned(),
+            builtins_iter(vm),
             (vm.ctx
                 .new_list(match &internal.status {
                     IterStatus::Exhausted => vec![],
@@ -1429,8 +1421,48 @@ impl IterNext for PySetIterator {
     }
 }
 
-pub fn init(context: &Context) {
+fn vectorcall_set(
+    zelf_obj: &PyObject,
+    args: Vec<PyObjectRef>,
+    nargs: usize,
+    kwnames: Option<&[PyObjectRef]>,
+    vm: &VirtualMachine,
+) -> PyResult {
+    let zelf: &Py<PyType> = zelf_obj.downcast_ref().unwrap();
+    let obj = PySet::default().into_ref_with_type(vm, zelf.to_owned())?;
+    let func_args = FuncArgs::from_vectorcall_owned(args, nargs, kwnames);
+    PySet::slot_init(obj.clone().into(), func_args, vm)?;
+    Ok(obj.into())
+}
+
+fn vectorcall_frozenset(
+    zelf_obj: &PyObject,
+    args: Vec<PyObjectRef>,
+    nargs: usize,
+    kwnames: Option<&[PyObjectRef]>,
+    vm: &VirtualMachine,
+) -> PyResult {
+    let zelf: &Py<PyType> = zelf_obj.downcast_ref().unwrap();
+    let func_args = FuncArgs::from_vectorcall_owned(args, nargs, kwnames);
+    (zelf.slots.new.load().unwrap())(zelf.to_owned(), func_args, vm)
+}
+
+pub fn init(context: &'static Context) {
     PySet::extend_class(context, context.types.set_type);
+    context
+        .types
+        .set_type
+        .slots
+        .vectorcall
+        .store(Some(vectorcall_set));
+
     PyFrozenSet::extend_class(context, context.types.frozenset_type);
+    context
+        .types
+        .frozenset_type
+        .slots
+        .vectorcall
+        .store(Some(vectorcall_frozenset));
+
     PySetIterator::extend_class(context, context.types.set_iterator_type);
 }
diff --git a/crates/vm/src/builtins/singletons.rs b/crates/vm/src/builtins/singletons.rs
index 169104efeb3..00d84dfabb6 100644
--- a/crates/vm/src/builtins/singletons.rs
+++ b/crates/vm/src/builtins/singletons.rs
@@ -2,10 +2,11 @@ use super::{PyStrRef, PyType, PyTypeRef};
 use crate::{
     Context, Py, PyObjectRef, PyPayload, PyResult, VirtualMachine,
     class::PyClassImpl,
+    common::hash::PyHash,
     convert::ToPyObject,
-    function::FuncArgs,
+    function::{FuncArgs, PyComparisonValue},
     protocol::PyNumberMethods,
-    types::{AsNumber, Constructor, Representable},
+    types::{AsNumber, Comparable, Constructor, Hashable, PyComparisonOp, Representable},
 };
 
 #[pyclass(module = false, name = "NoneType")]
@@ -49,7 +50,7 @@ impl Constructor for PyNone {
     }
 }
 
-#[pyclass(with(Constructor, AsNumber, Representable))]
+#[pyclass(with(Constructor, AsNumber, Comparable, Hashable, Representable))]
 impl PyNone {}
 
 impl Representable for PyNone {
@@ -74,6 +75,26 @@ impl AsNumber for PyNone {
     }
 }
 
+impl Comparable for PyNone {
+    fn cmp(
+        zelf: &Py<Self>,
+        other: &crate::PyObject,
+        op: PyComparisonOp,
+        _vm: &VirtualMachine,
+    ) -> PyResult<PyComparisonValue> {
+        Ok(op
+            .identical_optimization(zelf, other)
+            .map(PyComparisonValue::Implemented)
+            .unwrap_or(PyComparisonValue::NotImplemented))
+    }
+}
+
+impl Hashable for PyNone {
+    fn hash(_zelf: &Py<Self>, _vm: &VirtualMachine) -> PyResult<PyHash> {
+        Ok(0xFCA86420)
+    }
+}
+
 #[pyclass(module = false, name = "NotImplementedType")]
 #[derive(Debug)]
 pub struct PyNotImplemented;
@@ -98,7 +119,7 @@ impl Constructor for PyNotImplemented {
     }
 }
 
-#[pyclass(with(Constructor, AsNumber, Representable))]
+#[pyclass(with(Constructor, AsNumber, Representable), flags(IMMUTABLETYPE))]
 impl PyNotImplemented {
     #[pymethod]
     fn __reduce__(&self, vm: &VirtualMachine) -> PyStrRef {
@@ -110,9 +131,7 @@ impl AsNumber for PyNotImplemented {
     fn as_number() -> &'static PyNumberMethods {
         static AS_NUMBER: PyNumberMethods = PyNumberMethods {
             boolean: Some(|_number, vm| {
-                Err(vm.new_type_error(
-                    "NotImplemented should not be used in a boolean context".to_owned(),
-                ))
+                Err(vm.new_type_error("NotImplemented should not be used in a boolean context"))
             }),
             ..PyNumberMethods::NOT_IMPLEMENTED
         };
@@ -132,7 +151,7 @@ impl Representable for PyNotImplemented {
     }
 }
 
-pub fn init(context: &Context) {
+pub fn init(context: &'static Context) {
     PyNone::extend_class(context, context.types.none_type);
     PyNotImplemented::extend_class(context, context.types.not_implemented_type);
 }
diff --git a/crates/vm/src/builtins/slice.rs b/crates/vm/src/builtins/slice.rs
index 3aa23b0746c..9c6fa5b59fe 100644
--- a/crates/vm/src/builtins/slice.rs
+++ b/crates/vm/src/builtins/slice.rs
@@ -1,5 +1,9 @@
 // sliceobject.{h,c} in CPython
 // spell-checker:ignore sliceobject
+use core::cell::Cell;
+use core::ptr::NonNull;
+use rustpython_common::wtf8::{Wtf8Buf, wtf8_concat};
+
 use super::{PyGenericAlias, PyStrRef, PyTupleRef, PyType, PyTypeRef};
 use crate::{
     AsObject, Context, Py, PyObject, PyObjectRef, PyPayload, PyRef, PyResult, VirtualMachine,
@@ -13,7 +17,7 @@ use crate::{
 use malachite_bigint::{BigInt, ToBigInt};
 use num_traits::{One, Signed, Zero};
 
-#[pyclass(module = false, name = "slice", unhashable = true, traverse)]
+#[pyclass(module = false, name = "slice", unhashable = true, traverse = "manual")]
 #[derive(Debug)]
 pub struct PySlice {
     pub start: Option<PyObjectRef>,
@@ -21,11 +25,68 @@ pub struct PySlice {
     pub step: Option<PyObjectRef>,
 }
 
+// SAFETY: Traverse properly visits all owned PyObjectRefs
+unsafe impl crate::object::Traverse for PySlice {
+    fn traverse(&self, traverse_fn: &mut crate::object::TraverseFn<'_>) {
+        self.start.traverse(traverse_fn);
+        self.stop.traverse(traverse_fn);
+        self.step.traverse(traverse_fn);
+    }
+
+    fn clear(&mut self, out: &mut Vec<PyObjectRef>) {
+        if let Some(start) = self.start.take() {
+            out.push(start);
+        }
+        // stop is not Option, so it will be freed when payload is dropped
+        // (via drop_in_place on freelist pop, or Box::from_raw on dealloc)
+        if let Some(step) = self.step.take() {
+            out.push(step);
+        }
+    }
+}
+
+thread_local! {
+    static SLICE_FREELIST: Cell<crate::object::FreeList<PySlice>> = const { Cell::new(crate::object::FreeList::new()) };
+}
+
 impl PyPayload for PySlice {
+    const MAX_FREELIST: usize = 1;
+    const HAS_FREELIST: bool = true;
+
     #[inline]
     fn class(ctx: &Context) -> &'static Py<PyType> {
         ctx.types.slice_type
     }
+
+    #[inline]
+    unsafe fn freelist_push(obj: *mut PyObject) -> bool {
+        SLICE_FREELIST
+            .try_with(|fl| {
+                let mut list = fl.take();
+                let stored = if list.len() < Self::MAX_FREELIST {
+                    list.push(obj);
+                    true
+                } else {
+                    false
+                };
+                fl.set(list);
+                stored
+            })
+            .unwrap_or(false)
+    }
+
+    #[inline]
+    unsafe fn freelist_pop(_payload: &Self) -> Option<NonNull<PyObject>> {
+        SLICE_FREELIST
+            .try_with(|fl| {
+                let mut list = fl.take();
+                let result = list.pop().map(|p| unsafe { NonNull::new_unchecked(p) });
+                fl.set(list);
+                result
+            })
+            .ok()
+            .flatten()
+    }
 }
 
 #[pyclass(with(Comparable, Representable, Hashable))]
@@ -291,12 +352,20 @@ impl Comparable for PySlice {
 
 impl Representable for PySlice {
     #[inline]
-    fn repr_str(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<String> {
+    fn repr_wtf8(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<Wtf8Buf> {
         let start_repr = zelf.start_ref(vm).repr(vm)?;
         let stop_repr = zelf.stop.repr(vm)?;
         let step_repr = zelf.step_ref(vm).repr(vm)?;
 
-        Ok(format!("slice({start_repr}, {stop_repr}, {step_repr})"))
+        Ok(wtf8_concat!(
+            "slice(",
+            start_repr.as_wtf8(),
+            ", ",
+            stop_repr.as_wtf8(),
+            ", ",
+            step_repr.as_wtf8(),
+            ")"
+        ))
     }
 }
 
@@ -324,7 +393,7 @@ impl Constructor for PyEllipsis {
     }
 }
 
-#[pyclass(with(Constructor, Representable))]
+#[pyclass(with(Constructor, Representable), flags(IMMUTABLETYPE))]
 impl PyEllipsis {
     #[pymethod]
     fn __reduce__(&self, vm: &VirtualMachine) -> PyStrRef {
@@ -344,7 +413,7 @@ impl Representable for PyEllipsis {
     }
 }
 
-pub fn init(ctx: &Context) {
+pub fn init(ctx: &'static Context) {
     PySlice::extend_class(ctx, ctx.types.slice_type);
     PyEllipsis::extend_class(ctx, ctx.types.ellipsis_type);
 }
diff --git a/crates/vm/src/builtins/staticmethod.rs b/crates/vm/src/builtins/staticmethod.rs
index ac363415a9f..2554fa816aa 100644
--- a/crates/vm/src/builtins/staticmethod.rs
+++ b/crates/vm/src/builtins/staticmethod.rs
@@ -88,7 +88,7 @@ impl Initializer for PyStaticMethod {
 
 #[pyclass(
     with(Callable, GetDescriptor, Constructor, Initializer, Representable),
-    flags(BASETYPE, HAS_DICT)
+    flags(BASETYPE, HAS_DICT, HAS_WEAKREF)
 )]
 impl PyStaticMethod {
     #[pygetset]
@@ -182,11 +182,11 @@ impl Representable for PyStaticMethod {
             class
                 .__qualname__(vm)
                 .downcast_ref::<PyStr>()
-                .map(|n| n.as_str()),
+                .map(|n| n.as_wtf8()),
             class
                 .__module__(vm)
                 .downcast_ref::<PyStr>()
-                .map(|m| m.as_str()),
+                .map(|m| m.as_wtf8()),
         ) {
             (None, _) => Err(vm.new_type_error("Unknown qualified name")),
             (Some(qualname), Some(module)) if module != "builtins" => {
@@ -197,6 +197,6 @@ impl Representable for PyStaticMethod {
     }
 }
 
-pub fn init(context: &Context) {
+pub fn init(context: &'static Context) {
     PyStaticMethod::extend_class(context, context.types.staticmethod_type);
 }
diff --git a/crates/vm/src/builtins/str.rs b/crates/vm/src/builtins/str.rs
index e8ba6eb915e..74564278925 100644
--- a/crates/vm/src/builtins/str.rs
+++ b/crates/vm/src/builtins/str.rs
@@ -1,8 +1,12 @@
 use super::{
     PositionIterInternal, PyBytesRef, PyDict, PyTupleRef, PyType, PyTypeRef,
     int::{PyInt, PyIntRef},
-    iter::IterStatus::{self, Exhausted},
+    iter::{
+        IterStatus::{self, Exhausted},
+        builtins_iter,
+    },
 };
+use crate::common::lock::LazyLock;
 use crate::{
     AsObject, Context, Py, PyExact, PyObject, PyObjectRef, PyPayload, PyRef, PyRefExact, PyResult,
     TryFromBorrowedObject, VirtualMachine,
@@ -37,23 +41,23 @@ use rustpython_common::{
     hash,
     lock::PyMutex,
     str::DeduceStrKind,
-    wtf8::{CodePoint, Wtf8, Wtf8Buf, Wtf8Chunk},
+    wtf8::{CodePoint, Wtf8, Wtf8Buf, Wtf8Chunk, Wtf8Concat},
+};
+
+use icu_properties::props::{
+    BidiClass, BinaryProperty, EnumeratedProperty, GeneralCategory, XidContinue, XidStart,
 };
-use std::sync::LazyLock;
-use unic_ucd_bidi::BidiClass;
-use unic_ucd_category::GeneralCategory;
-use unic_ucd_ident::{is_xid_continue, is_xid_start};
 use unicode_casing::CharExt;
 
 impl<'a> TryFromBorrowedObject<'a> for String {
     fn try_from_borrowed_object(vm: &VirtualMachine, obj: &'a PyObject) -> PyResult<Self> {
-        obj.try_value_with(|pystr: &PyStr| Ok(pystr.as_str().to_owned()), vm)
+        obj.try_value_with(|pystr: &PyUtf8Str| Ok(pystr.as_str().to_owned()), vm)
     }
 }
 
 impl<'a> TryFromBorrowedObject<'a> for &'a str {
     fn try_from_borrowed_object(vm: &VirtualMachine, obj: &'a PyObject) -> PyResult<Self> {
-        let pystr: &Py<PyStr> = TryFromBorrowedObject::try_from_borrowed_object(vm, obj)?;
+        let pystr: &Py<PyUtf8Str> = TryFromBorrowedObject::try_from_borrowed_object(vm, obj)?;
         Ok(pystr.as_str())
     }
 }
@@ -87,21 +91,21 @@ impl fmt::Debug for PyStr {
 impl AsRef<str> for PyStr {
     #[track_caller] // <- can remove this once it doesn't panic
     fn as_ref(&self) -> &str {
-        self.as_str()
+        self.to_str().expect("str has surrogates")
     }
 }
 
 impl AsRef<str> for Py<PyStr> {
     #[track_caller] // <- can remove this once it doesn't panic
     fn as_ref(&self) -> &str {
-        self.as_str()
+        self.to_str().expect("str has surrogates")
     }
 }
 
 impl AsRef<str> for PyStrRef {
     #[track_caller] // <- can remove this once it doesn't panic
     fn as_ref(&self) -> &str {
-        self.as_str()
+        self.to_str().expect("str has surrogates")
     }
 }
 
@@ -123,6 +127,20 @@ impl AsRef<Wtf8> for PyStrRef {
     }
 }
 
+impl Wtf8Concat for PyStr {
+    #[inline]
+    fn fmt_wtf8(&self, buf: &mut Wtf8Buf) {
+        buf.push_wtf8(self.as_wtf8());
+    }
+}
+
+impl Wtf8Concat for Py<PyStr> {
+    #[inline]
+    fn fmt_wtf8(&self, buf: &mut Wtf8Buf) {
+        buf.push_wtf8(self.as_wtf8());
+    }
+}
+
 impl<'a> From<&'a AsciiStr> for PyStr {
     fn from(s: &'a AsciiStr) -> Self {
         s.to_owned().into()
@@ -232,7 +250,10 @@ pub trait AsPyStr<'a>
 where
     Self: 'a,
 {
-    #[allow(clippy::wrong_self_convention)] // to implement on refs
+    #[allow(
+        clippy::wrong_self_convention,
+        reason = "this trait is intentionally implemented for references"
+    )]
     fn as_pystr(self, ctx: &Context) -> &'a Py<PyStr>;
 }
 
@@ -243,6 +264,13 @@ impl<'a> AsPyStr<'a> for &'a Py<PyStr> {
     }
 }
 
+impl<'a> AsPyStr<'a> for &'a Py<PyUtf8Str> {
+    #[inline]
+    fn as_pystr(self, _ctx: &Context) -> &'a Py<PyStr> {
+        Py::<PyUtf8Str>::as_pystr(self)
+    }
+}
+
 impl<'a> AsPyStr<'a> for &'a PyStrRef {
     #[inline]
     fn as_pystr(self, _ctx: &Context) -> &'a Py<PyStr> {
@@ -250,6 +278,13 @@ impl<'a> AsPyStr<'a> for &'a PyStrRef {
     }
 }
 
+impl<'a> AsPyStr<'a> for &'a PyUtf8StrRef {
+    #[inline]
+    fn as_pystr(self, _ctx: &Context) -> &'a Py<PyStr> {
+        Py::<PyUtf8Str>::as_pystr(self)
+    }
+}
+
 impl AsPyStr<'static> for &'static str {
     #[inline]
     fn as_pystr(self, ctx: &Context) -> &'static Py<PyStr> {
@@ -264,6 +299,13 @@ impl<'a> AsPyStr<'a> for &'a PyStrInterned {
     }
 }
 
+impl<'a> AsPyStr<'a> for &'a PyUtf8StrInterned {
+    #[inline]
+    fn as_pystr(self, _ctx: &Context) -> &'a Py<PyStr> {
+        Py::<PyUtf8Str>::as_pystr(self)
+    }
+}
+
 #[pyclass(module = false, name = "str_iterator", traverse = "manual")]
 #[derive(Debug)]
 pub struct PyStrIterator {
@@ -301,10 +343,13 @@ impl PyStrIterator {
 
     #[pymethod]
     fn __reduce__(&self, vm: &VirtualMachine) -> PyTupleRef {
-        self.internal
-            .lock()
-            .0
-            .builtins_iter_reduce(|x| x.clone().into(), vm)
+        let func = builtins_iter(vm);
+        self.internal.lock().0.reduce(
+            func,
+            |x| x.clone().into(),
+            |vm| vm.ctx.empty_str.to_owned().into(),
+            vm,
+        )
     }
 }
 
@@ -341,9 +386,9 @@ pub struct StrArgs {
     #[pyarg(any, optional)]
     object: OptionalArg<PyObjectRef>,
     #[pyarg(any, optional)]
-    encoding: OptionalArg<PyStrRef>,
+    encoding: OptionalArg<PyUtf8StrRef>,
     #[pyarg(any, optional)]
-    errors: OptionalArg<PyStrRef>,
+    errors: OptionalArg<PyUtf8StrRef>,
 }
 
 impl Constructor for PyStr {
@@ -431,17 +476,20 @@ impl PyStr {
         self.data.as_wtf8().as_bytes()
     }
 
-    // FIXME: make this return an Option
-    #[inline]
-    #[track_caller] // <- can remove this once it doesn't panic
-    pub fn as_str(&self) -> &str {
-        self.data.as_str().expect("str has surrogates")
-    }
-
     pub fn to_str(&self) -> Option<&str> {
         self.data.as_str()
     }
 
+    /// Returns `&str`
+    ///
+    /// # Panic
+    /// If the string contains surrogates.
+    #[inline]
+    #[track_caller]
+    pub fn expect_str(&self) -> &str {
+        self.to_str().expect("PyStr contains surrogates")
+    }
+
     pub(crate) fn ensure_valid_utf8(&self, vm: &VirtualMachine) -> PyResult<()> {
         if self.is_utf8() {
             Ok(())
@@ -616,7 +664,6 @@ impl PyStr {
         self.data.is_empty()
     }
 
-    #[pymethod(name = "__len__")]
     #[inline]
     pub fn char_len(&self) -> usize {
         self.data.char_len()
@@ -651,14 +698,7 @@ impl PyStr {
         match self.as_str_kind() {
             PyKindStr::Ascii(s) => s.to_ascii_lowercase().into(),
             PyKindStr::Utf8(s) => s.to_lowercase().into(),
-            PyKindStr::Wtf8(w) => w
-                .chunks()
-                .map(|c| match c {
-                    Wtf8Chunk::Utf8(s) => s.to_lowercase().into(),
-                    Wtf8Chunk::Surrogate(c) => Wtf8Buf::from(c),
-                })
-                .collect::<Wtf8Buf>()
-                .into(),
+            PyKindStr::Wtf8(w) => w.to_lowercase().into(),
         }
     }
 
@@ -684,14 +724,7 @@ impl PyStr {
         match self.as_str_kind() {
             PyKindStr::Ascii(s) => s.to_ascii_uppercase().into(),
             PyKindStr::Utf8(s) => s.to_uppercase().into(),
-            PyKindStr::Wtf8(w) => w
-                .chunks()
-                .map(|c| match c {
-                    Wtf8Chunk::Utf8(s) => s.to_uppercase().into(),
-                    Wtf8Chunk::Surrogate(c) => Wtf8Buf::from(c),
-                })
-                .collect::<Wtf8Buf>()
-                .into(),
+            PyKindStr::Wtf8(w) => w.to_uppercase().into(),
         }
     }
 
@@ -723,12 +756,7 @@ impl PyStr {
                         Some(ch) => out.extend(ch.to_titlecase()),
                         None => out.push(ch),
                     }
-                    for chunk in chars.as_wtf8().chunks() {
-                        match chunk {
-                            Wtf8Chunk::Utf8(s) => out.push_str(&s.to_lowercase()),
-                            Wtf8Chunk::Surrogate(ch) => out.push(ch),
-                        }
-                    }
+                    out.push_wtf8(&chars.as_wtf8().to_lowercase());
                 }
                 out
             }
@@ -939,7 +967,9 @@ impl PyStr {
     #[pymethod]
     fn isdecimal(&self) -> bool {
         !self.data.is_empty()
-            && self.char_all(|c| GeneralCategory::of(c) == GeneralCategory::DecimalNumber)
+            && self.char_all(|c| {
+                matches!(GeneralCategory::for_char(c), GeneralCategory::DecimalNumber)
+            })
     }
 
     fn __mod__(&self, values: PyObjectRef, vm: &VirtualMachine) -> PyResult<Wtf8Buf> {
@@ -963,10 +993,9 @@ impl PyStr {
     #[pymethod]
     fn __format__(
         zelf: PyRef<PyStr>,
-        spec: PyStrRef,
+        spec: PyUtf8StrRef,
         vm: &VirtualMachine,
     ) -> PyResult<PyRef<PyStr>> {
-        let spec = spec.as_str();
         if spec.is_empty() {
             return if zelf.class().is(vm.ctx.types.str_type) {
                 Ok(zelf)
@@ -975,7 +1004,7 @@ impl PyStr {
             };
         }
         let zelf = zelf.try_into_utf8(vm)?;
-        let s = FormatSpec::parse(spec)
+        let s = FormatSpec::parse(spec.as_str())
             .and_then(|format_spec| {
                 format_spec.format_string(&CharLenStr(zelf.as_str(), zelf.char_len()))
             })
@@ -1016,11 +1045,11 @@ impl PyStr {
         let mut swapped_str = Wtf8Buf::with_capacity(self.data.len());
         for c_orig in self.as_wtf8().code_points() {
             let c = c_orig.to_char_lossy();
-            // to_uppercase returns an iterator, to_ascii_uppercase returns the char
+            // to_uppercase returns an iterator because case changes may be multiple bytes
             if c.is_lowercase() {
-                swapped_str.push_char(c.to_ascii_uppercase());
+                swapped_str.extend(c.to_uppercase());
             } else if c.is_uppercase() {
-                swapped_str.push_char(c.to_ascii_lowercase());
+                swapped_str.extend(c.to_lowercase());
             } else {
                 swapped_str.push(c_orig);
             }
@@ -1065,11 +1094,17 @@ impl PyStr {
 
     #[pymethod]
     fn isspace(&self) -> bool {
-        use unic_ucd_bidi::bidi_class::abbr_names::*;
         !self.data.is_empty()
             && self.char_all(|c| {
-                GeneralCategory::of(c) == GeneralCategory::SpaceSeparator
-                    || matches!(BidiClass::of(c), WS | B | S)
+                matches!(
+                    GeneralCategory::for_char(c),
+                    GeneralCategory::SpaceSeparator
+                ) || matches!(
+                    BidiClass::for_char(c),
+                    BidiClass::WhiteSpace
+                        | BidiClass::ParagraphSeparator
+                        | BidiClass::SegmentSeparator
+                )
             })
     }
 
@@ -1329,40 +1364,45 @@ impl PyStr {
     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));
+
+        let is_identifier_start = chars
+            .next()
+            .is_some_and(|c| c == '_' || XidStart::for_char(c));
+
         // a string is not an identifier if it has whitespace or starts with a number
-        is_identifier_start && chars.all(is_xid_continue)
+        is_identifier_start && chars.all(XidContinue::for_char)
     }
 
     // https://docs.python.org/3/library/stdtypes.html#str.translate
     #[pymethod]
-    fn translate(&self, table: PyObjectRef, vm: &VirtualMachine) -> PyResult<String> {
+    fn translate(&self, table: PyObjectRef, vm: &VirtualMachine) -> PyResult<Wtf8Buf> {
         vm.get_method_or_type_error(table.clone(), identifier!(vm, __getitem__), || {
             format!("'{}' object is not subscriptable", table.class().name())
         })?;
 
-        let mut translated = String::new();
-        for c in self.as_str().chars() {
-            match table.get_item(&*(c as u32).to_pyobject(vm), vm) {
+        let mut translated = Wtf8Buf::new();
+        for cp in self.as_wtf8().code_points() {
+            match table.get_item(&*cp.to_u32().to_pyobject(vm), vm) {
                 Ok(value) => {
                     if let Some(text) = value.downcast_ref::<Self>() {
-                        translated.push_str(text.as_str());
+                        translated.push_wtf8(text.as_wtf8());
                     } else if let Some(bigint) = value.downcast_ref::<PyInt>() {
-                        let ch = bigint
+                        let mapped = bigint
                             .as_bigint()
                             .to_u32()
-                            .and_then(core::char::from_u32)
+                            .and_then(CodePoint::from_u32)
                             .ok_or_else(|| {
                                 vm.new_value_error("character mapping must be in range(0x110000)")
                             })?;
-                        translated.push(ch);
+                        translated.push(mapped);
                     } else if !vm.is_none(&value) {
                         return Err(
                             vm.new_type_error("character mapping must return integer, None or str")
                         );
                     }
                 }
-                _ => translated.push(c),
+                Err(e) if e.fast_isinstance(vm.ctx.exceptions.key_error) => translated.push(cp),
+                Err(e) => return Err(e),
             }
         }
         Ok(translated)
@@ -1380,16 +1420,20 @@ impl PyStr {
             match dict_or_str.downcast::<Self>() {
                 Ok(from_str) => {
                     if to_str.len() == from_str.len() {
-                        for (c1, c2) in from_str.as_str().chars().zip(to_str.as_str().chars()) {
+                        for (c1, c2) in from_str
+                            .as_wtf8()
+                            .code_points()
+                            .zip(to_str.as_wtf8().code_points())
+                        {
                             new_dict.set_item(
-                                &*vm.new_pyobj(c1 as u32),
-                                vm.new_pyobj(c2 as u32),
+                                &*vm.new_pyobj(c1.to_u32()),
+                                vm.new_pyobj(c2.to_u32()),
                                 vm,
                             )?;
                         }
                         if let OptionalArg::Present(none_str) = none_str {
-                            for c in none_str.as_str().chars() {
-                                new_dict.set_item(&*vm.new_pyobj(c as u32), vm.ctx.none(), vm)?;
+                            for c in none_str.as_wtf8().code_points() {
+                                new_dict.set_item(&*vm.new_pyobj(c.to_u32()), vm.ctx.none(), vm)?;
                             }
                         }
                         Ok(new_dict.to_pyobject(vm))
@@ -1417,7 +1461,8 @@ impl PyStr {
                             )?;
                         } else if let Some(string) = key.downcast_ref::<Self>() {
                             if string.len() == 1 {
-                                let num_value = string.as_str().chars().next().unwrap() as u32;
+                                let num_value =
+                                    string.as_wtf8().code_points().next().unwrap().to_u32();
                                 new_dict.set_item(&*num_value.to_pyobject(vm), val, vm)?;
                             } else {
                                 return Err(vm.new_value_error(
@@ -1446,7 +1491,7 @@ impl PyStr {
 
     #[pymethod]
     fn __getnewargs__(zelf: PyRef<Self>, vm: &VirtualMachine) -> PyObjectRef {
-        (zelf.as_str(),).to_pyobject(vm)
+        (zelf.as_wtf8(),).to_pyobject(vm)
     }
 
     #[pymethod]
@@ -1467,14 +1512,25 @@ impl PyRef<PyStr> {
     }
 
     pub fn concat_in_place(&mut self, other: &Wtf8, vm: &VirtualMachine) {
-        // TODO: call [A]Rc::get_mut on the str to try to mutate the data in place
         if other.is_empty() {
             return;
         }
         let mut s = Wtf8Buf::with_capacity(self.byte_len() + other.len());
         s.push_wtf8(self.as_ref());
         s.push_wtf8(other);
-        *self = PyStr::from(s).into_ref(&vm.ctx);
+        if self.as_object().strong_count() == 1 {
+            // SAFETY: strong_count()==1 guarantees unique ownership of this PyStr.
+            // Mutating payload in place preserves semantics while avoiding PyObject reallocation.
+            unsafe {
+                let payload = self.payload() as *const PyStr as *mut PyStr;
+                (*payload).data = PyStr::from(s).data;
+                (*payload)
+                    .hash
+                    .store(hash::SENTINEL, atomic::Ordering::Relaxed);
+            }
+        } else {
+            *self = PyStr::from(s).into_ref(&vm.ctx);
+        }
     }
 
     pub fn try_into_utf8(self, vm: &VirtualMachine) -> PyResult<PyRef<PyUtf8Str>> {
@@ -1551,6 +1607,20 @@ impl AsMapping for PyStr {
 impl AsNumber for PyStr {
     fn as_number() -> &'static PyNumberMethods {
         static AS_NUMBER: PyNumberMethods = PyNumberMethods {
+            add: Some(|a, b, vm| {
+                let Some(a) = a.downcast_ref::<PyStr>() else {
+                    return Ok(vm.ctx.not_implemented());
+                };
+                let Some(b) = b.downcast_ref::<PyStr>() else {
+                    return Ok(vm.ctx.not_implemented());
+                };
+                let bytes = a.as_wtf8().py_add(b.as_wtf8());
+                Ok(unsafe {
+                    let kind = a.kind() | b.kind();
+                    PyStr::new_str_unchecked(bytes.into(), kind)
+                }
+                .to_pyobject(vm))
+            }),
             remainder: Some(|a, b, vm| {
                 if let Some(a) = a.downcast_ref::<PyStr>() {
                     a.__mod__(b.to_owned(), vm).to_pyresult(vm)
@@ -1592,20 +1662,21 @@ impl AsSequence for PyStr {
 #[derive(FromArgs)]
 struct EncodeArgs {
     #[pyarg(any, default)]
-    encoding: Option<PyStrRef>,
+    encoding: Option<PyUtf8StrRef>,
     #[pyarg(any, default)]
-    errors: Option<PyStrRef>,
+    errors: Option<PyUtf8StrRef>,
 }
 
 pub(crate) fn encode_string(
     s: PyStrRef,
-    encoding: Option<PyStrRef>,
-    errors: Option<PyStrRef>,
+    encoding: Option<PyUtf8StrRef>,
+    errors: Option<PyUtf8StrRef>,
     vm: &VirtualMachine,
 ) -> PyResult<PyBytesRef> {
-    let encoding = encoding
-        .as_ref()
-        .map_or(crate::codecs::DEFAULT_ENCODING, |s| s.as_str());
+    let encoding = match encoding.as_ref() {
+        None => crate::codecs::DEFAULT_ENCODING,
+        Some(s) => s.as_str(),
+    };
     vm.state.codec_registry.encode_text(s, encoding, errors, vm)
 }
 
@@ -1630,13 +1701,23 @@ impl ToPyObject for Wtf8Buf {
 
 impl ToPyObject for char {
     fn to_pyobject(self, vm: &VirtualMachine) -> PyObjectRef {
-        vm.ctx.new_str(self).into()
+        let cp = self as u32;
+        if cp <= u8::MAX as u32 {
+            vm.ctx.latin1_char(cp as u8).into()
+        } else {
+            vm.ctx.new_str(self).into()
+        }
     }
 }
 
 impl ToPyObject for CodePoint {
     fn to_pyobject(self, vm: &VirtualMachine) -> PyObjectRef {
-        vm.ctx.new_str(self).into()
+        let cp = self.to_u32();
+        if cp <= u8::MAX as u32 {
+            vm.ctx.latin1_char(cp as u8).into()
+        } else {
+            vm.ctx.new_str(self).into()
+        }
     }
 }
 
@@ -1678,7 +1759,7 @@ impl ToPyObject for AsciiString {
 
 impl ToPyObject for AsciiChar {
     fn to_pyobject(self, vm: &VirtualMachine) -> PyObjectRef {
-        vm.ctx.new_str(self).into()
+        vm.ctx.latin1_char(u8::from(self)).into()
     }
 }
 
@@ -1713,8 +1794,25 @@ struct ReplaceArgs {
     count: isize,
 }
 
-pub fn init(ctx: &Context) {
+fn vectorcall_str(
+    zelf_obj: &PyObject,
+    args: Vec<PyObjectRef>,
+    nargs: usize,
+    kwnames: Option<&[PyObjectRef]>,
+    vm: &VirtualMachine,
+) -> PyResult {
+    let zelf: &Py<PyType> = zelf_obj.downcast_ref().unwrap();
+    let func_args = FuncArgs::from_vectorcall_owned(args, nargs, kwnames);
+    (zelf.slots.new.load().unwrap())(zelf.to_owned(), func_args, vm)
+}
+
+pub fn init(ctx: &'static Context) {
     PyStr::extend_class(ctx, ctx.types.str_type);
+    ctx.types
+        .str_type
+        .slots
+        .vectorcall
+        .store(Some(vectorcall_str));
 
     PyStrIterator::extend_class(ctx, ctx.types.str_iterator_type);
 }
@@ -1859,14 +1957,16 @@ impl SliceableSequenceOp for PyStr {
 }
 
 impl AsRef<str> for PyRefExact<PyStr> {
+    #[track_caller]
     fn as_ref(&self) -> &str {
-        self.as_str()
+        self.to_str().expect("str has surrogates")
     }
 }
 
 impl AsRef<str> for PyExact<PyStr> {
+    #[track_caller]
     fn as_ref(&self) -> &str {
-        self.as_str()
+        self.to_str().expect("str has surrogates")
     }
 }
 
@@ -2024,7 +2124,7 @@ impl AsRef<Wtf8> for PyUtf8Str {
 impl AsRef<str> for PyUtf8Str {
     #[inline]
     fn as_ref(&self) -> &str {
-        self.0.as_str()
+        self.as_str()
     }
 }
 
@@ -2036,6 +2136,12 @@ impl PyUtf8Str {
         Self(PyStr::from(data))
     }
 
+    /// Returns the underlying WTF-8 slice (always valid UTF-8 for this type).
+    #[inline]
+    pub fn as_wtf8(&self) -> &Wtf8 {
+        self.0.as_wtf8()
+    }
+
     /// Returns the underlying string slice.
     pub fn as_str(&self) -> &str {
         debug_assert!(
@@ -2046,6 +2152,11 @@ impl PyUtf8Str {
         unsafe { self.0.to_str().unwrap_unchecked() }
     }
 
+    #[inline]
+    pub fn as_bytes(&self) -> &[u8] {
+        self.as_str().as_bytes()
+    }
+
     #[inline]
     pub fn byte_len(&self) -> usize {
         self.0.byte_len()
@@ -2070,6 +2181,29 @@ impl Py<PyUtf8Str> {
             &*(self as *const Self as *const Py<PyStr>)
         }
     }
+
+    /// Returns the underlying `&str`.
+    #[inline]
+    pub fn as_str(&self) -> &str {
+        self.as_pystr().to_str().unwrap_or_else(|| {
+            debug_assert!(false, "PyUtf8Str invariant violated");
+            // Safety: PyUtf8Str guarantees valid UTF-8
+            unsafe { core::hint::unreachable_unchecked() }
+        })
+    }
+}
+
+impl PyRef<PyUtf8Str> {
+    /// Convert to PyStrRef. Safe because PyUtf8Str is a subtype of PyStr.
+    pub fn into_wtf8(self) -> PyStrRef {
+        unsafe { mem::transmute::<Self, PyStrRef>(self) }
+    }
+}
+
+impl From<PyRef<PyUtf8Str>> for PyRef<PyStr> {
+    fn from(s: PyRef<PyUtf8Str>) -> Self {
+        s.into_wtf8()
+    }
 }
 
 impl PartialEq for PyUtf8Str {
@@ -2445,10 +2579,54 @@ impl AsRef<str> for PyStrInterned {
     }
 }
 
+/// Interned PyUtf8Str — guaranteed UTF-8 at type level.
+/// Same layout as `PyStrInterned` due to `#[repr(transparent)]` on both
+/// `PyInterned<T>` and `PyUtf8Str`.
+pub type PyUtf8StrInterned = PyInterned<PyUtf8Str>;
+
+impl PyUtf8StrInterned {
+    /// Returns the underlying `&str`.
+    #[inline]
+    pub fn as_str(&self) -> &str {
+        Py::<PyUtf8Str>::as_str(self)
+    }
+
+    /// View as `PyStrInterned` (widening: UTF-8 → WTF-8).
+    #[inline]
+    pub fn as_interned_str(&self) -> &PyStrInterned {
+        // Safety: PyUtf8Str is #[repr(transparent)] over PyStr,
+        // so PyInterned<PyUtf8Str> has the same layout as PyInterned<PyStr>.
+        unsafe { &*(self as *const Self as *const PyStrInterned) }
+    }
+
+    /// Narrow a `PyStrInterned` to `PyUtf8StrInterned`.
+    ///
+    /// # Safety
+    /// The caller must ensure that the interned string is valid UTF-8.
+    #[inline]
+    pub unsafe fn from_str_interned_unchecked(s: &PyStrInterned) -> &Self {
+        unsafe { &*(s as *const PyStrInterned as *const Self) }
+    }
+}
+
+impl core::fmt::Display for PyUtf8StrInterned {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        f.write_str(self.as_str())
+    }
+}
+
+impl AsRef<str> for PyUtf8StrInterned {
+    #[inline(always)]
+    fn as_ref(&self) -> &str {
+        self.as_str()
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
     use crate::Interpreter;
+    use rustpython_common::wtf8::Wtf8Buf;
 
     #[test]
     fn str_title() {
@@ -2516,7 +2694,7 @@ mod tests {
                     .unwrap();
             let text = PyStr::from("abc");
             let translated = text.translate(translated, vm).unwrap();
-            assert_eq!(translated, "🎅xda".to_owned());
+            assert_eq!(translated, Wtf8Buf::from("🎅xda"));
             let translated = text.translate(vm.ctx.new_int(3).into(), vm);
             assert_eq!("TypeError", &*translated.unwrap_err().class().name(),);
         })
diff --git a/crates/vm/src/builtins/super.rs b/crates/vm/src/builtins/super.rs
index b7bc3004332..88998dc8c8a 100644
--- a/crates/vm/src/builtins/super.rs
+++ b/crates/vm/src/builtins/super.rs
@@ -7,6 +7,7 @@ See also [CPython source code.](https://github.com/python/cpython/blob/50b48572d
 use super::{PyStr, PyType, PyTypeRef};
 use crate::{
     AsObject, Context, Py, PyObjectRef, PyPayload, PyRef, PyResult, VirtualMachine,
+    builtins::function::PyCell,
     class::PyClassImpl,
     common::lock::PyRwLock,
     function::{FuncArgs, IntoFuncArgs, OptionalArg},
@@ -85,27 +86,34 @@ impl Initializer for PySuper {
             if frame.code.arg_count == 0 {
                 return Err(vm.new_runtime_error("super(): no arguments"));
             }
-            let obj = frame.fastlocals.lock()[0]
+            // SAFETY: Frame is current and not concurrently mutated.
+            use rustpython_compiler_core::bytecode::CO_FAST_CELL;
+            let obj = unsafe { frame.fastlocals() }[0]
                 .clone()
-                .or_else(|| {
-                    if let Some(cell2arg) = frame.code.cell2arg.as_deref() {
-                        cell2arg[..frame.code.cellvars.len()]
-                            .iter()
-                            .enumerate()
-                            .find(|(_, arg_idx)| **arg_idx == 0)
-                            .and_then(|(cell_idx, _)| frame.cells_frees[cell_idx].get())
+                .and_then(|val| {
+                    // If slot 0 is a merged cell (LOCAL|CELL), extract value from cell
+                    if frame
+                        .code
+                        .localspluskinds
+                        .first()
+                        .is_some_and(|&k| k & CO_FAST_CELL != 0)
+                    {
+                        val.downcast_ref::<PyCell>().and_then(|c| c.get())
                     } else {
-                        None
+                        Some(val)
                     }
                 })
                 .ok_or_else(|| vm.new_runtime_error("super(): arg[0] deleted"))?;
 
             let mut typ = None;
+            // Search for __class__ in freevars using localspluskinds
+            let nlocalsplus = frame.code.localspluskinds.len();
+            let nfrees = frame.code.freevars.len();
+            let free_start = nlocalsplus - nfrees;
             for (i, var) in frame.code.freevars.iter().enumerate() {
                 if var.as_bytes() == b"__class__" {
-                    let i = frame.code.cellvars.len() + i;
-                    let class = frame.cells_frees[i]
-                        .get()
+                    let class = frame
+                        .get_cell_contents(free_start + i)
                         .ok_or_else(|| vm.new_runtime_error("super(): empty __class__ cell"))?;
                     typ = Some(class.downcast().map_err(|o| {
                         vm.new_type_error(format!(
@@ -268,7 +276,7 @@ fn super_check(ty: PyTypeRef, obj: PyObjectRef, vm: &VirtualMachine) -> PyResult
     )))
 }
 
-pub fn init(context: &Context) {
+pub fn init(context: &'static Context) {
     let super_type = &context.types.super_type;
     PySuper::extend_class(context, super_type);
 
diff --git a/crates/vm/src/builtins/template.rs b/crates/vm/src/builtins/template.rs
index 2433c9082e5..3f03f9a227a 100644
--- a/crates/vm/src/builtins/template.rs
+++ b/crates/vm/src/builtins/template.rs
@@ -1,8 +1,12 @@
-use super::{PyStr, PyTupleRef, PyType};
+use super::{
+    PyStr, PyTupleRef, PyType, PyTypeRef, genericalias::PyGenericAlias,
+    interpolation::PyInterpolation,
+};
 use crate::{
     AsObject, Context, Py, PyObject, PyObjectRef, PyPayload, PyRef, PyResult, VirtualMachine,
     atomic_func,
     class::PyClassImpl,
+    common::lock::LazyLock,
     function::{FuncArgs, PyComparisonValue},
     protocol::{PyIterReturn, PySequenceMethods},
     types::{
@@ -10,9 +14,7 @@ use crate::{
         SelfIter,
     },
 };
-use std::sync::LazyLock;
-
-use super::interpolation::PyInterpolation;
+use rustpython_common::wtf8::{Wtf8Buf, wtf8_concat};
 
 /// Template object for t-strings (PEP 750).
 ///
@@ -58,8 +60,9 @@ impl Constructor for PyTemplate {
                     // 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();
+                        let mut buf = last_str.as_wtf8().to_owned();
+                        buf.push_wtf8(s.as_wtf8());
+                        *last = vm.ctx.new_str(buf).into();
                     }
                 } else {
                     strings.push(s.into());
@@ -143,18 +146,22 @@ impl PyTemplate {
         }
 
         // Concatenate last string of self with first string of other
-        let last_self = self
+        let mut buf = Wtf8Buf::new();
+        if let Some(s) = 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
+            .and_then(|s| s.downcast_ref::<PyStr>())
+        {
+            buf.push_wtf8(s.as_wtf8());
+        }
+        if let Some(s) = 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());
+            .and_then(|s| s.downcast_ref::<PyStr>())
+        {
+            buf.push_wtf8(s.as_wtf8());
+        }
+        new_strings.push(vm.ctx.new_str(buf).into());
 
         // Add remaining strings from other (skip first)
         for i in 1..other.strings.len() {
@@ -178,6 +185,11 @@ impl PyTemplate {
         self.concat(&other, vm)
     }
 
+    #[pyclassmethod]
+    fn __class_getitem__(cls: PyTypeRef, args: PyObjectRef, vm: &VirtualMachine) -> PyGenericAlias {
+        PyGenericAlias::from_args(cls, args, vm)
+    }
+
     #[pymethod]
     fn __reduce__(&self, vm: &VirtualMachine) -> PyResult<PyTupleRef> {
         // Import string.templatelib._template_unpickle
@@ -238,31 +250,16 @@ impl Iterable for PyTemplate {
 
 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(", ")))
+    fn repr_wtf8(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<Wtf8Buf> {
+        let strings_repr = zelf.strings.as_object().repr(vm)?;
+        let interp_repr = zelf.interpolations.as_object().repr(vm)?;
+        Ok(wtf8_concat!(
+            "Template(strings=",
+            strings_repr.as_wtf8(),
+            ", interpolations=",
+            interp_repr.as_wtf8(),
+            ')',
+        ))
     }
 }
 
@@ -271,8 +268,8 @@ impl Representable for PyTemplate {
 #[derive(Debug)]
 pub struct PyTemplateIter {
     template: PyRef<PyTemplate>,
-    index: std::sync::atomic::AtomicUsize,
-    from_strings: std::sync::atomic::AtomicBool,
+    index: core::sync::atomic::AtomicUsize,
+    from_strings: core::sync::atomic::AtomicBool,
 }
 
 impl PyPayload for PyTemplateIter {
@@ -286,8 +283,8 @@ 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),
+            index: core::sync::atomic::AtomicUsize::new(0),
+            from_strings: core::sync::atomic::AtomicBool::new(true),
         }
     }
 }
@@ -299,7 +296,7 @@ impl SelfIter for PyTemplateIter {}
 
 impl IterNext for PyTemplateIter {
     fn next(zelf: &Py<Self>, _vm: &VirtualMachine) -> PyResult<PyIterReturn> {
-        use std::sync::atomic::Ordering;
+        use core::sync::atomic::Ordering;
 
         loop {
             let from_strings = zelf.from_strings.load(Ordering::SeqCst);
@@ -312,7 +309,7 @@ impl IterNext for PyTemplateIter {
 
                     // Skip empty strings
                     if let Some(s) = item.downcast_ref::<PyStr>()
-                        && s.as_str().is_empty()
+                        && s.as_wtf8().is_empty()
                     {
                         continue;
                     }
@@ -332,7 +329,7 @@ impl IterNext for PyTemplateIter {
     }
 }
 
-pub fn init(context: &Context) {
+pub fn init(context: &'static Context) {
     PyTemplate::extend_class(context, context.types.template_type);
     PyTemplateIter::extend_class(context, context.types.template_iter_type);
 }
diff --git a/crates/vm/src/builtins/traceback.rs b/crates/vm/src/builtins/traceback.rs
index 675025cd6b6..c6eac4e87e7 100644
--- a/crates/vm/src/builtins/traceback.rs
+++ b/crates/vm/src/builtins/traceback.rs
@@ -1,7 +1,7 @@
-use super::PyType;
+use super::{PyList, PyType};
 use crate::{
     AsObject, Context, Py, PyPayload, PyRef, PyResult, VirtualMachine, class::PyClassImpl,
-    frame::FrameRef, types::Constructor,
+    frame::FrameRef, function::PySetterValue, types::Constructor,
 };
 use rustpython_common::lock::PyMutex;
 use rustpython_compiler_core::OneIndexed;
@@ -62,17 +62,33 @@ impl PyTraceback {
         self.next.lock().as_ref().cloned()
     }
 
+    #[pymethod]
+    fn __dir__(&self, vm: &VirtualMachine) -> PyList {
+        PyList::from(
+            ["tb_frame", "tb_next", "tb_lasti", "tb_lineno"]
+                .iter()
+                .map(|&s| vm.ctx.new_str(s).into())
+                .collect::<Vec<_>>(),
+        )
+    }
+
     #[pygetset(setter)]
     fn set_tb_next(
         zelf: &Py<Self>,
-        value: Option<PyRef<Self>>,
+        value: PySetterValue<Option<PyRef<Self>>>,
         vm: &VirtualMachine,
     ) -> PyResult<()> {
+        let value = match value {
+            PySetterValue::Assign(v) => v,
+            PySetterValue::Delete => {
+                return Err(vm.new_type_error("can't delete tb_next attribute"));
+            }
+        };
         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()));
+                    return Err(vm.new_value_error("traceback loop detected"));
                 }
                 let next = cursor.next.lock().clone();
                 match next {
@@ -91,8 +107,8 @@ impl Constructor for PyTraceback {
 
     fn py_new(_cls: &Py<PyType>, args: Self::Args, vm: &VirtualMachine) -> PyResult<Self> {
         let (next, frame, lasti, lineno) = args;
-        let lineno = OneIndexed::new(lineno)
-            .ok_or_else(|| vm.new_value_error("lineno must be positive".to_owned()))?;
+        let lineno =
+            OneIndexed::new(lineno).ok_or_else(|| vm.new_value_error("lineno must be positive"))?;
         Ok(Self::new(next, frame, lasti, lineno))
     }
 }
@@ -103,7 +119,7 @@ impl PyTracebackRef {
     }
 }
 
-pub fn init(context: &Context) {
+pub fn init(context: &'static Context) {
     PyTraceback::extend_class(context, context.types.traceback_type);
 }
 
@@ -115,7 +131,7 @@ impl serde::Serialize for PyTraceback {
         let mut struc = s.serialize_struct("PyTraceback", 3)?;
         struc.serialize_field("name", self.frame.code.obj_name.as_str())?;
         struc.serialize_field("lineno", &self.lineno.get())?;
-        struc.serialize_field("filename", self.frame.code.source_path.as_str())?;
+        struc.serialize_field("filename", self.frame.code.source_path().as_str())?;
         struc.end()
     }
 }
diff --git a/crates/vm/src/builtins/tuple.rs b/crates/vm/src/builtins/tuple.rs
index ba296686c73..b2c2fabc540 100644
--- a/crates/vm/src/builtins/tuple.rs
+++ b/crates/vm/src/builtins/tuple.rs
@@ -1,7 +1,11 @@
-use super::{PositionIterInternal, PyGenericAlias, PyStrRef, PyType, PyTypeRef};
+use super::{
+    PositionIterInternal, PyGenericAlias, PyStrRef, PyType, PyTypeRef, iter::builtins_iter,
+};
+use crate::common::lock::LazyLock;
 use crate::common::{
     hash::{PyHash, PyUHash},
     lock::PyMutex,
+    wtf8::wtf8_concat,
 };
 use crate::object::{Traverse, TraverseFn};
 use crate::{
@@ -23,7 +27,8 @@ use crate::{
     vm::VirtualMachine,
 };
 use alloc::fmt;
-use std::sync::LazyLock;
+use core::cell::Cell;
+use core::ptr::NonNull;
 
 #[pyclass(module = false, name = "tuple", traverse = "manual")]
 pub struct PyTuple<R = PyObjectRef> {
@@ -45,16 +50,102 @@ unsafe impl Traverse for PyTuple {
     }
 
     fn clear(&mut self, out: &mut Vec<PyObjectRef>) {
-        let elements = std::mem::take(&mut self.elements);
+        let elements = core::mem::take(&mut self.elements);
         out.extend(elements.into_vec());
     }
 }
 
+// spell-checker:ignore MAXSAVESIZE
+/// Per-size freelist storage for tuples, matching tuples[PyTuple_MAXSAVESIZE].
+/// Each bucket caches tuples of a specific element count (index = len - 1).
+struct TupleFreeList {
+    buckets: [Vec<NonNull<PyObject>>; Self::MAX_SAVE_SIZE],
+}
+
+impl TupleFreeList {
+    /// Largest tuple size to cache on the freelist (sizes 1..=20).
+    const MAX_SAVE_SIZE: usize = 20;
+    const fn new() -> Self {
+        Self {
+            buckets: [const { Vec::new() }; Self::MAX_SAVE_SIZE],
+        }
+    }
+}
+
+impl Default for TupleFreeList {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl Drop for TupleFreeList {
+    fn drop(&mut self) {
+        // Same safety pattern as FreeList<T>::drop — free raw allocation
+        // without running payload destructors to avoid TLS-after-destruction panics.
+        let layout = crate::object::pyinner_layout::<PyTuple>();
+        for bucket in &mut self.buckets {
+            for ptr in bucket.drain(..) {
+                unsafe {
+                    alloc::alloc::dealloc(ptr.as_ptr() as *mut u8, layout);
+                }
+            }
+        }
+    }
+}
+
+thread_local! {
+    static TUPLE_FREELIST: Cell<TupleFreeList> = const { Cell::new(TupleFreeList::new()) };
+}
+
 impl PyPayload for PyTuple {
+    const MAX_FREELIST: usize = 2000;
+    const HAS_FREELIST: bool = true;
+
     #[inline]
     fn class(ctx: &Context) -> &'static Py<PyType> {
         ctx.types.tuple_type
     }
+
+    #[inline]
+    unsafe fn freelist_push(obj: *mut PyObject) -> bool {
+        let len = unsafe { &*(obj as *const crate::Py<PyTuple>) }
+            .elements
+            .len();
+        if len == 0 || len > TupleFreeList::MAX_SAVE_SIZE {
+            return false;
+        }
+        TUPLE_FREELIST
+            .try_with(|fl| {
+                let mut list = fl.take();
+                let bucket = &mut list.buckets[len - 1];
+                let stored = if bucket.len() < Self::MAX_FREELIST {
+                    bucket.push(unsafe { NonNull::new_unchecked(obj) });
+                    true
+                } else {
+                    false
+                };
+                fl.set(list);
+                stored
+            })
+            .unwrap_or(false)
+    }
+
+    #[inline]
+    unsafe fn freelist_pop(payload: &Self) -> Option<NonNull<PyObject>> {
+        let len = payload.elements.len();
+        if len == 0 || len > TupleFreeList::MAX_SAVE_SIZE {
+            return None;
+        }
+        TUPLE_FREELIST
+            .try_with(|fl| {
+                let mut list = fl.take();
+                let result = list.buckets[len - 1].pop();
+                fl.set(list);
+                result
+            })
+            .ok()
+            .flatten()
+    }
 }
 
 pub trait IntoPyTuple {
@@ -321,7 +412,13 @@ impl PyTuple {
 
     fn _getitem(&self, needle: &PyObject, vm: &VirtualMachine) -> PyResult {
         match SequenceIndex::try_from_borrowed_object(vm, needle, "tuple")? {
-            SequenceIndex::Int(i) => self.elements.getitem_by_index(vm, i),
+            SequenceIndex::Int(i) => {
+                let index = self
+                    .elements
+                    .wrap_index(i)
+                    .ok_or_else(|| vm.new_index_error("tuple index out of range"))?;
+                Ok(self.elements[index].clone())
+            }
             SequenceIndex::Slice(slice) => self
                 .elements
                 .getitem_by_slice(vm, slice)
@@ -479,7 +576,7 @@ impl Representable for PyTuple {
             vm.ctx.intern_str("()").to_owned()
         } else if let Some(_guard) = ReprGuard::enter(vm, zelf.as_object()) {
             let s = if zelf.len() == 1 {
-                format!("({},)", zelf.elements[0].repr(vm)?)
+                wtf8_concat!("(", zelf.elements[0].repr(vm)?.as_wtf8(), ",)")
             } else {
                 collection_repr(None, "(", ")", zelf.elements.iter(), vm)?
             };
@@ -559,9 +656,31 @@ impl PyTupleIterator {
 
     #[pymethod]
     fn __reduce__(&self, vm: &VirtualMachine) -> PyTupleRef {
+        let func = builtins_iter(vm);
+        self.internal.lock().reduce(
+            func,
+            |x| x.clone().into(),
+            |vm| vm.ctx.empty_tuple.clone().into(),
+            vm,
+        )
+    }
+}
+
+impl PyTupleIterator {
+    /// Fast path for FOR_ITER specialization.
+    pub(crate) fn fast_next(&self) -> Option<PyObjectRef> {
         self.internal
             .lock()
-            .builtins_iter_reduce(|x| x.clone().into(), vm)
+            .next(|tuple, pos| {
+                Ok(PyIterReturn::from_result(
+                    tuple.get(pos).cloned().ok_or(None),
+                ))
+            })
+            .ok()
+            .and_then(|r| match r {
+                PyIterReturn::Return(v) => Some(v),
+                PyIterReturn::StopIteration(_) => None,
+            })
     }
 }
 
@@ -576,9 +695,29 @@ impl IterNext for PyTupleIterator {
     }
 }
 
-pub(crate) fn init(context: &Context) {
+fn vectorcall_tuple(
+    zelf_obj: &PyObject,
+    args: Vec<PyObjectRef>,
+    nargs: usize,
+    kwnames: Option<&[PyObjectRef]>,
+    vm: &VirtualMachine,
+) -> PyResult {
+    let zelf: &Py<PyType> = zelf_obj.downcast_ref().unwrap();
+    let func_args = FuncArgs::from_vectorcall_owned(args, nargs, kwnames);
+    // Use the type's own slot_new rather than calling PyTuple::slot_new directly,
+    // so Rust-level subclasses (e.g. struct sequences) get their custom slot_new called.
+    (zelf.slots.new.load().unwrap())(zelf.to_owned(), func_args, vm)
+}
+
+pub(crate) fn init(context: &'static Context) {
     PyTuple::extend_class(context, context.types.tuple_type);
     PyTupleIterator::extend_class(context, context.types.tuple_iterator_type);
+    context
+        .types
+        .tuple_type
+        .slots
+        .vectorcall
+        .store(Some(vectorcall_tuple));
 }
 
 pub(super) fn tuple_hash(elements: &[PyObjectRef], vm: &VirtualMachine) -> PyResult<PyHash> {
diff --git a/crates/vm/src/builtins/type.rs b/crates/vm/src/builtins/type.rs
index 3fe396932ce..64801a1de5c 100644
--- a/crates/vm/src/builtins/type.rs
+++ b/crates/vm/src/builtins/type.rs
@@ -1,24 +1,24 @@
 use super::{
     PyClassMethod, PyDictRef, PyList, PyStaticMethod, PyStr, PyStrInterned, PyStrRef, PyTupleRef,
-    PyWeak, mappingproxy::PyMappingProxy, object, union_,
+    PyUtf8StrRef, PyWeak, mappingproxy::PyMappingProxy, object, union_,
 };
 use crate::{
-    AsObject, Context, Py, PyObject, PyObjectRef, PyPayload, PyRef, PyResult, TryFromObject,
-    VirtualMachine,
+    AsObject, Context, Py, PyAtomicRef, PyObject, PyObjectRef, PyPayload, PyRef, PyResult,
+    TryFromObject, VirtualMachine,
     builtins::{
         PyBaseExceptionRef,
         descriptor::{
             MemberGetter, MemberKind, MemberSetter, PyDescriptorOwned, PyMemberDef,
             PyMemberDescriptor,
         },
-        function::PyCellRef,
+        function::{PyCellRef, PyFunction},
         tuple::{IntoPyTuple, PyTuple},
     },
     class::{PyClassImpl, StaticType},
     common::{
         ascii,
         borrow::BorrowedValue,
-        lock::{PyRwLock, PyRwLockReadGuard},
+        lock::{PyMutex, PyRwLock, PyRwLockReadGuard},
     },
     function::{FuncArgs, KwArgs, OptionalArg, PyMethodDef, PySetterValue},
     object::{Traverse, TraverseFn},
@@ -28,10 +28,18 @@ use crate::{
         Representable, SLOT_DEFS, SetAttr, TypeDataRef, TypeDataRefMut, TypeDataSlot,
     },
 };
-use core::{any::Any, borrow::Borrow, ops::Deref, pin::Pin, ptr::NonNull};
+use core::{
+    any::Any,
+    borrow::Borrow,
+    ops::Deref,
+    pin::Pin,
+    ptr::NonNull,
+    sync::atomic::{AtomicBool, AtomicPtr, AtomicU32, Ordering},
+};
 use indexmap::{IndexMap, map::Entry};
 use itertools::Itertools;
 use num_traits::ToPrimitive;
+use rustpython_common::wtf8::Wtf8;
 use std::collections::HashSet;
 
 #[pyclass(module = false, name = "type", traverse = "manual")]
@@ -43,29 +51,317 @@ pub struct PyType {
     pub attributes: PyRwLock<PyAttributes>,
     pub slots: PyTypeSlots,
     pub heaptype_ext: Option<Pin<Box<HeapTypeExt>>>,
+    /// Type version tag for inline caching. 0 means unassigned/invalidated.
+    pub tp_version_tag: AtomicU32,
+}
+
+/// Monotonic counter for type version tags. Once it reaches `u32::MAX`,
+/// `assign_version_tag()` returns 0 permanently, disabling new inline-cache
+/// entries but not invalidating correctness (cache misses fall back to the
+/// generic path).
+static NEXT_TYPE_VERSION: AtomicU32 = AtomicU32::new(1);
+
+// Method cache (type_cache / MCACHE): direct-mapped cache keyed by
+// (tp_version_tag, interned_name_ptr).
+//
+// Uses a lock-free SeqLock pattern for the read/write protocol:
+//  - Readers validate sequence/version/name before and after the value read.
+//  - Writers bracket updates with sequence odd/even transitions.
+// No mutex needed on the hot path (cache hit).
+
+const TYPE_CACHE_SIZE_EXP: u32 = 12;
+const TYPE_CACHE_SIZE: usize = 1 << TYPE_CACHE_SIZE_EXP;
+const TYPE_CACHE_MASK: usize = TYPE_CACHE_SIZE - 1;
+
+struct TypeCacheEntry {
+    /// Sequence lock (odd = write in progress, even = quiescent).
+    sequence: AtomicU32,
+    /// tp_version_tag at cache time. 0 = empty/invalid.
+    version: AtomicU32,
+    /// Interned attribute name pointer (pointer equality check).
+    name: AtomicPtr<PyStrInterned>,
+    /// Cached lookup result as raw pointer. null = empty.
+    /// The cache holds a **borrowed** pointer (no refcount increment).
+    /// Safety: `type_cache_clear()` nullifies all entries during GC,
+    /// and `type_cache_clear_version()` nullifies entries when a type
+    /// is modified — both before the source dict entry is removed.
+    /// Types are always part of reference cycles (via `mro` self-reference)
+    /// so they are always collected by the cyclic GC (never refcount-freed).
+    value: AtomicPtr<PyObject>,
+}
+
+// SAFETY: TypeCacheEntry is thread-safe:
+// - All fields use atomic operations
+// - Value pointer is valid as long as version matches (SeqLock pattern)
+// - PyObjectRef uses atomic reference counting
+unsafe impl Send for TypeCacheEntry {}
+unsafe impl Sync for TypeCacheEntry {}
+
+impl TypeCacheEntry {
+    fn new() -> Self {
+        Self {
+            sequence: AtomicU32::new(0),
+            version: AtomicU32::new(0),
+            name: AtomicPtr::new(core::ptr::null_mut()),
+            value: AtomicPtr::new(core::ptr::null_mut()),
+        }
+    }
+
+    #[inline]
+    fn begin_write(&self) {
+        let mut seq = self.sequence.load(Ordering::Acquire);
+        loop {
+            while (seq & 1) != 0 {
+                core::hint::spin_loop();
+                seq = self.sequence.load(Ordering::Acquire);
+            }
+            match self.sequence.compare_exchange_weak(
+                seq,
+                seq.wrapping_add(1),
+                Ordering::AcqRel,
+                Ordering::Acquire,
+            ) {
+                Ok(_) => {
+                    core::sync::atomic::fence(Ordering::Release);
+                    break;
+                }
+                Err(observed) => {
+                    core::hint::spin_loop();
+                    seq = observed;
+                }
+            }
+        }
+    }
+
+    #[inline]
+    fn end_write(&self) {
+        self.sequence.fetch_add(1, Ordering::Release);
+    }
+
+    #[inline]
+    fn begin_read(&self) -> u32 {
+        let mut sequence = self.sequence.load(Ordering::Acquire);
+        while (sequence & 1) != 0 {
+            core::hint::spin_loop();
+            sequence = self.sequence.load(Ordering::Acquire);
+        }
+        sequence
+    }
+
+    #[inline]
+    fn end_read(&self, previous: u32) -> bool {
+        core::sync::atomic::fence(Ordering::Acquire);
+        self.sequence.load(Ordering::Relaxed) == previous
+    }
+
+    /// Null out the cached value pointer.
+    /// Caller must ensure no concurrent reads can observe this entry
+    /// (version should be set to 0 first).
+    fn clear_value(&self) {
+        self.value.store(core::ptr::null_mut(), Ordering::Relaxed);
+    }
+}
+
+// std::sync::LazyLock is used here (not crate::common::lock::LazyLock)
+// because TYPE_CACHE is a global shared across test threads. The common
+// LazyLock delegates to LazyCell in non-threading mode, which is !Sync.
+static TYPE_CACHE: std::sync::LazyLock<Box<[TypeCacheEntry]>> = std::sync::LazyLock::new(|| {
+    (0..TYPE_CACHE_SIZE)
+        .map(|_| TypeCacheEntry::new())
+        .collect::<Vec<_>>()
+        .into_boxed_slice()
+});
+
+/// When true, find_name_in_mro skips populating the cache.
+/// Set during GC's type_cache_clear to prevent re-population from drops.
+static TYPE_CACHE_CLEARING: AtomicBool = AtomicBool::new(false);
+
+/// MCACHE_HASH: XOR of version and name pointer hash, masked to cache size.
+#[inline]
+fn type_cache_hash(version: u32, name: &'static PyStrInterned) -> usize {
+    let name_hash = (name as *const PyStrInterned as usize >> 3) as u32;
+    ((version ^ name_hash) as usize) & TYPE_CACHE_MASK
+}
+
+/// Invalidate cache entries for a specific version tag.
+/// Called from modified() when a type is changed.
+fn type_cache_clear_version(version: u32) {
+    for entry in TYPE_CACHE.iter() {
+        if entry.version.load(Ordering::Relaxed) == version {
+            entry.begin_write();
+            if entry.version.load(Ordering::Relaxed) == version {
+                entry.version.store(0, Ordering::Release);
+                entry.clear_value();
+            }
+            entry.end_write();
+        }
+    }
+}
+
+/// Clear all method cache entries (_PyType_ClearCache).
+/// Called during GC collection to nullify borrowed pointers before
+/// the collector breaks cycles.
+///
+/// Sets TYPE_CACHE_CLEARING to suppress cache re-population during the
+/// entire operation, preventing concurrent lookups from repopulating
+/// entries while we're clearing them.
+pub fn type_cache_clear() {
+    TYPE_CACHE_CLEARING.store(true, Ordering::Release);
+    for entry in TYPE_CACHE.iter() {
+        entry.begin_write();
+        entry.version.store(0, Ordering::Release);
+        entry.clear_value();
+        entry.end_write();
+    }
+    TYPE_CACHE_CLEARING.store(false, Ordering::Release);
 }
 
 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);
-        // mro contains self as mro[0], so skip traversing to avoid circular reference
-        // self.mro.traverse(tracer_fn);
+        self.mro.traverse(tracer_fn);
         self.subclasses.traverse(tracer_fn);
         self.attributes
             .read_recursive()
             .iter()
             .map(|(_, v)| v.traverse(tracer_fn))
             .count();
+        if let Some(ext) = self.heaptype_ext.as_ref() {
+            ext.specialization_cache.traverse(tracer_fn);
+        }
+    }
+
+    /// type_clear: break reference cycles in type objects
+    fn clear(&mut self, out: &mut Vec<crate::PyObjectRef>) {
+        if let Some(base) = self.base.take() {
+            out.push(base.into());
+        }
+        if let Some(mut guard) = self.bases.try_write() {
+            for base in guard.drain(..) {
+                out.push(base.into());
+            }
+        }
+        if let Some(mut guard) = self.mro.try_write() {
+            for typ in guard.drain(..) {
+                out.push(typ.into());
+            }
+        }
+        if let Some(mut guard) = self.subclasses.try_write() {
+            for weak in guard.drain(..) {
+                out.push(weak.into());
+            }
+        }
+        if let Some(mut guard) = self.attributes.try_write() {
+            for (_, val) in guard.drain(..) {
+                out.push(val);
+            }
+        }
+        if let Some(ext) = self.heaptype_ext.as_ref() {
+            ext.specialization_cache.clear_into(out);
+        }
     }
 }
 
 // PyHeapTypeObject in CPython
 pub struct HeapTypeExt {
-    pub name: PyRwLock<PyStrRef>,
+    pub name: PyRwLock<PyUtf8StrRef>,
     pub qualname: PyRwLock<PyStrRef>,
     pub slots: Option<PyRef<PyTuple<PyStrRef>>>,
     pub type_data: PyRwLock<Option<TypeDataSlot>>,
+    pub specialization_cache: TypeSpecializationCache,
+}
+
+pub struct TypeSpecializationCache {
+    pub init: PyAtomicRef<Option<PyFunction>>,
+    pub getitem: PyAtomicRef<Option<PyFunction>>,
+    pub getitem_version: AtomicU32,
+    // Serialize cache writes/invalidation similar to CPython's BEGIN_TYPE_LOCK.
+    write_lock: PyMutex<()>,
+    retired: PyRwLock<Vec<PyObjectRef>>,
+}
+
+impl TypeSpecializationCache {
+    fn new() -> Self {
+        Self {
+            init: PyAtomicRef::from(None::<PyRef<PyFunction>>),
+            getitem: PyAtomicRef::from(None::<PyRef<PyFunction>>),
+            getitem_version: AtomicU32::new(0),
+            write_lock: PyMutex::new(()),
+            retired: PyRwLock::new(Vec::new()),
+        }
+    }
+
+    #[inline]
+    fn retire_old_function(&self, old: Option<PyRef<PyFunction>>) {
+        if let Some(old) = old {
+            self.retired.write().push(old.into());
+        }
+    }
+
+    #[inline]
+    fn swap_init(&self, new_init: Option<PyRef<PyFunction>>, vm: Option<&VirtualMachine>) {
+        if let Some(vm) = vm {
+            // Keep replaced refs alive for the currently executing frame, matching
+            // CPython-style "old pointer remains valid during ongoing execution"
+            // without accumulating global retired refs.
+            self.init.swap_to_temporary_refs(new_init, vm);
+            return;
+        }
+        // SAFETY: old value is moved to `retired`, so it stays alive while
+        // concurrent readers may still hold borrowed references.
+        let old = unsafe { self.init.swap(new_init) };
+        self.retire_old_function(old);
+    }
+
+    #[inline]
+    fn swap_getitem(&self, new_getitem: Option<PyRef<PyFunction>>, vm: Option<&VirtualMachine>) {
+        if let Some(vm) = vm {
+            self.getitem.swap_to_temporary_refs(new_getitem, vm);
+            return;
+        }
+        // SAFETY: old value is moved to `retired`, so it stays alive while
+        // concurrent readers may still hold borrowed references.
+        let old = unsafe { self.getitem.swap(new_getitem) };
+        self.retire_old_function(old);
+    }
+
+    #[inline]
+    fn invalidate_for_type_modified(&self) {
+        let _guard = self.write_lock.lock();
+        // _spec_cache contract: type modification invalidates all cached
+        // specialization functions.
+        self.swap_init(None, None);
+        self.swap_getitem(None, None);
+    }
+
+    fn traverse(&self, tracer_fn: &mut TraverseFn<'_>) {
+        if let Some(init) = self.init.deref() {
+            tracer_fn(init.as_object());
+        }
+        if let Some(getitem) = self.getitem.deref() {
+            tracer_fn(getitem.as_object());
+        }
+        self.retired
+            .read()
+            .iter()
+            .map(|obj| obj.traverse(tracer_fn))
+            .count();
+    }
+
+    fn clear_into(&self, out: &mut Vec<PyObjectRef>) {
+        let _guard = self.write_lock.lock();
+        let old_init = unsafe { self.init.swap(None) };
+        if let Some(old_init) = old_init {
+            out.push(old_init.into());
+        }
+        let old_getitem = unsafe { self.getitem.swap(None) };
+        if let Some(old_getitem) = old_getitem {
+            out.push(old_getitem.into());
+        }
+        self.getitem_version.store(0, Ordering::Release);
+        out.extend(self.retired.write().drain(..));
+    }
 }
 
 pub struct PointerSlot<T>(NonNull<T>);
@@ -161,6 +457,59 @@ fn is_subtype_with_mro(a_mro: &[PyTypeRef], a: &Py<PyType>, b: &Py<PyType>) -> b
 }
 
 impl PyType {
+    /// Assign a fresh version tag. Returns 0 if the version counter has been
+    /// exhausted, in which case no new cache entries can be created.
+    pub fn assign_version_tag(&self) -> u32 {
+        let v = self.tp_version_tag.load(Ordering::Acquire);
+        if v != 0 {
+            return v;
+        }
+
+        // Assign versions to all direct bases first (MRO invariant).
+        for base in self.bases.read().iter() {
+            if base.assign_version_tag() == 0 {
+                return 0;
+            }
+        }
+
+        loop {
+            let current = NEXT_TYPE_VERSION.load(Ordering::Relaxed);
+            let Some(next) = current.checked_add(1) else {
+                return 0; // Overflow: version space exhausted
+            };
+            if NEXT_TYPE_VERSION
+                .compare_exchange_weak(current, next, Ordering::Relaxed, Ordering::Relaxed)
+                .is_ok()
+            {
+                self.tp_version_tag.store(current, Ordering::Release);
+                return current;
+            }
+        }
+    }
+
+    /// Invalidate this type's version tag and cascade to all subclasses.
+    pub fn modified(&self) {
+        if let Some(ext) = self.heaptype_ext.as_ref() {
+            ext.specialization_cache.invalidate_for_type_modified();
+        }
+        // If already invalidated, all subclasses must also be invalidated
+        // (guaranteed by the MRO invariant in assign_version_tag).
+        let old_version = self.tp_version_tag.load(Ordering::Acquire);
+        if old_version == 0 {
+            return;
+        }
+        self.tp_version_tag.store(0, Ordering::SeqCst);
+        // Nullify borrowed pointers in cache entries for this version
+        // so they don't dangle after the dict is modified.
+        type_cache_clear_version(old_version);
+        let subclasses = self.subclasses.read();
+        for weak_ref in subclasses.iter() {
+            if let Some(sub) = weak_ref.upgrade() {
+                sub.downcast_ref::<PyType>().unwrap().modified();
+            }
+        }
+    }
+
     pub fn new_simple_heap(
         name: &str,
         base: &Py<PyType>,
@@ -189,12 +538,14 @@ impl PyType {
         // Set HEAPTYPE flag for heap-allocated types
         slots.flags |= PyTypeFlags::HEAPTYPE;
 
-        let name = ctx.new_str(name);
+        let name_utf8 = ctx.new_utf8_str(name);
+        let name = name_utf8.clone().into_wtf8();
         let heaptype_ext = HeapTypeExt {
-            name: PyRwLock::new(name.clone()),
+            name: PyRwLock::new(name_utf8),
             qualname: PyRwLock::new(name),
             slots: None,
             type_data: PyRwLock::new(None),
+            specialization_cache: TypeSpecializationCache::new(),
         };
         let base = bases[0].clone();
 
@@ -307,6 +658,14 @@ impl PyType {
             slots.flags |= PyTypeFlags::HAS_DICT
         }
 
+        // Inherit HAS_WEAKREF/MANAGED_WEAKREF from any base in MRO that has it
+        if mro
+            .iter()
+            .any(|b| b.slots.flags.has_feature(PyTypeFlags::HAS_WEAKREF))
+        {
+            slots.flags |= PyTypeFlags::HAS_WEAKREF | PyTypeFlags::MANAGED_WEAKREF
+        }
+
         // Inherit SEQUENCE and MAPPING flags from base classes
         Self::inherit_patma_flags(&mut slots, &bases);
 
@@ -319,6 +678,11 @@ impl PyType {
 
         Self::inherit_readonly_slots(&mut slots, &base);
 
+        // Normalize: any type with HAS_WEAKREF gets MANAGED_WEAKREF
+        if slots.flags.has_feature(PyTypeFlags::HAS_WEAKREF) {
+            slots.flags |= PyTypeFlags::MANAGED_WEAKREF;
+        }
+
         if let Some(qualname) = attrs.get(identifier!(ctx, __qualname__))
             && !qualname.fast_isinstance(ctx.types.str_type)
         {
@@ -337,6 +701,7 @@ impl PyType {
                 attributes: PyRwLock::new(attrs),
                 slots,
                 heaptype_ext: Some(Pin::new(Box::new(heaptype_ext))),
+                tp_version_tag: AtomicU32::new(0),
             },
             metaclass,
             None,
@@ -367,6 +732,9 @@ impl PyType {
         if base.slots.flags.has_feature(PyTypeFlags::HAS_DICT) {
             slots.flags |= PyTypeFlags::HAS_DICT
         }
+        if base.slots.flags.has_feature(PyTypeFlags::HAS_WEAKREF) {
+            slots.flags |= PyTypeFlags::HAS_WEAKREF | PyTypeFlags::MANAGED_WEAKREF
+        }
 
         // Inherit SEQUENCE and MAPPING flags from base class
         // For static types, we only have a single base
@@ -378,6 +746,11 @@ impl PyType {
 
         Self::inherit_readonly_slots(&mut slots, &base);
 
+        // Normalize: any type with HAS_WEAKREF gets MANAGED_WEAKREF
+        if slots.flags.has_feature(PyTypeFlags::HAS_WEAKREF) {
+            slots.flags |= PyTypeFlags::MANAGED_WEAKREF;
+        }
+
         let bases = PyRwLock::new(vec![base.clone()]);
         let mro = base.mro_map_collect(|x| x.to_owned());
 
@@ -390,16 +763,27 @@ impl PyType {
                 attributes: PyRwLock::new(attrs),
                 slots,
                 heaptype_ext: None,
+                tp_version_tag: AtomicU32::new(0),
             },
             metaclass,
             None,
         );
+
+        // Static types are not tracked by GC.
+        // They are immortal and never participate in collectable cycles.
+        unsafe {
+            crate::gc_state::gc_state()
+                .untrack_object(core::ptr::NonNull::from(new_type.as_object()));
+        }
+        new_type.as_object().clear_gc_tracked();
+
         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()
 
         Self::set_new(&new_type.slots, &new_type.base);
+        Self::set_alloc(&new_type.slots, &new_type.base);
 
         let weakref_type = super::PyWeak::static_type();
         for base in new_type.bases.read().iter() {
@@ -446,6 +830,7 @@ impl PyType {
         }
 
         Self::set_new(&self.slots, &self.base);
+        Self::set_alloc(&self.slots, &self.base);
     }
 
     fn set_new(slots: &PyTypeSlots, base: &Option<PyTypeRef>) {
@@ -460,6 +845,16 @@ impl PyType {
         }
     }
 
+    fn set_alloc(slots: &PyTypeSlots, base: &Option<PyTypeRef>) {
+        if slots.alloc.load().is_none() {
+            slots.alloc.store(
+                base.as_ref()
+                    .map(|base| base.slots.alloc.load())
+                    .unwrap_or(None),
+            );
+        }
+    }
+
     /// 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) {
@@ -490,25 +885,195 @@ impl PyType {
     }
 
     pub fn set_attr(&self, attr_name: &'static PyStrInterned, value: PyObjectRef) {
+        // Invalidate caches BEFORE modifying attributes so that borrowed
+        // pointers in cache entries are nullified while the source objects
+        // are still alive.
+        self.modified();
         self.attributes.write().insert(attr_name, value);
     }
 
-    /// This is the internal get_attr implementation for fast lookup on a class.
+    /// Internal get_attr implementation for fast lookup on a class.
+    /// Searches the full MRO (including self) with method cache acceleration.
     pub fn get_attr(&self, attr_name: &'static PyStrInterned) -> Option<PyObjectRef> {
-        flame_guard!(format!("class_get_attr({:?})", attr_name));
+        self.find_name_in_mro(attr_name)
+    }
+
+    /// Cache __init__ for CALL_ALLOC_AND_ENTER_INIT specialization.
+    /// The cache is valid only when guarded by the type version check.
+    pub(crate) fn cache_init_for_specialization(
+        &self,
+        init: PyRef<PyFunction>,
+        tp_version: u32,
+        vm: &VirtualMachine,
+    ) -> bool {
+        let Some(ext) = self.heaptype_ext.as_ref() else {
+            return false;
+        };
+        if tp_version == 0 {
+            return false;
+        }
+        if self.tp_version_tag.load(Ordering::Acquire) != tp_version {
+            return false;
+        }
+        let _guard = ext.specialization_cache.write_lock.lock();
+        if self.tp_version_tag.load(Ordering::Acquire) != tp_version {
+            return false;
+        }
+        ext.specialization_cache.swap_init(Some(init), Some(vm));
+        true
+    }
 
-        self.get_direct_attr(attr_name)
-            .or_else(|| self.get_super_attr(attr_name))
+    /// Read cached __init__ for CALL_ALLOC_AND_ENTER_INIT specialization.
+    pub(crate) fn get_cached_init_for_specialization(
+        &self,
+        tp_version: u32,
+    ) -> Option<PyRef<PyFunction>> {
+        let ext = self.heaptype_ext.as_ref()?;
+        if tp_version == 0 {
+            return None;
+        }
+        if self.tp_version_tag.load(Ordering::Acquire) != tp_version {
+            return None;
+        }
+        ext.specialization_cache
+            .init
+            .to_owned_ordering(Ordering::Acquire)
+    }
+
+    /// Cache __getitem__ for BINARY_OP_SUBSCR_GETITEM specialization.
+    /// The cache is valid only when guarded by the type version check.
+    pub(crate) fn cache_getitem_for_specialization(
+        &self,
+        getitem: PyRef<PyFunction>,
+        tp_version: u32,
+        vm: &VirtualMachine,
+    ) -> bool {
+        let Some(ext) = self.heaptype_ext.as_ref() else {
+            return false;
+        };
+        if tp_version == 0 {
+            return false;
+        }
+        let _guard = ext.specialization_cache.write_lock.lock();
+        if self.tp_version_tag.load(Ordering::Acquire) != tp_version {
+            return false;
+        }
+        let func_version = getitem.get_version_for_current_state();
+        if func_version == 0 {
+            return false;
+        }
+        ext.specialization_cache
+            .swap_getitem(Some(getitem), Some(vm));
+        ext.specialization_cache
+            .getitem_version
+            .store(func_version, Ordering::Relaxed);
+        true
+    }
+
+    /// Read cached __getitem__ for BINARY_OP_SUBSCR_GETITEM specialization.
+    pub(crate) fn get_cached_getitem_for_specialization(&self) -> Option<(PyRef<PyFunction>, u32)> {
+        let ext = self.heaptype_ext.as_ref()?;
+        // Match CPython check order: pointer (Acquire) then function version.
+        let getitem = ext
+            .specialization_cache
+            .getitem
+            .to_owned_ordering(Ordering::Acquire)?;
+        let cached_version = ext
+            .specialization_cache
+            .getitem_version
+            .load(Ordering::Relaxed);
+        if cached_version == 0 {
+            return None;
+        }
+        Some((getitem, cached_version))
     }
 
     pub fn get_direct_attr(&self, attr_name: &'static PyStrInterned) -> Option<PyObjectRef> {
         self.attributes.read().get(attr_name).cloned()
     }
 
-    /// Equivalent to CPython's find_name_in_mro
-    /// Look in tp_dict of types in MRO - bypasses descriptors and other attribute access machinery
+    /// find_name_in_mro with method cache (MCACHE).
+    /// Looks in tp_dict of types in MRO, bypasses descriptors.
+    ///
+    /// Uses a lock-free SeqLock-style pattern:
+    ///   Read:  load sequence/version/name → load value + try_to_owned →
+    ///          validate value pointer + sequence
+    ///   Write: sequence(begin) → version=0 → swap value/name → version=assigned → sequence(end)
     fn find_name_in_mro(&self, name: &'static PyStrInterned) -> Option<PyObjectRef> {
-        // mro[0] is self, so we just iterate through the entire MRO
+        let version = self.tp_version_tag.load(Ordering::Acquire);
+        if version != 0 {
+            let idx = type_cache_hash(version, name);
+            let entry = &TYPE_CACHE[idx];
+            let name_ptr = name as *const _ as *mut _;
+            loop {
+                let seq1 = entry.begin_read();
+                let v1 = entry.version.load(Ordering::Acquire);
+                let type_version = self.tp_version_tag.load(Ordering::Acquire);
+                if v1 != type_version
+                    || !core::ptr::eq(entry.name.load(Ordering::Relaxed), name_ptr)
+                {
+                    break;
+                }
+                let ptr = entry.value.load(Ordering::Acquire);
+                if ptr.is_null() {
+                    if entry.end_read(seq1) {
+                        break;
+                    }
+                    continue;
+                }
+                // _Py_TryIncrefCompare-style validation:
+                // safe_inc via raw pointer, then ensure source is unchanged.
+                if let Some(cloned) = unsafe { PyObject::try_to_owned_from_ptr(ptr) } {
+                    let same_ptr = core::ptr::eq(entry.value.load(Ordering::Relaxed), ptr);
+                    if same_ptr && entry.end_read(seq1) {
+                        return Some(cloned);
+                    }
+                    drop(cloned);
+                    continue;
+                }
+                break;
+            }
+        }
+
+        // Assign version BEFORE the MRO walk so that any concurrent
+        // modified() call during the walk invalidates this version.
+        let assigned = if version == 0 {
+            self.assign_version_tag()
+        } else {
+            version
+        };
+
+        // MRO walk
+        let result = self.find_name_in_mro_uncached(name);
+
+        // Only cache positive results. Negative results are not cached to
+        // avoid stale entries from transient MRO walk failures during
+        // concurrent type modifications.
+        if let Some(ref found) = result
+            && assigned != 0
+            && !TYPE_CACHE_CLEARING.load(Ordering::Acquire)
+            && self.tp_version_tag.load(Ordering::Acquire) == assigned
+        {
+            let idx = type_cache_hash(assigned, name);
+            let entry = &TYPE_CACHE[idx];
+            let name_ptr = name as *const _ as *mut _;
+            entry.begin_write();
+            // Invalidate first to prevent readers from seeing partial state
+            entry.version.store(0, Ordering::Release);
+            // Store borrowed pointer (no refcount increment).
+            let new_ptr = &**found as *const PyObject as *mut PyObject;
+            entry.value.store(new_ptr, Ordering::Relaxed);
+            entry.name.store(name_ptr, Ordering::Relaxed);
+            // Activate entry — Release ensures value/name writes are visible
+            entry.version.store(assigned, Ordering::Release);
+            entry.end_write();
+        }
+
+        result
+    }
+
+    /// Raw MRO walk without cache.
+    fn find_name_in_mro_uncached(&self, name: &'static PyStrInterned) -> Option<PyObjectRef> {
         for cls in self.mro.read().iter() {
             if let Some(value) = cls.attributes.read().get(name) {
                 return Some(value.clone());
@@ -517,14 +1082,9 @@ impl PyType {
         None
     }
 
-    /// Equivalent to CPython's _PyType_LookupRef
-    /// Looks up a name through the MRO without setting an exception
+    /// _PyType_LookupRef: look up a name through the MRO without setting an exception.
     pub fn lookup_ref(&self, name: &Py<PyStr>, vm: &VirtualMachine) -> Option<PyObjectRef> {
-        // Get interned name for efficient lookup
         let interned_name = vm.ctx.interned_str(name)?;
-
-        // Use find_name_in_mro which matches CPython's behavior
-        // This bypasses descriptors and other attribute access machinery
         self.find_name_in_mro(interned_name)
     }
 
@@ -534,12 +1094,41 @@ impl PyType {
             .find_map(|class| class.attributes.read().get(attr_name).cloned())
     }
 
-    // This is the internal has_attr implementation for fast lookup on a class.
+    /// Fast lookup for attribute existence on a class.
     pub fn has_attr(&self, attr_name: &'static PyStrInterned) -> bool {
-        self.attributes.read().contains_key(attr_name)
-            || self.mro.read()[1..]
-                .iter()
-                .any(|c| c.attributes.read().contains_key(attr_name))
+        self.has_name_in_mro(attr_name)
+    }
+
+    /// Check if attribute exists in MRO, using method cache for fast check.
+    /// Unlike find_name_in_mro, avoids cloning the value on cache hit.
+    fn has_name_in_mro(&self, name: &'static PyStrInterned) -> bool {
+        let version = self.tp_version_tag.load(Ordering::Acquire);
+        if version != 0 {
+            let idx = type_cache_hash(version, name);
+            let entry = &TYPE_CACHE[idx];
+            let name_ptr = name as *const _ as *mut _;
+            loop {
+                let seq1 = entry.begin_read();
+                let v1 = entry.version.load(Ordering::Acquire);
+                let type_version = self.tp_version_tag.load(Ordering::Acquire);
+                if v1 != type_version
+                    || !core::ptr::eq(entry.name.load(Ordering::Relaxed), name_ptr)
+                {
+                    break;
+                }
+                let ptr = entry.value.load(Ordering::Acquire);
+                if entry.end_read(seq1) {
+                    if !ptr.is_null() {
+                        return true;
+                    }
+                    break;
+                }
+                continue;
+            }
+        }
+
+        // Cache miss — use find_name_in_mro which populates cache
+        self.find_name_in_mro(name).is_some()
     }
 
     pub fn get_attributes(&self) -> PyAttributes {
@@ -574,24 +1163,34 @@ impl PyType {
         static_f: impl FnOnce(&'static str) -> R,
         heap_f: impl FnOnce(&'a HeapTypeExt) -> R,
     ) -> R {
-        if !self.slots.flags.has_feature(PyTypeFlags::HEAPTYPE) {
-            static_f(self.slots.name)
+        if let Some(ref ext) = self.heaptype_ext {
+            heap_f(ext)
         } else {
-            heap_f(self.heaptype_ext.as_ref().unwrap())
+            static_f(self.slots.name)
         }
     }
 
     pub fn slot_name(&self) -> BorrowedValue<'_, str> {
         self.name_inner(
             |name| name.into(),
-            |ext| PyRwLockReadGuard::map(ext.name.read(), |name| name.as_str()).into(),
+            |ext| {
+                PyRwLockReadGuard::map(ext.name.read(), |name: &PyUtf8StrRef| -> &str {
+                    name.as_str()
+                })
+                .into()
+            },
         )
     }
 
     pub fn name(&self) -> BorrowedValue<'_, str> {
         self.name_inner(
             |name| name.rsplit_once('.').map_or(name, |(_, name)| name).into(),
-            |ext| PyRwLockReadGuard::map(ext.name.read(), |name| name.as_str()).into(),
+            |ext| {
+                PyRwLockReadGuard::map(ext.name.read(), |name: &PyUtf8StrRef| -> &str {
+                    name.as_str()
+                })
+                .into()
+            },
         )
     }
 
@@ -697,7 +1296,7 @@ impl Py<PyType> {
         AsNumber,
         Representable
     ),
-    flags(BASETYPE)
+    flags(BASETYPE, HAS_DICT, HAS_WEAKREF)
 )]
 impl PyType {
     #[pygetset]
@@ -752,6 +1351,9 @@ impl PyType {
         }
         update_mro_recursively(zelf, vm)?;
 
+        // Invalidate inline caches
+        zelf.modified();
+
         // TODO: do any old slots need to be cleaned up first?
         zelf.init_slots(&vm.ctx);
 
@@ -802,7 +1404,7 @@ impl PyType {
                     })
                     .to_owned()
             },
-            |ext| ext.name.read().clone(),
+            |ext| ext.name.read().clone().into_wtf8(),
         )
     }
 
@@ -818,13 +1420,7 @@ impl PyType {
 
     #[pygetset(setter)]
     fn set___qualname__(&self, value: PySetterValue, vm: &VirtualMachine) -> PyResult<()> {
-        // TODO: we should replace heaptype flag check to immutable flag check
-        if !self.slots.flags.has_feature(PyTypeFlags::HEAPTYPE) {
-            return Err(vm.new_type_error(format!(
-                "cannot set '__qualname__' attribute of immutable type '{}'",
-                self.name()
-            )));
-        };
+        self.check_set_special_type_attr(identifier!(vm, __qualname__), vm)?;
         let value = value.ok_or_else(|| {
             vm.new_type_error(format!(
                 "cannot delete '__qualname__' attribute of immutable type '{}'",
@@ -834,10 +1430,12 @@ impl PyType {
 
         let str_value = downcast_qualname(value, vm)?;
 
-        let heap_type = self
-            .heaptype_ext
-            .as_ref()
-            .expect("HEAPTYPE should have heaptype_ext");
+        let heap_type = self.heaptype_ext.as_ref().ok_or_else(|| {
+            vm.new_type_error(format!(
+                "cannot set '__qualname__' attribute of immutable type '{}'",
+                self.name()
+            ))
+        })?;
 
         // 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
@@ -879,7 +1477,7 @@ impl PyType {
     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()));
+                return Err(vm.new_type_error("cannot delete __annotate__ attribute"));
             }
             PySetterValue::Assign(v) => v,
         };
@@ -892,38 +1490,59 @@ impl PyType {
         }
 
         if !vm.is_none(&value) && !value.is_callable() {
-            return Err(vm.new_type_error("__annotate__ must be callable or None".to_owned()));
+            return Err(vm.new_type_error("__annotate__ must be callable or None"));
         }
 
         let mut attrs = self.attributes.write();
-        // Store to __annotate_func__
+        // Clear cached annotations only when setting to a new callable
+        if !vm.is_none(&value) {
+            attrs.swap_remove(identifier!(vm, __annotations_cache__));
+        }
         attrs.insert(identifier!(vm, __annotate_func__), value.clone());
-        // Always clear cached annotations when __annotate__ is updated
-        attrs.swap_remove(identifier!(vm, __annotations_cache__));
 
         Ok(())
     }
 
     #[pygetset]
     fn __annotations__(&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 '__annotations__'",
-                self.name()
-            )));
-        }
-
-        // 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);
+            // Ignore the __annotations__ descriptor stored on type itself.
+            if !annotations.class().is(vm.ctx.types.getset_type) {
+                if vm.is_none(&annotations)
+                    || annotations.class().is(vm.ctx.types.dict_type)
+                    || self.slots.flags.has_feature(PyTypeFlags::HEAPTYPE)
+                {
+                    return Ok(annotations);
+                }
+                return Err(vm.new_attribute_error(format!(
+                    "type object '{}' has no attribute '__annotations__'",
+                    self.name()
+                )));
+            }
         }
         // Then try __annotations_cache__
         if let Some(annotations) = attrs.get(identifier!(vm, __annotations_cache__)).cloned() {
-            return Ok(annotations);
+            if vm.is_none(&annotations)
+                || annotations.class().is(vm.ctx.types.dict_type)
+                || self.slots.flags.has_feature(PyTypeFlags::HEAPTYPE)
+            {
+                return Ok(annotations);
+            }
+            return Err(vm.new_attribute_error(format!(
+                "type object '{}' has no attribute '__annotations__'",
+                self.name()
+            )));
         }
         drop(attrs);
 
+        if !self.slots.flags.has_feature(PyTypeFlags::HEAPTYPE) {
+            return Err(vm.new_attribute_error(format!(
+                "type object '{}' has no attribute '__annotations__'",
+                self.name()
+            )));
+        }
+
         // Get __annotate__ and call it if callable
         let annotate = self.__annotate__(vm)?;
         let annotations = if annotate.is_callable() {
@@ -948,7 +1567,11 @@ impl PyType {
     }
 
     #[pygetset(setter)]
-    fn set___annotations__(&self, value: Option<PyObjectRef>, vm: &VirtualMachine) -> PyResult<()> {
+    fn set___annotations__(
+        &self,
+        value: crate::function::PySetterValue<PyObjectRef>,
+        vm: &VirtualMachine,
+    ) -> PyResult<()> {
         if self.slots.flags.has_feature(PyTypeFlags::IMMUTABLETYPE) {
             return Err(vm.new_type_error(format!(
                 "cannot set '__annotations__' attribute of immutable type '{}'",
@@ -957,33 +1580,40 @@ impl PyType {
         }
 
         let mut attrs = self.attributes.write();
-        // 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("__annotations__".to_owned()));
+        match value {
+            crate::function::PySetterValue::Assign(value) => {
+                // SET path: store the value (including None)
+                let key = if has_annotations {
+                    identifier!(vm, __annotations__)
+                } else {
+                    identifier!(vm, __annotations_cache__)
+                };
+                attrs.insert(key, value);
+                if has_annotations {
+                    attrs.swap_remove(identifier!(vm, __annotations_cache__));
+                }
             }
-            // 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()));
+            crate::function::PySetterValue::Delete => {
+                // DELETE path: remove the key
+                let removed = if has_annotations {
+                    attrs
+                        .swap_remove(identifier!(vm, __annotations__))
+                        .is_some()
+                } else {
+                    attrs
+                        .swap_remove(identifier!(vm, __annotations_cache__))
+                        .is_some()
+                };
+                if !removed {
+                    return Err(vm.new_attribute_error("__annotations__"));
+                }
+                if has_annotations {
+                    attrs.swap_remove(identifier!(vm, __annotations_cache__));
+                }
             }
         }
-        // Always clear __annotate_func__ and __annotate__
         attrs.swap_remove(identifier!(vm, __annotate_func__));
         attrs.swap_remove(identifier!(vm, __annotate__));
 
@@ -1004,15 +1634,23 @@ impl PyType {
                     Some(found)
                 }
             })
-            .unwrap_or_else(|| vm.ctx.new_str(ascii!("builtins")).into())
+            .unwrap_or_else(|| {
+                // For non-heap types, extract module from tp_name (e.g. "typing.TypeAliasType" -> "typing")
+                let slot_name = self.slot_name();
+                if let Some((module, _)) = slot_name.rsplit_once('.') {
+                    vm.ctx.intern_str(module).to_object()
+                } else {
+                    vm.ctx.new_str(ascii!("builtins")).into()
+                }
+            })
     }
 
     #[pygetset(setter)]
     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);
+        let mut attributes = self.attributes.write();
+        attributes.swap_remove(identifier!(vm, __firstlineno__));
+        attributes.insert(identifier!(vm, __module__), value);
         Ok(())
     }
 
@@ -1087,12 +1725,19 @@ 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)?;
+        let name = name.try_into_utf8(vm)?;
+
+        let heap_type = self.heaptype_ext.as_ref().ok_or_else(|| {
+            vm.new_type_error(format!(
+                "cannot set '__name__' attribute of immutable type '{}'",
+                self.slot_name()
+            ))
+        })?;
 
         // 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)
+        // then drop the old value after releasing the lock
         let _old_name = {
-            let mut name_guard = self.heaptype_ext.as_ref().unwrap().name.write();
+            let mut name_guard = heap_type.name.write();
             core::mem::replace(&mut *name_guard, name)
         };
         // old_name is dropped here, outside the lock scope
@@ -1131,8 +1776,8 @@ impl PyType {
             PySetterValue::Assign(ref val) => {
                 let key = identifier!(vm, __type_params__);
                 self.check_set_special_type_attr(key, vm)?;
-                let mut attrs = self.attributes.write();
-                attrs.insert(key, val.clone().into());
+                self.modified();
+                self.attributes.write().insert(key, val.clone().into());
             }
             PySetterValue::Delete => {
                 // For delete, we still need to check if the type is immutable
@@ -1142,9 +1787,9 @@ impl PyType {
                         self.slot_name()
                     )));
                 }
-                let mut attrs = self.attributes.write();
                 let key = identifier!(vm, __type_params__);
-                attrs.shift_remove(&key);
+                self.modified();
+                self.attributes.write().shift_remove(&key);
             }
         }
         Ok(())
@@ -1179,7 +1824,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 name = name.try_into_utf8(vm)?;
 
         let (metatype, base, bases, base_is_type) = if bases.is_empty() {
             let base = vm.ctx.types.object_type.to_owned();
@@ -1223,14 +1868,16 @@ impl Constructor for PyType {
         };
 
         let qualname = dict
-            .pop_item(identifier!(vm, __qualname__).as_object(), vm)?
+            .get_item_opt(identifier!(vm, __qualname__), vm)?
             .map(|obj| downcast_qualname(obj, vm))
             .transpose()?
             .unwrap_or_else(|| {
                 // If __qualname__ is not provided, we can use the name as default
-                name.clone()
+                name.clone().into_wtf8()
             });
+
         let mut attributes = dict.to_attributes(vm);
+        attributes.shift_remove(identifier!(vm, __qualname__));
 
         // Check __doc__ for surrogates - raises UnicodeEncodeError during type creation
         if let Some(doc) = attributes.get(identifier!(vm, __doc__))
@@ -1277,14 +1924,14 @@ 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__))
-        {
+        let (heaptype_slots, add_dict, add_weakref): (
+            Option<PyRef<PyTuple<PyStrRef>>>,
+            bool,
+            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())
-                );
+                return Err(vm.new_type_error("__slots__ items must be strings, not 'bytes'"));
             }
 
             let slots = if x.class().is(vm.ctx.types.str_type) {
@@ -1297,9 +1944,9 @@ impl Constructor for PyType {
                     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(),
-                            ));
+                            return Err(
+                                vm.new_type_error("__slots__ items must be strings, not 'bytes'")
+                            );
                         }
                         elements.push(element);
                     }
@@ -1314,7 +1961,7 @@ impl Constructor for PyType {
             // 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__");
+                .any(|s| !matches!(s.as_bytes(), b"__dict__" | b"__weakref__"));
             if has_custom_slots && base.slots.itemsize > 0 {
                 return Err(vm.new_type_error(format!(
                     "nonempty __slots__ not supported for subtype of '{}'",
@@ -1328,81 +1975,62 @@ impl Constructor for PyType {
             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()));
+                    return Err(vm.new_type_error("__slots__ must be identifiers"));
                 }
 
-                let slot_name = slot.as_str();
+                let slot_name = slot.as_bytes();
 
                 // Check for duplicate __dict__
-                if slot_name == "__dict__" {
+                if slot_name == b"__dict__" {
                     if seen_dict {
-                        return Err(vm.new_type_error(
-                            "__dict__ slot disallowed: we already got one".to_owned(),
-                        ));
+                        return Err(
+                            vm.new_type_error("__dict__ slot disallowed: we already got one")
+                        );
                     }
                     seen_dict = true;
                 }
 
                 // Check for duplicate __weakref__
-                if slot_name == "__weakref__" {
+                if slot_name == b"__weakref__" {
                     if seen_weakref {
-                        return Err(vm.new_type_error(
-                            "__weakref__ slot disallowed: we already got one".to_owned(),
-                        ));
+                        return Err(
+                            vm.new_type_error("__weakref__ slot disallowed: we already got one")
+                        );
                     }
                     seen_weakref = true;
                 }
 
                 // Check if slot name conflicts with class attributes
-                if attributes.contains_key(vm.ctx.intern_str(slot_name)) {
+                if attributes.contains_key(vm.ctx.intern_str(slot.as_wtf8())) {
                     return Err(vm.new_value_error(format!(
                         "'{}' in __slots__ conflicts with a class variable",
-                        slot_name
+                        slot.as_wtf8()
                     )));
                 }
             }
 
             // 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())
-                );
+                return Err(vm.new_type_error("__dict__ slot disallowed: we already got one"));
             }
 
             // 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 {
-                    // Builtin type - check if it has __weakref__ descriptor
-                    let weakref_name = vm.ctx.intern_str("__weakref__");
-                    base.attributes.read().contains_key(weakref_name)
-                };
-
-                if base_has_weakref {
-                    return Err(vm.new_type_error(
-                        "__weakref__ slot disallowed: we already got one".to_owned(),
-                    ));
-                }
+            if seen_weakref && base.slots.flags.has_feature(PyTypeFlags::HAS_WEAKREF) {
+                return Err(vm.new_type_error("__weakref__ slot disallowed: we already got one"));
             }
 
-            // Check if __dict__ is in slots
+            // Check if __dict__ or __weakref__ is in slots
             let dict_name = "__dict__";
-            let has_dict = slots.iter().any(|s| s.as_str() == dict_name);
+            let weakref_name = "__weakref__";
+            let has_dict = slots.iter().any(|s| s.as_wtf8() == dict_name);
+            let add_weakref = seen_weakref;
 
-            // Filter out __dict__ from slots
-            let filtered_slots = if has_dict {
+            // Filter out __dict__ and __weakref__ from slots
+            // (they become descriptors, not member slots)
+            let filtered_slots = if has_dict || add_weakref {
                 let filtered: Vec<PyStrRef> = slots
                     .iter()
-                    .filter(|s| s.as_str() != dict_name)
+                    .filter(|s| s.as_wtf8() != dict_name && s.as_wtf8() != weakref_name)
                     .cloned()
                     .collect();
                 PyTuple::new_ref_typed(filtered, &vm.ctx)
@@ -1410,9 +2038,9 @@ impl Constructor for PyType {
                 slots
             };
 
-            (Some(filtered_slots), has_dict)
+            (Some(filtered_slots), has_dict, add_weakref)
         } else {
-            (None, false)
+            (None, false, false)
         };
 
         // FIXME: this is a temporary fix. multi bases with multiple slots will break object
@@ -1438,6 +2066,14 @@ impl Constructor for PyType {
             flags |= PyTypeFlags::HAS_DICT | PyTypeFlags::MANAGED_DICT;
         }
 
+        // Add HAS_WEAKREF if:
+        // 1. __slots__ is not defined (automatic weakref support), OR
+        // 2. __weakref__ is in __slots__
+        let may_add_weakref = !base.slots.flags.has_feature(PyTypeFlags::HAS_WEAKREF);
+        if (heaptype_slots.is_none() && may_add_weakref) || add_weakref {
+            flags |= PyTypeFlags::HAS_WEAKREF | PyTypeFlags::MANAGED_WEAKREF;
+        }
+
         let (slots, heaptype_ext) = {
             let slots = PyTypeSlots {
                 flags,
@@ -1450,6 +2086,7 @@ impl Constructor for PyType {
                 qualname: PyRwLock::new(qualname),
                 slots: heaptype_slots.clone(),
                 type_data: PyRwLock::new(None),
+                specialization_cache: TypeSpecializationCache::new(),
             };
             (slots, heaptype_ext)
         };
@@ -1470,7 +2107,10 @@ impl Constructor for PyType {
             let class_name = typ.name().to_string();
             for member in slots.as_slice() {
                 // Apply name mangling for private attributes (__x -> _ClassName__x)
-                let mangled_name = mangle_name(&class_name, member.as_str());
+                let member_str = member
+                    .to_str()
+                    .ok_or_else(|| vm.new_type_error("__slots__ must be valid UTF-8 strings"))?;
+                let mangled_name = mangle_name(&class_name, member_str);
                 let member_def = PyMemberDef {
                     name: mangled_name.clone(),
                     kind: MemberKind::ObjectEx,
@@ -1495,15 +2135,29 @@ impl Constructor for PyType {
             }
         }
 
-        if let Some(cell) = typ.attributes.write().get(identifier!(vm, __classcell__)) {
-            let cell = PyCellRef::try_from_object(vm, cell.clone()).map_err(|_| {
-                vm.new_type_error(format!(
-                    "__classcell__ must be a nonlocal cell, not {}",
-                    cell.class().name()
-                ))
-            })?;
-            cell.set(Some(typ.clone().into()));
-        };
+        {
+            let mut attrs = typ.attributes.write();
+            if let Some(cell) = attrs.get(identifier!(vm, __classcell__)) {
+                let cell = PyCellRef::try_from_object(vm, cell.clone()).map_err(|_| {
+                    vm.new_type_error(format!(
+                        "__classcell__ must be a nonlocal cell, not {}",
+                        cell.class().name()
+                    ))
+                })?;
+                cell.set(Some(typ.clone().into()));
+                attrs.shift_remove(identifier!(vm, __classcell__));
+            }
+            if let Some(cell) = attrs.get(identifier!(vm, __classdictcell__)) {
+                let cell = PyCellRef::try_from_object(vm, cell.clone()).map_err(|_| {
+                    vm.new_type_error(format!(
+                        "__classdictcell__ must be a nonlocal cell, not {}",
+                        cell.class().name()
+                    ))
+                })?;
+                cell.set(Some(dict.clone().into()));
+                attrs.shift_remove(identifier!(vm, __classdictcell__));
+            }
+        }
 
         // All *classes* should have a dict. Exceptions are *instances* of
         // classes that define __slots__ and instances of built-in classes
@@ -1533,6 +2187,29 @@ impl Constructor for PyType {
             }
         }
 
+        // Add __weakref__ descriptor for types with HAS_WEAKREF
+        if typ.slots.flags.has_feature(PyTypeFlags::HAS_WEAKREF) {
+            let __weakref__ = vm.ctx.intern_str("__weakref__");
+            let has_inherited_weakref = typ
+                .mro
+                .read()
+                .iter()
+                .any(|base| base.attributes.read().contains_key(&__weakref__));
+            if !typ.attributes.read().contains_key(&__weakref__) && !has_inherited_weakref {
+                unsafe {
+                    let descriptor = vm.ctx.new_getset(
+                        "__weakref__",
+                        &typ,
+                        subtype_get_weakref,
+                        subtype_set_weakref,
+                    );
+                    typ.attributes
+                        .write()
+                        .insert(__weakref__, descriptor.into());
+                }
+            }
+        }
+
         // Set __doc__ to None if not already present in the type's dict
         // This matches CPython's behavior in type_dict_set_doc (typeobject.c)
         // which ensures every type has a __doc__ entry in its dict
@@ -1554,15 +2231,17 @@ impl Constructor for PyType {
             })
             .collect::<PyResult<Vec<_>>>()?;
         for (obj, name, set_name) in attributes {
-            set_name.call((typ.clone(), name), vm).map_err(|e| {
-                let err = vm.new_runtime_error(format!(
-                    "Error calling __set_name__ on '{}' instance {} in '{}'",
+            set_name.call((typ.clone(), name), vm).inspect_err(|e| {
+                // PEP 678: Add a note to the original exception instead of wrapping it
+                // (Python 3.12+, gh-77757)
+                let note = format!(
+                    "Error calling __set_name__ on '{}' instance '{}' in '{}'",
                     obj.class().name(),
                     name,
                     typ.name()
-                ));
-                err.set___cause__(Some(e));
-                err
+                );
+                // Ignore result - adding a note is best-effort, the original exception is what matters
+                drop(vm.call_method(e.as_object(), "add_note", (vm.ctx.new_str(note.as_str()),)));
             })?;
         }
 
@@ -1622,10 +2301,10 @@ impl Initializer for PyType {
     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()));
+            return Err(vm.new_type_error("type.__init__() takes no keyword arguments"));
         }
         if args.args.len() != 1 && args.args.len() != 3 {
-            return Err(vm.new_type_error("type.__init__() takes 1 or 3 arguments".to_owned()));
+            return Err(vm.new_type_error("type.__init__() takes 1 or 3 arguments"));
         }
         Ok(())
     }
@@ -1640,7 +2319,7 @@ impl GetAttr for PyType {
         #[cold]
         fn attribute_error(
             zelf: &Py<PyType>,
-            name: &str,
+            name: &Wtf8,
             vm: &VirtualMachine,
         ) -> PyBaseExceptionRef {
             vm.new_attribute_error(format!(
@@ -1651,7 +2330,7 @@ impl GetAttr for PyType {
         }
 
         let Some(name) = vm.ctx.interned_str(name_str) else {
-            return Err(attribute_error(zelf, name_str.as_str(), vm));
+            return Err(attribute_error(zelf, name_str.as_wtf8(), vm));
         };
         vm_trace!("type.__getattribute__({:?}, {:?})", zelf, name);
         let mcl = zelf.class();
@@ -1681,7 +2360,7 @@ impl GetAttr for PyType {
         } else if let Some(attr) = mcl_attr {
             vm.call_if_get_descriptor(&attr, zelf.to_owned().into())
         } else {
-            Err(attribute_error(zelf, name_str.as_str(), vm))
+            Err(attribute_error(zelf, name_str.as_wtf8(), vm))
         }
     }
 }
@@ -1754,7 +2433,7 @@ impl Py<PyType> {
 
     #[pymethod]
     fn __instancecheck__(&self, obj: PyObjectRef, vm: &VirtualMachine) -> PyResult<bool> {
-        // Use real_is_instance to avoid infinite recursion, matching CPython's behavior
+        // Use real_is_instance to avoid infinite recursion
         obj.real_is_instance(self.as_object(), vm)
     }
 
@@ -1783,8 +2462,14 @@ impl SetAttr for PyType {
         value: PySetterValue,
         vm: &VirtualMachine,
     ) -> PyResult<()> {
-        // TODO: pass PyRefExact instead of &str
-        let attr_name = vm.ctx.intern_str(attr_name.as_str());
+        let attr_name = vm.ctx.intern_str(attr_name.as_wtf8());
+        if zelf.slots.flags.has_feature(PyTypeFlags::IMMUTABLETYPE) {
+            return Err(vm.new_type_error(format!(
+                "cannot set '{}' attribute of immutable type '{}'",
+                attr_name,
+                zelf.slot_name()
+            )));
+        }
         if let Some(attr) = zelf.get_class_attr(attr_name) {
             let descr_set = attr.class().slots.descr_set.load();
             if let Some(descriptor) = descr_set {
@@ -1793,6 +2478,11 @@ impl SetAttr for PyType {
         }
         let assign = value.is_assign();
 
+        // Invalidate inline caches before modifying attributes.
+        // This ensures other threads see the version invalidation before
+        // any attribute changes, preventing use-after-free of cached descriptors.
+        zelf.modified();
+
         if let PySetterValue::Assign(value) = value {
             zelf.attributes.write().insert(attr_name, value);
         } else {
@@ -1801,11 +2491,12 @@ impl SetAttr for PyType {
                 return Err(vm.new_attribute_error(format!(
                     "type object '{}' has no attribute '{}'",
                     zelf.name(),
-                    attr_name.as_str(),
+                    attr_name,
                 )));
             }
         }
-        if attr_name.as_str().starts_with("__") && attr_name.as_str().ends_with("__") {
+
+        if attr_name.as_wtf8().starts_with("__") && attr_name.as_wtf8().ends_with("__") {
             if assign {
                 zelf.update_slot::<true>(attr_name, &vm.ctx);
             } else {
@@ -1827,7 +2518,7 @@ impl Callable for PyType {
                 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()));
+                return Err(vm.new_type_error("type() takes 1 or 3 arguments"));
             }
         }
 
@@ -1862,19 +2553,15 @@ impl Representable for PyType {
     #[inline]
     fn repr_str(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<String> {
         let module = zelf.__module__(vm);
-        let module = module.downcast_ref::<PyStr>().map(|m| m.as_str());
+        let module = module.downcast_ref::<PyStr>().map(|m| m.as_wtf8());
 
         let repr = match module {
             Some(module) if module != "builtins" => {
+                let qualname = zelf.__qualname__(vm);
+                let qualname = qualname.downcast_ref::<PyStr>().map(|n| n.as_wtf8());
                 let name = zelf.name();
-                format!(
-                    "<class '{}.{}'>",
-                    module,
-                    zelf.__qualname__(vm)
-                        .downcast_ref::<PyStr>()
-                        .map(|n| n.as_str())
-                        .unwrap_or_else(|| &name)
-                )
+                let qualname = qualname.unwrap_or_else(|| name.as_ref());
+                format!("<class '{module}.{qualname}'>")
             }
             _ => format!("<class '{}'>", zelf.slot_name()),
         };
@@ -1958,12 +2645,80 @@ fn subtype_set_dict(obj: PyObjectRef, value: PyObjectRef, vm: &VirtualMachine) -
     }
 }
 
+// subtype_get_weakref
+fn subtype_get_weakref(obj: PyObjectRef, vm: &VirtualMachine) -> PyResult {
+    // Return the first weakref in the weakref list, or None
+    let weakref = obj.get_weakrefs();
+    Ok(weakref.unwrap_or_else(|| vm.ctx.none()))
+}
+
+// subtype_set_weakref: __weakref__ is read-only
+fn subtype_set_weakref(obj: PyObjectRef, _value: PyObjectRef, vm: &VirtualMachine) -> PyResult<()> {
+    Err(vm.new_attribute_error(format!(
+        "attribute '__weakref__' of '{}' objects is not writable",
+        obj.class().name()
+    )))
+}
+
 /*
  * The magical type type
  */
 
-pub(crate) fn init(ctx: &Context) {
+/// Vectorcall for PyType (PEP 590).
+/// Fast path: type(x) returns x.__class__ without constructing FuncArgs.
+///
+/// # Implementation note: `slots.vectorcall` dual use
+///
+/// CPython has three distinct fields on PyTypeObject:
+///   - `tp_vectorcall`: constructor fast path (e.g. `list_vectorcall`)
+///   - `tp_vectorcall_offset`: per-instance vectorcall for callables (e.g. functions)
+///   - `tp_call`: standard call slot
+///
+/// RustPython collapses the first two into a single `slots.vectorcall`. The
+/// `call.is_none()` guard below distinguishes the two uses: callable types have
+/// `slots.call` set, so their `slots.vectorcall` is for calling instances,
+/// not for construction.
+///
+/// This heuristic is correct for all current builtins but is not a general
+/// solution — `type` itself is both callable and has a constructor vectorcall,
+/// handled by the explicit `zelf.is(type_type)` check above the guard.
+/// If more such types arise, consider splitting into a dedicated
+/// `constructor_vectorcall` slot.
+fn vectorcall_type(
+    zelf_obj: &PyObject,
+    args: Vec<PyObjectRef>,
+    nargs: usize,
+    kwnames: Option<&[PyObjectRef]>,
+    vm: &VirtualMachine,
+) -> PyResult {
+    let zelf: &Py<PyType> = zelf_obj.downcast_ref().unwrap();
+
+    // type(x) fast path: single positional arg, no kwargs
+    if zelf.is(vm.ctx.types.type_type) {
+        let no_kwargs = kwnames.is_none_or(|kw| kw.is_empty());
+        if nargs == 1 && no_kwargs {
+            return Ok(args[0].obj_type());
+        }
+    } else if zelf.slots.call.load().is_none() && zelf.slots.new.load().is_some() {
+        // Per-type constructor vectorcall for non-callable types (dict, list, int, etc.)
+        // Also guard on slots.new to avoid dispatching for DISALLOW_INSTANTIATION types.
+        if let Some(type_vc) = zelf.slots.vectorcall.load() {
+            return type_vc(zelf_obj, args, nargs, kwnames, vm);
+        }
+    }
+
+    // Fallback: construct FuncArgs and use standard call
+    let func_args = FuncArgs::from_vectorcall_owned(args, nargs, kwnames);
+    PyType::call(zelf, func_args, vm)
+}
+
+pub(crate) fn init(ctx: &'static Context) {
     PyType::extend_class(ctx, ctx.types.type_type);
+    ctx.types
+        .type_type
+        .slots
+        .vectorcall
+        .store(Some(vectorcall_type));
 }
 
 pub(crate) fn call_slot_new(
@@ -2015,12 +2770,7 @@ pub(crate) fn call_slot_new(
 }
 
 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 Ok(vm.ctx.not_implemented());
-    }
-
-    let tuple = PyTuple::new_ref(vec![zelf, other], &vm.ctx);
-    union_::make_union(&tuple, vm)
+    union_::or_op(zelf, other, vm)
 }
 
 fn take_next_base(bases: &mut [Vec<PyTypeRef>]) -> Option<PyTypeRef> {
@@ -2054,9 +2804,10 @@ fn linearise_mro(mut bases: Vec<Vec<PyTypeRef>>) -> Result<Vec<PyTypeRef>, Strin
             // We start at index 1 to skip direct bases.
             // This will not catch duplicate bases, but such a thing is already tested for.
             if later_mro[1..].iter().any(|cls| cls.is(base)) {
-                return Err(
-                    "Unable to find mro order which keeps local precedence ordering".to_owned(),
-                );
+                return Err(format!(
+                    "Cannot create a consistent method resolution order (MRO) for bases {}",
+                    bases.iter().map(|x| x.first().unwrap()).format(", ")
+                ));
             }
         }
     }
diff --git a/crates/vm/src/builtins/union.rs b/crates/vm/src/builtins/union.rs
index 9856235ecf4..0f7ce123721 100644
--- a/crates/vm/src/builtins/union.rs
+++ b/crates/vm/src/builtins/union.rs
@@ -1,4 +1,5 @@
 use super::{genericalias, type_};
+use crate::common::lock::LazyLock;
 use crate::{
     AsObject, Context, Py, PyObject, PyObjectRef, PyPayload, PyRef, PyResult, VirtualMachine,
     atomic_func,
@@ -8,11 +9,10 @@ use crate::{
     convert::ToPyObject,
     function::PyComparisonValue,
     protocol::{PyMappingMethods, PyNumberMethods},
-    stdlib::typing::TypeAliasType,
+    stdlib::_typing::{TypeAliasType, call_typing_func_object},
     types::{AsMapping, AsNumber, Comparable, GetAttr, Hashable, PyComparisonOp, Representable},
 };
 use alloc::fmt;
-use std::sync::LazyLock;
 
 const CLS_ATTRS: &[&str] = &["__module__"];
 
@@ -51,7 +51,7 @@ impl PyUnion {
         })
     }
 
-    /// Direct access to args field, matching CPython's _Py_union_args
+    /// Direct access to args field (_Py_union_args)
     #[inline]
     pub fn args(&self) -> &Py<PyTuple> {
         &self.args
@@ -98,7 +98,7 @@ impl PyUnion {
 }
 
 #[pyclass(
-    flags(DISALLOW_INSTANTIATION),
+    flags(DISALLOW_INSTANTIATION, HAS_WEAKREF),
     with(Hashable, Comparable, AsMapping, AsNumber, Representable)
 )]
 impl PyUnion {
@@ -193,7 +193,7 @@ impl PyUnion {
     }
 }
 
-pub fn is_unionable(obj: PyObjectRef, vm: &VirtualMachine) -> bool {
+fn is_unionable(obj: PyObjectRef, vm: &VirtualMachine) -> bool {
     let cls = obj.class();
     cls.is(vm.ctx.types.none_type)
         || obj.downcastable::<PyType>()
@@ -202,6 +202,36 @@ pub fn is_unionable(obj: PyObjectRef, vm: &VirtualMachine) -> bool {
         || obj.downcast_ref::<TypeAliasType>().is_some()
 }
 
+fn type_check(arg: PyObjectRef, vm: &VirtualMachine) -> PyResult<PyObjectRef> {
+    // Fast path to avoid calling into typing.py
+    if is_unionable(arg.clone(), vm) {
+        return Ok(arg);
+    }
+    let message_str: PyObjectRef = vm
+        .ctx
+        .new_str("Union[arg, ...]: each arg must be a type.")
+        .into();
+    call_typing_func_object(vm, "_type_check", (arg, message_str))
+}
+
+fn has_union_operands(a: PyObjectRef, b: PyObjectRef, vm: &VirtualMachine) -> bool {
+    let union_type = vm.ctx.types.union_type;
+    a.class().is(union_type) || b.class().is(union_type)
+}
+
+pub fn or_op(zelf: PyObjectRef, other: PyObjectRef, vm: &VirtualMachine) -> PyResult {
+    if !has_union_operands(zelf.clone(), other.clone(), vm)
+        && (!is_unionable(zelf.clone(), vm) || !is_unionable(other.clone(), vm))
+    {
+        return Ok(vm.ctx.not_implemented());
+    }
+
+    let left = type_check(zelf, vm)?;
+    let right = type_check(other, vm)?;
+    let tuple = PyTuple::new_ref(vec![left, right], &vm.ctx);
+    make_union(&tuple, vm)
+}
+
 fn make_parameters(args: &Py<PyTuple>, vm: &VirtualMachine) -> PyResult<PyTupleRef> {
     let parameters = genericalias::make_parameters(args, vm);
     let result = dedup_and_flatten_args(&parameters, vm)?;
@@ -262,8 +292,8 @@ fn dedup_and_flatten_args(args: &Py<PyTuple>, vm: &VirtualMachine) -> PyResult<U
     // - 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.
+    // This avoids calling __eq__ when hashes differ, so `int | BadType`
+    // doesn't raise even if BadType.__eq__ raises.
 
     let mut new_args: Vec<PyObjectRef> = Vec::with_capacity(args.len());
 
@@ -510,7 +540,7 @@ impl Representable for PyUnion {
     }
 }
 
-pub fn init(context: &Context) {
+pub fn init(context: &'static Context) {
     let union_type = &context.types.union_type;
     PyUnion::extend_class(context, union_type);
 }
diff --git a/crates/vm/src/builtins/weakproxy.rs b/crates/vm/src/builtins/weakproxy.rs
index 0f68e9e9815..561e69d6180 100644
--- a/crates/vm/src/builtins/weakproxy.rs
+++ b/crates/vm/src/builtins/weakproxy.rs
@@ -1,4 +1,5 @@
 use super::{PyStr, PyStrRef, PyType, PyTypeRef, PyWeak};
+use crate::common::lock::LazyLock;
 use crate::{
     Context, Py, PyObject, PyObjectRef, PyPayload, PyRef, PyResult, VirtualMachine, atomic_func,
     class::PyClassImpl,
@@ -11,7 +12,6 @@ use crate::{
         Iterable, PyComparisonOp, Representable, SetAttr,
     },
 };
-use std::sync::LazyLock;
 
 #[pyclass(module = false, name = "weakproxy", unhashable = true, traverse)]
 #[derive(Debug)]
@@ -135,6 +135,9 @@ impl Iterable for PyWeakProxy {
 impl IterNext for PyWeakProxy {
     fn next(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<PyIterReturn> {
         let obj = zelf.try_upgrade(vm)?;
+        if obj.class().slots.iternext.load().is_none() {
+            return Err(vm.new_type_error("Weakref proxy referenced a non-iterator".to_owned()));
+        }
         PyIter::new(obj).next(vm)
     }
 }
@@ -142,7 +145,7 @@ impl IterNext for PyWeakProxy {
 fn new_reference_error(vm: &VirtualMachine) -> PyRef<super::PyBaseException> {
     vm.new_exception_msg(
         vm.ctx.exceptions.reference_error.to_owned(),
-        "weakly-referenced object no longer exists".to_owned(),
+        "weakly-referenced object no longer exists".into(),
     )
 }
 
@@ -166,14 +169,125 @@ impl SetAttr for PyWeakProxy {
     }
 }
 
+fn proxy_upgrade(obj: &PyObject, vm: &VirtualMachine) -> PyResult {
+    obj.downcast_ref::<PyWeakProxy>()
+        .expect("proxy_upgrade called on non-PyWeakProxy object")
+        .try_upgrade(vm)
+}
+
+fn proxy_upgrade_opt(obj: &PyObject, vm: &VirtualMachine) -> PyResult<Option<PyObjectRef>> {
+    match obj.downcast_ref::<PyWeakProxy>() {
+        Some(proxy) => Ok(Some(proxy.try_upgrade(vm)?)),
+        None => Ok(None),
+    }
+}
+
+fn proxy_unary_op(
+    obj: &PyObject,
+    vm: &VirtualMachine,
+    op: fn(&VirtualMachine, &PyObject) -> PyResult,
+) -> PyResult {
+    let upgraded = proxy_upgrade(obj, vm)?;
+    op(vm, &upgraded)
+}
+
+macro_rules! proxy_unary_slot {
+    ($vm_method:ident) => {
+        Some(|number, vm| proxy_unary_op(number.obj, vm, |vm, obj| vm.$vm_method(obj)))
+    };
+}
+
+fn proxy_binary_op(
+    a: &PyObject,
+    b: &PyObject,
+    vm: &VirtualMachine,
+    op: fn(&VirtualMachine, &PyObject, &PyObject) -> PyResult,
+) -> PyResult {
+    let a_up = proxy_upgrade_opt(a, vm)?;
+    let b_up = proxy_upgrade_opt(b, vm)?;
+    let a_ref = a_up.as_deref().unwrap_or(a);
+    let b_ref = b_up.as_deref().unwrap_or(b);
+    op(vm, a_ref, b_ref)
+}
+
+macro_rules! proxy_binary_slot {
+    ($vm_method:ident) => {
+        Some(|a, b, vm| proxy_binary_op(a, b, vm, |vm, a, b| vm.$vm_method(a, b)))
+    };
+}
+
+fn proxy_ternary_op(
+    a: &PyObject,
+    b: &PyObject,
+    c: &PyObject,
+    vm: &VirtualMachine,
+    op: fn(&VirtualMachine, &PyObject, &PyObject, &PyObject) -> PyResult,
+) -> PyResult {
+    let a_up = proxy_upgrade_opt(a, vm)?;
+    let b_up = proxy_upgrade_opt(b, vm)?;
+    let c_up = proxy_upgrade_opt(c, vm)?;
+    let a_ref = a_up.as_deref().unwrap_or(a);
+    let b_ref = b_up.as_deref().unwrap_or(b);
+    let c_ref = c_up.as_deref().unwrap_or(c);
+    op(vm, a_ref, b_ref, c_ref)
+}
+
+macro_rules! proxy_ternary_slot {
+    ($vm_method:ident) => {
+        Some(|a, b, c, vm| proxy_ternary_op(a, b, c, vm, |vm, a, b, c| vm.$vm_method(a, b, c)))
+    };
+}
+
 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)
+                let obj = proxy_upgrade(number.obj, vm)?;
+                obj.is_true(vm)
+            }),
+            int: Some(|number, vm| {
+                let obj = proxy_upgrade(number.obj, vm)?;
+                obj.try_int(vm).map(Into::into)
+            }),
+            float: Some(|number, vm| {
+                let obj = proxy_upgrade(number.obj, vm)?;
+                obj.try_float(vm).map(Into::into)
+            }),
+            index: Some(|number, vm| {
+                let obj = proxy_upgrade(number.obj, vm)?;
+                obj.try_index(vm).map(Into::into)
             }),
-            ..PyNumberMethods::NOT_IMPLEMENTED
+            negative: proxy_unary_slot!(_neg),
+            positive: proxy_unary_slot!(_pos),
+            absolute: proxy_unary_slot!(_abs),
+            invert: proxy_unary_slot!(_invert),
+            add: proxy_binary_slot!(_add),
+            subtract: proxy_binary_slot!(_sub),
+            multiply: proxy_binary_slot!(_mul),
+            remainder: proxy_binary_slot!(_mod),
+            divmod: proxy_binary_slot!(_divmod),
+            lshift: proxy_binary_slot!(_lshift),
+            rshift: proxy_binary_slot!(_rshift),
+            and: proxy_binary_slot!(_and),
+            xor: proxy_binary_slot!(_xor),
+            or: proxy_binary_slot!(_or),
+            floor_divide: proxy_binary_slot!(_floordiv),
+            true_divide: proxy_binary_slot!(_truediv),
+            matrix_multiply: proxy_binary_slot!(_matmul),
+            inplace_add: proxy_binary_slot!(_iadd),
+            inplace_subtract: proxy_binary_slot!(_isub),
+            inplace_multiply: proxy_binary_slot!(_imul),
+            inplace_remainder: proxy_binary_slot!(_imod),
+            inplace_lshift: proxy_binary_slot!(_ilshift),
+            inplace_rshift: proxy_binary_slot!(_irshift),
+            inplace_and: proxy_binary_slot!(_iand),
+            inplace_xor: proxy_binary_slot!(_ixor),
+            inplace_or: proxy_binary_slot!(_ior),
+            inplace_floor_divide: proxy_binary_slot!(_ifloordiv),
+            inplace_true_divide: proxy_binary_slot!(_itruediv),
+            inplace_matrix_multiply: proxy_binary_slot!(_imatmul),
+            power: proxy_ternary_slot!(_pow),
+            inplace_power: proxy_ternary_slot!(_ipow),
         });
         &AS_NUMBER
     }
@@ -238,7 +352,7 @@ impl Representable for PyWeakProxy {
     }
 }
 
-pub fn init(context: &Context) {
+pub fn init(context: &'static Context) {
     PyWeakProxy::extend_class(context, context.types.weakproxy_type);
 }
 
diff --git a/crates/vm/src/builtins/weakref.rs b/crates/vm/src/builtins/weakref.rs
index 327c0fd1489..e1b9545252d 100644
--- a/crates/vm/src/builtins/weakref.rs
+++ b/crates/vm/src/builtins/weakref.rs
@@ -15,6 +15,7 @@ use crate::{
 pub use crate::object::PyWeak;
 
 #[derive(FromArgs)]
+#[allow(dead_code)]
 pub struct WeakNewArgs {
     #[pyarg(positional)]
     referent: PyObjectRef,
@@ -41,8 +42,20 @@ impl Constructor for PyWeak {
     type Args = WeakNewArgs;
 
     fn slot_new(cls: PyTypeRef, args: FuncArgs, vm: &VirtualMachine) -> PyResult {
-        let Self::Args { referent, callback } = args.bind(vm)?;
-        let weak = referent.downgrade_with_typ(callback.into_option(), cls, vm)?;
+        // PyArg_UnpackTuple: only process positional args, ignore kwargs.
+        // Subclass __init__ will handle extra kwargs.
+        let mut positional = args.args.into_iter();
+        let referent = positional
+            .next()
+            .ok_or_else(|| vm.new_type_error("__new__ expected at least 1 argument, got 0"))?;
+        let callback = positional.next();
+        if let Some(_extra) = positional.next() {
+            return Err(vm.new_type_error(format!(
+                "__new__ expected at most 2 arguments, got {}",
+                3 + positional.count()
+            )));
+        }
+        let weak = referent.downgrade_with_typ(callback, cls, vm)?;
         Ok(weak.into())
     }
 
@@ -140,6 +153,6 @@ impl Representable for PyWeak {
     }
 }
 
-pub fn init(context: &Context) {
+pub fn init(context: &'static Context) {
     PyWeak::extend_class(context, context.types.weakref_type);
 }
diff --git a/crates/vm/src/builtins/zip.rs b/crates/vm/src/builtins/zip.rs
index ee3ecb57b27..19c036e7951 100644
--- a/crates/vm/src/builtins/zip.rs
+++ b/crates/vm/src/builtins/zip.rs
@@ -113,6 +113,6 @@ impl IterNext for PyZip {
     }
 }
 
-pub fn init(ctx: &Context) {
+pub fn init(ctx: &'static Context) {
     PyZip::extend_class(ctx, ctx.types.zip_type);
 }
diff --git a/crates/vm/src/bytes_inner.rs b/crates/vm/src/bytes_inner.rs
index 7e1c1c2220c..6a1aa73c6b8 100644
--- a/crates/vm/src/bytes_inner.rs
+++ b/crates/vm/src/bytes_inner.rs
@@ -4,7 +4,7 @@ use crate::{
     anystr::{self, AnyStr, AnyStrContainer, AnyStrWrapper},
     builtins::{
         PyBaseExceptionRef, PyByteArray, PyBytes, PyBytesRef, PyInt, PyIntRef, PyStr, PyStrRef,
-        pystr,
+        pystr, pystr::PyUtf8StrRef,
     },
     byte::bytes_from_object,
     cformat::cformat_bytes,
@@ -45,16 +45,16 @@ pub struct ByteInnerNewOptions {
     #[pyarg(any, optional)]
     pub source: OptionalArg<PyObjectRef>,
     #[pyarg(any, optional)]
-    pub encoding: OptionalArg<PyStrRef>,
+    pub encoding: OptionalArg<PyUtf8StrRef>,
     #[pyarg(any, optional)]
-    pub errors: OptionalArg<PyStrRef>,
+    pub errors: OptionalArg<PyUtf8StrRef>,
 }
 
 impl ByteInnerNewOptions {
     fn get_value_from_string(
         s: PyStrRef,
-        encoding: PyStrRef,
-        errors: OptionalArg<PyStrRef>,
+        encoding: PyUtf8StrRef,
+        errors: OptionalArg<PyUtf8StrRef>,
         vm: &VirtualMachine,
     ) -> PyResult<PyBytesInner> {
         let bytes = pystr::encode_string(s, Some(encoding), errors.into_option(), vm)?;
@@ -237,6 +237,18 @@ impl PyBytesInner {
         vm.new_overflow_error("bytes object is too large to make repr")
     }
 
+    pub(crate) fn warn_on_str(message: &'static str, vm: &VirtualMachine) -> PyResult<()> {
+        if vm.state.config.settings.bytes_warning > 0 {
+            crate::stdlib::_warnings::warn(
+                vm.ctx.exceptions.bytes_warning,
+                message.to_owned(),
+                1,
+                vm,
+            )?;
+        }
+        Ok(())
+    }
+
     pub fn repr_with_name(&self, class_name: &str, vm: &VirtualMachine) -> PyResult<String> {
         const DECORATION_LEN: isize = 2 + 3; // 2 for (), 3 for b"" => bytearray(b"")
         let escape = crate::literal::escape::AsciiEscape::new_repr(&self.elements);
@@ -461,7 +473,7 @@ impl PyBytesInner {
 
         match invalid_char {
             None => Err(vm.new_value_error(
-                "fromhex() arg must contain an even number of hexadecimal digits".to_owned(),
+                "fromhex() arg must contain an even number of hexadecimal digits",
             )),
             Some(i) => Err(vm.new_value_error(format!(
                 "non-hexadecimal number found in fromhex() arg at position {i}"
@@ -474,9 +486,9 @@ impl PyBytesInner {
         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())
-            })?;
+            let borrowed = buffer
+                .as_contiguous()
+                .ok_or_else(|| vm.new_buffer_error("fromhex() requires a contiguous buffer"))?;
             Self::fromhex(&borrowed, vm)
         } else {
             Err(vm.new_type_error(format!(
@@ -1114,9 +1126,9 @@ impl AnyStr for [u8] {
 #[derive(FromArgs)]
 pub struct DecodeArgs {
     #[pyarg(any, default)]
-    encoding: Option<PyStrRef>,
+    encoding: Option<PyUtf8StrRef>,
     #[pyarg(any, default)]
-    errors: Option<PyStrRef>,
+    errors: Option<PyUtf8StrRef>,
 }
 
 pub fn bytes_decode(
@@ -1125,9 +1137,10 @@ pub fn bytes_decode(
     vm: &VirtualMachine,
 ) -> PyResult<PyStrRef> {
     let DecodeArgs { encoding, errors } = args;
-    let encoding = encoding
-        .as_ref()
-        .map_or(crate::codecs::DEFAULT_ENCODING, |s| s.as_str());
+    let encoding = match encoding.as_ref() {
+        None => crate::codecs::DEFAULT_ENCODING,
+        Some(e) => e.as_str(),
+    };
     vm.state
         .codec_registry
         .decode_text(zelf, encoding, errors, vm)
@@ -1205,7 +1218,7 @@ pub fn bytes_to_hex(
         let b_guard;
         let sep = match &sep {
             Either::A(s) => {
-                s_guard = s.as_str();
+                s_guard = s.as_wtf8();
                 s_guard.as_bytes()
             }
             Either::B(bytes) => {
diff --git a/crates/vm/src/cformat.rs b/crates/vm/src/cformat.rs
index 939b1c7760f..5421b21d416 100644
--- a/crates/vm/src/cformat.rs
+++ b/crates/vm/src/cformat.rs
@@ -28,7 +28,7 @@ fn spec_format_bytes(
             // Unlike strings, %r and %a are identical for bytes: the behaviour corresponds to
             // %a for strings (not %r)
             CFormatConversion::Repr | CFormatConversion::Ascii => {
-                let b = builtins::ascii(obj, vm)?.into();
+                let b = builtins::ascii(obj, vm)?.as_bytes().to_vec();
                 Ok(b)
             }
             CFormatConversion::Str | CFormatConversion::Bytes => {
@@ -132,7 +132,7 @@ fn spec_format_string(
     match &spec.format_type {
         CFormatType::String(conversion) => {
             let result = match conversion {
-                CFormatConversion::Ascii => builtins::ascii(obj, vm)?.into(),
+                CFormatConversion::Ascii => builtins::ascii(obj, vm)?.as_wtf8().to_owned(),
                 CFormatConversion::Str => obj.str(vm)?.as_wtf8().to_owned(),
                 CFormatConversion::Repr => obj.repr(vm)?.as_wtf8().to_owned(),
                 CFormatConversion::Bytes => {
diff --git a/crates/vm/src/class.rs b/crates/vm/src/class.rs
index a71baf070cd..237e11abbe5 100644
--- a/crates/vm/src/class.rs
+++ b/crates/vm/src/class.rs
@@ -131,7 +131,7 @@ pub trait PyClassDef {
 pub trait PyClassImpl: PyClassDef {
     const TP_FLAGS: PyTypeFlags = PyTypeFlags::DEFAULT;
 
-    fn extend_class(ctx: &Context, class: &'static Py<PyType>)
+    fn extend_class(ctx: &'static Context, class: &'static Py<PyType>)
     where
         Self: Sized,
     {
@@ -165,10 +165,17 @@ pub trait PyClassImpl: PyClassDef {
             }
         }
         if let Some(module_name) = Self::MODULE_NAME {
-            class.set_attr(
-                identifier!(ctx, __module__),
-                ctx.new_str(module_name).into(),
-            );
+            let module_key = identifier!(ctx, __module__);
+            // Don't overwrite a getset descriptor for __module__ (e.g. TypeAliasType
+            // has an instance-level __module__ getset that should not be replaced)
+            let has_getset = class
+                .attributes
+                .read()
+                .get(module_key)
+                .is_some_and(|v| v.downcastable::<crate::builtins::PyGetSet>());
+            if !has_getset {
+                class.set_attr(module_key, ctx.new_str(module_name).into());
+            }
         }
 
         // Don't add __new__ attribute if slot_new is inherited from object
@@ -181,11 +188,9 @@ pub trait PyClassImpl: PyClassDef {
                 && 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,
-                );
+                let bound_new =
+                    ctx.slot_new_wrapper
+                        .build_bound_method(ctx, class.to_owned().into(), class);
                 class.set_attr(identifier!(ctx, __new__), bound_new.into());
             }
         }
@@ -201,13 +206,13 @@ pub trait PyClassImpl: PyClassDef {
         class.extend_methods(class.slots.methods, ctx);
     }
 
-    fn make_class(ctx: &Context) -> PyTypeRef
+    fn make_static_type() -> PyTypeRef
     where
         Self: StaticType + Sized,
     {
         (*Self::static_cell().get_or_init(|| {
             let typ = Self::create_static_type();
-            Self::extend_class(ctx, unsafe {
+            Self::extend_class(Context::genesis(), unsafe {
                 // typ will be saved in static_cell
                 let r: &Py<PyType> = &typ;
                 let r: &'static Py<PyType> = core::mem::transmute(r);
@@ -218,7 +223,7 @@ pub trait PyClassImpl: PyClassDef {
         .to_owned()
     }
 
-    fn impl_extend_class(ctx: &Context, class: &'static Py<PyType>);
+    fn impl_extend_class(ctx: &'static Context, class: &'static Py<PyType>);
     const METHOD_DEFS: &'static [PyMethodDef];
     fn extend_slots(slots: &mut PyTypeSlots);
 
diff --git a/crates/vm/src/codecs.rs b/crates/vm/src/codecs.rs
index 3241dee4981..87c3a4a0a9d 100644
--- a/crates/vm/src/codecs.rs
+++ b/crates/vm/src/codecs.rs
@@ -8,17 +8,20 @@ use rustpython_common::{
     wtf8::{CodePoint, Wtf8, Wtf8Buf},
 };
 
+use crate::common::lock::OnceCell;
 use crate::{
-    AsObject, Context, Py, PyObject, PyObjectRef, PyPayload, PyResult, TryFromBorrowedObject,
-    TryFromObject, VirtualMachine,
-    builtins::{PyBaseExceptionRef, PyBytes, PyBytesRef, PyStr, PyStrRef, PyTuple, PyTupleRef},
+    AsObject, Context, Py, PyObject, PyObjectRef, PyResult, TryFromBorrowedObject, TryFromObject,
+    VirtualMachine,
+    builtins::{
+        PyBaseExceptionRef, PyBytes, PyBytesRef, PyStr, PyStrRef, PyTuple, PyTupleRef, PyUtf8Str,
+        PyUtf8StrRef,
+    },
     common::{ascii, lock::PyRwLock},
     convert::ToPyObject,
     function::{ArgBytesLike, PyMethodDef},
 };
 use alloc::borrow::Cow;
 use core::ops::{self, Range};
-use once_cell::unsync::OnceCell;
 use std::collections::HashMap;
 
 pub struct CodecsRegistry {
@@ -71,11 +74,11 @@ impl PyCodec {
     pub fn encode(
         &self,
         obj: PyObjectRef,
-        errors: Option<PyStrRef>,
+        errors: Option<PyUtf8StrRef>,
         vm: &VirtualMachine,
     ) -> PyResult {
         let args = match errors {
-            Some(errors) => vec![obj, errors.into()],
+            Some(errors) => vec![obj, errors.into_wtf8().into()],
             None => vec![obj],
         };
         let res = self.get_encode_func().call(args, vm)?;
@@ -91,11 +94,11 @@ impl PyCodec {
     pub fn decode(
         &self,
         obj: PyObjectRef,
-        errors: Option<PyStrRef>,
+        errors: Option<PyUtf8StrRef>,
         vm: &VirtualMachine,
     ) -> PyResult {
         let args = match errors {
-            Some(errors) => vec![obj, errors.into()],
+            Some(errors) => vec![obj, errors.into_wtf8().into()],
             None => vec![obj],
         };
         let res = self.get_decode_func().call(args, vm)?;
@@ -150,6 +153,16 @@ impl ToPyObject for PyCodec {
 }
 
 impl CodecsRegistry {
+    /// Reset the inner RwLock to unlocked state after fork().
+    ///
+    /// # Safety
+    /// Must only be called after fork() in the child process when no other
+    /// threads exist.
+    #[cfg(all(unix, feature = "threading"))]
+    pub(crate) unsafe fn reinit_after_fork(&self) {
+        unsafe { crate::common::lock::reinit_rwlock_after_fork(&self.inner) };
+    }
+
     pub(crate) fn new(ctx: &Context) -> Self {
         ::rustpython_vm::common::static_cell! {
             static METHODS: Box<[PyMethodDef]>;
@@ -220,10 +233,11 @@ impl CodecsRegistry {
     }
 
     pub(crate) fn register_manual(&self, name: &str, codec: PyCodec) -> PyResult<()> {
+        let name = normalize_encoding_name(name);
         self.inner
             .write()
             .search_cache
-            .insert(name.to_owned(), codec);
+            .insert(name.into_owned(), codec);
         Ok(())
     }
 
@@ -237,7 +251,7 @@ impl CodecsRegistry {
             }
             inner.search_path.clone()
         };
-        let encoding = PyStr::from(encoding.into_owned()).into_ref(&vm.ctx);
+        let encoding: PyUtf8StrRef = vm.ctx.new_utf8_str(encoding.as_ref());
         for func in search_path {
             let res = func.call((encoding.clone(),), vm)?;
             let res: Option<PyCodec> = res.try_into_value(vm)?;
@@ -279,39 +293,46 @@ impl CodecsRegistry {
         &self,
         obj: PyObjectRef,
         encoding: &str,
-        errors: Option<PyStrRef>,
+        errors: Option<PyUtf8StrRef>,
         vm: &VirtualMachine,
     ) -> PyResult {
         let codec = self.lookup(encoding, vm)?;
-        codec.encode(obj, errors, vm)
+        codec.encode(obj, errors, vm).inspect_err(|exc| {
+            Self::add_codec_note(exc, "encoding", encoding, vm);
+        })
     }
 
     pub fn decode(
         &self,
         obj: PyObjectRef,
         encoding: &str,
-        errors: Option<PyStrRef>,
+        errors: Option<PyUtf8StrRef>,
         vm: &VirtualMachine,
     ) -> PyResult {
         let codec = self.lookup(encoding, vm)?;
-        codec.decode(obj, errors, vm)
+        codec.decode(obj, errors, vm).inspect_err(|exc| {
+            Self::add_codec_note(exc, "decoding", encoding, vm);
+        })
     }
 
     pub fn encode_text(
         &self,
         obj: PyStrRef,
         encoding: &str,
-        errors: Option<PyStrRef>,
+        errors: Option<PyUtf8StrRef>,
         vm: &VirtualMachine,
     ) -> PyResult<PyBytesRef> {
         let codec = self._lookup_text_encoding(encoding, "codecs.encode()", vm)?;
         codec
-            .encode(obj.into(), errors, vm)?
+            .encode(obj.into(), errors, vm)
+            .inspect_err(|exc| {
+                Self::add_codec_note(exc, "encoding", encoding, vm);
+            })?
             .downcast()
             .map_err(|obj| {
                 vm.new_type_error(format!(
                     "'{}' encoder returned '{}' instead of 'bytes'; use codecs.encode() to \
-                     encode arbitrary types",
+                     encode to arbitrary types",
                     encoding,
                     obj.class().name(),
                 ))
@@ -322,24 +343,59 @@ impl CodecsRegistry {
         &self,
         obj: PyObjectRef,
         encoding: &str,
-        errors: Option<PyStrRef>,
+        errors: Option<PyUtf8StrRef>,
         vm: &VirtualMachine,
     ) -> PyResult<PyStrRef> {
         let codec = self._lookup_text_encoding(encoding, "codecs.decode()", vm)?;
-        codec.decode(obj, errors, vm)?.downcast().map_err(|obj| {
-            vm.new_type_error(format!(
-                "'{}' decoder returned '{}' instead of 'str'; use codecs.decode() \
-                 to encode arbitrary types",
-                encoding,
-                obj.class().name(),
-            ))
-        })
+        codec
+            .decode(obj, errors, vm)
+            .inspect_err(|exc| {
+                Self::add_codec_note(exc, "decoding", encoding, vm);
+            })?
+            .downcast()
+            .map_err(|obj| {
+                vm.new_type_error(format!(
+                    "'{}' decoder returned '{}' instead of 'str'; use codecs.decode() to \
+                 decode to arbitrary types",
+                    encoding,
+                    obj.class().name(),
+                ))
+            })
+    }
+
+    fn add_codec_note(
+        exc: &crate::builtins::PyBaseExceptionRef,
+        operation: &str,
+        encoding: &str,
+        vm: &VirtualMachine,
+    ) {
+        let note = format!("{operation} with '{encoding}' codec failed");
+        let _ = vm.call_method(exc.as_object(), "add_note", (vm.ctx.new_str(note),));
     }
 
     pub fn register_error(&self, name: String, handler: PyObjectRef) -> Option<PyObjectRef> {
         self.inner.write().errors.insert(name, handler)
     }
 
+    pub fn unregister_error(&self, name: &str, vm: &VirtualMachine) -> PyResult<bool> {
+        const BUILTIN_ERROR_HANDLERS: &[&str] = &[
+            "strict",
+            "ignore",
+            "replace",
+            "xmlcharrefreplace",
+            "backslashreplace",
+            "namereplace",
+            "surrogatepass",
+            "surrogateescape",
+        ];
+        if BUILTIN_ERROR_HANDLERS.contains(&name) {
+            return Err(vm.new_value_error(format!(
+                "cannot un-register built-in error handler '{name}'"
+            )));
+        }
+        Ok(self.inner.write().errors.remove(name).is_some())
+    }
+
     pub fn lookup_error_opt(&self, name: &str) -> Option<PyObjectRef> {
         self.inner.read().errors.get(name).cloned()
     }
@@ -351,19 +407,28 @@ impl CodecsRegistry {
 }
 
 fn normalize_encoding_name(encoding: &str) -> Cow<'_, str> {
-    if let Some(i) = encoding.find(|c: char| c == ' ' || c.is_ascii_uppercase()) {
-        let mut out = encoding.as_bytes().to_owned();
-        for byte in &mut out[i..] {
-            if *byte == b' ' {
-                *byte = b'-';
-            } else {
-                byte.make_ascii_lowercase();
+    // _Py_normalize_encoding: collapse non-alphanumeric/non-dot chars into
+    // single underscore, strip non-ASCII, lowercase ASCII letters.
+    let needs_transform = encoding
+        .bytes()
+        .any(|b| b.is_ascii_uppercase() || !b.is_ascii_alphanumeric() && b != b'.');
+    if !needs_transform {
+        return encoding.into();
+    }
+    let mut out = String::with_capacity(encoding.len());
+    let mut punct = false;
+    for c in encoding.chars() {
+        if c.is_ascii_alphanumeric() || c == '.' {
+            if punct && !out.is_empty() {
+                out.push('_');
             }
+            out.push(c.to_ascii_lowercase());
+            punct = false;
+        } else {
+            punct = true;
         }
-        String::from_utf8(out).unwrap().into()
-    } else {
-        encoding.into()
     }
+    out.into()
 }
 
 #[derive(Eq, PartialEq)]
@@ -416,7 +481,7 @@ impl StandardEncoding {
             } else {
                 None
             }
-        } else if encoding == "CP_UTF8" {
+        } else if encoding == "cp65001" {
             Some(Self::Utf8)
         } else {
             None
@@ -476,7 +541,7 @@ impl<'a> DecodeErrorHandler<PyDecodeContext<'a>> for SurrogatePass {
         let p = &s[byte_range.start..];
 
         fn slice<const N: usize>(p: &[u8]) -> Option<[u8; N]> {
-            p.get(..N).map(|x| x.try_into().unwrap())
+            p.first_chunk().copied()
         }
 
         let c = match standard_encoding {
@@ -791,7 +856,7 @@ impl<'a> DecodeErrorHandler<PyDecodeContext<'a>> for StandardError {
 }
 
 pub struct ErrorsHandler<'a> {
-    errors: &'a Py<PyStr>,
+    errors: &'a Py<PyUtf8Str>,
     resolved: OnceCell<ResolvedError>,
 }
 enum ResolvedError {
@@ -801,30 +866,34 @@ enum ResolvedError {
 
 impl<'a> ErrorsHandler<'a> {
     #[inline]
-    pub fn new(errors: Option<&'a Py<PyStr>>, vm: &VirtualMachine) -> Self {
+    pub fn new(errors: Option<&'a Py<PyUtf8Str>>, vm: &VirtualMachine) -> Self {
         match errors {
             Some(errors) => Self {
                 errors,
                 resolved: OnceCell::new(),
             },
             None => Self {
-                errors: identifier!(vm, strict).as_ref(),
-                resolved: OnceCell::with_value(ResolvedError::Standard(StandardError::Strict)),
+                errors: identifier_utf8!(vm, strict),
+                resolved: OnceCell::from(ResolvedError::Standard(StandardError::Strict)),
             },
         }
     }
     #[inline]
     fn resolve(&self, vm: &VirtualMachine) -> PyResult<&ResolvedError> {
-        self.resolved.get_or_try_init(|| {
-            if let Ok(standard) = self.errors.as_str().parse() {
-                Ok(ResolvedError::Standard(standard))
-            } else {
-                vm.state
-                    .codec_registry
-                    .lookup_error(self.errors.as_str(), vm)
-                    .map(ResolvedError::Handler)
-            }
-        })
+        if let Some(val) = self.resolved.get() {
+            return Ok(val);
+        }
+        let errors_str = self.errors.as_str();
+        let val = if let Ok(standard) = errors_str.parse() {
+            ResolvedError::Standard(standard)
+        } else {
+            vm.state
+                .codec_registry
+                .lookup_error(errors_str, vm)
+                .map(ResolvedError::Handler)?
+        };
+        let _ = self.resolved.set(val);
+        Ok(self.resolved.get().unwrap())
     }
 }
 impl StrBuffer for PyStrRef {
@@ -940,13 +1009,13 @@ where
     // let err = err.
     let range = extract_unicode_error_range(&err, vm)?;
     let s = PyStrRef::try_from_object(vm, err.get_attr("object", vm)?)?;
-    let s_encoding = PyStrRef::try_from_object(vm, err.get_attr("encoding", vm)?)?;
+    let s_encoding = PyUtf8StrRef::try_from_object(vm, err.get_attr("encoding", vm)?)?;
     let mut ctx = PyEncodeContext {
         vm,
         encoding: s_encoding.as_str(),
         data: &s,
         pos: StrSize::default(),
-        exception: OnceCell::with_value(err.downcast().unwrap()),
+        exception: OnceCell::from(err.downcast().unwrap()),
     };
     let mut iter = s.as_wtf8().code_point_indices();
     let start = StrSize {
@@ -979,14 +1048,14 @@ where
 {
     let range = extract_unicode_error_range(&err, vm)?;
     let s = ArgBytesLike::try_from_object(vm, err.get_attr("object", vm)?)?;
-    let s_encoding = PyStrRef::try_from_object(vm, err.get_attr("encoding", vm)?)?;
+    let s_encoding = PyUtf8StrRef::try_from_object(vm, err.get_attr("encoding", vm)?)?;
     let mut ctx = PyDecodeContext {
         vm,
         encoding: s_encoding.as_str(),
         data: PyDecodeData::Original(s.borrow_buf()),
         orig_bytes: s.as_object().downcast_ref(),
         pos: 0,
-        exception: OnceCell::with_value(err.downcast().unwrap()),
+        exception: OnceCell::from(err.downcast().unwrap()),
     };
     let (replace, restart) = handler.handle_decode_error(&mut ctx, range, None)?;
     Ok((replace.into(), restart))
@@ -1009,7 +1078,7 @@ where
         encoding: "",
         data: &s,
         pos: StrSize::default(),
-        exception: OnceCell::with_value(err.downcast().unwrap()),
+        exception: OnceCell::from(err.downcast().unwrap()),
     };
     let mut iter = s.as_wtf8().code_point_indices();
     let start = StrSize {
diff --git a/crates/vm/src/convert/try_from.rs b/crates/vm/src/convert/try_from.rs
index ceb7d003e9b..85d6f5e20e3 100644
--- a/crates/vm/src/convert/try_from.rs
+++ b/crates/vm/src/convert/try_from.rs
@@ -126,10 +126,21 @@ 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();
+            if f.is_nan() {
+                return Err(vm.new_value_error("Invalid value NaN (not a number)"));
+            }
             if f < 0.0 {
                 return Err(vm.new_value_error("negative duration"));
             }
-            Ok(Self::from_secs_f64(f))
+            if !f.is_finite() || f > u64::MAX as f64 {
+                return Err(vm.new_overflow_error("timestamp too large to convert to C PyTime_t"));
+            }
+            // Convert float to Duration using floor rounding (_PyTime_ROUND_FLOOR)
+            let secs = f.trunc() as u64;
+            let frac = f.fract();
+            // Use floor to round down the nanoseconds
+            let nanos = (frac * 1_000_000_000.0).floor() as u32;
+            Ok(Self::new(secs, nanos))
         } else if let Some(int) = obj.try_index_opt(vm) {
             let int = int?;
             let bigint = int.as_bigint();
diff --git a/crates/vm/src/coroutine.rs b/crates/vm/src/coroutine.rs
index 236388ecf8b..07158c48859 100644
--- a/crates/vm/src/coroutine.rs
+++ b/crates/vm/src/coroutine.rs
@@ -1,11 +1,11 @@
 use crate::{
-    AsObject, Py, PyObject, PyObjectRef, PyResult, VirtualMachine,
-    builtins::{PyBaseExceptionRef, PyStrRef},
+    AsObject, Py, PyObject, PyObjectRef, PyResult, TryFromObject, VirtualMachine,
+    builtins::PyStrRef,
     common::lock::PyMutex,
     exceptions::types::PyBaseException,
-    frame::{ExecutionResult, FrameRef},
+    frame::{ExecutionResult, Frame, FrameOwner, FrameRef},
     function::OptionalArg,
-    object::{Traverse, TraverseFn},
+    object::{PyAtomicRef, Traverse, TraverseFn},
     protocol::PyIterReturn,
 };
 use crossbeam_utils::atomic::AtomicCell;
@@ -36,7 +36,7 @@ pub struct Coro {
     // _weakreflist
     name: PyMutex<PyStrRef>,
     qualname: PyMutex<PyStrRef>,
-    exception: PyMutex<Option<PyBaseExceptionRef>>, // exc_state
+    exception: PyAtomicRef<Option<PyBaseException>>, // exc_state
 }
 
 unsafe impl Traverse for Coro {
@@ -44,7 +44,9 @@ unsafe impl Traverse for Coro {
         self.frame.traverse(tracer_fn);
         self.name.traverse(tracer_fn);
         self.qualname.traverse(tracer_fn);
-        self.exception.traverse(tracer_fn);
+        if let Some(exc) = self.exception.deref() {
+            exc.traverse(tracer_fn);
+        }
     }
 }
 
@@ -65,7 +67,7 @@ impl Coro {
             frame,
             closed: AtomicCell::new(false),
             running: AtomicCell::new(false),
-            exception: PyMutex::default(),
+            exception: PyAtomicRef::from(None),
             name: PyMutex::new(name),
             qualname: PyMutex::new(qualname),
         }
@@ -73,7 +75,14 @@ impl Coro {
 
     fn maybe_close(&self, res: &PyResult<ExecutionResult>) {
         match res {
-            Ok(ExecutionResult::Return(_)) | Err(_) => self.closed.store(true),
+            Ok(ExecutionResult::Return(_)) | Err(_) => {
+                self.closed.store(true);
+                // Frame is no longer suspended; allow frame.clear() to succeed.
+                self.frame.owner.store(
+                    FrameOwner::FrameObject as i8,
+                    core::sync::atomic::Ordering::Release,
+                );
+            }
             Ok(ExecutionResult::Yield(_)) => {}
         }
     }
@@ -85,33 +94,20 @@ impl Coro {
         func: F,
     ) -> PyResult<ExecutionResult>
     where
-        F: FnOnce(FrameRef) -> PyResult<ExecutionResult>,
+        F: FnOnce(&Py<Frame>) -> PyResult<ExecutionResult>,
     {
         if self.running.compare_exchange(false, true).is_err() {
             return Err(vm.new_value_error(format!("{} already executing", gen_name(jen, vm))));
         }
 
-        // swap exception state
-        // Get generator's saved exception state from last yield
-        let gen_exc = self.exception.lock().take();
-
-        // Use a slot to capture generator's exception state before with_frame pops
-        let exception_slot = &self.exception;
+        // SAFETY: running.compare_exchange guarantees exclusive access
+        let gen_exc = unsafe { self.exception.swap(None) };
+        let exception_ptr = &self.exception as *const PyAtomicRef<Option<PyBaseException>>;
 
-        // 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 = vm.resume_gen_frame(&self.frame, gen_exc, |f| {
             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();
+            // SAFETY: exclusive access guaranteed by running flag
+            let _old = unsafe { (*exception_ptr).swap(vm.current_exception()) };
             result
         });
 
@@ -119,26 +115,12 @@ impl Coro {
         result
     }
 
-    pub fn send(
+    fn finalize_send_result(
         &self,
         jen: &PyObject,
-        value: PyObjectRef,
+        result: PyResult<ExecutionResult>,
         vm: &VirtualMachine,
     ) -> PyResult<PyIterReturn> {
-        if self.closed.load() {
-            return Ok(PyIterReturn::StopIteration(None));
-        }
-        let value = if self.frame.lasti() > 0 {
-            Some(value)
-        } else if !vm.is_none(&value) {
-            return Err(vm.new_type_error(format!(
-                "can't send non-None value to a just-started {}",
-                gen_name(jen, vm),
-            )));
-        } else {
-            None
-        };
-        let result = self.run_with_context(jen, vm, |f| f.resume(value, vm));
         self.maybe_close(&result);
         match result {
             Ok(exec_res) => Ok(exec_res.into_iter_return(vm)),
@@ -161,6 +143,44 @@ impl Coro {
         }
     }
 
+    pub(crate) fn send_none(&self, jen: &PyObject, vm: &VirtualMachine) -> PyResult<PyIterReturn> {
+        if self.closed.load() {
+            return Ok(PyIterReturn::StopIteration(None));
+        }
+        self.frame.locals_to_fast(vm)?;
+        let value = if self.frame.lasti() > 0 {
+            Some(vm.ctx.none())
+        } else {
+            None
+        };
+        let result = self.run_with_context(jen, vm, |f| f.resume(value, vm));
+        self.finalize_send_result(jen, result, vm)
+    }
+
+    pub fn send(
+        &self,
+        jen: &PyObject,
+        value: PyObjectRef,
+        vm: &VirtualMachine,
+    ) -> PyResult<PyIterReturn> {
+        if self.closed.load() {
+            return Ok(PyIterReturn::StopIteration(None));
+        }
+        self.frame.locals_to_fast(vm)?;
+        let value = if self.frame.lasti() > 0 {
+            Some(value)
+        } else if !vm.is_none(&value) {
+            return Err(vm.new_type_error(format!(
+                "can't send non-None value to a just-started {}",
+                gen_name(jen, vm),
+            )));
+        } else {
+            None
+        };
+        let result = self.run_with_context(jen, vm, |f| f.resume(value, vm));
+        self.finalize_send_result(jen, result, vm)
+    }
+
     pub fn throw(
         &self,
         jen: &PyObject,
@@ -169,22 +189,33 @@ impl Coro {
         exc_tb: PyObjectRef,
         vm: &VirtualMachine,
     ) -> PyResult<PyIterReturn> {
+        // Validate throw arguments (_gen_throw)
+        if exc_type.fast_isinstance(vm.ctx.exceptions.base_exception_type) && !vm.is_none(&exc_val)
+        {
+            return Err(vm.new_type_error("instance exception may not have a separate value"));
+        }
+        if !vm.is_none(&exc_tb) && !exc_tb.fast_isinstance(vm.ctx.types.traceback_type) {
+            return Err(vm.new_type_error("throw() third argument must be a traceback object"));
+        }
         if self.closed.load() {
             return Err(vm.normalize_exception(exc_type, exc_val, exc_tb)?);
         }
+        // Validate exception type before entering generator context.
+        // Invalid types propagate to caller without closing the generator.
+        crate::exceptions::ExceptionCtor::try_from_object(vm, exc_type.clone())?;
         let result = self.run_with_context(jen, vm, |f| f.gen_throw(vm, exc_type, exc_val, exc_tb));
         self.maybe_close(&result);
         Ok(result?.into_iter_return(vm))
     }
 
-    pub fn close(&self, jen: &PyObject, vm: &VirtualMachine) -> PyResult<()> {
+    pub fn close(&self, jen: &PyObject, vm: &VirtualMachine) -> PyResult<PyObjectRef> {
         if self.closed.load() {
-            return Ok(());
+            return Ok(vm.ctx.none());
         }
         // If generator hasn't started (FRAME_CREATED), just mark as closed
         if self.frame.lasti() == 0 {
             self.closed.store(true);
-            return Ok(());
+            return Ok(vm.ctx.none());
         }
         let result = self.run_with_context(jen, vm, |f| {
             f.gen_throw(
@@ -195,15 +226,23 @@ impl Coro {
             )
         });
         self.closed.store(true);
+        // Release frame locals and stack to free references held by the
+        // closed generator, matching gen_send_ex2 with close_on_completion.
+        self.frame.clear_locals_and_stack();
         match result {
             Ok(ExecutionResult::Yield(_)) => {
                 Err(vm.new_runtime_error(format!("{} ignored GeneratorExit", gen_name(jen, vm))))
             }
             Err(e) if !is_gen_exit(&e, vm) => Err(e),
-            _ => Ok(()),
+            Ok(ExecutionResult::Return(value)) => Ok(value),
+            _ => Ok(vm.ctx.none()),
         }
     }
 
+    pub fn suspended(&self) -> bool {
+        !self.closed.load() && !self.running.load() && self.frame.lasti() > 0
+    }
+
     pub fn running(&self) -> bool {
         self.running.load()
     }
@@ -233,10 +272,11 @@ impl Coro {
     }
 
     pub fn repr(&self, jen: &PyObject, id: usize, vm: &VirtualMachine) -> String {
+        let qualname = self.qualname();
         format!(
             "<{} object {} at {:#x}>",
             gen_name(jen, vm),
-            self.name.lock(),
+            qualname.as_wtf8(),
             id
         )
     }
@@ -246,6 +286,52 @@ pub fn is_gen_exit(exc: &Py<PyBaseException>, vm: &VirtualMachine) -> bool {
     exc.fast_isinstance(vm.ctx.exceptions.generator_exit)
 }
 
+/// Get an awaitable iterator from an object.
+///
+/// Returns the object itself if it's a coroutine or iterable coroutine (generator with
+/// CO_ITERABLE_COROUTINE flag). Otherwise calls `__await__()` and validates the result.
+pub fn get_awaitable_iter(obj: PyObjectRef, vm: &VirtualMachine) -> PyResult {
+    use crate::builtins::{PyCoroutine, PyGenerator};
+    use crate::protocol::PyIter;
+
+    if obj.downcastable::<PyCoroutine>()
+        || obj.downcast_ref::<PyGenerator>().is_some_and(|g| {
+            g.as_coro()
+                .frame()
+                .code
+                .flags
+                .contains(crate::bytecode::CodeFlags::ITERABLE_COROUTINE)
+        })
+    {
+        return Ok(obj);
+    }
+
+    if let Some(await_method) = vm.get_method(obj.clone(), identifier!(vm, __await__)) {
+        let result = await_method?.call((), vm)?;
+        // __await__() must NOT return a coroutine (PEP 492)
+        if result.downcastable::<PyCoroutine>()
+            || result.downcast_ref::<PyGenerator>().is_some_and(|g| {
+                g.as_coro()
+                    .frame()
+                    .code
+                    .flags
+                    .contains(crate::bytecode::CodeFlags::ITERABLE_COROUTINE)
+            })
+        {
+            return Err(vm.new_type_error("__await__() returned a coroutine"));
+        }
+        if !PyIter::check(&result) {
+            return Err(vm.new_type_error(format!(
+                "__await__() returned non-iterator of type '{}'",
+                result.class().name()
+            )));
+        }
+        return Ok(result);
+    }
+
+    Err(vm.new_type_error(format!("'{}' object can't be awaited", obj.class().name())))
+}
+
 /// Emit DeprecationWarning for the deprecated 3-argument throw() signature.
 pub fn warn_deprecated_throw_signature(
     exc_val: &OptionalArg,
@@ -254,10 +340,12 @@ pub fn warn_deprecated_throw_signature(
 ) -> 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, \
+            vm.ctx
+                .new_str(
+                    "the (type, val, tb) signature of throw() is deprecated, \
                  use throw(val) instead",
-            ),
+                )
+                .into(),
             Some(vm.ctx.exceptions.deprecation_warning.to_owned()),
             1,
             None,
diff --git a/crates/vm/src/datastack.rs b/crates/vm/src/datastack.rs
new file mode 100644
index 00000000000..b00f1b6dc19
--- /dev/null
+++ b/crates/vm/src/datastack.rs
@@ -0,0 +1,256 @@
+/// Thread data stack for interpreter frames (`_PyStackChunk` /
+/// `tstate->datastack_*`).
+///
+/// A linked list of chunks providing bump allocation for frame-local data
+/// (localsplus arrays).  Normal function calls allocate via `push()`
+/// (pointer bump).  Generators and coroutines use heap-allocated storage.
+use alloc::alloc::{alloc, dealloc};
+use core::alloc::Layout;
+use core::ptr;
+
+/// Minimum chunk size in bytes (`_PY_DATA_STACK_CHUNK_SIZE`).
+const MIN_CHUNK_SIZE: usize = 16 * 1024;
+
+/// Extra headroom (in bytes) to avoid allocating a new chunk for the next
+/// frame right after growing.
+const MINIMUM_OVERHEAD: usize = 1000 * core::mem::size_of::<usize>();
+
+/// Alignment for all data stack allocations.
+const ALIGN: usize = 16;
+
+/// Header for a data stack chunk.  The usable data region starts right after
+/// this header (aligned to `ALIGN`).
+#[repr(C)]
+struct DataStackChunk {
+    /// Previous chunk in the linked list (NULL for the root chunk).
+    previous: *mut DataStackChunk,
+    /// Total allocation size in bytes (including this header).
+    size: usize,
+    /// Saved `top` offset when a newer chunk was pushed.  Used to restore
+    /// `DataStack::top` when popping back to this chunk.
+    saved_top: usize,
+}
+
+impl DataStackChunk {
+    /// Pointer to the first usable byte after the header (aligned).
+    #[inline(always)]
+    fn data_start(&self) -> *mut u8 {
+        let header_end = (self as *const Self as usize) + core::mem::size_of::<Self>();
+        let aligned = (header_end + ALIGN - 1) & !(ALIGN - 1);
+        aligned as *mut u8
+    }
+
+    /// Pointer past the last usable byte.
+    #[inline(always)]
+    fn data_limit(&self) -> *mut u8 {
+        unsafe { (self as *const Self as *mut u8).add(self.size) }
+    }
+}
+
+/// Per-thread data stack for bump-allocating frame-local data.
+pub struct DataStack {
+    /// Current chunk.
+    chunk: *mut DataStackChunk,
+    /// Current allocation position within the current chunk.
+    top: *mut u8,
+    /// End of usable space in the current chunk.
+    limit: *mut u8,
+}
+
+impl DataStack {
+    /// Create a new data stack with an initial root chunk.
+    pub fn new() -> Self {
+        let chunk = Self::alloc_chunk(MIN_CHUNK_SIZE, ptr::null_mut());
+        let top = unsafe { (*chunk).data_start() };
+        let limit = unsafe { (*chunk).data_limit() };
+        // Skip one ALIGN-sized slot in the root chunk so that `pop()` never
+        // frees it (`push_chunk` convention).
+        let top = unsafe { top.add(ALIGN) };
+        Self { chunk, top, limit }
+    }
+
+    /// Check if the current chunk has at least `size` bytes available.
+    #[inline(always)]
+    pub fn has_space(&self, size: usize) -> bool {
+        let aligned_size = (size + ALIGN - 1) & !(ALIGN - 1);
+        (self.limit as usize).saturating_sub(self.top as usize) >= aligned_size
+    }
+
+    /// Allocate `size` bytes from the data stack.
+    ///
+    /// Returns a pointer to the allocated region (aligned to `ALIGN`).
+    /// The caller must call `pop()` with the returned pointer when done
+    /// (LIFO order).
+    #[inline(always)]
+    pub fn push(&mut self, size: usize) -> *mut u8 {
+        let aligned_size = (size + ALIGN - 1) & !(ALIGN - 1);
+        unsafe {
+            if self.top.add(aligned_size) <= self.limit {
+                let ptr = self.top;
+                self.top = self.top.add(aligned_size);
+                ptr
+            } else {
+                self.push_slow(aligned_size)
+            }
+        }
+    }
+
+    /// Slow path: allocate a new chunk and push from it.
+    #[cold]
+    #[inline(never)]
+    fn push_slow(&mut self, aligned_size: usize) -> *mut u8 {
+        let mut chunk_size = MIN_CHUNK_SIZE;
+        let needed = aligned_size
+            .checked_add(MINIMUM_OVERHEAD)
+            .and_then(|v| v.checked_add(core::mem::size_of::<DataStackChunk>()))
+            .and_then(|v| v.checked_add(ALIGN))
+            .expect("DataStack chunk size overflow");
+        while chunk_size < needed {
+            chunk_size = chunk_size
+                .checked_mul(2)
+                .expect("DataStack chunk size overflow");
+        }
+        // Save current position in old chunk.
+        unsafe {
+            (*self.chunk).saved_top = self.top as usize - self.chunk as usize;
+        }
+        let new_chunk = Self::alloc_chunk(chunk_size, self.chunk);
+        self.chunk = new_chunk;
+        let start = unsafe { (*new_chunk).data_start() };
+        self.limit = unsafe { (*new_chunk).data_limit() };
+        self.top = unsafe { start.add(aligned_size) };
+        start
+    }
+
+    /// Pop a previous allocation.  `base` must be the pointer returned by
+    /// `push()`.  Calls must be in LIFO order.
+    ///
+    /// # Safety
+    /// `base` must be a valid pointer returned by `push()` on this data stack,
+    /// and all allocations made after it must already have been popped.
+    #[inline(always)]
+    pub unsafe fn pop(&mut self, base: *mut u8) {
+        debug_assert!(!base.is_null());
+        if self.is_in_current_chunk(base) {
+            // Common case: base is within the current chunk.
+            self.top = base;
+        } else {
+            // base is in a previous chunk — free the current chunk.
+            unsafe { self.pop_slow(base) };
+        }
+    }
+
+    /// Check if `ptr` falls within the current chunk's data area.
+    /// Both bounds are checked to handle non-monotonic allocation addresses
+    /// (e.g. on Windows where newer chunks may be at lower addresses).
+    #[inline(always)]
+    fn is_in_current_chunk(&self, ptr: *mut u8) -> bool {
+        let chunk_start = unsafe { (*self.chunk).data_start() };
+        ptr >= chunk_start && ptr <= self.limit
+    }
+
+    /// Slow path: pop back to a previous chunk.
+    #[cold]
+    #[inline(never)]
+    unsafe fn pop_slow(&mut self, base: *mut u8) {
+        loop {
+            let old_chunk = self.chunk;
+            let prev = unsafe { (*old_chunk).previous };
+            debug_assert!(!prev.is_null(), "tried to pop past the root chunk");
+            unsafe { Self::free_chunk(old_chunk) };
+            self.chunk = prev;
+            self.limit = unsafe { (*prev).data_limit() };
+            if self.is_in_current_chunk(base) {
+                self.top = base;
+                return;
+            }
+        }
+    }
+
+    /// Allocate a new chunk.
+    fn alloc_chunk(size: usize, previous: *mut DataStackChunk) -> *mut DataStackChunk {
+        let layout = Layout::from_size_align(size, ALIGN).expect("invalid chunk layout");
+        let ptr = unsafe { alloc(layout) };
+        if ptr.is_null() {
+            alloc::alloc::handle_alloc_error(layout);
+        }
+        let chunk = ptr as *mut DataStackChunk;
+        unsafe {
+            (*chunk).previous = previous;
+            (*chunk).size = size;
+            (*chunk).saved_top = 0;
+        }
+        chunk
+    }
+
+    /// Free a chunk.
+    unsafe fn free_chunk(chunk: *mut DataStackChunk) {
+        let size = unsafe { (*chunk).size };
+        let layout = Layout::from_size_align(size, ALIGN).expect("invalid chunk layout");
+        unsafe { dealloc(chunk as *mut u8, layout) };
+    }
+}
+
+// SAFETY: DataStack is per-thread and not shared.  The raw pointers
+// it contains point to memory exclusively owned by this DataStack.
+unsafe impl Send for DataStack {}
+
+impl Default for DataStack {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl Drop for DataStack {
+    fn drop(&mut self) {
+        let mut chunk = self.chunk;
+        while !chunk.is_null() {
+            let prev = unsafe { (*chunk).previous };
+            unsafe { Self::free_chunk(chunk) };
+            chunk = prev;
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn basic_push_pop() {
+        let mut ds = DataStack::new();
+        let p1 = ds.push(64);
+        assert!(!p1.is_null());
+        let p2 = ds.push(128);
+        assert!(!p2.is_null());
+        assert!(p2 > p1);
+        unsafe {
+            ds.pop(p2);
+            ds.pop(p1);
+        }
+    }
+
+    #[test]
+    fn cross_chunk_push_pop() {
+        let mut ds = DataStack::new();
+        // Push enough to force a new chunk
+        let mut ptrs = Vec::new();
+        for _ in 0..100 {
+            ptrs.push(ds.push(1024));
+        }
+        // Pop all in reverse
+        for p in ptrs.into_iter().rev() {
+            unsafe { ds.pop(p) };
+        }
+    }
+
+    #[test]
+    fn alignment() {
+        let mut ds = DataStack::new();
+        for size in [1, 7, 15, 16, 17, 31, 32, 33, 64, 100] {
+            let p = ds.push(size);
+            assert_eq!(p as usize % ALIGN, 0, "alignment violated for size {size}");
+            unsafe { ds.pop(p) };
+        }
+    }
+}
diff --git a/crates/vm/src/dict_inner.rs b/crates/vm/src/dict_inner.rs
index f2a379d99a5..763fa856319 100644
--- a/crates/vm/src/dict_inner.rs
+++ b/crates/vm/src/dict_inner.rs
@@ -5,7 +5,7 @@
 
 use crate::{
     AsObject, Py, PyExact, PyObject, PyObjectRef, PyRefExact, PyResult, VirtualMachine,
-    builtins::{PyBytes, PyInt, PyStr, PyStrInterned, PyStrRef},
+    builtins::{PyBytes, PyInt, PyStr, PyStrInterned, PyStrRef, PyUtf8Str, PyUtf8StrRef},
     convert::ToPyObject,
 };
 use crate::{
@@ -17,7 +17,12 @@ use crate::{
     object::{Traverse, TraverseFn},
 };
 use alloc::fmt;
-use core::{mem::size_of, ops::ControlFlow};
+use core::mem::size_of;
+use core::ops::ControlFlow;
+use core::sync::atomic::{
+    AtomicU64,
+    Ordering::{Acquire, Release},
+};
 use num_traits::ToPrimitive;
 
 // HashIndex is intended to be same size with hash::PyHash
@@ -34,6 +39,7 @@ type EntryIndex = usize;
 
 pub struct Dict<T = PyObjectRef> {
     inner: PyRwLock<DictInner<T>>,
+    version: AtomicU64,
 }
 
 unsafe impl<T: Traverse> Traverse for Dict<T> {
@@ -98,6 +104,7 @@ impl<T: Clone> Clone for Dict<T> {
     fn clone(&self) -> Self {
         Self {
             inner: PyRwLock::new(self.inner.read().clone()),
+            version: AtomicU64::new(0),
         }
     }
 }
@@ -111,6 +118,7 @@ impl<T> Default for Dict<T> {
                 indices: vec![IndexEntry::FREE; 8],
                 entries: Vec::new(),
             }),
+            version: AtomicU64::new(0),
         }
     }
 }
@@ -254,6 +262,16 @@ impl<T> DictInner<T> {
 type PopInnerResult<T> = ControlFlow<Option<DictEntry<T>>>;
 
 impl<T: Clone> Dict<T> {
+    /// Monotonically increasing version counter for mutation tracking.
+    pub fn version(&self) -> u64 {
+        self.version.load(Acquire)
+    }
+
+    /// Bump the version counter after any mutation.
+    fn bump_version(&self) {
+        self.version.fetch_add(1, Release);
+    }
+
     fn read(&self) -> PyRwLockReadGuard<'_, DictInner<T>> {
         self.inner.read()
     }
@@ -283,6 +301,7 @@ impl<T: Clone> Dict<T> {
                     };
                     if entry.index == index_index {
                         let removed = core::mem::replace(&mut entry.value, value);
+                        self.bump_version();
                         // defer dec RC
                         break Some(removed);
                     } else {
@@ -292,8 +311,13 @@ impl<T: Clone> Dict<T> {
                     // The dict was changed since we did lookup. Let's try again.
                 }
             } else {
-                // New key:
+                // New key - validate slot is still what lookup found
+                if inner.indices.get(index_index) != Some(&entry_index) {
+                    // Dict was resized since lookup, retry
+                    continue;
+                }
                 inner.unchecked_push(index_index, hash, key.to_pyobject(vm), value, entry_index);
+                self.bump_version();
                 break None;
             }
         };
@@ -313,6 +337,50 @@ impl<T: Clone> Dict<T> {
         self._get_inner(vm, key, hash)
     }
 
+    /// Return a stable entry hint for `key` if present.
+    ///
+    /// The hint is the internal entry index and can be used with
+    /// [`Self::get_hint`]. It is invalidated by dict mutations.
+    pub fn hint_for_key<K: DictKey + ?Sized>(
+        &self,
+        vm: &VirtualMachine,
+        key: &K,
+    ) -> PyResult<Option<u16>> {
+        let hash = key.key_hash(vm)?;
+        let (entry, _) = self.lookup(vm, key, hash, None)?;
+        let Some(index) = entry.index() else {
+            return Ok(None);
+        };
+        Ok(u16::try_from(index).ok())
+    }
+
+    /// Fast path lookup using a cached entry index (`hint`).
+    ///
+    /// Returns `None` if the hint is stale or the key no longer matches.
+    pub fn get_hint<K: DictKey + ?Sized>(
+        &self,
+        vm: &VirtualMachine,
+        key: &K,
+        hint: usize,
+    ) -> PyResult<Option<T>> {
+        let (entry_key, entry_value) = {
+            let inner = self.read();
+            let Some(Some(entry)) = inner.entries.get(hint) else {
+                return Ok(None);
+            };
+            if key.key_is(&entry.key) {
+                return Ok(Some(entry.value.clone()));
+            }
+            (entry.key.clone(), entry.value.clone())
+        };
+        // key_eq may run Python __eq__, so must be outside the lock.
+        if key.key_eq(vm, &entry_key)? {
+            Ok(Some(entry_value))
+        } else {
+            Ok(None)
+        }
+    }
+
     fn _get_inner<K: DictKey + ?Sized>(
         &self,
         vm: &VirtualMachine,
@@ -357,6 +425,7 @@ impl<T: Clone> Dict<T> {
             inner.indices.resize(8, IndexEntry::FREE);
             inner.used = 0;
             inner.filled = 0;
+            self.bump_version();
             // defer dec rc
             core::mem::take(&mut inner.entries)
         };
@@ -431,7 +500,11 @@ impl<T: Clone> Dict<T> {
                 }
             } else {
                 let mut inner = self.write();
+                if inner.indices.get(index_index) != Some(&entry) {
+                    continue;
+                }
                 inner.unchecked_push(index_index, hash, key.to_owned(), value, entry);
+                self.bump_version();
                 break None;
             }
         };
@@ -444,31 +517,33 @@ impl<T: Clone> Dict<T> {
         F: FnOnce() -> T,
     {
         let hash = key.key_hash(vm)?;
-        let res = loop {
-            let lookup = self.lookup(vm, key, hash, None)?;
-            let (index_entry, index_index) = lookup;
+        let mut default = Some(default);
+        loop {
+            let (index_entry, index_index) = self.lookup(vm, key, hash, None)?;
             if let Some(index) = index_entry.index() {
                 let inner = self.read();
                 if let Some(entry) = inner.get_entry_checked(index, index_index) {
-                    break entry.value.clone();
-                } else {
-                    // The dict was changed since we did lookup, let's try again.
-                    continue;
+                    return Ok(entry.value.clone());
                 }
-            } else {
-                let value = default();
-                let mut inner = self.write();
-                inner.unchecked_push(
-                    index_index,
-                    hash,
-                    key.to_pyobject(vm),
-                    value.clone(),
-                    index_entry,
-                );
-                break value;
+                continue;
             }
-        };
-        Ok(res)
+            let mut inner = self.write();
+            if inner.indices.get(index_index) != Some(&index_entry) {
+                continue;
+            }
+            let value = default
+                .take()
+                .expect("default must only be computed on insertion")();
+            inner.unchecked_push(
+                index_index,
+                hash,
+                key.to_pyobject(vm),
+                value.clone(),
+                index_entry,
+            );
+            self.bump_version();
+            return Ok(value);
+        }
     }
 
     #[allow(dead_code)]
@@ -483,27 +558,29 @@ impl<T: Clone> Dict<T> {
         F: FnOnce() -> T,
     {
         let hash = key.key_hash(vm)?;
-        let res = loop {
-            let lookup = self.lookup(vm, key, hash, None)?;
-            let (index_entry, index_index) = lookup;
+        let mut default = Some(default);
+        loop {
+            let (index_entry, index_index) = self.lookup(vm, key, hash, None)?;
             if let Some(index) = index_entry.index() {
                 let inner = self.read();
                 if let Some(entry) = inner.get_entry_checked(index, index_index) {
-                    break (entry.key.clone(), entry.value.clone());
-                } else {
-                    // The dict was changed since we did lookup, let's try again.
-                    continue;
+                    return Ok((entry.key.clone(), entry.value.clone()));
                 }
-            } else {
-                let value = default();
-                let key = key.to_pyobject(vm);
-                let mut inner = self.write();
-                let ret = (key.clone(), value.clone());
-                inner.unchecked_push(index_index, hash, key, value, index_entry);
-                break ret;
+                continue;
             }
-        };
-        Ok(res)
+            let mut inner = self.write();
+            if inner.indices.get(index_index) != Some(&index_entry) {
+                continue;
+            }
+            let value = default
+                .take()
+                .expect("default must only be computed on insertion")();
+            let key_obj = key.to_pyobject(vm);
+            let ret = (key_obj.clone(), value.clone());
+            inner.unchecked_push(index_index, hash, key_obj, value, index_entry);
+            self.bump_version();
+            return Ok(ret);
+        }
     }
 
     pub fn len(&self) -> usize {
@@ -594,9 +671,13 @@ impl<T: Clone> Dict<T> {
         let ret = 'outer: loop {
             let (entry_key, ret) = {
                 let inner = lock.take().unwrap_or_else(|| self.read());
-                let idxs = idxs.get_or_insert_with(|| {
-                    GenIndexes::new(hash_value, (inner.indices.len() - 1) as i64)
-                });
+                let mask = (inner.indices.len() - 1) as i64;
+                let idxs = idxs.get_or_insert_with(|| GenIndexes::new(hash_value, mask));
+                if idxs.mask != mask {
+                    // Dict was resized since last probe, restart
+                    *idxs = GenIndexes::new(hash_value, mask);
+                    free_slot = None;
+                }
                 loop {
                     let index_index = idxs.next();
                     let index_entry = *unsafe {
@@ -685,6 +766,7 @@ impl<T: Clone> Dict<T> {
         } = IndexEntry::DUMMY;
         inner.used -= 1;
         let removed = slot.take();
+        self.bump_version();
         Ok(ControlFlow::Break(removed))
     }
 
@@ -714,6 +796,7 @@ impl<T: Clone> Dict<T> {
             // entry.index always refers valid index
             inner.indices.get_unchecked_mut(entry.index)
         } = IndexEntry::DUMMY;
+        self.bump_version();
         Some((entry.key, entry.value))
     }
 
@@ -818,6 +901,33 @@ impl DictKey for Py<PyStr> {
     }
 }
 
+impl DictKey for Py<PyUtf8Str> {
+    type Owned = PyUtf8StrRef;
+    #[inline(always)]
+    fn _to_owned(&self, _vm: &VirtualMachine) -> Self::Owned {
+        self.to_owned()
+    }
+
+    #[inline]
+    fn key_hash(&self, vm: &VirtualMachine) -> PyResult<HashValue> {
+        self.as_pystr().key_hash(vm)
+    }
+
+    #[inline(always)]
+    fn key_is(&self, other: &PyObject) -> bool {
+        self.as_pystr().key_is(other)
+    }
+
+    fn key_eq(&self, vm: &VirtualMachine, other_key: &PyObject) -> PyResult<bool> {
+        self.as_pystr().key_eq(vm, other_key)
+    }
+
+    #[inline(always)]
+    fn key_as_isize(&self, vm: &VirtualMachine) -> PyResult<isize> {
+        self.as_pystr().key_as_isize(vm)
+    }
+}
+
 impl DictKey for PyStrInterned {
     type Owned = PyRefExact<PyStr>;
 
diff --git a/crates/vm/src/exception_group.rs b/crates/vm/src/exception_group.rs
index 7ad27c078af..02342e4003d 100644
--- a/crates/vm/src/exception_group.rs
+++ b/crates/vm/src/exception_group.rs
@@ -8,6 +8,8 @@ use crate::types::{PyTypeFlags, PyTypeSlots};
 use crate::{
     AsObject, Context, Py, PyObject, PyObjectRef, PyRef, PyResult, TryFromObject, VirtualMachine,
 };
+use core::fmt::Write;
+use rustpython_common::wtf8::{Wtf8, Wtf8Buf};
 
 use crate::exceptions::types::PyBaseException;
 
@@ -183,12 +185,7 @@ pub(super) mod types {
 
         #[pymethod]
         fn __str__(zelf: &Py<PyBaseException>, vm: &VirtualMachine) -> PyResult<PyStrRef> {
-            let message = zelf
-                .get_arg(0)
-                .map(|m| m.str(vm))
-                .transpose()?
-                .map(|s| s.as_str().to_owned())
-                .unwrap_or_default();
+            let message = zelf.get_arg(0).map(|m| m.str(vm)).transpose()?;
 
             let num_excs = zelf
                 .get_arg(1)
@@ -196,10 +193,12 @@ pub(super) mod types {
                 .unwrap_or(0);
 
             let suffix = if num_excs == 1 { "" } else { "s" };
-            Ok(vm.ctx.new_str(format!(
-                "{} ({} sub-exception{})",
-                message, num_excs, suffix
-            )))
+            let mut result = match message {
+                Some(s) => s.as_wtf8().to_owned(),
+                None => Wtf8Buf::new(),
+            };
+            write!(result, " ({num_excs} sub-exception{suffix})").unwrap();
+            Ok(vm.ctx.new_str(result))
         }
 
         #[pyslot]
@@ -208,31 +207,28 @@ pub(super) mod types {
                 .downcast_ref::<PyBaseException>()
                 .expect("exception group must be BaseException");
             let class_name = zelf.class().name().to_owned();
-            let message = zelf
-                .get_arg(0)
-                .map(|m| m.repr(vm))
-                .transpose()?
-                .map(|s| s.as_str().to_owned())
-                .unwrap_or_else(|| "''".to_owned());
-
-            // Format exceptions as list [exc1, exc2, ...] instead of tuple (exc1, exc2, ...)
-            // CPython displays exceptions in list format even though they're stored as tuple
-            let exceptions_str = if let Some(exceptions_obj) = zelf.get_arg(1) {
-                // Get exceptions using ArgIterable for robustness
+            let message = zelf.get_arg(0).map(|m| m.repr(vm)).transpose()?;
+
+            let mut result = Wtf8Buf::new();
+            write!(result, "{class_name}(").unwrap();
+            let message_wtf8: &Wtf8 = message.as_ref().map_or("''".as_ref(), |s| s.as_wtf8());
+            result.push_wtf8(message_wtf8);
+            result.push_str(", [");
+            if let Some(exceptions_obj) = zelf.get_arg(1) {
                 let iter: ArgIterable<PyObjectRef> =
                     ArgIterable::try_from_object(vm, exceptions_obj.clone())?;
-                let mut exc_repr_list = Vec::new();
+                let mut first = true;
                 for exc in iter.iter(vm)? {
-                    exc_repr_list.push(exc?.repr(vm)?.as_str().to_owned());
+                    if !first {
+                        result.push_str(", ");
+                    }
+                    first = false;
+                    result.push_wtf8(exc?.repr(vm)?.as_wtf8());
                 }
-                format!("[{}]", exc_repr_list.join(", "))
-            } else {
-                "[]".to_owned()
-            };
+            }
+            result.push_str("])");
 
-            Ok(vm
-                .ctx
-                .new_str(format!("{}({}, {})", class_name, message, exceptions_str)))
+            Ok(vm.ctx.new_str(result))
         }
     }
 
@@ -280,9 +276,9 @@ pub(super) mod types {
 
             // Validate non-empty
             if exceptions.is_empty() {
-                return Err(vm.new_value_error(
-                    "second argument (exceptions) must be a non-empty sequence".to_owned(),
-                ));
+                return Err(
+                    vm.new_value_error("second argument (exceptions) must be a non-empty sequence")
+                );
             }
 
             // Validate all items are BaseException instances
diff --git a/crates/vm/src/exceptions.rs b/crates/vm/src/exceptions.rs
index dc25b6d2c03..1f82c3cd72c 100644
--- a/crates/vm/src/exceptions.rs
+++ b/crates/vm/src/exceptions.rs
@@ -8,7 +8,7 @@ use crate::{
         traceback::{PyTraceback, PyTracebackRef},
     },
     class::{PyClassImpl, StaticType},
-    convert::{ToPyException, ToPyObject},
+    convert::{IntoPyException, ToPyException, ToPyObject},
     function::{ArgIterable, FuncArgs, IntoFuncArgs, PySetterValue},
     py_io::{self, Write},
     stdlib::sys,
@@ -210,9 +210,17 @@ impl VirtualMachine {
         }
 
         if let Some(text) = maybe_text {
-            // if text ends with \n, remove it
-            let r_text = text.as_str().trim_end_matches('\n');
-            let l_text = r_text.trim_start_matches([' ', '\n', '\x0c']); // \x0c is \f
+            // if text ends with \n or \r\n, remove it
+            use rustpython_common::wtf8::CodePoint;
+            let text_wtf8 = text.as_wtf8();
+            let r_text = text_wtf8.trim_end_matches(|cp: CodePoint| {
+                cp == CodePoint::from_char('\n') || cp == CodePoint::from_char('\r')
+            });
+            let l_text = r_text.trim_start_matches(|cp: CodePoint| {
+                cp == CodePoint::from_char(' ')
+                    || cp == CodePoint::from_char('\n')
+                    || cp == CodePoint::from_char('\x0c') // \f
+            });
             let spaces = (r_text.len() - l_text.len()) as isize;
 
             writeln!(output, "    {l_text}")?;
@@ -249,9 +257,9 @@ impl VirtualMachine {
                     let end_colno = end_offset - 1 - spaces;
                     if colno >= 0 {
                         let caret_space = l_text
-                            .chars()
+                            .code_points()
                             .take(colno as usize)
-                            .map(|c| if c.is_whitespace() { c } else { ' ' })
+                            .map(|cp| cp.to_char().filter(|c| c.is_whitespace()).unwrap_or(' '))
                             .collect::<String>();
 
                         let mut error_width = end_colno - colno;
@@ -348,7 +356,13 @@ impl VirtualMachine {
     ) -> PyResult<PyBaseExceptionRef> {
         // TODO: fast-path built-in exceptions by directly instantiating them? Is that really worth it?
         let res = PyType::call(&cls, args.into_args(self), self)?;
-        PyBaseExceptionRef::try_from_object(self, res)
+        res.downcast::<PyBaseException>().map_err(|obj| {
+            self.new_type_error(format!(
+                "calling {} should have returned an instance of BaseException, not {}",
+                cls,
+                obj.class()
+            ))
+        })
     }
 }
 
@@ -383,7 +397,7 @@ fn write_traceback_entry<W: Write>(
     output: &mut W,
     tb_entry: &Py<PyTraceback>,
 ) -> Result<(), W::Error> {
-    let filename = tb_entry.frame.code.source_path.as_str();
+    let filename = tb_entry.frame.code.source_path().as_str();
     writeln!(
         output,
         r##"  File "{}", line {}, in {}"##,
@@ -710,7 +724,7 @@ impl PyRef<PyBaseException> {
 
             for (key, value) in &dict {
                 let key_str = key.str(vm)?;
-                if key_str.as_str().starts_with("__") {
+                if key_str.as_bytes().starts_with(b"__") {
                     continue;
                 }
                 self.as_object().set_attr(&key_str, value.clone(), vm)?;
@@ -925,8 +939,11 @@ impl ExceptionZoo {
     }
 
     // TODO: remove it after fixing `errno` / `winerror` problem
-    #[allow(clippy::redundant_clone)]
-    pub fn extend(ctx: &Context) {
+    #[allow(
+        clippy::redundant_clone,
+        reason = "temporary workaround until errno/winerror handling is fixed"
+    )]
+    pub fn extend(ctx: &'static Context) {
         use self::types::*;
 
         let excs = &ctx.exceptions;
@@ -1241,138 +1258,219 @@ 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};
-    #[cfg_attr(target_arch = "wasm32", allow(unused_imports))]
-    use crate::{
-        AsObject, Py, PyAtomicRef, PyObject, PyObjectRef, PyPayload, PyRef, PyResult,
-        VirtualMachine,
-        builtins::{
-            PyInt, PyStrRef, PyTupleRef, PyType, PyTypeRef, traceback::PyTracebackRef,
-            tuple::IntoPyTuple,
-        },
-        convert::ToPyObject,
-        convert::ToPyResult,
-        function::{ArgBytesLike, FuncArgs, KwArgs},
-        types::{Constructor, Initializer},
-    };
-    use crossbeam_utils::atomic::AtomicCell;
-    use itertools::Itertools;
-    use rustpython_common::str::UnicodeEscapeCodepoint;
+pub(crate) trait ToOSErrorBuilder {
+    fn to_os_error_builder(&self, vm: &VirtualMachine) -> OSErrorBuilder;
+}
 
-    pub(crate) trait ToOSErrorBuilder {
-        fn to_os_error_builder(&self, vm: &VirtualMachine) -> OSErrorBuilder;
-    }
+pub(crate) struct OSErrorBuilder {
+    exc_type: PyTypeRef,
+    errno: Option<i32>,
+    strerror: Option<PyObjectRef>,
+    filename: Option<PyObjectRef>,
+    #[cfg(windows)]
+    winerror: Option<PyObjectRef>,
+    filename2: Option<PyObjectRef>,
+}
 
-    pub struct OSErrorBuilder {
+impl OSErrorBuilder {
+    #[must_use]
+    pub fn with_subtype(
         exc_type: PyTypeRef,
         errno: Option<i32>,
-        strerror: Option<PyObjectRef>,
-        filename: Option<PyObjectRef>,
-        #[cfg(windows)]
-        winerror: Option<PyObjectRef>,
-        filename2: Option<PyObjectRef>,
+        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,
+        }
     }
 
-    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 fn with_errno(errno: i32, strerror: impl ToPyObject, vm: &VirtualMachine) -> Self {
+        let exc_type = 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]
+    #[allow(dead_code)]
+    pub(crate) fn filename(mut self, filename: PyObjectRef) -> Self {
+        self.filename.replace(filename);
+        self
+    }
 
-        #[must_use]
-        pub(crate) fn filename(mut self, filename: PyObjectRef) -> Self {
-            self.filename.replace(filename);
-            self
-        }
+    #[must_use]
+    #[allow(dead_code)]
+    pub(crate) fn filename2(mut self, filename: PyObjectRef) -> Self {
+        self.filename2.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
+    }
 
-        #[must_use]
-        #[cfg(windows)]
-        pub(crate) fn winerror(mut self, winerror: PyObjectRef) -> Self {
-            self.winerror.replace(winerror);
-            self
-        }
+    /// Strip winerror from the builder. Used for C runtime errors
+    /// (e.g. `_wopen`, `open`) that should produce `[Errno X]` format
+    /// instead of `[WinError X]`.
+    #[must_use]
+    #[cfg(windows)]
+    pub(crate) fn without_winerror(mut self) -> Self {
+        self.winerror = None;
+        self
+    }
 
-        pub fn build(self, vm: &VirtualMachine) -> PyRef<PyOSError> {
-            let OSErrorBuilder {
-                exc_type,
-                errno,
-                strerror,
-                filename,
-                #[cfg(windows)]
+    pub fn build(self, vm: &VirtualMachine) -> PyRef<types::PyOSError> {
+        use types::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,
-            } = self;
+                filename2.to_pyobject(vm),
+            ]
+        } else {
+            vec![strerror.to_pyobject(vm)]
+        };
 
-            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),
-                ]
+        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 IntoPyException for OSErrorBuilder {
+    fn into_pyexception(self, vm: &VirtualMachine) -> PyBaseExceptionRef {
+        self.build(vm).upcast()
+    }
+}
+
+impl ToOSErrorBuilder for std::io::Error {
+    fn to_os_error_builder(&self, vm: &VirtualMachine) -> OSErrorBuilder {
+        use crate::common::os::ErrorExt;
+
+        let errno = self.posix_errno();
+        #[cfg(windows)]
+        let msg = 'msg: {
+            // Use C runtime's strerror for POSIX errno values.
+            // For Windows-specific error codes, fall back to FormatMessage.
+            const MAX_POSIX_ERRNO: i32 = 127;
+            if errno > 0 && errno <= MAX_POSIX_ERRNO {
+                let ptr = unsafe { libc::strerror(errno) };
+                if !ptr.is_null() {
+                    let s = unsafe { core::ffi::CStr::from_ptr(ptr) }.to_string_lossy();
+                    if !s.starts_with("Unknown error") {
+                        break 'msg s.into_owned();
+                    }
+                }
+            }
+            self.to_string()
+        };
+        #[cfg(unix)]
+        let msg = {
+            let ptr = unsafe { libc::strerror(errno) };
+            if !ptr.is_null() {
+                unsafe { core::ffi::CStr::from_ptr(ptr) }
+                    .to_string_lossy()
+                    .into_owned()
             } else {
-                vec![strerror.to_pyobject(vm)]
-            };
+                self.to_string()
+            }
+        };
+        #[cfg(not(any(windows, unix)))]
+        let msg = self.to_string();
 
-            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
+        #[allow(unused_mut)]
+        let mut builder = OSErrorBuilder::with_errno(errno, msg, vm);
+        #[cfg(windows)]
+        if let Some(winerror) = self.raw_os_error() {
+            builder = builder.winerror(winerror.to_pyobject(vm));
         }
+        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)
     }
+}
 
-    impl crate::convert::IntoPyException for OSErrorBuilder {
-        fn into_pyexception(self, vm: &VirtualMachine) -> PyBaseExceptionRef {
-            self.build(vm).upcast()
-        }
+impl IntoPyException for std::io::Error {
+    fn into_pyexception(self, vm: &VirtualMachine) -> PyBaseExceptionRef {
+        self.to_pyexception(vm)
+    }
+}
+
+#[cfg(unix)]
+impl IntoPyException for nix::Error {
+    fn into_pyexception(self, vm: &VirtualMachine) -> PyBaseExceptionRef {
+        std::io::Error::from(self).into_pyexception(vm)
+    }
+}
+
+#[cfg(unix)]
+impl IntoPyException for rustix::io::Errno {
+    fn into_pyexception(self, vm: &VirtualMachine) -> PyBaseExceptionRef {
+        std::io::Error::from(self).into_pyexception(vm)
     }
+}
+
+pub(super) mod types {
+    use crate::common::lock::PyRwLock;
+    use crate::object::{MaybeTraverse, Traverse, TraverseFn};
+    #[cfg_attr(target_arch = "wasm32", allow(unused_imports))]
+    use crate::{
+        AsObject, Py, PyAtomicRef, PyObject, PyObjectRef, PyPayload, PyRef, PyResult,
+        VirtualMachine,
+        builtins::{
+            PyInt, PyStrRef, PyTupleRef, PyType, PyTypeRef, traceback::PyTracebackRef,
+            tuple::IntoPyTuple,
+        },
+        convert::ToPyResult,
+        function::{ArgBytesLike, FuncArgs, KwArgs},
+        types::{Constructor, Initializer},
+    };
+    use crossbeam_utils::atomic::AtomicCell;
+    use itertools::Itertools;
+    use rustpython_common::{
+        str::UnicodeEscapeCodepoint,
+        wtf8::{Wtf8, Wtf8Buf, wtf8_concat},
+    };
 
     // Re-export exception group types from dedicated module
     pub use crate::exception_group::types::PyBaseExceptionGroup;
@@ -1974,17 +2072,37 @@ pub(super) mod types {
                     if !vm.is_none(&filename) {
                         let mut args_reduced: Vec<PyObjectRef> = vec![errno, msg, filename];
 
-                        if let Ok(filename2) = obj.get_attr("filename2", vm)
-                            && !vm.is_none(&filename2)
-                        {
+                        let filename2 = obj
+                            .get_attr("filename2", vm)
+                            .ok()
+                            .filter(|f| !vm.is_none(f));
+                        #[cfg(windows)]
+                        let winerror = obj.get_attr("winerror", vm).ok().filter(|w| !vm.is_none(w));
+
+                        if let Some(filename2) = filename2 {
+                            #[cfg(windows)]
+                            {
+                                args_reduced.push(winerror.unwrap_or_else(|| vm.ctx.none()));
+                            }
+                            #[cfg(not(windows))]
+                            args_reduced.push(vm.ctx.none());
                             args_reduced.push(filename2);
+                        } else {
+                            // Diverges from CPython: include winerror even without
+                            // filename2 so it survives pickle round-trips.
+                            #[cfg(windows)]
+                            if let Some(winerror) = winerror {
+                                args_reduced.push(winerror);
+                            }
                         }
                         result.push(args_reduced.into_pytuple(vm).into());
                     } else {
-                        result.push(vm.new_tuple((errno, msg)).into());
+                        // filename is None - use original args as-is
+                        // (may contain winerror at position 3)
+                        result.push(args.into());
                     }
                 } else {
-                    result.push(vm.new_tuple((errno, msg)).into());
+                    result.push(args.into());
                 }
             } else {
                 result.push(args.into());
@@ -2053,7 +2171,7 @@ pub(super) mod types {
         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()))
+                Err(vm.new_attribute_error("characters_written"))
             } else {
                 Ok(written)
             }
@@ -2069,7 +2187,7 @@ pub(super) mod types {
                 None => {
                     // Deleting the attribute
                     if self.written.load() == -1 {
-                        Err(vm.new_attribute_error("characters_written".to_owned()))
+                        Err(vm.new_attribute_error("characters_written"))
                     } else {
                         self.written.store(-1);
                         Ok(())
@@ -2080,9 +2198,7 @@ pub(super) mod types {
                         .try_index(vm)?
                         .try_to_primitive::<isize>(vm)
                         .map_err(|_| {
-                            vm.new_value_error(
-                                "cannot convert characters_written value to isize".to_owned(),
-                            )
+                            vm.new_value_error("cannot convert characters_written value to isize")
                         })?;
                     self.written.store(n);
                     Ok(())
@@ -2210,19 +2326,25 @@ pub(super) mod types {
     impl PySyntaxError {
         #[pymethod]
         fn __str__(zelf: &Py<PyBaseException>, vm: &VirtualMachine) -> PyResult<PyStrRef> {
-            fn basename(filename: &str) -> &str {
-                let splitted = if cfg!(windows) {
-                    filename.rsplit(&['/', '\\']).next()
+            fn basename(filename: &Wtf8) -> &Wtf8 {
+                let bytes = filename.as_bytes();
+                let pos = if cfg!(windows) {
+                    bytes.iter().rposition(|&b| b == b'/' || b == b'\\')
                 } else {
-                    filename.rsplit('/').next()
+                    bytes.iter().rposition(|&b| b == b'/')
                 };
-                splitted.unwrap_or(filename)
+                match pos {
+                    // SAFETY: splitting at ASCII byte boundary preserves WTF-8 validity
+                    Some(pos) => unsafe { Wtf8::from_bytes_unchecked(&bytes[pos + 1..]) },
+                    None => filename,
+                }
             }
 
-            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_lineno = zelf
+                .as_object()
+                .get_attr("lineno", vm)
+                .and_then(|obj| obj.str_utf8(vm))
+                .ok();
             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>"))
@@ -2238,17 +2360,22 @@ pub(super) mod types {
                 }
             };
 
-            let msg_with_location_info: String = match (maybe_lineno, maybe_filename) {
-                (Some(lineno), Some(filename)) => {
-                    format!("{} ({}, line {})", msg, basename(filename.as_str()), lineno)
-                }
+            let msg_with_location_info: Wtf8Buf = match (maybe_lineno, maybe_filename) {
+                (Some(lineno), Some(filename)) => wtf8_concat!(
+                    msg.as_wtf8(),
+                    " (",
+                    basename(filename.as_wtf8()),
+                    ", line ",
+                    lineno.as_str(),
+                    ")"
+                ),
                 (Some(lineno), None) => {
-                    format!("{msg} (line {lineno})")
+                    wtf8_concat!(msg.as_wtf8(), " (line ", lineno.as_str(), ")")
                 }
                 (None, Some(filename)) => {
-                    format!("{} ({})", msg, basename(filename.as_str()))
+                    wtf8_concat!(msg.as_wtf8(), " (", basename(filename.as_wtf8()), ")")
                 }
-                (None, None) => msg.to_string(),
+                (None, None) => msg.as_wtf8().to_owned(),
             };
 
             Ok(vm.ctx.new_str(msg_with_location_info))
@@ -2270,6 +2397,22 @@ pub(super) mod types {
                     .downcast::<crate::builtins::PyTuple>()
             {
                 let location_tup_len = location_tuple.len();
+
+                match location_tup_len {
+                    4 | 6 => {}
+                    5 => {
+                        return Err(vm.new_type_error(
+                            "end_offset must be provided when end_lineno is provided".to_owned(),
+                        ));
+                    }
+                    _ => {
+                        return Err(vm.new_type_error(format!(
+                            "function takes exactly 4 or 6 arguments ({} given)",
+                            location_tup_len
+                        )));
+                    }
+                }
+
                 for (i, &attr) in [
                     "filename",
                     "lineno",
@@ -2585,14 +2728,13 @@ fn check_except_star_type_valid(match_type: &PyObjectRef, vm: &VirtualMachine) -
         // 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(),
+                "catching classes that do not inherit from BaseException is not allowed",
             ));
         }
         // 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(),
+                "catching ExceptionGroup with except* is not allowed. Use except instead.",
             ));
         }
         Ok(())
diff --git a/crates/vm/src/format.rs b/crates/vm/src/format.rs
index 04d06e9be07..e60b8ed9a4a 100644
--- a/crates/vm/src/format.rs
+++ b/crates/vm/src/format.rs
@@ -9,6 +9,64 @@ use crate::{
 use crate::common::format::*;
 use crate::common::wtf8::{Wtf8, Wtf8Buf};
 
+/// Get locale information from C `localeconv()` for the 'n' format specifier.
+#[cfg(unix)]
+pub(crate) fn get_locale_info() -> LocaleInfo {
+    use core::ffi::CStr;
+    unsafe {
+        let lc = libc::localeconv();
+        if lc.is_null() {
+            return LocaleInfo {
+                thousands_sep: String::new(),
+                decimal_point: ".".to_string(),
+                grouping: vec![],
+            };
+        }
+        let thousands_sep = CStr::from_ptr((*lc).thousands_sep)
+            .to_string_lossy()
+            .into_owned();
+        let decimal_point = CStr::from_ptr((*lc).decimal_point)
+            .to_string_lossy()
+            .into_owned();
+        let grouping = parse_grouping((*lc).grouping);
+        LocaleInfo {
+            thousands_sep,
+            decimal_point,
+            grouping,
+        }
+    }
+}
+
+#[cfg(not(unix))]
+pub(crate) fn get_locale_info() -> LocaleInfo {
+    LocaleInfo {
+        thousands_sep: String::new(),
+        decimal_point: ".".to_string(),
+        grouping: vec![],
+    }
+}
+
+/// Parse C `lconv.grouping` into a `Vec<u8>`.
+/// Reads bytes until 0 or CHAR_MAX, then appends 0 (meaning "repeat last group").
+#[cfg(unix)]
+unsafe fn parse_grouping(grouping: *const libc::c_char) -> Vec<u8> {
+    let mut result = Vec::new();
+    if grouping.is_null() {
+        return result;
+    }
+    unsafe {
+        let mut ptr = grouping;
+        while ![0, libc::c_char::MAX].contains(&*ptr) {
+            result.push(*ptr as u8);
+            ptr = ptr.add(1);
+        }
+    }
+    if !result.is_empty() {
+        result.push(0);
+    }
+    result
+}
+
 impl IntoPyException for FormatSpecError {
     fn into_pyexception(self, vm: &VirtualMachine) -> PyBaseExceptionRef {
         match self {
@@ -101,9 +159,7 @@ fn format_internal(
                 let argument = match conversion_spec.and_then(FormatConversion::from_char) {
                     Some(FormatConversion::Str) => argument.str(vm)?.into(),
                     Some(FormatConversion::Repr) => argument.repr(vm)?.into(),
-                    Some(FormatConversion::Ascii) => {
-                        vm.ctx.new_str(builtins::ascii(argument, vm)?).into()
-                    }
+                    Some(FormatConversion::Ascii) => builtins::ascii(argument, vm)?.into(),
                     Some(FormatConversion::Bytes) => {
                         vm.call_method(&argument, identifier!(vm, decode).as_str(), ())?
                     }
diff --git a/crates/vm/src/frame.rs b/crates/vm/src/frame.rs
index b7df081a642..7cb33ec95d9 100644
--- a/crates/vm/src/frame.rs
+++ b/crates/vm/src/frame.rs
@@ -1,35 +1,57 @@
+// spell-checker: ignore compactlong compactlongs
+
+use crate::anystr::AnyStr;
 #[cfg(feature = "flame")]
 use crate::bytecode::InstructionMetadata;
 use crate::{
-    AsObject, Py, PyObject, PyObjectRef, PyPayload, PyRef, PyResult, TryFromObject, VirtualMachine,
+    AsObject, Py, PyExact, PyObject, PyObjectRef, PyPayload, PyRef, PyResult, PyStackRef,
+    TryFromObject, VirtualMachine,
     builtins::{
-        PyBaseException, PyBaseExceptionRef, PyCode, PyCoroutine, PyDict, PyDictRef, PyGenerator,
-        PyInterpolation, PyList, PySet, PySlice, PyStr, PyStrInterned, PyStrRef, PyTemplate,
-        PyTraceback, PyType,
-        asyncgenerator::PyAsyncGenWrappedValue,
-        function::{PyCell, PyCellRef, PyFunction},
-        tuple::{PyTuple, PyTupleRef},
+        PyBaseException, PyBaseExceptionRef, PyBaseObject, PyCode, PyCoroutine, PyDict, PyDictRef,
+        PyFloat, PyFrozenSet, PyGenerator, PyInt, PyInterpolation, PyList, PyModule, PyProperty,
+        PySet, PySlice, PyStr, PyStrInterned, PyTemplate, PyTraceback, PyType, PyUtf8Str,
+        builtin_func::PyNativeFunction,
+        descriptor::{MemberGetter, PyMemberDescriptor, PyMethodDescriptor},
+        frame::stack_analysis,
+        function::{
+            PyBoundMethod, PyCell, PyCellRef, PyFunction, datastack_frame_size_bytes_for_code,
+            vectorcall_function,
+        },
+        list::PyListIterator,
+        range::PyRangeIterator,
+        tuple::{PyTuple, PyTupleIterator, PyTupleRef},
+    },
+    bytecode::{
+        self, ADAPTIVE_COOLDOWN_VALUE, Arg, Instruction, LoadAttr, LoadSuperAttr, SpecialMethod,
     },
-    bytecode::{self, Instruction},
-    convert::{IntoObject, ToPyResult},
+    convert::{ToPyObject, ToPyResult},
     coroutine::Coro,
     exceptions::ExceptionCtor,
-    function::{ArgMapping, Either, FuncArgs},
+    function::{ArgMapping, Either, FuncArgs, PyMethodFlags},
+    object::PyAtomicBorrow,
     object::{Traverse, TraverseFn},
     protocol::{PyIter, PyIterReturn},
     scope::Scope,
-    stdlib::{builtins, typing},
-    types::PyTypeFlags,
+    sliceable::SliceableSequenceOp,
+    stdlib::{_typing, builtins, sys::monitoring},
+    types::{PyComparisonOp, PyTypeFlags},
     vm::{Context, PyMethod},
 };
 use alloc::fmt;
-use core::iter::zip;
-#[cfg(feature = "threading")]
+use bstr::ByteSlice;
+use core::cell::UnsafeCell;
 use core::sync::atomic;
+use core::sync::atomic::AtomicPtr;
+use core::sync::atomic::Ordering::{Acquire, Relaxed};
 use indexmap::IndexMap;
 use itertools::Itertools;
-
-use rustpython_common::{boxvec::BoxVec, lock::PyMutex, wtf8::Wtf8Buf};
+use malachite_bigint::BigInt;
+use num_traits::Zero;
+use rustpython_common::atomic::{PyAtomic, Radium};
+use rustpython_common::{
+    lock::{OnceCell, PyMutex},
+    wtf8::{Wtf8, Wtf8Buf, wtf8_concat},
+};
 use rustpython_compiler_core::SourceLocation;
 
 pub type FrameRef = PyRef<Frame>;
@@ -47,43 +69,576 @@ enum UnwindReason {
     Raising { exception: PyBaseExceptionRef },
 }
 
-#[derive(Debug)]
-struct FrameState {
-    // We need 1 stack per frame
-    /// The main data frame of the stack machine
-    stack: BoxVec<Option<PyObjectRef>>,
-    /// index of last instruction ran
-    #[cfg(feature = "threading")]
-    lasti: u32,
+/// Tracks who owns a frame.
+// = `_PyFrameOwner`
+#[repr(i8)]
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub(crate) enum FrameOwner {
+    /// Being executed by a thread (FRAME_OWNED_BY_THREAD).
+    Thread = 0,
+    /// Owned by a generator/coroutine (FRAME_OWNED_BY_GENERATOR).
+    Generator = 1,
+    /// Not executing; held only by a frame object or traceback
+    /// (FRAME_OWNED_BY_FRAME_OBJECT).
+    FrameObject = 2,
+}
+
+impl FrameOwner {
+    pub(crate) fn from_i8(v: i8) -> Self {
+        match v {
+            0 => Self::Thread,
+            1 => Self::Generator,
+            _ => Self::FrameObject,
+        }
+    }
+}
+
+/// Lock-free mutable storage for frame-internal data.
+///
+/// # Safety
+/// Frame execution is single-threaded: only one thread at a time executes
+/// a given frame (enforced by the owner field and generator running flag).
+/// External readers (e.g. `f_locals`) are on the same thread as execution
+/// (trace callback) or the frame is not executing.
+pub(crate) struct FrameUnsafeCell<T>(UnsafeCell<T>);
+
+impl<T> FrameUnsafeCell<T> {
+    fn new(value: T) -> Self {
+        Self(UnsafeCell::new(value))
+    }
+
+    /// # Safety
+    /// Caller must ensure no concurrent mutable access.
+    #[inline(always)]
+    unsafe fn get(&self) -> *mut T {
+        self.0.get()
+    }
 }
 
+// SAFETY: Frame execution is single-threaded. See FrameUnsafeCell doc.
 #[cfg(feature = "threading")]
-type Lasti = atomic::AtomicU32;
-#[cfg(not(feature = "threading"))]
-type Lasti = core::cell::Cell<u32>;
+unsafe impl<T: Send> Send for FrameUnsafeCell<T> {}
+#[cfg(feature = "threading")]
+unsafe impl<T: Send> Sync for FrameUnsafeCell<T> {}
+
+/// Unified storage for local variables and evaluation stack.
+///
+/// Memory layout (each slot is `usize`-sized):
+///   `[0..nlocalsplus)` — fastlocals (`Option<PyObjectRef>`)
+///   `[nlocalsplus..nlocalsplus+stack_top)` — active evaluation stack (`Option<PyStackRef>`)
+///   `[nlocalsplus+stack_top..capacity)` — unused stack capacity
+///
+/// Both `Option<PyObjectRef>` and `Option<PyStackRef>` are `usize`-sized
+/// (niche optimization on NonNull / NonZeroUsize). The raw storage is
+/// `usize` to unify them; typed access is provided through methods.
+pub struct LocalsPlus {
+    /// Backing storage.
+    data: LocalsPlusData,
+    /// Number of fastlocals slots (nlocals + ncells + nfrees).
+    nlocalsplus: u32,
+    /// Current evaluation stack depth.
+    stack_top: u32,
+}
 
-#[pyclass(module = false, name = "frame", traverse = "manual")]
-pub struct Frame {
+enum LocalsPlusData {
+    /// Heap-allocated storage (generators, coroutines, exec/eval frames).
+    Heap(Box<[usize]>),
+    /// Data stack allocated storage (normal function calls).
+    /// The pointer is valid while the enclosing data stack frame is alive.
+    DataStack { ptr: *mut usize, capacity: usize },
+}
+
+// SAFETY: DataStack variant points to thread-local DataStack memory.
+// Frame execution is single-threaded (enforced by owner field).
+#[cfg(feature = "threading")]
+unsafe impl Send for LocalsPlusData {}
+#[cfg(feature = "threading")]
+unsafe impl Sync for LocalsPlusData {}
+
+const _: () = {
+    assert!(core::mem::size_of::<Option<PyObjectRef>>() == core::mem::size_of::<usize>());
+    // PyStackRef size is checked in object/core.rs
+};
+
+impl LocalsPlus {
+    /// Create a new heap-backed LocalsPlus.  All slots start as None (0).
+    fn new(nlocalsplus: usize, stacksize: usize) -> Self {
+        let capacity = nlocalsplus
+            .checked_add(stacksize)
+            .expect("LocalsPlus capacity overflow");
+        let nlocalsplus_u32 = u32::try_from(nlocalsplus).expect("nlocalsplus exceeds u32");
+        Self {
+            data: LocalsPlusData::Heap(vec![0usize; capacity].into_boxed_slice()),
+            nlocalsplus: nlocalsplus_u32,
+            stack_top: 0,
+        }
+    }
+
+    /// Create a new LocalsPlus backed by the thread data stack.
+    /// All slots are zero-initialized.
+    ///
+    /// The caller must call `materialize_localsplus()` when the frame finishes
+    /// to migrate data to the heap, then `datastack_pop()` to free the memory.
+    fn new_on_datastack(nlocalsplus: usize, stacksize: usize, vm: &VirtualMachine) -> Self {
+        let capacity = nlocalsplus
+            .checked_add(stacksize)
+            .expect("LocalsPlus capacity overflow");
+        let byte_size = capacity
+            .checked_mul(core::mem::size_of::<usize>())
+            .expect("LocalsPlus byte size overflow");
+        let nlocalsplus_u32 = u32::try_from(nlocalsplus).expect("nlocalsplus exceeds u32");
+        let ptr = vm.datastack_push(byte_size) as *mut usize;
+        // Zero-initialize all slots (0 = None for both PyObjectRef and PyStackRef).
+        unsafe { core::ptr::write_bytes(ptr, 0, capacity) };
+        Self {
+            data: LocalsPlusData::DataStack { ptr, capacity },
+            nlocalsplus: nlocalsplus_u32,
+            stack_top: 0,
+        }
+    }
+
+    /// Migrate data-stack-backed storage to the heap, preserving all values.
+    /// Returns the data stack base pointer for `DataStack::pop()`.
+    /// Returns `None` if already heap-backed.
+    fn materialize_to_heap(&mut self) -> Option<*mut u8> {
+        if let LocalsPlusData::DataStack { ptr, capacity } = &self.data {
+            let base = *ptr as *mut u8;
+            let heap_data = unsafe { core::slice::from_raw_parts(*ptr, *capacity) }
+                .to_vec()
+                .into_boxed_slice();
+            self.data = LocalsPlusData::Heap(heap_data);
+            Some(base)
+        } else {
+            None
+        }
+    }
+
+    /// Drop all contained values without freeing the backing storage.
+    fn drop_values(&mut self) {
+        self.stack_clear();
+        let fastlocals = self.fastlocals_mut();
+        for slot in fastlocals.iter_mut() {
+            let _ = slot.take();
+        }
+    }
+
+    // -- Data access helpers --
+
+    #[inline(always)]
+    fn data_as_slice(&self) -> &[usize] {
+        match &self.data {
+            LocalsPlusData::Heap(b) => b,
+            LocalsPlusData::DataStack { ptr, capacity } => unsafe {
+                core::slice::from_raw_parts(*ptr, *capacity)
+            },
+        }
+    }
+
+    #[inline(always)]
+    fn data_as_mut_slice(&mut self) -> &mut [usize] {
+        match &mut self.data {
+            LocalsPlusData::Heap(b) => b,
+            LocalsPlusData::DataStack { ptr, capacity } => unsafe {
+                core::slice::from_raw_parts_mut(*ptr, *capacity)
+            },
+        }
+    }
+
+    /// Total capacity (fastlocals + stack).
+    #[inline(always)]
+    fn capacity(&self) -> usize {
+        match &self.data {
+            LocalsPlusData::Heap(b) => b.len(),
+            LocalsPlusData::DataStack { capacity, .. } => *capacity,
+        }
+    }
+
+    /// Stack capacity (max stack depth).
+    #[inline(always)]
+    fn stack_capacity(&self) -> usize {
+        self.capacity() - self.nlocalsplus as usize
+    }
+
+    // -- Fastlocals access --
+
+    /// Immutable access to fastlocals as `Option<PyObjectRef>` slice.
+    #[inline(always)]
+    fn fastlocals(&self) -> &[Option<PyObjectRef>] {
+        let data = self.data_as_slice();
+        let ptr = data.as_ptr() as *const Option<PyObjectRef>;
+        unsafe { core::slice::from_raw_parts(ptr, self.nlocalsplus as usize) }
+    }
+
+    /// Mutable access to fastlocals as `Option<PyObjectRef>` slice.
+    #[inline(always)]
+    fn fastlocals_mut(&mut self) -> &mut [Option<PyObjectRef>] {
+        let nlocalsplus = self.nlocalsplus as usize;
+        let data = self.data_as_mut_slice();
+        let ptr = data.as_mut_ptr() as *mut Option<PyObjectRef>;
+        unsafe { core::slice::from_raw_parts_mut(ptr, nlocalsplus) }
+    }
+
+    // -- Stack access --
+
+    /// Current stack depth.
+    #[inline(always)]
+    fn stack_len(&self) -> usize {
+        self.stack_top as usize
+    }
+
+    /// Whether the stack is empty.
+    #[inline(always)]
+    fn stack_is_empty(&self) -> bool {
+        self.stack_top == 0
+    }
+
+    /// Push a value onto the evaluation stack.
+    #[inline(always)]
+    fn stack_push(&mut self, val: Option<PyStackRef>) {
+        let idx = self.nlocalsplus as usize + self.stack_top as usize;
+        debug_assert!(
+            idx < self.capacity(),
+            "stack overflow: stack_top={}, capacity={}",
+            self.stack_top,
+            self.stack_capacity()
+        );
+        let data = self.data_as_mut_slice();
+        data[idx] = unsafe { core::mem::transmute::<Option<PyStackRef>, usize>(val) };
+        self.stack_top += 1;
+    }
+
+    /// Try to push; returns Err if stack is full.
+    #[inline(always)]
+    fn stack_try_push(&mut self, val: Option<PyStackRef>) -> Result<(), Option<PyStackRef>> {
+        let idx = self.nlocalsplus as usize + self.stack_top as usize;
+        if idx >= self.capacity() {
+            return Err(val);
+        }
+        let data = self.data_as_mut_slice();
+        data[idx] = unsafe { core::mem::transmute::<Option<PyStackRef>, usize>(val) };
+        self.stack_top += 1;
+        Ok(())
+    }
+
+    /// Pop a value from the evaluation stack.
+    #[inline(always)]
+    fn stack_pop(&mut self) -> Option<PyStackRef> {
+        debug_assert!(self.stack_top > 0, "stack underflow");
+        self.stack_top -= 1;
+        let idx = self.nlocalsplus as usize + self.stack_top as usize;
+        let data = self.data_as_mut_slice();
+        let raw = core::mem::replace(&mut data[idx], 0);
+        unsafe { core::mem::transmute::<usize, Option<PyStackRef>>(raw) }
+    }
+
+    /// Immutable view of the active stack as `Option<PyStackRef>` slice.
+    #[inline(always)]
+    fn stack_as_slice(&self) -> &[Option<PyStackRef>] {
+        let data = self.data_as_slice();
+        let base = self.nlocalsplus as usize;
+        let ptr = unsafe { (data.as_ptr().add(base)) as *const Option<PyStackRef> };
+        unsafe { core::slice::from_raw_parts(ptr, self.stack_top as usize) }
+    }
+
+    /// Get a reference to a stack slot by index from the bottom.
+    #[inline(always)]
+    fn stack_index(&self, idx: usize) -> &Option<PyStackRef> {
+        debug_assert!(idx < self.stack_top as usize);
+        let data = self.data_as_slice();
+        let raw_idx = self.nlocalsplus as usize + idx;
+        unsafe { &*(data.as_ptr().add(raw_idx) as *const Option<PyStackRef>) }
+    }
+
+    /// Get a mutable reference to a stack slot by index from the bottom.
+    #[inline(always)]
+    fn stack_index_mut(&mut self, idx: usize) -> &mut Option<PyStackRef> {
+        debug_assert!(idx < self.stack_top as usize);
+        let raw_idx = self.nlocalsplus as usize + idx;
+        let data = self.data_as_mut_slice();
+        unsafe { &mut *(data.as_mut_ptr().add(raw_idx) as *mut Option<PyStackRef>) }
+    }
+
+    /// Get the last stack element (top of stack).
+    #[inline(always)]
+    fn stack_last(&self) -> Option<&Option<PyStackRef>> {
+        if self.stack_top == 0 {
+            None
+        } else {
+            Some(self.stack_index(self.stack_top as usize - 1))
+        }
+    }
+
+    /// Get mutable reference to the last stack element.
+    #[inline(always)]
+    fn stack_last_mut(&mut self) -> Option<&mut Option<PyStackRef>> {
+        if self.stack_top == 0 {
+            None
+        } else {
+            let idx = self.stack_top as usize - 1;
+            Some(self.stack_index_mut(idx))
+        }
+    }
+
+    /// Swap two stack elements.
+    #[inline(always)]
+    fn stack_swap(&mut self, a: usize, b: usize) {
+        let base = self.nlocalsplus as usize;
+        let data = self.data_as_mut_slice();
+        data.swap(base + a, base + b);
+    }
+
+    /// Truncate the stack to `new_len` elements, dropping excess values.
+    fn stack_truncate(&mut self, new_len: usize) {
+        debug_assert!(new_len <= self.stack_top as usize);
+        while self.stack_top as usize > new_len {
+            let _ = self.stack_pop();
+        }
+    }
+
+    /// Clear the stack, dropping all values.
+    fn stack_clear(&mut self) {
+        while self.stack_top > 0 {
+            let _ = self.stack_pop();
+        }
+    }
+
+    /// Drain stack elements from `from` to the end, returning an iterator
+    /// that yields `Option<PyStackRef>` in forward order and shrinks the stack.
+    fn stack_drain(
+        &mut self,
+        from: usize,
+    ) -> impl ExactSizeIterator<Item = Option<PyStackRef>> + '_ {
+        let end = self.stack_top as usize;
+        debug_assert!(from <= end);
+        // Reduce stack_top now; the drain iterator owns the elements.
+        self.stack_top = from as u32;
+        LocalsPlusStackDrain {
+            localsplus: self,
+            current: from,
+            end,
+        }
+    }
+
+    /// Extend the stack with values from an iterator.
+    fn stack_extend(&mut self, iter: impl Iterator<Item = Option<PyStackRef>>) {
+        for val in iter {
+            self.stack_push(val);
+        }
+    }
+}
+
+/// Iterator for draining stack elements in forward order.
+struct LocalsPlusStackDrain<'a> {
+    localsplus: &'a mut LocalsPlus,
+    /// Current read position (stack-relative index).
+    current: usize,
+    /// End position (exclusive, stack-relative index).
+    end: usize,
+}
+
+impl Iterator for LocalsPlusStackDrain<'_> {
+    type Item = Option<PyStackRef>;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        if self.current >= self.end {
+            return None;
+        }
+        let idx = self.localsplus.nlocalsplus as usize + self.current;
+        let data = self.localsplus.data_as_mut_slice();
+        let raw = core::mem::replace(&mut data[idx], 0);
+        self.current += 1;
+        Some(unsafe { core::mem::transmute::<usize, Option<PyStackRef>>(raw) })
+    }
+
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        let remaining = self.end - self.current;
+        (remaining, Some(remaining))
+    }
+}
+
+impl ExactSizeIterator for LocalsPlusStackDrain<'_> {}
+
+impl Drop for LocalsPlusStackDrain<'_> {
+    fn drop(&mut self) {
+        while self.current < self.end {
+            let idx = self.localsplus.nlocalsplus as usize + self.current;
+            let data = self.localsplus.data_as_mut_slice();
+            let raw = core::mem::replace(&mut data[idx], 0);
+            let _ = unsafe { core::mem::transmute::<usize, Option<PyStackRef>>(raw) };
+            self.current += 1;
+        }
+    }
+}
+
+impl Drop for LocalsPlus {
+    fn drop(&mut self) {
+        // drop_values handles both stack and fastlocals.
+        // For DataStack-backed storage, the caller should have called
+        // materialize_localsplus() + datastack_pop() before drop.
+        // If not (e.g. panic), the DataStack memory is leaked but
+        // values are still dropped safely.
+        self.drop_values();
+    }
+}
+
+unsafe impl Traverse for LocalsPlus {
+    fn traverse(&self, tracer_fn: &mut TraverseFn<'_>) {
+        self.fastlocals().traverse(tracer_fn);
+        self.stack_as_slice().traverse(tracer_fn);
+    }
+}
+
+/// Lazy locals dict for frames. For NEWLOCALS frames, the dict is
+/// only allocated on first access (most function frames never need it).
+pub struct FrameLocals {
+    inner: OnceCell<ArgMapping>,
+}
+
+impl FrameLocals {
+    /// Create with an already-initialized locals mapping (non-NEWLOCALS frames).
+    fn with_locals(locals: ArgMapping) -> Self {
+        let cell = OnceCell::new();
+        let _ = cell.set(locals);
+        Self { inner: cell }
+    }
+
+    /// Create an empty lazy locals (for NEWLOCALS frames).
+    /// The dict will be created on first access.
+    fn lazy() -> Self {
+        Self {
+            inner: OnceCell::new(),
+        }
+    }
+
+    /// Get the locals mapping, creating it lazily if needed.
+    #[inline]
+    pub fn get_or_create(&self, vm: &VirtualMachine) -> &ArgMapping {
+        self.inner
+            .get_or_init(|| ArgMapping::from_dict_exact(vm.ctx.new_dict()))
+    }
+
+    /// Get the locals mapping if already created.
+    #[inline]
+    pub fn get(&self) -> Option<&ArgMapping> {
+        self.inner.get()
+    }
+
+    #[inline]
+    pub fn mapping(&self, vm: &VirtualMachine) -> crate::protocol::PyMapping<'_> {
+        self.get_or_create(vm).mapping()
+    }
+
+    #[inline]
+    pub fn clone_mapping(&self, vm: &VirtualMachine) -> ArgMapping {
+        self.get_or_create(vm).clone()
+    }
+
+    pub fn into_object(&self, vm: &VirtualMachine) -> PyObjectRef {
+        self.clone_mapping(vm).into()
+    }
+
+    pub fn as_object(&self, vm: &VirtualMachine) -> &PyObject {
+        self.get_or_create(vm).obj()
+    }
+}
+
+impl fmt::Debug for FrameLocals {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("FrameLocals")
+            .field("initialized", &self.inner.get().is_some())
+            .finish()
+    }
+}
+
+impl Clone for FrameLocals {
+    fn clone(&self) -> Self {
+        let cell = OnceCell::new();
+        if let Some(locals) = self.inner.get() {
+            let _ = cell.set(locals.clone());
+        }
+        Self { inner: cell }
+    }
+}
+
+unsafe impl Traverse for FrameLocals {
+    fn traverse(&self, tracer_fn: &mut TraverseFn<'_>) {
+        if let Some(locals) = self.inner.get() {
+            locals.traverse(tracer_fn);
+        }
+    }
+}
+
+/// Lightweight execution frame. Not a PyObject.
+/// Analogous to CPython's `_PyInterpreterFrame`.
+///
+/// Currently always embedded inside a `Frame` PyObject via `FrameUnsafeCell`.
+/// In future PRs this will be usable independently for normal function calls
+/// (allocated on the Rust stack + DataStack), eliminating PyObject overhead.
+pub struct InterpreterFrame {
     pub code: PyRef<PyCode>,
     pub func_obj: Option<PyObjectRef>,
 
-    pub fastlocals: PyMutex<Box<[Option<PyObjectRef>]>>,
-    pub(crate) cells_frees: Box<[PyCellRef]>,
-    pub locals: ArgMapping,
+    /// Unified storage for local variables and evaluation stack.
+    pub(crate) localsplus: LocalsPlus,
+    pub locals: FrameLocals,
     pub globals: PyDictRef,
-    pub builtins: PyDictRef,
+    pub builtins: PyObjectRef,
 
-    // on feature=threading, this is a duplicate of FrameState.lasti, but it's faster to do an
-    // atomic store than it is to do a fetch_add, for every instruction executed
     /// index of last instruction ran
-    pub lasti: Lasti,
+    pub lasti: PyAtomic<u32>,
     /// tracer function for this frame (usually is None)
     pub trace: PyMutex<PyObjectRef>,
-    state: PyMutex<FrameState>,
+
+    /// Previous line number for LINE event suppression.
+    pub(crate) prev_line: u32,
 
     // member
     pub trace_lines: PyMutex<bool>,
+    pub trace_opcodes: PyMutex<bool>,
     pub temporary_refs: PyMutex<Vec<PyObjectRef>>,
+    /// Back-reference to owning generator/coroutine/async generator.
+    /// Borrowed reference (not ref-counted) to avoid Generator↔Frame cycle.
+    /// Cleared by the generator's Drop impl.
+    pub generator: PyAtomicBorrow,
+    /// Previous frame in the call chain for signal-safe traceback walking.
+    /// Mirrors `_PyInterpreterFrame.previous`.
+    pub(crate) previous: AtomicPtr<Frame>,
+    /// Who owns this frame. Mirrors `_PyInterpreterFrame.owner`.
+    /// Used by `frame.clear()` to reject clearing an executing frame,
+    /// even when called from a different thread.
+    pub(crate) owner: atomic::AtomicI8,
+    /// Set when f_locals is accessed. Cleared after locals_to_fast() sync.
+    pub(crate) locals_dirty: atomic::AtomicBool,
+    /// Number of stack entries to pop after set_f_lineno returns to the
+    /// execution loop.  set_f_lineno cannot pop directly because the
+    /// execution loop holds the state mutex.
+    pub(crate) pending_stack_pops: PyAtomic<u32>,
+    /// The encoded stack state that set_f_lineno wants to unwind *from*.
+    /// Used together with `pending_stack_pops` to identify Except entries
+    /// that need special exception-state handling.
+    pub(crate) pending_unwind_from_stack: PyAtomic<i64>,
+}
+
+/// Python-visible frame object. Currently always wraps an `InterpreterFrame`.
+/// Analogous to CPython's `PyFrameObject`.
+#[pyclass(module = false, name = "frame", traverse = "manual")]
+pub struct Frame {
+    pub(crate) iframe: FrameUnsafeCell<InterpreterFrame>,
+}
+
+impl core::ops::Deref for Frame {
+    type Target = InterpreterFrame;
+    /// Transparent access to InterpreterFrame fields.
+    ///
+    /// # Safety argument
+    /// Immutable fields (code, globals, builtins, func_obj, locals) are safe
+    /// to access at any time. Atomic/mutex fields (lasti, trace, owner, etc.)
+    /// provide their own synchronization. Mutable fields (localsplus, prev_line)
+    /// are only mutated during single-threaded execution via `with_exec`.
+    #[inline(always)]
+    fn deref(&self) -> &InterpreterFrame {
+        unsafe { &*self.iframe.get() }
+    }
 }
 
 impl PyPayload for Frame {
@@ -93,24 +648,18 @@ 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);
+        // SAFETY: GC traversal does not run concurrently with frame execution.
+        let iframe = unsafe { &*self.iframe.get() };
+        iframe.code.traverse(tracer_fn);
+        iframe.func_obj.traverse(tracer_fn);
+        iframe.localsplus.traverse(tracer_fn);
+        iframe.locals.traverse(tracer_fn);
+        iframe.globals.traverse(tracer_fn);
+        iframe.builtins.traverse(tracer_fn);
+        iframe.trace.traverse(tracer_fn);
+        iframe.temporary_refs.traverse(tracer_fn);
     }
 }
 
@@ -127,231 +676,761 @@ impl Frame {
     pub(crate) fn new(
         code: PyRef<PyCode>,
         scope: Scope,
-        builtins: PyDictRef,
+        builtins: PyObjectRef,
         closure: &[PyCellRef],
         func_obj: Option<PyObjectRef>,
+        use_datastack: bool,
         vm: &VirtualMachine,
     ) -> Self {
-        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];
+        let nlocalsplus = code.localspluskinds.len();
+        let max_stackdepth = code.max_stackdepth as usize;
+        let mut localsplus = if use_datastack {
+            LocalsPlus::new_on_datastack(nlocalsplus, max_stackdepth, vm)
+        } else {
+            LocalsPlus::new(nlocalsplus, max_stackdepth)
+        };
 
-        // Store cell objects at cellvars and freevars positions
-        for (i, cell) in cells_frees.iter().enumerate() {
-            fastlocals_vec[nlocals + i] = Some(cell.clone().into());
+        // Pre-copy closure cells into free var slots so that locals() works
+        // even before COPY_FREE_VARS runs (e.g. coroutine before first send).
+        // COPY_FREE_VARS will overwrite these on first execution.
+        {
+            let nfrees = code.freevars.len();
+            if nfrees > 0 {
+                let freevar_start = nlocalsplus - nfrees;
+                let fastlocals = localsplus.fastlocals_mut();
+                for (i, cell) in closure.iter().enumerate() {
+                    fastlocals[freevar_start + i] = Some(cell.clone().into());
+                }
+            }
         }
 
-        let state = FrameState {
-            stack: BoxVec::new(code.max_stackdepth as usize),
-            #[cfg(feature = "threading")]
-            lasti: 0,
+        // For generators/coroutines, initialize prev_line to the def line
+        // so that preamble instructions (RETURN_GENERATOR, POP_TOP) don't
+        // fire spurious LINE events.
+        let prev_line = if code
+            .flags
+            .intersects(bytecode::CodeFlags::GENERATOR | bytecode::CodeFlags::COROUTINE)
+        {
+            code.first_line_number.map_or(0, |line| line.get() as u32)
+        } else {
+            0
         };
 
-        Self {
-            fastlocals: PyMutex::new(fastlocals_vec.into_boxed_slice()),
-            cells_frees,
-            locals: scope.locals,
+        let iframe = InterpreterFrame {
+            localsplus,
+            locals: match scope.locals {
+                Some(locals) => FrameLocals::with_locals(locals),
+                None if code.flags.contains(bytecode::CodeFlags::NEWLOCALS) => FrameLocals::lazy(),
+                None => {
+                    FrameLocals::with_locals(ArgMapping::from_dict_exact(scope.globals.clone()))
+                }
+            },
             globals: scope.globals,
             builtins,
             code,
             func_obj,
-            lasti: Lasti::new(0),
-            state: PyMutex::new(state),
+            lasti: Radium::new(0),
+            prev_line,
             trace: PyMutex::new(vm.ctx.none()),
             trace_lines: PyMutex::new(true),
+            trace_opcodes: PyMutex::new(false),
             temporary_refs: PyMutex::new(vec![]),
+            generator: PyAtomicBorrow::new(),
+            previous: AtomicPtr::new(core::ptr::null_mut()),
+            owner: atomic::AtomicI8::new(FrameOwner::FrameObject as i8),
+            locals_dirty: atomic::AtomicBool::new(false),
+            pending_stack_pops: Default::default(),
+            pending_unwind_from_stack: Default::default(),
+        };
+        Self {
+            iframe: FrameUnsafeCell::new(iframe),
         }
     }
 
-    pub fn current_location(&self) -> SourceLocation {
-        self.code.locations[self.lasti() as usize - 1].0
+    /// Access fastlocals immutably.
+    ///
+    /// # Safety
+    /// Caller must ensure no concurrent mutable access (frame not executing,
+    /// or called from the same thread during trace callback).
+    #[inline(always)]
+    pub unsafe fn fastlocals(&self) -> &[Option<PyObjectRef>] {
+        unsafe { (*self.iframe.get()).localsplus.fastlocals() }
     }
 
-    pub fn lasti(&self) -> u32 {
-        #[cfg(feature = "threading")]
-        {
-            self.lasti.load(atomic::Ordering::Relaxed)
-        }
-        #[cfg(not(feature = "threading"))]
-        {
-            self.lasti.get()
-        }
+    /// Access fastlocals mutably.
+    ///
+    /// # Safety
+    /// Caller must ensure exclusive access (frame not executing).
+    #[inline(always)]
+    #[allow(clippy::mut_from_ref)]
+    pub unsafe fn fastlocals_mut(&self) -> &mut [Option<PyObjectRef>] {
+        unsafe { (*self.iframe.get()).localsplus.fastlocals_mut() }
     }
 
-    pub fn locals(&self, vm: &VirtualMachine) -> PyResult<ArgMapping> {
-        let locals = &self.locals;
-        let code = &**self.code;
-        let map = &code.varnames;
-        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) {
-                match locals.mapping().ass_subscript(k, v.clone(), vm) {
-                    Ok(()) => {}
-                    Err(e) if e.fast_isinstance(vm.ctx.exceptions.key_error) => {}
-                    Err(e) => return Err(e),
-                }
-            }
+    /// Migrate data-stack-backed storage to the heap, preserving all values,
+    /// and return the data stack base pointer for `DataStack::pop()`.
+    /// Returns `None` if already heap-backed.
+    ///
+    /// # Safety
+    /// Caller must ensure the frame is not executing and the returned
+    /// pointer is passed to `VirtualMachine::datastack_pop()`.
+    pub(crate) unsafe fn materialize_localsplus(&self) -> Option<*mut u8> {
+        unsafe { (*self.iframe.get()).localsplus.materialize_to_heap() }
+    }
+
+    /// Clear evaluation stack and state-owned cell/free references.
+    /// For full local/cell cleanup, call `clear_locals_and_stack()`.
+    pub(crate) fn clear_stack_and_cells(&self) {
+        // SAFETY: Called when frame is not executing (generator closed).
+        // Cell refs in fastlocals[nlocals..] are cleared by clear_locals_and_stack().
+        unsafe {
+            (*self.iframe.get()).localsplus.stack_clear();
         }
-        if !code.cellvars.is_empty() || !code.freevars.is_empty() {
-            let map_to_dict = |keys: &[&PyStrInterned], values: &[PyCellRef]| {
-                for (&k, v) in zip(keys, values) {
-                    if let Some(value) = v.get() {
-                        locals.mapping().ass_subscript(k, Some(value), vm)?;
-                    } else {
-                        match locals.mapping().ass_subscript(k, None, vm) {
-                            Ok(()) => {}
-                            Err(e) if e.fast_isinstance(vm.ctx.exceptions.key_error) => {}
-                            Err(e) => return Err(e),
-                        }
-                    }
-                }
-                Ok(())
-            };
-            map_to_dict(&code.cellvars, &self.cells_frees)?;
-            if code.flags.contains(bytecode::CodeFlags::OPTIMIZED) {
-                map_to_dict(&code.freevars, &self.cells_frees[code.cellvars.len()..])?;
-            }
+    }
+
+    /// Clear locals and stack after generator/coroutine close.
+    /// Releases references held by the frame, matching _PyFrame_ClearLocals.
+    pub(crate) fn clear_locals_and_stack(&self) {
+        self.clear_stack_and_cells();
+        // SAFETY: Frame is not executing (generator closed).
+        let fastlocals = unsafe { (*self.iframe.get()).localsplus.fastlocals_mut() };
+        for slot in fastlocals.iter_mut() {
+            *slot = None;
         }
-        Ok(locals.clone())
     }
-}
 
-impl Py<Frame> {
-    #[inline(always)]
-    fn with_exec<R>(&self, f: impl FnOnce(ExecutingFrame<'_>) -> R) -> R {
-        let mut state = self.state.lock();
-        let exec = ExecutingFrame {
-            code: &self.code,
-            fastlocals: &self.fastlocals,
-            cells_frees: &self.cells_frees,
-            locals: &self.locals,
-            globals: &self.globals,
-            builtins: &self.builtins,
-            lasti: &self.lasti,
-            object: self,
-            state: &mut state,
-        };
-        f(exec)
+    /// Get cell contents by localsplus index.
+    pub(crate) fn get_cell_contents(&self, localsplus_idx: usize) -> Option<PyObjectRef> {
+        // SAFETY: Frame not executing; no concurrent mutation.
+        let fastlocals = unsafe { (*self.iframe.get()).localsplus.fastlocals() };
+        fastlocals
+            .get(localsplus_idx)
+            .and_then(|slot| slot.as_ref())
+            .and_then(|obj| obj.downcast_ref::<PyCell>())
+            .and_then(|cell| cell.get())
     }
 
-    // #[cfg_attr(feature = "flame-it", flame("Frame"))]
-    pub fn run(&self, vm: &VirtualMachine) -> PyResult<ExecutionResult> {
-        self.with_exec(|mut exec| exec.run(vm))
+    /// Store a borrowed back-reference to the owning generator/coroutine.
+    /// The caller must ensure the generator outlives the frame.
+    pub fn set_generator(&self, generator: &PyObject) {
+        self.generator.store(generator);
+        self.owner
+            .store(FrameOwner::Generator as i8, atomic::Ordering::Release);
     }
 
-    pub(crate) fn resume(
-        &self,
-        value: Option<PyObjectRef>,
-        vm: &VirtualMachine,
-    ) -> PyResult<ExecutionResult> {
-        self.with_exec(|mut exec| {
-            if let Some(value) = value {
-                exec.push_value(value)
-            }
-            exec.run(vm)
-        })
+    /// Clear the generator back-reference. Called when the generator is finalized.
+    pub fn clear_generator(&self) {
+        self.generator.clear();
+        self.owner
+            .store(FrameOwner::FrameObject as i8, atomic::Ordering::Release);
     }
 
-    pub(crate) fn gen_throw(
+    pub fn current_location(&self) -> SourceLocation {
+        self.code.locations[self.lasti() as usize - 1].0
+    }
+
+    /// Get the previous frame pointer for signal-safe traceback walking.
+    pub fn previous_frame(&self) -> *const Frame {
+        self.previous.load(atomic::Ordering::Relaxed)
+    }
+
+    pub fn lasti(&self) -> u32 {
+        self.lasti.load(Relaxed)
+    }
+
+    pub fn set_lasti(&self, val: u32) {
+        self.lasti.store(val, Relaxed);
+    }
+
+    pub(crate) fn pending_stack_pops(&self) -> u32 {
+        self.pending_stack_pops.load(Relaxed)
+    }
+
+    pub(crate) fn set_pending_stack_pops(&self, val: u32) {
+        self.pending_stack_pops.store(val, Relaxed);
+    }
+
+    pub(crate) fn pending_unwind_from_stack(&self) -> i64 {
+        self.pending_unwind_from_stack.load(Relaxed)
+    }
+
+    pub(crate) fn set_pending_unwind_from_stack(&self, val: i64) {
+        self.pending_unwind_from_stack.store(val, Relaxed);
+    }
+
+    /// Sync locals dict back to fastlocals. Called before generator/coroutine resume
+    /// to apply any modifications made via f_locals.
+    pub fn locals_to_fast(&self, vm: &VirtualMachine) -> PyResult<()> {
+        if !self.locals_dirty.load(atomic::Ordering::Acquire) {
+            return Ok(());
+        }
+        let code = &**self.code;
+        // SAFETY: Called before generator resume; no concurrent access.
+        let fastlocals = unsafe { (*self.iframe.get()).localsplus.fastlocals_mut() };
+        let locals_map = self.locals.mapping(vm);
+        for (i, &varname) in code.varnames.iter().enumerate() {
+            if i >= fastlocals.len() {
+                break;
+            }
+            match locals_map.subscript(varname, vm) {
+                Ok(value) => fastlocals[i] = Some(value),
+                Err(e) if e.fast_isinstance(vm.ctx.exceptions.key_error) => {}
+                Err(e) => return Err(e),
+            }
+        }
+        self.locals_dirty.store(false, atomic::Ordering::Release);
+        Ok(())
+    }
+
+    pub fn locals(&self, vm: &VirtualMachine) -> PyResult<ArgMapping> {
+        use rustpython_compiler_core::bytecode::{
+            CO_FAST_CELL, CO_FAST_FREE, CO_FAST_HIDDEN, CO_FAST_LOCAL,
+        };
+        // SAFETY: Either the frame is not executing (caller checked owner),
+        // or we're in a trace callback on the same thread that's executing.
+        let locals = &self.locals;
+        let code = &**self.code;
+        let locals_map = locals.mapping(vm);
+        let fastlocals = unsafe { (*self.iframe.get()).localsplus.fastlocals() };
+
+        // Iterate through all localsplus slots using localspluskinds
+        let nlocalsplus = code.localspluskinds.len();
+        let nfrees = code.freevars.len();
+        let free_start = nlocalsplus - nfrees;
+        let is_optimized = code.flags.contains(bytecode::CodeFlags::OPTIMIZED);
+
+        // Track which non-merged cellvar index we're at
+        let mut nonmerged_cell_idx = 0;
+
+        for (i, &kind) in code.localspluskinds.iter().enumerate() {
+            if kind & CO_FAST_HIDDEN != 0 {
+                // Hidden variables are only skipped when their slot is empty.
+                // After a comprehension restores values, they should appear in locals().
+                let slot_empty = match fastlocals[i].as_ref() {
+                    None => true,
+                    Some(obj) => {
+                        if kind & (CO_FAST_CELL | CO_FAST_FREE) != 0 {
+                            // If it's a PyCell, check if the cell is empty.
+                            // If it's a raw value (merged cell during inlined comp), not empty.
+                            obj.downcast_ref::<PyCell>()
+                                .is_some_and(|cell| cell.get().is_none())
+                        } else {
+                            false
+                        }
+                    }
+                };
+                if slot_empty {
+                    continue;
+                }
+            }
+
+            // Free variables only included for optimized (function-like) scopes.
+            // Class/module scopes should not expose free vars in locals().
+            if kind == CO_FAST_FREE && !is_optimized {
+                continue;
+            }
+
+            // Get the name for this slot
+            let name = if kind & CO_FAST_LOCAL != 0 {
+                code.varnames[i]
+            } else if kind & CO_FAST_FREE != 0 {
+                code.freevars[i - free_start]
+            } else if kind & CO_FAST_CELL != 0 {
+                // Non-merged cell: find the name by skipping merged cellvars
+                let mut found_name = None;
+                let mut skip = nonmerged_cell_idx;
+                for cv in code.cellvars.iter() {
+                    let is_merged = code.varnames.contains(cv);
+                    if !is_merged {
+                        if skip == 0 {
+                            found_name = Some(*cv);
+                            break;
+                        }
+                        skip -= 1;
+                    }
+                }
+                nonmerged_cell_idx += 1;
+                match found_name {
+                    Some(n) => n,
+                    None => continue,
+                }
+            } else {
+                continue;
+            };
+
+            // Get the value
+            let value = if kind & (CO_FAST_CELL | CO_FAST_FREE) != 0 {
+                // Cell or free var: extract value from PyCell.
+                // During inlined comprehensions, a merged cell slot may hold a raw
+                // value (not a PyCell) after LOAD_FAST_AND_CLEAR + STORE_FAST.
+                fastlocals[i].as_ref().and_then(|obj| {
+                    if let Some(cell) = obj.downcast_ref::<PyCell>() {
+                        cell.get()
+                    } else {
+                        Some(obj.clone())
+                    }
+                })
+            } else {
+                // Regular local
+                fastlocals[i].clone()
+            };
+
+            match locals_map.ass_subscript(name, value, vm) {
+                Ok(()) => {}
+                Err(e) if e.fast_isinstance(vm.ctx.exceptions.key_error) => {}
+                Err(e) => return Err(e),
+            }
+        }
+        Ok(locals.clone_mapping(vm))
+    }
+}
+
+impl Py<Frame> {
+    #[inline(always)]
+    fn with_exec<R>(&self, vm: &VirtualMachine, f: impl FnOnce(ExecutingFrame<'_>) -> R) -> R {
+        // SAFETY: Frame execution is single-threaded. Only one thread at a time
+        // executes a given frame (enforced by the owner field and generator
+        // running flag). Same safety argument as FastLocals (UnsafeCell).
+        let iframe = unsafe { &mut *self.iframe.get() };
+        let exec = ExecutingFrame {
+            code: &iframe.code,
+            localsplus: &mut iframe.localsplus,
+            locals: &iframe.locals,
+            globals: &iframe.globals,
+            builtins: &iframe.builtins,
+            builtins_dict: if iframe.globals.class().is(vm.ctx.types.dict_type) {
+                iframe
+                    .builtins
+                    .downcast_ref_if_exact::<PyDict>(vm)
+                    // SAFETY: downcast_ref_if_exact already verified exact type
+                    .map(|d| unsafe { PyExact::ref_unchecked(d) })
+            } else {
+                None
+            },
+            lasti: &iframe.lasti,
+            object: self,
+            prev_line: &mut iframe.prev_line,
+            monitoring_mask: 0,
+        };
+        f(exec)
+    }
+
+    // #[cfg_attr(feature = "flame-it", flame("Frame"))]
+    pub fn run(&self, vm: &VirtualMachine) -> PyResult<ExecutionResult> {
+        self.with_exec(vm, |mut exec| exec.run(vm))
+    }
+
+    pub(crate) fn resume(
+        &self,
+        value: Option<PyObjectRef>,
+        vm: &VirtualMachine,
+    ) -> PyResult<ExecutionResult> {
+        self.with_exec(vm, |mut exec| {
+            if let Some(value) = value {
+                exec.push_value(value)
+            }
+            exec.run(vm)
+        })
+    }
+
+    pub(crate) fn gen_throw(
         &self,
         vm: &VirtualMachine,
         exc_type: PyObjectRef,
         exc_val: PyObjectRef,
         exc_tb: PyObjectRef,
     ) -> PyResult<ExecutionResult> {
-        self.with_exec(|mut exec| exec.gen_throw(vm, exc_type, exc_val, exc_tb))
+        self.with_exec(vm, |mut exec| exec.gen_throw(vm, exc_type, exc_val, exc_tb))
     }
 
     pub fn yield_from_target(&self) -> Option<PyObjectRef> {
-        self.with_exec(|exec| exec.yield_from_target().map(PyObject::to_owned))
+        // If the frame is currently executing (owned by thread), it has no
+        // yield-from target to report.
+        let owner = FrameOwner::from_i8(self.owner.load(atomic::Ordering::Acquire));
+        if owner == FrameOwner::Thread {
+            return None;
+        }
+        // SAFETY: Frame is not executing, so UnsafeCell access is safe.
+        let iframe = unsafe { &mut *self.iframe.get() };
+        let exec = ExecutingFrame {
+            code: &iframe.code,
+            localsplus: &mut iframe.localsplus,
+            locals: &iframe.locals,
+            globals: &iframe.globals,
+            builtins: &iframe.builtins,
+            builtins_dict: None,
+            lasti: &iframe.lasti,
+            object: self,
+            prev_line: &mut iframe.prev_line,
+            monitoring_mask: 0,
+        };
+        exec.yield_from_target().map(PyObject::to_owned)
     }
 
     pub fn is_internal_frame(&self) -> bool {
         let code = self.f_code();
         let filename = code.co_filename();
-        let filename_s = filename.as_str();
-        filename_s.contains("importlib") && filename_s.contains("_bootstrap")
+        let filename = filename.as_bytes();
+        filename.find(b"importlib").is_some() && filename.find(b"_bootstrap").is_some()
     }
 
     pub fn next_external_frame(&self, vm: &VirtualMachine) -> Option<FrameRef> {
-        self.f_back(vm).map(|mut back| {
-            loop {
-                back = if let Some(back) = back.to_owned().f_back(vm) {
-                    back
-                } else {
-                    break back;
-                };
-
-                if !back.is_internal_frame() {
-                    break back;
-                }
+        let mut frame = self.f_back(vm);
+        while let Some(ref f) = frame {
+            if !f.is_internal_frame() {
+                break;
             }
-        })
+            frame = f.f_back(vm);
+        }
+        frame
     }
 }
 
-/// An executing frame; essentially just a struct to combine the immutable data outside the mutex
-/// with the mutable data inside
+/// An executing frame; borrows mutable frame-internal data for the duration
+/// of bytecode execution.
 struct ExecutingFrame<'a> {
     code: &'a PyRef<PyCode>,
-    fastlocals: &'a PyMutex<Box<[Option<PyObjectRef>]>>,
-    cells_frees: &'a [PyCellRef],
-    locals: &'a ArgMapping,
+    localsplus: &'a mut LocalsPlus,
+    locals: &'a FrameLocals,
     globals: &'a PyDictRef,
-    builtins: &'a PyDictRef,
+    builtins: &'a PyObjectRef,
+    /// Cached downcast of builtins to PyDict for fast LOAD_GLOBAL.
+    /// Only set when both globals and builtins are exact dict types (not
+    /// subclasses), so that `__missing__` / `__getitem__` overrides are
+    /// not bypassed.
+    builtins_dict: Option<&'a PyExact<PyDict>>,
     object: &'a Py<Frame>,
-    lasti: &'a Lasti,
-    state: &'a mut FrameState,
+    lasti: &'a PyAtomic<u32>,
+    prev_line: &'a mut u32,
+    /// Cached monitoring events mask. Reloaded at Resume instruction only,
+    monitoring_mask: u32,
+}
+
+#[inline]
+fn specialization_compact_int_value(i: &PyInt, vm: &VirtualMachine) -> Option<isize> {
+    // _PyLong_IsCompact(): a one-digit PyLong (base 2^30),
+    // i.e. abs(value) <= 2^30 - 1.
+    const CPYTHON_COMPACT_LONG_ABS_MAX: i64 = (1i64 << 30) - 1;
+    let v = i.try_to_primitive::<i64>(vm).ok()?;
+    if (-CPYTHON_COMPACT_LONG_ABS_MAX..=CPYTHON_COMPACT_LONG_ABS_MAX).contains(&v) {
+        Some(v as isize)
+    } else {
+        None
+    }
+}
+
+#[inline]
+fn compact_int_from_obj(obj: &PyObject, vm: &VirtualMachine) -> Option<isize> {
+    obj.downcast_ref_if_exact::<PyInt>(vm)
+        .and_then(|i| specialization_compact_int_value(i, vm))
+}
+
+#[inline]
+fn exact_float_from_obj(obj: &PyObject, vm: &VirtualMachine) -> Option<f64> {
+    obj.downcast_ref_if_exact::<PyFloat>(vm).map(|f| f.to_f64())
+}
+
+#[inline]
+fn specialization_nonnegative_compact_index(i: &PyInt, vm: &VirtualMachine) -> Option<usize> {
+    // _PyLong_IsNonNegativeCompact(): a single base-2^30 digit.
+    const CPYTHON_COMPACT_LONG_MAX: u64 = (1u64 << 30) - 1;
+    let v = i.try_to_primitive::<u64>(vm).ok()?;
+    if v <= CPYTHON_COMPACT_LONG_MAX {
+        Some(v as usize)
+    } else {
+        None
+    }
+}
+
+fn release_datastack_frame(frame: &Py<Frame>, vm: &VirtualMachine) {
+    unsafe {
+        if let Some(base) = frame.materialize_localsplus() {
+            vm.datastack_pop(base);
+        }
+    }
+}
+
+type BinaryOpExtendGuard = fn(&PyObject, &PyObject, &VirtualMachine) -> bool;
+type BinaryOpExtendAction = fn(&PyObject, &PyObject, &VirtualMachine) -> Option<PyObjectRef>;
+
+struct BinaryOpExtendSpecializationDescr {
+    oparg: bytecode::BinaryOperator,
+    guard: BinaryOpExtendGuard,
+    action: BinaryOpExtendAction,
+}
+
+const BINARY_OP_EXTEND_EXTERNAL_CACHE_OFFSET: usize = 1;
+
+#[inline]
+fn compactlongs_guard(lhs: &PyObject, rhs: &PyObject, vm: &VirtualMachine) -> bool {
+    compact_int_from_obj(lhs, vm).is_some() && compact_int_from_obj(rhs, vm).is_some()
+}
+
+macro_rules! bitwise_longs_action {
+    ($name:ident, $op:tt) => {
+        #[inline]
+        fn $name(lhs: &PyObject, rhs: &PyObject, vm: &VirtualMachine) -> Option<PyObjectRef> {
+            let lhs_val = compact_int_from_obj(lhs, vm)?;
+            let rhs_val = compact_int_from_obj(rhs, vm)?;
+            Some(vm.ctx.new_int(lhs_val $op rhs_val).into())
+        }
+    };
+}
+bitwise_longs_action!(compactlongs_or, |);
+bitwise_longs_action!(compactlongs_and, &);
+bitwise_longs_action!(compactlongs_xor, ^);
+
+#[inline]
+fn float_compactlong_guard(lhs: &PyObject, rhs: &PyObject, vm: &VirtualMachine) -> bool {
+    exact_float_from_obj(lhs, vm).is_some_and(|f| !f.is_nan())
+        && compact_int_from_obj(rhs, vm).is_some()
+}
+
+#[inline]
+fn nonzero_float_compactlong_guard(lhs: &PyObject, rhs: &PyObject, vm: &VirtualMachine) -> bool {
+    float_compactlong_guard(lhs, rhs, vm) && compact_int_from_obj(rhs, vm).is_some_and(|v| v != 0)
+}
+
+macro_rules! float_long_action {
+    ($name:ident, $op:tt) => {
+        #[inline]
+        fn $name(lhs: &PyObject, rhs: &PyObject, vm: &VirtualMachine) -> Option<PyObjectRef> {
+            let lhs_val = exact_float_from_obj(lhs, vm)?;
+            let rhs_val = compact_int_from_obj(rhs, vm)?;
+            Some(vm.ctx.new_float(lhs_val $op rhs_val as f64).into())
+        }
+    };
+}
+float_long_action!(float_compactlong_add, +);
+float_long_action!(float_compactlong_subtract, -);
+float_long_action!(float_compactlong_multiply, *);
+float_long_action!(float_compactlong_true_div, /);
+
+#[inline]
+fn compactlong_float_guard(lhs: &PyObject, rhs: &PyObject, vm: &VirtualMachine) -> bool {
+    compact_int_from_obj(lhs, vm).is_some()
+        && exact_float_from_obj(rhs, vm).is_some_and(|f| !f.is_nan())
 }
 
+#[inline]
+fn nonzero_compactlong_float_guard(lhs: &PyObject, rhs: &PyObject, vm: &VirtualMachine) -> bool {
+    compactlong_float_guard(lhs, rhs, vm) && exact_float_from_obj(rhs, vm).is_some_and(|f| f != 0.0)
+}
+
+macro_rules! long_float_action {
+    ($name:ident, $op:tt) => {
+        #[inline]
+        fn $name(lhs: &PyObject, rhs: &PyObject, vm: &VirtualMachine) -> Option<PyObjectRef> {
+            let lhs_val = compact_int_from_obj(lhs, vm)?;
+            let rhs_val = exact_float_from_obj(rhs, vm)?;
+            Some(vm.ctx.new_float(lhs_val as f64 $op rhs_val).into())
+        }
+    };
+}
+long_float_action!(compactlong_float_add, +);
+long_float_action!(compactlong_float_subtract, -);
+long_float_action!(compactlong_float_multiply, *);
+long_float_action!(compactlong_float_true_div, /);
+
+static BINARY_OP_EXTEND_DESCRIPTORS: &[BinaryOpExtendSpecializationDescr] = &[
+    // long-long arithmetic
+    BinaryOpExtendSpecializationDescr {
+        oparg: bytecode::BinaryOperator::Or,
+        guard: compactlongs_guard,
+        action: compactlongs_or,
+    },
+    BinaryOpExtendSpecializationDescr {
+        oparg: bytecode::BinaryOperator::And,
+        guard: compactlongs_guard,
+        action: compactlongs_and,
+    },
+    BinaryOpExtendSpecializationDescr {
+        oparg: bytecode::BinaryOperator::Xor,
+        guard: compactlongs_guard,
+        action: compactlongs_xor,
+    },
+    BinaryOpExtendSpecializationDescr {
+        oparg: bytecode::BinaryOperator::InplaceOr,
+        guard: compactlongs_guard,
+        action: compactlongs_or,
+    },
+    BinaryOpExtendSpecializationDescr {
+        oparg: bytecode::BinaryOperator::InplaceAnd,
+        guard: compactlongs_guard,
+        action: compactlongs_and,
+    },
+    BinaryOpExtendSpecializationDescr {
+        oparg: bytecode::BinaryOperator::InplaceXor,
+        guard: compactlongs_guard,
+        action: compactlongs_xor,
+    },
+    // float-long arithmetic
+    BinaryOpExtendSpecializationDescr {
+        oparg: bytecode::BinaryOperator::Add,
+        guard: float_compactlong_guard,
+        action: float_compactlong_add,
+    },
+    BinaryOpExtendSpecializationDescr {
+        oparg: bytecode::BinaryOperator::Subtract,
+        guard: float_compactlong_guard,
+        action: float_compactlong_subtract,
+    },
+    BinaryOpExtendSpecializationDescr {
+        oparg: bytecode::BinaryOperator::TrueDivide,
+        guard: nonzero_float_compactlong_guard,
+        action: float_compactlong_true_div,
+    },
+    BinaryOpExtendSpecializationDescr {
+        oparg: bytecode::BinaryOperator::Multiply,
+        guard: float_compactlong_guard,
+        action: float_compactlong_multiply,
+    },
+    // long-float arithmetic
+    BinaryOpExtendSpecializationDescr {
+        oparg: bytecode::BinaryOperator::Add,
+        guard: compactlong_float_guard,
+        action: compactlong_float_add,
+    },
+    BinaryOpExtendSpecializationDescr {
+        oparg: bytecode::BinaryOperator::Subtract,
+        guard: compactlong_float_guard,
+        action: compactlong_float_subtract,
+    },
+    BinaryOpExtendSpecializationDescr {
+        oparg: bytecode::BinaryOperator::TrueDivide,
+        guard: nonzero_compactlong_float_guard,
+        action: compactlong_float_true_div,
+    },
+    BinaryOpExtendSpecializationDescr {
+        oparg: bytecode::BinaryOperator::Multiply,
+        guard: compactlong_float_guard,
+        action: compactlong_float_multiply,
+    },
+];
+
 impl fmt::Debug for ExecutingFrame<'_> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         f.debug_struct("ExecutingFrame")
             .field("code", self.code)
-            // .field("scope", self.scope)
-            .field("state", self.state)
+            .field("stack_len", &self.localsplus.stack_len())
             .finish()
     }
 }
 
 impl ExecutingFrame<'_> {
+    #[inline]
+    fn monitoring_disabled_for_code(&self, vm: &VirtualMachine) -> bool {
+        self.code.is(&vm.ctx.init_cleanup_code)
+    }
+
+    fn specialization_new_init_cleanup_frame(&self, vm: &VirtualMachine) -> FrameRef {
+        Frame::new(
+            vm.ctx.init_cleanup_code.clone(),
+            Scope::new(
+                Some(ArgMapping::from_dict_exact(vm.ctx.new_dict())),
+                self.globals.clone(),
+            ),
+            self.builtins.clone(),
+            &[],
+            None,
+            true,
+            vm,
+        )
+        .into_ref(&vm.ctx)
+    }
+
+    fn specialization_run_init_cleanup_shim(
+        &self,
+        new_obj: PyObjectRef,
+        init_func: &Py<PyFunction>,
+        pos_args: Vec<PyObjectRef>,
+        vm: &VirtualMachine,
+    ) -> PyResult<PyObjectRef> {
+        let shim = self.specialization_new_init_cleanup_frame(vm);
+        let shim_result = vm.with_frame_untraced(shim.clone(), |shim| {
+            shim.with_exec(vm, |mut exec| exec.push_value(new_obj.clone()));
+
+            let mut all_args = Vec::with_capacity(pos_args.len() + 1);
+            all_args.push(new_obj.clone());
+            all_args.extend(pos_args);
+
+            let init_frame = init_func.prepare_exact_args_frame(all_args, vm);
+            let init_result = vm.run_frame(init_frame.clone());
+            release_datastack_frame(&init_frame, vm);
+            let init_result = init_result?;
+
+            shim.with_exec(vm, |mut exec| exec.push_value(init_result));
+            match shim.run(vm)? {
+                ExecutionResult::Return(value) => Ok(value),
+                ExecutionResult::Yield(_) => unreachable!("_Py_InitCleanup shim cannot yield"),
+            }
+        });
+        release_datastack_frame(&shim, vm);
+        shim_result
+    }
+
     #[inline(always)]
     fn update_lasti(&mut self, f: impl FnOnce(&mut u32)) {
-        #[cfg(feature = "threading")]
-        {
-            f(&mut self.state.lasti);
-            self.lasti
-                .store(self.state.lasti, atomic::Ordering::Relaxed);
-        }
-        #[cfg(not(feature = "threading"))]
-        {
-            let mut lasti = self.lasti.get();
-            f(&mut lasti);
-            self.lasti.set(lasti);
-        }
+        let mut val = self.lasti.load(Relaxed);
+        f(&mut val);
+        self.lasti.store(val, Relaxed);
     }
 
     #[inline(always)]
-    const fn lasti(&self) -> u32 {
-        #[cfg(feature = "threading")]
-        {
-            self.state.lasti
+    fn lasti(&self) -> u32 {
+        self.lasti.load(Relaxed)
+    }
+
+    /// Access the PyCellRef at the given localsplus index.
+    #[inline(always)]
+    fn cell_ref(&self, localsplus_idx: usize) -> &PyCell {
+        let fastlocals = self.localsplus.fastlocals();
+        let slot = &fastlocals[localsplus_idx];
+        slot.as_ref()
+            .expect("cell slot empty")
+            .downcast_ref::<PyCell>()
+            .expect("cell slot is not a PyCell")
+    }
+
+    /// Perform deferred stack unwinding after set_f_lineno.
+    ///
+    /// set_f_lineno cannot pop the value stack directly because the execution
+    /// loop holds the state mutex.  Instead it records the work in
+    /// `pending_stack_pops` / `pending_unwind_from_stack` and we execute it
+    /// here, inside the execution loop where we already own the state.
+    fn unwind_stack_for_lineno(&mut self, pop_count: usize, from_stack: i64, vm: &VirtualMachine) {
+        let mut cur_stack = from_stack;
+        for _ in 0..pop_count {
+            let val = self.pop_value_opt();
+            if stack_analysis::top_of_stack(cur_stack) == stack_analysis::Kind::Except as i64
+                && let Some(exc_obj) = val
+            {
+                if vm.is_none(&exc_obj) {
+                    vm.set_exception(None);
+                } else {
+                    let exc = exc_obj.downcast::<PyBaseException>().ok();
+                    vm.set_exception(exc);
+                }
+            }
+            cur_stack = stack_analysis::pop_value(cur_stack);
         }
-        #[cfg(not(feature = "threading"))]
-        {
-            self.lasti.get()
+    }
+
+    /// Fire 'exception' trace event (sys.settrace) with (type, value, traceback) tuple.
+    /// Matches `_PyEval_MonitorRaise` → `PY_MONITORING_EVENT_RAISE` →
+    /// `sys_trace_exception_func` in legacy_tracing.c.
+    fn fire_exception_trace(&self, exc: &PyBaseExceptionRef, vm: &VirtualMachine) -> PyResult<()> {
+        if vm.use_tracing.get() && !vm.is_none(&self.object.trace.lock()) {
+            let exc_type: PyObjectRef = exc.class().to_owned().into();
+            let exc_value: PyObjectRef = exc.clone().into();
+            let exc_tb: PyObjectRef = exc
+                .__traceback__()
+                .map(|tb| -> PyObjectRef { tb.into() })
+                .unwrap_or_else(|| vm.ctx.none());
+            let tuple = vm.ctx.new_tuple(vec![exc_type, exc_value, exc_tb]).into();
+            vm.trace_event(crate::protocol::TraceEvent::Exception, Some(tuple))?;
         }
+        Ok(())
     }
 
     fn run(&mut self, vm: &VirtualMachine) -> PyResult<ExecutionResult> {
@@ -360,15 +1439,114 @@ impl ExecutingFrame<'_> {
             obj_name = self.code.obj_name
         ));
         // Execute until return or exception:
-        let instructions = &self.code.instructions;
         let mut arg_state = bytecode::OpArgState::default();
         loop {
             let idx = self.lasti() as usize;
+            // Advance lasti past the current instruction BEFORE firing the
+            // line event.  This ensures that f_lineno (which reads
+            // locations[lasti - 1]) returns the line of the instruction
+            // being traced, not the previous one.
             self.update_lasti(|i| *i += 1);
-            let bytecode::CodeUnit { op, arg } = instructions[idx];
-            let arg = arg_state.extend(arg);
+
+            // Fire 'line' trace event when line number changes.
+            // Only fire if this frame has a per-frame trace function set
+            // (frames entered before sys.settrace() have trace=None).
+            // Skip RESUME – it should not generate user-visible line events.
+            if vm.use_tracing.get()
+                && !vm.is_none(&self.object.trace.lock())
+                && !matches!(
+                    self.code.instructions.read_op(idx),
+                    Instruction::Resume { .. } | Instruction::InstrumentedResume
+                )
+                && let Some((loc, _)) = self.code.locations.get(idx)
+                && loc.line.get() as u32 != *self.prev_line
+            {
+                *self.prev_line = loc.line.get() as u32;
+                vm.trace_event(crate::protocol::TraceEvent::Line, None)?;
+                // Trace callback may have changed lasti via set_f_lineno.
+                // Re-read and restart the loop from the new position.
+                if self.lasti() != (idx as u32 + 1) {
+                    // set_f_lineno defers stack unwinding because we hold
+                    // the state mutex.  Perform it now.
+                    let pops = self.object.pending_stack_pops();
+                    if pops > 0 {
+                        let from_stack = self.object.pending_unwind_from_stack();
+                        self.unwind_stack_for_lineno(pops as usize, from_stack, vm);
+                        self.object.set_pending_stack_pops(0);
+                    }
+                    arg_state.reset();
+                    continue;
+                }
+            }
+            let op = self.code.instructions.read_op(idx);
+            let arg = arg_state.extend(self.code.instructions.read_arg(idx));
             let mut do_extend_arg = false;
+            let caches = op.cache_entries();
+
+            // Update prev_line only when tracing or monitoring is active.
+            // When neither is enabled, prev_line is stale but unused.
+            if vm.use_tracing.get() {
+                if !matches!(
+                    op,
+                    Instruction::Resume { .. }
+                        | Instruction::ExtendedArg
+                        | Instruction::InstrumentedLine
+                ) && let Some((loc, _)) = self.code.locations.get(idx)
+                {
+                    *self.prev_line = loc.line.get() as u32;
+                }
+
+                // Fire 'opcode' trace event for sys.settrace when f_trace_opcodes
+                // is set. Skip RESUME and ExtendedArg
+                // (_Py_call_instrumentation_instruction).
+                if !vm.is_none(&self.object.trace.lock())
+                    && *self.object.trace_opcodes.lock()
+                    && !matches!(
+                        op,
+                        Instruction::Resume { .. }
+                            | Instruction::InstrumentedResume
+                            | Instruction::ExtendedArg
+                    )
+                {
+                    vm.trace_event(crate::protocol::TraceEvent::Opcode, None)?;
+                }
+            }
+
+            if vm.eval_breaker_tripped()
+                && let Err(exception) = vm.check_signals()
+            {
+                #[cold]
+                fn handle_signal_exception(
+                    frame: &mut ExecutingFrame<'_>,
+                    exception: PyBaseExceptionRef,
+                    idx: usize,
+                    vm: &VirtualMachine,
+                ) -> FrameResult {
+                    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);
+                    exception.set_traceback_typed(Some(new_traceback.into_ref(&vm.ctx)));
+                    vm.contextualize_exception(&exception);
+                    frame.unwind_blocks(vm, UnwindReason::Raising { exception })
+                }
+                match handle_signal_exception(self, exception, idx, vm) {
+                    Ok(None) => {}
+                    Ok(Some(value)) => {
+                        break Ok(value);
+                    }
+                    Err(exception) => {
+                        break Err(exception);
+                    }
+                }
+                continue;
+            }
+            let lasti_before = self.lasti();
             let result = self.execute_instruction(op, arg, &mut do_extend_arg, vm);
+            // Skip inline cache entries if instruction fell through (no jump).
+            if caches > 0 && self.lasti() == lasti_before {
+                self.update_lasti(|i| *i += caches as u32);
+            }
             match result {
                 Ok(None) => {}
                 Ok(Some(value)) => {
@@ -382,6 +1560,7 @@ impl ExecutingFrame<'_> {
                         exception: PyBaseExceptionRef,
                         idx: usize,
                         is_reraise: bool,
+                        is_new_raise: bool,
                         vm: &VirtualMachine,
                     ) -> FrameResult {
                         // 1. Extract traceback from exception's '__traceback__' attr.
@@ -391,6 +1570,11 @@ impl ExecutingFrame<'_> {
                         // RERAISE instructions should not add traceback entries - they're just
                         // re-raising an already-processed exception
                         if !is_reraise {
+                            // Check if the exception already has traceback entries before
+                            // we add ours. If it does, it was propagated from a callee
+                            // function and we should not re-contextualize it.
+                            let had_prior_traceback = exception.__traceback__().is_some();
+
                             // 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),
@@ -406,13 +1590,15 @@ impl ExecutingFrame<'_> {
                             );
                             vm_trace!("Adding to traceback: {:?} {:?}", new_traceback, loc.line);
                             exception.set_traceback_typed(Some(new_traceback.into_ref(&vm.ctx)));
-                        }
 
-                        // 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);
+                            // _PyErr_SetObject sets __context__ only when the exception
+                            // is first raised. When an exception propagates through frames,
+                            // __context__ must not be overwritten. We contextualize when:
+                            // - It's an explicit raise (raise/raise from)
+                            // - The exception had no prior traceback (originated here)
+                            if is_new_raise || !had_prior_traceback {
+                                vm.contextualize_exception(&exception);
+                            }
                         }
 
                         // Use exception table for zero-cost exception handling
@@ -422,20 +1608,83 @@ impl ExecutingFrame<'_> {
                     // Check if this is a RERAISE instruction
                     // Both AnyInstruction::Raise { kind: Reraise/ReraiseFromStack } and
                     // AnyInstruction::Reraise are reraise operations that should not add
-                    // new traceback entries
+                    // new traceback entries.
+                    // EndAsyncFor and CleanupThrow also re-raise non-matching exceptions.
                     let is_reraise = match op {
-                        Instruction::RaiseVarargs { kind } => matches!(
+                        Instruction::RaiseVarargs { argc: kind } => matches!(
                             kind.get(arg),
                             bytecode::RaiseKind::BareRaise | bytecode::RaiseKind::ReraiseFromStack
                         ),
-                        Instruction::Reraise { .. } => true,
+                        Instruction::Reraise { .. }
+                        | Instruction::EndAsyncFor
+                        | Instruction::CleanupThrow => true,
                         _ => false,
                     };
 
-                    match handle_exception(self, exception, idx, is_reraise, vm) {
+                    // Explicit raise instructions (raise/raise from) - these always
+                    // need contextualization even if the exception has prior traceback
+                    let is_new_raise = matches!(
+                        op,
+                        Instruction::RaiseVarargs { argc: kind }
+                            if matches!(
+                                kind.get(arg),
+                                bytecode::RaiseKind::Raise | bytecode::RaiseKind::RaiseCause
+                            )
+                    );
+
+                    // Fire RAISE or RERAISE monitoring event.
+                    // If the callback raises, replace the original exception.
+                    let exception = {
+                        let mon_events = vm.state.monitoring_events.load();
+                        if is_reraise {
+                            if mon_events & monitoring::EVENT_RERAISE != 0 {
+                                let offset = idx as u32 * 2;
+                                let exc_obj: PyObjectRef = exception.clone().into();
+                                match monitoring::fire_reraise(vm, self.code, offset, &exc_obj) {
+                                    Ok(()) => exception,
+                                    Err(monitor_exc) => monitor_exc,
+                                }
+                            } else {
+                                exception
+                            }
+                        } else if mon_events & monitoring::EVENT_RAISE != 0 {
+                            let offset = idx as u32 * 2;
+                            let exc_obj: PyObjectRef = exception.clone().into();
+                            match monitoring::fire_raise(vm, self.code, offset, &exc_obj) {
+                                Ok(()) => exception,
+                                Err(monitor_exc) => monitor_exc,
+                            }
+                        } else {
+                            exception
+                        }
+                    };
+
+                    // Fire 'exception' trace event for sys.settrace.
+                    // Only for new raises, not re-raises (matching the
+                    // `error` label that calls _PyEval_MonitorRaise).
+                    if !is_reraise {
+                        self.fire_exception_trace(&exception, vm)?;
+                    }
+
+                    match handle_exception(self, exception, idx, is_reraise, is_new_raise, vm) {
                         Ok(None) => {}
                         Ok(Some(result)) => break Ok(result),
                         Err(exception) => {
+                            // Fire PY_UNWIND: exception escapes this frame
+                            let exception = if vm.state.monitoring_events.load()
+                                & monitoring::EVENT_PY_UNWIND
+                                != 0
+                            {
+                                let offset = idx as u32 * 2;
+                                let exc_obj: PyObjectRef = exception.clone().into();
+                                match monitoring::fire_py_unwind(vm, self.code, offset, &exc_obj) {
+                                    Ok(()) => exception,
+                                    Err(monitor_exc) => monitor_exc,
+                                }
+                            } else {
+                                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
@@ -466,23 +1715,26 @@ impl ExecutingFrame<'_> {
         // 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() {
+        if self.localsplus.stack_is_empty() {
             return None;
         }
         let lasti = self.lasti() as usize;
         if let Some(unit) = self.code.instructions.get(lasti) {
             match &unit.op {
                 Instruction::Send { .. } => return Some(self.top_value()),
-                Instruction::Resume { .. } => {
+                Instruction::Resume { .. } | Instruction::InstrumentedResume => {
                     // 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 Instruction::YieldValue { .. } = &prev_unit.op
+                        && matches!(
+                            &prev_unit.op,
+                            Instruction::YieldValue { .. } | Instruction::InstrumentedYieldValue
+                        )
                     {
                         // YIELD_VALUE arg: 0 = direct yield, >= 1 = yield-from/await
                         // OpArgByte.0 is the raw byte value
-                        if prev_unit.arg.0 >= 1 {
+                        if u8::from(prev_unit.arg) >= 1 {
                             // In yield-from/await context, delegate is on top of stack
                             return Some(self.top_value());
                         }
@@ -502,42 +1754,112 @@ impl ExecutingFrame<'_> {
         exc_val: PyObjectRef,
         exc_tb: PyObjectRef,
     ) -> PyResult<ExecutionResult> {
+        self.monitoring_mask = vm.state.monitoring_events.load();
         if let Some(jen) = self.yield_from_target() {
-            // borrow checker shenanigans - we only need to use exc_type/val/tb if the following
-            // variable is Some
-            let thrower = if let Some(coro) = self.builtin_coro(jen) {
-                Some(Either::A(coro))
+            // Check if the exception is GeneratorExit (type or instance).
+            // For GeneratorExit, close the sub-iterator instead of throwing.
+            let is_gen_exit = if let Some(typ) = exc_type.downcast_ref::<PyType>() {
+                typ.fast_issubclass(vm.ctx.exceptions.generator_exit)
             } else {
-                vm.get_attribute_opt(jen.to_owned(), "throw")?
-                    .map(Either::B)
+                exc_type.fast_isinstance(vm.ctx.exceptions.generator_exit)
             };
-            if let Some(thrower) = thrower {
-                let ret = match thrower {
-                    Either::A(coro) => coro
-                        .throw(jen, exc_type, exc_val, exc_tb, vm)
-                        .to_pyresult(vm),
-                    Either::B(meth) => meth.call((exc_type, exc_val, exc_tb), vm),
+
+            if is_gen_exit {
+                // gen_close_iter: close the sub-iterator
+                let close_result = if let Some(coro) = self.builtin_coro(jen) {
+                    coro.close(jen, vm).map(|_| ())
+                } else if let Some(close_meth) = vm.get_attribute_opt(jen.to_owned(), "close")? {
+                    close_meth.call((), vm).map(|_| ())
+                } else {
+                    Ok(())
                 };
-                return ret.map(ExecutionResult::Yield).or_else(|err| {
-                    // 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());
+                if let Err(err) = close_result {
+                    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 = err.__traceback__();
+                        let new_traceback = PyTraceback::new(
+                            next,
+                            self.object.to_owned(),
+                            idx as u32 * 2,
+                            loc.line,
+                        );
+                        err.set_traceback_typed(Some(new_traceback.into_ref(&vm.ctx)));
+                    }
 
-                    // 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),
+                    self.push_value(vm.ctx.none());
+                    vm.contextualize_exception(&err);
+                    return match self.unwind_blocks(vm, UnwindReason::Raising { exception: err }) {
+                        Ok(None) => {
+                            *self.prev_line = 0;
+                            self.run(vm)
+                        }
                         Ok(Some(result)) => Ok(result),
                         Err(exception) => Err(exception),
-                    }
-                });
+                    };
+                }
+                // Fall through to throw_here to raise GeneratorExit in the generator
+            } else {
+                // For non-GeneratorExit, delegate throw to sub-iterator
+                let thrower = if let Some(coro) = self.builtin_coro(jen) {
+                    Some(Either::A(coro))
+                } else {
+                    vm.get_attribute_opt(jen.to_owned(), "throw")?
+                        .map(Either::B)
+                };
+                if let Some(thrower) = thrower {
+                    let ret = match thrower {
+                        Either::A(coro) => coro
+                            .throw(jen, exc_type, exc_val, exc_tb, vm)
+                            .to_pyresult(vm),
+                        Either::B(meth) => meth.call((exc_type, exc_val, exc_tb), vm),
+                    };
+                    return ret.map(ExecutionResult::Yield).or_else(|err| {
+                        // Add traceback entry for the yield-from/await point.
+                        // gen_send_ex2 resumes the frame with a pending exception,
+                        // which goes through error: → PyTraceBack_Here. We add the
+                        // entry here before calling unwind_blocks.
+                        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 = err.__traceback__();
+                            let new_traceback = PyTraceback::new(
+                                next,
+                                self.object.to_owned(),
+                                idx as u32 * 2,
+                                loc.line,
+                            );
+                            err.set_traceback_typed(Some(new_traceback.into_ref(&vm.ctx)));
+                        }
+
+                        self.push_value(vm.ctx.none());
+                        vm.contextualize_exception(&err);
+                        match self.unwind_blocks(vm, UnwindReason::Raising { exception: err }) {
+                            Ok(None) => {
+                                *self.prev_line = 0;
+                                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)?;
+        // Validate the exception type first. Invalid types propagate directly to
+        // the caller. Valid types with failed instantiation (e.g. __new__ returns
+        // wrong type) get thrown into the generator via PyErr_SetObject path.
+        let ctor = ExceptionCtor::try_from_object(vm, exc_type)?;
+        let exception = match ctor.instantiate_value(exc_val, vm) {
+            Ok(exc) => {
+                if let Some(tb) = Option::<PyRef<PyTraceback>>::try_from_object(vm, exc_tb)? {
+                    exc.set_traceback_typed(Some(tb));
+                }
+                exc
+            }
+            Err(err) => err,
+        };
 
         // Add traceback entry for the generator frame at the yield site
         let idx = self.lasti().saturating_sub(1) as usize;
@@ -549,33 +1871,133 @@ impl ExecutingFrame<'_> {
             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);
+        // Fire PY_THROW and RAISE events before raising the exception.
+        // If a monitoring callback fails, its exception replaces the original.
+        let exception = {
+            let mon_events = vm.state.monitoring_events.load();
+            let exception = if mon_events & monitoring::EVENT_PY_THROW != 0 {
+                let offset = idx as u32 * 2;
+                let exc_obj: PyObjectRef = exception.clone().into();
+                match monitoring::fire_py_throw(vm, self.code, offset, &exc_obj) {
+                    Ok(()) => exception,
+                    Err(monitor_exc) => monitor_exc,
+                }
+            } else {
+                exception
+            };
+            if mon_events & monitoring::EVENT_RAISE != 0 {
+                let offset = idx as u32 * 2;
+                let exc_obj: PyObjectRef = exception.clone().into();
+                match monitoring::fire_raise(vm, self.code, offset, &exc_obj) {
+                    Ok(()) => exception,
+                    Err(monitor_exc) => monitor_exc,
+                }
+            } else {
+                exception
+            }
+        };
+
+        // 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(None) => {
+                // Reset prev_line so that the first instruction in the handler
+                // fires a LINE event. In CPython, gen_send_ex re-enters the
+                // eval loop which reinitializes its local prev_instr tracker.
+                *self.prev_line = 0;
+                self.run(vm)
+            }
             Ok(Some(result)) => Ok(result),
-            Err(exception) => Err(exception),
+            Err(exception) => {
+                // Fire PY_UNWIND: exception escapes the generator frame.
+                let exception =
+                    if vm.state.monitoring_events.load() & monitoring::EVENT_PY_UNWIND != 0 {
+                        let offset = idx as u32 * 2;
+                        let exc_obj: PyObjectRef = exception.clone().into();
+                        match monitoring::fire_py_unwind(vm, self.code, offset, &exc_obj) {
+                            Ok(()) => exception,
+                            Err(monitor_exc) => monitor_exc,
+                        }
+                    } else {
+                        exception
+                    };
+                Err(exception)
+            }
         }
     }
 
-    fn unbound_cell_exception(&self, i: usize, vm: &VirtualMachine) -> PyBaseExceptionRef {
-        if let Some(&name) = self.code.cellvars.get(i) {
+    fn unbound_cell_exception(
+        &self,
+        localsplus_idx: usize,
+        vm: &VirtualMachine,
+    ) -> PyBaseExceptionRef {
+        use rustpython_compiler_core::bytecode::CO_FAST_FREE;
+        let kind = self
+            .code
+            .localspluskinds
+            .get(localsplus_idx)
+            .copied()
+            .unwrap_or(0);
+        if kind & CO_FAST_FREE != 0 {
+            let name = self.localsplus_name(localsplus_idx);
+            vm.new_name_error(
+                format!("cannot access free variable '{name}' where it is not associated with a value in enclosing scope"),
+                name.to_owned(),
+            )
+        } else {
+            // Both merged cells (LOCAL|CELL) and non-merged cells get unbound local error
+            let name = self.localsplus_name(localsplus_idx);
             vm.new_exception_msg(
                 vm.ctx.exceptions.unbound_local_error.to_owned(),
-                format!("local variable '{name}' referenced before assignment"),
+                format!("local variable '{name}' referenced before assignment").into(),
             )
+        }
+    }
+
+    /// Get the variable name for a localsplus index.
+    fn localsplus_name(&self, idx: usize) -> &'static PyStrInterned {
+        use rustpython_compiler_core::bytecode::{CO_FAST_CELL, CO_FAST_FREE, CO_FAST_LOCAL};
+        let nlocals = self.code.varnames.len();
+        let kind = self.code.localspluskinds.get(idx).copied().unwrap_or(0);
+        if kind & CO_FAST_LOCAL != 0 {
+            // Merged cell or regular local: name is in varnames
+            self.code.varnames[idx]
+        } else if kind & CO_FAST_FREE != 0 {
+            // Free var: slots are at the end of localsplus
+            let nlocalsplus = self.code.localspluskinds.len();
+            let nfrees = self.code.freevars.len();
+            let free_start = nlocalsplus - nfrees;
+            self.code.freevars[idx - free_start]
+        } else if kind & CO_FAST_CELL != 0 {
+            // Non-merged cell: count how many non-merged cell slots are before
+            // this index to find the corresponding cellvars entry.
+            // Non-merged cellvars appear in their original order (skipping merged ones).
+            let nonmerged_pos = self.code.localspluskinds[nlocals..idx]
+                .iter()
+                .filter(|&&k| k == CO_FAST_CELL)
+                .count();
+            // Skip merged cellvars to find the right one
+            let mut cv_idx = 0;
+            let mut nonmerged_count = 0;
+            for (i, name) in self.code.cellvars.iter().enumerate() {
+                let is_merged = self.code.varnames.contains(name);
+                if !is_merged {
+                    if nonmerged_count == nonmerged_pos {
+                        cv_idx = i;
+                        break;
+                    }
+                    nonmerged_count += 1;
+                }
+            }
+            self.code.cellvars[cv_idx]
         } else {
-            let name = self.code.freevars[i - self.code.cellvars.len()];
-            vm.new_name_error(
-                format!("free variable '{name}' referenced before assignment in enclosing scope"),
-                name.to_owned(),
-            )
+            self.code.varnames[idx]
         }
     }
 
@@ -588,8 +2010,6 @@ impl ExecutingFrame<'_> {
         extend_arg: &mut bool,
         vm: &VirtualMachine,
     ) -> FrameResult {
-        vm.check_signals()?;
-
         flame_guard!(format!(
             "Frame::execute_instruction({})",
             instruction.display(arg, &self.code.code).to_string()
@@ -617,11 +2037,50 @@ impl ExecutingFrame<'_> {
         }
 
         match instruction {
-            Instruction::BinaryOp { op } => self.execute_bin_op(vm, op.get(arg)),
-            // TODO: In CPython, this does in-place unicode concatenation when
-            // refcount is 1. Falls back to regular iadd for now.
+            Instruction::BinaryOp { op } => {
+                let op_val = op.get(arg);
+                self.adaptive(|s, ii, cb| s.specialize_binary_op(vm, op_val, ii, cb));
+                self.execute_bin_op(vm, op_val)
+            }
+            // Super-instruction for BINARY_OP_ADD_UNICODE + STORE_FAST targeting
+            // the left local, matching BINARY_OP_INPLACE_ADD_UNICODE shape.
             Instruction::BinaryOpInplaceAddUnicode => {
-                self.execute_bin_op(vm, bytecode::BinaryOperator::InplaceAdd)
+                let b = self.top_value();
+                let a = self.nth_value(1);
+                let instr_idx = self.lasti() as usize - 1;
+                let cache_base = instr_idx + 1;
+                let target_local = self.binary_op_inplace_unicode_target_local(cache_base, a);
+                if let (Some(_a_str), Some(_b_str), Some(target_local)) = (
+                    a.downcast_ref_if_exact::<PyStr>(vm),
+                    b.downcast_ref_if_exact::<PyStr>(vm),
+                    target_local,
+                ) {
+                    let right = self.pop_value();
+                    let left = self.pop_value();
+
+                    let local_obj = self.localsplus.fastlocals_mut()[target_local]
+                        .take()
+                        .expect("BINARY_OP_INPLACE_ADD_UNICODE target local missing");
+                    debug_assert!(local_obj.is(&left));
+                    let mut local_str = local_obj
+                        .downcast_exact::<PyStr>(vm)
+                        .expect("BINARY_OP_INPLACE_ADD_UNICODE target local not exact str")
+                        .into_pyref();
+                    drop(left);
+                    let right_str = right
+                        .downcast_ref_if_exact::<PyStr>(vm)
+                        .expect("BINARY_OP_INPLACE_ADD_UNICODE right operand not exact str");
+                    local_str.concat_in_place(right_str.as_wtf8(), vm);
+
+                    self.localsplus.fastlocals_mut()[target_local] = Some(local_str.into());
+                    self.jump_relative_forward(
+                        1,
+                        Instruction::BinaryOpInplaceAddUnicode.cache_entries() as u32,
+                    );
+                    Ok(None)
+                } else {
+                    self.execute_bin_op(vm, self.binary_op_from_arg(arg))
+                }
             }
             Instruction::BinarySlice => {
                 // Stack: [container, start, stop] -> [result]
@@ -639,15 +2098,15 @@ impl ExecutingFrame<'_> {
                 self.push_value(result);
                 Ok(None)
             }
-            Instruction::BuildList { size } => {
+            Instruction::BuildList { count: size } => {
                 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)
             }
-            Instruction::BuildMap { size } => self.execute_build_map(vm, size.get(arg)),
-            Instruction::BuildSet { size } => {
+            Instruction::BuildMap { count: size } => self.execute_build_map(vm, size.get(arg)),
+            Instruction::BuildSet { count: size } => {
                 let set = PySet::default().into_ref(&vm.ctx);
                 for element in self.pop_multiple(size.get(arg) as usize) {
                     set.add(element, vm)?;
@@ -666,7 +2125,7 @@ impl ExecutingFrame<'_> {
                  Ok(None)
             }
             */
-            Instruction::BuildString { size } => {
+            Instruction::BuildString { count: size } => {
                 let s: Wtf8Buf = self
                     .pop_multiple(size.get(arg) as usize)
                     .map(|pyobj| pyobj.downcast::<PyStr>().unwrap())
@@ -674,7 +2133,7 @@ impl ExecutingFrame<'_> {
                 self.push_value(vm.ctx.new_str(s).into());
                 Ok(None)
             }
-            Instruction::BuildTuple { size } => {
+            Instruction::BuildTuple { count: 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());
@@ -696,7 +2155,7 @@ impl ExecutingFrame<'_> {
                 self.push_value(template.into_pyobject(vm));
                 Ok(None)
             }
-            Instruction::BuildInterpolation { oparg } => {
+            Instruction::BuildInterpolation { format: oparg } => {
                 // oparg encoding: (conversion << 2) | has_format_spec
                 // Stack: [value, expression_str, (format_spec)?] -> [interpolation]
                 let oparg_val = oparg.get(arg);
@@ -730,15 +2189,17 @@ impl ExecutingFrame<'_> {
                 self.push_value(interpolation.into_pyobject(vm));
                 Ok(None)
             }
-            Instruction::Call { nargs } => {
+            Instruction::Call { argc: nargs } => {
                 // Stack: [callable, self_or_null, arg1, ..., argN]
-                let args = self.collect_positional_args(nargs.get(arg));
-                self.execute_call(args, vm)
+                let nargs_val = nargs.get(arg);
+                self.adaptive(|s, ii, cb| s.specialize_call(vm, nargs_val, ii, cb));
+                self.execute_call_vectorcall(nargs_val, vm)
             }
-            Instruction::CallKw { nargs } => {
+            Instruction::CallKw { argc: nargs } => {
+                let nargs = nargs.get(arg);
+                self.adaptive(|s, ii, cb| s.specialize_call_kw(vm, nargs, ii, cb));
                 // Stack: [callable, self_or_null, arg1, ..., argN, kwarg_names]
-                let args = self.collect_keyword_args(nargs.get(arg));
-                self.execute_call(args, vm)
+                self.execute_call_kw_vectorcall(nargs, vm)
             }
             Instruction::CallFunctionEx => {
                 // Stack: [callable, self_or_null, args_tuple, kwargs_or_null]
@@ -776,8 +2237,13 @@ impl ExecutingFrame<'_> {
                 self.push_value(matched);
                 Ok(None)
             }
-            Instruction::CompareOp { op } => self.execute_compare(vm, op.get(arg)),
-            Instruction::ContainsOp(invert) => {
+            Instruction::CompareOp { opname: op } => {
+                let op_val = op.get(arg);
+                self.adaptive(|s, ii, cb| s.specialize_compare_op(vm, op_val, ii, cb));
+                self.execute_compare(vm, op_val)
+            }
+            Instruction::ContainsOp { invert } => {
+                self.adaptive(|s, ii, cb| s.specialize_contains_op(vm, ii, cb));
                 let b = self.pop_value();
                 let a = self.pop_value();
 
@@ -791,47 +2257,59 @@ impl ExecutingFrame<'_> {
             Instruction::ConvertValue { oparg: conversion } => {
                 self.convert_value(conversion.get(arg), vm)
             }
-            Instruction::Copy { index } => {
+            Instruction::Copy { i: index } => {
                 // CopyItem { index: 1 } copies TOS
                 // CopyItem { index: 2 } copies second from top
                 // This is 1-indexed to match CPython
                 let idx = index.get(arg) as usize;
-                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_opt(value);
+                let stack_len = self.localsplus.stack_len();
+                debug_assert!(stack_len >= idx, "CopyItem: stack underflow");
+                let value = self.localsplus.stack_index(stack_len - idx).clone();
+                self.push_stackref_opt(value);
                 Ok(None)
             }
-            Instruction::CopyFreeVars { .. } => {
-                // Free vars are already set up at frame creation time in RustPython
+            Instruction::CopyFreeVars { n } => {
+                let n = n.get(arg) as usize;
+                if n > 0 {
+                    let closure = self
+                        .object
+                        .func_obj
+                        .as_ref()
+                        .and_then(|f| f.downcast_ref::<PyFunction>())
+                        .and_then(|f| f.closure.as_ref());
+                    let nlocalsplus = self.code.localspluskinds.len();
+                    let freevar_start = nlocalsplus - n;
+                    let fastlocals = self.localsplus.fastlocals_mut();
+                    if let Some(closure) = closure {
+                        for i in 0..n {
+                            fastlocals[freevar_start + i] = Some(closure[i].clone().into());
+                        }
+                    }
+                }
                 Ok(None)
             }
-            Instruction::DeleteAttr { idx } => self.delete_attr(vm, idx.get(arg)),
-            Instruction::DeleteDeref(i) => {
-                self.cells_frees[i.get(arg) as usize].set(None);
+            Instruction::DeleteAttr { namei: idx } => self.delete_attr(vm, idx.get(arg)),
+            Instruction::DeleteDeref { i } => {
+                self.cell_ref(i.get(arg).as_usize()).set(None);
                 Ok(None)
             }
-            Instruction::DeleteFast(idx) => {
-                let mut fastlocals = self.fastlocals.lock();
-                let idx = idx.get(arg) as usize;
+            Instruction::DeleteFast { var_num } => {
+                let fastlocals = self.localsplus.fastlocals_mut();
+                let idx = var_num.get(arg);
                 if fastlocals[idx].is_none() {
                     return Err(vm.new_exception_msg(
                         vm.ctx.exceptions.unbound_local_error.to_owned(),
                         format!(
                             "local variable '{}' referenced before assignment",
                             self.code.varnames[idx]
-                        ),
+                        )
+                        .into(),
                     ));
                 }
                 fastlocals[idx] = None;
                 Ok(None)
             }
-            Instruction::DeleteGlobal(idx) => {
+            Instruction::DeleteGlobal { namei: idx } => {
                 let name = self.code.names[idx.get(arg) as usize];
                 match self.globals.del_item(name, vm) {
                     Ok(()) => {}
@@ -842,9 +2320,9 @@ impl ExecutingFrame<'_> {
                 }
                 Ok(None)
             }
-            Instruction::DeleteName(idx) => {
+            Instruction::DeleteName { namei: idx } => {
                 let name = self.code.names[idx.get(arg) as usize];
-                let res = self.locals.mapping().ass_subscript(name, None, vm);
+                let res = self.locals.mapping(vm).ass_subscript(name, None, vm);
 
                 match res {
                     Ok(()) => {}
@@ -856,7 +2334,7 @@ impl ExecutingFrame<'_> {
                 Ok(None)
             }
             Instruction::DeleteSubscr => self.execute_delete_subscript(vm),
-            Instruction::DictUpdate { index } => {
+            Instruction::DictUpdate { i: 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)
@@ -892,7 +2370,7 @@ impl ExecutingFrame<'_> {
                 dict.merge_object(source, vm)?;
                 Ok(None)
             }
-            Instruction::DictMerge { index } => {
+            Instruction::DictMerge { i: index } => {
                 let source = self.pop_value();
                 let idx = index.get(arg);
 
@@ -905,28 +2383,32 @@ impl ExecutingFrame<'_> {
 
                 let dict: &Py<PyDict> = unsafe { dict_ref.downcast_unchecked_ref() };
 
+                // Get callable for error messages
+                // Stack: [callable, self_or_null, args_tuple, kwargs_dict]
+                let callable = self.nth_value(idx + 2);
+                let func_str = Self::object_function_str(callable, vm);
+
                 // 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",
+                        "{} argument after ** must be a mapping, not {}",
+                        func_str,
                         source.class().name()
                     )));
                 }
 
-                // Check for duplicate keys
+                // Merge keys, checking for duplicates
                 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)?;
+                        let key_str = key.str(vm)?;
                         return Err(vm.new_type_error(format!(
-                            "got multiple values for keyword argument {}",
-                            key_repr.as_str()
+                            "{} got multiple values for keyword argument '{}'",
+                            func_str,
+                            key_str.as_wtf8()
                         )));
                     }
                     let value = vm.call_method(&source, "__getitem__", (key.clone(),))?;
@@ -935,9 +2417,9 @@ impl ExecutingFrame<'_> {
                 Ok(None)
             }
             Instruction::EndAsyncFor => {
-                // END_ASYNC_FOR pops (awaitable, exc) from stack
-                // Stack: [awaitable, exc] -> []
-                // exception_unwind pushes exception to stack before jumping to handler
+                // Pops (awaitable, exc) from stack.
+                // If exc is StopAsyncIteration, clears it (normal loop end).
+                // Otherwise re-raises.
                 let exc = self.pop_value();
                 let _awaitable = self.pop_value();
 
@@ -958,7 +2440,13 @@ impl ExecutingFrame<'_> {
                 *extend_arg = true;
                 Ok(None)
             }
-            Instruction::ForIter { target } => self.execute_for_iter(vm, target.get(arg)),
+            Instruction::ForIter { .. } => {
+                // Relative forward jump: target = lasti + caches + delta
+                let target = bytecode::Label::from_u32(self.lasti() + 1 + u32::from(arg));
+                self.adaptive(|s, ii, cb| s.specialize_for_iter(vm, u32::from(arg), ii, cb));
+                self.execute_for_iter(vm, target)?;
+                Ok(None)
+            }
             Instruction::FormatSimple => {
                 let value = self.pop_value();
                 let formatted = vm.format(&value, vm.ctx.new_str(""))?;
@@ -982,7 +2470,7 @@ impl ExecutingFrame<'_> {
             }
             Instruction::GetANext => {
                 #[cfg(debug_assertions)] // remove when GetANext is fully implemented
-                let orig_stack_len = self.state.stack.len();
+                let orig_stack_len = self.localsplus.stack_len();
 
                 let aiter = self.top_value();
                 let awaitable = if aiter.class().is(vm.ctx.types.async_generator) {
@@ -1022,57 +2510,48 @@ impl ExecutingFrame<'_> {
                 };
                 self.push_value(awaitable);
                 #[cfg(debug_assertions)]
-                debug_assert_eq!(orig_stack_len + 1, self.state.stack.len());
+                debug_assert_eq!(orig_stack_len + 1, self.localsplus.stack_len());
                 Ok(None)
             }
-            Instruction::GetAwaitable => {
-                use crate::protocol::PyIter;
+            Instruction::GetAwaitable { r#where: oparg } => {
+                let iterable = self.pop_value();
 
-                let awaited_obj = self.pop_value();
-                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 if awaited_obj
-                    .downcast_ref::<PyGenerator>()
-                    .is_some_and(|generator| {
-                        generator
-                            .as_coro()
-                            .frame()
-                            .code
-                            .flags
-                            .contains(bytecode::CodeFlags::ITERABLE_COROUTINE)
-                    })
-                {
-                    // Generator with CO_ITERABLE_COROUTINE flag can be awaited
-                    // (e.g., generators decorated with @types.coroutine)
-                    awaited_obj
-                } else {
-                    let await_method = vm.get_method_or_type_error(
-                        awaited_obj.clone(),
-                        identifier!(vm, __await__),
-                        || {
-                            format!(
-                                "object {} can't be used in 'await' expression",
-                                awaited_obj.class().name(),
-                            )
-                        },
-                    )?;
-                    let result = await_method.call((), vm)?;
-                    // Check that __await__ returned an iterator
-                    if !PyIter::check(&result) {
-                        return Err(vm.new_type_error(format!(
-                            "__await__() returned non-iterator of type '{}'",
-                            result.class().name()
-                        )));
+                let iter = match crate::coroutine::get_awaitable_iter(iterable.clone(), vm) {
+                    Ok(iter) => iter,
+                    Err(e) => {
+                        // _PyEval_FormatAwaitableError: override error for async with
+                        // when the type doesn't have __await__
+                        let oparg_val = oparg.get(arg);
+                        if vm
+                            .get_method(iterable.clone(), identifier!(vm, __await__))
+                            .is_none()
+                        {
+                            if oparg_val == 1 {
+                                return Err(vm.new_type_error(format!(
+                                    "'async with' received an object from __aenter__ \
+                                     that does not implement __await__: {}",
+                                    iterable.class().name()
+                                )));
+                            } else if oparg_val == 2 {
+                                return Err(vm.new_type_error(format!(
+                                    "'async with' received an object from __aexit__ \
+                                     that does not implement __await__: {}",
+                                    iterable.class().name()
+                                )));
+                            }
+                        }
+                        return Err(e);
                     }
-                    result
                 };
-                self.push_value(awaitable);
+
+                // Check if coroutine is already being awaited
+                if let Some(coro) = iter.downcast_ref::<PyCoroutine>()
+                    && coro.as_coro().frame().yield_from_target().is_some()
+                {
+                    return Err(vm.new_runtime_error("coroutine is being awaited already"));
+                }
+
+                self.push_value(iter);
                 Ok(None)
             }
             Instruction::GetIter => {
@@ -1093,8 +2572,7 @@ impl ExecutingFrame<'_> {
                         bytecode::CodeFlags::COROUTINE | bytecode::CodeFlags::ITERABLE_COROUTINE,
                     ) {
                         return Err(vm.new_type_error(
-                            "cannot 'yield from' a coroutine object in a non-coroutine generator"
-                                .to_owned(),
+                            "cannot 'yield from' a coroutine object in a non-coroutine generator",
                         ));
                     }
                     iterable
@@ -1115,16 +2593,16 @@ impl ExecutingFrame<'_> {
                 self.push_value(vm.ctx.new_int(len).into());
                 Ok(None)
             }
-            Instruction::ImportFrom { idx } => {
+            Instruction::ImportFrom { namei: idx } => {
                 let obj = self.import_from(vm, idx.get(arg))?;
                 self.push_value(obj);
                 Ok(None)
             }
-            Instruction::ImportName { idx } => {
+            Instruction::ImportName { namei: idx } => {
                 self.import(vm, Some(self.code.names[idx.get(arg) as usize]))?;
                 Ok(None)
             }
-            Instruction::IsOp(invert) => {
+            Instruction::IsOp { invert } => {
                 let b = self.pop_value();
                 let a = self.pop_value();
                 let res = a.is(&b);
@@ -1136,21 +2614,33 @@ impl ExecutingFrame<'_> {
                 self.push_value(vm.ctx.new_bool(value).into());
                 Ok(None)
             }
-            Instruction::JumpForward { target } => {
-                self.jump(target.get(arg));
+            Instruction::JumpForward { .. } => {
+                self.jump_relative_forward(u32::from(arg), 0);
+                Ok(None)
+            }
+            Instruction::JumpBackward { .. } => {
+                // CPython rewrites JUMP_BACKWARD to JUMP_BACKWARD_NO_JIT
+                // when JIT is unavailable.
+                let instr_idx = self.lasti() as usize - 1;
+                unsafe {
+                    self.code
+                        .instructions
+                        .replace_op(instr_idx, Instruction::JumpBackwardNoJit);
+                }
+                self.jump_relative_backward(u32::from(arg), 1);
                 Ok(None)
             }
-            Instruction::JumpBackward { target } => {
-                self.jump(target.get(arg));
+            Instruction::JumpBackwardJit | Instruction::JumpBackwardNoJit => {
+                self.jump_relative_backward(u32::from(arg), 1);
                 Ok(None)
             }
-            Instruction::JumpBackwardNoInterrupt { target } => {
-                self.jump(target.get(arg));
+            Instruction::JumpBackwardNoInterrupt { .. } => {
+                self.jump_relative_backward(u32::from(arg), 0);
                 Ok(None)
             }
             Instruction::ListAppend { i } => {
                 let item = self.pop_value();
-                let obj = self.nth_value(i.get(arg));
+                let obj = self.nth_value(i.get(arg) - 1);
                 let list: &Py<PyList> = unsafe {
                     // SAFETY: trust compiler
                     obj.downcast_unchecked_ref()
@@ -1160,35 +2650,74 @@ impl ExecutingFrame<'_> {
             }
             Instruction::ListExtend { i } => {
                 let iterable = self.pop_value();
-                let obj = self.nth_value(i.get(arg));
+                let obj = self.nth_value(i.get(arg) - 1);
                 let list: &Py<PyList> = unsafe {
                     // SAFETY: compiler guarantees correct type
                     obj.downcast_unchecked_ref()
                 };
-                list.extend(iterable, vm)?;
+                let type_name = iterable.class().name().to_owned();
+                // Only rewrite the error if the type is truly not iterable
+                // (no __iter__ and no __getitem__). Preserve original TypeError
+                // from custom iterables that raise during iteration.
+                let not_iterable = iterable.class().slots.iter.load().is_none()
+                    && iterable
+                        .get_class_attr(vm.ctx.intern_str("__getitem__"))
+                        .is_none();
+                list.extend(iterable, vm).map_err(|e| {
+                    if not_iterable && e.class().is(vm.ctx.exceptions.type_error) {
+                        vm.new_type_error(format!(
+                            "Value after * must be an iterable, not {type_name}"
+                        ))
+                    } else {
+                        e
+                    }
+                })?;
                 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::LoadAttr { namei: idx } => self.load_attr(vm, idx.get(arg)),
+            Instruction::LoadSuperAttr { namei: idx } => {
+                let idx_val = idx.get(arg);
+                self.adaptive(|s, ii, cb| s.specialize_load_super_attr(vm, idx_val, ii, cb));
+                self.load_super_attr(vm, idx_val)
+            }
             Instruction::LoadBuildClass => {
-                self.push_value(vm.builtins.get_attr(identifier!(vm, __build_class__), vm)?);
+                let build_class = if let Some(builtins_dict) = self.builtins_dict {
+                    builtins_dict
+                        .get_item_opt(identifier!(vm, __build_class__), vm)?
+                        .ok_or_else(|| {
+                            vm.new_name_error(
+                                "__build_class__ not found",
+                                identifier!(vm, __build_class__).to_owned(),
+                            )
+                        })?
+                } else {
+                    self.builtins
+                        .get_item(identifier!(vm, __build_class__), vm)
+                        .map_err(|e| {
+                            if e.fast_isinstance(vm.ctx.exceptions.key_error) {
+                                vm.new_name_error(
+                                    "__build_class__ not found",
+                                    identifier!(vm, __build_class__).to_owned(),
+                                )
+                            } else {
+                                e
+                            }
+                        })?
+                };
+                self.push_value(build_class);
                 Ok(None)
             }
             Instruction::LoadLocals => {
                 // Push the locals dict onto the stack
-                let locals = self.locals.clone().into_object();
+                let locals = self.locals.into_object(vm);
                 self.push_value(locals);
                 Ok(None)
             }
-            Instruction::LoadFromDictOrDeref(i) => {
+            Instruction::LoadFromDictOrDeref { i } => {
                 // Pop dict from stack (locals or classdict depending on context)
                 let class_dict = self.pop_value();
-                let i = i.get(arg) as usize;
-                let name = if i < self.code.cellvars.len() {
-                    self.code.cellvars[i]
-                } else {
-                    self.code.freevars[i - self.code.cellvars.len()]
-                };
+                let idx = i.get(arg).as_usize();
+                let name = self.localsplus_name(idx);
                 // Only treat KeyError as "not found", propagate other exceptions
                 let value = if let Some(dict_obj) = class_dict.downcast_ref::<PyDict>() {
                     dict_obj.get_item_opt(name, vm)?
@@ -1201,13 +2730,14 @@ impl ExecutingFrame<'_> {
                 };
                 self.push_value(match value {
                     Some(v) => v,
-                    None => self.cells_frees[i]
+                    None => self
+                        .cell_ref(idx)
                         .get()
-                        .ok_or_else(|| self.unbound_cell_exception(i, vm))?,
+                        .ok_or_else(|| self.unbound_cell_exception(idx, vm))?,
                 });
                 Ok(None)
             }
-            Instruction::LoadFromDictOrGlobals(idx) => {
+            Instruction::LoadFromDictOrGlobals { i: 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];
@@ -1230,8 +2760,20 @@ impl ExecutingFrame<'_> {
                 });
                 Ok(None)
             }
-            Instruction::LoadConst { idx } => {
-                self.push_value(self.code.constants[idx.get(arg) as usize].clone().into());
+            Instruction::LoadConst { consti } => {
+                self.push_value(self.code.constants[consti.get(arg)].clone().into());
+                // Mirror CPython's LOAD_CONST family transition. RustPython does
+                // not currently distinguish immortal constants at runtime.
+                let instr_idx = self.lasti() as usize - 1;
+                unsafe {
+                    self.code
+                        .instructions
+                        .replace_op(instr_idx, Instruction::LoadConstMortal);
+                }
+                Ok(None)
+            }
+            Instruction::LoadConstMortal | Instruction::LoadConstImmortal => {
+                self.push_value(self.code.constants[u32::from(arg).into()].clone().into());
                 Ok(None)
             }
             Instruction::LoadCommonConstant { idx } => {
@@ -1244,27 +2786,38 @@ impl ExecutingFrame<'_> {
                         vm.ctx.exceptions.not_implemented_error.to_owned().into()
                     }
                     CommonConstant::BuiltinTuple => vm.ctx.types.tuple_type.to_owned().into(),
-                    CommonConstant::BuiltinAll => vm.builtins.get_attr("all", vm)?,
-                    CommonConstant::BuiltinAny => vm.builtins.get_attr("any", vm)?,
+                    CommonConstant::BuiltinAll => vm
+                        .callable_cache
+                        .builtin_all
+                        .clone()
+                        .expect("builtin_all not initialized"),
+                    CommonConstant::BuiltinAny => vm
+                        .callable_cache
+                        .builtin_any
+                        .clone()
+                        .expect("builtin_any not initialized"),
+                    CommonConstant::BuiltinList => vm.ctx.types.list_type.to_owned().into(),
+                    CommonConstant::BuiltinSet => vm.ctx.types.set_type.to_owned().into(),
                 };
                 self.push_value(value);
                 Ok(None)
             }
-            Instruction::LoadSmallInt { idx } => {
+            Instruction::LoadSmallInt { i: idx } => {
                 // Push small integer (-5..=256) directly without constant table lookup
                 let value = vm.ctx.new_int(idx.get(arg) as i32);
                 self.push_value(value.into());
                 Ok(None)
             }
-            Instruction::LoadDeref(i) => {
-                let idx = i.get(arg) as usize;
-                let x = self.cells_frees[idx]
+            Instruction::LoadDeref { i } => {
+                let idx = i.get(arg).as_usize();
+                let x = self
+                    .cell_ref(idx)
                     .get()
                     .ok_or_else(|| self.unbound_cell_exception(idx, vm))?;
                 self.push_value(x);
                 Ok(None)
             }
-            Instruction::LoadFast(idx) => {
+            Instruction::LoadFast { var_num } => {
                 #[cold]
                 fn reference_error(
                     varname: &'static PyStrInterned,
@@ -1272,56 +2825,56 @@ impl ExecutingFrame<'_> {
                 ) -> PyBaseExceptionRef {
                     vm.new_exception_msg(
                         vm.ctx.exceptions.unbound_local_error.to_owned(),
-                        format!("local variable '{varname}' referenced before assignment",),
+                        format!("local variable '{varname}' referenced before assignment").into(),
                     )
                 }
-                let idx = idx.get(arg) as usize;
-                let x = self.fastlocals.lock()[idx]
+                let idx = var_num.get(arg);
+                let x = self.localsplus.fastlocals()[idx]
                     .clone()
                     .ok_or_else(|| reference_error(self.code.varnames[idx], vm))?;
                 self.push_value(x);
                 Ok(None)
             }
-            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);
+            Instruction::LoadFastAndClear { var_num } => {
+                // Save current slot value and clear it (for inlined comprehensions).
+                // Pushes NULL (None at Option level) if slot was empty, so that
+                // StoreFast can restore the empty state after the comprehension.
+                let idx = var_num.get(arg);
+                let x = self.localsplus.fastlocals_mut()[idx].take();
+                self.push_value_opt(x);
                 Ok(None)
             }
-            Instruction::LoadFastCheck(idx) => {
+            Instruction::LoadFastCheck { var_num } => {
                 // Same as LoadFast but explicitly checks for unbound locals
                 // (LoadFast in RustPython already does this check)
-                let idx = idx.get(arg) as usize;
-                let x = self.fastlocals.lock()[idx].clone().ok_or_else(|| {
+                let idx = var_num.get(arg);
+                let x = self.localsplus.fastlocals()[idx].clone().ok_or_else(|| {
                     vm.new_exception_msg(
                         vm.ctx.exceptions.unbound_local_error.to_owned(),
                         format!(
                             "local variable '{}' referenced before assignment",
                             self.code.varnames[idx]
-                        ),
+                        )
+                        .into(),
                     )
                 })?;
                 self.push_value(x);
                 Ok(None)
             }
-            Instruction::LoadFastLoadFast { arg: packed } => {
+            Instruction::LoadFastLoadFast { var_nums } => {
                 // Load two local variables at once
                 // oparg encoding: (idx1 << 4) | idx2
-                let oparg = packed.get(arg);
-                let idx1 = (oparg >> 4) as usize;
-                let idx2 = (oparg & 15) as usize;
-                let fastlocals = self.fastlocals.lock();
+                let oparg = var_nums.get(arg);
+                let (idx1, idx2) = oparg.indexes();
+                let fastlocals = self.localsplus.fastlocals();
                 let x1 = fastlocals[idx1].clone().ok_or_else(|| {
                     vm.new_exception_msg(
                         vm.ctx.exceptions.unbound_local_error.to_owned(),
                         format!(
                             "local variable '{}' referenced before assignment",
                             self.code.varnames[idx1]
-                        ),
+                        )
+                        .into(),
                     )
                 })?;
                 let x2 = fastlocals[idx2].clone().ok_or_else(|| {
@@ -1330,49 +2883,44 @@ impl ExecutingFrame<'_> {
                         format!(
                             "local variable '{}' referenced before assignment",
                             self.code.varnames[idx2]
-                        ),
+                        )
+                        .into(),
                     )
                 })?;
-                drop(fastlocals);
                 self.push_value(x1);
                 self.push_value(x2);
                 Ok(None)
             }
-            // TODO: Implement true borrow optimization (skip Arc::clone).
-            // CPython's LOAD_FAST_BORROW uses PyStackRef_Borrow to avoid refcount
-            // increment for values that are consumed within the same basic block.
-            // Possible approaches:
-            // - Store raw pointers with careful lifetime management
-            // - Add a "borrowed" variant to stack slots
-            // - Use arena allocation for short-lived stack values
-            // Currently this just clones like LoadFast.
-            Instruction::LoadFastBorrow(idx) => {
-                let idx = idx.get(arg) as usize;
-                let x = self.fastlocals.lock()[idx].clone().ok_or_else(|| {
+            // Borrow optimization not yet active; falls back to clone.
+            // push_borrowed() is available but disabled until stack
+            // lifetime issues at yield/exception points are resolved.
+            Instruction::LoadFastBorrow { var_num } => {
+                let idx = var_num.get(arg);
+                let x = self.localsplus.fastlocals()[idx].clone().ok_or_else(|| {
                     vm.new_exception_msg(
                         vm.ctx.exceptions.unbound_local_error.to_owned(),
                         format!(
                             "local variable '{}' referenced before assignment",
                             self.code.varnames[idx]
-                        ),
+                        )
+                        .into(),
                     )
                 })?;
                 self.push_value(x);
                 Ok(None)
             }
-            // TODO: Same as LoadFastBorrow - implement true borrow optimization.
-            Instruction::LoadFastBorrowLoadFastBorrow { arg: packed } => {
-                let oparg = packed.get(arg);
-                let idx1 = (oparg >> 4) as usize;
-                let idx2 = (oparg & 15) as usize;
-                let fastlocals = self.fastlocals.lock();
+            Instruction::LoadFastBorrowLoadFastBorrow { var_nums } => {
+                let oparg = var_nums.get(arg);
+                let (idx1, idx2) = oparg.indexes();
+                let fastlocals = self.localsplus.fastlocals();
                 let x1 = fastlocals[idx1].clone().ok_or_else(|| {
                     vm.new_exception_msg(
                         vm.ctx.exceptions.unbound_local_error.to_owned(),
                         format!(
                             "local variable '{}' referenced before assignment",
                             self.code.varnames[idx1]
-                        ),
+                        )
+                        .into(),
                     )
                 })?;
                 let x2 = fastlocals[idx2].clone().ok_or_else(|| {
@@ -1381,23 +2929,28 @@ impl ExecutingFrame<'_> {
                         format!(
                             "local variable '{}' referenced before assignment",
                             self.code.varnames[idx2]
-                        ),
+                        )
+                        .into(),
                     )
                 })?;
-                drop(fastlocals);
                 self.push_value(x1);
                 self.push_value(x2);
                 Ok(None)
             }
-            Instruction::LoadGlobal(idx) => {
-                let name = &self.code.names[idx.get(arg) as usize];
+            Instruction::LoadGlobal { namei: idx } => {
+                let oparg = idx.get(arg);
+                self.adaptive(|s, ii, cb| s.specialize_load_global(vm, oparg, ii, cb));
+                let name = &self.code.names[(oparg >> 1) as usize];
                 let x = self.load_global_or_builtin(name, vm)?;
                 self.push_value(x);
+                if (oparg & 1) != 0 {
+                    self.push_value_opt(None);
+                }
                 Ok(None)
             }
-            Instruction::LoadName(idx) => {
+            Instruction::LoadName { namei: idx } => {
                 let name = self.code.names[idx.get(arg) as usize];
-                let result = self.locals.mapping().subscript(name, vm);
+                let result = self.locals.mapping(vm).subscript(name, vm);
                 match result {
                     Ok(x) => self.push_value(x),
                     Err(e) if e.fast_isinstance(vm.ctx.exceptions.key_error) => {
@@ -1408,48 +2961,49 @@ impl ExecutingFrame<'_> {
                 Ok(None)
             }
             Instruction::LoadSpecial { method } => {
-                // Stack effect: 0 (replaces TOS with bound method)
-                // Input: [..., obj]
-                // Output: [..., bound_method]
+                // Pops obj, pushes (callable, self_or_null) for CALL convention.
+                // Push order: callable first (deeper), self_or_null on top.
                 use crate::vm::PyMethod;
-                use bytecode::SpecialMethod;
 
                 let obj = self.pop_value();
-                let method_name = match method.get(arg) {
-                    SpecialMethod::Enter => identifier!(vm, __enter__),
-                    SpecialMethod::Exit => identifier!(vm, __exit__),
-                    SpecialMethod::AEnter => identifier!(vm, __aenter__),
-                    SpecialMethod::AExit => identifier!(vm, __aexit__),
-                };
+                let oparg = method.get(arg);
+                let method_name = get_special_method_name(oparg, vm);
 
-                let bound = match vm.get_special_method(&obj, method_name)? {
+                match vm.get_special_method(&obj, method_name)? {
                     Some(PyMethod::Function { target, func }) => {
-                        // Create bound method: PyBoundMethod(object=target, function=func)
-                        crate::builtins::PyBoundMethod::new(target, func)
-                            .into_ref(&vm.ctx)
-                            .into()
+                        self.push_value(func); // callable (deeper)
+                        self.push_value(target); // self (TOS)
+                    }
+                    Some(PyMethod::Attribute(bound)) => {
+                        self.push_value(bound); // callable (deeper)
+                        self.push_null(); // NULL (TOS)
                     }
-                    Some(PyMethod::Attribute(bound)) => bound,
                     None => {
-                        return Err(vm.new_type_error(format!(
-                            "'{}' object does not support the context manager protocol (missed {} method)",
-                            obj.class().name(),
-                            method_name
+                        return Err(vm.new_type_error(get_special_method_error_msg(
+                            oparg,
+                            &obj.class().name(),
+                            special_method_can_suggest(&obj, oparg, vm)?,
                         )));
                     }
                 };
-                self.push_value(bound);
                 Ok(None)
             }
             Instruction::MakeFunction => self.execute_make_function(vm),
-            Instruction::MakeCell(_) => {
-                // Cell creation is handled at frame creation time in RustPython
+            Instruction::MakeCell { i } => {
+                // Wrap the current slot value (if any) in a new PyCell.
+                // For merged cells (LOCAL|CELL), this wraps the argument value.
+                // For non-merged cells, this creates an empty cell.
+                let idx = i.get(arg).as_usize();
+                let fastlocals = self.localsplus.fastlocals_mut();
+                let initial = fastlocals[idx].take();
+                let cell = PyCell::new(initial).into_ref(&vm.ctx).into();
+                fastlocals[idx] = Some(cell);
                 Ok(None)
             }
             Instruction::MapAdd { i } => {
                 let value = self.pop_value();
                 let key = self.pop_value();
-                let obj = self.nth_value(i.get(arg));
+                let obj = self.nth_value(i.get(arg) - 1);
                 let dict: &Py<PyDict> = unsafe {
                     // SAFETY: trust compiler
                     obj.downcast_unchecked_ref()
@@ -1457,7 +3011,7 @@ impl ExecutingFrame<'_> {
                 dict.set_item(&*key, value, vm)?;
                 Ok(None)
             }
-            Instruction::MatchClass(nargs) => {
+            Instruction::MatchClass { count: 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();
@@ -1485,8 +3039,9 @@ impl ExecutingFrame<'_> {
                                     // Get type names for error message
                                     let type_name = cls
                                         .downcast::<crate::builtins::PyType>()
-                                        .map(|t| t.__name__(vm).as_str().to_owned())
-                                        .unwrap_or_else(|_| String::from("?"));
+                                        .ok()
+                                        .and_then(|t| t.__name__(vm).to_str().map(str::to_owned))
+                                        .unwrap_or_else(|| String::from("?"));
                                     let match_args_type_name = match_args.class().__name__(vm);
                                     return Err(vm.new_type_error(format!(
                                         "{}.__match_args__ must be a tuple (got {})",
@@ -1511,7 +3066,7 @@ impl ExecutingFrame<'_> {
                                     Some(s) => s,
                                     None => {
                                         return Err(vm.new_type_error(
-                                            "__match_args__ elements must be strings".to_string(),
+                                            "__match_args__ elements must be strings",
                                         ));
                                     }
                                 };
@@ -1542,16 +3097,14 @@ impl ExecutingFrame<'_> {
                                 } else if nargs_val > 1 {
                                     // Too many positional arguments for MATCH_SELF
                                     return Err(vm.new_type_error(
-                                        "class pattern accepts at most 1 positional sub-pattern for MATCH_SELF types"
-                                            .to_string(),
+                                        "class pattern accepts at most 1 positional sub-pattern for MATCH_SELF types",
                                     ));
                                 }
                             } else {
                                 // No __match_args__ and not a MATCH_SELF type
                                 if nargs_val > 0 {
                                     return Err(vm.new_type_error(
-                                        "class pattern defines no positional sub-patterns (__match_args__ missing)"
-                                            .to_string(),
+                                        "class pattern defines no positional sub-patterns (__match_args__ missing)",
                                     ));
                                 }
                             }
@@ -1669,8 +3222,6 @@ impl ExecutingFrame<'_> {
             Instruction::Nop => Ok(None),
             // NOT_TAKEN is a branch prediction hint - functionally a NOP
             Instruction::NotTaken => Ok(None),
-            // Instrumented version of NOT_TAKEN - NOP without monitoring
-            Instruction::InstrumentedNotTaken => Ok(None),
             // CACHE is used by adaptive interpreter for inline caching - NOP for us
             Instruction::Cache => Ok(None),
             Instruction::ReturnGenerator => {
@@ -1700,19 +3251,19 @@ impl ExecutingFrame<'_> {
 
                 Ok(None)
             }
-            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::PopJumpIfNone { target } => {
+            Instruction::PopJumpIfFalse { .. } => self.pop_jump_if_relative(vm, arg, 1, false),
+            Instruction::PopJumpIfTrue { .. } => self.pop_jump_if_relative(vm, arg, 1, true),
+            Instruction::PopJumpIfNone { .. } => {
                 let value = self.pop_value();
                 if vm.is_none(&value) {
-                    self.jump(target.get(arg));
+                    self.jump_relative_forward(u32::from(arg), 1);
                 }
                 Ok(None)
             }
-            Instruction::PopJumpIfNotNone { target } => {
+            Instruction::PopJumpIfNotNone { .. } => {
                 let value = self.pop_value();
                 if !vm.is_none(&value) {
-                    self.jump(target.get(arg));
+                    self.jump_relative_forward(u32::from(arg), 1);
                 }
                 Ok(None)
             }
@@ -1736,17 +3287,45 @@ impl ExecutingFrame<'_> {
                 self.push_null();
                 Ok(None)
             }
-            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
-                let _resume_type = resume_arg.get(arg);
-
-                // Check for interrupts if not resuming from yield_from
-                // if resume_type < bytecode::ResumeType::AfterYieldFrom as u32 {
-                //     vm.check_signals()?;
-                // }
+            Instruction::RaiseVarargs { argc: kind } => self.execute_raise(vm, kind.get(arg)),
+            Instruction::Resume { .. } | Instruction::ResumeCheck => {
+                // Lazy quickening: initialize adaptive counters on first execution
+                if !self.code.quickened.swap(true, atomic::Ordering::Relaxed) {
+                    self.code.instructions.quicken();
+                    atomic::fence(atomic::Ordering::Release);
+                }
+                if self.monitoring_disabled_for_code(vm) {
+                    let global_ver = vm
+                        .state
+                        .instrumentation_version
+                        .load(atomic::Ordering::Acquire);
+                    monitoring::instrument_code(self.code, 0);
+                    self.code
+                        .instrumentation_version
+                        .store(global_ver, atomic::Ordering::Release);
+                    return Ok(None);
+                }
+                // Check if bytecode needs re-instrumentation
+                let global_ver = vm
+                    .state
+                    .instrumentation_version
+                    .load(atomic::Ordering::Acquire);
+                let code_ver = self
+                    .code
+                    .instrumentation_version
+                    .load(atomic::Ordering::Acquire);
+                if code_ver != global_ver {
+                    let events = {
+                        let state = vm.state.monitoring.lock();
+                        state.events_for_code(self.code.get_id())
+                    };
+                    monitoring::instrument_code(self.code, events);
+                    self.code
+                        .instrumentation_version
+                        .store(global_ver, atomic::Ordering::Release);
+                    // Re-execute this instruction (it may now be INSTRUMENTED_RESUME)
+                    self.update_lasti(|i| *i -= 1);
+                }
                 Ok(None)
             }
             Instruction::ReturnValue => {
@@ -1755,7 +3334,7 @@ impl ExecutingFrame<'_> {
             }
             Instruction::SetAdd { i } => {
                 let item = self.pop_value();
-                let obj = self.nth_value(i.get(arg));
+                let obj = self.nth_value(i.get(arg) - 1);
                 let set: &Py<PySet> = unsafe {
                     // SAFETY: trust compiler
                     obj.downcast_unchecked_ref()
@@ -1765,7 +3344,7 @@ impl ExecutingFrame<'_> {
             }
             Instruction::SetUpdate { i } => {
                 let iterable = self.pop_value();
-                let obj = self.nth_value(i.get(arg));
+                let obj = self.nth_value(i.get(arg) - 1);
                 let set: &Py<PySet> = unsafe {
                     // SAFETY: compiler guarantees correct type
                     obj.downcast_unchecked_ref()
@@ -1846,61 +3425,62 @@ impl ExecutingFrame<'_> {
                     Err(exc)
                 }
             }
-            Instruction::SetFunctionAttribute { attr } => {
+            Instruction::SetFunctionAttribute { flag: attr } => {
                 self.execute_set_function_attribute(vm, attr.get(arg))
             }
             Instruction::SetupAnnotations => self.setup_annotations(vm),
-            Instruction::StoreAttr { idx } => self.store_attr(vm, idx.get(arg)),
-            Instruction::StoreDeref(i) => {
+            Instruction::StoreAttr { namei: idx } => {
+                let idx_val = idx.get(arg);
+                self.adaptive(|s, ii, cb| s.specialize_store_attr(vm, idx_val, ii, cb));
+                self.store_attr(vm, idx_val)
+            }
+            Instruction::StoreDeref { i } => {
                 let value = self.pop_value();
-                self.cells_frees[i.get(arg) as usize].set(Some(value));
+                self.cell_ref(i.get(arg).as_usize()).set(Some(value));
                 Ok(None)
             }
-            Instruction::StoreFast(idx) => {
-                let value = self.pop_value();
-                self.fastlocals.lock()[idx.get(arg) as usize] = Some(value);
+            Instruction::StoreFast { var_num } => {
+                // pop_value_opt: allows NULL from LoadFastAndClear restore path
+                let value = self.pop_value_opt();
+                let fastlocals = self.localsplus.fastlocals_mut();
+                fastlocals[var_num.get(arg)] = value;
                 Ok(None)
             }
-            Instruction::StoreFastLoadFast {
-                store_idx,
-                load_idx,
-            } => {
-                // Store to one slot and load from another (often the same) - for inlined comprehensions
+            Instruction::StoreFastLoadFast { var_nums } => {
                 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]
+                let locals = self.localsplus.fastlocals_mut();
+                let oparg = var_nums.get(arg);
+                let (store_idx, load_idx) = oparg.indexes();
+                locals[store_idx] = Some(value);
+                let load_value = locals[load_idx]
                     .clone()
                     .expect("StoreFastLoadFast: load slot should have value after store");
-                drop(locals);
                 self.push_value(load_value);
                 Ok(None)
             }
-            Instruction::StoreFastStoreFast { arg: packed } => {
-                // Store two values to two local variables at once
-                // STORE_FAST idx1 executes first: pops TOS -> locals[idx1]
-                // STORE_FAST idx2 executes second: pops new TOS -> locals[idx2]
-                // oparg encoding: (idx1 << 4) | idx2
-                let oparg = packed.get(arg);
-                let idx1 = (oparg >> 4) as usize;
-                let idx2 = (oparg & 15) as usize;
-                let value1 = self.pop_value(); // TOS -> idx1
-                let value2 = self.pop_value(); // second -> idx2
-                let mut fastlocals = self.fastlocals.lock();
-                fastlocals[idx1] = Some(value1);
-                fastlocals[idx2] = Some(value2);
+            Instruction::StoreFastStoreFast { var_nums } => {
+                let oparg = var_nums.get(arg);
+                let (idx1, idx2) = oparg.indexes();
+                // pop_value_opt: allows NULL from LoadFastAndClear restore path
+                let value1 = self.pop_value_opt();
+                let value2 = self.pop_value_opt();
+                let fastlocals = self.localsplus.fastlocals_mut();
+                fastlocals[idx1] = value1;
+                fastlocals[idx2] = value2;
                 Ok(None)
             }
-            Instruction::StoreGlobal(idx) => {
+            Instruction::StoreGlobal { namei: idx } => {
                 let value = self.pop_value();
                 self.globals
                     .set_item(self.code.names[idx.get(arg) as usize], value, vm)?;
                 Ok(None)
             }
-            Instruction::StoreName(idx) => {
+            Instruction::StoreName { namei: 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)?;
+                self.locals
+                    .mapping(vm)
+                    .ass_subscript(name, Some(value), vm)?;
                 Ok(None)
             }
             Instruction::StoreSlice => {
@@ -1919,9 +3499,12 @@ impl ExecutingFrame<'_> {
                 container.set_item(&*slice, value, vm)?;
                 Ok(None)
             }
-            Instruction::StoreSubscr => self.execute_store_subscript(vm),
-            Instruction::Swap { index } => {
-                let len = self.state.stack.len();
+            Instruction::StoreSubscr => {
+                self.adaptive(|s, ii, cb| s.specialize_store_subscr(vm, ii, cb));
+                self.execute_store_subscript(vm)
+            }
+            Instruction::Swap { i: index } => {
+                let len = self.localsplus.stack_len();
                 debug_assert!(len > 0, "stack underflow in SWAP");
                 let i = len - 1; // TOS index
                 let index_val = index.get(arg) as usize;
@@ -1934,72 +3517,151 @@ impl ExecutingFrame<'_> {
                     len
                 );
                 let j = len - index_val;
-                self.state.stack.swap(i, j);
+                self.localsplus.stack_swap(i, j);
                 Ok(None)
             }
             Instruction::ToBool => {
+                self.adaptive(|s, ii, cb| s.specialize_to_bool(vm, ii, cb));
                 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)
             }
-            Instruction::UnpackEx { args } => {
+            Instruction::UnpackEx { counts: args } => {
                 let args = args.get(arg);
                 self.execute_unpack_ex(vm, args.before, args.after)
             }
-            Instruction::UnpackSequence { size } => self.unpack_sequence(size.get(arg), vm),
+            Instruction::UnpackSequence { count: size } => {
+                let expected = size.get(arg);
+                self.adaptive(|s, ii, cb| s.specialize_unpack_sequence(vm, expected, ii, cb));
+                self.unpack_sequence(expected, 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)
+                // Stack: [..., exit_func, self_or_null, lasti, prev_exc, exc]
+                // exit_func at TOS-4, self_or_null at TOS-3
                 let exc = vm.current_exception();
 
-                let stack_len = self.state.stack.len();
-                let exit = expect_unchecked(
-                    self.state.stack[stack_len - 4].clone(),
-                    "WithExceptStart: __exit__ is NULL",
+                let stack_len = self.localsplus.stack_len();
+                let exit_func = expect_unchecked(
+                    self.localsplus.stack_index(stack_len - 5).clone(),
+                    "WithExceptStart: exit_func is NULL",
                 );
+                let self_or_null = self.localsplus.stack_index(stack_len - 4).clone();
 
-                let args = if let Some(ref exc) = exc {
+                let (tp, val, tb) = 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)?;
-                // Push result on top of stack
+
+                let exit_res = if let Some(self_exit) = self_or_null {
+                    exit_func.call((self_exit.to_pyobj(), tp, val, tb), vm)?
+                } else {
+                    exit_func.call((tp, val, tb), vm)?
+                };
                 self.push_value(exit_res);
 
                 Ok(None)
             }
-            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)
-                let wrap = oparg.get(arg) == 0;
-                let value = if wrap && self.code.flags.contains(bytecode::CodeFlags::COROUTINE) {
-                    PyAsyncGenWrappedValue(value).into_pyobject(vm)
+            Instruction::YieldValue { .. } => {
+                debug_assert!(
+                    self.localsplus
+                        .stack_as_slice()
+                        .iter()
+                        .flatten()
+                        .all(|sr| !sr.is_borrowed()),
+                    "borrowed refs on stack at yield point"
+                );
+                Ok(Some(ExecutionResult::Yield(self.pop_value())))
+            }
+            Instruction::Send { .. } => {
+                // (receiver, v -- receiver, retval)
+                self.adaptive(|s, ii, cb| s.specialize_send(vm, ii, cb));
+                let exit_label = bytecode::Label::from_u32(self.lasti() + 1 + u32::from(arg));
+                let receiver = self.nth_value(1);
+                let can_fast_send = !self.specialization_eval_frame_active(vm)
+                    && (receiver.downcast_ref_if_exact::<PyGenerator>(vm).is_some()
+                        || receiver.downcast_ref_if_exact::<PyCoroutine>(vm).is_some())
+                    && self
+                        .builtin_coro(receiver)
+                        .is_some_and(|coro| !coro.running() && !coro.closed());
+                let val = self.pop_value();
+                let receiver = self.top_value();
+                let ret = if can_fast_send {
+                    let coro = self.builtin_coro(receiver).unwrap();
+                    if vm.is_none(&val) {
+                        coro.send_none(receiver, vm)?
+                    } else {
+                        coro.send(receiver, val, vm)?
+                    }
                 } else {
-                    value
+                    self._send(receiver, val, vm)?
                 };
-                Ok(Some(ExecutionResult::Yield(value)))
+                match ret {
+                    PyIterReturn::Return(value) => {
+                        self.push_value(value);
+                        Ok(None)
+                    }
+                    PyIterReturn::StopIteration(value) => {
+                        if vm.use_tracing.get() && !vm.is_none(&self.object.trace.lock()) {
+                            let stop_exc = vm.new_stop_iteration(value.clone());
+                            self.fire_exception_trace(&stop_exc, vm)?;
+                        }
+                        let value = vm.unwrap_or_none(value);
+                        self.push_value(value);
+                        self.jump(exit_label);
+                        Ok(None)
+                    }
+                }
             }
-            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);
+            Instruction::SendGen => {
+                let exit_label = bytecode::Label::from_u32(self.lasti() + 1 + u32::from(arg));
+                // Stack: [receiver, val] — peek receiver before popping
+                let receiver = self.nth_value(1);
+                let can_fast_send = !self.specialization_eval_frame_active(vm)
+                    && (receiver.downcast_ref_if_exact::<PyGenerator>(vm).is_some()
+                        || receiver.downcast_ref_if_exact::<PyCoroutine>(vm).is_some())
+                    && self
+                        .builtin_coro(receiver)
+                        .is_some_and(|coro| !coro.running() && !coro.closed());
                 let val = self.pop_value();
-                let receiver = self.top_value();
 
+                if can_fast_send {
+                    let receiver = self.top_value();
+                    let coro = self.builtin_coro(receiver).unwrap();
+                    let ret = if vm.is_none(&val) {
+                        coro.send_none(receiver, vm)?
+                    } else {
+                        coro.send(receiver, val, vm)?
+                    };
+                    match ret {
+                        PyIterReturn::Return(value) => {
+                            self.push_value(value);
+                            return Ok(None);
+                        }
+                        PyIterReturn::StopIteration(value) => {
+                            if vm.use_tracing.get() && !vm.is_none(&self.object.trace.lock()) {
+                                let stop_exc = vm.new_stop_iteration(value.clone());
+                                self.fire_exception_trace(&stop_exc, vm)?;
+                            }
+                            let value = vm.unwrap_or_none(value);
+                            self.push_value(value);
+                            self.jump(exit_label);
+                            return Ok(None);
+                        }
+                    }
+                }
+                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
+                        if vm.use_tracing.get() && !vm.is_none(&self.object.trace.lock()) {
+                            let stop_exc = vm.new_stop_iteration(value.clone());
+                            self.fire_exception_trace(&stop_exc, vm)?;
+                        }
                         let value = vm.unwrap_or_none(value);
                         self.push_value(value);
                         self.jump(exit_label);
@@ -2061,7 +3723,7 @@ impl ExecutingFrame<'_> {
 
                 let exc = exc
                     .downcast::<PyBaseException>()
-                    .map_err(|_| vm.new_type_error("exception expected".to_owned()))?;
+                    .map_err(|_| vm.new_type_error("exception expected"))?;
                 Err(exc)
             }
             Instruction::UnaryInvert => {
@@ -2082,713 +3744,5512 @@ impl ExecutingFrame<'_> {
                 self.push_value(vm.ctx.new_bool(!value).into());
                 Ok(None)
             }
-            _ => {
-                unreachable!("{instruction:?} instruction should not be executed")
+            // Specialized LOAD_ATTR opcodes
+            Instruction::LoadAttrMethodNoDict => {
+                let oparg = LoadAttr::from_u32(u32::from(arg));
+                let cache_base = self.lasti() as usize;
+
+                let owner = self.top_value();
+                let type_version = self.code.instructions.read_cache_u32(cache_base + 1);
+
+                if type_version != 0
+                    && owner.class().tp_version_tag.load(Acquire) == type_version
+                    && let Some(func) = self.try_read_cached_descriptor(cache_base, type_version)
+                {
+                    let owner = self.pop_value();
+                    self.push_value(func);
+                    self.push_value(owner);
+                    Ok(None)
+                } else {
+                    self.load_attr_slow(vm, oparg)
+                }
             }
-        }
-    }
+            Instruction::LoadAttrMethodLazyDict => {
+                let oparg = LoadAttr::from_u32(u32::from(arg));
+                let cache_base = self.lasti() as usize;
 
-    #[inline]
-    fn load_global_or_builtin(&self, name: &Py<PyStr>, vm: &VirtualMachine) -> PyResult {
-        self.globals
-            .get_chain(self.builtins, name, vm)?
-            .ok_or_else(|| {
-                vm.new_name_error(format!("name '{name}' is not defined"), name.to_owned())
-            })
-    }
+                let owner = self.top_value();
+                let type_version = self.code.instructions.read_cache_u32(cache_base + 1);
 
-    #[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);
-        let top = self.pop_value();
-        let from_list = match <Option<PyTupleRef>>::try_from_object(vm, top)? {
-            Some(from_list) => from_list.try_into_typed::<PyStr>(vm)?,
-            None => vm.ctx.empty_tuple_typed().to_owned(),
-        };
-        let level = usize::try_from_object(vm, self.pop_value())?;
+                if type_version != 0
+                    && owner.class().tp_version_tag.load(Acquire) == type_version
+                    && owner.dict().is_none()
+                    && let Some(func) = self.try_read_cached_descriptor(cache_base, type_version)
+                {
+                    let owner = self.pop_value();
+                    self.push_value(func);
+                    self.push_value(owner);
+                    Ok(None)
+                } else {
+                    self.load_attr_slow(vm, oparg)
+                }
+            }
+            Instruction::LoadAttrMethodWithValues => {
+                let oparg = LoadAttr::from_u32(u32::from(arg));
+                let cache_base = self.lasti() as usize;
+                let attr_name = self.code.names[oparg.name_idx() as usize];
+
+                let owner = self.top_value();
+                let type_version = self.code.instructions.read_cache_u32(cache_base + 1);
+
+                if type_version != 0 && owner.class().tp_version_tag.load(Acquire) == type_version {
+                    // Check instance dict doesn't shadow the method
+                    let shadowed = if let Some(dict) = owner.dict() {
+                        match dict.get_item_opt(attr_name, vm) {
+                            Ok(Some(_)) => true,
+                            Ok(None) => false,
+                            Err(_) => {
+                                // Dict lookup error -> use safe path.
+                                return self.load_attr_slow(vm, oparg);
+                            }
+                        }
+                    } else {
+                        false
+                    };
 
-        let module = vm.import_from(module_name, &from_list, level)?;
+                    if !shadowed
+                        && let Some(func) =
+                            self.try_read_cached_descriptor(cache_base, type_version)
+                    {
+                        let owner = self.pop_value();
+                        self.push_value(func);
+                        self.push_value(owner);
+                        return Ok(None);
+                    }
+                }
+                self.load_attr_slow(vm, oparg)
+            }
+            Instruction::LoadAttrInstanceValue => {
+                let oparg = LoadAttr::from_u32(u32::from(arg));
+                let cache_base = self.lasti() as usize;
+                let attr_name = self.code.names[oparg.name_idx() as usize];
 
-        self.push_value(module);
-        Ok(())
-    }
+                let owner = self.top_value();
+                let type_version = self.code.instructions.read_cache_u32(cache_base + 1);
 
-    #[cfg_attr(feature = "flame-it", flame("Frame"))]
-    fn import_from(&mut self, vm: &VirtualMachine, idx: bytecode::NameIdx) -> PyResult {
-        let module = self.top_value();
-        let name = self.code.names[idx as usize];
+                if type_version != 0 && owner.class().tp_version_tag.load(Acquire) == type_version {
+                    // Type version matches — no data descriptor for this attr.
+                    // Try direct dict lookup, skipping full descriptor protocol.
+                    if let Some(dict) = owner.dict()
+                        && let Some(value) = dict.get_item_opt(attr_name, vm)?
+                    {
+                        self.pop_value();
+                        self.push_value(value);
+                        return Ok(None);
+                    }
+                    // Not in instance dict — fall through to class lookup via slow path
+                }
+                self.load_attr_slow(vm, oparg)
+            }
+            Instruction::LoadAttrWithHint => {
+                let oparg = LoadAttr::from_u32(u32::from(arg));
+                let cache_base = self.lasti() as usize;
+                let attr_name = self.code.names[oparg.name_idx() as usize];
 
-        // Load attribute, and transform any error into import error.
-        if let Some(obj) = vm.get_attribute_opt(module.to_owned(), name)? {
-            return Ok(obj);
-        }
-        // fallback to importing '{module.__name__}.{name}' from sys.modules
-        let fallback_module = (|| {
-            let mod_name = module.get_attr(identifier!(vm, __name__), vm).ok()?;
-            let mod_name = mod_name.downcast_ref::<PyStr>()?;
-            let full_mod_name = format!("{mod_name}.{name}");
-            let sys_modules = vm.sys_module.get_attr("modules", vm).ok()?;
-            sys_modules.get_item(&full_mod_name, vm).ok()
-        })();
+                let owner = self.top_value();
+                let type_version = self.code.instructions.read_cache_u32(cache_base + 1);
 
-        if let Some(sub_module) = fallback_module {
-            return Ok(sub_module);
-        }
+                if type_version != 0
+                    && owner.class().tp_version_tag.load(Acquire) == type_version
+                    && let Some(dict) = owner.dict()
+                    && let Some(value) = dict.get_item_opt(attr_name, vm)?
+                {
+                    self.pop_value();
+                    if oparg.is_method() {
+                        self.push_value(value);
+                        self.push_value_opt(None);
+                    } else {
+                        self.push_value(value);
+                    }
+                    return Ok(None);
+                }
 
-        if is_module_initializing(module, vm) {
-            let module_name = module
-                .get_attr(identifier!(vm, __name__), vm)
-                .ok()
-                .and_then(|n| n.downcast_ref::<PyStr>().map(|s| s.as_str().to_owned()))
-                .unwrap_or_else(|| "<unknown>".to_owned());
+                self.load_attr_slow(vm, oparg)
+            }
+            Instruction::LoadAttrModule => {
+                let oparg = LoadAttr::from_u32(u32::from(arg));
+                let cache_base = self.lasti() as usize;
+                let attr_name = self.code.names[oparg.name_idx() as usize];
 
-            let msg = format!(
-                "cannot import name '{name}' from partially initialized module '{module_name}' (most likely due to a circular import)",
-            );
-            Err(vm.new_import_error(msg, name.to_owned()))
-        } else {
-            Err(vm.new_import_error(format!("cannot import name '{name}'"), name.to_owned()))
-        }
-    }
+                let owner = self.top_value();
+                let type_version = self.code.instructions.read_cache_u32(cache_base + 1);
 
-    #[cfg_attr(feature = "flame-it", flame("Frame"))]
-    fn import_star(&mut self, vm: &VirtualMachine) -> PyResult<()> {
-        let module = self.pop_value();
+                if type_version != 0
+                    && owner.class().tp_version_tag.load(Acquire) == type_version
+                    && let Some(module) = owner.downcast_ref_if_exact::<PyModule>(vm)
+                    && let Ok(value) = module.get_attr(attr_name, vm)
+                {
+                    self.pop_value();
+                    if oparg.is_method() {
+                        self.push_value(value);
+                        self.push_value_opt(None);
+                    } else {
+                        self.push_value(value);
+                    }
+                    return Ok(None);
+                }
+                self.load_attr_slow(vm, oparg)
+            }
+            Instruction::LoadAttrNondescriptorNoDict => {
+                let oparg = LoadAttr::from_u32(u32::from(arg));
+                let cache_base = self.lasti() as usize;
 
-        // Grab all the names from the module and put them in the context
-        if let Some(dict) = module.dict() {
-            let filter_pred: Box<dyn Fn(&str) -> bool> =
-                if let Ok(all) = dict.get_item(identifier!(vm, __all__), vm) {
-                    let all: Vec<PyStrRef> = all.try_to_value(vm)?;
-                    let all: Vec<String> = all
-                        .into_iter()
-                        .map(|name| name.as_str().to_owned())
-                        .collect();
-                    Box::new(move |name| all.contains(&name.to_owned()))
-                } else {
-                    Box::new(|name| !name.starts_with('_'))
-                };
-            for (k, v) in dict {
-                let k = PyStrRef::try_from_object(vm, k)?;
-                if filter_pred(k.as_str()) {
-                    self.locals.mapping().ass_subscript(&k, Some(v), vm)?;
+                let owner = self.top_value();
+                let type_version = self.code.instructions.read_cache_u32(cache_base + 1);
+
+                if type_version != 0
+                    && owner.class().tp_version_tag.load(Acquire) == type_version
+                    && let Some(attr) = self.try_read_cached_descriptor(cache_base, type_version)
+                {
+                    self.pop_value();
+                    if oparg.is_method() {
+                        self.push_value(attr);
+                        self.push_value_opt(None);
+                    } else {
+                        self.push_value(attr);
+                    }
+                    return Ok(None);
                 }
+                self.load_attr_slow(vm, oparg)
             }
-        }
-        Ok(())
-    }
+            Instruction::LoadAttrNondescriptorWithValues => {
+                let oparg = LoadAttr::from_u32(u32::from(arg));
+                let cache_base = self.lasti() as usize;
+                let attr_name = self.code.names[oparg.name_idx() as usize];
 
-    /// Unwind blocks.
-    /// The reason for unwinding gives a hint on what to do when
-    /// unwinding a block.
-    /// Optionally returns an exception.
-    #[cfg_attr(feature = "flame-it", flame("Frame"))]
-    fn unwind_blocks(&mut self, vm: &VirtualMachine, reason: UnwindReason) -> FrameResult {
-        // 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);
-                }
-                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.state.stack.pop();
-                    }
+                let owner = self.top_value();
+                let type_version = self.code.instructions.read_cache_u32(cache_base + 1);
 
-                    // 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());
+                if type_version != 0 && owner.class().tp_version_tag.load(Acquire) == type_version {
+                    // Instance dict has priority — check if attr is shadowed
+                    if let Some(dict) = owner.dict()
+                        && let Some(value) = dict.get_item_opt(attr_name, vm)?
+                    {
+                        self.pop_value();
+                        if oparg.is_method() {
+                            self.push_value(value);
+                            self.push_value_opt(None);
+                        } else {
+                            self.push_value(value);
+                        }
+                        return Ok(None);
+                    }
+                    // Not in instance dict — use cached class attr
+                    let Some(attr) = self.try_read_cached_descriptor(cache_base, type_version)
+                    else {
+                        return self.load_attr_slow(vm, oparg);
+                    };
+                    self.pop_value();
+                    if oparg.is_method() {
+                        self.push_value(attr);
+                        self.push_value_opt(None);
+                    } else {
+                        self.push_value(attr);
                     }
+                    return Ok(None);
+                }
+                self.load_attr_slow(vm, oparg)
+            }
+            Instruction::LoadAttrClass => {
+                let oparg = LoadAttr::from_u32(u32::from(arg));
+                let cache_base = self.lasti() as usize;
 
-                    // 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());
+                let owner = self.top_value();
+                let type_version = self.code.instructions.read_cache_u32(cache_base + 1);
 
-                    // 4. Jump to handler
-                    self.jump(bytecode::Label(entry.target));
+                if type_version != 0
+                    && let Some(owner_type) = owner.downcast_ref::<PyType>()
+                    && owner_type.tp_version_tag.load(Acquire) == type_version
+                    && let Some(attr) = self.try_read_cached_descriptor(cache_base, type_version)
+                {
+                    self.pop_value();
+                    if oparg.is_method() {
+                        self.push_value(attr);
+                        self.push_value_opt(None);
+                    } else {
+                        self.push_value(attr);
+                    }
+                    return Ok(None);
+                }
+                self.load_attr_slow(vm, oparg)
+            }
+            Instruction::LoadAttrClassWithMetaclassCheck => {
+                let oparg = LoadAttr::from_u32(u32::from(arg));
+                let cache_base = self.lasti() as usize;
+
+                let owner = self.top_value();
+                let type_version = self.code.instructions.read_cache_u32(cache_base + 1);
+                let metaclass_version = self.code.instructions.read_cache_u32(cache_base + 3);
+
+                if type_version != 0
+                    && metaclass_version != 0
+                    && let Some(owner_type) = owner.downcast_ref::<PyType>()
+                    && owner_type.tp_version_tag.load(Acquire) == type_version
+                    && owner.class().tp_version_tag.load(Acquire) == metaclass_version
+                    && let Some(attr) = self.try_read_cached_descriptor(cache_base, type_version)
+                {
+                    self.pop_value();
+                    if oparg.is_method() {
+                        self.push_value(attr);
+                        self.push_value_opt(None);
+                    } else {
+                        self.push_value(attr);
+                    }
+                    return Ok(None);
+                }
+                self.load_attr_slow(vm, oparg)
+            }
+            Instruction::LoadAttrGetattributeOverridden => {
+                let oparg = LoadAttr::from_u32(u32::from(arg));
+                let cache_base = self.lasti() as usize;
+                let owner = self.top_value();
+                let type_version = self.code.instructions.read_cache_u32(cache_base + 1);
+                let func_version = self.code.instructions.read_cache_u32(cache_base + 3);
+
+                if !oparg.is_method()
+                    && !self.specialization_eval_frame_active(vm)
+                    && type_version != 0
+                    && func_version != 0
+                    && owner.class().tp_version_tag.load(Acquire) == type_version
+                    && let Some(func_obj) =
+                        self.try_read_cached_descriptor(cache_base, type_version)
+                    && let Some(func) = func_obj.downcast_ref_if_exact::<PyFunction>(vm)
+                    && func.func_version() == func_version
+                    && self.specialization_has_datastack_space_for_func(vm, func)
+                {
+                    debug_assert!(func.has_exact_argcount(2));
+                    let owner = self.pop_value();
+                    let attr_name = self.code.names[oparg.name_idx() as usize].to_owned().into();
+                    let result = func.invoke_exact_args(vec![owner, attr_name], vm)?;
+                    self.push_value(result);
+                    return Ok(None);
+                }
+                self.load_attr_slow(vm, oparg)
+            }
+            Instruction::LoadAttrSlot => {
+                let oparg = LoadAttr::from_u32(u32::from(arg));
+                let cache_base = self.lasti() as usize;
+
+                let owner = self.top_value();
+                let type_version = self.code.instructions.read_cache_u32(cache_base + 1);
+
+                if type_version != 0 && owner.class().tp_version_tag.load(Acquire) == type_version {
+                    let slot_offset =
+                        self.code.instructions.read_cache_u32(cache_base + 3) as usize;
+                    if let Some(value) = owner.get_slot(slot_offset) {
+                        self.pop_value();
+                        if oparg.is_method() {
+                            self.push_value(value);
+                            self.push_value_opt(None);
+                        } else {
+                            self.push_value(value);
+                        }
+                        return Ok(None);
+                    }
+                    // Slot is None → AttributeError (fall through to slow path)
+                }
+                self.load_attr_slow(vm, oparg)
+            }
+            Instruction::LoadAttrProperty => {
+                let oparg = LoadAttr::from_u32(u32::from(arg));
+                let cache_base = self.lasti() as usize;
+
+                let owner = self.top_value();
+                let type_version = self.code.instructions.read_cache_u32(cache_base + 1);
+
+                if type_version != 0
+                    && !self.specialization_eval_frame_active(vm)
+                    && owner.class().tp_version_tag.load(Acquire) == type_version
+                    && let Some(fget_obj) =
+                        self.try_read_cached_descriptor(cache_base, type_version)
+                    && let Some(func) = fget_obj.downcast_ref_if_exact::<PyFunction>(vm)
+                    && func.can_specialize_call(1)
+                    && self.specialization_has_datastack_space_for_func(vm, func)
+                {
+                    let owner = self.pop_value();
+                    let result = func.invoke_exact_args(vec![owner], vm)?;
+                    self.push_value(result);
+                    return Ok(None);
+                }
+                self.load_attr_slow(vm, oparg)
+            }
+            Instruction::StoreAttrInstanceValue => {
+                let attr_idx = u32::from(arg);
+                let instr_idx = self.lasti() as usize - 1;
+                let cache_base = instr_idx + 1;
+                let attr_name = self.code.names[attr_idx as usize];
+                let owner = self.top_value();
+                let type_version = self.code.instructions.read_cache_u32(cache_base + 1);
+
+                if type_version != 0
+                    && owner.class().tp_version_tag.load(Acquire) == type_version
+                    && let Some(dict) = owner.dict()
+                {
+                    self.pop_value(); // owner
+                    let value = self.pop_value();
+                    dict.set_item(attr_name, value, vm)?;
+                    return Ok(None);
+                }
+                self.store_attr(vm, attr_idx)
+            }
+            Instruction::StoreAttrWithHint => {
+                let attr_idx = u32::from(arg);
+                let instr_idx = self.lasti() as usize - 1;
+                let cache_base = instr_idx + 1;
+                let attr_name = self.code.names[attr_idx as usize];
+                let owner = self.top_value();
+                let type_version = self.code.instructions.read_cache_u32(cache_base + 1);
+
+                if type_version != 0
+                    && owner.class().tp_version_tag.load(Acquire) == type_version
+                    && let Some(dict) = owner.dict()
+                {
+                    self.pop_value(); // owner
+                    let value = self.pop_value();
+                    dict.set_item(attr_name, value, vm)?;
+                    return Ok(None);
+                }
+                self.store_attr(vm, attr_idx)
+            }
+            Instruction::StoreAttrSlot => {
+                let instr_idx = self.lasti() as usize - 1;
+                let cache_base = instr_idx + 1;
+                let type_version = self.code.instructions.read_cache_u32(cache_base + 1);
+                let version_match = type_version != 0 && {
+                    let owner = self.top_value();
+                    owner.class().tp_version_tag.load(Acquire) == type_version
+                };
 
+                if version_match {
+                    let slot_offset =
+                        self.code.instructions.read_cache_u16(cache_base + 3) as usize;
+                    let owner = self.pop_value();
+                    let value = self.pop_value();
+                    owner.set_slot(slot_offset, Some(value));
+                    return Ok(None);
+                }
+                let attr_idx = u32::from(arg);
+                self.store_attr(vm, attr_idx)
+            }
+            Instruction::StoreSubscrListInt => {
+                // Stack: [value, obj, idx] (TOS=idx, TOS1=obj, TOS2=value)
+                let idx = self.pop_value();
+                let obj = self.pop_value();
+                let value = self.pop_value();
+                if let Some(list) = obj.downcast_ref_if_exact::<PyList>(vm)
+                    && let Some(int_idx) = idx.downcast_ref_if_exact::<PyInt>(vm)
+                    && let Some(i) = specialization_nonnegative_compact_index(int_idx, vm)
+                {
+                    let mut vec = list.borrow_vec_mut();
+                    if i < vec.len() {
+                        vec[i] = value;
+                        return Ok(None);
+                    }
+                }
+                obj.set_item(&*idx, value, vm)?;
+                Ok(None)
+            }
+            Instruction::StoreSubscrDict => {
+                // Stack: [value, obj, idx] (TOS=idx, TOS1=obj, TOS2=value)
+                let idx = self.pop_value();
+                let obj = self.pop_value();
+                let value = self.pop_value();
+                if let Some(dict) = obj.downcast_ref_if_exact::<PyDict>(vm) {
+                    dict.set_item(&*idx, value, vm)?;
                     Ok(None)
                 } else {
-                    // No handler found, propagate exception
-                    Err(exception)
+                    obj.set_item(&*idx, value, vm)?;
+                    Ok(None)
                 }
             }
-            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)) {
+            // Specialized BINARY_OP opcodes
+            Instruction::BinaryOpAddInt => {
+                self.execute_binary_op_int(vm, |a, b| a + b, bytecode::BinaryOperator::Add)
+            }
+            Instruction::BinaryOpSubtractInt => {
+                self.execute_binary_op_int(vm, |a, b| a - b, bytecode::BinaryOperator::Subtract)
+            }
+            Instruction::BinaryOpMultiplyInt => {
+                self.execute_binary_op_int(vm, |a, b| a * b, bytecode::BinaryOperator::Multiply)
+            }
+            Instruction::BinaryOpAddFloat => {
+                self.execute_binary_op_float(vm, |a, b| a + b, bytecode::BinaryOperator::Add)
+            }
+            Instruction::BinaryOpSubtractFloat => {
+                self.execute_binary_op_float(vm, |a, b| a - b, bytecode::BinaryOperator::Subtract)
+            }
+            Instruction::BinaryOpMultiplyFloat => {
+                self.execute_binary_op_float(vm, |a, b| a * b, bytecode::BinaryOperator::Multiply)
+            }
+            Instruction::BinaryOpAddUnicode => {
+                let b = self.top_value();
+                let a = self.nth_value(1);
+                if let (Some(a_str), Some(b_str)) = (
+                    a.downcast_ref_if_exact::<PyStr>(vm),
+                    b.downcast_ref_if_exact::<PyStr>(vm),
+                ) {
+                    let result = a_str.as_wtf8().py_add(b_str.as_wtf8());
+                    self.pop_value();
+                    self.pop_value();
+                    self.push_value(result.to_pyobject(vm));
+                    Ok(None)
+                } else {
+                    self.execute_bin_op(vm, bytecode::BinaryOperator::Add)
+                }
+            }
+            Instruction::BinaryOpSubscrGetitem => {
+                let owner = self.nth_value(1);
+                if !self.specialization_eval_frame_active(vm)
+                    && let Some((func, func_version)) =
+                        owner.class().get_cached_getitem_for_specialization()
+                    && func.func_version() == func_version
+                    && self.specialization_has_datastack_space_for_func(vm, &func)
+                {
+                    debug_assert!(func.has_exact_argcount(2));
+                    let sub = self.pop_value();
+                    let owner = self.pop_value();
+                    let result = func.invoke_exact_args(vec![owner, sub], vm)?;
+                    self.push_value(result);
+                    return Ok(None);
+                }
+                self.execute_bin_op(vm, bytecode::BinaryOperator::Subscr)
+            }
+            Instruction::BinaryOpExtend => {
+                let op = self.binary_op_from_arg(arg);
+                let b = self.top_value();
+                let a = self.nth_value(1);
+                let cache_base = self.lasti() as usize;
+                if let Some(descr) = self.read_cached_binary_op_extend_descr(cache_base)
+                    && descr.oparg == op
+                    && (descr.guard)(a, b, vm)
+                    && let Some(result) = (descr.action)(a, b, vm)
+                {
+                    self.pop_value();
+                    self.pop_value();
+                    self.push_value(result);
+                    Ok(None)
+                } else {
+                    self.execute_bin_op(vm, op)
+                }
+            }
+            Instruction::BinaryOpSubscrListInt => {
+                let b = self.top_value();
+                let a = self.nth_value(1);
+                if let (Some(list), Some(idx)) = (
+                    a.downcast_ref_if_exact::<PyList>(vm),
+                    b.downcast_ref_if_exact::<PyInt>(vm),
+                ) && let Some(i) = specialization_nonnegative_compact_index(idx, vm)
+                {
+                    let vec = list.borrow_vec();
+                    if i < vec.len() {
+                        let value = vec.do_get(i);
+                        drop(vec);
+                        self.pop_value();
+                        self.pop_value();
+                        self.push_value(value);
+                        return Ok(None);
+                    }
+                }
+                self.execute_bin_op(vm, bytecode::BinaryOperator::Subscr)
+            }
+            Instruction::BinaryOpSubscrTupleInt => {
+                let b = self.top_value();
+                let a = self.nth_value(1);
+                if let (Some(tuple), Some(idx)) = (
+                    a.downcast_ref_if_exact::<PyTuple>(vm),
+                    b.downcast_ref_if_exact::<PyInt>(vm),
+                ) && let Some(i) = specialization_nonnegative_compact_index(idx, vm)
+                {
+                    let elements = tuple.as_slice();
+                    if i < elements.len() {
+                        let value = elements[i].clone();
+                        self.pop_value();
+                        self.pop_value();
+                        self.push_value(value);
+                        return Ok(None);
+                    }
+                }
+                self.execute_bin_op(vm, bytecode::BinaryOperator::Subscr)
+            }
+            Instruction::BinaryOpSubscrDict => {
+                let b = self.top_value();
+                let a = self.nth_value(1);
+                if let Some(dict) = a.downcast_ref_if_exact::<PyDict>(vm) {
+                    match dict.get_item_opt(b, vm) {
+                        Ok(Some(value)) => {
+                            self.pop_value();
+                            self.pop_value();
+                            self.push_value(value);
+                            return Ok(None);
+                        }
+                        Ok(None) => {
+                            let key = self.pop_value();
+                            self.pop_value();
+                            return Err(vm.new_key_error(key));
+                        }
+                        Err(e) => {
+                            return Err(e);
+                        }
+                    }
+                }
+                self.execute_bin_op(vm, bytecode::BinaryOperator::Subscr)
+            }
+            Instruction::BinaryOpSubscrStrInt => {
+                let b = self.top_value();
+                let a = self.nth_value(1);
+                if let (Some(a_str), Some(b_int)) = (
+                    a.downcast_ref_if_exact::<PyStr>(vm),
+                    b.downcast_ref_if_exact::<PyInt>(vm),
+                ) && let Some(i) = specialization_nonnegative_compact_index(b_int, vm)
+                    && let Ok(ch) = a_str.getitem_by_index(vm, i as isize)
+                    && ch.is_ascii()
+                {
+                    let ascii_idx = ch.to_u32() as usize;
+                    self.pop_value();
+                    self.pop_value();
+                    self.push_value(vm.ctx.ascii_char_cache[ascii_idx].clone().into());
+                    return Ok(None);
+                }
+                self.execute_bin_op(vm, bytecode::BinaryOperator::Subscr)
+            }
+            Instruction::BinaryOpSubscrListSlice => {
+                let b = self.top_value();
+                let a = self.nth_value(1);
+                if a.downcast_ref_if_exact::<PyList>(vm).is_some()
+                    && b.downcast_ref::<PySlice>().is_some()
+                {
+                    let b_owned = self.pop_value();
+                    let a_owned = self.pop_value();
+                    let result = a_owned.get_item(b_owned.as_object(), vm)?;
+                    self.push_value(result);
+                    return Ok(None);
+                }
+                self.execute_bin_op(vm, bytecode::BinaryOperator::Subscr)
+            }
+            Instruction::CallPyExactArgs => {
+                let instr_idx = self.lasti() as usize - 1;
+                let cache_base = instr_idx + 1;
+                let cached_version = self.code.instructions.read_cache_u32(cache_base + 1);
+                let nargs: u32 = arg.into();
+                if self.specialization_eval_frame_active(vm) {
+                    return self.execute_call_vectorcall(nargs, vm);
+                }
+                // Stack: [callable, self_or_null, arg1, ..., argN]
+                let stack_len = self.localsplus.stack_len();
+                let self_or_null_is_some = self
+                    .localsplus
+                    .stack_index(stack_len - nargs as usize - 1)
+                    .is_some();
+                let callable = self.nth_value(nargs + 1);
+                if let Some(func) = callable.downcast_ref_if_exact::<PyFunction>(vm)
+                    && func.func_version() == cached_version
+                    && cached_version != 0
+                {
+                    let effective_nargs = nargs + u32::from(self_or_null_is_some);
+                    if !func.has_exact_argcount(effective_nargs) {
+                        return self.execute_call_vectorcall(nargs, vm);
+                    }
+                    if !self.specialization_has_datastack_space_for_func(vm, func) {
+                        return self.execute_call_vectorcall(nargs, vm);
+                    }
+                    if self.specialization_call_recursion_guard(vm) {
+                        return self.execute_call_vectorcall(nargs, vm);
+                    }
+                    let pos_args: Vec<PyObjectRef> = self.pop_multiple(nargs as usize).collect();
+                    let self_or_null = self.pop_value_opt();
+                    let callable = self.pop_value();
+                    let func = callable.downcast_ref_if_exact::<PyFunction>(vm).unwrap();
+                    let args = if let Some(self_val) = self_or_null {
+                        let mut all_args = Vec::with_capacity(pos_args.len() + 1);
+                        all_args.push(self_val);
+                        all_args.extend(pos_args);
+                        all_args
+                    } else {
+                        pos_args
+                    };
+                    let result = func.invoke_exact_args(args, vm)?;
+                    self.push_value(result);
+                    Ok(None)
+                } else {
+                    self.execute_call_vectorcall(nargs, vm)
+                }
+            }
+            Instruction::CallBoundMethodExactArgs => {
+                let instr_idx = self.lasti() as usize - 1;
+                let cache_base = instr_idx + 1;
+                let cached_version = self.code.instructions.read_cache_u32(cache_base + 1);
+                let nargs: u32 = arg.into();
+                if self.specialization_eval_frame_active(vm) {
+                    return self.execute_call_vectorcall(nargs, vm);
+                }
+                // Stack: [callable, self_or_null(NULL), arg1, ..., argN]
+                let stack_len = self.localsplus.stack_len();
+                let self_or_null_is_some = self
+                    .localsplus
+                    .stack_index(stack_len - nargs as usize - 1)
+                    .is_some();
+                let callable = self.nth_value(nargs + 1);
+                if !self_or_null_is_some
+                    && let Some(bound_method) = callable.downcast_ref_if_exact::<PyBoundMethod>(vm)
+                {
+                    let bound_function = bound_method.function_obj().clone();
+                    let bound_self = bound_method.self_obj().clone();
+                    if let Some(func) = bound_function.downcast_ref_if_exact::<PyFunction>(vm)
+                        && func.func_version() == cached_version
+                        && cached_version != 0
+                    {
+                        if !func.has_exact_argcount(nargs + 1) {
+                            return self.execute_call_vectorcall(nargs, vm);
+                        }
+                        if !self.specialization_has_datastack_space_for_func(vm, func) {
+                            return self.execute_call_vectorcall(nargs, vm);
+                        }
+                        if self.specialization_call_recursion_guard(vm) {
+                            return self.execute_call_vectorcall(nargs, vm);
+                        }
+                        let pos_args: Vec<PyObjectRef> =
+                            self.pop_multiple(nargs as usize).collect();
+                        self.pop_value_opt(); // null (self_or_null)
+                        self.pop_value(); // callable (bound method)
+                        let mut all_args = Vec::with_capacity(pos_args.len() + 1);
+                        all_args.push(bound_self);
+                        all_args.extend(pos_args);
+                        let result = func.invoke_exact_args(all_args, vm)?;
+                        self.push_value(result);
+                        return Ok(None);
+                    }
+                }
+                self.execute_call_vectorcall(nargs, vm)
+            }
+            Instruction::CallLen => {
+                let nargs: u32 = arg.into();
+                if nargs == 1 {
+                    // Stack: [callable, null, arg]
+                    let obj = self.pop_value(); // arg
+                    let null = self.pop_value_opt();
+                    let callable = self.pop_value();
+                    if null.is_none()
+                        && vm
+                            .callable_cache
+                            .len
+                            .as_ref()
+                            .is_some_and(|len_callable| callable.is(len_callable))
+                    {
+                        let len = obj.length(vm)?;
+                        self.push_value(vm.ctx.new_int(len).into());
+                        return Ok(None);
+                    }
+                    // Guard failed — re-push and fallback
+                    self.push_value(callable);
+                    self.push_value_opt(null);
+                    self.push_value(obj);
+                }
+                self.execute_call_vectorcall(nargs, vm)
+            }
+            Instruction::CallIsinstance => {
+                let nargs: u32 = arg.into();
+                let stack_len = self.localsplus.stack_len();
+                let self_or_null_is_some = self
+                    .localsplus
+                    .stack_index(stack_len - nargs as usize - 1)
+                    .is_some();
+                let effective_nargs = nargs + u32::from(self_or_null_is_some);
+                if effective_nargs == 2 {
+                    let callable = self.nth_value(nargs + 1);
+                    if vm
+                        .callable_cache
+                        .isinstance
+                        .as_ref()
+                        .is_some_and(|isinstance_callable| callable.is(isinstance_callable))
+                    {
+                        let nargs_usize = nargs as usize;
+                        let pos_args: Vec<PyObjectRef> = self.pop_multiple(nargs_usize).collect();
+                        let self_or_null = self.pop_value_opt();
+                        self.pop_value(); // callable
+                        let mut all_args = Vec::with_capacity(2);
+                        if let Some(self_val) = self_or_null {
+                            all_args.push(self_val);
+                        }
+                        all_args.extend(pos_args);
+                        let result = all_args[0].is_instance(&all_args[1], vm)?;
+                        self.push_value(vm.ctx.new_bool(result).into());
+                        return Ok(None);
+                    }
+                }
+                self.execute_call_vectorcall(nargs, vm)
+            }
+            Instruction::CallType1 => {
+                let nargs: u32 = arg.into();
+                if nargs == 1 {
+                    // Stack: [callable, null, arg]
+                    let obj = self.pop_value();
+                    let null = self.pop_value_opt();
+                    let callable = self.pop_value();
+                    if null.is_none() && callable.is(vm.ctx.types.type_type.as_object()) {
+                        let tp = obj.class().to_owned().into();
+                        self.push_value(tp);
+                        return Ok(None);
+                    }
+                    // Guard failed — re-push and fallback
+                    self.push_value(callable);
+                    self.push_value_opt(null);
+                    self.push_value(obj);
+                }
+                self.execute_call_vectorcall(nargs, vm)
+            }
+            Instruction::CallStr1 => {
+                let nargs: u32 = arg.into();
+                if nargs == 1 {
+                    let obj = self.pop_value();
+                    let null = self.pop_value_opt();
+                    let callable = self.pop_value();
+                    if null.is_none() && callable.is(vm.ctx.types.str_type.as_object()) {
+                        let result = obj.str(vm)?;
+                        self.push_value(result.into());
+                        return Ok(None);
+                    }
+                    self.push_value(callable);
+                    self.push_value_opt(null);
+                    self.push_value(obj);
+                }
+                self.execute_call_vectorcall(nargs, vm)
+            }
+            Instruction::CallTuple1 => {
+                let nargs: u32 = arg.into();
+                if nargs == 1 {
+                    let obj = self.pop_value();
+                    let null = self.pop_value_opt();
+                    let callable = self.pop_value();
+                    if null.is_none() && callable.is(vm.ctx.types.tuple_type.as_object()) {
+                        // tuple(x) returns x as-is when x is already an exact tuple
+                        if let Ok(tuple) = obj.clone().downcast_exact::<PyTuple>(vm) {
+                            self.push_value(tuple.into_pyref().into());
+                        } else {
+                            let elements: Vec<PyObjectRef> = vm.extract_elements_with(&obj, Ok)?;
+                            self.push_value(vm.ctx.new_tuple(elements).into());
+                        }
+                        return Ok(None);
+                    }
+                    self.push_value(callable);
+                    self.push_value_opt(null);
+                    self.push_value(obj);
+                }
+                self.execute_call_vectorcall(nargs, vm)
+            }
+            Instruction::CallBuiltinO => {
+                let nargs: u32 = arg.into();
+                let stack_len = self.localsplus.stack_len();
+                let self_or_null_is_some = self
+                    .localsplus
+                    .stack_index(stack_len - nargs as usize - 1)
+                    .is_some();
+                let effective_nargs = nargs + u32::from(self_or_null_is_some);
+                let callable = self.nth_value(nargs + 1);
+                if let Some(native) = callable.downcast_ref_if_exact::<PyNativeFunction>(vm) {
+                    let call_conv = native.value.flags
+                        & (PyMethodFlags::VARARGS
+                            | PyMethodFlags::FASTCALL
+                            | PyMethodFlags::NOARGS
+                            | PyMethodFlags::O
+                            | PyMethodFlags::KEYWORDS);
+                    if call_conv == PyMethodFlags::O && effective_nargs == 1 {
+                        let nargs_usize = nargs as usize;
+                        let pos_args: Vec<PyObjectRef> = self.pop_multiple(nargs_usize).collect();
+                        let self_or_null = self.pop_value_opt();
+                        let callable = self.pop_value();
+                        let mut args_vec = Vec::with_capacity(effective_nargs as usize);
+                        if let Some(self_val) = self_or_null {
+                            args_vec.push(self_val);
+                        }
+                        args_vec.extend(pos_args);
+                        let result =
+                            callable.vectorcall(args_vec, effective_nargs as usize, None, vm)?;
+                        self.push_value(result);
+                        return Ok(None);
+                    }
+                }
+                self.execute_call_vectorcall(nargs, vm)
+            }
+            Instruction::CallBuiltinFast => {
+                let nargs: u32 = arg.into();
+                let stack_len = self.localsplus.stack_len();
+                let self_or_null_is_some = self
+                    .localsplus
+                    .stack_index(stack_len - nargs as usize - 1)
+                    .is_some();
+                let effective_nargs = nargs + u32::from(self_or_null_is_some);
+                let callable = self.nth_value(nargs + 1);
+                if let Some(native) = callable.downcast_ref_if_exact::<PyNativeFunction>(vm) {
+                    let call_conv = native.value.flags
+                        & (PyMethodFlags::VARARGS
+                            | PyMethodFlags::FASTCALL
+                            | PyMethodFlags::NOARGS
+                            | PyMethodFlags::O
+                            | PyMethodFlags::KEYWORDS);
+                    if call_conv == PyMethodFlags::FASTCALL {
+                        let nargs_usize = nargs as usize;
+                        let pos_args: Vec<PyObjectRef> = self.pop_multiple(nargs_usize).collect();
+                        let self_or_null = self.pop_value_opt();
+                        let callable = self.pop_value();
+                        let mut args_vec = Vec::with_capacity(effective_nargs as usize);
+                        if let Some(self_val) = self_or_null {
+                            args_vec.push(self_val);
+                        }
+                        args_vec.extend(pos_args);
+                        let result =
+                            callable.vectorcall(args_vec, effective_nargs as usize, None, vm)?;
+                        self.push_value(result);
+                        return Ok(None);
+                    }
+                }
+                self.execute_call_vectorcall(nargs, vm)
+            }
+            Instruction::CallPyGeneral => {
+                let instr_idx = self.lasti() as usize - 1;
+                let cache_base = instr_idx + 1;
+                let cached_version = self.code.instructions.read_cache_u32(cache_base + 1);
+                let nargs: u32 = arg.into();
+                if self.specialization_eval_frame_active(vm) {
+                    return self.execute_call_vectorcall(nargs, vm);
+                }
+                let callable = self.nth_value(nargs + 1);
+                if let Some(func) = callable.downcast_ref_if_exact::<PyFunction>(vm)
+                    && func.func_version() == cached_version
+                    && cached_version != 0
+                {
+                    if self.specialization_call_recursion_guard(vm) {
+                        return self.execute_call_vectorcall(nargs, vm);
+                    }
+                    let nargs_usize = nargs as usize;
+                    let pos_args: Vec<PyObjectRef> = self.pop_multiple(nargs_usize).collect();
+                    let self_or_null = self.pop_value_opt();
+                    let callable = self.pop_value();
+                    let (args_vec, effective_nargs) = if let Some(self_val) = self_or_null {
+                        let mut v = Vec::with_capacity(nargs_usize + 1);
+                        v.push(self_val);
+                        v.extend(pos_args);
+                        (v, nargs_usize + 1)
+                    } else {
+                        (pos_args, nargs_usize)
+                    };
+                    let result =
+                        vectorcall_function(&callable, args_vec, effective_nargs, None, vm)?;
+                    self.push_value(result);
+                    Ok(None)
+                } else {
+                    self.execute_call_vectorcall(nargs, vm)
+                }
+            }
+            Instruction::CallBoundMethodGeneral => {
+                let instr_idx = self.lasti() as usize - 1;
+                let cache_base = instr_idx + 1;
+                let cached_version = self.code.instructions.read_cache_u32(cache_base + 1);
+                let nargs: u32 = arg.into();
+                if self.specialization_eval_frame_active(vm) {
+                    return self.execute_call_vectorcall(nargs, vm);
+                }
+                let stack_len = self.localsplus.stack_len();
+                let self_or_null_is_some = self
+                    .localsplus
+                    .stack_index(stack_len - nargs as usize - 1)
+                    .is_some();
+                let callable = self.nth_value(nargs + 1);
+                if !self_or_null_is_some
+                    && let Some(bound_method) = callable.downcast_ref_if_exact::<PyBoundMethod>(vm)
+                {
+                    let bound_function = bound_method.function_obj().clone();
+                    let bound_self = bound_method.self_obj().clone();
+                    if let Some(func) = bound_function.downcast_ref_if_exact::<PyFunction>(vm)
+                        && func.func_version() == cached_version
+                        && cached_version != 0
+                    {
+                        if self.specialization_call_recursion_guard(vm) {
+                            return self.execute_call_vectorcall(nargs, vm);
+                        }
+                        let nargs_usize = nargs as usize;
+                        let pos_args: Vec<PyObjectRef> = self.pop_multiple(nargs_usize).collect();
+                        self.pop_value_opt(); // null (self_or_null)
+                        self.pop_value(); // callable (bound method)
+                        let mut args_vec = Vec::with_capacity(nargs_usize + 1);
+                        args_vec.push(bound_self);
+                        args_vec.extend(pos_args);
+                        let result = vectorcall_function(
+                            &bound_function,
+                            args_vec,
+                            nargs_usize + 1,
+                            None,
+                            vm,
+                        )?;
+                        self.push_value(result);
+                        return Ok(None);
+                    }
+                }
+                self.execute_call_vectorcall(nargs, vm)
+            }
+            Instruction::CallListAppend => {
+                let nargs: u32 = arg.into();
+                if nargs == 1 {
+                    // Stack: [callable, self_or_null, item]
+                    let stack_len = self.localsplus.stack_len();
+                    let self_or_null_is_some = self.localsplus.stack_index(stack_len - 2).is_some();
+                    let callable = self.nth_value(2);
+                    let self_is_list = self
+                        .localsplus
+                        .stack_index(stack_len - 2)
+                        .as_ref()
+                        .is_some_and(|obj| obj.downcast_ref::<PyList>().is_some());
+                    if vm
+                        .callable_cache
+                        .list_append
+                        .as_ref()
+                        .is_some_and(|list_append| callable.is(list_append))
+                        && self_or_null_is_some
+                        && self_is_list
+                    {
+                        let item = self.pop_value();
+                        let self_or_null = self.pop_value_opt();
+                        let callable = self.pop_value();
+                        if let Some(list_obj) = self_or_null.as_ref()
+                            && let Some(list) = list_obj.downcast_ref::<PyList>()
+                        {
+                            list.append(item);
+                            // CALL_LIST_APPEND fuses the following POP_TOP.
+                            self.jump_relative_forward(
+                                1,
+                                Instruction::CallListAppend.cache_entries() as u32,
+                            );
+                            return Ok(None);
+                        }
+                        self.push_value(callable);
+                        self.push_value_opt(self_or_null);
+                        self.push_value(item);
+                    }
+                }
+                self.execute_call_vectorcall(nargs, vm)
+            }
+            Instruction::CallMethodDescriptorNoargs => {
+                let nargs: u32 = arg.into();
+                let stack_len = self.localsplus.stack_len();
+                let self_or_null_is_some = self
+                    .localsplus
+                    .stack_index(stack_len - nargs as usize - 1)
+                    .is_some();
+                let total_nargs = nargs + u32::from(self_or_null_is_some);
+                if total_nargs == 1 {
+                    let callable = self.nth_value(nargs + 1);
+                    let self_index =
+                        stack_len - nargs as usize - 1 + usize::from(!self_or_null_is_some);
+                    if let Some(descr) = callable.downcast_ref_if_exact::<PyMethodDescriptor>(vm)
+                        && (descr.method.flags
+                            & (PyMethodFlags::VARARGS
+                                | PyMethodFlags::FASTCALL
+                                | PyMethodFlags::NOARGS
+                                | PyMethodFlags::O
+                                | PyMethodFlags::KEYWORDS))
+                            == PyMethodFlags::NOARGS
+                        && self
+                            .localsplus
+                            .stack_index(self_index)
+                            .as_ref()
+                            .is_some_and(|self_obj| self_obj.class().is(descr.objclass))
+                    {
+                        let func = descr.method.func;
+                        let positional_args: Vec<PyObjectRef> =
+                            self.pop_multiple(nargs as usize).collect();
+                        let self_or_null = self.pop_value_opt();
+                        self.pop_value(); // callable
+                        let mut all_args = Vec::with_capacity(total_nargs as usize);
+                        if let Some(self_val) = self_or_null {
+                            all_args.push(self_val);
+                        }
+                        all_args.extend(positional_args);
+                        let args = FuncArgs {
+                            args: all_args,
+                            kwargs: Default::default(),
+                        };
+                        let result = func(vm, args)?;
+                        self.push_value(result);
+                        return Ok(None);
+                    }
+                }
+                self.execute_call_vectorcall(nargs, vm)
+            }
+            Instruction::CallMethodDescriptorO => {
+                let nargs: u32 = arg.into();
+                let stack_len = self.localsplus.stack_len();
+                let self_or_null_is_some = self
+                    .localsplus
+                    .stack_index(stack_len - nargs as usize - 1)
+                    .is_some();
+                let total_nargs = nargs + u32::from(self_or_null_is_some);
+                if total_nargs == 2 {
+                    let callable = self.nth_value(nargs + 1);
+                    let self_index =
+                        stack_len - nargs as usize - 1 + usize::from(!self_or_null_is_some);
+                    if let Some(descr) = callable.downcast_ref_if_exact::<PyMethodDescriptor>(vm)
+                        && (descr.method.flags
+                            & (PyMethodFlags::VARARGS
+                                | PyMethodFlags::FASTCALL
+                                | PyMethodFlags::NOARGS
+                                | PyMethodFlags::O
+                                | PyMethodFlags::KEYWORDS))
+                            == PyMethodFlags::O
+                        && self
+                            .localsplus
+                            .stack_index(self_index)
+                            .as_ref()
+                            .is_some_and(|self_obj| self_obj.class().is(descr.objclass))
+                    {
+                        let func = descr.method.func;
+                        let positional_args: Vec<PyObjectRef> =
+                            self.pop_multiple(nargs as usize).collect();
+                        let self_or_null = self.pop_value_opt();
+                        self.pop_value(); // callable
+                        let mut all_args = Vec::with_capacity(total_nargs as usize);
+                        if let Some(self_val) = self_or_null {
+                            all_args.push(self_val);
+                        }
+                        all_args.extend(positional_args);
+                        let args = FuncArgs {
+                            args: all_args,
+                            kwargs: Default::default(),
+                        };
+                        let result = func(vm, args)?;
+                        self.push_value(result);
+                        return Ok(None);
+                    }
+                }
+                self.execute_call_vectorcall(nargs, vm)
+            }
+            Instruction::CallMethodDescriptorFast => {
+                let nargs: u32 = arg.into();
+                let stack_len = self.localsplus.stack_len();
+                let self_or_null_is_some = self
+                    .localsplus
+                    .stack_index(stack_len - nargs as usize - 1)
+                    .is_some();
+                let total_nargs = nargs + u32::from(self_or_null_is_some);
+                let callable = self.nth_value(nargs + 1);
+                let self_index =
+                    stack_len - nargs as usize - 1 + usize::from(!self_or_null_is_some);
+                if total_nargs > 0
+                    && let Some(descr) = callable.downcast_ref_if_exact::<PyMethodDescriptor>(vm)
+                    && (descr.method.flags
+                        & (PyMethodFlags::VARARGS
+                            | PyMethodFlags::FASTCALL
+                            | PyMethodFlags::NOARGS
+                            | PyMethodFlags::O
+                            | PyMethodFlags::KEYWORDS))
+                        == PyMethodFlags::FASTCALL
+                    && self
+                        .localsplus
+                        .stack_index(self_index)
+                        .as_ref()
+                        .is_some_and(|self_obj| self_obj.class().is(descr.objclass))
+                {
+                    let func = descr.method.func;
+                    let positional_args: Vec<PyObjectRef> =
+                        self.pop_multiple(nargs as usize).collect();
+                    let self_or_null = self.pop_value_opt();
+                    self.pop_value(); // callable
+                    let mut all_args = Vec::with_capacity(total_nargs as usize);
+                    if let Some(self_val) = self_or_null {
+                        all_args.push(self_val);
+                    }
+                    all_args.extend(positional_args);
+                    let args = FuncArgs {
+                        args: all_args,
+                        kwargs: Default::default(),
+                    };
+                    let result = func(vm, args)?;
+                    self.push_value(result);
+                    return Ok(None);
+                }
+                self.execute_call_vectorcall(nargs, vm)
+            }
+            Instruction::CallBuiltinClass => {
+                let nargs: u32 = arg.into();
+                let callable = self.nth_value(nargs + 1);
+                if let Some(cls) = callable.downcast_ref::<PyType>()
+                    && cls.slots.vectorcall.load().is_some()
+                {
+                    let nargs_usize = nargs as usize;
+                    let pos_args: Vec<PyObjectRef> = self.pop_multiple(nargs_usize).collect();
+                    let self_or_null = self.pop_value_opt();
+                    let callable = self.pop_value();
+                    let self_is_some = self_or_null.is_some();
+                    let mut args_vec = Vec::with_capacity(nargs_usize + usize::from(self_is_some));
+                    if let Some(self_val) = self_or_null {
+                        args_vec.push(self_val);
+                    }
+                    args_vec.extend(pos_args);
+                    let result = callable.vectorcall(
+                        args_vec,
+                        nargs_usize + usize::from(self_is_some),
+                        None,
+                        vm,
+                    )?;
+                    self.push_value(result);
+                    return Ok(None);
+                }
+                self.execute_call_vectorcall(nargs, vm)
+            }
+            Instruction::CallAllocAndEnterInit => {
+                let instr_idx = self.lasti() as usize - 1;
+                let cache_base = instr_idx + 1;
+                let cached_version = self.code.instructions.read_cache_u32(cache_base + 1);
+                let nargs: u32 = arg.into();
+                let callable = self.nth_value(nargs + 1);
+                let stack_len = self.localsplus.stack_len();
+                let self_or_null_is_some = self
+                    .localsplus
+                    .stack_index(stack_len - nargs as usize - 1)
+                    .is_some();
+                if !self.specialization_eval_frame_active(vm)
+                    && !self_or_null_is_some
+                    && cached_version != 0
+                    && let Some(cls) = callable.downcast_ref::<PyType>()
+                    && cls.tp_version_tag.load(Acquire) == cached_version
+                    && let Some(init_func) = cls.get_cached_init_for_specialization(cached_version)
+                    && let Some(cls_alloc) = cls.slots.alloc.load()
+                {
+                    // Match CPython's `code->co_framesize + _Py_InitCleanup.co_framesize`
+                    // shape, using RustPython's datastack-backed frame size
+                    // equivalent for the extra shim frame.
+                    let init_cleanup_stack_bytes =
+                        datastack_frame_size_bytes_for_code(&vm.ctx.init_cleanup_code)
+                            .expect("_Py_InitCleanup shim is not a generator/coroutine");
+                    if !self.specialization_has_datastack_space_for_func_with_extra(
+                        vm,
+                        &init_func,
+                        init_cleanup_stack_bytes,
+                    ) {
+                        return self.execute_call_vectorcall(nargs, vm);
+                    }
+                    // CPython creates `_Py_InitCleanup` + `__init__` frames here.
+                    // Keep the guard conservative and deopt when the effective
+                    // recursion budget for those two frames is not available.
+                    if self.specialization_call_recursion_guard_with_extra_frames(vm, 1) {
+                        return self.execute_call_vectorcall(nargs, vm);
+                    }
+                    // Allocate object directly (tp_new == object.__new__, tp_alloc == generic).
+                    let cls_ref = cls.to_owned();
+                    let new_obj = cls_alloc(cls_ref, 0, vm)?;
+
+                    // Build args: [new_obj, arg1, ..., argN]
+                    let pos_args: Vec<PyObjectRef> = self.pop_multiple(nargs as usize).collect();
+                    let _null = self.pop_value_opt(); // self_or_null (None)
+                    let _callable = self.pop_value(); // callable (type)
+                    let result = self
+                        .specialization_run_init_cleanup_shim(new_obj, &init_func, pos_args, vm)?;
+                    self.push_value(result);
+                    return Ok(None);
+                }
+                self.execute_call_vectorcall(nargs, vm)
+            }
+            Instruction::CallMethodDescriptorFastWithKeywords => {
+                // Native function interface is uniform regardless of keyword support
+                let nargs: u32 = arg.into();
+                let stack_len = self.localsplus.stack_len();
+                let self_or_null_is_some = self
+                    .localsplus
+                    .stack_index(stack_len - nargs as usize - 1)
+                    .is_some();
+                let total_nargs = nargs + u32::from(self_or_null_is_some);
+                let callable = self.nth_value(nargs + 1);
+                let self_index =
+                    stack_len - nargs as usize - 1 + usize::from(!self_or_null_is_some);
+                if total_nargs > 0
+                    && let Some(descr) = callable.downcast_ref_if_exact::<PyMethodDescriptor>(vm)
+                    && (descr.method.flags
+                        & (PyMethodFlags::VARARGS
+                            | PyMethodFlags::FASTCALL
+                            | PyMethodFlags::NOARGS
+                            | PyMethodFlags::O
+                            | PyMethodFlags::KEYWORDS))
+                        == (PyMethodFlags::FASTCALL | PyMethodFlags::KEYWORDS)
+                    && self
+                        .localsplus
+                        .stack_index(self_index)
+                        .as_ref()
+                        .is_some_and(|self_obj| self_obj.class().is(descr.objclass))
+                {
+                    let func = descr.method.func;
+                    let positional_args: Vec<PyObjectRef> =
+                        self.pop_multiple(nargs as usize).collect();
+                    let self_or_null = self.pop_value_opt();
+                    self.pop_value(); // callable
+                    let mut all_args = Vec::with_capacity(total_nargs as usize);
+                    if let Some(self_val) = self_or_null {
+                        all_args.push(self_val);
+                    }
+                    all_args.extend(positional_args);
+                    let args = FuncArgs {
+                        args: all_args,
+                        kwargs: Default::default(),
+                    };
+                    let result = func(vm, args)?;
+                    self.push_value(result);
+                    return Ok(None);
+                }
+                self.execute_call_vectorcall(nargs, vm)
+            }
+            Instruction::CallBuiltinFastWithKeywords => {
+                // Native function interface is uniform regardless of keyword support
+                let nargs: u32 = arg.into();
+                let stack_len = self.localsplus.stack_len();
+                let self_or_null_is_some = self
+                    .localsplus
+                    .stack_index(stack_len - nargs as usize - 1)
+                    .is_some();
+                let effective_nargs = nargs + u32::from(self_or_null_is_some);
+                let callable = self.nth_value(nargs + 1);
+                if let Some(native) = callable.downcast_ref_if_exact::<PyNativeFunction>(vm) {
+                    let call_conv = native.value.flags
+                        & (PyMethodFlags::VARARGS
+                            | PyMethodFlags::FASTCALL
+                            | PyMethodFlags::NOARGS
+                            | PyMethodFlags::O
+                            | PyMethodFlags::KEYWORDS);
+                    if call_conv == (PyMethodFlags::FASTCALL | PyMethodFlags::KEYWORDS) {
+                        let nargs_usize = nargs as usize;
+                        let pos_args: Vec<PyObjectRef> = self.pop_multiple(nargs_usize).collect();
+                        let self_or_null = self.pop_value_opt();
+                        let callable = self.pop_value();
+                        let mut args_vec = Vec::with_capacity(effective_nargs as usize);
+                        if let Some(self_val) = self_or_null {
+                            args_vec.push(self_val);
+                        }
+                        args_vec.extend(pos_args);
+                        let result =
+                            callable.vectorcall(args_vec, effective_nargs as usize, None, vm)?;
+                        self.push_value(result);
+                        return Ok(None);
+                    }
+                }
+                self.execute_call_vectorcall(nargs, vm)
+            }
+            Instruction::CallNonPyGeneral => {
+                let nargs: u32 = arg.into();
+                let stack_len = self.localsplus.stack_len();
+                let self_or_null_is_some = self
+                    .localsplus
+                    .stack_index(stack_len - nargs as usize - 1)
+                    .is_some();
+                let callable = self.nth_value(nargs + 1);
+                if callable.downcast_ref_if_exact::<PyFunction>(vm).is_some()
+                    || callable
+                        .downcast_ref_if_exact::<PyBoundMethod>(vm)
+                        .is_some()
+                {
+                    return self.execute_call_vectorcall(nargs, vm);
+                }
+                let nargs_usize = nargs as usize;
+                let pos_args: Vec<PyObjectRef> = self.pop_multiple(nargs_usize).collect();
+                let self_or_null = self.pop_value_opt();
+                let callable = self.pop_value();
+                let mut args_vec =
+                    Vec::with_capacity(nargs_usize + usize::from(self_or_null_is_some));
+                if let Some(self_val) = self_or_null {
+                    args_vec.push(self_val);
+                }
+                args_vec.extend(pos_args);
+                let result = callable.vectorcall(
+                    args_vec,
+                    nargs_usize + usize::from(self_or_null_is_some),
+                    None,
+                    vm,
+                )?;
+                self.push_value(result);
+                Ok(None)
+            }
+            Instruction::CallKwPy => {
+                let instr_idx = self.lasti() as usize - 1;
+                let cache_base = instr_idx + 1;
+                let cached_version = self.code.instructions.read_cache_u32(cache_base + 1);
+                let nargs: u32 = arg.into();
+                if self.specialization_eval_frame_active(vm) {
+                    return self.execute_call_kw_vectorcall(nargs, vm);
+                }
+                // Stack: [callable, self_or_null, arg1, ..., argN, kwarg_names]
+                let callable = self.nth_value(nargs + 2);
+                if let Some(func) = callable.downcast_ref_if_exact::<PyFunction>(vm)
+                    && func.func_version() == cached_version
+                    && cached_version != 0
+                {
+                    if self.specialization_call_recursion_guard(vm) {
+                        return self.execute_call_kw_vectorcall(nargs, vm);
+                    }
+                    let nargs_usize = nargs as usize;
+                    let kwarg_names_obj = self.pop_value();
+                    let kwarg_names_tuple = kwarg_names_obj
+                        .downcast_ref::<PyTuple>()
+                        .expect("kwarg names should be tuple");
+                    let kw_count = kwarg_names_tuple.len();
+                    let all_args: Vec<PyObjectRef> = self.pop_multiple(nargs_usize).collect();
+                    let self_or_null = self.pop_value_opt();
+                    let callable = self.pop_value();
+                    let pos_count = nargs_usize - kw_count;
+                    let (args_vec, effective_nargs) = if let Some(self_val) = self_or_null {
+                        let mut v = Vec::with_capacity(nargs_usize + 1);
+                        v.push(self_val);
+                        v.extend(all_args);
+                        (v, pos_count + 1)
+                    } else {
+                        (all_args, pos_count)
+                    };
+                    let kwnames = kwarg_names_tuple.as_slice();
+                    let result = vectorcall_function(
+                        &callable,
+                        args_vec,
+                        effective_nargs,
+                        Some(kwnames),
+                        vm,
+                    )?;
+                    self.push_value(result);
+                    return Ok(None);
+                }
+                self.execute_call_kw_vectorcall(nargs, vm)
+            }
+            Instruction::CallKwBoundMethod => {
+                let instr_idx = self.lasti() as usize - 1;
+                let cache_base = instr_idx + 1;
+                let cached_version = self.code.instructions.read_cache_u32(cache_base + 1);
+                let nargs: u32 = arg.into();
+                if self.specialization_eval_frame_active(vm) {
+                    return self.execute_call_kw_vectorcall(nargs, vm);
+                }
+                // Stack: [callable, self_or_null, arg1, ..., argN, kwarg_names]
+                let stack_len = self.localsplus.stack_len();
+                let self_or_null_is_some = self
+                    .localsplus
+                    .stack_index(stack_len - nargs as usize - 2)
+                    .is_some();
+                let callable = self.nth_value(nargs + 2);
+                if !self_or_null_is_some
+                    && let Some(bound_method) = callable.downcast_ref_if_exact::<PyBoundMethod>(vm)
+                {
+                    let bound_function = bound_method.function_obj().clone();
+                    let bound_self = bound_method.self_obj().clone();
+                    if let Some(func) = bound_function.downcast_ref_if_exact::<PyFunction>(vm)
+                        && func.func_version() == cached_version
+                        && cached_version != 0
+                    {
+                        let nargs_usize = nargs as usize;
+                        let kwarg_names_obj = self.pop_value();
+                        let kwarg_names_tuple = kwarg_names_obj
+                            .downcast_ref::<PyTuple>()
+                            .expect("kwarg names should be tuple");
+                        let kw_count = kwarg_names_tuple.len();
+                        let all_args: Vec<PyObjectRef> = self.pop_multiple(nargs_usize).collect();
+                        self.pop_value_opt(); // null (self_or_null)
+                        self.pop_value(); // callable (bound method)
+                        let pos_count = nargs_usize - kw_count;
+                        let mut args_vec = Vec::with_capacity(nargs_usize + 1);
+                        args_vec.push(bound_self);
+                        args_vec.extend(all_args);
+                        let kwnames = kwarg_names_tuple.as_slice();
+                        let result = vectorcall_function(
+                            &bound_function,
+                            args_vec,
+                            pos_count + 1,
+                            Some(kwnames),
+                            vm,
+                        )?;
+                        self.push_value(result);
+                        return Ok(None);
+                    }
+                }
+                self.execute_call_kw_vectorcall(nargs, vm)
+            }
+            Instruction::CallKwNonPy => {
+                let nargs: u32 = arg.into();
+                let stack_len = self.localsplus.stack_len();
+                let self_or_null_is_some = self
+                    .localsplus
+                    .stack_index(stack_len - nargs as usize - 2)
+                    .is_some();
+                let callable = self.nth_value(nargs + 2);
+                if callable.downcast_ref_if_exact::<PyFunction>(vm).is_some()
+                    || callable
+                        .downcast_ref_if_exact::<PyBoundMethod>(vm)
+                        .is_some()
+                {
+                    return self.execute_call_kw_vectorcall(nargs, vm);
+                }
+                let nargs_usize = nargs as usize;
+                let kwarg_names_obj = self.pop_value();
+                let kwarg_names_tuple = kwarg_names_obj
+                    .downcast_ref::<PyTuple>()
+                    .expect("kwarg names should be tuple");
+                let kw_count = kwarg_names_tuple.len();
+                let all_args: Vec<PyObjectRef> = self.pop_multiple(nargs_usize).collect();
+                let self_or_null = self.pop_value_opt();
+                let callable = self.pop_value();
+                let pos_count = nargs_usize - kw_count;
+                let mut args_vec =
+                    Vec::with_capacity(nargs_usize + usize::from(self_or_null_is_some));
+                if let Some(self_val) = self_or_null {
+                    args_vec.push(self_val);
+                }
+                args_vec.extend(all_args);
+                let result = callable.vectorcall(
+                    args_vec,
+                    pos_count + usize::from(self_or_null_is_some),
+                    Some(kwarg_names_tuple.as_slice()),
+                    vm,
+                )?;
+                self.push_value(result);
+                Ok(None)
+            }
+            Instruction::LoadSuperAttrAttr => {
+                let oparg = u32::from(arg);
+                let attr_name = self.code.names[(oparg >> 2) as usize];
+                // Stack: [global_super, class, self]
+                let self_obj = self.top_value();
+                let class_obj = self.nth_value(1);
+                let global_super = self.nth_value(2);
+                // Guard: global_super is builtin super and class is a type
+                if global_super.is(&vm.ctx.types.super_type.as_object())
+                    && class_obj.downcast_ref::<PyType>().is_some()
+                {
+                    let class = class_obj.downcast_ref::<PyType>().unwrap();
+                    let start_type = self_obj.class();
+                    // MRO lookup: skip classes up to and including `class`, then search
+                    let mro: Vec<PyRef<PyType>> = start_type.mro_map_collect(|x| x.to_owned());
+                    let mut found = None;
+                    let mut past_class = false;
+                    for cls in &mro {
+                        if !past_class {
+                            if cls.is(class) {
+                                past_class = true;
+                            }
                             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);
+                        if let Some(descr) = cls.get_direct_attr(attr_name) {
+                            // Call descriptor __get__ if available
+                            // Pass None for obj when self IS its own type (classmethod)
+                            let obj_arg = if self_obj.is(start_type.as_object()) {
+                                None
+                            } else {
+                                Some(self_obj.to_owned())
+                            };
+                            let result = vm
+                                .call_get_descriptor_specific(
+                                    &descr,
+                                    obj_arg,
+                                    Some(start_type.as_object().to_owned()),
+                                )
+                                .unwrap_or(Ok(descr))?;
+                            found = Some(result);
+                            break;
+                        }
+                    }
+                    if let Some(attr) = found {
+                        self.pop_value(); // self
+                        self.pop_value(); // class
+                        self.pop_value(); // super
+                        self.push_value(attr);
+                        return Ok(None);
+                    }
+                }
+                let oparg = LoadSuperAttr::from_u32(oparg);
+                self.load_super_attr(vm, oparg)
+            }
+            Instruction::LoadSuperAttrMethod => {
+                let oparg = u32::from(arg);
+                let attr_name = self.code.names[(oparg >> 2) as usize];
+                // Stack: [global_super, class, self]
+                let self_obj = self.top_value();
+                let class_obj = self.nth_value(1);
+                let global_super = self.nth_value(2);
+                // Guard: global_super is builtin super and class is a type
+                if global_super.is(&vm.ctx.types.super_type.as_object())
+                    && class_obj.downcast_ref::<PyType>().is_some()
+                {
+                    let class = class_obj.downcast_ref::<PyType>().unwrap();
+                    let self_val = self_obj.to_owned();
+                    let start_type = self_obj.class();
+                    // MRO lookup
+                    let mro: Vec<PyRef<PyType>> = start_type.mro_map_collect(|x| x.to_owned());
+                    let mut found = None;
+                    let mut past_class = false;
+                    for cls in &mro {
+                        if !past_class {
+                            if cls.is(class) {
+                                past_class = true;
+                            }
+                            continue;
+                        }
+                        if let Some(descr) = cls.get_direct_attr(attr_name) {
+                            let descr_cls = descr.class();
+                            if descr_cls
+                                .slots
+                                .flags
+                                .has_feature(PyTypeFlags::METHOD_DESCRIPTOR)
+                            {
+                                // Method descriptor: push unbound func + self
+                                // CALL will prepend self as first positional arg
+                                found = Some((descr, true));
+                            } else if let Some(descr_get) = descr_cls.slots.descr_get.load() {
+                                // Has __get__ but not METHOD_DESCRIPTOR: bind it
+                                let bound = descr_get(
+                                    descr,
+                                    Some(self_val.clone()),
+                                    Some(start_type.as_object().to_owned()),
+                                    vm,
+                                )?;
+                                found = Some((bound, false));
+                            } else {
+                                // Plain attribute
+                                found = Some((descr, false));
+                            }
+                            break;
+                        }
+                    }
+                    if let Some((attr, is_method)) = found {
+                        self.pop_value(); // self
+                        self.pop_value(); // class
+                        self.pop_value(); // super
+                        self.push_value(attr);
+                        if is_method {
+                            self.push_value(self_val);
+                        } else {
+                            self.push_null();
+                        }
+                        return Ok(None);
+                    }
+                }
+                let oparg = LoadSuperAttr::from_u32(oparg);
+                self.load_super_attr(vm, oparg)
+            }
+            Instruction::CompareOpInt => {
+                let b = self.top_value();
+                let a = self.nth_value(1);
+                if let (Some(a_int), Some(b_int)) = (
+                    a.downcast_ref_if_exact::<PyInt>(vm),
+                    b.downcast_ref_if_exact::<PyInt>(vm),
+                ) && let (Some(a_val), Some(b_val)) = (
+                    specialization_compact_int_value(a_int, vm),
+                    specialization_compact_int_value(b_int, vm),
+                ) {
+                    let op = self.compare_op_from_arg(arg);
+                    let result = op.eval_ord(a_val.cmp(&b_val));
+                    self.pop_value();
+                    self.pop_value();
+                    self.push_value(vm.ctx.new_bool(result).into());
+                    Ok(None)
+                } else {
+                    let op = bytecode::ComparisonOperator::try_from(u32::from(arg))
+                        .unwrap_or(bytecode::ComparisonOperator::Equal);
+                    self.execute_compare(vm, op)
+                }
+            }
+            Instruction::CompareOpFloat => {
+                let b = self.top_value();
+                let a = self.nth_value(1);
+                if let (Some(a_f), Some(b_f)) = (
+                    a.downcast_ref_if_exact::<PyFloat>(vm),
+                    b.downcast_ref_if_exact::<PyFloat>(vm),
+                ) {
+                    let op = self.compare_op_from_arg(arg);
+                    let (a, b) = (a_f.to_f64(), b_f.to_f64());
+                    // Use Rust's IEEE 754 float comparison which handles NaN correctly
+                    let result = match a.partial_cmp(&b) {
+                        Some(ord) => op.eval_ord(ord),
+                        None => op == PyComparisonOp::Ne, // NaN != anything is true
+                    };
+                    self.pop_value();
+                    self.pop_value();
+                    self.push_value(vm.ctx.new_bool(result).into());
+                    Ok(None)
+                } else {
+                    let op = bytecode::ComparisonOperator::try_from(u32::from(arg))
+                        .unwrap_or(bytecode::ComparisonOperator::Equal);
+                    self.execute_compare(vm, op)
+                }
+            }
+            Instruction::CompareOpStr => {
+                let b = self.top_value();
+                let a = self.nth_value(1);
+                if let (Some(a_str), Some(b_str)) = (
+                    a.downcast_ref_if_exact::<PyStr>(vm),
+                    b.downcast_ref_if_exact::<PyStr>(vm),
+                ) {
+                    let op = self.compare_op_from_arg(arg);
+                    if op != PyComparisonOp::Eq && op != PyComparisonOp::Ne {
+                        let op = bytecode::ComparisonOperator::try_from(u32::from(arg))
+                            .unwrap_or(bytecode::ComparisonOperator::Equal);
+                        return self.execute_compare(vm, op);
+                    }
+                    let result = op.eval_ord(a_str.as_wtf8().cmp(b_str.as_wtf8()));
+                    self.pop_value();
+                    self.pop_value();
+                    self.push_value(vm.ctx.new_bool(result).into());
+                    Ok(None)
+                } else {
+                    let op = bytecode::ComparisonOperator::try_from(u32::from(arg))
+                        .unwrap_or(bytecode::ComparisonOperator::Equal);
+                    self.execute_compare(vm, op)
+                }
+            }
+            Instruction::ToBoolBool => {
+                let obj = self.top_value();
+                if obj.class().is(vm.ctx.types.bool_type) {
+                    // Already a bool, no-op
+                    Ok(None)
+                } else {
+                    let obj = self.pop_value();
+                    let result = obj.try_to_bool(vm)?;
+                    self.push_value(vm.ctx.new_bool(result).into());
+                    Ok(None)
+                }
+            }
+            Instruction::ToBoolInt => {
+                let obj = self.top_value();
+                if let Some(int_val) = obj.downcast_ref_if_exact::<PyInt>(vm) {
+                    let result = !int_val.as_bigint().is_zero();
+                    self.pop_value();
+                    self.push_value(vm.ctx.new_bool(result).into());
+                    Ok(None)
+                } else {
+                    let obj = self.pop_value();
+                    let result = obj.try_to_bool(vm)?;
+                    self.push_value(vm.ctx.new_bool(result).into());
+                    Ok(None)
+                }
+            }
+            Instruction::ToBoolNone => {
+                let obj = self.top_value();
+                if obj.class().is(vm.ctx.types.none_type) {
+                    self.pop_value();
+                    self.push_value(vm.ctx.new_bool(false).into());
+                    Ok(None)
+                } else {
+                    let obj = self.pop_value();
+                    let result = obj.try_to_bool(vm)?;
+                    self.push_value(vm.ctx.new_bool(result).into());
+                    Ok(None)
+                }
+            }
+            Instruction::ToBoolList => {
+                let obj = self.top_value();
+                if let Some(list) = obj.downcast_ref_if_exact::<PyList>(vm) {
+                    let result = !list.borrow_vec().is_empty();
+                    self.pop_value();
+                    self.push_value(vm.ctx.new_bool(result).into());
+                    Ok(None)
+                } else {
+                    let obj = self.pop_value();
+                    let result = obj.try_to_bool(vm)?;
+                    self.push_value(vm.ctx.new_bool(result).into());
+                    Ok(None)
+                }
+            }
+            Instruction::ToBoolStr => {
+                let obj = self.top_value();
+                if let Some(s) = obj.downcast_ref_if_exact::<PyStr>(vm) {
+                    let result = !s.is_empty();
+                    self.pop_value();
+                    self.push_value(vm.ctx.new_bool(result).into());
+                    Ok(None)
+                } else {
+                    let obj = self.pop_value();
+                    let result = obj.try_to_bool(vm)?;
+                    self.push_value(vm.ctx.new_bool(result).into());
+                    Ok(None)
+                }
+            }
+            Instruction::ToBoolAlwaysTrue => {
+                // Objects without __bool__ or __len__ are always True.
+                // Guard: check type version hasn't changed.
+                let instr_idx = self.lasti() as usize - 1;
+                let cache_base = instr_idx + 1;
+                let obj = self.top_value();
+                let cached_version = self.code.instructions.read_cache_u32(cache_base + 1);
+                if cached_version != 0 && obj.class().tp_version_tag.load(Acquire) == cached_version
+                {
+                    self.pop_value();
+                    self.push_value(vm.ctx.new_bool(true).into());
+                    Ok(None)
+                } else {
+                    let obj = self.pop_value();
+                    let result = obj.try_to_bool(vm)?;
+                    self.push_value(vm.ctx.new_bool(result).into());
+                    Ok(None)
+                }
+            }
+            Instruction::ContainsOpDict => {
+                let b = self.top_value(); // haystack
+                if let Some(dict) = b.downcast_ref_if_exact::<PyDict>(vm) {
+                    let a = self.nth_value(1); // needle
+                    let found = dict.get_item_opt(a, vm)?.is_some();
+                    self.pop_value();
+                    self.pop_value();
+                    let invert = bytecode::Invert::try_from(u32::from(arg) as u8)
+                        .unwrap_or(bytecode::Invert::No);
+                    let value = match invert {
+                        bytecode::Invert::No => found,
+                        bytecode::Invert::Yes => !found,
+                    };
+                    self.push_value(vm.ctx.new_bool(value).into());
+                    Ok(None)
+                } else {
+                    let b = self.pop_value();
+                    let a = self.pop_value();
+                    let invert = bytecode::Invert::try_from(u32::from(arg) as u8)
+                        .unwrap_or(bytecode::Invert::No);
+                    let value = match invert {
+                        bytecode::Invert::No => self._in(vm, &a, &b)?,
+                        bytecode::Invert::Yes => self._not_in(vm, &a, &b)?,
+                    };
+                    self.push_value(vm.ctx.new_bool(value).into());
+                    Ok(None)
+                }
+            }
+            Instruction::ContainsOpSet => {
+                let b = self.top_value(); // haystack
+                if b.downcast_ref_if_exact::<PySet>(vm).is_some()
+                    || b.downcast_ref_if_exact::<PyFrozenSet>(vm).is_some()
+                {
+                    let a = self.nth_value(1); // needle
+                    let found = vm._contains(b, a)?;
+                    self.pop_value();
+                    self.pop_value();
+                    let invert = bytecode::Invert::try_from(u32::from(arg) as u8)
+                        .unwrap_or(bytecode::Invert::No);
+                    let value = match invert {
+                        bytecode::Invert::No => found,
+                        bytecode::Invert::Yes => !found,
+                    };
+                    self.push_value(vm.ctx.new_bool(value).into());
+                    Ok(None)
+                } else {
+                    let b = self.pop_value();
+                    let a = self.pop_value();
+                    let invert = bytecode::Invert::try_from(u32::from(arg) as u8)
+                        .unwrap_or(bytecode::Invert::No);
+                    let value = match invert {
+                        bytecode::Invert::No => self._in(vm, &a, &b)?,
+                        bytecode::Invert::Yes => self._not_in(vm, &a, &b)?,
+                    };
+                    self.push_value(vm.ctx.new_bool(value).into());
+                    Ok(None)
+                }
+            }
+            Instruction::UnpackSequenceTwoTuple => {
+                let obj = self.top_value();
+                if let Some(tuple) = obj.downcast_ref_if_exact::<PyTuple>(vm) {
+                    let elements = tuple.as_slice();
+                    if elements.len() == 2 {
+                        let e0 = elements[0].clone();
+                        let e1 = elements[1].clone();
+                        self.pop_value();
+                        self.push_value(e1);
+                        self.push_value(e0);
+                        return Ok(None);
+                    }
+                }
+                let size = u32::from(arg);
+                self.unpack_sequence(size, vm)
+            }
+            Instruction::UnpackSequenceTuple => {
+                let size = u32::from(arg) as usize;
+                let obj = self.top_value();
+                if let Some(tuple) = obj.downcast_ref_if_exact::<PyTuple>(vm) {
+                    let elements = tuple.as_slice();
+                    if elements.len() == size {
+                        let elems: Vec<_> = elements.to_vec();
+                        self.pop_value();
+                        for elem in elems.into_iter().rev() {
+                            self.push_value(elem);
+                        }
+                        return Ok(None);
+                    }
+                }
+                self.unpack_sequence(size as u32, vm)
+            }
+            Instruction::UnpackSequenceList => {
+                let size = u32::from(arg) as usize;
+                let obj = self.top_value();
+                if let Some(list) = obj.downcast_ref_if_exact::<PyList>(vm) {
+                    let vec = list.borrow_vec();
+                    if vec.len() == size {
+                        let elems: Vec<_> = vec.to_vec();
+                        drop(vec);
+                        self.pop_value();
+                        for elem in elems.into_iter().rev() {
+                            self.push_value(elem);
+                        }
+                        return Ok(None);
+                    }
+                }
+                self.unpack_sequence(size as u32, vm)
+            }
+            Instruction::ForIterRange => {
+                let target = bytecode::Label::from_u32(self.lasti() + 1 + u32::from(arg));
+                let iter = self.top_value();
+                if let Some(range_iter) = iter.downcast_ref_if_exact::<PyRangeIterator>(vm) {
+                    if let Some(value) = range_iter.fast_next() {
+                        self.push_value(vm.ctx.new_int(value).into());
+                    } else {
+                        self.for_iter_jump_on_exhausted(target);
+                    }
+                    Ok(None)
+                } else {
+                    self.execute_for_iter(vm, target)?;
+                    Ok(None)
+                }
+            }
+            Instruction::ForIterList => {
+                let target = bytecode::Label::from_u32(self.lasti() + 1 + u32::from(arg));
+                let iter = self.top_value();
+                if let Some(list_iter) = iter.downcast_ref_if_exact::<PyListIterator>(vm) {
+                    if let Some(value) = list_iter.fast_next() {
+                        self.push_value(value);
+                    } else {
+                        self.for_iter_jump_on_exhausted(target);
+                    }
+                    Ok(None)
+                } else {
+                    self.execute_for_iter(vm, target)?;
+                    Ok(None)
+                }
+            }
+            Instruction::ForIterTuple => {
+                let target = bytecode::Label::from_u32(self.lasti() + 1 + u32::from(arg));
+                let iter = self.top_value();
+                if let Some(tuple_iter) = iter.downcast_ref_if_exact::<PyTupleIterator>(vm) {
+                    if let Some(value) = tuple_iter.fast_next() {
+                        self.push_value(value);
+                    } else {
+                        self.for_iter_jump_on_exhausted(target);
+                    }
+                    Ok(None)
+                } else {
+                    self.execute_for_iter(vm, target)?;
+                    Ok(None)
+                }
+            }
+            Instruction::ForIterGen => {
+                let target = bytecode::Label::from_u32(self.lasti() + 1 + u32::from(arg));
+                let iter = self.top_value();
+                if self.specialization_eval_frame_active(vm) {
+                    self.execute_for_iter(vm, target)?;
+                    return Ok(None);
+                }
+                if let Some(generator) = iter.downcast_ref_if_exact::<PyGenerator>(vm) {
+                    if generator.as_coro().running() || generator.as_coro().closed() {
+                        self.execute_for_iter(vm, target)?;
+                        return Ok(None);
+                    }
+                    match generator.as_coro().send_none(iter, vm) {
+                        Ok(PyIterReturn::Return(value)) => {
+                            self.push_value(value);
+                        }
+                        Ok(PyIterReturn::StopIteration(value)) => {
+                            if vm.use_tracing.get() && !vm.is_none(&self.object.trace.lock()) {
+                                let stop_exc = vm.new_stop_iteration(value);
+                                self.fire_exception_trace(&stop_exc, vm)?;
+                            }
+                            self.for_iter_jump_on_exhausted(target);
+                        }
+                        Err(e) => return Err(e),
+                    }
+                    Ok(None)
+                } else {
+                    self.execute_for_iter(vm, target)?;
+                    Ok(None)
+                }
+            }
+            Instruction::LoadGlobalModule => {
+                let oparg = u32::from(arg);
+                let cache_base = self.lasti() as usize;
+                // Keep specialized opcode on guard miss (JUMP_TO_PREDICTED behavior).
+                let cached_version = self.code.instructions.read_cache_u16(cache_base + 1);
+                let cached_index = self.code.instructions.read_cache_u16(cache_base + 3);
+                if let Ok(current_version) = u16::try_from(self.globals.version())
+                    && cached_version == current_version
+                {
+                    let name = self.code.names[(oparg >> 1) as usize];
+                    if let Some(x) = self.globals.get_item_opt_hint(name, cached_index, vm)? {
+                        self.push_value(x);
+                        if (oparg & 1) != 0 {
+                            self.push_value_opt(None);
+                        }
+                        return Ok(None);
+                    }
+                }
+                let name = self.code.names[(oparg >> 1) as usize];
+                let x = self.load_global_or_builtin(name, vm)?;
+                self.push_value(x);
+                if (oparg & 1) != 0 {
+                    self.push_value_opt(None);
+                }
+                Ok(None)
+            }
+            Instruction::LoadGlobalBuiltin => {
+                let oparg = u32::from(arg);
+                let cache_base = self.lasti() as usize;
+                let cached_globals_ver = self.code.instructions.read_cache_u16(cache_base + 1);
+                let cached_builtins_ver = self.code.instructions.read_cache_u16(cache_base + 2);
+                let cached_index = self.code.instructions.read_cache_u16(cache_base + 3);
+                if let Ok(current_globals_ver) = u16::try_from(self.globals.version())
+                    && cached_globals_ver == current_globals_ver
+                    && let Some(builtins_dict) = self.builtins.downcast_ref_if_exact::<PyDict>(vm)
+                    && let Ok(current_builtins_ver) = u16::try_from(builtins_dict.version())
+                    && cached_builtins_ver == current_builtins_ver
+                {
+                    let name = self.code.names[(oparg >> 1) as usize];
+                    if let Some(x) = builtins_dict.get_item_opt_hint(name, cached_index, vm)? {
+                        self.push_value(x);
+                        if (oparg & 1) != 0 {
+                            self.push_value_opt(None);
+                        }
+                        return Ok(None);
+                    }
+                }
+                let name = self.code.names[(oparg >> 1) as usize];
+                let x = self.load_global_or_builtin(name, vm)?;
+                self.push_value(x);
+                if (oparg & 1) != 0 {
+                    self.push_value_opt(None);
+                }
+                Ok(None)
+            }
+            // All INSTRUMENTED_* opcodes delegate to a cold function to keep
+            // the hot instruction loop free of monitoring overhead.
+            _ => self.execute_instrumented(instruction, arg, vm),
+        }
+    }
+
+    /// Handle all INSTRUMENTED_* opcodes. This function is cold — it only
+    /// runs when sys.monitoring has rewritten the bytecode.
+    #[cold]
+    fn execute_instrumented(
+        &mut self,
+        instruction: Instruction,
+        arg: bytecode::OpArg,
+        vm: &VirtualMachine,
+    ) -> FrameResult {
+        debug_assert!(
+            instruction.is_instrumented(),
+            "execute_instrumented called with non-instrumented opcode {instruction:?}"
+        );
+        if self.monitoring_disabled_for_code(vm) {
+            let global_ver = vm
+                .state
+                .instrumentation_version
+                .load(atomic::Ordering::Acquire);
+            monitoring::instrument_code(self.code, 0);
+            self.code
+                .instrumentation_version
+                .store(global_ver, atomic::Ordering::Release);
+            self.update_lasti(|i| *i -= 1);
+            return Ok(None);
+        }
+        self.monitoring_mask = vm.state.monitoring_events.load();
+        match instruction {
+            Instruction::InstrumentedResume => {
+                // Version check: re-instrument if stale
+                let global_ver = vm
+                    .state
+                    .instrumentation_version
+                    .load(atomic::Ordering::Acquire);
+                let code_ver = self
+                    .code
+                    .instrumentation_version
+                    .load(atomic::Ordering::Acquire);
+                if code_ver != global_ver {
+                    let events = {
+                        let state = vm.state.monitoring.lock();
+                        state.events_for_code(self.code.get_id())
+                    };
+                    monitoring::instrument_code(self.code, events);
+                    self.code
+                        .instrumentation_version
+                        .store(global_ver, atomic::Ordering::Release);
+                    // Re-execute (may have been de-instrumented to base Resume)
+                    self.update_lasti(|i| *i -= 1);
+                    return Ok(None);
+                }
+                let resume_type = u32::from(arg);
+                let offset = (self.lasti() - 1) * 2;
+                if resume_type == 0 {
+                    if self.monitoring_mask & monitoring::EVENT_PY_START != 0 {
+                        monitoring::fire_py_start(vm, self.code, offset)?;
+                    }
+                } else if self.monitoring_mask & monitoring::EVENT_PY_RESUME != 0 {
+                    monitoring::fire_py_resume(vm, self.code, offset)?;
+                }
+                Ok(None)
+            }
+            Instruction::InstrumentedReturnValue => {
+                let value = self.pop_value();
+                if self.monitoring_mask & monitoring::EVENT_PY_RETURN != 0 {
+                    let offset = (self.lasti() - 1) * 2;
+                    monitoring::fire_py_return(vm, self.code, offset, &value)?;
+                }
+                self.unwind_blocks(vm, UnwindReason::Returning { value })
+            }
+            Instruction::InstrumentedYieldValue => {
+                debug_assert!(
+                    self.localsplus
+                        .stack_as_slice()
+                        .iter()
+                        .flatten()
+                        .all(|sr| !sr.is_borrowed()),
+                    "borrowed refs on stack at yield point"
+                );
+                let value = self.pop_value();
+                if self.monitoring_mask & monitoring::EVENT_PY_YIELD != 0 {
+                    let offset = (self.lasti() - 1) * 2;
+                    monitoring::fire_py_yield(vm, self.code, offset, &value)?;
+                }
+                Ok(Some(ExecutionResult::Yield(value)))
+            }
+            Instruction::InstrumentedCall => {
+                let args = self.collect_positional_args(u32::from(arg));
+                self.execute_call_instrumented(args, vm)
+            }
+            Instruction::InstrumentedCallKw => {
+                let args = self.collect_keyword_args(u32::from(arg));
+                self.execute_call_instrumented(args, vm)
+            }
+            Instruction::InstrumentedCallFunctionEx => {
+                let args = self.collect_ex_args(vm)?;
+                self.execute_call_instrumented(args, vm)
+            }
+            Instruction::InstrumentedLoadSuperAttr => {
+                let oparg = bytecode::LoadSuperAttr::from(u32::from(arg));
+                let offset = (self.lasti() - 1) * 2;
+                // Fire CALL event before super() call
+                let call_args = if self.monitoring_mask & monitoring::EVENT_CALL != 0 {
+                    let global_super: PyObjectRef = self.nth_value(2).to_owned();
+                    let arg0 = if oparg.has_class() {
+                        self.nth_value(1).to_owned()
+                    } else {
+                        monitoring::get_missing(vm)
+                    };
+                    monitoring::fire_call(vm, self.code, offset, &global_super, arg0.clone())?;
+                    Some((global_super, arg0))
+                } else {
+                    None
+                };
+                match self.load_super_attr(vm, oparg) {
+                    Ok(result) => {
+                        // Fire C_RETURN on success
+                        if let Some((global_super, arg0)) = call_args {
+                            monitoring::fire_c_return(vm, self.code, offset, &global_super, arg0)?;
+                        }
+                        Ok(result)
+                    }
+                    Err(exc) => {
+                        // Fire C_RAISE on failure
+                        let exc = if let Some((global_super, arg0)) = call_args {
+                            match monitoring::fire_c_raise(
+                                vm,
+                                self.code,
+                                offset,
+                                &global_super,
+                                arg0,
+                            ) {
+                                Ok(()) => exc,
+                                Err(monitor_exc) => monitor_exc,
+                            }
+                        } else {
+                            exc
+                        };
+                        Err(exc)
+                    }
+                }
+            }
+            Instruction::InstrumentedJumpForward => {
+                let src_offset = (self.lasti() - 1) * 2;
+                let target_idx = self.lasti() + u32::from(arg);
+                let target = bytecode::Label::from_u32(target_idx);
+                self.jump(target);
+                if self.monitoring_mask & monitoring::EVENT_JUMP != 0 {
+                    monitoring::fire_jump(vm, self.code, src_offset, target.as_u32() * 2)?;
+                }
+                Ok(None)
+            }
+            Instruction::InstrumentedJumpBackward => {
+                let src_offset = (self.lasti() - 1) * 2;
+                let target_idx = self.lasti() + 1 - u32::from(arg);
+                let target = bytecode::Label::from_u32(target_idx);
+                self.jump(target);
+                if self.monitoring_mask & monitoring::EVENT_JUMP != 0 {
+                    monitoring::fire_jump(vm, self.code, src_offset, target.as_u32() * 2)?;
+                }
+                Ok(None)
+            }
+            Instruction::InstrumentedForIter => {
+                let src_offset = (self.lasti() - 1) * 2;
+                let target = bytecode::Label::from_u32(self.lasti() + 1 + u32::from(arg));
+                let continued = self.execute_for_iter(vm, target)?;
+                if continued {
+                    if self.monitoring_mask & monitoring::EVENT_BRANCH_LEFT != 0 {
+                        let dest_offset = (self.lasti() + 1) * 2; // after caches
+                        monitoring::fire_branch_left(vm, self.code, src_offset, dest_offset)?;
+                    }
+                } else if self.monitoring_mask & monitoring::EVENT_BRANCH_RIGHT != 0 {
+                    let dest_offset = self.lasti() * 2;
+                    monitoring::fire_branch_right(vm, self.code, src_offset, dest_offset)?;
+                }
+                Ok(None)
+            }
+            Instruction::InstrumentedEndFor => {
+                // Stack: [value, receiver(iter), ...]
+                // PyGen_Check: only fire STOP_ITERATION for generators
+                let is_gen = self
+                    .nth_value(1)
+                    .downcast_ref::<crate::builtins::PyGenerator>()
+                    .is_some();
+                let value = self.pop_value();
+                if is_gen && self.monitoring_mask & monitoring::EVENT_STOP_ITERATION != 0 {
+                    let offset = (self.lasti() - 1) * 2;
+                    monitoring::fire_stop_iteration(vm, self.code, offset, &value)?;
+                }
+                Ok(None)
+            }
+            Instruction::InstrumentedEndSend => {
+                let value = self.pop_value();
+                let receiver = self.pop_value();
+                // PyGen_Check || PyCoro_CheckExact
+                let is_gen_or_coro = receiver
+                    .downcast_ref::<crate::builtins::PyGenerator>()
+                    .is_some()
+                    || receiver
+                        .downcast_ref::<crate::builtins::PyCoroutine>()
+                        .is_some();
+                if is_gen_or_coro && self.monitoring_mask & monitoring::EVENT_STOP_ITERATION != 0 {
+                    let offset = (self.lasti() - 1) * 2;
+                    monitoring::fire_stop_iteration(vm, self.code, offset, &value)?;
+                }
+                self.push_value(value);
+                Ok(None)
+            }
+            Instruction::InstrumentedPopJumpIfTrue => {
+                let src_offset = (self.lasti() - 1) * 2;
+                let target_idx = self.lasti() + 1 + u32::from(arg);
+                let obj = self.pop_value();
+                let value = obj.try_to_bool(vm)?;
+                if value {
+                    self.jump(bytecode::Label::from_u32(target_idx));
+                    if self.monitoring_mask & monitoring::EVENT_BRANCH_RIGHT != 0 {
+                        monitoring::fire_branch_right(vm, self.code, src_offset, target_idx * 2)?;
+                    }
+                }
+                Ok(None)
+            }
+            Instruction::InstrumentedPopJumpIfFalse => {
+                let src_offset = (self.lasti() - 1) * 2;
+                let target_idx = self.lasti() + 1 + u32::from(arg);
+                let obj = self.pop_value();
+                let value = obj.try_to_bool(vm)?;
+                if !value {
+                    self.jump(bytecode::Label::from_u32(target_idx));
+                    if self.monitoring_mask & monitoring::EVENT_BRANCH_RIGHT != 0 {
+                        monitoring::fire_branch_right(vm, self.code, src_offset, target_idx * 2)?;
+                    }
+                }
+                Ok(None)
+            }
+            Instruction::InstrumentedPopJumpIfNone => {
+                let src_offset = (self.lasti() - 1) * 2;
+                let target_idx = self.lasti() + 1 + u32::from(arg);
+                let value = self.pop_value();
+                if vm.is_none(&value) {
+                    self.jump(bytecode::Label::from_u32(target_idx));
+                    if self.monitoring_mask & monitoring::EVENT_BRANCH_RIGHT != 0 {
+                        monitoring::fire_branch_right(vm, self.code, src_offset, target_idx * 2)?;
+                    }
+                }
+                Ok(None)
+            }
+            Instruction::InstrumentedPopJumpIfNotNone => {
+                let src_offset = (self.lasti() - 1) * 2;
+                let target_idx = self.lasti() + 1 + u32::from(arg);
+                let value = self.pop_value();
+                if !vm.is_none(&value) {
+                    self.jump(bytecode::Label::from_u32(target_idx));
+                    if self.monitoring_mask & monitoring::EVENT_BRANCH_RIGHT != 0 {
+                        monitoring::fire_branch_right(vm, self.code, src_offset, target_idx * 2)?;
+                    }
+                }
+                Ok(None)
+            }
+            Instruction::InstrumentedNotTaken => {
+                if self.monitoring_mask & monitoring::EVENT_BRANCH_LEFT != 0 {
+                    let not_taken_idx = self.lasti() as usize - 1;
+                    // Scan backwards past CACHE entries to find the branch instruction
+                    let mut branch_idx = not_taken_idx.saturating_sub(1);
+                    while branch_idx > 0
+                        && matches!(
+                            self.code.instructions.read_op(branch_idx),
+                            Instruction::Cache
+                        )
+                    {
+                        branch_idx -= 1;
+                    }
+                    let src_offset = (branch_idx as u32) * 2;
+                    let dest_offset = self.lasti() * 2;
+                    monitoring::fire_branch_left(vm, self.code, src_offset, dest_offset)?;
+                }
+                Ok(None)
+            }
+            Instruction::InstrumentedPopIter => {
+                // BRANCH_RIGHT is fired by InstrumentedForIter, not here.
+                self.pop_value();
+                Ok(None)
+            }
+            Instruction::InstrumentedEndAsyncFor => {
+                if self.monitoring_mask & monitoring::EVENT_BRANCH_RIGHT != 0 {
+                    let oparg_val = u32::from(arg);
+                    // src = next_instr - oparg (END_SEND position)
+                    let src_offset = (self.lasti() - oparg_val) * 2;
+                    // dest = this_instr + 1
+                    let dest_offset = self.lasti() * 2;
+                    monitoring::fire_branch_right(vm, self.code, src_offset, dest_offset)?;
+                }
+                let exc = self.pop_value();
+                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.set_exception(None);
+                    Ok(None)
+                } else {
+                    Err(exc)
+                }
+            }
+            Instruction::InstrumentedLine => {
+                let idx = self.lasti() as usize - 1;
+                let offset = idx as u32 * 2;
+
+                // Read the full side-table chain before firing any events,
+                // because a callback may de-instrument and clear the tables.
+                let (real_op_byte, also_instruction) = {
+                    let data = self.code.monitoring_data.lock();
+                    let line_op = data.as_ref().map(|d| d.line_opcodes[idx]).unwrap_or(0);
+                    if line_op == u8::from(Instruction::InstrumentedInstruction) {
+                        // LINE wraps INSTRUCTION: resolve the INSTRUCTION side-table too
+                        let inst_op = data
+                            .as_ref()
+                            .map(|d| d.per_instruction_opcodes[idx])
+                            .unwrap_or(0);
+                        (inst_op, true)
+                    } else {
+                        (line_op, false)
+                    }
+                };
+                debug_assert!(
+                    real_op_byte != 0,
+                    "INSTRUMENTED_LINE at {idx} without stored opcode"
+                );
+
+                // Fire LINE event only if line changed
+                if let Some((loc, _)) = self.code.locations.get(idx) {
+                    let line = loc.line.get() as u32;
+                    if line != *self.prev_line && line > 0 {
+                        *self.prev_line = line;
+                        monitoring::fire_line(vm, self.code, offset, line)?;
+                    }
+                }
+
+                // If the LINE position also had INSTRUCTION, fire that event too
+                if also_instruction {
+                    monitoring::fire_instruction(vm, self.code, offset)?;
+                }
+
+                // Re-dispatch to the real original opcode
+                let original_op = Instruction::try_from(real_op_byte)
+                    .expect("invalid opcode in side-table chain");
+                let lasti_before_dispatch = self.lasti();
+                let result = if original_op.to_base().is_some() {
+                    self.execute_instrumented(original_op, arg, vm)
+                } else {
+                    let mut do_extend_arg = false;
+                    self.execute_instruction(original_op, arg, &mut do_extend_arg, vm)
+                };
+                let orig_caches = original_op.to_base().unwrap_or(original_op).cache_entries();
+                if orig_caches > 0 && self.lasti() == lasti_before_dispatch {
+                    self.update_lasti(|i| *i += orig_caches as u32);
+                }
+                result
+            }
+            Instruction::InstrumentedInstruction => {
+                let idx = self.lasti() as usize - 1;
+                let offset = idx as u32 * 2;
+
+                // Get original opcode from side-table
+                let original_op_byte = {
+                    let data = self.code.monitoring_data.lock();
+                    data.as_ref()
+                        .map(|d| d.per_instruction_opcodes[idx])
+                        .unwrap_or(0)
+                };
+                debug_assert!(
+                    original_op_byte != 0,
+                    "INSTRUMENTED_INSTRUCTION at {idx} without stored opcode"
+                );
+
+                // Fire INSTRUCTION event
+                monitoring::fire_instruction(vm, self.code, offset)?;
+
+                // Re-dispatch to original opcode
+                let original_op = Instruction::try_from(original_op_byte)
+                    .expect("invalid opcode in instruction side-table");
+                let lasti_before_dispatch = self.lasti();
+                let result = if original_op.to_base().is_some() {
+                    self.execute_instrumented(original_op, arg, vm)
+                } else {
+                    let mut do_extend_arg = false;
+                    self.execute_instruction(original_op, arg, &mut do_extend_arg, vm)
+                };
+                let orig_caches = original_op.to_base().unwrap_or(original_op).cache_entries();
+                if orig_caches > 0 && self.lasti() == lasti_before_dispatch {
+                    self.update_lasti(|i| *i += orig_caches as u32);
+                }
+                result
+            }
+            _ => {
+                unreachable!("{instruction:?} instruction should not be executed")
+            }
+        }
+    }
+
+    #[inline]
+    fn load_global_or_builtin(&self, name: &Py<PyStr>, vm: &VirtualMachine) -> PyResult {
+        if let Some(builtins_dict) = self.builtins_dict {
+            // Fast path: both globals and builtins are exact dicts
+            // SAFETY: builtins_dict is only set when globals is also exact dict
+            let globals_exact = unsafe { PyExact::ref_unchecked(self.globals.as_ref()) };
+            globals_exact
+                .get_chain_exact(builtins_dict, name, vm)?
+                .ok_or_else(|| {
+                    vm.new_name_error(format!("name '{name}' is not defined"), name.to_owned())
+                })
+        } else {
+            // Slow path: builtins is not a dict, use generic __getitem__
+            if let Some(value) = self.globals.get_item_opt(name, vm)? {
+                return Ok(value);
+            }
+            self.builtins.get_item(name, vm).map_err(|e| {
+                if e.fast_isinstance(vm.ctx.exceptions.key_error) {
+                    vm.new_name_error(format!("name '{name}' is not defined"), name.to_owned())
+                } else {
+                    e
+                }
+            })
+        }
+    }
+
+    #[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);
+        let top = self.pop_value();
+        let from_list = match <Option<PyTupleRef>>::try_from_object(vm, top)? {
+            Some(from_list) => from_list.try_into_typed::<PyStr>(vm)?,
+            None => vm.ctx.empty_tuple_typed().to_owned(),
+        };
+        let level = usize::try_from_object(vm, self.pop_value())?;
+
+        let module = vm.import_from(module_name, &from_list, level)?;
+
+        self.push_value(module);
+        Ok(())
+    }
+
+    #[cfg_attr(feature = "flame-it", flame("Frame"))]
+    fn import_from(&mut self, vm: &VirtualMachine, idx: bytecode::NameIdx) -> PyResult {
+        let module = self.top_value();
+        let name = self.code.names[idx as usize];
+
+        // Load attribute, and transform any error into import error.
+        if let Some(obj) = vm.get_attribute_opt(module.to_owned(), name)? {
+            return Ok(obj);
+        }
+        // fallback to importing '{module.__name__}.{name}' from sys.modules
+        let fallback_module = (|| {
+            let mod_name = module.get_attr(identifier!(vm, __name__), vm).ok()?;
+            let mod_name = mod_name.downcast_ref::<PyStr>()?;
+            let full_mod_name = format!("{mod_name}.{name}");
+            let sys_modules = vm.sys_module.get_attr("modules", vm).ok()?;
+            sys_modules.get_item(&full_mod_name, vm).ok()
+        })();
+
+        if let Some(sub_module) = fallback_module {
+            return Ok(sub_module);
+        }
+
+        use crate::import::{
+            get_spec_file_origin, is_possibly_shadowing_path, is_stdlib_module_name,
+        };
+
+        // Get module name for the error message
+        let mod_name_obj = module.get_attr(identifier!(vm, __name__), vm).ok();
+        let mod_name_str = mod_name_obj
+            .as_ref()
+            .and_then(|n| n.downcast_ref::<PyUtf8Str>().map(|s| s.as_str().to_owned()));
+        let module_name = mod_name_str.as_deref().unwrap_or("<unknown module name>");
+
+        let spec = module
+            .get_attr("__spec__", vm)
+            .ok()
+            .filter(|s| !vm.is_none(s));
+
+        let origin = get_spec_file_origin(&spec, vm);
+
+        let is_possibly_shadowing = origin
+            .as_ref()
+            .map(|o| is_possibly_shadowing_path(o, vm))
+            .unwrap_or(false);
+        let is_possibly_shadowing_stdlib = if is_possibly_shadowing {
+            if let Some(ref mod_name) = mod_name_obj {
+                is_stdlib_module_name(mod_name, vm)?
+            } else {
+                false
+            }
+        } else {
+            false
+        };
+
+        let msg = if is_possibly_shadowing_stdlib {
+            let origin = origin.as_ref().unwrap();
+            format!(
+                "cannot import name '{name}' from '{module_name}' \
+                 (consider renaming '{origin}' since it has the same \
+                 name as the standard library module named '{module_name}' \
+                 and prevents importing that standard library module)"
+            )
+        } else {
+            let is_init = is_module_initializing(module, vm);
+            if is_init {
+                if is_possibly_shadowing {
+                    let origin = origin.as_ref().unwrap();
+                    format!(
+                        "cannot import name '{name}' from '{module_name}' \
+                         (consider renaming '{origin}' if it has the same name \
+                         as a library you intended to import)"
+                    )
+                } else if let Some(ref path) = origin {
+                    format!(
+                        "cannot import name '{name}' from partially initialized module \
+                         '{module_name}' (most likely due to a circular import) ({path})"
+                    )
+                } else {
+                    format!(
+                        "cannot import name '{name}' from partially initialized module \
+                         '{module_name}' (most likely due to a circular import)"
+                    )
+                }
+            } else if let Some(ref path) = origin {
+                format!("cannot import name '{name}' from '{module_name}' ({path})")
+            } else {
+                format!("cannot import name '{name}' from '{module_name}' (unknown location)")
+            }
+        };
+        let err = vm.new_import_error(msg, vm.ctx.new_utf8_str(module_name));
+
+        if let Some(ref path) = origin {
+            let _ignore = err
+                .as_object()
+                .set_attr("path", vm.ctx.new_str(path.as_str()), vm);
+        }
+
+        // name_from = the attribute name that failed to import (best-effort metadata)
+        let _ignore = err.as_object().set_attr("name_from", name.to_owned(), vm);
+
+        Err(err)
+    }
+
+    #[cfg_attr(feature = "flame-it", flame("Frame"))]
+    fn import_star(&mut self, vm: &VirtualMachine) -> PyResult<()> {
+        let module = self.pop_value();
+
+        let Some(dict) = module.dict() else {
+            return Ok(());
+        };
+
+        let mod_name = module
+            .get_attr(identifier!(vm, __name__), vm)
+            .ok()
+            .and_then(|n| n.downcast::<PyStr>().ok());
+
+        let require_str = |obj: PyObjectRef, attr: &str| -> PyResult<PyRef<PyStr>> {
+            obj.downcast().map_err(|obj: PyObjectRef| {
+                let source = if let Some(ref mod_name) = mod_name {
+                    format!("{}.{attr}", mod_name.as_wtf8())
+                } else {
+                    attr.to_owned()
+                };
+                let repr = obj.repr(vm).unwrap_or_else(|_| vm.ctx.new_str("?"));
+                vm.new_type_error(format!(
+                    "{} in {} must be str, not {}",
+                    repr.as_wtf8(),
+                    source,
+                    obj.class().name()
+                ))
+            })
+        };
+
+        let locals_map = self.locals.mapping(vm);
+        if let Ok(all) = dict.get_item(identifier!(vm, __all__), vm) {
+            let items: Vec<PyObjectRef> = all.try_to_value(vm)?;
+            for item in items {
+                let name = require_str(item, "__all__")?;
+                let value = module.get_attr(&*name, vm)?;
+                locals_map.ass_subscript(&name, Some(value), vm)?;
+            }
+        } else {
+            for (k, v) in dict {
+                let k = require_str(k, "__dict__")?;
+                if !k.as_bytes().starts_with(b"_") {
+                    locals_map.ass_subscript(&k, Some(v), vm)?;
+                }
+            }
+        }
+        Ok(())
+    }
+
+    /// Unwind blocks.
+    /// The reason for unwinding gives a hint on what to do when
+    /// unwinding a block.
+    /// Optionally returns an exception.
+    #[cfg_attr(feature = "flame-it", flame("Frame"))]
+    fn unwind_blocks(&mut self, vm: &VirtualMachine, reason: UnwindReason) -> FrameResult {
+        // 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.
+                if self.lasti() == 0 {
+                    // No instruction executed yet, no handler can match
+                    return Err(exception);
+                }
+                let offset = self.lasti() - 1;
+                if let Some(entry) =
+                    bytecode::find_exception_handler(&self.code.exceptiontable, offset)
+                {
+                    // Fire EXCEPTION_HANDLED before setting up handler.
+                    // If the callback raises, the handler is NOT set up and the
+                    // new exception propagates instead.
+                    if vm.state.monitoring_events.load() & monitoring::EVENT_EXCEPTION_HANDLED != 0
+                    {
+                        let byte_offset = offset * 2;
+                        let exc_obj: PyObjectRef = exception.clone().into();
+                        monitoring::fire_exception_handled(vm, self.code, byte_offset, &exc_obj)?;
+                    }
+
+                    // 1. Pop stack to entry.depth
+                    while self.localsplus.stack_len() > entry.depth as usize {
+                        let _ = self.localsplus.stack_pop();
+                    }
+
+                    // 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]
+                    // 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::from_u32(entry.target));
+
+                    Ok(None)
+                } else {
+                    // No handler found, propagate exception
+                    Err(exception)
+                }
+            }
+            UnwindReason::Returning { value } => Ok(Some(ExecutionResult::Return(value))),
+        }
+    }
+
+    fn execute_store_subscript(&mut self, vm: &VirtualMachine) -> FrameResult {
+        let idx = self.pop_value();
+        let obj = self.pop_value();
+        let value = self.pop_value();
+        obj.set_item(&*idx, value, vm)?;
+        Ok(None)
+    }
+
+    fn execute_delete_subscript(&mut self, vm: &VirtualMachine) -> FrameResult {
+        let idx = self.pop_value();
+        let obj = self.pop_value();
+        obj.del_item(&*idx, vm)?;
+        Ok(None)
+    }
+
+    fn execute_build_map(&mut self, vm: &VirtualMachine, size: u32) -> FrameResult {
+        let size = size as usize;
+        let map_obj = vm.ctx.new_dict();
+        for (key, value) in self.pop_multiple(2 * size).tuples() {
+            map_obj.set_item(&*key, value, vm)?;
+        }
+
+        self.push_value(map_obj.into());
+        Ok(None)
+    }
+
+    fn execute_build_slice(
+        &mut self,
+        vm: &VirtualMachine,
+        argc: bytecode::BuildSliceArgCount,
+    ) -> FrameResult {
+        let step = match argc {
+            bytecode::BuildSliceArgCount::Two => None,
+            bytecode::BuildSliceArgCount::Three => Some(self.pop_value()),
+        };
+        let stop = self.pop_value();
+        let start = self.pop_value();
+
+        let obj = PySlice {
+            start: Some(start),
+            stop,
+            step,
+        }
+        .into_ref(&vm.ctx);
+        self.push_value(obj.into());
+        Ok(None)
+    }
+
+    fn collect_positional_args(&mut self, nargs: u32) -> FuncArgs {
+        FuncArgs {
+            args: self.pop_multiple(nargs as usize).collect(),
+            kwargs: IndexMap::new(),
+        }
+    }
+
+    fn collect_keyword_args(&mut self, nargs: u32) -> FuncArgs {
+        let kwarg_names = self
+            .pop_value()
+            .downcast::<PyTuple>()
+            .expect("kwarg names should be tuple of strings");
+        let args = self.pop_multiple(nargs as usize);
+
+        let kwarg_names = kwarg_names.as_slice().iter().map(|pyobj| {
+            pyobj
+                .downcast_ref::<PyUtf8Str>()
+                .unwrap()
+                .as_str()
+                .to_owned()
+        });
+        FuncArgs::with_kwargs_names(args, kwarg_names)
+    }
+
+    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();
+
+            // Stack: [callable, self_or_null, args_tuple]
+            let callable = self.nth_value(2);
+            let func_str = Self::object_function_str(callable, vm);
+
+            Self::iterate_mapping_keys(vm, &kw_obj, &func_str, |key| {
+                let key_str = key
+                    .downcast_ref::<PyUtf8Str>()
+                    .ok_or_else(|| vm.new_type_error("keywords must be strings"))?;
+                let value = kw_obj.get_item(&*key, vm)?;
+                kwargs.insert(key_str.as_str().to_owned(), value);
+                Ok(())
+            })?;
+            kwargs
+        } else {
+            IndexMap::new()
+        };
+        let args_obj = self.pop_value();
+        let args = if let Some(tuple) = args_obj.downcast_ref::<PyTuple>() {
+            tuple.as_slice().to_vec()
+        } else {
+            // Single *arg passed directly; convert to sequence at runtime.
+            // Stack: [callable, self_or_null]
+            let callable = self.nth_value(1);
+            let func_str = Self::object_function_str(callable, vm);
+            let not_iterable = args_obj.class().slots.iter.load().is_none()
+                && args_obj
+                    .get_class_attr(vm.ctx.intern_str("__getitem__"))
+                    .is_none();
+            args_obj.try_to_value::<Vec<PyObjectRef>>(vm).map_err(|e| {
+                if not_iterable && e.class().is(vm.ctx.exceptions.type_error) {
+                    vm.new_type_error(format!(
+                        "{} argument after * must be an iterable, not {}",
+                        func_str,
+                        args_obj.class().name()
+                    ))
+                } else {
+                    e
+                }
+            })?
+        };
+        Ok(FuncArgs { args, kwargs })
+    }
+
+    /// Returns a display string for a callable object for use in error messages.
+    /// For objects with `__qualname__`, returns "module.qualname()" or "qualname()".
+    /// For other objects, returns repr(obj).
+    fn object_function_str(obj: &PyObject, vm: &VirtualMachine) -> Wtf8Buf {
+        let repr_fallback = || {
+            obj.repr(vm)
+                .as_ref()
+                .map_or("?".as_ref(), |s| s.as_wtf8())
+                .to_owned()
+        };
+        let Ok(qualname) = obj.get_attr(vm.ctx.intern_str("__qualname__"), vm) else {
+            return repr_fallback();
+        };
+        let Some(qualname_str) = qualname.downcast_ref::<PyStr>() else {
+            return repr_fallback();
+        };
+        if let Ok(module) = obj.get_attr(vm.ctx.intern_str("__module__"), vm)
+            && let Some(module_str) = module.downcast_ref::<PyStr>()
+            && module_str.as_bytes() != b"builtins"
+        {
+            return wtf8_concat!(module_str.as_wtf8(), ".", qualname_str.as_wtf8(), "()");
+        }
+        wtf8_concat!(qualname_str.as_wtf8(), "()")
+    }
+
+    /// Helper function to iterate over mapping keys using the keys() method.
+    /// This ensures proper order preservation for OrderedDict and other custom mappings.
+    fn iterate_mapping_keys<F>(
+        vm: &VirtualMachine,
+        mapping: &PyObject,
+        func_str: &Wtf8,
+        mut key_handler: F,
+    ) -> PyResult<()>
+    where
+        F: FnMut(PyObjectRef) -> PyResult<()>,
+    {
+        let Some(keys_method) = vm.get_method(mapping.to_owned(), vm.ctx.intern_str("keys")) else {
+            return Err(vm.new_type_error(format!(
+                "{} argument after ** must be a mapping, not {}",
+                func_str,
+                mapping.class().name()
+            )));
+        };
+
+        let keys = keys_method?.call((), vm)?.get_iter(vm)?;
+        while let PyIterReturn::Return(key) = keys.next(vm)? {
+            key_handler(key)?;
+        }
+        Ok(())
+    }
+
+    /// Vectorcall dispatch for Instruction::Call (positional args only).
+    /// Uses vectorcall slot if available, otherwise falls back to FuncArgs.
+    #[inline]
+    fn execute_call_vectorcall(&mut self, nargs: u32, vm: &VirtualMachine) -> FrameResult {
+        let nargs_usize = nargs as usize;
+        let stack_len = self.localsplus.stack_len();
+        debug_assert!(
+            stack_len >= nargs_usize + 2,
+            "CALL stack underflow: need callable + self_or_null + {nargs_usize} args, have {stack_len}"
+        );
+        let callable_idx = stack_len - nargs_usize - 2;
+        let self_or_null_idx = stack_len - nargs_usize - 1;
+        let args_start = stack_len - nargs_usize;
+
+        // Build args: [self?, arg1, ..., argN]
+        let self_or_null = self
+            .localsplus
+            .stack_index_mut(self_or_null_idx)
+            .take()
+            .map(|sr| sr.to_pyobj());
+        let has_self = self_or_null.is_some();
+
+        let effective_nargs = if has_self {
+            nargs_usize + 1
+        } else {
+            nargs_usize
+        };
+        let mut args_vec = Vec::with_capacity(effective_nargs);
+        if let Some(self_val) = self_or_null {
+            args_vec.push(self_val);
+        }
+        for stack_idx in args_start..stack_len {
+            let val = self
+                .localsplus
+                .stack_index_mut(stack_idx)
+                .take()
+                .unwrap()
+                .to_pyobj();
+            args_vec.push(val);
+        }
+
+        let callable_obj = self
+            .localsplus
+            .stack_index_mut(callable_idx)
+            .take()
+            .unwrap()
+            .to_pyobj();
+        self.localsplus.stack_truncate(callable_idx);
+
+        // invoke_vectorcall falls back to FuncArgs if no vectorcall slot
+        let result = callable_obj.vectorcall(args_vec, effective_nargs, None, vm)?;
+        self.push_value(result);
+        Ok(None)
+    }
+
+    /// Vectorcall dispatch for Instruction::CallKw (positional + keyword args).
+    #[inline]
+    fn execute_call_kw_vectorcall(&mut self, nargs: u32, vm: &VirtualMachine) -> FrameResult {
+        let nargs_usize = nargs as usize;
+
+        // Pop kwarg_names tuple from top of stack
+        let kwarg_names_obj = self.pop_value();
+        let kwarg_names_tuple = kwarg_names_obj
+            .downcast_ref::<PyTuple>()
+            .expect("kwarg names should be tuple");
+        let kw_count = kwarg_names_tuple.len();
+        debug_assert!(kw_count <= nargs_usize, "CALL_KW kw_count exceeds nargs");
+
+        let stack_len = self.localsplus.stack_len();
+        debug_assert!(
+            stack_len >= nargs_usize + 2,
+            "CALL_KW stack underflow: need callable + self_or_null + {nargs_usize} args, have {stack_len}"
+        );
+        let callable_idx = stack_len - nargs_usize - 2;
+        let self_or_null_idx = stack_len - nargs_usize - 1;
+        let args_start = stack_len - nargs_usize;
+
+        // Build args: [self?, pos_arg1, ..., pos_argM, kw_val1, ..., kw_valK]
+        let self_or_null = self
+            .localsplus
+            .stack_index_mut(self_or_null_idx)
+            .take()
+            .map(|sr| sr.to_pyobj());
+        let has_self = self_or_null.is_some();
+
+        let pos_count = nargs_usize
+            .checked_sub(kw_count)
+            .expect("CALL_KW: kw_count exceeds nargs");
+        let effective_nargs = if has_self { pos_count + 1 } else { pos_count };
+
+        // Build the full args slice: positional (including self) + kwarg values
+        let total_args = effective_nargs + kw_count;
+        let mut args_vec = Vec::with_capacity(total_args);
+        if let Some(self_val) = self_or_null {
+            args_vec.push(self_val);
+        }
+        for stack_idx in args_start..stack_len {
+            let val = self
+                .localsplus
+                .stack_index_mut(stack_idx)
+                .take()
+                .unwrap()
+                .to_pyobj();
+            args_vec.push(val);
+        }
+
+        let callable_obj = self
+            .localsplus
+            .stack_index_mut(callable_idx)
+            .take()
+            .unwrap()
+            .to_pyobj();
+        self.localsplus.stack_truncate(callable_idx);
+
+        // invoke_vectorcall falls back to FuncArgs if no vectorcall slot
+        let kwnames = kwarg_names_tuple.as_slice();
+        let result = callable_obj.vectorcall(args_vec, effective_nargs, Some(kwnames), vm)?;
+        self.push_value(result);
+        Ok(None)
+    }
+
+    #[inline]
+    fn execute_call(&mut self, args: FuncArgs, vm: &VirtualMachine) -> FrameResult {
+        // Stack: [callable, self_or_null, ...]
+        let self_or_null = self.pop_value_opt(); // Option<PyObjectRef>
+        let callable = self.pop_value();
+
+        let final_args = if let Some(self_val) = self_or_null {
+            let mut args = args;
+            args.prepend_arg(self_val);
+            args
+        } else {
+            args
+        };
+
+        let value = callable.call(final_args, vm)?;
+        self.push_value(value);
+        Ok(None)
+    }
+
+    /// Instrumented version of execute_call: fires CALL, C_RETURN, and C_RAISE events.
+    fn execute_call_instrumented(&mut self, args: FuncArgs, vm: &VirtualMachine) -> FrameResult {
+        let self_or_null = self.pop_value_opt();
+        let callable = self.pop_value();
+
+        let final_args = if let Some(self_val) = self_or_null {
+            let mut args = args;
+            args.prepend_arg(self_val);
+            args
+        } else {
+            args
+        };
+
+        let is_python_call = callable.downcast_ref_if_exact::<PyFunction>(vm).is_some();
+
+        // Fire CALL event
+        let call_arg0 = if self.monitoring_mask & monitoring::EVENT_CALL != 0 {
+            let arg0 = final_args
+                .args
+                .first()
+                .cloned()
+                .unwrap_or_else(|| monitoring::get_missing(vm));
+            let offset = (self.lasti() - 1) * 2;
+            monitoring::fire_call(vm, self.code, offset, &callable, arg0.clone())?;
+            Some(arg0)
+        } else {
+            None
+        };
+
+        match callable.call(final_args, vm) {
+            Ok(value) => {
+                if let Some(arg0) = call_arg0
+                    && !is_python_call
+                {
+                    let offset = (self.lasti() - 1) * 2;
+                    monitoring::fire_c_return(vm, self.code, offset, &callable, arg0)?;
+                }
+                self.push_value(value);
+                Ok(None)
+            }
+            Err(exc) => {
+                let exc = if let Some(arg0) = call_arg0
+                    && !is_python_call
+                {
+                    let offset = (self.lasti() - 1) * 2;
+                    match monitoring::fire_c_raise(vm, self.code, offset, &callable, arg0) {
+                        Ok(()) => exc,
+                        Err(monitor_exc) => monitor_exc,
+                    }
+                } else {
+                    exc
+                };
+                Err(exc)
+            }
+        }
+    }
+
+    fn execute_raise(&mut self, vm: &VirtualMachine, kind: bytecode::RaiseKind) -> FrameResult {
+        let cause = match kind {
+            bytecode::RaiseKind::RaiseCause => {
+                let val = self.pop_value();
+                Some(if vm.is_none(&val) {
+                    // if the cause arg is none, we clear the cause
+                    None
+                } else {
+                    // if the cause arg is an exception, we overwrite it
+                    let ctor = ExceptionCtor::try_from_object(vm, val).map_err(|_| {
+                        vm.new_type_error("exception causes must derive from BaseException")
+                    })?;
+                    Some(ctor.instantiate(vm)?)
+                })
+            }
+            // if there's no cause arg, we keep the cause as is
+            _ => None,
+        };
+        let exception = match kind {
+            bytecode::RaiseKind::RaiseCause | bytecode::RaiseKind::Raise => {
+                ExceptionCtor::try_from_object(vm, self.pop_value())?.instantiate(vm)?
+            }
+            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"))?
+            }
+            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:?}");
+        if let Some(cause) = cause {
+            exception.set___cause__(cause);
+        }
+        Err(exception)
+    }
+
+    fn builtin_coro<'a>(&self, coro: &'a PyObject) -> Option<&'a Coro> {
+        match_class!(match coro {
+            ref g @ PyGenerator => Some(g.as_coro()),
+            ref c @ PyCoroutine => Some(c.as_coro()),
+            _ => None,
+        })
+    }
+
+    fn _send(
+        &self,
+        jen: &PyObject,
+        val: PyObjectRef,
+        vm: &VirtualMachine,
+    ) -> PyResult<PyIterReturn> {
+        match self.builtin_coro(jen) {
+            Some(coro) => coro.send(jen, val, vm),
+            // TODO: turn return type to PyResult<PyIterReturn> then ExecutionResult will be simplified
+            None if vm.is_none(&val) => PyIter::new(jen).next(vm),
+            None => {
+                let meth = jen.get_attr("send", vm)?;
+                PyIterReturn::from_pyresult(meth.call((val,), vm), vm)
+            }
+        }
+    }
+
+    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();
+        let not_iterable = value.class().slots.iter.load().is_none()
+            && value
+                .get_class_attr(vm.ctx.intern_str("__getitem__"))
+                .is_none();
+        let elements: Vec<_> = value.try_to_value(vm).map_err(|e| {
+            if not_iterable && e.class().is(vm.ctx.exceptions.type_error) {
+                vm.new_type_error(format!(
+                    "cannot unpack non-iterable {} object",
+                    value.class().name()
+                ))
+            } else {
+                e
+            }
+        })?;
+        let min_expected = before + after;
+
+        let middle = elements.len().checked_sub(min_expected).ok_or_else(|| {
+            vm.new_value_error(format!(
+                "not enough values to unpack (expected at least {}, got {})",
+                min_expected,
+                elements.len()
+            ))
+        })?;
+
+        let mut elements = elements;
+        // Elements on stack from right-to-left:
+        self.localsplus.stack_extend(
+            elements
+                .drain(before + middle..)
+                .rev()
+                .map(|e| Some(PyStackRef::new_owned(e))),
+        );
+
+        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.localsplus.stack_extend(
+            elements
+                .into_iter()
+                .rev()
+                .map(|e| Some(PyStackRef::new_owned(e))),
+        );
+
+        Ok(None)
+    }
+
+    #[inline]
+    fn jump(&mut self, label: bytecode::Label) {
+        let target_pc = label.as_u32();
+        vm_trace!("jump from {:?} to {:?}", self.lasti(), target_pc);
+        self.update_lasti(|i| *i = target_pc);
+    }
+
+    /// Jump forward by `delta` code units from after instruction + caches.
+    /// lasti is already at instruction_index + 1, so after = lasti + caches.
+    ///
+    /// Unchecked arithmetic is intentional: the compiler guarantees valid
+    /// targets, and debug builds will catch overflow via Rust's default checks.
+    #[inline]
+    fn jump_relative_forward(&mut self, delta: u32, caches: u32) {
+        let target = self.lasti() + caches + delta;
+        self.update_lasti(|i| *i = target);
+    }
+
+    /// Jump backward by `delta` code units from after instruction + caches.
+    ///
+    /// Unchecked arithmetic is intentional: the compiler guarantees valid
+    /// targets, and debug builds will catch underflow via Rust's default checks.
+    #[inline]
+    fn jump_relative_backward(&mut self, delta: u32, caches: u32) {
+        let target = self.lasti() + caches - delta;
+        self.update_lasti(|i| *i = target);
+    }
+
+    #[inline]
+    fn pop_jump_if_relative(
+        &mut self,
+        vm: &VirtualMachine,
+        arg: bytecode::OpArg,
+        caches: u32,
+        flag: bool,
+    ) -> FrameResult {
+        let obj = self.pop_value();
+        let value = obj.try_to_bool(vm)?;
+        if value == flag {
+            self.jump_relative_forward(u32::from(arg), caches);
+        }
+        Ok(None)
+    }
+
+    /// Advance the iterator on top of stack.
+    /// Returns `true` if iteration continued (item pushed), `false` if exhausted (jumped).
+    fn execute_for_iter(
+        &mut self,
+        vm: &VirtualMachine,
+        target: bytecode::Label,
+    ) -> Result<bool, PyBaseExceptionRef> {
+        let top = self.top_value();
+
+        // FOR_ITER_RANGE: bypass generic iterator protocol for range iterators
+        if let Some(range_iter) = top.downcast_ref_if_exact::<PyRangeIterator>(vm) {
+            if let Some(value) = range_iter.fast_next() {
+                self.push_value(vm.ctx.new_int(value).into());
+                return Ok(true);
+            }
+            if vm.use_tracing.get() && !vm.is_none(&self.object.trace.lock()) {
+                let stop_exc = vm.new_stop_iteration(None);
+                self.fire_exception_trace(&stop_exc, vm)?;
+            }
+            self.jump(self.for_iter_jump_target(target));
+            return Ok(false);
+        }
+
+        let top_of_stack = PyIter::new(top);
+        let next_obj = top_of_stack.next(vm);
+
+        match next_obj {
+            Ok(PyIterReturn::Return(value)) => {
+                self.push_value(value);
+                Ok(true)
+            }
+            Ok(PyIterReturn::StopIteration(value)) => {
+                // Fire 'exception' trace event for StopIteration, matching
+                // FOR_ITER's inline call to _PyEval_MonitorRaise.
+                if vm.use_tracing.get() && !vm.is_none(&self.object.trace.lock()) {
+                    let stop_exc = vm.new_stop_iteration(value);
+                    self.fire_exception_trace(&stop_exc, vm)?;
+                }
+                self.jump(self.for_iter_jump_target(target));
+                Ok(false)
+            }
+            Err(next_error) => {
+                self.pop_value();
+                Err(next_error)
+            }
+        }
+    }
+
+    /// Compute the jump target for FOR_ITER exhaustion: skip END_FOR and jump to POP_ITER.
+    fn for_iter_jump_target(&self, target: bytecode::Label) -> bytecode::Label {
+        let target_idx = target.as_usize();
+        if let Some(unit) = self.code.instructions.get(target_idx)
+            && matches!(
+                unit.op,
+                bytecode::Instruction::EndFor | bytecode::Instruction::InstrumentedEndFor
+            )
+        {
+            return bytecode::Label::from_u32(target.as_u32() + 1);
+        }
+        target
+    }
+    fn execute_make_function(&mut self, vm: &VirtualMachine) -> FrameResult {
+        // MakeFunction only takes code object, no flags
+        let code_obj: PyRef<PyCode> = self
+            .pop_value()
+            .downcast()
+            .expect("Stack value should be code object");
+
+        // Create function with minimal attributes
+        let func_obj = PyFunction::new(code_obj, self.globals.clone(), vm)?.into_pyobject(vm);
+
+        self.push_value(func_obj);
+        Ok(None)
+    }
+
+    fn execute_set_function_attribute(
+        &mut self,
+        vm: &VirtualMachine,
+        attr: bytecode::MakeFunctionFlag,
+    ) -> FrameResult {
+        // SET_FUNCTION_ATTRIBUTE sets attributes on a function
+        // Stack: [..., attr_value, func] -> [..., func]
+        // Stack order: func is at -1, attr_value is at -2
+
+        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
+        let func_ref = func
+            .downcast_ref_if_exact::<PyFunction>(vm)
+            .expect("SET_FUNCTION_ATTRIBUTE expects function on stack");
+
+        let payload: &PyFunction = func_ref.payload();
+        // SetFunctionAttribute always follows MakeFunction, so at this point
+        // there are no other references to func. It is therefore safe to treat it as mutable.
+        unsafe {
+            let payload_ptr = payload as *const PyFunction as *mut PyFunction;
+            (*payload_ptr).set_function_attribute(attr, attr_value, vm)?;
+        };
+
+        Ok(None)
+    }
+
+    #[cfg_attr(feature = "flame-it", flame("Frame"))]
+    fn execute_bin_op(&mut self, vm: &VirtualMachine, op: bytecode::BinaryOperator) -> FrameResult {
+        let b_ref = &self.pop_value();
+        let a_ref = &self.pop_value();
+        let value = match op {
+            // BINARY_OP_ADD_INT / BINARY_OP_SUBTRACT_INT fast paths:
+            // bypass binary_op1 dispatch for exact int types, use i64 arithmetic
+            // when possible to avoid BigInt heap allocation.
+            bytecode::BinaryOperator::Add | bytecode::BinaryOperator::InplaceAdd => {
+                if let (Some(a), Some(b)) = (
+                    a_ref.downcast_ref_if_exact::<PyInt>(vm),
+                    b_ref.downcast_ref_if_exact::<PyInt>(vm),
+                ) {
+                    Ok(self.int_add(a.as_bigint(), b.as_bigint(), vm))
+                } else if matches!(op, bytecode::BinaryOperator::Add) {
+                    vm._add(a_ref, b_ref)
+                } else {
+                    vm._iadd(a_ref, b_ref)
+                }
+            }
+            bytecode::BinaryOperator::Subtract | bytecode::BinaryOperator::InplaceSubtract => {
+                if let (Some(a), Some(b)) = (
+                    a_ref.downcast_ref_if_exact::<PyInt>(vm),
+                    b_ref.downcast_ref_if_exact::<PyInt>(vm),
+                ) {
+                    Ok(self.int_sub(a.as_bigint(), b.as_bigint(), vm))
+                } else if matches!(op, bytecode::BinaryOperator::Subtract) {
+                    vm._sub(a_ref, b_ref)
+                } else {
+                    vm._isub(a_ref, b_ref)
+                }
+            }
+            bytecode::BinaryOperator::Multiply => vm._mul(a_ref, b_ref),
+            bytecode::BinaryOperator::MatrixMultiply => vm._matmul(a_ref, b_ref),
+            bytecode::BinaryOperator::Power => vm._pow(a_ref, b_ref, vm.ctx.none.as_object()),
+            bytecode::BinaryOperator::TrueDivide => vm._truediv(a_ref, b_ref),
+            bytecode::BinaryOperator::FloorDivide => vm._floordiv(a_ref, b_ref),
+            bytecode::BinaryOperator::Remainder => vm._mod(a_ref, b_ref),
+            bytecode::BinaryOperator::Lshift => vm._lshift(a_ref, b_ref),
+            bytecode::BinaryOperator::Rshift => vm._rshift(a_ref, b_ref),
+            bytecode::BinaryOperator::Xor => vm._xor(a_ref, b_ref),
+            bytecode::BinaryOperator::Or => vm._or(a_ref, b_ref),
+            bytecode::BinaryOperator::And => vm._and(a_ref, b_ref),
+            bytecode::BinaryOperator::InplaceMultiply => vm._imul(a_ref, b_ref),
+            bytecode::BinaryOperator::InplaceMatrixMultiply => vm._imatmul(a_ref, b_ref),
+            bytecode::BinaryOperator::InplacePower => {
+                vm._ipow(a_ref, b_ref, vm.ctx.none.as_object())
+            }
+            bytecode::BinaryOperator::InplaceTrueDivide => vm._itruediv(a_ref, b_ref),
+            bytecode::BinaryOperator::InplaceFloorDivide => vm._ifloordiv(a_ref, b_ref),
+            bytecode::BinaryOperator::InplaceRemainder => vm._imod(a_ref, b_ref),
+            bytecode::BinaryOperator::InplaceLshift => vm._ilshift(a_ref, b_ref),
+            bytecode::BinaryOperator::InplaceRshift => vm._irshift(a_ref, b_ref),
+            bytecode::BinaryOperator::InplaceXor => vm._ixor(a_ref, b_ref),
+            bytecode::BinaryOperator::InplaceOr => vm._ior(a_ref, b_ref),
+            bytecode::BinaryOperator::InplaceAnd => vm._iand(a_ref, b_ref),
+            bytecode::BinaryOperator::Subscr => a_ref.get_item(b_ref.as_object(), vm),
+        }?;
+
+        self.push_value(value);
+        Ok(None)
+    }
+
+    /// Int addition with i64 fast path to avoid BigInt heap allocation.
+    #[inline]
+    fn int_add(&self, a: &BigInt, b: &BigInt, vm: &VirtualMachine) -> PyObjectRef {
+        use num_traits::ToPrimitive;
+        if let (Some(av), Some(bv)) = (a.to_i64(), b.to_i64())
+            && let Some(result) = av.checked_add(bv)
+        {
+            return vm.ctx.new_int(result).into();
+        }
+        vm.ctx.new_int(a + b).into()
+    }
+
+    /// Int subtraction with i64 fast path to avoid BigInt heap allocation.
+    #[inline]
+    fn int_sub(&self, a: &BigInt, b: &BigInt, vm: &VirtualMachine) -> PyObjectRef {
+        use num_traits::ToPrimitive;
+        if let (Some(av), Some(bv)) = (a.to_i64(), b.to_i64())
+            && let Some(result) = av.checked_sub(bv)
+        {
+            return vm.ctx.new_int(result).into();
+        }
+        vm.ctx.new_int(a - b).into()
+    }
+
+    #[cold]
+    fn setup_annotations(&mut self, vm: &VirtualMachine) -> FrameResult {
+        let __annotations__ = identifier!(vm, __annotations__);
+        let locals_obj = self.locals.as_object(vm);
+        // Try using locals as dict first, if not, fallback to generic method.
+        let has_annotations = if let Some(d) = locals_obj.downcast_ref_if_exact::<PyDict>(vm) {
+            d.contains_key(__annotations__, vm)
+        } else {
+            self._in(vm, __annotations__.as_object(), locals_obj)?
+        };
+        if !has_annotations {
+            locals_obj.set_item(__annotations__, vm.ctx.new_dict().into(), vm)?;
+        }
+        Ok(None)
+    }
+
+    /// _PyEval_UnpackIterableStackRef
+    fn unpack_sequence(&mut self, size: u32, vm: &VirtualMachine) -> FrameResult {
+        let value = self.pop_value();
+        let size = size as usize;
+
+        // Fast path for exact tuple/list types (not subclasses) — push
+        // elements directly from the slice without intermediate Vec allocation,
+        // matching UNPACK_SEQUENCE_TUPLE / UNPACK_SEQUENCE_LIST specializations.
+        let cls = value.class();
+        if cls.is(vm.ctx.types.tuple_type) {
+            let tuple = value.downcast_ref::<PyTuple>().unwrap();
+            return self.unpack_fast(tuple.as_slice(), size, vm);
+        }
+        if cls.is(vm.ctx.types.list_type) {
+            let list = value.downcast_ref::<PyList>().unwrap();
+            let borrowed = list.borrow_vec();
+            return self.unpack_fast(&borrowed, size, vm);
+        }
+
+        // General path — iterate up to `size + 1` elements to avoid
+        // consuming the entire iterator (fixes hang on infinite sequences).
+        let not_iterable = value.class().slots.iter.load().is_none()
+            && value
+                .get_class_attr(vm.ctx.intern_str("__getitem__"))
+                .is_none();
+        let iter = PyIter::try_from_object(vm, value.clone()).map_err(|e| {
+            if not_iterable && e.class().is(vm.ctx.exceptions.type_error) {
+                vm.new_type_error(format!(
+                    "cannot unpack non-iterable {} object",
+                    value.class().name()
+                ))
+            } else {
+                e
+            }
+        })?;
+
+        let mut elements = Vec::with_capacity(size);
+        for _ in 0..size {
+            match iter.next(vm)? {
+                PyIterReturn::Return(item) => elements.push(item),
+                PyIterReturn::StopIteration(_) => {
+                    return Err(vm.new_value_error(format!(
+                        "not enough values to unpack (expected {size}, got {})",
+                        elements.len()
+                    )));
+                }
+            }
+        }
+
+        // Check that the iterator is exhausted.
+        match iter.next(vm)? {
+            PyIterReturn::Return(_) => {
+                // For exact dict types, show "got N" using the container's
+                // size (PyDict_Size). Exact tuple/list are handled by the
+                // fast path above and never reach here.
+                let msg = if value.class().is(vm.ctx.types.dict_type) {
+                    if let Ok(got) = value.length(vm) {
+                        if got > size {
+                            format!("too many values to unpack (expected {size}, got {got})")
+                        } else {
+                            format!("too many values to unpack (expected {size})")
+                        }
+                    } else {
+                        format!("too many values to unpack (expected {size})")
+                    }
+                } else {
+                    format!("too many values to unpack (expected {size})")
+                };
+                Err(vm.new_value_error(msg))
+            }
+            PyIterReturn::StopIteration(_) => {
+                self.localsplus.stack_extend(
+                    elements
+                        .into_iter()
+                        .rev()
+                        .map(|e| Some(PyStackRef::new_owned(e))),
+                );
+                Ok(None)
+            }
+        }
+    }
+
+    fn unpack_fast(
+        &mut self,
+        elements: &[PyObjectRef],
+        size: usize,
+        vm: &VirtualMachine,
+    ) -> FrameResult {
+        match elements.len().cmp(&size) {
+            core::cmp::Ordering::Equal => {
+                for elem in elements.iter().rev() {
+                    self.push_value(elem.clone());
+                }
+                Ok(None)
+            }
+            core::cmp::Ordering::Greater => Err(vm.new_value_error(format!(
+                "too many values to unpack (expected {size}, got {})",
+                elements.len()
+            ))),
+            core::cmp::Ordering::Less => Err(vm.new_value_error(format!(
+                "not enough values to unpack (expected {size}, got {})",
+                elements.len()
+            ))),
+        }
+    }
+
+    fn convert_value(
+        &mut self,
+        conversion: bytecode::ConvertValueOparg,
+        vm: &VirtualMachine,
+    ) -> FrameResult {
+        use bytecode::ConvertValueOparg;
+        let value = self.pop_value();
+        let value = match conversion {
+            ConvertValueOparg::Str => value.str(vm)?.into(),
+            ConvertValueOparg::Repr => value.repr(vm)?.into(),
+            ConvertValueOparg::Ascii => builtins::ascii(value, vm)?.into(),
+            ConvertValueOparg::None => value,
+        };
+
+        self.push_value(value);
+        Ok(None)
+    }
+
+    fn _in(&self, vm: &VirtualMachine, needle: &PyObject, haystack: &PyObject) -> PyResult<bool> {
+        let found = vm._contains(haystack, needle)?;
+        Ok(found)
+    }
+
+    #[inline(always)]
+    fn _not_in(
+        &self,
+        vm: &VirtualMachine,
+        needle: &PyObject,
+        haystack: &PyObject,
+    ) -> PyResult<bool> {
+        Ok(!self._in(vm, needle, haystack)?)
+    }
+
+    #[cfg_attr(feature = "flame-it", flame("Frame"))]
+    fn execute_compare(
+        &mut self,
+        vm: &VirtualMachine,
+        op: bytecode::ComparisonOperator,
+    ) -> FrameResult {
+        let b = self.pop_value();
+        let a = self.pop_value();
+        let cmp_op: PyComparisonOp = op.into();
+
+        // COMPARE_OP_INT: leaf type, cannot recurse — skip rich_compare dispatch
+        if let (Some(a_int), Some(b_int)) = (
+            a.downcast_ref_if_exact::<PyInt>(vm),
+            b.downcast_ref_if_exact::<PyInt>(vm),
+        ) {
+            let result = cmp_op.eval_ord(a_int.as_bigint().cmp(b_int.as_bigint()));
+            self.push_value(vm.ctx.new_bool(result).into());
+            return Ok(None);
+        }
+        // COMPARE_OP_FLOAT: leaf type, cannot recurse — skip rich_compare dispatch.
+        // Falls through on NaN (partial_cmp returns None) for correct != semantics.
+        if let (Some(a_f), Some(b_f)) = (
+            a.downcast_ref_if_exact::<PyFloat>(vm),
+            b.downcast_ref_if_exact::<PyFloat>(vm),
+        ) && let Some(ord) = a_f.to_f64().partial_cmp(&b_f.to_f64())
+        {
+            let result = cmp_op.eval_ord(ord);
+            self.push_value(vm.ctx.new_bool(result).into());
+            return Ok(None);
+        }
+
+        let value = a.rich_compare(b, cmp_op, vm)?;
+        self.push_value(value);
+        Ok(None)
+    }
+
+    /// Read a cached descriptor pointer and validate it against the expected
+    /// type version, using a lock-free double-check pattern:
+    ///   1. read pointer  →  incref (try_to_owned)
+    ///   2. re-read version + pointer and confirm they still match
+    ///
+    /// This matches the read-side pattern used in LOAD_ATTR_METHOD_WITH_VALUES
+    /// and friends: no read-side lock, relying on the write side to invalidate
+    /// the version tag before swapping the pointer.
+    #[inline]
+    fn try_read_cached_descriptor(
+        &self,
+        cache_base: usize,
+        expected_type_version: u32,
+    ) -> Option<PyObjectRef> {
+        let descr_ptr = self.code.instructions.read_cache_ptr(cache_base + 5);
+        if descr_ptr == 0 {
+            return None;
+        }
+        // SAFETY: `descr_ptr` was a valid `*mut PyObject` when the writer
+        // stored it, and the writer keeps a strong reference alive in
+        // `InlineCacheEntry`.  `try_to_owned_from_ptr` performs a
+        // conditional incref that fails if the object is already freed.
+        let cloned = unsafe { PyObject::try_to_owned_from_ptr(descr_ptr as *mut PyObject) }?;
+        // Double-check: version tag still matches AND pointer unchanged.
+        if self.code.instructions.read_cache_u32(cache_base + 1) == expected_type_version
+            && self.code.instructions.read_cache_ptr(cache_base + 5) == descr_ptr
+        {
+            Some(cloned)
+        } else {
+            drop(cloned);
+            None
+        }
+    }
+
+    #[inline]
+    unsafe fn write_cached_descriptor(
+        &self,
+        cache_base: usize,
+        type_version: u32,
+        descr_ptr: usize,
+    ) {
+        // Publish descriptor cache with version-invalidation protocol:
+        // invalidate version first, then write payload, then publish version.
+        // Reader double-checks version+ptr after incref, so no writer lock needed.
+        unsafe {
+            self.code.instructions.write_cache_u32(cache_base + 1, 0);
+            self.code
+                .instructions
+                .write_cache_ptr(cache_base + 5, descr_ptr);
+            self.code
+                .instructions
+                .write_cache_u32(cache_base + 1, type_version);
+        }
+    }
+
+    #[inline]
+    unsafe fn write_cached_descriptor_with_metaclass(
+        &self,
+        cache_base: usize,
+        type_version: u32,
+        metaclass_version: u32,
+        descr_ptr: usize,
+    ) {
+        unsafe {
+            self.code.instructions.write_cache_u32(cache_base + 1, 0);
+            self.code
+                .instructions
+                .write_cache_u32(cache_base + 3, metaclass_version);
+            self.code
+                .instructions
+                .write_cache_ptr(cache_base + 5, descr_ptr);
+            self.code
+                .instructions
+                .write_cache_u32(cache_base + 1, type_version);
+        }
+    }
+
+    #[inline]
+    unsafe fn write_cached_binary_op_extend_descr(
+        &self,
+        cache_base: usize,
+        descr: Option<&'static BinaryOpExtendSpecializationDescr>,
+    ) {
+        let ptr = descr.map_or(0, |d| {
+            d as *const BinaryOpExtendSpecializationDescr as usize
+        });
+        unsafe {
+            self.code
+                .instructions
+                .write_cache_ptr(cache_base + BINARY_OP_EXTEND_EXTERNAL_CACHE_OFFSET, ptr);
+        }
+    }
+
+    #[inline]
+    fn read_cached_binary_op_extend_descr(
+        &self,
+        cache_base: usize,
+    ) -> Option<&'static BinaryOpExtendSpecializationDescr> {
+        let ptr = self
+            .code
+            .instructions
+            .read_cache_ptr(cache_base + BINARY_OP_EXTEND_EXTERNAL_CACHE_OFFSET);
+        if ptr == 0 {
+            return None;
+        }
+        // SAFETY: We only store pointers to entries in `BINARY_OP_EXTEND_DESCRIPTORS`.
+        Some(unsafe { &*(ptr as *const BinaryOpExtendSpecializationDescr) })
+    }
+
+    #[inline]
+    fn binary_op_extended_specialization(
+        &self,
+        op: bytecode::BinaryOperator,
+        lhs: &PyObject,
+        rhs: &PyObject,
+        vm: &VirtualMachine,
+    ) -> Option<&'static BinaryOpExtendSpecializationDescr> {
+        BINARY_OP_EXTEND_DESCRIPTORS
+            .iter()
+            .find(|d| d.oparg == op && (d.guard)(lhs, rhs, vm))
+    }
+
+    fn load_attr(&mut self, vm: &VirtualMachine, oparg: LoadAttr) -> FrameResult {
+        self.adaptive(|s, ii, cb| s.specialize_load_attr(vm, oparg, ii, cb));
+        self.load_attr_slow(vm, oparg)
+    }
+
+    fn specialize_load_attr(
+        &mut self,
+        _vm: &VirtualMachine,
+        oparg: LoadAttr,
+        instr_idx: usize,
+        cache_base: usize,
+    ) {
+        // Pre-check: bail if already specialized by another thread
+        if !matches!(
+            self.code.instructions.read_op(instr_idx),
+            Instruction::LoadAttr { .. }
+        ) {
+            return;
+        }
+        let obj = self.top_value();
+        let cls = obj.class();
+
+        // Check if this is a type object (class attribute access)
+        if obj.downcast_ref::<PyType>().is_some() {
+            self.specialize_class_load_attr(_vm, oparg, instr_idx, cache_base);
+            return;
+        }
+
+        // Only specialize if getattro is the default (PyBaseObject::getattro)
+        let is_default_getattro = cls
+            .slots
+            .getattro
+            .load()
+            .is_some_and(|f| f as usize == PyBaseObject::getattro as *const () as usize);
+        if !is_default_getattro {
+            let mut type_version = cls.tp_version_tag.load(Acquire);
+            if type_version == 0 {
+                type_version = cls.assign_version_tag();
+            }
+            if type_version != 0
+                && !oparg.is_method()
+                && !self.specialization_eval_frame_active(_vm)
+                && cls.get_attr(identifier!(_vm, __getattr__)).is_none()
+                && let Some(getattribute) = cls.get_attr(identifier!(_vm, __getattribute__))
+                && let Some(func) = getattribute.downcast_ref_if_exact::<PyFunction>(_vm)
+                && func.can_specialize_call(2)
+            {
+                let func_version = func.get_version_for_current_state();
+                if func_version != 0 {
+                    let func_ptr = &*getattribute as *const PyObject as usize;
+                    unsafe {
+                        self.code
+                            .instructions
+                            .write_cache_u32(cache_base + 3, func_version);
+                        self.write_cached_descriptor(cache_base, type_version, func_ptr);
+                    }
+                    self.specialize_at(
+                        instr_idx,
+                        cache_base,
+                        Instruction::LoadAttrGetattributeOverridden,
+                    );
+                    return;
+                }
+            }
+            unsafe {
+                self.code.instructions.write_adaptive_counter(
+                    cache_base,
+                    bytecode::adaptive_counter_backoff(
+                        self.code.instructions.read_adaptive_counter(cache_base),
+                    ),
+                );
+            }
+            return;
+        }
+
+        // Get or assign type version
+        let mut type_version = cls.tp_version_tag.load(Acquire);
+        if type_version == 0 {
+            type_version = cls.assign_version_tag();
+        }
+        if type_version == 0 {
+            // Version counter overflow — backoff to avoid re-attempting every execution
+            unsafe {
+                self.code.instructions.write_adaptive_counter(
+                    cache_base,
+                    bytecode::adaptive_counter_backoff(
+                        self.code.instructions.read_adaptive_counter(cache_base),
+                    ),
+                );
+            }
+            return;
+        }
+
+        let attr_name = self.code.names[oparg.name_idx() as usize];
+
+        // Match CPython: only specialize module attribute loads when the
+        // current module dict has no __getattr__ override and the attribute is
+        // already present.
+        if let Some(module) = obj.downcast_ref_if_exact::<PyModule>(_vm) {
+            let module_dict = module.dict();
+            match (
+                module_dict.get_item_opt(identifier!(_vm, __getattr__), _vm),
+                module_dict.get_item_opt(attr_name, _vm),
+            ) {
+                (Ok(None), Ok(Some(_))) => {
+                    unsafe {
+                        self.code
+                            .instructions
+                            .write_cache_u32(cache_base + 1, type_version);
+                    }
+                    self.specialize_at(instr_idx, cache_base, Instruction::LoadAttrModule);
+                }
+                (Ok(_), Ok(_)) => self.cooldown_adaptive_at(cache_base),
+                _ => unsafe {
+                    self.code.instructions.write_adaptive_counter(
+                        cache_base,
+                        bytecode::adaptive_counter_backoff(
+                            self.code.instructions.read_adaptive_counter(cache_base),
+                        ),
+                    );
+                },
+            }
+            return;
+        }
+
+        // Look up attr in class via MRO
+        let cls_attr = cls.get_attr(attr_name);
+        let class_has_dict = cls.slots.flags.has_feature(PyTypeFlags::HAS_DICT);
+
+        if oparg.is_method() {
+            // Method specialization
+            if let Some(ref descr) = cls_attr
+                && descr
+                    .class()
+                    .slots
+                    .flags
+                    .has_feature(PyTypeFlags::METHOD_DESCRIPTOR)
+            {
+                let descr_ptr = &**descr as *const PyObject as usize;
+                unsafe {
+                    self.write_cached_descriptor(cache_base, type_version, descr_ptr);
+                }
+
+                let new_op = if !class_has_dict {
+                    Instruction::LoadAttrMethodNoDict
+                } else if obj.dict().is_none() {
+                    Instruction::LoadAttrMethodLazyDict
+                } else {
+                    Instruction::LoadAttrMethodWithValues
+                };
+                self.specialize_at(instr_idx, cache_base, new_op);
+                return;
+            }
+            // Can't specialize this method call
+            unsafe {
+                self.code.instructions.write_adaptive_counter(
+                    cache_base,
+                    bytecode::adaptive_counter_backoff(
+                        self.code.instructions.read_adaptive_counter(cache_base),
+                    ),
+                );
+            }
+        } else {
+            // Regular attribute access
+            let has_data_descr = cls_attr.as_ref().is_some_and(|descr| {
+                let descr_cls = descr.class();
+                descr_cls.slots.descr_get.load().is_some()
+                    && descr_cls.slots.descr_set.load().is_some()
+            });
+            let has_descr_get = cls_attr
+                .as_ref()
+                .is_some_and(|descr| descr.class().slots.descr_get.load().is_some());
+
+            if has_data_descr {
+                // Check for member descriptor (slot access)
+                if let Some(ref descr) = cls_attr
+                    && let Some(member_descr) = descr.downcast_ref::<PyMemberDescriptor>()
+                    && let MemberGetter::Offset(offset) = member_descr.member.getter
+                {
+                    unsafe {
+                        self.code
+                            .instructions
+                            .write_cache_u32(cache_base + 1, type_version);
+                        self.code
+                            .instructions
+                            .write_cache_u32(cache_base + 3, offset as u32);
+                    }
+                    self.specialize_at(instr_idx, cache_base, Instruction::LoadAttrSlot);
+                } else if let Some(ref descr) = cls_attr
+                    && let Some(prop) = descr.downcast_ref::<PyProperty>()
+                    && let Some(fget) = prop.get_fget()
+                    && let Some(func) = fget.downcast_ref_if_exact::<PyFunction>(_vm)
+                    && func.can_specialize_call(1)
+                    && !self.specialization_eval_frame_active(_vm)
+                {
+                    // Property specialization caches fget directly.
+                    let fget_ptr = &*fget as *const PyObject as usize;
+                    unsafe {
+                        self.write_cached_descriptor(cache_base, type_version, fget_ptr);
+                    }
+                    self.specialize_at(instr_idx, cache_base, Instruction::LoadAttrProperty);
+                } else {
+                    unsafe {
+                        self.code.instructions.write_adaptive_counter(
+                            cache_base,
+                            bytecode::adaptive_counter_backoff(
+                                self.code.instructions.read_adaptive_counter(cache_base),
+                            ),
+                        );
+                    }
+                }
+            } else if has_descr_get {
+                // Non-data descriptor with __get__ — can't specialize
+                unsafe {
+                    self.code.instructions.write_adaptive_counter(
+                        cache_base,
+                        bytecode::adaptive_counter_backoff(
+                            self.code.instructions.read_adaptive_counter(cache_base),
+                        ),
+                    );
+                }
+            } else if class_has_dict {
+                if let Some(ref descr) = cls_attr {
+                    // Plain class attr + class supports dict — check dict first, fallback
+                    let descr_ptr = &**descr as *const PyObject as usize;
+                    unsafe {
+                        self.write_cached_descriptor(cache_base, type_version, descr_ptr);
+                    }
+                    self.specialize_at(
+                        instr_idx,
+                        cache_base,
+                        Instruction::LoadAttrNondescriptorWithValues,
+                    );
+                } else {
+                    // Match CPython ABSENT/no-shadow behavior: if the
+                    // attribute is missing on both the class and the current
+                    // instance, keep the generic opcode and just enter
+                    // cooldown instead of specializing a repeated miss path.
+                    let has_instance_attr = if let Some(dict) = obj.dict() {
+                        match dict.get_item_opt(attr_name, _vm) {
+                            Ok(Some(_)) => true,
+                            Ok(None) => false,
+                            Err(_) => {
+                                unsafe {
+                                    self.code.instructions.write_adaptive_counter(
+                                        cache_base,
+                                        bytecode::adaptive_counter_backoff(
+                                            self.code
+                                                .instructions
+                                                .read_adaptive_counter(cache_base),
+                                        ),
+                                    );
+                                }
+                                return;
+                            }
+                        }
+                    } else {
+                        false
+                    };
+                    if has_instance_attr {
+                        unsafe {
+                            self.code
+                                .instructions
+                                .write_cache_u32(cache_base + 1, type_version);
                         }
+                        self.specialize_at(instr_idx, cache_base, Instruction::LoadAttrWithHint);
+                    } else {
+                        self.cooldown_adaptive_at(cache_base);
                     }
                 }
-                drop(fastlocals);
-                Ok(Some(ExecutionResult::Return(value)))
+            } else if let Some(ref descr) = cls_attr {
+                // No dict support, plain class attr — cache directly
+                let descr_ptr = &**descr as *const PyObject as usize;
+                unsafe {
+                    self.write_cached_descriptor(cache_base, type_version, descr_ptr);
+                }
+                self.specialize_at(
+                    instr_idx,
+                    cache_base,
+                    Instruction::LoadAttrNondescriptorNoDict,
+                );
+            } else {
+                // No dict and no class attr: repeated miss path, so cooldown.
+                self.cooldown_adaptive_at(cache_base);
             }
         }
     }
 
-    fn execute_store_subscript(&mut self, vm: &VirtualMachine) -> FrameResult {
-        let idx = self.pop_value();
-        let obj = self.pop_value();
-        let value = self.pop_value();
-        obj.set_item(&*idx, value, vm)?;
-        Ok(None)
-    }
-
-    fn execute_delete_subscript(&mut self, vm: &VirtualMachine) -> FrameResult {
-        let idx = self.pop_value();
-        let obj = self.pop_value();
-        obj.del_item(&*idx, vm)?;
-        Ok(None)
-    }
-
-    fn execute_build_map(&mut self, vm: &VirtualMachine, size: u32) -> FrameResult {
-        let size = size as usize;
-        let map_obj = vm.ctx.new_dict();
-        for (key, value) in self.pop_multiple(2 * size).tuples() {
-            map_obj.set_item(&*key, value, vm)?;
-        }
-
-        self.push_value(map_obj.into());
-        Ok(None)
-    }
-
-    fn execute_build_slice(
+    fn specialize_class_load_attr(
         &mut self,
-        vm: &VirtualMachine,
-        argc: bytecode::BuildSliceArgCount,
-    ) -> FrameResult {
-        let step = match argc {
-            bytecode::BuildSliceArgCount::Two => None,
-            bytecode::BuildSliceArgCount::Three => Some(self.pop_value()),
-        };
-        let stop = self.pop_value();
-        let start = self.pop_value();
-
-        let obj = PySlice {
-            start: Some(start),
-            stop,
-            step,
+        _vm: &VirtualMachine,
+        oparg: LoadAttr,
+        instr_idx: usize,
+        cache_base: usize,
+    ) {
+        let obj = self.top_value();
+        let owner_type = obj.downcast_ref::<PyType>().unwrap();
+
+        // Get or assign type version for the type object itself
+        let mut type_version = owner_type.tp_version_tag.load(Acquire);
+        if type_version == 0 {
+            type_version = owner_type.assign_version_tag();
+        }
+        if type_version == 0 {
+            unsafe {
+                self.code.instructions.write_adaptive_counter(
+                    cache_base,
+                    bytecode::adaptive_counter_backoff(
+                        self.code.instructions.read_adaptive_counter(cache_base),
+                    ),
+                );
+            }
+            return;
         }
-        .into_ref(&vm.ctx);
-        self.push_value(obj.into());
-        Ok(None)
-    }
 
-    fn collect_positional_args(&mut self, nargs: u32) -> FuncArgs {
-        FuncArgs {
-            args: self.pop_multiple(nargs as usize).collect(),
-            kwargs: IndexMap::new(),
+        let attr_name = self.code.names[oparg.name_idx() as usize];
+
+        // Check metaclass: ensure no data descriptor on metaclass for this name
+        let mcl = obj.class();
+        let mcl_attr = mcl.get_attr(attr_name);
+        if let Some(ref attr) = mcl_attr {
+            let attr_class = attr.class();
+            if attr_class.slots.descr_set.load().is_some() {
+                // Data descriptor on metaclass — can't specialize
+                unsafe {
+                    self.code.instructions.write_adaptive_counter(
+                        cache_base,
+                        bytecode::adaptive_counter_backoff(
+                            self.code.instructions.read_adaptive_counter(cache_base),
+                        ),
+                    );
+                }
+                return;
+            }
+        }
+        let mut metaclass_version = 0;
+        if !mcl.slots.flags.has_feature(PyTypeFlags::IMMUTABLETYPE) {
+            metaclass_version = mcl.tp_version_tag.load(Acquire);
+            if metaclass_version == 0 {
+                metaclass_version = mcl.assign_version_tag();
+            }
+            if metaclass_version == 0 {
+                unsafe {
+                    self.code.instructions.write_adaptive_counter(
+                        cache_base,
+                        bytecode::adaptive_counter_backoff(
+                            self.code.instructions.read_adaptive_counter(cache_base),
+                        ),
+                    );
+                }
+                return;
+            }
         }
-    }
 
-    fn collect_keyword_args(&mut self, nargs: u32) -> FuncArgs {
-        let kwarg_names = self
-            .pop_value()
-            .downcast::<PyTuple>()
-            .expect("kwarg names should be tuple of strings");
-        let args = self.pop_multiple(nargs as usize);
+        // Look up attr in the type's own MRO
+        let cls_attr = owner_type.get_attr(attr_name);
+        if let Some(ref descr) = cls_attr {
+            let descr_class = descr.class();
+            let has_descr_get = descr_class.slots.descr_get.load().is_some();
+            if !has_descr_get {
+                // METHOD or NON_DESCRIPTOR — can cache directly
+                let descr_ptr = &**descr as *const PyObject as usize;
+                let new_op = if metaclass_version == 0 {
+                    Instruction::LoadAttrClass
+                } else {
+                    Instruction::LoadAttrClassWithMetaclassCheck
+                };
+                unsafe {
+                    if metaclass_version == 0 {
+                        self.write_cached_descriptor(cache_base, type_version, descr_ptr);
+                    } else {
+                        self.write_cached_descriptor_with_metaclass(
+                            cache_base,
+                            type_version,
+                            metaclass_version,
+                            descr_ptr,
+                        );
+                    }
+                }
+                self.specialize_at(instr_idx, cache_base, new_op);
+                return;
+            }
+        }
 
-        let kwarg_names = kwarg_names
-            .as_slice()
-            .iter()
-            .map(|pyobj| pyobj.downcast_ref::<PyStr>().unwrap().as_str().to_owned());
-        FuncArgs::with_kwargs_names(args, kwarg_names)
+        // Can't specialize
+        unsafe {
+            self.code.instructions.write_adaptive_counter(
+                cache_base,
+                bytecode::adaptive_counter_backoff(
+                    self.code.instructions.read_adaptive_counter(cache_base),
+                ),
+            );
+        }
     }
 
-    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();
+    fn load_attr_slow(&mut self, vm: &VirtualMachine, oparg: LoadAttr) -> FrameResult {
+        let attr_name = self.code.names[oparg.name_idx() as usize];
+        let parent = self.pop_value();
 
-            // Use keys() method for all mapping objects to preserve order
-            Self::iterate_mapping_keys(vm, &kw_obj, "argument after **", |key| {
-                let key_str = key
-                    .downcast_ref::<PyStr>()
-                    .ok_or_else(|| vm.new_type_error("keywords must be strings"))?;
-                let value = kw_obj.get_item(&*key, vm)?;
-                kwargs.insert(key_str.as_str().to_owned(), value);
-                Ok(())
-            })?;
-            kwargs
+        if oparg.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 {
-            IndexMap::new()
-        };
-        // SAFETY: trust compiler
-        let args = unsafe { self.pop_value().downcast_unchecked::<PyTuple>() }
-            .as_slice()
-            .to_vec();
-        Ok(FuncArgs { args, kwargs })
+            // Regular attribute access
+            let obj = parent.get_attr(attr_name, vm)?;
+            self.push_value(obj);
+        }
+        Ok(None)
     }
 
-    /// Helper function to iterate over mapping keys using the keys() method.
-    /// This ensures proper order preservation for OrderedDict and other custom mappings.
-    fn iterate_mapping_keys<F>(
+    fn specialize_binary_op(
+        &mut self,
         vm: &VirtualMachine,
-        mapping: &PyObject,
-        error_prefix: &str,
-        mut key_handler: F,
-    ) -> PyResult<()>
-    where
-        F: FnMut(PyObjectRef) -> PyResult<()>,
-    {
-        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")));
-        };
-
-        let keys = keys_method?.call((), vm)?.get_iter(vm)?;
-        while let PyIterReturn::Return(key) = keys.next(vm)? {
-            key_handler(key)?;
+        op: bytecode::BinaryOperator,
+        instr_idx: usize,
+        cache_base: usize,
+    ) {
+        if !matches!(
+            self.code.instructions.read_op(instr_idx),
+            Instruction::BinaryOp { .. }
+        ) {
+            return;
         }
-        Ok(())
-    }
-
-    #[inline]
-    fn execute_call(&mut self, args: FuncArgs, vm: &VirtualMachine) -> FrameResult {
-        // Stack: [callable, self_or_null, ...]
-        let self_or_null = self.pop_value_opt(); // Option<PyObjectRef>
-        let callable = self.pop_value();
+        let b = self.top_value();
+        let a = self.nth_value(1);
+        // `external_cache` in _PyBinaryOpCache is used only by BINARY_OP_EXTEND.
+        unsafe {
+            self.write_cached_binary_op_extend_descr(cache_base, None);
+        }
+        let mut cached_extend_descr = None;
 
-        // 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,
+        let new_op = match op {
+            bytecode::BinaryOperator::Add => {
+                if a.downcast_ref_if_exact::<PyInt>(vm).is_some()
+                    && b.downcast_ref_if_exact::<PyInt>(vm).is_some()
+                {
+                    Some(Instruction::BinaryOpAddInt)
+                } else if a.downcast_ref_if_exact::<PyFloat>(vm).is_some()
+                    && b.downcast_ref_if_exact::<PyFloat>(vm).is_some()
+                {
+                    Some(Instruction::BinaryOpAddFloat)
+                } else if a.downcast_ref_if_exact::<PyStr>(vm).is_some()
+                    && b.downcast_ref_if_exact::<PyStr>(vm).is_some()
+                {
+                    if self
+                        .binary_op_inplace_unicode_target_local(cache_base, a)
+                        .is_some()
+                    {
+                        Some(Instruction::BinaryOpInplaceAddUnicode)
+                    } else {
+                        Some(Instruction::BinaryOpAddUnicode)
+                    }
+                } else if let Some(descr) = self.binary_op_extended_specialization(op, a, b, vm) {
+                    cached_extend_descr = Some(descr);
+                    Some(Instruction::BinaryOpExtend)
+                } else {
+                    None
+                }
             }
-        } else {
-            // Regular attribute call: self_or_null is NULL
-            args
-        };
-
-        let value = callable.call(final_args, vm)?;
-        self.push_value(value);
-        Ok(None)
-    }
-
-    fn execute_raise(&mut self, vm: &VirtualMachine, kind: bytecode::RaiseKind) -> FrameResult {
-        let cause = match kind {
-            bytecode::RaiseKind::RaiseCause => {
-                let val = self.pop_value();
-                Some(if vm.is_none(&val) {
-                    // if the cause arg is none, we clear the cause
+            bytecode::BinaryOperator::Subtract => {
+                if a.downcast_ref_if_exact::<PyInt>(vm).is_some()
+                    && b.downcast_ref_if_exact::<PyInt>(vm).is_some()
+                {
+                    Some(Instruction::BinaryOpSubtractInt)
+                } else if a.downcast_ref_if_exact::<PyFloat>(vm).is_some()
+                    && b.downcast_ref_if_exact::<PyFloat>(vm).is_some()
+                {
+                    Some(Instruction::BinaryOpSubtractFloat)
+                } else if let Some(descr) = self.binary_op_extended_specialization(op, a, b, vm) {
+                    cached_extend_descr = Some(descr);
+                    Some(Instruction::BinaryOpExtend)
+                } else {
                     None
+                }
+            }
+            bytecode::BinaryOperator::Multiply => {
+                if a.downcast_ref_if_exact::<PyInt>(vm).is_some()
+                    && b.downcast_ref_if_exact::<PyInt>(vm).is_some()
+                {
+                    Some(Instruction::BinaryOpMultiplyInt)
+                } else if a.downcast_ref_if_exact::<PyFloat>(vm).is_some()
+                    && b.downcast_ref_if_exact::<PyFloat>(vm).is_some()
+                {
+                    Some(Instruction::BinaryOpMultiplyFloat)
+                } else if let Some(descr) = self.binary_op_extended_specialization(op, a, b, vm) {
+                    cached_extend_descr = Some(descr);
+                    Some(Instruction::BinaryOpExtend)
                 } else {
-                    // if the cause arg is an exception, we overwrite it
-                    let ctor = ExceptionCtor::try_from_object(vm, val).map_err(|_| {
-                        vm.new_type_error("exception causes must derive from BaseException")
-                    })?;
-                    Some(ctor.instantiate(vm)?)
-                })
+                    None
+                }
             }
-            // if there's no cause arg, we keep the cause as is
-            _ => None,
-        };
-        let exception = match kind {
-            bytecode::RaiseKind::RaiseCause | bytecode::RaiseKind::Raise => {
-                ExceptionCtor::try_from_object(vm, self.pop_value())?.instantiate(vm)?
+            bytecode::BinaryOperator::TrueDivide => {
+                if let Some(descr) = self.binary_op_extended_specialization(op, a, b, vm) {
+                    cached_extend_descr = Some(descr);
+                    Some(Instruction::BinaryOpExtend)
+                } else {
+                    None
+                }
             }
-            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::BinaryOperator::Subscr => {
+                let b_is_nonnegative_int = b
+                    .downcast_ref_if_exact::<PyInt>(vm)
+                    .is_some_and(|i| specialization_nonnegative_compact_index(i, vm).is_some());
+                if a.downcast_ref_if_exact::<PyList>(vm).is_some() && b_is_nonnegative_int {
+                    Some(Instruction::BinaryOpSubscrListInt)
+                } else if a.downcast_ref_if_exact::<PyTuple>(vm).is_some() && b_is_nonnegative_int {
+                    Some(Instruction::BinaryOpSubscrTupleInt)
+                } else if a.downcast_ref_if_exact::<PyDict>(vm).is_some() {
+                    Some(Instruction::BinaryOpSubscrDict)
+                } else if a.downcast_ref_if_exact::<PyStr>(vm).is_some() && b_is_nonnegative_int {
+                    Some(Instruction::BinaryOpSubscrStrInt)
+                } else if a.downcast_ref_if_exact::<PyList>(vm).is_some()
+                    && b.downcast_ref::<PySlice>().is_some()
+                {
+                    Some(Instruction::BinaryOpSubscrListSlice)
+                } else {
+                    let cls = a.class();
+                    if cls.slots.flags.has_feature(PyTypeFlags::HEAPTYPE)
+                        && !self.specialization_eval_frame_active(vm)
+                        && let Some(_getitem) = cls.get_attr(identifier!(vm, __getitem__))
+                        && let Some(func) = _getitem.downcast_ref_if_exact::<PyFunction>(vm)
+                        && func.can_specialize_call(2)
+                    {
+                        let mut type_version = cls.tp_version_tag.load(Acquire);
+                        if type_version == 0 {
+                            type_version = cls.assign_version_tag();
+                        }
+                        if type_version != 0 {
+                            if cls.cache_getitem_for_specialization(
+                                func.to_owned(),
+                                type_version,
+                                vm,
+                            ) {
+                                Some(Instruction::BinaryOpSubscrGetitem)
+                            } else {
+                                None
+                            }
+                        } else {
+                            None
+                        }
+                    } else {
+                        None
+                    }
+                }
             }
-            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()
-                    ))
-                })?
+            bytecode::BinaryOperator::InplaceAdd => {
+                if a.downcast_ref_if_exact::<PyStr>(vm).is_some()
+                    && b.downcast_ref_if_exact::<PyStr>(vm).is_some()
+                {
+                    if self
+                        .binary_op_inplace_unicode_target_local(cache_base, a)
+                        .is_some()
+                    {
+                        Some(Instruction::BinaryOpInplaceAddUnicode)
+                    } else {
+                        Some(Instruction::BinaryOpAddUnicode)
+                    }
+                } else if a.downcast_ref_if_exact::<PyInt>(vm).is_some()
+                    && b.downcast_ref_if_exact::<PyInt>(vm).is_some()
+                {
+                    Some(Instruction::BinaryOpAddInt)
+                } else if a.downcast_ref_if_exact::<PyFloat>(vm).is_some()
+                    && b.downcast_ref_if_exact::<PyFloat>(vm).is_some()
+                {
+                    Some(Instruction::BinaryOpAddFloat)
+                } else {
+                    None
+                }
+            }
+            bytecode::BinaryOperator::InplaceSubtract => {
+                if a.downcast_ref_if_exact::<PyInt>(vm).is_some()
+                    && b.downcast_ref_if_exact::<PyInt>(vm).is_some()
+                {
+                    Some(Instruction::BinaryOpSubtractInt)
+                } else if a.downcast_ref_if_exact::<PyFloat>(vm).is_some()
+                    && b.downcast_ref_if_exact::<PyFloat>(vm).is_some()
+                {
+                    Some(Instruction::BinaryOpSubtractFloat)
+                } else {
+                    None
+                }
+            }
+            bytecode::BinaryOperator::InplaceMultiply => {
+                if a.downcast_ref_if_exact::<PyInt>(vm).is_some()
+                    && b.downcast_ref_if_exact::<PyInt>(vm).is_some()
+                {
+                    Some(Instruction::BinaryOpMultiplyInt)
+                } else if a.downcast_ref_if_exact::<PyFloat>(vm).is_some()
+                    && b.downcast_ref_if_exact::<PyFloat>(vm).is_some()
+                {
+                    Some(Instruction::BinaryOpMultiplyFloat)
+                } else {
+                    None
+                }
+            }
+            bytecode::BinaryOperator::And
+            | bytecode::BinaryOperator::Or
+            | bytecode::BinaryOperator::Xor
+            | bytecode::BinaryOperator::InplaceAnd
+            | bytecode::BinaryOperator::InplaceOr
+            | bytecode::BinaryOperator::InplaceXor => {
+                if let Some(descr) = self.binary_op_extended_specialization(op, a, b, vm) {
+                    cached_extend_descr = Some(descr);
+                    Some(Instruction::BinaryOpExtend)
+                } else {
+                    None
+                }
             }
+            _ => None,
         };
-        #[cfg(debug_assertions)]
-        debug!("Exception raised: {exception:?} with cause: {cause:?}");
-        if let Some(cause) = cause {
-            exception.set___cause__(cause);
+
+        if matches!(new_op, Some(Instruction::BinaryOpExtend)) {
+            unsafe {
+                self.write_cached_binary_op_extend_descr(cache_base, cached_extend_descr);
+            }
         }
-        Err(exception)
+        self.commit_specialization(instr_idx, cache_base, new_op);
     }
 
-    fn builtin_coro<'a>(&self, coro: &'a PyObject) -> Option<&'a Coro> {
-        match_class!(match coro {
-            ref g @ PyGenerator => Some(g.as_coro()),
-            ref c @ PyCoroutine => Some(c.as_coro()),
-            _ => None,
-        })
+    #[inline]
+    fn binary_op_inplace_unicode_target_local(
+        &self,
+        cache_base: usize,
+        left: &PyObject,
+    ) -> Option<usize> {
+        let next_idx = cache_base + Instruction::BinaryOp { op: Arg::marker() }.cache_entries();
+        let unit = self.code.instructions.get(next_idx)?;
+        let next_op = unit.op.to_base().unwrap_or(unit.op);
+        if !matches!(next_op, Instruction::StoreFast { .. }) {
+            return None;
+        }
+        let local_idx = usize::from(u8::from(unit.arg));
+        self.localsplus
+            .fastlocals()
+            .get(local_idx)
+            .and_then(|slot| slot.as_ref())
+            .filter(|local| local.is(left))
+            .map(|_| local_idx)
     }
 
-    fn _send(
-        &self,
-        jen: &PyObject,
-        val: PyObjectRef,
-        vm: &VirtualMachine,
-    ) -> PyResult<PyIterReturn> {
-        match self.builtin_coro(jen) {
-            Some(coro) => coro.send(jen, val, vm),
-            // FIXME: turn return type to PyResult<PyIterReturn> then ExecutionResult will be simplified
-            None if vm.is_none(&val) => PyIter::new(jen).next(vm),
-            None => {
-                let meth = jen.get_attr("send", vm)?;
-                PyIterReturn::from_pyresult(meth.call((val,), vm), vm)
+    /// Adaptive counter: trigger specialization at zero, otherwise advance countdown.
+    #[inline]
+    fn adaptive(&mut self, specialize: impl FnOnce(&mut Self, usize, usize)) {
+        let instr_idx = self.lasti() as usize - 1;
+        let cache_base = instr_idx + 1;
+        let counter = self.code.instructions.read_adaptive_counter(cache_base);
+        if bytecode::adaptive_counter_triggers(counter) {
+            specialize(self, instr_idx, cache_base);
+        } else {
+            unsafe {
+                self.code.instructions.write_adaptive_counter(
+                    cache_base,
+                    bytecode::advance_adaptive_counter(counter),
+                );
             }
         }
     }
 
-    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();
-        let elements: Vec<_> = value.try_to_value(vm)?;
-        let min_expected = before + after;
-
-        let middle = elements.len().checked_sub(min_expected).ok_or_else(|| {
-            vm.new_value_error(format!(
-                "not enough values to unpack (expected at least {}, got {})",
-                min_expected,
-                elements.len()
-            ))
-        })?;
-
-        let mut elements = elements;
-        // Elements on stack from right-to-left:
-        self.state
-            .stack
-            .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());
+    /// Install a specialized opcode and set adaptive cooldown bits.
+    #[inline]
+    fn specialize_at(&mut self, instr_idx: usize, cache_base: usize, new_op: Instruction) {
+        unsafe {
+            self.code
+                .instructions
+                .write_adaptive_counter(cache_base, ADAPTIVE_COOLDOWN_VALUE);
+            self.code.instructions.replace_op(instr_idx, new_op);
+        }
+    }
 
-        // Lastly the first reversed values:
-        self.state
-            .stack
-            .extend(elements.into_iter().rev().map(Some));
+    #[inline]
+    fn cooldown_adaptive_at(&mut self, cache_base: usize) {
+        unsafe {
+            self.code
+                .instructions
+                .write_adaptive_counter(cache_base, ADAPTIVE_COOLDOWN_VALUE);
+        }
+    }
 
-        Ok(None)
+    /// Commit a specialization result: replace op on success, backoff on failure.
+    #[inline]
+    fn commit_specialization(
+        &mut self,
+        instr_idx: usize,
+        cache_base: usize,
+        new_op: Option<Instruction>,
+    ) {
+        if let Some(new_op) = new_op {
+            self.specialize_at(instr_idx, cache_base, new_op);
+        } else {
+            unsafe {
+                self.code.instructions.write_adaptive_counter(
+                    cache_base,
+                    bytecode::adaptive_counter_backoff(
+                        self.code.instructions.read_adaptive_counter(cache_base),
+                    ),
+                );
+            }
+        }
     }
 
+    /// Execute a specialized binary op on two int operands.
+    /// Fallback to generic binary op if either operand is not an exact int.
     #[inline]
-    fn jump(&mut self, label: bytecode::Label) {
-        let target_pc = label.0;
-        vm_trace!("jump from {:?} to {:?}", self.lasti(), target_pc);
-        self.update_lasti(|i| *i = target_pc);
+    fn execute_binary_op_int(
+        &mut self,
+        vm: &VirtualMachine,
+        op: impl FnOnce(&BigInt, &BigInt) -> BigInt,
+        deopt_op: bytecode::BinaryOperator,
+    ) -> FrameResult {
+        let b = self.top_value();
+        let a = self.nth_value(1);
+        if let (Some(a_int), Some(b_int)) = (
+            a.downcast_ref_if_exact::<PyInt>(vm),
+            b.downcast_ref_if_exact::<PyInt>(vm),
+        ) {
+            let result = op(a_int.as_bigint(), b_int.as_bigint());
+            self.pop_value();
+            self.pop_value();
+            self.push_value(vm.ctx.new_bigint(&result).into());
+            Ok(None)
+        } else {
+            self.execute_bin_op(vm, deopt_op)
+        }
     }
 
+    /// Execute a specialized binary op on two float operands.
+    /// Fallback to generic binary op if either operand is not an exact float.
     #[inline]
-    fn pop_jump_if(
+    fn execute_binary_op_float(
         &mut self,
         vm: &VirtualMachine,
-        target: bytecode::Label,
-        flag: bool,
+        op: impl FnOnce(f64, f64) -> f64,
+        deopt_op: bytecode::BinaryOperator,
     ) -> FrameResult {
-        let obj = self.pop_value();
-        let value = obj.try_to_bool(vm)?;
-        if value == flag {
-            self.jump(target);
+        let b = self.top_value();
+        let a = self.nth_value(1);
+        if let (Some(a_f), Some(b_f)) = (
+            a.downcast_ref_if_exact::<PyFloat>(vm),
+            b.downcast_ref_if_exact::<PyFloat>(vm),
+        ) {
+            let result = op(a_f.to_f64(), b_f.to_f64());
+            self.pop_value();
+            self.pop_value();
+            self.push_value(vm.ctx.new_float(result).into());
+            Ok(None)
+        } else {
+            self.execute_bin_op(vm, deopt_op)
         }
-        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());
-        let next_obj = top_of_stack.next(vm);
+    fn specialize_call(
+        &mut self,
+        vm: &VirtualMachine,
+        nargs: u32,
+        instr_idx: usize,
+        cache_base: usize,
+    ) {
+        if !matches!(
+            self.code.instructions.read_op(instr_idx),
+            Instruction::Call { .. }
+        ) {
+            return;
+        }
+        // Stack: [callable, self_or_null, arg1, ..., argN]
+        // callable is at position nargs + 1 from top
+        // self_or_null is at position nargs from top
+        let stack_len = self.localsplus.stack_len();
+        let self_or_null_is_some = self
+            .localsplus
+            .stack_index(stack_len - nargs as usize - 1)
+            .is_some();
+        let callable = self.nth_value(nargs + 1);
+
+        if let Some(func) = callable.downcast_ref_if_exact::<PyFunction>(vm) {
+            if self.specialization_eval_frame_active(vm) {
+                unsafe {
+                    self.code.instructions.write_adaptive_counter(
+                        cache_base,
+                        bytecode::adaptive_counter_backoff(
+                            self.code.instructions.read_adaptive_counter(cache_base),
+                        ),
+                    );
+                }
+                return;
+            }
+            if !func.is_optimized_for_call_specialization() {
+                unsafe {
+                    self.code.instructions.write_adaptive_counter(
+                        cache_base,
+                        bytecode::adaptive_counter_backoff(
+                            self.code.instructions.read_adaptive_counter(cache_base),
+                        ),
+                    );
+                }
+                return;
+            }
+            let version = func.get_version_for_current_state();
+            if version == 0 {
+                unsafe {
+                    self.code.instructions.write_adaptive_counter(
+                        cache_base,
+                        bytecode::adaptive_counter_backoff(
+                            self.code.instructions.read_adaptive_counter(cache_base),
+                        ),
+                    );
+                }
+                return;
+            }
 
-        // Check the next object:
-        match next_obj {
-            Ok(PyIterReturn::Return(value)) => {
-                self.push_value(value);
-                Ok(None)
+            let effective_nargs = if self_or_null_is_some {
+                nargs + 1
+            } else {
+                nargs
+            };
+
+            let new_op = if func.can_specialize_call(effective_nargs) {
+                Instruction::CallPyExactArgs
+            } else {
+                Instruction::CallPyGeneral
+            };
+            unsafe {
+                self.code
+                    .instructions
+                    .write_cache_u32(cache_base + 1, version);
             }
-            Ok(PyIterReturn::StopIteration(_)) => {
-                // Check if target instruction is END_FOR (CPython 3.14 pattern)
-                // If so, skip it and jump to target + 1 instruction (POP_ITER)
-                let target_idx = target.0 as usize;
-                let jump_target = if let Some(unit) = self.code.instructions.get(target_idx) {
-                    if matches!(unit.op, bytecode::Instruction::EndFor)
-                        && matches!(
-                            self.code.instructions.get(target_idx + 1).map(|u| &u.op),
-                            Some(bytecode::Instruction::PopIter)
-                        )
-                    {
-                        // Skip END_FOR, jump to POP_ITER
-                        bytecode::Label(target.0 + 1)
-                    } else {
-                        // Legacy pattern: jump directly to target (POP_TOP/POP_ITER)
-                        target
+            self.specialize_at(instr_idx, cache_base, new_op);
+            return;
+        }
+
+        // Bound Python method object (`method`) specialization.
+        if !self_or_null_is_some
+            && let Some(bound_method) = callable.downcast_ref_if_exact::<PyBoundMethod>(vm)
+        {
+            if let Some(func) = bound_method
+                .function_obj()
+                .downcast_ref_if_exact::<PyFunction>(vm)
+            {
+                if self.specialization_eval_frame_active(vm) {
+                    unsafe {
+                        self.code.instructions.write_adaptive_counter(
+                            cache_base,
+                            bytecode::adaptive_counter_backoff(
+                                self.code.instructions.read_adaptive_counter(cache_base),
+                            ),
+                        );
                     }
+                    return;
+                }
+                if !func.is_optimized_for_call_specialization() {
+                    unsafe {
+                        self.code.instructions.write_adaptive_counter(
+                            cache_base,
+                            bytecode::adaptive_counter_backoff(
+                                self.code.instructions.read_adaptive_counter(cache_base),
+                            ),
+                        );
+                    }
+                    return;
+                }
+                let version = func.get_version_for_current_state();
+                if version == 0 {
+                    unsafe {
+                        self.code.instructions.write_adaptive_counter(
+                            cache_base,
+                            bytecode::adaptive_counter_backoff(
+                                self.code.instructions.read_adaptive_counter(cache_base),
+                            ),
+                        );
+                    }
+                    return;
+                }
+
+                let new_op = if func.can_specialize_call(nargs + 1) {
+                    Instruction::CallBoundMethodExactArgs
                 } else {
-                    target
+                    Instruction::CallBoundMethodGeneral
                 };
-                self.jump(jump_target);
-                Ok(None)
+                unsafe {
+                    self.code
+                        .instructions
+                        .write_cache_u32(cache_base + 1, version);
+                }
+                self.specialize_at(instr_idx, cache_base, new_op);
+            } else {
+                // Match CPython: bound methods wrapping non-Python callables
+                // are not specialized as CALL_NON_PY_GENERAL.
+                unsafe {
+                    self.code.instructions.write_adaptive_counter(
+                        cache_base,
+                        bytecode::adaptive_counter_backoff(
+                            self.code.instructions.read_adaptive_counter(cache_base),
+                        ),
+                    );
+                }
             }
-            Err(next_error) => {
-                // On error, pop iterator and propagate
-                self.pop_value();
-                Err(next_error)
+            return;
+        }
+
+        // Try to specialize method descriptor calls
+        if let Some(descr) = callable.downcast_ref_if_exact::<PyMethodDescriptor>(vm) {
+            let call_cache_entries = Instruction::CallListAppend.cache_entries();
+            let next_idx = cache_base + call_cache_entries;
+            let next_is_pop_top = if next_idx < self.code.instructions.len() {
+                let next_op = self.code.instructions.read_op(next_idx);
+                matches!(next_op.to_base().unwrap_or(next_op), Instruction::PopTop)
+            } else {
+                false
+            };
+
+            let call_conv = descr.method.flags
+                & (PyMethodFlags::VARARGS
+                    | PyMethodFlags::FASTCALL
+                    | PyMethodFlags::NOARGS
+                    | PyMethodFlags::O
+                    | PyMethodFlags::KEYWORDS);
+            let total_nargs = nargs + u32::from(self_or_null_is_some);
+
+            let new_op = if call_conv == PyMethodFlags::NOARGS {
+                if total_nargs != 1 {
+                    unsafe {
+                        self.code.instructions.write_adaptive_counter(
+                            cache_base,
+                            bytecode::adaptive_counter_backoff(
+                                self.code.instructions.read_adaptive_counter(cache_base),
+                            ),
+                        );
+                    }
+                    return;
+                }
+                Instruction::CallMethodDescriptorNoargs
+            } else if call_conv == PyMethodFlags::O {
+                if total_nargs != 2 {
+                    unsafe {
+                        self.code.instructions.write_adaptive_counter(
+                            cache_base,
+                            bytecode::adaptive_counter_backoff(
+                                self.code.instructions.read_adaptive_counter(cache_base),
+                            ),
+                        );
+                    }
+                    return;
+                }
+                if self_or_null_is_some
+                    && nargs == 1
+                    && next_is_pop_top
+                    && vm
+                        .callable_cache
+                        .list_append
+                        .as_ref()
+                        .is_some_and(|list_append| callable.is(list_append))
+                {
+                    Instruction::CallListAppend
+                } else {
+                    Instruction::CallMethodDescriptorO
+                }
+            } else if call_conv == PyMethodFlags::FASTCALL {
+                Instruction::CallMethodDescriptorFast
+            } else if call_conv == (PyMethodFlags::FASTCALL | PyMethodFlags::KEYWORDS) {
+                Instruction::CallMethodDescriptorFastWithKeywords
+            } else {
+                Instruction::CallNonPyGeneral
+            };
+            self.specialize_at(instr_idx, cache_base, new_op);
+            return;
+        }
+
+        // Try to specialize builtin calls
+        if let Some(native) = callable.downcast_ref_if_exact::<PyNativeFunction>(vm) {
+            let effective_nargs = nargs + u32::from(self_or_null_is_some);
+            let call_conv = native.value.flags
+                & (PyMethodFlags::VARARGS
+                    | PyMethodFlags::FASTCALL
+                    | PyMethodFlags::NOARGS
+                    | PyMethodFlags::O
+                    | PyMethodFlags::KEYWORDS);
+            let new_op = if call_conv == PyMethodFlags::O {
+                if effective_nargs != 1 {
+                    unsafe {
+                        self.code.instructions.write_adaptive_counter(
+                            cache_base,
+                            bytecode::adaptive_counter_backoff(
+                                self.code.instructions.read_adaptive_counter(cache_base),
+                            ),
+                        );
+                    }
+                    return;
+                }
+                if native.zelf.is_none()
+                    && nargs == 1
+                    && vm
+                        .callable_cache
+                        .len
+                        .as_ref()
+                        .is_some_and(|len_callable| callable.is(len_callable))
+                {
+                    Instruction::CallLen
+                } else {
+                    Instruction::CallBuiltinO
+                }
+            } else if call_conv == PyMethodFlags::FASTCALL {
+                if native.zelf.is_none()
+                    && effective_nargs == 2
+                    && vm
+                        .callable_cache
+                        .isinstance
+                        .as_ref()
+                        .is_some_and(|isinstance_callable| callable.is(isinstance_callable))
+                {
+                    Instruction::CallIsinstance
+                } else {
+                    Instruction::CallBuiltinFast
+                }
+            } else if call_conv == (PyMethodFlags::FASTCALL | PyMethodFlags::KEYWORDS) {
+                Instruction::CallBuiltinFastWithKeywords
+            } else {
+                Instruction::CallNonPyGeneral
+            };
+            self.specialize_at(instr_idx, cache_base, new_op);
+            return;
+        }
+
+        // type/str/tuple(x) and class-call specializations
+        if let Some(cls) = callable.downcast_ref::<PyType>() {
+            if cls.slots.flags.has_feature(PyTypeFlags::IMMUTABLETYPE) {
+                if !self_or_null_is_some && nargs == 1 {
+                    let new_op = if callable.is(&vm.ctx.types.type_type.as_object()) {
+                        Some(Instruction::CallType1)
+                    } else if callable.is(&vm.ctx.types.str_type.as_object()) {
+                        Some(Instruction::CallStr1)
+                    } else if callable.is(&vm.ctx.types.tuple_type.as_object()) {
+                        Some(Instruction::CallTuple1)
+                    } else {
+                        None
+                    };
+                    if let Some(new_op) = new_op {
+                        self.specialize_at(instr_idx, cache_base, new_op);
+                        return;
+                    }
+                }
+                if cls.slots.vectorcall.load().is_some() {
+                    self.specialize_at(instr_idx, cache_base, Instruction::CallBuiltinClass);
+                    return;
+                }
+                self.specialize_at(instr_idx, cache_base, Instruction::CallNonPyGeneral);
+                return;
+            }
+
+            // CPython only considers CALL_ALLOC_AND_ENTER_INIT for types whose
+            // metaclass is exactly `type`.
+            if !callable.class().is(vm.ctx.types.type_type) {
+                self.specialize_at(instr_idx, cache_base, Instruction::CallNonPyGeneral);
+                return;
+            }
+
+            // CallAllocAndEnterInit: heap type with default __new__
+            if !self_or_null_is_some && cls.slots.flags.has_feature(PyTypeFlags::HEAPTYPE) {
+                let object_new = vm.ctx.types.object_type.slots.new.load();
+                let cls_new = cls.slots.new.load();
+                let object_alloc = vm.ctx.types.object_type.slots.alloc.load();
+                let cls_alloc = cls.slots.alloc.load();
+                if let (Some(cls_new_fn), Some(obj_new_fn), Some(cls_alloc_fn), Some(obj_alloc_fn)) =
+                    (cls_new, object_new, cls_alloc, object_alloc)
+                    && cls_new_fn as usize == obj_new_fn as usize
+                    && cls_alloc_fn as usize == obj_alloc_fn as usize
+                {
+                    let init = cls.get_attr(identifier!(vm, __init__));
+                    let mut version = cls.tp_version_tag.load(Acquire);
+                    if version == 0 {
+                        version = cls.assign_version_tag();
+                    }
+                    if version == 0 {
+                        unsafe {
+                            self.code.instructions.write_adaptive_counter(
+                                cache_base,
+                                bytecode::adaptive_counter_backoff(
+                                    self.code.instructions.read_adaptive_counter(cache_base),
+                                ),
+                            );
+                        }
+                        return;
+                    }
+                    if let Some(init) = init
+                        && let Some(init_func) = init.downcast_ref_if_exact::<PyFunction>(vm)
+                        && init_func.is_simple_for_call_specialization()
+                        && cls.cache_init_for_specialization(init_func.to_owned(), version, vm)
+                    {
+                        unsafe {
+                            self.code
+                                .instructions
+                                .write_cache_u32(cache_base + 1, version);
+                        }
+                        self.specialize_at(
+                            instr_idx,
+                            cache_base,
+                            Instruction::CallAllocAndEnterInit,
+                        );
+                        return;
+                    }
+                }
             }
+            self.specialize_at(instr_idx, cache_base, Instruction::CallNonPyGeneral);
+            return;
         }
+
+        // General fallback: specialized non-Python callable path
+        self.specialize_at(instr_idx, cache_base, Instruction::CallNonPyGeneral);
     }
-    fn execute_make_function(&mut self, vm: &VirtualMachine) -> FrameResult {
-        // MakeFunction only takes code object, no flags
-        let code_obj: PyRef<PyCode> = self
-            .pop_value()
-            .downcast()
-            .expect("Stack value should be code object");
 
-        // Create function with minimal attributes
-        let func_obj = PyFunction::new(code_obj, self.globals.clone(), vm)?.into_pyobject(vm);
+    fn specialize_call_kw(
+        &mut self,
+        vm: &VirtualMachine,
+        nargs: u32,
+        instr_idx: usize,
+        cache_base: usize,
+    ) {
+        if !matches!(
+            self.code.instructions.read_op(instr_idx),
+            Instruction::CallKw { .. }
+        ) {
+            return;
+        }
+        // Stack: [callable, self_or_null, arg1, ..., argN, kwarg_names]
+        // callable is at position nargs + 2 from top
+        let stack_len = self.localsplus.stack_len();
+        let self_or_null_is_some = self
+            .localsplus
+            .stack_index(stack_len - nargs as usize - 2)
+            .is_some();
+        let callable = self.nth_value(nargs + 2);
+
+        if let Some(func) = callable.downcast_ref_if_exact::<PyFunction>(vm) {
+            if self.specialization_eval_frame_active(vm) {
+                unsafe {
+                    self.code.instructions.write_adaptive_counter(
+                        cache_base,
+                        bytecode::adaptive_counter_backoff(
+                            self.code.instructions.read_adaptive_counter(cache_base),
+                        ),
+                    );
+                }
+                return;
+            }
+            if !func.is_optimized_for_call_specialization() {
+                unsafe {
+                    self.code.instructions.write_adaptive_counter(
+                        cache_base,
+                        bytecode::adaptive_counter_backoff(
+                            self.code.instructions.read_adaptive_counter(cache_base),
+                        ),
+                    );
+                }
+                return;
+            }
+            let version = func.get_version_for_current_state();
+            if version == 0 {
+                unsafe {
+                    self.code.instructions.write_adaptive_counter(
+                        cache_base,
+                        bytecode::adaptive_counter_backoff(
+                            self.code.instructions.read_adaptive_counter(cache_base),
+                        ),
+                    );
+                }
+                return;
+            }
 
-        self.push_value(func_obj);
-        Ok(None)
+            unsafe {
+                self.code
+                    .instructions
+                    .write_cache_u32(cache_base + 1, version);
+            }
+            self.specialize_at(instr_idx, cache_base, Instruction::CallKwPy);
+            return;
+        }
+
+        if !self_or_null_is_some
+            && let Some(bound_method) = callable.downcast_ref_if_exact::<PyBoundMethod>(vm)
+        {
+            if let Some(func) = bound_method
+                .function_obj()
+                .downcast_ref_if_exact::<PyFunction>(vm)
+            {
+                if self.specialization_eval_frame_active(vm) {
+                    unsafe {
+                        self.code.instructions.write_adaptive_counter(
+                            cache_base,
+                            bytecode::adaptive_counter_backoff(
+                                self.code.instructions.read_adaptive_counter(cache_base),
+                            ),
+                        );
+                    }
+                    return;
+                }
+                if !func.is_optimized_for_call_specialization() {
+                    unsafe {
+                        self.code.instructions.write_adaptive_counter(
+                            cache_base,
+                            bytecode::adaptive_counter_backoff(
+                                self.code.instructions.read_adaptive_counter(cache_base),
+                            ),
+                        );
+                    }
+                    return;
+                }
+                let version = func.get_version_for_current_state();
+                if version == 0 {
+                    unsafe {
+                        self.code.instructions.write_adaptive_counter(
+                            cache_base,
+                            bytecode::adaptive_counter_backoff(
+                                self.code.instructions.read_adaptive_counter(cache_base),
+                            ),
+                        );
+                    }
+                    return;
+                }
+                unsafe {
+                    self.code
+                        .instructions
+                        .write_cache_u32(cache_base + 1, version);
+                }
+                self.specialize_at(instr_idx, cache_base, Instruction::CallKwBoundMethod);
+            } else {
+                // Match CPython: bound methods wrapping non-Python callables
+                // are not specialized as CALL_KW_NON_PY.
+                unsafe {
+                    self.code.instructions.write_adaptive_counter(
+                        cache_base,
+                        bytecode::adaptive_counter_backoff(
+                            self.code.instructions.read_adaptive_counter(cache_base),
+                        ),
+                    );
+                }
+            }
+            return;
+        }
+
+        // General fallback: specialized non-Python callable path
+        self.specialize_at(instr_idx, cache_base, Instruction::CallKwNonPy);
+    }
+
+    fn specialize_send(&mut self, vm: &VirtualMachine, instr_idx: usize, cache_base: usize) {
+        if !matches!(
+            self.code.instructions.read_op(instr_idx),
+            Instruction::Send { .. }
+        ) {
+            return;
+        }
+        // Stack: [receiver, val] — receiver is at position 1
+        let receiver = self.nth_value(1);
+        let is_exact_gen_or_coro = receiver.downcast_ref_if_exact::<PyGenerator>(vm).is_some()
+            || receiver.downcast_ref_if_exact::<PyCoroutine>(vm).is_some();
+        if is_exact_gen_or_coro && !self.specialization_eval_frame_active(vm) {
+            self.specialize_at(instr_idx, cache_base, Instruction::SendGen);
+        } else {
+            unsafe {
+                self.code.instructions.write_adaptive_counter(
+                    cache_base,
+                    bytecode::adaptive_counter_backoff(
+                        self.code.instructions.read_adaptive_counter(cache_base),
+                    ),
+                );
+            }
+        }
+    }
+
+    fn specialize_load_super_attr(
+        &mut self,
+        vm: &VirtualMachine,
+        oparg: LoadSuperAttr,
+        instr_idx: usize,
+        cache_base: usize,
+    ) {
+        if !matches!(
+            self.code.instructions.read_op(instr_idx),
+            Instruction::LoadSuperAttr { .. }
+        ) {
+            return;
+        }
+        // Stack: [global_super, class, self]
+        let global_super = self.nth_value(2);
+        let class = self.nth_value(1);
+
+        if !global_super.is(&vm.ctx.types.super_type.as_object())
+            || class.downcast_ref::<PyType>().is_none()
+        {
+            unsafe {
+                self.code.instructions.write_adaptive_counter(
+                    cache_base,
+                    bytecode::adaptive_counter_backoff(
+                        self.code.instructions.read_adaptive_counter(cache_base),
+                    ),
+                );
+            }
+            return;
+        }
+
+        let new_op = if oparg.is_load_method() {
+            Instruction::LoadSuperAttrMethod
+        } else {
+            Instruction::LoadSuperAttrAttr
+        };
+        self.specialize_at(instr_idx, cache_base, new_op);
+    }
+
+    fn specialize_compare_op(
+        &mut self,
+        vm: &VirtualMachine,
+        op: bytecode::ComparisonOperator,
+        instr_idx: usize,
+        cache_base: usize,
+    ) {
+        if !matches!(
+            self.code.instructions.read_op(instr_idx),
+            Instruction::CompareOp { .. }
+        ) {
+            return;
+        }
+        let b = self.top_value();
+        let a = self.nth_value(1);
+
+        let new_op = if let (Some(a_int), Some(b_int)) = (
+            a.downcast_ref_if_exact::<PyInt>(vm),
+            b.downcast_ref_if_exact::<PyInt>(vm),
+        ) {
+            if specialization_compact_int_value(a_int, vm).is_some()
+                && specialization_compact_int_value(b_int, vm).is_some()
+            {
+                Some(Instruction::CompareOpInt)
+            } else {
+                None
+            }
+        } else if a.downcast_ref_if_exact::<PyFloat>(vm).is_some()
+            && b.downcast_ref_if_exact::<PyFloat>(vm).is_some()
+        {
+            Some(Instruction::CompareOpFloat)
+        } else if a.downcast_ref_if_exact::<PyStr>(vm).is_some()
+            && b.downcast_ref_if_exact::<PyStr>(vm).is_some()
+            && (op == bytecode::ComparisonOperator::Equal
+                || op == bytecode::ComparisonOperator::NotEqual)
+        {
+            Some(Instruction::CompareOpStr)
+        } else {
+            None
+        };
+
+        self.commit_specialization(instr_idx, cache_base, new_op);
+    }
+
+    /// Recover the ComparisonOperator from the instruction arg byte.
+    /// `replace_op` preserves the arg byte, so the original op remains accessible.
+    fn compare_op_from_arg(&self, arg: bytecode::OpArg) -> PyComparisonOp {
+        bytecode::ComparisonOperator::try_from(u32::from(arg))
+            .unwrap_or(bytecode::ComparisonOperator::Equal)
+            .into()
+    }
+
+    /// Recover the BinaryOperator from the instruction arg byte.
+    /// `replace_op` preserves the arg byte, so the original op remains accessible.
+    fn binary_op_from_arg(&self, arg: bytecode::OpArg) -> bytecode::BinaryOperator {
+        bytecode::BinaryOperator::try_from(u32::from(arg)).unwrap_or(bytecode::BinaryOperator::Add)
+    }
+
+    fn specialize_to_bool(&mut self, vm: &VirtualMachine, instr_idx: usize, cache_base: usize) {
+        if !matches!(
+            self.code.instructions.read_op(instr_idx),
+            Instruction::ToBool
+        ) {
+            return;
+        }
+        let obj = self.top_value();
+        let cls = obj.class();
+
+        let new_op = if cls.is(vm.ctx.types.bool_type) {
+            Some(Instruction::ToBoolBool)
+        } else if cls.is(PyInt::class(&vm.ctx)) {
+            Some(Instruction::ToBoolInt)
+        } else if cls.is(vm.ctx.types.none_type) {
+            Some(Instruction::ToBoolNone)
+        } else if cls.is(PyList::class(&vm.ctx)) {
+            Some(Instruction::ToBoolList)
+        } else if cls.is(PyStr::class(&vm.ctx)) {
+            Some(Instruction::ToBoolStr)
+        } else if cls.slots.flags.has_feature(PyTypeFlags::HEAPTYPE)
+            && cls.slots.as_number.boolean.load().is_none()
+            && cls.slots.as_mapping.length.load().is_none()
+            && cls.slots.as_sequence.length.load().is_none()
+        {
+            // Cache type version for ToBoolAlwaysTrue guard
+            let mut type_version = cls.tp_version_tag.load(Acquire);
+            if type_version == 0 {
+                type_version = cls.assign_version_tag();
+            }
+            if type_version != 0 {
+                unsafe {
+                    self.code
+                        .instructions
+                        .write_cache_u32(cache_base + 1, type_version);
+                }
+                self.specialize_at(instr_idx, cache_base, Instruction::ToBoolAlwaysTrue);
+            } else {
+                unsafe {
+                    self.code.instructions.write_adaptive_counter(
+                        cache_base,
+                        bytecode::adaptive_counter_backoff(
+                            self.code.instructions.read_adaptive_counter(cache_base),
+                        ),
+                    );
+                }
+            }
+            return;
+        } else {
+            None
+        };
+
+        self.commit_specialization(instr_idx, cache_base, new_op);
     }
 
-    fn execute_set_function_attribute(
+    fn specialize_for_iter(
         &mut self,
         vm: &VirtualMachine,
-        attr: bytecode::MakeFunctionFlags,
-    ) -> FrameResult {
-        // SET_FUNCTION_ATTRIBUTE sets attributes on a function
-        // Stack: [..., attr_value, func] -> [..., func]
-        // Stack order: func is at -1, attr_value is at -2
+        jump_delta: u32,
+        instr_idx: usize,
+        cache_base: usize,
+    ) {
+        if !matches!(
+            self.code.instructions.read_op(instr_idx),
+            Instruction::ForIter { .. }
+        ) {
+            return;
+        }
+        let iter = self.top_value();
+
+        let new_op = if iter.downcast_ref_if_exact::<PyRangeIterator>(vm).is_some() {
+            Some(Instruction::ForIterRange)
+        } else if iter.downcast_ref_if_exact::<PyListIterator>(vm).is_some() {
+            Some(Instruction::ForIterList)
+        } else if iter.downcast_ref_if_exact::<PyTupleIterator>(vm).is_some() {
+            Some(Instruction::ForIterTuple)
+        } else if iter.downcast_ref_if_exact::<PyGenerator>(vm).is_some()
+            && jump_delta <= i16::MAX as u32
+            && self.for_iter_has_end_for_shape(instr_idx, jump_delta)
+            && !self.specialization_eval_frame_active(vm)
+        {
+            Some(Instruction::ForIterGen)
+        } else {
+            None
+        };
 
-        let func = self.pop_value_opt();
-        let attr_value = expect_unchecked(self.replace_top(func), "attr_value must not be null");
+        self.commit_specialization(instr_idx, cache_base, new_op);
+    }
 
-        let func = self.top_value();
-        // Get the function reference and call the new method
-        let func_ref = func
-            .downcast_ref::<PyFunction>()
-            .expect("SET_FUNCTION_ATTRIBUTE expects function on stack");
+    #[inline]
+    fn specialization_eval_frame_active(&self, vm: &VirtualMachine) -> bool {
+        vm.use_tracing.get()
+    }
 
-        let payload: &PyFunction = func_ref.payload();
-        // SetFunctionAttribute always follows MakeFunction, so at this point
-        // there are no other references to func. It is therefore safe to treat it as mutable.
-        unsafe {
-            let payload_ptr = payload as *const PyFunction as *mut PyFunction;
-            (*payload_ptr).set_function_attribute(attr, attr_value, vm)?;
-        };
+    #[inline]
+    fn specialization_has_datastack_space_for_func(
+        &self,
+        vm: &VirtualMachine,
+        func: &Py<PyFunction>,
+    ) -> bool {
+        self.specialization_has_datastack_space_for_func_with_extra(vm, func, 0)
+    }
 
-        Ok(None)
+    #[inline]
+    fn specialization_has_datastack_space_for_func_with_extra(
+        &self,
+        vm: &VirtualMachine,
+        func: &Py<PyFunction>,
+        extra_bytes: usize,
+    ) -> bool {
+        match func.datastack_frame_size_bytes() {
+            Some(frame_size) => frame_size
+                .checked_add(extra_bytes)
+                .is_some_and(|size| vm.datastack_has_space(size)),
+            None => extra_bytes == 0 || vm.datastack_has_space(extra_bytes),
+        }
     }
 
-    #[cfg_attr(feature = "flame-it", flame("Frame"))]
-    fn execute_bin_op(&mut self, vm: &VirtualMachine, op: bytecode::BinaryOperator) -> FrameResult {
-        let b_ref = &self.pop_value();
-        let a_ref = &self.pop_value();
-        let value = match op {
-            bytecode::BinaryOperator::Subtract => vm._sub(a_ref, b_ref),
-            bytecode::BinaryOperator::Add => vm._add(a_ref, b_ref),
-            bytecode::BinaryOperator::Multiply => vm._mul(a_ref, b_ref),
-            bytecode::BinaryOperator::MatrixMultiply => vm._matmul(a_ref, b_ref),
-            bytecode::BinaryOperator::Power => vm._pow(a_ref, b_ref, vm.ctx.none.as_object()),
-            bytecode::BinaryOperator::TrueDivide => vm._truediv(a_ref, b_ref),
-            bytecode::BinaryOperator::FloorDivide => vm._floordiv(a_ref, b_ref),
-            bytecode::BinaryOperator::Remainder => vm._mod(a_ref, b_ref),
-            bytecode::BinaryOperator::Lshift => vm._lshift(a_ref, b_ref),
-            bytecode::BinaryOperator::Rshift => vm._rshift(a_ref, b_ref),
-            bytecode::BinaryOperator::Xor => vm._xor(a_ref, b_ref),
-            bytecode::BinaryOperator::Or => vm._or(a_ref, b_ref),
-            bytecode::BinaryOperator::And => vm._and(a_ref, b_ref),
-            bytecode::BinaryOperator::InplaceSubtract => vm._isub(a_ref, b_ref),
-            bytecode::BinaryOperator::InplaceAdd => vm._iadd(a_ref, b_ref),
-            bytecode::BinaryOperator::InplaceMultiply => vm._imul(a_ref, b_ref),
-            bytecode::BinaryOperator::InplaceMatrixMultiply => vm._imatmul(a_ref, b_ref),
-            bytecode::BinaryOperator::InplacePower => {
-                vm._ipow(a_ref, b_ref, vm.ctx.none.as_object())
-            }
-            bytecode::BinaryOperator::InplaceTrueDivide => vm._itruediv(a_ref, b_ref),
-            bytecode::BinaryOperator::InplaceFloorDivide => vm._ifloordiv(a_ref, b_ref),
-            bytecode::BinaryOperator::InplaceRemainder => vm._imod(a_ref, b_ref),
-            bytecode::BinaryOperator::InplaceLshift => vm._ilshift(a_ref, b_ref),
-            bytecode::BinaryOperator::InplaceRshift => vm._irshift(a_ref, b_ref),
-            bytecode::BinaryOperator::InplaceXor => vm._ixor(a_ref, b_ref),
-            bytecode::BinaryOperator::InplaceOr => vm._ior(a_ref, b_ref),
-            bytecode::BinaryOperator::InplaceAnd => vm._iand(a_ref, b_ref),
-            bytecode::BinaryOperator::Subscr => a_ref.get_item(b_ref.as_object(), vm),
-        }?;
+    #[inline]
+    fn specialization_call_recursion_guard(&self, vm: &VirtualMachine) -> bool {
+        self.specialization_call_recursion_guard_with_extra_frames(vm, 0)
+    }
 
-        self.push_value(value);
-        Ok(None)
+    #[inline]
+    fn specialization_call_recursion_guard_with_extra_frames(
+        &self,
+        vm: &VirtualMachine,
+        extra_frames: usize,
+    ) -> bool {
+        vm.current_recursion_depth()
+            .saturating_add(1)
+            .saturating_add(extra_frames)
+            >= vm.recursion_limit.get()
     }
 
-    #[cold]
-    fn setup_annotations(&mut self, vm: &VirtualMachine) -> FrameResult {
-        let __annotations__ = identifier!(vm, __annotations__);
-        // Try using locals as dict first, if not, fallback to generic method.
-        let has_annotations = match self
-            .locals
-            .clone()
-            .into_object()
-            .downcast_exact::<PyDict>(vm)
-        {
-            Ok(d) => d.contains_key(__annotations__, vm),
-            Err(o) => {
-                let needle = __annotations__.as_object();
-                self._in(vm, needle, &o)?
+    #[inline]
+    fn for_iter_has_end_for_shape(&self, instr_idx: usize, jump_delta: u32) -> bool {
+        let target_idx = instr_idx
+            + 1
+            + Instruction::ForIter {
+                delta: Arg::marker(),
+            }
+            .cache_entries()
+            + jump_delta as usize;
+        self.code.instructions.get(target_idx).is_some_and(|unit| {
+            matches!(
+                unit.op,
+                Instruction::EndFor | Instruction::InstrumentedEndFor
+            )
+        })
+    }
+
+    /// Handle iterator exhaustion in specialized FOR_ITER handlers.
+    /// Skips END_FOR if present at target and jumps.
+    fn for_iter_jump_on_exhausted(&mut self, target: bytecode::Label) {
+        let target_idx = target.as_usize();
+        let jump_target = if let Some(unit) = self.code.instructions.get(target_idx) {
+            if matches!(
+                unit.op,
+                bytecode::Instruction::EndFor | bytecode::Instruction::InstrumentedEndFor
+            ) {
+                bytecode::Label::from_u32(target.as_u32() + 1)
+            } else {
+                target
             }
+        } else {
+            target
         };
-        if !has_annotations {
-            self.locals
-                .as_object()
-                .set_item(__annotations__, vm.ctx.new_dict().into(), vm)?;
-        }
-        Ok(None)
+        self.jump(jump_target);
     }
 
-    fn unpack_sequence(&mut self, size: u32, vm: &VirtualMachine) -> FrameResult {
-        let value = self.pop_value();
-        let elements: Vec<_> = value.try_to_value(vm).map_err(|e| {
-            if e.class().is(vm.ctx.exceptions.type_error) {
-                vm.new_type_error(format!(
-                    "cannot unpack non-iterable {} object",
-                    value.class().name()
-                ))
-            } else {
-                e
+    fn specialize_load_global(
+        &mut self,
+        vm: &VirtualMachine,
+        oparg: u32,
+        instr_idx: usize,
+        cache_base: usize,
+    ) {
+        if !matches!(
+            self.code.instructions.read_op(instr_idx),
+            Instruction::LoadGlobal { .. }
+        ) {
+            return;
+        }
+        let name = self.code.names[(oparg >> 1) as usize];
+        let Ok(globals_version) = u16::try_from(self.globals.version()) else {
+            unsafe {
+                self.code.instructions.write_adaptive_counter(
+                    cache_base,
+                    bytecode::adaptive_counter_backoff(
+                        self.code.instructions.read_adaptive_counter(cache_base),
+                    ),
+                );
             }
-        })?;
-        let msg = match elements.len().cmp(&(size as usize)) {
-            core::cmp::Ordering::Equal => {
-                // 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 => {
-                format!("too many values to unpack (expected {size})")
-            }
-            core::cmp::Ordering::Less => format!(
-                "not enough values to unpack (expected {}, got {})",
-                size,
-                elements.len()
-            ),
+            return;
         };
-        Err(vm.new_value_error(msg))
+
+        if let Ok(Some(globals_hint)) = self.globals.hint_for_key(name, vm) {
+            unsafe {
+                self.code
+                    .instructions
+                    .write_cache_u16(cache_base + 1, globals_version);
+                self.code.instructions.write_cache_u16(cache_base + 2, 0);
+                self.code
+                    .instructions
+                    .write_cache_u16(cache_base + 3, globals_hint);
+            }
+            self.specialize_at(instr_idx, cache_base, Instruction::LoadGlobalModule);
+            return;
+        }
+
+        if let Some(builtins_dict) = self.builtins.downcast_ref_if_exact::<PyDict>(vm)
+            && let Ok(Some(builtins_hint)) = builtins_dict.hint_for_key(name, vm)
+            && let Ok(builtins_version) = u16::try_from(builtins_dict.version())
+        {
+            unsafe {
+                self.code
+                    .instructions
+                    .write_cache_u16(cache_base + 1, globals_version);
+                self.code
+                    .instructions
+                    .write_cache_u16(cache_base + 2, builtins_version);
+                self.code
+                    .instructions
+                    .write_cache_u16(cache_base + 3, builtins_hint);
+            }
+            self.specialize_at(instr_idx, cache_base, Instruction::LoadGlobalBuiltin);
+            return;
+        }
+
+        unsafe {
+            self.code.instructions.write_adaptive_counter(
+                cache_base,
+                bytecode::adaptive_counter_backoff(
+                    self.code.instructions.read_adaptive_counter(cache_base),
+                ),
+            );
+        }
     }
 
-    fn convert_value(
+    fn specialize_store_subscr(
         &mut self,
-        conversion: bytecode::ConvertValueOparg,
         vm: &VirtualMachine,
-    ) -> FrameResult {
-        use bytecode::ConvertValueOparg;
-        let value = self.pop_value();
-        let value = match conversion {
-            ConvertValueOparg::Str => value.str(vm)?.into(),
-            ConvertValueOparg::Repr => value.repr(vm)?.into(),
-            ConvertValueOparg::Ascii => vm.ctx.new_str(builtins::ascii(value, vm)?).into(),
-            ConvertValueOparg::None => value,
+        instr_idx: usize,
+        cache_base: usize,
+    ) {
+        if !matches!(
+            self.code.instructions.read_op(instr_idx),
+            Instruction::StoreSubscr
+        ) {
+            return;
+        }
+        // Stack: [value, obj, idx] — obj is TOS-1
+        let obj = self.nth_value(1);
+        let idx = self.top_value();
+
+        let new_op = if let (Some(list), Some(int_idx)) = (
+            obj.downcast_ref_if_exact::<PyList>(vm),
+            idx.downcast_ref_if_exact::<PyInt>(vm),
+        ) {
+            let list_len = list.borrow_vec().len();
+            if specialization_nonnegative_compact_index(int_idx, vm).is_some_and(|i| i < list_len) {
+                Some(Instruction::StoreSubscrListInt)
+            } else {
+                None
+            }
+        } else if obj.downcast_ref_if_exact::<PyDict>(vm).is_some() {
+            Some(Instruction::StoreSubscrDict)
+        } else {
+            None
         };
 
-        self.push_value(value);
-        Ok(None)
+        self.commit_specialization(instr_idx, cache_base, new_op);
     }
 
-    fn _in(&self, vm: &VirtualMachine, needle: &PyObject, haystack: &PyObject) -> PyResult<bool> {
-        let found = vm._contains(haystack, needle)?;
-        Ok(found)
+    fn specialize_contains_op(&mut self, vm: &VirtualMachine, instr_idx: usize, cache_base: usize) {
+        if !matches!(
+            self.code.instructions.read_op(instr_idx),
+            Instruction::ContainsOp { .. }
+        ) {
+            return;
+        }
+        let haystack = self.top_value(); // b = TOS = haystack
+        let new_op = if haystack.downcast_ref_if_exact::<PyDict>(vm).is_some() {
+            Some(Instruction::ContainsOpDict)
+        } else if haystack.downcast_ref_if_exact::<PySet>(vm).is_some()
+            || haystack.downcast_ref_if_exact::<PyFrozenSet>(vm).is_some()
+        {
+            Some(Instruction::ContainsOpSet)
+        } else {
+            None
+        };
+
+        self.commit_specialization(instr_idx, cache_base, new_op);
     }
 
-    #[inline(always)]
-    fn _not_in(
-        &self,
+    fn specialize_unpack_sequence(
+        &mut self,
         vm: &VirtualMachine,
-        needle: &PyObject,
-        haystack: &PyObject,
-    ) -> PyResult<bool> {
-        Ok(!self._in(vm, needle, haystack)?)
+        expected_count: u32,
+        instr_idx: usize,
+        cache_base: usize,
+    ) {
+        if !matches!(
+            self.code.instructions.read_op(instr_idx),
+            Instruction::UnpackSequence { .. }
+        ) {
+            return;
+        }
+        let obj = self.top_value();
+        let new_op = if let Some(tuple) = obj.downcast_ref_if_exact::<PyTuple>(vm) {
+            if tuple.len() != expected_count as usize {
+                None
+            } else if expected_count == 2 {
+                Some(Instruction::UnpackSequenceTwoTuple)
+            } else {
+                Some(Instruction::UnpackSequenceTuple)
+            }
+        } else if let Some(list) = obj.downcast_ref_if_exact::<PyList>(vm) {
+            if list.borrow_vec().len() == expected_count as usize {
+                Some(Instruction::UnpackSequenceList)
+            } else {
+                None
+            }
+        } else {
+            None
+        };
+
+        self.commit_specialization(instr_idx, cache_base, new_op);
     }
 
-    #[cfg_attr(feature = "flame-it", flame("Frame"))]
-    fn execute_compare(
+    fn specialize_store_attr(
         &mut self,
         vm: &VirtualMachine,
-        op: bytecode::ComparisonOperator,
-    ) -> FrameResult {
-        let b = self.pop_value();
-        let a = self.pop_value();
-        let value = a.rich_compare(b, op.into(), vm)?;
-        self.push_value(value);
-        Ok(None)
-    }
+        attr_idx: bytecode::NameIdx,
+        instr_idx: usize,
+        cache_base: usize,
+    ) {
+        if !matches!(
+            self.code.instructions.read_op(instr_idx),
+            Instruction::StoreAttr { .. }
+        ) {
+            return;
+        }
+        // TOS = owner (the object being assigned to)
+        let owner = self.top_value();
+        let cls = owner.class();
+
+        // Only specialize if setattr is the default (generic_setattr)
+        let is_default_setattr = cls
+            .slots
+            .setattro
+            .load()
+            .is_some_and(|f| f as usize == PyBaseObject::slot_setattro as *const () as usize);
+        if !is_default_setattr {
+            unsafe {
+                self.code.instructions.write_adaptive_counter(
+                    cache_base,
+                    bytecode::adaptive_counter_backoff(
+                        self.code.instructions.read_adaptive_counter(cache_base),
+                    ),
+                );
+            }
+            return;
+        }
 
-    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();
+        // Get or assign type version
+        let mut type_version = cls.tp_version_tag.load(Acquire);
+        if type_version == 0 {
+            type_version = cls.assign_version_tag();
+        }
+        if type_version == 0 {
+            unsafe {
+                self.code.instructions.write_adaptive_counter(
+                    cache_base,
+                    bytecode::adaptive_counter_backoff(
+                        self.code.instructions.read_adaptive_counter(cache_base),
+                    ),
+                );
+            }
+            return;
+        }
 
-        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);
+        // Check for data descriptor
+        let attr_name = self.code.names[attr_idx as usize];
+        let cls_attr = cls.get_attr(attr_name);
+        let has_data_descr = cls_attr.as_ref().is_some_and(|descr| {
+            let descr_cls = descr.class();
+            descr_cls.slots.descr_get.load().is_some() && descr_cls.slots.descr_set.load().is_some()
+        });
+
+        if has_data_descr {
+            // Check for member descriptor (slot access)
+            if let Some(ref descr) = cls_attr
+                && let Some(member_descr) = descr.downcast_ref::<PyMemberDescriptor>()
+                && let MemberGetter::Offset(offset) = member_descr.member.getter
+            {
+                unsafe {
+                    self.code
+                        .instructions
+                        .write_cache_u32(cache_base + 1, type_version);
+                    self.code
+                        .instructions
+                        .write_cache_u16(cache_base + 3, offset as u16);
                 }
-                PyMethod::Attribute(val) => {
-                    self.push_value(val);
-                    self.push_null();
+                self.specialize_at(instr_idx, cache_base, Instruction::StoreAttrSlot);
+            } else {
+                unsafe {
+                    self.code.instructions.write_adaptive_counter(
+                        cache_base,
+                        bytecode::adaptive_counter_backoff(
+                            self.code.instructions.read_adaptive_counter(cache_base),
+                        ),
+                    );
                 }
             }
+        } else if let Some(dict) = owner.dict() {
+            let use_hint = match dict.get_item_opt(attr_name, vm) {
+                Ok(Some(_)) => true,
+                Ok(None) => false,
+                Err(_) => {
+                    unsafe {
+                        self.code.instructions.write_adaptive_counter(
+                            cache_base,
+                            bytecode::adaptive_counter_backoff(
+                                self.code.instructions.read_adaptive_counter(cache_base),
+                            ),
+                        );
+                    }
+                    return;
+                }
+            };
+            unsafe {
+                self.code
+                    .instructions
+                    .write_cache_u32(cache_base + 1, type_version);
+            }
+            self.specialize_at(
+                instr_idx,
+                cache_base,
+                if use_hint {
+                    Instruction::StoreAttrWithHint
+                } else {
+                    Instruction::StoreAttrInstanceValue
+                },
+            );
         } else {
-            // Regular attribute access
-            let obj = parent.get_attr(attr_name, vm)?;
-            self.push_value(obj);
+            unsafe {
+                self.code.instructions.write_adaptive_counter(
+                    cache_base,
+                    bytecode::adaptive_counter_backoff(
+                        self.code.instructions.read_adaptive_counter(cache_base),
+                    ),
+                );
+            }
         }
-        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];
+    fn load_super_attr(&mut self, vm: &VirtualMachine, oparg: LoadSuperAttr) -> FrameResult {
+        let attr_name = self.code.names[oparg.name_idx() as usize];
 
         // Stack layout (bottom to top): [super, class, self]
         // Pop in LIFO order: self, class, super
@@ -2798,13 +9259,13 @@ impl ExecutingFrame<'_> {
 
         // 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 {
+        let super_obj = if oparg.has_class() {
             global_super.call((class.clone(), self_obj.clone()), vm)?
         } else {
             global_super.call((), vm)?
         };
 
-        if load_method {
+        if oparg.is_load_method() {
             // Method load: push [method, self_or_null]
             let method = PyMethod::get(super_obj, attr_name, vm)?;
             match method {
@@ -2843,43 +9304,75 @@ impl ExecutingFrame<'_> {
     // Block stack functions removed - exception table handles all exception/cleanup
 
     #[inline]
-    #[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) {
+    #[track_caller]
+    fn push_stackref_opt(&mut self, obj: Option<PyStackRef>) {
+        match self.localsplus.stack_try_push(obj) {
             Ok(()) => {}
             Err(_e) => self.fatal("tried to push value onto stack but overflowed max_stackdepth"),
         }
     }
 
+    #[inline]
+    #[track_caller] // not a real track_caller but push_value is less useful for debugging
+    fn push_value_opt(&mut self, obj: Option<PyObjectRef>) {
+        self.push_stackref_opt(obj.map(PyStackRef::new_owned));
+    }
+
     #[inline]
     #[track_caller]
     fn push_value(&mut self, obj: PyObjectRef) {
-        self.push_value_opt(Some(obj));
+        self.push_stackref_opt(Some(PyStackRef::new_owned(obj)));
+    }
+
+    /// Push a borrowed reference onto the stack (no refcount increment).
+    ///
+    /// # Safety
+    /// The object must remain alive until the borrowed ref is consumed.
+    /// The compiler guarantees consumption within the same basic block.
+    #[inline]
+    #[track_caller]
+    #[allow(dead_code)]
+    unsafe fn push_borrowed(&mut self, obj: &PyObject) {
+        self.push_stackref_opt(Some(unsafe { PyStackRef::new_borrowed(obj) }));
     }
 
     #[inline]
     fn push_null(&mut self) {
-        self.push_value_opt(None);
+        self.push_stackref_opt(None);
     }
 
-    /// Pop a value from the stack, returning None if the stack slot is NULL
+    /// Pop a raw stackref 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(slot) => slot, // slot is Option<PyObjectRef>
-            None => self.fatal("tried to pop from empty stack"),
+    fn pop_stackref_opt(&mut self) -> Option<PyStackRef> {
+        if self.localsplus.stack_is_empty() {
+            self.fatal("tried to pop from empty stack");
         }
+        self.localsplus.stack_pop()
     }
 
+    /// Pop a raw stackref from the stack. Panics if NULL.
     #[inline]
     #[track_caller]
-    fn pop_value(&mut self) -> PyObjectRef {
+    fn pop_stackref(&mut self) -> PyStackRef {
         expect_unchecked(
-            self.pop_value_opt(),
-            "pop value but null found. This is a compiler bug.",
+            self.pop_stackref_opt(),
+            "pop stackref but null found. This is a compiler bug.",
         )
     }
 
+    /// Pop a value from the stack, returning None if the stack slot is NULL.
+    /// Automatically promotes borrowed refs to owned.
+    #[inline]
+    fn pop_value_opt(&mut self) -> Option<PyObjectRef> {
+        self.pop_stackref_opt().map(|sr| sr.to_pyobj())
+    }
+
+    #[inline]
+    #[track_caller]
+    fn pop_value(&mut self) -> PyObjectRef {
+        self.pop_stackref().to_pyobj()
+    }
+
     fn call_intrinsic_1(
         &mut self,
         func: bytecode::IntrinsicFunction1,
@@ -2907,19 +9400,19 @@ impl ExecutingFrame<'_> {
             }
             bytecode::IntrinsicFunction1::TypeVar => {
                 let type_var: PyObjectRef =
-                    typing::TypeVar::new(vm, arg.clone(), vm.ctx.none(), vm.ctx.none())
+                    _typing::TypeVar::new(vm, arg.clone(), vm.ctx.none(), vm.ctx.none())
                         .into_ref(&vm.ctx)
                         .into();
                 Ok(type_var)
             }
             bytecode::IntrinsicFunction1::ParamSpec => {
-                let param_spec: PyObjectRef = typing::ParamSpec::new(arg.clone(), vm)
+                let param_spec: PyObjectRef = _typing::ParamSpec::new(arg.clone(), vm)
                     .into_ref(&vm.ctx)
                     .into();
                 Ok(param_spec)
             }
             bytecode::IntrinsicFunction1::TypeVarTuple => {
-                let type_var_tuple: PyObjectRef = typing::TypeVarTuple::new(arg.clone(), vm)
+                let type_var_tuple: PyObjectRef = _typing::TypeVarTuple::new(arg.clone(), vm)
                     .into_ref(&vm.ctx)
                     .into();
                 Ok(type_var_tuple)
@@ -2939,7 +9432,7 @@ impl ExecutingFrame<'_> {
 
                 let name = tuple.as_slice()[0].clone();
                 let type_params_obj = tuple.as_slice()[1].clone();
-                let value = tuple.as_slice()[2].clone();
+                let compute_value = tuple.as_slice()[2].clone();
 
                 let type_params: PyTupleRef = if vm.is_none(&type_params_obj) {
                     vm.ctx.empty_tuple.clone()
@@ -2949,10 +9442,10 @@ impl ExecutingFrame<'_> {
                         .map_err(|_| vm.new_type_error("Type params must be a tuple."))?
                 };
 
-                let name = name.downcast::<crate::builtins::PyStr>().map_err(|_| {
-                    vm.new_type_error("TypeAliasType name must be a string".to_owned())
-                })?;
-                let type_alias = typing::TypeAliasType::new(name, type_params, value);
+                let name = name
+                    .downcast::<crate::builtins::PyStr>()
+                    .map_err(|_| vm.new_type_error("TypeAliasType name must be a string"))?;
+                let type_alias = _typing::TypeAliasType::new(name, type_params, compute_value);
                 Ok(type_alias.into_ref(&vm.ctx).into())
             }
             bytecode::IntrinsicFunction1::ListToTuple => {
@@ -2963,20 +9456,25 @@ impl ExecutingFrame<'_> {
                 Ok(vm.ctx.new_tuple(list.borrow_vec().to_vec()).into())
             }
             bytecode::IntrinsicFunction1::StopIterationError => {
-                // Convert StopIteration to RuntimeError
-                // Used to ensure async generators don't raise StopIteration directly
-                // _PyGen_FetchStopIterationValue
-                // Use fast_isinstance to handle subclasses of StopIteration
+                // Convert StopIteration to RuntimeError (PEP 479)
+                // Returns the exception object; RERAISE will re-raise it
                 if arg.fast_isinstance(vm.ctx.exceptions.stop_iteration) {
-                    Err(vm.new_runtime_error("coroutine raised StopIteration"))
+                    let flags = &self.code.flags;
+                    let msg = if flags
+                        .contains(bytecode::CodeFlags::COROUTINE | bytecode::CodeFlags::GENERATOR)
+                    {
+                        "async generator raised StopIteration"
+                    } else if flags.contains(bytecode::CodeFlags::COROUTINE) {
+                        "coroutine raised StopIteration"
+                    } else {
+                        "generator raised StopIteration"
+                    };
+                    let err = vm.new_runtime_error(msg);
+                    err.set___cause__(arg.downcast().ok());
+                    Ok(err.into())
                 } else {
-                    // If not StopIteration, just re-raise the original exception
-                    Err(arg.downcast().unwrap_or_else(|obj| {
-                        vm.new_runtime_error(format!(
-                            "unexpected exception type: {:?}",
-                            obj.class()
-                        ))
-                    }))
+                    // Not StopIteration, pass through for RERAISE
+                    Ok(arg)
                 }
             }
             bytecode::IntrinsicFunction1::AsyncGenWrap => {
@@ -2998,7 +9496,7 @@ impl ExecutingFrame<'_> {
     ) -> PyResult {
         match func {
             bytecode::IntrinsicFunction2::SetTypeparamDefault => {
-                crate::stdlib::typing::set_typeparam_default(arg1, arg2, vm)
+                crate::stdlib::_typing::set_typeparam_default(arg1, arg2, vm)
             }
             bytecode::IntrinsicFunction2::SetFunctionTypeParams => {
                 // arg1 is the function, arg2 is the type params tuple
@@ -3008,14 +9506,14 @@ impl ExecutingFrame<'_> {
             }
             bytecode::IntrinsicFunction2::TypeVarWithBound => {
                 let type_var: PyObjectRef =
-                    typing::TypeVar::new(vm, arg1.clone(), arg2, vm.ctx.none())
+                    _typing::TypeVar::new(vm, arg1.clone(), arg2, vm.ctx.none())
                         .into_ref(&vm.ctx)
                         .into();
                 Ok(type_var)
             }
             bytecode::IntrinsicFunction2::TypeVarWithConstraint => {
                 let type_var: PyObjectRef =
-                    typing::TypeVar::new(vm, arg1.clone(), vm.ctx.none(), arg2)
+                    _typing::TypeVar::new(vm, arg1.clone(), vm.ctx.none(), arg2)
                         .into_ref(&vm.ctx)
                         .into();
                 Ok(type_var)
@@ -3031,7 +9529,7 @@ impl ExecutingFrame<'_> {
 
     /// 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();
+        let stack_len = self.localsplus.stack_len();
         if count > stack_len {
             let instr = self.code.instructions.get(self.lasti() as usize);
             let op_name = instr
@@ -3044,38 +9542,39 @@ impl ExecutingFrame<'_> {
                 self.lasti(),
                 self.code.obj_name,
                 op_name,
-                self.code.source_path
+                self.code.source_path()
             );
         }
-        self.state.stack.drain(stack_len - count..).map(|obj| {
-            expect_unchecked(obj, "pop_multiple but null found. This is a compiler bug.")
+        self.localsplus.stack_drain(stack_len - count).map(|obj| {
+            expect_unchecked(obj, "pop_multiple but null found. This is a compiler bug.").to_pyobj()
         })
     }
 
     #[inline]
-    fn replace_top(&mut self, mut top: Option<PyObjectRef>) -> Option<PyObjectRef> {
-        let last = self.state.stack.last_mut().unwrap();
-        core::mem::swap(last, &mut top);
-        top
+    fn replace_top(&mut self, top: Option<PyObjectRef>) -> Option<PyObjectRef> {
+        let mut slot = top.map(PyStackRef::new_owned);
+        let last = self.localsplus.stack_last_mut().unwrap();
+        core::mem::swap(last, &mut slot);
+        slot.map(|sr| sr.to_pyobj())
     }
 
     #[inline]
     #[track_caller]
     fn top_value(&self) -> &PyObject {
-        match &*self.state.stack {
-            [.., 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"),
+        match self.localsplus.stack_last() {
+            Some(Some(last)) => last.as_object(),
+            Some(None) => self.fatal("tried to get top of stack but got NULL"),
+            None => self.fatal("tried to get top of stack but stack is empty"),
         }
     }
 
     #[inline]
     #[track_caller]
     fn nth_value(&self, depth: u32) -> &PyObject {
-        let stack = &self.state.stack;
-        match &stack[stack.len() - depth as usize - 1] {
-            Some(obj) => obj,
-            None => unsafe { std::hint::unreachable_unchecked() },
+        let idx = self.localsplus.stack_len() - depth as usize - 1;
+        match self.localsplus.stack_index(idx) {
+            Some(obj) => obj.as_object(),
+            None => unsafe { core::hint::unreachable_unchecked() },
         }
     }
 
@@ -3090,32 +9589,110 @@ 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, 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
-        });
+        // SAFETY: Debug is best-effort; concurrent mutation is unlikely
+        // and would only affect debug output.
+        let iframe = unsafe { &*self.iframe.get() };
+        let stack_str =
+            iframe
+                .localsplus
+                .stack_as_slice()
+                .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
+                });
         // TODO: fix this up
-        let locals = self.locals.clone();
         write!(
             f,
-            "Frame Object {{ \n Stack:{}\n Locals:{:?}\n}}",
+            "Frame Object {{ \n Stack:{}\n Locals initialized:{}\n}}",
             stack_str,
-            locals.into_object()
+            self.locals.get().is_some()
         )
     }
 }
 
+/// _PyEval_SpecialMethodCanSuggest
+fn special_method_can_suggest(
+    obj: &PyObjectRef,
+    oparg: SpecialMethod,
+    vm: &VirtualMachine,
+) -> PyResult<bool> {
+    Ok(match oparg {
+        SpecialMethod::Enter | SpecialMethod::Exit => {
+            vm.get_special_method(obj, get_special_method_name(SpecialMethod::AEnter, vm))?
+                .is_some()
+                && vm
+                    .get_special_method(obj, get_special_method_name(SpecialMethod::AExit, vm))?
+                    .is_some()
+        }
+        SpecialMethod::AEnter | SpecialMethod::AExit => {
+            vm.get_special_method(obj, get_special_method_name(SpecialMethod::Enter, vm))?
+                .is_some()
+                && vm
+                    .get_special_method(obj, get_special_method_name(SpecialMethod::Exit, vm))?
+                    .is_some()
+        }
+    })
+}
+
+fn get_special_method_name(oparg: SpecialMethod, vm: &VirtualMachine) -> &'static PyStrInterned {
+    match oparg {
+        SpecialMethod::Enter => identifier!(vm, __enter__),
+        SpecialMethod::Exit => identifier!(vm, __exit__),
+        SpecialMethod::AEnter => identifier!(vm, __aenter__),
+        SpecialMethod::AExit => identifier!(vm, __aexit__),
+    }
+}
+
+/// _Py_SpecialMethod _Py_SpecialMethods
+fn get_special_method_error_msg(
+    oparg: SpecialMethod,
+    class_name: &str,
+    can_suggest: bool,
+) -> String {
+    if can_suggest {
+        match oparg {
+            SpecialMethod::Enter => format!(
+                "'{class_name}' object does not support the context manager protocol (missed __enter__ method) but it supports the asynchronous context manager protocol. Did you mean to use 'async with'?"
+            ),
+            SpecialMethod::Exit => format!(
+                "'{class_name}' object does not support the context manager protocol (missed __exit__ method) but it supports the asynchronous context manager protocol. Did you mean to use 'async with'?"
+            ),
+            SpecialMethod::AEnter => format!(
+                "'{class_name}' object does not support the asynchronous context manager protocol (missed __aenter__ method) but it supports the context manager protocol. Did you mean to use 'with'?"
+            ),
+            SpecialMethod::AExit => format!(
+                "'{class_name}' object does not support the asynchronous context manager protocol (missed __aexit__ method) but it supports the context manager protocol. Did you mean to use 'with'?"
+            ),
+        }
+    } else {
+        match oparg {
+            SpecialMethod::Enter => format!(
+                "'{class_name}' object does not support the context manager protocol (missed __enter__ method)"
+            ),
+            SpecialMethod::Exit => format!(
+                "'{class_name}' object does not support the context manager protocol (missed __exit__ method)"
+            ),
+            SpecialMethod::AEnter => format!(
+                "'{class_name}' object does not support the asynchronous context manager protocol (missed __aenter__ method)"
+            ),
+            SpecialMethod::AExit => format!(
+                "'{class_name}' object does not support the asynchronous context manager protocol (missed __aexit__ method)"
+            ),
+        }
+    }
+}
+
 fn is_module_initializing(module: &PyObject, vm: &VirtualMachine) -> bool {
     let Ok(spec) = module.get_attr(&vm.ctx.new_str("__spec__"), vm) else {
         return false;
@@ -3129,7 +9706,7 @@ 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 {
+fn expect_unchecked<T: fmt::Debug>(optional: Option<T>, err_msg: &'static str) -> T {
     if cfg!(debug_assertions) {
         optional.expect(err_msg)
     } else {
diff --git a/crates/vm/src/function/argument.rs b/crates/vm/src/function/argument.rs
index a4877cf4042..b39ee6f6bca 100644
--- a/crates/vm/src/function/argument.rs
+++ b/crates/vm/src/function/argument.rs
@@ -135,6 +135,69 @@ impl FuncArgs {
         }
     }
 
+    /// Create FuncArgs from a vectorcall-style argument slice (PEP 590).
+    /// `args[..nargs]` are positional, and if `kwnames` is provided,
+    /// the last `kwnames.len()` entries in `args[nargs..]` are keyword values.
+    /// Convert borrowed vectorcall args to FuncArgs (clones all values).
+    pub fn from_vectorcall(
+        args: &[PyObjectRef],
+        nargs: usize,
+        kwnames: Option<&[PyObjectRef]>,
+    ) -> Self {
+        debug_assert!(nargs <= args.len());
+        debug_assert!(kwnames.is_none_or(|kw| nargs + kw.len() <= args.len()));
+        let pos_args = args[..nargs].to_vec();
+        let kwargs = if let Some(names) = kwnames {
+            names
+                .iter()
+                .zip(&args[nargs..nargs + names.len()])
+                .map(|(name, val)| {
+                    let key = name
+                        .downcast_ref::<crate::builtins::PyUtf8Str>()
+                        .expect("kwnames must be strings")
+                        .as_str()
+                        .to_owned();
+                    (key, val.clone())
+                })
+                .collect()
+        } else {
+            IndexMap::new()
+        };
+        Self {
+            args: pos_args,
+            kwargs,
+        }
+    }
+
+    /// Convert owned vectorcall args to FuncArgs (moves values, no clone).
+    pub fn from_vectorcall_owned(
+        mut args: Vec<PyObjectRef>,
+        nargs: usize,
+        kwnames: Option<&[PyObjectRef]>,
+    ) -> Self {
+        debug_assert!(nargs <= args.len());
+        debug_assert!(kwnames.is_none_or(|kw| nargs + kw.len() <= args.len()));
+        let kwargs = if let Some(names) = kwnames {
+            let kw_count = names.len();
+            names
+                .iter()
+                .zip(args.drain(nargs..nargs + kw_count))
+                .map(|(name, val)| {
+                    let key = name
+                        .downcast_ref::<crate::builtins::PyUtf8Str>()
+                        .expect("kwnames must be strings")
+                        .as_str()
+                        .to_owned();
+                    (key, val)
+                })
+                .collect()
+        } else {
+            IndexMap::new()
+        };
+        args.truncate(nargs);
+        Self { args, kwargs }
+    }
+
     pub fn is_empty(&self) -> bool {
         self.args.is_empty() && self.kwargs.is_empty()
     }
diff --git a/crates/vm/src/function/buffer.rs b/crates/vm/src/function/buffer.rs
index e8f835e1dac..c0dd6473bdc 100644
--- a/crates/vm/src/function/buffer.rs
+++ b/crates/vm/src/function/buffer.rs
@@ -172,7 +172,7 @@ impl TryFromObject for ArgAsciiBuffer {
     fn try_from_object(vm: &VirtualMachine, obj: PyObjectRef) -> PyResult<Self> {
         match obj.downcast::<PyStr>() {
             Ok(string) => {
-                if string.as_str().is_ascii() {
+                if string.as_wtf8().is_ascii() {
                     Ok(Self::String(string))
                 } else {
                     Err(vm.new_value_error("string argument should contain only ASCII characters"))
@@ -186,7 +186,7 @@ impl TryFromObject for ArgAsciiBuffer {
 impl ArgAsciiBuffer {
     pub fn len(&self) -> usize {
         match self {
-            Self::String(s) => s.as_str().len(),
+            Self::String(s) => s.as_wtf8().len(),
             Self::Buffer(buffer) => buffer.len(),
         }
     }
diff --git a/crates/vm/src/function/fspath.rs b/crates/vm/src/function/fspath.rs
index 7d3a0dcbbd5..732fd0ca35a 100644
--- a/crates/vm/src/function/fspath.rs
+++ b/crates/vm/src/function/fspath.rs
@@ -106,7 +106,7 @@ impl FsPath {
 
     pub fn to_path_buf(&self, vm: &VirtualMachine) -> PyResult<PathBuf> {
         let path = match self {
-            Self::Str(s) => PathBuf::from(s.as_str()),
+            Self::Str(s) => PathBuf::from(vm.fsencode(s)?.as_ref() as &OsStr),
             Self::Bytes(b) => PathBuf::from(Self::bytes_as_os_str(b, vm)?),
         };
         Ok(path)
diff --git a/crates/vm/src/function/method.rs b/crates/vm/src/function/method.rs
index 6440fd801fc..295e4d89adf 100644
--- a/crates/vm/src/function/method.rs
+++ b/crates/vm/src/function/method.rs
@@ -12,11 +12,11 @@ bitflags::bitflags! {
     // METH_XXX flags in CPython
     #[derive(Copy, Clone, Debug, PartialEq)]
     pub struct PyMethodFlags: u32 {
-        // const VARARGS = 0x0001;
-        // const KEYWORDS = 0x0002;
+        const VARARGS = 0x0001;
+        const KEYWORDS = 0x0002;
         // METH_NOARGS and METH_O must not be combined with the flags above.
-        // const NOARGS = 0x0004;
-        // const O = 0x0008;
+        const NOARGS = 0x0004;
+        const O = 0x0008;
 
         // METH_CLASS and METH_STATIC are a little different; these control
         // the construction of methods for a class.  These cannot be used for
@@ -31,7 +31,7 @@ bitflags::bitflags! {
         // const COEXIST = 0x0040;
 
         // if not Py_LIMITED_API
-        // const FASTCALL = 0x0080;
+        const FASTCALL = 0x0080;
 
         // This bit is preserved for Stackless Python
         // const STACKLESS = 0x0100;
@@ -123,6 +123,7 @@ impl PyMethodDef {
             zelf: None,
             value: self,
             module: None,
+            _method_def_owner: None,
         }
     }
 
@@ -144,6 +145,7 @@ impl PyMethodDef {
                 zelf: Some(obj),
                 value: self,
                 module: None,
+                _method_def_owner: None,
             },
             class,
         }
@@ -162,6 +164,7 @@ impl PyMethodDef {
             zelf: Some(obj),
             value: self,
             module: None,
+            _method_def_owner: None,
         };
         PyRef::new_ref(
             function,
@@ -188,7 +191,7 @@ impl PyMethodDef {
     ) -> PyRef<PyNativeMethod> {
         PyRef::new_ref(
             self.to_bound_method(obj, class),
-            ctx.types.builtin_method_type.to_owned(),
+            ctx.types.builtin_function_or_method_type.to_owned(),
             None,
         )
     }
@@ -211,7 +214,14 @@ impl PyMethodDef {
         class: &'static Py<PyType>,
     ) -> PyRef<PyNativeMethod> {
         debug_assert!(self.flags.contains(PyMethodFlags::STATIC));
-        let func = self.to_function();
+        // Set zelf to the class (m_self = type for static methods).
+        // Callable::call skips prepending when STATIC flag is set.
+        let func = PyNativeFunction {
+            zelf: Some(class.to_owned().into()),
+            value: self,
+            module: None,
+            _method_def_owner: None,
+        };
         PyNativeMethod { func, class }.into_ref(ctx)
     }
 
@@ -287,14 +297,12 @@ impl Py<HeapMethodDef> {
     }
 
     pub fn build_function(&self, vm: &VirtualMachine) -> PyRef<PyNativeFunction> {
-        let function = unsafe { self.method() }.to_function();
-        let dict = vm.ctx.new_dict();
-        dict.set_item("__method_def__", self.to_owned().into(), vm)
-            .unwrap();
+        let mut function = unsafe { self.method() }.to_function();
+        function._method_def_owner = Some(self.to_owned().into());
         PyRef::new_ref(
             function,
             vm.ctx.types.builtin_function_or_method_type.to_owned(),
-            Some(dict),
+            None,
         )
     }
 
@@ -303,14 +311,12 @@ impl Py<HeapMethodDef> {
         class: &'static Py<PyType>,
         vm: &VirtualMachine,
     ) -> PyRef<PyMethodDescriptor> {
-        let function = unsafe { self.method() }.to_method(class, &vm.ctx);
-        let dict = vm.ctx.new_dict();
-        dict.set_item("__method_def__", self.to_owned().into(), vm)
-            .unwrap();
+        let mut function = unsafe { self.method() }.to_method(class, &vm.ctx);
+        function._method_def_owner = Some(self.to_owned().into());
         PyRef::new_ref(
             function,
             vm.ctx.types.method_descriptor_type.to_owned(),
-            Some(dict),
+            None,
         )
     }
 }
diff --git a/crates/vm/src/function/mod.rs b/crates/vm/src/function/mod.rs
index e86adf5f27b..4be94e3f0be 100644
--- a/crates/vm/src/function/mod.rs
+++ b/crates/vm/src/function/mod.rs
@@ -8,6 +8,7 @@ mod getset;
 mod method;
 mod number;
 mod protocol;
+mod time;
 
 pub use argument::{
     ArgumentError, FromArgOptional, FromArgs, FuncArgs, IntoFuncArgs, KwArgs, OptionalArg,
@@ -23,6 +24,7 @@ pub(super) use getset::{IntoPyGetterFunc, IntoPySetterFunc, PyGetterFunc, PySett
 pub use method::{HeapMethodDef, PyMethodDef, PyMethodFlags};
 pub use number::{ArgIndex, ArgIntoBool, ArgIntoComplex, ArgIntoFloat, ArgPrimitiveIndex, ArgSize};
 pub use protocol::{ArgCallable, ArgIterable, ArgMapping, ArgSequence};
+pub use time::TimeoutSeconds;
 
 use crate::{PyObject, PyResult, VirtualMachine, builtins::PyStr, convert::TryFromBorrowedObject};
 use builtin::{BorrowedParam, OwnedParam, RefParam};
@@ -36,9 +38,9 @@ pub enum ArgByteOrder {
 impl<'a> TryFromBorrowedObject<'a> for ArgByteOrder {
     fn try_from_borrowed_object(vm: &VirtualMachine, obj: &'a PyObject) -> PyResult<Self> {
         obj.try_value_with(
-            |s: &PyStr| match s.as_str() {
-                "big" => Ok(Self::Big),
-                "little" => Ok(Self::Little),
+            |s: &PyStr| match s.as_bytes() {
+                b"big" => Ok(Self::Big),
+                b"little" => Ok(Self::Little),
                 _ => Err(vm.new_value_error("byteorder must be either 'little' or 'big'")),
             },
             vm,
diff --git a/crates/vm/src/function/time.rs b/crates/vm/src/function/time.rs
new file mode 100644
index 00000000000..29f14495d14
--- /dev/null
+++ b/crates/vm/src/function/time.rs
@@ -0,0 +1,34 @@
+use crate::{PyObjectRef, PyResult, TryFromObject, VirtualMachine};
+
+/// A Python timeout value that accepts both `float` and `int`.
+///
+/// `TimeoutSeconds` implements `FromArgs` so that a built-in function can accept
+/// timeout parameters given as either `float` or `int`, normalizing them to `f64`.
+#[derive(Debug, Clone, Copy, PartialEq)]
+pub struct TimeoutSeconds {
+    value: f64,
+}
+
+impl TimeoutSeconds {
+    pub const fn new(secs: f64) -> Self {
+        Self { value: secs }
+    }
+
+    #[inline]
+    pub fn to_secs_f64(self) -> f64 {
+        self.value
+    }
+}
+
+impl TryFromObject for TimeoutSeconds {
+    fn try_from_object(vm: &VirtualMachine, obj: PyObjectRef) -> PyResult<Self> {
+        let value = match super::Either::<f64, i64>::try_from_object(vm, obj)? {
+            super::Either::A(f) => f,
+            super::Either::B(i) => i as f64,
+        };
+        if value.is_nan() {
+            return Err(vm.new_value_error("Invalid value NaN (not a number)".to_owned()));
+        }
+        Ok(Self { value })
+    }
+}
diff --git a/crates/vm/src/gc_state.rs b/crates/vm/src/gc_state.rs
new file mode 100644
index 00000000000..4cadd98a9db
--- /dev/null
+++ b/crates/vm/src/gc_state.rs
@@ -0,0 +1,909 @@
+//! Garbage Collection State and Algorithm
+//!
+//! Generational garbage collection using an intrusive doubly-linked list.
+
+use crate::common::linked_list::LinkedList;
+use crate::common::lock::{PyMutex, PyRwLock};
+use crate::object::{GC_PERMANENT, GC_UNTRACKED, GcLink};
+use crate::{AsObject, PyObject, PyObjectRef};
+use core::ptr::NonNull;
+use core::sync::atomic::{AtomicBool, AtomicU32, AtomicUsize, Ordering};
+use std::collections::HashSet;
+
+#[cfg(not(target_arch = "wasm32"))]
+fn elapsed_secs(start: &std::time::Instant) -> f64 {
+    start.elapsed().as_secs_f64()
+}
+
+#[cfg(target_arch = "wasm32")]
+fn elapsed_secs(_start: &()) -> f64 {
+    0.0
+}
+
+bitflags::bitflags! {
+    /// GC debug flags (see Include/internal/pycore_gc.h)
+    #[derive(Copy, Clone, Debug, Default, PartialEq, Eq)]
+    pub struct GcDebugFlags: u32 {
+        /// Print collection statistics
+        const STATS         = 1 << 0;
+        /// Print collectable objects
+        const COLLECTABLE   = 1 << 1;
+        /// Print uncollectable objects
+        const UNCOLLECTABLE = 1 << 2;
+        /// Save all garbage in gc.garbage
+        const SAVEALL       = 1 << 5;
+        /// DEBUG_COLLECTABLE | DEBUG_UNCOLLECTABLE | DEBUG_SAVEALL
+        const LEAK = Self::COLLECTABLE.bits() | Self::UNCOLLECTABLE.bits() | Self::SAVEALL.bits();
+    }
+}
+
+/// Result from a single collection run
+#[derive(Debug, Default)]
+pub struct CollectResult {
+    pub collected: usize,
+    pub uncollectable: usize,
+    pub candidates: usize,
+    pub duration: f64,
+}
+
+/// Statistics for a single generation (gc_generation_stats)
+#[derive(Debug, Default)]
+pub struct GcStats {
+    pub collections: usize,
+    pub collected: usize,
+    pub uncollectable: usize,
+    pub candidates: usize,
+    pub duration: f64,
+}
+
+/// A single GC generation with intrusive linked list
+pub struct GcGeneration {
+    /// Number of objects in this generation
+    count: AtomicUsize,
+    /// Threshold for triggering collection
+    threshold: AtomicU32,
+    /// Collection statistics
+    stats: PyMutex<GcStats>,
+}
+
+impl GcGeneration {
+    pub const fn new(threshold: u32) -> Self {
+        Self {
+            count: AtomicUsize::new(0),
+            threshold: AtomicU32::new(threshold),
+            stats: PyMutex::new(GcStats {
+                collections: 0,
+                collected: 0,
+                uncollectable: 0,
+                candidates: 0,
+                duration: 0.0,
+            }),
+        }
+    }
+
+    pub fn count(&self) -> usize {
+        self.count.load(Ordering::SeqCst)
+    }
+
+    pub fn threshold(&self) -> u32 {
+        self.threshold.load(Ordering::SeqCst)
+    }
+
+    pub fn set_threshold(&self, value: u32) {
+        self.threshold.store(value, Ordering::SeqCst);
+    }
+
+    pub fn stats(&self) -> GcStats {
+        let guard = self.stats.lock();
+        GcStats {
+            collections: guard.collections,
+            collected: guard.collected,
+            uncollectable: guard.uncollectable,
+            candidates: guard.candidates,
+            duration: guard.duration,
+        }
+    }
+
+    pub fn update_stats(
+        &self,
+        collected: usize,
+        uncollectable: usize,
+        candidates: usize,
+        duration: f64,
+    ) {
+        let mut guard = self.stats.lock();
+        guard.collections += 1;
+        guard.collected += collected;
+        guard.uncollectable += uncollectable;
+        guard.candidates += candidates;
+        guard.duration += duration;
+    }
+
+    /// Reset the stats mutex to unlocked state after fork().
+    ///
+    /// # Safety
+    /// Must only be called after fork() in the child process when no other
+    /// threads exist.
+    #[cfg(all(unix, feature = "threading"))]
+    unsafe fn reinit_stats_after_fork(&self) {
+        unsafe { crate::common::lock::reinit_mutex_after_fork(&self.stats) };
+    }
+}
+
+/// Wrapper for NonNull<PyObject> to impl Hash/Eq for use in temporary collection sets.
+/// Only used within collect_inner, never shared across threads.
+#[derive(Clone, Copy, PartialEq, Eq, Hash)]
+struct GcPtr(NonNull<PyObject>);
+
+/// Global GC state
+pub struct GcState {
+    /// 3 generations (0 = youngest, 2 = oldest)
+    pub generations: [GcGeneration; 3],
+    /// Permanent generation (frozen objects)
+    pub permanent: GcGeneration,
+    /// GC enabled flag
+    pub enabled: AtomicBool,
+    /// Per-generation intrusive linked lists for object tracking.
+    /// Objects start in gen0, survivors are promoted to gen1, then gen2.
+    generation_lists: [PyRwLock<LinkedList<GcLink, PyObject>>; 3],
+    /// Frozen/permanent objects (excluded from normal GC)
+    permanent_list: PyRwLock<LinkedList<GcLink, PyObject>>,
+    /// Debug flags
+    pub debug: AtomicU32,
+    /// gc.garbage list (uncollectable objects with __del__)
+    pub garbage: PyMutex<Vec<PyObjectRef>>,
+    /// gc.callbacks list
+    pub callbacks: PyMutex<Vec<PyObjectRef>>,
+    /// Mutex for collection (prevents concurrent collections)
+    collecting: PyMutex<()>,
+    /// Allocation counter for gen0
+    alloc_count: AtomicUsize,
+}
+
+// SAFETY: All fields are either inherently Send/Sync (atomics, RwLock, Mutex) or protected by PyMutex.
+// LinkedList<GcLink, PyObject> is Send+Sync because GcLink's Target (PyObject) is Send+Sync.
+#[cfg(feature = "threading")]
+unsafe impl Send for GcState {}
+#[cfg(feature = "threading")]
+unsafe impl Sync for GcState {}
+
+impl Default for GcState {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl GcState {
+    pub fn new() -> Self {
+        Self {
+            generations: [
+                GcGeneration::new(2000), // young
+                GcGeneration::new(10),   // old[0]
+                GcGeneration::new(0),    // old[1]
+            ],
+            permanent: GcGeneration::new(0),
+            enabled: AtomicBool::new(true),
+            generation_lists: [
+                PyRwLock::new(LinkedList::new()),
+                PyRwLock::new(LinkedList::new()),
+                PyRwLock::new(LinkedList::new()),
+            ],
+            permanent_list: PyRwLock::new(LinkedList::new()),
+            debug: AtomicU32::new(0),
+            garbage: PyMutex::new(Vec::new()),
+            callbacks: PyMutex::new(Vec::new()),
+            collecting: PyMutex::new(()),
+            alloc_count: AtomicUsize::new(0),
+        }
+    }
+
+    /// Check if GC is enabled
+    pub fn is_enabled(&self) -> bool {
+        self.enabled.load(Ordering::SeqCst)
+    }
+
+    /// Enable GC
+    pub fn enable(&self) {
+        self.enabled.store(true, Ordering::SeqCst);
+    }
+
+    /// Disable GC
+    pub fn disable(&self) {
+        self.enabled.store(false, Ordering::SeqCst);
+    }
+
+    /// Get debug flags
+    pub fn get_debug(&self) -> GcDebugFlags {
+        GcDebugFlags::from_bits_truncate(self.debug.load(Ordering::SeqCst))
+    }
+
+    /// Set debug flags
+    pub fn set_debug(&self, flags: GcDebugFlags) {
+        self.debug.store(flags.bits(), Ordering::SeqCst);
+    }
+
+    /// Get thresholds for all generations
+    pub fn get_threshold(&self) -> (u32, u32, u32) {
+        (
+            self.generations[0].threshold(),
+            self.generations[1].threshold(),
+            self.generations[2].threshold(),
+        )
+    }
+
+    /// Set thresholds
+    pub fn set_threshold(&self, t0: u32, t1: Option<u32>, t2: Option<u32>) {
+        self.generations[0].set_threshold(t0);
+        if let Some(t1) = t1 {
+            self.generations[1].set_threshold(t1);
+        }
+        if let Some(t2) = t2 {
+            self.generations[2].set_threshold(t2);
+        }
+    }
+
+    /// Get counts for all generations
+    pub fn get_count(&self) -> (usize, usize, usize) {
+        (
+            self.generations[0].count(),
+            self.generations[1].count(),
+            self.generations[2].count(),
+        )
+    }
+
+    /// Get statistics for all generations
+    pub fn get_stats(&self) -> [GcStats; 3] {
+        [
+            self.generations[0].stats(),
+            self.generations[1].stats(),
+            self.generations[2].stats(),
+        ]
+    }
+
+    /// Track a new object (add to gen0).
+    /// O(1) — intrusive linked list push_front, no hashing.
+    ///
+    /// # Safety
+    /// obj must be a valid pointer to a PyObject
+    pub unsafe fn track_object(&self, obj: NonNull<PyObject>) {
+        let obj_ref = unsafe { obj.as_ref() };
+        obj_ref.set_gc_tracked();
+        obj_ref.set_gc_generation(0);
+
+        self.generation_lists[0].write().push_front(obj);
+        self.generations[0].count.fetch_add(1, Ordering::SeqCst);
+        self.alloc_count.fetch_add(1, Ordering::SeqCst);
+    }
+
+    /// Untrack an object (remove from GC lists).
+    /// O(1) — intrusive linked list remove by node pointer.
+    ///
+    /// # Safety
+    /// obj must be a valid pointer to a PyObject that is currently tracked.
+    /// The object's memory must still be valid (pointers are read).
+    pub unsafe fn untrack_object(&self, obj: NonNull<PyObject>) {
+        let obj_ref = unsafe { obj.as_ref() };
+
+        loop {
+            let obj_gen = obj_ref.gc_generation();
+
+            let (list_lock, count) = if obj_gen <= 2 {
+                (
+                    &self.generation_lists[obj_gen as usize]
+                        as &PyRwLock<LinkedList<GcLink, PyObject>>,
+                    &self.generations[obj_gen as usize].count,
+                )
+            } else if obj_gen == GC_PERMANENT {
+                (&self.permanent_list, &self.permanent.count)
+            } else {
+                return; // GC_UNTRACKED or unknown — already untracked
+            };
+
+            let mut list = list_lock.write();
+            // Re-check generation under lock (may have changed due to promotion)
+            if obj_ref.gc_generation() != obj_gen {
+                drop(list);
+                continue; // Retry with the updated generation
+            }
+            if unsafe { list.remove(obj) }.is_some() {
+                count.fetch_sub(1, Ordering::SeqCst);
+                obj_ref.clear_gc_tracked();
+                obj_ref.set_gc_generation(GC_UNTRACKED);
+            } else {
+                // Object claims to be in this generation but wasn't found in the list.
+                // This indicates a bug: the object was already removed from the list
+                // without updating gc_generation, or was never inserted.
+                eprintln!(
+                    "GC WARNING: untrack_object failed to remove obj={obj:p} from gen={obj_gen}, \
+                     tracked={}, gc_gen={}",
+                    obj_ref.is_gc_tracked(),
+                    obj_ref.gc_generation()
+                );
+            }
+            return;
+        }
+    }
+
+    /// Get tracked objects (for gc.get_objects)
+    /// If generation is None, returns all tracked objects.
+    /// If generation is Some(n), returns objects in generation n only.
+    pub fn get_objects(&self, generation: Option<i32>) -> Vec<PyObjectRef> {
+        fn collect_from_list(
+            list: &LinkedList<GcLink, PyObject>,
+        ) -> impl Iterator<Item = PyObjectRef> + '_ {
+            list.iter().filter_map(|obj| obj.try_to_owned())
+        }
+
+        match generation {
+            None => {
+                // Return all tracked objects from all generations + permanent
+                let mut result = Vec::new();
+                for gen_list in &self.generation_lists {
+                    result.extend(collect_from_list(&gen_list.read()));
+                }
+                result.extend(collect_from_list(&self.permanent_list.read()));
+                result
+            }
+            Some(g) if (0..=2).contains(&g) => {
+                let guard = self.generation_lists[g as usize].read();
+                collect_from_list(&guard).collect()
+            }
+            _ => Vec::new(),
+        }
+    }
+
+    /// Check if automatic GC should run and run it if needed.
+    /// Called after object allocation.
+    /// Returns true if GC was run, false otherwise.
+    pub fn maybe_collect(&self) -> bool {
+        if !self.is_enabled() {
+            return false;
+        }
+
+        // Check gen0 threshold
+        let count0 = self.generations[0].count.load(Ordering::SeqCst) as u32;
+        let threshold0 = self.generations[0].threshold();
+        if threshold0 > 0 && count0 >= threshold0 {
+            self.collect(0);
+            return true;
+        }
+
+        false
+    }
+
+    /// Perform garbage collection on the given generation
+    pub fn collect(&self, generation: usize) -> CollectResult {
+        self.collect_inner(generation, false)
+    }
+
+    /// Force collection even if GC is disabled (for manual gc.collect() calls)
+    pub fn collect_force(&self, generation: usize) -> CollectResult {
+        self.collect_inner(generation, true)
+    }
+
+    fn collect_inner(&self, generation: usize, force: bool) -> CollectResult {
+        if !force && !self.is_enabled() {
+            return CollectResult::default();
+        }
+
+        // Try to acquire the collecting lock
+        let Some(_guard) = self.collecting.try_lock() else {
+            return CollectResult::default();
+        };
+
+        #[cfg(not(target_arch = "wasm32"))]
+        let start_time = std::time::Instant::now();
+        #[cfg(target_arch = "wasm32")]
+        let start_time = ();
+
+        // Memory barrier to ensure visibility of all reference count updates
+        // from other threads before we start analyzing the object graph.
+        core::sync::atomic::fence(Ordering::SeqCst);
+
+        let generation = generation.min(2);
+        let debug = self.get_debug();
+
+        // Clear the method cache to release strong references that
+        // might prevent cycle collection (_PyType_ClearCache).
+        crate::builtins::type_::type_cache_clear();
+
+        // Step 1: Gather objects from generations 0..=generation
+        // Hold read locks for the entire scan to prevent concurrent modifications.
+        let gen_locks: Vec<_> = (0..=generation)
+            .map(|i| self.generation_lists[i].read())
+            .collect();
+
+        let mut collecting: HashSet<GcPtr> = HashSet::new();
+        for gen_list in &gen_locks {
+            for obj in gen_list.iter() {
+                if obj.strong_count() > 0 {
+                    collecting.insert(GcPtr(NonNull::from(obj)));
+                }
+            }
+        }
+
+        if collecting.is_empty() {
+            // Reset counts for generations whose objects were promoted away.
+            // For gen2 (oldest), survivors stay in-place so don't reset gen2 count.
+            let reset_end = if generation >= 2 { 2 } else { generation + 1 };
+            for i in 0..reset_end {
+                self.generations[i].count.store(0, Ordering::SeqCst);
+            }
+            let duration = elapsed_secs(&start_time);
+            self.generations[generation].update_stats(0, 0, 0, duration);
+            return CollectResult {
+                collected: 0,
+                uncollectable: 0,
+                candidates: 0,
+                duration,
+            };
+        }
+
+        let candidates = collecting.len();
+
+        if debug.contains(GcDebugFlags::STATS) {
+            eprintln!(
+                "gc: collecting {} objects from generations 0..={}",
+                collecting.len(),
+                generation
+            );
+        }
+
+        // Step 2: Build gc_refs map (copy reference counts)
+        let mut gc_refs: std::collections::HashMap<GcPtr, usize> = std::collections::HashMap::new();
+        for &ptr in &collecting {
+            let obj = unsafe { ptr.0.as_ref() };
+            gc_refs.insert(ptr, obj.strong_count());
+        }
+
+        // Step 3: Subtract internal references
+        // Pre-compute referent pointers once per object so that both step 3
+        // (subtract refs) and step 4 (BFS reachability) see the same snapshot
+        // of each object's children. Without this, a dict whose write lock is
+        // held during one traversal but not the other can yield inconsistent
+        // results, causing live objects to be incorrectly collected.
+        let mut referents_map: std::collections::HashMap<GcPtr, Vec<NonNull<PyObject>>> =
+            std::collections::HashMap::new();
+        for &ptr in &collecting {
+            let obj = unsafe { ptr.0.as_ref() };
+            if obj.strong_count() == 0 {
+                continue;
+            }
+            let referent_ptrs = unsafe { obj.gc_get_referent_ptrs() };
+            referents_map.insert(ptr, referent_ptrs.clone());
+            for child_ptr in referent_ptrs {
+                let gc_ptr = GcPtr(child_ptr);
+                if collecting.contains(&gc_ptr)
+                    && let Some(refs) = gc_refs.get_mut(&gc_ptr)
+                {
+                    *refs = refs.saturating_sub(1);
+                }
+            }
+        }
+
+        // Step 4: Find reachable objects (gc_refs > 0) and traverse from them
+        let mut reachable: HashSet<GcPtr> = HashSet::new();
+        let mut worklist: Vec<GcPtr> = Vec::new();
+
+        for (&ptr, &refs) in &gc_refs {
+            if refs > 0 {
+                reachable.insert(ptr);
+                worklist.push(ptr);
+            }
+        }
+
+        while let Some(ptr) = worklist.pop() {
+            let obj = unsafe { ptr.0.as_ref() };
+            if obj.is_gc_tracked() {
+                // Reuse the pre-computed referent pointers from step 3.
+                // For objects that were skipped in step 3 (strong_count was 0),
+                // compute them now as a fallback.
+                let referent_ptrs = referents_map
+                    .get(&ptr)
+                    .cloned()
+                    .unwrap_or_else(|| unsafe { obj.gc_get_referent_ptrs() });
+                for child_ptr in referent_ptrs {
+                    let gc_ptr = GcPtr(child_ptr);
+                    if collecting.contains(&gc_ptr) && reachable.insert(gc_ptr) {
+                        worklist.push(gc_ptr);
+                    }
+                }
+            }
+        }
+
+        // Step 5: Find unreachable objects
+        let unreachable: Vec<GcPtr> = collecting.difference(&reachable).copied().collect();
+
+        if debug.contains(GcDebugFlags::STATS) {
+            eprintln!(
+                "gc: {} reachable, {} unreachable",
+                reachable.len(),
+                unreachable.len()
+            );
+        }
+
+        // Create strong references while read locks are still held.
+        // After dropping gen_locks, other threads can untrack+free objects,
+        // making the raw pointers in `reachable`/`unreachable` dangling.
+        // Strong refs keep objects alive for later phases.
+        //
+        // Use try_to_owned() (CAS-based) instead of strong_count()+to_owned()
+        // to prevent a TOCTOU race: another thread can dec() the count to 0
+        // between the check and the increment, causing a use-after-free when
+        // the destroying thread eventually frees the memory.
+        let survivor_refs: Vec<PyObjectRef> = reachable
+            .iter()
+            .filter_map(|ptr| {
+                let obj = unsafe { ptr.0.as_ref() };
+                obj.try_to_owned()
+            })
+            .collect();
+
+        let unreachable_refs: Vec<crate::PyObjectRef> = unreachable
+            .iter()
+            .filter_map(|ptr| {
+                let obj = unsafe { ptr.0.as_ref() };
+                obj.try_to_owned()
+            })
+            .collect();
+
+        if unreachable.is_empty() {
+            drop(gen_locks);
+            self.promote_survivors(generation, &survivor_refs);
+            let reset_end = if generation >= 2 { 2 } else { generation + 1 };
+            for i in 0..reset_end {
+                self.generations[i].count.store(0, Ordering::SeqCst);
+            }
+            let duration = elapsed_secs(&start_time);
+            self.generations[generation].update_stats(0, 0, candidates, duration);
+            return CollectResult {
+                collected: 0,
+                uncollectable: 0,
+                candidates,
+                duration,
+            };
+        }
+
+        // Release read locks before finalization phase.
+        drop(gen_locks);
+
+        // Step 6: Finalize unreachable objects and handle resurrection
+
+        if unreachable_refs.is_empty() {
+            self.promote_survivors(generation, &survivor_refs);
+            let reset_end = if generation >= 2 { 2 } else { generation + 1 };
+            for i in 0..reset_end {
+                self.generations[i].count.store(0, Ordering::SeqCst);
+            }
+            let duration = elapsed_secs(&start_time);
+            self.generations[generation].update_stats(0, 0, candidates, duration);
+            return CollectResult {
+                collected: 0,
+                uncollectable: 0,
+                candidates,
+                duration,
+            };
+        }
+
+        // 6b: Record initial strong counts (for resurrection detection)
+        let initial_counts: std::collections::HashMap<GcPtr, usize> = unreachable_refs
+            .iter()
+            .map(|obj| {
+                let ptr = GcPtr(core::ptr::NonNull::from(obj.as_ref()));
+                (ptr, obj.strong_count())
+            })
+            .collect();
+
+        // 6c: Clear existing weakrefs BEFORE calling __del__
+        let mut all_callbacks: Vec<(crate::PyRef<crate::object::PyWeak>, crate::PyObjectRef)> =
+            Vec::new();
+        for obj_ref in &unreachable_refs {
+            let callbacks = obj_ref.gc_clear_weakrefs_collect_callbacks();
+            all_callbacks.extend(callbacks);
+        }
+        for (wr, cb) in all_callbacks {
+            if let Some(Err(e)) = crate::vm::thread::with_vm(&cb, |vm| cb.call((wr.clone(),), vm)) {
+                crate::vm::thread::with_vm(&cb, |vm| {
+                    vm.run_unraisable(e.clone(), Some("weakref callback".to_owned()), cb.clone());
+                });
+            }
+        }
+
+        // 6d: Call __del__ on unreachable objects (skip already-finalized).
+        // try_call_finalizer() internally checks gc_finalized() and sets it,
+        // so we must NOT set it beforehand.
+        for obj_ref in &unreachable_refs {
+            obj_ref.try_call_finalizer();
+        }
+
+        // Detect resurrection
+        let mut resurrected_set: HashSet<GcPtr> = HashSet::new();
+        let unreachable_set: HashSet<GcPtr> = unreachable.iter().copied().collect();
+
+        for obj in &unreachable_refs {
+            let ptr = GcPtr(core::ptr::NonNull::from(obj.as_ref()));
+            let initial = initial_counts.get(&ptr).copied().unwrap_or(1);
+            if obj.strong_count() > initial {
+                resurrected_set.insert(ptr);
+            }
+        }
+
+        // Transitive resurrection
+        let mut worklist: Vec<GcPtr> = resurrected_set.iter().copied().collect();
+        while let Some(ptr) = worklist.pop() {
+            let obj = unsafe { ptr.0.as_ref() };
+            let referent_ptrs = unsafe { obj.gc_get_referent_ptrs() };
+            for child_ptr in referent_ptrs {
+                let child_gc_ptr = GcPtr(child_ptr);
+                if unreachable_set.contains(&child_gc_ptr) && resurrected_set.insert(child_gc_ptr) {
+                    worklist.push(child_gc_ptr);
+                }
+            }
+        }
+
+        // Partition into resurrected and truly dead
+        let (resurrected, truly_dead): (Vec<_>, Vec<_>) =
+            unreachable_refs.into_iter().partition(|obj| {
+                let ptr = GcPtr(core::ptr::NonNull::from(obj.as_ref()));
+                resurrected_set.contains(&ptr)
+            });
+
+        if debug.contains(GcDebugFlags::STATS) {
+            eprintln!(
+                "gc: {} resurrected, {} truly dead",
+                resurrected.len(),
+                truly_dead.len()
+            );
+        }
+
+        // Compute collected count (exclude instance dicts in truly_dead)
+        let collected = {
+            let dead_ptrs: HashSet<usize> = truly_dead
+                .iter()
+                .map(|obj| obj.as_ref() as *const PyObject as usize)
+                .collect();
+            let instance_dict_count = truly_dead
+                .iter()
+                .filter(|obj| {
+                    if let Some(dict_ref) = obj.dict() {
+                        dead_ptrs.contains(&(dict_ref.as_object() as *const PyObject as usize))
+                    } else {
+                        false
+                    }
+                })
+                .count();
+            truly_dead.len() - instance_dict_count
+        };
+
+        // Promote survivors to next generation BEFORE tp_clear.
+        // move_legacy_finalizer_reachable → delete_garbage order ensures
+        // survivor_refs are dropped before tp_clear, so reachable objects
+        // aren't kept alive beyond the deferred-drop phase.
+        self.promote_survivors(generation, &survivor_refs);
+        drop(survivor_refs);
+
+        // Resurrected objects stay tracked — just drop our references
+        drop(resurrected);
+
+        if debug.contains(GcDebugFlags::COLLECTABLE) {
+            for obj in &truly_dead {
+                eprintln!(
+                    "gc: collectable <{} {:p}>",
+                    obj.class().name(),
+                    obj.as_ref()
+                );
+            }
+        }
+
+        if debug.contains(GcDebugFlags::SAVEALL) {
+            let mut garbage_guard = self.garbage.lock();
+            for obj_ref in truly_dead.iter() {
+                garbage_guard.push(obj_ref.clone());
+            }
+        }
+
+        if !truly_dead.is_empty() {
+            // Break cycles by clearing references (tp_clear)
+            // Use deferred drop context to prevent stack overflow.
+            rustpython_common::refcount::with_deferred_drops(|| {
+                for obj_ref in truly_dead.iter() {
+                    if obj_ref.gc_has_clear() {
+                        let edges = unsafe { obj_ref.gc_clear() };
+                        drop(edges);
+                    }
+                }
+                drop(truly_dead);
+            });
+        }
+
+        // Reset counts for generations whose objects were promoted away.
+        // For gen2 (oldest), survivors stay in-place so don't reset gen2 count.
+        let reset_end = if generation >= 2 { 2 } else { generation + 1 };
+        for i in 0..reset_end {
+            self.generations[i].count.store(0, Ordering::SeqCst);
+        }
+
+        let duration = elapsed_secs(&start_time);
+        self.generations[generation].update_stats(collected, 0, candidates, duration);
+
+        CollectResult {
+            collected,
+            uncollectable: 0,
+            candidates,
+            duration,
+        }
+    }
+
+    /// Promote surviving objects to the next generation.
+    ///
+    /// `survivors` must be strong references (`PyObjectRef`) to keep objects alive,
+    /// since the generation read locks are released before this is called.
+    ///
+    /// Holds both source and destination list locks simultaneously to prevent
+    /// a race where concurrent `untrack_object` reads a stale `gc_generation`
+    /// and operates on the wrong list.
+    fn promote_survivors(&self, from_gen: usize, survivors: &[PyObjectRef]) {
+        if from_gen >= 2 {
+            return; // Already in oldest generation
+        }
+
+        let next_gen = from_gen + 1;
+
+        for obj_ref in survivors {
+            let obj = obj_ref.as_ref();
+            let ptr = NonNull::from(obj);
+            let obj_gen = obj.gc_generation();
+            if obj_gen as usize <= from_gen && obj_gen <= 2 {
+                let src_gen = obj_gen as usize;
+
+                // Lock both source and destination lists simultaneously.
+                // Always ascending order (src_gen < next_gen) → no deadlock.
+                let mut src = self.generation_lists[src_gen].write();
+                let mut dst = self.generation_lists[next_gen].write();
+
+                // Re-check under locks: object might have been untracked concurrently
+                if obj.gc_generation() != obj_gen || !obj.is_gc_tracked() {
+                    continue;
+                }
+
+                if unsafe { src.remove(ptr) }.is_some() {
+                    self.generations[src_gen]
+                        .count
+                        .fetch_sub(1, Ordering::SeqCst);
+
+                    dst.push_front(ptr);
+                    self.generations[next_gen]
+                        .count
+                        .fetch_add(1, Ordering::SeqCst);
+
+                    obj.set_gc_generation(next_gen as u8);
+                }
+            }
+        }
+    }
+
+    /// Get count of frozen objects
+    pub fn get_freeze_count(&self) -> usize {
+        self.permanent.count()
+    }
+
+    /// Freeze all tracked objects (move to permanent generation).
+    /// Lock order: generation_lists[i] → permanent_list (consistent with unfreeze).
+    pub fn freeze(&self) {
+        let mut count = 0usize;
+
+        for (gen_idx, gen_list) in self.generation_lists.iter().enumerate() {
+            let mut list = gen_list.write();
+            let mut perm = self.permanent_list.write();
+            while let Some(ptr) = list.pop_front() {
+                perm.push_front(ptr);
+                unsafe { ptr.as_ref().set_gc_generation(GC_PERMANENT) };
+                count += 1;
+            }
+            self.generations[gen_idx].count.store(0, Ordering::SeqCst);
+        }
+
+        self.permanent.count.fetch_add(count, Ordering::SeqCst);
+    }
+
+    /// Unfreeze all objects (move from permanent to gen2).
+    /// Lock order: generation_lists[2] → permanent_list (consistent with freeze).
+    pub fn unfreeze(&self) {
+        let mut count = 0usize;
+
+        {
+            let mut gen2 = self.generation_lists[2].write();
+            let mut perm_list = self.permanent_list.write();
+            while let Some(ptr) = perm_list.pop_front() {
+                gen2.push_front(ptr);
+                unsafe { ptr.as_ref().set_gc_generation(2) };
+                count += 1;
+            }
+            self.permanent.count.store(0, Ordering::SeqCst);
+        }
+
+        self.generations[2].count.fetch_add(count, Ordering::SeqCst);
+    }
+
+    /// Reset all locks to unlocked state after fork().
+    ///
+    /// After fork(), only the forking thread survives. Any lock held by another
+    /// thread is permanently stuck. This resets them by zeroing the raw bytes.
+    ///
+    /// # Safety
+    /// Must only be called after fork() in the child process when no other
+    /// threads exist. The calling thread must NOT hold any of these locks.
+    #[cfg(all(unix, feature = "threading"))]
+    pub unsafe fn reinit_after_fork(&self) {
+        use crate::common::lock::{reinit_mutex_after_fork, reinit_rwlock_after_fork};
+
+        unsafe {
+            reinit_mutex_after_fork(&self.collecting);
+            reinit_mutex_after_fork(&self.garbage);
+            reinit_mutex_after_fork(&self.callbacks);
+
+            for generation in &self.generations {
+                generation.reinit_stats_after_fork();
+            }
+            self.permanent.reinit_stats_after_fork();
+
+            for rw in &self.generation_lists {
+                reinit_rwlock_after_fork(rw);
+            }
+            reinit_rwlock_after_fork(&self.permanent_list);
+        }
+    }
+}
+
+/// Get a reference to the GC state.
+///
+/// In threading mode this is a true global (OnceLock).
+/// In non-threading mode this is thread-local, because PyRwLock/PyMutex
+/// use Cell-based locks that are not Sync.
+pub fn gc_state() -> &'static GcState {
+    rustpython_common::static_cell! {
+        static GC_STATE: GcState;
+    }
+    GC_STATE.get_or_init(GcState::new)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_gc_state_default() {
+        let state = GcState::new();
+        assert!(state.is_enabled());
+        assert_eq!(state.get_debug(), GcDebugFlags::empty());
+        assert_eq!(state.get_threshold(), (2000, 10, 0));
+        assert_eq!(state.get_count(), (0, 0, 0));
+    }
+
+    #[test]
+    fn test_gc_enable_disable() {
+        let state = GcState::new();
+        assert!(state.is_enabled());
+        state.disable();
+        assert!(!state.is_enabled());
+        state.enable();
+        assert!(state.is_enabled());
+    }
+
+    #[test]
+    fn test_gc_threshold() {
+        let state = GcState::new();
+        state.set_threshold(100, Some(20), Some(30));
+        assert_eq!(state.get_threshold(), (100, 20, 30));
+    }
+
+    #[test]
+    fn test_gc_debug_flags() {
+        let state = GcState::new();
+        state.set_debug(GcDebugFlags::STATS | GcDebugFlags::COLLECTABLE);
+        assert_eq!(
+            state.get_debug(),
+            GcDebugFlags::STATS | GcDebugFlags::COLLECTABLE
+        );
+    }
+}
diff --git a/crates/vm/src/import.rs b/crates/vm/src/import.rs
index d1b77407ef8..9d015c8f3b6 100644
--- a/crates/vm/src/import.rs
+++ b/crates/vm/src/import.rs
@@ -1,8 +1,8 @@
 //! Import mechanics
 
 use crate::{
-    AsObject, Py, PyObjectRef, PyPayload, PyRef, PyResult, TryFromObject,
-    builtins::{PyCode, list, traceback::PyTraceback},
+    AsObject, Py, PyObjectRef, PyPayload, PyRef, PyResult,
+    builtins::{PyCode, PyStr, PyUtf8Str, PyUtf8StrRef, traceback::PyTraceback},
     exceptions::types::PyBaseException,
     scope::Scope,
     vm::{VirtualMachine, resolve_frozen_alias, thread},
@@ -30,15 +30,18 @@ pub(crate) fn init_importlib_base(vm: &mut VirtualMachine) -> PyResult<PyObjectR
         Ok(bootstrap)
     })?;
     vm.import_func = importlib.get_attr(identifier!(vm, __import__), vm)?;
+    vm.importlib = importlib.clone();
     Ok(importlib)
 }
 
+#[cfg(feature = "host_env")]
 pub(crate) fn init_importlib_package(vm: &VirtualMachine, importlib: PyObjectRef) -> PyResult<()> {
+    use crate::{TryFromObject, builtins::PyListRef};
+
     thread::enter_vm(vm, || {
         flame_guard!("install_external");
 
         // same deal as imports above
-        #[cfg(any(not(target_arch = "wasm32"), target_os = "wasi"))]
         import_builtin(vm, crate::stdlib::os::MODULE_NAME)?;
         #[cfg(windows)]
         import_builtin(vm, "winreg")?;
@@ -51,7 +54,7 @@ pub(crate) fn init_importlib_package(vm: &VirtualMachine, importlib: PyObjectRef
             let zipimport = vm.import("zipimport", 0)?;
             let zipimporter = zipimport.get_attr("zipimporter", vm)?;
             let path_hooks = vm.sys_module.get_attr("path_hooks", vm)?;
-            let path_hooks = list::PyListRef::try_from_object(vm, path_hooks)?;
+            let path_hooks = PyListRef::try_from_object(vm, path_hooks)?;
             path_hooks.insert(0, zipimporter);
             Ok(())
         })();
@@ -66,7 +69,7 @@ pub fn make_frozen(vm: &VirtualMachine, name: &str) -> PyResult<PyRef<PyCode>> {
     let frozen = vm.state.frozen.get(name).ok_or_else(|| {
         vm.new_import_error(
             format!("No such frozen object named {name}"),
-            vm.ctx.new_str(name),
+            vm.ctx.new_utf8_str(name),
         )
     })?;
     Ok(vm.ctx.new_code(frozen.code))
@@ -76,13 +79,13 @@ pub fn import_frozen(vm: &VirtualMachine, module_name: &str) -> PyResult {
     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),
+            vm.ctx.new_utf8_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());
     let origname = resolve_frozen_alias(module_name);
-    module.set_attr("__origname__", vm.ctx.new_str(origname), vm)?;
+    module.set_attr("__origname__", vm.ctx.new_utf8_str(origname), vm)?;
     Ok(module)
 }
 
@@ -115,7 +118,7 @@ pub fn import_builtin(vm: &VirtualMachine, module_name: &str) -> PyResult {
     // Module not found in module_defs
     Err(vm.new_import_error(
         format!("Cannot import builtin module {module_name}"),
-        vm.ctx.new_str(module_name),
+        vm.ctx.new_utf8_str(module_name),
     ))
 }
 
@@ -150,6 +153,27 @@ pub fn import_source(vm: &VirtualMachine, module_name: &str, content: &str) -> P
     import_code_obj(vm, module_name, code, false)
 }
 
+/// If `__spec__._initializing` is true, wait for the module to finish
+/// initializing by calling `_lock_unlock_module`.
+fn import_ensure_initialized(
+    module: &PyObjectRef,
+    name: &str,
+    vm: &VirtualMachine,
+) -> PyResult<()> {
+    let initializing = match vm.get_attribute_opt(module.clone(), vm.ctx.intern_str("__spec__"))? {
+        Some(spec) => match vm.get_attribute_opt(spec, vm.ctx.intern_str("_initializing"))? {
+            Some(v) => v.try_to_bool(vm)?,
+            None => false,
+        },
+        None => false,
+    };
+    if initializing {
+        let lock_unlock = vm.importlib.get_attr("_lock_unlock_module", vm)?;
+        lock_unlock.call((vm.ctx.new_utf8_str(name),), vm)?;
+    }
+    Ok(())
+}
+
 pub fn import_code_obj(
     vm: &VirtualMachine,
     module_name: &str,
@@ -159,13 +183,13 @@ pub fn import_code_obj(
     let attrs = vm.ctx.new_dict();
     attrs.set_item(
         identifier!(vm, __name__),
-        vm.ctx.new_str(module_name).into(),
+        vm.ctx.new_utf8_str(module_name).into(),
         vm,
     )?;
     if set_file_attr {
         attrs.set_item(
             identifier!(vm, __file__),
-            code_obj.source_path.to_object(),
+            code_obj.source_path().to_object(),
             vm,
         )?;
     }
@@ -192,7 +216,7 @@ fn remove_importlib_frames_inner(
         return (None, false);
     };
 
-    let file_name = traceback.frame.code.source_path.as_str();
+    let file_name = traceback.frame.code.source_path().as_str();
 
     let (inner_tb, mut now_in_importlib) =
         remove_importlib_frames_inner(vm, traceback.next.lock().clone(), always_trim);
@@ -235,3 +259,354 @@ pub fn remove_importlib_frames(vm: &VirtualMachine, exc: &Py<PyBaseException>) {
         exc.set_traceback_typed(trimmed_tb);
     }
 }
+
+/// Get origin path from a module spec, checking has_location first.
+pub(crate) fn get_spec_file_origin(
+    spec: &Option<PyObjectRef>,
+    vm: &VirtualMachine,
+) -> Option<String> {
+    let spec = spec.as_ref()?;
+    let has_location = spec
+        .get_attr("has_location", vm)
+        .ok()
+        .and_then(|v| v.try_to_bool(vm).ok())
+        .unwrap_or(false);
+    if !has_location {
+        return None;
+    }
+    spec.get_attr("origin", vm).ok().and_then(|origin| {
+        if vm.is_none(&origin) {
+            None
+        } else {
+            origin
+                .downcast_ref::<PyStr>()
+                .and_then(|s| s.to_str().map(|s| s.to_owned()))
+        }
+    })
+}
+
+/// Check if a module file possibly shadows another module of the same name.
+/// Compares the module's directory with the original sys.path[0] (derived from sys.argv[0]).
+pub(crate) fn is_possibly_shadowing_path(origin: &str, vm: &VirtualMachine) -> bool {
+    use std::path::Path;
+
+    if vm.state.config.settings.safe_path {
+        return false;
+    }
+
+    let origin_path = Path::new(origin);
+    let parent = match origin_path.parent() {
+        Some(p) => p,
+        None => return false,
+    };
+    // For packages (__init__.py), look one directory further up
+    let root = if origin_path.file_name() == Some("__init__.py".as_ref()) {
+        parent.parent().unwrap_or(Path::new(""))
+    } else {
+        parent
+    };
+
+    // Compute original sys.path[0] from sys.argv[0] (the script path).
+    // See: config->sys_path_0, which is set once
+    // at initialization and never changes even if sys.path is modified.
+    let sys_path_0 = (|| -> Option<String> {
+        let argv = vm.sys_module.get_attr("argv", vm).ok()?;
+        let argv0 = argv.get_item(&0usize, vm).ok()?;
+        let argv0_str = argv0.downcast_ref::<PyUtf8Str>()?;
+        let s = argv0_str.as_str();
+
+        // For -c and REPL, original sys.path[0] is ""
+        if s == "-c" || s.is_empty() {
+            return Some(String::new());
+        }
+        // For scripts, original sys.path[0] is dirname(argv[0])
+        Some(
+            Path::new(s)
+                .parent()
+                .and_then(|p| p.to_str())
+                .unwrap_or("")
+                .to_owned(),
+        )
+    })();
+
+    let sys_path_0 = match sys_path_0 {
+        Some(p) => p,
+        None => return false,
+    };
+
+    let cmp_path = if sys_path_0.is_empty() {
+        match std::env::current_dir() {
+            Ok(d) => d.to_string_lossy().to_string(),
+            Err(_) => return false,
+        }
+    } else {
+        sys_path_0
+    };
+
+    root.to_str() == Some(cmp_path.as_str())
+}
+
+/// Check if a module name is in sys.stdlib_module_names.
+/// Takes the original __name__ object to preserve str subclass behavior.
+/// Propagates errors (e.g. TypeError for unhashable str subclass).
+pub(crate) fn is_stdlib_module_name(name: &PyObjectRef, vm: &VirtualMachine) -> PyResult<bool> {
+    let stdlib_names = match vm.sys_module.get_attr("stdlib_module_names", vm) {
+        Ok(names) => names,
+        Err(_) => return Ok(false),
+    };
+    if !stdlib_names.class().fast_issubclass(vm.ctx.types.set_type)
+        && !stdlib_names
+            .class()
+            .fast_issubclass(vm.ctx.types.frozenset_type)
+    {
+        return Ok(false);
+    }
+    let result = vm.call_method(&stdlib_names, "__contains__", (name.clone(),))?;
+    result.try_to_bool(vm)
+}
+
+/// PyImport_ImportModuleLevelObject
+pub(crate) fn import_module_level(
+    name: &Py<PyStr>,
+    globals: Option<PyObjectRef>,
+    fromlist: Option<PyObjectRef>,
+    level: i32,
+    vm: &VirtualMachine,
+) -> PyResult {
+    if level < 0 {
+        return Err(vm.new_value_error("level must be >= 0"));
+    }
+
+    let name_str = match name.to_str() {
+        Some(s) => s,
+        None => {
+            // Name contains surrogates. Like CPython, try sys.modules
+            // lookup with the Python string key directly.
+            if level == 0 {
+                let sys_modules = vm.sys_module.get_attr("modules", vm)?;
+                return sys_modules.get_item(name, vm).map_err(|_| {
+                    vm.new_import_error(format!("No module named '{}'", name), name.to_owned())
+                });
+            }
+            return Err(vm.new_import_error(format!("No module named '{}'", name), name.to_owned()));
+        }
+    };
+
+    // Resolve absolute name
+    let abs_name = if level > 0 {
+        // When globals is not provided (Rust None), raise KeyError
+        // matching resolve_name() where globals==NULL
+        if globals.is_none() {
+            return Err(vm.new_key_error(vm.ctx.new_str("'__name__' not in globals").into()));
+        }
+        let globals_ref = globals.as_ref().unwrap();
+        // When globals is Python None, treat like empty mapping
+        let empty_dict_obj;
+        let globals_ref = if vm.is_none(globals_ref) {
+            empty_dict_obj = vm.ctx.new_dict().into();
+            &empty_dict_obj
+        } else {
+            globals_ref
+        };
+        let package = calc_package(Some(globals_ref), vm)?;
+        if package.is_empty() {
+            return Err(vm.new_import_error(
+                "attempted relative import with no known parent package",
+                vm.ctx.new_utf8_str(""),
+            ));
+        }
+        resolve_name(name_str, &package, level as usize, vm)?
+    } else {
+        if name_str.is_empty() {
+            return Err(vm.new_value_error("Empty module name"));
+        }
+        name_str.to_owned()
+    };
+
+    // import_get_module + import_find_and_load
+    let sys_modules = vm.sys_module.get_attr("modules", vm)?;
+    let module = match sys_modules.get_item(&*abs_name, vm) {
+        Ok(m) if !vm.is_none(&m) => {
+            import_ensure_initialized(&m, &abs_name, vm)?;
+            m
+        }
+        _ => {
+            let find_and_load = vm.importlib.get_attr("_find_and_load", vm)?;
+            let abs_name_obj = vm.ctx.new_utf8_str(&*abs_name);
+            find_and_load.call((abs_name_obj, vm.import_func.clone()), vm)?
+        }
+    };
+
+    // Handle fromlist
+    let has_from = match fromlist.as_ref().filter(|fl| !vm.is_none(fl)) {
+        Some(fl) => fl.clone().try_to_bool(vm)?,
+        None => false,
+    };
+
+    if has_from {
+        let fromlist = fromlist.unwrap();
+        // Only call _handle_fromlist if the module looks like a package
+        // (has __path__). Non-module objects without __name__/__path__ would
+        // crash inside _handle_fromlist; IMPORT_FROM handles per-attribute
+        // errors with proper ImportError conversion.
+        let has_path = vm
+            .get_attribute_opt(module.clone(), vm.ctx.intern_str("__path__"))?
+            .is_some();
+        if has_path {
+            let handle_fromlist = vm.importlib.get_attr("_handle_fromlist", vm)?;
+            handle_fromlist.call((module, fromlist, vm.import_func.clone()), vm)
+        } else {
+            Ok(module)
+        }
+    } else if level == 0 || !name_str.is_empty() {
+        match name_str.find('.') {
+            None => Ok(module),
+            Some(dot) => {
+                let to_return = if level == 0 {
+                    name_str[..dot].to_owned()
+                } else {
+                    let cut_off = name_str.len() - dot;
+                    abs_name[..abs_name.len() - cut_off].to_owned()
+                };
+                match sys_modules.get_item(&*to_return, vm) {
+                    Ok(m) => Ok(m),
+                    Err(_) if level == 0 => {
+                        // For absolute imports (level 0), try importing the
+                        // parent. Matches _bootstrap.__import__ behavior.
+                        let find_and_load = vm.importlib.get_attr("_find_and_load", vm)?;
+                        let to_return_obj = vm.ctx.new_utf8_str(&*to_return);
+                        find_and_load.call((to_return_obj, vm.import_func.clone()), vm)
+                    }
+                    Err(_) => {
+                        // For relative imports (level > 0), raise KeyError
+                        let to_return_obj: PyObjectRef = vm
+                            .ctx
+                            .new_utf8_str(format!("'{to_return}' not in sys.modules as expected"))
+                            .into();
+                        Err(vm.new_key_error(to_return_obj))
+                    }
+                }
+            }
+        }
+    } else {
+        Ok(module)
+    }
+}
+
+/// resolve_name in import.c - resolve relative import name
+fn resolve_name(name: &str, package: &str, level: usize, vm: &VirtualMachine) -> PyResult<String> {
+    // Python: bits = package.rsplit('.', level - 1)
+    // Rust: rsplitn(level, '.') gives maxsplit=level-1
+    let parts: Vec<&str> = package.rsplitn(level, '.').collect();
+    if parts.len() < level {
+        return Err(vm.new_import_error(
+            "attempted relative import beyond top-level package",
+            vm.ctx.new_utf8_str(name),
+        ));
+    }
+    // rsplitn returns parts right-to-left, so last() is the leftmost (base)
+    let base = parts.last().unwrap();
+    if name.is_empty() {
+        Ok(base.to_string())
+    } else {
+        Ok(format!("{base}.{name}"))
+    }
+}
+
+/// _calc___package__ - calculate package from globals for relative imports
+fn calc_package(globals: Option<&PyObjectRef>, vm: &VirtualMachine) -> PyResult<String> {
+    let globals = globals.ok_or_else(|| {
+        vm.new_import_error(
+            "attempted relative import with no known parent package",
+            vm.ctx.new_utf8_str(""),
+        )
+    })?;
+
+    let package = globals.get_item("__package__", vm).ok();
+    let spec = globals.get_item("__spec__", vm).ok();
+
+    if let Some(ref pkg) = package
+        && !vm.is_none(pkg)
+    {
+        let pkg_str: PyUtf8StrRef = pkg
+            .clone()
+            .downcast()
+            .map_err(|_| vm.new_type_error("package must be a string"))?;
+        // Warn if __package__ != __spec__.parent
+        if let Some(ref spec) = spec
+            && !vm.is_none(spec)
+            && let Ok(parent) = spec.get_attr("parent", vm)
+            && !pkg_str.is(&parent)
+            && pkg_str
+                .as_object()
+                .rich_compare_bool(&parent, crate::types::PyComparisonOp::Ne, vm)
+                .unwrap_or(false)
+        {
+            let parent_repr = parent
+                .repr_utf8(vm)
+                .map(|s| s.as_str().to_owned())
+                .unwrap_or_default();
+            let msg = format!(
+                "__package__ != __spec__.parent ('{}' != {})",
+                pkg_str.as_str(),
+                parent_repr
+            );
+            let warn = vm
+                .import("_warnings", 0)
+                .and_then(|w| w.get_attr("warn", vm));
+            if let Ok(warn_fn) = warn {
+                let _ = warn_fn.call(
+                    (
+                        vm.ctx.new_str(msg),
+                        vm.ctx.exceptions.deprecation_warning.to_owned(),
+                    ),
+                    vm,
+                );
+            }
+        }
+        return Ok(pkg_str.as_str().to_owned());
+    } else if let Some(ref spec) = spec
+        && !vm.is_none(spec)
+        && let Ok(parent) = spec.get_attr("parent", vm)
+        && !vm.is_none(&parent)
+    {
+        let parent_str: PyUtf8StrRef = parent
+            .downcast()
+            .map_err(|_| vm.new_type_error("package set to non-string"))?;
+        return Ok(parent_str.as_str().to_owned());
+    }
+
+    // Fall back to __name__ and __path__
+    let warn = vm
+        .import("_warnings", 0)
+        .and_then(|w| w.get_attr("warn", vm));
+    if let Ok(warn_fn) = warn {
+        let _ = warn_fn.call(
+            (
+                vm.ctx.new_str("can't resolve package from __spec__ or __package__, falling back on __name__ and __path__"),
+                vm.ctx.exceptions.import_warning.to_owned(),
+            ),
+            vm,
+        );
+    }
+
+    let mod_name = globals.get_item("__name__", vm).map_err(|_| {
+        vm.new_import_error(
+            "attempted relative import with no known parent package",
+            vm.ctx.new_utf8_str(""),
+        )
+    })?;
+    let mod_name_str: PyUtf8StrRef = mod_name
+        .downcast()
+        .map_err(|_| vm.new_type_error("__name__ must be a string"))?;
+    let mut package = mod_name_str.as_str().to_owned();
+    // If not a package (no __path__), strip last component.
+    // Uses rpartition('.')[0] semantics: returns empty string when no dot.
+    if globals.get_item("__path__", vm).is_err() {
+        package = match package.rfind('.') {
+            Some(dot) => package[..dot].to_owned(),
+            None => String::new(),
+        };
+    }
+    Ok(package)
+}
diff --git a/crates/vm/src/intern.rs b/crates/vm/src/intern.rs
index a50b8871cb9..37b971b8dca 100644
--- a/crates/vm/src/intern.rs
+++ b/crates/vm/src/intern.rs
@@ -31,6 +31,16 @@ impl Clone for StringPool {
 }
 
 impl StringPool {
+    /// Reset the inner RwLock to unlocked state after fork().
+    ///
+    /// # Safety
+    /// Must only be called after fork() in the child process when no other
+    /// threads exist.
+    #[cfg(all(unix, feature = "threading"))]
+    pub(crate) unsafe fn reinit_after_fork(&self) {
+        unsafe { crate::common::lock::reinit_rwlock_after_fork(&self.inner) };
+    }
+
     #[inline]
     pub unsafe fn intern<S: InternableString>(
         &self,
@@ -126,10 +136,25 @@ impl CachedPyStrRef {
     }
 }
 
+#[repr(transparent)]
 pub struct PyInterned<T> {
     inner: Py<T>,
 }
 
+impl PyInterned<PyStr> {
+    /// Returns `&str` for interned strings.
+    ///
+    /// # Panics
+    /// Panics if the interned string contains unpaired surrogates (WTF-8 content).
+    /// Most interned strings are valid UTF-8, so this is an ergonomic default.
+    #[inline]
+    pub fn as_str(&self) -> &str {
+        self.inner
+            .to_str()
+            .unwrap_or_else(|| panic!("interned str is always valid UTF-8"))
+    }
+}
+
 impl<T: PyPayload> PyInterned<T> {
     #[inline]
     pub fn leak(cache: PyRef<T>) -> &'static Self {
diff --git a/crates/vm/src/lib.rs b/crates/vm/src/lib.rs
index aaa94ff52c1..21762466f13 100644
--- a/crates/vm/src/lib.rs
+++ b/crates/vm/src/lib.rs
@@ -51,6 +51,7 @@ mod codecs;
 pub mod compiler;
 pub mod convert;
 mod coroutine;
+pub mod datastack;
 mod dict_inner;
 
 #[cfg(feature = "rustpython-compiler")]
@@ -67,7 +68,7 @@ mod intern;
 pub mod iter;
 pub mod object;
 
-#[cfg(any(not(target_arch = "wasm32"), target_os = "wasi"))]
+#[cfg(feature = "host_env")]
 pub mod ospath;
 
 pub mod prelude;
@@ -77,6 +78,7 @@ pub mod py_io;
 #[cfg(feature = "serde")]
 pub mod py_serde;
 
+pub mod gc_state;
 pub mod readline;
 pub mod recursion;
 pub mod scope;
@@ -97,7 +99,7 @@ pub mod windows;
 pub use self::convert::{TryFromBorrowedObject, TryFromObject};
 pub use self::object::{
     AsObject, Py, PyAtomicRef, PyExact, PyObject, PyObjectRef, PyPayload, PyRef, PyRefExact,
-    PyResult, PyWeakRef,
+    PyResult, PyStackRef, PyWeakRef,
 };
 pub use self::vm::{Context, Interpreter, InterpreterBuilder, Settings, VirtualMachine};
 
diff --git a/crates/vm/src/macros.rs b/crates/vm/src/macros.rs
index f5c912d89cf..4fad50ac8f2 100644
--- a/crates/vm/src/macros.rs
+++ b/crates/vm/src/macros.rs
@@ -116,12 +116,12 @@ macro_rules! match_class {
 
     // The default arm, binding the original object to the specified identifier.
     (match ($obj:expr) { $binding:ident => $default:expr $(,)? }) => {{
-        #[allow(clippy::redundant_locals)]
+        #[allow(clippy::redundant_locals, reason = "macro arm intentionally binds expression once to a local")]
         let $binding = $obj;
         $default
     }};
     (match ($obj:expr) { ref $binding:ident => $default:expr $(,)? }) => {{
-        #[allow(clippy::redundant_locals)]
+        #[allow(clippy::redundant_locals, reason = "macro arm intentionally binds expression once to a local reference")]
         let $binding = &$obj;
         $default
     }};
@@ -188,11 +188,11 @@ macro_rules! identifier(
 
 #[macro_export]
 macro_rules! identifier_utf8(
-    ($as_ctx:expr, $name:ident) => {
+    ($as_ctx:expr, $name:ident) => {{
         // Safety: All known identifiers are ascii strings.
-        #[allow(clippy::macro_metavars_in_unsafe)]
-        unsafe { $as_ctx.as_ref().names.$name.as_object().downcast_unchecked_ref::<$crate::builtins::PyUtf8Str>() }
-    };
+        let interned = $as_ctx.as_ref().names.$name;
+        unsafe { $crate::builtins::PyUtf8StrInterned::from_str_interned_unchecked(interned) }
+    }};
 );
 
 /// Super detailed logging. Might soon overflow your log buffers
diff --git a/crates/vm/src/object/core.rs b/crates/vm/src/object/core.rs
index 43b2f7dc61a..a8d7c09da89 100644
--- a/crates/vm/src/object/core.rs
+++ b/crates/vm/src/object/core.rs
@@ -19,9 +19,9 @@ use crate::object::traverse_object::PyObjVTable;
 use crate::{
     builtins::{PyDictRef, PyType, PyTypeRef},
     common::{
-        atomic::{OncePtr, PyAtomic, Radium},
-        linked_list::{Link, LinkedList, Pointers},
-        lock::{PyMutex, PyMutexGuard, PyRwLock},
+        atomic::{Ordering, PyAtomic, Radium},
+        linked_list::{Link, Pointers},
+        lock::PyRwLock,
         refcount::RefCount,
     },
     vm::VirtualMachine,
@@ -40,6 +40,7 @@ use core::{
     cell::UnsafeCell,
     marker::PhantomData,
     mem::ManuallyDrop,
+    num::NonZeroUsize,
     ops::Deref,
     ptr::{self, NonNull},
 };
@@ -81,8 +82,142 @@ use core::{
 #[derive(Debug)]
 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>) });
+/// Trashcan mechanism to limit recursive deallocation depth (Py_TRASHCAN).
+/// Without this, deeply nested structures (e.g. 200k-deep list) cause stack overflow
+/// during deallocation because each level adds a stack frame.
+mod trashcan {
+    use core::cell::Cell;
+
+    /// Maximum nesting depth for deallocation before deferring.
+    /// CPython uses UNWIND_NO_NESTING = 50.
+    const TRASHCAN_LIMIT: usize = 50;
+
+    type DeallocFn = unsafe fn(*mut super::PyObject);
+    type DeallocQueue = Vec<(*mut super::PyObject, DeallocFn)>;
+
+    thread_local! {
+        static DEALLOC_DEPTH: Cell<usize> = const { Cell::new(0) };
+        static DEALLOC_QUEUE: Cell<DeallocQueue> = const { Cell::new(Vec::new()) };
+    }
+
+    /// Try to begin deallocation. Returns true if we should proceed,
+    /// false if the object was deferred (depth exceeded).
+    #[inline]
+    pub(super) unsafe fn begin(
+        obj: *mut super::PyObject,
+        dealloc: unsafe fn(*mut super::PyObject),
+    ) -> bool {
+        DEALLOC_DEPTH.with(|d| {
+            let depth = d.get();
+            if depth >= TRASHCAN_LIMIT {
+                // Depth exceeded: defer this deallocation
+                DEALLOC_QUEUE.with(|q| {
+                    let mut queue = q.take();
+                    queue.push((obj, dealloc));
+                    q.set(queue);
+                });
+                false
+            } else {
+                d.set(depth + 1);
+                true
+            }
+        })
+    }
+
+    /// End deallocation and process any deferred objects if at outermost level.
+    #[inline]
+    pub(super) unsafe fn end() {
+        let depth = DEALLOC_DEPTH.with(|d| {
+            let depth = d.get();
+            debug_assert!(depth > 0, "trashcan::end called without matching begin");
+            let depth = depth - 1;
+            d.set(depth);
+            depth
+        });
+        if depth == 0 {
+            // Process deferred deallocations iteratively
+            loop {
+                let next = DEALLOC_QUEUE.with(|q| {
+                    let mut queue = q.take();
+                    let item = queue.pop();
+                    q.set(queue);
+                    item
+                });
+                if let Some((obj, dealloc)) = next {
+                    unsafe { dealloc(obj) };
+                } else {
+                    break;
+                }
+            }
+        }
+    }
+}
+
+/// Default dealloc: handles __del__, weakref clearing, tp_clear, and memory free.
+/// Equivalent to subtype_dealloc.
+pub(super) unsafe fn default_dealloc<T: PyPayload>(obj: *mut PyObject) {
+    let obj_ref = unsafe { &*(obj as *const PyObject) };
+    if let Err(()) = obj_ref.drop_slow_inner() {
+        return; // resurrected by __del__
+    }
+
+    // Trashcan: limit recursive deallocation depth to prevent stack overflow
+    if !unsafe { trashcan::begin(obj, default_dealloc::<T>) } {
+        return; // deferred to queue
+    }
+
+    let vtable = obj_ref.0.vtable;
+
+    // Untrack from GC BEFORE deallocation.
+    // Must happen before memory is freed because intrusive list removal
+    // reads the object's gc_pointers (prev/next).
+    if obj_ref.is_gc_tracked() {
+        let ptr = unsafe { NonNull::new_unchecked(obj) };
+        unsafe {
+            crate::gc_state::gc_state().untrack_object(ptr);
+        }
+        // Verify untrack cleared the tracked flag and generation
+        debug_assert!(
+            !obj_ref.is_gc_tracked(),
+            "object still tracked after untrack_object"
+        );
+        debug_assert_eq!(
+            obj_ref.gc_generation(),
+            crate::object::GC_UNTRACKED,
+            "gc_generation not reset after untrack_object"
+        );
+    }
+
+    // Try to store in freelist for reuse BEFORE tp_clear, so that
+    // size-based freelists (e.g. PyTuple) can read the payload directly.
+    // Only exact base types (not heaptype or structseq subtypes) go into the freelist.
+    let typ = obj_ref.class();
+    let pushed = if T::HAS_FREELIST
+        && typ.heaptype_ext.is_none()
+        && core::ptr::eq(typ, T::class(crate::vm::Context::genesis()))
+    {
+        unsafe { T::freelist_push(obj) }
+    } else {
+        false
+    };
+
+    // Extract child references to break circular refs (tp_clear).
+    // This runs regardless of freelist push — the object's children must be released.
+    let mut edges = Vec::new();
+    if let Some(clear_fn) = vtable.clear {
+        unsafe { clear_fn(obj, &mut edges) };
+    }
+
+    if !pushed {
+        // Deallocate the object memory (handles ObjExt prefix if present)
+        unsafe { PyInner::dealloc(obj as *mut PyInner<T>) };
+    }
+
+    // Drop child references - may trigger recursive destruction.
+    drop(edges);
+
+    // Trashcan: decrement depth and process deferred objects at outermost level
+    unsafe { trashcan::end() };
 }
 pub(super) unsafe fn debug_obj<T: PyPayload + core::fmt::Debug>(
     x: &PyObject,
@@ -99,6 +234,12 @@ pub(super) unsafe fn try_traverse_obj<T: PyPayload>(x: &PyObject, tracer_fn: &mu
     payload.try_traverse(tracer_fn)
 }
 
+/// Call `try_clear` on payload to extract child references (tp_clear)
+pub(super) unsafe fn try_clear_obj<T: PyPayload>(x: *mut PyObject, out: &mut Vec<PyObjectRef>) {
+    let x = unsafe { &mut *(x as *mut PyInner<T>) };
+    x.payload.try_clear(out);
+}
+
 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.
@@ -124,6 +265,79 @@ bitflags::bitflags! {
     }
 }
 
+/// GC generation constants
+pub(crate) const GC_UNTRACKED: u8 = 0xFF;
+pub(crate) const GC_PERMANENT: u8 = 3;
+
+/// Link implementation for GC intrusive linked list tracking
+pub(crate) struct GcLink;
+
+// SAFETY: PyObject (PyInner<Erased>) is heap-allocated and pinned in memory
+// once created. gc_pointers is at a fixed offset in PyInner.
+unsafe impl Link for GcLink {
+    type Handle = NonNull<PyObject>;
+    type Target = PyObject;
+
+    fn as_raw(handle: &NonNull<PyObject>) -> NonNull<PyObject> {
+        *handle
+    }
+
+    unsafe fn from_raw(ptr: NonNull<PyObject>) -> NonNull<PyObject> {
+        ptr
+    }
+
+    unsafe fn pointers(target: NonNull<PyObject>) -> NonNull<Pointers<PyObject>> {
+        let inner_ptr = target.as_ptr() as *mut PyInner<Erased>;
+        unsafe { NonNull::new_unchecked(&raw mut (*inner_ptr).gc_pointers) }
+    }
+}
+
+/// Extension fields for objects that need dict or member slots.
+/// Allocated as a prefix before PyInner when needed (prefix allocation pattern).
+/// Access via `PyInner::ext_ref()` using negative offset from the object pointer.
+///
+/// align(8) ensures size_of::<ObjExt>() is always a multiple of 8,
+/// so the offset from Layout::extend equals size_of::<ObjExt>() for any
+/// PyInner<T> alignment (important on wasm32 where pointers are 4 bytes
+/// but some payloads like PyWeak have align 8 due to i64 fields).
+#[repr(C, align(8))]
+pub(super) struct ObjExt {
+    pub(super) dict: Option<InstanceDict>,
+    pub(super) slots: Box<[PyRwLock<Option<PyObjectRef>>]>,
+}
+
+impl ObjExt {
+    fn new(dict: Option<PyDictRef>, member_count: usize) -> Self {
+        Self {
+            dict: dict.map(InstanceDict::new),
+            slots: core::iter::repeat_with(|| PyRwLock::new(None))
+                .take(member_count)
+                .collect_vec()
+                .into_boxed_slice(),
+        }
+    }
+}
+
+impl fmt::Debug for ObjExt {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "[ObjExt]")
+    }
+}
+
+/// Precomputed offset constants for prefix allocation.
+/// All prefix components are align(8) and their sizes are multiples of 8,
+/// so Layout::extend adds no inter-padding.
+const EXT_OFFSET: usize = core::mem::size_of::<ObjExt>();
+const WEAKREF_OFFSET: usize = core::mem::size_of::<WeakRefList>();
+
+const _: () =
+    assert!(core::mem::size_of::<ObjExt>().is_multiple_of(core::mem::align_of::<ObjExt>()));
+const _: () = assert!(core::mem::align_of::<ObjExt>() >= core::mem::align_of::<PyInner<()>>());
+const _: () = assert!(
+    core::mem::size_of::<WeakRefList>().is_multiple_of(core::mem::align_of::<WeakRefList>())
+);
+const _: () = assert!(core::mem::align_of::<WeakRefList>() >= core::mem::align_of::<PyInner<()>>());
+
 /// 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.
@@ -133,16 +347,72 @@ pub(super) struct PyInner<T> {
     pub(super) vtable: &'static PyObjVTable,
     /// GC bits for free-threading (like ob_gc_bits)
     pub(super) gc_bits: PyAtomic<u8>,
+    /// GC generation index (0-2=gen, GC_PERMANENT=permanent, GC_UNTRACKED=not tracked).
+    /// Uses PyAtomic for interior mutability (writes happen through &self under list locks).
+    pub(super) gc_generation: PyAtomic<u8>,
+    /// Intrusive linked list pointers for GC generational tracking
+    pub(super) gc_pointers: Pointers<PyObject>,
 
     pub(super) typ: PyAtomicRef<PyType>, // __class__ member
-    pub(super) dict: Option<InstanceDict>,
-    pub(super) weak_list: WeakRefList,
-    pub(super) slots: Box<[PyRwLock<Option<PyObjectRef>>]>,
 
     pub(super) payload: T,
 }
 pub(crate) const SIZEOF_PYOBJECT_HEAD: usize = core::mem::size_of::<PyInner<()>>();
 
+impl<T> PyInner<T> {
+    /// Read type flags and member_count via raw pointers to avoid Stacked Borrows
+    /// violations during bootstrap, where type objects have self-referential typ pointers.
+    #[inline(always)]
+    fn read_type_flags(&self) -> (crate::types::PyTypeFlags, usize) {
+        let typ_ptr = self.typ.load_raw();
+        let slots = unsafe { core::ptr::addr_of!((*typ_ptr).0.payload.slots) };
+        let flags = unsafe { core::ptr::addr_of!((*slots).flags).read() };
+        let member_count = unsafe { core::ptr::addr_of!((*slots).member_count).read() };
+        (flags, member_count)
+    }
+
+    /// Access the ObjExt prefix at a negative offset from this PyInner.
+    /// Returns None if this object was allocated without dict/slots.
+    ///
+    /// Layout: [ObjExt?][WeakRefList?][PyInner]
+    /// ObjExt offset depends on whether WeakRefList is also present.
+    #[inline(always)]
+    pub(super) fn ext_ref(&self) -> Option<&ObjExt> {
+        let (flags, member_count) = self.read_type_flags();
+        let has_ext = flags.has_feature(crate::types::PyTypeFlags::HAS_DICT) || member_count > 0;
+        if !has_ext {
+            return None;
+        }
+        let has_weakref = flags.has_feature(crate::types::PyTypeFlags::HAS_WEAKREF);
+        let offset = if has_weakref {
+            WEAKREF_OFFSET + EXT_OFFSET
+        } else {
+            EXT_OFFSET
+        };
+        let self_addr = (self as *const Self as *const u8).addr();
+        let ext_ptr = core::ptr::with_exposed_provenance::<ObjExt>(self_addr.wrapping_sub(offset));
+        Some(unsafe { &*ext_ptr })
+    }
+
+    /// Access the WeakRefList prefix at a fixed negative offset from this PyInner.
+    /// Returns None if the type does not support weakrefs.
+    ///
+    /// Layout: [ObjExt?][WeakRefList?][PyInner]
+    /// WeakRefList is always immediately before PyInner (fixed WEAKREF_OFFSET).
+    #[inline(always)]
+    pub(super) fn weakref_list_ref(&self) -> Option<&WeakRefList> {
+        let (flags, _) = self.read_type_flags();
+        if !flags.has_feature(crate::types::PyTypeFlags::HAS_WEAKREF) {
+            return None;
+        }
+        let self_addr = (self as *const Self as *const u8).addr();
+        let ptr = core::ptr::with_exposed_provenance::<WeakRefList>(
+            self_addr.wrapping_sub(WEAKREF_OFFSET),
+        );
+        Some(unsafe { &*ptr })
+    }
+}
+
 impl<T: fmt::Debug> fmt::Debug for PyInner<T> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         write!(f, "[PyObject {:?}]", &self.payload)
@@ -165,8 +435,78 @@ unsafe impl Traverse for PyObject {
     }
 }
 
+// === Stripe lock for weakref list protection (WEAKREF_LIST_LOCK) ===
+
+#[cfg(feature = "threading")]
+mod weakref_lock {
+    use core::sync::atomic::{AtomicU8, Ordering};
+
+    const NUM_WEAKREF_LOCKS: usize = 64;
+
+    static LOCKS: [AtomicU8; NUM_WEAKREF_LOCKS] = [const { AtomicU8::new(0) }; NUM_WEAKREF_LOCKS];
+
+    pub(super) struct WeakrefLockGuard {
+        idx: usize,
+    }
+
+    impl Drop for WeakrefLockGuard {
+        fn drop(&mut self) {
+            LOCKS[self.idx].store(0, Ordering::Release);
+        }
+    }
+
+    pub(super) fn lock(addr: usize) -> WeakrefLockGuard {
+        let idx = (addr >> 4) % NUM_WEAKREF_LOCKS;
+        loop {
+            if LOCKS[idx]
+                .compare_exchange_weak(0, 1, Ordering::Acquire, Ordering::Relaxed)
+                .is_ok()
+            {
+                return WeakrefLockGuard { idx };
+            }
+            core::hint::spin_loop();
+        }
+    }
+
+    /// Reset all weakref stripe locks after fork in child process.
+    /// Locks held by parent threads would cause infinite spin in the child.
+    #[cfg(unix)]
+    pub(crate) fn reset_all_after_fork() {
+        for lock in &LOCKS {
+            lock.store(0, Ordering::Release);
+        }
+    }
+}
+
+#[cfg(not(feature = "threading"))]
+mod weakref_lock {
+    pub(super) struct WeakrefLockGuard;
+
+    impl Drop for WeakrefLockGuard {
+        fn drop(&mut self) {}
+    }
+
+    pub(super) fn lock(_addr: usize) -> WeakrefLockGuard {
+        WeakrefLockGuard
+    }
+}
+
+/// Reset weakref stripe locks after fork. Must be called before any
+/// Python code runs in the child process.
+#[cfg(all(unix, feature = "threading"))]
+pub(crate) fn reset_weakref_locks_after_fork() {
+    weakref_lock::reset_all_after_fork();
+}
+
+// === WeakRefList: inline on every object (tp_weaklist) ===
+
+#[repr(C)]
 pub(super) struct WeakRefList {
-    inner: OncePtr<PyMutex<WeakListInner>>,
+    /// Head of the intrusive doubly-linked list of weakrefs.
+    head: PyAtomic<*mut Py<PyWeak>>,
+    /// Cached generic weakref (no callback, exact weakref type).
+    /// Matches try_reuse_basic_ref in weakrefobject.c.
+    generic: PyAtomic<*mut Py<PyWeak>>,
 }
 
 impl fmt::Debug for WeakRefList {
@@ -175,33 +515,43 @@ impl fmt::Debug for WeakRefList {
     }
 }
 
-struct WeakListInner {
-    list: LinkedList<WeakLink, Py<PyWeak>>,
-    generic_weakref: Option<NonNull<Py<PyWeak>>>,
-    obj: Option<NonNull<PyObject>>,
-    // one for each live PyWeak with a reference to this, + 1 for the referent object if it's not dead
-    ref_count: usize,
-}
+/// Unlink a node from the weakref list. Must be called under stripe lock.
+///
+/// # Safety
+/// `node` must be a valid pointer to a node currently in the list owned by `wrl`.
+unsafe fn unlink_weakref(wrl: &WeakRefList, node: NonNull<Py<PyWeak>>) {
+    unsafe {
+        let mut ptrs = WeakLink::pointers(node);
+        let prev = ptrs.as_ref().get_prev();
+        let next = ptrs.as_ref().get_next();
+
+        if let Some(prev) = prev {
+            WeakLink::pointers(prev).as_mut().set_next(next);
+        } else {
+            // node is the head
+            wrl.head.store(
+                next.map_or(ptr::null_mut(), |p| p.as_ptr()),
+                Ordering::Relaxed,
+            );
+        }
+        if let Some(next) = next {
+            WeakLink::pointers(next).as_mut().set_prev(prev);
+        }
 
-cfg_if::cfg_if! {
-    if #[cfg(feature = "threading")] {
-        unsafe impl Send for WeakListInner {}
-        unsafe impl Sync for WeakListInner {}
+        ptrs.as_mut().set_prev(None);
+        ptrs.as_mut().set_next(None);
     }
 }
 
 impl WeakRefList {
     pub fn new() -> Self {
         Self {
-            inner: OncePtr::new(),
+            head: Radium::new(ptr::null_mut()),
+            generic: Radium::new(ptr::null_mut()),
         }
     }
 
-    /// returns None if there have never been any weakrefs in this list
-    fn try_lock(&self) -> Option<PyMutexGuard<'_, WeakListInner>> {
-        self.inner.get().map(|mu| unsafe { mu.as_ref().lock() })
-    }
-
+    /// get_or_create_weakref
     fn add(
         &self,
         obj: &PyObject,
@@ -211,119 +561,217 @@ impl WeakRefList {
         dict: Option<PyDictRef>,
     ) -> PyRef<PyWeak> {
         let is_generic = cls_is_weakref && callback.is_none();
-        let inner_ptr = self.inner.get_or_init(|| {
-            Box::new(PyMutex::new(WeakListInner {
-                list: LinkedList::default(),
-                generic_weakref: None,
-                obj: Some(NonNull::from(obj)),
-                ref_count: 1,
-            }))
-        });
-        let mut inner = unsafe { inner_ptr.as_ref().lock() };
-        if is_generic && let Some(generic_weakref) = inner.generic_weakref {
-            let generic_weakref = unsafe { generic_weakref.as_ref() };
-            if generic_weakref.0.ref_count.get() != 0 {
-                return generic_weakref.to_owned();
+
+        // Try reuse under lock first (fast path, no allocation)
+        {
+            let _lock = weakref_lock::lock(obj as *const PyObject as usize);
+            if is_generic {
+                let generic_ptr = self.generic.load(Ordering::Relaxed);
+                if !generic_ptr.is_null() {
+                    let generic = unsafe { &*generic_ptr };
+                    if generic.0.ref_count.safe_inc() {
+                        return unsafe { PyRef::from_raw(generic_ptr) };
+                    }
+                }
             }
         }
-        let obj = PyWeak {
+
+        // Allocate OUTSIDE the stripe lock. PyRef::new_ref may trigger
+        // maybe_collect → GC → WeakRefList::clear on another object that
+        // hashes to the same stripe, which would deadlock on the spinlock.
+        let weak_payload = PyWeak {
             pointers: Pointers::new(),
-            parent: inner_ptr,
+            wr_object: Radium::new(obj as *const PyObject as *mut PyObject),
             callback: UnsafeCell::new(callback),
             hash: Radium::new(crate::common::hash::SENTINEL),
         };
-        let weak = PyRef::new_ref(obj, cls, dict);
-        // SAFETY: we don't actually own the PyObjectWeak's inside `list`, and every time we take
-        // one out of the list we immediately wrap it in ManuallyDrop or forget it
-        inner.list.push_front(unsafe { ptr::read(&weak) });
-        inner.ref_count += 1;
+        let weak = PyRef::new_ref(weak_payload, cls, dict);
+
+        // Re-acquire lock for linked list insertion
+        let _lock = weakref_lock::lock(obj as *const PyObject as usize);
+
+        // Re-check: another thread may have inserted a generic ref while we
+        // were allocating outside the lock. If so, reuse it and drop ours.
         if is_generic {
-            inner.generic_weakref = Some(NonNull::from(&*weak));
+            let generic_ptr = self.generic.load(Ordering::Relaxed);
+            if !generic_ptr.is_null() {
+                let generic = unsafe { &*generic_ptr };
+                if generic.0.ref_count.safe_inc() {
+                    // Nullify wr_object so drop_inner won't unlink an
+                    // un-inserted node (which would corrupt the list head).
+                    weak.wr_object.store(ptr::null_mut(), Ordering::Relaxed);
+                    return unsafe { PyRef::from_raw(generic_ptr) };
+                }
+            }
         }
-        weak
-    }
 
-    fn clear(&self) {
-        let to_dealloc = {
-            let ptr = match self.inner.get() {
-                Some(ptr) => ptr,
-                None => return,
-            };
-            let mut inner = unsafe { ptr.as_ref().lock() };
-            inner.obj = None;
-            // TODO: can be an arrayvec
-            let mut v = Vec::with_capacity(16);
-            loop {
-                let inner2 = &mut *inner;
-                let iter = inner2
-                    .list
-                    .drain_filter(|_| true)
-                    .filter_map(|wr| {
-                        // we don't have actual ownership of the reference counts in the list.
-                        // but, now we do want ownership (and so incref these *while the lock
-                        // is held*) to avoid weird things if PyWeakObj::drop happens after
-                        // this but before we reach the loop body below
-                        let wr = ManuallyDrop::new(wr);
-
-                        if Some(NonNull::from(&**wr)) == inner2.generic_weakref {
-                            inner2.generic_weakref = None
-                        }
-
-                        // if strong_count == 0 there's some reentrancy going on. we don't
-                        // want to call the callback
-                        (wr.as_object().strong_count() > 0).then(|| (*wr).clone())
-                    })
-                    .take(16);
-                v.extend(iter);
-                if v.is_empty() {
-                    break;
+        // Insert into linked list under stripe lock
+        let node_ptr = NonNull::from(&*weak);
+        unsafe {
+            let mut ptrs = WeakLink::pointers(node_ptr);
+            if is_generic {
+                // Generic ref goes to head (insert_head for basic ref)
+                let old_head = self.head.load(Ordering::Relaxed);
+                ptrs.as_mut().set_next(NonNull::new(old_head));
+                ptrs.as_mut().set_prev(None);
+                if let Some(old_head) = NonNull::new(old_head) {
+                    WeakLink::pointers(old_head)
+                        .as_mut()
+                        .set_prev(Some(node_ptr));
                 }
-                PyMutexGuard::unlocked(&mut inner, || {
-                    for wr in v.drain(..) {
-                        let cb = unsafe { wr.callback.get().replace(None) };
-                        if let Some(cb) = cb {
-                            crate::vm::thread::with_vm(&cb, |vm| {
-                                // TODO: handle unraisable exception
-                                let _ = cb.call((wr.clone(),), vm);
-                            });
-                        }
+                self.head.store(node_ptr.as_ptr(), Ordering::Relaxed);
+                self.generic.store(node_ptr.as_ptr(), Ordering::Relaxed);
+            } else {
+                // Non-generic refs go after generic ref (insert_after)
+                let generic_ptr = self.generic.load(Ordering::Relaxed);
+                if let Some(after) = NonNull::new(generic_ptr) {
+                    let after_next = WeakLink::pointers(after).as_ref().get_next();
+                    ptrs.as_mut().set_prev(Some(after));
+                    ptrs.as_mut().set_next(after_next);
+                    WeakLink::pointers(after).as_mut().set_next(Some(node_ptr));
+                    if let Some(next) = after_next {
+                        WeakLink::pointers(next).as_mut().set_prev(Some(node_ptr));
                     }
-                })
+                } else {
+                    // No generic ref; insert at head
+                    let old_head = self.head.load(Ordering::Relaxed);
+                    ptrs.as_mut().set_next(NonNull::new(old_head));
+                    ptrs.as_mut().set_prev(None);
+                    if let Some(old_head) = NonNull::new(old_head) {
+                        WeakLink::pointers(old_head)
+                            .as_mut()
+                            .set_prev(Some(node_ptr));
+                    }
+                    self.head.store(node_ptr.as_ptr(), Ordering::Relaxed);
+                }
             }
-            inner.ref_count -= 1;
-            (inner.ref_count == 0).then_some(ptr)
-        };
-        if let Some(ptr) = to_dealloc {
-            unsafe { Self::dealloc(ptr) }
         }
+
+        weak
     }
 
-    fn count(&self) -> usize {
-        self.try_lock()
-            // we assume the object is still alive (and this is only
-            // called from PyObject::weak_count so it should be)
-            .map(|inner| inner.ref_count - 1)
-            .unwrap_or(0)
+    /// Clear all weakrefs and call their callbacks.
+    /// Called when the owner object is being dropped.
+    // PyObject_ClearWeakRefs
+    fn clear(&self, obj: &PyObject) {
+        let obj_addr = obj as *const PyObject as usize;
+        let _lock = weakref_lock::lock(obj_addr);
+
+        // Clear generic cache
+        self.generic.store(ptr::null_mut(), Ordering::Relaxed);
+
+        // Walk the list, collecting weakrefs with callbacks
+        let mut callbacks: Vec<(PyRef<PyWeak>, PyObjectRef)> = Vec::new();
+        let mut current = NonNull::new(self.head.load(Ordering::Relaxed));
+        while let Some(node) = current {
+            let next = unsafe { WeakLink::pointers(node).as_ref().get_next() };
+
+            let wr = unsafe { node.as_ref() };
+
+            // Mark weakref as dead
+            wr.0.payload
+                .wr_object
+                .store(ptr::null_mut(), Ordering::Relaxed);
+
+            // Unlink from list
+            unsafe {
+                let mut ptrs = WeakLink::pointers(node);
+                ptrs.as_mut().set_prev(None);
+                ptrs.as_mut().set_next(None);
+            }
+
+            // Collect callback only if we can still acquire a strong ref.
+            if wr.0.ref_count.safe_inc() {
+                let wr_ref = unsafe { PyRef::from_raw(wr as *const Py<PyWeak>) };
+                let cb = unsafe { wr.0.payload.callback.get().replace(None) };
+                if let Some(cb) = cb {
+                    callbacks.push((wr_ref, cb));
+                }
+            }
+
+            current = next;
+        }
+        self.head.store(ptr::null_mut(), Ordering::Relaxed);
+
+        // Invoke callbacks outside the lock
+        drop(_lock);
+        for (wr, cb) in callbacks {
+            crate::vm::thread::with_vm(&cb, |vm| {
+                let _ = cb.call((wr.clone(),), vm);
+            });
+        }
     }
 
-    unsafe fn dealloc(ptr: NonNull<PyMutex<WeakListInner>>) {
-        drop(unsafe { Box::from_raw(ptr.as_ptr()) });
+    /// Clear all weakrefs but DON'T call callbacks. Instead, return them for later invocation.
+    /// Used by GC to ensure ALL weakrefs are cleared BEFORE any callbacks are invoked.
+    /// handle_weakrefs() clears all weakrefs first, then invokes callbacks.
+    fn clear_for_gc_collect_callbacks(&self, obj: &PyObject) -> Vec<(PyRef<PyWeak>, PyObjectRef)> {
+        let obj_addr = obj as *const PyObject as usize;
+        let _lock = weakref_lock::lock(obj_addr);
+
+        // Clear generic cache
+        self.generic.store(ptr::null_mut(), Ordering::Relaxed);
+
+        let mut callbacks = Vec::new();
+        let mut current = NonNull::new(self.head.load(Ordering::Relaxed));
+        while let Some(node) = current {
+            let next = unsafe { WeakLink::pointers(node).as_ref().get_next() };
+
+            let wr = unsafe { node.as_ref() };
+
+            // Mark weakref as dead
+            wr.0.payload
+                .wr_object
+                .store(ptr::null_mut(), Ordering::Relaxed);
+
+            // Unlink from list
+            unsafe {
+                let mut ptrs = WeakLink::pointers(node);
+                ptrs.as_mut().set_prev(None);
+                ptrs.as_mut().set_next(None);
+            }
+
+            // Collect callback without invoking only if we can keep weakref alive.
+            if wr.0.ref_count.safe_inc() {
+                let wr_ref = unsafe { PyRef::from_raw(wr as *const Py<PyWeak>) };
+                let cb = unsafe { wr.0.payload.callback.get().replace(None) };
+                if let Some(cb) = cb {
+                    callbacks.push((wr_ref, cb));
+                }
+            }
+
+            current = next;
+        }
+        self.head.store(ptr::null_mut(), Ordering::Relaxed);
+
+        callbacks
     }
 
-    fn get_weak_references(&self) -> Vec<PyRef<PyWeak>> {
-        let inner = match self.try_lock() {
-            Some(inner) => inner,
-            None => return vec![],
-        };
-        let mut v = Vec::with_capacity(inner.ref_count - 1);
-        v.extend(inner.iter().map(|wr| wr.to_owned()));
-        v
+    fn count(&self, obj: &PyObject) -> usize {
+        let _lock = weakref_lock::lock(obj as *const PyObject as usize);
+        let mut count = 0usize;
+        let mut current = NonNull::new(self.head.load(Ordering::Relaxed));
+        while let Some(node) = current {
+            if unsafe { node.as_ref() }.0.ref_count.get() > 0 {
+                count += 1;
+            }
+            current = unsafe { WeakLink::pointers(node).as_ref().get_next() };
+        }
+        count
     }
-}
 
-impl WeakListInner {
-    fn iter(&self) -> impl Iterator<Item = &Py<PyWeak>> {
-        self.list.iter().filter(|wr| wr.0.ref_count.get() > 0)
+    fn get_weak_references(&self, obj: &PyObject) -> Vec<PyRef<PyWeak>> {
+        let _lock = weakref_lock::lock(obj as *const PyObject as usize);
+        let mut v = Vec::new();
+        let mut current = NonNull::new(self.head.load(Ordering::Relaxed));
+        while let Some(node) = current {
+            let wr = unsafe { node.as_ref() };
+            if wr.0.ref_count.safe_inc() {
+                v.push(unsafe { PyRef::from_raw(wr as *const Py<PyWeak>) });
+            }
+            current = unsafe { WeakLink::pointers(node).as_ref().get_next() };
+        }
+        v
     }
 }
 
@@ -346,7 +794,6 @@ unsafe impl Link for WeakLink {
 
     #[inline(always)]
     unsafe fn from_raw(ptr: NonNull<Self::Target>) -> Self::Handle {
-        // SAFETY: requirements forwarded from caller
         unsafe { PyRef::from_raw(ptr.as_ptr()) }
     }
 
@@ -357,62 +804,91 @@ unsafe impl Link for WeakLink {
     }
 }
 
+/// PyWeakReference: each weakref holds a direct pointer to its referent.
 #[pyclass(name = "weakref", module = false)]
 #[derive(Debug)]
 pub struct PyWeak {
     pointers: Pointers<Py<PyWeak>>,
-    parent: NonNull<PyMutex<WeakListInner>>,
-    // this is treated as part of parent's mutex - you must hold that lock to access it
+    /// Direct pointer to the referent object, null when dead.
+    /// Equivalent to wr_object in PyWeakReference.
+    wr_object: PyAtomic<*mut PyObject>,
+    /// Protected by stripe lock (keyed on wr_object address).
     callback: UnsafeCell<Option<PyObjectRef>>,
     pub(crate) hash: PyAtomic<crate::common::hash::PyHash>,
 }
 
 cfg_if::cfg_if! {
     if #[cfg(feature = "threading")] {
-        #[allow(clippy::non_send_fields_in_send_ty)] // false positive?
         unsafe impl Send for PyWeak {}
         unsafe impl Sync for PyWeak {}
     }
 }
 
 impl PyWeak {
+    /// _PyWeakref_GET_REF: attempt to upgrade the weakref to a strong reference.
     pub(crate) fn upgrade(&self) -> Option<PyObjectRef> {
-        let guard = unsafe { self.parent.as_ref().lock() };
-        let obj_ptr = guard.obj?;
+        let obj_ptr = self.wr_object.load(Ordering::Acquire);
+        if obj_ptr.is_null() {
+            return None;
+        }
+
+        let _lock = weakref_lock::lock(obj_ptr as usize);
+
+        // Double-check under lock (clear may have run between our check and lock)
+        let obj_ptr = self.wr_object.load(Ordering::Relaxed);
+        if obj_ptr.is_null() {
+            return None;
+        }
+
         unsafe {
-            if !obj_ptr.as_ref().0.ref_count.safe_inc() {
+            if !(*obj_ptr).0.ref_count.safe_inc() {
                 return None;
             }
-            Some(PyObjectRef::from_raw(obj_ptr))
+            Some(PyObjectRef::from_raw(NonNull::new_unchecked(obj_ptr)))
         }
     }
 
     pub(crate) fn is_dead(&self) -> bool {
-        let guard = unsafe { self.parent.as_ref().lock() };
-        guard.obj.is_none()
+        self.wr_object.load(Ordering::Acquire).is_null()
     }
 
+    /// weakref_dealloc: remove from list if still linked.
     fn drop_inner(&self) {
-        let dealloc = {
-            let mut guard = unsafe { self.parent.as_ref().lock() };
-            let offset = std::mem::offset_of!(PyInner<Self>, payload);
-            let py_inner = (self as *const Self)
-                .cast::<u8>()
-                .wrapping_sub(offset)
-                .cast::<PyInner<Self>>();
-            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!!
-            core::mem::forget(unsafe { guard.list.remove(node_ptr) });
-            guard.ref_count -= 1;
-            if Some(node_ptr) == guard.generic_weakref {
-                guard.generic_weakref = None;
-            }
-            guard.ref_count == 0
-        };
-        if dealloc {
-            unsafe { WeakRefList::dealloc(self.parent) }
+        let obj_ptr = self.wr_object.load(Ordering::Acquire);
+        if obj_ptr.is_null() {
+            return; // Already cleared by WeakRefList::clear()
         }
+
+        let _lock = weakref_lock::lock(obj_ptr as usize);
+
+        // Double-check under lock
+        let obj_ptr = self.wr_object.load(Ordering::Relaxed);
+        if obj_ptr.is_null() {
+            return; // Cleared between our check and lock acquisition
+        }
+
+        let obj = unsafe { &*obj_ptr };
+        // Safety: if a weakref exists pointing to this object, weakref prefix must be present
+        let wrl = obj.0.weakref_list_ref().unwrap();
+
+        // Compute our Py<PyWeak> node pointer from payload address
+        let offset = std::mem::offset_of!(PyInner<Self>, payload);
+        let py_inner = (self as *const Self)
+            .cast::<u8>()
+            .wrapping_sub(offset)
+            .cast::<PyInner<Self>>();
+        let node_ptr = unsafe { NonNull::new_unchecked(py_inner as *mut Py<Self>) };
+
+        // Unlink from list
+        unsafe { unlink_weakref(wrl, node_ptr) };
+
+        // Update generic cache if this was it
+        if wrl.generic.load(Ordering::Relaxed) == node_ptr.as_ptr() {
+            wrl.generic.store(ptr::null_mut(), Ordering::Relaxed);
+        }
+
+        // Mark as dead
+        self.wr_object.store(ptr::null_mut(), Ordering::Relaxed);
     }
 }
 
@@ -420,7 +896,6 @@ impl Drop for PyWeak {
     #[inline(always)]
     fn drop(&mut self) {
         // we do NOT have actual exclusive access!
-        // no clue if doing this actually reduces chance of UB
         let me: &Self = self;
         me.drop_inner();
     }
@@ -467,24 +942,214 @@ impl InstanceDict {
     pub fn replace(&self, d: PyDictRef) -> PyDictRef {
         core::mem::replace(&mut self.d.write(), d)
     }
+
+    /// Consume the InstanceDict and return the inner PyDictRef.
+    #[inline]
+    pub fn into_inner(self) -> PyDictRef {
+        self.d.into_inner()
+    }
+}
+
+impl<T: PyPayload> PyInner<T> {
+    /// Deallocate a PyInner, handling optional prefix(es).
+    /// Layout: [ObjExt?][WeakRefList?][PyInner<T>]
+    ///
+    /// # Safety
+    /// `ptr` must be a valid pointer from `PyInner::new` and must not be used after this call.
+    unsafe fn dealloc(ptr: *mut Self) {
+        unsafe {
+            let (flags, member_count) = (*ptr).read_type_flags();
+            let has_ext =
+                flags.has_feature(crate::types::PyTypeFlags::HAS_DICT) || member_count > 0;
+            let has_weakref = flags.has_feature(crate::types::PyTypeFlags::HAS_WEAKREF);
+
+            if has_ext || has_weakref {
+                // Reconstruct the same layout used in new()
+                let mut layout = core::alloc::Layout::from_size_align(0, 1).unwrap();
+
+                if has_ext {
+                    layout = layout
+                        .extend(core::alloc::Layout::new::<ObjExt>())
+                        .unwrap()
+                        .0;
+                }
+                if has_weakref {
+                    layout = layout
+                        .extend(core::alloc::Layout::new::<WeakRefList>())
+                        .unwrap()
+                        .0;
+                }
+                let (combined, inner_offset) =
+                    layout.extend(core::alloc::Layout::new::<Self>()).unwrap();
+                let combined = combined.pad_to_align();
+
+                let alloc_ptr = (ptr as *mut u8).sub(inner_offset);
+
+                // Drop PyInner (payload, typ, etc.)
+                core::ptr::drop_in_place(ptr);
+
+                // Drop ObjExt if present (dict, slots)
+                if has_ext {
+                    core::ptr::drop_in_place(alloc_ptr as *mut ObjExt);
+                }
+                // WeakRefList has no Drop (just raw pointers), no drop_in_place needed
+
+                alloc::alloc::dealloc(alloc_ptr, combined);
+            } else {
+                drop(Box::from_raw(ptr));
+            }
+        }
+    }
 }
 
 impl<T: PyPayload + core::fmt::Debug> PyInner<T> {
-    fn new(payload: T, typ: PyTypeRef, dict: Option<PyDictRef>) -> Box<Self> {
+    /// Allocate a new PyInner, optionally with prefix(es).
+    /// Returns a raw pointer to the PyInner (NOT the allocation start).
+    /// Layout: [ObjExt?][WeakRefList?][PyInner<T>]
+    fn new(payload: T, typ: PyTypeRef, dict: Option<PyDictRef>) -> *mut Self {
         let member_count = typ.slots.member_count;
-        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(),
-            payload,
-            slots: core::iter::repeat_with(|| PyRwLock::new(None))
-                .take(member_count)
-                .collect_vec()
-                .into_boxed_slice(),
-        })
+        let needs_ext = typ
+            .slots
+            .flags
+            .has_feature(crate::types::PyTypeFlags::HAS_DICT)
+            || member_count > 0;
+        let needs_weakref = typ
+            .slots
+            .flags
+            .has_feature(crate::types::PyTypeFlags::HAS_WEAKREF);
+        debug_assert!(
+            needs_ext || dict.is_none(),
+            "dict passed to type '{}' without HAS_DICT flag",
+            typ.name()
+        );
+
+        if needs_ext || needs_weakref {
+            // Build layout left-to-right: [ObjExt?][WeakRefList?][PyInner]
+            let mut layout = core::alloc::Layout::from_size_align(0, 1).unwrap();
+
+            let ext_start = if needs_ext {
+                let (combined, offset) =
+                    layout.extend(core::alloc::Layout::new::<ObjExt>()).unwrap();
+                layout = combined;
+                Some(offset)
+            } else {
+                None
+            };
+
+            let weakref_start = if needs_weakref {
+                let (combined, offset) = layout
+                    .extend(core::alloc::Layout::new::<WeakRefList>())
+                    .unwrap();
+                layout = combined;
+                Some(offset)
+            } else {
+                None
+            };
+
+            let (combined, inner_offset) =
+                layout.extend(core::alloc::Layout::new::<Self>()).unwrap();
+            let combined = combined.pad_to_align();
+
+            let alloc_ptr = unsafe { alloc::alloc::alloc(combined) };
+            if alloc_ptr.is_null() {
+                alloc::alloc::handle_alloc_error(combined);
+            }
+            // Expose provenance so ext_ref()/weakref_list_ref() can reconstruct
+            alloc_ptr.expose_provenance();
+
+            unsafe {
+                if let Some(offset) = ext_start {
+                    let ext_ptr = alloc_ptr.add(offset) as *mut ObjExt;
+                    ext_ptr.write(ObjExt::new(dict, member_count));
+                }
+
+                if let Some(offset) = weakref_start {
+                    let weakref_ptr = alloc_ptr.add(offset) as *mut WeakRefList;
+                    weakref_ptr.write(WeakRefList::new());
+                }
+
+                let inner_ptr = alloc_ptr.add(inner_offset) as *mut Self;
+                inner_ptr.write(Self {
+                    ref_count: RefCount::new(),
+                    vtable: PyObjVTable::of::<T>(),
+                    gc_bits: Radium::new(0),
+                    gc_generation: Radium::new(GC_UNTRACKED),
+                    gc_pointers: Pointers::new(),
+                    typ: PyAtomicRef::from(typ),
+                    payload,
+                });
+                inner_ptr
+            }
+        } else {
+            Box::into_raw(Box::new(Self {
+                ref_count: RefCount::new(),
+                vtable: PyObjVTable::of::<T>(),
+                gc_bits: Radium::new(0),
+                gc_generation: Radium::new(GC_UNTRACKED),
+                gc_pointers: Pointers::new(),
+                typ: PyAtomicRef::from(typ),
+                payload,
+            }))
+        }
+    }
+}
+
+/// Returns the allocation layout for `PyInner<T>`, for use in freelist Drop impls.
+pub(crate) const fn pyinner_layout<T: PyPayload>() -> core::alloc::Layout {
+    core::alloc::Layout::new::<PyInner<T>>()
+}
+
+/// Thread-local freelist storage for reusing object allocations.
+///
+/// Wraps a `Vec<*mut PyObject>`. On thread teardown, `Drop` frees raw
+/// `PyInner<T>` allocations without running payload destructors to avoid
+/// accessing already-destroyed thread-local storage (GC state, other freelists).
+pub(crate) struct FreeList<T: PyPayload> {
+    items: Vec<*mut PyObject>,
+    _marker: core::marker::PhantomData<T>,
+}
+
+impl<T: PyPayload> FreeList<T> {
+    pub(crate) const fn new() -> Self {
+        Self {
+            items: Vec::new(),
+            _marker: core::marker::PhantomData,
+        }
+    }
+}
+
+impl<T: PyPayload> Default for FreeList<T> {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl<T: PyPayload> Drop for FreeList<T> {
+    fn drop(&mut self) {
+        // During thread teardown, we cannot safely run destructors on cached
+        // objects because their Drop impls may access thread-local storage
+        // (GC state, other freelists) that is already destroyed.
+        // Instead, free just the raw allocation. The payload's heap fields
+        // (BigInt, PyObjectRef, etc.) are leaked, but this is bounded by
+        // MAX_FREELIST per type per thread.
+        for ptr in self.items.drain(..) {
+            unsafe {
+                alloc::alloc::dealloc(ptr as *mut u8, core::alloc::Layout::new::<PyInner<T>>());
+            }
+        }
+    }
+}
+
+impl<T: PyPayload> core::ops::Deref for FreeList<T> {
+    type Target = Vec<*mut PyObject>;
+    fn deref(&self) -> &Self::Target {
+        &self.items
+    }
+}
+
+impl<T: PyPayload> core::ops::DerefMut for FreeList<T> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.items
     }
 }
 
@@ -536,6 +1201,46 @@ impl ToOwned for PyObject {
     }
 }
 
+impl PyObject {
+    /// Atomically try to create a strong reference.
+    /// Returns `None` if the strong count is already 0 (object being destroyed).
+    /// Uses CAS to prevent the TOCTOU race between checking strong_count and
+    /// incrementing it.
+    #[inline]
+    pub fn try_to_owned(&self) -> Option<PyObjectRef> {
+        if self.0.ref_count.safe_inc() {
+            Some(PyObjectRef {
+                ptr: NonNull::from(self),
+            })
+        } else {
+            None
+        }
+    }
+
+    /// Like [`try_to_owned`](Self::try_to_owned), but from a raw pointer.
+    ///
+    /// Uses `addr_of!` to access `ref_count` without forming `&PyObject`,
+    /// minimizing the borrow scope when the pointer may be stale
+    /// (e.g. cache-hit paths protected by version guards).
+    ///
+    /// # Safety
+    /// `ptr` must point to a live (not yet deallocated) `PyObject`, or to
+    /// memory whose `ref_count` field is still atomically readable
+    /// (same guarantee as `_Py_TryIncRefShared`).
+    #[inline]
+    pub unsafe fn try_to_owned_from_ptr(ptr: *mut Self) -> Option<PyObjectRef> {
+        let inner = ptr.cast::<PyInner<Erased>>();
+        let ref_count = unsafe { &*core::ptr::addr_of!((*inner).ref_count) };
+        if ref_count.safe_inc() {
+            Some(PyObjectRef {
+                ptr: unsafe { NonNull::new_unchecked(ptr) },
+            })
+        } else {
+            None
+        }
+    }
+}
+
 impl PyObjectRef {
     #[inline(always)]
     pub const fn into_raw(self) -> NonNull<PyObject> {
@@ -609,9 +1314,29 @@ impl PyObjectRef {
 }
 
 impl PyObject {
+    /// Returns the WeakRefList if the type supports weakrefs (HAS_WEAKREF).
+    /// The WeakRefList is stored as a separate prefix before PyInner,
+    /// independent from ObjExt (dict/slots).
     #[inline(always)]
-    const fn weak_ref_list(&self) -> Option<&WeakRefList> {
-        Some(&self.0.weak_list)
+    fn weak_ref_list(&self) -> Option<&WeakRefList> {
+        self.0.weakref_list_ref()
+    }
+
+    /// Returns the first weakref in the weakref list, if any.
+    pub(crate) fn get_weakrefs(&self) -> Option<PyObjectRef> {
+        let wrl = self.weak_ref_list()?;
+        let _lock = weakref_lock::lock(self as *const PyObject as usize);
+        let head_ptr = wrl.head.load(Ordering::Relaxed);
+        if head_ptr.is_null() {
+            None
+        } else {
+            let head = unsafe { &*head_ptr };
+            if head.0.ref_count.safe_inc() {
+                Some(unsafe { PyRef::from_raw(head_ptr) }.into())
+            } else {
+                None
+            }
+        }
     }
 
     pub(crate) fn downgrade_with_weakref_typ_opt(
@@ -630,6 +1355,18 @@ impl PyObject {
         typ: PyTypeRef,
         vm: &VirtualMachine,
     ) -> PyResult<PyRef<PyWeak>> {
+        // Check HAS_WEAKREF flag first
+        if !self
+            .class()
+            .slots
+            .flags
+            .has_feature(crate::types::PyTypeFlags::HAS_WEAKREF)
+        {
+            return Err(vm.new_type_error(format!(
+                "cannot create weak reference to '{}' object",
+                self.class().name()
+            )));
+        }
         let dict = if typ
             .slots
             .flags
@@ -658,7 +1395,8 @@ impl PyObject {
     }
 
     pub fn get_weak_references(&self) -> Option<Vec<PyRef<PyWeak>>> {
-        self.weak_ref_list().map(|wrl| wrl.get_weak_references())
+        self.weak_ref_list()
+            .map(|wrl| wrl.get_weak_references(self))
     }
 
     #[deprecated(note = "use downcastable instead")]
@@ -713,8 +1451,8 @@ impl PyObject {
     }
 
     #[inline(always)]
-    const fn instance_dict(&self) -> Option<&InstanceDict> {
-        self.0.dict.as_ref()
+    fn instance_dict(&self) -> Option<&InstanceDict> {
+        self.0.ext_ref().and_then(|ext| ext.dict.as_ref())
     }
 
     #[inline(always)]
@@ -800,7 +1538,7 @@ impl PyObject {
 
     #[inline]
     pub fn weak_count(&self) -> Option<usize> {
-        self.weak_ref_list().map(|wrl| wrl.count())
+        self.weak_ref_list().map(|wrl| wrl.count(self))
     }
 
     #[inline(always)]
@@ -811,18 +1549,48 @@ impl PyObject {
     /// 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)
+    pub(crate) fn gc_finalized(&self) -> bool {
+        GcBits::from_bits_retain(self.0.gc_bits.load(Ordering::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);
+    pub(crate) fn set_gc_finalized(&self) {
+        self.set_gc_bit(GcBits::FINALIZED);
+    }
+
+    /// Set a GC bit atomically.
+    #[inline]
+    pub(crate) fn set_gc_bit(&self, bit: GcBits) {
+        self.0.gc_bits.fetch_or(bit.bits(), Ordering::Relaxed);
+    }
+
+    /// Get the GC generation index for this object.
+    #[inline]
+    pub(crate) fn gc_generation(&self) -> u8 {
+        self.0.gc_generation.load(Ordering::Relaxed)
+    }
+
+    /// Set the GC generation index for this object.
+    /// Must only be called while holding the generation list's write lock.
+    #[inline]
+    pub(crate) fn set_gc_generation(&self, generation: u8) {
+        self.0.gc_generation.store(generation, Ordering::Relaxed);
+    }
+
+    /// _PyObject_GC_TRACK
+    #[inline]
+    pub(crate) fn set_gc_tracked(&self) {
+        self.set_gc_bit(GcBits::TRACKED);
+    }
+
+    /// _PyObject_GC_UNTRACK
+    #[inline]
+    pub(crate) fn clear_gc_tracked(&self) {
+        self.0
+            .gc_bits
+            .fetch_and(!GcBits::TRACKED.bits(), Ordering::Relaxed);
     }
 
     #[inline(always)] // the outer function is never inlined
@@ -835,26 +1603,33 @@ impl PyObject {
             slot_del: fn(&PyObject, &VirtualMachine) -> PyResult<()>,
         ) -> Result<(), ()> {
             let ret = crate::vm::thread::with_vm(zelf, |vm| {
-                zelf.0.ref_count.inc();
+                // Temporarily resurrect (0→2) so ref_count stays positive
+                // during __del__, preventing safe_inc from seeing 0.
+                zelf.0.ref_count.inc_by(2);
+
                 if let Err(e) = slot_del(zelf, vm) {
                     let del_method = zelf.get_class_attr(identifier!(vm, __del__)).unwrap();
                     vm.run_unraisable(e, None, del_method);
                 }
+
+                // Undo the temporary resurrection. Always remove both
+                // temporary refs; the second dec returns true only when
+                // ref_count drops to 0 (no resurrection).
+                let _ = zelf.0.ref_count.dec();
                 zelf.0.ref_count.dec()
             });
             match ret {
-                // the decref right above set ref_count back to 0
+                // the decref set ref_count back to 0
                 Some(true) => Ok(()),
                 // we've been resurrected by __del__
                 Some(false) => Err(()),
-                None => {
-                    warn!("couldn't run __del__ method for object");
-                    Ok(())
-                }
+                None => Ok(()),
             }
         }
 
         // __del__ should only be called once (like _PyGC_FINALIZED check in GIL_DISABLED)
+        // We call __del__ BEFORE clearing weakrefs to allow the finalizer to access
+        // the object's weak references if needed.
         let del = self.class().slots.del.load();
         if let Some(slot_del) = del
             && !self.gc_finalized()
@@ -862,23 +1637,23 @@ impl PyObject {
             self.set_gc_finalized();
             call_slot_del(self, slot_del)?;
         }
+
+        // Clear weak refs AFTER __del__.
+        // Note: This differs from GC behavior which clears weakrefs before finalizers,
+        // but for direct deallocation (drop_slow_inner), we need to allow the finalizer
+        // to run without triggering use-after-free from WeakRefList operations.
         if let Some(wrl) = self.weak_ref_list() {
-            wrl.clear();
+            wrl.clear(self);
         }
 
         Ok(())
     }
 
-    /// Can only be called when ref_count has dropped to zero. `ptr` must be valid
+    /// _Py_Dealloc: dispatch to type's dealloc
     #[inline(never)]
     unsafe fn drop_slow(ptr: NonNull<Self>) {
-        if let Err(()) = unsafe { ptr.as_ref().drop_slow_inner() } {
-            // abort drop for whatever reason
-            return;
-        }
-        let drop_dealloc = unsafe { ptr.as_ref().0.vtable.drop_dealloc };
-        // call drop only when there are no references in scope - stacked borrows stuff
-        unsafe { drop_dealloc(ptr.as_ptr()) }
+        let dealloc = unsafe { ptr.as_ref().0.vtable.dealloc };
+        unsafe { dealloc(ptr.as_ptr()) }
     }
 
     /// # Safety
@@ -892,11 +1667,150 @@ impl PyObject {
     }
 
     pub(crate) fn get_slot(&self, offset: usize) -> Option<PyObjectRef> {
-        self.0.slots[offset].read().clone()
+        self.0.ext_ref().unwrap().slots[offset].read().clone()
     }
 
     pub(crate) fn set_slot(&self, offset: usize, value: Option<PyObjectRef>) {
-        *self.0.slots[offset].write() = value;
+        *self.0.ext_ref().unwrap().slots[offset].write() = value;
+    }
+
+    /// _PyObject_GC_IS_TRACKED
+    pub fn is_gc_tracked(&self) -> bool {
+        GcBits::from_bits_retain(self.0.gc_bits.load(Ordering::Relaxed)).contains(GcBits::TRACKED)
+    }
+
+    /// Get the referents (objects directly referenced) of this object.
+    /// Uses the full traverse including dict and slots.
+    pub fn gc_get_referents(&self) -> Vec<PyObjectRef> {
+        let mut result = Vec::new();
+        self.0.traverse(&mut |child: &PyObject| {
+            result.push(child.to_owned());
+        });
+        result
+    }
+
+    /// Call __del__ if present, without triggering object deallocation.
+    /// Used by GC to call finalizers before breaking cycles.
+    /// This allows proper resurrection detection.
+    /// PyObject_CallFinalizerFromDealloc
+    pub fn try_call_finalizer(&self) {
+        let del = self.class().slots.del.load();
+        if let Some(slot_del) = del
+            && !self.gc_finalized()
+        {
+            // Mark as finalized BEFORE calling __del__ to prevent double-call
+            // This ensures drop_slow_inner() won't call __del__ again
+            self.set_gc_finalized();
+            let result = crate::vm::thread::with_vm(self, |vm| {
+                if let Err(e) = slot_del(self, vm)
+                    && let Some(del_method) = self.get_class_attr(identifier!(vm, __del__))
+                {
+                    vm.run_unraisable(e, None, del_method);
+                }
+            });
+            let _ = result;
+        }
+    }
+
+    /// Clear weakrefs but collect callbacks instead of calling them.
+    /// This is used by GC to ensure ALL weakrefs are cleared BEFORE any callbacks run.
+    /// Returns collected callbacks as (PyRef<PyWeak>, callback) pairs.
+    // = handle_weakrefs
+    pub fn gc_clear_weakrefs_collect_callbacks(&self) -> Vec<(PyRef<PyWeak>, PyObjectRef)> {
+        if let Some(wrl) = self.weak_ref_list() {
+            wrl.clear_for_gc_collect_callbacks(self)
+        } else {
+            vec![]
+        }
+    }
+
+    /// Get raw pointers to referents without incrementing reference counts.
+    /// This is used during GC to avoid reference count manipulation.
+    /// tp_traverse visits objects without incref
+    ///
+    /// # Safety
+    /// The returned pointers are only valid as long as the object is alive
+    /// and its contents haven't been modified.
+    pub unsafe fn gc_get_referent_ptrs(&self) -> Vec<NonNull<PyObject>> {
+        let mut result = Vec::new();
+        // Traverse the entire object including dict and slots
+        self.0.traverse(&mut |child: &PyObject| {
+            result.push(NonNull::from(child));
+        });
+        result
+    }
+
+    /// Pop edges from this object for cycle breaking.
+    /// Returns extracted child references that were removed from this object (tp_clear).
+    /// This is used during garbage collection to break circular references.
+    ///
+    /// # Safety
+    /// - ptr must be a valid pointer to a PyObject
+    /// - The caller must have exclusive access (no other references exist)
+    /// - This is only safe during GC when the object is unreachable
+    pub unsafe fn gc_clear_raw(ptr: *mut PyObject) -> Vec<PyObjectRef> {
+        let mut result = Vec::new();
+        let obj = unsafe { &*ptr };
+
+        // 1. Clear payload-specific references (vtable.clear / tp_clear)
+        if let Some(clear_fn) = obj.0.vtable.clear {
+            unsafe { clear_fn(ptr, &mut result) };
+        }
+
+        // 2. Clear dict and member slots (subtype_clear)
+        // Detach the dict via Py_CLEAR(*_PyObject_GetDictPtr(self)) — NULL
+        // the pointer without clearing dict contents. The dict may still be
+        // referenced by other live objects (e.g. function.__globals__).
+        let (flags, member_count) = obj.0.read_type_flags();
+        let has_ext = flags.has_feature(crate::types::PyTypeFlags::HAS_DICT) || member_count > 0;
+        if has_ext {
+            let has_weakref = flags.has_feature(crate::types::PyTypeFlags::HAS_WEAKREF);
+            let offset = if has_weakref {
+                WEAKREF_OFFSET + EXT_OFFSET
+            } else {
+                EXT_OFFSET
+            };
+            let self_addr = (ptr as *const u8).addr();
+            let ext_ptr =
+                core::ptr::with_exposed_provenance_mut::<ObjExt>(self_addr.wrapping_sub(offset));
+            let ext = unsafe { &mut *ext_ptr };
+            if let Some(old_dict) = ext.dict.take() {
+                // Get the dict ref before dropping InstanceDict
+                let dict_ref = old_dict.into_inner();
+                result.push(dict_ref.into());
+            }
+            for slot in ext.slots.iter() {
+                if let Some(val) = slot.write().take() {
+                    result.push(val);
+                }
+            }
+        }
+
+        result
+    }
+
+    /// Clear this object for cycle breaking (tp_clear).
+    /// This version takes &self but should only be called during GC
+    /// when exclusive access is guaranteed.
+    ///
+    /// # Safety
+    /// - The caller must guarantee exclusive access (no other references exist)
+    /// - This is only safe during GC when the object is unreachable
+    pub unsafe fn gc_clear(&self) -> Vec<PyObjectRef> {
+        // SAFETY: During GC collection, this object is unreachable (gc_refs == 0),
+        // meaning no other code has a reference to it. The only references are
+        // internal cycle references which we're about to break.
+        unsafe { Self::gc_clear_raw(self as *const _ as *mut PyObject) }
+    }
+
+    /// Check if this object has clear capability (tp_clear)
+    // Py_TPFLAGS_HAVE_GC types have tp_clear
+    pub fn gc_has_clear(&self) -> bool {
+        self.0.vtable.clear.is_some()
+            || self
+                .0
+                .ext_ref()
+                .is_some_and(|ext| ext.dict.is_some() || !ext.slots.is_empty())
     }
 }
 
@@ -944,6 +1858,153 @@ impl fmt::Debug for PyObjectRef {
     }
 }
 
+const STACKREF_BORROW_TAG: usize = 1;
+
+/// A tagged stack reference to a Python object.
+///
+/// Uses the lowest bit of the pointer to distinguish owned vs borrowed:
+/// - bit 0 = 0 → **owned**: refcount was incremented; Drop will decrement.
+/// - bit 0 = 1 → **borrowed**: no refcount change; Drop is a no-op.
+///
+/// Same size as `PyObjectRef` (one pointer-width).  `PyObject` is at least
+/// 8-byte aligned, so the low bit is always available for tagging.
+///
+/// Uses `NonZeroUsize` so that `Option<PyStackRef>` has the same size as
+/// `PyStackRef` via niche optimization (matching `Option<PyObjectRef>`).
+#[repr(transparent)]
+pub struct PyStackRef {
+    bits: NonZeroUsize,
+}
+
+impl PyStackRef {
+    /// Create an owned stack reference, consuming the `PyObjectRef`.
+    /// Refcount is NOT incremented — ownership is transferred.
+    #[inline(always)]
+    pub fn new_owned(obj: PyObjectRef) -> Self {
+        let ptr = obj.into_raw();
+        let bits = ptr.as_ptr() as usize;
+        debug_assert!(
+            bits & STACKREF_BORROW_TAG == 0,
+            "PyObject pointer must be aligned"
+        );
+        Self {
+            // SAFETY: valid PyObject pointers are never null
+            bits: unsafe { NonZeroUsize::new_unchecked(bits) },
+        }
+    }
+
+    /// Create a borrowed stack reference from a `&PyObject`.
+    ///
+    /// # Safety
+    /// The caller must guarantee that the pointed-to object lives at least as
+    /// long as this `PyStackRef`.  In practice the compiler guarantees that
+    /// borrowed refs are consumed within the same basic block, before any
+    /// `STORE_FAST`/`DELETE_FAST` could overwrite the source slot.
+    #[inline(always)]
+    pub unsafe fn new_borrowed(obj: &PyObject) -> Self {
+        let bits = (obj as *const PyObject as usize) | STACKREF_BORROW_TAG;
+        Self {
+            // SAFETY: valid PyObject pointers are never null, and ORing with 1 keeps it non-zero
+            bits: unsafe { NonZeroUsize::new_unchecked(bits) },
+        }
+    }
+
+    /// Whether this is a borrowed (non-owning) reference.
+    #[inline(always)]
+    pub fn is_borrowed(&self) -> bool {
+        self.bits.get() & STACKREF_BORROW_TAG != 0
+    }
+
+    /// Get a `&PyObject` reference.  Works for both owned and borrowed.
+    #[inline(always)]
+    pub fn as_object(&self) -> &PyObject {
+        unsafe { &*((self.bits.get() & !STACKREF_BORROW_TAG) as *const PyObject) }
+    }
+
+    /// Convert to an owned `PyObjectRef`.
+    ///
+    /// * If **borrowed** → increments refcount, forgets self.
+    /// * If **owned** → reconstructs `PyObjectRef` from the raw pointer, forgets self.
+    #[inline(always)]
+    pub fn to_pyobj(self) -> PyObjectRef {
+        let obj = if self.is_borrowed() {
+            self.as_object().to_owned() // inc refcount
+        } else {
+            let ptr = unsafe { NonNull::new_unchecked(self.bits.get() as *mut PyObject) };
+            unsafe { PyObjectRef::from_raw(ptr) }
+        };
+        core::mem::forget(self); // don't run Drop
+        obj
+    }
+
+    /// Promote a borrowed ref to owned **in place** (increments refcount,
+    /// clears the borrow tag).  No-op if already owned.
+    #[inline(always)]
+    pub fn promote(&mut self) {
+        if self.is_borrowed() {
+            self.as_object().0.ref_count.inc();
+            // SAFETY: clearing the low bit of a non-null pointer keeps it non-zero
+            self.bits =
+                unsafe { NonZeroUsize::new_unchecked(self.bits.get() & !STACKREF_BORROW_TAG) };
+        }
+    }
+}
+
+impl Drop for PyStackRef {
+    #[inline]
+    fn drop(&mut self) {
+        if !self.is_borrowed() {
+            // Owned: decrement refcount (potentially deallocate).
+            let ptr = unsafe { NonNull::new_unchecked(self.bits.get() as *mut PyObject) };
+            drop(unsafe { PyObjectRef::from_raw(ptr) });
+        }
+        // Borrowed: nothing to do.
+    }
+}
+
+impl core::ops::Deref for PyStackRef {
+    type Target = PyObject;
+
+    #[inline(always)]
+    fn deref(&self) -> &PyObject {
+        self.as_object()
+    }
+}
+
+impl Clone for PyStackRef {
+    /// Cloning always produces an **owned** reference (increments refcount).
+    #[inline(always)]
+    fn clone(&self) -> Self {
+        Self::new_owned(self.as_object().to_owned())
+    }
+}
+
+impl fmt::Debug for PyStackRef {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        if self.is_borrowed() {
+            write!(f, "PyStackRef(borrowed, ")?;
+        } else {
+            write!(f, "PyStackRef(owned, ")?;
+        }
+        self.as_object().fmt(f)?;
+        write!(f, ")")
+    }
+}
+
+cfg_if::cfg_if! {
+    if #[cfg(feature = "threading")] {
+        unsafe impl Send for PyStackRef {}
+        unsafe impl Sync for PyStackRef {}
+    }
+}
+
+// Ensure Option<PyStackRef> uses niche optimization and matches Option<PyObjectRef> in size
+const _: () = assert!(
+    core::mem::size_of::<Option<PyStackRef>>() == core::mem::size_of::<Option<PyObjectRef>>()
+);
+const _: () =
+    assert!(core::mem::size_of::<Option<PyStackRef>>() == core::mem::size_of::<PyStackRef>());
+
 #[repr(transparent)]
 pub struct Py<T>(PyInner<T>);
 
@@ -1111,13 +2172,56 @@ impl<T: PyPayload> PyRef<T> {
     }
 }
 
-impl<T: PyPayload + core::fmt::Debug> PyRef<T> {
+impl<T: PyPayload + crate::object::MaybeTraverse + 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));
-        Self {
-            ptr: unsafe { NonNull::new_unchecked(inner.cast::<Py<T>>()) },
+        let has_dict = dict.is_some();
+        let is_heaptype = typ.heaptype_ext.is_some();
+
+        // Try to reuse from freelist (no dict, no heaptype)
+        let cached = if !has_dict && !is_heaptype {
+            unsafe { T::freelist_pop(&payload) }
+        } else {
+            None
+        };
+
+        let ptr = if let Some(cached) = cached {
+            let inner = cached.as_ptr() as *mut PyInner<T>;
+            unsafe {
+                core::ptr::write(&mut (*inner).ref_count, RefCount::new());
+                (*inner).gc_bits.store(0, Ordering::Relaxed);
+                core::ptr::drop_in_place(&mut (*inner).payload);
+                core::ptr::write(&mut (*inner).payload, payload);
+                // Freelist only stores exact base types (push-side filter),
+                // but subtypes sharing the same Rust payload (e.g. structseq)
+                // may pop entries. Update typ if it differs.
+                let cached_typ: *const Py<PyType> = &*(*inner).typ;
+                if core::ptr::eq(cached_typ, &*typ) {
+                    drop(typ);
+                } else {
+                    let _old = (*inner).typ.swap(typ);
+                }
+            }
+            unsafe { NonNull::new_unchecked(inner.cast::<Py<T>>()) }
+        } else {
+            let inner = PyInner::new(payload, typ, dict);
+            unsafe { NonNull::new_unchecked(inner.cast::<Py<T>>()) }
+        };
+
+        // Track object if:
+        // - HAS_TRAVERSE is true (Rust payload implements Traverse), OR
+        // - has instance dict (user-defined class instances), OR
+        // - heap type (all heap type instances are GC-tracked, like Py_TPFLAGS_HAVE_GC)
+        if <T as crate::object::MaybeTraverse>::HAS_TRAVERSE || has_dict || is_heaptype {
+            let gc = crate::gc_state::gc_state();
+            unsafe {
+                gc.track_object(ptr.cast());
+            }
+            // Check if automatic GC should run
+            gc.maybe_collect();
         }
+
+        Self { ptr }
     }
 }
 
@@ -1269,7 +2373,7 @@ macro_rules! partially_init {
     ) => {{
         // check all the fields are there but *don't* actually run it
 
-        #[allow(clippy::diverging_sub_expression)]  // FIXME: better way than using `if false`?
+        #[allow(clippy::diverging_sub_expression, reason = "intentional compile-time field check in an unreachable branch")]
         if false {
             #[allow(invalid_value, dead_code, unreachable_code)]
             let _ = {$ty {
@@ -1308,6 +2412,7 @@ pub(crate) fn init_type_hierarchy() -> (PyTypeRef, PyTypeRef, PyTypeRef) {
             attributes: PyRwLock::new(Default::default()),
             slots: PyType::make_slots(),
             heaptype_ext: None,
+            tp_version_tag: core::sync::atomic::AtomicU32::new(0),
         };
         let object_payload = PyType {
             base: None,
@@ -1317,31 +2422,66 @@ pub(crate) fn init_type_hierarchy() -> (PyTypeRef, PyTypeRef, PyTypeRef) {
             attributes: PyRwLock::new(Default::default()),
             slots: object::PyBaseObject::make_slots(),
             heaptype_ext: None,
+            tp_version_tag: core::sync::atomic::AtomicU32::new(0),
+        };
+        // Both type_type and object_type are instances of `type`, which has
+        // HAS_DICT and HAS_WEAKREF, so they need both ObjExt and WeakRefList prefixes.
+        // Layout: [ObjExt][WeakRefList][PyInner<PyType>]
+        let alloc_type_with_prefixes = || -> *mut MaybeUninit<PyInner<PyType>> {
+            let inner_layout = core::alloc::Layout::new::<MaybeUninit<PyInner<PyType>>>();
+            let ext_layout = core::alloc::Layout::new::<ObjExt>();
+            let weakref_layout = core::alloc::Layout::new::<WeakRefList>();
+
+            let (layout, weakref_offset) = ext_layout.extend(weakref_layout).unwrap();
+            let (combined, inner_offset) = layout.extend(inner_layout).unwrap();
+            let combined = combined.pad_to_align();
+
+            let alloc_ptr = unsafe { alloc::alloc::alloc(combined) };
+            if alloc_ptr.is_null() {
+                alloc::alloc::handle_alloc_error(combined);
+            }
+            alloc_ptr.expose_provenance();
+
+            unsafe {
+                let ext_ptr = alloc_ptr as *mut ObjExt;
+                ext_ptr.write(ObjExt::new(None, 0));
+
+                let weakref_ptr = alloc_ptr.add(weakref_offset) as *mut WeakRefList;
+                weakref_ptr.write(WeakRefList::new());
+
+                alloc_ptr.add(inner_offset) as *mut MaybeUninit<PyInner<PyType>>
+            }
         };
-        let type_type_ptr = Box::into_raw(Box::new(partially_init!(
-            PyInner::<PyType> {
-                ref_count: RefCount::new(),
-                vtable: PyObjVTable::of::<PyType>(),
-                gc_bits: Radium::new(0),
-                dict: None,
-                weak_list: WeakRefList::new(),
-                payload: type_payload,
-                slots: Box::new([]),
-            },
-            Uninit { typ }
-        )));
-        let object_type_ptr = Box::into_raw(Box::new(partially_init!(
-            PyInner::<PyType> {
-                ref_count: RefCount::new(),
-                vtable: PyObjVTable::of::<PyType>(),
-                gc_bits: Radium::new(0),
-                dict: None,
-                weak_list: WeakRefList::new(),
-                payload: object_payload,
-                slots: Box::new([]),
-            },
-            Uninit { typ },
-        )));
+
+        let type_type_ptr = alloc_type_with_prefixes();
+        unsafe {
+            type_type_ptr.write(partially_init!(
+                PyInner::<PyType> {
+                    ref_count: RefCount::new(),
+                    vtable: PyObjVTable::of::<PyType>(),
+                    gc_bits: Radium::new(0),
+                    gc_generation: Radium::new(GC_UNTRACKED),
+                    gc_pointers: Pointers::new(),
+                    payload: type_payload,
+                },
+                Uninit { typ }
+            ));
+        }
+
+        let object_type_ptr = alloc_type_with_prefixes();
+        unsafe {
+            object_type_ptr.write(partially_init!(
+                PyInner::<PyType> {
+                    ref_count: RefCount::new(),
+                    vtable: PyObjVTable::of::<PyType>(),
+                    gc_bits: Radium::new(0),
+                    gc_generation: Radium::new(GC_UNTRACKED),
+                    gc_pointers: Pointers::new(),
+                    payload: object_payload,
+                },
+                Uninit { typ },
+            ));
+        }
 
         let object_type_ptr = object_type_ptr as *mut PyInner<PyType>;
         let type_type_ptr = type_type_ptr as *mut PyInner<PyType>;
@@ -1378,8 +2518,15 @@ pub(crate) fn init_type_hierarchy() -> (PyTypeRef, PyTypeRef, PyTypeRef) {
         attributes: PyRwLock::default(),
         slots: PyWeak::make_slots(),
         heaptype_ext: None,
+        tp_version_tag: core::sync::atomic::AtomicU32::new(0),
     };
     let weakref_type = PyRef::new_ref(weakref_type, type_type.clone(), None);
+    // Static type: untrack from GC (was tracked by new_ref because PyType has HAS_TRAVERSE)
+    unsafe {
+        crate::gc_state::gc_state()
+            .untrack_object(core::ptr::NonNull::from(weakref_type.as_object()));
+    }
+    weakref_type.as_object().clear_gc_tracked();
     // weakref's mro is [weakref, object]
     weakref_type.mro.write().insert(0, weakref_type.clone());
 
diff --git a/crates/vm/src/object/ext.rs b/crates/vm/src/object/ext.rs
index c1a5f63f85e..e39d1c7765f 100644
--- a/crates/vm/src/object/ext.rs
+++ b/crates/vm/src/object/ext.rs
@@ -289,8 +289,12 @@ impl<T: fmt::Debug> fmt::Debug for PyAtomicRef<T> {
 impl<T: PyPayload> From<PyRef<T>> for PyAtomicRef<T> {
     fn from(pyref: PyRef<T>) -> Self {
         let py = PyRef::leak(pyref);
+        let ptr = py as *const _ as *mut u8;
+        // Expose provenance so we can re-derive via with_exposed_provenance
+        // without Stacked Borrows tag restrictions during bootstrap
+        ptr.expose_provenance();
         Self {
-            inner: Radium::new(py as *const _ as *mut _),
+            inner: Radium::new(ptr),
             _phantom: Default::default(),
         }
     }
@@ -311,6 +315,14 @@ impl<T: PyPayload> Deref for PyAtomicRef<T> {
 }
 
 impl<T: PyPayload> PyAtomicRef<T> {
+    /// Load the raw pointer without creating a reference.
+    /// Avoids Stacked Borrows retag, safe for use during bootstrap
+    /// when type objects have self-referential pointers being mutated.
+    #[inline(always)]
+    pub(super) fn load_raw(&self) -> *const Py<T> {
+        self.inner.load(Ordering::Relaxed).cast::<Py<T>>()
+    }
+
     /// # Safety
     /// The caller is responsible to keep the returned PyRef alive
     /// until no more reference can be used via PyAtomicRef::deref()
@@ -343,11 +355,19 @@ impl<T: PyPayload> From<Option<PyRef<T>>> for PyAtomicRef<Option<T>> {
 
 impl<T: PyPayload> PyAtomicRef<Option<T>> {
     pub fn deref(&self) -> Option<&Py<T>> {
-        unsafe { self.inner.load(Ordering::Relaxed).cast::<Py<T>>().as_ref() }
+        self.deref_ordering(Ordering::Relaxed)
+    }
+
+    pub fn deref_ordering(&self, ordering: Ordering) -> Option<&Py<T>> {
+        unsafe { self.inner.load(ordering).cast::<Py<T>>().as_ref() }
     }
 
     pub fn to_owned(&self) -> Option<PyRef<T>> {
-        self.deref().map(|x| x.to_owned())
+        self.to_owned_ordering(Ordering::Relaxed)
+    }
+
+    pub fn to_owned_ordering(&self, ordering: Ordering) -> Option<PyRef<T>> {
+        self.deref_ordering(ordering).map(|x| x.to_owned())
     }
 
     /// # Safety
@@ -429,16 +449,19 @@ impl From<Option<PyObjectRef>> for PyAtomicRef<Option<PyObject>> {
 
 impl PyAtomicRef<Option<PyObject>> {
     pub fn deref(&self) -> Option<&PyObject> {
-        unsafe {
-            self.inner
-                .load(Ordering::Relaxed)
-                .cast::<PyObject>()
-                .as_ref()
-        }
+        self.deref_ordering(Ordering::Relaxed)
+    }
+
+    pub fn deref_ordering(&self, ordering: Ordering) -> Option<&PyObject> {
+        unsafe { self.inner.load(ordering).cast::<PyObject>().as_ref() }
     }
 
     pub fn to_owned(&self) -> Option<PyObjectRef> {
-        self.deref().map(|x| x.to_owned())
+        self.to_owned_ordering(Ordering::Relaxed)
+    }
+
+    pub fn to_owned_ordering(&self, ordering: Ordering) -> Option<PyObjectRef> {
+        self.deref_ordering(ordering).map(|x| x.to_owned())
     }
 
     /// # Safety
@@ -463,6 +486,64 @@ impl PyAtomicRef<Option<PyObject>> {
     }
 }
 
+/// Atomic borrowed (non-ref-counted) optional reference to a Python object.
+/// Unlike `PyAtomicRef`, this does NOT own the reference.
+/// The pointed-to object must outlive this reference.
+pub struct PyAtomicBorrow {
+    inner: PyAtomic<*mut u8>,
+}
+
+// Safety: Access patterns ensure the pointed-to object outlives this reference.
+// The owner (generator/coroutine) clears this in its Drop impl before deallocation.
+unsafe impl Send for PyAtomicBorrow {}
+unsafe impl Sync for PyAtomicBorrow {}
+
+impl PyAtomicBorrow {
+    pub fn new() -> Self {
+        Self {
+            inner: Radium::new(null_mut()),
+        }
+    }
+
+    pub fn store(&self, obj: &PyObject) {
+        let ptr = obj as *const PyObject as *mut u8;
+        Radium::store(&self.inner, ptr, Ordering::Relaxed);
+    }
+
+    pub fn load(&self) -> Option<&PyObject> {
+        let ptr = Radium::load(&self.inner, Ordering::Relaxed);
+        if ptr.is_null() {
+            None
+        } else {
+            Some(unsafe { &*(ptr as *const PyObject) })
+        }
+    }
+
+    pub fn clear(&self) {
+        Radium::store(&self.inner, null_mut(), Ordering::Relaxed);
+    }
+
+    pub fn to_owned(&self) -> Option<PyObjectRef> {
+        self.load().map(|obj| obj.to_owned())
+    }
+}
+
+impl Default for PyAtomicBorrow {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl fmt::Debug for PyAtomicBorrow {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(
+            f,
+            "PyAtomicBorrow({:?})",
+            Radium::load(&self.inner, Ordering::Relaxed)
+        )
+    }
+}
+
 pub trait AsObject
 where
     Self: Borrow<PyObject>,
diff --git a/crates/vm/src/object/mod.rs b/crates/vm/src/object/mod.rs
index a279201a0b0..56db97aef1d 100644
--- a/crates/vm/src/object/mod.rs
+++ b/crates/vm/src/object/mod.rs
@@ -8,4 +8,5 @@ pub use self::core::*;
 pub use self::ext::*;
 pub use self::payload::*;
 pub(crate) use core::SIZEOF_PYOBJECT_HEAD;
+pub(crate) use core::{GC_PERMANENT, GC_UNTRACKED, GcLink};
 pub use traverse::{MaybeTraverse, Traverse, TraverseFn};
diff --git a/crates/vm/src/object/payload.rs b/crates/vm/src/object/payload.rs
index 98c61817568..a615123c680 100644
--- a/crates/vm/src/object/payload.rs
+++ b/crates/vm/src/object/payload.rs
@@ -5,6 +5,7 @@ use crate::{
     types::PyTypeFlags,
     vm::{Context, VirtualMachine},
 };
+use core::ptr::NonNull;
 
 cfg_if::cfg_if! {
     if #[cfg(feature = "threading")] {
@@ -46,6 +47,39 @@ pub trait PyPayload: MaybeTraverse + PyThreadingConstraint + Sized + 'static {
 
     fn class(ctx: &Context) -> &'static Py<PyType>;
 
+    /// Whether this type has a freelist. Types with freelists require
+    /// immediate (non-deferred) GC untracking during dealloc to prevent
+    /// race conditions when the object is reused.
+    const HAS_FREELIST: bool = false;
+
+    /// Maximum number of objects to keep in the freelist.
+    const MAX_FREELIST: usize = 0;
+
+    /// Try to push a dead object onto this type's freelist for reuse.
+    /// Returns true if the object was stored (caller must NOT free the memory).
+    /// Called before tp_clear, so the payload is still intact.
+    ///
+    /// # Safety
+    /// `obj` must be a valid pointer to a `PyInner<Self>` with refcount 0.
+    /// The payload is still initialized and can be read for bucket selection.
+    #[inline]
+    unsafe fn freelist_push(_obj: *mut PyObject) -> bool {
+        false
+    }
+
+    /// Try to pop a pre-allocated object from this type's freelist.
+    /// The returned pointer still has the old payload; the caller must
+    /// reinitialize `ref_count`, `gc_bits`, and `payload`.
+    ///
+    /// # Safety
+    /// The returned pointer (if Some) must point to a valid `PyInner<Self>`
+    /// whose payload is still initialized from a previous allocation. The caller
+    /// will drop and overwrite `payload` before reuse.
+    #[inline]
+    unsafe fn freelist_pop(_payload: &Self) -> Option<NonNull<PyObject>> {
+        None
+    }
+
     #[inline]
     fn into_pyobject(self, vm: &VirtualMachine) -> PyObjectRef
     where
diff --git a/crates/vm/src/object/traverse.rs b/crates/vm/src/object/traverse.rs
index 367076b78e3..9a5ae324baf 100644
--- a/crates/vm/src/object/traverse.rs
+++ b/crates/vm/src/object/traverse.rs
@@ -2,7 +2,9 @@ use core::ptr::NonNull;
 
 use rustpython_common::lock::{PyMutex, PyRwLock};
 
-use crate::{AsObject, PyObject, PyObjectRef, PyRef, function::Either, object::PyObjectPayload};
+use crate::{
+    AsObject, PyObject, PyObjectRef, PyRef, PyStackRef, function::Either, object::PyObjectPayload,
+};
 
 pub type TraverseFn<'a> = dyn FnMut(&PyObject) + 'a;
 
@@ -45,6 +47,12 @@ unsafe impl Traverse for PyObjectRef {
     }
 }
 
+unsafe impl Traverse for PyStackRef {
+    fn traverse(&self, traverse_fn: &mut TraverseFn<'_>) {
+        traverse_fn(self.as_object())
+    }
+}
+
 unsafe impl<T: PyObjectPayload> Traverse for PyRef<T> {
     fn traverse(&self, traverse_fn: &mut TraverseFn<'_>) {
         traverse_fn(self.as_object())
diff --git a/crates/vm/src/object/traverse_object.rs b/crates/vm/src/object/traverse_object.rs
index 840bbd42b39..f5614b3502a 100644
--- a/crates/vm/src/object/traverse_object.rs
+++ b/crates/vm/src/object/traverse_object.rs
@@ -2,10 +2,10 @@ use alloc::fmt;
 use core::any::TypeId;
 
 use crate::{
-    PyObject,
+    PyObject, PyObjectRef,
     object::{
-        Erased, InstanceDict, MaybeTraverse, PyInner, PyObjectPayload, debug_obj, drop_dealloc_obj,
-        try_traverse_obj,
+        Erased, InstanceDict, MaybeTraverse, PyInner, PyObjectPayload, debug_obj, default_dealloc,
+        try_clear_obj, try_traverse_obj,
     },
 };
 
@@ -13,16 +13,20 @@ 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),
+    /// dealloc: handles __del__, weakref clearing, and memory free.
+    pub(in crate::object) 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<'_>)>,
+    /// Clear for circular reference resolution (tp_clear).
+    /// Called just before deallocation to extract child references.
+    pub(in crate::object) clear: Option<unsafe fn(*mut PyObject, &mut Vec<PyObjectRef>)>,
 }
 
 impl PyObjVTable {
     pub const fn of<T: PyObjectPayload>() -> &'static Self {
         &Self {
             typeid: T::PAYLOAD_TYPE_ID,
-            drop_dealloc: drop_dealloc_obj::<T>,
+            dealloc: default_dealloc::<T>,
             debug: debug_obj::<T>,
             trace: const {
                 if T::HAS_TRAVERSE {
@@ -31,6 +35,13 @@ impl PyObjVTable {
                     None
                 }
             },
+            clear: const {
+                if T::HAS_CLEAR {
+                    Some(try_clear_obj::<T>)
+                } else {
+                    None
+                }
+            },
         }
     }
 }
@@ -44,12 +55,21 @@ unsafe impl Traverse for InstanceDict {
 unsafe impl Traverse for PyInner<Erased> {
     /// Because PyObject hold a `PyInner<Erased>`, so we need to trace it
     fn traverse(&self, tracer_fn: &mut TraverseFn<'_>) {
-        // 1. trace `dict` and `slots` field(`typ` can't trace for it's a AtomicRef while is leaked by design)
-        // 2. call vtable's trace function to trace payload
-        // self.typ.trace(tracer_fn);
-        self.dict.traverse(tracer_fn);
-        // weak_list keeps a *pointer* to a struct for maintenance of weak ref, so no ownership, no trace
-        self.slots.traverse(tracer_fn);
+        // For heap type instances, traverse the type reference.
+        // PyAtomicRef holds a strong reference (via PyRef::leak), so GC must
+        // account for it to correctly detect instance ↔ type cycles.
+        // Static types are always alive and don't need this.
+        let typ = &*self.typ;
+        if typ.heaptype_ext.is_some() {
+            // Safety: Py<PyType> and PyObject share the same memory layout
+            let typ_obj: &PyObject = unsafe { &*(typ as *const _ as *const PyObject) };
+            tracer_fn(typ_obj);
+        }
+        // Traverse ObjExt prefix fields (dict and slots) if present
+        if let Some(ext) = self.ext_ref() {
+            ext.dict.traverse(tracer_fn);
+            ext.slots.traverse(tracer_fn);
+        }
 
         if let Some(f) = self.vtable.trace {
             unsafe {
@@ -63,13 +83,17 @@ unsafe impl Traverse for PyInner<Erased> {
 unsafe impl<T: MaybeTraverse> Traverse for PyInner<T> {
     /// Type is known, so we can call `try_trace` directly instead of using erased type vtable
     fn traverse(&self, tracer_fn: &mut TraverseFn<'_>) {
-        // 1. trace `dict` and `slots` field(`typ` can't trace for it's a AtomicRef while is leaked by design)
-        // 2. call corresponding `try_trace` function to trace payload
-        // (No need to call vtable's trace function because we already know the type)
-        // self.typ.trace(tracer_fn);
-        self.dict.traverse(tracer_fn);
-        // weak_list keeps a *pointer* to a struct for maintenance of weak ref, so no ownership, no trace
-        self.slots.traverse(tracer_fn);
+        // For heap type instances, traverse the type reference (same as erased version)
+        let typ = &*self.typ;
+        if typ.heaptype_ext.is_some() {
+            let typ_obj: &PyObject = unsafe { &*(typ as *const _ as *const PyObject) };
+            tracer_fn(typ_obj);
+        }
+        // Traverse ObjExt prefix fields (dict and slots) if present
+        if let Some(ext) = self.ext_ref() {
+            ext.dict.traverse(tracer_fn);
+            ext.slots.traverse(tracer_fn);
+        }
         T::try_traverse(&self.payload, tracer_fn);
     }
 }
diff --git a/crates/vm/src/ospath.rs b/crates/vm/src/ospath.rs
index 25fcafb74c5..d3123a87acb 100644
--- a/crates/vm/src/ospath.rs
+++ b/crates/vm/src/ospath.rs
@@ -1,8 +1,9 @@
 use rustpython_common::crt_fd;
 
 use crate::{
-    PyObjectRef, PyResult, VirtualMachine,
+    AsObject, PyObjectRef, PyResult, VirtualMachine,
     builtins::{PyBytes, PyStr},
+    class::StaticType,
     convert::{IntoPyException, ToPyException, ToPyObject, TryFromObject},
     function::FsPath,
 };
@@ -80,6 +81,18 @@ impl PathConverter {
     ) -> PyResult<OsPathOrFd<'fd>> {
         // Handle fd (before __fspath__ check, like CPython)
         if let Some(int) = obj.try_index_opt(vm) {
+            // Warn if bool is used as a file descriptor
+            if obj
+                .class()
+                .is(crate::builtins::bool_::PyBool::static_type())
+            {
+                crate::stdlib::_warnings::warn(
+                    vm.ctx.exceptions.runtime_warning,
+                    "bool is used as a file descriptor".to_owned(),
+                    1,
+                    vm,
+                )?;
+            }
             let fd = int?.try_to_primitive(vm)?;
             return unsafe { crt_fd::Borrowed::try_borrow_raw(fd) }
                 .map(OsPathOrFd::Fd)
@@ -314,4 +327,21 @@ impl crate::exceptions::OSErrorBuilder {
         let builder = builder.filename(filename.into().filename(vm));
         builder.build(vm).upcast()
     }
+
+    /// Like `with_filename`, but strips winerror on Windows.
+    /// Use for C runtime errors (open, fstat, etc.) that should produce
+    /// `[Errno X]` format instead of `[WinError X]`.
+    #[must_use]
+    pub(crate) fn with_filename_from_errno<'a>(
+        error: &std::io::Error,
+        filename: impl Into<OsPathOrFd<'a>>,
+        vm: &VirtualMachine,
+    ) -> crate::builtins::PyBaseExceptionRef {
+        use crate::exceptions::ToOSErrorBuilder;
+        let builder = error.to_os_error_builder(vm);
+        #[cfg(windows)]
+        let builder = builder.without_winerror();
+        let builder = builder.filename(filename.into().filename(vm));
+        builder.build(vm).upcast()
+    }
 }
diff --git a/crates/vm/src/protocol/callable.rs b/crates/vm/src/protocol/callable.rs
index fa5e48d58ba..6ff988abbe6 100644
--- a/crates/vm/src/protocol/callable.rs
+++ b/crates/vm/src/protocol/callable.rs
@@ -1,7 +1,8 @@
 use crate::{
+    builtins::{PyBoundMethod, PyFunction},
     function::{FuncArgs, IntoFuncArgs},
-    types::GenericMethod,
-    {AsObject, PyObject, PyResult, VirtualMachine},
+    types::{GenericMethod, VectorCallFunc},
+    {PyObject, PyObjectRef, PyResult, VirtualMachine},
 };
 
 impl PyObject {
@@ -32,33 +33,141 @@ impl PyObject {
         vm_trace!("Invoke: {:?} {:?}", callable, args);
         callable.invoke(args, vm)
     }
+
+    /// Vectorcall: call with owned positional args + optional kwnames.
+    /// Falls back to FuncArgs-based call if no vectorcall slot.
+    #[inline]
+    pub fn vectorcall(
+        &self,
+        args: Vec<PyObjectRef>,
+        nargs: usize,
+        kwnames: Option<&[PyObjectRef]>,
+        vm: &VirtualMachine,
+    ) -> PyResult {
+        let Some(callable) = self.to_callable() else {
+            return Err(
+                vm.new_type_error(format!("'{}' object is not callable", self.class().name()))
+            );
+        };
+        callable.invoke_vectorcall(args, nargs, kwnames, vm)
+    }
 }
 
 #[derive(Debug)]
 pub struct PyCallable<'a> {
     pub obj: &'a PyObject,
     pub call: GenericMethod,
+    pub vectorcall: Option<VectorCallFunc>,
 }
 
 impl<'a> PyCallable<'a> {
     pub fn new(obj: &'a PyObject) -> Option<Self> {
-        let call = obj.class().slots.call.load()?;
-        Some(PyCallable { obj, call })
+        let slots = &obj.class().slots;
+        let call = slots.call.load()?;
+        let vectorcall = slots.vectorcall.load();
+        Some(PyCallable {
+            obj,
+            call,
+            vectorcall,
+        })
     }
 
     pub fn invoke(&self, args: impl IntoFuncArgs, vm: &VirtualMachine) -> PyResult {
         let args = args.into_args(vm);
-        vm.trace_event(TraceEvent::Call)?;
-        let result = (self.call)(self.obj, args, vm);
-        vm.trace_event(TraceEvent::Return)?;
-        result
+        if !vm.use_tracing.get() {
+            return (self.call)(self.obj, args, vm);
+        }
+        // Python functions get 'call'/'return' events from with_frame().
+        // Bound methods delegate to the inner callable, which fires its own events.
+        // All other callables (built-in functions, etc.) get 'c_call'/'c_return'/'c_exception'.
+        let is_python_callable = self.obj.downcast_ref::<PyFunction>().is_some()
+            || self.obj.downcast_ref::<PyBoundMethod>().is_some();
+        if is_python_callable {
+            (self.call)(self.obj, args, vm)
+        } else {
+            let callable = self.obj.to_owned();
+            vm.trace_event(TraceEvent::CCall, Some(callable.clone()))?;
+            let result = (self.call)(self.obj, args, vm);
+            if result.is_ok() {
+                vm.trace_event(TraceEvent::CReturn, Some(callable))?;
+            } else {
+                let _ = vm.trace_event(TraceEvent::CException, Some(callable));
+            }
+            result
+        }
+    }
+
+    /// Vectorcall dispatch: use vectorcall slot if available, else fall back to FuncArgs.
+    #[inline]
+    pub fn invoke_vectorcall(
+        &self,
+        args: Vec<PyObjectRef>,
+        nargs: usize,
+        kwnames: Option<&[PyObjectRef]>,
+        vm: &VirtualMachine,
+    ) -> PyResult {
+        if let Some(vc) = self.vectorcall {
+            if !vm.use_tracing.get() {
+                return vc(self.obj, args, nargs, kwnames, vm);
+            }
+            let is_python_callable = self.obj.downcast_ref::<PyFunction>().is_some()
+                || self.obj.downcast_ref::<PyBoundMethod>().is_some();
+            if is_python_callable {
+                vc(self.obj, args, nargs, kwnames, vm)
+            } else {
+                let callable = self.obj.to_owned();
+                vm.trace_event(TraceEvent::CCall, Some(callable.clone()))?;
+                let result = vc(self.obj, args, nargs, kwnames, vm);
+                if result.is_ok() {
+                    vm.trace_event(TraceEvent::CReturn, Some(callable))?;
+                } else {
+                    let _ = vm.trace_event(TraceEvent::CException, Some(callable));
+                }
+                result
+            }
+        } else {
+            // Fallback: convert owned Vec to FuncArgs (move, no clone)
+            let func_args = FuncArgs::from_vectorcall_owned(args, nargs, kwnames);
+            self.invoke(func_args, vm)
+        }
     }
 }
 
 /// Trace events for sys.settrace and sys.setprofile.
-enum TraceEvent {
+pub(crate) enum TraceEvent {
     Call,
     Return,
+    Exception,
+    Line,
+    Opcode,
+    CCall,
+    CReturn,
+    CException,
+}
+
+impl TraceEvent {
+    /// Whether sys.settrace receives this event.
+    fn is_trace_event(&self) -> bool {
+        matches!(
+            self,
+            Self::Call | Self::Return | Self::Exception | Self::Line | Self::Opcode
+        )
+    }
+
+    /// Whether sys.setprofile receives this event.
+    /// In legacy_tracing.c, profile callbacks are only registered for
+    /// PY_RETURN, PY_UNWIND, C_CALL, C_RETURN, C_RAISE.
+    fn is_profile_event(&self) -> bool {
+        matches!(
+            self,
+            Self::Call | Self::Return | Self::CCall | Self::CReturn | Self::CException
+        )
+    }
+
+    /// Whether this event is dispatched only when f_trace_opcodes is set.
+    pub(crate) fn is_opcode_event(&self) -> bool {
+        matches!(self, Self::Opcode)
+    }
 }
 
 impl core::fmt::Display for TraceEvent {
@@ -67,48 +176,92 @@ impl core::fmt::Display for TraceEvent {
         match self {
             Call => write!(f, "call"),
             Return => write!(f, "return"),
+            Exception => write!(f, "exception"),
+            Line => write!(f, "line"),
+            Opcode => write!(f, "opcode"),
+            CCall => write!(f, "c_call"),
+            CReturn => write!(f, "c_return"),
+            CException => write!(f, "c_exception"),
         }
     }
 }
 
 impl VirtualMachine {
     /// Call registered trace function.
+    ///
+    /// Returns the trace function's return value:
+    /// - `Some(obj)` if the trace function returned a non-None value
+    /// - `None` if it returned Python None or no trace function was active
+    ///
+    /// In CPython's trace protocol:
+    /// - For 'call' events: the return value determines the per-frame `f_trace`
+    /// - For 'line'/'return' events: the return value can update `f_trace`
     #[inline]
-    fn trace_event(&self, event: TraceEvent) -> PyResult<()> {
+    pub(crate) fn trace_event(
+        &self,
+        event: TraceEvent,
+        arg: Option<PyObjectRef>,
+    ) -> PyResult<Option<PyObjectRef>> {
         if self.use_tracing.get() {
-            self._trace_event_inner(event)
+            self._trace_event_inner(event, arg)
         } else {
-            Ok(())
+            Ok(None)
         }
     }
-    fn _trace_event_inner(&self, event: TraceEvent) -> PyResult<()> {
+    fn _trace_event_inner(
+        &self,
+        event: TraceEvent,
+        arg: Option<PyObjectRef>,
+    ) -> PyResult<Option<PyObjectRef>> {
         let trace_func = self.trace_func.borrow().to_owned();
         let profile_func = self.profile_func.borrow().to_owned();
         if self.is_none(&trace_func) && self.is_none(&profile_func) {
-            return Ok(());
+            return Ok(None);
         }
 
-        let frame_ref = self.current_frame();
-        if frame_ref.is_none() {
-            return Ok(());
+        let is_trace_event = event.is_trace_event();
+        let is_profile_event = event.is_profile_event();
+        let is_opcode_event = event.is_opcode_event();
+
+        let Some(frame_ref) = self.current_frame() else {
+            return Ok(None);
+        };
+
+        // Opcode events are only dispatched when f_trace_opcodes is set.
+        if is_opcode_event && !*frame_ref.trace_opcodes.lock() {
+            return Ok(None);
         }
 
-        let frame = frame_ref.unwrap().as_object().to_owned();
+        let frame: PyObjectRef = frame_ref.into();
         let event = self.ctx.new_str(event.to_string()).into();
-        let args = vec![frame, event, self.ctx.none()];
+        let args = vec![frame, event, arg.unwrap_or_else(|| self.ctx.none())];
+
+        let mut trace_result = None;
 
         // temporarily disable tracing, during the call to the
         // tracing function itself.
-        if !self.is_none(&trace_func) {
+        if is_trace_event && !self.is_none(&trace_func) {
             self.use_tracing.set(false);
             let res = trace_func.call(args.clone(), self);
             self.use_tracing.set(true);
-            if res.is_err() {
-                *self.trace_func.borrow_mut() = self.ctx.none();
+            match res {
+                Ok(result) => {
+                    if !self.is_none(&result) {
+                        trace_result = Some(result);
+                    }
+                }
+                Err(e) => {
+                    // trace_trampoline behavior: clear per-frame f_trace
+                    // and propagate the error.
+                    if let Some(frame_ref) = self.current_frame() {
+                        *frame_ref.trace.lock() = self.ctx.none();
+                    }
+                    return Err(e);
+                }
             }
         }
 
-        if !self.is_none(&profile_func) {
+        if is_profile_event && !self.is_none(&profile_func) {
             self.use_tracing.set(false);
             let res = profile_func.call(args, self);
             self.use_tracing.set(true);
@@ -116,6 +269,6 @@ impl VirtualMachine {
                 *self.profile_func.borrow_mut() = self.ctx.none();
             }
         }
-        Ok(())
+        Ok(trace_result)
     }
 }
diff --git a/crates/vm/src/protocol/mod.rs b/crates/vm/src/protocol/mod.rs
index 6eb2909f167..411aa4dfad3 100644
--- a/crates/vm/src/protocol/mod.rs
+++ b/crates/vm/src/protocol/mod.rs
@@ -8,6 +8,7 @@ mod sequence;
 
 pub use buffer::{BufferDescriptor, BufferMethods, BufferResizeGuard, PyBuffer, VecBuffer};
 pub use callable::PyCallable;
+pub(crate) use callable::TraceEvent;
 pub use iter::{PyIter, PyIterIter, PyIterReturn};
 pub use mapping::{PyMapping, PyMappingMethods, PyMappingSlots};
 pub use number::{
diff --git a/crates/vm/src/protocol/number.rs b/crates/vm/src/protocol/number.rs
index 542afce2c6c..eaf04d9a065 100644
--- a/crates/vm/src/protocol/number.rs
+++ b/crates/vm/src/protocol/number.rs
@@ -11,7 +11,7 @@ use crate::{
     common::int::{BytesToIntError, bytes_to_int},
     function::ArgBytesLike,
     object::{Traverse, TraverseFn},
-    stdlib::warnings,
+    stdlib::_warnings,
 };
 
 pub type PyNumberUnaryFunc<R = PyObjectRef> = fn(PyNumber<'_>, &VirtualMachine) -> PyResult<R>;
@@ -59,7 +59,7 @@ impl PyObject {
         } 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(
+            _warnings::warn(
                 vm.ctx.exceptions.deprecation_warning,
                 "The delegation of int() to __trunc__ is deprecated.".to_owned(),
                 1,
@@ -200,33 +200,72 @@ impl PyNumberMethods {
     }
 }
 
+/// Matches the NB_* constants ordering from opcode.h / BinaryOperator.
 #[derive(Copy, Clone)]
 pub enum PyNumberBinaryOp {
     Add,
-    Subtract,
+    And,
+    FloorDivide,
+    Lshift,
+    MatrixMultiply,
     Multiply,
     Remainder,
-    Divmod,
-    Lshift,
+    Or,
     Rshift,
-    And,
+    Subtract,
+    TrueDivide,
     Xor,
-    Or,
     InplaceAdd,
-    InplaceSubtract,
+    InplaceAnd,
+    InplaceFloorDivide,
+    InplaceLshift,
+    InplaceMatrixMultiply,
     InplaceMultiply,
     InplaceRemainder,
-    InplaceLshift,
-    InplaceRshift,
-    InplaceAnd,
-    InplaceXor,
     InplaceOr,
-    FloorDivide,
-    TrueDivide,
-    InplaceFloorDivide,
+    InplaceRshift,
+    InplaceSubtract,
     InplaceTrueDivide,
-    MatrixMultiply,
-    InplaceMatrixMultiply,
+    InplaceXor,
+    Divmod,
+}
+
+impl PyNumberBinaryOp {
+    /// Returns `None` for in-place ops which don't have right-side variants.
+    pub fn right_method_name(
+        self,
+        vm: &VirtualMachine,
+    ) -> Option<&'static crate::builtins::PyStrInterned> {
+        use PyNumberBinaryOp::*;
+        Some(match self {
+            Add => identifier!(vm, __radd__),
+            Subtract => identifier!(vm, __rsub__),
+            Multiply => identifier!(vm, __rmul__),
+            Remainder => identifier!(vm, __rmod__),
+            Divmod => identifier!(vm, __rdivmod__),
+            Lshift => identifier!(vm, __rlshift__),
+            Rshift => identifier!(vm, __rrshift__),
+            And => identifier!(vm, __rand__),
+            Xor => identifier!(vm, __rxor__),
+            Or => identifier!(vm, __ror__),
+            FloorDivide => identifier!(vm, __rfloordiv__),
+            TrueDivide => identifier!(vm, __rtruediv__),
+            MatrixMultiply => identifier!(vm, __rmatmul__),
+            // In-place ops don't have right-side variants
+            InplaceAdd
+            | InplaceSubtract
+            | InplaceMultiply
+            | InplaceRemainder
+            | InplaceLshift
+            | InplaceRshift
+            | InplaceAnd
+            | InplaceXor
+            | InplaceOr
+            | InplaceFloorDivide
+            | InplaceTrueDivide
+            | InplaceMatrixMultiply => return None,
+        })
+    }
 }
 
 #[derive(Copy, Clone)]
@@ -235,6 +274,19 @@ pub enum PyNumberTernaryOp {
     InplacePower,
 }
 
+impl PyNumberTernaryOp {
+    /// Returns `None` for in-place ops which don't have right-side variants.
+    pub fn right_method_name(
+        self,
+        vm: &VirtualMachine,
+    ) -> Option<&'static crate::builtins::PyStrInterned> {
+        Some(match self {
+            PyNumberTernaryOp::Power => identifier!(vm, __rpow__),
+            PyNumberTernaryOp::InplacePower => return None,
+        })
+    }
+}
+
 #[derive(Default)]
 pub struct PyNumberSlots {
     pub add: AtomicCell<Option<PyNumberBinaryFunc>>,
@@ -589,7 +641,7 @@ impl PyNumber<'_> {
 
             let ret_class = ret.class().to_owned();
             if let Some(ret) = ret.downcast_ref::<PyInt>() {
-                warnings::warn(
+                _warnings::warn(
                     vm.ctx.exceptions.deprecation_warning,
                     format!(
                         "__int__ returned non-int (type {ret_class}).  \
@@ -622,7 +674,7 @@ impl PyNumber<'_> {
 
             let ret_class = ret.class().to_owned();
             if let Some(ret) = ret.downcast_ref::<PyInt>() {
-                warnings::warn(
+                _warnings::warn(
                     vm.ctx.exceptions.deprecation_warning,
                     format!(
                         "__index__ returned non-int (type {ret_class}).  \
@@ -655,7 +707,7 @@ impl PyNumber<'_> {
 
             let ret_class = ret.class().to_owned();
             if let Some(ret) = ret.downcast_ref::<PyFloat>() {
-                warnings::warn(
+                _warnings::warn(
                     vm.ctx.exceptions.deprecation_warning,
                     format!(
                         "__float__ returned non-float (type {ret_class}).  \
diff --git a/crates/vm/src/protocol/object.rs b/crates/vm/src/protocol/object.rs
index ec1a6f55969..e59a1f15a6f 100644
--- a/crates/vm/src/protocol/object.rs
+++ b/crates/vm/src/protocol/object.rs
@@ -277,17 +277,30 @@ impl PyObject {
 
     // Perform a comparison, raising TypeError when the requested comparison
     // operator is not supported.
-    // see: CPython PyObject_RichCompare
+    // see: PyObject_RichCompare / do_richcompare
     #[inline] // called by ExecutingFrame::execute_compare with const op
     fn _cmp(
         &self,
         other: &Self,
         op: PyComparisonOp,
         vm: &VirtualMachine,
+    ) -> PyResult<Either<PyObjectRef, bool>> {
+        // Single recursion guard for the entire comparison
+        // (do_richcompare in Objects/object.c).
+        vm.with_recursion("in comparison", || self._cmp_inner(other, op, vm))
+    }
+
+    fn _cmp_inner(
+        &self,
+        other: &Self,
+        op: PyComparisonOp,
+        vm: &VirtualMachine,
     ) -> PyResult<Either<PyObjectRef, bool>> {
         let swapped = op.swapped();
         let call_cmp = |obj: &Self, other: &Self, op| {
-            let cmp = obj.class().slots.richcompare.load().unwrap();
+            let Some(cmp) = obj.class().slots.richcompare.load() else {
+                return Ok(PyArithmeticValue::NotImplemented);
+            };
             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),
@@ -302,19 +315,17 @@ impl PyObject {
             !self_class.is(other_class) && other_class.fast_issubclass(self_class)
         };
         if is_strict_subclass {
-            let res = vm.with_recursion("in comparison", || call_cmp(other, self, swapped))?;
+            let res = call_cmp(other, self, swapped)?;
             checked_reverse_op = true;
             if let PyArithmeticValue::Implemented(x) = res {
                 return Ok(x);
             }
         }
-        if let PyArithmeticValue::Implemented(x) =
-            vm.with_recursion("in comparison", || call_cmp(self, other, op))?
-        {
+        if let PyArithmeticValue::Implemented(x) = call_cmp(self, other, op)? {
             return Ok(x);
         }
         if !checked_reverse_op {
-            let res = vm.with_recursion("in comparison", || call_cmp(other, self, swapped))?;
+            let res = call_cmp(other, self, swapped)?;
             if let PyArithmeticValue::Implemented(x) = res {
                 return Ok(x);
             }
@@ -322,7 +333,12 @@ impl PyObject {
         match op {
             PyComparisonOp::Eq => Ok(Either::B(self.is(&other))),
             PyComparisonOp::Ne => Ok(Either::B(!self.is(&other))),
-            _ => Err(vm.new_unsupported_bin_op_error(self, other, op.operator_token())),
+            _ => Err(vm.new_type_error(format!(
+                "'{}' not supported between instances of '{}' and '{}'",
+                op.operator_token(),
+                self.class().name(),
+                other.class().name()
+            ))),
         }
     }
     #[inline(always)]
@@ -356,10 +372,13 @@ impl PyObject {
         })
     }
 
-    pub fn ascii(&self, vm: &VirtualMachine) -> PyResult<ascii::AsciiString> {
-        let repr = self.repr_utf8(vm)?;
-        let ascii = to_ascii(repr.as_str());
-        Ok(ascii)
+    pub fn ascii(&self, vm: &VirtualMachine) -> PyResult<PyRef<PyStr>> {
+        let repr = self.repr(vm)?;
+        if repr.as_wtf8().is_ascii() {
+            Ok(repr)
+        } else {
+            Ok(vm.ctx.new_str(to_ascii(repr.as_wtf8())))
+        }
     }
 
     pub fn str_utf8(&self, vm: &VirtualMachine) -> PyResult<PyRef<PyUtf8Str>> {
@@ -370,6 +389,13 @@ impl PyObject {
             Ok(s) => return Ok(s.into_pyref()),
             Err(obj) => obj,
         };
+        // Fast path for exact int: skip __str__ method resolution
+        let obj = match obj.downcast_exact::<PyInt>(vm) {
+            Ok(int) => {
+                return Ok(vm.ctx.new_str(int.to_str_radix_10()));
+            }
+            Err(obj) => obj,
+        };
         // TODO: replace to obj.class().slots.str
         let str_method = match vm.get_special_method(&obj, identifier!(vm, __str__))? {
             Some(str_method) => str_method,
@@ -559,15 +585,13 @@ impl PyObject {
         if let Ok(cls) = cls.try_to_ref::<PyType>(vm) {
             // PyType_Check(cls) - cls is a type object
             let mut retval = self.class().is_subtype(cls);
-            if !retval {
-                // Check __class__ attribute, only masking AttributeError
-                if let Some(i_cls) =
+            if !retval
+                && let Some(i_cls) =
                     vm.get_attribute_opt(self.to_owned(), identifier!(vm, __class__))?
-                    && let Ok(i_cls_type) = PyTypeRef::try_from_object(vm, i_cls)
-                    && !i_cls_type.is(self.class())
-                {
-                    retval = i_cls_type.is_subtype(cls);
-                }
+                && let Ok(i_cls_type) = PyTypeRef::try_from_object(vm, i_cls)
+                && !i_cls_type.is(self.class())
+            {
+                retval = i_cls_type.is_subtype(cls);
             }
             Ok(retval)
         } else {
@@ -579,7 +603,6 @@ impl PyObject {
                 )
             })?;
 
-            // Get __class__ attribute and check, only masking AttributeError
             if let Some(i_cls) =
                 vm.get_attribute_opt(self.to_owned(), identifier!(vm, __class__))?
             {
@@ -653,7 +676,7 @@ impl PyObject {
 
         Err(vm.new_exception_msg(
             vm.ctx.exceptions.type_error.to_owned(),
-            format!("unhashable type: '{}'", self.class().name()),
+            format!("unhashable type: '{}'", self.class().name()).into(),
         ))
     }
 
@@ -704,9 +727,14 @@ impl PyObject {
 
                 if let Some(class_getitem) =
                     vm.get_attribute_opt(self.to_owned(), identifier!(vm, __class_getitem__))?
+                    && !vm.is_none(&class_getitem)
                 {
                     return class_getitem.call((needle,), vm);
                 }
+                return Err(vm.new_type_error(format!(
+                    "type '{}' is not subscriptable",
+                    self.downcast_ref::<PyType>().unwrap().name()
+                )));
             }
             Err(vm.new_type_error(format!("'{}' object is not subscriptable", self.class())))
         }
diff --git a/crates/vm/src/scope.rs b/crates/vm/src/scope.rs
index 74392dc9b73..5c6d92a8deb 100644
--- a/crates/vm/src/scope.rs
+++ b/crates/vm/src/scope.rs
@@ -3,7 +3,7 @@ use alloc::fmt;
 
 #[derive(Clone)]
 pub struct Scope {
-    pub locals: ArgMapping,
+    pub locals: Option<ArgMapping>,
     pub globals: PyDictRef,
 }
 
@@ -17,7 +17,6 @@ impl fmt::Debug for Scope {
 impl Scope {
     #[inline]
     pub fn new(locals: Option<ArgMapping>, globals: PyDictRef) -> Self {
-        let locals = locals.unwrap_or_else(|| ArgMapping::from_dict_exact(globals.clone()));
         Self { locals, globals }
     }
 
@@ -31,6 +30,8 @@ impl Scope {
                 .set_item("__builtins__", vm.builtins.clone().into(), vm)
                 .unwrap();
         }
+        // For module-level code, locals defaults to globals
+        let locals = locals.or_else(|| Some(ArgMapping::from_dict_exact(globals.clone())));
         Self::new(locals, globals)
     }
 
diff --git a/crates/vm/src/signal.rs b/crates/vm/src/signal.rs
index 4a1b84a1521..3caf8cb8e30 100644
--- a/crates/vm/src/signal.rs
+++ b/crates/vm/src/signal.rs
@@ -1,34 +1,75 @@
 #![cfg_attr(target_os = "wasi", allow(dead_code))]
-use crate::{PyResult, VirtualMachine};
+use crate::{PyObjectRef, PyResult, VirtualMachine};
 use alloc::fmt;
+use core::cell::{Cell, RefCell};
+#[cfg(windows)]
+use core::sync::atomic::AtomicIsize;
 use core::sync::atomic::{AtomicBool, Ordering};
 use std::sync::mpsc;
 
 pub(crate) const NSIG: usize = 64;
+
+pub(crate) fn new_signal_handlers() -> Box<RefCell<[Option<PyObjectRef>; NSIG]>> {
+    Box::new(const { RefCell::new([const { None }; NSIG]) })
+}
 static ANY_TRIGGERED: AtomicBool = AtomicBool::new(false);
 // hack to get around const array repeat expressions, rust issue #79270
-#[allow(clippy::declare_interior_mutable_const)]
+#[allow(
+    clippy::declare_interior_mutable_const,
+    reason = "workaround for const array repeat limitation (rust issue #79270)"
+)]
 const ATOMIC_FALSE: AtomicBool = AtomicBool::new(false);
 pub(crate) static TRIGGERS: [AtomicBool; NSIG] = [ATOMIC_FALSE; NSIG];
 
+#[cfg(windows)]
+static SIGINT_EVENT: AtomicIsize = AtomicIsize::new(0);
+
+thread_local! {
+    /// Prevent recursive signal handler invocation. When a Python signal
+    /// handler is running, new signals are deferred until it completes.
+    static IN_SIGNAL_HANDLER: Cell<bool> = const { Cell::new(false) };
+}
+
+struct SignalHandlerGuard;
+
+impl Drop for SignalHandlerGuard {
+    fn drop(&mut self) {
+        IN_SIGNAL_HANDLER.with(|h| h.set(false));
+    }
+}
+
 #[cfg_attr(feature = "flame-it", flame)]
 #[inline(always)]
 pub fn check_signals(vm: &VirtualMachine) -> PyResult<()> {
-    if vm.signal_handlers.is_none() {
+    if vm.signal_handlers.get().is_none() {
         return Ok(());
     }
 
+    // Read-only check first: avoids cache-line invalidation on every
+    // instruction when no signal is pending (the common case).
+    if !ANY_TRIGGERED.load(Ordering::Relaxed) {
+        return Ok(());
+    }
+    // Atomic RMW only when a signal is actually pending.
     if !ANY_TRIGGERED.swap(false, Ordering::Acquire) {
         return Ok(());
     }
 
     trigger_signals(vm)
 }
+
 #[inline(never)]
 #[cold]
 fn trigger_signals(vm: &VirtualMachine) -> PyResult<()> {
+    if IN_SIGNAL_HANDLER.with(|h| h.replace(true)) {
+        // Already inside a signal handler — defer pending signals
+        set_triggered();
+        return Ok(());
+    }
+    let _guard = SignalHandlerGuard;
+
     // unwrap should never fail since we check above
-    let signal_handlers = vm.signal_handlers.as_ref().unwrap().borrow();
+    let signal_handlers = vm.signal_handlers.get().unwrap().borrow();
     for (signum, trigger) in TRIGGERS.iter().enumerate().skip(1) {
         let triggered = trigger.swap(false, Ordering::Relaxed);
         if triggered
@@ -50,6 +91,22 @@ pub(crate) fn set_triggered() {
     ANY_TRIGGERED.store(true, Ordering::Release);
 }
 
+#[inline(always)]
+pub(crate) fn is_triggered() -> bool {
+    ANY_TRIGGERED.load(Ordering::Relaxed)
+}
+
+/// Reset all signal trigger state after fork in child process.
+/// Stale triggers from the parent must not fire in the child.
+#[cfg(unix)]
+#[cfg(feature = "host_env")]
+pub(crate) fn clear_after_fork() {
+    ANY_TRIGGERED.store(false, Ordering::Release);
+    for trigger in &TRIGGERS {
+        trigger.store(false, Ordering::Relaxed);
+    }
+}
+
 pub fn assert_in_range(signum: i32, vm: &VirtualMachine) -> PyResult<()> {
     if (1..NSIG as i32).contains(&signum) {
         Ok(())
@@ -62,9 +119,9 @@ pub fn assert_in_range(signum: i32, vm: &VirtualMachine) -> PyResult<()> {
 ///
 /// Missing signal handler for the given signal number is silently ignored.
 #[allow(dead_code)]
-#[cfg(not(target_arch = "wasm32"))]
+#[cfg(all(not(target_arch = "wasm32"), feature = "host_env"))]
 pub fn set_interrupt_ex(signum: i32, vm: &VirtualMachine) -> PyResult<()> {
-    use crate::stdlib::signal::_signal::{SIG_DFL, SIG_IGN, run_signal};
+    use crate::stdlib::_signal::_signal::{SIG_DFL, SIG_IGN, run_signal};
     assert_in_range(signum, vm)?;
 
     match signum as usize {
@@ -118,3 +175,14 @@ pub fn user_signal_channel() -> (UserSignalSender, UserSignalReceiver) {
     let (tx, rx) = mpsc::channel();
     (UserSignalSender { tx }, UserSignalReceiver { rx })
 }
+
+#[cfg(windows)]
+pub fn set_sigint_event(handle: isize) {
+    SIGINT_EVENT.store(handle, Ordering::Release);
+}
+
+#[cfg(windows)]
+pub fn get_sigint_event() -> Option<isize> {
+    let handle = SIGINT_EVENT.load(Ordering::Acquire);
+    if handle == 0 { None } else { Some(handle) }
+}
diff --git a/crates/vm/src/stdlib/_abc.rs b/crates/vm/src/stdlib/_abc.rs
index e04566b4b2d..28b3399ec4b 100644
--- a/crates/vm/src/stdlib/_abc.rs
+++ b/crates/vm/src/stdlib/_abc.rs
@@ -15,7 +15,7 @@ mod _abc {
         protocol::PyIterReturn,
         types::Constructor,
     };
-    use std::sync::atomic::{AtomicU64, Ordering};
+    use core::sync::atomic::{AtomicU64, Ordering};
 
     // Global invalidation counter
     static ABC_INVALIDATION_COUNTER: AtomicU64 = AtomicU64::new(0);
@@ -77,7 +77,7 @@ mod _abc {
         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()))
+            .map_err(|_| vm.new_type_error("_abc_impl is set to a wrong type"))
     }
 
     /// Check if obj is in the weak set
@@ -152,12 +152,10 @@ mod _abc {
         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()))?;
+                .map_err(|_| vm.new_type_error("items() returned non-tuple"))?;
             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())
-                );
+                return Err(vm.new_type_error("items() returned item which size is not 2"));
             }
             let key = &elements[0];
             let value = &elements[1];
@@ -174,7 +172,7 @@ mod _abc {
         let bases: PyTupleRef = cls
             .get_attr("__bases__", vm)?
             .downcast()
-            .map_err(|_| vm.new_type_error("__bases__ is not a tuple".to_owned()))?;
+            .map_err(|_| vm.new_type_error("__bases__ is not a tuple"))?;
 
         for base in bases.iter() {
             if let Ok(base_abstracts) = base.get_attr("__abstractmethods__", vm) {
@@ -220,7 +218,7 @@ mod _abc {
     ) -> 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()));
+            return Err(vm.new_type_error("Can only register classes"));
         }
 
         // Check if already a subclass
@@ -230,7 +228,7 @@ mod _abc {
 
         // Check for cycles
         if cls.is_subclass(&subclass, vm)? {
-            return Err(vm.new_runtime_error("Refusing to create an inheritance cycle".to_owned()));
+            return Err(vm.new_runtime_error("Refusing to create an inheritance cycle"));
         }
 
         // Add to registry
@@ -328,7 +326,7 @@ mod _abc {
     ) -> 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()));
+            return Err(vm.new_type_error("issubclass() arg 1 must be a class"));
         }
 
         let impl_data = get_impl(&cls, vm)?;
@@ -365,7 +363,7 @@ mod _abc {
         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(),
+                "__subclasshook__ must return either False, True, or NotImplemented".into(),
             ));
         }
 
@@ -373,11 +371,11 @@ mod _abc {
         let subclass_type: PyTypeRef = subclass
             .clone()
             .downcast()
-            .map_err(|_| vm.new_type_error("expected a type object".to_owned()))?;
+            .map_err(|_| vm.new_type_error("expected a type object"))?;
         let cls_type: PyTypeRef = cls
             .clone()
             .downcast()
-            .map_err(|_| vm.new_type_error("expected a type object".to_owned()))?;
+            .map_err(|_| vm.new_type_error("expected a type object"))?;
         if subclass_type.fast_issubclass(&cls_type) {
             add_to_weak_set(&impl_data.cache, &subclass, vm)?;
             return Ok(true);
@@ -392,7 +390,7 @@ mod _abc {
         let subclasses: PyRef<PyList> = vm
             .call_method(&cls, "__subclasses__", ())?
             .downcast()
-            .map_err(|_| vm.new_type_error("__subclasses__() must return a list".to_owned()))?;
+            .map_err(|_| vm.new_type_error("__subclasses__() must return a list"))?;
 
         for scls in subclasses.borrow_vec().iter() {
             if subclass.is_subclass(scls, vm)? {
diff --git a/crates/vm/src/stdlib/_ast.rs b/crates/vm/src/stdlib/_ast.rs
new file mode 100644
index 00000000000..73819e257c1
--- /dev/null
+++ b/crates/vm/src/stdlib/_ast.rs
@@ -0,0 +1,838 @@
+//! `ast` standard module for abstract syntax trees.
+
+//!
+//! This module makes use of the parser logic, and translates all ast nodes
+//! into python ast.AST objects.
+
+pub(crate) use python::_ast::module_def;
+
+mod pyast;
+
+use crate::builtins::{PyInt, PyStr};
+use crate::stdlib::_ast::module::{Mod, ModFunctionType, ModInteractive};
+use crate::stdlib::_ast::node::BoxedSlice;
+use crate::{
+    AsObject, Context, Py, PyObject, PyObjectRef, PyPayload, PyRef, PyRefExact, PyResult,
+    TryFromObject, VirtualMachine,
+    builtins::PyIntRef,
+    builtins::{PyDict, PyModule, PyType, PyUtf8StrRef},
+    class::{PyClassImpl, StaticType},
+    compiler::{CompileError, ParseError},
+    convert::ToPyObject,
+};
+use node::Node;
+use ruff_python_ast as ast;
+use ruff_text_size::{Ranged, TextRange, TextSize};
+use rustpython_compiler_core::{
+    LineIndex, OneIndexed, PositionEncoding, SourceFile, SourceFileBuilder, SourceLocation,
+};
+
+#[cfg(feature = "parser")]
+use ruff_python_parser as parser;
+
+#[cfg(feature = "codegen")]
+use rustpython_codegen as codegen;
+
+pub(crate) use python::_ast::NodeAst;
+
+mod python;
+mod repr;
+mod validate;
+
+mod argument;
+mod basic;
+mod constant;
+mod elif_else_clause;
+mod exception;
+mod expression;
+mod module;
+mod node;
+mod operator;
+mod other;
+mod parameter;
+mod pattern;
+mod statement;
+mod string;
+mod type_ignore;
+mod type_parameters;
+
+/// Return the cached singleton instance for an operator/context node type,
+/// or create a new instance if none exists.
+fn singleton_node_to_object(vm: &VirtualMachine, node_type: &'static Py<PyType>) -> PyObjectRef {
+    if let Some(instance) = node_type.get_attr(vm.ctx.intern_str("_instance")) {
+        return instance;
+    }
+    NodeAst
+        .into_ref_with_type(vm, node_type.to_owned())
+        .unwrap()
+        .into()
+}
+
+fn get_node_field(vm: &VirtualMachine, obj: &PyObject, field: &'static str, typ: &str) -> PyResult {
+    vm.get_attribute_opt(obj.to_owned(), field)?
+        .ok_or_else(|| vm.new_type_error(format!(r#"required field "{field}" missing from {typ}"#)))
+}
+
+fn get_node_field_opt(
+    vm: &VirtualMachine,
+    obj: &PyObject,
+    field: &'static str,
+) -> PyResult<Option<PyObjectRef>> {
+    Ok(vm
+        .get_attribute_opt(obj.to_owned(), field)?
+        .filter(|obj| !vm.is_none(obj)))
+}
+
+fn get_int_field(
+    vm: &VirtualMachine,
+    obj: &PyObject,
+    field: &'static str,
+    typ: &str,
+) -> PyResult<PyRefExact<PyInt>> {
+    get_node_field(vm, obj, field, typ)?
+        .downcast_exact(vm)
+        .map_err(|_| vm.new_type_error(format!(r#"field "{field}" must have integer type"#)))
+}
+
+struct PySourceRange {
+    start: PySourceLocation,
+    end: PySourceLocation,
+}
+
+pub struct PySourceLocation {
+    row: Row,
+    column: Column,
+}
+
+impl PySourceLocation {
+    const fn to_source_location(&self) -> SourceLocation {
+        SourceLocation {
+            line: self.row.get_one_indexed(),
+            character_offset: self.column.get_one_indexed(),
+        }
+    }
+}
+
+/// A one-based index into the lines.
+#[derive(Clone, Copy)]
+struct Row(OneIndexed);
+
+impl Row {
+    const fn get(self) -> usize {
+        self.0.get()
+    }
+
+    const fn get_one_indexed(self) -> OneIndexed {
+        self.0
+    }
+}
+
+/// An UTF-8 index into the line.
+#[derive(Clone, Copy)]
+struct Column(TextSize);
+
+impl Column {
+    const fn get(self) -> usize {
+        self.0.to_usize()
+    }
+
+    const fn get_one_indexed(self) -> OneIndexed {
+        OneIndexed::from_zero_indexed(self.get())
+    }
+}
+
+fn text_range_to_source_range(source_file: &SourceFile, text_range: TextRange) -> PySourceRange {
+    let index = LineIndex::from_source_text(source_file.clone().source_text());
+    let source = &source_file.source_text();
+
+    if source.is_empty() {
+        return PySourceRange {
+            start: PySourceLocation {
+                row: Row(OneIndexed::from_zero_indexed(0)),
+                column: Column(TextSize::new(0)),
+            },
+            end: PySourceLocation {
+                row: Row(OneIndexed::from_zero_indexed(0)),
+                column: Column(TextSize::new(0)),
+            },
+        };
+    }
+
+    let start_row = index.line_index(text_range.start());
+    let end_row = index.line_index(text_range.end());
+    let start_col = text_range.start() - index.line_start(start_row, source);
+    let end_col = text_range.end() - index.line_start(end_row, source);
+
+    PySourceRange {
+        start: PySourceLocation {
+            row: Row(start_row),
+            column: Column(start_col),
+        },
+        end: PySourceLocation {
+            row: Row(end_row),
+            column: Column(end_col),
+        },
+    }
+}
+
+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,
+    object: PyObjectRef,
+    name: &str,
+) -> PyResult<TextRange> {
+    let start_row = get_int_field(vm, &object, "lineno", name)?;
+    let start_column = get_int_field(vm, &object, "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)?;
+
+    if start_row_val > end_row_val {
+        return Err(vm.new_value_error(format!(
+            "AST node line range ({}, {}) is not valid",
+            start_row_val, end_row_val
+        )));
+    }
+    if (start_row_val < 0 && end_row_val != start_row_val)
+        || (start_col_val < 0 && end_col_val != start_col_val)
+    {
+        return Err(vm.new_value_error(format!(
+            "AST node column range ({}, {}) for line range ({}, {}) is not valid",
+            start_col_val, end_col_val, start_row_val, end_row_val
+        )));
+    }
+    if start_row_val == end_row_val && start_col_val > end_col_val {
+        return Err(vm.new_value_error(format!(
+            "line {}, column {}-{} is not a valid range",
+            start_row_val, start_col_val, end_col_val
+        )));
+    }
+
+    let location = PySourceRange {
+        start: PySourceLocation {
+            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(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)),
+        },
+    };
+
+    Ok(source_range_to_text_range(source_file, location))
+}
+
+fn source_range_to_text_range(source_file: &SourceFile, location: PySourceRange) -> TextRange {
+    let index = LineIndex::from_source_text(source_file.clone().source_text());
+    let source = &source_file.source_text();
+
+    if source.is_empty() {
+        return TextRange::new(TextSize::new(0), TextSize::new(0));
+    }
+
+    let start = index.offset(
+        location.start.to_source_location(),
+        source,
+        PositionEncoding::Utf8,
+    );
+    let end = index.offset(
+        location.end.to_source_location(),
+        source,
+        PositionEncoding::Utf8,
+    );
+
+    TextRange::new(start, end)
+}
+
+fn node_add_location(
+    dict: &Py<PyDict>,
+    range: TextRange,
+    vm: &VirtualMachine,
+    source_file: &SourceFile,
+) {
+    let range = text_range_to_source_range(source_file, range);
+    dict.set_item("lineno", vm.ctx.new_int(range.start.row.get()).into(), vm)
+        .unwrap();
+    dict.set_item(
+        "col_offset",
+        vm.ctx.new_int(range.start.column.get()).into(),
+        vm,
+    )
+    .unwrap();
+    dict.set_item("end_lineno", vm.ctx.new_int(range.end.row.get()).into(), vm)
+        .unwrap();
+    dict.set_item(
+        "end_col_offset",
+        vm.ctx.new_int(range.end.column.get()).into(),
+        vm,
+    )
+    .unwrap();
+}
+
+/// Return the expected AST mod type class for a compile() mode string.
+pub(crate) fn mode_type_and_name(mode: &str) -> Option<(PyRef<PyType>, &'static str)> {
+    match mode {
+        "exec" => Some((pyast::NodeModModule::make_static_type(), "Module")),
+        "eval" => Some((pyast::NodeModExpression::make_static_type(), "Expression")),
+        "single" => Some((pyast::NodeModInteractive::make_static_type(), "Interactive")),
+        "func_type" => Some((
+            pyast::NodeModFunctionType::make_static_type(),
+            "FunctionType",
+        )),
+        _ => None,
+    }
+}
+
+/// Create an empty `arguments` AST node (no parameters).
+fn empty_arguments_object(vm: &VirtualMachine) -> PyObjectRef {
+    let node = NodeAst
+        .into_ref_with_type(vm, pyast::NodeArguments::static_type().to_owned())
+        .unwrap();
+    let dict = node.as_object().dict().unwrap();
+    for list_field in [
+        "posonlyargs",
+        "args",
+        "kwonlyargs",
+        "kw_defaults",
+        "defaults",
+    ] {
+        dict.set_item(list_field, vm.ctx.new_list(vec![]).into(), vm)
+            .unwrap();
+    }
+    for none_field in ["vararg", "kwarg"] {
+        dict.set_item(none_field, vm.ctx.none(), vm).unwrap();
+    }
+    node.into()
+}
+
+#[cfg(feature = "parser")]
+pub(crate) fn parse(
+    vm: &VirtualMachine,
+    source: &str,
+    mode: parser::Mode,
+    optimize: u8,
+    target_version: Option<ast::PythonVersion>,
+    type_comments: bool,
+) -> Result<PyObjectRef, CompileError> {
+    let source_file = SourceFileBuilder::new("".to_owned(), source.to_owned()).finish();
+    let mut options = parser::ParseOptions::from(mode);
+    let target_version = target_version.unwrap_or(ast::PythonVersion::PY314);
+    options = options.with_target_version(target_version);
+    let parsed = parser::parse(source, options).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(),
+            is_unclosed_bracket: false,
+        }
+    })?;
+
+    if let Some(error) = parsed.unsupported_syntax_errors().first() {
+        let range = text_range_to_source_range(&source_file, error.range());
+        return Err(ParseError {
+            error: parser::ParseErrorType::OtherError(error.to_string()),
+            raw_location: error.range(),
+            location: range.start.to_source_location(),
+            end_location: range.end.to_source_location(),
+            source_path: "<unknown>".to_string(),
+            is_unclosed_bracket: false,
+        }
+        .into());
+    }
+
+    let mut top = parsed.into_syntax();
+    if optimize > 0 {
+        fold_match_value_constants(&mut top);
+    }
+    if optimize >= 2 {
+        strip_docstrings(&mut top);
+    }
+    let top = match top {
+        ast::Mod::Module(m) => Mod::Module(m),
+        ast::Mod::Expression(e) => Mod::Expression(e),
+    };
+    let obj = top.ast_to_object(vm, &source_file);
+    if type_comments && obj.class().is(pyast::NodeModModule::static_type()) {
+        let type_ignores = type_ignores_from_source(vm, source)?;
+        let dict = obj.as_object().dict().unwrap();
+        dict.set_item("type_ignores", vm.ctx.new_list(type_ignores).into(), vm)
+            .unwrap();
+    }
+    Ok(obj)
+}
+
+#[cfg(feature = "parser")]
+pub(crate) fn wrap_interactive(vm: &VirtualMachine, module_obj: PyObjectRef) -> PyResult {
+    if !module_obj.class().is(pyast::NodeModModule::static_type()) {
+        return Err(vm.new_type_error("expected Module node"));
+    }
+    let body = get_node_field(vm, &module_obj, "body", "Module")?;
+    let node = NodeAst
+        .into_ref_with_type(vm, pyast::NodeModInteractive::static_type().to_owned())
+        .unwrap();
+    let dict = node.as_object().dict().unwrap();
+    dict.set_item("body", body, vm).unwrap();
+    Ok(node.into())
+}
+
+#[cfg(feature = "parser")]
+pub(crate) fn parse_func_type(
+    vm: &VirtualMachine,
+    source: &str,
+    optimize: u8,
+    target_version: Option<ast::PythonVersion>,
+) -> Result<PyObjectRef, CompileError> {
+    let _ = optimize;
+    let _ = target_version;
+    let source = source.trim();
+    let mut depth = 0i32;
+    let mut split_at = None;
+    let mut chars = source.chars().peekable();
+    let mut idx = 0usize;
+    while let Some(ch) = chars.next() {
+        match ch {
+            '(' | '[' | '{' => depth += 1,
+            ')' | ']' | '}' => depth -= 1,
+            '-' if depth == 0 && chars.peek() == Some(&'>') => {
+                split_at = Some(idx);
+                break;
+            }
+            _ => {}
+        }
+        idx += ch.len_utf8();
+    }
+
+    let Some(split_at) = split_at else {
+        return Err(ParseError {
+            error: parser::ParseErrorType::OtherError("invalid func_type".to_owned()),
+            raw_location: TextRange::default(),
+            location: SourceLocation::default(),
+            end_location: SourceLocation::default(),
+            source_path: "<unknown>".to_owned(),
+            is_unclosed_bracket: false,
+        }
+        .into());
+    };
+
+    let left = source[..split_at].trim();
+    let right = source[split_at + 2..].trim();
+
+    let parse_expr = |expr_src: &str| -> Result<ast::Expr, CompileError> {
+        let source_file = SourceFileBuilder::new("".to_owned(), expr_src.to_owned()).finish();
+        let parsed = parser::parse_expression(expr_src).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(),
+                is_unclosed_bracket: false,
+            }
+        })?;
+        Ok(*parsed.into_syntax().body)
+    };
+
+    let arg_expr = parse_expr(left)?;
+    let returns = parse_expr(right)?;
+
+    let argtypes: Vec<ast::Expr> = match arg_expr {
+        ast::Expr::Tuple(tup) => tup.elts,
+        ast::Expr::Name(_) | ast::Expr::Subscript(_) | ast::Expr::Attribute(_) => vec![arg_expr],
+        other => vec![other],
+    };
+
+    let func_type = ModFunctionType {
+        argtypes: argtypes.into_boxed_slice(),
+        returns,
+        range: TextRange::default(),
+    };
+    let source_file = SourceFileBuilder::new("".to_owned(), source.to_owned()).finish();
+    Ok(func_type.ast_to_object(vm, &source_file))
+}
+
+fn type_ignores_from_source(
+    vm: &VirtualMachine,
+    source: &str,
+) -> Result<Vec<PyObjectRef>, CompileError> {
+    let mut ignores = Vec::new();
+    for (idx, line) in source.lines().enumerate() {
+        let Some(pos) = line.find("#") else {
+            continue;
+        };
+        let comment = &line[pos + 1..];
+        let comment = comment.trim_start();
+        let Some(rest) = comment.strip_prefix("type: ignore") else {
+            continue;
+        };
+        let tag = rest.trim_start();
+        let tag = if tag.is_empty() { "" } else { tag };
+        let node = NodeAst
+            .into_ref_with_type(
+                vm,
+                pyast::NodeTypeIgnoreTypeIgnore::static_type().to_owned(),
+            )
+            .unwrap();
+        let dict = node.as_object().dict().unwrap();
+        let lineno = idx + 1;
+        dict.set_item("lineno", vm.ctx.new_int(lineno).into(), vm)
+            .unwrap();
+        dict.set_item("tag", vm.ctx.new_str(tag).into(), vm)
+            .unwrap();
+        ignores.push(node.into());
+    }
+    Ok(ignores)
+}
+
+#[cfg(feature = "parser")]
+fn fold_match_value_constants(top: &mut ast::Mod) {
+    match top {
+        ast::Mod::Module(module) => fold_stmts(&mut module.body),
+        ast::Mod::Expression(_expr) => {}
+    }
+}
+
+#[cfg(feature = "parser")]
+fn strip_docstrings(top: &mut ast::Mod) {
+    match top {
+        ast::Mod::Module(module) => strip_docstring_in_body(&mut module.body),
+        ast::Mod::Expression(_expr) => {}
+    }
+}
+
+#[cfg(feature = "parser")]
+fn strip_docstring_in_body(body: &mut Vec<ast::Stmt>) {
+    if let Some(range) = take_docstring(body)
+        && body.is_empty()
+    {
+        let start_offset = range.start();
+        let end_offset = start_offset + TextSize::from(4);
+        let pass_range = TextRange::new(start_offset, end_offset);
+        body.push(ast::Stmt::Pass(ast::StmtPass {
+            node_index: Default::default(),
+            range: pass_range,
+        }));
+    }
+    for stmt in body {
+        match stmt {
+            ast::Stmt::FunctionDef(def) => strip_docstring_in_body(&mut def.body),
+            ast::Stmt::ClassDef(def) => strip_docstring_in_body(&mut def.body),
+            _ => {}
+        }
+    }
+}
+
+#[cfg(feature = "parser")]
+fn take_docstring(body: &mut Vec<ast::Stmt>) -> Option<TextRange> {
+    let ast::Stmt::Expr(expr_stmt) = body.first()? else {
+        return None;
+    };
+    if matches!(expr_stmt.value.as_ref(), ast::Expr::StringLiteral(_)) {
+        let range = expr_stmt.range;
+        body.remove(0);
+        return Some(range);
+    }
+    None
+}
+
+#[cfg(feature = "parser")]
+fn fold_stmts(stmts: &mut [ast::Stmt]) {
+    for stmt in stmts {
+        fold_stmt(stmt);
+    }
+}
+
+#[cfg(feature = "parser")]
+fn fold_stmt(stmt: &mut ast::Stmt) {
+    use ast::Stmt;
+    match stmt {
+        Stmt::FunctionDef(def) => fold_stmts(&mut def.body),
+        Stmt::ClassDef(def) => fold_stmts(&mut def.body),
+        Stmt::For(stmt) => {
+            fold_stmts(&mut stmt.body);
+            fold_stmts(&mut stmt.orelse);
+        }
+        Stmt::While(stmt) => {
+            fold_stmts(&mut stmt.body);
+            fold_stmts(&mut stmt.orelse);
+        }
+        Stmt::If(stmt) => {
+            fold_stmts(&mut stmt.body);
+            for clause in &mut stmt.elif_else_clauses {
+                fold_stmts(&mut clause.body);
+            }
+        }
+        Stmt::With(stmt) => {
+            fold_stmts(&mut stmt.body);
+        }
+        Stmt::Try(stmt) => {
+            fold_stmts(&mut stmt.body);
+            fold_stmts(&mut stmt.orelse);
+            fold_stmts(&mut stmt.finalbody);
+        }
+        Stmt::Match(stmt) => {
+            for case in &mut stmt.cases {
+                fold_pattern(&mut case.pattern);
+                if let Some(expr) = case.guard.as_deref_mut() {
+                    fold_expr(expr);
+                }
+                fold_stmts(&mut case.body);
+            }
+        }
+        _ => {}
+    }
+}
+
+#[cfg(feature = "parser")]
+fn fold_pattern(pattern: &mut ast::Pattern) {
+    use ast::Pattern;
+    match pattern {
+        Pattern::MatchValue(value) => fold_expr(&mut value.value),
+        Pattern::MatchSequence(seq) => {
+            for pattern in &mut seq.patterns {
+                fold_pattern(pattern);
+            }
+        }
+        Pattern::MatchMapping(mapping) => {
+            for key in &mut mapping.keys {
+                fold_expr(key);
+            }
+            for pattern in &mut mapping.patterns {
+                fold_pattern(pattern);
+            }
+        }
+        Pattern::MatchClass(class) => {
+            for pattern in &mut class.arguments.patterns {
+                fold_pattern(pattern);
+            }
+            for keyword in &mut class.arguments.keywords {
+                fold_pattern(&mut keyword.pattern);
+            }
+        }
+        Pattern::MatchAs(match_as) => {
+            if let Some(pattern) = match_as.pattern.as_deref_mut() {
+                fold_pattern(pattern);
+            }
+        }
+        Pattern::MatchOr(match_or) => {
+            for pattern in &mut match_or.patterns {
+                fold_pattern(pattern);
+            }
+        }
+        Pattern::MatchSingleton(_) | Pattern::MatchStar(_) => {}
+    }
+}
+
+#[cfg(feature = "parser")]
+fn fold_expr(expr: &mut ast::Expr) {
+    use ast::Expr;
+    if let Expr::UnaryOp(unary) = expr {
+        fold_expr(&mut unary.operand);
+        if matches!(unary.op, ast::UnaryOp::USub)
+            && let Expr::NumberLiteral(number_literal) = unary.operand.as_ref()
+        {
+            let number = match &number_literal.value {
+                ast::Number::Int(value) => {
+                    if *value == ast::Int::ZERO {
+                        Some(ast::Number::Int(ast::Int::ZERO))
+                    } else {
+                        None
+                    }
+                }
+                ast::Number::Float(value) => Some(ast::Number::Float(-value)),
+                ast::Number::Complex { real, imag } => Some(ast::Number::Complex {
+                    real: -real,
+                    imag: -imag,
+                }),
+            };
+            if let Some(number) = number {
+                *expr = Expr::NumberLiteral(ast::ExprNumberLiteral {
+                    node_index: unary.node_index.clone(),
+                    range: unary.range,
+                    value: number,
+                });
+                return;
+            }
+        }
+    }
+    if let Expr::BinOp(binop) = expr {
+        fold_expr(&mut binop.left);
+        fold_expr(&mut binop.right);
+
+        let Expr::NumberLiteral(left) = binop.left.as_ref() else {
+            return;
+        };
+        let Expr::NumberLiteral(right) = binop.right.as_ref() else {
+            return;
+        };
+
+        if let Some(number) = fold_number_binop(&left.value, &binop.op, &right.value) {
+            *expr = Expr::NumberLiteral(ast::ExprNumberLiteral {
+                node_index: binop.node_index.clone(),
+                range: binop.range,
+                value: number,
+            });
+        }
+    }
+}
+
+#[cfg(feature = "parser")]
+fn fold_number_binop(
+    left: &ast::Number,
+    op: &ast::Operator,
+    right: &ast::Number,
+) -> Option<ast::Number> {
+    let (left_real, left_imag, left_is_complex) = number_to_complex(left)?;
+    let (right_real, right_imag, right_is_complex) = number_to_complex(right)?;
+
+    if !(left_is_complex || right_is_complex) {
+        return None;
+    }
+
+    match op {
+        ast::Operator::Add => Some(ast::Number::Complex {
+            real: left_real + right_real,
+            imag: left_imag + right_imag,
+        }),
+        ast::Operator::Sub => Some(ast::Number::Complex {
+            real: left_real - right_real,
+            imag: left_imag - right_imag,
+        }),
+        _ => None,
+    }
+}
+
+#[cfg(feature = "parser")]
+fn number_to_complex(number: &ast::Number) -> Option<(f64, f64, bool)> {
+    match number {
+        ast::Number::Complex { real, imag } => Some((*real, *imag, true)),
+        ast::Number::Float(value) => Some((*value, 0.0, false)),
+        ast::Number::Int(value) => value.as_i64().map(|value| (value as f64, 0.0, false)),
+    }
+}
+
+#[cfg(feature = "codegen")]
+pub(crate) fn compile(
+    vm: &VirtualMachine,
+    object: PyObjectRef,
+    filename: &str,
+    mode: crate::compiler::Mode,
+    optimize: Option<u8>,
+) -> PyResult {
+    let mut opts = vm.compile_opts();
+    if let Some(optimize) = optimize {
+        opts.optimize = optimize;
+    }
+
+    let source_file = SourceFileBuilder::new(filename.to_owned(), "".to_owned()).finish();
+    let ast: Mod = Node::ast_from_object(vm, &source_file, object)?;
+    validate::validate_mod(vm, &ast)?;
+    let ast = match ast {
+        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) => ast::Mod::Expression(e),
+        Mod::FunctionType(_) => todo!(),
+    };
+    // TODO: create a textual representation of the ast
+    let text = "";
+    let source_file = SourceFileBuilder::new(filename, text).finish();
+    let code = codegen::compile::compile_top(ast, source_file, mode, opts)
+        .map_err(|err| vm.new_syntax_error(&err.into(), None))?; // FIXME source
+    Ok(vm.ctx.new_code(code).into())
+}
+
+#[cfg(feature = "codegen")]
+pub(crate) fn validate_ast_object(vm: &VirtualMachine, object: PyObjectRef) -> PyResult<()> {
+    let source_file = SourceFileBuilder::new("<ast>".to_owned(), "".to_owned()).finish();
+    let ast: Mod = Node::ast_from_object(vm, &source_file, object)?;
+    validate::validate_mod(vm, &ast)?;
+    Ok(())
+}
+
+// Used by builtins::compile()
+pub const PY_CF_ONLY_AST: i32 = 0x0400;
+
+// The following flags match the values from Include/cpython/compile.h
+// Caveat emptor: These flags are undocumented on purpose and depending
+// on their effect outside the standard library is **unsupported**.
+pub const PY_CF_SOURCE_IS_UTF8: i32 = 0x0100;
+pub const PY_CF_DONT_IMPLY_DEDENT: i32 = 0x200;
+pub const PY_CF_IGNORE_COOKIE: i32 = 0x0800;
+pub const PY_CF_ALLOW_INCOMPLETE_INPUT: i32 = 0x4000;
+pub const PY_CF_OPTIMIZED_AST: i32 = 0x8000 | PY_CF_ONLY_AST;
+pub const PY_CF_TYPE_COMMENTS: i32 = 0x1000;
+pub const PY_CF_ALLOW_TOP_LEVEL_AWAIT: i32 = 0x2000;
+
+// __future__ flags - sync with Lib/__future__.py
+// TODO: These flags aren't being used in rust code
+//       CO_FUTURE_ANNOTATIONS does make a difference in the codegen,
+//       so it should be used in compile().
+//       see compiler/codegen/src/compile.rs
+const CO_NESTED: i32 = 0x0010;
+const CO_GENERATOR_ALLOWED: i32 = 0;
+const CO_FUTURE_DIVISION: i32 = 0x20000;
+const CO_FUTURE_ABSOLUTE_IMPORT: i32 = 0x40000;
+const CO_FUTURE_WITH_STATEMENT: i32 = 0x80000;
+const CO_FUTURE_PRINT_FUNCTION: i32 = 0x100000;
+const CO_FUTURE_UNICODE_LITERALS: i32 = 0x200000;
+const CO_FUTURE_BARRY_AS_BDFL: i32 = 0x400000;
+const CO_FUTURE_GENERATOR_STOP: i32 = 0x800000;
+const CO_FUTURE_ANNOTATIONS: i32 = 0x1000000;
+
+// Used by builtins::compile() - the summary of all flags
+pub const PY_COMPILE_FLAGS_MASK: i32 = PY_CF_ONLY_AST
+    | PY_CF_SOURCE_IS_UTF8
+    | PY_CF_DONT_IMPLY_DEDENT
+    | PY_CF_IGNORE_COOKIE
+    | PY_CF_ALLOW_TOP_LEVEL_AWAIT
+    | PY_CF_ALLOW_INCOMPLETE_INPUT
+    | PY_CF_OPTIMIZED_AST
+    | PY_CF_TYPE_COMMENTS
+    | CO_NESTED
+    | CO_GENERATOR_ALLOWED
+    | CO_FUTURE_DIVISION
+    | CO_FUTURE_ABSOLUTE_IMPORT
+    | CO_FUTURE_WITH_STATEMENT
+    | CO_FUTURE_PRINT_FUNCTION
+    | CO_FUTURE_UNICODE_LITERALS
+    | CO_FUTURE_BARRY_AS_BDFL
+    | CO_FUTURE_GENERATOR_STOP
+    | CO_FUTURE_ANNOTATIONS;
diff --git a/crates/vm/src/stdlib/ast/argument.rs b/crates/vm/src/stdlib/_ast/argument.rs
similarity index 100%
rename from crates/vm/src/stdlib/ast/argument.rs
rename to crates/vm/src/stdlib/_ast/argument.rs
diff --git a/crates/vm/src/stdlib/ast/basic.rs b/crates/vm/src/stdlib/_ast/basic.rs
similarity index 92%
rename from crates/vm/src/stdlib/ast/basic.rs
rename to crates/vm/src/stdlib/_ast/basic.rs
index 612b6144eea..28e4a6803ee 100644
--- a/crates/vm/src/stdlib/ast/basic.rs
+++ b/crates/vm/src/stdlib/_ast/basic.rs
@@ -5,7 +5,7 @@ use rustpython_compiler_core::SourceFile;
 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()
+        vm.ctx.intern_str(id).to_object()
     }
 
     fn ast_from_object(
@@ -13,7 +13,7 @@ impl Node for ast::Identifier {
         _source_file: &SourceFile,
         object: PyObjectRef,
     ) -> PyResult<Self> {
-        let py_str = PyStrRef::try_from_object(vm, object)?;
+        let py_str = PyUtf8StrRef::try_from_object(vm, object)?;
         Ok(Self::new(py_str.as_str(), TextRange::default()))
     }
 }
diff --git a/crates/vm/src/stdlib/ast/constant.rs b/crates/vm/src/stdlib/_ast/constant.rs
similarity index 91%
rename from crates/vm/src/stdlib/ast/constant.rs
rename to crates/vm/src/stdlib/_ast/constant.rs
index a6aac224585..1030a037f17 100644
--- a/crates/vm/src/stdlib/ast/constant.rs
+++ b/crates/vm/src/stdlib/_ast/constant.rs
@@ -301,31 +301,41 @@ fn constant_to_ruff_expr(value: Constant) -> ast::Expr {
             // TODO: Does this matter?
             parenthesized: true,
         }),
-        ConstantLiteral::FrozenSet(value) => ast::Expr::Call(ast::ExprCall {
-            node_index: Default::default(),
-            range,
-            // idk lol
-            func: Box::new(ast::Expr::Name(ast::ExprName {
-                node_index: Default::default(),
-                range: TextRange::default(),
-                id: ast::name::Name::new_static("frozenset"),
-                ctx: ast::ExprContext::Load,
-            })),
-            arguments: ast::Arguments {
+        ConstantLiteral::FrozenSet(value) => {
+            let args = if value.is_empty() {
+                Vec::new()
+            } else {
+                vec![ast::Expr::Set(ast::ExprSet {
+                    node_index: Default::default(),
+                    range: TextRange::default(),
+                    elts: value
+                        .into_iter()
+                        .map(|value| {
+                            constant_to_ruff_expr(Constant {
+                                range: TextRange::default(),
+                                value,
+                            })
+                        })
+                        .collect(),
+                })]
+            };
+            ast::Expr::Call(ast::ExprCall {
                 node_index: Default::default(),
                 range,
-                args: value
-                    .into_iter()
-                    .map(|value| {
-                        constant_to_ruff_expr(Constant {
-                            range: TextRange::default(),
-                            value,
-                        })
-                    })
-                    .collect(),
-                keywords: Box::default(),
-            },
-        }),
+                func: Box::new(ast::Expr::Name(ast::ExprName {
+                    node_index: Default::default(),
+                    range: TextRange::default(),
+                    id: ast::name::Name::new_static("frozenset"),
+                    ctx: ast::ExprContext::Load,
+                })),
+                arguments: ast::Arguments {
+                    node_index: Default::default(),
+                    range,
+                    args: args.into(),
+                    keywords: Box::default(),
+                },
+            })
+        }
         ConstantLiteral::Float(value) => ast::Expr::NumberLiteral(ast::ExprNumberLiteral {
             node_index: Default::default(),
             range,
diff --git a/crates/vm/src/stdlib/ast/elif_else_clause.rs b/crates/vm/src/stdlib/_ast/elif_else_clause.rs
similarity index 90%
rename from crates/vm/src/stdlib/ast/elif_else_clause.rs
rename to crates/vm/src/stdlib/_ast/elif_else_clause.rs
index b27e956077e..0afdbc02ac1 100644
--- a/crates/vm/src/stdlib/ast/elif_else_clause.rs
+++ b/crates/vm/src/stdlib/_ast/elif_else_clause.rs
@@ -29,6 +29,10 @@ pub(super) fn ast_to_object(
 
     let orelse = if let Some(next) = rest.next() {
         if next.test.is_some() {
+            let next = ast::ElifElseClause {
+                range: TextRange::new(next.range.start(), range.end()),
+                ..next
+            };
             vm.ctx
                 .new_list(vec![ast_to_object(next, rest, vm, source_file)])
                 .into()
@@ -58,7 +62,9 @@ pub(super) fn ast_from_object(
     )?;
     let range = range_from_object(vm, source_file, object, "If")?;
 
-    let elif_else_clauses = if let [ast::Stmt::If(_)] = &*orelse {
+    let elif_else_clauses = if orelse.is_empty() {
+        vec![]
+    } else if let [ast::Stmt::If(_)] = &*orelse {
         let Some(ast::Stmt::If(ast::StmtIf {
             node_index: _,
             range,
diff --git a/crates/vm/src/stdlib/ast/exception.rs b/crates/vm/src/stdlib/_ast/exception.rs
similarity index 54%
rename from crates/vm/src/stdlib/ast/exception.rs
rename to crates/vm/src/stdlib/_ast/exception.rs
index bdb8b7ad9ac..2daabecc84c 100644
--- a/crates/vm/src/stdlib/ast/exception.rs
+++ b/crates/vm/src/stdlib/_ast/exception.rs
@@ -9,22 +9,22 @@ impl Node for ast::ExceptHandler {
         }
     }
     fn ast_from_object(
-        _vm: &VirtualMachine,
+        vm: &VirtualMachine,
         source_file: &SourceFile,
-        _object: PyObjectRef,
+        object: PyObjectRef,
     ) -> PyResult<Self> {
-        let _cls = _object.class();
+        let cls = object.class();
         Ok(
-            if _cls.is(pyast::NodeExceptHandlerExceptHandler::static_type()) {
+            if cls.is(pyast::NodeExceptHandlerExceptHandler::static_type()) {
                 Self::ExceptHandler(ast::ExceptHandlerExceptHandler::ast_from_object(
-                    _vm,
+                    vm,
                     source_file,
-                    _object,
+                    object,
                 )?)
             } else {
-                return Err(_vm.new_type_error(format!(
+                return Err(vm.new_type_error(format!(
                     "expected some sort of excepthandler, but got {}",
-                    _object.repr(_vm)?
+                    object.repr(vm)?
                 )));
             },
         )
@@ -33,50 +33,50 @@ impl Node for ast::ExceptHandler {
 
 // constructor
 impl Node for ast::ExceptHandlerExceptHandler {
-    fn ast_to_object(self, _vm: &VirtualMachine, source_file: &SourceFile) -> PyObjectRef {
+    fn ast_to_object(self, vm: &VirtualMachine, source_file: &SourceFile) -> PyObjectRef {
         let Self {
             node_index: _,
             type_,
             name,
             body,
-            range: _range,
+            range,
         } = self;
         let node = NodeAst
             .into_ref_with_type(
-                _vm,
+                vm,
                 pyast::NodeExceptHandlerExceptHandler::static_type().to_owned(),
             )
             .unwrap();
         let dict = node.as_object().dict().unwrap();
-        dict.set_item("type", type_.ast_to_object(_vm, source_file), _vm)
+        dict.set_item("type", type_.ast_to_object(vm, source_file), vm)
             .unwrap();
-        dict.set_item("name", name.ast_to_object(_vm, source_file), _vm)
+        dict.set_item("name", name.ast_to_object(vm, source_file), vm)
             .unwrap();
-        dict.set_item("body", body.ast_to_object(_vm, source_file), _vm)
+        dict.set_item("body", body.ast_to_object(vm, source_file), vm)
             .unwrap();
-        node_add_location(&dict, _range, _vm, source_file);
+        node_add_location(&dict, range, vm, source_file);
         node.into()
     }
 
     fn ast_from_object(
-        _vm: &VirtualMachine,
+        vm: &VirtualMachine,
         source_file: &SourceFile,
-        _object: PyObjectRef,
+        object: PyObjectRef,
     ) -> PyResult<Self> {
         Ok(Self {
             node_index: Default::default(),
-            type_: get_node_field_opt(_vm, &_object, "type")?
-                .map(|obj| Node::ast_from_object(_vm, source_file, obj))
+            type_: get_node_field_opt(vm, &object, "type")?
+                .map(|obj| Node::ast_from_object(vm, source_file, obj))
                 .transpose()?,
-            name: get_node_field_opt(_vm, &_object, "name")?
-                .map(|obj| Node::ast_from_object(_vm, source_file, obj))
+            name: get_node_field_opt(vm, &object, "name")?
+                .map(|obj| Node::ast_from_object(vm, source_file, obj))
                 .transpose()?,
             body: Node::ast_from_object(
-                _vm,
+                vm,
                 source_file,
-                get_node_field(_vm, &_object, "body", "ExceptHandler")?,
+                get_node_field(vm, &object, "body", "ExceptHandler")?,
             )?,
-            range: range_from_object(_vm, source_file, _object, "ExceptHandler")?,
+            range: range_from_object(vm, source_file, object, "ExceptHandler")?,
         })
     }
 }
diff --git a/crates/vm/src/stdlib/ast/expression.rs b/crates/vm/src/stdlib/_ast/expression.rs
similarity index 96%
rename from crates/vm/src/stdlib/ast/expression.rs
rename to crates/vm/src/stdlib/_ast/expression.rs
index 3bf1470795d..cbc47dde9fb 100644
--- a/crates/vm/src/stdlib/ast/expression.rs
+++ b/crates/vm/src/stdlib/_ast/expression.rs
@@ -1,5 +1,5 @@
 use super::*;
-use crate::stdlib::ast::{
+use crate::stdlib::_ast::{
     argument::{merge_function_call_arguments, split_function_call_arguments},
     constant::Constant,
     string::JoinedStr,
@@ -126,6 +126,13 @@ impl Node for ast::Expr {
             Constant::ast_from_object(vm, source_file, object)?.into_expr()
         } else if cls.is(pyast::NodeExprJoinedStr::static_type()) {
             JoinedStr::ast_from_object(vm, source_file, object)?.into_expr()
+        } else if cls.is(pyast::NodeExprTemplateStr::static_type()) {
+            let template = string::TemplateStr::ast_from_object(vm, source_file, object)?;
+            return string::template_str_to_expr(vm, template);
+        } else if cls.is(pyast::NodeExprInterpolation::static_type()) {
+            let interpolation =
+                string::TStringInterpolation::ast_from_object(vm, source_file, object)?;
+            return string::interpolation_to_expr(vm, interpolation);
         } else {
             return Err(vm.new_type_error(format!(
                 "expected some sort of expr, but got {}",
@@ -327,8 +334,12 @@ impl Node for ast::ExprLambda {
             .into_ref_with_type(vm, pyast::NodeExprLambda::static_type().to_owned())
             .unwrap();
         let dict = node.as_object().dict().unwrap();
-        dict.set_item("args", parameters.ast_to_object(vm, source_file), vm)
-            .unwrap();
+        // Lambda with no parameters should have an empty arguments object, not None
+        let args = match parameters {
+            Some(params) => params.ast_to_object(vm, source_file),
+            None => empty_arguments_object(vm),
+        };
+        dict.set_item("args", args, vm).unwrap();
         dict.set_item("body", body.ast_to_object(vm, source_file), vm)
             .unwrap();
         node_add_location(&dict, _range, vm, source_file);
@@ -451,6 +462,9 @@ impl Node for ast::ExprDict {
             source_file,
             get_node_field(vm, &object, "values", "Dict")?,
         )?;
+        if keys.len() != values.len() {
+            return Err(vm.new_value_error("Dict doesn't have the same number of keys as values"));
+        }
         let items = keys
             .into_iter()
             .zip(values)
@@ -643,8 +657,18 @@ impl Node for ast::ExprGenerator {
             elt,
             generators,
             range,
-            parenthesized: _,
+            parenthesized,
         } = self;
+        let range = if parenthesized {
+            range
+        } else {
+            TextRange::new(
+                range
+                    .start()
+                    .saturating_sub(ruff_text_size::TextSize::from(1)),
+                range.end() + ruff_text_size::TextSize::from(1),
+            )
+        };
         let node = NodeAst
             .into_ref_with_type(vm, pyast::NodeExprGeneratorExp::static_type().to_owned())
             .unwrap();
@@ -1230,10 +1254,7 @@ impl Node for ast::ExprContext {
                 unimplemented!("Invalid expression context is not allowed in Python AST")
             }
         };
-        NodeAst
-            .into_ref_with_type(vm, node_type.to_owned())
-            .unwrap()
-            .into()
+        singleton_node_to_object(vm, node_type)
     }
 
     fn ast_from_object(
@@ -1241,12 +1262,12 @@ impl Node for ast::ExprContext {
         _source_file: &SourceFile,
         object: PyObjectRef,
     ) -> PyResult<Self> {
-        let _cls = object.class();
-        Ok(if _cls.is(pyast::NodeExprContextLoad::static_type()) {
+        let cls = object.class();
+        Ok(if cls.is(pyast::NodeExprContextLoad::static_type()) {
             Self::Load
-        } else if _cls.is(pyast::NodeExprContextStore::static_type()) {
+        } else if cls.is(pyast::NodeExprContextStore::static_type()) {
             Self::Store
-        } else if _cls.is(pyast::NodeExprContextDel::static_type()) {
+        } else if cls.is(pyast::NodeExprContextDel::static_type()) {
             Self::Del
         } else {
             return Err(vm.new_type_error(format!(
diff --git a/crates/vm/src/stdlib/ast/module.rs b/crates/vm/src/stdlib/_ast/module.rs
similarity index 96%
rename from crates/vm/src/stdlib/ast/module.rs
rename to crates/vm/src/stdlib/_ast/module.rs
index 78f897b8930..b4c2468d33b 100644
--- a/crates/vm/src/stdlib/ast/module.rs
+++ b/crates/vm/src/stdlib/_ast/module.rs
@@ -1,5 +1,5 @@
 use super::*;
-use crate::stdlib::ast::type_ignore::TypeIgnore;
+use crate::stdlib::_ast::type_ignore::TypeIgnore;
 use rustpython_compiler_core::SourceFile;
 
 /// Represents the different types of Python module structures.
@@ -86,7 +86,7 @@ impl Node for ast::ModModule {
             vm,
         )
         .unwrap();
-        node_add_location(&dict, range, vm, source_file);
+        let _ = range;
         node.into()
     }
 
@@ -126,7 +126,7 @@ impl Node for ModInteractive {
         let dict = node.as_object().dict().unwrap();
         dict.set_item("body", body.ast_to_object(vm, source_file), vm)
             .unwrap();
-        node_add_location(&dict, range, vm, source_file);
+        let _ = range;
         node.into()
     }
 
@@ -160,7 +160,7 @@ impl Node for ast::ModExpression {
         let dict = node.as_object().dict().unwrap();
         dict.set_item("body", body.ast_to_object(vm, source_file), vm)
             .unwrap();
-        node_add_location(&dict, range, vm, source_file);
+        let _ = range;
         node.into()
     }
 
@@ -207,7 +207,7 @@ impl Node for ModFunctionType {
         .unwrap();
         dict.set_item("returns", returns.ast_to_object(vm, source_file), vm)
             .unwrap();
-        node_add_location(&dict, range, vm, source_file);
+        let _ = range;
         node.into()
     }
 
diff --git a/crates/vm/src/stdlib/ast/node.rs b/crates/vm/src/stdlib/_ast/node.rs
similarity index 100%
rename from crates/vm/src/stdlib/ast/node.rs
rename to crates/vm/src/stdlib/_ast/node.rs
diff --git a/crates/vm/src/stdlib/ast/operator.rs b/crates/vm/src/stdlib/_ast/operator.rs
similarity index 57%
rename from crates/vm/src/stdlib/ast/operator.rs
rename to crates/vm/src/stdlib/_ast/operator.rs
index 23aa63c7031..09e63b5d6ce 100644
--- a/crates/vm/src/stdlib/ast/operator.rs
+++ b/crates/vm/src/stdlib/_ast/operator.rs
@@ -8,26 +8,23 @@ impl Node for ast::BoolOp {
             Self::And => pyast::NodeBoolOpAnd::static_type(),
             Self::Or => pyast::NodeBoolOpOr::static_type(),
         };
-        NodeAst
-            .into_ref_with_type(vm, node_type.to_owned())
-            .unwrap()
-            .into()
+        singleton_node_to_object(vm, node_type)
     }
 
     fn ast_from_object(
-        _vm: &VirtualMachine,
+        vm: &VirtualMachine,
         _source_file: &SourceFile,
-        _object: PyObjectRef,
+        object: PyObjectRef,
     ) -> PyResult<Self> {
-        let _cls = _object.class();
-        Ok(if _cls.is(pyast::NodeBoolOpAnd::static_type()) {
+        let cls = object.class();
+        Ok(if cls.is(pyast::NodeBoolOpAnd::static_type()) {
             Self::And
-        } else if _cls.is(pyast::NodeBoolOpOr::static_type()) {
+        } else if cls.is(pyast::NodeBoolOpOr::static_type()) {
             Self::Or
         } else {
-            return Err(_vm.new_type_error(format!(
+            return Err(vm.new_type_error(format!(
                 "expected some sort of boolop, but got {}",
-                _object.repr(_vm)?
+                object.repr(vm)?
             )));
         })
     }
@@ -51,48 +48,45 @@ impl Node for ast::Operator {
             Self::BitAnd => pyast::NodeOperatorBitAnd::static_type(),
             Self::FloorDiv => pyast::NodeOperatorFloorDiv::static_type(),
         };
-        NodeAst
-            .into_ref_with_type(vm, node_type.to_owned())
-            .unwrap()
-            .into()
+        singleton_node_to_object(vm, node_type)
     }
 
     fn ast_from_object(
-        _vm: &VirtualMachine,
+        vm: &VirtualMachine,
         _source_file: &SourceFile,
-        _object: PyObjectRef,
+        object: PyObjectRef,
     ) -> PyResult<Self> {
-        let _cls = _object.class();
-        Ok(if _cls.is(pyast::NodeOperatorAdd::static_type()) {
+        let cls = object.class();
+        Ok(if cls.is(pyast::NodeOperatorAdd::static_type()) {
             Self::Add
-        } else if _cls.is(pyast::NodeOperatorSub::static_type()) {
+        } else if cls.is(pyast::NodeOperatorSub::static_type()) {
             Self::Sub
-        } else if _cls.is(pyast::NodeOperatorMult::static_type()) {
+        } else if cls.is(pyast::NodeOperatorMult::static_type()) {
             Self::Mult
-        } else if _cls.is(pyast::NodeOperatorMatMult::static_type()) {
+        } else if cls.is(pyast::NodeOperatorMatMult::static_type()) {
             Self::MatMult
-        } else if _cls.is(pyast::NodeOperatorDiv::static_type()) {
+        } else if cls.is(pyast::NodeOperatorDiv::static_type()) {
             Self::Div
-        } else if _cls.is(pyast::NodeOperatorMod::static_type()) {
+        } else if cls.is(pyast::NodeOperatorMod::static_type()) {
             Self::Mod
-        } else if _cls.is(pyast::NodeOperatorPow::static_type()) {
+        } else if cls.is(pyast::NodeOperatorPow::static_type()) {
             Self::Pow
-        } else if _cls.is(pyast::NodeOperatorLShift::static_type()) {
+        } else if cls.is(pyast::NodeOperatorLShift::static_type()) {
             Self::LShift
-        } else if _cls.is(pyast::NodeOperatorRShift::static_type()) {
+        } else if cls.is(pyast::NodeOperatorRShift::static_type()) {
             Self::RShift
-        } else if _cls.is(pyast::NodeOperatorBitOr::static_type()) {
+        } else if cls.is(pyast::NodeOperatorBitOr::static_type()) {
             Self::BitOr
-        } else if _cls.is(pyast::NodeOperatorBitXor::static_type()) {
+        } else if cls.is(pyast::NodeOperatorBitXor::static_type()) {
             Self::BitXor
-        } else if _cls.is(pyast::NodeOperatorBitAnd::static_type()) {
+        } else if cls.is(pyast::NodeOperatorBitAnd::static_type()) {
             Self::BitAnd
-        } else if _cls.is(pyast::NodeOperatorFloorDiv::static_type()) {
+        } else if cls.is(pyast::NodeOperatorFloorDiv::static_type()) {
             Self::FloorDiv
         } else {
-            return Err(_vm.new_type_error(format!(
+            return Err(vm.new_type_error(format!(
                 "expected some sort of operator, but got {}",
-                _object.repr(_vm)?
+                object.repr(vm)?
             )));
         })
     }
@@ -107,30 +101,27 @@ impl Node for ast::UnaryOp {
             Self::UAdd => pyast::NodeUnaryOpUAdd::static_type(),
             Self::USub => pyast::NodeUnaryOpUSub::static_type(),
         };
-        NodeAst
-            .into_ref_with_type(vm, node_type.to_owned())
-            .unwrap()
-            .into()
+        singleton_node_to_object(vm, node_type)
     }
 
     fn ast_from_object(
-        _vm: &VirtualMachine,
+        vm: &VirtualMachine,
         _source_file: &SourceFile,
-        _object: PyObjectRef,
+        object: PyObjectRef,
     ) -> PyResult<Self> {
-        let _cls = _object.class();
-        Ok(if _cls.is(pyast::NodeUnaryOpInvert::static_type()) {
+        let cls = object.class();
+        Ok(if cls.is(pyast::NodeUnaryOpInvert::static_type()) {
             Self::Invert
-        } else if _cls.is(pyast::NodeUnaryOpNot::static_type()) {
+        } else if cls.is(pyast::NodeUnaryOpNot::static_type()) {
             Self::Not
-        } else if _cls.is(pyast::NodeUnaryOpUAdd::static_type()) {
+        } else if cls.is(pyast::NodeUnaryOpUAdd::static_type()) {
             Self::UAdd
-        } else if _cls.is(pyast::NodeUnaryOpUSub::static_type()) {
+        } else if cls.is(pyast::NodeUnaryOpUSub::static_type()) {
             Self::USub
         } else {
-            return Err(_vm.new_type_error(format!(
+            return Err(vm.new_type_error(format!(
                 "expected some sort of unaryop, but got {}",
-                _object.repr(_vm)?
+                object.repr(vm)?
             )));
         })
     }
@@ -151,42 +142,39 @@ impl Node for ast::CmpOp {
             Self::In => pyast::NodeCmpOpIn::static_type(),
             Self::NotIn => pyast::NodeCmpOpNotIn::static_type(),
         };
-        NodeAst
-            .into_ref_with_type(vm, node_type.to_owned())
-            .unwrap()
-            .into()
+        singleton_node_to_object(vm, node_type)
     }
 
     fn ast_from_object(
-        _vm: &VirtualMachine,
+        vm: &VirtualMachine,
         _source_file: &SourceFile,
-        _object: PyObjectRef,
+        object: PyObjectRef,
     ) -> PyResult<Self> {
-        let _cls = _object.class();
-        Ok(if _cls.is(pyast::NodeCmpOpEq::static_type()) {
+        let cls = object.class();
+        Ok(if cls.is(pyast::NodeCmpOpEq::static_type()) {
             Self::Eq
-        } else if _cls.is(pyast::NodeCmpOpNotEq::static_type()) {
+        } else if cls.is(pyast::NodeCmpOpNotEq::static_type()) {
             Self::NotEq
-        } else if _cls.is(pyast::NodeCmpOpLt::static_type()) {
+        } else if cls.is(pyast::NodeCmpOpLt::static_type()) {
             Self::Lt
-        } else if _cls.is(pyast::NodeCmpOpLtE::static_type()) {
+        } else if cls.is(pyast::NodeCmpOpLtE::static_type()) {
             Self::LtE
-        } else if _cls.is(pyast::NodeCmpOpGt::static_type()) {
+        } else if cls.is(pyast::NodeCmpOpGt::static_type()) {
             Self::Gt
-        } else if _cls.is(pyast::NodeCmpOpGtE::static_type()) {
+        } else if cls.is(pyast::NodeCmpOpGtE::static_type()) {
             Self::GtE
-        } else if _cls.is(pyast::NodeCmpOpIs::static_type()) {
+        } else if cls.is(pyast::NodeCmpOpIs::static_type()) {
             Self::Is
-        } else if _cls.is(pyast::NodeCmpOpIsNot::static_type()) {
+        } else if cls.is(pyast::NodeCmpOpIsNot::static_type()) {
             Self::IsNot
-        } else if _cls.is(pyast::NodeCmpOpIn::static_type()) {
+        } else if cls.is(pyast::NodeCmpOpIn::static_type()) {
             Self::In
-        } else if _cls.is(pyast::NodeCmpOpNotIn::static_type()) {
+        } else if cls.is(pyast::NodeCmpOpNotIn::static_type()) {
             Self::NotIn
         } else {
-            return Err(_vm.new_type_error(format!(
+            return Err(vm.new_type_error(format!(
                 "expected some sort of cmpop, but got {}",
-                _object.repr(_vm)?
+                object.repr(vm)?
             )));
         })
     }
diff --git a/crates/vm/src/stdlib/ast/other.rs b/crates/vm/src/stdlib/_ast/other.rs
similarity index 98%
rename from crates/vm/src/stdlib/ast/other.rs
rename to crates/vm/src/stdlib/_ast/other.rs
index 8a89a740682..5c0803ac594 100644
--- a/crates/vm/src/stdlib/ast/other.rs
+++ b/crates/vm/src/stdlib/_ast/other.rs
@@ -3,7 +3,7 @@ use rustpython_compiler_core::SourceFile;
 
 impl Node for ast::ConversionFlag {
     fn ast_to_object(self, vm: &VirtualMachine, _source_file: &SourceFile) -> PyObjectRef {
-        vm.ctx.new_int(self as u8).into()
+        vm.ctx.new_int(self as i8).into()
     }
 
     fn ast_from_object(
@@ -26,7 +26,7 @@ impl Node for ast::ConversionFlag {
 // /// This is just a string, not strictly an AST node. But it makes AST conversions easier.
 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)
+        vm.ctx.intern_str(self.as_str()).to_object()
     }
 
     fn ast_from_object(
diff --git a/crates/vm/src/stdlib/ast/parameter.rs b/crates/vm/src/stdlib/_ast/parameter.rs
similarity index 92%
rename from crates/vm/src/stdlib/ast/parameter.rs
rename to crates/vm/src/stdlib/_ast/parameter.rs
index 1e411d41ab6..15ff237e50d 100644
--- a/crates/vm/src/stdlib/ast/parameter.rs
+++ b/crates/vm/src/stdlib/_ast/parameter.rs
@@ -42,7 +42,7 @@ impl Node for ast::Parameters {
             .unwrap();
         dict.set_item("defaults", defaults.ast_to_object(vm, source_file), vm)
             .unwrap();
-        node_add_location(&dict, range, vm, source_file);
+        let _ = range;
         node.into()
     }
 
@@ -61,7 +61,7 @@ impl Node for ast::Parameters {
             source_file,
             get_node_field(vm, &object, "kw_defaults", "arguments")?,
         )?;
-        let kwonlyargs = merge_keyword_parameter_defaults(kwonlyargs, kw_defaults);
+        let kwonlyargs = merge_keyword_parameter_defaults(vm, kwonlyargs, kw_defaults)?;
 
         let posonlyargs = Node::ast_from_object(
             vm,
@@ -78,7 +78,8 @@ impl Node for ast::Parameters {
             source_file,
             get_node_field(vm, &object, "defaults", "arguments")?,
         )?;
-        let (posonlyargs, args) = merge_positional_parameter_defaults(posonlyargs, args, defaults);
+        let (posonlyargs, args) =
+            merge_positional_parameter_defaults(vm, posonlyargs, args, defaults)?;
 
         Ok(Self {
             node_index: Default::default(),
@@ -126,8 +127,8 @@ impl Node for ast::Parameter {
             _vm,
         )
         .unwrap();
-        // dict.set_item("type_comment", type_comment.ast_to_object(_vm), _vm)
-        //     .unwrap();
+        // Ruff AST doesn't track type_comment, so always set to None
+        dict.set_item("type_comment", _vm.ctx.none(), _vm).unwrap();
         node_add_location(&dict, range, _vm, source_file);
         node.into()
     }
@@ -321,13 +322,14 @@ fn extract_positional_parameter_defaults(
 
 /// Merges the keyword parameters with their default values, opposite of [`extract_positional_parameter_defaults`].
 fn merge_positional_parameter_defaults(
+    vm: &VirtualMachine,
     posonlyargs: PositionalParameters,
     args: PositionalParameters,
     defaults: ParameterDefaults,
-) -> (
+) -> PyResult<(
     Vec<ast::ParameterWithDefault>,
     Vec<ast::ParameterWithDefault>,
-) {
+)> {
     let posonlyargs = posonlyargs.args;
     let args = args.args;
     let defaults = defaults.defaults;
@@ -352,7 +354,11 @@ fn merge_positional_parameter_defaults(
     // If an argument has a default value, insert it
     // Note that "defaults" will only contain default values for the last "n" parameters
     // so we need to skip the first "total_argument_count - n" arguments.
-    let default_argument_count = posonlyargs.len() + args.len() - defaults.len();
+    let total_args = posonlyargs.len() + args.len();
+    if defaults.len() > total_args {
+        return Err(vm.new_value_error("more positional defaults than args on arguments"));
+    }
+    let default_argument_count = total_args - defaults.len();
     for (arg, default) in posonlyargs
         .iter_mut()
         .chain(args.iter_mut())
@@ -362,7 +368,7 @@ fn merge_positional_parameter_defaults(
         arg.default = default;
     }
 
-    (posonlyargs, args)
+    Ok((posonlyargs, args))
 }
 
 fn extract_keyword_parameter_defaults(
@@ -400,15 +406,21 @@ fn extract_keyword_parameter_defaults(
 
 /// Merges the keyword parameters with their default values, opposite of [`extract_keyword_parameter_defaults`].
 fn merge_keyword_parameter_defaults(
+    vm: &VirtualMachine,
     kw_only_args: KeywordParameters,
     defaults: ParameterDefaults,
-) -> Vec<ast::ParameterWithDefault> {
-    core::iter::zip(kw_only_args.keywords, defaults.defaults)
+) -> PyResult<Vec<ast::ParameterWithDefault>> {
+    if kw_only_args.keywords.len() != defaults.defaults.len() {
+        return Err(
+            vm.new_value_error("length of kwonlyargs is not the same as kw_defaults on arguments")
+        );
+    }
+    Ok(core::iter::zip(kw_only_args.keywords, defaults.defaults)
         .map(|(parameter, default)| ast::ParameterWithDefault {
             node_index: Default::default(),
             parameter,
             default,
             range: Default::default(),
         })
-        .collect()
+        .collect())
 }
diff --git a/crates/vm/src/stdlib/ast/pattern.rs b/crates/vm/src/stdlib/_ast/pattern.rs
similarity index 65%
rename from crates/vm/src/stdlib/ast/pattern.rs
rename to crates/vm/src/stdlib/_ast/pattern.rs
index 4531a989cb3..621c849e812 100644
--- a/crates/vm/src/stdlib/ast/pattern.rs
+++ b/crates/vm/src/stdlib/_ast/pattern.rs
@@ -3,46 +3,46 @@ use rustpython_compiler_core::SourceFile;
 
 // product
 impl Node for ast::MatchCase {
-    fn ast_to_object(self, _vm: &VirtualMachine, source_file: &SourceFile) -> PyObjectRef {
+    fn ast_to_object(self, vm: &VirtualMachine, source_file: &SourceFile) -> PyObjectRef {
         let Self {
             node_index: _,
             pattern,
             guard,
             body,
-            range: _range,
+            range: _,
         } = self;
         let node = NodeAst
-            .into_ref_with_type(_vm, pyast::NodeMatchCase::static_type().to_owned())
+            .into_ref_with_type(vm, pyast::NodeMatchCase::static_type().to_owned())
             .unwrap();
         let dict = node.as_object().dict().unwrap();
-        dict.set_item("pattern", pattern.ast_to_object(_vm, source_file), _vm)
+        dict.set_item("pattern", pattern.ast_to_object(vm, source_file), vm)
             .unwrap();
-        dict.set_item("guard", guard.ast_to_object(_vm, source_file), _vm)
+        dict.set_item("guard", guard.ast_to_object(vm, source_file), vm)
             .unwrap();
-        dict.set_item("body", body.ast_to_object(_vm, source_file), _vm)
+        dict.set_item("body", body.ast_to_object(vm, source_file), vm)
             .unwrap();
         node.into()
     }
 
     fn ast_from_object(
-        _vm: &VirtualMachine,
+        vm: &VirtualMachine,
         source_file: &SourceFile,
-        _object: PyObjectRef,
+        object: PyObjectRef,
     ) -> PyResult<Self> {
         Ok(Self {
             node_index: Default::default(),
             pattern: Node::ast_from_object(
-                _vm,
+                vm,
                 source_file,
-                get_node_field(_vm, &_object, "pattern", "match_case")?,
+                get_node_field(vm, &object, "pattern", "match_case")?,
             )?,
-            guard: get_node_field_opt(_vm, &_object, "guard")?
-                .map(|obj| Node::ast_from_object(_vm, source_file, obj))
+            guard: get_node_field_opt(vm, &object, "guard")?
+                .map(|obj| Node::ast_from_object(vm, source_file, obj))
                 .transpose()?,
             body: Node::ast_from_object(
-                _vm,
+                vm,
                 source_file,
-                get_node_field(_vm, &_object, "body", "match_case")?,
+                get_node_field(vm, &object, "body", "match_case")?,
             )?,
             range: Default::default(),
         })
@@ -64,136 +64,136 @@ impl Node for ast::Pattern {
         }
     }
     fn ast_from_object(
-        _vm: &VirtualMachine,
+        vm: &VirtualMachine,
         source_file: &SourceFile,
-        _object: PyObjectRef,
+        object: PyObjectRef,
     ) -> PyResult<Self> {
-        let _cls = _object.class();
-        Ok(if _cls.is(pyast::NodePatternMatchValue::static_type()) {
+        let cls = object.class();
+        Ok(if cls.is(pyast::NodePatternMatchValue::static_type()) {
             Self::MatchValue(ast::PatternMatchValue::ast_from_object(
-                _vm,
+                vm,
                 source_file,
-                _object,
+                object,
             )?)
-        } else if _cls.is(pyast::NodePatternMatchSingleton::static_type()) {
+        } else if cls.is(pyast::NodePatternMatchSingleton::static_type()) {
             Self::MatchSingleton(ast::PatternMatchSingleton::ast_from_object(
-                _vm,
+                vm,
                 source_file,
-                _object,
+                object,
             )?)
-        } else if _cls.is(pyast::NodePatternMatchSequence::static_type()) {
+        } else if cls.is(pyast::NodePatternMatchSequence::static_type()) {
             Self::MatchSequence(ast::PatternMatchSequence::ast_from_object(
-                _vm,
+                vm,
                 source_file,
-                _object,
+                object,
             )?)
-        } else if _cls.is(pyast::NodePatternMatchMapping::static_type()) {
+        } else if cls.is(pyast::NodePatternMatchMapping::static_type()) {
             Self::MatchMapping(ast::PatternMatchMapping::ast_from_object(
-                _vm,
+                vm,
                 source_file,
-                _object,
+                object,
             )?)
-        } else if _cls.is(pyast::NodePatternMatchClass::static_type()) {
+        } else if cls.is(pyast::NodePatternMatchClass::static_type()) {
             Self::MatchClass(ast::PatternMatchClass::ast_from_object(
-                _vm,
+                vm,
                 source_file,
-                _object,
+                object,
             )?)
-        } else if _cls.is(pyast::NodePatternMatchStar::static_type()) {
+        } else if cls.is(pyast::NodePatternMatchStar::static_type()) {
             Self::MatchStar(ast::PatternMatchStar::ast_from_object(
-                _vm,
+                vm,
                 source_file,
-                _object,
+                object,
             )?)
-        } else if _cls.is(pyast::NodePatternMatchAs::static_type()) {
+        } else if cls.is(pyast::NodePatternMatchAs::static_type()) {
             Self::MatchAs(ast::PatternMatchAs::ast_from_object(
-                _vm,
+                vm,
                 source_file,
-                _object,
+                object,
             )?)
-        } else if _cls.is(pyast::NodePatternMatchOr::static_type()) {
+        } else if cls.is(pyast::NodePatternMatchOr::static_type()) {
             Self::MatchOr(ast::PatternMatchOr::ast_from_object(
-                _vm,
+                vm,
                 source_file,
-                _object,
+                object,
             )?)
         } else {
-            return Err(_vm.new_type_error(format!(
+            return Err(vm.new_type_error(format!(
                 "expected some sort of pattern, but got {}",
-                _object.repr(_vm)?
+                object.repr(vm)?
             )));
         })
     }
 }
 // constructor
 impl Node for ast::PatternMatchValue {
-    fn ast_to_object(self, _vm: &VirtualMachine, source_file: &SourceFile) -> PyObjectRef {
+    fn ast_to_object(self, vm: &VirtualMachine, source_file: &SourceFile) -> PyObjectRef {
         let Self {
             node_index: _,
             value,
-            range: _range,
+            range,
         } = self;
         let node = NodeAst
-            .into_ref_with_type(_vm, pyast::NodePatternMatchValue::static_type().to_owned())
+            .into_ref_with_type(vm, pyast::NodePatternMatchValue::static_type().to_owned())
             .unwrap();
         let dict = node.as_object().dict().unwrap();
-        dict.set_item("value", value.ast_to_object(_vm, source_file), _vm)
+        dict.set_item("value", value.ast_to_object(vm, source_file), vm)
             .unwrap();
-        node_add_location(&dict, _range, _vm, source_file);
+        node_add_location(&dict, range, vm, source_file);
         node.into()
     }
 
     fn ast_from_object(
-        _vm: &VirtualMachine,
+        vm: &VirtualMachine,
         source_file: &SourceFile,
-        _object: PyObjectRef,
+        object: PyObjectRef,
     ) -> PyResult<Self> {
         Ok(Self {
             node_index: Default::default(),
             value: Node::ast_from_object(
-                _vm,
+                vm,
                 source_file,
-                get_node_field(_vm, &_object, "value", "MatchValue")?,
+                get_node_field(vm, &object, "value", "MatchValue")?,
             )?,
-            range: range_from_object(_vm, source_file, _object, "MatchValue")?,
+            range: range_from_object(vm, source_file, object, "MatchValue")?,
         })
     }
 }
 
 // constructor
 impl Node for ast::PatternMatchSingleton {
-    fn ast_to_object(self, _vm: &VirtualMachine, source_file: &SourceFile) -> PyObjectRef {
+    fn ast_to_object(self, vm: &VirtualMachine, source_file: &SourceFile) -> PyObjectRef {
         let Self {
             node_index: _,
             value,
-            range: _range,
+            range,
         } = self;
         let node = NodeAst
             .into_ref_with_type(
-                _vm,
+                vm,
                 pyast::NodePatternMatchSingleton::static_type().to_owned(),
             )
             .unwrap();
         let dict = node.as_object().dict().unwrap();
-        dict.set_item("value", value.ast_to_object(_vm, source_file), _vm)
+        dict.set_item("value", value.ast_to_object(vm, source_file), vm)
             .unwrap();
-        node_add_location(&dict, _range, _vm, source_file);
+        node_add_location(&dict, range, vm, source_file);
         node.into()
     }
 
     fn ast_from_object(
-        _vm: &VirtualMachine,
+        vm: &VirtualMachine,
         source_file: &SourceFile,
-        _object: PyObjectRef,
+        object: PyObjectRef,
     ) -> PyResult<Self> {
         Ok(Self {
             node_index: Default::default(),
             value: Node::ast_from_object(
-                _vm,
+                vm,
                 source_file,
-                get_node_field(_vm, &_object, "value", "MatchSingleton")?,
+                get_node_field(vm, &object, "value", "MatchSingleton")?,
             )?,
-            range: range_from_object(_vm, source_file, _object, "MatchSingleton")?,
+            range: range_from_object(vm, source_file, object, "MatchSingleton")?,
         })
     }
 }
@@ -229,90 +229,87 @@ impl Node for ast::Singleton {
 
 // constructor
 impl Node for ast::PatternMatchSequence {
-    fn ast_to_object(self, _vm: &VirtualMachine, source_file: &SourceFile) -> PyObjectRef {
+    fn ast_to_object(self, vm: &VirtualMachine, source_file: &SourceFile) -> PyObjectRef {
         let Self {
             node_index: _,
             patterns,
-            range: _range,
+            range,
         } = self;
         let node = NodeAst
             .into_ref_with_type(
-                _vm,
+                vm,
                 pyast::NodePatternMatchSequence::static_type().to_owned(),
             )
             .unwrap();
         let dict = node.as_object().dict().unwrap();
-        dict.set_item("patterns", patterns.ast_to_object(_vm, source_file), _vm)
+        dict.set_item("patterns", patterns.ast_to_object(vm, source_file), vm)
             .unwrap();
-        node_add_location(&dict, _range, _vm, source_file);
+        node_add_location(&dict, range, vm, source_file);
         node.into()
     }
 
     fn ast_from_object(
-        _vm: &VirtualMachine,
+        vm: &VirtualMachine,
         source_file: &SourceFile,
-        _object: PyObjectRef,
+        object: PyObjectRef,
     ) -> PyResult<Self> {
         Ok(Self {
             node_index: Default::default(),
             patterns: Node::ast_from_object(
-                _vm,
+                vm,
                 source_file,
-                get_node_field(_vm, &_object, "patterns", "MatchSequence")?,
+                get_node_field(vm, &object, "patterns", "MatchSequence")?,
             )?,
-            range: range_from_object(_vm, source_file, _object, "MatchSequence")?,
+            range: range_from_object(vm, source_file, object, "MatchSequence")?,
         })
     }
 }
 
 // constructor
 impl Node for ast::PatternMatchMapping {
-    fn ast_to_object(self, _vm: &VirtualMachine, source_file: &SourceFile) -> PyObjectRef {
+    fn ast_to_object(self, vm: &VirtualMachine, source_file: &SourceFile) -> PyObjectRef {
         let Self {
             node_index: _,
             keys,
             patterns,
             rest,
-            range: _range,
+            range,
         } = self;
         let node = NodeAst
-            .into_ref_with_type(
-                _vm,
-                pyast::NodePatternMatchMapping::static_type().to_owned(),
-            )
+            .into_ref_with_type(vm, pyast::NodePatternMatchMapping::static_type().to_owned())
             .unwrap();
         let dict = node.as_object().dict().unwrap();
-        dict.set_item("keys", keys.ast_to_object(_vm, source_file), _vm)
+        dict.set_item("keys", keys.ast_to_object(vm, source_file), vm)
             .unwrap();
-        dict.set_item("patterns", patterns.ast_to_object(_vm, source_file), _vm)
+        dict.set_item("patterns", patterns.ast_to_object(vm, source_file), vm)
             .unwrap();
-        dict.set_item("rest", rest.ast_to_object(_vm, source_file), _vm)
+        dict.set_item("rest", rest.ast_to_object(vm, source_file), vm)
             .unwrap();
-        node_add_location(&dict, _range, _vm, source_file);
+        node_add_location(&dict, range, vm, source_file);
         node.into()
     }
 
     fn ast_from_object(
-        _vm: &VirtualMachine,
+        vm: &VirtualMachine,
         source_file: &SourceFile,
-        _object: PyObjectRef,
+        object: PyObjectRef,
     ) -> PyResult<Self> {
         Ok(Self {
             node_index: Default::default(),
             keys: Node::ast_from_object(
-                _vm,
+                vm,
                 source_file,
-                get_node_field(_vm, &_object, "keys", "MatchMapping")?,
+                get_node_field(vm, &object, "keys", "MatchMapping")?,
             )?,
             patterns: Node::ast_from_object(
-                _vm,
+                vm,
                 source_file,
-                get_node_field(_vm, &_object, "patterns", "MatchMapping")?,
+                get_node_field(vm, &object, "patterns", "MatchMapping")?,
             )?,
-            rest: get_node_field_opt(_vm, &_object, "rest")?
-                .map(|obj| Node::ast_from_object(_vm, source_file, obj))
+            rest: get_node_field_opt(vm, &object, "rest")?
+                .map(|obj| Node::ast_from_object(vm, source_file, obj))
                 .transpose()?,
-            range: range_from_object(_vm, source_file, _object, "MatchMapping")?,
+            range: range_from_object(vm, source_file, object, "MatchMapping")?,
         })
     }
 }
@@ -324,7 +321,7 @@ impl Node for ast::PatternMatchClass {
             node_index: _,
             cls,
             arguments,
-            range: _range,
+            range,
         } = self;
         let (patterns, kwd_attrs, kwd_patterns) = split_pattern_match_class(arguments);
         let node = NodeAst
@@ -343,7 +340,7 @@ impl Node for ast::PatternMatchClass {
             vm,
         )
         .unwrap();
-        node_add_location(&dict, _range, vm, source_file);
+        node_add_location(&dict, range, vm, source_file);
         node.into()
     }
 
@@ -357,16 +354,19 @@ impl Node for ast::PatternMatchClass {
             source_file,
             get_node_field(vm, &object, "patterns", "MatchClass")?,
         )?;
-        let kwd_attrs = Node::ast_from_object(
+        let kwd_attrs: PatternMatchClassKeywordAttributes = Node::ast_from_object(
             vm,
             source_file,
             get_node_field(vm, &object, "kwd_attrs", "MatchClass")?,
         )?;
-        let kwd_patterns = Node::ast_from_object(
+        let kwd_patterns: PatternMatchClassKeywordPatterns = Node::ast_from_object(
             vm,
             source_file,
             get_node_field(vm, &object, "kwd_patterns", "MatchClass")?,
         )?;
+        if kwd_attrs.0.len() != kwd_patterns.0.len() {
+            return Err(vm.new_value_error("MatchClass has mismatched kwd_attrs and kwd_patterns"));
+        }
         let (patterns, keywords) = merge_pattern_match_class(patterns, kwd_attrs, kwd_patterns);
 
         Ok(Self {
@@ -436,106 +436,106 @@ impl Node for PatternMatchClassKeywordPatterns {
 }
 // constructor
 impl Node for ast::PatternMatchStar {
-    fn ast_to_object(self, _vm: &VirtualMachine, source_file: &SourceFile) -> PyObjectRef {
+    fn ast_to_object(self, vm: &VirtualMachine, source_file: &SourceFile) -> PyObjectRef {
         let Self {
             node_index: _,
             name,
-            range: _range,
+            range,
         } = self;
         let node = NodeAst
-            .into_ref_with_type(_vm, pyast::NodePatternMatchStar::static_type().to_owned())
+            .into_ref_with_type(vm, pyast::NodePatternMatchStar::static_type().to_owned())
             .unwrap();
         let dict = node.as_object().dict().unwrap();
-        dict.set_item("name", name.ast_to_object(_vm, source_file), _vm)
+        dict.set_item("name", name.ast_to_object(vm, source_file), vm)
             .unwrap();
-        node_add_location(&dict, _range, _vm, source_file);
+        node_add_location(&dict, range, vm, source_file);
         node.into()
     }
 
     fn ast_from_object(
-        _vm: &VirtualMachine,
+        vm: &VirtualMachine,
         source_file: &SourceFile,
-        _object: PyObjectRef,
+        object: PyObjectRef,
     ) -> PyResult<Self> {
         Ok(Self {
             node_index: Default::default(),
-            name: get_node_field_opt(_vm, &_object, "name")?
-                .map(|obj| Node::ast_from_object(_vm, source_file, obj))
+            name: get_node_field_opt(vm, &object, "name")?
+                .map(|obj| Node::ast_from_object(vm, source_file, obj))
                 .transpose()?,
-            range: range_from_object(_vm, source_file, _object, "MatchStar")?,
+            range: range_from_object(vm, source_file, object, "MatchStar")?,
         })
     }
 }
 
 // constructor
 impl Node for ast::PatternMatchAs {
-    fn ast_to_object(self, _vm: &VirtualMachine, source_file: &SourceFile) -> PyObjectRef {
+    fn ast_to_object(self, vm: &VirtualMachine, source_file: &SourceFile) -> PyObjectRef {
         let Self {
             node_index: _,
             pattern,
             name,
-            range: _range,
+            range,
         } = self;
         let node = NodeAst
-            .into_ref_with_type(_vm, pyast::NodePatternMatchAs::static_type().to_owned())
+            .into_ref_with_type(vm, pyast::NodePatternMatchAs::static_type().to_owned())
             .unwrap();
         let dict = node.as_object().dict().unwrap();
-        dict.set_item("pattern", pattern.ast_to_object(_vm, source_file), _vm)
+        dict.set_item("pattern", pattern.ast_to_object(vm, source_file), vm)
             .unwrap();
-        dict.set_item("name", name.ast_to_object(_vm, source_file), _vm)
+        dict.set_item("name", name.ast_to_object(vm, source_file), vm)
             .unwrap();
-        node_add_location(&dict, _range, _vm, source_file);
+        node_add_location(&dict, range, vm, source_file);
         node.into()
     }
 
     fn ast_from_object(
-        _vm: &VirtualMachine,
+        vm: &VirtualMachine,
         source_file: &SourceFile,
-        _object: PyObjectRef,
+        object: PyObjectRef,
     ) -> PyResult<Self> {
         Ok(Self {
             node_index: Default::default(),
-            pattern: get_node_field_opt(_vm, &_object, "pattern")?
-                .map(|obj| Node::ast_from_object(_vm, source_file, obj))
+            pattern: get_node_field_opt(vm, &object, "pattern")?
+                .map(|obj| Node::ast_from_object(vm, source_file, obj))
                 .transpose()?,
-            name: get_node_field_opt(_vm, &_object, "name")?
-                .map(|obj| Node::ast_from_object(_vm, source_file, obj))
+            name: get_node_field_opt(vm, &object, "name")?
+                .map(|obj| Node::ast_from_object(vm, source_file, obj))
                 .transpose()?,
-            range: range_from_object(_vm, source_file, _object, "MatchAs")?,
+            range: range_from_object(vm, source_file, object, "MatchAs")?,
         })
     }
 }
 
 // constructor
 impl Node for ast::PatternMatchOr {
-    fn ast_to_object(self, _vm: &VirtualMachine, source_file: &SourceFile) -> PyObjectRef {
+    fn ast_to_object(self, vm: &VirtualMachine, source_file: &SourceFile) -> PyObjectRef {
         let Self {
             node_index: _,
             patterns,
-            range: _range,
+            range,
         } = self;
         let node = NodeAst
-            .into_ref_with_type(_vm, pyast::NodePatternMatchOr::static_type().to_owned())
+            .into_ref_with_type(vm, pyast::NodePatternMatchOr::static_type().to_owned())
             .unwrap();
         let dict = node.as_object().dict().unwrap();
-        dict.set_item("patterns", patterns.ast_to_object(_vm, source_file), _vm)
+        dict.set_item("patterns", patterns.ast_to_object(vm, source_file), vm)
             .unwrap();
-        node_add_location(&dict, _range, _vm, source_file);
+        node_add_location(&dict, range, vm, source_file);
         node.into()
     }
     fn ast_from_object(
-        _vm: &VirtualMachine,
+        vm: &VirtualMachine,
         source_file: &SourceFile,
-        _object: PyObjectRef,
+        object: PyObjectRef,
     ) -> PyResult<Self> {
         Ok(Self {
             node_index: Default::default(),
             patterns: Node::ast_from_object(
-                _vm,
+                vm,
                 source_file,
-                get_node_field(_vm, &_object, "patterns", "MatchOr")?,
+                get_node_field(vm, &object, "patterns", "MatchOr")?,
             )?,
-            range: range_from_object(_vm, source_file, _object, "MatchOr")?,
+            range: range_from_object(vm, source_file, object, "MatchOr")?,
         })
     }
 }
diff --git a/crates/vm/src/stdlib/_ast/pyast.rs b/crates/vm/src/stdlib/_ast/pyast.rs
new file mode 100644
index 00000000000..4b6e97e13fc
--- /dev/null
+++ b/crates/vm/src/stdlib/_ast/pyast.rs
@@ -0,0 +1,1835 @@
+#![allow(clippy::all)]
+
+use super::*;
+use crate::builtins::{PyGenericAlias, PyTuple, PyTupleRef, PyTypeRef, make_union};
+use crate::common::ascii;
+use crate::convert::ToPyObject;
+use crate::function::FuncArgs;
+use crate::types::Initializer;
+
+macro_rules! impl_node {
+    (
+        #[pyclass(module = $_mod:literal, name = $_name:literal, base = $base:ty)]
+        $vis:vis struct $name:ident,
+        fields: [$($field:expr),* $(,)?],
+        attributes: [$($attr:expr),* $(,)?] $(,)?
+    ) => {
+        #[pyclass(module = $_mod, name = $_name, base = $base)]
+        #[repr(transparent)]
+        $vis struct $name($base);
+
+        impl_base_node!($name, fields: [$($field),*], attributes: [$($attr),*]);
+    };
+    // Without attributes
+    (
+        #[pyclass(module = $_mod:literal, name = $_name:literal, base = $base:ty)]
+        $vis:vis struct $name:ident,
+        fields: [$($field:expr),* $(,)?] $(,)?
+    ) => {
+        impl_node!(
+            #[pyclass(module = $_mod, name = $_name, base = $base)]
+            $vis struct $name,
+            fields: [$($field),*],
+            attributes: [],
+        );
+    };
+    // Without fields
+    (
+        #[pyclass(module = $_mod:literal, name = $_name:literal, base = $base:ty)]
+        $vis:vis struct $name:ident,
+        attributes: [$($attr:expr),* $(,)?] $(,)?
+    ) => {
+        impl_node!(
+            #[pyclass(module = $_mod, name = $_name, base = $base)]
+            $vis struct $name,
+            fields: [],
+            attributes: [$($attr),*],
+        );
+    };
+    // Without fields and attributes
+    (
+        #[pyclass(module = $_mod:literal, name = $_name:literal, base = $base:ty)]
+        $vis:vis struct $name:ident $(,)?
+    ) => {
+        impl_node!(
+            #[pyclass(module = $_mod, name = $_name, base = $base)]
+            $vis struct $name,
+            fields: [],
+            attributes: [],
+        );
+    };
+}
+
+macro_rules! impl_base_node {
+    // Base node without fields/attributes (e.g. NodeMod, NodeExpr)
+    ($name:ident) => {
+        #[pyclass(flags(HAS_DICT, BASETYPE))]
+        impl $name {
+            #[pymethod]
+            fn __reduce__(zelf: PyObjectRef, vm: &VirtualMachine) -> PyResult<PyTupleRef> {
+                super::python::_ast::ast_reduce(zelf, vm)
+            }
+
+            #[pymethod]
+            fn __replace__(zelf: PyObjectRef, args: FuncArgs, vm: &VirtualMachine) -> PyResult {
+                super::python::_ast::ast_replace(zelf, args, vm)
+            }
+
+            #[extend_class]
+            fn extend_class(ctx: &Context, class: &'static Py<PyType>) {
+                // AST types are mutable (heap types in CPython, not IMMUTABLETYPE)
+                // Safety: called during type initialization before any concurrent access
+                unsafe {
+                    let flags = &class.slots.flags as *const crate::types::PyTypeFlags
+                        as *mut crate::types::PyTypeFlags;
+                    (*flags).remove(crate::types::PyTypeFlags::IMMUTABLETYPE);
+                }
+                class.set_attr(
+                    identifier!(ctx, _attributes),
+                    ctx.empty_tuple.clone().into(),
+                );
+            }
+        }
+    };
+    // Leaf node with fields and attributes
+    ($name:ident, fields: [$($field:expr),*], attributes: [$($attr:expr),*]) => {
+        #[pyclass(flags(HAS_DICT, BASETYPE))]
+        impl $name {
+            #[pymethod]
+            fn __reduce__(zelf: PyObjectRef, vm: &VirtualMachine) -> PyResult<PyTupleRef> {
+                super::python::_ast::ast_reduce(zelf, vm)
+            }
+
+            #[pymethod]
+            fn __replace__(zelf: PyObjectRef, args: FuncArgs, vm: &VirtualMachine) -> PyResult {
+                super::python::_ast::ast_replace(zelf, args, vm)
+            }
+
+            #[extend_class]
+            fn extend_class_with_fields(ctx: &Context, class: &'static Py<PyType>) {
+                // AST types are mutable (heap types in CPython, not IMMUTABLETYPE)
+                // Safety: called during type initialization before any concurrent access
+                unsafe {
+                    let flags = &class.slots.flags as *const crate::types::PyTypeFlags
+                        as *mut crate::types::PyTypeFlags;
+                    (*flags).remove(crate::types::PyTypeFlags::IMMUTABLETYPE);
+                }
+                class.set_attr(
+                    identifier!(ctx, _fields),
+                    ctx.new_tuple(vec![
+                        $(
+                            ctx.new_str(ascii!($field)).into()
+                        ),*
+                    ])
+                    .into(),
+                );
+
+                class.set_str_attr(
+                    "__match_args__",
+                    ctx.new_tuple(vec![
+                        $(
+                            ctx.new_str(ascii!($field)).into()
+                        ),*
+                    ]),
+                    ctx,
+                );
+
+                class.set_attr(
+                    identifier!(ctx, _attributes),
+                    ctx.new_tuple(vec![
+                        $(
+                            ctx.new_str(ascii!($attr)).into()
+                        ),*
+                    ])
+                    .into(),
+                );
+
+                // Signal that this is a built-in AST node with field defaults
+                class.set_attr(
+                    ctx.intern_str("_field_types"),
+                    ctx.new_dict().into(),
+                );
+            }
+        }
+    };
+}
+
+#[pyclass(module = "_ast", name = "mod", base = NodeAst)]
+pub(crate) struct NodeMod(NodeAst);
+
+impl_base_node!(NodeMod);
+
+impl_node!(
+    #[pyclass(module = "_ast", name = "Module", base = NodeMod)]
+    pub(crate) struct NodeModModule,
+    fields: ["body", "type_ignores"],
+);
+
+impl_node!(
+    #[pyclass(module = "_ast", name = "Interactive", base = NodeMod)]
+    pub(crate) struct NodeModInteractive,
+    fields: ["body"],
+);
+
+impl_node!(
+    #[pyclass(module = "_ast", name = "Expression", base = NodeMod)]
+    pub(crate) struct NodeModExpression,
+    fields: ["body"],
+);
+
+#[pyclass(module = "_ast", name = "stmt", base = NodeAst)]
+#[repr(transparent)]
+pub(crate) struct NodeStmt(NodeAst);
+
+impl_base_node!(NodeStmt);
+
+impl_node!(
+    #[pyclass(module = "_ast", name = "FunctionType", base = NodeMod)]
+    pub(crate) struct NodeModFunctionType,
+    fields: ["argtypes", "returns"],
+);
+
+impl_node!(
+    #[pyclass(module = "_ast", name = "FunctionDef", base = NodeStmt)]
+    pub(crate) struct NodeStmtFunctionDef,
+    fields: ["name", "args", "body", "decorator_list", "returns", "type_comment", "type_params"],
+    attributes: ["lineno", "col_offset", "end_lineno", "end_col_offset"],
+);
+
+impl_node!(
+    #[pyclass(module = "_ast", name = "AsyncFunctionDef", base = NodeStmt)]
+    pub(crate) struct NodeStmtAsyncFunctionDef,
+    fields: ["name", "args", "body", "decorator_list", "returns", "type_comment", "type_params"],
+    attributes: ["lineno", "col_offset", "end_lineno", "end_col_offset"],
+);
+
+impl_node!(
+    #[pyclass(module = "_ast", name = "ClassDef", base = NodeStmt)]
+    pub(crate) struct NodeStmtClassDef,
+    fields: ["name", "bases", "keywords", "body", "decorator_list", "type_params"],
+    attributes: ["lineno", "col_offset", "end_lineno", "end_col_offset"],
+);
+
+impl_node!(
+    #[pyclass(module = "_ast", name = "Return", base = NodeStmt)]
+    pub(crate) struct NodeStmtReturn,
+    fields: ["value"],
+    attributes: ["lineno", "col_offset", "end_lineno", "end_col_offset"],
+);
+
+impl_node!(
+    #[pyclass(module = "_ast", name = "Delete", base = NodeStmt)]
+    pub(crate) struct NodeStmtDelete,
+    fields: ["targets"],
+    attributes: ["lineno", "col_offset", "end_lineno", "end_col_offset"],
+);
+
+impl_node!(
+    #[pyclass(module = "_ast", name = "Assign", base = NodeStmt)]
+    pub(crate) struct NodeStmtAssign,
+    fields: ["targets", "value", "type_comment"],
+    attributes: ["lineno", "col_offset", "end_lineno", "end_col_offset"],
+);
+
+impl_node!(
+    #[pyclass(module = "_ast", name = "TypeAlias", base = NodeStmt)]
+    pub(crate) struct NodeStmtTypeAlias,
+    fields: ["name", "type_params", "value"],
+    attributes: ["lineno", "col_offset", "end_lineno", "end_col_offset"],
+);
+
+impl_node!(
+    #[pyclass(module = "_ast", name = "AugAssign", base = NodeStmt)]
+    pub(crate) struct NodeStmtAugAssign,
+    fields: ["target", "op", "value"],
+    attributes: ["lineno", "col_offset", "end_lineno", "end_col_offset"],
+);
+
+impl_node!(
+    #[pyclass(module = "_ast", name = "AnnAssign", base = NodeStmt)]
+    pub(crate) struct NodeStmtAnnAssign,
+    fields: ["target", "annotation", "value", "simple"],
+    attributes: ["lineno", "col_offset", "end_lineno", "end_col_offset"],
+);
+
+impl_node!(
+    #[pyclass(module = "_ast", name = "For", base = NodeStmt)]
+    pub(crate) struct NodeStmtFor,
+    fields: ["target", "iter", "body", "orelse", "type_comment"],
+    attributes: ["lineno", "col_offset", "end_lineno", "end_col_offset"],
+);
+
+impl_node!(
+    #[pyclass(module = "_ast", name = "AsyncFor", base = NodeStmt)]
+    pub(crate) struct NodeStmtAsyncFor,
+    fields: ["target", "iter", "body", "orelse", "type_comment"],
+    attributes: ["lineno", "col_offset", "end_lineno", "end_col_offset"],
+);
+
+impl_node!(
+    #[pyclass(module = "_ast", name = "While", base = NodeStmt)]
+    pub(crate) struct NodeStmtWhile,
+    fields: ["test", "body", "orelse"],
+    attributes: ["lineno", "col_offset", "end_lineno", "end_col_offset"],
+);
+
+impl_node!(
+    #[pyclass(module = "_ast", name = "If", base = NodeStmt)]
+    pub(crate) struct NodeStmtIf,
+    fields: ["test", "body", "orelse"],
+    attributes: ["lineno", "col_offset", "end_lineno", "end_col_offset"],
+);
+
+impl_node!(
+    #[pyclass(module = "_ast", name = "With", base = NodeStmt)]
+    pub(crate) struct NodeStmtWith,
+    fields: ["items", "body", "type_comment"],
+    attributes: ["lineno", "col_offset", "end_lineno", "end_col_offset"],
+);
+
+impl_node!(
+    #[pyclass(module = "_ast", name = "AsyncWith", base = NodeStmt)]
+    pub(crate) struct NodeStmtAsyncWith,
+    fields: ["items", "body", "type_comment"],
+    attributes: ["lineno", "col_offset", "end_lineno", "end_col_offset"],
+);
+
+impl_node!(
+    #[pyclass(module = "_ast", name = "Match", base = NodeStmt)]
+    pub(crate) struct NodeStmtMatch,
+    fields: ["subject", "cases"],
+    attributes: ["lineno", "col_offset", "end_lineno", "end_col_offset"],
+);
+
+impl_node!(
+    #[pyclass(module = "_ast", name = "Raise", base = NodeStmt)]
+    pub(crate) struct NodeStmtRaise,
+    fields: ["exc", "cause"],
+    attributes: ["lineno", "col_offset", "end_lineno", "end_col_offset"],
+);
+
+impl_node!(
+    #[pyclass(module = "_ast", name = "Try", base = NodeStmt)]
+    pub(crate) struct NodeStmtTry,
+    fields: ["body", "handlers", "orelse", "finalbody"],
+    attributes: ["lineno", "col_offset", "end_lineno", "end_col_offset"],
+);
+
+impl_node!(
+    #[pyclass(module = "_ast", name = "TryStar", base = NodeStmt)]
+    pub(crate) struct NodeStmtTryStar,
+    fields: ["body", "handlers", "orelse", "finalbody"],
+    attributes: ["lineno", "col_offset", "end_lineno", "end_col_offset"],
+);
+
+impl_node!(
+    #[pyclass(module = "_ast", name = "Assert", base = NodeStmt)]
+    pub(crate) struct NodeStmtAssert,
+    fields: ["test", "msg"],
+    attributes: ["lineno", "col_offset", "end_lineno", "end_col_offset"],
+);
+
+impl_node!(
+    #[pyclass(module = "_ast", name = "Import", base = NodeStmt)]
+    pub(crate) struct NodeStmtImport,
+    fields: ["names"],
+    attributes: ["lineno", "col_offset", "end_lineno", "end_col_offset"],
+);
+
+impl_node!(
+    #[pyclass(module = "_ast", name = "ImportFrom", base = NodeStmt)]
+    pub(crate) struct NodeStmtImportFrom,
+    fields: ["module", "names", "level"],
+    attributes: ["lineno", "col_offset", "end_lineno", "end_col_offset"],
+);
+
+impl_node!(
+    #[pyclass(module = "_ast", name = "Global", base = NodeStmt)]
+    pub(crate) struct NodeStmtGlobal,
+    fields: ["names"],
+    attributes: ["lineno", "col_offset", "end_lineno", "end_col_offset"],
+);
+
+impl_node!(
+    #[pyclass(module = "_ast", name = "Nonlocal", base = NodeStmt)]
+    pub(crate) struct NodeStmtNonlocal,
+    fields: ["names"],
+    attributes: ["lineno", "col_offset", "end_lineno", "end_col_offset"],
+);
+
+impl_node!(
+    #[pyclass(module = "_ast", name = "Expr", base = NodeStmt)]
+    pub(crate) struct NodeStmtExpr,
+    fields: ["value"],
+    attributes: ["lineno", "col_offset", "end_lineno", "end_col_offset"],
+);
+
+impl_node!(
+    #[pyclass(module = "_ast", name = "Pass", base = NodeStmt)]
+    pub(crate) struct NodeStmtPass,
+    attributes: ["lineno", "col_offset", "end_lineno", "end_col_offset"],
+);
+
+impl_node!(
+    #[pyclass(module = "_ast", name = "Break", base = NodeStmt)]
+    pub(crate) struct NodeStmtBreak,
+    attributes: ["lineno", "col_offset", "end_lineno", "end_col_offset"],
+);
+
+#[pyclass(module = "_ast", name = "expr", base = NodeAst)]
+#[repr(transparent)]
+pub(crate) struct NodeExpr(NodeAst);
+
+impl_base_node!(NodeExpr);
+
+impl_node!(
+    #[pyclass(module = "_ast", name = "Continue", base = NodeStmt)]
+    pub(crate) struct NodeStmtContinue,
+    attributes: ["lineno", "col_offset", "end_lineno", "end_col_offset"],
+);
+
+impl_node!(
+    #[pyclass(module = "_ast", name = "BoolOp", base = NodeExpr)]
+    pub(crate) struct NodeExprBoolOp,
+    fields: ["op", "values"],
+    attributes: ["lineno", "col_offset", "end_lineno", "end_col_offset"],
+);
+
+impl_node!(
+    #[pyclass(module = "_ast", name = "NamedExpr", base = NodeExpr)]
+    pub(crate) struct NodeExprNamedExpr,
+    fields: ["target", "value"],
+    attributes: ["lineno", "col_offset", "end_lineno", "end_col_offset"],
+);
+
+impl_node!(
+    #[pyclass(module = "_ast", name = "BinOp", base = NodeExpr)]
+    pub(crate) struct NodeExprBinOp,
+    fields: ["left", "op", "right"],
+    attributes: ["lineno", "col_offset", "end_lineno", "end_col_offset"],
+);
+
+impl_node!(
+    #[pyclass(module = "_ast", name = "UnaryOp", base = NodeExpr)]
+    pub(crate) struct NodeExprUnaryOp,
+    fields: ["op", "operand"],
+    attributes: ["lineno", "col_offset", "end_lineno", "end_col_offset"],
+);
+
+impl_node!(
+    #[pyclass(module = "_ast", name = "Lambda", base = NodeExpr)]
+    pub(crate) struct NodeExprLambda,
+    fields: ["args", "body"],
+    attributes: ["lineno", "col_offset", "end_lineno", "end_col_offset"],
+);
+
+impl_node!(
+    #[pyclass(module = "_ast", name = "IfExp", base = NodeExpr)]
+    pub(crate) struct NodeExprIfExp,
+    fields: ["test", "body", "orelse"],
+    attributes: ["lineno", "col_offset", "end_lineno", "end_col_offset"],
+);
+
+impl_node!(
+    #[pyclass(module = "_ast", name = "Dict", base = NodeExpr)]
+    pub(crate) struct NodeExprDict,
+    fields: ["keys", "values"],
+    attributes: ["lineno", "col_offset", "end_lineno", "end_col_offset"],
+);
+
+impl_node!(
+    #[pyclass(module = "_ast", name = "Set", base = NodeExpr)]
+    pub(crate) struct NodeExprSet,
+    fields: ["elts"],
+    attributes: ["lineno", "col_offset", "end_lineno", "end_col_offset"],
+);
+
+impl_node!(
+    #[pyclass(module = "_ast", name = "ListComp", base = NodeExpr)]
+    pub(crate) struct NodeExprListComp,
+    fields: ["elt", "generators"],
+    attributes: ["lineno", "col_offset", "end_lineno", "end_col_offset"],
+);
+
+impl_node!(
+    #[pyclass(module = "_ast", name = "SetComp", base = NodeExpr)]
+    pub(crate) struct NodeExprSetComp,
+    fields: ["elt", "generators"],
+    attributes: ["lineno", "col_offset", "end_lineno", "end_col_offset"],
+);
+
+impl_node!(
+    #[pyclass(module = "_ast", name = "DictComp", base = NodeExpr)]
+    pub(crate) struct NodeExprDictComp,
+    fields: ["key", "value", "generators"],
+    attributes: ["lineno", "col_offset", "end_lineno", "end_col_offset"],
+);
+
+impl_node!(
+    #[pyclass(module = "_ast", name = "GeneratorExp", base = NodeExpr)]
+    pub(crate) struct NodeExprGeneratorExp,
+    fields: ["elt", "generators"],
+    attributes: ["lineno", "col_offset", "end_lineno", "end_col_offset"],
+);
+
+impl_node!(
+    #[pyclass(module = "_ast", name = "Await", base = NodeExpr)]
+    pub(crate) struct NodeExprAwait,
+    fields: ["value"],
+    attributes: ["lineno", "col_offset", "end_lineno", "end_col_offset"],
+);
+
+impl_node!(
+    #[pyclass(module = "_ast", name = "Yield", base = NodeExpr)]
+    pub(crate) struct NodeExprYield,
+    fields: ["value"],
+    attributes: ["lineno", "col_offset", "end_lineno", "end_col_offset"],
+);
+
+impl_node!(
+    #[pyclass(module = "_ast", name = "YieldFrom", base = NodeExpr)]
+    pub(crate) struct NodeExprYieldFrom,
+    fields: ["value"],
+    attributes: ["lineno", "col_offset", "end_lineno", "end_col_offset"],
+);
+
+impl_node!(
+    #[pyclass(module = "_ast", name = "Compare", base = NodeExpr)]
+    pub(crate) struct NodeExprCompare,
+    fields: ["left", "ops", "comparators"],
+    attributes: ["lineno", "col_offset", "end_lineno", "end_col_offset"],
+);
+
+impl_node!(
+    #[pyclass(module = "_ast", name = "Call", base = NodeExpr)]
+    pub(crate) struct NodeExprCall,
+    fields: ["func", "args", "keywords"],
+    attributes: ["lineno", "col_offset", "end_lineno", "end_col_offset"],
+);
+
+impl_node!(
+    #[pyclass(module = "_ast", name = "FormattedValue", base = NodeExpr)]
+    pub(crate) struct NodeExprFormattedValue,
+    fields: ["value", "conversion", "format_spec"],
+    attributes: ["lineno", "col_offset", "end_lineno", "end_col_offset"],
+);
+
+impl_node!(
+    #[pyclass(module = "_ast", name = "JoinedStr", base = NodeExpr)]
+    pub(crate) struct NodeExprJoinedStr,
+    fields: ["values"],
+    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"],
+);
+
+// NodeExprConstant needs custom Initializer to default kind to None
+#[pyclass(module = "_ast", name = "Constant", base = NodeExpr)]
+#[repr(transparent)]
+pub(crate) struct NodeExprConstant(NodeExpr);
+
+#[pyclass(flags(HAS_DICT, BASETYPE), with(Initializer))]
+impl NodeExprConstant {
+    #[extend_class]
+    fn extend_class_with_fields(ctx: &Context, class: &'static Py<PyType>) {
+        // AST types are mutable (heap types, not IMMUTABLETYPE)
+        // Safety: called during type initialization before any concurrent access
+        unsafe {
+            let flags = &class.slots.flags as *const crate::types::PyTypeFlags
+                as *mut crate::types::PyTypeFlags;
+            (*flags).remove(crate::types::PyTypeFlags::IMMUTABLETYPE);
+        }
+        class.set_attr(
+            identifier!(ctx, _fields),
+            ctx.new_tuple(vec![
+                ctx.new_str(ascii!("value")).into(),
+                ctx.new_str(ascii!("kind")).into(),
+            ])
+            .into(),
+        );
+
+        class.set_str_attr(
+            "__match_args__",
+            ctx.new_tuple(vec![
+                ctx.new_str(ascii!("value")).into(),
+                ctx.new_str(ascii!("kind")).into(),
+            ]),
+            ctx,
+        );
+
+        class.set_attr(
+            identifier!(ctx, _attributes),
+            ctx.new_tuple(vec![
+                ctx.new_str(ascii!("lineno")).into(),
+                ctx.new_str(ascii!("col_offset")).into(),
+                ctx.new_str(ascii!("end_lineno")).into(),
+                ctx.new_str(ascii!("end_col_offset")).into(),
+            ])
+            .into(),
+        );
+    }
+}
+
+impl Initializer for NodeExprConstant {
+    type Args = FuncArgs;
+
+    fn slot_init(zelf: PyObjectRef, args: FuncArgs, vm: &VirtualMachine) -> PyResult<()> {
+        <NodeAst as Initializer>::slot_init(zelf.clone(), args, vm)?;
+        // kind defaults to None if not provided
+        let dict = zelf.as_object().dict().unwrap();
+        if !dict.contains_key("kind", vm) {
+            dict.set_item("kind", vm.ctx.none(), vm)?;
+        }
+        Ok(())
+    }
+
+    fn init(_zelf: PyRef<Self>, _args: Self::Args, _vm: &VirtualMachine) -> PyResult<()> {
+        unreachable!("slot_init is defined")
+    }
+}
+
+impl_node!(
+    #[pyclass(module = "_ast", name = "Attribute", base = NodeExpr)]
+    pub(crate) struct NodeExprAttribute,
+    fields: ["value", "attr", "ctx"],
+    attributes: ["lineno", "col_offset", "end_lineno", "end_col_offset"],
+);
+
+impl_node!(
+    #[pyclass(module = "_ast", name = "Subscript", base = NodeExpr)]
+    pub(crate) struct NodeExprSubscript,
+    fields: ["value", "slice", "ctx"],
+    attributes: ["lineno", "col_offset", "end_lineno", "end_col_offset"],
+);
+
+impl_node!(
+    #[pyclass(module = "_ast", name = "Starred", base = NodeExpr)]
+    pub(crate) struct NodeExprStarred,
+    fields: ["value", "ctx"],
+    attributes: ["lineno", "col_offset", "end_lineno", "end_col_offset"],
+);
+
+impl_node!(
+    #[pyclass(module = "_ast", name = "Name", base = NodeExpr)]
+    pub(crate) struct NodeExprName,
+    fields: ["id", "ctx"],
+    attributes: ["lineno", "col_offset", "end_lineno", "end_col_offset"],
+);
+
+impl_node!(
+    #[pyclass(module = "_ast", name = "List", base = NodeExpr)]
+    pub(crate) struct NodeExprList,
+    fields: ["elts", "ctx"],
+    attributes: ["lineno", "col_offset", "end_lineno", "end_col_offset"],
+);
+
+impl_node!(
+    #[pyclass(module = "_ast", name = "Tuple", base = NodeExpr)]
+    pub(crate) struct NodeExprTuple,
+    fields: ["elts", "ctx"],
+    attributes: ["lineno", "col_offset", "end_lineno", "end_col_offset"],
+);
+
+#[pyclass(module = "_ast", name = "expr_context", base = NodeAst)]
+#[repr(transparent)]
+pub(crate) struct NodeExprContext(NodeAst);
+
+impl_base_node!(NodeExprContext);
+
+impl_node!(
+    #[pyclass(module = "_ast", name = "Slice", base = NodeExpr)]
+    pub(crate) struct NodeExprSlice,
+    fields: ["lower", "upper", "step"],
+    attributes: ["lineno", "col_offset", "end_lineno", "end_col_offset"],
+);
+
+impl_node!(
+    #[pyclass(module = "_ast", name = "Load", base = NodeExprContext)]
+    pub(crate) struct NodeExprContextLoad,
+);
+
+impl_node!(
+    #[pyclass(module = "_ast", name = "Store", base = NodeExprContext)]
+    pub(crate) struct NodeExprContextStore,
+);
+
+#[pyclass(module = "_ast", name = "boolop", base = NodeAst)]
+#[repr(transparent)]
+pub(crate) struct NodeBoolOp(NodeAst);
+
+impl_base_node!(NodeBoolOp);
+
+impl_node!(
+    #[pyclass(module = "_ast", name = "Del", base = NodeExprContext)]
+    pub(crate) struct NodeExprContextDel,
+);
+
+impl_node!(
+    #[pyclass(module = "_ast", name = "And", base = NodeBoolOp)]
+    pub(crate) struct NodeBoolOpAnd,
+);
+
+#[pyclass(module = "_ast", name = "operator", base = NodeAst)]
+#[repr(transparent)]
+pub(crate) struct NodeOperator(NodeAst);
+
+impl_base_node!(NodeOperator);
+
+impl_node!(
+    #[pyclass(module = "_ast", name = "Or", base = NodeBoolOp)]
+    pub(crate) struct NodeBoolOpOr,
+);
+
+impl_node!(
+    #[pyclass(module = "_ast", name = "Add", base = NodeOperator)]
+    pub(crate) struct NodeOperatorAdd,
+);
+
+impl_node!(
+    #[pyclass(module = "_ast", name = "Sub", base = NodeOperator)]
+    pub(crate) struct NodeOperatorSub,
+);
+
+impl_node!(
+    #[pyclass(module = "_ast", name = "Mult", base = NodeOperator)]
+    pub(crate) struct NodeOperatorMult,
+);
+
+impl_node!(
+    #[pyclass(module = "_ast", name = "MatMult", base = NodeOperator)]
+    pub(crate) struct NodeOperatorMatMult,
+);
+
+impl_node!(
+    #[pyclass(module = "_ast", name = "Div", base = NodeOperator)]
+    pub(crate) struct NodeOperatorDiv,
+);
+
+impl_node!(
+    #[pyclass(module = "_ast", name = "Mod", base = NodeOperator)]
+    pub(crate) struct NodeOperatorMod,
+);
+
+impl_node!(
+    #[pyclass(module = "_ast", name = "Pow", base = NodeOperator)]
+    pub(crate) struct NodeOperatorPow,
+);
+
+impl_node!(
+    #[pyclass(module = "_ast", name = "LShift", base = NodeOperator)]
+    pub(crate) struct NodeOperatorLShift,
+);
+
+impl_node!(
+    #[pyclass(module = "_ast", name = "RShift", base = NodeOperator)]
+    pub(crate) struct NodeOperatorRShift,
+);
+
+impl_node!(
+    #[pyclass(module = "_ast", name = "BitOr", base = NodeOperator)]
+    pub(crate) struct NodeOperatorBitOr,
+);
+
+impl_node!(
+    #[pyclass(module = "_ast", name = "BitXor", base = NodeOperator)]
+    pub(crate) struct NodeOperatorBitXor,
+);
+
+impl_node!(
+    #[pyclass(module = "_ast", name = "BitAnd", base = NodeOperator)]
+    pub(crate) struct NodeOperatorBitAnd,
+);
+
+#[pyclass(module = "_ast", name = "unaryop", base = NodeAst)]
+#[repr(transparent)]
+pub(crate) struct NodeUnaryOp(NodeAst);
+
+impl_base_node!(NodeUnaryOp);
+
+impl_node!(
+    #[pyclass(module = "_ast", name = "FloorDiv", base = NodeOperator)]
+    pub(crate) struct NodeOperatorFloorDiv,
+);
+
+impl_node!(
+    #[pyclass(module = "_ast", name = "Invert", base = NodeUnaryOp)]
+    pub(crate) struct NodeUnaryOpInvert,
+);
+
+impl_node!(
+    #[pyclass(module = "_ast", name = "Not", base = NodeUnaryOp)]
+    pub(crate) struct NodeUnaryOpNot,
+);
+
+impl_node!(
+    #[pyclass(module = "_ast", name = "UAdd", base = NodeUnaryOp)]
+    pub(crate) struct NodeUnaryOpUAdd,
+);
+
+#[pyclass(module = "_ast", name = "cmpop", base = NodeAst)]
+#[repr(transparent)]
+pub(crate) struct NodeCmpOp(NodeAst);
+
+impl_base_node!(NodeCmpOp);
+
+impl_node!(
+    #[pyclass(module = "_ast", name = "USub", base = NodeUnaryOp)]
+    pub(crate) struct NodeUnaryOpUSub,
+);
+
+impl_node!(
+    #[pyclass(module = "_ast", name = "Eq", base = NodeCmpOp)]
+    pub(crate) struct NodeCmpOpEq,
+);
+
+impl_node!(
+    #[pyclass(module = "_ast", name = "NotEq", base = NodeCmpOp)]
+    pub(crate) struct NodeCmpOpNotEq,
+);
+
+impl_node!(
+    #[pyclass(module = "_ast", name = "Lt", base = NodeCmpOp)]
+    pub(crate) struct NodeCmpOpLt,
+);
+
+impl_node!(
+    #[pyclass(module = "_ast", name = "LtE", base = NodeCmpOp)]
+    pub(crate) struct NodeCmpOpLtE,
+);
+
+impl_node!(
+    #[pyclass(module = "_ast", name = "Gt", base = NodeCmpOp)]
+    pub(crate) struct NodeCmpOpGt,
+);
+
+impl_node!(
+    #[pyclass(module = "_ast", name = "GtE", base = NodeCmpOp)]
+    pub(crate) struct NodeCmpOpGtE,
+);
+
+impl_node!(
+    #[pyclass(module = "_ast", name = "Is", base = NodeCmpOp)]
+    pub(crate) struct NodeCmpOpIs,
+);
+
+impl_node!(
+    #[pyclass(module = "_ast", name = "IsNot", base = NodeCmpOp)]
+    pub(crate) struct NodeCmpOpIsNot,
+);
+
+impl_node!(
+    #[pyclass(module = "_ast", name = "In", base = NodeCmpOp)]
+    pub(crate) struct NodeCmpOpIn,
+);
+
+impl_node!(
+    #[pyclass(module = "_ast", name = "NotIn", base = NodeCmpOp)]
+    pub(crate) struct NodeCmpOpNotIn,
+);
+
+#[pyclass(module = "_ast", name = "excepthandler", base = NodeAst)]
+#[repr(transparent)]
+pub(crate) struct NodeExceptHandler(NodeAst);
+
+impl_base_node!(NodeExceptHandler);
+
+impl_node!(
+    #[pyclass(module = "_ast", name = "comprehension", base = NodeAst)]
+    pub(crate) struct NodeComprehension,
+    fields: ["target", "iter", "ifs", "is_async"],
+);
+
+impl_node!(
+    #[pyclass(module = "_ast", name = "ExceptHandler", base = NodeExceptHandler)]
+    pub(crate) struct NodeExceptHandlerExceptHandler,
+    fields: ["type", "name", "body"],
+    attributes: ["lineno", "col_offset", "end_lineno", "end_col_offset"],
+);
+
+impl_node!(
+    #[pyclass(module = "_ast", name = "arguments", base = NodeAst)]
+    pub(crate) struct NodeArguments,
+    fields: ["posonlyargs", "args", "vararg", "kwonlyargs", "kw_defaults", "kwarg", "defaults"],
+);
+
+impl_node!(
+    #[pyclass(module = "_ast", name = "arg", base = NodeAst)]
+    pub(crate) struct NodeArg,
+    fields: ["arg", "annotation", "type_comment"],
+    attributes: ["lineno", "col_offset", "end_lineno", "end_col_offset"],
+);
+
+impl_node!(
+    #[pyclass(module = "_ast", name = "keyword", base = NodeAst)]
+    pub(crate) struct NodeKeyword,
+    fields: ["arg", "value"],
+    attributes: ["lineno", "col_offset", "end_lineno", "end_col_offset"],
+);
+
+impl_node!(
+    #[pyclass(module = "_ast", name = "alias", base = NodeAst)]
+    pub(crate) struct NodeAlias,
+    fields: ["name", "asname"],
+    attributes: ["lineno", "col_offset", "end_lineno", "end_col_offset"],
+);
+
+impl_node!(
+    #[pyclass(module = "_ast", name = "withitem", base = NodeAst)]
+    pub(crate) struct NodeWithItem,
+    fields: ["context_expr", "optional_vars"],
+);
+
+#[pyclass(module = "_ast", name = "pattern", base = NodeAst)]
+#[repr(transparent)]
+pub(crate) struct NodePattern(NodeAst);
+
+impl_base_node!(NodePattern);
+
+impl_node!(
+    #[pyclass(module = "_ast", name = "match_case", base = NodeAst)]
+    pub(crate) struct NodeMatchCase,
+    fields: ["pattern", "guard", "body"],
+);
+
+impl_node!(
+    #[pyclass(module = "_ast", name = "MatchValue", base = NodePattern)]
+    pub(crate) struct NodePatternMatchValue,
+    fields: ["value"],
+    attributes: ["lineno", "col_offset", "end_lineno", "end_col_offset"],
+);
+
+impl_node!(
+    #[pyclass(module = "_ast", name = "MatchSingleton", base = NodePattern)]
+    pub(crate) struct NodePatternMatchSingleton,
+    fields: ["value"],
+    attributes: ["lineno", "col_offset", "end_lineno", "end_col_offset"],
+);
+
+impl_node!(
+    #[pyclass(module = "_ast", name = "MatchSequence", base = NodePattern)]
+    pub(crate) struct NodePatternMatchSequence,
+    fields: ["patterns"],
+    attributes: ["lineno", "col_offset", "end_lineno", "end_col_offset"],
+);
+
+impl_node!(
+    #[pyclass(module = "_ast", name = "MatchMapping", base = NodePattern)]
+    pub(crate) struct NodePatternMatchMapping,
+    fields: ["keys", "patterns", "rest"],
+    attributes: ["lineno", "col_offset", "end_lineno", "end_col_offset"],
+);
+
+impl_node!(
+    #[pyclass(module = "_ast", name = "MatchClass", base = NodePattern)]
+    pub(crate) struct NodePatternMatchClass,
+    fields: ["cls", "patterns", "kwd_attrs", "kwd_patterns"],
+    attributes: ["lineno", "col_offset", "end_lineno", "end_col_offset"],
+);
+
+impl_node!(
+    #[pyclass(module = "_ast", name = "MatchStar", base = NodePattern)]
+    pub(crate) struct NodePatternMatchStar,
+    fields: ["name"],
+    attributes: ["lineno", "col_offset", "end_lineno", "end_col_offset"],
+);
+
+impl_node!(
+    #[pyclass(module = "_ast", name = "MatchAs", base = NodePattern)]
+    pub(crate) struct NodePatternMatchAs,
+    fields: ["pattern", "name"],
+    attributes: ["lineno", "col_offset", "end_lineno", "end_col_offset"],
+);
+
+#[pyclass(module = "_ast", name = "type_ignore", base = NodeAst)]
+#[repr(transparent)]
+pub(crate) struct NodeTypeIgnore(NodeAst);
+
+impl_base_node!(NodeTypeIgnore);
+
+impl_node!(
+    #[pyclass(module = "_ast", name = "MatchOr", base = NodePattern)]
+    pub(crate) struct NodePatternMatchOr,
+    fields: ["patterns"],
+    attributes: ["lineno", "col_offset", "end_lineno", "end_col_offset"],
+);
+
+#[pyclass(module = "_ast", name = "type_param", base = NodeAst)]
+#[repr(transparent)]
+pub(crate) struct NodeTypeParam(NodeAst);
+
+impl_base_node!(NodeTypeParam);
+
+impl_node!(
+    #[pyclass(module = "_ast", name = "TypeIgnore", base = NodeTypeIgnore)]
+    pub(crate) struct NodeTypeIgnoreTypeIgnore,
+    fields: ["lineno", "tag"],
+);
+
+impl_node!(
+    #[pyclass(module = "_ast", name = "TypeVar", base = NodeTypeParam)]
+    pub(crate) struct NodeTypeParamTypeVar,
+    fields: ["name", "bound", "default_value"],
+    attributes: ["lineno", "col_offset", "end_lineno", "end_col_offset"],
+);
+
+impl_node!(
+    #[pyclass(module = "_ast", name = "ParamSpec", base = NodeTypeParam)]
+    pub(crate) struct NodeTypeParamParamSpec,
+    fields: ["name", "default_value"],
+    attributes: ["lineno", "col_offset", "end_lineno", "end_col_offset"],
+);
+
+impl_node!(
+    #[pyclass(module = "_ast", name = "TypeVarTuple", base = NodeTypeParam)]
+    pub(crate) struct NodeTypeParamTypeVarTuple,
+    fields: ["name", "default_value"],
+    attributes: ["lineno", "col_offset", "end_lineno", "end_col_offset"],
+);
+
+/// Marker for how to resolve an ASDL field type into a Python type object.
+#[derive(Clone, Copy)]
+enum FieldType {
+    /// AST node type reference (e.g. "expr", "stmt")
+    Node(&'static str),
+    /// Built-in type reference (e.g. "str", "int", "object")
+    Builtin(&'static str),
+    /// list[NodeType] — Py_GenericAlias(list, node_type)
+    ListOf(&'static str),
+    /// list[BuiltinType] — Py_GenericAlias(list, builtin_type)
+    ListOfBuiltin(&'static str),
+    /// NodeType | None — Union[node_type, None]
+    Optional(&'static str),
+    /// BuiltinType | None — Union[builtin_type, None]
+    OptionalBuiltin(&'static str),
+}
+
+/// Field type annotations for all concrete AST node classes.
+/// Derived from add_ast_annotations() in Python-ast.c.
+const FIELD_TYPES: &[(&str, &[(&str, FieldType)])] = &[
+    // -- mod --
+    (
+        "Module",
+        &[
+            ("body", FieldType::ListOf("stmt")),
+            ("type_ignores", FieldType::ListOf("type_ignore")),
+        ],
+    ),
+    ("Interactive", &[("body", FieldType::ListOf("stmt"))]),
+    ("Expression", &[("body", FieldType::Node("expr"))]),
+    (
+        "FunctionType",
+        &[
+            ("argtypes", FieldType::ListOf("expr")),
+            ("returns", FieldType::Node("expr")),
+        ],
+    ),
+    // -- stmt --
+    (
+        "FunctionDef",
+        &[
+            ("name", FieldType::Builtin("str")),
+            ("args", FieldType::Node("arguments")),
+            ("body", FieldType::ListOf("stmt")),
+            ("decorator_list", FieldType::ListOf("expr")),
+            ("returns", FieldType::Optional("expr")),
+            ("type_comment", FieldType::OptionalBuiltin("str")),
+            ("type_params", FieldType::ListOf("type_param")),
+        ],
+    ),
+    (
+        "AsyncFunctionDef",
+        &[
+            ("name", FieldType::Builtin("str")),
+            ("args", FieldType::Node("arguments")),
+            ("body", FieldType::ListOf("stmt")),
+            ("decorator_list", FieldType::ListOf("expr")),
+            ("returns", FieldType::Optional("expr")),
+            ("type_comment", FieldType::OptionalBuiltin("str")),
+            ("type_params", FieldType::ListOf("type_param")),
+        ],
+    ),
+    (
+        "ClassDef",
+        &[
+            ("name", FieldType::Builtin("str")),
+            ("bases", FieldType::ListOf("expr")),
+            ("keywords", FieldType::ListOf("keyword")),
+            ("body", FieldType::ListOf("stmt")),
+            ("decorator_list", FieldType::ListOf("expr")),
+            ("type_params", FieldType::ListOf("type_param")),
+        ],
+    ),
+    ("Return", &[("value", FieldType::Optional("expr"))]),
+    ("Delete", &[("targets", FieldType::ListOf("expr"))]),
+    (
+        "Assign",
+        &[
+            ("targets", FieldType::ListOf("expr")),
+            ("value", FieldType::Node("expr")),
+            ("type_comment", FieldType::OptionalBuiltin("str")),
+        ],
+    ),
+    (
+        "TypeAlias",
+        &[
+            ("name", FieldType::Node("expr")),
+            ("type_params", FieldType::ListOf("type_param")),
+            ("value", FieldType::Node("expr")),
+        ],
+    ),
+    (
+        "AugAssign",
+        &[
+            ("target", FieldType::Node("expr")),
+            ("op", FieldType::Node("operator")),
+            ("value", FieldType::Node("expr")),
+        ],
+    ),
+    (
+        "AnnAssign",
+        &[
+            ("target", FieldType::Node("expr")),
+            ("annotation", FieldType::Node("expr")),
+            ("value", FieldType::Optional("expr")),
+            ("simple", FieldType::Builtin("int")),
+        ],
+    ),
+    (
+        "For",
+        &[
+            ("target", FieldType::Node("expr")),
+            ("iter", FieldType::Node("expr")),
+            ("body", FieldType::ListOf("stmt")),
+            ("orelse", FieldType::ListOf("stmt")),
+            ("type_comment", FieldType::OptionalBuiltin("str")),
+        ],
+    ),
+    (
+        "AsyncFor",
+        &[
+            ("target", FieldType::Node("expr")),
+            ("iter", FieldType::Node("expr")),
+            ("body", FieldType::ListOf("stmt")),
+            ("orelse", FieldType::ListOf("stmt")),
+            ("type_comment", FieldType::OptionalBuiltin("str")),
+        ],
+    ),
+    (
+        "While",
+        &[
+            ("test", FieldType::Node("expr")),
+            ("body", FieldType::ListOf("stmt")),
+            ("orelse", FieldType::ListOf("stmt")),
+        ],
+    ),
+    (
+        "If",
+        &[
+            ("test", FieldType::Node("expr")),
+            ("body", FieldType::ListOf("stmt")),
+            ("orelse", FieldType::ListOf("stmt")),
+        ],
+    ),
+    (
+        "With",
+        &[
+            ("items", FieldType::ListOf("withitem")),
+            ("body", FieldType::ListOf("stmt")),
+            ("type_comment", FieldType::OptionalBuiltin("str")),
+        ],
+    ),
+    (
+        "AsyncWith",
+        &[
+            ("items", FieldType::ListOf("withitem")),
+            ("body", FieldType::ListOf("stmt")),
+            ("type_comment", FieldType::OptionalBuiltin("str")),
+        ],
+    ),
+    (
+        "Match",
+        &[
+            ("subject", FieldType::Node("expr")),
+            ("cases", FieldType::ListOf("match_case")),
+        ],
+    ),
+    (
+        "Raise",
+        &[
+            ("exc", FieldType::Optional("expr")),
+            ("cause", FieldType::Optional("expr")),
+        ],
+    ),
+    (
+        "Try",
+        &[
+            ("body", FieldType::ListOf("stmt")),
+            ("handlers", FieldType::ListOf("excepthandler")),
+            ("orelse", FieldType::ListOf("stmt")),
+            ("finalbody", FieldType::ListOf("stmt")),
+        ],
+    ),
+    (
+        "TryStar",
+        &[
+            ("body", FieldType::ListOf("stmt")),
+            ("handlers", FieldType::ListOf("excepthandler")),
+            ("orelse", FieldType::ListOf("stmt")),
+            ("finalbody", FieldType::ListOf("stmt")),
+        ],
+    ),
+    (
+        "Assert",
+        &[
+            ("test", FieldType::Node("expr")),
+            ("msg", FieldType::Optional("expr")),
+        ],
+    ),
+    ("Import", &[("names", FieldType::ListOf("alias"))]),
+    (
+        "ImportFrom",
+        &[
+            ("module", FieldType::OptionalBuiltin("str")),
+            ("names", FieldType::ListOf("alias")),
+            ("level", FieldType::OptionalBuiltin("int")),
+        ],
+    ),
+    ("Global", &[("names", FieldType::ListOfBuiltin("str"))]),
+    ("Nonlocal", &[("names", FieldType::ListOfBuiltin("str"))]),
+    ("Expr", &[("value", FieldType::Node("expr"))]),
+    // -- expr --
+    (
+        "BoolOp",
+        &[
+            ("op", FieldType::Node("boolop")),
+            ("values", FieldType::ListOf("expr")),
+        ],
+    ),
+    (
+        "NamedExpr",
+        &[
+            ("target", FieldType::Node("expr")),
+            ("value", FieldType::Node("expr")),
+        ],
+    ),
+    (
+        "BinOp",
+        &[
+            ("left", FieldType::Node("expr")),
+            ("op", FieldType::Node("operator")),
+            ("right", FieldType::Node("expr")),
+        ],
+    ),
+    (
+        "UnaryOp",
+        &[
+            ("op", FieldType::Node("unaryop")),
+            ("operand", FieldType::Node("expr")),
+        ],
+    ),
+    (
+        "Lambda",
+        &[
+            ("args", FieldType::Node("arguments")),
+            ("body", FieldType::Node("expr")),
+        ],
+    ),
+    (
+        "IfExp",
+        &[
+            ("test", FieldType::Node("expr")),
+            ("body", FieldType::Node("expr")),
+            ("orelse", FieldType::Node("expr")),
+        ],
+    ),
+    (
+        "Dict",
+        &[
+            ("keys", FieldType::ListOf("expr")),
+            ("values", FieldType::ListOf("expr")),
+        ],
+    ),
+    ("Set", &[("elts", FieldType::ListOf("expr"))]),
+    (
+        "ListComp",
+        &[
+            ("elt", FieldType::Node("expr")),
+            ("generators", FieldType::ListOf("comprehension")),
+        ],
+    ),
+    (
+        "SetComp",
+        &[
+            ("elt", FieldType::Node("expr")),
+            ("generators", FieldType::ListOf("comprehension")),
+        ],
+    ),
+    (
+        "DictComp",
+        &[
+            ("key", FieldType::Node("expr")),
+            ("value", FieldType::Node("expr")),
+            ("generators", FieldType::ListOf("comprehension")),
+        ],
+    ),
+    (
+        "GeneratorExp",
+        &[
+            ("elt", FieldType::Node("expr")),
+            ("generators", FieldType::ListOf("comprehension")),
+        ],
+    ),
+    ("Await", &[("value", FieldType::Node("expr"))]),
+    ("Yield", &[("value", FieldType::Optional("expr"))]),
+    ("YieldFrom", &[("value", FieldType::Node("expr"))]),
+    (
+        "Compare",
+        &[
+            ("left", FieldType::Node("expr")),
+            ("ops", FieldType::ListOf("cmpop")),
+            ("comparators", FieldType::ListOf("expr")),
+        ],
+    ),
+    (
+        "Call",
+        &[
+            ("func", FieldType::Node("expr")),
+            ("args", FieldType::ListOf("expr")),
+            ("keywords", FieldType::ListOf("keyword")),
+        ],
+    ),
+    (
+        "FormattedValue",
+        &[
+            ("value", FieldType::Node("expr")),
+            ("conversion", FieldType::Builtin("int")),
+            ("format_spec", FieldType::Optional("expr")),
+        ],
+    ),
+    ("JoinedStr", &[("values", FieldType::ListOf("expr"))]),
+    ("TemplateStr", &[("values", FieldType::ListOf("expr"))]),
+    (
+        "Interpolation",
+        &[
+            ("value", FieldType::Node("expr")),
+            ("str", FieldType::Builtin("object")),
+            ("conversion", FieldType::Builtin("int")),
+            ("format_spec", FieldType::Optional("expr")),
+        ],
+    ),
+    (
+        "Constant",
+        &[
+            ("value", FieldType::Builtin("object")),
+            ("kind", FieldType::OptionalBuiltin("str")),
+        ],
+    ),
+    (
+        "Attribute",
+        &[
+            ("value", FieldType::Node("expr")),
+            ("attr", FieldType::Builtin("str")),
+            ("ctx", FieldType::Node("expr_context")),
+        ],
+    ),
+    (
+        "Subscript",
+        &[
+            ("value", FieldType::Node("expr")),
+            ("slice", FieldType::Node("expr")),
+            ("ctx", FieldType::Node("expr_context")),
+        ],
+    ),
+    (
+        "Starred",
+        &[
+            ("value", FieldType::Node("expr")),
+            ("ctx", FieldType::Node("expr_context")),
+        ],
+    ),
+    (
+        "Name",
+        &[
+            ("id", FieldType::Builtin("str")),
+            ("ctx", FieldType::Node("expr_context")),
+        ],
+    ),
+    (
+        "List",
+        &[
+            ("elts", FieldType::ListOf("expr")),
+            ("ctx", FieldType::Node("expr_context")),
+        ],
+    ),
+    (
+        "Tuple",
+        &[
+            ("elts", FieldType::ListOf("expr")),
+            ("ctx", FieldType::Node("expr_context")),
+        ],
+    ),
+    (
+        "Slice",
+        &[
+            ("lower", FieldType::Optional("expr")),
+            ("upper", FieldType::Optional("expr")),
+            ("step", FieldType::Optional("expr")),
+        ],
+    ),
+    // -- misc --
+    (
+        "comprehension",
+        &[
+            ("target", FieldType::Node("expr")),
+            ("iter", FieldType::Node("expr")),
+            ("ifs", FieldType::ListOf("expr")),
+            ("is_async", FieldType::Builtin("int")),
+        ],
+    ),
+    (
+        "ExceptHandler",
+        &[
+            ("type", FieldType::Optional("expr")),
+            ("name", FieldType::OptionalBuiltin("str")),
+            ("body", FieldType::ListOf("stmt")),
+        ],
+    ),
+    (
+        "arguments",
+        &[
+            ("posonlyargs", FieldType::ListOf("arg")),
+            ("args", FieldType::ListOf("arg")),
+            ("vararg", FieldType::Optional("arg")),
+            ("kwonlyargs", FieldType::ListOf("arg")),
+            ("kw_defaults", FieldType::ListOf("expr")),
+            ("kwarg", FieldType::Optional("arg")),
+            ("defaults", FieldType::ListOf("expr")),
+        ],
+    ),
+    (
+        "arg",
+        &[
+            ("arg", FieldType::Builtin("str")),
+            ("annotation", FieldType::Optional("expr")),
+            ("type_comment", FieldType::OptionalBuiltin("str")),
+        ],
+    ),
+    (
+        "keyword",
+        &[
+            ("arg", FieldType::OptionalBuiltin("str")),
+            ("value", FieldType::Node("expr")),
+        ],
+    ),
+    (
+        "alias",
+        &[
+            ("name", FieldType::Builtin("str")),
+            ("asname", FieldType::OptionalBuiltin("str")),
+        ],
+    ),
+    (
+        "withitem",
+        &[
+            ("context_expr", FieldType::Node("expr")),
+            ("optional_vars", FieldType::Optional("expr")),
+        ],
+    ),
+    (
+        "match_case",
+        &[
+            ("pattern", FieldType::Node("pattern")),
+            ("guard", FieldType::Optional("expr")),
+            ("body", FieldType::ListOf("stmt")),
+        ],
+    ),
+    // -- pattern --
+    ("MatchValue", &[("value", FieldType::Node("expr"))]),
+    ("MatchSingleton", &[("value", FieldType::Builtin("object"))]),
+    (
+        "MatchSequence",
+        &[("patterns", FieldType::ListOf("pattern"))],
+    ),
+    (
+        "MatchMapping",
+        &[
+            ("keys", FieldType::ListOf("expr")),
+            ("patterns", FieldType::ListOf("pattern")),
+            ("rest", FieldType::OptionalBuiltin("str")),
+        ],
+    ),
+    (
+        "MatchClass",
+        &[
+            ("cls", FieldType::Node("expr")),
+            ("patterns", FieldType::ListOf("pattern")),
+            ("kwd_attrs", FieldType::ListOfBuiltin("str")),
+            ("kwd_patterns", FieldType::ListOf("pattern")),
+        ],
+    ),
+    ("MatchStar", &[("name", FieldType::OptionalBuiltin("str"))]),
+    (
+        "MatchAs",
+        &[
+            ("pattern", FieldType::Optional("pattern")),
+            ("name", FieldType::OptionalBuiltin("str")),
+        ],
+    ),
+    ("MatchOr", &[("patterns", FieldType::ListOf("pattern"))]),
+    // -- type_ignore --
+    (
+        "TypeIgnore",
+        &[
+            ("lineno", FieldType::Builtin("int")),
+            ("tag", FieldType::Builtin("str")),
+        ],
+    ),
+    // -- type_param --
+    (
+        "TypeVar",
+        &[
+            ("name", FieldType::Builtin("str")),
+            ("bound", FieldType::Optional("expr")),
+            ("default_value", FieldType::Optional("expr")),
+        ],
+    ),
+    (
+        "ParamSpec",
+        &[
+            ("name", FieldType::Builtin("str")),
+            ("default_value", FieldType::Optional("expr")),
+        ],
+    ),
+    (
+        "TypeVarTuple",
+        &[
+            ("name", FieldType::Builtin("str")),
+            ("default_value", FieldType::Optional("expr")),
+        ],
+    ),
+];
+
+pub fn extend_module_nodes(vm: &VirtualMachine, module: &Py<PyModule>) {
+    extend_module!(vm, module, {
+        "AST" => NodeAst::make_static_type(),
+        "mod" => NodeMod::make_static_type(),
+        "Module" => NodeModModule::make_static_type(),
+        "Interactive" => NodeModInteractive::make_static_type(),
+        "Expression" => NodeModExpression::make_static_type(),
+        "FunctionType" => NodeModFunctionType::make_static_type(),
+        "stmt" => NodeStmt::make_static_type(),
+        "FunctionDef" => NodeStmtFunctionDef::make_static_type(),
+        "AsyncFunctionDef" => NodeStmtAsyncFunctionDef::make_static_type(),
+        "ClassDef" => NodeStmtClassDef::make_static_type(),
+        "Return" => NodeStmtReturn::make_static_type(),
+        "Delete" => NodeStmtDelete::make_static_type(),
+        "Assign" => NodeStmtAssign::make_static_type(),
+        "TypeAlias" => NodeStmtTypeAlias::make_static_type(),
+        "AugAssign" => NodeStmtAugAssign::make_static_type(),
+        "AnnAssign" => NodeStmtAnnAssign::make_static_type(),
+        "For" => NodeStmtFor::make_static_type(),
+        "AsyncFor" => NodeStmtAsyncFor::make_static_type(),
+        "While" => NodeStmtWhile::make_static_type(),
+        "If" => NodeStmtIf::make_static_type(),
+        "With" => NodeStmtWith::make_static_type(),
+        "AsyncWith" => NodeStmtAsyncWith::make_static_type(),
+        "Match" => NodeStmtMatch::make_static_type(),
+        "Raise" => NodeStmtRaise::make_static_type(),
+        "Try" => NodeStmtTry::make_static_type(),
+        "TryStar" => NodeStmtTryStar::make_static_type(),
+        "Assert" => NodeStmtAssert::make_static_type(),
+        "Import" => NodeStmtImport::make_static_type(),
+        "ImportFrom" => NodeStmtImportFrom::make_static_type(),
+        "Global" => NodeStmtGlobal::make_static_type(),
+        "Nonlocal" => NodeStmtNonlocal::make_static_type(),
+        "Expr" => NodeStmtExpr::make_static_type(),
+        "Pass" => NodeStmtPass::make_static_type(),
+        "Break" => NodeStmtBreak::make_static_type(),
+        "Continue" => NodeStmtContinue::make_static_type(),
+        "expr" => NodeExpr::make_static_type(),
+        "BoolOp" => NodeExprBoolOp::make_static_type(),
+        "NamedExpr" => NodeExprNamedExpr::make_static_type(),
+        "BinOp" => NodeExprBinOp::make_static_type(),
+        "UnaryOp" => NodeExprUnaryOp::make_static_type(),
+        "Lambda" => NodeExprLambda::make_static_type(),
+        "IfExp" => NodeExprIfExp::make_static_type(),
+        "Dict" => NodeExprDict::make_static_type(),
+        "Set" => NodeExprSet::make_static_type(),
+        "ListComp" => NodeExprListComp::make_static_type(),
+        "SetComp" => NodeExprSetComp::make_static_type(),
+        "DictComp" => NodeExprDictComp::make_static_type(),
+        "GeneratorExp" => NodeExprGeneratorExp::make_static_type(),
+        "Await" => NodeExprAwait::make_static_type(),
+        "Yield" => NodeExprYield::make_static_type(),
+        "YieldFrom" => NodeExprYieldFrom::make_static_type(),
+        "Compare" => NodeExprCompare::make_static_type(),
+        "Call" => NodeExprCall::make_static_type(),
+        "FormattedValue" => NodeExprFormattedValue::make_static_type(),
+        "JoinedStr" => NodeExprJoinedStr::make_static_type(),
+        "TemplateStr" => NodeExprTemplateStr::make_static_type(),
+        "Interpolation" => NodeExprInterpolation::make_static_type(),
+        "Constant" => NodeExprConstant::make_static_type(),
+        "Attribute" => NodeExprAttribute::make_static_type(),
+        "Subscript" => NodeExprSubscript::make_static_type(),
+        "Starred" => NodeExprStarred::make_static_type(),
+        "Name" => NodeExprName::make_static_type(),
+        "List" => NodeExprList::make_static_type(),
+        "Tuple" => NodeExprTuple::make_static_type(),
+        "Slice" => NodeExprSlice::make_static_type(),
+        "expr_context" => NodeExprContext::make_static_type(),
+        "Load" => NodeExprContextLoad::make_static_type(),
+        "Store" => NodeExprContextStore::make_static_type(),
+        "Del" => NodeExprContextDel::make_static_type(),
+        "boolop" => NodeBoolOp::make_static_type(),
+        "And" => NodeBoolOpAnd::make_static_type(),
+        "Or" => NodeBoolOpOr::make_static_type(),
+        "operator" => NodeOperator::make_static_type(),
+        "Add" => NodeOperatorAdd::make_static_type(),
+        "Sub" => NodeOperatorSub::make_static_type(),
+        "Mult" => NodeOperatorMult::make_static_type(),
+        "MatMult" => NodeOperatorMatMult::make_static_type(),
+        "Div" => NodeOperatorDiv::make_static_type(),
+        "Mod" => NodeOperatorMod::make_static_type(),
+        "Pow" => NodeOperatorPow::make_static_type(),
+        "LShift" => NodeOperatorLShift::make_static_type(),
+        "RShift" => NodeOperatorRShift::make_static_type(),
+        "BitOr" => NodeOperatorBitOr::make_static_type(),
+        "BitXor" => NodeOperatorBitXor::make_static_type(),
+        "BitAnd" => NodeOperatorBitAnd::make_static_type(),
+        "FloorDiv" => NodeOperatorFloorDiv::make_static_type(),
+        "unaryop" => NodeUnaryOp::make_static_type(),
+        "Invert" => NodeUnaryOpInvert::make_static_type(),
+        "Not" => NodeUnaryOpNot::make_static_type(),
+        "UAdd" => NodeUnaryOpUAdd::make_static_type(),
+        "USub" => NodeUnaryOpUSub::make_static_type(),
+        "cmpop" => NodeCmpOp::make_static_type(),
+        "Eq" => NodeCmpOpEq::make_static_type(),
+        "NotEq" => NodeCmpOpNotEq::make_static_type(),
+        "Lt" => NodeCmpOpLt::make_static_type(),
+        "LtE" => NodeCmpOpLtE::make_static_type(),
+        "Gt" => NodeCmpOpGt::make_static_type(),
+        "GtE" => NodeCmpOpGtE::make_static_type(),
+        "Is" => NodeCmpOpIs::make_static_type(),
+        "IsNot" => NodeCmpOpIsNot::make_static_type(),
+        "In" => NodeCmpOpIn::make_static_type(),
+        "NotIn" => NodeCmpOpNotIn::make_static_type(),
+        "comprehension" => NodeComprehension::make_static_type(),
+        "excepthandler" => NodeExceptHandler::make_static_type(),
+        "ExceptHandler" => NodeExceptHandlerExceptHandler::make_static_type(),
+        "arguments" => NodeArguments::make_static_type(),
+        "arg" => NodeArg::make_static_type(),
+        "keyword" => NodeKeyword::make_static_type(),
+        "alias" => NodeAlias::make_static_type(),
+        "withitem" => NodeWithItem::make_static_type(),
+        "match_case" => NodeMatchCase::make_static_type(),
+        "pattern" => NodePattern::make_static_type(),
+        "MatchValue" => NodePatternMatchValue::make_static_type(),
+        "MatchSingleton" => NodePatternMatchSingleton::make_static_type(),
+        "MatchSequence" => NodePatternMatchSequence::make_static_type(),
+        "MatchMapping" => NodePatternMatchMapping::make_static_type(),
+        "MatchClass" => NodePatternMatchClass::make_static_type(),
+        "MatchStar" => NodePatternMatchStar::make_static_type(),
+        "MatchAs" => NodePatternMatchAs::make_static_type(),
+        "MatchOr" => NodePatternMatchOr::make_static_type(),
+        "type_ignore" => NodeTypeIgnore::make_static_type(),
+        "TypeIgnore" => NodeTypeIgnoreTypeIgnore::make_static_type(),
+        "type_param" => NodeTypeParam::make_static_type(),
+        "TypeVar" => NodeTypeParamTypeVar::make_static_type(),
+        "ParamSpec" => NodeTypeParamParamSpec::make_static_type(),
+        "TypeVarTuple" => NodeTypeParamTypeVarTuple::make_static_type(),
+    });
+
+    // Populate _field_types with real Python type objects
+    populate_field_types(vm, module);
+    populate_singletons(vm, module);
+    force_ast_module_name(vm, module);
+    populate_repr(vm, module);
+}
+
+fn populate_field_types(vm: &VirtualMachine, module: &Py<PyModule>) {
+    let list_type: PyTypeRef = vm.ctx.types.list_type.to_owned();
+    let none_type: PyObjectRef = vm.ctx.types.none_type.to_owned().into();
+
+    // Resolve a builtin type name to a Python type object
+    let resolve_builtin = |name: &str| -> PyObjectRef {
+        let ty: &Py<PyType> = match name {
+            "str" => vm.ctx.types.str_type,
+            "int" => vm.ctx.types.int_type,
+            "object" => vm.ctx.types.object_type,
+            "bool" => vm.ctx.types.bool_type,
+            _ => unreachable!("unknown builtin type: {name}"),
+        };
+        ty.to_owned().into()
+    };
+
+    // Resolve an AST node type name by looking it up from the module
+    let resolve_node = |name: &str| -> PyObjectRef {
+        module
+            .get_attr(vm.ctx.intern_str(name), vm)
+            .unwrap_or_else(|_| panic!("AST node type '{name}' not found in module"))
+    };
+
+    let field_types_attr = vm.ctx.intern_str("_field_types");
+    let annotations_attr = vm.ctx.intern_str("__annotations__");
+    let empty_dict: PyObjectRef = vm.ctx.new_dict().into();
+
+    for &(class_name, fields) in FIELD_TYPES {
+        if fields.is_empty() {
+            continue;
+        }
+
+        let class = module
+            .get_attr(class_name, vm)
+            .unwrap_or_else(|_| panic!("AST class '{class_name}' not found in module"));
+        let dict = vm.ctx.new_dict();
+
+        for &(field_name, ref field_type) in fields {
+            let type_obj = match field_type {
+                FieldType::Node(name) => resolve_node(name),
+                FieldType::Builtin(name) => resolve_builtin(name),
+                FieldType::ListOf(name) => {
+                    let elem = resolve_node(name);
+                    let args = PyTuple::new_ref(vec![elem], &vm.ctx);
+                    PyGenericAlias::new(list_type.clone(), args, false, vm).to_pyobject(vm)
+                }
+                FieldType::ListOfBuiltin(name) => {
+                    let elem = resolve_builtin(name);
+                    let args = PyTuple::new_ref(vec![elem], &vm.ctx);
+                    PyGenericAlias::new(list_type.clone(), args, false, vm).to_pyobject(vm)
+                }
+                FieldType::Optional(name) => {
+                    let base = resolve_node(name);
+                    let union_args = PyTuple::new_ref(vec![base, none_type.clone()], &vm.ctx);
+                    make_union(&union_args, vm).expect("failed to create union type")
+                }
+                FieldType::OptionalBuiltin(name) => {
+                    let base = resolve_builtin(name);
+                    let union_args = PyTuple::new_ref(vec![base, none_type.clone()], &vm.ctx);
+                    make_union(&union_args, vm).expect("failed to create union type")
+                }
+            };
+            dict.set_item(vm.ctx.intern_str(field_name), type_obj, vm)
+                .expect("failed to set field type");
+        }
+
+        let dict_obj: PyObjectRef = dict.into();
+        if let Some(type_obj) = class.downcast_ref::<PyType>() {
+            type_obj.set_attr(field_types_attr, dict_obj.clone());
+            type_obj.set_attr(annotations_attr, dict_obj);
+
+            // Set None as class-level default for optional fields.
+            // When ast_type_init skips optional fields, the instance
+            // inherits None from the class (init_types in Python-ast.c).
+            let none = vm.ctx.none();
+            for &(field_name, ref field_type) in fields {
+                if matches!(
+                    field_type,
+                    FieldType::Optional(_) | FieldType::OptionalBuiltin(_)
+                ) {
+                    type_obj.set_attr(vm.ctx.intern_str(field_name), none.clone());
+                }
+            }
+        }
+    }
+
+    // CPython sets __annotations__ for all built-in AST node classes, even
+    // when _field_types is an empty dict (e.g., operators, Load/Store/Del).
+    for (_name, value) in &module.dict() {
+        let Some(type_obj) = value.downcast_ref::<PyType>() else {
+            continue;
+        };
+        if let Some(field_types) = type_obj.get_attr(field_types_attr) {
+            type_obj.set_attr(annotations_attr, field_types);
+        }
+    }
+
+    // Base AST classes (e.g., expr, stmt) should still expose __annotations__.
+    const BASE_AST_TYPES: &[&str] = &[
+        "mod",
+        "stmt",
+        "expr",
+        "expr_context",
+        "boolop",
+        "operator",
+        "unaryop",
+        "cmpop",
+        "excepthandler",
+        "pattern",
+        "type_ignore",
+        "type_param",
+    ];
+    for &class_name in BASE_AST_TYPES {
+        let class = module
+            .get_attr(class_name, vm)
+            .unwrap_or_else(|_| panic!("AST class '{class_name}' not found in module"));
+        let Some(type_obj) = class.downcast_ref::<PyType>() else {
+            continue;
+        };
+        if type_obj.get_attr(field_types_attr).is_none() {
+            type_obj.set_attr(field_types_attr, empty_dict.clone());
+        }
+        if type_obj.get_attr(annotations_attr).is_none() {
+            type_obj.set_attr(annotations_attr, empty_dict.clone());
+        }
+    }
+}
+
+fn populate_singletons(vm: &VirtualMachine, module: &Py<PyModule>) {
+    let instance_attr = vm.ctx.intern_str("_instance");
+    const SINGLETON_TYPES: &[&str] = &[
+        // expr_context
+        "Load", "Store", "Del", // boolop
+        "And", "Or", // operator
+        "Add", "Sub", "Mult", "MatMult", "Div", "Mod", "Pow", "LShift", "RShift", "BitOr",
+        "BitXor", "BitAnd", "FloorDiv", // unaryop
+        "Invert", "Not", "UAdd", "USub", // cmpop
+        "Eq", "NotEq", "Lt", "LtE", "Gt", "GtE", "Is", "IsNot", "In", "NotIn",
+    ];
+
+    for &class_name in SINGLETON_TYPES {
+        let class = module
+            .get_attr(class_name, vm)
+            .unwrap_or_else(|_| panic!("AST class '{class_name}' not found in module"));
+        let Some(type_obj) = class.downcast_ref::<PyType>() else {
+            continue;
+        };
+        let instance = vm
+            .ctx
+            .new_base_object(type_obj.to_owned(), Some(vm.ctx.new_dict()));
+        type_obj.set_attr(instance_attr, instance);
+    }
+}
+
+fn force_ast_module_name(vm: &VirtualMachine, module: &Py<PyModule>) {
+    let ast_name = vm.ctx.new_str("ast");
+    for (_name, value) in &module.dict() {
+        let Some(type_obj) = value.downcast_ref::<PyType>() else {
+            continue;
+        };
+        type_obj.set_attr(identifier!(vm, __module__), ast_name.clone().into());
+    }
+}
+
+fn populate_repr(_vm: &VirtualMachine, module: &Py<PyModule>) {
+    for (_name, value) in &module.dict() {
+        let Some(type_obj) = value.downcast_ref::<PyType>() else {
+            continue;
+        };
+        type_obj
+            .slots
+            .repr
+            .store(Some(super::python::_ast::ast_repr));
+    }
+}
diff --git a/crates/vm/src/stdlib/_ast/python.rs b/crates/vm/src/stdlib/_ast/python.rs
new file mode 100644
index 00000000000..5c97d759934
--- /dev/null
+++ b/crates/vm/src/stdlib/_ast/python.rs
@@ -0,0 +1,525 @@
+use super::{
+    PY_CF_ALLOW_INCOMPLETE_INPUT, PY_CF_ALLOW_TOP_LEVEL_AWAIT, PY_CF_DONT_IMPLY_DEDENT,
+    PY_CF_IGNORE_COOKIE, PY_CF_ONLY_AST, PY_CF_OPTIMIZED_AST, PY_CF_SOURCE_IS_UTF8,
+    PY_CF_TYPE_COMMENTS,
+};
+
+#[pymodule]
+pub(crate) mod _ast {
+    use crate::{
+        AsObject, Context, Py, PyObjectRef, PyPayload, PyRef, PyResult, VirtualMachine,
+        builtins::{PyStr, PyStrRef, PyTupleRef, PyType, PyTypeRef, PyUtf8Str, PyUtf8StrRef},
+        class::{PyClassImpl, StaticType},
+        common::wtf8::Wtf8,
+        function::{FuncArgs, KwArgs, PyMethodDef, PyMethodFlags},
+        stdlib::_ast::repr,
+        types::{Constructor, Initializer},
+        warn,
+    };
+    use indexmap::IndexMap;
+    #[pyattr]
+    #[pyclass(module = "_ast", name = "AST")]
+    #[derive(Debug, PyPayload)]
+    pub(crate) struct NodeAst;
+
+    #[pyclass(with(Constructor, Initializer), flags(BASETYPE, HAS_DICT))]
+    impl NodeAst {
+        #[extend_class]
+        fn extend_class(ctx: &Context, class: &'static Py<PyType>) {
+            // AST types are mutable (heap types, not IMMUTABLETYPE)
+            // Safety: called during type initialization before any concurrent access
+            unsafe {
+                let flags = &class.slots.flags as *const crate::types::PyTypeFlags
+                    as *mut crate::types::PyTypeFlags;
+                (*flags).remove(crate::types::PyTypeFlags::IMMUTABLETYPE);
+            }
+            let empty_tuple = ctx.empty_tuple.clone();
+            class.set_str_attr("_fields", empty_tuple.clone(), ctx);
+            class.set_str_attr("_attributes", empty_tuple.clone(), ctx);
+            class.set_str_attr("__match_args__", empty_tuple.clone(), ctx);
+
+            const AST_REDUCE: PyMethodDef = PyMethodDef::new_const(
+                "__reduce__",
+                |zelf: PyObjectRef, vm: &VirtualMachine| -> PyResult<PyTupleRef> {
+                    ast_reduce(zelf, vm)
+                },
+                PyMethodFlags::METHOD,
+                None,
+            );
+            const AST_REPLACE: PyMethodDef = PyMethodDef::new_const(
+                "__replace__",
+                |zelf: PyObjectRef, args: FuncArgs, vm: &VirtualMachine| -> PyResult {
+                    ast_replace(zelf, args, vm)
+                },
+                PyMethodFlags::METHOD,
+                None,
+            );
+
+            class.set_str_attr("__reduce__", AST_REDUCE.to_proper_method(class, ctx), ctx);
+            class.set_str_attr("__replace__", AST_REPLACE.to_proper_method(class, ctx), ctx);
+            class.slots.repr.store(Some(ast_repr));
+        }
+
+        #[pyattr]
+        fn _fields(ctx: &Context) -> PyTupleRef {
+            ctx.empty_tuple.clone()
+        }
+
+        #[pyattr]
+        fn _attributes(ctx: &Context) -> PyTupleRef {
+            ctx.empty_tuple.clone()
+        }
+
+        #[pyattr]
+        fn __match_args__(ctx: &Context) -> PyTupleRef {
+            ctx.empty_tuple.clone()
+        }
+
+        #[pymethod]
+        fn __reduce__(zelf: PyObjectRef, vm: &VirtualMachine) -> PyResult<PyTupleRef> {
+            ast_reduce(zelf, vm)
+        }
+
+        #[pymethod]
+        fn __replace__(zelf: PyObjectRef, args: FuncArgs, vm: &VirtualMachine) -> PyResult {
+            ast_replace(zelf, args, vm)
+        }
+    }
+
+    pub(crate) fn ast_reduce(zelf: PyObjectRef, vm: &VirtualMachine) -> PyResult<PyTupleRef> {
+        let dict = zelf.as_object().dict();
+        let cls = zelf.class();
+        let type_obj: PyObjectRef = cls.to_owned().into();
+
+        let Some(dict) = dict else {
+            return Ok(vm.ctx.new_tuple(vec![type_obj]));
+        };
+
+        let fields = cls.get_attr(vm.ctx.intern_str("_fields"));
+        if let Some(fields) = fields {
+            let fields: Vec<PyStrRef> = fields.try_to_value(vm)?;
+            let mut positional: Vec<PyObjectRef> = Vec::new();
+            for field in fields {
+                if dict.get_item_opt::<Wtf8>(field.as_wtf8(), vm)?.is_some() {
+                    positional.push(vm.ctx.none());
+                } else {
+                    break;
+                }
+            }
+            let args: PyObjectRef = vm.ctx.new_tuple(positional).into();
+            let dict_obj: PyObjectRef = dict.into();
+            return Ok(vm.ctx.new_tuple(vec![type_obj, args, dict_obj]));
+        }
+
+        Ok(vm
+            .ctx
+            .new_tuple(vec![type_obj, vm.ctx.new_tuple(vec![]).into(), dict.into()]))
+    }
+
+    pub(crate) fn ast_replace(zelf: PyObjectRef, args: FuncArgs, vm: &VirtualMachine) -> PyResult {
+        if !args.args.is_empty() {
+            return Err(vm.new_type_error("__replace__() takes no positional arguments"));
+        }
+
+        let cls = zelf.class();
+        let fields = cls.get_attr(vm.ctx.intern_str("_fields"));
+        let attributes = cls.get_attr(vm.ctx.intern_str("_attributes"));
+        let dict = zelf.as_object().dict();
+
+        let mut expecting: std::collections::HashSet<String> = std::collections::HashSet::new();
+        if let Some(fields) = fields.clone() {
+            let fields: Vec<PyUtf8StrRef> = fields.try_to_value(vm)?;
+            for field in fields {
+                expecting.insert(field.as_str().to_owned());
+            }
+        }
+        if let Some(attributes) = attributes.clone() {
+            let attributes: Vec<PyUtf8StrRef> = attributes.try_to_value(vm)?;
+            for attr in attributes {
+                expecting.insert(attr.as_str().to_owned());
+            }
+        }
+
+        for (key, _value) in &args.kwargs {
+            if !expecting.remove(key) {
+                return Err(vm.new_type_error(format!(
+                    "{}.__replace__ got an unexpected keyword argument '{}'.",
+                    cls.name(),
+                    key
+                )));
+            }
+        }
+
+        if let Some(dict) = dict.as_ref() {
+            for (key, _value) in dict.items_vec() {
+                if let Ok(key) = key.downcast::<PyUtf8Str>() {
+                    expecting.remove(key.as_str());
+                }
+            }
+            if let Some(attributes) = attributes.clone() {
+                let attributes: Vec<PyUtf8StrRef> = attributes.try_to_value(vm)?;
+                for attr in attributes {
+                    expecting.remove(attr.as_str());
+                }
+            }
+        }
+
+        // Discard optional fields (T | None).
+        if let Some(field_types) = cls.get_attr(vm.ctx.intern_str("_field_types"))
+            && let Ok(field_types) = field_types.downcast::<crate::builtins::PyDict>()
+        {
+            for (key, value) in field_types.items_vec() {
+                let Ok(key) = key.downcast::<PyUtf8Str>() else {
+                    continue;
+                };
+                if value.fast_isinstance(vm.ctx.types.union_type) {
+                    expecting.remove(key.as_str());
+                }
+            }
+        }
+
+        if !expecting.is_empty() {
+            let mut names: Vec<String> = expecting
+                .into_iter()
+                .map(|name| format!("{name:?}"))
+                .collect();
+            names.sort();
+            let missing = names.join(", ");
+            let count = names.len();
+            return Err(vm.new_type_error(format!(
+                "{}.__replace__ missing {} keyword argument{}: {}.",
+                cls.name(),
+                count,
+                if count == 1 { "" } else { "s" },
+                missing
+            )));
+        }
+
+        let payload = vm.ctx.new_dict();
+        if let Some(dict) = dict {
+            if let Some(fields) = fields.clone() {
+                let fields: Vec<PyStrRef> = fields.try_to_value(vm)?;
+                for field in fields {
+                    if let Some(value) = dict.get_item_opt::<Wtf8>(field.as_wtf8(), vm)? {
+                        payload.set_item(field.as_object(), value, vm)?;
+                    }
+                }
+            }
+            if let Some(attributes) = attributes.clone() {
+                let attributes: Vec<PyStrRef> = attributes.try_to_value(vm)?;
+                for attr in attributes {
+                    if let Some(value) = dict.get_item_opt::<Wtf8>(attr.as_wtf8(), vm)? {
+                        payload.set_item(attr.as_object(), value, vm)?;
+                    }
+                }
+            }
+        }
+        for (key, value) in args.kwargs {
+            payload.set_item(vm.ctx.intern_str(key), value, vm)?;
+        }
+
+        let type_obj: PyObjectRef = cls.to_owned().into();
+        let kwargs = payload
+            .items_vec()
+            .into_iter()
+            .map(|(key, value)| {
+                let key = key
+                    .downcast::<PyUtf8Str>()
+                    .map_err(|_| vm.new_type_error("keywords must be strings"))?;
+                Ok((key.as_str().to_owned(), value))
+            })
+            .collect::<PyResult<IndexMap<String, PyObjectRef>>>()?;
+        let result = type_obj.call(FuncArgs::new(vec![], KwArgs::new(kwargs)), vm)?;
+        Ok(result)
+    }
+
+    pub(crate) fn ast_repr(zelf: &crate::PyObject, vm: &VirtualMachine) -> PyResult<PyRef<PyStr>> {
+        let repr = repr::repr_ast_node(vm, &zelf.to_owned(), 3)?;
+        Ok(vm.ctx.new_str(repr))
+    }
+
+    impl Constructor for NodeAst {
+        type Args = FuncArgs;
+
+        fn slot_new(cls: PyTypeRef, args: FuncArgs, vm: &VirtualMachine) -> PyResult {
+            if args.args.is_empty()
+                && args.kwargs.is_empty()
+                && let Some(instance) = cls.get_attr(vm.ctx.intern_str("_instance"))
+            {
+                return Ok(instance);
+            }
+
+            // AST nodes accept extra arguments (unlike object.__new__)
+            // This matches CPython's behavior where AST has its own tp_new
+            let dict = if cls
+                .slots
+                .flags
+                .contains(crate::types::PyTypeFlags::HAS_DICT)
+            {
+                Some(vm.ctx.new_dict())
+            } else {
+                None
+            };
+            let zelf = vm.ctx.new_base_object(cls, dict);
+
+            // type.__call__ does not invoke slot_init after slot_new
+            // for types with a custom slot_new, so we must call it here.
+            Self::slot_init(zelf.clone(), args, vm)?;
+
+            Ok(zelf)
+        }
+
+        fn py_new(_cls: &Py<PyType>, _args: Self::Args, _vm: &VirtualMachine) -> PyResult<Self> {
+            unimplemented!("use slot_new")
+        }
+    }
+
+    impl Initializer for NodeAst {
+        type Args = FuncArgs;
+
+        fn slot_init(zelf: PyObjectRef, args: FuncArgs, vm: &VirtualMachine) -> PyResult<()> {
+            let fields = zelf
+                .class()
+                .get_attr(vm.ctx.intern_str("_fields"))
+                .ok_or_else(|| {
+                    let module = zelf
+                        .class()
+                        .get_attr(vm.ctx.intern_str("__module__"))
+                        .and_then(|obj| obj.try_to_value::<String>(vm).ok())
+                        .unwrap_or_else(|| "ast".to_owned());
+                    vm.new_attribute_error(format!(
+                        "type object '{}.{}' has no attribute '_fields'",
+                        module,
+                        zelf.class().name()
+                    ))
+                })?;
+            let fields: Vec<PyUtf8StrRef> = 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" },
+                )));
+            }
+
+            // Track which fields were set
+            let mut set_fields = std::collections::HashSet::new();
+            let mut attributes: Option<Vec<PyStrRef>> = None;
+
+            for (name, arg) in fields.iter().zip(args.args) {
+                zelf.set_attr(name, arg, vm)?;
+                set_fields.insert(name.as_str().to_owned());
+            }
+            for (key, value) in args.kwargs {
+                if let Some(pos) = fields.iter().position(|f| f.as_bytes() == key.as_bytes())
+                    && pos < n_args
+                {
+                    return Err(vm.new_type_error(format!(
+                        "{} got multiple values for argument '{}'",
+                        zelf.class().name(),
+                        key
+                    )));
+                }
+
+                if fields
+                    .iter()
+                    .all(|field| field.as_bytes() != key.as_bytes())
+                {
+                    let attrs = if let Some(attrs) = &attributes {
+                        attrs
+                    } else {
+                        let attrs = zelf
+                            .class()
+                            .get_attr(vm.ctx.intern_str("_attributes"))
+                            .and_then(|attr| attr.try_to_value::<Vec<PyStrRef>>(vm).ok())
+                            .unwrap_or_default();
+                        attributes = Some(attrs);
+                        attributes.as_ref().unwrap()
+                    };
+                    if attrs.iter().all(|attr| attr.as_bytes() != key.as_bytes()) {
+                        let message = vm.ctx.new_str(format!(
+                            "{}.__init__ got an unexpected keyword argument '{}'. \
+Support for arbitrary keyword arguments is deprecated and will be removed in Python 3.15.",
+                            zelf.class().name(),
+                            key
+                        ));
+                        warn::warn(
+                            message.into(),
+                            Some(vm.ctx.exceptions.deprecation_warning.to_owned()),
+                            1,
+                            None,
+                            vm,
+                        )?;
+                    }
+                }
+
+                set_fields.insert(key.clone());
+                zelf.set_attr(vm.ctx.intern_str(key), value, vm)?;
+            }
+
+            // Use _field_types to determine defaults for unset fields.
+            // Only built-in AST node classes have _field_types populated.
+            let field_types = zelf.class().get_attr(vm.ctx.intern_str("_field_types"));
+            if let Some(Ok(ft_dict)) =
+                field_types.map(|ft| ft.downcast::<crate::builtins::PyDict>())
+            {
+                let expr_ctx_type: PyObjectRef =
+                    super::super::pyast::NodeExprContext::make_static_type().into();
+
+                for field in &fields {
+                    if set_fields.contains(field.as_str()) {
+                        continue;
+                    }
+                    if let Some(ftype) = ft_dict.get_item_opt::<Wtf8>(field.as_wtf8(), vm)? {
+                        if ftype.fast_isinstance(vm.ctx.types.union_type) {
+                            // Optional field (T | None) — no default
+                        } else if ftype.fast_isinstance(vm.ctx.types.generic_alias_type) {
+                            // List field (list[T]) — default to []
+                            let empty_list: PyObjectRef = vm.ctx.new_list(vec![]).into();
+                            zelf.set_attr(vm.ctx.intern_str(field.as_wtf8()), empty_list, vm)?;
+                        } else if ftype.is(&expr_ctx_type) {
+                            // expr_context — default to Load()
+                            let load_type =
+                                super::super::pyast::NodeExprContextLoad::make_static_type();
+                            let load_instance = load_type
+                                .get_attr(vm.ctx.intern_str("_instance"))
+                                .unwrap_or_else(|| {
+                                    vm.ctx.new_base_object(load_type, Some(vm.ctx.new_dict()))
+                                });
+                            zelf.set_attr(vm.ctx.intern_str(field.as_wtf8()), load_instance, vm)?;
+                        } else {
+                            // Required field missing: emit DeprecationWarning.
+                            let message = vm.ctx.new_str(format!(
+                                "{}.__init__ missing 1 required positional argument: '{}'",
+                                zelf.class().name(),
+                                field.as_wtf8()
+                            ));
+                            warn::warn(
+                                message.into(),
+                                Some(vm.ctx.exceptions.deprecation_warning.to_owned()),
+                                1,
+                                None,
+                                vm,
+                            )?;
+                        }
+                    }
+                }
+            }
+
+            Ok(())
+        }
+
+        fn init(_zelf: PyRef<Self>, _args: Self::Args, _vm: &VirtualMachine) -> PyResult<()> {
+            unreachable!("slot_init is defined")
+        }
+    }
+
+    #[pyattr(name = "PyCF_SOURCE_IS_UTF8")]
+    use super::PY_CF_SOURCE_IS_UTF8;
+
+    #[pyattr(name = "PyCF_DONT_IMPLY_DEDENT")]
+    use super::PY_CF_DONT_IMPLY_DEDENT;
+
+    #[pyattr(name = "PyCF_ONLY_AST")]
+    use super::PY_CF_ONLY_AST;
+
+    #[pyattr(name = "PyCF_IGNORE_COOKIE")]
+    use super::PY_CF_IGNORE_COOKIE;
+
+    #[pyattr(name = "PyCF_TYPE_COMMENTS")]
+    use super::PY_CF_TYPE_COMMENTS;
+
+    #[pyattr(name = "PyCF_ALLOW_TOP_LEVEL_AWAIT")]
+    use super::PY_CF_ALLOW_TOP_LEVEL_AWAIT;
+
+    #[pyattr(name = "PyCF_ALLOW_INCOMPLETE_INPUT")]
+    use super::PY_CF_ALLOW_INCOMPLETE_INPUT;
+
+    #[pyattr(name = "PyCF_OPTIMIZED_AST")]
+    use super::PY_CF_OPTIMIZED_AST;
+
+    pub(crate) fn module_exec(
+        vm: &VirtualMachine,
+        module: &Py<crate::builtins::PyModule>,
+    ) -> PyResult<()> {
+        __module_exec(vm, module);
+        super::super::pyast::extend_module_nodes(vm, module);
+
+        let ast_type = module
+            .get_attr("AST", vm)?
+            .downcast::<PyType>()
+            .map_err(|_| vm.new_type_error("AST is not a type"))?;
+        let ctx = &vm.ctx;
+        let empty_tuple = ctx.empty_tuple.clone();
+        ast_type.set_str_attr("_fields", empty_tuple.clone(), ctx);
+        ast_type.set_str_attr("_attributes", empty_tuple.clone(), ctx);
+        ast_type.set_str_attr("__match_args__", empty_tuple.clone(), ctx);
+
+        const AST_REDUCE: PyMethodDef = PyMethodDef::new_const(
+            "__reduce__",
+            |zelf: PyObjectRef, vm: &VirtualMachine| -> PyResult<PyTupleRef> {
+                ast_reduce(zelf, vm)
+            },
+            PyMethodFlags::METHOD,
+            None,
+        );
+        const AST_REPLACE: PyMethodDef = PyMethodDef::new_const(
+            "__replace__",
+            |zelf: PyObjectRef, args: FuncArgs, vm: &VirtualMachine| -> PyResult {
+                ast_replace(zelf, args, vm)
+            },
+            PyMethodFlags::METHOD,
+            None,
+        );
+        let base_type = NodeAst::static_type();
+        ast_type.set_str_attr(
+            "__reduce__",
+            AST_REDUCE.to_proper_method(base_type, ctx),
+            ctx,
+        );
+        ast_type.set_str_attr(
+            "__replace__",
+            AST_REPLACE.to_proper_method(base_type, ctx),
+            ctx,
+        );
+        ast_type.slots.repr.store(Some(ast_repr));
+
+        const EXPR_DOC: &str = "expr = BoolOp(boolop op, expr* values)\n\
+     | NamedExpr(expr target, expr value)\n\
+     | BinOp(expr left, operator op, expr right)\n\
+     | UnaryOp(unaryop op, expr operand)\n\
+     | Lambda(arguments args, expr body)\n\
+     | IfExp(expr test, expr body, expr orelse)\n\
+     | Dict(expr?* keys, expr* values)\n\
+     | Set(expr* elts)\n\
+     | ListComp(expr elt, comprehension* generators)\n\
+     | SetComp(expr elt, comprehension* generators)\n\
+     | DictComp(expr key, expr value, comprehension* generators)\n\
+     | GeneratorExp(expr elt, comprehension* generators)\n\
+     | Await(expr value)\n\
+     | Yield(expr? value)\n\
+     | YieldFrom(expr value)\n\
+     | Compare(expr left, cmpop* ops, expr* comparators)\n\
+     | Call(expr func, expr* args, keyword* keywords)\n\
+     | FormattedValue(expr value, int conversion, expr? format_spec)\n\
+     | Interpolation(expr value, constant str, int conversion, expr? format_spec)\n\
+     | JoinedStr(expr* values)\n\
+     | TemplateStr(expr* values)\n\
+     | Constant(constant value, string? kind)\n\
+     | Attribute(expr value, identifier attr, expr_context ctx)\n\
+     | Subscript(expr value, expr slice, expr_context ctx)\n\
+     | Starred(expr value, expr_context ctx)\n\
+     | Name(identifier id, expr_context ctx)\n\
+     | List(expr* elts, expr_context ctx)\n\
+     | Tuple(expr* elts, expr_context ctx)\n\
+     | Slice(expr? lower, expr? upper, expr? step)";
+        let expr_type = super::super::pyast::NodeExpr::static_type();
+        expr_type.set_attr(
+            identifier!(vm.ctx, __doc__),
+            vm.ctx.new_str(EXPR_DOC).into(),
+        );
+        Ok(())
+    }
+}
diff --git a/crates/vm/src/stdlib/_ast/repr.rs b/crates/vm/src/stdlib/_ast/repr.rs
new file mode 100644
index 00000000000..2897447fbec
--- /dev/null
+++ b/crates/vm/src/stdlib/_ast/repr.rs
@@ -0,0 +1,155 @@
+use crate::{
+    AsObject, PyObjectRef, PyResult, VirtualMachine,
+    builtins::{PyList, PyTuple},
+    class::PyClassImpl,
+    stdlib::_ast::NodeAst,
+};
+use rustpython_common::wtf8::Wtf8Buf;
+
+fn repr_ast_list(vm: &VirtualMachine, items: Vec<PyObjectRef>, depth: usize) -> PyResult<Wtf8Buf> {
+    if items.is_empty() {
+        let empty_list: PyObjectRef = vm.ctx.new_list(vec![]).into();
+        return Ok(empty_list.repr(vm)?.as_wtf8().to_owned());
+    }
+
+    let mut parts: Vec<Wtf8Buf> = Vec::new();
+    let first = &items[0];
+    let last = items.last().unwrap();
+
+    for (idx, item) in [first, last].iter().enumerate() {
+        if idx == 1 && items.len() == 1 {
+            break;
+        }
+        let repr = if item.fast_isinstance(&NodeAst::make_static_type()) {
+            repr_ast_node(vm, item, depth.saturating_sub(1))?
+        } else {
+            item.repr(vm)?.as_wtf8().to_owned()
+        };
+        parts.push(repr);
+    }
+
+    let mut rendered = Wtf8Buf::from("[");
+    if !parts.is_empty() {
+        rendered.push_wtf8(&parts[0]);
+    }
+    if items.len() > 2 {
+        if !parts[0].is_empty() {
+            rendered.push_wtf8(", ...".as_ref());
+        }
+        if parts.len() > 1 {
+            rendered.push_wtf8(", ".as_ref());
+            rendered.push_wtf8(&parts[1]);
+        }
+    } else if parts.len() > 1 {
+        rendered.push_wtf8(", ".as_ref());
+        rendered.push_wtf8(&parts[1]);
+    }
+    rendered.push_wtf8("]".as_ref());
+    Ok(rendered)
+}
+
+fn repr_ast_tuple(vm: &VirtualMachine, items: Vec<PyObjectRef>, depth: usize) -> PyResult<Wtf8Buf> {
+    if items.is_empty() {
+        let empty_tuple: PyObjectRef = vm.ctx.empty_tuple.clone().into();
+        return Ok(empty_tuple.repr(vm)?.as_wtf8().to_owned());
+    }
+
+    let mut parts: Vec<Wtf8Buf> = Vec::new();
+    let first = &items[0];
+    let last = items.last().unwrap();
+
+    for (idx, item) in [first, last].iter().enumerate() {
+        if idx == 1 && items.len() == 1 {
+            break;
+        }
+        let repr = if item.fast_isinstance(&NodeAst::make_static_type()) {
+            repr_ast_node(vm, item, depth.saturating_sub(1))?
+        } else {
+            item.repr(vm)?.as_wtf8().to_owned()
+        };
+        parts.push(repr);
+    }
+
+    let mut rendered = Wtf8Buf::from("(");
+    if !parts.is_empty() {
+        rendered.push_wtf8(&parts[0]);
+    }
+    if items.len() > 2 {
+        if !parts[0].is_empty() {
+            rendered.push_wtf8(", ...".as_ref());
+        }
+        if parts.len() > 1 {
+            rendered.push_wtf8(", ".as_ref());
+            rendered.push_wtf8(&parts[1]);
+        }
+    } else if parts.len() > 1 {
+        rendered.push_wtf8(", ".as_ref());
+        rendered.push_wtf8(&parts[1]);
+    }
+    if items.len() == 1 {
+        rendered.push_wtf8(",".as_ref());
+    }
+    rendered.push_wtf8(")".as_ref());
+    Ok(rendered)
+}
+
+pub(crate) fn repr_ast_node(
+    vm: &VirtualMachine,
+    obj: &PyObjectRef,
+    depth: usize,
+) -> PyResult<Wtf8Buf> {
+    let cls = obj.class();
+    if depth == 0 {
+        let mut s = Wtf8Buf::from(&*cls.name());
+        s.push_wtf8("(...)".as_ref());
+        return Ok(s);
+    }
+
+    let fields = cls.get_attr(vm.ctx.intern_str("_fields"));
+    let fields = match fields {
+        Some(fields) => fields.try_to_value::<Vec<crate::builtins::PyStrRef>>(vm)?,
+        None => {
+            let mut s = Wtf8Buf::from(&*cls.name());
+            s.push_wtf8("(...)".as_ref());
+            return Ok(s);
+        }
+    };
+
+    if fields.is_empty() {
+        let mut s = Wtf8Buf::from(&*cls.name());
+        s.push_wtf8("()".as_ref());
+        return Ok(s);
+    }
+
+    let mut rendered = Wtf8Buf::from(&*cls.name());
+    rendered.push_wtf8("(".as_ref());
+
+    for (idx, field) in fields.iter().enumerate() {
+        let value = obj.get_attr(field, vm)?;
+        let value_repr = if value.fast_isinstance(vm.ctx.types.list_type) {
+            let list = value
+                .downcast::<PyList>()
+                .expect("list type should downcast");
+            repr_ast_list(vm, list.borrow_vec().to_vec(), depth)?
+        } else if value.fast_isinstance(vm.ctx.types.tuple_type) {
+            let tuple = value
+                .downcast::<PyTuple>()
+                .expect("tuple type should downcast");
+            repr_ast_tuple(vm, tuple.as_slice().to_vec(), depth)?
+        } else if value.fast_isinstance(&NodeAst::make_static_type()) {
+            repr_ast_node(vm, &value, depth.saturating_sub(1))?
+        } else {
+            value.repr(vm)?.as_wtf8().to_owned()
+        };
+
+        if idx > 0 {
+            rendered.push_wtf8(", ".as_ref());
+        }
+        rendered.push_wtf8(field.as_wtf8());
+        rendered.push_wtf8("=".as_ref());
+        rendered.push_wtf8(&value_repr);
+    }
+
+    rendered.push_wtf8(")".as_ref());
+    Ok(rendered)
+}
diff --git a/crates/vm/src/stdlib/ast/statement.rs b/crates/vm/src/stdlib/_ast/statement.rs
similarity index 93%
rename from crates/vm/src/stdlib/ast/statement.rs
rename to crates/vm/src/stdlib/_ast/statement.rs
index b7bc692dd2e..4c53bf01877 100644
--- a/crates/vm/src/stdlib/ast/statement.rs
+++ b/crates/vm/src/stdlib/_ast/statement.rs
@@ -1,5 +1,5 @@
 use super::*;
-use crate::stdlib::ast::argument::{merge_class_def_args, split_class_def_args};
+use crate::stdlib::_ast::argument::{merge_class_def_args, split_class_def_args};
 use rustpython_compiler_core::SourceFile;
 
 // sum
@@ -159,6 +159,9 @@ impl Node for ast::StmtFunctionDef {
             is_async,
             range: _range,
         } = self;
+        let source_code = source_file.to_source_code();
+        let def_line = source_code.line_index(name.range.start());
+        let range = TextRange::new(source_code.line_start(def_line), _range.end());
 
         let cls = if !is_async {
             pyast::NodeStmtFunctionDef::static_type().to_owned()
@@ -182,9 +185,8 @@ impl Node for ast::StmtFunctionDef {
         .unwrap();
         dict.set_item("returns", returns.ast_to_object(vm, source_file), vm)
             .unwrap();
-        // TODO: Ruff ignores type_comment during parsing
-        // dict.set_item("type_comment", type_comment.ast_to_object(_vm), _vm)
-        //     .unwrap();
+        // Ruff AST doesn't track type_comment, so always set to None
+        dict.set_item("type_comment", vm.ctx.none(), vm).unwrap();
         dict.set_item(
             "type_params",
             type_params
@@ -193,7 +195,7 @@ impl Node for ast::StmtFunctionDef {
             vm,
         )
         .unwrap();
-        node_add_location(&dict, _range, vm, source_file);
+        node_add_location(&dict, range, vm, source_file);
         node.into()
     }
     fn ast_from_object(
@@ -203,6 +205,7 @@ impl Node for ast::StmtFunctionDef {
     ) -> PyResult<Self> {
         let _cls = _object.class();
         let is_async = _cls.is(pyast::NodeStmtAsyncFunctionDef::static_type());
+        let range = range_from_object(_vm, source_file, _object.clone(), "FunctionDef")?;
         Ok(Self {
             node_index: Default::default(),
             name: Node::ast_from_object(
@@ -235,9 +238,10 @@ impl Node for ast::StmtFunctionDef {
             type_params: Node::ast_from_object(
                 _vm,
                 source_file,
-                get_node_field_opt(_vm, &_object, "type_params")?.unwrap_or_else(|| _vm.ctx.none()),
+                get_node_field_opt(_vm, &_object, "type_params")?
+                    .unwrap_or_else(|| _vm.ctx.new_list(Vec::new()).into()),
             )?,
-            range: range_from_object(_vm, source_file, _object, "FunctionDef")?,
+            range,
             is_async,
         })
     }
@@ -256,6 +260,9 @@ impl Node for ast::StmtClassDef {
             range: _range,
         } = self;
         let (bases, keywords) = split_class_def_args(arguments);
+        let source_code = source_file.to_source_code();
+        let class_line = source_code.line_index(name.range.start());
+        let range = TextRange::new(source_code.line_start(class_line), _range.end());
         let node = NodeAst
             .into_ref_with_type(_vm, pyast::NodeStmtClassDef::static_type().to_owned())
             .unwrap();
@@ -294,7 +301,7 @@ impl Node for ast::StmtClassDef {
             _vm,
         )
         .unwrap();
-        node_add_location(&dict, _range, _vm, source_file);
+        node_add_location(&dict, range, _vm, source_file);
         node.into()
     }
     fn ast_from_object(
@@ -333,7 +340,8 @@ impl Node for ast::StmtClassDef {
             type_params: Node::ast_from_object(
                 _vm,
                 source_file,
-                get_node_field_opt(_vm, &_object, "type_params")?.unwrap_or_else(|| _vm.ctx.none()),
+                get_node_field_opt(_vm, &_object, "type_params")?
+                    .unwrap_or_else(|| _vm.ctx.new_list(Vec::new()).into()),
             )?,
             range: range_from_object(_vm, source_file, _object, "ClassDef")?,
         })
@@ -470,7 +478,9 @@ impl Node for ast::StmtTypeAlias {
             .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::new()).into()),
             _vm,
         )
         .unwrap();
@@ -647,8 +657,8 @@ impl Node for ast::StmtFor {
             .unwrap();
         dict.set_item("orelse", orelse.ast_to_object(_vm, source_file), _vm)
             .unwrap();
-        // dict.set_item("type_comment", type_comment.ast_to_object(_vm), _vm)
-        //     .unwrap();
+        // Ruff AST doesn't track type_comment, so always set to None
+        dict.set_item("type_comment", _vm.ctx.none(), _vm).unwrap();
         node_add_location(&dict, _range, _vm, source_file);
         node.into()
     }
@@ -799,8 +809,8 @@ impl Node for ast::StmtWith {
             .unwrap();
         dict.set_item("body", body.ast_to_object(_vm, source_file), _vm)
             .unwrap();
-        // dict.set_item("type_comment", type_comment.ast_to_object(_vm), _vm)
-        //     .unwrap();
+        // Ruff AST doesn't track type_comment, so always set to None
+        dict.set_item("type_comment", _vm.ctx.none(), _vm).unwrap();
         node_add_location(&dict, _range, _vm, source_file);
         node.into()
     }
@@ -1033,6 +1043,7 @@ impl Node for ast::StmtImport {
             node_index: _,
             names,
             range: _range,
+            is_lazy: _,
         } = self;
         let node = NodeAst
             .into_ref_with_type(_vm, pyast::NodeStmtImport::static_type().to_owned())
@@ -1043,6 +1054,7 @@ impl Node for ast::StmtImport {
         node_add_location(&dict, _range, _vm, source_file);
         node.into()
     }
+
     fn ast_from_object(
         _vm: &VirtualMachine,
         source_file: &SourceFile,
@@ -1056,6 +1068,7 @@ impl Node for ast::StmtImport {
                 get_node_field(_vm, &_object, "names", "Import")?,
             )?,
             range: range_from_object(_vm, source_file, _object, "Import")?,
+            is_lazy: false, // Placeholder
         })
     }
 }
@@ -1068,6 +1081,7 @@ impl Node for ast::StmtImportFrom {
             names,
             level,
             range,
+            is_lazy: _,
         } = self;
         let node = NodeAst
             .into_ref_with_type(vm, pyast::NodeStmtImportFrom::static_type().to_owned())
@@ -1082,6 +1096,7 @@ impl Node for ast::StmtImportFrom {
         node_add_location(&dict, range, vm, source_file);
         node.into()
     }
+
     fn ast_from_object(
         vm: &VirtualMachine,
         source_file: &SourceFile,
@@ -1100,11 +1115,17 @@ impl Node for ast::StmtImportFrom {
             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)
+                    let value: i64 = int.try_to_primitive(vm)?;
+                    if value < 0 {
+                        return Err(vm.new_value_error("Negative ImportFrom level"));
+                    }
+                    u32::try_from(value)
+                        .map_err(|_| vm.new_overflow_error("ImportFrom level out of range"))
                 })
                 .transpose()?
                 .unwrap_or(0),
             range: range_from_object(vm, source_file, _object, "ImportFrom")?,
+            is_lazy: false, // Placeholder
         })
     }
 }
@@ -1218,7 +1239,28 @@ impl Node for ast::StmtPass {
             .into_ref_with_type(_vm, pyast::NodeStmtPass::static_type().to_owned())
             .unwrap();
         let dict = node.as_object().dict().unwrap();
-        node_add_location(&dict, _range, _vm, source_file);
+        let location = super::text_range_to_source_range(source_file, _range);
+        let start_row = location.start.row.get();
+        let start_col = location.start.column.get();
+        let mut end_row = location.end.row.get();
+        let mut end_col = location.end.column.get();
+
+        // Align with CPython: when docstring optimization replaces a lone
+        // docstring with `pass`, the end position is on the same line even if
+        // it extends past the physical line length.
+        if end_row != start_row && _range.len() == TextSize::from(4) {
+            end_row = start_row;
+            end_col = start_col + 4;
+        }
+
+        dict.set_item("lineno", _vm.ctx.new_int(start_row).into(), _vm)
+            .unwrap();
+        dict.set_item("col_offset", _vm.ctx.new_int(start_col).into(), _vm)
+            .unwrap();
+        dict.set_item("end_lineno", _vm.ctx.new_int(end_row).into(), _vm)
+            .unwrap();
+        dict.set_item("end_col_offset", _vm.ctx.new_int(end_col).into(), _vm)
+            .unwrap();
         node.into()
     }
     fn ast_from_object(
diff --git a/crates/vm/src/stdlib/ast/string.rs b/crates/vm/src/stdlib/_ast/string.rs
similarity index 58%
rename from crates/vm/src/stdlib/ast/string.rs
rename to crates/vm/src/stdlib/_ast/string.rs
index 2533fb8c6b9..24cae476694 100644
--- a/crates/vm/src/stdlib/ast/string.rs
+++ b/crates/vm/src/stdlib/_ast/string.rs
@@ -1,5 +1,7 @@
 use super::constant::{Constant, ConstantLiteral};
 use super::*;
+use crate::warn;
+use ast::str_prefix::StringLiteralPrefix;
 
 fn ruff_fstring_element_into_iter(
     mut fstring_element: ast::InterpolatedStringElements,
@@ -45,6 +47,193 @@ fn ruff_fstring_element_to_joined_str_part(
     }
 }
 
+fn push_joined_str_literal(
+    output: &mut Vec<JoinedStrPart>,
+    pending: &mut Option<(String, StringLiteralPrefix, TextRange)>,
+) {
+    if let Some((value, prefix, range)) = pending.take()
+        && !value.is_empty()
+    {
+        output.push(JoinedStrPart::Constant(Constant::new_str(
+            value, prefix, range,
+        )));
+    }
+}
+
+fn normalize_joined_str_parts(values: Vec<JoinedStrPart>) -> Vec<JoinedStrPart> {
+    let mut output = Vec::with_capacity(values.len());
+    let mut pending: Option<(String, StringLiteralPrefix, TextRange)> = None;
+
+    for part in values {
+        match part {
+            JoinedStrPart::Constant(constant) => {
+                let ConstantLiteral::Str { value, prefix } = constant.value else {
+                    push_joined_str_literal(&mut output, &mut pending);
+                    output.push(JoinedStrPart::Constant(constant));
+                    continue;
+                };
+                let value: String = value.into();
+                if let Some((pending_value, _, _)) = pending.as_mut() {
+                    pending_value.push_str(&value);
+                } else {
+                    pending = Some((value, prefix, constant.range));
+                }
+            }
+            JoinedStrPart::FormattedValue(value) => {
+                push_joined_str_literal(&mut output, &mut pending);
+                output.push(JoinedStrPart::FormattedValue(value));
+            }
+        }
+    }
+
+    push_joined_str_literal(&mut output, &mut pending);
+    output
+}
+
+fn push_template_str_literal(
+    output: &mut Vec<TemplateStrPart>,
+    pending: &mut Option<(String, StringLiteralPrefix, TextRange)>,
+) {
+    if let Some((value, prefix, range)) = pending.take()
+        && !value.is_empty()
+    {
+        output.push(TemplateStrPart::Constant(Constant::new_str(
+            value, prefix, range,
+        )));
+    }
+}
+
+fn normalize_template_str_parts(values: Vec<TemplateStrPart>) -> Vec<TemplateStrPart> {
+    let mut output = Vec::with_capacity(values.len());
+    let mut pending: Option<(String, StringLiteralPrefix, TextRange)> = None;
+
+    for part in values {
+        match part {
+            TemplateStrPart::Constant(constant) => {
+                let ConstantLiteral::Str { value, prefix } = constant.value else {
+                    push_template_str_literal(&mut output, &mut pending);
+                    output.push(TemplateStrPart::Constant(constant));
+                    continue;
+                };
+                let value: String = value.into();
+                if let Some((pending_value, _, _)) = pending.as_mut() {
+                    pending_value.push_str(&value);
+                } else {
+                    pending = Some((value, prefix, constant.range));
+                }
+            }
+            TemplateStrPart::Interpolation(value) => {
+                push_template_str_literal(&mut output, &mut pending);
+                output.push(TemplateStrPart::Interpolation(value));
+            }
+        }
+    }
+
+    push_template_str_literal(&mut output, &mut pending);
+    output
+}
+
+fn warn_invalid_escape_sequences_in_format_spec(
+    vm: &VirtualMachine,
+    source_file: &SourceFile,
+    range: TextRange,
+) {
+    let source = source_file.source_text();
+    let start = range.start().to_usize();
+    let end = range.end().to_usize();
+    if start >= end || end > source.len() {
+        return;
+    }
+    let mut raw = &source[start..end];
+    if raw.starts_with(':') {
+        raw = &raw[1..];
+    }
+
+    let mut chars = raw.chars().peekable();
+    while let Some(ch) = chars.next() {
+        if ch != '\\' {
+            continue;
+        }
+        let Some(next) = chars.next() else {
+            break;
+        };
+        let valid = match next {
+            '\\' | '\'' | '"' | 'a' | 'b' | 'f' | 'n' | 'r' | 't' | 'v' => true,
+            '\n' => true,
+            '\r' => {
+                if let Some('\n') = chars.peek().copied() {
+                    chars.next();
+                }
+                true
+            }
+            '0'..='7' => {
+                for _ in 0..2 {
+                    if let Some('0'..='7') = chars.peek().copied() {
+                        chars.next();
+                    } else {
+                        break;
+                    }
+                }
+                true
+            }
+            'x' => {
+                for _ in 0..2 {
+                    if chars.peek().is_some_and(|c| c.is_ascii_hexdigit()) {
+                        chars.next();
+                    } else {
+                        break;
+                    }
+                }
+                true
+            }
+            'u' => {
+                for _ in 0..4 {
+                    if chars.peek().is_some_and(|c| c.is_ascii_hexdigit()) {
+                        chars.next();
+                    } else {
+                        break;
+                    }
+                }
+                true
+            }
+            'U' => {
+                for _ in 0..8 {
+                    if chars.peek().is_some_and(|c| c.is_ascii_hexdigit()) {
+                        chars.next();
+                    } else {
+                        break;
+                    }
+                }
+                true
+            }
+            'N' => {
+                if let Some('{') = chars.peek().copied() {
+                    chars.next();
+                    for c in chars.by_ref() {
+                        if c == '}' {
+                            break;
+                        }
+                    }
+                }
+                true
+            }
+            _ => false,
+        };
+        if !valid {
+            let message = vm.ctx.new_str(format!(
+                "\"\\{next}\" is an invalid escape sequence. Such sequences will not work in the future. Did you mean \"\\\\{next}\"? A raw string is also an option."
+            ));
+            let _ = warn::warn(
+                message.into(),
+                Some(vm.ctx.exceptions.syntax_warning.to_owned()),
+                1,
+                None,
+                vm,
+            );
+        }
+    }
+}
+
 fn ruff_format_spec_to_joined_str(
     format_spec: Option<Box<ast::InterpolatedStringFormatSpec>>,
 ) -> Option<Box<JoinedStr>> {
@@ -56,10 +245,18 @@ fn ruff_format_spec_to_joined_str(
                 elements,
                 node_index: _,
             } = *format_spec;
+            let range = if range.start() > ruff_text_size::TextSize::from(0) {
+                TextRange::new(
+                    range.start() - ruff_text_size::TextSize::from(1),
+                    range.end(),
+                )
+            } else {
+                range
+            };
             let values: Vec<_> = ruff_fstring_element_into_iter(elements)
                 .map(ruff_fstring_element_to_joined_str_part)
                 .collect();
-            let values = values.into_boxed_slice();
+            let values = normalize_joined_str_parts(values).into_boxed_slice();
             Some(Box::new(JoinedStr { range, values }))
         }
     }
@@ -353,6 +550,14 @@ pub(super) fn fstring_to_object(
             }
         }
     }
+    let values = normalize_joined_str_parts(values);
+    for part in &values {
+        if let JoinedStrPart::FormattedValue(value) = part
+            && let Some(format_spec) = &value.format_spec
+        {
+            warn_invalid_escape_sequences_in_format_spec(vm, source_file, format_spec.range);
+        }
+    }
     let c = JoinedStr {
         range,
         values: values.into_boxed_slice(),
@@ -384,40 +589,106 @@ fn ruff_tstring_element_to_template_str_part(
             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());
+            let expr_range =
+                extend_expr_range_with_wrapping_parens(source_file, range, expression.range())
+                    .unwrap_or_else(|| expression.range());
+            let expr_str = if let Some(debug_text) = debug_text {
+                let expr_source = source_file.slice(expr_range);
+                let mut expr_with_debug = String::with_capacity(
+                    debug_text.leading.len() + expr_source.len() + debug_text.trailing.len(),
+                );
+                expr_with_debug.push_str(&debug_text.leading);
+                expr_with_debug.push_str(expr_source);
+                expr_with_debug.push_str(&debug_text.trailing);
+                strip_interpolation_expr(&expr_with_debug)
+            } else {
+                tstring_interpolation_expr_str(source_file, range, expr_range)
+            };
             TemplateStrPart::Interpolation(TStringInterpolation {
                 value: expression,
                 str: expr_str,
                 conversion,
-                format_spec: ruff_format_spec_to_template_str(format_spec, source_file),
+                format_spec: ruff_format_spec_to_joined_str(format_spec),
                 range,
             })
         }
     }
 }
 
-fn ruff_format_spec_to_template_str(
-    format_spec: Option<Box<ast::InterpolatedStringFormatSpec>>,
+fn tstring_interpolation_expr_str(
     source_file: &SourceFile,
-) -> Option<Box<TemplateStr>> {
-    match format_spec {
-        None => None,
-        Some(format_spec) => {
-            let ast::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 }))
+    interpolation_range: TextRange,
+    expr_range: TextRange,
+) -> String {
+    let expr_range =
+        extend_expr_range_with_wrapping_parens(source_file, interpolation_range, expr_range)
+            .unwrap_or(expr_range);
+    let start = interpolation_range.start() + TextSize::from(1);
+    let start = if start > expr_range.end() {
+        expr_range.start()
+    } else {
+        start
+    };
+    let expr_source = source_file.slice(TextRange::new(start, expr_range.end()));
+    strip_interpolation_expr(expr_source)
+}
+
+fn extend_expr_range_with_wrapping_parens(
+    source_file: &SourceFile,
+    interpolation_range: TextRange,
+    expr_range: TextRange,
+) -> Option<TextRange> {
+    let left_slice = source_file.slice(TextRange::new(
+        interpolation_range.start(),
+        expr_range.start(),
+    ));
+    let mut left_char: Option<(usize, char)> = None;
+    for (idx, ch) in left_slice
+        .char_indices()
+        .collect::<Vec<_>>()
+        .into_iter()
+        .rev()
+    {
+        if !ch.is_whitespace() {
+            left_char = Some((idx, ch));
+            break;
+        }
+    }
+    let (left_idx, left_ch) = left_char?;
+    if left_ch != '(' {
+        return None;
+    }
+
+    let right_slice =
+        source_file.slice(TextRange::new(expr_range.end(), interpolation_range.end()));
+    let mut right_char: Option<(usize, char)> = None;
+    for (idx, ch) in right_slice.char_indices() {
+        if !ch.is_whitespace() {
+            right_char = Some((idx, ch));
+            break;
         }
     }
+    let (right_idx, right_ch) = right_char?;
+    if right_ch != ')' {
+        return None;
+    }
+
+    let left_pos = interpolation_range.start() + TextSize::from(left_idx as u32);
+    let right_pos = expr_range.end() + TextSize::from(right_idx as u32);
+    Some(TextRange::new(left_pos, right_pos + TextSize::from(1)))
+}
+
+fn strip_interpolation_expr(expr_source: &str) -> String {
+    let mut end = expr_source.len();
+    for (idx, ch) in expr_source.char_indices().rev() {
+        if ch.is_whitespace() || ch == '=' {
+            end = idx;
+            continue;
+        }
+        end = idx + ch.len_utf8();
+        break;
+    }
+    expr_source[..end].to_owned()
 }
 
 #[derive(Debug)]
@@ -426,6 +697,96 @@ pub(super) struct TemplateStr {
     pub(super) values: Box<[TemplateStrPart]>,
 }
 
+pub(super) fn template_str_to_expr(
+    vm: &VirtualMachine,
+    template: TemplateStr,
+) -> PyResult<ast::Expr> {
+    let TemplateStr { range, values } = template;
+    let elements = template_parts_to_elements(vm, values)?;
+    let tstring = ast::TString {
+        range,
+        node_index: Default::default(),
+        elements,
+        flags: ast::TStringFlags::empty(),
+    };
+    Ok(ast::Expr::TString(ast::ExprTString {
+        node_index: Default::default(),
+        range,
+        value: ast::TStringValue::single(tstring),
+    }))
+}
+
+pub(super) fn interpolation_to_expr(
+    vm: &VirtualMachine,
+    interpolation: TStringInterpolation,
+) -> PyResult<ast::Expr> {
+    let part = TemplateStrPart::Interpolation(interpolation);
+    let elements = template_parts_to_elements(vm, vec![part].into_boxed_slice())?;
+    let range = TextRange::default();
+    let tstring = ast::TString {
+        range,
+        node_index: Default::default(),
+        elements,
+        flags: ast::TStringFlags::empty(),
+    };
+    Ok(ast::Expr::TString(ast::ExprTString {
+        node_index: Default::default(),
+        range,
+        value: ast::TStringValue::single(tstring),
+    }))
+}
+
+fn template_parts_to_elements(
+    vm: &VirtualMachine,
+    values: Box<[TemplateStrPart]>,
+) -> PyResult<ast::InterpolatedStringElements> {
+    let mut elements = Vec::with_capacity(values.len());
+    for value in values.into_vec() {
+        elements.push(template_part_to_element(vm, value)?);
+    }
+    Ok(ast::InterpolatedStringElements::from(elements))
+}
+
+fn template_part_to_element(
+    vm: &VirtualMachine,
+    part: TemplateStrPart,
+) -> PyResult<ast::InterpolatedStringElement> {
+    match part {
+        TemplateStrPart::Constant(constant) => {
+            let ConstantLiteral::Str { value, .. } = constant.value else {
+                return Err(vm.new_type_error("TemplateStr constant values must be strings"));
+            };
+            Ok(ast::InterpolatedStringElement::Literal(
+                ast::InterpolatedStringLiteralElement {
+                    range: constant.range,
+                    node_index: Default::default(),
+                    value,
+                },
+            ))
+        }
+        TemplateStrPart::Interpolation(interpolation) => {
+            let TStringInterpolation {
+                value,
+                conversion,
+                format_spec,
+                range,
+                ..
+            } = interpolation;
+            let format_spec = joined_str_to_ruff_format_spec(format_spec);
+            Ok(ast::InterpolatedStringElement::Interpolation(
+                ast::InterpolatedElement {
+                    range,
+                    node_index: Default::default(),
+                    expression: value,
+                    debug_text: None,
+                    conversion,
+                    format_spec,
+                },
+            ))
+        }
+    }
+}
+
 // constructor
 impl Node for TemplateStr {
     fn ast_to_object(self, vm: &VirtualMachine, source_file: &SourceFile) -> PyObjectRef {
@@ -501,7 +862,7 @@ pub(super) struct TStringInterpolation {
     value: Box<ast::Expr>,
     str: String,
     conversion: ast::ConversionFlag,
-    format_spec: Option<Box<TemplateStr>>,
+    format_spec: Option<Box<JoinedStr>>,
     range: TextRange,
 }
 
@@ -587,6 +948,7 @@ pub(super) fn tstring_to_object(
             ));
         }
     }
+    let values = normalize_template_str_parts(values);
     let c = TemplateStr {
         range,
         values: values.into_boxed_slice(),
diff --git a/crates/vm/src/stdlib/ast/type_ignore.rs b/crates/vm/src/stdlib/_ast/type_ignore.rs
similarity index 86%
rename from crates/vm/src/stdlib/ast/type_ignore.rs
rename to crates/vm/src/stdlib/_ast/type_ignore.rs
index de929fcf623..6e90ba9b80e 100644
--- a/crates/vm/src/stdlib/ast/type_ignore.rs
+++ b/crates/vm/src/stdlib/_ast/type_ignore.rs
@@ -13,21 +13,21 @@ impl Node for TypeIgnore {
         }
     }
     fn ast_from_object(
-        _vm: &VirtualMachine,
+        vm: &VirtualMachine,
         source_file: &SourceFile,
-        _object: PyObjectRef,
+        object: PyObjectRef,
     ) -> PyResult<Self> {
-        let _cls = _object.class();
-        Ok(if _cls.is(pyast::NodeTypeIgnoreTypeIgnore::static_type()) {
+        let cls = object.class();
+        Ok(if cls.is(pyast::NodeTypeIgnoreTypeIgnore::static_type()) {
             Self::TypeIgnore(TypeIgnoreTypeIgnore::ast_from_object(
-                _vm,
+                vm,
                 source_file,
-                _object,
+                object,
             )?)
         } else {
-            return Err(_vm.new_type_error(format!(
+            return Err(vm.new_type_error(format!(
                 "expected some sort of type_ignore, but got {}",
-                _object.repr(_vm)?
+                object.repr(vm)?
             )));
         })
     }
diff --git a/crates/vm/src/stdlib/ast/type_parameters.rs b/crates/vm/src/stdlib/_ast/type_parameters.rs
similarity index 54%
rename from crates/vm/src/stdlib/ast/type_parameters.rs
rename to crates/vm/src/stdlib/_ast/type_parameters.rs
index 4801a9a4b28..0424ffbd768 100644
--- a/crates/vm/src/stdlib/ast/type_parameters.rs
+++ b/crates/vm/src/stdlib/_ast/type_parameters.rs
@@ -7,11 +7,11 @@ impl Node for ast::TypeParams {
     }
 
     fn ast_from_object(
-        _vm: &VirtualMachine,
-        _source_file: &SourceFile,
-        _object: PyObjectRef,
+        vm: &VirtualMachine,
+        source_file: &SourceFile,
+        object: PyObjectRef,
     ) -> PyResult<Self> {
-        let type_params: Vec<ast::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();
@@ -38,33 +38,33 @@ impl Node for ast::TypeParam {
     }
 
     fn ast_from_object(
-        _vm: &VirtualMachine,
+        vm: &VirtualMachine,
         source_file: &SourceFile,
-        _object: PyObjectRef,
+        object: PyObjectRef,
     ) -> PyResult<Self> {
-        let _cls = _object.class();
-        Ok(if _cls.is(pyast::NodeTypeParamTypeVar::static_type()) {
+        let cls = object.class();
+        Ok(if cls.is(pyast::NodeTypeParamTypeVar::static_type()) {
             Self::TypeVar(ast::TypeParamTypeVar::ast_from_object(
-                _vm,
+                vm,
                 source_file,
-                _object,
+                object,
             )?)
-        } else if _cls.is(pyast::NodeTypeParamParamSpec::static_type()) {
+        } else if cls.is(pyast::NodeTypeParamParamSpec::static_type()) {
             Self::ParamSpec(ast::TypeParamParamSpec::ast_from_object(
-                _vm,
+                vm,
                 source_file,
-                _object,
+                object,
             )?)
-        } else if _cls.is(pyast::NodeTypeParamTypeVarTuple::static_type()) {
+        } else if cls.is(pyast::NodeTypeParamTypeVarTuple::static_type()) {
             Self::TypeVarTuple(ast::TypeParamTypeVarTuple::ast_from_object(
-                _vm,
+                vm,
                 source_file,
-                _object,
+                object,
             )?)
         } else {
-            return Err(_vm.new_type_error(format!(
+            return Err(vm.new_type_error(format!(
                 "expected some sort of type_param, but got {}",
-                _object.repr(_vm)?
+                object.repr(vm)?
             )));
         })
     }
@@ -72,144 +72,138 @@ impl Node for ast::TypeParam {
 
 // constructor
 impl Node for ast::TypeParamTypeVar {
-    fn ast_to_object(self, _vm: &VirtualMachine, source_file: &SourceFile) -> PyObjectRef {
+    fn ast_to_object(self, vm: &VirtualMachine, source_file: &SourceFile) -> PyObjectRef {
         let Self {
             node_index: _,
             name,
             bound,
-            range: _range,
-            default: _,
+            range,
+            default,
         } = self;
         let node = NodeAst
-            .into_ref_with_type(_vm, pyast::NodeTypeParamTypeVar::static_type().to_owned())
+            .into_ref_with_type(vm, pyast::NodeTypeParamTypeVar::static_type().to_owned())
             .unwrap();
         let dict = node.as_object().dict().unwrap();
-        dict.set_item("name", name.ast_to_object(_vm, source_file), _vm)
+        dict.set_item("name", name.ast_to_object(vm, source_file), vm)
+            .unwrap();
+        dict.set_item("bound", bound.ast_to_object(vm, source_file), vm)
             .unwrap();
-        dict.set_item("bound", bound.ast_to_object(_vm, source_file), _vm)
+        dict.set_item("default_value", default.ast_to_object(vm, source_file), vm)
             .unwrap();
-        node_add_location(&dict, _range, _vm, source_file);
+        node_add_location(&dict, range, vm, source_file);
         node.into()
     }
 
     fn ast_from_object(
-        _vm: &VirtualMachine,
+        vm: &VirtualMachine,
         source_file: &SourceFile,
-        _object: PyObjectRef,
+        object: PyObjectRef,
     ) -> PyResult<Self> {
         Ok(Self {
             node_index: Default::default(),
             name: Node::ast_from_object(
-                _vm,
+                vm,
                 source_file,
-                get_node_field(_vm, &_object, "name", "TypeVar")?,
+                get_node_field(vm, &object, "name", "TypeVar")?,
             )?,
-            bound: get_node_field_opt(_vm, &_object, "bound")?
-                .map(|obj| Node::ast_from_object(_vm, source_file, obj))
+            bound: get_node_field_opt(vm, &object, "bound")?
+                .map(|obj| Node::ast_from_object(vm, source_file, obj))
                 .transpose()?,
             default: Node::ast_from_object(
-                _vm,
+                vm,
                 source_file,
-                get_node_field(_vm, &_object, "default_value", "TypeVar")?,
+                get_node_field(vm, &object, "default_value", "TypeVar")?,
             )?,
-            range: range_from_object(_vm, source_file, _object, "TypeVar")?,
+            range: range_from_object(vm, source_file, object, "TypeVar")?,
         })
     }
 }
 
 // constructor
 impl Node for ast::TypeParamParamSpec {
-    fn ast_to_object(self, _vm: &VirtualMachine, source_file: &SourceFile) -> PyObjectRef {
+    fn ast_to_object(self, vm: &VirtualMachine, source_file: &SourceFile) -> PyObjectRef {
         let Self {
             node_index: _,
             name,
-            range: _range,
+            range,
             default,
         } = self;
         let node = NodeAst
-            .into_ref_with_type(_vm, pyast::NodeTypeParamParamSpec::static_type().to_owned())
+            .into_ref_with_type(vm, pyast::NodeTypeParamParamSpec::static_type().to_owned())
             .unwrap();
         let dict = node.as_object().dict().unwrap();
-        dict.set_item("name", name.ast_to_object(_vm, source_file), _vm)
+        dict.set_item("name", name.ast_to_object(vm, source_file), vm)
+            .unwrap();
+        dict.set_item("default_value", default.ast_to_object(vm, source_file), vm)
             .unwrap();
-        dict.set_item(
-            "default_value",
-            default.ast_to_object(_vm, source_file),
-            _vm,
-        )
-        .unwrap();
-        node_add_location(&dict, _range, _vm, source_file);
+        node_add_location(&dict, range, vm, source_file);
         node.into()
     }
 
     fn ast_from_object(
-        _vm: &VirtualMachine,
+        vm: &VirtualMachine,
         source_file: &SourceFile,
-        _object: PyObjectRef,
+        object: PyObjectRef,
     ) -> PyResult<Self> {
         Ok(Self {
             node_index: Default::default(),
             name: Node::ast_from_object(
-                _vm,
+                vm,
                 source_file,
-                get_node_field(_vm, &_object, "name", "ParamSpec")?,
+                get_node_field(vm, &object, "name", "ParamSpec")?,
             )?,
             default: Node::ast_from_object(
-                _vm,
+                vm,
                 source_file,
-                get_node_field(_vm, &_object, "default_value", "ParamSpec")?,
+                get_node_field(vm, &object, "default_value", "ParamSpec")?,
             )?,
-            range: range_from_object(_vm, source_file, _object, "ParamSpec")?,
+            range: range_from_object(vm, source_file, object, "ParamSpec")?,
         })
     }
 }
 
 // constructor
 impl Node for ast::TypeParamTypeVarTuple {
-    fn ast_to_object(self, _vm: &VirtualMachine, source_file: &SourceFile) -> PyObjectRef {
+    fn ast_to_object(self, vm: &VirtualMachine, source_file: &SourceFile) -> PyObjectRef {
         let Self {
             node_index: _,
             name,
-            range: _range,
+            range,
             default,
         } = self;
         let node = NodeAst
             .into_ref_with_type(
-                _vm,
+                vm,
                 pyast::NodeTypeParamTypeVarTuple::static_type().to_owned(),
             )
             .unwrap();
         let dict = node.as_object().dict().unwrap();
-        dict.set_item("name", name.ast_to_object(_vm, source_file), _vm)
+        dict.set_item("name", name.ast_to_object(vm, source_file), vm)
+            .unwrap();
+        dict.set_item("default_value", default.ast_to_object(vm, source_file), vm)
             .unwrap();
-        dict.set_item(
-            "default_value",
-            default.ast_to_object(_vm, source_file),
-            _vm,
-        )
-        .unwrap();
-        node_add_location(&dict, _range, _vm, source_file);
+        node_add_location(&dict, range, vm, source_file);
         node.into()
     }
 
     fn ast_from_object(
-        _vm: &VirtualMachine,
+        vm: &VirtualMachine,
         source_file: &SourceFile,
-        _object: PyObjectRef,
+        object: PyObjectRef,
     ) -> PyResult<Self> {
         Ok(Self {
             node_index: Default::default(),
             name: Node::ast_from_object(
-                _vm,
+                vm,
                 source_file,
-                get_node_field(_vm, &_object, "name", "TypeVarTuple")?,
+                get_node_field(vm, &object, "name", "TypeVarTuple")?,
             )?,
             default: Node::ast_from_object(
-                _vm,
+                vm,
                 source_file,
-                get_node_field(_vm, &_object, "default_value", "TypeVarTuple")?,
+                get_node_field(vm, &object, "default_value", "TypeVarTuple")?,
             )?,
-            range: range_from_object(_vm, source_file, _object, "TypeVarTuple")?,
+            range: range_from_object(vm, source_file, object, "TypeVarTuple")?,
         })
     }
 }
diff --git a/crates/vm/src/stdlib/_ast/validate.rs b/crates/vm/src/stdlib/_ast/validate.rs
new file mode 100644
index 00000000000..9957fe4ee39
--- /dev/null
+++ b/crates/vm/src/stdlib/_ast/validate.rs
@@ -0,0 +1,663 @@
+// spell-checker: ignore assignlist ifexp
+
+use super::module::Mod;
+use crate::{PyResult, VirtualMachine};
+use ruff_python_ast as ast;
+
+fn expr_context_name(ctx: ast::ExprContext) -> &'static str {
+    match ctx {
+        ast::ExprContext::Load => "Load",
+        ast::ExprContext::Store => "Store",
+        ast::ExprContext::Del => "Del",
+        ast::ExprContext::Invalid => "Invalid",
+    }
+}
+
+fn validate_name(vm: &VirtualMachine, name: &ast::name::Name) -> PyResult<()> {
+    match name.as_str() {
+        "None" | "True" | "False" => Err(vm.new_value_error(format!(
+            "identifier field can't represent '{}' constant",
+            name.as_str()
+        ))),
+        _ => Ok(()),
+    }
+}
+
+fn validate_comprehension(vm: &VirtualMachine, gens: &[ast::Comprehension]) -> PyResult<()> {
+    if gens.is_empty() {
+        return Err(vm.new_value_error("comprehension with no generators"));
+    }
+    for comp in gens {
+        validate_expr(vm, &comp.target, ast::ExprContext::Store)?;
+        validate_expr(vm, &comp.iter, ast::ExprContext::Load)?;
+        validate_exprs(vm, &comp.ifs, ast::ExprContext::Load, false)?;
+    }
+    Ok(())
+}
+
+fn validate_keywords(vm: &VirtualMachine, keywords: &[ast::Keyword]) -> PyResult<()> {
+    for keyword in keywords {
+        validate_expr(vm, &keyword.value, ast::ExprContext::Load)?;
+    }
+    Ok(())
+}
+
+fn validate_parameters(vm: &VirtualMachine, params: &ast::Parameters) -> PyResult<()> {
+    for param in params
+        .posonlyargs
+        .iter()
+        .chain(&params.args)
+        .chain(&params.kwonlyargs)
+    {
+        if let Some(annotation) = &param.parameter.annotation {
+            validate_expr(vm, annotation, ast::ExprContext::Load)?;
+        }
+        if let Some(default) = &param.default {
+            validate_expr(vm, default, ast::ExprContext::Load)?;
+        }
+    }
+    if let Some(vararg) = &params.vararg
+        && let Some(annotation) = &vararg.annotation
+    {
+        validate_expr(vm, annotation, ast::ExprContext::Load)?;
+    }
+    if let Some(kwarg) = &params.kwarg
+        && let Some(annotation) = &kwarg.annotation
+    {
+        validate_expr(vm, annotation, ast::ExprContext::Load)?;
+    }
+    Ok(())
+}
+
+fn validate_nonempty_seq(
+    vm: &VirtualMachine,
+    len: usize,
+    what: &'static str,
+    owner: &'static str,
+) -> PyResult<()> {
+    if len == 0 {
+        return Err(vm.new_value_error(format!("empty {what} on {owner}")));
+    }
+    Ok(())
+}
+
+fn validate_assignlist(
+    vm: &VirtualMachine,
+    targets: &[ast::Expr],
+    ctx: ast::ExprContext,
+) -> PyResult<()> {
+    validate_nonempty_seq(
+        vm,
+        targets.len(),
+        "targets",
+        if ctx == ast::ExprContext::Del {
+            "Delete"
+        } else {
+            "Assign"
+        },
+    )?;
+    validate_exprs(vm, targets, ctx, false)
+}
+
+fn validate_body(vm: &VirtualMachine, body: &[ast::Stmt], owner: &'static str) -> PyResult<()> {
+    validate_nonempty_seq(vm, body.len(), "body", owner)?;
+    validate_stmts(vm, body)
+}
+
+fn validate_interpolated_elements<'a>(
+    vm: &VirtualMachine,
+    elements: impl IntoIterator<Item = ast::InterpolatedStringElementRef<'a>>,
+) -> PyResult<()> {
+    for element in elements {
+        if let ast::InterpolatedStringElementRef::Interpolation(interpolation) = element {
+            validate_expr(vm, &interpolation.expression, ast::ExprContext::Load)?;
+            if let Some(format_spec) = &interpolation.format_spec {
+                for spec_element in &format_spec.elements {
+                    if let ast::InterpolatedStringElement::Interpolation(spec_interp) = spec_element
+                    {
+                        validate_expr(vm, &spec_interp.expression, ast::ExprContext::Load)?;
+                    }
+                }
+            }
+        }
+    }
+    Ok(())
+}
+
+fn validate_pattern_match_value(vm: &VirtualMachine, expr: &ast::Expr) -> PyResult<()> {
+    validate_expr(vm, expr, ast::ExprContext::Load)?;
+    match expr {
+        ast::Expr::NumberLiteral(_) | ast::Expr::StringLiteral(_) | ast::Expr::BytesLiteral(_) => {
+            Ok(())
+        }
+        ast::Expr::Attribute(_) => Ok(()),
+        ast::Expr::UnaryOp(op) => match &*op.operand {
+            ast::Expr::NumberLiteral(_) => Ok(()),
+            _ => Err(vm.new_value_error("patterns may only match literals and attribute lookups")),
+        },
+        ast::Expr::BinOp(bin) => match (&*bin.left, &*bin.right) {
+            (ast::Expr::NumberLiteral(_), ast::Expr::NumberLiteral(_)) => Ok(()),
+            _ => Err(vm.new_value_error("patterns may only match literals and attribute lookups")),
+        },
+        ast::Expr::FString(_) | ast::Expr::TString(_) => Ok(()),
+        ast::Expr::BooleanLiteral(_)
+        | ast::Expr::NoneLiteral(_)
+        | ast::Expr::EllipsisLiteral(_) => {
+            Err(vm.new_value_error("unexpected constant inside of a literal pattern"))
+        }
+        _ => Err(vm.new_value_error("patterns may only match literals and attribute lookups")),
+    }
+}
+
+fn validate_capture(vm: &VirtualMachine, name: &ast::Identifier) -> PyResult<()> {
+    if name.as_str() == "_" {
+        return Err(vm.new_value_error("can't capture name '_' in patterns"));
+    }
+    validate_name(vm, name.id())
+}
+
+fn validate_pattern(vm: &VirtualMachine, pattern: &ast::Pattern, star_ok: bool) -> PyResult<()> {
+    match pattern {
+        ast::Pattern::MatchValue(value) => validate_pattern_match_value(vm, &value.value),
+        ast::Pattern::MatchSingleton(singleton) => match singleton.value {
+            ast::Singleton::None | ast::Singleton::True | ast::Singleton::False => Ok(()),
+        },
+        ast::Pattern::MatchSequence(seq) => validate_patterns(vm, &seq.patterns, true),
+        ast::Pattern::MatchMapping(mapping) => {
+            if mapping.keys.len() != mapping.patterns.len() {
+                return Err(vm.new_value_error(
+                    "MatchMapping doesn't have the same number of keys as patterns",
+                ));
+            }
+            if let Some(rest) = &mapping.rest {
+                validate_capture(vm, rest)?;
+            }
+            for key in &mapping.keys {
+                if let ast::Expr::BooleanLiteral(_) | ast::Expr::NoneLiteral(_) = key {
+                    continue;
+                }
+                validate_pattern_match_value(vm, key)?;
+            }
+            validate_patterns(vm, &mapping.patterns, false)
+        }
+        ast::Pattern::MatchClass(match_class) => {
+            validate_expr(vm, &match_class.cls, ast::ExprContext::Load)?;
+            let mut cls = match_class.cls.as_ref();
+            loop {
+                match cls {
+                    ast::Expr::Name(_) => break,
+                    ast::Expr::Attribute(attr) => {
+                        cls = &attr.value;
+                    }
+                    _ => {
+                        return Err(vm.new_value_error(
+                            "MatchClass cls field can only contain Name or Attribute nodes.",
+                        ));
+                    }
+                }
+            }
+            for keyword in &match_class.arguments.keywords {
+                validate_name(vm, keyword.attr.id())?;
+            }
+            validate_patterns(vm, &match_class.arguments.patterns, false)?;
+            for keyword in &match_class.arguments.keywords {
+                validate_pattern(vm, &keyword.pattern, false)?;
+            }
+            Ok(())
+        }
+        ast::Pattern::MatchStar(star) => {
+            if !star_ok {
+                return Err(vm.new_value_error("can't use MatchStar here"));
+            }
+            if let Some(name) = &star.name {
+                validate_capture(vm, name)?;
+            }
+            Ok(())
+        }
+        ast::Pattern::MatchAs(match_as) => {
+            if let Some(name) = &match_as.name {
+                validate_capture(vm, name)?;
+            }
+            match &match_as.pattern {
+                None => Ok(()),
+                Some(pattern) => {
+                    if match_as.name.is_none() {
+                        return Err(vm.new_value_error(
+                            "MatchAs must specify a target name if a pattern is given",
+                        ));
+                    }
+                    validate_pattern(vm, pattern, false)
+                }
+            }
+        }
+        ast::Pattern::MatchOr(match_or) => {
+            if match_or.patterns.len() < 2 {
+                return Err(vm.new_value_error("MatchOr requires at least 2 patterns"));
+            }
+            validate_patterns(vm, &match_or.patterns, false)
+        }
+    }
+}
+
+fn validate_patterns(
+    vm: &VirtualMachine,
+    patterns: &[ast::Pattern],
+    star_ok: bool,
+) -> PyResult<()> {
+    for pattern in patterns {
+        validate_pattern(vm, pattern, star_ok)?;
+    }
+    Ok(())
+}
+
+fn validate_typeparam(vm: &VirtualMachine, tp: &ast::TypeParam) -> PyResult<()> {
+    match tp {
+        ast::TypeParam::TypeVar(tp) => {
+            validate_name(vm, tp.name.id())?;
+            if let Some(bound) = &tp.bound {
+                validate_expr(vm, bound, ast::ExprContext::Load)?;
+            }
+            if let Some(default) = &tp.default {
+                validate_expr(vm, default, ast::ExprContext::Load)?;
+            }
+        }
+        ast::TypeParam::ParamSpec(tp) => {
+            validate_name(vm, tp.name.id())?;
+            if let Some(default) = &tp.default {
+                validate_expr(vm, default, ast::ExprContext::Load)?;
+            }
+        }
+        ast::TypeParam::TypeVarTuple(tp) => {
+            validate_name(vm, tp.name.id())?;
+            if let Some(default) = &tp.default {
+                validate_expr(vm, default, ast::ExprContext::Load)?;
+            }
+        }
+    }
+    Ok(())
+}
+
+fn validate_type_params(
+    vm: &VirtualMachine,
+    type_params: &Option<Box<ast::TypeParams>>,
+) -> PyResult<()> {
+    if let Some(type_params) = type_params {
+        for tp in &type_params.type_params {
+            validate_typeparam(vm, tp)?;
+        }
+    }
+    Ok(())
+}
+
+fn validate_exprs(
+    vm: &VirtualMachine,
+    exprs: &[ast::Expr],
+    ctx: ast::ExprContext,
+    _null_ok: bool,
+) -> PyResult<()> {
+    for expr in exprs {
+        validate_expr(vm, expr, ctx)?;
+    }
+    Ok(())
+}
+
+fn validate_expr(vm: &VirtualMachine, expr: &ast::Expr, ctx: ast::ExprContext) -> PyResult<()> {
+    let mut check_ctx = true;
+    let actual_ctx = match expr {
+        ast::Expr::Attribute(attr) => attr.ctx,
+        ast::Expr::Subscript(sub) => sub.ctx,
+        ast::Expr::Starred(star) => star.ctx,
+        ast::Expr::Name(name) => {
+            validate_name(vm, name.id())?;
+            name.ctx
+        }
+        ast::Expr::List(list) => list.ctx,
+        ast::Expr::Tuple(tuple) => tuple.ctx,
+        _ => {
+            if ctx != ast::ExprContext::Load {
+                return Err(vm.new_value_error(format!(
+                    "expression which can't be assigned to in {} context",
+                    expr_context_name(ctx)
+                )));
+            }
+            check_ctx = false;
+            ast::ExprContext::Invalid
+        }
+    };
+    if check_ctx && actual_ctx != ctx {
+        return Err(vm.new_value_error(format!(
+            "expression must have {} context but has {} instead",
+            expr_context_name(ctx),
+            expr_context_name(actual_ctx)
+        )));
+    }
+
+    match expr {
+        ast::Expr::BoolOp(op) => {
+            if op.values.len() < 2 {
+                return Err(vm.new_value_error("BoolOp with less than 2 values"));
+            }
+            validate_exprs(vm, &op.values, ast::ExprContext::Load, false)
+        }
+        ast::Expr::Named(named) => {
+            if !matches!(&*named.target, ast::Expr::Name(_)) {
+                return Err(vm.new_type_error("NamedExpr target must be a Name"));
+            }
+            validate_expr(vm, &named.value, ast::ExprContext::Load)
+        }
+        ast::Expr::BinOp(bin) => {
+            validate_expr(vm, &bin.left, ast::ExprContext::Load)?;
+            validate_expr(vm, &bin.right, ast::ExprContext::Load)
+        }
+        ast::Expr::UnaryOp(unary) => validate_expr(vm, &unary.operand, ast::ExprContext::Load),
+        ast::Expr::Lambda(lambda) => {
+            if let Some(parameters) = &lambda.parameters {
+                validate_parameters(vm, parameters)?;
+            }
+            validate_expr(vm, &lambda.body, ast::ExprContext::Load)
+        }
+        ast::Expr::If(ifexp) => {
+            validate_expr(vm, &ifexp.test, ast::ExprContext::Load)?;
+            validate_expr(vm, &ifexp.body, ast::ExprContext::Load)?;
+            validate_expr(vm, &ifexp.orelse, ast::ExprContext::Load)
+        }
+        ast::Expr::Dict(dict) => {
+            for item in &dict.items {
+                if let Some(key) = &item.key {
+                    validate_expr(vm, key, ast::ExprContext::Load)?;
+                }
+                validate_expr(vm, &item.value, ast::ExprContext::Load)?;
+            }
+            Ok(())
+        }
+        ast::Expr::Set(set) => validate_exprs(vm, &set.elts, ast::ExprContext::Load, false),
+        ast::Expr::ListComp(list) => {
+            validate_comprehension(vm, &list.generators)?;
+            validate_expr(vm, &list.elt, ast::ExprContext::Load)
+        }
+        ast::Expr::SetComp(set) => {
+            validate_comprehension(vm, &set.generators)?;
+            validate_expr(vm, &set.elt, ast::ExprContext::Load)
+        }
+        ast::Expr::DictComp(dict) => {
+            validate_comprehension(vm, &dict.generators)?;
+            validate_expr(vm, &dict.key, ast::ExprContext::Load)?;
+            validate_expr(vm, &dict.value, ast::ExprContext::Load)
+        }
+        ast::Expr::Generator(generator) => {
+            validate_comprehension(vm, &generator.generators)?;
+            validate_expr(vm, &generator.elt, ast::ExprContext::Load)
+        }
+        ast::Expr::Yield(yield_expr) => {
+            if let Some(value) = &yield_expr.value {
+                validate_expr(vm, value, ast::ExprContext::Load)?;
+            }
+            Ok(())
+        }
+        ast::Expr::YieldFrom(yield_expr) => {
+            validate_expr(vm, &yield_expr.value, ast::ExprContext::Load)
+        }
+        ast::Expr::Await(await_expr) => {
+            validate_expr(vm, &await_expr.value, ast::ExprContext::Load)
+        }
+        ast::Expr::Compare(compare) => {
+            if compare.comparators.is_empty() {
+                return Err(vm.new_value_error("Compare with no comparators"));
+            }
+            if compare.comparators.len() != compare.ops.len() {
+                return Err(vm.new_value_error(
+                    "Compare has a different number of comparators and operands",
+                ));
+            }
+            validate_exprs(vm, &compare.comparators, ast::ExprContext::Load, false)?;
+            validate_expr(vm, &compare.left, ast::ExprContext::Load)
+        }
+        ast::Expr::Call(call) => {
+            validate_expr(vm, &call.func, ast::ExprContext::Load)?;
+            validate_exprs(vm, &call.arguments.args, ast::ExprContext::Load, false)?;
+            validate_keywords(vm, &call.arguments.keywords)
+        }
+        ast::Expr::FString(fstring) => validate_interpolated_elements(
+            vm,
+            fstring
+                .value
+                .elements()
+                .map(ast::InterpolatedStringElementRef::from),
+        ),
+        ast::Expr::TString(tstring) => validate_interpolated_elements(
+            vm,
+            tstring
+                .value
+                .elements()
+                .map(ast::InterpolatedStringElementRef::from),
+        ),
+        ast::Expr::StringLiteral(_)
+        | ast::Expr::BytesLiteral(_)
+        | ast::Expr::NumberLiteral(_)
+        | ast::Expr::BooleanLiteral(_)
+        | ast::Expr::NoneLiteral(_)
+        | ast::Expr::EllipsisLiteral(_) => Ok(()),
+        ast::Expr::Attribute(attr) => validate_expr(vm, &attr.value, ast::ExprContext::Load),
+        ast::Expr::Subscript(sub) => {
+            validate_expr(vm, &sub.slice, ast::ExprContext::Load)?;
+            validate_expr(vm, &sub.value, ast::ExprContext::Load)
+        }
+        ast::Expr::Starred(star) => validate_expr(vm, &star.value, ctx),
+        ast::Expr::Name(_) => Ok(()),
+        ast::Expr::List(list) => validate_exprs(vm, &list.elts, ctx, false),
+        ast::Expr::Tuple(tuple) => validate_exprs(vm, &tuple.elts, ctx, false),
+        ast::Expr::Slice(slice) => {
+            if let Some(lower) = &slice.lower {
+                validate_expr(vm, lower, ast::ExprContext::Load)?;
+            }
+            if let Some(upper) = &slice.upper {
+                validate_expr(vm, upper, ast::ExprContext::Load)?;
+            }
+            if let Some(step) = &slice.step {
+                validate_expr(vm, step, ast::ExprContext::Load)?;
+            }
+            Ok(())
+        }
+        ast::Expr::IpyEscapeCommand(_) => Ok(()),
+    }
+}
+
+fn validate_decorators(vm: &VirtualMachine, decorators: &[ast::Decorator]) -> PyResult<()> {
+    for decorator in decorators {
+        validate_expr(vm, &decorator.expression, ast::ExprContext::Load)?;
+    }
+    Ok(())
+}
+
+fn validate_stmt(vm: &VirtualMachine, stmt: &ast::Stmt) -> PyResult<()> {
+    match stmt {
+        ast::Stmt::FunctionDef(func) => {
+            let owner = if func.is_async {
+                "AsyncFunctionDef"
+            } else {
+                "FunctionDef"
+            };
+            validate_body(vm, &func.body, owner)?;
+            validate_type_params(vm, &func.type_params)?;
+            validate_parameters(vm, &func.parameters)?;
+            validate_decorators(vm, &func.decorator_list)?;
+            if let Some(returns) = &func.returns {
+                validate_expr(vm, returns, ast::ExprContext::Load)?;
+            }
+            Ok(())
+        }
+        ast::Stmt::ClassDef(class_def) => {
+            validate_body(vm, &class_def.body, "ClassDef")?;
+            validate_type_params(vm, &class_def.type_params)?;
+            if let Some(arguments) = &class_def.arguments {
+                validate_exprs(vm, &arguments.args, ast::ExprContext::Load, false)?;
+                validate_keywords(vm, &arguments.keywords)?;
+            }
+            validate_decorators(vm, &class_def.decorator_list)
+        }
+        ast::Stmt::Return(ret) => {
+            if let Some(value) = &ret.value {
+                validate_expr(vm, value, ast::ExprContext::Load)?;
+            }
+            Ok(())
+        }
+        ast::Stmt::Delete(del) => validate_assignlist(vm, &del.targets, ast::ExprContext::Del),
+        ast::Stmt::Assign(assign) => {
+            validate_assignlist(vm, &assign.targets, ast::ExprContext::Store)?;
+            validate_expr(vm, &assign.value, ast::ExprContext::Load)
+        }
+        ast::Stmt::AugAssign(assign) => {
+            validate_expr(vm, &assign.target, ast::ExprContext::Store)?;
+            validate_expr(vm, &assign.value, ast::ExprContext::Load)
+        }
+        ast::Stmt::AnnAssign(assign) => {
+            if assign.simple && !matches!(&*assign.target, ast::Expr::Name(_)) {
+                return Err(vm.new_type_error("AnnAssign with simple non-Name target"));
+            }
+            validate_expr(vm, &assign.target, ast::ExprContext::Store)?;
+            if let Some(value) = &assign.value {
+                validate_expr(vm, value, ast::ExprContext::Load)?;
+            }
+            validate_expr(vm, &assign.annotation, ast::ExprContext::Load)
+        }
+        ast::Stmt::TypeAlias(alias) => {
+            if !matches!(&*alias.name, ast::Expr::Name(_)) {
+                return Err(vm.new_type_error("TypeAlias with non-Name name"));
+            }
+            validate_expr(vm, &alias.name, ast::ExprContext::Store)?;
+            validate_type_params(vm, &alias.type_params)?;
+            validate_expr(vm, &alias.value, ast::ExprContext::Load)
+        }
+        ast::Stmt::For(for_stmt) => {
+            let owner = if for_stmt.is_async { "AsyncFor" } else { "For" };
+            validate_expr(vm, &for_stmt.target, ast::ExprContext::Store)?;
+            validate_expr(vm, &for_stmt.iter, ast::ExprContext::Load)?;
+            validate_body(vm, &for_stmt.body, owner)?;
+            validate_stmts(vm, &for_stmt.orelse)
+        }
+        ast::Stmt::While(while_stmt) => {
+            validate_expr(vm, &while_stmt.test, ast::ExprContext::Load)?;
+            validate_body(vm, &while_stmt.body, "While")?;
+            validate_stmts(vm, &while_stmt.orelse)
+        }
+        ast::Stmt::If(if_stmt) => {
+            validate_expr(vm, &if_stmt.test, ast::ExprContext::Load)?;
+            validate_body(vm, &if_stmt.body, "If")?;
+            for clause in &if_stmt.elif_else_clauses {
+                if let Some(test) = &clause.test {
+                    validate_expr(vm, test, ast::ExprContext::Load)?;
+                }
+                validate_body(vm, &clause.body, "If")?;
+            }
+            Ok(())
+        }
+        ast::Stmt::With(with_stmt) => {
+            let owner = if with_stmt.is_async {
+                "AsyncWith"
+            } else {
+                "With"
+            };
+            validate_nonempty_seq(vm, with_stmt.items.len(), "items", owner)?;
+            for item in &with_stmt.items {
+                validate_expr(vm, &item.context_expr, ast::ExprContext::Load)?;
+                if let Some(optional_vars) = &item.optional_vars {
+                    validate_expr(vm, optional_vars, ast::ExprContext::Store)?;
+                }
+            }
+            validate_body(vm, &with_stmt.body, owner)
+        }
+        ast::Stmt::Match(match_stmt) => {
+            validate_expr(vm, &match_stmt.subject, ast::ExprContext::Load)?;
+            validate_nonempty_seq(vm, match_stmt.cases.len(), "cases", "Match")?;
+            for case in &match_stmt.cases {
+                validate_pattern(vm, &case.pattern, false)?;
+                if let Some(guard) = &case.guard {
+                    validate_expr(vm, guard, ast::ExprContext::Load)?;
+                }
+                validate_body(vm, &case.body, "match_case")?;
+            }
+            Ok(())
+        }
+        ast::Stmt::Raise(raise) => {
+            if let Some(exc) = &raise.exc {
+                validate_expr(vm, exc, ast::ExprContext::Load)?;
+                if let Some(cause) = &raise.cause {
+                    validate_expr(vm, cause, ast::ExprContext::Load)?;
+                }
+            } else if raise.cause.is_some() {
+                return Err(vm.new_value_error("Raise with cause but no exception"));
+            }
+            Ok(())
+        }
+        ast::Stmt::Try(try_stmt) => {
+            let owner = if try_stmt.is_star { "TryStar" } else { "Try" };
+            validate_body(vm, &try_stmt.body, owner)?;
+            if try_stmt.handlers.is_empty() && try_stmt.finalbody.is_empty() {
+                return Err(vm.new_value_error(format!(
+                    "{owner} has neither except handlers nor finalbody"
+                )));
+            }
+            if try_stmt.handlers.is_empty() && !try_stmt.orelse.is_empty() {
+                return Err(
+                    vm.new_value_error(format!("{owner} has orelse but no except handlers"))
+                );
+            }
+            for handler in &try_stmt.handlers {
+                let ast::ExceptHandler::ExceptHandler(handler) = handler;
+                if let Some(type_expr) = &handler.type_ {
+                    validate_expr(vm, type_expr, ast::ExprContext::Load)?;
+                }
+                validate_body(vm, &handler.body, "ExceptHandler")?;
+            }
+            validate_stmts(vm, &try_stmt.finalbody)?;
+            validate_stmts(vm, &try_stmt.orelse)
+        }
+        ast::Stmt::Assert(assert_stmt) => {
+            validate_expr(vm, &assert_stmt.test, ast::ExprContext::Load)?;
+            if let Some(msg) = &assert_stmt.msg {
+                validate_expr(vm, msg, ast::ExprContext::Load)?;
+            }
+            Ok(())
+        }
+        ast::Stmt::Import(import) => {
+            validate_nonempty_seq(vm, import.names.len(), "names", "Import")?;
+            Ok(())
+        }
+        ast::Stmt::ImportFrom(import) => {
+            validate_nonempty_seq(vm, import.names.len(), "names", "ImportFrom")?;
+            Ok(())
+        }
+        ast::Stmt::Global(global) => {
+            validate_nonempty_seq(vm, global.names.len(), "names", "Global")?;
+            Ok(())
+        }
+        ast::Stmt::Nonlocal(nonlocal) => {
+            validate_nonempty_seq(vm, nonlocal.names.len(), "names", "Nonlocal")?;
+            Ok(())
+        }
+        ast::Stmt::Expr(expr) => validate_expr(vm, &expr.value, ast::ExprContext::Load),
+        ast::Stmt::Pass(_)
+        | ast::Stmt::Break(_)
+        | ast::Stmt::Continue(_)
+        | ast::Stmt::IpyEscapeCommand(_) => Ok(()),
+    }
+}
+
+fn validate_stmts(vm: &VirtualMachine, stmts: &[ast::Stmt]) -> PyResult<()> {
+    for stmt in stmts {
+        validate_stmt(vm, stmt)?;
+    }
+    Ok(())
+}
+
+pub(super) fn validate_mod(vm: &VirtualMachine, module: &Mod) -> PyResult<()> {
+    match module {
+        Mod::Module(module) => validate_stmts(vm, &module.body),
+        Mod::Interactive(module) => validate_stmts(vm, &module.body),
+        Mod::Expression(expr) => validate_expr(vm, &expr.body, ast::ExprContext::Load),
+        Mod::FunctionType(func_type) => {
+            validate_exprs(vm, &func_type.argtypes, ast::ExprContext::Load, false)?;
+            validate_expr(vm, &func_type.returns, ast::ExprContext::Load)
+        }
+    }
+}
diff --git a/crates/vm/src/stdlib/_codecs.rs b/crates/vm/src/stdlib/_codecs.rs
new file mode 100644
index 00000000000..39ebb3599bd
--- /dev/null
+++ b/crates/vm/src/stdlib/_codecs.rs
@@ -0,0 +1,1395 @@
+// spell-checker: ignore unencodable pused
+
+pub(crate) use _codecs::module_def;
+
+use crate::common::static_cell::StaticCell;
+
+#[pymodule(with(#[cfg(windows)] _codecs_windows))]
+mod _codecs {
+    use crate::codecs::{ErrorsHandler, PyDecodeContext, PyEncodeContext};
+    use crate::common::encodings;
+    use crate::common::wtf8::Wtf8Buf;
+    use crate::{
+        AsObject, PyObjectRef, PyResult, VirtualMachine,
+        builtins::{PyStrRef, PyUtf8StrRef},
+        codecs,
+        exceptions::cstring_error,
+        function::{ArgBytesLike, FuncArgs},
+    };
+
+    #[pyfunction]
+    fn register(search_function: PyObjectRef, vm: &VirtualMachine) -> PyResult<()> {
+        vm.state.codec_registry.register(search_function, vm)
+    }
+
+    #[pyfunction]
+    fn unregister(search_function: PyObjectRef, vm: &VirtualMachine) -> PyResult<()> {
+        vm.state.codec_registry.unregister(search_function)
+    }
+
+    #[pyfunction]
+    fn lookup(encoding: PyUtf8StrRef, vm: &VirtualMachine) -> PyResult {
+        if encoding.as_str().contains('\0') {
+            return Err(cstring_error(vm));
+        }
+        vm.state
+            .codec_registry
+            .lookup(encoding.as_str(), vm)
+            .map(|codec| codec.into_tuple().into())
+    }
+
+    #[derive(FromArgs)]
+    struct CodeArgs {
+        obj: PyObjectRef,
+        #[pyarg(any, optional)]
+        encoding: Option<PyUtf8StrRef>,
+        #[pyarg(any, optional)]
+        errors: Option<PyUtf8StrRef>,
+    }
+
+    impl CodeArgs {
+        fn apply(
+            self,
+            vm: &VirtualMachine,
+            f: fn(
+                &codecs::CodecsRegistry,
+                PyObjectRef,
+                &str,
+                Option<PyUtf8StrRef>,
+                &VirtualMachine,
+            ) -> PyResult,
+        ) -> PyResult {
+            let encoding = self
+                .encoding
+                .as_deref()
+                .map(|s| s.as_str())
+                .unwrap_or(codecs::DEFAULT_ENCODING);
+            f(
+                &vm.state.codec_registry,
+                self.obj,
+                encoding,
+                self.errors,
+                vm,
+            )
+        }
+    }
+
+    #[pyfunction]
+    fn encode(args: CodeArgs, vm: &VirtualMachine) -> PyResult {
+        args.apply(vm, codecs::CodecsRegistry::encode)
+    }
+
+    #[pyfunction]
+    fn decode(args: CodeArgs, vm: &VirtualMachine) -> PyResult {
+        args.apply(vm, codecs::CodecsRegistry::decode)
+    }
+
+    #[pyfunction]
+    fn _forget_codec(encoding: PyUtf8StrRef, vm: &VirtualMachine) {
+        vm.state.codec_registry.forget(encoding.as_str());
+    }
+
+    #[pyfunction]
+    fn register_error(
+        name: PyUtf8StrRef,
+        handler: PyObjectRef,
+        vm: &VirtualMachine,
+    ) -> PyResult<()> {
+        if !handler.is_callable() {
+            return Err(vm.new_type_error("handler must be callable"));
+        }
+        vm.state
+            .codec_registry
+            .register_error(name.as_str().to_owned(), handler);
+        Ok(())
+    }
+
+    #[pyfunction]
+    fn lookup_error(name: PyUtf8StrRef, vm: &VirtualMachine) -> PyResult {
+        if name.as_str().contains('\0') {
+            return Err(cstring_error(vm));
+        }
+        vm.state.codec_registry.lookup_error(name.as_str(), vm)
+    }
+
+    #[pyfunction]
+    fn _unregister_error(errors: PyUtf8StrRef, vm: &VirtualMachine) -> PyResult<bool> {
+        if errors.as_str().contains('\0') {
+            return Err(cstring_error(vm));
+        }
+        vm.state
+            .codec_registry
+            .unregister_error(errors.as_str(), vm)
+    }
+
+    type EncodeResult = PyResult<(Vec<u8>, usize)>;
+
+    #[derive(FromArgs)]
+    struct EncodeArgs {
+        #[pyarg(positional)]
+        s: PyStrRef,
+        #[pyarg(positional, optional)]
+        errors: Option<PyUtf8StrRef>,
+    }
+
+    impl EncodeArgs {
+        #[inline]
+        fn encode<'a, F>(&'a self, name: &'a str, encode: F, vm: &'a VirtualMachine) -> EncodeResult
+        where
+            F: FnOnce(PyEncodeContext<'a>, &ErrorsHandler<'a>) -> PyResult<Vec<u8>>,
+        {
+            let ctx = PyEncodeContext::new(name, &self.s, vm);
+            let errors = ErrorsHandler::new(self.errors.as_deref(), vm);
+            let encoded = encode(ctx, &errors)?;
+            Ok((encoded, self.s.char_len()))
+        }
+    }
+
+    type DecodeResult = PyResult<(Wtf8Buf, usize)>;
+
+    #[derive(FromArgs)]
+    struct DecodeArgs {
+        #[pyarg(positional)]
+        data: ArgBytesLike,
+        #[pyarg(positional, optional)]
+        errors: Option<PyUtf8StrRef>,
+        #[pyarg(positional, default = false)]
+        final_decode: bool,
+    }
+
+    impl DecodeArgs {
+        #[inline]
+        fn decode<'a, F>(&'a self, name: &'a str, decode: F, vm: &'a VirtualMachine) -> DecodeResult
+        where
+            F: FnOnce(PyDecodeContext<'a>, &ErrorsHandler<'a>, bool) -> DecodeResult,
+        {
+            let ctx = PyDecodeContext::new(name, &self.data, vm);
+            let errors = ErrorsHandler::new(self.errors.as_deref(), vm);
+            decode(ctx, &errors, self.final_decode)
+        }
+    }
+
+    #[derive(FromArgs)]
+    struct DecodeArgsNoFinal {
+        #[pyarg(positional)]
+        data: ArgBytesLike,
+        #[pyarg(positional, optional)]
+        errors: Option<PyUtf8StrRef>,
+    }
+
+    impl DecodeArgsNoFinal {
+        #[inline]
+        fn decode<'a, F>(&'a self, name: &'a str, decode: F, vm: &'a VirtualMachine) -> DecodeResult
+        where
+            F: FnOnce(PyDecodeContext<'a>, &ErrorsHandler<'a>) -> DecodeResult,
+        {
+            let ctx = PyDecodeContext::new(name, &self.data, vm);
+            let errors = ErrorsHandler::new(self.errors.as_deref(), vm);
+            decode(ctx, &errors)
+        }
+    }
+
+    macro_rules! do_codec {
+        ($module:ident :: $func:ident, $args: expr, $vm:expr) => {{
+            use encodings::$module as codec;
+            $args.$func(codec::ENCODING_NAME, codec::$func, $vm)
+        }};
+    }
+
+    #[pyfunction]
+    fn utf_8_encode(args: EncodeArgs, vm: &VirtualMachine) -> EncodeResult {
+        if args.s.is_utf8()
+            || args
+                .errors
+                .as_ref()
+                .is_some_and(|s| s.is(identifier!(vm, surrogatepass)))
+        {
+            return Ok((args.s.as_bytes().to_vec(), args.s.byte_len()));
+        }
+        do_codec!(utf8::encode, args, vm)
+    }
+
+    #[pyfunction]
+    fn utf_8_decode(args: DecodeArgs, vm: &VirtualMachine) -> DecodeResult {
+        do_codec!(utf8::decode, args, vm)
+    }
+
+    #[pyfunction]
+    fn latin_1_encode(args: EncodeArgs, vm: &VirtualMachine) -> EncodeResult {
+        if args.s.isascii() {
+            return Ok((args.s.as_bytes().to_vec(), args.s.byte_len()));
+        }
+        do_codec!(latin_1::encode, args, vm)
+    }
+
+    #[pyfunction]
+    fn latin_1_decode(args: DecodeArgsNoFinal, vm: &VirtualMachine) -> DecodeResult {
+        do_codec!(latin_1::decode, args, vm)
+    }
+
+    #[pyfunction]
+    fn ascii_encode(args: EncodeArgs, vm: &VirtualMachine) -> EncodeResult {
+        if args.s.isascii() {
+            return Ok((args.s.as_bytes().to_vec(), args.s.byte_len()));
+        }
+        do_codec!(ascii::encode, args, vm)
+    }
+
+    #[pyfunction]
+    fn ascii_decode(args: DecodeArgsNoFinal, vm: &VirtualMachine) -> DecodeResult {
+        do_codec!(ascii::decode, args, vm)
+    }
+
+    // TODO: implement these codecs in Rust!
+
+    macro_rules! delegate_pycodecs {
+        ($name:ident, $args:ident, $vm:ident) => {{
+            rustpython_common::static_cell!(
+                static FUNC: PyObjectRef;
+            );
+            super::delegate_pycodecs(&FUNC, stringify!($name), $args, $vm)
+        }};
+    }
+
+    #[pyfunction]
+    fn readbuffer_encode(args: FuncArgs, vm: &VirtualMachine) -> PyResult {
+        delegate_pycodecs!(readbuffer_encode, args, vm)
+    }
+    #[pyfunction]
+    fn escape_encode(args: FuncArgs, vm: &VirtualMachine) -> PyResult {
+        delegate_pycodecs!(escape_encode, args, vm)
+    }
+    #[pyfunction]
+    fn escape_decode(args: FuncArgs, vm: &VirtualMachine) -> PyResult {
+        delegate_pycodecs!(escape_decode, args, vm)
+    }
+    #[pyfunction]
+    fn unicode_escape_encode(args: FuncArgs, vm: &VirtualMachine) -> PyResult {
+        delegate_pycodecs!(unicode_escape_encode, args, vm)
+    }
+    #[pyfunction]
+    fn unicode_escape_decode(args: FuncArgs, vm: &VirtualMachine) -> PyResult {
+        delegate_pycodecs!(unicode_escape_decode, args, vm)
+    }
+    #[pyfunction]
+    fn raw_unicode_escape_encode(args: FuncArgs, vm: &VirtualMachine) -> PyResult {
+        delegate_pycodecs!(raw_unicode_escape_encode, args, vm)
+    }
+    #[pyfunction]
+    fn raw_unicode_escape_decode(args: FuncArgs, vm: &VirtualMachine) -> PyResult {
+        delegate_pycodecs!(raw_unicode_escape_decode, args, vm)
+    }
+    #[pyfunction]
+    fn utf_7_encode(args: FuncArgs, vm: &VirtualMachine) -> PyResult {
+        delegate_pycodecs!(utf_7_encode, args, vm)
+    }
+    #[pyfunction]
+    fn utf_7_decode(args: FuncArgs, vm: &VirtualMachine) -> PyResult {
+        delegate_pycodecs!(utf_7_decode, args, vm)
+    }
+    #[pyfunction]
+    fn utf_16_encode(args: FuncArgs, vm: &VirtualMachine) -> PyResult {
+        delegate_pycodecs!(utf_16_encode, args, vm)
+    }
+    #[pyfunction]
+    fn utf_16_decode(args: FuncArgs, vm: &VirtualMachine) -> PyResult {
+        delegate_pycodecs!(utf_16_decode, args, vm)
+    }
+    #[pyfunction]
+    fn charmap_encode(args: FuncArgs, vm: &VirtualMachine) -> PyResult {
+        delegate_pycodecs!(charmap_encode, args, vm)
+    }
+    #[pyfunction]
+    fn charmap_decode(args: FuncArgs, vm: &VirtualMachine) -> PyResult {
+        delegate_pycodecs!(charmap_decode, args, vm)
+    }
+    #[pyfunction]
+    fn charmap_build(args: FuncArgs, vm: &VirtualMachine) -> PyResult {
+        delegate_pycodecs!(charmap_build, args, vm)
+    }
+    #[pyfunction]
+    fn utf_16_le_encode(args: FuncArgs, vm: &VirtualMachine) -> PyResult {
+        delegate_pycodecs!(utf_16_le_encode, args, vm)
+    }
+    #[pyfunction]
+    fn utf_16_le_decode(args: FuncArgs, vm: &VirtualMachine) -> PyResult {
+        delegate_pycodecs!(utf_16_le_decode, args, vm)
+    }
+    #[pyfunction]
+    fn utf_16_be_encode(args: FuncArgs, vm: &VirtualMachine) -> PyResult {
+        delegate_pycodecs!(utf_16_be_encode, args, vm)
+    }
+    #[pyfunction]
+    fn utf_16_be_decode(args: FuncArgs, vm: &VirtualMachine) -> PyResult {
+        delegate_pycodecs!(utf_16_be_decode, args, vm)
+    }
+    #[pyfunction]
+    fn utf_16_ex_decode(args: FuncArgs, vm: &VirtualMachine) -> PyResult {
+        delegate_pycodecs!(utf_16_ex_decode, args, vm)
+    }
+    #[pyfunction]
+    fn utf_32_ex_decode(args: FuncArgs, vm: &VirtualMachine) -> PyResult {
+        delegate_pycodecs!(utf_32_ex_decode, args, vm)
+    }
+    #[pyfunction]
+    fn utf_32_encode(args: FuncArgs, vm: &VirtualMachine) -> PyResult {
+        delegate_pycodecs!(utf_32_encode, args, vm)
+    }
+    #[pyfunction]
+    fn utf_32_decode(args: FuncArgs, vm: &VirtualMachine) -> PyResult {
+        delegate_pycodecs!(utf_32_decode, args, vm)
+    }
+    #[pyfunction]
+    fn utf_32_le_encode(args: FuncArgs, vm: &VirtualMachine) -> PyResult {
+        delegate_pycodecs!(utf_32_le_encode, args, vm)
+    }
+    #[pyfunction]
+    fn utf_32_le_decode(args: FuncArgs, vm: &VirtualMachine) -> PyResult {
+        delegate_pycodecs!(utf_32_le_decode, args, vm)
+    }
+    #[pyfunction]
+    fn utf_32_be_encode(args: FuncArgs, vm: &VirtualMachine) -> PyResult {
+        delegate_pycodecs!(utf_32_be_encode, args, vm)
+    }
+    #[pyfunction]
+    fn utf_32_be_decode(args: FuncArgs, vm: &VirtualMachine) -> PyResult {
+        delegate_pycodecs!(utf_32_be_decode, args, vm)
+    }
+}
+
+#[inline]
+fn delegate_pycodecs(
+    cell: &'static StaticCell<crate::PyObjectRef>,
+    name: &'static str,
+    args: crate::function::FuncArgs,
+    vm: &crate::VirtualMachine,
+) -> crate::PyResult {
+    let f = cell.get_or_try_init(|| {
+        let module = vm.import("_pycodecs", 0)?;
+        module.get_attr(name, vm)
+    })?;
+    f.call(args, vm)
+}
+
+#[cfg(windows)]
+#[pymodule(sub)]
+mod _codecs_windows {
+    use crate::{PyResult, VirtualMachine};
+    use crate::{builtins::PyStrRef, builtins::PyUtf8StrRef, function::ArgBytesLike};
+
+    #[derive(FromArgs)]
+    struct MbcsEncodeArgs {
+        #[pyarg(positional)]
+        s: PyStrRef,
+        #[pyarg(positional, optional)]
+        errors: Option<PyUtf8StrRef>,
+    }
+
+    #[pyfunction]
+    fn mbcs_encode(args: MbcsEncodeArgs, vm: &VirtualMachine) -> PyResult<(Vec<u8>, usize)> {
+        use crate::common::windows::ToWideString;
+        use windows_sys::Win32::Globalization::{
+            CP_ACP, WC_NO_BEST_FIT_CHARS, WideCharToMultiByte,
+        };
+
+        let errors = args.errors.as_ref().map(|s| s.as_str()).unwrap_or("strict");
+        let s = match args.s.to_str() {
+            Some(s) => s,
+            None => {
+                // String contains surrogates - not encodable with mbcs
+                return Err(vm.new_unicode_encode_error(
+                    "'mbcs' codec can't encode character: surrogates not allowed",
+                ));
+            }
+        };
+        let char_len = args.s.char_len();
+
+        if s.is_empty() {
+            return Ok((Vec::new(), char_len));
+        }
+
+        // Convert UTF-8 string to UTF-16
+        let wide: Vec<u16> = std::ffi::OsStr::new(s).to_wide();
+
+        // Get the required buffer size
+        let size = unsafe {
+            WideCharToMultiByte(
+                CP_ACP,
+                WC_NO_BEST_FIT_CHARS,
+                wide.as_ptr(),
+                wide.len() as i32,
+                core::ptr::null_mut(),
+                0,
+                core::ptr::null(),
+                core::ptr::null_mut(),
+            )
+        };
+
+        if size == 0 {
+            let err = std::io::Error::last_os_error();
+            return Err(vm.new_os_error(format!("mbcs_encode failed: {}", err)));
+        }
+
+        let mut buffer = vec![0u8; size as usize];
+        let mut used_default_char: i32 = 0;
+
+        let result = unsafe {
+            WideCharToMultiByte(
+                CP_ACP,
+                WC_NO_BEST_FIT_CHARS,
+                wide.as_ptr(),
+                wide.len() as i32,
+                buffer.as_mut_ptr().cast(),
+                size,
+                core::ptr::null(),
+                if errors == "strict" {
+                    &mut used_default_char
+                } else {
+                    core::ptr::null_mut()
+                },
+            )
+        };
+
+        if result == 0 {
+            let err = std::io::Error::last_os_error();
+            return Err(vm.new_os_error(format!("mbcs_encode failed: {err}")));
+        }
+
+        if errors == "strict" && used_default_char != 0 {
+            return Err(vm.new_unicode_encode_error(
+                "'mbcs' codec can't encode characters: invalid character",
+            ));
+        }
+
+        buffer.truncate(result as usize);
+        Ok((buffer, char_len))
+    }
+
+    #[derive(FromArgs)]
+    struct MbcsDecodeArgs {
+        #[pyarg(positional)]
+        data: ArgBytesLike,
+        #[pyarg(positional, optional)]
+        errors: Option<PyUtf8StrRef>,
+        #[pyarg(positional, default = false)]
+        #[allow(dead_code)]
+        r#final: bool,
+    }
+
+    #[pyfunction]
+    fn mbcs_decode(args: MbcsDecodeArgs, vm: &VirtualMachine) -> PyResult<(String, usize)> {
+        use windows_sys::Win32::Globalization::{
+            CP_ACP, MB_ERR_INVALID_CHARS, MultiByteToWideChar,
+        };
+
+        let _errors = args.errors.as_ref().map(|s| s.as_str()).unwrap_or("strict");
+        let data = args.data.borrow_buf();
+        let len = data.len();
+
+        if data.is_empty() {
+            return Ok((String::new(), 0));
+        }
+
+        // Get the required buffer size for UTF-16
+        let size = unsafe {
+            MultiByteToWideChar(
+                CP_ACP,
+                MB_ERR_INVALID_CHARS,
+                data.as_ptr().cast(),
+                len as i32,
+                core::ptr::null_mut(),
+                0,
+            )
+        };
+
+        if size == 0 {
+            // Try without MB_ERR_INVALID_CHARS for non-strict mode (replacement behavior)
+            let size = unsafe {
+                MultiByteToWideChar(
+                    CP_ACP,
+                    0,
+                    data.as_ptr().cast(),
+                    len as i32,
+                    core::ptr::null_mut(),
+                    0,
+                )
+            };
+            if size == 0 {
+                let err = std::io::Error::last_os_error();
+                return Err(vm.new_os_error(format!("mbcs_decode failed: {}", err)));
+            }
+
+            let mut buffer = vec![0u16; size as usize];
+            let result = unsafe {
+                MultiByteToWideChar(
+                    CP_ACP,
+                    0,
+                    data.as_ptr().cast(),
+                    len as i32,
+                    buffer.as_mut_ptr(),
+                    size,
+                )
+            };
+            if result == 0 {
+                let err = std::io::Error::last_os_error();
+                return Err(vm.new_os_error(format!("mbcs_decode failed: {}", err)));
+            }
+            buffer.truncate(result as usize);
+            let s = String::from_utf16(&buffer)
+                .map_err(|e| vm.new_unicode_decode_error(format!("mbcs_decode failed: {}", e)))?;
+            return Ok((s, len));
+        }
+
+        // Strict mode succeeded - no invalid characters
+        let mut buffer = vec![0u16; size as usize];
+        let result = unsafe {
+            MultiByteToWideChar(
+                CP_ACP,
+                MB_ERR_INVALID_CHARS,
+                data.as_ptr().cast(),
+                len as i32,
+                buffer.as_mut_ptr(),
+                size,
+            )
+        };
+        if result == 0 {
+            let err = std::io::Error::last_os_error();
+            return Err(vm.new_os_error(format!("mbcs_decode failed: {}", err)));
+        }
+        buffer.truncate(result as usize);
+        let s = String::from_utf16(&buffer)
+            .map_err(|e| vm.new_unicode_decode_error(format!("mbcs_decode failed: {}", e)))?;
+
+        Ok((s, len))
+    }
+
+    #[derive(FromArgs)]
+    struct OemEncodeArgs {
+        #[pyarg(positional)]
+        s: PyStrRef,
+        #[pyarg(positional, optional)]
+        errors: Option<PyUtf8StrRef>,
+    }
+
+    #[pyfunction]
+    fn oem_encode(args: OemEncodeArgs, vm: &VirtualMachine) -> PyResult<(Vec<u8>, usize)> {
+        use crate::common::windows::ToWideString;
+        use windows_sys::Win32::Globalization::{
+            CP_OEMCP, WC_NO_BEST_FIT_CHARS, WideCharToMultiByte,
+        };
+
+        let errors = args.errors.as_ref().map(|s| s.as_str()).unwrap_or("strict");
+        let s = match args.s.to_str() {
+            Some(s) => s,
+            None => {
+                // String contains surrogates - not encodable with oem
+                return Err(vm.new_unicode_encode_error(
+                    "'oem' codec can't encode character: surrogates not allowed",
+                ));
+            }
+        };
+        let char_len = args.s.char_len();
+
+        if s.is_empty() {
+            return Ok((Vec::new(), char_len));
+        }
+
+        // Convert UTF-8 string to UTF-16
+        let wide: Vec<u16> = std::ffi::OsStr::new(s).to_wide();
+
+        // Get the required buffer size
+        let size = unsafe {
+            WideCharToMultiByte(
+                CP_OEMCP,
+                WC_NO_BEST_FIT_CHARS,
+                wide.as_ptr(),
+                wide.len() as i32,
+                core::ptr::null_mut(),
+                0,
+                core::ptr::null(),
+                core::ptr::null_mut(),
+            )
+        };
+
+        if size == 0 {
+            let err = std::io::Error::last_os_error();
+            return Err(vm.new_os_error(format!("oem_encode failed: {}", err)));
+        }
+
+        let mut buffer = vec![0u8; size as usize];
+        let mut used_default_char: i32 = 0;
+
+        let result = unsafe {
+            WideCharToMultiByte(
+                CP_OEMCP,
+                WC_NO_BEST_FIT_CHARS,
+                wide.as_ptr(),
+                wide.len() as i32,
+                buffer.as_mut_ptr().cast(),
+                size,
+                core::ptr::null(),
+                if errors == "strict" {
+                    &mut used_default_char
+                } else {
+                    core::ptr::null_mut()
+                },
+            )
+        };
+
+        if result == 0 {
+            let err = std::io::Error::last_os_error();
+            return Err(vm.new_os_error(format!("oem_encode failed: {err}")));
+        }
+
+        if errors == "strict" && used_default_char != 0 {
+            return Err(vm.new_unicode_encode_error(
+                "'oem' codec can't encode characters: invalid character",
+            ));
+        }
+
+        buffer.truncate(result as usize);
+        Ok((buffer, char_len))
+    }
+
+    #[derive(FromArgs)]
+    struct OemDecodeArgs {
+        #[pyarg(positional)]
+        data: ArgBytesLike,
+        #[pyarg(positional, optional)]
+        errors: Option<PyUtf8StrRef>,
+        #[pyarg(positional, default = false)]
+        #[allow(dead_code)]
+        r#final: bool,
+    }
+
+    #[pyfunction]
+    fn oem_decode(args: OemDecodeArgs, vm: &VirtualMachine) -> PyResult<(String, usize)> {
+        use windows_sys::Win32::Globalization::{
+            CP_OEMCP, MB_ERR_INVALID_CHARS, MultiByteToWideChar,
+        };
+
+        let _errors = args.errors.as_ref().map(|s| s.as_str()).unwrap_or("strict");
+        let data = args.data.borrow_buf();
+        let len = data.len();
+
+        if data.is_empty() {
+            return Ok((String::new(), 0));
+        }
+
+        // Get the required buffer size for UTF-16
+        let size = unsafe {
+            MultiByteToWideChar(
+                CP_OEMCP,
+                MB_ERR_INVALID_CHARS,
+                data.as_ptr().cast(),
+                len as i32,
+                core::ptr::null_mut(),
+                0,
+            )
+        };
+
+        if size == 0 {
+            // Try without MB_ERR_INVALID_CHARS for non-strict mode (replacement behavior)
+            let size = unsafe {
+                MultiByteToWideChar(
+                    CP_OEMCP,
+                    0,
+                    data.as_ptr().cast(),
+                    len as i32,
+                    core::ptr::null_mut(),
+                    0,
+                )
+            };
+            if size == 0 {
+                let err = std::io::Error::last_os_error();
+                return Err(vm.new_os_error(format!("oem_decode failed: {}", err)));
+            }
+
+            let mut buffer = vec![0u16; size as usize];
+            let result = unsafe {
+                MultiByteToWideChar(
+                    CP_OEMCP,
+                    0,
+                    data.as_ptr().cast(),
+                    len as i32,
+                    buffer.as_mut_ptr(),
+                    size,
+                )
+            };
+            if result == 0 {
+                let err = std::io::Error::last_os_error();
+                return Err(vm.new_os_error(format!("oem_decode failed: {}", err)));
+            }
+            buffer.truncate(result as usize);
+            let s = String::from_utf16(&buffer)
+                .map_err(|e| vm.new_unicode_decode_error(format!("oem_decode failed: {}", e)))?;
+            return Ok((s, len));
+        }
+
+        // Strict mode succeeded - no invalid characters
+        let mut buffer = vec![0u16; size as usize];
+        let result = unsafe {
+            MultiByteToWideChar(
+                CP_OEMCP,
+                MB_ERR_INVALID_CHARS,
+                data.as_ptr().cast(),
+                len as i32,
+                buffer.as_mut_ptr(),
+                size,
+            )
+        };
+        if result == 0 {
+            let err = std::io::Error::last_os_error();
+            return Err(vm.new_os_error(format!("oem_decode failed: {}", err)));
+        }
+        buffer.truncate(result as usize);
+        let s = String::from_utf16(&buffer)
+            .map_err(|e| vm.new_unicode_decode_error(format!("oem_decode failed: {}", e)))?;
+
+        Ok((s, len))
+    }
+
+    #[derive(FromArgs)]
+    struct CodePageEncodeArgs {
+        #[pyarg(positional)]
+        code_page: i32,
+        #[pyarg(positional)]
+        s: PyStrRef,
+        #[pyarg(positional, optional)]
+        errors: Option<PyUtf8StrRef>,
+    }
+
+    fn code_page_encoding_name(code_page: u32) -> String {
+        match code_page {
+            0 => "mbcs".to_string(),
+            cp => format!("cp{cp}"),
+        }
+    }
+
+    /// Get WideCharToMultiByte flags for encoding.
+    /// Matches encode_code_page_flags() in CPython.
+    fn encode_code_page_flags(code_page: u32, errors: &str) -> u32 {
+        use windows_sys::Win32::Globalization::{WC_ERR_INVALID_CHARS, WC_NO_BEST_FIT_CHARS};
+        if code_page == 65001 {
+            // CP_UTF8
+            WC_ERR_INVALID_CHARS
+        } else if code_page == 65000 {
+            // CP_UTF7 only supports flags=0
+            0
+        } else if errors == "replace" {
+            0
+        } else {
+            WC_NO_BEST_FIT_CHARS
+        }
+    }
+
+    /// Try to encode the entire wide string at once (fast/strict path).
+    /// Returns Ok(Some(bytes)) on success, Ok(None) if there are unencodable chars,
+    /// or Err on OS error.
+    fn try_encode_code_page_strict(
+        code_page: u32,
+        wide: &[u16],
+        vm: &VirtualMachine,
+    ) -> PyResult<Option<Vec<u8>>> {
+        use windows_sys::Win32::Globalization::WideCharToMultiByte;
+
+        let flags = encode_code_page_flags(code_page, "strict");
+
+        let use_default_char = code_page != 65001 && code_page != 65000;
+        let mut used_default_char: i32 = 0;
+        let pused = if use_default_char {
+            &mut used_default_char as *mut i32
+        } else {
+            core::ptr::null_mut()
+        };
+
+        let size = unsafe {
+            WideCharToMultiByte(
+                code_page,
+                flags,
+                wide.as_ptr(),
+                wide.len() as i32,
+                core::ptr::null_mut(),
+                0,
+                core::ptr::null(),
+                pused,
+            )
+        };
+
+        if size <= 0 {
+            let err_code = std::io::Error::last_os_error().raw_os_error().unwrap_or(0);
+            if err_code == 1113 {
+                // ERROR_NO_UNICODE_TRANSLATION
+                return Ok(None);
+            }
+            let err = std::io::Error::last_os_error();
+            return Err(vm.new_os_error(format!("code_page_encode: {err}")));
+        }
+
+        if use_default_char && used_default_char != 0 {
+            return Ok(None);
+        }
+
+        let mut buffer = vec![0u8; size as usize];
+        used_default_char = 0;
+        let pused = if use_default_char {
+            &mut used_default_char as *mut i32
+        } else {
+            core::ptr::null_mut()
+        };
+
+        let result = unsafe {
+            WideCharToMultiByte(
+                code_page,
+                flags,
+                wide.as_ptr(),
+                wide.len() as i32,
+                buffer.as_mut_ptr().cast(),
+                size,
+                core::ptr::null(),
+                pused,
+            )
+        };
+
+        if result <= 0 {
+            let err_code = std::io::Error::last_os_error().raw_os_error().unwrap_or(0);
+            if err_code == 1113 {
+                return Ok(None);
+            }
+            let err = std::io::Error::last_os_error();
+            return Err(vm.new_os_error(format!("code_page_encode: {err}")));
+        }
+
+        if use_default_char && used_default_char != 0 {
+            return Ok(None);
+        }
+
+        buffer.truncate(result as usize);
+        Ok(Some(buffer))
+    }
+
+    /// Encode character by character with error handling.
+    fn encode_code_page_errors(
+        code_page: u32,
+        s: &PyStrRef,
+        errors: &str,
+        encoding_name: &str,
+        vm: &VirtualMachine,
+    ) -> PyResult<(Vec<u8>, usize)> {
+        use crate::builtins::{PyBytes, PyStr, PyTuple};
+        use windows_sys::Win32::Globalization::WideCharToMultiByte;
+
+        let char_len = s.char_len();
+        let flags = encode_code_page_flags(code_page, errors);
+        let use_default_char = code_page != 65001 && code_page != 65000;
+        let encoding_str = vm.ctx.new_str(encoding_name);
+        let reason_str = vm.ctx.new_str("invalid character");
+
+        // For strict mode, find the first unencodable character and raise
+        if errors == "strict" {
+            // Find the failing position by trying each character
+            let mut fail_pos = 0;
+            for cp in s.as_wtf8().code_points() {
+                let ch = cp.to_u32();
+                if (0xD800..=0xDFFF).contains(&ch) {
+                    break;
+                }
+                let mut wchars = [0u16; 2];
+                let wchar_len = if ch < 0x10000 {
+                    wchars[0] = ch as u16;
+                    1
+                } else {
+                    wchars[0] = ((ch - 0x10000) >> 10) as u16 + 0xD800;
+                    wchars[1] = ((ch - 0x10000) & 0x3FF) as u16 + 0xDC00;
+                    2
+                };
+                let mut used_default_char: i32 = 0;
+                let pused = if use_default_char {
+                    &mut used_default_char as *mut i32
+                } else {
+                    core::ptr::null_mut()
+                };
+                let outsize = unsafe {
+                    WideCharToMultiByte(
+                        code_page,
+                        flags,
+                        wchars.as_ptr(),
+                        wchar_len,
+                        core::ptr::null_mut(),
+                        0,
+                        core::ptr::null(),
+                        pused,
+                    )
+                };
+                if outsize <= 0 || (use_default_char && used_default_char != 0) {
+                    break;
+                }
+                fail_pos += 1;
+            }
+            return Err(vm.new_unicode_encode_error_real(
+                encoding_str,
+                s.clone(),
+                fail_pos,
+                fail_pos + 1,
+                reason_str,
+            ));
+        }
+
+        let error_handler = vm.state.codec_registry.lookup_error(errors, vm)?;
+        let mut output = Vec::new();
+
+        // Collect code points for random access
+        let code_points: Vec<u32> = s.as_wtf8().code_points().map(|cp| cp.to_u32()).collect();
+
+        let mut pos = 0usize;
+        while pos < code_points.len() {
+            let ch = code_points[pos];
+
+            // Convert code point to UTF-16
+            let mut wchars = [0u16; 2];
+            let wchar_len;
+            let is_surrogate = (0xD800..=0xDFFF).contains(&ch);
+
+            if is_surrogate {
+                wchar_len = 0; // Can't encode surrogates normally
+            } else if ch < 0x10000 {
+                wchars[0] = ch as u16;
+                wchar_len = 1;
+            } else {
+                wchars[0] = ((ch - 0x10000) >> 10) as u16 + 0xD800;
+                wchars[1] = ((ch - 0x10000) & 0x3FF) as u16 + 0xDC00;
+                wchar_len = 2;
+            }
+
+            if !is_surrogate {
+                let mut used_default_char: i32 = 0;
+                let pused = if use_default_char {
+                    &mut used_default_char as *mut i32
+                } else {
+                    core::ptr::null_mut()
+                };
+
+                let mut buf = [0u8; 8];
+                let outsize = unsafe {
+                    WideCharToMultiByte(
+                        code_page,
+                        flags,
+                        wchars.as_ptr(),
+                        wchar_len,
+                        buf.as_mut_ptr().cast(),
+                        buf.len() as i32,
+                        core::ptr::null(),
+                        pused,
+                    )
+                };
+
+                if outsize > 0 && (!use_default_char || used_default_char == 0) {
+                    output.extend_from_slice(&buf[..outsize as usize]);
+                    pos += 1;
+                    continue;
+                }
+            }
+
+            // Character can't be encoded - call error handler
+            let exc = vm.new_unicode_encode_error_real(
+                encoding_str.clone(),
+                s.clone(),
+                pos,
+                pos + 1,
+                reason_str.clone(),
+            );
+
+            let res = error_handler.call((exc,), vm)?;
+            let tuple_err =
+                || vm.new_type_error("encoding error handler must return (str/bytes, int) tuple");
+            let tuple: &PyTuple = res.downcast_ref().ok_or_else(&tuple_err)?;
+            let tuple_slice = tuple.as_slice();
+            if tuple_slice.len() != 2 {
+                return Err(tuple_err());
+            }
+
+            let replacement = &tuple_slice[0];
+            let new_pos_obj = tuple_slice[1].clone();
+
+            if let Some(bytes) = replacement.downcast_ref::<PyBytes>() {
+                output.extend_from_slice(bytes);
+            } else if let Some(rep_str) = replacement.downcast_ref::<PyStr>() {
+                // Replacement string - try to encode each character
+                for rcp in rep_str.as_wtf8().code_points() {
+                    let rch = rcp.to_u32();
+                    if rch > 127 {
+                        return Err(vm.new_unicode_encode_error_real(
+                            encoding_str.clone(),
+                            s.clone(),
+                            pos,
+                            pos + 1,
+                            vm.ctx
+                                .new_str("unable to encode error handler result to ASCII"),
+                        ));
+                    }
+                    output.push(rch as u8);
+                }
+            } else {
+                return Err(tuple_err());
+            }
+
+            let new_pos: isize = new_pos_obj.try_into_value(vm).map_err(|_| tuple_err())?;
+            pos = if new_pos < 0 {
+                (code_points.len() as isize + new_pos).max(0) as usize
+            } else {
+                new_pos as usize
+            };
+        }
+
+        Ok((output, char_len))
+    }
+
+    #[pyfunction]
+    fn code_page_encode(
+        args: CodePageEncodeArgs,
+        vm: &VirtualMachine,
+    ) -> PyResult<(Vec<u8>, usize)> {
+        use crate::common::windows::ToWideString;
+
+        if args.code_page < 0 {
+            return Err(vm.new_value_error("invalid code page number"));
+        }
+        let errors = args.errors.as_ref().map(|s| s.as_str()).unwrap_or("strict");
+        let code_page = args.code_page as u32;
+        let char_len = args.s.char_len();
+
+        if char_len == 0 {
+            return Ok((Vec::new(), 0));
+        }
+
+        let encoding_name = code_page_encoding_name(code_page);
+
+        // Fast path: try encoding the whole string at once (only if no surrogates)
+        if let Some(str_data) = args.s.to_str() {
+            let wide: Vec<u16> = std::ffi::OsStr::new(str_data).to_wide();
+            if let Some(result) = try_encode_code_page_strict(code_page, &wide, vm)? {
+                return Ok((result, char_len));
+            }
+        }
+
+        // Slow path: character by character with error handling
+        encode_code_page_errors(code_page, &args.s, errors, &encoding_name, vm)
+    }
+
+    #[derive(FromArgs)]
+    struct CodePageDecodeArgs {
+        #[pyarg(positional)]
+        code_page: i32,
+        #[pyarg(positional)]
+        data: ArgBytesLike,
+        #[pyarg(positional, optional)]
+        errors: Option<PyUtf8StrRef>,
+        #[pyarg(positional, default = false)]
+        r#final: bool,
+    }
+
+    /// Try to decode the entire buffer with strict flags (fast path).
+    /// Returns Ok(Some(wide_chars)) on success, Ok(None) on decode error,
+    /// or Err on OS error.
+    fn try_decode_code_page_strict(
+        code_page: u32,
+        data: &[u8],
+        vm: &VirtualMachine,
+    ) -> PyResult<Option<Vec<u16>>> {
+        use windows_sys::Win32::Globalization::{MB_ERR_INVALID_CHARS, MultiByteToWideChar};
+
+        let mut flags = MB_ERR_INVALID_CHARS;
+
+        loop {
+            let size = unsafe {
+                MultiByteToWideChar(
+                    code_page,
+                    flags,
+                    data.as_ptr().cast(),
+                    data.len() as i32,
+                    core::ptr::null_mut(),
+                    0,
+                )
+            };
+            if size > 0 {
+                let mut buffer = vec![0u16; size as usize];
+                let result = unsafe {
+                    MultiByteToWideChar(
+                        code_page,
+                        flags,
+                        data.as_ptr().cast(),
+                        data.len() as i32,
+                        buffer.as_mut_ptr(),
+                        size,
+                    )
+                };
+                if result > 0 {
+                    buffer.truncate(result as usize);
+                    return Ok(Some(buffer));
+                }
+            }
+
+            let err_code = std::io::Error::last_os_error().raw_os_error().unwrap_or(0);
+            // ERROR_INVALID_FLAGS = 1004
+            if flags != 0 && err_code == 1004 {
+                flags = 0;
+                continue;
+            }
+            // ERROR_NO_UNICODE_TRANSLATION = 1113
+            if err_code == 1113 {
+                return Ok(None);
+            }
+            let err = std::io::Error::last_os_error();
+            return Err(vm.new_os_error(format!("code_page_decode: {err}")));
+        }
+    }
+
+    /// Decode byte by byte with error handling (slow path).
+    fn decode_code_page_errors(
+        code_page: u32,
+        data: &[u8],
+        errors: &str,
+        is_final: bool,
+        encoding_name: &str,
+        vm: &VirtualMachine,
+    ) -> PyResult<(PyStrRef, usize)> {
+        use crate::builtins::PyTuple;
+        use crate::common::wtf8::Wtf8Buf;
+        use windows_sys::Win32::Globalization::{MB_ERR_INVALID_CHARS, MultiByteToWideChar};
+
+        let len = data.len();
+        let encoding_str = vm.ctx.new_str(encoding_name);
+        let reason_str = vm
+            .ctx
+            .new_str("No mapping for the Unicode character exists in the target code page.");
+
+        // For strict+final, find the failing position and raise
+        if errors == "strict" && is_final {
+            // Find the exact failing byte position by trying byte by byte
+            let mut fail_pos = 0;
+            let mut flags_s: u32 = MB_ERR_INVALID_CHARS;
+            let mut buf = [0u16; 2];
+            while fail_pos < len {
+                let mut in_size = 1;
+                let mut found = false;
+                while in_size <= 4 && fail_pos + in_size <= len {
+                    let outsize = unsafe {
+                        MultiByteToWideChar(
+                            code_page,
+                            flags_s,
+                            data[fail_pos..].as_ptr().cast(),
+                            in_size as i32,
+                            buf.as_mut_ptr(),
+                            2,
+                        )
+                    };
+                    if outsize > 0 {
+                        fail_pos += in_size;
+                        found = true;
+                        break;
+                    }
+                    let err_code = std::io::Error::last_os_error().raw_os_error().unwrap_or(0);
+                    if err_code == 1004 && flags_s != 0 {
+                        flags_s = 0;
+                        continue;
+                    }
+                    in_size += 1;
+                }
+                if !found {
+                    break;
+                }
+            }
+            let object = vm.ctx.new_bytes(data.to_vec());
+            return Err(vm.new_unicode_decode_error_real(
+                encoding_str,
+                object,
+                fail_pos,
+                fail_pos + 1,
+                reason_str,
+            ));
+        }
+
+        let error_handler = if errors != "strict"
+            && errors != "ignore"
+            && errors != "replace"
+            && errors != "backslashreplace"
+            && errors != "surrogateescape"
+        {
+            Some(vm.state.codec_registry.lookup_error(errors, vm)?)
+        } else {
+            None
+        };
+
+        let mut wide_buf: Vec<u16> = Vec::new();
+        let mut pos = 0usize;
+        let mut flags: u32 = MB_ERR_INVALID_CHARS;
+
+        while pos < len {
+            // Try to decode with increasing byte counts (1, 2, 3, 4)
+            let mut in_size = 1;
+            let mut outsize;
+            let mut buffer = [0u16; 2];
+
+            loop {
+                outsize = unsafe {
+                    MultiByteToWideChar(
+                        code_page,
+                        flags,
+                        data[pos..].as_ptr().cast(),
+                        in_size as i32,
+                        buffer.as_mut_ptr(),
+                        2,
+                    )
+                };
+                if outsize > 0 {
+                    break;
+                }
+                let err_code = std::io::Error::last_os_error().raw_os_error().unwrap_or(0);
+                if err_code == 1004 && flags != 0 {
+                    // ERROR_INVALID_FLAGS - retry with flags=0
+                    flags = 0;
+                    continue;
+                }
+                if err_code != 1113 && err_code != 122 {
+                    // Not ERROR_NO_UNICODE_TRANSLATION and not ERROR_INSUFFICIENT_BUFFER
+                    let err = std::io::Error::last_os_error();
+                    return Err(vm.new_os_error(format!("code_page_decode: {err}")));
+                }
+                in_size += 1;
+                if in_size > 4 || pos + in_size > len {
+                    break;
+                }
+            }
+
+            if outsize <= 0 {
+                // Can't decode this byte sequence
+                if pos + in_size >= len && !is_final {
+                    // Incomplete sequence at end, not final - stop here
+                    break;
+                }
+
+                // Handle the error based on error mode
+                match errors {
+                    "ignore" => {
+                        pos += 1;
+                    }
+                    "replace" => {
+                        wide_buf.push(0xFFFD);
+                        pos += 1;
+                    }
+                    "backslashreplace" => {
+                        let byte = data[pos];
+                        for ch in format!("\\x{byte:02x}").encode_utf16() {
+                            wide_buf.push(ch);
+                        }
+                        pos += 1;
+                    }
+                    "surrogateescape" => {
+                        let byte = data[pos];
+                        wide_buf.push(0xDC00 + byte as u16);
+                        pos += 1;
+                    }
+                    "strict" => {
+                        let object = vm.ctx.new_bytes(data.to_vec());
+                        return Err(vm.new_unicode_decode_error_real(
+                            encoding_str,
+                            object,
+                            pos,
+                            pos + 1,
+                            reason_str,
+                        ));
+                    }
+                    _ => {
+                        // Custom error handler
+                        let object = vm.ctx.new_bytes(data.to_vec());
+                        let exc = vm.new_unicode_decode_error_real(
+                            encoding_str.clone(),
+                            object,
+                            pos,
+                            pos + 1,
+                            reason_str.clone(),
+                        );
+                        let handler = error_handler.as_ref().unwrap();
+                        let res = handler.call((exc,), vm)?;
+                        let tuple_err = || {
+                            vm.new_type_error("decoding error handler must return (str, int) tuple")
+                        };
+                        let tuple: &PyTuple = res.downcast_ref().ok_or_else(&tuple_err)?;
+                        let tuple_slice = tuple.as_slice();
+                        if tuple_slice.len() != 2 {
+                            return Err(tuple_err());
+                        }
+
+                        let replacement: PyStrRef = tuple_slice[0]
+                            .clone()
+                            .try_into_value(vm)
+                            .map_err(|_| tuple_err())?;
+                        let new_pos: isize = tuple_slice[1]
+                            .clone()
+                            .try_into_value(vm)
+                            .map_err(|_| tuple_err())?;
+
+                        for cp in replacement.as_wtf8().code_points() {
+                            let u = cp.to_u32();
+                            if u < 0x10000 {
+                                wide_buf.push(u as u16);
+                            } else {
+                                wide_buf.push(((u - 0x10000) >> 10) as u16 + 0xD800);
+                                wide_buf.push(((u - 0x10000) & 0x3FF) as u16 + 0xDC00);
+                            }
+                        }
+
+                        pos = if new_pos < 0 {
+                            (len as isize + new_pos).max(0) as usize
+                        } else {
+                            new_pos as usize
+                        };
+                    }
+                }
+            } else {
+                // Successfully decoded
+                wide_buf.extend_from_slice(&buffer[..outsize as usize]);
+                pos += in_size;
+            }
+        }
+
+        let s = Wtf8Buf::from_wide(&wide_buf);
+        Ok((vm.ctx.new_str(s), pos))
+    }
+
+    #[pyfunction]
+    fn code_page_decode(
+        args: CodePageDecodeArgs,
+        vm: &VirtualMachine,
+    ) -> PyResult<(PyStrRef, usize)> {
+        use crate::common::wtf8::Wtf8Buf;
+
+        if args.code_page < 0 {
+            return Err(vm.new_value_error("invalid code page number"));
+        }
+        let errors = args.errors.as_ref().map(|s| s.as_str()).unwrap_or("strict");
+        let code_page = args.code_page as u32;
+        let data = args.data.borrow_buf();
+        let is_final = args.r#final;
+
+        if data.is_empty() {
+            return Ok((vm.ctx.empty_str.to_owned(), 0));
+        }
+
+        let encoding_name = code_page_encoding_name(code_page);
+
+        // Fast path: try to decode the whole buffer with strict flags
+        match try_decode_code_page_strict(code_page, &data, vm)? {
+            Some(wide) => {
+                let s = Wtf8Buf::from_wide(&wide);
+                return Ok((vm.ctx.new_str(s), data.len()));
+            }
+            None => {
+                // Decode error - fall through to slow path
+            }
+        }
+
+        // Slow path: byte by byte with error handling
+        decode_code_page_errors(code_page, &data, errors, is_final, &encoding_name, vm)
+    }
+}
diff --git a/crates/vm/src/stdlib/collections.rs b/crates/vm/src/stdlib/_collections.rs
similarity index 96%
rename from crates/vm/src/stdlib/collections.rs
rename to crates/vm/src/stdlib/_collections.rs
index 0f84db80e74..2807e171777 100644
--- a/crates/vm/src/stdlib/collections.rs
+++ b/crates/vm/src/stdlib/_collections.rs
@@ -7,7 +7,7 @@ mod _collections {
         atomic_func,
         builtins::{
             IterStatus::{Active, Exhausted},
-            PositionIterInternal, PyGenericAlias, PyInt, PyType, PyTypeRef,
+            PositionIterInternal, PyGenericAlias, PyInt, PyStr, PyType, PyTypeRef,
         },
         common::lock::{PyMutex, PyRwLock, PyRwLockReadGuard, PyRwLockWriteGuard},
         function::{KwArgs, OptionalArg, PyComparisonValue},
@@ -56,7 +56,7 @@ mod _collections {
     }
 
     #[pyclass(
-        flags(BASETYPE),
+        flags(BASETYPE, HAS_WEAKREF),
         with(
             Constructor,
             Initializer,
@@ -559,7 +559,7 @@ mod _collections {
 
     impl Representable for PyDeque {
         #[inline]
-        fn repr_str(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<String> {
+        fn repr(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<PyRef<PyStr>> {
             let deque = zelf.borrow_deque().clone();
             let class = zelf.class();
             let class_name = class.name();
@@ -568,15 +568,24 @@ mod _collections {
                 .map(|maxlen| format!("], maxlen={maxlen}"))
                 .unwrap_or_else(|| "]".to_owned());
 
-            let s = if zelf.__len__() == 0 {
-                format!("{class_name}([{closing_part})")
-            } else if let Some(_guard) = ReprGuard::enter(vm, zelf.as_object()) {
-                collection_repr(Some(&class_name), "[", &closing_part, deque.iter(), vm)?
+            if zelf.__len__() == 0 {
+                return Ok(vm.ctx.new_str(format!("{class_name}([{closing_part})")));
+            }
+            if let Some(_guard) = ReprGuard::enter(vm, zelf.as_object()) {
+                Ok(vm.ctx.new_str(collection_repr(
+                    Some(&class_name),
+                    "[",
+                    &closing_part,
+                    deque.iter(),
+                    vm,
+                )?))
             } else {
-                "[...]".to_owned()
-            };
+                Ok(vm.ctx.intern_str("[...]").to_owned())
+            }
+        }
 
-            Ok(s)
+        fn repr_str(_zelf: &Py<Self>, _vm: &VirtualMachine) -> PyResult<String> {
+            unreachable!("repr() is overridden directly")
         }
     }
 
diff --git a/crates/vm/src/stdlib/ctypes.rs b/crates/vm/src/stdlib/_ctypes.rs
similarity index 95%
rename from crates/vm/src/stdlib/ctypes.rs
rename to crates/vm/src/stdlib/_ctypes.rs
index 97255f4384f..2534f6128e8 100644
--- a/crates/vm/src/stdlib/ctypes.rs
+++ b/crates/vm/src/stdlib/_ctypes.rs
@@ -70,18 +70,26 @@ impl Py<PyType> {
 }
 
 impl PyType {
-    /// Check if StgInfo is already initialized - prevent double initialization
+    /// Check if StgInfo is already initialized.
+    /// Raises SystemError if already initialized.
     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()),
+                format!("class \"{}\" already initialized", self.name()).into(),
             ));
         }
         Ok(())
     }
+
+    /// Check if StgInfo is already initialized, returning true if so.
+    /// Unlike check_not_initialized, does not raise an error.
+    pub(crate) fn is_initialized(&self) -> bool {
+        self.get_type_data::<StgInfo>()
+            .is_some_and(|stg_info| stg_info.initialized)
+    }
 }
 
 // Dynamic type check helpers for PyCData
@@ -619,7 +627,7 @@ pub(crate) mod _ctypes {
     #[pyfunction]
     fn dlsym(
         handle: usize,
-        name: crate::builtins::PyStrRef,
+        name: crate::builtins::PyUtf8StrRef,
         vm: &VirtualMachine,
     ) -> PyResult<usize> {
         let symbol_name = alloc::ffi::CString::new(name.as_str())
@@ -681,7 +689,7 @@ pub(crate) mod _ctypes {
         // 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 name = format!("LP_{}", s.as_wtf8());
 
             let new_type = metaclass
                 .as_object()
@@ -922,7 +930,7 @@ pub(crate) mod _ctypes {
             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(),
+                    "Memory cannot be resized because this object doesn't own it",
                 ));
             }
         }
@@ -988,6 +996,11 @@ pub(crate) mod _ctypes {
         super::function::INTERNAL_CAST_ADDR
     }
 
+    #[pyattr]
+    fn _memoryview_at_addr(_vm: &VirtualMachine) -> usize {
+        super::function::INTERNAL_MEMORYVIEW_AT_ADDR
+    }
+
     #[pyfunction]
     fn _cast(
         obj: PyObjectRef,
@@ -1104,7 +1117,7 @@ pub(crate) mod _ctypes {
                 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;
+                let ptr = s.as_bytes().as_ptr() as isize;
                 arg_values.push(ptr);
                 arg_types.push(Type::pointer());
             } else {
@@ -1187,7 +1200,7 @@ pub(crate) mod _ctypes {
 
         let error_code = code.unwrap_or_else(|| unsafe { GetLastError() });
 
-        let mut buffer: *mut u16 = std::ptr::null_mut();
+        let mut buffer: *mut u16 = core::ptr::null_mut();
         let len = unsafe {
             FormatMessageW(
                 FORMAT_MESSAGE_ALLOCATE_BUFFER
@@ -1207,7 +1220,7 @@ pub(crate) mod _ctypes {
         }
 
         let message = unsafe {
-            let slice = std::slice::from_raw_parts(buffer, len as usize);
+            let slice = core::slice::from_raw_parts(buffer, len as usize);
             let msg = String::from_utf16_lossy(slice).trim_end().to_string();
             LocalFree(buffer as *mut _);
             msg
@@ -1244,11 +1257,11 @@ pub(crate) mod _ctypes {
         } 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>() {
+            if buffer.len() >= core::mem::size_of::<usize>() {
                 usize::from_ne_bytes(
-                    buffer[..std::mem::size_of::<usize>()]
+                    buffer[..core::mem::size_of::<usize>()]
                         .try_into()
-                        .unwrap_or([0; std::mem::size_of::<usize>()]),
+                        .unwrap_or([0; core::mem::size_of::<usize>()]),
                 )
             } else {
                 0
@@ -1264,9 +1277,9 @@ pub(crate) mod _ctypes {
                 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 =
+                let addref_fn: extern "system" fn(*mut core::ffi::c_void) -> u32 =
                     core::mem::transmute(*vtable.add(1)); // AddRef is index 1
-                addref_fn(src_ptr as *mut std::ffi::c_void);
+                addref_fn(src_ptr as *mut core::ffi::c_void);
             }
         }
 
@@ -1287,25 +1300,26 @@ pub(crate) mod _ctypes {
         __module_exec(vm, module);
 
         let ctx = &vm.ctx;
-        PyCSimpleType::make_class(ctx);
-        array::PyCArrayType::make_class(ctx);
-        pointer::PyCPointerType::make_class(ctx);
-        structure::PyCStructType::make_class(ctx);
-        union::PyCUnionType::make_class(ctx);
-        function::PyCFuncPtrType::make_class(ctx);
+        PyCSimpleType::make_static_type();
+        array::PyCArrayType::make_static_type();
+        pointer::PyCPointerType::make_static_type();
+        structure::PyCStructType::make_static_type();
+        union::PyCUnionType::make_static_type();
+        function::PyCFuncPtrType::make_static_type();
+        function::RawMemoryBuffer::make_static_type();
 
         extend_module!(vm, module, {
-            "_CData" => PyCData::make_class(ctx),
-            "_SimpleCData" => PyCSimple::make_class(ctx),
-            "Array" => PyCArray::make_class(ctx),
-            "CField" => PyCField::make_class(ctx),
-            "CFuncPtr" => function::PyCFuncPtr::make_class(ctx),
-            "_Pointer" => PyCPointer::make_class(ctx),
+            "_CData" => PyCData::make_static_type(),
+            "_SimpleCData" => PyCSimple::make_static_type(),
+            "Array" => PyCArray::make_static_type(),
+            "CField" => PyCField::make_static_type(),
+            "CFuncPtr" => function::PyCFuncPtr::make_static_type(),
+            "_Pointer" => PyCPointer::make_static_type(),
             "_pointer_type_cache" => ctx.new_dict(),
             "_array_type_cache" => ctx.new_dict(),
-            "Structure" => PyCStructure::make_class(ctx),
-            "CThunkObject" => function::PyCThunk::make_class(ctx),
-            "Union" => PyCUnion::make_class(ctx),
+            "Structure" => PyCStructure::make_static_type(),
+            "CThunkObject" => function::PyCThunk::make_static_type(),
+            "Union" => PyCUnion::make_static_type(),
         });
 
         Ok(())
diff --git a/crates/vm/src/stdlib/ctypes/array.rs b/crates/vm/src/stdlib/_ctypes/array.rs
similarity index 96%
rename from crates/vm/src/stdlib/ctypes/array.rs
rename to crates/vm/src/stdlib/_ctypes/array.rs
index eea1fd765d5..568e2a4a0a9 100644
--- a/crates/vm/src/stdlib/ctypes/array.rs
+++ b/crates/vm/src/stdlib/_ctypes/array.rs
@@ -1,6 +1,8 @@
 use super::StgInfo;
 use super::base::{CDATA_BUFFER_METHODS, PyCData};
 use super::type_info;
+use crate::common::lock::LazyLock;
+use crate::sliceable::SaturatedSliceIter;
 use crate::{
     AsObject, Py, PyObject, PyObjectRef, PyPayload, PyRef, PyResult, TryFromObject, VirtualMachine,
     atomic_func,
@@ -301,6 +303,16 @@ impl Initializer for PyCArrayType {
 
 #[pyclass(flags(IMMUTABLETYPE), with(Initializer, AsNumber))]
 impl PyCArrayType {
+    #[pygetset(name = "__pointer_type__")]
+    fn pointer_type(zelf: PyTypeRef, vm: &VirtualMachine) -> PyResult {
+        super::base::pointer_type_get(&zelf, vm)
+    }
+
+    #[pygetset(name = "__pointer_type__", setter)]
+    fn set_pointer_type(zelf: PyTypeRef, value: PyObjectRef, vm: &VirtualMachine) -> PyResult<()> {
+        super::base::pointer_type_set(&zelf, value, vm)
+    }
+
     #[pymethod]
     fn from_param(zelf: PyObjectRef, value: PyObjectRef, vm: &VirtualMachine) -> PyResult {
         // zelf is the array type class that from_param was called on
@@ -445,7 +457,6 @@ impl Initializer for PyCArray {
 
 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| {
                 let zelf = PyCArray::sequence_downcast(seq);
@@ -470,7 +481,6 @@ 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);
@@ -712,27 +722,22 @@ impl PyCArray {
             }
             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())
-                }
+                let val = buffer[offset..]
+                    .first_chunk::<4>()
+                    .copied()
+                    .map_or(0.0, f32::from_ne_bytes);
+                Ok(vm.ctx.new_float(val as f64).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())
-                }
+                let val = buffer[offset..]
+                    .first_chunk::<8>()
+                    .copied()
+                    .map_or(0.0, f64::from_ne_bytes);
+                Ok(vm.ctx.new_float(val).into())
             }
             _ => {
-                if offset + element_size <= buffer.len() {
-                    let bytes = &buffer[offset..offset + element_size];
+                if let Some(bytes) = buffer[offset..].get(..element_size) {
                     Ok(Self::bytes_to_int(bytes, element_size, type_code, vm))
                 } else {
                     Ok(vm.ctx.new_int(0).into())
@@ -770,7 +775,12 @@ impl PyCArray {
             }
             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);
+                    let code = s
+                        .as_wtf8()
+                        .code_points()
+                        .next()
+                        .map(|c| c.to_u32())
+                        .unwrap_or(0);
                     if offset + WCHAR_SIZE <= buffer.len() {
                         wchar_to_bytes(code, &mut buffer[offset..]);
                     }
@@ -782,14 +792,16 @@ impl PyCArray {
                 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))
+                    let (kept_alive, ptr) = super::base::ensure_z_null_terminated(bytes, vm);
+                    zelf.0.keep_alive(index, kept_alive);
+                    (ptr, Some(value.to_owned()))
                 } 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(),
-                    ));
+                    return Err(vm.new_type_error(format!(
+                        "bytes or integer address expected instead of {} instance",
+                        value.class().name()
+                    )));
                 };
                 if offset + element_size <= buffer.len() {
                     buffer[offset..offset + element_size].copy_from_slice(&ptr_val.to_ne_bytes());
@@ -802,7 +814,7 @@ impl PyCArray {
                 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);
+                    let (holder, ptr) = super::base::str_to_wchar_bytes(s.as_wtf8(), vm);
                     (ptr, Some(holder))
                 } else if let Ok(int_val) = value.try_index(vm) {
                     (int_val.as_bigint().to_usize().unwrap_or(0), None)
@@ -959,8 +971,6 @@ impl PyCArray {
 
     // 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);
 
@@ -1083,8 +1093,6 @@ impl PyCArray {
         value: PyObjectRef,
         vm: &VirtualMachine,
     ) -> PyResult<()> {
-        use crate::sliceable::SaturatedSliceIter;
-
         let length = zelf.class().stg_info_opt().map_or(0, |i| i.length);
 
         // PySlice_Unpack + PySlice_AdjustIndices
@@ -1243,15 +1251,15 @@ fn wchar_array_set_value(
         .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();
+    let char_count = s.as_wtf8().code_points().count();
 
     if char_count > wchar_count {
         return Err(vm.new_value_error("string too long"));
     }
 
-    for (i, ch) in s.as_str().chars().enumerate() {
+    for (i, ch) in s.as_wtf8().code_points().enumerate() {
         let offset = i * WCHAR_SIZE;
-        wchar_to_bytes(ch as u32, &mut buffer.to_mut()[offset..]);
+        wchar_to_bytes(ch.to_u32(), &mut buffer.to_mut()[offset..]);
     }
 
     let terminator_offset = char_count * WCHAR_SIZE;
diff --git a/crates/vm/src/stdlib/ctypes/base.rs b/crates/vm/src/stdlib/_ctypes/base.rs
similarity index 83%
rename from crates/vm/src/stdlib/ctypes/base.rs
rename to crates/vm/src/stdlib/_ctypes/base.rs
index 58d9466adb2..0bfbe57bb04 100644
--- a/crates/vm/src/stdlib/ctypes/base.rs
+++ b/crates/vm/src/stdlib/_ctypes/base.rs
@@ -1,9 +1,12 @@
 use super::array::{WCHAR_SIZE, wchar_from_bytes, wchar_to_bytes};
-use crate::builtins::{PyBytes, PyDict, PyMemoryView, PyStr, PyType, PyTypeRef};
+use crate::builtins::{
+    PyBytes, PyDict, PyList, PyMemoryView, PyStr, PyTuple, PyType, PyTypeRef, PyUtf8Str,
+};
 use crate::class::StaticType;
+use crate::convert::ToPyObject;
 use crate::function::{ArgBytesLike, OptionalArg, PySetterValue};
 use crate::protocol::{BufferMethods, PyBuffer};
-use crate::types::{GetDescriptor, Representable};
+use crate::types::{Constructor, GetDescriptor, Representable};
 use crate::{
     AsObject, Py, PyObject, PyObjectRef, PyPayload, PyResult, TryFromObject, VirtualMachine,
 };
@@ -16,6 +19,7 @@ use core::mem;
 use crossbeam_utils::atomic::AtomicCell;
 use num_traits::{Signed, ToPrimitive};
 use rustpython_common::lock::PyRwLock;
+use rustpython_common::wtf8::Wtf8;
 use widestring::WideChar;
 
 // StgInfo - Storage information for ctypes types
@@ -97,6 +101,9 @@ pub struct StgInfo {
 
     // FFI field types for structure/union passing (inherited from base class)
     pub ffi_field_types: Vec<libffi::middle::Type>,
+
+    // Cached pointer type (non-inheritable via descriptor)
+    pub pointer_type: Option<PyObjectRef>,
 }
 
 // StgInfo is stored in type_data which requires Send + Sync.
@@ -141,6 +148,7 @@ impl Default for StgInfo {
             paramfunc: ParamFunc::None,
             big_endian: cfg!(target_endian = "big"), // native endian by default
             ffi_field_types: Vec::new(),
+            pointer_type: None,
         }
     }
 }
@@ -161,6 +169,7 @@ impl StgInfo {
             paramfunc: ParamFunc::None,
             big_endian: cfg!(target_endian = "big"), // native endian by default
             ffi_field_types: Vec::new(),
+            pointer_type: None,
         }
     }
 
@@ -212,6 +221,7 @@ impl StgInfo {
             paramfunc: ParamFunc::Array,
             big_endian: cfg!(target_endian = "big"), // native endian by default
             ffi_field_types: Vec::new(),
+            pointer_type: None,
         }
     }
 
@@ -293,6 +303,34 @@ impl StgInfo {
     }
 }
 
+/// __pointer_type__ getter for ctypes metaclasses.
+/// Reads from StgInfo.pointer_type (non-inheritable).
+pub(super) fn pointer_type_get(zelf: &Py<PyType>, vm: &VirtualMachine) -> PyResult {
+    zelf.stg_info_opt()
+        .and_then(|info| info.pointer_type.clone())
+        .ok_or_else(|| {
+            vm.new_attribute_error(format!(
+                "type {} has no attribute '__pointer_type__'",
+                zelf.name()
+            ))
+        })
+}
+
+/// __pointer_type__ setter for ctypes metaclasses.
+/// Writes to StgInfo.pointer_type (non-inheritable).
+pub(super) fn pointer_type_set(
+    zelf: &Py<PyType>,
+    value: PyObjectRef,
+    vm: &VirtualMachine,
+) -> PyResult<()> {
+    if let Some(mut info) = zelf.get_type_data_mut::<StgInfo>() {
+        info.pointer_type = Some(value);
+        Ok(())
+    } else {
+        Err(vm.new_attribute_error(format!("cannot set __pointer_type__ on {}", zelf.name())))
+    }
+}
+
 /// Get PEP3118 format string for a field type
 /// Returns the format string considering byte order
 pub(super) fn get_field_format(
@@ -329,11 +367,10 @@ pub(super) fn get_field_format(
     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.is_empty() {
-            return format!("{}{}", endian_prefix, s);
-        }
-        return s.to_string();
+        let s = type_str
+            .to_str()
+            .expect("_type_ is validated as ASCII at type creation");
+        return format!("{}{}", endian_prefix, s);
     }
 
     // Default: single byte
@@ -380,32 +417,27 @@ fn vec_to_bytes<T>(vec: Vec<T>) -> Vec<u8> {
     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.
+/// Ensure PyBytes data is null-terminated. Returns (kept_alive_obj, pointer).
+/// The caller must keep the returned object alive to keep the pointer valid.
 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();
+    let mut buffer = data.to_vec();
+    if !buffer.ends_with(&[0]) {
         buffer.push(0);
-        let ptr = buffer.as_ptr() as usize;
-        let new_bytes: PyObjectRef = vm.ctx.new_bytes(buffer).into();
-        (new_bytes, ptr)
     }
+    let ptr = buffer.as_ptr() as usize;
+    let kept_alive: PyObjectRef = vm.ctx.new_bytes(buffer).into();
+    (kept_alive, 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) {
+pub(super) fn str_to_wchar_bytes(s: &Wtf8, vm: &VirtualMachine) -> (PyObjectRef, usize) {
     let wchars: Vec<libc::wchar_t> = s
-        .chars()
-        .map(|c| c as libc::wchar_t)
+        .code_points()
+        .map(|cp| cp.to_u32() as libc::wchar_t)
         .chain(core::iter::once(0))
         .collect();
     let ptr = wchars.as_ptr() as usize;
@@ -434,6 +466,11 @@ pub struct PyCData {
     pub objects: PyRwLock<Option<PyObjectRef>>,
     /// number of references we need (b_length)
     pub length: AtomicCell<usize>,
+    /// References kept alive but not visible in _objects.
+    /// Used for null-terminated c_char_p buffer copies, since
+    /// RustPython's PyBytes lacks CPython's internal trailing null.
+    /// Keyed by unique_key (hierarchical) so nested fields don't collide.
+    pub(super) kept_refs: PyRwLock<std::collections::HashMap<String, PyObjectRef>>,
 }
 
 impl PyCData {
@@ -446,6 +483,7 @@ impl PyCData {
             index: AtomicCell::new(0),
             objects: PyRwLock::new(None),
             length: AtomicCell::new(stg_info.length),
+            kept_refs: PyRwLock::new(std::collections::HashMap::new()),
         }
     }
 
@@ -458,6 +496,7 @@ impl PyCData {
             index: AtomicCell::new(0),
             objects: PyRwLock::new(objects),
             length: AtomicCell::new(0),
+            kept_refs: PyRwLock::new(std::collections::HashMap::new()),
         }
     }
 
@@ -474,6 +513,7 @@ impl PyCData {
             index: AtomicCell::new(0),
             objects: PyRwLock::new(objects),
             length: AtomicCell::new(length),
+            kept_refs: PyRwLock::new(std::collections::HashMap::new()),
         }
     }
 
@@ -494,6 +534,7 @@ impl PyCData {
             index: AtomicCell::new(0),
             objects: PyRwLock::new(None),
             length: AtomicCell::new(0),
+            kept_refs: PyRwLock::new(std::collections::HashMap::new()),
         }
     }
 
@@ -516,6 +557,7 @@ impl PyCData {
             index: AtomicCell::new(idx),
             objects: PyRwLock::new(None),
             length: AtomicCell::new(length),
+            kept_refs: PyRwLock::new(std::collections::HashMap::new()),
         }
     }
 
@@ -542,6 +584,7 @@ impl PyCData {
             index: AtomicCell::new(idx),
             objects: PyRwLock::new(None),
             length: AtomicCell::new(0),
+            kept_refs: PyRwLock::new(std::collections::HashMap::new()),
         }
     }
 
@@ -576,6 +619,7 @@ impl PyCData {
             index: AtomicCell::new(0),
             objects: PyRwLock::new(Some(objects_dict.into())),
             length: AtomicCell::new(length),
+            kept_refs: PyRwLock::new(std::collections::HashMap::new()),
         }
     }
 
@@ -797,6 +841,22 @@ impl PyCData {
         Ok(())
     }
 
+    /// Keep a reference alive without exposing it in _objects.
+    /// Walks up to root object (same as keep_ref) so the reference
+    /// lives as long as the owning ctypes object.
+    /// Uses unique_key (hierarchical) so nested fields don't collide.
+    pub fn keep_alive(&self, index: usize, obj: PyObjectRef) {
+        let key = self.unique_key(index);
+        if let Some(base_obj) = self.base.read().clone() {
+            let root = Self::find_root_object(&base_obj);
+            if let Some(cdata) = root.downcast_ref::<PyCData>() {
+                cdata.kept_refs.write().insert(key, obj);
+                return;
+            }
+        }
+        self.kept_refs.write().insert(key, obj);
+    }
+
     /// 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
@@ -907,9 +967,9 @@ impl PyCData {
             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) {
+                for cp in str_val.as_wtf8().code_points().take(size / WCHAR_SIZE) {
                     let mut bytes = [0u8; 4];
-                    wchar_to_bytes(ch as u32, &mut bytes);
+                    wchar_to_bytes(cp.to_u32(), &mut bytes);
                     wchar_bytes.extend_from_slice(&bytes[..WCHAR_SIZE]);
                 }
                 // Pad with nulls to fill the array
@@ -942,12 +1002,68 @@ impl PyCData {
             return Ok(());
         }
 
+        // For array fields with tuple/list input, instantiate the array type
+        // and unpack elements as positional args (Array_init expects *args)
+        if let Some(proto_type) = proto.downcast_ref::<PyType>()
+            && let Some(stg) = proto_type.stg_info_opt()
+            && stg.element_type.is_some()
+        {
+            let items: Option<Vec<PyObjectRef>> =
+                if let Some(tuple) = value.downcast_ref::<PyTuple>() {
+                    Some(tuple.to_vec())
+                } else {
+                    value
+                        .downcast_ref::<crate::builtins::PyList>()
+                        .map(|list| list.borrow_vec().to_vec())
+                };
+            if let Some(items) = items {
+                let array_obj = proto_type.as_object().call(items, vm).map_err(|e| {
+                    // Wrap errors in RuntimeError with type name prefix
+                    let type_name = proto_type.name().to_string();
+                    let exc_name = e.class().name().to_string();
+                    let exc_args = e.args();
+                    let exc_msg = exc_args
+                        .first()
+                        .and_then(|a| a.downcast_ref::<PyStr>().map(|s| s.to_string()))
+                        .unwrap_or_default();
+                    vm.new_runtime_error(format!("({type_name}) {exc_name}: {exc_msg}"))
+                })?;
+                if let Some(arr) = array_obj.downcast_ref::<super::array::PyCArray>() {
+                    let arr_buffer = arr.0.buffer.read();
+                    let len = core::cmp::min(arr_buffer.len(), size);
+                    self.write_bytes_at_offset(offset, &arr_buffer[..len]);
+                    drop(arr_buffer);
+                    self.keep_ref(index, array_obj, 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()));
 
+        // c_char_p (z type) with bytes: store original in _objects, keep
+        // null-terminated copy alive separately for the pointer.
+        if field_type_code.as_deref() == Some("z")
+            && let Some(bytes_val) = value.downcast_ref::<PyBytes>()
+        {
+            let (kept_alive, ptr) = ensure_z_null_terminated(bytes_val, vm);
+            let mut result = vec![0u8; size];
+            let addr_bytes = ptr.to_ne_bytes();
+            let len = core::cmp::min(addr_bytes.len(), size);
+            result[..len].copy_from_slice(&addr_bytes[..len]);
+            if needs_swap {
+                result.reverse();
+            }
+            self.write_bytes_at_offset(offset, &result);
+            self.keep_ref(index, value, vm)?;
+            self.keep_alive(index, kept_alive);
+            return Ok(());
+        }
+
         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 {
@@ -1111,7 +1227,7 @@ impl PyCData {
     // CDataType_methods - shared across all ctypes types
 
     #[pyclassmethod]
-    fn from_buffer(
+    pub(super) fn from_buffer(
         cls: PyTypeRef,
         source: PyObjectRef,
         offset: OptionalArg<isize>,
@@ -1122,7 +1238,7 @@ impl PyCData {
     }
 
     #[pyclassmethod]
-    fn from_buffer_copy(
+    pub(super) fn from_buffer_copy(
         cls: PyTypeRef,
         source: ArgBytesLike,
         offset: OptionalArg<isize>,
@@ -1134,7 +1250,7 @@ impl PyCData {
     }
 
     #[pyclassmethod]
-    fn from_address(cls: PyTypeRef, address: isize, vm: &VirtualMachine) -> PyResult {
+    pub(super) fn from_address(cls: PyTypeRef, address: isize, vm: &VirtualMachine) -> PyResult {
         let size = {
             let stg_info = cls.stg_info(vm)?;
             stg_info.size
@@ -1150,7 +1266,7 @@ impl PyCData {
     }
 
     #[pyclassmethod]
-    fn in_dll(
+    pub(super) fn in_dll(
         cls: PyTypeRef,
         dll: PyObjectRef,
         name: crate::builtins::PyStrRef,
@@ -1186,13 +1302,13 @@ impl PyCData {
             .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 symbol_name_with_nul = format!("{}\0", name.as_wtf8());
         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()))
+                        vm.new_value_error(format!("symbol '{}' not found", name.as_wtf8()))
                     })?
             }
         } else {
@@ -1202,7 +1318,7 @@ impl PyCData {
         // 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", name.as_str())));
+            return Err(vm.new_value_error(format!("symbol '{}' not found", name.as_wtf8())));
         }
 
         // PyCData_AtAddress
@@ -1217,78 +1333,84 @@ impl PyCData {
 #[pyclass(name = "CField", module = "_ctypes")]
 #[derive(Debug, PyPayload)]
 pub struct PyCField {
+    /// Field name
+    pub(crate) name: String,
     /// 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,
+    /// Byte size of the underlying type
+    pub(crate) byte_size_val: 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
+    /// Bitfield size in bits (0 for non-bitfield)
+    pub(crate) bitfield_size: u16,
+    /// Bit offset within the storage unit (only meaningful for bitfields)
+    pub(crate) bit_offset_val: u16,
 }
 
 impl PyCField {
     /// Create a new CField descriptor (non-bitfield)
-    pub fn new(proto: PyTypeRef, offset: isize, size: isize, index: usize) -> Self {
+    pub fn new(
+        name: String,
+        proto: PyTypeRef,
+        offset: isize,
+        byte_size: isize,
+        index: usize,
+    ) -> Self {
         Self {
+            name,
             offset,
-            size,
+            byte_size_val: byte_size,
             index,
             proto,
             anonymous: false,
+            bitfield_size: 0,
+            bit_offset_val: 0,
         }
     }
 
     /// Create a new CField descriptor for a bitfield
-    #[allow(dead_code)]
     pub fn new_bitfield(
+        name: String,
         proto: PyTypeRef,
         offset: isize,
-        bit_size: u16,
+        byte_size: isize,
+        bitfield_size: u16,
         bit_offset: u16,
         index: usize,
     ) -> Self {
-        let encoded_size = ((bit_size as isize) << 16) | (bit_offset as isize);
         Self {
+            name,
             offset,
-            size: encoded_size,
+            byte_size_val: byte_size,
             index,
             proto,
             anonymous: false,
+            bitfield_size,
+            bit_offset_val: bit_offset,
         }
     }
 
-    /// 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
+    /// Get the byte size of the field's underlying type
+    pub fn get_byte_size(&self) -> usize {
+        self.byte_size_val 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 {
+            name: fdescr.name.clone(),
             offset: fdescr.offset + offset_delta,
-            size: fdescr.size,
+            byte_size_val: fdescr.byte_size_val,
             index: fdescr.index + index_offset,
             proto: fdescr.proto.clone(),
             anonymous: false, // promoted fields are not anonymous themselves
+            bitfield_size: fdescr.bitfield_size,
+            bit_offset_val: fdescr.bit_offset_val,
         }
     }
 
@@ -1298,6 +1420,106 @@ impl PyCField {
     }
 }
 
+impl Constructor for PyCField {
+    type Args = crate::function::FuncArgs;
+
+    fn py_new(_cls: &Py<PyType>, args: Self::Args, vm: &VirtualMachine) -> PyResult<Self> {
+        // PyCField_new_impl: requires _internal_use=True
+        let internal_use = if let Some(v) = args.kwargs.get("_internal_use") {
+            v.clone().try_to_bool(vm)?
+        } else {
+            false
+        };
+
+        if !internal_use {
+            return Err(vm.new_type_error(
+                "CField is not intended to be used directly; use it via Structure or Union fields",
+            ));
+        }
+
+        let name: String = args
+            .kwargs
+            .get("name")
+            .ok_or_else(|| vm.new_type_error("missing required argument: 'name'"))?
+            .try_to_value(vm)?;
+
+        let field_type: PyTypeRef = args
+            .kwargs
+            .get("type")
+            .ok_or_else(|| vm.new_type_error("missing required argument: 'type'"))?
+            .clone()
+            .downcast()
+            .map_err(|_| vm.new_type_error("'type' must be a ctypes type"))?;
+
+        let byte_size: isize = args
+            .kwargs
+            .get("byte_size")
+            .ok_or_else(|| vm.new_type_error("missing required argument: 'byte_size'"))?
+            .try_to_value(vm)?;
+
+        let byte_offset: isize = args
+            .kwargs
+            .get("byte_offset")
+            .ok_or_else(|| vm.new_type_error("missing required argument: 'byte_offset'"))?
+            .try_to_value(vm)?;
+
+        let index: usize = args
+            .kwargs
+            .get("index")
+            .ok_or_else(|| vm.new_type_error("missing required argument: 'index'"))?
+            .try_to_value(vm)?;
+
+        // Validate byte_size matches the type
+        let type_size = super::base::get_field_size(field_type.as_object(), vm)? as isize;
+        if byte_size != type_size {
+            return Err(vm.new_value_error(format!(
+                "byte_size {} does not match type size {}",
+                byte_size, type_size
+            )));
+        }
+
+        let bit_size_val: Option<isize> = args
+            .kwargs
+            .get("bit_size")
+            .map(|v| v.try_to_value(vm))
+            .transpose()?;
+
+        let bit_offset_val: Option<isize> = args
+            .kwargs
+            .get("bit_offset")
+            .map(|v| v.try_to_value(vm))
+            .transpose()?;
+
+        if let Some(bs) = bit_size_val {
+            if bs < 0 {
+                return Err(vm.new_value_error("number of bits invalid for bit field"));
+            }
+            let bo = bit_offset_val.unwrap_or(0);
+            if bo < 0 {
+                return Err(vm.new_value_error("bit_offset must be >= 0"));
+            }
+            let type_bits = byte_size * 8;
+            if bo + bs > type_bits {
+                return Err(vm.new_value_error(format!(
+                    "bit field '{}' overflows its type ({} + {} > {})",
+                    name, bo, bs, type_bits
+                )));
+            }
+            Ok(Self::new_bitfield(
+                name,
+                field_type,
+                byte_offset,
+                byte_size,
+                bs as u16,
+                bo as u16,
+                index,
+            ))
+        } else {
+            Ok(Self::new(name, field_type, byte_offset, byte_size, index))
+        }
+    }
+}
+
 impl Representable for PyCField {
     fn repr_str(zelf: &Py<Self>, _vm: &VirtualMachine) -> PyResult<String> {
         // Get type name from proto (which is always PyTypeRef)
@@ -1305,17 +1527,15 @@ impl Representable for PyCField {
 
         // 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);
+        if zelf.bitfield_size > 0 {
             Ok(format!(
                 "<Field type={}, ofs={}:{}, bits={}>",
-                tp_name, zelf.offset, bit_offset, bits
+                tp_name, zelf.offset, zelf.bit_offset_val, zelf.bitfield_size
             ))
         } else {
             Ok(format!(
                 "<Field type={}, ofs={}, size={}>",
-                tp_name, zelf.offset, zelf.size
+                tp_name, zelf.offset, zelf.byte_size_val
             ))
         }
     }
@@ -1340,7 +1560,7 @@ impl GetDescriptor for PyCField {
         };
 
         let offset = zelf.offset as usize;
-        let size = zelf.byte_size();
+        let size = zelf.get_byte_size();
 
         // Get PyCData from obj (works for both Structure and Union)
         let cdata = PyCField::get_cdata_from_obj(&obj, vm)?;
@@ -1468,15 +1688,8 @@ impl PyCField {
                 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 = core::cmp::min(addr_bytes.len(), size);
-                    result[..len].copy_from_slice(&addr_bytes[..len]);
-                    return Ok((result, Some(converted)));
-                }
+                // c_char_p with bytes is handled in set_field before this call.
+                // This handles integer address and None cases.
                 // Integer address
                 if let Ok(int_val) = value.try_index(vm) {
                     let v = int_val.as_bigint().to_usize().unwrap_or(0);
@@ -1495,7 +1708,7 @@ impl PyCField {
             "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 (holder, ptr) = str_to_wchar_bytes(s.as_wtf8(), vm);
                     let mut result = vec![0u8; size];
                     let addr_bytes = ptr.to_ne_bytes();
                     let len = core::cmp::min(addr_bytes.len(), size);
@@ -1548,7 +1761,7 @@ impl PyCField {
             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";
+                return s.as_bytes() == b"c";
             }
         }
         false
@@ -1565,7 +1778,7 @@ impl PyCField {
             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";
+                return s.as_bytes() == b"u";
             }
         }
         false
@@ -1583,10 +1796,7 @@ impl PyCField {
     }
 }
 
-#[pyclass(
-    flags(DISALLOW_INSTANTIATION, IMMUTABLETYPE),
-    with(Representable, GetDescriptor)
-)]
+#[pyclass(flags(IMMUTABLETYPE), with(Representable, GetDescriptor, Constructor))]
 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> {
@@ -1615,7 +1825,7 @@ impl PyCField {
             .ok_or_else(|| vm.new_type_error("expected CField"))?;
 
         let offset = zelf.offset as usize;
-        let size = zelf.byte_size();
+        let size = zelf.get_byte_size();
 
         // Get PyCData from obj (works for both Structure and Union)
         let cdata = Self::get_cdata_from_obj(&obj, vm)?;
@@ -1650,14 +1860,65 @@ impl PyCField {
         }
     }
 
+    #[pygetset]
+    fn name(&self) -> String {
+        self.name.clone()
+    }
+
+    #[pygetset(name = "type")]
+    fn type_(&self) -> PyTypeRef {
+        self.proto.clone()
+    }
+
     #[pygetset]
     fn offset(&self) -> isize {
         self.offset
     }
 
+    #[pygetset]
+    fn byte_offset(&self) -> isize {
+        self.offset
+    }
+
     #[pygetset]
     fn size(&self) -> isize {
-        self.size
+        // Legacy: encode as (bitfield_size << 16) | bit_offset for bitfields
+        if self.bitfield_size > 0 {
+            ((self.bitfield_size as isize) << 16) | (self.bit_offset_val as isize)
+        } else {
+            self.byte_size_val
+        }
+    }
+
+    #[pygetset]
+    fn byte_size(&self) -> isize {
+        self.byte_size_val
+    }
+
+    #[pygetset]
+    fn bit_offset(&self) -> isize {
+        self.bit_offset_val as isize
+    }
+
+    #[pygetset]
+    fn bit_size(&self, vm: &VirtualMachine) -> PyObjectRef {
+        if self.bitfield_size > 0 {
+            vm.ctx.new_int(self.bitfield_size).into()
+        } else {
+            // Non-bitfield: bit_size = byte_size * 8
+            let byte_size = self.byte_size_val as i128;
+            vm.ctx.new_int(byte_size * 8).into()
+        }
+    }
+
+    #[pygetset]
+    fn is_bitfield(&self) -> bool {
+        self.bitfield_size > 0
+    }
+
+    #[pygetset]
+    fn is_anonymous(&self) -> bool {
+        self.anonymous
     }
 }
 
@@ -1836,71 +2097,53 @@ pub(super) fn buffer_to_ffi_value(type_code: &str, buffer: &[u8]) -> FfiArgValue
             FfiArgValue::U8(v)
         }
         "h" => {
-            let v = if buffer.len() >= 2 {
-                i16::from_ne_bytes(buffer[..2].try_into().unwrap())
-            } else {
-                0
-            };
+            let v = buffer.first_chunk().copied().map_or(0, i16::from_ne_bytes);
             FfiArgValue::I16(v)
         }
         "H" => {
-            let v = if buffer.len() >= 2 {
-                u16::from_ne_bytes(buffer[..2].try_into().unwrap())
-            } else {
-                0
-            };
+            let v = buffer.first_chunk().copied().map_or(0, u16::from_ne_bytes);
             FfiArgValue::U16(v)
         }
         "i" => {
-            let v = if buffer.len() >= 4 {
-                i32::from_ne_bytes(buffer[..4].try_into().unwrap())
-            } else {
-                0
-            };
+            let v = buffer.first_chunk().copied().map_or(0, i32::from_ne_bytes);
             FfiArgValue::I32(v)
         }
         "I" => {
-            let v = if buffer.len() >= 4 {
-                u32::from_ne_bytes(buffer[..4].try_into().unwrap())
-            } else {
-                0
-            };
+            let v = buffer.first_chunk().copied().map_or(0, u32::from_ne_bytes);
             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
+            let v = if let Some(&bytes) = buffer.first_chunk::<8>() {
+                i64::from_ne_bytes(bytes)
+            } else if let Some(&bytes) = buffer.first_chunk::<4>() {
+                i32::from_ne_bytes(bytes).into()
             } 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
+            let v = if let Some(&bytes) = buffer.first_chunk::<8>() {
+                u64::from_ne_bytes(bytes)
+            } else if let Some(&bytes) = buffer.first_chunk::<4>() {
+                u32::from_ne_bytes(bytes).into()
             } else {
                 0
             };
             FfiArgValue::U64(v)
         }
         "f" => {
-            let v = if buffer.len() >= 4 {
-                f32::from_ne_bytes(buffer[..4].try_into().unwrap())
-            } else {
-                0.0
-            };
+            let v = buffer
+                .first_chunk::<4>()
+                .copied()
+                .map_or(0.0, f32::from_ne_bytes);
             FfiArgValue::F32(v)
         }
         "d" | "g" => {
-            let v = if buffer.len() >= 8 {
-                f64::from_ne_bytes(buffer[..8].try_into().unwrap())
-            } else {
-                0.0
-            };
+            let v = buffer
+                .first_chunk::<8>()
+                .copied()
+                .map_or(0.0, f64::from_ne_bytes);
             FfiArgValue::F64(v)
         }
         "z" | "Z" | "P" | "O" => FfiArgValue::Pointer(read_ptr_from_buffer(buffer)),
@@ -1910,11 +2153,7 @@ pub(super) fn buffer_to_ffi_value(type_code: &str, buffer: &[u8]) -> FfiArgValue
         }
         "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
-            };
+            let v = buffer.first_chunk().copied().map_or(0, u32::from_ne_bytes);
             FfiArgValue::U32(v)
         }
         _ => FfiArgValue::Pointer(0),
@@ -2075,6 +2314,11 @@ pub(super) fn bytes_to_pyobject(
                 let len = unsafe { libc::wcslen(ptr as *const libc::wchar_t) };
                 let wchars =
                     unsafe { core::slice::from_raw_parts(ptr as *const libc::wchar_t, len) };
+                // wchar_t is i32 on some platforms and u32 on others
+                #[allow(
+                    clippy::unnecessary_cast,
+                    reason = "wchar_t is i32 on some platforms and u32 on others"
+                )]
                 let s: String = wchars
                     .iter()
                     .filter_map(|&c| char::from_u32(c as u32))
@@ -2135,11 +2379,10 @@ pub(super) fn get_usize_attr(
 #[inline]
 pub(super) fn read_ptr_from_buffer(buffer: &[u8]) -> 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 {
-        0
-    }
+    buffer
+        .first_chunk::<PTR_SIZE>()
+        .copied()
+        .map_or(0, usize::from_ne_bytes)
 }
 
 /// Check if a type is a "simple instance" (direct subclass of a simple type)
@@ -2157,7 +2400,12 @@ 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>()
     {
+        // Preserve pointer_type cache across StgInfo replacement
+        let old_pointer_type = existing.pointer_type.take();
         *existing = stg_info;
+        if existing.pointer_type.is_none() {
+            existing.pointer_type = old_pointer_type;
+        }
     }
 }
 
@@ -2262,9 +2510,6 @@ fn make_fields(
     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()
@@ -2286,7 +2531,7 @@ fn make_fields(
         let fname = field_tuple
             .first()
             .expect("len checked")
-            .downcast_ref::<PyStr>()
+            .downcast_ref::<PyUtf8Str>()
             .ok_or_else(|| vm.new_type_error("field name must be a string"))?;
 
         let fdescr_obj = descr
@@ -2309,7 +2554,10 @@ fn make_fields(
         }
 
         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));
+        cls.set_attr(
+            vm.ctx.intern_str(fname.as_wtf8()),
+            new_descr.to_pyobject(vm),
+        );
     }
 
     Ok(())
@@ -2317,9 +2565,6 @@ fn make_fields(
 
 /// 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(()),
@@ -2340,18 +2585,21 @@ pub(super) fn make_anon_fields(cls: &Py<PyType>, vm: &VirtualMachine) -> PyResul
 
         let descr_obj = cls
             .as_object()
-            .get_attr(vm.ctx.intern_str(fname.as_str()), vm)?;
+            .get_attr(vm.ctx.intern_str(fname.as_wtf8()), 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()
+                fname.as_wtf8()
             ))
         })?;
 
         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));
+        cls.set_attr(
+            vm.ctx.intern_str(fname.as_wtf8()),
+            new_descr.to_pyobject(vm),
+        );
 
         make_fields(cls, descr, descr.index, descr.offset, vm)?;
     }
diff --git a/crates/vm/src/stdlib/ctypes/function.rs b/crates/vm/src/stdlib/_ctypes/function.rs
similarity index 93%
rename from crates/vm/src/stdlib/ctypes/function.rs
rename to crates/vm/src/stdlib/_ctypes/function.rs
index 295e6fd137d..e28fd91abbc 100644
--- a/crates/vm/src/stdlib/ctypes/function.rs
+++ b/crates/vm/src/stdlib/_ctypes/function.rs
@@ -31,6 +31,7 @@ use rustpython_common::lock::PyRwLock;
 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;
+pub(super) const INTERNAL_MEMORYVIEW_AT_ADDR: usize = 4;
 
 // Thread-local errno storage for ctypes
 std::thread_local! {
@@ -231,7 +232,7 @@ fn convert_to_pointer(value: &PyObject, vm: &VirtualMachine) -> PyResult<FfiArgV
             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()));
+        return Err(vm.new_overflow_error("int too large to convert to pointer"));
     }
 
     // 8. Check _as_parameter_ attribute ( recursive ConvParam)
@@ -279,10 +280,10 @@ fn conv_param(value: &PyObject, vm: &VirtualMachine) -> PyResult<Argument> {
 
     // 4. Python str -> wide string pointer (like PyUnicode_AsWideCharString)
     if let Some(s) = value.downcast_ref::<PyStr>() {
-        // Convert to null-terminated UTF-16 (wide string)
+        // Convert to null-terminated UTF-16, preserving lone surrogates
         let wide: Vec<u16> = s
-            .as_str()
-            .encode_utf16()
+            .as_wtf8()
+            .encode_wide()
             .chain(core::iter::once(0))
             .collect();
         let wide_bytes: Vec<u8> = wide.iter().flat_map(|&x| x.to_ne_bytes()).collect();
@@ -447,7 +448,7 @@ impl ReturnType for PyTypeRef {
         // 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())
+            && let Some(ffi_type) = s.to_str().and_then(get_ffi_type)
         {
             return Some(ffi_type);
         }
@@ -512,7 +513,17 @@ impl Initializer for PyCFuncPtrType {
 }
 
 #[pyclass(flags(IMMUTABLETYPE), with(Initializer))]
-impl PyCFuncPtrType {}
+impl PyCFuncPtrType {
+    #[pygetset(name = "__pointer_type__")]
+    fn pointer_type(zelf: PyTypeRef, vm: &VirtualMachine) -> PyResult {
+        super::base::pointer_type_get(&zelf, vm)
+    }
+
+    #[pygetset(name = "__pointer_type__", setter)]
+    fn set_pointer_type(zelf: PyTypeRef, value: PyObjectRef, vm: &VirtualMachine) -> PyResult<()> {
+        super::base::pointer_type_set(&zelf, value, vm)
+    }
+}
 
 /// PyCFuncPtr - Function pointer instance
 /// Saved in _base.buffer
@@ -561,16 +572,24 @@ impl Debug for PyCFuncPtr {
 
 /// Extract pointer value from a ctypes argument (c_void_p conversion)
 fn extract_ptr_from_arg(arg: &PyObject, vm: &VirtualMachine) -> PyResult<usize> {
+    // Try CArgObject first - extract the wrapped pointer value, applying offset
+    if let Some(carg) = arg.downcast_ref::<super::_ctypes::CArgObject>() {
+        if carg.offset != 0
+            && let Some(cdata) = carg.obj.downcast_ref::<PyCData>()
+        {
+            let base = cdata.buffer.read().as_ptr() as isize;
+            return Ok((base + carg.offset) as usize);
+        }
+        return extract_ptr_from_arg(&carg.obj, vm);
+    }
     // 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() >= core::mem::size_of::<usize>() {
-            return Ok(usize::from_ne_bytes(
-                buffer[..core::mem::size_of::<usize>()].try_into().unwrap(),
-            ));
+        if let Some(&bytes) = buffer.first_chunk::<{ size_of::<usize>() }>() {
+            return Ok(usize::from_ne_bytes(bytes));
         }
     }
     if let Some(cdata) = arg.downcast_ref::<PyCData>() {
@@ -579,7 +598,7 @@ fn extract_ptr_from_arg(arg: &PyObject, vm: &VirtualMachine) -> PyResult<usize>
     }
     // PyStr: return internal buffer address
     if let Some(s) = arg.downcast_ref::<PyStr>() {
-        return Ok(s.as_str().as_ptr() as usize);
+        return Ok(s.as_bytes().as_ptr() as usize);
     }
     // PyBytes: return internal buffer address
     if let Some(bytes) = arg.downcast_ref::<PyBytes>() {
@@ -645,14 +664,80 @@ fn wstring_at_impl(ptr: usize, size: isize, vm: &VirtualMachine) -> PyResult {
     }
     #[cfg(not(windows))]
     {
+        #[allow(
+            clippy::useless_conversion,
+            reason = "wchar_t is i32 on some platforms and u32 on others"
+        )]
         let s: String = wchars
             .iter()
-            .filter_map(|&c| char::from_u32(c as u32))
+            .filter_map(|&c| u32::try_from(c).ok().and_then(char::from_u32))
             .collect();
         Ok(vm.ctx.new_str(s).into())
     }
 }
 
+/// A buffer wrapping raw memory at a given pointer, for zero-copy memoryview.
+#[pyclass(name = "_RawMemoryBuffer", module = "_ctypes")]
+#[derive(Debug, PyPayload)]
+pub(super) struct RawMemoryBuffer {
+    ptr: *const u8,
+    size: usize,
+    readonly: bool,
+}
+
+// SAFETY: The caller ensures the pointer remains valid
+unsafe impl Send for RawMemoryBuffer {}
+unsafe impl Sync for RawMemoryBuffer {}
+
+static RAW_MEMORY_BUFFER_METHODS: crate::protocol::BufferMethods = crate::protocol::BufferMethods {
+    obj_bytes: |buffer| {
+        let raw = buffer.obj_as::<RawMemoryBuffer>();
+        let slice = unsafe { core::slice::from_raw_parts(raw.ptr, raw.size) };
+        rustpython_common::borrow::BorrowedValue::Ref(slice)
+    },
+    obj_bytes_mut: |buffer| {
+        let raw = buffer.obj_as::<RawMemoryBuffer>();
+        let slice = unsafe { core::slice::from_raw_parts_mut(raw.ptr as *mut u8, raw.size) };
+        rustpython_common::borrow::BorrowedValueMut::RefMut(slice)
+    },
+    release: |_| {},
+    retain: |_| {},
+};
+
+#[pyclass(with(AsBuffer))]
+impl RawMemoryBuffer {}
+
+impl AsBuffer for RawMemoryBuffer {
+    fn as_buffer(zelf: &Py<Self>, _vm: &VirtualMachine) -> PyResult<PyBuffer> {
+        Ok(PyBuffer::new(
+            zelf.to_owned().into(),
+            BufferDescriptor::simple(zelf.size, zelf.readonly),
+            &RAW_MEMORY_BUFFER_METHODS,
+        ))
+    }
+}
+
+/// memoryview_at implementation - create a memoryview from memory at ptr
+fn memoryview_at_impl(ptr: usize, size: isize, readonly: bool, vm: &VirtualMachine) -> PyResult {
+    use crate::builtins::PyMemoryView;
+
+    if ptr == 0 {
+        return Err(vm.new_value_error("NULL pointer access"));
+    }
+    if size < 0 {
+        return Err(vm.new_value_error("negative size"));
+    }
+    let len = size as usize;
+    let raw_buf = RawMemoryBuffer {
+        ptr: ptr as *const u8,
+        size: len,
+        readonly,
+    }
+    .into_pyobject(vm);
+    let mv = PyMemoryView::from_object(&raw_buf, vm)?;
+    Ok(mv.into_pyobject(vm))
+}
+
 // cast_check_pointertype
 fn cast_check_pointertype(ctype: &PyObject, vm: &VirtualMachine) -> bool {
     use super::pointer::PyCPointerType;
@@ -668,7 +753,9 @@ fn cast_check_pointertype(ctype: &PyObject, vm: &VirtualMachine) -> bool {
     if let Ok(type_attr) = ctype.get_attr("_type_", vm)
         && let Some(s) = type_attr.downcast_ref::<PyStr>()
     {
-        let c = s.as_str();
+        let c = s
+            .to_str()
+            .expect("_type_ is validated as ASCII at type creation");
         if c.len() == 1 && "sPzUZXO".contains(c) {
             return true;
         }
@@ -705,7 +792,7 @@ pub(super) fn cast_impl(
         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
+        s.as_bytes().as_ptr() as usize
     } else if let Some(ptr) = obj.downcast_ref::<PyCPointer>() {
         // Pointer instance → contained pointer value
         ptr.get_ptr_value()
@@ -1062,6 +1149,25 @@ fn handle_internal_func(addr: usize, args: &FuncArgs, vm: &VirtualMachine) -> Op
         }));
     }
 
+    if addr == INTERNAL_MEMORYVIEW_AT_ADDR {
+        let result: PyResult<(PyObjectRef, PyObjectRef, Option<PyObjectRef>)> =
+            args.clone().bind(vm);
+        return Some(result.and_then(|(ptr_arg, size_arg, readonly_arg)| {
+            let ptr = extract_ptr_from_arg(&ptr_arg, vm)?;
+            let size_int = size_arg.try_int(vm)?;
+            let size = size_int
+                .as_bigint()
+                .to_isize()
+                .ok_or_else(|| vm.new_value_error("size too large"))?;
+            let readonly = readonly_arg
+                .and_then(|r| r.try_int(vm).ok())
+                .and_then(|i| i.as_bigint().to_i32())
+                .unwrap_or(0)
+                != 0;
+            memoryview_at_impl(ptr, size, readonly, vm)
+        }));
+    }
+
     None
 }
 
@@ -1202,16 +1308,14 @@ fn resolve_com_method(
 
     // 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())
-        );
+        return Err(vm.new_type_error("COM method requires at least one argument (self)"));
     }
 
     // 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>() {
+        if buffer.len() >= core::mem::size_of::<usize>() {
             super::base::read_ptr_from_buffer(&buffer)
         } else {
             0
@@ -1219,9 +1323,7 @@ fn resolve_com_method(
     } 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())
-        );
+        return Err(vm.new_type_error("COM method first argument must be a COM pointer"));
     };
 
     if com_ptr == 0 {
@@ -1361,9 +1463,8 @@ fn build_callargs_with_paramflags(
         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())
-            })?;
+            let addr = get_buffer_addr(&buffer)
+                .ok_or_else(|| vm.new_type_error("Cannot create OUT buffer for this type"))?;
             arguments.push(Argument {
                 ffi_type,
                 keep: None,
@@ -1938,9 +2039,13 @@ fn ffi_to_python(ty: &Py<PyType>, ptr: *const c_void, vm: &VirtualMachine) -> Py
                     }
                     #[cfg(not(windows))]
                     {
+                        #[allow(
+                            clippy::useless_conversion,
+                            reason = "wchar_t is i32 on some platforms and u32 on others"
+                        )]
                         let s: String = slice
                             .iter()
-                            .filter_map(|&c| char::from_u32(c as u32))
+                            .filter_map(|&c| u32::try_from(c).ok().and_then(char::from_u32))
                             .collect();
                         vm.ctx.new_str(s).into()
                     }
@@ -2085,7 +2190,7 @@ unsafe extern "C" fn thunk_callback(
                 .map(|s| s.to_string())
                 .unwrap_or_else(|_| "<unknown>".to_string());
             let msg = format!(
-                "Exception ignored on calling ctypes callback function {}",
+                "Exception ignored while calling ctypes callback function {}",
                 repr
             );
             vm.run_unraisable(exc.clone(), Some(msg), vm.ctx.none());
diff --git a/crates/vm/src/stdlib/ctypes/library.rs b/crates/vm/src/stdlib/_ctypes/library.rs
similarity index 100%
rename from crates/vm/src/stdlib/ctypes/library.rs
rename to crates/vm/src/stdlib/_ctypes/library.rs
diff --git a/crates/vm/src/stdlib/ctypes/pointer.rs b/crates/vm/src/stdlib/_ctypes/pointer.rs
similarity index 93%
rename from crates/vm/src/stdlib/ctypes/pointer.rs
rename to crates/vm/src/stdlib/_ctypes/pointer.rs
index 875d78a0010..503af1f1d56 100644
--- a/crates/vm/src/stdlib/ctypes/pointer.rs
+++ b/crates/vm/src/stdlib/_ctypes/pointer.rs
@@ -27,16 +27,24 @@ impl Initializer for PyCPointerType {
             .downcast()
             .map_err(|_| vm.new_type_error("expected type"))?;
 
-        new_type.check_not_initialized(vm)?;
+        if new_type.is_initialized() {
+            return Ok(());
+        }
 
         // 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());
 
+        // Validate that _type_ has storage info (is a ctypes type)
+        if let Some(ref proto_type) = proto
+            && proto_type.stg_info_opt().is_none()
+        {
+            return Err(vm.new_type_error(format!("{} must have storage info", proto_type.name())));
+        }
+
         // Initialize StgInfo for pointer type
         let pointer_size = core::mem::size_of::<usize>();
         let mut stg_info = StgInfo::new(pointer_size, pointer_size);
@@ -62,12 +70,31 @@ impl Initializer for PyCPointerType {
 
         let _ = new_type.init_type_data(stg_info);
 
+        // Cache: set target_type.__pointer_type__ = self (via StgInfo, not as inheritable attr)
+        if let Ok(type_attr) = new_type.as_object().get_attr("_type_", vm)
+            && let Ok(target_type) = type_attr.downcast::<PyType>()
+            && let Some(mut target_info) = target_type.get_type_data_mut::<StgInfo>()
+        {
+            let zelf_obj: PyObjectRef = zelf.into();
+            target_info.pointer_type = Some(zelf_obj);
+        }
+
         Ok(())
     }
 }
 
-#[pyclass(flags(IMMUTABLETYPE), with(AsNumber, Initializer))]
+#[pyclass(flags(BASETYPE, IMMUTABLETYPE), with(AsNumber, Initializer))]
 impl PyCPointerType {
+    #[pygetset(name = "__pointer_type__")]
+    fn pointer_type(zelf: PyTypeRef, vm: &VirtualMachine) -> PyResult {
+        super::base::pointer_type_get(&zelf, vm)
+    }
+
+    #[pygetset(name = "__pointer_type__", setter)]
+    fn set_pointer_type(zelf: PyTypeRef, value: PyObjectRef, vm: &VirtualMachine) -> PyResult<()> {
+        super::base::pointer_type_set(&zelf, value, vm)
+    }
+
     #[pymethod]
     fn from_param(zelf: PyObjectRef, value: PyObjectRef, vm: &VirtualMachine) -> PyResult {
         // zelf is the pointer type class that from_param was called on
@@ -182,7 +209,12 @@ impl PyCPointerType {
         }
 
         // 4. Set _type_ attribute on the pointer type
-        zelf.as_object().set_attr("_type_", typ_type, vm)?;
+        zelf.as_object().set_attr("_type_", typ_type.clone(), vm)?;
+
+        // 5. Cache: set target_type.__pointer_type__ = self (via StgInfo)
+        if let Some(mut target_info) = typ_type.get_type_data_mut::<StgInfo>() {
+            target_info.pointer_type = Some(zelf.into());
+        }
 
         Ok(())
     }
@@ -508,6 +540,10 @@ impl PyCPointer {
             for _ in 0..len {
                 let addr = (ptr_value as isize + cur * wchar_size as isize) as *const libc::wchar_t;
                 unsafe {
+                    #[allow(
+                        clippy::unnecessary_cast,
+                        reason = "wchar_t is i32 on some platforms and u32 on others"
+                    )]
                     if let Some(c) = char::from_u32(*addr as u32) {
                         result.push(c);
                     }
@@ -594,15 +630,16 @@ impl PyCPointer {
             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);
+                let (kept_alive, 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);
+                zelf.0.keep_alive(index as usize, kept_alive);
+                return zelf.0.keep_ref(index as usize, value.clone(), 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);
+                let (holder, ptr_val) = super::base::str_to_wchar_bytes(s.as_wtf8(), vm);
                 unsafe {
                     *(addr as *mut usize) = ptr_val;
                 }
@@ -696,9 +733,7 @@ impl PyCPointer {
                     } 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(),
-                        ));
+                        return Err(vm.new_type_error("bytes/string or integer address expected"));
                     };
                     core::ptr::write_unaligned(ptr as *mut usize, ptr_val);
                     return Ok(());
@@ -786,7 +821,7 @@ impl AsNumber for PyCPointer {
 
 impl AsMapping for PyCPointer {
     fn as_mapping() -> &'static PyMappingMethods {
-        use std::sync::LazyLock;
+        use crate::common::lock::LazyLock;
         static AS_MAPPING: LazyLock<PyMappingMethods> = LazyLock::new(|| PyMappingMethods {
             subscript: atomic_func!(|mapping, needle, vm| {
                 let zelf = PyCPointer::mapping_downcast(mapping);
diff --git a/crates/vm/src/stdlib/ctypes/simple.rs b/crates/vm/src/stdlib/_ctypes/simple.rs
similarity index 92%
rename from crates/vm/src/stdlib/ctypes/simple.rs
rename to crates/vm/src/stdlib/_ctypes/simple.rs
index b2ae0f7cc5b..3258d67d76f 100644
--- a/crates/vm/src/stdlib/ctypes/simple.rs
+++ b/crates/vm/src/stdlib/_ctypes/simple.rs
@@ -18,8 +18,12 @@ use core::fmt::Debug;
 use num_traits::ToPrimitive;
 
 /// Valid type codes for ctypes simple types
+#[cfg(windows)]
 // spell-checker: disable-next-line
 pub(super) const SIMPLE_TYPE_CHARS: &str = "cbBhHiIlLdfuzZqQPXOv?g";
+#[cfg(not(windows))]
+// spell-checker: disable-next-line
+pub(super) const SIMPLE_TYPE_CHARS: &str = "cbBhHiIlLdfuzZqQPOv?g";
 
 /// Convert ctypes type code to PEP 3118 format code.
 /// Some ctypes codes need to be mapped to standard-size codes based on platform.
@@ -113,8 +117,8 @@ fn set_primitive(_type_: &str, value: &PyObject, vm: &VirtualMachine) -> PyResul
             }
         }
         "u" => {
-            if let Ok(b) = value.str(vm).map(|v| v.to_string().chars().count() == 1) {
-                if b {
+            if let Some(s) = value.downcast_ref::<PyStr>() {
+                if s.as_wtf8().code_points().count() == 1 {
                     Ok(value.to_owned())
                 } else {
                     Err(vm.new_type_error("one character unicode string expected"))
@@ -235,6 +239,16 @@ pub struct PyCSimpleType(PyType);
 
 #[pyclass(flags(BASETYPE), with(AsNumber, Initializer))]
 impl PyCSimpleType {
+    #[pygetset(name = "__pointer_type__")]
+    fn pointer_type(zelf: PyTypeRef, vm: &VirtualMachine) -> PyResult {
+        super::base::pointer_type_get(&zelf, vm)
+    }
+
+    #[pygetset(name = "__pointer_type__", setter)]
+    fn set_pointer_type(zelf: PyTypeRef, value: PyObjectRef, vm: &VirtualMachine) -> PyResult<()> {
+        super::base::pointer_type_set(&zelf, value, vm)
+    }
+
     #[allow(clippy::new_ret_no_self)]
     #[pymethod]
     fn new(cls: PyTypeRef, _: OptionalArg, vm: &VirtualMachine) -> PyResult {
@@ -310,14 +324,12 @@ impl PyCSimpleType {
                 {
                     return create_simple_with_value("c", &value);
                 }
-                return Err(vm.new_type_error(
-                    "one character bytes, bytearray or integer expected".to_string(),
-                ));
+                return Err(vm.new_type_error("one character bytes, bytearray or integer expected"));
             }
             // c_wchar: 1 unicode character
             Some("u") => {
                 if let Some(s) = value.downcast_ref::<PyStr>()
-                    && s.as_str().chars().count() == 1
+                    && s.as_wtf8().code_points().count() == 1
                 {
                     return create_simple_with_value("u", &value);
                 }
@@ -327,10 +339,10 @@ impl PyCSimpleType {
             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);
+                    let (kept_alive, ptr) = super::base::ensure_z_null_terminated(bytes, vm);
                     return Ok(CArgObject {
                         tag: b'z',
-                        value: FfiArgValue::OwnedPointer(ptr, holder),
+                        value: FfiArgValue::OwnedPointer(ptr, kept_alive),
                         obj: value.clone(),
                         size: 0,
                         offset: 0,
@@ -352,7 +364,7 @@ impl PyCSimpleType {
             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);
+                    let (holder, ptr) = super::base::str_to_wchar_bytes(s.as_wtf8(), vm);
                     return Ok(CArgObject {
                         tag: b'Z',
                         value: FfiArgValue::OwnedPointer(ptr, holder),
@@ -381,10 +393,10 @@ impl PyCSimpleType {
                 }
                 // 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);
+                    let (kept_alive, ptr) = super::base::ensure_z_null_terminated(bytes, vm);
                     return Ok(CArgObject {
                         tag: b'z',
-                        value: FfiArgValue::OwnedPointer(ptr, holder),
+                        value: FfiArgValue::OwnedPointer(ptr, kept_alive),
                         obj: value.clone(),
                         size: 0,
                         offset: 0,
@@ -393,7 +405,7 @@ impl PyCSimpleType {
                 }
                 // 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);
+                    let (holder, ptr) = super::base::str_to_wchar_bytes(s.as_wtf8(), vm);
                     return Ok(CArgObject {
                         tag: b'Z',
                         value: FfiArgValue::OwnedPointer(ptr, holder),
@@ -419,13 +431,10 @@ impl PyCSimpleType {
                 if let Some(funcptr) = value.downcast_ref::<PyCFuncPtr>() {
                     let ptr_val = {
                         let buffer = funcptr._base.buffer.read();
-                        if buffer.len() >= core::mem::size_of::<usize>() {
-                            usize::from_ne_bytes(
-                                buffer[..core::mem::size_of::<usize>()].try_into().unwrap(),
-                            )
-                        } else {
-                            0
-                        }
+                        buffer
+                            .first_chunk::<{ size_of::<usize>() }>()
+                            .copied()
+                            .map_or(0, usize::from_ne_bytes)
                     };
                     return Ok(CArgObject {
                         tag: b'P',
@@ -442,13 +451,10 @@ 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() >= core::mem::size_of::<usize>() {
-                                usize::from_ne_bytes(
-                                    buffer[..core::mem::size_of::<usize>()].try_into().unwrap(),
-                                )
-                            } else {
-                                0
-                            }
+                            buffer
+                                .first_chunk::<{ size_of::<usize>() }>()
+                                .copied()
+                                .map_or(0, usize::from_ne_bytes)
                         };
                         return Ok(CArgObject {
                             tag: b'Z',
@@ -551,8 +557,7 @@ impl Initializer for PyCSimpleType {
         // 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(),
+                "class must define a '_type_' attribute which must be a string of length 1",
             ));
         }
 
@@ -767,15 +772,16 @@ fn value_to_bytes_endian(
         }
         "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();
+            if let Some(s) = value.downcast_ref::<PyStr>() {
+                let mut cps = s.as_wtf8().code_points();
+                if let (Some(c), None) = (cps.next(), cps.next()) {
+                    let mut buffer = vec![0u8; WCHAR_SIZE];
+                    wchar_to_bytes(c.to_u32(), &mut buffer);
+                    if swapped {
+                        buffer.reverse();
+                    }
+                    return buffer;
                 }
-                return buffer;
             }
             vec![0; WCHAR_SIZE]
         }
@@ -1033,15 +1039,16 @@ impl Constructor for PyCSimple {
         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 (kept_alive, 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));
+                    let cdata = PyCData::from_bytes(buffer, Some(v.clone()));
+                    *cdata.base.write() = Some(kept_alive);
                     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 (holder, ptr) = super::base::str_to_wchar_bytes(s.as_wtf8(), 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);
@@ -1185,9 +1192,13 @@ impl PyCSimple {
                 }
                 #[cfg(not(windows))]
                 {
+                    #[allow(
+                        clippy::useless_conversion,
+                        reason = "wchar_t is i32 on some platforms and u32 on others"
+                    )]
                     let s: String = wchars
                         .iter()
-                        .filter_map(|&c| char::from_u32(c as u32))
+                        .filter_map(|&c| u32::try_from(c).ok().and_then(char::from_u32))
                         .collect();
                     return Ok(vm.ctx.new_str(s).into());
                 }
@@ -1260,15 +1271,16 @@ impl PyCSimple {
         // 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);
+                let (kept_alive, ptr) = super::base::ensure_z_null_terminated(bytes, vm);
                 *zelf.0.buffer.write() = alloc::borrow::Cow::Owned(ptr.to_ne_bytes().to_vec());
-                *zelf.0.objects.write() = Some(converted);
+                *zelf.0.objects.write() = Some(value);
+                *zelf.0.base.write() = Some(kept_alive);
                 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);
+            let (holder, ptr) = super::base::str_to_wchar_bytes(s.as_wtf8(), vm);
             *zelf.0.buffer.write() = alloc::borrow::Cow::Owned(ptr.to_ne_bytes().to_vec());
             *zelf.0.objects.write() = Some(holder);
             return Ok(());
@@ -1360,68 +1372,47 @@ impl PyCSimple {
         let buffer = self.0.buffer.read();
         let bytes: &[u8] = &buffer;
 
-        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]));
-            }
+        let ret = if core::ptr::eq(ty.as_raw_ptr(), libffi::middle::Type::u8().as_raw_ptr()) {
+            let byte = *bytes.first()?;
+            FfiArgValue::U8(byte)
         } 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));
-            }
+            let byte = *bytes.first()?;
+            FfiArgValue::I8(byte as i8)
         } 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]])));
-            }
+            let bytes = *bytes.first_chunk::<2>()?;
+            FfiArgValue::U16(u16::from_ne_bytes(bytes))
         } 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]])));
-            }
+            let bytes = *bytes.first_chunk::<2>()?;
+            FfiArgValue::I16(i16::from_ne_bytes(bytes))
         } 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],
-                ])));
-            }
+            let bytes = *bytes.first_chunk::<4>()?;
+            FfiArgValue::U32(u32::from_ne_bytes(bytes))
         } 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],
-                ])));
-            }
+            let bytes = *bytes.first_chunk::<4>()?;
+            FfiArgValue::I32(i32::from_ne_bytes(bytes))
         } 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],
-                ])));
-            }
+            let bytes = *bytes.first_chunk::<8>()?;
+            FfiArgValue::U64(u64::from_ne_bytes(bytes))
         } 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],
-                ])));
-            }
+            let bytes = *bytes.first_chunk::<8>()?;
+            FfiArgValue::I64(i64::from_ne_bytes(bytes))
         } 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],
-                ])));
-            }
+            let bytes = *bytes.first_chunk::<4>()?;
+            FfiArgValue::F32(f32::from_ne_bytes(bytes))
         } 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],
-                ])));
-            }
+            let bytes = *bytes.first_chunk::<8>()?;
+            FfiArgValue::F64(f64::from_ne_bytes(bytes))
         } else if core::ptr::eq(
             ty.as_raw_ptr(),
             libffi::middle::Type::pointer().as_raw_ptr(),
-        ) && bytes.len() >= core::mem::size_of::<usize>()
-        {
-            let val =
-                usize::from_ne_bytes(bytes[..core::mem::size_of::<usize>()].try_into().unwrap());
-            return Some(FfiArgValue::Pointer(val));
-        }
-        None
+        ) {
+            let bytes = *buffer.first_chunk::<{ size_of::<usize>() }>()?;
+            let val = usize::from_ne_bytes(bytes);
+            FfiArgValue::Pointer(val)
+        } else {
+            return None;
+        };
+        Some(ret)
     }
 }
 
diff --git a/crates/vm/src/stdlib/ctypes/structure.rs b/crates/vm/src/stdlib/_ctypes/structure.rs
similarity index 77%
rename from crates/vm/src/stdlib/ctypes/structure.rs
rename to crates/vm/src/stdlib/_ctypes/structure.rs
index cd36ce85560..c9ab9205601 100644
--- a/crates/vm/src/stdlib/ctypes/structure.rs
+++ b/crates/vm/src/stdlib/_ctypes/structure.rs
@@ -1,9 +1,9 @@
 use super::base::{CDATA_BUFFER_METHODS, PyCData, PyCField, StgInfo, StgInfoFlags};
-use crate::builtins::{PyList, PyStr, PyTuple, PyType, PyTypeRef};
+use crate::builtins::{PyList, PyStr, PyTuple, PyType, PyTypeRef, PyUtf8Str};
 use crate::convert::ToPyObject;
-use crate::function::FuncArgs;
-use crate::function::PySetterValue;
+use crate::function::{FuncArgs, OptionalArg, PySetterValue};
 use crate::protocol::{BufferDescriptor, PyBuffer, PyNumberMethods};
+use crate::stdlib::_warnings;
 use crate::types::{AsBuffer, AsNumber, Constructor, Initializer, SetAttr};
 use crate::{AsObject, Py, PyObjectRef, PyPayload, PyResult, VirtualMachine};
 use alloc::borrow::Cow;
@@ -103,6 +103,7 @@ impl Initializer for PyCStructType {
                     let mut stg_info = baseinfo.clone();
                     stg_info.flags &= !StgInfoFlags::DICTFLAG_FINAL; // Clear FINAL in subclass
                     stg_info.initialized = true;
+                    stg_info.pointer_type = None; // Non-inheritable
                     stg_info
                 });
 
@@ -130,6 +131,16 @@ impl Initializer for PyCStructType {
 
 #[pyclass(flags(BASETYPE), with(AsNumber, Constructor, Initializer, SetAttr))]
 impl PyCStructType {
+    #[pygetset(name = "__pointer_type__")]
+    fn pointer_type(zelf: PyTypeRef, vm: &VirtualMachine) -> PyResult {
+        super::base::pointer_type_get(&zelf, vm)
+    }
+
+    #[pygetset(name = "__pointer_type__", setter)]
+    fn set_pointer_type(zelf: PyTypeRef, value: PyObjectRef, vm: &VirtualMachine) -> PyResult<()> {
+        super::base::pointer_type_set(&zelf, value, vm)
+    }
+
     #[pymethod]
     fn from_param(zelf: PyObjectRef, value: PyObjectRef, vm: &VirtualMachine) -> PyResult {
         // zelf is the structure type class that from_param was called on
@@ -154,6 +165,55 @@ impl PyCStructType {
         )))
     }
 
+    // CDataType methods - delegated to PyCData implementations
+
+    #[pymethod]
+    fn from_address(zelf: PyObjectRef, address: isize, vm: &VirtualMachine) -> PyResult {
+        let cls: PyTypeRef = zelf
+            .downcast()
+            .map_err(|_| vm.new_type_error("expected a type"))?;
+        PyCData::from_address(cls, address, vm)
+    }
+
+    #[pymethod]
+    fn from_buffer(
+        zelf: PyObjectRef,
+        source: PyObjectRef,
+        offset: OptionalArg<isize>,
+        vm: &VirtualMachine,
+    ) -> PyResult {
+        let cls: PyTypeRef = zelf
+            .downcast()
+            .map_err(|_| vm.new_type_error("expected a type"))?;
+        PyCData::from_buffer(cls, source, offset, vm)
+    }
+
+    #[pymethod]
+    fn from_buffer_copy(
+        zelf: PyObjectRef,
+        source: crate::function::ArgBytesLike,
+        offset: OptionalArg<isize>,
+        vm: &VirtualMachine,
+    ) -> PyResult {
+        let cls: PyTypeRef = zelf
+            .downcast()
+            .map_err(|_| vm.new_type_error("expected a type"))?;
+        PyCData::from_buffer_copy(cls, source, offset, vm)
+    }
+
+    #[pymethod]
+    fn in_dll(
+        zelf: PyObjectRef,
+        dll: PyObjectRef,
+        name: crate::builtins::PyStrRef,
+        vm: &VirtualMachine,
+    ) -> PyResult {
+        let cls: PyTypeRef = zelf
+            .downcast()
+            .map_err(|_| vm.new_type_error("expected a type"))?;
+        PyCData::in_dll(cls, dll, name, vm)
+    }
+
     /// Called when a new Structure subclass is created
     #[pyclassmethod]
     fn __init_subclass__(cls: PyTypeRef, vm: &VirtualMachine) -> PyResult<()> {
@@ -185,6 +245,24 @@ impl PyCStructType {
         };
 
         let pack = super::base::get_usize_attr(cls.as_object(), "_pack_", 0, vm)?;
+
+        // Emit DeprecationWarning on non-Windows when _pack_ is set without _layout_
+        if pack > 0 && !cfg!(windows) {
+            let has_layout = cls.as_object().get_attr("_layout_", vm).is_ok();
+            if !has_layout {
+                let base_type_name = "Structure";
+                let msg = format!(
+                    "Due to '_pack_', the '{}' {} will use memory layout compatible with \
+                     MSVC (Windows). If this is intended, set _layout_ to 'ms'. \
+                     The implicit default is deprecated and slated to become an error in \
+                     Python 3.19.",
+                    cls.name(),
+                    base_type_name,
+                );
+                _warnings::warn(vm.ctx.exceptions.deprecation_warning, msg, 1, vm)?;
+            }
+        }
+
         let forced_alignment =
             super::base::get_usize_attr(cls.as_object(), "_align_", 1, vm)?.max(1);
 
@@ -221,23 +299,29 @@ impl PyCStructType {
         let mut format = String::from("T{");
         let mut last_end = 0usize; // Track end of last field for padding calculation
 
+        // Bitfield layout tracking
+        let mut bitfield_bit_offset: u16 = 0; // Current bit position within bitfield group
+        let mut last_field_bit_size: u16 = 0; // For MSVC: bit size of previous storage unit
+        let use_msvc_bitfields = pack > 0; // MSVC layout when _pack_ is set
+
         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"))?;
 
             if field_tuple.len() < 2 {
-                return Err(vm.new_type_error(
-                    "_fields_ tuple must have at least 2 elements (name, type)".to_string(),
-                ));
+                return Err(
+                    vm.new_type_error("_fields_ tuple must have at least 2 elements (name, type)")
+                );
             }
 
             let name = field_tuple
                 .first()
                 .expect("len checked")
-                .downcast_ref::<PyStr>()
+                .downcast_ref::<PyUtf8Str>()
                 .ok_or_else(|| vm.new_type_error("field name must be a string"))?
-                .to_string();
+                .as_str()
+                .to_owned();
 
             let field_type = field_tuple.get(1).expect("len checked").clone();
 
@@ -336,14 +420,91 @@ impl PyCStructType {
                 .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);
+
+            // Check for bitfield size (optional 3rd element in tuple)
+            let (c_field, field_advances_offset) = if field_tuple.len() > 2 {
+                let bit_size_obj = field_tuple.get(2).expect("len checked");
+                let bit_size = bit_size_obj
+                    .try_int(vm)?
+                    .as_bigint()
+                    .to_u16()
+                    .ok_or_else(|| vm.new_value_error("number of bits invalid for bit field"))?;
+                has_bitfield = true;
+
+                let type_bits = (size * 8) as u16;
+                let (advances, bit_offset);
+
+                if use_msvc_bitfields {
+                    // MSVC layout: different types start new storage unit
+                    if bitfield_bit_offset + bit_size > type_bits
+                        || type_bits != last_field_bit_size
+                    {
+                        // Close previous bitfield, start new allocation unit
+                        bitfield_bit_offset = 0;
+                        advances = true;
+                    } else {
+                        advances = false;
+                    }
+                    bit_offset = bitfield_bit_offset;
+                    bitfield_bit_offset += bit_size;
+                    last_field_bit_size = type_bits;
+                } else {
+                    // GCC System V layout: pack within same type
+                    let fits_in_current = bitfield_bit_offset + bit_size <= type_bits;
+                    advances = if fits_in_current && bitfield_bit_offset > 0 {
+                        false
+                    } else if !fits_in_current {
+                        bitfield_bit_offset = 0;
+                        true
+                    } else {
+                        true
+                    };
+                    bit_offset = bitfield_bit_offset;
+                    bitfield_bit_offset += bit_size;
+                }
+
+                // For packed bitfields that share offset, use the same offset as previous
+                let field_offset = if !advances {
+                    offset - size // Reuse the previous field's offset
+                } else {
+                    offset
+                };
+
+                (
+                    PyCField::new_bitfield(
+                        name.clone(),
+                        field_type_ref,
+                        field_offset as isize,
+                        size as isize,
+                        bit_size,
+                        bit_offset,
+                        index,
+                    ),
+                    advances,
+                )
+            } else {
+                bitfield_bit_offset = 0; // Reset on non-bitfield
+                last_field_bit_size = 0;
+                (
+                    PyCField::new(
+                        name.clone(),
+                        field_type_ref,
+                        offset as isize,
+                        size as isize,
+                        index,
+                    ),
+                    true,
+                )
+            };
 
             // Set the CField as a class attribute
             cls.set_attr(vm.ctx.intern_str(name.clone()), c_field.to_pyobject(vm));
 
-            // Update tracking
-            last_end = offset + size;
-            offset += size;
+            // Update tracking - don't advance offset for packed bitfields
+            if field_advances_offset {
+                last_end = offset + size;
+                offset += size;
+            }
         }
 
         // Calculate total_align = max(max_align, forced_alignment)
@@ -366,6 +527,14 @@ impl PyCStructType {
         }
         format.push('}');
 
+        // Check for circular self-reference: if a field of the same type as this
+        // structure was encountered, it would have marked this type's stginfo as FINAL.
+        if let Some(stg_info) = cls.get_type_data::<StgInfo>()
+            && stg_info.is_final()
+        {
+            return Err(vm.new_attribute_error("Structure or union cannot contain itself"));
+        }
+
         // Store StgInfo with aligned size and total alignment
         let mut stg_info = StgInfo::new(aligned_size, total_align);
         stg_info.length = fields.len();
@@ -432,7 +601,7 @@ impl SetAttr for PyCStructType {
         vm: &VirtualMachine,
     ) -> PyResult<()> {
         // Check if _fields_ is being set
-        if attr_name.as_str() == "_fields_" {
+        if attr_name.as_bytes() == b"_fields_" {
             let pytype: &Py<PyType> = zelf.to_base();
 
             // Check finalization in separate scope to release read lock before process_fields
@@ -462,7 +631,7 @@ impl SetAttr for PyCStructType {
             return Ok(());
         }
         // Delegate to PyType's setattro logic for type attributes
-        let attr_name_interned = vm.ctx.intern_str(attr_name.as_str());
+        let attr_name_interned = vm.ctx.intern_str(attr_name.as_wtf8());
         let pytype: &Py<PyType> = zelf.to_base();
 
         // Check for data descriptor first
@@ -482,7 +651,7 @@ impl SetAttr for PyCStructType {
                 return Err(vm.new_attribute_error(format!(
                     "type object '{}' has no attribute '{}'",
                     pytype.name(),
-                    attr_name.as_str(),
+                    attr_name.as_wtf8(),
                 )));
             }
         }
@@ -575,7 +744,7 @@ impl PyCStructure {
                 }
                 if let Some(tuple) = field.downcast_ref::<PyTuple>()
                     && let Some(name) = tuple.first()
-                    && let Some(name_str) = name.downcast_ref::<PyStr>()
+                    && let Some(name_str) = name.downcast_ref::<PyUtf8Str>()
                 {
                     let field_name = name_str.as_str().to_owned();
                     // Check for duplicate in kwargs
diff --git a/crates/vm/src/stdlib/ctypes/union.rs b/crates/vm/src/stdlib/_ctypes/union.rs
similarity index 80%
rename from crates/vm/src/stdlib/ctypes/union.rs
rename to crates/vm/src/stdlib/_ctypes/union.rs
index aecef18ec7c..c1882141e98 100644
--- a/crates/vm/src/stdlib/ctypes/union.rs
+++ b/crates/vm/src/stdlib/_ctypes/union.rs
@@ -1,13 +1,14 @@
 use super::base::{CDATA_BUFFER_METHODS, StgInfoFlags};
 use super::{PyCData, PyCField, StgInfo};
-use crate::builtins::{PyList, PyStr, PyTuple, PyType, PyTypeRef};
+use crate::builtins::{PyList, PyStr, PyTuple, PyType, PyTypeRef, PyUtf8Str};
 use crate::convert::ToPyObject;
-use crate::function::FuncArgs;
-use crate::function::PySetterValue;
+use crate::function::{ArgBytesLike, FuncArgs, OptionalArg, PySetterValue};
 use crate::protocol::{BufferDescriptor, PyBuffer};
+use crate::stdlib::_warnings;
 use crate::types::{AsBuffer, Constructor, Initializer, SetAttr};
 use crate::{AsObject, Py, PyObjectRef, PyPayload, PyResult, VirtualMachine};
 use alloc::borrow::Cow;
+use num_traits::ToPrimitive;
 
 /// Calculate Union type size from _fields_ (max field size)
 pub(super) fn calculate_union_size(cls: &Py<PyType>, vm: &VirtualMachine) -> PyResult<usize> {
@@ -106,6 +107,7 @@ impl Initializer for PyCUnionType {
                     let mut stg_info = baseinfo.clone();
                     stg_info.flags &= !StgInfoFlags::DICTFLAG_FINAL; // Clear FINAL flag in subclass
                     stg_info.initialized = true;
+                    stg_info.pointer_type = None; // Non-inheritable
                     stg_info
                 });
 
@@ -163,6 +165,22 @@ impl PyCUnionType {
         };
 
         let pack = super::base::get_usize_attr(cls.as_object(), "_pack_", 0, vm)?;
+
+        // Emit DeprecationWarning on non-Windows when _pack_ is set without _layout_
+        if pack > 0 && !cfg!(windows) {
+            let has_layout = cls.as_object().get_attr("_layout_", vm).is_ok();
+            if !has_layout {
+                let msg = format!(
+                    "Due to '_pack_', the '{}' Union will use memory layout compatible with \
+                     MSVC (Windows). If this is intended, set _layout_ to 'ms'. \
+                     The implicit default is deprecated and slated to become an error in \
+                     Python 3.19.",
+                    cls.name(),
+                );
+                _warnings::warn(vm.ctx.exceptions.deprecation_warning, msg, 1, vm)?;
+            }
+        }
+
         let forced_alignment =
             super::base::get_usize_attr(cls.as_object(), "_align_", 1, vm)?.max(1);
 
@@ -191,17 +209,18 @@ impl PyCUnionType {
                 .ok_or_else(|| vm.new_type_error("_fields_ must contain tuples"))?;
 
             if field_tuple.len() < 2 {
-                return Err(vm.new_type_error(
-                    "_fields_ tuple must have at least 2 elements (name, type)".to_string(),
-                ));
+                return Err(
+                    vm.new_type_error("_fields_ tuple must have at least 2 elements (name, type)")
+                );
             }
 
             let name = field_tuple
                 .first()
                 .expect("len checked")
-                .downcast_ref::<PyStr>()
+                .downcast_ref::<PyUtf8Str>()
                 .ok_or_else(|| vm.new_type_error("field name must be a string"))?
-                .to_string();
+                .as_str()
+                .to_owned();
 
             let field_type = field_tuple.get(1).expect("len checked").clone();
 
@@ -258,7 +277,40 @@ impl PyCUnionType {
                 .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);
+
+            // Check for bitfield size (optional 3rd element in tuple)
+            // For unions, each field starts fresh (CPython: _layout.py)
+            let c_field = if field_tuple.len() > 2 {
+                let bit_size_obj = field_tuple.get(2).expect("len checked");
+                let bit_size = bit_size_obj
+                    .try_int(vm)?
+                    .as_bigint()
+                    .to_u16()
+                    .ok_or_else(|| vm.new_value_error("number of bits invalid for bit field"))?;
+                has_bitfield = true;
+
+                // Union fields all start at offset 0, so bit_offset = 0
+                let mut bit_offset: u16 = 0;
+                let type_bits = (size * 8) as u16;
+
+                // Big-endian: bit_offset = type_bits - bit_size
+                let big_endian = is_swapped != cfg!(target_endian = "big");
+                if big_endian && type_bits >= bit_size {
+                    bit_offset = type_bits - bit_size;
+                }
+
+                PyCField::new_bitfield(
+                    name.clone(),
+                    field_type_ref,
+                    0, // Union fields always at offset 0
+                    size as isize,
+                    bit_size,
+                    bit_offset,
+                    index,
+                )
+            } else {
+                PyCField::new(name.clone(), field_type_ref, 0, size as isize, index)
+            };
 
             cls.set_attr(vm.ctx.intern_str(name), c_field.to_pyobject(vm));
         }
@@ -271,6 +323,13 @@ impl PyCUnionType {
             max_size
         };
 
+        // Check for circular self-reference
+        if let Some(stg_info) = cls.get_type_data::<StgInfo>()
+            && stg_info.is_final()
+        {
+            return Err(vm.new_attribute_error("Structure or union cannot contain itself"));
+        }
+
         // Store StgInfo with aligned size
         let mut stg_info = StgInfo::new(aligned_size, total_align);
         stg_info.length = fields.len();
@@ -299,6 +358,16 @@ impl PyCUnionType {
 
 #[pyclass(flags(BASETYPE), with(Constructor, Initializer, SetAttr))]
 impl PyCUnionType {
+    #[pygetset(name = "__pointer_type__")]
+    fn pointer_type(zelf: PyTypeRef, vm: &VirtualMachine) -> PyResult {
+        super::base::pointer_type_get(&zelf, vm)
+    }
+
+    #[pygetset(name = "__pointer_type__", setter)]
+    fn set_pointer_type(zelf: PyTypeRef, value: PyObjectRef, vm: &VirtualMachine) -> PyResult<()> {
+        super::base::pointer_type_set(&zelf, value, vm)
+    }
+
     #[pymethod]
     fn from_param(zelf: PyObjectRef, value: PyObjectRef, vm: &VirtualMachine) -> PyResult {
         // zelf is the union type class that from_param was called on
@@ -344,6 +413,55 @@ impl PyCUnionType {
         )))
     }
 
+    // CDataType methods - delegated to PyCData implementations
+
+    #[pymethod]
+    fn from_address(zelf: PyObjectRef, address: isize, vm: &VirtualMachine) -> PyResult {
+        let cls: PyTypeRef = zelf
+            .downcast()
+            .map_err(|_| vm.new_type_error("expected a type"))?;
+        PyCData::from_address(cls, address, vm)
+    }
+
+    #[pymethod]
+    fn from_buffer(
+        zelf: PyObjectRef,
+        source: PyObjectRef,
+        offset: OptionalArg<isize>,
+        vm: &VirtualMachine,
+    ) -> PyResult {
+        let cls: PyTypeRef = zelf
+            .downcast()
+            .map_err(|_| vm.new_type_error("expected a type"))?;
+        PyCData::from_buffer(cls, source, offset, vm)
+    }
+
+    #[pymethod]
+    fn from_buffer_copy(
+        zelf: PyObjectRef,
+        source: ArgBytesLike,
+        offset: OptionalArg<isize>,
+        vm: &VirtualMachine,
+    ) -> PyResult {
+        let cls: PyTypeRef = zelf
+            .downcast()
+            .map_err(|_| vm.new_type_error("expected a type"))?;
+        PyCData::from_buffer_copy(cls, source, offset, vm)
+    }
+
+    #[pymethod]
+    fn in_dll(
+        zelf: PyObjectRef,
+        dll: PyObjectRef,
+        name: crate::builtins::PyStrRef,
+        vm: &VirtualMachine,
+    ) -> PyResult {
+        let cls: PyTypeRef = zelf
+            .downcast()
+            .map_err(|_| vm.new_type_error("expected a type"))?;
+        PyCData::in_dll(cls, dll, name, vm)
+    }
+
     /// Called when a new Union subclass is created
     #[pyclassmethod]
     fn __init_subclass__(cls: PyTypeRef, vm: &VirtualMachine) -> PyResult<()> {
@@ -365,7 +483,7 @@ impl SetAttr for PyCUnionType {
         vm: &VirtualMachine,
     ) -> PyResult<()> {
         let pytype: &Py<PyType> = zelf.to_base();
-        let attr_name_interned = vm.ctx.intern_str(attr_name.as_str());
+        let attr_name_interned = vm.ctx.intern_str(attr_name.as_wtf8());
 
         // 1. First, do PyType's setattro (PyType_Type.tp_setattro first)
         // Check for data descriptor first
@@ -374,7 +492,7 @@ impl SetAttr for PyCUnionType {
             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_"
+                if attr_name.as_bytes() == b"_fields_"
                     && let PySetterValue::Assign(fields_value) = value
                 {
                     PyCUnionType::process_fields(pytype, fields_value, vm)?;
@@ -383,6 +501,14 @@ impl SetAttr for PyCUnionType {
             }
         }
 
+        // 2. If _fields_, call process_fields (which checks FINAL internally)
+        // Check BEFORE writing to dict to avoid storing _fields_ when FINAL
+        if attr_name.as_bytes() == b"_fields_"
+            && let PySetterValue::Assign(ref fields_value) = value
+        {
+            PyCUnionType::process_fields(pytype, fields_value.clone(), vm)?;
+        }
+
         // Store in type's attributes dict
         match &value {
             PySetterValue::Assign(v) => {
@@ -397,19 +523,12 @@ impl SetAttr for PyCUnionType {
                     return Err(vm.new_attribute_error(format!(
                         "type object '{}' has no attribute '{}'",
                         pytype.name(),
-                        attr_name.as_str(),
+                        attr_name.as_wtf8(),
                     )));
                 }
             }
         }
 
-        // 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(())
     }
 }
@@ -496,7 +615,7 @@ impl PyCUnion {
                 }
                 if let Some(tuple) = field.downcast_ref::<PyTuple>()
                     && let Some(name) = tuple.first()
-                    && let Some(name_str) = name.downcast_ref::<PyStr>()
+                    && let Some(name_str) = name.downcast_ref::<PyUtf8Str>()
                 {
                     let field_name = name_str.as_str().to_owned();
                     // Check for duplicate in kwargs
diff --git a/crates/vm/src/stdlib/functools.rs b/crates/vm/src/stdlib/_functools.rs
similarity index 89%
rename from crates/vm/src/stdlib/functools.rs
rename to crates/vm/src/stdlib/_functools.rs
index 6c5c8f2e4c5..494f0e7fd83 100644
--- a/crates/vm/src/stdlib/functools.rs
+++ b/crates/vm/src/stdlib/_functools.rs
@@ -14,6 +14,7 @@ mod _functools {
         types::{Callable, Constructor, GetDescriptor, Representable},
     };
     use indexmap::IndexMap;
+    use rustpython_common::wtf8::Wtf8Buf;
 
     #[derive(FromArgs)]
     struct ReduceArgs {
@@ -44,7 +45,7 @@ mod _functools {
                 let exc_type = vm.ctx.exceptions.type_error.to_owned();
                 vm.new_exception_msg(
                     exc_type,
-                    "reduce() of empty sequence with no initial value".to_owned(),
+                    "reduce() of empty sequence with no initial value".into(),
                 )
             })?
         };
@@ -78,7 +79,7 @@ mod _functools {
 
         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 Err(vm.new_type_error("_PlaceholderType takes no arguments"));
             }
             // Return the singleton stored on the type class
             if let Some(instance) = cls.get_attr(vm.ctx.intern_str("_instance")) {
@@ -103,7 +104,7 @@ mod _functools {
 
         #[pymethod]
         fn __init_subclass__(_cls: PyTypeRef, vm: &VirtualMachine) -> PyResult<()> {
-            Err(vm.new_type_error("cannot subclass '_PlaceholderType'".to_owned()))
+            Err(vm.new_type_error("cannot subclass '_PlaceholderType'"))
         }
     }
 
@@ -139,7 +140,7 @@ mod _functools {
 
     #[pyclass(
         with(Constructor, Callable, GetDescriptor, Representable),
-        flags(BASETYPE, HAS_DICT)
+        flags(BASETYPE, HAS_DICT, HAS_WEAKREF)
     )]
     impl PyPartial {
         #[pygetset]
@@ -244,7 +245,7 @@ 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()));
+                return Err(vm.new_type_error("trailing Placeholders are not allowed"));
             }
             let phcount = count_placeholders(args_slice);
 
@@ -353,7 +354,7 @@ mod _functools {
 
             // 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()));
+                return Err(vm.new_type_error("trailing Placeholders are not allowed"));
             }
 
             let phcount = count_placeholders(&final_args);
@@ -424,9 +425,9 @@ mod _functools {
             // Add keywords from self.keywords
             for (key, value) in &*keywords {
                 let key_str = key
-                    .downcast::<crate::builtins::PyStr>()
-                    .map_err(|_| vm.new_type_error("keywords must be strings"))?;
-                final_kwargs.insert(key_str.as_str().to_owned(), value);
+                    .downcast_ref::<crate::builtins::PyStr>()
+                    .ok_or_else(|| vm.new_type_error("keywords must be strings"))?;
+                final_kwargs.insert(key_str.expect_str().to_owned(), value);
             }
 
             // Add keywords from args.kwargs (these override self.keywords)
@@ -455,7 +456,7 @@ mod _functools {
 
     impl Representable for PyPartial {
         #[inline]
-        fn repr_str(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<String> {
+        fn repr_wtf8(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<Wtf8Buf> {
             // Check for recursive repr
             let obj = zelf.as_object();
             if let Some(_guard) = ReprGuard::enter(vm, obj) {
@@ -469,52 +470,46 @@ mod _functools {
                     )
                 };
 
-                let func_repr = func.repr(vm)?;
-                let mut parts = vec![func_repr.as_str().to_owned()];
+                let qualname = zelf.class().__qualname__(vm);
+                let qualname_wtf8 = qualname
+                    .downcast_ref::<crate::builtins::PyStr>()
+                    .map(|s| s.as_wtf8().to_owned())
+                    .unwrap_or_else(|| Wtf8Buf::from(zelf.class().name().to_owned()));
+                let module = zelf.class().__module__(vm);
+
+                let mut result = Wtf8Buf::new();
+                if let Ok(module_str) = module.downcast::<crate::builtins::PyStr>() {
+                    let module_name = module_str.as_wtf8();
+                    if module_name != "builtins" && !module_name.is_empty() {
+                        result.push_wtf8(module_name);
+                        result.push_char('.');
+                    }
+                }
+                result.push_wtf8(&qualname_wtf8);
+                result.push_char('(');
+                result.push_wtf8(func.repr(vm)?.as_wtf8());
 
                 for arg in args.as_slice() {
-                    parts.push(arg.repr(vm)?.as_str().to_owned());
+                    result.push_str(", ");
+                    result.push_wtf8(arg.repr(vm)?.as_wtf8());
                 }
 
                 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()
+                    result.push_str(", ");
+                    let key_str = if let Ok(s) = key.clone().downcast::<crate::builtins::PyStr>() {
+                        s
                     } else {
-                        // For non-string keys, convert to string using __str__
-                        key.str(vm)?.as_str().to_owned()
+                        key.str(vm)?
                     };
-                    let value_str = value.repr(vm)?;
-                    parts.push(format!(
-                        "{key_part}={value_str}",
-                        value_str = value_str.as_str()
-                    ));
+                    result.push_wtf8(key_str.as_wtf8());
+                    result.push_char('=');
+                    result.push_wtf8(value.repr(vm)?.as_wtf8());
                 }
 
-                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 = 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(_) => qualname_str,
-                };
-
-                Ok(format!(
-                    "{qualified_name}({parts})",
-                    parts = parts.join(", ")
-                ))
+                result.push_char(')');
+                Ok(result)
             } else {
-                Ok("...".to_owned())
+                Ok(Wtf8Buf::from("..."))
             }
         }
     }
diff --git a/crates/vm/src/stdlib/_imp.rs b/crates/vm/src/stdlib/_imp.rs
new file mode 100644
index 00000000000..c0acb304a64
--- /dev/null
+++ b/crates/vm/src/stdlib/_imp.rs
@@ -0,0 +1,364 @@
+use crate::builtins::{PyCode, PyStrInterned};
+use crate::frozen::FrozenModule;
+use crate::{VirtualMachine, builtins::PyBaseExceptionRef};
+use core::borrow::Borrow;
+
+pub(crate) use _imp::module_def;
+
+pub use crate::vm::resolve_frozen_alias;
+
+#[cfg(feature = "threading")]
+#[pymodule(sub)]
+mod lock {
+    use crate::{PyResult, VirtualMachine, stdlib::_thread::RawRMutex};
+
+    static IMP_LOCK: RawRMutex = RawRMutex::INIT;
+
+    #[pyfunction]
+    fn acquire_lock(_vm: &VirtualMachine) {
+        acquire_lock_for_fork()
+    }
+
+    #[pyfunction]
+    fn release_lock(vm: &VirtualMachine) -> PyResult<()> {
+        if !IMP_LOCK.is_locked() {
+            Err(vm.new_runtime_error("Global import lock not held"))
+        } else {
+            unsafe { IMP_LOCK.unlock() };
+            Ok(())
+        }
+    }
+
+    #[pyfunction]
+    fn lock_held(_vm: &VirtualMachine) -> bool {
+        IMP_LOCK.is_locked()
+    }
+
+    pub(super) fn acquire_lock_for_fork() {
+        IMP_LOCK.lock();
+    }
+
+    pub(super) fn release_lock_after_fork_parent() {
+        if IMP_LOCK.is_locked() && IMP_LOCK.is_owned_by_current_thread() {
+            unsafe { IMP_LOCK.unlock() };
+        }
+    }
+
+    /// Reset import lock after fork() — only if held by a dead thread.
+    ///
+    /// `IMP_LOCK` is a reentrant mutex. If the *current* (surviving) thread
+    /// held it at fork time, the child must be able to release it normally.
+    /// Only reset if a now-dead thread was the owner.
+    ///
+    /// # Safety
+    ///
+    /// Must only be called from single-threaded child after fork().
+    #[cfg(unix)]
+    pub(crate) unsafe fn reinit_after_fork() {
+        if IMP_LOCK.is_locked() && !IMP_LOCK.is_owned_by_current_thread() {
+            // Held by a dead thread — reset to unlocked.
+            unsafe { rustpython_common::lock::zero_reinit_after_fork(&IMP_LOCK) };
+        }
+    }
+
+    /// Match CPython's `_PyImport_ReInitLock()` + `_PyImport_ReleaseLock()`
+    /// behavior in the post-fork child:
+    /// 1) if ownership metadata is stale (dead owner / changed tid), reset;
+    /// 2) if current thread owns the lock, release it.
+    #[cfg(unix)]
+    pub(super) unsafe fn after_fork_child_reinit_and_release() {
+        unsafe { reinit_after_fork() };
+        if IMP_LOCK.is_locked() && IMP_LOCK.is_owned_by_current_thread() {
+            unsafe { IMP_LOCK.unlock() };
+        }
+    }
+}
+
+/// Re-export for fork safety code in posix.rs
+#[cfg(feature = "threading")]
+pub(crate) fn acquire_imp_lock_for_fork() {
+    lock::acquire_lock_for_fork();
+}
+
+#[cfg(feature = "threading")]
+pub(crate) fn release_imp_lock_after_fork_parent() {
+    lock::release_lock_after_fork_parent();
+}
+
+#[cfg(all(unix, feature = "threading"))]
+pub(crate) unsafe fn reinit_imp_lock_after_fork() {
+    unsafe { lock::reinit_after_fork() }
+}
+
+#[cfg(all(unix, feature = "threading"))]
+pub(crate) unsafe fn after_fork_child_imp_lock_release() {
+    unsafe { lock::after_fork_child_reinit_and_release() }
+}
+
+#[cfg(not(feature = "threading"))]
+#[pymodule(sub)]
+mod lock {
+    use crate::vm::VirtualMachine;
+    #[pyfunction]
+    pub(super) const fn acquire_lock(_vm: &VirtualMachine) {}
+    #[pyfunction]
+    pub(super) const fn release_lock(_vm: &VirtualMachine) {}
+    #[pyfunction]
+    pub(super) const fn lock_held(_vm: &VirtualMachine) -> bool {
+        false
+    }
+}
+
+#[allow(dead_code)]
+enum FrozenError {
+    BadName,  // The given module name wasn't valid.
+    NotFound, // It wasn't in PyImport_FrozenModules.
+    Disabled, // -X frozen_modules=off (and not essential)
+    Excluded, // The PyImport_FrozenModules entry has NULL "code"
+    //        (module is present but marked as unimportable, stops search).
+    Invalid, // The PyImport_FrozenModules entry is bogus
+             //          (eg. does not contain executable code).
+}
+
+impl FrozenError {
+    fn to_pyexception(&self, mod_name: &str, vm: &VirtualMachine) -> PyBaseExceptionRef {
+        use FrozenError::*;
+        let msg = match self {
+            BadName | NotFound => format!("No such frozen object named {mod_name}"),
+            Disabled => format!(
+                "Frozen modules are disabled and the frozen object named {mod_name} is not essential"
+            ),
+            Excluded => format!("Excluded frozen object named {mod_name}"),
+            Invalid => format!("Frozen object named {mod_name} is invalid"),
+        };
+        vm.new_import_error(msg, vm.ctx.new_utf8_str(mod_name))
+    }
+}
+
+// look_up_frozen + use_frozen in import.c
+fn find_frozen(name: &str, vm: &VirtualMachine) -> Result<FrozenModule, FrozenError> {
+    let frozen = vm
+        .state
+        .frozen
+        .get(name)
+        .copied()
+        .ok_or(FrozenError::NotFound)?;
+
+    // Bootstrap modules are always available regardless of override flag
+    if matches!(
+        name,
+        "_frozen_importlib" | "_frozen_importlib_external" | "zipimport"
+    ) {
+        return Ok(frozen);
+    }
+
+    // use_frozen(): override > 0 → true, override < 0 → false, 0 → default (true)
+    // When disabled, non-bootstrap modules are simply not found (same as look_up_frozen)
+    let override_val = vm.state.override_frozen_modules.load();
+    if override_val < 0 {
+        return Err(FrozenError::NotFound);
+    }
+
+    Ok(frozen)
+}
+
+#[pymodule(with(lock))]
+mod _imp {
+    use crate::{
+        PyObjectRef, PyPayload, PyRef, PyResult, VirtualMachine,
+        builtins::{PyBytesRef, PyCode, PyMemoryView, PyModule, PyStrRef, PyUtf8StrRef},
+        convert::TryFromBorrowedObject,
+        function::OptionalArg,
+        import, version,
+    };
+
+    #[pyattr]
+    fn check_hash_based_pycs(vm: &VirtualMachine) -> PyStrRef {
+        vm.ctx
+            .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())
+    }
+
+    #[pyfunction]
+    fn is_builtin(name: PyUtf8StrRef, vm: &VirtualMachine) -> bool {
+        vm.state.module_defs.contains_key(name.as_str())
+    }
+
+    #[pyfunction]
+    fn is_frozen(name: PyUtf8StrRef, vm: &VirtualMachine) -> bool {
+        super::find_frozen(name.as_str(), vm).is_ok()
+    }
+
+    #[pyfunction]
+    fn create_builtin(spec: PyObjectRef, vm: &VirtualMachine) -> PyResult {
+        let sys_modules = vm.sys_module.get_attr("modules", vm).unwrap();
+        let name: PyUtf8StrRef = spec.get_attr("name", vm)?.try_into_value(vm)?;
+
+        // Check sys.modules first
+        if let Ok(module) = sys_modules.get_item(&*name, vm) {
+            return Ok(module);
+        }
+
+        let name_str = name.as_str();
+        if let Some(&def) = vm.state.module_defs.get(name_str) {
+            // Phase 1: Create module (use create slot if provided, else default creation)
+            let module = if let Some(create) = def.slots.create {
+                // Custom module creation
+                create(vm, &spec, def)?
+            } else {
+                // Default module creation
+                PyModule::from_def(def).into_ref(&vm.ctx)
+            };
+
+            // Initialize module dict and methods
+            // Corresponds to PyModule_FromDefAndSpec: md_def, _add_methods_to_object, PyModule_SetDocString
+            PyModule::__init_dict_from_def(vm, &module);
+            module.__init_methods(vm)?;
+
+            // Add to sys.modules BEFORE exec (critical for circular import handling)
+            sys_modules.set_item(name.as_pystr(), module.clone().into(), vm)?;
+
+            // Phase 2: Call exec slot (can safely import other modules now)
+            if let Some(exec) = def.slots.exec {
+                exec(vm, &module)?;
+            }
+
+            return Ok(module.into());
+        }
+
+        Ok(vm.ctx.none())
+    }
+
+    #[pyfunction]
+    fn exec_builtin(_mod: PyRef<PyModule>) -> i32 {
+        // For multi-phase init modules, exec is already called in create_builtin
+        0
+    }
+
+    #[pyfunction]
+    fn get_frozen_object(
+        name: PyUtf8StrRef,
+        data: OptionalArg<PyObjectRef>,
+        vm: &VirtualMachine,
+    ) -> PyResult<PyRef<PyCode>> {
+        if let OptionalArg::Present(data) = data
+            && !vm.is_none(&data)
+        {
+            let buf = crate::protocol::PyBuffer::try_from_borrowed_object(vm, &data)?;
+            let contiguous = buf.as_contiguous().ok_or_else(|| {
+                vm.new_buffer_error("get_frozen_object() requires a contiguous buffer")
+            })?;
+            let invalid_err = || {
+                vm.new_import_error(
+                    format!("Frozen object named '{}' is invalid", name.as_str()),
+                    name.clone().into_wtf8(),
+                )
+            };
+            let bag = crate::builtins::code::PyObjBag(&vm.ctx);
+            let code =
+                rustpython_compiler_core::marshal::deserialize_code(&mut &contiguous[..], bag)
+                    .map_err(|_| invalid_err())?;
+            return Ok(vm.ctx.new_code(code));
+        }
+        import::make_frozen(vm, name.as_str())
+    }
+
+    #[pyfunction]
+    fn init_frozen(name: PyUtf8StrRef, vm: &VirtualMachine) -> PyResult {
+        import::import_frozen(vm, name.as_str())
+    }
+
+    #[pyfunction]
+    fn is_frozen_package(name: PyUtf8StrRef, vm: &VirtualMachine) -> PyResult<bool> {
+        let name_str = name.as_str();
+        super::find_frozen(name_str, vm)
+            .map(|frozen| frozen.package)
+            .map_err(|e| e.to_pyexception(name_str, vm))
+    }
+
+    #[pyfunction]
+    fn _override_frozen_modules_for_tests(value: isize, vm: &VirtualMachine) {
+        vm.state.override_frozen_modules.store(value);
+    }
+
+    #[pyfunction]
+    fn _fix_co_filename(code: PyRef<PyCode>, path: PyStrRef, vm: &VirtualMachine) {
+        let old_name = code.source_path();
+        let new_name = vm.ctx.intern_str(path.as_wtf8());
+        super::update_code_filenames(&code, old_name, new_name);
+    }
+
+    #[pyfunction]
+    fn _frozen_module_names(vm: &VirtualMachine) -> PyResult<Vec<PyObjectRef>> {
+        let names = vm
+            .state
+            .frozen
+            .keys()
+            .map(|&name| vm.ctx.new_utf8_str(name).into())
+            .collect();
+        Ok(names)
+    }
+
+    #[allow(clippy::type_complexity)]
+    #[pyfunction]
+    fn find_frozen(
+        name: PyUtf8StrRef,
+        withdata: OptionalArg<bool>,
+        vm: &VirtualMachine,
+    ) -> PyResult<Option<(Option<PyRef<PyMemoryView>>, bool, Option<PyStrRef>)>> {
+        use super::FrozenError::*;
+
+        if withdata.into_option().is_some() {
+            // this is keyword-only argument in CPython
+            unimplemented!();
+        }
+
+        let name_str = name.as_str();
+        let info = match super::find_frozen(name_str, vm) {
+            Ok(info) => info,
+            Err(NotFound | Disabled | BadName) => return Ok(None),
+            Err(e) => return Err(e.to_pyexception(name_str, vm)),
+        };
+
+        // When origname is empty (e.g. __hello_only__), return None.
+        // Otherwise return the resolved alias name.
+        let origname_str = super::resolve_frozen_alias(name_str);
+        let origname = if origname_str.is_empty() {
+            None
+        } else {
+            Some(vm.ctx.new_utf8_str(origname_str).into())
+        };
+        Ok(Some((None, info.package, origname)))
+    }
+
+    #[pyfunction]
+    fn source_hash(key: u64, source: PyBytesRef) -> Vec<u8> {
+        let hash: u64 = crate::common::hash::keyed_hash(key, source.as_bytes());
+        hash.to_le_bytes().to_vec()
+    }
+}
+
+fn update_code_filenames(
+    code: &PyCode,
+    old_name: &'static PyStrInterned,
+    new_name: &'static PyStrInterned,
+) {
+    let current = code.source_path();
+    if !core::ptr::eq(current, old_name) && current.as_str() != old_name.as_str() {
+        return;
+    }
+    code.set_source_path(new_name);
+    for constant in code.code.constants.iter() {
+        let obj: &crate::PyObject = constant.borrow();
+        if let Some(inner_code) = obj.downcast_ref::<PyCode>() {
+            update_code_filenames(inner_code, old_name, new_name);
+        }
+    }
+}
diff --git a/crates/vm/src/stdlib/io.rs b/crates/vm/src/stdlib/_io.rs
similarity index 70%
rename from crates/vm/src/stdlib/io.rs
rename to crates/vm/src/stdlib/_io.rs
index b98de6a87a5..c238dda3725 100644
--- a/crates/vm/src/stdlib/io.rs
+++ b/crates/vm/src/stdlib/_io.rs
@@ -2,6 +2,8 @@
  * I/O core tools.
  */
 pub(crate) use _io::module_def;
+#[cfg(all(unix, feature = "threading"))]
+pub(crate) use _io::reinit_std_streams_after_fork;
 
 cfg_if::cfg_if! {
     if #[cfg(any(not(target_arch = "wasm32"), target_os = "wasi"))] {
@@ -21,73 +23,41 @@ cfg_if::cfg_if! {
 }
 
 use crate::{
-    PyObjectRef, PyResult, TryFromObject, VirtualMachine,
-    builtins::{PyBaseExceptionRef, PyModule},
-    common::os::ErrorExt,
-    convert::{IntoPyException, ToPyException},
-    exceptions::{OSErrorBuilder, ToOSErrorBuilder},
+    AsObject, PyObject, PyObjectRef, PyResult, TryFromObject, VirtualMachine, builtins::PyModule,
 };
 pub use _io::{OpenArgs, io_open as open};
 
-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: {
-            // On Windows, use C runtime's strerror for POSIX errno values
-            // For Windows-specific error codes, fall back to FormatMessage
-
-            // UCRT's strerror returns "Unknown error" for invalid errno values
-            // Windows UCRT defines errno values 1-42 plus some more up to ~127
-            const MAX_POSIX_ERRNO: i32 = 127;
-            if errno > 0 && errno <= MAX_POSIX_ERRNO {
-                let ptr = unsafe { libc::strerror(errno) };
-                if !ptr.is_null() {
-                    let s = unsafe { std::ffi::CStr::from_ptr(ptr) }.to_string_lossy();
-                    if !s.starts_with("Unknown error") {
-                        break 'msg s.into_owned();
-                    }
-                }
-            }
-            self.to_string()
-        };
-        #[cfg(unix)]
-        let msg = {
-            let ptr = unsafe { libc::strerror(errno) };
-            if !ptr.is_null() {
-                unsafe { core::ffi::CStr::from_ptr(ptr) }
-                    .to_string_lossy()
-                    .into_owned()
-            } else {
-                self.to_string()
-            }
-        };
-        #[cfg(not(any(windows, unix)))]
-        let msg = self.to_string();
-
-        #[allow(unused_mut)]
-        let mut builder = OSErrorBuilder::with_errno(errno, msg, vm);
-
-        #[cfg(windows)]
-        if let Some(winerror) = self.raw_os_error() {
-            use crate::convert::ToPyObject;
-            builder = builder.winerror(winerror.to_pyobject(vm));
-        }
-
-        builder
-    }
+fn file_closed(file: &PyObject, vm: &VirtualMachine) -> PyResult<bool> {
+    file.get_attr("closed", vm)?.try_to_bool(vm)
 }
 
-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)
-    }
-}
+const DEFAULT_BUFFER_SIZE: usize = 128 * 1024;
 
-impl IntoPyException for std::io::Error {
-    fn into_pyexception(self, vm: &VirtualMachine) -> PyBaseExceptionRef {
-        self.to_pyexception(vm)
+/// iobase_finalize in Modules/_io/iobase.c
+fn iobase_finalize(zelf: &PyObject, vm: &VirtualMachine) {
+    // If `closed` doesn't exist or can't be evaluated as bool, then the
+    // object is probably in an unusable state, so ignore.
+    let closed = match vm.get_attribute_opt(zelf.to_owned(), "closed") {
+        Ok(Some(val)) => match val.try_to_bool(vm) {
+            Ok(b) => b,
+            Err(_) => return,
+        },
+        _ => return,
+    };
+    if !closed {
+        // Signal close() that it was called as part of the object
+        // finalization process.
+        let _ = zelf.set_attr("_finalizing", vm.ctx.true_value.clone(), vm);
+        if let Err(e) = vm.call_method(zelf, "close", ()) {
+            // BrokenPipeError during GC finalization is expected when pipe
+            // buffer objects are collected after the subprocess dies. The
+            // underlying fd is still properly closed by raw.close().
+            // Popen.__del__ catches BrokenPipeError, but our tracing GC may
+            // finalize pipe buffers before Popen.__del__ runs.
+            if !e.fast_isinstance(vm.ctx.exceptions.broken_pipe_error) {
+                vm.run_unraisable(e, None, zelf.to_owned());
+            }
+        }
     }
 }
 
@@ -144,7 +114,7 @@ mod _io {
         TryFromBorrowedObject, TryFromObject,
         builtins::{
             PyBaseExceptionRef, PyBool, PyByteArray, PyBytes, PyBytesRef, PyDict, PyMemoryView,
-            PyStr, PyStrRef, PyTuple, PyTupleRef, PyType, PyTypeRef, PyUtf8StrRef,
+            PyStr, PyStrRef, PyTuple, PyTupleRef, PyType, PyTypeRef, PyUtf8Str, PyUtf8StrRef,
         },
         class::StaticType,
         common::lock::{
@@ -269,15 +239,8 @@ mod _io {
     }
 
     fn os_err(vm: &VirtualMachine, err: io::Error) -> PyBaseExceptionRef {
-        #[cfg(any(not(target_arch = "wasm32"), target_os = "wasi"))]
-        {
-            use crate::convert::ToPyException;
-            err.to_pyexception(vm)
-        }
-        #[cfg(all(target_arch = "wasm32", not(target_os = "wasi")))]
-        {
-            vm.new_os_error(err.to_string())
-        }
+        use crate::convert::ToPyException;
+        err.to_pyexception(vm)
     }
 
     pub(super) fn io_closed_error(vm: &VirtualMachine) -> PyBaseExceptionRef {
@@ -285,7 +248,7 @@ mod _io {
     }
 
     #[pyattr]
-    const DEFAULT_BUFFER_SIZE: usize = 8 * 1024;
+    const DEFAULT_BUFFER_SIZE: usize = super::DEFAULT_BUFFER_SIZE;
 
     pub(super) fn seekfrom(
         vm: &VirtualMachine,
@@ -395,10 +358,6 @@ mod _io {
         }
     }
 
-    fn file_closed(file: &PyObject, vm: &VirtualMachine) -> PyResult<bool> {
-        file.get_attr("closed", vm)?.try_to_bool(vm)
-    }
-
     fn check_closed(file: &PyObject, vm: &VirtualMachine) -> PyResult<()> {
         if file_closed(file, vm)? {
             Err(io_closed_error(vm))
@@ -454,7 +413,10 @@ mod _io {
     #[derive(Debug, Default, PyPayload)]
     pub struct _IOBase;
 
-    #[pyclass(with(IterNext, Iterable, Destructor), flags(BASETYPE, HAS_DICT))]
+    #[pyclass(
+        with(IterNext, Iterable, Destructor),
+        flags(BASETYPE, HAS_DICT, HAS_WEAKREF)
+    )]
     impl _IOBase {
         #[pymethod]
         fn seek(
@@ -478,7 +440,7 @@ mod _io {
 
         #[pymethod]
         fn fileno(zelf: PyObjectRef, vm: &VirtualMachine) -> PyResult {
-            _unsupported(vm, &zelf, "truncate")
+            _unsupported(vm, &zelf, "fileno")
         }
 
         #[pyattr]
@@ -520,8 +482,9 @@ mod _io {
         }
 
         #[pymethod]
-        fn isatty(_self: PyObjectRef) -> bool {
-            false
+        fn isatty(instance: PyObjectRef, vm: &VirtualMachine) -> PyResult<bool> {
+            check_closed(&instance, vm)?;
+            Ok(false)
         }
 
         #[pygetset]
@@ -618,6 +581,11 @@ mod _io {
 
     impl Destructor for _IOBase {
         fn slot_del(zelf: &PyObject, vm: &VirtualMachine) -> PyResult<()> {
+            // C-level IO types (FileIO, Buffered*, TextIOWrapper) have their own
+            // slot_del that calls iobase_finalize with proper _finalizing flag
+            // and _dealloc_warn chain. This base fallback is only reached by
+            // Python-level subclasses, where we silently discard close() errors
+            // to avoid surfacing unraisable from partially initialized objects.
             let _ = vm.call_method(zelf, "close", ());
             Ok(())
         }
@@ -669,7 +637,7 @@ mod _io {
     #[repr(transparent)]
     pub(super) struct _RawIOBase(_IOBase);
 
-    #[pyclass(flags(BASETYPE, HAS_DICT))]
+    #[pyclass(flags(BASETYPE, HAS_DICT, HAS_WEAKREF))]
     impl _RawIOBase {
         #[pymethod]
         fn read(instance: PyObjectRef, size: OptionalSize, vm: &VirtualMachine) -> PyResult {
@@ -737,6 +705,16 @@ mod _io {
             }
             Ok(Some(ret))
         }
+
+        #[pymethod]
+        fn readinto(_instance: PyObjectRef, _args: FuncArgs, vm: &VirtualMachine) -> PyResult {
+            Err(vm.new_not_implemented_error(String::new()))
+        }
+
+        #[pymethod]
+        fn write(_instance: PyObjectRef, _args: FuncArgs, vm: &VirtualMachine) -> PyResult {
+            Err(vm.new_not_implemented_error(String::new()))
+        }
     }
 
     #[pyattr]
@@ -745,7 +723,7 @@ mod _io {
     #[repr(transparent)]
     struct _BufferedIOBase(_IOBase);
 
-    #[pyclass(flags(BASETYPE))]
+    #[pyclass(flags(BASETYPE, HAS_WEAKREF))]
     impl _BufferedIOBase {
         #[pymethod]
         fn read(zelf: PyObjectRef, _size: OptionalArg, vm: &VirtualMachine) -> PyResult {
@@ -810,7 +788,7 @@ mod _io {
     #[repr(transparent)]
     struct _TextIOBase(_IOBase);
 
-    #[pyclass(flags(BASETYPE))]
+    #[pyclass(flags(BASETYPE, HAS_WEAKREF))]
     impl _TextIOBase {
         #[pygetset]
         fn encoding(_zelf: PyObjectRef, vm: &VirtualMachine) -> PyObjectRef {
@@ -1038,29 +1016,39 @@ mod _io {
             vm: &VirtualMachine,
         ) -> PyResult<Option<usize>> {
             let len = buf_range.len();
-            let res = if let Some(buf) = buf {
-                let mem_obj = PyMemoryView::from_buffer_range(buf, buf_range, vm)?.to_pyobject(vm);
 
-                // TODO: loop if write() raises an interrupt
-                vm.call_method(self.raw.as_ref().unwrap(), "write", (mem_obj,))?
+            // Prepare the memoryview; if using the internal buffer, stash it
+            // in write_buf so we can restore it after the write.
+            let (mem_obj, write_buf) = if let Some(buf) = buf {
+                let mem_obj =
+                    PyMemoryView::from_buffer_range(buf, buf_range, vm)?.into_ref(&vm.ctx);
+                (mem_obj, None)
             } else {
                 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),
-                    buf_range,
-                    vm,
-                )?
-                .into_ref(&vm.ctx);
+                let wb = VecBuffer::from(v).into_ref(&vm.ctx);
+                let mem_obj =
+                    PyMemoryView::from_buffer_range(wb.clone().into_pybuffer(true), buf_range, vm)?
+                        .into_ref(&vm.ctx);
+                (mem_obj, Some(wb))
+            };
 
-                // TODO: loop if write() raises an interrupt
+            // Loop if write() raises EINTR (PEP 475)
+            let res = loop {
                 let res = vm.call_method(self.raw.as_ref().unwrap(), "write", (mem_obj.clone(),));
+                match trap_eintr(res, vm) {
+                    Ok(Some(val)) => break Ok(val),
+                    Ok(None) => continue,
+                    Err(e) => break Err(e),
+                }
+            };
 
+            // Restore internal buffer if we borrowed it
+            if let Some(wb) = write_buf {
                 mem_obj.release();
-                self.buffer = write_buf.take();
+                self.buffer = wb.take();
+            }
 
-                res?
-            };
+            let res = res?;
 
             if vm.is_none(&res) {
                 return Ok(None);
@@ -1580,7 +1568,7 @@ mod _io {
     }
 
     #[pyclass]
-    trait BufferedMixin: PyPayload {
+    trait BufferedMixin: PyPayload + StaticType {
         const CLASS_NAME: &'static str;
         const READABLE: bool;
         const WRITABLE: bool;
@@ -1588,10 +1576,11 @@ mod _io {
 
         fn data(&self) -> &PyThreadMutex<BufferedData>;
         fn closing(&self) -> &AtomicBool;
+        fn finalizing(&self) -> &AtomicBool;
 
         fn lock(&self, vm: &VirtualMachine) -> PyResult<PyThreadMutexGuard<'_, BufferedData>> {
             self.data()
-                .lock()
+                .lock_wrapped(|do_lock| vm.allow_threads(do_lock))
                 .ok_or_else(|| vm.new_runtime_error("reentrant call inside buffered io"))
         }
 
@@ -1602,10 +1591,11 @@ mod _io {
                 args.bind(vm).map_err(|e| {
                     let str_repr = e
                         .__str__(vm)
-                        .map(|s| s.as_str().to_owned())
-                        .unwrap_or_else(|_| "<error getting exception str>".to_owned());
+                        .as_ref()
+                        .map_or("<error getting exception str>".as_ref(), |s| s.as_wtf8())
+                        .to_owned();
                     let msg = format!("{}() {}", Self::CLASS_NAME, str_repr);
-                    vm.new_exception_msg(e.class().to_owned(), msg)
+                    vm.new_exception_msg(e.class().to_owned(), msg.into())
                 })?;
             zelf.init(raw, BufferSize { buffer_size }, vm)
         }
@@ -1797,6 +1787,10 @@ mod _io {
                 }
                 raw.to_owned()
             };
+            if zelf.finalizing().load(Ordering::Relaxed) {
+                // _dealloc_warn: delegate to raw._dealloc_warn(source)
+                let _ = vm.call_method(&raw, "_dealloc_warn", (zelf.as_object().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);
@@ -1818,6 +1812,34 @@ mod _io {
         fn __getstate__(zelf: PyObjectRef, vm: &VirtualMachine) -> PyResult {
             Err(vm.new_type_error(format!("cannot pickle '{}' instances", zelf.class().name())))
         }
+
+        #[pymethod]
+        fn __reduce_ex__(zelf: PyObjectRef, proto: usize, vm: &VirtualMachine) -> PyResult {
+            if zelf.class().is(Self::static_type()) {
+                return Err(
+                    vm.new_type_error(format!("cannot pickle '{}' object", zelf.class().name()))
+                );
+            }
+            let _ = proto;
+            reduce_ex_for_subclass(zelf, vm)
+        }
+
+        #[pymethod]
+        fn _dealloc_warn(
+            zelf: PyRef<Self>,
+            source: PyObjectRef,
+            vm: &VirtualMachine,
+        ) -> PyResult<()> {
+            // Get raw reference and release lock before calling downstream
+            let raw = {
+                let data = zelf.lock(vm)?;
+                data.raw.clone()
+            };
+            if let Some(raw) = raw {
+                let _ = vm.call_method(&raw, "_dealloc_warn", (source,));
+            }
+            Ok(())
+        }
     }
 
     #[pyclass]
@@ -1931,6 +1953,7 @@ mod _io {
         _base: _BufferedIOBase,
         data: PyThreadMutex<BufferedData>,
         closing: AtomicBool,
+        finalizing: AtomicBool,
     }
 
     impl BufferedMixin for BufferedReader {
@@ -1945,6 +1968,10 @@ mod _io {
         fn closing(&self) -> &AtomicBool {
             &self.closing
         }
+
+        fn finalizing(&self) -> &AtomicBool {
+            &self.finalizing
+        }
     }
 
     impl BufferedReadable for BufferedReader {
@@ -1957,13 +1984,16 @@ mod _io {
 
     #[pyclass(
         with(Constructor, BufferedMixin, BufferedReadable, Destructor),
-        flags(BASETYPE, HAS_DICT)
+        flags(BASETYPE, HAS_DICT, HAS_WEAKREF)
     )]
     impl BufferedReader {}
 
     impl Destructor for BufferedReader {
         fn slot_del(zelf: &PyObject, vm: &VirtualMachine) -> PyResult<()> {
-            let _ = vm.call_method(zelf, "close", ());
+            if let Some(buf) = zelf.downcast_ref::<BufferedReader>() {
+                buf.finalizing.store(true, Ordering::Relaxed);
+            }
+            iobase_finalize(zelf, vm);
             Ok(())
         }
 
@@ -2002,7 +2032,7 @@ mod _io {
                     // Yield to other threads
                     std::thread::yield_now();
                 }
-                return Err(vm.new_value_error("write to closed file".to_owned()));
+                return Err(vm.new_value_error("write to closed file"));
             }
             let mut data = self.writer().lock(vm)?;
             let raw = data.check_init(vm)?;
@@ -2027,6 +2057,7 @@ mod _io {
         _base: _BufferedIOBase,
         data: PyThreadMutex<BufferedData>,
         closing: AtomicBool,
+        finalizing: AtomicBool,
     }
 
     impl BufferedMixin for BufferedWriter {
@@ -2041,6 +2072,10 @@ mod _io {
         fn closing(&self) -> &AtomicBool {
             &self.closing
         }
+
+        fn finalizing(&self) -> &AtomicBool {
+            &self.finalizing
+        }
     }
 
     impl BufferedWritable for BufferedWriter {
@@ -2053,13 +2088,16 @@ mod _io {
 
     #[pyclass(
         with(Constructor, BufferedMixin, BufferedWritable, Destructor),
-        flags(BASETYPE, HAS_DICT)
+        flags(BASETYPE, HAS_DICT, HAS_WEAKREF)
     )]
     impl BufferedWriter {}
 
     impl Destructor for BufferedWriter {
         fn slot_del(zelf: &PyObject, vm: &VirtualMachine) -> PyResult<()> {
-            let _ = vm.call_method(zelf, "close", ());
+            if let Some(buf) = zelf.downcast_ref::<BufferedWriter>() {
+                buf.finalizing.store(true, Ordering::Relaxed);
+            }
+            iobase_finalize(zelf, vm);
             Ok(())
         }
 
@@ -2078,6 +2116,7 @@ mod _io {
         _base: _BufferedIOBase,
         data: PyThreadMutex<BufferedData>,
         closing: AtomicBool,
+        finalizing: AtomicBool,
     }
 
     impl BufferedMixin for BufferedRandom {
@@ -2093,6 +2132,10 @@ mod _io {
         fn closing(&self) -> &AtomicBool {
             &self.closing
         }
+
+        fn finalizing(&self) -> &AtomicBool {
+            &self.finalizing
+        }
     }
 
     impl BufferedReadable for BufferedRandom {
@@ -2119,13 +2162,16 @@ mod _io {
             BufferedWritable,
             Destructor
         ),
-        flags(BASETYPE, HAS_DICT)
+        flags(BASETYPE, HAS_DICT, HAS_WEAKREF)
     )]
     impl BufferedRandom {}
 
     impl Destructor for BufferedRandom {
         fn slot_del(zelf: &PyObject, vm: &VirtualMachine) -> PyResult<()> {
-            let _ = vm.call_method(zelf, "close", ());
+            if let Some(buf) = zelf.downcast_ref::<BufferedRandom>() {
+                buf.finalizing.store(true, Ordering::Relaxed);
+            }
+            iobase_finalize(zelf, vm);
             Ok(())
         }
 
@@ -2186,7 +2232,7 @@ mod _io {
             BufferedWritable,
             Destructor
         ),
-        flags(BASETYPE, HAS_DICT)
+        flags(BASETYPE, HAS_DICT, HAS_WEAKREF)
     )]
     impl BufferedRWPair {
         #[pymethod]
@@ -2229,7 +2275,7 @@ mod _io {
 
     impl Destructor for BufferedRWPair {
         fn slot_del(zelf: &PyObject, vm: &VirtualMachine) -> PyResult<()> {
-            let _ = vm.call_method(zelf, "close", ());
+            iobase_finalize(zelf, vm);
             Ok(())
         }
 
@@ -2244,16 +2290,16 @@ mod _io {
         #[pyarg(any, default)]
         encoding: Option<PyUtf8StrRef>,
         #[pyarg(any, default)]
-        errors: Option<PyStrRef>,
+        errors: Option<PyUtf8StrRef>,
         #[pyarg(any, default)]
-        newline: Option<Newlines>,
+        newline: OptionalOption<Newlines>,
         #[pyarg(any, default)]
-        line_buffering: Option<bool>,
+        line_buffering: OptionalOption<PyObjectRef>,
         #[pyarg(any, default)]
-        write_through: Option<bool>,
+        write_through: OptionalOption<PyObjectRef>,
     }
 
-    #[derive(Debug, Copy, Clone, Default)]
+    #[derive(Debug, Copy, Clone, Default, PartialEq)]
     enum Newlines {
         #[default]
         Universal,
@@ -2284,7 +2330,7 @@ mod _io {
                         })
                         .ok_or(len)
                 }
-                Self::Cr => s.find("\n".as_ref()).map(|p| p + 1).ok_or(len),
+                Self::Cr => s.find("\r".as_ref()).map(|p| p + 1).ok_or(len),
                 Self::Crlf => {
                     // s[searched..] == remaining
                     let mut searched = 0;
@@ -2323,7 +2369,13 @@ mod _io {
                         obj.class().name()
                     ))
                 })?;
-                match s.as_str() {
+                let wtf8 = s.as_wtf8();
+                if !wtf8.is_utf8() {
+                    let repr = s.repr(vm)?.as_str().to_owned();
+                    return Err(vm.new_value_error(format!("illegal newline value: {repr}")));
+                }
+                let s_str = wtf8.as_str().expect("checked utf8");
+                match s_str {
                     "" => Self::Passthrough,
                     "\n" => Self::Lf,
                     "\r" => Self::Cr,
@@ -2335,6 +2387,22 @@ mod _io {
         }
     }
 
+    fn reduce_ex_for_subclass(zelf: PyObjectRef, vm: &VirtualMachine) -> PyResult {
+        let cls = zelf.class();
+        let new = vm
+            .get_attribute_opt(cls.to_owned().into(), "__new__")?
+            .ok_or_else(|| vm.new_attribute_error("type has no attribute '__new__'"))?;
+        let args = vm.ctx.new_tuple(vec![cls.to_owned().into()]);
+        let state = if let Some(getstate) = vm.get_attribute_opt(zelf.clone(), "__getstate__")? {
+            getstate.call((), vm)?
+        } else if let Ok(dict) = zelf.get_attr("__dict__", vm) {
+            dict
+        } else {
+            vm.ctx.none()
+        };
+        Ok(vm.ctx.new_tuple(vec![new, args.into(), state]).into())
+    }
+
     /// A length of or index into a UTF-8 string, measured in both chars and bytes
     #[derive(Debug, Default, Copy, Clone)]
     struct Utf8size {
@@ -2406,7 +2474,7 @@ mod _io {
         encoder: Option<(PyObjectRef, Option<EncodeFunc>)>,
         decoder: Option<PyObjectRef>,
         encoding: PyUtf8StrRef,
-        errors: PyStrRef,
+        errors: PyUtf8StrRef,
         newline: Newlines,
         line_buffering: bool,
         write_through: bool,
@@ -2506,15 +2574,11 @@ mod _io {
                 return None;
             }
             buf.resize(Self::BYTE_LEN, 0);
-            let buf: &[u8; Self::BYTE_LEN] = buf.as_slice().try_into().unwrap();
+            let buf: &[u8; Self::BYTE_LEN] = buf.as_array()?;
             macro_rules! get_field {
-                ($t:ty, $off:ident) => {{
-                    <$t>::from_ne_bytes(
-                        buf[Self::$off..][..core::mem::size_of::<$t>()]
-                            .try_into()
-                            .unwrap(),
-                    )
-                }};
+                ($t:ty, $off:ident) => {
+                    <$t>::from_ne_bytes(*buf[Self::$off..].first_chunk().unwrap())
+                };
             }
             Some(Self {
                 start_pos: get_field!(Offset, START_POS_OFF),
@@ -2570,12 +2634,99 @@ mod _io {
         }
     }
 
+    #[pyclass(module = "_io", name, no_attr)]
+    #[derive(Debug, PyPayload)]
+    struct StatelessIncrementalEncoder {
+        encode: PyObjectRef,
+        errors: Option<PyStrRef>,
+        name: Option<PyStrRef>,
+    }
+
+    #[pyclass]
+    impl StatelessIncrementalEncoder {
+        #[pymethod]
+        fn encode(
+            &self,
+            input: PyObjectRef,
+            _final: OptionalArg<bool>,
+            vm: &VirtualMachine,
+        ) -> PyResult {
+            let mut args: Vec<PyObjectRef> = vec![input];
+            if let Some(errors) = &self.errors {
+                args.push(errors.to_owned().into());
+            }
+            let res = self.encode.call(args, vm)?;
+            let tuple: PyTupleRef = res.try_into_value(vm)?;
+            if tuple.len() != 2 {
+                return Err(vm.new_type_error("encoder must return a tuple (object, integer)"));
+            }
+            Ok(tuple[0].clone())
+        }
+
+        #[pymethod]
+        fn reset(&self) {}
+
+        #[pymethod]
+        fn setstate(&self, _state: PyObjectRef) {}
+
+        #[pymethod]
+        fn getstate(&self, vm: &VirtualMachine) -> PyObjectRef {
+            vm.ctx.new_int(0).into()
+        }
+
+        #[pygetset]
+        fn name(&self) -> Option<PyStrRef> {
+            self.name.clone()
+        }
+    }
+
+    #[pyclass(module = "_io", name, no_attr)]
+    #[derive(Debug, PyPayload)]
+    struct StatelessIncrementalDecoder {
+        decode: PyObjectRef,
+        errors: Option<PyStrRef>,
+    }
+
+    #[pyclass]
+    impl StatelessIncrementalDecoder {
+        #[pymethod]
+        fn decode(
+            &self,
+            input: PyObjectRef,
+            _final: OptionalArg<bool>,
+            vm: &VirtualMachine,
+        ) -> PyResult {
+            let mut args: Vec<PyObjectRef> = vec![input];
+            if let Some(errors) = &self.errors {
+                args.push(errors.to_owned().into());
+            }
+            let res = self.decode.call(args, vm)?;
+            let tuple: PyTupleRef = res.try_into_value(vm)?;
+            if tuple.len() != 2 {
+                return Err(vm.new_type_error("decoder must return a tuple (object, integer)"));
+            }
+            Ok(tuple[0].clone())
+        }
+
+        #[pymethod]
+        fn getstate(&self, vm: &VirtualMachine) -> (PyBytesRef, u64) {
+            (vm.ctx.empty_bytes.to_owned(), 0)
+        }
+
+        #[pymethod]
+        fn setstate(&self, _state: PyTupleRef, _vm: &VirtualMachine) {}
+
+        #[pymethod]
+        fn reset(&self) {}
+    }
+
     #[pyattr]
     #[pyclass(name = "TextIOWrapper", base = _TextIOBase)]
     #[derive(Debug, Default)]
     struct TextIOWrapper {
         _base: _TextIOBase,
         data: PyThreadMutex<Option<TextIOData>>,
+        finalizing: AtomicBool,
     }
 
     impl DefaultConstructor for TextIOWrapper {}
@@ -2591,41 +2742,34 @@ mod _io {
             let mut data = zelf.lock_opt(vm)?;
             *data = None;
 
-            let encoding = match args.encoding {
-                None if vm.state.config.settings.utf8_mode > 0 => {
-                    identifier_utf8!(vm, utf_8).to_owned()
-                }
-                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)?
-                        .get_attr("getencoding", vm)?
-                        .call((), vm)?
-                        .try_into_value(vm)?
-                }
-            };
-
-            let errors = args
-                .errors
-                .unwrap_or_else(|| identifier!(vm, strict).to_owned());
+            let encoding = Self::resolve_encoding(args.encoding, vm)?;
 
-            // 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 errors = args.errors.unwrap_or_else(|| vm.ctx.new_utf8_str("strict"));
+            Self::validate_errors(&errors, vm)?;
 
             let has_read1 = vm.get_attribute_opt(buffer.clone(), "read1")?.is_some();
             let seekable = vm.call_method(&buffer, "seekable", ())?.try_to_bool(vm)?;
 
-            let newline = args.newline.unwrap_or_default();
+            let newline = match args.newline {
+                OptionalArg::Missing | OptionalArg::Present(None) => Newlines::default(),
+                OptionalArg::Present(Some(newline)) => newline,
+            };
             let (encoder, decoder) =
                 Self::find_coder(&buffer, encoding.as_str(), &errors, newline, vm)?;
+            if let Some((encoder, _)) = &encoder {
+                Self::adjust_encoder_state_for_bom(encoder, encoding.as_str(), &buffer, vm)?;
+            }
+
+            let line_buffering = match args.line_buffering {
+                OptionalArg::Missing => false,
+                OptionalArg::Present(None) => false,
+                OptionalArg::Present(Some(value)) => value.try_to_bool(vm)?,
+            };
+            let write_through = match args.write_through {
+                OptionalArg::Missing => false,
+                OptionalArg::Present(None) => false,
+                OptionalArg::Present(Some(value)) => value.try_to_bool(vm)?,
+            };
 
             *data = Some(TextIOData {
                 buffer,
@@ -2634,8 +2778,8 @@ mod _io {
                 encoding,
                 errors,
                 newline,
-                line_buffering: args.line_buffering.unwrap_or_default(),
-                write_through: args.write_through.unwrap_or_default(),
+                line_buffering,
+                write_through,
                 chunk_size: 8192,
                 seekable,
                 has_read1,
@@ -2650,6 +2794,16 @@ mod _io {
 
             Ok(())
         }
+
+        fn slot_init(zelf: PyObjectRef, args: FuncArgs, vm: &VirtualMachine) -> PyResult<()> {
+            let zelf_ref: PyRef<Self> = zelf.try_into_value(vm)?;
+            {
+                let mut data = zelf_ref.lock_opt(vm)?;
+                *data = None;
+            }
+            let (buffer, text_args): (PyObjectRef, TextIOWrapperArgs) = args.bind(vm)?;
+            Self::init(zelf_ref, (buffer, text_args), vm)
+        }
     }
 
     impl TextIOWrapper {
@@ -2658,7 +2812,7 @@ mod _io {
             vm: &VirtualMachine,
         ) -> PyResult<PyThreadMutexGuard<'_, Option<TextIOData>>> {
             self.data
-                .lock()
+                .lock_wrapped(|do_lock| vm.allow_threads(do_lock))
                 .ok_or_else(|| vm.new_runtime_error("reentrant call inside textio"))
         }
 
@@ -2668,11 +2822,104 @@ mod _io {
                 .map_err(|_| vm.new_value_error("I/O operation on uninitialized object"))
         }
 
+        fn validate_errors(errors: &PyRef<PyUtf8Str>, vm: &VirtualMachine) -> PyResult<()> {
+            if errors.as_str().contains('\0') {
+                return Err(cstring_error(vm));
+            }
+            vm.state
+                .codec_registry
+                .lookup_error(errors.as_str(), vm)
+                .map(drop)
+        }
+
+        fn bool_from_index(value: PyObjectRef, vm: &VirtualMachine) -> PyResult<bool> {
+            let int = value.try_index(vm)?;
+            let value: i32 = int.try_to_primitive(vm)?;
+            Ok(value != 0)
+        }
+
+        fn resolve_encoding(
+            encoding: Option<PyUtf8StrRef>,
+            vm: &VirtualMachine,
+        ) -> PyResult<PyUtf8StrRef> {
+            // Note: Do not issue EncodingWarning here. The warning should only
+            // be issued by io.text_encoding(), the public API. This function
+            // is used internally (e.g., for stdin/stdout/stderr initialization)
+            // where no warning should be emitted.
+            let encoding = match encoding {
+                None if vm.state.config.settings.utf8_mode > 0 => {
+                    identifier_utf8!(vm, utf_8).to_owned()
+                }
+                Some(enc) if enc.as_str() == "locale" => match vm.import("locale", 0) {
+                    Ok(locale) => locale
+                        .get_attr("getencoding", vm)?
+                        .call((), vm)?
+                        .try_into_value(vm)?,
+                    Err(err)
+                        if err.fast_isinstance(vm.ctx.exceptions.import_error)
+                            || err.fast_isinstance(vm.ctx.exceptions.module_not_found_error) =>
+                    {
+                        identifier_utf8!(vm, utf_8).to_owned()
+                    }
+                    Err(err) => return Err(err),
+                },
+                Some(enc) => {
+                    if enc.as_str().contains('\0') {
+                        return Err(cstring_error(vm));
+                    }
+                    enc
+                }
+                _ => match vm.import("locale", 0) {
+                    Ok(locale) => locale
+                        .get_attr("getencoding", vm)?
+                        .call((), vm)?
+                        .try_into_value(vm)?,
+                    Err(err)
+                        if err.fast_isinstance(vm.ctx.exceptions.import_error)
+                            || err.fast_isinstance(vm.ctx.exceptions.module_not_found_error) =>
+                    {
+                        identifier_utf8!(vm, utf_8).to_owned()
+                    }
+                    Err(err) => return Err(err),
+                },
+            };
+            if encoding.as_str().contains('\0') {
+                return Err(cstring_error(vm));
+            }
+            Ok(encoding)
+        }
+
+        fn adjust_encoder_state_for_bom(
+            encoder: &PyObjectRef,
+            encoding: &str,
+            buffer: &PyObject,
+            vm: &VirtualMachine,
+        ) -> PyResult<()> {
+            let needs_bom = matches!(encoding, "utf-8-sig" | "utf-16" | "utf-32");
+            if !needs_bom {
+                return Ok(());
+            }
+            let seekable = vm.call_method(buffer, "seekable", ())?.try_to_bool(vm)?;
+            if !seekable {
+                return Ok(());
+            }
+            let pos = vm.call_method(buffer, "tell", ())?;
+            if vm.bool_eq(&pos, vm.ctx.new_int(0).as_ref())? {
+                return Ok(());
+            }
+            if let Err(err) = vm.call_method(encoder, "setstate", (0,))
+                && !err.fast_isinstance(vm.ctx.exceptions.attribute_error)
+            {
+                return Err(err);
+            }
+            Ok(())
+        }
+
         #[allow(clippy::type_complexity)]
         fn find_coder(
             buffer: &PyObject,
             encoding: &str,
-            errors: &Py<PyStr>,
+            errors: &Py<PyUtf8Str>,
             newline: Newlines,
             vm: &VirtualMachine,
         ) -> PyResult<(
@@ -2680,14 +2927,38 @@ mod _io {
             Option<PyObjectRef>,
         )> {
             let codec = vm.state.codec_registry.lookup(encoding, vm)?;
+            if !codec.is_text_codec(vm)? {
+                return Err(vm.new_lookup_error(format!(
+                    "'{encoding}' is not a text encoding; use codecs.open() to handle arbitrary codecs"
+                )));
+            }
+            let errors = errors.to_owned().into_wtf8();
 
             let encoder = if vm.call_method(buffer, "writable", ())?.try_to_bool(vm)? {
                 let incremental_encoder =
-                    codec.get_incremental_encoder(Some(errors.to_owned()), vm)?;
+                    match codec.get_incremental_encoder(Some(errors.clone()), vm) {
+                        Ok(encoder) => encoder,
+                        Err(err)
+                            if err.fast_isinstance(vm.ctx.exceptions.type_error)
+                                || err.fast_isinstance(vm.ctx.exceptions.attribute_error) =>
+                        {
+                            let name = vm
+                                .get_attribute_opt(codec.as_tuple().to_owned().into(), "name")?
+                                .and_then(|obj| obj.downcast::<PyStr>().ok());
+                            StatelessIncrementalEncoder {
+                                encode: codec.get_encode_func().to_owned(),
+                                errors: Some(errors.clone()),
+                                name,
+                            }
+                            .into_ref(&vm.ctx)
+                            .into()
+                        }
+                        Err(err) => return Err(err),
+                    };
                 let encoding_name = vm.get_attribute_opt(incremental_encoder.clone(), "name")?;
                 let encode_func = encoding_name.and_then(|name| {
                     let name = name.downcast_ref::<PyStr>()?;
-                    match name.as_str() {
+                    match name.to_str()? {
                         "utf-8" => Some(textio_encode_utf8 as EncodeFunc),
                         _ => None,
                     }
@@ -2698,7 +2969,21 @@ mod _io {
             };
 
             let decoder = if vm.call_method(buffer, "readable", ())?.try_to_bool(vm)? {
-                let decoder = codec.get_incremental_decoder(Some(errors.to_owned()), vm)?;
+                let decoder = match codec.get_incremental_decoder(Some(errors.clone()), vm) {
+                    Ok(decoder) => decoder,
+                    Err(err)
+                        if err.fast_isinstance(vm.ctx.exceptions.type_error)
+                            || err.fast_isinstance(vm.ctx.exceptions.attribute_error) =>
+                    {
+                        StatelessIncrementalDecoder {
+                            decode: codec.get_decode_func().to_owned(),
+                            errors: Some(errors),
+                        }
+                        .into_ref(&vm.ctx)
+                        .into()
+                    }
+                    Err(err) => return Err(err),
+                };
                 if let Newlines::Universal | Newlines::Passthrough = newline {
                     let args = IncrementalNewlineDecoderArgs {
                         decoder,
@@ -2733,38 +3018,102 @@ mod _io {
             IterNext,
             Representable
         ),
-        flags(BASETYPE)
+        flags(BASETYPE, HAS_WEAKREF)
     )]
     impl TextIOWrapper {
         #[pymethod]
         fn reconfigure(&self, args: TextIOWrapperArgs, vm: &VirtualMachine) -> PyResult<()> {
-            let mut data = self.data.lock().unwrap();
-            if let Some(data) = data.as_mut() {
-                if let Some(encoding) = args.encoding {
-                    let (encoder, decoder) = Self::find_coder(
+            let mut data = self.lock(vm)?;
+            data.check_closed(vm)?;
+
+            let mut encoding = data.encoding.clone();
+            let mut errors = data.errors.clone();
+            let mut newline = data.newline;
+            let mut encoding_changed = false;
+            let mut errors_changed = false;
+            let mut newline_changed = false;
+            let mut line_buffering = None;
+            let mut write_through = None;
+
+            if let Some(enc) = args.encoding {
+                if enc.as_str().contains('\0') && enc.as_str().starts_with("locale") {
+                    return Err(vm.new_lookup_error(format!("unknown encoding: {enc}")));
+                }
+                let resolved = Self::resolve_encoding(Some(enc), vm)?;
+                encoding_changed = resolved.as_str() != encoding.as_str();
+                encoding = resolved;
+            }
+
+            if let Some(errs) = args.errors {
+                Self::validate_errors(&errs, vm)?;
+                errors_changed = errs.as_str() != errors.as_str();
+                errors = errs;
+            } else if encoding_changed {
+                errors = identifier_utf8!(vm, strict).to_owned();
+                errors_changed = true;
+            }
+
+            if let OptionalArg::Present(nl) = args.newline {
+                let nl = nl.unwrap_or_default();
+                newline_changed = nl != newline;
+                newline = nl;
+            }
+
+            if let OptionalArg::Present(Some(value)) = args.line_buffering {
+                line_buffering = Some(Self::bool_from_index(value, vm)?);
+            }
+            if let OptionalArg::Present(Some(value)) = args.write_through {
+                write_through = Some(Self::bool_from_index(value, vm)?);
+            }
+
+            if (encoding_changed || newline_changed)
+                && data.decoder.is_some()
+                && (data.decoded_chars.is_some()
+                    || data.snapshot.is_some()
+                    || data.decoded_chars_used.chars != 0)
+            {
+                return Err(new_unsupported_operation(
+                    vm,
+                    "cannot reconfigure encoding or newline after reading from the stream"
+                        .to_owned(),
+                ));
+            }
+
+            if data.pending.num_bytes > 0 {
+                data.write_pending(vm)?;
+            }
+            vm.call_method(&data.buffer, "flush", ())?;
+
+            if encoding_changed || errors_changed || newline_changed {
+                if data.pending.num_bytes > 0 {
+                    data.write_pending(vm)?;
+                }
+                let (encoder, decoder) =
+                    Self::find_coder(&data.buffer, encoding.as_str(), &errors, newline, vm)?;
+                data.encoding = encoding;
+                data.errors = errors;
+                data.newline = newline;
+                data.encoder = encoder;
+                data.decoder = decoder;
+                data.set_decoded_chars(None);
+                data.snapshot = None;
+                data.decoded_chars_used = Utf8size::default();
+                if let Some((encoder, _)) = &data.encoder {
+                    Self::adjust_encoder_state_for_bom(
+                        encoder,
+                        data.encoding.as_str(),
                         &data.buffer,
-                        encoding.as_str(),
-                        &data.errors,
-                        data.newline,
                         vm,
                     )?;
-                    data.encoding = encoding;
-                    data.encoder = encoder;
-                    data.decoder = decoder;
-                }
-                if let Some(errors) = args.errors {
-                    data.errors = errors;
-                }
-                if let Some(newline) = args.newline {
-                    data.newline = newline;
-                }
-                if let Some(line_buffering) = args.line_buffering {
-                    data.line_buffering = line_buffering;
-                }
-                if let Some(write_through) = args.write_through {
-                    data.write_through = write_through;
                 }
             }
+
+            if let Some(line_buffering) = line_buffering {
+                data.line_buffering = line_buffering;
+            }
+            if let Some(write_through) = write_through {
+                data.write_through = write_through;
+            }
             Ok(())
         }
 
@@ -3089,7 +3438,7 @@ mod _io {
         }
 
         #[pygetset]
-        fn errors(&self, vm: &VirtualMachine) -> PyResult<PyStrRef> {
+        fn errors(&self, vm: &VirtualMachine) -> PyResult<PyUtf8StrRef> {
             Ok(self.lock(vm)?.errors.clone())
         }
 
@@ -3201,12 +3550,34 @@ mod _io {
                         }
                     })?
             };
-            if textio.pending.num_bytes + chunk.as_bytes().len() > textio.chunk_size {
-                textio.write_pending(vm)?;
+            if textio.pending.num_bytes > 0
+                && textio.pending.num_bytes + chunk.as_bytes().len() > textio.chunk_size
+            {
+                let buffer = textio.buffer.clone();
+                let pending = textio.pending.take(vm);
+                drop(textio);
+                vm.call_method(&buffer, "write", (pending,))?;
+                textio = self.lock(vm)?;
+                textio.check_closed(vm)?;
+                if textio.pending.num_bytes > 0 {
+                    let buffer = textio.buffer.clone();
+                    let pending = textio.pending.take(vm);
+                    drop(textio);
+                    vm.call_method(&buffer, "write", (pending,))?;
+                    textio = self.lock(vm)?;
+                    textio.check_closed(vm)?;
+                }
             }
             textio.pending.push(chunk);
-            if flush || textio.write_through || textio.pending.num_bytes >= textio.chunk_size {
-                textio.write_pending(vm)?;
+            if textio.pending.num_bytes > 0
+                && (flush || textio.write_through || textio.pending.num_bytes >= textio.chunk_size)
+            {
+                let buffer = textio.buffer.clone();
+                let pending = textio.pending.take(vm);
+                drop(textio);
+                vm.call_method(&buffer, "write", (pending,))?;
+                textio = self.lock(vm)?;
+                textio.check_closed(vm)?;
             }
             if flush {
                 let _ = vm.call_method(&textio.buffer, "flush", ());
@@ -3422,6 +3793,17 @@ mod _io {
             if file_closed(&buffer, vm)? {
                 return Ok(());
             }
+            // https://github.com/python/cpython/issues/142594
+            // The file_closed() check above may have triggered a reentrant
+            // call to detach() via a custom `closed` property.
+            // If so, the buffer is now detached and we should return early.
+            if vm.is_none(&zelf.lock(vm)?.buffer) {
+                return Ok(());
+            }
+            if zelf.finalizing.load(Ordering::Relaxed) {
+                // _dealloc_warn: delegate to buffer._dealloc_warn(source)
+                let _ = vm.call_method(&buffer, "_dealloc_warn", (zelf.as_object().to_owned(),));
+            }
             let flush_res = vm.call_method(zelf.as_object(), "flush", ()).map(drop);
             let close_res = vm.call_method(&buffer, "close", ()).map(drop);
             exception_chain(flush_res, close_res)
@@ -3442,6 +3824,17 @@ mod _io {
         fn __getstate__(zelf: PyObjectRef, vm: &VirtualMachine) -> PyResult {
             Err(vm.new_type_error(format!("cannot pickle '{}' instances", zelf.class().name())))
         }
+
+        #[pymethod]
+        fn __reduce_ex__(zelf: PyObjectRef, proto: usize, vm: &VirtualMachine) -> PyResult {
+            if zelf.class().is(TextIOWrapper::static_type()) {
+                return Err(
+                    vm.new_type_error(format!("cannot pickle '{}' object", zelf.class().name()))
+                );
+            }
+            let _ = proto;
+            reduce_ex_for_subclass(zelf, vm)
+        }
     }
 
     fn parse_decoder_state(state: PyObjectRef, vm: &VirtualMachine) -> PyResult<(PyBytesRef, i32)> {
@@ -3599,7 +3992,10 @@ mod _io {
 
     impl Destructor for TextIOWrapper {
         fn slot_del(zelf: &PyObject, vm: &VirtualMachine) -> PyResult<()> {
-            let _ = vm.call_method(zelf, "close", ());
+            if let Some(wrapper) = zelf.downcast_ref::<TextIOWrapper>() {
+                wrapper.finalizing.store(true, Ordering::Relaxed);
+            }
+            iobase_finalize(zelf, vm);
             Ok(())
         }
 
@@ -3611,41 +4007,54 @@ mod _io {
 
     impl Representable for TextIOWrapper {
         #[inline]
-        fn repr_str(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<String> {
+        fn repr(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<PyRef<PyStr>> {
             let type_name = zelf.class().slot_name();
+            let Some(_guard) = ReprGuard::enter(vm, zelf.as_object()) else {
+                return Err(
+                    vm.new_runtime_error(format!("reentrant call inside {type_name}.__repr__"))
+                );
+            };
             let Some(data) = zelf.data.lock() else {
                 // Reentrant call
-                return Ok(format!("<{type_name}>"));
+                return Ok(vm.ctx.new_str(Wtf8Buf::from(format!("<{type_name}>"))));
             };
             let Some(data) = data.as_ref() else {
-                return Err(vm.new_value_error("I/O operation on uninitialized object".to_owned()));
+                return Err(vm.new_value_error("I/O operation on uninitialized object"));
             };
 
-            let mut result = format!("<{type_name}");
+            let mut result = Wtf8Buf::from(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());
+            if let Ok(Some(name)) = vm.get_attribute_opt(data.buffer.clone(), "name") {
+                let name_repr = name.repr(vm)?;
+                result.push_wtf8(" name=".as_ref());
+                result.push_wtf8(name_repr.as_wtf8());
+            }
+
+            // Add mode if present (prefer the wrapper's attribute)
+            let mode_obj = match vm.get_attribute_opt(zelf.as_object().to_owned(), "mode") {
+                Ok(Some(mode)) => Some(mode),
+                Ok(None) | Err(_) => match vm.get_attribute_opt(data.buffer.clone(), "mode") {
+                    Ok(Some(mode)) => Some(mode),
+                    _ => None,
+                },
+            };
+            if let Some(mode) = mode_obj {
+                let mode_repr = mode.repr(vm)?;
+                result.push_wtf8(" mode=".as_ref());
+                result.push_wtf8(mode_repr.as_wtf8());
             }
 
-            // 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 (always valid UTF-8)
+            result.push_wtf8(" encoding='".as_ref());
+            result.push_wtf8(data.encoding.as_str().as_ref());
+            result.push_wtf8("'>".as_ref());
 
-            // Add encoding
-            result.push_str(" encoding='");
-            result.push_str(data.encoding.as_str());
-            result.push('\'');
+            Ok(vm.ctx.new_str(result))
+        }
 
-            result.push('>');
-            Ok(result)
+        fn repr_str(_zelf: &Py<Self>, _vm: &VirtualMachine) -> PyResult<String> {
+            unreachable!("repr() is overridden directly")
         }
     }
 
@@ -3749,7 +4158,7 @@ mod _io {
             vm: &VirtualMachine,
         ) -> PyResult<PyThreadMutexGuard<'_, Option<IncrementalNewlineDecoderData>>> {
             self.data
-                .lock()
+                .lock_wrapped(|do_lock| vm.allow_threads(do_lock))
                 .ok_or_else(|| vm.new_runtime_error("reentrant call inside nldecoder"))
         }
 
@@ -3846,7 +4255,7 @@ mod _io {
                 output.to_mut().insert(0, '\r'.into());
                 self.pendingcr = false;
             }
-            if !final_ && let Some(s) = output.strip_suffix("\r".as_ref()) {
+            if !final_ && let Some(s) = output.strip_suffix("\r") {
                 output = Cow::Owned(s.to_owned());
                 self.pendingcr = true;
             }
@@ -3970,7 +4379,7 @@ mod _io {
         }
     }
 
-    #[pyclass(flags(BASETYPE, HAS_DICT), with(Constructor, Initializer))]
+    #[pyclass(flags(BASETYPE, HAS_DICT, HAS_WEAKREF), with(Constructor, Initializer))]
     impl StringIO {
         #[pymethod]
         const fn readable(&self) -> bool {
@@ -4129,6 +4538,12 @@ mod _io {
         }
     }
 
+    #[derive(FromArgs)]
+    struct BytesIOArgs {
+        #[pyarg(any, optional)]
+        initial_bytes: OptionalArg<Option<ArgBytesLike>>,
+    }
+
     #[pyattr]
     #[pyclass(name = "BytesIO", base = _BufferedIOBase)]
     #[derive(Debug)]
@@ -4153,15 +4568,17 @@ mod _io {
     }
 
     impl Initializer for BytesIO {
-        type Args = OptionalArg<Option<ArgBytesLike>>;
+        type Args = BytesIOArgs;
 
-        fn init(zelf: PyRef<Self>, object: Self::Args, vm: &VirtualMachine) -> PyResult<()> {
+        fn init(zelf: PyRef<Self>, args: 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(),
-                ));
+                return Err(
+                    vm.new_buffer_error("Existing exports of data: object cannot be re-sized")
+                );
             }
-            let raw_bytes = object
+
+            let raw_bytes = args
+                .initial_bytes
                 .flatten()
                 .map_or_else(Vec::new, |input| input.borrow_buf().to_vec());
             *zelf.buffer.write() = BufferedIO::new(Cursor::new(raw_bytes));
@@ -4179,7 +4596,10 @@ mod _io {
         }
     }
 
-    #[pyclass(flags(BASETYPE, HAS_DICT), with(PyRef, Constructor, Initializer))]
+    #[pyclass(
+        flags(BASETYPE, HAS_DICT, HAS_WEAKREF),
+        with(PyRef, Constructor, Initializer)
+    )]
     impl BytesIO {
         #[pymethod]
         const fn readable(&self) -> bool {
@@ -4196,6 +4616,15 @@ mod _io {
             true
         }
 
+        #[pymethod]
+        fn flush(&self, vm: &VirtualMachine) -> PyResult<()> {
+            if self.closed.load() {
+                Err(io_closed_error(vm))
+            } else {
+                Ok(())
+            }
+        }
+
         #[pymethod]
         fn write(&self, data: ArgBytesLike, vm: &VirtualMachine) -> PyResult<u64> {
             let mut buffer = self.try_resizable(vm)?;
@@ -4239,9 +4668,20 @@ mod _io {
             how: OptionalArg<i32>,
             vm: &VirtualMachine,
         ) -> PyResult<u64> {
-            self.buffer(vm)?
-                .seek(seekfrom(vm, offset, how)?)
-                .map_err(|err| os_err(vm, err))
+            let seek_from = seekfrom(vm, offset, how)?;
+            let mut buffer = self.buffer(vm)?;
+
+            // Handle negative positions by clamping to 0
+            match seek_from {
+                SeekFrom::Current(offset) if offset < 0 => {
+                    let current = buffer.tell();
+                    let new_pos = current.saturating_add_signed(offset);
+                    buffer
+                        .seek(SeekFrom::Start(new_pos))
+                        .map_err(|err| os_err(vm, err))
+                }
+                _ => buffer.seek(seek_from).map_err(|err| os_err(vm, err)),
+            }
         }
 
         #[pymethod]
@@ -4271,7 +4711,11 @@ mod _io {
 
         #[pymethod]
         fn close(&self, vm: &VirtualMachine) -> PyResult<()> {
-            drop(self.try_resizable(vm)?);
+            if self.exports.load() > 0 {
+                return Err(
+                    vm.new_buffer_error("Existing exports of data: object cannot be closed")
+                );
+            }
             self.closed.store(true);
             Ok(())
         }
@@ -4334,12 +4778,24 @@ mod _io {
 
             Ok(())
         }
+
+        #[pymethod]
+        fn isatty(&self, vm: &VirtualMachine) -> PyResult<bool> {
+            if self.closed() {
+                return Err(io_closed_error(vm));
+            }
+
+            Ok(false)
+        }
     }
 
     #[pyclass]
     impl PyRef<BytesIO> {
         #[pymethod]
         fn getbuffer(self, vm: &VirtualMachine) -> PyResult<PyMemoryView> {
+            if self.closed.load() {
+                return Err(vm.new_value_error("I/O operation on closed file."));
+            }
             let len = self.buffer.read().cursor.get_ref().len();
             let buffer = PyBuffer::new(
                 self.into(),
@@ -4515,9 +4971,9 @@ mod _io {
         #[pyarg(any, default)]
         pub encoding: Option<PyUtf8StrRef>,
         #[pyarg(any, default)]
-        pub errors: Option<PyStrRef>,
+        pub errors: Option<PyUtf8StrRef>,
         #[pyarg(any, default)]
-        pub newline: Option<PyStrRef>,
+        pub newline: Option<PyUtf8StrRef>,
         #[pyarg(any, default = true)]
         pub closefd: bool,
         #[pyarg(any, default)]
@@ -4537,6 +4993,60 @@ mod _io {
         }
     }
 
+    /// Reinit per-object IO buffer locks on std streams after `fork()`.
+    ///
+    /// # Safety
+    ///
+    /// Must only be called from the single-threaded child process immediately
+    /// after `fork()`, before any other thread is created.
+    #[cfg(all(unix, feature = "threading"))]
+    pub unsafe fn reinit_std_streams_after_fork(vm: &VirtualMachine) {
+        for name in ["stdin", "stdout", "stderr"] {
+            let Ok(stream) = vm.sys_module.get_attr(name, vm) else {
+                continue;
+            };
+            reinit_io_locks(&stream);
+        }
+    }
+
+    #[cfg(all(unix, feature = "threading"))]
+    fn reinit_io_locks(obj: &PyObject) {
+        use crate::common::lock::reinit_thread_mutex_after_fork;
+
+        if let Some(tio) = obj.downcast_ref::<TextIOWrapper>() {
+            unsafe { reinit_thread_mutex_after_fork(&tio.data) };
+            if let Some(guard) = tio.data.lock()
+                && let Some(ref data) = *guard
+            {
+                if let Some(ref decoder) = data.decoder {
+                    reinit_io_locks(decoder);
+                }
+                reinit_io_locks(&data.buffer);
+            }
+            return;
+        }
+        if let Some(nl) = obj.downcast_ref::<IncrementalNewlineDecoder>() {
+            unsafe { reinit_thread_mutex_after_fork(&nl.data) };
+            return;
+        }
+        if let Some(br) = obj.downcast_ref::<BufferedReader>() {
+            unsafe { reinit_thread_mutex_after_fork(&br.data) };
+            return;
+        }
+        if let Some(bw) = obj.downcast_ref::<BufferedWriter>() {
+            unsafe { reinit_thread_mutex_after_fork(&bw.data) };
+            return;
+        }
+        if let Some(brw) = obj.downcast_ref::<BufferedRandom>() {
+            unsafe { reinit_thread_mutex_after_fork(&brw.data) };
+            return;
+        }
+        if let Some(brw) = obj.downcast_ref::<BufferedRWPair>() {
+            unsafe { reinit_thread_mutex_after_fork(&brw.read.data) };
+            unsafe { reinit_thread_mutex_after_fork(&brw.write.data) };
+        }
+    }
+
     pub fn io_open(
         file: PyObjectRef,
         mode: Option<&str>,
@@ -4565,16 +5075,28 @@ mod _io {
         }
 
         // check file descriptor validity
-        #[cfg(unix)]
+        #[cfg(all(unix, feature = "host_env"))]
         if let Ok(crate::ospath::OsPathOrFd::Fd(fd)) = file.clone().try_into_value(vm) {
             nix::fcntl::fcntl(fd, nix::fcntl::F_GETFD).map_err(|_| vm.new_last_errno_error())?;
         }
 
-        // Construct a FileIO (subclass of RawIOBase)
+        // Construct a RawIO (subclass of RawIOBase)
+        // On Windows, use _WindowsConsoleIO for console handles.
         // This is subsequently consumed by a Buffered Class.
+        #[cfg(all(feature = "host_env", windows))]
+        let is_console = super::winconsoleio::pyio_get_console_type(&file, vm) != '\0';
+        #[cfg(not(all(feature = "host_env", windows)))]
+        let is_console = false;
+
         let file_io_class: &Py<PyType> = {
             cfg_if::cfg_if! {
-                if #[cfg(any(not(target_arch = "wasm32"), target_os = "wasi"))] {
+                if #[cfg(all(feature = "host_env", windows))] {
+                    if is_console {
+                        Some(super::winconsoleio::WindowsConsoleIO::static_type())
+                    } else {
+                        Some(super::fileio::FileIO::static_type())
+                    }
+                } else if #[cfg(feature = "host_env")] {
                     Some(super::fileio::FileIO::static_type())
                 } else {
                     None
@@ -4600,7 +5122,7 @@ mod _io {
 
         // Warn if line buffering is requested in binary mode
         if opts.buffering == 1 && matches!(mode.encode, EncodeMode::Bytes) {
-            crate::stdlib::warnings::warn(
+            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,
@@ -4618,7 +5140,10 @@ mod _io {
 
         if buffering == 0 {
             let ret = match mode.encode {
-                EncodeMode::Text => Err(vm.new_value_error("can't have unbuffered text I/O")),
+                EncodeMode::Text => {
+                    let _ = vm.call_method(&raw, "close", ());
+                    Err(vm.new_value_error("can't have unbuffered text I/O"))
+                }
                 EncodeMode::Bytes => Ok(raw),
             };
             return ret;
@@ -4635,19 +5160,35 @@ mod _io {
 
         match mode.encode {
             EncodeMode::Text => {
+                let encoding = if is_console && opts.encoding.is_none() {
+                    // Console IO always uses utf-8
+                    Some(PyUtf8Str::from("utf-8").into_ref(&vm.ctx))
+                } else {
+                    match opts.encoding {
+                        Some(enc) => Some(enc),
+                        None => {
+                            let encoding =
+                                text_encoding(vm.ctx.none(), OptionalArg::Present(2), vm)?;
+                            Some(PyUtf8StrRef::try_from_object(vm, encoding.into())?)
+                        }
+                    }
+                };
                 let tio = TextIOWrapper::static_type();
                 let wrapper = PyType::call(
                     tio,
                     (
-                        buffered,
-                        opts.encoding,
+                        buffered.clone(),
+                        encoding,
                         opts.errors,
                         opts.newline,
                         line_buffering,
                     )
                         .into_args(vm),
                     vm,
-                )?;
+                )
+                .inspect_err(|_err| {
+                    let _ = vm.call_method(&buffered, "close", ());
+                })?;
                 wrapper.set_attr("mode", vm.new_pyobj(mode_string), vm)?;
                 Ok(wrapper)
             }
@@ -4656,14 +5197,19 @@ mod _io {
     }
 
     fn create_unsupported_operation(ctx: &Context) -> PyTypeRef {
+        use crate::builtins::type_::PyAttributes;
         use crate::types::PyTypeSlots;
+
+        let mut attrs = PyAttributes::default();
+        attrs.insert(identifier!(ctx, __module__), ctx.new_str("io").into());
+
         PyType::new_heap(
             "UnsupportedOperation",
             vec![
                 ctx.exceptions.os_error.to_owned(),
                 ctx.exceptions.value_error.to_owned(),
             ],
-            Default::default(),
+            attrs,
             PyTypeSlots::heap_default(),
             ctx.types.type_type.to_owned(),
             ctx,
@@ -4681,12 +5227,35 @@ mod _io {
     #[pyfunction]
     fn text_encoding(
         encoding: PyObjectRef,
-        _stacklevel: OptionalArg<i32>,
+        stacklevel: OptionalArg<i32>,
         vm: &VirtualMachine,
     ) -> PyResult<PyStrRef> {
         if vm.is_none(&encoding) {
-            // TODO: This is `locale` encoding - but we don't have locale encoding yet
-            return Ok(vm.ctx.new_str("utf-8"));
+            let encoding = if vm.state.config.settings.utf8_mode > 0 {
+                "utf-8"
+            } else {
+                "locale"
+            };
+            if vm.state.config.settings.warn_default_encoding {
+                let mut stacklevel = stacklevel.unwrap_or(2);
+                if stacklevel > 1
+                    && let Some(frame) = vm.current_frame()
+                    && let Some(stdlib_dir) = vm.state.config.paths.stdlib_dir.as_deref()
+                {
+                    let path = frame.code.source_path().as_str();
+                    if !path.starts_with(stdlib_dir) {
+                        stacklevel = stacklevel.saturating_sub(1);
+                    }
+                }
+                let stacklevel = usize::try_from(stacklevel).unwrap_or(0);
+                crate::stdlib::_warnings::warn(
+                    vm.ctx.exceptions.encoding_warning,
+                    "'encoding' argument not specified".to_owned(),
+                    stacklevel,
+                    vm,
+                )?;
+            }
+            return Ok(vm.ctx.new_str(encoding));
         }
         encoding.try_into_value(vm)
     }
@@ -4733,10 +5302,14 @@ mod _io {
         // Call auto-generated initialization first
         __module_exec(vm, module);
 
-        // Initialize FileIO types on non-WASM platforms
-        #[cfg(any(not(target_arch = "wasm32"), target_os = "wasi"))]
+        // Initialize FileIO types (requires host_env for filesystem access)
+        #[cfg(feature = "host_env")]
         super::fileio::module_exec(vm, module)?;
 
+        // Initialize WindowsConsoleIO type (Windows only)
+        #[cfg(all(feature = "host_env", windows))]
+        super::winconsoleio::module_exec(vm, module)?;
+
         let unsupported_operation = unsupported_operation().to_owned();
         extend_module!(vm, module, {
             "UnsupportedOperation" => unsupported_operation,
@@ -4745,16 +5318,16 @@ mod _io {
         Ok(())
     }
 }
-// disable FileIO on WASM
-#[cfg(any(not(target_arch = "wasm32"), target_os = "wasi"))]
+// FileIO requires host environment for filesystem access
+#[cfg(feature = "host_env")]
 #[pymodule]
 mod fileio {
-    use super::{_io::*, Offset};
+    use super::{_io::*, Offset, iobase_finalize};
     use crate::{
         AsObject, Py, PyObject, PyObjectRef, PyPayload, PyRef, PyResult, TryFromObject,
         VirtualMachine,
         builtins::{PyBaseExceptionRef, PyUtf8Str, PyUtf8StrRef},
-        common::crt_fd,
+        common::{crt_fd, wtf8::Wtf8Buf},
         convert::{IntoPyException, ToPyException},
         exceptions::OSErrorBuilder,
         function::{ArgBytesLike, ArgMemoryBuffer, OptionalArg, OptionalOption},
@@ -4763,7 +5336,7 @@ mod fileio {
         types::{Constructor, DefaultConstructor, Destructor, Initializer, Representable},
     };
     use crossbeam_utils::atomic::AtomicCell;
-    use std::io::{Read, Write};
+    use std::io::Read;
 
     bitflags::bitflags! {
         #[derive(Copy, Clone, Debug, PartialEq)]
@@ -4876,6 +5449,7 @@ mod fileio {
         mode: AtomicCell<Mode>,
         seekable: AtomicCell<Option<bool>>,
         blksize: AtomicCell<i64>,
+        finalizing: AtomicCell<bool>,
     }
 
     #[derive(FromArgs)]
@@ -4898,7 +5472,8 @@ mod fileio {
                 closefd: AtomicCell::new(true),
                 mode: AtomicCell::new(Mode::empty()),
                 seekable: AtomicCell::new(None),
-                blksize: AtomicCell::new(8 * 1024), // DEFAULT_BUFFER_SIZE
+                blksize: AtomicCell::new(super::DEFAULT_BUFFER_SIZE as _),
+                finalizing: AtomicCell::new(false),
             }
         }
     }
@@ -4913,7 +5488,7 @@ mod fileio {
             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(
+                crate::stdlib::_warnings::warn(
                     vm.ctx.exceptions.runtime_warning,
                     "bool is used as a file descriptor".to_owned(),
                     1,
@@ -4966,7 +5541,9 @@ mod fileio {
                     let filename = OsPathOrFd::Path(path);
                     match fd {
                         Ok(fd) => (fd.into_raw(), Some(filename)),
-                        Err(e) => return Err(OSErrorBuilder::with_filename(&e, filename, vm)),
+                        Err(e) => {
+                            return Err(OSErrorBuilder::with_filename_from_errno(&e, filename, vm));
+                        }
                     }
                 }
             };
@@ -4982,6 +5559,12 @@ mod fileio {
             #[cfg(windows)]
             {
                 if let Err(err) = fd_fstat {
+                    // If the fd is invalid, prevent destructor from trying to close it
+                    if err.raw_os_error()
+                        == Some(windows_sys::Win32::Foundation::ERROR_INVALID_HANDLE as i32)
+                    {
+                        zelf.fd.store(-1);
+                    }
                     return Err(OSErrorBuilder::with_filename(&err, filename, vm));
                 }
             }
@@ -4999,16 +5582,17 @@ mod fileio {
                         }
                         // Store st_blksize for _blksize property
                         if status.st_blksize > 1 {
-                            #[allow(clippy::useless_conversion)] // needed for 32-bit platforms
+                            #[allow(
+                                clippy::useless_conversion,
+                                reason = "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);
-                            }
+                            // fd is invalid, prevent destructor from trying to close it
+                            zelf.fd.store(-1);
                             return Err(OSErrorBuilder::with_filename(&err, filename, vm));
                         }
                     }
@@ -5055,7 +5639,7 @@ mod fileio {
 
     #[pyclass(
         with(Constructor, Initializer, Representable, Destructor),
-        flags(BASETYPE, HAS_DICT)
+        flags(BASETYPE, HAS_DICT, HAS_WEAKREF)
     )]
     impl FileIO {
         fn io_error(
@@ -5156,12 +5740,12 @@ mod fileio {
                     "File or stream is not readable".to_owned(),
                 ));
             }
-            let mut handle = zelf.get_fd(vm)?;
+            let handle = zelf.get_fd(vm)?;
             let bytes = if let Some(read_byte) = read_byte.to_usize() {
                 let mut bytes = vec![0; read_byte];
                 // Loop on EINTR (PEP 475)
                 let n = loop {
-                    match handle.read(&mut bytes) {
+                    match vm.allow_threads(|| crt_fd::read(handle, &mut bytes)) {
                         Ok(n) => break n,
                         Err(e) if e.raw_os_error() == Some(libc::EINTR) => {
                             vm.check_signals()?;
@@ -5180,7 +5764,10 @@ mod fileio {
                 let mut bytes = vec![];
                 // Loop on EINTR (PEP 475)
                 loop {
-                    match handle.read_to_end(&mut bytes) {
+                    match vm.allow_threads(|| {
+                        let mut h = handle;
+                        h.read_to_end(&mut bytes)
+                    }) {
                         Ok(_) => break,
                         Err(e) if e.raw_os_error() == Some(libc::EINTR) => {
                             vm.check_signals()?;
@@ -5218,10 +5805,9 @@ mod fileio {
             let handle = zelf.get_fd(vm)?;
 
             let mut buf = obj.borrow_buf_mut();
-            let mut f = handle.take(buf.len() as _);
             // Loop on EINTR (PEP 475)
             let ret = loop {
-                match f.read(&mut buf) {
+                match vm.allow_threads(|| crt_fd::read(handle, &mut buf)) {
                     Ok(n) => break n,
                     Err(e) if e.raw_os_error() == Some(libc::EINTR) => {
                         vm.check_signals()?;
@@ -5251,13 +5837,20 @@ mod fileio {
                 ));
             }
 
-            let mut handle = zelf.get_fd(vm)?;
+            let handle = zelf.get_fd(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)),
+            // Loop on EINTR (PEP 475)
+            let len = loop {
+                match obj.with_ref(|b| vm.allow_threads(|| crt_fd::write(handle, b))) {
+                    Ok(n) => break n,
+                    Err(e) if e.raw_os_error() == Some(libc::EINTR) => {
+                        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)),
+                }
             };
 
             //return number of bytes written
@@ -5271,12 +5864,26 @@ mod fileio {
                 zelf.fd.store(-1);
                 return res;
             }
+            let flush_exc = res.err();
+            if zelf.finalizing.load() {
+                Self::dealloc_warn(zelf, zelf.as_object().to_owned(), vm);
+            }
             let fd = zelf.fd.swap(-1);
-            if fd >= 0 {
+            let close_err = if fd >= 0 {
                 crt_fd::close(unsafe { crt_fd::Owned::from_raw(fd) })
-                    .map_err(|err| Self::io_error(zelf, err, vm))?;
+                    .map_err(|err| Self::io_error(zelf, err, vm))
+                    .err()
+            } else {
+                None
+            };
+            match (flush_exc, close_err) {
+                (Some(fe), Some(ce)) => {
+                    ce.set___context__(Some(fe));
+                    Err(ce)
+                }
+                (Some(e), None) | (None, Some(e)) => Err(e),
+                (None, None) => Ok(()),
             }
-            res
         }
 
         #[pymethod]
@@ -5330,11 +5937,1093 @@ mod fileio {
         fn __getstate__(zelf: PyObjectRef, vm: &VirtualMachine) -> PyResult {
             Err(vm.new_type_error(format!("cannot pickle '{}' instances", zelf.class().name())))
         }
+
+        /// fileio_dealloc_warn in Modules/_io/fileio.c
+        #[pymethod(name = "_dealloc_warn")]
+        fn _dealloc_warn_method(
+            zelf: &Py<Self>,
+            source: PyObjectRef,
+            vm: &VirtualMachine,
+        ) -> PyResult<()> {
+            Self::dealloc_warn(zelf, source, vm);
+            Ok(())
+        }
+    }
+
+    impl FileIO {
+        /// Issue ResourceWarning if fd is still open and closefd is true.
+        fn dealloc_warn(zelf: &Py<Self>, source: PyObjectRef, vm: &VirtualMachine) {
+            if zelf.fd.load() >= 0 && zelf.closefd.load() {
+                let repr = source
+                    .repr(vm)
+                    .map(|s| s.as_wtf8().to_owned())
+                    .unwrap_or_else(|_| Wtf8Buf::from("<file>"));
+                if let Err(e) = crate::stdlib::_warnings::warn(
+                    vm.ctx.exceptions.resource_warning,
+                    format!("unclosed file {repr}"),
+                    1,
+                    vm,
+                ) {
+                    vm.run_unraisable(e, None, zelf.as_object().to_owned());
+                }
+            }
+        }
     }
 
     impl Destructor for FileIO {
         fn slot_del(zelf: &PyObject, vm: &VirtualMachine) -> PyResult<()> {
-            let _ = vm.call_method(zelf, "close", ());
+            if let Some(fileio) = zelf.downcast_ref::<FileIO>() {
+                fileio.finalizing.store(true);
+            }
+            iobase_finalize(zelf, vm);
+            Ok(())
+        }
+
+        #[cold]
+        fn del(_zelf: &Py<Self>, _vm: &VirtualMachine) -> PyResult<()> {
+            unreachable!("slot_del is implemented")
+        }
+    }
+}
+
+// WindowsConsoleIO requires host environment and Windows
+#[cfg(all(feature = "host_env", windows))]
+#[pymodule]
+mod winconsoleio {
+    use super::{_io::*, iobase_finalize};
+    use crate::{
+        AsObject, Py, PyObject, PyObjectRef, PyRef, PyResult, TryFromObject, VirtualMachine,
+        builtins::{PyBaseExceptionRef, PyUtf8StrRef},
+        common::{lock::PyMutex, wtf8::Wtf8Buf},
+        convert::{IntoPyException, ToPyException},
+        function::{ArgBytesLike, ArgMemoryBuffer, OptionalArg},
+        types::{Constructor, DefaultConstructor, Destructor, Initializer, Representable},
+    };
+    use crossbeam_utils::atomic::AtomicCell;
+    use windows_sys::Win32::{
+        Foundation::{self, GENERIC_READ, GENERIC_WRITE, INVALID_HANDLE_VALUE},
+        Globalization::{CP_UTF8, MultiByteToWideChar, WideCharToMultiByte},
+        Storage::FileSystem::{
+            CreateFileW, FILE_SHARE_READ, FILE_SHARE_WRITE, GetFullPathNameW, OPEN_EXISTING,
+        },
+        System::Console::{
+            GetConsoleMode, GetNumberOfConsoleInputEvents, ReadConsoleW, WriteConsoleW,
+        },
+    };
+
+    type HANDLE = Foundation::HANDLE;
+
+    const SMALLBUF: usize = 4;
+    const BUFMAX: usize = 32 * 1024 * 1024;
+
+    fn handle_from_fd(fd: i32) -> HANDLE {
+        unsafe { rustpython_common::suppress_iph!(libc::get_osfhandle(fd)) as HANDLE }
+    }
+
+    fn is_invalid_handle(handle: HANDLE) -> bool {
+        handle == INVALID_HANDLE_VALUE || handle.is_null()
+    }
+
+    /// Check if a HANDLE is a console and what type ('r', 'w', or '\0').
+    fn get_console_type(handle: HANDLE) -> char {
+        if is_invalid_handle(handle) {
+            return '\0';
+        }
+        let mut mode: u32 = 0;
+        if unsafe { GetConsoleMode(handle, &mut mode) } == 0 {
+            return '\0';
+        }
+        let mut peek_count: u32 = 0;
+        if unsafe { GetNumberOfConsoleInputEvents(handle, &mut peek_count) } != 0 {
+            'r'
+        } else {
+            'w'
+        }
+    }
+
+    /// Check if a Python object (fd or path string) refers to a console.
+    /// Returns 'r' (input), 'w' (output), 'x' (generic CON), or '\0' (not a console).
+    pub(super) fn pyio_get_console_type(path_or_fd: &PyObject, vm: &VirtualMachine) -> char {
+        // Try as integer fd first
+        if let Ok(fd) = i32::try_from_object(vm, path_or_fd.to_owned()) {
+            if fd >= 0 {
+                let handle = handle_from_fd(fd);
+                return get_console_type(handle);
+            }
+            return '\0';
+        }
+
+        // Try as string path
+        let Ok(name) = path_or_fd.str(vm) else {
+            return '\0';
+        };
+        let Some(name_str) = name.to_str() else {
+            // Surrogate strings can't be console device names
+            return '\0';
+        };
+
+        if name_str.eq_ignore_ascii_case("CONIN$") {
+            return 'r';
+        }
+        if name_str.eq_ignore_ascii_case("CONOUT$") {
+            return 'w';
+        }
+        if name_str.eq_ignore_ascii_case("CON") {
+            return 'x';
+        }
+
+        // Resolve full path and check for console device names
+        let wide: Vec<u16> = name_str.encode_utf16().chain(core::iter::once(0)).collect();
+        let mut buf = [0u16; 260]; // MAX_PATH
+        let length = unsafe {
+            GetFullPathNameW(
+                wide.as_ptr(),
+                buf.len() as u32,
+                buf.as_mut_ptr(),
+                core::ptr::null_mut(),
+            )
+        };
+        if length == 0 || length as usize > buf.len() {
+            return '\0';
+        }
+        let full_path = &buf[..length as usize];
+        // Skip \\?\ or \\.\ prefix
+        let path_part = if full_path.len() >= 4
+            && full_path[0] == b'\\' as u16
+            && full_path[1] == b'\\' as u16
+            && (full_path[2] == b'.' as u16 || full_path[2] == b'?' as u16)
+            && full_path[3] == b'\\' as u16
+        {
+            &full_path[4..]
+        } else {
+            full_path
+        };
+
+        let path_str = String::from_utf16_lossy(path_part);
+        if path_str.eq_ignore_ascii_case("CONIN$") {
+            'r'
+        } else if path_str.eq_ignore_ascii_case("CONOUT$") {
+            'w'
+        } else if path_str.eq_ignore_ascii_case("CON") {
+            'x'
+        } else {
+            '\0'
+        }
+    }
+
+    /// Find the last valid UTF-8 boundary in a byte slice.
+    fn find_last_utf8_boundary(buf: &[u8], len: usize) -> usize {
+        let len = len.min(buf.len());
+        for count in 1..=4.min(len) {
+            let c = buf[len - count];
+            if c < 0x80 {
+                return len;
+            }
+            if c >= 0xc0 {
+                let expected = if c < 0xe0 {
+                    2
+                } else if c < 0xf0 {
+                    3
+                } else {
+                    4
+                };
+                if count < expected {
+                    // Incomplete multibyte sequence
+                    return len - count;
+                }
+                return len;
+            }
+        }
+        len
+    }
+
+    #[pyattr]
+    #[pyclass(module = "_io", name = "_WindowsConsoleIO", base = _RawIOBase)]
+    #[derive(Debug)]
+    pub(super) struct WindowsConsoleIO {
+        _base: _RawIOBase,
+        fd: AtomicCell<i32>,
+        readable: AtomicCell<bool>,
+        writable: AtomicCell<bool>,
+        closefd: AtomicCell<bool>,
+        finalizing: AtomicCell<bool>,
+        blksize: AtomicCell<i64>,
+        buf: PyMutex<[u8; SMALLBUF]>,
+    }
+
+    impl Default for WindowsConsoleIO {
+        fn default() -> Self {
+            Self {
+                _base: Default::default(),
+                fd: AtomicCell::new(-1),
+                readable: AtomicCell::new(false),
+                writable: AtomicCell::new(false),
+                closefd: AtomicCell::new(false),
+                finalizing: AtomicCell::new(false),
+                blksize: AtomicCell::new(super::DEFAULT_BUFFER_SIZE as _),
+                buf: PyMutex::new([0u8; SMALLBUF]),
+            }
+        }
+    }
+
+    impl DefaultConstructor for WindowsConsoleIO {}
+
+    #[derive(FromArgs)]
+    pub struct WindowsConsoleIOArgs {
+        #[pyarg(positional)]
+        name: PyObjectRef,
+        #[pyarg(any, default)]
+        mode: Option<PyUtf8StrRef>,
+        #[pyarg(any, default = true)]
+        closefd: bool,
+        #[allow(dead_code)]
+        #[pyarg(any, default)]
+        opener: Option<PyObjectRef>,
+    }
+
+    impl Initializer for WindowsConsoleIO {
+        type Args = WindowsConsoleIOArgs;
+
+        fn init(zelf: PyRef<Self>, args: Self::Args, vm: &VirtualMachine) -> PyResult<()> {
+            let nameobj = args.name;
+
+            if zelf.fd.load() >= 0 {
+                if zelf.closefd.load() {
+                    internal_close(&zelf);
+                } else {
+                    zelf.fd.store(-1);
+                }
+            }
+
+            // Warn if bool is used as file descriptor
+            if nameobj.class().is(vm.ctx.types.bool_type) {
+                crate::stdlib::_warnings::warn(
+                    vm.ctx.exceptions.runtime_warning,
+                    "bool is used as a file descriptor".to_owned(),
+                    1,
+                    vm,
+                )?;
+            }
+
+            // Try to get fd from integer
+            let mut fd: i32 = -1;
+            if let Some(i) = nameobj.downcast_ref::<crate::builtins::PyInt>() {
+                fd = i.try_to_primitive::<i32>(vm).unwrap_or(-1);
+                if fd < 0 {
+                    return Err(vm.new_value_error("negative file descriptor"));
+                }
+            }
+
+            // Parse mode
+            let mode_str: &str = args
+                .mode
+                .as_ref()
+                .map(|s: &PyUtf8StrRef| s.as_str())
+                .unwrap_or("r");
+
+            let mut rwa = false;
+            let mut readable = false;
+            let mut writable = false;
+            let mut console_type = '\0';
+            for c in mode_str.bytes() {
+                match c {
+                    b'+' | b'a' | b'b' | b'x' => {}
+                    b'r' => {
+                        if rwa {
+                            return Err(
+                                vm.new_value_error("Must have exactly one of read or write mode")
+                            );
+                        }
+                        rwa = true;
+                        readable = true;
+                    }
+                    b'w' => {
+                        if rwa {
+                            return Err(
+                                vm.new_value_error("Must have exactly one of read or write mode")
+                            );
+                        }
+                        rwa = true;
+                        writable = true;
+                    }
+                    _ => {
+                        return Err(vm.new_value_error(format!("invalid mode: {mode_str}")));
+                    }
+                }
+            }
+            if !rwa {
+                return Err(vm.new_value_error("Must have exactly one of read or write mode"));
+            }
+
+            zelf.readable.store(readable);
+            zelf.writable.store(writable);
+
+            let mut _name_wide: Option<Vec<u16>> = None;
+
+            if fd < 0 {
+                // Get console type from name
+                console_type = pyio_get_console_type(&nameobj, vm);
+                if console_type == 'x' {
+                    if writable {
+                        console_type = 'w';
+                    } else {
+                        console_type = 'r';
+                    }
+                }
+
+                // Opening by name
+                zelf.closefd.store(true);
+                if !args.closefd {
+                    return Err(vm.new_value_error("Cannot use closefd=False with file name"));
+                }
+
+                let name_str = nameobj.str(vm)?;
+                let wide: Vec<u16> = name_str
+                    .as_wtf8()
+                    .encode_wide()
+                    .chain(core::iter::once(0))
+                    .collect();
+
+                let access = if writable {
+                    GENERIC_WRITE
+                } else {
+                    GENERIC_READ
+                };
+
+                // Try read/write first, fall back to specific access
+                let mut handle: HANDLE = unsafe {
+                    CreateFileW(
+                        wide.as_ptr(),
+                        GENERIC_READ | GENERIC_WRITE,
+                        FILE_SHARE_READ | FILE_SHARE_WRITE,
+                        core::ptr::null(),
+                        OPEN_EXISTING,
+                        0,
+                        core::ptr::null_mut(),
+                    )
+                };
+                if is_invalid_handle(handle) {
+                    handle = unsafe {
+                        CreateFileW(
+                            wide.as_ptr(),
+                            access,
+                            FILE_SHARE_READ | FILE_SHARE_WRITE,
+                            core::ptr::null(),
+                            OPEN_EXISTING,
+                            0,
+                            core::ptr::null_mut(),
+                        )
+                    };
+                }
+
+                if is_invalid_handle(handle) {
+                    return Err(std::io::Error::last_os_error().to_pyexception(vm));
+                }
+
+                let osf_flags = if writable {
+                    libc::O_WRONLY | libc::O_BINARY | 0x80 /* O_NOINHERIT */
+                } else {
+                    libc::O_RDONLY | libc::O_BINARY | 0x80 /* O_NOINHERIT */
+                };
+
+                fd = unsafe { libc::open_osfhandle(handle as isize, osf_flags) };
+                if fd < 0 {
+                    unsafe {
+                        Foundation::CloseHandle(handle);
+                    }
+                    return Err(std::io::Error::last_os_error().to_pyexception(vm));
+                }
+
+                _name_wide = Some(wide);
+            } else {
+                // When opened by fd, never close the fd (user owns it)
+                zelf.closefd.store(false);
+            }
+
+            zelf.fd.store(fd);
+
+            // Validate console type
+            if console_type == '\0' {
+                let handle = handle_from_fd(fd);
+                console_type = get_console_type(handle);
+            }
+
+            if console_type == '\0' {
+                // Not a console at all
+                internal_close(&zelf);
+                return Err(vm.new_value_error("Cannot open non-console file"));
+            }
+
+            if writable && console_type != 'w' {
+                internal_close(&zelf);
+                return Err(vm.new_value_error("Cannot open console input buffer for writing"));
+            }
+            if readable && console_type != 'r' {
+                internal_close(&zelf);
+                return Err(vm.new_value_error("Cannot open console output buffer for reading"));
+            }
+
+            zelf.blksize.store(super::DEFAULT_BUFFER_SIZE as _);
+            *zelf.buf.lock() = [0u8; SMALLBUF];
+
+            zelf.as_object().set_attr("name", nameobj, vm)?;
+
+            Ok(())
+        }
+    }
+
+    fn internal_close(zelf: &WindowsConsoleIO) {
+        let fd = zelf.fd.swap(-1);
+        if fd >= 0 && zelf.closefd.load() {
+            unsafe {
+                libc::close(fd);
+            }
+        }
+    }
+
+    impl Representable for WindowsConsoleIO {
+        #[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(format!("<{type_name} [closed]>"));
+            }
+            let mode = if zelf.readable.load() { "rb" } else { "wb" };
+            let closefd = if zelf.closefd.load() { "True" } else { "False" };
+            Ok(format!("<{type_name} mode='{mode}' closefd={closefd}>"))
+        }
+    }
+
+    #[pyclass(
+        with(Constructor, Initializer, Representable, Destructor),
+        flags(BASETYPE, HAS_DICT, HAS_WEAKREF)
+    )]
+    impl WindowsConsoleIO {
+        #[allow(dead_code)]
+        fn io_error(
+            zelf: &Py<Self>,
+            error: std::io::Error,
+            vm: &VirtualMachine,
+        ) -> PyBaseExceptionRef {
+            let exc = error.to_pyexception(vm);
+            if let Ok(name) = zelf.as_object().get_attr("name", vm) {
+                exc.as_object()
+                    .set_attr("filename", name, vm)
+                    .expect("OSError.filename set must succeed");
+            }
+            exc
+        }
+
+        #[pygetset]
+        fn closed(&self) -> bool {
+            self.fd.load() < 0
+        }
+
+        #[pygetset]
+        fn closefd(&self) -> bool {
+            self.closefd.load()
+        }
+
+        #[pygetset(name = "_blksize")]
+        fn blksize(&self) -> i64 {
+            self.blksize.load()
+        }
+
+        #[pygetset]
+        fn mode(&self) -> &'static str {
+            if self.readable.load() { "rb" } else { "wb" }
+        }
+
+        #[pymethod]
+        fn fileno(&self, vm: &VirtualMachine) -> PyResult<i32> {
+            let fd = self.fd.load();
+            if fd >= 0 {
+                Ok(fd)
+            } else {
+                Err(io_closed_error(vm))
+            }
+        }
+
+        fn get_fd(&self, vm: &VirtualMachine) -> PyResult<i32> {
+            self.fileno(vm)
+        }
+
+        #[pymethod]
+        fn readable(&self, vm: &VirtualMachine) -> PyResult<bool> {
+            if self.fd.load() < 0 {
+                return Err(io_closed_error(vm));
+            }
+            Ok(self.readable.load())
+        }
+
+        #[pymethod]
+        fn writable(&self, vm: &VirtualMachine) -> PyResult<bool> {
+            if self.fd.load() < 0 {
+                return Err(io_closed_error(vm));
+            }
+            Ok(self.writable.load())
+        }
+
+        #[pymethod]
+        fn isatty(&self, vm: &VirtualMachine) -> PyResult<bool> {
+            if self.fd.load() < 0 {
+                return Err(io_closed_error(vm));
+            }
+            Ok(true)
+        }
+
+        #[pymethod]
+        fn close(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<()> {
+            let res = iobase_close(zelf.as_object(), vm);
+            if !zelf.closefd.load() {
+                zelf.fd.store(-1);
+                return res;
+            }
+            let flush_exc = res.err();
+            if zelf.finalizing.load() {
+                Self::dealloc_warn(zelf, zelf.as_object().to_owned(), vm);
+            }
+            let fd = zelf.fd.swap(-1);
+            let close_err: Option<PyBaseExceptionRef> = if fd >= 0 {
+                let result = unsafe { libc::close(fd) };
+                if result < 0 {
+                    Some(std::io::Error::last_os_error().into_pyexception(vm))
+                } else {
+                    None
+                }
+            } else {
+                None
+            };
+            match (flush_exc, close_err) {
+                (Some(fe), Some(ce)) => {
+                    ce.set___context__(Some(fe));
+                    Err(ce)
+                }
+                (Some(e), None) | (None, Some(e)) => Err(e),
+                (None, None) => Ok(()),
+            }
+        }
+
+        fn dealloc_warn(zelf: &Py<Self>, source: PyObjectRef, vm: &VirtualMachine) {
+            if zelf.fd.load() >= 0 && zelf.closefd.load() {
+                let repr = source
+                    .repr(vm)
+                    .map(|s| s.as_wtf8().to_owned())
+                    .unwrap_or_else(|_| Wtf8Buf::from("<file>"));
+                if let Err(e) = crate::stdlib::_warnings::warn(
+                    vm.ctx.exceptions.resource_warning,
+                    format!("unclosed file {repr}"),
+                    1,
+                    vm,
+                ) {
+                    vm.run_unraisable(e, None, zelf.as_object().to_owned());
+                }
+            }
+        }
+
+        fn copy_from_buf(buf: &mut [u8; SMALLBUF], dest: &mut [u8]) -> usize {
+            let mut n = 0;
+            while buf[0] != 0 && n < dest.len() {
+                dest[n] = buf[0];
+                n += 1;
+                for i in 1..SMALLBUF {
+                    buf[i - 1] = buf[i];
+                }
+                buf[SMALLBUF - 1] = 0;
+            }
+            n
+        }
+
+        #[pymethod]
+        fn readinto(&self, buffer: ArgMemoryBuffer, vm: &VirtualMachine) -> PyResult<usize> {
+            let fd = self.get_fd(vm)?;
+            if !self.readable.load() {
+                return Err(new_unsupported_operation(
+                    vm,
+                    "Console buffer does not support reading".to_owned(),
+                ));
+            }
+            let mut buf_ref = buffer.borrow_buf_mut();
+            let len = buf_ref.len();
+            if len == 0 {
+                return Ok(0);
+            }
+            if len > BUFMAX {
+                return Err(vm.new_value_error(format!("cannot read more than {BUFMAX} bytes")));
+            }
+
+            let handle = handle_from_fd(fd);
+            if is_invalid_handle(handle) {
+                return Err(std::io::Error::last_os_error().to_pyexception(vm));
+            }
+
+            // Each character may take up to 4 bytes in UTF-8.
+            let mut wlen = (len / 4) as u32;
+            if wlen == 0 {
+                wlen = 1;
+            }
+
+            let dest = &mut *buf_ref;
+
+            // Copy from internal buffer first
+            let mut read_len = {
+                let mut buf = self.buf.lock();
+                Self::copy_from_buf(&mut buf, dest)
+            };
+            if read_len > 0 {
+                wlen = wlen.saturating_sub(1);
+            }
+            if read_len >= len || wlen == 0 {
+                return Ok(read_len);
+            }
+
+            // Read from console
+            let mut wbuf = vec![0u16; wlen as usize];
+            let mut nread: u32 = 0;
+            let res = unsafe {
+                ReadConsoleW(
+                    handle,
+                    wbuf.as_mut_ptr() as _,
+                    wlen,
+                    &mut nread,
+                    core::ptr::null(),
+                )
+            };
+            if res == 0 {
+                return Err(std::io::Error::last_os_error().into_pyexception(vm));
+            }
+            if nread == 0 {
+                return Ok(read_len);
+            }
+
+            // Check for Ctrl+Z (EOF)
+            if nread > 0 && wbuf[0] == 0x1A {
+                return Ok(read_len);
+            }
+
+            // Convert wchar to UTF-8
+            let remaining = len - read_len;
+            let u8n;
+            if remaining < 4 {
+                // Buffer the result in the internal small buffer
+                let mut buf = self.buf.lock();
+                let converted = unsafe {
+                    WideCharToMultiByte(
+                        CP_UTF8,
+                        0,
+                        wbuf.as_ptr(),
+                        nread as i32,
+                        buf.as_mut_ptr() as _,
+                        SMALLBUF as i32,
+                        core::ptr::null(),
+                        core::ptr::null_mut(),
+                    )
+                };
+                if converted > 0 {
+                    u8n = Self::copy_from_buf(&mut buf, &mut dest[read_len..]) as i32;
+                } else {
+                    u8n = 0;
+                }
+            } else {
+                u8n = unsafe {
+                    WideCharToMultiByte(
+                        CP_UTF8,
+                        0,
+                        wbuf.as_ptr(),
+                        nread as i32,
+                        dest[read_len..].as_mut_ptr() as _,
+                        remaining as i32,
+                        core::ptr::null(),
+                        core::ptr::null_mut(),
+                    )
+                };
+            }
+
+            if u8n > 0 {
+                read_len += u8n as usize;
+            } else {
+                let err = std::io::Error::last_os_error();
+                if err.raw_os_error() == Some(122) {
+                    // ERROR_INSUFFICIENT_BUFFER
+                    let needed = unsafe {
+                        WideCharToMultiByte(
+                            CP_UTF8,
+                            0,
+                            wbuf.as_ptr(),
+                            nread as i32,
+                            core::ptr::null_mut(),
+                            0,
+                            core::ptr::null(),
+                            core::ptr::null_mut(),
+                        )
+                    };
+                    if needed > 0 {
+                        return Err(vm.new_system_error(format!(
+                            "Buffer had room for {remaining} bytes but {needed} bytes required",
+                        )));
+                    }
+                }
+                return Err(err.into_pyexception(vm));
+            }
+
+            Ok(read_len)
+        }
+
+        #[pymethod]
+        fn readall(&self, vm: &VirtualMachine) -> PyResult<PyObjectRef> {
+            if self.fd.load() < 0 {
+                return Err(io_closed_error(vm));
+            }
+
+            let handle = handle_from_fd(self.fd.load());
+            if is_invalid_handle(handle) {
+                return Err(std::io::Error::last_os_error().to_pyexception(vm));
+            }
+
+            let mut result = Vec::new();
+
+            // Copy any buffered bytes first
+            {
+                let mut buf = self.buf.lock();
+                let mut tmp = [0u8; SMALLBUF];
+                let n = Self::copy_from_buf(&mut buf, &mut tmp);
+                result.extend_from_slice(&tmp[..n]);
+            }
+
+            let mut wbuf = vec![0u16; 8192];
+            loop {
+                let mut nread: u32 = 0;
+                let res = unsafe {
+                    ReadConsoleW(
+                        handle,
+                        wbuf.as_mut_ptr() as _,
+                        wbuf.len() as u32,
+                        &mut nread,
+                        core::ptr::null(),
+                    )
+                };
+                if res == 0 {
+                    return Err(std::io::Error::last_os_error().into_pyexception(vm));
+                }
+                if nread == 0 {
+                    break;
+                }
+                // Ctrl+Z at start -> EOF
+                if wbuf[0] == 0x1A {
+                    break;
+                }
+                // Convert to UTF-8
+                let needed = unsafe {
+                    WideCharToMultiByte(
+                        CP_UTF8,
+                        0,
+                        wbuf.as_ptr(),
+                        nread as i32,
+                        core::ptr::null_mut(),
+                        0,
+                        core::ptr::null(),
+                        core::ptr::null_mut(),
+                    )
+                };
+                if needed == 0 {
+                    return Err(std::io::Error::last_os_error().into_pyexception(vm));
+                }
+                let offset = result.len();
+                result.resize(offset + needed as usize, 0);
+                let written = unsafe {
+                    WideCharToMultiByte(
+                        CP_UTF8,
+                        0,
+                        wbuf.as_ptr(),
+                        nread as i32,
+                        result[offset..].as_mut_ptr() as _,
+                        needed,
+                        core::ptr::null(),
+                        core::ptr::null_mut(),
+                    )
+                };
+                if written == 0 {
+                    return Err(std::io::Error::last_os_error().into_pyexception(vm));
+                }
+                // If we didn't fill the buffer, no more data
+                if nread < wbuf.len() as u32 {
+                    break;
+                }
+            }
+
+            Ok(vm.ctx.new_bytes(result).into())
+        }
+
+        #[pymethod]
+        fn read(&self, size: OptionalArg<isize>, vm: &VirtualMachine) -> PyResult<PyObjectRef> {
+            if self.fd.load() < 0 {
+                return Err(io_closed_error(vm));
+            }
+            if !self.readable.load() {
+                return Err(new_unsupported_operation(
+                    vm,
+                    "Console buffer does not support reading".to_owned(),
+                ));
+            }
+            let size = size.unwrap_or(-1);
+            if size < 0 {
+                return self.readall(vm);
+            }
+            if size as usize > BUFMAX {
+                return Err(vm.new_value_error(format!("cannot read more than {BUFMAX} bytes")));
+            }
+            let mut buf = vec![0u8; size as usize];
+            let handle = handle_from_fd(self.fd.load());
+            if is_invalid_handle(handle) {
+                return Err(std::io::Error::last_os_error().to_pyexception(vm));
+            }
+
+            let len = size as usize;
+
+            let mut wlen = (len / 4) as u32;
+            if wlen == 0 {
+                wlen = 1;
+            }
+
+            let mut read_len = {
+                let mut ibuf = self.buf.lock();
+                Self::copy_from_buf(&mut ibuf, &mut buf)
+            };
+            if read_len > 0 {
+                wlen = wlen.saturating_sub(1);
+            }
+            if read_len >= len || wlen == 0 {
+                buf.truncate(read_len);
+                return Ok(vm.ctx.new_bytes(buf).into());
+            }
+
+            let mut wbuf = vec![0u16; wlen as usize];
+            let mut nread: u32 = 0;
+            let res = unsafe {
+                ReadConsoleW(
+                    handle,
+                    wbuf.as_mut_ptr() as _,
+                    wlen,
+                    &mut nread,
+                    core::ptr::null(),
+                )
+            };
+            if res == 0 {
+                return Err(std::io::Error::last_os_error().into_pyexception(vm));
+            }
+            if nread == 0 || wbuf[0] == 0x1A {
+                buf.truncate(read_len);
+                return Ok(vm.ctx.new_bytes(buf).into());
+            }
+
+            let remaining = len - read_len;
+            let u8n;
+            if remaining < 4 {
+                let mut ibuf = self.buf.lock();
+                let converted = unsafe {
+                    WideCharToMultiByte(
+                        CP_UTF8,
+                        0,
+                        wbuf.as_ptr(),
+                        nread as i32,
+                        ibuf.as_mut_ptr() as _,
+                        SMALLBUF as i32,
+                        core::ptr::null(),
+                        core::ptr::null_mut(),
+                    )
+                };
+                if converted > 0 {
+                    u8n = Self::copy_from_buf(&mut ibuf, &mut buf[read_len..]) as i32;
+                } else {
+                    u8n = 0;
+                }
+            } else {
+                u8n = unsafe {
+                    WideCharToMultiByte(
+                        CP_UTF8,
+                        0,
+                        wbuf.as_ptr(),
+                        nread as i32,
+                        buf[read_len..].as_mut_ptr() as _,
+                        remaining as i32,
+                        core::ptr::null(),
+                        core::ptr::null_mut(),
+                    )
+                };
+            }
+
+            if u8n > 0 {
+                read_len += u8n as usize;
+            } else {
+                let err = std::io::Error::last_os_error();
+                if err.raw_os_error() == Some(122) {
+                    // ERROR_INSUFFICIENT_BUFFER
+                    let needed = unsafe {
+                        WideCharToMultiByte(
+                            CP_UTF8,
+                            0,
+                            wbuf.as_ptr(),
+                            nread as i32,
+                            core::ptr::null_mut(),
+                            0,
+                            core::ptr::null(),
+                            core::ptr::null_mut(),
+                        )
+                    };
+                    if needed > 0 {
+                        return Err(vm.new_system_error(format!(
+                            "Buffer had room for {remaining} bytes but {needed} bytes required",
+                        )));
+                    }
+                }
+                return Err(err.into_pyexception(vm));
+            }
+
+            buf.truncate(read_len);
+            Ok(vm.ctx.new_bytes(buf).into())
+        }
+
+        #[pymethod]
+        fn write(&self, b: ArgBytesLike, vm: &VirtualMachine) -> PyResult<usize> {
+            if self.fd.load() < 0 {
+                return Err(io_closed_error(vm));
+            }
+            if !self.writable.load() {
+                return Err(new_unsupported_operation(
+                    vm,
+                    "Console buffer does not support writing".to_owned(),
+                ));
+            }
+
+            let handle = handle_from_fd(self.fd.load());
+            if is_invalid_handle(handle) {
+                return Err(std::io::Error::last_os_error().to_pyexception(vm));
+            }
+
+            let data = b.borrow_buf();
+            let data = &*data;
+            if data.is_empty() {
+                return Ok(0);
+            }
+
+            let mut len = data.len().min(BUFMAX);
+
+            // Cap at 32766/2 wchars * 3 bytes (UTF-8 to wchar ratio is at most 3:1)
+            let max_wlen: u32 = 32766 / 2;
+            len = len.min(max_wlen as usize * 3);
+
+            // Reduce len until wlen fits within max_wlen
+            let wlen;
+            loop {
+                len = find_last_utf8_boundary(data, len);
+                let w = unsafe {
+                    MultiByteToWideChar(
+                        CP_UTF8,
+                        0,
+                        data.as_ptr(),
+                        len as i32,
+                        core::ptr::null_mut(),
+                        0,
+                    )
+                };
+                if w as u32 <= max_wlen {
+                    wlen = w;
+                    break;
+                }
+                len /= 2;
+            }
+            if wlen == 0 {
+                return Ok(0);
+            }
+
+            let mut wbuf = vec![0u16; wlen as usize];
+            let wlen = unsafe {
+                MultiByteToWideChar(
+                    CP_UTF8,
+                    0,
+                    data.as_ptr(),
+                    len as i32,
+                    wbuf.as_mut_ptr(),
+                    wlen,
+                )
+            };
+            if wlen == 0 {
+                return Err(std::io::Error::last_os_error().into_pyexception(vm));
+            }
+
+            let mut n_written: u32 = 0;
+            let res = unsafe {
+                WriteConsoleW(
+                    handle,
+                    wbuf.as_ptr() as _,
+                    wlen as u32,
+                    &mut n_written,
+                    core::ptr::null(),
+                )
+            };
+            if res == 0 {
+                return Err(std::io::Error::last_os_error().into_pyexception(vm));
+            }
+
+            // If we wrote fewer wchars than expected, recalculate bytes consumed
+            if n_written < wlen as u32 {
+                // Binary search to find how many input bytes correspond to n_written wchars
+                len = wchar_to_utf8_count(data, len, n_written);
+            }
+
+            Ok(len)
+        }
+
+        #[pymethod(name = "__reduce__")]
+        fn reduce(_zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult {
+            Err(vm.new_type_error("cannot pickle '_WindowsConsoleIO' instances"))
+        }
+    }
+
+    /// Find how many UTF-8 bytes correspond to n wide chars.
+    fn wchar_to_utf8_count(data: &[u8], mut len: usize, mut n: u32) -> usize {
+        let mut start: usize = 0;
+        loop {
+            let mut mid = 0;
+            for i in (len / 2)..=len {
+                mid = find_last_utf8_boundary(data, i);
+                if mid != 0 {
+                    break;
+                }
+            }
+            if mid == len {
+                return start + len;
+            }
+            if mid == 0 {
+                mid = if len > 1 { len - 1 } else { 1 };
+            }
+            let wlen = unsafe {
+                MultiByteToWideChar(
+                    CP_UTF8,
+                    0,
+                    data[start..].as_ptr(),
+                    mid as i32,
+                    core::ptr::null_mut(),
+                    0,
+                )
+            } as u32;
+            if wlen <= n {
+                start += mid;
+                len -= mid;
+                n -= wlen;
+            } else {
+                len = mid;
+            }
+        }
+    }
+
+    impl Destructor for WindowsConsoleIO {
+        fn slot_del(zelf: &PyObject, vm: &VirtualMachine) -> PyResult<()> {
+            if let Some(cio) = zelf.downcast_ref::<WindowsConsoleIO>() {
+                cio.finalizing.store(true);
+            }
+            iobase_finalize(zelf, vm);
             Ok(())
         }
 
diff --git a/crates/vm/src/stdlib/operator.rs b/crates/vm/src/stdlib/_operator.rs
similarity index 87%
rename from crates/vm/src/stdlib/operator.rs
rename to crates/vm/src/stdlib/_operator.rs
index c5fa03a12d6..38b0f715d31 100644
--- a/crates/vm/src/stdlib/operator.rs
+++ b/crates/vm/src/stdlib/_operator.rs
@@ -4,8 +4,8 @@ pub(crate) use _operator::module_def;
 mod _operator {
     use crate::{
         AsObject, Py, PyObjectRef, PyPayload, PyRef, PyResult, VirtualMachine,
-        builtins::{PyInt, PyIntRef, PyStr, PyStrRef, PyTupleRef, PyType, PyTypeRef},
-        common::wtf8::Wtf8,
+        builtins::{PyInt, PyIntRef, PyStr, PyStrRef, PyTupleRef, PyType, PyTypeRef, PyUtf8StrRef},
+        common::wtf8::{Wtf8, Wtf8Buf},
         function::{ArgBytesLike, Either, FuncArgs, KwArgs, OptionalArg},
         protocol::PyIter,
         recursion::ReprGuard,
@@ -340,7 +340,8 @@ mod _operator {
         Ok(res)
     }
 
-    /// attrgetter(attr, ...) --> attrgetter object
+    /// attrgetter(attr, /, *attrs)
+    /// --
     ///
     /// Return a callable object that fetches the given attribute(s) from its operand.
     /// After f = attrgetter('name'), the call f(r) returns r.name.
@@ -356,6 +357,11 @@ mod _operator {
 
     #[pyclass(with(Callable, Constructor, Representable))]
     impl PyAttrGetter {
+        #[pygetset]
+        fn __text_signature__(&self) -> &'static str {
+            "(obj, /)"
+        }
+
         #[pymethod]
         fn __reduce__(zelf: PyRef<Self>, vm: &VirtualMachine) -> PyResult<(PyTypeRef, PyTupleRef)> {
             let attrs = vm
@@ -426,21 +432,27 @@ mod _operator {
 
     impl Representable for PyAttrGetter {
         #[inline]
-        fn repr_str(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<String> {
-            let fmt = if let Some(_guard) = ReprGuard::enter(vm, zelf.as_object()) {
-                let mut parts = Vec::with_capacity(zelf.attrs.len());
+        fn repr_wtf8(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<Wtf8Buf> {
+            let mut result = Wtf8Buf::from("operator.attrgetter(");
+            if let Some(_guard) = ReprGuard::enter(vm, zelf.as_object()) {
+                let mut first = true;
                 for part in &zelf.attrs {
-                    parts.push(part.as_object().repr(vm)?.as_str().to_owned());
+                    if !first {
+                        result.push_str(", ");
+                    }
+                    first = false;
+                    result.push_wtf8(part.as_object().repr(vm)?.as_wtf8());
                 }
-                parts.join(", ")
             } else {
-                "...".to_owned()
-            };
-            Ok(format!("operator.attrgetter({fmt})"))
+                result.push_str("...");
+            }
+            result.push_char(')');
+            Ok(result)
         }
     }
 
-    /// itemgetter(item, ...) --> itemgetter object
+    /// itemgetter(item, /, *items)
+    /// --
     ///
     /// Return a callable object that fetches the given item(s) from its operand.
     /// After f = itemgetter(2), the call f(r) returns r[2].
@@ -454,6 +466,11 @@ mod _operator {
 
     #[pyclass(with(Callable, Constructor, Representable))]
     impl PyItemGetter {
+        #[pygetset]
+        fn __text_signature__(&self) -> &'static str {
+            "(obj, /)"
+        }
+
         #[pymethod]
         fn __reduce__(zelf: PyRef<Self>, vm: &VirtualMachine) -> PyObjectRef {
             let items = vm.ctx.new_tuple(zelf.items.to_vec());
@@ -493,21 +510,27 @@ mod _operator {
 
     impl Representable for PyItemGetter {
         #[inline]
-        fn repr_str(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<String> {
-            let fmt = if let Some(_guard) = ReprGuard::enter(vm, zelf.as_object()) {
-                let mut items = Vec::with_capacity(zelf.items.len());
+        fn repr_wtf8(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<Wtf8Buf> {
+            let mut result = Wtf8Buf::from("operator.itemgetter(");
+            if let Some(_guard) = ReprGuard::enter(vm, zelf.as_object()) {
+                let mut first = true;
                 for item in &zelf.items {
-                    items.push(item.repr(vm)?.as_str().to_owned());
+                    if !first {
+                        result.push_str(", ");
+                    }
+                    first = false;
+                    result.push_wtf8(item.repr(vm)?.as_wtf8());
                 }
-                items.join(", ")
             } else {
-                "...".to_owned()
-            };
-            Ok(format!("operator.itemgetter({fmt})"))
+                result.push_str("...");
+            }
+            result.push_char(')');
+            Ok(result)
         }
     }
 
-    /// methodcaller(name, ...) --> methodcaller object
+    /// methodcaller(name, /, *args, **kwargs)
+    /// --
     ///
     /// Return a callable object that calls the given method on its operand.
     /// After f = methodcaller('name'), the call f(r) returns r.name().
@@ -517,12 +540,17 @@ mod _operator {
     #[pyclass(name = "methodcaller")]
     #[derive(Debug, PyPayload)]
     struct PyMethodCaller {
-        name: PyStrRef,
+        name: PyUtf8StrRef,
         args: FuncArgs,
     }
 
     #[pyclass(with(Callable, Constructor, Representable))]
     impl PyMethodCaller {
+        #[pygetset]
+        fn __text_signature__(&self) -> &'static str {
+            "(obj, /)"
+        }
+
         #[pymethod]
         fn __reduce__(zelf: PyRef<Self>, vm: &VirtualMachine) -> PyResult<PyTupleRef> {
             // With no kwargs, return (type(obj), (name, *args)) tuple.
@@ -552,11 +580,10 @@ mod _operator {
             (name, args): Self::Args,
             vm: &VirtualMachine,
         ) -> PyResult<Self> {
-            if let Ok(name) = name.try_into_value(vm) {
-                Ok(Self { name, args })
-            } else {
-                Err(vm.new_type_error("method name must be a string"))
-            }
+            let name = name
+                .try_into_value(vm)
+                .map_err(|_| vm.new_type_error("method name must be a string"))?;
+            Ok(Self { name, args })
         }
     }
 
@@ -571,32 +598,27 @@ mod _operator {
 
     impl Representable for PyMethodCaller {
         #[inline]
-        fn repr_str(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<String> {
-            let fmt = if let Some(_guard) = ReprGuard::enter(vm, zelf.as_object()) {
+        fn repr_wtf8(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<Wtf8Buf> {
+            let mut result = Wtf8Buf::from("operator.methodcaller(");
+            if let Some(_guard) = ReprGuard::enter(vm, zelf.as_object()) {
                 let args = &zelf.args.args;
                 let kwargs = &zelf.args.kwargs;
-                let mut fmt = vec![zelf.name.as_object().repr(vm)?.as_str().to_owned()];
-                if !args.is_empty() {
-                    let mut parts = Vec::with_capacity(args.len());
-                    for v in args {
-                        parts.push(v.repr(vm)?.as_str().to_owned());
-                    }
-                    fmt.push(parts.join(", "));
+                result.push_wtf8(zelf.name.as_object().repr(vm)?.as_wtf8());
+                for v in args {
+                    result.push_str(", ");
+                    result.push_wtf8(v.repr(vm)?.as_wtf8());
                 }
-                // build name=value pairs from KwArgs.
-                if !kwargs.is_empty() {
-                    let mut parts = Vec::with_capacity(kwargs.len());
-                    for (key, value) in kwargs {
-                        let value_repr = value.repr(vm)?;
-                        parts.push(format!("{key}={value_repr}"));
-                    }
-                    fmt.push(parts.join(", "));
+                for (key, value) in kwargs {
+                    result.push_str(", ");
+                    result.push_str(key);
+                    result.push_char('=');
+                    result.push_wtf8(value.repr(vm)?.as_wtf8());
                 }
-                fmt.join(", ")
             } else {
-                "...".to_owned()
-            };
-            Ok(format!("operator.methodcaller({fmt})"))
+                result.push_str("...");
+            }
+            result.push_char(')');
+            Ok(result)
         }
     }
 }
diff --git a/crates/vm/src/stdlib/signal.rs b/crates/vm/src/stdlib/_signal.rs
similarity index 90%
rename from crates/vm/src/stdlib/signal.rs
rename to crates/vm/src/stdlib/_signal.rs
index 231fae75376..a69d766ce51 100644
--- a/crates/vm/src/stdlib/signal.rs
+++ b/crates/vm/src/stdlib/_signal.rs
@@ -28,7 +28,7 @@ pub(crate) mod _signal {
             static WAKEUP: atomic::AtomicUsize = atomic::AtomicUsize::new(INVALID_WAKEUP);
             // windows doesn't use the same fds for files and sockets like windows does, so we need
             // this to know whether to send() or write()
-            static WAKEUP_IS_SOCKET: std::sync::atomic::AtomicBool = std::sync::atomic::AtomicBool::new(false);
+            static WAKEUP_IS_SOCKET: core::sync::atomic::AtomicBool = core::sync::atomic::AtomicBool::new(false);
 
             impl<'a> TryFromBorrowedObject<'a> for WakeupFd {
                 fn try_from_borrowed_object(vm: &VirtualMachine, obj: &'a crate::PyObject) -> PyResult<Self> {
@@ -101,6 +101,10 @@ pub(crate) mod _signal {
     #[pyattr]
     pub use libc::{SIGABRT, SIGFPE, SIGILL, SIGINT, SIGSEGV, SIGTERM};
 
+    #[cfg(windows)]
+    #[pyattr]
+    const SIGBREAK: i32 = 21; // _SIGBREAK
+
     // Windows-specific control events for GenerateConsoleCtrlEvent
     #[cfg(windows)]
     #[pyattr]
@@ -173,7 +177,9 @@ pub(crate) mod _signal {
                 } else {
                     None
                 };
-                vm.signal_handlers.as_deref().unwrap().borrow_mut()[signum] = py_handler;
+                vm.signal_handlers
+                    .get_or_init(signal::new_signal_handlers)
+                    .borrow_mut()[signum] = py_handler;
             }
 
             let int_handler = module
@@ -201,10 +207,24 @@ pub(crate) mod _signal {
         vm: &VirtualMachine,
     ) -> PyResult<Option<PyObjectRef>> {
         signal::assert_in_range(signalnum, vm)?;
-        let signal_handlers = vm
-            .signal_handlers
-            .as_deref()
-            .ok_or_else(|| vm.new_value_error("signal only works in main thread"))?;
+        #[cfg(windows)]
+        {
+            const VALID_SIGNALS: &[i32] = &[
+                libc::SIGINT,
+                libc::SIGILL,
+                libc::SIGFPE,
+                libc::SIGSEGV,
+                libc::SIGTERM,
+                SIGBREAK,
+                libc::SIGABRT,
+            ];
+            if !VALID_SIGNALS.contains(&signalnum) {
+                return Err(vm.new_value_error(format!("signal number {} out of range", signalnum)));
+            }
+        }
+        if !vm.is_main_thread() {
+            return Err(vm.new_value_error("signal only works in main thread"));
+        }
 
         let sig_handler =
             match usize::try_from_borrowed_object(vm, &handler).ok() {
@@ -226,6 +246,7 @@ pub(crate) mod _signal {
             siginterrupt(signalnum, 1);
         }
 
+        let signal_handlers = vm.signal_handlers.get_or_init(signal::new_signal_handlers);
         let old_handler = signal_handlers.borrow_mut()[signalnum as usize].replace(handler);
         Ok(old_handler)
     }
@@ -233,10 +254,7 @@ pub(crate) mod _signal {
     #[pyfunction]
     fn getsignal(signalnum: i32, vm: &VirtualMachine) -> PyResult {
         signal::assert_in_range(signalnum, vm)?;
-        let signal_handlers = vm
-            .signal_handlers
-            .as_deref()
-            .ok_or_else(|| vm.new_value_error("getsignal only works in main thread"))?;
+        let signal_handlers = vm.signal_handlers.get_or_init(signal::new_signal_handlers);
         let handler = signal_handlers.borrow()[signalnum as usize]
             .clone()
             .unwrap_or_else(|| vm.ctx.none());
@@ -305,7 +323,7 @@ pub(crate) mod _signal {
         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()));
+            return Err(vm.new_exception_msg(itimer_error, err.to_string().into()));
         }
         let old = unsafe { old.assume_init() };
         Ok(itimerval_to_tuple(&old))
@@ -322,7 +340,7 @@ pub(crate) mod _signal {
         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()));
+            return Err(vm.new_exception_msg(itimer_error, err.to_string().into()));
         }
         let old = unsafe { old.assume_init() };
         Ok(itimerval_to_tuple(&old))
@@ -353,8 +371,8 @@ pub(crate) mod _signal {
         #[cfg(not(windows))]
         let fd = args.fd;
 
-        if vm.signal_handlers.is_none() {
-            return Err(vm.new_value_error("signal only works in main thread"));
+        if !vm.is_main_thread() {
+            return Err(vm.new_value_error("set_wakeup_fd only works in main thread"));
         }
 
         #[cfg(windows)]
@@ -363,7 +381,7 @@ pub(crate) mod _signal {
 
             crate::windows::init_winsock();
             let mut res = 0i32;
-            let mut res_size = std::mem::size_of::<i32>() as i32;
+            let mut res_size = core::mem::size_of::<i32>() as i32;
             let res = unsafe {
                 WinSock::getsockopt(
                     fd,
@@ -383,8 +401,7 @@ pub(crate) mod _signal {
                 }
                 // Validate that fd is a valid file descriptor using fstat
                 // First check if SOCKET can be safely cast to i32 (file descriptor)
-                let fd_i32 =
-                    i32::try_from(fd).map_err(|_| vm.new_value_error("invalid fd".to_owned()))?;
+                let fd_i32 = i32::try_from(fd).map_err(|_| vm.new_value_error("invalid fd"))?;
                 // Verify the fd is valid by trying to fstat it
                 let borrowed_fd =
                     unsafe { crate::common::crt_fd::Borrowed::try_borrow_raw(fd_i32) }
@@ -440,7 +457,7 @@ pub(crate) mod _signal {
         if let OptionalArg::Present(obj) = siginfo
             && !vm.is_none(&obj)
         {
-            return Err(vm.new_type_error("siginfo must be None".to_owned()));
+            return Err(vm.new_type_error("siginfo must be None"));
         }
 
         let flags = flags.unwrap_or(0);
@@ -449,7 +466,7 @@ pub(crate) mod _signal {
                 libc::SYS_pidfd_send_signal,
                 pidfd,
                 sig,
-                std::ptr::null::<libc::siginfo_t>(),
+                core::ptr::null::<libc::siginfo_t>(),
                 flags,
             ) as libc::c_long
         };
@@ -482,18 +499,20 @@ pub(crate) mod _signal {
         // On Windows, only certain signals are supported
         #[cfg(windows)]
         {
-            use crate::convert::IntoPyException;
-            // Windows supports: SIGINT(2), SIGILL(4), SIGFPE(8), SIGSEGV(11), SIGTERM(15), SIGABRT(22)
+            // Windows supports: SIGINT(2), SIGILL(4), SIGFPE(8), SIGSEGV(11), SIGTERM(15), SIGBREAK(21), SIGABRT(22)
             const VALID_SIGNALS: &[i32] = &[
                 libc::SIGINT,
                 libc::SIGILL,
                 libc::SIGFPE,
                 libc::SIGSEGV,
                 libc::SIGTERM,
+                SIGBREAK,
                 libc::SIGABRT,
             ];
             if !VALID_SIGNALS.contains(&signalnum) {
-                return Err(std::io::Error::from_raw_os_error(libc::EINVAL).into_pyexception(vm));
+                return Err(vm
+                    .new_errno_error(libc::EINVAL, "Invalid argument")
+                    .upcast());
             }
         }
 
@@ -537,6 +556,7 @@ pub(crate) mod _signal {
             libc::SIGFPE => "Floating-point exception",
             libc::SIGSEGV => "Segmentation fault",
             libc::SIGTERM => "Terminated",
+            SIGBREAK => "Break",
             libc::SIGABRT => "Aborted",
             _ => return Ok(None),
         };
@@ -573,6 +593,7 @@ pub(crate) mod _signal {
                 libc::SIGFPE,
                 libc::SIGSEGV,
                 libc::SIGTERM,
+                SIGBREAK,
                 libc::SIGABRT,
             ] {
                 set.add(vm.ctx.new_int(signum).into(), vm)?;
@@ -659,6 +680,14 @@ pub(crate) mod _signal {
     pub extern "C" fn run_signal(signum: i32) {
         signal::TRIGGERS[signum as usize].store(true, Ordering::Relaxed);
         signal::set_triggered();
+        #[cfg(windows)]
+        if signum == libc::SIGINT
+            && let Some(handle) = signal::get_sigint_event()
+        {
+            unsafe {
+                windows_sys::Win32::System::Threading::SetEvent(handle as _);
+            }
+        }
         let wakeup_fd = WAKEUP.load(Ordering::Relaxed);
         if wakeup_fd != INVALID_WAKEUP {
             let sigbyte = signum as u8;
@@ -679,6 +708,13 @@ pub(crate) mod _signal {
         }
     }
 
+    /// Reset wakeup fd after fork in child process.
+    /// The child must not write to the parent's wakeup fd.
+    #[cfg(unix)]
+    pub(crate) fn clear_wakeup_fd_after_fork() {
+        WAKEUP.store(INVALID_WAKEUP, Ordering::Relaxed);
+    }
+
     pub(crate) fn module_exec(
         vm: &VirtualMachine,
         module: &Py<crate::builtins::PyModule>,
diff --git a/crates/vm/src/stdlib/sre.rs b/crates/vm/src/stdlib/_sre.rs
similarity index 95%
rename from crates/vm/src/stdlib/sre.rs
rename to crates/vm/src/stdlib/_sre.rs
index 692b9754214..ba7044fb5a9 100644
--- a/crates/vm/src/stdlib/sre.rs
+++ b/crates/vm/src/stdlib/_sre.rs
@@ -9,7 +9,7 @@ mod _sre {
             PyCallableIterator, PyDictRef, PyGenericAlias, PyInt, PyList, PyListRef, PyStr,
             PyStrRef, PyTuple, PyTupleRef, PyTypeRef,
         },
-        common::wtf8::{Wtf8, Wtf8Buf},
+        common::wtf8::{Wtf8, Wtf8Buf, wtf8_concat},
         common::{ascii, hash::PyHash},
         convert::ToPyObject,
         function::{ArgCallable, OptionalArg, PosArgs, PyComparisonValue},
@@ -190,7 +190,7 @@ mod _sre {
     }
 
     #[pyattr]
-    #[pyclass(name = "Pattern")]
+    #[pyclass(module = "re", name = "Pattern")]
     #[derive(Debug, PyPayload)]
     pub(crate) struct Pattern {
         pub pattern: PyObjectRef,
@@ -212,7 +212,7 @@ mod _sre {
         };
     }
 
-    #[pyclass(with(Hashable, Comparable, Representable))]
+    #[pyclass(with(Hashable, Comparable, Representable), flags(HAS_WEAKREF))]
     impl Pattern {
         fn with_str<F, R>(string: &PyObject, vm: &VirtualMachine, f: F) -> PyResult<R>
         where
@@ -552,7 +552,7 @@ mod _sre {
 
     impl Representable for Pattern {
         #[inline]
-        fn repr_str(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<String> {
+        fn repr_wtf8(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<Wtf8Buf> {
             let flag_names = [
                 ("re.IGNORECASE", SreFlag::IGNORECASE),
                 ("re.LOCALE", SreFlag::LOCALE),
@@ -580,24 +580,24 @@ mod _sre {
                 .join("|");
 
             let pattern = zelf.pattern.repr(vm)?;
-            let truncated: String;
-            let s = if pattern.char_len() > 200 {
-                truncated = pattern.as_str().chars().take(200).collect();
-                &truncated
+            let mut result = Wtf8Buf::from("re.compile(");
+            let pat = if pattern.char_len() > 200 {
+                pattern.as_wtf8().code_points().take(200).collect()
             } else {
-                pattern.as_str()
+                pattern.as_wtf8().to_owned()
             };
-
-            if flags.is_empty() {
-                Ok(format!("re.compile({s})"))
-            } else {
-                Ok(format!("re.compile({s}, {flags})"))
+            result.push_wtf8(&pat);
+            if !flags.is_empty() {
+                result.push_str(", ");
+                result.push_str(&flags);
             }
+            result.push_char(')');
+            Ok(result)
         }
     }
 
     #[pyattr]
-    #[pyclass(name = "Match")]
+    #[pyclass(module = "re", name = "Match")]
     #[derive(Debug, PyPayload)]
     pub(crate) struct Match {
         string: PyObjectRef,
@@ -836,8 +836,8 @@ mod _sre {
 
     impl AsMapping for Match {
         fn as_mapping() -> &'static PyMappingMethods {
-            static AS_MAPPING: std::sync::LazyLock<PyMappingMethods> =
-                std::sync::LazyLock::new(|| PyMappingMethods {
+            static AS_MAPPING: crate::common::lock::LazyLock<PyMappingMethods> =
+                crate::common::lock::LazyLock::new(|| PyMappingMethods {
                     subscript: atomic_func!(|mapping, needle, vm| {
                         Match::mapping_downcast(mapping)
                             .__getitem__(needle.to_owned(), vm)
@@ -851,13 +851,17 @@ mod _sre {
 
     impl Representable for Match {
         #[inline]
-        fn repr_str(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<String> {
+        fn repr_wtf8(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<Wtf8Buf> {
             with_sre_str!(zelf.pattern, &zelf.string, vm, |str_drive| {
-                Ok(format!(
-                    "<re.Match object; span=({}, {}), match={}>",
+                let match_repr = zelf.get_slice(0, str_drive, vm).unwrap().repr(vm)?;
+                Ok(wtf8_concat!(
+                    "<re.Match object; span=(",
                     zelf.regs[0].0,
+                    ", ",
                     zelf.regs[0].1,
-                    zelf.get_slice(0, str_drive, vm).unwrap().repr(vm)?
+                    "), match=",
+                    match_repr.as_wtf8(),
+                    '>',
                 ))
             })
         }
diff --git a/crates/vm/src/stdlib/stat.rs b/crates/vm/src/stdlib/_stat.rs
similarity index 100%
rename from crates/vm/src/stdlib/stat.rs
rename to crates/vm/src/stdlib/_stat.rs
diff --git a/crates/vm/src/stdlib/string.rs b/crates/vm/src/stdlib/_string.rs
similarity index 100%
rename from crates/vm/src/stdlib/string.rs
rename to crates/vm/src/stdlib/_string.rs
diff --git a/crates/vm/src/stdlib/symtable.rs b/crates/vm/src/stdlib/_symtable.rs
similarity index 88%
rename from crates/vm/src/stdlib/symtable.rs
rename to crates/vm/src/stdlib/_symtable.rs
index 881c5519843..299e006bdce 100644
--- a/crates/vm/src/stdlib/symtable.rs
+++ b/crates/vm/src/stdlib/_symtable.rs
@@ -3,9 +3,10 @@ pub(crate) use _symtable::module_def;
 #[pymodule]
 mod _symtable {
     use crate::{
-        PyObjectRef, PyPayload, PyRef, PyResult, VirtualMachine,
-        builtins::{PyDictRef, PyStrRef},
+        Py, PyObjectRef, PyPayload, PyRef, PyResult, VirtualMachine,
+        builtins::{PyDictRef, PyUtf8StrRef},
         compiler,
+        types::Representable,
     };
     use alloc::fmt;
     use rustpython_codegen::symboltable::{
@@ -110,9 +111,9 @@ mod _symtable {
 
     #[pyfunction]
     fn symtable(
-        source: PyStrRef,
-        filename: PyStrRef,
-        mode: PyStrRef,
+        source: PyUtf8StrRef,
+        filename: PyUtf8StrRef,
+        mode: PyUtf8StrRef,
         vm: &VirtualMachine,
     ) -> PyResult<PyRef<PySymbolTable>> {
         let mode = mode
@@ -132,7 +133,7 @@ mod _symtable {
     }
 
     #[pyattr]
-    #[pyclass(name = "SymbolTable")]
+    #[pyclass(name = "symtable entry")]
     #[derive(PyPayload)]
     struct PySymbolTable {
         symtable: SymbolTable,
@@ -144,7 +145,7 @@ mod _symtable {
         }
     }
 
-    #[pyclass]
+    #[pyclass(with(Representable))]
     impl PySymbolTable {
         #[pygetset]
         fn name(&self) -> String {
@@ -173,6 +174,14 @@ mod _symtable {
                 .symtable
                 .sub_tables
                 .iter()
+                .flat_map(|t| {
+                    if t.comp_inlined {
+                        // Flatten: replace inlined comprehension tables with their children
+                        t.sub_tables.iter().collect::<Vec<_>>()
+                    } else {
+                        vec![t]
+                    }
+                })
                 .map(|t| to_py_symbol_table(t.clone()).into_pyobject(vm))
                 .collect();
             Ok(children)
@@ -210,6 +219,19 @@ mod _symtable {
         }
     }
 
+    impl Representable for PySymbolTable {
+        #[inline]
+        fn repr_str(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<String> {
+            Ok(format!(
+                "<{} {}({}), line {}>",
+                Self::class(&vm.ctx).name(),
+                zelf.symtable.name,
+                zelf.id(),
+                zelf.symtable.line_number
+            ))
+        }
+    }
+
     #[pyattr]
     #[pyclass(name = "Symbol")]
     #[derive(PyPayload)]
diff --git a/crates/vm/src/stdlib/sysconfig.rs b/crates/vm/src/stdlib/_sysconfig.rs
similarity index 82%
rename from crates/vm/src/stdlib/sysconfig.rs
rename to crates/vm/src/stdlib/_sysconfig.rs
index 724e1bcf979..2de27d71ac9 100644
--- a/crates/vm/src/stdlib/sysconfig.rs
+++ b/crates/vm/src/stdlib/_sysconfig.rs
@@ -15,10 +15,9 @@ pub(crate) mod _sysconfig {
             .unwrap();
         vars.set_item("SOABI", vm.ctx.none(), vm).unwrap();
 
-        vars.set_item("Py_GIL_DISABLED", true.to_pyobject(vm), vm)
-            .unwrap();
-        vars.set_item("Py_DEBUG", false.to_pyobject(vm), vm)
+        vars.set_item("Py_GIL_DISABLED", (1).to_pyobject(vm), vm)
             .unwrap();
+        vars.set_item("Py_DEBUG", (0).to_pyobject(vm), vm).unwrap();
 
         vars
     }
diff --git a/crates/vm/src/stdlib/sysconfigdata.rs b/crates/vm/src/stdlib/_sysconfigdata.rs
similarity index 83%
rename from crates/vm/src/stdlib/sysconfigdata.rs
rename to crates/vm/src/stdlib/_sysconfigdata.rs
index a10745a8cad..99aab892e1c 100644
--- a/crates/vm/src/stdlib/sysconfigdata.rs
+++ b/crates/vm/src/stdlib/_sysconfigdata.rs
@@ -14,6 +14,14 @@ mod _sysconfigdata {
     fn module_exec(vm: &VirtualMachine, module: &Py<PyModule>) -> PyResult<()> {
         // Set build_time_vars attribute
         let build_time_vars = build_time_vars(vm);
+
+        // Add runtime-dependent values needed by sysconfig
+        let paths = &vm.state.config.paths;
+        build_time_vars.set_item("prefix", paths.prefix.clone().to_pyobject(vm), vm)?;
+        build_time_vars.set_item("exec_prefix", paths.exec_prefix.clone().to_pyobject(vm), vm)?;
+        let bindir = format!("{}/bin", &paths.exec_prefix);
+        build_time_vars.set_item("BINDIR", bindir.to_pyobject(vm), vm)?;
+
         module.set_attr("build_time_vars", build_time_vars, vm)?;
 
         // Ensure the module is registered under the platform-specific name
@@ -43,6 +51,8 @@ mod _sysconfigdata {
             "HAVE_GETRANDOM" => 1,
             // RustPython has no GIL (like free-threaded Python)
             "Py_GIL_DISABLED" => 1,
+            "Py_DEBUG" => 0,
+            "ABIFLAGS" => "t",
             // Compiler configuration for native extension builds
             "CC" => "cc",
             "CXX" => "c++",
diff --git a/crates/vm/src/stdlib/thread.rs b/crates/vm/src/stdlib/_thread.rs
similarity index 53%
rename from crates/vm/src/stdlib/thread.rs
rename to crates/vm/src/stdlib/_thread.rs
index 22457b3f17f..765f2537440 100644
--- a/crates/vm/src/stdlib/thread.rs
+++ b/crates/vm/src/stdlib/_thread.rs
@@ -1,9 +1,10 @@
 //! Implementation of the _thread module
 #[cfg(unix)]
 pub(crate) use _thread::after_fork_child;
+pub use _thread::get_ident;
 #[cfg_attr(target_arch = "wasm32", allow(unused_imports))]
 pub(crate) use _thread::{
-    CurrentFrameSlot, HandleEntry, RawRMutex, ShutdownEntry, get_all_current_frames, get_ident,
+    CurrentFrameSlot, HandleEntry, RawRMutex, ShutdownEntry, get_all_current_frames,
     init_main_thread_ident, module_def,
 };
 
@@ -11,18 +12,22 @@ pub(crate) use _thread::{
 pub(crate) mod _thread {
     use crate::{
         AsObject, Py, PyPayload, PyRef, PyResult, VirtualMachine,
-        builtins::{PyDictRef, PyStr, PyStrRef, PyTupleRef, PyType, PyTypeRef},
+        builtins::{PyDictRef, PyStr, PyTupleRef, PyType, PyTypeRef, PyUtf8StrRef},
+        common::wtf8::Wtf8Buf,
         frame::FrameRef,
-        function::{ArgCallable, Either, FuncArgs, KwArgs, OptionalArg, PySetterValue},
+        function::{ArgCallable, FuncArgs, KwArgs, OptionalArg, PySetterValue, TimeoutSeconds},
         types::{Constructor, GetAttr, Representable, SetAttr},
     };
-    use alloc::fmt;
+    use alloc::{
+        fmt,
+        sync::{Arc, Weak},
+    };
     use core::{cell::RefCell, time::Duration};
-    use crossbeam_utils::atomic::AtomicCell;
     use parking_lot::{
         RawMutex, RawThreadId,
         lock_api::{RawMutex as RawMutexT, RawMutexTimed, RawReentrantMutex},
     };
+    use rustpython_common::str::levenshtein::{MOVE_COST, levenshtein_distance};
     use std::thread;
 
     // PYTHREAD_NAME: show current thread name
@@ -60,36 +65,29 @@ pub(crate) mod _thread {
     struct AcquireArgs {
         #[pyarg(any, default = true)]
         blocking: bool,
-        #[pyarg(any, default = Either::A(-1.0))]
-        timeout: Either<f64, i64>,
+        #[pyarg(any, default = TimeoutSeconds::new(-1.0))]
+        timeout: TimeoutSeconds,
     }
 
     macro_rules! acquire_lock_impl {
         ($mu:expr, $args:expr, $vm:expr) => {{
             let (mu, args, vm) = ($mu, $args, $vm);
-            let timeout = match args.timeout {
-                Either::A(f) => f,
-                Either::B(i) => i as f64,
-            };
+            let timeout = args.timeout.to_secs_f64();
             match args.blocking {
                 true if timeout == -1.0 => {
-                    mu.lock();
+                    vm.allow_threads(|| mu.lock());
                     Ok(true)
                 }
                 true if timeout < 0.0 => {
-                    Err(vm.new_value_error("timeout value must be positive".to_owned()))
+                    Err(vm
+                        .new_value_error("timeout value must be a non-negative number".to_owned()))
                 }
                 true => {
-                    // modified from std::time::Duration::from_secs_f64 to avoid a panic.
-                    // TODO: put this in the Duration::try_from_object impl, maybe?
-                    let nanos = timeout * 1_000_000_000.0;
-                    if timeout > TIMEOUT_MAX as f64 || nanos < 0.0 || !nanos.is_finite() {
-                        return Err(vm.new_overflow_error(
-                            "timestamp too large to convert to Rust Duration".to_owned(),
-                        ));
+                    if timeout > TIMEOUT_MAX {
+                        return Err(vm.new_overflow_error("timeout value is too large".to_owned()));
                     }
 
-                    Ok(mu.try_lock_for(Duration::from_secs_f64(timeout)))
+                    Ok(vm.allow_threads(|| mu.try_lock_for(Duration::from_secs_f64(timeout))))
                 }
                 false if timeout != -1.0 => Err(vm
                     .new_value_error("can't specify a timeout for a non-blocking call".to_owned())),
@@ -127,7 +125,7 @@ pub(crate) mod _thread {
         }
     }
 
-    #[pyclass(with(Constructor, Representable))]
+    #[pyclass(with(Constructor, Representable), flags(HAS_WEAKREF))]
     impl Lock {
         #[pymethod]
         #[pymethod(name = "acquire_lock")]
@@ -145,23 +143,12 @@ pub(crate) mod _thread {
             Ok(())
         }
 
+        #[cfg(unix)]
         #[pymethod]
         fn _at_fork_reinit(&self, _vm: &VirtualMachine) -> PyResult<()> {
-            if self.mu.is_locked() {
-                unsafe {
-                    self.mu.unlock();
-                };
-            }
-            // Casting to AtomicCell is as unsafe as CPython code.
-            // Using AtomicCell will prevent compiler optimizer move it to somewhere later unsafe place.
-            // It will be not under the cell anymore after init call.
-
-            let new_mut = RawMutex::INIT;
-            unsafe {
-                let old_mutex: &AtomicCell<RawMutex> = core::mem::transmute(&self.mu);
-                old_mutex.swap(new_mut);
-            }
-
+            // Overwrite lock state to unlocked. Do NOT call unlock() here —
+            // after fork(), unlock_slow() would try to unpark stale waiters.
+            unsafe { rustpython_common::lock::zero_reinit_after_fork(&self.mu) };
             Ok(())
         }
 
@@ -206,7 +193,7 @@ pub(crate) mod _thread {
         }
     }
 
-    #[pyclass(with(Representable), flags(BASETYPE))]
+    #[pyclass(with(Representable), flags(BASETYPE, HAS_WEAKREF))]
     impl RLock {
         #[pyslot]
         fn slot_new(cls: PyTypeRef, _args: FuncArgs, vm: &VirtualMachine) -> PyResult {
@@ -222,43 +209,42 @@ pub(crate) mod _thread {
         #[pymethod(name = "acquire_lock")]
         #[pymethod(name = "__enter__")]
         fn acquire(&self, args: AcquireArgs, vm: &VirtualMachine) -> PyResult<bool> {
-            let result = acquire_lock_impl!(&self.mu, args, vm)?;
-            if result {
+            if self.mu.is_owned_by_current_thread() {
+                // Re-entrant acquisition: just increment our count.
+                // parking_lot stays at 1 level; we track recursion ourselves.
                 self.count
                     .fetch_add(1, core::sync::atomic::Ordering::Relaxed);
+                return Ok(true);
+            }
+            let result = acquire_lock_impl!(&self.mu, args, vm)?;
+            if result {
+                self.count.store(1, core::sync::atomic::Ordering::Relaxed);
             }
             Ok(result)
         }
         #[pymethod]
         #[pymethod(name = "release_lock")]
         fn release(&self, vm: &VirtualMachine) -> PyResult<()> {
-            if !self.mu.is_locked() {
-                return Err(vm.new_runtime_error("release unlocked lock"));
+            if !self.mu.is_owned_by_current_thread() {
+                return Err(vm.new_runtime_error("cannot release un-acquired lock"));
             }
-            debug_assert!(
-                self.count.load(core::sync::atomic::Ordering::Relaxed) > 0,
-                "RLock count underflow"
-            );
-            self.count
+            let prev = self
+                .count
                 .fetch_sub(1, core::sync::atomic::Ordering::Relaxed);
-            unsafe { self.mu.unlock() };
+            debug_assert!(prev > 0, "RLock count underflow");
+            if prev == 1 {
+                unsafe { self.mu.unlock() };
+            }
             Ok(())
         }
 
+        #[cfg(unix)]
         #[pymethod]
         fn _at_fork_reinit(&self, _vm: &VirtualMachine) -> PyResult<()> {
-            if self.mu.is_locked() {
-                unsafe {
-                    self.mu.unlock();
-                };
-            }
+            // Overwrite lock state to unlocked. Do NOT call unlock() here —
+            // after fork(), unlock_slow() would try to unpark stale waiters.
             self.count.store(0, core::sync::atomic::Ordering::Relaxed);
-            let new_mut = RawRMutex::INIT;
-            unsafe {
-                let old_mutex: &AtomicCell<RawRMutex> = core::mem::transmute(&self.mu);
-                old_mutex.swap(new_mut);
-            }
-
+            unsafe { rustpython_common::lock::zero_reinit_after_fork(&self.mu) };
             Ok(())
         }
 
@@ -281,6 +267,35 @@ pub(crate) mod _thread {
             }
         }
 
+        #[pymethod]
+        fn _release_save(&self, vm: &VirtualMachine) -> PyResult<(usize, u64)> {
+            if !self.mu.is_owned_by_current_thread() {
+                return Err(vm.new_runtime_error("cannot release un-acquired lock"));
+            }
+            let count = self.count.swap(0, core::sync::atomic::Ordering::Relaxed);
+            debug_assert!(count > 0, "RLock count underflow");
+            unsafe { self.mu.unlock() };
+            Ok((count, current_thread_id()))
+        }
+
+        #[pymethod]
+        fn _acquire_restore(&self, state: PyTupleRef, vm: &VirtualMachine) -> PyResult<()> {
+            let [count_obj, owner_obj] = state.as_slice() else {
+                return Err(
+                    vm.new_type_error("_acquire_restore() argument 1 must be a 2-item tuple")
+                );
+            };
+            let count: usize = count_obj.clone().try_into_value(vm)?;
+            let _owner: u64 = owner_obj.clone().try_into_value(vm)?;
+            if count == 0 {
+                return Ok(());
+            }
+            vm.allow_threads(|| self.mu.lock());
+            self.count
+                .store(count, core::sync::atomic::Ordering::Relaxed);
+            Ok(())
+        }
+
         #[pymethod]
         fn __exit__(&self, _args: FuncArgs, vm: &VirtualMachine) -> PyResult<()> {
             self.release(vm)
@@ -290,7 +305,19 @@ pub(crate) mod _thread {
     impl Representable for RLock {
         #[inline]
         fn repr_str(zelf: &Py<Self>, _vm: &VirtualMachine) -> PyResult<String> {
-            repr_lock_impl!(zelf)
+            let count = zelf.count.load(core::sync::atomic::Ordering::Relaxed);
+            let status = if zelf.mu.is_locked() {
+                "locked"
+            } else {
+                "unlocked"
+            };
+            Ok(format!(
+                "<{} {} object count={} at {:#x}>",
+                status,
+                zelf.class().name(),
+                count,
+                zelf.get_id()
+            ))
         }
     }
 
@@ -300,12 +327,69 @@ pub(crate) mod _thread {
         current_thread_id()
     }
 
+    #[cfg(all(unix, feature = "threading"))]
+    #[pyfunction]
+    fn _stop_the_world_stats(vm: &VirtualMachine) -> PyResult<PyDictRef> {
+        let stats = vm.state.stop_the_world.stats_snapshot();
+        let d = vm.ctx.new_dict();
+        d.set_item("stop_calls", vm.ctx.new_int(stats.stop_calls).into(), vm)?;
+        d.set_item(
+            "last_wait_ns",
+            vm.ctx.new_int(stats.last_wait_ns).into(),
+            vm,
+        )?;
+        d.set_item(
+            "total_wait_ns",
+            vm.ctx.new_int(stats.total_wait_ns).into(),
+            vm,
+        )?;
+        d.set_item("max_wait_ns", vm.ctx.new_int(stats.max_wait_ns).into(), vm)?;
+        d.set_item("poll_loops", vm.ctx.new_int(stats.poll_loops).into(), vm)?;
+        d.set_item(
+            "attached_seen",
+            vm.ctx.new_int(stats.attached_seen).into(),
+            vm,
+        )?;
+        d.set_item(
+            "forced_parks",
+            vm.ctx.new_int(stats.forced_parks).into(),
+            vm,
+        )?;
+        d.set_item(
+            "suspend_notifications",
+            vm.ctx.new_int(stats.suspend_notifications).into(),
+            vm,
+        )?;
+        d.set_item(
+            "attach_wait_yields",
+            vm.ctx.new_int(stats.attach_wait_yields).into(),
+            vm,
+        )?;
+        d.set_item(
+            "suspend_wait_yields",
+            vm.ctx.new_int(stats.suspend_wait_yields).into(),
+            vm,
+        )?;
+        d.set_item(
+            "world_stopped",
+            vm.ctx.new_bool(stats.world_stopped).into(),
+            vm,
+        )?;
+        Ok(d)
+    }
+
+    #[cfg(all(unix, feature = "threading"))]
+    #[pyfunction]
+    fn _stop_the_world_reset_stats(vm: &VirtualMachine) {
+        vm.state.stop_the_world.reset_stats();
+    }
+
     /// Set the name of the current thread
     #[pyfunction]
-    fn set_name(name: PyStrRef) {
+    fn set_name(name: PyUtf8StrRef) {
         #[cfg(target_os = "linux")]
         {
-            use std::ffi::CString;
+            use alloc::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.
@@ -322,7 +406,7 @@ pub(crate) mod _thread {
         }
         #[cfg(target_os = "macos")]
         {
-            use std::ffi::CString;
+            use alloc::ffi::CString;
             if let Ok(c_name) = CString::new(name.as_str()) {
                 unsafe {
                     libc::pthread_setname_np(c_name.as_ptr());
@@ -345,7 +429,7 @@ pub(crate) mod _thread {
     /// 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
+        // pthread_self() for fork compatibility
         unsafe { libc::pthread_self() as u64 }
     }
 
@@ -397,12 +481,68 @@ pub(crate) mod _thread {
     }
 
     #[pyfunction]
-    fn start_new_thread(
-        func: ArgCallable,
-        args: PyTupleRef,
-        kwargs: OptionalArg<PyDictRef>,
-        vm: &VirtualMachine,
-    ) -> PyResult<u64> {
+    fn start_new_thread(mut f_args: FuncArgs, vm: &VirtualMachine) -> PyResult<u64> {
+        if !f_args.kwargs.is_empty() {
+            return Err(vm.new_type_error("start_new_thread() takes no keyword arguments"));
+        }
+        let given = f_args.args.len();
+        if given < 2 {
+            return Err(vm.new_type_error(format!(
+                "start_new_thread expected at least 2 arguments, got {given}"
+            )));
+        }
+        if given > 3 {
+            return Err(vm.new_type_error(format!(
+                "start_new_thread expected at most 3 arguments, got {given}"
+            )));
+        }
+
+        let func_obj = f_args.take_positional().unwrap();
+        let args_obj = f_args.take_positional().unwrap();
+        let kwargs_obj = f_args.take_positional();
+
+        if func_obj.to_callable().is_none() {
+            return Err(vm.new_type_error("first arg must be callable"));
+        }
+        if !args_obj.fast_isinstance(vm.ctx.types.tuple_type) {
+            return Err(vm.new_type_error("2nd arg must be a tuple"));
+        }
+        if kwargs_obj
+            .as_ref()
+            .is_some_and(|obj| !obj.fast_isinstance(vm.ctx.types.dict_type))
+        {
+            return Err(vm.new_type_error("optional 3rd arg must be a dictionary"));
+        }
+
+        let func: ArgCallable = func_obj.clone().try_into_value(vm)?;
+        let args: PyTupleRef = args_obj.clone().try_into_value(vm)?;
+        let kwargs: Option<PyDictRef> = kwargs_obj.map(|obj| obj.try_into_value(vm)).transpose()?;
+
+        vm.sys_module.get_attr("audit", vm)?.call(
+            (
+                "_thread.start_new_thread",
+                func_obj,
+                args_obj,
+                kwargs
+                    .as_ref()
+                    .map_or_else(|| vm.ctx.none(), |k| k.clone().into()),
+            ),
+            vm,
+        )?;
+
+        if vm
+            .state
+            .finalizing
+            .load(core::sync::atomic::Ordering::Acquire)
+        {
+            return Err(vm.new_exception_msg(
+                vm.ctx.exceptions.python_finalization_error.to_owned(),
+                "can't create new thread at interpreter shutdown"
+                    .to_owned()
+                    .into(),
+            ));
+        }
+
         let args = FuncArgs::new(
             args.to_vec(),
             kwargs
@@ -422,7 +562,7 @@ pub(crate) mod _thread {
                     .make_spawn_func(move |vm| run_thread(func, args, vm)),
             )
             .map(|handle| thread_to_id(&handle))
-            .map_err(|err| vm.new_runtime_error(format!("can't start new thread: {err}")))
+            .map_err(|_err| vm.new_runtime_error("can't start new thread"))
     }
 
     fn run_thread(func: ArgCallable, args: FuncArgs, vm: &VirtualMachine) {
@@ -463,7 +603,7 @@ pub(crate) mod _thread {
         });
     }
 
-    #[cfg(not(target_arch = "wasm32"))]
+    #[cfg(all(not(target_arch = "wasm32"), feature = "host_env"))]
     #[pyfunction]
     fn interrupt_main(signum: OptionalArg<i32>, vm: &VirtualMachine) -> PyResult<()> {
         crate::signal::set_interrupt_ex(signum.unwrap_or(libc::SIGINT), vm)
@@ -503,8 +643,8 @@ pub(crate) mod _thread {
 
     // 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)>,
+        Weak<parking_lot::Mutex<ThreadHandleInner>>,
+        Weak<(parking_lot::Mutex<bool>, parking_lot::Condvar)>,
     );
 
     #[pyfunction]
@@ -540,14 +680,17 @@ pub(crate) mod _thread {
             };
 
             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);
+                Some((inner, done_event)) => {
+                    if let Err(exc) = ThreadHandle::join_internal(&inner, &done_event, None, vm) {
+                        vm.run_unraisable(
+                            exc,
+                            Some(
+                                "Exception ignored while joining a thread in _thread._shutdown()"
+                                    .to_owned(),
+                            ),
+                            vm.ctx.none(),
+                        );
+                        return;
                     }
                 }
                 None => break, // No more threads to wait on
@@ -558,14 +701,29 @@ pub(crate) mod _thread {
     /// 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)>,
+        inner: &Arc<parking_lot::Mutex<ThreadHandleInner>>,
+        done_event: &Arc<(parking_lot::Mutex<bool>, parking_lot::Condvar)>,
+    ) {
+        let mut handles = vm.state.shutdown_handles.lock();
+        handles.push((Arc::downgrade(inner), Arc::downgrade(done_event)));
+    }
+
+    fn remove_from_shutdown_handles(
+        vm: &VirtualMachine,
+        inner: &Arc<parking_lot::Mutex<ThreadHandleInner>>,
+        done_event: &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),
-        ));
+        handles.retain(|(inner_weak, done_event_weak): &ShutdownEntry| {
+            let Some(registered_inner) = inner_weak.upgrade() else {
+                return false;
+            };
+            let Some(registered_done_event) = done_event_weak.upgrade() else {
+                return false;
+            };
+            !(Arc::ptr_eq(&registered_inner, inner)
+                && Arc::ptr_eq(&registered_done_event, done_event))
+        });
     }
 
     #[pyfunction]
@@ -658,9 +816,7 @@ pub(crate) mod _thread {
     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(),
-            )
+            vm.new_type_error("_thread._excepthook argument type must be _ExceptHookArgs")
         })?;
 
         let exc_type = args.exc_type.clone();
@@ -697,11 +853,11 @@ pub(crate) mod _thread {
                 .get_attr("name", vm)
                 .ok()
                 .and_then(|n| n.str(vm).ok())
-                .map(|s| s.as_str().to_owned())
+                .map(|s| s.as_wtf8().to_owned())
         } else {
             None
         };
-        let name = thread_name.unwrap_or_else(|| format!("{}", get_ident()));
+        let name = thread_name.unwrap_or_else(|| Wtf8Buf::from(format!("{}", get_ident())));
 
         let _ = vm.call_method(
             &file,
@@ -731,12 +887,12 @@ pub(crate) mod _thread {
     // 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()) };
+        static LOCAL_GUARDS: RefCell<Vec<LocalGuard>> = const { RefCell::new(Vec::new()) };
     }
 
     // Guard that removes thread-local data when dropped
     struct LocalGuard {
-        local: std::sync::Weak<LocalData>,
+        local: Weak<LocalData>,
         thread_id: std::thread::ThreadId,
     }
 
@@ -756,8 +912,8 @@ pub(crate) mod _thread {
         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 {
+    impl fmt::Debug for LocalData {
+        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
             f.debug_struct("LocalData").finish_non_exhaustive()
         }
     }
@@ -766,7 +922,7 @@ pub(crate) mod _thread {
     #[pyclass(module = "_thread", name = "_local")]
     #[derive(Debug, PyPayload)]
     struct Local {
-        inner: std::sync::Arc<LocalData>,
+        inner: Arc<LocalData>,
     }
 
     #[pyclass(with(GetAttr, SetAttr), flags(BASETYPE))]
@@ -797,7 +953,7 @@ pub(crate) mod _thread {
             // Register cleanup guard only if we inserted a new entry
             if need_guard {
                 let guard = LocalGuard {
-                    local: std::sync::Arc::downgrade(&self.inner),
+                    local: Arc::downgrade(&self.inner),
                     thread_id,
                 };
                 LOCAL_GUARDS.with(|guards| {
@@ -811,7 +967,7 @@ pub(crate) mod _thread {
         #[pyslot]
         fn slot_new(cls: PyTypeRef, _args: FuncArgs, vm: &VirtualMachine) -> PyResult {
             Self {
-                inner: std::sync::Arc::new(LocalData {
+                inner: Arc::new(LocalData {
                     data: parking_lot::Mutex::new(std::collections::HashMap::new()),
                 }),
             }
@@ -823,7 +979,7 @@ pub(crate) mod _thread {
     impl GetAttr for Local {
         fn getattro(zelf: &Py<Self>, attr: &Py<PyStr>, vm: &VirtualMachine) -> PyResult {
             let l_dict = zelf.l_dict(vm);
-            if attr.as_str() == "__dict__" {
+            if attr.as_bytes() == b"__dict__" {
                 Ok(l_dict.into())
             } else {
                 zelf.as_object()
@@ -846,7 +1002,7 @@ pub(crate) mod _thread {
             value: PySetterValue,
             vm: &VirtualMachine,
         ) -> PyResult<()> {
-            if attr.as_str() == "__dict__" {
+            if attr.as_bytes() == b"__dict__" {
                 Err(vm.new_attribute_error(format!(
                     "{} attribute '__dict__' is read-only",
                     zelf.class().name()
@@ -866,24 +1022,34 @@ 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)>,
+        Weak<parking_lot::Mutex<ThreadHandleInner>>,
+        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().
+    /// Get all threads' current (top) 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)))
+            .filter_map(|(id, slot)| {
+                let frames = slot.frames.lock();
+                // SAFETY: the owning thread can't pop while we hold the Mutex,
+                // so the FramePtr is valid for the duration of the lock.
+                frames
+                    .last()
+                    .map(|fp| (*id, unsafe { fp.as_ref() }.to_owned()))
+            })
             .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.
+    ///
+    /// Precondition: `reinit_locks_after_fork()` has already been called, so all
+    /// parking_lot-based locks in VmState are in unlocked state.
     #[cfg(unix)]
     pub fn after_fork_child(vm: &VirtualMachine) {
         let current_ident = get_ident();
@@ -891,29 +1057,27 @@ pub(crate) mod _thread {
         // 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
+        // Reinitialize frame slot for current thread.
+        // Locks are already reinit'd, so lock() is safe.
         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
+        // Clean up thread handles. All VmState locks were reinit'd to unlocked,
+        // so lock() won't deadlock. Per-thread Arc<Mutex<ThreadHandleInner>>
+        // locks are also reinit'd below before use.
+        {
+            let mut handles = vm.state.thread_handles.lock();
             handles.retain(|(inner_weak, done_event_weak): &HandleEntry| {
                 let Some(inner) = inner_weak.upgrade() else {
-                    return false; // Remove dead entries
+                    return false;
                 };
                 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;
-                };
+                // Reinit this per-handle lock in case a dead thread held it
+                reinit_parking_lot_mutex(&inner);
+                let mut inner_guard = inner.lock();
 
-                // Skip current thread and not-started threads
                 if inner_guard.ident == current_ident {
                     return true;
                 }
@@ -921,67 +1085,60 @@ pub(crate) mod _thread {
                     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
+                inner_guard.join_handle = None;
                 drop(inner_guard);
 
-                // Try to notify waiters - skip if we can't acquire the lock
+                // Reinit and set the done event
                 let (lock, cvar) = &*done_event;
-                if let Some(mut done) = lock.try_lock() {
-                    *done = true;
-                    cvar.notify_all();
-                }
+                reinit_parking_lot_mutex(lock);
+                *lock.lock() = true;
+                cvar.notify_all();
 
                 true
             });
         }
 
-        // Clean up shutdown_handles as well.
-        // This is critical to prevent _shutdown() from waiting on threads
-        // that don't exist in the child process after fork.
-        if let Some(mut handles) = vm.state.shutdown_handles.try_lock() {
-            // Mark all non-current threads as done in shutdown_handles
+        // Clean up shutdown_handles.
+        {
+            let mut handles = vm.state.shutdown_handles.lock();
             handles.retain(|(inner_weak, done_event_weak): &ShutdownEntry| {
                 let Some(inner) = inner_weak.upgrade() else {
-                    return false; // Remove dead entries
+                    return false;
                 };
                 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;
-                };
+                reinit_parking_lot_mutex(&inner);
+                let mut inner_guard = inner.lock();
 
-                // Skip current thread
                 if inner_guard.ident == current_ident {
                     return true;
                 }
-
-                // Keep handles for threads that have not been started yet.
-                // They are safe to start in the child process.
                 if inner_guard.state == ThreadHandleState::NotStarted {
                     return true;
                 }
 
-                // Mark as done so _shutdown() won't wait on it
                 inner_guard.state = ThreadHandleState::Done;
                 drop(inner_guard);
 
-                // Notify waiters
                 let (lock, cvar) = &*done_event;
-                if let Some(mut done) = lock.try_lock() {
-                    *done = true;
-                    cvar.notify_all();
-                }
+                reinit_parking_lot_mutex(lock);
+                *lock.lock() = true;
+                cvar.notify_all();
 
-                false // Remove from shutdown_handles - these threads don't exist in child
+                false
             });
         }
     }
 
+    /// Reset a parking_lot::Mutex to unlocked state after fork.
+    #[cfg(unix)]
+    fn reinit_parking_lot_mutex<T: ?Sized>(mutex: &parking_lot::Mutex<T>) {
+        unsafe { rustpython_common::lock::zero_reinit_after_fork(mutex.raw()) };
+    }
+
     // Thread handle state enum
     #[derive(Debug, Clone, Copy, PartialEq, Eq)]
     pub enum ThreadHandleState {
@@ -1017,15 +1174,15 @@ pub(crate) mod _thread {
     #[pyclass(module = "_thread", name = "_ThreadHandle")]
     #[derive(Debug, PyPayload)]
     struct ThreadHandle {
-        inner: std::sync::Arc<parking_lot::Mutex<ThreadHandleInner>>,
+        inner: 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)>,
+        done_event: Arc<(parking_lot::Mutex<bool>, parking_lot::Condvar)>,
     }
 
-    #[pyclass]
+    #[pyclass(with(Representable))]
     impl ThreadHandle {
         fn new(vm: &VirtualMachine) -> Self {
-            let inner = std::sync::Arc::new(parking_lot::Mutex::new(ThreadHandleInner {
+            let inner = Arc::new(parking_lot::Mutex::new(ThreadHandleInner {
                 state: ThreadHandleState::NotStarted,
                 ident: 0,
                 join_handle: None,
@@ -1033,121 +1190,265 @@ pub(crate) mod _thread {
                 joined: false,
             }));
             let done_event =
-                std::sync::Arc::new((parking_lot::Mutex::new(false), parking_lot::Condvar::new()));
+                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),
-            ));
+            vm.state
+                .thread_handles
+                .lock()
+                .push((Arc::downgrade(&inner), 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>>>,
+        fn join_internal(
+            inner: &Arc<parking_lot::Mutex<ThreadHandleInner>>,
+            done_event: &Arc<(parking_lot::Mutex<bool>, parking_lot::Condvar)>,
+            timeout_duration: Option<Duration>,
             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,
-            };
+            Self::check_started(inner, vm)?;
 
-            // 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()));
-                }
-            }
+            let deadline =
+                timeout_duration.and_then(|timeout| std::time::Instant::now().checked_add(timeout));
 
             // Wait for thread completion using Condvar (supports timeout)
             // Loop to handle spurious wakeups
-            let (lock, cvar) = &*self.done_event;
+            let (lock, cvar) = &**done_event;
             let mut done = lock.lock();
 
+            // ThreadHandle_join semantics: self-join/finalizing checks
+            // apply only while target thread has not reported it is exiting yet.
+            if !*done {
+                let inner_guard = inner.lock();
+                let current_ident = get_ident();
+                if inner_guard.ident == current_ident
+                    && inner_guard.state == ThreadHandleState::Running
+                {
+                    return Err(vm.new_runtime_error("Cannot join current thread"));
+                }
+                if vm
+                    .state
+                    .finalizing
+                    .load(core::sync::atomic::Ordering::Acquire)
+                {
+                    return Err(vm.new_exception_msg(
+                        vm.ctx.exceptions.python_finalization_error.to_owned(),
+                        "cannot join thread at interpreter shutdown"
+                            .to_owned()
+                            .into(),
+                    ));
+                }
+            }
+
             while !*done {
                 if let Some(timeout) = timeout_duration {
-                    let result = cvar.wait_for(&mut done, timeout);
+                    let remaining = deadline.map_or(timeout, |deadline| {
+                        deadline.saturating_duration_since(std::time::Instant::now())
+                    });
+                    if remaining.is_zero() {
+                        return Ok(());
+                    }
+                    let result = vm.allow_threads(|| cvar.wait_for(&mut done, remaining));
                     if result.timed_out() && !*done {
                         // Timeout occurred and done is still false
                         return Ok(());
                     }
                 } else {
                     // Infinite wait
-                    cvar.wait(&mut done);
+                    vm.allow_threads(|| cvar.wait(&mut done));
                 }
             }
             drop(done);
 
             // Thread is done, now perform cleanup
             let join_handle = {
-                let mut inner = self.inner.lock();
+                let mut inner_guard = inner.lock();
 
                 // If already joined, return immediately (idempotent)
-                if inner.joined {
+                if inner_guard.joined {
                     return Ok(());
                 }
 
                 // If another thread is already joining, wait for them to finish
-                if inner.joining {
-                    drop(inner);
+                if inner_guard.joining {
+                    drop(inner_guard);
                     // Wait on done_event
-                    let (lock, cvar) = &*self.done_event;
+                    let (lock, cvar) = &**done_event;
                     let mut done = lock.lock();
                     while !*done {
-                        cvar.wait(&mut done);
+                        vm.allow_threads(|| cvar.wait(&mut done));
                     }
                     return Ok(());
                 }
 
                 // Mark that we're joining
-                inner.joining = true;
+                inner_guard.joining = true;
 
                 // Take the join handle if available
-                inner.join_handle.take()
+                inner_guard.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();
+                let _ = vm.allow_threads(|| handle.join());
             }
 
             // Mark as joined and clear joining flag
             {
-                let mut inner = self.inner.lock();
-                inner.joined = true;
-                inner.joining = false;
+                let mut inner_guard = inner.lock();
+                inner_guard.joined = true;
+                inner_guard.joining = false;
+            }
+
+            Ok(())
+        }
+
+        fn check_started(
+            inner: &Arc<parking_lot::Mutex<ThreadHandleInner>>,
+            vm: &VirtualMachine,
+        ) -> PyResult<()> {
+            let state = inner.lock().state;
+            if matches!(
+                state,
+                ThreadHandleState::NotStarted | ThreadHandleState::Starting
+            ) {
+                return Err(vm.new_runtime_error("thread not started"));
+            }
+            Ok(())
+        }
+
+        fn set_done_internal(
+            inner: &Arc<parking_lot::Mutex<ThreadHandleInner>>,
+            done_event: &Arc<(parking_lot::Mutex<bool>, parking_lot::Condvar)>,
+            vm: &VirtualMachine,
+        ) -> PyResult<()> {
+            Self::check_started(inner, vm)?;
+            {
+                let mut inner_guard = inner.lock();
+                inner_guard.state = ThreadHandleState::Done;
+                // _set_done() detach path. Dropping the JoinHandle
+                // detaches the underlying Rust thread.
+                inner_guard.join_handle = None;
+                inner_guard.joining = false;
+                inner_guard.joined = true;
             }
+            remove_from_shutdown_handles(vm, inner, done_event);
 
+            let (lock, cvar) = &**done_event;
+            *lock.lock() = true;
+            cvar.notify_all();
             Ok(())
         }
 
+        fn parse_join_timeout(
+            timeout_obj: Option<crate::PyObjectRef>,
+            vm: &VirtualMachine,
+        ) -> PyResult<Option<Duration>> {
+            const JOIN_TIMEOUT_MAX_SECONDS: i64 = TIMEOUT_MAX_IN_MICROSECONDS / 1_000_000;
+            let Some(timeout_obj) = timeout_obj else {
+                return Ok(None);
+            };
+
+            if let Some(t) = timeout_obj.try_index_opt(vm) {
+                let t: i64 = t?.try_to_primitive(vm).map_err(|_| {
+                    vm.new_overflow_error("timestamp too large to convert to C PyTime_t")
+                })?;
+                if !(-JOIN_TIMEOUT_MAX_SECONDS..=JOIN_TIMEOUT_MAX_SECONDS).contains(&t) {
+                    return Err(
+                        vm.new_overflow_error("timestamp too large to convert to C PyTime_t")
+                    );
+                }
+                if t < 0 {
+                    return Ok(None);
+                }
+                return Ok(Some(Duration::from_secs(t as u64)));
+            }
+
+            if let Some(t) = timeout_obj.try_float_opt(vm) {
+                let t = t?.to_f64();
+                if t.is_nan() {
+                    return Err(vm.new_value_error("Invalid value NaN (not a number)"));
+                }
+                if !t.is_finite() || !(-TIMEOUT_MAX..=TIMEOUT_MAX).contains(&t) {
+                    return Err(vm.new_overflow_error("timestamp out of range for platform time_t"));
+                }
+                if t < 0.0 {
+                    return Ok(None);
+                }
+                return Ok(Some(Duration::from_secs_f64(t)));
+            }
+
+            Err(vm.new_type_error(format!(
+                "'{}' object cannot be interpreted as an integer or float",
+                timeout_obj.class().name()
+            )))
+        }
+
+        #[pygetset]
+        fn ident(&self) -> u64 {
+            self.inner.lock().ident
+        }
+
+        #[pymethod]
+        fn is_done(&self, f_args: FuncArgs, vm: &VirtualMachine) -> PyResult<bool> {
+            if !f_args.kwargs.is_empty() {
+                return Err(vm.new_type_error("_ThreadHandle.is_done() takes no keyword arguments"));
+            }
+            let given = f_args.args.len();
+            if given != 0 {
+                return Err(vm.new_type_error(format!(
+                    "_ThreadHandle.is_done() takes no arguments ({given} given)"
+                )));
+            }
+
+            // If completion was observed, perform one-time join cleanup
+            // before returning True.
+            let done = {
+                let (lock, _) = &*self.done_event;
+                *lock.lock()
+            };
+            if !done {
+                return Ok(false);
+            }
+            Self::join_internal(&self.inner, &self.done_event, Some(Duration::ZERO), vm)?;
+            Ok(true)
+        }
+
+        #[pymethod]
+        fn _set_done(&self, f_args: FuncArgs, vm: &VirtualMachine) -> PyResult<()> {
+            if !f_args.kwargs.is_empty() {
+                return Err(
+                    vm.new_type_error("_ThreadHandle._set_done() takes no keyword arguments")
+                );
+            }
+            let given = f_args.args.len();
+            if given != 0 {
+                return Err(vm.new_type_error(format!(
+                    "_ThreadHandle._set_done() takes no arguments ({given} given)"
+                )));
+            }
+
+            Self::set_done_internal(&self.inner, &self.done_event, vm)
+        }
+
+        #[pymethod]
+        fn join(&self, mut f_args: FuncArgs, vm: &VirtualMachine) -> PyResult<()> {
+            if !f_args.kwargs.is_empty() {
+                return Err(vm.new_type_error("_ThreadHandle.join() takes no keyword arguments"));
+            }
+            let given = f_args.args.len();
+            if given > 1 {
+                return Err(
+                    vm.new_type_error(format!("join() takes at most 1 argument ({given} given)"))
+                );
+            }
+            let timeout = f_args.take_positional().filter(|obj| !vm.is_none(obj));
+            let timeout_duration = Self::parse_join_timeout(timeout, vm)?;
+            Self::join_internal(&self.inner, &self.done_event, timeout_duration, vm)
+        }
+
         #[pyslot]
         fn slot_new(cls: PyTypeRef, _args: FuncArgs, vm: &VirtualMachine) -> PyResult {
             ThreadHandle::new(vm)
@@ -1156,38 +1457,174 @@ pub(crate) mod _thread {
         }
     }
 
-    #[derive(FromArgs)]
-    struct StartJoinableThreadArgs {
-        #[pyarg(positional)]
-        function: ArgCallable,
-        #[pyarg(any, optional)]
-        handle: OptionalArg<PyRef<ThreadHandle>>,
-        #[pyarg(any, default = true)]
-        daemon: bool,
+    impl Representable for ThreadHandle {
+        fn repr_str(zelf: &Py<Self>, _vm: &VirtualMachine) -> PyResult<String> {
+            let ident = zelf.inner.lock().ident;
+            Ok(format!(
+                "<{} object: ident={ident}>",
+                zelf.class().slot_name()
+            ))
+        }
     }
 
     #[pyfunction]
     fn start_joinable_thread(
-        args: StartJoinableThreadArgs,
+        mut f_args: FuncArgs,
         vm: &VirtualMachine,
     ) -> PyResult<PyRef<ThreadHandle>> {
-        let handle = match args.handle {
-            OptionalArg::Present(h) => h,
-            OptionalArg::Missing => ThreadHandle::new(vm).into_ref(&vm.ctx),
+        let given = f_args.args.len() + f_args.kwargs.len();
+        if given > 3 {
+            return Err(vm.new_type_error(format!(
+                "start_joinable_thread() takes at most 3 arguments ({given} given)"
+            )));
+        }
+
+        let function_pos = f_args.take_positional();
+        let function_kw = f_args.take_keyword("function");
+        if function_pos.is_some() && function_kw.is_some() {
+            return Err(vm.new_type_error(
+                "argument for start_joinable_thread() given by name ('function') and position (1)",
+            ));
+        }
+        let Some(function_obj) = function_pos.or(function_kw) else {
+            return Err(vm.new_type_error(
+                "start_joinable_thread() missing required argument 'function' (pos 1)",
+            ));
+        };
+
+        let handle_pos = f_args.take_positional();
+        let handle_kw = f_args.take_keyword("handle");
+        if handle_pos.is_some() && handle_kw.is_some() {
+            return Err(vm.new_type_error(
+                "argument for start_joinable_thread() given by name ('handle') and position (2)",
+            ));
+        }
+        let handle_obj = handle_pos.or(handle_kw);
+
+        let daemon_pos = f_args.take_positional();
+        let daemon_kw = f_args.take_keyword("daemon");
+        if daemon_pos.is_some() && daemon_kw.is_some() {
+            return Err(vm.new_type_error(
+                "argument for start_joinable_thread() given by name ('daemon') and position (3)",
+            ));
+        }
+        let daemon = daemon_pos
+            .or(daemon_kw)
+            .map_or(Ok(true), |obj| obj.try_to_bool(vm))?;
+
+        // Match CPython parser precedence:
+        // - required positional/keyword argument errors are raised before
+        //   unknown keyword errors when `function` is missing.
+        if let Some(unexpected) = f_args.kwargs.keys().next() {
+            let suggestion = ["function", "handle", "daemon"]
+                .iter()
+                .filter_map(|candidate| {
+                    let max_distance = (unexpected.len() + candidate.len() + 3) * MOVE_COST / 6;
+                    let distance = levenshtein_distance(
+                        unexpected.as_bytes(),
+                        candidate.as_bytes(),
+                        max_distance,
+                    );
+                    (distance <= max_distance).then_some((distance, *candidate))
+                })
+                .min_by_key(|(distance, _)| *distance)
+                .map(|(_, candidate)| candidate);
+            let msg = if let Some(suggestion) = suggestion {
+                format!(
+                    "start_joinable_thread() got an unexpected keyword argument '{unexpected}'. Did you mean '{suggestion}'?"
+                )
+            } else {
+                format!("start_joinable_thread() got an unexpected keyword argument '{unexpected}'")
+            };
+            return Err(vm.new_type_error(msg));
+        }
+
+        if function_obj.to_callable().is_none() {
+            return Err(vm.new_type_error("thread function must be callable"));
+        }
+        let function: ArgCallable = function_obj.clone().try_into_value(vm)?;
+
+        let thread_handle_type = ThreadHandle::class(&vm.ctx);
+        let handle = if let Some(handle_obj) = handle_obj {
+            if vm.is_none(&handle_obj) {
+                None
+            } else if !handle_obj.class().is(thread_handle_type) {
+                return Err(vm.new_type_error("'handle' must be a _ThreadHandle"));
+            } else {
+                Some(
+                    handle_obj
+                        .downcast::<ThreadHandle>()
+                        .map_err(|_| vm.new_type_error("'handle' must be a _ThreadHandle"))?,
+                )
+            }
+        } else {
+            None
+        };
+
+        vm.sys_module.get_attr("audit", vm)?.call(
+            (
+                "_thread.start_joinable_thread",
+                function_obj,
+                daemon,
+                handle
+                    .as_ref()
+                    .map_or_else(|| vm.ctx.none(), |h| h.clone().into()),
+            ),
+            vm,
+        )?;
+
+        if vm
+            .state
+            .finalizing
+            .load(core::sync::atomic::Ordering::Acquire)
+        {
+            return Err(vm.new_exception_msg(
+                vm.ctx.exceptions.python_finalization_error.to_owned(),
+                "can't create new thread at interpreter shutdown"
+                    .to_owned()
+                    .into(),
+            ));
+        }
+
+        let handle = match handle {
+            Some(h) => h,
+            None => ThreadHandle::new(vm).into_ref(&vm.ctx),
         };
 
-        // Mark as starting
-        handle.inner.lock().state = ThreadHandleState::Starting;
+        // Must only start once (ThreadHandle_start).
+        {
+            let mut inner = handle.inner.lock();
+            if inner.state != ThreadHandleState::NotStarted {
+                return Err(vm.new_runtime_error("thread already started"));
+            }
+            inner.state = ThreadHandleState::Starting;
+            inner.ident = 0;
+            inner.join_handle = None;
+            inner.joining = false;
+            inner.joined = false;
+        }
+        // Starting a handle always resets the completion event.
+        {
+            let (done_lock, _) = &*handle.done_event;
+            *done_lock.lock() = false;
+        }
 
         // Add non-daemon threads to shutdown registry so _shutdown() will wait for them
-        if !args.daemon {
+        if !daemon {
             add_to_shutdown_handles(vm, &handle.inner, &handle.done_event);
         }
 
-        let func = args.function;
+        let func = function;
         let handle_clone = handle.clone();
         let inner_clone = handle.inner.clone();
         let done_event_clone = handle.done_event.clone();
+        // Use std::sync (pthread-based) instead of parking_lot for these
+        // events so they remain fork-safe without the parking_lot_core patch.
+        let started_event = Arc::new((std::sync::Mutex::new(false), std::sync::Condvar::new()));
+        let started_event_clone = Arc::clone(&started_event);
+        let handle_ready_event =
+            Arc::new((std::sync::Mutex::new(false), std::sync::Condvar::new()));
+        let handle_ready_event_clone = Arc::clone(&handle_ready_event);
 
         let mut thread_builder = thread::Builder::new();
         let stacksize = vm.state.stacksize.load();
@@ -1197,11 +1634,27 @@ pub(crate) mod _thread {
 
         let join_handle = thread_builder
             .spawn(vm.new_thread().make_spawn_func(move |vm| {
-                // Set ident and mark as running
+                // Publish ident for the parent starter thread.
+                {
+                    inner_clone.lock().ident = get_ident();
+                }
+                {
+                    let (started_lock, started_cvar) = &*started_event_clone;
+                    *started_lock.lock().unwrap() = true;
+                    started_cvar.notify_all();
+                }
+                // Don't execute the target function until parent marks the
+                // handle as running.
                 {
-                    let mut inner = inner_clone.lock();
-                    inner.ident = get_ident();
-                    inner.state = ThreadHandleState::Running;
+                    let (ready_lock, ready_cvar) = &*handle_ready_event_clone;
+                    let mut ready = ready_lock.lock().unwrap();
+                    while !*ready {
+                        // Short timeout so we stay responsive to STW requests.
+                        let (guard, _) = ready_cvar
+                            .wait_timeout(ready, core::time::Duration::from_millis(1))
+                            .unwrap();
+                        ready = guard;
+                    }
                 }
 
                 // Ensure cleanup happens even if the function panics
@@ -1227,6 +1680,9 @@ pub(crate) mod _thread {
 
                     vm_state.thread_count.fetch_sub(1);
 
+                    // The runtime no longer needs to wait for this thread.
+                    remove_from_shutdown_handles(vm, &inner_for_cleanup, &done_event_for_cleanup);
+
                     // Signal waiting threads that this thread is done
                     // This must be LAST to ensure all cleanup is complete before join() returns
                     {
@@ -1252,10 +1708,52 @@ pub(crate) mod _thread {
                     }
                 }
             }))
-            .map_err(|err| vm.new_runtime_error(format!("can't start new thread: {err}")))?;
+            .map_err(|_err| {
+                // force_done + remove_from_shutdown_handles on start failure.
+                {
+                    let mut inner = handle.inner.lock();
+                    inner.state = ThreadHandleState::Done;
+                    inner.join_handle = None;
+                    inner.joining = false;
+                    inner.joined = true;
+                }
+                {
+                    let (done_lock, done_cvar) = &*handle.done_event;
+                    *done_lock.lock() = true;
+                    done_cvar.notify_all();
+                }
+                if !daemon {
+                    remove_from_shutdown_handles(vm, &handle.inner, &handle.done_event);
+                }
+                vm.new_runtime_error("can't start new thread")
+            })?;
+
+        // Wait until the new thread has reported its ident.
+        {
+            let (started_lock, started_cvar) = &*started_event;
+            let mut started = started_lock.lock().unwrap();
+            while !*started {
+                let (guard, _) = started_cvar
+                    .wait_timeout(started, core::time::Duration::from_millis(1))
+                    .unwrap();
+                started = guard;
+            }
+        }
 
-        // Store the join handle
-        handle.inner.lock().join_handle = Some(join_handle);
+        // Mark the handle running in the parent thread (like CPython's
+        // ThreadHandle_start sets THREAD_HANDLE_RUNNING after spawn succeeds).
+        {
+            let mut inner = handle.inner.lock();
+            inner.join_handle = Some(join_handle);
+            inner.state = ThreadHandleState::Running;
+        }
+
+        // Unblock the started thread once handle state is fully published.
+        {
+            let (ready_lock, ready_cvar) = &*handle_ready_event;
+            *ready_lock.lock().unwrap() = true;
+            ready_cvar.notify_all();
+        }
 
         Ok(handle_clone)
     }
diff --git a/crates/vm/src/stdlib/_types.rs b/crates/vm/src/stdlib/_types.rs
new file mode 100644
index 00000000000..385ecf8cf5a
--- /dev/null
+++ b/crates/vm/src/stdlib/_types.rs
@@ -0,0 +1,157 @@
+//! Implementation of the `_types` module.
+//!
+//! This module exposes built-in types that are used by the `types` module.
+
+pub(crate) use _types::module_def;
+
+#[pymodule]
+#[allow(non_snake_case)]
+mod _types {
+    use crate::{PyObjectRef, VirtualMachine};
+
+    #[pyattr]
+    fn AsyncGeneratorType(vm: &VirtualMachine) -> PyObjectRef {
+        vm.ctx.types.async_generator.to_owned().into()
+    }
+
+    #[pyattr]
+    fn BuiltinFunctionType(vm: &VirtualMachine) -> PyObjectRef {
+        vm.ctx
+            .types
+            .builtin_function_or_method_type
+            .to_owned()
+            .into()
+    }
+
+    #[pyattr]
+    fn BuiltinMethodType(vm: &VirtualMachine) -> PyObjectRef {
+        // Same as BuiltinFunctionType in CPython
+        vm.ctx
+            .types
+            .builtin_function_or_method_type
+            .to_owned()
+            .into()
+    }
+
+    #[pyattr]
+    fn CapsuleType(vm: &VirtualMachine) -> PyObjectRef {
+        vm.ctx.types.capsule_type.to_owned().into()
+    }
+
+    #[pyattr]
+    fn CellType(vm: &VirtualMachine) -> PyObjectRef {
+        vm.ctx.types.cell_type.to_owned().into()
+    }
+
+    #[pyattr]
+    fn CodeType(vm: &VirtualMachine) -> PyObjectRef {
+        vm.ctx.types.code_type.to_owned().into()
+    }
+
+    #[pyattr]
+    fn CoroutineType(vm: &VirtualMachine) -> PyObjectRef {
+        vm.ctx.types.coroutine_type.to_owned().into()
+    }
+
+    #[pyattr]
+    fn EllipsisType(vm: &VirtualMachine) -> PyObjectRef {
+        vm.ctx.types.ellipsis_type.to_owned().into()
+    }
+
+    #[pyattr]
+    fn FrameType(vm: &VirtualMachine) -> PyObjectRef {
+        vm.ctx.types.frame_type.to_owned().into()
+    }
+
+    #[pyattr]
+    fn FunctionType(vm: &VirtualMachine) -> PyObjectRef {
+        vm.ctx.types.function_type.to_owned().into()
+    }
+
+    #[pyattr]
+    fn GeneratorType(vm: &VirtualMachine) -> PyObjectRef {
+        vm.ctx.types.generator_type.to_owned().into()
+    }
+
+    #[pyattr]
+    fn GenericAlias(vm: &VirtualMachine) -> PyObjectRef {
+        vm.ctx.types.generic_alias_type.to_owned().into()
+    }
+
+    #[pyattr]
+    fn GetSetDescriptorType(vm: &VirtualMachine) -> PyObjectRef {
+        vm.ctx.types.getset_type.to_owned().into()
+    }
+
+    #[pyattr]
+    fn LambdaType(vm: &VirtualMachine) -> PyObjectRef {
+        // Same as FunctionType in CPython
+        vm.ctx.types.function_type.to_owned().into()
+    }
+
+    #[pyattr]
+    fn MappingProxyType(vm: &VirtualMachine) -> PyObjectRef {
+        vm.ctx.types.mappingproxy_type.to_owned().into()
+    }
+
+    #[pyattr]
+    fn MemberDescriptorType(vm: &VirtualMachine) -> PyObjectRef {
+        vm.ctx.types.member_descriptor_type.to_owned().into()
+    }
+
+    #[pyattr]
+    fn MethodDescriptorType(vm: &VirtualMachine) -> PyObjectRef {
+        vm.ctx.types.method_descriptor_type.to_owned().into()
+    }
+
+    #[pyattr]
+    fn ClassMethodDescriptorType(vm: &VirtualMachine) -> PyObjectRef {
+        // TODO: implement as separate type
+        vm.ctx.types.method_descriptor_type.to_owned().into()
+    }
+
+    #[pyattr]
+    fn MethodType(vm: &VirtualMachine) -> PyObjectRef {
+        vm.ctx.types.bound_method_type.to_owned().into()
+    }
+
+    #[pyattr]
+    fn MethodWrapperType(vm: &VirtualMachine) -> PyObjectRef {
+        vm.ctx.types.method_wrapper_type.to_owned().into()
+    }
+
+    #[pyattr]
+    fn ModuleType(vm: &VirtualMachine) -> PyObjectRef {
+        vm.ctx.types.module_type.to_owned().into()
+    }
+
+    #[pyattr]
+    fn NoneType(vm: &VirtualMachine) -> PyObjectRef {
+        vm.ctx.types.none_type.to_owned().into()
+    }
+
+    #[pyattr]
+    fn NotImplementedType(vm: &VirtualMachine) -> PyObjectRef {
+        vm.ctx.types.not_implemented_type.to_owned().into()
+    }
+
+    #[pyattr]
+    fn SimpleNamespace(vm: &VirtualMachine) -> PyObjectRef {
+        vm.ctx.types.namespace_type.to_owned().into()
+    }
+
+    #[pyattr]
+    fn TracebackType(vm: &VirtualMachine) -> PyObjectRef {
+        vm.ctx.types.traceback_type.to_owned().into()
+    }
+
+    #[pyattr]
+    fn UnionType(vm: &VirtualMachine) -> PyObjectRef {
+        vm.ctx.types.union_type.to_owned().into()
+    }
+
+    #[pyattr]
+    fn WrapperDescriptorType(vm: &VirtualMachine) -> PyObjectRef {
+        vm.ctx.types.wrapper_descriptor_type.to_owned().into()
+    }
+}
diff --git a/crates/vm/src/stdlib/_typing.rs b/crates/vm/src/stdlib/_typing.rs
new file mode 100644
index 00000000000..7467a7f2574
--- /dev/null
+++ b/crates/vm/src/stdlib/_typing.rs
@@ -0,0 +1,505 @@
+// spell-checker:ignore typevarobject funcobj typevartuples
+use crate::{
+    Context, PyResult, VirtualMachine, builtins::pystr::AsPyStr, class::PyClassImpl,
+    function::IntoFuncArgs,
+};
+
+pub use crate::stdlib::typevar::{
+    Generic, ParamSpec, ParamSpecArgs, ParamSpecKwargs, TypeVar, TypeVarTuple,
+    set_typeparam_default,
+};
+pub(crate) use decl::module_def;
+pub use decl::*;
+
+/// Initialize typing types (call extend_class)
+pub fn init(ctx: &'static Context) {
+    NoDefault::extend_class(ctx, ctx.types.typing_no_default_type);
+}
+
+pub fn call_typing_func_object<'a>(
+    vm: &VirtualMachine,
+    func_name: impl AsPyStr<'a>,
+    args: impl IntoFuncArgs,
+) -> PyResult {
+    let module = vm.import("typing", 0)?;
+    let func = module.get_attr(func_name.as_pystr(&vm.ctx), vm)?;
+    func.call(args, vm)
+}
+
+#[pymodule(name = "_typing", with(super::typevar::typevar))]
+pub(crate) mod decl {
+    use crate::common::lock::LazyLock;
+    use crate::{
+        AsObject, Py, PyObjectRef, PyPayload, PyRef, PyResult, VirtualMachine, atomic_func,
+        builtins::{PyGenericAlias, PyStrRef, PyTuple, PyTupleRef, PyType, PyTypeRef, type_},
+        common::wtf8::Wtf8Buf,
+        function::FuncArgs,
+        protocol::{PyMappingMethods, PyNumberMethods},
+        types::{AsMapping, AsNumber, Callable, Constructor, Iterable, Representable},
+    };
+
+    #[pyfunction]
+    pub(crate) fn _idfunc(args: FuncArgs, _vm: &VirtualMachine) -> PyObjectRef {
+        args.args[0].clone()
+    }
+
+    #[pyfunction(name = "override")]
+    pub(crate) fn r#override(func: PyObjectRef, vm: &VirtualMachine) -> PyResult {
+        // Set __override__ attribute to True
+        // Skip the attribute silently if it is not writable.
+        // AttributeError happens if the object has __slots__ or a
+        // read-only property, TypeError if it's a builtin class.
+        let _ = func.set_attr("__override__", vm.ctx.true_value.clone(), vm);
+        Ok(func)
+    }
+
+    #[pyclass(no_attr, name = "NoDefaultType", module = "typing")]
+    #[derive(Debug, PyPayload)]
+    pub struct NoDefault;
+
+    #[pyclass(with(Constructor, Representable), flags(IMMUTABLETYPE))]
+    impl NoDefault {
+        #[pymethod]
+        fn __reduce__(&self, _vm: &VirtualMachine) -> String {
+            "NoDefault".to_owned()
+        }
+    }
+
+    impl Constructor for NoDefault {
+        type Args = ();
+
+        fn slot_new(_cls: PyTypeRef, args: FuncArgs, vm: &VirtualMachine) -> PyResult {
+            let _: () = args.bind(vm)?;
+            Ok(vm.ctx.typing_no_default.clone().into())
+        }
+
+        fn py_new(_cls: &Py<PyType>, _args: Self::Args, _vm: &VirtualMachine) -> PyResult<Self> {
+            unreachable!("NoDefault is a singleton, use slot_new")
+        }
+    }
+
+    impl Representable for NoDefault {
+        #[inline(always)]
+        fn repr_str(_zelf: &Py<Self>, _vm: &VirtualMachine) -> PyResult<String> {
+            Ok("typing.NoDefault".to_owned())
+        }
+    }
+
+    #[pyattr]
+    #[pyclass(name = "_ConstEvaluator", module = "_typing")]
+    #[derive(Debug, PyPayload)]
+    pub(crate) struct ConstEvaluator {
+        value: PyObjectRef,
+    }
+
+    #[pyclass(with(Constructor, Callable, Representable), flags(IMMUTABLETYPE))]
+    impl ConstEvaluator {}
+
+    impl Constructor for ConstEvaluator {
+        type Args = FuncArgs;
+
+        fn slot_new(_cls: PyTypeRef, _args: FuncArgs, vm: &VirtualMachine) -> PyResult {
+            Err(vm.new_type_error("cannot create '_typing._ConstEvaluator' instances"))
+        }
+
+        fn py_new(_cls: &Py<PyType>, _args: Self::Args, _vm: &VirtualMachine) -> PyResult<Self> {
+            unreachable!("ConstEvaluator cannot be instantiated from Python")
+        }
+    }
+
+    /// annotationlib.Format.STRING = 4
+    const ANNOTATE_FORMAT_STRING: i32 = 4;
+
+    impl Callable for ConstEvaluator {
+        type Args = FuncArgs;
+
+        fn call(zelf: &Py<Self>, args: FuncArgs, vm: &VirtualMachine) -> PyResult {
+            let (format,): (i32,) = args.bind(vm)?;
+            let value = &zelf.value;
+            if format == ANNOTATE_FORMAT_STRING {
+                return typing_type_repr_value(value, vm);
+            }
+            Ok(value.clone())
+        }
+    }
+
+    /// String representation of a type for annotation purposes.
+    /// Equivalent of _Py_typing_type_repr.
+    fn typing_type_repr(obj: &PyObjectRef, vm: &VirtualMachine) -> PyResult<String> {
+        // Ellipsis
+        if obj.is(&vm.ctx.ellipsis) {
+            return Ok("...".to_owned());
+        }
+        // NoneType -> "None"
+        if obj.is(&vm.ctx.types.none_type.as_object()) {
+            return Ok("None".to_owned());
+        }
+        // Generic aliases (has __origin__ and __args__) -> repr
+        let has_origin = obj.get_attr("__origin__", vm).is_ok();
+        let has_args = obj.get_attr("__args__", vm).is_ok();
+        if has_origin && has_args {
+            return Ok(obj.repr(vm)?.to_string());
+        }
+        // Has __qualname__ and __module__
+        if let Ok(qualname) = obj.get_attr("__qualname__", vm)
+            && let Ok(module) = obj.get_attr("__module__", vm)
+            && !vm.is_none(&module)
+            && let Some(module_str) = module.downcast_ref::<crate::builtins::PyStr>()
+        {
+            if module_str.as_bytes() == b"builtins" {
+                return Ok(qualname.str_utf8(vm)?.as_str().to_owned());
+            }
+            return Ok(format!(
+                "{}.{}",
+                module_str.as_wtf8(),
+                qualname.str_utf8(vm)?.as_str()
+            ));
+        }
+        // Fallback to repr
+        Ok(obj.repr(vm)?.to_string())
+    }
+
+    /// Format a value as a string for ANNOTATE_FORMAT_STRING.
+    /// Handles tuples specially by wrapping in parentheses.
+    fn typing_type_repr_value(value: &PyObjectRef, vm: &VirtualMachine) -> PyResult {
+        if let Ok(tuple) = value.try_to_ref::<PyTuple>(vm) {
+            let mut parts = Vec::with_capacity(tuple.len());
+            for item in tuple.iter() {
+                parts.push(typing_type_repr(item, vm)?);
+            }
+            let inner = if parts.len() == 1 {
+                format!("{},", parts[0])
+            } else {
+                parts.join(", ")
+            };
+            Ok(vm.ctx.new_str(format!("({})", inner)).into())
+        } else {
+            Ok(vm.ctx.new_str(typing_type_repr(value, vm)?).into())
+        }
+    }
+
+    impl Representable for ConstEvaluator {
+        fn repr_str(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<String> {
+            let value_repr = zelf.value.repr(vm)?;
+            Ok(format!("<constevaluator {}>", value_repr))
+        }
+    }
+
+    pub(crate) fn const_evaluator_alloc(value: PyObjectRef, vm: &VirtualMachine) -> PyObjectRef {
+        ConstEvaluator { value }.into_ref(&vm.ctx).into()
+    }
+
+    #[pyattr]
+    #[pyclass(name, module = "typing")]
+    #[derive(Debug, PyPayload)]
+    pub(crate) struct TypeAliasType {
+        name: PyStrRef,
+        type_params: PyTupleRef,
+        compute_value: PyObjectRef,
+        cached_value: crate::common::lock::PyMutex<Option<PyObjectRef>>,
+        module: Option<PyObjectRef>,
+        is_lazy: bool,
+    }
+    #[pyclass(
+        with(Constructor, Representable, AsMapping, AsNumber, Iterable),
+        flags(IMMUTABLETYPE)
+    )]
+    impl TypeAliasType {
+        /// Create from intrinsic: compute_value is a callable that returns the value
+        pub fn new(name: PyStrRef, type_params: PyTupleRef, compute_value: PyObjectRef) -> Self {
+            Self {
+                name,
+                type_params,
+                compute_value,
+                cached_value: crate::common::lock::PyMutex::new(None),
+                module: None,
+                is_lazy: true,
+            }
+        }
+
+        /// Create with an eagerly evaluated value (used by constructor)
+        fn new_eager(
+            name: PyStrRef,
+            type_params: PyTupleRef,
+            value: PyObjectRef,
+            module: Option<PyObjectRef>,
+        ) -> Self {
+            Self {
+                name,
+                type_params,
+                compute_value: value.clone(),
+                cached_value: crate::common::lock::PyMutex::new(Some(value)),
+                module,
+                is_lazy: false,
+            }
+        }
+
+        #[pygetset]
+        fn __name__(&self) -> PyObjectRef {
+            self.name.clone().into()
+        }
+
+        #[pygetset]
+        fn __value__(&self, vm: &VirtualMachine) -> PyResult {
+            let cached = self.cached_value.lock().clone();
+            if let Some(value) = cached {
+                return Ok(value);
+            }
+            // Call evaluator with format=1 (FORMAT_VALUE)
+            let value = self.compute_value.call((1i32,), vm)?;
+            *self.cached_value.lock() = Some(value.clone());
+            Ok(value)
+        }
+
+        #[pygetset]
+        fn __type_params__(&self) -> PyTupleRef {
+            self.type_params.clone()
+        }
+
+        #[pygetset]
+        fn __parameters__(&self, vm: &VirtualMachine) -> PyResult<PyObjectRef> {
+            // TypeVarTuples must be unpacked in __parameters__
+            unpack_typevartuples(&self.type_params, vm).map(|t| t.into())
+        }
+
+        #[pygetset]
+        fn __module__(&self, vm: &VirtualMachine) -> PyObjectRef {
+            if let Some(ref module) = self.module {
+                return module.clone();
+            }
+            // Fall back to compute_value's __module__ (like PyFunction_GetModule)
+            if let Ok(module) = self.compute_value.get_attr("__module__", vm) {
+                return module;
+            }
+            vm.ctx.none()
+        }
+
+        fn __getitem__(zelf: PyRef<Self>, args: PyObjectRef, vm: &VirtualMachine) -> PyResult {
+            if zelf.type_params.is_empty() {
+                return Err(vm.new_type_error("Only generic type aliases are subscriptable"));
+            }
+            let args_tuple = if let Ok(tuple) = args.try_to_ref::<PyTuple>(vm) {
+                tuple.to_owned()
+            } else {
+                PyTuple::new_ref(vec![args], &vm.ctx)
+            };
+            let origin: PyObjectRef = zelf.as_object().to_owned();
+            Ok(PyGenericAlias::new(origin, args_tuple, false, vm).into_pyobject(vm))
+        }
+
+        #[pymethod]
+        fn __reduce__(zelf: &Py<Self>, _vm: &VirtualMachine) -> PyObjectRef {
+            zelf.name.clone().into()
+        }
+
+        #[pymethod]
+        fn __typing_unpacked_tuple_args__(&self, vm: &VirtualMachine) -> PyObjectRef {
+            vm.ctx.none()
+        }
+
+        #[pygetset]
+        fn evaluate_value(&self, vm: &VirtualMachine) -> PyResult {
+            if self.is_lazy {
+                return Ok(self.compute_value.clone());
+            }
+            Ok(const_evaluator_alloc(self.compute_value.clone(), vm))
+        }
+
+        /// Check type_params ordering: non-default params must precede default params.
+        /// Uses __default__ attribute to check if a type param has a default value,
+        /// comparing against typing.NoDefault sentinel (like get_type_param_default).
+        fn check_type_params(
+            type_params: &PyTupleRef,
+            vm: &VirtualMachine,
+        ) -> PyResult<Option<PyTupleRef>> {
+            if type_params.is_empty() {
+                return Ok(None);
+            }
+            let no_default = &vm.ctx.typing_no_default;
+            let mut default_seen = false;
+            for param in type_params.iter() {
+                let dflt = param.get_attr("__default__", vm).map_err(|_| {
+                    vm.new_type_error(format!(
+                        "Expected a type param, got {}",
+                        param
+                            .repr(vm)
+                            .map(|s| s.to_string())
+                            .unwrap_or_else(|_| "?".to_owned())
+                    ))
+                })?;
+                let is_no_default = dflt.is(no_default);
+                if is_no_default {
+                    if default_seen {
+                        return Err(vm.new_type_error(format!(
+                            "non-default type parameter '{}' follows default type parameter",
+                            param.repr(vm)?
+                        )));
+                    }
+                } else {
+                    default_seen = true;
+                }
+            }
+            Ok(Some(type_params.clone()))
+        }
+    }
+
+    impl Constructor for TypeAliasType {
+        type Args = FuncArgs;
+
+        fn py_new(_cls: &Py<PyType>, args: Self::Args, vm: &VirtualMachine) -> PyResult<Self> {
+            // typealias(name, value, *, type_params=())
+            // name and value are positional-or-keyword; type_params is keyword-only.
+
+            // Reject unexpected keyword arguments
+            for key in args.kwargs.keys() {
+                if key != "name" && key != "value" && key != "type_params" {
+                    return Err(vm.new_type_error(format!(
+                        "typealias() got an unexpected keyword argument '{key}'"
+                    )));
+                }
+            }
+
+            // Reject too many positional arguments
+            if args.args.len() > 2 {
+                return Err(vm.new_type_error(format!(
+                    "typealias() takes exactly 2 positional arguments ({} given)",
+                    args.args.len()
+                )));
+            }
+
+            // Resolve name: positional[0] or kwarg
+            let name = if !args.args.is_empty() {
+                if args.kwargs.contains_key("name") {
+                    return Err(vm.new_type_error(
+                        "argument for typealias() given by name ('name') and position (1)",
+                    ));
+                }
+                args.args[0].clone()
+            } else {
+                args.kwargs.get("name").cloned().ok_or_else(|| {
+                    vm.new_type_error("typealias() missing required argument 'name' (pos 1)")
+                })?
+            };
+
+            // Resolve value: positional[1] or kwarg
+            let value = if args.args.len() >= 2 {
+                if args.kwargs.contains_key("value") {
+                    return Err(vm.new_type_error(
+                        "argument for typealias() given by name ('value') and position (2)",
+                    ));
+                }
+                args.args[1].clone()
+            } else {
+                args.kwargs.get("value").cloned().ok_or_else(|| {
+                    vm.new_type_error("typealias() missing required argument 'value' (pos 2)")
+                })?
+            };
+
+            let name = name.downcast::<crate::builtins::PyStr>().map_err(|obj| {
+                vm.new_type_error(format!(
+                    "typealias() argument 'name' must be str, not {}",
+                    obj.class().name()
+                ))
+            })?;
+
+            let type_params = if let Some(tp) = args.kwargs.get("type_params") {
+                let tp = tp
+                    .clone()
+                    .downcast::<crate::builtins::PyTuple>()
+                    .map_err(|_| vm.new_type_error("type_params must be a tuple"))?;
+                Self::check_type_params(&tp, vm)?;
+                tp
+            } else {
+                vm.ctx.empty_tuple.clone()
+            };
+
+            // Get caller's module name from frame globals, like typevar.rs caller()
+            let module = vm
+                .current_frame()
+                .and_then(|f| f.globals.get_item("__name__", vm).ok());
+
+            Ok(Self::new_eager(name, type_params, value, module))
+        }
+    }
+
+    impl Representable for TypeAliasType {
+        fn repr_wtf8(zelf: &Py<Self>, _vm: &VirtualMachine) -> PyResult<Wtf8Buf> {
+            Ok(zelf.name.as_wtf8().to_owned())
+        }
+    }
+
+    impl AsMapping for TypeAliasType {
+        fn as_mapping() -> &'static PyMappingMethods {
+            static AS_MAPPING: LazyLock<PyMappingMethods> = LazyLock::new(|| PyMappingMethods {
+                subscript: atomic_func!(|mapping, needle, vm| {
+                    let zelf = TypeAliasType::mapping_downcast(mapping);
+                    TypeAliasType::__getitem__(zelf.to_owned(), needle.to_owned(), vm)
+                }),
+                ..PyMappingMethods::NOT_IMPLEMENTED
+            });
+            &AS_MAPPING
+        }
+    }
+
+    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)),
+                ..PyNumberMethods::NOT_IMPLEMENTED
+            };
+            &AS_NUMBER
+        }
+    }
+
+    impl Iterable for TypeAliasType {
+        fn iter(zelf: PyRef<Self>, vm: &VirtualMachine) -> PyResult {
+            // Import typing.Unpack and return iter((Unpack[self],))
+            let typing = vm.import("typing", 0)?;
+            let unpack = typing.get_attr("Unpack", vm)?;
+            let zelf_obj: PyObjectRef = zelf.into();
+            let unpacked = vm.call_method(&unpack, "__getitem__", (zelf_obj,))?;
+            let tuple = PyTuple::new_ref(vec![unpacked], &vm.ctx);
+            Ok(tuple.as_object().get_iter(vm)?.into())
+        }
+    }
+
+    /// Wrap TypeVarTuples in Unpack[], matching unpack_typevartuples()
+    pub(crate) fn unpack_typevartuples(
+        type_params: &PyTupleRef,
+        vm: &VirtualMachine,
+    ) -> PyResult<PyTupleRef> {
+        let has_tvt = type_params
+            .iter()
+            .any(|p| p.downcastable::<crate::stdlib::typevar::TypeVarTuple>());
+        if !has_tvt {
+            return Ok(type_params.clone());
+        }
+        let typing = vm.import("typing", 0)?;
+        let unpack_cls = typing.get_attr("Unpack", vm)?;
+        let new_params: Vec<PyObjectRef> = type_params
+            .iter()
+            .map(|p| {
+                if p.downcastable::<crate::stdlib::typevar::TypeVarTuple>() {
+                    vm.call_method(&unpack_cls, "__getitem__", (p.clone(),))
+                } else {
+                    Ok(p.clone())
+                }
+            })
+            .collect::<PyResult<_>>()?;
+        Ok(PyTuple::new_ref(new_params, &vm.ctx))
+    }
+
+    pub(crate) fn module_exec(
+        vm: &VirtualMachine,
+        module: &Py<crate::builtins::PyModule>,
+    ) -> PyResult<()> {
+        __module_exec(vm, module);
+
+        extend_module!(vm, module, {
+            "NoDefault" => vm.ctx.typing_no_default.clone(),
+            "Union" => vm.ctx.types.union_type.to_owned(),
+        });
+
+        Ok(())
+    }
+}
diff --git a/crates/vm/src/stdlib/_warnings.rs b/crates/vm/src/stdlib/_warnings.rs
new file mode 100644
index 00000000000..a41ce2625c7
--- /dev/null
+++ b/crates/vm/src/stdlib/_warnings.rs
@@ -0,0 +1,213 @@
+pub(crate) use _warnings::module_def;
+
+use crate::{Py, PyResult, VirtualMachine, builtins::PyType};
+
+pub fn warn(
+    category: &Py<PyType>,
+    message: String,
+    stack_level: usize,
+    vm: &VirtualMachine,
+) -> PyResult<()> {
+    crate::warn::warn(
+        vm.new_pyobj(message),
+        Some(category.to_owned()),
+        isize::try_from(stack_level).unwrap_or(isize::MAX),
+        None,
+        vm,
+    )
+}
+
+#[pymodule]
+mod _warnings {
+    use crate::{
+        AsObject, PyObjectRef, PyResult, VirtualMachine,
+        builtins::{PyDictRef, PyListRef, PyStrRef, PyTupleRef, PyTypeRef},
+        convert::TryFromObject,
+        function::OptionalArg,
+    };
+
+    #[pyattr]
+    fn filters(vm: &VirtualMachine) -> PyListRef {
+        vm.state.warnings.filters.clone()
+    }
+
+    #[pyattr]
+    fn _defaultaction(vm: &VirtualMachine) -> PyStrRef {
+        vm.state.warnings.default_action.clone()
+    }
+
+    #[pyattr]
+    fn _onceregistry(vm: &VirtualMachine) -> PyDictRef {
+        vm.state.warnings.once_registry.clone()
+    }
+
+    #[pyattr]
+    fn _warnings_context(vm: &VirtualMachine) -> PyObjectRef {
+        vm.state
+            .warnings
+            .context_var
+            .get_or_init(|| {
+                // Try to create a real ContextVar if _contextvars is available.
+                // During early startup it may not be importable yet, in which
+                // case we fall back to None.  This is safe because
+                // context_aware_warnings defaults to False.
+                if let Ok(contextvars) = vm.import("_contextvars", 0)
+                    && let Ok(cv_cls) = contextvars.get_attr("ContextVar", vm)
+                    && let Ok(cv) = cv_cls.call(("_warnings_context",), vm)
+                {
+                    cv
+                } else {
+                    vm.ctx.none()
+                }
+            })
+            .clone()
+    }
+
+    #[pyfunction]
+    fn _acquire_lock(vm: &VirtualMachine) {
+        vm.state.warnings.acquire_lock();
+    }
+
+    #[pyfunction]
+    fn _release_lock(vm: &VirtualMachine) -> PyResult<()> {
+        if !vm.state.warnings.release_lock() {
+            return Err(vm.new_runtime_error("cannot release un-acquired lock"));
+        }
+        Ok(())
+    }
+
+    #[pyfunction]
+    fn _filters_mutated_lock_held(vm: &VirtualMachine) {
+        vm.state.warnings.filters_mutated();
+    }
+
+    #[derive(FromArgs)]
+    struct WarnArgs {
+        #[pyarg(positional)]
+        message: PyObjectRef,
+        #[pyarg(any, optional)]
+        category: OptionalArg<PyObjectRef>,
+        #[pyarg(any, optional)]
+        stacklevel: OptionalArg<i32>,
+        #[pyarg(named, optional)]
+        source: OptionalArg<PyObjectRef>,
+        #[pyarg(named, optional)]
+        skip_file_prefixes: OptionalArg<PyTupleRef>,
+    }
+
+    /// Validate and resolve the category argument, matching get_category() in C.
+    fn get_category(
+        message: &PyObjectRef,
+        category: Option<PyObjectRef>,
+        vm: &VirtualMachine,
+    ) -> PyResult<Option<PyTypeRef>> {
+        let cat_obj = match category {
+            Some(c) if !vm.is_none(&c) => c,
+            _ => {
+                if message.fast_isinstance(vm.ctx.exceptions.warning) {
+                    return Ok(Some(message.class().to_owned()));
+                } else {
+                    return Ok(None); // will default to UserWarning in warn_explicit
+                }
+            }
+        };
+
+        let cat = PyTypeRef::try_from_object(vm, cat_obj.clone()).map_err(|_| {
+            vm.new_type_error(format!(
+                "category must be a Warning subclass, not '{}'",
+                cat_obj.class().name()
+            ))
+        })?;
+
+        if !cat.fast_issubclass(vm.ctx.exceptions.warning) {
+            return Err(vm.new_type_error(format!(
+                "category must be a Warning subclass, not '{}'",
+                cat.class().name()
+            )));
+        }
+
+        Ok(Some(cat))
+    }
+
+    #[pyfunction]
+    fn warn(args: WarnArgs, vm: &VirtualMachine) -> PyResult<()> {
+        let level = args.stacklevel.unwrap_or(1) as isize;
+
+        let category = get_category(&args.message, args.category.into_option(), vm)?;
+
+        // Validate skip_file_prefixes: each element must be a str
+        let skip_prefixes = args.skip_file_prefixes.into_option();
+        if let Some(ref prefixes) = skip_prefixes {
+            for item in prefixes.iter() {
+                if !item.class().is(vm.ctx.types.str_type) {
+                    return Err(vm.new_type_error("skip_file_prefixes must be a tuple of strs"));
+                }
+            }
+        }
+
+        crate::warn::warn_with_skip(
+            args.message,
+            category,
+            level,
+            args.source.into_option(),
+            skip_prefixes,
+            vm,
+        )
+    }
+
+    #[derive(FromArgs)]
+    struct WarnExplicitArgs {
+        #[pyarg(positional)]
+        message: PyObjectRef,
+        #[pyarg(positional)]
+        category: PyObjectRef,
+        #[pyarg(positional)]
+        filename: PyStrRef,
+        #[pyarg(positional)]
+        lineno: usize,
+        #[pyarg(any, optional)]
+        module: OptionalArg<PyObjectRef>,
+        #[pyarg(any, optional)]
+        registry: OptionalArg<PyObjectRef>,
+        #[pyarg(any, optional)]
+        module_globals: OptionalArg<PyObjectRef>,
+        #[pyarg(named, optional)]
+        source: OptionalArg<PyObjectRef>,
+    }
+
+    #[pyfunction]
+    fn warn_explicit(args: WarnExplicitArgs, vm: &VirtualMachine) -> PyResult<()> {
+        let registry = args.registry.into_option().unwrap_or_else(|| vm.ctx.none());
+
+        let module = args.module.into_option();
+
+        // Validate module_globals: must be None or a dict
+        if let Some(ref mg) = args.module_globals.into_option()
+            && !vm.is_none(mg)
+            && !mg.class().is(vm.ctx.types.dict_type)
+        {
+            return Err(vm.new_type_error("module_globals must be a dict"));
+        }
+
+        let category = if vm.is_none(&args.category) {
+            None
+        } else {
+            Some(
+                PyTypeRef::try_from_object(vm, args.category)
+                    .map_err(|_| vm.new_type_error("category must be a Warning subclass"))?,
+            )
+        };
+
+        crate::warn::warn_explicit(
+            category,
+            args.message,
+            args.filename,
+            args.lineno,
+            module,
+            registry,
+            None, // source_line
+            args.source.into_option(),
+            vm,
+        )
+    }
+}
diff --git a/crates/vm/src/stdlib/weakref.rs b/crates/vm/src/stdlib/_weakref.rs
similarity index 100%
rename from crates/vm/src/stdlib/weakref.rs
rename to crates/vm/src/stdlib/_weakref.rs
diff --git a/crates/vm/src/stdlib/winapi.rs b/crates/vm/src/stdlib/_winapi.rs
similarity index 57%
rename from crates/vm/src/stdlib/winapi.rs
rename to crates/vm/src/stdlib/_winapi.rs
index 1ebb2831763..b210badd00a 100644
--- a/crates/vm/src/stdlib/winapi.rs
+++ b/crates/vm/src/stdlib/_winapi.rs
@@ -14,17 +14,19 @@ mod _winapi {
         types::Constructor,
         windows::{WinHandle, WindowsSysResult},
     };
-    use std::ptr::{null, null_mut};
-    use windows_sys::Win32::Foundation::{HANDLE, INVALID_HANDLE_VALUE, MAX_PATH};
+    use core::ptr::{null, null_mut};
+    use rustpython_common::wtf8::Wtf8Buf;
+    use windows_sys::Win32::Foundation::{HANDLE, MAX_PATH};
 
     #[pyattr]
     use windows_sys::Win32::{
         Foundation::{
-            DUPLICATE_CLOSE_SOURCE, DUPLICATE_SAME_ACCESS, ERROR_ALREADY_EXISTS, ERROR_BROKEN_PIPE,
-            ERROR_IO_PENDING, ERROR_MORE_DATA, ERROR_NETNAME_DELETED, ERROR_NO_DATA,
-            ERROR_NO_SYSTEM_RESOURCES, ERROR_OPERATION_ABORTED, ERROR_PIPE_BUSY,
-            ERROR_PIPE_CONNECTED, ERROR_SEM_TIMEOUT, GENERIC_READ, GENERIC_WRITE, STILL_ACTIVE,
-            WAIT_ABANDONED, WAIT_ABANDONED_0, WAIT_OBJECT_0, WAIT_TIMEOUT,
+            DUPLICATE_CLOSE_SOURCE, DUPLICATE_SAME_ACCESS, ERROR_ACCESS_DENIED,
+            ERROR_ALREADY_EXISTS, ERROR_BROKEN_PIPE, ERROR_IO_PENDING, ERROR_MORE_DATA,
+            ERROR_NETNAME_DELETED, ERROR_NO_DATA, ERROR_NO_SYSTEM_RESOURCES,
+            ERROR_OPERATION_ABORTED, ERROR_PIPE_BUSY, ERROR_PIPE_CONNECTED,
+            ERROR_PRIVILEGE_NOT_HELD, ERROR_SEM_TIMEOUT, GENERIC_READ, GENERIC_WRITE, STILL_ACTIVE,
+            WAIT_ABANDONED_0, WAIT_OBJECT_0, WAIT_TIMEOUT,
         },
         Globalization::{
             LCMAP_FULLWIDTH, LCMAP_HALFWIDTH, LCMAP_HIRAGANA, LCMAP_KATAKANA,
@@ -32,78 +34,45 @@ mod _winapi {
             LCMAP_TRADITIONAL_CHINESE, LCMAP_UPPERCASE,
         },
         Storage::FileSystem::{
-            COPY_FILE_ALLOW_DECRYPTED_DESTINATION,
-            COPY_FILE_COPY_SYMLINK,
-            COPY_FILE_FAIL_IF_EXISTS,
-            COPY_FILE_NO_BUFFERING,
-            COPY_FILE_NO_OFFLOAD,
-            COPY_FILE_OPEN_SOURCE_FOR_WRITE,
-            COPY_FILE_REQUEST_COMPRESSED_TRAFFIC,
-            COPY_FILE_REQUEST_SECURITY_PRIVILEGES,
-            COPY_FILE_RESTARTABLE,
-            COPY_FILE_RESUME_FROM_PAUSE,
-            COPYFILE2_CALLBACK_CHUNK_FINISHED,
-            COPYFILE2_CALLBACK_CHUNK_STARTED,
-            COPYFILE2_CALLBACK_ERROR,
-            COPYFILE2_CALLBACK_POLL_CONTINUE,
-            COPYFILE2_CALLBACK_STREAM_FINISHED,
-            COPYFILE2_CALLBACK_STREAM_STARTED,
-            COPYFILE2_PROGRESS_CANCEL,
-            COPYFILE2_PROGRESS_CONTINUE,
-            COPYFILE2_PROGRESS_PAUSE,
-            COPYFILE2_PROGRESS_QUIET,
-            COPYFILE2_PROGRESS_STOP,
-            CREATE_ALWAYS,
-            // CreateFile constants
-            CREATE_NEW,
-            FILE_ATTRIBUTE_NORMAL,
-            FILE_FLAG_BACKUP_SEMANTICS,
-            FILE_FLAG_DELETE_ON_CLOSE,
-            FILE_FLAG_FIRST_PIPE_INSTANCE,
-            FILE_FLAG_NO_BUFFERING,
-            FILE_FLAG_OPEN_REPARSE_POINT,
-            FILE_FLAG_OVERLAPPED,
-            FILE_FLAG_POSIX_SEMANTICS,
-            FILE_FLAG_RANDOM_ACCESS,
-            FILE_FLAG_SEQUENTIAL_SCAN,
-            FILE_FLAG_WRITE_THROUGH,
-            FILE_GENERIC_READ,
-            FILE_GENERIC_WRITE,
-            FILE_SHARE_DELETE,
-            FILE_SHARE_READ,
-            FILE_SHARE_WRITE,
-            FILE_TYPE_CHAR,
-            FILE_TYPE_DISK,
-            FILE_TYPE_PIPE,
-            FILE_TYPE_REMOTE,
-            FILE_TYPE_UNKNOWN,
-            OPEN_ALWAYS,
-            OPEN_EXISTING,
-            PIPE_ACCESS_DUPLEX,
-            PIPE_ACCESS_INBOUND,
-            SYNCHRONIZE,
-            TRUNCATE_EXISTING,
+            COPY_FILE_ALLOW_DECRYPTED_DESTINATION, COPY_FILE_COPY_SYMLINK,
+            COPY_FILE_FAIL_IF_EXISTS, COPY_FILE_NO_BUFFERING, COPY_FILE_NO_OFFLOAD,
+            COPY_FILE_OPEN_SOURCE_FOR_WRITE, COPY_FILE_REQUEST_COMPRESSED_TRAFFIC,
+            COPY_FILE_REQUEST_SECURITY_PRIVILEGES, COPY_FILE_RESTARTABLE,
+            COPY_FILE_RESUME_FROM_PAUSE, COPYFILE2_CALLBACK_CHUNK_FINISHED,
+            COPYFILE2_CALLBACK_CHUNK_STARTED, COPYFILE2_CALLBACK_ERROR,
+            COPYFILE2_CALLBACK_POLL_CONTINUE, COPYFILE2_CALLBACK_STREAM_FINISHED,
+            COPYFILE2_CALLBACK_STREAM_STARTED, COPYFILE2_PROGRESS_CANCEL,
+            COPYFILE2_PROGRESS_CONTINUE, COPYFILE2_PROGRESS_PAUSE, COPYFILE2_PROGRESS_QUIET,
+            COPYFILE2_PROGRESS_STOP, FILE_FLAG_FIRST_PIPE_INSTANCE, FILE_FLAG_OVERLAPPED,
+            FILE_GENERIC_READ, FILE_GENERIC_WRITE, FILE_TYPE_CHAR, FILE_TYPE_DISK, FILE_TYPE_PIPE,
+            FILE_TYPE_REMOTE, FILE_TYPE_UNKNOWN, OPEN_EXISTING, PIPE_ACCESS_DUPLEX,
+            PIPE_ACCESS_INBOUND, SYNCHRONIZE,
         },
         System::{
             Console::{STD_ERROR_HANDLE, STD_INPUT_HANDLE, STD_OUTPUT_HANDLE},
             Memory::{
-                FILE_MAP_ALL_ACCESS, MEM_COMMIT, MEM_FREE, MEM_IMAGE, MEM_MAPPED, MEM_PRIVATE,
+                FILE_MAP_ALL_ACCESS, FILE_MAP_COPY, FILE_MAP_EXECUTE, FILE_MAP_READ,
+                FILE_MAP_WRITE, MEM_COMMIT, MEM_FREE, MEM_IMAGE, MEM_MAPPED, MEM_PRIVATE,
                 MEM_RESERVE, PAGE_EXECUTE, PAGE_EXECUTE_READ, PAGE_EXECUTE_READWRITE,
                 PAGE_EXECUTE_WRITECOPY, PAGE_GUARD, PAGE_NOACCESS, PAGE_NOCACHE, PAGE_READONLY,
                 PAGE_READWRITE, PAGE_WRITECOMBINE, PAGE_WRITECOPY, SEC_COMMIT, SEC_IMAGE,
                 SEC_LARGE_PAGES, SEC_NOCACHE, SEC_RESERVE, SEC_WRITECOMBINE,
             },
             Pipes::{
-                PIPE_READMODE_MESSAGE, PIPE_TYPE_MESSAGE, PIPE_UNLIMITED_INSTANCES, PIPE_WAIT,
+                NMPWAIT_WAIT_FOREVER, PIPE_READMODE_MESSAGE, PIPE_TYPE_MESSAGE,
+                PIPE_UNLIMITED_INSTANCES, PIPE_WAIT,
             },
             SystemServices::LOCALE_NAME_MAX_LENGTH,
             Threading::{
                 ABOVE_NORMAL_PRIORITY_CLASS, BELOW_NORMAL_PRIORITY_CLASS,
                 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_FORCEOFFFEEDBACK, STARTF_FORCEONFEEDBACK,
-                STARTF_USESHOWWINDOW, STARTF_USESTDHANDLES,
+                IDLE_PRIORITY_CLASS, INFINITE, NORMAL_PRIORITY_CLASS, PROCESS_ALL_ACCESS,
+                PROCESS_DUP_HANDLE, REALTIME_PRIORITY_CLASS, STARTF_FORCEOFFFEEDBACK,
+                STARTF_FORCEONFEEDBACK, STARTF_PREVENTPINNING, STARTF_RUNFULLSCREEN,
+                STARTF_TITLEISAPPID, STARTF_TITLEISLINKNAME, STARTF_UNTRUSTEDSOURCE,
+                STARTF_USECOUNTCHARS, STARTF_USEFILLATTRIBUTE, STARTF_USEHOTKEY,
+                STARTF_USEPOSITION, STARTF_USESHOWWINDOW, STARTF_USESIZE, STARTF_USESTDHANDLES,
             },
         },
         UI::WindowsAndMessaging::SW_HIDE,
@@ -112,6 +81,12 @@ mod _winapi {
     #[pyattr]
     const NULL: isize = 0;
 
+    #[pyattr]
+    const INVALID_HANDLE_VALUE: isize = -1;
+
+    #[pyattr]
+    const COPY_FILE_DIRECTORY: u32 = 0x00000080;
+
     #[pyfunction]
     fn CloseHandle(handle: WinHandle) -> WindowsSysResult<i32> {
         WindowsSysResult(unsafe { windows_sys::Win32::Foundation::CloseHandle(handle.0) })
@@ -119,7 +94,10 @@ mod _winapi {
 
     /// CreateFile - Create or open a file or I/O device.
     #[pyfunction]
-    #[allow(clippy::too_many_arguments)]
+    #[allow(
+        clippy::too_many_arguments,
+        reason = "matches Win32 CreateFile parameter structure"
+    )]
     fn CreateFile(
         file_name: PyStrRef,
         desired_access: u32,
@@ -146,7 +124,7 @@ mod _winapi {
             )
         };
 
-        if handle == INVALID_HANDLE_VALUE {
+        if handle == windows_sys::Win32::Foundation::INVALID_HANDLE_VALUE {
             return Err(vm.new_last_os_error());
         }
 
@@ -159,7 +137,7 @@ mod _winapi {
         vm: &VirtualMachine,
     ) -> PyResult<Option<WinHandle>> {
         let handle = unsafe { windows_sys::Win32::System::Console::GetStdHandle(std_handle) };
-        if handle == INVALID_HANDLE_VALUE {
+        if handle == windows_sys::Win32::Foundation::INVALID_HANDLE_VALUE {
             return Err(vm.new_last_os_error());
         }
         Ok(if handle.is_null() {
@@ -178,8 +156,8 @@ mod _winapi {
     ) -> PyResult<(WinHandle, WinHandle)> {
         use windows_sys::Win32::Foundation::HANDLE;
         let (read, write) = unsafe {
-            let mut read = std::mem::MaybeUninit::<HANDLE>::uninit();
-            let mut write = std::mem::MaybeUninit::<HANDLE>::uninit();
+            let mut read = core::mem::MaybeUninit::<HANDLE>::uninit();
+            let mut write = core::mem::MaybeUninit::<HANDLE>::uninit();
             WindowsSysResult(windows_sys::Win32::System::Pipes::CreatePipe(
                 read.as_mut_ptr(),
                 write.as_mut_ptr(),
@@ -204,7 +182,7 @@ mod _winapi {
     ) -> PyResult<WinHandle> {
         use windows_sys::Win32::Foundation::HANDLE;
         let target = unsafe {
-            let mut target = std::mem::MaybeUninit::<HANDLE>::uninit();
+            let mut target = core::mem::MaybeUninit::<HANDLE>::uninit();
             WindowsSysResult(windows_sys::Win32::Foundation::DuplicateHandle(
                 src_process.0,
                 src.0,
@@ -281,8 +259,8 @@ mod _winapi {
         vm: &VirtualMachine,
     ) -> PyResult<(WinHandle, WinHandle, u32, u32)> {
         let mut si: windows_sys::Win32::System::Threading::STARTUPINFOEXW =
-            unsafe { std::mem::zeroed() };
-        si.StartupInfo.cb = std::mem::size_of_val(&si) as _;
+            unsafe { core::mem::zeroed() };
+        si.StartupInfo.cb = core::mem::size_of_val(&si) as _;
 
         macro_rules! si_attr {
             ($attr:ident, $t:ty) => {{
@@ -302,9 +280,9 @@ mod _winapi {
         }
         si_attr!(dwFlags);
         si_attr!(wShowWindow);
-        si_attr!(hStdInput, usize);
-        si_attr!(hStdOutput, usize);
-        si_attr!(hStdError, usize);
+        si_attr!(hStdInput, isize);
+        si_attr!(hStdOutput, isize);
+        si_attr!(hStdError, isize);
 
         let mut env = args
             .env_mapping
@@ -319,19 +297,19 @@ mod _winapi {
             .map_or_else(null_mut, |l| l.attrlist.as_mut_ptr() as _);
 
         let wstr = |s: PyStrRef| {
-            let ws = widestring::WideCString::from_str(s.as_str())
+            let ws = widestring::WideCString::from_str(s.expect_str())
                 .map_err(|err| err.to_pyexception(vm))?;
             Ok(ws.into_vec_with_nul())
         };
 
         // Validate no embedded null bytes in command name and command line
         if let Some(ref name) = args.name
-            && name.as_str().contains('\0')
+            && name.as_bytes().contains(&0)
         {
             return Err(crate::exceptions::cstring_error(vm));
         }
         if let Some(ref cmd) = args.command_line
-            && cmd.as_str().contains('\0')
+            && cmd.as_bytes().contains(&0)
         {
             return Err(crate::exceptions::cstring_error(vm));
         }
@@ -350,7 +328,7 @@ mod _winapi {
             .map_or_else(null_mut, |w| w.as_mut_ptr());
 
         let procinfo = unsafe {
-            let mut procinfo = std::mem::MaybeUninit::uninit();
+            let mut procinfo = core::mem::MaybeUninit::uninit();
             WindowsSysResult(windows_sys::Win32::System::Threading::CreateProcessW(
                 app_name,
                 command_line,
@@ -419,8 +397,8 @@ mod _winapi {
         dest_path: PyStrRef,
         vm: &VirtualMachine,
     ) -> PyResult<()> {
-        let src_path = std::path::Path::new(src_path.as_str());
-        let dest_path = std::path::Path::new(dest_path.as_str());
+        let src_path = std::path::Path::new(src_path.expect_str());
+        let dest_path = std::path::Path::new(dest_path.expect_str());
 
         junction::create(src_path, dest_path).map_err(|e| e.to_pyexception(vm))
     }
@@ -436,21 +414,40 @@ mod _winapi {
             return Err(vm.new_runtime_error("environment changed size during iteration"));
         }
 
-        let mut out = widestring::WideString::new();
+        // Deduplicate case-insensitive keys, keeping the last value
+        use std::collections::HashMap;
+        let mut last_entry: HashMap<String, widestring::WideString> = HashMap::new();
         for (k, v) in keys.into_iter().zip(values.into_iter()) {
             let k = PyStrRef::try_from_object(vm, k)?;
-            let k = k.as_str();
+            let k = k.expect_str();
             let v = PyStrRef::try_from_object(vm, v)?;
-            let v = v.as_str();
+            let v = v.expect_str();
             if k.contains('\0') || v.contains('\0') {
                 return Err(crate::exceptions::cstring_error(vm));
             }
             if k.is_empty() || k[1..].contains('=') {
                 return Err(vm.new_value_error("illegal environment variable name"));
             }
-            out.push_str(k);
-            out.push_str("=");
-            out.push_str(v);
+            let key_upper = k.to_uppercase();
+            let mut entry = widestring::WideString::new();
+            entry.push_str(k);
+            entry.push_str("=");
+            entry.push_str(v);
+            entry.push_str("\0");
+            last_entry.insert(key_upper, entry);
+        }
+
+        // Sort by uppercase key for case-insensitive ordering
+        let mut entries: Vec<(String, widestring::WideString)> = last_entry.into_iter().collect();
+        entries.sort_by(|a, b| a.0.cmp(&b.0));
+
+        let mut out = widestring::WideString::new();
+        for (_, entry) in entries {
+            out.push(entry);
+        }
+        // Each entry ends with \0, so one more \0 terminates the block.
+        // For empty env, we need \0\0 as a valid empty environment block.
+        if out.is_empty() {
             out.push_str("\0");
         }
         out.push_str("\0");
@@ -490,10 +487,10 @@ mod _winapi {
 
                 let attr_count = handlelist.is_some() as u32;
                 let (result, mut size) = unsafe {
-                    let mut size = std::mem::MaybeUninit::uninit();
+                    let mut size = core::mem::MaybeUninit::uninit();
                     let result = WindowsSysResult(
                         windows_sys::Win32::System::Threading::InitializeProcThreadAttributeList(
-                            std::ptr::null_mut(),
+                            core::ptr::null_mut(),
                             attr_count,
                             0,
                             size.as_mut_ptr(),
@@ -528,8 +525,8 @@ mod _winapi {
                             0,
                             (2 & 0xffff) | 0x20000, // PROC_THREAD_ATTRIBUTE_HANDLE_LIST
                             handlelist.as_mut_ptr() as _,
-                            (handlelist.len() * std::mem::size_of::<usize>()) as _,
-                            std::ptr::null_mut(),
+                            (handlelist.len() * core::mem::size_of::<usize>()) as _,
+                            core::ptr::null_mut(),
                             core::ptr::null(),
                         )
                     })
@@ -546,7 +543,7 @@ mod _winapi {
         let ms = if ms < 0 {
             windows_sys::Win32::System::Threading::INFINITE
         } else if ms > u32::MAX as i64 {
-            return Err(vm.new_overflow_error("timeout value is too large".to_owned()));
+            return Err(vm.new_overflow_error("timeout value is too large"));
         } else {
             ms as u32
         };
@@ -575,13 +572,11 @@ mod _winapi {
             .collect();
 
         if handles.is_empty() {
-            return Err(vm.new_value_error("handle_seq must not be empty".to_owned()));
+            return Err(vm.new_value_error("handle_seq must not be empty"));
         }
 
         if handles.len() > 64 {
-            return Err(
-                vm.new_value_error("WaitForMultipleObjects supports at most 64 handles".to_owned())
-            );
+            return Err(vm.new_value_error("WaitForMultipleObjects supports at most 64 handles"));
         }
 
         let ret = unsafe {
@@ -603,7 +598,7 @@ mod _winapi {
     #[pyfunction]
     fn GetExitCodeProcess(h: WinHandle, vm: &VirtualMachine) -> PyResult<u32> {
         unsafe {
-            let mut ec = std::mem::MaybeUninit::uninit();
+            let mut ec = core::mem::MaybeUninit::uninit();
             WindowsSysResult(windows_sys::Win32::System::Threading::GetExitCodeProcess(
                 h.0,
                 ec.as_mut_ptr(),
@@ -620,16 +615,76 @@ mod _winapi {
         })
     }
 
-    // TODO: ctypes.LibraryLoader.LoadLibrary
-    #[allow(dead_code)]
-    fn LoadLibrary(path: PyStrRef, vm: &VirtualMachine) -> PyResult<isize> {
-        let path_wide = path.as_wtf8().to_wide_with_nul();
-        let handle =
-            unsafe { windows_sys::Win32::System::LibraryLoader::LoadLibraryW(path_wide.as_ptr()) };
+    #[pyfunction]
+    fn CreateJobObject(
+        _security_attributes: PyObjectRef,
+        name: OptionalArg<Option<PyStrRef>>,
+        vm: &VirtualMachine,
+    ) -> PyResult<WinHandle> {
+        let handle = unsafe {
+            match name.flatten() {
+                Some(name) => {
+                    let name_wide = name.as_wtf8().to_wide_with_nul();
+                    windows_sys::Win32::System::JobObjects::CreateJobObjectW(
+                        null(),
+                        name_wide.as_ptr(),
+                    )
+                }
+                None => windows_sys::Win32::System::JobObjects::CreateJobObjectW(null(), null()),
+            }
+        };
         if handle.is_null() {
-            return Err(vm.new_runtime_error("LoadLibrary failed"));
+            return Err(vm.new_last_os_error());
+        }
+        Ok(WinHandle(handle))
+    }
+
+    #[pyfunction]
+    fn AssignProcessToJobObject(
+        job: WinHandle,
+        process: WinHandle,
+        vm: &VirtualMachine,
+    ) -> PyResult<()> {
+        let ret = unsafe {
+            windows_sys::Win32::System::JobObjects::AssignProcessToJobObject(job.0, process.0)
+        };
+        if ret == 0 {
+            return Err(vm.new_last_os_error());
+        }
+        Ok(())
+    }
+
+    #[pyfunction]
+    fn TerminateJobObject(job: WinHandle, exit_code: u32, vm: &VirtualMachine) -> PyResult<()> {
+        let ret =
+            unsafe { windows_sys::Win32::System::JobObjects::TerminateJobObject(job.0, exit_code) };
+        if ret == 0 {
+            return Err(vm.new_last_os_error());
         }
-        Ok(handle as isize)
+        Ok(())
+    }
+
+    #[pyfunction]
+    fn SetJobObjectKillOnClose(job: WinHandle, vm: &VirtualMachine) -> PyResult<()> {
+        use windows_sys::Win32::System::JobObjects::{
+            JOBOBJECT_EXTENDED_LIMIT_INFORMATION, JobObjectExtendedLimitInformation,
+            SetInformationJobObject,
+        };
+        let mut info: JOBOBJECT_EXTENDED_LIMIT_INFORMATION = unsafe { core::mem::zeroed() };
+        info.BasicLimitInformation.LimitFlags =
+            windows_sys::Win32::System::JobObjects::JOB_OBJECT_LIMIT_KILL_ON_JOB_CLOSE;
+        let ret = unsafe {
+            SetInformationJobObject(
+                job.0,
+                JobObjectExtendedLimitInformation,
+                &info as *const _ as *const core::ffi::c_void,
+                core::mem::size_of::<JOBOBJECT_EXTENDED_LIMIT_INFORMATION>() as u32,
+            )
+        };
+        if ret == 0 {
+            return Err(vm.new_last_os_error());
+        }
+        Ok(())
     }
 
     #[pyfunction]
@@ -657,7 +712,7 @@ mod _winapi {
         inherit_handle: bool,
         name: PyStrRef,
         vm: &VirtualMachine,
-    ) -> PyResult<isize> {
+    ) -> PyResult<WinHandle> {
         let name_wide = name.as_wtf8().to_wide_with_nul();
         let handle = unsafe {
             windows_sys::Win32::System::Threading::OpenMutexW(
@@ -666,23 +721,29 @@ mod _winapi {
                 name_wide.as_ptr(),
             )
         };
-        if handle == INVALID_HANDLE_VALUE {
+        if handle.is_null() {
             return Err(vm.new_last_os_error());
         }
-        Ok(handle as _)
+        Ok(WinHandle(handle))
     }
 
     #[pyfunction]
-    fn ReleaseMutex(handle: isize) -> WindowsSysResult<i32> {
-        WindowsSysResult(unsafe {
-            windows_sys::Win32::System::Threading::ReleaseMutex(handle as _)
-        })
+    fn ReleaseMutex(handle: WinHandle) -> WindowsSysResult<i32> {
+        WindowsSysResult(unsafe { windows_sys::Win32::System::Threading::ReleaseMutex(handle.0) })
     }
 
     // LOCALE_NAME_INVARIANT is an empty string in Windows API
     #[pyattr]
     const LOCALE_NAME_INVARIANT: &str = "";
 
+    #[pyattr]
+    const LOCALE_NAME_SYSTEM_DEFAULT: &str = "!x-sys-default-locale";
+
+    #[pyattr(name = "LOCALE_NAME_USER_DEFAULT")]
+    fn locale_name_user_default(vm: &VirtualMachine) -> PyObjectRef {
+        vm.ctx.none()
+    }
+
     /// LCMapStringEx - Map a string to another string using locale-specific rules
     /// This is used by ntpath.normcase() for proper Windows case conversion
     #[pyfunction]
@@ -692,7 +753,6 @@ mod _winapi {
         src: PyStrRef,
         vm: &VirtualMachine,
     ) -> PyResult<PyStrRef> {
-        use rustpython_common::wtf8::Wtf8Buf;
         use windows_sys::Win32::Globalization::{
             LCMAP_BYTEREV, LCMAP_HASH, LCMAP_SORTHANDLE, LCMAP_SORTKEY,
             LCMapStringEx as WinLCMapStringEx,
@@ -708,7 +768,7 @@ mod _winapi {
         let src_wide = src.as_wtf8().to_wide();
 
         if src_wide.len() > i32::MAX as usize {
-            return Err(vm.new_overflow_error("input string is too long".to_string()));
+            return Err(vm.new_overflow_error("input string is too long"));
         }
 
         // First call to get required buffer size
@@ -797,7 +857,7 @@ mod _winapi {
             )
         };
 
-        if handle == INVALID_HANDLE_VALUE {
+        if handle == windows_sys::Win32::Foundation::INVALID_HANDLE_VALUE {
             return Err(vm.new_last_os_error());
         }
 
@@ -815,15 +875,20 @@ mod _winapi {
     }
 
     struct OverlappedInner {
-        overlapped: windows_sys::Win32::System::IO::OVERLAPPED,
+        // Box ensures the OVERLAPPED struct stays at a stable heap address
+        // even when the containing Overlapped Python object is moved during
+        // into_pyobject(). The OS holds a pointer to this struct for pending
+        // I/O operations, so it must not be relocated.
+        overlapped: Box<windows_sys::Win32::System::IO::OVERLAPPED>,
         handle: HANDLE,
         pending: bool,
         completed: bool,
         read_buffer: Option<Vec<u8>>,
+        write_buffer: Option<Vec<u8>>,
     }
 
-    impl std::fmt::Debug for OverlappedInner {
-        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+    impl core::fmt::Debug for OverlappedInner {
+        fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
             f.debug_struct("OverlappedInner")
                 .field("handle", &self.handle)
                 .field("pending", &self.pending)
@@ -842,62 +907,77 @@ mod _winapi {
 
             let event = unsafe { CreateEventW(null(), 1, 0, null()) };
             let mut overlapped: windows_sys::Win32::System::IO::OVERLAPPED =
-                unsafe { std::mem::zeroed() };
+                unsafe { core::mem::zeroed() };
             overlapped.hEvent = event;
 
             Overlapped {
                 inner: PyMutex::new(OverlappedInner {
-                    overlapped,
+                    overlapped: Box::new(overlapped),
                     handle,
                     pending: false,
                     completed: false,
                     read_buffer: None,
+                    write_buffer: None,
                 }),
             }
         }
 
         #[pymethod]
-        fn GetOverlappedResult(&self, wait: bool, vm: &VirtualMachine) -> PyResult<u32> {
-            use windows_sys::Win32::Foundation::{ERROR_IO_PENDING, GetLastError};
+        fn GetOverlappedResult(&self, wait: bool, vm: &VirtualMachine) -> PyResult<(u32, u32)> {
+            use windows_sys::Win32::Foundation::{
+                ERROR_IO_INCOMPLETE, ERROR_MORE_DATA, ERROR_OPERATION_ABORTED, ERROR_SUCCESS,
+                GetLastError,
+            };
             use windows_sys::Win32::System::IO::GetOverlappedResult;
 
             let mut inner = self.inner.lock();
 
-            // If operation was already completed synchronously (e.g., ERROR_PIPE_CONNECTED),
-            // return immediately without calling GetOverlappedResult
-            if inner.completed && !inner.pending {
-                return Ok(0);
-            }
-
             let mut transferred: u32 = 0;
 
             let ret = unsafe {
                 GetOverlappedResult(
                     inner.handle,
-                    &inner.overlapped,
+                    &*inner.overlapped,
                     &mut transferred,
                     if wait { 1 } else { 0 },
                 )
             };
 
-            if ret == 0 {
-                let err = unsafe { GetLastError() };
-                if err == ERROR_IO_PENDING {
+            let err = if ret == 0 {
+                unsafe { GetLastError() }
+            } else {
+                ERROR_SUCCESS
+            };
+
+            match err {
+                ERROR_SUCCESS | ERROR_MORE_DATA | ERROR_OPERATION_ABORTED => {
+                    inner.completed = true;
+                    inner.pending = false;
+                }
+                ERROR_IO_INCOMPLETE => {}
+                _ => {
+                    inner.pending = false;
                     return Err(std::io::Error::from_raw_os_error(err as i32).to_pyexception(vm));
                 }
-                return Err(std::io::Error::from_raw_os_error(err as i32).to_pyexception(vm));
             }
 
-            inner.completed = true;
-            inner.pending = false;
-            Ok(transferred)
+            if inner.completed
+                && let Some(read_buffer) = &mut inner.read_buffer
+                && transferred != read_buffer.len() as u32
+            {
+                read_buffer.truncate(transferred as usize);
+            }
+
+            Ok((transferred, err))
         }
 
         #[pymethod]
         fn getbuffer(&self, vm: &VirtualMachine) -> PyResult<Option<PyObjectRef>> {
             let inner = self.inner.lock();
             if !inner.completed {
-                return Err(vm.new_value_error("operation not completed".to_owned()));
+                return Err(vm.new_value_error(
+                    "can't get read buffer before GetOverlappedResult() signals the operation completed",
+                ));
             }
             Ok(inner
                 .read_buffer
@@ -909,19 +989,19 @@ mod _winapi {
         fn cancel(&self, vm: &VirtualMachine) -> PyResult<()> {
             use windows_sys::Win32::System::IO::CancelIoEx;
 
-            let inner = self.inner.lock();
-            if !inner.pending {
-                return Ok(());
-            }
-
-            let ret = unsafe { CancelIoEx(inner.handle, &inner.overlapped) };
+            let mut inner = self.inner.lock();
+            let ret = if inner.pending {
+                unsafe { CancelIoEx(inner.handle, &*inner.overlapped) }
+            } else {
+                1
+            };
             if ret == 0 {
                 let err = unsafe { windows_sys::Win32::Foundation::GetLastError() };
-                // ERROR_NOT_FOUND means operation already completed
                 if err != windows_sys::Win32::Foundation::ERROR_NOT_FOUND {
                     return Err(std::io::Error::from_raw_os_error(err as i32).to_pyexception(vm));
                 }
             }
+            inner.pending = false;
             Ok(())
         }
 
@@ -956,9 +1036,9 @@ mod _winapi {
     /// ConnectNamedPipe - Wait for a client to connect to a named pipe
     #[derive(FromArgs)]
     struct ConnectNamedPipeArgs {
-        #[pyarg(positional)]
+        #[pyarg(any)]
         handle: WinHandle,
-        #[pyarg(named, optional)]
+        #[pyarg(any, optional)]
         overlapped: OptionalArg<bool>,
     }
 
@@ -975,38 +1055,31 @@ mod _winapi {
             // Overlapped (async) mode
             let ov = Overlapped::new_with_handle(handle.0);
 
-            let ret = {
+            let _ret = {
                 let mut inner = ov.inner.lock();
                 unsafe {
                     windows_sys::Win32::System::Pipes::ConnectNamedPipe(
                         handle.0,
-                        &mut inner.overlapped,
+                        &mut *inner.overlapped,
                     )
                 }
             };
 
-            if ret != 0 {
-                // Connected immediately
-                let mut inner = ov.inner.lock();
-                inner.completed = true;
-            } else {
-                let err = unsafe { GetLastError() };
-                match err {
-                    ERROR_IO_PENDING => {
-                        let mut inner = ov.inner.lock();
-                        inner.pending = true;
-                    }
-                    ERROR_PIPE_CONNECTED => {
-                        // Client was already connected
-                        let mut inner = ov.inner.lock();
-                        inner.completed = true;
-                    }
-                    _ => {
-                        return Err(
-                            std::io::Error::from_raw_os_error(err as i32).to_pyexception(vm)
-                        );
+            let err = unsafe { GetLastError() };
+            match err {
+                ERROR_IO_PENDING => {
+                    let mut inner = ov.inner.lock();
+                    inner.pending = true;
+                }
+                ERROR_PIPE_CONNECTED => {
+                    let inner = ov.inner.lock();
+                    unsafe {
+                        windows_sys::Win32::System::Threading::SetEvent(inner.overlapped.hEvent);
                     }
                 }
+                _ => {
+                    return Err(std::io::Error::from_raw_os_error(err as i32).to_pyexception(vm));
+                }
             }
 
             Ok(ov.into_pyobject(vm))
@@ -1033,8 +1106,6 @@ mod _winapi {
         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
@@ -1103,7 +1174,7 @@ mod _winapi {
         let size = size.unwrap_or(0);
 
         if size < 0 {
-            return Err(vm.new_value_error("negative size".to_string()));
+            return Err(vm.new_value_error("negative size"));
         }
 
         let mut navail: u32 = 0;
@@ -1203,28 +1274,87 @@ mod _winapi {
         Ok(())
     }
 
-    /// WriteFile - Write data to a file or I/O device.
-    #[pyfunction]
-    fn WriteFile(
+    #[derive(FromArgs)]
+    struct WriteFileArgs {
+        #[pyarg(any)]
         handle: WinHandle,
+        #[pyarg(any)]
         buffer: crate::function::ArgBytesLike,
-        use_overlapped: OptionalArg<bool>,
-        vm: &VirtualMachine,
-    ) -> PyResult<(u32, u32)> {
+        #[pyarg(any, default = false)]
+        overlapped: bool,
+    }
+
+    /// WriteFile - Write data to a file or I/O device.
+    #[pyfunction]
+    fn WriteFile(args: WriteFileArgs, vm: &VirtualMachine) -> PyResult<PyObjectRef> {
         use windows_sys::Win32::Storage::FileSystem::WriteFile as WinWriteFile;
 
-        let use_overlapped = use_overlapped.unwrap_or(false);
+        let handle = args.handle;
+        let use_overlapped = args.overlapped;
+        let buf = args.buffer.borrow_buf();
+        let len = core::cmp::min(buf.len(), u32::MAX as usize) as u32;
 
         if use_overlapped {
-            return Err(vm.new_not_implemented_error(
-                "overlapped WriteFile is not yet implemented in _winapi".to_string(),
-            ));
+            use windows_sys::Win32::Foundation::ERROR_IO_PENDING;
+
+            let ov = Overlapped::new_with_handle(handle.0);
+            let err = {
+                let mut inner = ov.inner.lock();
+                inner.write_buffer = Some(buf.to_vec());
+                let write_buf = inner.write_buffer.as_ref().unwrap();
+                let mut written: u32 = 0;
+                let ret = unsafe {
+                    WinWriteFile(
+                        handle.0,
+                        write_buf.as_ptr() as *const _,
+                        len,
+                        &mut written,
+                        &mut *inner.overlapped,
+                    )
+                };
+
+                let err = if ret == 0 {
+                    unsafe { windows_sys::Win32::Foundation::GetLastError() }
+                } else {
+                    0
+                };
+
+                if ret == 0 && err != ERROR_IO_PENDING {
+                    return Err(vm.new_last_os_error());
+                }
+                if ret == 0 && err == ERROR_IO_PENDING {
+                    inner.pending = true;
+                }
+
+                err
+            };
+
+            // Without GIL, the Python-level PipeConnection._send_bytes has a
+            // race on _send_ov when the caller (SimpleQueue) skips locking on
+            // Windows. Wait for completion here so the caller never sees
+            // ERROR_IO_PENDING and never blocks in WaitForMultipleObjects,
+            // keeping the _send_ov window negligibly small.
+            if err == ERROR_IO_PENDING {
+                let event = ov.inner.lock().overlapped.hEvent;
+                vm.allow_threads(|| unsafe {
+                    windows_sys::Win32::System::Threading::WaitForSingleObject(
+                        event,
+                        windows_sys::Win32::System::Threading::INFINITE,
+                    );
+                });
+                let result = vm
+                    .ctx
+                    .new_tuple(vec![ov.into_pyobject(vm), vm.ctx.new_int(0u32).into()]);
+                return Ok(result.into());
+            }
+
+            let result = vm
+                .ctx
+                .new_tuple(vec![ov.into_pyobject(vm), vm.ctx.new_int(err).into()]);
+            return Ok(result.into());
         }
 
-        let buf = buffer.borrow_buf();
-        let len = core::cmp::min(buf.len(), u32::MAX as usize) as u32;
         let mut written: u32 = 0;
-
         let ret = unsafe {
             WinWriteFile(
                 handle.0,
@@ -1234,18 +1364,199 @@ mod _winapi {
                 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(vm
+            .ctx
+            .new_tuple(vec![
+                vm.ctx.new_int(written).into(),
+                vm.ctx.new_int(err).into(),
+            ])
+            .into())
+    }
+
+    #[derive(FromArgs)]
+    struct ReadFileArgs {
+        #[pyarg(any)]
+        handle: WinHandle,
+        #[pyarg(any)]
+        size: u32,
+        #[pyarg(any, default = false)]
+        overlapped: bool,
+    }
+
+    /// ReadFile - Read data from a file or I/O device.
+    #[pyfunction]
+    fn ReadFile(args: ReadFileArgs, vm: &VirtualMachine) -> PyResult<PyObjectRef> {
+        use windows_sys::Win32::Storage::FileSystem::ReadFile as WinReadFile;
+
+        let handle = args.handle;
+        let size = args.size;
+        let use_overlapped = args.overlapped;
 
+        if use_overlapped {
+            use windows_sys::Win32::Foundation::ERROR_IO_PENDING;
+
+            let ov = Overlapped::new_with_handle(handle.0);
+            let err = {
+                let mut inner = ov.inner.lock();
+                inner.read_buffer = Some(vec![0u8; size as usize]);
+                let read_buf = inner.read_buffer.as_mut().unwrap();
+                let mut nread: u32 = 0;
+                let ret = unsafe {
+                    WinReadFile(
+                        handle.0,
+                        read_buf.as_mut_ptr() as *mut _,
+                        size,
+                        &mut nread,
+                        &mut *inner.overlapped,
+                    )
+                };
+
+                let err = if ret == 0 {
+                    unsafe { windows_sys::Win32::Foundation::GetLastError() }
+                } else {
+                    0
+                };
+
+                if ret == 0 && err != ERROR_IO_PENDING && err != ERROR_MORE_DATA {
+                    return Err(vm.new_last_os_error());
+                }
+                if ret == 0 && err == ERROR_IO_PENDING {
+                    inner.pending = true;
+                }
+
+                err
+            };
+            let result = vm
+                .ctx
+                .new_tuple(vec![ov.into_pyobject(vm), vm.ctx.new_int(err).into()]);
+            return Ok(result.into());
+        }
+
+        let mut buf = vec![0u8; size as usize];
+        let mut nread: u32 = 0;
+        let ret = unsafe {
+            WinReadFile(
+                handle.0,
+                buf.as_mut_ptr() as *mut _,
+                size,
+                &mut nread,
+                null_mut(),
+            )
+        };
         let err = if ret == 0 {
             unsafe { windows_sys::Win32::Foundation::GetLastError() }
         } else {
             0
         };
+        if ret == 0 && err != ERROR_MORE_DATA {
+            return Err(vm.new_last_os_error());
+        }
+        buf.truncate(nread as usize);
+        Ok(vm
+            .ctx
+            .new_tuple(vec![
+                vm.ctx.new_bytes(buf).into(),
+                vm.ctx.new_int(err).into(),
+            ])
+            .into())
+    }
+
+    /// SetNamedPipeHandleState - Set the read mode and other options of a named pipe.
+    #[pyfunction]
+    fn SetNamedPipeHandleState(
+        named_pipe: WinHandle,
+        mode: PyObjectRef,
+        max_collection_count: PyObjectRef,
+        collect_data_timeout: PyObjectRef,
+        vm: &VirtualMachine,
+    ) -> PyResult<()> {
+        use windows_sys::Win32::System::Pipes::SetNamedPipeHandleState as WinSetNamedPipeHandleState;
+
+        let mut dw_args: [u32; 3] = [0; 3];
+        let mut p_args: [*mut u32; 3] = [null_mut(); 3];
+
+        let objs = [&mode, &max_collection_count, &collect_data_timeout];
+        for (i, obj) in objs.iter().enumerate() {
+            if !vm.is_none(obj) {
+                dw_args[i] = u32::try_from_object(vm, (*obj).clone())?;
+                p_args[i] = &mut dw_args[i];
+            }
+        }
+
+        let ret =
+            unsafe { WinSetNamedPipeHandleState(named_pipe.0, p_args[0], p_args[1], p_args[2]) };
 
         if ret == 0 {
             return Err(vm.new_last_os_error());
         }
+        Ok(())
+    }
 
-        Ok((written, err))
+    /// ResetEvent - Reset the specified event object to the nonsignaled state.
+    #[pyfunction]
+    fn ResetEvent(event: WinHandle, vm: &VirtualMachine) -> PyResult<()> {
+        use windows_sys::Win32::System::Threading::ResetEvent as WinResetEvent;
+
+        let ret = unsafe { WinResetEvent(event.0) };
+        if ret == 0 {
+            return Err(vm.new_last_os_error());
+        }
+        Ok(())
+    }
+
+    /// CreateMutexW - Create or open a named or unnamed mutex object.
+    #[pyfunction]
+    fn CreateMutexW(
+        security_attributes: isize,
+        initial_owner: bool,
+        name: Option<PyStrRef>,
+        vm: &VirtualMachine,
+    ) -> PyResult<WinHandle> {
+        use windows_sys::Win32::System::Threading::CreateMutexW as WinCreateMutexW;
+
+        let _ = security_attributes;
+        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 { WinCreateMutexW(null(), i32::from(initial_owner), name_ptr) };
+
+        if handle.is_null() {
+            return Err(vm.new_last_os_error());
+        }
+        Ok(WinHandle(handle))
+    }
+
+    /// OpenEventW - Open an existing named event object.
+    #[pyfunction]
+    fn OpenEventW(
+        desired_access: u32,
+        inherit_handle: bool,
+        name: PyStrRef,
+        vm: &VirtualMachine,
+    ) -> PyResult<WinHandle> {
+        use windows_sys::Win32::System::Threading::OpenEventW as WinOpenEventW;
+
+        let name_wide = name.as_wtf8().to_wide_with_nul();
+        let handle = unsafe {
+            WinOpenEventW(
+                desired_access,
+                i32::from(inherit_handle),
+                name_wide.as_ptr(),
+            )
+        };
+
+        if handle.is_null() {
+            return Err(vm.new_last_os_error());
+        }
+        Ok(WinHandle(handle))
     }
 
     const MAXIMUM_WAIT_OBJECTS: usize = 64;
@@ -1258,8 +1569,8 @@ mod _winapi {
         milliseconds: OptionalArg<u32>,
         vm: &VirtualMachine,
     ) -> PyResult<PyObjectRef> {
-        use std::sync::Arc;
-        use std::sync::atomic::{AtomicU32, Ordering};
+        use alloc::sync::Arc;
+        use core::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::{
@@ -1301,8 +1612,28 @@ mod _winapi {
             i = end;
         }
 
+        #[cfg(feature = "threading")]
+        let sigint_event = {
+            let is_main = crate::stdlib::_thread::get_ident() == vm.state.main_thread_ident.load();
+            if is_main {
+                let handle = crate::signal::get_sigint_event().unwrap_or_else(|| {
+                    let handle = unsafe { WinCreateEventW(null(), 1, 0, null()) };
+                    if !handle.is_null() {
+                        crate::signal::set_sigint_event(handle as isize);
+                    }
+                    handle as isize
+                });
+                if handle == 0 { None } else { Some(handle) }
+            } else {
+                None
+            }
+        };
+        #[cfg(not(feature = "threading"))]
+        let sigint_event: Option<isize> = None;
+
         if wait_all {
             // For wait_all, we wait sequentially for each batch
+            let mut err: Option<u32> = None;
             let deadline = if milliseconds != WIN_INFINITE {
                 Some(unsafe { GetTickCount64() } + milliseconds as u64)
             } else {
@@ -1313,9 +1644,8 @@ mod _winapi {
                 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())
-                        );
+                        err = Some(windows_sys::Win32::Foundation::WAIT_TIMEOUT);
+                        break;
                     }
                     (deadline - now) as u32
                 } else {
@@ -1333,13 +1663,50 @@ mod _winapi {
                 };
 
                 if result == WAIT_FAILED {
-                    return Err(vm.new_last_os_error());
+                    err = Some(unsafe { windows_sys::Win32::Foundation::GetLastError() });
+                    break;
                 }
                 if result == windows_sys::Win32::Foundation::WAIT_TIMEOUT {
-                    return Err(vm.new_exception_empty(vm.ctx.exceptions.timeout_error.to_owned()));
+                    err = Some(windows_sys::Win32::Foundation::WAIT_TIMEOUT);
+                    break;
+                }
+
+                if let Some(sigint_event) = sigint_event {
+                    let sig_result = unsafe {
+                        windows_sys::Win32::System::Threading::WaitForSingleObject(
+                            sigint_event as _,
+                            0,
+                        )
+                    };
+                    if sig_result == WAIT_OBJECT_0 {
+                        err = Some(windows_sys::Win32::Foundation::ERROR_CONTROL_C_EXIT);
+                        break;
+                    }
+                    if sig_result == WAIT_FAILED {
+                        err = Some(unsafe { windows_sys::Win32::Foundation::GetLastError() });
+                        break;
+                    }
                 }
             }
 
+            if let Some(err) = err {
+                if err == windows_sys::Win32::Foundation::WAIT_TIMEOUT {
+                    return Err(vm
+                        .new_os_subtype_error(
+                            vm.ctx.exceptions.timeout_error.to_owned(),
+                            None,
+                            "timed out",
+                        )
+                        .upcast());
+                }
+                if err == windows_sys::Win32::Foundation::ERROR_CONTROL_C_EXIT {
+                    return Err(vm
+                        .new_errno_error(libc::EINTR, "Interrupted system call")
+                        .upcast());
+                }
+                return Err(vm.new_os_error(err as i32));
+            }
+
             Ok(vm.ctx.none())
         } else {
             // For wait_any, we use threads to wait on each batch in parallel
@@ -1353,7 +1720,7 @@ mod _winapi {
                 cancel_event: isize,
                 handle_base: usize,
                 result: AtomicU32,
-                thread: std::cell::UnsafeCell<isize>,
+                thread: core::cell::UnsafeCell<isize>,
             }
 
             unsafe impl Send for BatchData {}
@@ -1371,13 +1738,13 @@ mod _winapi {
                         cancel_event: cancel_event as isize,
                         handle_base: base,
                         result: AtomicU32::new(WAIT_FAILED),
-                        thread: std::cell::UnsafeCell::new(0),
+                        thread: core::cell::UnsafeCell::new(0),
                     })
                 })
                 .collect();
 
             // Thread function
-            extern "system" fn batch_wait_thread(param: *mut std::ffi::c_void) -> u32 {
+            extern "system" fn batch_wait_thread(param: *mut core::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 {
@@ -1438,7 +1805,10 @@ mod _winapi {
             }
 
             // Wait for any thread to complete
-            let thread_handles_raw: Vec<_> = thread_handles.iter().map(|&h| h as _).collect();
+            let mut thread_handles_raw: Vec<_> = thread_handles.iter().map(|&h| h as _).collect();
+            if let Some(sigint_event) = sigint_event {
+                thread_handles_raw.push(sigint_event as _);
+            }
             let result = unsafe {
                 WaitForMultipleObjects(
                     thread_handles_raw.len() as u32,
@@ -1452,6 +1822,10 @@ mod _winapi {
                 Some(unsafe { windows_sys::Win32::Foundation::GetLastError() })
             } else if result == windows_sys::Win32::Foundation::WAIT_TIMEOUT {
                 Some(windows_sys::Win32::Foundation::WAIT_TIMEOUT)
+            } else if sigint_event.is_some()
+                && result == WAIT_OBJECT_0 + thread_handles_raw.len() as u32
+            {
+                Some(windows_sys::Win32::Foundation::ERROR_CONTROL_C_EXIT)
             } else {
                 None
             };
@@ -1460,10 +1834,11 @@ mod _winapi {
             unsafe { WinSetEvent(cancel_event) };
 
             // Wait for all threads to finish
+            let thread_handles_only: Vec<_> = thread_handles.iter().map(|&h| h as _).collect();
             unsafe {
                 WaitForMultipleObjects(
-                    thread_handles_raw.len() as u32,
-                    thread_handles_raw.as_ptr(),
+                    thread_handles_only.len() as u32,
+                    thread_handles_only.as_ptr(),
                     1, // wait_all
                     WIN_INFINITE,
                 )
@@ -1491,7 +1866,18 @@ mod _winapi {
             // 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_subtype_error(
+                            vm.ctx.exceptions.timeout_error.to_owned(),
+                            None,
+                            "timed out",
+                        )
+                        .upcast());
+                }
+                if e == windows_sys::Win32::Foundation::ERROR_CONTROL_C_EXIT {
+                    return Err(vm
+                        .new_errno_error(libc::EINTR, "Interrupted system call")
+                        .upcast());
                 }
                 return Err(vm.new_os_error(e as i32));
             }
@@ -1511,4 +1897,284 @@ mod _winapi {
             Ok(vm.ctx.new_list(triggered_indices).into())
         }
     }
+
+    /// CreateFileMapping - Create or open a named or unnamed file mapping object.
+    #[pyfunction]
+    fn CreateFileMapping(
+        file_handle: WinHandle,
+        _security_attributes: PyObjectRef,
+        protect: u32,
+        max_size_high: u32,
+        max_size_low: u32,
+        name: Option<PyStrRef>,
+        vm: &VirtualMachine,
+    ) -> PyResult<WinHandle> {
+        use windows_sys::Win32::System::Memory::CreateFileMappingW;
+
+        if let Some(ref n) = name
+            && n.as_bytes().contains(&0)
+        {
+            return Err(
+                vm.new_value_error("CreateFileMapping: name must not contain null characters")
+            );
+        }
+        let name_wide = name.as_ref().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 {
+            CreateFileMappingW(
+                file_handle.0,
+                null(),
+                protect,
+                max_size_high,
+                max_size_low,
+                name_ptr,
+            )
+        };
+
+        if handle.is_null() {
+            return Err(vm.new_last_os_error());
+        }
+        Ok(WinHandle(handle))
+    }
+
+    /// OpenFileMapping - Open a named file mapping object.
+    #[pyfunction]
+    fn OpenFileMapping(
+        desired_access: u32,
+        inherit_handle: bool,
+        name: PyStrRef,
+        vm: &VirtualMachine,
+    ) -> PyResult<WinHandle> {
+        use windows_sys::Win32::System::Memory::OpenFileMappingW;
+
+        if name.as_bytes().contains(&0) {
+            return Err(
+                vm.new_value_error("OpenFileMapping: name must not contain null characters")
+            );
+        }
+        let name_wide = name.as_wtf8().to_wide_with_nul();
+        let handle = unsafe {
+            OpenFileMappingW(
+                desired_access,
+                i32::from(inherit_handle),
+                name_wide.as_ptr(),
+            )
+        };
+
+        if handle.is_null() {
+            return Err(vm.new_last_os_error());
+        }
+        Ok(WinHandle(handle))
+    }
+
+    /// MapViewOfFile - Map a view of a file mapping into the address space.
+    #[pyfunction]
+    fn MapViewOfFile(
+        file_map: WinHandle,
+        desired_access: u32,
+        file_offset_high: u32,
+        file_offset_low: u32,
+        number_bytes: usize,
+        vm: &VirtualMachine,
+    ) -> PyResult<isize> {
+        let address = unsafe {
+            windows_sys::Win32::System::Memory::MapViewOfFile(
+                file_map.0,
+                desired_access,
+                file_offset_high,
+                file_offset_low,
+                number_bytes,
+            )
+        };
+
+        let ptr = address.Value;
+        if ptr.is_null() {
+            return Err(vm.new_last_os_error());
+        }
+        Ok(ptr as isize)
+    }
+
+    /// UnmapViewOfFile - Unmap a mapped view of a file.
+    #[pyfunction]
+    fn UnmapViewOfFile(address: isize, vm: &VirtualMachine) -> PyResult<()> {
+        use windows_sys::Win32::System::Memory::MEMORY_MAPPED_VIEW_ADDRESS;
+
+        let view = MEMORY_MAPPED_VIEW_ADDRESS {
+            Value: address as *mut core::ffi::c_void,
+        };
+        let ret = unsafe { windows_sys::Win32::System::Memory::UnmapViewOfFile(view) };
+
+        if ret == 0 {
+            return Err(vm.new_last_os_error());
+        }
+        Ok(())
+    }
+
+    /// VirtualQuerySize - Return the size of a memory region.
+    #[pyfunction]
+    fn VirtualQuerySize(address: isize, vm: &VirtualMachine) -> PyResult<usize> {
+        use windows_sys::Win32::System::Memory::{MEMORY_BASIC_INFORMATION, VirtualQuery};
+
+        let mut mbi: MEMORY_BASIC_INFORMATION = unsafe { core::mem::zeroed() };
+        let ret = unsafe {
+            VirtualQuery(
+                address as *const core::ffi::c_void,
+                &mut mbi,
+                core::mem::size_of::<MEMORY_BASIC_INFORMATION>(),
+            )
+        };
+
+        if ret == 0 {
+            return Err(vm.new_last_os_error());
+        }
+        Ok(mbi.RegionSize)
+    }
+
+    /// CopyFile2 - Copy a file with extended parameters.
+    #[pyfunction]
+    fn CopyFile2(
+        existing_file_name: PyStrRef,
+        new_file_name: PyStrRef,
+        flags: u32,
+        _progress_routine: OptionalArg<PyObjectRef>,
+        vm: &VirtualMachine,
+    ) -> PyResult<()> {
+        use windows_sys::Win32::Storage::FileSystem::{
+            COPYFILE2_EXTENDED_PARAMETERS, CopyFile2 as WinCopyFile2,
+        };
+
+        let src_wide = existing_file_name.as_wtf8().to_wide_with_nul();
+        let dst_wide = new_file_name.as_wtf8().to_wide_with_nul();
+
+        let mut params: COPYFILE2_EXTENDED_PARAMETERS = unsafe { core::mem::zeroed() };
+        params.dwSize = core::mem::size_of::<COPYFILE2_EXTENDED_PARAMETERS>() as u32;
+        params.dwCopyFlags = flags;
+
+        let hr = unsafe { WinCopyFile2(src_wide.as_ptr(), dst_wide.as_ptr(), &params) };
+
+        if hr < 0 {
+            // HRESULT failure - convert to Windows error code
+            let err = if (hr as u32 >> 16) == 0x8007 {
+                (hr as u32) & 0xFFFF
+            } else {
+                hr as u32
+            };
+            return Err(std::io::Error::from_raw_os_error(err as i32).to_pyexception(vm));
+        }
+        Ok(())
+    }
+
+    /// _mimetypes_read_windows_registry - Read MIME type associations from registry.
+    #[pyfunction]
+    fn _mimetypes_read_windows_registry(
+        on_type_read: PyObjectRef,
+        vm: &VirtualMachine,
+    ) -> PyResult<()> {
+        use windows_sys::Win32::System::Registry::{
+            HKEY, HKEY_CLASSES_ROOT, KEY_READ, REG_SZ, RegCloseKey, RegEnumKeyExW, RegOpenKeyExW,
+            RegQueryValueExW,
+        };
+
+        let mut hkcr: HKEY = null_mut() as HKEY;
+        let err = unsafe { RegOpenKeyExW(HKEY_CLASSES_ROOT, null(), 0, KEY_READ, &mut hkcr) };
+        if err != 0 {
+            return Err(vm.new_os_error(err as i32));
+        }
+        scopeguard::defer! { unsafe { RegCloseKey(hkcr) }; }
+
+        let mut i: u32 = 0;
+        let mut entries: Vec<(String, String)> = Vec::new();
+
+        loop {
+            let mut ext_buf = [0u16; 128];
+            let mut cch_ext: u32 = ext_buf.len() as u32;
+
+            let err = unsafe {
+                RegEnumKeyExW(
+                    hkcr,
+                    i,
+                    ext_buf.as_mut_ptr(),
+                    &mut cch_ext,
+                    null_mut(),
+                    null_mut(),
+                    null_mut(),
+                    null_mut(),
+                )
+            };
+            i += 1;
+
+            if err == windows_sys::Win32::Foundation::ERROR_NO_MORE_ITEMS {
+                break;
+            }
+            if err != 0 && err != windows_sys::Win32::Foundation::ERROR_MORE_DATA {
+                return Err(vm.new_os_error(err as i32));
+            }
+
+            // Only process keys starting with '.'
+            if cch_ext == 0 || ext_buf[0] != b'.' as u16 {
+                continue;
+            }
+
+            let ext_wide = &ext_buf[..cch_ext as usize];
+
+            // Open subkey to read Content Type
+            let mut subkey: HKEY = null_mut() as HKEY;
+            let err = unsafe { RegOpenKeyExW(hkcr, ext_buf.as_ptr(), 0, KEY_READ, &mut subkey) };
+            if err == windows_sys::Win32::Foundation::ERROR_FILE_NOT_FOUND
+                || err == windows_sys::Win32::Foundation::ERROR_ACCESS_DENIED
+            {
+                continue;
+            }
+            if err != 0 {
+                return Err(vm.new_os_error(err as i32));
+            }
+
+            let content_type_key: Vec<u16> = "Content Type\0".encode_utf16().collect();
+            let mut type_buf = [0u16; 256];
+            let mut cb_type: u32 = (type_buf.len() * 2) as u32;
+            let mut reg_type: u32 = 0;
+
+            let err = unsafe {
+                RegQueryValueExW(
+                    subkey,
+                    content_type_key.as_ptr(),
+                    null_mut(),
+                    &mut reg_type,
+                    type_buf.as_mut_ptr() as *mut u8,
+                    &mut cb_type,
+                )
+            };
+            unsafe { RegCloseKey(subkey) };
+
+            if err != 0 || reg_type != REG_SZ || cb_type == 0 {
+                continue;
+            }
+
+            // Convert wide strings to Rust strings
+            let type_len = (cb_type as usize / 2).saturating_sub(1); // exclude null terminator
+            let type_str = String::from_utf16_lossy(&type_buf[..type_len]);
+            let ext_str = String::from_utf16_lossy(ext_wide);
+
+            if type_str.is_empty() {
+                continue;
+            }
+
+            entries.push((type_str, ext_str));
+
+            // Flush buffer periodically to call Python callback
+            if entries.len() >= 64 {
+                for (mime_type, ext) in entries.drain(..) {
+                    on_type_read.call((vm.ctx.new_str(mime_type), vm.ctx.new_str(ext)), vm)?;
+                }
+            }
+        }
+
+        // Process remaining entries
+        for (mime_type, ext) in entries {
+            on_type_read.call((vm.ctx.new_str(mime_type), vm.ctx.new_str(ext)), vm)?;
+        }
+
+        Ok(())
+    }
 }
diff --git a/crates/vm/src/stdlib/_wmi.rs b/crates/vm/src/stdlib/_wmi.rs
new file mode 100644
index 00000000000..96275e5ac4b
--- /dev/null
+++ b/crates/vm/src/stdlib/_wmi.rs
@@ -0,0 +1,698 @@
+// spell-checker:disable
+#![allow(non_snake_case)]
+
+pub(crate) use _wmi::module_def;
+
+// COM/WMI FFI declarations (not inside pymodule to avoid macro issues)
+mod wmi_ffi {
+    #![allow(unsafe_op_in_unsafe_fn)]
+    use core::ffi::c_void;
+
+    pub type HRESULT = i32;
+
+    #[repr(C)]
+    pub struct GUID {
+        pub data1: u32,
+        pub data2: u16,
+        pub data3: u16,
+        pub data4: [u8; 8],
+    }
+
+    // Opaque VARIANT type (24 bytes covers both 32-bit and 64-bit)
+    #[repr(C, align(8))]
+    pub struct VARIANT([u64; 3]);
+
+    impl VARIANT {
+        pub fn zeroed() -> Self {
+            VARIANT([0u64; 3])
+        }
+    }
+
+    // CLSID_WbemLocator = {4590F811-1D3A-11D0-891F-00AA004B2E24}
+    pub const CLSID_WBEM_LOCATOR: GUID = GUID {
+        data1: 0x4590F811,
+        data2: 0x1D3A,
+        data3: 0x11D0,
+        data4: [0x89, 0x1F, 0x00, 0xAA, 0x00, 0x4B, 0x2E, 0x24],
+    };
+
+    // IID_IWbemLocator = {DC12A687-737F-11CF-884D-00AA004B2E24}
+    pub const IID_IWBEM_LOCATOR: GUID = GUID {
+        data1: 0xDC12A687,
+        data2: 0x737F,
+        data3: 0x11CF,
+        data4: [0x88, 0x4D, 0x00, 0xAA, 0x00, 0x4B, 0x2E, 0x24],
+    };
+
+    // COM constants
+    pub const COINIT_APARTMENTTHREADED: u32 = 0x2;
+    pub const CLSCTX_INPROC_SERVER: u32 = 0x1;
+    pub const RPC_C_AUTHN_LEVEL_DEFAULT: u32 = 0;
+    pub const RPC_C_IMP_LEVEL_IMPERSONATE: u32 = 3;
+    pub const RPC_C_AUTHN_LEVEL_CALL: u32 = 3;
+    pub const RPC_C_AUTHN_WINNT: u32 = 10;
+    pub const RPC_C_AUTHZ_NONE: u32 = 0;
+    pub const EOAC_NONE: u32 = 0;
+    pub const RPC_E_TOO_LATE: HRESULT = 0x80010119_u32 as i32;
+
+    // WMI constants
+    pub const WBEM_FLAG_FORWARD_ONLY: i32 = 0x20;
+    pub const WBEM_FLAG_RETURN_IMMEDIATELY: i32 = 0x10;
+    pub const WBEM_S_FALSE: HRESULT = 1;
+    pub const WBEM_S_NO_MORE_DATA: HRESULT = 0x40005;
+    pub const WBEM_INFINITE: i32 = -1;
+    pub const WBEM_FLAVOR_MASK_ORIGIN: i32 = 0x60;
+    pub const WBEM_FLAVOR_ORIGIN_SYSTEM: i32 = 0x40;
+
+    #[link(name = "ole32")]
+    unsafe extern "system" {
+        pub fn CoInitializeEx(pvReserved: *mut c_void, dwCoInit: u32) -> HRESULT;
+        pub fn CoUninitialize();
+        pub fn CoInitializeSecurity(
+            pSecDesc: *const c_void,
+            cAuthSvc: i32,
+            asAuthSvc: *const c_void,
+            pReserved1: *const c_void,
+            dwAuthnLevel: u32,
+            dwImpLevel: u32,
+            pAuthList: *const c_void,
+            dwCapabilities: u32,
+            pReserved3: *const c_void,
+        ) -> HRESULT;
+        pub fn CoCreateInstance(
+            rclsid: *const GUID,
+            pUnkOuter: *mut c_void,
+            dwClsContext: u32,
+            riid: *const GUID,
+            ppv: *mut *mut c_void,
+        ) -> HRESULT;
+        pub fn CoSetProxyBlanket(
+            pProxy: *mut c_void,
+            dwAuthnSvc: u32,
+            dwAuthzSvc: u32,
+            pServerPrincName: *const u16,
+            dwAuthnLevel: u32,
+            dwImpLevel: u32,
+            pAuthInfo: *const c_void,
+            dwCapabilities: u32,
+        ) -> HRESULT;
+    }
+
+    #[link(name = "oleaut32")]
+    unsafe extern "system" {
+        pub fn SysAllocString(psz: *const u16) -> *mut u16;
+        pub fn SysFreeString(bstrString: *mut u16);
+        pub fn VariantClear(pvarg: *mut VARIANT) -> HRESULT;
+    }
+
+    #[link(name = "propsys")]
+    unsafe extern "system" {
+        pub fn VariantToString(varIn: *const VARIANT, pszBuf: *mut u16, cchBuf: u32) -> HRESULT;
+    }
+
+    /// Release a COM object (IUnknown::Release, vtable index 2)
+    pub unsafe fn com_release(this: *mut c_void) {
+        if !this.is_null() {
+            let vtable = *(this as *const *const usize);
+            let release: unsafe extern "system" fn(*mut c_void) -> u32 =
+                core::mem::transmute(*vtable.add(2));
+            release(this);
+        }
+    }
+
+    /// IWbemLocator::ConnectServer (vtable index 3)
+    #[allow(clippy::too_many_arguments)]
+    pub unsafe fn locator_connect_server(
+        this: *mut c_void,
+        network_resource: *const u16,
+        user: *const u16,
+        password: *const u16,
+        locale: *const u16,
+        security_flags: i32,
+        authority: *const u16,
+        ctx: *mut c_void,
+        services: *mut *mut c_void,
+    ) -> HRESULT {
+        let vtable = *(this as *const *const usize);
+        let method: unsafe extern "system" fn(
+            *mut c_void,
+            *const u16,
+            *const u16,
+            *const u16,
+            *const u16,
+            i32,
+            *const u16,
+            *mut c_void,
+            *mut *mut c_void,
+        ) -> HRESULT = core::mem::transmute(*vtable.add(3));
+        method(
+            this,
+            network_resource,
+            user,
+            password,
+            locale,
+            security_flags,
+            authority,
+            ctx,
+            services,
+        )
+    }
+
+    /// IWbemServices::ExecQuery (vtable index 20)
+    pub unsafe fn services_exec_query(
+        this: *mut c_void,
+        query_language: *const u16,
+        query: *const u16,
+        flags: i32,
+        ctx: *mut c_void,
+        enumerator: *mut *mut c_void,
+    ) -> HRESULT {
+        let vtable = *(this as *const *const usize);
+        let method: unsafe extern "system" fn(
+            *mut c_void,
+            *const u16,
+            *const u16,
+            i32,
+            *mut c_void,
+            *mut *mut c_void,
+        ) -> HRESULT = core::mem::transmute(*vtable.add(20));
+        method(this, query_language, query, flags, ctx, enumerator)
+    }
+
+    /// IEnumWbemClassObject::Next (vtable index 4)
+    pub unsafe fn enum_next(
+        this: *mut c_void,
+        timeout: i32,
+        count: u32,
+        objects: *mut *mut c_void,
+        returned: *mut u32,
+    ) -> HRESULT {
+        let vtable = *(this as *const *const usize);
+        let method: unsafe extern "system" fn(
+            *mut c_void,
+            i32,
+            u32,
+            *mut *mut c_void,
+            *mut u32,
+        ) -> HRESULT = core::mem::transmute(*vtable.add(4));
+        method(this, timeout, count, objects, returned)
+    }
+
+    /// IWbemClassObject::BeginEnumeration (vtable index 8)
+    pub unsafe fn object_begin_enumeration(this: *mut c_void, enum_flags: i32) -> HRESULT {
+        let vtable = *(this as *const *const usize);
+        let method: unsafe extern "system" fn(*mut c_void, i32) -> HRESULT =
+            core::mem::transmute(*vtable.add(8));
+        method(this, enum_flags)
+    }
+
+    /// IWbemClassObject::Next (vtable index 9)
+    pub unsafe fn object_next(
+        this: *mut c_void,
+        flags: i32,
+        name: *mut *mut u16,
+        val: *mut VARIANT,
+        cim_type: *mut i32,
+        flavor: *mut i32,
+    ) -> HRESULT {
+        let vtable = *(this as *const *const usize);
+        let method: unsafe extern "system" fn(
+            *mut c_void,
+            i32,
+            *mut *mut u16,
+            *mut VARIANT,
+            *mut i32,
+            *mut i32,
+        ) -> HRESULT = core::mem::transmute(*vtable.add(9));
+        method(this, flags, name, val, cim_type, flavor)
+    }
+
+    /// IWbemClassObject::EndEnumeration (vtable index 10)
+    pub unsafe fn object_end_enumeration(this: *mut c_void) -> HRESULT {
+        let vtable = *(this as *const *const usize);
+        let method: unsafe extern "system" fn(*mut c_void) -> HRESULT =
+            core::mem::transmute(*vtable.add(10));
+        method(this)
+    }
+}
+
+#[pymodule]
+mod _wmi {
+    use super::wmi_ffi::*;
+    use crate::builtins::PyStrRef;
+    use crate::convert::ToPyException;
+    use crate::{PyResult, VirtualMachine};
+    use core::ffi::c_void;
+    use core::ptr::{null, null_mut};
+    use windows_sys::Win32::Foundation::{
+        CloseHandle, ERROR_BROKEN_PIPE, ERROR_MORE_DATA, ERROR_NOT_ENOUGH_MEMORY, GetLastError,
+        HANDLE, WAIT_OBJECT_0, WAIT_TIMEOUT,
+    };
+    use windows_sys::Win32::Storage::FileSystem::{ReadFile, WriteFile};
+    use windows_sys::Win32::System::Pipes::CreatePipe;
+    use windows_sys::Win32::System::Threading::{
+        CreateEventW, CreateThread, GetExitCodeThread, SetEvent, WaitForSingleObject,
+    };
+
+    const BUFFER_SIZE: usize = 8192;
+
+    fn hresult_from_win32(err: u32) -> HRESULT {
+        if err == 0 {
+            0
+        } else {
+            ((err & 0xFFFF) | 0x80070000) as HRESULT
+        }
+    }
+
+    fn succeeded(hr: HRESULT) -> bool {
+        hr >= 0
+    }
+
+    fn failed(hr: HRESULT) -> bool {
+        hr < 0
+    }
+
+    fn wide_str(s: &str) -> Vec<u16> {
+        s.encode_utf16().chain(core::iter::once(0)).collect()
+    }
+
+    unsafe fn wcslen(s: *const u16) -> usize {
+        unsafe {
+            let mut len = 0;
+            while *s.add(len) != 0 {
+                len += 1;
+            }
+            len
+        }
+    }
+
+    unsafe fn wait_event(event: HANDLE, timeout: u32) -> u32 {
+        unsafe {
+            match WaitForSingleObject(event, timeout) {
+                WAIT_OBJECT_0 => 0,
+                WAIT_TIMEOUT => WAIT_TIMEOUT,
+                _ => GetLastError(),
+            }
+        }
+    }
+
+    struct QueryThreadData {
+        query: Vec<u16>,
+        write_pipe: HANDLE,
+        init_event: HANDLE,
+        connect_event: HANDLE,
+    }
+
+    // SAFETY: QueryThreadData contains HANDLEs (isize) which are safe to send across threads
+    unsafe impl Send for QueryThreadData {}
+
+    unsafe extern "system" fn query_thread(param: *mut c_void) -> u32 {
+        unsafe { query_thread_impl(param) }
+    }
+
+    unsafe fn query_thread_impl(param: *mut c_void) -> u32 {
+        unsafe {
+            let data = Box::from_raw(param as *mut QueryThreadData);
+            let write_pipe = data.write_pipe;
+            let init_event = data.init_event;
+            let connect_event = data.connect_event;
+
+            let mut locator: *mut c_void = null_mut();
+            let mut services: *mut c_void = null_mut();
+            let mut enumerator: *mut c_void = null_mut();
+            let mut hr: HRESULT = 0;
+
+            // gh-125315: Copy the query string first
+            let bstr_query = SysAllocString(data.query.as_ptr());
+            if bstr_query.is_null() {
+                hr = hresult_from_win32(ERROR_NOT_ENOUGH_MEMORY);
+            }
+
+            drop(data);
+
+            if succeeded(hr) {
+                hr = CoInitializeEx(null_mut(), COINIT_APARTMENTTHREADED);
+            }
+
+            if failed(hr) {
+                CloseHandle(write_pipe);
+                if !bstr_query.is_null() {
+                    SysFreeString(bstr_query);
+                }
+                return hr as u32;
+            }
+
+            hr = CoInitializeSecurity(
+                null(),
+                -1,
+                null(),
+                null(),
+                RPC_C_AUTHN_LEVEL_DEFAULT,
+                RPC_C_IMP_LEVEL_IMPERSONATE,
+                null(),
+                EOAC_NONE,
+                null(),
+            );
+            // gh-96684: CoInitializeSecurity will fail if another part of the app has
+            // already called it.
+            if hr == RPC_E_TOO_LATE {
+                hr = 0;
+            }
+
+            if succeeded(hr) {
+                hr = CoCreateInstance(
+                    &CLSID_WBEM_LOCATOR,
+                    null_mut(),
+                    CLSCTX_INPROC_SERVER,
+                    &IID_IWBEM_LOCATOR,
+                    &mut locator,
+                );
+            }
+            if succeeded(hr) && SetEvent(init_event) == 0 {
+                hr = hresult_from_win32(GetLastError());
+            }
+
+            if succeeded(hr) {
+                let root_cimv2 = wide_str("ROOT\\CIMV2");
+                let bstr_root = SysAllocString(root_cimv2.as_ptr());
+                hr = locator_connect_server(
+                    locator,
+                    bstr_root,
+                    null(),
+                    null(),
+                    null(),
+                    0,
+                    null(),
+                    null_mut(),
+                    &mut services,
+                );
+                if !bstr_root.is_null() {
+                    SysFreeString(bstr_root);
+                }
+            }
+            if succeeded(hr) && SetEvent(connect_event) == 0 {
+                hr = hresult_from_win32(GetLastError());
+            }
+
+            if succeeded(hr) {
+                hr = CoSetProxyBlanket(
+                    services,
+                    RPC_C_AUTHN_WINNT,
+                    RPC_C_AUTHZ_NONE,
+                    null(),
+                    RPC_C_AUTHN_LEVEL_CALL,
+                    RPC_C_IMP_LEVEL_IMPERSONATE,
+                    null(),
+                    EOAC_NONE,
+                );
+            }
+            if succeeded(hr) {
+                let wql = wide_str("WQL");
+                let bstr_wql = SysAllocString(wql.as_ptr());
+                hr = services_exec_query(
+                    services,
+                    bstr_wql,
+                    bstr_query,
+                    WBEM_FLAG_FORWARD_ONLY | WBEM_FLAG_RETURN_IMMEDIATELY,
+                    null_mut(),
+                    &mut enumerator,
+                );
+                if !bstr_wql.is_null() {
+                    SysFreeString(bstr_wql);
+                }
+            }
+
+            // Enumerate results and write to pipe
+            let mut value: *mut c_void;
+            let mut start_of_enum = true;
+            let null_sep: u16 = 0;
+            let eq_sign: u16 = b'=' as u16;
+
+            while succeeded(hr) {
+                let mut got: u32 = 0;
+                let mut written: u32 = 0;
+                value = null_mut();
+                hr = enum_next(enumerator, WBEM_INFINITE, 1, &mut value, &mut got);
+
+                if hr == WBEM_S_FALSE {
+                    hr = 0;
+                    break;
+                }
+                if failed(hr) || got != 1 || value.is_null() {
+                    continue;
+                }
+
+                if !start_of_enum
+                    && WriteFile(
+                        write_pipe,
+                        &null_sep as *const u16 as *const _,
+                        2,
+                        &mut written,
+                        null_mut(),
+                    ) == 0
+                {
+                    hr = hresult_from_win32(GetLastError());
+                    com_release(value);
+                    break;
+                }
+                start_of_enum = false;
+
+                hr = object_begin_enumeration(value, 0);
+                if failed(hr) {
+                    com_release(value);
+                    break;
+                }
+
+                while succeeded(hr) {
+                    let mut prop_name: *mut u16 = null_mut();
+                    let mut prop_value = VARIANT::zeroed();
+                    let mut flavor: i32 = 0;
+
+                    hr = object_next(
+                        value,
+                        0,
+                        &mut prop_name,
+                        &mut prop_value,
+                        null_mut(),
+                        &mut flavor,
+                    );
+
+                    if hr == WBEM_S_NO_MORE_DATA {
+                        hr = 0;
+                        break;
+                    }
+
+                    if succeeded(hr)
+                        && (flavor & WBEM_FLAVOR_MASK_ORIGIN) != WBEM_FLAVOR_ORIGIN_SYSTEM
+                    {
+                        let mut prop_str = [0u16; BUFFER_SIZE];
+                        hr =
+                            VariantToString(&prop_value, prop_str.as_mut_ptr(), BUFFER_SIZE as u32);
+
+                        if succeeded(hr) {
+                            let cb_str1 = (wcslen(prop_name) * 2) as u32;
+                            let cb_str2 = (wcslen(prop_str.as_ptr()) * 2) as u32;
+
+                            if WriteFile(
+                                write_pipe,
+                                prop_name as *const _,
+                                cb_str1,
+                                &mut written,
+                                null_mut(),
+                            ) == 0
+                                || WriteFile(
+                                    write_pipe,
+                                    &eq_sign as *const u16 as *const _,
+                                    2,
+                                    &mut written,
+                                    null_mut(),
+                                ) == 0
+                                || WriteFile(
+                                    write_pipe,
+                                    prop_str.as_ptr() as *const _,
+                                    cb_str2,
+                                    &mut written,
+                                    null_mut(),
+                                ) == 0
+                                || WriteFile(
+                                    write_pipe,
+                                    &null_sep as *const u16 as *const _,
+                                    2,
+                                    &mut written,
+                                    null_mut(),
+                                ) == 0
+                            {
+                                hr = hresult_from_win32(GetLastError());
+                            }
+                        }
+
+                        VariantClear(&mut prop_value);
+                        SysFreeString(prop_name);
+                    }
+                }
+
+                object_end_enumeration(value);
+                com_release(value);
+            }
+
+            // Cleanup
+            if !bstr_query.is_null() {
+                SysFreeString(bstr_query);
+            }
+            if !enumerator.is_null() {
+                com_release(enumerator);
+            }
+            if !services.is_null() {
+                com_release(services);
+            }
+            if !locator.is_null() {
+                com_release(locator);
+            }
+            CoUninitialize();
+            CloseHandle(write_pipe);
+
+            hr as u32
+        }
+    }
+
+    /// Runs a WMI query against the local machine.
+    ///
+    /// This returns a single string with 'name=value' pairs in a flat array separated
+    /// by null characters.
+    #[pyfunction]
+    fn exec_query(query: PyStrRef, vm: &VirtualMachine) -> PyResult<String> {
+        let query_str = query.expect_str();
+
+        if !query_str
+            .get(..7)
+            .is_some_and(|s| s.eq_ignore_ascii_case("select "))
+        {
+            return Err(vm.new_value_error("only SELECT queries are supported"));
+        }
+
+        let query_wide = wide_str(query_str);
+
+        let mut h_thread: HANDLE = null_mut();
+        let mut err: u32 = 0;
+        let mut buffer = [0u16; BUFFER_SIZE];
+        let mut offset: u32 = 0;
+        let mut bytes_read: u32 = 0;
+
+        let mut read_pipe: HANDLE = null_mut();
+        let mut write_pipe: HANDLE = null_mut();
+
+        unsafe {
+            let init_event = CreateEventW(null(), 1, 0, null());
+            let connect_event = CreateEventW(null(), 1, 0, null());
+
+            if init_event.is_null()
+                || connect_event.is_null()
+                || CreatePipe(&mut read_pipe, &mut write_pipe, null(), 0) == 0
+            {
+                err = GetLastError();
+            } else {
+                let thread_data = Box::new(QueryThreadData {
+                    query: query_wide,
+                    write_pipe,
+                    init_event,
+                    connect_event,
+                });
+                let thread_data_ptr = Box::into_raw(thread_data);
+
+                h_thread = CreateThread(
+                    null(),
+                    0,
+                    Some(query_thread),
+                    thread_data_ptr as *const _ as *mut _,
+                    0,
+                    null_mut(),
+                );
+
+                if h_thread.is_null() {
+                    err = GetLastError();
+                    // Thread didn't start, so recover data and close write pipe
+                    let data = Box::from_raw(thread_data_ptr);
+                    CloseHandle(data.write_pipe);
+                }
+            }
+
+            // gh-112278: Timeout for COM init and WMI connection
+            if err == 0 {
+                err = wait_event(init_event, 1000);
+                if err == 0 {
+                    err = wait_event(connect_event, 100);
+                }
+            }
+
+            // Read results from pipe
+            while err == 0 {
+                let buf_ptr = (buffer.as_mut_ptr() as *mut u8).add(offset as usize);
+                let buf_remaining = (BUFFER_SIZE * 2) as u32 - offset;
+
+                if ReadFile(
+                    read_pipe,
+                    buf_ptr as *mut _,
+                    buf_remaining,
+                    &mut bytes_read,
+                    null_mut(),
+                ) != 0
+                {
+                    offset += bytes_read;
+                    if offset >= (BUFFER_SIZE * 2) as u32 {
+                        err = ERROR_MORE_DATA;
+                    }
+                } else {
+                    err = GetLastError();
+                }
+            }
+
+            if !read_pipe.is_null() {
+                CloseHandle(read_pipe);
+            }
+
+            if !h_thread.is_null() {
+                let thread_err: u32;
+                match WaitForSingleObject(h_thread, 100) {
+                    WAIT_OBJECT_0 => {
+                        let mut exit_code: u32 = 0;
+                        if GetExitCodeThread(h_thread, &mut exit_code) == 0 {
+                            thread_err = GetLastError();
+                        } else {
+                            thread_err = exit_code;
+                        }
+                    }
+                    WAIT_TIMEOUT => {
+                        thread_err = WAIT_TIMEOUT;
+                    }
+                    _ => {
+                        thread_err = GetLastError();
+                    }
+                }
+                if err == 0 || err == ERROR_BROKEN_PIPE {
+                    err = thread_err;
+                }
+
+                CloseHandle(h_thread);
+            }
+
+            CloseHandle(init_event);
+            CloseHandle(connect_event);
+        }
+
+        if err == ERROR_MORE_DATA {
+            return Err(vm.new_os_error(format!(
+                "Query returns more than {} characters",
+                BUFFER_SIZE,
+            )));
+        } else if err != 0 {
+            return Err(std::io::Error::from_raw_os_error(err as i32).to_pyexception(vm));
+        }
+
+        if offset == 0 {
+            return Ok(String::new());
+        }
+
+        let char_count = (offset as usize) / 2 - 1;
+        Ok(String::from_utf16_lossy(&buffer[..char_count]))
+    }
+}
diff --git a/crates/vm/src/stdlib/ast.rs b/crates/vm/src/stdlib/ast.rs
deleted file mode 100644
index cb7bfc289b0..00000000000
--- a/crates/vm/src/stdlib/ast.rs
+++ /dev/null
@@ -1,369 +0,0 @@
-//! `ast` standard module for abstract syntax trees.
-
-//!
-//! This module makes use of the parser logic, and translates all ast nodes
-//! into python ast.AST objects.
-
-pub(crate) use python::_ast::module_def;
-
-mod pyast;
-
-use crate::builtins::{PyInt, PyStr};
-use crate::stdlib::ast::module::{Mod, ModInteractive};
-use crate::stdlib::ast::node::BoxedSlice;
-use crate::{
-    AsObject, Context, Py, PyObject, PyObjectRef, PyPayload, PyRef, PyRefExact, PyResult,
-    TryFromObject, VirtualMachine,
-    builtins::PyIntRef,
-    builtins::{PyDict, PyModule, PyStrRef, PyType},
-    class::{PyClassImpl, StaticType},
-    compiler::{CompileError, ParseError},
-    convert::ToPyObject,
-};
-use node::Node;
-use ruff_python_ast as ast;
-use ruff_text_size::{Ranged, TextRange, TextSize};
-use rustpython_compiler_core::{
-    LineIndex, OneIndexed, PositionEncoding, SourceFile, SourceFileBuilder, SourceLocation,
-};
-
-#[cfg(feature = "parser")]
-use ruff_python_parser as parser;
-
-#[cfg(feature = "codegen")]
-use rustpython_codegen as codegen;
-
-pub(crate) use python::_ast::NodeAst;
-
-mod python;
-
-mod argument;
-mod basic;
-mod constant;
-mod elif_else_clause;
-mod exception;
-mod expression;
-mod module;
-mod node;
-mod operator;
-mod other;
-mod parameter;
-mod pattern;
-mod statement;
-mod string;
-mod type_ignore;
-mod type_parameters;
-
-fn get_node_field(vm: &VirtualMachine, obj: &PyObject, field: &'static str, typ: &str) -> PyResult {
-    vm.get_attribute_opt(obj.to_owned(), field)?
-        .ok_or_else(|| vm.new_type_error(format!(r#"required field "{field}" missing from {typ}"#)))
-}
-
-fn get_node_field_opt(
-    vm: &VirtualMachine,
-    obj: &PyObject,
-    field: &'static str,
-) -> PyResult<Option<PyObjectRef>> {
-    Ok(vm
-        .get_attribute_opt(obj.to_owned(), field)?
-        .filter(|obj| !vm.is_none(obj)))
-}
-
-fn get_int_field(
-    vm: &VirtualMachine,
-    obj: &PyObject,
-    field: &'static str,
-    typ: &str,
-) -> PyResult<PyRefExact<PyInt>> {
-    get_node_field(vm, obj, field, typ)?
-        .downcast_exact(vm)
-        .map_err(|_| vm.new_type_error(format!(r#"field "{field}" must have integer type"#)))
-}
-
-struct PySourceRange {
-    start: PySourceLocation,
-    end: PySourceLocation,
-}
-
-pub struct PySourceLocation {
-    row: Row,
-    column: Column,
-}
-
-impl PySourceLocation {
-    const fn to_source_location(&self) -> SourceLocation {
-        SourceLocation {
-            line: self.row.get_one_indexed(),
-            character_offset: self.column.get_one_indexed(),
-        }
-    }
-}
-
-/// A one-based index into the lines.
-#[derive(Clone, Copy)]
-struct Row(OneIndexed);
-
-impl Row {
-    const fn get(self) -> usize {
-        self.0.get()
-    }
-
-    const fn get_one_indexed(self) -> OneIndexed {
-        self.0
-    }
-}
-
-/// An UTF-8 index into the line.
-#[derive(Clone, Copy)]
-struct Column(TextSize);
-
-impl Column {
-    const fn get(self) -> usize {
-        self.0.to_usize()
-    }
-
-    const fn get_one_indexed(self) -> OneIndexed {
-        OneIndexed::from_zero_indexed(self.get())
-    }
-}
-
-fn text_range_to_source_range(source_file: &SourceFile, text_range: TextRange) -> PySourceRange {
-    let index = LineIndex::from_source_text(source_file.clone().source_text());
-    let source = &source_file.source_text();
-
-    if source.is_empty() {
-        return PySourceRange {
-            start: PySourceLocation {
-                row: Row(OneIndexed::from_zero_indexed(0)),
-                column: Column(TextSize::new(0)),
-            },
-            end: PySourceLocation {
-                row: Row(OneIndexed::from_zero_indexed(0)),
-                column: Column(TextSize::new(0)),
-            },
-        };
-    }
-
-    let start_row = index.line_index(text_range.start());
-    let end_row = index.line_index(text_range.end());
-    let start_col = text_range.start() - index.line_start(start_row, source);
-    let end_col = text_range.end() - index.line_start(end_row, source);
-
-    PySourceRange {
-        start: PySourceLocation {
-            row: Row(start_row),
-            column: Column(start_col),
-        },
-        end: PySourceLocation {
-            row: Row(end_row),
-            column: Column(end_col),
-        },
-    }
-}
-
-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,
-    object: PyObjectRef,
-    name: &str,
-) -> PyResult<TextRange> {
-    let start_row = get_int_field(vm, &object, "lineno", name)?;
-    let start_column = get_int_field(vm, &object, "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(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(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)),
-        },
-    };
-
-    Ok(source_range_to_text_range(source_file, location))
-}
-
-fn source_range_to_text_range(source_file: &SourceFile, location: PySourceRange) -> TextRange {
-    let index = LineIndex::from_source_text(source_file.clone().source_text());
-    let source = &source_file.source_text();
-
-    if source.is_empty() {
-        return TextRange::new(TextSize::new(0), TextSize::new(0));
-    }
-
-    let start = index.offset(
-        location.start.to_source_location(),
-        source,
-        PositionEncoding::Utf8,
-    );
-    let end = index.offset(
-        location.end.to_source_location(),
-        source,
-        PositionEncoding::Utf8,
-    );
-
-    TextRange::new(start, end)
-}
-
-fn node_add_location(
-    dict: &Py<PyDict>,
-    range: TextRange,
-    vm: &VirtualMachine,
-    source_file: &SourceFile,
-) {
-    let range = text_range_to_source_range(source_file, range);
-    dict.set_item("lineno", vm.ctx.new_int(range.start.row.get()).into(), vm)
-        .unwrap();
-    dict.set_item(
-        "col_offset",
-        vm.ctx.new_int(range.start.column.get()).into(),
-        vm,
-    )
-    .unwrap();
-    dict.set_item("end_lineno", vm.ctx.new_int(range.end.row.get()).into(), vm)
-        .unwrap();
-    dict.set_item(
-        "end_col_offset",
-        vm.ctx.new_int(range.end.column.get()).into(),
-        vm,
-    )
-    .unwrap();
-}
-
-#[cfg(feature = "parser")]
-pub(crate) fn parse(
-    vm: &VirtualMachine,
-    source: &str,
-    mode: parser::Mode,
-) -> 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| {
-            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 {
-        ast::Mod::Module(m) => Mod::Module(m),
-        ast::Mod::Expression(e) => Mod::Expression(e),
-    };
-    Ok(top.ast_to_object(vm, &source_file))
-}
-
-#[cfg(feature = "codegen")]
-pub(crate) fn compile(
-    vm: &VirtualMachine,
-    object: PyObjectRef,
-    filename: &str,
-    mode: crate::compiler::Mode,
-    optimize: Option<u8>,
-) -> PyResult {
-    let mut opts = vm.compile_opts();
-    if let Some(optimize) = optimize {
-        opts.optimize = optimize;
-    }
-
-    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) => ast::Mod::Module(m),
-        Mod::Interactive(ModInteractive { range, body }) => ast::Mod::Module(ast::ModModule {
-            node_index: Default::default(),
-            range,
-            body,
-        }),
-        Mod::Expression(e) => ast::Mod::Expression(e),
-        Mod::FunctionType(_) => todo!(),
-    };
-    // TODO: create a textual representation of the ast
-    let text = "";
-    let source_file = SourceFileBuilder::new(filename, text).finish();
-    let code = codegen::compile::compile_top(ast, source_file, mode, opts)
-        .map_err(|err| vm.new_syntax_error(&err.into(), None))?; // FIXME source
-    Ok(vm.ctx.new_code(code).into())
-}
-
-// Used by builtins::compile()
-pub const PY_COMPILE_FLAG_AST_ONLY: i32 = 0x0400;
-
-// The following flags match the values from Include/cpython/compile.h
-// Caveat emptor: These flags are undocumented on purpose and depending
-// on their effect outside the standard library is **unsupported**.
-pub const PY_CF_DONT_IMPLY_DEDENT: i32 = 0x200;
-pub const PY_CF_ALLOW_INCOMPLETE_INPUT: i32 = 0x4000;
-pub const PY_CF_OPTIMIZED_AST: i32 = 0x8000 | PY_COMPILE_FLAG_AST_ONLY;
-pub const PY_CF_TYPE_COMMENTS: i32 = 0x1000;
-
-// __future__ flags - sync with Lib/__future__.py
-// TODO: These flags aren't being used in rust code
-//       CO_FUTURE_ANNOTATIONS does make a difference in the codegen,
-//       so it should be used in compile().
-//       see compiler/codegen/src/compile.rs
-const CO_NESTED: i32 = 0x0010;
-const CO_GENERATOR_ALLOWED: i32 = 0;
-const CO_FUTURE_DIVISION: i32 = 0x20000;
-const CO_FUTURE_ABSOLUTE_IMPORT: i32 = 0x40000;
-const CO_FUTURE_WITH_STATEMENT: i32 = 0x80000;
-const CO_FUTURE_PRINT_FUNCTION: i32 = 0x100000;
-const CO_FUTURE_UNICODE_LITERALS: i32 = 0x200000;
-const CO_FUTURE_BARRY_AS_BDFL: i32 = 0x400000;
-const CO_FUTURE_GENERATOR_STOP: i32 = 0x800000;
-const CO_FUTURE_ANNOTATIONS: i32 = 0x1000000;
-
-// Used by builtins::compile() - the summary of all flags
-pub const PY_COMPILE_FLAGS_MASK: i32 = PY_COMPILE_FLAG_AST_ONLY
-    | PY_CF_DONT_IMPLY_DEDENT
-    | PY_CF_ALLOW_INCOMPLETE_INPUT
-    | PY_CF_OPTIMIZED_AST
-    | PY_CF_TYPE_COMMENTS
-    | CO_NESTED
-    | CO_GENERATOR_ALLOWED
-    | CO_FUTURE_DIVISION
-    | CO_FUTURE_ABSOLUTE_IMPORT
-    | CO_FUTURE_WITH_STATEMENT
-    | CO_FUTURE_PRINT_FUNCTION
-    | CO_FUTURE_UNICODE_LITERALS
-    | CO_FUTURE_BARRY_AS_BDFL
-    | CO_FUTURE_GENERATOR_STOP
-    | CO_FUTURE_ANNOTATIONS;
diff --git a/crates/vm/src/stdlib/ast/pyast.rs b/crates/vm/src/stdlib/ast/pyast.rs
deleted file mode 100644
index 2131df29b96..00000000000
--- a/crates/vm/src/stdlib/ast/pyast.rs
+++ /dev/null
@@ -1,1051 +0,0 @@
-#![allow(clippy::all)]
-
-use super::*;
-use crate::common::ascii;
-use crate::function::FuncArgs;
-use crate::types::Initializer;
-
-macro_rules! impl_node {
-    (
-        #[pyclass(module = $_mod:literal, name = $_name:literal, base = $base:ty)]
-        $vis:vis struct $name:ident,
-        fields: [$($field:expr),* $(,)?],
-        attributes: [$($attr:expr),* $(,)?] $(,)?
-    ) => {
-        #[pyclass(module = $_mod, name = $_name, base = $base)]
-        #[repr(transparent)]
-        $vis struct $name($base);
-
-        #[pyclass(flags(HAS_DICT, BASETYPE))]
-        impl $name {
-            #[extend_class]
-            fn extend_class_with_fields(ctx: &Context, class: &'static Py<PyType>) {
-                class.set_attr(
-                    identifier!(ctx, _fields),
-                    ctx.new_tuple(vec![
-                        $(
-                            ctx.new_str(ascii!($field)).into()
-                        ),*
-                    ]).into(),
-                );
-
-                class.set_attr(
-                    identifier!(ctx, _attributes),
-                    ctx.new_list(vec![
-                        $(
-                            ctx.new_str(ascii!($attr)).into()
-                        ),*
-                    ]).into(),
-                );
-            }
-        }
-    };
-    // Without attributes
-    (
-        #[pyclass(module = $_mod:literal, name = $_name:literal, base = $base:ty)]
-        $vis:vis struct $name:ident,
-        fields: [$($field:expr),* $(,)?] $(,)?
-    ) => {
-        impl_node!(
-            #[pyclass(module = $_mod, name = $_name, base = $base)]
-            $vis struct $name,
-            fields: [$($field),*],
-            attributes: [],
-        );
-    };
-    // Without fields
-    (
-        #[pyclass(module = $_mod:literal, name = $_name:literal, base = $base:ty)]
-        $vis:vis struct $name:ident,
-        attributes: [$($attr:expr),* $(,)?] $(,)?
-    ) => {
-        impl_node!(
-            #[pyclass(module = $_mod, name = $_name, base = $base)]
-            $vis struct $name,
-            fields: [],
-            attributes: [$($attr),*],
-        );
-    };
-    // Without fields and attributes
-    (
-        #[pyclass(module = $_mod:literal, name = $_name:literal, base = $base:ty)]
-        $vis:vis struct $name:ident $(,)?
-    ) => {
-        impl_node!(
-            #[pyclass(module = $_mod, name = $_name, base = $base)]
-            $vis struct $name,
-            fields: [],
-            attributes: [],
-        );
-    };
-}
-
-#[pyclass(module = "_ast", name = "mod", base = NodeAst)]
-pub(crate) struct NodeMod(NodeAst);
-
-#[pyclass(flags(HAS_DICT, BASETYPE))]
-impl NodeMod {}
-
-impl_node!(
-    #[pyclass(module = "_ast", name = "Module", base = NodeMod)]
-    pub(crate) struct NodeModModule,
-    fields: ["body", "type_ignores"],
-);
-
-impl_node!(
-    #[pyclass(module = "_ast", name = "Interactive", base = NodeMod)]
-    pub(crate) struct NodeModInteractive,
-    fields: ["body"],
-);
-
-impl_node!(
-    #[pyclass(module = "_ast", name = "Expression", base = NodeMod)]
-    pub(crate) struct NodeModExpression,
-    fields: ["body"],
-);
-
-#[pyclass(module = "_ast", name = "stmt", base = NodeAst)]
-#[repr(transparent)]
-pub(crate) struct NodeStmt(NodeAst);
-
-#[pyclass(flags(HAS_DICT, BASETYPE))]
-impl NodeStmt {}
-
-impl_node!(
-    #[pyclass(module = "_ast", name = "FunctionType", base = NodeMod)]
-    pub(crate) struct NodeModFunctionType,
-    fields: ["argtypes", "returns"],
-);
-
-impl_node!(
-    #[pyclass(module = "_ast", name = "FunctionDef", base = NodeStmt)]
-    pub(crate) struct NodeStmtFunctionDef,
-    fields: ["name", "args", "body", "decorator_list", "returns", "type_comment", "type_params"],
-    attributes: ["lineno", "col_offset", "end_lineno", "end_col_offset"],
-);
-
-impl_node!(
-    #[pyclass(module = "_ast", name = "AsyncFunctionDef", base = NodeStmt)]
-    pub(crate) struct NodeStmtAsyncFunctionDef,
-    fields: ["name", "args", "body", "decorator_list", "returns", "type_comment", "type_params"],
-    attributes: ["lineno", "col_offset", "end_lineno", "end_col_offset"],
-);
-
-impl_node!(
-    #[pyclass(module = "_ast", name = "ClassDef", base = NodeStmt)]
-    pub(crate) struct NodeStmtClassDef,
-    fields: ["name", "bases", "keywords", "body", "decorator_list", "type_params"],
-    attributes: ["lineno", "col_offset", "end_lineno", "end_col_offset"],
-);
-
-impl_node!(
-    #[pyclass(module = "_ast", name = "Return", base = NodeStmt)]
-    pub(crate) struct NodeStmtReturn,
-    fields: ["value"],
-    attributes: ["lineno", "col_offset", "end_lineno", "end_col_offset"],
-);
-
-impl_node!(
-    #[pyclass(module = "_ast", name = "Delete", base = NodeStmt)]
-    pub(crate) struct NodeStmtDelete,
-    fields: ["targets"],
-    attributes: ["lineno", "col_offset", "end_lineno", "end_col_offset"],
-);
-
-impl_node!(
-    #[pyclass(module = "_ast", name = "Assign", base = NodeStmt)]
-    pub(crate) struct NodeStmtAssign,
-    fields: ["targets", "value", "type_comment"],
-    attributes: ["lineno", "col_offset", "end_lineno", "end_col_offset"],
-);
-
-impl_node!(
-    #[pyclass(module = "_ast", name = "TypeAlias", base = NodeStmt)]
-    pub(crate) struct NodeStmtTypeAlias,
-    fields: ["name", "type_params", "value"],
-    attributes: ["lineno", "col_offset", "end_lineno", "end_col_offset"],
-);
-
-impl_node!(
-    #[pyclass(module = "_ast", name = "AugAssign", base = NodeStmt)]
-    pub(crate) struct NodeStmtAugAssign,
-    fields: ["target", "op", "value"],
-    attributes: ["lineno", "col_offset", "end_lineno", "end_col_offset"],
-);
-
-impl_node!(
-    #[pyclass(module = "_ast", name = "AnnAssign", base = NodeStmt)]
-    pub(crate) struct NodeStmtAnnAssign,
-    fields: ["target", "annotation", "value", "simple"],
-    attributes: ["lineno", "col_offset", "end_lineno", "end_col_offset"],
-);
-
-impl_node!(
-    #[pyclass(module = "_ast", name = "For", base = NodeStmt)]
-    pub(crate) struct NodeStmtFor,
-    fields: ["target", "iter", "body", "orelse", "type_comment"],
-    attributes: ["lineno", "col_offset", "end_lineno", "end_col_offset"],
-);
-
-impl_node!(
-    #[pyclass(module = "_ast", name = "AsyncFor", base = NodeStmt)]
-    pub(crate) struct NodeStmtAsyncFor,
-    fields: ["target", "iter", "body", "orelse", "type_comment"],
-    attributes: ["lineno", "col_offset", "end_lineno", "end_col_offset"],
-);
-
-impl_node!(
-    #[pyclass(module = "_ast", name = "While", base = NodeStmt)]
-    pub(crate) struct NodeStmtWhile,
-    fields: ["test", "body", "orelse"],
-    attributes: ["lineno", "col_offset", "end_lineno", "end_col_offset"],
-);
-
-impl_node!(
-    #[pyclass(module = "_ast", name = "If", base = NodeStmt)]
-    pub(crate) struct NodeStmtIf,
-    fields: ["test", "body", "orelse"],
-    attributes: ["lineno", "col_offset", "end_lineno", "end_col_offset"],
-);
-
-impl_node!(
-    #[pyclass(module = "_ast", name = "With", base = NodeStmt)]
-    pub(crate) struct NodeStmtWith,
-    fields: ["items", "body", "type_comment"],
-    attributes: ["lineno", "col_offset", "end_lineno", "end_col_offset"],
-);
-
-impl_node!(
-    #[pyclass(module = "_ast", name = "AsyncWith", base = NodeStmt)]
-    pub(crate) struct NodeStmtAsyncWith,
-    fields: ["items", "body", "type_comment"],
-    attributes: ["lineno", "col_offset", "end_lineno", "end_col_offset"],
-);
-
-impl_node!(
-    #[pyclass(module = "_ast", name = "Match", base = NodeStmt)]
-    pub(crate) struct NodeStmtMatch,
-    fields: ["subject", "cases"],
-    attributes: ["lineno", "col_offset", "end_lineno", "end_col_offset"],
-);
-
-impl_node!(
-    #[pyclass(module = "_ast", name = "Raise", base = NodeStmt)]
-    pub(crate) struct NodeStmtRaise,
-    fields: ["exc", "cause"],
-    attributes: ["lineno", "col_offset", "end_lineno", "end_col_offset"],
-);
-
-impl_node!(
-    #[pyclass(module = "_ast", name = "Try", base = NodeStmt)]
-    pub(crate) struct NodeStmtTry,
-    fields: ["body", "handlers", "orelse", "finalbody"],
-    attributes: ["lineno", "col_offset", "end_lineno", "end_col_offset"],
-);
-
-impl_node!(
-    #[pyclass(module = "_ast", name = "TryStar", base = NodeStmt)]
-    pub(crate) struct NodeStmtTryStar,
-    fields: ["body", "handlers", "orelse", "finalbody"],
-    attributes: ["lineno", "col_offset", "end_lineno", "end_col_offset"],
-);
-
-impl_node!(
-    #[pyclass(module = "_ast", name = "Assert", base = NodeStmt)]
-    pub(crate) struct NodeStmtAssert,
-    fields: ["test", "msg"],
-    attributes: ["lineno", "col_offset", "end_lineno", "end_col_offset"],
-);
-
-impl_node!(
-    #[pyclass(module = "_ast", name = "Import", base = NodeStmt)]
-    pub(crate) struct NodeStmtImport,
-    fields: ["names"],
-    attributes: ["lineno", "col_offset", "end_lineno", "end_col_offset"],
-);
-
-impl_node!(
-    #[pyclass(module = "_ast", name = "ImportFrom", base = NodeStmt)]
-    pub(crate) struct NodeStmtImportFrom,
-    fields: ["module", "names", "level"],
-    attributes: ["lineno", "col_offset", "end_lineno", "end_col_offset"],
-);
-
-impl_node!(
-    #[pyclass(module = "_ast", name = "Global", base = NodeStmt)]
-    pub(crate) struct NodeStmtGlobal,
-    fields: ["names"],
-    attributes: ["lineno", "col_offset", "end_lineno", "end_col_offset"],
-);
-
-impl_node!(
-    #[pyclass(module = "_ast", name = "Nonlocal", base = NodeStmt)]
-    pub(crate) struct NodeStmtNonlocal,
-    fields: ["names"],
-    attributes: ["lineno", "col_offset", "end_lineno", "end_col_offset"],
-);
-
-impl_node!(
-    #[pyclass(module = "_ast", name = "Expr", base = NodeStmt)]
-    pub(crate) struct NodeStmtExpr,
-    fields: ["value"],
-    attributes: ["lineno", "col_offset", "end_lineno", "end_col_offset"],
-);
-
-impl_node!(
-    #[pyclass(module = "_ast", name = "Pass", base = NodeStmt)]
-    pub(crate) struct NodeStmtPass,
-    attributes: ["lineno", "col_offset", "end_lineno", "end_col_offset"],
-);
-
-impl_node!(
-    #[pyclass(module = "_ast", name = "Break", base = NodeStmt)]
-    pub(crate) struct NodeStmtBreak,
-    attributes: ["lineno", "col_offset", "end_lineno", "end_col_offset"],
-);
-
-#[pyclass(module = "_ast", name = "expr", base = NodeAst)]
-#[repr(transparent)]
-pub(crate) struct NodeExpr(NodeAst);
-
-#[pyclass(flags(HAS_DICT, BASETYPE))]
-impl NodeExpr {}
-
-impl_node!(
-    #[pyclass(module = "_ast", name = "Continue", base = NodeStmt)]
-    pub(crate) struct NodeStmtContinue,
-    attributes: ["lineno", "col_offset", "end_lineno", "end_col_offset"],
-);
-
-impl_node!(
-    #[pyclass(module = "_ast", name = "BoolOp", base = NodeExpr)]
-    pub(crate) struct NodeExprBoolOp,
-    fields: ["op", "values"],
-    attributes: ["lineno", "col_offset", "end_lineno", "end_col_offset"],
-);
-
-impl_node!(
-    #[pyclass(module = "_ast", name = "NamedExpr", base = NodeExpr)]
-    pub(crate) struct NodeExprNamedExpr,
-    fields: ["target", "value"],
-    attributes: ["lineno", "col_offset", "end_lineno", "end_col_offset"],
-);
-
-impl_node!(
-    #[pyclass(module = "_ast", name = "BinOp", base = NodeExpr)]
-    pub(crate) struct NodeExprBinOp,
-    fields: ["left", "op", "right"],
-    attributes: ["lineno", "col_offset", "end_lineno", "end_col_offset"],
-);
-
-impl_node!(
-    #[pyclass(module = "_ast", name = "UnaryOp", base = NodeExpr)]
-    pub(crate) struct NodeExprUnaryOp,
-    fields: ["op", "operand"],
-    attributes: ["lineno", "col_offset", "end_lineno", "end_col_offset"],
-);
-
-impl_node!(
-    #[pyclass(module = "_ast", name = "Lambda", base = NodeExpr)]
-    pub(crate) struct NodeExprLambda,
-    fields: ["args", "body"],
-    attributes: ["lineno", "col_offset", "end_lineno", "end_col_offset"],
-);
-
-impl_node!(
-    #[pyclass(module = "_ast", name = "IfExp", base = NodeExpr)]
-    pub(crate) struct NodeExprIfExp,
-    fields: ["test", "body", "orelse"],
-    attributes: ["lineno", "col_offset", "end_lineno", "end_col_offset"],
-);
-
-impl_node!(
-    #[pyclass(module = "_ast", name = "Dict", base = NodeExpr)]
-    pub(crate) struct NodeExprDict,
-    fields: ["keys", "values"],
-    attributes: ["lineno", "col_offset", "end_lineno", "end_col_offset"],
-);
-
-impl_node!(
-    #[pyclass(module = "_ast", name = "Set", base = NodeExpr)]
-    pub(crate) struct NodeExprSet,
-    fields: ["elts"],
-    attributes: ["lineno", "col_offset", "end_lineno", "end_col_offset"],
-);
-
-impl_node!(
-    #[pyclass(module = "_ast", name = "ListComp", base = NodeExpr)]
-    pub(crate) struct NodeExprListComp,
-    fields: ["elt", "generators"],
-    attributes: ["lineno", "col_offset", "end_lineno", "end_col_offset"],
-);
-
-impl_node!(
-    #[pyclass(module = "_ast", name = "SetComp", base = NodeExpr)]
-    pub(crate) struct NodeExprSetComp,
-    fields: ["elt", "generators"],
-    attributes: ["lineno", "col_offset", "end_lineno", "end_col_offset"],
-);
-
-impl_node!(
-    #[pyclass(module = "_ast", name = "DictComp", base = NodeExpr)]
-    pub(crate) struct NodeExprDictComp,
-    fields: ["key", "value", "generators"],
-    attributes: ["lineno", "col_offset", "end_lineno", "end_col_offset"],
-);
-
-impl_node!(
-    #[pyclass(module = "_ast", name = "GeneratorExp", base = NodeExpr)]
-    pub(crate) struct NodeExprGeneratorExp,
-    fields: ["elt", "generators"],
-    attributes: ["lineno", "col_offset", "end_lineno", "end_col_offset"],
-);
-
-impl_node!(
-    #[pyclass(module = "_ast", name = "Await", base = NodeExpr)]
-    pub(crate) struct NodeExprAwait,
-    fields: ["value"],
-    attributes: ["lineno", "col_offset", "end_lineno", "end_col_offset"],
-);
-
-impl_node!(
-    #[pyclass(module = "_ast", name = "Yield", base = NodeExpr)]
-    pub(crate) struct NodeExprYield,
-    fields: ["value"],
-    attributes: ["lineno", "col_offset", "end_lineno", "end_col_offset"],
-);
-
-impl_node!(
-    #[pyclass(module = "_ast", name = "YieldFrom", base = NodeExpr)]
-    pub(crate) struct NodeExprYieldFrom,
-    fields: ["value"],
-    attributes: ["lineno", "col_offset", "end_lineno", "end_col_offset"],
-);
-
-impl_node!(
-    #[pyclass(module = "_ast", name = "Compare", base = NodeExpr)]
-    pub(crate) struct NodeExprCompare,
-    fields: ["left", "ops", "comparators"],
-    attributes: ["lineno", "col_offset", "end_lineno", "end_col_offset"],
-);
-
-impl_node!(
-    #[pyclass(module = "_ast", name = "Call", base = NodeExpr)]
-    pub(crate) struct NodeExprCall,
-    fields: ["func", "args", "keywords"],
-    attributes: ["lineno", "col_offset", "end_lineno", "end_col_offset"],
-);
-
-impl_node!(
-    #[pyclass(module = "_ast", name = "FormattedValue", base = NodeExpr)]
-    pub(crate) struct NodeExprFormattedValue,
-    fields: ["value", "conversion", "format_spec"],
-    attributes: ["lineno", "col_offset", "end_lineno", "end_col_offset"],
-);
-
-impl_node!(
-    #[pyclass(module = "_ast", name = "JoinedStr", base = NodeExpr)]
-    pub(crate) struct NodeExprJoinedStr,
-    fields: ["values"],
-    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"],
-);
-
-// NodeExprConstant needs custom Initializer to default kind to None
-#[pyclass(module = "_ast", name = "Constant", base = NodeExpr)]
-#[repr(transparent)]
-pub(crate) struct NodeExprConstant(NodeExpr);
-
-#[pyclass(flags(HAS_DICT, BASETYPE), with(Initializer))]
-impl NodeExprConstant {
-    #[extend_class]
-    fn extend_class_with_fields(ctx: &Context, class: &'static Py<PyType>) {
-        class.set_attr(
-            identifier!(ctx, _fields),
-            ctx.new_tuple(vec![
-                ctx.new_str(ascii!("value")).into(),
-                ctx.new_str(ascii!("kind")).into(),
-            ])
-            .into(),
-        );
-
-        class.set_attr(
-            identifier!(ctx, _attributes),
-            ctx.new_list(vec![
-                ctx.new_str(ascii!("lineno")).into(),
-                ctx.new_str(ascii!("col_offset")).into(),
-                ctx.new_str(ascii!("end_lineno")).into(),
-                ctx.new_str(ascii!("end_col_offset")).into(),
-            ])
-            .into(),
-        );
-    }
-}
-
-impl Initializer for NodeExprConstant {
-    type Args = FuncArgs;
-
-    fn slot_init(zelf: PyObjectRef, args: FuncArgs, vm: &VirtualMachine) -> PyResult<()> {
-        <NodeAst as Initializer>::slot_init(zelf.clone(), args, vm)?;
-        // kind defaults to None if not provided
-        let dict = zelf.as_object().dict().unwrap();
-        if !dict.contains_key("kind", vm) {
-            dict.set_item("kind", vm.ctx.none(), vm)?;
-        }
-        Ok(())
-    }
-
-    fn init(_zelf: PyRef<Self>, _args: Self::Args, _vm: &VirtualMachine) -> PyResult<()> {
-        unreachable!("slot_init is defined")
-    }
-}
-
-impl_node!(
-    #[pyclass(module = "_ast", name = "Attribute", base = NodeExpr)]
-    pub(crate) struct NodeExprAttribute,
-    fields: ["value", "attr", "ctx"],
-    attributes: ["lineno", "col_offset", "end_lineno", "end_col_offset"],
-);
-
-impl_node!(
-    #[pyclass(module = "_ast", name = "Subscript", base = NodeExpr)]
-    pub(crate) struct NodeExprSubscript,
-    fields: ["value", "slice", "ctx"],
-    attributes: ["lineno", "col_offset", "end_lineno", "end_col_offset"],
-);
-
-impl_node!(
-    #[pyclass(module = "_ast", name = "Starred", base = NodeExpr)]
-    pub(crate) struct NodeExprStarred,
-    fields: ["value", "ctx"],
-    attributes: ["lineno", "col_offset", "end_lineno", "end_col_offset"],
-);
-
-impl_node!(
-    #[pyclass(module = "_ast", name = "Name", base = NodeExpr)]
-    pub(crate) struct NodeExprName,
-    fields: ["id", "ctx"],
-    attributes: ["lineno", "col_offset", "end_lineno", "end_col_offset"],
-);
-
-impl_node!(
-    #[pyclass(module = "_ast", name = "List", base = NodeExpr)]
-    pub(crate) struct NodeExprList,
-    fields: ["elts", "ctx"],
-    attributes: ["lineno", "col_offset", "end_lineno", "end_col_offset"],
-);
-
-impl_node!(
-    #[pyclass(module = "_ast", name = "Tuple", base = NodeExpr)]
-    pub(crate) struct NodeExprTuple,
-    fields: ["elts", "ctx"],
-    attributes: ["lineno", "col_offset", "end_lineno", "end_col_offset"],
-);
-
-#[pyclass(module = "_ast", name = "expr_context", base = NodeAst)]
-#[repr(transparent)]
-pub(crate) struct NodeExprContext(NodeAst);
-
-#[pyclass(flags(HAS_DICT, BASETYPE))]
-impl NodeExprContext {}
-
-impl_node!(
-    #[pyclass(module = "_ast", name = "Slice", base = NodeExpr)]
-    pub(crate) struct NodeExprSlice,
-    fields: ["lower", "upper", "step"],
-    attributes: ["lineno", "col_offset", "end_lineno", "end_col_offset"],
-);
-
-impl_node!(
-    #[pyclass(module = "_ast", name = "Load", base = NodeExprContext)]
-    pub(crate) struct NodeExprContextLoad,
-);
-
-impl_node!(
-    #[pyclass(module = "_ast", name = "Store", base = NodeExprContext)]
-    pub(crate) struct NodeExprContextStore,
-);
-
-#[pyclass(module = "_ast", name = "boolop", base = NodeAst)]
-#[repr(transparent)]
-pub(crate) struct NodeBoolOp(NodeAst);
-
-#[pyclass(flags(HAS_DICT, BASETYPE))]
-impl NodeBoolOp {}
-
-impl_node!(
-    #[pyclass(module = "_ast", name = "Del", base = NodeExprContext)]
-    pub(crate) struct NodeExprContextDel,
-);
-
-impl_node!(
-    #[pyclass(module = "_ast", name = "And", base = NodeBoolOp)]
-    pub(crate) struct NodeBoolOpAnd,
-);
-
-#[pyclass(module = "_ast", name = "operator", base = NodeAst)]
-#[repr(transparent)]
-pub(crate) struct NodeOperator(NodeAst);
-
-#[pyclass(flags(HAS_DICT, BASETYPE))]
-impl NodeOperator {}
-
-impl_node!(
-    #[pyclass(module = "_ast", name = "Or", base = NodeBoolOp)]
-    pub(crate) struct NodeBoolOpOr,
-);
-
-impl_node!(
-    #[pyclass(module = "_ast", name = "Add", base = NodeOperator)]
-    pub(crate) struct NodeOperatorAdd,
-);
-
-impl_node!(
-    #[pyclass(module = "_ast", name = "Sub", base = NodeOperator)]
-    pub(crate) struct NodeOperatorSub,
-);
-
-impl_node!(
-    #[pyclass(module = "_ast", name = "Mult", base = NodeOperator)]
-    pub(crate) struct NodeOperatorMult,
-);
-
-impl_node!(
-    #[pyclass(module = "_ast", name = "MatMult", base = NodeOperator)]
-    pub(crate) struct NodeOperatorMatMult,
-);
-
-impl_node!(
-    #[pyclass(module = "_ast", name = "Div", base = NodeOperator)]
-    pub(crate) struct NodeOperatorDiv,
-);
-
-impl_node!(
-    #[pyclass(module = "_ast", name = "Mod", base = NodeOperator)]
-    pub(crate) struct NodeOperatorMod,
-);
-
-impl_node!(
-    #[pyclass(module = "_ast", name = "Pow", base = NodeOperator)]
-    pub(crate) struct NodeOperatorPow,
-);
-
-impl_node!(
-    #[pyclass(module = "_ast", name = "LShift", base = NodeOperator)]
-    pub(crate) struct NodeOperatorLShift,
-);
-
-impl_node!(
-    #[pyclass(module = "_ast", name = "RShift", base = NodeOperator)]
-    pub(crate) struct NodeOperatorRShift,
-);
-
-impl_node!(
-    #[pyclass(module = "_ast", name = "BitOr", base = NodeOperator)]
-    pub(crate) struct NodeOperatorBitOr,
-);
-
-impl_node!(
-    #[pyclass(module = "_ast", name = "BitXor", base = NodeOperator)]
-    pub(crate) struct NodeOperatorBitXor,
-);
-
-impl_node!(
-    #[pyclass(module = "_ast", name = "BitAnd", base = NodeOperator)]
-    pub(crate) struct NodeOperatorBitAnd,
-);
-
-#[pyclass(module = "_ast", name = "unaryop", base = NodeAst)]
-#[repr(transparent)]
-pub(crate) struct NodeUnaryOp(NodeAst);
-
-#[pyclass(flags(HAS_DICT, BASETYPE))]
-impl NodeUnaryOp {}
-
-impl_node!(
-    #[pyclass(module = "_ast", name = "FloorDiv", base = NodeOperator)]
-    pub(crate) struct NodeOperatorFloorDiv,
-);
-
-impl_node!(
-    #[pyclass(module = "_ast", name = "Invert", base = NodeUnaryOp)]
-    pub(crate) struct NodeUnaryOpInvert,
-);
-
-impl_node!(
-    #[pyclass(module = "_ast", name = "Not", base = NodeUnaryOp)]
-    pub(crate) struct NodeUnaryOpNot,
-);
-
-impl_node!(
-    #[pyclass(module = "_ast", name = "UAdd", base = NodeUnaryOp)]
-    pub(crate) struct NodeUnaryOpUAdd,
-);
-
-#[pyclass(module = "_ast", name = "cmpop", base = NodeAst)]
-#[repr(transparent)]
-pub(crate) struct NodeCmpOp(NodeAst);
-
-#[pyclass(flags(HAS_DICT, BASETYPE))]
-impl NodeCmpOp {}
-
-impl_node!(
-    #[pyclass(module = "_ast", name = "USub", base = NodeUnaryOp)]
-    pub(crate) struct NodeUnaryOpUSub,
-);
-
-impl_node!(
-    #[pyclass(module = "_ast", name = "Eq", base = NodeCmpOp)]
-    pub(crate) struct NodeCmpOpEq,
-);
-
-impl_node!(
-    #[pyclass(module = "_ast", name = "NotEq", base = NodeCmpOp)]
-    pub(crate) struct NodeCmpOpNotEq,
-);
-
-impl_node!(
-    #[pyclass(module = "_ast", name = "Lt", base = NodeCmpOp)]
-    pub(crate) struct NodeCmpOpLt,
-);
-
-impl_node!(
-    #[pyclass(module = "_ast", name = "LtE", base = NodeCmpOp)]
-    pub(crate) struct NodeCmpOpLtE,
-);
-
-impl_node!(
-    #[pyclass(module = "_ast", name = "Gt", base = NodeCmpOp)]
-    pub(crate) struct NodeCmpOpGt,
-);
-
-impl_node!(
-    #[pyclass(module = "_ast", name = "GtE", base = NodeCmpOp)]
-    pub(crate) struct NodeCmpOpGtE,
-);
-
-impl_node!(
-    #[pyclass(module = "_ast", name = "Is", base = NodeCmpOp)]
-    pub(crate) struct NodeCmpOpIs,
-);
-
-impl_node!(
-    #[pyclass(module = "_ast", name = "IsNot", base = NodeCmpOp)]
-    pub(crate) struct NodeCmpOpIsNot,
-);
-
-impl_node!(
-    #[pyclass(module = "_ast", name = "In", base = NodeCmpOp)]
-    pub(crate) struct NodeCmpOpIn,
-);
-
-impl_node!(
-    #[pyclass(module = "_ast", name = "NotIn", base = NodeCmpOp)]
-    pub(crate) struct NodeCmpOpNotIn,
-);
-
-#[pyclass(module = "_ast", name = "excepthandler", base = NodeAst)]
-#[repr(transparent)]
-pub(crate) struct NodeExceptHandler(NodeAst);
-
-#[pyclass(flags(HAS_DICT, BASETYPE))]
-impl NodeExceptHandler {}
-
-impl_node!(
-    #[pyclass(module = "_ast", name = "comprehension", base = NodeAst)]
-    pub(crate) struct NodeComprehension,
-    fields: ["target", "iter", "ifs", "is_async"],
-);
-
-impl_node!(
-    #[pyclass(module = "_ast", name = "ExceptHandler", base = NodeExceptHandler)]
-    pub(crate) struct NodeExceptHandlerExceptHandler,
-    fields: ["type", "name", "body"],
-    attributes: ["lineno", "col_offset", "end_lineno", "end_col_offset"],
-);
-
-impl_node!(
-    #[pyclass(module = "_ast", name = "arguments", base = NodeAst)]
-    pub(crate) struct NodeArguments,
-    fields: ["posonlyargs", "args", "vararg", "kwonlyargs", "kw_defaults", "kwarg", "defaults"],
-);
-
-impl_node!(
-    #[pyclass(module = "_ast", name = "arg", base = NodeAst)]
-    pub(crate) struct NodeArg,
-    fields: ["arg", "annotation", "type_comment"],
-    attributes: ["lineno", "col_offset", "end_lineno", "end_col_offset"],
-);
-
-impl_node!(
-    #[pyclass(module = "_ast", name = "keyword", base = NodeAst)]
-    pub(crate) struct NodeKeyword,
-    fields: ["arg", "value"],
-    attributes: ["lineno", "col_offset", "end_lineno", "end_col_offset"],
-);
-
-impl_node!(
-    #[pyclass(module = "_ast", name = "alias", base = NodeAst)]
-    pub(crate) struct NodeAlias,
-    fields: ["name", "asname"],
-    attributes: ["lineno", "col_offset", "end_lineno", "end_col_offset"],
-);
-
-impl_node!(
-    #[pyclass(module = "_ast", name = "withitem", base = NodeAst)]
-    pub(crate) struct NodeWithItem,
-    fields: ["context_expr", "optional_vars"],
-);
-
-#[pyclass(module = "_ast", name = "pattern", base = NodeAst)]
-#[repr(transparent)]
-pub(crate) struct NodePattern(NodeAst);
-
-#[pyclass(flags(HAS_DICT, BASETYPE))]
-impl NodePattern {}
-
-impl_node!(
-    #[pyclass(module = "_ast", name = "match_case", base = NodeAst)]
-    pub(crate) struct NodeMatchCase,
-    fields: ["pattern", "guard", "body"],
-);
-
-impl_node!(
-    #[pyclass(module = "_ast", name = "MatchValue", base = NodePattern)]
-    pub(crate) struct NodePatternMatchValue,
-    fields: ["value"],
-    attributes: ["lineno", "col_offset", "end_lineno", "end_col_offset"],
-);
-
-impl_node!(
-    #[pyclass(module = "_ast", name = "MatchSingleton", base = NodePattern)]
-    pub(crate) struct NodePatternMatchSingleton,
-    fields: ["value"],
-    attributes: ["lineno", "col_offset", "end_lineno", "end_col_offset"],
-);
-
-impl_node!(
-    #[pyclass(module = "_ast", name = "MatchSequence", base = NodePattern)]
-    pub(crate) struct NodePatternMatchSequence,
-    fields: ["patterns"],
-    attributes: ["lineno", "col_offset", "end_lineno", "end_col_offset"],
-);
-
-impl_node!(
-    #[pyclass(module = "_ast", name = "MatchMapping", base = NodePattern)]
-    pub(crate) struct NodePatternMatchMapping,
-    fields: ["keys", "patterns", "rest"],
-    attributes: ["lineno", "col_offset", "end_lineno", "end_col_offset"],
-);
-
-impl_node!(
-    #[pyclass(module = "_ast", name = "MatchClass", base = NodePattern)]
-    pub(crate) struct NodePatternMatchClass,
-    fields: ["cls", "patterns", "kwd_attrs", "kwd_patterns"],
-    attributes: ["lineno", "col_offset", "end_lineno", "end_col_offset"],
-);
-
-impl_node!(
-    #[pyclass(module = "_ast", name = "MatchStar", base = NodePattern)]
-    pub(crate) struct NodePatternMatchStar,
-    fields: ["name"],
-    attributes: ["lineno", "col_offset", "end_lineno", "end_col_offset"],
-);
-
-impl_node!(
-    #[pyclass(module = "_ast", name = "MatchAs", base = NodePattern)]
-    pub(crate) struct NodePatternMatchAs,
-    fields: ["pattern", "name"],
-    attributes: ["lineno", "col_offset", "end_lineno", "end_col_offset"],
-);
-
-#[pyclass(module = "_ast", name = "type_ignore", base = NodeAst)]
-#[repr(transparent)]
-pub(crate) struct NodeTypeIgnore(NodeAst);
-
-#[pyclass(flags(HAS_DICT, BASETYPE))]
-impl NodeTypeIgnore {}
-
-impl_node!(
-    #[pyclass(module = "_ast", name = "MatchOr", base = NodePattern)]
-    pub(crate) struct NodePatternMatchOr,
-    fields: ["patterns"],
-    attributes: ["lineno", "col_offset", "end_lineno", "end_col_offset"],
-);
-
-#[pyclass(module = "_ast", name = "type_param", base = NodeAst)]
-#[repr(transparent)]
-pub(crate) struct NodeTypeParam(NodeAst);
-
-#[pyclass(flags(HAS_DICT, BASETYPE))]
-impl NodeTypeParam {}
-
-impl_node!(
-    #[pyclass(module = "_ast", name = "TypeIgnore", base = NodeTypeIgnore)]
-    pub(crate) struct NodeTypeIgnoreTypeIgnore,
-    fields: ["lineno", "tag"],
-);
-
-impl_node!(
-    #[pyclass(module = "_ast", name = "TypeVar", base = NodeTypeParam)]
-    pub(crate) struct NodeTypeParamTypeVar,
-    fields: ["name", "bound"],
-    attributes: ["lineno", "col_offset", "end_lineno", "end_col_offset"],
-);
-
-impl_node!(
-    #[pyclass(module = "_ast", name = "ParamSpec", base = NodeTypeParam)]
-    pub(crate) struct NodeTypeParamParamSpec,
-    fields: ["name"],
-    attributes: ["lineno", "col_offset", "end_lineno", "end_col_offset"],
-);
-
-impl_node!(
-    #[pyclass(module = "_ast", name = "TypeVarTuple", base = NodeTypeParam)]
-    pub(crate) struct NodeTypeParamTypeVarTuple,
-    fields: ["name"],
-    attributes: ["lineno", "col_offset", "end_lineno", "end_col_offset"],
-);
-
-pub fn extend_module_nodes(vm: &VirtualMachine, module: &Py<PyModule>) {
-    extend_module!(vm, module, {
-        "mod" => NodeMod::make_class(&vm.ctx),
-        "Module" => NodeModModule::make_class(&vm.ctx),
-        "Interactive" => NodeModInteractive::make_class(&vm.ctx),
-        "Expression" => NodeModExpression::make_class(&vm.ctx),
-        "FunctionType" => NodeModFunctionType::make_class(&vm.ctx),
-        "stmt" => NodeStmt::make_class(&vm.ctx),
-        "FunctionDef" => NodeStmtFunctionDef::make_class(&vm.ctx),
-        "AsyncFunctionDef" => NodeStmtAsyncFunctionDef::make_class(&vm.ctx),
-        "ClassDef" => NodeStmtClassDef::make_class(&vm.ctx),
-        "Return" => NodeStmtReturn::make_class(&vm.ctx),
-        "Delete" => NodeStmtDelete::make_class(&vm.ctx),
-        "Assign" => NodeStmtAssign::make_class(&vm.ctx),
-        "TypeAlias" => NodeStmtTypeAlias::make_class(&vm.ctx),
-        "AugAssign" => NodeStmtAugAssign::make_class(&vm.ctx),
-        "AnnAssign" => NodeStmtAnnAssign::make_class(&vm.ctx),
-        "For" => NodeStmtFor::make_class(&vm.ctx),
-        "AsyncFor" => NodeStmtAsyncFor::make_class(&vm.ctx),
-        "While" => NodeStmtWhile::make_class(&vm.ctx),
-        "If" => NodeStmtIf::make_class(&vm.ctx),
-        "With" => NodeStmtWith::make_class(&vm.ctx),
-        "AsyncWith" => NodeStmtAsyncWith::make_class(&vm.ctx),
-        "Match" => NodeStmtMatch::make_class(&vm.ctx),
-        "Raise" => NodeStmtRaise::make_class(&vm.ctx),
-        "Try" => NodeStmtTry::make_class(&vm.ctx),
-        "TryStar" => NodeStmtTryStar::make_class(&vm.ctx),
-        "Assert" => NodeStmtAssert::make_class(&vm.ctx),
-        "Import" => NodeStmtImport::make_class(&vm.ctx),
-        "ImportFrom" => NodeStmtImportFrom::make_class(&vm.ctx),
-        "Global" => NodeStmtGlobal::make_class(&vm.ctx),
-        "Nonlocal" => NodeStmtNonlocal::make_class(&vm.ctx),
-        "Expr" => NodeStmtExpr::make_class(&vm.ctx),
-        "Pass" => NodeStmtPass::make_class(&vm.ctx),
-        "Break" => NodeStmtBreak::make_class(&vm.ctx),
-        "Continue" => NodeStmtContinue::make_class(&vm.ctx),
-        "expr" => NodeExpr::make_class(&vm.ctx),
-        "BoolOp" => NodeExprBoolOp::make_class(&vm.ctx),
-        "NamedExpr" => NodeExprNamedExpr::make_class(&vm.ctx),
-        "BinOp" => NodeExprBinOp::make_class(&vm.ctx),
-        "UnaryOp" => NodeExprUnaryOp::make_class(&vm.ctx),
-        "Lambda" => NodeExprLambda::make_class(&vm.ctx),
-        "IfExp" => NodeExprIfExp::make_class(&vm.ctx),
-        "Dict" => NodeExprDict::make_class(&vm.ctx),
-        "Set" => NodeExprSet::make_class(&vm.ctx),
-        "ListComp" => NodeExprListComp::make_class(&vm.ctx),
-        "SetComp" => NodeExprSetComp::make_class(&vm.ctx),
-        "DictComp" => NodeExprDictComp::make_class(&vm.ctx),
-        "GeneratorExp" => NodeExprGeneratorExp::make_class(&vm.ctx),
-        "Await" => NodeExprAwait::make_class(&vm.ctx),
-        "Yield" => NodeExprYield::make_class(&vm.ctx),
-        "YieldFrom" => NodeExprYieldFrom::make_class(&vm.ctx),
-        "Compare" => NodeExprCompare::make_class(&vm.ctx),
-        "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),
-        "Starred" => NodeExprStarred::make_class(&vm.ctx),
-        "Name" => NodeExprName::make_class(&vm.ctx),
-        "List" => NodeExprList::make_class(&vm.ctx),
-        "Tuple" => NodeExprTuple::make_class(&vm.ctx),
-        "Slice" => NodeExprSlice::make_class(&vm.ctx),
-        "expr_context" => NodeExprContext::make_class(&vm.ctx),
-        "Load" => NodeExprContextLoad::make_class(&vm.ctx),
-        "Store" => NodeExprContextStore::make_class(&vm.ctx),
-        "Del" => NodeExprContextDel::make_class(&vm.ctx),
-        "boolop" => NodeBoolOp::make_class(&vm.ctx),
-        "And" => NodeBoolOpAnd::make_class(&vm.ctx),
-        "Or" => NodeBoolOpOr::make_class(&vm.ctx),
-        "operator" => NodeOperator::make_class(&vm.ctx),
-        "Add" => NodeOperatorAdd::make_class(&vm.ctx),
-        "Sub" => NodeOperatorSub::make_class(&vm.ctx),
-        "Mult" => NodeOperatorMult::make_class(&vm.ctx),
-        "MatMult" => NodeOperatorMatMult::make_class(&vm.ctx),
-        "Div" => NodeOperatorDiv::make_class(&vm.ctx),
-        "Mod" => NodeOperatorMod::make_class(&vm.ctx),
-        "Pow" => NodeOperatorPow::make_class(&vm.ctx),
-        "LShift" => NodeOperatorLShift::make_class(&vm.ctx),
-        "RShift" => NodeOperatorRShift::make_class(&vm.ctx),
-        "BitOr" => NodeOperatorBitOr::make_class(&vm.ctx),
-        "BitXor" => NodeOperatorBitXor::make_class(&vm.ctx),
-        "BitAnd" => NodeOperatorBitAnd::make_class(&vm.ctx),
-        "FloorDiv" => NodeOperatorFloorDiv::make_class(&vm.ctx),
-        "unaryop" => NodeUnaryOp::make_class(&vm.ctx),
-        "Invert" => NodeUnaryOpInvert::make_class(&vm.ctx),
-        "Not" => NodeUnaryOpNot::make_class(&vm.ctx),
-        "UAdd" => NodeUnaryOpUAdd::make_class(&vm.ctx),
-        "USub" => NodeUnaryOpUSub::make_class(&vm.ctx),
-        "cmpop" => NodeCmpOp::make_class(&vm.ctx),
-        "Eq" => NodeCmpOpEq::make_class(&vm.ctx),
-        "NotEq" => NodeCmpOpNotEq::make_class(&vm.ctx),
-        "Lt" => NodeCmpOpLt::make_class(&vm.ctx),
-        "LtE" => NodeCmpOpLtE::make_class(&vm.ctx),
-        "Gt" => NodeCmpOpGt::make_class(&vm.ctx),
-        "GtE" => NodeCmpOpGtE::make_class(&vm.ctx),
-        "Is" => NodeCmpOpIs::make_class(&vm.ctx),
-        "IsNot" => NodeCmpOpIsNot::make_class(&vm.ctx),
-        "In" => NodeCmpOpIn::make_class(&vm.ctx),
-        "NotIn" => NodeCmpOpNotIn::make_class(&vm.ctx),
-        "comprehension" => NodeComprehension::make_class(&vm.ctx),
-        "excepthandler" => NodeExceptHandler::make_class(&vm.ctx),
-        "ExceptHandler" => NodeExceptHandlerExceptHandler::make_class(&vm.ctx),
-        "arguments" => NodeArguments::make_class(&vm.ctx),
-        "arg" => NodeArg::make_class(&vm.ctx),
-        "keyword" => NodeKeyword::make_class(&vm.ctx),
-        "alias" => NodeAlias::make_class(&vm.ctx),
-        "withitem" => NodeWithItem::make_class(&vm.ctx),
-        "match_case" => NodeMatchCase::make_class(&vm.ctx),
-        "pattern" => NodePattern::make_class(&vm.ctx),
-        "MatchValue" => NodePatternMatchValue::make_class(&vm.ctx),
-        "MatchSingleton" => NodePatternMatchSingleton::make_class(&vm.ctx),
-        "MatchSequence" => NodePatternMatchSequence::make_class(&vm.ctx),
-        "MatchMapping" => NodePatternMatchMapping::make_class(&vm.ctx),
-        "MatchClass" => NodePatternMatchClass::make_class(&vm.ctx),
-        "MatchStar" => NodePatternMatchStar::make_class(&vm.ctx),
-        "MatchAs" => NodePatternMatchAs::make_class(&vm.ctx),
-        "MatchOr" => NodePatternMatchOr::make_class(&vm.ctx),
-        "type_ignore" => NodeTypeIgnore::make_class(&vm.ctx),
-        "TypeIgnore" => NodeTypeIgnoreTypeIgnore::make_class(&vm.ctx),
-        "type_param" => NodeTypeParam::make_class(&vm.ctx),
-        "TypeVar" => NodeTypeParamTypeVar::make_class(&vm.ctx),
-        "ParamSpec" => NodeTypeParamParamSpec::make_class(&vm.ctx),
-        "TypeVarTuple" => NodeTypeParamTypeVarTuple::make_class(&vm.ctx),
-    })
-}
diff --git a/crates/vm/src/stdlib/ast/python.rs b/crates/vm/src/stdlib/ast/python.rs
deleted file mode 100644
index 6c38b00f9ad..00000000000
--- a/crates/vm/src/stdlib/ast/python.rs
+++ /dev/null
@@ -1,109 +0,0 @@
-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, PyRef, PyResult, VirtualMachine,
-        builtins::{PyStrRef, PyTupleRef, PyType, PyTypeRef},
-        function::FuncArgs,
-        types::{Constructor, Initializer},
-    };
-    #[pyattr]
-    #[pyclass(module = "_ast", name = "AST")]
-    #[derive(Debug, PyPayload)]
-    pub(crate) struct NodeAst;
-
-    #[pyclass(with(Constructor, Initializer), flags(BASETYPE, HAS_DICT))]
-    impl NodeAst {
-        #[pyattr]
-        fn _fields(ctx: &Context) -> PyTupleRef {
-            ctx.empty_tuple.clone()
-        }
-    }
-
-    impl Constructor for NodeAst {
-        type Args = FuncArgs;
-
-        fn slot_new(cls: PyTypeRef, args: FuncArgs, vm: &VirtualMachine) -> PyResult {
-            // AST nodes accept extra arguments (unlike object.__new__)
-            // This matches CPython's behavior where AST has its own tp_new
-            let dict = if cls
-                .slots
-                .flags
-                .contains(crate::types::PyTypeFlags::HAS_DICT)
-            {
-                Some(vm.ctx.new_dict())
-            } else {
-                None
-            };
-            let zelf = vm.ctx.new_base_object(cls, dict);
-
-            // Initialize the instance with the provided arguments
-            // FIXME: This is probably incorrect. Please check if init should be called outside of __new__
-            Self::slot_init(zelf.clone(), args, vm)?;
-
-            Ok(zelf)
-        }
-
-        fn py_new(_cls: &Py<PyType>, _args: Self::Args, _vm: &VirtualMachine) -> PyResult<Self> {
-            unimplemented!("use slot_new")
-        }
-    }
-
-    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;
-
-    #[pyattr(name = "PyCF_OPTIMIZED_AST")]
-    use super::PY_CF_OPTIMIZED_AST;
-
-    #[pyattr(name = "PyCF_TYPE_COMMENTS")]
-    use super::PY_CF_TYPE_COMMENTS;
-
-    pub(crate) fn module_exec(
-        vm: &VirtualMachine,
-        module: &Py<crate::builtins::PyModule>,
-    ) -> PyResult<()> {
-        __module_exec(vm, module);
-        super::super::pyast::extend_module_nodes(vm, module);
-        Ok(())
-    }
-}
diff --git a/crates/vm/src/stdlib/atexit.rs b/crates/vm/src/stdlib/atexit.rs
index 338fae3b2b7..638927fe90f 100644
--- a/crates/vm/src/stdlib/atexit.rs
+++ b/crates/vm/src/stdlib/atexit.rs
@@ -7,7 +7,11 @@ mod atexit {
 
     #[pyfunction]
     fn register(func: PyObjectRef, args: FuncArgs, vm: &VirtualMachine) -> PyObjectRef {
-        vm.state.atexit_funcs.lock().push((func.clone(), args));
+        // Callbacks go in LIFO order (insert at front)
+        vm.state
+            .atexit_funcs
+            .lock()
+            .insert(0, Box::new((func.clone(), args)));
         func
     }
 
@@ -18,27 +22,62 @@ mod atexit {
 
     #[pyfunction]
     fn unregister(func: PyObjectRef, vm: &VirtualMachine) -> PyResult<()> {
-        let mut funcs = vm.state.atexit_funcs.lock();
-
-        let mut i = 0;
-        while i < funcs.len() {
-            if vm.bool_eq(&funcs[i].0, &func)? {
-                funcs.remove(i);
-            } else {
-                i += 1;
+        // Iterate backward (oldest to newest in LIFO list).
+        // Release the lock during comparison so __eq__ can call atexit functions.
+        let mut i = {
+            let funcs = vm.state.atexit_funcs.lock();
+            funcs.len() as isize - 1
+        };
+        while i >= 0 {
+            let (cb, entry_ptr) = {
+                let funcs = vm.state.atexit_funcs.lock();
+                if i as usize >= funcs.len() {
+                    i = funcs.len() as isize;
+                    i -= 1;
+                    continue;
+                }
+                let entry = &funcs[i as usize];
+                (entry.0.clone(), &**entry as *const (PyObjectRef, FuncArgs))
+            };
+            // Lock released: __eq__ can safely call atexit functions
+            let eq = vm.bool_eq(&func, &cb)?;
+            if eq {
+                // The entry may have moved during __eq__. Search backward by identity.
+                let mut funcs = vm.state.atexit_funcs.lock();
+                let mut j = (funcs.len() as isize - 1).min(i);
+                while j >= 0 {
+                    if core::ptr::eq(&**funcs.get(j as usize).unwrap(), entry_ptr) {
+                        funcs.remove(j as usize);
+                        i = j;
+                        break;
+                    }
+                    j -= 1;
+                }
             }
+            {
+                let funcs = vm.state.atexit_funcs.lock();
+                if i as usize >= funcs.len() {
+                    i = funcs.len() as isize;
+                }
+            }
+            i -= 1;
         }
-
         Ok(())
     }
 
     #[pyfunction]
     pub fn _run_exitfuncs(vm: &VirtualMachine) {
         let funcs: Vec<_> = core::mem::take(&mut *vm.state.atexit_funcs.lock());
-        for (func, args) in funcs.into_iter().rev() {
+        // Callbacks stored in LIFO order, iterate forward
+        for entry in funcs.into_iter() {
+            let (func, args) = *entry;
             if let Err(e) = func.call(args, vm) {
                 let exit = e.fast_isinstance(vm.ctx.exceptions.system_exit);
-                vm.run_unraisable(e, Some("Error in atexit._run_exitfuncs".to_owned()), func);
+                let msg = func
+                    .repr(vm)
+                    .ok()
+                    .map(|r| format!("Exception ignored in atexit callback {}", r.as_wtf8()));
+                vm.run_unraisable(e, msg, vm.ctx.none());
                 if exit {
                     break;
                 }
diff --git a/crates/vm/src/stdlib/builtins.rs b/crates/vm/src/stdlib/builtins.rs
index 1f14f6f5b04..008d342a79b 100644
--- a/crates/vm/src/stdlib/builtins.rs
+++ b/crates/vm/src/stdlib/builtins.rs
@@ -11,13 +11,14 @@ mod builtins {
         AsObject, PyObject, PyObjectRef, PyPayload, PyRef, PyResult, TryFromObject, VirtualMachine,
         builtins::{
             PyByteArray, PyBytes, PyDictRef, PyStr, PyStrRef, PyTuple, PyTupleRef, PyType,
+            PyUtf8StrRef,
             enumerate::PyReverseSequenceIterator,
             function::{PyCellRef, PyFunction},
             int::PyIntRef,
             iter::PyCallableIterator,
             list::{PyList, SortOptions},
         },
-        common::{hash::PyHash, str::to_ascii},
+        common::hash::PyHash,
         function::{
             ArgBytesLike, ArgCallable, ArgIndex, ArgIntoBool, ArgIterable, ArgMapping,
             ArgStrOrBytesLike, Either, FsPath, FuncArgs, KwArgs, OptionalArg, OptionalOption,
@@ -30,7 +31,7 @@ mod builtins {
         types::PyComparisonOp,
     };
     use itertools::Itertools;
-    use num_traits::{Signed, ToPrimitive};
+    use num_traits::{Signed, ToPrimitive, Zero};
     use rustpython_common::wtf8::CodePoint;
 
     #[cfg(not(feature = "rustpython-compiler"))]
@@ -63,10 +64,8 @@ mod builtins {
     }
 
     #[pyfunction]
-    pub fn ascii(obj: PyObjectRef, vm: &VirtualMachine) -> PyResult<ascii::AsciiString> {
-        let repr = obj.repr(vm)?;
-        let ascii = to_ascii(repr.as_str());
-        Ok(ascii)
+    pub fn ascii(obj: PyObjectRef, vm: &VirtualMachine) -> PyResult<PyStrRef> {
+        obj.ascii(vm)
     }
 
     #[pyfunction]
@@ -87,7 +86,7 @@ mod builtins {
     #[pyfunction]
     fn chr(i: PyIntRef, vm: &VirtualMachine) -> PyResult<CodePoint> {
         let value = i
-            .try_to_primitive::<isize>(vm)?
+            .as_bigint()
             .to_u32()
             .and_then(CodePoint::from_u32)
             .ok_or_else(|| vm.new_value_error("chr() arg not in range(0x110000)"))?;
@@ -99,7 +98,7 @@ mod builtins {
     struct CompileArgs {
         source: PyObjectRef,
         filename: FsPath,
-        mode: PyStrRef,
+        mode: PyUtf8StrRef,
         #[pyarg(any, optional)]
         flags: OptionalArg<PyIntRef>,
         #[pyarg(any, optional)]
@@ -110,6 +109,145 @@ mod builtins {
         _feature_version: OptionalArg<i32>,
     }
 
+    /// Detect PEP 263 encoding cookie from source bytes.
+    /// Checks first two lines for `# coding[:=] <encoding>` pattern.
+    /// Returns the encoding name if found, or None for default (UTF-8).
+    #[cfg(feature = "parser")]
+    fn detect_source_encoding(source: &[u8]) -> Option<String> {
+        fn find_encoding_in_line(line: &[u8]) -> Option<String> {
+            // PEP 263: '#' must be preceded only by whitespace/formfeed
+            let hash_pos = line.iter().position(|&b| b == b'#')?;
+            if !line[..hash_pos]
+                .iter()
+                .all(|&b| b == b' ' || b == b'\t' || b == b'\x0c' || b == b'\r')
+            {
+                return None;
+            }
+            let after_hash = &line[hash_pos..];
+
+            // Find "coding" after the #
+            let coding_pos = after_hash.windows(6).position(|w| w == b"coding")?;
+            let after_coding = &after_hash[coding_pos + 6..];
+
+            // Next char must be ':' or '='
+            let rest = if after_coding.first() == Some(&b':') || after_coding.first() == Some(&b'=')
+            {
+                &after_coding[1..]
+            } else {
+                return None;
+            };
+
+            // Skip whitespace
+            let rest = rest
+                .iter()
+                .copied()
+                .skip_while(|&b| b == b' ' || b == b'\t')
+                .collect::<Vec<_>>();
+
+            // Read encoding name: [-\w.]+
+            let name: String = rest
+                .iter()
+                .take_while(|&&b| b.is_ascii_alphanumeric() || b == b'-' || b == b'_' || b == b'.')
+                .map(|&b| b as char)
+                .collect();
+
+            if name.is_empty() { None } else { Some(name) }
+        }
+
+        // Split into lines (first two only)
+        let mut lines = source.splitn(3, |&b| b == b'\n');
+
+        if let Some(first) = lines.next() {
+            // Strip BOM if present
+            let first = first.strip_prefix(b"\xef\xbb\xbf").unwrap_or(first);
+            if let Some(enc) = find_encoding_in_line(first) {
+                return Some(enc);
+            }
+            // Only check second line if first line is blank or a comment
+            let trimmed = first
+                .iter()
+                .skip_while(|&&b| b == b' ' || b == b'\t' || b == b'\x0c' || b == b'\r')
+                .copied()
+                .collect::<Vec<_>>();
+            if !trimmed.is_empty() && trimmed[0] != b'#' {
+                return None;
+            }
+        }
+
+        lines.next().and_then(find_encoding_in_line)
+    }
+
+    /// Decode source bytes to a string, handling PEP 263 encoding declarations
+    /// and BOM. Raises SyntaxError for invalid UTF-8 without an encoding
+    /// declaration.
+    /// Check if an encoding name is a UTF-8 variant after normalization.
+    /// Matches: utf-8, utf_8, utf8, UTF-8, etc.
+    #[cfg(feature = "parser")]
+    fn is_utf8_encoding(name: &str) -> bool {
+        let normalized: String = name.chars().filter(|&c| c != '-' && c != '_').collect();
+        normalized.eq_ignore_ascii_case("utf8")
+    }
+
+    #[cfg(feature = "parser")]
+    fn decode_source_bytes(source: &[u8], filename: &str, vm: &VirtualMachine) -> PyResult<String> {
+        let has_bom = source.starts_with(b"\xef\xbb\xbf");
+        let encoding = detect_source_encoding(source);
+
+        let is_utf8 = encoding.as_deref().is_none_or(is_utf8_encoding);
+
+        // Validate BOM + encoding combination
+        if has_bom && !is_utf8 {
+            return Err(vm.new_exception_msg(
+                vm.ctx.exceptions.syntax_error.to_owned(),
+                format!("encoding problem for '{filename}': utf-8").into(),
+            ));
+        }
+
+        if is_utf8 {
+            let src = if has_bom { &source[3..] } else { source };
+            match core::str::from_utf8(src) {
+                Ok(s) => Ok(s.to_owned()),
+                Err(e) => {
+                    let bad_byte = src[e.valid_up_to()];
+                    let line = src[..e.valid_up_to()]
+                        .iter()
+                        .filter(|&&b| b == b'\n')
+                        .count()
+                        + 1;
+                    Err(vm.new_exception_msg(
+                        vm.ctx.exceptions.syntax_error.to_owned(),
+                        format!(
+                            "Non-UTF-8 code starting with '\\x{bad_byte:02x}' \
+                             on line {line}, but no encoding declared; \
+                             see https://peps.python.org/pep-0263/ for details \
+                             ({filename}, line {line})"
+                        )
+                        .into(),
+                    ))
+                }
+            }
+        } else {
+            // Use codec registry for non-UTF-8 encodings
+            let enc = encoding.as_deref().unwrap();
+            let bytes_obj = vm.ctx.new_bytes(source.to_vec());
+            let decoded = vm
+                .state
+                .codec_registry
+                .decode_text(bytes_obj.into(), enc, None, vm)
+                .map_err(|exc| {
+                    if exc.fast_isinstance(vm.ctx.exceptions.lookup_error) {
+                        vm.new_exception_msg(
+                            vm.ctx.exceptions.syntax_error.to_owned(),
+                            format!("unknown encoding for '{filename}': {enc}").into(),
+                        )
+                    } else {
+                        exc
+                    }
+                })?;
+            Ok(decoded.to_string_lossy().into_owned())
+        }
+    }
+
     #[cfg(any(feature = "parser", feature = "compiler"))]
     #[pyfunction]
     fn compile(args: CompileArgs, vm: &VirtualMachine) -> PyResult {
@@ -120,11 +258,9 @@ mod builtins {
         }
         #[cfg(feature = "ast")]
         {
-            use crate::{class::PyClassImpl, stdlib::ast};
+            use crate::{class::PyClassImpl, stdlib::_ast};
 
-            if args._feature_version.is_present() {
-                // TODO: add support for _feature_version
-            }
+            let feature_version = feature_version_from_arg(args._feature_version, vm)?;
 
             let mode_str = args.mode.as_str();
 
@@ -139,8 +275,37 @@ mod builtins {
 
             if args
                 .source
-                .fast_isinstance(&ast::NodeAst::make_class(&vm.ctx))
+                .fast_isinstance(&_ast::NodeAst::make_static_type())
             {
+                let flags: i32 = args.flags.map_or(Ok(0), |v| v.try_to_primitive(vm))?;
+                let is_ast_only = !(flags & _ast::PY_CF_ONLY_AST).is_zero();
+
+                // func_type mode requires PyCF_ONLY_AST
+                if mode_str == "func_type" && !is_ast_only {
+                    return Err(vm.new_value_error(
+                        "compile() mode 'func_type' requires flag PyCF_ONLY_AST",
+                    ));
+                }
+
+                // compile(ast_node, ..., PyCF_ONLY_AST) returns the AST after validation
+                if is_ast_only {
+                    let (expected_type, expected_name) = _ast::mode_type_and_name(mode_str)
+                        .ok_or_else(|| {
+                            vm.new_value_error(
+                                "compile() mode must be 'exec', 'eval', 'single' or 'func_type'",
+                            )
+                        })?;
+                    if !args.source.fast_isinstance(&expected_type) {
+                        return Err(vm.new_type_error(format!(
+                            "expected {} node, got {}",
+                            expected_name,
+                            args.source.class().name()
+                        )));
+                    }
+                    _ast::validate_ast_object(vm, args.source.clone())?;
+                    return Ok(args.source);
+                }
+
                 #[cfg(not(feature = "rustpython-codegen"))]
                 {
                     return Err(vm.new_type_error(CODEGEN_NOT_SUPPORTED.to_owned()));
@@ -150,7 +315,7 @@ mod builtins {
                     let mode = mode_str
                         .parse::<crate::compiler::Mode>()
                         .map_err(|err| vm.new_value_error(err.to_string()))?;
-                    return ast::compile(
+                    return _ast::compile(
                         vm,
                         args.source,
                         &args.filename.to_string_lossy(),
@@ -168,31 +333,48 @@ mod builtins {
             #[cfg(feature = "parser")]
             {
                 use crate::convert::ToPyException;
-                use num_traits::Zero;
+
                 use ruff_python_parser as parser;
 
                 let source = ArgStrOrBytesLike::try_from_object(vm, args.source)?;
                 let source = source.borrow_bytes();
 
-                // TODO: compiler::compile should probably get bytes
-                let source = core::str::from_utf8(&source)
-                    .map_err(|e| vm.new_unicode_decode_error(e.to_string()))?;
+                let source = decode_source_bytes(&source, &args.filename.to_string_lossy(), vm)?;
+                let source = source.as_str();
 
                 let flags = args.flags.map_or(Ok(0), |v| v.try_to_primitive(vm))?;
 
-                if !(flags & !ast::PY_COMPILE_FLAGS_MASK).is_zero() {
+                if !(flags & !_ast::PY_COMPILE_FLAGS_MASK).is_zero() {
                     return Err(vm.new_value_error("compile() unrecognized flags"));
                 }
 
-                let allow_incomplete = !(flags & ast::PY_CF_ALLOW_INCOMPLETE_INPUT).is_zero();
+                let allow_incomplete = !(flags & _ast::PY_CF_ALLOW_INCOMPLETE_INPUT).is_zero();
+                let type_comments = !(flags & _ast::PY_CF_TYPE_COMMENTS).is_zero();
 
-                if (flags & ast::PY_COMPILE_FLAG_AST_ONLY).is_zero() {
+                let optimize_level = optimize;
+
+                if (flags & _ast::PY_CF_ONLY_AST).is_zero() {
                     #[cfg(not(feature = "compiler"))]
                     {
                         Err(vm.new_value_error(CODEGEN_NOT_SUPPORTED.to_owned()))
                     }
                     #[cfg(feature = "compiler")]
                     {
+                        if let Some(feature_version) = feature_version {
+                            let mode = mode_str
+                                .parse::<parser::Mode>()
+                                .map_err(|err| vm.new_value_error(err.to_string()))?;
+                            let _ = _ast::parse(
+                                vm,
+                                source,
+                                mode,
+                                optimize_level,
+                                Some(feature_version),
+                                type_comments,
+                            )
+                            .map_err(|e| (e, Some(source), allow_incomplete).to_pyexception(vm))?;
+                        }
+
                         let mode = mode_str
                             .parse::<crate::compiler::Mode>()
                             .map_err(|err| vm.new_value_error(err.to_string()))?;
@@ -213,16 +395,53 @@ mod builtins {
                         Ok(code.into())
                     }
                 } else {
+                    if mode_str == "func_type" {
+                        return _ast::parse_func_type(vm, source, optimize_level, feature_version)
+                            .map_err(|e| (e, Some(source), allow_incomplete).to_pyexception(vm));
+                    }
+
                     let mode = mode_str
                         .parse::<parser::Mode>()
                         .map_err(|err| vm.new_value_error(err.to_string()))?;
-                    ast::parse(vm, source, mode)
-                        .map_err(|e| (e, Some(source), allow_incomplete).to_pyexception(vm))
+                    let parsed = _ast::parse(
+                        vm,
+                        source,
+                        mode,
+                        optimize_level,
+                        feature_version,
+                        type_comments,
+                    )
+                    .map_err(|e| (e, Some(source), allow_incomplete).to_pyexception(vm))?;
+
+                    if mode_str == "single" {
+                        return _ast::wrap_interactive(vm, parsed);
+                    }
+
+                    Ok(parsed)
                 }
             }
         }
     }
 
+    #[cfg(feature = "ast")]
+    fn feature_version_from_arg(
+        feature_version: OptionalArg<i32>,
+        vm: &VirtualMachine,
+    ) -> PyResult<Option<ruff_python_ast::PythonVersion>> {
+        let minor = match feature_version.into_option() {
+            Some(minor) => minor,
+            None => return Ok(None),
+        };
+
+        if minor < 0 {
+            return Ok(None);
+        }
+
+        let minor = u8::try_from(minor)
+            .map_err(|_| vm.new_value_error("compile() _feature_version out of range"))?;
+        Ok(Some(ruff_python_ast::PythonVersion { major: 3, minor }))
+    }
+
     #[pyfunction]
     fn delattr(obj: PyObjectRef, attr: PyObjectRef, vm: &VirtualMachine) -> PyResult<()> {
         let attr = attr.try_to_ref::<PyStr>(vm).map_err(|_e| {
@@ -278,7 +497,7 @@ mod builtins {
                             "exec() globals must be a dict, not {}",
                             globals.class().name()
                         )),
-                        _ => vm.new_type_error("globals must be a dict".to_owned()),
+                        _ => vm.new_type_error("globals must be a dict"),
                     });
                 }
                 Ok(())
@@ -300,7 +519,7 @@ mod builtins {
                     )
                 }
                 None => (
-                    vm.current_globals().clone(),
+                    vm.current_globals(),
                     if let Some(locals) = self.locals {
                         locals
                     } else {
@@ -329,7 +548,7 @@ mod builtins {
                 if source.contains(&0) {
                     return Err(vm.new_exception_msg(
                         vm.ctx.exceptions.syntax_error.to_owned(),
-                        "source code string cannot contain null bytes".to_owned(),
+                        "source code string cannot contain null bytes".into(),
                     ));
                 }
 
@@ -340,9 +559,9 @@ mod builtins {
                         err.valid_up_to()
                     );
 
-                    vm.new_exception_msg(vm.ctx.exceptions.syntax_error.to_owned(), msg)
+                    vm.new_exception_msg(vm.ctx.exceptions.syntax_error.to_owned(), msg.into())
                 })?;
-                Ok(Either::A(vm.ctx.new_str(source.trim_start())))
+                Ok(Either::A(vm.ctx.new_utf8_str(source.trim_start())))
             }
             Either::B(code) => Ok(Either::B(code)),
         }?;
@@ -351,7 +570,7 @@ mod builtins {
 
     #[pyfunction]
     fn exec(
-        source: Either<PyStrRef, PyRef<crate::builtins::PyCode>>,
+        source: Either<PyUtf8StrRef, PyRef<crate::builtins::PyCode>>,
         scope: ScopeArgs,
         vm: &VirtualMachine,
     ) -> PyResult {
@@ -361,7 +580,7 @@ mod builtins {
 
     fn run_code(
         vm: &VirtualMachine,
-        source: Either<PyStrRef, PyRef<crate::builtins::PyCode>>,
+        source: Either<PyUtf8StrRef, PyRef<crate::builtins::PyCode>>,
         scope: crate::scope::Scope,
         #[allow(unused_variables)] mode: crate::compiler::Mode,
         func: &str,
@@ -369,9 +588,11 @@ mod builtins {
         // Determine code object:
         let code_obj = match source {
             #[cfg(feature = "rustpython-compiler")]
-            Either::A(string) => vm
-                .compile(string.as_str(), mode, "<string>".to_owned())
-                .map_err(|err| vm.new_syntax_error(&err, Some(string.as_str())))?,
+            Either::A(string) => {
+                let source = string.as_str();
+                vm.compile(source, mode, "<string>".to_owned())
+                    .map_err(|err| vm.new_syntax_error(&err, Some(source)))?
+            }
             #[cfg(not(feature = "rustpython-compiler"))]
             Either::A(_) => return Err(vm.new_type_error(CODEGEN_NOT_SUPPORTED.to_owned())),
             Either::B(code_obj) => code_obj,
@@ -419,7 +640,7 @@ mod builtins {
 
     #[pyfunction]
     fn globals(vm: &VirtualMachine) -> PyDictRef {
-        vm.current_globals().clone()
+        vm.current_globals()
     }
 
     #[pyfunction]
@@ -483,8 +704,15 @@ mod builtins {
             && std::io::stdin().is_terminal()
             && !is_pty_child();
 
+        // Disable rustyline if prompt contains surrogates (not valid UTF-8 for terminal)
+        let prompt_str = match &prompt {
+            OptionalArg::Present(s) => s.to_str(),
+            OptionalArg::Missing => Some(""),
+        };
+        let use_rustyline = use_rustyline && prompt_str.is_some();
+
         if use_rustyline {
-            let prompt = prompt.as_ref().map_or("", |s| s.as_str());
+            let prompt = prompt_str.unwrap();
             let mut readline = Readline::new(());
             match readline.readline(prompt) {
                 ReadlineResult::Line(s) => Ok(vm.ctx.new_str(s).into()),
@@ -628,7 +856,7 @@ mod builtins {
             Some(x) => x,
             None => {
                 return default.ok_or_else(|| {
-                    vm.new_value_error(format!("{func_name}() arg is an empty sequence"))
+                    vm.new_value_error(format!("{func_name}() iterable argument is empty"))
                 });
             }
         };
@@ -768,9 +996,7 @@ mod builtins {
         };
         let write = |obj: PyStrRef| vm.call_method(&file, "write", (obj,));
 
-        let sep = options
-            .sep
-            .unwrap_or_else(|| PyStr::from(" ").into_ref(&vm.ctx));
+        let sep = options.sep.unwrap_or_else(|| vm.ctx.new_str(" "));
 
         let mut first = true;
         for object in objects {
@@ -783,9 +1009,7 @@ mod builtins {
             write(object.str(vm)?)?;
         }
 
-        let end = options
-            .end
-            .unwrap_or_else(|| PyStr::from("\n").into_ref(&vm.ctx));
+        let end = options.end.unwrap_or_else(|| vm.ctx.new_str("\n"));
         write(end)?;
 
         if options.flush.into() {
@@ -907,9 +1131,24 @@ mod builtins {
         Ok(sum)
     }
 
+    #[derive(FromArgs)]
+    struct ImportArgs {
+        #[pyarg(any)]
+        name: PyStrRef,
+        #[pyarg(any, default)]
+        globals: Option<PyObjectRef>,
+        #[allow(dead_code)]
+        #[pyarg(any, default)]
+        locals: Option<PyObjectRef>,
+        #[pyarg(any, default)]
+        fromlist: Option<PyObjectRef>,
+        #[pyarg(any, default)]
+        level: i32,
+    }
+
     #[pyfunction]
-    fn __import__(args: FuncArgs, vm: &VirtualMachine) -> PyResult {
-        vm.import_func.call(args, vm)
+    fn __import__(args: ImportArgs, vm: &VirtualMachine) -> PyResult {
+        crate::import::import_module_level(&args.name, args.globals, args.fromlist, args.level, vm)
     }
 
     #[pyfunction]
@@ -1098,7 +1337,7 @@ mod builtins {
 pub fn init_module(vm: &VirtualMachine, module: &Py<PyModule>) {
     let ctx = &vm.ctx;
 
-    crate::protocol::VecBuffer::make_class(&vm.ctx);
+    crate::protocol::VecBuffer::make_static_type();
 
     module.__init_methods(vm).unwrap();
     builtins::module_exec(vm, module).unwrap();
diff --git a/crates/vm/src/stdlib/codecs.rs b/crates/vm/src/stdlib/codecs.rs
deleted file mode 100644
index 1b728386671..00000000000
--- a/crates/vm/src/stdlib/codecs.rs
+++ /dev/null
@@ -1,709 +0,0 @@
-pub(crate) use _codecs::module_def;
-
-#[pymodule]
-mod _codecs {
-    use crate::codecs::{ErrorsHandler, PyDecodeContext, PyEncodeContext};
-    use crate::common::encodings;
-    use crate::common::wtf8::Wtf8Buf;
-    use crate::{
-        AsObject, PyObjectRef, PyResult, VirtualMachine,
-        builtins::{PyStrRef, PyUtf8StrRef},
-        codecs,
-        function::{ArgBytesLike, FuncArgs},
-    };
-
-    #[pyfunction]
-    fn register(search_function: PyObjectRef, vm: &VirtualMachine) -> PyResult<()> {
-        vm.state.codec_registry.register(search_function, vm)
-    }
-
-    #[pyfunction]
-    fn unregister(search_function: PyObjectRef, vm: &VirtualMachine) -> PyResult<()> {
-        vm.state.codec_registry.unregister(search_function)
-    }
-
-    #[pyfunction]
-    fn lookup(encoding: PyUtf8StrRef, vm: &VirtualMachine) -> PyResult {
-        vm.state
-            .codec_registry
-            .lookup(encoding.as_str(), vm)
-            .map(|codec| codec.into_tuple().into())
-    }
-
-    #[derive(FromArgs)]
-    struct CodeArgs {
-        obj: PyObjectRef,
-        #[pyarg(any, optional)]
-        encoding: Option<PyStrRef>,
-        #[pyarg(any, optional)]
-        errors: Option<PyStrRef>,
-    }
-
-    #[pyfunction]
-    fn encode(args: CodeArgs, vm: &VirtualMachine) -> PyResult {
-        let encoding = args
-            .encoding
-            .as_ref()
-            .map_or(codecs::DEFAULT_ENCODING, |s| s.as_str());
-        vm.state
-            .codec_registry
-            .encode(args.obj, encoding, args.errors, vm)
-    }
-
-    #[pyfunction]
-    fn decode(args: CodeArgs, vm: &VirtualMachine) -> PyResult {
-        let encoding = args
-            .encoding
-            .as_ref()
-            .map_or(codecs::DEFAULT_ENCODING, |s| s.as_str());
-        vm.state
-            .codec_registry
-            .decode(args.obj, encoding, args.errors, vm)
-    }
-
-    #[pyfunction]
-    fn _forget_codec(encoding: PyStrRef, vm: &VirtualMachine) {
-        vm.state.codec_registry.forget(encoding.as_str());
-    }
-
-    #[pyfunction]
-    fn register_error(name: PyStrRef, handler: PyObjectRef, vm: &VirtualMachine) -> PyResult<()> {
-        if !handler.is_callable() {
-            return Err(vm.new_type_error("handler must be callable".to_owned()));
-        }
-        vm.state
-            .codec_registry
-            .register_error(name.as_str().to_owned(), handler);
-        Ok(())
-    }
-
-    #[pyfunction]
-    fn lookup_error(name: PyStrRef, vm: &VirtualMachine) -> PyResult {
-        vm.state.codec_registry.lookup_error(name.as_str(), vm)
-    }
-
-    type EncodeResult = PyResult<(Vec<u8>, usize)>;
-
-    #[derive(FromArgs)]
-    struct EncodeArgs {
-        #[pyarg(positional)]
-        s: PyStrRef,
-        #[pyarg(positional, optional)]
-        errors: Option<PyStrRef>,
-    }
-
-    impl EncodeArgs {
-        #[inline]
-        fn encode<'a, F>(&'a self, name: &'a str, encode: F, vm: &'a VirtualMachine) -> EncodeResult
-        where
-            F: FnOnce(PyEncodeContext<'a>, &ErrorsHandler<'a>) -> PyResult<Vec<u8>>,
-        {
-            let ctx = PyEncodeContext::new(name, &self.s, vm);
-            let errors = ErrorsHandler::new(self.errors.as_deref(), vm);
-            let encoded = encode(ctx, &errors)?;
-            Ok((encoded, self.s.char_len()))
-        }
-    }
-
-    type DecodeResult = PyResult<(Wtf8Buf, usize)>;
-
-    #[derive(FromArgs)]
-    struct DecodeArgs {
-        #[pyarg(positional)]
-        data: ArgBytesLike,
-        #[pyarg(positional, optional)]
-        errors: Option<PyStrRef>,
-        #[pyarg(positional, default = false)]
-        final_decode: bool,
-    }
-
-    impl DecodeArgs {
-        #[inline]
-        fn decode<'a, F>(&'a self, name: &'a str, decode: F, vm: &'a VirtualMachine) -> DecodeResult
-        where
-            F: FnOnce(PyDecodeContext<'a>, &ErrorsHandler<'a>, bool) -> DecodeResult,
-        {
-            let ctx = PyDecodeContext::new(name, &self.data, vm);
-            let errors = ErrorsHandler::new(self.errors.as_deref(), vm);
-            decode(ctx, &errors, self.final_decode)
-        }
-    }
-
-    #[derive(FromArgs)]
-    struct DecodeArgsNoFinal {
-        #[pyarg(positional)]
-        data: ArgBytesLike,
-        #[pyarg(positional, optional)]
-        errors: Option<PyStrRef>,
-    }
-
-    impl DecodeArgsNoFinal {
-        #[inline]
-        fn decode<'a, F>(&'a self, name: &'a str, decode: F, vm: &'a VirtualMachine) -> DecodeResult
-        where
-            F: FnOnce(PyDecodeContext<'a>, &ErrorsHandler<'a>) -> DecodeResult,
-        {
-            let ctx = PyDecodeContext::new(name, &self.data, vm);
-            let errors = ErrorsHandler::new(self.errors.as_deref(), vm);
-            decode(ctx, &errors)
-        }
-    }
-
-    macro_rules! do_codec {
-        ($module:ident :: $func:ident, $args: expr, $vm:expr) => {{
-            use encodings::$module as codec;
-            $args.$func(codec::ENCODING_NAME, codec::$func, $vm)
-        }};
-    }
-
-    #[pyfunction]
-    fn utf_8_encode(args: EncodeArgs, vm: &VirtualMachine) -> EncodeResult {
-        if args.s.is_utf8()
-            || args
-                .errors
-                .as_ref()
-                .is_some_and(|s| s.is(identifier!(vm, surrogatepass)))
-        {
-            return Ok((args.s.as_bytes().to_vec(), args.s.byte_len()));
-        }
-        do_codec!(utf8::encode, args, vm)
-    }
-
-    #[pyfunction]
-    fn utf_8_decode(args: DecodeArgs, vm: &VirtualMachine) -> DecodeResult {
-        do_codec!(utf8::decode, args, vm)
-    }
-
-    #[pyfunction]
-    fn latin_1_encode(args: EncodeArgs, vm: &VirtualMachine) -> EncodeResult {
-        if args.s.isascii() {
-            return Ok((args.s.as_bytes().to_vec(), args.s.byte_len()));
-        }
-        do_codec!(latin_1::encode, args, vm)
-    }
-
-    #[pyfunction]
-    fn latin_1_decode(args: DecodeArgsNoFinal, vm: &VirtualMachine) -> DecodeResult {
-        do_codec!(latin_1::decode, args, vm)
-    }
-
-    #[pyfunction]
-    fn ascii_encode(args: EncodeArgs, vm: &VirtualMachine) -> EncodeResult {
-        if args.s.isascii() {
-            return Ok((args.s.as_bytes().to_vec(), args.s.byte_len()));
-        }
-        do_codec!(ascii::encode, args, vm)
-    }
-
-    #[pyfunction]
-    fn ascii_decode(args: DecodeArgsNoFinal, vm: &VirtualMachine) -> DecodeResult {
-        do_codec!(ascii::decode, args, vm)
-    }
-
-    // TODO: implement these codecs in Rust!
-
-    use crate::common::static_cell::StaticCell;
-    #[inline]
-    fn delegate_pycodecs(
-        cell: &'static StaticCell<PyObjectRef>,
-        name: &'static str,
-        args: FuncArgs,
-        vm: &VirtualMachine,
-    ) -> PyResult {
-        let f = cell.get_or_try_init(|| {
-            let module = vm.import("_pycodecs", 0)?;
-            module.get_attr(name, vm)
-        })?;
-        f.call(args, vm)
-    }
-    macro_rules! delegate_pycodecs {
-        ($name:ident, $args:ident, $vm:ident) => {{
-            rustpython_common::static_cell!(
-                static FUNC: PyObjectRef;
-            );
-            delegate_pycodecs(&FUNC, stringify!($name), $args, $vm)
-        }};
-    }
-
-    #[cfg(windows)]
-    #[derive(FromArgs)]
-    struct MbcsEncodeArgs {
-        #[pyarg(positional)]
-        s: PyStrRef,
-        #[pyarg(positional, optional)]
-        errors: Option<PyStrRef>,
-    }
-
-    #[cfg(windows)]
-    #[pyfunction]
-    fn mbcs_encode(args: MbcsEncodeArgs, vm: &VirtualMachine) -> PyResult<(Vec<u8>, usize)> {
-        use crate::common::windows::ToWideString;
-        use windows_sys::Win32::Globalization::{
-            CP_ACP, WC_NO_BEST_FIT_CHARS, WideCharToMultiByte,
-        };
-
-        let errors = args.errors.as_ref().map(|s| s.as_str()).unwrap_or("strict");
-        let s = match args.s.to_str() {
-            Some(s) => s,
-            None => {
-                // String contains surrogates - not encodable with mbcs
-                return Err(vm.new_unicode_encode_error(
-                    "'mbcs' codec can't encode character: surrogates not allowed".to_string(),
-                ));
-            }
-        };
-        let char_len = args.s.char_len();
-
-        if s.is_empty() {
-            return Ok((Vec::new(), char_len));
-        }
-
-        // Convert UTF-8 string to UTF-16
-        let wide: Vec<u16> = std::ffi::OsStr::new(s).to_wide();
-
-        // Get the required buffer size
-        let size = unsafe {
-            WideCharToMultiByte(
-                CP_ACP,
-                WC_NO_BEST_FIT_CHARS,
-                wide.as_ptr(),
-                wide.len() as i32,
-                std::ptr::null_mut(),
-                0,
-                core::ptr::null(),
-                std::ptr::null_mut(),
-            )
-        };
-
-        if size == 0 {
-            let err = std::io::Error::last_os_error();
-            return Err(vm.new_os_error(format!("mbcs_encode failed: {}", err)));
-        }
-
-        let mut buffer = vec![0u8; size as usize];
-        let mut used_default_char: i32 = 0;
-
-        let result = unsafe {
-            WideCharToMultiByte(
-                CP_ACP,
-                WC_NO_BEST_FIT_CHARS,
-                wide.as_ptr(),
-                wide.len() as i32,
-                buffer.as_mut_ptr().cast(),
-                size,
-                core::ptr::null(),
-                if errors == "strict" {
-                    &mut used_default_char
-                } else {
-                    std::ptr::null_mut()
-                },
-            )
-        };
-
-        if result == 0 {
-            let err = std::io::Error::last_os_error();
-            return Err(vm.new_os_error(format!("mbcs_encode failed: {err}")));
-        }
-
-        if errors == "strict" && used_default_char != 0 {
-            return Err(vm.new_unicode_encode_error(
-                "'mbcs' codec can't encode characters: invalid character",
-            ));
-        }
-
-        buffer.truncate(result as usize);
-        Ok((buffer, char_len))
-    }
-
-    #[cfg(not(windows))]
-    #[pyfunction]
-    fn mbcs_encode(args: FuncArgs, vm: &VirtualMachine) -> PyResult {
-        delegate_pycodecs!(mbcs_encode, args, vm)
-    }
-
-    #[cfg(windows)]
-    #[derive(FromArgs)]
-    struct MbcsDecodeArgs {
-        #[pyarg(positional)]
-        data: ArgBytesLike,
-        #[pyarg(positional, optional)]
-        errors: Option<PyStrRef>,
-        #[pyarg(positional, default = false)]
-        #[allow(dead_code)]
-        r#final: bool,
-    }
-
-    #[cfg(windows)]
-    #[pyfunction]
-    fn mbcs_decode(args: MbcsDecodeArgs, vm: &VirtualMachine) -> PyResult<(String, usize)> {
-        use windows_sys::Win32::Globalization::{
-            CP_ACP, MB_ERR_INVALID_CHARS, MultiByteToWideChar,
-        };
-
-        let _errors = args.errors.as_ref().map(|s| s.as_str()).unwrap_or("strict");
-        let data = args.data.borrow_buf();
-        let len = data.len();
-
-        if data.is_empty() {
-            return Ok((String::new(), 0));
-        }
-
-        // Get the required buffer size for UTF-16
-        let size = unsafe {
-            MultiByteToWideChar(
-                CP_ACP,
-                MB_ERR_INVALID_CHARS,
-                data.as_ptr().cast(),
-                len as i32,
-                std::ptr::null_mut(),
-                0,
-            )
-        };
-
-        if size == 0 {
-            // Try without MB_ERR_INVALID_CHARS for non-strict mode (replacement behavior)
-            let size = unsafe {
-                MultiByteToWideChar(
-                    CP_ACP,
-                    0,
-                    data.as_ptr().cast(),
-                    len as i32,
-                    std::ptr::null_mut(),
-                    0,
-                )
-            };
-            if size == 0 {
-                let err = std::io::Error::last_os_error();
-                return Err(vm.new_os_error(format!("mbcs_decode failed: {}", err)));
-            }
-
-            let mut buffer = vec![0u16; size as usize];
-            let result = unsafe {
-                MultiByteToWideChar(
-                    CP_ACP,
-                    0,
-                    data.as_ptr().cast(),
-                    len as i32,
-                    buffer.as_mut_ptr(),
-                    size,
-                )
-            };
-            if result == 0 {
-                let err = std::io::Error::last_os_error();
-                return Err(vm.new_os_error(format!("mbcs_decode failed: {}", err)));
-            }
-            buffer.truncate(result as usize);
-            let s = String::from_utf16(&buffer)
-                .map_err(|e| vm.new_unicode_decode_error(format!("mbcs_decode failed: {}", e)))?;
-            return Ok((s, len));
-        }
-
-        // Strict mode succeeded - no invalid characters
-        let mut buffer = vec![0u16; size as usize];
-        let result = unsafe {
-            MultiByteToWideChar(
-                CP_ACP,
-                MB_ERR_INVALID_CHARS,
-                data.as_ptr().cast(),
-                len as i32,
-                buffer.as_mut_ptr(),
-                size,
-            )
-        };
-        if result == 0 {
-            let err = std::io::Error::last_os_error();
-            return Err(vm.new_os_error(format!("mbcs_decode failed: {}", err)));
-        }
-        buffer.truncate(result as usize);
-        let s = String::from_utf16(&buffer)
-            .map_err(|e| vm.new_unicode_decode_error(format!("mbcs_decode failed: {}", e)))?;
-
-        Ok((s, len))
-    }
-
-    #[cfg(not(windows))]
-    #[pyfunction]
-    fn mbcs_decode(args: FuncArgs, vm: &VirtualMachine) -> PyResult {
-        delegate_pycodecs!(mbcs_decode, args, vm)
-    }
-
-    #[cfg(windows)]
-    #[derive(FromArgs)]
-    struct OemEncodeArgs {
-        #[pyarg(positional)]
-        s: PyStrRef,
-        #[pyarg(positional, optional)]
-        errors: Option<PyStrRef>,
-    }
-
-    #[cfg(windows)]
-    #[pyfunction]
-    fn oem_encode(args: OemEncodeArgs, vm: &VirtualMachine) -> PyResult<(Vec<u8>, usize)> {
-        use crate::common::windows::ToWideString;
-        use windows_sys::Win32::Globalization::{
-            CP_OEMCP, WC_NO_BEST_FIT_CHARS, WideCharToMultiByte,
-        };
-
-        let errors = args.errors.as_ref().map(|s| s.as_str()).unwrap_or("strict");
-        let s = match args.s.to_str() {
-            Some(s) => s,
-            None => {
-                // String contains surrogates - not encodable with oem
-                return Err(vm.new_unicode_encode_error(
-                    "'oem' codec can't encode character: surrogates not allowed".to_string(),
-                ));
-            }
-        };
-        let char_len = args.s.char_len();
-
-        if s.is_empty() {
-            return Ok((Vec::new(), char_len));
-        }
-
-        // Convert UTF-8 string to UTF-16
-        let wide: Vec<u16> = std::ffi::OsStr::new(s).to_wide();
-
-        // Get the required buffer size
-        let size = unsafe {
-            WideCharToMultiByte(
-                CP_OEMCP,
-                WC_NO_BEST_FIT_CHARS,
-                wide.as_ptr(),
-                wide.len() as i32,
-                std::ptr::null_mut(),
-                0,
-                core::ptr::null(),
-                std::ptr::null_mut(),
-            )
-        };
-
-        if size == 0 {
-            let err = std::io::Error::last_os_error();
-            return Err(vm.new_os_error(format!("oem_encode failed: {}", err)));
-        }
-
-        let mut buffer = vec![0u8; size as usize];
-        let mut used_default_char: i32 = 0;
-
-        let result = unsafe {
-            WideCharToMultiByte(
-                CP_OEMCP,
-                WC_NO_BEST_FIT_CHARS,
-                wide.as_ptr(),
-                wide.len() as i32,
-                buffer.as_mut_ptr().cast(),
-                size,
-                core::ptr::null(),
-                if errors == "strict" {
-                    &mut used_default_char
-                } else {
-                    std::ptr::null_mut()
-                },
-            )
-        };
-
-        if result == 0 {
-            let err = std::io::Error::last_os_error();
-            return Err(vm.new_os_error(format!("oem_encode failed: {err}")));
-        }
-
-        if errors == "strict" && used_default_char != 0 {
-            return Err(vm.new_unicode_encode_error(
-                "'oem' codec can't encode characters: invalid character",
-            ));
-        }
-
-        buffer.truncate(result as usize);
-        Ok((buffer, char_len))
-    }
-
-    #[cfg(not(windows))]
-    #[pyfunction]
-    fn oem_encode(args: FuncArgs, vm: &VirtualMachine) -> PyResult {
-        delegate_pycodecs!(oem_encode, args, vm)
-    }
-
-    #[cfg(windows)]
-    #[derive(FromArgs)]
-    struct OemDecodeArgs {
-        #[pyarg(positional)]
-        data: ArgBytesLike,
-        #[pyarg(positional, optional)]
-        errors: Option<PyStrRef>,
-        #[pyarg(positional, default = false)]
-        #[allow(dead_code)]
-        r#final: bool,
-    }
-
-    #[cfg(windows)]
-    #[pyfunction]
-    fn oem_decode(args: OemDecodeArgs, vm: &VirtualMachine) -> PyResult<(String, usize)> {
-        use windows_sys::Win32::Globalization::{
-            CP_OEMCP, MB_ERR_INVALID_CHARS, MultiByteToWideChar,
-        };
-
-        let _errors = args.errors.as_ref().map(|s| s.as_str()).unwrap_or("strict");
-        let data = args.data.borrow_buf();
-        let len = data.len();
-
-        if data.is_empty() {
-            return Ok((String::new(), 0));
-        }
-
-        // Get the required buffer size for UTF-16
-        let size = unsafe {
-            MultiByteToWideChar(
-                CP_OEMCP,
-                MB_ERR_INVALID_CHARS,
-                data.as_ptr().cast(),
-                len as i32,
-                std::ptr::null_mut(),
-                0,
-            )
-        };
-
-        if size == 0 {
-            // Try without MB_ERR_INVALID_CHARS for non-strict mode (replacement behavior)
-            let size = unsafe {
-                MultiByteToWideChar(
-                    CP_OEMCP,
-                    0,
-                    data.as_ptr().cast(),
-                    len as i32,
-                    std::ptr::null_mut(),
-                    0,
-                )
-            };
-            if size == 0 {
-                let err = std::io::Error::last_os_error();
-                return Err(vm.new_os_error(format!("oem_decode failed: {}", err)));
-            }
-
-            let mut buffer = vec![0u16; size as usize];
-            let result = unsafe {
-                MultiByteToWideChar(
-                    CP_OEMCP,
-                    0,
-                    data.as_ptr().cast(),
-                    len as i32,
-                    buffer.as_mut_ptr(),
-                    size,
-                )
-            };
-            if result == 0 {
-                let err = std::io::Error::last_os_error();
-                return Err(vm.new_os_error(format!("oem_decode failed: {}", err)));
-            }
-            buffer.truncate(result as usize);
-            let s = String::from_utf16(&buffer)
-                .map_err(|e| vm.new_unicode_decode_error(format!("oem_decode failed: {}", e)))?;
-            return Ok((s, len));
-        }
-
-        // Strict mode succeeded - no invalid characters
-        let mut buffer = vec![0u16; size as usize];
-        let result = unsafe {
-            MultiByteToWideChar(
-                CP_OEMCP,
-                MB_ERR_INVALID_CHARS,
-                data.as_ptr().cast(),
-                len as i32,
-                buffer.as_mut_ptr(),
-                size,
-            )
-        };
-        if result == 0 {
-            let err = std::io::Error::last_os_error();
-            return Err(vm.new_os_error(format!("oem_decode failed: {}", err)));
-        }
-        buffer.truncate(result as usize);
-        let s = String::from_utf16(&buffer)
-            .map_err(|e| vm.new_unicode_decode_error(format!("oem_decode failed: {}", e)))?;
-
-        Ok((s, len))
-    }
-
-    #[cfg(not(windows))]
-    #[pyfunction]
-    fn oem_decode(args: FuncArgs, vm: &VirtualMachine) -> PyResult {
-        delegate_pycodecs!(oem_decode, args, vm)
-    }
-
-    #[pyfunction]
-    fn readbuffer_encode(args: FuncArgs, vm: &VirtualMachine) -> PyResult {
-        delegate_pycodecs!(readbuffer_encode, args, vm)
-    }
-    #[pyfunction]
-    fn escape_encode(args: FuncArgs, vm: &VirtualMachine) -> PyResult {
-        delegate_pycodecs!(escape_encode, args, vm)
-    }
-    #[pyfunction]
-    fn escape_decode(args: FuncArgs, vm: &VirtualMachine) -> PyResult {
-        delegate_pycodecs!(escape_decode, args, vm)
-    }
-    #[pyfunction]
-    fn unicode_escape_encode(args: FuncArgs, vm: &VirtualMachine) -> PyResult {
-        delegate_pycodecs!(unicode_escape_encode, args, vm)
-    }
-    #[pyfunction]
-    fn unicode_escape_decode(args: FuncArgs, vm: &VirtualMachine) -> PyResult {
-        delegate_pycodecs!(unicode_escape_decode, args, vm)
-    }
-    #[pyfunction]
-    fn raw_unicode_escape_encode(args: FuncArgs, vm: &VirtualMachine) -> PyResult {
-        delegate_pycodecs!(raw_unicode_escape_encode, args, vm)
-    }
-    #[pyfunction]
-    fn raw_unicode_escape_decode(args: FuncArgs, vm: &VirtualMachine) -> PyResult {
-        delegate_pycodecs!(raw_unicode_escape_decode, args, vm)
-    }
-    #[pyfunction]
-    fn utf_7_encode(args: FuncArgs, vm: &VirtualMachine) -> PyResult {
-        delegate_pycodecs!(utf_7_encode, args, vm)
-    }
-    #[pyfunction]
-    fn utf_7_decode(args: FuncArgs, vm: &VirtualMachine) -> PyResult {
-        delegate_pycodecs!(utf_7_decode, args, vm)
-    }
-    #[pyfunction]
-    fn utf_16_encode(args: FuncArgs, vm: &VirtualMachine) -> PyResult {
-        delegate_pycodecs!(utf_16_encode, args, vm)
-    }
-    #[pyfunction]
-    fn utf_16_decode(args: FuncArgs, vm: &VirtualMachine) -> PyResult {
-        delegate_pycodecs!(utf_16_decode, args, vm)
-    }
-    #[pyfunction]
-    fn charmap_encode(args: FuncArgs, vm: &VirtualMachine) -> PyResult {
-        delegate_pycodecs!(charmap_encode, args, vm)
-    }
-    #[pyfunction]
-    fn charmap_decode(args: FuncArgs, vm: &VirtualMachine) -> PyResult {
-        delegate_pycodecs!(charmap_decode, args, vm)
-    }
-    #[pyfunction]
-    fn charmap_build(args: FuncArgs, vm: &VirtualMachine) -> PyResult {
-        delegate_pycodecs!(charmap_build, args, vm)
-    }
-    #[pyfunction]
-    fn utf_16_le_encode(args: FuncArgs, vm: &VirtualMachine) -> PyResult {
-        delegate_pycodecs!(utf_16_le_encode, args, vm)
-    }
-    #[pyfunction]
-    fn utf_16_le_decode(args: FuncArgs, vm: &VirtualMachine) -> PyResult {
-        delegate_pycodecs!(utf_16_le_decode, args, vm)
-    }
-    #[pyfunction]
-    fn utf_16_be_encode(args: FuncArgs, vm: &VirtualMachine) -> PyResult {
-        delegate_pycodecs!(utf_16_be_encode, args, vm)
-    }
-    #[pyfunction]
-    fn utf_16_be_decode(args: FuncArgs, vm: &VirtualMachine) -> PyResult {
-        delegate_pycodecs!(utf_16_be_decode, args, vm)
-    }
-    #[pyfunction]
-    fn utf_16_ex_decode(args: FuncArgs, vm: &VirtualMachine) -> PyResult {
-        delegate_pycodecs!(utf_16_ex_decode, args, vm)
-    }
-    // TODO: utf-32 functions
-}
diff --git a/crates/vm/src/stdlib/errno.rs b/crates/vm/src/stdlib/errno.rs
index 8e4efbaafe9..d7a0a222a76 100644
--- a/crates/vm/src/stdlib/errno.rs
+++ b/crates/vm/src/stdlib/errno.rs
@@ -39,12 +39,11 @@ pub mod errors {
             WSAENOMORE, WSAENOPROTOOPT, WSAENOTCONN, WSAENOTEMPTY, WSAENOTSOCK, WSAEOPNOTSUPP,
             WSAEPFNOSUPPORT, WSAEPROCLIM, WSAEPROTONOSUPPORT, WSAEPROTOTYPE,
             WSAEPROVIDERFAILEDINIT, WSAEREFUSED, WSAEREMOTE, WSAESHUTDOWN, WSAESOCKTNOSUPPORT,
-            WSAESTALE, WSAETIMEDOUT, WSAETOOMANYREFS, WSAEUSERS, WSAEWOULDBLOCK, WSAHOST_NOT_FOUND,
-            WSAID_ACCEPTEX, WSAID_CONNECTEX, WSAID_DISCONNECTEX, WSAID_GETACCEPTEXSOCKADDRS,
-            WSAID_TRANSMITFILE, WSAID_TRANSMITPACKETS, WSAID_WSAPOLL, WSAID_WSARECVMSG, WSANO_DATA,
-            WSANO_RECOVERY, WSANOTINITIALISED, WSAPROTOCOL_LEN, WSASERVICE_NOT_FOUND,
-            WSASYS_STATUS_LEN, WSASYSCALLFAILURE, WSASYSNOTREADY, WSATRY_AGAIN, WSATYPE_NOT_FOUND,
-            WSAVERNOTSUPPORTED,
+            WSAESTALE, WSAETIMEDOUT, WSAETOOMANYREFS, WSAEUSERS, WSAEWOULDBLOCK, WSAID_ACCEPTEX,
+            WSAID_CONNECTEX, WSAID_DISCONNECTEX, WSAID_GETACCEPTEXSOCKADDRS, WSAID_TRANSMITFILE,
+            WSAID_TRANSMITPACKETS, WSAID_WSAPOLL, WSAID_WSARECVMSG, WSANO_DATA, WSANO_RECOVERY,
+            WSANOTINITIALISED, WSAPROTOCOL_LEN, WSASERVICE_NOT_FOUND, WSASYS_STATUS_LEN,
+            WSASYSCALLFAILURE, WSASYSNOTREADY, WSATRY_AGAIN, WSATYPE_NOT_FOUND, WSAVERNOTSUPPORTED,
         },
     };
     #[cfg(windows)]
@@ -64,8 +63,6 @@ pub mod errors {
         ETIMEDOUT, ETOOMANYREFS, EUSERS, EWOULDBLOCK,
         // TODO: EBADF should be here once winerrs are translated to errnos but it messes up some things atm
     }
-    #[cfg(windows)]
-    pub const WSAHOS: i32 = WSAHOST_NOT_FOUND;
 }
 
 #[cfg(any(unix, windows, target_os = "wasi"))]
@@ -566,7 +563,7 @@ const ERROR_CODES: &[(&str, i32)] = &[
     e!(cfg(windows), WSAEDISCON),
     e!(cfg(windows), WSAEINTR),
     e!(cfg(windows), WSAEPROTOTYPE),
-    e!(cfg(windows), WSAHOS),
+    // TODO: e!(cfg(windows), WSAHOS),
     e!(cfg(windows), WSAEADDRINUSE),
     e!(cfg(windows), WSAEADDRNOTAVAIL),
     e!(cfg(windows), WSAEALREADY),
diff --git a/crates/vm/src/stdlib/gc.rs b/crates/vm/src/stdlib/gc.rs
new file mode 100644
index 00000000000..3909186b5c0
--- /dev/null
+++ b/crates/vm/src/stdlib/gc.rs
@@ -0,0 +1,305 @@
+pub(crate) use gc::module_def;
+
+#[pymodule]
+mod gc {
+    use crate::{
+        PyObjectRef, PyResult, VirtualMachine,
+        builtins::PyListRef,
+        function::{FuncArgs, OptionalArg},
+        gc_state,
+    };
+
+    // Debug flag constants
+    #[pyattr]
+    const DEBUG_STATS: u32 = gc_state::GcDebugFlags::STATS.bits();
+    #[pyattr]
+    const DEBUG_COLLECTABLE: u32 = gc_state::GcDebugFlags::COLLECTABLE.bits();
+    #[pyattr]
+    const DEBUG_UNCOLLECTABLE: u32 = gc_state::GcDebugFlags::UNCOLLECTABLE.bits();
+    #[pyattr]
+    const DEBUG_SAVEALL: u32 = gc_state::GcDebugFlags::SAVEALL.bits();
+    #[pyattr]
+    const DEBUG_LEAK: u32 = gc_state::GcDebugFlags::LEAK.bits();
+
+    /// Enable automatic garbage collection.
+    #[pyfunction]
+    fn enable() {
+        gc_state::gc_state().enable();
+    }
+
+    /// Disable automatic garbage collection.
+    #[pyfunction]
+    fn disable() {
+        gc_state::gc_state().disable();
+    }
+
+    /// Return true if automatic gc is enabled.
+    #[pyfunction]
+    fn isenabled() -> bool {
+        gc_state::gc_state().is_enabled()
+    }
+
+    /// Run a garbage collection. Returns the number of unreachable objects found.
+    #[derive(FromArgs)]
+    struct CollectArgs {
+        #[pyarg(any, optional)]
+        generation: OptionalArg<i32>,
+    }
+
+    #[pyfunction]
+    fn collect(args: CollectArgs, vm: &VirtualMachine) -> PyResult<i32> {
+        let generation = args.generation;
+        let generation_num = generation.unwrap_or(2);
+        if !(0..=2).contains(&generation_num) {
+            return Err(vm.new_value_error("invalid generation"));
+        }
+
+        // Invoke callbacks with "start" phase
+        invoke_callbacks(vm, "start", generation_num as usize, &Default::default());
+
+        // Manual gc.collect() should run even if GC is disabled
+        let gc = gc_state::gc_state();
+        let result = gc.collect_force(generation_num as usize);
+
+        // Move objects from gc_state.garbage to vm.ctx.gc_garbage (for DEBUG_SAVEALL)
+        {
+            let mut state_garbage = gc.garbage.lock();
+            if !state_garbage.is_empty() {
+                let py_garbage = &vm.ctx.gc_garbage;
+                let mut garbage_vec = py_garbage.borrow_vec_mut();
+                for obj in state_garbage.drain(..) {
+                    garbage_vec.push(obj);
+                }
+            }
+        }
+
+        // Invoke callbacks with "stop" phase
+        invoke_callbacks(vm, "stop", generation_num as usize, &result);
+
+        Ok((result.collected + result.uncollectable) as i32)
+    }
+
+    /// Return the current collection thresholds as a tuple.
+    #[pyfunction]
+    fn get_threshold(vm: &VirtualMachine) -> PyObjectRef {
+        let (t0, t1, t2) = gc_state::gc_state().get_threshold();
+        vm.ctx
+            .new_tuple(vec![
+                vm.ctx.new_int(t0).into(),
+                vm.ctx.new_int(t1).into(),
+                vm.ctx.new_int(t2).into(),
+            ])
+            .into()
+    }
+
+    /// Set the collection thresholds.
+    #[pyfunction]
+    fn set_threshold(threshold0: u32, threshold1: OptionalArg<u32>, threshold2: OptionalArg<u32>) {
+        gc_state::gc_state().set_threshold(
+            threshold0,
+            threshold1.into_option(),
+            threshold2.into_option(),
+        );
+    }
+
+    /// Return the current collection counts as a tuple.
+    #[pyfunction]
+    fn get_count(vm: &VirtualMachine) -> PyObjectRef {
+        let (c0, c1, c2) = gc_state::gc_state().get_count();
+        vm.ctx
+            .new_tuple(vec![
+                vm.ctx.new_int(c0).into(),
+                vm.ctx.new_int(c1).into(),
+                vm.ctx.new_int(c2).into(),
+            ])
+            .into()
+    }
+
+    /// Return the current debugging flags.
+    #[pyfunction]
+    fn get_debug() -> u32 {
+        gc_state::gc_state().get_debug().bits()
+    }
+
+    /// Set the debugging flags.
+    #[pyfunction]
+    fn set_debug(flags: u32) {
+        gc_state::gc_state().set_debug(gc_state::GcDebugFlags::from_bits_truncate(flags));
+    }
+
+    /// Return a list of per-generation gc stats.
+    #[pyfunction]
+    fn get_stats(vm: &VirtualMachine) -> PyResult<PyListRef> {
+        let stats = gc_state::gc_state().get_stats();
+        let mut result = Vec::with_capacity(3);
+
+        for stat in stats.iter() {
+            let dict = vm.ctx.new_dict();
+            dict.set_item("collections", vm.ctx.new_int(stat.collections).into(), vm)?;
+            dict.set_item("collected", vm.ctx.new_int(stat.collected).into(), vm)?;
+            dict.set_item(
+                "uncollectable",
+                vm.ctx.new_int(stat.uncollectable).into(),
+                vm,
+            )?;
+            dict.set_item("candidates", vm.ctx.new_int(stat.candidates).into(), vm)?;
+            dict.set_item("duration", vm.ctx.new_float(stat.duration).into(), vm)?;
+            result.push(dict.into());
+        }
+
+        Ok(vm.ctx.new_list(result))
+    }
+
+    /// Return the list of objects tracked by the collector.
+    #[derive(FromArgs)]
+    struct GetObjectsArgs {
+        #[pyarg(any, optional)]
+        generation: OptionalArg<Option<i32>>,
+    }
+
+    #[pyfunction]
+    fn get_objects(args: GetObjectsArgs, vm: &VirtualMachine) -> PyResult<PyListRef> {
+        let generation_opt = args.generation.flatten();
+        if let Some(g) = generation_opt
+            && !(0..=2).contains(&g)
+        {
+            return Err(vm.new_value_error(format!("generation must be in range(0, 3), not {}", g)));
+        }
+        let objects = gc_state::gc_state().get_objects(generation_opt);
+        Ok(vm.ctx.new_list(objects))
+    }
+
+    /// Return the list of objects directly referred to by any of the arguments.
+    #[pyfunction]
+    fn get_referents(args: FuncArgs, vm: &VirtualMachine) -> PyListRef {
+        let mut result = Vec::new();
+
+        for obj in args.args {
+            // Use the gc_get_referents method to get references
+            result.extend(obj.gc_get_referents());
+        }
+
+        vm.ctx.new_list(result)
+    }
+
+    /// Return the list of objects that directly refer to any of the arguments.
+    #[pyfunction]
+    fn get_referrers(args: FuncArgs, vm: &VirtualMachine) -> PyListRef {
+        use std::collections::HashSet;
+
+        // Build a set of target object pointers for fast lookup
+        let targets: HashSet<usize> = args
+            .args
+            .iter()
+            .map(|obj| obj.as_ref() as *const crate::PyObject as usize)
+            .collect();
+
+        // Collect pointers of frames currently on the execution stack.
+        // In CPython, executing frames (_PyInterpreterFrame) are not GC-tracked
+        // PyObjects, so they never appear in get_referrers results. Since
+        // RustPython materializes every frame as a PyObject, we must exclude
+        // them manually to match the expected behavior.
+        let stack_frames: HashSet<usize> = vm
+            .frames
+            .borrow()
+            .iter()
+            .map(|fp| {
+                let frame: &crate::PyObject = unsafe { fp.as_ref() }.as_ref();
+                frame as *const crate::PyObject as usize
+            })
+            .collect();
+
+        let mut result = Vec::new();
+
+        // Scan all tracked objects across all generations
+        let all_objects = gc_state::gc_state().get_objects(None);
+        for obj in all_objects {
+            let obj_ptr = obj.as_ref() as *const crate::PyObject as usize;
+            if stack_frames.contains(&obj_ptr) {
+                continue;
+            }
+            let referent_ptrs = unsafe { obj.gc_get_referent_ptrs() };
+            for child_ptr in referent_ptrs {
+                if targets.contains(&(child_ptr.as_ptr() as usize)) {
+                    result.push(obj.clone());
+                    break;
+                }
+            }
+        }
+
+        vm.ctx.new_list(result)
+    }
+
+    /// Return True if the object is tracked by the garbage collector.
+    #[pyfunction]
+    fn is_tracked(obj: PyObjectRef) -> bool {
+        // An object is tracked if it has IS_TRACE = true (has a trace function)
+        obj.is_gc_tracked()
+    }
+
+    /// Return True if the object has been finalized by the garbage collector.
+    #[pyfunction]
+    fn is_finalized(obj: PyObjectRef) -> bool {
+        obj.gc_finalized()
+    }
+
+    /// Freeze all objects tracked by gc.
+    #[pyfunction]
+    fn freeze() {
+        gc_state::gc_state().freeze();
+    }
+
+    /// Unfreeze all objects in the permanent generation.
+    #[pyfunction]
+    fn unfreeze() {
+        gc_state::gc_state().unfreeze();
+    }
+
+    /// Return the number of objects in the permanent generation.
+    #[pyfunction]
+    fn get_freeze_count() -> usize {
+        gc_state::gc_state().get_freeze_count()
+    }
+
+    /// gc.garbage - list of uncollectable objects
+    #[pyattr]
+    fn garbage(vm: &VirtualMachine) -> PyListRef {
+        vm.ctx.gc_garbage.clone()
+    }
+
+    /// gc.callbacks - list of callbacks to be invoked
+    #[pyattr]
+    fn callbacks(vm: &VirtualMachine) -> PyListRef {
+        vm.ctx.gc_callbacks.clone()
+    }
+
+    /// Helper function to invoke GC callbacks
+    fn invoke_callbacks(
+        vm: &VirtualMachine,
+        phase: &str,
+        generation: usize,
+        result: &gc_state::CollectResult,
+    ) {
+        let callbacks_list = &vm.ctx.gc_callbacks;
+        let callbacks: Vec<PyObjectRef> = callbacks_list.borrow_vec().to_vec();
+        if callbacks.is_empty() {
+            return;
+        }
+
+        let phase_str: PyObjectRef = vm.ctx.new_str(phase).into();
+        let info = vm.ctx.new_dict();
+        let _ = info.set_item("generation", vm.ctx.new_int(generation).into(), vm);
+        let _ = info.set_item("collected", vm.ctx.new_int(result.collected).into(), vm);
+        let _ = info.set_item(
+            "uncollectable",
+            vm.ctx.new_int(result.uncollectable).into(),
+            vm,
+        );
+        let _ = info.set_item("candidates", vm.ctx.new_int(result.candidates).into(), vm);
+        let _ = info.set_item("duration", vm.ctx.new_float(result.duration).into(), vm);
+
+        for callback in callbacks {
+            let _ = callback.call((phase_str.clone(), info.clone()), vm);
+        }
+    }
+}
diff --git a/crates/vm/src/stdlib/imp.rs b/crates/vm/src/stdlib/imp.rs
deleted file mode 100644
index 1c78e835a2d..00000000000
--- a/crates/vm/src/stdlib/imp.rs
+++ /dev/null
@@ -1,230 +0,0 @@
-use crate::frozen::FrozenModule;
-use crate::{VirtualMachine, builtins::PyBaseExceptionRef};
-pub(crate) use _imp::module_def;
-
-pub use crate::vm::resolve_frozen_alias;
-
-#[cfg(feature = "threading")]
-#[pymodule(sub)]
-mod lock {
-    use crate::{PyResult, VirtualMachine, stdlib::thread::RawRMutex};
-
-    static IMP_LOCK: RawRMutex = RawRMutex::INIT;
-
-    #[pyfunction]
-    fn acquire_lock(_vm: &VirtualMachine) {
-        IMP_LOCK.lock()
-    }
-
-    #[pyfunction]
-    fn release_lock(vm: &VirtualMachine) -> PyResult<()> {
-        if !IMP_LOCK.is_locked() {
-            Err(vm.new_runtime_error("Global import lock not held"))
-        } else {
-            unsafe { IMP_LOCK.unlock() };
-            Ok(())
-        }
-    }
-
-    #[pyfunction]
-    fn lock_held(_vm: &VirtualMachine) -> bool {
-        IMP_LOCK.is_locked()
-    }
-}
-
-#[cfg(not(feature = "threading"))]
-#[pymodule(sub)]
-mod lock {
-    use crate::vm::VirtualMachine;
-    #[pyfunction]
-    pub(super) const fn acquire_lock(_vm: &VirtualMachine) {}
-    #[pyfunction]
-    pub(super) const fn release_lock(_vm: &VirtualMachine) {}
-    #[pyfunction]
-    pub(super) const fn lock_held(_vm: &VirtualMachine) -> bool {
-        false
-    }
-}
-
-#[allow(dead_code)]
-enum FrozenError {
-    BadName,  // The given module name wasn't valid.
-    NotFound, // It wasn't in PyImport_FrozenModules.
-    Disabled, // -X frozen_modules=off (and not essential)
-    Excluded, // The PyImport_FrozenModules entry has NULL "code"
-    //        (module is present but marked as unimportable, stops search).
-    Invalid, // The PyImport_FrozenModules entry is bogus
-             //          (eg. does not contain executable code).
-}
-
-impl FrozenError {
-    fn to_pyexception(&self, mod_name: &str, vm: &VirtualMachine) -> PyBaseExceptionRef {
-        use FrozenError::*;
-        let msg = match self {
-            BadName | NotFound => format!("No such frozen object named {mod_name}"),
-            Disabled => format!(
-                "Frozen modules are disabled and the frozen object named {mod_name} is not essential"
-            ),
-            Excluded => format!("Excluded frozen object named {mod_name}"),
-            Invalid => format!("Frozen object named {mod_name} is invalid"),
-        };
-        vm.new_import_error(msg, vm.ctx.new_str(mod_name))
-    }
-}
-
-// find_frozen in frozen.c
-fn find_frozen(name: &str, vm: &VirtualMachine) -> Result<FrozenModule, FrozenError> {
-    vm.state
-        .frozen
-        .get(name)
-        .copied()
-        .ok_or(FrozenError::NotFound)
-}
-
-#[pymodule(with(lock))]
-mod _imp {
-    use crate::{
-        PyObjectRef, PyPayload, PyRef, PyResult, VirtualMachine,
-        builtins::{PyBytesRef, PyCode, PyMemoryView, PyModule, PyStrRef},
-        function::OptionalArg,
-        import, version,
-    };
-
-    #[pyattr]
-    fn check_hash_based_pycs(vm: &VirtualMachine) -> PyStrRef {
-        vm.ctx
-            .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())
-    }
-
-    #[pyfunction]
-    fn is_builtin(name: PyStrRef, vm: &VirtualMachine) -> bool {
-        vm.state.module_defs.contains_key(name.as_str())
-    }
-
-    #[pyfunction]
-    fn is_frozen(name: PyStrRef, vm: &VirtualMachine) -> bool {
-        vm.state.frozen.contains_key(name.as_str())
-    }
-
-    #[pyfunction]
-    fn create_builtin(spec: PyObjectRef, vm: &VirtualMachine) -> PyResult {
-        let sys_modules = vm.sys_module.get_attr("modules", vm).unwrap();
-        let name: PyStrRef = spec.get_attr("name", vm)?.try_into_value(vm)?;
-
-        // Check sys.modules first
-        if let Ok(module) = sys_modules.get_item(&*name, vm) {
-            return Ok(module);
-        }
-
-        // Try multi-phase init modules first (they need special handling)
-        if let Some(&def) = vm.state.module_defs.get(name.as_str()) {
-            // Phase 1: Create module (use create slot if provided, else default creation)
-            let module = if let Some(create) = def.slots.create {
-                // Custom module creation
-                create(vm, &spec, def)?
-            } else {
-                // Default module creation
-                PyModule::from_def(def).into_ref(&vm.ctx)
-            };
-
-            // Initialize module dict and methods
-            // Corresponds to PyModule_FromDefAndSpec: md_def, _add_methods_to_object, PyModule_SetDocString
-            PyModule::__init_dict_from_def(vm, &module);
-            module.__init_methods(vm)?;
-
-            // Add to sys.modules BEFORE exec (critical for circular import handling)
-            sys_modules.set_item(&*name, module.clone().into(), vm)?;
-
-            // Phase 2: Call exec slot (can safely import other modules now)
-            if let Some(exec) = def.slots.exec {
-                exec(vm, &module)?;
-            }
-
-            return Ok(module.into());
-        }
-
-        Ok(vm.ctx.none())
-    }
-
-    #[pyfunction]
-    fn exec_builtin(_mod: PyRef<PyModule>) -> i32 {
-        // For multi-phase init modules, exec is already called in create_builtin
-        0
-    }
-
-    #[pyfunction]
-    fn get_frozen_object(name: PyStrRef, vm: &VirtualMachine) -> PyResult<PyRef<PyCode>> {
-        import::make_frozen(vm, name.as_str())
-    }
-
-    #[pyfunction]
-    fn init_frozen(name: PyStrRef, vm: &VirtualMachine) -> PyResult {
-        import::import_frozen(vm, name.as_str())
-    }
-
-    #[pyfunction]
-    fn is_frozen_package(name: PyStrRef, vm: &VirtualMachine) -> PyResult<bool> {
-        super::find_frozen(name.as_str(), vm)
-            .map(|frozen| frozen.package)
-            .map_err(|e| e.to_pyexception(name.as_str(), vm))
-    }
-
-    #[pyfunction]
-    fn _override_frozen_modules_for_tests(value: isize, vm: &VirtualMachine) {
-        vm.state.override_frozen_modules.store(value);
-    }
-
-    #[pyfunction]
-    fn _fix_co_filename(_code: PyObjectRef, _path: PyStrRef) {
-        // TODO:
-    }
-
-    #[pyfunction]
-    fn _frozen_module_names(vm: &VirtualMachine) -> PyResult<Vec<PyObjectRef>> {
-        let names = vm
-            .state
-            .frozen
-            .keys()
-            .map(|&name| vm.ctx.new_str(name).into())
-            .collect();
-        Ok(names)
-    }
-
-    #[allow(clippy::type_complexity)]
-    #[pyfunction]
-    fn find_frozen(
-        name: PyStrRef,
-        withdata: OptionalArg<bool>,
-        vm: &VirtualMachine,
-    ) -> PyResult<Option<(Option<PyRef<PyMemoryView>>, bool, PyStrRef)>> {
-        use super::FrozenError::*;
-
-        if withdata.into_option().is_some() {
-            // this is keyword-only argument in CPython
-            unimplemented!();
-        }
-
-        let info = match super::find_frozen(name.as_str(), vm) {
-            Ok(info) => info,
-            Err(NotFound | Disabled | BadName) => return Ok(None),
-            Err(e) => return Err(e.to_pyexception(name.as_str(), vm)),
-        };
-
-        let origname = vm.ctx.new_str(super::resolve_frozen_alias(name.as_str()));
-        Ok(Some((None, info.package, origname)))
-    }
-
-    #[pyfunction]
-    fn source_hash(key: u64, source: PyBytesRef) -> Vec<u8> {
-        let hash: u64 = crate::common::hash::keyed_hash(key, source.as_bytes());
-        hash.to_le_bytes().to_vec()
-    }
-}
diff --git a/crates/vm/src/stdlib/itertools.rs b/crates/vm/src/stdlib/itertools.rs
index 5a3cfee391b..763c3ddce76 100644
--- a/crates/vm/src/stdlib/itertools.rs
+++ b/crates/vm/src/stdlib/itertools.rs
@@ -16,9 +16,11 @@ mod decl {
         stdlib::sys,
         types::{Constructor, IterNext, Iterable, Representable, SelfIter},
     };
+    use core::sync::atomic::{AtomicBool, Ordering};
     use crossbeam_utils::atomic::AtomicCell;
     use malachite_bigint::BigInt;
     use num_traits::One;
+    use rustpython_common::wtf8::Wtf8Buf;
 
     use alloc::fmt;
     use num_traits::{Signed, ToPrimitive};
@@ -219,13 +221,17 @@ mod decl {
 
     impl Representable for PyItertoolsCount {
         #[inline]
-        fn repr_str(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<String> {
-            let cur = format!("{}", zelf.cur.read().clone().repr(vm)?);
+        fn repr_wtf8(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<Wtf8Buf> {
+            let cur_repr = zelf.cur.read().clone().repr(vm)?;
             let step = &zelf.step;
-            if vm.bool_eq(step, vm.ctx.new_int(1).as_object())? {
-                return Ok(format!("count({cur})"));
+            let mut result = Wtf8Buf::from("count(");
+            result.push_wtf8(cur_repr.as_wtf8());
+            if !vm.bool_eq(step, vm.ctx.new_int(1).as_object())? {
+                result.push_str(", ");
+                result.push_wtf8(step.repr(vm)?.as_wtf8());
             }
-            Ok(format!("count({}, {})", cur, step.repr(vm)?))
+            result.push_char(')');
+            Ok(result)
         }
     }
 
@@ -291,7 +297,7 @@ mod decl {
     struct PyRepeatNewArgs {
         object: PyObjectRef,
         #[pyarg(any, optional)]
-        times: OptionalArg<PyIntRef>,
+        times: OptionalArg<PyObjectRef>,
     }
 
     impl Constructor for PyItertoolsRepeat {
@@ -303,7 +309,8 @@ mod decl {
             vm: &VirtualMachine,
         ) -> PyResult<Self> {
             let times = match times.into_option() {
-                Some(int) => {
+                Some(obj) => {
+                    let int = obj.try_index(vm)?;
                     let val: isize = int.try_to_primitive(vm)?;
                     // times always >= 0.
                     Some(PyRwLock::new(val.to_usize().unwrap_or(0)))
@@ -344,13 +351,15 @@ mod decl {
 
     impl Representable for PyItertoolsRepeat {
         #[inline]
-        fn repr_str(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<String> {
-            let mut fmt = format!("{}", &zelf.object.repr(vm)?);
+        fn repr_wtf8(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<Wtf8Buf> {
+            let mut result = Wtf8Buf::from("repeat(");
+            result.push_wtf8(zelf.object.repr(vm)?.as_wtf8());
             if let Some(ref times) = zelf.times {
-                fmt.push_str(", ");
-                fmt.push_str(&times.read().to_string());
+                result.push_str(", ");
+                result.push_str(&times.read().to_string());
             }
-            Ok(format!("repeat({fmt})"))
+            result.push_char(')');
+            Ok(result)
         }
     }
 
@@ -658,7 +667,7 @@ mod decl {
         groupby: PyRef<PyItertoolsGroupBy>,
     }
 
-    #[pyclass(with(IterNext, Iterable))]
+    #[pyclass(with(IterNext, Iterable), flags(HAS_WEAKREF))]
     impl PyItertoolsGrouper {}
 
     impl SelfIter for PyItertoolsGrouper {}
@@ -943,6 +952,7 @@ mod decl {
     struct PyItertoolsTeeData {
         iterable: PyIter,
         values: PyMutex<Vec<PyObjectRef>>,
+        running: AtomicBool,
     }
 
     impl PyItertoolsTeeData {
@@ -950,19 +960,33 @@ mod decl {
             Ok(PyRc::new(Self {
                 iterable,
                 values: PyMutex::new(vec![]),
+                running: AtomicBool::new(false),
             }))
         }
 
         fn get_item(&self, vm: &VirtualMachine, index: usize) -> PyResult<PyIterReturn> {
+            // Return cached value if available
+            {
+                let Some(values) = self.values.try_lock() else {
+                    return Err(vm.new_runtime_error("cannot re-enter the tee iterator"));
+                };
+                if index < values.len() {
+                    return Ok(PyIterReturn::Return(values[index].clone()));
+                }
+            }
+            // Prevent concurrent/reentrant calls to iterable.next()
+            if self.running.swap(true, Ordering::Acquire) {
+                return Err(vm.new_runtime_error("cannot re-enter the tee iterator"));
+            }
+            let result = self.iterable.next(vm);
+            self.running.store(false, Ordering::Release);
+            let obj = raise_if_stop!(result?);
             let Some(mut values) = self.values.try_lock() else {
                 return Err(vm.new_runtime_error("cannot re-enter the tee iterator"));
             };
-
             if values.len() == index {
-                let obj = raise_if_stop!(self.iterable.next(vm)?);
                 values.push(obj);
             }
-
             Ok(PyIterReturn::Return(values[index].clone()))
         }
     }
diff --git a/crates/vm/src/stdlib/marshal.rs b/crates/vm/src/stdlib/marshal.rs
index cf7abe65194..dace6bbf3e3 100644
--- a/crates/vm/src/stdlib/marshal.rs
+++ b/crates/vm/src/stdlib/marshal.rs
@@ -5,20 +5,19 @@ pub(crate) use decl::module_def;
 mod decl {
     use crate::builtins::code::{CodeObject, Literal, PyObjBag};
     use crate::class::StaticType;
+    use crate::common::wtf8::Wtf8;
     use crate::{
         PyObjectRef, PyResult, TryFromObject, VirtualMachine,
         builtins::{
             PyBool, PyByteArray, PyBytes, PyCode, PyComplex, PyDict, PyEllipsis, PyFloat,
             PyFrozenSet, PyInt, PyList, PyNone, PySet, PyStopIteration, PyStr, PyTuple,
         },
-        common::wtf8::Wtf8,
         convert::ToPyObject,
         function::{ArgBytesLike, OptionalArg},
         object::{AsObject, PyPayload},
         protocol::PyBuffer,
     };
     use malachite_bigint::BigInt;
-    use num_complex::Complex64;
     use num_traits::Zero;
     use rustpython_compiler_core::marshal;
 
@@ -91,34 +90,290 @@ mod decl {
         }
     }
 
-    #[pyfunction]
-    fn dumps(
+    #[derive(FromArgs)]
+    struct DumpsArgs {
         value: PyObjectRef,
+        #[pyarg(any, optional)]
         _version: OptionalArg<i32>,
-        vm: &VirtualMachine,
-    ) -> PyResult<PyBytes> {
-        use marshal::Dumpable;
+        #[pyarg(named, default = true)]
+        allow_code: bool,
+    }
+
+    #[pyfunction]
+    fn dumps(args: DumpsArgs, vm: &VirtualMachine) -> PyResult<PyBytes> {
+        let DumpsArgs {
+            value,
+            allow_code,
+            _version,
+        } = args;
+        let version = _version.unwrap_or(marshal::FORMAT_VERSION as i32);
+        if !allow_code {
+            check_no_code(&value, vm)?;
+        }
+        check_exact_type(&value, vm)?;
         let mut buf = Vec::new();
-        value
-            .with_dump(|val| marshal::serialize_value(&mut buf, val))
-            .unwrap_or_else(Err)
-            .map_err(|DumpError| {
-                vm.new_not_implemented_error(
-                    "TODO: not implemented yet or marshal unsupported type",
-                )
-            })?;
+        let mut refs = if version >= 3 {
+            Some(WriterRefTable::new())
+        } else {
+            None
+        };
+        write_object(&mut buf, &value, &mut refs, version, vm)?;
         Ok(PyBytes::from(buf))
     }
 
-    #[pyfunction]
-    fn dump(
-        value: PyObjectRef,
-        f: PyObjectRef,
-        version: OptionalArg<i32>,
+    struct WriterRefTable {
+        map: std::collections::HashMap<usize, u32>,
+        next_idx: u32,
+    }
+
+    impl WriterRefTable {
+        fn new() -> Self {
+            Self {
+                map: std::collections::HashMap::new(),
+                next_idx: 0,
+            }
+        }
+        fn try_ref(&mut self, buf: &mut Vec<u8>, obj: &PyObjectRef) -> bool {
+            use marshal::Write;
+            let id = obj.get_id();
+            if let Some(&idx) = self.map.get(&id) {
+                buf.write_u8(b'r');
+                buf.write_u32(idx);
+                true
+            } else {
+                false
+            }
+        }
+        fn reserve(&mut self, obj: &PyObjectRef) -> u32 {
+            let idx = self.next_idx;
+            self.map.insert(obj.get_id(), idx);
+            self.next_idx += 1;
+            idx
+        }
+    }
+
+    fn write_object(
+        buf: &mut Vec<u8>,
+        obj: &PyObjectRef,
+        refs: &mut Option<WriterRefTable>,
+        version: i32,
         vm: &VirtualMachine,
     ) -> PyResult<()> {
-        let dumped = dumps(value, version, vm)?;
-        vm.call_method(&f, "write", (dumped,))?;
+        write_object_depth(
+            buf,
+            obj,
+            refs,
+            version,
+            vm,
+            marshal::MAX_MARSHAL_STACK_DEPTH,
+        )
+    }
+
+    fn write_object_depth(
+        buf: &mut Vec<u8>,
+        obj: &PyObjectRef,
+        refs: &mut Option<WriterRefTable>,
+        version: i32,
+        vm: &VirtualMachine,
+        depth: usize,
+    ) -> PyResult<()> {
+        use marshal::Write;
+        if depth == 0 {
+            return Err(vm.new_value_error("object too deeply nested to marshal".to_string()));
+        }
+
+        // Singletons: no FLAG_REF needed
+        let is_singleton = vm.is_none(obj)
+            || obj.class().is(PyBool::static_type())
+            || obj.is(PyStopIteration::static_type())
+            || obj.downcast_ref::<crate::builtins::PyEllipsis>().is_some();
+
+        // FLAG_REF: check if already written, otherwise reserve slot
+        if !is_singleton
+            && let Some(rt) = refs.as_mut()
+            && rt.try_ref(buf, obj)
+        {
+            return Ok(());
+        }
+        let type_pos = buf.len();
+        let use_ref = refs.is_some() && !is_singleton;
+        if use_ref {
+            refs.as_mut().unwrap().reserve(obj);
+        }
+
+        if vm.is_none(obj) {
+            buf.write_u8(b'N');
+        } else if obj.is(PyStopIteration::static_type()) {
+            buf.write_u8(b'S');
+        } else if obj.class().is(PyBool::static_type()) {
+            let val = obj
+                .downcast_ref::<PyInt>()
+                .is_some_and(|i| !i.as_bigint().is_zero());
+            buf.write_u8(if val { b'T' } else { b'F' });
+        } else if obj.downcast_ref::<crate::builtins::PyEllipsis>().is_some() {
+            buf.write_u8(b'.');
+        } else if let Some(i) = obj.downcast_ref::<PyInt>() {
+            // TYPE_INT for i32 range, TYPE_LONG for larger
+            if let Ok(val) = i32::try_from(i.as_bigint()) {
+                buf.write_u8(b'i');
+                buf.write_u32(val as u32);
+            } else {
+                buf.write_u8(b'l');
+                let (sign, raw) = i.as_bigint().to_bytes_le();
+                let mut digits = Vec::new();
+                let mut accum: u32 = 0;
+                let mut bits = 0u32;
+                for &byte in &raw {
+                    accum |= (byte as u32) << bits;
+                    bits += 8;
+                    while bits >= 15 {
+                        digits.push((accum & 0x7fff) as u16);
+                        accum >>= 15;
+                        bits -= 15;
+                    }
+                }
+                if accum > 0 || digits.is_empty() {
+                    digits.push(accum as u16);
+                }
+                while digits.len() > 1 && *digits.last().unwrap() == 0 {
+                    digits.pop();
+                }
+                let n = digits.len() as i32;
+                let n = if sign == malachite_bigint::Sign::Minus {
+                    -n
+                } else {
+                    n
+                };
+                buf.write_u32(n as u32);
+                for d in &digits {
+                    buf.write_u16(*d);
+                }
+            }
+        } else if let Some(f) = obj.downcast_ref::<PyFloat>() {
+            buf.write_u8(b'g');
+            buf.write_u64(f.to_f64().to_bits());
+        } else if let Some(c) = obj.downcast_ref::<PyComplex>() {
+            buf.write_u8(b'y');
+            let cv = c.to_complex64();
+            buf.write_u64(cv.re.to_bits());
+            buf.write_u64(cv.im.to_bits());
+        } else if let Some(s) = obj.downcast_ref::<PyStr>() {
+            let bytes = s.as_wtf8().as_bytes();
+            let interned = version >= 3;
+            if bytes.len() < 256 && bytes.is_ascii() {
+                buf.write_u8(if interned { b'Z' } else { b'z' });
+                buf.write_u8(bytes.len() as u8);
+            } else {
+                buf.write_u8(if interned { b't' } else { b'u' });
+                buf.write_u32(bytes.len() as u32);
+            }
+            buf.write_slice(bytes);
+        } else if let Some(b) = obj.downcast_ref::<PyBytes>() {
+            buf.write_u8(b's');
+            let data = b.as_bytes();
+            buf.write_u32(data.len() as u32);
+            buf.write_slice(data);
+        } else if let Some(b) = obj.downcast_ref::<PyByteArray>() {
+            buf.write_u8(b's');
+            let data = b.borrow_buf();
+            buf.write_u32(data.len() as u32);
+            buf.write_slice(&data);
+        } else if let Some(t) = obj.downcast_ref::<PyTuple>() {
+            buf.write_u8(b'(');
+            buf.write_u32(t.len() as u32);
+            for elem in t.as_slice() {
+                write_object_depth(buf, elem, refs, version, vm, depth - 1)?;
+            }
+        } else if let Some(l) = obj.downcast_ref::<PyList>() {
+            buf.write_u8(b'[');
+            let items = l.borrow_vec();
+            buf.write_u32(items.len() as u32);
+            for elem in items.iter() {
+                write_object_depth(buf, elem, refs, version, vm, depth - 1)?;
+            }
+        } else if let Some(d) = obj.downcast_ref::<PyDict>() {
+            buf.write_u8(b'{');
+            for (k, v) in d.into_iter() {
+                write_object_depth(buf, &k, refs, version, vm, depth - 1)?;
+                write_object_depth(buf, &v, refs, version, vm, depth - 1)?;
+            }
+            buf.write_u8(b'0'); // TYPE_NULL terminator
+        } else if let Some(s) = obj.downcast_ref::<PySet>() {
+            buf.write_u8(b'<');
+            let elems = s.elements();
+            buf.write_u32(elems.len() as u32);
+            for elem in &elems {
+                write_object_depth(buf, elem, refs, version, vm, depth - 1)?;
+            }
+        } else if let Some(s) = obj.downcast_ref::<PyFrozenSet>() {
+            buf.write_u8(b'>');
+            let elems = s.elements();
+            buf.write_u32(elems.len() as u32);
+            for elem in &elems {
+                write_object_depth(buf, elem, refs, version, vm, depth - 1)?;
+            }
+        } else if let Some(co) = obj.downcast_ref::<PyCode>() {
+            buf.write_u8(b'c');
+            marshal::serialize_code(buf, &co.code);
+        } else if let Some(sl) = obj.downcast_ref::<crate::builtins::PySlice>() {
+            if version < 5 {
+                return Err(vm.new_value_error("unmarshallable object".to_string()));
+            }
+            buf.write_u8(b':');
+            let none: PyObjectRef = vm.ctx.none();
+            write_object_depth(
+                buf,
+                sl.start.as_ref().unwrap_or(&none),
+                refs,
+                version,
+                vm,
+                depth - 1,
+            )?;
+            write_object_depth(buf, &sl.stop, refs, version, vm, depth - 1)?;
+            write_object_depth(
+                buf,
+                sl.step.as_ref().unwrap_or(&none),
+                refs,
+                version,
+                vm,
+                depth - 1,
+            )?;
+        } else if let Ok(bytes_like) = ArgBytesLike::try_from_object(vm, obj.clone()) {
+            buf.write_u8(b's');
+            let data = bytes_like.borrow_buf();
+            buf.write_u32(data.len() as u32);
+            buf.write_slice(&data);
+        } else {
+            return Err(vm.new_value_error("unmarshallable object".to_string()));
+        }
+
+        if use_ref {
+            buf[type_pos] |= marshal::FLAG_REF;
+        }
+        Ok(())
+    }
+
+    #[derive(FromArgs)]
+    struct DumpArgs {
+        value: PyObjectRef,
+        f: PyObjectRef,
+        #[pyarg(any, optional)]
+        _version: OptionalArg<i32>,
+        #[pyarg(named, default = true)]
+        allow_code: bool,
+    }
+
+    #[pyfunction]
+    fn dump(args: DumpArgs, vm: &VirtualMachine) -> PyResult<()> {
+        let dumped = dumps(
+            DumpsArgs {
+                value: args.value,
+                _version: args._version,
+                allow_code: args.allow_code,
+            },
+            vm,
+        )?;
+        vm.call_method(&args.f, "write", (dumped,))?;
         Ok(())
     }
 
@@ -132,121 +387,219 @@ mod decl {
         fn make_bool(&self, value: bool) -> Self::Value {
             self.0.ctx.new_bool(value).into()
         }
-
         fn make_none(&self) -> Self::Value {
             self.0.ctx.none()
         }
-
         fn make_ellipsis(&self) -> Self::Value {
             self.0.ctx.ellipsis.clone().into()
         }
-
         fn make_float(&self, value: f64) -> Self::Value {
             self.0.ctx.new_float(value).into()
         }
-
-        fn make_complex(&self, value: Complex64) -> Self::Value {
+        fn make_complex(&self, value: num_complex::Complex64) -> Self::Value {
             self.0.ctx.new_complex(value).into()
         }
-
         fn make_str(&self, value: &Wtf8) -> Self::Value {
             self.0.ctx.new_str(value).into()
         }
-
         fn make_bytes(&self, value: &[u8]) -> Self::Value {
             self.0.ctx.new_bytes(value.to_vec()).into()
         }
-
         fn make_int(&self, value: BigInt) -> Self::Value {
             self.0.ctx.new_int(value).into()
         }
-
         fn make_tuple(&self, elements: impl Iterator<Item = Self::Value>) -> Self::Value {
-            let elements = elements.collect();
-            self.0.ctx.new_tuple(elements).into()
+            self.0.ctx.new_tuple(elements.collect()).into()
         }
-
         fn make_code(&self, code: CodeObject) -> Self::Value {
             self.0.ctx.new_code(code).into()
         }
-
         fn make_stop_iter(&self) -> Result<Self::Value, marshal::MarshalError> {
             Ok(self.0.ctx.exceptions.stop_iteration.to_owned().into())
         }
-
         fn make_list(
             &self,
             it: impl Iterator<Item = Self::Value>,
         ) -> Result<Self::Value, marshal::MarshalError> {
             Ok(self.0.ctx.new_list(it.collect()).into())
         }
-
         fn make_set(
             &self,
             it: impl Iterator<Item = Self::Value>,
         ) -> Result<Self::Value, marshal::MarshalError> {
-            let vm = self.0;
-            let set = PySet::default().into_ref(&vm.ctx);
+            let set = PySet::default().into_ref(&self.0.ctx);
             for elem in it {
-                set.add(elem, vm).unwrap()
+                set.add(elem, self.0).unwrap()
             }
             Ok(set.into())
         }
-
         fn make_frozenset(
             &self,
             it: impl Iterator<Item = Self::Value>,
         ) -> Result<Self::Value, marshal::MarshalError> {
-            let vm = self.0;
-            Ok(PyFrozenSet::from_iter(vm, it).unwrap().to_pyobject(vm))
+            Ok(PyFrozenSet::from_iter(self.0, it)
+                .unwrap()
+                .to_pyobject(self.0))
         }
-
         fn make_dict(
             &self,
             it: impl Iterator<Item = (Self::Value, Self::Value)>,
         ) -> Result<Self::Value, marshal::MarshalError> {
-            let vm = self.0;
-            let dict = vm.ctx.new_dict();
+            let dict = self.0.ctx.new_dict();
             for (k, v) in it {
-                dict.set_item(&*k, v, vm).unwrap()
+                dict.set_item(&*k, v, self.0).unwrap()
             }
             Ok(dict.into())
         }
-
+        fn make_slice(
+            &self,
+            start: Self::Value,
+            stop: Self::Value,
+            step: Self::Value,
+        ) -> Result<Self::Value, marshal::MarshalError> {
+            use crate::builtins::PySlice;
+            let vm = self.0;
+            Ok(PySlice {
+                start: if vm.is_none(&start) {
+                    None
+                } else {
+                    Some(start)
+                },
+                stop,
+                step: if vm.is_none(&step) { None } else { Some(step) },
+            }
+            .into_ref(&vm.ctx)
+            .into())
+        }
         fn constant_bag(self) -> Self::ConstantBag {
             PyObjBag(&self.0.ctx)
         }
     }
 
+    #[derive(FromArgs)]
+    struct LoadsArgs {
+        #[pyarg(any)]
+        data: PyBuffer,
+        #[pyarg(named, default = true)]
+        allow_code: bool,
+    }
+
     #[pyfunction]
-    fn loads(pybuffer: PyBuffer, vm: &VirtualMachine) -> PyResult<PyObjectRef> {
+    fn loads(args: LoadsArgs, vm: &VirtualMachine) -> PyResult<PyObjectRef> {
+        let LoadsArgs {
+            data: pybuffer,
+            allow_code,
+        } = args;
         let buf = pybuffer.as_contiguous().ok_or_else(|| {
             vm.new_buffer_error("Buffer provided to marshal.loads() is not contiguous")
         })?;
-        marshal::deserialize_value(&mut &buf[..], PyMarshalBag(vm)).map_err(|e| match e {
-            marshal::MarshalError::Eof => vm.new_exception_msg(
-                vm.ctx.exceptions.eof_error.to_owned(),
-                "marshal data too short".to_owned(),
-            ),
-            marshal::MarshalError::InvalidBytecode => {
-                vm.new_value_error("Couldn't deserialize python bytecode")
+
+        let result =
+            marshal::deserialize_value(&mut &buf[..], PyMarshalBag(vm)).map_err(|e| match e {
+                marshal::MarshalError::Eof => vm.new_exception_msg(
+                    vm.ctx.exceptions.eof_error.to_owned(),
+                    "marshal data too short".into(),
+                ),
+                _ => vm.new_value_error("bad marshal data"),
+            })?;
+        if !allow_code {
+            check_no_code(&result, vm)?;
+        }
+        Ok(result)
+    }
+
+    #[derive(FromArgs)]
+    struct LoadArgs {
+        f: PyObjectRef,
+        #[pyarg(named, default = true)]
+        allow_code: bool,
+    }
+
+    #[pyfunction]
+    fn load(args: LoadArgs, vm: &VirtualMachine) -> PyResult<PyObjectRef> {
+        // Read from file object into a buffer, one object at a time.
+        // We read all available data, deserialize one object, then seek
+        // back to just after the consumed bytes.
+        let tell_before = vm
+            .call_method(&args.f, "tell", ())?
+            .try_into_value::<i64>(vm)?;
+        let read_res = vm.call_method(&args.f, "read", ())?;
+        let bytes = ArgBytesLike::try_from_object(vm, read_res)?;
+        let buf = bytes.borrow_buf();
+
+        let mut rdr: &[u8] = &buf;
+        let len_before = rdr.len();
+        let result =
+            marshal::deserialize_value(&mut rdr, PyMarshalBag(vm)).map_err(|e| match e {
+                marshal::MarshalError::Eof => vm.new_exception_msg(
+                    vm.ctx.exceptions.eof_error.to_owned(),
+                    "marshal data too short".into(),
+                ),
+                _ => vm.new_value_error("bad marshal data"),
+            })?;
+        let consumed = len_before - rdr.len();
+
+        // Seek file to just after the consumed bytes
+        let new_pos = tell_before + consumed as i64;
+        vm.call_method(&args.f, "seek", (new_pos,))?;
+
+        if !args.allow_code {
+            check_no_code(&result, vm)?;
+        }
+        Ok(result)
+    }
+
+    /// Reject subclasses of marshallable types (int, float, complex, tuple, etc.).
+    /// Recursively check that no code objects are present.
+    fn check_no_code(obj: &PyObjectRef, vm: &VirtualMachine) -> PyResult<()> {
+        if obj.downcast_ref::<PyCode>().is_some() {
+            return Err(vm.new_value_error("unmarshalling code objects is disallowed".to_string()));
+        }
+        if let Some(tup) = obj.downcast_ref::<PyTuple>() {
+            for elem in tup.as_slice() {
+                check_no_code(elem, vm)?;
             }
-            marshal::MarshalError::InvalidUtf8 => {
-                vm.new_value_error("invalid utf8 in marshalled string")
+        } else if let Some(list) = obj.downcast_ref::<PyList>() {
+            for elem in list.borrow_vec().iter() {
+                check_no_code(elem, vm)?;
             }
-            marshal::MarshalError::InvalidLocation => {
-                vm.new_value_error("invalid location in marshalled object")
+        } else if let Some(set) = obj.downcast_ref::<PySet>() {
+            for elem in set.elements() {
+                check_no_code(&elem, vm)?;
             }
-            marshal::MarshalError::BadType => {
-                vm.new_value_error("bad marshal data (unknown type code)")
+        } else if let Some(fset) = obj.downcast_ref::<PyFrozenSet>() {
+            for elem in fset.elements() {
+                check_no_code(&elem, vm)?;
             }
-        })
+        } else if let Some(dict) = obj.downcast_ref::<PyDict>() {
+            for (k, v) in dict.into_iter() {
+                check_no_code(&k, vm)?;
+                check_no_code(&v, vm)?;
+            }
+        }
+        Ok(())
     }
 
-    #[pyfunction]
-    fn load(f: PyObjectRef, vm: &VirtualMachine) -> PyResult<PyObjectRef> {
-        let read_res = vm.call_method(&f, "read", ())?;
-        let bytes = ArgBytesLike::try_from_object(vm, read_res)?;
-        loads(PyBuffer::from(bytes), vm)
+    fn check_exact_type(obj: &PyObjectRef, vm: &VirtualMachine) -> PyResult<()> {
+        let cls = obj.class();
+        // bool is a subclass of int but is marshallable
+        if cls.is(PyBool::static_type()) {
+            return Ok(());
+        }
+        for base in [
+            PyInt::static_type(),
+            PyFloat::static_type(),
+            PyComplex::static_type(),
+            PyTuple::static_type(),
+            PyList::static_type(),
+            PyDict::static_type(),
+            PySet::static_type(),
+            PyFrozenSet::static_type(),
+        ] {
+            if cls.fast_issubclass(base) && !cls.is(base) {
+                return Err(vm.new_value_error("unmarshallable object".to_string()));
+            }
+        }
+        Ok(())
     }
 }
diff --git a/crates/vm/src/stdlib/mod.rs b/crates/vm/src/stdlib/mod.rs
index 088abc5b4a6..97fb4b372cf 100644
--- a/crates/vm/src/stdlib/mod.rs
+++ b/crates/vm/src/stdlib/mod.rs
@@ -1,66 +1,78 @@
 mod _abc;
 #[cfg(feature = "ast")]
-pub(crate) mod ast;
+pub(crate) mod _ast;
+mod _codecs;
+mod _collections;
+mod _functools;
+mod _imp;
+pub mod _io;
+mod _operator;
+mod _sre;
+mod _stat;
+mod _string;
+#[cfg(feature = "compiler")]
+mod _symtable;
+mod _sysconfig;
+mod _sysconfigdata;
+mod _types;
+pub mod _typing;
+pub mod _warnings;
+mod _weakref;
 pub mod atexit;
 pub mod builtins;
-mod codecs;
-mod collections;
 pub mod errno;
-mod functools;
-mod imp;
-pub mod io;
+mod gc;
 mod itertools;
 mod marshal;
-mod operator;
-// TODO: maybe make this an extension module, if we ever get those
-// mod re;
-mod sre;
-mod stat;
-mod string;
-#[cfg(feature = "compiler")]
-mod symtable;
-mod sysconfig;
-mod sysconfigdata;
-#[cfg(feature = "threading")]
-pub mod thread;
 pub mod time;
 mod typevar;
-pub mod typing;
-pub mod warnings;
-mod weakref;
 
-#[cfg(any(not(target_arch = "wasm32"), target_os = "wasi"))]
+#[cfg(feature = "host_env")]
 #[macro_use]
 pub mod os;
-#[cfg(windows)]
+#[cfg(all(feature = "host_env", windows))]
 pub mod nt;
-#[cfg(unix)]
+#[cfg(all(feature = "host_env", unix))]
 pub mod posix;
-#[cfg(any(not(target_arch = "wasm32"), target_os = "wasi"))]
-#[cfg(not(any(unix, windows)))]
+#[cfg(all(feature = "host_env", not(any(unix, windows))))]
 #[path = "posix_compat.rs"]
 pub mod posix;
 
 #[cfg(all(
-    any(target_os = "linux", target_os = "macos", target_os = "windows"),
+    feature = "host_env",
+    any(
+        target_os = "linux",
+        target_os = "macos",
+        target_os = "windows",
+        target_os = "android"
+    ),
     not(any(target_env = "musl", target_env = "sgx"))
 ))]
-mod ctypes;
-#[cfg(windows)]
+mod _ctypes;
+#[cfg(all(feature = "host_env", windows))]
 pub(crate) mod msvcrt;
 
 #[cfg(all(
+    feature = "host_env",
     unix,
     not(any(target_os = "ios", target_os = "wasi", target_os = "redox"))
 ))]
 mod pwd;
 
-pub(crate) mod signal;
+#[cfg(feature = "host_env")]
+pub(crate) mod _signal;
+#[cfg(feature = "threading")]
+pub mod _thread;
+#[cfg(all(feature = "host_env", windows))]
+mod _wmi;
 pub mod sys;
-#[cfg(windows)]
+#[cfg(all(feature = "host_env", windows))]
+#[path = "_winapi.rs"]
 mod winapi;
-#[cfg(windows)]
+#[cfg(all(feature = "host_env", windows))]
 mod winreg;
+#[cfg(all(feature = "host_env", windows))]
+mod winsound;
 
 use crate::{Context, builtins::PyModuleDef};
 
@@ -72,56 +84,67 @@ use crate::{Context, builtins::PyModuleDef};
 pub fn builtin_module_defs(ctx: &Context) -> Vec<&'static PyModuleDef> {
     vec![
         _abc::module_def(ctx),
+        _types::module_def(ctx),
         #[cfg(feature = "ast")]
-        ast::module_def(ctx),
+        _ast::module_def(ctx),
         atexit::module_def(ctx),
-        codecs::module_def(ctx),
-        collections::module_def(ctx),
+        _codecs::module_def(ctx),
+        _collections::module_def(ctx),
         #[cfg(all(
-            any(target_os = "linux", target_os = "macos", target_os = "windows"),
+            feature = "host_env",
+            any(
+                target_os = "linux",
+                target_os = "macos",
+                target_os = "windows",
+                target_os = "android"
+            ),
             not(any(target_env = "musl", target_env = "sgx"))
         ))]
-        ctypes::module_def(ctx),
+        _ctypes::module_def(ctx),
         errno::module_def(ctx),
-        functools::module_def(ctx),
-        imp::module_def(ctx),
-        io::module_def(ctx),
+        _functools::module_def(ctx),
+        gc::module_def(ctx),
+        _imp::module_def(ctx),
+        _io::module_def(ctx),
         itertools::module_def(ctx),
         marshal::module_def(ctx),
-        #[cfg(windows)]
+        #[cfg(all(feature = "host_env", windows))]
         msvcrt::module_def(ctx),
-        #[cfg(windows)]
+        #[cfg(all(feature = "host_env", windows))]
         nt::module_def(ctx),
-        operator::module_def(ctx),
-        #[cfg(any(unix, target_os = "wasi"))]
+        _operator::module_def(ctx),
+        #[cfg(all(feature = "host_env", any(unix, target_os = "wasi")))]
         posix::module_def(ctx),
-        #[cfg(all(
-            any(not(target_arch = "wasm32"), target_os = "wasi"),
-            not(any(unix, windows))
-        ))]
+        #[cfg(all(feature = "host_env", not(any(unix, windows, target_os = "wasi"))))]
         posix::module_def(ctx),
         #[cfg(all(
+            feature = "host_env",
             unix,
             not(any(target_os = "ios", target_os = "wasi", target_os = "redox"))
         ))]
         pwd::module_def(ctx),
-        signal::module_def(ctx),
-        sre::module_def(ctx),
-        stat::module_def(ctx),
-        string::module_def(ctx),
+        #[cfg(feature = "host_env")]
+        _signal::module_def(ctx),
+        _sre::module_def(ctx),
+        _stat::module_def(ctx),
+        _string::module_def(ctx),
         #[cfg(feature = "compiler")]
-        symtable::module_def(ctx),
-        sysconfigdata::module_def(ctx),
-        sysconfig::module_def(ctx),
+        _symtable::module_def(ctx),
+        _sysconfigdata::module_def(ctx),
+        _sysconfig::module_def(ctx),
         #[cfg(feature = "threading")]
-        thread::module_def(ctx),
+        _thread::module_def(ctx),
         time::module_def(ctx),
-        typing::module_def(ctx),
-        warnings::module_def(ctx),
-        weakref::module_def(ctx),
-        #[cfg(windows)]
+        _typing::module_def(ctx),
+        _warnings::module_def(ctx),
+        _weakref::module_def(ctx),
+        #[cfg(all(feature = "host_env", windows))]
         winapi::module_def(ctx),
-        #[cfg(windows)]
+        #[cfg(all(feature = "host_env", windows))]
         winreg::module_def(ctx),
+        #[cfg(all(feature = "host_env", windows))]
+        winsound::module_def(ctx),
+        #[cfg(all(feature = "host_env", windows))]
+        _wmi::module_def(ctx),
     ]
 }
diff --git a/crates/vm/src/stdlib/msvcrt.rs b/crates/vm/src/stdlib/msvcrt.rs
index 9986db3ff8c..93364ea3596 100644
--- a/crates/vm/src/stdlib/msvcrt.rs
+++ b/crates/vm/src/stdlib/msvcrt.rs
@@ -58,7 +58,7 @@ mod msvcrt {
     #[pyfunction]
     fn getwch() -> String {
         let c = unsafe { _getwch() };
-        std::char::from_u32(c).unwrap().to_string()
+        char::from_u32(c).unwrap().to_string()
     }
     #[pyfunction]
     fn getche() -> Vec<u8> {
@@ -68,7 +68,7 @@ mod msvcrt {
     #[pyfunction]
     fn getwche() -> String {
         let c = unsafe { _getwche() };
-        std::char::from_u32(c).unwrap().to_string()
+        char::from_u32(c).unwrap().to_string()
     }
     #[pyfunction]
     fn putch(b: PyRef<PyBytes>, vm: &VirtualMachine) -> PyResult<()> {
@@ -82,7 +82,7 @@ mod msvcrt {
     #[pyfunction]
     fn putwch(s: PyStrRef, vm: &VirtualMachine) -> PyResult<()> {
         let c = s
-            .as_str()
+            .expect_str()
             .chars()
             .exactly_one()
             .map_err(|_| vm.new_type_error("putch() argument must be a string of length 1"))?;
@@ -107,7 +107,7 @@ mod msvcrt {
     #[pyfunction]
     fn ungetwch(s: PyStrRef, vm: &VirtualMachine) -> PyResult<()> {
         let c =
-            s.as_str().chars().exactly_one().map_err(|_| {
+            s.expect_str().chars().exactly_one().map_err(|_| {
                 vm.new_type_error("ungetwch() argument must be a string of length 1")
             })?;
         let ret = unsafe { suppress_iph!(_ungetwch(c as u32)) };
diff --git a/crates/vm/src/stdlib/nt.rs b/crates/vm/src/stdlib/nt.rs
index c8c699fb3fa..5dd4cf4f001 100644
--- a/crates/vm/src/stdlib/nt.rs
+++ b/crates/vm/src/stdlib/nt.rs
@@ -7,18 +7,21 @@ pub use module::raw_set_handle_inheritable;
 pub(crate) mod module {
     use crate::{
         Py, PyResult, TryFromObject, VirtualMachine,
-        builtins::{PyBaseExceptionRef, PyDictRef, PyListRef, PyStrRef, PyTupleRef},
+        builtins::{
+            PyBaseExceptionRef, PyBytes, PyDictRef, PyListRef, PyStr, PyStrRef, PyTupleRef,
+        },
         common::{crt_fd, suppress_iph, windows::ToWideString},
         convert::ToPyException,
         exceptions::OSErrorBuilder,
-        function::{Either, OptionalArg},
+        function::{ArgMapping, Either, OptionalArg},
         ospath::{OsPath, OsPathOrFd},
         stdlib::os::{_os, DirFd, SupportFunc, TargetIsDirectory},
     };
-
+    use core::mem::MaybeUninit;
     use libc::intptr_t;
+    use rustpython_common::wtf8::Wtf8Buf;
     use std::os::windows::io::AsRawHandle;
-    use std::{env, fs, io, mem::MaybeUninit, os::windows::ffi::OsStringExt};
+    use std::{env, io, os::windows::ffi::OsStringExt};
     use windows_sys::Win32::{
         Foundation::{self, INVALID_HANDLE_VALUE},
         Storage::FileSystem,
@@ -99,7 +102,7 @@ pub(crate) mod module {
 
             // 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 mut find_data: WIN32_FIND_DATAW = unsafe { core::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
@@ -124,8 +127,12 @@ pub(crate) mod module {
 
     #[pyfunction]
     pub(super) fn _supports_virtual_terminal() -> PyResult<bool> {
-        // TODO: implement this
-        Ok(true)
+        let mut mode = 0;
+        let handle = unsafe { Console::GetStdHandle(Console::STD_ERROR_HANDLE) };
+        if unsafe { Console::GetConsoleMode(handle, &mut mode) } == 0 {
+            return Ok(false);
+        }
+        Ok(mode & Console::ENABLE_VIRTUAL_TERMINAL_PROCESSING != 0)
     }
 
     #[derive(FromArgs)]
@@ -140,20 +147,78 @@ pub(crate) mod module {
 
     #[pyfunction]
     pub(super) fn symlink(args: SymlinkArgs<'_>, vm: &VirtualMachine) -> PyResult<()> {
-        use std::os::windows::fs as win_fs;
-        let dir = args.target_is_directory.target_is_directory
-            || args
-                .dst
-                .as_path()
-                .parent()
-                .and_then(|dst_parent| dst_parent.join(&args.src).symlink_metadata().ok())
-                .is_some_and(|meta| meta.is_dir());
-        let res = if dir {
-            win_fs::symlink_dir(args.src.path, args.dst.path)
-        } else {
-            win_fs::symlink_file(args.src.path, args.dst.path)
+        use crate::exceptions::ToOSErrorBuilder;
+        use core::sync::atomic::{AtomicBool, Ordering};
+        use windows_sys::Win32::Storage::FileSystem::WIN32_FILE_ATTRIBUTE_DATA;
+        use windows_sys::Win32::Storage::FileSystem::{
+            CreateSymbolicLinkW, FILE_ATTRIBUTE_DIRECTORY, GetFileAttributesExW,
+            SYMBOLIC_LINK_FLAG_ALLOW_UNPRIVILEGED_CREATE, SYMBOLIC_LINK_FLAG_DIRECTORY,
         };
-        res.map_err(|err| err.to_pyexception(vm))
+
+        static HAS_UNPRIVILEGED_FLAG: AtomicBool = AtomicBool::new(true);
+
+        fn check_dir(src: &OsPath, dst: &OsPath) -> bool {
+            use windows_sys::Win32::Storage::FileSystem::GetFileExInfoStandard;
+
+            let dst_parent = dst.as_path().parent();
+            let Some(dst_parent) = dst_parent else {
+                return false;
+            };
+            let resolved = if src.as_path().is_absolute() {
+                src.as_path().to_path_buf()
+            } else {
+                dst_parent.join(src.as_path())
+            };
+            let wide = match widestring::WideCString::from_os_str(&resolved) {
+                Ok(wide) => wide,
+                Err(_) => return false,
+            };
+            let mut info: WIN32_FILE_ATTRIBUTE_DATA = unsafe { core::mem::zeroed() };
+            let ok = unsafe {
+                GetFileAttributesExW(
+                    wide.as_ptr(),
+                    GetFileExInfoStandard,
+                    &mut info as *mut _ as *mut _,
+                )
+            };
+            ok != 0 && (info.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) != 0
+        }
+
+        let mut flags = 0u32;
+        if HAS_UNPRIVILEGED_FLAG.load(Ordering::Relaxed) {
+            flags |= SYMBOLIC_LINK_FLAG_ALLOW_UNPRIVILEGED_CREATE;
+        }
+        if args.target_is_directory.target_is_directory || check_dir(&args.src, &args.dst) {
+            flags |= SYMBOLIC_LINK_FLAG_DIRECTORY;
+        }
+
+        let src = args.src.to_wide_cstring(vm)?;
+        let dst = args.dst.to_wide_cstring(vm)?;
+
+        let mut result = unsafe { CreateSymbolicLinkW(dst.as_ptr(), src.as_ptr(), flags) };
+        if !result
+            && HAS_UNPRIVILEGED_FLAG.load(Ordering::Relaxed)
+            && unsafe { Foundation::GetLastError() } == Foundation::ERROR_INVALID_PARAMETER
+        {
+            let flags = flags & !SYMBOLIC_LINK_FLAG_ALLOW_UNPRIVILEGED_CREATE;
+            result = unsafe { CreateSymbolicLinkW(dst.as_ptr(), src.as_ptr(), flags) };
+            if result
+                || unsafe { Foundation::GetLastError() } != Foundation::ERROR_INVALID_PARAMETER
+            {
+                HAS_UNPRIVILEGED_FLAG.store(false, Ordering::Relaxed);
+            }
+        }
+
+        if !result {
+            let err = io::Error::last_os_error();
+            let builder = err.to_os_error_builder(vm);
+            let builder = builder
+                .filename(args.src.filename(vm))
+                .filename2(args.dst.filename(vm));
+            return Err(builder.build(vm).upcast());
+        }
+
+        Ok(())
     }
 
     #[pyfunction]
@@ -173,8 +238,19 @@ pub(crate) mod module {
         for (key, value) in env::vars() {
             // Skip hidden Windows environment variables (e.g., =C:, =D:, =ExitCode)
             // These are internal cmd.exe bookkeeping variables that store per-drive
-            // current directories. They cannot be modified via _wputenv() and should
-            // not be exposed to Python code.
+            // current directories and cannot be reliably modified via _wputenv().
+            if key.starts_with('=') {
+                continue;
+            }
+            environ.set_item(&key, vm.new_pyobj(value), vm).unwrap();
+        }
+        environ
+    }
+
+    #[pyfunction]
+    fn _create_environ(vm: &VirtualMachine) -> PyDictRef {
+        let environ = vm.ctx.new_dict();
+        for (key, value) in env::vars() {
             if key.starts_with('=') {
                 continue;
             }
@@ -197,25 +273,20 @@ pub(crate) mod module {
 
     const S_IWRITE: u32 = 128;
 
-    fn fchmod_impl(fd: i32, mode: u32, vm: &VirtualMachine) -> PyResult<()> {
+    fn win32_hchmod(handle: Foundation::HANDLE, 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 mut info: FILE_BASIC_INFO = unsafe { core::mem::zeroed() };
         let ret = unsafe {
             GetFileInformationByHandleEx(
-                hfile,
+                handle,
                 FileBasicInfo,
                 &mut info as *mut _ as *mut _,
-                std::mem::size_of::<FILE_BASIC_INFO>() as u32,
+                core::mem::size_of::<FILE_BASIC_INFO>() as u32,
             )
         };
         if ret == 0 {
@@ -232,10 +303,10 @@ pub(crate) mod module {
         // Set the new attributes
         let ret = unsafe {
             SetFileInformationByHandle(
-                hfile,
+                handle,
                 FileBasicInfo,
                 &info as *const _ as *const _,
-                std::mem::size_of::<FILE_BASIC_INFO>() as u32,
+                core::mem::size_of::<FILE_BASIC_INFO>() as u32,
             )
         };
         if ret == 0 {
@@ -245,6 +316,36 @@ pub(crate) mod module {
         Ok(())
     }
 
+    fn fchmod_impl(fd: i32, mode: u32, vm: &VirtualMachine) -> PyResult<()> {
+        // 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;
+        win32_hchmod(hfile, mode, vm)
+    }
+
+    fn win32_lchmod(path: &OsPath, mode: u32, vm: &VirtualMachine) -> PyResult<()> {
+        use windows_sys::Win32::Storage::FileSystem::{GetFileAttributesW, SetFileAttributesW};
+
+        let wide = path.to_wide_cstring(vm)?;
+        let attr = unsafe { GetFileAttributesW(wide.as_ptr()) };
+        if attr == FileSystem::INVALID_FILE_ATTRIBUTES {
+            let err = io::Error::last_os_error();
+            return Err(OSErrorBuilder::with_filename(&err, path.clone(), vm));
+        }
+        let new_attr = if mode & S_IWRITE != 0 {
+            attr & !FileSystem::FILE_ATTRIBUTE_READONLY
+        } else {
+            attr | FileSystem::FILE_ATTRIBUTE_READONLY
+        };
+        let ret = unsafe { SetFileAttributesW(wide.as_ptr(), new_attr) };
+        if ret == 0 {
+            let err = io::Error::last_os_error();
+            return Err(OSErrorBuilder::with_filename(&err, path.clone(), vm));
+        }
+        Ok(())
+    }
+
     #[pyfunction]
     fn fchmod(fd: i32, mode: u32, vm: &VirtualMachine) -> PyResult<()> {
         fchmod_impl(fd, mode, vm)
@@ -263,9 +364,9 @@ pub(crate) mod module {
         // 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 Err(
+                    vm.new_value_error("chmod: follow_symlinks is not supported with fd argument")
+                );
             }
             return fchmod_impl(fd.as_raw(), mode, vm);
         }
@@ -274,45 +375,36 @@ pub(crate) mod module {
             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
-        // - Explicitly False: raise NotImplementedError (Windows can't change symlink permissions)
-        let actual_path: std::borrow::Cow<'_, std::path::Path> = match follow_symlinks.into_option()
-        {
-            None => {
-                // Default behavior: don't resolve symlinks, operate on path directly
-                std::borrow::Cow::Borrowed(path.as_ref())
-            }
-            Some(true) => {
-                // Explicitly follow symlinks: resolve the path first
-                match fs::canonicalize(&path) {
-                    Ok(p) => std::borrow::Cow::Owned(p),
-                    Err(_) => std::borrow::Cow::Borrowed(path.as_ref()),
-                }
-            }
-            Some(false) => {
-                // follow_symlinks=False on Windows - not supported for symlinks
-                // Check if path is a symlink
-                if let Ok(meta) = fs::symlink_metadata(&path)
-                    && meta.file_type().is_symlink()
-                {
-                    return Err(vm.new_not_implemented_error(
-                        "chmod: follow_symlinks=False is not supported on Windows for symlinks"
-                            .to_owned(),
-                    ));
-                }
-                std::borrow::Cow::Borrowed(path.as_ref())
-            }
-        };
+        let follow_symlinks = follow_symlinks.into_option().unwrap_or(false);
 
-        // Use symlink_metadata to avoid following dangling symlinks
-        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| OSErrorBuilder::with_filename(&err, path, vm))
+        if follow_symlinks {
+            use windows_sys::Win32::Storage::FileSystem::{
+                CreateFileW, FILE_FLAG_BACKUP_SEMANTICS, FILE_READ_ATTRIBUTES, FILE_SHARE_DELETE,
+                FILE_SHARE_READ, FILE_SHARE_WRITE, FILE_WRITE_ATTRIBUTES, OPEN_EXISTING,
+            };
+
+            let wide = path.to_wide_cstring(vm)?;
+            let handle = unsafe {
+                CreateFileW(
+                    wide.as_ptr(),
+                    FILE_READ_ATTRIBUTES | FILE_WRITE_ATTRIBUTES,
+                    FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
+                    core::ptr::null(),
+                    OPEN_EXISTING,
+                    FILE_FLAG_BACKUP_SEMANTICS,
+                    core::ptr::null_mut(),
+                )
+            };
+            if handle == INVALID_HANDLE_VALUE {
+                let err = io::Error::last_os_error();
+                return Err(OSErrorBuilder::with_filename(&err, path, vm));
+            }
+            let result = win32_hchmod(handle, mode, vm);
+            unsafe { Foundation::CloseHandle(handle) };
+            result
+        } else {
+            win32_lchmod(&path, mode, vm)
+        }
     }
 
     /// Get the real file name (with correct case) without accessing the file.
@@ -326,14 +418,12 @@ pub(crate) mod module {
         };
 
         let wide_path = path.as_ref().to_wide_with_nul();
-        let mut find_data: WIN32_FIND_DATAW = unsafe { std::mem::zeroed() };
+        let mut find_data: WIN32_FIND_DATAW = unsafe { core::mem::zeroed() };
 
         let handle = unsafe { FindFirstFileW(wide_path.as_ptr(), &mut find_data) };
         if handle == INVALID_HANDLE_VALUE {
-            return Err(vm.new_os_error(format!(
-                "FindFirstFileW failed for path: {}",
-                path.as_ref().display()
-            )));
+            let err = io::Error::last_os_error();
+            return Err(OSErrorBuilder::with_filename(&err, path, vm));
         }
 
         unsafe { FindClose(handle) };
@@ -370,6 +460,8 @@ pub(crate) mod module {
     const PY_IFDIR: u32 = 2; // Directory
     const PY_IFLNK: u32 = 4; // Symlink
     const PY_IFMNT: u32 = 8; // Mount point (junction)
+    const PY_IFLRP: u32 = 16; // Link Reparse Point (name-surrogate, symlink, junction)
+    const PY_IFRRP: u32 = 32; // Regular Reparse Point
 
     /// _testInfo - determine file type based on attributes and reparse tag
     fn _test_info(attributes: u32, reparse_tag: u32, disk_device: bool, tested_type: u32) -> bool {
@@ -394,10 +486,38 @@ pub(crate) mod module {
                 (attributes & FILE_ATTRIBUTE_REPARSE_POINT) != 0
                     && reparse_tag == IO_REPARSE_TAG_MOUNT_POINT
             }
+            PY_IFLRP => {
+                (attributes & FILE_ATTRIBUTE_REPARSE_POINT) != 0
+                    && is_reparse_tag_name_surrogate(reparse_tag)
+            }
+            PY_IFRRP => {
+                (attributes & FILE_ATTRIBUTE_REPARSE_POINT) != 0
+                    && reparse_tag != 0
+                    && !is_reparse_tag_name_surrogate(reparse_tag)
+            }
             _ => false,
         }
     }
 
+    fn is_reparse_tag_name_surrogate(tag: u32) -> bool {
+        (tag & 0x20000000) != 0
+    }
+
+    fn file_info_error_is_trustworthy(error: u32) -> bool {
+        use windows_sys::Win32::Foundation;
+        matches!(
+            error,
+            Foundation::ERROR_FILE_NOT_FOUND
+                | Foundation::ERROR_PATH_NOT_FOUND
+                | Foundation::ERROR_NOT_READY
+                | Foundation::ERROR_BAD_NET_NAME
+                | Foundation::ERROR_BAD_NETPATH
+                | Foundation::ERROR_BAD_PATHNAME
+                | Foundation::ERROR_INVALID_NAME
+                | Foundation::ERROR_FILENAME_EXCED_RANGE
+        )
+    }
+
     /// _testFileTypeByHandle - test file type using an open handle
     fn _test_file_type_by_handle(
         handle: windows_sys::Win32::Foundation::HANDLE,
@@ -417,13 +537,13 @@ pub(crate) mod module {
 
         if tested_type != PY_IFREG && tested_type != PY_IFDIR {
             // For symlinks/junctions, need FileAttributeTagInfo to get reparse tag
-            let mut info: FILE_ATTRIBUTE_TAG_INFO = unsafe { std::mem::zeroed() };
+            let mut info: FILE_ATTRIBUTE_TAG_INFO = unsafe { core::mem::zeroed() };
             let ret = unsafe {
                 GetFileInformationByHandleEx(
                     handle,
                     FileAttributeTagInfoClass,
                     &mut info as *mut _ as *mut _,
-                    std::mem::size_of::<FILE_ATTRIBUTE_TAG_INFO>() as u32,
+                    core::mem::size_of::<FILE_ATTRIBUTE_TAG_INFO>() as u32,
                 )
             };
             if ret == 0 {
@@ -437,13 +557,13 @@ pub(crate) mod module {
             )
         } else {
             // For regular files/directories, FileBasicInfo is sufficient
-            let mut info: FILE_BASIC_INFO = unsafe { std::mem::zeroed() };
+            let mut info: FILE_BASIC_INFO = unsafe { core::mem::zeroed() };
             let ret = unsafe {
                 GetFileInformationByHandleEx(
                     handle,
                     FileBasicInfo,
                     &mut info as *mut _ as *mut _,
-                    std::mem::size_of::<FILE_BASIC_INFO>() as u32,
+                    core::mem::size_of::<FILE_BASIC_INFO>() as u32,
                 )
             };
             if ret == 0 {
@@ -455,140 +575,183 @@ pub(crate) mod module {
 
     /// _testFileTypeByName - test file type by path name
     fn _test_file_type_by_name(path: &std::path::Path, tested_type: u32) -> bool {
+        use crate::common::fileutils::windows::{
+            FILE_INFO_BY_NAME_CLASS, get_file_information_by_name,
+        };
         use crate::common::windows::ToWideString;
         use windows_sys::Win32::Foundation::{CloseHandle, INVALID_HANDLE_VALUE};
         use windows_sys::Win32::Storage::FileSystem::{
-            CreateFileW, FILE_FLAG_BACKUP_SEMANTICS, FILE_FLAG_OPEN_REPARSE_POINT,
-            FILE_READ_ATTRIBUTES, FILE_SHARE_DELETE, FILE_SHARE_READ, FILE_SHARE_WRITE,
-            OPEN_EXISTING,
+            CreateFileW, FILE_ATTRIBUTE_REPARSE_POINT, FILE_FLAG_BACKUP_SEMANTICS,
+            FILE_FLAG_OPEN_REPARSE_POINT, FILE_READ_ATTRIBUTES, OPEN_EXISTING,
         };
-
-        // For islink/isjunction, use symlink_metadata to check reparse points
-        if (tested_type == PY_IFLNK || tested_type == PY_IFMNT)
-            && let Ok(meta) = path.symlink_metadata()
-        {
-            use std::os::windows::fs::MetadataExt;
-            let attrs = meta.file_attributes();
-            use windows_sys::Win32::Storage::FileSystem::FILE_ATTRIBUTE_REPARSE_POINT;
-            if (attrs & FILE_ATTRIBUTE_REPARSE_POINT) == 0 {
-                return false;
+        use windows_sys::Win32::Storage::FileSystem::{FILE_DEVICE_CD_ROM, FILE_DEVICE_DISK};
+        use windows_sys::Win32::System::Ioctl::FILE_DEVICE_VIRTUAL_DISK;
+
+        match get_file_information_by_name(
+            path.as_os_str(),
+            FILE_INFO_BY_NAME_CLASS::FileStatBasicByNameInfo,
+        ) {
+            Ok(info) => {
+                let disk_device = matches!(
+                    info.DeviceType,
+                    FILE_DEVICE_DISK | FILE_DEVICE_VIRTUAL_DISK | FILE_DEVICE_CD_ROM
+                );
+                let result = _test_info(
+                    info.FileAttributes,
+                    info.ReparseTag,
+                    disk_device,
+                    tested_type,
+                );
+                if !result
+                    || (tested_type != PY_IFREG && tested_type != PY_IFDIR)
+                    || (info.FileAttributes & FILE_ATTRIBUTE_REPARSE_POINT) == 0
+                {
+                    return result;
+                }
+            }
+            Err(err) => {
+                if let Some(code) = err.raw_os_error()
+                    && file_info_error_is_trustworthy(code as u32)
+                {
+                    return false;
+                }
             }
-            // Need to check reparse tag, fall through to CreateFileW
         }
 
         let wide_path = path.to_wide_with_nul();
 
-        // For symlinks/junctions, add FILE_FLAG_OPEN_REPARSE_POINT to not follow
         let mut flags = FILE_FLAG_BACKUP_SEMANTICS;
         if tested_type != PY_IFREG && tested_type != PY_IFDIR {
             flags |= FILE_FLAG_OPEN_REPARSE_POINT;
         }
-
-        // Use sharing flags to avoid access denied errors
         let handle = unsafe {
             CreateFileW(
                 wide_path.as_ptr(),
                 FILE_READ_ATTRIBUTES,
-                FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
+                0,
                 core::ptr::null(),
                 OPEN_EXISTING,
                 flags,
-                std::ptr::null_mut(),
+                core::ptr::null_mut(),
             )
         };
 
-        if handle == INVALID_HANDLE_VALUE {
-            // Fallback: try using Rust's metadata for isdir/isfile
-            if tested_type == PY_IFDIR {
-                return path.metadata().is_ok_and(|m| m.is_dir());
-            } else if tested_type == PY_IFREG {
-                return path.metadata().is_ok_and(|m| m.is_file());
-            }
-            // For symlinks/junctions, try without FILE_FLAG_BACKUP_SEMANTICS
-            let handle = unsafe {
-                CreateFileW(
-                    wide_path.as_ptr(),
-                    FILE_READ_ATTRIBUTES,
-                    FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
-                    core::ptr::null(),
-                    OPEN_EXISTING,
-                    FILE_FLAG_OPEN_REPARSE_POINT,
-                    std::ptr::null_mut(),
-                )
-            };
-            if handle == INVALID_HANDLE_VALUE {
-                return false;
-            }
-            let result = _test_file_type_by_handle(handle, tested_type, true);
+        if handle != INVALID_HANDLE_VALUE {
+            let result = _test_file_type_by_handle(handle, tested_type, false);
             unsafe { CloseHandle(handle) };
             return result;
         }
 
-        let result = _test_file_type_by_handle(handle, tested_type, true);
-        unsafe { CloseHandle(handle) };
-        result
+        match unsafe { windows_sys::Win32::Foundation::GetLastError() } {
+            windows_sys::Win32::Foundation::ERROR_ACCESS_DENIED
+            | windows_sys::Win32::Foundation::ERROR_SHARING_VIOLATION
+            | windows_sys::Win32::Foundation::ERROR_CANT_ACCESS_FILE
+            | windows_sys::Win32::Foundation::ERROR_INVALID_PARAMETER => {
+                let stat = if tested_type == PY_IFREG || tested_type == PY_IFDIR {
+                    crate::windows::win32_xstat(path.as_os_str(), true)
+                } else {
+                    crate::windows::win32_xstat(path.as_os_str(), false)
+                };
+                if let Ok(st) = stat {
+                    let disk_device = (st.st_mode & libc::S_IFREG as u16) != 0;
+                    return _test_info(
+                        st.st_file_attributes,
+                        st.st_reparse_tag,
+                        disk_device,
+                        tested_type,
+                    );
+                }
+            }
+            _ => {}
+        }
+
+        false
     }
 
     /// _testFileExistsByName - test if path exists
     fn _test_file_exists_by_name(path: &std::path::Path, follow_links: bool) -> bool {
+        use crate::common::fileutils::windows::{
+            FILE_INFO_BY_NAME_CLASS, get_file_information_by_name,
+        };
         use crate::common::windows::ToWideString;
-        use windows_sys::Win32::Foundation::{CloseHandle, GENERIC_READ, INVALID_HANDLE_VALUE};
+        use windows_sys::Win32::Foundation::{CloseHandle, INVALID_HANDLE_VALUE};
         use windows_sys::Win32::Storage::FileSystem::{
-            CreateFileW, FILE_FLAG_BACKUP_SEMANTICS, FILE_FLAG_OPEN_REPARSE_POINT,
-            FILE_READ_ATTRIBUTES, FILE_SHARE_DELETE, FILE_SHARE_READ, FILE_SHARE_WRITE,
-            OPEN_EXISTING,
+            CreateFileW, FILE_ATTRIBUTE_REPARSE_POINT, FILE_FLAG_BACKUP_SEMANTICS,
+            FILE_FLAG_OPEN_REPARSE_POINT, FILE_READ_ATTRIBUTES, OPEN_EXISTING,
         };
 
-        // First try standard Rust exists/symlink_metadata (handles \\?\ paths well)
-        if follow_links {
-            if path.exists() {
-                return true;
+        match get_file_information_by_name(
+            path.as_os_str(),
+            FILE_INFO_BY_NAME_CLASS::FileStatBasicByNameInfo,
+        ) {
+            Ok(info) => {
+                if (info.FileAttributes & FILE_ATTRIBUTE_REPARSE_POINT) == 0
+                    || (!follow_links && is_reparse_tag_name_surrogate(info.ReparseTag))
+                {
+                    return true;
+                }
+            }
+            Err(err) => {
+                if let Some(code) = err.raw_os_error()
+                    && file_info_error_is_trustworthy(code as u32)
+                {
+                    return false;
+                }
             }
-        } else if path.symlink_metadata().is_ok() {
-            return true;
         }
 
         let wide_path = path.to_wide_with_nul();
-
         let mut flags = FILE_FLAG_BACKUP_SEMANTICS;
         if !follow_links {
             flags |= FILE_FLAG_OPEN_REPARSE_POINT;
         }
-
-        // Fallback: try with FILE_READ_ATTRIBUTES and sharing flags
         let handle = unsafe {
             CreateFileW(
                 wide_path.as_ptr(),
                 FILE_READ_ATTRIBUTES,
-                FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
+                0,
                 core::ptr::null(),
                 OPEN_EXISTING,
                 flags,
-                std::ptr::null_mut(),
+                core::ptr::null_mut(),
             )
         };
-
         if handle != INVALID_HANDLE_VALUE {
+            if follow_links {
+                unsafe { CloseHandle(handle) };
+                return true;
+            }
+            let is_regular_reparse_point = _test_file_type_by_handle(handle, PY_IFRRP, false);
             unsafe { CloseHandle(handle) };
-            return true;
+            if !is_regular_reparse_point {
+                return true;
+            }
+            let handle = unsafe {
+                CreateFileW(
+                    wide_path.as_ptr(),
+                    FILE_READ_ATTRIBUTES,
+                    0,
+                    core::ptr::null(),
+                    OPEN_EXISTING,
+                    FILE_FLAG_BACKUP_SEMANTICS,
+                    core::ptr::null_mut(),
+                )
+            };
+            if handle != INVALID_HANDLE_VALUE {
+                unsafe { CloseHandle(handle) };
+                return true;
+            }
         }
 
-        // Fallback for console devices like \\.\CON
-        let handle = unsafe {
-            CreateFileW(
-                wide_path.as_ptr(),
-                GENERIC_READ,
-                FILE_SHARE_READ | FILE_SHARE_WRITE,
-                core::ptr::null(),
-                OPEN_EXISTING,
-                0,
-                std::ptr::null_mut(),
-            )
-        };
-
-        if handle != INVALID_HANDLE_VALUE {
-            unsafe { CloseHandle(handle) };
-            return true;
+        match unsafe { windows_sys::Win32::Foundation::GetLastError() } {
+            windows_sys::Win32::Foundation::ERROR_ACCESS_DENIED
+            | windows_sys::Win32::Foundation::ERROR_SHARING_VIOLATION
+            | windows_sys::Win32::Foundation::ERROR_CANT_ACCESS_FILE
+            | windows_sys::Win32::Foundation::ERROR_INVALID_PARAMETER => {
+                let stat = crate::windows::win32_xstat(path.as_os_str(), follow_links);
+                return stat.is_ok();
+            }
+            _ => {}
         }
 
         false
@@ -729,7 +892,7 @@ pub(crate) mod module {
                 core::ptr::null(),
                 OPEN_EXISTING,
                 FILE_FLAG_BACKUP_SEMANTICS,
-                std::ptr::null_mut(),
+                core::ptr::null_mut(),
             )
         };
         if handle == INVALID_HANDLE_VALUE {
@@ -748,12 +911,12 @@ pub(crate) mod module {
             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(),
+                &volume_state as *const _ as *const core::ffi::c_void,
+                core::mem::size_of::<FileFsPersistentVolumeInformation>() as u32,
+                &mut volume_state as *mut _ as *mut core::ffi::c_void,
+                core::mem::size_of::<FileFsPersistentVolumeInformation>() as u32,
+                core::ptr::null_mut(),
+                core::ptr::null_mut(),
             )
         };
 
@@ -858,7 +1021,7 @@ pub(crate) mod module {
                     core::ptr::null(),
                     FileSystem::OPEN_EXISTING,
                     0,
-                    std::ptr::null_mut(),
+                    core::ptr::null_mut(),
                 )
             };
             if console_handle == INVALID_HANDLE_VALUE {
@@ -903,16 +1066,14 @@ pub(crate) mod module {
         argv: Either<PyListRef, PyTupleRef>,
         vm: &VirtualMachine,
     ) -> PyResult<intptr_t> {
-        use std::iter::once;
-
-        let make_widestring =
-            |s: &str| widestring::WideCString::from_os_str(s).map_err(|err| err.to_pyexception(vm));
+        use crate::function::FsPath;
+        use core::iter::once;
 
         let path = path.to_wide_cstring(vm)?;
 
         let argv = vm.extract_elements_with(argv.as_ref(), |obj| {
-            let arg = PyStrRef::try_from_object(vm, obj)?;
-            make_widestring(arg.as_str())
+            let fspath = FsPath::try_from_path_like(obj, true, vm)?;
+            fspath.to_wide_cstring(vm)
         })?;
 
         let first = argv
@@ -946,16 +1107,14 @@ pub(crate) mod module {
         env: PyDictRef,
         vm: &VirtualMachine,
     ) -> PyResult<intptr_t> {
-        use std::iter::once;
-
-        let make_widestring =
-            |s: &str| widestring::WideCString::from_os_str(s).map_err(|err| err.to_pyexception(vm));
+        use crate::function::FsPath;
+        use core::iter::once;
 
         let path = path.to_wide_cstring(vm)?;
 
         let argv = vm.extract_elements_with(argv.as_ref(), |obj| {
-            let arg = PyStrRef::try_from_object(vm, obj)?;
-            make_widestring(arg.as_str())
+            let fspath = FsPath::try_from_path_like(obj, true, vm)?;
+            fspath.to_wide_cstring(vm)
         })?;
 
         let first = argv
@@ -975,23 +1134,23 @@ pub(crate) mod module {
         // Build environment strings as "KEY=VALUE\0" wide strings
         let mut env_strings: Vec<widestring::WideCString> = Vec::new();
         for (key, value) in env.into_iter() {
-            let key = PyStrRef::try_from_object(vm, key)?;
-            let value = PyStrRef::try_from_object(vm, value)?;
-            let key_str = key.as_str();
-            let value_str = value.as_str();
-
-            // Validate: no null characters in key or value
-            if key_str.contains('\0') || value_str.contains('\0') {
-                return Err(vm.new_value_error("embedded null character"));
-            }
-            // Validate: no '=' in key (search from index 1 because on Windows
-            // starting '=' is allowed for defining hidden environment variables)
-            if key_str.get(1..).is_some_and(|s| s.contains('=')) {
+            let key = FsPath::try_from_path_like(key, true, vm)?;
+            let value = FsPath::try_from_path_like(value, true, vm)?;
+            let key_str = key.to_string_lossy();
+            let value_str = value.to_string_lossy();
+
+            // Validate: empty key or '=' in key after position 0
+            // (search from index 1 because on Windows starting '=' is allowed
+            // for defining hidden environment variables)
+            if key_str.is_empty() || key_str.get(1..).is_some_and(|s| s.contains('=')) {
                 return Err(vm.new_value_error("illegal environment variable name"));
             }
 
             let env_str = format!("{}={}", key_str, value_str);
-            env_strings.push(make_widestring(&env_str)?);
+            env_strings.push(
+                widestring::WideCString::from_os_str(&*std::ffi::OsString::from(env_str))
+                    .map_err(|err| err.to_pyexception(vm))?,
+            );
         }
 
         let envp: Vec<*const u16> = env_strings
@@ -1022,7 +1181,7 @@ pub(crate) mod module {
         argv: Either<PyListRef, PyTupleRef>,
         vm: &VirtualMachine,
     ) -> PyResult<()> {
-        use std::iter::once;
+        use core::iter::once;
 
         let make_widestring =
             |s: &str| widestring::WideCString::from_os_str(s).map_err(|err| err.to_pyexception(vm));
@@ -1031,7 +1190,7 @@ pub(crate) mod module {
 
         let argv = vm.extract_elements_with(argv.as_ref(), |obj| {
             let arg = PyStrRef::try_from_object(vm, obj)?;
-            make_widestring(arg.as_str())
+            make_widestring(arg.expect_str())
         })?;
 
         let first = argv
@@ -1060,10 +1219,10 @@ pub(crate) mod module {
     fn execve(
         path: OsPath,
         argv: Either<PyListRef, PyTupleRef>,
-        env: PyDictRef,
+        env: ArgMapping,
         vm: &VirtualMachine,
     ) -> PyResult<()> {
-        use std::iter::once;
+        use core::iter::once;
 
         let make_widestring =
             |s: &str| widestring::WideCString::from_os_str(s).map_err(|err| err.to_pyexception(vm));
@@ -1072,7 +1231,7 @@ pub(crate) mod module {
 
         let argv = vm.extract_elements_with(argv.as_ref(), |obj| {
             let arg = PyStrRef::try_from_object(vm, obj)?;
-            make_widestring(arg.as_str())
+            make_widestring(arg.expect_str())
         })?;
 
         let first = argv
@@ -1089,21 +1248,23 @@ pub(crate) mod module {
             .chain(once(core::ptr::null()))
             .collect();
 
+        let env = crate::stdlib::os::envobj_to_dict(env, vm)?;
         // Build environment strings as "KEY=VALUE\0" wide strings
         let mut env_strings: Vec<widestring::WideCString> = Vec::new();
         for (key, value) in env.into_iter() {
             let key = PyStrRef::try_from_object(vm, key)?;
             let value = PyStrRef::try_from_object(vm, value)?;
-            let key_str = key.as_str();
-            let value_str = value.as_str();
+            let key_str = key.expect_str();
+            let value_str = value.expect_str();
 
             // Validate: no null characters in key or value
             if key_str.contains('\0') || value_str.contains('\0') {
                 return Err(vm.new_value_error("embedded null character"));
             }
-            // Validate: no '=' in key (search from index 1 because on Windows
-            // starting '=' is allowed for defining hidden environment variables)
-            if key_str.get(1..).is_some_and(|s| s.contains('=')) {
+            // Validate: empty key or '=' in key after position 0
+            // (search from index 1 because on Windows starting '=' is allowed
+            // for defining hidden environment variables)
+            if key_str.is_empty() || key_str.get(1..).is_some_and(|s| s.contains('=')) {
                 return Err(vm.new_value_error("illegal environment variable name"));
             }
 
@@ -1128,11 +1289,52 @@ pub(crate) mod module {
 
     #[pyfunction]
     fn _getfinalpathname(path: OsPath, vm: &VirtualMachine) -> PyResult {
-        let real = path
-            .as_ref()
-            .canonicalize()
-            .map_err(|e| e.to_pyexception(vm))?;
-        Ok(path.mode().process_path(real, vm))
+        use windows_sys::Win32::Storage::FileSystem::{
+            CreateFileW, FILE_FLAG_BACKUP_SEMANTICS, GetFinalPathNameByHandleW, OPEN_EXISTING,
+            VOLUME_NAME_DOS,
+        };
+
+        let wide = path.to_wide_cstring(vm)?;
+        let handle = unsafe {
+            CreateFileW(
+                wide.as_ptr(),
+                0,
+                0,
+                core::ptr::null(),
+                OPEN_EXISTING,
+                FILE_FLAG_BACKUP_SEMANTICS,
+                core::ptr::null_mut(),
+            )
+        };
+        if handle == INVALID_HANDLE_VALUE {
+            let err = io::Error::last_os_error();
+            return Err(OSErrorBuilder::with_filename(&err, path, vm));
+        }
+
+        let mut buffer: Vec<u16> = vec![0; Foundation::MAX_PATH as usize];
+        let result = loop {
+            let ret = unsafe {
+                GetFinalPathNameByHandleW(
+                    handle,
+                    buffer.as_mut_ptr(),
+                    buffer.len() as u32,
+                    VOLUME_NAME_DOS,
+                )
+            };
+            if ret == 0 {
+                let err = io::Error::last_os_error();
+                let _ = unsafe { Foundation::CloseHandle(handle) };
+                return Err(OSErrorBuilder::with_filename(&err, path, vm));
+            }
+            if (ret as usize) < buffer.len() {
+                let final_path = std::ffi::OsString::from_wide(&buffer[..ret as usize]);
+                break Ok(path.mode().process_path(final_path, vm));
+            }
+            buffer.resize(ret as usize, 0);
+        };
+
+        unsafe { Foundation::CloseHandle(handle) };
+        result
     }
 
     #[pyfunction]
@@ -1144,11 +1346,12 @@ pub(crate) mod module {
                 wpath.as_ptr(),
                 buffer.len() as _,
                 buffer.as_mut_ptr(),
-                std::ptr::null_mut(),
+                core::ptr::null_mut(),
             )
         };
         if ret == 0 {
-            return Err(vm.new_last_os_error());
+            let err = io::Error::last_os_error();
+            return Err(OSErrorBuilder::with_filename(&err, path.clone(), vm));
         }
         if ret as usize > buffer.len() {
             buffer.resize(ret as usize, 0);
@@ -1157,11 +1360,12 @@ pub(crate) mod module {
                     wpath.as_ptr(),
                     buffer.len() as _,
                     buffer.as_mut_ptr(),
-                    std::ptr::null_mut(),
+                    core::ptr::null_mut(),
                 )
             };
             if ret == 0 {
-                return Err(vm.new_last_os_error());
+                let err = io::Error::last_os_error();
+                return Err(OSErrorBuilder::with_filename(&err, path.clone(), vm));
             }
         }
         let buffer = widestring::WideCString::from_vec_truncate(buffer);
@@ -1171,13 +1375,17 @@ pub(crate) mod module {
     #[pyfunction]
     fn _getvolumepathname(path: OsPath, vm: &VirtualMachine) -> PyResult {
         let wide = path.to_wide_cstring(vm)?;
-        let buflen = std::cmp::max(wide.len(), Foundation::MAX_PATH as usize);
+        let buflen = core::cmp::max(wide.len(), Foundation::MAX_PATH as usize);
+        if buflen > u32::MAX as usize {
+            return Err(vm.new_overflow_error("path too long"));
+        }
         let mut buffer = vec![0u16; buflen];
         let ret = unsafe {
             FileSystem::GetVolumePathNameW(wide.as_ptr(), buffer.as_mut_ptr(), buflen as _)
         };
         if ret == 0 {
-            return Err(vm.new_last_os_error());
+            let err = io::Error::last_os_error();
+            return Err(OSErrorBuilder::with_filename(&err, path, vm));
         }
         let buffer = widestring::WideCString::from_vec_truncate(buffer);
         Ok(path.mode().process_path(buffer.to_os_string(), vm))
@@ -1257,9 +1465,6 @@ pub(crate) mod module {
 
     #[pyfunction]
     fn _path_splitroot_ex(path: crate::PyObjectRef, vm: &VirtualMachine) -> PyResult<PyTupleRef> {
-        use crate::builtins::{PyBytes, PyStr};
-        use rustpython_common::wtf8::Wtf8Buf;
-
         // 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)?
@@ -1274,14 +1479,15 @@ pub(crate) mod module {
             (wide, false)
         } else if let Some(b) = path.downcast_ref::<PyBytes>() {
             // On Windows, bytes must be valid UTF-8 - this raises UnicodeDecodeError if not
-            let s = std::str::from_utf8(b.as_bytes()).map_err(|e| {
+            let s = core::str::from_utf8(b.as_bytes()).map_err(|e| {
                 vm.new_exception_msg(
                     vm.ctx.exceptions.unicode_decode_error.to_owned(),
                     format!(
                         "'utf-8' codec can't decode byte {:#x} in position {}: invalid start byte",
                         b.as_bytes().get(e.valid_up_to()).copied().unwrap_or(0),
                         e.valid_up_to()
-                    ),
+                    )
+                    .into(),
                 )
             })?;
             let wide: Vec<u16> = s.encode_utf16().collect();
@@ -1329,15 +1535,7 @@ pub(crate) mod module {
     }
 
     #[pyfunction]
-    fn _path_splitroot(
-        path: OsPath,
-        _vm: &VirtualMachine,
-    ) -> (
-        rustpython_common::wtf8::Wtf8Buf,
-        rustpython_common::wtf8::Wtf8Buf,
-    ) {
-        use rustpython_common::wtf8::Wtf8Buf;
-
+    fn _path_splitroot(path: OsPath, _vm: &VirtualMachine) -> (Wtf8Buf, Wtf8Buf) {
         let orig: Vec<_> = path.path.to_wide();
         if orig.is_empty() {
             return (Wtf8Buf::new(), Wtf8Buf::new());
@@ -1346,15 +1544,14 @@ pub(crate) mod module {
             .iter()
             .copied()
             .map(|c| if c == b'/' as u16 { b'\\' as u16 } else { c })
-            .chain(std::iter::once(0)) // null-terminated
+            .chain(core::iter::once(0)) // null-terminated
             .collect();
 
         let mut end: *const u16 = core::ptr::null();
         let hr = unsafe {
             windows_sys::Win32::UI::Shell::PathCchSkipRoot(backslashed.as_ptr(), &mut end)
         };
-        if hr == 0 {
-            // S_OK
+        if hr >= 0 {
             assert!(!end.is_null());
             let len: usize = unsafe { end.offset_from(backslashed.as_ptr()) }
                 .try_into()
@@ -1366,15 +1563,184 @@ pub(crate) mod module {
                 len,
                 backslashed.len()
             );
-            (
-                Wtf8Buf::from_wide(&orig[..len]),
-                Wtf8Buf::from_wide(&orig[len..]),
-            )
+            if len != 0 {
+                (
+                    Wtf8Buf::from_wide(&orig[..len]),
+                    Wtf8Buf::from_wide(&orig[len..]),
+                )
+            } else {
+                (Wtf8Buf::from_wide(&orig), Wtf8Buf::new())
+            }
         } else {
             (Wtf8Buf::new(), Wtf8Buf::from_wide(&orig))
         }
     }
 
+    /// Normalize a wide-char path (faithful port of _Py_normpath_and_size).
+    /// Uses lastC tracking like the C implementation.
+    fn normpath_wide(path: &[u16]) -> Vec<u16> {
+        if path.is_empty() {
+            return vec![b'.' as u16];
+        }
+
+        const SEP: u16 = b'\\' as u16;
+        const ALTSEP: u16 = b'/' as u16;
+        const DOT: u16 = b'.' as u16;
+
+        let is_sep = |c: u16| c == SEP || c == ALTSEP;
+        let sep_or_end = |input: &[u16], idx: usize| idx >= input.len() || is_sep(input[idx]);
+
+        // Work on a mutable copy with normalized separators
+        let mut buf: Vec<u16> = path
+            .iter()
+            .map(|&c| if c == ALTSEP { SEP } else { c })
+            .collect();
+
+        let (drv_size, root_size) = skiproot(&buf);
+        let prefix_len = drv_size + root_size;
+
+        // p1 = read cursor, p2 = write cursor
+        let mut p1 = prefix_len;
+        let mut p2 = prefix_len;
+        let mut min_p2 = if prefix_len > 0 { prefix_len } else { 0 };
+        let mut last_c: u16 = if prefix_len > 0 {
+            min_p2 = prefix_len - 1;
+            let c = buf[min_p2];
+            // On Windows, if last char of prefix is not SEP, advance min_p2
+            if c != SEP {
+                min_p2 = prefix_len;
+            }
+            c
+        } else {
+            0
+        };
+
+        // Skip leading ".\" after prefix
+        if p1 < buf.len() && buf[p1] == DOT && sep_or_end(&buf, p1 + 1) {
+            p1 += 1;
+            last_c = SEP; // treat as if we consumed a separator
+            while p1 < buf.len() && buf[p1] == SEP {
+                p1 += 1;
+            }
+        }
+
+        while p1 < buf.len() {
+            let c = buf[p1];
+
+            if last_c == SEP {
+                if c == DOT {
+                    let sep_at_1 = sep_or_end(&buf, p1 + 1);
+                    let sep_at_2 = !sep_at_1 && sep_or_end(&buf, p1 + 2);
+                    if sep_at_2 && buf[p1 + 1] == DOT {
+                        // ".." component
+                        let mut p3 = p2;
+                        while p3 != min_p2 && buf[p3 - 1] == SEP {
+                            p3 -= 1;
+                        }
+                        while p3 != min_p2 && buf[p3 - 1] != SEP {
+                            p3 -= 1;
+                        }
+                        if p2 == min_p2
+                            || (buf[p3] == DOT
+                                && p3 + 1 < buf.len()
+                                && buf[p3 + 1] == DOT
+                                && (p3 + 2 >= buf.len() || buf[p3 + 2] == SEP))
+                        {
+                            // Previous segment is also ../ or at minimum
+                            buf[p2] = DOT;
+                            p2 += 1;
+                            buf[p2] = DOT;
+                            p2 += 1;
+                            last_c = DOT;
+                        } else if buf[p3] == SEP {
+                            // Absolute path - absorb segment
+                            p2 = p3 + 1;
+                            // last_c stays SEP
+                        } else {
+                            p2 = p3;
+                            // last_c stays SEP
+                        }
+                        p1 += 1; // skip second dot (first dot is current p1)
+                    } else if sep_at_1 {
+                        // "." component - skip
+                    } else {
+                        buf[p2] = c;
+                        p2 += 1;
+                        last_c = c;
+                    }
+                } else if c == SEP {
+                    // Collapse multiple separators - skip
+                } else {
+                    buf[p2] = c;
+                    p2 += 1;
+                    last_c = c;
+                }
+            } else {
+                buf[p2] = c;
+                p2 += 1;
+                last_c = c;
+            }
+
+            p1 += 1;
+        }
+
+        // Null-terminate style: trim trailing separators
+        if p2 != min_p2 {
+            while p2 > min_p2 + 1 && buf[p2 - 1] == SEP {
+                p2 -= 1;
+            }
+        }
+
+        buf.truncate(p2);
+
+        if buf.is_empty() { vec![DOT] } else { buf }
+    }
+
+    #[pyfunction]
+    fn _path_normpath(path: crate::PyObjectRef, vm: &VirtualMachine) -> PyResult {
+        // Handle path-like objects via os.fspath
+        let path = if let Some(fspath) = vm.get_method(path.clone(), identifier!(vm, __fspath__)) {
+            fspath?.call((), vm)?
+        } else {
+            path
+        };
+
+        let (wide, is_bytes): (Vec<u16>, bool) = if let Some(s) = path.downcast_ref::<PyStr>() {
+            let wide: Vec<u16> = s.as_wtf8().encode_wide().collect();
+            (wide, false)
+        } else if let Some(b) = path.downcast_ref::<PyBytes>() {
+            let s = core::str::from_utf8(b.as_bytes()).map_err(|e| {
+                vm.new_exception_msg(
+                    vm.ctx.exceptions.unicode_decode_error.to_owned(),
+                    format!(
+                        "'utf-8' codec can't decode byte {:#x} in position {}: invalid start byte",
+                        b.as_bytes().get(e.valid_up_to()).copied().unwrap_or(0),
+                        e.valid_up_to()
+                    )
+                    .into(),
+                )
+            })?;
+            let wide: Vec<u16> = s.encode_utf16().collect();
+            (wide, true)
+        } else {
+            return Err(vm.new_type_error(format!(
+                "expected str or bytes, not {}",
+                path.class().name()
+            )));
+        };
+
+        let normalized = normpath_wide(&wide);
+
+        if is_bytes {
+            let s = String::from_utf16(&normalized)
+                .map_err(|e| vm.new_unicode_decode_error(e.to_string()))?;
+            Ok(vm.ctx.new_bytes(s.into_bytes()).into())
+        } else {
+            let s = Wtf8Buf::from_wide(&normalized);
+            Ok(vm.ctx.new_str(s).into())
+        }
+    }
+
     #[pyfunction]
     fn _getdiskusage(path: OsPath, vm: &VirtualMachine) -> PyResult<(u64, u64)> {
         use FileSystem::GetDiskFreeSpaceExW;
@@ -1594,8 +1960,8 @@ pub(crate) mod module {
         // special case: mode 0o700 sets a protected ACL
         let res = if args.mode == 0o700 {
             let mut sec_attr = SECURITY_ATTRIBUTES {
-                nLength: std::mem::size_of::<SECURITY_ATTRIBUTES>() as u32,
-                lpSecurityDescriptor: std::ptr::null_mut(),
+                nLength: core::mem::size_of::<SECURITY_ATTRIBUTES>() as u32,
+                lpSecurityDescriptor: core::ptr::null_mut(),
                 bInheritHandle: 0,
             };
             // Set a discretionary ACL (D) that is protected (P) and includes
@@ -1609,7 +1975,7 @@ pub(crate) mod module {
                     sddl.as_ptr(),
                     SDDL_REVISION_1,
                     &mut sec_attr.lpSecurityDescriptor,
-                    std::ptr::null_mut(),
+                    core::ptr::null_mut(),
                 )
             };
             if convert_result == 0 {
@@ -1620,7 +1986,7 @@ pub(crate) mod module {
             unsafe { LocalFree(sec_attr.lpSecurityDescriptor) };
             res
         } else {
-            unsafe { FileSystem::CreateDirectoryW(wide.as_ptr(), std::ptr::null_mut()) }
+            unsafe { FileSystem::CreateDirectoryW(wide.as_ptr(), core::ptr::null_mut()) }
         };
 
         if res == 0 {
@@ -1652,15 +2018,22 @@ pub(crate) mod module {
 
     #[pyfunction]
     fn pipe(vm: &VirtualMachine) -> PyResult<(i32, i32)> {
+        use windows_sys::Win32::Security::SECURITY_ATTRIBUTES;
         use windows_sys::Win32::System::Pipes::CreatePipe;
 
+        let mut attr = SECURITY_ATTRIBUTES {
+            nLength: core::mem::size_of::<SECURITY_ATTRIBUTES>() as u32,
+            lpSecurityDescriptor: core::ptr::null_mut(),
+            bInheritHandle: 0,
+        };
+
         let (read_handle, write_handle) = unsafe {
             let mut read = MaybeUninit::<isize>::uninit();
             let mut write = MaybeUninit::<isize>::uninit();
             let res = CreatePipe(
                 read.as_mut_ptr() as *mut _,
                 write.as_mut_ptr() as *mut _,
-                core::ptr::null(),
+                &mut attr as *mut _,
                 0,
             );
             if res == 0 {
@@ -1693,7 +2066,7 @@ pub(crate) mod module {
         type NtQueryInformationProcessFn = unsafe extern "system" fn(
             process_handle: isize,
             process_information_class: u32,
-            process_information: *mut std::ffi::c_void,
+            process_information: *mut core::ffi::c_void,
             process_information_length: u32,
             return_length: *mut u32,
         ) -> i32;
@@ -1718,15 +2091,15 @@ pub(crate) mod module {
         };
         let nt_query: NtQueryInformationProcessFn = unsafe { core::mem::transmute(func) };
 
-        let mut info: PROCESS_BASIC_INFORMATION = unsafe { std::mem::zeroed() };
+        let mut info: PROCESS_BASIC_INFORMATION = unsafe { core::mem::zeroed() };
 
         let status = unsafe {
             nt_query(
                 GetCurrentProcess() as isize,
                 0, // ProcessBasicInformation
-                &mut info as *mut _ as *mut std::ffi::c_void,
-                std::mem::size_of::<PROCESS_BASIC_INFORMATION>() as u32,
-                std::ptr::null_mut(),
+                &mut info as *mut _ as *mut core::ffi::c_void,
+                core::mem::size_of::<PROCESS_BASIC_INFORMATION>() as u32,
+                core::ptr::null_mut(),
             )
         };
 
@@ -1804,7 +2177,7 @@ pub(crate) mod module {
                 core::ptr::null(),
                 OPEN_EXISTING,
                 FILE_FLAG_BACKUP_SEMANTICS | FILE_FLAG_OPEN_REPARSE_POINT,
-                std::ptr::null_mut(),
+                core::ptr::null_mut(),
             )
         };
 
@@ -1830,7 +2203,7 @@ pub(crate) mod module {
                 buffer.as_mut_ptr() as *mut _,
                 BUFFER_SIZE as u32,
                 &mut bytes_returned,
-                std::ptr::null_mut(),
+                core::ptr::null_mut(),
             )
         };
 
@@ -1878,10 +2251,7 @@ pub(crate) mod module {
                 // PathBuffer starts at offset 16
                 (sub_offset, sub_length, 16usize)
             } else {
-                // Unknown reparse tag - fall back to std::fs::read_link
-                let link_path = fs::read_link(path.as_ref())
-                    .map_err(|e| crate::convert::ToPyException::to_pyexception(&e, vm))?;
-                return Ok(mode.process_path(link_path, vm));
+                return Err(vm.new_value_error("not a symbolic link"));
             };
 
         // Extract the substitute name
@@ -1899,17 +2269,20 @@ pub(crate) mod module {
             .map(|chunk| u16::from_le_bytes([chunk[0], chunk[1]]))
             .collect();
 
-        let mut result_path = std::ffi::OsString::from_wide(&wide_chars);
-
+        let mut wide_chars = wide_chars;
         // For mount points (junctions), the substitute name typically starts with \??\
         // Convert this to \\?\
-        let result_str = result_path.to_string_lossy();
-        if let Some(stripped) = result_str.strip_prefix(r"\??\") {
-            // Replace \??\ with \\?\
-            let new_path = format!(r"\\?\{}", stripped);
-            result_path = std::ffi::OsString::from(new_path);
+        if wide_chars.len() > 4
+            && wide_chars[0] == b'\\' as u16
+            && wide_chars[1] == b'?' as u16
+            && wide_chars[2] == b'?' as u16
+            && wide_chars[3] == b'\\' as u16
+        {
+            wide_chars[1] = b'\\' as u16;
         }
 
+        let result_path = std::ffi::OsString::from_wide(&wide_chars);
+
         Ok(mode.process_path(std::path::PathBuf::from(result_path), vm))
     }
 
diff --git a/crates/vm/src/stdlib/os.rs b/crates/vm/src/stdlib/os.rs
index 691cb068605..bc9d24aa4aa 100644
--- a/crates/vm/src/stdlib/os.rs
+++ b/crates/vm/src/stdlib/os.rs
@@ -20,20 +20,6 @@ pub(crate) fn fs_metadata<P: AsRef<Path>>(
     }
 }
 
-#[cfg(unix)]
-impl crate::convert::IntoPyException for nix::Error {
-    fn into_pyexception(self, vm: &VirtualMachine) -> crate::builtins::PyBaseExceptionRef {
-        io::Error::from(self).into_pyexception(vm)
-    }
-}
-
-#[cfg(unix)]
-impl crate::convert::IntoPyException for rustix::io::Errno {
-    fn into_pyexception(self, vm: &VirtualMachine) -> crate::builtins::PyBaseExceptionRef {
-        io::Error::from(self).into_pyexception(vm)
-    }
-}
-
 #[allow(dead_code)]
 #[derive(FromArgs, Default)]
 pub struct TargetIsDirectory {
@@ -87,6 +73,7 @@ impl<const AVAILABLE: usize> FromArgs for DirFd<'_, AVAILABLE> {
             Some(o) if vm.is_none(&o) => Ok(DEFAULT_DIR_FD),
             None => Ok(DEFAULT_DIR_FD),
             Some(o) => {
+                warn_if_bool_fd(&o, vm).map_err(Into::<ArgumentError>::into)?;
                 let fd = o.try_index_opt(vm).unwrap_or_else(|| {
                     Err(vm.new_type_error(format!(
                         "argument should be integer or None, not {}",
@@ -118,8 +105,25 @@ fn bytes_as_os_str<'a>(b: &'a [u8], vm: &VirtualMachine) -> PyResult<&'a std::ff
         .map_err(|_| vm.new_unicode_decode_error("can't decode path for utf-8"))
 }
 
+pub(crate) fn warn_if_bool_fd(obj: &PyObjectRef, vm: &VirtualMachine) -> PyResult<()> {
+    use crate::class::StaticType;
+    if obj
+        .class()
+        .is(crate::builtins::bool_::PyBool::static_type())
+    {
+        crate::stdlib::_warnings::warn(
+            vm.ctx.exceptions.runtime_warning,
+            "bool is used as a file descriptor".to_owned(),
+            1,
+            vm,
+        )?;
+    }
+    Ok(())
+}
+
 impl TryFromObject for crt_fd::Owned {
     fn try_from_object(vm: &VirtualMachine, obj: PyObjectRef) -> PyResult<Self> {
+        warn_if_bool_fd(&obj, vm)?;
         let fd = crt_fd::Raw::try_from_object(vm, obj)?;
         unsafe { crt_fd::Owned::try_from_raw(fd) }.map_err(|e| e.into_pyexception(vm))
     }
@@ -127,6 +131,7 @@ impl TryFromObject for crt_fd::Owned {
 
 impl TryFromObject for crt_fd::Borrowed<'_> {
     fn try_from_object(vm: &VirtualMachine, obj: PyObjectRef) -> PyResult<Self> {
+        warn_if_bool_fd(&obj, vm)?;
         let fd = crt_fd::Raw::try_from_object(vm, obj)?;
         unsafe { crt_fd::Borrowed::try_borrow_raw(fd) }.map_err(|e| e.into_pyexception(vm))
     }
@@ -155,7 +160,6 @@ pub(super) mod _os {
         AsObject, Py, PyObjectRef, PyPayload, PyRef, PyResult, TryFromObject,
         builtins::{
             PyBytesRef, PyGenericAlias, PyIntRef, PyStrRef, PyTuple, PyTupleRef, PyTypeRef,
-            ToOSErrorBuilder,
         },
         common::{
             crt_fd,
@@ -164,17 +168,17 @@ pub(super) mod _os {
             suppress_iph,
         },
         convert::{IntoPyException, ToPyObject},
-        exceptions::OSErrorBuilder,
-        function::{ArgBytesLike, FsPath, FuncArgs, OptionalArg},
+        exceptions::{OSErrorBuilder, ToOSErrorBuilder},
+        function::{ArgBytesLike, ArgMemoryBuffer, FsPath, FuncArgs, OptionalArg},
         ospath::{OsPath, OsPathOrFd, OutputMode, PathConverter},
         protocol::PyIterReturn,
         recursion::ReprGuard,
-        types::{IterNext, Iterable, PyStructSequence, Representable, SelfIter},
+        types::{Destructor, IterNext, Iterable, PyStructSequence, Representable, SelfIter},
         vm::VirtualMachine,
     };
     use core::time::Duration;
     use crossbeam_utils::atomic::AtomicCell;
-    use itertools::Itertools;
+    use rustpython_common::wtf8::Wtf8Buf;
     use std::{env, fs, fs::OpenOptions, io, path::PathBuf, time::SystemTime};
 
     const OPEN_DIR_FD: bool = cfg!(not(any(windows, target_os = "redox")));
@@ -182,12 +186,12 @@ pub(super) mod _os {
     const STAT_DIR_FD: bool = cfg!(not(any(windows, target_os = "redox")));
     const UTIME_DIR_FD: bool = cfg!(not(any(windows, target_os = "redox")));
     pub(crate) const SYMLINK_DIR_FD: bool = cfg!(not(any(windows, target_os = "redox")));
+    pub(crate) const UNLINK_DIR_FD: bool = cfg!(not(any(windows, target_os = "redox")));
+    const RMDIR_DIR_FD: bool = cfg!(not(any(windows, target_os = "redox")));
+    const SCANDIR_FD: bool = cfg!(all(unix, not(target_os = "redox")));
 
     #[pyattr]
-    use libc::{
-        O_APPEND, O_CREAT, O_EXCL, O_RDONLY, O_RDWR, O_TRUNC, O_WRONLY, SEEK_CUR, SEEK_END,
-        SEEK_SET,
-    };
+    use libc::{O_APPEND, O_CREAT, O_EXCL, O_RDONLY, O_RDWR, O_TRUNC, O_WRONLY};
 
     #[pyattr]
     pub(crate) const F_OK: u8 = 0;
@@ -270,7 +274,7 @@ pub(super) mod _os {
                 crt_fd::open(&name, flags, mode)
             }
         };
-        fd.map_err(|err| OSErrorBuilder::with_filename(&err, name, vm))
+        fd.map_err(|err| OSErrorBuilder::with_filename_from_errno(&err, name, vm))
     }
 
     #[pyfunction]
@@ -282,7 +286,7 @@ pub(super) mod _os {
     fn read(fd: crt_fd::Borrowed<'_>, n: usize, vm: &VirtualMachine) -> PyResult<PyBytesRef> {
         let mut buffer = vec![0u8; n];
         loop {
-            match crt_fd::read(fd, &mut buffer) {
+            match vm.allow_threads(|| crt_fd::read(fd, &mut buffer)) {
                 Ok(n) => {
                     buffer.truncate(n);
                     return Ok(vm.ctx.new_bytes(buffer));
@@ -297,8 +301,39 @@ pub(super) mod _os {
     }
 
     #[pyfunction]
-    fn write(fd: crt_fd::Borrowed<'_>, data: ArgBytesLike) -> io::Result<usize> {
-        data.with_ref(|b| crt_fd::write(fd, b))
+    fn readinto(
+        fd: crt_fd::Borrowed<'_>,
+        buffer: ArgMemoryBuffer,
+        vm: &VirtualMachine,
+    ) -> PyResult<usize> {
+        buffer.with_ref(|buf| {
+            loop {
+                match vm.allow_threads(|| crt_fd::read(fd, buf)) {
+                    Ok(n) => return Ok(n),
+                    Err(e) if e.raw_os_error() == Some(libc::EINTR) => {
+                        vm.check_signals()?;
+                        continue;
+                    }
+                    Err(e) => return Err(e.into_pyexception(vm)),
+                }
+            }
+        })
+    }
+
+    #[pyfunction]
+    fn write(fd: crt_fd::Borrowed<'_>, data: ArgBytesLike, vm: &VirtualMachine) -> PyResult<usize> {
+        data.with_ref(|b| {
+            loop {
+                match vm.allow_threads(|| crt_fd::write(fd, b)) {
+                    Ok(n) => return Ok(n),
+                    Err(e) if e.raw_os_error() == Some(libc::EINTR) => {
+                        vm.check_signals()?;
+                        continue;
+                    }
+                    Err(e) => return Err(e.into_pyexception(vm)),
+                }
+            }
+        })
     }
 
     #[cfg(not(windows))]
@@ -333,9 +368,34 @@ pub(super) mod _os {
 
     #[pyfunction]
     fn mkdirs(path: PyStrRef, vm: &VirtualMachine) -> PyResult<()> {
-        fs::create_dir_all(path.as_str()).map_err(|err| err.into_pyexception(vm))
+        let os_path = vm.fsencode(&path)?;
+        fs::create_dir_all(&*os_path).map_err(|err| err.into_pyexception(vm))
     }
 
+    #[cfg(not(windows))]
+    #[pyfunction]
+    fn rmdir(
+        path: OsPath,
+        dir_fd: DirFd<'_, { RMDIR_DIR_FD as usize }>,
+        vm: &VirtualMachine,
+    ) -> PyResult<()> {
+        #[cfg(not(target_os = "redox"))]
+        if let Some(fd) = dir_fd.raw_opt() {
+            let c_path = path.clone().into_cstring(vm)?;
+            let res = unsafe { libc::unlinkat(fd, c_path.as_ptr(), libc::AT_REMOVEDIR) };
+            return if res < 0 {
+                let err = crate::common::os::errno_io_error();
+                Err(OSErrorBuilder::with_filename(&err, path, vm))
+            } else {
+                Ok(())
+            };
+        }
+        #[cfg(target_os = "redox")]
+        let [] = dir_fd.0;
+        fs::remove_dir(&path).map_err(|err| OSErrorBuilder::with_filename(&err, path, vm))
+    }
+
+    #[cfg(windows)]
     #[pyfunction]
     fn rmdir(path: OsPath, dir_fd: DirFd<'_, 0>, vm: &VirtualMachine) -> PyResult<()> {
         let [] = dir_fd.0;
@@ -379,22 +439,36 @@ pub(super) mod _os {
                 #[cfg(all(unix, not(target_os = "redox")))]
                 {
                     use rustpython_common::os::ffi::OsStrExt;
+                    use std::os::unix::io::IntoRawFd;
                     let new_fd = nix::unistd::dup(fno).map_err(|e| e.into_pyexception(vm))?;
-                    let mut dir =
-                        nix::dir::Dir::from_fd(new_fd).map_err(|e| e.into_pyexception(vm))?;
-                    dir.iter()
-                        .filter_map_ok(|entry| {
-                            let fname = entry.file_name().to_bytes();
-                            match fname {
-                                b"." | b".." => None,
-                                _ => Some(
-                                    OutputMode::String
-                                        .process_path(std::ffi::OsStr::from_bytes(fname), vm),
-                                ),
+                    let raw_fd = new_fd.into_raw_fd();
+                    let dir = OwnedDir::from_fd(raw_fd).map_err(|e| {
+                        unsafe { libc::close(raw_fd) };
+                        e.into_pyexception(vm)
+                    })?;
+                    // OwnedDir::drop calls rewinddir (reset to start) then closedir.
+                    let mut list = Vec::new();
+                    loop {
+                        nix::errno::Errno::clear();
+                        let entry = unsafe { libc::readdir(dir.as_ptr()) };
+                        if entry.is_null() {
+                            let err = nix::errno::Errno::last();
+                            if err != nix::errno::Errno::UnknownErrno {
+                                return Err(io::Error::from(err).into_pyexception(vm));
                             }
-                        })
-                        .collect::<Result<_, _>>()
-                        .map_err(|e| e.into_pyexception(vm))?
+                            break;
+                        }
+                        let fname = unsafe { core::ffi::CStr::from_ptr((*entry).d_name.as_ptr()) }
+                            .to_bytes();
+                        match fname {
+                            b"." | b".." => continue,
+                            _ => list.push(
+                                OutputMode::String
+                                    .process_path(std::ffi::OsStr::from_bytes(fname), vm),
+                            ),
+                        }
+                    }
+                    list
                 }
             }
         };
@@ -429,8 +503,8 @@ pub(super) mod _os {
     #[cfg(windows)]
     #[pyfunction]
     fn putenv(key: PyStrRef, value: PyStrRef, vm: &VirtualMachine) -> PyResult<()> {
-        let key_str = key.as_str();
-        let value_str = value.as_str();
+        let key_str = key.expect_str();
+        let value_str = value.expect_str();
         // Search from index 1 because on Windows starting '=' is allowed for
         // defining hidden environment variables.
         if key_str.is_empty()
@@ -477,7 +551,7 @@ pub(super) mod _os {
     #[cfg(windows)]
     #[pyfunction]
     fn unsetenv(key: PyStrRef, vm: &VirtualMachine) -> PyResult<()> {
-        let key_str = key.as_str();
+        let key_str = key.expect_str();
         // Search from index 1 because on Windows starting '=' is allowed for
         // defining hidden environment variables.
         if key_str.is_empty()
@@ -542,6 +616,12 @@ pub(super) mod _os {
         file_name: std::ffi::OsString,
         pathval: PathBuf,
         file_type: io::Result<fs::FileType>,
+        /// dirent d_type value, used when file_type is unavailable (fd-based scandir)
+        #[cfg(unix)]
+        d_type: Option<u8>,
+        /// Parent directory fd for fd-based scandir, used for fstatat
+        #[cfg(not(any(windows, target_os = "redox")))]
+        dir_fd: Option<crt_fd::Raw>,
         mode: OutputMode,
         stat: OnceCell<PyObjectRef>,
         lstat: OnceCell<PyObjectRef>,
@@ -565,53 +645,116 @@ pub(super) mod _os {
             Ok(self.mode.process_path(&self.pathval, vm))
         }
 
+        /// Build the DirFd to use for stat calls.
+        /// If this entry was produced by fd-based scandir, use the stored dir_fd
+        /// so that fstatat(dir_fd, name, ...) is used instead of stat(full_path).
+        fn stat_dir_fd(&self) -> DirFd<'_, { STAT_DIR_FD as usize }> {
+            #[cfg(not(any(windows, target_os = "redox")))]
+            if let Some(raw_fd) = self.dir_fd {
+                // Safety: the fd came from os.open() and is borrowed for
+                // the lifetime of this DirEntry reference.
+                let borrowed = unsafe { crt_fd::Borrowed::borrow_raw(raw_fd) };
+                return DirFd([borrowed; STAT_DIR_FD as usize]);
+            }
+            DirFd::default()
+        }
+
+        /// Stat-based mode test fallback. Uses fstatat when dir_fd is available.
+        #[cfg(unix)]
+        fn test_mode_via_stat(
+            &self,
+            follow_symlinks: bool,
+            mode_bits: u32,
+            vm: &VirtualMachine,
+        ) -> PyResult<bool> {
+            match self.stat(self.stat_dir_fd(), FollowSymlinks(follow_symlinks), vm) {
+                Ok(stat_obj) => {
+                    let st_mode: i32 = stat_obj.get_attr("st_mode", vm)?.try_into_value(vm)?;
+                    #[allow(clippy::unnecessary_cast)]
+                    Ok((st_mode as u32 & libc::S_IFMT as u32) == mode_bits)
+                }
+                Err(e) => {
+                    if e.fast_isinstance(vm.ctx.exceptions.file_not_found_error) {
+                        Ok(false)
+                    } else {
+                        Err(e)
+                    }
+                }
+            }
+        }
+
         #[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
                 && (!follow_symlinks.0 || !file_type.is_symlink())
             {
                 return Ok(file_type.is_dir());
             }
+            #[cfg(unix)]
+            if let Some(dt) = self.d_type {
+                let is_symlink = dt == libc::DT_LNK;
+                let need_stat = dt == libc::DT_UNKNOWN || (follow_symlinks.0 && is_symlink);
+                if !need_stat {
+                    return Ok(dt == libc::DT_DIR);
+                }
+            }
+            #[cfg(unix)]
+            return self.test_mode_via_stat(follow_symlinks.0, libc::S_IFDIR as _, vm);
+            #[cfg(not(unix))]
             match super::fs_metadata(&self.pathval, follow_symlinks.0) {
                 Ok(meta) => Ok(meta.is_dir()),
-                Err(e) => {
-                    if e.kind() == io::ErrorKind::NotFound {
-                        Ok(false)
-                    } else {
-                        Err(e.into_pyexception(vm))
-                    }
-                }
+                Err(e) if e.kind() == io::ErrorKind::NotFound => Ok(false),
+                Err(e) => Err(e.into_pyexception(vm)),
             }
         }
 
         #[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
                 && (!follow_symlinks.0 || !file_type.is_symlink())
             {
                 return Ok(file_type.is_file());
             }
+            #[cfg(unix)]
+            if let Some(dt) = self.d_type {
+                let is_symlink = dt == libc::DT_LNK;
+                let need_stat = dt == libc::DT_UNKNOWN || (follow_symlinks.0 && is_symlink);
+                if !need_stat {
+                    return Ok(dt == libc::DT_REG);
+                }
+            }
+            #[cfg(unix)]
+            return self.test_mode_via_stat(follow_symlinks.0, libc::S_IFREG as _, vm);
+            #[cfg(not(unix))]
             match super::fs_metadata(&self.pathval, follow_symlinks.0) {
                 Ok(meta) => Ok(meta.is_file()),
-                Err(e) => {
-                    if e.kind() == io::ErrorKind::NotFound {
-                        Ok(false)
-                    } else {
-                        Err(e.into_pyexception(vm))
-                    }
-                }
+                Err(e) if e.kind() == io::ErrorKind::NotFound => Ok(false),
+                Err(e) => Err(e.into_pyexception(vm)),
             }
         }
 
         #[pymethod]
         fn is_symlink(&self, vm: &VirtualMachine) -> PyResult<bool> {
-            Ok(self
-                .file_type
-                .as_ref()
-                .map_err(|err| err.into_pyexception(vm))?
-                .is_symlink())
+            if let Ok(file_type) = &self.file_type {
+                return Ok(file_type.is_symlink());
+            }
+            #[cfg(unix)]
+            if let Some(dt) = self.d_type
+                && dt != libc::DT_UNKNOWN
+            {
+                return Ok(dt == libc::DT_LNK);
+            }
+            #[cfg(unix)]
+            return self.test_mode_via_stat(false, libc::S_IFLNK as _, vm);
+            #[cfg(not(unix))]
+            match &self.file_type {
+                Err(e) if e.kind() == io::ErrorKind::NotFound => Ok(false),
+                Err(e) => {
+                    use crate::convert::ToPyException;
+                    Err(e.to_pyexception(vm))
+                }
+                Ok(_) => Ok(false),
+            }
         }
 
         #[pymethod]
@@ -621,6 +764,12 @@ pub(super) mod _os {
             follow_symlinks: FollowSymlinks,
             vm: &VirtualMachine,
         ) -> PyResult {
+            // Use stored dir_fd if the caller didn't provide one
+            let effective_dir_fd = if dir_fd == DirFd::default() {
+                self.stat_dir_fd()
+            } else {
+                dir_fd
+            };
             let do_stat = |follow_symlinks| {
                 stat(
                     OsPath {
@@ -628,21 +777,32 @@ pub(super) mod _os {
                         origin: None,
                     }
                     .into(),
-                    dir_fd,
+                    effective_dir_fd,
                     FollowSymlinks(follow_symlinks),
                     vm,
                 )
             };
-            let lstat = || self.lstat.get_or_try_init(|| do_stat(false));
+            let lstat = || match self.lstat.get() {
+                Some(val) => Ok(val),
+                None => {
+                    let val = do_stat(false)?;
+                    let _ = self.lstat.set(val);
+                    Ok(self.lstat.get().unwrap())
+                }
+            };
             let stat = if follow_symlinks.0 {
-                // if follow_symlinks == true and we aren't a symlink, cache both stat and lstat
-                self.stat.get_or_try_init(|| {
-                    if self.is_symlink(vm)? {
-                        do_stat(true)
-                    } else {
-                        lstat().cloned()
+                match self.stat.get() {
+                    Some(val) => val,
+                    None => {
+                        let val = if self.is_symlink(vm)? {
+                            do_stat(true)?
+                        } else {
+                            lstat()?.clone()
+                        };
+                        let _ = self.stat.set(val);
+                        self.stat.get().unwrap()
                     }
-                })?
+                }
             } else {
                 lstat()?
             };
@@ -714,13 +874,13 @@ pub(super) mod _os {
 
         #[pymethod]
         fn __reduce__(&self, vm: &VirtualMachine) -> PyResult {
-            Err(vm.new_type_error("cannot pickle 'DirEntry' object".to_owned()))
+            Err(vm.new_type_error("cannot pickle 'DirEntry' object"))
         }
     }
 
     impl Representable for DirEntry {
         #[inline]
-        fn repr_str(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<String> {
+        fn repr_wtf8(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<Wtf8Buf> {
             let name = match zelf.as_object().get_attr("name", vm) {
                 Ok(name) => Some(name),
                 Err(e)
@@ -734,7 +894,10 @@ pub(super) mod _os {
             if let Some(name) = name {
                 if let Some(_guard) = ReprGuard::enter(vm, zelf.as_object()) {
                     let repr = name.repr(vm)?;
-                    Ok(format!("<{} {}>", zelf.class(), repr))
+                    let mut result = Wtf8Buf::from(format!("<{} ", zelf.class()));
+                    result.push_wtf8(repr.as_wtf8());
+                    result.push_char('>');
+                    Ok(result)
                 } else {
                     Err(vm.new_runtime_error(format!(
                         "reentrant call inside {}.__repr__",
@@ -742,7 +905,7 @@ pub(super) mod _os {
                     )))
                 }
             } else {
-                Ok(format!("<{}>", zelf.class()))
+                Ok(Wtf8Buf::from(format!("<{}>", zelf.class())))
             }
         }
     }
@@ -754,7 +917,7 @@ pub(super) mod _os {
         mode: OutputMode,
     }
 
-    #[pyclass(flags(DISALLOW_INSTANTIATION), with(IterNext, Iterable))]
+    #[pyclass(flags(DISALLOW_INSTANTIATION), with(Destructor, IterNext, Iterable))]
     impl ScandirIterator {
         #[pymethod]
         fn close(&self) {
@@ -774,7 +937,22 @@ pub(super) mod _os {
 
         #[pymethod]
         fn __reduce__(&self, vm: &VirtualMachine) -> PyResult {
-            Err(vm.new_type_error("cannot pickle 'ScandirIterator' object".to_owned()))
+            Err(vm.new_type_error("cannot pickle 'ScandirIterator' object"))
+        }
+    }
+    impl Destructor for ScandirIterator {
+        fn del(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<()> {
+            // Emit ResourceWarning if the iterator is not yet exhausted/closed
+            if zelf.entries.read().is_some() {
+                let _ = crate::stdlib::_warnings::warn(
+                    vm.ctx.exceptions.resource_warning,
+                    format!("unclosed scandir iterator {:?}", zelf.as_object()),
+                    1,
+                    vm,
+                );
+                zelf.close();
+            }
+            Ok(())
         }
     }
     impl SelfIter for ScandirIterator {}
@@ -825,6 +1003,10 @@ pub(super) mod _os {
                                     file_name: entry.file_name(),
                                     pathval,
                                     file_type: entry.file_type(),
+                                    #[cfg(unix)]
+                                    d_type: None,
+                                    #[cfg(not(any(windows, target_os = "redox")))]
+                                    dir_fd: None,
                                     mode: zelf.mode,
                                     lstat,
                                     stat: OnceCell::new(),
@@ -845,17 +1027,202 @@ pub(super) mod _os {
         }
     }
 
+    /// Wrapper around a raw `libc::DIR*` for fd-based scandir.
+    #[cfg(all(unix, not(target_os = "redox")))]
+    struct OwnedDir(core::ptr::NonNull<libc::DIR>);
+
+    #[cfg(all(unix, not(target_os = "redox")))]
+    impl OwnedDir {
+        fn from_fd(fd: crt_fd::Raw) -> io::Result<Self> {
+            let ptr = unsafe { libc::fdopendir(fd) };
+            core::ptr::NonNull::new(ptr)
+                .map(OwnedDir)
+                .ok_or_else(io::Error::last_os_error)
+        }
+
+        fn as_ptr(&self) -> *mut libc::DIR {
+            self.0.as_ptr()
+        }
+    }
+
+    #[cfg(all(unix, not(target_os = "redox")))]
+    impl Drop for OwnedDir {
+        fn drop(&mut self) {
+            unsafe {
+                libc::rewinddir(self.0.as_ptr());
+                libc::closedir(self.0.as_ptr());
+            }
+        }
+    }
+
+    #[cfg(all(unix, not(target_os = "redox")))]
+    impl core::fmt::Debug for OwnedDir {
+        fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+            f.debug_tuple("OwnedDir").field(&self.0).finish()
+        }
+    }
+
+    // Safety: OwnedDir wraps a *mut libc::DIR. All access is synchronized
+    // through the PyMutex in ScandirIteratorFd.
+    #[cfg(all(unix, not(target_os = "redox")))]
+    unsafe impl Send for OwnedDir {}
+    #[cfg(all(unix, not(target_os = "redox")))]
+    unsafe impl Sync for OwnedDir {}
+
+    #[cfg(all(unix, not(target_os = "redox")))]
+    #[pyattr]
+    #[pyclass(name = "ScandirIter")]
+    #[derive(Debug, PyPayload)]
+    struct ScandirIteratorFd {
+        dir: crate::common::lock::PyMutex<Option<OwnedDir>>,
+        /// The original fd passed to scandir(), stored in DirEntry for fstatat
+        orig_fd: crt_fd::Raw,
+    }
+
+    #[cfg(all(unix, not(target_os = "redox")))]
+    #[pyclass(flags(DISALLOW_INSTANTIATION), with(Destructor, IterNext, Iterable))]
+    impl ScandirIteratorFd {
+        #[pymethod]
+        fn close(&self) {
+            let _dropped = self.dir.lock().take();
+        }
+
+        #[pymethod]
+        const fn __enter__(zelf: PyRef<Self>) -> PyRef<Self> {
+            zelf
+        }
+
+        #[pymethod]
+        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"))
+        }
+    }
+
+    #[cfg(all(unix, not(target_os = "redox")))]
+    impl Destructor for ScandirIteratorFd {
+        fn del(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<()> {
+            if zelf.dir.lock().is_some() {
+                let _ = crate::stdlib::_warnings::warn(
+                    vm.ctx.exceptions.resource_warning,
+                    format!("unclosed scandir iterator {:?}", zelf.as_object()),
+                    1,
+                    vm,
+                );
+                zelf.close();
+            }
+            Ok(())
+        }
+    }
+
+    #[cfg(all(unix, not(target_os = "redox")))]
+    impl SelfIter for ScandirIteratorFd {}
+
+    #[cfg(all(unix, not(target_os = "redox")))]
+    impl IterNext for ScandirIteratorFd {
+        fn next(zelf: &crate::Py<Self>, vm: &VirtualMachine) -> PyResult<PyIterReturn> {
+            use rustpython_common::os::ffi::OsStrExt;
+            let mut guard = zelf.dir.lock();
+            let dir = match guard.as_mut() {
+                None => return Ok(PyIterReturn::StopIteration(None)),
+                Some(dir) => dir,
+            };
+            loop {
+                nix::errno::Errno::clear();
+                let entry = unsafe {
+                    let ptr = libc::readdir(dir.as_ptr());
+                    if ptr.is_null() {
+                        let err = nix::errno::Errno::last();
+                        if err != nix::errno::Errno::UnknownErrno {
+                            return Err(io::Error::from(err).into_pyexception(vm));
+                        }
+                        drop(guard.take());
+                        return Ok(PyIterReturn::StopIteration(None));
+                    }
+                    &*ptr
+                };
+                let fname = unsafe { core::ffi::CStr::from_ptr(entry.d_name.as_ptr()) }.to_bytes();
+                if fname == b"." || fname == b".." {
+                    continue;
+                }
+                let file_name = std::ffi::OsString::from(std::ffi::OsStr::from_bytes(fname));
+                let pathval = PathBuf::from(&file_name);
+                #[cfg(target_os = "freebsd")]
+                let ino = entry.d_fileno;
+                #[cfg(not(target_os = "freebsd"))]
+                let ino = entry.d_ino;
+                let d_type = entry.d_type;
+                return Ok(PyIterReturn::Return(
+                    DirEntry {
+                        file_name,
+                        pathval,
+                        file_type: Err(io::Error::other(
+                            "file_type unavailable for fd-based scandir",
+                        )),
+                        d_type: if d_type == libc::DT_UNKNOWN {
+                            None
+                        } else {
+                            Some(d_type)
+                        },
+                        dir_fd: Some(zelf.orig_fd),
+                        mode: OutputMode::String,
+                        lstat: OnceCell::new(),
+                        stat: OnceCell::new(),
+                        ino: AtomicCell::new(ino as _),
+                    }
+                    .into_ref(&vm.ctx)
+                    .into(),
+                ));
+            }
+        }
+    }
+
     #[pyfunction]
-    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| OSErrorBuilder::with_filename(&err, path.clone(), vm))?;
-        Ok(ScandirIterator {
-            entries: PyRwLock::new(Some(entries)),
-            mode: path.mode(),
+    fn scandir(path: OptionalArg<Option<OsPathOrFd<'_>>>, vm: &VirtualMachine) -> PyResult {
+        let path = path
+            .flatten()
+            .unwrap_or_else(|| OsPathOrFd::Path(OsPath::new_str(".")));
+        match path {
+            OsPathOrFd::Path(path) => {
+                let entries = fs::read_dir(&path.path)
+                    .map_err(|err| OSErrorBuilder::with_filename(&err, path.clone(), vm))?;
+                Ok(ScandirIterator {
+                    entries: PyRwLock::new(Some(entries)),
+                    mode: path.mode(),
+                }
+                .into_ref(&vm.ctx)
+                .into())
+            }
+            OsPathOrFd::Fd(fno) => {
+                #[cfg(not(all(unix, not(target_os = "redox"))))]
+                {
+                    let _ = fno;
+                    Err(vm.new_not_implemented_error("can't pass fd to scandir on this platform"))
+                }
+                #[cfg(all(unix, not(target_os = "redox")))]
+                {
+                    use std::os::unix::io::IntoRawFd;
+                    // closedir() closes the fd, so duplicate it first
+                    let new_fd = nix::unistd::dup(fno).map_err(|e| e.into_pyexception(vm))?;
+                    let raw_fd = new_fd.into_raw_fd();
+                    let dir = OwnedDir::from_fd(raw_fd).map_err(|e| {
+                        // fdopendir failed, close the dup'd fd
+                        unsafe { libc::close(raw_fd) };
+                        e.into_pyexception(vm)
+                    })?;
+                    Ok(ScandirIteratorFd {
+                        dir: crate::common::lock::PyMutex::new(Some(dir)),
+                        orig_fd: fno.as_raw(),
+                    }
+                    .into_ref(&vm.ctx)
+                    .into())
+                }
+            }
         }
-        .into_ref(&vm.ctx)
-        .into())
     }
 
     #[derive(Debug, FromArgs)]
@@ -869,12 +1236,15 @@ pub(super) mod _os {
         pub st_gid: PyIntRef,
         pub st_size: PyIntRef,
         // Indices 7-9: integer seconds
+        #[cfg_attr(target_env = "musl", allow(deprecated))]
         #[pyarg(positional, default)]
         #[pystruct_sequence(unnamed)]
         pub st_atime_int: libc::time_t,
+        #[cfg_attr(target_env = "musl", allow(deprecated))]
         #[pyarg(positional, default)]
         #[pystruct_sequence(unnamed)]
         pub st_mtime_int: libc::time_t,
+        #[cfg_attr(target_env = "musl", allow(deprecated))]
         #[pyarg(positional, default)]
         #[pystruct_sequence(unnamed)]
         pub st_ctime_int: libc::time_t,
@@ -957,10 +1327,10 @@ pub(super) mod _os {
             let st_ino = stat.st_ino;
 
             #[cfg(not(windows))]
-            #[allow(clippy::useless_conversion)] // needed for 32-bit platforms
+            #[allow(clippy::useless_conversion, reason = "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
+            #[allow(clippy::useless_conversion, reason = "needed for 32-bit platforms")]
             let st_blocks = i64::from(stat.st_blocks);
 
             Self {
@@ -999,29 +1369,25 @@ pub(super) mod _os {
     #[pyclass(with(PyStructSequence))]
     impl PyStatResult {
         #[pyslot]
-        fn slot_new(_cls: PyTypeRef, args: FuncArgs, vm: &VirtualMachine) -> PyResult {
-            let flatten_args = |r: &[PyObjectRef]| {
-                let mut vec_args = Vec::from(r);
-                loop {
-                    if let Ok(obj) = vec_args.iter().exactly_one() {
-                        match obj.downcast_ref::<PyTuple>() {
-                            Some(t) => {
-                                vec_args = Vec::from(t.as_slice());
-                            }
-                            None => {
-                                return vec_args;
-                            }
-                        }
-                    } else {
-                        return vec_args;
-                    }
+        fn slot_new(cls: PyTypeRef, args: FuncArgs, vm: &VirtualMachine) -> PyResult {
+            let seq: PyObjectRef = args.bind(vm)?;
+            let result = crate::types::struct_sequence_new(cls.clone(), seq, vm)?;
+            let tuple = result.downcast_ref::<PyTuple>().unwrap();
+            let mut items: Vec<PyObjectRef> = tuple.to_vec();
+
+            // Copy integer time fields to hidden float timestamp slots when not provided.
+            // indices 7-9: st_atime_int, st_mtime_int, st_ctime_int
+            // i+3: st_atime/st_mtime/st_ctime (float timestamps, copied from int if missing)
+            // i+6: st_atime_ns/st_mtime_ns/st_ctime_ns (left as None if not provided)
+            for i in 7..=9 {
+                if vm.is_none(&items[i + 3]) {
+                    items[i + 3] = items[i].clone();
                 }
-            };
-
-            let args: FuncArgs = flatten_args(&args.args).into();
+            }
 
-            let stat: StatResultData = args.bind(vm)?;
-            Ok(stat.to_pyobject(vm))
+            PyTuple::new_unchecked(items.into_boxed_slice())
+                .into_ref_with_type(vm, cls)
+                .map(Into::into)
         }
     }
 
@@ -1267,14 +1633,76 @@ pub(super) mod _os {
         }
     }
 
+    #[derive(FromArgs)]
+    struct LinkArgs {
+        #[pyarg(any)]
+        src: OsPath,
+        #[pyarg(any)]
+        dst: OsPath,
+        #[pyarg(named, name = "follow_symlinks", optional)]
+        follow_symlinks: OptionalArg<bool>,
+    }
+
     #[pyfunction]
-    fn link(src: OsPath, dst: OsPath, vm: &VirtualMachine) -> PyResult<()> {
-        fs::hard_link(&src.path, &dst.path).map_err(|err| {
-            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()
-        })
+    fn link(args: LinkArgs, vm: &VirtualMachine) -> PyResult<()> {
+        let LinkArgs {
+            src,
+            dst,
+            follow_symlinks,
+        } = args;
+
+        #[cfg(unix)]
+        {
+            use std::os::unix::ffi::OsStrExt;
+            let src_cstr = alloc::ffi::CString::new(src.path.as_os_str().as_bytes())
+                .map_err(|_| vm.new_value_error("embedded null byte"))?;
+            let dst_cstr = alloc::ffi::CString::new(dst.path.as_os_str().as_bytes())
+                .map_err(|_| vm.new_value_error("embedded null byte"))?;
+
+            let follow = follow_symlinks.into_option().unwrap_or(true);
+            let flags = if follow { libc::AT_SYMLINK_FOLLOW } else { 0 };
+
+            let ret = unsafe {
+                libc::linkat(
+                    libc::AT_FDCWD,
+                    src_cstr.as_ptr(),
+                    libc::AT_FDCWD,
+                    dst_cstr.as_ptr(),
+                    flags,
+                )
+            };
+
+            if ret != 0 {
+                let err = std::io::Error::last_os_error();
+                let builder = err.to_os_error_builder(vm);
+                let builder = builder.filename(src.filename(vm));
+                let builder = builder.filename2(dst.filename(vm));
+                return Err(builder.build(vm).upcast());
+            }
+
+            Ok(())
+        }
+
+        #[cfg(not(unix))]
+        {
+            let src_path = match follow_symlinks.into_option() {
+                Some(true) => {
+                    // Explicit follow_symlinks=True: resolve symlinks
+                    fs::canonicalize(&src.path).unwrap_or_else(|_| PathBuf::from(src.path.clone()))
+                }
+                Some(false) | None => {
+                    // Default or explicit no-follow: native hard_link behavior
+                    PathBuf::from(src.path.clone())
+                }
+            };
+
+            fs::hard_link(&src_path, &dst.path).map_err(|err| {
+                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()
+            })
+        }
     }
 
     #[cfg(any(unix, windows))]
@@ -1479,7 +1907,7 @@ pub(super) mod _os {
     fn times(vm: &VirtualMachine) -> PyResult {
         #[cfg(windows)]
         {
-            use std::mem::MaybeUninit;
+            use core::mem::MaybeUninit;
             use windows_sys::Win32::{Foundation::FILETIME, System::Threading};
 
             let mut _create = MaybeUninit::<FILETIME>::uninit();
@@ -1606,8 +2034,10 @@ pub(super) mod _os {
 
     #[pyfunction]
     fn truncate(path: PyObjectRef, length: crt_fd::Offset, vm: &VirtualMachine) -> PyResult<()> {
-        if let Ok(fd) = path.clone().try_into_value(vm) {
-            return ftruncate(fd, length).map_err(|e| e.into_pyexception(vm));
+        match path.clone().try_into_value::<crt_fd::Borrowed<'_>>(vm) {
+            Ok(fd) => return ftruncate(fd, length).map_err(|e| e.into_pyexception(vm)),
+            Err(e) if e.fast_isinstance(vm.ctx.exceptions.warning) => return Err(e),
+            Err(_) => {}
         }
 
         #[cold]
@@ -1695,7 +2125,7 @@ pub(super) mod _os {
             } else {
                 let encoding = unsafe {
                     let encoding = libc::nl_langinfo(libc::CODESET);
-                    if encoding.is_null() || encoding.read() == '\0' as libc::c_char {
+                    if encoding.is_null() || encoding.read() == b'\0' as libc::c_char {
                         "UTF-8".to_owned()
                     } else {
                         core::ffi::CStr::from_ptr(encoding).to_string_lossy().into_owned()
@@ -1842,17 +2272,18 @@ pub(super) mod _os {
             SupportFunc::new("access", Some(false), Some(false), None),
             SupportFunc::new("chdir", None, Some(false), Some(false)),
             // chflags Some, None Some
+            SupportFunc::new("link", Some(false), Some(false), Some(cfg!(unix))),
             SupportFunc::new("listdir", Some(LISTDIR_FD), Some(false), Some(false)),
             SupportFunc::new("mkdir", Some(false), Some(MKDIR_DIR_FD), Some(false)),
             // mkfifo Some Some None
             // mknod Some Some None
             SupportFunc::new("readlink", Some(false), None, Some(false)),
-            SupportFunc::new("remove", Some(false), None, Some(false)),
-            SupportFunc::new("unlink", Some(false), None, Some(false)),
+            SupportFunc::new("remove", Some(false), Some(UNLINK_DIR_FD), Some(false)),
+            SupportFunc::new("unlink", Some(false), Some(UNLINK_DIR_FD), Some(false)),
             SupportFunc::new("rename", Some(false), None, Some(false)),
             SupportFunc::new("replace", Some(false), None, Some(false)), // TODO: Fix replace
-            SupportFunc::new("rmdir", Some(false), None, Some(false)),
-            SupportFunc::new("scandir", None, Some(false), Some(false)),
+            SupportFunc::new("rmdir", Some(false), Some(RMDIR_DIR_FD), Some(false)),
+            SupportFunc::new("scandir", Some(SCANDIR_FD), Some(false), Some(false)),
             SupportFunc::new("stat", Some(true), Some(STAT_DIR_FD), Some(true)),
             SupportFunc::new("fstat", Some(true), Some(STAT_DIR_FD), Some(true)),
             SupportFunc::new("symlink", Some(false), Some(SYMLINK_DIR_FD), Some(false)),
@@ -1925,6 +2356,36 @@ pub fn module_exec(vm: &VirtualMachine, module: &Py<PyModule>) -> PyResult<()> {
     Ok(())
 }
 
+/// Convert a mapping (e.g. os._Environ) to a plain dict for use by execve/posix_spawn.
+///
+/// For `os._Environ`, accesses the internal `_data` dict directly at the Rust level.
+/// This avoids Python-level method calls that can deadlock after fork() when
+/// parking_lot locks are held by threads that no longer exist.
+#[cfg(any(unix, windows))]
+pub(crate) fn envobj_to_dict(
+    env: crate::function::ArgMapping,
+    vm: &VirtualMachine,
+) -> PyResult<crate::builtins::PyDictRef> {
+    let obj = env.obj();
+    if let Some(dict) = obj.downcast_ref_if_exact::<crate::builtins::PyDict>(vm) {
+        return Ok(dict.to_owned());
+    }
+    if let Some(inst_dict) = obj.dict()
+        && let Ok(Some(data)) = inst_dict.get_item_opt("_data", vm)
+        && let Some(dict) = data.downcast_ref_if_exact::<crate::builtins::PyDict>(vm)
+    {
+        return Ok(dict.to_owned());
+    }
+    let keys = vm.call_method(obj, "keys", ())?;
+    let dict = vm.ctx.new_dict();
+    for key in keys.get_iter(vm)?.into_iter::<PyObjectRef>(vm)? {
+        let key = key?;
+        let val = obj.get_item(&*key, vm)?;
+        dict.set_item(&*key, val, vm)?;
+    }
+    Ok(dict)
+}
+
 #[cfg(not(windows))]
 use super::posix as platform;
 
diff --git a/crates/vm/src/stdlib/posix.rs b/crates/vm/src/stdlib/posix.rs
index 84d27f2286e..8cde18a47ba 100644
--- a/crates/vm/src/stdlib/posix.rs
+++ b/crates/vm/src/stdlib/posix.rs
@@ -15,36 +15,52 @@ pub fn set_inheritable(fd: BorrowedFd<'_>, inheritable: bool) -> nix::Result<()>
     Ok(())
 }
 
-#[pymodule(name = "posix", with(super::os::_os))]
+#[pymodule(name = "posix", with(
+    super::os::_os,
+    #[cfg(any(
+        target_os = "linux",
+        target_os = "netbsd",
+        target_os = "freebsd",
+        target_os = "android"
+    ))]
+    posix_sched
+))]
 pub mod module {
     use crate::{
-        AsObject, Py, PyObjectRef, PyPayload, PyResult, VirtualMachine,
-        builtins::{PyDictRef, PyInt, PyListRef, PyStrRef, PyTupleRef, PyType, PyUtf8StrRef},
+        AsObject, Py, PyObjectRef, PyResult, VirtualMachine,
+        builtins::{PyDictRef, PyInt, PyListRef, PyTupleRef, PyUtf8Str},
         convert::{IntoPyException, ToPyObject, TryFromObject},
         exceptions::OSErrorBuilder,
-        function::{Either, KwArgs, OptionalArg},
+        function::{ArgMapping, Either, KwArgs, OptionalArg},
         ospath::{OsPath, OsPathOrFd},
-        stdlib::os::{_os, DirFd, FollowSymlinks, SupportFunc, TargetIsDirectory, fs_metadata},
-        types::{Constructor, Representable},
-        utils::ToCString,
+        stdlib::os::{
+            _os, DirFd, FollowSymlinks, SupportFunc, TargetIsDirectory, fs_metadata,
+            warn_if_bool_fd,
+        },
     };
+    #[cfg(any(
+        target_os = "android",
+        target_os = "freebsd",
+        target_os = "linux",
+        target_os = "openbsd"
+    ))]
+    use crate::{builtins::PyUtf8StrRef, utils::ToCString};
     use alloc::ffi::CString;
     use bitflags::bitflags;
     use core::ffi::CStr;
     use nix::{
+        errno::Errno,
         fcntl,
         unistd::{self, Gid, Pid, Uid},
     };
+    use rustpython_common::os::ffi::OsStringExt;
     use std::{
         env, fs, io,
         os::fd::{AsFd, BorrowedFd, FromRawFd, IntoRawFd, OwnedFd},
     };
+    use strum::IntoEnumIterator;
     use strum_macros::{EnumIter, EnumString};
 
-    #[cfg(target_os = "freebsd")]
-    #[pyattr]
-    use libc::{MFD_HUGE_MASK, SF_MNOWAIT, SF_NOCACHE, SF_NODISKIO, SF_SYNC};
-
     #[cfg(target_os = "linux")]
     #[pyattr]
     use libc::PIDFD_NONBLOCK;
@@ -56,42 +72,72 @@ pub mod module {
         PRIO_DARWIN_NONUI, PRIO_DARWIN_PROCESS, PRIO_DARWIN_THREAD,
     };
 
+    #[cfg(target_os = "freebsd")]
+    #[pyattr]
+    use libc::{SF_MNOWAIT, SF_NOCACHE, SF_NODISKIO, SF_SYNC};
+
     #[cfg(any(target_os = "android", target_os = "linux"))]
     #[pyattr]
     use libc::{
         CLONE_FILES, CLONE_FS, CLONE_NEWCGROUP, CLONE_NEWIPC, CLONE_NEWNET, CLONE_NEWNS,
         CLONE_NEWPID, CLONE_NEWUSER, CLONE_NEWUTS, CLONE_SIGHAND, CLONE_SYSVSEM, CLONE_THREAD,
-        CLONE_VM, EFD_CLOEXEC, EFD_NONBLOCK, EFD_SEMAPHORE, O_NOATIME, O_TMPFILE, P_PIDFD,
-        SCHED_BATCH, SCHED_IDLE, SCHED_RESET_ON_FORK, SPLICE_F_MORE, SPLICE_F_MOVE,
+        CLONE_VM, MFD_HUGE_SHIFT, O_NOATIME, O_TMPFILE, P_PIDFD, SCHED_BATCH, SCHED_DEADLINE,
+        SCHED_IDLE, SCHED_NORMAL, SCHED_RESET_ON_FORK, SPLICE_F_MORE, SPLICE_F_MOVE,
         SPLICE_F_NONBLOCK,
     };
 
-    #[cfg(any(target_os = "android", unix))]
-    #[pyattr]
-    use libc::{
-        F_OK, O_CLOEXEC, O_DIRECTORY, O_NOFOLLOW, O_NONBLOCK, PRIO_PGRP, PRIO_PROCESS, PRIO_USER,
-        R_OK, RTLD_GLOBAL, RTLD_LAZY, RTLD_LOCAL, RTLD_NOW, W_OK, WCONTINUED, WNOHANG, WUNTRACED,
-        X_OK,
-    };
-
     #[cfg(any(target_os = "macos", target_os = "redox"))]
     #[pyattr]
     use libc::O_SYMLINK;
 
+    #[cfg(any(target_os = "android", target_os = "redox", unix))]
+    #[pyattr]
+    use libc::{O_NOFOLLOW, PRIO_PGRP, PRIO_PROCESS, PRIO_USER};
+
+    #[cfg(any(target_os = "linux", target_os = "macos", target_os = "netbsd"))]
+    #[pyattr]
+    use libc::{XATTR_CREATE, XATTR_REPLACE};
+
+    #[cfg(any(target_os = "android", target_os = "linux", target_os = "netbsd"))]
+    #[pyattr]
+    use libc::O_RSYNC;
+
     #[cfg(any(target_os = "android", target_os = "freebsd", target_os = "linux"))]
     #[pyattr]
     use libc::{
-        MFD_ALLOW_SEALING, MFD_CLOEXEC, MFD_HUGETLB, POSIX_FADV_DONTNEED, POSIX_FADV_NOREUSE,
-        POSIX_FADV_NORMAL, POSIX_FADV_RANDOM, POSIX_FADV_SEQUENTIAL, POSIX_FADV_WILLNEED,
+        MFD_ALLOW_SEALING, MFD_CLOEXEC, MFD_HUGE_MASK, MFD_HUGETLB, POSIX_FADV_DONTNEED,
+        POSIX_FADV_NOREUSE, POSIX_FADV_NORMAL, POSIX_FADV_RANDOM, POSIX_FADV_SEQUENTIAL,
+        POSIX_FADV_WILLNEED,
     };
 
-    #[cfg(any(target_os = "android", target_os = "linux", target_os = "netbsd"))]
+    #[cfg(any(target_os = "android", target_os = "linux", target_os = "redox", unix))]
     #[pyattr]
-    use libc::{TFD_CLOEXEC, TFD_NONBLOCK, TFD_TIMER_ABSTIME, TFD_TIMER_CANCEL_ON_SET};
+    use libc::{RTLD_LAZY, RTLD_NOW, WNOHANG};
 
-    #[cfg(any(target_os = "linux", target_os = "macos", target_os = "netbsd"))]
+    #[cfg(any(target_os = "android", target_os = "macos", target_os = "redox", unix))]
     #[pyattr]
-    use libc::{XATTR_CREATE, XATTR_REPLACE};
+    use libc::RTLD_GLOBAL;
+
+    #[cfg(any(
+        target_os = "android",
+        target_os = "freebsd",
+        target_os = "linux",
+        target_os = "redox"
+    ))]
+    #[pyattr]
+    use libc::O_PATH;
+
+    #[cfg(any(
+        target_os = "android",
+        target_os = "freebsd",
+        target_os = "linux",
+        target_os = "netbsd"
+    ))]
+    #[pyattr]
+    use libc::{
+        EFD_CLOEXEC, EFD_NONBLOCK, EFD_SEMAPHORE, TFD_CLOEXEC, TFD_NONBLOCK, TFD_TIMER_ABSTIME,
+        TFD_TIMER_CANCEL_ON_SET,
+    };
 
     #[cfg(any(
         target_os = "android",
@@ -104,21 +150,43 @@ pub mod module {
 
     #[cfg(any(
         target_os = "android",
-        target_os = "freebsd",
         target_os = "linux",
-        target_os = "redox"
+        target_os = "macos",
+        target_os = "redox",
+        unix
     ))]
     #[pyattr]
-    use libc::O_PATH;
+    use libc::{F_OK, R_OK, W_OK, X_OK};
 
     #[cfg(any(
         target_os = "android",
-        target_os = "linux",
+        target_os = "freebsd",
         target_os = "netbsd",
-        target_os = "openbsd"
+        target_os = "redox",
+        unix
     ))]
     #[pyattr]
-    use libc::O_RSYNC;
+    use libc::O_NONBLOCK;
+
+    #[cfg(any(
+        target_os = "android",
+        target_os = "freebsd",
+        target_os = "linux",
+        target_os = "macos",
+        target_os = "netbsd"
+    ))]
+    #[pyattr]
+    use libc::O_DSYNC;
+
+    #[cfg(any(
+        target_os = "dragonfly",
+        target_os = "freebsd",
+        target_os = "linux",
+        target_os = "macos",
+        target_os = "netbsd"
+    ))]
+    #[pyattr]
+    use libc::SCHED_OTHER;
 
     #[cfg(any(
         target_os = "android",
@@ -141,48 +209,62 @@ pub mod module {
     use libc::O_DIRECT;
 
     #[cfg(any(
-        target_os = "android",
         target_os = "dragonfly",
         target_os = "freebsd",
+        target_os = "macos",
+        target_os = "netbsd",
+        target_os = "redox"
+    ))]
+    #[pyattr]
+    use libc::{O_EXLOCK, O_FSYNC, O_SHLOCK};
+
+    #[cfg(any(
+        target_os = "android",
         target_os = "linux",
         target_os = "macos",
-        target_os = "netbsd"
+        target_os = "netbsd",
+        target_os = "redox",
+        unix
     ))]
     #[pyattr]
-    use libc::RTLD_NOLOAD;
+    use libc::RTLD_LOCAL;
 
     #[cfg(any(
         target_os = "android",
         target_os = "freebsd",
         target_os = "linux",
-        target_os = "macos",
         target_os = "netbsd",
-        target_os = "openbsd"
+        target_os = "redox",
+        unix
     ))]
     #[pyattr]
-    use libc::O_DSYNC;
+    use libc::WUNTRACED;
 
     #[cfg(any(
+        target_os = "android",
         target_os = "dragonfly",
         target_os = "freebsd",
         target_os = "linux",
         target_os = "macos",
-        target_os = "netbsd",
-        target_os = "openbsd"
+        target_os = "netbsd"
     ))]
     #[pyattr]
-    use libc::SCHED_OTHER;
+    use libc::{
+        CLD_CONTINUED, CLD_DUMPED, CLD_EXITED, CLD_KILLED, CLD_STOPPED, CLD_TRAPPED, O_SYNC, P_ALL,
+        P_PGID, P_PID, RTLD_NOLOAD, SCHED_FIFO, SCHED_RR,
+    };
 
     #[cfg(any(
+        target_os = "android",
         target_os = "dragonfly",
         target_os = "freebsd",
         target_os = "macos",
         target_os = "netbsd",
-        target_os = "openbsd",
-        target_os = "redox"
+        target_os = "redox",
+        unix
     ))]
     #[pyattr]
-    use libc::{O_EXLOCK, O_FSYNC, O_SHLOCK};
+    use libc::O_DIRECTORY;
 
     #[cfg(any(
         target_os = "android",
@@ -191,12 +273,11 @@ pub mod module {
         target_os = "linux",
         target_os = "macos",
         target_os = "netbsd",
-        target_os = "openbsd"
+        target_os = "redox"
     ))]
     #[pyattr]
     use libc::{
-        CLD_CONTINUED, CLD_DUMPED, CLD_EXITED, CLD_KILLED, CLD_STOPPED, CLD_TRAPPED, F_LOCK,
-        F_TEST, F_TLOCK, F_ULOCK, O_SYNC, P_ALL, P_PGID, P_PID, SCHED_FIFO, SCHED_RR,
+        F_LOCK, F_TEST, F_TLOCK, F_ULOCK, O_ASYNC, O_NDELAY, O_NOCTTY, WEXITED, WNOWAIT, WSTOPPED,
     };
 
     #[cfg(any(
@@ -206,11 +287,11 @@ pub mod module {
         target_os = "linux",
         target_os = "macos",
         target_os = "netbsd",
-        target_os = "openbsd",
-        target_os = "redox"
+        target_os = "redox",
+        unix
     ))]
     #[pyattr]
-    use libc::{O_ASYNC, O_NDELAY, O_NOCTTY, WEXITED, WNOWAIT, WSTOPPED};
+    use libc::{O_CLOEXEC, WCONTINUED};
 
     #[pyattr]
     const EX_OK: i8 = exitcode::OK as i8;
@@ -274,6 +355,7 @@ pub mod module {
 
     impl TryFromObject for BorrowedFd<'_> {
         fn try_from_object(vm: &VirtualMachine, obj: PyObjectRef) -> PyResult<Self> {
+            crate::stdlib::os::warn_if_bool_fd(&obj, vm)?;
             let fd = i32::try_from_object(vm, obj)?;
             if fd == -1 {
                 return Err(io::Error::from_raw_os_error(libc::EBADF).into_pyexception(vm));
@@ -357,7 +439,7 @@ pub mod module {
     fn getgroups_impl() -> nix::Result<Vec<Gid>> {
         use core::ptr;
         use libc::{c_int, gid_t};
-        use nix::errno::Errno;
+
         let ret = unsafe { libc::getgroups(0, ptr::null_mut()) };
         let mut groups = Vec::<Gid>::with_capacity(Errno::result(ret)? as usize);
         let ret = unsafe {
@@ -427,8 +509,6 @@ pub mod module {
 
     #[pyattr]
     fn environ(vm: &VirtualMachine) -> PyDictRef {
-        use rustpython_common::os::ffi::OsStringExt;
-
         let environ = vm.ctx.new_dict();
         for (key, value) in env::vars_os() {
             let key: PyObjectRef = vm.ctx.new_bytes(key.into_vec()).into();
@@ -439,6 +519,17 @@ pub mod module {
         environ
     }
 
+    #[pyfunction]
+    fn _create_environ(vm: &VirtualMachine) -> PyDictRef {
+        let environ = vm.ctx.new_dict();
+        for (key, value) in env::vars_os() {
+            let key: PyObjectRef = vm.ctx.new_bytes(key.into_vec()).into();
+            let value: PyObjectRef = vm.ctx.new_bytes(value.into_vec()).into();
+            environ.set_item(&*key, value, vm).unwrap();
+        }
+        environ
+    }
+
     #[derive(FromArgs)]
     pub(super) struct SymlinkArgs<'fd> {
         src: OsPath,
@@ -472,15 +563,38 @@ pub mod module {
 
     #[pyfunction]
     #[pyfunction(name = "unlink")]
-    fn remove(path: OsPath, dir_fd: DirFd<'_, 0>, vm: &VirtualMachine) -> PyResult<()> {
+    fn remove(
+        path: OsPath,
+        dir_fd: DirFd<'_, { _os::UNLINK_DIR_FD as usize }>,
+        vm: &VirtualMachine,
+    ) -> PyResult<()> {
+        #[cfg(not(target_os = "redox"))]
+        if let Some(fd) = dir_fd.raw_opt() {
+            let c_path = path.clone().into_cstring(vm)?;
+            let res = unsafe { libc::unlinkat(fd, c_path.as_ptr(), 0) };
+            return if res < 0 {
+                let err = crate::common::os::errno_io_error();
+                Err(OSErrorBuilder::with_filename(&err, path, vm))
+            } else {
+                Ok(())
+            };
+        }
+        #[cfg(target_os = "redox")]
         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<()> {
-        nix::unistd::fchdir(fd).map_err(|err| err.into_pyexception(vm))
+    fn fchdir(fd: PyObjectRef, vm: &VirtualMachine) -> PyResult<()> {
+        warn_if_bool_fd(&fd, vm)?;
+        let fd = i32::try_from_object(vm, fd)?;
+        let ret = unsafe { libc::fchdir(fd) };
+        if ret == 0 {
+            Ok(())
+        } else {
+            Err(io::Error::last_os_error().into_pyexception(vm))
+        }
     }
 
     #[cfg(not(target_os = "redox"))]
@@ -653,92 +767,276 @@ pub mod module {
         // only for before_forkers, refer: test_register_at_fork in test_posix
 
         run_at_forkers(before_forkers, true, vm);
+
+        #[cfg(feature = "threading")]
+        crate::stdlib::_imp::acquire_imp_lock_for_fork();
+
+        #[cfg(feature = "threading")]
+        vm.state.stop_the_world.stop_the_world(vm);
     }
 
     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);
+        vm.state.stop_the_world.reset_after_fork();
+
+        // Phase 1: Reset all internal locks FIRST.
+        // After fork(), locks held by dead parent threads would deadlock
+        // if we try to acquire them. This must happen before anything else.
+        #[cfg(feature = "threading")]
+        reinit_locks_after_fork(vm);
+
+        // Reinit per-object IO buffer locks on std streams.
+        // BufferedReader/Writer/TextIOWrapper use PyThreadMutex which can be
+        // held by dead parent threads, causing deadlocks on any IO in the child.
+        #[cfg(feature = "threading")]
+        unsafe {
+            crate::stdlib::_io::reinit_std_streams_after_fork(vm)
+        };
+
+        // Phase 2: Reset low-level atomic state (no locks needed).
+        crate::signal::clear_after_fork();
+        crate::stdlib::_signal::_signal::clear_wakeup_fd_after_fork();
+
+        // Reset weakref stripe locks that may have been held during fork.
+        #[cfg(feature = "threading")]
+        crate::object::reset_weakref_locks_after_fork();
+
+        // Phase 3: Clean up thread state. Locks are now reinit'd so we can
+        // acquire them normally instead of using try_lock().
+        #[cfg(feature = "threading")]
+        crate::stdlib::_thread::after_fork_child(vm);
 
+        // CPython parity: reinit import lock ownership metadata in child
+        // and release the lock acquired by PyOS_BeforeFork().
+        #[cfg(feature = "threading")]
+        unsafe {
+            crate::stdlib::_imp::after_fork_child_imp_lock_release()
+        };
+
+        // Initialize signal handlers for the child's main thread.
+        // When forked from a worker thread, the OnceCell is empty.
+        vm.signal_handlers
+            .get_or_init(crate::signal::new_signal_handlers);
+
+        // Phase 4: Run Python-level at-fork callbacks.
         let after_forkers_child: Vec<PyObjectRef> = vm.state.after_forkers_child.lock().clone();
         run_at_forkers(after_forkers_child, false, vm);
     }
 
+    /// Reset all parking_lot-based locks in the interpreter state after fork().
+    ///
+    /// After fork(), only the calling thread survives. Any locks held by other
+    /// (now-dead) threads would cause deadlocks. We unconditionally reset them
+    /// to unlocked by zeroing the raw lock bytes.
+    #[cfg(all(unix, feature = "threading"))]
+    fn reinit_locks_after_fork(vm: &VirtualMachine) {
+        use rustpython_common::lock::reinit_mutex_after_fork;
+
+        unsafe {
+            // PyGlobalState PyMutex locks
+            reinit_mutex_after_fork(&vm.state.before_forkers);
+            reinit_mutex_after_fork(&vm.state.after_forkers_child);
+            reinit_mutex_after_fork(&vm.state.after_forkers_parent);
+            reinit_mutex_after_fork(&vm.state.atexit_funcs);
+            reinit_mutex_after_fork(&vm.state.global_trace_func);
+            reinit_mutex_after_fork(&vm.state.global_profile_func);
+            reinit_mutex_after_fork(&vm.state.monitoring);
+
+            // PyGlobalState parking_lot::Mutex locks
+            reinit_mutex_after_fork(&vm.state.thread_frames);
+            reinit_mutex_after_fork(&vm.state.thread_handles);
+            reinit_mutex_after_fork(&vm.state.shutdown_handles);
+
+            // Context-level RwLock
+            vm.ctx.string_pool.reinit_after_fork();
+
+            // Codec registry RwLock
+            vm.state.codec_registry.reinit_after_fork();
+
+            // GC state (multiple Mutex + RwLock)
+            crate::gc_state::gc_state().reinit_after_fork();
+
+            // Import lock (RawReentrantMutex<RawMutex, RawThreadId>)
+            crate::stdlib::_imp::reinit_imp_lock_after_fork();
+        }
+    }
+
     fn py_os_after_fork_parent(vm: &VirtualMachine) {
+        #[cfg(feature = "threading")]
+        vm.state.stop_the_world.start_the_world(vm);
+
+        #[cfg(feature = "threading")]
+        crate::stdlib::_imp::release_imp_lock_after_fork_parent();
+
         let after_forkers_parent: Vec<PyObjectRef> = vm.state.after_forkers_parent.lock().clone();
         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))
+    /// Best-effort number of OS threads in this process.
+    /// Returns <= 0 when unavailable.
+    fn get_number_of_os_threads() -> isize {
+        #[cfg(target_os = "macos")]
         {
-            Ok(m) => m,
-            Err(_) => return,
-        };
-        let active = threading.get_attr("_active", vm).ok();
-        let limbo = threading.get_attr("_limbo", vm).ok();
+            type MachPortT = libc::c_uint;
+            type KernReturnT = libc::c_int;
+            type MachMsgTypeNumberT = libc::c_uint;
+            type ThreadActArrayT = *mut MachPortT;
+            const KERN_SUCCESS: KernReturnT = 0;
+            unsafe extern "C" {
+                fn mach_task_self() -> MachPortT;
+                fn task_for_pid(
+                    task: MachPortT,
+                    pid: libc::c_int,
+                    target_task: *mut MachPortT,
+                ) -> KernReturnT;
+                fn task_threads(
+                    target_task: MachPortT,
+                    act_list: *mut ThreadActArrayT,
+                    act_list_cnt: *mut MachMsgTypeNumberT,
+                ) -> KernReturnT;
+                fn vm_deallocate(
+                    target_task: MachPortT,
+                    address: libc::uintptr_t,
+                    size: libc::uintptr_t,
+                ) -> KernReturnT;
+            }
 
-        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 self_task = unsafe { mach_task_self() };
+            let mut proc_task: MachPortT = 0;
+            if unsafe { task_for_pid(self_task, libc::getpid(), &mut proc_task) } == KERN_SUCCESS {
+                let mut threads: ThreadActArrayT = core::ptr::null_mut();
+                let mut n_threads: MachMsgTypeNumberT = 0;
+                if unsafe { task_threads(proc_task, &mut threads, &mut n_threads) } == KERN_SUCCESS
+                {
+                    if !threads.is_null() {
+                        let _ = unsafe {
+                            vm_deallocate(
+                                self_task,
+                                threads as libc::uintptr_t,
+                                (n_threads as usize * core::mem::size_of::<MachPortT>())
+                                    as libc::uintptr_t,
+                            )
+                        };
+                    }
+                    return n_threads as isize;
+                }
+            }
+            0
+        }
+        #[cfg(target_os = "linux")]
+        {
+            use std::io::Read as _;
+            let mut file = match std::fs::File::open("/proc/self/stat") {
+                Ok(f) => f,
+                Err(_) => return 0,
+            };
+            let mut buf = [0u8; 160];
+            let n = match file.read(&mut buf) {
+                Ok(n) => n,
+                Err(_) => return 0,
+            };
+            let line = match core::str::from_utf8(&buf[..n]) {
+                Ok(s) => s,
+                Err(_) => return 0,
+            };
+            if let Some(field) = line.split_whitespace().nth(19) {
+                return field.parse::<isize>().unwrap_or(0);
+            }
+            0
+        }
+        #[cfg(not(any(target_os = "macos", target_os = "linux")))]
+        {
+            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;
+    /// Warn if forking from a multi-threaded process.
+    /// `num_os_threads` should be captured before parent after-fork hooks run.
+    fn warn_if_multi_threaded(name: &str, num_os_threads: isize, vm: &VirtualMachine) {
+        let num_threads = if num_os_threads > 0 {
+            num_os_threads as usize
+        } else {
+            // CPython fallback: if OS-level count isn't available, use the
+            // threading module's active+limbo view.
+            // 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 Ok(warn_fn) = warnings.get_attr("warn", vm) else {
-                return;
+            let active = threading.get_attr("_active", vm).ok();
+            let limbo = threading.get_attr("_limbo", vm).ok();
+
+            // Match threading module internals and avoid sequence overcounting:
+            // count only dict-backed _active/_limbo containers.
+            let count_dict = |obj: Option<crate::PyObjectRef>| -> usize {
+                obj.and_then(|o| {
+                    o.downcast_ref::<crate::builtins::PyDict>()
+                        .map(|d| d.__len__())
+                })
+                .unwrap_or(0)
             };
 
+            count_dict(active) + count_dict(limbo)
+        };
+
+        if num_threads > 1 {
             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);
+            // Match PyErr_WarnFormat(..., stacklevel=1) in CPython.
+            // Best effort: ignore failures like CPython does in this path.
+            let _ =
+                crate::stdlib::_warnings::warn(vm.ctx.exceptions.deprecation_warning, msg, 1, vm);
         }
     }
 
     #[pyfunction]
-    fn fork(vm: &VirtualMachine) -> i32 {
-        warn_if_multi_threaded("fork", vm);
+    fn fork(vm: &VirtualMachine) -> PyResult<i32> {
+        if vm
+            .state
+            .finalizing
+            .load(core::sync::atomic::Ordering::Acquire)
+        {
+            return Err(vm.new_exception_msg(
+                vm.ctx.exceptions.python_finalization_error.to_owned(),
+                "can't fork at interpreter shutdown".into(),
+            ));
+        }
+
+        // RustPython does not yet have C-level audit hooks; call sys.audit()
+        // to preserve Python-visible behavior and failure semantics.
+        vm.sys_module
+            .get_attr("audit", vm)?
+            .call(("os.fork",), vm)?;
 
-        let pid: i32;
         py_os_before_fork(vm);
-        unsafe {
-            pid = libc::fork();
-        }
+
+        let pid = unsafe { libc::fork() };
+        // Save errno immediately — AfterFork callbacks may clobber it.
+        let saved_errno = nix::Error::last_raw();
         if pid == 0 {
             py_os_after_fork_child(vm);
         } else {
+            // Match CPython timing: capture this before parent after-fork hooks
+            // in case those hooks start threads.
+            let num_os_threads = get_number_of_os_threads();
             py_os_after_fork_parent(vm);
+            // Match CPython timing: warn only after parent callback path resumes world.
+            warn_if_multi_threaded("fork", num_os_threads, vm);
+        }
+        if pid == -1 {
+            Err(nix::Error::from_raw(saved_errno).into_pyexception(vm))
+        } else {
+            Ok(pid)
         }
-        pid
     }
 
     #[cfg(not(target_os = "redox"))]
@@ -810,7 +1108,6 @@ pub mod module {
     #[cfg(not(target_os = "redox"))]
     #[pyfunction]
     fn nice(increment: i32, vm: &VirtualMachine) -> PyResult<i32> {
-        use nix::errno::Errno;
         Errno::clear();
         let res = unsafe { libc::nice(increment) };
         if res == -1 && Errno::last_raw() != 0 {
@@ -847,175 +1144,6 @@ pub mod module {
         nix::sched::sched_yield().map_err(|e| e.into_pyexception(vm))
     }
 
-    #[pyattr]
-    #[pyclass(name = "sched_param")]
-    #[derive(Debug, PyPayload)]
-    struct SchedParam {
-        sched_priority: PyObjectRef,
-    }
-
-    impl TryFromObject for SchedParam {
-        fn try_from_object(_vm: &VirtualMachine, obj: PyObjectRef) -> PyResult<Self> {
-            Ok(Self {
-                sched_priority: obj,
-            })
-        }
-    }
-
-    #[pyclass(with(Constructor, Representable))]
-    impl SchedParam {
-        #[pygetset]
-        fn sched_priority(&self, vm: &VirtualMachine) -> PyObjectRef {
-            self.sched_priority.clone().to_pyobject(vm)
-        }
-
-        #[cfg(any(
-            target_os = "linux",
-            target_os = "netbsd",
-            target_os = "freebsd",
-            target_os = "android"
-        ))]
-        #[cfg(not(target_env = "musl"))]
-        fn try_to_libc(&self, vm: &VirtualMachine) -> PyResult<libc::sched_param> {
-            use crate::AsObject;
-            let priority_class = self.sched_priority.class();
-            let priority_type = priority_class.name();
-            let priority = self.sched_priority.clone();
-            let value = priority.downcast::<PyInt>().map_err(|_| {
-                vm.new_type_error(format!("an integer is required (got type {priority_type})"))
-            })?;
-            let sched_priority = value.try_to_primitive(vm)?;
-            Ok(libc::sched_param { sched_priority })
-        }
-    }
-
-    #[derive(FromArgs)]
-    pub struct SchedParamArg {
-        sched_priority: PyObjectRef,
-    }
-
-    impl Constructor for SchedParam {
-        type Args = SchedParamArg;
-
-        fn py_new(_cls: &Py<PyType>, arg: Self::Args, _vm: &VirtualMachine) -> PyResult<Self> {
-            Ok(Self {
-                sched_priority: arg.sched_priority,
-            })
-        }
-    }
-
-    impl Representable for SchedParam {
-        #[inline]
-        fn repr_str(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<String> {
-            let sched_priority_repr = zelf.sched_priority.repr(vm)?;
-            Ok(format!(
-                "posix.sched_param(sched_priority = {})",
-                sched_priority_repr.as_str()
-            ))
-        }
-    }
-
-    #[cfg(any(
-        target_os = "linux",
-        target_os = "netbsd",
-        target_os = "freebsd",
-        target_os = "android"
-    ))]
-    #[pyfunction]
-    fn sched_getscheduler(pid: libc::pid_t, vm: &VirtualMachine) -> PyResult<i32> {
-        let policy = unsafe { libc::sched_getscheduler(pid) };
-        if policy == -1 {
-            Err(vm.new_last_errno_error())
-        } else {
-            Ok(policy)
-        }
-    }
-
-    #[cfg(any(
-        target_os = "linux",
-        target_os = "netbsd",
-        target_os = "freebsd",
-        target_os = "android"
-    ))]
-    #[derive(FromArgs)]
-    struct SchedSetschedulerArgs {
-        #[pyarg(positional)]
-        pid: i32,
-        #[pyarg(positional)]
-        policy: i32,
-        #[pyarg(positional)]
-        sched_param_obj: crate::PyRef<SchedParam>,
-    }
-
-    #[cfg(any(
-        target_os = "linux",
-        target_os = "netbsd",
-        target_os = "freebsd",
-        target_os = "android"
-    ))]
-    #[cfg(not(target_env = "musl"))]
-    #[pyfunction]
-    fn sched_setscheduler(args: SchedSetschedulerArgs, vm: &VirtualMachine) -> PyResult<i32> {
-        let libc_sched_param = args.sched_param_obj.try_to_libc(vm)?;
-        let policy = unsafe { libc::sched_setscheduler(args.pid, args.policy, &libc_sched_param) };
-        if policy == -1 {
-            Err(vm.new_last_errno_error())
-        } else {
-            Ok(policy)
-        }
-    }
-    #[cfg(any(
-        target_os = "linux",
-        target_os = "netbsd",
-        target_os = "freebsd",
-        target_os = "android"
-    ))]
-    #[pyfunction]
-    fn sched_getparam(pid: libc::pid_t, vm: &VirtualMachine) -> PyResult<SchedParam> {
-        let param = unsafe {
-            let mut param = core::mem::MaybeUninit::uninit();
-            if -1 == libc::sched_getparam(pid, param.as_mut_ptr()) {
-                return Err(vm.new_last_errno_error());
-            }
-            param.assume_init()
-        };
-        Ok(SchedParam {
-            sched_priority: param.sched_priority.to_pyobject(vm),
-        })
-    }
-
-    #[cfg(any(
-        target_os = "linux",
-        target_os = "netbsd",
-        target_os = "freebsd",
-        target_os = "android"
-    ))]
-    #[derive(FromArgs)]
-    struct SchedSetParamArgs {
-        #[pyarg(positional)]
-        pid: i32,
-        #[pyarg(positional)]
-        sched_param_obj: crate::PyRef<SchedParam>,
-    }
-
-    #[cfg(any(
-        target_os = "linux",
-        target_os = "netbsd",
-        target_os = "freebsd",
-        target_os = "android"
-    ))]
-    #[cfg(not(target_env = "musl"))]
-    #[pyfunction]
-    fn sched_setparam(args: SchedSetParamArgs, vm: &VirtualMachine) -> PyResult<i32> {
-        let libc_sched_param = args.sched_param_obj.try_to_libc(vm)?;
-        let ret = unsafe { libc::sched_setparam(args.pid, &libc_sched_param) };
-        if ret == -1 {
-            Err(vm.new_last_errno_error())
-        } else {
-            Ok(ret)
-        }
-    }
-
     #[pyfunction]
     fn get_inheritable(fd: BorrowedFd<'_>, vm: &VirtualMachine) -> PyResult<bool> {
         let flags = fcntl::fcntl(fd, fcntl::FcntlArg::F_GETFD);
@@ -1103,7 +1231,7 @@ pub mod module {
     fn _fchmod(fd: BorrowedFd<'_>, mode: u32, vm: &VirtualMachine) -> PyResult<()> {
         nix::sys::stat::fchmod(
             fd,
-            nix::sys::stat::Mode::from_bits(mode as libc::mode_t).unwrap(),
+            nix::sys::stat::Mode::from_bits_truncate(mode as libc::mode_t),
         )
         .map_err(|err| err.into_pyexception(vm))
     }
@@ -1171,7 +1299,7 @@ pub mod module {
         let path = path.into_cstring(vm)?;
 
         let argv = vm.extract_elements_with(argv.as_ref(), |obj| {
-            PyStrRef::try_from_object(vm, obj)?.to_cstring(vm)
+            OsPath::try_from_object(vm, obj)?.into_cstring(vm)
         })?;
         let argv: Vec<&CStr> = argv.iter().map(|entry| entry.as_c_str()).collect();
 
@@ -1191,13 +1319,13 @@ pub mod module {
     fn execve(
         path: OsPath,
         argv: Either<PyListRef, PyTupleRef>,
-        env: PyDictRef,
+        env: ArgMapping,
         vm: &VirtualMachine,
     ) -> PyResult<()> {
         let path = path.into_cstring(vm)?;
 
         let argv = vm.extract_elements_with(argv.as_ref(), |obj| {
-            PyStrRef::try_from_object(vm, obj)?.to_cstring(vm)
+            OsPath::try_from_object(vm, obj)?.into_cstring(vm)
         })?;
         let argv: Vec<&CStr> = argv.iter().map(|entry| entry.as_c_str()).collect();
 
@@ -1209,6 +1337,7 @@ pub mod module {
             return Err(vm.new_value_error("execve() arg 2 first element cannot be empty"));
         }
 
+        let env = crate::stdlib::os::envobj_to_dict(env, vm)?;
         let env = env
             .into_iter()
             .map(|(k, v)| -> PyResult<_> {
@@ -1217,7 +1346,7 @@ pub mod module {
                     OsPath::try_from_object(vm, v)?.into_bytes(),
                 );
 
-                if memchr::memchr(b'=', &key).is_some() {
+                if key.is_empty() || memchr::memchr(b'=', &key).is_some() {
                     return Err(vm.new_value_error("illegal environment variable name"));
                 }
 
@@ -1471,12 +1600,7 @@ pub mod module {
     }
 
     // cfg from nix
-    #[cfg(any(
-        target_os = "android",
-        target_os = "freebsd",
-        target_os = "linux",
-        target_os = "openbsd"
-    ))]
+    #[cfg(any(target_os = "freebsd", target_os = "linux", target_os = "openbsd"))]
     #[pyfunction]
     fn setresgid(rgid: Gid, egid: Gid, sgid: Gid, vm: &VirtualMachine) -> PyResult<()> {
         unistd::setresgid(rgid, egid, sgid).map_err(|err| err.into_pyexception(vm))
@@ -1490,14 +1614,9 @@ pub mod module {
     }
 
     // cfg from nix
-    #[cfg(any(
-        target_os = "android",
-        target_os = "freebsd",
-        target_os = "linux",
-        target_os = "openbsd"
-    ))]
+    #[cfg(any(target_os = "freebsd", target_os = "linux", target_os = "openbsd"))]
     #[pyfunction]
-    fn initgroups(user_name: PyStrRef, gid: Gid, vm: &VirtualMachine) -> PyResult<()> {
+    fn initgroups(user_name: PyUtf8StrRef, gid: Gid, vm: &VirtualMachine) -> PyResult<()> {
         let user = user_name.to_cstring(vm)?;
         unistd::initgroups(&user, gid).map_err(|err| err.into_pyexception(vm))
     }
@@ -1600,6 +1719,8 @@ pub mod module {
     #[cfg(any(target_os = "linux", target_os = "freebsd", target_os = "macos"))]
     impl PosixSpawnArgs {
         fn spawn(self, spawnp: bool, vm: &VirtualMachine) -> PyResult<libc::pid_t> {
+            use nix::sys::signal;
+
             use crate::TryFromBorrowedObject;
 
             let path = self
@@ -1653,7 +1774,6 @@ pub mod module {
             let mut flags = nix::spawn::PosixSpawnFlags::empty();
 
             if let Some(sigs) = self.setsigdef {
-                use nix::sys::signal;
                 let mut set = signal::SigSet::empty();
                 for sig in sigs.iter(vm)? {
                     let sig = sig?;
@@ -1699,7 +1819,6 @@ pub mod module {
             }
 
             if let Some(sigs) = self.setsigmask {
-                use nix::sys::signal;
                 let mut set = signal::SigSet::empty();
                 for sig in sigs.iter(vm)? {
                     let sig = sig?;
@@ -1738,7 +1857,7 @@ pub mod module {
                 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();
@@ -1834,13 +1953,18 @@ pub mod module {
     fn waitpid(pid: libc::pid_t, opt: i32, vm: &VirtualMachine) -> PyResult<(libc::pid_t, i32)> {
         let mut status = 0;
         loop {
-            let res = unsafe { libc::waitpid(pid, &mut status, opt) };
+            // Capture errno inside the closure: attach_thread (called by
+            // allow_threads on return) can clobber errno via syscalls.
+            let (res, err) = vm.allow_threads(|| {
+                let r = unsafe { libc::waitpid(pid, &mut status, opt) };
+                (r, nix::Error::last_raw())
+            });
             if res == -1 {
-                if nix::Error::last_raw() == libc::EINTR {
+                if err == libc::EINTR {
                     vm.check_signals()?;
                     continue;
                 }
-                return Err(nix::Error::last().into_pyexception(vm));
+                return Err(nix::Error::from_raw(err).into_pyexception(vm));
             }
             return Ok((res, status));
         }
@@ -1989,8 +2113,12 @@ pub mod module {
         target_os = "openbsd"
     ))]
     #[pyfunction]
-    fn getgrouplist(user: PyStrRef, group: u32, vm: &VirtualMachine) -> PyResult<Vec<PyObjectRef>> {
-        let user = CString::new(user.as_str()).unwrap();
+    fn getgrouplist(
+        user: PyUtf8StrRef,
+        group: u32,
+        vm: &VirtualMachine,
+    ) -> PyResult<Vec<PyObjectRef>> {
+        let user = user.to_cstring(vm)?;
         let gid = Gid::from_raw(group);
         let group_ids = unistd::getgrouplist(&user, gid).map_err(|err| err.into_pyexception(vm))?;
         Ok(group_ids
@@ -2023,7 +2151,6 @@ pub mod module {
         who: PriorityWhoType,
         vm: &VirtualMachine,
     ) -> PyResult {
-        use nix::errno::Errno;
         Errno::clear();
         let retval = unsafe { libc::getpriority(which, who) };
         if Errno::last_raw() != 0 {
@@ -2056,7 +2183,9 @@ pub mod module {
             let i = match obj.downcast::<PyInt>() {
                 Ok(int) => int.try_to_primitive(vm)?,
                 Err(obj) => {
-                    let s = PyStrRef::try_from_object(vm, obj)?;
+                    let s = obj.downcast::<PyUtf8Str>().map_err(|_| {
+                        vm.new_type_error("configuration names must be strings or integers")
+                    })?;
                     s.as_str()
                         .parse::<PathconfVar>()
                         .map_err(|_| vm.new_value_error("unrecognized configuration name"))?
@@ -2241,8 +2370,6 @@ pub mod module {
         PathconfName(name): PathconfName,
         vm: &VirtualMachine,
     ) -> PyResult<Option<libc::c_long>> {
-        use nix::errno::Errno;
-
         Errno::clear();
         debug_assert_eq!(Errno::last_raw(), 0);
         let raw = match &path {
@@ -2279,7 +2406,6 @@ pub mod module {
 
     #[pyattr]
     fn pathconf_names(vm: &VirtualMachine) -> PyDictRef {
-        use strum::IntoEnumIterator;
         let pathname = vm.ctx.new_dict();
         for variant in PathconfVar::iter() {
             // get the name of variant as a string to use as the dictionary key
@@ -2450,14 +2576,19 @@ pub mod module {
             let i = match obj.downcast::<PyInt>() {
                 Ok(int) => int.try_to_primitive(vm)?,
                 Err(obj) => {
-                    let s = PyUtf8StrRef::try_from_object(vm, obj)?;
-                    s.as_str().parse::<SysconfVar>().or_else(|_| {
-                        if s.as_str() == "SC_PAGESIZE" {
-                            Ok(SysconfVar::SC_PAGESIZE)
-                        } else {
-                            Err(vm.new_value_error("unrecognized configuration name"))
-                        }
-                    })? as i32
+                    let s = obj.downcast::<PyUtf8Str>().map_err(|_| {
+                        vm.new_type_error("configuration names must be strings or integers")
+                    })?;
+                    {
+                        let name = s.as_str();
+                        name.parse::<SysconfVar>().or_else(|_| {
+                            if name == "SC_PAGESIZE" {
+                                Ok(SysconfVar::SC_PAGESIZE)
+                            } else {
+                                Err(vm.new_value_error("unrecognized configuration name"))
+                            }
+                        })? as i32
+                    }
                 }
             };
             Ok(Self(i))
@@ -2476,7 +2607,6 @@ pub mod module {
 
     #[pyattr]
     fn sysconf_names(vm: &VirtualMachine) -> PyDictRef {
-        use strum::IntoEnumIterator;
         let names = vm.ctx.new_dict();
         for variant in SysconfVar::iter() {
             // get the name of variant as a string to use as the dictionary key
@@ -2618,3 +2748,161 @@ pub mod module {
         Ok(())
     }
 }
+
+#[cfg(any(
+    target_os = "linux",
+    target_os = "netbsd",
+    target_os = "freebsd",
+    target_os = "android"
+))]
+#[pymodule(sub)]
+mod posix_sched {
+    use crate::{
+        AsObject, Py, PyObjectRef, PyResult, VirtualMachine, builtins::PyTupleRef,
+        convert::ToPyObject, function::FuncArgs, types::PyStructSequence,
+    };
+
+    #[derive(FromArgs)]
+    struct SchedParamArgs {
+        #[pyarg(any)]
+        sched_priority: PyObjectRef,
+    }
+
+    #[pystruct_sequence_data]
+    struct SchedParamData {
+        pub sched_priority: PyObjectRef,
+    }
+
+    #[pyattr]
+    #[pystruct_sequence(name = "sched_param", module = "posix", data = "SchedParamData")]
+    struct PySchedParam;
+
+    #[pyclass(with(PyStructSequence))]
+    impl PySchedParam {
+        #[pyslot]
+        fn slot_new(
+            cls: crate::builtins::PyTypeRef,
+            args: FuncArgs,
+            vm: &VirtualMachine,
+        ) -> PyResult {
+            use crate::PyPayload;
+            let SchedParamArgs { sched_priority } = args.bind(vm)?;
+            let items = vec![sched_priority];
+            crate::builtins::PyTuple::new_unchecked(items.into_boxed_slice())
+                .into_ref_with_type(vm, cls)
+                .map(Into::into)
+        }
+
+        #[extend_class]
+        fn extend_pyclass(ctx: &crate::vm::Context, class: &'static Py<crate::builtins::PyType>) {
+            // Override __reduce__ to return (type, (sched_priority,))
+            // instead of the generic structseq (type, ((sched_priority,),)).
+            // The trait's extend_class checks contains_key before setting default.
+            const SCHED_PARAM_REDUCE: crate::function::PyMethodDef =
+                crate::function::PyMethodDef::new_const(
+                    "__reduce__",
+                    |zelf: crate::PyRef<crate::builtins::PyTuple>,
+                     vm: &VirtualMachine|
+                     -> PyTupleRef {
+                        vm.new_tuple((zelf.class().to_owned(), (zelf[0].clone(),)))
+                    },
+                    crate::function::PyMethodFlags::METHOD,
+                    None,
+                );
+            class.set_attr(
+                ctx.intern_str("__reduce__"),
+                SCHED_PARAM_REDUCE.to_proper_method(class, ctx),
+            );
+        }
+    }
+
+    #[cfg(not(target_env = "musl"))]
+    fn convert_sched_param(obj: &PyObjectRef, vm: &VirtualMachine) -> PyResult<libc::sched_param> {
+        use crate::{
+            builtins::{PyInt, PyTuple},
+            class::StaticType,
+        };
+        if !obj.fast_isinstance(PySchedParam::static_type()) {
+            return Err(vm.new_type_error("must have a sched_param object"));
+        }
+        let tuple = obj.downcast_ref::<PyTuple>().unwrap();
+        let priority = tuple[0].clone();
+        let priority_type = priority.class().name().to_string();
+        let value = priority.downcast::<PyInt>().map_err(|_| {
+            vm.new_type_error(format!("an integer is required (got type {priority_type})"))
+        })?;
+        let sched_priority = value.try_to_primitive(vm)?;
+        Ok(libc::sched_param { sched_priority })
+    }
+
+    #[pyfunction]
+    fn sched_getscheduler(pid: libc::pid_t, vm: &VirtualMachine) -> PyResult<i32> {
+        let policy = unsafe { libc::sched_getscheduler(pid) };
+        if policy == -1 {
+            Err(vm.new_last_errno_error())
+        } else {
+            Ok(policy)
+        }
+    }
+
+    #[cfg(not(target_env = "musl"))]
+    #[derive(FromArgs)]
+    struct SchedSetschedulerArgs {
+        #[pyarg(positional)]
+        pid: i32,
+        #[pyarg(positional)]
+        policy: i32,
+        #[pyarg(positional)]
+        sched_param: PyObjectRef,
+    }
+
+    #[cfg(not(target_env = "musl"))]
+    #[pyfunction]
+    fn sched_setscheduler(args: SchedSetschedulerArgs, vm: &VirtualMachine) -> PyResult<i32> {
+        let libc_sched_param = convert_sched_param(&args.sched_param, vm)?;
+        let policy = unsafe { libc::sched_setscheduler(args.pid, args.policy, &libc_sched_param) };
+        if policy == -1 {
+            Err(vm.new_last_errno_error())
+        } else {
+            Ok(policy)
+        }
+    }
+
+    #[pyfunction]
+    fn sched_getparam(pid: libc::pid_t, vm: &VirtualMachine) -> PyResult<PyTupleRef> {
+        let param = unsafe {
+            let mut param = core::mem::MaybeUninit::uninit();
+            if -1 == libc::sched_getparam(pid, param.as_mut_ptr()) {
+                return Err(vm.new_last_errno_error());
+            }
+            param.assume_init()
+        };
+        Ok(PySchedParam::from_data(
+            SchedParamData {
+                sched_priority: param.sched_priority.to_pyobject(vm),
+            },
+            vm,
+        ))
+    }
+
+    #[cfg(not(target_env = "musl"))]
+    #[derive(FromArgs)]
+    struct SchedSetParamArgs {
+        #[pyarg(positional)]
+        pid: i32,
+        #[pyarg(positional)]
+        sched_param: PyObjectRef,
+    }
+
+    #[cfg(not(target_env = "musl"))]
+    #[pyfunction]
+    fn sched_setparam(args: SchedSetParamArgs, vm: &VirtualMachine) -> PyResult<i32> {
+        let libc_sched_param = convert_sched_param(&args.sched_param, vm)?;
+        let ret = unsafe { libc::sched_setparam(args.pid, &libc_sched_param) };
+        if ret == -1 {
+            Err(vm.new_last_errno_error())
+        } else {
+            Ok(ret)
+        }
+    }
+}
diff --git a/crates/vm/src/stdlib/sys.rs b/crates/vm/src/stdlib/sys.rs
index 9c0f84650bc..72379494ddb 100644
--- a/crates/vm/src/stdlib/sys.rs
+++ b/crates/vm/src/stdlib/sys.rs
@@ -1,5 +1,9 @@
-use crate::{Py, PyResult, VirtualMachine, builtins::PyModule, convert::ToPyObject};
+pub(crate) mod monitoring;
 
+use crate::{Py, PyPayload, PyResult, VirtualMachine, builtins::PyModule, convert::ToPyObject};
+
+#[cfg(all(not(feature = "host_env"), feature = "stdio"))]
+pub(crate) use sys::SandboxStdio;
 pub(crate) use sys::{DOC, MAXSIZE, RUST_MULTIARCH, UnraisableHookArgsData, module_def, multiarch};
 
 #[pymodule(name = "_jit")]
@@ -29,19 +33,19 @@ mod sys_jit {
 #[pymodule]
 mod sys {
     use crate::{
-        AsObject, PyObject, PyObjectRef, PyRef, PyRefExact, PyResult,
+        AsObject, PyObject, PyObjectRef, PyPayload, PyRef, PyRefExact, PyResult,
         builtins::{
-            PyBaseExceptionRef, PyDictRef, PyFrozenSet, PyNamespace, PyStr, PyStrRef, PyTupleRef,
-            PyTypeRef,
+            PyBaseExceptionRef, PyDictRef, PyFrozenSet, PyNamespace, PyStr, PyStrRef, PyTuple,
+            PyTupleRef, PyTypeRef, PyUtf8StrRef,
         },
         common::{
             ascii,
             hash::{PyHash, PyUHash},
         },
         convert::ToPyObject,
-        frame::FrameRef,
+        frame::{Frame, FrameRef},
         function::{FuncArgs, KwArgs, OptionalArg, PosArgs},
-        stdlib::{builtins, warnings::warn},
+        stdlib::{_warnings::warn, builtins},
         types::PyStructSequence,
         version,
         vm::{Settings, VirtualMachine},
@@ -50,7 +54,7 @@ mod sys {
     use num_traits::ToPrimitive;
     use std::{
         env::{self, VarError},
-        io::Read,
+        io::{IsTerminal, Read, Write},
     };
 
     #[cfg(windows)]
@@ -71,6 +75,152 @@ mod sys {
         RUST_MULTIARCH.replace("-unknown", "")
     }
 
+    #[pymodule(name = "monitoring", with(super::monitoring::sys_monitoring))]
+    pub(super) mod monitoring {}
+
+    #[pyclass(no_attr, name = "_BootstrapStderr")]
+    #[derive(Debug, PyPayload)]
+    pub(super) struct BootstrapStderr;
+
+    #[pyclass]
+    impl BootstrapStderr {
+        #[pymethod]
+        fn write(&self, s: PyStrRef) -> PyResult<usize> {
+            let bytes = s.as_bytes();
+            let _ = std::io::stderr().write_all(bytes);
+            Ok(bytes.len())
+        }
+
+        #[pymethod]
+        fn flush(&self) -> PyResult<()> {
+            let _ = std::io::stderr().flush();
+            Ok(())
+        }
+    }
+
+    /// Lightweight stdio wrapper for sandbox mode (no host_env).
+    /// Directly uses Rust's std::io for stdin/stdout/stderr without FileIO.
+    #[pyclass(no_attr, name = "_SandboxStdio")]
+    #[derive(Debug, PyPayload)]
+    pub struct SandboxStdio {
+        pub fd: i32,
+        pub name: String,
+        pub mode: String,
+    }
+
+    #[pyclass]
+    impl SandboxStdio {
+        #[pymethod]
+        fn write(&self, s: PyStrRef, vm: &VirtualMachine) -> PyResult<usize> {
+            if self.fd == 0 {
+                return Err(vm.new_os_error("not writable".to_owned()));
+            }
+            let bytes = s.as_bytes();
+            if self.fd == 2 {
+                std::io::stderr()
+                    .write_all(bytes)
+                    .map_err(|e| vm.new_os_error(e.to_string()))?;
+            } else {
+                std::io::stdout()
+                    .write_all(bytes)
+                    .map_err(|e| vm.new_os_error(e.to_string()))?;
+            }
+            Ok(bytes.len())
+        }
+
+        #[pymethod]
+        fn readline(&self, size: OptionalArg<isize>, vm: &VirtualMachine) -> PyResult<String> {
+            if self.fd != 0 {
+                return Err(vm.new_os_error("not readable".to_owned()));
+            }
+            let size = size.unwrap_or(-1);
+            if size == 0 {
+                return Ok(String::new());
+            }
+            let mut line = String::new();
+            std::io::stdin()
+                .read_line(&mut line)
+                .map_err(|e| vm.new_os_error(e.to_string()))?;
+            if size > 0 {
+                line.truncate(size as usize);
+            }
+            Ok(line)
+        }
+
+        #[pymethod]
+        fn flush(&self, vm: &VirtualMachine) -> PyResult<()> {
+            match self.fd {
+                1 => {
+                    std::io::stdout()
+                        .flush()
+                        .map_err(|e| vm.new_os_error(e.to_string()))?;
+                }
+                2 => {
+                    std::io::stderr()
+                        .flush()
+                        .map_err(|e| vm.new_os_error(e.to_string()))?;
+                }
+                _ => {}
+            }
+            Ok(())
+        }
+
+        #[pymethod]
+        fn fileno(&self) -> i32 {
+            self.fd
+        }
+
+        #[pymethod]
+        fn isatty(&self) -> bool {
+            match self.fd {
+                0 => std::io::stdin().is_terminal(),
+                1 => std::io::stdout().is_terminal(),
+                2 => std::io::stderr().is_terminal(),
+                _ => false,
+            }
+        }
+
+        #[pymethod]
+        fn readable(&self) -> bool {
+            self.fd == 0
+        }
+
+        #[pymethod]
+        fn writable(&self) -> bool {
+            self.fd == 1 || self.fd == 2
+        }
+
+        #[pygetset]
+        fn closed(&self) -> bool {
+            false
+        }
+
+        #[pygetset]
+        fn encoding(&self) -> String {
+            "utf-8".to_owned()
+        }
+
+        #[pygetset]
+        fn errors(&self) -> String {
+            if self.fd == 2 {
+                "backslashreplace"
+            } else {
+                "strict"
+            }
+            .to_owned()
+        }
+
+        #[pygetset(name = "name")]
+        fn name_prop(&self) -> String {
+            self.name.clone()
+        }
+
+        #[pygetset(name = "mode")]
+        fn mode_prop(&self) -> String {
+            self.mode.clone()
+        }
+    }
+
     #[pyattr(name = "_rustpython_debugbuild")]
     const RUSTPYTHON_DEBUGBUILD: bool = cfg!(debug_assertions);
 
@@ -644,8 +794,22 @@ mod sys {
 
     #[pyfunction]
     fn exit(code: OptionalArg<PyObjectRef>, vm: &VirtualMachine) -> PyResult {
-        let code = code.unwrap_or_none(vm);
-        Err(vm.new_exception(vm.ctx.exceptions.system_exit.to_owned(), vec![code]))
+        let status = code.unwrap_or_none(vm);
+        let args = if let Some(status_tuple) = status.downcast_ref::<PyTuple>() {
+            status_tuple.as_slice().to_vec()
+        } else {
+            vec![status]
+        };
+        let exc = vm.invoke_exception(vm.ctx.exceptions.system_exit.to_owned(), args)?;
+        Err(exc)
+    }
+
+    #[pyfunction]
+    fn call_tracing(func: PyObjectRef, args: PyTupleRef, vm: &VirtualMachine) -> PyResult {
+        // CPython temporarily enables tracing state around this call.
+        // RustPython does not currently model the full C-level tracing toggles,
+        // but call semantics (func(*args)) are matched.
+        func.call(PosArgs::new(args.as_slice().to_vec()), vm)
     }
 
     #[pyfunction]
@@ -678,14 +842,22 @@ mod sys {
         vm: &VirtualMachine,
     ) -> PyResult<()> {
         let stderr = super::get_stderr(vm)?;
-
-        // Try to normalize the exception. If it fails, print error to stderr like CPython
         match vm.normalize_exception(exc_type.clone(), exc_val.clone(), exc_tb) {
-            Ok(exc) => vm.write_exception(&mut crate::py_io::PyWriter(stderr, vm), &exc),
+            Ok(exc) => {
+                // PyErr_Display: try traceback._print_exception_bltin first
+                if let Ok(tb_mod) = vm.import("traceback", 0)
+                    && let Ok(print_exc_builtin) = tb_mod.get_attr("_print_exception_bltin", vm)
+                    && print_exc_builtin
+                        .call((exc.as_object().to_owned(),), vm)
+                        .is_ok()
+                {
+                    return Ok(());
+                }
+                // Fallback to Rust-level exception printing
+                vm.write_exception(&mut crate::py_io::PyWriter(stderr, vm), &exc)
+            }
             Err(_) => {
-                // CPython prints error message to stderr instead of raising exception
                 let type_name = exc_val.class().name();
-                // TODO: fix error message
                 let msg = format!(
                     "TypeError: print_exception(): Exception expected for value, {type_name} found\n"
                 );
@@ -807,7 +979,7 @@ mod sys {
     }
 
     #[pyfunction]
-    fn getfilesystemencodeerrors(vm: &VirtualMachine) -> PyStrRef {
+    fn getfilesystemencodeerrors(vm: &VirtualMachine) -> PyUtf8StrRef {
         vm.fs_encode_errors().to_owned()
     }
 
@@ -819,12 +991,14 @@ mod sys {
     #[pyfunction]
     fn _getframe(offset: OptionalArg<usize>, vm: &VirtualMachine) -> PyResult<FrameRef> {
         let offset = offset.into_option().unwrap_or(0);
-        if offset > vm.frames.borrow().len() - 1 {
+        let frames = vm.frames.borrow();
+        if offset >= frames.len() {
             return Err(vm.new_value_error("call stack is not deep enough"));
         }
-        let idx = vm.frames.borrow().len() - offset - 1;
-        let frame = &vm.frames.borrow()[idx];
-        Ok(frame.clone())
+        let idx = frames.len() - offset - 1;
+        // SAFETY: the FrameRef is alive on the call stack while it's in the Vec
+        let py: &crate::Py<Frame> = unsafe { frames[idx].as_ref() };
+        Ok(py.to_owned())
     }
 
     #[pyfunction]
@@ -832,15 +1006,19 @@ mod sys {
         let depth = depth.into_option().unwrap_or(0);
 
         // Get the frame at the specified depth
-        if depth > vm.frames.borrow().len() - 1 {
-            return Ok(vm.ctx.none());
-        }
-
-        let idx = vm.frames.borrow().len() - depth - 1;
-        let frame = &vm.frames.borrow()[idx];
+        let func_obj = {
+            let frames = vm.frames.borrow();
+            if depth >= frames.len() {
+                return Ok(vm.ctx.none());
+            }
+            let idx = frames.len() - depth - 1;
+            // SAFETY: the FrameRef is alive on the call stack while it's in the Vec
+            let frame: &crate::Py<Frame> = unsafe { frames[idx].as_ref() };
+            frame.func_obj.clone()
+        };
 
         // If the frame has a function object, return its __module__ attribute
-        if let Some(func_obj) = &frame.func_obj {
+        if let Some(func_obj) = func_obj {
             match func_obj.get_attr(identifier!(vm, __module__), vm) {
                 Ok(module) => Ok(module),
                 Err(_) => {
@@ -859,7 +1037,7 @@ mod sys {
     #[pyfunction]
     fn _current_frames(vm: &VirtualMachine) -> PyResult<PyDictRef> {
         use crate::AsObject;
-        use crate::stdlib::thread::get_all_current_frames;
+        use crate::stdlib::_thread::get_all_current_frames;
 
         let frames = get_all_current_frames(vm);
         let dict = vm.ctx.new_dict();
@@ -872,6 +1050,33 @@ mod sys {
         Ok(dict)
     }
 
+    /// Return a dictionary mapping each thread's identifier to its currently
+    /// active exception, or None if no exception is active.
+    #[cfg(feature = "threading")]
+    #[pyfunction]
+    fn _current_exceptions(vm: &VirtualMachine) -> PyResult<PyDictRef> {
+        use crate::AsObject;
+        use crate::vm::thread::get_all_current_exceptions;
+
+        let dict = vm.ctx.new_dict();
+        for (thread_id, exc) in get_all_current_exceptions(vm) {
+            let key = vm.ctx.new_int(thread_id);
+            let value = exc.map_or_else(|| vm.ctx.none(), |e| e.into());
+            dict.set_item(key.as_object(), value, vm)?;
+        }
+
+        Ok(dict)
+    }
+
+    #[cfg(not(feature = "threading"))]
+    #[pyfunction]
+    fn _current_exceptions(vm: &VirtualMachine) -> PyResult<PyDictRef> {
+        let dict = vm.ctx.new_dict();
+        let key = vm.ctx.new_int(0);
+        dict.set_item(key.as_object(), vm.topmost_exception().to_pyobject(vm), vm)?;
+        Ok(dict)
+    }
+
     /// Stub for non-threading builds - returns empty dict
     #[cfg(not(feature = "threading"))]
     #[pyfunction]
@@ -908,7 +1113,7 @@ mod sys {
 
             // Get the size of the version information block
             let ver_block_size =
-                GetFileVersionInfoSizeW(kernel32_path.as_ptr(), std::ptr::null_mut());
+                GetFileVersionInfoSizeW(kernel32_path.as_ptr(), core::ptr::null_mut());
             if ver_block_size == 0 {
                 return Err(std::io::Error::last_os_error());
             }
@@ -928,7 +1133,7 @@ mod sys {
             // Prepare an empty sub-block string (L"") as required by VerQueryValueW
             let sub_block: Vec<u16> = std::ffi::OsStr::new("").to_wide_with_nul();
 
-            let mut ffi_ptr: *mut VS_FIXEDFILEINFO = std::ptr::null_mut();
+            let mut ffi_ptr: *mut VS_FIXEDFILEINFO = core::ptr::null_mut();
             let mut ffi_len: u32 = 0;
             if VerQueryValueW(
                 ver_block.as_ptr() as *const _,
@@ -960,8 +1165,8 @@ mod sys {
             GetVersionExW, OSVERSIONINFOEXW, OSVERSIONINFOW,
         };
 
-        let mut version: OSVERSIONINFOEXW = unsafe { std::mem::zeroed() };
-        version.dwOSVersionInfoSize = std::mem::size_of::<OSVERSIONINFOEXW>() as u32;
+        let mut version: OSVERSIONINFOEXW = unsafe { core::mem::zeroed() };
+        version.dwOSVersionInfoSize = core::mem::size_of::<OSVERSIONINFOEXW>() as u32;
         let result = unsafe {
             let os_vi = &mut version as *mut OSVERSIONINFOEXW as *mut OSVERSIONINFOW;
             // SAFETY: GetVersionExW accepts a pointer of OSVERSIONINFOW, but windows-sys crate's type currently doesn't allow to do so.
@@ -1050,7 +1255,7 @@ mod sys {
         // 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();
+            let module = module_str.as_wtf8();
             if module != "builtins" && module != "__main__" {
                 write!(stderr, "{}.", module);
             }
@@ -1061,7 +1266,7 @@ mod sys {
         // Print qualname
         let qualname = unraisable.exc_type.__qualname__(vm);
         if let Ok(qualname_str) = qualname.downcast::<PyStr>() {
-            write!(stderr, "{}", qualname_str.as_str());
+            write!(stderr, "{}", qualname_str.as_wtf8());
         } else {
             write!(stderr, "{}", unraisable.exc_type.name());
         }
@@ -1070,7 +1275,7 @@ mod sys {
         if !vm.is_none(&unraisable.exc_value) {
             write!(stderr, ": ");
             if let Ok(str) = unraisable.exc_value.str(vm) {
-                write!(stderr, "{}", str.to_str().unwrap_or("<str with surrogate>"));
+                write!(stderr, "{}", str.as_wtf8());
             } else {
                 write!(stderr, "<exception str() failed>");
             }
@@ -1225,7 +1430,7 @@ mod sys {
 
         // 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()));
+            return Err(vm.new_type_error("argument is immutable"));
         }
 
         let mut attributes = type_obj.attributes.write();
@@ -1365,10 +1570,6 @@ 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,
-        /// -X context_aware_warnings, whether warnings are context aware
-        context_aware_warnings: bool,
     }
 
     impl FlagsData {
@@ -1388,17 +1589,19 @@ mod sys {
                 hash_randomization: settings.hash_seed.is_none() as u8,
                 isolated: settings.isolated as u8,
                 dev_mode: settings.dev_mode,
-                utf8_mode: settings.utf8_mode,
+                utf8_mode: if settings.utf8_mode < 0 {
+                    1
+                } else {
+                    settings.utf8_mode as u8
+                },
                 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,
-                context_aware_warnings: settings.context_aware_warnings,
             }
         }
     }
 
-    #[pystruct_sequence(name = "flags", module = "sys", data = "FlagsData", no_attr)]
+    #[pystruct_sequence(name = "flags", data = "FlagsData", no_attr)]
     pub(super) struct PyFlags;
 
     #[pyclass(with(PyStructSequence))]
@@ -1407,6 +1610,16 @@ mod sys {
         fn slot_new(_cls: PyTypeRef, _args: FuncArgs, vm: &VirtualMachine) -> PyResult {
             Err(vm.new_type_error("cannot create 'sys.flags' instances"))
         }
+
+        #[pygetset]
+        fn context_aware_warnings(&self, vm: &VirtualMachine) -> bool {
+            vm.state.config.settings.context_aware_warnings
+        }
+
+        #[pygetset]
+        fn thread_inherit_context(&self, vm: &VirtualMachine) -> bool {
+            vm.state.config.settings.thread_inherit_context
+        }
     }
 
     #[cfg(feature = "threading")]
@@ -1420,7 +1633,7 @@ mod sys {
     #[cfg(feature = "threading")]
     impl ThreadInfoData {
         const INFO: Self = Self {
-            name: crate::stdlib::thread::_thread::PYTHREAD_NAME,
+            name: crate::stdlib::_thread::_thread::PYTHREAD_NAME,
             // As I know, there's only way to use lock as "Mutex" in Rust
             // with satisfying python document spec.
             lock: Some("mutex+cond"),
@@ -1576,10 +1789,15 @@ mod sys {
         build: u32,
         platform: u32,
         service_pack: String,
+        #[pystruct_sequence(skip)]
         service_pack_major: u16,
+        #[pystruct_sequence(skip)]
         service_pack_minor: u16,
+        #[pystruct_sequence(skip)]
         suite_mask: u16,
+        #[pystruct_sequence(skip)]
         product_type: u8,
+        #[pystruct_sequence(skip)]
         platform_version: (u32, u32, u32),
     }
 
@@ -1589,7 +1807,12 @@ mod sys {
 
     #[cfg(windows)]
     #[pyclass(with(PyStructSequence))]
-    impl PyWindowsVersion {}
+    impl PyWindowsVersion {
+        #[pyslot]
+        fn slot_new(_cls: PyTypeRef, _args: FuncArgs, vm: &VirtualMachine) -> PyResult {
+            Err(vm.new_type_error("cannot create 'sys.getwindowsversion' instances"))
+        }
+    }
 
     #[derive(Debug)]
     #[pystruct_sequence_data(try_from_object)]
@@ -1631,6 +1854,14 @@ pub(crate) fn init_module(vm: &VirtualMachine, module: &Py<PyModule>, builtins:
     });
 }
 
+pub(crate) fn set_bootstrap_stderr(vm: &VirtualMachine) -> PyResult<()> {
+    let stderr = sys::BootstrapStderr.into_ref(&vm.ctx);
+    let stderr_obj: crate::PyObjectRef = stderr.into();
+    vm.sys_module.set_attr("stderr", stderr_obj.clone(), vm)?;
+    vm.sys_module.set_attr("__stderr__", stderr_obj, vm)?;
+    Ok(())
+}
+
 /// Similar to PySys_WriteStderr in CPython.
 ///
 /// # Usage
diff --git a/crates/vm/src/stdlib/sys/monitoring.rs b/crates/vm/src/stdlib/sys/monitoring.rs
new file mode 100644
index 00000000000..367038658c6
--- /dev/null
+++ b/crates/vm/src/stdlib/sys/monitoring.rs
@@ -0,0 +1,1194 @@
+use crate::{
+    AsObject, PyObjectRef, PyPayload, PyRef, PyResult, VirtualMachine,
+    builtins::{PyCode, PyDictRef, PyNamespace, PyUtf8StrRef, code::CoMonitoringData},
+    function::FuncArgs,
+};
+use core::sync::atomic::Ordering;
+use crossbeam_utils::atomic::AtomicCell;
+use std::collections::{HashMap, HashSet};
+
+pub const TOOL_LIMIT: usize = 6;
+const EVENTS_COUNT: usize = 19;
+const LOCAL_EVENTS_COUNT: usize = 11;
+const UNGROUPED_EVENTS_COUNT: usize = 18;
+
+// Event bit positions
+bitflags::bitflags! {
+    #[derive(Copy, Clone, Debug, PartialEq, Eq)]
+    pub struct MonitoringEvents: u32 {
+        const PY_START           = 1 << 0;
+        const PY_RESUME          = 1 << 1;
+        const PY_RETURN          = 1 << 2;
+        const PY_YIELD           = 1 << 3;
+        const CALL               = 1 << 4;
+        const LINE               = 1 << 5;
+        const INSTRUCTION        = 1 << 6;
+        const JUMP               = 1 << 7;
+        const BRANCH_LEFT        = 1 << 8;
+        const BRANCH_RIGHT       = 1 << 9;
+        const STOP_ITERATION     = 1 << 10;
+        const RAISE              = 1 << 11;
+        const EXCEPTION_HANDLED  = 1 << 12;
+        const PY_UNWIND          = 1 << 13;
+        const PY_THROW           = 1 << 14;
+        const RERAISE            = 1 << 15;
+        const C_RETURN           = 1 << 16;
+        const C_RAISE            = 1 << 17;
+        const BRANCH             = 1 << 18;
+    }
+}
+
+// Re-export as plain u32 constants for use in frame.rs hot-path checks
+pub const EVENT_PY_START: u32 = MonitoringEvents::PY_START.bits();
+pub const EVENT_PY_RESUME: u32 = MonitoringEvents::PY_RESUME.bits();
+pub const EVENT_PY_RETURN: u32 = MonitoringEvents::PY_RETURN.bits();
+pub const EVENT_PY_YIELD: u32 = MonitoringEvents::PY_YIELD.bits();
+pub const EVENT_CALL: u32 = MonitoringEvents::CALL.bits();
+pub const EVENT_LINE: u32 = MonitoringEvents::LINE.bits();
+pub const EVENT_INSTRUCTION: u32 = MonitoringEvents::INSTRUCTION.bits();
+pub const EVENT_JUMP: u32 = MonitoringEvents::JUMP.bits();
+pub const EVENT_BRANCH_LEFT: u32 = MonitoringEvents::BRANCH_LEFT.bits();
+pub const EVENT_BRANCH_RIGHT: u32 = MonitoringEvents::BRANCH_RIGHT.bits();
+pub const EVENT_RAISE: u32 = MonitoringEvents::RAISE.bits();
+pub const EVENT_EXCEPTION_HANDLED: u32 = MonitoringEvents::EXCEPTION_HANDLED.bits();
+pub const EVENT_PY_UNWIND: u32 = MonitoringEvents::PY_UNWIND.bits();
+pub const EVENT_C_RETURN: u32 = MonitoringEvents::C_RETURN.bits();
+const EVENT_C_RAISE: u32 = MonitoringEvents::C_RAISE.bits();
+pub const EVENT_STOP_ITERATION: u32 = MonitoringEvents::STOP_ITERATION.bits();
+pub const EVENT_PY_THROW: u32 = MonitoringEvents::PY_THROW.bits();
+const EVENT_BRANCH: u32 = MonitoringEvents::BRANCH.bits();
+pub const EVENT_RERAISE: u32 = MonitoringEvents::RERAISE.bits();
+const EVENT_C_RETURN_MASK: u32 = EVENT_C_RETURN | EVENT_C_RAISE;
+
+const EVENT_NAMES: [&str; EVENTS_COUNT] = [
+    "PY_START",
+    "PY_RESUME",
+    "PY_RETURN",
+    "PY_YIELD",
+    "CALL",
+    "LINE",
+    "INSTRUCTION",
+    "JUMP",
+    "BRANCH_LEFT",
+    "BRANCH_RIGHT",
+    "STOP_ITERATION",
+    "RAISE",
+    "EXCEPTION_HANDLED",
+    "PY_UNWIND",
+    "PY_THROW",
+    "RERAISE",
+    "C_RETURN",
+    "C_RAISE",
+    "BRANCH",
+];
+
+/// Interpreter-level monitoring state, shared by all threads.
+pub struct MonitoringState {
+    pub tool_names: [Option<String>; TOOL_LIMIT],
+    pub global_events: [u32; TOOL_LIMIT],
+    pub local_events: HashMap<(usize, usize), u32>,
+    pub callbacks: HashMap<(usize, usize), PyObjectRef>,
+    /// Per-instruction disabled tools: (code_id, offset, tool)
+    pub disabled: HashSet<(usize, usize, usize)>,
+    /// Cached MISSING sentinel singleton
+    pub missing: Option<PyObjectRef>,
+    /// Cached DISABLE sentinel singleton
+    pub disable: Option<PyObjectRef>,
+}
+
+impl Default for MonitoringState {
+    fn default() -> Self {
+        Self {
+            tool_names: Default::default(),
+            global_events: [0; TOOL_LIMIT],
+            local_events: HashMap::new(),
+            callbacks: HashMap::new(),
+            disabled: HashSet::new(),
+            missing: None,
+            disable: None,
+        }
+    }
+}
+
+impl MonitoringState {
+    /// Compute the OR of all tools' global_events + local_events.
+    /// This is used for the fast-path atomic mask to skip monitoring
+    /// when no events are registered at all.
+    pub fn combined_events(&self) -> u32 {
+        let global = self.global_events.iter().fold(0, |acc, &e| acc | e);
+        let local = self.local_events.values().fold(0, |acc, &e| acc | e);
+        global | local
+    }
+
+    /// Compute the events that apply to a specific code object:
+    /// global events OR'd with local events registered for that code.
+    /// This prevents events like INSTRUCTION that are local to one code
+    /// from being applied to unrelated code objects.
+    pub fn events_for_code(&self, code_id: usize) -> u32 {
+        let global = self.global_events.iter().fold(0, |acc, &e| acc | e);
+        let local = self
+            .local_events
+            .iter()
+            .filter(|((_, cid), _)| *cid == code_id)
+            .fold(0, |acc, (_, &e)| acc | e);
+        global | local
+    }
+}
+
+/// Global atomic mask: OR of all tools' events. Checked in the hot path
+/// to skip monitoring overhead when no events are registered.
+/// Lives in PyGlobalState alongside the PyMutex<MonitoringState>.
+pub type MonitoringEventsMask = AtomicCell<u32>;
+
+/// Get the MISSING sentinel, creating it if necessary.
+pub fn get_missing(vm: &VirtualMachine) -> PyObjectRef {
+    let mut state = vm.state.monitoring.lock();
+    if let Some(ref m) = state.missing {
+        m.clone()
+    } else {
+        let m: PyObjectRef = sys_monitoring::MonitoringSentinel.into_ref(&vm.ctx).into();
+        state.missing = Some(m.clone());
+        m
+    }
+}
+
+/// Get the DISABLE sentinel, creating it if necessary.
+pub fn get_disable(vm: &VirtualMachine) -> PyObjectRef {
+    let mut state = vm.state.monitoring.lock();
+    if let Some(ref d) = state.disable {
+        d.clone()
+    } else {
+        let d: PyObjectRef = sys_monitoring::MonitoringSentinel.into_ref(&vm.ctx).into();
+        state.disable = Some(d.clone());
+        d
+    }
+}
+
+fn check_valid_tool(tool_id: i32, vm: &VirtualMachine) -> PyResult<usize> {
+    if !(0..TOOL_LIMIT as i32).contains(&tool_id) {
+        return Err(vm.new_value_error(format!("invalid tool {tool_id} (must be between 0 and 5)")));
+    }
+    Ok(tool_id as usize)
+}
+
+fn check_tool_in_use(tool: usize, vm: &VirtualMachine) -> PyResult<()> {
+    let state = vm.state.monitoring.lock();
+    if state.tool_names[tool].is_some() {
+        Ok(())
+    } else {
+        Err(vm.new_value_error(format!("tool {tool} is not in use")))
+    }
+}
+
+fn parse_single_event(event: i32, vm: &VirtualMachine) -> PyResult<usize> {
+    let event = u32::try_from(event)
+        .map_err(|_| vm.new_value_error("The callback can only be set for one event at a time"))?;
+    if event.count_ones() != 1 {
+        return Err(vm.new_value_error("The callback can only be set for one event at a time"));
+    }
+    let event_id = event.trailing_zeros() as usize;
+    if event_id >= EVENTS_COUNT {
+        return Err(vm.new_value_error(format!("invalid event {event}")));
+    }
+    Ok(event_id)
+}
+
+fn normalize_event_set(event_set: i32, local: bool, vm: &VirtualMachine) -> PyResult<u32> {
+    let kind = if local {
+        "local event set"
+    } else {
+        "event set"
+    };
+    if event_set < 0 {
+        return Err(vm.new_value_error(format!("invalid {kind} 0x{event_set:x}")));
+    }
+
+    let mut event_set = event_set as u32;
+    if event_set >= (1 << EVENTS_COUNT) {
+        return Err(vm.new_value_error(format!("invalid {kind} 0x{event_set:x}")));
+    }
+
+    if (event_set & EVENT_C_RETURN_MASK) != 0 && (event_set & EVENT_CALL) != EVENT_CALL {
+        return Err(vm.new_value_error("cannot set C_RETURN or C_RAISE events independently"));
+    }
+
+    event_set &= !EVENT_C_RETURN_MASK;
+
+    if (event_set & EVENT_BRANCH) != 0 {
+        event_set &= !EVENT_BRANCH;
+        event_set |= EVENT_BRANCH_LEFT | EVENT_BRANCH_RIGHT;
+    }
+
+    if local && event_set >= (1 << LOCAL_EVENTS_COUNT) {
+        return Err(vm.new_value_error(format!("invalid local event set 0x{event_set:x}")));
+    }
+
+    Ok(event_set)
+}
+
+/// Rewrite a code object's bytecode in-place with layered instrumentation.
+///
+/// Three layers (outermost first):
+/// 1. INSTRUMENTED_LINE — wraps line-start instructions (stores original in side-table)
+/// 2. INSTRUMENTED_INSTRUCTION — wraps all traceable instructions (stores original in side-table)
+/// 3. Regular INSTRUMENTED_* — direct 1:1 opcode swap (no side-table needed)
+///
+/// De-instrumentation peels layers in reverse order.
+pub fn instrument_code(code: &PyCode, events: u32) {
+    use rustpython_compiler_core::bytecode::{self, Instruction};
+
+    let len = code.code.instructions.len();
+    let mut monitoring_data = code.monitoring_data.lock();
+
+    // === Phase 1-3: De-instrument all layers (outermost first) ===
+
+    // Phase 1: Remove INSTRUMENTED_LINE → restore from side-table
+    if let Some(data) = monitoring_data.as_mut() {
+        for i in 0..len {
+            if data.line_opcodes[i] != 0 {
+                let original = Instruction::try_from(data.line_opcodes[i])
+                    .expect("invalid opcode in line side-table");
+                unsafe {
+                    code.code.instructions.replace_op(i, original);
+                }
+                data.line_opcodes[i] = 0;
+            }
+        }
+    }
+
+    // Phase 2: Remove INSTRUMENTED_INSTRUCTION → restore from side-table
+    if let Some(data) = monitoring_data.as_mut() {
+        for i in 0..len {
+            if data.per_instruction_opcodes[i] != 0 {
+                let original = Instruction::try_from(data.per_instruction_opcodes[i])
+                    .expect("invalid opcode in instruction side-table");
+                unsafe {
+                    code.code.instructions.replace_op(i, original);
+                }
+                data.per_instruction_opcodes[i] = 0;
+            }
+        }
+    }
+
+    // Phase 3: Remove regular INSTRUMENTED_* and specialized opcodes → restore base opcodes.
+    // Also clear all CACHE entries so specialization starts fresh.
+    {
+        let mut i = 0;
+        while i < len {
+            let op = code.code.instructions[i].op;
+            let base_op = op.deoptimize();
+            if u8::from(base_op) != u8::from(op) {
+                unsafe {
+                    code.code.instructions.replace_op(i, base_op);
+                }
+            }
+            let caches = base_op.cache_entries();
+            // Zero all CACHE entries (the op+arg bytes may have been overwritten
+            // by specialization with arbitrary data like pointers).
+            for c in 1..=caches {
+                if i + c < len {
+                    unsafe {
+                        code.code.instructions.write_cache_u16(i + c, 0);
+                    }
+                }
+            }
+            i += 1 + caches;
+        }
+    }
+
+    // All opcodes are now base opcodes.
+
+    if events == 0 {
+        *monitoring_data = None;
+        return;
+    }
+
+    // === Phase 4-6: Re-instrument (innermost first) ===
+
+    // Ensure monitoring data exists
+    if monitoring_data.is_none() {
+        *monitoring_data = Some(CoMonitoringData {
+            line_opcodes: vec![0u8; len],
+            per_instruction_opcodes: vec![0u8; len],
+        });
+    }
+    let data = monitoring_data.as_mut().unwrap();
+    // Resize if code length changed (shouldn't happen, but be safe)
+    data.line_opcodes.resize(len, 0);
+    data.per_instruction_opcodes.resize(len, 0);
+
+    // Find _co_firsttraceable: index of first RESUME instruction
+    let first_traceable = code
+        .code
+        .instructions
+        .iter()
+        .position(|u| matches!(u.op, Instruction::Resume { .. } | Instruction::ResumeCheck))
+        .unwrap_or(0);
+
+    // Phase 4: Place regular INSTRUMENTED_* opcodes
+    for i in 0..len {
+        let op = code.code.instructions[i].op;
+        if let Some(instrumented) = op.to_instrumented() {
+            unsafe {
+                code.code.instructions.replace_op(i, instrumented);
+            }
+        }
+    }
+
+    // Phase 5: Place INSTRUMENTED_INSTRUCTION (if EVENT_INSTRUCTION is active)
+    if events & EVENT_INSTRUCTION != 0 {
+        for i in first_traceable..len {
+            let op = code.code.instructions[i].op;
+            // Skip ExtendedArg
+            if matches!(op, Instruction::ExtendedArg) {
+                continue;
+            }
+            // Excluded: RESUME, END_FOR, CACHE (and their instrumented variants)
+            let base = op.to_base().map_or(op, |b| b);
+            if matches!(
+                base,
+                Instruction::Resume { .. } | Instruction::EndFor | Instruction::Cache
+            ) {
+                continue;
+            }
+            // Store current opcode (may already be INSTRUMENTED_*) and replace
+            data.per_instruction_opcodes[i] = u8::from(op);
+            unsafe {
+                code.code
+                    .instructions
+                    .replace_op(i, Instruction::InstrumentedInstruction);
+            }
+        }
+    }
+
+    // Phase 6: Place INSTRUMENTED_LINE (if EVENT_LINE is active)
+    // Mirrors CPython's initialize_lines: first determine which positions
+    // are line starts, then mark branch/jump targets, then place opcodes.
+    if events & EVENT_LINE != 0 {
+        // is_line_start[i] = true if position i should have INSTRUMENTED_LINE
+        let mut is_line_start = vec![false; len];
+
+        // Build NO_LOCATION mask from linetable
+        let no_loc_mask = bytecode::build_no_location_mask(&code.code.linetable, len);
+
+        // First pass: mark positions where the source line changes
+        let mut prev_line: Option<u32> = None;
+        for (i, unit) in code
+            .code
+            .instructions
+            .iter()
+            .enumerate()
+            .take(len)
+            .skip(first_traceable)
+        {
+            let op = unit.op;
+            let base = op.to_base().map_or(op, |b| b);
+            if matches!(base, Instruction::ExtendedArg) {
+                continue;
+            }
+            // Excluded opcodes
+            if matches!(
+                base,
+                Instruction::Resume { .. }
+                    | Instruction::EndFor
+                    | Instruction::EndSend
+                    | Instruction::PopIter
+                    | Instruction::EndAsyncFor
+                    | Instruction::Cache
+            ) {
+                continue;
+            }
+            // Skip NO_LOCATION instructions
+            if no_loc_mask.get(i).copied().unwrap_or(false) {
+                continue;
+            }
+            if let Some((loc, _)) = code.code.locations.get(i) {
+                let line = loc.line.get() as u32;
+                let is_new = prev_line != Some(line);
+                prev_line = Some(line);
+                if is_new && line > 0 {
+                    is_line_start[i] = true;
+                }
+            }
+        }
+
+        // Second pass: mark branch/jump targets as line starts.
+        // Every jump/branch target must be a line start, even if on the
+        // same source line as the preceding instruction. Critical for loops
+        // (JUMP_BACKWARD → FOR_ITER).
+        let mut arg_state = bytecode::OpArgState::default();
+        let mut instr_idx = first_traceable;
+        for unit in code.code.instructions[first_traceable..len].iter().copied() {
+            let (op, arg) = arg_state.get(unit);
+            let base = op.to_base().map_or(op, |b| b);
+
+            if matches!(base, Instruction::ExtendedArg) || matches!(base, Instruction::Cache) {
+                instr_idx += 1;
+                continue;
+            }
+
+            let caches = base.cache_entries();
+            let after_caches = instr_idx + 1 + caches;
+            let delta = u32::from(arg) as usize;
+
+            let target: Option<usize> = match base {
+                // Forward relative jumps
+                Instruction::PopJumpIfFalse { .. }
+                | Instruction::PopJumpIfTrue { .. }
+                | Instruction::PopJumpIfNone { .. }
+                | Instruction::PopJumpIfNotNone { .. }
+                | Instruction::JumpForward { .. } => Some(after_caches + delta),
+                // Backward relative jumps
+                Instruction::JumpBackward { .. } | Instruction::JumpBackwardNoInterrupt { .. } => {
+                    Some(after_caches.wrapping_sub(delta))
+                }
+                Instruction::ForIter { .. } | Instruction::Send { .. } => {
+                    // Skip over END_FOR/END_SEND
+                    Some(after_caches + delta + 1)
+                }
+                _ => None,
+            };
+
+            if let Some(target_idx) = target
+                && target_idx < len
+                && !is_line_start[target_idx]
+                && !no_loc_mask.get(target_idx).copied().unwrap_or(false)
+            {
+                let target_op = code.code.instructions[target_idx].op;
+                let target_base = target_op.to_base().map_or(target_op, |b| b);
+                // Skip POP_ITER targets
+                if matches!(target_base, Instruction::PopIter) {
+                    instr_idx += 1;
+                    continue;
+                }
+                if let Some((loc, _)) = code.code.locations.get(target_idx)
+                    && loc.line.get() > 0
+                {
+                    is_line_start[target_idx] = true;
+                }
+            }
+            instr_idx += 1;
+        }
+
+        // Third pass: mark exception handler targets as line starts.
+        for entry in bytecode::decode_exception_table(&code.code.exceptiontable) {
+            let target_idx = entry.target as usize;
+            if target_idx < len
+                && !is_line_start[target_idx]
+                && !no_loc_mask.get(target_idx).copied().unwrap_or(false)
+            {
+                let target_op = code.code.instructions[target_idx].op;
+                let target_base = target_op.to_base().map_or(target_op, |b| b);
+                if !matches!(target_base, Instruction::PopIter)
+                    && let Some((loc, _)) = code.code.locations.get(target_idx)
+                    && loc.line.get() > 0
+                {
+                    is_line_start[target_idx] = true;
+                }
+            }
+        }
+
+        // Fourth pass: actually place INSTRUMENTED_LINE at all marked positions
+        for (i, marked) in is_line_start
+            .iter()
+            .copied()
+            .enumerate()
+            .take(len)
+            .skip(first_traceable)
+        {
+            if marked {
+                let op = code.code.instructions[i].op;
+                data.line_opcodes[i] = u8::from(op);
+                unsafe {
+                    code.code
+                        .instructions
+                        .replace_op(i, Instruction::InstrumentedLine);
+                }
+            }
+        }
+    }
+}
+
+/// Update the global monitoring_events atomic mask from current state.
+fn update_events_mask(vm: &VirtualMachine, state: &MonitoringState) {
+    let events = state.combined_events();
+    vm.state.monitoring_events.store(events);
+    let new_ver = vm
+        .state
+        .instrumentation_version
+        .fetch_add(1, Ordering::Release)
+        + 1;
+    // Eagerly re-instrument all frames on the current thread's stack so that
+    // code objects already past their RESUME pick up the new event set.
+    // Each code object gets only the events that apply to it (global + its
+    // own local events), preventing e.g. INSTRUCTION from being applied to
+    // unrelated code objects.
+    for fp in vm.frames.borrow().iter() {
+        // SAFETY: frames in the Vec are alive while their FrameRef is on the call stack.
+        let frame = unsafe { fp.as_ref() };
+        let code = &frame.code;
+        let code_ver = code.instrumentation_version.load(Ordering::Acquire);
+        if code_ver != new_ver {
+            let code_events = state.events_for_code(code.get_id());
+            instrument_code(code, code_events);
+            code.instrumentation_version
+                .store(new_ver, Ordering::Release);
+        }
+    }
+}
+
+fn use_tool_id(tool_id: i32, name: &str, vm: &VirtualMachine) -> PyResult<()> {
+    let tool = check_valid_tool(tool_id, vm)?;
+    let mut state = vm.state.monitoring.lock();
+    if state.tool_names[tool].is_some() {
+        return Err(vm.new_value_error(format!("tool {tool_id} is already in use")));
+    }
+    state.tool_names[tool] = Some(name.to_owned());
+    Ok(())
+}
+
+fn clear_tool_id(tool_id: i32, vm: &VirtualMachine) -> PyResult<()> {
+    let tool = check_valid_tool(tool_id, vm)?;
+    let mut state = vm.state.monitoring.lock();
+    if state.tool_names[tool].is_some() {
+        state.global_events[tool] = 0;
+        state
+            .local_events
+            .retain(|(local_tool, _), _| *local_tool != tool);
+        state.callbacks.retain(|(cb_tool, _), _| *cb_tool != tool);
+        state.disabled.retain(|&(_, _, t)| t != tool);
+    }
+    update_events_mask(vm, &state);
+    Ok(())
+}
+
+fn free_tool_id(tool_id: i32, vm: &VirtualMachine) -> PyResult<()> {
+    let tool = check_valid_tool(tool_id, vm)?;
+    let mut state = vm.state.monitoring.lock();
+    if state.tool_names[tool].is_some() {
+        state.global_events[tool] = 0;
+        state
+            .local_events
+            .retain(|(local_tool, _), _| *local_tool != tool);
+        state.callbacks.retain(|(cb_tool, _), _| *cb_tool != tool);
+        state.disabled.retain(|&(_, _, t)| t != tool);
+        state.tool_names[tool] = None;
+    }
+    update_events_mask(vm, &state);
+    Ok(())
+}
+
+fn get_tool(tool_id: i32, vm: &VirtualMachine) -> PyResult<Option<String>> {
+    let tool = check_valid_tool(tool_id, vm)?;
+    let state = vm.state.monitoring.lock();
+    Ok(state.tool_names[tool].clone())
+}
+
+fn register_callback(
+    tool_id: i32,
+    event: i32,
+    func: PyObjectRef,
+    vm: &VirtualMachine,
+) -> PyResult<PyObjectRef> {
+    let tool = check_valid_tool(tool_id, vm)?;
+    let event_id = parse_single_event(event, vm)?;
+
+    let mut state = vm.state.monitoring.lock();
+    let prev = state
+        .callbacks
+        .remove(&(tool, event_id))
+        .unwrap_or_else(|| vm.ctx.none());
+    let branch_id = EVENT_BRANCH.trailing_zeros() as usize;
+    let branch_left_id = EVENT_BRANCH_LEFT.trailing_zeros() as usize;
+    let branch_right_id = EVENT_BRANCH_RIGHT.trailing_zeros() as usize;
+    if !vm.is_none(&func) {
+        state.callbacks.insert((tool, event_id), func.clone());
+        // BRANCH is a composite event: also register for BRANCH_LEFT/RIGHT
+        if event_id == branch_id {
+            state.callbacks.insert((tool, branch_left_id), func.clone());
+            state.callbacks.insert((tool, branch_right_id), func);
+        }
+    } else {
+        // Also clear BRANCH_LEFT/RIGHT when clearing BRANCH
+        if event_id == branch_id {
+            state.callbacks.remove(&(tool, branch_left_id));
+            state.callbacks.remove(&(tool, branch_right_id));
+        }
+    }
+    Ok(prev)
+}
+
+fn get_events(tool_id: i32, vm: &VirtualMachine) -> PyResult<u32> {
+    let tool = check_valid_tool(tool_id, vm)?;
+    let state = vm.state.monitoring.lock();
+    Ok(state.global_events[tool])
+}
+
+fn set_events(tool_id: i32, event_set: i32, vm: &VirtualMachine) -> PyResult<()> {
+    let tool = check_valid_tool(tool_id, vm)?;
+    check_tool_in_use(tool, vm)?;
+    let normalized = normalize_event_set(event_set, false, vm)?;
+    let mut state = vm.state.monitoring.lock();
+    state.global_events[tool] = normalized;
+    update_events_mask(vm, &state);
+    Ok(())
+}
+
+fn get_local_events(tool_id: i32, code: PyObjectRef, vm: &VirtualMachine) -> PyResult<u32> {
+    if code.downcast_ref::<PyCode>().is_none() {
+        return Err(vm.new_type_error("code must be a code object"));
+    }
+    let tool = check_valid_tool(tool_id, vm)?;
+    let code_id = code.get_id();
+    let state = vm.state.monitoring.lock();
+    Ok(state
+        .local_events
+        .get(&(tool, code_id))
+        .copied()
+        .unwrap_or(0))
+}
+
+fn set_local_events(
+    tool_id: i32,
+    code: PyObjectRef,
+    event_set: i32,
+    vm: &VirtualMachine,
+) -> PyResult<()> {
+    if code.downcast_ref::<PyCode>().is_none() {
+        return Err(vm.new_type_error("code must be a code object"));
+    }
+    let tool = check_valid_tool(tool_id, vm)?;
+    check_tool_in_use(tool, vm)?;
+    let normalized = normalize_event_set(event_set, true, vm)?;
+    let code_id = code.get_id();
+    let mut state = vm.state.monitoring.lock();
+    if normalized == 0 {
+        state.local_events.remove(&(tool, code_id));
+    } else {
+        state.local_events.insert((tool, code_id), normalized);
+    }
+    update_events_mask(vm, &state);
+    Ok(())
+}
+
+fn restart_events(vm: &VirtualMachine) {
+    let mut state = vm.state.monitoring.lock();
+    state.disabled.clear();
+}
+
+fn all_events(vm: &VirtualMachine) -> PyResult<PyDictRef> {
+    // Collect data under the lock, then release before calling into Python VM.
+    let masks: Vec<(&str, u8)> = {
+        let state = vm.state.monitoring.lock();
+        EVENT_NAMES
+            .iter()
+            .take(UNGROUPED_EVENTS_COUNT)
+            .enumerate()
+            .filter_map(|(event_id, event_name)| {
+                let event_bit = 1u32 << event_id;
+                let mut tools_mask = 0u8;
+                for tool in 0..TOOL_LIMIT {
+                    if (state.global_events[tool] & event_bit) != 0 {
+                        tools_mask |= 1 << tool;
+                    }
+                }
+                if tools_mask != 0 {
+                    Some((*event_name, tools_mask))
+                } else {
+                    None
+                }
+            })
+            .collect()
+    };
+    let all_events = vm.ctx.new_dict();
+    for (name, mask) in masks {
+        all_events.set_item(name, vm.ctx.new_int(mask).into(), vm)?;
+    }
+    Ok(all_events)
+}
+
+// Event dispatch
+
+use core::cell::Cell;
+
+thread_local! {
+    /// Re-entrancy guard: prevents monitoring callbacks from triggering
+    /// additional monitoring events (which would cause infinite recursion).
+    static FIRING: Cell<bool> = const { Cell::new(false) };
+
+    /// Tracks whether a RERAISE event has been fired since the last
+    /// EXCEPTION_HANDLED. Used to suppress duplicate RERAISE from
+    /// cleanup handlers that chain through multiple exception table entries.
+    static RERAISE_PENDING: Cell<bool> = const { Cell::new(false) };
+}
+
+/// Fire an event for all tools that have the event bit set.
+/// `cb_extra` contains the callback arguments after the code object.
+fn fire(
+    vm: &VirtualMachine,
+    event: u32,
+    code: &PyRef<PyCode>,
+    offset: u32,
+    cb_extra: &[PyObjectRef],
+) -> PyResult<()> {
+    // Prevent recursive event firing
+    if FIRING.with(|f| f.get()) {
+        return Ok(());
+    }
+
+    let event_id = event.trailing_zeros() as usize;
+    let code_id = code.get_id();
+
+    // C_RETURN and C_RAISE are implicitly enabled when CALL is set.
+    let check_bit = if event & EVENT_C_RETURN_MASK != 0 {
+        event | EVENT_CALL
+    } else {
+        event
+    };
+
+    // Collect callbacks and snapshot the DISABLE sentinel under a single lock.
+    let (callbacks, disable_sentinel): (Vec<(usize, PyObjectRef)>, Option<PyObjectRef>) = {
+        let state = vm.state.monitoring.lock();
+        let mut cbs = Vec::new();
+        for tool in 0..TOOL_LIMIT {
+            let global = state.global_events[tool];
+            let local = state
+                .local_events
+                .get(&(tool, code_id))
+                .copied()
+                .unwrap_or(0);
+            if ((global | local) & check_bit) == 0 {
+                continue;
+            }
+            if state.disabled.contains(&(code_id, offset as usize, tool)) {
+                continue;
+            }
+            if let Some(cb) = state.callbacks.get(&(tool, event_id)) {
+                cbs.push((tool, cb.clone()));
+            }
+        }
+        (cbs, state.disable.clone())
+    };
+
+    if callbacks.is_empty() {
+        return Ok(());
+    }
+
+    let mut args_vec = Vec::with_capacity(1 + cb_extra.len());
+    args_vec.push(code.clone().into());
+    args_vec.extend_from_slice(cb_extra);
+    let args = FuncArgs::from(args_vec);
+
+    FIRING.with(|f| f.set(true));
+    let result = (|| {
+        for (tool, cb) in callbacks {
+            let result = cb.call(args.clone(), vm)?;
+            if disable_sentinel.as_ref().is_some_and(|d| result.is(d)) {
+                // Only local events (event_id < LOCAL_EVENTS_COUNT) can be disabled.
+                // Non-local events (RAISE, EXCEPTION_HANDLED, PY_UNWIND, etc.)
+                // cannot be disabled per code object.
+                if event_id >= LOCAL_EVENTS_COUNT {
+                    // Remove the callback.
+                    let mut state = vm.state.monitoring.lock();
+                    state.callbacks.remove(&(tool, event_id));
+                    return Err(vm.new_value_error(format!(
+                        "Cannot disable {} events. Callback removed.",
+                        EVENT_NAMES[event_id]
+                    )));
+                }
+                let mut state = vm.state.monitoring.lock();
+                state.disabled.insert((code_id, offset as usize, tool));
+            }
+        }
+        Ok(())
+    })();
+    FIRING.with(|f| f.set(false));
+    result
+}
+
+// Public dispatch functions (called from frame.rs)
+
+pub fn fire_py_start(vm: &VirtualMachine, code: &PyRef<PyCode>, offset: u32) -> PyResult<()> {
+    fire(
+        vm,
+        EVENT_PY_START,
+        code,
+        offset,
+        &[vm.ctx.new_int(offset).into()],
+    )
+}
+
+pub fn fire_py_resume(vm: &VirtualMachine, code: &PyRef<PyCode>, offset: u32) -> PyResult<()> {
+    fire(
+        vm,
+        EVENT_PY_RESUME,
+        code,
+        offset,
+        &[vm.ctx.new_int(offset).into()],
+    )
+}
+
+pub fn fire_py_return(
+    vm: &VirtualMachine,
+    code: &PyRef<PyCode>,
+    offset: u32,
+    retval: &PyObjectRef,
+) -> PyResult<()> {
+    fire(
+        vm,
+        EVENT_PY_RETURN,
+        code,
+        offset,
+        &[vm.ctx.new_int(offset).into(), retval.clone()],
+    )
+}
+
+pub fn fire_py_yield(
+    vm: &VirtualMachine,
+    code: &PyRef<PyCode>,
+    offset: u32,
+    retval: &PyObjectRef,
+) -> PyResult<()> {
+    fire(
+        vm,
+        EVENT_PY_YIELD,
+        code,
+        offset,
+        &[vm.ctx.new_int(offset).into(), retval.clone()],
+    )
+}
+
+pub fn fire_call(
+    vm: &VirtualMachine,
+    code: &PyRef<PyCode>,
+    offset: u32,
+    callable: &PyObjectRef,
+    arg0: PyObjectRef,
+) -> PyResult<()> {
+    fire(
+        vm,
+        EVENT_CALL,
+        code,
+        offset,
+        &[vm.ctx.new_int(offset).into(), callable.clone(), arg0],
+    )
+}
+
+pub fn fire_c_return(
+    vm: &VirtualMachine,
+    code: &PyRef<PyCode>,
+    offset: u32,
+    callable: &PyObjectRef,
+    arg0: PyObjectRef,
+) -> PyResult<()> {
+    fire(
+        vm,
+        EVENT_C_RETURN,
+        code,
+        offset,
+        &[vm.ctx.new_int(offset).into(), callable.clone(), arg0],
+    )
+}
+
+pub fn fire_c_raise(
+    vm: &VirtualMachine,
+    code: &PyRef<PyCode>,
+    offset: u32,
+    callable: &PyObjectRef,
+    arg0: PyObjectRef,
+) -> PyResult<()> {
+    fire(
+        vm,
+        EVENT_C_RAISE,
+        code,
+        offset,
+        &[vm.ctx.new_int(offset).into(), callable.clone(), arg0],
+    )
+}
+
+pub fn fire_line(
+    vm: &VirtualMachine,
+    code: &PyRef<PyCode>,
+    offset: u32,
+    line: u32,
+) -> PyResult<()> {
+    fire(vm, EVENT_LINE, code, offset, &[vm.ctx.new_int(line).into()])
+}
+
+pub fn fire_instruction(vm: &VirtualMachine, code: &PyRef<PyCode>, offset: u32) -> PyResult<()> {
+    fire(
+        vm,
+        EVENT_INSTRUCTION,
+        code,
+        offset,
+        &[vm.ctx.new_int(offset).into()],
+    )
+}
+
+pub fn fire_raise(
+    vm: &VirtualMachine,
+    code: &PyRef<PyCode>,
+    offset: u32,
+    exception: &PyObjectRef,
+) -> PyResult<()> {
+    fire(
+        vm,
+        EVENT_RAISE,
+        code,
+        offset,
+        &[vm.ctx.new_int(offset).into(), exception.clone()],
+    )
+}
+
+/// Only fires if no RERAISE has been fired since the last EXCEPTION_HANDLED,
+/// preventing duplicate events from chained cleanup handlers.
+pub fn fire_reraise(
+    vm: &VirtualMachine,
+    code: &PyRef<PyCode>,
+    offset: u32,
+    exception: &PyObjectRef,
+) -> PyResult<()> {
+    if RERAISE_PENDING.with(|f| f.get()) {
+        return Ok(());
+    }
+    RERAISE_PENDING.with(|f| f.set(true));
+    let result = fire(
+        vm,
+        EVENT_RERAISE,
+        code,
+        offset,
+        &[vm.ctx.new_int(offset).into(), exception.clone()],
+    );
+    if result.is_err() {
+        RERAISE_PENDING.with(|f| f.set(false));
+    }
+    result
+}
+
+pub fn fire_exception_handled(
+    vm: &VirtualMachine,
+    code: &PyRef<PyCode>,
+    offset: u32,
+    exception: &PyObjectRef,
+) -> PyResult<()> {
+    RERAISE_PENDING.with(|f| f.set(false));
+    fire(
+        vm,
+        EVENT_EXCEPTION_HANDLED,
+        code,
+        offset,
+        &[vm.ctx.new_int(offset).into(), exception.clone()],
+    )
+}
+
+pub fn fire_py_unwind(
+    vm: &VirtualMachine,
+    code: &PyRef<PyCode>,
+    offset: u32,
+    exception: &PyObjectRef,
+) -> PyResult<()> {
+    RERAISE_PENDING.with(|f| f.set(false));
+    fire(
+        vm,
+        EVENT_PY_UNWIND,
+        code,
+        offset,
+        &[vm.ctx.new_int(offset).into(), exception.clone()],
+    )
+}
+
+pub fn fire_py_throw(
+    vm: &VirtualMachine,
+    code: &PyRef<PyCode>,
+    offset: u32,
+    exception: &PyObjectRef,
+) -> PyResult<()> {
+    fire(
+        vm,
+        EVENT_PY_THROW,
+        code,
+        offset,
+        &[vm.ctx.new_int(offset).into(), exception.clone()],
+    )
+}
+
+pub fn fire_stop_iteration(
+    vm: &VirtualMachine,
+    code: &PyRef<PyCode>,
+    offset: u32,
+    exception: &PyObjectRef,
+) -> PyResult<()> {
+    fire(
+        vm,
+        EVENT_STOP_ITERATION,
+        code,
+        offset,
+        &[vm.ctx.new_int(offset).into(), exception.clone()],
+    )
+}
+
+pub fn fire_jump(
+    vm: &VirtualMachine,
+    code: &PyRef<PyCode>,
+    offset: u32,
+    destination: u32,
+) -> PyResult<()> {
+    fire(
+        vm,
+        EVENT_JUMP,
+        code,
+        offset,
+        &[
+            vm.ctx.new_int(offset).into(),
+            vm.ctx.new_int(destination).into(),
+        ],
+    )
+}
+
+pub fn fire_branch_left(
+    vm: &VirtualMachine,
+    code: &PyRef<PyCode>,
+    offset: u32,
+    destination: u32,
+) -> PyResult<()> {
+    fire(
+        vm,
+        EVENT_BRANCH_LEFT,
+        code,
+        offset,
+        &[
+            vm.ctx.new_int(offset).into(),
+            vm.ctx.new_int(destination).into(),
+        ],
+    )
+}
+
+pub fn fire_branch_right(
+    vm: &VirtualMachine,
+    code: &PyRef<PyCode>,
+    offset: u32,
+    destination: u32,
+) -> PyResult<()> {
+    fire(
+        vm,
+        EVENT_BRANCH_RIGHT,
+        code,
+        offset,
+        &[
+            vm.ctx.new_int(offset).into(),
+            vm.ctx.new_int(destination).into(),
+        ],
+    )
+}
+
+#[pymodule(sub)]
+pub(super) mod sys_monitoring {
+    use super::*;
+
+    #[pyclass(no_attr, module = "sys.monitoring", name = "_Sentinel")]
+    #[derive(Debug, PyPayload)]
+    pub(super) struct MonitoringSentinel;
+
+    #[pyclass]
+    impl MonitoringSentinel {}
+
+    #[pyattr(name = "DEBUGGER_ID")]
+    const DEBUGGER_ID: u8 = 0;
+    #[pyattr(name = "COVERAGE_ID")]
+    const COVERAGE_ID: u8 = 1;
+    #[pyattr(name = "PROFILER_ID")]
+    const PROFILER_ID: u8 = 2;
+    #[pyattr(name = "OPTIMIZER_ID")]
+    const OPTIMIZER_ID: u8 = 5;
+
+    #[pyattr(once, name = "DISABLE")]
+    fn disable(vm: &VirtualMachine) -> PyObjectRef {
+        super::get_disable(vm)
+    }
+
+    #[pyattr(once, name = "MISSING")]
+    fn missing(vm: &VirtualMachine) -> PyObjectRef {
+        super::get_missing(vm)
+    }
+
+    #[pyattr(once)]
+    fn events(vm: &VirtualMachine) -> PyRef<PyNamespace> {
+        let events = PyNamespace::default().into_ref(&vm.ctx);
+        for (event_id, event_name) in EVENT_NAMES.iter().enumerate() {
+            events
+                .as_object()
+                .set_attr(*event_name, vm.ctx.new_int(1u32 << event_id), vm)
+                .expect("setting sys.monitoring.events attribute should not fail");
+        }
+        events
+            .as_object()
+            .set_attr("NO_EVENTS", vm.ctx.new_int(0), vm)
+            .expect("setting sys.monitoring.events.NO_EVENTS should not fail");
+        events
+    }
+
+    #[pyfunction]
+    fn use_tool_id(tool_id: i32, name: PyUtf8StrRef, vm: &VirtualMachine) -> PyResult<()> {
+        super::use_tool_id(tool_id, name.as_str(), vm)
+    }
+
+    #[pyfunction]
+    fn clear_tool_id(tool_id: i32, vm: &VirtualMachine) -> PyResult<()> {
+        super::clear_tool_id(tool_id, vm)
+    }
+
+    #[pyfunction]
+    fn free_tool_id(tool_id: i32, vm: &VirtualMachine) -> PyResult<()> {
+        super::free_tool_id(tool_id, vm)
+    }
+
+    #[pyfunction]
+    fn get_tool(tool_id: i32, vm: &VirtualMachine) -> PyResult<Option<String>> {
+        super::get_tool(tool_id, vm)
+    }
+
+    #[pyfunction]
+    fn register_callback(
+        tool_id: i32,
+        event: i32,
+        func: PyObjectRef,
+        vm: &VirtualMachine,
+    ) -> PyResult<PyObjectRef> {
+        super::register_callback(tool_id, event, func, vm)
+    }
+
+    #[pyfunction]
+    fn get_events(tool_id: i32, vm: &VirtualMachine) -> PyResult<u32> {
+        super::get_events(tool_id, vm)
+    }
+
+    #[pyfunction]
+    fn set_events(tool_id: i32, event_set: i32, vm: &VirtualMachine) -> PyResult<()> {
+        super::set_events(tool_id, event_set, vm)
+    }
+
+    #[pyfunction]
+    fn get_local_events(tool_id: i32, code: PyObjectRef, vm: &VirtualMachine) -> PyResult<u32> {
+        super::get_local_events(tool_id, code, vm)
+    }
+
+    #[pyfunction]
+    fn set_local_events(
+        tool_id: i32,
+        code: PyObjectRef,
+        event_set: i32,
+        vm: &VirtualMachine,
+    ) -> PyResult<()> {
+        super::set_local_events(tool_id, code, event_set, vm)
+    }
+
+    #[pyfunction]
+    fn restart_events(vm: &VirtualMachine) {
+        super::restart_events(vm)
+    }
+
+    #[pyfunction]
+    fn _all_events(vm: &VirtualMachine) -> PyResult<PyDictRef> {
+        super::all_events(vm)
+    }
+}
diff --git a/crates/vm/src/stdlib/time.rs b/crates/vm/src/stdlib/time.rs
index ccd80402bf7..9235d8c89b7 100644
--- a/crates/vm/src/stdlib/time.rs
+++ b/crates/vm/src/stdlib/time.rs
@@ -23,14 +23,19 @@ unsafe extern "C" {
     fn c_tzset();
 }
 
-#[pymodule(name = "time", with(platform))]
+#[pymodule(name = "time", with(#[cfg(any(unix, windows))] platform))]
 mod decl {
     use crate::{
         AsObject, Py, PyObjectRef, PyResult, VirtualMachine,
-        builtins::{PyStrRef, PyTypeRef, PyUtf8StrRef},
+        builtins::{PyStrRef, PyTypeRef},
         function::{Either, FuncArgs, OptionalArg},
         types::{PyStructSequence, struct_sequence_new},
     };
+    #[cfg(any(unix, windows))]
+    use crate::{common::wtf8::Wtf8Buf, convert::ToPyObject};
+    #[cfg(unix)]
+    use alloc::ffi::CString;
+    #[cfg(not(any(unix, windows)))]
     use chrono::{
         DateTime, Datelike, TimeZone, Timelike,
         naive::{NaiveDate, NaiveDateTime, NaiveTime},
@@ -40,6 +45,16 @@ mod decl {
     #[cfg(not(target_arch = "wasm32"))]
     use windows_sys::Win32::System::Time::{GetTimeZoneInformation, TIME_ZONE_INFORMATION};
 
+    #[cfg(windows)]
+    unsafe extern "C" {
+        fn wcsftime(
+            s: *mut libc::wchar_t,
+            max: libc::size_t,
+            format: *const libc::wchar_t,
+            tm: *const libc::tm,
+        ) -> libc::size_t;
+    }
+
     #[allow(dead_code)]
     pub(super) const SEC_TO_MS: i64 = 1000;
     #[allow(dead_code)]
@@ -82,31 +97,55 @@ mod decl {
 
     #[pyfunction]
     fn sleep(seconds: PyObjectRef, vm: &VirtualMachine) -> PyResult<()> {
+        let seconds_type_name = seconds.clone().class().name().to_owned();
         let dur = seconds.try_into_value::<Duration>(vm).map_err(|e| {
             if e.class().is(vm.ctx.exceptions.value_error)
                 && let Some(s) = e.args().first().and_then(|arg| arg.str(vm).ok())
-                && s.as_str() == "negative duration"
+                && s.as_bytes() == b"negative duration"
             {
                 return vm.new_value_error("sleep length must be non-negative");
             }
+            if e.class().is(vm.ctx.exceptions.type_error) {
+                return vm.new_type_error(format!(
+                    "'{seconds_type_name}' object cannot be interpreted as an integer or float"
+                ));
+            }
             e
         })?;
 
         #[cfg(unix)]
         {
-            // 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(), core::ptr::null_mut()) };
-            let interrupted = res == -1 && nix::Error::last_raw() == libc::EINTR;
-
-            if interrupted {
+            // Loop on nanosleep, recomputing the
+            // remaining timeout after each EINTR so that signals don't
+            // shorten the requested sleep duration.
+            use std::time::Instant;
+            let deadline = Instant::now() + dur;
+            loop {
+                let remaining = deadline.saturating_duration_since(Instant::now());
+                if remaining.is_zero() {
+                    break;
+                }
+                let ts = nix::sys::time::TimeSpec::from(remaining);
+                let (res, err) = vm.allow_threads(|| {
+                    let r = unsafe { libc::nanosleep(ts.as_ref(), core::ptr::null_mut()) };
+                    (r, nix::Error::last_raw())
+                });
+                if res == 0 {
+                    break;
+                }
+                if err != libc::EINTR {
+                    return Err(
+                        vm.new_os_error(format!("nanosleep: {}", nix::Error::from_raw(err)))
+                    );
+                }
+                // EINTR: run signal handlers, then retry with remaining time
                 vm.check_signals()?;
             }
         }
 
         #[cfg(not(unix))]
         {
-            std::thread::sleep(dur);
+            vm.allow_threads(|| std::thread::sleep(dur));
         }
 
         Ok(())
@@ -178,8 +217,8 @@ mod decl {
 
     #[cfg(target_env = "msvc")]
     #[cfg(not(target_arch = "wasm32"))]
-    fn get_tz_info() -> TIME_ZONE_INFORMATION {
-        let mut info: TIME_ZONE_INFORMATION = unsafe { std::mem::zeroed() };
+    pub(super) fn get_tz_info() -> TIME_ZONE_INFORMATION {
+        let mut info: TIME_ZONE_INFORMATION = unsafe { core::mem::zeroed() };
         unsafe { GetTimeZoneInformation(&mut info) };
         info
     }
@@ -260,49 +299,212 @@ mod decl {
         use crate::builtins::tuple::IntoPyTuple;
         let info = get_tz_info();
         let standard = widestring::decode_utf16_lossy(info.StandardName)
-            .filter(|&c| c != '\0')
+            .take_while(|&c| c != '\0')
             .collect::<String>();
         let daylight = widestring::decode_utf16_lossy(info.DaylightName)
-            .filter(|&c| c != '\0')
+            .take_while(|&c| c != '\0')
             .collect::<String>();
         let tz_name = (&*standard, &*daylight);
         tz_name.into_pytuple(vm)
     }
 
+    #[cfg(not(any(unix, windows)))]
     fn pyobj_to_date_time(
         value: Either<f64, i64>,
         vm: &VirtualMachine,
     ) -> PyResult<DateTime<chrono::offset::Utc>> {
-        let timestamp = match value {
+        let secs = match value {
             Either::A(float) => {
-                let secs = float.trunc() as i64;
-                let nano_secs = (float.fract() * 1e9) as u32;
-                DateTime::<chrono::offset::Utc>::from_timestamp(secs, nano_secs)
+                if !float.is_finite() {
+                    return Err(vm.new_value_error("Invalid value for timestamp"));
+                }
+                float.floor() as i64
             }
-            Either::B(int) => DateTime::<chrono::offset::Utc>::from_timestamp(int, 0),
+            Either::B(int) => int,
         };
-        timestamp.ok_or_else(|| vm.new_overflow_error("timestamp out of range for platform time_t"))
+        DateTime::<chrono::offset::Utc>::from_timestamp(secs, 0)
+            .ok_or_else(|| vm.new_overflow_error("timestamp out of range for platform time_t"))
     }
 
-    impl OptionalArg<Either<f64, i64>> {
+    #[cfg(not(any(unix, windows)))]
+    impl OptionalArg<Option<Either<f64, i64>>> {
         /// Construct a localtime from the optional seconds, or get the current local time.
         fn naive_or_local(self, vm: &VirtualMachine) -> PyResult<NaiveDateTime> {
             Ok(match self {
-                Self::Present(secs) => pyobj_to_date_time(secs, vm)?
+                Self::Present(Some(secs)) => pyobj_to_date_time(secs, vm)?
                     .with_timezone(&chrono::Local)
                     .naive_local(),
-                Self::Missing => chrono::offset::Local::now().naive_local(),
+                Self::Present(None) | Self::Missing => chrono::offset::Local::now().naive_local(),
             })
         }
+    }
 
-        fn naive_or_utc(self, vm: &VirtualMachine) -> PyResult<NaiveDateTime> {
-            Ok(match self {
-                Self::Present(secs) => pyobj_to_date_time(secs, vm)?.naive_utc(),
-                Self::Missing => chrono::offset::Utc::now().naive_utc(),
-            })
+    #[cfg(any(unix, windows))]
+    struct CheckedTm {
+        tm: libc::tm,
+        #[cfg(unix)]
+        zone: Option<CString>,
+    }
+
+    #[cfg(any(unix, windows))]
+    fn checked_tm_from_struct_time(
+        t: &StructTimeData,
+        vm: &VirtualMachine,
+        func_name: &'static str,
+    ) -> PyResult<CheckedTm> {
+        let invalid_tuple =
+            || vm.new_type_error(format!("{func_name}(): illegal time tuple argument"));
+
+        let year: i64 = t.tm_year.clone().try_into_value(vm).map_err(|e| {
+            if e.class().is(vm.ctx.exceptions.overflow_error) {
+                vm.new_overflow_error("year out of range")
+            } else {
+                invalid_tuple()
+            }
+        })?;
+        if year < i64::from(i32::MIN) + 1900 || year > i64::from(i32::MAX) {
+            return Err(vm.new_overflow_error("year out of range"));
         }
+        let year = year as i32;
+        let tm_mon = t
+            .tm_mon
+            .clone()
+            .try_into_value::<i32>(vm)
+            .map_err(|_| invalid_tuple())?
+            - 1;
+        let tm_mday = t
+            .tm_mday
+            .clone()
+            .try_into_value(vm)
+            .map_err(|_| invalid_tuple())?;
+        let tm_hour = t
+            .tm_hour
+            .clone()
+            .try_into_value(vm)
+            .map_err(|_| invalid_tuple())?;
+        let tm_min = t
+            .tm_min
+            .clone()
+            .try_into_value(vm)
+            .map_err(|_| invalid_tuple())?;
+        let tm_sec = t
+            .tm_sec
+            .clone()
+            .try_into_value(vm)
+            .map_err(|_| invalid_tuple())?;
+        let tm_wday = (t
+            .tm_wday
+            .clone()
+            .try_into_value::<i32>(vm)
+            .map_err(|_| invalid_tuple())?
+            + 1)
+            % 7;
+        let tm_yday = t
+            .tm_yday
+            .clone()
+            .try_into_value::<i32>(vm)
+            .map_err(|_| invalid_tuple())?
+            - 1;
+        let tm_isdst = t
+            .tm_isdst
+            .clone()
+            .try_into_value(vm)
+            .map_err(|_| invalid_tuple())?;
+
+        let mut tm: libc::tm = unsafe { core::mem::zeroed() };
+        tm.tm_year = year - 1900;
+        tm.tm_mon = tm_mon;
+        tm.tm_mday = tm_mday;
+        tm.tm_hour = tm_hour;
+        tm.tm_min = tm_min;
+        tm.tm_sec = tm_sec;
+        tm.tm_wday = tm_wday;
+        tm.tm_yday = tm_yday;
+        tm.tm_isdst = tm_isdst;
+
+        if tm.tm_mon == -1 {
+            tm.tm_mon = 0;
+        } else if tm.tm_mon < 0 || tm.tm_mon > 11 {
+            return Err(vm.new_value_error("month out of range"));
+        }
+        if tm.tm_mday == 0 {
+            tm.tm_mday = 1;
+        } else if tm.tm_mday < 0 || tm.tm_mday > 31 {
+            return Err(vm.new_value_error("day of month out of range"));
+        }
+        if tm.tm_hour < 0 || tm.tm_hour > 23 {
+            return Err(vm.new_value_error("hour out of range"));
+        }
+        if tm.tm_min < 0 || tm.tm_min > 59 {
+            return Err(vm.new_value_error("minute out of range"));
+        }
+        if tm.tm_sec < 0 || tm.tm_sec > 61 {
+            return Err(vm.new_value_error("seconds out of range"));
+        }
+        if tm.tm_wday < 0 {
+            return Err(vm.new_value_error("day of week out of range"));
+        }
+        if tm.tm_yday == -1 {
+            tm.tm_yday = 0;
+        } else if tm.tm_yday < 0 || tm.tm_yday > 365 {
+            return Err(vm.new_value_error("day of year out of range"));
+        }
+
+        #[cfg(unix)]
+        {
+            use crate::builtins::PyUtf8StrRef;
+            let zone = if t.tm_zone.is(&vm.ctx.none) {
+                None
+            } else {
+                let zone: PyUtf8StrRef = t
+                    .tm_zone
+                    .clone()
+                    .try_into_value(vm)
+                    .map_err(|_| invalid_tuple())?;
+                Some(
+                    CString::new(zone.as_str())
+                        .map_err(|_| vm.new_value_error("embedded null character"))?,
+                )
+            };
+            if let Some(zone) = &zone {
+                tm.tm_zone = zone.as_ptr().cast_mut();
+            }
+            if !t.tm_gmtoff.is(&vm.ctx.none) {
+                let gmtoff: i64 = t
+                    .tm_gmtoff
+                    .clone()
+                    .try_into_value(vm)
+                    .map_err(|_| invalid_tuple())?;
+                tm.tm_gmtoff = gmtoff as _;
+            }
+
+            Ok(CheckedTm { tm, zone })
+        }
+        #[cfg(windows)]
+        {
+            Ok(CheckedTm { tm })
+        }
+    }
+
+    #[cfg(any(unix, windows))]
+    fn asctime_from_tm(tm: &libc::tm) -> String {
+        const WDAY_NAME: [&str; 7] = ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"];
+        const MON_NAME: [&str; 12] = [
+            "Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec",
+        ];
+        format!(
+            "{} {}{:>3} {:02}:{:02}:{:02} {}",
+            WDAY_NAME[tm.tm_wday as usize],
+            MON_NAME[tm.tm_mon as usize],
+            tm.tm_mday,
+            tm.tm_hour,
+            tm.tm_min,
+            tm.tm_sec,
+            tm.tm_year + 1900
+        )
     }
 
+    #[cfg(not(any(unix, windows)))]
     impl OptionalArg<StructTimeData> {
         fn naive_or_local(self, vm: &VirtualMachine) -> PyResult<NaiveDateTime> {
             Ok(match self {
@@ -315,78 +517,258 @@ mod decl {
     /// https://docs.python.org/3/library/time.html?highlight=gmtime#time.gmtime
     #[pyfunction]
     fn gmtime(
-        secs: OptionalArg<Either<f64, i64>>,
+        secs: OptionalArg<Option<Either<f64, i64>>>,
         vm: &VirtualMachine,
     ) -> PyResult<StructTimeData> {
-        let instant = secs.naive_or_utc(vm)?;
-        Ok(StructTimeData::new_utc(vm, instant))
+        #[cfg(any(unix, windows))]
+        {
+            let ts = match secs {
+                OptionalArg::Present(Some(value)) => pyobj_to_time_t(value, vm)?,
+                OptionalArg::Present(None) | OptionalArg::Missing => current_time_t(),
+            };
+            gmtime_from_timestamp(ts, vm)
+        }
+
+        #[cfg(not(any(unix, windows)))]
+        {
+            let instant = match secs {
+                OptionalArg::Present(Some(secs)) => pyobj_to_date_time(secs, vm)?.naive_utc(),
+                OptionalArg::Present(None) | OptionalArg::Missing => {
+                    chrono::offset::Utc::now().naive_utc()
+                }
+            };
+            Ok(StructTimeData::new_utc(vm, instant))
+        }
     }
 
     #[pyfunction]
     fn localtime(
-        secs: OptionalArg<Either<f64, i64>>,
+        secs: OptionalArg<Option<Either<f64, i64>>>,
         vm: &VirtualMachine,
     ) -> PyResult<StructTimeData> {
+        #[cfg(any(unix, windows))]
+        {
+            let ts = match secs {
+                OptionalArg::Present(Some(value)) => pyobj_to_time_t(value, vm)?,
+                OptionalArg::Present(None) | OptionalArg::Missing => current_time_t(),
+            };
+            localtime_from_timestamp(ts, vm)
+        }
+
+        #[cfg(not(any(unix, windows)))]
         let instant = secs.naive_or_local(vm)?;
-        // TODO: isdst flag must be valid value here
-        // https://docs.python.org/3/library/time.html#time.localtime
-        Ok(StructTimeData::new_local(vm, instant, -1))
+        #[cfg(not(any(unix, windows)))]
+        {
+            Ok(StructTimeData::new_local(vm, instant, 0))
+        }
     }
 
     #[pyfunction]
     fn mktime(t: StructTimeData, vm: &VirtualMachine) -> PyResult<f64> {
-        let datetime = t.to_date_time(vm)?;
-        // mktime interprets struct_time as local time
-        let local_dt = chrono::Local
-            .from_local_datetime(&datetime)
-            .single()
-            .ok_or_else(|| vm.new_overflow_error("mktime argument out of range"))?;
-        let seconds_since_epoch = local_dt.timestamp() as f64;
-        Ok(seconds_since_epoch)
+        #[cfg(unix)]
+        {
+            unix_mktime(&t, vm)
+        }
+
+        #[cfg(windows)]
+        {
+            win_mktime(&t, vm)
+        }
+
+        #[cfg(not(any(unix, windows)))]
+        {
+            let datetime = t.to_date_time(vm)?;
+            // mktime interprets struct_time as local time
+            let local_dt = chrono::Local
+                .from_local_datetime(&datetime)
+                .single()
+                .ok_or_else(|| vm.new_overflow_error("mktime argument out of range"))?;
+            let seconds_since_epoch = local_dt.timestamp() as f64;
+            Ok(seconds_since_epoch)
+        }
     }
 
+    #[cfg(not(any(unix, windows)))]
     const CFMT: &str = "%a %b %e %H:%M:%S %Y";
 
     #[pyfunction]
     fn asctime(t: OptionalArg<StructTimeData>, vm: &VirtualMachine) -> PyResult {
-        let instant = t.naive_or_local(vm)?;
-        let formatted_time = instant.format(CFMT).to_string();
-        Ok(vm.ctx.new_str(formatted_time).into())
+        #[cfg(any(unix, windows))]
+        {
+            let tm = match t {
+                OptionalArg::Present(value) => {
+                    checked_tm_from_struct_time(&value, vm, "asctime")?.tm
+                }
+                OptionalArg::Missing => {
+                    let now = current_time_t();
+                    let local = localtime_from_timestamp(now, vm)?;
+                    checked_tm_from_struct_time(&local, vm, "asctime")?.tm
+                }
+            };
+            Ok(vm.ctx.new_str(asctime_from_tm(&tm)).into())
+        }
+
+        #[cfg(not(any(unix, windows)))]
+        {
+            let instant = t.naive_or_local(vm)?;
+            let formatted_time = instant.format(CFMT).to_string();
+            Ok(vm.ctx.new_str(formatted_time).into())
+        }
     }
 
     #[pyfunction]
-    fn ctime(secs: OptionalArg<Either<f64, i64>>, vm: &VirtualMachine) -> PyResult<String> {
-        let instant = secs.naive_or_local(vm)?;
-        Ok(instant.format(CFMT).to_string())
+    fn ctime(secs: OptionalArg<Option<Either<f64, i64>>>, vm: &VirtualMachine) -> PyResult<String> {
+        #[cfg(any(unix, windows))]
+        {
+            let ts = match secs {
+                OptionalArg::Present(Some(value)) => pyobj_to_time_t(value, vm)?,
+                OptionalArg::Present(None) | OptionalArg::Missing => current_time_t(),
+            };
+            let local = localtime_from_timestamp(ts, vm)?;
+            let tm = checked_tm_from_struct_time(&local, vm, "asctime")?.tm;
+            Ok(asctime_from_tm(&tm))
+        }
+
+        #[cfg(not(any(unix, windows)))]
+        {
+            let instant = secs.naive_or_local(vm)?;
+            Ok(instant.format(CFMT).to_string())
+        }
     }
 
-    #[pyfunction]
-    fn strftime(
-        format: PyUtf8StrRef,
-        t: OptionalArg<StructTimeData>,
-        vm: &VirtualMachine,
-    ) -> PyResult {
-        use core::fmt::Write;
+    #[cfg(any(unix, windows))]
+    fn strftime_crt(format: &PyStrRef, checked_tm: CheckedTm, vm: &VirtualMachine) -> PyResult {
+        #[cfg(unix)]
+        let _keep_zone_alive = &checked_tm.zone;
+        let mut tm = checked_tm.tm;
+        tm.tm_isdst = tm.tm_isdst.clamp(-1, 1);
+
+        // MSVC strftime requires year in [1; 9999]
+        #[cfg(windows)]
+        {
+            let year = tm.tm_year + 1900;
+            if !(1..=9999).contains(&year) {
+                return Err(vm.new_value_error("strftime() requires year in [1; 9999]"));
+            }
+        }
+
+        #[cfg(unix)]
+        fn strftime_ascii(fmt: &str, tm: &libc::tm, vm: &VirtualMachine) -> PyResult<String> {
+            let fmt_c =
+                CString::new(fmt).map_err(|_| vm.new_value_error("embedded null character"))?;
+            let mut size = 1024usize;
+            let max_scale = 256usize.saturating_mul(fmt.len().max(1));
+            loop {
+                let mut out = vec![0u8; size];
+                let written = unsafe {
+                    libc::strftime(
+                        out.as_mut_ptr().cast(),
+                        out.len(),
+                        fmt_c.as_ptr(),
+                        tm as *const libc::tm,
+                    )
+                };
+                if written > 0 || size >= max_scale {
+                    return Ok(String::from_utf8_lossy(&out[..written]).into_owned());
+                }
+                size = size.saturating_mul(2);
+            }
+        }
+
+        #[cfg(windows)]
+        fn strftime_ascii(fmt: &str, tm: &libc::tm, vm: &VirtualMachine) -> PyResult<String> {
+            if fmt.contains('\0') {
+                return Err(vm.new_value_error("embedded null character"));
+            }
+            // Use wcsftime for proper Unicode output (e.g. %Z timezone names)
+            let fmt_wide: Vec<u16> = fmt.encode_utf16().chain(core::iter::once(0)).collect();
+            let mut size = 1024usize;
+            let max_scale = 256usize.saturating_mul(fmt.len().max(1));
+            loop {
+                let mut out = vec![0u16; size];
+                let written = unsafe {
+                    rustpython_common::suppress_iph!(wcsftime(
+                        out.as_mut_ptr(),
+                        out.len(),
+                        fmt_wide.as_ptr(),
+                        tm as *const libc::tm,
+                    ))
+                };
+                if written > 0 || size >= max_scale {
+                    return Ok(String::from_utf16_lossy(&out[..written]));
+                }
+                size = size.saturating_mul(2);
+            }
+        }
 
-        let instant = t.naive_or_local(vm)?;
+        let mut out = Wtf8Buf::new();
+        let mut ascii = String::new();
+
+        for codepoint in format.as_wtf8().code_points() {
+            if codepoint.to_u32() == 0 {
+                if !ascii.is_empty() {
+                    let part = strftime_ascii(&ascii, &tm, vm)?;
+                    out.extend(part.chars());
+                    ascii.clear();
+                }
+                out.push(codepoint);
+                continue;
+            }
+            if let Some(ch) = codepoint.to_char()
+                && ch.is_ascii()
+            {
+                ascii.push(ch);
+                continue;
+            }
 
-        // On Windows/AIX/Solaris, %y format with year < 1900 is not supported
-        #[cfg(any(windows, target_os = "aix", target_os = "solaris"))]
-        if instant.year() < 1900 && format.as_str().contains("%y") {
-            let msg = "format %y requires year >= 1900 on Windows";
-            return Err(vm.new_value_error(msg.to_owned()));
+            if !ascii.is_empty() {
+                let part = strftime_ascii(&ascii, &tm, vm)?;
+                out.extend(part.chars());
+                ascii.clear();
+            }
+            out.push(codepoint);
         }
+        if !ascii.is_empty() {
+            let part = strftime_ascii(&ascii, &tm, vm)?;
+            out.extend(part.chars());
+        }
+        Ok(out.to_pyobject(vm))
+    }
 
-        let mut formatted_time = String::new();
+    #[pyfunction]
+    fn strftime(format: PyStrRef, t: OptionalArg<StructTimeData>, vm: &VirtualMachine) -> PyResult {
+        #[cfg(any(unix, windows))]
+        {
+            let checked_tm = match t {
+                OptionalArg::Present(value) => checked_tm_from_struct_time(&value, vm, "strftime")?,
+                OptionalArg::Missing => {
+                    let now = current_time_t();
+                    let local = localtime_from_timestamp(now, vm)?;
+                    checked_tm_from_struct_time(&local, vm, "strftime")?
+                }
+            };
+            strftime_crt(&format, checked_tm, vm)
+        }
 
-        /*
-         * chrono doesn't support all formats and it
-         * raises an error if unsupported format is supplied.
-         * If error happens, we set result as input arg.
-         */
-        write!(&mut formatted_time, "{}", instant.format(format.as_str()))
-            .unwrap_or_else(|_| formatted_time = format.to_string());
-        Ok(vm.ctx.new_str(formatted_time).into())
+        #[cfg(not(any(unix, windows)))]
+        {
+            use core::fmt::Write;
+
+            let fmt_lossy = format.to_string_lossy();
+
+            // If the struct_time can't be represented as NaiveDateTime
+            // (e.g. month=0), return the format string as-is, matching
+            // the fallback behavior for unsupported chrono formats.
+            let instant = match t.naive_or_local(vm) {
+                Ok(dt) => dt,
+                Err(_) => return Ok(vm.ctx.new_str(fmt_lossy.into_owned()).into()),
+            };
+
+            let mut formatted_time = String::new();
+            write!(&mut formatted_time, "{}", instant.format(&fmt_lossy))
+                .unwrap_or_else(|_| formatted_time = format.to_string());
+            Ok(vm.ctx.new_str(formatted_time).into())
+        }
     }
 
     #[pyfunction]
@@ -437,7 +819,7 @@ mod decl {
     #[cfg(all(target_arch = "wasm32", target_os = "emscripten"))]
     fn get_process_time(vm: &VirtualMachine) -> PyResult<Duration> {
         let t: libc::tms = unsafe {
-            let mut t = std::mem::MaybeUninit::uninit();
+            let mut t = core::mem::MaybeUninit::uninit();
             if libc::times(t.as_mut_ptr()) == -1 {
                 return Err(vm.new_os_error("Failed to get clock time".to_owned()));
             }
@@ -491,9 +873,9 @@ mod decl {
         pub tm_yday: PyObjectRef,
         pub tm_isdst: PyObjectRef,
         #[pystruct_sequence(skip)]
-        pub tm_gmtoff: PyObjectRef,
-        #[pystruct_sequence(skip)]
         pub tm_zone: PyObjectRef,
+        #[pystruct_sequence(skip)]
+        pub tm_gmtoff: PyObjectRef,
     }
 
     impl core::fmt::Debug for StructTimeData {
@@ -503,6 +885,7 @@ mod decl {
     }
 
     impl StructTimeData {
+        #[cfg(not(any(unix, windows)))]
         fn new_inner(
             vm: &VirtualMachine,
             tm: NaiveDateTime,
@@ -520,25 +903,27 @@ mod decl {
                 tm_wday: vm.ctx.new_int(tm.weekday().num_days_from_monday()).into(),
                 tm_yday: vm.ctx.new_int(tm.ordinal()).into(),
                 tm_isdst: vm.ctx.new_int(isdst).into(),
-                tm_gmtoff: vm.ctx.new_int(gmtoff).into(),
                 tm_zone: vm.ctx.new_str(zone).into(),
+                tm_gmtoff: vm.ctx.new_int(gmtoff).into(),
             }
         }
 
         /// Create struct_time for UTC (gmtime)
+        #[cfg(not(any(unix, windows)))]
         fn new_utc(vm: &VirtualMachine, tm: NaiveDateTime) -> Self {
             Self::new_inner(vm, tm, 0, 0, "UTC")
         }
 
         /// Create struct_time for local timezone (localtime)
+        #[cfg(not(any(unix, windows)))]
         fn new_local(vm: &VirtualMachine, tm: NaiveDateTime, isdst: i32) -> Self {
             let local_time = chrono::Local.from_local_datetime(&tm).unwrap();
-            let offset_seconds =
-                local_time.offset().local_minus_utc() + if isdst == 1 { 3600 } else { 0 };
+            let offset_seconds = local_time.offset().local_minus_utc();
             let tz_abbr = local_time.format("%Z").to_string();
             Self::new_inner(vm, tm, isdst, offset_seconds, &tz_abbr)
         }
 
+        #[cfg(not(any(unix, windows)))]
         fn to_date_time(&self, vm: &VirtualMachine) -> PyResult<NaiveDateTime> {
             let invalid_overflow = || vm.new_overflow_error("mktime argument out of range");
             let invalid_value = || vm.new_value_error("invalid struct_time parameter");
@@ -566,11 +951,99 @@ mod decl {
     impl PyStructTime {
         #[pyslot]
         fn slot_new(cls: PyTypeRef, args: FuncArgs, vm: &VirtualMachine) -> PyResult {
-            let seq: PyObjectRef = args.bind(vm)?;
+            let (seq, _dict): (PyObjectRef, OptionalArg<PyObjectRef>) = args.bind(vm)?;
             struct_sequence_new(cls, seq, vm)
         }
     }
 
+    /// Extract fields from StructTimeData into a libc::tm for mktime.
+    #[cfg(any(unix, windows))]
+    pub(super) fn tm_from_struct_time(
+        t: &StructTimeData,
+        vm: &VirtualMachine,
+    ) -> PyResult<libc::tm> {
+        let invalid_tuple = || vm.new_type_error("mktime(): illegal time tuple argument");
+        let year: i32 = t
+            .tm_year
+            .clone()
+            .try_into_value(vm)
+            .map_err(|_| invalid_tuple())?;
+        if year < i32::MIN + 1900 {
+            return Err(vm.new_overflow_error("year out of range"));
+        }
+
+        let mut tm: libc::tm = unsafe { core::mem::zeroed() };
+        tm.tm_sec = t
+            .tm_sec
+            .clone()
+            .try_into_value(vm)
+            .map_err(|_| invalid_tuple())?;
+        tm.tm_min = t
+            .tm_min
+            .clone()
+            .try_into_value(vm)
+            .map_err(|_| invalid_tuple())?;
+        tm.tm_hour = t
+            .tm_hour
+            .clone()
+            .try_into_value(vm)
+            .map_err(|_| invalid_tuple())?;
+        tm.tm_mday = t
+            .tm_mday
+            .clone()
+            .try_into_value(vm)
+            .map_err(|_| invalid_tuple())?;
+        tm.tm_mon = t
+            .tm_mon
+            .clone()
+            .try_into_value::<i32>(vm)
+            .map_err(|_| invalid_tuple())?
+            - 1;
+        tm.tm_year = year - 1900;
+        tm.tm_wday = -1;
+        tm.tm_yday = t
+            .tm_yday
+            .clone()
+            .try_into_value::<i32>(vm)
+            .map_err(|_| invalid_tuple())?
+            - 1;
+        tm.tm_isdst = t
+            .tm_isdst
+            .clone()
+            .try_into_value(vm)
+            .map_err(|_| invalid_tuple())?;
+        Ok(tm)
+    }
+
+    #[cfg(any(unix, windows))]
+    #[cfg_attr(target_env = "musl", allow(deprecated))]
+    fn pyobj_to_time_t(value: Either<f64, i64>, vm: &VirtualMachine) -> PyResult<libc::time_t> {
+        match value {
+            Either::A(float) => {
+                if !float.is_finite() {
+                    return Err(vm.new_value_error("Invalid value for timestamp"));
+                }
+                let secs = float.floor();
+                #[cfg_attr(target_env = "musl", allow(deprecated))]
+                if secs < libc::time_t::MIN as f64 || secs > libc::time_t::MAX as f64 {
+                    return Err(vm.new_overflow_error("timestamp out of range for platform time_t"));
+                }
+                #[cfg_attr(target_env = "musl", allow(deprecated))]
+                Ok(secs as libc::time_t)
+            }
+            Either::B(int) => {
+                // try_into is needed on 32-bit platforms where time_t != i64
+                #[allow(clippy::useless_conversion)]
+                #[cfg_attr(target_env = "musl", allow(deprecated))]
+                let ts: libc::time_t = int.try_into().map_err(|_| {
+                    vm.new_overflow_error("timestamp out of range for platform time_t")
+                })?;
+                Ok(ts)
+            }
+        }
+    }
+
+    #[cfg(any(unix, windows))]
     #[allow(unused_imports)]
     use super::platform::*;
 
@@ -593,14 +1066,16 @@ mod decl {
 #[pymodule(sub)]
 mod platform {
     #[allow(unused_imports)]
-    use super::decl::{SEC_TO_NS, US_TO_NS};
+    use super::decl::{SEC_TO_NS, StructTimeData, US_TO_NS};
     #[cfg_attr(target_os = "macos", allow(unused_imports))]
     use crate::{
         PyObject, PyRef, PyResult, TryFromBorrowedObject, VirtualMachine,
-        builtins::{PyNamespace, PyStrRef},
+        builtins::{PyNamespace, PyUtf8StrRef},
         convert::IntoPyException,
     };
     use core::time::Duration;
+    #[cfg_attr(target_env = "musl", allow(deprecated))]
+    use libc::time_t;
     use nix::{sys::time::TimeSpec, time::ClockId};
 
     #[cfg(target_os = "solaris")]
@@ -639,6 +1114,71 @@ mod platform {
         }
     }
 
+    fn struct_time_from_tm(vm: &VirtualMachine, tm: libc::tm) -> StructTimeData {
+        let zone = unsafe {
+            if tm.tm_zone.is_null() {
+                String::new()
+            } else {
+                core::ffi::CStr::from_ptr(tm.tm_zone)
+                    .to_string_lossy()
+                    .into_owned()
+            }
+        };
+        StructTimeData {
+            tm_year: vm.ctx.new_int(tm.tm_year + 1900).into(),
+            tm_mon: vm.ctx.new_int(tm.tm_mon + 1).into(),
+            tm_mday: vm.ctx.new_int(tm.tm_mday).into(),
+            tm_hour: vm.ctx.new_int(tm.tm_hour).into(),
+            tm_min: vm.ctx.new_int(tm.tm_min).into(),
+            tm_sec: vm.ctx.new_int(tm.tm_sec).into(),
+            tm_wday: vm.ctx.new_int((tm.tm_wday + 6) % 7).into(),
+            tm_yday: vm.ctx.new_int(tm.tm_yday + 1).into(),
+            tm_isdst: vm.ctx.new_int(tm.tm_isdst).into(),
+            tm_zone: vm.ctx.new_str(zone).into(),
+            tm_gmtoff: vm.ctx.new_int(tm.tm_gmtoff).into(),
+        }
+    }
+
+    #[cfg_attr(target_env = "musl", allow(deprecated))]
+    pub(super) fn current_time_t() -> time_t {
+        unsafe { libc::time(core::ptr::null_mut()) }
+    }
+
+    #[cfg_attr(target_env = "musl", allow(deprecated))]
+    pub(super) fn gmtime_from_timestamp(
+        when: time_t,
+        vm: &VirtualMachine,
+    ) -> PyResult<StructTimeData> {
+        let mut out = core::mem::MaybeUninit::<libc::tm>::uninit();
+        let ret = unsafe { libc::gmtime_r(&when, out.as_mut_ptr()) };
+        if ret.is_null() {
+            return Err(vm.new_overflow_error("timestamp out of range for platform time_t"));
+        }
+        Ok(struct_time_from_tm(vm, unsafe { out.assume_init() }))
+    }
+
+    #[cfg_attr(target_env = "musl", allow(deprecated))]
+    pub(super) fn localtime_from_timestamp(
+        when: time_t,
+        vm: &VirtualMachine,
+    ) -> PyResult<StructTimeData> {
+        let mut out = core::mem::MaybeUninit::<libc::tm>::uninit();
+        let ret = unsafe { libc::localtime_r(&when, out.as_mut_ptr()) };
+        if ret.is_null() {
+            return Err(vm.new_overflow_error("timestamp out of range for platform time_t"));
+        }
+        Ok(struct_time_from_tm(vm, unsafe { out.assume_init() }))
+    }
+
+    pub(super) fn unix_mktime(t: &StructTimeData, vm: &VirtualMachine) -> PyResult<f64> {
+        let mut tm = super::decl::tm_from_struct_time(t, vm)?;
+        let timestamp = unsafe { libc::mktime(&mut tm) };
+        if timestamp == -1 && tm.tm_wday == -1 {
+            return Err(vm.new_overflow_error("mktime argument out of range"));
+        }
+        Ok(timestamp as f64)
+    }
+
     fn get_clock_time(clk_id: ClockId, vm: &VirtualMachine) -> PyResult<Duration> {
         let ts = nix::time::clock_gettime(clk_id).map_err(|e| e.into_pyexception(vm))?;
         Ok(ts.into())
@@ -686,6 +1226,7 @@ mod platform {
 
     #[cfg(not(target_os = "redox"))]
     #[cfg(any(not(target_vendor = "apple"), target_os = "macos"))]
+    #[cfg_attr(target_env = "musl", allow(deprecated))]
     #[pyfunction]
     fn clock_settime_ns(clk_id: ClockId, time: libc::time_t, vm: &VirtualMachine) -> PyResult<()> {
         let ts = Duration::from_nanos(time as _).into();
@@ -703,8 +1244,8 @@ mod platform {
         target_os = "linux",
     ))]
     #[pyfunction]
-    fn get_clock_info(name: PyStrRef, vm: &VirtualMachine) -> PyResult<PyRef<PyNamespace>> {
-        let (adj, imp, mono, res) = match name.as_ref() {
+    fn get_clock_info(name: PyUtf8StrRef, vm: &VirtualMachine) -> PyResult<PyRef<PyNamespace>> {
+        let (adj, imp, mono, res) = match name.as_str() {
             "monotonic" | "perf_counter" => (
                 false,
                 "time.clock_gettime(CLOCK_MONOTONIC)",
@@ -750,7 +1291,7 @@ mod platform {
         target_os = "linux",
     )))]
     #[pyfunction]
-    fn get_clock_info(_name: PyStrRef, vm: &VirtualMachine) -> PyResult<PyRef<PyNamespace>> {
+    fn get_clock_info(_name: PyUtf8StrRef, vm: &VirtualMachine) -> PyResult<PyRef<PyNamespace>> {
         Err(vm.new_not_implemented_error("get_clock_info unsupported on this system"))
     }
 
@@ -812,14 +1353,14 @@ mod platform {
 }
 
 #[cfg(windows)]
-#[pymodule]
+#[pymodule(sub)]
 mod platform {
-    use super::decl::{MS_TO_NS, SEC_TO_NS, time_muldiv};
+    use super::decl::{MS_TO_NS, SEC_TO_NS, StructTimeData, get_tz_info, time_muldiv};
     use crate::{
         PyRef, PyResult, VirtualMachine,
-        builtins::{PyNamespace, PyStrRef},
+        builtins::{PyNamespace, PyUtf8StrRef},
     };
-    use std::time::Duration;
+    use core::time::Duration;
     use windows_sys::Win32::{
         Foundation::FILETIME,
         System::Performance::{QueryPerformanceCounter, QueryPerformanceFrequency},
@@ -827,6 +1368,93 @@ mod platform {
         System::Threading::{GetCurrentProcess, GetCurrentThread, GetProcessTimes, GetThreadTimes},
     };
 
+    unsafe extern "C" {
+        fn _gmtime64_s(tm: *mut libc::tm, time: *const libc::time_t) -> libc::c_int;
+        fn _localtime64_s(tm: *mut libc::tm, time: *const libc::time_t) -> libc::c_int;
+        #[link_name = "_mktime64"]
+        fn c_mktime(tm: *mut libc::tm) -> libc::time_t;
+    }
+
+    fn struct_time_from_tm(
+        vm: &VirtualMachine,
+        tm: libc::tm,
+        zone: &str,
+        gmtoff: i32,
+    ) -> StructTimeData {
+        StructTimeData {
+            tm_year: vm.ctx.new_int(tm.tm_year + 1900).into(),
+            tm_mon: vm.ctx.new_int(tm.tm_mon + 1).into(),
+            tm_mday: vm.ctx.new_int(tm.tm_mday).into(),
+            tm_hour: vm.ctx.new_int(tm.tm_hour).into(),
+            tm_min: vm.ctx.new_int(tm.tm_min).into(),
+            tm_sec: vm.ctx.new_int(tm.tm_sec).into(),
+            tm_wday: vm.ctx.new_int((tm.tm_wday + 6) % 7).into(),
+            tm_yday: vm.ctx.new_int(tm.tm_yday + 1).into(),
+            tm_isdst: vm.ctx.new_int(tm.tm_isdst).into(),
+            tm_zone: vm.ctx.new_str(zone).into(),
+            tm_gmtoff: vm.ctx.new_int(gmtoff).into(),
+        }
+    }
+
+    #[cfg_attr(target_env = "musl", allow(deprecated))]
+    pub(super) fn current_time_t() -> libc::time_t {
+        unsafe { libc::time(core::ptr::null_mut()) }
+    }
+
+    #[cfg_attr(target_env = "musl", allow(deprecated))]
+    pub(super) fn gmtime_from_timestamp(
+        when: libc::time_t,
+        vm: &VirtualMachine,
+    ) -> PyResult<StructTimeData> {
+        let mut out = core::mem::MaybeUninit::<libc::tm>::uninit();
+        let err = unsafe { _gmtime64_s(out.as_mut_ptr(), &when) };
+        if err != 0 {
+            return Err(vm.new_overflow_error("timestamp out of range for platform time_t"));
+        }
+        Ok(struct_time_from_tm(
+            vm,
+            unsafe { out.assume_init() },
+            "UTC",
+            0,
+        ))
+    }
+
+    #[cfg_attr(target_env = "musl", allow(deprecated))]
+    pub(super) fn localtime_from_timestamp(
+        when: libc::time_t,
+        vm: &VirtualMachine,
+    ) -> PyResult<StructTimeData> {
+        let mut out = core::mem::MaybeUninit::<libc::tm>::uninit();
+        let err = unsafe { _localtime64_s(out.as_mut_ptr(), &when) };
+        if err != 0 {
+            return Err(vm.new_overflow_error("timestamp out of range for platform time_t"));
+        }
+        let tm = unsafe { out.assume_init() };
+
+        // Get timezone info from Windows API
+        let info = get_tz_info();
+        let (bias, name) = if tm.tm_isdst > 0 {
+            (info.DaylightBias, &info.DaylightName)
+        } else {
+            (info.StandardBias, &info.StandardName)
+        };
+        let zone = widestring::decode_utf16_lossy(name.iter().copied())
+            .take_while(|&c| c != '\0')
+            .collect::<String>();
+        let gmtoff = -((info.Bias + bias) as i32) * 60;
+
+        Ok(struct_time_from_tm(vm, tm, &zone, gmtoff))
+    }
+
+    pub(super) fn win_mktime(t: &StructTimeData, vm: &VirtualMachine) -> PyResult<f64> {
+        let mut tm = super::decl::tm_from_struct_time(t, vm)?;
+        let timestamp = unsafe { rustpython_common::suppress_iph!(c_mktime(&mut tm)) };
+        if timestamp == -1 && tm.tm_wday == -1 {
+            return Err(vm.new_overflow_error("mktime argument out of range"));
+        }
+        Ok(timestamp as f64)
+    }
+
     fn u64_from_filetime(time: FILETIME) -> u64 {
         let large: [u32; 2] = [time.dwLowDateTime, time.dwHighDateTime];
         unsafe { core::mem::transmute(large) }
@@ -834,7 +1462,7 @@ mod platform {
 
     fn win_perf_counter_frequency(vm: &VirtualMachine) -> PyResult<i64> {
         let frequency = unsafe {
-            let mut freq = std::mem::MaybeUninit::uninit();
+            let mut freq = core::mem::MaybeUninit::uninit();
             if QueryPerformanceFrequency(freq.as_mut_ptr()) == 0 {
                 return Err(vm.new_last_os_error());
             }
@@ -861,7 +1489,7 @@ mod platform {
 
     pub(super) fn get_perf_time(vm: &VirtualMachine) -> PyResult<Duration> {
         let ticks = unsafe {
-            let mut performance_count = std::mem::MaybeUninit::uninit();
+            let mut performance_count = core::mem::MaybeUninit::uninit();
             QueryPerformanceCounter(performance_count.as_mut_ptr());
             performance_count.assume_init()
         };
@@ -874,9 +1502,9 @@ mod platform {
     }
 
     fn get_system_time_adjustment(vm: &VirtualMachine) -> PyResult<u32> {
-        let mut _time_adjustment = std::mem::MaybeUninit::uninit();
-        let mut time_increment = std::mem::MaybeUninit::uninit();
-        let mut _is_time_adjustment_disabled = std::mem::MaybeUninit::uninit();
+        let mut _time_adjustment = core::mem::MaybeUninit::uninit();
+        let mut time_increment = core::mem::MaybeUninit::uninit();
+        let mut _is_time_adjustment_disabled = core::mem::MaybeUninit::uninit();
         let time_increment = unsafe {
             if GetSystemTimeAdjustment(
                 _time_adjustment.as_mut_ptr(),
@@ -903,8 +1531,8 @@ mod platform {
     }
 
     #[pyfunction]
-    fn get_clock_info(name: PyStrRef, vm: &VirtualMachine) -> PyResult<PyRef<PyNamespace>> {
-        let (adj, imp, mono, res) = match name.as_ref() {
+    fn get_clock_info(name: PyUtf8StrRef, vm: &VirtualMachine) -> PyResult<PyRef<PyNamespace>> {
+        let (adj, imp, mono, res) = match name.as_str() {
             "monotonic" => (
                 false,
                 "GetTickCount64()",
@@ -938,10 +1566,10 @@ mod platform {
 
     pub(super) fn get_thread_time(vm: &VirtualMachine) -> PyResult<Duration> {
         let (kernel_time, user_time) = unsafe {
-            let mut _creation_time = std::mem::MaybeUninit::uninit();
-            let mut _exit_time = std::mem::MaybeUninit::uninit();
-            let mut kernel_time = std::mem::MaybeUninit::uninit();
-            let mut user_time = std::mem::MaybeUninit::uninit();
+            let mut _creation_time = core::mem::MaybeUninit::uninit();
+            let mut _exit_time = core::mem::MaybeUninit::uninit();
+            let mut kernel_time = core::mem::MaybeUninit::uninit();
+            let mut user_time = core::mem::MaybeUninit::uninit();
 
             let thread = GetCurrentThread();
             if GetThreadTimes(
@@ -963,10 +1591,10 @@ mod platform {
 
     pub(super) fn get_process_time(vm: &VirtualMachine) -> PyResult<Duration> {
         let (kernel_time, user_time) = unsafe {
-            let mut _creation_time = std::mem::MaybeUninit::uninit();
-            let mut _exit_time = std::mem::MaybeUninit::uninit();
-            let mut kernel_time = std::mem::MaybeUninit::uninit();
-            let mut user_time = std::mem::MaybeUninit::uninit();
+            let mut _creation_time = core::mem::MaybeUninit::uninit();
+            let mut _exit_time = core::mem::MaybeUninit::uninit();
+            let mut kernel_time = core::mem::MaybeUninit::uninit();
+            let mut user_time = core::mem::MaybeUninit::uninit();
 
             let process = GetCurrentProcess();
             if GetProcessTimes(
@@ -986,8 +1614,3 @@ mod platform {
         Ok(Duration::from_nanos((k_time + u_time) * 100))
     }
 }
-
-// mostly for wasm32
-#[cfg(not(any(unix, windows)))]
-#[pymodule(sub)]
-mod platform {}
diff --git a/crates/vm/src/stdlib/typevar.rs b/crates/vm/src/stdlib/typevar.rs
index 36f2b170023..b28fad21bd7 100644
--- a/crates/vm/src/stdlib/typevar.rs
+++ b/crates/vm/src/stdlib/typevar.rs
@@ -6,30 +6,40 @@ pub use typevar::*;
 pub(crate) mod typevar {
     use crate::{
         AsObject, Context, Py, PyObject, PyObjectRef, PyPayload, PyRef, PyResult, VirtualMachine,
-        builtins::{PyTuple, PyTupleRef, PyType, PyTypeRef, make_union, pystr::AsPyStr},
+        builtins::{PyTuple, PyTupleRef, PyType, PyTypeRef, make_union},
         common::lock::PyMutex,
-        function::{FuncArgs, IntoFuncArgs, PyComparisonValue},
+        function::{FuncArgs, PyComparisonValue},
         protocol::PyNumberMethods,
+        stdlib::_typing::{call_typing_func_object, decl::const_evaluator_alloc},
         types::{AsNumber, Comparable, Constructor, Iterable, PyComparisonOp, Representable},
     };
 
-    pub(crate) fn _call_typing_func_object<'a>(
-        vm: &VirtualMachine,
-        func_name: impl AsPyStr<'a>,
-        args: impl IntoFuncArgs,
-    ) -> PyResult {
-        let module = vm.import("typing", 0)?;
-        let func = module.get_attr(func_name.as_pystr(&vm.ctx), vm)?;
-        func.call(args, vm)
-    }
-
     fn type_check(arg: PyObjectRef, msg: &str, vm: &VirtualMachine) -> PyResult<PyObjectRef> {
         // Calling typing.py here leads to bootstrapping problems
         if vm.is_none(&arg) {
             return Ok(arg.class().to_owned().into());
         }
         let message_str: PyObjectRef = vm.ctx.new_str(msg).into();
-        _call_typing_func_object(vm, "_type_check", (arg, message_str))
+        call_typing_func_object(vm, "_type_check", (arg, message_str))
+    }
+
+    fn variance_repr(
+        name: &str,
+        infer_variance: bool,
+        covariant: bool,
+        contravariant: bool,
+    ) -> String {
+        if infer_variance {
+            return name.to_owned();
+        }
+        let prefix = if covariant {
+            '+'
+        } else if contravariant {
+            '-'
+        } else {
+            '~'
+        };
+        format!("{prefix}{name}")
     }
 
     /// Get the module of the caller frame, similar to CPython's caller() function.
@@ -52,23 +62,19 @@ pub(crate) mod typevar {
     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) {
+        let module_value: PyObjectRef = if let Some(module_name) = caller(vm) {
             // Special handling for certain module names
-            if let Ok(name_str) = module_name.str(vm) {
-                let name = name_str.as_str();
-                // CPython sets __module__ to None for builtins and <...> modules
-                // Also set to None for exec contexts (no __name__ in globals means exec)
-                if name == "builtins" || name.starts_with('<') {
-                    // Don't set __module__ attribute at all (CPython behavior)
-                    // This allows the typing module to handle it
-                    return Ok(());
-                }
+            if let Ok(name_str) = module_name.str(vm)
+                && let Some(name) = name_str.to_str()
+                && (name == "builtins" || name.starts_with('<'))
+            {
+                return Ok(());
             }
-            obj.set_attr("__module__", module_name, vm)?;
+            module_name
         } else {
-            // If no module name is found (e.g., in exec context), set __module__ to None
-            obj.set_attr("__module__", vm.ctx.none(), vm)?;
-        }
+            vm.ctx.none()
+        };
+        obj.set_attr("__module__", module_value, vm)?;
         Ok(())
     }
 
@@ -78,17 +84,20 @@ pub(crate) mod typevar {
     #[allow(dead_code)]
     pub struct TypeVar {
         name: PyObjectRef, // TODO PyStrRef?
-        bound: parking_lot::Mutex<PyObjectRef>,
+        bound: PyMutex<PyObjectRef>,
         evaluate_bound: PyObjectRef,
-        constraints: parking_lot::Mutex<PyObjectRef>,
+        constraints: PyMutex<PyObjectRef>,
         evaluate_constraints: PyObjectRef,
-        default_value: parking_lot::Mutex<PyObjectRef>,
+        default_value: PyMutex<PyObjectRef>,
         evaluate_default: PyMutex<PyObjectRef>,
         covariant: bool,
         contravariant: bool,
         infer_variance: bool,
     }
-    #[pyclass(flags(HAS_DICT), with(AsNumber, Constructor, Representable))]
+    #[pyclass(
+        flags(HAS_DICT, HAS_WEAKREF),
+        with(AsNumber, Constructor, Representable)
+    )]
     impl TypeVar {
         #[pymethod]
         fn __mro_entries__(&self, _bases: PyObjectRef, vm: &VirtualMachine) -> PyResult {
@@ -107,7 +116,7 @@ pub(crate) mod typevar {
                 return Ok(constraints.clone());
             }
             let r = if !vm.is_none(&self.evaluate_constraints) {
-                *constraints = self.evaluate_constraints.call((), vm)?;
+                *constraints = self.evaluate_constraints.call((1i32,), vm)?;
                 constraints.clone()
             } else {
                 vm.ctx.empty_tuple.clone().into()
@@ -122,7 +131,7 @@ pub(crate) mod typevar {
                 return Ok(bound.clone());
             }
             let r = if !vm.is_none(&self.evaluate_bound) {
-                *bound = self.evaluate_bound.call((), vm)?;
+                *bound = self.evaluate_bound.call((1i32,), vm)?;
                 bound.clone()
             } else {
                 vm.ctx.none()
@@ -147,21 +156,59 @@ pub(crate) mod typevar {
 
         #[pygetset]
         fn __default__(&self, vm: &VirtualMachine) -> PyResult {
-            let mut default_value = self.default_value.lock();
-            // Check if default_value is NoDefault (not just None)
-            if !default_value.is(&vm.ctx.typing_no_default) {
-                return Ok(default_value.clone());
+            {
+                let default_value = self.default_value.lock();
+                if !default_value.is(&vm.ctx.typing_no_default) {
+                    return Ok(default_value.clone());
+                }
             }
-            let evaluate_default = self.evaluate_default.lock();
-            if !vm.is_none(&evaluate_default) {
-                *default_value = evaluate_default.call((), vm)?;
-                Ok(default_value.clone())
+            let evaluator = self.evaluate_default.lock().clone();
+            if !vm.is_none(&evaluator) {
+                let result = evaluator.call((1i32,), vm)?;
+                *self.default_value.lock() = result.clone();
+                Ok(result)
             } else {
-                // Return NoDefault singleton
                 Ok(vm.ctx.typing_no_default.clone().into())
             }
         }
 
+        #[pygetset]
+        fn evaluate_bound(&self, vm: &VirtualMachine) -> PyResult {
+            if !vm.is_none(&self.evaluate_bound) {
+                return Ok(self.evaluate_bound.clone());
+            }
+            let bound = self.bound.lock();
+            if !vm.is_none(&bound) {
+                return Ok(const_evaluator_alloc(bound.clone(), vm));
+            }
+            Ok(vm.ctx.none())
+        }
+
+        #[pygetset]
+        fn evaluate_constraints(&self, vm: &VirtualMachine) -> PyResult {
+            if !vm.is_none(&self.evaluate_constraints) {
+                return Ok(self.evaluate_constraints.clone());
+            }
+            let constraints = self.constraints.lock();
+            if !vm.is_none(&constraints) {
+                return Ok(const_evaluator_alloc(constraints.clone(), vm));
+            }
+            Ok(vm.ctx.none())
+        }
+
+        #[pygetset]
+        fn evaluate_default(&self, vm: &VirtualMachine) -> PyResult {
+            let evaluator = self.evaluate_default.lock().clone();
+            if !vm.is_none(&evaluator) {
+                return Ok(evaluator);
+            }
+            let default_value = self.default_value.lock().clone();
+            if !default_value.is(&vm.ctx.typing_no_default) {
+                return Ok(const_evaluator_alloc(default_value, vm));
+            }
+            Ok(vm.ctx.none())
+        }
+
         #[pymethod]
         fn __typing_subst__(
             zelf: crate::PyRef<Self>,
@@ -169,7 +216,7 @@ pub(crate) mod typevar {
             vm: &VirtualMachine,
         ) -> PyResult {
             let self_obj: PyObjectRef = zelf.into();
-            _call_typing_func_object(vm, "_typevar_subst", (self_obj, arg))
+            call_typing_func_object(vm, "_typevar_subst", (self_obj, arg))
         }
 
         #[pymethod]
@@ -240,15 +287,13 @@ pub(crate) mod typevar {
     impl Representable for TypeVar {
         #[inline(always)]
         fn repr_str(zelf: &crate::Py<Self>, vm: &VirtualMachine) -> PyResult<String> {
-            let name = zelf.name.str(vm)?;
-            let repr = if zelf.covariant {
-                format!("+{name}")
-            } else if zelf.contravariant {
-                format!("-{name}")
-            } else {
-                format!("~{name}")
-            };
-            Ok(repr)
+            let name = zelf.name.str_utf8(vm)?;
+            Ok(variance_repr(
+                name.as_str(),
+                zelf.infer_variance,
+                zelf.covariant,
+                zelf.contravariant,
+            ))
         }
     }
 
@@ -342,7 +387,7 @@ pub(crate) mod typevar {
                     return Err(vm.new_type_error("Constraints cannot be used with bound"));
                 }
                 let constraints_tuple = vm.ctx.new_tuple(constraints);
-                (constraints_tuple.clone().into(), constraints_tuple.into())
+                (constraints_tuple.into(), vm.ctx.none())
             } else {
                 (vm.ctx.none(), vm.ctx.none())
             };
@@ -370,11 +415,11 @@ pub(crate) mod typevar {
 
             Ok(Self {
                 name,
-                bound: parking_lot::Mutex::new(bound_obj),
+                bound: PyMutex::new(bound_obj),
                 evaluate_bound,
-                constraints: parking_lot::Mutex::new(constraints_obj),
+                constraints: PyMutex::new(constraints_obj),
                 evaluate_constraints,
-                default_value: parking_lot::Mutex::new(default_value),
+                default_value: PyMutex::new(default_value),
                 evaluate_default: PyMutex::new(evaluate_default),
                 covariant,
                 contravariant,
@@ -392,15 +437,15 @@ pub(crate) mod typevar {
         ) -> Self {
             Self {
                 name,
-                bound: parking_lot::Mutex::new(vm.ctx.none()),
+                bound: PyMutex::new(vm.ctx.none()),
                 evaluate_bound,
-                constraints: parking_lot::Mutex::new(vm.ctx.none()),
+                constraints: PyMutex::new(vm.ctx.none()),
                 evaluate_constraints,
-                default_value: parking_lot::Mutex::new(vm.ctx.typing_no_default.clone().into()),
+                default_value: PyMutex::new(vm.ctx.typing_no_default.clone().into()),
                 evaluate_default: PyMutex::new(vm.ctx.none()),
                 covariant: false,
                 contravariant: false,
-                infer_variance: false,
+                infer_variance: true,
             }
         }
     }
@@ -412,14 +457,17 @@ pub(crate) mod typevar {
     pub struct ParamSpec {
         name: PyObjectRef,
         bound: Option<PyObjectRef>,
-        default_value: PyObjectRef,
+        default_value: PyMutex<PyObjectRef>,
         evaluate_default: PyMutex<PyObjectRef>,
         covariant: bool,
         contravariant: bool,
         infer_variance: bool,
     }
 
-    #[pyclass(flags(HAS_DICT), with(AsNumber, Constructor, Representable))]
+    #[pyclass(
+        flags(HAS_DICT, HAS_WEAKREF),
+        with(AsNumber, Constructor, Representable)
+    )]
     impl ParamSpec {
         #[pymethod]
         fn __mro_entries__(&self, _bases: PyObjectRef, vm: &VirtualMachine) -> PyResult {
@@ -474,23 +522,33 @@ pub(crate) mod typevar {
 
         #[pygetset]
         fn __default__(&self, vm: &VirtualMachine) -> PyResult {
-            // Check if default_value is NoDefault (not just None)
-            if !self.default_value.is(&vm.ctx.typing_no_default) {
-                return Ok(self.default_value.clone());
+            {
+                let default_value = self.default_value.lock();
+                if !default_value.is(&vm.ctx.typing_no_default) {
+                    return Ok(default_value.clone());
+                }
             }
-            // handle evaluate_default
-            let evaluate_default = self.evaluate_default.lock();
-            if !vm.is_none(&evaluate_default) {
-                let default_value = evaluate_default.call((), vm)?;
-                return Ok(default_value);
+            let evaluator = self.evaluate_default.lock().clone();
+            if !vm.is_none(&evaluator) {
+                let result = evaluator.call((1i32,), vm)?;
+                *self.default_value.lock() = result.clone();
+                Ok(result)
+            } else {
+                Ok(vm.ctx.typing_no_default.clone().into())
             }
-            // Return NoDefault singleton
-            Ok(vm.ctx.typing_no_default.clone().into())
         }
 
         #[pygetset]
-        fn evaluate_default(&self, _vm: &VirtualMachine) -> PyObjectRef {
-            self.evaluate_default.lock().clone()
+        fn evaluate_default(&self, vm: &VirtualMachine) -> PyResult {
+            let evaluator = self.evaluate_default.lock().clone();
+            if !vm.is_none(&evaluator) {
+                return Ok(evaluator);
+            }
+            let default_value = self.default_value.lock().clone();
+            if !default_value.is(&vm.ctx.typing_no_default) {
+                return Ok(const_evaluator_alloc(default_value, vm));
+            }
+            Ok(vm.ctx.none())
         }
 
         #[pymethod]
@@ -503,8 +561,7 @@ pub(crate) mod typevar {
             if !vm.is_none(&self.evaluate_default.lock()) {
                 return true;
             }
-            // Check if default_value is not NoDefault
-            !self.default_value.is(&vm.ctx.typing_no_default)
+            !self.default_value.lock().is(&vm.ctx.typing_no_default)
         }
 
         #[pymethod]
@@ -514,7 +571,7 @@ pub(crate) mod typevar {
             vm: &VirtualMachine,
         ) -> PyResult {
             let self_obj: PyObjectRef = zelf.into();
-            _call_typing_func_object(vm, "_paramspec_subst", (self_obj, arg))
+            call_typing_func_object(vm, "_paramspec_subst", (self_obj, arg))
         }
 
         #[pymethod]
@@ -525,7 +582,7 @@ pub(crate) mod typevar {
             vm: &VirtualMachine,
         ) -> PyResult {
             let self_obj: PyObjectRef = zelf.into();
-            _call_typing_func_object(vm, "_paramspec_prepare_subst", (self_obj, alias, args))
+            call_typing_func_object(vm, "_paramspec_prepare_subst", (self_obj, alias, args))
         }
     }
 
@@ -563,7 +620,10 @@ pub(crate) mod typevar {
                 return Err(vm.new_type_error("ParamSpec() takes at most 1 positional argument"));
             };
 
-            let bound = kwargs.swap_remove("bound");
+            let bound = kwargs
+                .swap_remove("bound")
+                .map(|b| type_check(b, "Bound must be a type.", vm))
+                .transpose()?;
             let covariant = kwargs
                 .swap_remove("covariant")
                 .map(|v| v.try_to_bool(vm))
@@ -605,7 +665,7 @@ pub(crate) mod typevar {
             let paramspec = Self {
                 name,
                 bound,
-                default_value,
+                default_value: PyMutex::new(default_value),
                 evaluate_default: PyMutex::new(vm.ctx.none()),
                 covariant,
                 contravariant,
@@ -626,8 +686,13 @@ pub(crate) mod typevar {
     impl Representable for ParamSpec {
         #[inline(always)]
         fn repr_str(zelf: &crate::Py<Self>, vm: &VirtualMachine) -> PyResult<String> {
-            let name = zelf.__name__().str(vm)?;
-            Ok(format!("~{name}"))
+            let name = zelf.__name__().str_utf8(vm)?;
+            Ok(variance_repr(
+                name.as_str(),
+                zelf.infer_variance,
+                zelf.covariant,
+                zelf.contravariant,
+            ))
         }
     }
 
@@ -636,11 +701,11 @@ pub(crate) mod typevar {
             Self {
                 name,
                 bound: None,
-                default_value: vm.ctx.typing_no_default.clone().into(),
+                default_value: PyMutex::new(vm.ctx.typing_no_default.clone().into()),
                 evaluate_default: PyMutex::new(vm.ctx.none()),
                 covariant: false,
                 contravariant: false,
-                infer_variance: false,
+                infer_variance: true,
             }
         }
     }
@@ -651,10 +716,13 @@ pub(crate) mod typevar {
     #[allow(dead_code)]
     pub struct TypeVarTuple {
         name: PyObjectRef,
-        default_value: parking_lot::Mutex<PyObjectRef>,
+        default_value: PyMutex<PyObjectRef>,
         evaluate_default: PyMutex<PyObjectRef>,
     }
-    #[pyclass(flags(HAS_DICT), with(Constructor, Representable, Iterable))]
+    #[pyclass(
+        flags(HAS_DICT, HAS_WEAKREF),
+        with(Constructor, Representable, Iterable)
+    )]
     impl TypeVarTuple {
         #[pygetset]
         fn __name__(&self) -> PyObjectRef {
@@ -663,28 +731,41 @@ pub(crate) mod typevar {
 
         #[pygetset]
         fn __default__(&self, vm: &VirtualMachine) -> PyResult {
-            let mut default_value = self.default_value.lock();
-            // Check if default_value is NoDefault (not just None)
-            if !default_value.is(&vm.ctx.typing_no_default) {
-                return Ok(default_value.clone());
+            {
+                let default_value = self.default_value.lock();
+                if !default_value.is(&vm.ctx.typing_no_default) {
+                    return Ok(default_value.clone());
+                }
             }
-            let evaluate_default = self.evaluate_default.lock();
-            if !vm.is_none(&evaluate_default) {
-                *default_value = evaluate_default.call((), vm)?;
-                Ok(default_value.clone())
+            let evaluator = self.evaluate_default.lock().clone();
+            if !vm.is_none(&evaluator) {
+                let result = evaluator.call((1i32,), vm)?;
+                *self.default_value.lock() = result.clone();
+                Ok(result)
             } else {
-                // Return NoDefault singleton
                 Ok(vm.ctx.typing_no_default.clone().into())
             }
         }
 
+        #[pygetset]
+        fn evaluate_default(&self, vm: &VirtualMachine) -> PyResult {
+            let evaluator = self.evaluate_default.lock().clone();
+            if !vm.is_none(&evaluator) {
+                return Ok(evaluator);
+            }
+            let default_value = self.default_value.lock().clone();
+            if !default_value.is(&vm.ctx.typing_no_default) {
+                return Ok(const_evaluator_alloc(default_value, vm));
+            }
+            Ok(vm.ctx.none())
+        }
+
         #[pymethod]
         fn has_default(&self, vm: &VirtualMachine) -> bool {
             if !vm.is_none(&self.evaluate_default.lock()) {
                 return true;
             }
             let default_value = self.default_value.lock();
-            // Check if default_value is not NoDefault
             !default_value.is(&vm.ctx.typing_no_default)
         }
 
@@ -711,7 +792,7 @@ pub(crate) mod typevar {
             vm: &VirtualMachine,
         ) -> PyResult {
             let self_obj: PyObjectRef = zelf.into();
-            _call_typing_func_object(vm, "_typevartuple_prepare_subst", (self_obj, alias, args))
+            call_typing_func_object(vm, "_typevartuple_prepare_subst", (self_obj, alias, args))
         }
     }
 
@@ -771,7 +852,7 @@ pub(crate) mod typevar {
 
             let typevartuple = Self {
                 name,
-                default_value: parking_lot::Mutex::new(default_value),
+                default_value: PyMutex::new(default_value),
                 evaluate_default: PyMutex::new(evaluate_default),
             };
 
@@ -798,7 +879,7 @@ pub(crate) mod typevar {
         pub fn new(name: PyObjectRef, vm: &VirtualMachine) -> Self {
             Self {
                 name,
-                default_value: parking_lot::Mutex::new(vm.ctx.typing_no_default.clone().into()),
+                default_value: PyMutex::new(vm.ctx.typing_no_default.clone().into()),
                 evaluate_default: PyMutex::new(vm.ctx.none()),
             }
         }
@@ -811,7 +892,7 @@ pub(crate) mod typevar {
     pub struct ParamSpecArgs {
         __origin__: PyObjectRef,
     }
-    #[pyclass(with(Constructor, Representable, Comparable))]
+    #[pyclass(with(Constructor, Representable, Comparable), flags(HAS_WEAKREF))]
     impl ParamSpecArgs {
         #[pymethod]
         fn __mro_entries__(&self, _bases: PyObjectRef, vm: &VirtualMachine) -> PyResult {
@@ -851,35 +932,19 @@ pub(crate) mod typevar {
             op: PyComparisonOp,
             vm: &VirtualMachine,
         ) -> PyResult<PyComparisonValue> {
-            fn eq(
-                zelf: &crate::Py<ParamSpecArgs>,
-                other: PyObjectRef,
-                _vm: &VirtualMachine,
-            ) -> PyResult<bool> {
-                // First check if other is also ParamSpecArgs
-                if let Ok(other_args) = other.downcast::<ParamSpecArgs>() {
-                    // Check if they have the same origin
-                    return Ok(zelf.__origin__.is(&other_args.__origin__));
+            op.eq_only(|| {
+                if other.class().is(zelf.class())
+                    && let Some(other_args) = other.downcast_ref::<ParamSpecArgs>()
+                {
+                    let eq = zelf.__origin__.rich_compare_bool(
+                        &other_args.__origin__,
+                        PyComparisonOp::Eq,
+                        vm,
+                    )?;
+                    return Ok(PyComparisonValue::Implemented(eq));
                 }
-                Ok(false)
-            }
-            match op {
-                PyComparisonOp::Eq => {
-                    if let Ok(result) = eq(zelf, other.to_owned(), vm) {
-                        Ok(result.into())
-                    } else {
-                        Ok(PyComparisonValue::NotImplemented)
-                    }
-                }
-                PyComparisonOp::Ne => {
-                    if let Ok(result) = eq(zelf, other.to_owned(), vm) {
-                        Ok((!result).into())
-                    } else {
-                        Ok(PyComparisonValue::NotImplemented)
-                    }
-                }
-                _ => Ok(PyComparisonValue::NotImplemented),
-            }
+                Ok(PyComparisonValue::NotImplemented)
+            })
         }
     }
 
@@ -890,7 +955,7 @@ pub(crate) mod typevar {
     pub struct ParamSpecKwargs {
         __origin__: PyObjectRef,
     }
-    #[pyclass(with(Constructor, Representable, Comparable))]
+    #[pyclass(with(Constructor, Representable, Comparable), flags(HAS_WEAKREF))]
     impl ParamSpecKwargs {
         #[pymethod]
         fn __mro_entries__(&self, _bases: PyObjectRef, vm: &VirtualMachine) -> PyResult {
@@ -930,35 +995,19 @@ pub(crate) mod typevar {
             op: PyComparisonOp,
             vm: &VirtualMachine,
         ) -> PyResult<PyComparisonValue> {
-            fn eq(
-                zelf: &crate::Py<ParamSpecKwargs>,
-                other: PyObjectRef,
-                _vm: &VirtualMachine,
-            ) -> PyResult<bool> {
-                // First check if other is also ParamSpecKwargs
-                if let Ok(other_kwargs) = other.downcast::<ParamSpecKwargs>() {
-                    // Check if they have the same origin
-                    return Ok(zelf.__origin__.is(&other_kwargs.__origin__));
-                }
-                Ok(false)
-            }
-            match op {
-                PyComparisonOp::Eq => {
-                    if let Ok(result) = eq(zelf, other.to_owned(), vm) {
-                        Ok(result.into())
-                    } else {
-                        Ok(PyComparisonValue::NotImplemented)
-                    }
+            op.eq_only(|| {
+                if other.class().is(zelf.class())
+                    && let Some(other_kwargs) = other.downcast_ref::<ParamSpecKwargs>()
+                {
+                    let eq = zelf.__origin__.rich_compare_bool(
+                        &other_kwargs.__origin__,
+                        PyComparisonOp::Eq,
+                        vm,
+                    )?;
+                    return Ok(PyComparisonValue::Implemented(eq));
                 }
-                PyComparisonOp::Ne => {
-                    if let Ok(result) = eq(zelf, other.to_owned(), vm) {
-                        Ok((!result).into())
-                    } else {
-                        Ok(PyComparisonValue::NotImplemented)
-                    }
-                }
-                _ => Ok(PyComparisonValue::NotImplemented),
-            }
+                Ok(PyComparisonValue::NotImplemented)
+            })
         }
     }
 
@@ -992,7 +1041,7 @@ pub(crate) mod typevar {
     #[allow(dead_code)]
     pub struct Generic;
 
-    #[pyclass(flags(BASETYPE))]
+    #[pyclass(flags(BASETYPE, HEAPTYPE))]
     impl Generic {
         #[pyattr]
         fn __slots__(ctx: &Context) -> PyTupleRef {
diff --git a/crates/vm/src/stdlib/typing.rs b/crates/vm/src/stdlib/typing.rs
deleted file mode 100644
index 6938bca8bbb..00000000000
--- a/crates/vm/src/stdlib/typing.rs
+++ /dev/null
@@ -1,191 +0,0 @@
-// spell-checker:ignore typevarobject funcobj
-use crate::{Context, class::PyClassImpl};
-
-pub use crate::stdlib::typevar::{
-    Generic, ParamSpec, ParamSpecArgs, ParamSpecKwargs, TypeVar, TypeVarTuple,
-    set_typeparam_default,
-};
-pub(crate) use decl::module_def;
-pub use decl::*;
-
-/// Initialize typing types (call extend_class)
-pub fn init(ctx: &Context) {
-    NoDefault::extend_class(ctx, ctx.types.typing_no_default_type);
-}
-
-#[pymodule(name = "_typing", with(super::typevar::typevar))]
-pub(crate) mod decl {
-    use crate::{
-        Py, PyObjectRef, PyPayload, PyResult, VirtualMachine,
-        builtins::{PyStrRef, PyTupleRef, PyType, PyTypeRef, pystr::AsPyStr, type_},
-        function::{FuncArgs, IntoFuncArgs},
-        protocol::PyNumberMethods,
-        types::{AsNumber, Constructor, Representable},
-    };
-
-    pub(crate) fn _call_typing_func_object<'a>(
-        vm: &VirtualMachine,
-        func_name: impl AsPyStr<'a>,
-        args: impl IntoFuncArgs,
-    ) -> PyResult {
-        let module = vm.import("typing", 0)?;
-        let func = module.get_attr(func_name.as_pystr(&vm.ctx), vm)?;
-        func.call(args, vm)
-    }
-
-    #[pyfunction]
-    pub(crate) fn _idfunc(args: FuncArgs, _vm: &VirtualMachine) -> PyObjectRef {
-        args.args[0].clone()
-    }
-
-    #[pyfunction(name = "override")]
-    pub(crate) fn r#override(func: PyObjectRef, vm: &VirtualMachine) -> PyResult {
-        // Set __override__ attribute to True
-        // Skip the attribute silently if it is not writable.
-        // AttributeError happens if the object has __slots__ or a
-        // read-only property, TypeError if it's a builtin class.
-        let _ = func.set_attr("__override__", vm.ctx.true_value.clone(), vm);
-        Ok(func)
-    }
-
-    #[pyclass(no_attr, name = "NoDefaultType", module = "typing")]
-    #[derive(Debug, PyPayload)]
-    pub struct NoDefault;
-
-    #[pyclass(with(Constructor, Representable), flags(BASETYPE))]
-    impl NoDefault {
-        #[pymethod]
-        fn __reduce__(&self, _vm: &VirtualMachine) -> String {
-            "NoDefault".to_owned()
-        }
-    }
-
-    impl Constructor for NoDefault {
-        type Args = ();
-
-        fn slot_new(_cls: PyTypeRef, args: FuncArgs, vm: &VirtualMachine) -> PyResult {
-            let _: () = args.bind(vm)?;
-            Ok(vm.ctx.typing_no_default.clone().into())
-        }
-
-        fn py_new(_cls: &Py<PyType>, _args: Self::Args, _vm: &VirtualMachine) -> PyResult<Self> {
-            unreachable!("NoDefault is a singleton, use slot_new")
-        }
-    }
-
-    impl Representable for NoDefault {
-        #[inline(always)]
-        fn repr_str(_zelf: &Py<Self>, _vm: &VirtualMachine) -> PyResult<String> {
-            Ok("typing.NoDefault".to_owned())
-        }
-    }
-
-    #[pyattr]
-    #[pyclass(name)]
-    #[derive(Debug, PyPayload)]
-    #[allow(dead_code)]
-    pub(crate) struct TypeAliasType {
-        name: PyStrRef,
-        type_params: PyTupleRef,
-        value: PyObjectRef,
-        // compute_value: PyObjectRef,
-        // module: PyObjectRef,
-    }
-    #[pyclass(with(Constructor, Representable, AsNumber), flags(BASETYPE))]
-    impl TypeAliasType {
-        pub const fn new(name: PyStrRef, type_params: PyTupleRef, value: PyObjectRef) -> Self {
-            Self {
-                name,
-                type_params,
-                value,
-            }
-        }
-
-        #[pygetset]
-        fn __name__(&self) -> PyObjectRef {
-            self.name.clone().into()
-        }
-
-        #[pygetset]
-        fn __value__(&self) -> PyObjectRef {
-            self.value.clone()
-        }
-
-        #[pygetset]
-        fn __type_params__(&self) -> PyTupleRef {
-            self.type_params.clone()
-        }
-    }
-
-    impl Constructor for TypeAliasType {
-        type Args = FuncArgs;
-
-        fn py_new(_cls: &Py<PyType>, args: Self::Args, vm: &VirtualMachine) -> PyResult<Self> {
-            // TypeAliasType(name, value, *, type_params=None)
-            if args.args.len() < 2 {
-                return Err(vm.new_type_error(format!(
-                    "TypeAliasType() missing {} required positional argument{}: {}",
-                    2 - args.args.len(),
-                    if 2 - args.args.len() == 1 { "" } else { "s" },
-                    if args.args.is_empty() {
-                        "'name' and 'value'"
-                    } else {
-                        "'value'"
-                    }
-                )));
-            }
-            if args.args.len() > 2 {
-                return Err(vm.new_type_error(format!(
-                    "TypeAliasType() takes 2 positional arguments but {} were given",
-                    args.args.len()
-                )));
-            }
-
-            let name = args.args[0]
-                .clone()
-                .downcast::<crate::builtins::PyStr>()
-                .map_err(|_| vm.new_type_error("TypeAliasType name must be a string".to_owned()))?;
-            let value = args.args[1].clone();
-
-            let type_params = if let Some(tp) = args.kwargs.get("type_params") {
-                tp.clone()
-                    .downcast::<crate::builtins::PyTuple>()
-                    .map_err(|_| vm.new_type_error("type_params must be a tuple".to_owned()))?
-            } else {
-                vm.ctx.empty_tuple.clone()
-            };
-
-            Ok(Self::new(name, type_params, value))
-        }
-    }
-
-    impl Representable for TypeAliasType {
-        fn repr_str(zelf: &Py<Self>, _vm: &VirtualMachine) -> PyResult<String> {
-            Ok(zelf.name.as_str().to_owned())
-        }
-    }
-
-    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)),
-                ..PyNumberMethods::NOT_IMPLEMENTED
-            };
-            &AS_NUMBER
-        }
-    }
-
-    pub(crate) fn module_exec(
-        vm: &VirtualMachine,
-        module: &Py<crate::builtins::PyModule>,
-    ) -> PyResult<()> {
-        __module_exec(vm, module);
-
-        extend_module!(vm, module, {
-            "NoDefault" => vm.ctx.typing_no_default.clone(),
-            "Union" => vm.ctx.types.union_type.to_owned(),
-        });
-
-        Ok(())
-    }
-}
diff --git a/crates/vm/src/stdlib/warnings.rs b/crates/vm/src/stdlib/warnings.rs
deleted file mode 100644
index ad54b806220..00000000000
--- a/crates/vm/src/stdlib/warnings.rs
+++ /dev/null
@@ -1,49 +0,0 @@
-pub(crate) use _warnings::module_def;
-
-use crate::{Py, PyResult, VirtualMachine, builtins::PyType};
-
-pub fn warn(
-    category: &Py<PyType>,
-    message: String,
-    stack_level: usize,
-    vm: &VirtualMachine,
-) -> PyResult<()> {
-    // TODO: use rust warnings module
-    if let Ok(module) = vm.import("warnings", 0)
-        && let Ok(func) = module.get_attr("warn", vm)
-    {
-        let _ = func.call((message, category.to_owned(), stack_level), vm);
-    }
-    Ok(())
-}
-
-#[pymodule]
-mod _warnings {
-    use crate::{
-        PyResult, VirtualMachine,
-        builtins::{PyStrRef, PyTypeRef},
-        function::OptionalArg,
-    };
-
-    #[derive(FromArgs)]
-    struct WarnArgs {
-        #[pyarg(positional)]
-        message: PyStrRef,
-        #[pyarg(any, optional)]
-        category: OptionalArg<PyTypeRef>,
-        #[pyarg(any, optional)]
-        stacklevel: OptionalArg<u32>,
-    }
-
-    #[pyfunction]
-    fn warn(args: WarnArgs, vm: &VirtualMachine) -> PyResult<()> {
-        let level = args.stacklevel.unwrap_or(1);
-        crate::warn::warn(
-            args.message,
-            args.category.into_option(),
-            level as isize,
-            None,
-            vm,
-        )
-    }
-}
diff --git a/crates/vm/src/stdlib/winreg.rs b/crates/vm/src/stdlib/winreg.rs
index 53a4fd0d556..264d14327da 100644
--- a/crates/vm/src/stdlib/winreg.rs
+++ b/crates/vm/src/stdlib/winreg.rs
@@ -14,10 +14,10 @@ mod winreg {
     use crate::protocol::PyNumberMethods;
     use crate::types::{AsNumber, Hashable};
     use crate::{Py, PyObjectRef, PyPayload, PyRef, PyResult, VirtualMachine};
+    use core::ptr;
     use crossbeam_utils::atomic::AtomicCell;
     use malachite_bigint::Sign;
     use num_traits::ToPrimitive;
-    use std::ptr;
     use windows_sys::Win32::Foundation::{self, ERROR_MORE_DATA};
     use windows_sys::Win32::System::Registry;
 
@@ -37,20 +37,12 @@ mod winreg {
         u16_slice
     }
 
-    // TODO: check if errno.rs can be reused here or not
     fn os_error_from_windows_code(
         vm: &VirtualMachine,
         code: i32,
-        func_name: &str,
     ) -> crate::PyRef<crate::builtins::PyBaseException> {
-        use windows_sys::Win32::Foundation::{ERROR_ACCESS_DENIED, ERROR_FILE_NOT_FOUND};
-        let msg = format!("[WinError {}] {}", code, func_name);
-        let exc_type = match code as u32 {
-            ERROR_FILE_NOT_FOUND => vm.ctx.exceptions.file_not_found_error.to_owned(),
-            ERROR_ACCESS_DENIED => vm.ctx.exceptions.permission_error.to_owned(),
-            _ => vm.ctx.exceptions.os_error.to_owned(),
-        };
-        vm.new_exception_msg(exc_type, msg)
+        use crate::convert::ToPyException;
+        std::io::Error::from_raw_os_error(code).to_pyexception(vm)
     }
 
     /// Wrapper type for HKEY that can be created from PyHkey or int
@@ -188,7 +180,7 @@ mod winreg {
         #[pymethod]
         fn Close(&self, vm: &VirtualMachine) -> PyResult<()> {
             // Atomically swap the handle with null and get the old value
-            let old_hkey = self.hkey.swap(std::ptr::null_mut());
+            let old_hkey = self.hkey.swap(core::ptr::null_mut());
             // Already closed - silently succeed
             if old_hkey.is_null() {
                 return Ok(());
@@ -204,7 +196,7 @@ mod winreg {
         #[pymethod]
         fn Detach(&self) -> PyResult<usize> {
             // Atomically swap the handle with null and return the old value
-            let old_hkey = self.hkey.swap(std::ptr::null_mut());
+            let old_hkey = self.hkey.swap(core::ptr::null_mut());
             Ok(old_hkey as usize)
         }
 
@@ -230,7 +222,7 @@ mod winreg {
 
     impl Drop for PyHkey {
         fn drop(&mut self) {
-            let hkey = self.hkey.swap(std::ptr::null_mut());
+            let hkey = self.hkey.swap(core::ptr::null_mut());
             if !hkey.is_null() {
                 unsafe { Registry::RegCloseKey(hkey) };
             }
@@ -290,7 +282,7 @@ mod winreg {
         vm: &VirtualMachine,
     ) -> PyResult<PyHkey> {
         if let Some(computer_name) = computer_name {
-            let mut ret_key = std::ptr::null_mut();
+            let mut ret_key = core::ptr::null_mut();
             let wide_computer_name = computer_name.to_wide_with_nul();
             let res = unsafe {
                 Registry::RegConnectRegistryW(
@@ -305,9 +297,9 @@ mod winreg {
                 Err(vm.new_os_error(format!("error code: {res}")))
             }
         } else {
-            let mut ret_key = std::ptr::null_mut();
+            let mut ret_key = core::ptr::null_mut();
             let res = unsafe {
-                Registry::RegConnectRegistryW(std::ptr::null_mut(), key.hkey.load(), &mut ret_key)
+                Registry::RegConnectRegistryW(core::ptr::null_mut(), key.hkey.load(), &mut ret_key)
             };
             if res == 0 {
                 Ok(PyHkey::new(ret_key))
@@ -320,7 +312,7 @@ mod winreg {
     #[pyfunction]
     fn CreateKey(key: PyRef<PyHkey>, sub_key: String, vm: &VirtualMachine) -> PyResult<PyHkey> {
         let wide_sub_key = sub_key.to_wide_with_nul();
-        let mut out_key = std::ptr::null_mut();
+        let mut out_key = core::ptr::null_mut();
         let res = unsafe {
             Registry::RegCreateKeyW(key.hkey.load(), wide_sub_key.as_ptr(), &mut out_key)
         };
@@ -358,7 +350,7 @@ mod winreg {
                 args.access,
                 core::ptr::null(),
                 &mut res,
-                std::ptr::null_mut(),
+                core::ptr::null_mut(),
             )
         };
         if err == 0 {
@@ -447,14 +439,14 @@ mod winreg {
                 index as u32,
                 tmpbuf.as_mut_ptr(),
                 &mut len,
-                std::ptr::null_mut(),
-                std::ptr::null_mut(),
-                std::ptr::null_mut(),
-                std::ptr::null_mut(),
+                core::ptr::null_mut(),
+                core::ptr::null_mut(),
+                core::ptr::null_mut(),
+                core::ptr::null_mut(),
             )
         };
         if res != 0 {
-            return Err(vm.new_os_error(format!("error code: {res}")));
+            return Err(os_error_from_windows_code(vm, res as i32));
         }
         String::from_utf16(&tmpbuf[..len as usize])
             .map_err(|e| vm.new_value_error(format!("UTF16 error: {e}")))
@@ -596,7 +588,7 @@ mod winreg {
     #[pyfunction(name = "OpenKeyEx")]
     fn OpenKey(args: OpenKeyArgs, vm: &VirtualMachine) -> PyResult<PyHkey> {
         let wide_sub_key = args.sub_key.to_wide_with_nul();
-        let mut res: Registry::HKEY = std::ptr::null_mut();
+        let mut res: Registry::HKEY = core::ptr::null_mut();
         let err = unsafe {
             let key = args.key.hkey.load();
             Registry::RegOpenKeyExW(
@@ -613,7 +605,7 @@ mod winreg {
                 hkey: AtomicHKEY::new(res),
             })
         } else {
-            Err(os_error_from_windows_code(vm, err as i32, "RegOpenKeyEx"))
+            Err(os_error_from_windows_code(vm, err as i32))
         }
     }
 
@@ -622,20 +614,20 @@ mod winreg {
         let key = key.0;
         let mut lpcsubkeys: u32 = 0;
         let mut lpcvalues: u32 = 0;
-        let mut lpftlastwritetime: Foundation::FILETIME = unsafe { std::mem::zeroed() };
+        let mut lpftlastwritetime: Foundation::FILETIME = unsafe { core::mem::zeroed() };
         let err = unsafe {
             Registry::RegQueryInfoKeyW(
                 key,
-                std::ptr::null_mut(),
-                std::ptr::null_mut(),
+                core::ptr::null_mut(),
+                core::ptr::null_mut(),
                 0 as _,
                 &mut lpcsubkeys,
-                std::ptr::null_mut(),
-                std::ptr::null_mut(),
+                core::ptr::null_mut(),
+                core::ptr::null_mut(),
                 &mut lpcvalues,
-                std::ptr::null_mut(),
-                std::ptr::null_mut(),
-                std::ptr::null_mut(),
+                core::ptr::null_mut(),
+                core::ptr::null_mut(),
+                core::ptr::null_mut(),
                 &mut lpftlastwritetime,
             )
         };
@@ -661,7 +653,6 @@ mod winreg {
             return Err(os_error_from_windows_code(
                 vm,
                 Foundation::ERROR_INVALID_HANDLE as i32,
-                "RegQueryValue",
             ));
         }
 
@@ -669,7 +660,7 @@ mod winreg {
         let child_key = if let Some(ref sk) = sub_key {
             if !sk.is_empty() {
                 let wide_sub_key = sk.to_wide_with_nul();
-                let mut out_key = std::ptr::null_mut();
+                let mut out_key = core::ptr::null_mut();
                 let res = unsafe {
                     Registry::RegOpenKeyExW(
                         hkey,
@@ -680,7 +671,7 @@ mod winreg {
                     )
                 };
                 if res != 0 {
-                    return Err(os_error_from_windows_code(vm, res as i32, "RegOpenKeyEx"));
+                    return Err(os_error_from_windows_code(vm, res as i32));
                 }
                 Some(out_key)
             } else {
@@ -702,7 +693,7 @@ mod winreg {
                 Registry::RegQueryValueExW(
                     target_key,
                     core::ptr::null(), // NULL value name for default value
-                    std::ptr::null_mut(),
+                    core::ptr::null_mut(),
                     &mut reg_type,
                     buffer.as_mut_ptr(),
                     &mut size,
@@ -718,17 +709,12 @@ mod winreg {
                 break Ok(String::new());
             }
             if res != 0 {
-                break Err(os_error_from_windows_code(
-                    vm,
-                    res as i32,
-                    "RegQueryValueEx",
-                ));
+                break Err(os_error_from_windows_code(vm, res as i32));
             }
             if reg_type != Registry::REG_SZ {
                 break Err(os_error_from_windows_code(
                     vm,
                     Foundation::ERROR_INVALID_DATA as i32,
-                    "RegQueryValue",
                 ));
             }
 
@@ -759,9 +745,9 @@ mod winreg {
             Registry::RegQueryValueExW(
                 hkey,
                 wide_name.as_ptr(),
-                std::ptr::null_mut(),
-                std::ptr::null_mut(),
-                std::ptr::null_mut(),
+                core::ptr::null_mut(),
+                core::ptr::null_mut(),
+                core::ptr::null_mut(),
                 &mut buf_size,
             )
         };
@@ -769,11 +755,7 @@ mod winreg {
         if res == ERROR_MORE_DATA || buf_size == 0 {
             buf_size = 256;
         } else if res != 0 {
-            return Err(os_error_from_windows_code(
-                vm,
-                res as i32,
-                "RegQueryValueEx",
-            ));
+            return Err(os_error_from_windows_code(vm, res as i32));
         }
 
         let mut ret_buf = vec![0u8; buf_size as usize];
@@ -787,7 +769,7 @@ mod winreg {
                 Registry::RegQueryValueExW(
                     hkey,
                     wide_name.as_ptr(),
-                    std::ptr::null_mut(),
+                    core::ptr::null_mut(),
                     &mut typ,
                     ret_buf.as_mut_ptr(),
                     &mut ret_size,
@@ -796,11 +778,7 @@ mod winreg {
 
             if res != ERROR_MORE_DATA {
                 if res != 0 {
-                    return Err(os_error_from_windows_code(
-                        vm,
-                        res as i32,
-                        "RegQueryValueEx",
-                    ));
+                    return Err(os_error_from_windows_code(vm, res as i32));
                 }
                 break;
             }
@@ -820,7 +798,7 @@ mod winreg {
     fn SaveKey(key: PyRef<PyHkey>, file_name: String, vm: &VirtualMachine) -> PyResult<()> {
         let file_name = file_name.to_wide_with_nul();
         let res = unsafe {
-            Registry::RegSaveKeyW(key.hkey.load(), file_name.as_ptr(), std::ptr::null_mut())
+            Registry::RegSaveKeyW(key.hkey.load(), file_name.as_ptr(), core::ptr::null_mut())
         };
         if res == 0 {
             Ok(())
@@ -846,14 +824,13 @@ mod winreg {
             return Err(os_error_from_windows_code(
                 vm,
                 Foundation::ERROR_INVALID_HANDLE as i32,
-                "RegSetValue",
             ));
         }
 
         // Create subkey if sub_key is non-empty
         let child_key = if !sub_key.is_empty() {
             let wide_sub_key = sub_key.to_wide_with_nul();
-            let mut out_key = std::ptr::null_mut();
+            let mut out_key = core::ptr::null_mut();
             let res = unsafe {
                 Registry::RegCreateKeyExW(
                     hkey,
@@ -864,11 +841,11 @@ mod winreg {
                     Registry::KEY_SET_VALUE,
                     core::ptr::null(),
                     &mut out_key,
-                    std::ptr::null_mut(),
+                    core::ptr::null_mut(),
                 )
             };
             if res != 0 {
-                return Err(os_error_from_windows_code(vm, res as i32, "RegCreateKeyEx"));
+                return Err(os_error_from_windows_code(vm, res as i32));
             }
             Some(out_key)
         } else {
@@ -897,7 +874,7 @@ mod winreg {
         if res == 0 {
             Ok(())
         } else {
-            Err(os_error_from_windows_code(vm, res as i32, "RegSetValueEx"))
+            Err(os_error_from_windows_code(vm, res as i32))
         }
     }
 
@@ -905,20 +882,18 @@ mod winreg {
         match typ {
             REG_DWORD => {
                 // If there isn’t enough data, return 0.
-                if ret_data.len() < std::mem::size_of::<u32>() {
-                    Ok(vm.ctx.new_int(0).into())
-                } else {
-                    let val = u32::from_ne_bytes(ret_data[..4].try_into().unwrap());
-                    Ok(vm.ctx.new_int(val).into())
-                }
+                let val = ret_data
+                    .first_chunk::<4>()
+                    .copied()
+                    .map_or(0, u32::from_ne_bytes);
+                Ok(vm.ctx.new_int(val).into())
             }
             REG_QWORD => {
-                if ret_data.len() < std::mem::size_of::<u64>() {
-                    Ok(vm.ctx.new_int(0).into())
-                } else {
-                    let val = u64::from_ne_bytes(ret_data[..8].try_into().unwrap());
-                    Ok(vm.ctx.new_int(val).into())
-                }
+                let val = ret_data
+                    .first_chunk::<8>()
+                    .copied()
+                    .map_or(0, u64::from_ne_bytes);
+                Ok(vm.ctx.new_int(val).into())
             }
             REG_SZ | REG_EXPAND_SZ => {
                 let u16_slice = bytes_as_wide_slice(ret_data);
@@ -983,15 +958,15 @@ mod winreg {
                 }
                 let val = value
                     .downcast_ref::<PyInt>()
-                    .ok_or_else(|| vm.new_type_error("value must be an integer".to_string()))?;
+                    .ok_or_else(|| vm.new_type_error("value must be an integer"))?;
                 let bigint = val.as_bigint();
                 // Check for negative value - raise OverflowError
                 if bigint.sign() == Sign::Minus {
-                    return Err(vm.new_overflow_error("int too big to convert".to_string()));
+                    return Err(vm.new_overflow_error("int too big to convert"));
                 }
                 let val = bigint
                     .to_u32()
-                    .ok_or_else(|| vm.new_overflow_error("int too big to convert".to_string()))?;
+                    .ok_or_else(|| vm.new_overflow_error("int too big to convert"))?;
                 Ok(Some(val.to_le_bytes().to_vec()))
             }
             REG_QWORD => {
@@ -1000,15 +975,15 @@ mod winreg {
                 }
                 let val = value
                     .downcast_ref::<PyInt>()
-                    .ok_or_else(|| vm.new_type_error("value must be an integer".to_string()))?;
+                    .ok_or_else(|| vm.new_type_error("value must be an integer"))?;
                 let bigint = val.as_bigint();
                 // Check for negative value - raise OverflowError
                 if bigint.sign() == Sign::Minus {
-                    return Err(vm.new_overflow_error("int too big to convert".to_string()));
+                    return Err(vm.new_overflow_error("int too big to convert"));
                 }
                 let val = bigint
                     .to_u64()
-                    .ok_or_else(|| vm.new_overflow_error("int too big to convert".to_string()))?;
+                    .ok_or_else(|| vm.new_overflow_error("int too big to convert"))?;
                 Ok(Some(val.to_le_bytes().to_vec()))
             }
             REG_SZ | REG_EXPAND_SZ => {
@@ -1018,8 +993,8 @@ mod winreg {
                 }
                 let s = value
                     .downcast::<PyStr>()
-                    .map_err(|_| vm.new_type_error("value must be a string".to_string()))?;
-                let wide = s.as_str().to_wide_with_nul();
+                    .map_err(|_| vm.new_type_error("value must be a string"))?;
+                let wide = s.as_wtf8().to_wide_with_nul();
                 // Convert Vec<u16> to Vec<u8>
                 let bytes: Vec<u8> = wide.iter().flat_map(|&c| c.to_le_bytes()).collect();
                 Ok(Some(bytes))
@@ -1029,16 +1004,16 @@ mod winreg {
                     // Empty list = double null terminator
                     return Ok(Some(vec![0u8, 0u8, 0u8, 0u8]));
                 }
-                let list = value.downcast::<crate::builtins::PyList>().map_err(|_| {
-                    vm.new_type_error("value must be a list of strings".to_string())
-                })?;
+                let list = value
+                    .downcast::<crate::builtins::PyList>()
+                    .map_err(|_| vm.new_type_error("value must be a list of strings"))?;
 
                 let mut bytes: Vec<u8> = Vec::new();
                 for item in list.borrow_vec().iter() {
-                    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();
+                    let s = item
+                        .downcast_ref::<PyStr>()
+                        .ok_or_else(|| vm.new_type_error("list items must be strings"))?;
+                    let wide = s.as_wtf8().to_wide_with_nul();
                     bytes.extend(wide.iter().flat_map(|&c| c.to_le_bytes()));
                 }
                 // Add final null terminator (double null at end)
@@ -1065,50 +1040,25 @@ mod winreg {
     #[pyfunction]
     fn SetValueEx(
         key: PyRef<PyHkey>,
-        value_name: String,
+        value_name: Option<String>,
         _reserved: PyObjectRef,
         typ: u32,
         value: PyObjectRef,
         vm: &VirtualMachine,
     ) -> PyResult<()> {
-        match py2reg(value, typ, vm) {
-            Ok(Some(v)) => {
-                let len = v.len() as u32;
-                let ptr = v.as_ptr();
-                let wide_value_name = value_name.to_wide_with_nul();
-                let res = unsafe {
-                    Registry::RegSetValueExW(
-                        key.hkey.load(),
-                        wide_value_name.as_ptr(),
-                        0,
-                        typ,
-                        ptr,
-                        len,
-                    )
-                };
-                if res != 0 {
-                    return Err(vm.new_os_error(format!("error code: {res}")));
-                }
-            }
-            Ok(None) => {
-                let len = 0;
-                let ptr = core::ptr::null();
-                let wide_value_name = value_name.to_wide_with_nul();
-                let res = unsafe {
-                    Registry::RegSetValueExW(
-                        key.hkey.load(),
-                        wide_value_name.as_ptr(),
-                        0,
-                        typ,
-                        ptr,
-                        len,
-                    )
-                };
-                if res != 0 {
-                    return Err(vm.new_os_error(format!("error code: {res}")));
-                }
-            }
-            Err(e) => return Err(e),
+        let wide_value_name = value_name.as_deref().map(|s| s.to_wide_with_nul());
+        let value_name_ptr = wide_value_name
+            .as_deref()
+            .map_or(core::ptr::null(), |s| s.as_ptr());
+        let reg_value = py2reg(value, typ, vm)?;
+        let (ptr, len) = match &reg_value {
+            Some(v) => (v.as_ptr(), v.len() as u32),
+            None => (core::ptr::null(), 0),
+        };
+        let res =
+            unsafe { Registry::RegSetValueExW(key.hkey.load(), value_name_ptr, 0, typ, ptr, len) };
+        if res != 0 {
+            return Err(os_error_from_windows_code(vm, res as i32));
         }
         Ok(())
     }
@@ -1152,7 +1102,7 @@ mod winreg {
         let required_size = unsafe {
             windows_sys::Win32::System::Environment::ExpandEnvironmentStringsW(
                 wide_input.as_ptr(),
-                std::ptr::null_mut(),
+                core::ptr::null_mut(),
                 0,
             )
         };
diff --git a/crates/vm/src/stdlib/winsound.rs b/crates/vm/src/stdlib/winsound.rs
new file mode 100644
index 00000000000..0ca2e9a2258
--- /dev/null
+++ b/crates/vm/src/stdlib/winsound.rs
@@ -0,0 +1,202 @@
+// spell-checker:ignore pszSound fdwSound
+#![allow(non_snake_case)]
+
+pub(crate) use winsound::module_def;
+
+mod win32 {
+    #[link(name = "winmm")]
+    unsafe extern "system" {
+        pub fn PlaySoundW(pszSound: *const u16, hmod: isize, fdwSound: u32) -> i32;
+    }
+
+    unsafe extern "system" {
+        pub fn Beep(dwFreq: u32, dwDuration: u32) -> i32;
+        pub fn MessageBeep(uType: u32) -> i32;
+    }
+}
+
+#[pymodule]
+mod winsound {
+    use crate::builtins::{PyBytes, PyStr};
+    use crate::common::windows::ToWideString;
+    use crate::convert::{IntoPyException, TryFromBorrowedObject};
+    use crate::protocol::PyBuffer;
+    use crate::{AsObject, PyObjectRef, PyResult, VirtualMachine};
+
+    // PlaySound flags
+    #[pyattr]
+    const SND_SYNC: u32 = 0x0000;
+    #[pyattr]
+    const SND_ASYNC: u32 = 0x0001;
+    #[pyattr]
+    const SND_NODEFAULT: u32 = 0x0002;
+    #[pyattr]
+    const SND_MEMORY: u32 = 0x0004;
+    #[pyattr]
+    const SND_LOOP: u32 = 0x0008;
+    #[pyattr]
+    const SND_NOSTOP: u32 = 0x0010;
+    #[pyattr]
+    const SND_PURGE: u32 = 0x0040;
+    #[pyattr]
+    const SND_APPLICATION: u32 = 0x0080;
+    #[pyattr]
+    const SND_NOWAIT: u32 = 0x00002000;
+    #[pyattr]
+    const SND_ALIAS: u32 = 0x00010000;
+    #[pyattr]
+    const SND_FILENAME: u32 = 0x00020000;
+    #[pyattr]
+    const SND_SENTRY: u32 = 0x00080000;
+    #[pyattr]
+    const SND_SYSTEM: u32 = 0x00200000;
+
+    // MessageBeep types
+    #[pyattr]
+    const MB_OK: u32 = 0x00000000;
+    #[pyattr]
+    const MB_ICONHAND: u32 = 0x00000010;
+    #[pyattr]
+    const MB_ICONQUESTION: u32 = 0x00000020;
+    #[pyattr]
+    const MB_ICONEXCLAMATION: u32 = 0x00000030;
+    #[pyattr]
+    const MB_ICONASTERISK: u32 = 0x00000040;
+    #[pyattr]
+    const MB_ICONERROR: u32 = MB_ICONHAND;
+    #[pyattr]
+    const MB_ICONSTOP: u32 = MB_ICONHAND;
+    #[pyattr]
+    const MB_ICONINFORMATION: u32 = MB_ICONASTERISK;
+    #[pyattr]
+    const MB_ICONWARNING: u32 = MB_ICONEXCLAMATION;
+
+    #[derive(FromArgs)]
+    struct PlaySoundArgs {
+        #[pyarg(any)]
+        sound: PyObjectRef,
+        #[pyarg(any)]
+        flags: i32,
+    }
+
+    #[pyfunction]
+    fn PlaySound(args: PlaySoundArgs, vm: &VirtualMachine) -> PyResult<()> {
+        let sound = args.sound;
+        let flags = args.flags as u32;
+
+        if vm.is_none(&sound) {
+            let ok = unsafe { super::win32::PlaySoundW(core::ptr::null(), 0, flags) };
+            if ok == 0 {
+                return Err(vm.new_runtime_error("Failed to play sound"));
+            }
+            return Ok(());
+        }
+
+        if flags & SND_MEMORY != 0 {
+            if flags & SND_ASYNC != 0 {
+                return Err(vm.new_runtime_error("Cannot play asynchronously from memory"));
+            }
+            let buffer = PyBuffer::try_from_borrowed_object(vm, &sound)?;
+            let buf = buffer
+                .as_contiguous()
+                .ok_or_else(|| vm.new_type_error("a bytes-like object is required, not 'str'"))?;
+            let ok = unsafe { super::win32::PlaySoundW(buf.as_ptr() as *const u16, 0, flags) };
+            if ok == 0 {
+                return Err(vm.new_runtime_error("Failed to play sound"));
+            }
+            return Ok(());
+        }
+
+        if sound.downcastable::<PyBytes>() {
+            let type_name = sound.class().name().to_string();
+            return Err(vm.new_type_error(format!(
+                "'sound' must be str, os.PathLike, or None, not {type_name}"
+            )));
+        }
+
+        // os.fspath(sound)
+        let path = match sound.downcast_ref::<PyStr>() {
+            Some(s) => s.as_wtf8().to_owned(),
+            None => {
+                let fspath = vm.get_method_or_type_error(
+                    sound.clone(),
+                    identifier!(vm, __fspath__),
+                    || {
+                        let type_name = sound.class().name().to_string();
+                        format!("'sound' must be str, os.PathLike, or None, not {type_name}")
+                    },
+                )?;
+
+                if vm.is_none(&fspath) {
+                    return Err(vm.new_type_error(format!(
+                        "'sound' must be str, os.PathLike, or None, not {}",
+                        sound.class().name()
+                    )));
+                }
+                let result = fspath.call((), vm)?;
+
+                if result.downcastable::<PyBytes>() {
+                    return Err(vm.new_type_error("'sound' must resolve to str, not bytes"));
+                }
+
+                let s: &PyStr = result.downcast_ref().ok_or_else(|| {
+                    vm.new_type_error(format!(
+                        "expected {}.__fspath__() to return str or bytes, not {}",
+                        sound.class().name(),
+                        result.class().name()
+                    ))
+                })?;
+
+                s.as_wtf8().to_owned()
+            }
+        };
+
+        // Check for embedded null characters
+        if path.as_bytes().contains(&0) {
+            return Err(vm.new_value_error("embedded null character"));
+        }
+
+        let wide = path.to_wide_with_nul();
+        let ok = unsafe { super::win32::PlaySoundW(wide.as_ptr(), 0, flags) };
+        if ok == 0 {
+            return Err(vm.new_runtime_error("Failed to play sound"));
+        }
+        Ok(())
+    }
+
+    #[derive(FromArgs)]
+    struct BeepArgs {
+        #[pyarg(any)]
+        frequency: i32,
+        #[pyarg(any)]
+        duration: i32,
+    }
+
+    #[pyfunction]
+    fn Beep(args: BeepArgs, vm: &VirtualMachine) -> PyResult<()> {
+        if !(37..=32767).contains(&args.frequency) {
+            return Err(vm.new_value_error("frequency must be in 37 thru 32767"));
+        }
+
+        let ok = unsafe { super::win32::Beep(args.frequency as u32, args.duration as u32) };
+        if ok == 0 {
+            return Err(vm.new_runtime_error("Failed to beep"));
+        }
+        Ok(())
+    }
+
+    #[derive(FromArgs)]
+    struct MessageBeepArgs {
+        #[pyarg(any, default = 0)]
+        r#type: u32,
+    }
+
+    #[pyfunction]
+    fn MessageBeep(args: MessageBeepArgs, vm: &VirtualMachine) -> PyResult<()> {
+        let ok = unsafe { super::win32::MessageBeep(args.r#type) };
+        if ok == 0 {
+            return Err(std::io::Error::last_os_error().into_pyexception(vm));
+        }
+        Ok(())
+    }
+}
diff --git a/crates/vm/src/suggestion.rs b/crates/vm/src/suggestion.rs
index 55326d1d3f0..b48b78af755 100644
--- a/crates/vm/src/suggestion.rs
+++ b/crates/vm/src/suggestion.rs
@@ -48,13 +48,25 @@ pub fn calculate_suggestions<'a>(
 }
 
 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();
+    if exc
+        .class()
+        .fast_issubclass(vm.ctx.exceptions.attribute_error)
+    {
+        let name = exc.as_object().get_attr("name", vm).ok()?;
+        if vm.is_none(&name) {
+            return None;
+        }
+        let obj = exc.as_object().get_attr("obj", vm).ok()?;
+        if vm.is_none(&obj) {
+            return None;
+        }
 
         calculate_suggestions(vm.dir(Some(obj)).ok()?.borrow_vec().iter(), &name)
-    } else if exc.class().is(vm.ctx.exceptions.name_error) {
-        let name = exc.as_object().get_attr("name", vm).unwrap();
+    } else if exc.class().fast_issubclass(vm.ctx.exceptions.name_error) {
+        let name = exc.as_object().get_attr("name", vm).ok()?;
+        if vm.is_none(&name) {
+            return None;
+        }
         let tb = exc.__traceback__()?;
         let tb = tb.iter().last().unwrap_or(tb);
 
@@ -68,8 +80,18 @@ pub fn offer_suggestions(exc: &Py<PyBaseException>, vm: &VirtualMachine) -> Opti
             return Some(suggestions);
         };
 
-        let builtins: Vec<_> = tb.frame.builtins.as_object().try_to_value(vm).ok()?;
+        let builtins: Vec<_> = tb.frame.builtins.try_to_value(vm).ok()?;
         calculate_suggestions(builtins.iter(), &name)
+    } else if exc.class().fast_issubclass(vm.ctx.exceptions.import_error) {
+        let mod_name = exc.as_object().get_attr("name", vm).ok()?;
+        let wrong_name = exc.as_object().get_attr("name_from", vm).ok()?;
+        let mod_name_str = mod_name.downcast_ref::<PyStr>()?;
+
+        // Look up the module in sys.modules
+        let sys_modules = vm.sys_module.get_attr("modules", vm).ok()?;
+        let module = sys_modules.get_item(mod_name_str, vm).ok()?;
+
+        calculate_suggestions(vm.dir(Some(module)).ok()?.borrow_vec().iter(), &wrong_name)
     } else {
         None
     }
diff --git a/crates/vm/src/types/slot.rs b/crates/vm/src/types/slot.rs
index 2f45d9dcff1..b92f2658f13 100644
--- a/crates/vm/src/types/slot.rs
+++ b/crates/vm/src/types/slot.rs
@@ -3,13 +3,11 @@ use crate::common::lock::{
 };
 use crate::{
     AsObject, Py, PyObject, PyObjectRef, PyPayload, PyRef, PyResult, VirtualMachine,
-    builtins::{PyInt, PyStr, PyStrInterned, PyStrRef, PyType, PyTypeRef},
+    builtins::{PyInt, PyStr, PyStrInterned, PyType, PyTypeRef},
     bytecode::ComparisonOperator,
     common::hash::{PyHash, fix_sentinel, hash_bigint},
     convert::ToPyObject,
-    function::{
-        Either, FromArgs, FuncArgs, OptionalArg, PyComparisonValue, PyMethodDef, PySetterValue,
-    },
+    function::{Either, FromArgs, FuncArgs, PyComparisonValue, PyMethodDef, PySetterValue},
     protocol::{
         PyBuffer, PyIterReturn, PyMapping, PyMappingMethods, PyMappingSlots, PyNumber,
         PyNumberMethods, PyNumberSlots, PySequence, PySequenceMethods, PySequenceSlots,
@@ -20,6 +18,7 @@ use crate::{
 use core::{any::Any, any::TypeId, borrow::Borrow, cmp::Ordering, ops::Deref};
 use crossbeam_utils::atomic::AtomicCell;
 use num_traits::{Signed, ToPrimitive};
+use rustpython_common::wtf8::Wtf8Buf;
 
 /// Type-erased storage for extension module data attached to heap types.
 pub struct TypeDataSlot {
@@ -140,6 +139,7 @@ pub struct PyTypeSlots {
     // More standard operations (here for binary compatibility)
     pub hash: AtomicCell<Option<HashFunc>>,
     pub call: AtomicCell<Option<GenericMethod>>,
+    pub vectorcall: AtomicCell<Option<VectorCallFunc>>,
     pub str: AtomicCell<Option<StringifyFunc>>,
     pub repr: AtomicCell<Option<StringifyFunc>>,
     pub getattro: AtomicCell<Option<GetattroFunc>>,
@@ -172,6 +172,7 @@ pub struct PyTypeSlots {
     // tp_dictoffset
     pub init: AtomicCell<Option<InitFunc>>,
     // tp_alloc
+    pub alloc: AtomicCell<Option<AllocFunc>>,
     pub new: AtomicCell<Option<NewFunc>>,
     // tp_free
     // tp_is_gc
@@ -213,6 +214,7 @@ bitflags! {
     #[derive(Copy, Clone, Debug, PartialEq)]
     #[non_exhaustive]
     pub struct PyTypeFlags: u64 {
+        const MANAGED_WEAKREF = 1 << 3;
         const MANAGED_DICT = 1 << 4;
         const SEQUENCE = 1 << 5;
         const MAPPING = 1 << 6;
@@ -226,6 +228,7 @@ bitflags! {
         // This is not a stable API
         const _MATCH_SELF = 1 << 22;
         const HAS_DICT = 1 << 40;
+        const HAS_WEAKREF = 1 << 41;
 
         #[cfg(debug_assertions)]
         const _CREATED_WITH_FLAGS = 1 << 63;
@@ -265,6 +268,17 @@ impl Default for PyTypeFlags {
 }
 
 pub(crate) type GenericMethod = fn(&PyObject, FuncArgs, &VirtualMachine) -> PyResult;
+/// Vectorcall function pointer (PEP 590).
+/// args: owned positional args followed by kwarg values.
+/// nargs: number of positional args (self prepended by caller if needed).
+/// kwnames: keyword argument names (last kwnames.len() entries in args are kwarg values).
+pub(crate) type VectorCallFunc = fn(
+    &PyObject,              // callable
+    Vec<PyObjectRef>,       // owned args (positional + kwarg values)
+    usize,                  // nargs (positional count)
+    Option<&[PyObjectRef]>, // kwnames (keyword argument names)
+    &VirtualMachine,
+) -> PyResult;
 pub(crate) type HashFunc = fn(&PyObject, &VirtualMachine) -> PyResult<PyHash>;
 // CallFunc = GenericMethod
 pub(crate) type StringifyFunc = fn(&PyObject, &VirtualMachine) -> PyResult<PyRef<PyStr>>;
@@ -284,6 +298,7 @@ pub(crate) type DescrGetFunc =
     fn(PyObjectRef, Option<PyObjectRef>, Option<PyObjectRef>, &VirtualMachine) -> PyResult;
 pub(crate) type DescrSetFunc =
     fn(&PyObject, PyObjectRef, PySetterValue, &VirtualMachine) -> PyResult<()>;
+pub(crate) type AllocFunc = fn(PyTypeRef, usize, &VirtualMachine) -> PyResult;
 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<()>;
@@ -534,7 +549,15 @@ pub(crate) fn richcompare_wrapper(
 }
 
 fn iter_wrapper(zelf: PyObjectRef, vm: &VirtualMachine) -> PyResult {
-    vm.call_special_method(&zelf, identifier!(vm, __iter__), ())
+    // slot_tp_iter: if __iter__ is None, the type is explicitly not iterable
+    let cls = zelf.class();
+    let iter_attr = cls.get_attr(identifier!(vm, __iter__));
+    match iter_attr {
+        Some(attr) if vm.is_none(&attr) => {
+            Err(vm.new_type_error(format!("'{}' object is not iterable", cls.name())))
+        }
+        _ => vm.call_special_method(&zelf, identifier!(vm, __iter__), ()),
+    }
 }
 
 fn bool_wrapper(num: PyNumber<'_>, vm: &VirtualMachine) -> PyResult<bool> {
@@ -589,7 +612,7 @@ fn init_wrapper(obj: PyObjectRef, args: FuncArgs, vm: &VirtualMachine) -> PyResu
     let res = vm.call_special_method(&obj, identifier!(vm, __init__), args)?;
     if !vm.is_none(&res) {
         return Err(vm.new_type_error(format!(
-            "__init__ should return None, not '{:.200}'",
+            "__init__() should return None, not '{:.200}'",
             res.class().name()
         )));
     }
@@ -607,6 +630,18 @@ fn del_wrapper(zelf: &PyObject, vm: &VirtualMachine) -> PyResult<()> {
     Ok(())
 }
 
+/// Result of looking up a slot function in MRO.
+enum SlotLookupResult<T> {
+    /// Found a native slot function from a wrapper_descriptor.
+    NativeSlot(T),
+    /// Found a Python-level method (not a native slot).
+    /// The caller should use the wrapper function.
+    PythonMethod,
+    /// No method with this name found in MRO at all.
+    /// The caller should inherit the slot from MRO.
+    NotFound,
+}
+
 impl PyType {
     /// Update slots based on dunder method changes
     ///
@@ -667,16 +702,22 @@ impl PyType {
         macro_rules! update_main_slot {
             ($slot:ident, $wrapper:expr, $variant:ident) => {{
                 if ADD {
-                    if let Some(func) = self.lookup_slot_in_mro(name, ctx, |sf| {
+                    match 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));
+                        SlotLookupResult::NativeSlot(func) => {
+                            self.slots.$slot.store(Some(func));
+                        }
+                        SlotLookupResult::PythonMethod => {
+                            self.slots.$slot.store(Some($wrapper));
+                        }
+                        SlotLookupResult::NotFound => {
+                            accessor.inherit_from_mro(self);
+                        }
                     }
                 } else {
                     accessor.inherit_from_mro(self);
@@ -710,16 +751,24 @@ impl PyType {
                     };
                     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 {
-                            None
-                        }
-                    }) {
-                        self.slots.$group.$slot.store(Some(func));
                     } else {
-                        self.slots.$group.$slot.store(Some($wrapper));
+                        match self.lookup_slot_in_mro(name, ctx, |sf| {
+                            if let SlotFunc::$variant(f) = sf {
+                                Some(*f)
+                            } else {
+                                None
+                            }
+                        }) {
+                            SlotLookupResult::NativeSlot(func) => {
+                                self.slots.$group.$slot.store(Some(func));
+                            }
+                            SlotLookupResult::PythonMethod => {
+                                self.slots.$group.$slot.store(Some($wrapper));
+                            }
+                            SlotLookupResult::NotFound => {
+                                accessor.inherit_from_mro(self);
+                            }
+                        }
                     }
                 } else {
                     accessor.inherit_from_mro(self);
@@ -743,29 +792,50 @@ impl PyType {
 
                     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));
+                        match self.lookup_slot_in_mro(name, ctx, |sf| {
+                            if let SlotFunc::Hash(f) = sf {
+                                Some(*f)
+                            } else {
+                                None
+                            }
+                        }) {
+                            SlotLookupResult::NativeSlot(func) => {
+                                self.slots.hash.store(Some(func));
+                            }
+                            SlotLookupResult::PythonMethod => {
+                                self.slots.hash.store(Some(hash_wrapper));
+                            }
+                            SlotLookupResult::NotFound => {
+                                accessor.inherit_from_mro(self);
+                            }
+                        }
                     }
                 } else {
                     accessor.inherit_from_mro(self);
                 }
             }
-            SlotAccessor::TpCall => update_main_slot!(call, call_wrapper, Call),
+            SlotAccessor::TpCall => {
+                update_main_slot!(call, call_wrapper, Call);
+                // When __call__ is overridden in Python, clear vectorcall
+                // so the slow path through call_wrapper is used.
+                if ADD {
+                    self.slots.vectorcall.store(None);
+                }
+            }
             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::TpInit => {
+                update_main_slot!(init, init_wrapper, Init);
+                if ADD {
+                    self.slots.vectorcall.store(None);
+                }
+            }
             SlotAccessor::TpNew => {
                 // __new__ is not wrapped via PyWrapper
                 if ADD {
                     self.slots.new.store(Some(new_wrapper));
+                    self.slots.vectorcall.store(None);
                 } else {
                     accessor.inherit_from_mro(self);
                 }
@@ -794,16 +864,22 @@ impl PyType {
                     // 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| {
+                    match 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));
+                        SlotLookupResult::NativeSlot(func) => {
+                            self.slots.getattro.store(Some(func));
+                        }
+                        SlotLookupResult::PythonMethod => {
+                            self.slots.getattro.store(Some(getattro_wrapper));
+                        }
+                        SlotLookupResult::NotFound => {
+                            accessor.inherit_from_mro(self);
+                        }
                     }
                 } else {
                     accessor.inherit_from_mro(self);
@@ -812,13 +888,19 @@ impl PyType {
             SlotAccessor::TpSetattro => {
                 // __setattr__ and __delattr__ share the same slot
                 if ADD {
-                    if let Some(func) = self.lookup_slot_in_mro(name, ctx, |sf| match sf {
+                    match 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));
+                        SlotLookupResult::NativeSlot(func) => {
+                            self.slots.setattro.store(Some(func));
+                        }
+                        SlotLookupResult::PythonMethod => {
+                            self.slots.setattro.store(Some(setattro_wrapper));
+                        }
+                        SlotLookupResult::NotFound => {
+                            accessor.inherit_from_mro(self);
+                        }
                     }
                 } else {
                     accessor.inherit_from_mro(self);
@@ -828,13 +910,19 @@ impl PyType {
             SlotAccessor::TpDescrSet => {
                 // __set__ and __delete__ share the same slot
                 if ADD {
-                    if let Some(func) = self.lookup_slot_in_mro(name, ctx, |sf| match sf {
+                    match 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));
+                        SlotLookupResult::NativeSlot(func) => {
+                            self.slots.descr_set.store(Some(func));
+                        }
+                        SlotLookupResult::PythonMethod => {
+                            self.slots.descr_set.store(Some(descr_set_wrapper));
+                        }
+                        SlotLookupResult::NotFound => {
+                            accessor.inherit_from_mro(self);
+                        }
                     }
                 } else {
                     accessor.inherit_from_mro(self);
@@ -868,8 +956,9 @@ impl PyType {
                                 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)
+                                        // Check if it's a Python function (not a native descriptor)
                                         !attr.class().is(ctx.types.wrapper_descriptor_type)
+                                            && !attr.class().is(ctx.types.method_descriptor_type)
                                     } else {
                                         false
                                     }
@@ -880,16 +969,24 @@ impl PyType {
                     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));
+                        match self.lookup_slot_in_mro(name, ctx, |sf| {
+                            if let SlotFunc::RichCompare(f, _) = sf {
+                                Some(*f)
+                            } else {
+                                None
+                            }
+                        }) {
+                            SlotLookupResult::NativeSlot(func) => {
+                                self.slots.richcompare.store(Some(func));
+                            }
+                            SlotLookupResult::PythonMethod => {
+                                self.slots.richcompare.store(Some(richcompare_wrapper));
+                            }
+                            SlotLookupResult::NotFound => {
+                                accessor.inherit_from_mro(self);
+                            }
+                        }
                     }
                 } else {
                     accessor.inherit_from_mro(self);
@@ -1332,16 +1429,24 @@ impl PyType {
                             .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));
+                        match self.lookup_slot_in_mro(name, ctx, |sf| match sf {
+                            SlotFunc::SeqSetItem(f) | SlotFunc::SeqDelItem(f) => Some(*f),
+                            _ => None,
+                        }) {
+                            SlotLookupResult::NativeSlot(func) => {
+                                self.slots.as_sequence.ass_item.store(Some(func));
+                            }
+                            SlotLookupResult::PythonMethod => {
+                                self.slots
+                                    .as_sequence
+                                    .ass_item
+                                    .store(Some(sequence_setitem_wrapper));
+                            }
+                            SlotLookupResult::NotFound => {
+                                accessor.inherit_from_mro(self);
+                            }
+                        }
                     }
                 } else {
                     accessor.inherit_from_mro(self);
@@ -1377,16 +1482,24 @@ impl PyType {
                             .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));
+                        match self.lookup_slot_in_mro(name, ctx, |sf| match sf {
+                            SlotFunc::MapSetSubscript(f) | SlotFunc::MapDelSubscript(f) => Some(*f),
+                            _ => None,
+                        }) {
+                            SlotLookupResult::NativeSlot(func) => {
+                                self.slots.as_mapping.ass_subscript.store(Some(func));
+                            }
+                            SlotLookupResult::PythonMethod => {
+                                self.slots
+                                    .as_mapping
+                                    .ass_subscript
+                                    .store(Some(mapping_setitem_wrapper));
+                            }
+                            SlotLookupResult::NotFound => {
+                                accessor.inherit_from_mro(self);
+                            }
+                        }
                     }
                 } else {
                     accessor.inherit_from_mro(self);
@@ -1399,14 +1512,12 @@ impl PyType {
     }
 
     /// 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> {
+    ) -> SlotLookupResult<T> {
         use crate::builtins::descriptor::PyWrapper;
 
         // Helper to check if a class is a subclass of another by checking MRO
@@ -1437,9 +1548,9 @@ impl PyType {
         // Look up in self's dict first
         if let Some(attr) = self.attributes.read().get(name).cloned() {
             if let Some(func) = try_extract(&attr, &mro) {
-                return Some(func);
+                return SlotLookupResult::NativeSlot(func);
             }
-            return None;
+            return SlotLookupResult::PythonMethod;
         }
 
         // Look up in MRO (mro[0] is self, so skip it)
@@ -1447,13 +1558,13 @@ impl PyType {
             if let Some(attr) = cls.attributes.read().get(name).cloned() {
                 // Use the slice starting from this class in MRO
                 if let Some(func) = try_extract(&attr, &mro[i + 1..]) {
-                    return Some(func);
+                    return SlotLookupResult::NativeSlot(func);
                 }
-                return None;
+                return SlotLookupResult::PythonMethod;
             }
         }
         // No method found in MRO
-        None
+        SlotLookupResult::NotFound
     }
 }
 
@@ -1540,8 +1651,11 @@ pub trait Initializer: PyPayload {
                 #[cfg(debug_assertions)]
                 {
                     if let Ok(msg) = err.as_object().repr(vm) {
-                        let double_appearance =
-                            msg.as_str().matches(&class_name_for_debug as &str).count() == 2;
+                        let double_appearance = msg
+                            .to_string_lossy()
+                            .matches(&class_name_for_debug as &str)
+                            .count()
+                            == 2;
                         if double_appearance {
                             panic!(
                                 "This type `{}` doesn't seem to support `init`. Override `slot_init` instead: {}",
@@ -1571,11 +1685,6 @@ pub trait Destructor: PyPayload {
         Self::del(zelf, vm)
     }
 
-    #[pymethod]
-    fn __del__(zelf: PyObjectRef, vm: &VirtualMachine) -> PyResult<()> {
-        Self::slot_del(&zelf, vm)
-    }
-
     fn del(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<()>;
 }
 
@@ -1588,22 +1697,19 @@ pub trait Callable: PyPayload {
     fn slot_call(zelf: &PyObject, args: FuncArgs, vm: &VirtualMachine) -> PyResult {
         let zelf = zelf.downcast_ref().ok_or_else(|| {
             let repr = zelf.repr(vm);
-            let help = if let Ok(repr) = repr.as_ref() {
-                repr.as_str().to_owned()
+            let help: Wtf8Buf = if let Ok(repr) = repr.as_ref() {
+                repr.as_wtf8().to_owned()
             } else {
-                zelf.class().name().to_owned()
+                zelf.class().name().to_owned().into()
             };
-            vm.new_type_error(format!("unexpected payload for __call__ of {help}"))
+            let mut msg = Wtf8Buf::from("unexpected payload for __call__ of ");
+            msg.push_wtf8(&help);
+            vm.new_type_error(msg)
         })?;
         let args = args.bind(vm)?;
         Self::call(zelf, args, vm)
     }
 
-    #[inline]
-    #[pymethod]
-    fn __call__(zelf: PyObjectRef, args: FuncArgs, vm: &VirtualMachine) -> PyResult {
-        Self::slot_call(&zelf, args.bind(vm)?, vm)
-    }
     fn call(zelf: &Py<Self>, args: Self::Args, vm: &VirtualMachine) -> PyResult;
 }
 
@@ -1617,17 +1723,6 @@ pub trait GetDescriptor: PyPayload {
         vm: &VirtualMachine,
     ) -> PyResult;
 
-    #[inline]
-    #[pymethod]
-    fn __get__(
-        zelf: PyObjectRef,
-        obj: PyObjectRef,
-        cls: OptionalArg<PyObjectRef>,
-        vm: &VirtualMachine,
-    ) -> PyResult {
-        Self::descr_get(zelf, Some(obj), cls.into_option(), vm)
-    }
-
     #[inline]
     fn _as_pyref<'a>(zelf: &'a PyObject, vm: &VirtualMachine) -> PyResult<&'a Py<Self>> {
         zelf.try_to_value(vm)
@@ -1698,11 +1793,16 @@ pub trait Representable: PyPayload {
 
     #[inline]
     fn repr(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<PyRef<PyStr>> {
-        let repr = Self::repr_str(zelf, vm)?;
+        let repr = Self::repr_wtf8(zelf, vm)?;
         Ok(vm.ctx.new_str(repr))
     }
 
-    fn repr_str(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<String>;
+    fn repr_wtf8(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<Wtf8Buf> {
+        Self::repr_str(zelf, vm).map(|utf8| utf8.into())
+    }
+    fn repr_str(_zelf: &Py<Self>, _vm: &VirtualMachine) -> PyResult<String> {
+        unreachable!("Representable requires overriding either repr_str or repr_wtf8")
+    }
 }
 
 #[pyclass]
@@ -1730,61 +1830,6 @@ pub trait Comparable: PyPayload {
         op: PyComparisonOp,
         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)
-    }
 }
 
 #[derive(Debug, Copy, Clone, Eq, PartialEq)]
@@ -1819,13 +1864,15 @@ impl PyComparisonOp {
         }
     }
 
-    pub const fn eval_ord(self, ord: Ordering) -> bool {
-        let bit = match ord {
-            Ordering::Less => Self::Lt,
-            Ordering::Equal => Self::Eq,
-            Ordering::Greater => Self::Gt,
-        };
-        self.0 as u8 & bit.0 as u8 != 0
+    pub fn eval_ord(self, ord: Ordering) -> bool {
+        match self {
+            Self::Lt => ord == Ordering::Less,
+            Self::Le => ord != Ordering::Greater,
+            Self::Eq => ord == Ordering::Equal,
+            Self::Ne => ord != Ordering::Equal,
+            Self::Gt => ord == Ordering::Greater,
+            Self::Ge => ord != Ordering::Less,
+        }
     }
 
     pub const fn swapped(self) -> Self {
@@ -1896,12 +1943,6 @@ pub trait GetAttr: PyPayload {
     }
 
     fn getattro(zelf: &Py<Self>, name: &Py<PyStr>, vm: &VirtualMachine) -> PyResult;
-
-    #[inline]
-    #[pymethod]
-    fn __getattribute__(zelf: PyObjectRef, name: PyStrRef, vm: &VirtualMachine) -> PyResult {
-        Self::slot_getattro(&zelf, &name, vm)
-    }
 }
 
 #[pyclass]
@@ -1926,23 +1967,6 @@ pub trait SetAttr: PyPayload {
         value: PySetterValue,
         vm: &VirtualMachine,
     ) -> PyResult<()>;
-
-    #[inline]
-    #[pymethod]
-    fn __setattr__(
-        zelf: PyObjectRef,
-        name: PyStrRef,
-        value: PyObjectRef,
-        vm: &VirtualMachine,
-    ) -> PyResult<()> {
-        Self::slot_setattro(&zelf, &name, PySetterValue::Assign(value), vm)
-    }
-
-    #[inline]
-    #[pymethod]
-    fn __delattr__(zelf: PyObjectRef, name: PyStrRef, vm: &VirtualMachine) -> PyResult<()> {
-        Self::slot_setattro(&zelf, &name, PySetterValue::Delete, vm)
-    }
 }
 
 #[pyclass]
@@ -2055,7 +2079,7 @@ where
     #[cold]
     fn slot_iter(zelf: PyObjectRef, vm: &VirtualMachine) -> PyResult {
         let repr = zelf.repr(vm)?;
-        unreachable!("slot must be overridden for {}", repr.as_str());
+        unreachable!("slot must be overridden for {}", repr.as_wtf8());
     }
 
     #[cold]
diff --git a/crates/vm/src/types/slot_defs.rs b/crates/vm/src/types/slot_defs.rs
index 024776f7893..efd1a8913f5 100644
--- a/crates/vm/src/types/slot_defs.rs
+++ b/crates/vm/src/types/slot_defs.rs
@@ -451,7 +451,23 @@ impl SlotAccessor {
             Self::TpHash => inherit_main!(hash),
             Self::TpRepr => inherit_main!(repr),
             Self::TpStr => inherit_main!(str),
-            Self::TpCall => inherit_main!(call),
+            Self::TpCall => {
+                inherit_main!(call);
+                // CPython does not inherit tp_vectorcall to heap types at all; it only
+                // inherits tp_vectorcall_offset (the per-instance callable fast path).
+                // RustPython approximates this by inheriting vectorcall only from types
+                // with a call slot (instance-call vectorcall), not from types that use
+                // vectorcall as a constructor fast path (call=None).
+                // See vectorcall_type() in type.rs for the dual-use design rationale.
+                let inherited_vc = mro.iter().find_map(|cls| {
+                    if cls.slots.call.load().is_some() {
+                        cls.slots.vectorcall.load()
+                    } else {
+                        None
+                    }
+                });
+                typ.slots.vectorcall.store(inherited_vc);
+            }
             Self::TpIter => inherit_main!(iter),
             Self::TpIternext => inherit_main!(iternext),
             Self::TpInit => inherit_main!(init),
@@ -568,7 +584,16 @@ impl SlotAccessor {
             Self::TpHash => copy_main!(hash),
             Self::TpRepr => copy_main!(repr),
             Self::TpStr => copy_main!(str),
-            Self::TpCall => copy_main!(call),
+            Self::TpCall => {
+                copy_main!(call);
+                // See inherit_from_mro TpCall for rationale.
+                if typ.slots.vectorcall.load().is_none()
+                    && base.slots.call.load().is_some()
+                    && let Some(base_val) = base.slots.vectorcall.load()
+                {
+                    typ.slots.vectorcall.store(Some(base_val));
+                }
+            }
             Self::TpIter => copy_main!(iter),
             Self::TpIternext => copy_main!(iternext),
             Self::TpInit => {
diff --git a/crates/vm/src/types/structseq.rs b/crates/vm/src/types/structseq.rs
index 27315749e06..02d1a4d6349 100644
--- a/crates/vm/src/types/structseq.rs
+++ b/crates/vm/src/types/structseq.rs
@@ -1,15 +1,24 @@
+use crate::common::lock::LazyLock;
 use crate::{
     AsObject, Py, PyObject, PyObjectRef, PyPayload, PyRef, PyResult, VirtualMachine, atomic_func,
-    builtins::{PyBaseExceptionRef, PyStrRef, PyTuple, PyTupleRef, PyType, PyTypeRef},
+    builtins::{PyBaseExceptionRef, PyStr, PyStrRef, PyTuple, PyTupleRef, PyType, PyTypeRef},
     class::{PyClassImpl, StaticType},
-    function::{Either, PyComparisonValue},
+    function::{Either, FuncArgs, PyComparisonValue, PyMethodDef, PyMethodFlags},
     iter::PyExactSizeIterator,
     protocol::{PyMappingMethods, PySequenceMethods},
     sliceable::{SequenceIndex, SliceableSequenceOp},
     types::PyComparisonOp,
     vm::Context,
 };
-use std::sync::LazyLock;
+
+const DEFAULT_STRUCTSEQ_REDUCE: PyMethodDef = PyMethodDef::new_const(
+    "__reduce__",
+    |zelf: PyRef<PyTuple>, vm: &VirtualMachine| -> PyTupleRef {
+        vm.new_tuple((zelf.class().to_owned(), (vm.ctx.new_tuple(zelf.to_vec()),)))
+    },
+    PyMethodFlags::METHOD,
+    None,
+);
 
 /// Create a new struct sequence instance from a sequence.
 ///
@@ -206,34 +215,74 @@ pub trait PyStructSequence: StaticType + PyClassImpl + Sized + 'static {
         };
         let (body, suffix) =
             if let Some(_guard) = rustpython_vm::recursion::ReprGuard::enter(vm, zelf.as_ref()) {
-                if field_names.len() == 1 {
-                    let value = zelf.first().unwrap();
-                    let formatted = format_field((value, field_names[0]))?;
-                    (formatted, ",")
-                } else {
-                    let fields: PyResult<Vec<_>> = zelf
-                        .iter()
-                        .map(|value| value.as_ref())
-                        .zip(field_names.iter().copied())
-                        .map(format_field)
-                        .collect();
-                    (fields?.join(", "), "")
-                }
+                let fields: PyResult<Vec<_>> = zelf
+                    .iter()
+                    .map(|value| value.as_ref())
+                    .zip(field_names.iter().copied())
+                    .map(format_field)
+                    .collect();
+                (fields?.join(", "), "")
             } else {
                 (String::new(), "...")
             };
-        let repr_str = format!("{}({}{})", Self::TP_NAME, body, suffix);
+        // Build qualified name: if MODULE_NAME is already in TP_NAME, use it directly.
+        // Otherwise, check __module__ attribute (set by #[pymodule] at runtime).
+        let type_name = if Self::MODULE_NAME.is_some() {
+            alloc::borrow::Cow::Borrowed(Self::TP_NAME)
+        } else {
+            let typ = zelf.class();
+            match typ.get_attr(identifier!(vm.ctx, __module__)) {
+                Some(module) if module.downcastable::<PyStr>() => {
+                    let module_str = module.downcast_ref::<PyStr>().unwrap();
+                    alloc::borrow::Cow::Owned(format!("{}.{}", module_str.as_wtf8(), Self::NAME))
+                }
+                _ => alloc::borrow::Cow::Borrowed(Self::TP_NAME),
+            }
+        };
+        let repr_str = format!("{}({}{})", type_name, body, suffix);
         Ok(vm.ctx.new_str(repr_str))
     }
 
     #[pymethod]
-    fn __repr__(zelf: PyObjectRef, vm: &VirtualMachine) -> PyResult<PyStrRef> {
-        Self::slot_repr(&zelf, vm)
-    }
+    fn __replace__(zelf: PyRef<PyTuple>, args: FuncArgs, vm: &VirtualMachine) -> PyResult {
+        if !args.args.is_empty() {
+            return Err(vm.new_type_error("__replace__() takes no positional arguments"));
+        }
 
-    #[pymethod]
-    fn __reduce__(zelf: PyRef<PyTuple>, vm: &VirtualMachine) -> PyTupleRef {
-        vm.new_tuple((zelf.class().to_owned(), (vm.ctx.new_tuple(zelf.to_vec()),)))
+        if Self::Data::UNNAMED_FIELDS_LEN > 0 {
+            return Err(vm.new_type_error(format!(
+                "__replace__() is not supported for {} because it has unnamed field(s)",
+                zelf.class().slot_name()
+            )));
+        }
+
+        let n_fields =
+            Self::Data::REQUIRED_FIELD_NAMES.len() + Self::Data::OPTIONAL_FIELD_NAMES.len();
+        let mut items: Vec<PyObjectRef> = zelf.as_slice()[..n_fields].to_vec();
+
+        let mut kwargs = args.kwargs.clone();
+
+        // Replace fields from kwargs
+        let all_field_names: Vec<&str> = Self::Data::REQUIRED_FIELD_NAMES
+            .iter()
+            .chain(Self::Data::OPTIONAL_FIELD_NAMES.iter())
+            .copied()
+            .collect();
+        for (i, &name) in all_field_names.iter().enumerate() {
+            if let Some(val) = kwargs.shift_remove(name) {
+                items[i] = val;
+            }
+        }
+
+        // Check for unexpected keyword arguments
+        if !kwargs.is_empty() {
+            let names: Vec<&str> = kwargs.keys().map(|k| k.as_str()).collect();
+            return Err(vm.new_type_error(format!("Got unexpected field name(s): {:?}", names)));
+        }
+
+        PyTuple::new_unchecked(items.into_boxed_slice())
+            .into_ref_with_type(vm, zelf.class().to_owned())
+            .map(Into::into)
     }
 
     #[pymethod]
@@ -327,6 +376,20 @@ pub trait PyStructSequence: StaticType + PyClassImpl + Sized + 'static {
             .slots
             .richcompare
             .store(Some(struct_sequence_richcompare));
+
+        // Default __reduce__: only set if not already overridden by the impl's extend_class.
+        // This allows struct sequences like sched_param to provide a custom __reduce__
+        // (equivalent to METH_COEXIST in structseq.c).
+        if !class
+            .attributes
+            .read()
+            .contains_key(ctx.intern_str("__reduce__"))
+        {
+            class.set_attr(
+                ctx.intern_str("__reduce__"),
+                DEFAULT_STRUCTSEQ_REDUCE.to_proper_method(class, ctx),
+            );
+        }
     }
 }
 
diff --git a/crates/vm/src/types/zoo.rs b/crates/vm/src/types/zoo.rs
index 9fa4e777a1a..0394f672cf8 100644
--- a/crates/vm/src/types/zoo.rs
+++ b/crates/vm/src/types/zoo.rs
@@ -1,7 +1,7 @@
 use crate::{
     Py,
     builtins::{
-        asyncgenerator, bool_, builtin_func, bytearray, bytes, classmethod, code, complex,
+        asyncgenerator, bool_, builtin_func, bytearray, bytes, capsule, classmethod, code, complex,
         coroutine, descriptor, dict, enumerate, filter, float, frame, function, generator,
         genericalias, getset, int, interpolation, iter, list, map, mappingproxy, memory, module,
         namespace, object, property, pystr, range, set, singletons, slice, staticmethod, super_,
@@ -28,6 +28,7 @@ pub struct TypeZoo {
     pub bytearray_iterator_type: &'static Py<PyType>,
     pub bool_type: &'static Py<PyType>,
     pub callable_iterator: &'static Py<PyType>,
+    pub capsule_type: &'static Py<PyType>,
     pub cell_type: &'static Py<PyType>,
     pub classmethod_type: &'static Py<PyType>,
     pub code_type: &'static Py<PyType>,
@@ -92,6 +93,7 @@ pub struct TypeZoo {
     pub typing_no_default_type: &'static Py<PyType>,
     pub not_implemented_type: &'static Py<PyType>,
     pub generic_alias_type: &'static Py<PyType>,
+    pub generic_alias_iterator_type: &'static Py<PyType>,
     pub union_type: &'static Py<PyType>,
     pub interpolation_type: &'static Py<PyType>,
     pub template_type: &'static Py<PyType>,
@@ -108,12 +110,20 @@ impl TypeZoo {
     #[cold]
     pub(crate) fn init() -> Self {
         let (type_type, object_type, weakref_type) = crate::object::init_type_hierarchy();
+        // the order matters for type, object, weakref, and int - must be initialized first
+        let type_type = type_::PyType::init_manually(type_type);
+        let object_type = object::PyBaseObject::init_manually(object_type);
+        let weakref_type = weakref::PyWeak::init_manually(weakref_type);
+        let int_type = int::PyInt::init_builtin_type();
+
+        // builtin_function_or_method and builtin_method share the same type (CPython behavior)
+        let builtin_function_or_method_type = builtin_func::PyNativeFunction::init_builtin_type();
+
         Self {
-            // the order matters for type, object, weakref, and int
-            type_type: type_::PyType::init_manually(type_type),
-            object_type: object::PyBaseObject::init_manually(object_type),
-            weakref_type: weakref::PyWeak::init_manually(weakref_type),
-            int_type: int::PyInt::init_builtin_type(),
+            type_type,
+            object_type,
+            weakref_type,
+            int_type,
 
             // types exposed as builtins
             bool_type: bool_::PyBool::init_builtin_type(),
@@ -147,11 +157,12 @@ impl TypeZoo {
                 asyncgenerator::PyAsyncGenWrappedValue::init_builtin_type(),
             anext_awaitable: asyncgenerator::PyAnextAwaitable::init_builtin_type(),
             bound_method_type: function::PyBoundMethod::init_builtin_type(),
-            builtin_function_or_method_type: builtin_func::PyNativeFunction::init_builtin_type(),
-            builtin_method_type: builtin_func::PyNativeMethod::init_builtin_type(),
+            builtin_function_or_method_type,
+            builtin_method_type: builtin_function_or_method_type,
             bytearray_iterator_type: bytearray::PyByteArrayIterator::init_builtin_type(),
             bytes_iterator_type: bytes::PyBytesIterator::init_builtin_type(),
             callable_iterator: iter::PyCallableIterator::init_builtin_type(),
+            capsule_type: capsule::PyCapsule::init_builtin_type(),
             cell_type: function::PyCell::init_builtin_type(),
             code_type: code::PyCode::init_builtin_type(),
             coroutine_type: coroutine::PyCoroutine::init_builtin_type(),
@@ -187,9 +198,10 @@ impl TypeZoo {
             weakproxy_type: weakproxy::PyWeakProxy::init_builtin_type(),
             method_descriptor_type: descriptor::PyMethodDescriptor::init_builtin_type(),
             none_type: singletons::PyNone::init_builtin_type(),
-            typing_no_default_type: crate::stdlib::typing::NoDefault::init_builtin_type(),
+            typing_no_default_type: crate::stdlib::_typing::NoDefault::init_builtin_type(),
             not_implemented_type: singletons::PyNotImplemented::init_builtin_type(),
             generic_alias_type: genericalias::PyGenericAlias::init_builtin_type(),
+            generic_alias_iterator_type: genericalias::PyGenericAliasIterator::init_builtin_type(),
             union_type: union_::PyUnion::init_builtin_type(),
             interpolation_type: interpolation::PyInterpolation::init_builtin_type(),
             template_type: template::PyTemplate::init_builtin_type(),
@@ -204,7 +216,7 @@ impl TypeZoo {
 
     /// Fill attributes of builtin types.
     #[cold]
-    pub(crate) fn extend(context: &Context) {
+    pub(crate) fn extend(context: &'static Context) {
         // object must be initialized before type to set object.slots.init,
         // which type will inherit via inherit_slots()
         object::init(context);
@@ -225,6 +237,7 @@ impl TypeZoo {
         complex::init(context);
         bytes::init(context);
         bytearray::init(context);
+        capsule::init(context);
         property::init(context);
         getset::init(context);
         memory::init(context);
@@ -252,6 +265,6 @@ impl TypeZoo {
         interpolation::init(context);
         template::init(context);
         descriptor::init(context);
-        crate::stdlib::typing::init(context);
+        crate::stdlib::_typing::init(context);
     }
 }
diff --git a/crates/vm/src/utils.rs b/crates/vm/src/utils.rs
index db232e81949..b5117ddd8d1 100644
--- a/crates/vm/src/utils.rs
+++ b/crates/vm/src/utils.rs
@@ -1,4 +1,4 @@
-use rustpython_common::wtf8::Wtf8;
+use rustpython_common::wtf8::{Wtf8, Wtf8Buf};
 
 use crate::{
     PyObjectRef, PyResult, VirtualMachine,
@@ -43,33 +43,31 @@ pub(crate) fn collection_repr<'a, I>(
     suffix: &str,
     iter: I,
     vm: &VirtualMachine,
-) -> PyResult<String>
+) -> PyResult<Wtf8Buf>
 where
     I: core::iter::Iterator<Item = &'a PyObjectRef>,
 {
-    let mut repr = String::new();
+    let mut repr = Wtf8Buf::new();
     if let Some(name) = class_name {
         repr.push_str(name);
-        repr.push('(');
+        repr.push_char('(');
     }
     repr.push_str(prefix);
     {
         let mut parts_iter = iter.map(|o| o.repr(vm));
-        repr.push_str(
-            parts_iter
-                .next()
-                .transpose()?
-                .expect("this is not called for empty collection")
-                .as_str(),
-        );
+        let first = parts_iter
+            .next()
+            .transpose()?
+            .expect("this is not called for empty collection");
+        repr.push_wtf8(first.as_wtf8());
         for part in parts_iter {
             repr.push_str(", ");
-            repr.push_str(part?.as_str());
+            repr.push_wtf8(part?.as_wtf8());
         }
     }
     repr.push_str(suffix);
     if class_name.is_some() {
-        repr.push(')');
+        repr.push_char(')');
     }
 
     Ok(repr)
diff --git a/crates/vm/src/version.rs b/crates/vm/src/version.rs
index a75a6f47de6..5b80a33322b 100644
--- a/crates/vm/src/version.rs
+++ b/crates/vm/src/version.rs
@@ -129,7 +129,8 @@ pub fn get_git_datetime() -> String {
 }
 
 // Must be aligned to Lib/importlib/_bootstrap_external.py
-pub const PYC_MAGIC_NUMBER: u16 = 2996;
+// Bumped to 2994 for new CommonConstant discriminants (BuiltinList, BuiltinSet)
+pub const PYC_MAGIC_NUMBER: u16 = 2994;
 
 // CPython format: magic_number | ('\r' << 16) | ('\n' << 24)
 // This protects against text-mode file reads
diff --git a/crates/vm/src/vm/compile.rs b/crates/vm/src/vm/compile.rs
index 97f0f9e97b8..7294dc8f897 100644
--- a/crates/vm/src/vm/compile.rs
+++ b/crates/vm/src/vm/compile.rs
@@ -25,6 +25,337 @@ impl VirtualMachine {
         source_path: String,
         opts: CompileOpts,
     ) -> Result<PyRef<PyCode>, CompileError> {
-        compiler::compile(source, mode, &source_path, opts).map(|code| self.ctx.new_code(code))
+        let code =
+            compiler::compile(source, mode, &source_path, opts).map(|code| self.ctx.new_code(code));
+        #[cfg(feature = "parser")]
+        if code.is_ok() {
+            self.emit_string_escape_warnings(source, &source_path);
+        }
+        code
+    }
+}
+
+/// Scan source for invalid escape sequences in all string literals and emit
+/// SyntaxWarning.
+///
+/// Corresponds to:
+/// - `warn_invalid_escape_sequence()` in `Parser/string_parser.c`
+/// - `_PyTokenizer_warn_invalid_escape_sequence()` in `Parser/tokenizer/helpers.c`
+#[cfg(feature = "parser")]
+mod escape_warnings {
+    use super::*;
+    use crate::warn;
+    use ruff_python_ast::{self as ast, visitor::Visitor};
+    use ruff_text_size::TextRange;
+
+    /// Calculate 1-indexed line number at byte offset in source.
+    fn line_number_at(source: &str, offset: usize) -> usize {
+        source[..offset.min(source.len())]
+            .bytes()
+            .filter(|&b| b == b'\n')
+            .count()
+            + 1
+    }
+
+    /// Get content bounds (start, end byte offsets) of a quoted string literal,
+    /// excluding prefix characters and quote delimiters.
+    fn content_bounds(source: &str, range: TextRange) -> Option<(usize, usize)> {
+        let s = range.start().to_usize();
+        let e = range.end().to_usize();
+        if s >= e || e > source.len() {
+            return None;
+        }
+        let bytes = &source.as_bytes()[s..e];
+        // Skip prefix (u, b, r, etc.) to find the first quote character.
+        let qi = bytes.iter().position(|&c| c == b'\'' || c == b'"')?;
+        let qc = bytes[qi];
+        let ql = if bytes.get(qi + 1) == Some(&qc) && bytes.get(qi + 2) == Some(&qc) {
+            3
+        } else {
+            1
+        };
+        let cs = s + qi + ql;
+        let ce = e.checked_sub(ql)?;
+        if cs <= ce { Some((cs, ce)) } else { None }
+    }
+
+    /// Scan `source[start..end]` for the first invalid escape sequence.
+    /// Returns `Some((invalid_char, byte_offset_in_source))` for the first
+    /// invalid escape found, or `None` if all escapes are valid.
+    ///
+    /// When `is_bytes` is true, `\u`, `\U`, and `\N` are treated as invalid
+    /// (bytes literals only support byte-oriented escapes).
+    ///
+    /// Only reports the **first** invalid escape per string literal, matching
+    /// `_PyUnicode_DecodeUnicodeEscapeInternal2` which stores only the first
+    /// `first_invalid_escape_char`.
+    fn first_invalid_escape(
+        source: &str,
+        start: usize,
+        end: usize,
+        is_bytes: bool,
+    ) -> Option<(char, usize)> {
+        let raw = &source[start..end];
+        let mut chars = raw.char_indices().peekable();
+        while let Some((i, ch)) = chars.next() {
+            if ch != '\\' {
+                continue;
+            }
+            let Some((_, next)) = chars.next() else {
+                break;
+            };
+            let valid = match next {
+                '\\' | '\'' | '"' | 'a' | 'b' | 'f' | 'n' | 'r' | 't' | 'v' => true,
+                '\n' => true,
+                '\r' => {
+                    if matches!(chars.peek(), Some(&(_, '\n'))) {
+                        chars.next();
+                    }
+                    true
+                }
+                '0'..='7' => {
+                    for _ in 0..2 {
+                        if matches!(chars.peek(), Some(&(_, '0'..='7'))) {
+                            chars.next();
+                        } else {
+                            break;
+                        }
+                    }
+                    true
+                }
+                'x' | 'u' | 'U' => {
+                    // \u and \U are only valid in string literals, not bytes
+                    if is_bytes && next != 'x' {
+                        false
+                    } else {
+                        let count = match next {
+                            'x' => 2,
+                            'u' => 4,
+                            'U' => 8,
+                            _ => unreachable!(),
+                        };
+                        for _ in 0..count {
+                            if chars.peek().is_some_and(|&(_, c)| c.is_ascii_hexdigit()) {
+                                chars.next();
+                            } else {
+                                break;
+                            }
+                        }
+                        true
+                    }
+                }
+                'N' => {
+                    // \N{name} is only valid in string literals, not bytes
+                    if is_bytes {
+                        false
+                    } else {
+                        if matches!(chars.peek(), Some(&(_, '{'))) {
+                            chars.next();
+                            for (_, c) in chars.by_ref() {
+                                if c == '}' {
+                                    break;
+                                }
+                            }
+                        }
+                        true
+                    }
+                }
+                _ => false,
+            };
+            if !valid {
+                return Some((next, start + i));
+            }
+        }
+        None
+    }
+
+    /// Emit `SyntaxWarning` for an invalid escape sequence.
+    ///
+    /// `warn_invalid_escape_sequence()` in `Parser/string_parser.c`
+    fn warn_invalid_escape_sequence(
+        source: &str,
+        ch: char,
+        offset: usize,
+        filename: &str,
+        vm: &VirtualMachine,
+    ) {
+        let lineno = line_number_at(source, offset);
+        let message = vm.ctx.new_str(format!(
+            "\"\\{ch}\" is an invalid escape sequence. \
+             Such sequences will not work in the future. \
+             Did you mean \"\\\\{ch}\"? A raw string is also an option."
+        ));
+        let fname = vm.ctx.new_str(filename);
+        let _ = warn::warn_explicit(
+            Some(vm.ctx.exceptions.syntax_warning.to_owned()),
+            message.into(),
+            fname,
+            lineno,
+            None,
+            vm.ctx.none(),
+            None,
+            None,
+            vm,
+        );
+    }
+
+    struct EscapeWarningVisitor<'a> {
+        source: &'a str,
+        filename: &'a str,
+        vm: &'a VirtualMachine,
+    }
+
+    impl<'a> EscapeWarningVisitor<'a> {
+        /// Check a quoted string/bytes literal for invalid escapes.
+        /// The range must include the prefix and quote delimiters.
+        fn check_quoted_literal(&self, range: TextRange, is_bytes: bool) {
+            if let Some((start, end)) = content_bounds(self.source, range)
+                && let Some((ch, offset)) = first_invalid_escape(self.source, start, end, is_bytes)
+            {
+                warn_invalid_escape_sequence(self.source, ch, offset, self.filename, self.vm);
+            }
+        }
+
+        /// Check an f-string literal element for invalid escapes.
+        /// The range covers content only (no prefix/quotes).
+        ///
+        /// Also handles `\{` / `\}` at the literal–interpolation boundary,
+        /// equivalent to `_PyTokenizer_warn_invalid_escape_sequence` handling
+        /// `FSTRING_MIDDLE` / `FSTRING_END` tokens.
+        fn check_fstring_literal(&self, range: TextRange) {
+            let start = range.start().to_usize();
+            let end = range.end().to_usize();
+            if start >= end || end > self.source.len() {
+                return;
+            }
+            if let Some((ch, offset)) = first_invalid_escape(self.source, start, end, false) {
+                warn_invalid_escape_sequence(self.source, ch, offset, self.filename, self.vm);
+                return;
+            }
+            // In CPython, _PyTokenizer_warn_invalid_escape_sequence handles
+            // `\{` and `\}` for FSTRING_MIDDLE/FSTRING_END tokens.  Ruff
+            // splits the literal element before the interpolation delimiter,
+            // so the `\` sits at the end of the literal range and the `{`/`}`
+            // sits just after it.  Only warn when the number of trailing
+            // backslashes is odd (an even count means they are all escaped).
+            let trailing_bs = self.source.as_bytes()[start..end]
+                .iter()
+                .rev()
+                .take_while(|&&b| b == b'\\')
+                .count();
+            if trailing_bs % 2 == 1
+                && let Some(&after) = self.source.as_bytes().get(end)
+                && (after == b'{' || after == b'}')
+            {
+                warn_invalid_escape_sequence(
+                    self.source,
+                    after as char,
+                    end - 1,
+                    self.filename,
+                    self.vm,
+                );
+            }
+        }
+
+        /// Visit f-string elements, checking literals and recursing into
+        /// interpolation expressions and format specs.
+        fn visit_fstring_elements(&mut self, elements: &'a ast::InterpolatedStringElements) {
+            for element in elements {
+                match element {
+                    ast::InterpolatedStringElement::Literal(lit) => {
+                        self.check_fstring_literal(lit.range);
+                    }
+                    ast::InterpolatedStringElement::Interpolation(interp) => {
+                        self.visit_expr(&interp.expression);
+                        if let Some(spec) = &interp.format_spec {
+                            self.visit_fstring_elements(&spec.elements);
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    impl<'a> Visitor<'a> for EscapeWarningVisitor<'a> {
+        fn visit_expr(&mut self, expr: &'a ast::Expr) {
+            match expr {
+                // Regular string literals — decode_unicode_with_escapes path
+                ast::Expr::StringLiteral(string) => {
+                    for part in string.value.as_slice() {
+                        if !matches!(
+                            part.flags.prefix(),
+                            ast::str_prefix::StringLiteralPrefix::Raw { .. }
+                        ) {
+                            self.check_quoted_literal(part.range, false);
+                        }
+                    }
+                }
+                // Byte string literals — decode_bytes_with_escapes path
+                ast::Expr::BytesLiteral(bytes) => {
+                    for part in bytes.value.as_slice() {
+                        if !matches!(
+                            part.flags.prefix(),
+                            ast::str_prefix::ByteStringPrefix::Raw { .. }
+                        ) {
+                            self.check_quoted_literal(part.range, true);
+                        }
+                    }
+                }
+                // F-string literals — tokenizer + string_parser paths
+                ast::Expr::FString(fstring_expr) => {
+                    for part in fstring_expr.value.as_slice() {
+                        match part {
+                            ast::FStringPart::Literal(string_lit) => {
+                                // Plain string part in f-string concatenation
+                                if !matches!(
+                                    string_lit.flags.prefix(),
+                                    ast::str_prefix::StringLiteralPrefix::Raw { .. }
+                                ) {
+                                    self.check_quoted_literal(string_lit.range, false);
+                                }
+                            }
+                            ast::FStringPart::FString(fstring) => {
+                                if matches!(
+                                    fstring.flags.prefix(),
+                                    ast::str_prefix::FStringPrefix::Raw { .. }
+                                ) {
+                                    continue;
+                                }
+                                self.visit_fstring_elements(&fstring.elements);
+                            }
+                        }
+                    }
+                }
+                _ => ast::visitor::walk_expr(self, expr),
+            }
+        }
+    }
+
+    impl VirtualMachine {
+        /// Walk all string literals in `source` and emit `SyntaxWarning` for
+        /// each that contains an invalid escape sequence.
+        pub(super) fn emit_string_escape_warnings(&self, source: &str, filename: &str) {
+            let Ok(parsed) =
+                ruff_python_parser::parse(source, ruff_python_parser::Mode::Module.into())
+            else {
+                return;
+            };
+            let ast = parsed.into_syntax();
+            let mut visitor = EscapeWarningVisitor {
+                source,
+                filename,
+                vm: self,
+            };
+            match ast {
+                ast::Mod::Module(module) => {
+                    for stmt in &module.body {
+                        visitor.visit_stmt(stmt);
+                    }
+                }
+                ast::Mod::Expression(expr) => {
+                    visitor.visit_expr(&expr.body);
+                }
+            }
+        }
     }
 }
diff --git a/crates/vm/src/vm/context.rs b/crates/vm/src/vm/context.rs
index f4368e91a1d..fedb641c542 100644
--- a/crates/vm/src/vm/context.rs
+++ b/crates/vm/src/vm/context.rs
@@ -3,7 +3,7 @@ use crate::{
     builtins::{
         PyByteArray, PyBytes, PyComplex, PyDict, PyDictRef, PyEllipsis, PyFloat, PyFrozenSet,
         PyInt, PyIntRef, PyList, PyListRef, PyNone, PyNotImplemented, PyStr, PyStrInterned,
-        PyTuple, PyTupleRef, PyType, PyTypeRef,
+        PyTuple, PyTupleRef, PyType, PyTypeRef, PyUtf8Str,
         bool_::PyBool,
         code::{self, PyCode},
         descriptor::{
@@ -14,6 +14,7 @@ use crate::{
         object, pystr,
         type_::PyAttributes,
     },
+    bytecode::{self, CodeFlags, CodeUnit, Instruction},
     class::StaticType,
     common::rc::PyRc,
     exceptions,
@@ -29,6 +30,7 @@ use malachite_bigint::BigInt;
 use num_complex::Complex64;
 use num_traits::ToPrimitive;
 use rustpython_common::lock::PyRwLock;
+use rustpython_compiler_core::{OneIndexed, SourceLocation};
 
 #[derive(Debug)]
 pub struct Context {
@@ -42,15 +44,22 @@ pub struct Context {
     pub ellipsis: PyRef<PyEllipsis>,
     pub not_implemented: PyRef<PyNotImplemented>,
 
-    pub typing_no_default: PyRef<crate::stdlib::typing::NoDefault>,
+    pub typing_no_default: PyRef<crate::stdlib::_typing::NoDefault>,
 
     pub types: TypeZoo,
     pub exceptions: exceptions::ExceptionZoo,
     pub int_cache_pool: Vec<PyIntRef>,
+    pub(crate) latin1_char_cache: Vec<PyRef<PyStr>>,
+    pub(crate) ascii_char_cache: Vec<PyRef<PyStr>>,
+    pub(crate) init_cleanup_code: PyRef<PyCode>,
     // there should only be exact objects of str in here, no non-str objects and no subclasses
     pub(crate) string_pool: StringPool,
     pub(crate) slot_new_wrapper: PyMethodDef,
     pub names: ConstName,
+
+    // GC module state (callbacks and garbage lists)
+    pub gc_callbacks: PyListRef,
+    pub gc_garbage: PyListRef,
 }
 
 macro_rules! declare_const_name {
@@ -109,6 +118,7 @@ declare_const_name! {
     __class__,
     __class_getitem__,
     __classcell__,
+    __classdictcell__,
     __complex__,
     __contains__,
     __copy__,
@@ -126,6 +136,7 @@ declare_const_name! {
     __eq__,
     __exit__,
     __file__,
+    __firstlineno__,
     __float__,
     __floor__,
     __floordiv__,
@@ -240,7 +251,12 @@ declare_const_name! {
     // common names
     _attributes,
     _fields,
+    _defaultaction,
+    _onceregistry,
     _showwarnmsg,
+    defaultaction,
+    onceregistry,
+    filters,
     backslashreplace,
     close,
     copy,
@@ -276,7 +292,15 @@ impl Context {
         rustpython_common::static_cell! {
             static CONTEXT: PyRc<Context>;
         }
-        CONTEXT.get_or_init(|| PyRc::new(Self::init_genesis()))
+        CONTEXT.get_or_init(|| {
+            let ctx = PyRc::new(Self::init_genesis());
+            // SAFETY: ctx is heap-allocated via PyRc and will be stored in
+            // the CONTEXT static cell, so the Context lives for 'static.
+            let ctx_ref: &'static Context = unsafe { &*PyRc::as_ptr(&ctx) };
+            crate::types::TypeZoo::extend(ctx_ref);
+            crate::exceptions::ExceptionZoo::extend(ctx_ref);
+            ctx
+        })
     }
 
     fn init_genesis() -> Self {
@@ -294,8 +318,8 @@ impl Context {
         let not_implemented = create_object(PyNotImplemented, PyNotImplemented::static_type());
 
         let typing_no_default = create_object(
-            crate::stdlib::typing::NoDefault,
-            crate::stdlib::typing::NoDefault::static_type(),
+            crate::stdlib::_typing::NoDefault,
+            crate::stdlib::_typing::NoDefault::static_type(),
         );
 
         let int_cache_pool = Self::INT_CACHE_POOL_RANGE
@@ -307,6 +331,10 @@ impl Context {
                 )
             })
             .collect();
+        let latin1_char_cache: Vec<PyRef<PyStr>> = (0u8..=255)
+            .map(|b| create_object(PyStr::from(char::from(b)), types.str_type))
+            .collect();
+        let ascii_char_cache = latin1_char_cache[..128].to_vec();
 
         let true_value = create_object(PyBool(PyInt::from(1)), types.bool_type);
         let false_value = create_object(PyBool(PyInt::from(0)), types.bool_type);
@@ -330,9 +358,15 @@ impl Context {
             PyMethodFlags::METHOD,
             None,
         );
+        let init_cleanup_code = Self::new_init_cleanup_code(&types, &names);
 
         let empty_str = unsafe { string_pool.intern("", types.str_type.to_owned()) };
         let empty_bytes = create_object(PyBytes::from(Vec::new()), types.bytes_type);
+
+        // GC callbacks and garbage lists
+        let gc_callbacks = PyRef::new_ref(PyList::default(), types.list_type.to_owned(), None);
+        let gc_garbage = PyRef::new_ref(PyList::default(), types.list_type.to_owned(), None);
+
         Self {
             true_value,
             false_value,
@@ -349,12 +383,63 @@ impl Context {
             types,
             exceptions,
             int_cache_pool,
+            latin1_char_cache,
+            ascii_char_cache,
+            init_cleanup_code,
             string_pool,
             slot_new_wrapper,
             names,
+
+            gc_callbacks,
+            gc_garbage,
         }
     }
 
+    fn new_init_cleanup_code(types: &TypeZoo, names: &ConstName) -> PyRef<PyCode> {
+        let loc = SourceLocation {
+            line: OneIndexed::MIN,
+            character_offset: OneIndexed::from_zero_indexed(0),
+        };
+        let instructions = [
+            CodeUnit {
+                op: Instruction::ExitInitCheck,
+                arg: 0.into(),
+            },
+            CodeUnit {
+                op: Instruction::ReturnValue,
+                arg: 0.into(),
+            },
+            CodeUnit {
+                op: Instruction::Resume {
+                    context: bytecode::Arg::marker(),
+                },
+                arg: 0.into(),
+            },
+        ];
+        let code = bytecode::CodeObject {
+            instructions: instructions.into(),
+            locations: vec![(loc, loc); instructions.len()].into_boxed_slice(),
+            flags: CodeFlags::OPTIMIZED,
+            posonlyarg_count: 0,
+            arg_count: 0,
+            kwonlyarg_count: 0,
+            source_path: names.__init__,
+            first_line_number: None,
+            max_stackdepth: 2,
+            obj_name: names.__init__,
+            qualname: names.__init__,
+            constants: core::iter::empty().collect(),
+            names: Vec::new().into_boxed_slice(),
+            varnames: Vec::new().into_boxed_slice(),
+            cellvars: Vec::new().into_boxed_slice(),
+            freevars: Vec::new().into_boxed_slice(),
+            localspluskinds: Vec::new().into_boxed_slice(),
+            linetable: Vec::new().into_boxed_slice(),
+            exceptiontable: Vec::new().into_boxed_slice(),
+        };
+        PyRef::new_ref(PyCode::new(code), types.code_type.to_owned(), None)
+    }
+
     pub fn intern_str<S: InternableString>(&self, s: S) -> &'static PyStrInterned {
         unsafe { self.string_pool.intern(s, self.types.str_type.to_owned()) }
     }
@@ -425,8 +510,32 @@ impl Context {
         PyComplex::from(value).into_ref(self)
     }
 
+    #[inline]
+    pub fn latin1_char(&self, ch: u8) -> PyRef<PyStr> {
+        self.latin1_char_cache[ch as usize].clone()
+    }
+
+    #[inline]
+    fn latin1_singleton_index(s: &PyStr) -> Option<u8> {
+        let mut cps = s.as_wtf8().code_points();
+        let cp = cps.next()?;
+        if cps.next().is_some() {
+            return None;
+        }
+        u8::try_from(cp.to_u32()).ok()
+    }
+
     #[inline]
     pub fn new_str(&self, s: impl Into<pystr::PyStr>) -> PyRef<PyStr> {
+        let s = s.into();
+        if let Some(ch) = Self::latin1_singleton_index(&s) {
+            return self.latin1_char(ch);
+        }
+        s.into_ref(self)
+    }
+
+    #[inline]
+    pub fn new_utf8_str(&self, s: impl Into<PyUtf8Str>) -> PyRef<PyUtf8Str> {
         s.into().into_ref(self)
     }
 
@@ -443,7 +552,11 @@ impl Context {
 
     #[inline]
     pub fn new_bytes(&self, data: Vec<u8>) -> PyRef<PyBytes> {
-        PyBytes::from(data).into_ref(self)
+        if data.is_empty() {
+            self.empty_bytes.clone()
+        } else {
+            PyBytes::from(data).into_ref(self)
+        }
     }
 
     #[inline]
@@ -637,7 +750,7 @@ impl Context {
 
     pub fn new_code(&self, code: impl code::IntoCodeObject) -> PyRef<PyCode> {
         let code = code.into_code_object(self);
-        PyRef::new_ref(PyCode { code }, self.types.code_type.to_owned(), None)
+        PyRef::new_ref(PyCode::new(code), self.types.code_type.to_owned(), None)
     }
 }
 
diff --git a/crates/vm/src/vm/interpreter.rs b/crates/vm/src/vm/interpreter.rs
index 7f33a8a49e4..57f3d406461 100644
--- a/crates/vm/src/vm/interpreter.rs
+++ b/crates/vm/src/vm/interpreter.rs
@@ -1,12 +1,19 @@
+#[cfg(all(unix, feature = "threading"))]
+use super::StopTheWorldState;
 use super::{Context, PyConfig, PyGlobalState, VirtualMachine, setting::Settings, thread};
 use crate::{
     PyResult, builtins, common::rc::PyRc, frozen::FrozenModule, getpath, py_freeze, stdlib::atexit,
     vm::PyBaseExceptionRef,
 };
+use alloc::collections::BTreeMap;
 use core::sync::atomic::Ordering;
 
 type InitFunc = Box<dyn FnOnce(&mut VirtualMachine)>;
 
+/// Exit code used when stdout/stderr flush fails during interpreter shutdown.
+/// Matches CPython's behavior (see cpython/Python/pylifecycle.c).
+const EXITCODE_FLUSH_FAILURE: u32 = 120;
+
 /// Configuration builder for constructing an Interpreter.
 ///
 /// This is the preferred way to configure and create an interpreter with custom modules.
@@ -45,24 +52,19 @@ where
     use crate::common::hash::HashSecret;
     use crate::common::lock::PyMutex;
     use crate::warn::WarningsState;
+    use core::sync::atomic::{AtomicBool, AtomicU64};
     use crossbeam_utils::atomic::AtomicCell;
-    use std::sync::atomic::AtomicBool;
 
     let paths = getpath::init_path_config(&settings);
     let config = PyConfig::new(settings, paths);
 
-    crate::types::TypeZoo::extend(&ctx);
-    crate::exceptions::ExceptionZoo::extend(&ctx);
-
     // Build module_defs map from builtin modules + additional modules
-    let mut all_module_defs: std::collections::BTreeMap<
-        &'static str,
-        &'static builtins::PyModuleDef,
-    > = crate::stdlib::builtin_module_defs(&ctx)
-        .into_iter()
-        .chain(module_defs)
-        .map(|def| (def.name.as_str(), def))
-        .collect();
+    let mut all_module_defs: BTreeMap<&'static str, &'static builtins::PyModuleDef> =
+        crate::stdlib::builtin_module_defs(&ctx)
+            .into_iter()
+            .chain(module_defs)
+            .map(|def| (def.name.as_str(), def))
+            .collect();
 
     // Register sysconfigdata under platform-specific name as well
     if let Some(&sysconfigdata_def) = all_module_defs.get("_sysconfigdata") {
@@ -125,6 +127,11 @@ where
         thread_handles: parking_lot::Mutex::new(Vec::new()),
         #[cfg(feature = "threading")]
         shutdown_handles: parking_lot::Mutex::new(Vec::new()),
+        monitoring: PyMutex::default(),
+        monitoring_events: AtomicCell::new(0),
+        instrumentation_version: AtomicU64::new(0),
+        #[cfg(all(unix, feature = "threading"))]
+        stop_the_world: StopTheWorldState::new(),
     });
 
     // Create VM with the global state
@@ -388,15 +395,17 @@ impl Interpreter {
     /// Finalization steps (matching Py_FinalizeEx):
     /// 1. Flush stdout and stderr.
     /// 1. Handle exit exception and turn it to exit code.
-    /// 1. Wait for thread shutdown (call threading._shutdown).
-    /// 1. Mark vm as finalizing.
+    /// 1. Call threading._shutdown() to join non-daemon threads.
     /// 1. Run atexit exit functions.
-    /// 1. Mark vm as finalized.
+    /// 1. Set finalizing flag (suppresses unraisable exceptions from __del__).
+    /// 1. Forced GC collection pass (collect cycles while builtins are available).
+    /// 1. Module finalization (finalize_modules).
+    /// 1. Final stdout/stderr flush.
     ///
     /// Note that calling `finalize` is not necessary by purpose though.
     pub fn finalize(self, exc: Option<PyBaseExceptionRef>) -> u32 {
         self.enter(|vm| {
-            vm.flush_std();
+            let mut flush_status = vm.flush_std();
 
             // See if any exception leaked out:
             let exit_code = if let Some(exc) = exc {
@@ -419,15 +428,31 @@ impl Interpreter {
                 );
             }
 
-            // Mark as finalizing AFTER thread shutdown
+            // Run atexit handlers before setting finalizing flag.
+            // This allows unraisable exceptions from atexit handlers to be reported.
+            atexit::_run_exitfuncs(vm);
+
+            // Now suppress unraisable exceptions from daemon threads and __del__
+            // methods during the rest of shutdown.
             vm.state.finalizing.store(true, Ordering::Release);
 
-            // Run atexit exit functions
-            atexit::_run_exitfuncs(vm);
+            // GC pass - collect cycles before module cleanup
+            crate::gc_state::gc_state().collect_force(2);
 
-            vm.flush_std();
+            // Module finalization: remove modules from sys.modules, GC collect
+            // (while builtins is still available for __del__), then clear module dicts.
+            vm.finalize_modules();
 
-            exit_code
+            if vm.flush_std() < 0 && flush_status == 0 {
+                flush_status = -1;
+            }
+
+            // Match CPython: if exit_code is 0 and stdout flush failed, exit 120
+            if exit_code == 0 && flush_status < 0 {
+                EXITCODE_FLUSH_FAILURE
+            } else {
+                exit_code
+            }
         })
     }
 }
@@ -440,19 +465,12 @@ fn core_frozen_inits() -> impl Iterator<Item = (&'static str, FrozenModule)> {
         };
     }
 
-    // keep as example but use file one now
-    // ext_modules!(
-    //     iter,
-    //     source = "initialized = True; print(\"Hello world!\")\n",
-    //     module_name = "__hello__",
-    // );
-
     // Python modules that the vm calls into, but are not actually part of the stdlib. They could
     // in theory be implemented in Rust, but are easiest to do in Python for one reason or another.
     // Includes _importlib_bootstrap and _importlib_bootstrap_external
     ext_modules!(
         iter,
-        dir = "./Lib/python_builtins",
+        dir = "../../Lib/python_builtins",
         crate_name = "rustpython_compiler_core"
     );
 
@@ -463,11 +481,75 @@ fn core_frozen_inits() -> impl Iterator<Item = (&'static str, FrozenModule)> {
     // #[cfg(not(feature = "freeze-stdlib"))]
     ext_modules!(
         iter,
-        dir = "./Lib/core_modules",
+        dir = "../../Lib/core_modules",
         crate_name = "rustpython_compiler_core"
     );
 
-    iter
+    // Collect frozen module entries
+    let mut entries: Vec<_> = iter.collect();
+
+    // Add test module aliases
+    if let Some(hello_code) = entries
+        .iter()
+        .find(|(n, _)| *n == "__hello__")
+        .map(|(_, m)| m.code)
+    {
+        entries.push((
+            "__hello_alias__",
+            FrozenModule {
+                code: hello_code,
+                package: false,
+            },
+        ));
+        entries.push((
+            "__phello_alias__",
+            FrozenModule {
+                code: hello_code,
+                package: true,
+            },
+        ));
+        entries.push((
+            "__phello_alias__.spam",
+            FrozenModule {
+                code: hello_code,
+                package: false,
+            },
+        ));
+        entries.push((
+            "__hello_only__",
+            FrozenModule {
+                code: hello_code,
+                package: false,
+            },
+        ));
+    }
+    if let Some(code) = entries
+        .iter()
+        .find(|(n, _)| *n == "__phello__")
+        .map(|(_, m)| m.code)
+    {
+        entries.push((
+            "__phello__.__init__",
+            FrozenModule {
+                code,
+                package: false,
+            },
+        ));
+    }
+    if let Some(code) = entries
+        .iter()
+        .find(|(n, _)| *n == "__phello__.ham")
+        .map(|(_, m)| m.code)
+    {
+        entries.push((
+            "__phello__.ham.__init__",
+            FrozenModule {
+                code,
+                package: false,
+            },
+        ));
+    }
+    entries.into_iter()
 }
 
 #[cfg(test)]
@@ -497,7 +579,7 @@ mod tests {
             let b = vm.new_pyobj(4_i32);
             let res = vm._mul(&a, &b).unwrap();
             let value = res.downcast_ref::<PyStr>().unwrap();
-            assert_eq!(value.as_str(), "Hello Hello Hello Hello ")
+            assert_eq!(value.as_wtf8(), "Hello Hello Hello Hello ")
         })
     }
 }
diff --git a/crates/vm/src/vm/mod.rs b/crates/vm/src/vm/mod.rs
index 9df9f9bea4d..231ba5cde38 100644
--- a/crates/vm/src/vm/mod.rs
+++ b/crates/vm/src/vm/mod.rs
@@ -20,7 +20,7 @@ use crate::{
     AsObject, Py, PyObject, PyObjectRef, PyPayload, PyRef, PyResult,
     builtins::{
         self, PyBaseExceptionRef, PyDict, PyDictRef, PyInt, PyList, PyModule, PyStr, PyStrInterned,
-        PyStrRef, PyTypeRef,
+        PyStrRef, PyTypeRef, PyUtf8Str, PyUtf8StrInterned, PyWeak,
         code::PyCode,
         dict::{PyDictItems, PyDictKeys, PyDictValues},
         pystr::AsPyStr,
@@ -39,10 +39,13 @@ use crate::{
     signal, stdlib,
     warn::WarningsState,
 };
-use alloc::borrow::Cow;
+use alloc::{borrow::Cow, collections::BTreeMap};
+#[cfg(all(unix, feature = "threading"))]
+use core::sync::atomic::AtomicI64;
 use core::{
-    cell::{Cell, Ref, RefCell},
-    sync::atomic::AtomicBool,
+    cell::{Cell, OnceCell, RefCell},
+    ptr::NonNull,
+    sync::atomic::{AtomicBool, AtomicU64, Ordering},
 };
 use crossbeam_utils::atomic::AtomicCell;
 #[cfg(unix)]
@@ -72,21 +75,26 @@ pub struct VirtualMachine {
     pub builtins: PyRef<PyModule>,
     pub sys_module: PyRef<PyModule>,
     pub ctx: PyRc<Context>,
-    pub frames: RefCell<Vec<FrameRef>>,
+    pub frames: RefCell<Vec<FramePtr>>,
+    /// Thread-local data stack for bump-allocating frame-local data
+    /// (localsplus arrays for non-generator frames).
+    datastack: core::cell::UnsafeCell<crate::datastack::DataStack>,
     pub wasm_id: Option<String>,
     exceptions: RefCell<ExceptionStack>,
     pub import_func: PyObjectRef,
+    pub(crate) importlib: PyObjectRef,
     pub profile_func: RefCell<PyObjectRef>,
     pub trace_func: RefCell<PyObjectRef>,
     pub use_tracing: Cell<bool>,
     pub recursion_limit: Cell<usize>,
-    pub(crate) signal_handlers: Option<Box<RefCell<[Option<PyObjectRef>; signal::NSIG]>>>,
+    pub(crate) signal_handlers: OnceCell<Box<RefCell<[Option<PyObjectRef>; signal::NSIG]>>>,
     pub(crate) signal_rx: Option<signal::UserSignalReceiver>,
     pub repr_guards: RefCell<HashSet<usize>>,
     pub state: PyRc<PyGlobalState>,
     pub initialized: bool,
     recursion_depth: Cell<usize>,
     /// C stack soft limit for detecting stack overflow (like c_stack_soft_limit)
+    #[cfg_attr(any(miri, target_env = "musl"), allow(dead_code))]
     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>>,
@@ -96,22 +104,490 @@ pub struct VirtualMachine {
     pub asyncio_running_loop: RefCell<Option<PyObjectRef>>,
     /// Current running asyncio task for this thread
     pub asyncio_running_task: RefCell<Option<PyObjectRef>>,
+    pub(crate) callable_cache: CallableCache,
 }
 
+/// Non-owning frame pointer for the frames stack.
+/// The pointed-to frame is kept alive by the caller of with_frame_exc/resume_gen_frame.
+#[derive(Copy, Clone)]
+pub struct FramePtr(NonNull<Py<Frame>>);
+
+impl FramePtr {
+    /// # Safety
+    /// The pointed-to frame must still be alive.
+    pub unsafe fn as_ref(&self) -> &Py<Frame> {
+        unsafe { self.0.as_ref() }
+    }
+}
+
+// SAFETY: FramePtr is only stored in the VM's frames Vec while the corresponding
+// FrameRef is alive on the call stack. The Vec is always empty when the VM moves between threads.
+unsafe impl Send for FramePtr {}
+
 #[derive(Debug, Default)]
 struct ExceptionStack {
-    exc: Option<PyBaseExceptionRef>,
-    prev: Option<Box<ExceptionStack>>,
+    stack: Vec<Option<PyBaseExceptionRef>>,
+}
+
+/// Stop-the-world state for fork safety. Before `fork()`, the requester
+/// stops all other Python threads so they are not holding internal locks.
+#[cfg(all(unix, feature = "threading"))]
+pub struct StopTheWorldState {
+    /// Fast-path flag checked in the bytecode loop (like `_PY_EVAL_PLEASE_STOP_BIT`)
+    pub(crate) requested: AtomicBool,
+    /// Whether the world is currently stopped (`stw->world_stopped`).
+    world_stopped: AtomicBool,
+    /// Ident of the thread that requested the stop (like `stw->requester`)
+    requester: AtomicU64,
+    /// Signaled by suspending threads when their state transitions to SUSPENDED
+    notify_mutex: std::sync::Mutex<()>,
+    notify_cv: std::sync::Condvar,
+    /// Number of non-requester threads still expected to park for current stop request.
+    thread_countdown: AtomicI64,
+    /// Number of stop-the-world attempts.
+    stats_stop_calls: AtomicU64,
+    /// Most recent stop-the-world wait duration in ns.
+    stats_last_wait_ns: AtomicU64,
+    /// Total accumulated stop-the-world wait duration in ns.
+    stats_total_wait_ns: AtomicU64,
+    /// Max observed stop-the-world wait duration in ns.
+    stats_max_wait_ns: AtomicU64,
+    /// Number of poll-loop iterations spent waiting.
+    stats_poll_loops: AtomicU64,
+    /// Number of ATTACHED threads observed while polling.
+    stats_attached_seen: AtomicU64,
+    /// Number of DETACHED->SUSPENDED parks requested by requester.
+    stats_forced_parks: AtomicU64,
+    /// Number of suspend notifications from worker threads.
+    stats_suspend_notifications: AtomicU64,
+    /// Number of yield loops while attach waited on SUSPENDED->DETACHED.
+    stats_attach_wait_yields: AtomicU64,
+    /// Number of yield loops while suspend waited on SUSPENDED->DETACHED.
+    stats_suspend_wait_yields: AtomicU64,
+}
+
+#[cfg(all(unix, feature = "threading"))]
+#[derive(Debug, Clone, Copy)]
+pub struct StopTheWorldStats {
+    pub stop_calls: u64,
+    pub last_wait_ns: u64,
+    pub total_wait_ns: u64,
+    pub max_wait_ns: u64,
+    pub poll_loops: u64,
+    pub attached_seen: u64,
+    pub forced_parks: u64,
+    pub suspend_notifications: u64,
+    pub attach_wait_yields: u64,
+    pub suspend_wait_yields: u64,
+    pub world_stopped: bool,
+}
+
+#[cfg(all(unix, feature = "threading"))]
+impl Default for StopTheWorldState {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+#[cfg(all(unix, feature = "threading"))]
+impl StopTheWorldState {
+    pub const fn new() -> Self {
+        Self {
+            requested: AtomicBool::new(false),
+            world_stopped: AtomicBool::new(false),
+            requester: AtomicU64::new(0),
+            notify_mutex: std::sync::Mutex::new(()),
+            notify_cv: std::sync::Condvar::new(),
+            thread_countdown: AtomicI64::new(0),
+            stats_stop_calls: AtomicU64::new(0),
+            stats_last_wait_ns: AtomicU64::new(0),
+            stats_total_wait_ns: AtomicU64::new(0),
+            stats_max_wait_ns: AtomicU64::new(0),
+            stats_poll_loops: AtomicU64::new(0),
+            stats_attached_seen: AtomicU64::new(0),
+            stats_forced_parks: AtomicU64::new(0),
+            stats_suspend_notifications: AtomicU64::new(0),
+            stats_attach_wait_yields: AtomicU64::new(0),
+            stats_suspend_wait_yields: AtomicU64::new(0),
+        }
+    }
+
+    /// Wake the stop-the-world requester (called by each thread that suspends).
+    pub(crate) fn notify_suspended(&self) {
+        self.stats_suspend_notifications
+            .fetch_add(1, Ordering::Relaxed);
+        // Synchronize with requester wait loop to avoid lost wakeups.
+        let _guard = self.notify_mutex.lock().unwrap();
+        self.decrement_thread_countdown(1);
+        self.notify_cv.notify_one();
+    }
+
+    #[inline]
+    fn init_thread_countdown(&self, vm: &VirtualMachine) -> i64 {
+        let requester = self.requester.load(Ordering::Relaxed);
+        let registry = vm.state.thread_frames.lock();
+        // Keep requested/count initialization serialized with thread-slot
+        // registration (which also takes this lock), matching the
+        // HEAD_LOCK-guarded stop-the-world bookkeeping.
+        self.requested.store(true, Ordering::Release);
+        let count = registry
+            .keys()
+            .filter(|&&thread_id| thread_id != requester)
+            .count();
+        let count = (count.min(i64::MAX as usize)) as i64;
+        self.thread_countdown.store(count, Ordering::Release);
+        count
+    }
+
+    #[inline]
+    fn decrement_thread_countdown(&self, n: u64) {
+        if n == 0 {
+            return;
+        }
+        let n = (n.min(i64::MAX as u64)) as i64;
+        let prev = self.thread_countdown.fetch_sub(n, Ordering::AcqRel);
+        if prev <= n {
+            // Clamp at 0 for safety in case of duplicate notifications.
+            self.thread_countdown.store(0, Ordering::Release);
+        }
+    }
+
+    /// Try to CAS detached threads directly to SUSPENDED and check whether
+    /// stop countdown reached zero after parking detached threads.
+    fn park_detached_threads(&self, vm: &VirtualMachine) -> bool {
+        use thread::{THREAD_ATTACHED, THREAD_DETACHED, THREAD_SUSPENDED};
+        let requester = self.requester.load(Ordering::Relaxed);
+        let registry = vm.state.thread_frames.lock();
+        let mut attached_seen = 0u64;
+        let mut forced_parks = 0u64;
+        for (&id, slot) in registry.iter() {
+            if id == requester {
+                continue;
+            }
+            let state = slot.state.load(Ordering::Relaxed);
+            if state == THREAD_DETACHED {
+                // CAS DETACHED → SUSPENDED (park without thread cooperation)
+                match slot.state.compare_exchange(
+                    THREAD_DETACHED,
+                    THREAD_SUSPENDED,
+                    Ordering::AcqRel,
+                    Ordering::Relaxed,
+                ) {
+                    Ok(_) => {
+                        slot.stop_requested.store(false, Ordering::Release);
+                        forced_parks = forced_parks.saturating_add(1);
+                    }
+                    Err(THREAD_ATTACHED) => {
+                        // Set per-thread stop bit (_PY_EVAL_PLEASE_STOP_BIT).
+                        slot.stop_requested.store(true, Ordering::Release);
+                        // Raced with a thread re-attaching; it will self-suspend.
+                        attached_seen = attached_seen.saturating_add(1);
+                    }
+                    Err(THREAD_DETACHED) => {
+                        // Extremely unlikely race; next poll will handle it.
+                    }
+                    Err(THREAD_SUSPENDED) => {
+                        slot.stop_requested.store(false, Ordering::Release);
+                        // Another path parked it first.
+                    }
+                    Err(other) => {
+                        debug_assert!(
+                            false,
+                            "unexpected thread state in park_detached_threads: {other}"
+                        );
+                    }
+                }
+            } else if state == THREAD_ATTACHED {
+                // Set per-thread stop bit (_PY_EVAL_PLEASE_STOP_BIT).
+                slot.stop_requested.store(true, Ordering::Release);
+                // Thread is in bytecode — it will see `requested` and self-suspend
+                attached_seen = attached_seen.saturating_add(1);
+            }
+            // THREAD_SUSPENDED → already parked
+        }
+        if attached_seen != 0 {
+            self.stats_attached_seen
+                .fetch_add(attached_seen, Ordering::Relaxed);
+        }
+        if forced_parks != 0 {
+            self.decrement_thread_countdown(forced_parks);
+            self.stats_forced_parks
+                .fetch_add(forced_parks, Ordering::Relaxed);
+        }
+        forced_parks != 0 && self.thread_countdown.load(Ordering::Acquire) == 0
+    }
+
+    /// Stop all non-requester threads (`stop_the_world`).
+    ///
+    /// 1. Sets `requested`, marking the requester thread.
+    /// 2. CAS detached threads to SUSPENDED.
+    /// 3. Waits (polling with 1 ms condvar timeout) for attached threads
+    ///    to self-suspend in `check_signals`.
+    pub fn stop_the_world(&self, vm: &VirtualMachine) {
+        let start = std::time::Instant::now();
+        let requester_ident = crate::stdlib::_thread::get_ident();
+        self.requester.store(requester_ident, Ordering::Relaxed);
+        self.stats_stop_calls.fetch_add(1, Ordering::Relaxed);
+        let initial_countdown = self.init_thread_countdown(vm);
+        stw_trace(format_args!("stop begin requester={requester_ident}"));
+        if initial_countdown == 0 {
+            self.world_stopped.store(true, Ordering::Release);
+            #[cfg(debug_assertions)]
+            self.debug_assert_all_non_requester_suspended(vm);
+            stw_trace(format_args!(
+                "stop end requester={requester_ident} wait_ns=0 polls=0"
+            ));
+            return;
+        }
+
+        let mut polls = 0u64;
+        loop {
+            if self.park_detached_threads(vm) {
+                break;
+            }
+            polls = polls.saturating_add(1);
+            // Wait up to 1 ms for a thread to notify us it suspended.
+            // Re-check under the wait mutex first to avoid a lost-wake race:
+            // a thread may have suspended and notified right before we enter wait.
+            let guard = self.notify_mutex.lock().unwrap();
+            if self.thread_countdown.load(Ordering::Acquire) == 0 || self.park_detached_threads(vm)
+            {
+                drop(guard);
+                break;
+            }
+            let _ = self
+                .notify_cv
+                .wait_timeout(guard, core::time::Duration::from_millis(1));
+        }
+        if polls != 0 {
+            self.stats_poll_loops.fetch_add(polls, Ordering::Relaxed);
+        }
+        let wait_ns = start.elapsed().as_nanos().min(u128::from(u64::MAX)) as u64;
+        self.stats_last_wait_ns.store(wait_ns, Ordering::Relaxed);
+        self.stats_total_wait_ns
+            .fetch_add(wait_ns, Ordering::Relaxed);
+        let mut prev_max = self.stats_max_wait_ns.load(Ordering::Relaxed);
+        while wait_ns > prev_max {
+            match self.stats_max_wait_ns.compare_exchange_weak(
+                prev_max,
+                wait_ns,
+                Ordering::Relaxed,
+                Ordering::Relaxed,
+            ) {
+                Ok(_) => break,
+                Err(observed) => prev_max = observed,
+            }
+        }
+        self.world_stopped.store(true, Ordering::Release);
+        #[cfg(debug_assertions)]
+        self.debug_assert_all_non_requester_suspended(vm);
+        stw_trace(format_args!(
+            "stop end requester={requester_ident} wait_ns={wait_ns} polls={polls}"
+        ));
+    }
+
+    /// Resume all suspended threads (`start_the_world`).
+    pub fn start_the_world(&self, vm: &VirtualMachine) {
+        use thread::{THREAD_DETACHED, THREAD_SUSPENDED};
+        let requester = self.requester.load(Ordering::Relaxed);
+        stw_trace(format_args!("start begin requester={requester}"));
+        let registry = vm.state.thread_frames.lock();
+        // Clear the request flag BEFORE waking threads. Otherwise a thread
+        // returning from allow_threads → attach_thread could observe
+        // `requested == true`, re-suspend itself, and stay parked forever.
+        // Keep this write under the registry lock to serialize with new
+        // thread-slot initialization.
+        self.requested.store(false, Ordering::Release);
+        self.world_stopped.store(false, Ordering::Release);
+        for (&id, slot) in registry.iter() {
+            if id == requester {
+                continue;
+            }
+            slot.stop_requested.store(false, Ordering::Release);
+            let state = slot.state.load(Ordering::Relaxed);
+            debug_assert!(
+                state == THREAD_SUSPENDED,
+                "non-requester thread not suspended at start-the-world: id={id} state={state}"
+            );
+            if state == THREAD_SUSPENDED {
+                slot.state.store(THREAD_DETACHED, Ordering::Release);
+                slot.thread.unpark();
+            }
+        }
+        drop(registry);
+        self.thread_countdown.store(0, Ordering::Release);
+        self.requester.store(0, Ordering::Relaxed);
+        #[cfg(debug_assertions)]
+        self.debug_assert_all_non_requester_detached(vm);
+        stw_trace(format_args!("start end requester={requester}"));
+    }
+
+    /// Reset after fork in the child (only one thread alive).
+    pub fn reset_after_fork(&self) {
+        self.requested.store(false, Ordering::Relaxed);
+        self.world_stopped.store(false, Ordering::Relaxed);
+        self.requester.store(0, Ordering::Relaxed);
+        self.thread_countdown.store(0, Ordering::Relaxed);
+        stw_trace(format_args!("reset-after-fork"));
+    }
+
+    #[inline]
+    pub(crate) fn requester_ident(&self) -> u64 {
+        self.requester.load(Ordering::Relaxed)
+    }
+
+    #[inline]
+    pub(crate) fn notify_thread_gone(&self) {
+        let _guard = self.notify_mutex.lock().unwrap();
+        self.decrement_thread_countdown(1);
+        self.notify_cv.notify_one();
+    }
+
+    pub fn stats_snapshot(&self) -> StopTheWorldStats {
+        StopTheWorldStats {
+            stop_calls: self.stats_stop_calls.load(Ordering::Relaxed),
+            last_wait_ns: self.stats_last_wait_ns.load(Ordering::Relaxed),
+            total_wait_ns: self.stats_total_wait_ns.load(Ordering::Relaxed),
+            max_wait_ns: self.stats_max_wait_ns.load(Ordering::Relaxed),
+            poll_loops: self.stats_poll_loops.load(Ordering::Relaxed),
+            attached_seen: self.stats_attached_seen.load(Ordering::Relaxed),
+            forced_parks: self.stats_forced_parks.load(Ordering::Relaxed),
+            suspend_notifications: self.stats_suspend_notifications.load(Ordering::Relaxed),
+            attach_wait_yields: self.stats_attach_wait_yields.load(Ordering::Relaxed),
+            suspend_wait_yields: self.stats_suspend_wait_yields.load(Ordering::Relaxed),
+            world_stopped: self.world_stopped.load(Ordering::Relaxed),
+        }
+    }
+
+    pub fn reset_stats(&self) {
+        self.stats_stop_calls.store(0, Ordering::Relaxed);
+        self.stats_last_wait_ns.store(0, Ordering::Relaxed);
+        self.stats_total_wait_ns.store(0, Ordering::Relaxed);
+        self.stats_max_wait_ns.store(0, Ordering::Relaxed);
+        self.stats_poll_loops.store(0, Ordering::Relaxed);
+        self.stats_attached_seen.store(0, Ordering::Relaxed);
+        self.stats_forced_parks.store(0, Ordering::Relaxed);
+        self.stats_suspend_notifications.store(0, Ordering::Relaxed);
+        self.stats_attach_wait_yields.store(0, Ordering::Relaxed);
+        self.stats_suspend_wait_yields.store(0, Ordering::Relaxed);
+    }
+
+    #[inline]
+    pub(crate) fn add_attach_wait_yields(&self, n: u64) {
+        if n != 0 {
+            self.stats_attach_wait_yields
+                .fetch_add(n, Ordering::Relaxed);
+        }
+    }
+
+    #[inline]
+    pub(crate) fn add_suspend_wait_yields(&self, n: u64) {
+        if n != 0 {
+            self.stats_suspend_wait_yields
+                .fetch_add(n, Ordering::Relaxed);
+        }
+    }
+
+    #[cfg(debug_assertions)]
+    fn debug_assert_all_non_requester_suspended(&self, vm: &VirtualMachine) {
+        use thread::THREAD_SUSPENDED;
+        let requester = self.requester.load(Ordering::Relaxed);
+        let registry = vm.state.thread_frames.lock();
+        for (&id, slot) in registry.iter() {
+            if id == requester {
+                continue;
+            }
+            let state = slot.state.load(Ordering::Relaxed);
+            debug_assert!(
+                state == THREAD_SUSPENDED,
+                "non-requester thread not suspended during stop-the-world: id={id} state={state}"
+            );
+        }
+    }
+
+    #[cfg(debug_assertions)]
+    fn debug_assert_all_non_requester_detached(&self, vm: &VirtualMachine) {
+        use thread::THREAD_SUSPENDED;
+        let requester = self.requester.load(Ordering::Relaxed);
+        let registry = vm.state.thread_frames.lock();
+        for (&id, slot) in registry.iter() {
+            if id == requester {
+                continue;
+            }
+            let state = slot.state.load(Ordering::Relaxed);
+            debug_assert!(
+                state != THREAD_SUSPENDED,
+                "non-requester thread still suspended after start-the-world: id={id} state={state}"
+            );
+        }
+    }
+}
+
+#[cfg(all(unix, feature = "threading"))]
+pub(super) fn stw_trace_enabled() -> bool {
+    static ENABLED: std::sync::OnceLock<bool> = std::sync::OnceLock::new();
+    *ENABLED.get_or_init(|| std::env::var_os("RUSTPYTHON_STW_TRACE").is_some())
+}
+
+#[cfg(all(unix, feature = "threading"))]
+pub(super) fn stw_trace(msg: core::fmt::Arguments<'_>) {
+    if stw_trace_enabled() {
+        use core::fmt::Write as _;
+
+        // Avoid stdio locking here: this path runs around fork where a child
+        // may inherit a borrowed stderr lock and panic on eprintln!/stderr.
+        struct FixedBuf {
+            buf: [u8; 512],
+            len: usize,
+        }
+
+        impl core::fmt::Write for FixedBuf {
+            fn write_str(&mut self, s: &str) -> core::fmt::Result {
+                if self.len >= self.buf.len() {
+                    return Ok(());
+                }
+                let remain = self.buf.len() - self.len;
+                let src = s.as_bytes();
+                let n = src.len().min(remain);
+                self.buf[self.len..self.len + n].copy_from_slice(&src[..n]);
+                self.len += n;
+                Ok(())
+            }
+        }
+
+        let mut out = FixedBuf {
+            buf: [0u8; 512],
+            len: 0,
+        };
+        let _ = writeln!(
+            &mut out,
+            "[rp-stw tid={}] {}",
+            crate::stdlib::_thread::get_ident(),
+            msg
+        );
+        unsafe {
+            let _ = libc::write(libc::STDERR_FILENO, out.buf.as_ptr().cast(), out.len);
+        }
+    }
+}
+
+#[derive(Clone, Debug, Default)]
+pub(crate) struct CallableCache {
+    pub len: Option<PyObjectRef>,
+    pub isinstance: Option<PyObjectRef>,
+    pub list_append: Option<PyObjectRef>,
+    pub builtin_all: Option<PyObjectRef>,
+    pub builtin_any: Option<PyObjectRef>,
 }
 
 pub struct PyGlobalState {
     pub config: PyConfig,
-    pub module_defs: std::collections::BTreeMap<&'static str, &'static builtins::PyModuleDef>,
+    pub module_defs: BTreeMap<&'static str, &'static builtins::PyModuleDef>,
     pub frozen: HashMap<&'static str, FrozenModule, ahash::RandomState>,
     pub stacksize: AtomicCell<usize>,
     pub thread_count: AtomicCell<usize>,
     pub hash_secret: HashSecret,
-    pub atexit_funcs: PyMutex<Vec<(PyObjectRef, FuncArgs)>>,
+    pub atexit_funcs: PyMutex<Vec<Box<(PyObjectRef, FuncArgs)>>>,
     pub codec_registry: CodecsRegistry,
     pub finalizing: AtomicBool,
     pub warnings: WarningsState,
@@ -128,15 +604,25 @@ pub struct PyGlobalState {
     /// 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()
+    /// Registry of all threads' slots for sys._current_frames() and sys._current_exceptions()
     #[cfg(feature = "threading")]
-    pub thread_frames: parking_lot::Mutex<HashMap<u64, stdlib::thread::CurrentFrameSlot>>,
+    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>>,
+    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 shutdown_handles: parking_lot::Mutex<Vec<stdlib::_thread::ShutdownEntry>>,
+    /// sys.monitoring state (tool names, events, callbacks)
+    pub monitoring: PyMutex<stdlib::sys::monitoring::MonitoringState>,
+    /// Fast-path mask: OR of all tools' events. 0 means no monitoring overhead.
+    pub monitoring_events: stdlib::sys::monitoring::MonitoringEventsMask,
+    /// Incremented on every monitoring state change. Code objects compare their
+    /// local version against this to decide whether re-instrumentation is needed.
+    pub instrumentation_version: AtomicU64,
+    /// Stop-the-world state for pre-fork thread suspension
+    #[cfg(all(unix, feature = "threading"))]
+    pub stop_the_world: StopTheWorldState,
 }
 
 pub fn process_hash_secret_seed() -> u32 {
@@ -147,6 +633,70 @@ pub fn process_hash_secret_seed() -> u32 {
 }
 
 impl VirtualMachine {
+    fn init_callable_cache(&mut self) -> PyResult<()> {
+        self.callable_cache.len = Some(self.builtins.get_attr("len", self)?);
+        self.callable_cache.isinstance = Some(self.builtins.get_attr("isinstance", self)?);
+        let list_append = self
+            .ctx
+            .types
+            .list_type
+            .get_attr(self.ctx.intern_str("append"))
+            .ok_or_else(|| self.new_runtime_error("failed to cache list.append".to_owned()))?;
+        self.callable_cache.list_append = Some(list_append);
+        self.callable_cache.builtin_all = Some(self.builtins.get_attr("all", self)?);
+        self.callable_cache.builtin_any = Some(self.builtins.get_attr("any", self)?);
+        Ok(())
+    }
+
+    /// Bump-allocate `size` bytes from the thread data stack.
+    ///
+    /// # Safety
+    /// The returned pointer must be freed by calling `datastack_pop` in LIFO order.
+    #[inline(always)]
+    pub(crate) fn datastack_push(&self, size: usize) -> *mut u8 {
+        unsafe { (*self.datastack.get()).push(size) }
+    }
+
+    /// Check whether the thread data stack currently has room for `size` bytes.
+    #[inline(always)]
+    pub(crate) fn datastack_has_space(&self, size: usize) -> bool {
+        unsafe { (*self.datastack.get()).has_space(size) }
+    }
+
+    /// Pop a previous data stack allocation.
+    ///
+    /// # Safety
+    /// `base` must be a pointer returned by `datastack_push` on this VM,
+    /// and all allocations made after it must already have been popped.
+    #[inline(always)]
+    pub(crate) unsafe fn datastack_pop(&self, base: *mut u8) {
+        unsafe { (*self.datastack.get()).pop(base) }
+    }
+
+    /// Temporarily detach the current thread (ATTACHED → DETACHED) while
+    /// running `f`, then re-attach afterwards.  Allows `stop_the_world` to
+    /// park this thread during blocking syscalls.
+    ///
+    /// Equivalent to CPython's `Py_BEGIN_ALLOW_THREADS` / `Py_END_ALLOW_THREADS`.
+    #[inline]
+    pub fn allow_threads<R>(&self, f: impl FnOnce() -> R) -> R {
+        thread::allow_threads(self, f)
+    }
+
+    /// Check whether the current thread is the main thread.
+    /// Mirrors `_Py_ThreadCanHandleSignals`.
+    #[allow(dead_code)]
+    pub(crate) fn is_main_thread(&self) -> bool {
+        #[cfg(feature = "threading")]
+        {
+            crate::stdlib::_thread::get_ident() == self.state.main_thread_ident.load()
+        }
+        #[cfg(not(feature = "threading"))]
+        {
+            true
+        }
+    }
+
     /// Create a new `VirtualMachine` structure.
     pub(crate) fn new(ctx: PyRc<Context>, state: PyRc<PyGlobalState>) -> Self {
         flame_guard!("new VirtualMachine");
@@ -166,21 +716,21 @@ impl VirtualMachine {
         let sys_module = new_module(stdlib::sys::module_def(&ctx));
 
         let import_func = ctx.none();
+        let importlib = ctx.none();
         let profile_func = RefCell::new(ctx.none());
         let trace_func = RefCell::new(ctx.none());
-        let signal_handlers = Some(Box::new(
-            // putting it in a const optimizes better, prevents linear initialization of the array
-            const { RefCell::new([const { None }; signal::NSIG]) },
-        ));
+        let signal_handlers = OnceCell::from(signal::new_signal_handlers());
 
         let vm = Self {
             builtins,
             sys_module,
             ctx,
             frames: RefCell::new(vec![]),
+            datastack: core::cell::UnsafeCell::new(crate::datastack::DataStack::new()),
             wasm_id: None,
             exceptions: RefCell::default(),
             import_func,
+            importlib,
             profile_func,
             trace_func,
             use_tracing: Cell::new(false),
@@ -196,6 +746,7 @@ impl VirtualMachine {
             async_gen_finalizer: RefCell::new(None),
             asyncio_running_loop: RefCell::new(None),
             asyncio_running_task: RefCell::new(None),
+            callable_cache: CallableCache::default(),
         };
 
         if vm.state.hash_secret.hash_str("")
@@ -263,7 +814,9 @@ impl VirtualMachine {
     }
 
     fn import_ascii_utf8_encodings(&mut self) -> PyResult<()> {
-        import::import_frozen(self, "codecs")?;
+        // Use the Python import machinery (FrozenImporter) so modules get
+        // proper __spec__ and __loader__ attributes.
+        self.import("codecs", 0)?;
 
         // Use dotted names when freeze-stdlib is enabled (modules come from Lib/encodings/),
         // otherwise use underscored names (modules come from core_modules/).
@@ -274,20 +827,45 @@ impl VirtualMachine {
         };
 
         // Register ascii encoding
-        let ascii_module = import::import_frozen(self, ascii_module_name)?;
+        // __import__("encodings.ascii") returns top-level "encodings", so
+        // look up the actual submodule in sys.modules.
+        self.import(ascii_module_name, 0)?;
+        let sys_modules = self.sys_module.get_attr(identifier!(self, modules), self)?;
+        let ascii_module = sys_modules.get_item(ascii_module_name, self)?;
         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)?;
+        // Register utf-8 encoding (also as "utf8" alias since normalize_encoding_name
+        // maps "utf-8" → "utf_8" but leaves "utf8" as-is)
+        self.import(utf8_module_name, 0)?;
+        let utf8_module = sys_modules.get_item(utf8_module_name, self)?;
         let getregentry = utf8_module.get_attr("getregentry", self)?;
         let codec_info = getregentry.call((), self)?;
+        let utf8_codec: crate::codecs::PyCodec = codec_info.try_into_value(self)?;
+        self.state
+            .codec_registry
+            .register_manual("utf-8", utf8_codec.clone())?;
         self.state
             .codec_registry
-            .register_manual("utf-8", codec_info.try_into_value(self)?)?;
+            .register_manual("utf8", utf8_codec)?;
+
+        // Register latin-1 / iso8859-1 aliases needed very early for stdio
+        // bootstrap (e.g. PYTHONIOENCODING=latin-1).
+        if cfg!(feature = "freeze-stdlib") {
+            self.import("encodings.latin_1", 0)?;
+            let latin1_module = sys_modules.get_item("encodings.latin_1", self)?;
+            let getregentry = latin1_module.get_attr("getregentry", self)?;
+            let codec_info = getregentry.call((), self)?;
+            let latin1_codec: crate::codecs::PyCodec = codec_info.try_into_value(self)?;
+            for name in ["latin-1", "latin_1", "latin1", "iso8859-1", "iso8859_1"] {
+                self.state
+                    .codec_registry
+                    .register_manual(name, latin1_codec.clone())?;
+            }
+        }
         Ok(())
     }
 
@@ -300,14 +878,20 @@ impl VirtualMachine {
 
         // Initialize main thread ident before any threading operations
         #[cfg(feature = "threading")]
-        stdlib::thread::init_main_thread_ident(self);
+        stdlib::_thread::init_main_thread_ident(self);
 
         stdlib::builtins::init_module(self, &self.builtins);
+        let callable_cache_init = self.init_callable_cache();
+        self.expect_pyresult(callable_cache_init, "failed to initialize callable cache");
         stdlib::sys::init_module(self, &self.sys_module, &self.builtins);
+        self.expect_pyresult(
+            stdlib::sys::set_bootstrap_stderr(self),
+            "failed to initialize bootstrap stderr",
+        );
 
         let mut essential_init = || -> PyResult {
             import::import_builtin(self, "_typing")?;
-            #[cfg(not(target_arch = "wasm32"))]
+            #[cfg(all(not(target_arch = "wasm32"), feature = "host_env"))]
             import::import_builtin(self, "_signal")?;
             #[cfg(any(feature = "parser", feature = "compiler"))]
             import::import_builtin(self, "_ast")?;
@@ -316,18 +900,20 @@ impl VirtualMachine {
             let importlib = import::init_importlib_base(self)?;
             self.import_ascii_utf8_encodings()?;
 
-            #[cfg(any(not(target_arch = "wasm32"), target_os = "wasi"))]
             {
                 let io = import::import_builtin(self, "_io")?;
-                #[cfg(feature = "stdio")]
-                let make_stdio = |name, fd, write| {
+
+                // Full stdio: FileIO → BufferedWriter → TextIOWrapper
+                #[cfg(all(feature = "host_env", feature = "stdio"))]
+                let make_stdio = |name: &str, fd: i32, write: bool| -> PyResult<PyObjectRef> {
                     let buffered_stdio = self.state.config.settings.buffered_stdio;
                     let unbuffered = write && !buffered_stdio;
-                    let buf = crate::stdlib::io::open(
+                    let buf = crate::stdlib::_io::open(
                         self.ctx.new_int(fd).into(),
                         Some(if write { "wb" } else { "rb" }),
-                        crate::stdlib::io::OpenArgs {
+                        crate::stdlib::_io::OpenArgs {
                             buffering: if unbuffered { 0 } else { -1 },
+                            closefd: false,
                             ..Default::default()
                         },
                         self,
@@ -348,7 +934,13 @@ impl VirtualMachine {
                     let errors = if fd == 2 {
                         Some("backslashreplace")
                     } else {
-                        self.state.config.settings.stdio_errors.as_deref()
+                        self.state.config.settings.stdio_errors.as_deref().or(
+                            if self.state.config.settings.stdio_encoding.is_some() {
+                                Some("strict")
+                            } else {
+                                Some("surrogateescape")
+                            },
+                        )
                     };
 
                     let stdio = self.call_method(
@@ -365,14 +957,30 @@ impl VirtualMachine {
                     )?;
                     let mode = if write { "w" } else { "r" };
                     stdio.set_attr("mode", self.ctx.new_str(mode), self)?;
-                    Ok(stdio)
+                    Ok::<_, self::PyBaseExceptionRef>(stdio)
+                };
+
+                // Sandbox stdio: lightweight wrapper using Rust's std::io directly
+                #[cfg(all(not(feature = "host_env"), feature = "stdio"))]
+                let make_stdio = |name: &str, fd: i32, write: bool| {
+                    let mode = if write { "w" } else { "r" };
+                    let stdio = stdlib::sys::SandboxStdio {
+                        fd,
+                        name: format!("<{name}>"),
+                        mode: mode.to_owned(),
+                    }
+                    .into_ref(&self.ctx);
+                    Ok(stdio.into())
                 };
+
+                // No stdio: set to None (embedding use case)
                 #[cfg(not(feature = "stdio"))]
-                let make_stdio =
-                    |_name, _fd, _write| Ok(crate::builtins::PyNone.into_pyobject(self));
+                let make_stdio = |_name: &str, _fd: i32, _write: bool| {
+                    Ok(crate::builtins::PyNone.into_pyobject(self))
+                };
 
                 let set_stdio = |name, fd, write| {
-                    let stdio = make_stdio(name, fd, write)?;
+                    let stdio: PyObjectRef = make_stdio(name, fd, write)?;
                     let dunder_name = self.ctx.intern_str(format!("__{name}__"));
                     self.sys_module.set_attr(
                         dunder_name, // e.g. __stdin__
@@ -396,6 +1004,7 @@ impl VirtualMachine {
         let res = essential_init();
         let importlib = self.expect_pyresult(res, "essential initialization failed");
 
+        #[cfg(feature = "host_env")]
         if self.state.config.settings.allow_external_library
             && cfg!(feature = "rustpython-compiler")
             && let Err(e) = import::init_importlib_package(self, importlib)
@@ -406,6 +1015,9 @@ impl VirtualMachine {
             self.print_exception(e);
         }
 
+        #[cfg(not(feature = "host_env"))]
+        let _ = importlib;
+
         let _expect_stdlib = cfg!(feature = "freeze-stdlib")
             || !self.state.config.paths.module_search_paths.is_empty();
 
@@ -472,14 +1084,29 @@ impl VirtualMachine {
     }
 
     pub fn run_code_obj(&self, code: PyRef<PyCode>, scope: Scope) -> PyResult {
-        use crate::builtins::PyFunction;
+        use crate::builtins::{PyFunction, PyModule};
 
         // Create a function object for module code, similar to CPython's PyEval_EvalCode
         let func = PyFunction::new(code.clone(), scope.globals.clone(), self)?;
         let func_obj = func.into_ref(&self.ctx).into();
 
-        let frame = Frame::new(code, scope, self.builtins.dict(), &[], Some(func_obj), self)
-            .into_ref(&self.ctx);
+        // Extract builtins from globals["__builtins__"], like PyEval_EvalCode
+        let builtins = match scope
+            .globals
+            .get_item_opt(identifier!(self, __builtins__), self)?
+        {
+            Some(b) => {
+                if let Some(module) = b.downcast_ref::<PyModule>() {
+                    module.dict().into()
+                } else {
+                    b
+                }
+            }
+            None => self.builtins.dict().into(),
+        };
+
+        let frame =
+            Frame::new(code, scope, builtins, &[], Some(func_obj), false, self).into_ref(&self.ctx);
         self.run_frame(frame)
     }
 
@@ -488,11 +1115,7 @@ impl VirtualMachine {
         // 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)
-        {
+        if self.state.finalizing.load(Ordering::Acquire) {
             self.write_unraisable_to_stderr(&e, msg.as_deref(), &object);
             return;
         }
@@ -534,31 +1157,28 @@ impl VirtualMachine {
             }
         };
 
-        // Format: "Exception ignored {msg} {object_repr}\n"
-        if let Some(msg) = msg {
-            write_to_stderr(&format!("Exception ignored {}", msg), &stderr, self);
+        let msg_str = if let Some(msg) = msg {
+            format!("{msg}: ")
         } else {
-            write_to_stderr("Exception ignored in: ", &stderr, self);
-        }
+            "Exception ignored in: ".to_owned()
+        };
+        write_to_stderr(&msg_str, &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);
-        }
+        let repr_result = object.repr(self);
+        let repr_wtf8 = repr_result
+            .as_ref()
+            .map_or("<object repr failed>".as_ref(), |s| s.as_wtf8());
+        write_to_stderr(&format!("{repr_wtf8}\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);
+        let msg = match e.as_object().str(self) {
+            Ok(exc_str) if !exc_str.as_wtf8().is_empty() => {
+                format!("{}: {}\n", exc_type_name, exc_str.as_wtf8())
             }
-        } else {
-            write_to_stderr(&format!("{}\n", exc_type_name), &stderr, self);
-        }
+            _ => format!("{}\n", exc_type_name),
+        };
+        write_to_stderr(&msg, &stderr, self);
 
         // Flush stderr to ensure output is visible
         if let Some(ref stderr) = stderr {
@@ -620,17 +1240,196 @@ impl VirtualMachine {
         }
     }
 
+    /// Clear module references during shutdown.
+    /// Follows the same phased algorithm as pylifecycle.c finalize_modules():
+    /// no hardcoded module names, reverse import order, only builtins/sys last.
+    pub fn finalize_modules(&self) {
+        // Phase 1: Set special sys/builtins attributes to None, restore stdio
+        self.finalize_modules_delete_special();
+
+        // Phase 2: Remove all modules from sys.modules (set values to None),
+        // and collect weakrefs to modules preserving import order.
+        // No strong refs are kept — modules freed when their last ref drops.
+        let module_weakrefs = self.finalize_remove_modules();
+
+        // Phase 3: Clear sys.modules dict
+        self.finalize_clear_modules_dict();
+
+        // Phase 4: GC collect — modules removed from sys.modules are freed,
+        // exposing cycles (e.g., dict ↔ function.__globals__). GC collects
+        // these and calls __del__ while module dicts are still intact.
+        crate::gc_state::gc_state().collect_force(2);
+
+        // Phase 5: Clear module dicts in reverse import order using 2-pass algorithm.
+        // Skip builtins and sys — those are cleared last.
+        self.finalize_clear_module_dicts(&module_weakrefs);
+
+        // Phase 6: GC collect — pick up anything freed by dict clearing.
+        crate::gc_state::gc_state().collect_force(2);
+
+        // Phase 7: Clear sys and builtins dicts last
+        self.finalize_clear_sys_builtins_dict();
+    }
+
+    /// Phase 1: Set special sys attributes to None and restore stdio.
+    fn finalize_modules_delete_special(&self) {
+        let none = self.ctx.none();
+        let sys_dict = self.sys_module.dict();
+
+        // Set special sys attributes to None
+        for attr in &[
+            "path",
+            "argv",
+            "ps1",
+            "ps2",
+            "last_exc",
+            "last_type",
+            "last_value",
+            "last_traceback",
+            "path_importer_cache",
+            "meta_path",
+            "path_hooks",
+        ] {
+            let _ = sys_dict.set_item(*attr, none.clone(), self);
+        }
+
+        // Restore stdin/stdout/stderr from __stdin__/__stdout__/__stderr__
+        for (std_name, dunder_name) in &[
+            ("stdin", "__stdin__"),
+            ("stdout", "__stdout__"),
+            ("stderr", "__stderr__"),
+        ] {
+            let restored = sys_dict
+                .get_item_opt(*dunder_name, self)
+                .ok()
+                .flatten()
+                .unwrap_or_else(|| none.clone());
+            let _ = sys_dict.set_item(*std_name, restored, self);
+        }
+
+        // builtins._ = None
+        let _ = self.builtins.dict().set_item("_", none, self);
+    }
+
+    /// Phase 2: Set all sys.modules values to None and collect weakrefs.
+    /// No strong refs are kept — modules are freed when removed from sys.modules
+    /// (if nothing else references them), allowing GC to collect their cycles.
+    fn finalize_remove_modules(&self) -> Vec<(String, PyRef<PyWeak>)> {
+        let mut module_weakrefs = Vec::new();
+
+        let Ok(modules) = self.sys_module.get_attr(identifier!(self, modules), self) else {
+            return module_weakrefs;
+        };
+        let Some(modules_dict) = modules.downcast_ref::<PyDict>() else {
+            return module_weakrefs;
+        };
+
+        let none = self.ctx.none();
+        let items: Vec<_> = modules_dict.into_iter().collect();
+
+        for (key, value) in items {
+            let name = key
+                .downcast_ref::<PyUtf8Str>()
+                .map(|s| s.as_str().to_owned())
+                .unwrap_or_default();
+
+            // Save weakref to module (for later dict clearing)
+            if value.downcast_ref::<PyModule>().is_some()
+                && let Ok(weak) = value.downgrade(None, self)
+            {
+                module_weakrefs.push((name, weak));
+            }
+
+            // Set the value to None in sys.modules
+            let _ = modules_dict.set_item(&*key, none.clone(), self);
+        }
+
+        module_weakrefs
+    }
+
+    /// Phase 3: Clear sys.modules dict.
+    fn finalize_clear_modules_dict(&self) {
+        if let Ok(modules) = self.sys_module.get_attr(identifier!(self, modules), self)
+            && let Some(modules_dict) = modules.downcast_ref::<PyDict>()
+        {
+            modules_dict.clear();
+        }
+    }
+
+    /// Phase 5: Clear module dicts in reverse import order.
+    /// Skip builtins and sys — those are cleared last in Phase 7.
+    fn finalize_clear_module_dicts(&self, module_weakrefs: &[(String, PyRef<PyWeak>)]) {
+        let builtins_dict = self.builtins.dict();
+        let sys_dict = self.sys_module.dict();
+
+        for (_name, weakref) in module_weakrefs.iter().rev() {
+            let Some(module_obj) = weakref.upgrade() else {
+                continue;
+            };
+            let Some(module) = module_obj.downcast_ref::<PyModule>() else {
+                continue;
+            };
+
+            let dict = module.dict();
+            // Skip builtins and sys — they are cleared last
+            if dict.is(&builtins_dict) || dict.is(&sys_dict) {
+                continue;
+            }
+
+            Self::module_clear_dict(&dict, self);
+        }
+    }
+
+    /// 2-pass module dict clearing (_PyModule_ClearDict algorithm).
+    /// Pass 1: Set names starting with '_' (except __builtins__) to None.
+    /// Pass 2: Set all remaining names (except __builtins__) to None.
+    pub(crate) fn module_clear_dict(dict: &Py<PyDict>, vm: &VirtualMachine) {
+        let none = vm.ctx.none();
+
+        // Pass 1: names starting with '_' (except __builtins__)
+        for (key, value) in dict.into_iter().collect::<Vec<_>>() {
+            if vm.is_none(&value) {
+                continue;
+            }
+            if let Some(key_str) = key.downcast_ref::<PyStr>() {
+                let name = key_str.as_wtf8();
+                if name.starts_with("_") && name != "__builtins__" {
+                    let _ = dict.set_item(key_str, none.clone(), vm);
+                }
+            }
+        }
+
+        // Pass 2: all remaining (except __builtins__)
+        for (key, value) in dict.into_iter().collect::<Vec<_>>() {
+            if vm.is_none(&value) {
+                continue;
+            }
+            if let Some(key_str) = key.downcast_ref::<PyStr>()
+                && key_str.as_bytes() != b"__builtins__"
+            {
+                let _ = dict.set_item(key_str.as_wtf8(), none.clone(), vm);
+            }
+        }
+    }
+
+    /// Phase 7: Clear sys and builtins dicts last.
+    fn finalize_clear_sys_builtins_dict(&self) {
+        Self::module_clear_dict(&self.sys_module.dict(), self);
+        Self::module_clear_dict(&self.builtins.dict(), self);
+    }
+
     pub fn current_recursion_depth(&self) -> usize {
         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>();
+    #[cfg_attr(any(miri, target_env = "musl"), allow(dead_code))]
+    const STACK_MARGIN_BYTES: usize = 2048 * core::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))]
+    #[cfg(all(not(miri), not(target_env = "musl"), windows))]
     fn get_stack_bounds() -> (usize, usize) {
         use windows_sys::Win32::System::Threading::{
             GetCurrentThreadStackLimits, SetThreadStackGuarantee,
@@ -649,7 +1448,7 @@ impl VirtualMachine {
 
     /// Get stack boundaries on non-Windows platforms.
     /// Falls back to estimating based on current stack pointer.
-    #[cfg(all(not(miri), not(windows)))]
+    #[cfg(all(not(miri), not(target_env = "musl"), 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"))]
@@ -658,10 +1457,10 @@ impl VirtualMachine {
                 pthread_attr_destroy, pthread_attr_getstack, pthread_attr_t, pthread_getattr_np,
                 pthread_self,
             };
-            let mut attr: pthread_attr_t = unsafe { std::mem::zeroed() };
+            let mut attr: pthread_attr_t = unsafe { core::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_addr: *mut libc::c_void = core::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);
@@ -700,15 +1499,16 @@ impl VirtualMachine {
 
     /// Calculate the C stack soft limit based on actual stack boundaries.
     /// soft_limit = base + 2 * margin (for downward-growing stacks)
-    #[cfg(not(miri))]
+    #[cfg(all(not(miri), not(target_env = "musl")))]
     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)]
+    /// Musl currently reports stack bounds in a way that trips the VM's
+    /// native stack guard during frozen stdlib bootstrap, so keep the Python
+    /// recursion limit as the only guard there.
+    #[cfg(any(miri, target_env = "musl"))]
     fn calculate_c_stack_soft_limit() -> usize {
         0
     }
@@ -716,19 +1516,18 @@ impl VirtualMachine {
     /// 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))]
+    #[cfg(all(not(miri), not(target_env = "musl")))]
     #[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)]
+    /// Miri does not support the native stack probe, and musl currently trips
+    /// the probe during stdlib bootstrap.
+    #[cfg(any(miri, target_env = "musl"))]
     #[inline(always)]
     fn check_c_stack_overflow(&self) -> bool {
         false
@@ -745,38 +1544,175 @@ impl VirtualMachine {
             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);
-        result
+        self.recursion_depth.update(|d| d + 1);
+        scopeguard::defer! { self.recursion_depth.update(|d| d - 1) }
+        f()
     }
 
     pub fn with_frame<R, F: FnOnce(FrameRef) -> PyResult<R>>(
         &self,
         frame: FrameRef,
         f: F,
+    ) -> PyResult<R> {
+        self.with_frame_impl(frame, None, true, f)
+    }
+
+    /// Like `with_frame` but allows specifying the initial exception state.
+    pub fn with_frame_exc<R, F: FnOnce(FrameRef) -> PyResult<R>>(
+        &self,
+        frame: FrameRef,
+        exc: Option<PyBaseExceptionRef>,
+        f: F,
+    ) -> PyResult<R> {
+        self.with_frame_impl(frame, exc, true, f)
+    }
+
+    pub(crate) fn with_frame_untraced<R, F: FnOnce(FrameRef) -> PyResult<R>>(
+        &self,
+        frame: FrameRef,
+        f: F,
+    ) -> PyResult<R> {
+        self.with_frame_impl(frame, None, false, f)
+    }
+
+    fn with_frame_impl<R, F: FnOnce(FrameRef) -> PyResult<R>>(
+        &self,
+        frame: FrameRef,
+        exc: Option<PyBaseExceptionRef>,
+        traced: bool,
+        f: F,
     ) -> PyResult<R> {
         self.with_recursion("", || {
-            self.frames.borrow_mut().push(frame.clone());
-            // Update the current frame slot for sys._current_frames()
+            // SAFETY: `frame` (FrameRef) stays alive for the entire closure scope,
+            // keeping the FramePtr valid. We pass a clone to `f` so that `f`
+            // consuming its FrameRef doesn't invalidate our pointer.
+            let fp = FramePtr(NonNull::from(&*frame));
+            self.frames.borrow_mut().push(fp);
+            // Update the shared frame stack for sys._current_frames() and faulthandler
             #[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
-            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();
-            // 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
+            crate::vm::thread::push_thread_frame(fp);
+            // Link frame into the signal-safe frame chain (previous pointer)
+            let old_frame = crate::vm::thread::set_current_frame((&**frame) as *const Frame);
+            frame.previous.store(
+                old_frame as *mut Frame,
+                core::sync::atomic::Ordering::Relaxed,
+            );
+            // Push exception context for frame isolation.
+            // For normal calls: None (clean slate).
+            // For generators: the saved exception from last yield.
+            self.push_exception(exc);
+            let old_owner = frame.owner.swap(
+                crate::frame::FrameOwner::Thread as i8,
+                core::sync::atomic::Ordering::AcqRel,
+            );
+
+            // Ensure cleanup on panic: restore owner, pop exception, frame chain, and frames Vec.
+            scopeguard::defer! {
+                frame.owner.store(old_owner, core::sync::atomic::Ordering::Release);
+                self.pop_exception();
+                crate::vm::thread::set_current_frame(old_frame);
+                self.frames.borrow_mut().pop();
+                #[cfg(feature = "threading")]
+                crate::vm::thread::pop_thread_frame();
+            }
+
+            if traced {
+                self.dispatch_traced_frame(&frame, |frame| f(frame.to_owned()))
+            } else {
+                f(frame.to_owned())
+            }
         })
     }
 
+    /// Lightweight frame execution for generator/coroutine resume.
+    /// Pushes to the thread frame stack and fires trace/profile events,
+    /// but skips the thread exception update for performance.
+    pub fn resume_gen_frame<R, F: FnOnce(&Py<Frame>) -> PyResult<R>>(
+        &self,
+        frame: &FrameRef,
+        exc: Option<PyBaseExceptionRef>,
+        f: F,
+    ) -> PyResult<R> {
+        self.check_recursive_call("")?;
+        if self.check_c_stack_overflow() {
+            return Err(self.new_recursion_error(String::new()));
+        }
+        self.recursion_depth.update(|d| d + 1);
+
+        // SAFETY: frame (&FrameRef) stays alive for the duration, so NonNull is valid until pop.
+        let fp = FramePtr(NonNull::from(&**frame));
+        self.frames.borrow_mut().push(fp);
+        #[cfg(feature = "threading")]
+        crate::vm::thread::push_thread_frame(fp);
+        let old_frame = crate::vm::thread::set_current_frame((&***frame) as *const Frame);
+        frame.previous.store(
+            old_frame as *mut Frame,
+            core::sync::atomic::Ordering::Relaxed,
+        );
+        // Inline exception push without thread exception update
+        self.exceptions.borrow_mut().stack.push(exc);
+        let old_owner = frame.owner.swap(
+            crate::frame::FrameOwner::Thread as i8,
+            core::sync::atomic::Ordering::AcqRel,
+        );
+
+        // Ensure cleanup on panic: restore owner, pop exception, frame chain, frames Vec,
+        // and recursion depth.
+        scopeguard::defer! {
+            frame.owner.store(old_owner, core::sync::atomic::Ordering::Release);
+            self.exceptions.borrow_mut().stack
+                .pop()
+                .expect("pop_exception() without nested exc stack");
+            crate::vm::thread::set_current_frame(old_frame);
+            self.frames.borrow_mut().pop();
+            #[cfg(feature = "threading")]
+            crate::vm::thread::pop_thread_frame();
+
+            self.recursion_depth.update(|d| d - 1);
+        }
+
+        self.dispatch_traced_frame(frame, |frame| f(frame))
+    }
+
+    /// Fire trace/profile 'call' and 'return' events around a frame body.
+    ///
+    /// Matches `call_trace_protected` / `trace_trampoline` protocol:
+    /// - Fire `TraceEvent::Call`; if the trace function returns non-None,
+    ///   install it as the per-frame `f_trace`.
+    /// - Execute the closure (the actual frame body).
+    /// - Fire `TraceEvent::Return` on both normal return **and** exception
+    ///   unwind (`PY_UNWIND` → `PyTrace_RETURN` with `arg = None`).
+    ///   Propagate any trace-function error, replacing the original exception.
+    fn dispatch_traced_frame<R, F: FnOnce(&Py<Frame>) -> PyResult<R>>(
+        &self,
+        frame: &Py<Frame>,
+        f: F,
+    ) -> PyResult<R> {
+        use crate::protocol::TraceEvent;
+
+        // Fire 'call' trace event. current_frame() now returns the callee.
+        let trace_result = self.trace_event(TraceEvent::Call, None)?;
+        if let Some(local_trace) = trace_result {
+            *frame.trace.lock() = local_trace;
+        }
+
+        let result = f(frame);
+
+        // Fire 'return' event if frame is being traced or profiled.
+        // PY_UNWIND fires PyTrace_RETURN with arg=None — so we fire for
+        // both Ok and Err, matching `call_trace_protected` behavior.
+        if self.use_tracing.get()
+            && (!self.is_none(&frame.trace.lock()) || !self.is_none(&self.profile_func.borrow()))
+        {
+            let ret_result = self.trace_event(TraceEvent::Return, None);
+            // call_trace_protected: if trace function raises, its error
+            // replaces the original exception.
+            ret_result?;
+        }
+
+        result
+    }
+
     /// Returns a basic CompileOpts instance with options accurate to the vm. Used
     /// as the CompileOpts for `vm.compile()`.
     #[cfg(feature = "rustpython-codegen")]
@@ -796,15 +1732,11 @@ impl VirtualMachine {
         }
     }
 
-    pub fn current_frame(&self) -> Option<Ref<'_, FrameRef>> {
-        let frames = self.frames.borrow();
-        if frames.is_empty() {
-            None
-        } else {
-            Some(Ref::map(self.frames.borrow(), |frames| {
-                frames.last().unwrap()
-            }))
-        }
+    pub fn current_frame(&self) -> Option<FrameRef> {
+        self.frames.borrow().last().map(|fp| {
+            // SAFETY: the caller keeps the FrameRef alive while it's in the Vec
+            unsafe { fp.as_ref() }.to_owned()
+        })
     }
 
     pub fn current_locals(&self) -> PyResult<ArgMapping> {
@@ -813,11 +1745,11 @@ impl VirtualMachine {
             .locals(self)
     }
 
-    pub fn current_globals(&self) -> Ref<'_, PyDictRef> {
-        let frame = self
-            .current_frame()
-            .expect("called current_globals but no frames on the stack");
-        Ref::map(frame, |f| &f.globals)
+    pub fn current_globals(&self) -> PyDictRef {
+        self.current_frame()
+            .expect("called current_globals but no frames on the stack")
+            .globals
+            .clone()
     }
 
     pub fn try_class(&self, module: &'static str, class: &'static str) -> PyResult<PyTypeRef> {
@@ -871,54 +1803,32 @@ impl VirtualMachine {
         from_list: &Py<PyTuple<PyStrRef>>,
         level: usize,
     ) -> PyResult {
-        // if the import inputs seem weird, e.g a package import or something, rather than just
-        // a straight `import ident`
-        let weird = module.as_str().contains('.') || level != 0 || !from_list.is_empty();
-
-        let cached_module = if weird {
-            None
+        let import_func = self
+            .builtins
+            .get_attr(identifier!(self, __import__), self)
+            .map_err(|_| self.new_import_error("__import__ not found", module.to_owned()))?;
+
+        let (locals, globals) = if let Some(frame) = self.current_frame() {
+            (
+                Some(frame.locals.clone_mapping(self)),
+                Some(frame.globals.clone()),
+            )
         } else {
-            let sys_modules = self.sys_module.get_attr("modules", self)?;
-            sys_modules.get_item(module, self).ok()
+            (None, None)
         };
-
-        match cached_module {
-            Some(cached_module) => {
-                if self.is_none(&cached_module) {
-                    Err(self.new_import_error(
-                        format!("import of {module} halted; None in sys.modules"),
-                        module.to_owned(),
-                    ))
-                } else {
-                    Ok(cached_module)
-                }
-            }
-            None => {
-                let import_func = self
-                    .builtins
-                    .get_attr(identifier!(self, __import__), self)
-                    .map_err(|_| {
-                        self.new_import_error("__import__ not found", module.to_owned())
-                    })?;
-
-                let (locals, globals) = if let Some(frame) = self.current_frame() {
-                    (Some(frame.locals.clone()), Some(frame.globals.clone()))
-                } else {
-                    (None, None)
-                };
-                let from_list: PyObjectRef = from_list.to_owned().into();
-                import_func
-                    .call((module.to_owned(), globals, locals, from_list, level), self)
-                    .inspect_err(|exc| import::remove_importlib_frames(self, exc))
-            }
-        }
+        let from_list: PyObjectRef = from_list.to_owned().into();
+        import_func
+            .call((module.to_owned(), globals, locals, from_list, level), self)
+            .inspect_err(|exc| import::remove_importlib_frames(self, exc))
     }
 
     pub fn extract_elements_with<T, F>(&self, value: &PyObject, func: F) -> PyResult<Vec<T>>
     where
         F: Fn(PyObjectRef) -> PyResult<T>,
     {
-        // Extract elements from item, if possible:
+        // Type-specific fast paths corresponding to _list_extend() in CPython
+        // Objects/listobject.c. Each branch takes an atomic snapshot to avoid
+        // race conditions from concurrent mutation (no GIL).
         let cls = value.class();
         let list_borrow;
         let slice = if cls.is(self.ctx.types.tuple_type) {
@@ -926,12 +1836,13 @@ 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_type) {
+            let keys = value.downcast_ref::<PyDict>().unwrap().keys_vec();
+            return keys.into_iter().map(func).collect();
         } 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()
@@ -939,7 +1850,6 @@ impl VirtualMachine {
                 .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()
@@ -1036,6 +1946,14 @@ impl VirtualMachine {
     ) {
         if exc.class().is(self.ctx.exceptions.attribute_error) {
             let exc = exc.as_object();
+            // Check if this exception was already augmented
+            let already_set = exc
+                .get_attr("name", self)
+                .ok()
+                .is_some_and(|v| !self.is_none(&v));
+            if already_set {
+                return;
+            }
             exc.set_attr("name", name, self).unwrap();
             exc.set_attr("obj", obj, self).unwrap();
         }
@@ -1074,10 +1992,41 @@ impl VirtualMachine {
         self.get_method(obj, method_name)
     }
 
+    #[inline]
+    pub(crate) fn eval_breaker_tripped(&self) -> bool {
+        #[cfg(feature = "threading")]
+        if self.state.finalizing.load(Ordering::Relaxed) && !self.is_main_thread() {
+            return true;
+        }
+
+        #[cfg(all(unix, feature = "threading"))]
+        if thread::stop_requested_for_current_thread() {
+            return true;
+        }
+
+        #[cfg(not(target_arch = "wasm32"))]
+        if crate::signal::is_triggered() {
+            return true;
+        }
+
+        false
+    }
+
     #[inline]
     /// Checks for triggered signals and calls the appropriate handlers. A no-op on
     /// platforms where signals are not supported.
     pub fn check_signals(&self) -> PyResult<()> {
+        #[cfg(feature = "threading")]
+        if self.state.finalizing.load(Ordering::Acquire) && !self.is_main_thread() {
+            // once finalization starts,
+            // non-main Python threads should stop running bytecode.
+            return Err(self.new_exception(self.ctx.exceptions.system_exit.to_owned(), vec![]));
+        }
+
+        // Suspend this thread if stop-the-world is in progress
+        #[cfg(all(unix, feature = "threading"))]
+        thread::suspend_if_needed(&self.state.stop_the_world);
+
         #[cfg(not(target_arch = "wasm32"))]
         {
             crate::signal::check_signals(self)
@@ -1089,27 +2038,44 @@ impl VirtualMachine {
     }
 
     pub(crate) fn push_exception(&self, exc: Option<PyBaseExceptionRef>) {
-        let mut excs = self.exceptions.borrow_mut();
-        let prev = core::mem::take(&mut *excs);
-        excs.prev = Some(Box::new(prev));
-        excs.exc = exc
+        self.exceptions.borrow_mut().stack.push(exc);
+        #[cfg(feature = "threading")]
+        thread::update_thread_exception(self.topmost_exception());
     }
 
     pub(crate) fn pop_exception(&self) -> Option<PyBaseExceptionRef> {
-        let mut excs = self.exceptions.borrow_mut();
-        let cur = core::mem::take(&mut *excs);
-        *excs = *cur.prev.expect("pop_exception() without nested exc stack");
-        cur.exc
+        let exc = self
+            .exceptions
+            .borrow_mut()
+            .stack
+            .pop()
+            .expect("pop_exception() without nested exc stack");
+        #[cfg(feature = "threading")]
+        thread::update_thread_exception(self.topmost_exception());
+        exc
     }
 
     pub(crate) fn current_exception(&self) -> Option<PyBaseExceptionRef> {
-        self.exceptions.borrow().exc.clone()
+        self.exceptions.borrow().stack.last().cloned().flatten()
     }
 
     pub(crate) fn set_exception(&self, exc: Option<PyBaseExceptionRef>) {
         // don't be holding the RefCell guard while __del__ is called
-        let prev = core::mem::replace(&mut self.exceptions.borrow_mut().exc, exc);
-        drop(prev);
+        let mut excs = self.exceptions.borrow_mut();
+        debug_assert!(
+            !excs.stack.is_empty(),
+            "set_exception called with empty exception stack"
+        );
+        if let Some(top) = excs.stack.last_mut() {
+            let prev = core::mem::replace(top, exc);
+            drop(excs);
+            drop(prev);
+        } else {
+            excs.stack.push(exc);
+            drop(excs);
+        }
+        #[cfg(feature = "threading")]
+        thread::update_thread_exception(self.topmost_exception());
     }
 
     pub(crate) fn contextualize_exception(&self, exception: &Py<PyBaseException>) {
@@ -1142,13 +2108,7 @@ impl VirtualMachine {
 
     pub(crate) fn topmost_exception(&self) -> Option<PyBaseExceptionRef> {
         let excs = self.exceptions.borrow();
-        let mut cur = &*excs;
-        loop {
-            if let Some(exc) = &cur.exc {
-                return Some(exc.clone());
-            }
-            cur = cur.prev.as_deref()?;
-        }
+        excs.stack.iter().rev().find_map(|e| e.clone())
     }
 
     pub fn handle_exit_exception(&self, exc: PyBaseExceptionRef) -> u32 {
@@ -1250,11 +2210,11 @@ impl VirtualMachine {
         identifier!(self, utf_8)
     }
 
-    pub fn fs_encode_errors(&self) -> &'static PyStrInterned {
+    pub fn fs_encode_errors(&self) -> &'static PyUtf8StrInterned {
         if cfg!(windows) {
-            identifier!(self, surrogatepass)
+            identifier_utf8!(self, surrogatepass)
         } else {
-            identifier!(self, surrogateescape)
+            identifier_utf8!(self, surrogateescape)
         }
     }
 
@@ -1309,6 +2269,10 @@ pub fn resolve_frozen_alias(name: &str) -> &str {
         "_frozen_importlib_external" => "importlib._bootstrap_external",
         "encodings_ascii" => "encodings.ascii",
         "encodings_utf_8" => "encodings.utf_8",
+        "__hello_alias__" | "__phello_alias__" | "__phello_alias__.spam" => "__hello__",
+        "__phello__.__init__" => "<__phello__",
+        "__phello__.ham.__init__" => "<__phello__.ham",
+        "__hello_only__" => "",
         _ => name,
     }
 }
@@ -1319,7 +2283,7 @@ fn test_nested_frozen() {
 
     vm::Interpreter::builder(Default::default())
         .add_frozen_modules(rustpython_vm::py_freeze!(
-            dir = "../../extra_tests/snippets"
+            dir = "../../../../extra_tests/snippets"
         ))
         .build()
         .enter(|vm| {
@@ -1352,7 +2316,7 @@ fn frozen_origname_matches() {
                     .unwrap()
                     .try_into_value(vm)
                     .unwrap();
-                assert_eq!(origname.as_str(), expected);
+                assert_eq!(origname.as_wtf8(), expected);
             };
 
             check("_frozen_importlib", "importlib._bootstrap");
diff --git a/crates/vm/src/vm/python_run.rs b/crates/vm/src/vm/python_run.rs
index 1c712279f8b..2f6f0bbee01 100644
--- a/crates/vm/src/vm/python_run.rs
+++ b/crates/vm/src/vm/python_run.rs
@@ -1,71 +1,13 @@
 //! Python code execution functions.
 
 use crate::{
-    Py, PyResult, VirtualMachine,
-    builtins::{PyCode, PyDict},
+    AsObject, PyRef, PyResult, VirtualMachine,
+    builtins::PyCode,
     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<()> {
-        self.with_simple_run(path, |module_dict| {
-            self.run_simple_file_inner(module_dict, scope, path)
-        })
-    }
-
-    fn run_simple_file_inner(
-        &self,
-        module_dict: &Py<PyDict>,
-        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.
@@ -81,19 +23,27 @@ impl VirtualMachine {
         let code_obj = self
             .compile(source, compiler::Mode::Exec, source_path)
             .map_err(|err| self.new_syntax_error(&err, Some(source)))?;
+        // linecache._register_code(code, source, filename)
+        let _ = self.register_code_in_linecache(&code_obj, source);
         self.run_code_obj(code_obj, scope)
     }
 
+    /// Register a code object's source in linecache._interactive_cache
+    /// so that traceback can display source lines and caret indicators.
+    fn register_code_in_linecache(&self, code: &PyRef<PyCode>, source: &str) -> PyResult<()> {
+        let linecache = self.import("linecache", 0)?;
+        let register = linecache.get_attr("_register_code", self)?;
+        let source_str = self.ctx.new_str(source);
+        let filename = self.ctx.new_str(code.source_path().as_str());
+        register.call((code.as_object().to_owned(), source_str, filename), self)?;
+        Ok(())
+    }
+
     #[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())
@@ -102,50 +52,125 @@ impl VirtualMachine {
     }
 }
 
-fn set_main_loader(
-    module_dict: &Py<PyDict>,
-    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(())
-}
+#[cfg(feature = "host_env")]
+mod file_run {
+    use crate::{
+        Py, PyResult, VirtualMachine,
+        builtins::{PyCode, PyDict},
+        compiler::{self},
+        scope::Scope,
+    };
 
-/// 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).unwrap_or(false)
-}
+    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<()> {
+            self.with_simple_run(path, |module_dict| {
+                self.run_simple_file_inner(module_dict, scope, path)
+            })
+        }
+
+        fn run_simple_file_inner(
+            &self,
+            module_dict: &Py<PyDict>,
+            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"))?;
+                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(())
+        }
 
-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);
+        // #[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)
+        }
     }
 
-    let mut file = std::fs::File::open(path)?;
-    let mut buf = [0u8; 2];
+    fn set_main_loader(
+        module_dict: &Py<PyDict>,
+        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(())
+    }
 
-    use std::io::Read;
-    if file.read(&mut buf)? != 2 {
-        return Ok(false);
+    /// 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).unwrap_or(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(crate::import::check_pyc_magic_number_bytes(&buf))
+    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);
+        }
+
+        let mut file = std::fs::File::open(path)?;
+        let mut buf = [0u8; 2];
+
+        use std::io::Read;
+        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(crate::import::check_pyc_magic_number_bytes(&buf))
+    }
 }
diff --git a/crates/vm/src/vm/setting.rs b/crates/vm/src/vm/setting.rs
index 1a5ef9efa8f..0563e7131ac 100644
--- a/crates/vm/src/vm/setting.rs
+++ b/crates/vm/src/vm/setting.rs
@@ -124,7 +124,7 @@ pub struct Settings {
     pub stdio_encoding: Option<String>,
     /// PYTHONIOENCODING - stdio error handler
     pub stdio_errors: Option<String>,
-    pub utf8_mode: u8,
+    pub utf8_mode: i8,
     /// --check-hash-based-pycs
     pub check_hash_pycs_mode: CheckHashPycsMode,
 
@@ -211,7 +211,7 @@ impl Default for Settings {
             allow_external_library: cfg!(feature = "importlib"),
             stdio_encoding: None,
             stdio_errors: None,
-            utf8_mode: 1,
+            utf8_mode: -1,
             int_max_str_digits: 4300,
             #[cfg(feature = "flame-it")]
             profile_output: None,
diff --git a/crates/vm/src/vm/thread.rs b/crates/vm/src/vm/thread.rs
index fb8621d1526..e7cc64f00b4 100644
--- a/crates/vm/src/vm/thread.rs
+++ b/crates/vm/src/vm/thread.rs
@@ -1,27 +1,69 @@
 #[cfg(feature = "threading")]
-use crate::frame::FrameRef;
+use super::FramePtr;
+#[cfg(feature = "threading")]
+use crate::builtins::PyBaseExceptionRef;
+use crate::frame::Frame;
 use crate::{AsObject, PyObject, VirtualMachine};
+#[cfg(feature = "threading")]
+use alloc::sync::Arc;
 use core::{
     cell::{Cell, RefCell},
     ptr::NonNull,
+    sync::atomic::{AtomicPtr, Ordering},
 };
 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()
+// Thread states for stop-the-world support.
+//   DETACHED: not executing Python bytecode (in native code, or idle)
+//   ATTACHED: actively executing Python bytecode
+//   SUSPENDED: parked by a stop-the-world request
+#[cfg(all(unix, feature = "threading"))]
+pub const THREAD_DETACHED: i32 = 0;
+#[cfg(all(unix, feature = "threading"))]
+pub const THREAD_ATTACHED: i32 = 1;
+#[cfg(all(unix, feature = "threading"))]
+pub const THREAD_SUSPENDED: i32 = 2;
+
+/// Per-thread shared state for sys._current_frames() and sys._current_exceptions().
+/// The exception field uses atomic operations for lock-free cross-thread reads.
 #[cfg(feature = "threading")]
-pub type CurrentFrameSlot = Arc<parking_lot::Mutex<Option<FrameRef>>>;
+pub struct ThreadSlot {
+    /// Raw frame pointers, valid while the owning thread's call stack is active.
+    /// Readers must hold the Mutex and convert to FrameRef inside the lock.
+    pub frames: parking_lot::Mutex<Vec<FramePtr>>,
+    pub exception: crate::PyAtomicRef<Option<crate::exceptions::types::PyBaseException>>,
+    /// Thread state for stop-the-world: DETACHED / ATTACHED / SUSPENDED
+    #[cfg(unix)]
+    pub state: core::sync::atomic::AtomicI32,
+    /// Per-thread stop request bit (eval breaker equivalent).
+    #[cfg(unix)]
+    pub stop_requested: core::sync::atomic::AtomicBool,
+    /// Handle for waking this thread from park in stop-the-world paths.
+    #[cfg(unix)]
+    pub thread: std::thread::Thread,
+}
+
+#[cfg(feature = "threading")]
+pub type CurrentFrameSlot = Arc<ThreadSlot>;
 
 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) };
 
-    /// Current thread's frame slot for sys._current_frames()
+    /// Current thread's slot for sys._current_frames() and sys._current_exceptions()
     #[cfg(feature = "threading")]
-    static CURRENT_FRAME_SLOT: RefCell<Option<CurrentFrameSlot>> = const { RefCell::new(None) };
+    static CURRENT_THREAD_SLOT: RefCell<Option<CurrentFrameSlot>> = const { RefCell::new(None) };
+
+    /// Current top frame for signal-safe traceback walking.
+    /// Mirrors `PyThreadState.current_frame`. Read by faulthandler's signal
+    /// handler to dump tracebacks without accessing RefCell or locks.
+    /// Uses AtomicPtr for async-signal-safety (signal handlers may read this
+    /// while the owning thread is writing).
+    pub(crate) static CURRENT_FRAME: AtomicPtr<Frame> =
+        const { AtomicPtr::new(core::ptr::null_mut()) };
+
 }
 
 scoped_tls::scoped_thread_local!(static VM_CURRENT: VirtualMachine);
@@ -35,71 +77,422 @@ 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| {
+        // Outermost enter_vm: transition DETACHED → ATTACHED
+        #[cfg(all(unix, feature = "threading"))]
+        let was_outermost = vms.borrow().is_empty();
+
         vms.borrow_mut().push(vm.into());
 
-        // Initialize frame slot for this thread if not already done
+        // Initialize thread slot for this thread if not already done
         #[cfg(feature = "threading")]
-        init_frame_slot_if_needed(vm);
+        init_thread_slot_if_needed(vm);
+
+        #[cfg(all(unix, feature = "threading"))]
+        if was_outermost {
+            attach_thread(vm);
+        }
 
-        scopeguard::defer! { vms.borrow_mut().pop(); }
+        scopeguard::defer! {
+            // Outermost exit: transition ATTACHED → DETACHED
+            #[cfg(all(unix, feature = "threading"))]
+            if vms.borrow().len() == 1 {
+                detach_thread();
+            }
+            vms.borrow_mut().pop();
+        }
         VM_CURRENT.set(vm, f)
     })
 }
 
-/// Initialize frame slot for current thread if not already initialized.
+/// Initialize thread 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| {
+fn init_thread_slot_if_needed(vm: &VirtualMachine) {
+    CURRENT_THREAD_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());
+            let thread_id = crate::stdlib::_thread::get_ident();
+            let mut registry = vm.state.thread_frames.lock();
+            let new_slot = Arc::new(ThreadSlot {
+                frames: parking_lot::Mutex::new(Vec::new()),
+                exception: crate::PyAtomicRef::from(None::<PyBaseExceptionRef>),
+                #[cfg(unix)]
+                state: core::sync::atomic::AtomicI32::new(
+                    if vm.state.stop_the_world.requested.load(Ordering::Acquire) {
+                        // Match init_threadstate(): new thread-state starts
+                        // suspended while stop-the-world is active.
+                        THREAD_SUSPENDED
+                    } else {
+                        THREAD_DETACHED
+                    },
+                ),
+                #[cfg(unix)]
+                stop_requested: core::sync::atomic::AtomicBool::new(false),
+                #[cfg(unix)]
+                thread: std::thread::current(),
+            });
+            registry.insert(thread_id, new_slot.clone());
+            drop(registry);
             *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.
+/// Transition DETACHED → ATTACHED. Blocks if the thread was SUSPENDED by
+/// a stop-the-world request (like `_PyThreadState_Attach` + `tstate_wait_attach`).
+#[cfg(all(unix, feature = "threading"))]
+fn wait_while_suspended(slot: &ThreadSlot) -> u64 {
+    let mut wait_yields = 0u64;
+    while slot.state.load(Ordering::Acquire) == THREAD_SUSPENDED {
+        wait_yields = wait_yields.saturating_add(1);
+        std::thread::park();
+    }
+    wait_yields
+}
+
+#[cfg(all(unix, feature = "threading"))]
+fn attach_thread(vm: &VirtualMachine) {
+    CURRENT_THREAD_SLOT.with(|slot| {
+        if let Some(s) = slot.borrow().as_ref() {
+            super::stw_trace(format_args!("attach begin"));
+            loop {
+                match s.state.compare_exchange(
+                    THREAD_DETACHED,
+                    THREAD_ATTACHED,
+                    Ordering::AcqRel,
+                    Ordering::Relaxed,
+                ) {
+                    Ok(_) => {
+                        super::stw_trace(format_args!("attach DETACHED->ATTACHED"));
+                        break;
+                    }
+                    Err(THREAD_SUSPENDED) => {
+                        // Parked by stop-the-world — wait until released to DETACHED
+                        super::stw_trace(format_args!("attach wait-suspended"));
+                        let wait_yields = wait_while_suspended(s);
+                        vm.state.stop_the_world.add_attach_wait_yields(wait_yields);
+                        // Retry CAS
+                    }
+                    Err(state) => {
+                        debug_assert!(false, "unexpected thread state in attach: {state}");
+                        break;
+                    }
+                }
+            }
+        }
+    });
+}
+
+/// Transition ATTACHED → DETACHED (like `_PyThreadState_Detach`).
+#[cfg(all(unix, feature = "threading"))]
+fn detach_thread() {
+    CURRENT_THREAD_SLOT.with(|slot| {
+        if let Some(s) = slot.borrow().as_ref() {
+            match s.state.compare_exchange(
+                THREAD_ATTACHED,
+                THREAD_DETACHED,
+                Ordering::AcqRel,
+                Ordering::Acquire,
+            ) {
+                Ok(_) => {}
+                Err(THREAD_DETACHED) => {
+                    debug_assert!(false, "detach called while already DETACHED");
+                    return;
+                }
+                Err(state) => {
+                    debug_assert!(false, "unexpected thread state in detach: {state}");
+                    return;
+                }
+            }
+            super::stw_trace(format_args!("detach ATTACHED->DETACHED"));
+        }
+    });
+}
+
+/// Temporarily transition the current thread ATTACHED → DETACHED while
+/// running `f`, then re-attach afterwards.  This allows `stop_the_world`
+/// to park this thread during blocking operations.
+///
+/// `Py_BEGIN_ALLOW_THREADS` / `Py_END_ALLOW_THREADS` equivalent.
+#[cfg(all(unix, feature = "threading"))]
+pub fn allow_threads<R>(vm: &VirtualMachine, f: impl FnOnce() -> R) -> R {
+    // Preserve save/restore semantics:
+    // only detach if this call observed ATTACHED at entry, and always restore
+    // on unwind.
+    let should_transition = CURRENT_THREAD_SLOT.with(|slot| {
+        slot.borrow()
+            .as_ref()
+            .is_some_and(|s| s.state.load(Ordering::Acquire) == THREAD_ATTACHED)
+    });
+    if !should_transition {
+        return f();
+    }
+
+    detach_thread();
+    let reattach_guard = scopeguard::guard(vm, attach_thread);
+    let result = f();
+    drop(reattach_guard);
+    result
+}
+
+/// No-op on non-unix or non-threading builds.
+#[cfg(not(all(unix, feature = "threading")))]
+pub fn allow_threads<R>(_vm: &VirtualMachine, f: impl FnOnce() -> R) -> R {
+    f()
+}
+
+/// Called from check_signals when stop-the-world is requested.
+/// Transitions ATTACHED → SUSPENDED and waits until released
+/// (like `_PyThreadState_Suspend` + `_PyThreadState_Attach`).
+#[cfg(all(unix, feature = "threading"))]
+pub fn suspend_if_needed(stw: &super::StopTheWorldState) {
+    let should_suspend = CURRENT_THREAD_SLOT.with(|slot| {
+        slot.borrow()
+            .as_ref()
+            .is_some_and(|s| s.stop_requested.load(Ordering::Relaxed))
+    });
+    if !should_suspend {
+        return;
+    }
+
+    if !stw.requested.load(Ordering::Acquire) {
+        CURRENT_THREAD_SLOT.with(|slot| {
+            if let Some(s) = slot.borrow().as_ref() {
+                s.stop_requested.store(false, Ordering::Release);
+            }
+        });
+        return;
+    }
+
+    do_suspend(stw);
+}
+
+#[cfg(all(unix, feature = "threading"))]
+#[cold]
+fn do_suspend(stw: &super::StopTheWorldState) {
+    CURRENT_THREAD_SLOT.with(|slot| {
+        if let Some(s) = slot.borrow().as_ref() {
+            // ATTACHED → SUSPENDED
+            match s.state.compare_exchange(
+                THREAD_ATTACHED,
+                THREAD_SUSPENDED,
+                Ordering::AcqRel,
+                Ordering::Acquire,
+            ) {
+                Ok(_) => {
+                    // Consumed this thread's stop request bit.
+                    s.stop_requested.store(false, Ordering::Release);
+                }
+                Err(THREAD_DETACHED) => {
+                    // Leaving VM; caller will re-check on next entry.
+                    super::stw_trace(format_args!("suspend skip DETACHED"));
+                    return;
+                }
+                Err(THREAD_SUSPENDED) => {
+                    // Already parked by another path.
+                    s.stop_requested.store(false, Ordering::Release);
+                    super::stw_trace(format_args!("suspend skip already-suspended"));
+                    return;
+                }
+                Err(state) => {
+                    debug_assert!(false, "unexpected thread state in suspend: {state}");
+                    return;
+                }
+            }
+            super::stw_trace(format_args!("suspend ATTACHED->SUSPENDED"));
+
+            // Re-check: if start_the_world already ran (cleared `requested`),
+            // no one will set us back to DETACHED — we must self-recover.
+            if !stw.requested.load(Ordering::Acquire) {
+                s.state.store(THREAD_ATTACHED, Ordering::Release);
+                s.stop_requested.store(false, Ordering::Release);
+                super::stw_trace(format_args!("suspend abort requested-cleared"));
+                return;
+            }
+
+            // Notify the stop-the-world requester that we've parked
+            stw.notify_suspended();
+            super::stw_trace(format_args!("suspend notified-requester"));
+
+            // Wait until start_the_world sets us back to DETACHED
+            let wait_yields = wait_while_suspended(s);
+            stw.add_suspend_wait_yields(wait_yields);
+
+            // Re-attach (DETACHED → ATTACHED), tstate_wait_attach CAS loop.
+            loop {
+                match s.state.compare_exchange(
+                    THREAD_DETACHED,
+                    THREAD_ATTACHED,
+                    Ordering::AcqRel,
+                    Ordering::Acquire,
+                ) {
+                    Ok(_) => break,
+                    Err(THREAD_SUSPENDED) => {
+                        let extra_wait = wait_while_suspended(s);
+                        stw.add_suspend_wait_yields(extra_wait);
+                    }
+                    Err(THREAD_ATTACHED) => break,
+                    Err(state) => {
+                        debug_assert!(false, "unexpected post-suspend state: {state}");
+                        break;
+                    }
+                }
+            }
+            s.stop_requested.store(false, Ordering::Release);
+            super::stw_trace(format_args!("suspend resume -> ATTACHED"));
+        }
+    });
+}
+
+#[cfg(all(unix, feature = "threading"))]
+#[inline]
+pub fn stop_requested_for_current_thread() -> bool {
+    CURRENT_THREAD_SLOT.with(|slot| {
+        slot.borrow()
+            .as_ref()
+            .is_some_and(|s| s.stop_requested.load(Ordering::Relaxed))
+    })
+}
+
+/// Push a frame pointer onto the current thread's shared frame stack.
+/// The pointed-to frame must remain alive until the matching pop.
+#[cfg(feature = "threading")]
+pub fn push_thread_frame(fp: FramePtr) {
+    CURRENT_THREAD_SLOT.with(|slot| {
+        if let Some(s) = slot.borrow().as_ref() {
+            s.frames.lock().push(fp);
+        } else {
+            debug_assert!(
+                false,
+                "push_thread_frame called without initialized thread slot"
+            );
+        }
+    });
+}
+
+/// Pop a frame from the current thread's shared frame stack.
+/// Called when a frame is exited.
+#[cfg(feature = "threading")]
+pub fn pop_thread_frame() {
+    CURRENT_THREAD_SLOT.with(|slot| {
+        if let Some(s) = slot.borrow().as_ref() {
+            s.frames.lock().pop();
+        } else {
+            debug_assert!(
+                false,
+                "pop_thread_frame called without initialized thread slot"
+            );
+        }
+    });
+}
+
+/// Set the current thread's top frame pointer for signal-safe traceback walking.
+/// Returns the previous frame pointer so it can be restored on pop.
+pub fn set_current_frame(frame: *const Frame) -> *const Frame {
+    CURRENT_FRAME.with(|c| c.swap(frame as *mut Frame, Ordering::Relaxed) as *const Frame)
+}
+
+/// Get the current thread's top frame pointer.
+/// Used by faulthandler's signal handler to start traceback walking.
+pub fn get_current_frame() -> *const Frame {
+    CURRENT_FRAME.with(|c| c.load(Ordering::Relaxed) as *const Frame)
+}
+
+/// Update the current thread's exception slot atomically (no locks).
+/// Called from push_exception/pop_exception/set_exception.
 #[cfg(feature = "threading")]
-pub fn update_current_frame(frame: Option<FrameRef>) {
-    CURRENT_FRAME_SLOT.with(|slot| {
+pub fn update_thread_exception(exc: Option<PyBaseExceptionRef>) {
+    CURRENT_THREAD_SLOT.with(|slot| {
         if let Some(s) = slot.borrow().as_ref() {
-            *s.lock() = frame;
+            // SAFETY: Called only from the owning thread. The old ref is dropped
+            // here on the owning thread, which is safe.
+            let _old = unsafe { s.exception.swap(exc) };
         }
     });
 }
 
-/// Cleanup frame tracking for the current thread. Called at thread exit.
+/// Collect all threads' current exceptions for sys._current_exceptions().
+/// Acquires the global registry lock briefly, then reads each slot's exception atomically.
+#[cfg(feature = "threading")]
+pub fn get_all_current_exceptions(vm: &VirtualMachine) -> Vec<(u64, Option<PyBaseExceptionRef>)> {
+    let registry = vm.state.thread_frames.lock();
+    registry
+        .iter()
+        .map(|(id, slot)| (*id, slot.exception.to_owned()))
+        .collect()
+}
+
+/// Cleanup thread slot 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| {
+    let thread_id = crate::stdlib::_thread::get_ident();
+    let current_slot = CURRENT_THREAD_SLOT.with(|slot| slot.borrow().as_ref().cloned());
+
+    // A dying thread should not remain logically ATTACHED while its
+    // thread-state slot is being removed.
+    #[cfg(all(unix, feature = "threading"))]
+    if let Some(slot) = &current_slot {
+        let _ = slot.state.compare_exchange(
+            THREAD_ATTACHED,
+            THREAD_DETACHED,
+            Ordering::AcqRel,
+            Ordering::Acquire,
+        );
+    }
+
+    // Guard against OS thread-id reuse races: only remove the registry entry
+    // if it still points at this thread's own slot.
+    let removed = if let Some(slot) = &current_slot {
+        let mut registry = vm.state.thread_frames.lock();
+        match registry.get(&thread_id) {
+            Some(registered) if Arc::ptr_eq(registered, slot) => registry.remove(&thread_id),
+            _ => None,
+        }
+    } else {
+        None
+    };
+    #[cfg(all(unix, feature = "threading"))]
+    if let Some(slot) = &removed
+        && vm.state.stop_the_world.requested.load(Ordering::Acquire)
+        && thread_id != vm.state.stop_the_world.requester_ident()
+        && slot.state.load(Ordering::Relaxed) != THREAD_SUSPENDED
+    {
+        // A non-requester thread disappeared while stop-the-world is pending.
+        // Unblock requester countdown progress.
+        vm.state.stop_the_world.notify_thread_gone();
+    }
+    CURRENT_THREAD_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.
+/// Reinitialize thread slot after fork. Called in child process.
+/// Creates a fresh slot and registers it for the current thread,
+/// preserving the current thread's frames from `vm.frames`.
+///
+/// Precondition: `reinit_locks_after_fork()` has already reset all
+/// VmState locks to unlocked.
 #[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());
-    }
+    let current_ident = crate::stdlib::_thread::get_ident();
+    let current_frames: Vec<FramePtr> = vm.frames.borrow().clone();
+    let new_slot = Arc::new(ThreadSlot {
+        frames: parking_lot::Mutex::new(current_frames),
+        exception: crate::PyAtomicRef::from(vm.topmost_exception()),
+        #[cfg(unix)]
+        state: core::sync::atomic::AtomicI32::new(THREAD_ATTACHED),
+        #[cfg(unix)]
+        stop_requested: core::sync::atomic::AtomicBool::new(false),
+        #[cfg(unix)]
+        thread: std::thread::current(),
+    });
+
+    // Lock is safe: reinit_locks_after_fork() already reset it to unlocked.
+    let mut registry = vm.state.thread_frames.lock();
+    registry.clear();
+    registry.insert(current_ident, new_slot.clone());
+    drop(registry);
 
-    // Always update thread-local to point to the new slot
-    CURRENT_FRAME_SLOT.with(|s| {
+    CURRENT_THREAD_SLOT.with(|s| {
         *s.borrow_mut() = Some(new_slot);
     });
 }
@@ -221,14 +614,16 @@ impl VirtualMachine {
             sys_module: self.sys_module.clone(),
             ctx: self.ctx.clone(),
             frames: RefCell::new(vec![]),
+            datastack: core::cell::UnsafeCell::new(crate::datastack::DataStack::new()),
             wasm_id: self.wasm_id.clone(),
             exceptions: RefCell::default(),
             import_func: self.import_func.clone(),
+            importlib: self.importlib.clone(),
             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_handlers: core::cell::OnceCell::new(),
             signal_rx: None,
             repr_guards: RefCell::default(),
             state: self.state.clone(),
@@ -239,6 +634,7 @@ impl VirtualMachine {
             async_gen_finalizer: RefCell::new(None),
             asyncio_running_loop: RefCell::new(None),
             asyncio_running_task: RefCell::new(None),
+            callable_cache: self.callable_cache.clone(),
         };
         ThreadedVirtualMachine { vm }
     }
diff --git a/crates/vm/src/vm/vm_new.rs b/crates/vm/src/vm/vm_new.rs
index 8fc8108b6a3..fb40268c569 100644
--- a/crates/vm/src/vm/vm_new.rs
+++ b/crates/vm/src/vm/vm_new.rs
@@ -13,6 +13,7 @@ use crate::{
     scope::Scope,
     vm::VirtualMachine,
 };
+use rustpython_common::wtf8::Wtf8Buf;
 use rustpython_compiler_core::SourceLocation;
 
 macro_rules! define_exception_fn {
@@ -24,7 +25,7 @@ macro_rules! define_exception_fn {
                     stringify!($python_repr),
                     " object.\nUseful for raising errors from python functions implemented in rust."
                 )]
-        pub fn $fn_name(&self, msg: impl Into<String>) -> PyBaseExceptionRef
+        pub fn $fn_name(&self, msg: impl Into<Wtf8Buf>) -> PyBaseExceptionRef
         {
             let err = self.ctx.exceptions.$attr.to_owned();
             self.new_exception_msg(err, msg.into())
@@ -109,8 +110,8 @@ impl VirtualMachine {
         debug_assert_eq!(
             exc_type.slots.basicsize,
             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()
+            "vm.new_exception() is only for exception types without additional payload. The given type '{}' is not allowed. Use vm.new_os_subtype_error() for OSError subtypes.",
+            exc_type.name()
         );
 
         PyRef::new_ref(
@@ -150,7 +151,7 @@ impl VirtualMachine {
     /// type is passed in, it may not be fully initialized; try using
     /// [`vm.invoke_exception()`][Self::invoke_exception] or
     /// [`exceptions::ExceptionCtor`][crate::exceptions::ExceptionCtor] instead.
-    pub fn new_exception_msg(&self, exc_type: PyTypeRef, msg: String) -> PyBaseExceptionRef {
+    pub fn new_exception_msg(&self, exc_type: PyTypeRef, msg: Wtf8Buf) -> PyBaseExceptionRef {
         self.new_exception(exc_type, vec![self.ctx.new_str(msg).into()])
     }
 
@@ -162,7 +163,7 @@ impl VirtualMachine {
     pub fn new_exception_msg_dict(
         &self,
         exc_type: PyTypeRef,
-        msg: String,
+        msg: Wtf8Buf,
         dict: PyDictRef,
     ) -> PyBaseExceptionRef {
         PyRef::new_ref(
@@ -189,7 +190,7 @@ impl VirtualMachine {
         attribute_error
     }
 
-    pub fn new_name_error(&self, msg: impl Into<String>, name: PyStrRef) -> PyBaseExceptionRef {
+    pub fn new_name_error(&self, msg: impl Into<Wtf8Buf>, name: PyStrRef) -> PyBaseExceptionRef {
         let name_error_type = self.ctx.exceptions.name_error.to_owned();
         let name_error = self.new_exception_msg(name_error_type, msg.into());
         name_error.as_object().set_attr("name", name, self).unwrap();
@@ -211,7 +212,7 @@ impl VirtualMachine {
         op: &str,
     ) -> PyBaseExceptionRef {
         self.new_type_error(format!(
-            "'{}' not supported between instances of '{}' and '{}'",
+            "unsupported operand type(s) for {}: '{}' and '{}'",
             op,
             a.class().name(),
             b.class().name()
@@ -332,16 +333,54 @@ impl VirtualMachine {
         source: Option<&str>,
         allow_incomplete: bool,
     ) -> PyBaseExceptionRef {
+        let incomplete_or_syntax = |allow| -> &'static Py<crate::builtins::PyType> {
+            if allow {
+                self.ctx.exceptions.incomplete_input_error
+            } else {
+                self.ctx.exceptions.syntax_error
+            }
+        };
+
         let syntax_error_type = match &error {
             #[cfg(feature = "parser")]
-            // FIXME: this condition will cause TabError even when the matching actual error is IndentationError
             crate::compiler::CompileError::Parse(rustpython_compiler::ParseError {
                 error:
                     ruff_python_parser::ParseErrorType::Lexical(
                         ruff_python_parser::LexicalErrorType::IndentationError,
                     ),
                 ..
-            }) => self.ctx.exceptions.tab_error,
+            }) => {
+                // Detect tab/space mixing to raise TabError instead of IndentationError.
+                // This checks both within a single line and across different lines.
+                let is_tab_error = source.is_some_and(|source| {
+                    let mut has_space_indent = false;
+                    let mut has_tab_indent = false;
+                    for line in source.lines() {
+                        let indent: Vec<u8> = line
+                            .bytes()
+                            .take_while(|&b| b == b' ' || b == b'\t')
+                            .collect();
+                        if indent.is_empty() {
+                            continue;
+                        }
+                        if indent.contains(&b' ') && indent.contains(&b'\t') {
+                            return true;
+                        }
+                        if indent.contains(&b' ') {
+                            has_space_indent = true;
+                        }
+                        if indent.contains(&b'\t') {
+                            has_tab_indent = true;
+                        }
+                    }
+                    has_space_indent && has_tab_indent
+                });
+                if is_tab_error {
+                    self.ctx.exceptions.tab_error
+                } else {
+                    self.ctx.exceptions.indentation_error
+                }
+            }
             #[cfg(feature = "parser")]
             crate::compiler::CompileError::Parse(rustpython_compiler::ParseError {
                 error: ruff_python_parser::ParseErrorType::UnexpectedIndentation,
@@ -354,13 +393,13 @@ impl VirtualMachine {
                         ruff_python_parser::LexicalErrorType::Eof,
                     ),
                 ..
-            }) => {
-                if allow_incomplete {
-                    self.ctx.exceptions.incomplete_input_error
-                } else {
-                    self.ctx.exceptions.syntax_error
-                }
-            }
+            }) => incomplete_or_syntax(allow_incomplete),
+            // Unclosed bracket errors (converted from Eof by from_ruff_parse_error)
+            #[cfg(feature = "parser")]
+            crate::compiler::CompileError::Parse(rustpython_compiler::ParseError {
+                is_unclosed_bracket: true,
+                ..
+            }) => incomplete_or_syntax(allow_incomplete),
             #[cfg(feature = "parser")]
             crate::compiler::CompileError::Parse(rustpython_compiler::ParseError {
                 error:
@@ -370,13 +409,7 @@ impl VirtualMachine {
                         ),
                     ),
                 ..
-            }) => {
-                if allow_incomplete {
-                    self.ctx.exceptions.incomplete_input_error
-                } else {
-                    self.ctx.exceptions.syntax_error
-                }
-            }
+            }) => incomplete_or_syntax(allow_incomplete),
             #[cfg(feature = "parser")]
             crate::compiler::CompileError::Parse(rustpython_compiler::ParseError {
                 error:
@@ -400,11 +433,7 @@ impl VirtualMachine {
                         }
                     }
 
-                    if is_incomplete {
-                        self.ctx.exceptions.incomplete_input_error
-                    } else {
-                        self.ctx.exceptions.syntax_error
-                    }
+                    incomplete_or_syntax(is_incomplete)
                 } else {
                     self.ctx.exceptions.syntax_error
                 }
@@ -440,7 +469,7 @@ impl VirtualMachine {
                         if is_incomplete {
                             self.ctx.exceptions.incomplete_input_error
                         } else {
-                            self.ctx.exceptions.indentation_error
+                            self.ctx.exceptions.indentation_error // not syntax_error
                         }
                     } else {
                         self.ctx.exceptions.indentation_error
@@ -458,6 +487,7 @@ impl VirtualMachine {
             let line = source
                 .split('\n')
                 .nth(loc?.line.to_zero_indexed())?
+                .trim_end_matches('\r')
                 .to_owned();
             Some(line + "\n")
         }
@@ -472,17 +502,125 @@ impl VirtualMachine {
         if let Some(msg) = msg.get_mut(..1) {
             msg.make_ascii_lowercase();
         }
+        let mut narrow_caret = false;
         match error {
+            #[cfg(feature = "parser")]
+            crate::compiler::CompileError::Parse(rustpython_compiler::ParseError {
+                error:
+                    ruff_python_parser::ParseErrorType::FStringError(
+                        ruff_python_parser::InterpolatedStringErrorType::UnterminatedString,
+                    )
+                    | ruff_python_parser::ParseErrorType::Lexical(
+                        ruff_python_parser::LexicalErrorType::FStringError(
+                            ruff_python_parser::InterpolatedStringErrorType::UnterminatedString,
+                        ),
+                    ),
+                ..
+            }) => {
+                msg = "unterminated f-string literal".to_owned();
+            }
+            #[cfg(feature = "parser")]
+            crate::compiler::CompileError::Parse(rustpython_compiler::ParseError {
+                error:
+                    ruff_python_parser::ParseErrorType::FStringError(
+                        ruff_python_parser::InterpolatedStringErrorType::UnterminatedTripleQuotedString,
+                    )
+                    | ruff_python_parser::ParseErrorType::Lexical(
+                        ruff_python_parser::LexicalErrorType::FStringError(
+                            ruff_python_parser::InterpolatedStringErrorType::UnterminatedTripleQuotedString,
+                        ),
+                    ),
+                ..
+            }) => {
+                msg = "unterminated triple-quoted f-string literal".to_owned();
+            }
             #[cfg(feature = "parser")]
             crate::compiler::CompileError::Parse(rustpython_compiler::ParseError {
                 error:
                     ruff_python_parser::ParseErrorType::FStringError(_)
-                    | ruff_python_parser::ParseErrorType::UnexpectedExpressionToken,
+                    | ruff_python_parser::ParseErrorType::Lexical(
+                        ruff_python_parser::LexicalErrorType::FStringError(_),
+                    ),
+                ..
+            }) => {
+                // Replace backticks with single quotes to match CPython's error messages
+                msg = msg.replace('`', "'");
+                msg.insert_str(0, "invalid syntax: ");
+            }
+            #[cfg(feature = "parser")]
+            crate::compiler::CompileError::Parse(rustpython_compiler::ParseError {
+                error: ruff_python_parser::ParseErrorType::UnexpectedExpressionToken,
                 ..
             }) => msg.insert_str(0, "invalid syntax: "),
+            #[cfg(feature = "parser")]
+            crate::compiler::CompileError::Parse(rustpython_compiler::ParseError {
+                error:
+                    ruff_python_parser::ParseErrorType::Lexical(
+                        ruff_python_parser::LexicalErrorType::UnrecognizedToken { .. },
+                    )
+                    | ruff_python_parser::ParseErrorType::SimpleStatementsOnSameLine
+                    | ruff_python_parser::ParseErrorType::SimpleAndCompoundStatementOnSameLine
+                    | ruff_python_parser::ParseErrorType::ExpectedToken { .. }
+                    | ruff_python_parser::ParseErrorType::ExpectedExpression,
+                ..
+            }) => {
+                msg = "invalid syntax".to_owned();
+            }
+            #[cfg(feature = "parser")]
+            crate::compiler::CompileError::Parse(rustpython_compiler::ParseError {
+                error: ruff_python_parser::ParseErrorType::InvalidStarredExpressionUsage,
+                ..
+            }) => {
+                msg = "invalid syntax".to_owned();
+                narrow_caret = true;
+            }
+            #[cfg(feature = "parser")]
+            crate::compiler::CompileError::Parse(rustpython_compiler::ParseError {
+                error: ruff_python_parser::ParseErrorType::InvalidDeleteTarget,
+                ..
+            }) => {
+                msg = "invalid syntax".to_owned();
+            }
+            #[cfg(feature = "parser")]
+            crate::compiler::CompileError::Parse(rustpython_compiler::ParseError {
+                error:
+                    ruff_python_parser::ParseErrorType::Lexical(
+                        ruff_python_parser::LexicalErrorType::LineContinuationError,
+                    ),
+                ..
+            }) => {
+                msg = "unexpected character after line continuation".to_owned();
+            }
+            #[cfg(feature = "parser")]
+            crate::compiler::CompileError::Parse(rustpython_compiler::ParseError {
+                error:
+                    ruff_python_parser::ParseErrorType::Lexical(
+                        ruff_python_parser::LexicalErrorType::UnclosedStringError,
+                    ),
+                ..
+            }) => {
+                msg = "unterminated string".to_owned();
+            }
+            #[cfg(feature = "parser")]
+            crate::compiler::CompileError::Parse(rustpython_compiler::ParseError {
+                error: ruff_python_parser::ParseErrorType::OtherError(s),
+                ..
+            }) if s.eq_ignore_ascii_case("bytes literal cannot be mixed with non-bytes literals") => {
+                msg = "cannot mix bytes and nonbytes literals".to_owned();
+            }
+            #[cfg(feature = "parser")]
+            crate::compiler::CompileError::Parse(rustpython_compiler::ParseError {
+                error: ruff_python_parser::ParseErrorType::OtherError(s),
+                ..
+            }) if s.starts_with("Expected an identifier, but found a keyword") => {
+                msg = "invalid syntax".to_owned();
+            }
             _ => {}
         }
-        let syntax_error = self.new_exception_msg(syntax_error_type, msg);
+        if syntax_error_type.is(self.ctx.exceptions.tab_error) {
+            msg = "inconsistent use of tabs and spaces in indentation".to_owned();
+        }
+        let syntax_error = self.new_exception_msg(syntax_error_type, msg.into());
         let (lineno, offset) = error.python_location();
         let lineno = self.ctx.new_int(lineno);
         let offset = self.ctx.new_int(offset);
@@ -497,6 +635,12 @@ impl VirtualMachine {
 
         // Set end_lineno and end_offset if available
         if let Some((end_lineno, end_offset)) = error.python_end_location() {
+            let (end_lineno, end_offset) = if narrow_caret {
+                let (l, o) = error.python_location();
+                (l, o + 1)
+            } else {
+                (end_lineno, end_offset)
+            };
             let end_lineno = self.ctx.new_int(end_lineno);
             let end_offset = self.ctx.new_int(end_offset);
             syntax_error
@@ -517,6 +661,23 @@ impl VirtualMachine {
             .as_object()
             .set_attr("filename", self.ctx.new_str(error.source_path()), self)
             .unwrap();
+
+        // Set _metadata for keyword typo suggestions in traceback module.
+        // Format: (start_line, col_offset, source_code)
+        // start_line=0 means "include all lines from beginning" which provides
+        // full context needed by _find_keyword_typos to compile-check suggestions.
+        if let Some(source) = source {
+            let metadata = self.ctx.new_tuple(vec![
+                self.ctx.new_int(0).into(),
+                self.ctx.new_int(0).into(),
+                self.ctx.new_str(source).into(),
+            ]);
+            syntax_error
+                .as_object()
+                .set_attr("_metadata", metadata, self)
+                .unwrap();
+        }
+
         syntax_error
     }
 
@@ -529,10 +690,14 @@ impl VirtualMachine {
         self.new_syntax_error_maybe_incomplete(error, source, false)
     }
 
-    pub fn new_import_error(&self, msg: impl Into<String>, name: PyStrRef) -> PyBaseExceptionRef {
+    pub fn new_import_error(
+        &self,
+        msg: impl Into<Wtf8Buf>,
+        name: impl Into<PyStrRef>,
+    ) -> PyBaseExceptionRef {
         let import_error = self.ctx.exceptions.import_error.to_owned();
         let exc = self.new_exception_msg(import_error, msg.into());
-        exc.as_object().set_attr("name", name, self).unwrap();
+        exc.as_object().set_attr("name", name.into(), self).unwrap();
         exc
     }
 
@@ -573,7 +738,7 @@ impl VirtualMachine {
         } else {
             msg
         };
-        self.new_exception_msg(error_type.to_owned(), msg)
+        self.new_exception_msg(error_type.to_owned(), msg.into())
     }
 
     pub(crate) fn new_downcast_runtime_error(
diff --git a/crates/vm/src/vm/vm_object.rs b/crates/vm/src/vm/vm_object.rs
index 0d5b286148c..0c60be2c0ec 100644
--- a/crates/vm/src/vm/vm_object.rs
+++ b/crates/vm/src/vm/vm_object.rs
@@ -52,14 +52,31 @@ impl VirtualMachine {
         }
     }
 
-    pub(crate) fn flush_std(&self) {
+    /// Returns true if the file object's `closed` attribute is truthy.
+    fn file_is_closed(&self, file: &PyObject) -> bool {
+        file.get_attr("closed", self)
+            .ok()
+            .is_some_and(|v| v.try_to_bool(self).unwrap_or(false))
+    }
+
+    pub(crate) fn flush_std(&self) -> i32 {
         let vm = self;
-        if let Ok(stdout) = sys::get_stdout(vm) {
-            let _ = vm.call_method(&stdout, identifier!(vm, flush).as_str(), ());
+        let mut status = 0;
+        if let Ok(stdout) = sys::get_stdout(vm)
+            && !vm.is_none(&stdout)
+            && !vm.file_is_closed(&stdout)
+            && let Err(e) = vm.call_method(&stdout, identifier!(vm, flush).as_str(), ())
+        {
+            vm.run_unraisable(e, None, stdout);
+            status = -1;
         }
-        if let Ok(stderr) = sys::get_stderr(vm) {
+        if let Ok(stderr) = sys::get_stderr(vm)
+            && !vm.is_none(&stderr)
+            && !vm.file_is_closed(&stderr)
+        {
             let _ = vm.call_method(&stderr, identifier!(vm, flush).as_str(), ());
         }
+        status
     }
 
     #[track_caller]
diff --git a/crates/vm/src/vm/vm_ops.rs b/crates/vm/src/vm/vm_ops.rs
index 1a362d67bed..abce0ea678b 100644
--- a/crates/vm/src/vm/vm_ops.rs
+++ b/crates/vm/src/vm/vm_ops.rs
@@ -1,14 +1,32 @@
 use super::VirtualMachine;
-use crate::stdlib::warnings;
+use crate::stdlib::_warnings;
 use crate::{
-    PyRef,
-    builtins::{PyInt, PyStr, PyStrRef, PyUtf8Str},
+    Py, PyRef,
+    builtins::{PyInt, PyStr, PyStrInterned, PyStrRef, PyType, PyUtf8Str},
     object::{AsObject, PyObject, PyObjectRef, PyResult},
     protocol::{PyNumberBinaryOp, PyNumberTernaryOp},
     types::PyComparisonOp,
 };
 use num_traits::ToPrimitive;
 
+/// [CPython `method_is_overloaded`](https://github.com/python/cpython/blob/v3.14.3/Objects/typeobject.c#L9849-L9879)
+fn method_is_overloaded(
+    class_a: &Py<PyType>,
+    class_b: &Py<PyType>,
+    rop_name: Option<&'static PyStrInterned>,
+    vm: &VirtualMachine,
+) -> PyResult<bool> {
+    let Some(rop_name) = rop_name else {
+        return Ok(false);
+    };
+    let Some(method_b) = class_b.get_attr(rop_name) else {
+        return Ok(false);
+    };
+    class_a.get_attr(rop_name).map_or(Ok(true), |method_a| {
+        vm.identical_or_equal(&method_a, &method_b).map(|eq| !eq)
+    })
+}
+
 macro_rules! binary_func {
     ($fn:ident, $op_slot:ident, $op:expr) => {
         pub fn $fn(&self, a: &PyObject, b: &PyObject) -> PyResult {
@@ -162,18 +180,34 @@ impl VirtualMachine {
 
         // Number slots are inherited, direct access is O(1)
         let slot_a = class_a.slots.as_number.left_binary_op(op_slot);
+        let slot_a_addr = slot_a.map(|x| x as usize);
         let mut slot_b = None;
+        let left_b_addr;
 
         if !class_a.is(class_b) {
             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) {
+            if slot_bb.map(|x| x as usize) != slot_a_addr {
                 slot_b = slot_bb;
             }
+            left_b_addr = class_b
+                .slots
+                .as_number
+                .left_binary_op(op_slot)
+                .map(|x| x as usize);
+        } else {
+            left_b_addr = slot_a_addr;
         }
 
         if let Some(slot_a) = slot_a {
             if let Some(slot_bb) = slot_b
                 && class_b.fast_issubclass(class_a)
+                && (slot_a_addr != left_b_addr
+                    || method_is_overloaded(
+                        class_a,
+                        class_b,
+                        op_slot.right_method_name(self),
+                        self,
+                    )?)
             {
                 let ret = slot_bb(a, b, self)?;
                 if !ret.is(&self.ctx.not_implemented) {
@@ -269,18 +303,34 @@ impl VirtualMachine {
 
         // Number slots are inherited, direct access is O(1)
         let slot_a = class_a.slots.as_number.left_ternary_op(op_slot);
+        let slot_a_addr = slot_a.map(|x| x as usize);
         let mut slot_b = None;
+        let left_b_addr;
 
         if !class_a.is(class_b) {
             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) {
+            if slot_bb.map(|x| x as usize) != slot_a_addr {
                 slot_b = slot_bb;
             }
+            left_b_addr = class_b
+                .slots
+                .as_number
+                .left_ternary_op(op_slot)
+                .map(|x| x as usize);
+        } else {
+            left_b_addr = slot_a_addr;
         }
 
         if let Some(slot_a) = slot_a {
             if let Some(slot_bb) = slot_b
                 && class_b.fast_issubclass(class_a)
+                && (slot_a_addr != left_b_addr
+                    || method_is_overloaded(
+                        class_a,
+                        class_b,
+                        op_slot.right_method_name(self),
+                        self,
+                    )?)
             {
                 let ret = slot_bb(a, b, c, self)?;
                 if !ret.is(&self.ctx.not_implemented) {
@@ -485,7 +535,7 @@ impl VirtualMachine {
             This returns the bitwise inversion of the underlying int object and is usually not what you expect from negating a bool. \
             Use the 'not' operator for boolean negation or ~int(x) if you really want the bitwise inversion of the underlying int.";
         if a.fast_isinstance(self.ctx.types.bool_type) {
-            warnings::warn(
+            _warnings::warn(
                 self.ctx.exceptions.deprecation_warning,
                 STR.to_owned(),
                 1,
diff --git a/crates/vm/src/warn.rs b/crates/vm/src/warn.rs
index 3ec75090b4e..0bae7a9619a 100644
--- a/crates/vm/src/warn.rs
+++ b/crates/vm/src/warn.rs
@@ -1,27 +1,67 @@
 use crate::{
     AsObject, Context, Py, PyObject, PyObjectRef, PyResult, VirtualMachine,
     builtins::{
-        PyDictRef, PyListRef, PyStr, PyStrInterned, PyStrRef, PyTuple, PyTupleRef, PyTypeRef,
+        PyBaseExceptionRef, PyDictRef, PyListRef, PyStr, PyStrInterned, PyStrRef, PyTuple,
+        PyTupleRef, PyTypeRef,
     },
-    convert::{IntoObject, TryFromObject},
-    types::PyComparisonOp,
+    convert::TryFromObject,
 };
+use core::sync::atomic::{AtomicUsize, Ordering};
+use rustpython_common::lock::OnceCell;
 
 pub struct WarningsState {
-    filters: PyListRef,
-    _once_registry: PyDictRef,
-    default_action: PyStrRef,
-    filters_version: usize,
+    pub filters: PyListRef,
+    pub once_registry: PyDictRef,
+    pub default_action: PyStrRef,
+    pub filters_version: AtomicUsize,
+    pub context_var: OnceCell<PyObjectRef>,
+    lock_count: AtomicUsize,
 }
 
 impl WarningsState {
-    fn create_filter(ctx: &Context) -> PyListRef {
+    fn create_default_filters(ctx: &Context) -> PyListRef {
+        // init_filters(): non-debug default filter set.
         ctx.new_list(vec![
             ctx.new_tuple(vec![
+                ctx.new_str("default").into(),
+                ctx.none(),
+                ctx.exceptions.deprecation_warning.as_object().to_owned(),
                 ctx.new_str("__main__").into(),
-                ctx.types.none_type.as_object().to_owned(),
-                ctx.exceptions.warning.as_object().to_owned(),
-                ctx.new_str("ACTION").into(),
+                ctx.new_int(0).into(),
+            ])
+            .into(),
+            ctx.new_tuple(vec![
+                ctx.new_str("ignore").into(),
+                ctx.none(),
+                ctx.exceptions.deprecation_warning.as_object().to_owned(),
+                ctx.none(),
+                ctx.new_int(0).into(),
+            ])
+            .into(),
+            ctx.new_tuple(vec![
+                ctx.new_str("ignore").into(),
+                ctx.none(),
+                ctx.exceptions
+                    .pending_deprecation_warning
+                    .as_object()
+                    .to_owned(),
+                ctx.none(),
+                ctx.new_int(0).into(),
+            ])
+            .into(),
+            ctx.new_tuple(vec![
+                ctx.new_str("ignore").into(),
+                ctx.none(),
+                ctx.exceptions.import_warning.as_object().to_owned(),
+                ctx.none(),
+                ctx.new_int(0).into(),
+            ])
+            .into(),
+            ctx.new_tuple(vec![
+                ctx.new_str("ignore").into(),
+                ctx.none(),
+                ctx.exceptions.resource_warning.as_object().to_owned(),
+                ctx.none(),
                 ctx.new_int(0).into(),
             ])
             .into(),
@@ -30,25 +70,44 @@ impl WarningsState {
 
     pub fn init_state(ctx: &Context) -> Self {
         Self {
-            filters: Self::create_filter(ctx),
-            _once_registry: ctx.new_dict(),
+            filters: Self::create_default_filters(ctx),
+            once_registry: ctx.new_dict(),
             default_action: ctx.new_str("default"),
-            filters_version: 0,
+            filters_version: AtomicUsize::new(0),
+            context_var: OnceCell::new(),
+            lock_count: AtomicUsize::new(0),
         }
     }
+
+    pub fn acquire_lock(&self) {
+        self.lock_count.fetch_add(1, Ordering::SeqCst);
+    }
+
+    pub fn release_lock(&self) -> bool {
+        let prev = self.lock_count.load(Ordering::SeqCst);
+        if prev == 0 {
+            return false;
+        }
+        self.lock_count.fetch_sub(1, Ordering::SeqCst);
+        true
+    }
+
+    pub fn filters_mutated(&self) {
+        self.filters_version.fetch_add(1, Ordering::SeqCst);
+    }
 }
 
+/// None matches everything; plain strings do exact comparison;
+/// regex objects use .match().
 fn check_matched(obj: &PyObject, arg: &PyObject, vm: &VirtualMachine) -> PyResult<bool> {
-    if obj.class().is(vm.ctx.types.none_type) {
+    if vm.is_none(obj) {
         return Ok(true);
     }
-
-    if obj.rich_compare_bool(arg, PyComparisonOp::Eq, vm)? {
-        return Ok(false);
+    if obj.class().is(vm.ctx.types.str_type) {
+        return obj.rich_compare_bool(arg, crate::types::PyComparisonOp::Eq, vm);
     }
-
-    let result = obj.call((arg.to_owned(),), vm);
-    Ok(result.is_ok())
+    let result = vm.call_method(obj, "match", (arg.to_owned(),))?;
+    result.is_true(vm)
 }
 
 fn get_warnings_attr(
@@ -67,8 +126,6 @@ fn get_warnings_attr(
             Err(_) => return Ok(None),
         }
     } else {
-        // 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,
@@ -77,151 +134,207 @@ fn get_warnings_attr(
             Err(_) => return Ok(None),
         }
     };
-    Ok(Some(module.get_attr(attr_name, vm)?))
+    match module.get_attr(attr_name, vm) {
+        Ok(attr) => Ok(Some(attr)),
+        Err(_) => Ok(None),
+    }
 }
 
-pub fn warn(
-    message: PyStrRef,
-    category: Option<PyTypeRef>,
-    stack_level: isize,
-    source: Option<PyObjectRef>,
-    vm: &VirtualMachine,
-) -> PyResult<()> {
-    let (filename, lineno, module, registry) = setup_context(stack_level, vm)?;
-    warn_explicit(
-        category, message, filename, lineno, module, registry, None, source, vm,
-    )
+/// Get the warnings filters list from sys.modules['warnings'].filters,
+/// falling back to vm.state.warnings.filters.
+fn get_warnings_filters(vm: &VirtualMachine) -> PyResult<PyListRef> {
+    if let Some(filters_obj) = get_warnings_attr(vm, identifier!(&vm.ctx, filters), false)?
+        && let Ok(filters) = filters_obj.try_into_value::<PyListRef>(vm)
+    {
+        return Ok(filters);
+    }
+    Ok(vm.state.warnings.filters.clone())
 }
 
+/// Get the default action from sys.modules['warnings']._defaultaction,
+/// falling back to vm.state.warnings.default_action.
 fn get_default_action(vm: &VirtualMachine) -> PyResult<PyObjectRef> {
+    if let Some(action) = get_warnings_attr(vm, identifier!(&vm.ctx, defaultaction), false)? {
+        if !action.class().is(vm.ctx.types.str_type) {
+            return Err(vm.new_type_error(format!(
+                "_warnings.defaultaction must be a string, not '{}'",
+                action.class().name()
+            )));
+        }
+        return Ok(action);
+    }
     Ok(vm.state.warnings.default_action.clone().into())
-    // .map_err(|_| {
-    //     vm.new_value_error(format!(
-    //         "_warnings.defaultaction must be a string, not '{}'",
-    //         vm.state.warnings.default_action
-    //     ))
-    // })
 }
 
-fn get_filter(
-    category: PyObjectRef,
-    text: PyObjectRef,
-    lineno: usize,
-    module: PyObjectRef,
-    mut _item: PyTupleRef,
-    vm: &VirtualMachine,
-) -> PyResult {
-    let filters = vm.state.warnings.filters.as_object().to_owned();
-
-    let filters: PyListRef = filters
-        .try_into_value(vm)
-        .map_err(|_| vm.new_value_error("_warnings.filters must be a list"))?;
-
-    /* WarningsState.filters could change while we are iterating over it. */
-    for i in 0..filters.borrow_vec().len() {
-        let tmp_item = if let Some(tmp_item) = filters.borrow_vec().get(i).cloned() {
-            let tmp_item = PyTupleRef::try_from_object(vm, tmp_item)?;
-            (tmp_item.len() == 5).then_some(tmp_item)
-        } else {
-            None
-        }
-        .ok_or_else(|| vm.new_value_error(format!("_warnings.filters item {i} isn't a 5-tuple")))?;
-
-        /* Python code: action, msg, cat, mod, ln = item */
-        let action = if let Some(action) = tmp_item.first() {
-            action.str_utf8(vm).map(|action| action.into_object())
-        } else {
-            Err(vm.new_type_error("action must be a string"))
-        };
-
-        let good_msg = if let Some(msg) = tmp_item.get(1) {
-            check_matched(msg, &text, vm)?
-        } else {
-            false
-        };
-
-        let is_subclass = if let Some(cat) = tmp_item.get(2) {
-            category.fast_isinstance(cat.class())
-        } else {
-            false
-        };
-
-        let good_mod = if let Some(item_mod) = tmp_item.get(3) {
-            check_matched(item_mod, &module, vm)?
-        } else {
-            false
-        };
-
-        let ln = tmp_item.get(4).map_or(0, |ln_obj| {
-            ln_obj.try_int(vm).map_or(0, |ln| ln.as_u32_mask() as _)
-        });
-
-        if good_msg && good_mod && is_subclass && (ln == 0 || lineno == ln) {
-            _item = tmp_item;
-            return action;
+/// Get the once registry from sys.modules['warnings']._onceregistry,
+/// falling back to vm.state.warnings.once_registry.
+fn get_once_registry(vm: &VirtualMachine) -> PyResult<PyObjectRef> {
+    if let Some(registry) = get_warnings_attr(vm, identifier!(&vm.ctx, onceregistry), false)? {
+        if !registry.class().is(vm.ctx.types.dict_type) {
+            return Err(vm.new_type_error(format!(
+                "_warnings.onceregistry must be a dict, not '{}'",
+                registry.class().name()
+            )));
         }
+        return Ok(registry);
     }
-
-    get_default_action(vm)
+    Ok(vm.state.warnings.once_registry.clone().into())
 }
 
 fn already_warned(
-    registry: PyObjectRef,
+    registry: &PyObject,
     key: PyObjectRef,
     should_set: bool,
     vm: &VirtualMachine,
 ) -> PyResult<bool> {
+    if vm.is_none(registry) {
+        return Ok(false);
+    }
+
+    let current_version = vm.state.warnings.filters_version.load(Ordering::SeqCst);
     let version_obj = registry.get_item(identifier!(&vm.ctx, version), vm).ok();
-    let filters_version = vm.ctx.new_int(vm.state.warnings.filters_version).into();
 
-    match version_obj {
-        Some(version_obj)
-            if version_obj.try_int(vm).is_ok() || version_obj.is(&filters_version) =>
+    let version_matches = version_obj.as_ref().is_some_and(|v| {
+        v.try_int(vm)
+            .map(|i| i.as_u32_mask() as usize == current_version)
+            .unwrap_or(false)
+    });
+
+    if version_matches {
+        if let Ok(val) = registry.get_item(key.as_ref(), vm)
+            && val.is_true(vm)?
         {
-            // Use .ok() to handle KeyError when key doesn't exist (like Python's dict.get())
-            if let Ok(already_warned) = registry.get_item(key.as_ref(), vm)
-                && already_warned.is_true(vm)?
-            {
-                return Ok(true);
-            }
-        }
-        _ => {
-            let registry = registry.dict();
-            if let Some(registry) = registry.as_ref() {
-                registry.clear();
-                let r = registry.set_item("version", filters_version, vm);
-                if r.is_err() {
-                    return Ok(false);
-                }
-            }
+            return Ok(true);
         }
+    } else if let Ok(dict) = PyDictRef::try_from_object(vm, registry.to_owned()) {
+        dict.clear();
+        dict.set_item(
+            identifier!(&vm.ctx, version),
+            vm.ctx.new_int(current_version).into(),
+            vm,
+        )?;
     }
 
-    /* This warning wasn't found in the registry, set it. */
-    if !should_set {
-        return Ok(false);
+    if should_set {
+        registry.set_item(key.as_ref(), vm.ctx.true_value.clone().into(), vm)?;
     }
+    Ok(false)
+}
 
-    let item = vm.ctx.true_value.clone().into();
-    let _ = registry.set_item(key.as_ref(), item, vm); // ignore set error
-    Ok(true)
+/// Create a `(text, category)` or `(text, category, 0)` key and record
+/// it in the registry via `already_warned`.
+fn update_registry(
+    registry: &PyObject,
+    text: &PyObject,
+    category: &PyObject,
+    add_zero: bool,
+    vm: &VirtualMachine,
+) -> PyResult<bool> {
+    let altkey: PyObjectRef = if add_zero {
+        PyTuple::new_ref(
+            vec![
+                text.to_owned(),
+                category.to_owned(),
+                vm.ctx.new_int(0).into(),
+            ],
+            &vm.ctx,
+        )
+        .into()
+    } else {
+        PyTuple::new_ref(vec![text.to_owned(), category.to_owned()], &vm.ctx).into()
+    };
+    already_warned(registry, altkey, true, vm)
 }
 
-fn normalize_module(filename: &Py<PyStr>, vm: &VirtualMachine) -> Option<PyObjectRef> {
-    let obj = match filename.char_len() {
+fn normalize_module(filename: &Py<PyStr>, vm: &VirtualMachine) -> PyObjectRef {
+    match filename.byte_len() {
         0 => vm.new_pyobj("<unknown>"),
         len if len >= 3 && filename.as_bytes().ends_with(b".py") => {
             vm.new_pyobj(&filename.as_wtf8()[..len - 3])
         }
         _ => filename.as_object().to_owned(),
-    };
-    Some(obj)
+    }
+}
+
+/// Search the global filters list for a matching action.
+// TODO: split into filter_search() + get_filter() and support
+//       context-aware filters (get_warnings_context_filters).
+fn get_filter(
+    category: PyObjectRef,
+    text: PyObjectRef,
+    lineno: usize,
+    module: PyObjectRef,
+    vm: &VirtualMachine,
+) -> PyResult {
+    let filters = get_warnings_filters(vm)?;
+
+    // filters could change while we are iterating over it.
+    // Re-check list length each iteration (matches C behavior).
+    let mut i = 0;
+    while i < filters.borrow_vec().len() {
+        let Some(tmp_item) = filters.borrow_vec().get(i).cloned() else {
+            break;
+        };
+        let tmp_item = PyTupleRef::try_from_object(vm, tmp_item)
+            .ok()
+            .filter(|t| t.len() == 5)
+            .ok_or_else(|| {
+                vm.new_value_error(format!("_warnings.filters item {i} isn't a 5-tuple"))
+            })?;
+
+        /* action, msg, cat, mod, ln = item */
+        let action = &tmp_item[0];
+        let good_msg = check_matched(&tmp_item[1], &text, vm)?;
+        let is_subclass = category.is_subclass(&tmp_item[2], vm)?;
+        let good_mod = check_matched(&tmp_item[3], &module, vm)?;
+        let ln: usize = tmp_item[4].try_int(vm).map_or(0, |v| v.as_u32_mask() as _);
+
+        if good_msg && is_subclass && good_mod && (ln == 0 || lineno == ln) {
+            return Ok(action.to_owned());
+        }
+        i += 1;
+    }
+
+    get_default_action(vm)
 }
 
+pub fn warn(
+    message: PyObjectRef,
+    category: Option<PyTypeRef>,
+    stack_level: isize,
+    source: Option<PyObjectRef>,
+    vm: &VirtualMachine,
+) -> PyResult<()> {
+    warn_with_skip(message, category, stack_level, source, None, vm)
+}
+
+/// do_warn: resolve context via setup_context, then call warn_explicit.
+pub fn warn_with_skip(
+    message: PyObjectRef,
+    category: Option<PyTypeRef>,
+    mut stack_level: isize,
+    source: Option<PyObjectRef>,
+    skip_file_prefixes: Option<PyTupleRef>,
+    vm: &VirtualMachine,
+) -> PyResult<()> {
+    if let Some(ref prefixes) = skip_file_prefixes
+        && !prefixes.is_empty()
+        && stack_level < 2
+    {
+        stack_level = 2;
+    }
+    let (filename, lineno, module, registry) =
+        setup_context(stack_level, skip_file_prefixes.as_ref(), vm)?;
+    warn_explicit(
+        category, message, filename, lineno, module, registry, None, source, vm,
+    )
+}
+
+/// Core warning logic matching `warn_explicit()` in `_warnings.c`.
 #[allow(clippy::too_many_arguments)]
-fn warn_explicit(
+pub(crate) fn warn_explicit(
     category: Option<PyTypeRef>,
-    message: PyStrRef,
+    message: PyObjectRef,
     filename: PyStrRef,
     lineno: usize,
     module: Option<PyObjectRef>,
@@ -230,88 +343,123 @@ fn warn_explicit(
     source: Option<PyObjectRef>,
     vm: &VirtualMachine,
 ) -> PyResult<()> {
-    let registry: PyObjectRef = registry
-        .try_into_value(vm)
-        .map_err(|_| vm.new_type_error("'registry' must be a dict or None"))?;
-
-    // Normalize module.
-    let module = match module.or_else(|| normalize_module(&filename, vm)) {
-        Some(module) => module,
-        None => return Ok(()),
-    };
+    // Normalize module. None → silent return (late-shutdown safety).
+    let module = module.unwrap_or_else(|| normalize_module(&filename, vm));
+    if vm.is_none(&module) {
+        return Ok(());
+    }
 
     // Normalize message.
-    let text = message.as_wtf8();
-
-    let category = if let Some(category) = category {
-        if !category.fast_issubclass(vm.ctx.exceptions.warning) {
-            return Err(vm.new_type_error(format!(
-                "category must be a Warning subclass, not '{}'",
-                category.class().name()
-            )));
-        }
-        category
+    let is_warning = message.fast_isinstance(vm.ctx.exceptions.warning);
+    let (text, category, message) = if is_warning {
+        let text = message.str(vm)?;
+        let cat = message.class().to_owned();
+        (text, cat, message)
     } else {
-        vm.ctx.exceptions.user_warning.to_owned()
+        // For non-Warning messages, convert to string via str()
+        let text = message.str(vm)?;
+        let cat = category.unwrap_or_else(|| vm.ctx.exceptions.user_warning.to_owned());
+        let instance = cat.as_object().call((text.clone(),), vm)?;
+        (text, cat, instance)
     };
 
-    let category = if message.fast_isinstance(vm.ctx.exceptions.warning) {
-        message.class().to_owned()
-    } else {
-        category
-    };
+    let lineno_obj: PyObjectRef = vm.ctx.new_int(lineno).into();
 
-    // Create key.
-    let key = PyTuple::new_ref(
+    // key = (text, category, lineno)
+    let key: PyObjectRef = PyTuple::new_ref(
         vec![
-            vm.ctx.new_int(3).into(),
-            vm.ctx.new_str(text).into(),
+            text.clone().into(),
             category.as_object().to_owned(),
-            vm.ctx.new_int(lineno).into(),
+            lineno_obj.clone(),
         ],
         &vm.ctx,
-    );
+    )
+    .into();
 
-    if !vm.is_none(registry.as_object()) && already_warned(registry, key.into_object(), false, vm)?
-    {
+    // Check if already warned
+    if !vm.is_none(&registry) && already_warned(&registry, key.clone(), false, vm)? {
         return Ok(());
     }
 
-    let item = vm.ctx.new_tuple(vec![]);
+    // Get filter action
     let action = get_filter(
         category.as_object().to_owned(),
-        vm.ctx.new_str(text).into(),
+        text.clone().into(),
         lineno,
         module,
-        item,
         vm,
     )?;
+    let action_str = PyStrRef::try_from_object(vm, action)
+        .map_err(|_| vm.new_type_error("action must be a string"))?;
 
-    if action.str_utf8(vm)?.as_str().eq("error") {
-        return Err(vm.new_type_error(message.to_string()));
+    if action_str.as_bytes() == b"error" {
+        let exc = PyBaseExceptionRef::try_from_object(vm, message)?;
+        return Err(exc);
     }
+    if action_str.as_bytes() == b"ignore" {
+        return Ok(());
+    }
+
+    // For everything except "always"/"all", record in registry then
+    // check per-action registries.
+    let already = if action_str.as_wtf8() != "always" && action_str.as_wtf8() != "all" {
+        if !vm.is_none(&registry) {
+            registry.set_item(&*key, vm.ctx.true_value.clone().into(), vm)?;
+        }
 
-    if action.str_utf8(vm)?.as_str().eq("ignore") {
+        let action_s = action_str.to_str();
+        match action_s {
+            Some("once") => {
+                let reg = if vm.is_none(&registry) {
+                    get_once_registry(vm)?
+                } else {
+                    registry.clone()
+                };
+                update_registry(&reg, text.as_ref(), category.as_object(), false, vm)?
+            }
+            Some("module") => {
+                if !vm.is_none(&registry) {
+                    update_registry(&registry, text.as_ref(), category.as_object(), false, vm)?
+                } else {
+                    false
+                }
+            }
+            Some("default") => false,
+            _ => {
+                return Err(vm.new_runtime_error(format!(
+                    "Unrecognized action ({action_str}) in warnings.filters:\n {action_str}"
+                )));
+            }
+        }
+    } else {
+        false
+    };
+
+    if already {
         return Ok(());
     }
 
     call_show_warning(
-        // t_state,
         category,
+        text,
         message,
         filename,
-        lineno, // lineno_obj,
+        lineno,
+        lineno_obj,
         source_line,
         source,
         vm,
     )
 }
 
+#[allow(clippy::too_many_arguments)]
 fn call_show_warning(
     category: PyTypeRef,
-    message: PyStrRef,
+    text: PyStrRef,
+    message: PyObjectRef,
     filename: PyStrRef,
     lineno: usize,
+    lineno_obj: PyObjectRef,
     source_line: Option<PyObjectRef>,
     source: Option<PyObjectRef>,
     vm: &VirtualMachine,
@@ -319,26 +467,22 @@ fn call_show_warning(
     let Some(show_fn) =
         get_warnings_attr(vm, identifier!(&vm.ctx, _showwarnmsg), source.is_some())?
     else {
-        return show_warning(filename, lineno, message, category, source_line, vm);
+        return show_warning(filename, lineno, text, category, source_line, vm);
     };
     if !show_fn.is_callable() {
         return Err(vm.new_type_error("warnings._showwarnmsg() must be set to a callable"));
     }
     let Some(warnmsg_cls) = get_warnings_attr(vm, identifier!(&vm.ctx, WarningMessage), false)?
     else {
-        return Err(vm.new_type_error("unable to get warnings.WarningMessage"));
+        return Err(vm.new_runtime_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![
-            warning_instance,
+            message,
             category.into(),
             filename.into(),
-            vm.new_pyobj(lineno),
+            lineno_obj,
             vm.ctx.none(),
             vm.ctx.none(),
             vm.unwrap_or_none(source),
@@ -350,62 +494,90 @@ fn call_show_warning(
 }
 
 fn show_warning(
-    _filename: PyStrRef,
-    _lineno: usize,
+    filename: PyStrRef,
+    lineno: usize,
     text: PyStrRef,
     category: PyTypeRef,
     _source_line: Option<PyObjectRef>,
     vm: &VirtualMachine,
 ) -> PyResult<()> {
     let stderr = crate::stdlib::sys::PyStderr(vm);
-    writeln!(stderr, "{}: {}", category.name(), text);
+    writeln!(
+        stderr,
+        "{}:{}: {}: {}",
+        filename,
+        lineno,
+        category.name(),
+        text
+    );
     Ok(())
 }
 
+/// Check if a frame's filename starts with any of the given prefixes.
+fn is_filename_to_skip(frame: &crate::frame::Frame, prefixes: &PyTupleRef) -> bool {
+    let filename = frame.f_code().co_filename();
+    let filename_bytes = filename.as_bytes();
+    prefixes.iter().any(|prefix| {
+        prefix
+            .downcast_ref::<PyStr>()
+            .is_some_and(|s| filename_bytes.starts_with(s.as_bytes()))
+    })
+}
+
+/// Like Frame::next_external_frame but also skips frames matching prefixes.
+fn next_external_frame_with_skip(
+    frame: &crate::frame::FrameRef,
+    skip_file_prefixes: Option<&PyTupleRef>,
+    vm: &VirtualMachine,
+) -> Option<crate::frame::FrameRef> {
+    let mut f = frame.f_back(vm);
+    loop {
+        let current: crate::frame::FrameRef = f.take()?;
+        if current.is_internal_frame()
+            || skip_file_prefixes.is_some_and(|p| is_filename_to_skip(&current, p))
+        {
+            f = current.f_back(vm);
+        } else {
+            return Some(current);
+        }
+    }
+}
+
 /// filename, module, and registry are new refs, globals is borrowed
 /// Returns `Ok` on success, or `Err` on error (no new refs)
 fn setup_context(
     mut stack_level: isize,
+    skip_file_prefixes: Option<&PyTupleRef>,
     vm: &VirtualMachine,
-) -> PyResult<
-    // filename, lineno, module, registry
-    (PyStrRef, usize, Option<PyObjectRef>, PyObjectRef),
-> {
-    let __warningregistry__ = "__warningregistry__";
-    let __name__ = "__name__";
-
-    let mut f = vm.current_frame().as_deref().cloned();
+) -> PyResult<(PyStrRef, usize, Option<PyObjectRef>, PyObjectRef)> {
+    let mut f = vm.current_frame();
 
     // Stack level comparisons to Python code is off by one as there is no
     // warnings-related stack level to avoid.
     if stack_level <= 0 || f.as_ref().is_some_and(|frame| frame.is_internal_frame()) {
-        loop {
+        while {
             stack_level -= 1;
-            if stack_level <= 0 {
-                break;
-            }
-            if let Some(tmp) = f {
-                f = tmp.f_back(vm);
-            } else {
-                break;
+            stack_level > 0
+        } {
+            match f {
+                Some(tmp) => f = tmp.f_back(vm),
+                None => break,
             }
         }
     } else {
-        loop {
+        while {
             stack_level -= 1;
-            if stack_level <= 0 {
-                break;
-            }
-            if let Some(tmp) = f {
-                f = tmp.next_external_frame(vm);
-            } else {
-                break;
+            stack_level > 0
+        } {
+            match f {
+                Some(tmp) => f = next_external_frame_with_skip(&tmp, skip_file_prefixes, vm),
+                None => break,
             }
         }
     }
 
     let (globals, filename, lineno) = if let Some(f) = f {
-        (f.globals.clone(), f.code.source_path, f.f_lineno())
+        (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)
@@ -422,17 +594,18 @@ fn setup_context(
         (globals, vm.ctx.intern_str("<sys>"), 0)
     };
 
-    let registry = if let Ok(registry) = globals.get_item(__warningregistry__, vm) {
-        registry
-    } else {
-        let registry = vm.ctx.new_dict();
-        globals.set_item(__warningregistry__, registry.clone().into(), vm)?;
-        registry.into()
+    let registry = match globals.get_item("__warningregistry__", vm) {
+        Ok(r) => r,
+        Err(_) => {
+            let r = vm.ctx.new_dict();
+            globals.set_item("__warningregistry__", r.clone().into(), vm)?;
+            r.into()
+        }
     };
 
     // Setup module.
     let module = globals
-        .get_item(__name__, vm)
+        .get_item("__name__", vm)
         .unwrap_or_else(|_| vm.new_pyobj("<string>"));
     Ok((filename.to_owned(), lineno, Some(module), registry))
 }
diff --git a/crates/vm/src/windows.rs b/crates/vm/src/windows.rs
index ff2b612c06d..ec9ac8f18fb 100644
--- a/crates/vm/src/windows.rs
+++ b/crates/vm/src/windows.rs
@@ -61,7 +61,7 @@ impl<T: WindowsSysResultValue> ToPyResult for WindowsSysResult<T> {
     }
 }
 
-type HandleInt = usize; // TODO: change to isize when fully ported to windows-rs
+type HandleInt = isize;
 
 impl TryFromObject for WinHandle {
     fn try_from_object(vm: &VirtualMachine, obj: PyObjectRef) -> PyResult<Self> {
@@ -79,7 +79,7 @@ impl ToPyObject for WinHandle {
 pub fn init_winsock() {
     static WSA_INIT: parking_lot::Once = parking_lot::Once::new();
     WSA_INIT.call_once(|| unsafe {
-        let mut wsa_data = std::mem::MaybeUninit::uninit();
+        let mut wsa_data = core::mem::MaybeUninit::uninit();
         let _ = windows_sys::Win32::Networking::WinSock::WSAStartup(0x0101, wsa_data.as_mut_ptr());
     })
 }
@@ -244,7 +244,7 @@ fn attributes_from_dir(
     };
 
     let wide: Vec<u16> = path.to_wide_with_nul();
-    let mut find_data: WIN32_FIND_DATAW = unsafe { std::mem::zeroed() };
+    let mut find_data: WIN32_FIND_DATAW = unsafe { core::mem::zeroed() };
 
     let handle = unsafe { FindFirstFileW(wide.as_ptr(), &mut find_data) };
     if handle == INVALID_HANDLE_VALUE {
@@ -252,7 +252,7 @@ fn attributes_from_dir(
     }
     unsafe { FindClose(handle) };
 
-    let mut info: BY_HANDLE_FILE_INFORMATION = unsafe { std::mem::zeroed() };
+    let mut info: BY_HANDLE_FILE_INFORMATION = unsafe { core::mem::zeroed() };
     info.dwFileAttributes = find_data.dwFileAttributes;
     info.ftCreationTime = find_data.ftCreationTime;
     info.ftLastAccessTime = find_data.ftLastAccessTime;
@@ -304,11 +304,11 @@ fn win32_xstat_slow_impl(path: &OsStr, traverse: bool) -> std::io::Result<StatSt
             core::ptr::null(),
             OPEN_EXISTING,
             flags,
-            std::ptr::null_mut(),
+            core::ptr::null_mut(),
         )
     };
 
-    let mut file_info: BY_HANDLE_FILE_INFORMATION = unsafe { std::mem::zeroed() };
+    let mut file_info: BY_HANDLE_FILE_INFORMATION = unsafe { core::mem::zeroed() };
     let mut tag_info = FileAttributeTagInfo::default();
     let mut is_unhandled_tag = false;
 
@@ -340,7 +340,7 @@ fn win32_xstat_slow_impl(path: &OsStr, traverse: bool) -> std::io::Result<StatSt
                         core::ptr::null(),
                         OPEN_EXISTING,
                         flags,
-                        std::ptr::null_mut(),
+                        core::ptr::null_mut(),
                     )
                 };
                 if h_file == INVALID_HANDLE_VALUE {
@@ -358,7 +358,7 @@ fn win32_xstat_slow_impl(path: &OsStr, traverse: bool) -> std::io::Result<StatSt
                         core::ptr::null(),
                         OPEN_EXISTING,
                         flags | FILE_FLAG_OPEN_REPARSE_POINT,
-                        std::ptr::null_mut(),
+                        core::ptr::null_mut(),
                     )
                 };
                 if h_file == INVALID_HANDLE_VALUE {
@@ -400,13 +400,13 @@ fn win32_xstat_slow_impl(path: &OsStr, traverse: bool) -> std::io::Result<StatSt
 
             // Query the reparse tag
             if !traverse || is_unhandled_tag {
-                let mut local_tag_info: FileAttributeTagInfo = unsafe { std::mem::zeroed() };
+                let mut local_tag_info: FileAttributeTagInfo = unsafe { core::mem::zeroed() };
                 let ret = unsafe {
                     GetFileInformationByHandleEx(
                         h_file,
                         FileAttributeTagInfo,
                         &mut local_tag_info as *mut _ as *mut _,
-                        std::mem::size_of::<FileAttributeTagInfo>() as u32,
+                        core::mem::size_of::<FileAttributeTagInfo>() as u32,
                     )
                 };
                 if ret == 0 {
@@ -453,24 +453,24 @@ fn win32_xstat_slow_impl(path: &OsStr, traverse: bool) -> std::io::Result<StatSt
             }
 
             // Get FILE_BASIC_INFO
-            let mut basic_info: FILE_BASIC_INFO = unsafe { std::mem::zeroed() };
+            let mut basic_info: FILE_BASIC_INFO = unsafe { core::mem::zeroed() };
             let has_basic_info = unsafe {
                 GetFileInformationByHandleEx(
                     h_file,
                     FileBasicInfo,
                     &mut basic_info as *mut _ as *mut _,
-                    std::mem::size_of::<FILE_BASIC_INFO>() as u32,
+                    core::mem::size_of::<FILE_BASIC_INFO>() as u32,
                 )
             } != 0;
 
             // Get FILE_ID_INFO (optional)
-            let mut id_info: FILE_ID_INFO = unsafe { std::mem::zeroed() };
+            let mut id_info: FILE_ID_INFO = unsafe { core::mem::zeroed() };
             let has_id_info = unsafe {
                 GetFileInformationByHandleEx(
                     h_file,
                     FileIdInfo,
                     &mut id_info as *mut _ as *mut _,
-                    std::mem::size_of::<FILE_ID_INFO>() as u32,
+                    core::mem::size_of::<FILE_ID_INFO>() as u32,
                 )
             } != 0;
 
diff --git a/crates/wasm/Cargo.toml b/crates/wasm/Cargo.toml
index a2bb1a9f948..a285dcabda9 100644
--- a/crates/wasm/Cargo.toml
+++ b/crates/wasm/Cargo.toml
@@ -23,8 +23,6 @@ rustpython-stdlib = { workspace = true, default-features = false, optional = tru
 # make sure no threading! otherwise wasm build will fail
 rustpython-vm = { workspace = true, features = ["compiler", "encodings", "serde", "wasmbind"] }
 
-ruff_python_parser = { workspace = true }
-
 serde = { workspace = true }
 wasm-bindgen = { workspace = true }
 
@@ -48,3 +46,6 @@ wasm-opt = false#["-O1"]
 
 [lints]
 workspace = true
+
+[package.metadata.cargo-shear]
+ignored = ["serde", "rustpython-common"]
diff --git a/crates/wasm/src/browser_module.rs b/crates/wasm/src/browser_module.rs
index d1eecce28a9..59ca55f45c7 100644
--- a/crates/wasm/src/browser_module.rs
+++ b/crates/wasm/src/browser_module.rs
@@ -64,22 +64,19 @@ mod _browser {
         } = args;
 
         let response_format = match response_format {
-            Some(s) => FetchResponseFormat::from_str(vm, s.as_str())?,
+            Some(s) => FetchResponseFormat::from_str(vm, s.expect_str())?,
             None => FetchResponseFormat::Text,
         };
 
         let opts = web_sys::RequestInit::new();
 
-        match method {
-            Some(s) => opts.set_method(s.as_str()),
-            None => opts.set_method("GET"),
-        };
+        opts.set_method(method.as_ref().map_or("GET", |s| s.expect_str()));
 
         if let Some(body) = body {
             opts.set_body(&convert::py_to_js(vm, body));
         }
 
-        let request = web_sys::Request::new_with_str_and_init(url.as_str(), &opts)
+        let request = web_sys::Request::new_with_str_and_init(url.expect_str(), &opts)
             .map_err(|err| convert::js_py_typeerror(vm, err))?;
 
         if let Some(headers) = headers {
@@ -87,7 +84,7 @@ mod _browser {
             for (key, value) in headers {
                 let key = key.str(vm)?;
                 let value = value.str(vm)?;
-                h.set(key.as_str(), value.as_str())
+                h.set(key.expect_str(), value.expect_str())
                     .map_err(|err| convert::js_py_typeerror(vm, err))?;
             }
         }
@@ -95,7 +92,7 @@ mod _browser {
         if let Some(content_type) = content_type {
             request
                 .headers()
-                .set("Content-Type", content_type.as_str())
+                .set("Content-Type", content_type.expect_str())
                 .map_err(|err| convert::js_py_typeerror(vm, err))?;
         }
 
@@ -171,7 +168,7 @@ mod _browser {
         fn query(&self, query: PyStrRef, vm: &VirtualMachine) -> PyResult {
             let elem = self
                 .doc
-                .query_selector(query.as_str())
+                .query_selector(query.expect_str())
                 .map_err(|err| convert::js_py_typeerror(vm, err))?
                 .map(|elem| Element { elem })
                 .to_pyobject(vm);
@@ -180,12 +177,12 @@ mod _browser {
     }
 
     #[pyattr]
-    fn document(vm: &VirtualMachine) -> PyRef<Document> {
+    fn document(_vm: &VirtualMachine) -> PyRef<Document> {
         PyRef::new_ref(
             Document {
                 doc: window().document().expect("Document missing from window"),
             },
-            Document::make_class(&vm.ctx),
+            Document::make_static_type(),
             None,
         )
     }
@@ -206,7 +203,7 @@ mod _browser {
             default: OptionalArg<PyObjectRef>,
             vm: &VirtualMachine,
         ) -> PyObjectRef {
-            match self.elem.get_attribute(attr.as_str()) {
+            match self.elem.get_attribute(attr.expect_str()) {
                 Some(s) => vm.ctx.new_str(s).into(),
                 None => default.unwrap_or_none(vm),
             }
@@ -215,7 +212,7 @@ mod _browser {
         #[pymethod]
         fn set_attr(&self, attr: PyStrRef, value: PyStrRef, vm: &VirtualMachine) -> PyResult<()> {
             self.elem
-                .set_attribute(attr.as_str(), value.as_str())
+                .set_attribute(attr.expect_str(), value.expect_str())
                 .map_err(|err| convert::js_py_typeerror(vm, err))
         }
     }
@@ -227,7 +224,7 @@ mod _browser {
         let opts = web_sys::RequestInit::new();
         opts.set_method("GET");
 
-        let request = web_sys::Request::new_with_str_and_init(path.as_str(), &opts)
+        let request = web_sys::Request::new_with_str_and_init(path.expect_str(), &opts)
             .map_err(|err| convert::js_py_typeerror(vm, err))?;
 
         let window = window();
@@ -244,7 +241,7 @@ mod _browser {
                 .expect("that the vm is valid when the promise resolves");
             stored_vm.interp.enter(move |vm| {
                 let resp_text = text.as_string().unwrap();
-                let res = import_source(vm, module.as_str(), &resp_text);
+                let res = import_source(vm, module.expect_str(), &resp_text);
                 match res {
                     Ok(_) => Ok(JsValue::null()),
                     Err(err) => Err(convert::py_err_to_js_err(vm, &err)),
diff --git a/crates/wasm/src/convert.rs b/crates/wasm/src/convert.rs
index f84b0d46239..bbf263975f3 100644
--- a/crates/wasm/src/convert.rs
+++ b/crates/wasm/src/convert.rs
@@ -49,14 +49,22 @@ pub fn py_err_to_js_err(vm: &VirtualMachine, py_err: &Py<PyBaseException>) -> Js
                 serde_wasm_bindgen::to_value(&exceptions::SerializeException::new(vm, py_err));
             match res {
                 Ok(err_info) => PyError::new(err_info).into(),
-                Err(e) => e.into(),
+                Err(_) => {
+                    // Fallback: create a basic JS Error with the exception type and message
+                    let exc_type = py_err.class().name().to_string();
+                    let msg = match py_err.as_object().str(vm) {
+                        Ok(s) => format!("{exc_type}: {s}"),
+                        Err(_) => exc_type,
+                    };
+                    js_sys::Error::new(&msg).into()
+                }
             }
         }
     }
 }
 
 pub fn js_py_typeerror(vm: &VirtualMachine, js_err: JsValue) -> PyBaseExceptionRef {
-    let msg = js_err.unchecked_into::<js_sys::Error>().to_string();
+    let msg: String = js_err.unchecked_into::<js_sys::Error>().to_string().into();
     vm.new_type_error(msg)
 }
 
@@ -70,11 +78,11 @@ pub fn js_err_to_py_err(vm: &VirtualMachine, js_err: &JsValue) -> PyBaseExceptio
                 _ => vm.ctx.exceptions.exception_type,
             }
             .to_owned();
-            vm.new_exception_msg(exc_type, err.message().into())
+            vm.new_exception_msg(exc_type, String::from(err.message()).into())
         }
         None => vm.new_exception_msg(
             vm.ctx.exceptions.exception_type.to_owned(),
-            format!("{js_err:?}"),
+            format!("{js_err:?}").into(),
         ),
     }
 }
diff --git a/crates/wasm/src/js_module.rs b/crates/wasm/src/js_module.rs
index 750e85994a1..314e2adbee0 100644
--- a/crates/wasm/src/js_module.rs
+++ b/crates/wasm/src/js_module.rs
@@ -83,7 +83,7 @@ mod _js {
     impl JsProperty {
         fn into_js_value(self) -> JsValue {
             match self {
-                JsProperty::Str(s) => s.as_str().into(),
+                JsProperty::Str(s) => s.expect_str().into(),
                 JsProperty::Js(value) => value.value.clone(),
             }
         }
@@ -109,7 +109,7 @@ mod _js {
 
         #[pymethod]
         fn new_from_str(&self, s: PyStrRef) -> PyJsValue {
-            PyJsValue::new(s.as_str())
+            PyJsValue::new(s.expect_str())
         }
 
         #[pymethod]
diff --git a/crates/wasm/src/vm_class.rs b/crates/wasm/src/vm_class.rs
index c6f1318e692..0657b0bc08e 100644
--- a/crates/wasm/src/vm_class.rs
+++ b/crates/wasm/src/vm_class.rs
@@ -8,7 +8,7 @@ use core::cell::RefCell;
 use js_sys::{Object, TypeError};
 use rustpython_vm::{
     Interpreter, PyObjectRef, PyRef, PyResult, Settings, VirtualMachine, builtins::PyWeak,
-    compiler::Mode, scope::Scope,
+    compiler::Mode, function::ArgMapping, scope::Scope,
 };
 use std::collections::HashMap;
 use wasm_bindgen::prelude::*;
@@ -59,7 +59,7 @@ impl StoredVirtualMachine {
             let browser_def = browser_module::module_def(&builder.ctx);
             builder = builder
                 .add_native_modules(&[window_def, browser_def])
-                .add_frozen_modules(rustpython_vm::py_freeze!(dir = "Lib"));
+                .add_frozen_modules(rustpython_vm::py_freeze!(dir = "../Lib"));
         }
 
         let interp = builder
@@ -275,8 +275,14 @@ impl WASMVirtualMachine {
                 }
             }
 
-            vm.run_code_obj(code, Scope::new(None, attrs.clone()))
-                .into_js(vm)?;
+            vm.run_code_obj(
+                code,
+                Scope::new(
+                    Some(ArgMapping::from_dict_exact(attrs.clone())),
+                    attrs.clone(),
+                ),
+            )
+            .into_js(vm)?;
 
             let module = vm.new_module(&name, attrs, None);
 
diff --git a/crates/wasm/src/wasm_builtins.rs b/crates/wasm/src/wasm_builtins.rs
index 79423fc250e..efbc03c39ce 100644
--- a/crates/wasm/src/wasm_builtins.rs
+++ b/crates/wasm/src/wasm_builtins.rs
@@ -33,7 +33,7 @@ pub fn make_stdout_object(
         "write",
         cls,
         move |_self: PyObjectRef, data: PyStrRef, vm: &VirtualMachine| -> PyResult<()> {
-            write_f(data.as_str(), vm)
+            write_f(data.expect_str(), vm)
         },
     );
     let flush_method = vm.new_method("flush", cls, |_self: PyObjectRef| {});
diff --git a/crates/wtf8/src/concat.rs b/crates/wtf8/src/concat.rs
new file mode 100644
index 00000000000..055a401d69f
--- /dev/null
+++ b/crates/wtf8/src/concat.rs
@@ -0,0 +1,143 @@
+use alloc::borrow::{Cow, ToOwned};
+use alloc::boxed::Box;
+use alloc::string::String;
+use core::fmt;
+use fmt::Write;
+
+use crate::{CodePoint, Wtf8, Wtf8Buf};
+
+impl fmt::Write for Wtf8Buf {
+    #[inline]
+    fn write_str(&mut self, s: &str) -> fmt::Result {
+        self.push_str(s);
+        Ok(())
+    }
+}
+
+/// Trait for types that can be appended to a [`Wtf8Buf`], preserving surrogates.
+pub trait Wtf8Concat {
+    fn fmt_wtf8(&self, buf: &mut Wtf8Buf);
+}
+
+impl Wtf8Concat for Wtf8 {
+    #[inline]
+    fn fmt_wtf8(&self, buf: &mut Wtf8Buf) {
+        buf.push_wtf8(self);
+    }
+}
+
+impl Wtf8Concat for Wtf8Buf {
+    #[inline]
+    fn fmt_wtf8(&self, buf: &mut Wtf8Buf) {
+        buf.push_wtf8(self);
+    }
+}
+
+impl Wtf8Concat for str {
+    #[inline]
+    fn fmt_wtf8(&self, buf: &mut Wtf8Buf) {
+        buf.push_str(self);
+    }
+}
+
+impl Wtf8Concat for String {
+    #[inline]
+    fn fmt_wtf8(&self, buf: &mut Wtf8Buf) {
+        buf.push_str(self);
+    }
+}
+
+impl Wtf8Concat for char {
+    #[inline]
+    fn fmt_wtf8(&self, buf: &mut Wtf8Buf) {
+        buf.push_char(*self);
+    }
+}
+
+impl Wtf8Concat for CodePoint {
+    #[inline]
+    fn fmt_wtf8(&self, buf: &mut Wtf8Buf) {
+        buf.push(*self);
+    }
+}
+
+/// Wrapper that appends a [`fmt::Display`] value to a [`Wtf8Buf`].
+///
+/// Note: This goes through UTF-8 formatting, so lone surrogates in the
+/// display output will be replaced with U+FFFD. Use direct [`Wtf8Concat`]
+/// impls for surrogate-preserving concatenation.
+#[allow(dead_code)]
+pub struct DisplayAsWtf8<T>(pub T);
+
+impl<T: fmt::Display> Wtf8Concat for DisplayAsWtf8<T> {
+    #[inline]
+    fn fmt_wtf8(&self, buf: &mut Wtf8Buf) {
+        write!(buf, "{}", self.0).unwrap();
+    }
+}
+
+macro_rules! impl_wtf8_concat_for_int {
+    ($($t:ty),*) => {
+        $(impl Wtf8Concat for $t {
+            #[inline]
+            fn fmt_wtf8(&self, buf: &mut Wtf8Buf) {
+                write!(buf, "{}", self).unwrap();
+            }
+        })*
+    };
+}
+
+impl_wtf8_concat_for_int!(
+    u8, u16, u32, u64, u128, usize, i8, i16, i32, i64, i128, isize, f32, f64
+);
+
+impl<T: Wtf8Concat + ?Sized> Wtf8Concat for &T {
+    #[inline]
+    fn fmt_wtf8(&self, buf: &mut Wtf8Buf) {
+        (**self).fmt_wtf8(buf);
+    }
+}
+
+impl<T: Wtf8Concat + ?Sized> Wtf8Concat for &mut T {
+    #[inline]
+    fn fmt_wtf8(&self, buf: &mut Wtf8Buf) {
+        (**self).fmt_wtf8(buf);
+    }
+}
+
+impl<T: Wtf8Concat + ?Sized> Wtf8Concat for Box<T> {
+    #[inline]
+    fn fmt_wtf8(&self, buf: &mut Wtf8Buf) {
+        (**self).fmt_wtf8(buf);
+    }
+}
+
+impl<T: Wtf8Concat + ?Sized> Wtf8Concat for Cow<'_, T>
+where
+    T: ToOwned,
+{
+    #[inline]
+    fn fmt_wtf8(&self, buf: &mut Wtf8Buf) {
+        (**self).fmt_wtf8(buf);
+    }
+}
+
+/// Concatenate values into a [`Wtf8Buf`], preserving surrogates.
+///
+/// Each argument must implement [`Wtf8Concat`]. String literals (`&str`),
+/// [`Wtf8`], [`Wtf8Buf`], [`char`], and [`CodePoint`] are all supported.
+///
+/// ```
+/// use rustpython_wtf8::Wtf8Buf;
+/// let name = "world";
+/// let result = rustpython_wtf8::wtf8_concat!("hello, ", name, "!");
+/// assert_eq!(result, Wtf8Buf::from("hello, world!"));
+/// ```
+#[macro_export]
+macro_rules! wtf8_concat {
+    ($($arg:expr),* $(,)?) => {{
+        let mut buf = $crate::Wtf8Buf::new();
+        $($crate::Wtf8Concat::fmt_wtf8(&$arg, &mut buf);)*
+        buf
+    }};
+}
diff --git a/crates/wtf8/src/core_str_count.rs b/crates/wtf8/src/core_str_count.rs
index f02f0a5708d..8f9d5585bc7 100644
--- a/crates/wtf8/src/core_str_count.rs
+++ b/crates/wtf8/src/core_str_count.rs
@@ -60,7 +60,7 @@ fn do_count_chars(s: &Wtf8) -> usize {
         // a subset of the sum of this chunk, like a `[u8; size_of::<usize>()]`.
         let mut counts = 0;
 
-        let (unrolled_chunks, remainder) = slice_as_chunks::<_, UNROLL_INNER>(chunk);
+        let (unrolled_chunks, remainder) = chunk.as_chunks::<UNROLL_INNER>();
         for unrolled in unrolled_chunks {
             for &word in unrolled {
                 // Because `CHUNK_SIZE` is < 256, this addition can't cause the
@@ -137,26 +137,6 @@ const fn usize_repeat_u16(x: u16) -> usize {
     }
     r
 }
-
-fn slice_as_chunks<T, const N: usize>(slice: &[T]) -> (&[[T; N]], &[T]) {
-    assert!(N != 0, "chunk size must be non-zero");
-    let len_rounded_down = slice.len() / N * N;
-    // SAFETY: The rounded-down value is always the same or smaller than the
-    // original length, and thus must be in-bounds of the slice.
-    let (multiple_of_n, remainder) = unsafe { slice.split_at_unchecked(len_rounded_down) };
-    // SAFETY: We already panicked for zero, and ensured by construction
-    // that the length of the subslice is a multiple of N.
-    let array_slice = unsafe { slice_as_chunks_unchecked(multiple_of_n) };
-    (array_slice, remainder)
-}
-
-unsafe fn slice_as_chunks_unchecked<T, const N: usize>(slice: &[T]) -> &[[T; N]] {
-    let new_len = slice.len() / N;
-    // SAFETY: We cast a slice of `new_len * N` elements into
-    // a slice of `new_len` many `N` elements chunks.
-    unsafe { std::slice::from_raw_parts(slice.as_ptr().cast(), new_len) }
-}
-
 const fn unlikely(x: bool) -> bool {
     x
 }
diff --git a/crates/wtf8/src/lib.rs b/crates/wtf8/src/lib.rs
index 01deb61f19b..772a2879944 100644
--- a/crates/wtf8/src/lib.rs
+++ b/crates/wtf8/src/lib.rs
@@ -33,8 +33,17 @@
 //! [WTF-8]: https://simonsapin.github.io/wtf-8
 //! [`OsStr`]: std::ffi::OsStr
 
+#![no_std]
 #![allow(clippy::precedence, clippy::match_overlapping_arm)]
 
+extern crate alloc;
+
+use alloc::borrow::{Cow, ToOwned};
+use alloc::boxed::Box;
+use alloc::collections::TryReserveError;
+use alloc::string::String;
+use alloc::vec::Vec;
+use core::borrow::Borrow;
 use core::fmt;
 use core::hash::{Hash, Hasher};
 use core::iter::FusedIterator;
@@ -46,10 +55,6 @@ use core_char::MAX_LEN_UTF8;
 use core_char::{MAX_LEN_UTF16, encode_utf8_raw, encode_utf16_raw, len_utf8};
 use core_str::{next_code_point, next_code_point_reverse};
 use itertools::{Either, Itertools};
-use std::borrow::{Borrow, Cow};
-use std::collections::TryReserveError;
-use std::string::String;
-use std::vec::Vec;
 
 use bstr::{ByteSlice, ByteVec};
 
@@ -325,6 +330,24 @@ impl Wtf8Buf {
         }
     }
 
+    pub fn join<I, S>(sep: impl AsRef<Wtf8>, iter: I) -> Wtf8Buf
+    where
+        I: IntoIterator<Item = S>,
+        S: AsRef<Wtf8>,
+    {
+        let sep = sep.as_ref();
+        let mut iter = iter.into_iter();
+        let mut buf = match iter.next() {
+            Some(first) => first.as_ref().to_owned(),
+            None => return Wtf8Buf::new(),
+        };
+        for part in iter {
+            buf.push_wtf8(sep);
+            buf.push_wtf8(part.as_ref());
+        }
+        buf
+    }
+
     pub fn clear(&mut self) {
         self.bytes.clear();
     }
@@ -665,7 +688,7 @@ impl PartialEq<str> for Wtf8 {
 impl fmt::Debug for Wtf8 {
     fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
         fn write_str_escaped(f: &mut fmt::Formatter<'_>, s: &str) -> fmt::Result {
-            use std::fmt::Write;
+            use core::fmt::Write;
             for c in s.chars().flat_map(|c| c.escape_debug()) {
                 f.write_char(c)?
             }
@@ -765,7 +788,7 @@ impl Wtf8 {
     #[inline]
     pub fn from_bytes(b: &[u8]) -> Option<&Self> {
         let mut rest = b;
-        while let Err(e) = std::str::from_utf8(rest) {
+        while let Err(e) = core::str::from_utf8(rest) {
             rest = &rest[e.valid_up_to()..];
             let _ = Self::decode_surrogate(rest)?;
             rest = &rest[3..];
@@ -899,7 +922,7 @@ impl Wtf8 {
     {
         self.chunks().flat_map(move |chunk| match chunk {
             Wtf8Chunk::Utf8(s) => Either::Left(f(s).map_into()),
-            Wtf8Chunk::Surrogate(c) => Either::Right(std::iter::once(c)),
+            Wtf8Chunk::Surrogate(c) => Either::Right(core::iter::once(c)),
         })
     }
 
@@ -974,6 +997,28 @@ impl Wtf8 {
         }
     }
 
+    pub fn to_lowercase(&self) -> Wtf8Buf {
+        let mut buf = Wtf8Buf::with_capacity(self.len());
+        for chunk in self.chunks() {
+            match chunk {
+                Wtf8Chunk::Utf8(s) => buf.push_str(&s.to_lowercase()),
+                Wtf8Chunk::Surrogate(c) => buf.push(c),
+            }
+        }
+        buf
+    }
+
+    pub fn to_uppercase(&self) -> Wtf8Buf {
+        let mut buf = Wtf8Buf::with_capacity(self.len());
+        for chunk in self.chunks() {
+            match chunk {
+                Wtf8Chunk::Utf8(s) => buf.push_str(&s.to_uppercase()),
+                Wtf8Chunk::Surrogate(c) => buf.push(c),
+            }
+        }
+        buf
+    }
+
     #[inline]
     pub const fn is_ascii(&self) -> bool {
         self.bytes.is_ascii()
@@ -1109,23 +1154,23 @@ impl Wtf8 {
         }
     }
 
-    pub fn ends_with(&self, w: &Wtf8) -> bool {
-        self.bytes.ends_with_str(w)
+    pub fn ends_with(&self, w: impl AsRef<Wtf8>) -> bool {
+        self.bytes.ends_with_str(w.as_ref())
     }
 
-    pub fn starts_with(&self, w: &Wtf8) -> bool {
-        self.bytes.starts_with_str(w)
+    pub fn starts_with(&self, w: impl AsRef<Wtf8>) -> bool {
+        self.bytes.starts_with_str(w.as_ref())
     }
 
-    pub fn strip_prefix(&self, w: &Wtf8) -> Option<&Self> {
+    pub fn strip_prefix(&self, w: impl AsRef<Wtf8>) -> Option<&Self> {
         self.bytes
-            .strip_prefix(w.as_bytes())
+            .strip_prefix(w.as_ref().as_bytes())
             .map(|w| unsafe { Wtf8::from_bytes_unchecked(w) })
     }
 
-    pub fn strip_suffix(&self, w: &Wtf8) -> Option<&Self> {
+    pub fn strip_suffix(&self, w: impl AsRef<Wtf8>) -> Option<&Self> {
         self.bytes
-            .strip_suffix(w.as_bytes())
+            .strip_suffix(w.as_ref().as_bytes())
             .map(|w| unsafe { Wtf8::from_bytes_unchecked(w) })
     }
 
@@ -1469,7 +1514,7 @@ impl<'a> Iterator for Wtf8Chunks<'a> {
             }
             None => {
                 let s =
-                    unsafe { str::from_utf8_unchecked(std::mem::take(&mut self.wtf8).as_bytes()) };
+                    unsafe { str::from_utf8_unchecked(core::mem::take(&mut self.wtf8).as_bytes()) };
                 (!s.is_empty()).then_some(Wtf8Chunk::Utf8(s))
             }
         }
@@ -1515,6 +1560,14 @@ impl From<&Wtf8> for Box<Wtf8> {
     }
 }
 
+impl<'a> From<&'a str> for &'a Wtf8 {
+    #[inline]
+    fn from(s: &'a str) -> &'a Wtf8 {
+        // Valid UTF-8 is always valid WTF-8
+        unsafe { Wtf8::from_bytes_unchecked(s.as_bytes()) }
+    }
+}
+
 impl From<&str> for Box<Wtf8> {
     fn from(s: &str) -> Self {
         Box::<str>::from(s).into()
@@ -1556,3 +1609,6 @@ impl From<String> for Box<Wtf8> {
         s.into_boxed_str().into()
     }
 }
+
+mod concat;
+pub use concat::Wtf8Concat;
diff --git a/example_projects/barebone/Cargo.toml b/example_projects/barebone/Cargo.toml
index b69617bdaf7..f622b65f75e 100644
--- a/example_projects/barebone/Cargo.toml
+++ b/example_projects/barebone/Cargo.toml
@@ -4,7 +4,7 @@ version = "0.1.0"
 edition = "2021"
 
 [dependencies]
-rustpython-vm = { path = "../../crates/vm", default-features = false }
+rustpython-vm = { path = "../../crates/vm", default-features = false, features = ["stdio"] }
 
 [workspace]
 
diff --git a/example_projects/wasm32_without_js/rustpython-without-js/src/lib.rs b/example_projects/wasm32_without_js/rustpython-without-js/src/lib.rs
index 0a8695fd7fb..382daebb04e 100644
--- a/example_projects/wasm32_without_js/rustpython-without-js/src/lib.rs
+++ b/example_projects/wasm32_without_js/rustpython-without-js/src/lib.rs
@@ -1,4 +1,4 @@
-use rustpython_vm::{Interpreter};
+use rustpython_vm::Interpreter;
 
 unsafe extern "C" {
     fn kv_get(kp: i32, kl: i32, vp: i32, vl: i32) -> i32;
@@ -25,7 +25,7 @@ pub unsafe extern "C" fn eval(s: *const u8, l: usize) -> i32 {
             Err(_) => return Err(-1), // Python execution error
         };
         let repr_str = match res.repr(vm) {
-            Ok(repr) => repr.as_str().to_string(),
+            Ok(repr) => repr.to_string(),
             Err(_) => return Err(-1), // Failed to get string representation
         };
         Ok(repr_str)
@@ -37,12 +37,7 @@ pub unsafe extern "C" fn eval(s: *const u8, l: usize) -> i32 {
 
     let msg = format!("eval result: {result}");
 
-    unsafe {
-        print(
-            msg.as_str().as_ptr() as usize as i32,
-            msg.len() as i32,
-        )
-    };
+    unsafe { print(msg.as_str().as_ptr() as usize as i32, msg.len() as i32) };
 
     0
 }
diff --git a/examples/freeze/main.rs b/examples/freeze/main.rs
index 48991129073..ab26a2bc808 100644
--- a/examples/freeze/main.rs
+++ b/examples/freeze/main.rs
@@ -7,9 +7,8 @@ fn main() -> vm::PyResult<()> {
 fn run(vm: &vm::VirtualMachine) -> vm::PyResult<()> {
     let scope = vm.new_scope_with_builtins();
 
-    // the file parameter is relative to the directory where the crate's Cargo.toml is located, see $CARGO_MANIFEST_DIR:
-    // https://doc.rust-lang.org/cargo/reference/environment-variables.html#environment-variables-cargo-sets-for-crates
-    let module = vm::py_compile!(file = "examples/freeze/freeze.py");
+    // the file parameter is relative to the current file.
+    let module = vm::py_compile!(file = "freeze.py");
 
     let res = vm.run_code_obj(vm.ctx.new_code(module), scope);
 
diff --git a/extra_tests/custom_text_test_runner.py b/extra_tests/custom_text_test_runner.py
index afec493a66c..3457bdfd0e4 100644
--- a/extra_tests/custom_text_test_runner.py
+++ b/extra_tests/custom_text_test_runner.py
@@ -38,6 +38,16 @@
 from unittest.runner import registerResult, result
 
 
+def _get_method_dict(test):
+    """Get the __dict__ of the underlying function for a test method.
+
+    Works for both bound methods (__func__.__dict__) and plain functions.
+    """
+    method = getattr(test, test._testMethodName)
+    func = getattr(method, "__func__", method)
+    return func.__dict__
+
+
 class TablePrinter(object):
     # Modified from https://github.com/agramian/table-printer, same license as above
     "Print a list of dicts as a table"
@@ -325,9 +335,7 @@ def startTest(self, test):
                 self.stream.writeln("TEST SUITE: %s" % self.suite)
                 self.stream.writeln("Description: %s" % self.getSuiteDescription(test))
         try:
-            name_override = getattr(test, test._testMethodName).__func__.__dict__[
-                "test_case_name"
-            ]
+            name_override = _get_method_dict(test)["test_case_name"]
         except:
             name_override = None
         self.case = name_override if name_override else self.case
@@ -345,7 +353,11 @@ def startTest(self, test):
             self.results["suites"][self.suite_number] = {
                 "name": self.suite,
                 "class": test.__class__.__name__,
-                "module": re.compile(".* \((.*)\)").match(str(test)).group(1),
+                "module": (
+                    m.group(1)
+                    if (m := re.compile(r".* \((.*)\)").match(str(test)))
+                    else str(test)
+                ),
                 "description": self.getSuiteDescription(test),
                 "cases": {},
                 "used_case_names": {},
@@ -380,34 +392,22 @@ def startTest(self, test):
             if "test_type" in getattr(
                 test, test._testMethodName
             ).__func__.__dict__ and set([s.lower() for s in self.test_types]) == set(
-                [
-                    s.lower()
-                    for s in getattr(test, test._testMethodName).__func__.__dict__[
-                        "test_type"
-                    ]
-                ]
+                [s.lower() for s in _get_method_dict(test)["test_type"]]
             ):
                 pass
             else:
-                getattr(test, test._testMethodName).__func__.__dict__[
-                    "__unittest_skip_why__"
-                ] = 'Test run specified to only run tests of type "%s"' % ",".join(
-                    self.test_types
+                _get_method_dict(test)["__unittest_skip_why__"] = (
+                    'Test run specified to only run tests of type "%s"'
+                    % ",".join(self.test_types)
                 )
-                getattr(test, test._testMethodName).__func__.__dict__[
-                    "__unittest_skip__"
-                ] = True
-        if "skip_device" in getattr(test, test._testMethodName).__func__.__dict__:
-            for device in getattr(test, test._testMethodName).__func__.__dict__[
-                "skip_device"
-            ]:
+                _get_method_dict(test)["__unittest_skip__"] = True
+        if "skip_device" in _get_method_dict(test):
+            for device in _get_method_dict(test)["skip_device"]:
                 if self.config and device.lower() in self.config["device_name"].lower():
-                    getattr(test, test._testMethodName).__func__.__dict__[
-                        "__unittest_skip_why__"
-                    ] = "Test is marked to be skipped on %s" % device
-                    getattr(test, test._testMethodName).__func__.__dict__[
-                        "__unittest_skip__"
-                    ] = True
+                    _get_method_dict(test)["__unittest_skip_why__"] = (
+                        "Test is marked to be skipped on %s" % device
+                    )
+                    _get_method_dict(test)["__unittest_skip__"] = True
                     break
 
     def stopTest(self, test):
diff --git a/extra_tests/snippets/builtin_ascii.py b/extra_tests/snippets/builtin_ascii.py
index 5b5b45d9990..08ce51cc086 100644
--- a/extra_tests/snippets/builtin_ascii.py
+++ b/extra_tests/snippets/builtin_ascii.py
@@ -5,3 +5,23 @@
 assert ascii(chr(0x10001)) == "'\\U00010001'"
 assert ascii(chr(0x9999)) == "'\\u9999'"
 assert ascii(chr(0x0A)) == "'\\n'"
+
+
+class MyStr(str):
+    pass
+
+
+class Foo:
+    def __repr__(self):
+        return MyStr("hello")
+
+
+class Bar:
+    def __repr__(self):
+        return MyStr("héllo")
+
+
+assert type(ascii(Foo())) is MyStr
+assert ascii(Foo()) == MyStr("hello")
+assert type(ascii(Bar())) is str
+assert ascii(Bar()) == "h\\xe9llo"
diff --git a/extra_tests/snippets/builtin_filter.py b/extra_tests/snippets/builtin_filter.py
index 25c00803c41..f778fd0cfe9 100644
--- a/extra_tests/snippets/builtin_filter.py
+++ b/extra_tests/snippets/builtin_filter.py
@@ -1,4 +1,4 @@
-assert list(filter(lambda x: ((x % 2) == 0), [0, 1, 2])) == [0, 2]
+assert list(filter(lambda x: (x % 2) == 0, [0, 1, 2])) == [0, 2]
 
 # None implies identity
 assert list(filter(None, [0, 1, 2])) == [1, 2]
@@ -18,7 +18,7 @@ def __iter__(self):
         return self
 
 
-it = filter(lambda x: ((x % 2) == 0), Counter())
+it = filter(lambda x: (x % 2) == 0, Counter())
 assert next(it) == 2
 assert next(it) == 4
 
diff --git a/extra_tests/snippets/builtin_none.py b/extra_tests/snippets/builtin_none.py
index 230a7229e02..061739153ff 100644
--- a/extra_tests/snippets/builtin_none.py
+++ b/extra_tests/snippets/builtin_none.py
@@ -26,3 +26,15 @@ def none2():
 assert None.__ne__(3) is NotImplemented
 assert None.__eq__(None) is True
 assert None.__ne__(None) is False
+assert None.__lt__(3) is NotImplemented
+assert None.__le__(3) is NotImplemented
+assert None.__gt__(3) is NotImplemented
+assert None.__ge__(3) is NotImplemented
+
+none_type_dict = type(None).__dict__
+for name in ("__eq__", "__ne__", "__lt__", "__le__", "__gt__", "__ge__", "__hash__"):
+    assert name in none_type_dict
+    assert none_type_dict[name] is not object.__dict__[name]
+    assert type(none_type_dict[name]).__name__ == "wrapper_descriptor"
+
+assert hash(None) & 0xFFFFFFFF == 0xFCA86420
diff --git a/extra_tests/snippets/builtin_str.py b/extra_tests/snippets/builtin_str.py
index 415156184c4..b852e678ace 100644
--- a/extra_tests/snippets/builtin_str.py
+++ b/extra_tests/snippets/builtin_str.py
@@ -61,6 +61,9 @@
 assert not a.endswith("on")
 assert not a.endswith(("A", "ll"))
 assert a.zfill(8) == "000Hallo"
+assert "á".zfill(4) == "000á"
+assert "🙂".zfill(5) == "0000🙂"
+assert "+あ".zfill(5) == "+000あ"
 assert a.isalnum()
 assert not a.isdigit()
 assert not a.isdecimal()
@@ -232,6 +235,8 @@
 assert not "😂".isidentifier()
 assert not "123".isidentifier()
 
+assert "Σίσυφος".swapcase() == "σΊΣΥΦΟΣ"
+
 # String Formatting
 assert "{} {}".format(1, 2) == "1 2"
 assert "{0} {1}".format(2, 3) == "2 3"
diff --git a/extra_tests/snippets/sandbox_smoke.py b/extra_tests/snippets/sandbox_smoke.py
new file mode 100644
index 00000000000..13fa0722742
--- /dev/null
+++ b/extra_tests/snippets/sandbox_smoke.py
@@ -0,0 +1,55 @@
+"""Sandbox mode smoke test.
+
+Verifies basic functionality that works in both sandbox and normal mode:
+- stdio (print, sys.stdout/stdin/stderr)
+- builtin modules (math, json)
+- in-memory IO (BytesIO, StringIO)
+- open() is properly blocked when FileIO is unavailable (sandbox)
+"""
+
+import _io
+import json
+import math
+import sys
+
+SANDBOX = not hasattr(_io, "FileIO")
+
+# stdio
+print("1. print works")
+assert sys.stdout.writable()
+assert sys.stderr.writable()
+assert sys.stdin.readable()
+assert sys.stdout.fileno() == 1
+
+# math
+assert math.pi > 3.14
+print("2. math works:", math.pi)
+
+# json
+d = json.loads('{"a": 1}')
+assert d == {"a": 1}
+print("3. json works:", d)
+
+# BytesIO / StringIO
+buf = _io.BytesIO(b"hello")
+assert buf.read() == b"hello"
+sio = _io.StringIO("world")
+assert sio.read() == "world"
+print("4. BytesIO/StringIO work")
+
+# open() behavior depends on mode
+if SANDBOX:
+    try:
+        open("/tmp/x", "w")
+        assert False, "should have raised"
+    except _io.UnsupportedOperation:
+        print("5. open() properly blocked (sandbox)")
+else:
+    print("5. open() available (host_env)")
+
+# builtins
+assert list(range(5)) == [0, 1, 2, 3, 4]
+assert sorted([3, 1, 2]) == [1, 2, 3]
+print("6. builtins work")
+
+print("All smoke tests passed!", "(sandbox)" if SANDBOX else "(host_env)")
diff --git a/extra_tests/snippets/stdlib_io.py b/extra_tests/snippets/stdlib_io.py
index 7c473908295..93c083a90c1 100644
--- a/extra_tests/snippets/stdlib_io.py
+++ b/extra_tests/snippets/stdlib_io.py
@@ -1,5 +1,5 @@
 import os
-from io import BufferedReader, BytesIO, FileIO, StringIO
+from io import BufferedReader, BytesIO, FileIO, RawIOBase, StringIO, TextIOWrapper
 
 from testutils import assert_raises
 
@@ -40,3 +40,47 @@
     assert len(nres) == 1
     nres = fio.read(2)
     assert len(nres) == 2
+
+
+# Test that IOBase.isatty() raises ValueError when called on a closed file.
+# Minimal subclass that inherits IOBase.isatty() without overriding it.
+class MinimalRaw(RawIOBase):
+    def readinto(self, b):
+        return 0
+
+
+f = MinimalRaw()
+assert not f.closed
+assert not f.isatty()  # open file: should return False
+
+f.close()
+assert f.closed
+
+with assert_raises(ValueError):
+    f.isatty()
+
+
+class Gh6588:
+    def __init__(self):
+        self.textio = None
+        self.closed = False
+
+    def writable(self):
+        return True
+
+    def readable(self):
+        return False
+
+    def seekable(self):
+        return False
+
+    def write(self, data):
+        self.textio.reconfigure(encoding="utf-8")
+        return len(data)
+
+
+raw = Gh6588()
+textio = TextIOWrapper(raw, encoding="utf-8", write_through=True)
+raw.textio = textio
+with assert_raises(AttributeError):
+    textio.writelines(["x"])
diff --git a/extra_tests/snippets/stdlib_io_bytesio.py b/extra_tests/snippets/stdlib_io_bytesio.py
index e51177014c3..ba8ae20015e 100644
--- a/extra_tests/snippets/stdlib_io_bytesio.py
+++ b/extra_tests/snippets/stdlib_io_bytesio.py
@@ -74,6 +74,30 @@ def test_06():
     assert f.readline() == b""
 
 
+def test_07():
+    """
+    Tests that flush() returns None when the file is open,
+    and raises ValueError when the file is closed.
+    CPython reference: Modules/_io/bytesio.c:325-335
+    """
+    f = BytesIO(b"Test String 7")
+
+    # flush() on an open BytesIO returns None
+    assert f.flush() is None
+
+    # flush() is defined directly on BytesIO (not just inherited)
+    assert "flush" in BytesIO.__dict__
+
+    f.close()
+
+    # flush() on a closed BytesIO raises ValueError
+    try:
+        f.flush()
+        assert False, "Expected ValueError not raised"
+    except ValueError:
+        pass
+
+
 if __name__ == "__main__":
     test_01()
     test_02()
@@ -81,3 +105,4 @@ def test_06():
     test_04()
     test_05()
     test_06()
+    test_07()
diff --git a/extra_tests/snippets/stdlib_re.py b/extra_tests/snippets/stdlib_re.py
index 89d729f2b25..53f21f91734 100644
--- a/extra_tests/snippets/stdlib_re.py
+++ b/extra_tests/snippets/stdlib_re.py
@@ -75,3 +75,7 @@
 
 assert re.compile("(?:\w+(?:\s|/(?!>))*)*").match("a /bb />ccc").group() == "a /bb "
 assert re.compile("(?:(1)?)*").match("111").group() == "111"
+
+# Test of fix re.fullmatch POSSESSIVE_REPEAT, issue #7183
+assert re.fullmatch(r"([0-9]++(?:\.[0-9]+)*+)", "1.25.38")
+assert re.fullmatch(r"([0-9]++(?:\.[0-9]+)*+)", "1.25.38").group(0) == "1.25.38"
diff --git a/extra_tests/snippets/stdlib_types.py b/extra_tests/snippets/stdlib_types.py
index 14028268f0e..cdecf12dd2b 100644
--- a/extra_tests/snippets/stdlib_types.py
+++ b/extra_tests/snippets/stdlib_types.py
@@ -22,19 +22,15 @@ def _run_missing_type_params_regression():
         kwarg=None,
         defaults=[],
     )
-    fn = _ast.FunctionDef("f", args, [], [], None, None)
+    pass_stmt = _ast.Pass(lineno=1, col_offset=4, end_lineno=1, end_col_offset=8)
+    fn = _ast.FunctionDef("f", args, [pass_stmt], [], None, None)
     fn.lineno = 1
     fn.col_offset = 0
     fn.end_lineno = 1
-    fn.end_col_offset = 0
+    fn.end_col_offset = 8
     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()
+_run_missing_type_params_regression()
diff --git a/extra_tests/snippets/syntax_comprehension.py b/extra_tests/snippets/syntax_comprehension.py
index 6445c655306..3408c47daf7 100644
--- a/extra_tests/snippets/syntax_comprehension.py
+++ b/extra_tests/snippets/syntax_comprehension.py
@@ -45,3 +45,37 @@
 def f():
     # Test no panic occurred.
     [[x := 1 for j in range(5)] for i in range(5)]
+
+
+# Nested inlined comprehensions with lambda in the first iterator expression.
+# The lambda's sub_table must be consumed before the inner comprehension's
+# sub_table is spliced in, otherwise scope ordering is wrong.
+def test_nested_comp_with_lambda():
+    import itertools
+    offsets = {0: [0], 1: [1], 3: [2]}
+    grouped = [
+        [x for _, x in group]
+        for _, group in itertools.groupby(
+            enumerate(sorted(offsets.keys())), lambda x: x[1] - x[0]
+        )
+    ]
+    assert grouped == [[0, 1], [3]], f"got {grouped}"
+
+test_nested_comp_with_lambda()
+
+
+# Nested inlined comprehensions with throwaway `_` in both levels.
+def test_nested_comp_underscore():
+    data = [(1, "a", "x"), (2, "b", "y")]
+    result = [[v for _, v in zip(range(2), row)] for _, *row in data]
+    assert result == [["a", "x"], ["b", "y"]], f"got {result}"
+
+test_nested_comp_underscore()
+
+
+# Simple nested inlined comprehensions.
+def test_simple_nested_comp():
+    result = [[j * i for j in range(3)] for i in range(3)]
+    assert result == [[0, 0, 0], [0, 1, 2], [0, 2, 4]]
+
+test_simple_nested_comp()
diff --git a/extra_tests/snippets/syntax_non_utf8.py b/extra_tests/snippets/syntax_non_utf8.py
index ad93d5b33c1..8f11078bc07 100644
--- a/extra_tests/snippets/syntax_non_utf8.py
+++ b/extra_tests/snippets/syntax_non_utf8.py
@@ -5,5 +5,5 @@
 dir_path = os.path.dirname(os.path.realpath(__file__))
 
 with assert_raises(SyntaxError):
-    with open(os.path.join(dir_path , "non_utf8.txt")) as f:
+    with open(os.path.join(dir_path , "non_utf8.txt"), encoding="latin-1") as f:
         eval(f.read())
diff --git a/extra_tests/snippets/syntax_short_circuit_bool.py b/extra_tests/snippets/syntax_short_circuit_bool.py
index 76d89352cbb..6cbae190cae 100644
--- a/extra_tests/snippets/syntax_short_circuit_bool.py
+++ b/extra_tests/snippets/syntax_short_circuit_bool.py
@@ -31,3 +31,6 @@ def __bool__(self):
 
 # if ExplodingBool(False) and False and True and False:
 #     pass
+
+# Issue #3567: nested BoolOps should not call __bool__ redundantly
+assert (ExplodingBool(False) and False or False) == False
diff --git a/extra_tests/snippets/vm_specialization.py b/extra_tests/snippets/vm_specialization.py
new file mode 100644
index 00000000000..2c884cc2f6d
--- /dev/null
+++ b/extra_tests/snippets/vm_specialization.py
@@ -0,0 +1,71 @@
+## BinaryOp inplace-add unicode: deopt falls back to __add__/__iadd__
+
+
+class S(str):
+    def __add__(self, other):
+        return "ADD"
+
+    def __iadd__(self, other):
+        return "IADD"
+
+
+def add_path_fallback_uses_add():
+    x = "a"
+    y = "b"
+    for i in range(1200):
+        if i == 600:
+            x = S("s")
+            y = "t"
+        x = x + y
+    return x
+
+
+def iadd_path_fallback_uses_iadd():
+    x = "a"
+    y = "b"
+    for i in range(1200):
+        if i == 600:
+            x = S("s")
+            y = "t"
+        x += y
+    return x
+
+
+assert add_path_fallback_uses_add().startswith("ADD")
+assert iadd_path_fallback_uses_iadd().startswith("IADD")
+
+
+## BINARY_SUBSCR_STR_INT: ASCII singleton identity
+
+
+def check_ascii_subscr_singleton_after_warmup():
+    s = "abc"
+    first = None
+    for i in range(4000):
+        c = s[0]
+        if i >= 3500:
+            if first is None:
+                first = c
+            else:
+                assert c is first
+
+
+check_ascii_subscr_singleton_after_warmup()
+
+
+## BINARY_SUBSCR_STR_INT: Latin-1 singleton identity
+
+
+def check_latin1_subscr_singleton_after_warmup():
+    for s in ("abc", "éx"):
+        first = None
+        for i in range(5000):
+            c = s[0]
+            if i >= 4500:
+                if first is None:
+                    first = c
+                else:
+                    assert c is first
+
+
+check_latin1_subscr_singleton_after_warmup()
diff --git a/extra_tests/test_manager_fork_debug.py b/extra_tests/test_manager_fork_debug.py
new file mode 100644
index 00000000000..6110f7e3699
--- /dev/null
+++ b/extra_tests/test_manager_fork_debug.py
@@ -0,0 +1,149 @@
+"""Minimal reproduction of multiprocessing Manager + fork failure."""
+
+import multiprocessing
+import os
+import sys
+import time
+import traceback
+
+import pytest
+
+pytestmark = pytest.mark.skipif(not hasattr(os, "fork"), reason="requires os.fork")
+
+
+def test_basic_manager():
+    """Test Manager without fork - does it work at all?"""
+    print("=== Test 1: Basic Manager (no fork) ===")
+    ctx = multiprocessing.get_context("fork")
+    manager = ctx.Manager()
+    try:
+        ev = manager.Event()
+        print(f"  Event created: {ev}")
+        ev.set()
+        print(f"  Event set, is_set={ev.is_set()}")
+        assert ev.is_set()
+        print("  PASS")
+    finally:
+        manager.shutdown()
+
+
+def test_manager_with_process():
+    """Test Manager shared between parent and child process."""
+    print("\n=== Test 2: Manager with forked child ===")
+    ctx = multiprocessing.get_context("fork")
+    manager = ctx.Manager()
+    try:
+        result = manager.Value("i", 0)
+        ev = manager.Event()
+
+        def child_fn():
+            try:
+                ev.set()
+                result.value = 42
+            except Exception as e:
+                print(f"  CHILD ERROR: {e}", file=sys.stderr)
+                traceback.print_exc()
+                sys.exit(1)
+
+        print(f"  Starting child process...")
+        process = ctx.Process(target=child_fn)
+        process.start()
+        print(f"  Waiting for child (pid={process.pid})...")
+        process.join(timeout=10)
+
+        if process.exitcode != 0:
+            print(f"  FAIL: child exited with code {process.exitcode}")
+            return False
+
+        print(f"  Child done. result={result.value}, event={ev.is_set()}")
+        assert result.value == 42
+        assert ev.is_set()
+        print("  PASS")
+        return True
+    finally:
+        manager.shutdown()
+
+
+def test_manager_server_alive_after_fork():
+    """Test that Manager server survives after forking a child."""
+    print("\n=== Test 3: Manager server alive after fork ===")
+    ctx = multiprocessing.get_context("fork")
+    manager = ctx.Manager()
+    try:
+        ev = manager.Event()
+
+        # Fork a child that does nothing with the manager
+        pid = os.fork()
+        if pid == 0:
+            # Child - exit immediately
+            os._exit(0)
+
+        # Parent - wait for child
+        os.waitpid(pid, 0)
+
+        # Now try to use the manager in the parent
+        print(f"  After fork, trying to use Manager in parent...")
+        ev.set()
+        print(f"  ev.is_set() = {ev.is_set()}")
+        assert ev.is_set()
+        print("  PASS")
+        return True
+    finally:
+        manager.shutdown()
+
+
+def test_manager_server_alive_after_fork_with_child_usage():
+    """Test that Manager server survives when child also uses it."""
+    print("\n=== Test 4: Manager server alive after fork + child usage ===")
+    ctx = multiprocessing.get_context("fork")
+    manager = ctx.Manager()
+    try:
+        child_ev = manager.Event()
+        parent_ev = manager.Event()
+
+        def child_fn():
+            try:
+                child_ev.set()
+            except Exception as e:
+                print(f"  CHILD ERROR: {e}", file=sys.stderr)
+                traceback.print_exc()
+                sys.exit(1)
+
+        process = ctx.Process(target=child_fn)
+        process.start()
+        process.join(timeout=10)
+
+        if process.exitcode != 0:
+            print(f"  FAIL: child exited with code {process.exitcode}")
+            return False
+
+        # Now use manager in parent AFTER child is done
+        print(f"  Child done. Trying parent usage...")
+        parent_ev.set()
+        print(f"  child_ev={child_ev.is_set()}, parent_ev={parent_ev.is_set()}")
+        assert child_ev.is_set()
+        assert parent_ev.is_set()
+        print("  PASS")
+        return True
+    finally:
+        manager.shutdown()
+
+
+if __name__ == "__main__":
+    test_basic_manager()
+
+    passed = 0
+    total = 10
+    for i in range(total):
+        print(f"\n--- Iteration {i + 1}/{total} ---")
+        ok = True
+        ok = ok and test_manager_with_process()
+        ok = ok and test_manager_server_alive_after_fork()
+        ok = ok and test_manager_server_alive_after_fork_with_child_usage()
+        if ok:
+            passed += 1
+        else:
+            print(f"  FAILED on iteration {i + 1}")
+
+    print(f"\n=== Results: {passed}/{total} passed ===")
+    sys.exit(0 if passed == total else 1)
diff --git a/scripts/check_redundant_patches.py b/scripts/check_redundant_patches.py
new file mode 100644
index 00000000000..4bc89a573d4
--- /dev/null
+++ b/scripts/check_redundant_patches.py
@@ -0,0 +1,92 @@
+#!/usr/bin/env python
+import argparse
+import ast
+import glob
+import os
+import pathlib
+import sys
+
+ROOT = pathlib.Path(__file__).parents[1]
+TEST_DIR = ROOT / "Lib" / "test"
+
+IS_GH_CI = "GITHUB_ACTIONS" in os.environ
+
+
+def build_argparser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(prog="check_redundant_patches")
+    parser.add_argument(
+        "patterns",
+        nargs="*",
+        default=[f"{TEST_DIR}/**/*.py"],
+        help="Glob patterns (e.g. foo/bar/**.py a/b/file.py)",
+    )
+
+    return parser
+
+
+def iter_files(patterns: list[str]):
+    seen = set()
+    for pattern in set(patterns):
+        matches = glob.glob(pattern, recursive=True)
+        for path in matches:
+            if path in seen:
+                continue
+            seen.add(path)
+            yield path
+
+
+def main(patterns: list[str]):
+    exit_status = 0
+    for file in map(pathlib.Path, iter_files(patterns)):
+        if file.is_dir():
+            continue
+
+        try:
+            contents = file.read_text(encoding="utf-8")
+        except UnicodeDecodeError:
+            continue
+
+        try:
+            tree = ast.parse(contents)
+        except SyntaxError:
+            continue
+
+        cls_name = None
+        for node in ast.walk(tree):
+            if isinstance(node, ast.ClassDef):
+                cls_name = node.name
+
+            if not isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)):
+                continue
+
+            name = node.name
+            if not name.startswith("test"):
+                continue
+
+            if node.decorator_list:
+                continue
+
+            func_code = ast.unparse(node.body)
+            if func_code in (
+                f"await super().{name}()",
+                f"return await super().{name}()",
+                f"return super().{name}()",
+                f"super().{name}()",
+            ):
+                exit_status += 1
+
+                lineno = node.lineno
+                msg = f"{file}:{lineno}:{cls_name}.{name} is a test patch that can be safely removed"
+                if IS_GH_CI:
+                    end_lineno = node.end_lineno
+                    msg = f"::error file={file},line={lineno},endLine={end_lineno},title=Redundant Test Patch::{msg}"
+
+                print(msg, file=sys.stderr)
+
+    return exit_status
+
+
+if __name__ == "__main__":
+    parser = build_argparser()
+    args = parser.parse_args()
+    exit(main(args.patterns))
diff --git a/scripts/generate_opcode_metadata.py b/scripts/generate_opcode_metadata.py
index 42fb55a7c01..7e1c9222ffe 100644
--- a/scripts/generate_opcode_metadata.py
+++ b/scripts/generate_opcode_metadata.py
@@ -16,25 +16,48 @@
 OPCODE_METADATA_FILE = ROOT / "Lib" / "_opcode_metadata.py"
 
 
+# Opcodes that needs to be first, regardless of their opcode ID.
+PRIORITY_OPMAP = {
+    "CACHE",
+    "RESERVED",
+    "RESUME",
+    "INSTRUMENTED_LINE",
+    "ENTER_EXECUTOR",
+}
+
+
+def to_pascal_case(s: str) -> str:
+    res = re.sub(r"(?<=[a-z0-9])([A-Z])", r"_\1", s)
+    return re.sub(r"(\D)(\d+)$", r"\1_\2", res).upper()
+
+
 class Opcode(typing.NamedTuple):
     rust_name: str
     id: int
+    have_oparg: bool
 
     @property
     def cpython_name(self) -> str:
-        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()
+        return to_pascal_case(self.rust_name)
+
+    @property
+    def is_instrumented(self):
+        return self.cpython_name.startswith("INSTRUMENTED_")
 
     @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):
+        for raw_name, raw_id in itertools.batched(raw_variants, 2, strict=True):
+            have_oparg = "Arg<" in raw_name  # Hacky but works
             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))
+            yield cls(rust_name=name.strip(), id=int(raw_id), have_oparg=have_oparg)
 
     def __lt__(self, other: typing.Self) -> bool:
-        return self.id < other.id
+        sprio, oprio = (
+            opcode.cpython_name not in PRIORITY_OPMAP for opcode in (self, other)
+        )
+        return (sprio, self.id) < (oprio, other.id)
 
 
 def extract_enum_body(contents: str, enum_name: str) -> str:
@@ -49,33 +72,106 @@ def extract_enum_body(contents: str, enum_name: str) -> str:
     )
 
 
+def build_deopts(contents: str) -> dict[str, list[str]]:
+    raw_body = re.search(
+        r"fn deopt\(self\) -> Option<Self>(.*)", contents, re.DOTALL
+    ).group(1)
+    body = "\n".join(
+        itertools.takewhile(
+            lambda l: not l.startswith("_ =>"),  # Take until reaching fallback
+            filter(
+                lambda l: (
+                    not l.startswith(
+                        ("//", "Some(match")
+                    )  # Skip comments or start of match
+                ),
+                map(str.strip, raw_body.splitlines()),
+            ),
+        )
+    ).removeprefix("{")
+
+    depth = 0
+    arms = []
+    buf = []
+    for char in body:
+        if char == "{":
+            depth += 1
+        elif char == "}":
+            depth -= 1
+
+        if depth == 0 and (char in ("}", ",")):
+            arm = "".join(buf).strip()
+            arms.append(arm)
+            buf = []
+        else:
+            buf.append(char)
+
+    # last arm
+    arms.append("".join(buf))
+    arms = [arm for arm in arms if arm]
+
+    deopts = {}
+    for arm in arms:
+        *specialized, deopt = map(to_pascal_case, re.findall(r"Self::(\w*)\b", arm))
+        deopts[deopt] = specialized
+
+    return deopts
+
+
 contents = BYTECODE_FILE.read_text(encoding="utf-8")
+
+deopts = build_deopts(contents)
+
 enum_body = "\n".join(
     extract_enum_body(contents, enum_name)
     for enum_name in ("Instruction", "PseudoInstruction")
 )
 opcodes = list(Opcode.from_str(enum_body))
 
+have_oparg = min(opcode.id for opcode in opcodes if opcode.have_oparg) - 1
+min_instrumented = min(opcode.id for opcode in opcodes if opcode.is_instrumented)
+
 # 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).
+# for RustPython bytecode format (CPython 3.14 compatible opcode numbers).
 # Do not edit!
+"""
 
-_specializations = {}
+output += "\n_specializations = {\n"
 
-_specialized_opmap = {}
+for key, lst in deopts.items():
+    output += f'    "{key}": [\n'
+    for item in lst:
+        output += f'        "{item}",\n'
+    output += "    ],\n"
 
-opmap = {
-"""
+output += "}\n"
+
+specialized = set(itertools.chain.from_iterable(deopts.values()))
+output += "\n_specialized_opmap = {\n"
+for opcode in sorted(opcodes, key=lambda op: op.cpython_name):
+    cpython_name = opcode.cpython_name
+    if cpython_name not in specialized:
+        continue
+
+    output += f"    '{cpython_name}': {opcode.id},\n"
+
+output += "}\n"
+
+output += "\nopmap = {\n"
 
 for opcode in sorted(opcodes):
-    output += f"    '{opcode.cpython_name}': {opcode.id},\n"
+    cpython_name = opcode.cpython_name
+    if cpython_name in specialized:
+        continue
+
+    output += f"    '{cpython_name}': {opcode.id},\n"
 
-output += """}
+output += "}\n"
 
-# CPython 3.13 compatible: opcodes < 44 have no argument
-HAVE_ARGUMENT = 44
-MIN_INSTRUMENTED_OPCODE = 236
+output += f"""
+HAVE_ARGUMENT = {have_oparg}
+MIN_INSTRUMENTED_OPCODE = {min_instrumented}
 """
 
 OPCODE_METADATA_FILE.write_text(output, encoding="utf-8")
diff --git a/scripts/libc_posix.py b/scripts/libc_posix.py
index 73f082a0658..82f3eb96d83 100644
--- a/scripts/libc_posix.py
+++ b/scripts/libc_posix.py
@@ -1,19 +1,24 @@
 #!/usr/bin/env python
 import collections
+import dataclasses
+import pathlib
 import re
+import subprocess
 import urllib.request
-from typing import TYPE_CHECKING
 
-if TYPE_CHECKING:
-    from collections.abc import Iterator
+import tomllib
 
-CONSTS_PAT = re.compile(r"\b_*[A-Z]+(?:_+[A-Z]+)*_*\b")
-OS_CONSTS_PAT = re.compile(
-    r"\bos\.(_*[A-Z]+(?:_+[A-Z]+)*_*)"
-)  # TODO: Exclude matches if they have `(` after (those are functions)
+CPYTHON_VERSION = "3.14"
 
+CONSTS_PATTERN = re.compile(r"\b_*[A-Z]+(?:_+[A-Z]+)*_*\b")
 
-LIBC_VERSION = "0.2.177"
+CARGO_TOML_FILE = pathlib.Path(__file__).parents[1] / "Cargo.toml"
+CARGO_TOML = tomllib.loads(CARGO_TOML_FILE.read_text())
+LIBC_DATA = CARGO_TOML["workspace"]["dependencies"]["libc"]
+
+
+LIBC_VERSION = LIBC_DATA["version"] if isinstance(LIBC_DATA, dict) else LIBC_DATA
+BASE_URL = f"https://raw.githubusercontent.com/rust-lang/libc/refs/tags/{LIBC_VERSION}"
 
 EXCLUDE = frozenset(
     {
@@ -42,89 +47,201 @@
     }
 )
 
-EXTRAS = {
-    frozenset({"macos"}): {"COPYFILE_DATA"},
-}
-RENAMES = {"COPYFILE_DATA": "_COPYFILE_DATA"}
-
-
-def build_url(fname: str) -> str:
-    return f"https://raw.githubusercontent.com/rust-lang/libc/refs/tags/{LIBC_VERSION}/libc-test/semver/{fname}.txt"
-
-
-TARGET_OS = {
-    "android": "android",
-    "dragonfly": "dragonfly",
-    "freebsd": "freebsd",
-    "linux": "linux",
-    "macos": "apple",
-    "netbsd": "netbsd",
-    "openbsd": "openbsd",
-    "redox": "redox",
-    # solaris?
-    "unix": "unix",
-}
-
-
-def get_consts(url: str, pattern: re.Pattern = CONSTS_PAT) -> frozenset[str]:
-    with urllib.request.urlopen(url) as f:
-        resp = f.read().decode()
-
-    return frozenset(pattern.findall(resp)) - EXCLUDE
 
+def rustfmt(code: str) -> str:
+    return subprocess.check_output(["rustfmt", "--emit=stdout"], input=code, text=True)
+
+
+@dataclasses.dataclass(eq=True, frozen=True, slots=True)
+class Cfg:
+    inner: str
+
+    def __str__(self) -> str:
+        return self.inner
+
+    def __lt__(self, other) -> bool:
+        si, oi = map(str, (self.inner, other.inner))
+
+        # Smaller length cfgs are smaller, regardless of value.
+        return (len(si), si) < (len(oi), oi)
+
+
+@dataclasses.dataclass(frozen=True, kw_only=True, slots=True)
+class Target:
+    cfgs: set[Cfg]
+    sources: set[str] = dataclasses.field(default_factory=set)
+    extras: set[str] = dataclasses.field(default_factory=set)
+
+
+TARGETS = (
+    Target(
+        cfgs={Cfg('target_os = "android"')},
+        sources={
+            f"{BASE_URL}/src/unix/linux_like/android/mod.rs",
+            f"{BASE_URL}/libc-test/semver/android.txt",
+        },
+    ),
+    Target(
+        cfgs={Cfg('target_os = "dragonfly"')},
+        sources={
+            f"{BASE_URL}/src/unix/bsd/freebsdlike/dragonfly/mod.rs",
+            f"{BASE_URL}/libc-test/semver/dragonfly.txt",
+        },
+    ),
+    Target(
+        cfgs={Cfg('target_os = "freebsd"')},
+        sources={
+            f"{BASE_URL}/src/unix/bsd/freebsdlike/freebsd/mod.rs",
+            f"{BASE_URL}/libc-test/semver/freebsd.txt",
+        },
+    ),
+    Target(
+        cfgs={Cfg('target_os = "linux"')},
+        sources={
+            f"{BASE_URL}/src/unix/linux_like/mod.rs",
+            f"{BASE_URL}/src/unix/linux_like/linux_l4re_shared.rs",
+            f"{BASE_URL}/libc-test/semver/linux.txt",
+        },
+    ),
+    Target(
+        cfgs={Cfg('target_os = "macos"')},
+        sources={
+            f"{BASE_URL}/src/unix/bsd/apple/mod.rs",
+            f"{BASE_URL}/libc-test/semver/apple.txt",
+        },
+        extras={"COPYFILE_DATA as _COPYFILE_DATA"},
+    ),
+    Target(
+        cfgs={Cfg('target_os = "netbsd"')},
+        sources={
+            f"{BASE_URL}/src/unix/bsd/netbsdlike/netbsd/mod.rs",
+            f"{BASE_URL}/libc-test/semver/netbsd.txt",
+        },
+    ),
+    Target(
+        cfgs={Cfg('target_os = "redox"')},
+        sources={
+            f"{BASE_URL}/src/unix/redox/mod.rs",
+            f"{BASE_URL}/libc-test/semver/redox.txt",
+        },
+    ),
+    Target(cfgs={Cfg("unix")}, sources={f"{BASE_URL}/libc-test/semver/unix.txt"}),
+)
 
-def format_groups(groups: dict) -> "Iterator[tuple[str, str]]":
-    # sort by length, then alphabet. so we will have a consistent output
-    for targets, consts in sorted(
-        groups.items(), key=lambda t: (len(t[0]), sorted(t[0]))
-    ):
-        cond = ", ".join(
-            f'target_os = "{target_os}"' if target_os != "unix" else target_os
-            for target_os in sorted(targets)
-        )
-        if len(targets) > 1:
-            cond = f"any({cond})"
-        cfg = f"#[cfg({cond})]"
 
-        imports = ", ".join(
-            const if const not in RENAMES else f"{const} as {RENAMES[const]}"
-            for const in sorted(consts)
-        )
-        use = f"use libc::{{{imports}}};"
-        yield cfg, use
+def extract_consts(
+    contents: str,
+    *,
+    pattern: re.Pattern = CONSTS_PATTERN,
+    exclude: frozenset[str] = EXCLUDE,
+) -> frozenset[str]:
+    """
+    Extract all words that are comprised from only uppercase letters + underscores.
+
+    Parameters
+    ----------
+    contents : str
+        Contents to extract the constants from.
+    pattern : re.Pattern, Optional
+        RE compiled pattern for extracting the consts.
+    exclude : frozenset[str], Optional
+        Items to exclude from the returned value.
+
+    Returns
+    -------
+    frozenset[str]
+        All constant names.
+    """
+    result = frozenset(pattern.findall(contents))
+    return result - exclude
+
+
+def consts_from_url(
+    url: str, *, pattern: re.Pattern = CONSTS_PATTERN, exclude: frozenset[str] = EXCLUDE
+) -> frozenset[str]:
+    """
+    Extract all consts from the contents found at the given URL.
+
+    Parameters
+    ----------
+    url : str
+        URL to fetch the contents from.
+    pattern : re.Pattern, Optional
+        RE compiled pattern for extracting the consts.
+    exclude : frozenset[str], Optional
+        Items to exclude from the returned value.
+
+    Returns
+    -------
+    frozenset[str]
+        All constant names at the URL.
+    """
+    try:
+        with urllib.request.urlopen(url) as f:
+            contents = f.read().decode()
+    except urllib.error.HTTPError as err:
+        err.add_note(url)
+        raise
+
+    return extract_consts(contents, pattern=pattern, exclude=exclude)
 
 
 def main():
-    wanted_consts = get_consts(
-        "https://docs.python.org/3.13/library/os.html",  # Should we read from https://github.com/python/cpython/blob/bcee1c322115c581da27600f2ae55e5439c027eb/Modules/posixmodule.c#L17023 instead?
-        pattern=OS_CONSTS_PAT,
+    # Step 1: Get all OS contants that we do want from upstream
+    wanted_consts = consts_from_url(
+        f"https://docs.python.org/{CPYTHON_VERSION}/library/os.html",
+        # TODO: Exclude matches if they have `(` after (those are functions)
+        pattern=re.compile(r"\bos\.(_*[A-Z]+(?:_+[A-Z]+)*_*)"),
     )
-    available = {
-        target_os: get_consts(build_url(fname))
-        for target_os, fname in TARGET_OS.items()
-    }
 
-    group_consts = collections.defaultdict(set)
-    for const in wanted_consts:
-        target_oses = frozenset(
-            target_os for target_os, consts in available.items() if const in consts
+    # Step 2: build dict of what consts are available per cfg. `cfg -> {consts}`
+    available = collections.defaultdict(set)
+    for target in TARGETS:
+        consts = set()
+        for source in target.sources:
+            consts |= consts_from_url(source)
+
+        for cfg in target.cfgs:
+            available[cfg] |= consts
+
+    # Step 3: Keep only the "wanted" consts. Build a groupped mapping of `{cfgs} -> {consts}'
+    groups = collections.defaultdict(set)
+    available_items = available.items()
+    for wanted_const in wanted_consts:
+        cfgs = frozenset(
+            cfg for cfg, consts in available_items if wanted_const in consts
         )
-        if not target_oses:
+        if not cfgs:
+            # We have no cfgs for a wanted const :/
             continue
 
-        group_consts[target_oses].add(const)
-    group_consts = {grp: v | EXTRAS.get(grp, set()) for grp, v in group_consts.items()}
+        groups[cfgs].add(wanted_const)
+
+    # Step 4: Build output
+    output = ""
+    for cfgs, consts in sorted(groups.items(), key=lambda t: (len(t[0]), sorted(t[0]))):
+        target = next((target for target in TARGETS if target.cfgs == cfgs), None)
+        if target:
+            # If we found an exact target. Add its "extras" as-is
+            consts |= target.extras
 
-    code = "\n\n".join(
-        f"""
-{cfg}
+        cfgs_inner = ",".join(sorted(map(str, cfgs)))
+
+        if len(cfgs) >= 2:
+            cfgs_rust = f"#[cfg(any({cfgs_inner}))]"
+        else:
+            cfgs_rust = f"#[cfg({cfgs_inner})]"
+
+        imports = ",".join(consts)
+        entry = f"""
+{cfgs_rust}
 #[pyattr]
-{use}
+use libc::{{{imports}}};
 """.strip()
-        for cfg, use in format_groups(group_consts)
-    )
 
-    print(code)
+        output += f"{entry}\n\n"
+
+    print(rustfmt(output))
 
 
 if __name__ == "__main__":
diff --git a/scripts/update_lib/cmd_auto_mark.py b/scripts/update_lib/cmd_auto_mark.py
index 0714f2a67dd..c77cbf300f1 100644
--- a/scripts/update_lib/cmd_auto_mark.py
+++ b/scripts/update_lib/cmd_auto_mark.py
@@ -71,45 +71,81 @@ def run_test(test_name: str, skip_build: bool = False) -> TestResult:
     return parse_results(result)
 
 
+def _try_parse_test_info(test_info: str) -> tuple[str, str] | None:
+    """Try to extract (name, path) from 'test_name (path)' or 'test_name (path) [subtest]'."""
+    first_space = test_info.find(" ")
+    if first_space > 0:
+        name = test_info[:first_space]
+        rest = test_info[first_space:].strip()
+        if rest.startswith("("):
+            end_paren = rest.find(")")
+            if end_paren > 0:
+                return name, rest[1:end_paren]
+    return None
+
+
 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 multiline format: "test_name (path)\ndocstring ... RESULT"
+    pending_test_info = None
 
     for line in lines:
         if re.search(r"Run \d+ tests? sequentially", line):
             in_test_results = True
-        elif line.startswith("-----------"):
+        elif "== Tests result: " in line:
             in_test_results = False
 
         if in_test_results and " ... " in line:
-            line = line.strip()
+            stripped = line.strip()
             # Skip lines that don't look like test results
-            if line.startswith("tests") or line.startswith("["):
+            if stripped.startswith("tests") or stripped.startswith("["):
+                pending_test_info = None
                 continue
             # Parse: "test_name (path) [subtest] ... RESULT"
-            parts = line.split(" ... ")
+            parts = stripped.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"):
+                    pending_test_info = None
                     continue
-                # Extract test name (first word)
-                first_space = test_info.find(" ")
-                if first_space > 0:
+                # Try parsing from this line (single-line format)
+                parsed = _try_parse_test_info(test_info)
+                if not parsed and pending_test_info:
+                    # Multiline format: previous line had test_name (path)
+                    parsed = _try_parse_test_info(pending_test_info)
+                if parsed:
                     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)
+                    test.name, test.path = parsed
+                    test.result = result_str
+                    test_results.tests.append(test)
+                pending_test_info = None
+
+        elif in_test_results:
+            # Track test info for multiline format:
+            #   test_name (path)
+            #   docstring ... RESULT
+            stripped = line.strip()
+            if (
+                stripped
+                and "(" in stripped
+                and stripped.endswith(")")
+                and ":" not in stripped.split("(")[0]
+            ):
+                pending_test_info = stripped
+            else:
+                pending_test_info = None
+
+            # Also check for Tests result on non-" ... " lines
+            if "== Tests result: " in line:
+                res = line.split("== Tests result: ")[1]
+                res = res.split(" ")[0]
+                test_results.tests_result = res
 
         elif "== Tests result: " in line:
             res = line.split("== Tests result: ")[1]
@@ -117,7 +153,7 @@ def parse_results(result: subprocess.CompletedProcess) -> TestResult:
             test_results.tests_result = res
 
         # Parse: "UNEXPECTED SUCCESS: test_name (path)"
-        elif line.startswith("UNEXPECTED SUCCESS: "):
+        if line.startswith("UNEXPECTED SUCCESS: "):
             rest = line[len("UNEXPECTED SUCCESS: ") :]
             # Format: "test_name (path)"
             first_space = rest.find(" ")
@@ -214,6 +250,99 @@ def path_to_test_parts(path: str) -> list[str]:
     return parts[-2:]
 
 
+def _expand_stripped_to_children(
+    contents: str,
+    stripped_tests: set[tuple[str, str]],
+    all_failing_tests: set[tuple[str, str]],
+) -> set[tuple[str, str]]:
+    """Find child-class failures that correspond to stripped parent-class markers.
+
+    When ``strip_reasonless_expected_failures`` removes a marker from a parent
+    (mixin) class, test failures are reported against the concrete subclasses,
+    not the parent itself.  This function maps those child failures back so
+    they get re-marked (and later consolidated to the parent by
+    ``_consolidate_to_parent``).
+
+    Returns the set of ``(class, method)`` pairs from *all_failing_tests* that
+    should be re-marked.
+    """
+    # Direct matches (stripped test itself is a concrete TestCase)
+    result = stripped_tests & all_failing_tests
+
+    unmatched = stripped_tests - all_failing_tests
+    if not unmatched:
+        return result
+
+    tree = ast.parse(contents)
+    class_bases, class_methods = _build_inheritance_info(tree)
+
+    for parent_cls, method_name in unmatched:
+        if method_name not in class_methods.get(parent_cls, set()):
+            continue
+        for cls in _find_all_inheritors(
+            parent_cls, method_name, class_bases, class_methods
+        ):
+            if (cls, method_name) in all_failing_tests:
+                result.add((cls, method_name))
+
+    return result
+
+
+def _consolidate_to_parent(
+    contents: str,
+    failing_tests: set[tuple[str, str]],
+    error_messages: dict[tuple[str, str], str] | None = None,
+) -> tuple[set[tuple[str, str]], dict[tuple[str, str], str] | None]:
+    """Move failures to the parent class when ALL inheritors fail.
+
+    If every concrete subclass that inherits a method from a parent class
+    appears in *failing_tests*, replace those per-subclass entries with a
+    single entry on the parent.  This avoids creating redundant super-call
+    overrides in every child.
+
+    Returns:
+        (consolidated_failing_tests, consolidated_error_messages)
+    """
+    tree = ast.parse(contents)
+    class_bases, class_methods = _build_inheritance_info(tree)
+
+    # Group by (defining_parent, method) → set of failing children
+    from collections import defaultdict
+
+    groups: dict[tuple[str, str], set[str]] = defaultdict(set)
+    for class_name, method_name in failing_tests:
+        defining = _find_method_definition(
+            class_name, method_name, class_bases, class_methods
+        )
+        if defining and defining != class_name:
+            groups[(defining, method_name)].add(class_name)
+
+    if not groups:
+        return failing_tests, error_messages
+
+    result = set(failing_tests)
+    new_error_messages = dict(error_messages) if error_messages else {}
+
+    for (parent, method_name), failing_children in groups.items():
+        all_inheritors = _find_all_inheritors(
+            parent, method_name, class_bases, class_methods
+        )
+
+        if all_inheritors and failing_children >= all_inheritors:
+            # All inheritors fail → mark on parent instead
+            children_keys = {(child, method_name) for child in failing_children}
+            result -= children_keys
+            result.add((parent, method_name))
+            # Pick any child's error message for the parent
+            if new_error_messages:
+                for child in failing_children:
+                    msg = new_error_messages.pop((child, method_name), "")
+                    if msg:
+                        new_error_messages[(parent, method_name)] = msg
+
+    return result, new_error_messages or error_messages
+
+
 def build_patches(
     test_parts_set: set[tuple[str, str]],
     error_messages: dict[tuple[str, str], str] | None = None,
@@ -221,7 +350,7 @@ def build_patches(
     """Convert failing tests to patch format."""
     patches = {}
     error_messages = error_messages or {}
-    for class_name, method_name in test_parts_set:
+    for class_name, method_name in sorted(test_parts_set):
         if class_name not in patches:
             patches[class_name] = {}
         reason = error_messages.get((class_name, method_name), "")
@@ -232,13 +361,16 @@ def build_patches(
 
 
 def _is_super_call_only(func_node: ast.FunctionDef | ast.AsyncFunctionDef) -> bool:
-    """Check if the method body is just 'return super().method_name()'."""
+    """Check if the method body is just 'return super().method_name()' or 'return await 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
+    # Unwrap await for async methods
+    if isinstance(call, ast.Await):
+        call = call.value
     if not isinstance(call, ast.Call):
         return False
     if not isinstance(call.func, ast.Attribute):
@@ -254,6 +386,27 @@ def _is_super_call_only(func_node: ast.FunctionDef | ast.AsyncFunctionDef) -> bo
     return True
 
 
+def _method_removal_range(
+    func_node: ast.FunctionDef | ast.AsyncFunctionDef, lines: list[str]
+) -> range:
+    """Line range covering an entire method including decorators and a preceding COMMENT line."""
+    first = (
+        func_node.decorator_list[0].lineno - 1
+        if func_node.decorator_list
+        else func_node.lineno - 1
+    )
+    if (
+        first > 0
+        and lines[first - 1].strip().startswith("#")
+        and COMMENT in lines[first - 1]
+    ):
+        first -= 1
+    # Also remove a preceding blank line to avoid double-blanks after removal
+    if first > 0 and not lines[first - 1].strip():
+        first -= 1
+    return range(first, func_node.end_lineno)
+
+
 def _build_inheritance_info(tree: ast.Module) -> tuple[dict, dict]:
     """
     Build inheritance information from AST.
@@ -309,6 +462,20 @@ def _find_method_definition(
     return None
 
 
+def _find_all_inheritors(
+    parent: str, method_name: str, class_bases: dict, class_methods: dict
+) -> set[str]:
+    """Find all classes that inherit *method_name* from *parent* (not overriding it)."""
+    return {
+        cls
+        for cls in class_bases
+        if cls != parent
+        and method_name not in class_methods.get(cls, set())
+        and _find_method_definition(cls, method_name, class_bases, class_methods)
+        == parent
+    }
+
+
 def remove_expected_failures(
     contents: str, tests_to_remove: set[tuple[str, str]]
 ) -> str:
@@ -344,15 +511,7 @@ def remove_expected_failures(
             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)
+                lines_to_remove.update(_method_removal_range(item, lines))
             else:
                 for dec in item.decorator_list:
                     dec_line = dec.lineno - 1
@@ -367,11 +526,18 @@ def remove_expected_failures(
                         and lines[dec_line - 1].strip().startswith("#")
                         and COMMENT in lines[dec_line - 1]
                     )
+                    has_comment_after = (
+                        dec_line + 1 < len(lines)
+                        and lines[dec_line + 1].strip().startswith("#")
+                        and COMMENT not 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)
+                        if has_comment_after and has_comment_on_line:
+                            lines_to_remove.add(dec_line + 1)
 
     for line_idx in sorted(lines_to_remove, reverse=True):
         del lines[line_idx]
@@ -442,12 +608,98 @@ def apply_test_changes(
         contents = remove_expected_failures(contents, unexpected_successes)
 
     if failing_tests:
+        failing_tests, error_messages = _consolidate_to_parent(
+            contents, failing_tests, error_messages
+        )
         patches = build_patches(failing_tests, error_messages)
         contents = apply_patches(contents, patches)
 
     return contents
 
 
+def strip_reasonless_expected_failures(
+    contents: str,
+) -> tuple[str, set[tuple[str, str]]]:
+    """Strip @expectedFailure decorators that have no failure reason.
+
+    Markers like ``@unittest.expectedFailure  # TODO: RUSTPYTHON`` (without a
+    reason after the semicolon) are removed so the tests fail normally during
+    the next test run and error messages can be captured.
+
+    Returns:
+        (modified_contents, stripped_tests) where stripped_tests is a set of
+        (class_name, method_name) tuples whose markers were removed.
+    """
+    tree = ast.parse(contents)
+    lines = contents.splitlines()
+    stripped_tests: set[tuple[str, str]] = set()
+    lines_to_remove: set[int] = set()
+
+    for node in ast.walk(tree):
+        if not isinstance(node, ast.ClassDef):
+            continue
+        for item in node.body:
+            if not isinstance(item, (ast.FunctionDef, ast.AsyncFunctionDef)):
+                continue
+            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 not has_comment_on_line and not has_comment_before:
+                    continue  # not our marker
+
+                # Check if there's a reason (on either the decorator or before)
+                for check_line in (
+                    line_content,
+                    lines[dec_line - 1] if has_comment_before else "",
+                ):
+                    match = re.search(rf"{COMMENT}(.*)", check_line)
+                    if match and match.group(1).strip(";:, "):
+                        break  # has a reason, keep it
+                else:
+                    # No reason found — strip this decorator
+                    stripped_tests.add((node.name, item.name))
+
+                    if _is_super_call_only(item):
+                        # Remove entire super-call override (the method
+                        # exists only to apply the decorator; without it
+                        # the override is pointless and blocks parent
+                        # consolidation)
+                        lines_to_remove.update(_method_removal_range(item, lines))
+                    else:
+                        lines_to_remove.add(dec_line)
+
+                        if has_comment_before:
+                            lines_to_remove.add(dec_line - 1)
+
+                        # Also remove a reason-comment on the line after (old format)
+                        if (
+                            has_comment_on_line
+                            and dec_line + 1 < len(lines)
+                            and lines[dec_line + 1].strip().startswith("#")
+                            and COMMENT not in lines[dec_line + 1]
+                        ):
+                            lines_to_remove.add(dec_line + 1)
+
+    if not lines_to_remove:
+        return contents, stripped_tests
+
+    for idx in sorted(lines_to_remove, reverse=True):
+        del lines[idx]
+
+    return "\n".join(lines) + "\n" if lines else "", stripped_tests
+
+
 def extract_test_methods(contents: str) -> set[tuple[str, str]]:
     """
     Extract all test method names from file contents.
@@ -490,6 +742,14 @@ def auto_mark_file(
     if not test_path.exists():
         raise FileNotFoundError(f"File not found: {test_path}")
 
+    # Strip reason-less markers so those tests fail normally and we capture
+    # their error messages during the test run.
+    contents = test_path.read_text(encoding="utf-8")
+    original_contents = contents
+    contents, stripped_tests = strip_reasonless_expected_failures(contents)
+    if stripped_tests:
+        test_path.write_text(contents, encoding="utf-8")
+
     test_name = get_test_module_name(test_path)
     if verbose:
         print(f"Running test: {test_name}")
@@ -497,12 +757,26 @@ def auto_mark_file(
     results = run_test(test_name, skip_build=skip_build)
 
     # Check if test run failed entirely (e.g., import error, crash)
-    if not results.tests_result:
+    if (
+        not results.tests_result
+        and not results.tests
+        and not results.unexpected_successes
+    ):
+        # Restore original contents before raising
+        if stripped_tests:
+            test_path.write_text(original_contents, encoding="utf-8")
         raise TestRunError(
             f"Test run failed for {test_name}. "
             f"Output: {results.stdout[-500:] if results.stdout else '(no output)'}"
         )
 
+    # If the run crashed (incomplete), restore original file so that markers
+    # for tests that never ran are preserved.  Only observed results will be
+    # re-applied below.
+    if not results.tests_result and stripped_tests:
+        test_path.write_text(original_contents, encoding="utf-8")
+        stripped_tests = set()
+
     contents = test_path.read_text(encoding="utf-8")
 
     all_failing_tests, unexpected_successes, error_messages = collect_test_changes(
@@ -520,6 +794,13 @@ def auto_mark_file(
     else:
         failing_tests = set()
 
+    # Re-mark stripped tests that still fail (to restore markers with reasons).
+    # Uses inheritance expansion: if a parent marker was stripped, child
+    # failures are included so _consolidate_to_parent can re-mark the parent.
+    failing_tests |= _expand_stripped_to_children(
+        contents, stripped_tests, all_failing_tests
+    )
+
     regressions = all_failing_tests - failing_tests
 
     if verbose:
@@ -587,6 +868,21 @@ def auto_mark_directory(
     if not test_dir.is_dir():
         raise ValueError(f"Not a directory: {test_dir}")
 
+    # Get all .py files in directory
+    test_files = sorted(test_dir.glob("**/*.py"))
+
+    # Strip reason-less markers from ALL files before running tests so those
+    # tests fail normally and we capture their error messages.
+    stripped_per_file: dict[pathlib.Path, set[tuple[str, str]]] = {}
+    original_per_file: dict[pathlib.Path, str] = {}
+    for test_file in test_files:
+        contents = test_file.read_text(encoding="utf-8")
+        stripped_contents, stripped = strip_reasonless_expected_failures(contents)
+        if stripped:
+            original_per_file[test_file] = contents
+            test_file.write_text(stripped_contents, encoding="utf-8")
+            stripped_per_file[test_file] = stripped
+
     test_name = get_test_module_name(test_dir)
     if verbose:
         print(f"Running test: {test_name}")
@@ -594,20 +890,31 @@ def auto_mark_directory(
     results = run_test(test_name, skip_build=skip_build)
 
     # Check if test run failed entirely (e.g., import error, crash)
-    if not results.tests_result:
+    if (
+        not results.tests_result
+        and not results.tests
+        and not results.unexpected_successes
+    ):
+        # Restore original contents before raising
+        for fpath, original in original_per_file.items():
+            fpath.write_text(original, encoding="utf-8")
         raise TestRunError(
             f"Test run failed for {test_name}. "
             f"Output: {results.stdout[-500:] if results.stdout else '(no output)'}"
         )
 
+    # If the run crashed (incomplete), restore original files so that markers
+    # for tests that never ran are preserved.
+    if not results.tests_result and original_per_file:
+        for fpath, original in original_per_file.items():
+            fpath.write_text(original, encoding="utf-8")
+        stripped_per_file.clear()
+
     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 = get_test_module_name(test_file)
@@ -632,6 +939,15 @@ def auto_mark_directory(
         else:
             failing_tests = set()
 
+        # Re-mark stripped tests that still fail (restore markers with reasons).
+        # Uses inheritance expansion for parent→child mapping.
+        stripped = stripped_per_file.get(test_file, set())
+        if stripped:
+            file_contents = test_file.read_text(encoding="utf-8")
+            failing_tests |= _expand_stripped_to_children(
+                file_contents, stripped, all_failing_tests
+            )
+
         regressions = all_failing_tests - failing_tests
 
         if failing_tests or unexpected_successes:
diff --git a/scripts/update_lib/cmd_migrate.py b/scripts/update_lib/cmd_migrate.py
index 77292831cea..97cdf7b141b 100644
--- a/scripts/update_lib/cmd_migrate.py
+++ b/scripts/update_lib/cmd_migrate.py
@@ -13,6 +13,7 @@
 
 import argparse
 import pathlib
+import shutil
 import sys
 
 sys.path.insert(0, str(pathlib.Path(__file__).parent.parent))
@@ -92,23 +93,29 @@ def patch_directory(
     if lib_dir is None:
         lib_dir = parse_lib_path(src_dir)
 
-    src_files = sorted(src_dir.glob("**/*.py"))
+    src_files = sorted(f for f in src_dir.glob("**/*") if f.is_file())
 
     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)
+        if src_file.suffix == ".py":
+            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(encoding="utf-8")
+
+            lib_file.parent.mkdir(parents=True, exist_ok=True)
+            lib_file.write_text(content, encoding="utf-8")
         else:
             if verbose:
                 print(f"Copying: {src_file} -> {lib_file}")
-            content = src_file.read_text(encoding="utf-8")
-
-        lib_file.parent.mkdir(parents=True, exist_ok=True)
-        lib_file.write_text(content, encoding="utf-8")
+            lib_file.parent.mkdir(parents=True, exist_ok=True)
+            shutil.copy2(src_file, lib_file)
 
 
 def main(argv: list[str] | None = None) -> int:
diff --git a/scripts/update_lib/cmd_quick.py b/scripts/update_lib/cmd_quick.py
index 939ad50b780..c43e0761518 100644
--- a/scripts/update_lib/cmd_quick.py
+++ b/scripts/update_lib/cmd_quick.py
@@ -31,7 +31,7 @@
 
 sys.path.insert(0, str(pathlib.Path(__file__).parent.parent))
 
-from update_lib.deps import get_test_paths
+from update_lib.deps import DEPENDENCIES, get_test_paths
 from update_lib.file_utils import (
     construct_lib_path,
     get_cpython_dir,
@@ -80,7 +80,7 @@ def quick(
     mark_failure: bool = False,
     verbose: bool = True,
     skip_build: bool = False,
-) -> None:
+) -> list[pathlib.Path]:
     """
     Process a file or directory: migrate + auto-mark.
 
@@ -91,10 +91,15 @@ def quick(
         mark_failure: Add @expectedFailure to ALL failing tests
         verbose: Print progress messages
         skip_build: Skip cargo build, use pre-built binary
+
+    Returns:
+        List of extra paths (data dirs, hard deps) that were copied/migrated.
     """
     from update_lib.cmd_auto_mark import auto_mark_directory, auto_mark_file
     from update_lib.cmd_migrate import patch_directory, patch_file
 
+    extra_paths: list[pathlib.Path] = []
+
     # Determine lib_path and whether to migrate
     if is_lib_path(src_path):
         no_migrate = True
@@ -128,6 +133,7 @@ def quick(
                 patch_directory(dep_src, dep_lib, verbose=False)
             else:
                 patch_file(dep_src, dep_lib, verbose=False)
+            extra_paths.append(dep_lib)
 
         # Copy data directories (no migration)
         import shutil
@@ -146,6 +152,7 @@ def quick(
             else:
                 data_lib.parent.mkdir(parents=True, exist_ok=True)
                 shutil.copy2(data_src, data_lib)
+            extra_paths.append(data_lib)
 
     # Step 2: Auto-mark
     if not no_auto_mark:
@@ -174,6 +181,8 @@ def quick(
                 print(f"Added expectedFailure to {num_added} tests")
             print(f"Removed expectedFailure from {num_removed} tests")
 
+    return extra_paths
+
 
 def get_cpython_version(cpython_dir: pathlib.Path) -> str:
     """Get CPython version from git tag."""
@@ -194,6 +203,7 @@ def git_commit(
     lib_path: pathlib.Path | None,
     test_paths: list[pathlib.Path] | pathlib.Path | None,
     cpython_dir: pathlib.Path,
+    hard_deps: list[pathlib.Path] | None = None,
     verbose: bool = True,
 ) -> bool:
     """Commit changes with CPython author.
@@ -203,6 +213,7 @@ def git_commit(
         lib_path: Path to library file/directory (or None)
         test_paths: Path(s) to test file/directory (or None)
         cpython_dir: Path to cpython directory
+        hard_deps: Path(s) to hard dependency files (or None)
         verbose: Print progress messages
 
     Returns:
@@ -216,6 +227,10 @@ def git_commit(
     elif isinstance(test_paths, pathlib.Path):
         test_paths = [test_paths]
 
+    # Normalize hard_deps to list
+    if hard_deps is None:
+        hard_deps = []
+
     # Stage changes
     paths_to_add = []
     if lib_path and lib_path.exists():
@@ -223,6 +238,9 @@ def git_commit(
     for test_path in test_paths:
         if test_path and test_path.exists():
             paths_to_add.append(str(test_path))
+    for dep_path in hard_deps:
+        if dep_path and dep_path.exists():
+            paths_to_add.append(str(dep_path))
 
     if not paths_to_add:
         return False
@@ -362,6 +380,7 @@ def main(argv: list[str] | None = None) -> int:
         # Track library path for commit
         lib_file_path = None
         test_path = None
+        hard_deps_for_commit = []
 
         # If it's a library path (not test path), do copy_lib first
         if not is_test_path(src_path):
@@ -384,6 +403,13 @@ def main(argv: list[str] | None = None) -> int:
                 if default_test.exists():
                     test_src_paths = (default_test,)
 
+            # Collect hard dependencies for commit
+            lib_deps = DEPENDENCIES.get(module_name, {})
+            for dep_name in lib_deps.get("hard_deps", []):
+                dep_lib_path = pathlib.Path("Lib") / dep_name
+                if dep_lib_path.exists():
+                    hard_deps_for_commit.append(dep_lib_path)
+
             # Process all test paths
             test_paths_for_commit = []
             for test_src in test_src_paths:
@@ -394,13 +420,14 @@ def main(argv: list[str] | None = None) -> int:
                 test_lib_path = parse_lib_path(test_src)
                 test_paths_for_commit.append(test_lib_path)
 
-                quick(
+                extra = quick(
                     test_src,
                     no_migrate=not args.migrate,
                     no_auto_mark=not args.auto_mark,
                     mark_failure=args.mark_failure,
                     skip_build=not args.build,
                 )
+                hard_deps_for_commit.extend(extra)
 
             test_paths = test_paths_for_commit
         else:
@@ -409,20 +436,25 @@ def main(argv: list[str] | None = None) -> int:
                 parse_lib_path(src_path) if not is_lib_path(src_path) else src_path
             )
 
-            quick(
+            extra = quick(
                 src_path,
                 no_migrate=not args.migrate,
                 no_auto_mark=not args.auto_mark,
                 mark_failure=args.mark_failure,
                 skip_build=not args.build,
             )
+            hard_deps_for_commit.extend(extra)
             test_paths = [test_path]
 
         # Step 3: Git commit
         if args.commit:
             cpython_dir = get_cpython_dir(original_src)
             git_commit(
-                get_module_name(original_src), lib_file_path, test_paths, cpython_dir
+                get_module_name(original_src),
+                lib_file_path,
+                test_paths,
+                cpython_dir,
+                hard_deps=hard_deps_for_commit,
             )
 
         return 0
diff --git a/scripts/update_lib/cmd_todo.py b/scripts/update_lib/cmd_todo.py
index 87099aa5422..a7cf83f7b9e 100644
--- a/scripts/update_lib/cmd_todo.py
+++ b/scripts/update_lib/cmd_todo.py
@@ -15,6 +15,9 @@
 
 from update_lib.deps import (
     count_test_todos,
+    get_module_diff_stat,
+    get_module_last_updated,
+    get_test_last_updated,
     is_test_tracked,
     is_test_up_to_date,
 )
@@ -142,11 +145,12 @@ def get_all_tests(cpython_prefix: str) -> list[str]:
 
     tests = set()
     for entry in test_dir.iterdir():
-        # Skip private/internal and special directories
-        if entry.name.startswith(("_", ".")):
-            continue
         # Skip non-test items
-        if not entry.name.startswith("test_"):
+        if "test" not in entry.name:
+            continue
+
+        # Exclude special cases
+        if "regrtest" in entry.name:
             continue
 
         if entry.is_file() and entry.suffix == ".py":
@@ -333,8 +337,16 @@ def compute_test_todo_list(
             # Get order from DEPENDENCIES
             test_order = lib_test_order[lib_name].index(test_name)
         else:
-            # Extract lib name from test name (test_foo -> foo)
-            lib_name = test_name.removeprefix("test_")
+            # Extract lib name from test name:
+            # - test_foo -> foo
+            # - datetimetester -> datetime
+            # - xmltests -> xml
+            lib_name = (
+                test_name.removeprefix("test_")
+                .removeprefix("_test")
+                .removesuffix("tester")
+                .removesuffix("tests")
+            )
             test_order = 0  # Default order for tests not in DEPENDENCIES
 
         # Check if corresponding lib is up-to-date
@@ -368,6 +380,18 @@ def compute_test_todo_list(
     return result
 
 
+def _format_meta_suffix(item: dict) -> str:
+    """Format metadata suffix (last updated date and diff count)."""
+    parts = []
+    last_updated = item.get("last_updated")
+    diff_lines = item.get("diff_lines", 0)
+    if last_updated:
+        parts.append(last_updated)
+    if diff_lines > 0:
+        parts.append(f"Δ{diff_lines}")
+    return f" | {' '.join(parts)}" if parts else ""
+
+
 def _format_test_suffix(item: dict) -> str:
     """Format suffix for test item (TODO count or untracked)."""
     tracked = item.get("tracked", True)
@@ -410,13 +434,15 @@ def format_test_todo_list(
         primary = tests[0]
         done_mark = "[x]" if primary["up_to_date"] else "[ ]"
         suffix = _format_test_suffix(primary)
-        lines.append(f"- {done_mark} {primary['name']}{suffix}")
+        meta = _format_meta_suffix(primary)
+        lines.append(f"- {done_mark} `{primary['name']}`{suffix}{meta}")
 
         # Rest are indented
         for item in tests[1:]:
             done_mark = "[x]" if item["up_to_date"] else "[ ]"
             suffix = _format_test_suffix(item)
-            lines.append(f"  - {done_mark} {item['name']}{suffix}")
+            meta = _format_meta_suffix(item)
+            lines.append(f"  - {done_mark} `{item['name']}`{suffix}{meta}")
 
     return lines
 
@@ -462,7 +488,8 @@ def format_todo_list(
         if rev_str:
             parts.append(f"({rev_str})")
 
-        lines.append(" ".join(parts))
+        line = " ".join(parts) + _format_meta_suffix(item)
+        lines.append(line)
 
         # Show hard_deps:
         # - Normal mode: only show if lib is up-to-date but hard_deps are not
@@ -482,7 +509,10 @@ def format_todo_list(
             for test_info in test_by_lib[name]:
                 test_done_mark = "[x]" if test_info["up_to_date"] else "[ ]"
                 suffix = _format_test_suffix(test_info)
-                lines.append(f"  - {test_done_mark} {test_info['name']}{suffix}")
+                meta = _format_meta_suffix(test_info)
+                lines.append(
+                    f"  - {test_done_mark} `{test_info['name']}`{suffix}{meta}"
+                )
 
         # Verbose mode: show detailed dependency info
         if verbose:
@@ -556,6 +586,28 @@ def format_all_todo(
         if include_done or lib_not_done or has_pending_test:
             lib_todo.append(item)
 
+    # Add metadata (last updated date and diff stat) to lib items
+    for item in lib_todo:
+        item["last_updated"] = get_module_last_updated(
+            item["name"], cpython_prefix, lib_prefix
+        )
+        item["diff_lines"] = (
+            0
+            if item["up_to_date"]
+            else get_module_diff_stat(item["name"], cpython_prefix, lib_prefix)
+        )
+
+    # Add last_updated to displayed test items
+    for tests in test_by_lib.values():
+        for test in tests:
+            test["last_updated"] = get_test_last_updated(
+                test["name"], cpython_prefix, lib_prefix
+            )
+    for test in no_lib_tests:
+        test["last_updated"] = get_test_last_updated(
+            test["name"], cpython_prefix, lib_prefix
+        )
+
     # Format lib todo with embedded tests
     lines.extend(format_todo_list(lib_todo, test_by_lib, limit, verbose))
 
diff --git a/scripts/update_lib/deps.py b/scripts/update_lib/deps.py
index 4dd0a9d2ee8..49ddf9a8730 100644
--- a/scripts/update_lib/deps.py
+++ b/scripts/update_lib/deps.py
@@ -8,9 +8,9 @@
 """
 
 import ast
+import difflib
 import functools
 import pathlib
-import re
 import shelve
 import subprocess
 
@@ -31,62 +31,107 @@
 # === Import parsing utilities ===
 
 
-def _extract_top_level_code(content: str) -> str:
-    """Extract only top-level code from Python content for faster parsing."""
-    def_idx = content.find("\ndef ")
-    class_idx = content.find("\nclass ")
+class ImportVisitor(ast.NodeVisitor):
+    def __init__(self) -> None:
+        self.__imports = set()
 
-    indices = [i for i in (def_idx, class_idx) if i != -1]
-    if indices:
-        content = content[: min(indices)]
-    return content.rstrip("\n")
+    @property
+    def test_imports(self) -> set[str]:
+        imports = set()
+        for module in self.__imports:
+            if not module.startswith("test."):
+                continue
+            name = module.removeprefix("test.")
 
+            if name == "support" or name.startswith("support."):
+                continue
 
-_FROM_TEST_IMPORT_RE = re.compile(r"^from test import (.+)", re.MULTILINE)
-_FROM_TEST_DOT_RE = re.compile(r"^from test\.(\w+)", re.MULTILINE)
-_IMPORT_TEST_DOT_RE = re.compile(r"^import test\.(\w+)", re.MULTILINE)
+            imports.add(name)
 
+        return imports
 
-def parse_test_imports(content: str) -> set[str]:
-    """Parse test file content and extract test package dependencies."""
-    content = _extract_top_level_code(content)
-    imports = set()
+    @property
+    def lib_imports(self) -> set[str]:
+        return {module for module in self.__imports if not module.startswith("test.")}
 
-    for match in _FROM_TEST_IMPORT_RE.finditer(content):
-        import_list = match.group(1)
-        for part in import_list.split(","):
-            name = part.split()[0].strip()
-            if name and name not in ("support", "__init__"):
-                imports.add(name)
+    def visit_Import(self, node):
+        for alias in node.names:
+            self.__imports.add(alias.name)
 
-    for match in _FROM_TEST_DOT_RE.finditer(content):
-        dep = match.group(1)
-        if dep not in ("support", "__init__"):
-            imports.add(dep)
+    def visit_ImportFrom(self, node):
+        try:
+            module = node.module
+        except AttributeError:
+            # Ignore `from . import my_internal_module`
+            return
 
-    for match in _IMPORT_TEST_DOT_RE.finditer(content):
-        dep = match.group(1)
-        if dep not in ("support", "__init__"):
-            imports.add(dep)
+        if module is None:  # Ignore `from . import my_internal_module`
+            return
 
-    return imports
+        for alias in node.names:
+            # We only care about what we import if it was from the "test" module
+            if module == "test":
+                name = f"{module}.{alias.name}"
+            else:
+                name = module
 
+            self.__imports.add(name)
 
-_IMPORT_RE = re.compile(r"^import\s+(\w[\w.]*)", re.MULTILINE)
-_FROM_IMPORT_RE = re.compile(r"^from\s+(\w[\w.]*)\s+import", re.MULTILINE)
+    def visit_Call(self, node) -> None:
+        """
+        In test files, there's sometimes use of:
 
+        ```python
+        import test.support
+        from test.support import script_helper
 
-def parse_lib_imports(content: str) -> set[str]:
-    """Parse library file and extract all imported module names."""
-    imports = set()
+        script = support.findfile("_test_atexit.py")
+        script_helper.run_test_script(script)
+        ```
+
+        This imports "_test_atexit.py" but does not show as an import node.
+        """
+        func = node.func
+        if not isinstance(func, ast.Attribute):
+            return
 
-    for match in _IMPORT_RE.finditer(content):
-        imports.add(match.group(1))
+        value = func.value
+        if not isinstance(value, ast.Name):
+            return
 
-    for match in _FROM_IMPORT_RE.finditer(content):
-        imports.add(match.group(1))
+        if (value.id != "support") or (func.attr != "findfile"):
+            return
 
-    return imports
+        arg = node.args[0]
+        if not isinstance(arg, ast.Constant):
+            return
+
+        target = arg.value
+        if not target.endswith(".py"):
+            return
+
+        target = target.removesuffix(".py")
+        self.__imports.add(f"test.{target}")
+
+
+def parse_test_imports(content: str) -> frozenset[str]:
+    """Parse test file content and extract test package dependencies."""
+    if not (tree := safe_parse_ast(content)):
+        return set()
+
+    visitor = ImportVisitor()
+    visitor.visit(tree)
+    return visitor.test_imports
+
+
+def parse_lib_imports(content: str) -> frozenset[str]:
+    """Parse library file and extract all imported module names."""
+    if not (tree := safe_parse_ast(content)):
+        return set()
+
+    visitor = ImportVisitor()
+    visitor.visit(tree)
+    return visitor.lib_imports
 
 
 # === TODO marker utilities ===
@@ -97,13 +142,12 @@ def parse_lib_imports(content: str) -> set[str]:
 def filter_rustpython_todo(content: str) -> str:
     """Remove lines containing RustPython TODO markers."""
     lines = content.splitlines(keepends=True)
-    filtered = [line for line in lines if TODO_MARKER not in line]
-    return "".join(filtered)
+    return "".join(line for line in lines if TODO_MARKER not in line)
 
 
 def count_rustpython_todo(content: str) -> int:
     """Count lines containing RustPython TODO markers."""
-    return sum(1 for line in content.splitlines() if TODO_MARKER in line)
+    return content.count(TODO_MARKER)
 
 
 def count_todo_in_path(path: pathlib.Path) -> int:
@@ -112,10 +156,7 @@ def count_todo_in_path(path: pathlib.Path) -> int:
         content = safe_read_text(path)
         return count_rustpython_todo(content) if content else 0
 
-    total = 0
-    for _, content in read_python_files(path):
-        total += count_rustpython_todo(content)
-    return total
+    return sum(count_rustpython_todo(content) for _, content in read_python_files(path))
 
 
 # === Test utilities ===
@@ -227,6 +268,7 @@ def clear_import_graph_caches() -> None:
         "test": [
             "test_int.py",
             "test_long.py",
+            "test_int_literal.py",
         ],
     },
     "exception": {
@@ -247,6 +289,7 @@ def clear_import_graph_caches() -> None:
             "test_dictcomps.py",
             "test_dictviews.py",
             "test_userdict.py",
+            "mapping_tests.py",
         ],
     },
     "list": {
@@ -276,16 +319,29 @@ def clear_import_graph_caches() -> None:
     },
     "pickle": {
         "hard_deps": ["_compat_pickle.py"],
+        "test": [
+            "test_pickle.py",
+            "test_picklebuffer.py",
+            "test_pickletools.py",
+        ],
     },
     "re": {
         "hard_deps": ["sre_compile.py", "sre_constants.py", "sre_parse.py"],
+        "test": [
+            "test_re.py",
+            "re_tests.py",
+        ],
     },
     "weakref": {
         "hard_deps": ["_weakrefset.py"],
+        "test": [
+            "test_weakref.py",
+            "test_weakset.py",
+        ],
     },
     "codecs": {
         "test": [
-            "test_codecs.py",
+            "test_charmapcodec.py",
             "test_codeccallbacks.py",
             "test_codecencodings_cn.py",
             "test_codecencodings_hk.py",
@@ -298,8 +354,9 @@ def clear_import_graph_caches() -> None:
             "test_codecmaps_jp.py",
             "test_codecmaps_kr.py",
             "test_codecmaps_tw.py",
-            "test_charmapcodec.py",
+            "test_codecs.py",
             "test_multibytecodec.py",
+            "testcodec.py",
         ],
     },
     # Non-pattern hard_deps (can't be auto-detected)
@@ -308,6 +365,7 @@ def clear_import_graph_caches() -> None:
         "test": [
             "test_ast.py",
             "test_unparse.py",
+            "test_type_comments.py",
         ],
     },
     # Data directories
@@ -317,6 +375,22 @@ def clear_import_graph_caches() -> None:
     "turtle": {
         "hard_deps": ["turtledemo"],
     },
+    "sysconfig": {
+        "hard_deps": ["_aix_support.py", "_osx_support.py"],
+        "test": [
+            "test_sysconfig.py",
+            "test__osx_support.py",
+        ],
+    },
+    "tkinter": {
+        "test": [
+            "test_tkinter",
+            "test_ttk",
+            "test_ttk_textonly.py",
+            "test_tcl.py",
+            "test_idle",
+        ],
+    },
     # Test support library (like regrtest)
     "support": {
         "lib": ["test/support"],
@@ -339,6 +413,8 @@ def clear_import_graph_caches() -> None:
             "test_pulldom.py",
             "test_pyexpat.py",
             "test_sax.py",
+            "test_xml_dom_minicompat.py",
+            "test_xml_dom_xmlbuilder.py",
         ],
     },
     "multiprocessing": {
@@ -346,6 +422,8 @@ def clear_import_graph_caches() -> None:
             "test_multiprocessing_fork",
             "test_multiprocessing_forkserver",
             "test_multiprocessing_spawn",
+            "test_multiprocessing_main_handling.py",
+            "_test_multiprocessing.py",
         ],
     },
     "urllib": {
@@ -361,6 +439,7 @@ def clear_import_graph_caches() -> None:
         ],
     },
     "collections": {
+        "hard_deps": ["_collections_abc.py"],
         "test": [
             "test_collections.py",
             "test_deque.py",
@@ -422,6 +501,8 @@ def clear_import_graph_caches() -> None:
             "test_syslog.py",
             "test_sys_setprofile.py",
             "test_sys_settrace.py",
+            "test_audit.py",
+            "audit-tests.py",
         ],
     },
     "str": {
@@ -472,6 +553,11 @@ def clear_import_graph_caches() -> None:
             "test_descrtut.py",
         ],
     },
+    "code": {
+        "test": [
+            "test_code_module.py",
+        ],
+    },
     "contextlib": {
         "test": [
             "test_contextlib.py",
@@ -479,6 +565,7 @@ def clear_import_graph_caches() -> None:
         ],
     },
     "io": {
+        "hard_deps": ["_pyio.py"],
         "test": [
             "test_io.py",
             "test_bufio.py",
@@ -489,8 +576,10 @@ def clear_import_graph_caches() -> None:
     "dbm": {
         "test": [
             "test_dbm.py",
+            "test_dbm_dumb.py",
             "test_dbm_gnu.py",
             "test_dbm_ndbm.py",
+            "test_dbm_sqlite3.py",
         ],
     },
     "datetime": {
@@ -500,11 +589,6 @@ def clear_import_graph_caches() -> None:
             "test_strptime.py",
         ],
     },
-    "concurrent": {
-        "test": [
-            "test_concurrent_futures",
-        ],
-    },
     "locale": {
         "test": [
             "test_locale.py",
@@ -550,6 +634,93 @@ def clear_import_graph_caches() -> None:
             "test_stable_abi_ctypes.py",
         ],
     },
+    # Grouped tests for modules without custom lib paths
+    "compile": {
+        "lib": [],
+        "test": [
+            "test_compile.py",
+            "test_compiler_assemble.py",
+            "test_compiler_codegen.py",
+            "test_peepholer.py",
+        ],
+    },
+    "math": {
+        "lib": [],
+        "test": [
+            "test_math.py",
+            "test_math_property.py",
+        ],
+    },
+    "float": {
+        "lib": [],
+        "test": [
+            "test_float.py",
+            "test_strtod.py",
+        ],
+    },
+    "zipfile": {
+        "test": [
+            "test_zipfile.py",
+            "test_zipfile64.py",
+        ],
+    },
+    "smtplib": {
+        "test": [
+            "test_smtplib.py",
+            "test_smtpnet.py",
+        ],
+    },
+    "profile": {
+        "test": [
+            "test_profile.py",
+            "test_cprofile.py",
+        ],
+    },
+    "string": {
+        "test": [
+            "test_string.py",
+            "test_userstring.py",
+        ],
+    },
+    "os": {
+        "test": [
+            "test_os.py",
+            "test_popen.py",
+        ],
+    },
+    "pyrepl": {
+        "test": [
+            "test_pyrepl",
+            "test_repl.py",
+        ],
+    },
+    "concurrent": {
+        "test": [
+            "test_concurrent_futures",
+            "test_interpreters",
+            "test__interpreters.py",
+            "test__interpchannels.py",
+            "test_crossinterp.py",
+        ],
+    },
+    "atexit": {
+        "test": [
+            "test_atexit.py",
+            "_test_atexit.py",
+        ],
+    },
+    "eintr": {
+        "test": [
+            "test_eintr.py",
+            "_test_eintr.py",
+        ]
+    },
+    "curses": {
+        "test": [
+            "test_curses.py",
+            "curses_tests.py",
+        ],
+    },
 }
 
 
@@ -583,12 +754,9 @@ def resolve_hard_dep_parent(name: str, cpython_prefix: str) -> str | None:
     # Auto-detect _py{module} or _py_{module} patterns
     # Only if the parent module actually exists
     if name.startswith("_py"):
-        if name.startswith("_py_"):
-            # _py_abc -> abc
-            parent = name[4:]
-        else:
-            # _pydatetime -> datetime
-            parent = name[3:]
+        # _py_abc -> abc
+        # _pydatetime -> datetime
+        parent = name.removeprefix("_py_").removeprefix("_py")
 
         # Verify the parent module exists
         lib_dir = pathlib.Path(cpython_prefix) / "Lib"
@@ -619,7 +787,7 @@ def resolve_test_to_lib(test_name: str) -> str | None:
         tests = dep_info.get("test", [])
         for test_path in tests:
             # test_path is like "test_urllib2.py" or "test_multiprocessing_fork"
-            path_stem = test_path[:-3] if test_path.endswith(".py") else test_path
+            path_stem = test_path.removesuffix(".py")
             if path_stem == test_name:
                 return lib_name
 
@@ -707,6 +875,10 @@ def resolve_test_to_lib(test_name: str) -> str | None:
     "test_makefile": {
         "data": ["wheeldata"],
     },
+    # profilee is used by test_monitoring
+    "test_monitoring": {
+        "hard_deps": ["profilee"],
+    },
 }
 
 
@@ -909,6 +1081,174 @@ def is_up_to_date(name: str, cpython_prefix: str, lib_prefix: str) -> bool:
     return found_any
 
 
+def _count_file_diff(file_a: pathlib.Path, file_b: pathlib.Path) -> int:
+    """Count changed lines between two text files using difflib."""
+    a_content = safe_read_text(file_a)
+    b_content = safe_read_text(file_b)
+    if a_content is None or b_content is None:
+        return 0
+    if a_content == b_content:
+        return 0
+    a_lines = a_content.splitlines()
+    b_lines = b_content.splitlines()
+    count = 0
+    for line in difflib.unified_diff(a_lines, b_lines, lineterm=""):
+        if (line.startswith("+") and not line.startswith("+++")) or (
+            line.startswith("-") and not line.startswith("---")
+        ):
+            count += 1
+    return count
+
+
+def _count_path_diff(path_a: pathlib.Path, path_b: pathlib.Path) -> int:
+    """Count changed lines between two paths (file or directory, *.py only)."""
+    if path_a.is_file() and path_b.is_file():
+        return _count_file_diff(path_a, path_b)
+    if path_a.is_dir() and path_b.is_dir():
+        total = 0
+        a_files = {f.relative_to(path_a) for f in path_a.rglob("*.py")}
+        b_files = {f.relative_to(path_b) for f in path_b.rglob("*.py")}
+        for rel in a_files & b_files:
+            total += _count_file_diff(path_a / rel, path_b / rel)
+        for rel in a_files - b_files:
+            content = safe_read_text(path_a / rel)
+            if content:
+                total += len(content.splitlines())
+        for rel in b_files - a_files:
+            content = safe_read_text(path_b / rel)
+            if content:
+                total += len(content.splitlines())
+        return total
+    return 0
+
+
+@functools.cache
+def _bulk_last_updated() -> dict[str, str]:
+    """Get last git commit dates for all paths under Lib/ in one git call.
+
+    Keys are Lib/-relative paths (e.g. "re/__init__.py", "test/test_os.py",
+    "os.py"), plus directory rollups (e.g. "re", "test/test_zoneinfo").
+
+    Returns:
+        Dict mapping Lib/-relative path to date string.
+    """
+    file_map: dict[str, str] = {}
+    try:
+        result = subprocess.run(
+            ["git", "log", "--format=%cd", "--date=short", "--name-only", "--", "Lib/"],
+            capture_output=True,
+            text=True,
+            timeout=30,
+        )
+        if result.returncode != 0:
+            return file_map
+    except Exception:
+        return file_map
+
+    current_date = None
+    for line in result.stdout.splitlines():
+        line = line.strip()
+        if not line:
+            continue
+        # Date lines are YYYY-MM-DD format
+        if len(line) == 10 and line[4] == "-" and line[7] == "-":
+            current_date = line
+        elif current_date and line.startswith("Lib/"):
+            # Strip "Lib/" prefix to get Lib-relative key
+            rel = line[4:]
+            if rel and rel not in file_map:
+                file_map[rel] = current_date
+
+    # Pre-compute directory rollups
+    dir_map: dict[str, str] = {}
+    for filepath, date in file_map.items():
+        parts = filepath.split("/")
+        for i in range(1, len(parts)):
+            dirpath = "/".join(parts[:i])
+            if dirpath not in dir_map or date > dir_map[dirpath]:
+                dir_map[dirpath] = date
+
+    dir_map.update(file_map)
+    return dir_map
+
+
+@functools.cache
+def _lib_prefix_stripped(lib_prefix: str) -> str:
+    """Get the normalized prefix to strip from paths, with trailing /."""
+    # e.g. "Lib" -> "Lib/", "./Lib" -> "Lib/", "../Lib" -> "../Lib/"
+    return pathlib.Path(lib_prefix).as_posix().rstrip("/") + "/"
+
+
+def _lookup_last_updated(paths: list[str], lib_prefix: str) -> str | None:
+    """Look up the most recent date among paths from the bulk cache."""
+    cache = _bulk_last_updated()
+    prefix = _lib_prefix_stripped(lib_prefix)
+    latest = None
+    for p in paths:
+        p_norm = pathlib.Path(p).as_posix()
+        # Strip lib_prefix to get Lib-relative key
+        # e.g. "Lib/test/test_os.py" -> "test/test_os.py"
+        #      "../Lib/re" -> "re"
+        if p_norm.startswith(prefix):
+            key = p_norm[len(prefix) :]
+        else:
+            key = p_norm
+        date = cache.get(key)
+        if date and (latest is None or date > latest):
+            latest = date
+    return latest
+
+
+def get_module_last_updated(
+    name: str, cpython_prefix: str, lib_prefix: str
+) -> str | None:
+    """Get the last git commit date for a module's Lib files."""
+    local_paths = []
+    for cpython_path in get_lib_paths(name, cpython_prefix):
+        if not cpython_path.exists():
+            continue
+        try:
+            rel_path = cpython_path.relative_to(cpython_prefix)
+            local_path = pathlib.Path(lib_prefix) / rel_path.relative_to("Lib")
+            if local_path.exists():
+                local_paths.append(str(local_path))
+        except ValueError:
+            continue
+    if not local_paths:
+        return None
+    return _lookup_last_updated(local_paths, lib_prefix)
+
+
+def get_module_diff_stat(name: str, cpython_prefix: str, lib_prefix: str) -> int:
+    """Count differing lines between cpython and local Lib for a module."""
+    total = 0
+    for cpython_path in get_lib_paths(name, cpython_prefix):
+        if not cpython_path.exists():
+            continue
+        try:
+            rel_path = cpython_path.relative_to(cpython_prefix)
+            local_path = pathlib.Path(lib_prefix) / rel_path.relative_to("Lib")
+        except ValueError:
+            continue
+        if not local_path.exists():
+            continue
+        total += _count_path_diff(cpython_path, local_path)
+    return total
+
+
+def get_test_last_updated(
+    test_name: str, cpython_prefix: str, lib_prefix: str
+) -> str | None:
+    """Get the last git commit date for a test's files."""
+    cpython_path = _get_cpython_test_path(test_name, cpython_prefix)
+    if cpython_path is None:
+        return None
+    local_path = _get_local_test_path(cpython_path, lib_prefix)
+    if not local_path.exists():
+        return None
+    return _lookup_last_updated([str(local_path)], lib_prefix)
+
+
 def get_test_dependencies(
     test_path: pathlib.Path,
 ) -> dict[str, list[pathlib.Path]]:
@@ -938,18 +1278,15 @@ def get_test_dependencies(
 
     # Convert imports to paths (deps)
     for imp in all_imports:
-        # Check if it's a test file (test_*) or support module
+        # Skip other test modules (test_*) - they are independently managed
+        # via their own update_lib entry. Only support/helper modules
+        # (e.g., string_tests, mapping_tests) should be treated as hard deps.
         if imp.startswith("test_"):
-            # It's a test, resolve to test path
-            dep_path = test_path.parent / f"{imp}.py"
-            if not dep_path.exists():
-                dep_path = test_path.parent / imp
-        else:
-            # Support module like string_tests, lock_tests, encoded_modules
-            # Check file first, then directory
-            dep_path = test_path.parent / f"{imp}.py"
-            if not dep_path.exists():
-                dep_path = test_path.parent / imp
+            continue
+
+        dep_path = test_path.parent / f"{imp}.py"
+        if not dep_path.exists():
+            dep_path = test_path.parent / imp
 
         if dep_path.exists() and dep_path not in result["hard_deps"]:
             result["hard_deps"].append(dep_path)
diff --git a/scripts/update_lib/patch_spec.py b/scripts/update_lib/patch_spec.py
index 410525794f0..d27d2e22fa7 100644
--- a/scripts/update_lib/patch_spec.py
+++ b/scripts/update_lib/patch_spec.py
@@ -247,9 +247,25 @@ def _iter_patch_lines(
 
     # Build cache of all classes (for Phase 2 to find classes without methods)
     cache = {}
+    # Build per-class set of async method names (for Phase 2 to generate correct override)
+    async_methods: dict[str, set[str]] = {}
+    # Track class bases for inherited async method lookup
+    class_bases: dict[str, list[str]] = {}
+    all_classes = {node.name for node in tree.body if isinstance(node, ast.ClassDef)}
     for node in tree.body:
         if isinstance(node, ast.ClassDef):
             cache[node.name] = node.end_lineno
+            class_bases[node.name] = [
+                base.id
+                for base in node.bases
+                if isinstance(base, ast.Name) and base.id in all_classes
+            ]
+            cls_async: set[str] = set()
+            for item in node.body:
+                if isinstance(item, ast.AsyncFunctionDef):
+                    cls_async.add(item.name)
+            if cls_async:
+                async_methods[node.name] = cls_async
 
     # Phase 1: Iterate and mark existing tests
     for cls_node, fn_node in iter_tests(tree):
@@ -266,15 +282,35 @@ def _iter_patch_lines(
         yield (lineno - 1, textwrap.indent(patch_lines, indent))
 
     # Phase 2: Iterate and mark inherited tests
-    for cls_name, tests in patches.items():
+    for cls_name, tests in sorted(patches.items()):
         lineno = cache.get(cls_name)
         if not lineno:
             print(f"WARNING: {cls_name} does not exist in remote file", file=sys.stderr)
             continue
 
-        for test_name, specs in tests.items():
+        for test_name, specs in sorted(tests.items()):
             decorators = "\n".join(spec.as_decorator() for spec in specs)
-            patch_lines = f"""
+            # Check current class and ancestors for async method
+            is_async = False
+            queue = [cls_name]
+            visited: set[str] = set()
+            while queue:
+                cur = queue.pop(0)
+                if cur in visited:
+                    continue
+                visited.add(cur)
+                if test_name in async_methods.get(cur, set()):
+                    is_async = True
+                    break
+                queue.extend(class_bases.get(cur, []))
+            if is_async:
+                patch_lines = f"""
+{decorators}
+async def {test_name}(self):
+{DEFAULT_INDENT}return await super().{test_name}()
+""".rstrip()
+            else:
+                patch_lines = f"""
 {decorators}
 def {test_name}(self):
 {DEFAULT_INDENT}return super().{test_name}()
diff --git a/scripts/update_lib/tests/test_auto_mark.py b/scripts/update_lib/tests/test_auto_mark.py
index d919601a0e9..ce89b0f9918 100644
--- a/scripts/update_lib/tests/test_auto_mark.py
+++ b/scripts/update_lib/tests/test_auto_mark.py
@@ -1,77 +1,95 @@
 """Tests for auto_mark.py - test result parsing and auto-marking."""
 
+import ast
+import pathlib
 import subprocess
+import tempfile
 import unittest
+from unittest import mock
 
 from update_lib.cmd_auto_mark import (
     Test,
     TestResult,
+    TestRunError,
+    _expand_stripped_to_children,
     _is_super_call_only,
     apply_test_changes,
+    auto_mark_directory,
+    auto_mark_file,
     collect_test_changes,
     extract_test_methods,
     parse_results,
     path_to_test_parts,
     remove_expected_failures,
+    strip_reasonless_expected_failures,
 )
 from update_lib.patch_spec import COMMENT
 
 
-class TestParseResults(unittest.TestCase):
-    """Tests for parse_results function."""
+def _make_result(stdout: str) -> subprocess.CompletedProcess:
+    return subprocess.CompletedProcess(
+        args=["test"], returncode=0, stdout=stdout, stderr=""
+    )
 
-    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.test_foo) ... FAIL
------------
+# -- fixtures shared across inheritance-aware tests --
+
+BASE_TWO_CHILDREN = """import unittest
+
+class Base:
+    def test_foo(self):
+        pass
+
+class ChildA(Base, unittest.TestCase):
+    pass
+
+class ChildB(Base, unittest.TestCase):
+    pass
 """
-        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.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.test_bar) ... ERROR
------------
+BASE_TWO_CHILDREN_ONE_OVERRIDE = """import unittest
+
+class Base:
+    def test_foo(self):
+        pass
+
+class ChildA(Base, unittest.TestCase):
+    pass
+
+class ChildB(Base, unittest.TestCase):
+    def test_foo(self):
+        # own implementation
+        pass
 """
-        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.test_foo) ... ok
+
+class TestParseResults(unittest.TestCase):
+    """Tests for parse_results function."""
+
+    def test_parse_fail_and_error(self):
+        """FAIL and ERROR are collected; ok is ignored."""
+        stdout = """\
+Run 3 tests sequentially
+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))
-        self.assertEqual(len(result.tests), 0)
+        result = parse_results(_make_result(stdout))
+        self.assertEqual(len(result.tests), 2)
+        by_name = {t.name: t for t in result.tests}
+        self.assertEqual(by_name["test_one"].path, "test.test_example.TestA.test_one")
+        self.assertEqual(by_name["test_one"].result, "fail")
+        self.assertEqual(by_name["test_three"].result, "error")
 
     def test_parse_unexpected_success(self):
-        """Test parsing unexpected success."""
-        stdout = """
+        stdout = """\
 Run 1 tests sequentially
 test_foo (test.test_example.TestClass.test_foo) ... unexpected success
 -----------
 UNEXPECTED SUCCESS: test_foo (test.test_example.TestClass.test_foo)
 """
-        result = parse_results(self._make_result(stdout))
+        result = parse_results(_make_result(stdout))
         self.assertEqual(len(result.unexpected_successes), 1)
         self.assertEqual(result.unexpected_successes[0].name, "test_foo")
         self.assertEqual(
@@ -79,48 +97,40 @@ def test_parse_unexpected_success(self):
         )
 
     def test_parse_tests_result(self):
-        """Test parsing tests result line."""
-        stdout = """
-== Tests result: FAILURE ==
-"""
-        result = parse_results(self._make_result(stdout))
+        result = parse_results(_make_result("== Tests result: FAILURE ==\n"))
         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.test_one) ... FAIL
-test_two (test.test_example.TestA.test_two) ... ok
-test_three (test.test_example.TestB.test_three) ... ERROR
------------
+    def test_parse_crashed_run_no_tests_result(self):
+        """Test results are still parsed when the runner crashes (no Tests result line)."""
+        stdout = """\
+Run 1 test sequentially in a single process
+0:00:00 [1/1] test_ast
+test_foo (test.test_ast.test_ast.TestA.test_foo) ... FAIL
+test_bar (test.test_ast.test_ast.TestA.test_bar) ... ok
+test_baz (test.test_ast.test_ast.TestB.test_baz) ... 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.test_foo) ... FAIL
------------
-======================================================================
-FAIL: test_foo (test.test_example.TestClass.test_foo)
-----------------------------------------------------------------------
-Traceback (most recent call last):
-  File "test.py", line 10, in test_foo
-    self.assertEqual(1, 2)
-AssertionError: 1 != 2
-
-======================================================================
+        result = parse_results(_make_result(stdout))
+        self.assertEqual(result.tests_result, "")
+        self.assertEqual(len(result.tests), 2)
+        names = {t.name for t in result.tests}
+        self.assertIn("test_foo", names)
+        self.assertIn("test_baz", names)
+
+    def test_parse_crashed_run_has_unexpected_success(self):
+        """Unexpected successes are parsed even without Tests result line."""
+        stdout = """\
+Run 1 test sequentially in a single process
+0:00:00 [1/1] test_ast
+test_foo (test.test_ast.test_ast.TestA.test_foo) ... unexpected success
+UNEXPECTED SUCCESS: test_foo (test.test_ast.test_ast.TestA.test_foo)
 """
-        result = parse_results(self._make_result(stdout))
-        self.assertEqual(len(result.tests), 1)
-        self.assertEqual(result.tests[0].error_message, "AssertionError: 1 != 2")
+        result = parse_results(_make_result(stdout))
+        self.assertEqual(result.tests_result, "")
+        self.assertEqual(len(result.unexpected_successes), 1)
 
-    def test_parse_multiple_error_messages(self):
-        """Test parsing multiple error messages."""
-        stdout = """
+    def test_parse_error_messages(self):
+        """Single and multiple error messages are parsed from tracebacks."""
+        stdout = """\
 Run 2 tests sequentially
 test_foo (test.test_example.TestClass.test_foo) ... FAIL
 test_bar (test.test_example.TestClass.test_bar) ... ERROR
@@ -143,57 +153,111 @@ def test_parse_multiple_error_messages(self):
 
 ======================================================================
 """
-        result = parse_results(self._make_result(stdout))
+        result = parse_results(_make_result(stdout))
+        by_name = {t.name: t for t in result.tests}
+        self.assertEqual(by_name["test_foo"].error_message, "AssertionError: 1 != 2")
+        self.assertEqual(by_name["test_bar"].error_message, "ValueError: oops")
+
+    def test_parse_directory_test_multiple_submodules(self):
+        """Failures across submodule boundaries are all detected."""
+        stdout = """\
+Run 3 tests sequentially
+0:00:00 [  1/3] test_asyncio.test_buffered_proto
+test_ok (test.test_asyncio.test_buffered_proto.TestProto.test_ok) ... ok
+
+----------------------------------------------------------------------
+Ran 1 tests in 0.1s
+
+OK
+
+0:00:01 [  2/3] test_asyncio.test_events
+test_create (test.test_asyncio.test_events.TestEvents.test_create) ... FAIL
+
+----------------------------------------------------------------------
+Ran 1 tests in 0.2s
+
+FAILED (failures=1)
+
+0:00:02 [  3/3] test_asyncio.test_tasks
+test_gather (test.test_asyncio.test_tasks.TestTasks.test_gather) ... ERROR
+
+----------------------------------------------------------------------
+Ran 1 tests in 0.3s
+
+FAILED (errors=1)
+
+== Tests result: FAILURE ==
+"""
+        result = parse_results(_make_result(stdout))
+        self.assertEqual(len(result.tests), 2)
+        names = {t.name for t in result.tests}
+        self.assertIn("test_create", names)
+        self.assertIn("test_gather", names)
+        self.assertEqual(result.tests_result, "FAILURE")
+
+    def test_parse_multiline_test_with_docstring(self):
+        """Two-line output (test_name + docstring ... RESULT) is handled."""
+        stdout = """\
+Run 3 tests sequentially
+test_ok (test.test_example.TestClass.test_ok) ... ok
+test_with_doc (test.test_example.TestClass.test_with_doc)
+Test that something works ... ERROR
+test_normal_fail (test.test_example.TestClass.test_normal_fail) ... FAIL
+"""
+        result = parse_results(_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")
+        names = {t.name for t in result.tests}
+        self.assertIn("test_with_doc", names)
+        self.assertIn("test_normal_fail", names)
+        test_doc = next(t for t in result.tests if t.name == "test_with_doc")
+        self.assertEqual(test_doc.path, "test.test_example.TestClass.test_with_doc")
+        self.assertEqual(test_doc.result, "error")
 
 
 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"])
+        self.assertEqual(
+            path_to_test_parts("test.test_foo.TestClass.test_method"),
+            ["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"])
+        self.assertEqual(
+            path_to_test_parts("test.test_foo.test_bar.TestClass.test_method"),
+            ["TestClass", "test_method"],
+        )
 
 
 class TestCollectTestChanges(unittest.TestCase):
-    """Tests for collect_test_changes function."""
-
-    def test_collect_failing_tests(self):
-        """Test collecting failing tests."""
+    def test_collect_failures_and_error_messages(self):
+        """Failures and error messages are collected; empty messages are omitted."""
         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(failing), 2)
-        self.assertIn(("TestClass", "test_foo"), failing)
-        self.assertIn(("TestClass", "test_bar"), failing)
-        self.assertEqual(len(successes), 0)
+        self.assertEqual(
+            failing, {("TestClass", "test_foo"), ("TestClass", "test_bar")}
+        )
+        self.assertEqual(successes, set())
+        self.assertEqual(len(error_messages), 1)
+        self.assertEqual(
+            error_messages[("TestClass", "test_foo")], "AssertionError: 1 != 2"
+        )
 
     def test_collect_unexpected_successes(self):
-        """Test collecting unexpected successes."""
         results = TestResult()
         results.unexpected_successes = [
             Test(
@@ -202,86 +266,35 @@ def test_collect_unexpected_successes(self):
                 result="unexpected_success",
             ),
         ]
+        _, successes, _ = collect_test_changes(results)
+        self.assertEqual(successes, {("TestClass", "test_foo")})
 
-        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."""
+    def test_module_prefix_filtering(self):
+        """Prefix filters with both short and 'test.' prefix formats."""
         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",
+                path="test.test_dataclasses.TestCase.test_bar",
                 result="fail",
             ),
             Test(
-                name="test_bar",
-                path="test.test_other.TestOther.test_bar",
+                name="test_baz",
+                path="test.test_other.TestOther.test_baz",
                 result="fail",
             ),
         ]
+        failing_a, _, _ = collect_test_changes(results, module_prefix="test_a.")
+        self.assertEqual(failing_a, {("TestClass", "test_foo")})
 
-        # Filter with prefix that matches real test module path format
-        failing, _, _ = collect_test_changes(
+        failing_dc, _, _ = collect_test_changes(
             results, module_prefix="test.test_dataclasses."
         )
-
-        self.assertEqual(len(failing), 1)
-        self.assertIn(("TestCase", "test_foo"), failing)
+        self.assertEqual(failing_dc, {("TestCase", "test_bar")})
 
     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 get_test_module_name would be:
-        'test_dataclasses.__init__'
-
-        So we need to strip '.__init__' and add 'test.' prefix.
-        """
+        """__init__.py tests match after stripping .__init__ from the prefix."""
         results = TestResult()
         results.tests = [
             Test(
@@ -290,39 +303,18 @@ def test_collect_init_module_matching(self):
                 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)
+        self.assertEqual(failing, {("TestCase", "test_field_repr")})
 
 
 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."""
+    def test_extract_methods(self):
+        """Extracts from single and multiple classes."""
         code = """
 class TestA(unittest.TestCase):
     def test_a(self):
@@ -333,22 +325,14 @@ 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)
+        self.assertEqual(methods, {("TestA", "test_a"), ("TestB", "test_b")})
 
     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())
+        self.assertEqual(extract_test_methods("this is not valid python {"), set())
 
 
 class TestRemoveExpectedFailures(unittest.TestCase):
-    """Tests for remove_expected_failures function."""
-
-    def test_remove_simple(self):
-        """Test removing simple expectedFailure decorator."""
+    def test_remove_comment_before(self):
         code = f"""import unittest
 
 class TestFoo(unittest.TestCase):
@@ -361,8 +345,7 @@ def test_one(self):
         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."""
+    def test_remove_inline_comment(self):
         code = f"""import unittest
 
 class TestFoo(unittest.TestCase):
@@ -374,7 +357,7 @@ def test_one(self):
         self.assertNotIn("@unittest.expectedFailure", result)
 
     def test_remove_super_call_method(self):
-        """Test removing method that just calls super()."""
+        """Super-call-only override is removed entirely (sync)."""
         code = f"""import unittest
 
 class TestFoo(unittest.TestCase):
@@ -386,8 +369,43 @@ def test_one(self):
         result = remove_expected_failures(code, {("TestFoo", "test_one")})
         self.assertNotIn("def test_one", result)
 
+    def test_remove_async_super_call_override(self):
+        """Super-call-only override is removed entirely (async)."""
+        code = f"""import unittest
+
+class BaseTest:
+    async def test_async_one(self):
+        pass
+
+class TestChild(BaseTest, unittest.TestCase):
+    # {COMMENT}
+    @unittest.expectedFailure
+    async def test_async_one(self):
+        return await super().test_async_one()
+"""
+        result = remove_expected_failures(code, {("TestChild", "test_async_one")})
+        self.assertNotIn("return await super().test_async_one()", result)
+        self.assertNotIn("@unittest.expectedFailure", result)
+        self.assertIn("class TestChild", result)
+        self.assertIn("async def test_async_one(self):", result)
+
+    def test_remove_with_comment_after(self):
+        """Reason comment on the line after the decorator is also removed."""
+        code = f"""import unittest
+
+class TestFoo(unittest.TestCase):
+    @unittest.expectedFailure  # {COMMENT}
+    # RuntimeError: something went wrong
+    def test_one(self):
+        pass
+"""
+        result = remove_expected_failures(code, {("TestFoo", "test_one")})
+        self.assertNotIn("@unittest.expectedFailure", result)
+        self.assertNotIn("RuntimeError: something went wrong", result)
+        self.assertIn("def test_one(self):", result)
+
     def test_no_removal_without_comment(self):
-        """Test that decorators without COMMENT are not removed."""
+        """Decorators without our COMMENT marker are left untouched."""
         code = """import unittest
 
 class TestFoo(unittest.TestCase):
@@ -396,29 +414,187 @@ 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."""
+class TestStripReasonlessExpectedFailures(unittest.TestCase):
+    def test_strip_reason_formats(self):
+        """Strips both inline-comment and comment-before formats when no reason."""
+        for label, code in [
+            (
+                "inline",
+                f"""import unittest
 
-    def test_apply_failing_tests(self):
-        """Test applying expectedFailure to failing tests."""
+class TestFoo(unittest.TestCase):
+    @unittest.expectedFailure  # {COMMENT}
+    def test_one(self):
+        pass
+""",
+            ),
+            (
+                "comment-before",
+                f"""import unittest
+
+class TestFoo(unittest.TestCase):
+    # {COMMENT}
+    @unittest.expectedFailure
+    def test_one(self):
+        pass
+""",
+            ),
+        ]:
+            with self.subTest(label):
+                result, stripped = strip_reasonless_expected_failures(code)
+                self.assertNotIn("@unittest.expectedFailure", result)
+                self.assertIn("def test_one(self):", result)
+                self.assertEqual(stripped, {("TestFoo", "test_one")})
+
+    def test_keep_with_reason(self):
+        code = f"""import unittest
+
+class TestFoo(unittest.TestCase):
+    @unittest.expectedFailure  # {COMMENT}; AssertionError: 1 != 2
+    def test_one(self):
+        pass
+"""
+        result, stripped = strip_reasonless_expected_failures(code)
+        self.assertIn("@unittest.expectedFailure", result)
+        self.assertEqual(stripped, set())
+
+    def test_strip_with_comment_after(self):
+        """Old-format reason comment on the next line is also removed."""
+        code = f"""import unittest
+
+class TestFoo(unittest.TestCase):
+    @unittest.expectedFailure  # {COMMENT}
+    # RuntimeError: something went wrong
+    def test_one(self):
+        pass
+"""
+        result, stripped = strip_reasonless_expected_failures(code)
+        self.assertNotIn("RuntimeError", result)
+        self.assertIn("def test_one(self):", result)
+        self.assertEqual(stripped, {("TestFoo", "test_one")})
+
+    def test_strip_super_call_override(self):
+        """Super-call overrides are removed entirely (both comment formats)."""
+        for label, code in [
+            (
+                "comment-before",
+                f"""import unittest
+
+class _BaseTests:
+    def test_foo(self):
+        pass
+
+class TestChild(_BaseTests, unittest.TestCase):
+    # {COMMENT}
+    @unittest.expectedFailure
+    def test_foo(self):
+        return super().test_foo()
+""",
+            ),
+            (
+                "inline",
+                f"""import unittest
+
+class _BaseTests:
+    def test_foo(self):
+        pass
+
+class TestChild(_BaseTests, unittest.TestCase):
+    @unittest.expectedFailure  # {COMMENT}
+    def test_foo(self):
+        return super().test_foo()
+""",
+            ),
+        ]:
+            with self.subTest(label):
+                result, stripped = strip_reasonless_expected_failures(code)
+                self.assertNotIn("return super().test_foo()", result)
+                self.assertNotIn("@unittest.expectedFailure", result)
+                self.assertEqual(stripped, {("TestChild", "test_foo")})
+                self.assertIn("class _BaseTests:", result)
+
+    def test_no_strip_without_comment(self):
+        """Markers without our COMMENT are NOT stripped."""
         code = """import unittest
 
 class TestFoo(unittest.TestCase):
+    @unittest.expectedFailure
     def test_one(self):
         pass
 """
-        failing = {("TestFoo", "test_one")}
-        result = apply_test_changes(code, failing, set())
+        result, stripped = strip_reasonless_expected_failures(code)
+        self.assertIn("@unittest.expectedFailure", result)
+        self.assertEqual(stripped, set())
+
+    def test_mixed_with_and_without_reason(self):
+        code = f"""import unittest
+
+class TestFoo(unittest.TestCase):
+    @unittest.expectedFailure  # {COMMENT}
+    def test_no_reason(self):
+        pass
+
+    @unittest.expectedFailure  # {COMMENT}; has a reason
+    def test_has_reason(self):
+        pass
+"""
+        result, stripped = strip_reasonless_expected_failures(code)
+        self.assertEqual(stripped, {("TestFoo", "test_no_reason")})
+        self.assertIn("has a reason", result)
+        self.assertEqual(result.count("@unittest.expectedFailure"), 1)
+
+
+class TestExpandStrippedToChildren(unittest.TestCase):
+    def test_parent_to_children(self):
+        """Parent stripped → all/partial failing children returned."""
+        stripped = {("Base", "test_foo")}
+        all_children = {("ChildA", "test_foo"), ("ChildB", "test_foo")}
 
+        # All children fail
+        result = _expand_stripped_to_children(BASE_TWO_CHILDREN, stripped, all_children)
+        self.assertEqual(result, all_children)
+
+        # Only one child fails
+        partial = {("ChildA", "test_foo")}
+        result = _expand_stripped_to_children(BASE_TWO_CHILDREN, stripped, partial)
+        self.assertEqual(result, partial)
+
+    def test_direct_match(self):
+        code = """import unittest
+
+class TestFoo(unittest.TestCase):
+    def test_one(self):
+        pass
+"""
+        s = {("TestFoo", "test_one")}
+        self.assertEqual(_expand_stripped_to_children(code, s, s), s)
+
+    def test_child_with_own_override_excluded(self):
+        stripped = {("Base", "test_foo")}
+        all_failing = {("ChildA", "test_foo"), ("ChildB", "test_foo")}
+        result = _expand_stripped_to_children(
+            BASE_TWO_CHILDREN_ONE_OVERRIDE, stripped, all_failing
+        )
+        # ChildA inherits → included; ChildB has own method → excluded
+        self.assertEqual(result, {("ChildA", "test_foo")})
+
+
+class TestApplyTestChanges(unittest.TestCase):
+    def test_apply_failing_tests(self):
+        code = """import unittest
+
+class TestFoo(unittest.TestCase):
+    def test_one(self):
+        pass
+"""
+        result = apply_test_changes(code, {("TestFoo", "test_one")}, 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):
@@ -427,14 +603,11 @@ class TestFoo(unittest.TestCase):
     def test_one(self):
         pass
 """
-        successes = {("TestFoo", "test_one")}
-        result = apply_test_changes(code, set(), successes)
-
+        result = apply_test_changes(code, set(), {("TestFoo", "test_one")})
         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):
@@ -446,203 +619,466 @@ def test_one(self):
     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)
+        result = apply_test_changes(
+            code, {("TestFoo", "test_one")}, {("TestFoo", "test_two")}
+        )
         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)
+        result = apply_test_changes(
+            code,
+            {("TestFoo", "test_one")},
+            set(),
+            {("TestFoo", "test_one"): "AssertionError: 1 != 2"},
+        )
         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
-        )
+class TestConsolidateToParent(unittest.TestCase):
+    def test_all_children_fail_marks_parent_with_message(self):
+        """All subclasses fail → marks parent; error message is transferred."""
+        failing = {("ChildA", "test_foo"), ("ChildB", "test_foo")}
+        error_messages = {("ChildA", "test_foo"): "RuntimeError: boom"}
+        result = apply_test_changes(BASE_TWO_CHILDREN, failing, set(), error_messages)
 
-        self.assertEqual(to_mark, {("TestFoo", "test_new")})
-        self.assertEqual(regressions, set())
+        self.assertEqual(result.count("@unittest.expectedFailure"), 1)
+        self.assertNotIn("return super()", result)
+        self.assertIn("RuntimeError: boom", result)
 
-    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")}
+    def test_partial_children_fail_marks_children(self):
+        result = apply_test_changes(BASE_TWO_CHILDREN, {("ChildA", "test_foo")}, set())
+        self.assertIn("return super().test_foo()", result)
+        self.assertEqual(result.count("@unittest.expectedFailure"), 1)
 
-        to_mark, regressions = self._filter_failures(
-            all_failing, original_methods, current_methods
-        )
+    def test_child_with_own_override_not_consolidated(self):
+        failing = {("ChildA", "test_foo"), ("ChildB", "test_foo")}
+        result = apply_test_changes(BASE_TWO_CHILDREN_ONE_OVERRIDE, failing, set())
+        self.assertEqual(result.count("@unittest.expectedFailure"), 2)
 
-        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")}
+    def test_strip_then_consolidate_restores_parent_marker(self):
+        """End-to-end: strip parent marker → child failures → re-mark on parent."""
+        code = f"""import unittest
 
-        to_mark, regressions = self._filter_failures(
-            all_failing, original_methods, current_methods
-        )
+class _BaseTests:
+    @unittest.expectedFailure  # {COMMENT}
+    def test_foo(self):
+        pass
 
-        self.assertEqual(to_mark, {("TestFoo", "test_new1")})
-        self.assertEqual(regressions, {("TestFoo", "test_old1")})
+class ChildA(_BaseTests, unittest.TestCase):
+    pass
 
-    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)
-        }
+class ChildB(_BaseTests, unittest.TestCase):
+    pass
+"""
+        stripped_code, stripped_tests = strip_reasonless_expected_failures(code)
+        self.assertEqual(stripped_tests, {("_BaseTests", "test_foo")})
+
+        all_failing = {("ChildA", "test_foo"), ("ChildB", "test_foo")}
+        error_messages = {("ChildA", "test_foo"): "RuntimeError: boom"}
 
-        to_mark, regressions = self._filter_failures(
-            all_failing, original_methods, current_methods
+        to_remark = _expand_stripped_to_children(
+            stripped_code, stripped_tests, all_failing
         )
+        self.assertEqual(to_remark, all_failing)
 
-        self.assertEqual(to_mark, {("TestA", "test_new_a"), ("TestC", "test_c")})
-        self.assertEqual(regressions, {("TestA", "test_a")})
+        result = apply_test_changes(stripped_code, to_remark, set(), error_messages)
+        self.assertIn("RuntimeError: boom", result)
+        self.assertEqual(result.count("@unittest.expectedFailure"), 1)
+        self.assertNotIn("return super()", result)
 
-    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
-        )
+class TestSmartAutoMarkFiltering(unittest.TestCase):
+    """Tests for smart auto-mark filtering (new tests vs regressions)."""
+
+    @staticmethod
+    def _filter(all_failing, original, current):
+        new = current - original
+        to_mark = {t for t in all_failing if t in new}
+        return to_mark, all_failing - to_mark
+
+    def test_new_vs_regression(self):
+        """New failures are marked; existing (regression) failures are not."""
+        original = {("TestFoo", "test_old1"), ("TestFoo", "test_old2")}
+        current = original | {("TestFoo", "test_new1"), ("TestFoo", "test_new2")}
+        all_failing = {("TestFoo", "test_old1"), ("TestFoo", "test_new1")}
+
+        to_mark, regressions = self._filter(all_failing, original, current)
+        self.assertEqual(to_mark, {("TestFoo", "test_new1")})
+        self.assertEqual(regressions, {("TestFoo", "test_old1")})
 
+        # Edge: all new → all marked
+        to_mark, regressions = self._filter(all_failing, set(), current)
         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
-        )
-
+        # Edge: all old → nothing marked
+        to_mark, regressions = self._filter(all_failing, current, current)
         self.assertEqual(to_mark, set())
-        self.assertEqual(regressions, {("TestFoo", "test_one")})
+        self.assertEqual(regressions, all_failing)
 
+    def test_filters_across_classes(self):
+        original = {("TestA", "test_a"), ("TestB", "test_b")}
+        current = original | {("TestA", "test_new_a"), ("TestC", "test_c")}
+        all_failing = {
+            ("TestA", "test_a"),  # regression
+            ("TestA", "test_new_a"),  # new
+            ("TestC", "test_c"),  # new (new class)
+        }
+        to_mark, regressions = self._filter(all_failing, original, current)
+        self.assertEqual(to_mark, {("TestA", "test_new_a"), ("TestC", "test_c")})
+        self.assertEqual(regressions, {("TestA", "test_a")})
 
-class TestIsSuperCallOnly(unittest.TestCase):
-    """Tests for _is_super_call_only function."""
-
-    def _parse_method(self, code: str):
-        """Parse code and return the first method."""
-        import ast
 
+class TestIsSuperCallOnly(unittest.TestCase):
+    @staticmethod
+    def _parse_method(code):
         tree = ast.parse(code)
         for node in ast.walk(tree):
             if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)):
                 return node
         return None
 
-    def test_matching_super_call(self):
-        """Test method that calls super().same_name()."""
-        code = """
+    def test_sync(self):
+        cases = [
+            ("return super().test_one()", True),
+            ("return super().test_two()", False),  # mismatched name
+            ("pass", False),  # regular body
+            ("x = 1\n        return super().test_one()", False),  # multiple stmts
+        ]
+        for body, expected in cases:
+            with self.subTest(body=body):
+                code = f"""
 class Foo:
     def test_one(self):
-        return super().test_one()
+        {body}
 """
-        method = self._parse_method(code)
-        self.assertTrue(_is_super_call_only(method))
-
-    def test_mismatched_super_call(self):
-        """Test method that calls super().different_name()."""
-        code = """
+                self.assertEqual(
+                    _is_super_call_only(self._parse_method(code)), expected
+                )
+
+    def test_async(self):
+        cases = [
+            ("return await super().test_one()", True),
+            ("return await super().test_two()", False),
+            ("return super().test_one()", True),  # sync call in async method
+        ]
+        for body, expected in cases:
+            with self.subTest(body=body):
+                code = f"""
 class Foo:
-    def test_one(self):
-        return super().test_two()
+    async def test_one(self):
+        {body}
 """
-        method = self._parse_method(code)
-        self.assertFalse(_is_super_call_only(method))
+                self.assertEqual(
+                    _is_super_call_only(self._parse_method(code)), expected
+                )
 
-    def test_not_super_call(self):
-        """Test method with regular body."""
-        code = """
-class Foo:
-    def test_one(self):
+
+class TestAutoMarkFileWithCrashedRun(unittest.TestCase):
+    """auto_mark_file should process partial results when test runner crashes."""
+
+    CRASHED_STDOUT = """\
+Run 1 test sequentially in a single process
+0:00:00 [1/1] test_example
+test_foo (test.test_example.TestA.test_foo) ... FAIL
+test_bar (test.test_example.TestA.test_bar) ... ok
+======================================================================
+FAIL: test_foo (test.test_example.TestA.test_foo)
+----------------------------------------------------------------------
+Traceback (most recent call last):
+  File "test.py", line 10, in test_foo
+    self.assertEqual(1, 2)
+AssertionError: 1 != 2
+"""
+
+    def test_auto_mark_file_crashed_run(self):
+        """auto_mark_file processes results even when tests_result is empty (crash)."""
+        test_code = f"""import unittest
+
+class TestA(unittest.TestCase):
+    def test_foo(self):
+        pass
+
+    def test_bar(self):
         pass
 """
-        method = self._parse_method(code)
-        self.assertFalse(_is_super_call_only(method))
+        with tempfile.TemporaryDirectory() as tmpdir:
+            test_file = pathlib.Path(tmpdir) / "test_example.py"
+            test_file.write_text(test_code)
+
+            mock_result = TestResult()
+            mock_result.tests_result = ""
+            mock_result.tests = [
+                Test(
+                    name="test_foo",
+                    path="test.test_example.TestA.test_foo",
+                    result="fail",
+                    error_message="AssertionError: 1 != 2",
+                ),
+            ]
+
+            with mock.patch(
+                "update_lib.cmd_auto_mark.run_test", return_value=mock_result
+            ):
+                added, removed, regressions = auto_mark_file(
+                    test_file, mark_failure=True, verbose=False
+                )
+
+            self.assertEqual(added, 1)
+            contents = test_file.read_text()
+            self.assertIn("expectedFailure", contents)
+
+    def test_auto_mark_file_no_results_at_all_raises(self):
+        """auto_mark_file raises TestRunError when there are zero parsed results."""
+        test_code = """import unittest
 
-    def test_multiple_statements(self):
-        """Test method with multiple statements."""
-        code = """
-class Foo:
-    def test_one(self):
-        x = 1
-        return super().test_one()
+class TestA(unittest.TestCase):
+    def test_foo(self):
+        pass
+"""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            test_file = pathlib.Path(tmpdir) / "test_example.py"
+            test_file.write_text(test_code)
+
+            mock_result = TestResult()
+            mock_result.tests_result = ""
+            mock_result.tests = []
+            mock_result.stdout = "some crash output"
+
+            with mock.patch(
+                "update_lib.cmd_auto_mark.run_test", return_value=mock_result
+            ):
+                with self.assertRaises(TestRunError):
+                    auto_mark_file(test_file, verbose=False)
+
+
+class TestAutoMarkDirectoryWithCrashedRun(unittest.TestCase):
+    """auto_mark_directory should process partial results when test runner crashes."""
+
+    def test_auto_mark_directory_crashed_run(self):
+        """auto_mark_directory processes results even when tests_result is empty."""
+        test_code = f"""import unittest
+
+class TestA(unittest.TestCase):
+    def test_foo(self):
+        pass
+"""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            test_dir = pathlib.Path(tmpdir) / "test_example"
+            test_dir.mkdir()
+            test_file = test_dir / "test_sub.py"
+            test_file.write_text(test_code)
+
+            mock_result = TestResult()
+            mock_result.tests_result = ""
+            mock_result.tests = [
+                Test(
+                    name="test_foo",
+                    path="test.test_example.test_sub.TestA.test_foo",
+                    result="fail",
+                    error_message="AssertionError: oops",
+                ),
+            ]
+
+            with (
+                mock.patch(
+                    "update_lib.cmd_auto_mark.run_test", return_value=mock_result
+                ),
+                mock.patch(
+                    "update_lib.cmd_auto_mark.get_test_module_name",
+                    side_effect=lambda p: (
+                        "test_example" if p == test_dir else "test_example.test_sub"
+                    ),
+                ),
+            ):
+                added, removed, regressions = auto_mark_directory(
+                    test_dir, mark_failure=True, verbose=False
+                )
+
+            self.assertEqual(added, 1)
+            contents = test_file.read_text()
+            self.assertIn("expectedFailure", contents)
+
+    def test_auto_mark_directory_no_results_raises(self):
+        """auto_mark_directory raises TestRunError when zero results."""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            test_dir = pathlib.Path(tmpdir) / "test_example"
+            test_dir.mkdir()
+            test_file = test_dir / "test_sub.py"
+            test_file.write_text("import unittest\n")
+
+            mock_result = TestResult()
+            mock_result.tests_result = ""
+            mock_result.tests = []
+            mock_result.stdout = "crash"
+
+            with (
+                mock.patch(
+                    "update_lib.cmd_auto_mark.run_test", return_value=mock_result
+                ),
+                mock.patch(
+                    "update_lib.cmd_auto_mark.get_test_module_name",
+                    return_value="test_example",
+                ),
+            ):
+                with self.assertRaises(TestRunError):
+                    auto_mark_directory(test_dir, verbose=False)
+
+
+class TestAutoMarkFileRestoresOnCrash(unittest.TestCase):
+    """Stripped markers must be restored when the test runner crashes."""
+
+    def test_stripped_markers_restored_when_crash(self):
+        """Markers stripped before run must be restored for unobserved tests on crash."""
+        test_code = f"""\
+import unittest
+
+class TestA(unittest.TestCase):
+    @unittest.expectedFailure  # {COMMENT}
+    def test_foo(self):
+        pass
+
+    @unittest.expectedFailure  # {COMMENT}
+    def test_bar(self):
+        pass
+
+    @unittest.expectedFailure  # {COMMENT}
+    def test_baz(self):
+        pass
+"""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            test_file = pathlib.Path(tmpdir) / "test_example.py"
+            test_file.write_text(test_code)
+
+            # Simulate a crashed run that only observed test_foo (failed)
+            # test_bar and test_baz never ran due to crash
+            mock_result = TestResult()
+            mock_result.tests_result = ""  # no Tests result line (crash)
+            mock_result.tests = [
+                Test(
+                    name="test_foo",
+                    path="test.test_example.TestA.test_foo",
+                    result="fail",
+                    error_message="AssertionError: 1 != 2",
+                ),
+            ]
+
+            with mock.patch(
+                "update_lib.cmd_auto_mark.run_test", return_value=mock_result
+            ):
+                auto_mark_file(test_file, verbose=False)
+
+            contents = test_file.read_text()
+            # test_bar and test_baz were not observed — their markers must be restored
+            self.assertIn("def test_bar", contents)
+            self.assertIn("def test_baz", contents)
+            # Count expectedFailure markers: all 3 should be present
+            self.assertEqual(contents.count("expectedFailure"), 3, contents)
+
+    def test_stripped_markers_removed_when_complete_run(self):
+        """Markers are properly removed when the run completes normally."""
+        test_code = f"""\
+import unittest
+
+class TestA(unittest.TestCase):
+    @unittest.expectedFailure  # {COMMENT}
+    def test_foo(self):
+        pass
+
+    @unittest.expectedFailure  # {COMMENT}
+    def test_bar(self):
+        pass
+"""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            test_file = pathlib.Path(tmpdir) / "test_example.py"
+            test_file.write_text(test_code)
+
+            # Simulate a complete run where test_foo fails but test_bar passes
+            mock_result = TestResult()
+            mock_result.tests_result = "FAILURE"  # normal completion
+            mock_result.tests = [
+                Test(
+                    name="test_foo",
+                    path="test.test_example.TestA.test_foo",
+                    result="fail",
+                    error_message="AssertionError",
+                ),
+            ]
+            # test_bar passes → shows as unexpected success
+            mock_result.unexpected_successes = [
+                Test(
+                    name="test_bar",
+                    path="test.test_example.TestA.test_bar",
+                    result="unexpected success",
+                ),
+            ]
+
+            with mock.patch(
+                "update_lib.cmd_auto_mark.run_test", return_value=mock_result
+            ):
+                auto_mark_file(test_file, verbose=False)
+
+            contents = test_file.read_text()
+            # test_foo should still have marker (re-added)
+            self.assertEqual(contents.count("expectedFailure"), 1, contents)
+            self.assertIn("def test_foo", contents)
+
+
+class TestAutoMarkDirectoryRestoresOnCrash(unittest.TestCase):
+    """Stripped markers must be restored for directory runs that crash."""
+
+    def test_stripped_markers_restored_when_crash(self):
+        test_code = f"""\
+import unittest
+
+class TestA(unittest.TestCase):
+    @unittest.expectedFailure  # {COMMENT}
+    def test_foo(self):
+        pass
+
+    @unittest.expectedFailure  # {COMMENT}
+    def test_bar(self):
+        pass
 """
-        method = self._parse_method(code)
-        self.assertFalse(_is_super_call_only(method))
+        with tempfile.TemporaryDirectory() as tmpdir:
+            test_dir = pathlib.Path(tmpdir) / "test_example"
+            test_dir.mkdir()
+            test_file = test_dir / "test_sub.py"
+            test_file.write_text(test_code)
+
+            mock_result = TestResult()
+            mock_result.tests_result = ""  # crash
+            mock_result.tests = [
+                Test(
+                    name="test_foo",
+                    path="test.test_example.test_sub.TestA.test_foo",
+                    result="fail",
+                ),
+            ]
+
+            with (
+                mock.patch(
+                    "update_lib.cmd_auto_mark.run_test", return_value=mock_result
+                ),
+                mock.patch(
+                    "update_lib.cmd_auto_mark.get_test_module_name",
+                    side_effect=lambda p: (
+                        "test_example" if p == test_dir else "test_example.test_sub"
+                    ),
+                ),
+            ):
+                auto_mark_directory(test_dir, verbose=False)
+
+            contents = test_file.read_text()
+            # Both markers must be present (unobserved test_bar restored)
+            self.assertEqual(contents.count("expectedFailure"), 2, contents)
 
 
 if __name__ == "__main__":
diff --git a/scripts/update_lib/tests/test_quick.py b/scripts/update_lib/tests/test_quick.py
index b5354436e97..f0262eebd04 100644
--- a/scripts/update_lib/tests/test_quick.py
+++ b/scripts/update_lib/tests/test_quick.py
@@ -199,6 +199,64 @@ def test_both_none_returns_false(self):
         result = git_commit("test", None, None, pathlib.Path("cpython"), verbose=False)
         self.assertFalse(result)
 
+    @patch("subprocess.run")
+    @patch("update_lib.cmd_quick.get_cpython_version")
+    def test_hard_deps_are_added(self, mock_version, mock_run):
+        """Test that hard_deps are included in git commit."""
+        mock_version.return_value = "v3.14.0"
+        mock_run.return_value.returncode = 1  # Has changes
+
+        with tempfile.TemporaryDirectory() as tmpdir:
+            lib_file = pathlib.Path(tmpdir) / "lib.py"
+            lib_file.write_text("# lib")
+            test_file = pathlib.Path(tmpdir) / "test.py"
+            test_file.write_text("# test")
+            dep_file = pathlib.Path(tmpdir) / "_dep.py"
+            dep_file.write_text("# dep")
+
+            git_commit(
+                "test",
+                lib_file,
+                test_file,
+                pathlib.Path("cpython"),
+                hard_deps=[dep_file],
+                verbose=False,
+            )
+
+            # Check git add was called with all three files
+            add_call = mock_run.call_args_list[0]
+            add_args = add_call[0][0]
+            self.assertIn(str(lib_file), add_args)
+            self.assertIn(str(test_file), add_args)
+            self.assertIn(str(dep_file), add_args)
+
+    @patch("subprocess.run")
+    @patch("update_lib.cmd_quick.get_cpython_version")
+    def test_nonexistent_hard_deps_not_added(self, mock_version, mock_run):
+        """Test that nonexistent hard_deps don't cause errors."""
+        mock_version.return_value = "v3.14.0"
+        mock_run.return_value.returncode = 1  # Has changes
+
+        with tempfile.TemporaryDirectory() as tmpdir:
+            lib_file = pathlib.Path(tmpdir) / "lib.py"
+            lib_file.write_text("# lib")
+            nonexistent_dep = pathlib.Path(tmpdir) / "nonexistent.py"
+
+            git_commit(
+                "test",
+                lib_file,
+                None,
+                pathlib.Path("cpython"),
+                hard_deps=[nonexistent_dep],
+                verbose=False,
+            )
+
+            # Check git add was called with only lib_file
+            add_call = mock_run.call_args_list[0]
+            add_args = add_call[0][0]
+            self.assertIn(str(lib_file), add_args)
+            self.assertNotIn(str(nonexistent_dep), add_args)
+
 
 class TestQuickTestRunFailure(unittest.TestCase):
     """Tests for quick() behavior when test run fails."""
diff --git a/scripts/whats_left.py b/scripts/whats_left.py
index 00db9a0ac5c..9a4d57df6ae 100755
--- a/scripts/whats_left.py
+++ b/scripts/whats_left.py
@@ -67,9 +67,9 @@ def parse_args():
     )
     parser.add_argument(
         "--features",
-        action="store",
-        help="which features to enable when building RustPython (default: ssl)",
-        default="ssl",
+        action="append",
+        help="which features to enable when building RustPython (default: [])",
+        default=[],
     )
 
     args = parser.parse_args()
@@ -449,16 +449,20 @@ def remove_one_indent(s):
 cargo_build_command = ["cargo", "build", "--release"]
 if args.no_default_features:
     cargo_build_command.append("--no-default-features")
+
+joined_features = ",".join(args.features)
 if args.features:
-    cargo_build_command.extend(["--features", args.features])
+    cargo_build_command.extend(["--features", joined_features])
 
 subprocess.run(cargo_build_command, check=True)
 
 cargo_run_command = ["cargo", "run", "--release"]
 if args.no_default_features:
     cargo_run_command.append("--no-default-features")
+
 if args.features:
-    cargo_run_command.extend(["--features", args.features])
+    cargo_run_command.extend(["--features", joined_features])
+
 cargo_run_command.extend(["-q", "--", GENERATED_FILE])
 
 result = subprocess.run(
diff --git a/src/lib.rs b/src/lib.rs
index c489782ded7..02b514b6e17 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -33,7 +33,7 @@
 //!     #[pyfunction]
 //!     fn other_thing(s: PyStrRef) -> (String, usize) {
 //!         let new_string = format!("hello from rust, {}!", s);
-//!         let prev_len = s.as_str().len();
+//!         let prev_len = s.byte_len();
 //!         (new_string, prev_len)
 //!     }
 //! }
@@ -44,7 +44,6 @@
 //!
 //! See [`rustpython_derive`](../rustpython_derive/index.html) crate for documentation on macros used in the example above.
 
-#![cfg_attr(all(target_os = "wasi", target_env = "p2"), feature(wasip2))]
 #![allow(clippy::needless_doctest_main)]
 
 #[macro_use]
@@ -57,6 +56,9 @@ mod interpreter;
 mod settings;
 mod shell;
 
+#[cfg(feature = "rustpython-pylib")]
+pub use rustpython_pylib as pylib;
+
 use rustpython_vm::{AsObject, PyObjectRef, PyResult, VirtualMachine, scope::Scope};
 use std::env;
 use std::io::IsTerminal;
@@ -136,7 +138,7 @@ __import__("io").TextIOWrapper(
         .downcast()
         .expect("TextIOWrapper.read() should return str");
     eprintln!("running get-pip.py...");
-    vm.run_string(scope, getpip_code.as_str(), "get-pip.py".to_owned())?;
+    vm.run_string(scope, getpip_code.expect_str(), "get-pip.py".to_owned())?;
     Ok(())
 }
 
@@ -144,7 +146,7 @@ fn install_pip(installer: InstallPipMode, scope: Scope, vm: &VirtualMachine) ->
     if !cfg!(feature = "ssl") {
         return Err(vm.new_exception_msg(
             vm.ctx.exceptions.system_error.to_owned(),
-            "install-pip requires rustpython be build with '--features=ssl'".to_owned(),
+            "install-pip requires rustpython be build with '--features=ssl'".into(),
         ));
     }
 
@@ -174,7 +176,20 @@ fn run_file(vm: &VirtualMachine, scope: Scope, path: &str) -> PyResult<()> {
         vm.insert_sys_path(vm.new_pyobj(dir))?;
     }
 
-    vm.run_any_file(scope, path)
+    #[cfg(feature = "host_env")]
+    {
+        vm.run_any_file(scope, path)
+    }
+    #[cfg(not(feature = "host_env"))]
+    {
+        // In sandbox mode, the binary reads the file and feeds source to the VM.
+        // The VM itself has no filesystem access.
+        let path = if path.is_empty() { "???" } else { path };
+        match std::fs::read_to_string(path) {
+            Ok(source) => vm.run_string(scope, &source, path.to_owned()).map(drop),
+            Err(err) => Err(vm.new_os_error(err.to_string())),
+        }
+    }
 }
 
 fn get_importer(path: &str, vm: &VirtualMachine) -> PyResult<Option<PyObjectRef>> {
@@ -367,11 +382,14 @@ mod tests {
             vm.unwrap_pyresult((|| {
                 let scope = vm.new_scope_with_main()?;
                 // test file run
-                vm.run_any_file(scope, "extra_tests/snippets/dir_main/__main__.py")?;
-
-                let scope = vm.new_scope_with_main()?;
-                // test module run (directory with __main__.py)
-                run_file(vm, scope, "extra_tests/snippets/dir_main")?;
+                run_file(vm, scope, "extra_tests/snippets/dir_main/__main__.py")?;
+
+                #[cfg(feature = "host_env")]
+                {
+                    let scope = vm.new_scope_with_main()?;
+                    // test module run (directory with __main__.py)
+                    run_file(vm, scope, "extra_tests/snippets/dir_main")?;
+                }
 
                 Ok(())
             })());
diff --git a/src/settings.rs b/src/settings.rs
index 71a9c5a3f06..5233cf98d49 100644
--- a/src/settings.rs
+++ b/src/settings.rs
@@ -260,6 +260,24 @@ pub fn parse_opts() -> Result<(Settings, RunMode), lexopt::Error> {
 
     settings.check_hash_pycs_mode = args.check_hash_based_pycs;
 
+    if let Some(val) = get_env("PYTHONUTF8")
+        && let Some(val_str) = val.to_str()
+        && !val_str.is_empty()
+    {
+        settings.utf8_mode = match val_str {
+            "1" => 1,
+            "0" => 0,
+            _ => {
+                error!(
+                    "Fatal Python error: config_init_utf8_mode: \
+                     PYTHONUTF8=N: N is missing or invalid\n\
+                     Python runtime state: preinitialized"
+                );
+                std::process::exit(1);
+            }
+        };
+    }
+
     let xopts = args.implementation_option.into_iter().map(|s| {
         let (name, value) = match s.split_once('=') {
             Some((name, value)) => (name.to_owned(), Some(value)),
@@ -269,6 +287,21 @@ pub fn parse_opts() -> Result<(Settings, RunMode), lexopt::Error> {
             "dev" => settings.dev_mode = true,
             "faulthandler" => settings.faulthandler = true,
             "warn_default_encoding" => settings.warn_default_encoding = true,
+            "utf8" => {
+                settings.utf8_mode = match value {
+                    None => 1,
+                    Some("1") => 1,
+                    Some("0") => 0,
+                    _ => {
+                        error!(
+                            "Fatal Python error: config_init_utf8_mode: \
+                             -X utf8=n: n is missing or invalid\n\
+                             Python runtime state: preinitialized"
+                        );
+                        std::process::exit(1);
+                    }
+                };
+            }
             "no_sig_int" => settings.install_signal_handlers = false,
             "no_debug_ranges" => settings.code_debug_ranges = false,
             "int_max_str_digits" => {
@@ -305,6 +338,13 @@ pub fn parse_opts() -> Result<(Settings, RunMode), lexopt::Error> {
     });
     settings.xoptions.extend(xopts);
 
+    // Resolve utf8_mode if not explicitly set by PYTHONUTF8 or -X utf8.
+    // Default to UTF-8 mode since RustPython's locale encoding detection
+    // is incomplete. Users can set PYTHONUTF8=0 or -X utf8=0 to disable.
+    if settings.utf8_mode < 0 {
+        settings.utf8_mode = 1;
+    }
+
     settings.warn_default_encoding =
         settings.warn_default_encoding || env_bool("PYTHONWARNDEFAULTENCODING");
     settings.faulthandler = settings.faulthandler || env_bool("PYTHONFAULTHANDLER");
@@ -355,6 +395,17 @@ pub fn parse_opts() -> Result<(Settings, RunMode), lexopt::Error> {
         };
         settings.warnoptions.push(warn.to_owned());
     }
+    if let Some(val) = get_env("PYTHONWARNINGS")
+        && let Some(val_str) = val.to_str()
+        && !val_str.is_empty()
+    {
+        for warning in val_str.split(',') {
+            let warning = warning.trim();
+            if !warning.is_empty() {
+                settings.warnoptions.push(warning.to_owned());
+            }
+        }
+    }
     settings.warnoptions.extend(args.warning_control);
 
     settings.hash_seed = match (!args.random_hash_seed)
@@ -407,8 +458,10 @@ pub(crate) use env::split_paths;
 pub(crate) fn split_paths<T: AsRef<std::ffi::OsStr> + ?Sized>(
     s: &T,
 ) -> impl Iterator<Item = std::path::PathBuf> + '_ {
-    use std::os::wasi::ffi::OsStrExt;
-    let s = s.as_ref().as_bytes();
-    s.split(|b| *b == b':')
-        .map(|x| std::ffi::OsStr::from_bytes(x).to_owned().into())
+    let s = s.as_ref().as_encoded_bytes();
+    s.split(|b| *b == b':').map(|x| {
+        unsafe { std::ffi::OsStr::from_encoded_bytes_unchecked(x) }
+            .to_owned()
+            .into()
+    })
 }
diff --git a/src/shell.rs b/src/shell.rs
index d2e54c490a8..6c75e94572c 100644
--- a/src/shell.rs
+++ b/src/shell.rs
@@ -142,7 +142,7 @@ pub fn run_shell(vm: &VirtualMachine, scope: Scope) -> PyResult<()> {
             .get_attr(prompt_name, vm)
             .and_then(|prompt| prompt.str(vm));
         let prompt = match prompt {
-            Ok(ref s) => s.as_str(),
+            Ok(ref s) => s.expect_str(),
             Err(_) => "",
         };
 
@@ -211,8 +211,10 @@ pub fn run_shell(vm: &VirtualMachine, scope: Scope) -> PyResult<()> {
             }
             #[cfg(unix)]
             ReadlineResult::OsError(num) => {
-                let os_error =
-                    vm.new_exception_msg(vm.ctx.exceptions.os_error.to_owned(), format!("{num:?}"));
+                let os_error = vm.new_exception_msg(
+                    vm.ctx.exceptions.os_error.to_owned(),
+                    format!("{num:?}").into(),
+                );
                 vm.print_exception(os_error);
                 break;
             }
diff --git a/src/shell/helper.rs b/src/shell/helper.rs
index 493dc578469..944e936397d 100644
--- a/src/shell/helper.rs
+++ b/src/shell/helper.rs
@@ -108,7 +108,7 @@ impl<'vm> ShellHelper<'vm> {
             .filter(|res| {
                 res.as_ref()
                     .ok()
-                    .is_none_or(|s| s.as_str().starts_with(word_start))
+                    .is_none_or(|s| s.as_bytes().starts_with(word_start.as_bytes()))
             })
             .collect::<Result<Vec<_>, _>>()
             .ok()?;
@@ -120,7 +120,7 @@ impl<'vm> ShellHelper<'vm> {
             // only the completions that don't start with a '_'
             let no_underscore = all_completions
                 .iter()
-                .filter(|&s| !s.as_str().starts_with('_'))
+                .filter(|&s| !s.as_bytes().starts_with(b"_"))
                 .cloned()
                 .collect::<Vec<_>>();
 
@@ -134,13 +134,13 @@ impl<'vm> ShellHelper<'vm> {
         };
 
         // sort the completions alphabetically
-        completions.sort_by(|a, b| std::cmp::Ord::cmp(a.as_str(), b.as_str()));
+        completions.sort_by(|a, b| a.as_wtf8().cmp(b.as_wtf8()));
 
         Some((
             startpos,
             completions
                 .into_iter()
-                .map(|s| s.as_str().to_owned())
+                .map(|s| s.expect_str().to_owned())
                 .collect(),
         ))
     }
diff --git a/wapm.toml b/wapm.toml
index 22d8f181640..b116cb84161 100644
--- a/wapm.toml
+++ b/wapm.toml
@@ -1,6 +1,6 @@
 [package]
 name = "rustpython"
-version = "0.4.0"
+version = "0.5.0"
 description = "A Python-3 (CPython >= 3.5.0) Interpreter written in Rust 🐍 😱 🤘"
 license-file = "LICENSE"
 readme = "README.md"
diff --git a/wasm/demo/package-lock.json b/wasm/demo/package-lock.json
index 699168925db..f766a3282c5 100644
--- a/wasm/demo/package-lock.json
+++ b/wasm/demo/package-lock.json
@@ -21,8 +21,8 @@
                 "css-loader": "^7.1.2",
                 "html-webpack-plugin": "^5.6.3",
                 "mini-css-extract-plugin": "^2.9.2",
-                "serve": "^14.2.5",
-                "webpack": "^5.97.1",
+                "serve": "^14.2.6",
+                "webpack": "^5.105.0",
                 "webpack-cli": "^6.0.1",
                 "webpack-dev-server": "^5.2.1"
             }
@@ -364,9 +364,9 @@
             }
         },
         "node_modules/@types/estree": {
-            "version": "1.0.6",
-            "resolved": "https://registry.npmjs.org/@types/estree/-/estree-1.0.6.tgz",
-            "integrity": "sha512-AYnb1nQyY49te+VRAVgmzfcgjYS91mY5P0TKUDCLEM+gNnA+3T6rWITXRLYCpahpqSQbN5cE+gHpnPyXjHWxcw==",
+            "version": "1.0.8",
+            "resolved": "https://registry.npmjs.org/@types/estree/-/estree-1.0.8.tgz",
+            "integrity": "sha512-dWHzHa2WqEXI/O1E9OjrocMTKJl2mSrEolh1Iomrv6U+JuNwaHXsXx9bLu5gG7BUWFIN0skIQJQ/L1rIex4X6w==",
             "dev": true,
             "license": "MIT"
         },
@@ -813,9 +813,9 @@
             }
         },
         "node_modules/acorn": {
-            "version": "8.14.0",
-            "resolved": "https://registry.npmjs.org/acorn/-/acorn-8.14.0.tgz",
-            "integrity": "sha512-cl669nCJTZBsL97OF4kUQm5g5hC2uihk0NxY3WENAC0TYdILVkAyHymAntgxGkl7K+t0cXIrH5siy5S4XkFycA==",
+            "version": "8.15.0",
+            "resolved": "https://registry.npmjs.org/acorn/-/acorn-8.15.0.tgz",
+            "integrity": "sha512-NZyJarBfL7nWwIq+FDL6Zp/yHEhePMNnnJ0y3qfieCrmNvYct8uvtiV41UvlSe6apAfk0fY1FbWx+NwfmpvtTg==",
             "dev": true,
             "license": "MIT",
             "bin": {
@@ -825,10 +825,23 @@
                 "node": ">=0.4.0"
             }
         },
+        "node_modules/acorn-import-phases": {
+            "version": "1.0.4",
+            "resolved": "https://registry.npmjs.org/acorn-import-phases/-/acorn-import-phases-1.0.4.tgz",
+            "integrity": "sha512-wKmbr/DDiIXzEOiWrTTUcDm24kQ2vGfZQvM2fwg2vXqR5uW6aapr7ObPtj1th32b9u90/Pf4AItvdTh42fBmVQ==",
+            "dev": true,
+            "license": "MIT",
+            "engines": {
+                "node": ">=10.13.0"
+            },
+            "peerDependencies": {
+                "acorn": "^8.14.0"
+            }
+        },
         "node_modules/ajv": {
-            "version": "8.17.1",
-            "resolved": "https://registry.npmjs.org/ajv/-/ajv-8.17.1.tgz",
-            "integrity": "sha512-B/gBuNg5SiMTrPkC+A2+cW0RszwxYmn6VYxB/inlBStS5nx6xHIt/ehKRhIMhqusl7a8LjQoZnjCs5vhwxOQ1g==",
+            "version": "8.18.0",
+            "resolved": "https://registry.npmjs.org/ajv/-/ajv-8.18.0.tgz",
+            "integrity": "sha512-PlXPeEWMXMZ7sPYOHqmDyCJzcfNrUr3fGNKtezX14ykXOEIvyK81d+qydx89KY5O71FKMPaQ2vBfBFI5NHR63A==",
             "dev": true,
             "license": "MIT",
             "dependencies": {
@@ -996,6 +1009,16 @@
             "dev": true,
             "license": "MIT"
         },
+        "node_modules/baseline-browser-mapping": {
+            "version": "2.9.19",
+            "resolved": "https://registry.npmjs.org/baseline-browser-mapping/-/baseline-browser-mapping-2.9.19.tgz",
+            "integrity": "sha512-ipDqC8FrAl/76p2SSWKSI+H9tFwm7vYqXQrItCuiVPt26Km0jS+NzSsBWAaBusvSbQcfJG+JitdMm+wZAgTYqg==",
+            "dev": true,
+            "license": "Apache-2.0",
+            "bin": {
+                "baseline-browser-mapping": "dist/cli.js"
+            }
+        },
         "node_modules/batch": {
             "version": "0.6.1",
             "resolved": "https://registry.npmjs.org/batch/-/batch-0.6.1.tgz",
@@ -1106,9 +1129,9 @@
             }
         },
         "node_modules/brace-expansion": {
-            "version": "1.1.11",
-            "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.11.tgz",
-            "integrity": "sha512-iCuPHDFgrHX7H2vEI/5xpz07zSHB00TpugqhmYtVmMO6518mCuRMoOYFldEBl0g187ufozdaHgWKcYFb61qGiA==",
+            "version": "1.1.13",
+            "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.13.tgz",
+            "integrity": "sha512-9ZLprWS6EENmhEOpjCYW2c8VkmOvckIJZfkr7rBW6dObmfgJ/L1GpSYW5Hpo9lDz4D1+n0Ckz8rU7FwHDQiG/w==",
             "dev": true,
             "license": "MIT",
             "dependencies": {
@@ -1130,9 +1153,9 @@
             }
         },
         "node_modules/browserslist": {
-            "version": "4.24.4",
-            "resolved": "https://registry.npmjs.org/browserslist/-/browserslist-4.24.4.tgz",
-            "integrity": "sha512-KDi1Ny1gSePi1vm0q4oxSF8b4DR44GF4BbmS2YdhPLOEqd8pDviZOGH/GsmRwoWJ2+5Lr085X7naowMwKHDG1A==",
+            "version": "4.28.1",
+            "resolved": "https://registry.npmjs.org/browserslist/-/browserslist-4.28.1.tgz",
+            "integrity": "sha512-ZC5Bd0LgJXgwGqUknZY/vkUQ04r8NXnJZ3yYi4vDmSiZmC/pdSN0NbNRPxZpbtO4uAfDUAFffO8IZoM3Gj8IkA==",
             "dev": true,
             "funding": [
                 {
@@ -1150,10 +1173,11 @@
             ],
             "license": "MIT",
             "dependencies": {
-                "caniuse-lite": "^1.0.30001688",
-                "electron-to-chromium": "^1.5.73",
-                "node-releases": "^2.0.19",
-                "update-browserslist-db": "^1.1.1"
+                "baseline-browser-mapping": "^2.9.0",
+                "caniuse-lite": "^1.0.30001759",
+                "electron-to-chromium": "^1.5.263",
+                "node-releases": "^2.0.27",
+                "update-browserslist-db": "^1.2.0"
             },
             "bin": {
                 "browserslist": "cli.js"
@@ -1251,9 +1275,9 @@
             }
         },
         "node_modules/caniuse-lite": {
-            "version": "1.0.30001701",
-            "resolved": "https://registry.npmjs.org/caniuse-lite/-/caniuse-lite-1.0.30001701.tgz",
-            "integrity": "sha512-faRs/AW3jA9nTwmJBSO1PQ6L/EOgsB5HMQQq4iCu5zhPgVVgO/pZRHlmatwijZKetFw8/Pr4q6dEN8sJuq8qTw==",
+            "version": "1.0.30001768",
+            "resolved": "https://registry.npmjs.org/caniuse-lite/-/caniuse-lite-1.0.30001768.tgz",
+            "integrity": "sha512-qY3aDRZC5nWPgHUgIB84WL+nySuo19wk0VJpp/XI9T34lrvkyhRvNVOFJOp2kxClQhiFBu+TaUSudf6oa3vkSA==",
             "dev": true,
             "funding": [
                 {
@@ -1976,9 +2000,9 @@
             "license": "MIT"
         },
         "node_modules/electron-to-chromium": {
-            "version": "1.5.109",
-            "resolved": "https://registry.npmjs.org/electron-to-chromium/-/electron-to-chromium-1.5.109.tgz",
-            "integrity": "sha512-AidaH9JETVRr9DIPGfp1kAarm/W6hRJTPuCnkF+2MqhF4KaAgRIcBc8nvjk+YMXZhwfISof/7WG29eS4iGxQLQ==",
+            "version": "1.5.286",
+            "resolved": "https://registry.npmjs.org/electron-to-chromium/-/electron-to-chromium-1.5.286.tgz",
+            "integrity": "sha512-9tfDXhJ4RKFNerfjdCcZfufu49vg620741MNs26a9+bhLThdB+plgMeou98CAaHu/WATj2iHOOHTp1hWtABj2A==",
             "dev": true,
             "license": "ISC"
         },
@@ -2000,14 +2024,14 @@
             }
         },
         "node_modules/enhanced-resolve": {
-            "version": "5.18.1",
-            "resolved": "https://registry.npmjs.org/enhanced-resolve/-/enhanced-resolve-5.18.1.tgz",
-            "integrity": "sha512-ZSW3ma5GkcQBIpwZTSRAI8N71Uuwgs93IezB7mf7R60tC8ZbJideoDNKjHn2O9KIlx6rkGTTEk1xUCK2E1Y2Yg==",
+            "version": "5.19.0",
+            "resolved": "https://registry.npmjs.org/enhanced-resolve/-/enhanced-resolve-5.19.0.tgz",
+            "integrity": "sha512-phv3E1Xl4tQOShqSte26C7Fl84EwUdZsyOuSSk9qtAGyyQs2s3jJzComh+Abf4g187lUUAvH+H26omrqia2aGg==",
             "dev": true,
             "license": "MIT",
             "dependencies": {
                 "graceful-fs": "^4.2.4",
-                "tapable": "^2.2.0"
+                "tapable": "^2.3.0"
             },
             "engines": {
                 "node": ">=10.13.0"
@@ -2057,9 +2081,9 @@
             }
         },
         "node_modules/es-module-lexer": {
-            "version": "1.6.0",
-            "resolved": "https://registry.npmjs.org/es-module-lexer/-/es-module-lexer-1.6.0.tgz",
-            "integrity": "sha512-qqnD1yMU6tk/jnaMosogGySTZP8YtUgAffA9nMN+E/rjxcfRQ6IEk7IiozUjgxKoFHBGjTLnrHB/YC45r/59EQ==",
+            "version": "2.0.0",
+            "resolved": "https://registry.npmjs.org/es-module-lexer/-/es-module-lexer-2.0.0.tgz",
+            "integrity": "sha512-5POEcUuZybH7IdmGsD8wlf0AI55wMecM9rVBTI/qEAy2c1kTOm3DjFYjrBdI2K3BaJjJYfYFeRtM0t9ssnRuxw==",
             "dev": true,
             "license": "MIT"
         },
@@ -3215,13 +3239,17 @@
             }
         },
         "node_modules/loader-runner": {
-            "version": "4.3.0",
-            "resolved": "https://registry.npmjs.org/loader-runner/-/loader-runner-4.3.0.tgz",
-            "integrity": "sha512-3R/1M+yS3j5ou80Me59j7F9IMs4PXs3VqRrm0TU3AbKPxlmpoY1TNscJV/oGJXo8qCatFGTfDbY6W6ipGOYXfg==",
+            "version": "4.3.1",
+            "resolved": "https://registry.npmjs.org/loader-runner/-/loader-runner-4.3.1.tgz",
+            "integrity": "sha512-IWqP2SCPhyVFTBtRcgMHdzlf9ul25NwaFx4wCEH/KjAXuuHY4yNjvPXsBokp8jCB936PyWRaPKUNh8NvylLp2Q==",
             "dev": true,
             "license": "MIT",
             "engines": {
                 "node": ">=6.11.5"
+            },
+            "funding": {
+                "type": "opencollective",
+                "url": "https://opencollective.com/webpack"
             }
         },
         "node_modules/locate-path": {
@@ -3238,9 +3266,9 @@
             }
         },
         "node_modules/lodash": {
-            "version": "4.17.23",
-            "resolved": "https://registry.npmjs.org/lodash/-/lodash-4.17.23.tgz",
-            "integrity": "sha512-LgVTMpQtIopCi79SJeDiP0TfWi5CNEc/L/aRdTh3yIvmZXTnheWpKjSZhnvMl8iXbC1tFg9gdHHDMLoV7CnG+w==",
+            "version": "4.18.1",
+            "resolved": "https://registry.npmjs.org/lodash/-/lodash-4.18.1.tgz",
+            "integrity": "sha512-dMInicTPVE8d1e5otfwmmjlxkZoUpiVLwyeTdUsi/Caj/gfzzblBcCE5sRHV/AsjuCmxWrte2TNGSYuCeCq+0Q==",
             "dev": true,
             "license": "MIT"
         },
@@ -3420,9 +3448,9 @@
             "license": "ISC"
         },
         "node_modules/minimatch": {
-            "version": "3.1.2",
-            "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.1.2.tgz",
-            "integrity": "sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw==",
+            "version": "3.1.5",
+            "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.1.5.tgz",
+            "integrity": "sha512-VgjWUsnnT6n+NUk6eZq77zeFdpW2LWDzP6zFGrCbHXiYNul5Dzqk2HHQ5uFH2DNW5Xbp8+jVzaeNt94ssEEl4w==",
             "dev": true,
             "license": "ISC",
             "dependencies": {
@@ -3511,9 +3539,9 @@
             }
         },
         "node_modules/node-forge": {
-            "version": "1.3.2",
-            "resolved": "https://registry.npmjs.org/node-forge/-/node-forge-1.3.2.tgz",
-            "integrity": "sha512-6xKiQ+cph9KImrRh0VsjH2d8/GXA4FIMlgU4B757iI1ApvcyA9VlouP0yZJha01V+huImO+kKMU7ih+2+E14fw==",
+            "version": "1.4.0",
+            "resolved": "https://registry.npmjs.org/node-forge/-/node-forge-1.4.0.tgz",
+            "integrity": "sha512-LarFH0+6VfriEhqMMcLX2F7SwSXeWwnEAJEsYm5QKWchiVYVvJyV9v7UDvUv+w5HO23ZpQTXDv/GxdDdMyOuoQ==",
             "dev": true,
             "license": "(BSD-3-Clause OR GPL-2.0)",
             "engines": {
@@ -3521,9 +3549,9 @@
             }
         },
         "node_modules/node-releases": {
-            "version": "2.0.19",
-            "resolved": "https://registry.npmjs.org/node-releases/-/node-releases-2.0.19.tgz",
-            "integrity": "sha512-xxOWJsBKtzAq7DY0J+DTzuz58K8e7sJbdgwkbMWQe8UYB6ekmsQ45q0M/tJDsGaZmbC+l7n57UV8Hl5tHxO9uw==",
+            "version": "2.0.27",
+            "resolved": "https://registry.npmjs.org/node-releases/-/node-releases-2.0.27.tgz",
+            "integrity": "sha512-nmh3lCkYZ3grZvqcCH+fjmQ7X+H0OeZgP40OierEaAptX4XofMh5kwNbWh7lBduUzCcV/8kZ+NDLCwm2iorIlA==",
             "dev": true,
             "license": "MIT"
         },
@@ -3795,9 +3823,9 @@
             "license": "ISC"
         },
         "node_modules/picomatch": {
-            "version": "2.3.1",
-            "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-2.3.1.tgz",
-            "integrity": "sha512-JU3teHTNjmE2VCGFzuY8EXzCDVwEqB2a8fsIvwaStHhAWJEeVd1o1QD80CU6+ZdEXXSLbSsuLwJjkCBWqRQUVA==",
+            "version": "2.3.2",
+            "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-2.3.2.tgz",
+            "integrity": "sha512-V7+vQEJ06Z+c5tSye8S+nHUfI51xoXIXjHQ99cQtKUkQqqO1kO/KCJUfZXuB47h/YBlDhah2H3hdUGXn8ie0oA==",
             "dev": true,
             "license": "MIT",
             "engines": {
@@ -3975,16 +4003,6 @@
                 "node": ">= 0.10"
             }
         },
-        "node_modules/punycode": {
-            "version": "2.3.1",
-            "resolved": "https://registry.npmjs.org/punycode/-/punycode-2.3.1.tgz",
-            "integrity": "sha512-vYt7UD1U9Wg6138shLtLOvdAu+8DsC/ilFtEVHcH+wydcSpNE20AfSOduf6MkRFahL5FY7X1oU7nKVZFtfq8Fg==",
-            "dev": true,
-            "license": "MIT",
-            "engines": {
-                "node": ">=6"
-            }
-        },
         "node_modules/qs": {
             "version": "6.13.0",
             "resolved": "https://registry.npmjs.org/qs/-/qs-6.13.0.tgz",
@@ -4001,16 +4019,6 @@
                 "url": "https://github.com/sponsors/ljharb"
             }
         },
-        "node_modules/randombytes": {
-            "version": "2.1.0",
-            "resolved": "https://registry.npmjs.org/randombytes/-/randombytes-2.1.0.tgz",
-            "integrity": "sha512-vYl3iOX+4CKUWuxGi9Ukhie6fsqXqS9FE2Zaic4tNFD2N2QQaXOMFbuKK4QmDHC0JO6B1Zp41J0LpT0oR68amQ==",
-            "dev": true,
-            "license": "MIT",
-            "dependencies": {
-                "safe-buffer": "^5.1.0"
-            }
-        },
         "node_modules/range-parser": {
             "version": "1.2.0",
             "resolved": "https://registry.npmjs.org/range-parser/-/range-parser-1.2.0.tgz",
@@ -4251,9 +4259,9 @@
             "license": "MIT"
         },
         "node_modules/schema-utils": {
-            "version": "4.3.0",
-            "resolved": "https://registry.npmjs.org/schema-utils/-/schema-utils-4.3.0.tgz",
-            "integrity": "sha512-Gf9qqc58SpCA/xdziiHz35F4GNIWYWZrEshUc/G/r5BnLph6xpKuLeoJoQuj5WfBIx/eQLf+hmVPYHaxJu7V2g==",
+            "version": "4.3.3",
+            "resolved": "https://registry.npmjs.org/schema-utils/-/schema-utils-4.3.3.tgz",
+            "integrity": "sha512-eflK8wEtyOE6+hsaRVPxvUKYCpRgzLqDTb8krvAsRIwOGlHoSgYLgBXoubGgLd2fT41/OUYdb48v4k4WWHQurA==",
             "dev": true,
             "license": "MIT",
             "dependencies": {
@@ -4356,25 +4364,15 @@
                 "node": ">= 0.6"
             }
         },
-        "node_modules/serialize-javascript": {
-            "version": "6.0.2",
-            "resolved": "https://registry.npmjs.org/serialize-javascript/-/serialize-javascript-6.0.2.tgz",
-            "integrity": "sha512-Saa1xPByTTq2gdeFZYLLo+RFE35NHZkAbqZeWNd3BpzppeVisAqpDjcp8dyf6uIvEqJRd46jemmyA4iFIeVk8g==",
-            "dev": true,
-            "license": "BSD-3-Clause",
-            "dependencies": {
-                "randombytes": "^2.1.0"
-            }
-        },
         "node_modules/serve": {
-            "version": "14.2.5",
-            "resolved": "https://registry.npmjs.org/serve/-/serve-14.2.5.tgz",
-            "integrity": "sha512-Qn/qMkzCcMFVPb60E/hQy+iRLpiU8PamOfOSYoAHmmF+fFFmpPpqa6Oci2iWYpTdOUM3VF+TINud7CfbQnsZbA==",
+            "version": "14.2.6",
+            "resolved": "https://registry.npmjs.org/serve/-/serve-14.2.6.tgz",
+            "integrity": "sha512-QEjUSA+sD4Rotm1znR8s50YqA3kYpRGPmtd5GlFxbaL9n/FdUNbqMhxClqdditSk0LlZyA/dhud6XNRTOC9x2Q==",
             "dev": true,
             "license": "MIT",
             "dependencies": {
                 "@zeit/schemas": "2.36.0",
-                "ajv": "8.12.0",
+                "ajv": "8.18.0",
                 "arg": "5.0.2",
                 "boxen": "7.0.0",
                 "chalk": "5.0.1",
@@ -4382,7 +4380,7 @@
                 "clipboardy": "3.0.0",
                 "compression": "1.8.1",
                 "is-port-reachable": "4.0.0",
-                "serve-handler": "6.1.6",
+                "serve-handler": "6.1.7",
                 "update-check": "1.5.4"
             },
             "bin": {
@@ -4393,16 +4391,16 @@
             }
         },
         "node_modules/serve-handler": {
-            "version": "6.1.6",
-            "resolved": "https://registry.npmjs.org/serve-handler/-/serve-handler-6.1.6.tgz",
-            "integrity": "sha512-x5RL9Y2p5+Sh3D38Fh9i/iQ5ZK+e4xuXRd/pGbM4D13tgo/MGwbttUk8emytcr1YYzBYs+apnUngBDFYfpjPuQ==",
+            "version": "6.1.7",
+            "resolved": "https://registry.npmjs.org/serve-handler/-/serve-handler-6.1.7.tgz",
+            "integrity": "sha512-CinAq1xWb0vR3twAv9evEU8cNWkXCb9kd5ePAHUKJBkOsUpR1wt/CvGdeca7vqumL1U5cSaeVQ6zZMxiJ3yWsg==",
             "dev": true,
             "license": "MIT",
             "dependencies": {
                 "bytes": "3.0.0",
                 "content-disposition": "0.5.2",
                 "mime-types": "2.1.18",
-                "minimatch": "3.1.2",
+                "minimatch": "3.1.5",
                 "path-is-inside": "1.0.2",
                 "path-to-regexp": "3.3.0",
                 "range-parser": "1.2.0"
@@ -4516,23 +4514,6 @@
                 "node": ">= 0.8.0"
             }
         },
-        "node_modules/serve/node_modules/ajv": {
-            "version": "8.12.0",
-            "resolved": "https://registry.npmjs.org/ajv/-/ajv-8.12.0.tgz",
-            "integrity": "sha512-sRu1kpcO9yLtYxBKvqfTeh9KzZEwO3STyX1HT+4CaDzC6HpTGYhIhPIzj9XuKU7KYDwnaeh5hcOwjy1QuJzBPA==",
-            "dev": true,
-            "license": "MIT",
-            "dependencies": {
-                "fast-deep-equal": "^3.1.1",
-                "json-schema-traverse": "^1.0.0",
-                "require-from-string": "^2.0.2",
-                "uri-js": "^4.2.2"
-            },
-            "funding": {
-                "type": "github",
-                "url": "https://github.com/sponsors/epoberezkin"
-            }
-        },
         "node_modules/serve/node_modules/chalk": {
             "version": "5.0.1",
             "resolved": "https://registry.npmjs.org/chalk/-/chalk-5.0.1.tgz",
@@ -4963,13 +4944,17 @@
             }
         },
         "node_modules/tapable": {
-            "version": "2.2.1",
-            "resolved": "https://registry.npmjs.org/tapable/-/tapable-2.2.1.tgz",
-            "integrity": "sha512-GNzQvQTOIP6RyTfE2Qxb8ZVlNmw0n88vp1szwWRimP02mnTsx3Wtn5qRdqY9w2XduFNUgvOwhNnQsjwCp+kqaQ==",
+            "version": "2.3.0",
+            "resolved": "https://registry.npmjs.org/tapable/-/tapable-2.3.0.tgz",
+            "integrity": "sha512-g9ljZiwki/LfxmQADO3dEY1CbpmXT5Hm2fJ+QaGKwSXUylMybePR7/67YW7jOrrvjEgL1Fmz5kzyAjWVWLlucg==",
             "dev": true,
             "license": "MIT",
             "engines": {
                 "node": ">=6"
+            },
+            "funding": {
+                "type": "opencollective",
+                "url": "https://opencollective.com/webpack"
             }
         },
         "node_modules/terser": {
@@ -4992,16 +4977,15 @@
             }
         },
         "node_modules/terser-webpack-plugin": {
-            "version": "5.3.12",
-            "resolved": "https://registry.npmjs.org/terser-webpack-plugin/-/terser-webpack-plugin-5.3.12.tgz",
-            "integrity": "sha512-jDLYqo7oF8tJIttjXO6jBY5Hk8p3A8W4ttih7cCEq64fQFWmgJ4VqAQjKr7WwIDlmXKEc6QeoRb5ecjZ+2afcg==",
+            "version": "5.4.0",
+            "resolved": "https://registry.npmjs.org/terser-webpack-plugin/-/terser-webpack-plugin-5.4.0.tgz",
+            "integrity": "sha512-Bn5vxm48flOIfkdl5CaD2+1CiUVbonWQ3KQPyP7/EuIl9Gbzq/gQFOzaMFUEgVjB1396tcK0SG8XcNJ/2kDH8g==",
             "dev": true,
             "license": "MIT",
             "dependencies": {
                 "@jridgewell/trace-mapping": "^0.3.25",
                 "jest-worker": "^27.4.5",
                 "schema-utils": "^4.3.0",
-                "serialize-javascript": "^6.0.2",
                 "terser": "^5.31.1"
             },
             "engines": {
@@ -5145,9 +5129,9 @@
             }
         },
         "node_modules/update-browserslist-db": {
-            "version": "1.1.3",
-            "resolved": "https://registry.npmjs.org/update-browserslist-db/-/update-browserslist-db-1.1.3.tgz",
-            "integrity": "sha512-UxhIZQ+QInVdunkDAaiazvvT/+fXL5Osr0JZlJulepYu6Jd7qJtDZjlur0emRlT71EN3ScPoE7gvsuIKKNavKw==",
+            "version": "1.2.3",
+            "resolved": "https://registry.npmjs.org/update-browserslist-db/-/update-browserslist-db-1.2.3.tgz",
+            "integrity": "sha512-Js0m9cx+qOgDxo0eMiFGEueWztz+d4+M3rGlmKPT+T4IS/jP4ylw3Nwpu6cpTTP8R1MAC1kF4VbdLt3ARf209w==",
             "dev": true,
             "funding": [
                 {
@@ -5192,16 +5176,6 @@
             "integrity": "sha512-NtkVvqVCqsJo5U3mYRum2Tw6uCltOxfIJ/AfTZeTmw6U39IB5X23xF+kRZ9aiPaORqeiQQ7Q209/ibhOvxzwHA==",
             "license": "MIT"
         },
-        "node_modules/uri-js": {
-            "version": "4.4.1",
-            "resolved": "https://registry.npmjs.org/uri-js/-/uri-js-4.4.1.tgz",
-            "integrity": "sha512-7rKUyy33Q1yc98pQ1DAmLtwX109F7TIfWlW1Ydo8Wl1ii1SeHieeh0HHfPeL2fMXK6z0s8ecKs9frCuLJvndBg==",
-            "dev": true,
-            "license": "BSD-2-Clause",
-            "dependencies": {
-                "punycode": "^2.1.0"
-            }
-        },
         "node_modules/util-deprecate": {
             "version": "1.0.2",
             "resolved": "https://registry.npmjs.org/util-deprecate/-/util-deprecate-1.0.2.tgz",
@@ -5253,9 +5227,9 @@
             "license": "MIT"
         },
         "node_modules/watchpack": {
-            "version": "2.4.2",
-            "resolved": "https://registry.npmjs.org/watchpack/-/watchpack-2.4.2.tgz",
-            "integrity": "sha512-TnbFSbcOCcDgjZ4piURLCbJ3nJhznVh9kw6F6iokjiFPl8ONxe9A6nMDVXDiNbrSfLILs6vB07F7wLBrwPYzJw==",
+            "version": "2.5.1",
+            "resolved": "https://registry.npmjs.org/watchpack/-/watchpack-2.5.1.tgz",
+            "integrity": "sha512-Zn5uXdcFNIA1+1Ei5McRd+iRzfhENPCe7LeABkJtNulSxjma+l7ltNx55BWZkRlwRnpOgHqxnjyaDgJnNXnqzg==",
             "dev": true,
             "license": "MIT",
             "dependencies": {
@@ -5277,35 +5251,37 @@
             }
         },
         "node_modules/webpack": {
-            "version": "5.98.0",
-            "resolved": "https://registry.npmjs.org/webpack/-/webpack-5.98.0.tgz",
-            "integrity": "sha512-UFynvx+gM44Gv9qFgj0acCQK2VE1CtdfwFdimkapco3hlPCJ/zeq73n2yVKimVbtm+TnApIugGhLJnkU6gjYXA==",
+            "version": "5.105.0",
+            "resolved": "https://registry.npmjs.org/webpack/-/webpack-5.105.0.tgz",
+            "integrity": "sha512-gX/dMkRQc7QOMzgTe6KsYFM7DxeIONQSui1s0n/0xht36HvrgbxtM1xBlgx596NbpHuQU8P7QpKwrZYwUX48nw==",
             "dev": true,
             "license": "MIT",
             "dependencies": {
                 "@types/eslint-scope": "^3.7.7",
-                "@types/estree": "^1.0.6",
+                "@types/estree": "^1.0.8",
+                "@types/json-schema": "^7.0.15",
                 "@webassemblyjs/ast": "^1.14.1",
                 "@webassemblyjs/wasm-edit": "^1.14.1",
                 "@webassemblyjs/wasm-parser": "^1.14.1",
-                "acorn": "^8.14.0",
-                "browserslist": "^4.24.0",
+                "acorn": "^8.15.0",
+                "acorn-import-phases": "^1.0.3",
+                "browserslist": "^4.28.1",
                 "chrome-trace-event": "^1.0.2",
-                "enhanced-resolve": "^5.17.1",
-                "es-module-lexer": "^1.2.1",
+                "enhanced-resolve": "^5.19.0",
+                "es-module-lexer": "^2.0.0",
                 "eslint-scope": "5.1.1",
                 "events": "^3.2.0",
                 "glob-to-regexp": "^0.4.1",
                 "graceful-fs": "^4.2.11",
                 "json-parse-even-better-errors": "^2.3.1",
-                "loader-runner": "^4.2.0",
+                "loader-runner": "^4.3.1",
                 "mime-types": "^2.1.27",
                 "neo-async": "^2.6.2",
-                "schema-utils": "^4.3.0",
-                "tapable": "^2.1.1",
-                "terser-webpack-plugin": "^5.3.11",
-                "watchpack": "^2.4.1",
-                "webpack-sources": "^3.2.3"
+                "schema-utils": "^4.3.3",
+                "tapable": "^2.3.0",
+                "terser-webpack-plugin": "^5.3.16",
+                "watchpack": "^2.5.1",
+                "webpack-sources": "^3.3.3"
             },
             "bin": {
                 "webpack": "bin/webpack.js"
@@ -5503,9 +5479,9 @@
             }
         },
         "node_modules/webpack-sources": {
-            "version": "3.2.3",
-            "resolved": "https://registry.npmjs.org/webpack-sources/-/webpack-sources-3.2.3.tgz",
-            "integrity": "sha512-/DyMEOrDgLKKIG0fmvtz+4dUX/3Ghozwgm6iPp8KRhvn+eQf9+Q7GWxVNMk3+uCPWfdXYC4ExGBckIXdFEfH1w==",
+            "version": "3.3.3",
+            "resolved": "https://registry.npmjs.org/webpack-sources/-/webpack-sources-3.3.3.tgz",
+            "integrity": "sha512-yd1RBzSGanHkitROoPFd6qsrxt+oFhg/129YzheDGqeustzX0vTZJZsSsQjVQC4yzBQ56K55XU8gaNCtIzOnTg==",
             "dev": true,
             "license": "MIT",
             "engines": {
diff --git a/wasm/demo/package.json b/wasm/demo/package.json
index 2c08e5c416f..a815b90c70b 100644
--- a/wasm/demo/package.json
+++ b/wasm/demo/package.json
@@ -16,8 +16,8 @@
         "css-loader": "^7.1.2",
         "html-webpack-plugin": "^5.6.3",
         "mini-css-extract-plugin": "^2.9.2",
-        "serve": "^14.2.5",
-        "webpack": "^5.97.1",
+        "serve": "^14.2.6",
+        "webpack": "^5.105.0",
         "webpack-cli": "^6.0.1",
         "webpack-dev-server": "^5.2.1"
     },
diff --git a/wasm/example/package.json b/wasm/example/package.json
index f6128263017..40b70e0b75d 100644
--- a/wasm/example/package.json
+++ b/wasm/example/package.json
@@ -6,7 +6,7 @@
     },
     "devDependencies": {
         "raw-loader": "1.0.0",
-        "webpack": "5.94.0",
+        "webpack": "5.104.1",
         "webpack-cli": "^3.1.2"
     },
     "scripts": {